[ { "path": ".formatter.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\n[\n inputs: [\n \"lib/*/{lib,scripts,unicode,test}/**/*.{ex,exs}\",\n \"lib/*/*.exs\",\n \"lib/ex_unit/examples/*.exs\",\n \".formatter.exs\"\n ],\n locals_without_parens: [\n # Formatter tests\n assert_format: 2,\n assert_format: 3,\n assert_same: 1,\n assert_same: 2,\n\n # Errors tests\n assert_eval_raise: 3,\n\n # Float tests\n float_assert: 1\n ]\n]\n" }, { "path": ".gitattributes", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nlib/elixir/test/elixir/fixtures/*.txt text eol=lf\n*.ex diff=elixir\n*.exs diff=elixir\n" }, { "path": ".github/ISSUE_TEMPLATE/config.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\n---\nblank_issues_enabled: true\n\ncontact_links:\n - name: Ask questions, support, and general discussions\n url: https://elixirforum.com/\n about: Ask questions, provide support, and more on Elixir Forum\n\n - name: Propose new features\n url: https://github.com/elixir-lang/elixir/#proposing-new-features\n about: Propose new features in our mailing list\n" }, { "path": ".github/ISSUE_TEMPLATE/issue.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\n---\nname: Report an issue\ndescription:\n Tell us about something that is not working the way we (probably) intend\nbody:\n - type: markdown\n attributes:\n value: >\n Thank you for contributing to Elixir! :heart:\n\n\n Please, do not use this form for guidance, questions or support.\n Try instead in [Elixir Forum](https://elixirforum.com),\n the [IRC Chat](https://web.libera.chat/#elixir),\n [Stack Overflow](https://stackoverflow.com/questions/tagged/elixir),\n [Slack](https://elixir-slackin.herokuapp.com),\n [Discord](https://discord.gg/elixir) or in other online communities.\n\n - type: textarea\n id: elixir-and-otp-version\n attributes:\n label: Elixir and Erlang/OTP versions\n description: Paste the output of `elixir --version` here.\n validations:\n required: true\n\n - type: input\n id: os\n attributes:\n label: Operating system\n description: The operating system that this issue is happening on.\n validations:\n required: true\n\n - type: textarea\n id: current-behavior\n attributes:\n label: Current behavior\n description: >\n Include code samples, errors, and stacktraces if appropriate.\n\n\n If reporting a bug, please include the reproducing steps.\n validations:\n required: true\n\n - type: textarea\n id: expected-behavior\n attributes:\n label: Expected behavior\n description: A short description on how you expect the code to behave.\n validations:\n required: true\n" }, { "path": ".github/dependabot.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nversion: 2\nupdates:\n - package-ecosystem: \"github-actions\"\n directory: \"/\"\n schedule:\n interval: \"weekly\"\n cooldown:\n default-days: 7\n" }, { "path": ".github/workflows/ci.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nname: CI\n\non:\n push:\n pull_request:\n workflow_dispatch:\n\nenv:\n ELIXIR_ASSERT_TIMEOUT: 2000\n ELIXIRC_OPTS: \"--warnings-as-errors\"\n LANG: C.UTF-8\n\npermissions:\n contents: read\n\njobs:\n test_linux:\n name: Ubuntu 24.04, OTP ${{ matrix.otp_version }}${{ matrix.deterministic && ' (deterministic)' || '' }}${{ matrix.coverage && ' (coverage)' || '' }}\n runs-on: ubuntu-24.04\n\n strategy:\n fail-fast: false\n matrix:\n include:\n - otp_version: \"29.0-rc1\"\n - otp_version: \"28.1\"\n deterministic: true\n - otp_version: \"28.1\"\n docs: true\n coverage: true\n - otp_version: \"27.3\"\n - otp_version: \"27.0\"\n - otp_version: master\n development: true\n - otp_version: maint\n development: true\n\n env:\n ERLC_OPTS: \"warnings_as_errors\"\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - uses: erlef/setup-beam@e6d7c94229049569db56a7ad5a540c051a010af9 # v1.20.4\n with:\n otp-version: ${{ matrix.otp_version }}\n\n - name: Set ERL_COMPILER_OPTIONS\n if: ${{ matrix.deterministic }}\n run: echo \"ERL_COMPILER_OPTIONS=deterministic\" >> $GITHUB_ENV\n\n - name: Compile Elixir\n run: |\n make compile\n echo \"$PWD/bin\" >> $GITHUB_PATH\n\n - name: Build info\n run: bin/elixir --version\n\n - name: Check format\n run: make test_formatted && echo \"All Elixir source code files are properly formatted.\"\n\n - name: Erlang test suite\n run: make test_erlang\n continue-on-error: ${{ matrix.development == true }}\n\n - name: Elixir test suite\n run: make test_elixir\n continue-on-error: ${{ matrix.development == true }}\n env:\n COVER: \"${{ matrix.coverage }}\"\n\n - name: Build docs (ExDoc main)\n if: ${{ matrix.docs }}\n run: |\n cd ..\n git clone https://github.com/elixir-lang/ex_doc.git --depth 1\n cd ex_doc\n ../elixir/bin/mix do local.rebar --force + local.hex --force + deps.get + compile\n cd ../elixir/\n git fetch --tags\n DOCS_OPTIONS=\"--warnings-as-errors\" make docs\n\n - name: \"Calculate Coverage\"\n if: ${{ matrix.coverage }}\n run: make cover | tee \"$GITHUB_STEP_SUMMARY\"\n\n - name: \"Upload Coverage Artifact\"\n if: ${{ matrix.coverage }}\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0\n with:\n name: TestCoverage\n path: cover/*\n\n - name: Check reproducible builds\n if: ${{ matrix.deterministic }}\n run: taskset 1 make check_reproducible\n\n - name: Check git is not required\n if: ${{ matrix.deterministic }}\n run: |\n rm -rf .git\n cd lib/elixir\n elixirc --ignore-module-conflict -o ebin \"lib/**/*.ex\"\n\n test_windows:\n name: Windows Server 2022, OTP ${{ matrix.otp_version }}\n runs-on: windows-2022\n\n strategy:\n matrix:\n otp_version:\n - \"29.0-rc1\"\n - \"28.1\"\n - \"27.3\"\n\n steps:\n - name: Configure Git\n run: git config --global core.autocrlf input\n\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - uses: erlef/setup-beam@e6d7c94229049569db56a7ad5a540c051a010af9 # v1.20.4\n with:\n otp-version: ${{ matrix.otp_version }}\n\n - name: Compile Elixir\n run: |\n Remove-Item -Recurse -Force '.git'\n make compile\n\n - name: Build info\n run: bin/elixir --version\n\n - name: Check format\n run: make test_formatted && echo \"All Elixir source code files are properly formatted.\"\n\n - name: Erlang test suite\n run: make test_erlang\n\n - name: Elixir test suite\n run: |\n Remove-Item 'c:/Windows/System32/drivers/etc/hosts'\n make test_elixir\n" }, { "path": ".github/workflows/codeql.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2026 The Elixir Team\n\nname: \"CodeQL Advanced\"\n\non:\n push:\n branches: [\"main\"]\n pull_request:\n branches: [\"main\"]\n schedule:\n - cron: \"29 8 * * 1\"\n\npermissions:\n contents: read\n\njobs:\n analyze:\n name: Analyze (${{ matrix.language }})\n runs-on: \"ubuntu-latest\"\n permissions:\n security-events: write\n strategy:\n fail-fast: false\n matrix:\n include:\n - language: actions\n build-mode: none\n steps:\n - name: Checkout repository\n uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n - name: Initialize CodeQL\n uses: github/codeql-action/init@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4\n with:\n languages: ${{ matrix.language }}\n build-mode: ${{ matrix.build-mode }}\n - name: Perform CodeQL Analysis\n uses: github/codeql-action/analyze@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4\n with:\n category: \"/language:${{matrix.language}}\"\n\n zizmor:\n name: Zizmor\n runs-on: ubuntu-latest\n permissions:\n security-events: write\n steps:\n - name: Checkout repository\n uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n - name: Run zizmor\n uses: zizmorcore/zizmor-action@0dce2577a4760a2749d8cfb7a84b7d5585ebcb7d # v0.5.0\n" }, { "path": ".github/workflows/license_compliance.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nname: License Compliance\n\non:\n push:\n pull_request:\n workflow_dispatch:\n\npermissions:\n contents: read\n\nenv:\n LANG: C.UTF-8\n\njobs:\n license_compliance:\n name: Check License Compliance\n runs-on: ubuntu-24.04\n\n steps:\n - name: Use HTTPS instead of SSH for Git cloning\n id: git-config\n shell: bash\n run: git config --global url.https://github.com/.insteadOf ssh://git@github.com/\n\n - name: Checkout project\n id: checkout\n uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - name: Run OSS Review Toolkit\n id: ort\n uses: ./.github/workflows/ort\n with:\n upload-reports: true\n fail-on-violation: true\n report-formats: \"WebApp\"\n version: \"${{ github.sha }}\"\n" }, { "path": ".github/workflows/markdown.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nname: Markdown Content\n\non:\n push:\n branches:\n - \"main\"\n\n paths: &paths-filter\n - \"**/*.md\"\n - .github/workflows/markdown.yml\n - .markdownlint-cli2.jsonc\n\n pull_request:\n paths: *paths-filter\n\n workflow_dispatch:\n\npermissions:\n contents: read\n\nenv:\n LANG: C.UTF-8\n\njobs:\n lint:\n name: Lint Markdown content\n runs-on: ubuntu-latest\n\n strategy:\n fail-fast: false\n\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - name: Run markdownlint-cli2\n uses: DavidAnson/markdownlint-cli2-action@07035fd053f7be764496c0f8d8f9f41f98305101 # v22.0.0\n" }, { "path": ".github/workflows/notify.exs", "content": "# #!/usr/bin/env elixir\n\n# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\n[tag] = System.argv()\n\nMix.install([\n {:req, \"~> 0.2.1\"},\n {:jason, \"~> 1.0\"}\n])\n\n%{status: 200, body: release} =\n Req.get!(\"https://api.github.com/repos/elixir-lang/elixir/releases/tags/#{tag}\")\n\nif release[\"draft\"] do\n raise \"cannot notify a draft release\"\nend\n\n## Notify on elixir-lang-ann\n\nnames_and_checksums =\n for asset <- release[\"assets\"],\n name = asset[\"name\"],\n name =~ ~r/.sha\\d+sum$/,\n do: {name, Req.get!(asset[\"browser_download_url\"]).body}\n\nline_items =\n for {name, checksum_and_name} <- Enum.sort(names_and_checksums) do\n [checksum | _] = String.split(checksum_and_name, \" \")\n root = Path.rootname(name)\n \".\" <> type = Path.extname(name)\n \" * #{root} - #{type} - #{checksum}\\n\"\n end\n\nbody = \"https://github.com/elixir-lang/elixir/releases/tag/#{tag}\\n\\n#{line_items}\"\n\nIO.puts([\n \"========================================\\n\",\n body,\n \"\\n========================================\"\n])\n\nmail = %{\n # The email must have access to post\n \"From\" => \"jose.valim@dashbit.co\",\n \"To\" => \"elixir-lang-ann@googlegroups.com\",\n \"Subject\" => \"Elixir #{tag} released\",\n \"HtmlBody\" => body,\n \"MessageStream\" => \"outbound\"\n}\n\nunless System.get_env(\"DRYRUN\") do\n headers = %{\n \"X-Postmark-Server-Token\" => System.fetch_env!(\"ELIXIR_LANG_ANN_TOKEN\")\n }\n\n resp = Req.post!(\"https://api.postmarkapp.com/email\", {:json, mail}, headers: headers)\n IO.puts(\"#{resp.status} elixir-lang-ann\\n#{inspect(resp.body)}\")\nend\n\n## Notify on Elixir Forum\n\npost = %{\n \"title\" => \"Elixir #{tag} released\",\n \"raw\" => \"https://github.com/elixir-lang/elixir/releases/tag/#{tag}\\n\\n#{release[\"body\"]}\",\n # Elixir News\n \"category\" => 28\n}\n\nunless System.get_env(\"DRYRUN\") do\n headers = %{\n \"api-key\" => System.fetch_env!(\"ELIXIR_FORUM_TOKEN\"),\n \"api-username\" => \"Elixir\"\n }\n\n resp = Req.post!(\"https://elixirforum.com/posts.json\", {:json, post}, headers: headers)\n IO.puts(\"#{resp.status} Elixir Forum\\n#{inspect(resp.body)}\")\nend\n" }, { "path": ".github/workflows/ort/action.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nname: \"Run OSS Review Toolkit\"\ndescription: \"Runs OSS Review Toolkit & generates SBoMs\"\ninputs:\n report-formats:\n description: \"ORT Report Formats\"\n required: true\n fail-on-violation:\n description: \"Whether to fail on violation.\"\n required: false\n default: false\n upload-reports:\n description: \"Whether to upload all reports\"\n required: false\n default: false\n version:\n description: \"Elixir Version (Tag / SHA)\"\n required: true\n\noutputs:\n results-path:\n description: \"See oss-review-toolkit/ort-ci-github-action action\"\n value: \"${{ steps.ort.outputs.results-path }}\"\n results-sbom-cyclonedx-xml-path:\n description: \"See oss-review-toolkit/ort-ci-github-action action\"\n value: \"${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}\"\n results-sbom-cyclonedx-json-path:\n description: \"See oss-review-toolkit/ort-ci-github-action action\"\n value: \"${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}\"\n results-sbom-spdx-yml-path:\n description: \"See oss-review-toolkit/ort-ci-github-action action\"\n value: \"${{ steps.ort.outputs.results-sbom-spdx-yml-path }}\"\n results-sbom-spdx-json-path:\n description: \"See oss-review-toolkit/ort-ci-github-action action\"\n value: \"${{ steps.ort.outputs.results-sbom-spdx-json-path }}\"\n\nruns:\n using: \"composite\"\n steps:\n - name: Fetch Default ORT Config\n id: fetch-default-ort-config\n uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2\n with:\n repository: oss-review-toolkit/ort-config\n ref: \"main\"\n path: \".ort-config\"\n persist-credentials: false\n\n - name: Setup ORT Config\n id: setup-ort-config\n shell: bash\n run: |\n mkdir -p \"/$HOME/.ort/\"\n\n # Move Fetched Default Config into Place\n mv .ort-config \"$HOME/.ort/config\"\n \n # Append Global ORT Config\n cat .ort/config/config.yml >> \"$HOME/.ort/config/config.yml\"\n \n # Override Default Evaluator Rules\n cp .ort/config/evaluator.rules.kts \"$HOME/.ort/config/evaluator.rules.kts\"\n\n # Add Package Configurations\n mkdir -p \"$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team\"\n for FILE in .ort/package-configurations/*.yml; do\n COMPONENT=\"$(basename \"$FILE\")\"\n cp \"$FILE\" \"$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team/$COMPONENT\"\n sed -i -E \\\n \"s/(\\\"SpdxDocumentFile:The Elixir Team:.+:)\\\"/\\1${ELIXIR_VERSION}\\\"/\" \\\n \"$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team/$COMPONENT\"\n done\n\n # Set Version in SPDX & Config\n sed -i \"s/# elixir-version-insert/versionInfo: '${ELIXIR_VERSION}'/\" project.spdx.yml\n sed -i -E \"s/(\\\"SpdxDocumentFile:The Elixir Team:.+:)\\\"/\\1${ELIXIR_VERSION}\\\"/\" .ort.yml\n sed -i \"s|https://github.com/elixir-lang/elixir.git|${ELIXIR_REPO}@${ELIXIR_VERSION}|\" project.spdx.yml\n env:\n ELIXIR_VERSION: \"${{ inputs.version }}\"\n ELIXIR_REPO: \"${{ github.server_url }}/${{ github.repository }}.git\"\n\n - name: \"Cache ScanCode\"\n uses: actions/cache@d4323d4df104b026a6aa633fdb11d772146be0bf # v4.2.2\n with:\n path: \"~/.cache/scancode-tk\"\n key: ${{ runner.os }}-scancode\n\n - name: Run OSS Review Toolkit\n id: ort\n uses: oss-review-toolkit/ort-ci-github-action@1805edcf1f4f55f35ae6e4d2d9795ccfb29b6021 # v1.1.0\n with:\n image: ghcr.io/oss-review-toolkit/ort-minimal:65.0.0\n run: >-\n labels,\n cache-dependencies,\n cache-scan-results,\n analyzer,\n scanner,\n advisor,\n evaluator,\n reporter,\n ${{ inputs.upload-reports == 'true' && 'upload-results' || '' }}\n fail-on: \"${{ inputs.fail-on-violation == 'true' && 'violations,issues' || '' }}\"\n report-formats: \"${{ inputs.report-formats }}\"\n ort-cli-report-args: >-\n -O CycloneDX=output.file.formats=json,xml\n -O SpdxDocument=outputFileFormats=JSON,YAML\n sw-version: \"${{ inputs.version }}\"\n" }, { "path": ".github/workflows/posix_compliance.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nname: POSIX Compliance\n\non:\n push:\n paths: &paths-filter\n - .github/workflows/posix_compliance.yml\n - bin/elixir\n - bin/elixirc\n - bin/iex\n\n pull_request:\n paths: *paths-filter\n\n workflow_dispatch:\n\npermissions:\n contents: read\n\nenv:\n LANG: C.UTF-8\n\njobs:\n check_posix_compliance:\n name: Check POSIX compliance\n runs-on: ubuntu-latest\n\n strategy:\n fail-fast: false\n\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - name: Install ShellCheck\n run: |\n sudo apt update\n sudo apt install -y shellcheck\n\n - name: Run ShellCheck on bin/ dir\n run: |\n shellcheck -e SC2039,2086 bin/elixir && \\\n echo \"bin/elixir is POSIX compliant\"\n\n shellcheck bin/elixirc && \\\n echo \"bin/elixirc is POSIX compliant\"\n\n shellcheck bin/iex && \\\n echo \"bin/iex is POSIX compliant\"\n" }, { "path": ".github/workflows/release.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nname: Releases\n\non:\n push:\n branches:\n - main\n - v*.*\n\n tags:\n - v*\n\n workflow_dispatch:\n\nenv:\n ELIXIR_OPTS: \"--warnings-as-errors\"\n LANG: C.UTF-8\n\npermissions:\n contents: read\n\njobs:\n create_draft_release:\n name: Create draft release\n runs-on: ubuntu-24.04\n\n permissions:\n contents: write\n\n env:\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n\n steps:\n - name: Create draft release\n if: github.ref_type != 'branch'\n run: |\n gh release create \\\n --repo \"$GITHUB_REPOSITORY\" \\\n --title \"$GITHUB_REF_NAME\" \\\n --notes '' \\\n --draft \\\n \"$GITHUB_REF_NAME\"\n\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n # zizmor: ignore[artipacked]\n if: github.ref_type == 'branch'\n\n - name: Update ${{ github.ref_name }}-latest\n if: github.ref_type == 'branch'\n run: |\n ref_name=\"${GITHUB_REF_NAME}-latest\"\n\n if ! gh release view \"$ref_name\"; then\n gh release create \\\n --latest=false \\\n --title \"$ref_name\" \\\n --notes \"Automated release for latest ${GITHUB_REF_NAME}.\" \\\n \"$ref_name\"\n fi\n\n git tag \"$ref_name\" --force\n git push origin \"$ref_name\" --force\n\n build:\n name: Ubuntu 24.04, OTP ${{ matrix.otp_version }}${{ matrix.build_docs && ' (build docs)' || '' }}\n runs-on: ubuntu-24.04\n\n strategy:\n fail-fast: true\n matrix:\n include:\n - otp: 27\n otp_version: \"27.0\"\n\n - otp: 28\n otp_version: \"28.0\"\n build_docs: build_docs\n\n - otp: 29\n otp_version: \"29.0-rc1\"\n\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - name: \"Build Release\"\n uses: ./.github/workflows/release_pre_built\n with:\n otp_version: ${{ matrix.otp_version }}\n otp: ${{ matrix.otp }}\n build_docs: ${{ matrix.build_docs }}\n\n - name: Create Docs Hashes\n if: matrix.build_docs\n run: |\n shasum -a 1 Docs.zip > Docs.zip.sha1sum\n shasum -a 256 Docs.zip > Docs.zip.sha256sum\n\n - name: \"Upload Linux release artifacts\"\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0\n with:\n name: build-linux-elixir-otp-${{ matrix.otp }}\n path: elixir-otp-${{ matrix.otp }}.zip\n\n - name: \"Upload Windows release artifacts\"\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0\n with:\n name: build-windows-elixir-otp-${{ matrix.otp }}\n path: elixir-otp-${{ matrix.otp }}.exe\n\n - name: \"Upload doc artifacts\"\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0\n if: matrix.build_docs\n with:\n name: Docs\n path: Docs.zip*\n\n sign:\n name: Sign files, ${{ matrix.flavor == 'windows' && 'Windows' || matrix.flavor == 'linux' && 'Linux' || matrix.flavor }}, OTP ${{ matrix.otp }}\n needs: [build]\n environment: release\n strategy:\n fail-fast: true\n matrix:\n otp: [27, 28, 29]\n flavor: [windows, linux]\n\n env:\n RELEASE_FILE: elixir-otp-${{ matrix.otp }}.${{ matrix.flavor == 'linux' && 'zip' || 'exe' }}\n\n runs-on: ${{ matrix.flavor == 'linux' && 'ubuntu-24.04' || 'windows-2022' }}\n\n permissions:\n contents: write\n id-token: write\n\n steps:\n - name: \"Download build\"\n uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0\n with:\n name: build-${{ matrix.flavor }}-elixir-otp-${{ matrix.otp }}\n\n - name: Log in to Azure\n if: ${{ matrix.flavor == 'windows' && vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}\n uses: azure/login@a457da9ea143d694b1b9c7c869ebb04ebe844ef5 # v2.3.0\n with:\n client-id: ${{ secrets.AZURE_CLIENT_ID }}\n tenant-id: ${{ secrets.AZURE_TENANT_ID }}\n subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}\n\n - name: \"Sign files with Trusted Signing\"\n uses: azure/trusted-signing-action@87c2e83e6868da99d3380aa309851b32ed9a8346 # v1.1.0\n if: ${{ matrix.flavor == 'windows' && vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}\n with:\n endpoint: https://eus.codesigning.azure.net/\n trusted-signing-account-name: ${{ vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}\n certificate-profile-name: ${{ vars.AZURE_CERTIFICATE_PROFILE_NAME }}\n files-folder: ${{ github.workspace }}\n files-folder-filter: exe\n file-digest: SHA256\n timestamp-rfc3161: http://timestamp.acs.microsoft.com\n timestamp-digest: SHA256\n\n - name: Create Release Hashes\n if: matrix.flavor == 'windows'\n shell: pwsh\n run: |\n $sha1 = Get-FileHash \"$env:RELEASE_FILE\" -Algorithm SHA1\n $sha1.Hash.ToLower() + \" \" + $env:RELEASE_FILE | Out-File \"$env:RELEASE_FILE.sha1sum\"\n\n $sha256 = Get-FileHash \"$env:RELEASE_FILE\" -Algorithm SHA256\n $sha256.Hash.ToLower() + \" \" + $env:RELEASE_FILE | Out-File \"$env:RELEASE_FILE.sha256sum\"\n\n - name: Create Release Hashes\n if: matrix.flavor == 'linux'\n shell: bash\n run: |\n shasum -a 1 \"$RELEASE_FILE\" > \"${RELEASE_FILE}.sha1sum\"\n shasum -a 256 \"$RELEASE_FILE\" > \"${RELEASE_FILE}.sha256sum\"\n\n - name: \"Upload Linux release artifacts\"\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0\n with:\n name: sign-${{ matrix.flavor }}-elixir-otp-${{ matrix.otp }}\n path: ${{ env.RELEASE_FILE }}*\n\n sbom:\n name: Generate SBoM\n needs: [build, sign]\n runs-on: ubuntu-24.04\n\n permissions:\n contents: write\n id-token: write\n attestations: write\n\n steps:\n - name: Use HTTPS instead of SSH for Git cloning\n id: git-config\n shell: bash\n run: git config --global url.https://github.com/.insteadOf ssh://git@github.com/\n\n - name: Checkout project\n id: checkout\n uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - name: \"Download Build Artifacts\"\n id: download-build-artifacts\n uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0\n with:\n pattern: \"{sign-*-elixir-otp-*,Docs}\"\n merge-multiple: true\n path: /tmp/build-artifacts/\n\n - name: \"Run OSS Review Toolkit\"\n id: ort\n uses: ./.github/workflows/ort\n with:\n report-formats: \"CycloneDx,SpdxDocument\"\n version: \"${{ github.ref_type\t== 'tag' && github.ref_name || github.sha }}\"\n\n - name: Attest Distribution Assets with SBoM\n id: attest-sbom\n uses: actions/attest-sbom@07e74fc4e78d1aad915e867f9a094073a9f71527 # v4.0.0\n with:\n subject-path: |\n /tmp/build-artifacts/{elixir-otp-*.*,Docs.zip}\n ${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}\n ${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}\n ${{ steps.ort.outputs.results-sbom-spdx-yml-path }}\n ${{ steps.ort.outputs.results-sbom-spdx-json-path }}\n sbom-path: \"${{ steps.ort.outputs.results-sbom-spdx-json-path }}\"\n\n - name: \"Copy SBoM provenance\"\n id: sbom-provenance\n shell: bash\n run: |\n mkdir attestations\n\n for FILE in /tmp/build-artifacts/{elixir-otp-*.*,Docs.zip}; do\n cp \"$ATTESTATION\" \"attestations/$(basename \"$FILE\").sigstore\"\n done\n\n cp \"$ATTESTATION\" \"attestations/$(basename \"$SBOM_CYCLONEDX_XML\").sigstore\"\n cp \"$ATTESTATION\" \"attestations/$(basename \"$SBOM_CYCLONEDX_JSON\").sigstore\"\n cp \"$ATTESTATION\" \"attestations/$(basename \"$SBOM_SPDX_YML\").sigstore\"\n cp \"$ATTESTATION\" \"attestations/$(basename \"$SBOM_SPDX_JSON\").sigstore\"\n env:\n ATTESTATION: \"${{ steps.attest-sbom.outputs.bundle-path }}\"\n SBOM_CYCLONEDX_XML: \"${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}\"\n SBOM_CYCLONEDX_JSON: \"${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}\"\n SBOM_SPDX_YML: \"${{ steps.ort.outputs.results-sbom-spdx-yml-path }}\"\n SBOM_SPDX_JSON: \"${{ steps.ort.outputs.results-sbom-spdx-json-path }}\"\n\n - name: \"Assemble Release SBoM Artifacts\"\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0\n with:\n name: \"SBoM\"\n path: |\n ${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}\n ${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}\n ${{ steps.ort.outputs.results-sbom-spdx-yml-path }}\n ${{ steps.ort.outputs.results-sbom-spdx-json-path }}\n\n - name: \"Assemble Distribution Attestations\"\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0\n with:\n name: \"Attestations\"\n path: \"attestations/*.sigstore\"\n\n upload-release:\n name: Upload release\n needs: [create_draft_release, build, sign, sbom]\n runs-on: ubuntu-24.04\n\n permissions:\n contents: write\n\n steps:\n - uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0\n with:\n pattern: \"{sign-*-elixir-otp-*,Docs,SBoM,Attestations}\"\n merge-multiple: true\n\n - name: Upload Pre-build\n shell: bash\n env:\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n run: |\n if [ \"$GITHUB_REF_TYPE\" == \"branch\" ]; then\n tag=\"${GITHUB_REF_NAME}-latest\"\n else\n tag=\"$GITHUB_REF_NAME\"\n fi\n\n gh release upload \\\n --repo \"$GITHUB_REPOSITORY\" \\\n --clobber \\\n \"$tag\" \\\n elixir-otp-*.zip \\\n elixir-otp-*.zip.sha{1,256}sum \\\n elixir-otp-*.zip.sigstore \\\n elixir-otp-*.exe \\\n elixir-otp-*.exe.sha{1,256}sum \\\n elixir-otp-*.exe.sigstore \\\n Docs.zip \\\n Docs.zip.sha{1,256}sum \\\n Docs.zip.sigstore \\\n bom.*\n\n upload-builds-hex-pm:\n name: Upload builds to hex.pm\n runs-on: ubuntu-24.04\n needs: [build, sign]\n concurrency: builds-hex-pm\n environment: release\n\n env:\n AWS_ACCESS_KEY_ID: ${{ secrets.HEX_AWS_ACCESS_KEY_ID }}\n AWS_SECRET_ACCESS_KEY: ${{ secrets.HEX_AWS_SECRET_ACCESS_KEY }}\n AWS_REGION: ${{ vars.HEX_AWS_REGION }}\n AWS_S3_BUCKET: ${{ vars.HEX_AWS_S3_BUCKET }}\n\n steps:\n - name: \"Check if variables are set up\"\n if: \"${{ ! vars.HEX_AWS_REGION }}\"\n run: |\n echo \"Required variables for uploading to hex.pm are not set up, skipping...\"\n exit 1\n\n - uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0\n with:\n pattern: \"{sign-*-elixir-otp-*,Docs}\"\n merge-multiple: true\n\n - name: Init purge keys file\n run: |\n touch purge_keys.txt\n\n - name: Upload Precompiled to S3\n run: |\n oldest_otp=$(find . -type f -name 'elixir-otp-*.zip' | sed -r 's/^.*elixir-otp-([[:digit:]]+)\\.zip$/\\1/' | sort -n | head -n 1)\n\n for zip in $(find . -type f -name 'elixir-otp-*.zip' | sed 's/^\\.\\///'); do\n dest=${zip/elixir/${GITHUB_REF_NAME}}\n surrogate_key=${dest/.zip$/}\n\n aws s3 cp \"${zip}\" \"s3://${AWS_S3_BUCKET}/builds/elixir/${dest}\" \\\n --cache-control \"public,max-age=3600\" \\\n --metadata \"{\\\"surrogate-key\\\":\\\"builds builds/elixir builds/elixir/${surrogate_key}\\\",\\\"surrogate-control\\\":\\\"public,max-age=604800\\\"}\"\n echo \"builds/elixir/${surrogate_key}\" >> purge_keys.txt\n\n if [ \"$zip\" == \"elixir-otp-${oldest_otp}.zip\" ]; then\n aws s3 cp \"${zip}\" \"s3://${AWS_S3_BUCKET}/builds/elixir/${GITHUB_REF_NAME}.zip\" \\\n --cache-control \"public,max-age=3600\" \\\n --metadata \"{\\\"surrogate-key\\\":\\\"builds builds/elixir builds/elixir/${GITHUB_REF_NAME}\\\",\\\"surrogate-control\\\":\\\"public,max-age=604800\\\"}\"\n echo builds/elixir/${GITHUB_REF_NAME} >> purge_keys.txt\n fi\n done\n\n - name: Upload Docs to S3\n run: |\n version=$(echo \"$GITHUB_REF_NAME\" | sed -e 's/^v//g')\n\n unzip Docs.zip\n\n for f in doc/*; do\n if [ -d \"$f\" ]; then\n app=$(echo \"$f\" | sed s/\"doc\\/\"//)\n tarball=\"${app}-${version}.tar.gz\"\n surrogate_key=\"docs/${app}-${version}\"\n\n tar -czf \"${tarball}\" -C \"doc/${app}\" .\n aws s3 cp \"${tarball}\" \"s3://${AWS_S3_BUCKET}/docs/${tarball}\" \\\n --cache-control \"public,max-age=3600\" \\\n --metadata \"{\\\"surrogate-key\\\":\\\"${surrogate_key}\\\",\\\"surrogate-control\\\":\\\"public,max-age=604800\\\"}\"\n echo \"${surrogate_key}\" >> ../purge_keys.txt\n fi\n done\n\n - name: Update builds txt\n run: |\n date=\"$(date -u '+%Y-%m-%dT%H:%M:%SZ')\"\n ref_name=\"$GITHUB_REF_NAME\"\n\n oldest_otp=$(find . -name 'elixir-otp-*.zip.sha256sum' | sed -r 's/^.*elixir-otp-([[:digit:]]+)\\.zip\\.sha256sum$/\\1/' | sort -n | head -n 1)\n\n aws s3 cp \"s3://${AWS_S3_BUCKET}/builds/elixir/builds.txt\" builds.txt || true\n touch builds.txt\n\n for sha256_file in $(find . -name 'elixir-otp-*.zip.sha256sum' | sed 's/^\\.\\///'); do\n otp_version=$(echo \"${sha256_file}\" | sed -r 's/^elixir-otp-([[:digit:]]+)\\.zip\\.sha256sum/otp-\\1/')\n build_sha256=$(cut -d ' ' -f 1 \"${sha256_file}\")\n\n sed -i \"/^${ref_name}-${otp_version} /d\" builds.txt\n echo -e \"${ref_name}-${otp_version} ${{ github.sha }} ${date} ${build_sha256} \\n$(cat builds.txt)\" > builds.txt\n\n if [ \"${otp_version}\" == \"otp-${oldest_otp}\" ]; then\n sed -i \"/^${ref_name} /d\" builds.txt\n echo -e \"${ref_name} ${{ github.sha }} ${date} ${build_sha256} \\n$(cat builds.txt)\" > builds.txt\n fi\n done\n\n sort -u -k1,1 -o builds.txt builds.txt\n aws s3 cp builds.txt \"s3://${AWS_S3_BUCKET}/builds/elixir/builds.txt\" \\\n --cache-control \"public,max-age=3600\" \\\n --metadata '{\"surrogate-key\":\"builds builds/elixir builds/elixir/txt\",\"surrogate-control\":\"public,max-age=604800\"}'\n\n echo 'builds/elixir/txt' >> purge_keys.txt\n\n - name: Flush cache\n if: github.repository == 'elixir-lang/elixir'\n run: |\n function purge_key() {\n curl \\\n -X POST \\\n -H \"Fastly-Key: ${FASTLY_KEY}\" \\\n -H \"Accept: application/json\" \\\n -H \"Content-Length: 0\" \\\n \"https://api.fastly.com/service/$1/purge/$2\"\n }\n\n function purge() {\n purge_key ${FASTLY_REPO_SERVICE_ID} $1\n purge_key ${FASTLY_BUILDS_SERVICE_ID} $1\n sleep 2\n purge_key ${FASTLY_REPO_SERVICE_ID} $1\n purge_key ${FASTLY_BUILDS_SERVICE_ID} $1\n sleep 2\n purge_key ${FASTLY_REPO_SERVICE_ID} $1\n purge_key ${FASTLY_BUILDS_SERVICE_ID} $1\n }\n\n for key in $(cat purge_keys.txt); do\n purge \"${key}\"\n done\n\n env:\n FASTLY_REPO_SERVICE_ID: ${{ secrets.HEX_FASTLY_REPO_SERVICE_ID }}\n FASTLY_BUILDS_SERVICE_ID: ${{ secrets.HEX_FASTLY_BUILDS_SERVICE_ID }}\n FASTLY_KEY: ${{ secrets.HEX_FASTLY_KEY }}\n" }, { "path": ".github/workflows/release_notifications.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nname: Release Notifications\n\non:\n release:\n types:\n - published\n\npermissions:\n contents: read\n\njobs:\n notify:\n runs-on: ubuntu-latest\n name: Notify\n\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2\n with:\n persist-credentials: false\n\n - uses: erlef/setup-beam@e6d7c94229049569db56a7ad5a540c051a010af9 # v1.20.4\n with:\n otp-version: \"27.3\"\n elixir-version: \"1.18.3\"\n\n - name: Run Elixir script\n env:\n ELIXIR_FORUM_TOKEN: ${{ secrets.ELIXIR_FORUM_TOKEN }}\n ELIXIR_LANG_ANN_TOKEN: ${{ secrets.ELIXIR_LANG_ANN_TOKEN }}\n run: |\n elixir .github/workflows/notify.exs \"$GITHUB_REF_NAME\"\n" }, { "path": ".github/workflows/release_pre_built/action.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nname: Release Pre-build\ndescription: \"Builds Elixir release, ExDoc and generates docs\"\n\ninputs:\n otp:\n description: \"The major OTP version\"\n\n otp_version:\n description: \"The exact OTP version (major.minor[.patch])\"\n\n build_docs:\n description: \"Whether docs have to be built\"\n\nruns:\n using: \"composite\"\n\n steps:\n - uses: erlef/setup-beam@5304e04ea2b355f03681464e683d92e3b2f18451 # v1.18.2\n with:\n otp-version: ${{ inputs.otp_version }}\n version-type: strict\n\n - name: Build Elixir Release\n shell: bash\n run: | # zizmor: ignore[github-env]\n make Precompiled.zip\n mv Precompiled.zip \"elixir-otp-${INPUT_OTP}.zip\"\n echo \"$PWD/bin\" >> $GITHUB_PATH\n env:\n INPUT_OTP: ${{ inputs.otp }}\n\n - name: Install NSIS\n shell: bash\n run: |\n sudo apt update\n sudo apt install -y nsis\n\n - name: Build Elixir Windows Installer\n shell: bash\n run: |\n export OTP_VERSION=\"$INPUT_OTP_VERSION\"\n export ELIXIR_ZIP=\"$PWD/elixir-otp-${INPUT_OTP}.zip\"\n (cd lib/elixir/scripts/windows_installer && ./build.sh)\n mv \"lib/elixir/scripts/windows_installer/tmp/elixir-otp-${INPUT_OTP}.exe\" .\n env:\n INPUT_OTP: ${{ inputs.otp }}\n INPUT_OTP_VERSION: ${{ inputs.otp_version }}\n - name: Get ExDoc ref\n if: ${{ inputs.build_docs }}\n shell: bash\n run: | # zizmor: ignore[github-env]\n if [ \"$GITHUB_REF_NAME\" = \"main\" ]; then\n ref=main\n else\n ref=v$(curl -s https://hex.pm/api/packages/ex_doc | jq --raw-output '.latest_stable_version')\n fi\n echo \"EX_DOC_REF=$ref\" >> $GITHUB_ENV\n - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2\n if: ${{ inputs.build_docs }}\n with:\n repository: elixir-lang/ex_doc\n ref: ${{ env.EX_DOC_REF }}\n path: ex_doc\n persist-credentials: false\n - name: Build ex_doc\n if: ${{ inputs.build_docs }}\n shell: bash\n run: |\n mv ex_doc ../ex_doc\n cd ../ex_doc\n ../elixir/bin/mix do local.rebar --force + local.hex --force + deps.get + compile\n cd ../elixir\n - name: Build Docs\n if: ${{ inputs.build_docs }}\n shell: bash\n run: |\n git fetch --tags\n make Docs.zip\n" }, { "path": ".gitignore", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\n/doc/\n/lib/*/ebin/\n/lib/*/_build/\n/lib/*/tmp/\n/lib/elixir/src/*_parser.erl\n/lib/elixir/test/ebin/\n/man/elixir.1\n/man/iex.1\n/Docs.zip\n/Precompiled.zip\n/.eunit\n.elixir.plt\nerl_crash.dump\n/cover/\n.tool-versions\n" }, { "path": ".markdownlint-cli2.jsonc", "content": "// SPDX-License-Identifier: Apache-2.0\n// SPDX-FileCopyrightText: 2021 The Elixir Team\n{\n \"globs\": [\n \"**/*.md\"\n ],\n \"ignores\": [\n \".git/**\"\n ],\n \"gitignore\": true,\n \"config\": {\n // Consecutive header levels (h1 -> h2 -> h3).\n \"MD001\": false,\n // Header style. We use #s.\n \"MD003\": {\n \"style\": \"atx\"\n },\n // Style of unordered lists..\n \"MD007\": {\n \"indent\": 2,\n \"start_indented\": true\n },\n // Line length. Who cares.\n \"MD013\": false,\n // This warns if you have \"console\" or \"shell\" code blocks with a dollar sign $ that\n // don't show output. We use those a lot, so this is fine for us.\n \"MD014\": false,\n // Multiple headings with the same content.\n \"MD024\": {\n // Duplication is allowed for headings with different parents.\n \"siblings_only\": true\n },\n // Trailing punctuation in heading.\n // Some headers finish with ! because it refers to a function name. Therefore we remove ! from\n // the default values.\n \"MD026\": {\n \"punctuation\": \".,;:。，；：！\"\n },\n // Allow empty line between block quotes. Used by contiguous admonition blocks.\n \"MD028\": false,\n // Allowed HTML inline elements.\n \"MD033\": {\n \"allowed_elements\": [\n \"h1\",\n \"a\",\n \"br\",\n \"img\",\n \"picture\",\n \"source\",\n \"noscript\",\n \"p\",\n \"script\"\n ]\n },\n // This warns if you have spaces in code blocks. Sometimes, that's fine.\n \"MD038\": false,\n // Code block style. We don't care if it's fenced or indented.\n \"MD046\": false,\n // Our tables are too large to align.\n \"MD060\": false\n }\n}" }, { "path": ".ort/config/config.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nort:\n enableRepositoryPackageCurations: true\n enableRepositoryPackageConfigurations: true\n\n scanner:\n skipConcluded: false\n includeFilesWithoutFindings: true\n\n analyzer:\n allowDynamicVersions: true\n enabledPackageManagers: [SpdxDocumentFile]\n\n reporter:\n reporters:\n SpdxDocument:\n options:\n creationInfoOrganization: The Elixir Team\n documentName: \"Elixir Source SPDX Document\"\n" }, { "path": ".ort/config/evaluator.rules.kts", "content": "/*\n * Copyright (C) 2019 The ORT Project Authors (see )\n * Copyright (c) 2021 The Elixir Team\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * SPDX-License-Identifier: Apache-2.0\n */\n\n // Docs: https://oss-review-toolkit.org/ort/docs/configuration/evaluator-rules\n\nval whitelistedLicenses = listOf(\n // License for Elixir & Imported Erlang Projects\n \"Apache-2.0\",\n // License for the Elixir Logo\n \"LicenseRef-elixir-trademark-policy\",\n \"LicenseRef-scancode-elixir-trademark-policy\",\n // License for included Unicode Files\n \"LicenseRef-scancode-unicode\",\n // DCO for committers\n \"LicenseRef-scancode-dco-1.1\"\n).map { SpdxSingleLicenseExpression.parse(it) }.toSet()\n\nfun PackageRule.howToFixDefault() = \"\"\"\n * Check if this license violation is intended\n * Adjust evaluation rules in `.ort/config/evaluator.rules.kts`\n \"\"\".trimIndent()\n\nfun PackageRule.LicenseRule.isHandled() =\n object : RuleMatcher {\n override val description = \"isHandled($license)\"\n\n override fun matches() = license in whitelistedLicenses\n }\n\nfun RuleSet.unhandledLicenseRule() = packageRule(\"UNHANDLED_LICENSE\") {\n // Do not trigger this rule on packages that have been excluded in the .ort.yml.\n require {\n -isExcluded()\n }\n\n // Define a rule that is executed for each license of the package.\n licenseRule(\"UNHANDLED_LICENSE\", LicenseView.CONCLUDED_OR_DECLARED_AND_DETECTED) {\n require {\n -isExcluded()\n -isHandled()\n }\n\n // Throw an error message including guidance how to fix the issue.\n error(\n \"The license $license is currently not covered by policy rules. \" +\n \"The license was ${licenseSource.name.lowercase()} in package \" +\n \"${pkg.metadata.id.toCoordinates()}.\",\n howToFixDefault()\n )\n }\n}\n\nfun RuleSet.unmappedDeclaredLicenseRule() = packageRule(\"UNMAPPED_DECLARED_LICENSE\") {\n require {\n -isExcluded()\n }\n\n resolvedLicenseInfo.licenseInfo.declaredLicenseInfo.processed.unmapped.forEach { unmappedLicense ->\n warning(\n \"The declared license '$unmappedLicense' could not be mapped to a valid license or parsed as an SPDX \" +\n \"expression. The license was found in package ${pkg.metadata.id.toCoordinates()}.\",\n howToFixDefault()\n )\n }\n}\n\nval ruleSet = ruleSet(ortResult, licenseInfoResolver, resolutionProvider) {\n unhandledLicenseRule()\n unmappedDeclaredLicenseRule()\n}\n\nruleViolations += ruleSet.violations\n" }, { "path": ".ort/package-configurations/eex.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nid: \"SpdxDocumentFile:The Elixir Team:eex:\"\npath_excludes:\n - pattern: \"lib/eex/test/**/*\"\n reason: \"TEST_OF\"\n comment: \"Tests\"\nlicense_finding_curations:\n # Test Fixtures\n - path: \"lib/eex/test/fixtures/**/*\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to test fixtures\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n" }, { "path": ".ort/package-configurations/elixir.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nid: \"SpdxDocumentFile:The Elixir Team:elixir:\"\npath_excludes:\n - pattern: \"lib/elixir/pages/**/*\"\n reason: \"DOCUMENTATION_OF\"\n comment: \"Documentation\"\n - pattern: \"lib/elixir/scripts/**/*\"\n reason: \"BUILD_TOOL_OF\"\n comment: \"Build Tool\"\n - pattern: \"lib/elixir/test/**/*\"\n reason: \"TEST_OF\"\n comment: \"Tests\"\nlicense_finding_curations:\n # Logos\n - path: \"lib/elixir/pages/images/logo.png\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply Trademark Policy to Elixir Logo\"\n detected_license: \"NONE\"\n concluded_license: \"LicenseRef-elixir-trademark-policy\"\n - path: \"lib/elixir/scripts/windows_installer/assets/Elixir.ico\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply Trademark Policy to Elixir Logo\"\n detected_license: \"NONE\"\n concluded_license: \"LicenseRef-elixir-trademark-policy\"\n\n # Documentation Images\n - path: \"lib/elixir/pages/images/**/*.png\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to all images\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n\n # Test Fixtures\n - path: \"lib/elixir/test/elixir/fixtures/**/*\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to test fixtures\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n\n # Unicode\n - path: \"lib/elixir/unicode/*.txt\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to unicode files\"\n detected_license: \"NONE\"\n concluded_license: \"LicenseRef-scancode-unicode\"\n\n # Wrongly Identified\n - path: \"lib/elixir/pages/references/library-guidelines.md\"\n reason: \"INCORRECT\"\n comment: |\n The guide mentions multiple licenses for users to choose from.\n It however is not licensed itself by the mentioned licenses.\n concluded_license: \"Apache-2.0\"\n - path: \"lib/elixir/scripts/windows_installer/.gitignore\"\n reason: \"INCORRECT\"\n comment: \"Ignored by ScanCode\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n" }, { "path": ".ort/package-configurations/ex_unit.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nid: \"SpdxDocumentFile:The Elixir Team:exunit:\"\npath_excludes:\n - pattern: \"lib/ex_unit/examples/**/*\"\n reason: \"EXAMPLE_OF\"\n comment: \"Example\"\n - pattern: \"lib/ex_unit/test/**/*\"\n reason: \"TEST_OF\"\n comment: \"Tests\"\nlicense_finding_curations:\n # Test Fixtures\n - path: \"lib/ex_unit/test/fixtures/**/*\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to test fixtures\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n" }, { "path": ".ort/package-configurations/logger.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nid: \"SpdxDocumentFile:The Elixir Team:logger:\"\npath_excludes:\n - pattern: \"lib/logger/test/**/*\"\n reason: \"TEST_OF\"\n comment: \"Tests\"\n" }, { "path": ".ort/package-configurations/mix.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nid: \"SpdxDocumentFile:The Elixir Team:mix:\"\npath_excludes:\n - pattern: \"lib/mix/test/**/*\"\n reason: \"TEST_OF\"\n comment: \"Tests\"\nlicense_finding_curations:\n # Test Fixtures\n - path: \"lib/mix/test/fixtures/**/*\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to test fixtures\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n" }, { "path": ".ort.yml", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nexcludes:\n paths:\n - pattern: \"man/*\"\n reason: \"DOCUMENTATION_OF\"\n comment: \"Documentation\"\n - pattern: \".github/**/*\"\n reason: \"BUILD_TOOL_OF\"\n comment: \"Documentation\"\n - pattern: \".ort/**/*\"\n reason: \"BUILD_TOOL_OF\"\n comment: \"Documentation\"\n\n # Unfortunately we'll have to repeat all package level excludes here\n # Make sure to keep them in sync with the package configuration in\n # .ort/package-configurations\n - pattern: \"lib/*/pages/**/*\"\n reason: \"DOCUMENTATION_OF\"\n comment: \"Documentation\"\n - pattern: \"lib/*/test/**/*\"\n reason: \"TEST_OF\"\n comment: \"Tests\"\n - pattern: \"lib/*/scripts/**/*\"\n reason: \"BUILD_TOOL_OF\"\n comment: \"Build Tool\"\n - pattern: \"lib/*/examples/**/*\"\n reason: \"EXAMPLE_OF\"\n comment: \"Example\"\n\ncurations:\n license_findings:\n # Version File\n - path: \"VERSION\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply Trademark Policy to VERSION file\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n\n # Wrongly Identified\n - path: \".gitignore\"\n reason: \"INCORRECT\"\n comment: \"Ignored by ScanCode\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n - path: \".gitattributes\"\n reason: \"INCORRECT\"\n comment: \"Ignored by ScanCode\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n - path: \"CONTRIBUTING.md\"\n reason: \"INCORRECT\"\n comment: \"Wrongly identified TSL license\"\n detected_license: \"Apache-2.0 OR NOASSERTION OR LicenseRef-scancode-tsl-2020\"\n concluded_license: \"Apache-2.0\"\n - path: \"OPEN_SOURCE_POLICY.md\"\n reason: \"INCORRECT\"\n comment: \"Wrongly identified NOASSERTION\"\n detected_license: \"NOASSERTION\"\n concluded_license: \"Apache-2.0\"\n\n # Unfortunately we'll have to repeat all package level license curations here\n # Make sure to keep them in sync with the package configuration in\n # .ort/package-configurations\n\n # Test Fixtures\n - path: \"lib/*/test/fixtures/**/*\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to test fixtures\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n\n # Logos\n - path: \"lib/elixir/pages/images/logo.png\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply Trademark Policy to Elixir Logo\"\n detected_license: \"NONE\"\n concluded_license: \"LicenseRef-elixir-trademark-policy\"\n - path: \"lib/elixir/scripts/windows_installer/assets/Elixir.ico\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply Trademark Policy to Elixir Logo\"\n detected_license: \"NONE\"\n concluded_license: \"LicenseRef-elixir-trademark-policy\"\n\n # Documentation Images\n - path: \"lib/elixir/pages/images/**/*.png\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to all images\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n\n # Test Fixtures\n - path: \"lib/elixir/test/elixir/fixtures/**/*\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to test fixtures\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n\n # Unicode\n - path: \"lib/elixir/unicode/*.txt\"\n reason: \"NOT_DETECTED\"\n comment: \"Apply default license to unicode files\"\n detected_license: \"NONE\"\n concluded_license: \"LicenseRef-scancode-unicode\"\n\n # Wrongly Identified\n - path: \"lib/elixir/pages/references/library-guidelines.md\"\n reason: \"INCORRECT\"\n comment: |\n The guide mentions multiple licenses for users to choose from.\n It however is not licensed itself by the mentioned licenses.\n concluded_license: \"Apache-2.0\"\n - path: \"lib/elixir/scripts/windows_installer/.gitignore\"\n reason: \"INCORRECT\"\n comment: \"Ignored by ScanCode\"\n detected_license: \"NONE\"\n concluded_license: \"Apache-2.0\"\n" }, { "path": "CHANGELOG.md", "content": "\n\n# Changelog for Elixir v1.20\n\n## Type system improvements\n\nThis release includes type inference of all constructs.\n\n### Type inference of function definitions\n\nElixir now performs inference of whole functions. The best way to show the new capabilities are with examples. Take the following code:\n\n```elixir\ndef add_foo_and_bar(data) do\n data.foo + data.bar\nend\n```\n\nElixir now infers that the function expects a `map` as first argument, and the map must have the keys `.foo` and `.bar` whose values are either `integer()` or `float()`. The return type will be either `integer()` or `float()`.\n\nHere is another example:\n\n```elixir\ndef sum_to_string(a, b) do\n Integer.to_string(a + b)\nend\n```\n\nEven though the `+` operator works with both integers and floats, Elixir infers that `a` and `b` must be both integers, as the result of `+` is given to a function that expects an integer. The inferred type information is then used during type checking to find possible typing errors.\n\n### Type inference of guards\n\nThis release also performs inference of guards! Let's see some examples:\n\n```elixir\ndef example(x, y) when is_list(x) and is_integer(y)\n```\n\nThe code above correctly infers `x` is a list and `y` is an integer.\n\n```elixir\ndef example({:ok, x} = y) when is_binary(x) or is_integer(x)\n```\n\nThe one above infers x is a binary or an integer, and `y` is a two element tuple with `:ok` as first element and a binary or integer as second.\n\n```elixir\ndef example(x) when is_map_key(x, :foo)\n```\n\nThe code above infers `x` is a map which has the `:foo` key, represented as `%{..., foo: dynamic()}`. Remember the leading `...` indicates the map may have other keys.\n\n```elixir\ndef example(x) when not is_map_key(x, :foo)\n```\n\nAnd the code above infers `x` does not have the `:foo` key (hence `x.foo` will raise a typing violation), which has the type: `%{..., foo: not_set()}`.\n\nYou can also have expressions that assert on the size of data structures:\n\n```elixir\ndef example(x) when tuple_size(x) < 3\n```\n\nElixir will correctly track the tuple has at most two elements, and therefore accessing `elem(x, 3)` will emit a typing violation. In other words, Elixir can look at complex guards, infer types, and use this information to find bugs in our code, without a need to introduce type signatures (yet).\n\n### Typing across clauses\n\nElixir now infers the type of a given clause based on previous clauses. Let's see an example:\n\n```elixir\ncase System.get_env(\"SOME_VAR\") do\n nil -> :not_found\n value -> {:ok, String.upcase(value)}\nend\n```\n\n`System.get_env(\"SOME_VAR\")` returns either `nil` or a `binary()`. Because the first clause matches on `nil`, the type system now knows `value` can no longer be `nil`, and therefore it must only be a `binary()`, which allows the second clause to also type check without violations.\n\nThis type inference across clauses also helps the type system find redundant clauses and dead code in existing codebases.\n\n### Complete typing of maps keys\n\nMaps were one of the first data-structures we implemented within the Elixir type system however, up to this point, they only supported atom keys. If they had additional keys, those keys were simply marked as `dynamic()`.\n\nAs of Elixir v1.20, we can track all possible domains as map keys. For example, the map:\n\n```elixir\n%{123 => \"hello\", 456.0 => :ok}\n```\n\nwill have the type:\n\n```elixir\n%{integer() => binary(), float() => :ok}\n```\n\nIt is also possible to mix domain keys, as above, with atom keys, yielding the following:\n\n```elixir\n%{integer() => integer(), root: integer()}\n```\n\nThis system is an implementation of [Typing Records, Maps, and Structs, by Giuseppe Castagna (2023)](https://www.irif.fr/~gc/papers/icfp23.pdf).\n\n### Typing of map operations\n\nWe have typed the majority of the functions in the `Map` module, allowing the type system to track how keys are added, updated, and removed across all possible key types.\n\nFor example, imagine we are calling the following `Map` functions with a variable `map`, which we don't know the exact shape of, and an atom key:\n\n```elixir\nMap.put(map, :key, 123)\n#=> returns type %{..., key: integer()}\n\nMap.delete(map, :key)\n#=> returns type %{..., key: not_set()}\n```\n\nAs you can see, we track when keys are set and also when they are removed.\n\nSome operations, like `Map.replace/3`, only replace the key if it exists, and that is also propagated by the type system:\n\n```elixir\nMap.replace(map, :key, 123)\n#=> returns type %{..., key: if_set(integer())}\n```\n\nIn other words, if the key exists, it would have been replaced by an integer value. Furthermore, whenever calling a function in the `Map` module and the given key is statically proven to never exist in the map, an error is emitted.\n\nBy combining full type inference with bang operations like `Map.fetch!/2`, `Map.pop!/2`, `Map.replace!/3`, and `Map.update!/3`, Elixir is able to propagate information about the desired keys. Take this module:\n\n```elixir\ndefmodule User do\n def name(map), do: Map.fetch!(map, :name)\nend\n\ndefmodule CallsUser do\n def calls_name do\n User.name(%{})\n end\nend\n```\n\nThe code above has a type violation, which is now caught by the type system:\n\n```text\n warning: incompatible types given to User.name/1:\n\n User.name(%{})\n\n given types:\n\n %{name: not_set()}\n\n but expected one of:\n\n dynamic(%{..., name: term()})\n\n type warning found at:\n │\n 16 │ User.name(%{})\n │ ~\n │\n └─ lib/calls_user.ex:7:5: CallsUser.calls_name/0\n```\n\n### Acknowledgements\n\nThe type system was made possible thanks to a partnership between [CNRS](https://www.cnrs.fr/) and [Remote](https://remote.com/). The development work is currently sponsored by [Fresha](https://www.fresha.com/) and [Tidewave](https://tidewave.ai/).\n\n## v1.20.0-rc.3 (2026-03-09)\n\n### 1. Enhancements\n\n#### IEx\n\n * [IEx] Optimize autocompleting modules\n\n### 2. Bug fixes\n\n#### Elixir\n\n * [Enum] Fix `Enum.slice/2` for ranges with step > 1 sliced by step > 1\n * [File] Preserve directory permissions in `File.cp_r/3`\n * [File] Fix `File.cp_r/3` infinite loop with symlink cycles\n * [File] Fix `File.cp_r/3` infinite loop when copying into subdirectory of source\n * [File] Warn when defining `@type record()`, fixes CI on Erlang/OTP 29\n * [File] Fix `File.Stream` `Enumerable.count` for files without trailing newline\n * [Float] Fix `Float.parse/1` inconsistent error handling for non-scientific notation overflow\n * [Kernel] Process fields even when structs are unknown (regression)\n * [Kernel] Improve performance on several corner cases in the type system (regression)\n * [Kernel] Fix regression when using `Kernel.in/2` in defguard (regression)\n\n## v1.20.0-rc.2 (2026-03-04)\n\n### 1. Enhancements\n\n#### Elixir\n\n * [Code] Add `module_definition: :interpreted` option to `Code` which allows module definitions to be evaluated instead of compiled. In some applications/architectures, this can lead to drastic improvements to compilation times. Note this does not affect the generated `.beam` file, which will have the same performance/behaviour as before\n * [Code] Make module purging opt-in and move temporary module deletion to the background to speed up compilation times\n * [Integer] Add `Integer.popcount/1`\n * [Kernel] Move struct validation in patterns and updates to type checker, this means adding and remove struct fields will cause fewer files to be recompiled\n * [Kernel] Add type inference across clauses. For example, if one clause says `x when is_integer(x)`, then the next clause may no longer be an integer\n * [Kernel] Detect and warn on redundant clauses\n * [List] Add `List.first!/1` and `List.last!/1`\n * Add Software Bill of Materials guide to the Documentation\n\n#### Mix\n\n * [mix compile] Add `module_definition: :interpreted` option to `Code` which allows module definitions to be evaluated instead of compiled. In some applications/architectures, this can lead to drastic improvements to compilation times. Note this does not affect the generated `.beam` file, which will have the same performance/behaviour as before\n * [mix deps] Parallelize dep lock status checks during `deps.loadpaths`, improving boot times in projects with many git dependencies\n\n### 2. Potential breaking changes\n\n#### Elixir\n\n * `map.foo()` (accessing a map field with parens) and `mod.foo` (invoking a function without parens) will now raise instead of emitting runtime warnings, aligning themselves with the type system behaviour\n\n### 3. Bug fixes\n\n#### IEx\n\n * [IEx] Ensure warnings emitted during IEx parsing are properly displayed/printed\n * [IEx] Ensure pry works across remote nodes\n\n#### Mix\n\n * [mix compile.erlang] Topsort Erlang modules before compilation for proper dependency resolution\n\n## v1.20.0-rc.1 (2026-01-13)\n\n### 1. Bug fixes\n\n#### Elixir\n\n * [Kernel] Do not crash on map types with struct keys when performing type operations (regression)\n * [Kernel] Mark the outcome of bitstring types as dynamic (regression)\n * [Kernel] `<>` will have type `binary` instead of `bitstring` if `expr` is a binary (regression)\n * [Kernel] Do not crash on conditional variables when calling a function on a module which is represented by a variable (regression)\n\n## v1.20.0-rc.0 (2026-01-09)\n\n### 1. Enhancements\n\n#### Elixir\n\n * [Calendar] Optimize `date_from_iso_days` by using the Neri-Schneider algorithm\n * [Enum] Add `Enum.min_max` sorter\n * [Integer] Add `Integer.ceil_div/2`\n * [IO] Add `IO.iodata_empty?/1`\n * [File] Skip device, named pipes, etc in `File.cp_r/3` instead of erroring with reason `:eio`\n * [Kernel] Print intermediate results of `dbg` for pipes\n * [Kernel] Warn on unused requires\n * [Regex] Add `Regex.import/1` to import regexes defined with `/E`\n\n#### ExUnit\n\n * [ExUnit.CaptureLog] Add `:formatter` option for custom log formatting\n\n#### Mix\n\n * [mix deps] Support filtering `mix deps` output\n * [mix compile] Enforce `:elixirc_paths` to be a list of strings to avoid paths from being discarded (the only documented type was lists of strings)\n * [mix test] Add `mix test --dry-run`\n\n### 2. Potential breaking changes\n\n#### Elixir\n\n * `require SomeModule` no longer expands to the given module at compile-time, but it still returns the module at runtime. Note that while Elixir does not guarantee macros will expand to certain constructs, but since this can break code relying on the previous behaviour, such as `require(SomeMod).some_macro()`, we are adding this note to the CHANGELOG\n\n### 3. Hard deprecations\n\n#### Elixir\n\n * [File] `File.stream!(path, modes, lines_or_bytes)` is deprecated in favor of `File.stream!(path, lines_or_bytes, modes)`\n * [Kernel] Matching on the size inside a bit pattern now requires the pin operator for consistency, such as `<>`\n * [Kernel.ParallelCompiler] `Kernel.ParallelCompiler.async/1` is deprecated in favor of `Kernel.ParallelCompiler.pmap/2`, which is more performant and addresses known limitations\n\n#### Logger\n\n * [Logger] `Logger.*_backend` functions are deprecated in favor of handlers. If you really want to keep on using backends, see the `:logger_backends` package\n * [Logger] `Logger.enable/1` and `Logger.disable/1` have been deprecated in favor of `Logger.put_process_level/2` and `Logger.delete_process_level/1`\n\n## v1.19\n\nThe CHANGELOG for v1.19 releases can be found [in the v1.19 branch](https://github.com/elixir-lang/elixir/blob/v1.19/CHANGELOG.md).\n" }, { "path": "CODE_OF_CONDUCT.md", "content": "\n\n# Code of Conduct\n\nContact: \n\n## Why have a Code of Conduct?\n\nAs 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.\n\nThe 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.\n\n## Our Values\n\nThese are the values Elixir developers should aspire to:\n\n * Be friendly and welcoming\n * Be kind\n * Remember that people have varying communication styles and that not everyone is using their native language. (Meaning and tone can be lost in translation.)\n * Interpret the arguments of others in good faith, do not seek to disagree.\n * When we do disagree, try to understand why.\n * Be thoughtful\n * Productive communication requires effort. Think about how your words will be interpreted.\n * Remember that sometimes it is best to refrain entirely from commenting.\n * Be respectful\n * In particular, respect differences of opinion. It is important that we resolve disagreements and differing views constructively.\n * Be constructive\n * Avoid derailing: stay on topic; if you want to talk about something else, start a new conversation.\n * 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.\n * 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.\n * Avoid snarking (pithy, unproductive, sniping comments).\n * 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).\n * Be responsible\n * What you say and do matters. Take responsibility for your words and actions, including their consequences, whether intended or otherwise.\n\nThe following actions are explicitly forbidden:\n\n * Insulting, demeaning, hateful, or threatening remarks.\n * Discrimination based on age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.\n * Bullying or systematic harassment.\n * Unwelcome sexual advances.\n * Incitement to any of these.\n\n## Where does the Code of Conduct apply?\n\nIf you participate in or contribute to the Elixir ecosystem in any way, you are encouraged to follow the Code of Conduct while doing so.\n\nExplicit enforcement of the Code of Conduct applies to the official mediums operated by the Elixir project:\n\n * The [official GitHub projects][1] and code reviews.\n * The official elixir-lang mailing lists.\n * The **[#elixir][2]** IRC channel on [Libera.Chat][3].\n\nOther 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.\n\nProject 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.\n\nInstances of abusive, harassing, or otherwise unacceptable behavior may be reported by emailing: . 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**.\n\n**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.\n\n## Acknowledgements\n\nThis document was based on the Code of Conduct from the Go project (dated Sep/2021) and the Contributor Covenant (v1.4).\n\n[1]: https://github.com/elixir-lang/\n[2]: https://web.libera.chat/#elixir\n[3]: https://libera.chat/\n" }, { "path": "CONTRIBUTING.md", "content": "\n\n# Contributing to Elixir\n\nWe invite contributions to Elixir. To contribute, there are a few\nthings you need to know about the code. First, Elixir code is divided\nby each application inside the `lib` folder:\n\n * `elixir` - Elixir's kernel and standard library\n\n * `eex` - EEx is the template engine that allows you to embed Elixir\n\n * `ex_unit` - ExUnit is a simple test framework that ships with Elixir\n\n * `iex` - IEx stands for Interactive Elixir: Elixir's interactive shell\n\n * `logger` - Logger is the built-in logger\n\n * `mix` - Mix is Elixir's build tool\n\nYou can run all tests in the root directory with `make test`. You can\nalso run tests for a specific framework with `make test_#{APPLICATION}`, for example,\n`make test_ex_unit`. If you just changed something in Elixir's standard\nlibrary, you can run only that portion through `make test_stdlib`.\n\nIf you are only changing one file, you can choose to compile and run tests\nfor that specific file for faster development cycles. For example, if you\nare changing the String module, you can compile it and run its tests as:\n\n```sh\nbin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin\nbin/elixir lib/elixir/test/elixir/string_test.exs\n```\n\nSome test files need their `test_helper.exs` to be explicitly required\nbefore, such as:\n\n```sh\nbin/elixir -r lib/logger/test/test_helper.exs lib/logger/test/logger_test.exs\n```\n\nYou can also use the `LINE` env var to run a single test:\n\n```sh\nLINE=123 bin/elixir lib/elixir/test/elixir/string_test.exs\n````\n\nTo recompile all (including Erlang modules):\n\n```sh\nmake compile\n```\n\nAfter your changes are done, please remember to run `make format` to guarantee\nall files are properly formatted, then run the full suite with\n`make test`.\n\nIf your contribution fails during the bootstrapping of the language,\nyou can rebuild the language from scratch with:\n\n```sh\nmake clean_elixir compile\n```\n\nSimilarly, if you can not get Elixir to compile or the tests to pass after\nupdating an existing checkout, run `make clean compile`. You can check\n[the official build status](https://github.com/elixir-lang/elixir/actions/workflows/ci.yml).\nMore tasks can be found by reading the [Makefile](Makefile).\n\nWe encourage contributors to write tests that capture both existing and newly\nintroduced behavior, especially for bug fixes and major changes:\n\n * **Bug Fixes:** If you are fixing a bug, please try to include a test that\n *fails* before your change and *passes* afterward. This makes it easier to\n confirm that the fix addresses the underlying issue and helps prevent\n regressions in the future.\n\n * **New Features or Major Changes:** If you are adding a new feature or making\n major changes to existing functionality, please add tests that cover the\n major parts of that functionality. Aim to have the best code coverage possible.\n\nWith tests running and passing, you are ready to contribute to Elixir and\n[send a pull request](https://help.github.com/articles/using-pull-requests/).\nWe have saved some excellent pull requests we have received in the past in\ncase you are looking for some examples:\n\n * [Implement Enum.member? - Pull request](https://github.com/elixir-lang/elixir/pull/992)\n\n * [Add String.valid? - Pull request](https://github.com/elixir-lang/elixir/pull/1058)\n\n * [Implement capture_io for ExUnit - Pull request](https://github.com/elixir-lang/elixir/pull/1059)\n\n## Reviewing changes\n\nOnce a pull request is sent, the Elixir team will review your changes.\nWe outline our process below to clarify the roles of everyone involved.\n\nAll pull requests must be approved by two committers before being merged into\nthe repository. If changes are necessary, the team will leave appropriate\ncomments requesting changes to the code. Unfortunately, we cannot guarantee a\npull request will be merged, even when modifications are requested, as the Elixir\nteam will re-evaluate the contribution as it changes.\n\nCommitters may also push style changes directly to your branch. If you would\nrather manage all changes yourself, you can disable the \"Allow edits from maintainers\"\nfeature when submitting your pull request.\n\nThe Elixir team may optionally assign someone to review a pull request.\nIf someone is assigned, they must explicitly approve the code before\nanother team member can merge it.\n\nWhen the review finishes, your pull request will be squashed and merged\ninto the repository. If you have carefully organized your commits and\nbelieve they should be merged without squashing, please mention it in\na comment.\n\n## Licensing and Compliance Requirements\n\nPlease review our [Open Source Policy](OPEN_SOURCE_POLICY.md) for complete\nguidelines on licensing and compliance. Below is a summary of the key points\naffecting **all external contributors**:\n\n * Accepted Licenses: Any code contributed must be licensed under the\n `Apache-2.0` license.\n\n * SPDX License Headers: With the exception of approved test fixture files,\n all new or modified files in a pull request must include correct SPDX\n headers. If you are creating a new file under the `Apache-2.0` license, for\n instance, please use:\n\n ```elixir\n # SPDX-License-Identifier: Apache-2.0\n # SPDX-FileCopyrightText: 2021 The Elixir Team\n ```\n\n * No Executable Binaries: Contributions must **not** include any executable\n binary files. If you require an exception (for example, certain test artifacts),\n please see the policy on how to request approval and document exceptions.\n\n * Preserving Copyright and License Info: If you copy code from elsewhere,\n ensure that **all original copyright and license notices remain intact**. If\n they are missing or incomplete, you must add them.\n\n * Failure to Comply: Pull requests that do not meet these licensing and\n compliance standards will be rejected or require modifications before merging.\n\n * Developer Certificate of Origin: All contributions are subject to the\n Developer Certificate of Origin.\n\n ```text\n By making a contribution to this project, I certify that:\n\n (a) The contribution was created in whole or in part by me and I\n have the right to submit it under the open source license\n indicated in the file; or\n\n (b) The contribution is based upon previous work that, to the \n best of my knowledge, is covered under an appropriate open \n source license and I have the right under that license to \n submit that work with modifications, whether created in whole\n or in part by me, under the same open source license (unless\n I am permitted to submit under a different license), as \n Indicated in the file; or\n\n (c) The contribution was provided directly to me by some other\n person who certified (a), (b) or (c) and I have not modified\n it.\n\n (d) I understand and agree that this project and the contribution\n are public and that a record of the contribution (including \n all personal information I submit with it, including my\n sign-off) is maintained indefinitely and may be redistributed\n consistent with this project or the open source license(s)\n involved.\n ```\n\n See for a copy of the Developer Certificate\n of Origin license.\n\n## Building documentation\n\nBuilding the documentation requires that [ExDoc](https://github.com/elixir-lang/ex_doc)\nis installed and built alongside Elixir.\n\nAfter cloning and compiling Elixir, run:\n\n```sh\nelixir_dir=$(pwd)\ncd .. && git clone https://github.com/elixir-lang/ex_doc.git\ncd ex_doc && \"${elixir_dir}/bin/elixir\" \"${elixir_dir}/bin/mix\" do deps.get + compile\n\n# Now we will go back to Elixir's root directory,\ncd \"${elixir_dir}\"\n\n# and generate HTML and EPUB documents:\nmake docs\n```\n\nThis will produce documentation sets for `elixir`, `eex`, `ex_unit`, `iex`, `logger`,\nand `mix` under the `doc` directory. If you are planning to contribute documentation,\n[please check our best practices for writing documentation](https://hexdocs.pm/elixir/writing-documentation.html).\n" }, { "path": "LICENSE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n" }, { "path": "LICENSES/Apache-2.0.txt", "content": "Apache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n\"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n\"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n\"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.\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n\"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n\"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.\n\n\"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).\n\n\"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.\n\n\"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.\"\n\n\"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.\n\n2. 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.\n\n3. 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.\n\n4. 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:\n\n (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n (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\n\n (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.\n\n 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.\n\n5. 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.\n\n6. 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.\n\n7. 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.\n\n8. 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.\n\n9. 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.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\nTo 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.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n" }, { "path": "LICENSES/LicenseRef-elixir-trademark-policy.txt", "content": "ELIXIR TEAM TRADEMARKS POLICY\n\nThis document outlines the policy for allowed usage of the “Elixir” word and the\nElixir logo by other parties.\n\n“Elixir” and the Elixir logo are registered trademarks of the Elixir Team. The\nElixir Team believes in a decentralized approach to growing the community and\nthe ecosystem, independent of the Elixir project and the Elixir Team.\n\nAnyone can use the Elixir trademarks if that use of the trademark is nominative.\nThe trademarks must not be used to disparage the project and its community, nor\nbe used in any way to imply ownership, endorsement, or association with the\nElixir project and the Elixir Team.\n\nYou must not visually combine the Elixir logo with any other images, or change\nthe logo in any way other than ways required by printing restrictions. If you\nwant to create your own visual identity in relation to Elixir, you might use the\nshape of an unrelated “water drop” as part of your design, as seen in many\ncommunity projects and initiatives. You must not combine or modify the Elixir\nlogo.\n\nThe Elixir logo is available in our repository in both vertical and horizontal\nversions.\n\nNominative use\nThe “nominative use” (or “nominative fair use”) is a legal doctrine that\nauthorizes everyone (even commercial companies) to use or refer to the trademark\nof another if:\n\nThe product or service in question must be one not readily identifiable without\nuse of the trademark.\n\nOnly so much of the mark or marks may be used as is reasonably necessary to\nidentify the product or service.\n\nThe organization using the mark must do nothing that would, in conjunction with\nthe mark, suggest sponsorship or endorsement by the trademark holder.\n\nOur trademarks must be used to refer to the Elixir programming language.\n\nExamples of permitted use\nAll examples listed next must strictly adhere to the terms outlined in the\nprevious sections:\n\nUsage of the Elixir logo to say a technology is “powered by Elixir” under\nnominative use. Linking back to the Elixir website, if possible, is appreciated.\n\nUsage of the Elixir logo to display it as a supported technology in a service or\nplatform. For instance, you may say “we support Elixir” and use the Elixir logo,\nbut you may not refer to yourself as “the Elixir platform” nor imply any form of\nendorsement or association with Elixir.\n\nUsage of the Elixir logo in non-commercial community meetups, in presentations,\nand in courses when referring to the language and its ecosystem under nominative\nuse.\n\nUsage of the Elixir logo in non-commercial swag (stickers, t-shirts, mugs, etc)\nto promote the Elixir programming language. The Elixir marks must be the only\nmarks featured in the product. You need permission to make swag that include\nElixir and other third party marks in them.\n\nInclusion of the Elixir logo in non-commercial icon sets. Use of the Elixir\nicons must still adhere to Elixir’s trademark policies.\n\nUsage of the “Elixir” word in book titles, meetups, conferences, and podcasts.\nYou must not use the word to imply uniqueness or endorsement from the Elixir\nteam. “The Elixir book” and “The Elixir podcast” are not permitted.\n“Elixir in Action”, “Thinking Elixir”, and “Kraków Elixir User Group” are valid\nexamples already in use today.\n\nUsage of the “Elixir” word in the names of freely distributed software and\nhardware products is allowed when referring to use with or suitability for the\nElixir programming language, such as wxElixir, Elixirsense, etc. If the product\nincludes the Elixir programming language itself, then you must also respect its\nlicense.\n\nExamples of not permitted use\nHere is a non-exhaustive list of non permitted uses of the marks:\n\nUsage of the Elixir logo in book covers, conferences, and podcasts.\n\nUsage of the Elixir logo as the mark of third party projects, even in combination\nwith other marks.\n\nNaming any company or product after Elixir, such as “The Elixir Hosting”,\n“The Elixir Consultants”, etc.\n\nExamples that require permission\nHere are some examples that may be granted permission upon request:\n\nSelling merchandise (stickers, t-shirts, mugs, etc).\nYou can request permission by emailing trademarks@elixir-lang.org.\n\nImportant note\nNothing in this page shall be interpreted to allow any third party to claim any\nassociation with the Elixir project and the Elixir Team, or to imply any\napproval or support by the Elixir project and the Elixir Team for any third\nparty products, services, or events.\n" }, { "path": "LICENSES/LicenseRef-scancode-unicode.txt", "content": "UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE\n\nUnicode Data Files include all data files under the directories\nhttp://www.unicode.org/Public/, http://www.unicode.org/reports/, and\nhttp://www.unicode.org/cldr/data/ . Unicode Software includes any source\ncode published in the Unicode Standard or under the directories\nhttp://www.unicode.org/Public/, http://www.unicode.org/reports/, and\nhttp://www.unicode.org/cldr/data/.\n\nNOTICE TO USER: Carefully read the following legal agreement. BY\nDOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA\nFILES (\"DATA FILES\"), AND/OR SOFTWARE (\"SOFTWARE\"), YOU UNEQUIVOCALLY\nACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS\nAGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE\nOR USE THE DATA FILES OR SOFTWARE.\n\nCOPYRIGHT AND PERMISSION NOTICE\n\nCopyright © Unicode, Inc. All rights reserved. Distributed under\nthe Terms of Use in http://www.unicode.org/copyright.html.\n\nPermission is hereby granted, free of charge, to any person obtaining a\ncopy of the Unicode data files and any associated documentation (the\n\"Data Files\") or Unicode software and any associated documentation (the\n\"Software\") to deal in the Data Files or Software without restriction,\nincluding without limitation the rights to use, copy, modify, merge,\npublish, distribute, and/or sell copies of the Data Files or Software,\nand to permit persons to whom the Data Files or Software are furnished\nto do so, provided that\n\n(a) the above copyright notice(s) and this permission notice appear with\nall copies of the Data Files or Software,\n\n(b) both the above copyright notice(s) and this permission notice appear\nin associated documentation, and\n\n(c) there is clear notice in each modified Data File or in the Software\nas well as in the documentation associated with the Data File(s) or\nSoftware that the data or software has been modified.\n\nTHE DATA FILES AND SOFTWARE ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE\nWARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT\nHOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR\nANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER\nRESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF\nCONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN\nCONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.\n\nExcept as contained in this notice, the name of a copyright holder shall\nnot be used in advertising or otherwise to promote the sale, use or\nother dealings in these Data Files or Software without prior written\nauthorization of the copyright holder.\n\nUnicode and the Unicode logo are trademarks of Unicode, Inc., and may be\nregistered in some jurisdictions. All other trademarks and registered\ntrademarks mentioned herein are the property of their respective owners.\n" }, { "path": "Makefile", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nPREFIX ?= /usr/local\nTEST_FILES ?= \"*_test.exs\"\nSHARE_PREFIX ?= $(PREFIX)/share\nMAN_PREFIX ?= $(SHARE_PREFIX)/man\nCANONICAL := main/\nELIXIRC := bin/elixirc --ignore-module-conflict $(ELIXIRC_OPTS)\nELIXIRC_MIN_SIG := $(ELIXIRC) -e 'Code.put_compiler_option :infer_signatures, []'\nERLC := erlc -I lib/elixir/include\nERL_MAKE := erl -make\nERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin\nGENERATE_APP := $(CURDIR)/lib/elixir/scripts/generate_app.escript\nVERSION := $(strip $(shell cat VERSION))\nQ := @\nLIBDIR := lib\nBINDIR := bin\nINSTALL = install\nINSTALL_DIR = $(INSTALL) -m755 -d\nINSTALL_DATA = $(INSTALL) -m644\nINSTALL_PROGRAM = $(INSTALL) -m755\nGIT_REVISION = $(strip $(shell git rev-parse HEAD 2> /dev/null ))\nGIT_TAG = $(strip $(shell head=\"$(call GIT_REVISION)\"; git tag --points-at $$head 2> /dev/null | grep -v latest | tail -1))\nSOURCE_DATE_EPOCH_PATH = lib/elixir/tmp/ebin_reproducible\nSOURCE_DATE_EPOCH_FILE = $(SOURCE_DATE_EPOCH_PATH)/SOURCE_DATE_EPOCH\n\n.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\n.NOTPARALLEL:\n\n#==> Functions\n\ndefine CHECK_ERLANG_RELEASE\n\terl -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'; \\\n\t\tif [ $$? != 0 ]; then \\\n\t\t echo \"At least Erlang/OTP 27.0 is required to build Elixir\"; \\\n\t\t exit 1; \\\n\t\tfi\nendef\n\ndefine APP_TEMPLATE\n$(1): lib/$(1)/ebin/Elixir.$(2).beam lib/$(1)/ebin/$(1).app\n\nlib/$(1)/ebin/$(1).app: lib/$(1)/mix.exs\n\t$(Q) cd lib/$(1) && ../../bin/elixir -e 'Mix.start(:permanent, [])' -r mix.exs -e 'Mix.Task.run(\"compile.app\", ~w[--compile-path ebin])'\n\nlib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1)/lib/*/*.ex) $(wildcard lib/$(1)/lib/*/*/*.ex)\n\t@ echo \"==> $(1) (compile)\"\n\t@ rm -rf lib/$(1)/ebin\n\t$(Q) cd lib/$(1) && ../../$$(ELIXIRC) \"lib/**/*.ex\" -o ebin\n\ntest_$(1): test_formatted $(1)\n\t@ echo \"==> $(1) (ex_unit)\"\n\t$(Q) cd lib/$(1) && ../../bin/elixir -r \"test/test_helper.exs\" -pr \"test/**/$(TEST_FILES)\";\n\ncover/ex_unit_$(1).coverdata:\n\t$(Q) COVER=\"1\" $(MAKE) test_$(1)\ncover/combined.coverdata: cover/ex_unit_$(1).coverdata\nendef\n\ndefine WRITE_SOURCE_DATE_EPOCH\n$(shell mkdir -p $(SOURCE_DATE_EPOCH_PATH) && bin/elixir -e \\\n 'IO.puts System.build_info()[:date] \\\n |> DateTime.from_iso8601() \\\n |> elem(1) \\\n |> DateTime.to_unix()' > $(SOURCE_DATE_EPOCH_FILE))\nendef\n\ndefine READ_SOURCE_DATE_EPOCH\n$(strip $(shell cat $(SOURCE_DATE_EPOCH_FILE)))\nendef\n\n#==> Compilation tasks\n\nAPP := lib/elixir/ebin/elixir.app\nEEX := lib/eex/ebin/Elixir.EEx.beam\nELIXIR := lib/elixir/ebin/elixir.beam\nPARSER := lib/elixir/src/elixir_parser.erl\nKERNEL := lib/elixir/ebin/Elixir.Kernel.beam\nUNICODE := lib/elixir/ebin/Elixir.String.Unicode.beam\n\ndefault: compile\n\ncompile: erlang elixir\n\nerlang: $(ELIXIR)\n$(ELIXIR): $(PARSER) lib/elixir/src/*\n\t$(Q) if [ ! -f $(APP) ]; then $(call CHECK_ERLANG_RELEASE); fi\n\t$(Q) cd lib/elixir && mkdir -p ebin && $(ERL_MAKE)\n\t$(Q) $(GENERATE_APP) $(VERSION)\n\n$(PARSER): lib/elixir/src/elixir_parser.yrl\n\t$(Q) erlc -o $@ +'{verbose,true}' +'{report,true}' $<\n\n# Since Mix depends on EEx and EEx depends on Mix,\n# we first compile EEx without the .app file,\n# then Mix, and then compile EEx fully\nelixir: stdlib $(EEX) mix ex_unit logger eex iex\nstdlib: $(KERNEL) $(UNICODE) $(APP)\n\n$(KERNEL): lib/elixir/src/* lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex VERSION\n\t$(Q) if [ ! -f $(KERNEL) ]; then \\\n\t\techo \"==> bootstrap (compile)\"; \\\n\t\t$(ERL) -s elixir_compiler bootstrap -s erlang halt; \\\n\t\t\"$(MAKE)\" unicode; \\\n\tfi\n\t@ echo \"==> elixir (compile)\";\n\t$(Q) cd lib/elixir && ../../$(ELIXIRC_MIN_SIG) \"lib/**/*.ex\" -o ebin;\n\t$(Q) $(GENERATE_APP) $(VERSION)\n\t$(Q) bin/elixir lib/elixir/scripts/infer.exs;\n\n$(APP): lib/elixir/src/elixir.app.src $(GENERATE_APP)\n\t$(Q) $(GENERATE_APP) $(VERSION)\n\nunicode: $(UNICODE)\n$(UNICODE): lib/elixir/unicode/*\n\t@ echo \"==> unicode (compile)\";\n\t$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/unicode.ex -o lib/elixir/ebin;\n\t$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/tokenizer.ex -o lib/elixir/ebin;\n\t$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/security.ex -o lib/elixir/ebin;\n\n$(eval $(call APP_TEMPLATE,ex_unit,ExUnit))\n$(eval $(call APP_TEMPLATE,logger,Logger))\n$(eval $(call APP_TEMPLATE,eex,EEx))\n$(eval $(call APP_TEMPLATE,mix,Mix))\n$(eval $(call APP_TEMPLATE,iex,IEx))\n\ninstall: compile\n\t@ echo \"==> elixir (install)\"\n\t$(Q) for dir in lib/*; do \\\n\t\trm -rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \\\n\t\t$(INSTALL_DIR) \"$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin\"; \\\n\t\t$(INSTALL_DATA) $$dir/ebin/* \"$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin\"; \\\n\tdone\n\t$(Q) $(INSTALL_DIR) \"$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin\"\n\t$(Q) $(INSTALL_PROGRAM) $(filter-out %.ps1, $(filter-out %.bat, $(wildcard bin/*))) \"$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin\"\n\t$(Q) $(INSTALL_DIR) \"$(DESTDIR)$(PREFIX)/$(BINDIR)\"\n\t$(Q) for file in \"$(DESTDIR)$(PREFIX)\"/$(LIBDIR)/elixir/bin/*; do \\\n\t\tln -sf \"../$(LIBDIR)/elixir/bin/$${file##*/}\" \"$(DESTDIR)$(PREFIX)/$(BINDIR)/\"; \\\n\tdone\n\t\"$(MAKE)\" install_man\n\ncheck_reproducible: compile\n\t$(Q) echo \"==> Checking for reproducible builds...\"\n\t$(Q) rm -rf lib/*/tmp/ebin_reproducible/\n\t$(call WRITE_SOURCE_DATE_EPOCH)\n\t$(Q) mkdir -p lib/elixir/tmp/ebin_reproducible/ \\\n\t lib/eex/tmp/ebin_reproducible/ \\\n\t lib/ex_unit/tmp/ebin_reproducible/ \\\n\t lib/iex/tmp/ebin_reproducible/ \\\n\t lib/logger/tmp/ebin_reproducible/ \\\n\t lib/mix/tmp/ebin_reproducible/\n\t$(Q) mv lib/elixir/ebin/* lib/elixir/tmp/ebin_reproducible/\n\t$(Q) mv lib/eex/ebin/* lib/eex/tmp/ebin_reproducible/\n\t$(Q) mv lib/ex_unit/ebin/* lib/ex_unit/tmp/ebin_reproducible/\n\t$(Q) mv lib/iex/ebin/* lib/iex/tmp/ebin_reproducible/\n\t$(Q) mv lib/logger/ebin/* lib/logger/tmp/ebin_reproducible/\n\t$(Q) mv lib/mix/ebin/* lib/mix/tmp/ebin_reproducible/\n\t$(Q) rm -rf lib/*/ebin\n\tSOURCE_DATE_EPOCH=$(call READ_SOURCE_DATE_EPOCH) \"$(MAKE)\" compile\n\t$(Q) echo \"Diffing...\"\n\t$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/elixir/ebin/ lib/elixir/tmp/ebin_reproducible/\n\t$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/eex/ebin/ lib/eex/tmp/ebin_reproducible/\n\t$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/ex_unit/ebin/ lib/ex_unit/tmp/ebin_reproducible/\n\t$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/iex/ebin/ lib/iex/tmp/ebin_reproducible/\n\t$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/logger/ebin/ lib/logger/tmp/ebin_reproducible/\n\t$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/mix/ebin/ lib/mix/tmp/ebin_reproducible/\n\t$(Q) echo \"Builds are reproducible\"\n\nclean: clean_man\n\trm -rf ebin\n\trm -rf lib/*/ebin\n\trm -rf $(PARSER)\n\trm -rf lib/*/_build/\n\trm -rf lib/*/tmp/\n\trm -rf lib/elixir/test/ebin/\n\trm -rf lib/mix/test/fixtures/deps_on_git_repo/\n\trm -rf lib/mix/test/fixtures/git_rebar/\n\trm -rf lib/mix/test/fixtures/git_repo/\n\trm -rf lib/mix/test/fixtures/git_sparse_repo/\n\trm -rf lib/mix/test/fixtures/archive/ebin/\n\trm -f erl_crash.dump\n\trm -rf cover\n\nclean_elixir:\n\t$(Q) rm -f lib/*/ebin/Elixir.*.beam\n\n#==> Documentation tasks\n\nSOURCE_REF = $(shell tag=\"$(call GIT_TAG)\" revision=\"$(call GIT_REVISION)\"; echo \"$${tag:-$$revision}\")\nDOCS_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://hexdocs.pm/$(2)/$(CANONICAL)\" --homepage-url \"https://elixir-lang.org/docs.html\" $(DOCS_OPTIONS) $(4)\nDOCS_CONFIG = bin/elixir lib/elixir/scripts/docs_config.exs \"$(1)\"\n\ndocs: compile ../ex_doc/bin/ex_doc docs_elixir docs_eex docs_mix docs_iex docs_ex_unit docs_logger\n\ndocs_elixir: compile ../ex_doc/bin/ex_doc\n\t@ echo \"==> ex_doc (elixir)\"\n\t$(Q) rm -rf doc/elixir\n\t$(call DOCS_COMPILE,Elixir,elixir,Kernel,--config \"lib/elixir/scripts/elixir_docs.exs\")\n\t$(call DOCS_CONFIG,elixir)\n\ndocs_eex: compile ../ex_doc/bin/ex_doc\n\t@ echo \"==> ex_doc (eex)\"\n\t$(Q) rm -rf doc/eex\n\t$(call DOCS_COMPILE,EEx,eex,EEx,--config \"lib/elixir/scripts/mix_docs.exs\")\n\t$(call DOCS_CONFIG,eex)\n\ndocs_mix: compile ../ex_doc/bin/ex_doc\n\t@ echo \"==> ex_doc (mix)\"\n\t$(Q) rm -rf doc/mix\n\t$(call DOCS_COMPILE,Mix,mix,Mix,--config \"lib/elixir/scripts/mix_docs.exs\")\n\t$(call DOCS_CONFIG,mix)\n\ndocs_iex: compile ../ex_doc/bin/ex_doc\n\t@ echo \"==> ex_doc (iex)\"\n\t$(Q) rm -rf doc/iex\n\t$(call DOCS_COMPILE,IEx,iex,IEx,--config \"lib/elixir/scripts/mix_docs.exs\")\n\t$(call DOCS_CONFIG,iex)\n\ndocs_ex_unit: compile ../ex_doc/bin/ex_doc\n\t@ echo \"==> ex_doc (ex_unit)\"\n\t$(Q) rm -rf doc/ex_unit\n\t$(call DOCS_COMPILE,ExUnit,ex_unit,ExUnit,--config \"lib/elixir/scripts/mix_docs.exs\")\n\t$(call DOCS_CONFIG,ex_unit)\n\ndocs_logger: compile ../ex_doc/bin/ex_doc\n\t@ echo \"==> ex_doc (logger)\"\n\t$(Q) rm -rf doc/logger\n\t$(call DOCS_COMPILE,Logger,logger,Logger,--config \"lib/elixir/scripts/mix_docs.exs\")\n\t$(call DOCS_CONFIG,logger)\n\n../ex_doc/bin/ex_doc:\n\t@ echo \"ex_doc is not found in ../ex_doc as expected. See CONTRIBUTING.md for more information.\"\n\t@ false\n\n#==> Zip tasks\n\nDocs.zip: docs\n\trm -f Docs.zip\n\tzip -9 -r Docs.zip CHANGELOG.md doc LICENSE README.md\n\t@ echo \"Docs file created $(CURDIR)/Docs.zip\"\n\nPrecompiled.zip: build_man compile\n\trm -f Precompiled.zip\n\tzip -9 -r Precompiled.zip bin CHANGELOG.md lib/*/ebin lib/*/lib LICENSE Makefile man README.md VERSION\n\t@ echo \"Precompiled file created $(CURDIR)/Precompiled.zip\"\n\n#==> Test tasks\n\ntest: test_formatted test_erlang test_elixir\n\ntest_windows: test test_taskkill\n\ntest_taskkill:\n\ttaskkill //IM erl.exe //F //T //FI \"MEMUSAGE gt 0\"\n\ttaskkill //IM epmd.exe //F //T //FI \"MEMUSAGE gt 0\"\n\nTEST_ERL = lib/elixir/test/erlang\nTEST_EBIN = lib/elixir/test/ebin\nTEST_ERLS = $(addprefix $(TEST_EBIN)/, $(addsuffix .beam, $(basename $(notdir $(wildcard $(TEST_ERL)/*.erl)))))\n\ndefine FORMAT\n\t$(Q) if [ \"$(OS)\" = \"Windows_NT\" ]; then \\\n\t\tcmd //C call ./bin/mix.bat format $(1); \\\n\telse \\\n\t\tbin/elixir bin/mix format $(1); \\\n\tfi\nendef\n\nformat: compile\n\t$(call FORMAT)\n\ntest_formatted: compile\n\t$(call FORMAT,--check-formatted)\n\ntest_erlang: compile $(TEST_ERLS)\n\t@ echo \"==> elixir (eunit)\"\n\t$(Q) $(ERL) -pa $(TEST_EBIN) -s test_helper test;\n\t@ echo \"\"\n\n$(TEST_EBIN)/%.beam: $(TEST_ERL)/%.erl\n\t$(Q) mkdir -p $(TEST_EBIN)\n\t$(Q) $(ERLC) -o $(TEST_EBIN) $<\n\ntest_elixir: test_stdlib test_ex_unit test_logger test_eex test_iex test_mix\n\ntest_stdlib: compile\n\t@ echo \"==> elixir (ex_unit)\"\n\t$(Q) exec epmd & exit\n\t$(Q) if [ \"$(OS)\" = \"Windows_NT\" ]; then \\\n\t\tcd lib/elixir && cmd //C call ../../bin/elixir.bat --sname primary -r \"test/elixir/test_helper.exs\" -pr \"test/elixir/**/$(TEST_FILES)\"; \\\n\telse \\\n\t\tcd lib/elixir && ../../bin/elixir --sname primary -r \"test/elixir/test_helper.exs\" -pr \"test/elixir/**/$(TEST_FILES)\"; \\\n\tfi\n\ncover/ex_unit_elixir.coverdata:\n\t$(Q) COVER=\"1\" $(MAKE) test_stdlib\ncover/combined.coverdata: cover/ex_unit_elixir.coverdata\n\ncover/combined.coverdata:\n\tbin/elixir ./lib/elixir/scripts/cover.exs\n\ncover: cover/combined.coverdata\n\n#==> Dialyzer tasks\n\nDIALYZER_OPTS = --no_check_plt --fullpath -Werror_handling -Wunmatched_returns -Wunderspecs\nPLT = .elixir.plt\n\n$(PLT):\n\t@ echo \"==> Building PLT with Elixir's dependencies...\"\n\t$(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\n\nclean_plt:\n\t$(Q) rm -f $(PLT)\n\nbuild_plt: clean_plt $(PLT)\n\ndialyze: compile $(PLT)\n\t@ echo \"==> Dialyzing Elixir...\"\n\t$(Q) dialyzer -pa lib/elixir/ebin --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin\n\n#==> Man page tasks\n\nbuild_man: man/iex.1 man/elixir.1\n\ndefine BUILD_MANPAGES\nman/$(APP).1:\n\t$(Q) cp man/$(APP).1.in man/$(APP).1\n\t$(Q) sed -i.bak \"/{COMMON}/r man/common\" man/$(APP).1\n\t$(Q) sed -i.bak \"/{COMMON}/d\" man/$(APP).1\n\t$(Q) rm -f man/$(APP).1.bak\nendef\n\n$(foreach APP, elixir iex, $(eval $(BUILD_MANPAGES)))\n\nclean_man:\n\trm -f man/elixir.1\n\trm -f man/elixir.1.bak\n\trm -f man/iex.1\n\trm -f man/iex.1.bak\n\ninstall_man: build_man\n\t$(Q) mkdir -p $(DESTDIR)$(MAN_PREFIX)/man1\n\t$(Q) $(INSTALL_DATA) man/elixir.1 $(DESTDIR)$(MAN_PREFIX)/man1\n\t$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(MAN_PREFIX)/man1\n\t$(Q) $(INSTALL_DATA) man/iex.1 $(DESTDIR)$(MAN_PREFIX)/man1\n\t$(Q) $(INSTALL_DATA) man/mix.1 $(DESTDIR)$(MAN_PREFIX)/man1\n\t\"$(MAKE)\" clean_man\n" }, { "path": "OPEN_SOURCE_POLICY.md", "content": "\n\n# Open Source Policy\n\n## 1. Introduction\n\nThis Open Source Policy outlines the licensing, contribution, and compliance\nrequirements for all code released under the Elixir project. By adhering to\nthese guidelines, we ensure that our community, maintainers, and contributors\nuphold both legal and ethical standards while fostering a collaborative,\ntransparent environment.\n\nThis policy exists to support and protect the Elixir community. It aims to\nbalance openness, collaboration, and respect for all contributors’ rights,\nensuring that Elixir remains a trusted and innovative open source project.\n\n## 2. Scope\n\nThis policy applies to the Elixir Programming language, located at\n. It covers every file, and contribution\nmade, including documentation and any associated assets.\n\n## 3. Licensing\n\nAll code released by the Elixir team is licensed under the\n[Apache-2.0](./LICENSES/Apache-2.0.txt) license. Additionally, the following\nlicenses are recognized as permissible in this project:\n\n - The Unicode license, as documented at\n [LicenseRef-scancode-unicode](./LICENSES/LicenseRef-scancode-unicode.txt)\n\n - The Elixir Trademark Policy, as documented at\n [LicenseRef-elixir-trademark-policy](./LICENSES/LicenseRef-elixir-trademark-policy.txt)\n\nThese licenses are considered acceptable for any files or code that form part of\nan Elixir repository. If a contribution requires a different license, it must\neither be rejected or prompt an update to this policy.\n\n## 4. Contributing to the Elixir repository\n\nAny code contributed to the Elixir repository must fall under one of the accepted\nlicenses (Apache-2.0, Unicode, or Elixir Trademark). Contributions under any\nother license will be rejected unless this policy is formally revised to include\nthat license. All files except those specifically exempted (e.g., certain test\nfixture files) must contain SPDX license and copyright headers\n(`SPDX-License-Identifier` and `SPDX-FileCopyrightText`). If a file qualifies\nfor an exception, this must be configured in the ORT (Open Source Review Toolkit)\nconfiguration and undergo review.\n\nContributions must not introduce executable binary files into the codebase.\n\n## 5. Preservation of Copyright and License Information\n\nAny third-party code incorporated into the Elixir repository must retain original\ncopyright and license headers. If no such headers exist in the source, they must\nbe added. This practice ensures that original authors receive proper credit and\nthat the licensing lineage is preserved.\n\n## 6. Objectives\n\nThe Elixir project aims to promote a culture of responsible open source usage.\nSpecifically, our objectives include:\n\n### 6.1 Clearly Define and Communicate Licensing & Compliance Policies\n\nWe will identify and document all third-party dependencies, ensure that license\ninformation is communicated clearly, and maintain a project-wide license policy\nor compliance handbook.\n\n### 6.2 Implement Clear Processes for Reviewing Contributions\n\nWe will provide well-defined contribution guidelines. We implement the\nDeveloper Certificate of Origin (DCO) for additional clarity regarding\ncontributor rights and obligations.\n\n### 6.3 Track and Audit Third-Party Code Usage\n\nAll projects will implement a Software Bill of Materials (SBoM) strategy and\nregularly verify license compliance for direct and transitive dependencies.\n\n### 6.4 Monitor and Continuously Improve Open Source Compliance\n\nWe will conduct periodic internal audits, integrate compliance checks into\ncontinuous integration (CI/CD) pipelines, and regularly review and refine these\nobjectives to align with best practices.\n\n## 7. Roles and Responsibilities\n\n### 7.1 Core Team Member\n\nCore Team Members are responsible for being familiar with this policy and\nensuring it is consistently enforced. They must demonstrate sufficient\ncompetencies to understand the policy requirements and must reject or request\nchanges to any pull requests that violate these standards.\n\n### 7.2 Contributor\n\nContributors are expected to follow this policy when submitting code. If a\ncontributor submits a pull request that does not comply with the policy\n(e.g., introduces a disallowed license), Core Team Members have the authority to\nreject it or request changes. No special competencies are required for\ncontributors beyond awareness and adherence to the policy.\n\n### 7.3 EEF CISO\n\nThe CISO designated by the Erlang Ecosystem Foundation (EEF) provides oversight\non queries and guidance regarding open source compliance or legal matters for\nElixir. The CISO is responsible for checking ongoing compliance with the policy,\nescalating potential violations to the Core Team, and involving legal counsel if\nnecessary. This role does not require legal expertise but does involve\ninitiating legal or community discussions when needed.\n\n## 8. Implications of Failing to Follow the Program Requirements\n\nIf a violation of this policy is identified, the Elixir Core Team will undertake\nthe following actions:\n\n## 8.1 Review the Codebase for Additional Violations\n\nWe will investigate the codebase thoroughly to detect any similar instances of\nnon-compliance.\n\n## 8.2 Review and Update the Process or Policy\n\nIn collaboration with the EEF CISO, the Elixir Core Team will assess the policy\nand our internal workflows, making any necessary clarifications or amendments to\nreduce the likelihood of recurrence.\n\n## 8.3 Notify and Train Core Team Members\n\nWe will ensure that all active Core Team Members are informed about any policy\nchanges and understand how to apply them in everyday development.\n\n## 8.4 Remove or Replace the Offending Code\n\nIf required, we will remove or replace the non-compliant code.\n\n## 9. Contact\n\nThe project maintains a private mailing list at\n[policy@elixir-lang.org](mailto:policy@elixir-lang.org) for handling licensing\nand policy-related queries. Email is the preferred communication channel, and\nthe EEF CISO will be included on this list to provide assistance and ensure\ntimely responses. While solutions may take longer to implement, the project\ncommits to acknowledging all queries within five business days.\n\n## 10. External Contributions of Core Team Members\n\nWhen Core Team Members contribute to repositories outside Elixir, they do so in\na personal capacity or via their employer. They will not act as official\nrepresentatives of the Elixir team in those external contexts.\n\n## 11. Policy Review and Amendments\n\nThis policy will be revisited annually to address new concerns, accommodate\nchanges in community standards, or adjust to emerging legal or technical\nrequirements. Proposed amendments must be reviewed by the Core Team and, if\nnecessary, by the EEF CISO. Any significant changes will be communicated to\ncontributors and made publicly available.\n\n*Effective Date: 2025-02-20* \n*Last Reviewed: 2025-11-20*\n" }, { "path": "README.md", "content": "\n\n

\n \n \n \"Elixir\n \n

\n\n[![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)\n[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/10187/badge)](https://www.bestpractices.dev/projects/10187)\n\nElixir is a dynamic, functional language designed for building scalable\nand maintainable applications.\n\nFor more about Elixir, installation and documentation,\n[check Elixir's website](https://elixir-lang.org/).\n\n## Policies\n\nNew releases are announced in the [announcement mailing list][8].\nYou can subscribe by sending an email to \nand replying to the confirmation email.\n\nAll security releases [will be tagged with `[security]`][10]. For more\ninformation, please read our [Security Policy][9].\n\nAll interactions in our official communication channels follow our\n[Code of Conduct][1].\n\nAll contributions are required to conform to our [Open Source Policy][11].\n\n## Bug reports\n\nFor reporting bugs, [visit our issue tracker][2] and follow the steps\nfor reporting a new issue. **Please disclose security vulnerabilities\nprivately [in our Security page](https://github.com/elixir-lang/elixir/security)**.\n\nAll currently open bugs related to Elixir are listed in the issues tracker.\nThe Elixir team uses the issues tracker to focus on *actionable items*,\nincluding planned enhancements in the short and medium term. We also do\nour best to label entries for clarity and to ease collaboration.\n\nOur *actionable item policy* has some important consequences, such as:\n\n * Proposing new features as well as requests for support, help, and\n guidance must be done in their own spaces, detailed next.\n\n * Issues we have identified to be outside of Elixir's scope,\n such as an upstream bug, will be closed (and requested to be moved\n elsewhere if appropriate).\n\n * We actively close unrelated and non-actionable issues to keep the\n issues tracker tidy. If you believe we got something wrong, drop a\n comment and we can always reopen the issue.\n\nBy keeping the overall issues tracker tidy and organized, the community\ncan easily peek at what is coming in new releases and also get involved\nby commenting on existing issues and submitting pull requests. Please\nremember to keep the tone positive and be kind! For more information,\nsee the [Code of Conduct][1].\n\n## Discussions, support, and help\n\nFor general discussions, support, and help, please use the community\nspaces [listed on the sidebar of the Elixir website](https://elixir-lang.org/),\nsuch as forums, chat platforms, etc, where the wider community will be available\nto help you.\n\n## Proposing new features\n\nWe encourage you to first propose new features in the community spaces\nlisted above. These discussions help refine ideas and gather feedback before\nsubmission. Our website also includes [a general outline of the language\nhistory and its current development focus](https://elixir-lang.org/development.html).\n\nOnce you are ready, you can submit your proposal to the [Elixir Core\nmailing list][3], either through the web interface or by subscribing to\nit at . Remember to include\na clear problem description, compare the proposed solution to existing\nalternatives in the Elixir ecosystem (and in other languages if possible),\nand consider the potential impact your changes will have on the codebase and\ncommunity.\n\nOnce a proposal is accepted, it will be added to [the issue tracker][2].\nFeatures and bug fixes that have already been merged and will be included\nin the next release are then \"closed\" and added to the [changelog][7]\nbefore release.\n\n## Compiling from source\n\nFor the many different ways to install Elixir,\n[see our installation instructions on the website](https://elixir-lang.org/install.html).\nHowever, if you want to contribute to Elixir, you will need to compile from source.\n\nFirst, [install Erlang](https://elixir-lang.org/install.html#installing-erlang).\nAfter that, clone this repository to your machine, compile and test it:\n\n```sh\ngit clone https://github.com/elixir-lang/elixir.git\ncd elixir\nmake\n```\n\n> Note: if you are running on Windows,\n[this article includes important notes for compiling Elixir from source\non Windows](https://github.com/elixir-lang/elixir/wiki/Windows).\n\nIn case you want to use this Elixir version as your system version,\nyou need to add the `bin` directory to [your PATH environment variable](https://elixir-lang.org/install.html#setting-path-environment-variable).\n\nWhen updating the repository, you may want to run `make clean` before\nrecompiling. For deterministic builds, you should set the environment\nvariable `ERL_COMPILER_OPTIONS=deterministic`.\n\n## Contributing\n\nContributions to Elixir are always welcome! Before you get started, please check\nout our [CONTRIBUTING.md](CONTRIBUTING.md) file. There you will find detailed\nguidelines on how to set up your environment, run the test suite, format your\ncode, and submit pull requests. We also include information on our review\nprocess, licensing requirements, and helpful tips to ensure a smooth\ncontribution experience.\n\n## Development links\n\n * [Elixir Documentation][6]\n * [Elixir Core Mailing list (development)][3]\n * [Announcement mailing list][8]\n * [Code of Conduct][1]\n * [Issue tracker][2]\n * [Changelog][7]\n * [Security Policy][9]\n * **[#elixir][4]** on [Libera.Chat][5] IRC\n\n [1]: CODE_OF_CONDUCT.md\n [2]: https://github.com/elixir-lang/elixir/issues\n [3]: https://groups.google.com/group/elixir-lang-core\n [4]: https://web.libera.chat/#elixir\n [5]: https://libera.chat\n [6]: https://elixir-lang.org/docs.html\n [7]: CHANGELOG.md\n [8]: https://groups.google.com/group/elixir-lang-ann\n [9]: SECURITY.md\n [10]: https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date\n [11]: OPEN_SOURCE_POLICY.md\n\n## License\n\n\"Elixir\" and the Elixir logo are registered trademarks of The Elixir Team.\n\nElixir source code is released under Apache License 2.0.\n\nCheck [LICENSE](LICENSE) file for more information.\n" }, { "path": "RELEASE.md", "content": "\n\n# Release process\n\n## Shipping a new version\n\n1. Update version in /VERSION, bin/elixir, and bin/elixir.bat\n\n2. Ensure /CHANGELOG.md is updated, versioned and add the current date\n\n3. Update \"Compatibility and Deprecations\" if a new OTP version is supported\n\n4. Commit changes above with title \"Release vVERSION\" and push it\n\n5. Once GitHub actions completes, generate a new tag, and push it\n\n6. Wait until GitHub Actions publish artifacts to the draft release\n\n7. Copy the relevant bits from /CHANGELOG.md to the GitHub release and publish it (link to the announcement if there is one)\n\n8. Update `_data/elixir-versions.yml` (except for RCs) in `elixir-lang/elixir-lang.github.com`\n\n## Creating a new vMAJOR.MINOR branch (usually before first rc)\n\n### In the new branch\n\n1. Comment out `CANONICAL := main/` in /Makefile\n\n2. Update tables in /SECURITY.md and \"Compatibility and Deprecations\"\n\n3. Commit \"Branch out vMAJOR.MINOR\"\n\n### Back in main\n\n1. Bump /VERSION file, bin/elixir, and bin/elixir.bat\n\n2. Start new /CHANGELOG.md\n\n3. Update tables in /SECURITY.md and in \"Compatibility and Deprecations\"\n\n4. Commit \"Start vMAJOR.MINOR+1\"\n\n## Changing supported Erlang/OTP versions\n\n1. Update the table in Compatibility and Deprecations\n\n2. Update `otp_release` checks in `/Makefile` and `/lib/elixir/src/elixir.erl`\n\n3. Update relevant CI workflows in `/.github/workflows/*.yml` - for release workflows, outdated/recently added Erlang/OTP versions must run conditionally\n\n4. Remove `otp_release` version checks that are no longer needed\n" }, { "path": "SECURITY.md", "content": "\n\n# Security Policy\n\n## Supported versions\n\nElixir applies bug fixes only to the latest minor branch. Security patches are available for the last 5 minor branches:\n\nElixir version | Support\n:------------- | :-----------------------------\n1.20 | Development\n1.19 | Bug fixes and security patches\n1.18 | Security patches only\n1.17 | Security patches only\n1.16 | Security patches only\n1.15 | Security patches only\n\n## Announcements\n\nNew 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 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).\n\nYou 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.\n\n## Reporting a vulnerability\n\n[Please disclose security vulnerabilities privately via GitHub](https://github.com/elixir-lang/elixir/security).\n" }, { "path": "VERSION", "content": "1.20.0-rc.3\n" }, { "path": "bin/elixir", "content": "#!/bin/sh\n\n# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nset -e\n\nELIXIR_VERSION=1.20.0-rc.3\n\nif [ $# -eq 0 ] || { [ $# -eq 1 ] && { [ \"$1\" = \"--help\" ] || [ \"$1\" = \"-h\" ]; }; }; then\n cat <&2\nUsage: $(basename \"$0\") [options] [.exs file] [data]\n\n## General options\n\n -e \"COMMAND\" Evaluates the given command (*)\n -h, --help Prints this message (standalone)\n -r \"FILE\" Requires the given files/patterns (*)\n -S SCRIPT Finds and executes the given script in \\$PATH\n -pr \"FILE\" Requires the given files/patterns in parallel (*)\n -pa \"PATH\" Prepends the given path to Erlang code path (*)\n -pz \"PATH\" Appends the given path to Erlang code path (*)\n -v, --version Prints Erlang/OTP and Elixir versions (standalone)\n\n --color, --no-color Enables or disables ANSI coloring\n --erl \"SWITCHES\" Switches to be passed down to Erlang (*)\n --eval \"COMMAND\" Evaluates the given command, same as -e (*)\n --logger-otp-reports BOOL Enables or disables OTP reporting\n --logger-sasl-reports BOOL Enables or disables SASL reporting\n --no-halt Does not halt the Erlang VM after execution\n --short-version Prints Elixir version (standalone)\n\nOptions given after the .exs file or -- are passed down to the executed code.\nOptions can be passed to the Erlang runtime using \\$ELIXIR_ERL_OPTIONS or --erl.\n\n## Distribution options\n\nThe following options are related to node distribution.\n\n --cookie COOKIE Sets a cookie for this distributed node\n --hidden Makes a hidden node\n --name NAME Makes and assigns a name to the distributed node\n --rpc-eval NODE \"COMMAND\" Evaluates the given command on the given remote node (*)\n --sname NAME Makes and assigns a short name to the distributed node\n\n--name and --sname may be set to undefined so one is automatically generated.\n\n## Release options\n\nThe following options are generally used under releases.\n\n --boot \"FILE\" Uses the given FILE.boot to start the system\n --boot-var VAR \"VALUE\" Makes \\$VAR available as VALUE to FILE.boot (*)\n --erl-config \"FILE\" Loads configuration in FILE.config written in Erlang (*)\n --pipe-to \"PIPEDIR\" \"LOGDIR\" Starts the Erlang VM as a named PIPEDIR and LOGDIR\n --vm-args \"FILE\" Passes the contents in file as arguments to the VM\n\n--pipe-to starts Elixir detached from console (Unix-like only).\nIt will attempt to create PIPEDIR and LOGDIR if they don't exist.\nSee run_erl to learn more. To reattach, run: to_erl PIPEDIR.\n\n** Options marked with (*) can be given more than once.\n** Standalone options can't be combined with other options.\nUSAGE\n exit 1\nfi\n\nreadlink_f () {\n cd \"$(dirname \"$1\")\" > /dev/null\n filename=\"$(basename \"$1\")\"\n if [ -h \"$filename\" ]; then\n readlink_f \"$(readlink \"$filename\")\"\n else\n echo \"$(pwd -P)/$filename\"\n fi\n}\n\nif [ $# -eq 1 ] && [ \"$1\" = \"--short-version\" ]; then\n echo \"$ELIXIR_VERSION\"\n exit 0\nfi\n\n# Stores static Erlang arguments and --erl (which is passed as is)\nERL=\"\"\n\n# Stores erl arguments preserving spaces/quotes (mimics an array)\nerl_set () {\n eval \"E${E}=\\$1\"\n E=$((E + 1))\n}\n\n# Checks if a string starts with prefix. Usage: starts_with \"$STRING\" \"$PREFIX\"\nstarts_with () {\n case $1 in\n \"$2\"*) true;;\n *) false;;\n esac\n}\n\nERL_EXEC=\"erl\"\nMODE=\"cli\"\nI=1\nE=0\nLENGTH=$#\nset -- \"$@\" -extra\n\nwhile [ $I -le $LENGTH ]; do\n # S counts to be shifted, C counts to be copied\n S=0\n C=0\n case \"$1\" in\n +elixirc)\n C=1\n ;;\n +iex)\n C=1\n MODE=\"iex\"\n ;;\n -v|--no-halt|--color|--no-color)\n C=1\n ;;\n -e|-r|-pr|-pa|-pz|--eval|--remsh|--dot-iex|--dbg)\n C=2\n ;;\n --rpc-eval)\n C=3\n ;;\n --hidden)\n S=1\n ERL=\"$ERL -hidden\"\n ;;\n --logger-otp-reports)\n S=2\n if [ \"$2\" = 'true' ] || [ \"$2\" = 'false' ]; then\n ERL=\"$ERL -logger handle_otp_reports $2\"\n fi\n ;;\n --logger-sasl-reports)\n S=2\n if [ \"$2\" = 'true' ] || [ \"$2\" = 'false' ]; then\n ERL=\"$ERL -logger handle_sasl_reports $2\"\n fi\n ;;\n --erl)\n S=2\n ERL=\"$ERL $2\"\n ;;\n --cookie)\n S=2\n erl_set \"-setcookie\"\n erl_set \"$2\"\n ;;\n --sname|--name)\n S=2\n erl_set \"$(echo \"$1\" | cut -c 2-)\"\n erl_set \"$2\"\n ;;\n --erl-config)\n S=2\n erl_set \"-config\"\n erl_set \"$2\"\n ;;\n --vm-args)\n S=2\n erl_set \"-args_file\"\n erl_set \"$2\"\n ;;\n --boot)\n S=2\n erl_set \"-boot\"\n erl_set \"$2\"\n ;;\n --boot-var)\n S=3\n erl_set \"-boot_var\"\n erl_set \"$2\"\n erl_set \"$3\"\n ;;\n --pipe-to)\n S=3\n RUN_ERL_PIPE=\"$2\"\n RUN_ERL_LOG=\"$3\"\n if [ \"$(starts_with \"$RUN_ERL_PIPE\" \"-\")\" ]; then\n echo \"--pipe-to : PIPEDIR cannot be a switch\" >&2 && exit 1\n elif [ \"$(starts_with \"$RUN_ERL_LOG\" \"-\")\" ]; then\n echo \"--pipe-to : LOGDIR cannot be a switch\" >&2 && exit 1\n fi\n ;;\n *)\n while [ $I -le $LENGTH ]; do\n I=$((I + 1))\n set -- \"$@\" \"$1\"\n shift\n done\n break\n ;;\n esac\n\n while [ $I -le $LENGTH ] && [ $C -gt 0 ]; do\n C=$((C - 1))\n I=$((I + 1))\n set -- \"$@\" \"$1\"\n shift\n done\n\n I=$((I + S))\n shift $S\ndone\n\nI=$((E - 1))\nwhile [ $I -ge 0 ]; do\n eval \"VAL=\\$E$I\"\n set -- \"$VAL\" \"$@\"\n I=$((I - 1))\ndone\n\nSELF=$(readlink_f \"$0\")\nSCRIPT_PATH=$(dirname \"$SELF\")\n\nif [ \"$OSTYPE\" = \"cygwin\" ]; then SCRIPT_PATH=$(cygpath -m \"$SCRIPT_PATH\"); fi\nif [ \"$MODE\" != \"iex\" ]; then ERL=\"-s elixir start_cli $ERL\"; fi\n\n# One MAY change ERTS_BIN= but you MUST NOT change\n# ERTS_BIN=$ERTS_BIN as it is handled by Elixir releases.\nERTS_BIN=\nERTS_BIN=\"$ERTS_BIN\"\n\nset -- \"$ERTS_BIN$ERL_EXEC\" -noshell -elixir_root \"$SCRIPT_PATH\"/../lib -pa \"$SCRIPT_PATH\"/../lib/elixir/ebin $ELIXIR_ERL_OPTIONS $ERL \"$@\"\n\nif [ -n \"$RUN_ERL_PIPE\" ]; then\n ESCAPED=\"\"\n for PART in \"$@\"; do\n ESCAPED=\"$ESCAPED $(printf '%s' \"$PART\" | sed 's@[^a-zA-Z0-9_/-]@\\\\&@g')\"\n done\n mkdir -p \"$RUN_ERL_PIPE\"\n mkdir -p \"$RUN_ERL_LOG\"\n ERL_EXEC=\"run_erl\"\n set -- \"$ERTS_BIN$ERL_EXEC\" -daemon \"$RUN_ERL_PIPE/\" \"$RUN_ERL_LOG/\" \"$ESCAPED\"\nfi\n\nif [ -n \"$ELIXIR_CLI_DRY_RUN\" ]; then\n echo \"$@\"\nelse\n exec \"$@\"\nfi\n" }, { "path": "bin/elixir.bat", "content": "@echo off\n\n:: SPDX-License-Identifier: Apache-2.0\n:: SPDX-FileCopyrightText: 2021 The Elixir Team\n:: SPDX-FileCopyrightText: 2012 Plataformatec\n\nset ELIXIR_VERSION=1.20.0-rc.3\n\nif \"\"%1\"\"==\"\"\"\" if \"\"%2\"\"==\"\"\"\" goto documentation\nif /I \"\"%1\"\"==\"\"--help\"\" if \"\"%2\"\"==\"\"\"\" goto documentation\nif /I \"\"%1\"\"==\"\"-h\"\" if \"\"%2\"\"==\"\"\"\" goto documentation\nif /I \"\"%1\"\"==\"\"/h\"\" if \"\"%2\"\"==\"\"\"\" goto documentation\nif \"\"%1\"\"==\"\"/?\"\" if \"\"%2\"\"==\"\"\"\" goto documentation\nif /I \"\"%1\"\"==\"\"--short-version\"\" if \"\"%2\"\"==\"\"\"\" goto shortversion\ngoto parseopts\n\n:documentation\necho Usage: %~nx0 [options] [.exs file] [data]\necho.\necho ## General options\necho.\necho -e \"COMMAND\" Evaluates the given command (*)\necho -h, --help Prints this message (standalone)\necho -r \"FILE\" Requires the given files/patterns (*)\necho -S SCRIPT Finds and executes the given script in $PATH\necho -pr \"FILE\" Requires the given files/patterns in parallel (*)\necho -pa \"PATH\" Prepends the given path to Erlang code path (*)\necho -pz \"PATH\" Appends the given path to Erlang code path (*)\necho -v, --version Prints Erlang/OTP and Elixir versions (standalone)\necho.\necho --color, --no-color Enables or disables ANSI coloring\necho --erl \"SWITCHES\" Switches to be passed down to Erlang (*)\necho --eval \"COMMAND\" Evaluates the given command, same as -e (*)\necho --logger-otp-reports BOOL Enables or disables OTP reporting\necho --logger-sasl-reports BOOL Enables or disables SASL reporting\necho --no-halt Does not halt the Erlang VM after execution\necho --short-version Prints Elixir version (standalone)\necho.\necho Options given after the .exs file or -- are passed down to the executed code.\necho Options can be passed to the Erlang runtime using $ELIXIR_ERL_OPTIONS or --erl.\necho.\necho ## Distribution options\necho.\necho The following options are related to node distribution.\necho.\necho --cookie COOKIE Sets a cookie for this distributed node\necho --hidden Makes a hidden node\necho --name NAME Makes and assigns a name to the distributed node\necho --rpc-eval NODE \"COMMAND\" Evaluates the given command on the given remote node (*)\necho --sname NAME Makes and assigns a short name to the distributed node\necho.\necho --name and --sname may be set to undefined so one is automatically generated.\necho.\necho ## Release options\necho.\necho The following options are generally used under releases.\necho.\necho --boot \"FILE\" Uses the given FILE.boot to start the system\necho --boot-var VAR \"VALUE\" Makes $VAR available as VALUE to FILE.boot (*)\necho --erl-config \"FILE\" Loads configuration in FILE.config written in Erlang (*)\necho --vm-args \"FILE\" Passes the contents in file as arguments to the VM\necho.\necho --pipe-to is not supported on Windows. If set, Elixir won't boot.\necho.\necho ** Options marked with (*) can be given more than once.\necho ** Standalone options can't be combined with other options.\ngoto end\n\n:shortversion\necho %ELIXIR_VERSION%\ngoto end\n\n:parseopts\nsetlocal enabledelayedexpansion\n\nrem Parameters for Erlang\nset parsErlang=\n\nrem Optional parameters before the \"-extra\" parameter\nset beforeExtra=\n\nrem Option which determines whether the loop is over\nset endLoop=0\n\nrem Designates the path to the current script\nset SCRIPT_PATH=%~dp0\n\nrem Designates the path to the ERTS system\nset ERTS_BIN=\nset ERTS_BIN=!ERTS_BIN!\n\nrem Recursive loop called for each parameter that parses the cmd line parameters\n:startloop\nset \"par=%~1\"\nif \"!par!\"==\"\" (\n rem skip if no parameter\n goto run\n)\nshift\nset par=\"!par:\"=\\\"!\"\nrem ******* EXECUTION OPTIONS **********************\nif !par!==\"+iex\" (set useIEx=1 && goto startloop)\nif !par!==\"+elixirc\" (goto startloop)\nrem ******* ELIXIR PARAMETERS **********************\nif \"\"==!par:-e=! (shift && goto startloop)\nif \"\"==!par:--eval=! (shift && goto startloop)\nif \"\"==!par:--rpc-eval=! (shift && shift && goto startloop)\nif \"\"==!par:-r=! (shift && goto startloop)\nif \"\"==!par:-pr=! (shift && goto startloop)\nif \"\"==!par:-pa=! (shift && goto startloop)\nif \"\"==!par:-pz=! (shift && goto startloop)\nif \"\"==!par:-v=! (goto startloop)\nif \"\"==!par:--version=! (goto startloop)\nif \"\"==!par:--no-halt=! (goto startloop)\nif \"\"==!par:--color=! (goto startloop)\nif \"\"==!par:--no-color=! (goto startloop)\nif \"\"==!par:--remsh=! (shift && goto startloop)\nif \"\"==!par:--dot-iex=! (shift && goto startloop)\nif \"\"==!par:--dbg=! (shift && goto startloop)\nrem ******* ERLANG PARAMETERS **********************\nif \"\"==!par:--boot=! (set \"parsErlang=!parsErlang! -boot \"%~1\"\" && shift && goto startloop)\nif \"\"==!par:--boot-var=! (set \"parsErlang=!parsErlang! -boot_var \"%~1\" \"%~2\"\" && shift && shift && goto startloop)\nif \"\"==!par:--cookie=! (set \"parsErlang=!parsErlang! -setcookie \"%~1\"\" && shift && goto startloop)\nif \"\"==!par:--hidden=! (set \"parsErlang=!parsErlang! -hidden\" && goto startloop)\nif \"\"==!par:--erl-config=! (set \"parsErlang=!parsErlang! -config \"%~1\"\" && shift && goto startloop)\nif \"\"==!par:--logger-otp-reports=! (set \"parsErlang=!parsErlang! -logger handle_otp_reports %1\" && shift && goto startloop)\nif \"\"==!par:--logger-sasl-reports=! (set \"parsErlang=!parsErlang! -logger handle_sasl_reports %1\" && shift && goto startloop)\nif \"\"==!par:--name=! (set \"parsErlang=!parsErlang! -name \"%~1\"\" && shift && goto startloop)\nif \"\"==!par:--sname=! (set \"parsErlang=!parsErlang! -sname \"%~1\"\" && shift && goto startloop)\nif \"\"==!par:--vm-args=! (set \"parsErlang=!parsErlang! -args_file \"%~1\"\" && shift && goto startloop)\nif \"\"==!par:--erl=! (set \"beforeExtra=!beforeExtra! %~1\" && shift && goto startloop)\nif \"\"==!par:--pipe-to=! (echo --pipe-to : Option is not supported on Windows && goto end)\n\n:run\nsetlocal disabledelayedexpansion\nif not defined useIEx (\n set beforeExtra=-s elixir start_cli %beforeExtra%\n)\n\nset beforeExtra=-noshell -elixir_root \"%SCRIPT_PATH%..\\lib\" -pa \"%SCRIPT_PATH%..\\lib\\elixir\\ebin\" %beforeExtra%\n\nif defined ELIXIR_CLI_DRY_RUN (\n echo \"%ERTS_BIN%erl.exe\" %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*\n) else (\n \"%ERTS_BIN%erl.exe\" %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*\n)\nexit /B %ERRORLEVEL%\n:end\nendlocal\n" }, { "path": "bin/elixirc", "content": "#!/bin/sh\n\n# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nset -e\n\nif [ $# -eq 0 ] || [ \"$1\" = \"--help\" ] || [ \"$1\" = \"-h\" ]; then\n cat <&2\nUsage: $(basename \"$0\") [elixir switches] [compiler switches] [.ex files]\n\n -h, --help Prints this message and exits\n -o The directory to output compiled files\n -v, --version Prints Elixir version and exits (standalone)\n\n --ignore-module-conflict Does not emit warnings if a module was previously defined\n --no-debug-info Does not attach debug info to compiled modules\n --no-docs Does not attach documentation to compiled modules\n --profile time Profile the time to compile modules\n --verbose Prints compilation status\n --warnings-as-errors Treats warnings as errors and return non-zero exit status\n\nOptions given after -- are passed down to the executed code.\nOptions can be passed to the Erlang runtime using \\$ELIXIR_ERL_OPTIONS.\nOptions can be passed to the Erlang compiler using \\$ERL_COMPILER_OPTIONS.\nUSAGE\n exit 1\nfi\n\nreadlink_f () {\n cd \"$(dirname \"$1\")\" > /dev/null\n filename=\"$(basename \"$1\")\"\n if [ -h \"$filename\" ]; then\n readlink_f \"$(readlink \"$filename\")\"\n else\n echo \"$(pwd -P)/$filename\"\n fi\n}\n\nSELF=$(readlink_f \"$0\")\nSCRIPT_PATH=$(dirname \"$SELF\")\nexec \"$SCRIPT_PATH\"/elixir +elixirc \"$@\"\n" }, { "path": "bin/elixirc.bat", "content": "@echo off\n\n:: SPDX-License-Identifier: Apache-2.0\n:: SPDX-FileCopyrightText: 2021 The Elixir Team\n:: SPDX-FileCopyrightText: 2012 Plataformatec\n\nsetlocal\nset argc=0\nfor %%A in (%*) do (\n if /I \"%%A\"==\"--help\" goto documentation\n if /I \"%%A\"==\"-h\" goto documentation\n if /I \"%%A\"==\"/h\" goto documentation\n if \"%%A\"==\"/?\" goto documentation\n set /A argc+=1\n)\nif %argc%==0 goto documentation\ngoto run\n\n:documentation\necho Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]\necho.\necho -h, --help Prints this message and exits\necho -o The directory to output compiled files\necho -v, --version Prints Elixir version and exits (standalone)\necho.\necho --ignore-module-conflict Does not emit warnings if a module was previously defined\necho --no-debug-info Does not attach debug info to compiled modules\necho --no-docs Does not attach documentation to compiled modules\necho --profile time Profile the time to compile modules\necho --verbose Prints compilation status\necho --warnings-as-errors Treats warnings as errors and returns non-zero exit status\necho.\necho ** Options given after -- are passed down to the executed code\necho ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS\necho ** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS\ngoto end\n\n:run\ncall \"%~dp0\\elixir.bat\" +elixirc %*\n\n:end\nendlocal\n" }, { "path": "bin/iex", "content": "#!/bin/sh\n\n# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nset -e\n\nif [ \"$1\" = \"--help\" ] || [ \"$1\" = \"-h\" ]; then\n cat <&2\nUsage: $(basename \"$0\") [options] [.exs file] [data]\n\nThe following options are exclusive to IEx:\n\n --dbg pry Sets the backend for Kernel.dbg/2 to IEx.pry/0\n --dot-iex \"FILE\" Evaluates FILE, line by line, to set up IEx' environment.\n Defaults to evaluating .iex.exs or ~/.iex.exs, if any exists.\n If FILE is empty, then no file will be loaded.\n --remsh NAME Connects to a node using a remote shell.\n\nIt accepts all other options listed by \"elixir --help\".\nUSAGE\n exit 1\nfi\n\nreadlink_f () {\n cd \"$(dirname \"$1\")\" > /dev/null\n filename=\"$(basename \"$1\")\"\n if [ -h \"$filename\" ]; then\n readlink_f \"$(readlink \"$filename\")\"\n else\n echo \"$(pwd -P)/$filename\"\n fi\n}\n\nSELF=$(readlink_f \"$0\")\nSCRIPT_PATH=$(dirname \"$SELF\")\nexec \"$SCRIPT_PATH\"/elixir --no-halt --erl \"-user elixir\" +iex \"$@\"\n" }, { "path": "bin/iex.bat", "content": "@echo off\n\n:: SPDX-License-Identifier: Apache-2.0\n:: SPDX-FileCopyrightText: 2021 The Elixir Team\n:: SPDX-FileCopyrightText: 2012 Plataformatec\n\nsetlocal\nif /I \"\"%1\"\"==\"\"--help\"\" goto documentation\nif /I \"\"%1\"\"==\"\"-h\"\" goto documentation\nif /I \"\"%1\"\"==\"\"/h\"\" goto documentation\nif \"\"%1\"\"==\"\"/?\"\" goto documentation\ngoto run\n\n:documentation\necho Usage: %~nx0 [options] [.exs file] [data]\necho.\necho The following options are exclusive to IEx:\necho.\necho --dbg pry Sets the backend for Kernel.dbg/2 to IEx.pry/0\necho --dot-iex \"FILE\" Evaluates FILE, line by line, to set up IEx' environment.\necho Defaults to evaluating .iex.exs or ~/.iex.exs, if any exists.\necho If FILE is empty, then no file will be loaded.\necho --remsh NAME Connects to a node using a remote shell\necho.\necho It accepts all other options listed by \"elixir --help\".\ngoto end\n\n:run\ncall \"%~dp0\\elixir.bat\" --no-halt --erl \"-user elixir\" +iex %*\n:end\nendlocal\n" }, { "path": "bin/mix", "content": "#!/usr/bin/env elixir\n\n# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nMix.CLI.main()\n" }, { "path": "bin/mix.bat", "content": "@echo off\n\n:: SPDX-License-Identifier: Apache-2.0\n:: SPDX-FileCopyrightText: 2021 The Elixir Team\n:: SPDX-FileCopyrightText: 2012 Plataformatec\n\ncall \"%~dp0\\elixir.bat\" \"%~dp0\\mix\" %*\n" }, { "path": "bin/mix.ps1", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\n# Store path to mix.bat as a FileInfo object\n$mixBatPath = (Get-ChildItem (((Get-ChildItem $MyInvocation.MyCommand.Path).Directory.FullName) + '\\mix.bat'))\n$newArgs = @()\n\nfor ($i = 0; $i -lt $args.length; $i++)\n{\n if ($args[$i] -is [array])\n {\n # Commas created the array so we need to reintroduce those commas\n for ($j = 0; $j -lt $args[$i].length - 1; $j++)\n {\n $newArgs += ($args[$i][$j] + ',')\n }\n $newArgs += $args[$i][-1]\n }\n else\n {\n $newArgs += $args[$i]\n }\n}\n\n# Corrected arguments are ready to pass to batch file\n& $mixBatPath $newArgs" }, { "path": "lib/eex/lib/eex/compiler.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule EEx.Compiler do\n @moduledoc false\n\n # When changing this setting, don't forget to update the docs for EEx\n @default_engine EEx.SmartEngine\n @h_spaces [?\\s, ?\\t]\n @all_spaces [?\\s, ?\\t, ?\\n, ?\\r]\n\n @doc \"\"\"\n Tokenize EEx contents.\n \"\"\"\n def tokenize(contents, opts) when is_binary(contents) do\n tokenize(String.to_charlist(contents), contents, opts)\n end\n\n def tokenize(contents, opts) when is_list(contents) do\n tokenize(contents, List.to_string(contents), opts)\n end\n\n def tokenize(contents, source, opts) when is_list(contents) do\n file = opts[:file] || \"nofile\"\n line = opts[:line] || 1\n trim = opts[:trim] || false\n indentation = opts[:indentation] || 0\n column = indentation + (opts[:column] || 1)\n\n state = %{trim: trim, indentation: indentation, file: file, source: source}\n\n {contents, line, column} =\n (trim && trim_init(contents, line, column, state)) || {contents, line, column}\n\n tokenize(contents, line, column, state, [{line, column}], [])\n end\n\n defp tokenize(~c\"<%%\" ++ t, line, column, state, buffer, acc) do\n tokenize(t, line, column + 3, state, [?%, ?< | buffer], acc)\n end\n\n defp tokenize(~c\"<%!--\" ++ t, line, column, state, buffer, acc) do\n case comment(t, line, column + 5, state, []) do\n {:error, message} ->\n meta = %{line: line, column: column}\n {:error, message <> code_snippet(state.source, state.indentation, meta), meta}\n\n {:ok, new_line, new_column, rest, comments} ->\n token = {:comment, Enum.reverse(comments), %{line: line, column: column}}\n trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &[token | &1])\n end\n end\n\n # TODO: Remove me on Elixir v2.0\n defp tokenize(~c\"<%#\" ++ t, line, column, state, buffer, acc) do\n IO.warn(\"<%# is deprecated, use <%!-- or add a space between <% and # instead\",\n line: line,\n column: column,\n file: state.file\n )\n\n case expr(t, line, column + 3, state, []) do\n {:error, message} ->\n {:error, message, %{line: line, column: column}}\n\n {:ok, _, new_line, new_column, rest} ->\n trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, & &1)\n end\n end\n\n defp tokenize(~c\"<%\" ++ t, line, column, state, buffer, acc) do\n {marker, t} = retrieve_marker(t)\n marker_length = length(marker)\n\n case expr(t, line, column + 2 + marker_length, state, []) do\n {:error, message} ->\n meta = %{line: line, column: column}\n {:error, message <> code_snippet(state.source, state.indentation, meta), meta}\n\n {:ok, expr, new_line, new_column, rest} ->\n {key, expr} =\n case :elixir_tokenizer.tokenize(expr, 1, file: \"eex\", check_terminators: false) do\n {:ok, _line, _column, _warnings, rev_tokens, []} ->\n # We ignore warnings because the code will be tokenized\n # again later with the right line+column info\n token_key(rev_tokens, expr)\n\n {:error, _, _, _, _} ->\n {:expr, expr}\n end\n\n marker =\n if key in [:middle_expr, :end_expr] and marker != ~c\"\" do\n message =\n \"unexpected beginning of EEx tag \\\"<%#{marker}\\\" on \\\"<%#{marker}#{expr}%>\\\", \" <>\n \"please remove \\\"#{marker}\\\"\"\n\n IO.warn(message, file: state.file, line: line, column: column)\n ~c\"\"\n else\n marker\n end\n\n token = {key, marker, expr, %{line: line, column: column}}\n trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &[token | &1])\n end\n end\n\n defp tokenize([?\\n | t], line, _column, state, buffer, acc) do\n tokenize(t, line + 1, state.indentation + 1, state, [?\\n | buffer], acc)\n end\n\n defp tokenize([h | t], line, column, state, buffer, acc) do\n tokenize(t, line, column + 1, state, [h | buffer], acc)\n end\n\n defp tokenize([], line, column, _state, buffer, acc) do\n eof = {:eof, %{line: line, column: column}}\n {:ok, Enum.reverse([eof | tokenize_text(buffer, acc)])}\n end\n\n defp trim_and_tokenize(rest, line, column, state, buffer, acc, fun) do\n {rest, line, column, buffer} = trim_if_needed(rest, line, column, state, buffer)\n\n acc = tokenize_text(buffer, acc)\n tokenize(rest, line, column, state, [{line, column}], fun.(acc))\n end\n\n # Retrieve marker for <%\n\n defp retrieve_marker([marker | t]) when marker in [?=, ?/, ?|] do\n {[marker], t}\n end\n\n defp retrieve_marker(t) do\n {~c\"\", t}\n end\n\n # Tokenize a multi-line comment until we find --%>\n\n defp comment([?-, ?-, ?%, ?> | t], line, column, _state, buffer) do\n {:ok, line, column + 4, t, buffer}\n end\n\n defp comment([?\\n | t], line, _column, state, buffer) do\n comment(t, line + 1, state.indentation + 1, state, [?\\n | buffer])\n end\n\n defp comment([head | t], line, column, state, buffer) do\n comment(t, line, column + 1, state, [head | buffer])\n end\n\n defp comment([], _line, _column, _state, _buffer) do\n {:error, \"expected closing '--%>' for EEx expression\"}\n end\n\n # Tokenize an expression until we find %>\n\n defp expr([?%, ?> | t], line, column, _state, buffer) do\n {:ok, Enum.reverse(buffer), line, column + 2, t}\n end\n\n defp expr([?\\n | t], line, _column, state, buffer) do\n expr(t, line + 1, state.indentation + 1, state, [?\\n | buffer])\n end\n\n defp expr([h | t], line, column, state, buffer) do\n expr(t, line, column + 1, state, [h | buffer])\n end\n\n defp expr([], _line, _column, _state, _buffer) do\n {:error, \"expected closing '%>' for EEx expression\"}\n end\n\n # Receives tokens and check if it is a start, middle or an end token.\n defp token_key(rev_tokens, expr) do\n case {Enum.reverse(rev_tokens), drop_eol(rev_tokens)} do\n {[{:end, _} | _], [{:do, _} | _]} ->\n {:middle_expr, expr}\n\n {_, [{:do, _} | _]} ->\n {:start_expr, maybe_append_space(expr)}\n\n {_, [{:block_identifier, _, _} | _]} ->\n {:middle_expr, maybe_append_space(expr)}\n\n {[{:end, _} | _], [{:stab_op, _, _} | _]} ->\n {:middle_expr, expr}\n\n {_, [{:stab_op, _, _} | reverse_tokens]} ->\n fn_index = Enum.find_index(reverse_tokens, &match?({:fn, _}, &1)) || :infinity\n end_index = Enum.find_index(reverse_tokens, &match?({:end, _}, &1)) || :infinity\n\n if end_index > fn_index do\n {:start_expr, expr}\n else\n {:middle_expr, expr}\n end\n\n {tokens, _} ->\n case Enum.drop_while(tokens, &closing_bracket?/1) do\n [{:end, _} | _] -> {:end_expr, expr}\n _ -> {:expr, expr}\n end\n end\n end\n\n defp drop_eol([{:eol, _} | rest]), do: drop_eol(rest)\n defp drop_eol(rest), do: rest\n\n defp maybe_append_space([?\\s]), do: [?\\s]\n defp maybe_append_space([h]), do: [h, ?\\s]\n defp maybe_append_space([h | t]), do: [h | maybe_append_space(t)]\n\n defp closing_bracket?({closing, _}) when closing in ~w\"( [ {\"a, do: true\n defp closing_bracket?(_), do: false\n\n # Tokenize the buffered text by appending\n # it to the given accumulator.\n\n defp tokenize_text([{_line, _column}], acc) do\n acc\n end\n\n defp tokenize_text(buffer, acc) do\n [{line, column} | buffer] = Enum.reverse(buffer)\n [{:text, buffer, %{line: line, column: column}} | acc]\n end\n\n ## Trim\n\n defp trim_if_needed(rest, line, column, state, buffer) do\n if state.trim do\n buffer = trim_left(buffer, 0)\n {rest, line, column} = trim_right(rest, line, column, 0, state)\n {rest, line, column, buffer}\n else\n {rest, line, column, buffer}\n end\n end\n\n defp trim_init([h | t], line, column, state) when h in @h_spaces,\n do: trim_init(t, line, column + 1, state)\n\n defp trim_init([?\\r, ?\\n | t], line, _column, state),\n do: trim_init(t, line + 1, state.indentation + 1, state)\n\n defp trim_init([?\\n | t], line, _column, state),\n do: trim_init(t, line + 1, state.indentation + 1, state)\n\n defp trim_init([?<, ?% | _] = rest, line, column, _state),\n do: {rest, line, column}\n\n defp trim_init(_, _, _, _), do: false\n\n defp trim_left(buffer, count) do\n case trim_whitespace(buffer, 0) do\n {[?\\n, ?\\r | rest], _} -> trim_left(rest, count + 1)\n {[?\\n | rest], _} -> trim_left(rest, count + 1)\n _ when count > 0 -> [?\\n | buffer]\n _ -> buffer\n end\n end\n\n defp trim_right(rest, line, column, last_column, state) do\n case trim_whitespace(rest, column) do\n {[?\\r, ?\\n | rest], column} ->\n trim_right(rest, line + 1, state.indentation + 1, column + 1, state)\n\n {[?\\n | rest], column} ->\n trim_right(rest, line + 1, state.indentation + 1, column, state)\n\n {[], column} ->\n {[], line, column}\n\n _ when last_column > 0 ->\n {[?\\n | rest], line - 1, last_column}\n\n _ ->\n {rest, line, column}\n end\n end\n\n defp trim_whitespace([h | t], column) when h in @h_spaces, do: trim_whitespace(t, column + 1)\n defp trim_whitespace(list, column), do: {list, column}\n\n @doc \"\"\"\n This is the compilation entry point. It glues the tokenizer\n and the engine together by handling the tokens and invoking\n the engine every time a full expression or text is received.\n \"\"\"\n @spec compile([EEx.token()], String.t(), keyword) :: Macro.t()\n def compile(tokens, source, opts) do\n file = opts[:file] || \"nofile\"\n line = opts[:line] || 1\n indentation = opts[:indentation] || 0\n parser_options = opts[:parser_options] || Code.get_compiler_option(:parser_options)\n engine = opts[:engine] || @default_engine\n\n state = %{\n engine: engine,\n file: file,\n source: source,\n line: line,\n quoted: [],\n parser_options: [indentation: indentation] ++ parser_options,\n indentation: indentation\n }\n\n init = state.engine.init(opts)\n\n if function_exported?(state.engine, :handle_text, 2) and\n not function_exported?(state.engine, :handle_text, 3) do\n IO.warn(\n \"#{inspect(state.engine)}.handle_text/2 is deprecated, implement handle_text/3 instead\"\n )\n end\n\n generate_buffer(tokens, init, [], state)\n end\n\n # Ignore tokens related to comment.\n defp generate_buffer([{:comment, _chars, _meta} | rest], buffer, scope, state) do\n generate_buffer(rest, buffer, scope, state)\n end\n\n # Generates the buffers by handling each expression from the tokenizer.\n # It returns Macro.t/0 or it raises.\n\n defp generate_buffer([{:text, chars, meta} | rest], buffer, scope, state) do\n buffer =\n if function_exported?(state.engine, :handle_text, 3) do\n meta = [line: meta.line, column: meta.column]\n state.engine.handle_text(buffer, meta, IO.chardata_to_string(chars))\n else\n # TODO: Remove this on Elixir v2.0. The deprecation is on init.\n state.engine.handle_text(buffer, IO.chardata_to_string(chars))\n end\n\n generate_buffer(rest, buffer, scope, state)\n end\n\n defp generate_buffer([{:expr, mark, chars, meta} | rest], buffer, scope, state) do\n options =\n [file: state.file, line: meta.line, column: column(meta.column, mark)] ++\n state.parser_options\n\n expr = Code.string_to_quoted!(chars, options)\n buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), expr)\n generate_buffer(rest, buffer, scope, state)\n end\n\n defp generate_buffer(\n [{:start_expr, mark, chars, meta} | rest],\n buffer,\n scope,\n state\n ) do\n {rest, line, contents} = look_ahead_middle(rest, meta.line, chars) || {rest, meta.line, chars}\n start_line = meta.line\n start_column = column(meta.column, mark)\n\n {contents, rest} =\n generate_buffer(\n rest,\n state.engine.handle_begin(buffer),\n [{contents, start_line, start_column} | scope],\n %{state | quoted: [], line: line}\n )\n\n if mark == ~c\"\" and not match?({:=, _, [_, _]}, contents) do\n message =\n \"the contents of this expression won't be output unless the EEx block starts with \\\"<%=\\\"\"\n\n IO.warn(message, file: state.file, line: meta.line, column: meta.column)\n end\n\n buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), contents)\n generate_buffer(rest, buffer, scope, state)\n end\n\n defp generate_buffer(\n [{:middle_expr, ~c\"\", chars, meta} | rest],\n buffer,\n [{current, current_line, current_column} | scope],\n state\n ) do\n {wrapped, state} = wrap_expr(current, meta.line, buffer, chars, state)\n state = %{state | line: meta.line}\n\n generate_buffer(\n rest,\n state.engine.handle_begin(buffer),\n [{wrapped, current_line, current_column} | scope],\n state\n )\n end\n\n defp generate_buffer([{:middle_expr, _, chars, meta} | _tokens], _buffer, [], state) do\n message = \"unexpected middle of expression <%#{chars}%>\"\n syntax_error!(message, meta, state)\n end\n\n defp generate_buffer(\n [{:end_expr, ~c\"\", chars, meta} | rest],\n buffer,\n [{current, line, column} | _],\n state\n ) do\n {wrapped, state} = wrap_expr(current, meta.line, buffer, chars, state)\n options = [file: state.file, line: line, column: column] ++ state.parser_options\n tuples = Code.string_to_quoted!(wrapped, options)\n buffer = insert_quoted(tuples, state.quoted)\n {buffer, rest}\n end\n\n defp generate_buffer([{:end_expr, _, chars, meta} | _], _buffer, [], state) do\n message = \"unexpected end of expression <%#{chars}%>\"\n syntax_error!(message, meta, state)\n end\n\n defp generate_buffer([{:eof, _meta}], buffer, [], state) do\n state.engine.handle_body(buffer)\n end\n\n defp generate_buffer([{:eof, _meta}], _buffer, [{content, line, column} | _scope], state) do\n message = \"expected a closing '<% end %>' for block expression in EEx\"\n expr_meta = non_whitespace_meta(content, line, column, state)\n syntax_error!(message, expr_meta, state)\n end\n\n defp non_whitespace_meta([space | rest], line, column, state) when space in @h_spaces,\n do: non_whitespace_meta(rest, line, column + 1, state)\n\n defp non_whitespace_meta([?\\n | rest], line, _column, state),\n do: non_whitespace_meta(rest, line + 1, state.indentation + 1, state)\n\n defp non_whitespace_meta(_, line, column, _),\n do: %{line: line, column: column}\n\n # Creates a placeholder and wrap it inside the expression block\n\n defp wrap_expr(current, line, buffer, chars, state) do\n new_lines = List.duplicate(?\\n, line - state.line)\n key = length(state.quoted)\n placeholder = ~c\"__EEX__(\" ++ Integer.to_charlist(key) ++ ~c\");\"\n count = current ++ placeholder ++ new_lines ++ chars\n new_state = %{state | quoted: [{key, state.engine.handle_end(buffer)} | state.quoted]}\n\n {count, new_state}\n end\n\n # Look middle expressions that immediately follow a start_expr\n\n defp look_ahead_middle([{:comment, _comment, _meta} | rest], start, contents),\n do: look_ahead_middle(rest, start, contents)\n\n defp look_ahead_middle([{:text, text, _meta} | rest], start, contents) do\n if only_spaces?(text) do\n look_ahead_middle(rest, start, contents ++ text)\n else\n nil\n end\n end\n\n defp look_ahead_middle([{:middle_expr, _, chars, meta} | rest], _start, contents) do\n {rest, meta.line, contents ++ chars}\n end\n\n defp look_ahead_middle(_tokens, _start, _contents) do\n nil\n end\n\n defp only_spaces?(chars) do\n Enum.all?(chars, &(&1 in @all_spaces))\n end\n\n # Changes placeholder to real expression\n\n defp insert_quoted({:__EEX__, _, [key]}, quoted) do\n {^key, value} = List.keyfind(quoted, key, 0)\n value\n end\n\n defp insert_quoted({left, line, right}, quoted) do\n {insert_quoted(left, quoted), line, insert_quoted(right, quoted)}\n end\n\n defp insert_quoted({left, right}, quoted) do\n {insert_quoted(left, quoted), insert_quoted(right, quoted)}\n end\n\n defp insert_quoted(list, quoted) when is_list(list) do\n Enum.map(list, &insert_quoted(&1, quoted))\n end\n\n defp insert_quoted(other, _quoted) do\n other\n end\n\n defp column(column, mark) do\n # length(~c\"<%\") == 2\n column + 2 + length(mark)\n end\n\n defp syntax_error!(message, meta, state) do\n raise EEx.SyntaxError,\n message: message,\n snippet: code_snippet(state.source, state.indentation, meta),\n file: state.file,\n line: meta.line,\n column: meta.column\n end\n\n defp code_snippet(source, indentation, meta) do\n line_start = max(meta.line - 3, 1)\n line_end = meta.line\n digits = line_end |> Integer.to_string() |> byte_size()\n number_padding = String.duplicate(\" \", digits)\n indentation = String.duplicate(\" \", indentation)\n\n source\n |> String.split([\"\\r\\n\", \"\\n\"])\n |> Enum.slice((line_start - 1)..(line_end - 1))\n |> Enum.map_reduce(line_start, fn\n expr, line_number when line_number == line_end ->\n arrow = String.duplicate(\" \", meta.column - 1) <> \"^\"\n {\"#{line_number} | #{indentation}#{expr}\\n #{number_padding}| #{arrow}\", line_number + 1}\n\n expr, line_number ->\n line_number_padding = String.pad_leading(\"#{line_number}\", digits)\n {\"#{line_number_padding} | #{indentation}#{expr}\", line_number + 1}\n end)\n |> case do\n {[], _} -> \"\"\n {snippet, _} -> Enum.join([\"\\n #{number_padding}|\" | snippet], \"\\n\")\n end\n end\nend\n" }, { "path": "lib/eex/lib/eex/engine.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule EEx.Engine do\n @moduledoc ~S\"\"\"\n Basic EEx engine that ships with Elixir.\n\n An engine needs to implement all callbacks below.\n\n This module also ships with a default engine implementation\n you can delegate to. See `EEx.SmartEngine` as an example.\n \"\"\"\n\n @type state :: term\n\n @doc \"\"\"\n Called at the beginning of every template.\n\n It receives the options during compilation, including the\n ones managed by EEx, such as `:line` and `:file`, as well\n as custom engine options.\n\n It must return the initial state.\n \"\"\"\n @callback init(opts :: keyword) :: state\n\n @doc \"\"\"\n Called at the end of every template.\n\n It must return Elixir's quoted expressions for the template.\n \"\"\"\n @callback handle_body(state) :: Macro.t()\n\n @doc \"\"\"\n Called for the text/static parts of a template.\n\n It must return the updated state.\n \"\"\"\n @callback handle_text(state, [line: pos_integer, column: pos_integer], text :: String.t()) ::\n state\n\n @doc \"\"\"\n Called for the dynamic/code parts of a template.\n\n The marker is what follows exactly after `<%`. For example,\n `<% foo %>` has an empty marker, but `<%= foo %>` has `\"=\"`\n as marker. The allowed markers so far are:\n\n * `\"\"`\n * `\"=\"`\n * `\"/\"`\n * `\"|\"`\n\n Markers `\"/\"` and `\"|\"` are only for use in custom EEx engines\n and are not implemented by default. Using them without an\n appropriate implementation raises `EEx.SyntaxError`.\n\n It must return the updated state.\n \"\"\"\n @callback handle_expr(state, marker :: String.t(), expr :: Macro.t()) :: state\n\n @doc \"\"\"\n Invoked at the beginning of every nesting.\n\n It must return a new state that is used only inside the nesting.\n Once the nesting terminates, the current `state` is resumed.\n \"\"\"\n @callback handle_begin(state) :: state\n\n @doc \"\"\"\n Invokes at the end of a nesting.\n\n It must return Elixir's quoted expressions for the nesting.\n \"\"\"\n @callback handle_end(state) :: Macro.t()\n\n @doc false\n @deprecated \"Use explicit delegation to EEx.Engine instead\"\n defmacro __using__(_) do\n quote do\n @behaviour EEx.Engine\n\n def init(opts) do\n EEx.Engine.init(opts)\n end\n\n def handle_body(state) do\n EEx.Engine.handle_body(state)\n end\n\n def handle_begin(state) do\n EEx.Engine.handle_begin(state)\n end\n\n def handle_end(state) do\n EEx.Engine.handle_end(state)\n end\n\n def handle_text(state, text) do\n EEx.Engine.handle_text(state, [], text)\n end\n\n def handle_expr(state, marker, expr) do\n EEx.Engine.handle_expr(state, marker, expr)\n end\n\n defoverridable EEx.Engine\n end\n end\n\n @doc \"\"\"\n Handles assigns in quoted expressions.\n\n A warning will be printed on missing assigns.\n Future versions will raise.\n\n This can be added to any custom engine by invoking\n `handle_assign/1` with `Macro.prewalk/2`:\n\n def handle_expr(state, token, expr) do\n expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)\n super(state, token, expr)\n end\n\n \"\"\"\n @spec handle_assign(Macro.t()) :: Macro.t()\n def handle_assign({:@, meta, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do\n line = meta[:line] || 0\n quote(line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name)))\n end\n\n def handle_assign(arg) do\n arg\n end\n\n @doc false\n # TODO: Raise on v2.0\n @spec fetch_assign!(Access.t(), Access.key()) :: term | nil\n def fetch_assign!(assigns, key) do\n case Access.fetch(assigns, key) do\n {:ok, val} ->\n val\n\n :error ->\n keys = Enum.map(assigns, &elem(&1, 0))\n\n IO.warn(\n \"assign @#{key} not available in EEx template. \" <>\n \"Please ensure all assigns are given as options. \" <>\n \"Available assigns: #{inspect(keys)}\"\n )\n\n nil\n end\n end\n\n @doc \"Default implementation for `c:init/1`.\"\n def init(_opts) do\n %{\n binary: [],\n dynamic: [],\n vars_count: 0\n }\n end\n\n @doc \"Default implementation for `c:handle_begin/1`.\"\n def handle_begin(state) do\n check_state!(state)\n %{state | binary: [], dynamic: []}\n end\n\n @doc \"Default implementation for `c:handle_end/1`.\"\n def handle_end(quoted) do\n handle_body(quoted)\n end\n\n @doc \"Default implementation for `c:handle_body/1`.\"\n def handle_body(state) do\n check_state!(state)\n %{binary: binary, dynamic: dynamic} = state\n binary = {:<<>>, [], Enum.reverse(binary)}\n dynamic = [binary | dynamic]\n {:__block__, [], Enum.reverse(dynamic)}\n end\n\n @doc \"Default implementation for `c:handle_text/3`.\"\n def handle_text(state, _meta, text) do\n check_state!(state)\n %{binary: binary} = state\n %{state | binary: [text | binary]}\n end\n\n @doc \"Default implementation for `c:handle_expr/3`.\"\n def handle_expr(state, \"=\", ast) do\n check_state!(state)\n %{binary: binary, dynamic: dynamic, vars_count: vars_count} = state\n var = Macro.var(:\"arg#{vars_count}\", __MODULE__)\n\n ast =\n quote do\n unquote(var) = String.Chars.to_string(unquote(ast))\n end\n\n segment =\n quote do\n unquote(var) :: binary\n end\n\n %{state | dynamic: [ast | dynamic], binary: [segment | binary], vars_count: vars_count + 1}\n end\n\n def handle_expr(state, \"\", ast) do\n %{dynamic: dynamic} = state\n %{state | dynamic: [ast | dynamic]}\n end\n\n def handle_expr(_state, marker, _ast) when marker in [\"/\", \"|\"] do\n raise EEx.SyntaxError,\n \"unsupported EEx syntax <%#{marker} %> (the syntax is valid but not supported by the current EEx engine)\"\n end\n\n defp check_state!(%{binary: _, dynamic: _, vars_count: _}), do: :ok\n\n defp check_state!(state) do\n raise \"unexpected EEx.Engine state: #{inspect(state)}. \" <>\n \"This typically means a bug or an outdated EEx.Engine or tool\"\n end\nend\n" }, { "path": "lib/eex/lib/eex/smart_engine.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule EEx.SmartEngine do\n @moduledoc \"\"\"\n The default engine used by EEx.\n\n It includes assigns (like `@foo`) and possibly other\n conveniences in the future.\n\n ## Examples\n\n iex> EEx.eval_string(\"<%= @foo %>\", assigns: [foo: 1])\n \"1\"\n\n In the example above, we can access the value `foo` under\n the binding `assigns` using `@foo`. This is useful because\n a template, after being compiled, can receive different\n assigns and would not require recompilation for each\n variable set.\n\n Assigns can also be used when compiled to a function:\n\n # sample.eex\n <%= @a + @b %>\n\n # sample.ex\n defmodule Sample do\n require EEx\n EEx.function_from_file(:def, :sample, \"sample.eex\", [:assigns])\n end\n\n # iex\n Sample.sample(a: 1, b: 2)\n #=> \"3\"\n\n \"\"\"\n\n @behaviour EEx.Engine\n\n @impl true\n defdelegate init(opts), to: EEx.Engine\n\n @impl true\n defdelegate handle_body(state), to: EEx.Engine\n\n @impl true\n defdelegate handle_begin(state), to: EEx.Engine\n\n @impl true\n defdelegate handle_end(state), to: EEx.Engine\n\n @impl true\n defdelegate handle_text(state, meta, text), to: EEx.Engine\n\n @impl true\n def handle_expr(state, marker, expr) do\n expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)\n EEx.Engine.handle_expr(state, marker, expr)\n end\nend\n" }, { "path": "lib/eex/lib/eex.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule EEx.SyntaxError do\n defexception [:file, :line, :column, :snippet, message: \"syntax error\"]\n\n @impl true\n def message(exception) do\n %{file: file, line: line, column: column, message: message, snippet: snippet} = exception\n\n Exception.format_file_line_column(file && Path.relative_to_cwd(file), line, column, \" \") <>\n message <> (snippet || \"\")\n end\nend\n\ndefmodule EEx do\n @moduledoc ~S\"\"\"\n EEx stands for Embedded Elixir.\n\n Embedded Elixir allows you to embed Elixir code inside a string\n in a robust way.\n\n iex> EEx.eval_string(\"foo <%= bar %>\", bar: \"baz\")\n \"foo baz\"\n\n This module provides three main APIs for you to use:\n\n 1. Evaluate a string (`eval_string/3`) or a file (`eval_file/3`)\n directly. This is the simplest API to use but also the\n slowest, since the code is evaluated at runtime and not precompiled.\n\n 2. Define a function from a string (`function_from_string/5`)\n or a file (`function_from_file/5`). This allows you to embed\n the template as a function inside a module which will then\n be compiled. This is the preferred API if you have access\n to the template at compilation time.\n\n 3. Compile a string (`compile_string/2`) or a file (`compile_file/2`)\n into Elixir syntax tree. This is the API used by both functions\n above and is available to you if you want to provide your own\n ways of handling the compiled template.\n\n The APIs above support several options, documented below. You may\n also pass an engine which customizes how the EEx code is compiled.\n\n ## Options\n\n All functions in this module, unless otherwise noted, accept EEx-related\n options. They are:\n\n * `:file` - the file to be used in the template. Defaults to the given\n file the template is read from or to `\"nofile\"` when compiling from a string.\n\n * `:line` - the line to be used as the template start. Defaults to `1`.\n\n * `:indentation` - (since v1.11.0) an integer added to the column after every\n new line. Defaults to `0`.\n\n * `:engine` - the EEx engine to be used for compilation. Defaults to `EEx.SmartEngine`.\n\n * `:trim` - if `true`, trims whitespace left and right of quotation as\n long as at least one newline is present. All subsequent newlines and\n spaces are removed but one newline is retained. Defaults to `false`.\n\n * `:parser_options` - (since: 1.13.0) allow customizing the parsed code\n that is generated. See `Code.string_to_quoted/2` for available options.\n Note that the options `:file`, `:line` and `:column` are ignored if\n passed in. Defaults to `Code.get_compiler_option(:parser_options)`\n (which defaults to `[]` if not set).\n\n ## Tags\n\n EEx supports multiple tags, declared below:\n\n <% Elixir expression: executes code but discards output %>\n <%= Elixir expression: executes code and prints result %>\n <%% EEx quotation: returns the contents inside the tag as is %>\n <%!-- Comments: they are discarded from source --%>\n\n EEx supports additional tags, that may be used by some engines,\n but they do not have a meaning by default:\n\n <%| ... %>\n <%/ ... %>\n\n ## Engine\n\n EEx has the concept of engines which allows you to modify or\n transform the code extracted from the given string or file.\n\n By default, `EEx` uses the `EEx.SmartEngine` that provides some\n conveniences on top of the simple `EEx.Engine`.\n\n ### `EEx.SmartEngine`\n\n The smart engine uses EEx default rules and adds the `@` construct\n for reading template assigns:\n\n iex> EEx.eval_string(\"<%= @foo %>\", assigns: [foo: 1])\n \"1\"\n\n In other words, `<%= @foo %>` translates to:\n\n <%= {:ok, v} = Access.fetch(assigns, :foo); v %>\n\n The `assigns` extension is useful when the number of variables\n required by the template is not specified at compilation time.\n \"\"\"\n\n @type line :: non_neg_integer\n @type column :: non_neg_integer\n @type marker :: [?=] | [?/] | [?|] | []\n @type metadata :: %{column: column, line: line}\n @type token ::\n {:comment, charlist, metadata}\n | {:text, charlist, metadata}\n | {:expr | :start_expr | :middle_expr | :end_expr, marker, charlist, metadata}\n | {:eof, metadata}\n\n @type tokenize_opt ::\n {:file, binary()}\n | {:line, line}\n | {:column, column}\n | {:indentation, non_neg_integer}\n | {:trim, boolean()}\n\n @type compile_opt ::\n tokenize_opt\n | {:engine, module()}\n | {:parser_options, Code.parser_opts()}\n | {atom(), term()}\n\n @doc \"\"\"\n Generates a function definition from the given string.\n\n The first argument is the kind of the generated function (`:def` or `:defp`).\n The `name` argument is the name that the generated function will have.\n `template` is the string containing the EEx template. `args` is a list of arguments\n that the generated function will accept. They will be available inside the EEx\n template.\n\n The supported `options` are described [in the module docs](#module-options).\n Additional options are passed to the underlying engine.\n\n ## Examples\n\n iex> defmodule Sample do\n ...> require EEx\n ...> EEx.function_from_string(:def, :sample, \"<%= a + b %>\", [:a, :b])\n ...> end\n iex> Sample.sample(1, 2)\n \"3\"\n\n \"\"\"\n defmacro function_from_string(kind, name, template, args \\\\ [], options \\\\ []) do\n quote bind_quoted: binding() do\n info = Keyword.merge([file: __ENV__.file, line: __ENV__.line], options)\n args = Enum.map(args, fn arg -> {arg, [line: info[:line]], nil} end)\n compiled = EEx.compile_string(template, info)\n\n case kind do\n :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)\n :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)\n end\n end\n end\n\n @doc \"\"\"\n Generates a function definition from the file contents.\n\n The first argument is the kind of the generated function (`:def` or `:defp`).\n The `name` argument is the name that the generated function will have.\n `file` is the path to the EEx template file. `args` is a list of arguments\n that the generated function will accept. They will be available inside the EEx\n template.\n\n This function is useful in case you have templates but\n you want to precompile inside a module for speed.\n\n The supported `options` are described [in the module docs](#module-options).\n\n ## Examples\n\n # sample.eex\n <%= a + b %>\n\n # sample.ex\n defmodule Sample do\n require EEx\n EEx.function_from_file(:def, :sample, \"sample.eex\", [:a, :b])\n end\n\n # iex\n Sample.sample(1, 2)\n #=> \"3\"\n\n \"\"\"\n defmacro function_from_file(kind, name, file, args \\\\ [], options \\\\ []) do\n quote bind_quoted: binding() do\n info = Keyword.merge([file: IO.chardata_to_string(file), line: 1], options)\n args = Enum.map(args, fn arg -> {arg, [line: 1], nil} end)\n compiled = EEx.compile_file(file, info)\n\n @external_resource file\n @file file\n case kind do\n :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)\n :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)\n end\n end\n end\n\n @doc \"\"\"\n Gets a string `source` and generates a quoted expression\n that can be evaluated by Elixir or compiled to a function.\n\n This is useful if you want to compile a EEx template into code and inject\n that code somewhere or evaluate it at runtime.\n\n The generated quoted code will use variables defined in the template that\n will be taken from the context where the code is evaluated. If you\n have a template such as `<%= a + b %>`, then the returned quoted code\n will use the `a` and `b` variables in the context where it's evaluated. See\n examples below.\n\n The supported `options` are described [in the module docs](#module-options).\n\n ## Examples\n\n iex> quoted = EEx.compile_string(\"<%= a + b %>\")\n iex> {result, _bindings} = Code.eval_quoted(quoted, a: 1, b: 2)\n iex> result\n \"3\"\n\n \"\"\"\n @spec compile_string(String.t(), [compile_opt]) :: Macro.t()\n def compile_string(source, options \\\\ []) when is_binary(source) and is_list(options) do\n tokenize_opts = Keyword.take(options, [:file, :line, :column, :indentation, :trim])\n\n case tokenize(source, tokenize_opts) do\n {:ok, tokens} ->\n EEx.Compiler.compile(tokens, source, options)\n\n {:error, message, %{column: column, line: line}} ->\n file = options[:file] || \"nofile\"\n raise EEx.SyntaxError, file: file, line: line, column: column, message: message\n end\n end\n\n @doc \"\"\"\n Gets a `filename` and generates a quoted expression\n that can be evaluated by Elixir or compiled to a function.\n\n This is useful if you want to compile a EEx template into code and inject\n that code somewhere or evaluate it at runtime.\n\n The generated quoted code will use variables defined in the template that\n will be taken from the context where the code is evaluated. If you\n have a template such as `<%= a + b %>`, then the returned quoted code\n will use the `a` and `b` variables in the context where it's evaluated. See\n examples below.\n\n The supported `options` are described [in the module docs](#module-options).\n\n ## Examples\n\n # sample.eex\n <%= a + b %>\n\n # In code:\n quoted = EEx.compile_file(\"sample.eex\")\n {result, _bindings} = Code.eval_quoted(quoted, a: 1, b: 2)\n result\n #=> \"3\"\n\n \"\"\"\n @spec compile_file(Path.t(), [compile_opt]) :: Macro.t()\n def compile_file(filename, options \\\\ []) when is_list(options) do\n filename = IO.chardata_to_string(filename)\n options = Keyword.merge([file: filename, line: 1], options)\n compile_string(File.read!(filename), options)\n end\n\n @doc \"\"\"\n Gets a string `source` and evaluate the values using the `bindings`.\n\n The supported `options` are described [in the module docs](#module-options).\n\n ## Examples\n\n iex> EEx.eval_string(\"foo <%= bar %>\", bar: \"baz\")\n \"foo baz\"\n\n \"\"\"\n @spec eval_string(String.t(), keyword, [compile_opt]) :: term()\n def eval_string(source, bindings \\\\ [], options \\\\ [])\n when is_binary(source) and is_list(bindings) and is_list(options) do\n compiled = compile_string(source, options)\n do_eval(compiled, bindings, options)\n end\n\n @doc \"\"\"\n Gets a `filename` and evaluate the values using the `bindings`.\n\n The supported `options` are described [in the module docs](#module-options).\n\n ## Examples\n\n # sample.eex\n foo <%= bar %>\n\n # IEx\n EEx.eval_file(\"sample.eex\", bar: \"baz\")\n #=> \"foo baz\"\n\n \"\"\"\n @spec eval_file(Path.t(), keyword, [compile_opt]) :: String.t()\n def eval_file(filename, bindings \\\\ [], options \\\\ [])\n when is_list(bindings) and is_list(options) do\n filename = IO.chardata_to_string(filename)\n options = Keyword.put_new(options, :file, filename)\n compiled = compile_file(filename, options)\n do_eval(compiled, bindings, options)\n end\n\n @doc \"\"\"\n Tokenize the given contents according to the given options.\n\n ## Options\n\n * `:line` - An integer to start as line. Default is 1.\n * `:column` - An integer to start as column. Default is 1.\n * `:indentation` - An integer that indicates the indentation. Default is 0.\n * `:trim` - Tells the tokenizer to either trim the content or not. Default is false.\n * `:file` - Can be either a file or a string \"nofile\".\n\n ## Examples\n\n iex> EEx.tokenize(~c\"foo\", line: 1, column: 1)\n {:ok, [{:text, ~c\"foo\", %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}\n\n ## Result\n\n It returns `{:ok, [token]}` where a token is one of:\n\n * `{:text, content, %{column: column, line: line}}`\n * `{:expr, marker, content, %{column: column, line: line}}`\n * `{:start_expr, marker, content, %{column: column, line: line}}`\n * `{:middle_expr, marker, content, %{column: column, line: line}}`\n * `{:end_expr, marker, content, %{column: column, line: line}}`\n * `{:eof, %{column: column, line: line}}`\n\n Or `{:error, message, %{column: column, line: line}}` in case of errors.\n Note new tokens may be added in the future.\n \"\"\"\n @doc since: \"1.14.0\"\n @spec tokenize([char()] | String.t(), [tokenize_opt]) ::\n {:ok, [token()]} | {:error, String.t(), metadata()}\n def tokenize(contents, opts \\\\ []) do\n EEx.Compiler.tokenize(contents, opts)\n end\n\n ### Helpers\n\n defp do_eval(compiled, bindings, options) do\n options = Keyword.take(options, [:file, :line, :module, :prune_binding])\n {result, _} = Code.eval_quoted(compiled, bindings, options)\n result\n end\nend\n" }, { "path": "lib/eex/mix.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule EEx.MixProject do\n use Mix.Project\n\n def project do\n [\n app: :eex,\n version: System.version(),\n build_per_environment: false\n ]\n end\nend\n" }, { "path": "lib/eex/test/eex/smart_engine_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule EEx.SmartEngineTest do\n use ExUnit.Case, async: true\n\n test \"evaluates simple string\" do\n assert_eval(\"foo bar\", \"foo bar\")\n end\n\n test \"evaluates with assigns as keywords\" do\n assert_eval(\"1\", \"<%= @foo %>\", assigns: [foo: 1])\n end\n\n test \"evaluates with assigns as a map\" do\n assert_eval(\"1\", \"<%= @foo %>\", assigns: %{foo: 1})\n end\n\n test \"error with missing assigns\" do\n stderr =\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert_eval(\"\", \"<%= @foo %>\", assigns: %{})\n end)\n\n assert stderr =~ \"assign @foo not available in EEx template\"\n end\n\n test \"evaluates with loops\" do\n assert_eval(\"1\\n2\\n3\\n\", \"<%= for x <- [1, 2, 3] do %><%= x %>\\n<% end %>\")\n end\n\n test \"preserves line numbers in assignments\" do\n result = EEx.compile_string(\"foo\\n<%= @hello %>\", engine: EEx.SmartEngine)\n\n Macro.prewalk(result, fn\n {_left, meta, [_, :hello]} ->\n assert Keyword.get(meta, :line) == 2\n send(self(), :found)\n\n node ->\n node\n end)\n\n assert_received :found\n end\n\n defp assert_eval(expected, actual, binding \\\\ []) do\n result = EEx.eval_string(actual, binding, file: __ENV__.file, engine: EEx.SmartEngine)\n assert result == expected\n end\nend\n" }, { "path": "lib/eex/test/eex/tokenizer_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule EEx.TokenizerTest do\n use ExUnit.Case, async: true\n\n @opts [indentation: 0, trim: false]\n\n test \"simple charlists\" do\n assert EEx.tokenize(~c\"foo\", @opts) ==\n {:ok, [{:text, ~c\"foo\", %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}\n end\n\n test \"simple strings\" do\n assert EEx.tokenize(\"foo\", @opts) ==\n {:ok, [{:text, ~c\"foo\", %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}\n end\n\n test \"strings with embedded code\" do\n assert EEx.tokenize(~c\"foo <% bar %>\", @opts) ==\n {:ok,\n [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:expr, ~c\"\", ~c\" bar \", %{column: 5, line: 1}},\n {:eof, %{column: 14, line: 1}}\n ]}\n end\n\n test \"strings with embedded equals code\" do\n assert EEx.tokenize(~c\"foo <%= bar %>\", @opts) ==\n {:ok,\n [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:expr, ~c\"=\", ~c\" bar \", %{column: 5, line: 1}},\n {:eof, %{column: 15, line: 1}}\n ]}\n end\n\n test \"strings with embedded slash code\" do\n assert EEx.tokenize(~c\"foo <%/ bar %>\", @opts) ==\n {:ok,\n [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:expr, ~c\"/\", ~c\" bar \", %{column: 5, line: 1}},\n {:eof, %{column: 15, line: 1}}\n ]}\n end\n\n test \"strings with embedded pipe code\" do\n assert EEx.tokenize(~c\"foo <%| bar %>\", @opts) ==\n {:ok,\n [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:expr, ~c\"|\", ~c\" bar \", %{column: 5, line: 1}},\n {:eof, %{column: 15, line: 1}}\n ]}\n end\n\n test \"strings with more than one line\" do\n assert EEx.tokenize(~c\"foo\\n<%= bar %>\", @opts) ==\n {:ok,\n [\n {:text, ~c\"foo\\n\", %{column: 1, line: 1}},\n {:expr, ~c\"=\", ~c\" bar \", %{column: 1, line: 2}},\n {:eof, %{column: 11, line: 2}}\n ]}\n end\n\n test \"strings with more than one line and expression with more than one line\" do\n string = ~c\"\"\"\n foo <%= bar\n\n baz %>\n <% foo %>\n \"\"\"\n\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:expr, ~c\"=\", ~c\" bar\\n\\nbaz \", %{column: 5, line: 1}},\n {:text, ~c\"\\n\", %{column: 7, line: 3}},\n {:expr, ~c\"\", ~c\" foo \", %{column: 1, line: 4}},\n {:text, ~c\"\\n\", %{column: 10, line: 4}},\n {:eof, %{column: 1, line: 5}}\n ]\n\n assert EEx.tokenize(string, @opts) == {:ok, exprs}\n end\n\n test \"quotation\" do\n assert EEx.tokenize(~c\"foo <%% true %>\", @opts) ==\n {:ok,\n [\n {:text, ~c\"foo <% true %>\", %{column: 1, line: 1}},\n {:eof, %{column: 16, line: 1}}\n ]}\n end\n\n test \"quotation with do-end\" do\n assert EEx.tokenize(~c\"foo <%% true do %>bar<%% end %>\", @opts) ==\n {:ok,\n [\n {:text, ~c\"foo <% true do %>bar<% end %>\", %{column: 1, line: 1}},\n {:eof, %{column: 32, line: 1}}\n ]}\n end\n\n test \"quotation with interpolation\" do\n exprs = [\n {:text, ~c\"a <% b \", %{column: 1, line: 1}},\n {:expr, ~c\"=\", ~c\" c \", %{column: 9, line: 1}},\n {:text, ~c\" \", %{column: 17, line: 1}},\n {:expr, ~c\"=\", ~c\" d \", %{column: 18, line: 1}},\n {:text, ~c\" e %> f\", %{column: 26, line: 1}},\n {:eof, %{column: 33, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"a <%% b <%= c %> <%= d %> e %> f\", @opts) == {:ok, exprs}\n end\n\n test \"improperly formatted quotation with interpolation\" do\n exprs = [\n {:text, ~c\"<%% a <%= b %> c %>\", %{column: 1, line: 1}},\n {:eof, %{column: 22, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"<%%% a <%%= b %> c %>\", @opts) == {:ok, exprs}\n end\n\n test \"EEx comments\" do\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:eof, %{column: 16, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"foo <%# true %>\", @opts) == {:ok, exprs}\n\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:eof, %{column: 8, line: 2}}\n ]\n\n assert EEx.tokenize(~c\"foo <%#\\ntrue %>\", @opts) == {:ok, exprs}\n end)\n end\n\n test \"EEx multi-line comments\" do\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:comment, ~c\" true \", %{column: 5, line: 1}},\n {:text, ~c\" bar\", %{column: 20, line: 1}},\n {:eof, %{column: 24, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"foo <%!-- true --%> bar\", @opts) == {:ok, exprs}\n\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:comment, ~c\" \\ntrue\\n \", %{column: 5, line: 1}},\n {:text, ~c\" bar\", %{column: 6, line: 3}},\n {:eof, %{column: 10, line: 3}}\n ]\n\n assert EEx.tokenize(~c\"foo <%!-- \\ntrue\\n --%> bar\", @opts) == {:ok, exprs}\n\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:comment, ~c\" <%= true %> \", %{column: 5, line: 1}},\n {:text, ~c\" bar\", %{column: 27, line: 1}},\n {:eof, %{column: 31, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"foo <%!-- <%= true %> --%> bar\", @opts) == {:ok, exprs}\n end\n\n test \"Elixir comments\" do\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:expr, [], ~c\" true # this is a boolean \", %{column: 5, line: 1}},\n {:eof, %{column: 35, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"foo <% true # this is a boolean %>\", @opts) == {:ok, exprs}\n end\n\n test \"Elixir comments with do-end\" do\n exprs = [\n {:start_expr, [], ~c\" if true do # startif \", %{column: 1, line: 1}},\n {:text, ~c\"text\", %{column: 27, line: 1}},\n {:end_expr, [], ~c\" end # closeif \", %{column: 31, line: 1}},\n {:eof, %{column: 50, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"<% if true do # startif %>text<% end # closeif %>\", @opts) ==\n {:ok, exprs}\n end\n\n test \"strings with embedded do end\" do\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:start_expr, ~c\"\", ~c\" if true do \", %{column: 5, line: 1}},\n {:text, ~c\"bar\", %{column: 21, line: 1}},\n {:end_expr, ~c\"\", ~c\" end \", %{column: 24, line: 1}},\n {:eof, %{column: 33, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"foo <% if true do %>bar<% end %>\", @opts) == {:ok, exprs}\n end\n\n test \"strings with embedded -> end\" do\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:start_expr, ~c\"\", ~c\" cond do \", %{column: 5, line: 1}},\n {:middle_expr, ~c\"\", ~c\" false -> \", %{column: 18, line: 1}},\n {:text, ~c\"bar\", %{column: 32, line: 1}},\n {:middle_expr, ~c\"\", ~c\" true -> \", %{column: 35, line: 1}},\n {:text, ~c\"baz\", %{column: 48, line: 1}},\n {:end_expr, ~c\"\", ~c\" end \", %{column: 51, line: 1}},\n {:eof, %{column: 60, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>\", @opts) ==\n {:ok, exprs}\n end\n\n test \"strings with fn-end with newline\" do\n exprs = [\n {:start_expr, ~c\"=\", ~c\" a fn ->\\n\", %{column: 1, line: 1}},\n {:text, ~c\"foo\", %{column: 3, line: 2}},\n {:end_expr, [], ~c\" end \", %{column: 6, line: 2}},\n {:eof, %{column: 15, line: 2}}\n ]\n\n assert EEx.tokenize(~c\"<%= a fn ->\\n%>foo<% end %>\", @opts) ==\n {:ok, exprs}\n end\n\n test \"strings with multiple fn-end\" do\n exprs = [\n {:start_expr, ~c\"=\", ~c\" a fn -> \", %{column: 1, line: 1}},\n {:text, ~c\"foo\", %{column: 15, line: 1}},\n {:middle_expr, ~c\"\", ~c\" end, fn -> \", %{column: 18, line: 1}},\n {:text, ~c\"bar\", %{column: 34, line: 1}},\n {:end_expr, ~c\"\", ~c\" end \", %{column: 37, line: 1}},\n {:eof, %{column: 46, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"<%= a fn -> %>foo<% end, fn -> %>bar<% end %>\", @opts) ==\n {:ok, exprs}\n end\n\n test \"strings with fn-end followed by do block\" do\n exprs = [\n {:start_expr, ~c\"=\", ~c\" a fn -> \", %{column: 1, line: 1}},\n {:text, ~c\"foo\", %{column: 15, line: 1}},\n {:middle_expr, ~c\"\", ~c\" end do \", %{column: 18, line: 1}},\n {:text, ~c\"bar\", %{column: 30, line: 1}},\n {:end_expr, ~c\"\", ~c\" end \", %{column: 33, line: 1}},\n {:eof, %{column: 42, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"<%= a fn -> %>foo<% end do %>bar<% end %>\", @opts) == {:ok, exprs}\n end\n\n test \"strings with embedded keywords blocks\" do\n exprs = [\n {:text, ~c\"foo \", %{column: 1, line: 1}},\n {:start_expr, ~c\"\", ~c\" if true do \", %{column: 5, line: 1}},\n {:text, ~c\"bar\", %{column: 21, line: 1}},\n {:middle_expr, ~c\"\", ~c\" else \", %{column: 24, line: 1}},\n {:text, ~c\"baz\", %{column: 34, line: 1}},\n {:end_expr, ~c\"\", ~c\" end \", %{column: 37, line: 1}},\n {:eof, %{column: 46, line: 1}}\n ]\n\n assert EEx.tokenize(~c\"foo <% if true do %>bar<% else %>baz<% end %>\", @opts) ==\n {:ok, exprs}\n end\n\n test \"trim mode\" do\n template = ~c\"\\t<%= if true do %> \\n TRUE \\n <% else %>\\n FALSE \\n <% end %> \\n\\n \"\n\n exprs = [\n {:start_expr, ~c\"=\", ~c\" if true do \", %{column: 2, line: 1}},\n {:text, ~c\"\\n TRUE \\n\", %{column: 20, line: 1}},\n {:middle_expr, ~c\"\", ~c\" else \", %{column: 3, line: 3}},\n {:text, ~c\"\\n FALSE \\n\", %{column: 13, line: 3}},\n {:end_expr, ~c\"\", ~c\" end \", %{column: 3, line: 5}},\n {:eof, %{column: 3, line: 7}}\n ]\n\n assert EEx.tokenize(template, [trim: true] ++ @opts) == {:ok, exprs}\n end\n\n test \"trim mode with multi-line comment\" do\n exprs = [\n {:comment, ~c\" comment \", %{column: 3, line: 1}},\n {:text, ~c\"\\n123\", %{column: 23, line: 1}},\n {:eof, %{column: 4, line: 2}}\n ]\n\n assert EEx.tokenize(~c\" <%!-- comment --%> \\n123\", [trim: true] ++ @opts) == {:ok, exprs}\n end\n\n test \"trim mode with CRLF\" do\n exprs = [\n {:text, ~c\"0\\n\", %{column: 1, line: 1}},\n {:expr, ~c\"=\", ~c\" 12 \", %{column: 3, line: 2}},\n {:text, ~c\"\\n34\", %{column: 15, line: 2}},\n {:eof, %{column: 3, line: 3}}\n ]\n\n assert EEx.tokenize(~c\"0\\r\\n <%= 12 %> \\r\\n34\", [trim: true] ++ @opts) == {:ok, exprs}\n end\n\n test \"trim mode set to false\" do\n exprs = [\n {:text, ~c\" \", %{column: 1, line: 1}},\n {:expr, ~c\"=\", ~c\" 12 \", %{column: 2, line: 1}},\n {:text, ~c\" \\n\", %{column: 11, line: 1}},\n {:eof, %{column: 1, line: 2}}\n ]\n\n assert EEx.tokenize(~c\" <%= 12 %> \\n\", [trim: false] ++ @opts) == {:ok, exprs}\n end\n\n test \"trim mode no false positives\" do\n assert_not_trimmed = fn x ->\n assert EEx.tokenize(x, [trim: false] ++ @opts) == EEx.tokenize(x, @opts)\n end\n\n assert_not_trimmed.(~c\"foo <%= \\\"bar\\\" %> \")\n assert_not_trimmed.(~c\"\\n <%= \\\"foo\\\" %>bar\")\n assert_not_trimmed.(~c\" <%% hello %> \")\n assert_not_trimmed.(~c\" <%= 01 %><%= 23 %>\\n\")\n end\n\n test \"returns error when there is start mark and no end mark\" do\n message = \"\"\"\n expected closing '%>' for EEx expression\n |\n 1 | foo <% :bar\n | ^\\\n \"\"\"\n\n assert EEx.tokenize(~c\"foo <% :bar\", @opts) ==\n {:error, message, %{column: 5, line: 1}}\n\n message = \"\"\"\n expected closing '--%>' for EEx expression\n |\n 1 | <%!-- foo\n | ^\\\n \"\"\"\n\n assert EEx.tokenize(~c\"<%!-- foo\", @opts) == {:error, message, %{column: 1, line: 1}}\n end\n\n test \"marks invalid expressions as regular expressions\" do\n assert EEx.tokenize(~c\"<% 1 $ 2 %>\", @opts) ==\n {:ok,\n [\n {:expr, [], ~c\" 1 $ 2 \", %{column: 1, line: 1}},\n {:eof, %{column: 12, line: 1}}\n ]}\n end\nend\n" }, { "path": "lib/eex/test/eex_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\nrequire EEx\n\ndefmodule EExTest.Compiled do\n def before_compile do\n {__ENV__.line, hd(tl(get_stacktrace()))}\n end\n\n EEx.function_from_string(:def, :string_sample, \"<%= a + b %>\", [:a, :b])\n\n filename = Path.join(__DIR__, \"fixtures/eex_template_with_bindings.eex\")\n EEx.function_from_file(:defp, :private_file_sample, filename, [:bar])\n\n filename = Path.join(__DIR__, \"fixtures/eex_template_with_bindings.eex\")\n EEx.function_from_file(:def, :public_file_sample, filename, [:bar])\n\n def file_sample(arg), do: private_file_sample(arg)\n\n def after_compile do\n {__ENV__.line, hd(tl(get_stacktrace()))}\n end\n\n @file \"unknown\"\n def unknown do\n {__ENV__.line, hd(tl(get_stacktrace()))}\n end\n\n defp get_stacktrace do\n try do\n :erlang.error(\"failed\")\n rescue\n _ -> __STACKTRACE__\n end\n end\nend\n\ndefmodule Clause do\n defmacro defclause(expr, block) do\n quote do\n def unquote(expr), unquote(block)\n end\n end\nend\n\ndefmodule EExTest do\n use ExUnit.Case, async: true\n\n doctest EEx\n doctest EEx.Engine\n doctest EEx.SmartEngine\n\n describe \"evaluates\" do\n test \"simple string\" do\n assert_eval(\"foo bar\", \"foo bar\")\n end\n\n test \"Unicode\" do\n template = \"\"\"\n • <%= \"•\" %> •\n <%= \"Jößé Vâlìm\" %> Jößé Vâlìm\n \"\"\"\n\n assert_eval(\" • • •\\n Jößé Vâlìm Jößé Vâlìm\\n\", template)\n end\n\n test \"no spaces\" do\n string = \"\"\"\n <%=cond do%>\n <%false ->%>\n this\n <%true ->%>\n that\n <%end%>\n \"\"\"\n\n expected = \"\\n that\\n\\n\"\n assert_eval(expected, string, [])\n end\n\n test \"trim mode\" do\n string = \"<%= 123 %> \\n \\n <%= 789 %>\"\n expected = \"123\\n789\"\n assert_eval(expected, string, [], trim: true)\n\n string = \"<%= 123 %> \\n456\\n <%= 789 %>\"\n expected = \"123\\n456\\n789\"\n assert_eval(expected, string, [], trim: true)\n\n string = \"<%= 123 %> \\n\\n456\\n\\n <%= 789 %>\"\n expected = \"123\\n456\\n789\"\n assert_eval(expected, string, [], trim: true)\n\n string = \"<%= 123 %> \\n \\n456\\n \\n <%= 789 %>\"\n expected = \"123\\n456\\n789\"\n assert_eval(expected, string, [], trim: true)\n\n string = \"\\n <%= 123 %> \\n <%= 456 %> \\n <%= 789 %> \\n\"\n expected = \"123\\n456\\n789\"\n assert_eval(expected, string, [], trim: true)\n\n string = \"\\r\\n <%= 123 %> \\r\\n <%= 456 %> \\r\\n <%= 789 %> \\r\\n\"\n expected = \"123\\n456\\n789\"\n assert_eval(expected, string, [], trim: true)\n end\n\n test \"trim mode with middle expression\" do\n string = \"\"\"\n <%= cond do %>\n <% false -> %>\n this\n <% true -> %>\n that\n <% end %>\n \"\"\"\n\n expected = \"\\n that\\n\"\n assert_eval(expected, string, [], trim: true)\n end\n\n test \"trim mode with multiple lines\" do\n string = \"\"\"\n <%= \"First line\" %>\n <%= \"Second line\" %>\n <%= \"Third line\" %>\n <%= \"Fourth line\" %>\n \"\"\"\n\n expected = \"First line\\nSecond line\\nThird line\\nFourth line\"\n assert_eval(expected, string, [], trim: true)\n end\n\n test \"trim mode with no spaces\" do\n string = \"\"\"\n <%=if true do%>\n this\n <%else%>\n that\n <%end%>\n \"\"\"\n\n expected = \"\\n this\\n\"\n assert_eval(expected, string, [], trim: true)\n\n string = \"\"\"\n <%=cond do%>\n <%false ->%>\n this\n <%true ->%>\n that\n <%end%>\n \"\"\"\n\n expected = \"\\n that\\n\"\n assert_eval(expected, string, [], trim: true)\n end\n\n test \"embedded code\" do\n assert_eval(\"foo bar\", \"foo <%= :bar %>\")\n end\n\n test \"embedded code with binding\" do\n assert EEx.eval_string(\"foo <%= bar %>\", bar: 1) == \"foo 1\"\n end\n\n test \"embedded code with do end when true\" do\n assert_eval(\"foo bar\", \"foo <%= if true do %>bar<% end %>\")\n end\n\n test \"embedded code with do end when false\" do\n assert_eval(\"foo \", \"foo <%= if false do %>bar<% end %>\")\n end\n\n test \"embedded code with do preceded by bracket\" do\n assert_eval(\"foo bar\", \"foo <%= if {true}do %>bar<% end %>\")\n assert_eval(\"foo bar\", \"foo <%= if (true)do %>bar<% end %>\")\n assert_eval(\"foo bar\", \"foo <%= if [true]do %>bar<% end %>\")\n end\n\n test \"embedded code with do end and expression\" do\n assert_eval(\"foo bar\", \"foo <%= if true do %><%= :bar %><% end %>\")\n end\n\n test \"embedded code with do end and multiple expressions\" do\n assert_eval(\n \"foo bar baz\",\n \"foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>\"\n )\n\n assert Process.get(:eex_text) == 1\n end\n\n test \"embedded code with middle expression\" do\n assert_eval(\"foo bar\", \"foo <%= if true do %>bar<% else %>baz<% end %>\")\n end\n\n test \"embedded code with evaluated middle expression\" do\n assert_eval(\"foo baz\", \"foo <%= if false do %>bar<% else %>baz<% end %>\")\n end\n\n test \"embedded code with multi-line comments in do end\" do\n assert_eval(\"foo bar\", \"foo <%= case true do %><%!-- comment --%><% true -> %>bar<% end %>\")\n\n assert_eval(\n \"foo\\n\\nbar\\n\",\n \"foo\\n<%= case true do %>\\n<%!-- comment --%>\\n<% true -> %>\\nbar\\n<% end %>\"\n )\n end\n\n test \"embedded code with nested do end\" do\n assert_eval(\"foo bar\", \"foo <%= if true do %><%= if true do %>bar<% end %><% end %>\")\n end\n\n test \"embedded code with nested do end with middle expression\" do\n assert_eval(\n \"foo baz\",\n \"foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>\"\n )\n end\n\n test \"embedded code with end followed by bracket\" do\n assert_eval(\n \" 101 102 103 \",\n \"<%= Enum.map([1, 2, 3], fn x -> %> <%= 100 + x %> <% end) %>\"\n )\n\n assert_eval(\n \" 101 102 103 \",\n \"<%= Enum.map([1, 2, 3], fn x ->\\n%> <%= 100 + x %> <% end) %>\"\n )\n\n assert_eval(\n \" 101 102 103 \",\n \"<%= apply Enum, :map, [[1, 2, 3], fn x -> %> <%= 100 + x %> <% end] %>\"\n )\n\n assert_eval(\n \" 101 102 103 \",\n \"<%= #{__MODULE__}.tuple_map {[1, 2, 3], fn x -> %> <%= 100 + x %> <% end} %>\"\n )\n\n assert_eval(\n \" 101 102 103 \",\n \"<%= apply(Enum, :map, [[1, 2, 3], fn x -> %> <%= 100 + x %> <% end]) %>\"\n )\n\n assert_eval(\n \" 101 102 103 \",\n \"<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>\"\n )\n end\n\n test \"embedded code with variable definition\" do\n assert_eval(\"foo 1\", \"foo <% bar = 1 %><%= bar %>\")\n end\n\n test \"embedded code with require\" do\n assert_eval(\"foo 1,2,3\", \"foo <% require Enum, as: E %><%= E.join [1, 2, 3], \\\",\\\" %>\")\n end\n\n test \"with end of token\" do\n assert_eval(\"foo bar %>\", \"foo bar %>\")\n end\n end\n\n describe \"raises syntax errors\" do\n test \"with relative file information\" do\n message = \"\"\"\n foobar.eex:1:5: expected closing '%>' for EEx expression\n |\n 1 | foo <%= bar\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo <%= bar\", file: Path.join(File.cwd!(), \"foobar.eex\"))\n end\n end\n\n test \"when <%!-- is not closed\" do\n message = \"\"\"\n my_file.eex:1:5: expected closing '--%>' for EEx expression\n |\n 1 | foo <%!-- bar\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo <%!-- bar\", file: \"my_file.eex\")\n end\n end\n\n test \"when the token is invalid\" do\n message = \"\"\"\n nofile:1:5: expected closing '%>' for EEx expression\n |\n 1 | foo <%= bar\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo <%= bar\")\n end\n end\n\n test \"when middle expression is found without a start expression\" do\n message = \"\"\"\n nofile:5:1: unexpected middle of expression <% else %>\n |\n 2 | <%= \"content\" %>\n 3 | <%= if true %>\n 4 | <%= \"foo\" %>\n 5 | <% else %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\n ~s(

Hi!

\\n<%= \"content\" %>\\n<%= if true %>\\n <%= \"foo\" %>\\n<% else %>\\n bar<% end %>)\n )\n end\n end\n\n test \"proper format line number of code snippet\" do\n message = \"\"\"\n nofile:11:1: unexpected middle of expression <% else %>\n |\n 8 | <%= \"content\" %>\n 9 | <%= if true %>\n 10 | <%= \"foo\" %>\n 11 | <% else %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\n ~s(\\n\\n\\n\\n\\n\\n

Hi!

\\n<%= \"content\" %>\\n<%= if true %>\\n <%= \"foo\" %>\\n<% else %>\\n bar<% end %>)\n )\n end\n end\n\n test \"when there is only middle expression\" do\n message = \"\"\"\n nofile:1:1: unexpected middle of expression <% else %>\n |\n 1 | <% else %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(~s(<% else %>))\n end\n end\n\n test \"when it is missing a `do` in case expr\" do\n message = \"\"\"\n nofile:3:3: unexpected middle of expression <% :something -> %>\n |\n 1 | content\n 2 | <%= case @var %>\n 3 | <% :something -> %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"content\\n<%= case @var %>\\n <% :something -> %>\\n bar<% end %>\")\n end\n end\n\n test \"when it is a `do` in cond expr\" do\n message = \"\"\"\n nofile:3:3: unexpected middle of expression <% true -> %>\n |\n 1 | content\n 2 | <%= cond %>\n 3 | <% true -> %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"content\\n<%= cond %>\\n <% true -> %>\\n bar<% end %>\")\n end\n end\n\n test \"when end expression is found without a start expression\" do\n message = \"\"\"\n nofile:1:5: unexpected end of expression <% end %>\n |\n 1 | foo <% end %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo <% end %>\")\n end\n end\n\n test \"when start expression is found without an end expression\" do\n message = \"\"\"\n nofile:2:5: expected a closing '<% end %>' for block expression in EEx\n |\n 1 | foo\n 2 | <%= if true do %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo\\n<%= if true do %>\\nfoo\\n\")\n end\n\n message = \"\"\"\n nofile:3:3: expected a closing '<% end %>' for block expression in EEx\n |\n 1 | foo\n 2 | <%=\n 3 | if true do %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo\\n<%=\\n if true do %>\\nfoo\\n\", indentation: 0)\n end\n\n message = \"\"\"\n nofile:3:6: expected a closing '<% end %>' for block expression in EEx\n |\n 1 | foo\n 2 | <%=\n 3 | if true do %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo\\n<%=\\n if true do %>\\nfoo\\n\", indentation: 3)\n end\n end\n\n test \"when start expression with middle expression is found without an end expression\" do\n message = \"\"\"\n nofile:2:5: expected a closing '<% end %>' for block expression in EEx\n |\n 1 | foo\n 2 | <%= if true do %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo\\n<%= if true do %>\\nfoo\\n<% else %>\\n\")\n end\n end\n\n test \"when multiple start expressions is found without an end expression\" do\n message = \"\"\"\n nofile:5:5: expected a closing '<% end %>' for block expression in EEx\n |\n 2 | <%= if true do %>\n 3 | <%= @something %>\n 4 |\\s\n 5 | <%= if @var do %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\n \"foo\\n<%= if true do %>\\n <%= @something %>\\n\\n<%= if @var do %>\\nfoo\\n\"\n )\n end\n end\n\n test \"when nested end expression is found without a start expression\" do\n message = \"\"\"\n nofile:1:31: unexpected end of expression <% end %>\n |\n 1 | foo <%= if true do %><% end %><% end %>\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo <%= if true do %><% end %><% end %>\")\n end\n end\n\n test \"when trying to use marker '|' without implementation\" do\n msg =\n ~r/unsupported EEx syntax <%| %> \\(the syntax is valid but not supported by the current EEx engine\\)/\n\n assert_raise EEx.SyntaxError, msg, fn ->\n EEx.compile_string(\"<%| true %>\")\n end\n end\n\n test \"when trying to use marker '/' without implementation\" do\n msg =\n ~r/unsupported EEx syntax <%\\/ %> \\(the syntax is valid but not supported by the current EEx engine\\)/\n\n assert_raise EEx.SyntaxError, msg, fn ->\n EEx.compile_string(\"<%/ true %>\")\n end\n end\n\n test \"from Elixir parser\" do\n line = __ENV__.line + 6\n\n message =\n assert_raise TokenMissingError, fn ->\n EEx.compile_string(\n \"\"\"\n
  • \n Some:\n <%= true && @some[ %>\n
    • \n \"\"\",\n file: __ENV__.file,\n line: line,\n indentation: 12\n )\n end\n\n assert message |> Exception.message() |> strip_ansi() =~ \"\"\"\n │\n 514 │ true && @some[\\s\n │ │ └ missing closing delimiter (expected \"]\")\n │ └ unclosed delimiter\n \"\"\"\n end\n\n test \"from Elixir parser with line breaks\" do\n line = __ENV__.line + 6\n\n message =\n assert_raise TokenMissingError, fn ->\n EEx.compile_string(\n \"\"\"\n
  • \n Some:\n <%= true &&\n @some[ %>\n
    • \n \"\"\",\n file: __ENV__.file,\n line: line,\n indentation: 12\n )\n end\n\n assert message |> Exception.message() |> strip_ansi() =~ \"\"\"\n │\n #{line + 3} │ @some[\\s\n │ │ └ missing closing delimiter (expected \"]\")\n │ └ unclosed delimiter\n \"\"\"\n end\n\n test \"honor line numbers\" do\n assert_raise EEx.SyntaxError,\n \"nofile:100:6: expected closing '%>' for EEx expression\",\n fn ->\n EEx.compile_string(\"foo\\n bar <%= baz\", line: 99)\n end\n end\n\n test \"honor file names\" do\n message = \"\"\"\n my_file.eex:1:5: expected closing '%>' for EEx expression\n |\n 1 | foo <%= bar\n | ^\\\n \"\"\"\n\n assert_raise EEx.SyntaxError, message, fn ->\n EEx.compile_string(\"foo <%= bar\", file: \"my_file.eex\")\n end\n end\n end\n\n describe \"warnings\" do\n test \"when middle expression has a modifier\" do\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n EEx.compile_string(\"foo <%= if true do %>true<%= else %>false<% end %>\")\n end) =~ ~s[unexpected beginning of EEx tag \\\"<%=\\\" on \\\"<%= else %>\\\"]\n end\n\n test \"when end expression has a modifier\" do\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n EEx.compile_string(\"foo <%= if true do %>true<% else %>false<%= end %>\")\n end) =~\n ~s[unexpected beginning of EEx tag \\\"<%=\\\" on \\\"<%= end %>\\\"]\n end\n\n test \"unused \\\"do\\\" block without \\\"<%=\\\" modifier\" do\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n EEx.compile_string(\"<% if true do %>I'm invisible!<% end %>\")\n end) =~ \"the contents of this expression won't be output\"\n\n # These are fine though\n EEx.compile_string(\"<% foo = fn -> %>Hello<% end %>\")\n EEx.compile_string(\"<% foo = if true do %>Hello<% end %>\")\n end\n\n test \"from tokenizer\" do\n warning =\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n EEx.compile_string(~s'<%= :\"foo\" %>', file: \"tokenizer.ex\")\n end)\n\n assert warning =~ \"found quoted atom \\\"foo\\\" but the quotes are not required\"\n assert warning =~ \"tokenizer.ex:1:5\"\n end\n end\n\n describe \"environment\" do\n test \"respects line numbers\" do\n expected = \"\"\"\n foo\n 2\n \"\"\"\n\n string = \"\"\"\n foo\n <%= __ENV__.line %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"respects line numbers inside nested expressions\" do\n expected = \"\"\"\n foo\n\n 3\n\n 5\n \"\"\"\n\n string = \"\"\"\n foo\n <%= if true do %>\n <%= __ENV__.line %>\n <% end %>\n <%= __ENV__.line %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"respects line numbers inside start expression\" do\n expected = \"\"\"\n foo\n\n true\n\n 5\n \"\"\"\n\n string = \"\"\"\n foo\n <%= if __ENV__.line == 2 do %>\n <%= true %>\n <% end %>\n <%= __ENV__.line %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"respects line numbers inside middle expression with ->\" do\n expected = \"\"\"\n foo\n\n true\n\n 7\n \"\"\"\n\n string = \"\"\"\n foo\n <%= cond do %>\n <% false -> %> false\n <% __ENV__.line == 4 -> %>\n <%= true %>\n <% end %>\n <%= __ENV__.line %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"respects line number inside middle expressions with keywords\" do\n expected = \"\"\"\n foo\n\n 5\n\n 7\n \"\"\"\n\n string = \"\"\"\n foo\n <%= if false do %>\n <%= __ENV__.line %>\n <% else %>\n <%= __ENV__.line %>\n <% end %>\n <%= __ENV__.line %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"respects files\" do\n assert_eval(\"sample.ex\", \"<%= __ENV__.file %>\", [], file: \"sample.ex\")\n end\n end\n\n describe \"clauses\" do\n test \"inside functions\" do\n expected = \"\"\"\n\n Number 1\n\n Number 2\n\n Number 3\n\n \"\"\"\n\n string = \"\"\"\n <%= Enum.map [1, 2, 3], fn x -> %>\n Number <%= x %>\n <% end %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"inside multiple functions\" do\n expected = \"\"\"\n\n A 1\n\n B 2\n\n A 3\n\n \"\"\"\n\n string = \"\"\"\n <%= #{__MODULE__}.switching_map [1, 2, 3], fn x -> %>\n A <%= x %>\n <% end, fn x -> %>\n B <%= x %>\n <% end %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"inside callback and do block\" do\n expected = \"\"\"\n\n\n A 1\n\n B 2\n\n A 3\n\n \"\"\"\n\n string = \"\"\"\n <% require #{__MODULE__} %>\n <%= #{__MODULE__}.switching_macro [1, 2, 3], fn x -> %>\n A <%= x %>\n <% end do %>\n B <%= x %>\n <% end %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"inside cond\" do\n expected = \"\"\"\n foo\n\n true\n\n \"\"\"\n\n string = \"\"\"\n foo\n <%= cond do %>\n <% false -> %> false\n <% fn -> 1 end -> %>\n <%= true %>\n <% end %>\n \"\"\"\n\n assert_eval(expected, string)\n end\n\n test \"inside cond with do end\" do\n string = \"\"\"\n <% y = [\"a\", \"b\", \"c\"] %>\n <%= cond do %>\n <% \"a\" in y -> %>\n Good\n <% true -> %>\n <%= if true do %>true<% else %>false<% end %>\n Bad\n <% end %>\n \"\"\"\n\n assert_eval(\"\\n\\n Good\\n \\n\", string)\n end\n\n test \"line and column meta\" do\n indentation = 12\n\n ast =\n EEx.compile_string(\n \"\"\"\n <%= f() %> <% f() %>\n <%= f fn -> %>\n <%= f() %>\n <% end %>\n \"\"\",\n indentation: indentation\n )\n\n {_, calls} =\n Macro.prewalk(ast, [], fn\n {:f, meta, _args} = expr, acc -> {expr, [meta | acc]}\n other, acc -> {other, acc}\n end)\n\n assert Enum.reverse(calls) == [\n [line: 1, column: indentation + 5],\n [line: 1, column: indentation + 15],\n [line: 2, column: indentation + 7],\n [line: 3, column: indentation + 9]\n ]\n end\n end\n\n describe \"buffers\" do\n test \"inside comprehensions\" do\n string = \"\"\"\n <%= for _name <- packages || [] do %>\n <% end %>\n <%= all || :done %>\n \"\"\"\n\n assert_eval(\"\\ndone\\n\", string, packages: nil, all: nil)\n end\n end\n\n describe \"from file\" do\n test \"evaluates the source\" do\n filename = Path.join(__DIR__, \"fixtures/eex_template.eex\")\n result = EEx.eval_file(filename)\n assert_normalized_newline_equal(\"foo bar.\\n\", result)\n end\n\n test \"evaluates the source with bindings\" do\n filename = Path.join(__DIR__, \"fixtures/eex_template_with_bindings.eex\")\n result = EEx.eval_file(filename, bar: 1)\n assert_normalized_newline_equal(\"foo 1\\n\", result)\n end\n\n test \"raises an Exception when file is missing\" do\n msg = \"could not read file \\\"non-existent.eex\\\": no such file or directory\"\n\n assert_raise File.Error, msg, fn ->\n filename = \"non-existent.eex\"\n EEx.compile_file(filename)\n end\n end\n\n test \"sets external resource attribute\" do\n assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==\n [Path.join(__DIR__, \"fixtures/eex_template_with_bindings.eex\")]\n end\n\n test \"supports t:Path.t() paths\" do\n filename = to_charlist(Path.join(__DIR__, \"fixtures/eex_template_with_bindings.eex\"))\n result = EEx.eval_file(filename, bar: 1)\n assert_normalized_newline_equal(\"foo 1\\n\", result)\n end\n\n test \"supports overriding file and line through options\" do\n filename = Path.join(__DIR__, \"fixtures/eex_template_with_syntax_error.eex\")\n\n assert_raise EEx.SyntaxError,\n \"my_file.eex:10:5: expected closing '%>' for EEx expression\",\n fn ->\n EEx.eval_file(filename, _bindings = [], file: \"my_file.eex\", line: 10)\n end\n end\n end\n\n describe \"precompiled\" do\n test \"from string\" do\n assert EExTest.Compiled.string_sample(1, 2) == \"3\"\n end\n\n test \"from file\" do\n assert_normalized_newline_equal(\"foo 1\\n\", EExTest.Compiled.file_sample(1))\n assert_normalized_newline_equal(\"foo 1\\n\", EExTest.Compiled.public_file_sample(1))\n end\n\n test \"from file does not affect backtrace\" do\n file = to_charlist(Path.relative_to_cwd(__ENV__.file))\n\n assert EExTest.Compiled.before_compile() ==\n {11, {EExTest.Compiled, :before_compile, 0, [file: file, line: 11]}}\n\n assert EExTest.Compiled.after_compile() ==\n {25, {EExTest.Compiled, :after_compile, 0, [file: file, line: 25]}}\n\n assert EExTest.Compiled.unknown() ==\n {30, {EExTest.Compiled, :unknown, 0, [file: ~c\"unknown\", line: 30]}}\n end\n end\n\n defmodule TestEngine do\n @behaviour EEx.Engine\n\n def init(_opts) do\n \"INIT\"\n end\n\n def handle_body(body) do\n \"BODY(#{body})\"\n end\n\n def handle_begin(_) do\n \"BEGIN\"\n end\n\n def handle_end(buffer) do\n buffer <> \":END\"\n end\n\n def handle_text(buffer, meta, text) do\n buffer <> \":TEXT-#{meta[:line]}-#{meta[:column]}(#{String.trim(text)})\"\n end\n\n def handle_expr(buffer, \"/\", expr) do\n buffer <> \":DIV(#{Macro.to_string(expr)})\"\n end\n\n def handle_expr(buffer, \"=\", expr) do\n buffer <> \":EQUAL(#{Macro.to_string(expr)})\"\n end\n\n def handle_expr(buffer, mark, expr) do\n EEx.Engine.handle_expr(buffer, mark, expr)\n end\n end\n\n describe \"custom engines\" do\n test \"text\" do\n assert_eval(\"BODY(INIT:TEXT-1-1(foo))\", \"foo\", [], engine: TestEngine)\n end\n\n test \"custom marker\" do\n assert_eval(\"BODY(INIT:TEXT-1-1(foo):DIV(:bar))\", \"foo <%/ :bar %>\", [], engine: TestEngine)\n end\n\n test \"begin/end\" do\n assert_eval(\n ~s[BODY(INIT:TEXT-1-1(foo):EQUAL(if do\\n \"BEGIN:TEXT-1-17(this):END\"\\nelse\\n \"BEGIN:TEXT-1-31(that):END\"\\nend))],\n \"foo <%= if do %>this<% else %>that<% end %>\",\n [],\n engine: TestEngine\n )\n end\n\n test \"not implemented custom marker\" do\n msg =\n ~r/unsupported EEx syntax <%| %> \\(the syntax is valid but not supported by the current EEx engine\\)/\n\n assert_raise EEx.SyntaxError, msg, fn ->\n assert_eval({:wrapped, \"foo baz\"}, \"foo <%| :bar %>\", [], engine: TestEngine)\n end\n end\n end\n\n describe \"parser options\" do\n test \"customizes parsed code\" do\n atoms_encoder = fn \"not_jose\", _ -> {:ok, :jose} end\n\n assert_eval(\"valid\", \"<%= not_jose %>\", [jose: \"valid\"],\n parser_options: [static_atoms_encoder: atoms_encoder]\n )\n end\n end\n\n @strip_ansi [IO.ANSI.green(), IO.ANSI.red(), IO.ANSI.reset()]\n\n defp strip_ansi(doc) do\n String.replace(doc, @strip_ansi, \"\")\n end\n\n defp assert_eval(expected, actual, binding \\\\ [], opts \\\\ []) do\n opts = Keyword.merge([file: __ENV__.file, engine: opts[:engine] || EEx.Engine], opts)\n result = EEx.eval_string(actual, binding, opts)\n assert result == expected\n end\n\n defp assert_normalized_newline_equal(expected, actual) do\n assert String.replace(expected, \"\\r\\n\", \"\\n\") == String.replace(actual, \"\\r\\n\", \"\\n\")\n end\n\n def tuple_map({list, callback}) do\n Enum.map(list, callback)\n end\n\n def switching_map(list, a, b) do\n list\n |> Enum.with_index()\n |> Enum.map(fn\n {element, index} when rem(index, 2) == 0 -> a.(element)\n {element, index} when rem(index, 2) == 1 -> b.(element)\n end)\n end\n\n defmacro switching_macro(list, a, do: block) do\n quote do\n b = fn var!(x) ->\n unquote(block)\n end\n\n unquote(__MODULE__).switching_map(unquote(list), unquote(a), b)\n end\n end\nend\n" }, { "path": "lib/eex/test/fixtures/eex_template.eex", "content": "foo <%= if true do %>bar.<% end %>\n" }, { "path": "lib/eex/test/fixtures/eex_template_with_bindings.eex", "content": "foo <%= bar %>\n" }, { "path": "lib/eex/test/fixtures/eex_template_with_syntax_error.eex", "content": "foo <%= bar\n" }, { "path": "lib/eex/test/test_helper.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\n{line_exclude, line_include} =\n if line = System.get_env(\"LINE\"), do: {[:test], [line: line]}, else: {[], []}\n\nCode.require_file(\"../../elixir/scripts/cover_record.exs\", __DIR__)\nCoverageRecorder.maybe_record(\"eex\")\n\nmaybe_seed_opt = if seed = System.get_env(\"SEED\"), do: [seed: String.to_integer(seed)], else: []\n\nex_unit_opts =\n [\n trace: !!System.get_env(\"TRACE\"),\n include: line_include,\n exclude: line_exclude\n ] ++ maybe_seed_opt\n\nExUnit.start(ex_unit_opts)\n" }, { "path": "lib/elixir/Emakefile", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n{'src/*', [\n warn_unused_vars,\n warn_export_all,\n warn_shadow_vars,\n warn_unused_import,\n warn_unused_function,\n warn_bif_clash,\n warn_unused_record,\n warn_deprecated_function,\n warn_obsolete_guard,\n warn_exported_vars,\n %% Enable this when we require Erlang/OTP 27+\n %% warnings_as_errors,\n debug_info,\n {outdir, \"ebin/\"}\n]}.\n" }, { "path": "lib/elixir/lib/access.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Access do\n @moduledoc \"\"\"\n Key-based access to data structures.\n\n The `Access` module defines a behaviour for dynamically accessing\n keys of any type in a data structure via the `data[key]` syntax.\n\n `Access` supports keyword lists (`Keyword`) and maps (`Map`) out\n of the box. Keywords supports only atoms keys, keys for maps can\n be of any type. Both return `nil` if the key does not exist:\n\n iex> keywords = [a: 1, b: 2]\n iex> keywords[:a]\n 1\n iex> keywords[:c]\n nil\n\n iex> map = %{a: 1, b: 2}\n iex> map[:a]\n 1\n\n iex> star_ratings = %{1.0 => \"★\", 1.5 => \"★☆\", 2.0 => \"★★\"}\n iex> star_ratings[1.5]\n \"★☆\"\n\n This syntax is very convenient as it can be nested arbitrarily:\n\n iex> keywords = [a: 1, b: 2]\n iex> keywords[:c][:unknown]\n nil\n\n This works because accessing anything on a `nil` value, returns\n `nil` itself:\n\n iex> nil[:a]\n nil\n\n ## Maps and structs\n\n While the access syntax is allowed in maps via `map[key]`,\n if your map is made of predefined atom keys, you should prefer\n to access those atom keys with `map.key` instead of `map[key]`,\n as `map.key` will raise if the key is missing (which is not\n supposed to happen if the keys are predefined) or if `map` is\n `nil`.\n\n Similarly, since structs are maps and structs have predefined\n keys, they only allow the `struct.key` syntax and they do not\n allow the `struct[key]` access syntax.\n\n In other words, the `map[key]` syntax is loose, returning `nil`\n for missing keys, while the `map.key` syntax is strict, raising\n for both nil values and missing keys.\n\n To bridge this gap, Elixir provides the `get_in/1` and `get_in/2`\n functions, which are capable of traversing nested data structures,\n even in the presence of `nil`s:\n\n iex> users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n iex> get_in(users[\"john\"].age)\n 27\n iex> get_in(users[\"unknown\"].age)\n nil\n\n Notice how, even if no user was found, `get_in/1` returned `nil`.\n Outside of `get_in/1`, trying to access the field `.age` on `nil`\n would raise.\n\n The `get_in/2` function takes one step further by allowing\n different accessors to be mixed in. For example, given a user\n map with the `:name` and `:languages` keys, here is how to\n access the name of all programming languages:\n\n iex> languages = [\n ...> %{name: \"elixir\", type: :functional},\n ...> %{name: \"c\", type: :procedural}\n ...> ]\n iex> user = %{name: \"john\", languages: languages}\n iex> get_in(user, [:languages, Access.all(), :name])\n [\"elixir\", \"c\"]\n\n This module provides convenience functions for traversing other\n structures, like tuples and lists. As we will see next, they can\n even be used to update nested data structures.\n\n If you want to learn more about the dual nature of maps in Elixir,\n as they can be either for structured data or as a key-value store,\n see the `Map` module.\n\n ## Updating nested data structures\n\n The access syntax can also be used with the `Kernel.put_in/2`,\n `Kernel.update_in/2`, `Kernel.get_and_update_in/2`, and `Kernel.pop_in/1`\n macros to further manipulate values in nested data structures:\n\n iex> users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n iex> put_in(users[\"john\"].age, 28)\n %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}\n\n As shown in the previous section, you can also use the\n `Kernel.put_in/3`, `Kernel.update_in/3`, `Kernel.pop_in/2`, and\n `Kernel.get_and_update_in/3` functions to provide nested\n custom accessors. For instance, given a user map with the\n `:name` and `:languages` keys, here is how to deeply traverse\n the map and convert all language names to uppercase:\n\n iex> languages = [\n ...> %{name: \"elixir\", type: :functional},\n ...> %{name: \"c\", type: :procedural}\n ...> ]\n iex> user = %{name: \"john\", languages: languages}\n iex> update_in(user, [:languages, Access.all(), :name], &String.upcase/1)\n %{\n name: \"john\",\n languages: [\n %{name: \"ELIXIR\", type: :functional},\n %{name: \"C\", type: :procedural}\n ]\n }\n\n See the functions `key/1`, `key!/1`, `elem/1`, and `all/0` for\n some of the available accessors.\n \"\"\"\n\n @type container :: keyword | struct | map\n @type nil_container :: nil\n @type t :: container | nil_container | any\n @type key :: any\n @type value :: any\n\n @type get_fun(data) ::\n (:get, data, (term -> term) -> new_data :: container)\n\n @type get_and_update_fun(data, current_value) ::\n (:get_and_update, data, (term -> term) ->\n {current_value, new_data :: container} | :pop)\n\n @type access_fun(data, current_value) ::\n get_fun(data) | get_and_update_fun(data, current_value)\n\n @doc \"\"\"\n Invoked in order to access the value stored under `key` in the given term `term`.\n\n This function should return `{:ok, value}` where `value` is the value under\n `key` if the key exists in the term, or `:error` if the key does not exist in\n the term.\n\n Many of the functions defined in the `Access` module internally call this\n function. This function is also used when the square-brackets access syntax\n (`structure[key]`) is used: the `fetch/2` callback implemented by the module\n that defines the `structure` struct is invoked and if it returns `{:ok,\n value}` then `value` is returned, or if it returns `:error` then `nil` is\n returned.\n\n See the `Map.fetch/2` and `Keyword.fetch/2` implementations for examples of\n how to implement this callback.\n \"\"\"\n @callback fetch(term :: t, key) :: {:ok, value} | :error\n\n @doc \"\"\"\n Invoked in order to access the value under `key` and update it at the same time.\n\n The implementation of this callback should invoke `fun` with the value under\n `key` in the passed structure `data`, or with `nil` if `key` is not present in it.\n This function must return either `{current_value, new_value}` or `:pop`.\n\n If the passed function returns `{current_value, new_value}`,\n the return value of this callback should be `{current_value, new_data}`, where:\n\n * `current_value` is the retrieved value (which can be operated on before being returned)\n\n * `new_value` is the new value to be stored under `key`\n\n * `new_data` is `data` after updating the value of `key` with `new_value`.\n\n If the passed function returns `:pop`, the return value of this callback\n must be `{value, new_data}` where `value` is the value under `key`\n (or `nil` if not present) and `new_data` is `data` without `key`.\n\n See the implementations of `Map.get_and_update/3` or `Keyword.get_and_update/3`\n for more examples.\n \"\"\"\n @callback get_and_update(data, key, (value | nil -> {current_value, new_value :: value} | :pop)) ::\n {current_value, new_data :: data}\n when current_value: value, data: container\n\n @doc \"\"\"\n Invoked to \"pop\" the value under `key` out of the given data structure.\n\n When `key` exists in the given structure `data`, the implementation should\n return a `{value, new_data}` tuple where `value` is the value that was under\n `key` and `new_data` is `term` without `key`.\n\n When `key` is not present in the given structure, a tuple `{value, data}`\n should be returned, where `value` is implementation-defined.\n\n See the implementations for `Map.pop/3` or `Keyword.pop/3` for more examples.\n \"\"\"\n @callback pop(data, key) :: {value, data} when data: container\n\n defmacrop raise_undefined_behaviour(exception, module, top) do\n quote do\n exception =\n case __STACKTRACE__ do\n [unquote(top) | _] ->\n reason =\n \"\"\"\n #{inspect(unquote(module))} does not implement the Access behaviour\n\n You can use the \"struct.field\" syntax to access struct fields. \\\n You can also use Access.key!/1 to access struct fields dynamically \\\n inside get_in/put_in/update_in\\\n \"\"\"\n\n %{unquote(exception) | reason: reason}\n\n _ ->\n unquote(exception)\n end\n\n reraise exception, __STACKTRACE__\n end\n end\n\n @doc \"\"\"\n Fetches the value for the given key in a container (a map, keyword\n list, or struct that implements the `Access` behaviour).\n\n Returns `{:ok, value}` where `value` is the value under `key` if there is such\n a key, or `:error` if `key` is not found.\n\n ## Examples\n\n iex> Access.fetch(%{name: \"meg\", age: 26}, :name)\n {:ok, \"meg\"}\n\n iex> Access.fetch([ordered: true, on_timeout: :exit], :timeout)\n :error\n\n \"\"\"\n @spec fetch(container, term) :: {:ok, term} | :error\n @spec fetch(nil_container, any) :: :error\n def fetch(container, key)\n\n def fetch(%module{} = container, key) do\n module.fetch(container, key)\n rescue\n exception in UndefinedFunctionError ->\n raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})\n end\n\n def fetch(map, key) when is_map(map) do\n case map do\n %{^key => value} -> {:ok, value}\n _ -> :error\n end\n end\n\n def fetch(list, key) when is_list(list) and is_atom(key) do\n case :lists.keyfind(key, 1, list) do\n {_, value} -> {:ok, value}\n false -> :error\n end\n end\n\n def fetch(list, key) when is_list(list) do\n raise ArgumentError,\n \"the Access calls for keywords expect the key to be an atom, got: \" <> inspect(key)\n end\n\n def fetch(nil, _key) do\n :error\n end\n\n @doc \"\"\"\n Same as `fetch/2` but returns the value directly,\n or raises a `KeyError` exception if `key` is not found.\n\n ## Examples\n\n iex> Access.fetch!(%{name: \"meg\", age: 26}, :name)\n \"meg\"\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec fetch!(container, term) :: term\n def fetch!(container, key) do\n case fetch(container, key) do\n {:ok, value} -> value\n :error -> raise(KeyError, key: key, term: container)\n end\n end\n\n @doc \"\"\"\n Gets the value for the given key in a container (a map, keyword\n list, or struct that implements the `Access` behaviour).\n\n Returns the value under `key` if there is such a key, or `default` if `key` is\n not found.\n\n ## Examples\n\n iex> Access.get(%{name: \"john\"}, :name, \"default name\")\n \"john\"\n iex> Access.get(%{name: \"john\"}, :age, 25)\n 25\n\n iex> Access.get([ordered: true], :timeout)\n nil\n\n \"\"\"\n @spec get(container, term, term) :: term\n @spec get(nil_container, any, default) :: default when default: var\n def get(container, key, default \\\\ nil)\n\n # Reimplementing the same logic as Access.fetch/2 here is done for performance, since\n # this is called a lot and calling fetch/2 means introducing some overhead (like\n # building the \"{:ok, _}\" tuple and deconstructing it back right away).\n\n def get(%module{} = container, key, default) do\n try do\n module.fetch(container, key)\n rescue\n exception in UndefinedFunctionError ->\n raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})\n else\n {:ok, value} -> value\n :error -> default\n end\n end\n\n def get(map, key, default) when is_map(map) do\n case map do\n %{^key => value} -> value\n _ -> default\n end\n end\n\n def get(list, key, default) when is_list(list) and is_atom(key) do\n case :lists.keyfind(key, 1, list) do\n {_, value} -> value\n false -> default\n end\n end\n\n def get(list, key, _default) when is_list(list) and is_integer(key) do\n raise ArgumentError, \"\"\"\n the Access module does not support accessing lists by index, got: #{inspect(key)}\n\n Accessing a list by index is typically discouraged in Elixir, \\\n instead we prefer to use the Enum module to manipulate lists \\\n as a whole. If you really must access a list element by index, \\\n you can use Enum.at/2 or the functions in the List module\\\n \"\"\"\n end\n\n def get(list, key, _default) when is_list(list) do\n raise ArgumentError, \"\"\"\n the Access module supports only keyword lists (with atom keys), got: #{inspect(key)}\n\n If you want to search lists of tuples, use List.keyfind/3\\\n \"\"\"\n end\n\n def get(nil, _key, default) do\n default\n end\n\n @doc \"\"\"\n Gets and updates the given key in a `container` (a map, a keyword list,\n a struct that implements the `Access` behaviour).\n\n The `fun` argument receives the value of `key` (or `nil` if `key` is not\n present in `container`) and must return a two-element tuple `{current_value, new_value}`:\n the \"get\" value `current_value` (the retrieved value, which can be operated on before\n being returned) and the new value to be stored under `key` (`new_value`).\n `fun` may also return `:pop`, which means the current value\n should be removed from the container and returned.\n\n The returned value is a two-element tuple with the \"get\" value returned by\n `fun` and a new container with the updated value under `key`.\n\n ## Examples\n\n iex> Access.get_and_update([a: 1], :a, fn current_value ->\n ...> {current_value, current_value + 1}\n ...> end)\n {1, [a: 2]}\n\n \"\"\"\n @spec get_and_update(data, key, (value | nil -> {current_value, new_value :: value} | :pop)) ::\n {current_value, new_data :: data}\n when current_value: var, data: container\n def get_and_update(container, key, fun)\n\n def get_and_update(%module{} = container, key, fun) do\n module.get_and_update(container, key, fun)\n rescue\n exception in UndefinedFunctionError ->\n raise_undefined_behaviour(\n exception,\n module,\n {^module, :get_and_update, [^container, ^key, ^fun], _}\n )\n end\n\n def get_and_update(map, key, fun) when is_map(map) do\n Map.get_and_update(map, key, fun)\n end\n\n def get_and_update(list, key, fun) when is_list(list) and is_atom(key) do\n Keyword.get_and_update(list, key, fun)\n end\n\n def get_and_update(list, key, _fun) when is_list(list) and is_integer(key) do\n raise ArgumentError, \"\"\"\n the Access module does not support accessing lists by index, got: #{inspect(key)}\n\n Accessing a list by index is typically discouraged in Elixir, \\\n instead we prefer to use the Enum module to manipulate lists \\\n as a whole. If you really must modify a list element by index, \\\n you can use Access.at/1 or the functions in the List module\\\n \"\"\"\n end\n\n def get_and_update(list, key, _fun) when is_list(list) do\n raise ArgumentError,\n \"the Access module supports only keyword lists (with atom keys), got: \" <> inspect(key)\n end\n\n def get_and_update(nil, key, _fun) do\n raise ArgumentError, \"could not put/update key #{inspect(key)} on a nil value\"\n end\n\n @doc \"\"\"\n Removes the entry with a given key from a container (a map, keyword\n list, or struct that implements the `Access` behaviour).\n\n Returns a tuple containing the value associated with the key and the\n updated container. `nil` is returned for the value if the key isn't\n in the container.\n\n ## Examples\n\n With a map:\n\n iex> Access.pop(%{name: \"Elixir\", creator: \"Valim\"}, :name)\n {\"Elixir\", %{creator: \"Valim\"}}\n\n A keyword list:\n\n iex> Access.pop([name: \"Elixir\", creator: \"Valim\"], :name)\n {\"Elixir\", [creator: \"Valim\"]}\n\n An unknown key:\n\n iex> Access.pop(%{name: \"Elixir\", creator: \"Valim\"}, :year)\n {nil, %{creator: \"Valim\", name: \"Elixir\"}}\n\n \"\"\"\n @spec pop(data, key) :: {value, data} when data: container\n def pop(%module{} = container, key) do\n module.pop(container, key)\n rescue\n exception in UndefinedFunctionError ->\n raise_undefined_behaviour(exception, module, {^module, :pop, [^container, ^key], _})\n end\n\n def pop(map, key) when is_map(map) do\n Map.pop(map, key)\n end\n\n def pop(list, key) when is_list(list) do\n Keyword.pop(list, key)\n end\n\n def pop(nil, key) do\n raise ArgumentError, \"could not pop key #{inspect(key)} on a nil value\"\n end\n\n ## Accessors\n\n @doc \"\"\"\n Returns a function that accesses the given key in a map/struct.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n The returned function uses the default value if the key does not exist.\n This can be used to specify defaults and safely traverse missing keys:\n\n iex> get_in(%{}, [Access.key(:user, %{}), Access.key(:name, \"meg\")])\n \"meg\"\n\n Such is also useful when using update functions, allowing us to introduce\n values as we traverse the data structure for updates:\n\n iex> put_in(%{}, [Access.key(:user, %{}), Access.key(:name)], \"Mary\")\n %{user: %{name: \"Mary\"}}\n\n ## Examples\n\n iex> map = %{user: %{name: \"john\"}}\n iex> get_in(map, [Access.key(:unknown, %{}), Access.key(:name, \"john\")])\n \"john\"\n iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {\"john\", %{user: %{name: \"JOHN\"}}}\n iex> pop_in(map, [Access.key(:user), Access.key(:name)])\n {\"john\", %{user: %{}}}\n\n An error is raised if the accessed structure is not a map or a struct:\n\n iex> get_in([], [Access.key(:foo)])\n ** (BadMapError) expected a map, got:\n ...\n \"\"\"\n @spec key(key, term) :: access_fun(data :: struct | map, current_value :: term)\n def key(key, default \\\\ nil) do\n fn\n :get, data, next ->\n next.(Map.get(data, key, default))\n\n :get_and_update, data, next ->\n value = Map.get(data, key, default)\n\n case next.(value) do\n {get, update} -> {get, Map.put(data, key, update)}\n :pop -> {value, Map.delete(data, key)}\n end\n end\n end\n\n @doc \"\"\"\n Returns a function that accesses the given key in a map/struct.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n Similar to `key/2`, but the returned function raises if the key does not exist.\n\n ## Examples\n\n iex> map = %{user: %{name: \"john\"}}\n iex> get_in(map, [Access.key!(:user), Access.key!(:name)])\n \"john\"\n iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {\"john\", %{user: %{name: \"JOHN\"}}}\n iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])\n {\"john\", %{user: %{}}}\n iex> get_in(map, [Access.key!(:user), Access.key!(:unknown)])\n ** (KeyError) key :unknown not found in:\n ...\n\n The examples above could be partially written as:\n\n iex> map = %{user: %{name: \"john\"}}\n iex> map.user.name\n \"john\"\n iex> get_and_update_in(map.user.name, fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {\"john\", %{user: %{name: \"JOHN\"}}}\n\n However, it is not possible to remove fields using the dot notation,\n as it is implied those fields must also be present. In any case,\n `Access.key!/1` is useful when the key is not known in advance\n and must be accessed dynamically.\n\n An error is raised if the accessed structure is not a map/struct:\n\n iex> get_in([], [Access.key!(:foo)])\n ** (RuntimeError) Access.key!/1 expected a map/struct, got: []\n\n \"\"\"\n @spec key!(key) :: access_fun(data :: struct | map, current_value :: term)\n def key!(key) do\n fn\n :get, %{} = data, next ->\n next.(Map.fetch!(data, key))\n\n :get_and_update, %{} = data, next ->\n value = Map.fetch!(data, key)\n\n case next.(value) do\n {get, update} -> {get, Map.put(data, key, update)}\n :pop -> {value, Map.delete(data, key)}\n end\n\n _op, data, _next ->\n raise \"Access.key!/1 expected a map/struct, got: #{inspect(data)}\"\n end\n end\n\n @doc ~S\"\"\"\n Returns a function that accesses the element at the given index in a tuple.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n The returned function raises if `index` is out of bounds.\n\n Note that popping elements out of tuples is not possible and raises an\n error.\n\n ## Examples\n\n iex> map = %{user: {\"john\", 27}}\n iex> get_in(map, [:user, Access.elem(0)])\n \"john\"\n iex> get_and_update_in(map, [:user, Access.elem(0)], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {\"john\", %{user: {\"JOHN\", 27}}}\n iex> pop_in(map, [:user, Access.elem(0)])\n ** (RuntimeError) cannot pop data from a tuple\n\n An error is raised if the accessed structure is not a tuple:\n\n iex> get_in(%{}, [Access.elem(0)])\n ** (RuntimeError) Access.elem/1 expected a tuple, got: %{}\n\n \"\"\"\n @spec elem(non_neg_integer) :: access_fun(data :: tuple, current_value :: term)\n def elem(index) when is_integer(index) and index >= 0 do\n pos = index + 1\n\n fn\n :get, data, next when is_tuple(data) ->\n next.(:erlang.element(pos, data))\n\n :get_and_update, data, next when is_tuple(data) ->\n value = :erlang.element(pos, data)\n\n case next.(value) do\n {get, update} -> {get, :erlang.setelement(pos, data, update)}\n :pop -> raise \"cannot pop data from a tuple\"\n end\n\n _op, data, _next ->\n raise \"Access.elem/1 expected a tuple, got: #{inspect(data)}\"\n end\n end\n\n @doc ~S\"\"\"\n Returns a function that accesses all the elements in a list.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n ## Examples\n\n iex> list = [%{name: \"john\"}, %{name: \"mary\"}]\n iex> get_in(list, [Access.all(), :name])\n [\"john\", \"mary\"]\n iex> get_and_update_in(list, [Access.all(), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {[\"john\", \"mary\"], [%{name: \"JOHN\"}, %{name: \"MARY\"}]}\n iex> pop_in(list, [Access.all(), :name])\n {[\"john\", \"mary\"], [%{}, %{}]}\n\n Here is an example that traverses the list dropping even\n numbers and multiplying odd numbers by 2:\n\n iex> require Integer\n iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all()], fn num ->\n ...> if Integer.is_even(num), do: :pop, else: {num, num * 2}\n ...> end)\n {[1, 2, 3, 4, 5], [2, 6, 10]}\n\n An error is raised if the accessed structure is not a list:\n\n iex> get_in(%{}, [Access.all()])\n ** (RuntimeError) Access.all/0 expected a list, got: %{}\n\n \"\"\"\n @spec all() :: access_fun(data :: list, current_value :: list)\n def all() do\n &all/3\n end\n\n defp all(:get, data, next) when is_list(data) do\n Enum.map(data, next)\n end\n\n defp all(:get_and_update, data, next) when is_list(data) do\n all(data, next, _gets = [], _updates = [])\n end\n\n defp all(_op, data, _next) do\n raise \"Access.all/0 expected a list, got: #{inspect(data)}\"\n end\n\n defp all([head | rest], next, gets, updates) do\n case next.(head) do\n {get, update} -> all(rest, next, [get | gets], [update | updates])\n :pop -> all(rest, next, [head | gets], updates)\n end\n end\n\n defp all([], _next, gets, updates) do\n {:lists.reverse(gets), :lists.reverse(updates)}\n end\n\n @doc ~S\"\"\"\n Returns a function that accesses the element at `index` (zero based) of a list.\n\n Keep in mind that index lookups in lists take linear time: the larger the list,\n the longer it will take to access its index. Therefore index-based operations\n are generally avoided in favor of other functions in the `Enum` module.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n ## Examples\n\n iex> list = [%{name: \"john\"}, %{name: \"mary\"}]\n iex> get_in(list, [Access.at(1), :name])\n \"mary\"\n iex> get_in(list, [Access.at(-1), :name])\n \"mary\"\n iex> get_and_update_in(list, [Access.at(0), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {\"john\", [%{name: \"JOHN\"}, %{name: \"mary\"}]}\n iex> get_and_update_in(list, [Access.at(-1), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {\"mary\", [%{name: \"john\"}, %{name: \"MARY\"}]}\n\n `at/1` can also be used to pop elements out of a list or\n a key inside of a list:\n\n iex> list = [%{name: \"john\"}, %{name: \"mary\"}]\n iex> pop_in(list, [Access.at(0)])\n {%{name: \"john\"}, [%{name: \"mary\"}]}\n iex> pop_in(list, [Access.at(0), :name])\n {\"john\", [%{}, %{name: \"mary\"}]}\n\n When the index is out of bounds, `nil` is returned and the update function is never called:\n\n iex> list = [%{name: \"john\"}, %{name: \"mary\"}]\n iex> get_in(list, [Access.at(10), :name])\n nil\n iex> get_and_update_in(list, [Access.at(10), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {nil, [%{name: \"john\"}, %{name: \"mary\"}]}\n\n An error is raised if the accessed structure is not a list:\n\n iex> get_in(%{}, [Access.at(1)])\n ** (RuntimeError) Access.at/1 expected a list, got: %{}\n\n \"\"\"\n @spec at(integer) :: access_fun(data :: list, current_value :: term)\n def at(index) when is_integer(index) do\n fn op, data, next -> at(op, data, index, next) end\n end\n\n defp at(:get, data, index, next) when is_list(data) do\n data |> Enum.at(index) |> next.()\n end\n\n defp at(:get_and_update, data, index, next) when is_list(data) do\n get_and_update_at(data, index, next, [], fn -> nil end)\n end\n\n defp at(_op, data, _index, _next) do\n raise \"Access.at/1 expected a list, got: #{inspect(data)}\"\n end\n\n defp get_and_update_at([head | rest], 0, next, updates, _default_fun) do\n case next.(head) do\n {get, update} -> {get, :lists.reverse([update | updates], rest)}\n :pop -> {head, :lists.reverse(updates, rest)}\n end\n end\n\n defp get_and_update_at([_ | _] = list, index, next, updates, default_fun) when index < 0 do\n list_length = length(list)\n\n if list_length + index >= 0 do\n get_and_update_at(list, list_length + index, next, updates, default_fun)\n else\n {default_fun.(), list}\n end\n end\n\n defp get_and_update_at([head | rest], index, next, updates, default_fun) when index > 0 do\n get_and_update_at(rest, index - 1, next, [head | updates], default_fun)\n end\n\n defp get_and_update_at([], _index, _next, updates, default_fun) do\n {default_fun.(), :lists.reverse(updates)}\n end\n\n @doc ~S\"\"\"\n Same as `at/1` except that it raises `Enum.OutOfBoundsError`\n if the given index is out of bounds.\n\n ## Examples\n\n iex> get_in([:a, :b, :c], [Access.at!(2)])\n :c\n iex> get_in([:a, :b, :c], [Access.at!(3)])\n ** (Enum.OutOfBoundsError) out of bounds error at position 3 when traversing enumerable [:a, :b, :c]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec at!(integer) :: access_fun(data :: list, current_value :: term)\n def at!(index) when is_integer(index) do\n fn op, data, next -> at!(op, data, index, next) end\n end\n\n defp at!(:get, data, index, next) when is_list(data) do\n case Enum.fetch(data, index) do\n {:ok, value} -> next.(value)\n :error -> raise Enum.OutOfBoundsError, index: index, enumerable: data\n end\n end\n\n defp at!(:get_and_update, data, index, next) when is_list(data) do\n get_and_update_at(data, index, next, [], fn ->\n raise Enum.OutOfBoundsError, index: index, enumerable: data\n end)\n end\n\n defp at!(_op, data, _index, _next) do\n raise \"Access.at!/1 expected a list, got: #{inspect(data)}\"\n end\n\n @doc ~S\"\"\"\n Returns a function that accesses all elements of a list that match the provided predicate.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n ## Examples\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]\n iex> get_in(list, [Access.filter(&(&1.salary > 20)), :name])\n [\"francine\"]\n iex> get_and_update_in(list, [Access.filter(&(&1.salary <= 20)), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {[\"john\"], [%{name: \"JOHN\", salary: 10}, %{name: \"francine\", salary: 30}]}\n\n `filter/1` can also be used to pop elements out of a list or\n a key inside of a list:\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]\n iex> pop_in(list, [Access.filter(&(&1.salary >= 20))])\n {[%{name: \"francine\", salary: 30}], [%{name: \"john\", salary: 10}]}\n iex> pop_in(list, [Access.filter(&(&1.salary >= 20)), :name])\n {[\"francine\"], [%{name: \"john\", salary: 10}, %{salary: 30}]}\n\n When no match is found, an empty list is returned and the update function is never called\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]\n iex> get_in(list, [Access.filter(&(&1.salary >= 50)), :name])\n []\n iex> get_and_update_in(list, [Access.filter(&(&1.salary >= 50)), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {[], [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]}\n\n An error is raised if the accessed structure is not a list:\n\n iex> get_in(%{}, [Access.filter(fn a -> a == 10 end)])\n ** (RuntimeError) Access.filter/1 expected a list, got: %{}\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec filter((term -> boolean)) :: access_fun(data :: list, current_value :: list)\n def filter(func) when is_function(func) do\n fn op, data, next -> filter(op, data, func, next) end\n end\n\n defp filter(:get, data, func, next) when is_list(data) do\n for elem <- data, func.(elem), do: next.(elem)\n end\n\n defp filter(:get_and_update, data, func, next) when is_list(data) do\n get_and_update_filter(data, func, next, [], [])\n end\n\n defp filter(_op, data, _func, _next) do\n raise \"Access.filter/1 expected a list, got: #{inspect(data)}\"\n end\n\n defp get_and_update_filter([head | rest], func, next, updates, gets) do\n if func.(head) do\n case next.(head) do\n {get, update} ->\n get_and_update_filter(rest, func, next, [update | updates], [get | gets])\n\n :pop ->\n get_and_update_filter(rest, func, next, updates, [head | gets])\n end\n else\n get_and_update_filter(rest, func, next, [head | updates], gets)\n end\n end\n\n defp get_and_update_filter([], _func, _next, updates, gets) do\n {:lists.reverse(gets), :lists.reverse(updates)}\n end\n\n @doc ~S\"\"\"\n Returns a function that accesses all items of a list that are within the provided range.\n\n The range will be normalized following the same rules from `Enum.slice/2`.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n ## Examples\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}, %{name: \"vitor\", salary: 25}]\n iex> get_in(list, [Access.slice(1..2), :name])\n [\"francine\", \"vitor\"]\n iex> get_and_update_in(list, [Access.slice(1..3//2), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {[\"francine\"], [%{name: \"john\", salary: 10}, %{name: \"FRANCINE\", salary: 30}, %{name: \"vitor\", salary: 25}]}\n\n `slice/1` can also be used to pop elements out of a list or\n a key inside of a list:\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}, %{name: \"vitor\", salary: 25}]\n iex> pop_in(list, [Access.slice(-2..-1)])\n {[%{name: \"francine\", salary: 30}, %{name: \"vitor\", salary: 25}], [%{name: \"john\", salary: 10}]}\n iex> pop_in(list, [Access.slice(-2..-1), :name])\n {[\"francine\", \"vitor\"], [%{name: \"john\", salary: 10}, %{salary: 30}, %{salary: 25}]}\n\n When no match is found, an empty list is returned and the update function is never called\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}, %{name: \"vitor\", salary: 25}]\n iex> get_in(list, [Access.slice(5..10//2), :name])\n []\n iex> get_and_update_in(list, [Access.slice(5..10//2), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {[], [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}, %{name: \"vitor\", salary: 25}]}\n\n An error is raised if the accessed structure is not a list:\n\n iex> get_in(%{}, [Access.slice(2..10//3)])\n ** (ArgumentError) Access.slice/1 expected a list, got: %{}\n\n An error is raised if the step of the range is negative:\n\n iex> get_in([], [Access.slice(2..10//-1)])\n ** (ArgumentError) Access.slice/1 does not accept ranges with negative steps, got: 2..10//-1\n\n \"\"\"\n @doc since: \"1.14\"\n @spec slice(Range.t()) :: access_fun(data :: list, current_value :: list)\n def slice(%Range{} = range) do\n if range.step > 0 do\n fn op, data, next -> slice(op, data, range, next) end\n else\n raise ArgumentError,\n \"Access.slice/1 does not accept ranges with negative steps, got: #{inspect(range)}\"\n end\n end\n\n defp slice(:get, data, %Range{} = range, next) when is_list(data) do\n data\n |> Enum.slice(range)\n |> Enum.map(next)\n end\n\n defp slice(:get_and_update, data, range, next) when is_list(data) do\n range = normalize_range(range, data)\n\n if range.first > range.last do\n {[], data}\n else\n get_and_update_slice(data, range, next, [], [], 0)\n end\n end\n\n defp slice(_op, data, _range, _next) do\n raise ArgumentError, \"Access.slice/1 expected a list, got: #{inspect(data)}\"\n end\n\n @doc \"\"\"\n Returns a function that accesses all values in a map or a keyword list.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n ## Examples\n\n iex> users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n iex> get_in(users, [Access.values(), :age]) |> Enum.sort()\n [23, 27]\n iex> update_in(users, [Access.values(), :age], fn age -> age + 1 end)\n %{\"john\" => %{age: 28}, \"meg\" => %{age: 24}}\n iex> put_in(users, [Access.values(), :planet], \"Earth\")\n %{\"john\" => %{age: 27, planet: \"Earth\"}, \"meg\" => %{age: 23, planet: \"Earth\"}}\n\n Values in keyword lists can be accessed as well:\n\n iex> users = [john: %{age: 27}, meg: %{age: 23}]\n iex> get_and_update_in(users, [Access.values(), :age], fn age -> {age, age + 1} end)\n {[27, 23], [john: %{age: 28}, meg: %{age: 24}]}\n\n By returning `:pop` from an accessor function, you can remove the accessed key and value\n from the map or keyword list:\n\n iex> require Integer\n iex> numbers = [one: 1, two: 2, three: 3, four: 4]\n iex> get_and_update_in(numbers, [Access.values()], fn num ->\n ...> if Integer.is_even(num), do: :pop, else: {num, to_string(num)}\n ...> end)\n {[1, 2, 3, 4], [one: \"1\", three: \"3\"]}\n\n An error is raised if the accessed structure is not a map nor a keyword list:\n\n iex> get_in([1, 2, 3], [Access.values()])\n ** (RuntimeError) Access.values/0 expected a map or a keyword list, got: [1, 2, 3]\n \"\"\"\n @doc since: \"1.19.0\"\n @spec values() :: Access.access_fun(data :: map() | keyword(), current_value :: list())\n def values do\n &values/3\n end\n\n defp values(:get, data = %{}, next) do\n Enum.map(data, fn {_key, value} -> next.(value) end)\n end\n\n defp values(:get_and_update, data = %{}, next) do\n {reverse_gets, updated_data} =\n Enum.reduce(data, {[], %{}}, fn {key, value}, {gets, data_acc} ->\n case next.(value) do\n {get, update} -> {[get | gets], Map.put(data_acc, key, update)}\n :pop -> {[value | gets], data_acc}\n end\n end)\n\n {Enum.reverse(reverse_gets), updated_data}\n end\n\n defp values(op, data = [], next) do\n values_keyword(op, data, next)\n end\n\n defp values(op, data = [{key, _value} | _tail], next) when is_atom(key) do\n values_keyword(op, data, next)\n end\n\n defp values(_op, data, _next) do\n raise \"Access.values/0 expected a map or a keyword list, got: #{inspect(data)}\"\n end\n\n defp values_keyword(:get, data, next) do\n Enum.map(data, fn {key, value} when is_atom(key) -> next.(value) end)\n end\n\n defp values_keyword(:get_and_update, data, next) do\n {reverse_gets, reverse_updated_data} =\n Enum.reduce(data, {[], []}, fn {key, value}, {gets, data_acc} when is_atom(key) ->\n case next.(value) do\n {get, update} -> {[get | gets], [{key, update} | data_acc]}\n :pop -> {[value | gets], data_acc}\n end\n end)\n\n {Enum.reverse(reverse_gets), Enum.reverse(reverse_updated_data)}\n end\n\n defp normalize_range(%Range{first: first, last: last, step: step}, list)\n when first < 0 or last < 0 do\n count = length(list)\n first = if first >= 0, do: first, else: Kernel.max(first + count, 0)\n last = if last >= 0, do: last, else: last + count\n Range.new(first, last, step)\n end\n\n defp normalize_range(range, _list), do: range\n\n defp get_and_update_slice([head | rest], range, next, updates, gets, index) do\n if index in range do\n case next.(head) do\n :pop ->\n get_and_update_slice(rest, range, next, updates, [head | gets], index + 1)\n\n {get, update} ->\n get_and_update_slice(\n rest,\n range,\n next,\n [update | updates],\n [get | gets],\n index + 1\n )\n end\n else\n get_and_update_slice(rest, range, next, [head | updates], gets, index + 1)\n end\n end\n\n defp get_and_update_slice([], _range, _next, updates, gets, _index) do\n {:lists.reverse(gets), :lists.reverse(updates)}\n end\n\n @doc ~S\"\"\"\n Returns a function that accesses the first element of a list that matches the provided predicate.\n\n The returned function is typically passed as an accessor to `Kernel.get_in/2`,\n `Kernel.get_and_update_in/3`, and friends.\n\n ## Examples\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]\n iex> get_in(list, [Access.find(&(&1.salary > 20)), :name])\n \"francine\"\n iex> get_and_update_in(list, [Access.find(&(&1.salary <= 40)), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {\"john\", [%{name: \"JOHN\", salary: 10}, %{name: \"francine\", salary: 30}]}\n\n `find/1` can also be used to pop the first found element out of a list or\n a key inside of a list:\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]\n iex> pop_in(list, [Access.find(&(&1.salary <= 40))])\n {%{name: \"john\", salary: 10}, [%{name: \"francine\", salary: 30}]}\n\n When no match is found, nil is returned and the update function is never called\n\n iex> list = [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]\n iex> get_in(list, [Access.find(&(&1.salary >= 50)), :name])\n nil\n iex> get_and_update_in(list, [Access.find(&(&1.salary >= 50)), :name], fn prev ->\n ...> {prev, String.upcase(prev)}\n ...> end)\n {nil, [%{name: \"john\", salary: 10}, %{name: \"francine\", salary: 30}]}\n\n An error is raised if the accessed structure is not a list:\n\n iex> get_in(%{}, [Access.find(fn a -> a == 10 end)])\n ** (RuntimeError) Access.find/1 expected a list, got: %{}\n \"\"\"\n @doc since: \"1.17.0\"\n @spec find((term -> as_boolean(term))) :: access_fun(data :: list, current_value :: term)\n def find(predicate) when is_function(predicate, 1) do\n fn op, data, next -> find(op, data, predicate, next) end\n end\n\n defp find(:get, data, predicate, next) when is_list(data) do\n data |> Enum.find(predicate) |> next.()\n end\n\n defp find(:get_and_update, data, predicate, next) when is_list(data) do\n get_and_update_find(data, [], predicate, next)\n end\n\n defp find(_op, data, _predicate, _next) do\n raise \"Access.find/1 expected a list, got: #{inspect(data)}\"\n end\n\n defp get_and_update_find([], updates, _predicate, _next) do\n {nil, :lists.reverse(updates)}\n end\n\n defp get_and_update_find([head | rest], updates, predicate, next) do\n if predicate.(head) do\n case next.(head) do\n {get, update} -> {get, :lists.reverse([update | updates], rest)}\n :pop -> {head, :lists.reverse(updates, rest)}\n end\n else\n get_and_update_find(rest, [head | updates], predicate, next)\n end\n end\nend\n" }, { "path": "lib/elixir/lib/agent/server.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Agent.Server do\n @moduledoc false\n\n use GenServer\n\n def init(fun) do\n _ = initial_call(fun)\n {:ok, run(fun, [])}\n end\n\n def handle_call({:get, fun}, _from, state) do\n {:reply, run(fun, [state]), state}\n end\n\n def handle_call({:get_and_update, fun}, _from, state) do\n case run(fun, [state]) do\n {reply, state} -> {:reply, reply, state}\n other -> {:stop, {:bad_return_value, other}, state}\n end\n end\n\n def handle_call({:update, fun}, _from, state) do\n {:reply, :ok, run(fun, [state])}\n end\n\n def handle_cast({:cast, fun}, state) do\n {:noreply, run(fun, [state])}\n end\n\n def code_change(_old, state, fun) do\n {:ok, run(fun, [state])}\n end\n\n defp initial_call(mfa) do\n _ = Process.put(:\"$initial_call\", get_initial_call(mfa))\n :ok\n end\n\n defp get_initial_call(fun) when is_function(fun, 0) do\n {:module, module} = Function.info(fun, :module)\n {:name, name} = Function.info(fun, :name)\n {module, name, 0}\n end\n\n defp get_initial_call({mod, fun, args}) do\n {mod, fun, length(args)}\n end\n\n defp run({m, f, a}, extra), do: apply(m, f, extra ++ a)\n defp run(fun, extra), do: apply(fun, extra)\nend\n" }, { "path": "lib/elixir/lib/agent.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Agent do\n @moduledoc \"\"\"\n Agents are a simple abstraction around state.\n\n Often in Elixir there is a need to share or store state that\n must be accessed from different processes or by the same process\n at different points in time.\n\n The `Agent` module provides a basic server implementation that\n allows state to be retrieved and updated via a simple API.\n\n ## Examples\n\n For example, the following agent implements a counter:\n\n defmodule Counter do\n use Agent\n\n def start_link(initial_value) do\n Agent.start_link(fn -> initial_value end, name: __MODULE__)\n end\n\n def value do\n Agent.get(__MODULE__, & &1)\n end\n\n def increment do\n Agent.update(__MODULE__, &(&1 + 1))\n end\n end\n\n Usage would be:\n\n Counter.start_link(0)\n #=> {:ok, #PID<0.123.0>}\n\n Counter.value()\n #=> 0\n\n Counter.increment()\n #=> :ok\n\n Counter.increment()\n #=> :ok\n\n Counter.value()\n #=> 2\n\n Thanks to the agent server process, the counter can be safely incremented\n concurrently.\n\n > #### `use Agent` {: .info}\n >\n > When you `use Agent`, the `Agent` module will define a\n > `child_spec/1` function, so your module can be used\n > as a child in a supervision tree.\n\n Agents provide a segregation between the client and server APIs (similar to\n `GenServer`s). In particular, the functions passed as arguments to the calls to\n `Agent` functions are invoked inside the agent (the server). This distinction\n is important because you may want to avoid expensive operations inside the\n agent, as they will effectively block the agent until the request is\n fulfilled.\n\n Consider these two examples:\n\n # Compute in the agent/server\n def get_something(agent) do\n Agent.get(agent, fn state -> do_something_expensive(state) end)\n end\n\n # Compute in the agent/client\n def get_something(agent) do\n Agent.get(agent, & &1) |> do_something_expensive()\n end\n\n The first function blocks the agent. The second function copies all the state\n to the client and then executes the operation in the client. One aspect to\n consider is whether the data is large enough to require processing in the server,\n at least initially, or small enough to be sent to the client cheaply. Another\n factor is whether the data needs to be processed atomically: getting the\n state and calling `do_something_expensive(state)` outside of the agent means\n that the agent's state can be updated in the meantime. This is specially\n important in case of updates as computing the new state in the client rather\n than in the server can lead to race conditions if multiple clients are trying\n to update the same state to different values.\n\n ## How to supervise\n\n An `Agent` is most commonly started under a supervision tree.\n When we invoke `use Agent`, it automatically defines a `child_spec/1`\n function that allows us to start the agent directly under a supervisor.\n To start an agent under a supervisor with an initial counter of 0,\n one may do:\n\n children = [\n {Counter, 0}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_all)\n\n While one could also simply pass the `Counter` as a child to the supervisor,\n such as:\n\n children = [\n Counter # Same as {Counter, []}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_all)\n\n The definition above wouldn't work for this particular example,\n as it would attempt to start the counter with an initial value\n of an empty list. However, this may be a viable option in your\n own agents. A common approach is to use a keyword list, as that\n would allow setting the initial value and giving a name to the\n counter process, for example:\n\n def start_link(opts) do\n {initial_value, opts} = Keyword.pop(opts, :initial_value, 0)\n Agent.start_link(fn -> initial_value end, opts)\n end\n\n and then you can use `Counter`, `{Counter, name: :my_counter}` or\n even `{Counter, initial_value: 0, name: :my_counter}` as a child\n specification.\n\n `use Agent` also accepts a list of options which configures the\n child specification and therefore how it runs under a supervisor.\n The generated `child_spec/1` can be customized with the following options:\n\n * `:id` - the child specification identifier, defaults to the current module\n * `:restart` - when the child should be restarted, defaults to `:permanent`\n * `:shutdown` - how to shut down the child, either immediately or by giving it time to shut down\n\n For example:\n\n use Agent, restart: :transient, shutdown: 10_000\n\n See the \"Child specification\" section in the `Supervisor` module for more\n detailed information. The `@doc` annotation immediately preceding\n `use Agent` will be attached to the generated `child_spec/1` function.\n\n ## Name registration\n\n An agent is bound to the same name registration rules as GenServers.\n Read more about it in the `GenServer` documentation.\n\n ## A word on distributed agents\n\n It is important to consider the limitations of distributed agents. Agents\n provide two APIs, one that works with anonymous functions and another\n that expects an explicit module, function, and arguments.\n\n In a distributed setup with multiple nodes, the API that accepts anonymous\n functions only works if the caller (client) and the agent have the same\n version of the caller module.\n\n Keep in mind this issue also shows up when performing \"rolling upgrades\"\n with agents. By rolling upgrades we mean the following situation: you wish\n to deploy a new version of your software by *shutting down* some of your\n nodes and replacing them with nodes running a new version of the software.\n In this setup, part of your environment will have one version of a given\n module and the other part another version (the newer one) of the same module.\n\n The best solution is to simply use the explicit module, function, and arguments\n APIs when working with distributed agents.\n\n ## Hot code swapping\n\n An agent can have its code hot swapped live by simply passing a module,\n function, and arguments tuple to the update instruction. For example, imagine\n you have an agent named `:sample` and you want to convert its inner state\n from a keyword list to a map. It can be done with the following\n instruction:\n\n {:update, :sample, {:advanced, {Enum, :into, [%{}]}}}\n\n The agent's state will be added to the given list of arguments (`[%{}]`) as\n the first argument.\n \"\"\"\n\n @typedoc \"Return values of `start*` functions\"\n @type on_start :: {:ok, pid} | {:error, {:already_started, pid} | term}\n\n @typedoc \"The agent name\"\n @type name :: atom | {:global, term} | {:via, module, term}\n\n @typedoc \"The agent reference\"\n @type agent :: pid | {atom, node} | name\n\n @typedoc \"The agent state\"\n @type state :: term\n\n @doc \"\"\"\n Returns a specification to start an agent under a supervisor.\n\n See the \"Child specification\" section in the `Supervisor` module for more detailed information.\n \"\"\"\n @doc since: \"1.5.0\"\n def child_spec(arg) do\n %{\n id: Agent,\n start: {Agent, :start_link, [arg]}\n }\n end\n\n @doc false\n defmacro __using__(opts) do\n quote location: :keep, bind_quoted: [opts: opts] do\n if not Module.has_attribute?(__MODULE__, :doc) do\n @doc \"\"\"\n Returns a specification to start this module under a supervisor.\n\n See `Supervisor`.\n \"\"\"\n end\n\n def child_spec(arg) do\n default = %{\n id: __MODULE__,\n start: {__MODULE__, :start_link, [arg]}\n }\n\n Supervisor.child_spec(default, unquote(Macro.escape(opts)))\n end\n\n defoverridable child_spec: 1\n end\n end\n\n @doc \"\"\"\n Starts an agent linked to the current process with the given function.\n\n This is often used to start the agent as part of a supervision tree.\n\n Once the agent is spawned, the given function `fun` is invoked in the server\n process, and should return the initial agent state. Note that `start_link/2`\n does not return until the given function has returned.\n\n ## Options\n\n The `:name` option is used for registration as described in the module\n documentation.\n\n If the `:timeout` option is present, the agent is allowed to spend at most\n the given number of milliseconds on initialization or it will be terminated\n and the start function will return `{:error, :timeout}`.\n\n If the `:debug` option is present, the corresponding function in the\n [`:sys` module](`:sys`) will be invoked.\n\n If the `:spawn_opt` option is present, its value will be passed as options\n to the underlying process as in `Process.spawn/4`.\n\n ## Return values\n\n If the server is successfully created and initialized, the function returns\n `{:ok, pid}`, where `pid` is the PID of the server. If an agent with the\n specified name already exists, the function returns\n `{:error, {:already_started, pid}}` with the PID of that process.\n\n If the given function callback fails, the function returns `{:error, reason}`.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.get(pid, fn state -> state end)\n 42\n\n iex> {:error, {exception, _stacktrace}} = Agent.start(fn -> raise \"oops\" end)\n iex> exception\n %RuntimeError{message: \"oops\"}\n\n \"\"\"\n @spec start_link((-> term), GenServer.options()) :: on_start\n def start_link(fun, options \\\\ []) when is_function(fun, 0) do\n GenServer.start_link(Agent.Server, fun, options)\n end\n\n @doc \"\"\"\n Starts an agent linked to the current process.\n\n Same as `start_link/2` but a module, function, and arguments are expected\n instead of an anonymous function; `fun` in `module` will be called with the\n given arguments `args` to initialize the state.\n \"\"\"\n @spec start_link(module, atom, [term], GenServer.options()) :: on_start\n def start_link(module, fun, args, options \\\\ []) do\n GenServer.start_link(Agent.Server, {module, fun, args}, options)\n end\n\n @doc \"\"\"\n Starts an agent process without links (outside of a supervision tree).\n\n See `start_link/2` for more information.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start(fn -> 42 end)\n iex> Agent.get(pid, fn state -> state end)\n 42\n\n \"\"\"\n @spec start((-> term), GenServer.options()) :: on_start\n def start(fun, options \\\\ []) when is_function(fun, 0) do\n GenServer.start(Agent.Server, fun, options)\n end\n\n @doc \"\"\"\n Starts an agent without links with the given module, function, and arguments.\n\n See `start_link/4` for more information.\n \"\"\"\n @spec start(module, atom, [term], GenServer.options()) :: on_start\n def start(module, fun, args, options \\\\ []) do\n GenServer.start(Agent.Server, {module, fun, args}, options)\n end\n\n @doc \"\"\"\n Gets an agent value via the given anonymous function.\n\n The function `fun` is sent to the `agent` which invokes the function\n passing the agent state. The result of the function invocation is\n returned from this function.\n\n `timeout` is an integer greater than zero which specifies how many\n milliseconds are allowed before the agent executes the function and returns\n the result value, or the atom `:infinity` to wait indefinitely. If no result\n is received within the specified time, the function call fails and the caller\n exits.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.get(pid, fn state -> state end)\n 42\n\n \"\"\"\n @spec get(agent, (state -> a), timeout) :: a when a: var\n def get(agent, fun, timeout \\\\ 5000) when is_function(fun, 1) do\n GenServer.call(agent, {:get, fun}, timeout)\n end\n\n @doc \"\"\"\n Gets an agent value via the given function.\n\n Same as `get/3` but a module, function, and arguments are expected\n instead of an anonymous function. The state is added as first\n argument to the given list of arguments.\n \"\"\"\n @spec get(agent, module, atom, [term], timeout) :: term\n def get(agent, module, fun, args, timeout \\\\ 5000) do\n GenServer.call(agent, {:get, {module, fun, args}}, timeout)\n end\n\n @doc \"\"\"\n Gets and updates the agent state in one operation via the given anonymous\n function.\n\n The function `fun` is sent to the `agent` which invokes the function\n passing the agent state. The function must return a tuple with two\n elements, the first being the value to return (that is, the \"get\" value)\n and the second one being the new state of the agent.\n\n `timeout` is an integer greater than zero which specifies how many\n milliseconds are allowed before the agent executes the function and returns\n the result value, or the atom `:infinity` to wait indefinitely. If no result\n is received within the specified time, the function call fails and the caller\n exits.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.get_and_update(pid, fn state -> {state, state + 1} end)\n 42\n iex> Agent.get(pid, fn state -> state end)\n 43\n\n \"\"\"\n @spec get_and_update(agent, (state -> {a, state}), timeout) :: a when a: var\n def get_and_update(agent, fun, timeout \\\\ 5000) when is_function(fun, 1) do\n GenServer.call(agent, {:get_and_update, fun}, timeout)\n end\n\n @doc \"\"\"\n Gets and updates the agent state in one operation via the given function.\n\n Same as `get_and_update/3` but a module, function, and arguments are expected\n instead of an anonymous function. The state is added as first\n argument to the given list of arguments.\n \"\"\"\n @spec get_and_update(agent, module, atom, [term], timeout) :: term\n def get_and_update(agent, module, fun, args, timeout \\\\ 5000) do\n GenServer.call(agent, {:get_and_update, {module, fun, args}}, timeout)\n end\n\n @doc \"\"\"\n Updates the agent state via the given anonymous function.\n\n The function `fun` is sent to the `agent` which invokes the function\n passing the agent state. The return value of `fun` becomes the new\n state of the agent.\n\n This function always returns `:ok`.\n\n `timeout` is an integer greater than zero which specifies how many\n milliseconds are allowed before the agent executes the function and returns\n the result value, or the atom `:infinity` to wait indefinitely. If no result\n is received within the specified time, the function call fails and the caller\n exits.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.update(pid, fn state -> state + 1 end)\n :ok\n iex> Agent.get(pid, fn state -> state end)\n 43\n\n \"\"\"\n @spec update(agent, (state -> state), timeout) :: :ok\n def update(agent, fun, timeout \\\\ 5000) when is_function(fun, 1) do\n GenServer.call(agent, {:update, fun}, timeout)\n end\n\n @doc \"\"\"\n Updates the agent state via the given function.\n\n Same as `update/3` but a module, function, and arguments are expected\n instead of an anonymous function. The state is added as first\n argument to the given list of arguments.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.update(pid, Kernel, :+, [12])\n :ok\n iex> Agent.get(pid, fn state -> state end)\n 54\n\n \"\"\"\n @spec update(agent, module, atom, [term], timeout) :: :ok\n def update(agent, module, fun, args, timeout \\\\ 5000) do\n GenServer.call(agent, {:update, {module, fun, args}}, timeout)\n end\n\n @doc \"\"\"\n Performs a cast (*fire and forget*) operation on the agent state.\n\n The function `fun` is sent to the `agent` which invokes the function\n passing the agent state. The return value of `fun` becomes the new\n state of the agent.\n\n Note that `cast` returns `:ok` immediately, regardless of whether `agent` (or\n the node it should live on) exists.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.cast(pid, fn state -> state + 1 end)\n :ok\n iex> Agent.get(pid, fn state -> state end)\n 43\n\n \"\"\"\n @spec cast(agent, (state -> state)) :: :ok\n def cast(agent, fun) when is_function(fun, 1) do\n GenServer.cast(agent, {:cast, fun})\n end\n\n @doc \"\"\"\n Performs a cast (*fire and forget*) operation on the agent state.\n\n Same as `cast/2` but a module, function, and arguments are expected\n instead of an anonymous function. The state is added as first\n argument to the given list of arguments.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.cast(pid, Kernel, :+, [12])\n :ok\n iex> Agent.get(pid, fn state -> state end)\n 54\n\n \"\"\"\n @spec cast(agent, module, atom, [term]) :: :ok\n def cast(agent, module, fun, args) do\n GenServer.cast(agent, {:cast, {module, fun, args}})\n end\n\n @doc \"\"\"\n Synchronously stops the agent with the given `reason`.\n\n It returns `:ok` if the agent terminates with the given\n reason. If the agent terminates with another reason, the call will\n exit.\n\n This function keeps OTP semantics regarding error reporting.\n If the reason is any other than `:normal`, `:shutdown` or\n `{:shutdown, _}`, an error report will be logged.\n\n ## Examples\n\n iex> {:ok, pid} = Agent.start_link(fn -> 42 end)\n iex> Agent.stop(pid)\n :ok\n\n \"\"\"\n @spec stop(agent, reason :: term, timeout) :: :ok\n def stop(agent, reason \\\\ :normal, timeout \\\\ :infinity) do\n GenServer.stop(agent, reason, timeout)\n end\nend\n" }, { "path": "lib/elixir/lib/application.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Application do\n @moduledoc \"\"\"\n A module for working with applications and defining application callbacks.\n\n Applications are the idiomatic way to package software in Erlang/OTP. To get\n the idea, they are similar to the \"library\" concept common in other\n programming languages, but with some additional characteristics.\n\n An application is a component implementing some specific functionality, with a\n standardized directory structure, configuration, and life cycle. Applications\n are *loaded*, *started*, and *stopped*. Each application also has its own\n environment, which provides a unified API for configuring each application.\n\n Developers typically interact with the application environment and its\n callback module. Therefore those will be the topics we will cover first\n before jumping into details about the application resource file and life cycle.\n\n ## The application environment\n\n Each application has its own environment. The environment is a keyword list\n that maps atoms to terms. Note that this environment is unrelated to the\n operating system environment.\n\n By default, the environment of an application is an empty list. In a Mix\n project's `mix.exs` file, you can set the `:env` key in `application/0`:\n\n def application do\n [env: [db_host: \"localhost\"]]\n end\n\n Now, in your application, you can read this environment by using functions\n such as `fetch_env!/2` and friends:\n\n defmodule MyApp.DBClient do\n def start_link() do\n SomeLib.DBClient.start_link(host: db_host())\n end\n\n defp db_host do\n Application.fetch_env!(:my_app, :db_host)\n end\n end\n\n In Mix projects, the environment of the application and its dependencies can\n be overridden via the `config/config.exs` and `config/runtime.exs` files. The\n former is loaded at build-time, before your code compiles, and the latter at\n runtime, just before your app starts. For example, someone using your application\n can override its `:db_host` environment variable as follows:\n\n import Config\n config :my_app, :db_host, \"db.local\"\n\n See the \"Configuration\" section in the `Mix` module for more information.\n You can also change the application environment dynamically by using functions\n such as `put_env/3` and `delete_env/2`.\n\n > #### Application environment in libraries {: .info}\n >\n > If you are writing a library to be used by other developers,\n > it is generally recommended to avoid the application environment, as the\n > application environment is effectively a global storage. For more information,\n > read about this [anti-pattern](design-anti-patterns.md#using-application-configuration-for-libraries).\n\n > #### Reading the environment of other applications {: .warning}\n >\n > Each application is responsible for its own environment. Do not\n > use the functions in this module for directly accessing or modifying\n > the environment of other applications. Whenever you change the application\n > environment, Elixir's build tool will only recompile the files that\n > belong to that application. So if you read the application environment\n > of another application, there is a chance you will be depending on\n > outdated configuration, as your file won't be recompiled as it changes.\n\n ## Compile-time environment\n\n In the previous example, we read the application environment at runtime:\n\n defmodule MyApp.DBClient do\n def start_link() do\n SomeLib.DBClient.start_link(host: db_host())\n end\n\n defp db_host do\n Application.fetch_env!(:my_app, :db_host)\n end\n end\n\n In other words, the environment key `:db_host` for application `:my_app`\n will only be read when `MyApp.DBClient` effectively starts. While reading\n the application environment at runtime is the preferred approach, in some\n rare occasions you may want to use the application environment to configure\n the compilation of a certain project. However, if you try to access\n `Application.fetch_env!/2` outside of a function:\n\n defmodule MyApp.DBClient do\n @db_host Application.fetch_env!(:my_app, :db_host)\n\n def start_link() do\n SomeLib.DBClient.start_link(host: @db_host)\n end\n end\n\n You might see warnings and errors:\n\n warning: Application.fetch_env!/2 is discouraged in the module body,\n use Application.compile_env/3 instead\n iex:3: MyApp.DBClient\n\n ** (ArgumentError) could not fetch application environment :db_host\n for application :my_app because the application was not loaded nor\n configured\n\n This happens because, when defining modules, the application environment\n is not yet available. Luckily, the warning tells us how to solve this\n issue, by using `Application.compile_env/3` instead:\n\n defmodule MyApp.DBClient do\n @db_host Application.compile_env(:my_app, :db_host, \"db.local\")\n\n def start_link() do\n SomeLib.DBClient.start_link(host: @db_host)\n end\n end\n\n The difference here is that `compile_env` expects the default value to be\n given as an argument, instead of using the `def application` function of\n your `mix.exs`. Furthermore, by using `compile_env/3`, tools like Mix will\n store the values used during compilation and compare the compilation values\n with the runtime values whenever your system starts, raising an error in\n case they differ.\n\n In any case, compile-time environments should be avoided. Whenever possible,\n reading the application environment at runtime should be the first choice.\n\n ## The application callback module\n\n Applications can be loaded, started, and stopped. Generally, build tools\n like Mix take care of starting an application and all of its dependencies\n for you, but you can also do it manually by calling:\n\n {:ok, _} = Application.ensure_all_started(:some_app)\n\n When an application starts, developers may configure a callback module\n that executes custom code. Developers use this callback to start the\n application supervision tree.\n\n The first step to do so is to add a `:mod` key to the `application/0`\n definition in your `mix.exs` file. It expects a tuple, with the application\n callback module and start argument (commonly an empty list):\n\n def application do\n [mod: {MyApp, []}]\n end\n\n The `MyApp` module given to `:mod` needs to implement the `Application` behaviour.\n This can be done by putting `use Application` in that module and implementing the\n `c:start/2` callback, for example:\n\n defmodule MyApp do\n use Application\n\n def start(_type, _args) do\n children = []\n Supervisor.start_link(children, strategy: :one_for_one)\n end\n end\n\n > #### `use Application` {: .info}\n >\n > When you `use Application`, the `Application` module will\n > set `@behaviour Application` and define an overridable\n > definition for the `c:stop/1` function, which is required\n > by Erlang/OTP.\n\n The `c:start/2` callback has to spawn and link a supervisor and return `{:ok,\n pid}` or `{:ok, pid, state}`, where `pid` is the PID of the supervisor, and\n `state` is an optional application state. `args` is the second element of the\n tuple given to the `:mod` option.\n\n The `type` argument passed to `c:start/2` is usually `:normal` unless in a\n distributed setup where application takeovers and failovers are configured.\n Distributed applications are beyond the scope of this documentation.\n\n When an application is shutting down, its `c:stop/1` callback is called after\n the supervision tree has been stopped by the runtime. This callback allows the\n application to do any final cleanup. The argument is the state returned by\n `c:start/2`, if it did, or `[]` otherwise. The return value of `c:stop/1` is\n ignored.\n\n By using `Application`, modules get a default implementation of `c:stop/1`\n that ignores its argument and returns `:ok`, but it can be overridden.\n\n Application callback modules may also implement the optional callback\n `c:prep_stop/1`. If present, `c:prep_stop/1` is invoked before the supervision\n tree is terminated. Its argument is the state returned by `c:start/2`, if it did,\n or `[]` otherwise, and its return value is passed to `c:stop/1`.\n\n ## The application resource file\n\n In the sections above, we have configured an application in the\n `application/0` section of the `mix.exs` file. Ultimately, Mix will use\n this configuration to create an [*application resource\n file*](https://www.erlang.org/doc/man/app), which is a file called\n `APP_NAME.app`. For example, the application resource file of the OTP\n application `ex_unit` is called `ex_unit.app`.\n\n You can learn more about the generation of application resource files in\n the documentation of `Mix.Tasks.Compile.App`, available as well by running\n `mix help compile.app`.\n\n ## The application life cycle\n\n ### Loading applications\n\n Applications are *loaded*, which means that the runtime finds and processes\n their resource files:\n\n Application.load(:ex_unit)\n #=> :ok\n\n When an application is loaded, the environment specified in its resource file\n is merged with any overrides from config files.\n\n Loading an application *does not* load its modules.\n\n In practice, you rarely load applications by hand because that is part of the\n start process, explained next.\n\n ### Starting applications\n\n Applications are also *started*:\n\n Application.start(:ex_unit)\n #=> :ok\n\n Once your application is compiled, running your system is a matter of starting\n your current application and its dependencies. Differently from other languages,\n Elixir does not have a `main` procedure that is responsible for starting your\n system. Instead, you start one or more applications, each with their own\n initialization and termination logic.\n\n When an application is started, the `Application.load/1` is automatically\n invoked if it hasn't been done yet. Then, it checks if the dependencies listed\n in the `applications` key of the resource file are already started. Having at\n least one dependency not started is an error condition. Functions like\n `ensure_all_started/1` take care of starting an application and all of its\n dependencies for you.\n\n If the application does not have a callback module configured, starting is\n done at this point. Otherwise, its `c:start/2` callback is invoked. The PID of\n the top-level supervisor returned by this function is stored by the runtime\n for later use, and the returned application state is saved too, if any.\n\n ### Stopping applications\n\n Started applications are, finally, *stopped*:\n\n Application.stop(:ex_unit)\n #=> :ok\n\n Stopping an application without a callback module defined, is in practice a\n no-op, except for some system tracing.\n\n Stopping an application with a callback module has three steps:\n\n 1. If present, invoke the optional callback `c:prep_stop/1`.\n 2. Terminate the top-level supervisor.\n 3. Invoke the required callback `c:stop/1`.\n\n The arguments passed to the callbacks are related to the state optionally\n returned by `c:start/2`, and are documented in the section about the callback\n module above.\n\n It is important to highlight that step 2 is a blocking one. Termination of a\n supervisor triggers a recursive chain of children terminations, therefore\n orderly shutting down all descendant processes. The `c:stop/1` callback is\n invoked only after termination of the whole supervision tree.\n\n Shutting down a live system cleanly can be done by calling `System.stop/1`. It\n will shut down every application in the reverse order they were started.\n\n By default, a SIGTERM from the operating system will automatically translate to\n `System.stop/0`. You can also have more explicit control over operating system\n signals via the `:os.set_signal/2` function.\n\n ## Tooling\n\n The Mix build tool automates most of the application management tasks. For example,\n `mix test` automatically starts your application dependencies and your application\n itself before your test runs. `mix run --no-halt` boots your current project and\n can be used to start a long running system. See `mix help run`.\n\n Developers can also use `mix release` to build **releases**. Releases are able to\n package all of your source code as well as the Erlang VM into a single directory.\n Releases also give you explicit control over how each application is started and in\n which order. They also provide a more streamlined mechanism for starting and\n stopping systems, debugging, logging, as well as system monitoring.\n\n Finally, Elixir provides tools such as escripts and archives, which are\n different mechanisms for packaging your application. Those are typically used\n when tools must be shared between developers and not as deployment options.\n See `mix help archive.build` and `mix help escript.build` for more detail.\n\n ## Further information\n\n For further details on applications please check the documentation of the\n [`:application` Erlang module](`:application`), and the\n [Applications](https://www.erlang.org/doc/design_principles/applications.html)\n section of the [OTP Design Principles User's\n Guide](https://www.erlang.org/doc/design_principles/users_guide.html).\n \"\"\"\n\n @doc \"\"\"\n Called when an application is started.\n\n This function is called when an application is started using\n `Application.start/2` (and functions on top of that, such as\n `Application.ensure_started/2`). This function should start the top-level\n process of the application (which should be the top supervisor of the\n application's supervision tree if the application follows the OTP design\n principles around supervision).\n\n `start_type` defines how the application is started:\n\n * `:normal` - used if the startup is a normal startup or if the application\n is distributed and is started on the current node because of a failover\n from another node and the application specification key `:start_phases`\n is `:undefined`.\n * `{:takeover, node}` - used if the application is distributed and is\n started on the current node because of a failover on the node `node`.\n * `{:failover, node}` - used if the application is distributed and is\n started on the current node because of a failover on node `node`, and the\n application specification key `:start_phases` is not `:undefined`.\n\n `start_args` are the arguments passed to the application in the `:mod`\n specification key (for example, `mod: {MyApp, [:my_args]}`).\n\n This function should either return `{:ok, pid}` or `{:ok, pid, state}` if\n startup is successful. `pid` should be the PID of the top supervisor. `state`\n can be an arbitrary term, and if omitted will default to `[]`; if the\n application is later stopped, `state` is passed to the `stop/1` callback (see\n the documentation for the `c:stop/1` callback for more information).\n\n `use Application` provides no default implementation for the `start/2`\n callback.\n \"\"\"\n @callback start(start_type, start_args :: term) ::\n {:ok, pid}\n | {:ok, pid, state}\n | {:error, reason :: term}\n\n @doc \"\"\"\n Called before stopping the application.\n\n This function is called before the top-level supervisor is terminated. It\n receives the state returned by `c:start/2`, if it did, or `[]` otherwise.\n The return value is later passed to `c:stop/1`.\n \"\"\"\n @callback prep_stop(state) :: state\n\n @doc \"\"\"\n Called after an application has been stopped.\n\n This function is called after an application has been stopped, i.e., after its\n supervision tree has been stopped. It should do the opposite of what the\n `c:start/2` callback did, and should perform any necessary cleanup. The return\n value of this callback is ignored.\n\n `state` is the state returned by `c:start/2`, if it did, or `[]` otherwise.\n If the optional callback `c:prep_stop/1` is present, `state` is its return\n value instead.\n\n `use Application` defines a default implementation of this function which does\n nothing and just returns `:ok`.\n \"\"\"\n @callback stop(state) :: term\n\n @doc \"\"\"\n Starts an application in synchronous phases.\n\n This function is called after `start/2` finishes but before\n `Application.start/2` returns. It will be called once for every start phase\n defined in the application's (and any included applications') specification,\n in the order they are listed in.\n \"\"\"\n @callback start_phase(phase :: term, start_type, phase_args :: term) ::\n :ok | {:error, reason :: term}\n\n @doc \"\"\"\n Callback invoked after code upgrade, if the application environment\n has changed.\n\n `changed` is a keyword list of keys and their changed values in the\n application environment. `new` is a keyword list with all new keys\n and their values. `removed` is a list with all removed keys.\n \"\"\"\n @callback config_change(changed, new, removed) :: :ok\n when changed: keyword, new: keyword, removed: [atom]\n\n @optional_callbacks start_phase: 3, prep_stop: 1, config_change: 3\n\n @doc false\n defmacro __using__(_) do\n quote location: :keep do\n @behaviour Application\n\n @doc false\n def stop(_state) do\n :ok\n end\n\n defoverridable Application\n end\n end\n\n @application_keys [\n :description,\n :id,\n :vsn,\n :modules,\n :maxP,\n :maxT,\n :registered,\n :included_applications,\n :optional_applications,\n :applications,\n :mod,\n :start_phases\n ]\n\n application_key_specs = Enum.reduce(@application_keys, &{:|, [], [&1, &2]})\n\n @type app :: atom\n @type key :: atom\n @type application_key :: unquote(application_key_specs)\n @type value :: term\n @type state :: term\n @type start_type :: :normal | {:takeover, node} | {:failover, node}\n\n @typedoc \"\"\"\n Specifies the type of the application:\n\n * `:permanent` - if `app` terminates, all other applications and the entire\n node are also terminated.\n\n * `:transient` - if `app` terminates with `:normal` reason, it is reported\n but no other applications are terminated. If a transient application\n terminates abnormally, all other applications and the entire node are\n also terminated.\n\n * `:temporary` - if `app` terminates, it is reported but no other\n applications are terminated (the default).\n\n Note that it is always possible to stop an application explicitly by calling\n `stop/1`. Regardless of the type of the application, no other applications will\n be affected.\n\n Note also that the `:transient` type is of little practical use, since when a\n supervision tree terminates, the reason is set to `:shutdown`, not `:normal`.\n \"\"\"\n @type restart_type :: :permanent | :transient | :temporary\n\n @doc \"\"\"\n Returns the spec for `app`.\n\n The following keys are returned:\n\n * #{Enum.map_join(@application_keys, \"\\n * \", &\"`#{inspect(&1)}`\")}\n\n For a description of all fields, see [Erlang's application\n specification](https://www.erlang.org/doc/man/app).\n\n Note the environment is not returned as it can be accessed via\n `fetch_env/2`. Returns `nil` if the application is not loaded.\n \"\"\"\n @spec spec(app) :: [{application_key, value}] | nil\n def spec(app) when is_atom(app) do\n case :application.get_all_key(app) do\n {:ok, info} -> :lists.keydelete(:env, 1, info)\n :undefined -> nil\n end\n end\n\n @doc \"\"\"\n Returns the value for `key` in `app`'s specification.\n\n See `spec/1` for the supported keys. If the given\n specification parameter does not exist, this function\n will raise. Returns `nil` if the application is not loaded.\n \"\"\"\n @spec spec(app, application_key) :: value | nil\n def spec(app, key) when is_atom(app) and key in @application_keys do\n case :application.get_key(app, key) do\n {:ok, value} -> value\n :undefined -> nil\n end\n end\n\n @doc \"\"\"\n Gets the application for the given module.\n\n The application is located by analyzing the spec\n of all loaded applications. Returns `nil` if\n the module is not listed in any application spec.\n \"\"\"\n @spec get_application(module) :: app | nil\n def get_application(module) when is_atom(module) do\n case :application.get_application(module) do\n {:ok, app} -> app\n :undefined -> nil\n end\n end\n\n @doc \"\"\"\n Returns all key-value pairs for `app`.\n \"\"\"\n @spec get_all_env(app) :: [{key, value}]\n def get_all_env(app) when is_atom(app) do\n :application.get_all_env(app)\n end\n\n @doc \"\"\"\n Reads the application environment at compilation time.\n\n Similar to `get_env/3`, except it must be used to read values\n at compile time. This allows Elixir to track when configuration\n values change between compile time and runtime.\n\n The first argument is the application name. The second argument\n `key_or_path` is either an atom key or a path to traverse in\n search of the configuration, starting with an atom key.\n\n For example, imagine the following configuration:\n\n config :my_app, :key, [foo: [bar: :baz]]\n\n We can access it during compile time as:\n\n Application.compile_env(:my_app, :key)\n #=> [foo: [bar: :baz]]\n\n Application.compile_env(:my_app, [:key, :foo])\n #=> [bar: :baz]\n\n Application.compile_env(:my_app, [:key, :foo, :bar])\n #=> :baz\n\n A default value can also be given as third argument. If\n any of the keys in the path along the way is missing, the\n default value is used:\n\n Application.compile_env(:my_app, [:unknown, :foo, :bar], :default)\n #=> :default\n\n Application.compile_env(:my_app, [:key, :unknown, :bar], :default)\n #=> :default\n\n Application.compile_env(:my_app, [:key, :foo, :unknown], :default)\n #=> :default\n\n Giving a path is useful to let Elixir know that only certain paths\n in a large configuration are compile time dependent.\n \"\"\"\n @doc since: \"1.10.0\"\n @spec compile_env(app, key | list, value) :: value\n defmacro compile_env(app, key_or_path, default \\\\ nil) do\n if __CALLER__.function do\n raise \"Application.compile_env/3 cannot be called inside functions, only in the module body\"\n end\n\n key_or_path = Macro.expand_literals(key_or_path, %{__CALLER__ | function: {:__info__, 1}})\n\n quote do\n Application.compile_env(__ENV__, unquote(app), unquote(key_or_path), unquote(default))\n end\n end\n\n @doc \"\"\"\n Reads the application environment at compilation time from a macro.\n\n Typically, developers will use `compile_env/3`. This function must\n only be invoked from macros which aim to read the compilation environment\n dynamically.\n\n It expects a `Macro.Env` as first argument, where the `Macro.Env` is\n typically the `__CALLER__` in a macro. It raises if `Macro.Env` comes\n from a function.\n \"\"\"\n @doc since: \"1.14.0\"\n @spec compile_env(Macro.Env.t(), app, key | list, value) :: value\n def compile_env(%Macro.Env{} = env, app, key_or_path, default) do\n case fetch_compile_env(app, key_or_path, env) do\n {:ok, value} -> value\n :error -> default\n end\n end\n\n @doc \"\"\"\n Reads the application environment at compilation time or raises.\n\n This is the same as `compile_env/3` but it raises an\n `ArgumentError` if the configuration is not available.\n \"\"\"\n @doc since: \"1.10.0\"\n @spec compile_env!(app, key | list) :: value\n defmacro compile_env!(app, key_or_path) do\n if __CALLER__.function do\n raise \"Application.compile_env!/2 cannot be called inside functions, only in the module body\"\n end\n\n key_or_path = Macro.expand_literals(key_or_path, %{__CALLER__ | function: {:__info__, 1}})\n\n quote do\n Application.compile_env!(__ENV__, unquote(app), unquote(key_or_path))\n end\n end\n\n @doc \"\"\"\n Reads the application environment at compilation time from a macro\n or raises.\n\n Typically, developers will use `compile_env!/2`. This function must\n only be invoked from macros which aim to read the compilation environment\n dynamically.\n\n It expects a `Macro.Env` as first argument, where the `Macro.Env` is\n typically the `__CALLER__` in a macro. It raises if `Macro.Env` comes\n from a function.\n \"\"\"\n @doc since: \"1.14.0\"\n @spec compile_env!(Macro.Env.t(), app, key | list) :: value\n def compile_env!(%Macro.Env{} = env, app, key_or_path) do\n case fetch_compile_env(app, key_or_path, env) do\n {:ok, value} ->\n value\n\n :error ->\n raise ArgumentError,\n \"could not fetch application environment #{inspect(key_or_path)} for application \" <>\n \"#{inspect(app)} #{fetch_env_failed_reason(app, key_or_path)}\"\n end\n end\n\n defp fetch_compile_env(app, key, env) when is_atom(key) do\n fetch_compile_env(app, key, [], env)\n end\n\n defp fetch_compile_env(app, [key | paths], env) when is_atom(key),\n do: fetch_compile_env(app, key, paths, env)\n\n defp fetch_compile_env(app, key, path, env) do\n return = traverse_env(fetch_env(app, key), path)\n\n for tracer <- env.tracers do\n tracer.trace({:compile_env, app, [key | path], return}, env)\n end\n\n return\n end\n\n defp traverse_env(return, []), do: return\n defp traverse_env(:error, _paths), do: :error\n defp traverse_env({:ok, value}, [key | keys]), do: traverse_env(Access.fetch(value, key), keys)\n\n @doc \"\"\"\n Returns the value for `key` in `app`'s environment.\n\n If the configuration parameter does not exist, the function returns the\n `default` value.\n\n > #### Warning {: .warning}\n >\n > You must use this function to read only your own application\n > environment. Do not read the environment of other applications.\n\n ## Examples\n\n `get_env/3` is commonly used to read the configuration of your OTP applications.\n Since Mix configurations are commonly used to configure applications (including\n your dependencies), we will use this as a point of illustration.\n\n Consider a new application `:my_app`. `:my_app` contains a database engine which\n supports a pool of databases. The database engine needs to know the configuration for\n each of those databases, and that configuration is supplied by key-value pairs in\n environment of `:my_app`. For example, your `config/runtime.exs` file might have:\n\n config :my_app, Databases.RepoOne,\n # A database configuration\n ip: \"localhost\",\n port: 5433\n\n config :my_app, Databases.RepoTwo,\n # Another database configuration (for the same OTP app)\n ip: \"localhost\",\n port: 20_717\n\n config :my_app, my_app_databases: [Databases.RepoOne, Databases.RepoTwo]\n\n Our database engine used by `:my_app` needs to know what databases exist, and\n what the database configurations are. The database engine can make a call to\n `Application.get_env(:my_app, :my_app_databases, [])` to retrieve the list of\n databases (specified by module names).\n\n The engine can then traverse each repository in the list and call\n `Application.get_env(:my_app, Databases.RepoOne)` and so forth to retrieve the\n configuration of each one. In this case, each configuration will be a keyword\n list, so you can use the functions in the `Keyword` module or even the `Access`\n module to traverse it, for example:\n\n config = Application.get_env(:my_app, Databases.RepoOne)\n config[:ip]\n\n The sample `config/runtime.exs` above could be used both for `:my_app` to\n configure itself but also to allow any application that depends on `:my_app`\n to configure how it works. However, one should keep in mind the caveats described\n in the `Application` module documentation: the application environment is global\n state which should be avoided if possible.\n \"\"\"\n @spec get_env(app, key, value) :: value\n def get_env(app, key, default \\\\ nil) when is_atom(app) do\n maybe_warn_on_app_env_key(app, key)\n :application.get_env(app, key, default)\n end\n\n @doc \"\"\"\n Returns the value for `key` in `app`'s environment in a tuple.\n\n If the configuration parameter does not exist, the function returns `:error`.\n\n > #### Warning {: .warning}\n >\n > You must use this function to read only your own application\n > environment. Do not read the environment of other applications.\n\n > #### Application environment in info\n >\n > If you are writing a library to be used by other developers,\n > it is generally recommended to avoid the application environment, as the\n > application environment is effectively a global storage. For more information,\n > read our [library guidelines](library-guidelines.md).\n \"\"\"\n @spec fetch_env(app, key) :: {:ok, value} | :error\n def fetch_env(app, key) when is_atom(app) do\n maybe_warn_on_app_env_key(app, key)\n\n case :application.get_env(app, key) do\n {:ok, value} -> {:ok, value}\n :undefined -> :error\n end\n end\n\n @doc \"\"\"\n Returns the value for `key` in `app`'s environment.\n\n If the configuration parameter does not exist, raises `ArgumentError`.\n\n > #### Warning {: .warning}\n >\n > You must use this function to read only your own application\n > environment. Do not read the environment of other applications.\n\n > #### Application environment in info\n >\n > If you are writing a library to be used by other developers,\n > it is generally recommended to avoid the application environment, as the\n > application environment is effectively a global storage. For more information,\n > read our [library guidelines](library-guidelines.md).\n \"\"\"\n @spec fetch_env!(app, key) :: value\n def fetch_env!(app, key) when is_atom(app) do\n case fetch_env(app, key) do\n {:ok, value} ->\n value\n\n :error ->\n raise ArgumentError,\n \"could not fetch application environment #{inspect(key)} for application \" <>\n \"#{inspect(app)} #{fetch_env_failed_reason(app, key)}\"\n end\n end\n\n defp fetch_env_failed_reason(app, key) do\n vsn = :application.get_key(app, :vsn)\n\n case vsn do\n {:ok, _} ->\n \"because configuration at #{inspect(key)} was not set\"\n\n :undefined ->\n \"because the application was not loaded nor configured\"\n end\n end\n\n @doc \"\"\"\n Puts the `value` in `key` for the given `app`.\n\n > #### Compile environment {: .warning}\n >\n > Do not use this function to change environment variables read\n > via `Application.compile_env/2`. The compile environment must\n > be exclusively set before compilation, in your config files.\n\n ## Options\n\n * `:timeout` - the timeout for the change (defaults to `5_000` milliseconds)\n * `:persistent` - persists the given value on application load and reloads\n\n If `put_env/4` is called before the application is loaded, the application\n environment values specified in the `.app` file will override the ones\n previously set.\n\n The `:persistent` option can be set to `true` when there is a need to guarantee\n parameters set with this function will not be overridden by the ones defined\n in the application resource file on load. This means persistent values will\n stick after the application is loaded and also on application reload.\n \"\"\"\n @spec put_env(app, key, value, timeout: timeout, persistent: boolean) :: :ok\n def put_env(app, key, value, opts \\\\ []) when is_atom(app) and is_list(opts) do\n maybe_warn_on_app_env_key(app, key)\n :application.set_env(app, key, value, opts)\n end\n\n @doc \"\"\"\n Puts the environment for multiple applications at the same time.\n\n The given config should not:\n\n * have the same application listed more than once\n * have the same key inside the same application listed more than once\n\n If those conditions are not met, this function will raise.\n\n This function receives the same options as `put_env/4`. Returns `:ok`.\n\n ## Examples\n\n Application.put_all_env(\n my_app: [\n key: :value,\n another_key: :another_value\n ],\n another_app: [\n key: :value\n ]\n )\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec put_all_env([{app, [{key, value}]}], timeout: timeout, persistent: boolean) :: :ok\n def put_all_env(config, opts \\\\ []) when is_list(config) and is_list(opts) do\n :application.set_env(config, opts)\n end\n\n @doc \"\"\"\n Deletes the `key` from the given `app` environment.\n\n It receives the same options as `put_env/4`. Returns `:ok`.\n \"\"\"\n @spec delete_env(app, key, timeout: timeout, persistent: boolean) :: :ok\n def delete_env(app, key, opts \\\\ []) when is_atom(app) and is_list(opts) do\n maybe_warn_on_app_env_key(app, key)\n :application.unset_env(app, key, opts)\n end\n\n defp maybe_warn_on_app_env_key(_app, key) when is_atom(key),\n do: :ok\n\n # TODO: Remove this deprecation warning on 2.0+ and allow list lookups as in compile_env.\n defp maybe_warn_on_app_env_key(app, key) do\n message = fn ->\n \"passing non-atom as application env key is deprecated, got: #{inspect(key)}\"\n end\n\n IO.warn_once({Application, :key, app, key}, message, _stacktrace_drop_levels = 2)\n end\n\n @doc \"\"\"\n Ensures the given `app` is started with `t:restart_type/0`.\n\n Same as `start/2` but returns `:ok` if the application was already\n started.\n \"\"\"\n @spec ensure_started(app, restart_type()) :: :ok | {:error, term}\n def ensure_started(app, type \\\\ :temporary) when is_atom(app) and is_atom(type) do\n :application.ensure_started(app, type)\n end\n\n @doc \"\"\"\n Ensures the given `app` is loaded.\n\n Same as `load/1` but returns `:ok` if the application was already\n loaded.\n \"\"\"\n @doc since: \"1.10.0\"\n @spec ensure_loaded(app) :: :ok | {:error, term}\n def ensure_loaded(app) when is_atom(app) do\n case :application.load(app) do\n :ok -> :ok\n {:error, {:already_loaded, ^app}} -> :ok\n {:error, _} = error -> error\n end\n end\n\n @doc \"\"\"\n Ensures the given `app` or `apps` and their child applications are started.\n\n The second argument is either the `t:restart_type/0` (for consistency with\n `start/2`) or a keyword list.\n\n ## Options\n\n * `:type` - if the application should be started `:temporary` (default),\n `:permanent`, or `:transient`. See `t:restart_type/0` for more information.\n\n * `:mode` - (since v1.15.0) if the applications should be started serially\n (`:serial`, default) or concurrently (`:concurrent`).\n\n \"\"\"\n @spec ensure_all_started(app | [app], type: restart_type(), mode: :serial | :concurrent) ::\n {:ok, [app]} | {:error, term}\n @spec ensure_all_started(app | [app], restart_type()) ::\n {:ok, [app]} | {:error, term}\n def ensure_all_started(app_or_apps, type_or_opts \\\\ [])\n\n def ensure_all_started(app_or_apps, type) when is_atom(type) do\n ensure_all_started(app_or_apps, type: type)\n end\n\n def ensure_all_started(app, opts) when is_atom(app) and is_list(opts) do\n ensure_all_started([app], opts)\n end\n\n @compile {:no_warn_undefined, {:application, :ensure_all_started, 3}}\n\n def ensure_all_started(apps, opts) when is_list(apps) and is_list(opts) do\n opts = Keyword.validate!(opts, type: :temporary, mode: :serial)\n :application.ensure_all_started(apps, opts[:type], opts[:mode])\n end\n\n @doc \"\"\"\n Starts the given `app` with `t:restart_type/0`.\n\n If the `app` is not loaded, the application will first be loaded using `load/1`.\n Any included application, defined in the `:included_applications` key of the\n `.app` file will also be loaded, but they won't be started.\n\n Furthermore, all applications listed in the `:applications` key must be explicitly\n started before this application is. If not, `{:error, {:not_started, app}}` is\n returned, where `app` is the name of the missing application.\n\n In case you want to automatically load **and start** all of `app`'s dependencies,\n see `ensure_all_started/2`.\n \"\"\"\n @spec start(app, restart_type()) :: :ok | {:error, term}\n def start(app, type \\\\ :temporary) when is_atom(app) and is_atom(type) do\n :application.start(app, type)\n end\n\n @doc \"\"\"\n Stops the given `app`.\n\n When stopped, the application is still loaded.\n \"\"\"\n @spec stop(app) :: :ok | {:error, term}\n def stop(app) when is_atom(app) do\n :application.stop(app)\n end\n\n @doc \"\"\"\n Loads the given `app`.\n\n In order to be loaded, an `.app` file must be in the load paths.\n All `:included_applications` will also be loaded.\n\n Loading the application does not start it nor load its modules, but\n it does load its environment.\n \"\"\"\n @spec load(app) :: :ok | {:error, term}\n def load(app) when is_atom(app) do\n :application.load(app)\n end\n\n @doc \"\"\"\n Unloads the given `app`.\n\n It will also unload all `:included_applications`.\n Note that the function does not purge the application modules.\n \"\"\"\n @spec unload(app) :: :ok | {:error, term}\n def unload(app) when is_atom(app) do\n :application.unload(app)\n end\n\n @doc \"\"\"\n Gets the directory for app.\n\n This information is returned based on the code path. Here is an\n example:\n\n File.mkdir_p!(\"foo/ebin\")\n Code.prepend_path(\"foo/ebin\")\n Application.app_dir(:foo)\n #=> \"foo\"\n\n Even though the directory is empty and there is no `.app` file\n it is considered the application directory based on the name\n \"foo/ebin\". The name may contain a dash `-` which is considered\n to be the app version and it is removed for the lookup purposes:\n\n File.mkdir_p!(\"bar-123/ebin\")\n Code.prepend_path(\"bar-123/ebin\")\n Application.app_dir(:bar)\n #=> \"bar-123\"\n\n For more information on code paths, check the `Code` module in\n Elixir and also Erlang's [`:code` module](`:code`).\n \"\"\"\n @spec app_dir(app) :: String.t()\n def app_dir(app) when is_atom(app) do\n case :code.lib_dir(app) do\n lib when is_list(lib) -> IO.chardata_to_string(lib)\n {:error, :bad_name} -> raise ArgumentError, \"unknown application: #{inspect(app)}\"\n end\n end\n\n @doc \"\"\"\n Returns the given path inside `app_dir/1`.\n\n If `path` is a string, then it will be used as the path inside `app_dir/1`. If\n `path` is a list of strings, it will be joined (see `Path.join/1`) and the result\n will be used as the path inside `app_dir/1`.\n\n ## Examples\n\n File.mkdir_p!(\"foo/ebin\")\n Code.prepend_path(\"foo/ebin\")\n\n Application.app_dir(:foo, \"my_path\")\n #=> \"foo/my_path\"\n\n Application.app_dir(:foo, [\"my\", \"nested\", \"path\"])\n #=> \"foo/my/nested/path\"\n\n \"\"\"\n @spec app_dir(app, String.t() | [String.t()]) :: String.t()\n def app_dir(app, path)\n\n def app_dir(app, path) when is_atom(app) and is_binary(path) do\n Path.join(app_dir(app), path)\n end\n\n def app_dir(app, path) when is_atom(app) and is_list(path) do\n Path.join([app_dir(app) | path])\n end\n\n @doc \"\"\"\n Returns a list with information about the applications which are currently running.\n \"\"\"\n @spec started_applications(timeout) :: [{app, description :: charlist(), vsn :: charlist()}]\n def started_applications(timeout \\\\ 5000)\n when timeout == :infinity or (is_integer(timeout) and timeout >= 0) do\n :application.which_applications(timeout)\n end\n\n @doc \"\"\"\n Returns a list with information about the applications which have been loaded.\n \"\"\"\n @spec loaded_applications :: [{app, description :: charlist(), vsn :: charlist()}]\n def loaded_applications do\n :application.loaded_applications()\n end\n\n @doc \"\"\"\n Formats the error reason returned by `start/2`,\n `ensure_started/2`, `stop/1`, `load/1` and `unload/1`,\n returns a string.\n \"\"\"\n @spec format_error(any) :: String.t()\n def format_error(reason) do\n try do\n do_format_error(reason)\n catch\n # A user could create an error that looks like a built-in one\n # causing an error.\n :error, _ ->\n inspect(reason)\n end\n end\n\n # exit(:normal) call is special cased, undo the special case.\n defp do_format_error({{:EXIT, :normal}, {mod, :start, args}}) do\n Exception.format_exit({:normal, {mod, :start, args}})\n end\n\n # {:error, reason} return value\n defp do_format_error({reason, {mod, :start, args}}) do\n Exception.format_mfa(mod, :start, args) <>\n \" returned an error: \" <> Exception.format_exit(reason)\n end\n\n # error or exit(reason) call, use exit reason as reason.\n defp do_format_error({:bad_return, {{mod, :start, args}, {:EXIT, reason}}}) do\n Exception.format_exit({reason, {mod, :start, args}})\n end\n\n # bad return value\n defp do_format_error({:bad_return, {{mod, :start, args}, return}}) do\n Exception.format_mfa(mod, :start, args) <> \" returned a bad value: \" <> inspect(return)\n end\n\n defp do_format_error({:already_started, app}) when is_atom(app) do\n \"already started application #{app}\"\n end\n\n defp do_format_error({:not_started, app}) when is_atom(app) do\n \"not started application #{app}\"\n end\n\n defp do_format_error({:bad_application, app}) do\n \"bad application: #{inspect(app)}\"\n end\n\n defp do_format_error({:already_loaded, app}) when is_atom(app) do\n \"already loaded application #{app}\"\n end\n\n defp do_format_error({:not_loaded, app}) when is_atom(app) do\n \"not loaded application #{app}\"\n end\n\n defp do_format_error({:invalid_restart_type, restart}) do\n \"invalid application restart type: #{inspect(restart)}\"\n end\n\n defp do_format_error({:invalid_name, name}) do\n \"invalid application name: #{inspect(name)}\"\n end\n\n defp do_format_error({:invalid_options, opts}) do\n \"invalid application options: #{inspect(opts)}\"\n end\n\n defp do_format_error({:badstartspec, spec}) do\n \"bad application start specs: #{inspect(spec)}\"\n end\n\n defp do_format_error({~c\"no such file or directory\", file}) do\n \"could not find application file: #{file}\"\n end\n\n defp do_format_error(reason) do\n Exception.format_exit(reason)\n end\nend\n" }, { "path": "lib/elixir/lib/atom.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Atom do\n @moduledoc \"\"\"\n Atoms are constants whose values are their own name.\n\n They are often useful to enumerate over distinct values, such as:\n\n iex> :apple\n :apple\n iex> :orange\n :orange\n iex> :watermelon\n :watermelon\n\n Atoms are equal if their names are equal.\n\n iex> :apple == :apple\n true\n iex> :apple == :orange\n false\n\n Often they are used to express the state of an operation, by using\n values such as `:ok` and `:error`.\n\n The booleans `true` and `false` are also atoms:\n\n iex> true == :true\n true\n iex> is_atom(false)\n true\n iex> is_boolean(:false)\n true\n\n Elixir allows you to skip the leading `:` for the atoms `false`, `true`,\n and `nil`.\n\n Atoms must be composed of Unicode characters such as letters, numbers,\n underscore, and `@`. If the keyword has a character that does not\n belong to the category above, such as spaces, you can wrap it in\n quotes:\n\n iex> :\"this is an atom with spaces\"\n :\"this is an atom with spaces\"\n\n \"\"\"\n\n @doc \"\"\"\n Converts an atom to a string.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Atom.to_string(:foo)\n \"foo\"\n\n \"\"\"\n @spec to_string(atom) :: String.t()\n def to_string(atom) do\n :erlang.atom_to_binary(atom)\n end\n\n @doc \"\"\"\n Converts an atom to a charlist.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Atom.to_charlist(:\"An atom\")\n ~c\"An atom\"\n\n \"\"\"\n @spec to_charlist(atom) :: charlist\n def to_charlist(atom) do\n :erlang.atom_to_list(atom)\n end\n\n @doc false\n @deprecated \"Use Atom.to_charlist/1 instead\"\n @spec to_char_list(atom) :: charlist\n def to_char_list(atom), do: Atom.to_charlist(atom)\nend\n" }, { "path": "lib/elixir/lib/base.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Base do\n import Bitwise\n\n @moduledoc \"\"\"\n This module provides data encoding and decoding functions\n according to [RFC 4648](https://tools.ietf.org/html/rfc4648).\n\n This document defines the commonly used base 16, base 32, and base\n 64 encoding schemes.\n\n ## Base 16 alphabet\n\n | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |\n |------:|:---------|------:|:---------|------:|:---------|------:|:---------|\n | 0 | 0 | 4 | 4 | 8 | 8 | 12 | C |\n | 1 | 1 | 5 | 5 | 9 | 9 | 13 | D |\n | 2 | 2 | 6 | 6 | 10 | A | 14 | E |\n | 3 | 3 | 7 | 7 | 11 | B | 15 | F |\n\n ## Base 32 alphabet\n\n | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |\n |------:|:---------|------:|:---------|------:|:---------|------:|:---------|\n | 0 | A | 9 | J | 18 | S | 27 | 3 |\n | 1 | B | 10 | K | 19 | T | 28 | 4 |\n | 2 | C | 11 | L | 20 | U | 29 | 5 |\n | 3 | D | 12 | M | 21 | V | 30 | 6 |\n | 4 | E | 13 | N | 22 | W | 31 | 7 |\n | 5 | F | 14 | O | 23 | X | | |\n | 6 | G | 15 | P | 24 | Y | (pad) | = |\n | 7 | H | 16 | Q | 25 | Z | | |\n | 8 | I | 17 | R | 26 | 2 | | |\n\n\n ## Base 32 (extended hex) alphabet\n\n | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |\n |------:|:---------|------:|:---------|------:|:---------|------:|:---------|\n | 0 | 0 | 9 | 9 | 18 | I | 27 | R |\n | 1 | 1 | 10 | A | 19 | J | 28 | S |\n | 2 | 2 | 11 | B | 20 | K | 29 | T |\n | 3 | 3 | 12 | C | 21 | L | 30 | U |\n | 4 | 4 | 13 | D | 22 | M | 31 | V |\n | 5 | 5 | 14 | E | 23 | N | | |\n | 6 | 6 | 15 | F | 24 | O | (pad) | = |\n | 7 | 7 | 16 | G | 25 | P | | |\n | 8 | 8 | 17 | H | 26 | Q | | |\n\n ## Base 64 alphabet\n\n | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |\n |------:|:----------|------:|:---------|------:|:---------|------:|:---------|\n | 0 | A | 17 | R | 34 | i | 51 | z |\n | 1 | B | 18 | S | 35 | j | 52 | 0 |\n | 2 | C | 19 | T | 36 | k | 53 | 1 |\n | 3 | D | 20 | U | 37 | l | 54 | 2 |\n | 4 | E | 21 | V | 38 | m | 55 | 3 |\n | 5 | F | 22 | W | 39 | n | 56 | 4 |\n | 6 | G | 23 | X | 40 | o | 57 | 5 |\n | 7 | H | 24 | Y | 41 | p | 58 | 6 |\n | 8 | I | 25 | Z | 42 | q | 59 | 7 |\n | 9 | J | 26 | a | 43 | r | 60 | 8 |\n | 10 | K | 27 | b | 44 | s | 61 | 9 |\n | 11 | L | 28 | c | 45 | t | 62 | + |\n | 12 | M | 29 | d | 46 | u | 63 | / |\n | 13 | N | 30 | e | 47 | v | | |\n | 14 | O | 31 | f | 48 | w | (pad) | = |\n | 15 | P | 32 | g | 49 | x | | |\n | 16 | Q | 33 | h | 50 | y | | |\n\n ## Base 64 (URL and filename safe) alphabet\n\n | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |\n |------:|:---------|------:|:---------|------:|:---------|------:|:---------|\n | 0 | A | 17 | R | 34 | i | 51 | z |\n | 1 | B | 18 | S | 35 | j | 52 | 0 |\n | 2 | C | 19 | T | 36 | k | 53 | 1 |\n | 3 | D | 20 | U | 37 | l | 54 | 2 |\n | 4 | E | 21 | V | 38 | m | 55 | 3 |\n | 5 | F | 22 | W | 39 | n | 56 | 4 |\n | 6 | G | 23 | X | 40 | o | 57 | 5 |\n | 7 | H | 24 | Y | 41 | p | 58 | 6 |\n | 8 | I | 25 | Z | 42 | q | 59 | 7 |\n | 9 | J | 26 | a | 43 | r | 60 | 8 |\n | 10 | K | 27 | b | 44 | s | 61 | 9 |\n | 11 | L | 28 | c | 45 | t | 62 | - |\n | 12 | M | 29 | d | 46 | u | 63 | _ |\n | 13 | N | 30 | e | 47 | v | | |\n | 14 | O | 31 | f | 48 | w | (pad) | = |\n | 15 | P | 32 | g | 49 | x | | |\n | 16 | Q | 33 | h | 50 | y | | |\n\n \"\"\"\n\n @type encode_case :: :upper | :lower\n @type decode_case :: :upper | :lower | :mixed\n\n b16_alphabet = ~c\"0123456789ABCDEF\"\n b64_alphabet = ~c\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\n b64url_alphabet = ~c\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"\n b32_alphabet = ~c\"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567\"\n b32hex_alphabet = ~c\"0123456789ABCDEFGHIJKLMNOPQRSTUV\"\n\n to_lower_enc = &Enum.map(&1, fn c -> if c in ?A..?Z, do: c - ?A + ?a, else: c end)\n\n to_mixed_dec =\n &Enum.flat_map(&1, fn {encoding, value} = pair ->\n if encoding in ?A..?Z do\n [pair, {encoding - ?A + ?a, value}]\n else\n [pair]\n end\n end)\n\n to_lower_dec =\n &Enum.map(&1, fn {encoding, value} = pair ->\n if encoding in ?A..?Z do\n {encoding - ?A + ?a, value}\n else\n pair\n end\n end)\n\n to_encode_list = fn alphabet ->\n for e1 <- alphabet, e2 <- alphabet, do: bsl(e1, 8) + e2\n end\n\n to_decode_list = fn alphabet ->\n alphabet = Enum.sort(alphabet)\n map = Map.new(alphabet)\n {min, _} = List.first(alphabet)\n {max, _} = List.last(alphabet)\n {min, Enum.map(min..max, &map[&1])}\n end\n\n defp bad_character!(byte) do\n raise ArgumentError,\n \"non-alphabet character found: #{inspect(<>, binaries: :as_strings)} (byte #{byte})\"\n end\n\n defp maybe_pad(acc, false, _count), do: acc\n defp maybe_pad(acc, true, 6), do: acc <> \"======\"\n defp maybe_pad(acc, true, 4), do: acc <> \"====\"\n defp maybe_pad(acc, true, 3), do: acc <> \"===\"\n defp maybe_pad(acc, true, 2), do: acc <> \"==\"\n defp maybe_pad(acc, true, 1), do: acc <> \"=\"\n\n defp remove_ignored(string, nil), do: string\n\n defp remove_ignored(string, :whitespace) do\n for <>, char not in ~c\"\\s\\t\\r\\n\", into: <<>>, do: <>\n end\n\n @doc \"\"\"\n Encodes a binary string into a base 16 encoded string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to use when encoding\n\n The values for `:case` can be:\n\n * `:upper` - uses upper case characters (default)\n * `:lower` - uses lower case characters\n\n ## Examples\n\n iex> Base.encode16(\"foobar\")\n \"666F6F626172\"\n\n iex> Base.encode16(\"foobar\", case: :lower)\n \"666f6f626172\"\n\n \"\"\"\n @spec encode16(binary, case: encode_case) :: binary\n def encode16(data, opts \\\\ []) when is_binary(data) do\n case Keyword.get(opts, :case, :upper) do\n :upper -> encode16upper(data, \"\")\n :lower -> encode16lower(data, \"\")\n end\n end\n\n for {base, alphabet} <- [upper: b16_alphabet, lower: to_lower_enc.(b16_alphabet)] do\n name = :\"encode16#{base}\"\n encoded = to_encode_list.(alphabet)\n\n @compile {:inline, [{name, 1}]}\n defp unquote(name)(byte) do\n elem({unquote_splicing(encoded)}, byte)\n end\n\n defp unquote(name)(<>, acc) do\n unquote(name)(\n rest,\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n unquote(name)(c3)::16,\n unquote(name)(c4)::16,\n unquote(name)(c5)::16,\n unquote(name)(c6)::16,\n unquote(name)(c7)::16,\n unquote(name)(c8)::16\n >>\n )\n end\n\n defp unquote(name)(<>, acc) do\n unquote(name)(\n rest,\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n unquote(name)(c3)::16,\n unquote(name)(c4)::16\n >>\n )\n end\n\n defp unquote(name)(<>, acc) do\n unquote(name)(rest, <>)\n end\n\n defp unquote(name)(<>, acc) do\n unquote(name)(rest, <>)\n end\n\n defp unquote(name)(<<>>, acc) do\n acc\n end\n end\n\n @doc \"\"\"\n Decodes a base 16 encoded string into a binary string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to accept when decoding\n\n The values for `:case` can be:\n\n * `:upper` - only allows upper case characters (default)\n * `:lower` - only allows lower case characters\n * `:mixed` - allows mixed case characters\n\n ## Examples\n\n iex> Base.decode16(\"666F6F626172\")\n {:ok, \"foobar\"}\n\n iex> Base.decode16(\"666f6f626172\", case: :lower)\n {:ok, \"foobar\"}\n\n iex> Base.decode16(\"666f6F626172\", case: :mixed)\n {:ok, \"foobar\"}\n\n \"\"\"\n @spec decode16(binary, case: decode_case) :: {:ok, binary} | :error\n def decode16(string, opts \\\\ []) do\n {:ok, decode16!(string, opts)}\n rescue\n ArgumentError -> :error\n end\n\n @doc \"\"\"\n Decodes a base 16 encoded string into a binary string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to accept when decoding\n\n The values for `:case` can be:\n\n * `:upper` - only allows upper case characters (default)\n * `:lower` - only allows lower case characters\n * `:mixed` - allows mixed case characters\n\n An `ArgumentError` exception is raised if the padding is incorrect or\n a non-alphabet character is present in the string.\n\n ## Examples\n\n iex> Base.decode16!(\"666F6F626172\")\n \"foobar\"\n\n iex> Base.decode16!(\"666f6f626172\", case: :lower)\n \"foobar\"\n\n iex> Base.decode16!(\"666f6F626172\", case: :mixed)\n \"foobar\"\n\n \"\"\"\n @spec decode16!(binary, case: decode_case) :: binary\n def decode16!(string, opts \\\\ [])\n\n def decode16!(string, opts) when is_binary(string) and rem(byte_size(string), 2) == 0 do\n case Keyword.get(opts, :case, :upper) do\n :upper -> decode16upper!(string, \"\")\n :lower -> decode16lower!(string, \"\")\n :mixed -> decode16mixed!(string, \"\")\n end\n end\n\n def decode16!(string, _opts) when is_binary(string) do\n raise ArgumentError,\n \"string given to decode has wrong length. An even number of bytes was expected, got: #{byte_size(string)}. \" <>\n \"Double check your string for unwanted characters or pad it accordingly\"\n end\n\n @doc \"\"\"\n Checks if a string is a valid base 16 encoded string.\n\n > #### When to use this {: .tip}\n >\n > Use this function when you just need to *validate* that a string is\n > valid base 16 data, without actually producing a decoded output string.\n > This function is both more performant and memory efficient than using\n > `decode16/2`, checking that the result is `{:ok, ...}`, and then\n > discarding the decoded binary.\n\n ## Options\n\n Accepts the same options as `decode16/2`.\n\n ## Examples\n\n iex> Base.valid16?(\"666F6F626172\")\n true\n\n iex> Base.valid16?(\"666f6f626172\", case: :lower)\n true\n\n iex> Base.valid16?(\"666f6F626172\", case: :mixed)\n true\n\n iex> Base.valid16?(\"ff\", case: :upper)\n false\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec valid16?(binary, case: decode_case) :: boolean\n def valid16?(string, opts \\\\ [])\n\n def valid16?(string, opts) when is_binary(string) and rem(byte_size(string), 2) == 0 do\n case Keyword.get(opts, :case, :upper) do\n :upper -> validate16upper?(string)\n :lower -> validate16lower?(string)\n :mixed -> validate16mixed?(string)\n end\n end\n\n def valid16?(string, _opts) when is_binary(string) do\n false\n end\n\n upper = Enum.with_index(b16_alphabet)\n\n for {base, alphabet} <- [upper: upper, lower: to_lower_dec.(upper), mixed: to_mixed_dec.(upper)] do\n decode_name = :\"decode16#{base}!\"\n validate_name = :\"validate16#{base}?\"\n valid_char_name = :\"valid_char16#{base}?\"\n\n {min, decoded} = to_decode_list.(alphabet)\n\n defp unquote(validate_name)(<<>>), do: true\n\n defp unquote(validate_name)(<>) do\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(validate_name)(rest)\n end\n\n defp unquote(validate_name)(<<_char, _rest::binary>>), do: false\n\n @compile {:inline, [{valid_char_name, 1}]}\n defp unquote(valid_char_name)(char)\n when elem({unquote_splicing(decoded)}, char - unquote(min)) != nil,\n do: true\n\n defp unquote(valid_char_name)(_char), do: false\n\n defp unquote(decode_name)(char) do\n index = char - unquote(min)\n\n cond do\n index not in 0..unquote(length(decoded) - 1) -> bad_character!(char)\n new_char = elem({unquote_splicing(decoded)}, index) -> new_char\n true -> bad_character!(char)\n end\n end\n\n defp unquote(decode_name)(<>, acc) do\n unquote(decode_name)(\n rest,\n <<\n acc::binary,\n unquote(decode_name)(c1)::4,\n unquote(decode_name)(c2)::4,\n unquote(decode_name)(c3)::4,\n unquote(decode_name)(c4)::4,\n unquote(decode_name)(c5)::4,\n unquote(decode_name)(c6)::4,\n unquote(decode_name)(c7)::4,\n unquote(decode_name)(c8)::4\n >>\n )\n end\n\n defp unquote(decode_name)(<>, acc) do\n unquote(decode_name)(\n rest,\n <<\n acc::binary,\n unquote(decode_name)(c1)::4,\n unquote(decode_name)(c2)::4,\n unquote(decode_name)(c3)::4,\n unquote(decode_name)(c4)::4\n >>\n )\n end\n\n defp unquote(decode_name)(<>, acc) do\n unquote(decode_name)(\n rest,\n <>\n )\n end\n\n defp unquote(decode_name)(<<>>, acc) do\n acc\n end\n end\n\n @doc \"\"\"\n Encodes a binary string into a base 64 encoded string.\n\n Accepts `padding: false` option which will omit padding from\n the output string.\n\n ## Examples\n\n iex> Base.encode64(\"foobar\")\n \"Zm9vYmFy\"\n\n iex> Base.encode64(\"foob\")\n \"Zm9vYg==\"\n\n iex> Base.encode64(\"foob\", padding: false)\n \"Zm9vYg\"\n\n \"\"\"\n @spec encode64(binary, padding: boolean) :: binary\n def encode64(data, opts \\\\ []) when is_binary(data) do\n pad? = Keyword.get(opts, :padding, true)\n encode64base(data, \"\", pad?)\n end\n\n @doc \"\"\"\n Encodes a binary string into a base 64 encoded string with URL and filename\n safe alphabet.\n\n Accepts `padding: false` option which will omit padding from\n the output string.\n\n ## Examples\n\n iex> Base.url_encode64(<<255, 127, 254, 252>>)\n \"_3_-_A==\"\n\n iex> Base.url_encode64(<<255, 127, 254, 252>>, padding: false)\n \"_3_-_A\"\n\n \"\"\"\n @spec url_encode64(binary, padding: boolean) :: binary\n def url_encode64(data, opts \\\\ []) when is_binary(data) do\n pad? = Keyword.get(opts, :padding, true)\n encode64url(data, \"\", pad?)\n end\n\n for {base, alphabet} <- [base: b64_alphabet, url: b64url_alphabet] do\n name = :\"encode64#{base}\"\n encoded = to_encode_list.(alphabet)\n\n @compile {:inline, [{name, 1}]}\n defp unquote(name)(byte) do\n elem({unquote_splicing(encoded)}, byte)\n end\n\n defp unquote(name)(<>, acc, pad?) do\n unquote(name)(\n rest,\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n unquote(name)(c3)::16,\n unquote(name)(c4)::16\n >>,\n pad?\n )\n end\n\n defp unquote(name)(<>, acc, pad?) do\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n unquote(name)(c3)::16,\n c4 |> bsl(2) |> unquote(name)() |> band(0x00FF)::8\n >>\n |> maybe_pad(pad?, 1)\n end\n\n defp unquote(name)(<>, acc, pad?) do\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n c3 |> bsl(4) |> unquote(name)()::16\n >>\n |> maybe_pad(pad?, 2)\n end\n\n defp unquote(name)(<>, acc, _pad?) do\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16\n >>\n end\n\n defp unquote(name)(<>, acc, pad?) do\n <<\n acc::binary,\n unquote(name)(c1)::16,\n c2 |> bsl(2) |> unquote(name)() |> band(0x00FF)::8\n >>\n |> maybe_pad(pad?, 1)\n end\n\n defp unquote(name)(<>, acc, pad?) do\n <<\n acc::binary,\n c1 |> bsl(4) |> unquote(name)()::16\n >>\n |> maybe_pad(pad?, 2)\n end\n\n defp unquote(name)(<<>>, acc, _pad?) do\n acc\n end\n end\n\n @doc \"\"\"\n Decodes a base 64 encoded string into a binary string.\n\n Accepts `ignore: :whitespace` option which will ignore all the\n whitespace characters in the input string.\n\n Accepts `padding: false` option which will ignore padding from\n the input string.\n\n ## Examples\n\n iex> Base.decode64(\"Zm9vYmFy\")\n {:ok, \"foobar\"}\n\n iex> Base.decode64(\"Zm9vYmFy\\\\n\", ignore: :whitespace)\n {:ok, \"foobar\"}\n\n iex> Base.decode64(\"Zm9vYg==\")\n {:ok, \"foob\"}\n\n iex> Base.decode64(\"Zm9vYg\", padding: false)\n {:ok, \"foob\"}\n\n \"\"\"\n @spec decode64(binary, ignore: :whitespace, padding: boolean) :: {:ok, binary} | :error\n def decode64(string, opts \\\\ []) when is_binary(string) do\n {:ok, decode64!(string, opts)}\n rescue\n ArgumentError -> :error\n end\n\n @doc \"\"\"\n Decodes a base 64 encoded string into a binary string.\n\n Accepts `ignore: :whitespace` option which will ignore all the\n whitespace characters in the input string.\n\n Accepts `padding: false` option which will ignore padding from\n the input string.\n\n An `ArgumentError` exception is raised if the padding is incorrect or\n a non-alphabet character is present in the string.\n\n ## Examples\n\n iex> Base.decode64!(\"Zm9vYmFy\")\n \"foobar\"\n\n iex> Base.decode64!(\"Zm9vYmFy\\\\n\", ignore: :whitespace)\n \"foobar\"\n\n iex> Base.decode64!(\"Zm9vYg==\")\n \"foob\"\n\n iex> Base.decode64!(\"Zm9vYg\", padding: false)\n \"foob\"\n\n \"\"\"\n @spec decode64!(binary, ignore: :whitespace, padding: boolean) :: binary\n def decode64!(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n string |> remove_ignored(opts[:ignore]) |> decode64base!(pad?)\n end\n\n @doc \"\"\"\n Validates a base 64 encoded string.\n\n > #### When to use this {: .tip}\n >\n > Use this function when you just need to *validate* that a string is\n > valid base 64 data, without actually producing a decoded output string.\n > This function is both more performant and memory efficient than using\n > `decode64/2`, checking that the result is `{:ok, ...}`, and then\n > discarding the decoded binary.\n\n ## Options\n\n Accepts the same options as `decode64/2`.\n\n ## Examples\n\n iex> Base.valid64?(\"Zm9vYmFy\")\n true\n\n iex> Base.valid64?(\"Zm9vYmFy\\\\n\", ignore: :whitespace)\n true\n\n iex> Base.valid64?(\"Zm9vYg==\")\n true\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec valid64?(binary, ignore: :whitespace, padding: boolean) :: boolean\n def valid64?(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n string |> remove_ignored(opts[:ignore]) |> validate64base?(pad?)\n end\n\n @doc \"\"\"\n Decodes a base 64 encoded string with URL and filename safe alphabet\n into a binary string.\n\n Accepts `ignore: :whitespace` option which will ignore all the\n whitespace characters in the input string.\n\n Accepts `padding: false` option which will ignore padding from\n the input string.\n\n ## Examples\n\n iex> Base.url_decode64(\"_3_-_A==\")\n {:ok, <<255, 127, 254, 252>>}\n\n iex> Base.url_decode64(\"_3_-_A==\\\\n\", ignore: :whitespace)\n {:ok, <<255, 127, 254, 252>>}\n\n iex> Base.url_decode64(\"_3_-_A\", padding: false)\n {:ok, <<255, 127, 254, 252>>}\n\n \"\"\"\n @spec url_decode64(binary, ignore: :whitespace, padding: boolean) :: {:ok, binary} | :error\n def url_decode64(string, opts \\\\ []) when is_binary(string) do\n {:ok, url_decode64!(string, opts)}\n rescue\n ArgumentError -> :error\n end\n\n @doc \"\"\"\n Decodes a base 64 encoded string with URL and filename safe alphabet\n into a binary string.\n\n Accepts `ignore: :whitespace` option which will ignore all the\n whitespace characters in the input string.\n\n Accepts `padding: false` option which will ignore padding from\n the input string.\n\n An `ArgumentError` exception is raised if the padding is incorrect or\n a non-alphabet character is present in the string.\n\n ## Examples\n\n iex> Base.url_decode64!(\"_3_-_A==\")\n <<255, 127, 254, 252>>\n\n iex> Base.url_decode64!(\"_3_-_A==\\\\n\", ignore: :whitespace)\n <<255, 127, 254, 252>>\n\n iex> Base.url_decode64!(\"_3_-_A\", padding: false)\n <<255, 127, 254, 252>>\n\n \"\"\"\n @spec url_decode64!(binary, ignore: :whitespace, padding: boolean) :: binary\n def url_decode64!(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n string |> remove_ignored(opts[:ignore]) |> decode64url!(pad?)\n end\n\n @doc \"\"\"\n Validates a base 64 encoded string with URL and filename safe alphabet.\n\n > #### When to use this {: .tip}\n >\n > Use this function when you just need to *validate* that a string is\n > valid (URL-safe) base 64 data, without actually producing a decoded\n > output string. This function is both more performant and memory efficient\n > than using `url_decode64/2`, checking that the result is `{:ok, ...}`,\n > and then discarding the decoded binary.\n\n ## Options\n\n Accepts the same options as `url_decode64/2`.\n\n ## Examples\n\n iex> Base.url_valid64?(\"_3_-_A==\")\n true\n\n iex> Base.url_valid64?(\"_3_-_A==\\\\n\", ignore: :whitespace)\n true\n\n iex> Base.url_valid64?(\"_3_-_A\", padding: false)\n true\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec url_valid64?(binary, ignore: :whitespace, padding: boolean) :: boolean\n def url_valid64?(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n string |> remove_ignored(opts[:ignore]) |> validate64url?(pad?)\n end\n\n for {base, alphabet} <- [base: b64_alphabet, url: b64url_alphabet] do\n decode_name = :\"decode64#{base}!\"\n\n validate_name = :\"validate64#{base}?\"\n validate_main_name = :\"validate_main64#{validate_name}?\"\n valid_char_name = :\"valid_char64#{base}?\"\n {min, decoded} = alphabet |> Enum.with_index() |> to_decode_list.()\n\n defp unquote(validate_main_name)(<<>>), do: true\n\n defp unquote(validate_main_name)(\n <>\n ) do\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7) and\n unquote(valid_char_name)(c8) and\n unquote(validate_main_name)(rest)\n end\n\n defp unquote(validate_name)(<<>>, _pad?), do: true\n\n defp unquote(validate_name)(string, pad?) do\n segs = div(byte_size(string) + 7, 8) - 1\n <> = string\n main_valid? = unquote(validate_main_name)(main)\n\n case rest do\n _ when not main_valid? ->\n false\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7) and\n unquote(valid_char_name)(c8)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7)\n\n _ ->\n false\n end\n end\n\n @compile {:inline, [{valid_char_name, 1}]}\n defp unquote(valid_char_name)(char)\n when elem({unquote_splicing(decoded)}, char - unquote(min)) != nil,\n do: true\n\n defp unquote(valid_char_name)(_char), do: false\n\n defp unquote(decode_name)(char) do\n index = char - unquote(min)\n\n cond do\n index not in 0..unquote(length(decoded) - 1) -> bad_character!(char)\n new_char = elem({unquote_splicing(decoded)}, index) -> new_char\n true -> bad_character!(char)\n end\n end\n\n defp unquote(decode_name)(<<>>, _pad?), do: <<>>\n\n defp unquote(decode_name)(string, pad?) do\n segs = div(byte_size(string) + 7, 8) - 1\n <> = string\n\n main =\n for <>, into: <<>> do\n <<\n unquote(decode_name)(c1)::6,\n unquote(decode_name)(c2)::6,\n unquote(decode_name)(c3)::6,\n unquote(decode_name)(c4)::6,\n unquote(decode_name)(c5)::6,\n unquote(decode_name)(c6)::6,\n unquote(decode_name)(c7)::6,\n unquote(decode_name)(c8)::6\n >>\n end\n\n case rest do\n <> ->\n <>\n\n <> ->\n <>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::6,\n unquote(decode_name)(c2)::6,\n unquote(decode_name)(c3)::6,\n unquote(decode_name)(c4)::6\n >>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::6,\n unquote(decode_name)(c2)::6,\n unquote(decode_name)(c3)::6,\n unquote(decode_name)(c4)::6,\n unquote(decode_name)(c5)::6,\n bsr(unquote(decode_name)(c6), 4)::2\n >>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::6,\n unquote(decode_name)(c2)::6,\n unquote(decode_name)(c3)::6,\n unquote(decode_name)(c4)::6,\n unquote(decode_name)(c5)::6,\n unquote(decode_name)(c6)::6,\n bsr(unquote(decode_name)(c7), 2)::4\n >>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::6,\n unquote(decode_name)(c2)::6,\n unquote(decode_name)(c3)::6,\n unquote(decode_name)(c4)::6,\n unquote(decode_name)(c5)::6,\n unquote(decode_name)(c6)::6,\n unquote(decode_name)(c7)::6,\n unquote(decode_name)(c8)::6\n >>\n\n <> when not pad? ->\n <>\n\n <> when not pad? ->\n <>\n\n <> when not pad? ->\n <<\n main::bits,\n unquote(decode_name)(c1)::6,\n unquote(decode_name)(c2)::6,\n unquote(decode_name)(c3)::6,\n unquote(decode_name)(c4)::6,\n unquote(decode_name)(c5)::6,\n bsr(unquote(decode_name)(c6), 4)::2\n >>\n\n <> when not pad? ->\n <<\n main::bits,\n unquote(decode_name)(c1)::6,\n unquote(decode_name)(c2)::6,\n unquote(decode_name)(c3)::6,\n unquote(decode_name)(c4)::6,\n unquote(decode_name)(c5)::6,\n unquote(decode_name)(c6)::6,\n bsr(unquote(decode_name)(c7), 2)::4\n >>\n\n _ ->\n raise ArgumentError, \"incorrect padding\"\n end\n end\n end\n\n @doc \"\"\"\n Encodes a binary string into a base 32 encoded string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to use when encoding\n * `:padding` - specifies whether to apply padding\n\n The values for `:case` can be:\n\n * `:upper` - uses upper case characters (default)\n * `:lower` - uses lower case characters\n\n The values for `:padding` can be:\n\n * `true` - pad the output string to the nearest multiple of 8 (default)\n * `false` - omit padding from the output string\n\n ## Examples\n\n iex> Base.encode32(\"foobar\")\n \"MZXW6YTBOI======\"\n\n iex> Base.encode32(\"foobar\", case: :lower)\n \"mzxw6ytboi======\"\n\n iex> Base.encode32(\"foobar\", padding: false)\n \"MZXW6YTBOI\"\n\n \"\"\"\n @spec encode32(binary, case: encode_case, padding: boolean) :: binary\n def encode32(data, opts \\\\ []) when is_binary(data) do\n pad? = Keyword.get(opts, :padding, true)\n\n case Keyword.get(opts, :case, :upper) do\n :upper -> encode32upper(data, \"\", pad?)\n :lower -> encode32lower(data, \"\", pad?)\n end\n end\n\n @doc \"\"\"\n Encodes a binary string into a base 32 encoded string with an\n extended hexadecimal alphabet.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to use when encoding\n * `:padding` - specifies whether to apply padding\n\n The values for `:case` can be:\n\n * `:upper` - uses upper case characters (default)\n * `:lower` - uses lower case characters\n\n The values for `:padding` can be:\n\n * `true` - pad the output string to the nearest multiple of 8 (default)\n * `false` - omit padding from the output string\n\n ## Examples\n\n iex> Base.hex_encode32(\"foobar\")\n \"CPNMUOJ1E8======\"\n\n iex> Base.hex_encode32(\"foobar\", case: :lower)\n \"cpnmuoj1e8======\"\n\n iex> Base.hex_encode32(\"foobar\", padding: false)\n \"CPNMUOJ1E8\"\n\n \"\"\"\n @spec hex_encode32(binary, case: encode_case, padding: boolean) :: binary\n def hex_encode32(data, opts \\\\ []) when is_binary(data) do\n pad? = Keyword.get(opts, :padding, true)\n\n case Keyword.get(opts, :case, :upper) do\n :upper -> encode32hexupper(data, \"\", pad?)\n :lower -> encode32hexlower(data, \"\", pad?)\n end\n end\n\n for {base, alphabet} <- [\n upper: b32_alphabet,\n lower: to_lower_enc.(b32_alphabet),\n hexupper: b32hex_alphabet,\n hexlower: to_lower_enc.(b32hex_alphabet)\n ] do\n name = :\"encode32#{base}\"\n encoded = to_encode_list.(alphabet)\n\n @compile {:inline, [{name, 1}]}\n defp unquote(name)(byte) do\n elem({unquote_splicing(encoded)}, byte)\n end\n\n defp unquote(name)(<>, acc, pad?) do\n unquote(name)(\n rest,\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n unquote(name)(c3)::16,\n unquote(name)(c4)::16\n >>,\n pad?\n )\n end\n\n defp unquote(name)(<>, acc, pad?) do\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n unquote(name)(c3)::16,\n c4 |> bsl(3) |> unquote(name)() |> band(0x00FF)::8\n >>\n |> maybe_pad(pad?, 1)\n end\n\n defp unquote(name)(<>, acc, pad?) do\n <<\n acc::binary,\n unquote(name)(c1)::16,\n unquote(name)(c2)::16,\n c3 |> bsl(1) |> unquote(name)() |> band(0x00FF)::8\n >>\n |> maybe_pad(pad?, 3)\n end\n\n defp unquote(name)(<>, acc, pad?) do\n <<\n acc::binary,\n unquote(name)(c1)::16,\n c2 |> bsl(4) |> unquote(name)()::16\n >>\n |> maybe_pad(pad?, 4)\n end\n\n defp unquote(name)(<>, acc, pad?) do\n < bsl(2) |> unquote(name)()::16>>\n |> maybe_pad(pad?, 6)\n end\n\n defp unquote(name)(<<>>, acc, _pad?) do\n acc\n end\n end\n\n @doc \"\"\"\n Decodes a base 32 encoded string into a binary string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to accept when decoding\n * `:padding` - specifies whether to require padding\n\n The values for `:case` can be:\n\n * `:upper` - only allows upper case characters (default)\n * `:lower` - only allows lower case characters\n * `:mixed` - allows mixed case characters\n\n The values for `:padding` can be:\n\n * `true` - requires the input string to be padded to the nearest multiple of 8 (default)\n * `false` - ignores padding from the input string\n\n ## Examples\n\n iex> Base.decode32(\"MZXW6YTBOI======\")\n {:ok, \"foobar\"}\n\n iex> Base.decode32(\"mzxw6ytboi======\", case: :lower)\n {:ok, \"foobar\"}\n\n iex> Base.decode32(\"mzXW6ytBOi======\", case: :mixed)\n {:ok, \"foobar\"}\n\n iex> Base.decode32(\"MZXW6YTBOI\", padding: false)\n {:ok, \"foobar\"}\n\n \"\"\"\n @spec decode32(binary, case: decode_case, padding: boolean) :: {:ok, binary} | :error\n def decode32(string, opts \\\\ []) do\n {:ok, decode32!(string, opts)}\n rescue\n ArgumentError -> :error\n end\n\n @doc \"\"\"\n Decodes a base 32 encoded string into a binary string.\n\n An `ArgumentError` exception is raised if the padding is incorrect or\n a non-alphabet character is present in the string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to accept when decoding\n * `:padding` - specifies whether to require padding\n\n The values for `:case` can be:\n\n * `:upper` - only allows upper case characters (default)\n * `:lower` - only allows lower case characters\n * `:mixed` - allows mixed case characters\n\n The values for `:padding` can be:\n\n * `true` - requires the input string to be padded to the nearest multiple of 8 (default)\n * `false` - ignores padding from the input string\n\n ## Examples\n\n iex> Base.decode32!(\"MZXW6YTBOI======\")\n \"foobar\"\n\n iex> Base.decode32!(\"mzxw6ytboi======\", case: :lower)\n \"foobar\"\n\n iex> Base.decode32!(\"mzXW6ytBOi======\", case: :mixed)\n \"foobar\"\n\n iex> Base.decode32!(\"MZXW6YTBOI\", padding: false)\n \"foobar\"\n\n \"\"\"\n @spec decode32!(binary, case: decode_case, padding: boolean) :: binary\n def decode32!(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n\n case Keyword.get(opts, :case, :upper) do\n :upper -> decode32upper!(string, pad?)\n :lower -> decode32lower!(string, pad?)\n :mixed -> decode32mixed!(string, pad?)\n end\n end\n\n @doc \"\"\"\n Checks if a base 32 encoded string is valid.\n\n > #### When to use this {: .tip}\n >\n > Use this function when you just need to *validate* that a string is\n > valid base 32 data, without actually producing a decoded output string.\n > This function is both more performant and memory efficient than using\n > `decode32/2`, checking that the result is `{:ok, ...}`, and then\n > discarding the decoded binary.\n\n ## Options\n\n Accepts the same options as `decode32/2`.\n\n ## Examples\n\n iex> Base.valid32?(\"MZXW6YTBOI======\")\n true\n\n iex> Base.valid32?(\"mzxw6ytboi======\", case: :lower)\n true\n\n iex> Base.valid32?(\"zzz\")\n false\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec valid32?(binary, case: decode_case, padding: boolean) :: boolean()\n def valid32?(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n\n case Keyword.get(opts, :case, :upper) do\n :upper -> validate32upper?(string, pad?)\n :lower -> validate32lower?(string, pad?)\n :mixed -> validate32mixed?(string, pad?)\n end\n end\n\n @doc \"\"\"\n Decodes a base 32 encoded string with extended hexadecimal alphabet\n into a binary string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to accept when decoding\n * `:padding` - specifies whether to require padding\n\n The values for `:case` can be:\n\n * `:upper` - only allows upper case characters (default)\n * `:lower` - only allows lower case characters\n * `:mixed` - allows mixed case characters\n\n The values for `:padding` can be:\n\n * `true` - requires the input string to be padded to the nearest multiple of 8 (default)\n * `false` - ignores padding from the input string\n\n ## Examples\n\n iex> Base.hex_decode32(\"CPNMUOJ1E8======\")\n {:ok, \"foobar\"}\n\n iex> Base.hex_decode32(\"cpnmuoj1e8======\", case: :lower)\n {:ok, \"foobar\"}\n\n iex> Base.hex_decode32(\"cpnMuOJ1E8======\", case: :mixed)\n {:ok, \"foobar\"}\n\n iex> Base.hex_decode32(\"CPNMUOJ1E8\", padding: false)\n {:ok, \"foobar\"}\n\n \"\"\"\n @spec hex_decode32(binary, case: decode_case, padding: boolean) :: {:ok, binary} | :error\n def hex_decode32(string, opts \\\\ []) do\n {:ok, hex_decode32!(string, opts)}\n rescue\n ArgumentError -> :error\n end\n\n @doc \"\"\"\n Decodes a base 32 encoded string with extended hexadecimal alphabet\n into a binary string.\n\n An `ArgumentError` exception is raised if the padding is incorrect or\n a non-alphabet character is present in the string.\n\n ## Options\n\n The accepted options are:\n\n * `:case` - specifies the character case to accept when decoding\n * `:padding` - specifies whether to require padding\n\n The values for `:case` can be:\n\n * `:upper` - only allows upper case characters (default)\n * `:lower` - only allows lower case characters\n * `:mixed` - allows mixed case characters\n\n The values for `:padding` can be:\n\n * `true` - requires the input string to be padded to the nearest multiple of 8 (default)\n * `false` - ignores padding from the input string\n\n ## Examples\n\n iex> Base.hex_decode32!(\"CPNMUOJ1E8======\")\n \"foobar\"\n\n iex> Base.hex_decode32!(\"cpnmuoj1e8======\", case: :lower)\n \"foobar\"\n\n iex> Base.hex_decode32!(\"cpnMuOJ1E8======\", case: :mixed)\n \"foobar\"\n\n iex> Base.hex_decode32!(\"CPNMUOJ1E8\", padding: false)\n \"foobar\"\n\n \"\"\"\n @spec hex_decode32!(binary, case: decode_case, padding: boolean) :: binary\n def hex_decode32!(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n\n case Keyword.get(opts, :case, :upper) do\n :upper -> decode32hexupper!(string, pad?)\n :lower -> decode32hexlower!(string, pad?)\n :mixed -> decode32hexmixed!(string, pad?)\n end\n end\n\n @doc \"\"\"\n Checks if a base 32 encoded string with extended hexadecimal alphabet is valid.\n\n > #### When to use this {: .tip}\n >\n > Use this function when you just need to *validate* that a string is\n > valid (extended hexadecimal) base 32 data, without actually producing\n > a decoded output string. This function is both more performant and\n > memory efficient than using `hex_decode32/2`, checking that the result\n > is `{:ok, ...}`, and then discarding the decoded binary.\n\n ## Options\n\n Accepts the same options as `hex_decode32/2`.\n\n ## Examples\n\n iex> Base.hex_valid32?(\"CPNMUOJ1E8======\")\n true\n\n iex> Base.hex_valid32?(\"cpnmuoj1e8======\", case: :lower)\n true\n\n iex> Base.hex_valid32?(\"zzz\", padding: false)\n false\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec hex_valid32?(binary, case: decode_case, padding: boolean) :: boolean\n def hex_valid32?(string, opts \\\\ []) when is_binary(string) do\n pad? = Keyword.get(opts, :padding, true)\n\n case Keyword.get(opts, :case, :upper) do\n :upper -> validate32hexupper?(string, pad?)\n :lower -> validate32hexlower?(string, pad?)\n :mixed -> validate32hexmixed?(string, pad?)\n end\n end\n\n upper = Enum.with_index(b32_alphabet)\n hexupper = Enum.with_index(b32hex_alphabet)\n\n for {base, alphabet} <- [\n upper: upper,\n lower: to_lower_dec.(upper),\n mixed: to_mixed_dec.(upper),\n hexupper: hexupper,\n hexlower: to_lower_dec.(hexupper),\n hexmixed: to_mixed_dec.(hexupper)\n ] do\n decode_name = :\"decode32#{base}!\"\n validate_name = :\"validate32#{base}?\"\n validate_main_name = :\"validate_main32#{validate_name}?\"\n valid_char_name = :\"valid_char32#{base}?\"\n {min, decoded} = to_decode_list.(alphabet)\n\n defp unquote(validate_main_name)(<<>>), do: true\n\n defp unquote(validate_main_name)(\n <>\n ) do\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7) and\n unquote(valid_char_name)(c8) and\n unquote(validate_main_name)(rest)\n end\n\n defp unquote(validate_name)(<<>>, _pad?), do: true\n\n defp unquote(validate_name)(string, pad?) do\n segs = div(byte_size(string) + 7, 8) - 1\n <> = string\n main_valid? = unquote(validate_main_name)(main)\n\n case rest do\n _ when not main_valid? ->\n false\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7)\n\n <> ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7) and\n unquote(valid_char_name)(c8)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5)\n\n <> when not pad? ->\n unquote(valid_char_name)(c1) and\n unquote(valid_char_name)(c2) and\n unquote(valid_char_name)(c3) and\n unquote(valid_char_name)(c4) and\n unquote(valid_char_name)(c5) and\n unquote(valid_char_name)(c6) and\n unquote(valid_char_name)(c7)\n\n _ ->\n false\n end\n end\n\n @compile {:inline, [{valid_char_name, 1}]}\n defp unquote(valid_char_name)(char)\n when elem({unquote_splicing(decoded)}, char - unquote(min)) != nil,\n do: true\n\n defp unquote(valid_char_name)(_char), do: false\n\n defp unquote(decode_name)(char) do\n index = char - unquote(min)\n\n cond do\n index not in 0..unquote(length(decoded) - 1) -> bad_character!(char)\n new_char = elem({unquote_splicing(decoded)}, index) -> new_char\n true -> bad_character!(char)\n end\n end\n\n defp unquote(decode_name)(<<>>, _), do: <<>>\n\n defp unquote(decode_name)(string, pad?) do\n segs = div(byte_size(string) + 7, 8) - 1\n <> = string\n\n main =\n for <>, into: <<>> do\n <<\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n unquote(decode_name)(c4)::5,\n unquote(decode_name)(c5)::5,\n unquote(decode_name)(c6)::5,\n unquote(decode_name)(c7)::5,\n unquote(decode_name)(c8)::5\n >>\n end\n\n case rest do\n <> ->\n <>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n bsr(unquote(decode_name)(c4), 4)::1\n >>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n unquote(decode_name)(c4)::5,\n bsr(unquote(decode_name)(c5), 1)::4\n >>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n unquote(decode_name)(c4)::5,\n unquote(decode_name)(c5)::5,\n unquote(decode_name)(c6)::5,\n bsr(unquote(decode_name)(c7), 3)::2\n >>\n\n <> ->\n <<\n main::bits,\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n unquote(decode_name)(c4)::5,\n unquote(decode_name)(c5)::5,\n unquote(decode_name)(c6)::5,\n unquote(decode_name)(c7)::5,\n unquote(decode_name)(c8)::5\n >>\n\n <> when not pad? ->\n <>\n\n <> when not pad? ->\n <<\n main::bits,\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n bsr(unquote(decode_name)(c4), 4)::1\n >>\n\n <> when not pad? ->\n <<\n main::bits,\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n unquote(decode_name)(c4)::5,\n bsr(unquote(decode_name)(c5), 1)::4\n >>\n\n <> when not pad? ->\n <<\n main::bits,\n unquote(decode_name)(c1)::5,\n unquote(decode_name)(c2)::5,\n unquote(decode_name)(c3)::5,\n unquote(decode_name)(c4)::5,\n unquote(decode_name)(c5)::5,\n unquote(decode_name)(c6)::5,\n bsr(unquote(decode_name)(c7), 3)::2\n >>\n\n _ ->\n raise ArgumentError, \"incorrect padding\"\n end\n end\n end\nend\n" }, { "path": "lib/elixir/lib/behaviour.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Behaviour do\n @moduledoc \"\"\"\n Mechanism for handling behaviours.\n\n This module is deprecated. Instead of `defcallback/1` and\n `defmacrocallback/1`, the `@callback` and `@macrocallback`\n module attributes can be used respectively. See the\n documentation for `Module` for more information on these\n attributes.\n\n Instead of `MyModule.__behaviour__(:callbacks)`,\n `MyModule.behaviour_info(:callbacks)` can be used. `behaviour_info/1`\n is documented in `Module`.\n \"\"\"\n\n @moduledoc deprecated: \"Use @callback and @macrocallback attributes instead\"\n\n @doc \"\"\"\n Defines a function callback according to the given type specification.\n \"\"\"\n @deprecated \"Use the @callback module attribute instead\"\n defmacro defcallback(spec) do\n do_defcallback(:def, split_spec(spec, quote(do: term)))\n end\n\n @doc \"\"\"\n Defines a macro callback according to the given type specification.\n \"\"\"\n @deprecated \"Use the @macrocallback module attribute instead\"\n defmacro defmacrocallback(spec) do\n do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t())))\n end\n\n defp split_spec({:when, _, [{:\"::\", _, [spec, return]}, guard]}, _default) do\n {spec, return, guard}\n end\n\n defp split_spec({:when, _, [spec, guard]}, default) do\n {spec, default, guard}\n end\n\n defp split_spec({:\"::\", _, [spec, return]}, _default) do\n {spec, return, []}\n end\n\n defp split_spec(spec, default) do\n {spec, default, []}\n end\n\n defp do_defcallback(kind, {spec, return, guards}) do\n case Macro.decompose_call(spec) do\n {name, args} ->\n do_callback(kind, name, args, return, guards)\n\n _ ->\n raise ArgumentError, \"invalid syntax in #{kind}callback #{Macro.to_string(spec)}\"\n end\n end\n\n defp do_callback(kind, name, args, return, guards) do\n fun = fn\n {:\"::\", _, [left, right]} ->\n ensure_not_default(left)\n ensure_not_default(right)\n left\n\n other ->\n ensure_not_default(other)\n other\n end\n\n :lists.foreach(fun, args)\n\n spec =\n quote do\n unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)\n end\n\n case kind do\n :def -> quote(do: @callback(unquote(spec)))\n :defmacro -> quote(do: @macrocallback(unquote(spec)))\n end\n end\n\n defp ensure_not_default({:\\\\, _, [_, _]}) do\n raise ArgumentError, \"default arguments \\\\\\\\ not supported in defcallback/defmacrocallback\"\n end\n\n defp ensure_not_default(_), do: :ok\n\n @doc false\n defmacro __using__(_) do\n quote do\n warning =\n \"the Behaviour module is deprecated. Instead of using this module, \" <>\n \"use the @callback and @macrocallback module attributes. See the \" <>\n \"documentation for Module for more information on these attributes\"\n\n IO.warn(warning)\n\n @doc false\n def __behaviour__(:callbacks) do\n __MODULE__.behaviour_info(:callbacks)\n end\n\n def __behaviour__(:docs) do\n {:docs_v1, _, :elixir, _, _, _, docs} = Code.fetch_docs(__MODULE__)\n\n for {{kind, name, arity}, line, _, doc, _} <- docs, kind in [:callback, :macrocallback] do\n case kind do\n :callback -> {{name, arity}, line, :def, __behaviour__doc_value(doc)}\n :macrocallback -> {{name, arity}, line, :defmacro, __behaviour__doc_value(doc)}\n end\n end\n end\n\n defp __behaviour__doc_value(%{\"en\" => doc}), do: doc\n defp __behaviour__doc_value(:hidden), do: false\n defp __behaviour__doc_value(_), do: nil\n\n import unquote(__MODULE__)\n end\n end\nend\n" }, { "path": "lib/elixir/lib/bitwise.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Bitwise do\n @moduledoc \"\"\"\n A set of functions that perform calculations on bits.\n\n All bitwise functions work only on integers, otherwise an\n `ArithmeticError` is raised. The functions `band/2`,\n `bor/2`, `bsl/2`, and `bsr/2` also have operators,\n respectively: `&&&/2`, `|||/2`, `<<>>/2`.\n\n ## Guards\n\n All bitwise functions can be used in guards:\n\n iex> odd? = fn\n ...> int when Bitwise.band(int, 1) == 1 -> true\n ...> _ -> false\n ...> end\n iex> odd?.(1)\n true\n\n All functions in this module are inlined by the compiler.\n \"\"\"\n\n @doc false\n @deprecated \"import Bitwise instead\"\n defmacro __using__(options) do\n except =\n cond do\n Keyword.get(options, :only_operators) ->\n [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]\n\n Keyword.get(options, :skip_operators) ->\n [\"~~~\": 1, &&&: 2, |||: 2, \"^^^\": 2, <<<: 2, >>>: 2]\n\n true ->\n []\n end\n\n quote do\n import Bitwise, except: unquote(except)\n end\n end\n\n @doc \"\"\"\n Calculates the bitwise NOT of the argument.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> bnot(2)\n -3\n\n iex> bnot(2) &&& 3\n 1\n\n \"\"\"\n @doc guard: true\n @spec bnot(integer) :: integer\n def bnot(expr) do\n :erlang.bnot(expr)\n end\n\n @doc false\n def unquote(:\"~~~\")(expr) do\n :erlang.bnot(expr)\n end\n\n @doc \"\"\"\n Calculates the bitwise AND of its arguments.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> band(9, 3)\n 1\n\n \"\"\"\n @doc guard: true\n @spec band(integer, integer) :: integer\n def band(left, right) do\n :erlang.band(left, right)\n end\n\n @doc \"\"\"\n Bitwise AND operator.\n\n Calculates the bitwise AND of its arguments.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> 9 &&& 3\n 1\n\n \"\"\"\n @doc guard: true\n @spec integer &&& integer :: integer\n def left &&& right do\n :erlang.band(left, right)\n end\n\n @doc \"\"\"\n Calculates the bitwise OR of its arguments.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> bor(9, 3)\n 11\n\n \"\"\"\n @doc guard: true\n @spec bor(integer, integer) :: integer\n def bor(left, right) do\n :erlang.bor(left, right)\n end\n\n @doc \"\"\"\n Bitwise OR operator.\n\n Calculates the bitwise OR of its arguments.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> 9 ||| 3\n 11\n\n \"\"\"\n @doc guard: true\n @spec integer ||| integer :: integer\n def left ||| right do\n :erlang.bor(left, right)\n end\n\n @doc \"\"\"\n Calculates the bitwise XOR of its arguments.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> bxor(9, 3)\n 10\n\n \"\"\"\n @doc guard: true\n @spec bxor(integer, integer) :: integer\n def bxor(left, right) do\n :erlang.bxor(left, right)\n end\n\n @doc false\n def unquote(:\"^^^\")(left, right) do\n :erlang.bxor(left, right)\n end\n\n @doc \"\"\"\n Calculates the result of an arithmetic left bitshift.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> bsl(1, 2)\n 4\n\n iex> bsl(1, -2)\n 0\n\n iex> bsl(-1, 2)\n -4\n\n iex> bsl(-1, -2)\n -1\n\n \"\"\"\n @doc guard: true\n @spec bsl(integer, integer) :: integer\n def bsl(left, right) do\n :erlang.bsl(left, right)\n end\n\n @doc \"\"\"\n Arithmetic left bitshift operator.\n\n Calculates the result of an arithmetic left bitshift.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> 1 <<< 2\n 4\n\n iex> 1 <<< -2\n 0\n\n iex> -1 <<< 2\n -4\n\n iex> -1 <<< -2\n -1\n\n \"\"\"\n @doc guard: true\n @spec integer <<< integer :: integer\n def left <<< right do\n :erlang.bsl(left, right)\n end\n\n @doc \"\"\"\n Calculates the result of an arithmetic right bitshift.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> bsr(1, 2)\n 0\n\n iex> bsr(1, -2)\n 4\n\n iex> bsr(-1, 2)\n -1\n\n iex> bsr(-1, -2)\n -4\n\n \"\"\"\n @doc guard: true\n @spec bsr(integer, integer) :: integer\n def bsr(left, right) do\n :erlang.bsr(left, right)\n end\n\n @doc \"\"\"\n Arithmetic right bitshift operator.\n\n Calculates the result of an arithmetic right bitshift.\n\n Allowed in guard tests. Inlined by the compiler.\n\n ## Examples\n\n iex> 1 >>> 2\n 0\n\n iex> 1 >>> -2\n 4\n\n iex> -1 >>> 2\n -1\n\n iex> -1 >>> -2\n -4\n\n \"\"\"\n @doc guard: true\n @spec integer >>> integer :: integer\n def left >>> right do\n :erlang.bsr(left, right)\n end\nend\n" }, { "path": "lib/elixir/lib/calendar/date.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Date do\n @moduledoc \"\"\"\n A Date struct and functions.\n\n The Date struct contains the fields year, month, day and calendar.\n New dates can be built with the `new/3` function or using the\n `~D` (see `sigil_D/2`) sigil:\n\n iex> ~D[2000-01-01]\n ~D[2000-01-01]\n\n Both `new/3` and sigil return a struct where the date fields can\n be accessed directly:\n\n iex> date = ~D[2000-01-01]\n iex> date.year\n 2000\n iex> date.month\n 1\n\n The functions on this module work with the `Date` struct as well\n as any struct that contains the same fields as the `Date` struct,\n such as `NaiveDateTime` and `DateTime`. Such functions expect\n `t:Calendar.date/0` in their typespecs (instead of `t:t/0`).\n\n Developers should avoid creating the Date structs directly\n and instead rely on the functions provided by this module as well\n as the ones in third-party calendar libraries.\n\n ## Comparing dates\n\n Comparisons in Elixir using `==/2`, `>/2`, ` Enum.min([~D[2017-03-31], ~D[2017-04-01]], Date)\n ~D[2017-03-31]\n\n ## Using epochs\n\n The `add/2`, `diff/2` and `shift/2` functions can be used for computing dates\n or retrieving the number of days between instants. For example, if there\n is an interest in computing the number of days from the Unix epoch\n (1970-01-01):\n\n iex> Date.diff(~D[2010-04-17], ~D[1970-01-01])\n 14716\n\n iex> Date.add(~D[1970-01-01], 14_716)\n ~D[2010-04-17]\n\n iex> Date.shift(~D[1970-01-01], year: 40, month: 3, week: 2, day: 2)\n ~D[2010-04-17]\n\n Those functions are optimized to deal with common epochs, such\n as the Unix Epoch above or the Gregorian Epoch (0000-01-01).\n \"\"\"\n\n @enforce_keys [:year, :month, :day]\n defstruct [:year, :month, :day, calendar: Calendar.ISO]\n\n @type t :: %__MODULE__{\n year: Calendar.year(),\n month: Calendar.month(),\n day: Calendar.day(),\n calendar: Calendar.calendar()\n }\n\n @doc \"\"\"\n Returns a range of dates.\n\n A range of dates represents a discrete number of dates where\n the first and last values are dates with matching calendars.\n\n Ranges of dates can be increasing (`first <= last`) and are\n always inclusive. For a decreasing range, use `range/3` with\n a step of -1 as first argument.\n\n ## Examples\n\n iex> Date.range(~D[1999-01-01], ~D[2000-01-01])\n Date.range(~D[1999-01-01], ~D[2000-01-01])\n\n A range of dates implements the `Enumerable` protocol, which means\n functions in the `Enum` module can be used to work with\n ranges:\n\n iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01])\n iex> range\n Date.range(~D[2001-01-01], ~D[2002-01-01])\n iex> Enum.count(range)\n 366\n iex> ~D[2001-02-01] in range\n true\n iex> Enum.take(range, 3)\n [~D[2001-01-01], ~D[2001-01-02], ~D[2001-01-03]]\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec range(Calendar.date(), Calendar.date()) :: Date.Range.t()\n def range(%{calendar: calendar} = first, %{calendar: calendar} = last) do\n {first_days, _} = to_iso_days(first)\n {last_days, _} = to_iso_days(last)\n\n step =\n if first_days <= last_days do\n 1\n else\n IO.warn(\n \"a negative range was inferred for Date.range/2, call Date.range/3 instead with -1 as third argument\"\n )\n\n -1\n end\n\n range(first, first_days, last, last_days, calendar, step)\n end\n\n def range(%{calendar: _, year: _, month: _, day: _}, %{calendar: _, year: _, month: _, day: _}) do\n raise ArgumentError, \"both dates must have matching calendars\"\n end\n\n @doc \"\"\"\n Returns a range of dates with a step.\n\n ## Examples\n\n iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01], 2)\n iex> range\n Date.range(~D[2001-01-01], ~D[2002-01-01], 2)\n iex> Enum.count(range)\n 183\n iex> ~D[2001-01-03] in range\n true\n iex> Enum.take(range, 3)\n [~D[2001-01-01], ~D[2001-01-03], ~D[2001-01-05]]\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec range(Calendar.date(), Calendar.date(), step :: pos_integer | neg_integer) ::\n Date.Range.t()\n def range(%{calendar: calendar} = first, %{calendar: calendar} = last, step)\n when is_integer(step) and step != 0 do\n {first_days, _} = to_iso_days(first)\n {last_days, _} = to_iso_days(last)\n range(first, first_days, last, last_days, calendar, step)\n end\n\n def range(\n %{calendar: _, year: _, month: _, day: _} = first,\n %{calendar: _, year: _, month: _, day: _} = last,\n step\n ) do\n raise ArgumentError,\n \"both dates must have matching calendar and the step must be a \" <>\n \"non-zero integer, got: #{inspect(first)}, #{inspect(last)}, #{step}\"\n end\n\n defp range(first, first_days, last, last_days, calendar, step) do\n %Date.Range{\n first: %Date{calendar: calendar, year: first.year, month: first.month, day: first.day},\n last: %Date{calendar: calendar, year: last.year, month: last.month, day: last.day},\n first_in_iso_days: first_days,\n last_in_iso_days: last_days,\n step: step\n }\n end\n\n @doc \"\"\"\n Returns the current date in UTC.\n\n ## Examples\n\n iex> date = Date.utc_today()\n iex> date.year >= 2016\n true\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec utc_today(Calendar.calendar()) :: t\n def utc_today(calendar \\\\ Calendar.ISO)\n\n def utc_today(Calendar.ISO) do\n {:ok, {year, month, day}, _, _} = Calendar.ISO.from_unix(System.os_time(), :native)\n %Date{year: year, month: month, day: day}\n end\n\n def utc_today(calendar) do\n %{year: year, month: month, day: day} = DateTime.utc_now(calendar)\n %Date{year: year, month: month, day: day, calendar: calendar}\n end\n\n @doc \"\"\"\n Returns `true` if the year in the given `date` is a leap year.\n\n ## Examples\n\n iex> Date.leap_year?(~D[2000-01-01])\n true\n iex> Date.leap_year?(~D[2001-01-01])\n false\n iex> Date.leap_year?(~D[2004-01-01])\n true\n iex> Date.leap_year?(~D[1900-01-01])\n false\n iex> Date.leap_year?(~N[2004-01-01 01:23:45])\n true\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec leap_year?(Calendar.date()) :: boolean()\n def leap_year?(date)\n\n def leap_year?(%{calendar: calendar, year: year}) do\n calendar.leap_year?(year)\n end\n\n @doc \"\"\"\n Returns the number of days in the given `date` month.\n\n ## Examples\n\n iex> Date.days_in_month(~D[1900-01-13])\n 31\n iex> Date.days_in_month(~D[1900-02-09])\n 28\n iex> Date.days_in_month(~N[2000-02-20 01:23:45])\n 29\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec days_in_month(Calendar.date()) :: Calendar.day()\n def days_in_month(date)\n\n def days_in_month(%{calendar: calendar, year: year, month: month}) do\n calendar.days_in_month(year, month)\n end\n\n @doc \"\"\"\n Returns the number of months in the given `date` year.\n\n ## Example\n\n iex> Date.months_in_year(~D[1900-01-13])\n 12\n\n \"\"\"\n @doc since: \"1.7.0\"\n @spec months_in_year(Calendar.date()) :: Calendar.month()\n def months_in_year(date)\n\n def months_in_year(%{calendar: calendar, year: year}) do\n calendar.months_in_year(year)\n end\n\n @doc \"\"\"\n Builds a new ISO date.\n\n Expects all values to be integers. Returns `{:ok, date}` if each\n entry fits its appropriate range, returns `{:error, reason}` otherwise.\n\n ## Examples\n\n iex> Date.new(2000, 1, 1)\n {:ok, ~D[2000-01-01]}\n iex> Date.new(2000, 13, 1)\n {:error, :invalid_date}\n iex> Date.new(2000, 2, 29)\n {:ok, ~D[2000-02-29]}\n\n iex> Date.new(2000, 2, 30)\n {:error, :invalid_date}\n iex> Date.new(2001, 2, 29)\n {:error, :invalid_date}\n\n \"\"\"\n @spec new(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) ::\n {:ok, t} | {:error, atom}\n def new(year, month, day, calendar \\\\ Calendar.ISO) do\n if calendar.valid_date?(year, month, day) do\n {:ok, %Date{year: year, month: month, day: day, calendar: calendar}}\n else\n {:error, :invalid_date}\n end\n end\n\n @doc \"\"\"\n Builds a new ISO date.\n\n Expects all values to be integers. Returns `date` if each\n entry fits its appropriate range, raises if the date is invalid.\n\n ## Examples\n\n iex> Date.new!(2000, 1, 1)\n ~D[2000-01-01]\n iex> Date.new!(2000, 13, 1)\n ** (ArgumentError) cannot build date, reason: :invalid_date\n iex> Date.new!(2000, 2, 29)\n ~D[2000-02-29]\n \"\"\"\n @doc since: \"1.11.0\"\n @spec new!(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) :: t\n def new!(year, month, day, calendar \\\\ Calendar.ISO) do\n case new(year, month, day, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError, \"cannot build date, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts the given date to a string according to its calendar.\n\n ## Examples\n\n iex> Date.to_string(~D[2000-02-28])\n \"2000-02-28\"\n iex> Date.to_string(~N[2000-02-28 01:23:45])\n \"2000-02-28\"\n iex> Date.to_string(~D[-0100-12-15])\n \"-0100-12-15\"\n\n \"\"\"\n @spec to_string(Calendar.date()) :: String.t()\n def to_string(date)\n\n def to_string(%{calendar: calendar, year: year, month: month, day: day}) do\n calendar.date_to_string(year, month, day)\n end\n\n @doc \"\"\"\n Parses the extended \"Dates\" format described by\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n The year parsed by this function is limited to four digits.\n\n ## Examples\n\n iex> Date.from_iso8601(\"2015-01-23\")\n {:ok, ~D[2015-01-23]}\n\n iex> Date.from_iso8601(\"2015:01:23\")\n {:error, :invalid_format}\n\n iex> Date.from_iso8601(\"2015-01-32\")\n {:error, :invalid_date}\n\n \"\"\"\n @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}\n def from_iso8601(string, calendar \\\\ Calendar.ISO) do\n with {:ok, {year, month, day}} <- Calendar.ISO.parse_date(string) do\n convert(%Date{year: year, month: month, day: day}, calendar)\n end\n end\n\n @doc \"\"\"\n Parses the extended \"Dates\" format described by\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n Raises if the format is invalid.\n\n ## Examples\n\n iex> Date.from_iso8601!(\"2015-01-23\")\n ~D[2015-01-23]\n iex> Date.from_iso8601!(\"2015:01:23\")\n ** (ArgumentError) cannot parse \"2015:01:23\" as date, reason: :invalid_format\n\n \"\"\"\n @spec from_iso8601!(String.t(), Calendar.calendar()) :: t\n def from_iso8601!(string, calendar \\\\ Calendar.ISO) do\n case from_iso8601(string, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError, \"cannot parse #{inspect(string)} as date, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts the given `date` to\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n By default, `Date.to_iso8601/2` returns dates formatted in the \"extended\"\n format, for human readability. It also supports the \"basic\" format through passing the `:basic` option.\n\n Only supports converting dates which are in the ISO calendar,\n or other calendars in which the days also start at midnight.\n Attempting to convert dates from other calendars will raise an `ArgumentError`.\n\n ## Examples\n\n iex> Date.to_iso8601(~D[2000-02-28])\n \"2000-02-28\"\n\n iex> Date.to_iso8601(~D[2000-02-28], :basic)\n \"20000228\"\n\n iex> Date.to_iso8601(~N[2000-02-28 00:00:00])\n \"2000-02-28\"\n\n \"\"\"\n @spec to_iso8601(Calendar.date(), :extended | :basic) :: String.t()\n def to_iso8601(date, format \\\\ :extended)\n\n def to_iso8601(%{calendar: Calendar.ISO} = date, format) when format in [:basic, :extended] do\n %{year: year, month: month, day: day} = date\n Calendar.ISO.date_to_string(year, month, day, format)\n end\n\n def to_iso8601(%{calendar: _} = date, format) when format in [:basic, :extended] do\n date\n |> convert!(Calendar.ISO)\n |> to_iso8601()\n end\n\n @doc \"\"\"\n Converts the given `date` to an Erlang date tuple.\n\n Only supports converting dates which are in the ISO calendar,\n or other calendars in which the days also start at midnight.\n Attempting to convert dates from other calendars will raise.\n\n ## Examples\n\n iex> Date.to_erl(~D[2000-01-01])\n {2000, 1, 1}\n\n iex> Date.to_erl(~N[2000-01-01 00:00:00])\n {2000, 1, 1}\n\n \"\"\"\n @spec to_erl(Calendar.date()) :: :calendar.date()\n def to_erl(date) do\n %{year: year, month: month, day: day} = convert!(date, Calendar.ISO)\n {year, month, day}\n end\n\n @doc \"\"\"\n Converts an Erlang date tuple to a `Date` struct.\n\n Only supports converting dates which are in the ISO calendar,\n or other calendars in which the days also start at midnight.\n Attempting to convert dates from other calendars will return an error tuple.\n\n ## Examples\n\n iex> Date.from_erl({2000, 1, 1})\n {:ok, ~D[2000-01-01]}\n iex> Date.from_erl({2000, 13, 1})\n {:error, :invalid_date}\n\n \"\"\"\n @spec from_erl(:calendar.date(), Calendar.calendar()) :: {:ok, t} | {:error, atom}\n def from_erl(tuple, calendar \\\\ Calendar.ISO)\n\n def from_erl({year, month, day}, calendar) do\n with {:ok, date} <- new(year, month, day, Calendar.ISO), do: convert(date, calendar)\n end\n\n @doc \"\"\"\n Converts an Erlang date tuple but raises for invalid dates.\n\n ## Examples\n\n iex> Date.from_erl!({2000, 1, 1})\n ~D[2000-01-01]\n iex> Date.from_erl!({2000, 13, 1})\n ** (ArgumentError) cannot convert {2000, 13, 1} to date, reason: :invalid_date\n\n \"\"\"\n @spec from_erl!(:calendar.date(), Calendar.calendar()) :: t\n def from_erl!(tuple, calendar \\\\ Calendar.ISO) do\n case from_erl(tuple, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot convert #{inspect(tuple)} to date, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts a number of gregorian days to a `Date` struct.\n\n ## Examples\n\n iex> Date.from_gregorian_days(1)\n ~D[0000-01-02]\n iex> Date.from_gregorian_days(730_485)\n ~D[2000-01-01]\n iex> Date.from_gregorian_days(-1)\n ~D[-0001-12-31]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec from_gregorian_days(integer(), Calendar.calendar()) :: t\n def from_gregorian_days(days, calendar \\\\ Calendar.ISO) when is_integer(days) do\n from_iso_days({days, 0}, calendar)\n end\n\n @doc \"\"\"\n Converts a `date` struct to a number of gregorian days.\n\n ## Examples\n\n iex> Date.to_gregorian_days(~D[0000-01-02])\n 1\n iex> Date.to_gregorian_days(~D[2000-01-01])\n 730_485\n iex> Date.to_gregorian_days(~N[2000-01-01 00:00:00])\n 730_485\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec to_gregorian_days(Calendar.date()) :: integer()\n def to_gregorian_days(date) do\n {days, _} = to_iso_days(date)\n days\n end\n\n @doc \"\"\"\n Compares two date structs.\n\n Returns `:gt` if first date is later than the second\n and `:lt` for vice versa. If the two dates are equal\n `:eq` is returned.\n\n ## Examples\n\n iex> Date.compare(~D[2016-04-16], ~D[2016-04-28])\n :lt\n\n This function can also be used to compare across more\n complex calendar types by considering only the date fields:\n\n iex> Date.compare(~D[2016-04-16], ~N[2016-04-28 01:23:45])\n :lt\n iex> Date.compare(~D[2016-04-16], ~N[2016-04-16 01:23:45])\n :eq\n iex> Date.compare(~N[2016-04-16 12:34:56], ~N[2016-04-16 01:23:45])\n :eq\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec compare(Calendar.date(), Calendar.date()) :: :lt | :eq | :gt\n def compare(%{calendar: calendar} = date1, %{calendar: calendar} = date2) do\n %{year: year1, month: month1, day: day1} = date1\n %{year: year2, month: month2, day: day2} = date2\n\n case {{year1, month1, day1}, {year2, month2, day2}} do\n {first, second} when first > second -> :gt\n {first, second} when first < second -> :lt\n _ -> :eq\n end\n end\n\n def compare(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do\n if Calendar.compatible_calendars?(calendar1, calendar2) do\n case {to_iso_days(date1), to_iso_days(date2)} do\n {first, second} when first > second -> :gt\n {first, second} when first < second -> :lt\n _ -> :eq\n end\n else\n raise ArgumentError, \"\"\"\n cannot compare #{inspect(date1)} with #{inspect(date2)}.\n\n This comparison would be ambiguous as their calendars have incompatible day rollover moments.\n Specify an exact time of day (using DateTime) to resolve this ambiguity\n \"\"\"\n end\n end\n\n @doc \"\"\"\n Returns `true` if the first date is strictly earlier than the second.\n\n ## Examples\n\n iex> Date.before?(~D[2021-01-01], ~D[2022-02-02])\n true\n iex> Date.before?(~D[2021-01-01], ~D[2021-01-01])\n false\n iex> Date.before?(~D[2022-02-02], ~D[2021-01-01])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec before?(Calendar.date(), Calendar.date()) :: boolean()\n def before?(date1, date2) do\n compare(date1, date2) == :lt\n end\n\n @doc \"\"\"\n Returns `true` if the first date is strictly later than the second.\n\n ## Examples\n\n iex> Date.after?(~D[2022-02-02], ~D[2021-01-01])\n true\n iex> Date.after?(~D[2021-01-01], ~D[2021-01-01])\n false\n iex> Date.after?(~D[2021-01-01], ~D[2022-02-02])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec after?(Calendar.date(), Calendar.date()) :: boolean()\n def after?(date1, date2) do\n compare(date1, date2) == :gt\n end\n\n @doc \"\"\"\n Converts the given `date` from its calendar to the given `calendar`.\n\n Returns `{:ok, date}` if the calendars are compatible,\n or `{:error, :incompatible_calendars}` if they are not.\n\n See also `Calendar.compatible_calendars?/2`.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> Date.convert(~D[2000-01-01], Calendar.Holocene)\n {:ok, %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert(Calendar.date(), Calendar.calendar()) ::\n {:ok, t} | {:error, :incompatible_calendars}\n def convert(%{calendar: calendar, year: year, month: month, day: day}, calendar) do\n {:ok, %Date{calendar: calendar, year: year, month: month, day: day}}\n end\n\n def convert(%{calendar: calendar} = date, target_calendar) do\n if Calendar.compatible_calendars?(calendar, target_calendar) do\n result_date =\n date\n |> to_iso_days()\n |> from_iso_days(target_calendar)\n\n {:ok, result_date}\n else\n {:error, :incompatible_calendars}\n end\n end\n\n @doc \"\"\"\n Similar to `Date.convert/2`, but raises an `ArgumentError`\n if the conversion between the two calendars is not possible.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> Date.convert!(~D[2000-01-01], Calendar.Holocene)\n %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert!(Calendar.date(), Calendar.calendar()) :: t\n def convert!(date, calendar) do\n case convert(date, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot convert #{inspect(date)} to target calendar #{inspect(calendar)}, \" <>\n \"reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Adds the number of days to the given `date`.\n\n > #### Prefer `shift/2` {: .info}\n >\n > Prefer `shift/2` over `add/2`, as it offers a more ergonomic API.\n >\n > `add/2` always considers a day to be measured according to the\n > `Calendar.ISO`.\n\n The days are counted as Gregorian days, independent of the underlying\n calendar. The date is returned in the same calendar as it was given in.\n\n ## Examples\n\n iex> Date.add(~D[2000-01-03], -2)\n ~D[2000-01-01]\n iex> Date.add(~D[2000-01-01], 2)\n ~D[2000-01-03]\n iex> Date.add(~N[2000-01-01 09:00:00], 2)\n ~D[2000-01-03]\n iex> Date.add(~D[-0010-01-01], -2)\n ~D[-0011-12-30]\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec add(Calendar.date(), integer()) :: t\n def add(%{calendar: Calendar.ISO} = date, days) do\n %{year: year, month: month, day: day} = date\n {year, month, day} = Calendar.ISO.shift_days({year, month, day}, days)\n %Date{calendar: Calendar.ISO, year: year, month: month, day: day}\n end\n\n def add(%{calendar: calendar} = date, days) do\n {base_days, fraction} = to_iso_days(date)\n from_iso_days({base_days + days, fraction}, calendar)\n end\n\n @doc \"\"\"\n Calculates the difference between two dates, in a full number of days.\n\n It returns the number of Gregorian days between the dates. Only `Date`\n structs that follow the same or compatible calendars can be compared\n this way. If two calendars are not compatible, it will raise.\n\n ## Examples\n\n iex> Date.diff(~D[2000-01-03], ~D[2000-01-01])\n 2\n iex> Date.diff(~D[2000-01-01], ~D[2000-01-03])\n -2\n iex> Date.diff(~D[0000-01-02], ~D[-0001-12-30])\n 3\n iex> Date.diff(~D[2000-01-01], ~N[2000-01-03 09:00:00])\n -2\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec diff(Calendar.date(), Calendar.date()) :: integer\n def diff(%{calendar: Calendar.ISO} = date1, %{calendar: Calendar.ISO} = date2) do\n %{year: year1, month: month1, day: day1} = date1\n %{year: year2, month: month2, day: day2} = date2\n\n Calendar.ISO.date_to_iso_days(year1, month1, day1) -\n Calendar.ISO.date_to_iso_days(year2, month2, day2)\n end\n\n def diff(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do\n if Calendar.compatible_calendars?(calendar1, calendar2) do\n {days1, _} = to_iso_days(date1)\n {days2, _} = to_iso_days(date2)\n days1 - days2\n else\n raise ArgumentError,\n \"cannot calculate the difference between #{inspect(date1)} and #{inspect(date2)} because their calendars are not compatible and thus the result would be ambiguous\"\n end\n end\n\n @doc \"\"\"\n Shifts given `date` by `duration` according to its calendar.\n\n Allowed units are: `:year`, `:month`, `:week`, `:day`.\n\n When using the default ISO calendar, durations are collapsed and\n applied in the order of months and then days:\n\n * when shifting by 1 year and 2 months the date is actually shifted by 14 months\n * when shifting by 2 weeks and 3 days the date is shifted by 17 days\n\n When shifting by month, days are rounded down to the nearest valid date.\n\n Raises an `ArgumentError` when called with time scale units.\n\n ## Examples\n\n iex> Date.shift(~D[2016-01-03], month: 2)\n ~D[2016-03-03]\n iex> Date.shift(~D[2016-01-30], month: -1)\n ~D[2015-12-30]\n iex> Date.shift(~D[2016-01-31], year: 4, day: 1)\n ~D[2020-02-01]\n iex> Date.shift(~D[2016-01-03], Duration.new!(month: 2))\n ~D[2016-03-03]\n\n # leap years\n iex> Date.shift(~D[2024-02-29], year: 1)\n ~D[2025-02-28]\n iex> Date.shift(~D[2024-02-29], year: 4)\n ~D[2028-02-29]\n\n # rounding down\n iex> Date.shift(~D[2015-01-31], month: 1)\n ~D[2015-02-28]\n\n \"\"\"\n @doc since: \"1.17.0\"\n @spec shift(Calendar.date(), Duration.t() | [unit_pair]) :: t\n when unit_pair: {:year, integer} | {:month, integer} | {:week, integer} | {:day, integer}\n def shift(%{calendar: calendar} = date, duration) do\n %{year: year, month: month, day: day} = date\n {year, month, day} = calendar.shift_date(year, month, day, __duration__!(duration))\n %Date{calendar: calendar, year: year, month: month, day: day}\n end\n\n @doc false\n def __duration__!(%Duration{} = duration) do\n duration\n end\n\n # This part is inlined by the compiler on constant values\n def __duration__!(unit_pairs) do\n Enum.each(unit_pairs, &validate_duration_unit!/1)\n struct!(Duration, unit_pairs)\n end\n\n defp validate_duration_unit!({unit, _value})\n when unit in [:hour, :minute, :second, :microsecond] do\n raise ArgumentError, \"unsupported unit #{inspect(unit)}. Expected :year, :month, :week, :day\"\n end\n\n defp validate_duration_unit!({unit, _value}) when unit not in [:year, :month, :week, :day] do\n raise ArgumentError, \"unknown unit #{inspect(unit)}. Expected :year, :month, :week, :day\"\n end\n\n defp validate_duration_unit!({_unit, value}) when is_integer(value) do\n :ok\n end\n\n defp validate_duration_unit!({unit, value}) do\n raise ArgumentError,\n \"unsupported value #{inspect(value)} for #{inspect(unit)}. Expected an integer\"\n end\n\n @doc false\n def to_iso_days(%{calendar: Calendar.ISO, year: year, month: month, day: day}) do\n {Calendar.ISO.date_to_iso_days(year, month, day), {0, 86_400_000_000}}\n end\n\n def to_iso_days(%{calendar: calendar, year: year, month: month, day: day}) do\n calendar.naive_datetime_to_iso_days(year, month, day, 0, 0, 0, {0, 0})\n end\n\n defp from_iso_days({days, _}, Calendar.ISO) do\n {year, month, day} = Calendar.ISO.date_from_iso_days(days)\n %Date{year: year, month: month, day: day, calendar: Calendar.ISO}\n end\n\n defp from_iso_days(iso_days, target_calendar) do\n {year, month, day, _, _, _, _} = target_calendar.naive_datetime_from_iso_days(iso_days)\n %Date{year: year, month: month, day: day, calendar: target_calendar}\n end\n\n @doc \"\"\"\n Calculates the ordinal day of the week of a given `date`.\n\n Returns the day of the week as an integer. For the ISO 8601\n calendar (the default), it is an integer from 1 to 7, where\n 1 is Monday and 7 is Sunday.\n\n An optional `starting_on` value may be supplied, which\n configures the weekday the week starts on. The default value\n for it is `:default`, which translates to `:monday` for the\n built-in ISO 8601 calendar. Any other weekday may be used for\n `starting_on`, in such cases, that weekday will be considered the first\n day of the week, and therefore it will be assigned the ordinal number 1.\n\n The other calendars, the value returned is an ordinal day of week.\n For example, `1` may mean \"first day of the week\" and `7` is\n defined to mean \"seventh day of the week\". Custom calendars may\n also accept their own variations of the `starting_on` parameter\n with their own meaning.\n\n ## Examples\n\n # 2016-10-31 is a Monday and by default Monday is the first day of the week\n iex> Date.day_of_week(~D[2016-10-31])\n 1\n iex> Date.day_of_week(~D[2016-11-01])\n 2\n iex> Date.day_of_week(~N[2016-11-01 01:23:45])\n 2\n iex> Date.day_of_week(~D[-0015-10-30])\n 3\n\n # 2016-10-31 is a Monday but, as we start the week on Sunday, now it returns 2\n iex> Date.day_of_week(~D[2016-10-31], :sunday)\n 2\n iex> Date.day_of_week(~D[2016-11-01], :sunday)\n 3\n iex> Date.day_of_week(~N[2016-11-01 01:23:45], :sunday)\n 3\n iex> Date.day_of_week(~D[-0015-10-30], :sunday)\n 4\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec day_of_week(Calendar.date(), starting_on :: :default | atom) :: Calendar.day_of_week()\n def day_of_week(date, starting_on \\\\ :default)\n\n def day_of_week(%{calendar: calendar, year: year, month: month, day: day}, starting_on) do\n {day_of_week, _first, _last} = calendar.day_of_week(year, month, day, starting_on)\n day_of_week\n end\n\n @doc \"\"\"\n Calculates a date that is the first day of the week for the given `date`.\n\n If the day is already the first day of the week, it returns the\n day itself. For the built-in ISO calendar, the week starts on Monday.\n A weekday rather than `:default` can be given as `starting_on`.\n\n ## Examples\n\n iex> Date.beginning_of_week(~D[2020-07-11])\n ~D[2020-07-06]\n iex> Date.beginning_of_week(~D[2020-07-06])\n ~D[2020-07-06]\n iex> Date.beginning_of_week(~D[2020-07-11], :sunday)\n ~D[2020-07-05]\n iex> Date.beginning_of_week(~D[2020-07-11], :saturday)\n ~D[2020-07-11]\n iex> Date.beginning_of_week(~N[2020-07-11 01:23:45])\n ~D[2020-07-06]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec beginning_of_week(Calendar.date(), starting_on :: :default | atom) :: Date.t()\n def beginning_of_week(date, starting_on \\\\ :default)\n\n def beginning_of_week(%{calendar: Calendar.ISO} = date, starting_on) do\n %{year: year, month: month, day: day} = date\n iso_days = Calendar.ISO.date_to_iso_days(year, month, day)\n\n {year, month, day} =\n case Calendar.ISO.iso_days_to_day_of_week(iso_days, starting_on) do\n 1 ->\n {year, month, day}\n\n day_of_week ->\n Calendar.ISO.date_from_iso_days(iso_days - day_of_week + 1)\n end\n\n %Date{calendar: Calendar.ISO, year: year, month: month, day: day}\n end\n\n def beginning_of_week(%{calendar: calendar} = date, starting_on) do\n %{year: year, month: month, day: day} = date\n\n case calendar.day_of_week(year, month, day, starting_on) do\n {day_of_week, day_of_week, _} ->\n %Date{calendar: calendar, year: year, month: month, day: day}\n\n {day_of_week, first_day_of_week, _} ->\n add(date, -(day_of_week - first_day_of_week))\n end\n end\n\n @doc \"\"\"\n Calculates a date that is the last day of the week for the given `date`.\n\n If the day is already the last day of the week, it returns the\n day itself. For the built-in ISO calendar, the week ends on Sunday.\n A weekday rather than `:default` can be given as `starting_on`.\n\n ## Examples\n\n iex> Date.end_of_week(~D[2020-07-11])\n ~D[2020-07-12]\n iex> Date.end_of_week(~D[2020-07-05])\n ~D[2020-07-05]\n iex> Date.end_of_week(~D[2020-07-06], :sunday)\n ~D[2020-07-11]\n iex> Date.end_of_week(~D[2020-07-06], :saturday)\n ~D[2020-07-10]\n iex> Date.end_of_week(~N[2020-07-11 01:23:45])\n ~D[2020-07-12]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec end_of_week(Calendar.date(), starting_on :: :default | atom) :: Date.t()\n def end_of_week(date, starting_on \\\\ :default)\n\n def end_of_week(%{calendar: Calendar.ISO} = date, starting_on) do\n %{year: year, month: month, day: day} = date\n iso_days = Calendar.ISO.date_to_iso_days(year, month, day)\n\n {year, month, day} =\n case Calendar.ISO.iso_days_to_day_of_week(iso_days, starting_on) do\n 7 ->\n {year, month, day}\n\n day_of_week ->\n Calendar.ISO.date_from_iso_days(iso_days + 7 - day_of_week)\n end\n\n %Date{calendar: Calendar.ISO, year: year, month: month, day: day}\n end\n\n def end_of_week(%{calendar: calendar} = date, starting_on) do\n %{year: year, month: month, day: day} = date\n\n case calendar.day_of_week(year, month, day, starting_on) do\n {day_of_week, _, day_of_week} ->\n %Date{calendar: calendar, year: year, month: month, day: day}\n\n {day_of_week, _, last_day_of_week} ->\n add(date, last_day_of_week - day_of_week)\n end\n end\n\n @doc \"\"\"\n Calculates the day of the year of a given `date`.\n\n Returns the day of the year as an integer. For the ISO 8601\n calendar (the default), it is an integer from 1 to 366.\n\n ## Examples\n\n iex> Date.day_of_year(~D[2016-01-01])\n 1\n iex> Date.day_of_year(~D[2016-11-01])\n 306\n iex> Date.day_of_year(~D[-0015-10-30])\n 303\n iex> Date.day_of_year(~D[2004-12-31])\n 366\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec day_of_year(Calendar.date()) :: Calendar.day()\n def day_of_year(date)\n\n def day_of_year(%{calendar: calendar, year: year, month: month, day: day}) do\n calendar.day_of_year(year, month, day)\n end\n\n @doc \"\"\"\n Calculates the quarter of the year of a given `date`.\n\n Returns the day of the year as an integer. For the ISO 8601\n calendar (the default), it is an integer from 1 to 4.\n\n ## Examples\n\n iex> Date.quarter_of_year(~D[2016-10-31])\n 4\n iex> Date.quarter_of_year(~D[2016-01-01])\n 1\n iex> Date.quarter_of_year(~N[2016-04-01 01:23:45])\n 2\n iex> Date.quarter_of_year(~D[-0015-09-30])\n 3\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec quarter_of_year(Calendar.date()) :: non_neg_integer()\n def quarter_of_year(date)\n\n def quarter_of_year(%{calendar: calendar, year: year, month: month, day: day}) do\n calendar.quarter_of_year(year, month, day)\n end\n\n @doc \"\"\"\n Calculates the year-of-era and era for a given\n calendar year.\n\n Returns a tuple `{year, era}` representing the\n year within the era and the era number.\n\n ## Examples\n\n iex> Date.year_of_era(~D[0001-01-01])\n {1, 1}\n iex> Date.year_of_era(~D[0000-12-31])\n {1, 0}\n iex> Date.year_of_era(~D[-0001-01-01])\n {2, 0}\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec year_of_era(Calendar.date()) :: {Calendar.year(), non_neg_integer()}\n def year_of_era(date)\n\n def year_of_era(%{calendar: calendar, year: year, month: month, day: day}) do\n calendar.year_of_era(year, month, day)\n end\n\n @doc \"\"\"\n Calculates the day-of-era and era for a given\n calendar `date`.\n\n Returns a tuple `{day, era}` representing the\n day within the era and the era number.\n\n ## Examples\n\n iex> Date.day_of_era(~D[0001-01-01])\n {1, 1}\n\n iex> Date.day_of_era(~D[0000-12-31])\n {1, 0}\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec day_of_era(Calendar.date()) :: {Calendar.day(), non_neg_integer()}\n def day_of_era(date)\n\n def day_of_era(%{calendar: calendar, year: year, month: month, day: day}) do\n calendar.day_of_era(year, month, day)\n end\n\n @doc \"\"\"\n Calculates a date that is the first day of the month for the given `date`.\n\n ## Examples\n\n iex> Date.beginning_of_month(~D[2000-01-31])\n ~D[2000-01-01]\n iex> Date.beginning_of_month(~D[2000-01-01])\n ~D[2000-01-01]\n iex> Date.beginning_of_month(~N[2000-01-31 01:23:45])\n ~D[2000-01-01]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec beginning_of_month(Calendar.date()) :: t()\n def beginning_of_month(date)\n\n def beginning_of_month(%{year: year, month: month, calendar: calendar}) do\n %Date{year: year, month: month, day: 1, calendar: calendar}\n end\n\n @doc \"\"\"\n Calculates a date that is the last day of the month for the given `date`.\n\n ## Examples\n\n iex> Date.end_of_month(~D[2000-01-01])\n ~D[2000-01-31]\n iex> Date.end_of_month(~D[2000-01-31])\n ~D[2000-01-31]\n iex> Date.end_of_month(~N[2000-01-01 01:23:45])\n ~D[2000-01-31]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec end_of_month(Calendar.date()) :: t()\n def end_of_month(date)\n\n def end_of_month(%{year: year, month: month, calendar: calendar} = date) do\n day = Date.days_in_month(date)\n %Date{year: year, month: month, day: day, calendar: calendar}\n end\n\n ## Helpers\n\n defimpl String.Chars do\n def to_string(%{calendar: calendar, year: year, month: month, day: day}) do\n calendar.date_to_string(year, month, day)\n end\n end\n\n defimpl Inspect do\n def inspect(%{calendar: calendar, year: year, month: month, day: day}, _)\n when calendar != Calendar.ISO or year in -9999..9999 do\n \"~D[\" <> calendar.date_to_string(year, month, day) <> suffix(calendar) <> \"]\"\n end\n\n def inspect(%{calendar: Calendar.ISO, year: year, month: month, day: day}, _) do\n \"Date.new!(#{Integer.to_string(year)}, #{Integer.to_string(month)}, #{Integer.to_string(day)})\"\n end\n\n def inspect(%{calendar: calendar, year: year, month: month, day: day}, _) do\n \"Date.new!(#{Integer.to_string(year)}, #{Integer.to_string(month)}, #{Integer.to_string(day)}, #{inspect(calendar)})\"\n end\n\n defp suffix(Calendar.ISO), do: \"\"\n defp suffix(calendar), do: \" \" <> inspect(calendar)\n end\nend\n" }, { "path": "lib/elixir/lib/calendar/date_range.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Date.Range do\n @moduledoc \"\"\"\n Returns an inclusive range between dates.\n\n Ranges must be created with the `Date.range/2` or `Date.range/3` function.\n\n The following fields are public:\n\n * `:first` - the initial date on the range\n * `:last` - the last date on the range\n * `:step` - (since v1.12.0) the step\n\n The remaining fields are private and should not be accessed.\n \"\"\"\n\n @type t :: %__MODULE__{\n first: Date.t(),\n last: Date.t(),\n first_in_iso_days: days(),\n last_in_iso_days: days(),\n step: pos_integer | neg_integer\n }\n\n @typep days() :: integer()\n\n @enforce_keys [:first, :last, :first_in_iso_days, :last_in_iso_days, :step]\n defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days, :step]\n\n defimpl Enumerable do\n def member?(\n %Date.Range{\n first: %{calendar: calendar},\n first_in_iso_days: first_days,\n last_in_iso_days: last_days,\n step: step\n } = range,\n %Date{calendar: calendar} = date\n ) do\n {days, _} = Date.to_iso_days(date)\n\n cond do\n empty?(range) ->\n {:ok, false}\n\n first_days <= last_days ->\n {:ok, first_days <= days and days <= last_days and rem(days - first_days, step) == 0}\n\n true ->\n {:ok, last_days <= days and days <= first_days and rem(days - first_days, step) == 0}\n end\n end\n\n def member?(%Date.Range{step: _}, _) do\n {:ok, false}\n end\n\n # TODO: Remove me on v2.0\n member? =\n quote generated: true do\n member?(\n %{\n __struct__: Date.Range,\n first_in_iso_days: var!(first_days),\n last_in_iso_days: var!(last_days)\n } =\n var!(date_range),\n var!(date)\n )\n end\n\n def unquote(member?) do\n step = if first_days <= last_days, do: 1, else: -1\n member?(Map.put(date_range, :step, step), date)\n end\n\n def count(range) do\n {:ok, size(range)}\n end\n\n def slice(\n %Date.Range{\n first_in_iso_days: first,\n first: %{calendar: calendar},\n step: step\n } = range\n ) do\n {:ok, size(range), &slice(first + &1 * step, step + &3 - 1, &2, calendar)}\n end\n\n # TODO: Remove me on v2.0\n def slice(\n %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =\n date_range\n ) do\n step = if first_days <= last_days, do: 1, else: -1\n slice(Map.put(date_range, :step, step))\n end\n\n defp slice(current, _step, 1, calendar) do\n [date_from_iso_days(current, calendar)]\n end\n\n defp slice(current, step, remaining, calendar) when remaining > 1 do\n [\n date_from_iso_days(current, calendar)\n | slice(current + step, step, remaining - 1, calendar)\n ]\n end\n\n def reduce(\n %Date.Range{\n first_in_iso_days: first_days,\n last_in_iso_days: last_days,\n first: %{calendar: calendar},\n step: step\n },\n acc,\n fun\n ) do\n reduce(first_days, last_days, acc, fun, step, calendar)\n end\n\n # TODO: Remove me on v2.0\n def reduce(\n %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =\n date_range,\n acc,\n fun\n ) do\n step = if first_days <= last_days, do: 1, else: -1\n reduce(Map.put(date_range, :step, step), acc, fun)\n end\n\n defp reduce(_first_days, _last_days, {:halt, acc}, _fun, _step, _calendar) do\n {:halted, acc}\n end\n\n defp reduce(first_days, last_days, {:suspend, acc}, fun, step, calendar) do\n {:suspended, acc, &reduce(first_days, last_days, &1, fun, step, calendar)}\n end\n\n defp reduce(first_days, last_days, {:cont, acc}, fun, step, calendar)\n when step > 0 and first_days <= last_days\n when step < 0 and first_days >= last_days do\n reduce(\n first_days + step,\n last_days,\n fun.(date_from_iso_days(first_days, calendar), acc),\n fun,\n step,\n calendar\n )\n end\n\n defp reduce(_, _, {:cont, acc}, _fun, _step, _calendar) do\n {:done, acc}\n end\n\n defp date_from_iso_days(days, Calendar.ISO) do\n {year, month, day} = Calendar.ISO.date_from_iso_days(days)\n %Date{year: year, month: month, day: day, calendar: Calendar.ISO}\n end\n\n defp date_from_iso_days(days, calendar) do\n {year, month, day, _, _, _, _} =\n calendar.naive_datetime_from_iso_days({days, {0, 86_400_000_000}})\n\n %Date{year: year, month: month, day: day, calendar: calendar}\n end\n\n defp size(%Date.Range{first_in_iso_days: first_days, last_in_iso_days: last_days, step: step})\n when step > 0 and first_days > last_days,\n do: 0\n\n defp size(%Date.Range{first_in_iso_days: first_days, last_in_iso_days: last_days, step: step})\n when step < 0 and first_days < last_days,\n do: 0\n\n defp size(%Date.Range{\n first_in_iso_days: first_days,\n last_in_iso_days: last_days,\n step: step\n }),\n do: abs(div(last_days - first_days, step)) + 1\n\n # TODO: Remove me on v2.0\n defp size(\n %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =\n date_range\n ) do\n step = if first_days <= last_days, do: 1, else: -1\n size(Map.put(date_range, :step, step))\n end\n\n defp empty?(%Date.Range{\n first_in_iso_days: first_days,\n last_in_iso_days: last_days,\n step: step\n })\n when step > 0 and first_days > last_days,\n do: true\n\n defp empty?(%Date.Range{\n first_in_iso_days: first_days,\n last_in_iso_days: last_days,\n step: step\n })\n when step < 0 and first_days < last_days,\n do: true\n\n defp empty?(%Date.Range{step: _}), do: false\n\n # TODO: Remove me on v2.0\n defp empty?(\n %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =\n date_range\n ) do\n step = if first_days <= last_days, do: 1, else: -1\n empty?(Map.put(date_range, :step, step))\n end\n end\n\n defimpl Inspect do\n import Kernel, except: [inspect: 2]\n\n def inspect(%Date.Range{first: first, last: last, step: 1}, %Inspect.Opts{}) do\n \"Date.range(\" <> inspect(first) <> \", \" <> inspect(last) <> \")\"\n end\n\n def inspect(%Date.Range{first: first, last: last, step: step}, %Inspect.Opts{}) do\n \"Date.range(\" <> inspect(first) <> \", \" <> inspect(last) <> \", #{step})\"\n end\n\n # TODO: Remove me on v2.0\n def inspect(%{__struct__: Date.Range, first: first, last: last} = date_range, opts) do\n step = if first <= last, do: 1, else: -1\n inspect(Map.put(date_range, :step, step), opts)\n end\n end\nend\n" }, { "path": "lib/elixir/lib/calendar/datetime.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule DateTime do\n @moduledoc \"\"\"\n A datetime implementation with a time zone.\n\n This datetime can be seen as a snapshot of a date and time\n at a given time zone. For such purposes, it also includes both\n UTC and Standard offsets, as well as the zone abbreviation\n field used exclusively for formatting purposes. Note future\n datetimes are not necessarily guaranteed to exist, as time\n zones may change any time in the future due to geopolitical\n reasons. See the \"Datetimes as snapshots\" section for more\n information.\n\n Remember, comparisons in Elixir using `==/2`, `>/2`, ` Enum.min([~U[2022-01-12 00:01:00.00Z], ~U[2021-01-12 00:01:00.00Z]], DateTime)\n ~U[2021-01-12 00:01:00.00Z]\n\n Developers should avoid creating the `DateTime` struct directly\n and instead rely on the functions provided by this module as\n well as the ones in third-party calendar libraries.\n\n ## Time zone database\n\n Many functions in this module require a time zone database.\n A time zone database is a record of the UTC offsets that its locales have\n used at various times in the past, are using, and are expected to use in the\n future.\n Because those plans can change, it needs to be periodically updated.\n\n By default, `DateTime` uses the default time zone database returned by\n `Calendar.get_time_zone_database/0`, which defaults to\n `Calendar.UTCOnlyTimeZoneDatabase` which only handles \"Etc/UTC\"\n datetimes and returns `{:error, :utc_only_time_zone_database}`\n for any other time zone.\n\n Other time zone databases can also be configured. Here are some\n available options and libraries:\n\n * [`time_zone_info`](https://github.com/hrzndhrn/time_zone_info)\n * [`tz`](https://github.com/mathieuprog/tz)\n * [`tzdata`](https://github.com/lau/tzdata)\n * [`zoneinfo`](https://github.com/smartrent/zoneinfo) -\n recommended for embedded devices\n\n To use one of them, first make sure it is added as a dependency in `mix.exs`.\n It can then be configured either via configuration:\n\n config :elixir, :time_zone_database, Tz.TimeZoneDatabase\n\n or by calling `Calendar.put_time_zone_database/1`:\n\n Calendar.put_time_zone_database(Tz.TimeZoneDatabase)\n\n See the proper names in the library installation instructions.\n\n ## Datetimes as snapshots\n\n In the first section, we described datetimes as a \"snapshot of\n a date and time at a given time zone\". To understand precisely\n what we mean, let's see an example.\n\n Imagine someone in Poland who wants to schedule a meeting with someone\n in Brazil in the next year. The meeting will happen at 2:30 AM\n in the Polish time zone. At what time will the meeting happen in\n Brazil?\n\n You can consult the time zone database today, one year before,\n using the API in this module and it will give you an answer that\n is valid right now. However, this answer may not be valid in the\n future. Why? Because both Brazil and Poland may change their timezone\n rules, ultimately affecting the result. For example, a country may\n choose to enter or abandon \"Daylight Saving Time\", which is a\n process where we adjust the clock one hour forward or one hour\n back once per year. Whenever the rules change, the exact instant\n that 2:30 AM in Polish time will be in Brazil may change.\n\n In other words, whenever working with future DateTimes, there is\n no guarantee the results you get will always be correct, until\n the event actually happens. Therefore, when you ask for a future\n time, the answers you get are a snapshot that reflects the current\n state of the time zone rules. For datetimes in the past, this is\n not a problem, because time zone rules do not change for past\n events.\n\n To make matters worse, it may be that 2:30 AM in Polish time\n does not actually even exist or it is ambiguous. If a certain\n time zone observes \"Daylight Saving Time\", they will move their\n clock forward once a year. When this happens, there is a whole\n hour that does not exist. Then, when they move the clock back,\n there is a certain hour that will happen twice. So if you want to\n schedule a meeting when this shift back happens, you would need to\n explicitly say which occurrence of 2:30 AM you mean: the one in\n \"Summer Time\", which occurs before the shift, or the one\n in \"Standard Time\", which occurs after it. Applications that are\n date and time sensitive need to take these scenarios into account\n and correctly communicate them to users.\n\n The good news is: Elixir contains all of the building blocks\n necessary to tackle those problems. The default timezone database\n used by Elixir, `Calendar.UTCOnlyTimeZoneDatabase`, only works\n with UTC, which does not observe those issues. Once you bring\n a proper time zone database, the functions in this module will\n query the database and return the relevant information. For\n example, look at how `DateTime.new/4` returns different results\n based on the scenarios described in this section.\n\n ## Converting between timezones\n\n Bearing in mind the cautions above, and assuming you've brought in a full\n timezone database, here are some examples of common shifts between time\n zones.\n\n # Local time to UTC\n new_york = DateTime.from_naive!(~N[2023-06-26T09:30:00], \"America/New_York\")\n #=> #DateTime<2023-06-26 09:30:00-04:00 EDT America/New_York>\n\n utc = DateTime.shift_zone!(new_york, \"Etc/UTC\")\n #=> ~U[2023-06-26 13:30:00Z]\n\n # UTC to local time\n DateTime.shift_zone!(utc, \"Europe/Paris\")\n #=> #DateTime<2023-06-26 15:30:00+02:00 CEST Europe/Paris>\n\n \"\"\"\n\n @enforce_keys [:year, :month, :day, :hour, :minute, :second] ++\n [:time_zone, :zone_abbr, :utc_offset, :std_offset]\n\n defstruct [\n :year,\n :month,\n :day,\n :hour,\n :minute,\n :second,\n :time_zone,\n :zone_abbr,\n :utc_offset,\n :std_offset,\n microsecond: {0, 0},\n calendar: Calendar.ISO\n ]\n\n @type t :: %__MODULE__{\n year: Calendar.year(),\n month: Calendar.month(),\n day: Calendar.day(),\n calendar: Calendar.calendar(),\n hour: Calendar.hour(),\n minute: Calendar.minute(),\n second: Calendar.second(),\n microsecond: Calendar.microsecond(),\n time_zone: Calendar.time_zone(),\n zone_abbr: Calendar.zone_abbr(),\n utc_offset: Calendar.utc_offset(),\n std_offset: Calendar.std_offset()\n }\n\n @unix_days :calendar.date_to_gregorian_days({1970, 1, 1})\n @seconds_per_day 24 * 60 * 60\n\n @doc \"\"\"\n Returns the current datetime in UTC.\n\n If you want the current time in Unix seconds,\n use `System.os_time/1` instead.\n\n You can also pass a time unit to automatically\n truncate the resulting datetime. This is available\n since v1.15.0.\n\n The default unit if none gets passed is `:native`,\n which results on a default resolution of microseconds.\n\n ## Examples\n\n iex> datetime = DateTime.utc_now()\n iex> datetime.time_zone\n \"Etc/UTC\"\n\n iex> datetime = DateTime.utc_now(:second)\n iex> datetime.microsecond\n {0, 0}\n\n \"\"\"\n @spec utc_now(Calendar.calendar() | :native | :microsecond | :millisecond | :second) :: t\n def utc_now(calendar_or_time_unit \\\\ Calendar.ISO) do\n case calendar_or_time_unit do\n unit when unit in [:microsecond, :millisecond, :second, :native] ->\n utc_now(unit, Calendar.ISO)\n\n calendar ->\n System.os_time() |> from_unix!(:native, calendar)\n end\n end\n\n @doc \"\"\"\n Returns the current datetime in UTC, supporting\n a specific calendar and precision.\n\n If you want the current time in Unix seconds,\n use `System.os_time/1` instead.\n\n ## Examples\n\n iex> datetime = DateTime.utc_now(:microsecond, Calendar.ISO)\n iex> datetime.time_zone\n \"Etc/UTC\"\n\n iex> datetime = DateTime.utc_now(:second, Calendar.ISO)\n iex> datetime.microsecond\n {0, 0}\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec utc_now(:native | :microsecond | :millisecond | :second, Calendar.calendar()) :: t\n def utc_now(time_unit, calendar)\n when time_unit in [:native, :microsecond, :millisecond, :second] do\n System.os_time(time_unit) |> from_unix!(time_unit, calendar)\n end\n\n @doc \"\"\"\n Builds a datetime from date and time structs.\n\n It expects a time zone to put the `DateTime` in.\n If the time zone is not passed it will default to `\"Etc/UTC\"`,\n which always succeeds. Otherwise, the `DateTime` is checked against the time zone database\n given as `time_zone_database`. See the \"Time zone database\"\n section in the module documentation.\n\n ## Examples\n\n iex> DateTime.new(~D[2016-05-24], ~T[13:26:08.003], \"Etc/UTC\")\n {:ok, ~U[2016-05-24 13:26:08.003Z]}\n\n When the datetime is ambiguous - for instance during changing from summer\n to winter time - the two possible valid datetimes are returned in a tuple.\n The first datetime is also the one which comes first chronologically, while\n the second one comes last.\n\n iex> {:ambiguous, first_dt, second_dt} = DateTime.new(~D[2018-10-28], ~T[02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> first_dt\n #DateTime<2018-10-28 02:30:00+02:00 CEST Europe/Copenhagen>\n iex> second_dt\n #DateTime<2018-10-28 02:30:00+01:00 CET Europe/Copenhagen>\n\n When there is a gap in wall time - for instance in spring when the clocks are\n turned forward - the latest valid datetime just before the gap and the first\n valid datetime just after the gap.\n\n iex> {:gap, just_before, just_after} = DateTime.new(~D[2019-03-31], ~T[02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> just_before\n #DateTime<2019-03-31 01:59:59.999999+01:00 CET Europe/Copenhagen>\n iex> just_after\n #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>\n\n Most of the time there is one, and just one, valid datetime for a certain\n date and time in a certain time zone.\n\n iex> {:ok, datetime} = DateTime.new(~D[2018-07-28], ~T[12:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> datetime\n #DateTime<2018-07-28 12:30:00+02:00 CEST Europe/Copenhagen>\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec new(Date.t(), Time.t(), Calendar.time_zone(), Calendar.time_zone_database()) ::\n {:ok, t}\n | {:ambiguous, first_datetime :: t, second_datetime :: t}\n | {:gap, t, t}\n | {:error,\n :incompatible_calendars | :time_zone_not_found | :utc_only_time_zone_database}\n def new(\n date,\n time,\n time_zone \\\\ \"Etc/UTC\",\n time_zone_database \\\\ Calendar.get_time_zone_database()\n )\n\n def new(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time, \"Etc/UTC\", _db) do\n %{year: year, month: month, day: day} = date\n %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time\n\n datetime = %DateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n std_offset: 0,\n utc_offset: 0,\n zone_abbr: \"UTC\",\n time_zone: \"Etc/UTC\"\n }\n\n {:ok, datetime}\n end\n\n def new(date, time, time_zone, time_zone_database) do\n with {:ok, naive_datetime} <- NaiveDateTime.new(date, time) do\n from_naive(naive_datetime, time_zone, time_zone_database)\n end\n end\n\n @doc \"\"\"\n Builds a datetime from date and time structs, raising on errors.\n\n It expects a time zone to put the `DateTime` in.\n If the time zone is not passed it will default to `\"Etc/UTC\"`,\n which always succeeds. Otherwise, the DateTime is checked against the time zone database\n given as `time_zone_database`. See the \"Time zone database\"\n section in the module documentation.\n\n ## Examples\n\n iex> DateTime.new!(~D[2016-05-24], ~T[13:26:08.003], \"Etc/UTC\")\n ~U[2016-05-24 13:26:08.003Z]\n\n When the datetime is ambiguous - for instance during changing from summer\n to winter time - an error will be raised.\n\n iex> DateTime.new!(~D[2018-10-28], ~T[02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n ** (ArgumentError) cannot build datetime with ~D[2018-10-28] and ~T[02:30:00] because such instant is ambiguous in time zone Europe/Copenhagen as there is an overlap between #DateTime<2018-10-28 02:30:00+02:00 CEST Europe/Copenhagen> and #DateTime<2018-10-28 02:30:00+01:00 CET Europe/Copenhagen>\n\n When there is a gap in wall time - for instance in spring when the clocks are\n turned forward - an error will be raised.\n\n iex> DateTime.new!(~D[2019-03-31], ~T[02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n ** (ArgumentError) cannot build datetime with ~D[2019-03-31] and ~T[02:30:00] because such instant does not exist in time zone Europe/Copenhagen as there is a gap between #DateTime<2019-03-31 01:59:59.999999+01:00 CET Europe/Copenhagen> and #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>\n\n Most of the time there is one, and just one, valid datetime for a certain\n date and time in a certain time zone.\n\n iex> datetime = DateTime.new!(~D[2018-07-28], ~T[12:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> datetime\n #DateTime<2018-07-28 12:30:00+02:00 CEST Europe/Copenhagen>\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec new!(Date.t(), Time.t(), Calendar.time_zone(), Calendar.time_zone_database()) :: t\n def new!(\n date,\n time,\n time_zone \\\\ \"Etc/UTC\",\n time_zone_database \\\\ Calendar.get_time_zone_database()\n )\n\n def new!(date, time, time_zone, time_zone_database) do\n case new(date, time, time_zone, time_zone_database) do\n {:ok, datetime} ->\n datetime\n\n {:ambiguous, dt1, dt2} ->\n raise ArgumentError,\n \"cannot build datetime with #{inspect(date)} and #{inspect(time)} because such \" <>\n \"instant is ambiguous in time zone #{time_zone} as there is an overlap \" <>\n \"between #{inspect(dt1)} and #{inspect(dt2)}\"\n\n {:gap, dt1, dt2} ->\n raise ArgumentError,\n \"cannot build datetime with #{inspect(date)} and #{inspect(time)} because such \" <>\n \"instant does not exist in time zone #{time_zone} as there is a gap \" <>\n \"between #{inspect(dt1)} and #{inspect(dt2)}\"\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot build datetime with #{inspect(date)} and #{inspect(time)}, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts the given Unix time to `DateTime`.\n\n The integer can be given in different unit, according to `System.convert_time_unit/3`,\n and it will be converted to microseconds internally, which is the maximum precision\n supported by `DateTime`. In other words, any precision higher than microseconds will\n lead to truncation.\n\n Unix times are always in UTC. Therefore the DateTime will be returned in UTC.\n\n ## Examples\n\n iex> {:ok, datetime} = DateTime.from_unix(1_464_096_368)\n iex> datetime\n ~U[2016-05-24 13:26:08Z]\n\n iex> {:ok, datetime} = DateTime.from_unix(1_432_560_368_868_569, :microsecond)\n iex> datetime\n ~U[2015-05-25 13:26:08.868569Z]\n\n iex> {:ok, datetime} = DateTime.from_unix(253_402_300_799)\n iex> datetime\n ~U[9999-12-31 23:59:59Z]\n\n iex> {:error, :invalid_unix_time} = DateTime.from_unix(253_402_300_800)\n\n The unit can also be an integer as in `t:System.time_unit/0`:\n\n iex> {:ok, datetime} = DateTime.from_unix(143_256_036_886_856, 1024)\n iex> datetime\n ~U[6403-03-17 07:05:22.320312Z]\n\n Negative Unix times are supported up to -377705116800 seconds:\n\n iex> {:ok, datetime} = DateTime.from_unix(-377_705_116_800)\n iex> datetime\n ~U[-9999-01-01 00:00:00Z]\n\n iex> {:error, :invalid_unix_time} = DateTime.from_unix(-377_705_116_801)\n\n \"\"\"\n @spec from_unix(integer, :native | System.time_unit(), Calendar.calendar()) ::\n {:ok, t} | {:error, atom}\n def from_unix(integer, unit \\\\ :second, calendar \\\\ Calendar.ISO) when is_integer(integer) do\n case Calendar.ISO.from_unix(integer, unit) do\n {:ok, {year, month, day}, {hour, minute, second}, microsecond} ->\n iso_datetime = %DateTime{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n std_offset: 0,\n utc_offset: 0,\n zone_abbr: \"UTC\",\n time_zone: \"Etc/UTC\"\n }\n\n convert(iso_datetime, calendar)\n\n {:error, _} = error ->\n error\n end\n end\n\n @doc \"\"\"\n Converts the given Unix time to `DateTime`.\n\n The integer can be given in different unit\n according to `System.convert_time_unit/3` and it will\n be converted to microseconds internally.\n\n Unix times are always in UTC and therefore the DateTime\n will be returned in UTC.\n\n ## Examples\n\n # An easy way to get the Unix epoch is passing 0 to this function\n iex> DateTime.from_unix!(0)\n ~U[1970-01-01 00:00:00Z]\n\n iex> DateTime.from_unix!(1_464_096_368)\n ~U[2016-05-24 13:26:08Z]\n\n iex> DateTime.from_unix!(1_432_560_368_868_569, :microsecond)\n ~U[2015-05-25 13:26:08.868569Z]\n\n iex> DateTime.from_unix!(143_256_036_886_856, 1024)\n ~U[6403-03-17 07:05:22.320312Z]\n\n \"\"\"\n @spec from_unix!(integer, :native | System.time_unit(), Calendar.calendar()) :: t\n def from_unix!(integer, unit \\\\ :second, calendar \\\\ Calendar.ISO) do\n case from_unix(integer, unit, calendar) do\n {:ok, datetime} ->\n datetime\n\n {:error, :invalid_unix_time} ->\n raise ArgumentError, \"invalid Unix time #{integer}\"\n end\n end\n\n @doc \"\"\"\n Converts the given `NaiveDateTime` to `DateTime`.\n\n It expects a time zone to put the `NaiveDateTime` in.\n If the time zone is \"Etc/UTC\", it always succeeds. Otherwise,\n the NaiveDateTime is checked against the time zone database\n given as `time_zone_database`. See the \"Time zone database\"\n section in the module documentation.\n\n ## Examples\n\n iex> DateTime.from_naive(~N[2016-05-24 13:26:08.003], \"Etc/UTC\")\n {:ok, ~U[2016-05-24 13:26:08.003Z]}\n\n When the datetime is ambiguous - for instance during changing from summer\n to winter time - the two possible valid datetimes are returned in a tuple.\n The first datetime is also the one which comes first chronologically, while\n the second one comes last.\n\n iex> {:ambiguous, first_dt, second_dt} = DateTime.from_naive(~N[2018-10-28 02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> first_dt\n #DateTime<2018-10-28 02:30:00+02:00 CEST Europe/Copenhagen>\n iex> second_dt\n #DateTime<2018-10-28 02:30:00+01:00 CET Europe/Copenhagen>\n\n When there is a gap in wall time - for instance in spring when the clocks are\n turned forward - the latest valid datetime just before the gap and the first\n valid datetime just after the gap.\n\n iex> {:gap, just_before, just_after} = DateTime.from_naive(~N[2019-03-31 02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> just_before\n #DateTime<2019-03-31 01:59:59.999999+01:00 CET Europe/Copenhagen>\n iex> just_after\n #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>\n\n Most of the time there is one, and just one, valid datetime for a certain\n date and time in a certain time zone.\n\n iex> {:ok, datetime} = DateTime.from_naive(~N[2018-07-28 12:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> datetime\n #DateTime<2018-07-28 12:30:00+02:00 CEST Europe/Copenhagen>\n\n This function accepts any map or struct that contains at least the same fields as a `NaiveDateTime`\n struct. The most common example of that is a `DateTime`. In this case the information about the time\n zone of that `DateTime` is completely ignored. This is the same principle as passing a `DateTime` to\n `Date.to_iso8601/2`. `Date.to_iso8601/2` extracts only the date-specific fields (calendar, year,\n month and day) of the given structure and ignores all others.\n\n This way if you have a `DateTime` in one time zone, you can get the same wall time in another time zone.\n For instance if you have 2018-08-24 10:00:00 in Copenhagen and want a `DateTime` for 2018-08-24 10:00:00\n in UTC you can do:\n\n iex> cph_datetime = DateTime.from_naive!(~N[2018-08-24 10:00:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> {:ok, utc_datetime} = DateTime.from_naive(cph_datetime, \"Etc/UTC\", FakeTimeZoneDatabase)\n iex> utc_datetime\n ~U[2018-08-24 10:00:00Z]\n\n If instead you want a `DateTime` for the same point time in a different time zone see the\n `DateTime.shift_zone/3` function which would convert 2018-08-24 10:00:00 in Copenhagen\n to 2018-08-24 08:00:00 in UTC.\n \"\"\"\n @doc since: \"1.4.0\"\n @spec from_naive(\n Calendar.naive_datetime(),\n Calendar.time_zone(),\n Calendar.time_zone_database()\n ) ::\n {:ok, t}\n | {:ambiguous, first_datetime :: t, second_datetime :: t}\n | {:gap, t, t}\n | {:error,\n :incompatible_calendars | :time_zone_not_found | :utc_only_time_zone_database}\n\n def from_naive(\n naive_datetime,\n time_zone,\n time_zone_database \\\\ Calendar.get_time_zone_database()\n )\n\n def from_naive(naive_datetime, \"Etc/UTC\", _) do\n utc_period = %{std_offset: 0, utc_offset: 0, zone_abbr: \"UTC\"}\n {:ok, from_naive_with_period(naive_datetime, \"Etc/UTC\", utc_period)}\n end\n\n def from_naive(%{calendar: Calendar.ISO} = naive_datetime, time_zone, time_zone_database) do\n case time_zone_database.time_zone_periods_from_wall_datetime(naive_datetime, time_zone) do\n {:ok, period} ->\n {:ok, from_naive_with_period(naive_datetime, time_zone, period)}\n\n {:ambiguous, first_period, second_period} ->\n first_datetime = from_naive_with_period(naive_datetime, time_zone, first_period)\n second_datetime = from_naive_with_period(naive_datetime, time_zone, second_period)\n {:ambiguous, first_datetime, second_datetime}\n\n {:gap, {first_period, first_period_until_wall}, {second_period, second_period_from_wall}} ->\n # `until_wall` is not valid, but any time just before is.\n # So by subtracting a second and adding .999999 seconds\n # we get the last microsecond just before.\n before_naive =\n first_period_until_wall\n |> Map.replace!(:microsecond, {999_999, 6})\n |> NaiveDateTime.add(-1)\n\n after_naive = second_period_from_wall\n\n latest_datetime_before = from_naive_with_period(before_naive, time_zone, first_period)\n first_datetime_after = from_naive_with_period(after_naive, time_zone, second_period)\n {:gap, latest_datetime_before, first_datetime_after}\n\n {:error, _} = error ->\n error\n end\n end\n\n def from_naive(%{calendar: calendar} = naive_datetime, time_zone, time_zone_database)\n when calendar != Calendar.ISO do\n # For non-ISO calendars, convert to ISO, create ISO DateTime, and then\n # convert to original calendar\n iso_result =\n with {:ok, in_iso} <- NaiveDateTime.convert(naive_datetime, Calendar.ISO) do\n from_naive(in_iso, time_zone, time_zone_database)\n end\n\n case iso_result do\n {:ok, dt} ->\n convert(dt, calendar)\n\n {:ambiguous, dt1, dt2} ->\n with {:ok, dt1converted} <- convert(dt1, calendar),\n {:ok, dt2converted} <- convert(dt2, calendar),\n do: {:ambiguous, dt1converted, dt2converted}\n\n {:gap, dt1, dt2} ->\n with {:ok, dt1converted} <- convert(dt1, calendar),\n {:ok, dt2converted} <- convert(dt2, calendar),\n do: {:gap, dt1converted, dt2converted}\n\n {:error, _} = error ->\n error\n end\n end\n\n defp from_naive_with_period(naive_datetime, time_zone, period) do\n %{std_offset: std_offset, utc_offset: utc_offset, zone_abbr: zone_abbr} = period\n\n %{\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n year: year,\n month: month,\n day: day\n } = naive_datetime\n\n %DateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n std_offset: std_offset,\n utc_offset: utc_offset,\n zone_abbr: zone_abbr,\n time_zone: time_zone\n }\n end\n\n @doc \"\"\"\n Converts the given `NaiveDateTime` to `DateTime`.\n\n It expects a time zone to put the NaiveDateTime in.\n If the time zone is \"Etc/UTC\", it always succeeds. Otherwise,\n the NaiveDateTime is checked against the time zone database\n given as `time_zone_database`. See the \"Time zone database\"\n section in the module documentation.\n\n ## Examples\n\n iex> DateTime.from_naive!(~N[2016-05-24 13:26:08.003], \"Etc/UTC\")\n ~U[2016-05-24 13:26:08.003Z]\n\n iex> DateTime.from_naive!(~N[2018-05-24 13:26:08.003], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n #DateTime<2018-05-24 13:26:08.003+02:00 CEST Europe/Copenhagen>\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec from_naive!(\n NaiveDateTime.t(),\n Calendar.time_zone(),\n Calendar.time_zone_database()\n ) :: t\n def from_naive!(\n naive_datetime,\n time_zone,\n time_zone_database \\\\ Calendar.get_time_zone_database()\n ) do\n case from_naive(naive_datetime, time_zone, time_zone_database) do\n {:ok, datetime} ->\n datetime\n\n {:ambiguous, dt1, dt2} ->\n raise ArgumentError,\n \"cannot convert #{inspect(naive_datetime)} to datetime because such \" <>\n \"instant is ambiguous in time zone #{time_zone} as there is an overlap \" <>\n \"between #{inspect(dt1)} and #{inspect(dt2)}\"\n\n {:gap, dt1, dt2} ->\n raise ArgumentError,\n \"cannot convert #{inspect(naive_datetime)} to datetime because such \" <>\n \"instant does not exist in time zone #{time_zone} as there is a gap \" <>\n \"between #{inspect(dt1)} and #{inspect(dt2)}\"\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot convert #{inspect(naive_datetime)} to datetime, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Changes the time zone of a `DateTime`.\n\n Returns a `DateTime` for the same point in time, but instead at\n the time zone provided. It assumes that `DateTime` is valid and\n exists in the given time zone and calendar.\n\n By default, it uses the default time zone database returned by\n `Calendar.get_time_zone_database/0`, which defaults to\n `Calendar.UTCOnlyTimeZoneDatabase` which only handles \"Etc/UTC\" datetimes.\n Other time zone databases can be passed as argument or set globally.\n See the \"Time zone database\" section in the module docs.\n\n ## Examples\n\n iex> {:ok, pacific_datetime} = DateTime.shift_zone(~U[2018-07-16 10:00:00Z], \"America/Los_Angeles\", FakeTimeZoneDatabase)\n iex> pacific_datetime\n #DateTime<2018-07-16 03:00:00-07:00 PDT America/Los_Angeles>\n\n iex> DateTime.shift_zone(~U[2018-07-16 10:00:00Z], \"bad timezone\", FakeTimeZoneDatabase)\n {:error, :time_zone_not_found}\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec shift_zone(t, Calendar.time_zone(), Calendar.time_zone_database()) ::\n {:ok, t} | {:error, :time_zone_not_found | :utc_only_time_zone_database}\n def shift_zone(datetime, time_zone, time_zone_database \\\\ Calendar.get_time_zone_database())\n\n def shift_zone(%{time_zone: time_zone} = datetime, time_zone, _) do\n {:ok, datetime}\n end\n\n def shift_zone(datetime, time_zone, time_zone_database) do\n %{\n std_offset: std_offset,\n utc_offset: utc_offset,\n calendar: calendar,\n microsecond: {_, precision}\n } = datetime\n\n datetime\n |> to_iso_days()\n |> apply_tz_offset(utc_offset + std_offset)\n |> shift_zone_for_iso_days_utc(calendar, precision, time_zone, time_zone_database)\n end\n\n defp shift_zone_for_iso_days_utc(iso_days_utc, calendar, precision, time_zone, time_zone_db) do\n case time_zone_db.time_zone_period_from_utc_iso_days(iso_days_utc, time_zone) do\n {:ok, %{std_offset: std_offset, utc_offset: utc_offset, zone_abbr: zone_abbr}} ->\n {year, month, day, hour, minute, second, {microsecond_without_precision, _}} =\n iso_days_utc\n |> apply_tz_offset(-(utc_offset + std_offset))\n |> calendar.naive_datetime_from_iso_days()\n\n datetime = %DateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond_without_precision, precision},\n std_offset: std_offset,\n utc_offset: utc_offset,\n zone_abbr: zone_abbr,\n time_zone: time_zone\n }\n\n {:ok, datetime}\n\n {:error, _} = error ->\n error\n end\n end\n\n @doc \"\"\"\n Changes the time zone of a `DateTime` or raises on errors.\n\n See `shift_zone/3` for more information.\n\n ## Examples\n\n iex> DateTime.shift_zone!(~U[2018-07-16 10:00:00Z], \"America/Los_Angeles\", FakeTimeZoneDatabase)\n #DateTime<2018-07-16 03:00:00-07:00 PDT America/Los_Angeles>\n\n iex> DateTime.shift_zone!(~U[2018-07-16 10:00:00Z], \"bad timezone\", FakeTimeZoneDatabase)\n ** (ArgumentError) cannot shift ~U[2018-07-16 10:00:00Z] to \"bad timezone\" time zone, reason: :time_zone_not_found\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec shift_zone!(t, Calendar.time_zone(), Calendar.time_zone_database()) :: t\n def shift_zone!(datetime, time_zone, time_zone_database \\\\ Calendar.get_time_zone_database()) do\n case shift_zone(datetime, time_zone, time_zone_database) do\n {:ok, datetime} ->\n datetime\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot shift #{inspect(datetime)} to #{inspect(time_zone)} time zone\" <>\n \", reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Returns the current datetime in the provided time zone.\n\n By default, it uses the default time_zone returned by\n `Calendar.get_time_zone_database/0`, which defaults to\n `Calendar.UTCOnlyTimeZoneDatabase` which only handles \"Etc/UTC\" datetimes.\n Other time zone databases can be passed as argument or set globally.\n See the \"Time zone database\" section in the module docs.\n\n ## Examples\n\n iex> {:ok, datetime} = DateTime.now(\"Etc/UTC\")\n iex> datetime.time_zone\n \"Etc/UTC\"\n\n iex> DateTime.now(\"Europe/Copenhagen\")\n {:error, :utc_only_time_zone_database}\n\n iex> DateTime.now(\"bad timezone\", FakeTimeZoneDatabase)\n {:error, :time_zone_not_found}\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec now(Calendar.time_zone(), Calendar.time_zone_database()) ::\n {:ok, t} | {:error, :time_zone_not_found | :utc_only_time_zone_database}\n def now(time_zone, time_zone_database \\\\ Calendar.get_time_zone_database())\n\n def now(\"Etc/UTC\", _) do\n {:ok, utc_now()}\n end\n\n def now(time_zone, time_zone_database) do\n shift_zone(utc_now(), time_zone, time_zone_database)\n end\n\n @doc \"\"\"\n Returns the current datetime in the provided time zone or raises on errors\n\n See `now/2` for more information.\n\n ## Examples\n\n iex> datetime = DateTime.now!(\"Etc/UTC\")\n iex> datetime.time_zone\n \"Etc/UTC\"\n\n iex> DateTime.now!(\"Europe/Copenhagen\")\n ** (ArgumentError) cannot get current datetime in \"Europe/Copenhagen\" time zone, reason: :utc_only_time_zone_database\n\n iex> DateTime.now!(\"bad timezone\", FakeTimeZoneDatabase)\n ** (ArgumentError) cannot get current datetime in \"bad timezone\" time zone, reason: :time_zone_not_found\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec now!(Calendar.time_zone(), Calendar.time_zone_database()) :: t\n def now!(time_zone, time_zone_database \\\\ Calendar.get_time_zone_database()) do\n case now(time_zone, time_zone_database) do\n {:ok, datetime} ->\n datetime\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot get current datetime in #{inspect(time_zone)} time zone, reason: \" <>\n inspect(reason)\n end\n end\n\n @doc \"\"\"\n Converts the given `datetime` to Unix time.\n\n The `datetime` is expected to be using the ISO calendar\n with a year greater than or equal to 0.\n\n It will return the integer with the given unit, according\n to `System.convert_time_unit/3`. If the given unit is different\n than microseconds, the returned value will be either truncated\n or padded accordingly.\n\n ## Examples\n\n iex> 1_464_096_368 |> DateTime.from_unix!() |> DateTime.to_unix()\n 1464096368\n\n iex> dt = %DateTime{calendar: Calendar.ISO, day: 20, hour: 18, microsecond: {273806, 6},\n ...> minute: 58, month: 11, second: 19, time_zone: \"America/Montevideo\",\n ...> utc_offset: -10800, std_offset: 3600, year: 2014, zone_abbr: \"UYST\"}\n iex> DateTime.to_unix(dt)\n 1416517099\n\n iex> flamel = %DateTime{calendar: Calendar.ISO, day: 22, hour: 8, microsecond: {527771, 6},\n ...> minute: 2, month: 3, second: 25, std_offset: 0, time_zone: \"Etc/UTC\",\n ...> utc_offset: 0, year: 1418, zone_abbr: \"UTC\"}\n iex> DateTime.to_unix(flamel)\n -17412508655\n\n \"\"\"\n @spec to_unix(Calendar.datetime(), :native | System.time_unit()) :: integer\n def to_unix(datetime, unit \\\\ :second)\n\n def to_unix(%{utc_offset: utc_offset, std_offset: std_offset} = datetime, unit) do\n {days, fraction} = to_iso_days(datetime)\n unix_units = Calendar.ISO.iso_days_to_unit({days - @unix_days, fraction}, unit)\n offset_units = System.convert_time_unit(utc_offset + std_offset, :second, unit)\n unix_units - offset_units\n end\n\n @doc \"\"\"\n Converts the given `datetime` into a `NaiveDateTime`.\n\n Because `NaiveDateTime` does not hold time zone information,\n any time zone related data will be lost during the conversion.\n\n ## Examples\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 1},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.to_naive(dt)\n ~N[2000-02-29 23:00:07.0]\n\n \"\"\"\n @spec to_naive(Calendar.datetime()) :: NaiveDateTime.t()\n def to_naive(datetime)\n\n def to_naive(%{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: _\n }) do\n %NaiveDateTime{\n year: year,\n month: month,\n day: day,\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n end\n\n @doc \"\"\"\n Converts a `DateTime` into a `Date`.\n\n Because `Date` does not hold time nor time zone information,\n data will be lost during the conversion.\n\n ## Examples\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.to_date(dt)\n ~D[2000-02-29]\n\n \"\"\"\n @spec to_date(Calendar.datetime()) :: Date.t()\n def to_date(datetime)\n\n def to_date(%{\n year: year,\n month: month,\n day: day,\n calendar: calendar,\n hour: _,\n minute: _,\n second: _,\n microsecond: _,\n time_zone: _\n }) do\n %Date{year: year, month: month, day: day, calendar: calendar}\n end\n\n @doc \"\"\"\n Converts a `DateTime` into `Time`.\n\n Because `Time` does not hold date nor time zone information,\n data will be lost during the conversion.\n\n ## Examples\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 1},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.to_time(dt)\n ~T[23:00:07.0]\n\n \"\"\"\n @spec to_time(Calendar.datetime()) :: Time.t()\n def to_time(datetime)\n\n def to_time(%{\n year: _,\n month: _,\n day: _,\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: _\n }) do\n %Time{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: calendar\n }\n end\n\n @doc \"\"\"\n Converts the given datetime to\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601) format.\n\n By default, `DateTime.to_iso8601/2` returns datetimes formatted in the \"extended\"\n format, for human readability. It also supports the \"basic\" format through passing the `:basic` option.\n\n You can also optionally specify an offset for the formatted string.\n If none is given, the one in the given `datetime` is used.\n\n Only supports converting datetimes which are in the ISO calendar.\n If another calendar is given, it is automatically converted to ISO.\n It raises if not possible.\n\n WARNING: the ISO 8601 datetime format does not contain the time zone nor\n its abbreviation, which means information is lost when converting to such\n format.\n\n ## Examples\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.to_iso8601(dt)\n \"2000-02-29T23:00:07+01:00\"\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"UTC\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 0, std_offset: 0, time_zone: \"Etc/UTC\"}\n iex> DateTime.to_iso8601(dt)\n \"2000-02-29T23:00:07Z\"\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> DateTime.to_iso8601(dt, :extended)\n \"2000-02-29T23:00:07-04:00\"\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> DateTime.to_iso8601(dt, :basic)\n \"20000229T230007-0400\"\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> DateTime.to_iso8601(dt, :extended, 3600)\n \"2000-03-01T04:00:07+01:00\"\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> DateTime.to_iso8601(dt, :extended, 0)\n \"2000-03-01T03:00:07+00:00\"\n\n iex> dt = %DateTime{year: 2000, month: 3, day: 01, zone_abbr: \"UTC\",\n ...> hour: 03, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 0, std_offset: 0, time_zone: \"Etc/UTC\"}\n iex> DateTime.to_iso8601(dt, :extended, 0)\n \"2000-03-01T03:00:07Z\"\n\n iex> {:ok, dt, offset} = DateTime.from_iso8601(\"2000-03-01T03:00:07Z\")\n iex> \"2000-03-01T03:00:07Z\" = DateTime.to_iso8601(dt, :extended, offset)\n \"\"\"\n @spec to_iso8601(Calendar.datetime(), :basic | :extended, nil | integer()) :: String.t()\n def to_iso8601(datetime, format \\\\ :extended, offset \\\\ nil)\n\n def to_iso8601(%{calendar: Calendar.ISO} = datetime, format, offset)\n when format in [:extended, :basic] do\n datetime\n |> to_iso8601_iodata(format, offset)\n |> IO.iodata_to_binary()\n end\n\n def to_iso8601(%{calendar: _} = datetime, format, offset)\n when format in [:extended, :basic] do\n datetime\n |> convert!(Calendar.ISO)\n |> to_iso8601(format, offset)\n end\n\n defp to_iso8601_iodata(datetime, format, nil) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: time_zone,\n utc_offset: utc_offset,\n std_offset: std_offset\n } = datetime\n\n [\n datetime_to_iodata(year, month, day, hour, minute, second, microsecond, format),\n Calendar.ISO.offset_to_iodata(utc_offset, std_offset, time_zone, format)\n ]\n end\n\n defp to_iso8601_iodata(\n %{microsecond: {_, precision}, time_zone: \"Etc/UTC\"} = datetime,\n format,\n 0\n ) do\n {year, month, day, hour, minute, second, {microsecond, _}} = shift_by_offset(datetime, 0)\n\n [\n datetime_to_iodata(\n year,\n month,\n day,\n hour,\n minute,\n second,\n {microsecond, precision},\n format\n ),\n ?Z\n ]\n end\n\n defp to_iso8601_iodata(datetime, format, offset) do\n {_, precision} = datetime.microsecond\n {year, month, day, hour, minute, second, {microsecond, _}} = shift_by_offset(datetime, offset)\n\n [\n datetime_to_iodata(\n year,\n month,\n day,\n hour,\n minute,\n second,\n {microsecond, precision},\n format\n ),\n Calendar.ISO.offset_to_iodata(offset, 0, nil, format)\n ]\n end\n\n defp shift_by_offset(%{calendar: calendar} = datetime, offset) do\n total_offset = datetime.utc_offset + datetime.std_offset\n\n datetime\n |> to_iso_days()\n # Subtract total original offset in order to get UTC and add the new offset\n |> Calendar.ISO.add_day_fraction_to_iso_days(offset - total_offset, 86400)\n |> calendar.naive_datetime_from_iso_days()\n end\n\n defp datetime_to_iodata(year, month, day, hour, minute, second, microsecond, format) do\n [\n Calendar.ISO.date_to_iodata(year, month, day, format),\n ?T,\n Calendar.ISO.time_to_iodata(hour, minute, second, microsecond, format)\n ]\n end\n\n @doc \"\"\"\n Parses the extended \"Date and time of day\" format described by\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n Since ISO 8601 does not include the proper time zone, the given\n string will be converted to UTC and its offset in seconds will be\n returned as part of this function. Therefore offset information\n must be present in the string.\n\n As specified in the standard, the separator \"T\" may be omitted if\n desired as there is no ambiguity within this function.\n\n Note leap seconds are not supported by the built-in Calendar.ISO.\n\n ## Examples\n\n iex> {:ok, datetime, 0} = DateTime.from_iso8601(\"2015-01-23T23:50:07Z\")\n iex> datetime\n ~U[2015-01-23 23:50:07Z]\n\n iex> {:ok, datetime, 9000} = DateTime.from_iso8601(\"2015-01-23T23:50:07.123+02:30\")\n iex> datetime\n ~U[2015-01-23 21:20:07.123Z]\n\n iex> {:ok, datetime, 9000} = DateTime.from_iso8601(\"2015-01-23T23:50:07,123+02:30\")\n iex> datetime\n ~U[2015-01-23 21:20:07.123Z]\n\n iex> {:ok, datetime, 0} = DateTime.from_iso8601(\"-2015-01-23T23:50:07Z\")\n iex> datetime\n ~U[-2015-01-23 23:50:07Z]\n\n iex> {:ok, datetime, 9000} = DateTime.from_iso8601(\"-2015-01-23T23:50:07,123+02:30\")\n iex> datetime\n ~U[-2015-01-23 21:20:07.123Z]\n\n iex> {:ok, datetime, 9000} = DateTime.from_iso8601(\"20150123T235007.123+0230\", :basic)\n iex> datetime\n ~U[2015-01-23 21:20:07.123Z]\n\n iex> DateTime.from_iso8601(\"2015-01-23P23:50:07\")\n {:error, :invalid_format}\n iex> DateTime.from_iso8601(\"2015-01-23T23:50:07\")\n {:error, :missing_offset}\n iex> DateTime.from_iso8601(\"2015-01-23 23:50:61\")\n {:error, :invalid_time}\n iex> DateTime.from_iso8601(\"2015-01-32 23:50:07\")\n {:error, :invalid_date}\n iex> DateTime.from_iso8601(\"2015-01-23T23:50:07.123-00:00\")\n {:error, :invalid_format}\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec from_iso8601(String.t(), Calendar.calendar() | :extended | :basic) ::\n {:ok, t, Calendar.utc_offset()} | {:error, atom}\n def from_iso8601(string, format_or_calendar \\\\ Calendar.ISO)\n\n def from_iso8601(string, format) when format in [:basic, :extended] do\n from_iso8601(string, Calendar.ISO, format)\n end\n\n def from_iso8601(string, calendar) when is_atom(calendar) do\n from_iso8601(string, calendar, :extended)\n end\n\n @doc \"\"\"\n Converts from ISO8601 specifying both a calendar and a mode.\n\n See `from_iso8601/2` for more information.\n\n ## Examples\n\n iex> {:ok, datetime, 9000} = DateTime.from_iso8601(\"2015-01-23T23:50:07,123+02:30\", Calendar.ISO, :extended)\n iex> datetime\n ~U[2015-01-23 21:20:07.123Z]\n\n iex> {:ok, datetime, 9000} = DateTime.from_iso8601(\"20150123T235007.123+0230\", Calendar.ISO, :basic)\n iex> datetime\n ~U[2015-01-23 21:20:07.123Z]\n\n \"\"\"\n @spec from_iso8601(String.t(), Calendar.calendar(), :extended | :basic) ::\n {:ok, t, Calendar.utc_offset()} | {:error, atom}\n def from_iso8601(string, calendar, format) do\n with {:ok, {year, month, day, hour, minute, second, microsecond}, offset} <-\n Calendar.ISO.parse_utc_datetime(string, format) do\n datetime = %DateTime{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n std_offset: 0,\n utc_offset: 0,\n zone_abbr: \"UTC\",\n time_zone: \"Etc/UTC\"\n }\n\n with {:ok, converted} <- convert(datetime, calendar) do\n {:ok, converted, offset}\n end\n end\n end\n\n @doc \"\"\"\n Converts a number of gregorian seconds to a `DateTime` struct.\n\n The returned `DateTime` will have `UTC` timezone, if you want other timezone, please use\n `DateTime.shift_zone/3`.\n\n ## Examples\n\n iex> DateTime.from_gregorian_seconds(1)\n ~U[0000-01-01 00:00:01Z]\n iex> DateTime.from_gregorian_seconds(63_755_511_991, {5000, 3})\n ~U[2020-05-01 00:26:31.005Z]\n iex> DateTime.from_gregorian_seconds(-1)\n ~U[-0001-12-31 23:59:59Z]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec from_gregorian_seconds(integer(), Calendar.microsecond(), Calendar.calendar()) :: t\n def from_gregorian_seconds(\n seconds,\n {microsecond, precision} \\\\ {0, 0},\n calendar \\\\ Calendar.ISO\n )\n when is_integer(seconds) do\n iso_days = Calendar.ISO.gregorian_seconds_to_iso_days(seconds, microsecond)\n\n {year, month, day, hour, minute, second, {microsecond, _}} =\n calendar.naive_datetime_from_iso_days(iso_days)\n\n %DateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision},\n std_offset: 0,\n utc_offset: 0,\n zone_abbr: \"UTC\",\n time_zone: \"Etc/UTC\"\n }\n end\n\n @doc \"\"\"\n Converts a `DateTime` struct to a number of gregorian seconds and microseconds.\n\n ## Examples\n\n iex> dt = %DateTime{year: 0000, month: 1, day: 1, zone_abbr: \"UTC\",\n ...> hour: 0, minute: 0, second: 1, microsecond: {0, 0},\n ...> utc_offset: 0, std_offset: 0, time_zone: \"Etc/UTC\"}\n iex> DateTime.to_gregorian_seconds(dt)\n {1, 0}\n\n iex> dt = %DateTime{year: 2020, month: 5, day: 1, zone_abbr: \"UTC\",\n ...> hour: 0, minute: 26, second: 31, microsecond: {5000, 0},\n ...> utc_offset: 0, std_offset: 0, time_zone: \"Etc/UTC\"}\n iex> DateTime.to_gregorian_seconds(dt)\n {63_755_511_991, 5000}\n\n iex> dt = %DateTime{year: 2020, month: 5, day: 1, zone_abbr: \"CET\",\n ...> hour: 1, minute: 26, second: 31, microsecond: {5000, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.to_gregorian_seconds(dt)\n {63_755_511_991, 5000}\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec to_gregorian_seconds(Calendar.datetime()) :: {integer(), non_neg_integer()}\n def to_gregorian_seconds(\n %{\n std_offset: std_offset,\n utc_offset: utc_offset,\n microsecond: {microsecond, _}\n } = datetime\n ) do\n {days, day_fraction} =\n datetime\n |> to_iso_days()\n |> apply_tz_offset(utc_offset + std_offset)\n\n seconds_in_day = seconds_from_day_fraction(day_fraction)\n {days * @seconds_per_day + seconds_in_day, microsecond}\n end\n\n @doc \"\"\"\n Converts the given `datetime` to a string according to its calendar.\n\n Unfortunately, there is no standard that specifies rendering of a\n datetime with its complete time zone information, so Elixir uses a\n custom (but relatively common) representation which appends the time\n zone abbreviation and full name to the datetime.\n\n ## Examples\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.to_string(dt)\n \"2000-02-29 23:00:07+01:00 CET Europe/Warsaw\"\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"UTC\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 0, std_offset: 0, time_zone: \"Etc/UTC\"}\n iex> DateTime.to_string(dt)\n \"2000-02-29 23:00:07Z\"\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> DateTime.to_string(dt)\n \"2000-02-29 23:00:07-04:00 AMT America/Manaus\"\n\n iex> dt = %DateTime{year: -100, month: 12, day: 19, zone_abbr: \"CET\",\n ...> hour: 3, minute: 20, second: 31, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Stockholm\"}\n iex> DateTime.to_string(dt)\n \"-0100-12-19 03:20:31+01:00 CET Europe/Stockholm\"\n\n \"\"\"\n @spec to_string(Calendar.datetime()) :: String.t()\n def to_string(%{calendar: calendar} = datetime) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: time_zone,\n zone_abbr: zone_abbr,\n utc_offset: utc_offset,\n std_offset: std_offset\n } = datetime\n\n calendar.datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n zone_abbr,\n utc_offset,\n std_offset\n )\n end\n\n @doc \"\"\"\n Compares two datetime structs.\n\n Returns `:gt` if the first datetime is later than the second\n and `:lt` for vice versa. If the two datetimes are equal\n `:eq` is returned.\n\n Note that both UTC and Standard offsets will be taken into\n account when comparison is done.\n\n ## Examples\n\n iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.compare(dt1, dt2)\n :gt\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec compare(Calendar.datetime(), Calendar.datetime()) :: :lt | :eq | :gt\n def compare(\n %{utc_offset: utc_offset1, std_offset: std_offset1} = datetime1,\n %{utc_offset: utc_offset2, std_offset: std_offset2} = datetime2\n ) do\n {days1, {parts1, ppd1}} =\n datetime1\n |> to_iso_days()\n |> apply_tz_offset(utc_offset1 + std_offset1)\n\n {days2, {parts2, ppd2}} =\n datetime2\n |> to_iso_days()\n |> apply_tz_offset(utc_offset2 + std_offset2)\n\n # Ensure fraction tuples have same denominator.\n first = {days1, parts1 * ppd2}\n second = {days2, parts2 * ppd1}\n\n cond do\n first > second -> :gt\n first < second -> :lt\n true -> :eq\n end\n end\n\n @doc \"\"\"\n Returns `true` if the first datetime is strictly earlier than the second.\n\n ## Examples\n\n iex> DateTime.before?(~U[2021-01-01 11:00:00Z], ~U[2022-02-02 11:00:00Z])\n true\n iex> DateTime.before?(~U[2021-01-01 11:00:00Z], ~U[2021-01-01 11:00:00Z])\n false\n iex> DateTime.before?(~U[2022-02-02 11:00:00Z], ~U[2021-01-01 11:00:00Z])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec before?(Calendar.datetime(), Calendar.datetime()) :: boolean()\n def before?(datetime1, datetime2) do\n compare(datetime1, datetime2) == :lt\n end\n\n @doc \"\"\"\n Returns `true` if the first datetime is strictly later than the second.\n\n ## Examples\n\n iex> DateTime.after?(~U[2022-02-02 11:00:00Z], ~U[2021-01-01 11:00:00Z])\n true\n iex> DateTime.after?(~U[2021-01-01 11:00:00Z], ~U[2021-01-01 11:00:00Z])\n false\n iex> DateTime.after?(~U[2021-01-01 11:00:00Z], ~U[2022-02-02 11:00:00Z])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec after?(Calendar.datetime(), Calendar.datetime()) :: boolean()\n def after?(datetime1, datetime2) do\n compare(datetime1, datetime2) == :gt\n end\n\n @doc \"\"\"\n Subtracts `datetime2` from `datetime1`.\n\n The answer can be returned in any `:day`, `:hour`, `:minute`, or any `unit`\n available from `t:System.time_unit/0`. The unit is measured according to\n `Calendar.ISO` and defaults to `:second`.\n\n Fractional results are not supported and are truncated.\n\n ## Examples\n\n iex> DateTime.diff(~U[2024-01-15 10:00:10Z], ~U[2024-01-15 10:00:00Z])\n 10\n\n This function also considers timezone offsets:\n\n iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> DateTime.diff(dt1, dt2)\n 18000\n iex> DateTime.diff(dt2, dt1)\n -18000\n iex> DateTime.diff(dt1, dt2, :hour)\n 5\n iex> DateTime.diff(dt2, dt1, :hour)\n -5\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec diff(\n Calendar.datetime(),\n Calendar.datetime(),\n :day | :hour | :minute | System.time_unit()\n ) :: integer()\n def diff(datetime1, datetime2, unit \\\\ :second)\n\n def diff(datetime1, datetime2, :day) do\n diff(datetime1, datetime2, :second) |> div(86400)\n end\n\n def diff(datetime1, datetime2, :hour) do\n diff(datetime1, datetime2, :second) |> div(3600)\n end\n\n def diff(datetime1, datetime2, :minute) do\n diff(datetime1, datetime2, :second) |> div(60)\n end\n\n def diff(\n %{utc_offset: utc_offset1, std_offset: std_offset1} = datetime1,\n %{utc_offset: utc_offset2, std_offset: std_offset2} = datetime2,\n unit\n ) do\n if not is_integer(unit) and\n unit not in ~w(second millisecond microsecond nanosecond)a do\n raise ArgumentError,\n \"unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}\"\n end\n\n naive_diff =\n (datetime1 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(:microsecond)) -\n (datetime2 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(:microsecond))\n\n offset_diff = utc_offset2 + std_offset2 - (utc_offset1 + std_offset1)\n\n System.convert_time_unit(naive_diff, :microsecond, unit) +\n System.convert_time_unit(offset_diff, :second, unit)\n end\n\n @doc \"\"\"\n Adds a specified amount of time to a `DateTime`.\n\n > #### Prefer `shift/2` {: .info}\n >\n > Prefer `shift/2` over `add/3`, as it offers a more ergonomic API.\n >\n > `add/3` provides a lower-level API which only supports fixed units\n > such as `:hour` and `:second`, but not `:month` (as the exact length\n > of a month depends on the current month). `add/3` always considers\n > the unit to be computed according to the `Calendar.ISO`.\n\n Accepts an `amount_to_add` in any `unit`. `unit` can be `:day`,\n `:hour`, `:minute`, `:second` or any subsecond precision from\n `t:System.time_unit/0` for convenience but ultimately they are\n all converted to microseconds. Negative values will move backwards\n in time and the default precision is `:second`.\n\n This function relies on a contiguous representation of time,\n ignoring timezone changes. For example, if you add one day when there\n are summer time/daylight saving time changes, it will also change the\n time forward or backward by one hour, so the elapsed time is precisely\n 24 hours. Similarly, adding just a few seconds to a datetime just before\n \"spring forward\" can cause wall time to increase by more than an hour.\n\n While this means this function is precise in terms of elapsed time,\n its result may be confusing in certain use cases. For example, if a\n user requests a meeting to happen every day at 15:00 and you use this\n function to compute all future meetings by adding day after day, this\n function may change the meeting time to 14:00 or 16:00 if there are\n changes to the current timezone.\n\n In case you don't want these changes to happen automatically or you\n want to surface time zone conflicts to the user, you can add to\n the datetime as a naive datetime and then use `from_naive/2`:\n\n dt |> NaiveDateTime.add(1, :day) |> DateTime.from_naive(dt.time_zone)\n\n The above will surface time jumps and ambiguous datetimes, allowing you\n to deal with them accordingly.\n\n ## Examples\n\n iex> dt = DateTime.from_naive!(~N[2018-11-15 10:00:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> dt |> DateTime.add(3600, :second, FakeTimeZoneDatabase)\n #DateTime<2018-11-15 11:00:00+01:00 CET Europe/Copenhagen>\n\n iex> DateTime.add(~U[2018-11-15 10:00:00Z], 3600, :second)\n ~U[2018-11-15 11:00:00Z]\n\n When adding 3 seconds just before \"spring forward\" we go from 1:59:59 to 3:00:02:\n\n iex> dt = DateTime.from_naive!(~N[2019-03-31 01:59:59.123], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> dt |> DateTime.add(3, :second, FakeTimeZoneDatabase)\n #DateTime<2019-03-31 03:00:02.123+02:00 CEST Europe/Copenhagen>\n\n When adding 1 day during \"spring forward\", the hour also changes:\n\n iex> dt = DateTime.from_naive!(~N[2019-03-31 01:00:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n iex> dt |> DateTime.add(1, :day, FakeTimeZoneDatabase)\n #DateTime<2019-04-01 02:00:00+02:00 CEST Europe/Copenhagen>\n\n This operation merges the precision of the naive date time with the given unit:\n\n iex> result = DateTime.add(~U[2014-10-02 00:29:10Z], 21, :millisecond)\n ~U[2014-10-02 00:29:10.021Z]\n iex> result.microsecond\n {21000, 3}\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec add(\n Calendar.datetime(),\n integer,\n :day | :hour | :minute | System.time_unit(),\n Calendar.time_zone_database()\n ) ::\n t()\n def add(\n datetime,\n amount_to_add,\n unit \\\\ :second,\n time_zone_database \\\\ Calendar.get_time_zone_database()\n )\n\n def add(datetime, amount_to_add, :day, time_zone_database) when is_integer(amount_to_add) do\n add(datetime, amount_to_add * 86400, :second, time_zone_database)\n end\n\n def add(datetime, amount_to_add, :hour, time_zone_database) when is_integer(amount_to_add) do\n add(datetime, amount_to_add * 3600, :second, time_zone_database)\n end\n\n def add(datetime, amount_to_add, :minute, time_zone_database) when is_integer(amount_to_add) do\n add(datetime, amount_to_add * 60, :second, time_zone_database)\n end\n\n def add(%{calendar: calendar} = datetime, amount_to_add, unit, time_zone_database)\n when is_integer(amount_to_add) do\n %{\n microsecond: {_, precision},\n time_zone: time_zone,\n utc_offset: utc_offset,\n std_offset: std_offset\n } = datetime\n\n if not is_integer(unit) and unit not in ~w(second millisecond microsecond nanosecond)a do\n raise ArgumentError,\n \"unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}\"\n end\n\n precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)\n\n result =\n datetime\n |> to_iso_days()\n |> Calendar.ISO.shift_time_unit(amount_to_add, unit)\n |> apply_tz_offset(utc_offset + std_offset)\n |> shift_zone_for_iso_days_utc(calendar, precision, time_zone, time_zone_database)\n\n case result do\n {:ok, result_datetime} ->\n result_datetime\n\n {:error, error} ->\n raise ArgumentError,\n \"cannot add #{amount_to_add} #{unit} to #{inspect(datetime)} (with time zone \" <>\n \"database #{inspect(time_zone_database)}), reason: #{inspect(error)}\"\n end\n end\n\n @doc \"\"\"\n Shifts given `datetime` by `duration` according to its calendar.\n\n Allowed units are: `:year`, `:month`, `:week`, `:day`, `:hour`, `:minute`, `:second`, `:microsecond`.\n\n This operation is equivalent to shifting the datetime wall clock\n (in other words, the value as someone in that timezone would see\n on their watch), then applying the time zone offset to convert it\n to UTC, and finally computing the new timezone in case of shifts.\n This ensures `shift/3` always returns a valid datetime.\n\n Consequently, time zones that observe \"Daylight Saving Time\"\n or other changes, across summer/winter time will add/remove hours\n from the resulting datetime:\n\n dt = DateTime.new!(~D[2019-03-31], ~T[01:00:00], \"Europe/Copenhagen\")\n DateTime.shift(dt, hour: 1)\n #=> #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>\n\n dt = DateTime.new!(~D[2018-11-04], ~T[00:00:00], \"America/Los_Angeles\")\n DateTime.shift(dt, hour: 2)\n #=> #DateTime<2018-11-04 01:00:00-08:00 PST America/Los_Angeles>\n\n Although the first example shows a difference of 2 hours when\n comparing the wall clocks of the given datetime with the returned one,\n due to the \"spring forward\" time jump, the actual elapsed time is\n still exactly of 1 hour.\n\n In case you don't want these changes to happen automatically or you\n want to surface time zone conflicts to the user, you can shift\n the datetime as a naive datetime and then use `from_naive/2`:\n\n dt |> NaiveDateTime.shift(duration) |> DateTime.from_naive(dt.time_zone)\n\n The above will surface time jumps and ambiguous datetimes, allowing you\n to deal with them accordingly.\n\n ## ISO calendar considerations\n\n When using the default ISO calendar, durations are collapsed and\n applied in the order of months, then seconds and microseconds:\n\n * when shifting by 1 year and 2 months the date is actually shifted by 14 months\n * weeks, days and smaller units are collapsed into seconds and microseconds\n\n When shifting by month, days are rounded down to the nearest valid date.\n\n ## Examples\n\n iex> DateTime.shift(~U[2016-01-01 00:00:00Z], month: 2)\n ~U[2016-03-01 00:00:00Z]\n iex> DateTime.shift(~U[2016-01-01 00:00:00Z], year: 1, week: 4)\n ~U[2017-01-29 00:00:00Z]\n iex> DateTime.shift(~U[2016-01-01 00:00:00Z], minute: -25)\n ~U[2015-12-31 23:35:00Z]\n iex> DateTime.shift(~U[2016-01-01 00:00:00Z], minute: 5, microsecond: {500, 4})\n ~U[2016-01-01 00:05:00.0005Z]\n\n # leap years\n iex> DateTime.shift(~U[2024-02-29 00:00:00Z], year: 1)\n ~U[2025-02-28 00:00:00Z]\n iex> DateTime.shift(~U[2024-02-29 00:00:00Z], year: 4)\n ~U[2028-02-29 00:00:00Z]\n\n # rounding down\n iex> DateTime.shift(~U[2015-01-31 00:00:00Z], month: 1)\n ~U[2015-02-28 00:00:00Z]\n\n \"\"\"\n @doc since: \"1.17.0\"\n @spec shift(Calendar.datetime(), Duration.duration(), Calendar.time_zone_database()) :: t\n def shift(datetime, duration, time_zone_database \\\\ Calendar.get_time_zone_database())\n\n def shift(%{calendar: calendar, time_zone: \"Etc/UTC\"} = datetime, duration, _time_zone_database) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n } = datetime\n\n {year, month, day, hour, minute, second, microsecond} =\n calendar.shift_naive_datetime(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n __duration__!(duration)\n )\n\n %DateTime{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: \"Etc/UTC\",\n zone_abbr: \"UTC\",\n std_offset: 0,\n utc_offset: 0\n }\n end\n\n def shift(%{calendar: calendar} = datetime, duration, time_zone_database) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n std_offset: std_offset,\n utc_offset: utc_offset,\n time_zone: time_zone\n } = datetime\n\n {year, month, day, hour, minute, second, {_, precision} = microsecond} =\n calendar.shift_naive_datetime(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n __duration__!(duration)\n )\n\n result =\n calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)\n |> apply_tz_offset(utc_offset + std_offset)\n |> shift_zone_for_iso_days_utc(calendar, precision, time_zone, time_zone_database)\n\n case result do\n {:ok, result_datetime} ->\n result_datetime\n\n {:error, error} ->\n raise ArgumentError,\n \"cannot shift #{inspect(datetime)} to #{inspect(duration)} (with time zone \" <>\n \"database #{inspect(time_zone_database)}), reason: #{inspect(error)}\"\n end\n end\n\n @doc false\n defdelegate __duration__!(params), to: Duration, as: :new!\n\n @doc \"\"\"\n Returns the given datetime with the microsecond field truncated to the given\n precision (`:microsecond`, `:millisecond` or `:second`).\n\n The given datetime is returned unchanged if it already has lower precision than\n the given precision.\n\n ## Examples\n\n iex> dt1 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: \"CET\",\n ...> hour: 11, minute: 45, second: 18, microsecond: {123456, 6},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Paris\"}\n iex> DateTime.truncate(dt1, :microsecond)\n #DateTime<2017-11-07 11:45:18.123456+01:00 CET Europe/Paris>\n\n iex> dt2 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: \"CET\",\n ...> hour: 11, minute: 45, second: 18, microsecond: {123456, 6},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Paris\"}\n iex> DateTime.truncate(dt2, :millisecond)\n #DateTime<2017-11-07 11:45:18.123+01:00 CET Europe/Paris>\n\n iex> dt3 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: \"CET\",\n ...> hour: 11, minute: 45, second: 18, microsecond: {123456, 6},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Paris\"}\n iex> DateTime.truncate(dt3, :second)\n #DateTime<2017-11-07 11:45:18+01:00 CET Europe/Paris>\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec truncate(Calendar.datetime(), :microsecond | :millisecond | :second) :: t()\n def truncate(%DateTime{microsecond: microsecond} = datetime, precision) do\n %{datetime | microsecond: Calendar.truncate(microsecond, precision)}\n end\n\n def truncate(%{} = datetime_map, precision) do\n truncate(from_map(datetime_map), precision)\n end\n\n @doc \"\"\"\n Converts a given `datetime` from one calendar to another.\n\n If it is not possible to convert unambiguously between the calendars\n (see `Calendar.compatible_calendars?/2`), an `{:error, :incompatible_calendars}` tuple\n is returned.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> DateTime.convert(dt1, Calendar.Holocene)\n {:ok, %DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,\n microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,\n time_zone: \"America/Manaus\", utc_offset: -14400, year: 12000,\n zone_abbr: \"AMT\"}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert(Calendar.datetime(), Calendar.calendar()) ::\n {:ok, t} | {:error, :incompatible_calendars}\n\n def convert(%DateTime{calendar: calendar} = datetime, calendar) do\n {:ok, datetime}\n end\n\n def convert(%{calendar: calendar} = datetime, calendar) do\n {:ok, from_map(datetime)}\n end\n\n def convert(%{calendar: dt_calendar, microsecond: {_, precision}} = datetime, calendar) do\n if Calendar.compatible_calendars?(dt_calendar, calendar) do\n result_datetime =\n datetime\n |> to_iso_days()\n |> from_iso_days(datetime, calendar, precision)\n\n {:ok, result_datetime}\n else\n {:error, :incompatible_calendars}\n end\n end\n\n @doc \"\"\"\n Converts a given `datetime` from one calendar to another.\n\n If it is not possible to convert unambiguously between the calendars\n (see `Calendar.compatible_calendars?/2`), an ArgumentError is raised.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"AMT\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: -14400, std_offset: 0, time_zone: \"America/Manaus\"}\n iex> DateTime.convert!(dt1, Calendar.Holocene)\n %DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,\n microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,\n time_zone: \"America/Manaus\", utc_offset: -14400, year: 12000,\n zone_abbr: \"AMT\"}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert!(Calendar.datetime(), Calendar.calendar()) :: t\n def convert!(datetime, calendar) do\n case convert(datetime, calendar) do\n {:ok, value} ->\n value\n\n {:error, :incompatible_calendars} ->\n raise ArgumentError,\n \"cannot convert #{inspect(datetime)} to target calendar #{inspect(calendar)}, \" <>\n \"reason: #{inspect(datetime.calendar)} and #{inspect(calendar)} have different \" <>\n \"day rollover moments, making this conversion ambiguous\"\n end\n end\n\n # Keep it multiline for proper function clause errors.\n defp to_iso_days(%{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }) do\n calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)\n end\n\n defp from_iso_days(iso_days, datetime, calendar, precision) do\n %{time_zone: time_zone, zone_abbr: zone_abbr, utc_offset: utc_offset, std_offset: std_offset} =\n datetime\n\n {year, month, day, hour, minute, second, {microsecond, _}} =\n calendar.naive_datetime_from_iso_days(iso_days)\n\n %DateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision},\n time_zone: time_zone,\n zone_abbr: zone_abbr,\n utc_offset: utc_offset,\n std_offset: std_offset\n }\n end\n\n defp apply_tz_offset(iso_days, 0) do\n iso_days\n end\n\n defp apply_tz_offset(iso_days, offset) do\n Calendar.ISO.add_day_fraction_to_iso_days(iso_days, -offset, 86400)\n end\n\n defp from_map(%{} = datetime_map) do\n %DateTime{\n year: datetime_map.year,\n month: datetime_map.month,\n day: datetime_map.day,\n hour: datetime_map.hour,\n minute: datetime_map.minute,\n second: datetime_map.second,\n microsecond: datetime_map.microsecond,\n time_zone: datetime_map.time_zone,\n zone_abbr: datetime_map.zone_abbr,\n utc_offset: datetime_map.utc_offset,\n std_offset: datetime_map.std_offset\n }\n end\n\n defp seconds_from_day_fraction({parts_in_day, @seconds_per_day}),\n do: parts_in_day\n\n defp seconds_from_day_fraction({parts_in_day, parts_per_day}),\n do: div(parts_in_day * @seconds_per_day, parts_per_day)\n\n defimpl String.Chars do\n def to_string(datetime) do\n %{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: time_zone,\n zone_abbr: zone_abbr,\n utc_offset: utc_offset,\n std_offset: std_offset\n } = datetime\n\n calendar.datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n zone_abbr,\n utc_offset,\n std_offset\n )\n end\n end\n\n defimpl Inspect do\n def inspect(datetime, _) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: time_zone,\n zone_abbr: zone_abbr,\n utc_offset: utc_offset,\n std_offset: std_offset,\n calendar: calendar\n } = datetime\n\n formatted =\n calendar.datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n zone_abbr,\n utc_offset,\n std_offset\n )\n\n case datetime do\n %{utc_offset: 0, std_offset: 0, time_zone: \"Etc/UTC\", year: year}\n when calendar != Calendar.ISO or year in -9999..9999 ->\n \"~U[\" <> formatted <> suffix(calendar) <> \"]\"\n\n _ ->\n \"#DateTime<\" <> formatted <> suffix(calendar) <> \">\"\n end\n end\n\n defp suffix(Calendar.ISO), do: \"\"\n defp suffix(calendar), do: \" \" <> inspect(calendar)\n end\nend\n" }, { "path": "lib/elixir/lib/calendar/duration.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\ndefmodule Duration do\n @moduledoc \"\"\"\n Struct and functions for handling durations.\n\n A `Duration` struct represents a collection of time scale units,\n allowing for manipulation and calculation of durations.\n\n Date and time scale units are represented as integers, allowing for\n both positive and negative values.\n\n Microseconds are represented using a tuple `{microsecond, precision}`.\n This ensures compatibility with other calendar types implementing time,\n such as `Time`, `DateTime`, and `NaiveDateTime`.\n\n ## Shifting\n\n The most common use of durations in Elixir's standard library is to\n \"shift\" the calendar types.\n\n iex> Date.shift(~D[2016-01-03], month: 2)\n ~D[2016-03-03]\n\n In the example above, `Date.shift/2` automatically converts the units\n into a `Duration` struct, although one can also be given directly:\n\n iex> Date.shift(~D[2016-01-03], Duration.new!(month: 2))\n ~D[2016-03-03]\n\n It is important to note that shifting is not an arithmetic operation.\n For example, adding `date + 1 month + 1 month` does not yield the same\n result as `date + 2 months`. Let's see an example:\n\n iex> ~D[2016-01-31] |> Date.shift(month: 1) |> Date.shift(month: 1)\n ~D[2016-03-29]\n\n iex> ~D[2016-01-31] |> Date.shift(month: 2)\n ~D[2016-03-31]\n\n As you can see above, the results differ, which explains why operations\n with durations are called \"shift\" rather than \"add\". This happens because,\n once we add one month to `2016-01-31`, we get `2016-02-29`. Then adding\n one extra month gives us `2016-03-29` instead of `2016-03-31`.\n\n In particular, when applying durations to `Calendar.ISO` types:\n\n * larger units (such as years and months) are applied before\n smaller ones (such as weeks, hours, days, and so on)\n\n * units are collapsed into months (`:year` and `:month`),\n seconds (`:week`, `:day`, `:hour`, `:minute`, `:second`)\n and microseconds (`:microsecond`) before they are applied\n\n * 1 year is equivalent to 12 months, 1 week is equivalent to 7 days.\n Therefore, 4 weeks _are not_ equivalent to 1 month\n\n * in case of non-existing dates, the results are rounded down to the\n nearest valid date\n\n As the `shift/2` functions are calendar aware, they are guaranteed to return\n valid date/times, considering leap years as well as DST in applicable time zones.\n\n ## Intervals\n\n Durations in Elixir can be combined with stream operations to build intervals.\n For example, to retrieve the next three Wednesdays starting from 17th April, 2024:\n\n iex> ~D[2024-04-17] |> Stream.iterate(&Date.shift(&1, week: 1)) |> Enum.take(3)\n [~D[2024-04-17], ~D[2024-04-24], ~D[2024-05-01]]\n\n However, once again, it is important to remember that shifting a duration is not\n arithmetic, so you may want to use the functions in this module depending on what\n you to achieve. Compare the results of both examples below:\n\n # Adding one month after the other\n iex> date = ~D[2016-01-31]\n iex> duration = Duration.new!(month: 1)\n iex> stream = Stream.iterate(date, fn prev_date -> Date.shift(prev_date, duration) end)\n iex> Enum.take(stream, 3)\n [~D[2016-01-31], ~D[2016-02-29], ~D[2016-03-29]]\n\n # Multiplying durations by an index\n iex> date = ~D[2016-01-31]\n iex> duration = Duration.new!(month: 1)\n iex> stream = Stream.from_index(fn i -> Date.shift(date, Duration.multiply(duration, i)) end)\n iex> Enum.take(stream, 3)\n [~D[2016-01-31], ~D[2016-02-29], ~D[2016-03-31]]\n\n The second example consistently points to the last day of the month,\n as it performs operations on the duration, rather than shifting date\n after date.\n\n ## Comparing durations\n\n In order to accurately compare durations, you need to either compare\n only certain fields or use a reference time instant. This is because\n some fields are relative to others. For example, you may say that\n 1 month is the same as 30 days, but if you add both of these durations\n to `~D[2015-02-01]`, you would get different results, as that month\n has only 28 days.\n\n Therefore, if you wish to compare durations, one option is to use\n `Date.shift/2` (or `DateTime.shift/2` or similar), and then compare\n the dates:\n\n iex> date = ~D[2015-02-01]\n iex> Date.compare(Date.shift(date, month: 1), Date.shift(date, day: 30))\n :lt\n\n Or alternatively convert the durations to a fixed unit by using `to_timeout/1`,\n which supports durations only up to weeks, raising if it has the month or year\n fields set.\n\n iex> to_timeout(hour: 24) == to_timeout(day: 1)\n true\n \"\"\"\n\n @moduledoc since: \"1.17.0\"\n\n @derive {Inspect, optional: [:year, :month, :week, :day, :hour, :minute, :second, :microsecond]}\n defstruct year: 0,\n month: 0,\n week: 0,\n day: 0,\n hour: 0,\n minute: 0,\n second: 0,\n microsecond: {0, 0}\n\n @typedoc \"\"\"\n The duration struct type.\n \"\"\"\n @type t :: %Duration{\n year: integer,\n month: integer,\n week: integer,\n day: integer,\n hour: integer,\n minute: integer,\n second: integer,\n microsecond: Calendar.microsecond()\n }\n\n @typedoc \"\"\"\n The unit pair type specifies a pair of a valid duration unit key and value.\n \"\"\"\n @type unit_pair ::\n {:year, integer}\n | {:month, integer}\n | {:week, integer}\n | {:day, integer}\n | {:hour, integer}\n | {:minute, integer}\n | {:second, integer}\n | {:microsecond, Calendar.microsecond()}\n\n @typedoc \"\"\"\n The duration type specifies a `%Duration{}` struct or a keyword list of valid duration unit pairs.\n \"\"\"\n @type duration :: t | [unit_pair]\n\n @typedoc \"\"\"\n Options for `Duration.to_string/2`.\n \"\"\"\n @type to_string_opts :: [\n units: [\n year: String.t(),\n month: String.t(),\n week: String.t(),\n day: String.t(),\n hour: String.t(),\n minute: String.t(),\n second: String.t()\n ],\n separator: String.t()\n ]\n\n @microseconds_per_second 1_000_000\n\n @doc \"\"\"\n Creates a new `Duration` struct from given `unit_pairs`.\n\n Raises an `ArgumentError` when called with invalid unit pairs.\n\n ## Examples\n\n iex> Duration.new!(year: 1, week: 3, hour: 4, second: 1)\n %Duration{year: 1, week: 3, hour: 4, second: 1}\n iex> Duration.new!(second: 1, microsecond: {1000, 6})\n %Duration{second: 1, microsecond: {1000, 6}}\n iex> Duration.new!(month: 2)\n %Duration{month: 2}\n\n \"\"\"\n @spec new!(duration()) :: t\n def new!(%Duration{} = duration) do\n duration\n end\n\n def new!(unit_pairs) do\n Enum.each(unit_pairs, &validate_unit!/1)\n struct!(Duration, unit_pairs)\n end\n\n defp validate_unit!({:microsecond, {ms, precision}})\n when is_integer(ms) and precision in 0..6 do\n :ok\n end\n\n defp validate_unit!({:microsecond, microsecond}) do\n raise ArgumentError,\n \"unsupported value #{inspect(microsecond)} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6\"\n end\n\n defp validate_unit!({unit, _value})\n when unit not in [:year, :month, :week, :day, :hour, :minute, :second] do\n raise ArgumentError,\n \"unknown unit #{inspect(unit)}. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond\"\n end\n\n defp validate_unit!({_unit, value}) when is_integer(value) do\n :ok\n end\n\n defp validate_unit!({unit, value}) do\n raise ArgumentError,\n \"unsupported value #{inspect(value)} for #{inspect(unit)}. Expected an integer\"\n end\n\n @doc \"\"\"\n Adds units of given durations `d1` and `d2`.\n\n Respects the highest microsecond precision of the two.\n\n ## Examples\n\n iex> Duration.add(Duration.new!(week: 2, day: 1), Duration.new!(day: 2))\n %Duration{week: 2, day: 3}\n iex> Duration.add(Duration.new!(microsecond: {400, 3}), Duration.new!(microsecond: {600, 6}))\n %Duration{microsecond: {1000, 6}}\n\n \"\"\"\n @spec add(t, t) :: t\n def add(%Duration{} = d1, %Duration{} = d2) do\n {m1, p1} = d1.microsecond\n {m2, p2} = d2.microsecond\n\n %Duration{\n year: d1.year + d2.year,\n month: d1.month + d2.month,\n week: d1.week + d2.week,\n day: d1.day + d2.day,\n hour: d1.hour + d2.hour,\n minute: d1.minute + d2.minute,\n second: d1.second + d2.second,\n microsecond: {m1 + m2, max(p1, p2)}\n }\n end\n\n @doc \"\"\"\n Subtracts units of given durations `d1` and `d2`.\n\n Respects the highest microsecond precision of the two.\n\n ## Examples\n\n iex> Duration.subtract(Duration.new!(week: 2, day: 1), Duration.new!(day: 2))\n %Duration{week: 2, day: -1}\n iex> Duration.subtract(Duration.new!(microsecond: {400, 6}), Duration.new!(microsecond: {600, 3}))\n %Duration{microsecond: {-200, 6}}\n\n \"\"\"\n @spec subtract(t, t) :: t\n def subtract(%Duration{} = d1, %Duration{} = d2) do\n {m1, p1} = d1.microsecond\n {m2, p2} = d2.microsecond\n\n %Duration{\n year: d1.year - d2.year,\n month: d1.month - d2.month,\n week: d1.week - d2.week,\n day: d1.day - d2.day,\n hour: d1.hour - d2.hour,\n minute: d1.minute - d2.minute,\n second: d1.second - d2.second,\n microsecond: {m1 - m2, max(p1, p2)}\n }\n end\n\n @doc \"\"\"\n Multiplies `duration` units by given `integer`.\n\n ## Examples\n\n iex> Duration.multiply(Duration.new!(day: 1, minute: 15, second: -10), 3)\n %Duration{day: 3, minute: 45, second: -30}\n iex> Duration.multiply(Duration.new!(microsecond: {200, 4}), 3)\n %Duration{microsecond: {600, 4}}\n\n \"\"\"\n @spec multiply(t, integer) :: t\n def multiply(%Duration{microsecond: {ms, p}} = duration, integer) when is_integer(integer) do\n %Duration{\n year: duration.year * integer,\n month: duration.month * integer,\n week: duration.week * integer,\n day: duration.day * integer,\n hour: duration.hour * integer,\n minute: duration.minute * integer,\n second: duration.second * integer,\n microsecond: {ms * integer, p}\n }\n end\n\n @doc \"\"\"\n Negates `duration` units.\n\n ## Examples\n\n iex> Duration.negate(Duration.new!(day: 1, minute: 15, second: -10))\n %Duration{day: -1, minute: -15, second: 10}\n iex> Duration.negate(Duration.new!(microsecond: {500000, 4}))\n %Duration{microsecond: {-500000, 4}}\n\n \"\"\"\n @spec negate(t) :: t\n def negate(%Duration{microsecond: {ms, p}} = duration) do\n %Duration{\n year: -duration.year,\n month: -duration.month,\n week: -duration.week,\n day: -duration.day,\n hour: -duration.hour,\n minute: -duration.minute,\n second: -duration.second,\n microsecond: {-ms, p}\n }\n end\n\n @doc \"\"\"\n Parses an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) formatted duration string to a `Duration` struct.\n\n Duration strings, as well as individual units, may be prefixed with plus/minus signs so that:\n\n - `-PT6H3M` parses as `%Duration{hour: -6, minute: -3}`\n - `-PT6H-3M` parses as `%Duration{hour: -6, minute: 3}`\n - `+PT6H3M` parses as `%Duration{hour: 6, minute: 3}`\n - `+PT6H-3M` parses as `%Duration{hour: 6, minute: -3}`\n\n Duration designators must be provided in order of magnitude: `P[n]Y[n]M[n]W[n]DT[n]H[n]M[n]S`.\n\n Only seconds may be specified with a decimal fraction, using either a comma or a full stop: `P1DT4,5S`.\n\n ## Examples\n\n iex> Duration.from_iso8601(\"P1Y2M3DT4H5M6S\")\n {:ok, %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}}\n iex> Duration.from_iso8601(\"P3Y-2MT3H\")\n {:ok, %Duration{year: 3, month: -2, hour: 3}}\n iex> Duration.from_iso8601(\"-PT10H-30M\")\n {:ok, %Duration{hour: -10, minute: 30}}\n iex> Duration.from_iso8601(\"PT4.650S\")\n {:ok, %Duration{second: 4, microsecond: {650000, 3}}}\n\n \"\"\"\n @spec from_iso8601(String.t()) :: {:ok, t} | {:error, atom}\n def from_iso8601(string) when is_binary(string) do\n case Calendar.ISO.parse_duration(string) do\n {:ok, duration} ->\n {:ok, new!(duration)}\n\n error ->\n error\n end\n end\n\n @doc \"\"\"\n Same as `from_iso8601/1` but raises an `ArgumentError`.\n\n ## Examples\n\n iex> Duration.from_iso8601!(\"P1Y2M3DT4H5M6S\")\n %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}\n iex> Duration.from_iso8601!(\"P10D\")\n %Duration{day: 10}\n\n \"\"\"\n @spec from_iso8601!(String.t()) :: t\n def from_iso8601!(string) when is_binary(string) do\n case from_iso8601(string) do\n {:ok, duration} ->\n duration\n\n {:error, reason} ->\n raise ArgumentError, ~s/failed to parse duration \"#{string}\". reason: #{inspect(reason)}/\n end\n end\n\n @doc \"\"\"\n Converts the given `duration` to a human readable representation.\n\n ## Options\n\n * `:units` - the units to be used alongside each duration component.\n The default units follow the ISO 80000-3 standard:\n\n [\n year: \"a\",\n month: \"mo\",\n week: \"wk\",\n day: \"d\",\n hour: \"h\",\n minute: \"min\",\n second: \"s\"\n ]\n\n * `:separator` - a string used to separate the distinct components. Defaults to `\" \"`.\n\n ## Examples\n\n iex> Duration.to_string(Duration.new!(second: 30))\n \"30s\"\n iex> Duration.to_string(Duration.new!(day: 40, hour: 12, minute: 42, second: 12))\n \"40d 12h 42min 12s\"\n\n By default, this function uses ISO 80000-3 units, which uses \"a\" for years.\n But you can customize all units via the units option:\n\n iex> Duration.to_string(Duration.new!(year: 3))\n \"3a\"\n iex> Duration.to_string(Duration.new!(year: 3), units: [year: \"y\"])\n \"3y\"\n\n You may also choose the separator:\n\n iex> Duration.to_string(Duration.new!(day: 40, hour: 12, minute: 42, second: 12), separator: \", \")\n \"40d, 12h, 42min, 12s\"\n\n A duration without components is rendered as \"0s\":\n\n iex> Duration.to_string(Duration.new!([]))\n \"0s\"\n\n Microseconds are rendered as part of seconds with the appropriate precision:\n\n iex> Duration.to_string(Duration.new!(second: 1, microsecond: {2_200, 3}))\n \"1.002s\"\n iex> Duration.to_string(Duration.new!(second: 1, microsecond: {-1_200_000, 4}))\n \"-0.2000s\"\n\n \"\"\"\n @doc since: \"1.18.0\"\n @spec to_string(t, to_string_opts) :: String.t()\n def to_string(%Duration{} = duration, opts \\\\ []) do\n units = Keyword.get(opts, :units, [])\n separator = Keyword.get(opts, :separator, \" \")\n\n case to_string_year(duration, [], units) do\n [] ->\n \"0\" <> Keyword.get(units, :second, \"s\")\n\n [part] ->\n IO.iodata_to_binary(part)\n\n parts ->\n parts |> Enum.reduce(&[&1, separator | &2]) |> IO.iodata_to_binary()\n end\n end\n\n defp to_string_part(0, _units, _key, _default, acc),\n do: acc\n\n defp to_string_part(x, units, key, default, acc),\n do: [[Integer.to_string(x) | Keyword.get(units, key, default)] | acc]\n\n defp to_string_year(%{year: year} = duration, acc, units) do\n to_string_month(duration, to_string_part(year, units, :year, \"a\", acc), units)\n end\n\n defp to_string_month(%{month: month} = duration, acc, units) do\n to_string_week(duration, to_string_part(month, units, :month, \"mo\", acc), units)\n end\n\n defp to_string_week(%{week: week} = duration, acc, units) do\n to_string_day(duration, to_string_part(week, units, :week, \"wk\", acc), units)\n end\n\n defp to_string_day(%{day: day} = duration, acc, units) do\n to_string_hour(duration, to_string_part(day, units, :day, \"d\", acc), units)\n end\n\n defp to_string_hour(%{hour: hour} = duration, acc, units) do\n to_string_minute(duration, to_string_part(hour, units, :hour, \"h\", acc), units)\n end\n\n defp to_string_minute(%{minute: minute} = duration, acc, units) do\n to_string_second(duration, to_string_part(minute, units, :minute, \"min\", acc), units)\n end\n\n defp to_string_second(%{second: 0, microsecond: {0, _}}, acc, _units) do\n acc\n end\n\n defp to_string_second(%{second: s, microsecond: {ms, p}}, acc, units) do\n [[second_component(s, ms, p) | Keyword.get(units, :second, \"s\")] | acc]\n end\n\n @doc \"\"\"\n Converts the given `duration` to an [ISO 8601-2:2019](https://en.wikipedia.org/wiki/ISO_8601) formatted string.\n\n This function implements the extension of ISO 8601:2019, allowing weeks to appear between months and days: `P3M3W3D`.\n\n ## Examples\n\n iex> Duration.to_iso8601(Duration.new!(year: 3))\n \"P3Y\"\n iex> Duration.to_iso8601(Duration.new!(day: 40, hour: 12, minute: 42, second: 12))\n \"P40DT12H42M12S\"\n iex> Duration.to_iso8601(Duration.new!(second: 30))\n \"PT30S\"\n\n iex> Duration.to_iso8601(Duration.new!([]))\n \"PT0S\"\n\n iex> Duration.to_iso8601(Duration.new!(second: 1, microsecond: {2_200, 3}))\n \"PT1.002S\"\n iex> Duration.to_iso8601(Duration.new!(second: 1, microsecond: {-1_200_000, 4}))\n \"PT-0.2000S\"\n \"\"\"\n\n @spec to_iso8601(t) :: String.t()\n def to_iso8601(%Duration{} = duration) do\n case {to_iso8601_duration_date(duration), to_iso8601_duration_time(duration)} do\n {[], []} -> \"PT0S\"\n {date, time} -> IO.iodata_to_binary([?P, date, time])\n end\n end\n\n defp to_iso8601_duration_date(%{year: 0, month: 0, week: 0, day: 0}) do\n []\n end\n\n defp to_iso8601_duration_date(%{year: year, month: month, week: week, day: day}) do\n [pair(year, ?Y), pair(month, ?M), pair(week, ?W), pair(day, ?D)]\n end\n\n defp to_iso8601_duration_time(%{hour: 0, minute: 0, second: 0, microsecond: {0, _}}) do\n []\n end\n\n defp to_iso8601_duration_time(%{hour: hour, minute: minute} = d) do\n [?T, pair(hour, ?H), pair(minute, ?M), second_component(d)]\n end\n\n defp second_component(%{second: 0, microsecond: {0, _}}) do\n []\n end\n\n defp second_component(%{second: second, microsecond: {ms, p}}) do\n [second_component(second, ms, p), ?S]\n end\n\n defp second_component(second, _ms, 0) do\n Integer.to_string(second)\n end\n\n defp second_component(second, ms, p) do\n total_ms = second * @microseconds_per_second + ms\n second = total_ms |> div(@microseconds_per_second) |> abs()\n ms = total_ms |> rem(@microseconds_per_second) |> abs()\n sign = if total_ms < 0, do: ?-, else: []\n\n [\n sign,\n Integer.to_string(second),\n ?.,\n Calendar.ISO.microseconds_to_iodata(ms, p)\n ]\n end\n\n @compile {:inline, pair: 2}\n defp pair(0, _key), do: []\n defp pair(num, key), do: [Integer.to_string(num), key]\nend\n" }, { "path": "lib/elixir/lib/calendar/iso.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Calendar.ISO do\n @moduledoc \"\"\"\n The default calendar implementation, a Gregorian calendar following ISO 8601.\n\n This calendar implements a proleptic Gregorian calendar and\n is therefore compatible with the calendar used in most countries\n today. The proleptic means the Gregorian rules for leap years are\n applied for all time, consequently the dates give different results\n before the year 1583 from when the Gregorian calendar was adopted.\n\n ## ISO 8601 compliance\n\n The ISO 8601 specification is feature-rich, but allows applications\n to selectively implement most parts of it. The choices Elixir makes\n are catalogued below.\n\n ### Features\n\n The standard library supports a minimal set of possible ISO 8601 features.\n Specifically, the parser only supports calendar dates and does not support\n ordinal and week formats. Additionally, it supports parsing ISO 8601\n formatted durations, including negative time units and fractional seconds.\n\n By default Elixir only parses extended-formatted date/times. You can opt-in\n to parse basic-formatted date/times.\n\n `NaiveDateTime.to_iso8601/2` and `DateTime.to_iso8601/2` allow you to produce\n either basic or extended formatted strings, and `Calendar.strftime/2` allows\n you to format datetimes however else you desire.\n\n Elixir does not support reduced accuracy formats (for example, a date without\n the day component) nor decimal precisions in the lowest component (such as\n `10:01:25,5`).\n\n #### Examples\n\n Elixir expects the extended format by default when parsing:\n\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_naive_datetime(\"20150123T235007\")\n {:error, :invalid_format}\n\n Parsing can be restricted to basic if desired:\n\n iex> Calendar.ISO.parse_naive_datetime(\"20150123T235007Z\", :basic)\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_naive_datetime(\"20150123T235007Z\", :extended)\n {:error, :invalid_format}\n\n Only calendar dates are supported in parsing; ordinal and week dates are not.\n\n iex> Calendar.ISO.parse_date(\"2015-04-15\")\n {:ok, {2015, 4, 15}}\n iex> Calendar.ISO.parse_date(\"2015-105\")\n {:error, :invalid_format}\n iex> Calendar.ISO.parse_date(\"2015-W16\")\n {:error, :invalid_format}\n iex> Calendar.ISO.parse_date(\"2015-W016-3\")\n {:error, :invalid_format}\n\n Years, months, days, hours, minutes, and seconds must be fully specified:\n\n iex> Calendar.ISO.parse_date(\"2015-04-15\")\n {:ok, {2015, 4, 15}}\n iex> Calendar.ISO.parse_date(\"2015-04\")\n {:error, :invalid_format}\n iex> Calendar.ISO.parse_date(\"2015\")\n {:error, :invalid_format}\n\n iex> Calendar.ISO.parse_time(\"23:50:07.0123456\")\n {:ok, {23, 50, 7, {12345, 6}}}\n iex> Calendar.ISO.parse_time(\"23:50:07\")\n {:ok, {23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_time(\"23:50\")\n {:error, :invalid_format}\n iex> Calendar.ISO.parse_time(\"23\")\n {:error, :invalid_format}\n\n ### Extensions\n\n The parser and formatter adopt one ISO 8601 extension: extended year notation.\n\n This allows dates to be prefixed with a `+` or `-` sign, extending the range of\n expressible years from the default (`0000..9999`) to `-9999..9999`. Elixir still\n restricts years in this format to four digits.\n\n #### Examples\n\n iex> Calendar.ISO.parse_date(\"-2015-01-23\")\n {:ok, {-2015, 1, 23}}\n iex> Calendar.ISO.parse_date(\"+2015-01-23\")\n {:ok, {2015, 1, 23}}\n\n iex> Calendar.ISO.parse_naive_datetime(\"-2015-01-23 23:50:07\")\n {:ok, {-2015, 1, 23, 23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_naive_datetime(\"+2015-01-23 23:50:07\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n\n iex> Calendar.ISO.parse_utc_datetime(\"-2015-01-23 23:50:07Z\")\n {:ok, {-2015, 1, 23, 23, 50, 7, {0, 0}}, 0}\n iex> Calendar.ISO.parse_utc_datetime(\"+2015-01-23 23:50:07Z\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}\n\n ### Additions\n\n ISO 8601 does not allow a whitespace instead of `T` as a separator\n between date and times, both when parsing and formatting.\n This is a common enough representation, Elixir allows it during parsing.\n\n The formatting of dates in `NaiveDateTime.to_iso8601/1` and `DateTime.to_iso8601/1`\n do produce specification-compliant string representations using the `T` separator.\n\n #### Examples\n\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07.0123456\")\n {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}}\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07.0123456\")\n {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}}\n\n iex> Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07.0123456Z\")\n {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}, 0}\n iex> Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07.0123456Z\")\n {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}, 0}\n\n \"\"\"\n\n @behaviour Calendar\n\n @unix_epoch 62_167_219_200\n unix_start = (315_537_897_600 + @unix_epoch) * -1_000_000\n unix_end = 315_569_519_999_999_999 - @unix_epoch * 1_000_000\n @unix_range_microseconds unix_start..unix_end\n\n defguardp is_format(term) when term in [:basic, :extended]\n\n @typedoc \"\"\"\n \"Before the Current Era\" or \"Before the Common Era\" (BCE), for those years less than `1`.\n \"\"\"\n @type bce :: 0\n\n @typedoc \"\"\"\n The \"Current Era\" or the \"Common Era\" (CE) which starts in year `1`.\n \"\"\"\n @type ce :: 1\n\n @typedoc \"\"\"\n The calendar era.\n\n The ISO calendar has two eras:\n * [CE](`t:ce/0`) - which starts in year `1` and is defined as era `1`.\n * [BCE](`t:bce/0`) - for those years less than `1` and is defined as era `0`.\n \"\"\"\n @type era :: bce | ce\n @type year :: -9999..9999\n @type month :: 1..12\n @type day :: 1..31\n @type hour :: 0..23\n @type minute :: 0..59\n @type second :: 0..59\n @type weekday :: :monday | :tuesday | :wednesday | :thursday | :friday | :saturday | :sunday\n @type utc_offset :: integer\n @type format :: :basic | :extended\n\n @typedoc \"\"\"\n Microseconds with stored precision.\n\n The precision represents the number of digits that must be used when\n representing the microseconds to external format. If the precision is 0,\n it means microseconds must be skipped.\n \"\"\"\n @type microsecond :: {0..999_999, 0..6}\n\n @typedoc \"\"\"\n Integer that represents the day of the week, where 1 is Monday and 7 is Sunday.\n \"\"\"\n @type day_of_week :: 1..7\n\n @type day_of_year :: 1..366\n @type quarter_of_year :: 1..4\n @type year_of_era :: {1..10_000, era}\n\n @seconds_per_minute 60\n @seconds_per_hour 60 * 60\n # Note that this does *not* handle leap seconds.\n @seconds_per_day 24 * 60 * 60\n @last_second_of_the_day @seconds_per_day - 1\n @microseconds_per_second 1_000_000\n @parts_per_day @seconds_per_day * @microseconds_per_second\n\n @datetime_seps [?\\s, ?T]\n @ext_date_sep ?-\n @ext_time_sep ?:\n\n # The ISO epoch starts, in this implementation,\n # with ~D[0000-01-01]. Era \"1\" starts\n # on ~D[0001-01-01] which is 366 days later.\n @iso_epoch 366\n\n # Constants for date calculations using 400-year era cycles.\n # The algorithm uses a March-based year where March 1 is day 0.\n # Reference: Neri C, Schneider L. \"Euclidean Affine Functions and\n # their Application to Calendar Algorithms\". Softw Pract Exper. 2022.\n @days_per_year 365\n @years_per_era 400\n @days_per_era @years_per_era * @days_per_year + 97\n @days_per_4_years 4 * @days_per_year\n @days_per_100_years 100 * @days_per_year + 24\n @march_1_offset 31 + 29\n @unix_epoch_days 719_528\n\n # Month calculation constants: in a March-based year, each 5-month\n # cycle has exactly 153 days (31+30+31+30+31 or 31+30+31+30+31).\n @days_per_5_months 153\n @months_per_cycle 5\n\n [match_basic_date, match_ext_date, guard_date, read_date] =\n quote do\n [\n <>,\n <>,\n y1 >= ?0 and y1 <= ?9 and y2 >= ?0 and y2 <= ?9 and y3 >= ?0 and y3 <= ?9 and y4 >= ?0 and\n y4 <= ?9 and m1 >= ?0 and m1 <= ?9 and m2 >= ?0 and m2 <= ?9 and d1 >= ?0 and d1 <= ?9 and\n d2 >= ?0 and d2 <= ?9,\n {\n (y1 - ?0) * 1000 + (y2 - ?0) * 100 + (y3 - ?0) * 10 + (y4 - ?0),\n (m1 - ?0) * 10 + (m2 - ?0),\n (d1 - ?0) * 10 + (d2 - ?0)\n }\n ]\n end\n\n [match_basic_time, match_ext_time, guard_time, read_time] =\n quote do\n [\n <>,\n <>,\n h1 >= ?0 and h1 <= ?9 and h2 >= ?0 and h2 <= ?9 and i1 >= ?0 and i1 <= ?9 and i2 >= ?0 and\n i2 <= ?9 and s1 >= ?0 and s1 <= ?9 and s2 >= ?0 and s2 <= ?9,\n {\n (h1 - ?0) * 10 + (h2 - ?0),\n (i1 - ?0) * 10 + (i2 - ?0),\n (s1 - ?0) * 10 + (s2 - ?0)\n }\n ]\n end\n\n defguardp is_year(year) when is_integer(year)\n defguardp is_year_BCE(year) when year <= 0\n defguardp is_year_CE(year) when year >= 1\n defguardp is_month(month) when month in 1..12\n defguardp is_day(day) when day in 1..31\n defguardp is_hour(hour) when hour in 0..23\n defguardp is_minute(minute) when minute in 0..59\n defguardp is_second(second) when second in 0..59\n\n defguardp is_microsecond(microsecond, precision)\n when microsecond in 0..999_999 and precision in 0..6\n\n defguardp is_time_zone(term) when is_binary(term)\n defguardp is_zone_abbr(term) when is_binary(term)\n defguardp is_utc_offset(offset) when is_integer(offset)\n defguardp is_std_offset(offset) when is_integer(offset)\n\n @doc \"\"\"\n Converts a `t:System.time_unit/0` to precision.\n\n Integer-based time units always get maximum precision.\n\n ## Examples\n\n iex> Calendar.ISO.time_unit_to_precision(:nanosecond)\n 6\n\n iex> Calendar.ISO.time_unit_to_precision(:second)\n 0\n\n iex> Calendar.ISO.time_unit_to_precision(1)\n 6\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec time_unit_to_precision(System.time_unit()) :: 0..6\n def time_unit_to_precision(:nanosecond), do: 6\n def time_unit_to_precision(:microsecond), do: 6\n def time_unit_to_precision(:millisecond), do: 3\n def time_unit_to_precision(:second), do: 0\n def time_unit_to_precision(int) when is_integer(int), do: 6\n\n @doc \"\"\"\n Parses a time `string` in the `:extended` format.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_time(\"23:50:07\")\n {:ok, {23, 50, 7, {0, 0}}}\n\n iex> Calendar.ISO.parse_time(\"23:50:07Z\")\n {:ok, {23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_time(\"T23:50:07Z\")\n {:ok, {23, 50, 7, {0, 0}}}\n\n \"\"\"\n @doc since: \"1.10.0\"\n @impl true\n @spec parse_time(String.t()) ::\n {:ok, {hour, minute, second, microsecond}}\n | {:error, atom}\n def parse_time(string) when is_binary(string),\n do: parse_time(string, :extended)\n\n @doc \"\"\"\n Parses a time `string` according to a given `format`.\n\n The `format` can either be `:basic` or `:extended`.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_time(\"235007\", :basic)\n {:ok, {23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_time(\"235007\", :extended)\n {:error, :invalid_format}\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec parse_time(String.t(), format) ::\n {:ok, {hour, minute, second, microsecond}}\n | {:error, atom}\n def parse_time(string, format) when is_binary(string) and is_format(format) do\n case string do\n \"T\" <> rest -> do_parse_time(rest, format)\n _ -> do_parse_time(string, format)\n end\n end\n\n defp do_parse_time(<>, :basic)\n when unquote(guard_time) do\n {hour, minute, second} = unquote(read_time)\n parse_formatted_time(hour, minute, second, rest)\n end\n\n defp do_parse_time(<>, :extended)\n when unquote(guard_time) do\n {hour, minute, second} = unquote(read_time)\n parse_formatted_time(hour, minute, second, rest)\n end\n\n defp do_parse_time(_, _) do\n {:error, :invalid_format}\n end\n\n defp parse_formatted_time(hour, minute, second, rest) do\n with {microsecond, rest} <- parse_microsecond(rest),\n {_offset, \"\"} <- parse_offset(rest) do\n if valid_time?(hour, minute, second, microsecond) do\n {:ok, {hour, minute, second, microsecond}}\n else\n {:error, :invalid_time}\n end\n else\n _ -> {:error, :invalid_format}\n end\n end\n\n @doc \"\"\"\n Parses a date `string` in the `:extended` format.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_date(\"2015-01-23\")\n {:ok, {2015, 1, 23}}\n\n iex> Calendar.ISO.parse_date(\"2015:01:23\")\n {:error, :invalid_format}\n iex> Calendar.ISO.parse_date(\"2015-01-32\")\n {:error, :invalid_date}\n\n \"\"\"\n @doc since: \"1.10.0\"\n @impl true\n @spec parse_date(String.t()) ::\n {:ok, {year, month, day}}\n | {:error, atom}\n def parse_date(string) when is_binary(string),\n do: parse_date(string, :extended)\n\n @doc \"\"\"\n Parses a date `string` according to a given `format`.\n\n The `format` can either be `:basic` or `:extended`.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_date(\"20150123\", :basic)\n {:ok, {2015, 1, 23}}\n iex> Calendar.ISO.parse_date(\"20150123\", :extended)\n {:error, :invalid_format}\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec parse_date(String.t(), format) ::\n {:ok, {year, month, day}}\n | {:error, atom}\n def parse_date(string, format) when is_binary(string) and is_format(format),\n do: parse_date_guarded(string, format)\n\n defp parse_date_guarded(\"-\" <> string, format),\n do: do_parse_date(string, -1, format)\n\n defp parse_date_guarded(\"+\" <> string, format),\n do: do_parse_date(string, 1, format)\n\n defp parse_date_guarded(string, format),\n do: do_parse_date(string, 1, format)\n\n defp do_parse_date(unquote(match_basic_date), multiplier, :basic) when unquote(guard_date) do\n {year, month, day} = unquote(read_date)\n parse_formatted_date(year, month, day, multiplier)\n end\n\n defp do_parse_date(unquote(match_ext_date), multiplier, :extended) when unquote(guard_date) do\n {year, month, day} = unquote(read_date)\n parse_formatted_date(year, month, day, multiplier)\n end\n\n defp do_parse_date(_, _, _) do\n {:error, :invalid_format}\n end\n\n defp parse_formatted_date(year, month, day, multiplier) do\n year = multiplier * year\n\n if valid_date?(year, month, day) do\n {:ok, {year, month, day}}\n else\n {:error, :invalid_date}\n end\n end\n\n @doc \"\"\"\n Parses a naive datetime `string` in the `:extended` format.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07Z\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07-02:30\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07.0\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 1}}}\n iex> Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07,0123456\")\n {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}}\n\n \"\"\"\n @doc since: \"1.10.0\"\n @impl true\n @spec parse_naive_datetime(String.t()) ::\n {:ok, {year, month, day, hour, minute, second, microsecond}}\n | {:error, atom}\n def parse_naive_datetime(string) when is_binary(string),\n do: parse_naive_datetime(string, :extended)\n\n @doc \"\"\"\n Parses a naive datetime `string` according to a given `format`.\n\n The `format` can either be `:basic` or `:extended`.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_naive_datetime(\"20150123 235007\", :basic)\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n iex> Calendar.ISO.parse_naive_datetime(\"20150123 235007\", :extended)\n {:error, :invalid_format}\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec parse_naive_datetime(String.t(), format) ::\n {:ok, {year, month, day, hour, minute, second, microsecond}}\n | {:error, atom}\n def parse_naive_datetime(string, format) when is_binary(string) and is_format(format),\n do: parse_naive_datetime_guarded(string, format)\n\n defp parse_naive_datetime_guarded(\"-\" <> string, format),\n do: do_parse_naive_datetime(string, -1, format)\n\n defp parse_naive_datetime_guarded(\"+\" <> string, format),\n do: do_parse_naive_datetime(string, 1, format)\n\n defp parse_naive_datetime_guarded(string, format),\n do: do_parse_naive_datetime(string, 1, format)\n\n defp do_parse_naive_datetime(\n <>,\n multiplier,\n :basic\n )\n when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do\n {year, month, day} = unquote(read_date)\n {hour, minute, second} = unquote(read_time)\n parse_formatted_naive_datetime(year, month, day, hour, minute, second, rest, multiplier)\n end\n\n defp do_parse_naive_datetime(\n <>,\n multiplier,\n :extended\n )\n when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do\n {year, month, day} = unquote(read_date)\n {hour, minute, second} = unquote(read_time)\n parse_formatted_naive_datetime(year, month, day, hour, minute, second, rest, multiplier)\n end\n\n defp do_parse_naive_datetime(_, _, _) do\n {:error, :invalid_format}\n end\n\n defp parse_formatted_naive_datetime(year, month, day, hour, minute, second, rest, multiplier) do\n year = multiplier * year\n\n with {microsecond, rest} <- parse_microsecond(rest),\n {_offset, \"\"} <- parse_offset(rest) do\n cond do\n not valid_date?(year, month, day) ->\n {:error, :invalid_date}\n\n not valid_time?(hour, minute, second, microsecond) ->\n {:error, :invalid_time}\n\n true ->\n {:ok, {year, month, day, hour, minute, second, microsecond}}\n end\n else\n _ -> {:error, :invalid_format}\n end\n end\n\n @doc \"\"\"\n Parses a UTC datetime `string` in the `:extended` format.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07Z\")\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}\n\n iex> Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07+02:30\")\n {:ok, {2015, 1, 23, 21, 20, 7, {0, 0}}, 9000}\n\n iex> Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07\")\n {:error, :missing_offset}\n\n \"\"\"\n @doc since: \"1.10.0\"\n @impl true\n @spec parse_utc_datetime(String.t()) ::\n {:ok, {year, month, day, hour, minute, second, microsecond}, utc_offset}\n | {:error, atom}\n def parse_utc_datetime(string) when is_binary(string),\n do: parse_utc_datetime(string, :extended)\n\n @doc \"\"\"\n Parses a UTC datetime `string` according to a given `format`.\n\n The `format` can either be `:basic` or `:extended`.\n\n For more information on supported strings, see how this\n module implements [ISO 8601](#module-iso-8601-compliance).\n\n ## Examples\n\n iex> Calendar.ISO.parse_utc_datetime(\"20150123 235007Z\", :basic)\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}\n iex> Calendar.ISO.parse_utc_datetime(\"20150123 235007Z\", :extended)\n {:error, :invalid_format}\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec parse_utc_datetime(String.t(), format) ::\n {:ok, {year, month, day, hour, minute, second, microsecond}, utc_offset}\n | {:error, atom}\n def parse_utc_datetime(string, format) when is_binary(string) and is_format(format),\n do: parse_utc_datetime_guarded(string, format)\n\n defp parse_utc_datetime_guarded(\"-\" <> string, format),\n do: do_parse_utc_datetime(string, -1, format)\n\n defp parse_utc_datetime_guarded(\"+\" <> string, format),\n do: do_parse_utc_datetime(string, 1, format)\n\n defp parse_utc_datetime_guarded(string, format),\n do: do_parse_utc_datetime(string, 1, format)\n\n defp do_parse_utc_datetime(\n <>,\n multiplier,\n :basic\n )\n when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do\n {year, month, day} = unquote(read_date)\n {hour, minute, second} = unquote(read_time)\n parse_formatted_utc_datetime(year, month, day, hour, minute, second, rest, multiplier)\n end\n\n defp do_parse_utc_datetime(\n <>,\n multiplier,\n :extended\n )\n when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do\n {year, month, day} = unquote(read_date)\n {hour, minute, second} = unquote(read_time)\n parse_formatted_utc_datetime(year, month, day, hour, minute, second, rest, multiplier)\n end\n\n defp do_parse_utc_datetime(_, _, _) do\n {:error, :invalid_format}\n end\n\n defp parse_formatted_utc_datetime(year, month, day, hour, minute, second, rest, multiplier) do\n year = multiplier * year\n\n with {microsecond, rest} <- parse_microsecond(rest),\n {offset, \"\"} <- parse_offset(rest) do\n cond do\n not valid_date?(year, month, day) ->\n {:error, :invalid_date}\n\n not valid_time?(hour, minute, second, microsecond) ->\n {:error, :invalid_time}\n\n offset == 0 ->\n {:ok, {year, month, day, hour, minute, second, microsecond}, offset}\n\n is_nil(offset) ->\n {:error, :missing_offset}\n\n true ->\n day_fraction = time_to_day_fraction(hour, minute, second, {0, 0})\n\n {{year, month, day}, {hour, minute, second, _}} =\n case add_day_fraction_to_iso_days({0, day_fraction}, -offset, 86_400) do\n {0, day_fraction} ->\n {{year, month, day}, time_from_day_fraction(day_fraction)}\n\n {extra_days, day_fraction} ->\n base_days = date_to_iso_days(year, month, day)\n {date_from_iso_days(base_days + extra_days), time_from_day_fraction(day_fraction)}\n end\n\n {:ok, {year, month, day, hour, minute, second, microsecond}, offset}\n end\n else\n _ -> {:error, :invalid_format}\n end\n end\n\n @doc \"\"\"\n Parses an ISO 8601 formatted duration string to a list of `Duration` compabitble unit pairs.\n\n See `Duration.from_iso8601/1`.\n \"\"\"\n @doc since: \"1.17.0\"\n @spec parse_duration(String.t()) :: {:ok, [Duration.unit_pair()]} | {:error, atom}\n def parse_duration(\"P\" <> string) when byte_size(string) > 0 do\n parse_duration_date(string, [], year: ?Y, month: ?M, week: ?W, day: ?D)\n end\n\n def parse_duration(\"+P\" <> string) when byte_size(string) > 0 do\n parse_duration_date(string, [], year: ?Y, month: ?M, week: ?W, day: ?D)\n end\n\n def parse_duration(\"-P\" <> string) when byte_size(string) > 0 do\n with {:ok, fields} <- parse_duration_date(string, [], year: ?Y, month: ?M, week: ?W, day: ?D) do\n {:ok,\n Enum.map(fields, fn\n {:microsecond, {value, precision}} -> {:microsecond, {-value, precision}}\n {unit, value} -> {unit, -value}\n end)}\n end\n end\n\n def parse_duration(_) do\n {:error, :invalid_duration}\n end\n\n defp parse_duration_date(\"\", acc, _allowed), do: {:ok, acc}\n\n defp parse_duration_date(\"T\" <> string, acc, _allowed) when byte_size(string) > 0 do\n parse_duration_time(string, acc, hour: ?H, minute: ?M, second: ?S)\n end\n\n defp parse_duration_date(string, acc, allowed) do\n with {integer, <>} <- Integer.parse(string),\n {key, allowed} <- find_unit(allowed, next) do\n parse_duration_date(rest, [{key, integer} | acc], allowed)\n else\n _ -> {:error, :invalid_date_component}\n end\n end\n\n defp parse_duration_time(\"\", acc, _allowed), do: {:ok, acc}\n\n defp parse_duration_time(string, acc, allowed) do\n case Integer.parse(string) do\n {second, <> = rest} when delimiter in [?., ?,] ->\n case parse_microsecond(rest) do\n {{ms, precision}, \"S\"} ->\n ms =\n case string do\n \"-\" <> _ ->\n -ms\n\n _ ->\n ms\n end\n\n {:ok, [second: second, microsecond: {ms, precision}] ++ acc}\n\n _ ->\n {:error, :invalid_time_component}\n end\n\n {integer, <>} ->\n case find_unit(allowed, next) do\n {key, allowed} -> parse_duration_time(rest, [{key, integer} | acc], allowed)\n false -> {:error, :invalid_time_component}\n end\n\n _ ->\n {:error, :invalid_time_component}\n end\n end\n\n defp find_unit([{key, unit} | rest], unit), do: {key, rest}\n defp find_unit([_ | rest], unit), do: find_unit(rest, unit)\n defp find_unit([], _unit), do: false\n\n @doc \"\"\"\n Returns the `t:Calendar.iso_days/0` format of the specified date.\n\n ## Examples\n\n iex> Calendar.ISO.naive_datetime_to_iso_days(0, 1, 1, 0, 0, 0, {0, 6})\n {0, {0, 86400000000}}\n iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 12, 0, 0, {0, 6})\n {730485, {43200000000, 86400000000}}\n iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 13, 0, 0, {0, 6})\n {730485, {46800000000, 86400000000}}\n iex> Calendar.ISO.naive_datetime_to_iso_days(-1, 1, 1, 0, 0, 0, {0, 6})\n {-365, {0, 86400000000}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @impl true\n @spec naive_datetime_to_iso_days(\n Calendar.year(),\n Calendar.month(),\n Calendar.day(),\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond()\n ) :: Calendar.iso_days()\n def naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) do\n {date_to_iso_days(year, month, day), time_to_day_fraction(hour, minute, second, microsecond)}\n end\n\n @doc \"\"\"\n Converts the `t:Calendar.iso_days/0` format to the datetime format specified by this calendar.\n\n ## Examples\n\n iex> Calendar.ISO.naive_datetime_from_iso_days({0, {0, 86_400}})\n {0, 1, 1, 0, 0, 0, {0, 6}}\n iex> Calendar.ISO.naive_datetime_from_iso_days({730_485, {0, 86_400}})\n {2000, 1, 1, 0, 0, 0, {0, 6}}\n iex> Calendar.ISO.naive_datetime_from_iso_days({730_485, {43_200, 86_400}})\n {2000, 1, 1, 12, 0, 0, {0, 6}}\n iex> Calendar.ISO.naive_datetime_from_iso_days({-365, {0, 86_400_000_000}})\n {-1, 1, 1, 0, 0, 0, {0, 6}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec naive_datetime_from_iso_days(Calendar.iso_days()) :: {\n Calendar.year(),\n Calendar.month(),\n Calendar.day(),\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond()\n }\n @impl true\n def naive_datetime_from_iso_days({days, day_fraction}) do\n {year, month, day} = date_from_iso_days(days)\n {hour, minute, second, microsecond} = time_from_day_fraction(day_fraction)\n {year, month, day, hour, minute, second, microsecond}\n end\n\n @doc \"\"\"\n Returns the normalized day fraction of the specified time.\n\n ## Examples\n\n iex> Calendar.ISO.time_to_day_fraction(0, 0, 0, {0, 6})\n {0, 86400000000}\n iex> Calendar.ISO.time_to_day_fraction(12, 34, 56, {123, 6})\n {45296000123, 86400000000}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @impl true\n @spec time_to_day_fraction(\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond()\n ) :: Calendar.day_fraction()\n def time_to_day_fraction(0, 0, 0, {0, _}) do\n {0, @parts_per_day}\n end\n\n def time_to_day_fraction(hour, minute, second, {microsecond, _}) do\n combined_seconds = hour * @seconds_per_hour + minute * @seconds_per_minute + second\n {combined_seconds * @microseconds_per_second + microsecond, @parts_per_day}\n end\n\n @doc \"\"\"\n Converts a day fraction to this Calendar's representation of time.\n\n ## Examples\n\n iex> Calendar.ISO.time_from_day_fraction({1, 2})\n {12, 0, 0, {0, 6}}\n iex> Calendar.ISO.time_from_day_fraction({13, 24})\n {13, 0, 0, {0, 6}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @impl true\n @spec time_from_day_fraction(Calendar.day_fraction()) ::\n {hour(), minute(), second(), microsecond()}\n def time_from_day_fraction({0, _}) do\n {0, 0, 0, {0, 6}}\n end\n\n def time_from_day_fraction({parts_in_day, parts_per_day}) do\n total_microseconds = divide_by_parts_per_day(parts_in_day, parts_per_day)\n\n {hours, rest_microseconds1} =\n div_rem(total_microseconds, @seconds_per_hour * @microseconds_per_second)\n\n {minutes, rest_microseconds2} =\n div_rem(rest_microseconds1, @seconds_per_minute * @microseconds_per_second)\n\n {seconds, microseconds} = div_rem(rest_microseconds2, @microseconds_per_second)\n {hours, minutes, seconds, {microseconds, 6}}\n end\n\n defp divide_by_parts_per_day(parts_in_day, @parts_per_day), do: parts_in_day\n\n defp divide_by_parts_per_day(parts_in_day, parts_per_day),\n do: div(parts_in_day * @parts_per_day, parts_per_day)\n\n # Converts year, month, day to count of days since 0000-01-01.\n @doc false\n def date_to_iso_days(0, 1, 1), do: 0\n def date_to_iso_days(1970, 1, 1), do: @unix_epoch_days\n\n def date_to_iso_days(year, month, day) do\n ensure_day_in_month!(year, month, day)\n\n y = if month <= 2, do: year - 1, else: year\n era = if y >= 0, do: div(y, @years_per_era), else: div(y - 399, @years_per_era)\n year_of_era = y - era * @years_per_era\n month_prime = if month > 2, do: month - 3, else: month + 9\n day_of_year = div(@days_per_5_months * month_prime + 2, @months_per_cycle) + day - 1\n\n day_of_era =\n @days_per_year * year_of_era + div(year_of_era, 4) - div(year_of_era, 100) + day_of_year\n\n era * @days_per_era + day_of_era + @march_1_offset\n end\n\n # Converts count of days since 0000-01-01 to {year, month, day} tuple.\n @doc false\n def date_from_iso_days(days) do\n z = days - @march_1_offset\n era = if z >= 0, do: div(z, @days_per_era), else: div(z - @days_per_era + 1, @days_per_era)\n day_of_era = z - era * @days_per_era\n\n year_of_era =\n div(\n day_of_era - div(day_of_era, @days_per_4_years) + div(day_of_era, @days_per_100_years) -\n div(day_of_era, @days_per_era - 1),\n @days_per_year\n )\n\n day_of_year =\n day_of_era -\n (@days_per_year * year_of_era + div(year_of_era, 4) - div(year_of_era, 100))\n\n month_prime = div(@months_per_cycle * day_of_year + 2, @days_per_5_months)\n day = day_of_year - div(@days_per_5_months * month_prime + 2, @months_per_cycle) + 1\n month = if month_prime < 10, do: month_prime + 3, else: month_prime - 9\n year = year_of_era + era * @years_per_era\n year = if month <= 2, do: year + 1, else: year\n\n {year, month, day}\n end\n\n defp div_rem(int1, int2) do\n div = div(int1, int2)\n rem = int1 - div * int2\n\n if rem >= 0 do\n {div, rem}\n else\n {div - 1, rem + int2}\n end\n end\n\n defp floor_div_positive_divisor(int1, int2) when int1 >= 0, do: div(int1, int2)\n defp floor_div_positive_divisor(int1, int2), do: -div(-int1 - 1, int2) - 1\n\n @doc \"\"\"\n Returns how many days there are in the given year-month.\n\n ## Examples\n\n iex> Calendar.ISO.days_in_month(1900, 1)\n 31\n iex> Calendar.ISO.days_in_month(1900, 2)\n 28\n iex> Calendar.ISO.days_in_month(2000, 2)\n 29\n iex> Calendar.ISO.days_in_month(2001, 2)\n 28\n iex> Calendar.ISO.days_in_month(2004, 2)\n 29\n iex> Calendar.ISO.days_in_month(2004, 4)\n 30\n iex> Calendar.ISO.days_in_month(-1, 5)\n 31\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec days_in_month(year, month) :: 28..31\n @impl true\n def days_in_month(year, month) when is_year(year) and is_month(month) do\n days_in_month_guarded(year, month)\n end\n\n defp days_in_month_guarded(year, 2) do\n if leap_year?(year), do: 29, else: 28\n end\n\n defp days_in_month_guarded(_, month) when month in [4, 6, 9, 11], do: 30\n defp days_in_month_guarded(_, _), do: 31\n\n @doc \"\"\"\n Returns how many months there are in the given year.\n\n ## Example\n\n iex> Calendar.ISO.months_in_year(2004)\n 12\n\n \"\"\"\n @doc since: \"1.7.0\"\n @impl true\n @spec months_in_year(year) :: 12\n def months_in_year(year) when is_year(year) do\n 12\n end\n\n @doc \"\"\"\n Returns if the given year is a leap year.\n\n ## Examples\n\n iex> Calendar.ISO.leap_year?(2000)\n true\n iex> Calendar.ISO.leap_year?(2001)\n false\n iex> Calendar.ISO.leap_year?(2004)\n true\n iex> Calendar.ISO.leap_year?(1900)\n false\n iex> Calendar.ISO.leap_year?(-4)\n true\n\n \"\"\"\n @doc since: \"1.3.0\"\n @spec leap_year?(year) :: boolean()\n @impl true\n def leap_year?(year) when is_year(year) do\n rem(year, 4) === 0 and (rem(year, 100) !== 0 or rem(year, 400) === 0)\n end\n\n @doc false\n @deprecated \"Use Calendar.ISO.day_of_week/4 instead\"\n def day_of_week(year, month, day) do\n day_of_week(year, month, day, :default) |> elem(0)\n end\n\n @doc \"\"\"\n Calculates the day of the week from the given `year`, `month`, and `day`.\n\n It is an integer from 1 to 7, where 1 is the given `starting_on` weekday.\n For example, if `starting_on` is set to `:monday`, then 1 is Monday and\n 7 is Sunday.\n\n `starting_on` can also be `:default`, which is equivalent to `:monday`.\n\n ## Examples\n\n iex> Calendar.ISO.day_of_week(2016, 10, 31, :monday)\n {1, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 1, :monday)\n {2, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 2, :monday)\n {3, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 3, :monday)\n {4, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 4, :monday)\n {5, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 5, :monday)\n {6, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 6, :monday)\n {7, 1, 7}\n iex> Calendar.ISO.day_of_week(-99, 1, 31, :monday)\n {4, 1, 7}\n\n iex> Calendar.ISO.day_of_week(2016, 10, 31, :sunday)\n {2, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 1, :sunday)\n {3, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 2, :sunday)\n {4, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 3, :sunday)\n {5, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 4, :sunday)\n {6, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 5, :sunday)\n {7, 1, 7}\n iex> Calendar.ISO.day_of_week(2016, 11, 6, :sunday)\n {1, 1, 7}\n iex> Calendar.ISO.day_of_week(-99, 1, 31, :sunday)\n {5, 1, 7}\n\n iex> Calendar.ISO.day_of_week(2016, 10, 31, :saturday)\n {3, 1, 7}\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec day_of_week(year, month, day, :default | weekday) :: {day_of_week(), 1, 7}\n @impl true\n def day_of_week(year, month, day, starting_on) do\n iso_days = date_to_iso_days(year, month, day)\n {iso_days_to_day_of_week(iso_days, starting_on), 1, 7}\n end\n\n @doc false\n def iso_days_to_day_of_week(iso_days, starting_on) do\n Integer.mod(iso_days + day_of_week_offset(starting_on), 7) + 1\n end\n\n defp day_of_week_offset(:default), do: 5\n defp day_of_week_offset(:wednesday), do: 3\n defp day_of_week_offset(:thursday), do: 2\n defp day_of_week_offset(:friday), do: 1\n defp day_of_week_offset(:saturday), do: 0\n defp day_of_week_offset(:sunday), do: 6\n defp day_of_week_offset(:monday), do: 5\n defp day_of_week_offset(:tuesday), do: 4\n\n @doc \"\"\"\n Calculates the day of the year from the given `year`, `month`, and `day`.\n\n It is an integer from 1 to 366.\n\n ## Examples\n\n iex> Calendar.ISO.day_of_year(2016, 1, 31)\n 31\n iex> Calendar.ISO.day_of_year(-99, 2, 1)\n 32\n iex> Calendar.ISO.day_of_year(2018, 2, 28)\n 59\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec day_of_year(year, month, day) :: day_of_year()\n @impl true\n def day_of_year(year, month, day) do\n ensure_day_in_month!(year, month, day)\n days_before_month(month) + leap_day_offset(year, month) + day\n end\n\n @doc \"\"\"\n Calculates the quarter of the year from the given `year`, `month`, and `day`.\n\n It is an integer from 1 to 4.\n\n ## Examples\n\n iex> Calendar.ISO.quarter_of_year(2016, 1, 31)\n 1\n iex> Calendar.ISO.quarter_of_year(2016, 4, 3)\n 2\n iex> Calendar.ISO.quarter_of_year(-99, 9, 31)\n 3\n iex> Calendar.ISO.quarter_of_year(2018, 12, 28)\n 4\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec quarter_of_year(year, month, day) :: quarter_of_year()\n @impl true\n def quarter_of_year(year, month, day)\n when is_year(year) and is_month(month) and is_day(day) do\n div(month - 1, 3) + 1\n end\n\n @doc \"\"\"\n Calculates the year and era from the given `year`.\n\n The ISO calendar has two eras: the \"current era\" (CE) which\n starts in year `1` and is defined as era `1`. And \"before the current\n era\" (BCE) for those years less than `1`, defined as era `0`.\n\n ## Examples\n\n iex> Calendar.ISO.year_of_era(1)\n {1, 1}\n iex> Calendar.ISO.year_of_era(2018)\n {2018, 1}\n iex> Calendar.ISO.year_of_era(0)\n {1, 0}\n iex> Calendar.ISO.year_of_era(-1)\n {2, 0}\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec year_of_era(year) :: {1..10_000, era}\n def year_of_era(year) when is_year_CE(year), do: {year, 1}\n def year_of_era(year) when is_year_BCE(year), do: {abs(year) + 1, 0}\n\n @doc \"\"\"\n Calendar callback to compute the year and era from the\n given `year`, `month` and `day`.\n\n In the ISO calendar, the new year coincides with the new era,\n so the `month` and `day` arguments are discarded. If you only\n have the year available, you can `year_of_era/1` instead.\n\n ## Examples\n\n iex> Calendar.ISO.year_of_era(1, 1, 1)\n {1, 1}\n iex> Calendar.ISO.year_of_era(2018, 12, 1)\n {2018, 1}\n iex> Calendar.ISO.year_of_era(0, 1, 1)\n {1, 0}\n iex> Calendar.ISO.year_of_era(-1, 12, 1)\n {2, 0}\n\n \"\"\"\n @doc since: \"1.13.0\"\n @impl true\n @spec year_of_era(year, month, day) :: {1..10_000, era}\n def year_of_era(year, _month, _day), do: year_of_era(year)\n\n @doc \"\"\"\n Calculates the day and era from the given `year`, `month`, and `day`.\n\n ## Examples\n\n iex> Calendar.ISO.day_of_era(0, 1, 1)\n {366, 0}\n iex> Calendar.ISO.day_of_era(1, 1, 1)\n {1, 1}\n iex> Calendar.ISO.day_of_era(0, 12, 31)\n {1, 0}\n iex> Calendar.ISO.day_of_era(0, 12, 30)\n {2, 0}\n iex> Calendar.ISO.day_of_era(-1, 12, 31)\n {367, 0}\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec day_of_era(year, month, day) :: Calendar.day_of_era()\n @impl true\n def day_of_era(year, month, day) when is_year_CE(year) do\n day = date_to_iso_days(year, month, day) - @iso_epoch + 1\n {day, 1}\n end\n\n def day_of_era(year, month, day) when is_year_BCE(year) do\n day = abs(date_to_iso_days(year, month, day) - @iso_epoch)\n {day, 0}\n end\n\n @doc \"\"\"\n Converts the given time into a string.\n\n By default, returns times formatted in the \"extended\" format,\n for human readability. It also supports the \"basic\" format\n by passing the `:basic` option.\n\n ## Examples\n\n iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 6})\n \"02:02:02.000002\"\n iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 2})\n \"02:02:02.00\"\n iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 0})\n \"02:02:02\"\n\n iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 6}, :basic)\n \"020202.000002\"\n iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 6}, :extended)\n \"02:02:02.000002\"\n\n \"\"\"\n @impl true\n @doc since: \"1.5.0\"\n @spec time_to_string(\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond(),\n :basic | :extended\n ) :: String.t()\n def time_to_string(\n hour,\n minute,\n second,\n microsecond,\n format \\\\ :extended\n ) do\n time_to_iodata(hour, minute, second, microsecond, format)\n |> IO.iodata_to_binary()\n end\n\n @doc \"\"\"\n Converts the given time into a iodata.\n\n See `time_to_string/5` for more information.\n\n ## Examples\n\n iex> data = Calendar.ISO.time_to_iodata(2, 2, 2, {2, 6})\n iex> IO.iodata_to_binary(data)\n \"02:02:02.000002\"\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec time_to_iodata(\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond(),\n :basic | :extended\n ) :: iodata\n def time_to_iodata(\n hour,\n minute,\n second,\n {ms_value, ms_precision} = microsecond,\n format \\\\ :extended\n )\n when is_hour(hour) and is_minute(minute) and is_second(second) and\n is_microsecond(ms_value, ms_precision) and format in [:basic, :extended] do\n time_to_iodata_guarded(hour, minute, second, microsecond, format)\n end\n\n defp time_to_iodata_guarded(hour, minute, second, {_, 0}, format) do\n time_to_iodata_format(hour, minute, second, format)\n end\n\n defp time_to_iodata_guarded(hour, minute, second, {microsecond, precision}, format) do\n [\n time_to_iodata_format(hour, minute, second, format),\n ?.\n | microseconds_to_iodata(microsecond, precision)\n ]\n end\n\n @doc false\n def microseconds_to_iodata(_microsecond, 0), do: []\n def microseconds_to_iodata(microsecond, 6), do: zero_pad(microsecond, 6)\n\n def microseconds_to_iodata(microsecond, precision) do\n num = div(microsecond, scale_factor(precision))\n zero_pad(num, precision)\n end\n\n defp scale_factor(1), do: 100_000\n defp scale_factor(2), do: 10_000\n defp scale_factor(3), do: 1_000\n defp scale_factor(4), do: 100\n defp scale_factor(5), do: 10\n defp scale_factor(6), do: 1\n\n defp time_to_iodata_format(hour, minute, second, :extended) do\n [zero_pad(hour, 2), ?:, zero_pad(minute, 2), ?: | zero_pad(second, 2)]\n end\n\n defp time_to_iodata_format(hour, minute, second, :basic) do\n [zero_pad(hour, 2), zero_pad(minute, 2) | zero_pad(second, 2)]\n end\n\n @doc \"\"\"\n Converts the given date into a string.\n\n By default, returns dates formatted in the \"extended\" format,\n for human readability. It also supports the \"basic\" format\n by passing the `:basic` option.\n\n ## Examples\n\n iex> Calendar.ISO.date_to_string(2015, 2, 28)\n \"2015-02-28\"\n iex> Calendar.ISO.date_to_string(2017, 8, 1)\n \"2017-08-01\"\n iex> Calendar.ISO.date_to_string(-99, 1, 31)\n \"-0099-01-31\"\n\n iex> Calendar.ISO.date_to_string(2015, 2, 28, :basic)\n \"20150228\"\n iex> Calendar.ISO.date_to_string(-99, 1, 31, :basic)\n \"-00990131\"\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec date_to_string(year, month, day, :basic | :extended) :: String.t()\n @impl true\n def date_to_string(year, month, day, format \\\\ :extended) do\n date_to_iodata(year, month, day, format)\n |> IO.iodata_to_binary()\n end\n\n @doc \"\"\"\n Converts the given date into a iodata.\n\n See `date_to_string/4` for more information.\n\n ## Examples\n\n iex> data = Calendar.ISO.date_to_iodata(2015, 2, 28)\n iex> IO.iodata_to_binary(data)\n \"2015-02-28\"\n \"\"\"\n @doc since: \"1.19.0\"\n @spec date_to_iodata(year, month, day, :basic | :extended) :: iodata\n def date_to_iodata(year, month, day, format \\\\ :extended)\n when is_integer(year) and is_integer(month) and is_integer(day) and\n format in [:basic, :extended] do\n date_to_iodata_guarded(year, month, day, format)\n end\n\n defp date_to_iodata_guarded(year, month, day, :extended) do\n [zero_pad(year, 4), ?-, zero_pad(month, 2), ?- | zero_pad(day, 2)]\n end\n\n defp date_to_iodata_guarded(year, month, day, :basic) do\n [zero_pad(year, 4), zero_pad(month, 2) | zero_pad(day, 2)]\n end\n\n @doc \"\"\"\n Converts the datetime (without time zone) into a string.\n\n By default, returns datetimes formatted in the \"extended\" format,\n for human readability. It also supports the \"basic\" format\n by passing the `:basic` option.\n\n ## Examples\n\n iex> Calendar.ISO.naive_datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 6})\n \"2015-02-28 01:02:03.000004\"\n iex> Calendar.ISO.naive_datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5})\n \"2017-08-01 01:02:03.00000\"\n\n iex> Calendar.ISO.naive_datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 6}, :basic)\n \"20150228 010203.000004\"\n\n \"\"\"\n @doc since: \"1.4.0\"\n @impl true\n @spec naive_datetime_to_string(\n year,\n month,\n day,\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond(),\n :basic | :extended\n ) :: String.t()\n def naive_datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n format \\\\ :extended\n ) do\n naive_datetime_to_iodata(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n format\n )\n |> IO.iodata_to_binary()\n end\n\n @doc \"\"\"\n Converts the given naive_datetime into a iodata.\n\n See `naive_datetime_to_iodata/8` for more information.\n\n ## Examples\n\n iex> data = Calendar.ISO.naive_datetime_to_iodata(2015, 2, 28, 1, 2, 3, {4, 6}, :basic)\n iex> IO.iodata_to_binary(data)\n \"20150228 010203.000004\"\n\n iex> data = Calendar.ISO.naive_datetime_to_iodata(2015, 2, 28, 1, 2, 3, {4, 6}, :extended)\n iex> IO.iodata_to_binary(data)\n \"2015-02-28 01:02:03.000004\"\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec naive_datetime_to_iodata(\n year,\n month,\n day,\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond(),\n :basic | :extended\n ) :: iodata\n def naive_datetime_to_iodata(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n format \\\\ :extended\n ) do\n [\n date_to_iodata(year, month, day, format),\n ?\\s\n | time_to_iodata(hour, minute, second, microsecond, format)\n ]\n end\n\n @doc \"\"\"\n Converts the datetime (with time zone) into a string.\n\n By default, returns datetimes formatted in the \"extended\" format,\n for human readability. It also supports the \"basic\" format\n by passing the `:basic` option.\n\n ## Examples\n\n iex> time_zone = \"Etc/UTC\"\n iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, \"UTC\", 0, 0)\n \"2017-08-01 01:02:03.00000Z\"\n iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, \"UTC\", 3600, 0)\n \"2017-08-01 01:02:03.00000+01:00\"\n iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, \"UTC\", 3600, 3600)\n \"2017-08-01 01:02:03.00000+02:00\"\n\n iex> time_zone = \"Europe/Berlin\"\n iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, \"CET\", 3600, 0)\n \"2017-08-01 01:02:03.00000+01:00 CET Europe/Berlin\"\n iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, \"CDT\", 3600, 3600)\n \"2017-08-01 01:02:03.00000+02:00 CDT Europe/Berlin\"\n\n iex> time_zone = \"America/Los_Angeles\"\n iex> Calendar.ISO.datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 5}, time_zone, \"PST\", -28800, 0)\n \"2015-02-28 01:02:03.00000-08:00 PST America/Los_Angeles\"\n iex> Calendar.ISO.datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 5}, time_zone, \"PDT\", -28800, 3600)\n \"2015-02-28 01:02:03.00000-07:00 PDT America/Los_Angeles\"\n\n iex> time_zone = \"Europe/Berlin\"\n iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, \"CET\", 3600, 0, :basic)\n \"20170801 010203.00000+0100 CET Europe/Berlin\"\n\n \"\"\"\n @doc since: \"1.4.0\"\n @impl true\n @spec datetime_to_string(\n year,\n month,\n day,\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond(),\n Calendar.time_zone(),\n Calendar.zone_abbr(),\n Calendar.utc_offset(),\n Calendar.std_offset(),\n :basic | :extended\n ) :: String.t()\n def datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n zone_abbr,\n utc_offset,\n std_offset,\n format \\\\ :extended\n ) do\n datetime_to_iodata(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n zone_abbr,\n utc_offset,\n std_offset,\n format\n )\n |> IO.iodata_to_binary()\n end\n\n @doc \"\"\"\n Converts the given datetime into a iodata.\n\n See `datetime_to_iodata/12` for more information.\n\n ## Examples\n\n iex> time_zone = \"Etc/UTC\"\n iex> data = Calendar.ISO.datetime_to_iodata(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, \"UTC\", 0, 0)\n iex> IO.iodata_to_binary(data)\n \"2017-08-01 01:02:03.00000Z\"\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec datetime_to_iodata(\n year,\n month,\n day,\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond(),\n Calendar.time_zone(),\n Calendar.zone_abbr(),\n Calendar.utc_offset(),\n Calendar.std_offset(),\n :basic | :extended\n ) :: iodata\n def datetime_to_iodata(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n zone_abbr,\n utc_offset,\n std_offset,\n format \\\\ :extended\n )\n when is_time_zone(time_zone) and is_zone_abbr(zone_abbr) and is_utc_offset(utc_offset) and\n is_std_offset(std_offset) do\n [\n date_to_iodata(year, month, day, format),\n ?\\s,\n time_to_iodata(hour, minute, second, microsecond, format),\n offset_to_iodata(utc_offset, std_offset, time_zone, format),\n zone_to_iodata(utc_offset, std_offset, zone_abbr, time_zone)\n ]\n end\n\n @doc false\n def offset_to_string(0, 0, \"Etc/UTC\", _format), do: \"Z\"\n\n def offset_to_string(utc, std, zone, format) do\n offset_to_iodata(utc, std, zone, format)\n |> IO.iodata_to_binary()\n end\n\n @doc false\n def offset_to_iodata(0, 0, \"Etc/UTC\", _format), do: ?Z\n\n def offset_to_iodata(utc, std, _zone, format) do\n total = utc + std\n second = abs(total)\n minute = second |> rem(3600) |> div(60)\n hour = div(second, 3600)\n format_offset(total, hour, minute, format)\n end\n\n defp format_offset(total, hour, minute, :extended) do\n [sign(total), zero_pad(hour, 2), ?: | zero_pad(minute, 2)]\n end\n\n defp format_offset(total, hour, minute, :basic) do\n [sign(total), zero_pad(hour, 2) | zero_pad(minute, 2)]\n end\n\n defp zone_to_iodata(_, _, _, \"Etc/UTC\"), do: []\n defp zone_to_iodata(_, _, abbr, zone), do: [?\\s, abbr, ?\\s | zone]\n\n @doc \"\"\"\n Determines if the date given is valid according to the proleptic Gregorian calendar.\n\n ## Examples\n\n iex> Calendar.ISO.valid_date?(2015, 2, 28)\n true\n iex> Calendar.ISO.valid_date?(2015, 2, 30)\n false\n iex> Calendar.ISO.valid_date?(-1, 12, 31)\n true\n iex> Calendar.ISO.valid_date?(-1, 12, 32)\n false\n\n \"\"\"\n @doc since: \"1.5.0\"\n @impl true\n @spec valid_date?(year, month, day) :: boolean\n def valid_date?(year, month, day)\n when is_integer(year) and is_integer(month) and is_integer(day) do\n is_month(month) and day in 1..days_in_month(year, month)\n end\n\n @doc \"\"\"\n Determines if the date given is valid according to the proleptic Gregorian calendar.\n\n Leap seconds are not supported by the built-in Calendar.ISO.\n\n ## Examples\n\n iex> Calendar.ISO.valid_time?(10, 50, 25, {3006, 6})\n true\n iex> Calendar.ISO.valid_time?(23, 59, 60, {0, 0})\n false\n iex> Calendar.ISO.valid_time?(24, 0, 0, {0, 0})\n false\n\n \"\"\"\n @doc since: \"1.5.0\"\n @impl true\n @spec valid_time?(Calendar.hour(), Calendar.minute(), Calendar.second(), Calendar.microsecond()) ::\n boolean\n def valid_time?(hour, minute, second, {ms_value, ms_precision} = _microsecond)\n when is_integer(hour) and is_integer(minute) and is_integer(second) and is_integer(ms_value) and\n is_integer(ms_value) do\n is_hour(hour) and is_minute(minute) and is_second(second) and\n is_microsecond(ms_value, ms_precision)\n end\n\n @doc \"\"\"\n See `c:Calendar.day_rollover_relative_to_midnight_utc/0` for documentation.\n \"\"\"\n @doc since: \"1.5.0\"\n @impl true\n @spec day_rollover_relative_to_midnight_utc() :: {0, 1}\n def day_rollover_relative_to_midnight_utc() do\n {0, 1}\n end\n\n defp sign(total) when total < 0, do: ?-\n defp sign(_), do: ?+\n\n defp zero_pad(val, count) when val >= 0 and count <= 6 do\n num = Integer.to_string(val)\n\n case max(count - byte_size(num), 0) do\n 0 -> num\n 1 -> [\"0\" | num]\n 2 -> [\"00\" | num]\n 3 -> [\"000\" | num]\n 4 -> [\"0000\" | num]\n 5 -> [\"00000\" | num]\n end\n end\n\n defp zero_pad(val, count) do\n [?- | zero_pad(-val, count)]\n end\n\n @doc \"\"\"\n Converts the `t:Calendar.iso_days/0` to the first moment of the day.\n\n ## Examples\n\n iex> Calendar.ISO.iso_days_to_beginning_of_day({0, {0, 86_400_000_000}})\n {0, {0, 86400000000}}\n iex> Calendar.ISO.iso_days_to_beginning_of_day({730_485, {43_200_000_000, 86_400_000_000}})\n {730485, {0, 86400000000}}\n iex> Calendar.ISO.iso_days_to_beginning_of_day({730_485, {46_800_000_000, 86_400_000_000}})\n {730485, {0, 86400000000}}\n\n \"\"\"\n @doc since: \"1.15.0\"\n @impl true\n @spec iso_days_to_beginning_of_day(Calendar.iso_days()) :: Calendar.iso_days()\n def iso_days_to_beginning_of_day({days, _day_fraction}) do\n {days, {0, @parts_per_day}}\n end\n\n @doc \"\"\"\n Converts the `t:Calendar.iso_days/0` to the last moment of the day.\n\n ## Examples\n\n iex> Calendar.ISO.iso_days_to_end_of_day({0, {0, 86_400_000_000}})\n {0, {86399999999, 86400000000}}\n iex> Calendar.ISO.iso_days_to_end_of_day({730_485, {43_200_000_000, 86_400_000_000}})\n {730485, {86399999999, 86400000000}}\n iex> Calendar.ISO.iso_days_to_end_of_day({730_485, {46_800_000_000, 86_400_000_000}})\n {730485, {86399999999, 86400000000}}\n\n \"\"\"\n @doc since: \"1.15.0\"\n @impl true\n @spec iso_days_to_end_of_day(Calendar.iso_days()) :: Calendar.iso_days()\n def iso_days_to_end_of_day({days, _day_fraction}) do\n {days, {@parts_per_day - 1, @parts_per_day}}\n end\n\n @doc \"\"\"\n Shifts Date by Duration according to its calendar.\n\n ## Examples\n\n iex> Calendar.ISO.shift_date(2016, 1, 3, Duration.new!(month: 2))\n {2016, 3, 3}\n iex> Calendar.ISO.shift_date(2016, 2, 29, Duration.new!(month: 1))\n {2016, 3, 29}\n iex> Calendar.ISO.shift_date(2016, 1, 31, Duration.new!(month: 1))\n {2016, 2, 29}\n iex> Calendar.ISO.shift_date(2016, 1, 31, Duration.new!(year: 4, day: 1))\n {2020, 2, 1}\n \"\"\"\n @impl true\n @spec shift_date(year, month, day, Duration.t()) :: {year, month, day}\n def shift_date(year, month, day, duration) do\n shift_options = shift_date_options(duration)\n\n Enum.reduce(shift_options, {year, month, day}, fn\n {_, 0}, date ->\n date\n\n {:month, value}, date ->\n shift_months(date, value)\n\n {:day, value}, date ->\n shift_days(date, value)\n end)\n end\n\n @doc \"\"\"\n Shifts NaiveDateTime by Duration according to its calendar.\n\n ## Examples\n\n iex> Calendar.ISO.shift_naive_datetime(2016, 1, 3, 0, 0, 0, {0, 0}, Duration.new!(hour: 1))\n {2016, 1, 3, 1, 0, 0, {0, 0}}\n iex> Calendar.ISO.shift_naive_datetime(2016, 1, 3, 0, 0, 0, {0, 0}, Duration.new!(hour: 30))\n {2016, 1, 4, 6, 0, 0, {0, 0}}\n iex> Calendar.ISO.shift_naive_datetime(2016, 1, 3, 0, 0, 0, {0, 0}, Duration.new!(microsecond: {100, 6}))\n {2016, 1, 3, 0, 0, 0, {100, 6}}\n \"\"\"\n @impl true\n @spec shift_naive_datetime(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n Duration.t()\n ) :: {year, month, day, hour, minute, second, microsecond}\n def shift_naive_datetime(year, month, day, hour, minute, second, microsecond, duration) do\n shift_options = shift_datetime_options(duration)\n\n Enum.reduce(shift_options, {year, month, day, hour, minute, second, microsecond}, fn\n {_, 0}, naive_datetime ->\n naive_datetime\n\n {:month, value}, {year, month, day, hour, minute, second, microsecond} ->\n {new_year, new_month, new_day} = shift_months({year, month, day}, value)\n {new_year, new_month, new_day, hour, minute, second, microsecond}\n\n {time_unit, value}, naive_datetime ->\n shift_time_unit(naive_datetime, value, time_unit)\n end)\n end\n\n @doc \"\"\"\n Shifts Time by Duration units according to its calendar.\n\n ## Examples\n\n iex> Calendar.ISO.shift_time(13, 0, 0, {0, 0}, Duration.new!(hour: 2))\n {15, 0, 0, {0, 0}}\n iex> Calendar.ISO.shift_time(13, 0, 0, {0, 0}, Duration.new!(microsecond: {100, 6}))\n {13, 0, 0, {100, 6}}\n \"\"\"\n @impl true\n @spec shift_time(hour, minute, second, microsecond, Duration.t()) ::\n {hour, minute, second, microsecond}\n def shift_time(hour, minute, second, microsecond, duration) do\n shift_options = shift_time_options(duration)\n\n Enum.reduce(shift_options, {hour, minute, second, microsecond}, fn\n {_, 0}, time ->\n time\n\n {time_unit, value}, time ->\n shift_time_unit(time, value, time_unit)\n end)\n end\n\n @doc false\n def shift_days({year, month, day}, days) do\n {year, month, day} =\n date_to_iso_days(year, month, day)\n |> Kernel.+(days)\n |> date_from_iso_days()\n\n {year, month, day}\n end\n\n defp shift_months({year, month, day}, months) do\n months_in_year = 12\n total_months = year * months_in_year + month + months - 1\n\n new_year = floor_div_positive_divisor(total_months, months_in_year)\n\n new_month =\n case rem(total_months, months_in_year) + 1 do\n new_month when new_month < 1 -> new_month + months_in_year\n new_month -> new_month\n end\n\n new_day = min(day, days_in_month(new_year, new_month))\n\n {new_year, new_month, new_day}\n end\n\n @doc false\n def shift_time_unit({year, month, day, hour, minute, second, microsecond}, value, unit)\n when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do\n {value, precision} = shift_time_unit_values(value, microsecond)\n\n {year, month, day, hour, minute, second, {ms_value, _}} =\n naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)\n |> shift_time_unit(value, unit)\n |> naive_datetime_from_iso_days()\n\n {year, month, day, hour, minute, second, {ms_value, precision}}\n end\n\n def shift_time_unit({hour, minute, second, microsecond}, value, unit)\n when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do\n {value, precision} = shift_time_unit_values(value, microsecond)\n\n {_days, day_fraction} =\n shift_time_unit({0, time_to_day_fraction(hour, minute, second, microsecond)}, value, unit)\n\n {hour, minute, second, {microsecond, _}} = time_from_day_fraction(day_fraction)\n\n {hour, minute, second, {microsecond, precision}}\n end\n\n def shift_time_unit({_days, _day_fraction} = iso_days, value, unit)\n when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do\n ppd = System.convert_time_unit(86_400, :second, unit)\n add_day_fraction_to_iso_days(iso_days, value, ppd)\n end\n\n defp shift_time_unit_values({0, _}, {_, original_precision}) do\n {0, original_precision}\n end\n\n defp shift_time_unit_values({ms_value, ms_precision}, {_, _}) do\n {ms_value, ms_precision}\n end\n\n defp shift_time_unit_values(value, {_, original_precision}) do\n {value, original_precision}\n end\n\n defp shift_date_options(%Duration{\n year: year,\n month: month,\n week: week,\n day: day,\n hour: 0,\n minute: 0,\n second: 0,\n microsecond: {0, _precision}\n }) do\n [\n month: year * 12 + month,\n day: week * 7 + day\n ]\n end\n\n defp shift_date_options(_duration) do\n raise ArgumentError,\n \"cannot shift date by time scale unit. Expected :year, :month, :week, :day\"\n end\n\n defp shift_datetime_options(%Duration{\n year: year,\n month: month,\n week: week,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }) do\n [\n month: year * 12 + month,\n second: week * 7 * 86_400 + day * 86_400 + hour * 3600 + minute * 60 + second,\n microsecond: microsecond\n ]\n end\n\n defp shift_time_options(%Duration{\n year: 0,\n month: 0,\n week: 0,\n day: 0,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }) do\n [\n second: hour * 3600 + minute * 60 + second,\n microsecond: microsecond\n ]\n end\n\n defp shift_time_options(_duration) do\n raise ArgumentError,\n \"cannot shift time by date scale unit. Expected :hour, :minute, :second, :microsecond\"\n end\n\n ## Helpers\n\n @doc false\n def from_unix(integer, unit) when is_integer(integer) do\n total = System.convert_time_unit(integer, unit, :microsecond)\n\n if total in @unix_range_microseconds do\n microseconds = Integer.mod(total, @microseconds_per_second)\n seconds = @unix_epoch + floor_div_positive_divisor(total, @microseconds_per_second)\n precision = precision_for_unit(unit)\n {date, time} = iso_seconds_to_datetime(seconds)\n {:ok, date, time, {microseconds, precision}}\n else\n {:error, :invalid_unix_time}\n end\n end\n\n defp precision_for_unit(unit) do\n case System.convert_time_unit(1, :second, unit) do\n 1 -> 0\n 10 -> 1\n 100 -> 2\n 1_000 -> 3\n 10_000 -> 4\n 100_000 -> 5\n _ -> 6\n end\n end\n\n defp parse_microsecond(\".\" <> rest) do\n case parse_microsecond(rest, 0, []) do\n {[], 0, _} ->\n :error\n\n {microsecond, precision, rest} ->\n scale = scale_factor(precision)\n {{:erlang.list_to_integer(microsecond) * scale, precision}, rest}\n end\n end\n\n defp parse_microsecond(\",\" <> rest) do\n parse_microsecond(\".\" <> rest)\n end\n\n defp parse_microsecond(rest) do\n {{0, 0}, rest}\n end\n\n defp parse_microsecond(<>, 6, acc) when head in ?0..?9,\n do: parse_microsecond(tail, 6, acc)\n\n defp parse_microsecond(<>, precision, acc) when head in ?0..?9,\n do: parse_microsecond(tail, precision + 1, [head | acc])\n\n defp parse_microsecond(rest, precision, acc) do\n {:lists.reverse(acc), precision, rest}\n end\n\n defp parse_offset(\"\"), do: {nil, \"\"}\n defp parse_offset(\"Z\"), do: {0, \"\"}\n defp parse_offset(\"-00:00\"), do: :error\n\n defp parse_offset(<>),\n do: parse_offset(1, h1, h2, m1, m2, rest)\n\n defp parse_offset(<>),\n do: parse_offset(-1, h1, h2, m1, m2, rest)\n\n defp parse_offset(<>),\n do: parse_offset(1, h1, h2, m1, m2, rest)\n\n defp parse_offset(<>),\n do: parse_offset(-1, h1, h2, m1, m2, rest)\n\n defp parse_offset(<>), do: parse_offset(1, h1, h2, ?0, ?0, rest)\n defp parse_offset(<>), do: parse_offset(-1, h1, h2, ?0, ?0, rest)\n defp parse_offset(_), do: :error\n\n defp parse_offset(sign, h1, h2, m1, m2, rest) do\n with true <- h1 in ?0..?2 and h2 in ?0..?9,\n true <- m1 in ?0..?5 and m2 in ?0..?9,\n hour = (h1 - ?0) * 10 + h2 - ?0,\n min = (m1 - ?0) * 10 + m2 - ?0,\n true <- hour < 24 do\n {(hour * 60 + min) * 60 * sign, rest}\n else\n _ -> :error\n end\n end\n\n @doc false\n def gregorian_seconds_to_iso_days(seconds, microsecond) do\n {days, rest_seconds} = div_rem(seconds, @seconds_per_day)\n microseconds_in_day = rest_seconds * @microseconds_per_second + microsecond\n day_fraction = {microseconds_in_day, @parts_per_day}\n {days, day_fraction}\n end\n\n @doc false\n def iso_days_to_unit({days, {parts, ppd}}, unit) do\n day_microseconds = days * @parts_per_day\n microseconds = divide_by_parts_per_day(parts, ppd)\n System.convert_time_unit(day_microseconds + microseconds, :microsecond, unit)\n end\n\n @doc false\n def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, ppd) do\n normalize_iso_days(days, parts + add, ppd)\n end\n\n def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, add_ppd) do\n parts = parts * add_ppd\n add = add * ppd\n gcd = Integer.gcd(ppd, add_ppd)\n result_parts = div(parts + add, gcd)\n result_ppd = div(ppd * add_ppd, gcd)\n normalize_iso_days(days, result_parts, result_ppd)\n end\n\n defp normalize_iso_days(days, parts, ppd) do\n days_offset = div(parts, ppd)\n parts = rem(parts, ppd)\n\n if parts < 0 do\n {days + days_offset - 1, {parts + ppd, ppd}}\n else\n {days + days_offset, {parts, ppd}}\n end\n end\n\n defp leap_day_offset(_year, month) when month < 3, do: 0\n\n defp leap_day_offset(year, _month) do\n if leap_year?(year), do: 1, else: 0\n end\n\n defp days_before_month(1), do: 0\n defp days_before_month(2), do: 31\n defp days_before_month(3), do: 59\n defp days_before_month(4), do: 90\n defp days_before_month(5), do: 120\n defp days_before_month(6), do: 151\n defp days_before_month(7), do: 181\n defp days_before_month(8), do: 212\n defp days_before_month(9), do: 243\n defp days_before_month(10), do: 273\n defp days_before_month(11), do: 304\n defp days_before_month(12), do: 334\n\n defp iso_seconds_to_datetime(seconds) do\n {days, rest_seconds} = div_rem(seconds, @seconds_per_day)\n\n date = date_from_iso_days(days)\n time = seconds_to_time(rest_seconds)\n {date, time}\n end\n\n defp seconds_to_time(seconds) when seconds in 0..@last_second_of_the_day do\n {hour, rest_seconds} = div_rem(seconds, @seconds_per_hour)\n {minute, second} = div_rem(rest_seconds, @seconds_per_minute)\n\n {hour, minute, second}\n end\n\n defp ensure_day_in_month!(year, month, day) when is_integer(day) do\n if day < 1 or day > days_in_month(year, month) do\n raise ArgumentError, \"invalid date: #{date_to_string(year, month, day)}\"\n end\n end\nend\n" }, { "path": "lib/elixir/lib/calendar/naive_datetime.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule NaiveDateTime do\n @moduledoc \"\"\"\n A NaiveDateTime struct (without a time zone) and functions.\n\n The NaiveDateTime struct contains the fields year, month, day, hour,\n minute, second, microsecond and calendar. New naive datetimes can be\n built with the `new/2` and `new/8` functions or using the\n `~N` (see `sigil_N/2`) sigil:\n\n iex> ~N[2000-01-01 23:00:07]\n ~N[2000-01-01 23:00:07]\n\n The date and time fields in the struct can be accessed directly:\n\n iex> naive = ~N[2000-01-01 23:00:07]\n iex> naive.year\n 2000\n iex> naive.second\n 7\n\n We call them \"naive\" because this datetime representation does not\n have a time zone. This means the datetime may not actually exist in\n certain areas in the world even though it is valid.\n\n For example, when daylight saving changes are applied by a region,\n the clock typically moves forward or backward by one hour. This means\n certain datetimes never occur or may occur more than once. Since\n `NaiveDateTime` is not validated against a time zone, such errors\n would go unnoticed.\n\n Developers should avoid creating the NaiveDateTime structs directly\n and instead, rely on the functions provided by this module as well\n as the ones in third-party calendar libraries.\n\n ## Comparing naive date times\n\n Comparisons in Elixir using `==/2`, `>/2`, ` Enum.min([~N[2020-01-01 23:00:07], ~N[2000-01-01 23:00:07]], NaiveDateTime)\n ~N[2000-01-01 23:00:07]\n\n ## Using epochs\n\n The `add/3` and `diff/3` functions can be used for computing date\n times or retrieving the number of seconds between instants.\n For example, if there is an interest in computing the number of\n seconds from the Unix epoch (1970-01-01 00:00:00):\n\n iex> NaiveDateTime.diff(~N[2010-04-17 14:00:00], ~N[1970-01-01 00:00:00])\n 1271512800\n\n iex> NaiveDateTime.add(~N[1970-01-01 00:00:00], 1_271_512_800)\n ~N[2010-04-17 14:00:00]\n\n Those functions are optimized to deal with common epochs, such\n as the Unix Epoch above or the Gregorian Epoch (0000-01-01 00:00:00).\n \"\"\"\n\n @enforce_keys [:year, :month, :day, :hour, :minute, :second]\n defstruct [\n :year,\n :month,\n :day,\n :hour,\n :minute,\n :second,\n microsecond: {0, 0},\n calendar: Calendar.ISO\n ]\n\n @type t :: %__MODULE__{\n year: Calendar.year(),\n month: Calendar.month(),\n day: Calendar.day(),\n calendar: Calendar.calendar(),\n hour: Calendar.hour(),\n minute: Calendar.minute(),\n second: Calendar.second(),\n microsecond: Calendar.microsecond()\n }\n\n @seconds_per_day 24 * 60 * 60\n\n @doc \"\"\"\n Returns the current naive datetime in UTC.\n\n Prefer using `DateTime.utc_now/0` when possible as, opposite\n to `NaiveDateTime`, it will keep the time zone information.\n\n You can also provide a time unit to automatically truncate\n the naive datetime. This is available since v1.15.0.\n\n ## Examples\n\n iex> naive_datetime = NaiveDateTime.utc_now()\n iex> naive_datetime.year >= 2016\n true\n\n iex> naive_datetime = NaiveDateTime.utc_now(:second)\n iex> naive_datetime.microsecond\n {0, 0}\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec utc_now(Calendar.calendar() | :native | :microsecond | :millisecond | :second) :: t\n def utc_now(calendar_or_time_unit \\\\ Calendar.ISO)\n\n def utc_now(time_unit) when time_unit in [:microsecond, :millisecond, :second, :native] do\n utc_now(time_unit, Calendar.ISO)\n end\n\n def utc_now(calendar) do\n utc_now(:native, calendar)\n end\n\n @doc \"\"\"\n Returns the current naive datetime in UTC, supporting a specific\n calendar and precision.\n\n Prefer using `DateTime.utc_now/2` when possible as, opposite\n to `NaiveDateTime`, it will keep the time zone information.\n\n ## Examples\n\n iex> naive_datetime = NaiveDateTime.utc_now(:second, Calendar.ISO)\n iex> naive_datetime.year >= 2016\n true\n\n iex> naive_datetime = NaiveDateTime.utc_now(:second, Calendar.ISO)\n iex> naive_datetime.microsecond\n {0, 0}\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec utc_now(:native | :microsecond | :millisecond | :second, Calendar.calendar()) :: t\n def utc_now(time_unit, calendar)\n when time_unit in [:native, :microsecond, :millisecond, :second] do\n {:ok, {year, month, day}, {hour, minute, second}, microsecond} =\n Calendar.ISO.from_unix(System.os_time(time_unit), time_unit)\n\n %NaiveDateTime{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: Calendar.ISO\n }\n |> convert!(calendar)\n end\n\n @doc \"\"\"\n Returns the \"local time\" for the machine the Elixir program is running on.\n\n WARNING: This function can cause insidious bugs. It depends on the time zone\n configuration at run time. This can changed and be set to a time zone that has\n daylight saving jumps (spring forward or fall back).\n\n This function can be used to display what the time is right now for the time\n zone configuration that the machine happens to have. An example would be a\n desktop program displaying a clock to the user. For any other uses it is\n probably a bad idea to use this function.\n\n For most cases, use `DateTime.now/2` or `DateTime.utc_now/1` instead.\n\n Does not include fractional seconds.\n\n ## Examples\n\n iex> naive_datetime = NaiveDateTime.local_now()\n iex> naive_datetime.year >= 2019\n true\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec local_now(Calendar.calendar()) :: t\n def local_now(calendar \\\\ Calendar.ISO)\n\n def local_now(Calendar.ISO) do\n {{year, month, day}, {hour, minute, second}} = :erlang.localtime()\n {:ok, ndt} = NaiveDateTime.new(year, month, day, hour, minute, second)\n ndt\n end\n\n def local_now(calendar) do\n naive_datetime = local_now()\n\n case convert(naive_datetime, calendar) do\n {:ok, value} ->\n value\n\n {:error, :incompatible_calendars} ->\n raise ArgumentError,\n ~s(cannot get \"local now\" in target calendar #{inspect(calendar)}, ) <>\n \"reason: cannot convert from Calendar.ISO to #{inspect(calendar)}.\"\n end\n end\n\n @doc \"\"\"\n Builds a new ISO naive datetime.\n\n Expects all values to be integers. Returns `{:ok, naive_datetime}`\n if each entry fits its appropriate range, returns `{:error, reason}`\n otherwise.\n\n ## Examples\n\n iex> NaiveDateTime.new(2000, 1, 1, 0, 0, 0)\n {:ok, ~N[2000-01-01 00:00:00]}\n iex> NaiveDateTime.new(2000, 13, 1, 0, 0, 0)\n {:error, :invalid_date}\n iex> NaiveDateTime.new(2000, 2, 29, 0, 0, 0)\n {:ok, ~N[2000-02-29 00:00:00]}\n iex> NaiveDateTime.new(2000, 2, 30, 0, 0, 0)\n {:error, :invalid_date}\n iex> NaiveDateTime.new(2001, 2, 29, 0, 0, 0)\n {:error, :invalid_date}\n\n iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1})\n {:ok, ~N[2000-01-01 23:59:59.0]}\n iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 999_999)\n {:ok, ~N[2000-01-01 23:59:59.999999]}\n iex> NaiveDateTime.new(2000, 1, 1, 24, 59, 59, 999_999)\n {:error, :invalid_time}\n iex> NaiveDateTime.new(2000, 1, 1, 23, 60, 59, 999_999)\n {:error, :invalid_time}\n iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 60, 999_999)\n {:error, :invalid_time}\n iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 1_000_000)\n {:error, :invalid_time}\n\n iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)\n {:ok, ~N[2000-01-01 23:59:59.0]}\n\n \"\"\"\n @spec new(\n Calendar.year(),\n Calendar.month(),\n Calendar.day(),\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond() | non_neg_integer(),\n Calendar.calendar()\n ) :: {:ok, t} | {:error, atom}\n def new(year, month, day, hour, minute, second, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO)\n\n def new(year, month, day, hour, minute, second, microsecond, calendar)\n when is_integer(microsecond) do\n new(year, month, day, hour, minute, second, {microsecond, 6}, calendar)\n end\n\n def new(year, month, day, hour, minute, second, microsecond, calendar) do\n cond do\n not calendar.valid_date?(year, month, day) ->\n {:error, :invalid_date}\n\n not calendar.valid_time?(hour, minute, second, microsecond) ->\n {:error, :invalid_time}\n\n true ->\n naive_datetime = %NaiveDateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n\n {:ok, naive_datetime}\n end\n end\n\n @doc \"\"\"\n Builds a new ISO naive datetime.\n\n Expects all values to be integers. Returns `naive_datetime`\n if each entry fits its appropriate range, raises if\n time or date is invalid.\n\n ## Examples\n\n iex> NaiveDateTime.new!(2000, 1, 1, 0, 0, 0)\n ~N[2000-01-01 00:00:00]\n iex> NaiveDateTime.new!(2000, 2, 29, 0, 0, 0)\n ~N[2000-02-29 00:00:00]\n iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, {0, 1})\n ~N[2000-01-01 23:59:59.0]\n iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, 999_999)\n ~N[2000-01-01 23:59:59.999999]\n iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)\n ~N[2000-01-01 23:59:59.0]\n iex> NaiveDateTime.new!(2000, 1, 1, 24, 59, 59, 999_999)\n ** (ArgumentError) cannot build naive datetime, reason: :invalid_time\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec new!(\n Calendar.year(),\n Calendar.month(),\n Calendar.day(),\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond() | non_neg_integer(),\n Calendar.calendar()\n ) :: t\n def new!(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond \\\\ {0, 0},\n calendar \\\\ Calendar.ISO\n )\n\n def new!(year, month, day, hour, minute, second, microsecond, calendar) do\n case new(year, month, day, hour, minute, second, microsecond, calendar) do\n {:ok, naive_datetime} ->\n naive_datetime\n\n {:error, reason} ->\n raise ArgumentError, \"cannot build naive datetime, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Builds a naive datetime from date and time structs.\n\n ## Examples\n\n iex> NaiveDateTime.new(~D[2010-01-13], ~T[23:00:07.005])\n {:ok, ~N[2010-01-13 23:00:07.005]}\n\n \"\"\"\n @spec new(Date.t(), Time.t()) :: {:ok, t}\n def new(date, time)\n\n def new(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time) do\n %{year: year, month: month, day: day} = date\n %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time\n\n naive_datetime = %NaiveDateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n\n {:ok, naive_datetime}\n end\n\n @doc \"\"\"\n Builds a naive datetime from date and time structs.\n\n ## Examples\n\n iex> NaiveDateTime.new!(~D[2010-01-13], ~T[23:00:07.005])\n ~N[2010-01-13 23:00:07.005]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec new!(Date.t(), Time.t()) :: t\n def new!(date, time)\n\n def new!(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time) do\n {:ok, naive_datetime} = new(date, time)\n naive_datetime\n end\n\n @doc \"\"\"\n Adds a specified amount of time to a `NaiveDateTime`.\n\n > #### Prefer `shift/2` {: .info}\n >\n > Prefer `shift/2` over `add/3`, as it offers a more ergonomic API.\n >\n > `add/3` provides a lower-level API which only supports fixed units\n > such as `:hour` and `:second`, but not `:month` (as the exact length\n > of a month depends on the current month). `add/3` always considers\n > the unit to be computed according to the `Calendar.ISO`.\n\n Accepts an `amount_to_add` in any `unit`. `unit` can be `:day`,\n `:hour`, `:minute`, `:second` or any subsecond precision from\n `t:System.time_unit/0` for convenience but ultimately they are\n all converted to microseconds. Negative values will move backwards\n in time and the default precision is `:second`.\n\n ## Examples\n\n It uses seconds by default:\n\n # adds seconds by default\n iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2)\n ~N[2014-10-02 00:29:12]\n\n # accepts negative offsets\n iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], -2)\n ~N[2014-10-02 00:29:08]\n\n It can also work with subsecond precisions:\n\n iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2_000, :millisecond)\n ~N[2014-10-02 00:29:12.000]\n\n As well as days/hours/minutes:\n\n iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 2, :day)\n ~N[2015-03-02 00:29:10]\n iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 36, :hour)\n ~N[2015-03-01 12:29:10]\n iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 60, :minute)\n ~N[2015-02-28 01:29:10]\n\n This operation merges the precision of the naive date time with the given unit:\n\n iex> result = NaiveDateTime.add(~N[2014-10-02 00:29:10], 21, :millisecond)\n ~N[2014-10-02 00:29:10.021]\n iex> result.microsecond\n {21000, 3}\n\n Operations on top of gregorian seconds or the Unix epoch are optimized:\n\n # from Gregorian seconds\n iex> NaiveDateTime.add(~N[0000-01-01 00:00:00], 63_579_428_950)\n ~N[2014-10-02 00:29:10]\n\n Passing a `DateTime` automatically converts it to `NaiveDateTime`,\n discarding the time zone information:\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> NaiveDateTime.add(dt, 21, :second)\n ~N[2000-02-29 23:00:28]\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec add(Calendar.naive_datetime(), integer, :day | :hour | :minute | System.time_unit()) :: t\n def add(naive_datetime, amount_to_add, unit \\\\ :second)\n\n def add(naive_datetime, amount_to_add, :day) when is_integer(amount_to_add) do\n add(naive_datetime, amount_to_add * 86400, :second)\n end\n\n def add(naive_datetime, amount_to_add, :hour) when is_integer(amount_to_add) do\n add(naive_datetime, amount_to_add * 3600, :second)\n end\n\n def add(naive_datetime, amount_to_add, :minute) when is_integer(amount_to_add) do\n add(naive_datetime, amount_to_add * 60, :second)\n end\n\n def add(\n %{calendar: calendar, microsecond: {_, precision}} = naive_datetime,\n amount_to_add,\n unit\n )\n when is_integer(amount_to_add) do\n if not is_integer(unit) and unit not in ~w(second millisecond microsecond nanosecond)a do\n raise ArgumentError,\n \"unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}\"\n end\n\n precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)\n\n naive_datetime\n |> to_iso_days()\n |> Calendar.ISO.shift_time_unit(amount_to_add, unit)\n |> from_iso_days(calendar, precision)\n end\n\n @doc \"\"\"\n Subtracts `naive_datetime2` from `naive_datetime1`.\n\n The answer can be returned in any `:day`, `:hour`, `:minute`, or any `unit`\n available from `t:System.time_unit/0`. The unit is measured according to\n `Calendar.ISO` and defaults to `:second`.\n\n Fractional results are not supported and are truncated.\n\n ## Examples\n\n iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10])\n 2\n iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10], :microsecond)\n 2_000_000\n\n iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021])\n 0\n iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021], :millisecond)\n 21\n\n iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[2014-10-02 00:29:12])\n -2\n iex> NaiveDateTime.diff(~N[-0001-10-02 00:29:10], ~N[-0001-10-02 00:29:12])\n -2\n\n It can also compute the difference in days, hours, or minutes:\n\n iex> NaiveDateTime.diff(~N[2014-10-10 00:29:10], ~N[2014-10-02 00:29:10], :day)\n 8\n iex> NaiveDateTime.diff(~N[2014-10-02 12:29:10], ~N[2014-10-02 00:29:10], :hour)\n 12\n iex> NaiveDateTime.diff(~N[2014-10-02 00:39:10], ~N[2014-10-02 00:29:10], :minute)\n 10\n\n But it also rounds incomplete days to zero:\n\n iex> NaiveDateTime.diff(~N[2014-10-10 00:29:09], ~N[2014-10-02 00:29:10], :day)\n 7\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec diff(\n Calendar.naive_datetime(),\n Calendar.naive_datetime(),\n :day | :hour | :minute | System.time_unit()\n ) :: integer\n\n def diff(naive_datetime1, naive_datetime2, unit \\\\ :second)\n\n def diff(naive_datetime1, naive_datetime2, :day) do\n diff(naive_datetime1, naive_datetime2, :second) |> div(86400)\n end\n\n def diff(naive_datetime1, naive_datetime2, :hour) do\n diff(naive_datetime1, naive_datetime2, :second) |> div(3600)\n end\n\n def diff(naive_datetime1, naive_datetime2, :minute) do\n diff(naive_datetime1, naive_datetime2, :second) |> div(60)\n end\n\n def diff(\n %{calendar: calendar1} = naive_datetime1,\n %{calendar: calendar2} = naive_datetime2,\n unit\n ) do\n if not Calendar.compatible_calendars?(calendar1, calendar2) do\n raise ArgumentError,\n \"cannot calculate the difference between #{inspect(naive_datetime1)} and \" <>\n \"#{inspect(naive_datetime2)} because their calendars are not compatible \" <>\n \"and thus the result would be ambiguous\"\n end\n\n if not is_integer(unit) and\n unit not in ~w(second millisecond microsecond nanosecond)a do\n raise ArgumentError,\n \"unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}\"\n end\n\n units1 = naive_datetime1 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)\n units2 = naive_datetime2 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)\n units1 - units2\n end\n\n @doc \"\"\"\n Shifts given `naive_datetime` by `duration` according to its calendar.\n\n Allowed units are: `:year`, `:month`, `:week`, `:day`, `:hour`, `:minute`, `:second`, `:microsecond`.\n\n When using the default ISO calendar, durations are collapsed and\n applied in the order of months, then seconds and microseconds:\n\n * when shifting by 1 year and 2 months the date is actually shifted by 14 months\n * weeks, days and smaller units are collapsed into seconds and microseconds\n\n When shifting by month, days are rounded down to the nearest valid date.\n\n ## Examples\n\n iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], month: 1)\n ~N[2016-02-29 00:00:00]\n iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], year: 4, day: 1)\n ~N[2020-02-01 00:00:00]\n iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], year: -2, day: 1)\n ~N[2014-02-01 00:00:00]\n iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], second: 45)\n ~N[2016-01-31 00:00:45]\n iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], microsecond: {100, 6})\n ~N[2016-01-31 00:00:00.000100]\n\n # leap years\n iex> NaiveDateTime.shift(~N[2024-02-29 00:00:00], year: 1)\n ~N[2025-02-28 00:00:00]\n iex> NaiveDateTime.shift(~N[2024-02-29 00:00:00], year: 4)\n ~N[2028-02-29 00:00:00]\n\n # rounding down\n iex> NaiveDateTime.shift(~N[2015-01-31 00:00:00], month: 1)\n ~N[2015-02-28 00:00:00]\n\n \"\"\"\n @doc since: \"1.17.0\"\n @spec shift(Calendar.naive_datetime(), Duration.duration()) :: t\n def shift(%{calendar: calendar} = naive_datetime, duration) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n } = naive_datetime\n\n {year, month, day, hour, minute, second, microsecond} =\n calendar.shift_naive_datetime(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n __duration__!(duration)\n )\n\n %NaiveDateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n end\n\n @doc false\n defdelegate __duration__!(params), to: Duration, as: :new!\n\n @doc \"\"\"\n Returns the given naive datetime with the microsecond field truncated to the\n given precision (`:microsecond`, `:millisecond` or `:second`).\n\n The given naive datetime is returned unchanged if it already has lower precision\n than the given precision.\n\n ## Examples\n\n iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond)\n ~N[2017-11-06 00:23:51.123456]\n\n iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond)\n ~N[2017-11-06 00:23:51.123]\n\n iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second)\n ~N[2017-11-06 00:23:51]\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec truncate(t(), :microsecond | :millisecond | :second) :: t()\n def truncate(%NaiveDateTime{microsecond: microsecond} = naive_datetime, precision) do\n %{naive_datetime | microsecond: Calendar.truncate(microsecond, precision)}\n end\n\n def truncate(\n %{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n },\n precision\n ) do\n %NaiveDateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: Calendar.truncate(microsecond, precision)\n }\n end\n\n @doc \"\"\"\n Converts a `NaiveDateTime` into a `Date`.\n\n Because `Date` does not hold time information,\n data will be lost during the conversion.\n\n ## Examples\n\n iex> NaiveDateTime.to_date(~N[2002-01-13 23:00:07])\n ~D[2002-01-13]\n\n \"\"\"\n @spec to_date(Calendar.naive_datetime()) :: Date.t()\n def to_date(%{\n year: year,\n month: month,\n day: day,\n calendar: calendar,\n hour: _,\n minute: _,\n second: _,\n microsecond: _\n }) do\n %Date{year: year, month: month, day: day, calendar: calendar}\n end\n\n @doc \"\"\"\n Converts a `NaiveDateTime` into `Time`.\n\n Because `Time` does not hold date information,\n data will be lost during the conversion.\n\n ## Examples\n\n iex> NaiveDateTime.to_time(~N[2002-01-13 23:00:07])\n ~T[23:00:07]\n\n \"\"\"\n @spec to_time(Calendar.naive_datetime()) :: Time.t()\n def to_time(%{\n year: _,\n month: _,\n day: _,\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }) do\n %Time{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: calendar\n }\n end\n\n @doc \"\"\"\n Converts the given naive datetime to a string according to its calendar.\n\n For readability, this function follows the RFC3339 suggestion of removing\n the \"T\" separator between the date and time components.\n\n ## Examples\n\n iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13])\n \"2000-02-28 23:00:13\"\n iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13.001])\n \"2000-02-28 23:00:13.001\"\n iex> NaiveDateTime.to_string(~N[-0100-12-15 03:20:31])\n \"-0100-12-15 03:20:31\"\n\n This function can also be used to convert a DateTime to a string without\n the time zone information:\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> NaiveDateTime.to_string(dt)\n \"2000-02-29 23:00:07\"\n\n \"\"\"\n @spec to_string(Calendar.naive_datetime()) :: String.t()\n def to_string(%{calendar: calendar} = naive_datetime) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n } = naive_datetime\n\n calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)\n end\n\n @doc \"\"\"\n Parses the extended \"Date and time of day\" format described by\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n Time zone offset may be included in the string but they will be\n simply discarded as such information is not included in naive date\n times.\n\n As specified in the standard, the separator \"T\" may be omitted if\n desired as there is no ambiguity within this function.\n\n Note leap seconds are not supported by the built-in Calendar.ISO.\n\n ## Examples\n\n iex> NaiveDateTime.from_iso8601(\"2015-01-23 23:50:07\")\n {:ok, ~N[2015-01-23 23:50:07]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07\")\n {:ok, ~N[2015-01-23 23:50:07]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07Z\")\n {:ok, ~N[2015-01-23 23:50:07]}\n\n iex> NaiveDateTime.from_iso8601(\"2015-01-23 23:50:07.0\")\n {:ok, ~N[2015-01-23 23:50:07.0]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23 23:50:07,0123456\")\n {:ok, ~N[2015-01-23 23:50:07.012345]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23 23:50:07.0123456\")\n {:ok, ~N[2015-01-23 23:50:07.012345]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07.123Z\")\n {:ok, ~N[2015-01-23 23:50:07.123]}\n\n iex> NaiveDateTime.from_iso8601(\"2015-01-23P23:50:07\")\n {:error, :invalid_format}\n iex> NaiveDateTime.from_iso8601(\"2015:01:23 23-50-07\")\n {:error, :invalid_format}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23 23:50:07A\")\n {:error, :invalid_format}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23 23:50:61\")\n {:error, :invalid_time}\n iex> NaiveDateTime.from_iso8601(\"2015-01-32 23:50:07\")\n {:error, :invalid_date}\n\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07.123+02:30\")\n {:ok, ~N[2015-01-23 23:50:07.123]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07.123+00:00\")\n {:ok, ~N[2015-01-23 23:50:07.123]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07.123-02:30\")\n {:ok, ~N[2015-01-23 23:50:07.123]}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07.123-00:00\")\n {:error, :invalid_format}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07.123-00:60\")\n {:error, :invalid_format}\n iex> NaiveDateTime.from_iso8601(\"2015-01-23T23:50:07.123-24:00\")\n {:error, :invalid_format}\n\n \"\"\"\n @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}\n def from_iso8601(string, calendar \\\\ Calendar.ISO) do\n with {:ok, {year, month, day, hour, minute, second, microsecond}} <-\n Calendar.ISO.parse_naive_datetime(string) do\n convert(\n %NaiveDateTime{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n },\n calendar\n )\n end\n end\n\n @doc \"\"\"\n Parses the extended \"Date and time of day\" format described by\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n Raises if the format is invalid.\n\n ## Examples\n\n iex> NaiveDateTime.from_iso8601!(\"2015-01-23T23:50:07.123Z\")\n ~N[2015-01-23 23:50:07.123]\n iex> NaiveDateTime.from_iso8601!(\"2015-01-23T23:50:07,123Z\")\n ~N[2015-01-23 23:50:07.123]\n iex> NaiveDateTime.from_iso8601!(\"2015-01-23P23:50:07\")\n ** (ArgumentError) cannot parse \"2015-01-23P23:50:07\" as naive datetime, reason: :invalid_format\n\n \"\"\"\n @spec from_iso8601!(String.t(), Calendar.calendar()) :: t\n def from_iso8601!(string, calendar \\\\ Calendar.ISO) do\n case from_iso8601(string, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot parse #{inspect(string)} as naive datetime, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts the given naive datetime to\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n By default, `NaiveDateTime.to_iso8601/2` returns naive datetimes formatted in the \"extended\"\n format, for human readability. It also supports the \"basic\" format through passing the `:basic` option.\n\n Only supports converting naive datetimes which are in the ISO calendar,\n attempting to convert naive datetimes from other calendars will raise.\n\n ## Examples\n\n iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13])\n \"2000-02-28T23:00:13\"\n\n iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001])\n \"2000-02-28T23:00:13.001\"\n\n iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001], :basic)\n \"20000228T230013.001\"\n\n This function can also be used to convert a DateTime to ISO 8601 without\n the time zone information:\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> NaiveDateTime.to_iso8601(dt)\n \"2000-02-29T23:00:07\"\n\n \"\"\"\n @spec to_iso8601(Calendar.naive_datetime(), :basic | :extended) :: String.t()\n def to_iso8601(naive_datetime, format \\\\ :extended)\n\n def to_iso8601(%{calendar: Calendar.ISO} = naive_datetime, format)\n when format in [:basic, :extended] do\n naive_datetime\n |> to_iso8601_iodata(format)\n |> IO.iodata_to_binary()\n end\n\n def to_iso8601(%{calendar: _} = naive_datetime, format)\n when format in [:basic, :extended] do\n naive_datetime\n |> convert!(Calendar.ISO)\n |> to_iso8601(format)\n end\n\n defp to_iso8601_iodata(naive_datetime, format) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n } = naive_datetime\n\n [\n Calendar.ISO.date_to_iodata(year, month, day, format),\n ?T,\n Calendar.ISO.time_to_iodata(hour, minute, second, microsecond, format)\n ]\n end\n\n @doc \"\"\"\n Converts a `NaiveDateTime` struct to an Erlang datetime tuple.\n\n Only supports converting naive datetimes which are in the ISO calendar,\n attempting to convert naive datetimes from other calendars will raise.\n\n WARNING: Loss of precision may occur, as Erlang time tuples only store\n hour/minute/second.\n\n ## Examples\n\n iex> NaiveDateTime.to_erl(~N[2000-01-01 13:30:15])\n {{2000, 1, 1}, {13, 30, 15}}\n\n This function can also be used to convert a DateTime to an Erlang\n datetime tuple without the time zone information:\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> NaiveDateTime.to_erl(dt)\n {{2000, 2, 29}, {23, 00, 07}}\n\n \"\"\"\n @spec to_erl(Calendar.naive_datetime()) :: :calendar.datetime()\n def to_erl(%{calendar: _} = naive_datetime) do\n %{year: year, month: month, day: day, hour: hour, minute: minute, second: second} =\n convert!(naive_datetime, Calendar.ISO)\n\n {{year, month, day}, {hour, minute, second}}\n end\n\n @doc \"\"\"\n Converts an Erlang datetime tuple to a `NaiveDateTime` struct.\n\n Attempting to convert an invalid ISO calendar date will produce an error tuple.\n\n ## Examples\n\n iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}})\n {:ok, ~N[2000-01-01 13:30:15]}\n iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, 5000)\n {:ok, ~N[2000-01-01 13:30:15.005000]}\n iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})\n {:ok, ~N[2000-01-01 13:30:15.005]}\n iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})\n {:error, :invalid_date}\n iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})\n {:error, :invalid_date}\n\n \"\"\"\n @spec from_erl(\n :calendar.datetime(),\n Calendar.microsecond() | non_neg_integer(),\n Calendar.calendar()\n ) ::\n {:ok, t} | {:error, atom}\n def from_erl(tuple, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO)\n\n def from_erl({{year, month, day}, {hour, minute, second}}, microsecond, calendar) do\n with {:ok, iso_naive_dt} <- new(year, month, day, hour, minute, second, microsecond),\n do: convert(iso_naive_dt, calendar)\n end\n\n @doc \"\"\"\n Converts an Erlang datetime tuple to a `NaiveDateTime` struct.\n\n Raises if the datetime is invalid.\n Attempting to convert an invalid ISO calendar date will produce an error tuple.\n\n ## Examples\n\n iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}})\n ~N[2000-01-01 13:30:15]\n iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, 5000)\n ~N[2000-01-01 13:30:15.005000]\n iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})\n ~N[2000-01-01 13:30:15.005]\n iex> NaiveDateTime.from_erl!({{2000, 13, 1}, {13, 30, 15}})\n ** (ArgumentError) cannot convert {{2000, 13, 1}, {13, 30, 15}} to naive datetime, reason: :invalid_date\n\n \"\"\"\n @spec from_erl!(\n :calendar.datetime(),\n Calendar.microsecond() | non_neg_integer(),\n Calendar.calendar()\n ) :: t\n def from_erl!(tuple, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO) do\n case from_erl(tuple, microsecond, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot convert #{inspect(tuple)} to naive datetime, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts a number of gregorian seconds to a `NaiveDateTime` struct.\n\n ## Examples\n\n iex> NaiveDateTime.from_gregorian_seconds(1)\n ~N[0000-01-01 00:00:01]\n iex> NaiveDateTime.from_gregorian_seconds(63_755_511_991, {5000, 3})\n ~N[2020-05-01 00:26:31.005]\n iex> NaiveDateTime.from_gregorian_seconds(-1)\n ~N[-0001-12-31 23:59:59]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec from_gregorian_seconds(integer(), Calendar.microsecond(), Calendar.calendar()) :: t\n def from_gregorian_seconds(seconds, microsecond_precision \\\\ {0, 0}, calendar \\\\ Calendar.ISO)\n\n def from_gregorian_seconds(seconds, {microsecond, precision}, Calendar.ISO)\n when is_integer(seconds) do\n {days, seconds} = div_rem(seconds, 24 * 60 * 60)\n {hours, seconds} = div_rem(seconds, 60 * 60)\n {minutes, seconds} = div_rem(seconds, 60)\n {year, month, day} = Calendar.ISO.date_from_iso_days(days)\n\n %NaiveDateTime{\n calendar: Calendar.ISO,\n year: year,\n month: month,\n day: day,\n hour: hours,\n minute: minutes,\n second: seconds,\n microsecond: {microsecond, precision}\n }\n end\n\n def from_gregorian_seconds(seconds, {microsecond, precision}, calendar)\n when is_integer(seconds) do\n iso_days = Calendar.ISO.gregorian_seconds_to_iso_days(seconds, microsecond)\n\n {year, month, day, hour, minute, second, {microsecond, _}} =\n calendar.naive_datetime_from_iso_days(iso_days)\n\n %NaiveDateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision}\n }\n end\n\n defp div_rem(int1, int2) do\n div = div(int1, int2)\n rem = int1 - div * int2\n\n if rem >= 0 do\n {div, rem}\n else\n {div - 1, rem + int2}\n end\n end\n\n @doc \"\"\"\n Converts a `NaiveDateTime` struct to a number of gregorian seconds and microseconds.\n\n ## Examples\n\n iex> NaiveDateTime.to_gregorian_seconds(~N[0000-01-01 00:00:01])\n {1, 0}\n iex> NaiveDateTime.to_gregorian_seconds(~N[2020-05-01 00:26:31.005])\n {63_755_511_991, 5000}\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec to_gregorian_seconds(Calendar.naive_datetime()) :: {integer(), non_neg_integer()}\n def to_gregorian_seconds(%{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision}\n }) do\n {days, day_fraction} =\n calendar.naive_datetime_to_iso_days(\n year,\n month,\n day,\n hour,\n minute,\n second,\n {microsecond, precision}\n )\n\n seconds_in_day = seconds_from_day_fraction(day_fraction)\n {days * @seconds_per_day + seconds_in_day, microsecond}\n end\n\n @doc \"\"\"\n Compares two `NaiveDateTime` structs.\n\n Returns `:gt` if first is later than the second\n and `:lt` for vice versa. If the two NaiveDateTime\n are equal `:eq` is returned.\n\n ## Examples\n\n iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15], ~N[2016-04-28 16:19:25])\n :lt\n iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15.1], ~N[2016-04-16 13:30:15.01])\n :gt\n\n This function can also be used to compare a DateTime without\n the time zone information:\n\n iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: \"CET\",\n ...> hour: 23, minute: 0, second: 7, microsecond: {0, 0},\n ...> utc_offset: 3600, std_offset: 0, time_zone: \"Europe/Warsaw\"}\n iex> NaiveDateTime.compare(dt, ~N[2000-02-29 23:00:07])\n :eq\n iex> NaiveDateTime.compare(dt, ~N[2000-01-29 23:00:07])\n :gt\n iex> NaiveDateTime.compare(dt, ~N[2000-03-29 23:00:07])\n :lt\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec compare(Calendar.naive_datetime(), Calendar.naive_datetime()) :: :lt | :eq | :gt\n def compare(%{calendar: calendar1} = naive_datetime1, %{calendar: calendar2} = naive_datetime2) do\n if Calendar.compatible_calendars?(calendar1, calendar2) do\n case {to_iso_days(naive_datetime1), to_iso_days(naive_datetime2)} do\n {first, second} when first > second -> :gt\n {first, second} when first < second -> :lt\n _ -> :eq\n end\n else\n raise ArgumentError, \"\"\"\n cannot compare #{inspect(naive_datetime1)} with #{inspect(naive_datetime2)}.\n\n This comparison would be ambiguous as their calendars have incompatible day rollover moments.\n Specify an exact time of day (using `DateTime`s) to resolve this ambiguity\n \"\"\"\n end\n end\n\n @doc \"\"\"\n Returns `true` if the first `NaiveDateTime` is strictly earlier than the second.\n\n ## Examples\n\n iex> NaiveDateTime.before?(~N[2021-01-01 11:00:00], ~N[2022-02-02 11:00:00])\n true\n iex> NaiveDateTime.before?(~N[2021-01-01 11:00:00], ~N[2021-01-01 11:00:00])\n false\n iex> NaiveDateTime.before?(~N[2022-02-02 11:00:00], ~N[2021-01-01 11:00:00])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec before?(Calendar.naive_datetime(), Calendar.naive_datetime()) :: boolean()\n def before?(naive_datetime1, naive_datetime2) do\n compare(naive_datetime1, naive_datetime2) == :lt\n end\n\n @doc \"\"\"\n Returns `true` if the first `NaiveDateTime` is strictly later than the second.\n\n ## Examples\n\n iex> NaiveDateTime.after?(~N[2022-02-02 11:00:00], ~N[2021-01-01 11:00:00])\n true\n iex> NaiveDateTime.after?(~N[2021-01-01 11:00:00], ~N[2021-01-01 11:00:00])\n false\n iex> NaiveDateTime.after?(~N[2021-01-01 11:00:00], ~N[2022-02-02 11:00:00])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec after?(Calendar.naive_datetime(), Calendar.naive_datetime()) :: boolean()\n def after?(naive_datetime1, naive_datetime2) do\n compare(naive_datetime1, naive_datetime2) == :gt\n end\n\n @doc \"\"\"\n Converts the given `naive_datetime` from one calendar to another.\n\n If it is not possible to convert unambiguously between the calendars\n (see `Calendar.compatible_calendars?/2`), an `{:error, :incompatible_calendars}` tuple\n is returned.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> NaiveDateTime.convert(~N[2000-01-01 13:30:15], Calendar.Holocene)\n {:ok, %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,\n hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert(Calendar.naive_datetime(), Calendar.calendar()) ::\n {:ok, t} | {:error, :incompatible_calendars}\n\n # Keep it multiline for proper function clause errors.\n def convert(%NaiveDateTime{calendar: calendar} = ndt, calendar) do\n {:ok, ndt}\n end\n\n def convert(\n %{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n },\n calendar\n ) do\n naive_datetime = %NaiveDateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n\n {:ok, naive_datetime}\n end\n\n def convert(%{calendar: ndt_calendar, microsecond: {_, precision}} = naive_datetime, calendar) do\n if Calendar.compatible_calendars?(ndt_calendar, calendar) do\n result_naive_datetime =\n naive_datetime\n |> to_iso_days()\n |> from_iso_days(calendar, precision)\n\n {:ok, result_naive_datetime}\n else\n {:error, :incompatible_calendars}\n end\n end\n\n @doc \"\"\"\n Converts the given `naive_datetime` from one calendar to another.\n\n If it is not possible to convert unambiguously between the calendars\n (see `Calendar.compatible_calendars?/2`), an ArgumentError is raised.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> NaiveDateTime.convert!(~N[2000-01-01 13:30:15], Calendar.Holocene)\n %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,\n hour: 13, minute: 30, second: 15, microsecond: {0, 0}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert!(Calendar.naive_datetime(), Calendar.calendar()) :: t\n def convert!(naive_datetime, calendar) do\n case convert(naive_datetime, calendar) do\n {:ok, value} ->\n value\n\n {:error, :incompatible_calendars} ->\n raise ArgumentError,\n \"cannot convert #{inspect(naive_datetime)} to target calendar #{inspect(calendar)}, \" <>\n \"reason: #{inspect(naive_datetime.calendar)} and #{inspect(calendar)} \" <>\n \"have different day rollover moments, making this conversion ambiguous\"\n end\n end\n\n @doc \"\"\"\n Calculates a `NaiveDateTime` that is the first moment for the given `NaiveDateTime`.\n\n To calculate the beginning of day of a `DateTime`, call this function, then convert back to a `DateTime`:\n\n datetime\n |> NaiveDateTime.beginning_of_day()\n |> DateTime.from_naive(datetime.time_zone)\n\n Note that the beginning of the day may not exist or be ambiguous\n in a given timezone, so you must handle those cases accordingly.\n\n ## Examples\n\n iex> NaiveDateTime.beginning_of_day(~N[2000-01-01 23:00:07.123456])\n ~N[2000-01-01 00:00:00.000000]\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec beginning_of_day(Calendar.naive_datetime()) :: t\n def beginning_of_day(%{calendar: calendar, microsecond: {_, precision}} = naive_datetime) do\n naive_datetime\n |> to_iso_days()\n |> calendar.iso_days_to_beginning_of_day()\n |> from_iso_days(calendar, precision)\n end\n\n @doc \"\"\"\n Calculates a `NaiveDateTime` that is the last moment for the given `NaiveDateTime`.\n\n To calculate the end of day of a `DateTime`, call this function, then convert back to a `DateTime`:\n\n datetime\n |> NaiveDateTime.end_of_day()\n |> DateTime.from_naive(datetime.time_zone)\n\n Note that the end of the day may not exist or be ambiguous\n in a given timezone, so you must handle those cases accordingly.\n\n ## Examples\n\n iex> NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.123456])\n ~N[2000-01-01 23:59:59.999999]\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec end_of_day(Calendar.naive_datetime()) :: t\n def end_of_day(%{calendar: calendar, microsecond: {_, precision}} = naive_datetime) do\n end_of_day =\n naive_datetime\n |> to_iso_days()\n |> calendar.iso_days_to_end_of_day()\n |> from_iso_days(calendar, precision)\n\n %{microsecond: {microsecond, precision}} = end_of_day\n\n multiplier = 10 ** (6 - precision)\n\n %{end_of_day | microsecond: {div(microsecond, multiplier) * multiplier, precision}}\n end\n\n ## Helpers\n\n defp seconds_from_day_fraction({parts_in_day, @seconds_per_day}),\n do: parts_in_day\n\n defp seconds_from_day_fraction({parts_in_day, parts_per_day}),\n do: div(parts_in_day * @seconds_per_day, parts_per_day)\n\n # Keep it multiline for proper function clause errors.\n defp to_iso_days(%{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }) do\n calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)\n end\n\n defp from_iso_days(iso_days, calendar, precision) do\n {year, month, day, hour, minute, second, {microsecond, _}} =\n calendar.naive_datetime_from_iso_days(iso_days)\n\n %NaiveDateTime{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision}\n }\n end\n\n defimpl String.Chars do\n def to_string(naive_datetime) do\n %{\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n } = naive_datetime\n\n calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)\n end\n end\n\n defimpl Inspect do\n def inspect(naive_datetime, _) do\n %{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: calendar\n } = naive_datetime\n\n if calendar != Calendar.ISO or year in -9999..9999 do\n formatted =\n calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)\n\n \"~N[\" <> formatted <> suffix(calendar) <> \"]\"\n else\n \"NaiveDateTime.new!(#{Integer.to_string(year)}, #{Integer.to_string(month)}, #{Integer.to_string(day)}, \" <>\n \"#{Integer.to_string(hour)}, #{Integer.to_string(minute)}, #{Integer.to_string(second)}, #{inspect(microsecond)})\"\n end\n end\n\n defp suffix(Calendar.ISO), do: \"\"\n defp suffix(calendar), do: \" \" <> inspect(calendar)\n end\nend\n" }, { "path": "lib/elixir/lib/calendar/time.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Time do\n @moduledoc \"\"\"\n A Time struct and functions.\n\n The Time struct contains the fields hour, minute, second and microseconds.\n New times can be built with the `new/4` function or using the\n `~T` (see `sigil_T/2`) sigil:\n\n iex> ~T[23:00:07.001]\n ~T[23:00:07.001]\n\n Both `new/4` and sigil return a struct where the time fields can\n be accessed directly:\n\n iex> time = ~T[23:00:07.001]\n iex> time.hour\n 23\n iex> time.microsecond\n {1000, 3}\n\n The functions on this module work with the `Time` struct as well\n as any struct that contains the same fields as the `Time` struct,\n such as `NaiveDateTime` and `DateTime`. Such functions expect\n `t:Calendar.time/0` in their typespecs (instead of `t:t/0`).\n\n Developers should avoid creating the Time structs directly\n and instead rely on the functions provided by this module as well\n as the ones in third-party calendar libraries.\n\n ## Comparing times\n\n Comparisons in Elixir using `==/2`, `>/2`, ` Enum.min([~T[23:00:07.001], ~T[10:00:07.001]], Time)\n ~T[10:00:07.001]\n \"\"\"\n\n @enforce_keys [:hour, :minute, :second]\n defstruct [:hour, :minute, :second, microsecond: {0, 0}, calendar: Calendar.ISO]\n\n @type t :: %__MODULE__{\n hour: Calendar.hour(),\n minute: Calendar.minute(),\n second: Calendar.second(),\n microsecond: Calendar.microsecond(),\n calendar: Calendar.calendar()\n }\n\n @seconds_per_day 24 * 60 * 60\n\n @doc \"\"\"\n Returns the current time in UTC.\n\n You can pass a time unit to automatically truncate the resulting time.\n\n The default unit if none gets passed is `:native` which results on a default resolution of microseconds.\n\n ## Examples\n\n iex> time = Time.utc_now()\n iex> time.hour >= 0\n true\n\n iex> time = Time.utc_now(:second)\n iex> time.microsecond\n {0, 0}\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec utc_now(Calendar.calendar() | :native | :microsecond | :millisecond | :second) :: t\n def utc_now(calendar_or_time_unit \\\\ Calendar.ISO) do\n case calendar_or_time_unit do\n unit when unit in [:native, :microsecond, :millisecond, :second] ->\n utc_now(unit, Calendar.ISO)\n\n calendar ->\n utc_now(:native, calendar)\n end\n end\n\n @doc \"\"\"\n Returns the current time in UTC, supporting a precision and a specific calendar.\n\n ## Examples\n\n iex> time = Time.utc_now(:microsecond, Calendar.ISO)\n iex> time.hour >= 0\n true\n\n iex> time = Time.utc_now(:second, Calendar.ISO)\n iex> time.microsecond\n {0, 0}\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec utc_now(:native | :microsecond | :millisecond | :second, Calendar.calendar()) :: t\n def utc_now(time_unit, calendar)\n when time_unit in [:native, :microsecond, :millisecond, :second] do\n {:ok, _, time, microsecond} = Calendar.ISO.from_unix(System.os_time(time_unit), time_unit)\n {hour, minute, second} = time\n\n iso_time = %Time{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: Calendar.ISO\n }\n\n convert!(iso_time, calendar)\n end\n\n @doc \"\"\"\n Builds a new time.\n\n Expects all values to be integers. Returns `{:ok, time}` if each\n entry fits its appropriate range, returns `{:error, reason}` otherwise.\n\n Microseconds can also be given with a precision, which must be an\n integer between 0 and 6.\n\n The built-in calendar does not support leap seconds.\n\n ## Examples\n\n iex> Time.new(0, 0, 0, 0)\n {:ok, ~T[00:00:00.000000]}\n iex> Time.new(23, 59, 59, 999_999)\n {:ok, ~T[23:59:59.999999]}\n\n iex> Time.new(24, 59, 59, 999_999)\n {:error, :invalid_time}\n iex> Time.new(23, 60, 59, 999_999)\n {:error, :invalid_time}\n iex> Time.new(23, 59, 60, 999_999)\n {:error, :invalid_time}\n iex> Time.new(23, 59, 59, 1_000_000)\n {:error, :invalid_time}\n\n # Invalid precision\n Time.new(23, 59, 59, {999_999, 10})\n {:error, :invalid_time}\n\n \"\"\"\n @spec new(\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond() | non_neg_integer(),\n Calendar.calendar()\n ) :: {:ok, t} | {:error, atom}\n def new(hour, minute, second, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO)\n\n def new(hour, minute, second, microsecond, calendar) when is_integer(microsecond) do\n new(hour, minute, second, {microsecond, 6}, calendar)\n end\n\n def new(hour, minute, second, {microsecond, precision}, calendar)\n when is_integer(hour) and is_integer(minute) and is_integer(second) and\n is_integer(microsecond) and is_integer(precision) do\n case calendar.valid_time?(hour, minute, second, {microsecond, precision}) do\n true ->\n time = %Time{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision},\n calendar: calendar\n }\n\n {:ok, time}\n\n false ->\n {:error, :invalid_time}\n end\n end\n\n @doc \"\"\"\n Builds a new time.\n\n Expects all values to be integers. Returns `time` if each\n entry fits its appropriate range, raises if the time is invalid.\n\n Microseconds can also be given with a precision, which must be an\n integer between 0 and 6.\n\n The built-in calendar does not support leap seconds.\n\n ## Examples\n\n iex> Time.new!(0, 0, 0, 0)\n ~T[00:00:00.000000]\n iex> Time.new!(23, 59, 59, 999_999)\n ~T[23:59:59.999999]\n iex> Time.new!(24, 59, 59, 999_999)\n ** (ArgumentError) cannot build time, reason: :invalid_time\n \"\"\"\n @doc since: \"1.11.0\"\n @spec new!(\n Calendar.hour(),\n Calendar.minute(),\n Calendar.second(),\n Calendar.microsecond() | non_neg_integer,\n Calendar.calendar()\n ) :: t\n def new!(hour, minute, second, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO) do\n case new(hour, minute, second, microsecond, calendar) do\n {:ok, time} ->\n time\n\n {:error, reason} ->\n raise ArgumentError, \"cannot build time, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts the given `time` to a string.\n\n ## Examples\n\n iex> Time.to_string(~T[23:00:00])\n \"23:00:00\"\n iex> Time.to_string(~T[23:00:00.001])\n \"23:00:00.001\"\n iex> Time.to_string(~T[23:00:00.123456])\n \"23:00:00.123456\"\n\n iex> Time.to_string(~N[2015-01-01 23:00:00.001])\n \"23:00:00.001\"\n iex> Time.to_string(~N[2015-01-01 23:00:00.123456])\n \"23:00:00.123456\"\n\n \"\"\"\n @spec to_string(Calendar.time()) :: String.t()\n def to_string(time)\n\n def to_string(%{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: calendar\n }) do\n calendar.time_to_string(hour, minute, second, microsecond)\n end\n\n @doc \"\"\"\n Parses the extended \"Local time\" format described by\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n Time zone offset may be included in the string but they will be\n simply discarded as such information is not included in times.\n\n As specified in the standard, the separator \"T\" may be omitted if\n desired as there is no ambiguity within this function.\n\n ## Examples\n\n iex> Time.from_iso8601(\"23:50:07\")\n {:ok, ~T[23:50:07]}\n iex> Time.from_iso8601(\"23:50:07Z\")\n {:ok, ~T[23:50:07]}\n iex> Time.from_iso8601(\"T23:50:07Z\")\n {:ok, ~T[23:50:07]}\n\n iex> Time.from_iso8601(\"23:50:07,0123456\")\n {:ok, ~T[23:50:07.012345]}\n iex> Time.from_iso8601(\"23:50:07.0123456\")\n {:ok, ~T[23:50:07.012345]}\n iex> Time.from_iso8601(\"23:50:07.123Z\")\n {:ok, ~T[23:50:07.123]}\n\n iex> Time.from_iso8601(\"2015:01:23 23-50-07\")\n {:error, :invalid_format}\n iex> Time.from_iso8601(\"23:50:07A\")\n {:error, :invalid_format}\n iex> Time.from_iso8601(\"23:50:07.\")\n {:error, :invalid_format}\n iex> Time.from_iso8601(\"23:50:61\")\n {:error, :invalid_time}\n\n \"\"\"\n @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}\n def from_iso8601(string, calendar \\\\ Calendar.ISO) do\n with {:ok, {hour, minute, second, microsecond}} <- Calendar.ISO.parse_time(string) do\n convert(\n %Time{hour: hour, minute: minute, second: second, microsecond: microsecond},\n calendar\n )\n end\n end\n\n @doc \"\"\"\n Parses the extended \"Local time\" format described by\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n Raises if the format is invalid.\n\n ## Examples\n\n iex> Time.from_iso8601!(\"23:50:07,123Z\")\n ~T[23:50:07.123]\n iex> Time.from_iso8601!(\"23:50:07.123Z\")\n ~T[23:50:07.123]\n iex> Time.from_iso8601!(\"2015:01:23 23-50-07\")\n ** (ArgumentError) cannot parse \"2015:01:23 23-50-07\" as time, reason: :invalid_format\n\n \"\"\"\n @spec from_iso8601!(String.t(), Calendar.calendar()) :: t\n def from_iso8601!(string, calendar \\\\ Calendar.ISO) do\n case from_iso8601(string, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError, \"cannot parse #{inspect(string)} as time, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts the given time to\n [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).\n\n By default, `Time.to_iso8601/2` returns times formatted in the \"extended\"\n format, for human readability. It also supports the \"basic\" format through\n passing the `:basic` option.\n\n ## Examples\n\n iex> Time.to_iso8601(~T[23:00:13])\n \"23:00:13\"\n\n iex> Time.to_iso8601(~T[23:00:13.001])\n \"23:00:13.001\"\n\n iex> Time.to_iso8601(~T[23:00:13.001], :basic)\n \"230013.001\"\n\n iex> Time.to_iso8601(~N[2010-04-17 23:00:13])\n \"23:00:13\"\n\n \"\"\"\n @spec to_iso8601(Calendar.time(), :extended | :basic) :: String.t()\n def to_iso8601(time, format \\\\ :extended)\n\n def to_iso8601(%{calendar: Calendar.ISO} = time, format) when format in [:extended, :basic] do\n %{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n } = time\n\n Calendar.ISO.time_to_string(hour, minute, second, microsecond, format)\n end\n\n def to_iso8601(%{calendar: _} = time, format) when format in [:extended, :basic] do\n time\n |> convert!(Calendar.ISO)\n |> to_iso8601(format)\n end\n\n @doc \"\"\"\n Converts given `time` to an Erlang time tuple.\n\n WARNING: Loss of precision may occur, as Erlang time tuples\n only contain hours/minutes/seconds.\n\n ## Examples\n\n iex> Time.to_erl(~T[23:30:15.999])\n {23, 30, 15}\n\n iex> Time.to_erl(~N[2010-04-17 23:30:15.999])\n {23, 30, 15}\n\n \"\"\"\n @spec to_erl(Calendar.time()) :: :calendar.time()\n def to_erl(time) do\n %{hour: hour, minute: minute, second: second} = convert!(time, Calendar.ISO)\n {hour, minute, second}\n end\n\n @doc \"\"\"\n Converts an Erlang time tuple to a `Time` struct.\n\n ## Examples\n\n iex> Time.from_erl({23, 30, 15})\n {:ok, ~T[23:30:15]}\n iex> Time.from_erl({23, 30, 15}, 5000)\n {:ok, ~T[23:30:15.005000]}\n iex> Time.from_erl({23, 30, 15}, {5000, 3})\n {:ok, ~T[23:30:15.005]}\n iex> Time.from_erl({24, 30, 15})\n {:error, :invalid_time}\n\n \"\"\"\n @spec from_erl(\n :calendar.time(),\n Calendar.microsecond() | non_neg_integer(),\n Calendar.calendar()\n ) ::\n {:ok, t} | {:error, atom}\n def from_erl(tuple, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO)\n\n def from_erl({hour, minute, second}, microsecond, calendar) do\n with {:ok, time} <- new(hour, minute, second, microsecond, Calendar.ISO),\n do: convert(time, calendar)\n end\n\n @doc \"\"\"\n Converts an Erlang time tuple to a `Time` struct.\n\n ## Examples\n\n iex> Time.from_erl!({23, 30, 15})\n ~T[23:30:15]\n iex> Time.from_erl!({23, 30, 15}, 5000)\n ~T[23:30:15.005000]\n iex> Time.from_erl!({23, 30, 15}, {5000, 3})\n ~T[23:30:15.005]\n iex> Time.from_erl!({24, 30, 15})\n ** (ArgumentError) cannot convert {24, 30, 15} to time, reason: :invalid_time\n\n \"\"\"\n @spec from_erl!(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) :: t\n def from_erl!(tuple, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO) do\n case from_erl(tuple, microsecond, calendar) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise ArgumentError,\n \"cannot convert #{inspect(tuple)} to time, reason: #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Converts a number of seconds after midnight to a `Time` struct.\n\n ## Examples\n\n iex> Time.from_seconds_after_midnight(10_000)\n ~T[02:46:40]\n iex> Time.from_seconds_after_midnight(30_000, {5000, 3})\n ~T[08:20:00.005]\n iex> Time.from_seconds_after_midnight(-1)\n ~T[23:59:59]\n iex> Time.from_seconds_after_midnight(100_000)\n ~T[03:46:40]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec from_seconds_after_midnight(\n integer(),\n Calendar.microsecond(),\n Calendar.calendar()\n ) :: t\n def from_seconds_after_midnight(seconds, microsecond \\\\ {0, 0}, calendar \\\\ Calendar.ISO)\n when is_integer(seconds) do\n seconds_in_day = Integer.mod(seconds, @seconds_per_day)\n\n {hour, minute, second, {_, _}} =\n calendar.time_from_day_fraction({seconds_in_day, @seconds_per_day})\n\n %Time{\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n end\n\n @doc \"\"\"\n Converts a `Time` struct to a number of seconds after midnight.\n\n The returned value is a two-element tuple with the number of seconds and microseconds.\n\n ## Examples\n\n iex> Time.to_seconds_after_midnight(~T[23:30:15])\n {84615, 0}\n iex> Time.to_seconds_after_midnight(~N[2010-04-17 23:30:15.999])\n {84615, 999000}\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec to_seconds_after_midnight(Calendar.time()) :: {integer(), non_neg_integer()}\n def to_seconds_after_midnight(%{microsecond: {microsecond, _precision}} = time) do\n iso_days = {0, to_day_fraction(time)}\n {Calendar.ISO.iso_days_to_unit(iso_days, :second), microsecond}\n end\n\n @doc \"\"\"\n Adds the `amount_to_add` of `unit`s to the given `time`.\n\n > #### Prefer `shift/2` {: .info}\n >\n > Prefer `shift/2` over `add/3`, as it offers a more ergonomic API.\n >\n > `add/3` always considers the unit to be computed according to\n > the `Calendar.ISO`.\n\n Accepts an `amount_to_add` in any `unit`. `unit` can be\n `:hour`, `:minute`, `:second` or any subsecond precision from\n `t:System.time_unit/0` for convenience but ultimately they are\n all converted to microseconds. Negative values will move backwards\n in time and the default precision is `:second`.\n\n Note the result value represents the time of day, meaning that it is cyclic,\n for instance, it will never go over 24 hours for the ISO calendar.\n\n ## Examples\n\n iex> Time.add(~T[10:00:00], 27000)\n ~T[17:30:00]\n iex> Time.add(~T[11:00:00.005], 2400)\n ~T[11:40:00.005]\n iex> Time.add(~T[00:00:00.000], 86_399_999, :millisecond)\n ~T[23:59:59.999]\n\n Negative values are allowed:\n\n iex> Time.add(~T[23:00:00], -60)\n ~T[22:59:00]\n\n Note that the time is cyclic:\n\n iex> Time.add(~T[17:10:05], 86400)\n ~T[17:10:05]\n\n Hours and minutes are also supported:\n\n iex> Time.add(~T[17:10:05], 2, :hour)\n ~T[19:10:05]\n iex> Time.add(~T[17:10:05], 30, :minute)\n ~T[17:40:05]\n\n This operation merges the precision of the time with the given unit:\n\n iex> result = Time.add(~T[00:29:10], 21, :millisecond)\n ~T[00:29:10.021]\n iex> result.microsecond\n {21000, 3}\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec add(Calendar.time(), integer, :hour | :minute | System.time_unit()) :: t\n def add(time, amount_to_add, unit \\\\ :second)\n\n def add(time, amount_to_add, :hour) when is_integer(amount_to_add) do\n add(time, amount_to_add * 3600, :second)\n end\n\n def add(time, amount_to_add, :minute) when is_integer(amount_to_add) do\n add(time, amount_to_add * 60, :second)\n end\n\n def add(%{calendar: calendar, microsecond: {_, precision}} = time, amount_to_add, unit)\n when is_integer(amount_to_add) do\n valid? =\n if is_integer(unit),\n do: unit > 0,\n else: unit in ~w(second millisecond microsecond nanosecond)a\n\n if not valid? do\n raise ArgumentError,\n \"unsupported time unit. Expected :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}\"\n end\n\n %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time\n\n precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)\n\n {hour, minute, second, {microsecond, _precision}} =\n Calendar.ISO.shift_time_unit(\n {hour, minute, second, microsecond},\n amount_to_add,\n unit\n )\n\n %Time{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision},\n calendar: calendar\n }\n end\n\n @doc \"\"\"\n Shifts given `time` by `duration` according to its calendar.\n\n Available duration units are: `:hour`, `:minute`, `:second`, `:microsecond`.\n\n When using the default ISO calendar, durations are collapsed to seconds and\n microseconds before they are applied.\n\n Raises an `ArgumentError` when called with date scale units.\n\n ## Examples\n\n iex> Time.shift(~T[01:00:15], hour: 12)\n ~T[13:00:15]\n iex> Time.shift(~T[01:35:00], hour: 6, minute: -15)\n ~T[07:20:00]\n iex> Time.shift(~T[01:15:00], second: 125)\n ~T[01:17:05]\n iex> Time.shift(~T[01:00:15], microsecond: {100, 6})\n ~T[01:00:15.000100]\n iex> Time.shift(~T[01:15:00], Duration.new!(second: 65))\n ~T[01:16:05]\n\n \"\"\"\n @doc since: \"1.17.0\"\n @spec shift(Calendar.time(), Duration.t() | [unit_pair]) :: t\n when unit_pair:\n {:hour, integer}\n | {:minute, integer}\n | {:second, integer}\n | {:microsecond, {integer, 0..6}}\n def shift(%{calendar: calendar} = time, duration) do\n %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time\n\n {hour, minute, second, microsecond} =\n calendar.shift_time(hour, minute, second, microsecond, __duration__!(duration))\n\n %Time{\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n end\n\n @doc false\n def __duration__!(%Duration{} = duration) do\n duration\n end\n\n # This part is inlined by the compiler on constant values\n def __duration__!(unit_pairs) do\n Enum.each(unit_pairs, &validate_duration_unit!/1)\n struct!(Duration, unit_pairs)\n end\n\n defp validate_duration_unit!({:microsecond, {ms, precision}})\n when is_integer(ms) and precision in 0..6 do\n :ok\n end\n\n defp validate_duration_unit!({:microsecond, microsecond}) do\n raise ArgumentError,\n \"unsupported value #{inspect(microsecond)} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6\"\n end\n\n defp validate_duration_unit!({unit, _value}) when unit in [:year, :month, :week, :day] do\n raise ArgumentError,\n \"unsupported unit #{inspect(unit)}. Expected :hour, :minute, :second, :microsecond\"\n end\n\n defp validate_duration_unit!({unit, _value})\n when unit not in [:hour, :minute, :second, :microsecond] do\n raise ArgumentError,\n \"unknown unit #{inspect(unit)}. Expected :hour, :minute, :second, :microsecond\"\n end\n\n defp validate_duration_unit!({_unit, value}) when is_integer(value) do\n :ok\n end\n\n defp validate_duration_unit!({unit, value}) do\n raise ArgumentError,\n \"unsupported value #{inspect(value)} for #{inspect(unit)}. Expected an integer\"\n end\n\n @doc \"\"\"\n Compares two time structs.\n\n Returns `:gt` if first time is later than the second\n and `:lt` for vice versa. If the two times are equal\n `:eq` is returned.\n\n ## Examples\n\n iex> Time.compare(~T[16:04:16], ~T[16:04:28])\n :lt\n iex> Time.compare(~T[16:04:16], ~T[16:04:16])\n :eq\n iex> Time.compare(~T[16:04:16.01], ~T[16:04:16.001])\n :gt\n\n This function can also be used to compare across more\n complex calendar types by considering only the time fields:\n\n iex> Time.compare(~N[1900-01-01 16:04:16], ~N[2015-01-01 16:04:16])\n :eq\n iex> Time.compare(~N[2015-01-01 16:04:16], ~N[2015-01-01 16:04:28])\n :lt\n iex> Time.compare(~N[2015-01-01 16:04:16.01], ~N[2000-01-01 16:04:16.001])\n :gt\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec compare(Calendar.time(), Calendar.time()) :: :lt | :eq | :gt\n def compare(%{calendar: calendar} = time1, %{calendar: calendar} = time2) do\n %{hour: hour1, minute: minute1, second: second1, microsecond: {microsecond1, _}} = time1\n %{hour: hour2, minute: minute2, second: second2, microsecond: {microsecond2, _}} = time2\n\n case {{hour1, minute1, second1, microsecond1}, {hour2, minute2, second2, microsecond2}} do\n {first, second} when first > second -> :gt\n {first, second} when first < second -> :lt\n _ -> :eq\n end\n end\n\n def compare(time1, time2) do\n {parts1, ppd1} = to_day_fraction(time1)\n {parts2, ppd2} = to_day_fraction(time2)\n\n case {parts1 * ppd2, parts2 * ppd1} do\n {first, second} when first > second -> :gt\n {first, second} when first < second -> :lt\n _ -> :eq\n end\n end\n\n @doc \"\"\"\n Returns `true` if the first time is strictly earlier than the second.\n\n ## Examples\n\n iex> Time.before?(~T[16:04:16], ~T[16:04:28])\n true\n iex> Time.before?(~T[16:04:16], ~T[16:04:16])\n false\n iex> Time.before?(~T[16:04:16.01], ~T[16:04:16.001])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec before?(Calendar.time(), Calendar.time()) :: boolean()\n def before?(time1, time2) do\n compare(time1, time2) == :lt\n end\n\n @doc \"\"\"\n Returns `true` if the first time is strictly later than the second.\n\n ## Examples\n\n iex> Time.after?(~T[16:04:28], ~T[16:04:16])\n true\n iex> Time.after?(~T[16:04:16], ~T[16:04:16])\n false\n iex> Time.after?(~T[16:04:16.001], ~T[16:04:16.01])\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec after?(Calendar.time(), Calendar.time()) :: boolean()\n def after?(time1, time2) do\n compare(time1, time2) == :gt\n end\n\n @doc \"\"\"\n Converts given `time` to a different calendar.\n\n Returns `{:ok, time}` if the conversion was successful,\n or `{:error, reason}` if it was not, for some reason.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> Time.convert(~T[13:30:15], Calendar.Holocene)\n {:ok, %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert(Calendar.time(), Calendar.calendar()) :: {:ok, t} | {:error, atom}\n\n # Keep it multiline for proper function clause errors.\n def convert(\n %{\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n },\n calendar\n ) do\n time = %Time{\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n\n {:ok, time}\n end\n\n def convert(%{microsecond: {_, precision}} = time, calendar) do\n {hour, minute, second, {microsecond, _}} =\n time\n |> to_day_fraction()\n |> calendar.time_from_day_fraction()\n\n time = %Time{\n calendar: calendar,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {microsecond, precision}\n }\n\n {:ok, time}\n end\n\n @doc \"\"\"\n Similar to `Time.convert/2`, but raises an `ArgumentError`\n if the conversion between the two calendars is not possible.\n\n ## Examples\n\n Imagine someone implements `Calendar.Holocene`, a calendar based on the\n Gregorian calendar that adds exactly 10 000 years to the current Gregorian\n year:\n\n iex> Time.convert!(~T[13:30:15], Calendar.Holocene)\n %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec convert!(Calendar.time(), Calendar.calendar()) :: t\n def convert!(time, calendar) do\n {:ok, value} = convert(time, calendar)\n value\n end\n\n @doc \"\"\"\n Returns the difference between two times, considering only the hour, minute,\n second and microsecond.\n\n As with the `compare/2` function both `Time` structs and other structures\n containing time can be used. If for instance a `NaiveDateTime` or `DateTime`\n is passed, only the hour, minute, second, and microsecond is considered. Any\n additional information about a date or time zone is ignored when calculating\n the difference.\n\n The answer can be returned in any `:hour`, `:minute`, `:second` or any\n subsecond `unit` available from `t:System.time_unit/0`. If the first time\n value is earlier than the second, a negative number is returned.\n\n The unit is measured according to `Calendar.ISO` and defaults to `:second`.\n Fractional results are not supported and are truncated.\n\n ## Examples\n\n iex> Time.diff(~T[00:29:12], ~T[00:29:10])\n 2\n\n # When passing a `NaiveDateTime` the date part is ignored.\n iex> Time.diff(~N[2017-01-01 00:29:12], ~T[00:29:10])\n 2\n\n # Two `NaiveDateTime` structs could have big differences in the date\n # but only the time part is considered.\n iex> Time.diff(~N[2017-01-01 00:29:12], ~N[1900-02-03 00:29:10])\n 2\n\n iex> Time.diff(~T[00:29:12], ~T[00:29:10], :microsecond)\n 2_000_000\n iex> Time.diff(~T[00:29:10], ~T[00:29:12], :microsecond)\n -2_000_000\n\n iex> Time.diff(~T[02:29:10], ~T[00:29:10], :hour)\n 2\n iex> Time.diff(~T[02:29:10], ~T[00:29:11], :hour)\n 1\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec diff(Calendar.time(), Calendar.time(), :hour | :minute | System.time_unit()) :: integer\n def diff(time1, time2, unit \\\\ :second)\n\n def diff(time1, time2, :hour) do\n diff(time1, time2, :second) |> div(3600)\n end\n\n def diff(time1, time2, :minute) do\n diff(time1, time2, :second) |> div(60)\n end\n\n def diff(\n %{\n calendar: Calendar.ISO,\n hour: hour1,\n minute: minute1,\n second: second1,\n microsecond: {microsecond1, _}\n },\n %{\n calendar: Calendar.ISO,\n hour: hour2,\n minute: minute2,\n second: second2,\n microsecond: {microsecond2, _}\n },\n unit\n ) do\n total =\n (hour1 - hour2) * 3_600_000_000 + (minute1 - minute2) * 60_000_000 +\n (second1 - second2) * 1_000_000 + (microsecond1 - microsecond2)\n\n System.convert_time_unit(total, :microsecond, unit)\n end\n\n def diff(time1, time2, unit) do\n fraction1 = to_day_fraction(time1)\n fraction2 = to_day_fraction(time2)\n\n Calendar.ISO.iso_days_to_unit({0, fraction1}, unit) -\n Calendar.ISO.iso_days_to_unit({0, fraction2}, unit)\n end\n\n @doc \"\"\"\n Returns the given time with the microsecond field truncated to the given\n precision (`:microsecond`, `millisecond` or `:second`).\n\n The given time is returned unchanged if it already has lower precision than\n the given precision.\n\n ## Examples\n\n iex> Time.truncate(~T[01:01:01.123456], :microsecond)\n ~T[01:01:01.123456]\n\n iex> Time.truncate(~T[01:01:01.123456], :millisecond)\n ~T[01:01:01.123]\n\n iex> Time.truncate(~T[01:01:01.123456], :second)\n ~T[01:01:01]\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec truncate(t(), :microsecond | :millisecond | :second) :: t()\n def truncate(%Time{microsecond: microsecond} = time, precision) do\n %{time | microsecond: Calendar.truncate(microsecond, precision)}\n end\n\n ## Helpers\n\n defp to_day_fraction(%{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: {_, _} = microsecond,\n calendar: calendar\n }) do\n calendar.time_to_day_fraction(hour, minute, second, microsecond)\n end\n\n defimpl String.Chars do\n def to_string(time) do\n %{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: calendar\n } = time\n\n calendar.time_to_string(hour, minute, second, microsecond)\n end\n end\n\n defimpl Inspect do\n def inspect(time, _) do\n %{\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: calendar\n } = time\n\n \"~T[\" <>\n calendar.time_to_string(hour, minute, second, microsecond) <> suffix(calendar) <> \"]\"\n end\n\n defp suffix(Calendar.ISO), do: \"\"\n defp suffix(calendar), do: \" \" <> inspect(calendar)\n end\nend\n" }, { "path": "lib/elixir/lib/calendar/time_zone_database.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Calendar.TimeZoneDatabase do\n @moduledoc \"\"\"\n This module defines a behaviour for providing time zone data.\n\n IANA provides time zone data that includes data about different\n UTC offsets and standard offsets for time zones.\n \"\"\"\n\n @typedoc \"\"\"\n A period where a certain combination of UTC offset, standard offset, and zone\n abbreviation is in effect.\n\n For example, one period could be the summer of 2018 in the `Europe/London` timezone,\n where summer time/daylight saving time is in effect and lasts from spring to autumn.\n In autumn, the `std_offset` changes along with the `zone_abbr` so a different\n period is needed during winter.\n \"\"\"\n @type time_zone_period :: %{\n optional(any) => any,\n utc_offset: Calendar.utc_offset(),\n std_offset: Calendar.std_offset(),\n zone_abbr: Calendar.zone_abbr()\n }\n\n @typedoc \"\"\"\n Limit for when a certain time zone period begins or ends.\n\n A beginning is inclusive. An ending is exclusive. For example, if a period is from\n `2015-03-29 01:00:00` and until `2015-10-25 01:00:00`, the period includes and\n begins from the beginning of `2015-03-29 01:00:00` and lasts until just before\n `2015-10-25 01:00:00`.\n\n A beginning or end for certain periods are infinite, such as the latest\n period for time zones without DST or plans to change. However, for the purpose\n of this behaviour, they are only used for gaps in wall time where the needed\n period limits are at a certain time.\n \"\"\"\n @type time_zone_period_limit :: Calendar.naive_datetime()\n\n @doc \"\"\"\n Time zone period for a point in time in UTC for a specific time zone.\n\n Takes a time zone name and a point in time for UTC and returns a\n `time_zone_period` for that point in time.\n \"\"\"\n @doc since: \"1.8.0\"\n @callback time_zone_period_from_utc_iso_days(Calendar.iso_days(), Calendar.time_zone()) ::\n {:ok, time_zone_period}\n | {:error, :time_zone_not_found | :utc_only_time_zone_database}\n\n @doc \"\"\"\n Possible time zone periods for a certain time zone and wall clock date and time.\n\n When the provided naive datetime is ambiguous, return a tuple with `:ambiguous`\n and the two possible periods. The periods in the tuple must be sorted with the\n first element being the one that begins first.\n\n When the provided naive datetime is in a gap, such as during the \"spring forward\" when going\n from winter time to summer time, return a tuple with `:gap` and two periods with limits\n in a nested tuple. The first nested two-tuple is the period before the gap and a naive datetime\n with a limit for when the period ends (wall time). The second nested two-tuple is the period\n just after the gap and a datetime (wall time) for when the period begins just after the gap.\n\n If there is only a single possible period for the provided `datetime`, then return a tuple\n with `:ok` and the `time_zone_period`.\n \"\"\"\n @doc since: \"1.8.0\"\n @callback time_zone_periods_from_wall_datetime(Calendar.naive_datetime(), Calendar.time_zone()) ::\n {:ok, time_zone_period}\n | {:ambiguous, time_zone_period, time_zone_period}\n | {:gap, {time_zone_period, time_zone_period_limit},\n {time_zone_period, time_zone_period_limit}}\n | {:error, :time_zone_not_found | :utc_only_time_zone_database}\nend\n\ndefmodule Calendar.UTCOnlyTimeZoneDatabase do\n @moduledoc \"\"\"\n Built-in time zone database that works only in the `Etc/UTC` timezone.\n\n For all other time zones, it returns `{:error, :utc_only_time_zone_database}`.\n \"\"\"\n\n @behaviour Calendar.TimeZoneDatabase\n\n @impl true\n def time_zone_period_from_utc_iso_days(_, \"Etc/UTC\"),\n do: {:ok, %{std_offset: 0, utc_offset: 0, zone_abbr: \"UTC\"}}\n\n def time_zone_period_from_utc_iso_days(_, _),\n do: {:error, :utc_only_time_zone_database}\n\n @impl true\n def time_zone_periods_from_wall_datetime(_, \"Etc/UTC\"),\n do: {:ok, %{std_offset: 0, utc_offset: 0, zone_abbr: \"UTC\"}}\n\n def time_zone_periods_from_wall_datetime(_, _),\n do: {:error, :utc_only_time_zone_database}\nend\n" }, { "path": "lib/elixir/lib/calendar.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Calendar do\n @moduledoc \"\"\"\n This module defines the responsibilities for working with\n calendars, dates, times and datetimes in Elixir.\n\n It defines types and the minimal implementation\n for a calendar behaviour in Elixir. The goal of the calendar\n features in Elixir is to provide a base for interoperability\n rather than a full-featured datetime API.\n\n For the actual date, time and datetime structs, see `Date`,\n `Time`, `NaiveDateTime`, and `DateTime`.\n\n Types for year, month, day, and more are *overspecified*.\n For example, the `t:month/0` type is specified as an integer\n instead of `1..12`. This is because different calendars may\n have a different number of days per month.\n \"\"\"\n\n @type year :: integer\n @type month :: pos_integer\n @type day :: pos_integer\n @type week :: pos_integer\n @type day_of_week :: non_neg_integer\n @type era :: non_neg_integer\n\n @typedoc \"\"\"\n A tuple representing the `day` and the `era`.\n \"\"\"\n @type day_of_era :: {day :: non_neg_integer(), era}\n\n @type hour :: non_neg_integer\n @type minute :: non_neg_integer\n @type second :: non_neg_integer\n\n @typedoc \"\"\"\n The internal time format is used when converting between calendars.\n\n It represents time as a fraction of a day (starting from midnight).\n `parts_in_day` specifies how much of the day is already passed,\n while `parts_per_day` signifies how many parts are there in a day.\n \"\"\"\n @type day_fraction :: {parts_in_day :: non_neg_integer, parts_per_day :: pos_integer}\n\n @typedoc \"\"\"\n The internal date format that is used when converting between calendars.\n\n This is the number of days including the fractional part that has passed of\n the last day since `0000-01-01+00:00T00:00.000000` in ISO 8601 notation (also\n known as *midnight 1 January BC 1* of the proleptic Gregorian calendar).\n \"\"\"\n @type iso_days :: {days :: integer, day_fraction}\n\n @typedoc \"\"\"\n Microseconds with stored precision.\n\n `value` always represents the total value in microseconds.\n\n The `precision` represents the number of digits that must be used when\n representing the microseconds to external format. If the precision is `0`,\n it means microseconds must be skipped. If the precision is `6`, it means\n that `value` represents exactly the number of microseconds to be used.\n\n ## Examples\n\n * `{0, 0}` means no microseconds.\n * `{1, 6}` means 1µs.\n * `{1000, 6}` means 1000µs (which is 1ms but measured at the microsecond precision).\n * `{1000, 3}` means 1ms (which is measured at the millisecond precision).\n\n \"\"\"\n @type microsecond :: {value :: non_neg_integer, precision :: non_neg_integer}\n\n @typedoc \"A calendar implementation.\"\n @type calendar :: module\n\n @typedoc \"The time zone ID according to the IANA tz database (for example, `Europe/Zurich`).\"\n @type time_zone :: String.t()\n\n @typedoc \"The time zone abbreviation (for example, `CET` or `CEST` or `BST`).\"\n @type zone_abbr :: String.t()\n\n @typedoc \"\"\"\n The time zone UTC offset in ISO seconds for standard time.\n\n See also `t:std_offset/0`.\n \"\"\"\n @type utc_offset :: integer\n\n @typedoc \"\"\"\n The time zone standard offset in ISO seconds (typically not zero in summer times).\n\n It must be added to `t:utc_offset/0` to get the total offset from UTC used for \"wall time\".\n \"\"\"\n @type std_offset :: integer\n\n @typedoc \"Any map or struct that contains the date fields.\"\n @type date :: %{optional(any) => any, calendar: calendar, year: year, month: month, day: day}\n\n @typedoc \"Any map or struct that contains the time fields.\"\n @type time :: %{\n optional(any) => any,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n\n @typedoc \"Any map or struct that contains the naive datetime fields.\"\n @type naive_datetime :: %{\n optional(any) => any,\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond\n }\n\n @typedoc \"Any map or struct that contains the datetime fields.\"\n @type datetime :: %{\n optional(any) => any,\n calendar: calendar,\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n time_zone: time_zone,\n zone_abbr: zone_abbr,\n utc_offset: utc_offset,\n std_offset: std_offset\n }\n\n @typedoc \"\"\"\n Specifies the time zone database for calendar operations.\n\n Many functions in the `DateTime` module require a time zone database.\n By default, this module uses the default time zone database returned by\n `Calendar.get_time_zone_database/0`, which defaults to\n `Calendar.UTCOnlyTimeZoneDatabase`. This database only handles `Etc/UTC`\n datetimes and returns `{:error, :utc_only_time_zone_database}`\n for any other time zone.\n\n Other time zone databases (including ones provided by packages)\n can be configured as default either via configuration:\n\n config :elixir, :time_zone_database, CustomTimeZoneDatabase\n\n or by calling `Calendar.put_time_zone_database/1`.\n\n See `Calendar.TimeZoneDatabase` for more information on custom\n time zone databases.\n \"\"\"\n @type time_zone_database :: module()\n\n @typedoc \"\"\"\n Options for formatting dates and times with `strftime/3`.\n \"\"\"\n @type strftime_opts :: [\n preferred_datetime: String.t(),\n preferred_date: String.t(),\n preferred_time: String.t(),\n am_pm_names: (:am | :pm -> String.t()) | (:am | :pm, map() -> String.t()),\n month_names: (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t()),\n abbreviated_month_names:\n (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t()),\n day_of_week_names: (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t()),\n abbreviated_day_of_week_names:\n (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t())\n ]\n\n @doc \"\"\"\n Returns how many days there are in the given month of the given year.\n \"\"\"\n @callback days_in_month(year, month) :: day\n\n @doc \"\"\"\n Returns how many months there are in the given year.\n \"\"\"\n @callback months_in_year(year) :: month\n\n @doc \"\"\"\n Returns `true` if the given year is a leap year.\n\n A leap year is a year of a longer length than normal. The exact meaning\n is up to the calendar. A calendar must return `false` if it does not support\n the concept of leap years.\n \"\"\"\n @callback leap_year?(year) :: boolean\n\n @doc \"\"\"\n Calculates the day of the week from the given `year`, `month`, and `day`.\n\n `starting_on` represents the starting day of the week. All\n calendars must support at least the `:default` value. They may\n also support other values representing their days of the week.\n\n The value of `day_of_week` is an ordinal number meaning that a\n value of `1` is defined to mean \"first day of the week\". It is\n specifically not defined to mean `1` is `Monday`.\n\n It is a requirement that `first_day_of_week` is less than `last_day_of_week`\n and that `day_of_week` must be within that range. Therefore it can be said\n that `day_of_week in first_day_of_week..last_day_of_week//1` must be\n `true` for all values of `day_of_week`.\n \"\"\"\n @callback day_of_week(year, month, day, starting_on :: :default | atom) ::\n {day_of_week(), first_day_of_week :: non_neg_integer(),\n last_day_of_week :: non_neg_integer()}\n\n @doc \"\"\"\n Calculates the day of the year from the given `year`, `month`, and `day`.\n \"\"\"\n @callback day_of_year(year, month, day) :: non_neg_integer()\n\n @doc \"\"\"\n Calculates the quarter of the year from the given `year`, `month`, and `day`.\n \"\"\"\n @callback quarter_of_year(year, month, day) :: non_neg_integer()\n\n @doc \"\"\"\n Calculates the year and era from the given `year`.\n \"\"\"\n @callback year_of_era(year, month, day) :: {year, era}\n\n @doc \"\"\"\n Calculates the day and era from the given `year`, `month`, and `day`.\n \"\"\"\n @callback day_of_era(year, month, day) :: day_of_era()\n\n @doc \"\"\"\n Converts the date into a string according to the calendar.\n \"\"\"\n @callback date_to_string(year, month, day) :: String.t()\n\n @doc \"\"\"\n Converts the naive datetime (without time zone) into a string according to the calendar.\n \"\"\"\n @callback naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) ::\n String.t()\n\n @doc \"\"\"\n Converts the datetime (with time zone) into a string according to the calendar.\n \"\"\"\n @callback datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n zone_abbr,\n utc_offset,\n std_offset\n ) :: String.t()\n\n @doc \"\"\"\n Converts the time into a string according to the calendar.\n \"\"\"\n @callback time_to_string(hour, minute, second, microsecond) :: String.t()\n\n @doc \"\"\"\n Converts the datetime (without time zone) into the `t:iso_days/0` format.\n \"\"\"\n @callback naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) ::\n iso_days\n\n @doc \"\"\"\n Converts `t:iso_days/0` to the calendar's datetime format.\n \"\"\"\n @callback naive_datetime_from_iso_days(iso_days) ::\n {year, month, day, hour, minute, second, microsecond}\n\n @doc \"\"\"\n Converts the given time to the `t:day_fraction/0` format.\n \"\"\"\n @callback time_to_day_fraction(hour, minute, second, microsecond) :: day_fraction\n\n @doc \"\"\"\n Converts `t:day_fraction/0` to the calendar's time format.\n \"\"\"\n @callback time_from_day_fraction(day_fraction) :: {hour, minute, second, microsecond}\n\n @doc \"\"\"\n Define the rollover moment for the calendar.\n\n This is the moment, in your calendar, when the current day ends\n and the next day starts.\n\n The result of this function is used to check if two calendars roll over at\n the same time of day. If they do not, we can only convert datetimes and times\n between them. If they do, this means that we can also convert dates as well\n as naive datetimes between them.\n\n This day fraction should be in its most simplified form possible, to make comparisons fast.\n\n ## Examples\n\n * If in your calendar a new day starts at midnight, return `{0, 1}`.\n * If in your calendar a new day starts at sunrise, return `{1, 4}`.\n * If in your calendar a new day starts at noon, return `{1, 2}`.\n * If in your calendar a new day starts at sunset, return `{3, 4}`.\n\n \"\"\"\n @callback day_rollover_relative_to_midnight_utc() :: day_fraction\n\n @doc \"\"\"\n Should return `true` if the given date describes a proper date in the calendar.\n \"\"\"\n @callback valid_date?(year, month, day) :: boolean\n\n @doc \"\"\"\n Should return `true` if the given time describes a proper time in the calendar.\n \"\"\"\n @callback valid_time?(hour, minute, second, microsecond) :: boolean\n\n @doc \"\"\"\n Parses the string representation for a time returned by `c:time_to_string/4`\n into a time tuple.\n \"\"\"\n @doc since: \"1.10.0\"\n @callback parse_time(String.t()) ::\n {:ok, {hour, minute, second, microsecond}}\n | {:error, atom}\n\n @doc \"\"\"\n Parses the string representation for a date returned by `c:date_to_string/3`\n into a date tuple.\n \"\"\"\n @doc since: \"1.10.0\"\n @callback parse_date(String.t()) ::\n {:ok, {year, month, day}}\n | {:error, atom}\n\n @doc \"\"\"\n Parses the string representation for a naive datetime returned by\n `c:naive_datetime_to_string/7` into a naive datetime tuple.\n\n The given string may contain a timezone offset but it is ignored.\n \"\"\"\n @doc since: \"1.10.0\"\n @callback parse_naive_datetime(String.t()) ::\n {:ok, {year, month, day, hour, minute, second, microsecond}}\n | {:error, atom}\n\n @doc \"\"\"\n Parses the string representation for a datetime returned by\n `c:datetime_to_string/11` into a datetime tuple.\n\n The returned datetime must be in UTC. The original `utc_offset`\n it was written in must be returned in the result.\n \"\"\"\n @doc since: \"1.10.0\"\n @callback parse_utc_datetime(String.t()) ::\n {:ok, {year, month, day, hour, minute, second, microsecond}, utc_offset}\n | {:error, atom}\n\n @doc \"\"\"\n Converts the given `t:iso_days/0` to the first moment of the day.\n \"\"\"\n @doc since: \"1.15.0\"\n @callback iso_days_to_beginning_of_day(iso_days) :: iso_days\n\n @doc \"\"\"\n Converts the given `t:iso_days/0` to the last moment of the day.\n \"\"\"\n @doc since: \"1.15.0\"\n @callback iso_days_to_end_of_day(iso_days) :: iso_days\n\n @doc \"\"\"\n Shifts date by given duration according to its calendar.\n \"\"\"\n @doc since: \"1.17.0\"\n @callback shift_date(year, month, day, Duration.t()) :: {year, month, day}\n\n @doc \"\"\"\n Shifts naive datetime by given duration according to its calendar.\n \"\"\"\n @doc since: \"1.17.0\"\n @callback shift_naive_datetime(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n Duration.t()\n ) :: {year, month, day, hour, minute, second, microsecond}\n\n @doc \"\"\"\n Shifts time by given duration according to its calendar.\n \"\"\"\n @doc since: \"1.17.0\"\n @callback shift_time(hour, minute, second, microsecond, Duration.t()) ::\n {hour, minute, second, microsecond}\n\n # General Helpers\n\n @doc \"\"\"\n Returns `true` if two calendars have the same moment of starting a new day,\n `false` otherwise.\n\n If two calendars are not compatible, we can only convert datetimes and times\n between them. If they are compatible, this means that we can also convert\n dates as well as naive datetimes between them.\n \"\"\"\n @doc since: \"1.5.0\"\n @spec compatible_calendars?(Calendar.calendar(), Calendar.calendar()) :: boolean\n def compatible_calendars?(calendar, calendar), do: true\n\n def compatible_calendars?(calendar1, calendar2) do\n calendar1.day_rollover_relative_to_midnight_utc() ==\n calendar2.day_rollover_relative_to_midnight_utc()\n end\n\n @doc \"\"\"\n Returns a microsecond tuple truncated to a given precision (`:microsecond`,\n `:millisecond`, or `:second`).\n \"\"\"\n @doc since: \"1.6.0\"\n @spec truncate(Calendar.microsecond(), :microsecond | :millisecond | :second) ::\n Calendar.microsecond()\n def truncate(microsecond_tuple, :microsecond), do: microsecond_tuple\n\n def truncate({microsecond, precision}, :millisecond) do\n output_precision = min(precision, 3)\n {div(microsecond, 1000) * 1000, output_precision}\n end\n\n def truncate(_, :second), do: {0, 0}\n\n @doc \"\"\"\n Sets the current time zone database.\n \"\"\"\n @doc since: \"1.8.0\"\n @spec put_time_zone_database(time_zone_database()) :: :ok\n def put_time_zone_database(database) when is_atom(database) do\n Application.put_env(:elixir, :time_zone_database, database)\n end\n\n @doc \"\"\"\n Gets the current time zone database.\n \"\"\"\n @doc since: \"1.8.0\"\n @spec get_time_zone_database() :: time_zone_database()\n def get_time_zone_database() do\n Application.fetch_env!(:elixir, :time_zone_database)\n end\n\n @doc \"\"\"\n Formats the given date, time, or datetime into a string.\n\n The datetime can be any of the `Calendar` types (`Time`, `Date`,\n `NaiveDateTime`, and `DateTime`) or any map, as long as they\n contain all of the relevant fields necessary for formatting.\n For example, if you use `%Y` to format the year, the datetime\n must have the `:year` field. Therefore, if you pass a `Time`,\n or a map without the `:year` field to a format that expects `%Y`,\n an error will be raised.\n\n Examples of common usage:\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], \"%y-%m-%d %I:%M:%S %p\")\n \"19-08-26 01:52:06 PM\"\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], \"%a, %B %d %Y\")\n \"Mon, August 26 2019\"\n\n ## User Options\n\n * `:preferred_datetime` - a string for the preferred format to show datetimes,\n it can't contain the `%c` format and defaults to `\"%Y-%m-%d %H:%M:%S\"`\n if the option is not received\n\n * `:preferred_date` - a string for the preferred format to show dates,\n it can't contain the `%x` format and defaults to `\"%Y-%m-%d\"`\n if the option is not received\n\n * `:preferred_time` - a string for the preferred format to show times,\n it can't contain the `%X` format and defaults to `\"%H:%M:%S\"`\n if the option is not received\n\n * `:am_pm_names` - a function that receives either `:am` or `:pm`\n (and also the datetime if the function is arity/2) and returns\n the name of the period of the day, if the option is not received it defaults\n to a function that returns `\"am\"` and `\"pm\"`, respectively\n\n * `:month_names` - a function that receives a number (and also the\n datetime if the function is arity/2) and returns the name of\n the corresponding month, if the option is not received it defaults to a\n function that returns the month names in English\n\n * `:abbreviated_month_names` - a function that receives a number (and also\n the datetime if the function is arity/2) and returns the\n abbreviated name of the corresponding month, if the option is not received it\n defaults to a function that returns the abbreviated month names in English\n\n * `:day_of_week_names` - a function that receives a number and (and also the\n datetime if the function is arity/2) returns the name of\n the corresponding day of week, if the option is not received it defaults to a\n function that returns the day of week names in English\n\n * `:abbreviated_day_of_week_names` - a function that receives a number (and also\n the datetime if the function is arity/2) and returns the abbreviated name of\n the corresponding day of week, if the option is not received it defaults to a\n function that returns the abbreviated day of week names in English\n\n ## Formatting syntax\n\n The formatting syntax for the `string_format` argument is a sequence of characters in\n the following format:\n\n %\n\n where:\n\n * `%`: indicates the start of a formatted section\n * ``: set the padding (see below)\n * ``: a number indicating the minimum size of the formatted section\n * ``: the format itself (see below)\n\n ### Accepted padding options\n\n * `-`: no padding, removes all padding from the format\n * `_`: pad with spaces\n * `0`: pad with zeroes\n\n ### Accepted string formats\n\n The accepted formats for `string_format` are:\n\n Format | Description | Examples (in ISO)\n :----- | :-----------------------------------------------------------------------| :------------------------\n a | Abbreviated name of day | Mon\n A | Full name of day | Monday\n b | Abbreviated month name | Jan\n B | Full month name | January\n c | Preferred date+time representation | 2018-10-17 12:34:56\n d | Day of the month | 01, 31\n f | Microseconds (uses its precision for width and padding) | 000000, 999999, 0123\n H | Hour using a 24-hour clock | 00, 23\n I | Hour using a 12-hour clock | 01, 12\n j | Day of the year | 001, 366\n m | Month | 01, 12\n M | Minute | 00, 59\n p | \"AM\" or \"PM\" (noon is \"PM\", midnight as \"AM\") | AM, PM\n P | \"am\" or \"pm\" (noon is \"pm\", midnight as \"am\") | am, pm\n q | Quarter | 1, 2, 3, 4\n s | Number of seconds since the Epoch, 1970-01-01 00:00:00+0000 (UTC) | 1565888877\n S | Second | 00, 59, 60\n u | Day of the week | 1 (Monday), 7 (Sunday)\n x | Preferred date (without time) representation | 2018-10-17\n X | Preferred time (without date) representation | 12:34:56\n y | Year as 2-digits | 01, 01, 86, 18\n Y | Year | -0001, 0001, 1986\n z | +hhmm/-hhmm time zone offset from UTC (empty string if naive) | +0300, -0530\n Z | Time zone abbreviation (empty string if naive) | CET, BRST\n % | Literal \"%\" character | %\n\n Any other character will be interpreted as an invalid format and raise an error.\n\n ### `%f` Microseconds\n\n `%f` does not support width and padding modifiers. It will be formatted by truncating\n the microseconds to the precision of the `microseconds` field of the struct, with a\n minimum precision of 1.\n\n ## Examples\n\n Without user options:\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], \"%y-%m-%d %I:%M:%S %p\")\n \"19-08-26 01:52:06 PM\"\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], \"%a, %B %d %Y\")\n \"Mon, August 26 2019\"\n\n iex> Calendar.strftime(~U[2020-04-02 13:52:06.0Z], \"%B %-d, %Y\")\n \"April 2, 2020\"\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], \"%c\")\n \"2019-08-26 13:52:06\"\n\n With user options:\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], \"%c\", preferred_datetime: \"%H:%M:%S %d-%m-%y\")\n \"13:52:06 26-08-19\"\n\n iex> Calendar.strftime(\n ...> ~U[2019-08-26 13:52:06.0Z],\n ...> \"%A\",\n ...> day_of_week_names: fn day_of_week ->\n ...> {\"segunda-feira\", \"terça-feira\", \"quarta-feira\", \"quinta-feira\",\n ...> \"sexta-feira\", \"sábado\", \"domingo\"}\n ...> |> elem(day_of_week - 1)\n ...> end\n ...>)\n \"segunda-feira\"\n\n iex> Calendar.strftime(\n ...> ~U[2019-08-26 13:52:06.0Z],\n ...> \"%B\",\n ...> month_names: fn month ->\n ...> {\"січень\", \"лютий\", \"березень\", \"квітень\", \"травень\", \"червень\",\n ...> \"липень\", \"серпень\", \"вересень\", \"жовтень\", \"листопад\", \"грудень\"}\n ...> |> elem(month - 1)\n ...> end\n ...>)\n \"серпень\"\n\n Microsecond formatting:\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06Z], \"%y-%m-%d %H:%M:%S.%f\")\n \"19-08-26 13:52:06.0\"\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.048Z], \"%y-%m-%d %H:%M:%S.%f\")\n \"19-08-26 13:52:06.048\"\n\n iex> Calendar.strftime(~U[2019-08-26 13:52:06.048531Z], \"%y-%m-%d %H:%M:%S.%f\")\n \"19-08-26 13:52:06.048531\"\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec strftime(map(), String.t(), strftime_opts()) :: String.t()\n def strftime(date_or_time_or_datetime, string_format, user_options \\\\ [])\n when is_map(date_or_time_or_datetime) and is_binary(string_format) do\n parse(\n string_format,\n date_or_time_or_datetime,\n options(user_options),\n []\n )\n |> IO.iodata_to_binary()\n end\n\n defp parse(\"\", _datetime, _format_options, acc),\n do: Enum.reverse(acc)\n\n defp parse(\"%\" <> rest, datetime, format_options, acc),\n do: parse_modifiers(rest, nil, nil, {datetime, format_options, acc})\n\n defp parse(<>, datetime, format_options, acc),\n do: parse(rest, datetime, format_options, [char | acc])\n\n defp parse_modifiers(\"-\" <> rest, width, nil, parser_data) do\n parse_modifiers(rest, width, \"\", parser_data)\n end\n\n defp parse_modifiers(\"0\" <> rest, nil, nil, parser_data) do\n parse_modifiers(rest, nil, ?0, parser_data)\n end\n\n defp parse_modifiers(\"_\" <> rest, width, nil, parser_data) do\n parse_modifiers(rest, width, ?\\s, parser_data)\n end\n\n defp parse_modifiers(<>, width, pad, parser_data) when digit in ?0..?9 do\n new_width = (width || 0) * 10 + (digit - ?0)\n\n parse_modifiers(rest, new_width, pad, parser_data)\n end\n\n # set default padding if none was specified\n defp parse_modifiers(<> = rest, width, nil, parser_data) do\n parse_modifiers(rest, width, default_pad(format), parser_data)\n end\n\n # set default width if none was specified\n defp parse_modifiers(<> = rest, nil, pad, parser_data) do\n parse_modifiers(rest, default_width(format), pad, parser_data)\n end\n\n defp parse_modifiers(rest, width, pad, {datetime, format_options, acc}) do\n format_modifiers(rest, width, pad, datetime, format_options, acc)\n end\n\n defp am_pm(hour, format_options, datetime) when hour > 11 do\n apply_format(:pm, format_options.am_pm_names, datetime)\n end\n\n defp am_pm(hour, format_options, datetime) when hour <= 11 do\n apply_format(:am, format_options.am_pm_names, datetime)\n end\n\n defp default_pad(format) when format in ~c\"aAbBpPZ\", do: ?\\s\n defp default_pad(_format), do: ?0\n\n defp default_width(format) when format in ~c\"dHImMSy\", do: 2\n defp default_width(?j), do: 3\n defp default_width(format) when format in ~c\"Yz\", do: 4\n defp default_width(_format), do: 0\n\n # Literally just %\n defp format_modifiers(\"%\" <> rest, width, pad, datetime, format_options, acc) do\n parse(rest, datetime, format_options, [pad_leading(\"%\", width, pad) | acc])\n end\n\n # Abbreviated name of day\n defp format_modifiers(\"a\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n datetime\n |> Date.day_of_week()\n |> apply_format(format_options.abbreviated_day_of_week_names, datetime)\n |> pad_leading(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Full name of day\n defp format_modifiers(\"A\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n datetime\n |> Date.day_of_week()\n |> apply_format(format_options.day_of_week_names, datetime)\n |> pad_leading(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Abbreviated month name\n defp format_modifiers(\"b\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n datetime.month\n |> apply_format(format_options.abbreviated_month_names, datetime)\n |> pad_leading(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Full month name\n defp format_modifiers(\"B\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n datetime.month\n |> apply_format(format_options.month_names, datetime)\n |> pad_leading(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Preferred date+time representation\n defp format_modifiers(\n \"c\" <> _rest,\n _width,\n _pad,\n _datetime,\n %{preferred_datetime_invoked: true},\n _acc\n ) do\n raise ArgumentError,\n \"tried to format preferred_datetime within another preferred_datetime format\"\n end\n\n defp format_modifiers(\"c\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n format_options.preferred_datetime\n |> parse(datetime, %{format_options | preferred_datetime_invoked: true}, [])\n |> pad_preferred(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Day of the month\n defp format_modifiers(\"d\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime.day |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Microseconds\n defp format_modifiers(\"f\" <> rest, _width, _pad, datetime, format_options, acc) do\n {microsecond, precision} = datetime.microsecond\n\n result =\n microsecond\n |> Integer.to_string()\n |> String.pad_leading(6, \"0\")\n |> binary_part(0, max(precision, 1))\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Hour using a 24-hour clock\n defp format_modifiers(\"H\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime.hour |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Hour using a 12-hour clock\n defp format_modifiers(\"I\" <> rest, width, pad, datetime, format_options, acc) do\n result = (rem(datetime.hour + 23, 12) + 1) |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Day of the year\n defp format_modifiers(\"j\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime |> Date.day_of_year() |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Month\n defp format_modifiers(\"m\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime.month |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Minute\n defp format_modifiers(\"M\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime.minute |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # \"AM\" or \"PM\" (noon is \"PM\", midnight as \"AM\")\n defp format_modifiers(\"p\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n datetime.hour\n |> am_pm(format_options, datetime)\n |> String.upcase()\n |> pad_leading(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # \"am\" or \"pm\" (noon is \"pm\", midnight as \"am\")\n defp format_modifiers(\"P\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n datetime.hour\n |> am_pm(format_options, datetime)\n |> String.downcase()\n |> pad_leading(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Quarter\n defp format_modifiers(\"q\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime |> Date.quarter_of_year() |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Second\n defp format_modifiers(\"S\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime.second |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Day of the week\n defp format_modifiers(\"u\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime |> Date.day_of_week() |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Preferred date (without time) representation\n defp format_modifiers(\n \"x\" <> _rest,\n _width,\n _pad,\n _datetime,\n %{preferred_date_invoked: true},\n _acc\n ) do\n raise ArgumentError,\n \"tried to format preferred_date within another preferred_date format\"\n end\n\n defp format_modifiers(\"x\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n format_options.preferred_date\n |> parse(datetime, %{format_options | preferred_date_invoked: true}, [])\n |> pad_preferred(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Preferred time (without date) representation\n defp format_modifiers(\n \"X\" <> _rest,\n _width,\n _pad,\n _datetime,\n %{preferred_time_invoked: true},\n _acc\n ) do\n raise ArgumentError,\n \"tried to format preferred_time within another preferred_time format\"\n end\n\n defp format_modifiers(\"X\" <> rest, width, pad, datetime, format_options, acc) do\n result =\n format_options.preferred_time\n |> parse(datetime, %{format_options | preferred_time_invoked: true}, [])\n |> pad_preferred(width, pad)\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Year as 2-digits\n defp format_modifiers(\"y\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime.year |> rem(100) |> Integer.to_string() |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Year\n defp format_modifiers(\"Y\" <> rest, width, pad, datetime, format_options, acc) do\n {sign, year} =\n if datetime.year < 0 do\n {?-, -datetime.year}\n else\n {[], datetime.year}\n end\n\n result = [sign | year |> Integer.to_string() |> pad_leading(width, pad)]\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Epoch time for DateTime with time zones\n defp format_modifiers(\n \"s\" <> rest,\n _width,\n _pad,\n datetime = %{utc_offset: _utc_offset, std_offset: _std_offset},\n format_options,\n acc\n ) do\n result =\n datetime\n |> DateTime.shift_zone!(\"Etc/UTC\")\n |> NaiveDateTime.diff(~N[1970-01-01 00:00:00])\n |> Integer.to_string()\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # Epoch time\n defp format_modifiers(\"s\" <> rest, _width, _pad, datetime, format_options, acc) do\n result =\n datetime\n |> NaiveDateTime.diff(~N[1970-01-01 00:00:00])\n |> Integer.to_string()\n\n parse(rest, datetime, format_options, [result | acc])\n end\n\n # +hhmm/-hhmm time zone offset from UTC (empty string if naive)\n defp format_modifiers(\n \"z\" <> rest,\n width,\n pad,\n datetime = %{utc_offset: utc_offset, std_offset: std_offset},\n format_options,\n acc\n ) do\n absolute_offset = abs(utc_offset + std_offset)\n\n offset_number =\n Integer.to_string(div(absolute_offset, 3600) * 100 + rem(div(absolute_offset, 60), 60))\n\n sign = if utc_offset + std_offset >= 0, do: \"+\", else: \"-\"\n result = \"#{sign}#{pad_leading(offset_number, width, pad)}\"\n parse(rest, datetime, format_options, [result | acc])\n end\n\n defp format_modifiers(\"z\" <> rest, _width, _pad, datetime, format_options, acc) do\n parse(rest, datetime, format_options, [\"\" | acc])\n end\n\n # Time zone abbreviation (empty string if naive)\n defp format_modifiers(\"Z\" <> rest, width, pad, datetime, format_options, acc) do\n result = datetime |> Map.get(:zone_abbr, \"\") |> pad_leading(width, pad)\n parse(rest, datetime, format_options, [result | acc])\n end\n\n defp format_modifiers(rest, _width, _pad, _datetime, _format_options, _acc) do\n {next, _rest} = String.next_grapheme(rest) || {\"\", \"\"}\n raise ArgumentError, \"invalid strftime format: %#{next}\"\n end\n\n defp pad_preferred(result, width, pad) when length(result) < width do\n pad_preferred([pad | result], width, pad)\n end\n\n defp pad_preferred(result, _width, _pad), do: result\n\n defp pad_leading(string, count, padding) do\n to_pad = count - byte_size(string)\n if to_pad > 0, do: do_pad_leading(to_pad, padding, string), else: string\n end\n\n defp do_pad_leading(0, _, acc), do: acc\n\n defp do_pad_leading(count, padding, acc),\n do: do_pad_leading(count - 1, padding, [padding | acc])\n\n defp apply_format(term, formatter, _datetime) when is_function(formatter, 1) do\n formatter.(term)\n end\n\n defp apply_format(term, formatter, datetime) when is_function(formatter, 2) do\n formatter.(term, datetime)\n end\n\n defp apply_format(_term, formatter, _datetime) do\n raise ArgumentError, \"formatter functions must be of arity 1 or 2, got: #{inspect(formatter)}\"\n end\n\n defp options(user_options) do\n default_options = %{\n preferred_date: \"%Y-%m-%d\",\n preferred_time: \"%H:%M:%S\",\n preferred_datetime: \"%Y-%m-%d %H:%M:%S\",\n am_pm_names: fn\n :am -> \"am\"\n :pm -> \"pm\"\n end,\n month_names: fn month ->\n {\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\",\n \"October\", \"November\", \"December\"}\n |> elem(month - 1)\n end,\n day_of_week_names: fn day_of_week ->\n {\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"}\n |> elem(day_of_week - 1)\n end,\n abbreviated_month_names: fn month ->\n {\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"}\n |> elem(month - 1)\n end,\n abbreviated_day_of_week_names: fn day_of_week ->\n {\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\"} |> elem(day_of_week - 1)\n end,\n preferred_datetime_invoked: false,\n preferred_date_invoked: false,\n preferred_time_invoked: false\n }\n\n Enum.reduce(user_options, default_options, fn {key, value}, acc ->\n if Map.has_key?(acc, key) do\n %{acc | key => value}\n else\n raise ArgumentError, \"unknown option #{inspect(key)} given to Calendar.strftime/3\"\n end\n end)\n end\nend\n" }, { "path": "lib/elixir/lib/code/formatter.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Code.Formatter do\n @moduledoc false\n import Inspect.Algebra, except: [format: 2, surround: 3, surround: 4]\n\n @double_quote \"\\\"\"\n @double_heredoc \"\\\"\\\"\\\"\"\n @single_quote \"'\"\n @single_heredoc \"'''\"\n @sigil_c_double \"~c\\\"\"\n @sigil_c_single \"~c'\"\n @sigil_c_heredoc \"~c\\\"\\\"\\\"\"\n @newlines 2\n @min_line 0\n @max_line 9_999_999\n @empty empty()\n @ampersand_prec Code.Identifier.unary_op(:&) |> elem(1)\n\n # Operators that are composed of multiple binary operators\n @multi_binary_operators [:..//]\n\n # Operators that do not have space between operands\n @no_space_binary_operators [:.., :\"//\"]\n\n # Operators that do not have newline between operands (as well as => and keywords)\n @no_newline_binary_operators [:\\\\, :in]\n\n # Left associative operators that start on the next line in case of breaks (always pipes)\n @pipeline_operators [:|>, :~>>, :<<~, :~>, :<~, :<~>, :\"<|>\"]\n\n # Right associative operators that start on the next line in case of breaks\n @right_new_line_before_binary_operators [:|, :when]\n\n # Operators that are logical cannot be mixed without parens\n @required_parens_logical_binary_operands [:|||, :||, :or, :&&&, :&&, :and]\n\n # Operators with next break fits\n @next_break_fits_operators [:<-, :==, :!=, :=~, :===, :!==, :<, :>, :<=, :>=, :=, :\"::\"]\n\n # Operators that always require parens even\n # when they are their own parents as they are not semantically associative\n @required_parens_even_when_parent [:--, :---]\n\n # Operators that always require parens on operands\n # when they are the parent of another operator with a difference precedence\n # Most operators are listed, except comparison, arithmetic, and low precedence\n @required_parens_on_binary_operands [\n :<<<,\n :>>>,\n :|>,\n :<~,\n :~>,\n :<<~,\n :~>>,\n :<~>,\n :\"<|>\",\n :in,\n :\"^^^\",\n :\"//\",\n :++,\n :--,\n :+++,\n :---,\n :<>,\n :..\n ]\n\n @locals_without_parens [\n # Special forms\n alias: 1,\n alias: 2,\n case: 2,\n cond: 1,\n for: :*,\n import: 1,\n import: 2,\n quote: 1,\n quote: 2,\n receive: 1,\n require: 1,\n require: 2,\n try: 1,\n with: :*,\n\n # Kernel\n def: 1,\n def: 2,\n defp: 1,\n defp: 2,\n defguard: 1,\n defguardp: 1,\n defmacro: 1,\n defmacro: 2,\n defmacrop: 1,\n defmacrop: 2,\n defmodule: 2,\n defdelegate: 2,\n defexception: 1,\n defoverridable: 1,\n defstruct: 1,\n destructure: 2,\n raise: 1,\n raise: 2,\n reraise: 2,\n reraise: 3,\n if: 2,\n unless: 2,\n use: 1,\n use: 2,\n\n # Stdlib,\n defrecord: 2,\n defrecord: 3,\n defrecordp: 2,\n defrecordp: 3,\n\n # Testing\n assert: 1,\n assert: 2,\n assert_in_delta: 3,\n assert_in_delta: 4,\n assert_raise: 2,\n assert_raise: 3,\n assert_receive: 1,\n assert_receive: 2,\n assert_receive: 3,\n assert_received: 1,\n assert_received: 2,\n doctest: 1,\n doctest: 2,\n refute: 1,\n refute: 2,\n refute_in_delta: 3,\n refute_in_delta: 4,\n refute_receive: 1,\n refute_receive: 2,\n refute_receive: 3,\n refute_received: 1,\n refute_received: 2,\n setup: 1,\n setup: 2,\n setup_all: 1,\n setup_all: 2,\n test: 1,\n test: 2,\n\n # Mix config\n config: 2,\n config: 3,\n import_config: 1\n ]\n\n @do_end_keywords [:rescue, :catch, :else, :after]\n\n @doc \"\"\"\n Converts the quoted expression into an algebra document.\n \"\"\"\n @spec to_algebra(Macro.t(), keyword()) :: Inspect.Algebra.t()\n def to_algebra(quoted, opts \\\\ []) do\n comments = Keyword.get(opts, :comments, [])\n\n state =\n comments\n |> Enum.map(&format_comment/1)\n |> gather_comments()\n |> state(opts)\n\n {doc, _} = block_to_algebra(quoted, @min_line, @max_line, state)\n doc\n end\n\n @doc \"\"\"\n Lists all default locals without parens.\n \"\"\"\n def locals_without_parens do\n @locals_without_parens\n end\n\n @doc \"\"\"\n Checks if a function is a local without parens.\n \"\"\"\n def local_without_parens?(fun, arity, locals_without_parens) do\n arity > 0 and\n Enum.any?(locals_without_parens, fn {key, val} ->\n key == fun and (val == :* or val == arity)\n end)\n end\n\n defp state(comments, opts) do\n force_do_end_blocks = Keyword.get(opts, :force_do_end_blocks, false)\n locals_without_parens = Keyword.get(opts, :locals_without_parens, [])\n file = Keyword.get(opts, :file, nil)\n sigils = Keyword.get(opts, :sigils, [])\n migrate = Keyword.get(opts, :migrate, false)\n migrate_bitstring_modifiers = Keyword.get(opts, :migrate_bitstring_modifiers, migrate)\n migrate_call_parens_on_pipe = Keyword.get(opts, :migrate_call_parens_on_pipe, migrate)\n migrate_charlists_as_sigils = Keyword.get(opts, :migrate_charlists_as_sigils, migrate)\n migrate_unless = Keyword.get(opts, :migrate_unless, migrate)\n syntax_colors = Keyword.get(opts, :syntax_colors, [])\n\n sigils =\n Map.new(sigils, fn {key, value} ->\n with true <- is_atom(key) and is_function(value, 2),\n name = Atom.to_charlist(key),\n true <- Enum.all?(name, &(&1 in ?A..?Z)) do\n {name, value}\n else\n _ ->\n raise ArgumentError,\n \":sigils must be a keyword list with uppercased atoms as keys and an \" <>\n \"anonymous function expecting two arguments as value, got: #{inspect(sigils)}\"\n end\n end)\n\n %{\n force_do_end_blocks: force_do_end_blocks,\n locals_without_parens: locals_without_parens ++ locals_without_parens(),\n operand_nesting: 2,\n skip_eol: false,\n comments: comments,\n sigils: sigils,\n file: file,\n migrate_bitstring_modifiers: migrate_bitstring_modifiers,\n migrate_call_parens_on_pipe: migrate_call_parens_on_pipe,\n migrate_charlists_as_sigils: migrate_charlists_as_sigils,\n migrate_unless: migrate_unless,\n inspect_opts: %Inspect.Opts{syntax_colors: syntax_colors}\n }\n end\n\n defp format_comment(%{text: text} = comment) do\n %{comment | text: format_comment_text(text)}\n end\n\n defp format_comment_text(\"#\"), do: \"#\"\n defp format_comment_text(\"#!\" <> rest), do: \"#!\" <> rest\n defp format_comment_text(\"##\" <> rest), do: \"#\" <> format_comment_text(\"#\" <> rest)\n defp format_comment_text(\"# \" <> rest), do: \"# \" <> rest\n defp format_comment_text(\"#\" <> rest), do: \"# \" <> rest\n\n # If there is a no new line before, we can't gather all followup comments.\n defp gather_comments([%{previous_eol_count: 0} = comment | comments]) do\n comment = %{comment | previous_eol_count: @newlines}\n [comment | gather_comments(comments)]\n end\n\n defp gather_comments([comment | comments]) do\n %{line: line, next_eol_count: next_eol_count, text: doc} = comment\n\n {next_eol_count, comments, doc} =\n gather_followup_comments(line + 1, next_eol_count, comments, doc)\n\n comment = %{comment | next_eol_count: next_eol_count, text: doc}\n [comment | gather_comments(comments)]\n end\n\n defp gather_comments([]) do\n []\n end\n\n defp gather_followup_comments(line, _, [%{line: line} = comment | comments], doc)\n when comment.previous_eol_count != 0 do\n %{next_eol_count: next_eol_count, text: text} = comment\n gather_followup_comments(line + 1, next_eol_count, comments, line(doc, text))\n end\n\n defp gather_followup_comments(_line, next_eol_count, comments, doc) do\n {next_eol_count, comments, doc}\n end\n\n # Special AST nodes from compiler feedback\n\n defp quoted_to_algebra({{:special, :clause_args}, _meta, [args]}, _context, state) do\n {doc, state} = clause_args_to_algebra(args, state)\n {group(doc), state}\n end\n\n defp quoted_to_algebra({{:special, :bitstring_segment}, _meta, [arg, last]}, _context, state) do\n bitstring_segment_to_algebra({arg, -1}, state, last)\n end\n\n defp quoted_to_algebra({var, _meta, var_context}, _context, state) when is_atom(var_context) do\n {var |> Atom.to_string() |> string() |> color_doc(:variable, state.inspect_opts), state}\n end\n\n defp quoted_to_algebra({:<<>>, meta, entries}, _context, state) do\n cond do\n entries == [] ->\n {\"<<>>\", state}\n\n not interpolated?(entries) ->\n bitstring_to_algebra(meta, entries, state)\n\n meta[:delimiter] == ~s[\"\"\"] ->\n {doc, state} =\n entries\n |> prepend_heredoc_line()\n |> interpolation_to_algebra(~s[\"\"\"], state, @double_heredoc, @double_heredoc)\n\n {force_unfit(doc), state}\n\n true ->\n interpolation_to_algebra(entries, @double_quote, state, @double_quote, @double_quote)\n end\n end\n\n # TODO: Remove this clause on Elixir v2.0 once single-quoted charlists are removed\n defp quoted_to_algebra(\n {{:., _, [List, :to_charlist]}, meta, [entries]} = quoted,\n context,\n state\n ) do\n cond do\n not list_interpolated?(entries) ->\n remote_to_algebra(quoted, context, state)\n\n meta[:delimiter] == ~s['''] ->\n {opener, quotes} = get_charlist_quotes(:heredoc, state)\n\n {doc, state} =\n entries\n |> prepend_heredoc_line()\n |> list_interpolation_to_algebra(quotes, state, opener, quotes)\n\n {force_unfit(doc), state}\n\n true ->\n {opener, quotes} = get_charlist_quotes({:regular, entries}, state)\n list_interpolation_to_algebra(entries, quotes, state, opener, quotes)\n end\n end\n\n defp quoted_to_algebra(\n {{:., _, [:erlang, :binary_to_atom]}, _, [{:<<>>, _, entries}, :utf8]} = quoted,\n context,\n state\n ) do\n if interpolated?(entries) do\n interpolation_to_algebra(entries, @double_quote, state, \":\\\"\", @double_quote)\n else\n remote_to_algebra(quoted, context, state)\n end\n end\n\n # foo[bar]\n defp quoted_to_algebra({{:., _, [Access, :get]}, meta, [target, arg]}, _context, state) do\n {target_doc, state} = remote_target_to_algebra(target, state)\n\n {access_doc, state} =\n if keyword?(arg) do\n list_to_algebra(meta, arg, state)\n else\n list_to_algebra(meta, [arg], state)\n end\n\n {concat(target_doc, access_doc), state}\n end\n\n # %Foo{}\n # %name{foo: 1}\n # %name{bar | foo: 1}\n defp quoted_to_algebra({:%, _, [name, {:%{}, meta, args}]}, _context, state) do\n {name_doc, state} = quoted_to_algebra(name, :parens_arg, state)\n map_to_algebra(meta, name_doc, args, state)\n end\n\n # %{foo: 1}\n # %{foo => bar}\n # %{name | foo => bar}\n defp quoted_to_algebra({:%{}, meta, args}, _context, state) do\n map_to_algebra(meta, @empty, args, state)\n end\n\n # {}\n # {1, 2}\n defp quoted_to_algebra({:{}, meta, args}, _context, state) do\n tuple_to_algebra(meta, args, :flex_break, state)\n end\n\n defp quoted_to_algebra({:__block__, meta, [{left, right}]}, _context, state) do\n tuple_to_algebra(meta, [left, right], :flex_break, state)\n end\n\n # (left -> right)\n defp quoted_to_algebra({:__block__, _, [[{:->, _, _} | _] = clauses]}, _context, state) do\n paren_fun_to_algebra(clauses, @max_line, @min_line, state)\n end\n\n defp quoted_to_algebra({:__block__, meta, [list]}, _context, state) when is_list(list) do\n case meta[:delimiter] do\n ~s['''] ->\n {opener, quotes} = get_charlist_quotes(:heredoc, state)\n string = list |> List.to_string() |> escape_heredoc(quotes)\n {opener |> concat(string) |> concat(quotes) |> force_unfit(), state}\n\n ~s['] ->\n string = list |> List.to_string()\n {opener, quotes} = get_charlist_quotes({:regular, [string]}, state)\n string = escape_string(string, quotes)\n {opener |> concat(string) |> concat(quotes), state}\n\n _other ->\n list_to_algebra(meta, list, state)\n end\n end\n\n defp quoted_to_algebra({:__block__, meta, [string]}, _context, state) when is_binary(string) do\n if meta[:delimiter] == ~s[\"\"\"] do\n string = escape_heredoc(string, ~s[\"\"\"])\n\n {@double_heredoc\n |> concat(string)\n |> concat(@double_heredoc)\n |> color_doc(:string, state.inspect_opts)\n |> force_unfit(), state}\n else\n string = escape_string(string, @double_quote)\n\n {@double_quote\n |> concat(string)\n |> concat(@double_quote)\n |> color_doc(:string, state.inspect_opts), state}\n end\n end\n\n defp quoted_to_algebra({:__block__, meta, [atom]}, _context, state) when is_atom(atom) do\n {atom_to_algebra(atom, meta, state.inspect_opts), state}\n end\n\n defp quoted_to_algebra({:__block__, meta, [integer]}, _context, state)\n when is_integer(integer) do\n {Keyword.fetch!(meta, :token) |> integer_to_algebra(state.inspect_opts), state}\n end\n\n defp quoted_to_algebra({:__block__, meta, [float]}, _context, state) when is_float(float) do\n {Keyword.fetch!(meta, :token) |> float_to_algebra(state.inspect_opts), state}\n end\n\n # (unquote_splicing(...))\n defp quoted_to_algebra(\n {:__block__, _meta, [{:unquote_splicing, meta, [_] = args}]},\n context,\n state\n ) do\n {doc, state} = local_to_algebra(:unquote_splicing, meta, args, context, state)\n {wrap_in_parens(doc), state}\n end\n\n defp quoted_to_algebra({:__block__, _meta, [arg]}, context, state) do\n quoted_to_algebra(arg, context, state)\n end\n\n defp quoted_to_algebra({:__block__, _meta, []}, _context, state) do\n {color_doc(\"nil\", nil, state.inspect_opts), state}\n end\n\n defp quoted_to_algebra({:__block__, meta, args} = block, _context, state) when is_list(args) do\n {block, state} = block_to_algebra(block, line(meta), closing_line(meta), state)\n {surround(\"(\", block, \")\"), state}\n end\n\n defp quoted_to_algebra({:__aliases__, _meta, [head | tail]}, context, state) do\n {doc, state} =\n if is_atom(head) do\n {Atom.to_string(head), state}\n else\n quoted_to_algebra_with_parens_if_operator(head, context, state)\n end\n\n {Enum.reduce(tail, doc, &concat(&2, \".\" <> Atom.to_string(&1)))\n |> color_doc(:atom, state.inspect_opts), state}\n end\n\n # &1\n # &local(&1)\n # &local/1\n # &Mod.remote/1\n # & &1\n # & &1 + &2\n defp quoted_to_algebra({:&, _, [arg]}, context, state) do\n capture_to_algebra(arg, context, state)\n end\n\n defp quoted_to_algebra({:@, meta, [arg]}, context, state) do\n module_attribute_to_algebra(meta, arg, context, state)\n end\n\n # not(left in right)\n # left not in right\n defp quoted_to_algebra({:not, meta, [{:in, _, [left, right]}]}, context, state) do\n binary_op_to_algebra(:in, \"not in\", meta, left, right, context, state)\n end\n\n # disable migrate_call_parens_on_pipe within defmacro\n defp quoted_to_algebra(\n {atom, _, [{:|>, _, _}, _]} = ast,\n context,\n %{migrate_call_parens_on_pipe: true} = state\n )\n when atom in [:defmacro, :defmacrop] do\n quoted_to_algebra(ast, context, %{state | migrate_call_parens_on_pipe: false})\n end\n\n defp quoted_to_algebra(\n {atom, _, [{:unless, _, _}, _]} = ast,\n context,\n %{migrate_unless: true} = state\n )\n when atom in [:defmacro, :defmacrop] do\n quoted_to_algebra(ast, context, %{state | migrate_unless: false})\n end\n\n # rewrite unless as if!\n defp quoted_to_algebra(\n {:unless, meta, [condition, block]},\n context,\n %{migrate_unless: true} = state\n ) do\n quoted_to_algebra({:if, meta, [negate_condition(condition), block]}, context, state)\n end\n\n # a |> b() |> unless(...) => a |> b() |> Kernel.!() |> unless(...)\n defp quoted_to_algebra(\n {:|>, meta1, [{:|>, _, _} = condition, {:unless, meta2, [block]}]},\n context,\n %{migrate_unless: true} = state\n ) do\n negated_condition = {:|>, [], [condition, {{:., [], [Kernel, :!]}, [closing: []], []}]}\n\n quoted_to_algebra(\n {:|>, meta1, [negated_condition, {:if, meta2, [block]}]},\n context,\n state\n )\n end\n\n # condition |> unless(...) => negated(condition) |> unless(...)\n defp quoted_to_algebra(\n {:|>, meta1, [condition, {:unless, meta2, [block]}]},\n context,\n %{migrate_unless: true} = state\n ) do\n quoted_to_algebra(\n {:|>, meta1, [negate_condition(condition), {:if, meta2, [block]}]},\n context,\n state\n )\n end\n\n # ..\n defp quoted_to_algebra({:.., _meta, []}, context, state) do\n if context in [:no_parens_arg, :no_parens_one_arg] do\n {\"(..)\", state}\n else\n {\"..\", state}\n end\n end\n\n # ...\n defp quoted_to_algebra({:..., _meta, []}, _context, state) do\n {\"...\", state}\n end\n\n # 1..2//3\n defp quoted_to_algebra({:..//, meta, [left, middle, right]}, context, state) do\n quoted_to_algebra({:\"//\", meta, [{:.., meta, [left, middle]}, right]}, context, state)\n end\n\n defp quoted_to_algebra({:fn, meta, [_ | _] = clauses}, _context, state) do\n anon_fun_to_algebra(clauses, line(meta), closing_line(meta), state, eol?(meta, state))\n end\n\n defp quoted_to_algebra({fun, meta, args}, context, state) when is_atom(fun) and is_list(args) do\n with :error <- maybe_sigil_to_algebra(fun, meta, args, state),\n :error <- maybe_unary_op_to_algebra(fun, meta, args, context, state),\n :error <- maybe_binary_op_to_algebra(fun, meta, args, context, state),\n do: local_to_algebra(fun, meta, args, context, state)\n end\n\n defp quoted_to_algebra({_, _, args} = quoted, context, state) when is_list(args) do\n remote_to_algebra(quoted, context, state)\n end\n\n # [keyword: :list] (inner part)\n # %{:foo => :bar} (inner part)\n defp quoted_to_algebra(list, context, state) when is_list(list) do\n many_args_to_algebra(list, state, "ed_to_algebra(&1, context, &2))\n end\n\n # keyword: :list\n # key => value\n defp quoted_to_algebra({left_arg, right_arg}, context, state) do\n {left, op, right, state} =\n if keyword_key?(left_arg) do\n {left, state} =\n case left_arg do\n {:__block__, _, [atom]} when is_atom(atom) ->\n formatted = Macro.inspect_atom(:key, atom, escape: &escape_atom/2)\n\n {formatted\n |> string()\n |> color_doc(:atom, state.inspect_opts), state}\n\n {{:., _, [:erlang, :binary_to_atom]}, _, [{:<<>>, _, entries}, :utf8]} ->\n interpolation_to_algebra(entries, @double_quote, state, \"\\\"\", \"\\\":\")\n end\n\n {right, state} = quoted_to_algebra(right_arg, context, state)\n {left, \"\", right, state}\n else\n {left, state} = quoted_to_algebra(left_arg, context, state)\n {right, state} = quoted_to_algebra(right_arg, context, state)\n left = wrap_in_parens_if_binary_operator(left, left_arg)\n {left, \" =>\", right, state}\n end\n\n doc =\n concat(\n group(left),\n with_next_break_fits(next_break_fits?(right_arg, state), right, fn right ->\n nest(glue(op, right), 2, :break)\n end)\n )\n\n {doc, state}\n end\n\n # #PID's and #Ref's may appear on regular AST\n # Other foreign structures, such as maps and structs,\n # may appear from Macro.to_string, so we stick a limit,\n # although they won't be formatted accordingly.\n defp quoted_to_algebra(unknown, _context, state) do\n {inspect(unknown, printable_limit: :infinity), state}\n end\n\n ## Blocks\n\n defp block_to_algebra([{:->, _, _} | _] = paren_fun, min_line, max_line, state) do\n paren_fun_to_algebra(paren_fun, min_line, max_line, state)\n end\n\n defp block_to_algebra({:__block__, _, []}, min_line, max_line, state) do\n block_args_to_algebra([], min_line, max_line, state)\n end\n\n defp block_to_algebra({:__block__, _, [_, _ | _] = args}, min_line, max_line, state) do\n block_args_to_algebra(args, min_line, max_line, state)\n end\n\n defp block_to_algebra(block, min_line, max_line, state) do\n block_args_to_algebra([block], min_line, max_line, state)\n end\n\n defp block_args_to_algebra(args, min_line, max_line, state) do\n quoted_to_algebra = fn {kind, meta, _} = arg, _args, state ->\n newlines = meta[:end_of_expression][:newlines] || 1\n {doc, state} = quoted_to_algebra(arg, :block, state)\n {{doc, block_next_line(kind), newlines}, state}\n end\n\n {args_docs, _comments?, state} =\n quoted_to_algebra_with_comments(args, [], min_line, max_line, state, quoted_to_algebra)\n\n case args_docs do\n [] -> {@empty, state}\n [line] -> {line, state}\n lines -> {lines |> Enum.reduce(&line(&2, &1)) |> force_unfit(), state}\n end\n end\n\n defp block_next_line(:@), do: @empty\n defp block_next_line(_), do: break(\"\")\n\n ## Operators\n\n defp maybe_unary_op_to_algebra(fun, meta, args, context, state) do\n with [arg] <- args,\n {_, _} <- Code.Identifier.unary_op(fun) do\n unary_op_to_algebra(fun, meta, arg, context, state)\n else\n _ -> :error\n end\n end\n\n defp unary_op_to_algebra(op, _meta, arg, context, state) do\n {doc, state} = quoted_to_algebra(arg, force_many_args_or_operand(context, :operand), state)\n\n # not and ! are nestable, all others are not.\n doc =\n case arg do\n {^op, _, [_]} when op in [:!, :not] -> doc\n _ -> wrap_in_parens_if_operator(doc, arg)\n end\n\n # not requires a space unless the doc was wrapped in parens.\n op_string =\n if op == :not do\n \"not \"\n else\n Atom.to_string(op)\n end\n\n {color_doc(op_string, :operator, state.inspect_opts) |> concat(doc), state}\n end\n\n defp maybe_binary_op_to_algebra(fun, meta, args, context, state) do\n with [left, right] <- args,\n {_, _} <- augmented_binary_op(fun) do\n binary_op_to_algebra(fun, Atom.to_string(fun), meta, left, right, context, state)\n else\n _ -> :error\n end\n end\n\n # There are five kinds of operators.\n #\n # 1. no space binary operators, for example, 1..2\n # 2. no newline binary operators, for example, left in right\n # 3. strict newlines before a left precedent operator, for example, foo |> bar |> baz\n # 4. strict newlines before a right precedent operator, for example, foo when bar when baz\n # 5. flex newlines after the operator, for example, foo ++ bar ++ baz\n #\n # Cases 1, 2 and 5 are handled fairly easily by relying on the\n # operator precedence and making sure nesting is applied only once.\n #\n # Cases 3 and 4 are the complex ones, as it requires passing the\n # strict or flex mode around.\n defp binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state) do\n %{operand_nesting: nesting} = state\n binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state, nesting)\n end\n\n defp binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state, _nesting)\n when op in @right_new_line_before_binary_operators do\n op_info = augmented_binary_op(op)\n op_string = op_string <> \" \"\n left_context = left_op_context(context)\n right_context = right_op_context(context)\n\n min_line =\n case left_arg do\n {_, left_meta, _} -> line(left_meta)\n _ -> line(meta)\n end\n\n {operands, max_line} =\n unwrap_right(right_arg, op, meta, right_context, [{{:root, left_context}, left_arg}])\n\n fun = fn\n {{:root, context}, arg}, _args, state ->\n {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, :left, 2)\n {{doc, @empty, 1}, state}\n\n {{kind, context}, arg}, _args, state ->\n {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, kind, 0)\n doc = doc |> nest_by_length(op_string) |> force_keyword(arg)\n {{concat(op_string, doc), @empty, 1}, state}\n end\n\n {doc, state} =\n operand_to_algebra_with_comments(operands, meta, min_line, max_line, context, state, fun)\n\n if keyword?(right_arg) and context in [:parens_arg, :no_parens_arg] do\n {wrap_in_parens(doc), state}\n else\n {doc, state}\n end\n end\n\n defp binary_op_to_algebra(op, _, meta, left_arg, right_arg, context, state, _nesting)\n when op in @pipeline_operators do\n op_info = augmented_binary_op(op)\n left_context = left_op_context(context)\n right_context = right_op_context(context)\n max_line = line(meta)\n\n {pipes, min_line} =\n unwrap_pipes(left_arg, meta, left_context, [{{op, right_context}, right_arg}])\n\n fun = fn\n {{:root, context}, arg}, _args, state ->\n {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, :left, 2)\n {{doc, @empty, 1}, state}\n\n {{op, context}, arg}, _args, state ->\n op_info = augmented_binary_op(op)\n op_string = Atom.to_string(op) <> \" \"\n {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, :right, 0)\n {{concat(op_string, doc), @empty, 1}, state}\n end\n\n operand_to_algebra_with_comments(pipes, meta, min_line, max_line, context, state, fun)\n end\n\n defp binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state, nesting) do\n op_info = augmented_binary_op(op)\n left_context = left_op_context(context)\n right_context = right_op_context(context)\n\n {left, state} =\n binary_operand_to_algebra(left_arg, left_context, state, op, op_info, :left, 2)\n\n {right, state} =\n binary_operand_to_algebra(right_arg, right_context, state, op, op_info, :right, 0)\n\n {op_string, right} =\n cond do\n op in @no_space_binary_operators ->\n {op_string, group(right)}\n\n op in @no_newline_binary_operators ->\n {\" \" <> op_string <> \" \", group(right)}\n\n true ->\n eol? = eol?(meta, state)\n\n next_break_fits? =\n op in @next_break_fits_operators and next_break_fits?(right_arg, state) and not eol?\n\n {\" \" <> op_string,\n with_next_break_fits(next_break_fits?, right, fn right ->\n right = nest(concat(break(), right), nesting, :break)\n if eol?, do: force_unfit(right), else: right\n end)}\n end\n\n op_doc = color_doc(op_string, :operator, state.inspect_opts)\n doc = concat(concat(group(left), op_doc), group(right))\n {doc, state}\n end\n\n # TODO: We can remove this workaround once we remove\n # ?rearrange_uop from the parser on v2.0.\n # (! left) in right\n # (not left) in right\n defp binary_operand_to_algebra(\n {:__block__, _, [{op, meta, [arg]}]},\n context,\n state,\n :in,\n _parent_info,\n :left,\n _nesting\n )\n when op in [:not, :!] do\n {doc, state} = unary_op_to_algebra(op, meta, arg, context, state)\n {wrap_in_parens(doc), state}\n end\n\n # |> var\n # |> var()\n defp binary_operand_to_algebra(\n {var, meta, var_context},\n context,\n %{migrate_call_parens_on_pipe: true} = state,\n :|>,\n _parent_info,\n :right,\n _nesting\n )\n when is_atom(var) and is_atom(var_context) do\n operand = {var, meta, []}\n quoted_to_algebra(operand, context, state)\n end\n\n # |> var.fun\n # |> var.fun()\n defp binary_operand_to_algebra(\n {{:., _, [_, fun]} = call, meta, []},\n context,\n %{migrate_call_parens_on_pipe: true} = state,\n :|>,\n _parent_info,\n :right,\n _nesting\n )\n when is_atom(fun) do\n meta = Keyword.put_new_lazy(meta, :closing, fn -> [line: meta[:line]] end)\n quoted_to_algebra({call, meta, []}, context, state)\n end\n\n defp binary_operand_to_algebra(operand, context, state, parent_op, parent_info, side, nesting) do\n {parent_assoc, parent_prec} = parent_info\n\n with {op, meta, [left, right]} <- operand,\n op_info = augmented_binary_op(op),\n {_assoc, prec} <- op_info do\n op_string = Atom.to_string(op)\n\n cond do\n # If we have the same operator and it is in the correct side,\n # we don't add parens unless it is explicitly required.\n parent_assoc == side and op == parent_op and op not in @required_parens_even_when_parent ->\n binary_op_to_algebra(op, op_string, meta, left, right, context, state, nesting)\n\n # If the operator requires parens (most of them do) or we are mixing logical operators\n # or the precedence is inverted or it is in the wrong side, then we *need* parenthesis.\n (parent_op in @required_parens_on_binary_operands and op not in @no_space_binary_operators) or\n (op in @required_parens_logical_binary_operands and\n parent_op in @required_parens_logical_binary_operands) or parent_prec > prec or\n (parent_prec == prec and parent_assoc != side) ->\n {operand, state} =\n binary_op_to_algebra(op, op_string, meta, left, right, context, state, 2)\n\n {wrap_in_parens(operand), state}\n\n # Otherwise, we rely on precedence but also nest.\n true ->\n binary_op_to_algebra(op, op_string, meta, left, right, context, state, 2)\n end\n else\n {:&, _, [arg]}\n when not is_integer(arg) and side == :left\n when not is_integer(arg) and parent_assoc == :left and parent_prec > @ampersand_prec ->\n {doc, state} = quoted_to_algebra(operand, context, state)\n {wrap_in_parens(doc), state}\n\n _ ->\n quoted_to_algebra(operand, context, state)\n end\n end\n\n defp unwrap_pipes({op, meta, [left, right]}, _meta, context, acc)\n when op in @pipeline_operators do\n left_context = left_op_context(context)\n right_context = right_op_context(context)\n unwrap_pipes(left, meta, left_context, [{{op, right_context}, right} | acc])\n end\n\n defp unwrap_pipes(left, meta, context, acc) do\n min_line =\n case left do\n {_, meta, _} -> line(meta)\n _ -> line(meta)\n end\n\n {[{{:root, context}, left} | acc], min_line}\n end\n\n defp unwrap_right({op, meta, [left, right]}, op, _meta, context, acc) do\n left_context = left_op_context(context)\n right_context = right_op_context(context)\n unwrap_right(right, op, meta, right_context, [{{:left, left_context}, left} | acc])\n end\n\n defp unwrap_right(right, _op, meta, context, acc) do\n acc = [{{:right, context}, right} | acc]\n {Enum.reverse(acc), line(meta)}\n end\n\n defp operand_to_algebra_with_comments(operands, meta, min_line, max_line, context, state, fun) do\n # If we are in a no_parens_one_arg expression, we actually cannot\n # extract comments from the first operand, because it would rewrite:\n #\n # @spec function(x) ::\n # # Comment\n # any\n # when x: any\n #\n # to:\n #\n # @spec # Comment\n # function(x) ::\n # any\n # when x: any\n #\n # Instead we get:\n #\n # @spec function(x) ::\n # any\n # # Comment\n # when x: any\n #\n # Which may look counter-intuitive but it actually makes sense,\n # as the closest possible location for the comment is the when\n # operator.\n {operands, acc, state} =\n if context == :no_parens_one_arg do\n [operand | operands] = operands\n {doc_triplet, state} = fun.(operand, :unused, state)\n {operands, [doc_triplet], state}\n else\n {operands, [], state}\n end\n\n {docs, comments?, state} =\n quoted_to_algebra_with_comments(operands, acc, min_line, max_line, state, fun)\n\n if comments? or eol?(meta, state) do\n {docs |> Enum.reduce(&line(&2, &1)) |> force_unfit(), state}\n else\n {docs |> Enum.reduce(&glue(&2, &1)), state}\n end\n end\n\n ## Module attributes\n\n # @Foo\n # @Foo.Bar\n defp module_attribute_to_algebra(_meta, {:__aliases__, _, [_, _ | _]} = quoted, _context, state) do\n {doc, state} = quoted_to_algebra(quoted, :parens_arg, state)\n {concat(concat(\"@(\", doc), \")\"), state}\n end\n\n # @foo bar\n # @foo(bar)\n defp module_attribute_to_algebra(meta, {name, call_meta, [_] = args} = expr, context, state)\n when is_atom(name) and name not in [:__block__, :__aliases__] do\n if Macro.classify_atom(name) == :identifier do\n {{call_doc, state}, wrap_in_parens?} =\n call_args_to_algebra(args, call_meta, context, :skip_unless_many_args, false, state)\n\n doc =\n \"@#{name}\"\n |> string()\n |> concat(call_doc)\n\n doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc\n {doc, state}\n else\n unary_op_to_algebra(:@, meta, expr, context, state)\n end\n end\n\n # @foo\n # @(foo.bar())\n defp module_attribute_to_algebra(meta, quoted, context, state) do\n unary_op_to_algebra(:@, meta, quoted, context, state)\n end\n\n ## Capture operator\n\n defp capture_to_algebra(integer, _context, state) when is_integer(integer) do\n {\"&\" <> Integer.to_string(integer), state}\n end\n\n defp capture_to_algebra(arg, context, state) do\n {doc, state} = capture_target_to_algebra(arg, context, state)\n\n case format_to_string(doc) do\n <<\"&\", _::binary>> -> {concat(\"& \", doc), state}\n <> when int in ?0..?9 -> {concat(\"& \", doc), state}\n _ -> {concat(\"&\", doc), state}\n end\n end\n\n defp capture_target_to_algebra(\n {:/, _, [{{:., _, [target, fun]}, _, []}, {:__block__, _, [arity]}]},\n _context,\n state\n )\n when is_atom(fun) and is_integer(arity) do\n {target_doc, state} = remote_target_to_algebra(target, state)\n fun = Macro.inspect_atom(:remote_call, fun, escape: &escape_atom/2)\n {target_doc |> nest(1) |> concat(string(\".#{fun}/#{arity}\")), state}\n end\n\n defp capture_target_to_algebra(\n {:/, _, [{name, _, var_context}, {:__block__, _, [arity]}]},\n _context,\n state\n )\n when is_atom(name) and is_atom(var_context) and is_integer(arity) do\n {string(\"#{name}/#{arity}\"), state}\n end\n\n defp capture_target_to_algebra(arg, context, state) do\n {doc, state} = quoted_to_algebra(arg, context, state)\n {wrap_in_parens_if_operator(doc, arg), state}\n end\n\n ## Calls (local, remote and anonymous)\n\n # expression.{arguments}\n defp remote_to_algebra({{:., _, [target, :{}]}, meta, args}, _context, state) do\n {target_doc, state} = remote_target_to_algebra(target, state)\n {call_doc, state} = tuple_to_algebra(meta, args, :break, state)\n {concat(concat(target_doc, \".\"), call_doc), state}\n end\n\n # expression.(arguments)\n defp remote_to_algebra({{:., _, [target]}, meta, args}, context, state) do\n {target_doc, state} = remote_target_to_algebra(target, state)\n\n {{call_doc, state}, wrap_in_parens?} =\n call_args_to_algebra(args, meta, context, :skip_if_do_end, true, state)\n\n doc = concat(concat(target_doc, \".\"), call_doc)\n doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc\n {doc, state}\n end\n\n # Mod.function()\n # var.function\n # expression.function(arguments)\n defp remote_to_algebra({{:., _, [target, fun]}, meta, args}, context, state)\n when is_atom(fun) do\n {target_doc, state} = remote_target_to_algebra(target, state)\n\n fun_doc =\n Macro.inspect_atom(:remote_call, fun, escape: &escape_atom/2)\n |> string()\n |> color_doc(:call, state.inspect_opts)\n\n remote_doc = target_doc |> concat(\".\") |> concat(fun_doc)\n\n if args == [] and not remote_target_is_a_module?(target) and not meta?(meta, :closing) do\n {remote_doc, state}\n else\n {{call_doc, state}, wrap_in_parens?} =\n call_args_to_algebra(args, meta, context, :skip_if_do_end, true, state)\n\n doc = concat(remote_doc, call_doc)\n doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc\n {doc, state}\n end\n end\n\n # call(call)(arguments)\n defp remote_to_algebra({target, meta, args}, context, state) do\n {target_doc, state} = quoted_to_algebra(target, :no_parens_arg, state)\n\n {{call_doc, state}, wrap_in_parens?} =\n call_args_to_algebra(args, meta, context, :required, true, state)\n\n doc = concat(target_doc, call_doc)\n doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc\n {doc, state}\n end\n\n defp remote_target_is_a_module?(target) do\n case target do\n {:__MODULE__, _, context} when is_atom(context) -> true\n {:__block__, _, [atom]} when is_atom(atom) -> true\n {:__aliases__, _, _} -> true\n _ -> false\n end\n end\n\n defp remote_target_to_algebra({:fn, _, [_ | _]} = quoted, state) do\n # This change is not semantically required but for beautification.\n {doc, state} = quoted_to_algebra(quoted, :no_parens_arg, state)\n {wrap_in_parens(doc), state}\n end\n\n defp remote_target_to_algebra(quoted, state) do\n quoted_to_algebra_with_parens_if_operator(quoted, :no_parens_arg, state)\n end\n\n # function(arguments)\n defp local_to_algebra(fun, meta, args, context, state) when is_atom(fun) do\n skip_parens =\n cond do\n meta?(meta, :closing) ->\n :skip_if_only_do_end\n\n local_without_parens?(fun, length(args), state.locals_without_parens) ->\n :skip_unless_many_args\n\n true ->\n :skip_if_do_end\n end\n\n {{call_doc, state}, wrap_in_parens?} =\n call_args_to_algebra(args, meta, context, skip_parens, true, state)\n\n doc =\n fun\n |> Atom.to_string()\n |> string()\n |> color_doc(:call, state.inspect_opts)\n |> concat(call_doc)\n\n doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc\n {doc, state}\n end\n\n # parens may be one of:\n #\n # * :skip_unless_many_args - skips parens unless we are the argument context\n # * :skip_if_only_do_end - skip parens if we are do-end and the only arg\n # * :skip_if_do_end - skip parens if we are do-end\n # * :required - never skip parens\n #\n defp call_args_to_algebra([], meta, _context, _parens, _list_to_keyword?, state) do\n {args_doc, _join, state} =\n args_to_algebra_with_comments([], meta, false, :none, :break, state, &{&1, &2})\n\n {{surround(\"(\", args_doc, \")\"), state}, false}\n end\n\n defp call_args_to_algebra(args, meta, context, parens, list_to_keyword?, state) do\n {rest, last} = split_last(args)\n\n if blocks = do_end_blocks(meta, last, state) do\n {call_doc, state} =\n case rest do\n [] when parens == :required ->\n {\"() do\", state}\n\n [] ->\n {\" do\", state}\n\n _ ->\n no_parens? = parens not in [:required, :skip_if_only_do_end]\n call_args_to_algebra_no_blocks(meta, rest, no_parens?, list_to_keyword?, \" do\", state)\n end\n\n {blocks_doc, state} = do_end_blocks_to_algebra(blocks, state)\n call_doc = call_doc |> concat(blocks_doc) |> line(\"end\") |> force_unfit()\n {{call_doc, state}, context in [:no_parens_arg, :no_parens_one_arg]}\n else\n no_parens? =\n parens == :skip_unless_many_args and\n context in [:block, :operand, :no_parens_one_arg, :parens_one_arg]\n\n res =\n call_args_to_algebra_no_blocks(meta, args, no_parens?, list_to_keyword?, @empty, state)\n\n {res, false}\n end\n end\n\n defp call_args_to_algebra_no_blocks(meta, args, skip_parens?, list_to_keyword?, extra, state) do\n {left, right} = split_last(args)\n {keyword?, right} = last_arg_to_keyword(right, list_to_keyword?, skip_parens?, state.comments)\n\n context =\n if left == [] and not keyword? do\n if skip_parens?, do: :no_parens_one_arg, else: :parens_one_arg\n else\n if skip_parens?, do: :no_parens_arg, else: :parens_arg\n end\n\n args = if keyword?, do: left ++ right, else: left ++ [right]\n many_eol? = match?([_, _ | _], args) and eol?(meta, state)\n no_generators? = no_generators?(args)\n to_algebra_fun = "ed_to_algebra(&1, context, &2)\n\n {args_doc, next_break_fits?, state} =\n if left != [] and keyword? and no_generators? do\n join = if force_args?(left) or many_eol?, do: :line, else: :break\n\n {left_doc, _join, state} =\n args_to_algebra_with_comments(\n left,\n Keyword.delete(meta, :closing),\n skip_parens?,\n :force_comma,\n join,\n state,\n to_algebra_fun\n )\n\n join = if force_args?(right) or force_args?(args) or many_eol?, do: :line, else: :break\n\n {right_doc, _join, state} =\n args_to_algebra_with_comments(right, meta, false, :none, join, state, to_algebra_fun)\n\n right_doc = apply(Inspect.Algebra, join, []) |> concat(right_doc)\n\n args_doc =\n if skip_parens? do\n left_doc\n |> concat(group(right_doc, :optimistic))\n |> nest(:cursor, :break)\n else\n right_doc =\n right_doc\n |> nest(2, :break)\n |> concat(break(\"\"))\n |> concat(\")\")\n |> group(:optimistic)\n\n concat(nest(left_doc, 2, :break), right_doc)\n end\n\n {args_doc, true, state}\n else\n join = if force_args?(args) or many_eol?, do: :line, else: :break\n next_break_fits? = join == :break and next_break_fits?(right, state)\n last_arg_mode = if next_break_fits?, do: :next_break_fits, else: :none\n\n {args_doc, _join, state} =\n args_to_algebra_with_comments(\n args,\n meta,\n skip_parens?,\n last_arg_mode,\n join,\n state,\n to_algebra_fun\n )\n\n # If we have a single argument, then we won't have an option to break\n # before the \"extra\" part, so we ungroup it and build it later.\n args_doc = ungroup_if_group(args_doc)\n\n args_doc =\n if skip_parens? do\n nest(args_doc, :cursor, :break)\n else\n nest(args_doc, 2, :break) |> concat(break(\"\")) |> concat(\")\")\n end\n\n {args_doc, next_break_fits?, state}\n end\n\n doc =\n cond do\n left != [] and keyword? and skip_parens? and no_generators? ->\n \" \"\n |> concat(args_doc)\n |> nest(2)\n |> concat(extra)\n\n skip_parens? ->\n \" \"\n |> concat(args_doc)\n |> concat(extra)\n\n true ->\n \"(\"\n |> concat(break(\"\"))\n |> nest(2, :break)\n |> concat(args_doc)\n |> concat(extra)\n end\n\n if next_break_fits? do\n {group(doc, :pessimistic), state}\n else\n {group(doc), state}\n end\n end\n\n defp no_generators?(args) do\n not Enum.any?(args, &match?({:<-, _, [_, _]}, &1))\n end\n\n defp do_end_blocks(meta, [{{:__block__, _, [:do]}, _} | rest] = blocks, state) do\n if meta?(meta, :do) or can_force_do_end_blocks?(rest, state) do\n blocks\n |> Enum.map(fn {{:__block__, meta, [key]}, value} -> {key, line(meta), value} end)\n |> do_end_blocks_with_range(end_line(meta))\n end\n end\n\n defp do_end_blocks(_, _, _), do: nil\n\n defp can_force_do_end_blocks?(rest, state) do\n state.force_do_end_blocks and\n Enum.all?(rest, fn {{:__block__, _, [key]}, _} -> key in @do_end_keywords end)\n end\n\n defp do_end_blocks_with_range([{key1, line1, value1}, {_, line2, _} = h | t], end_line) do\n [{key1, line1, line2, value1} | do_end_blocks_with_range([h | t], end_line)]\n end\n\n defp do_end_blocks_with_range([{key, line, value}], end_line) do\n [{key, line, end_line, value}]\n end\n\n defp do_end_blocks_to_algebra([{:do, line, end_line, value} | blocks], state) do\n {acc, state} = do_end_block_to_algebra(@empty, line, end_line, value, state)\n\n Enum.reduce(blocks, {acc, state}, fn {key, line, end_line, value}, {acc, state} ->\n {doc, state} = do_end_block_to_algebra(Atom.to_string(key), line, end_line, value, state)\n {line(acc, doc), state}\n end)\n end\n\n defp do_end_block_to_algebra(key_doc, line, end_line, value, state) do\n case clauses_to_algebra(value, line, end_line, state) do\n {@empty, state} -> {key_doc, state}\n {value_doc, state} -> {key_doc |> line(value_doc) |> nest(2), state}\n end\n end\n\n ## Interpolation\n\n defp list_interpolated?(entries) do\n Enum.all?(entries, fn\n {{:., _, [Kernel, :to_string]}, _, [_]} -> true\n entry when is_binary(entry) -> true\n _ -> false\n end)\n end\n\n defp interpolated?(entries) do\n Enum.all?(entries, fn\n {:\"::\", _, [{{:., _, [Kernel, :to_string]}, _, [_]}, {:binary, _, _}]} -> true\n entry when is_binary(entry) -> true\n _ -> false\n end)\n end\n\n defp prepend_heredoc_line([entry | entries]) when is_binary(entry) do\n [\"\\n\" <> entry | entries]\n end\n\n defp prepend_heredoc_line(entries) do\n [\"\\n\" | entries]\n end\n\n defp list_interpolation_to_algebra([entry | entries], escape, state, acc, last)\n when is_binary(entry) do\n acc = concat(acc, escape_string(entry, escape))\n list_interpolation_to_algebra(entries, escape, state, acc, last)\n end\n\n defp list_interpolation_to_algebra([entry | entries], escape, state, acc, last) do\n {{:., _, [Kernel, :to_string]}, _meta, [quoted]} = entry\n {doc, state} = interpolation_to_algebra(quoted, state)\n list_interpolation_to_algebra(entries, escape, state, concat(acc, doc), last)\n end\n\n defp list_interpolation_to_algebra([], _escape, state, acc, last) do\n {concat(acc, last), state}\n end\n\n defp interpolation_to_algebra([entry | entries], escape, state, acc, last)\n when is_binary(entry) do\n acc = concat(acc, escape_string(entry, escape))\n interpolation_to_algebra(entries, escape, state, acc, last)\n end\n\n defp interpolation_to_algebra([entry | entries], escape, state, acc, last) do\n {:\"::\", _, [{{:., _, [Kernel, :to_string]}, _meta, [quoted]}, {:binary, _, _}]} = entry\n {doc, state} = interpolation_to_algebra(quoted, state)\n interpolation_to_algebra(entries, escape, state, concat(acc, doc), last)\n end\n\n defp interpolation_to_algebra([], _escape, state, acc, last) do\n {concat(acc, last), state}\n end\n\n defp interpolation_to_algebra(quoted, %{skip_eol: skip_eol} = state) do\n {doc, state} = block_to_algebra(quoted, @max_line, @min_line, %{state | skip_eol: true})\n {no_limit(surround(\"\\#{\", doc, \"}\")), %{state | skip_eol: skip_eol}}\n end\n\n ## Sigils\n\n defp maybe_sigil_to_algebra(fun, meta, args, state) do\n with <<\"sigil_\", name::binary>> <- Atom.to_string(fun),\n [{:<<>>, _, entries}, modifiers] when is_list(modifiers) <- args,\n opening_delimiter when not is_nil(opening_delimiter) <- meta[:delimiter] do\n doc = <>\n\n entries =\n case Map.fetch(state.sigils, String.to_charlist(name)) do\n {:ok, callback} ->\n metadata = [\n file: state.file,\n line: meta[:line],\n sigil: String.to_atom(name),\n modifiers: modifiers,\n opening_delimiter: opening_delimiter\n ]\n\n case callback.(hd(entries), metadata) do\n iodata when is_binary(iodata) or is_list(iodata) ->\n [IO.iodata_to_binary(iodata)]\n\n other ->\n raise ArgumentError,\n \"expected sigil callback to return iodata, got: #{inspect(other)}\"\n end\n\n :error ->\n entries\n end\n\n if opening_delimiter in [@double_heredoc, @single_heredoc] do\n closing_delimiter = concat(opening_delimiter, List.to_string(modifiers))\n\n {doc, state} =\n entries\n |> prepend_heredoc_line()\n |> interpolation_to_algebra(opening_delimiter, state, doc, closing_delimiter)\n\n {force_unfit(doc), state}\n else\n escape = closing_sigil_delimiter(opening_delimiter)\n closing_delimiter = concat(escape, List.to_string(modifiers))\n interpolation_to_algebra(entries, escape, state, doc, closing_delimiter)\n end\n else\n _ ->\n :error\n end\n end\n\n defp closing_sigil_delimiter(\"(\"), do: \")\"\n defp closing_sigil_delimiter(\"[\"), do: \"]\"\n defp closing_sigil_delimiter(\"{\"), do: \"}\"\n defp closing_sigil_delimiter(\"<\"), do: \">\"\n defp closing_sigil_delimiter(other) when other in [\"\\\"\", \"'\", \"|\", \"/\"], do: other\n\n ## Bitstrings\n\n defp bitstring_to_algebra(meta, args, state) do\n last = length(args) - 1\n join = if eol?(meta, state), do: :line, else: :flex_break\n to_algebra_fun = &bitstring_segment_to_algebra(&1, &2, last)\n\n {args_doc, join, state} =\n args\n |> Enum.with_index()\n |> args_to_algebra_with_comments(meta, false, :none, join, state, to_algebra_fun)\n\n if join == :flex_break do\n {\"<<\" |> concat(args_doc) |> nest(2) |> concat(\">>\") |> group(), state}\n else\n {surround(\"<<\", args_doc, \">>\"), state}\n end\n end\n\n defp bitstring_segment_to_algebra({{:<-, meta, [left, right]}, i}, state, last) do\n left = {{:special, :bitstring_segment}, meta, [left, last]}\n {doc, state} = quoted_to_algebra({:<-, meta, [left, right]}, :parens_arg, state)\n {bitstring_wrap_parens(doc, i, last), state}\n end\n\n defp bitstring_segment_to_algebra({{:\"::\", _, [segment, spec]}, i}, state, last) do\n {doc, state} = quoted_to_algebra(segment, :parens_arg, state)\n\n {spec, state} =\n bitstring_spec_to_algebra(spec, state, state.migrate_bitstring_modifiers, :\"::\")\n\n spec = wrap_in_parens_if_inspected_atom(spec)\n spec = if i == last, do: bitstring_wrap_parens(spec, i, last), else: spec\n\n doc =\n doc\n |> bitstring_wrap_parens(i, -1)\n |> concat(\"::\")\n |> concat(spec)\n\n {doc, state}\n end\n\n defp bitstring_segment_to_algebra({segment, i}, state, last) do\n {doc, state} = quoted_to_algebra(segment, :parens_arg, state)\n {bitstring_wrap_parens(doc, i, last), state}\n end\n\n defp bitstring_spec_to_algebra({op, _, [left, right]}, state, normalize_modifiers, paren_op)\n when op in [:-, :*] do\n normalize_modifiers = normalize_modifiers && op != :*\n {left, state} = bitstring_spec_to_algebra(left, state, normalize_modifiers, op)\n {right, state} = bitstring_spec_element_to_algebra(right, state, normalize_modifiers)\n doc = concat(concat(left, Atom.to_string(op)), right)\n doc = if paren_op == :*, do: wrap_in_parens(doc), else: doc\n {doc, state}\n end\n\n defp bitstring_spec_to_algebra(spec, state, normalize_modifiers, _paren_op) do\n bitstring_spec_element_to_algebra(spec, state, normalize_modifiers)\n end\n\n defp bitstring_spec_element_to_algebra(\n {atom, meta, empty_args},\n state,\n _normalize_modifiers = true\n )\n when is_atom(atom) and empty_args in [nil, []] do\n empty_args = bitstring_spec_normalize_empty_args(atom)\n quoted_to_algebra_with_parens_if_operator({atom, meta, empty_args}, :parens_arg, state)\n end\n\n defp bitstring_spec_element_to_algebra(spec_element, state, _normalize_modifiers) do\n quoted_to_algebra_with_parens_if_operator(spec_element, :parens_arg, state)\n end\n\n defp bitstring_spec_normalize_empty_args(:_), do: nil\n\n defp bitstring_spec_normalize_empty_args(atom) do\n case :elixir_bitstring.validate_spec(atom, nil) do\n :none -> []\n _ -> nil\n end\n end\n\n defp bitstring_wrap_parens(doc, i, last) when i == 0 or i == last do\n string = format_to_string(doc)\n\n if (i == 0 and String.starts_with?(string, [\"~\", \"<<\"])) or\n (i == last and String.ends_with?(string, [\">>\"])) do\n wrap_in_parens(doc)\n else\n doc\n end\n end\n\n defp bitstring_wrap_parens(doc, _, _), do: doc\n\n ## Literals\n\n defp list_to_algebra(meta, args, state) do\n join = if eol?(meta, state), do: :line, else: :break\n fun = "ed_to_algebra(&1, :parens_arg, &2)\n\n {args_doc, _join, state} =\n args_to_algebra_with_comments(args, meta, false, :none, join, state, fun)\n\n left_bracket = color_doc(\"[\", :list, state.inspect_opts)\n right_bracket = color_doc(\"]\", :list, state.inspect_opts)\n\n {surround(left_bracket, args_doc, right_bracket), state}\n end\n\n defp map_to_algebra(meta, name_doc, [{:|, _, [left, right]}], state) do\n join = if eol?(meta, state), do: :line, else: :break\n fun = "ed_to_algebra(&1, :parens_arg, &2)\n {left_doc, state} = fun.(left, state)\n\n {right_doc, _join, state} =\n args_to_algebra_with_comments(right, meta, false, :none, join, state, fun)\n\n args_doc =\n left_doc\n |> wrap_in_parens_if_binary_operator(left)\n |> glue(concat(\"| \", nest(right_doc, 2)))\n\n do_map_to_algebra(name_doc, args_doc, state)\n end\n\n defp map_to_algebra(meta, name_doc, args, state) do\n join = if eol?(meta, state), do: :line, else: :break\n fun = "ed_to_algebra(&1, :parens_arg, &2)\n\n {args_doc, _join, state} =\n args_to_algebra_with_comments(args, meta, false, :none, join, state, fun)\n\n do_map_to_algebra(name_doc, args_doc, state)\n end\n\n defp do_map_to_algebra(name_doc, args_doc, state) do\n name_doc = \"%\" |> concat(name_doc) |> concat(\"{\") |> color_doc(:map, state.inspect_opts)\n {surround(name_doc, args_doc, color_doc(\"}\", :map, state.inspect_opts)), state}\n end\n\n defp tuple_to_algebra(meta, args, join, state) do\n join = if eol?(meta, state), do: :line, else: join\n fun = "ed_to_algebra(&1, :parens_arg, &2)\n\n {args_doc, join, state} =\n args_to_algebra_with_comments(args, meta, false, :none, join, state, fun)\n\n left_bracket = color_doc(\"{\", :tuple, state.inspect_opts)\n right_bracket = color_doc(\"}\", :tuple, state.inspect_opts)\n\n if join == :flex_break do\n {left_bracket |> concat(args_doc) |> nest(1) |> concat(right_bracket) |> group(), state}\n else\n {surround(left_bracket, args_doc, right_bracket), state}\n end\n end\n\n defp atom_to_algebra(atom, _, inspect_opts) when atom in [true, false] do\n Atom.to_string(atom) |> color_doc(:boolean, inspect_opts)\n end\n\n defp atom_to_algebra(nil, _, inspect_opts) do\n Atom.to_string(nil) |> color_doc(nil, inspect_opts)\n end\n\n defp atom_to_algebra(:\\\\, meta, inspect_opts) do\n # Since we parse strings without unescaping, the atoms\n # :\\\\ and :\"\\\\\" have the same representation, so we need\n # to check the delimiter and handle them accordingly.\n string =\n case Keyword.get(meta, :delimiter) do\n \"\\\"\" -> \":\\\"\\\\\\\\\\\"\"\n _ -> \":\\\\\\\\\"\n end\n\n string(string) |> color_doc(:atom, inspect_opts)\n end\n\n defp atom_to_algebra(atom, _, inspect_opts) do\n string = Atom.to_string(atom)\n\n iodata =\n if Macro.classify_atom(atom) in [:unquoted, :identifier] do\n [?:, string]\n else\n [?:, ?\", String.replace(string, \"\\\"\", \"\\\\\\\"\"), ?\"]\n end\n\n iodata |> IO.iodata_to_binary() |> string() |> color_doc(:atom, inspect_opts)\n end\n\n defp integer_to_algebra(text, inspect_otps) do\n case text do\n <> ->\n \"0x\" <> String.upcase(rest)\n\n <> = digits when base in [?b, ?o] ->\n digits\n\n <> = char ->\n char\n\n decimal ->\n insert_underscores(decimal)\n end\n |> color_doc(:number, inspect_otps)\n end\n\n defp float_to_algebra(text, inspect_otps) do\n [int_part, decimal_part] = :binary.split(text, \".\")\n decimal_part = String.downcase(decimal_part)\n\n string = insert_underscores(int_part) <> \".\" <> decimal_part\n color_doc(string, :number, inspect_otps)\n end\n\n defp insert_underscores(\"-\" <> digits) do\n \"-\" <> insert_underscores(digits)\n end\n\n defp insert_underscores(digits) do\n byte_size = byte_size(digits)\n\n cond do\n digits =~ \"_\" ->\n digits\n\n byte_size >= 6 ->\n offset = rem(byte_size, 3)\n {prefix, rest} = String.split_at(digits, offset)\n do_insert_underscores(prefix, rest)\n\n true ->\n digits\n end\n end\n\n defp do_insert_underscores(acc, \"\"), do: acc\n\n defp do_insert_underscores(\"\", <>),\n do: do_insert_underscores(next, rest)\n\n defp do_insert_underscores(acc, <>),\n do: do_insert_underscores(<>, rest)\n\n defp escape_heredoc(string, escape) do\n string = String.replace(string, escape, \"\\\\\" <> escape)\n heredoc_to_algebra([\"\" | String.split(string, \"\\n\")])\n end\n\n defp escape_string(string, <<_, _, _>> = escape) do\n string = String.replace(string, escape, \"\\\\\" <> escape)\n heredoc_to_algebra(String.split(string, \"\\n\"))\n end\n\n defp escape_string(string, escape) when is_binary(escape) do\n string\n |> String.replace(escape, \"\\\\\" <> escape)\n |> String.split(\"\\n\")\n |> Enum.reverse()\n |> Enum.map(&string/1)\n |> Enum.reduce(&concat(&1, concat(nest(line(), :reset), &2)))\n end\n\n defp heredoc_to_algebra([string]) do\n string(string)\n end\n\n defp heredoc_to_algebra([\"\" | rest]) do\n rest\n |> heredoc_line()\n |> concat(heredoc_to_algebra(rest))\n end\n\n defp heredoc_to_algebra([string | rest]) do\n string\n |> string()\n |> concat(heredoc_line(rest))\n |> concat(heredoc_to_algebra(rest))\n end\n\n defp heredoc_line([\"\", _ | _]), do: nest(line(), :reset)\n defp heredoc_line([\"\\r\", _ | _]), do: nest(line(), :reset)\n defp heredoc_line(_), do: line()\n\n defp args_to_algebra_with_comments(args, meta, skip_parens?, last_arg_mode, join, state, fun) do\n min_line = line(meta)\n max_line = closing_line(meta)\n\n arg_to_algebra = fn arg, args, state ->\n {doc, state} = fun.(arg, state)\n\n doc =\n case args do\n [_ | _] ->\n concat_to_last_group(doc, \",\")\n\n [] when last_arg_mode == :force_comma ->\n concat_to_last_group(doc, \",\")\n\n [] when last_arg_mode == :next_break_fits ->\n doc |> ungroup_if_group() |> group(:optimistic)\n\n [] when last_arg_mode == :none ->\n doc\n end\n\n {{doc, @empty, 1}, state}\n end\n\n # If skipping parens, we cannot extract the comments of the first\n # argument as there is no place to move them to, so we handle it now.\n {args, acc, state} =\n case args do\n [head | tail] when skip_parens? ->\n {doc_triplet, state} = arg_to_algebra.(head, tail, state)\n {tail, [doc_triplet], state}\n\n _ ->\n {args, [], state}\n end\n\n {args_docs, comments?, state} =\n quoted_to_algebra_with_comments(args, acc, min_line, max_line, state, arg_to_algebra)\n\n cond do\n args_docs == [] ->\n {@empty, :empty, state}\n\n join == :line or comments? ->\n {args_docs |> Enum.reduce(&line(&2, &1)) |> force_unfit(), :line, state}\n\n join == :break ->\n {args_docs |> Enum.reduce(&glue(&2, &1)), :break, state}\n\n join == :flex_break ->\n {args_docs |> Enum.reduce(&flex_glue(&2, &1)), :flex_break, state}\n end\n end\n\n ## Anonymous functions\n\n # fn -> block end\n defp anon_fun_to_algebra(\n [{:->, meta, [[], body]}] = clauses,\n _min_line,\n max_line,\n state,\n _multi_clauses_style\n ) do\n min_line = line(meta)\n {body_doc, state} = block_to_algebra(body, min_line, max_line, state)\n break_or_line = clause_break_or_line(clauses, state)\n\n doc =\n \"fn ->\"\n |> concat(break_or_line)\n |> concat(body_doc)\n |> nest(2)\n |> concat(break_or_line)\n |> concat(\"end\")\n |> maybe_force_clauses(clauses, state)\n |> group()\n\n {doc, state}\n end\n\n # fn x -> y end\n # fn x ->\n # y\n # end\n defp anon_fun_to_algebra(\n [{:->, meta, [args, body]}] = clauses,\n _min_line,\n max_line,\n state,\n false = _multi_clauses_style\n ) do\n min_line = line(meta)\n {args_doc, state} = clause_args_to_algebra(args, min_line, state)\n {body_doc, state} = block_to_algebra(body, min_line, max_line, state)\n\n head =\n args_doc\n |> ungroup_if_group()\n |> concat(\" ->\")\n |> nest(:cursor)\n |> group()\n\n break_or_line = clause_break_or_line(clauses, state)\n\n doc =\n \"fn \"\n |> concat(head)\n |> concat(break_or_line)\n |> concat(body_doc)\n |> nest(2)\n |> concat(break_or_line)\n |> concat(\"end\")\n |> maybe_force_clauses(clauses, state)\n |> group()\n\n {doc, state}\n end\n\n # fn\n # args1 ->\n # block1\n # args2 ->\n # block2\n # end\n defp anon_fun_to_algebra(clauses, min_line, max_line, state, _multi_clauses_style) do\n {clauses_doc, state} = clauses_to_algebra(clauses, min_line, max_line, state)\n {\"fn\" |> line(clauses_doc) |> nest(2) |> line(\"end\") |> force_unfit(), state}\n end\n\n ## Type functions\n\n # (-> block)\n defp paren_fun_to_algebra([{:->, meta, [[], body]}] = clauses, _min_line, max_line, state) do\n min_line = line(meta)\n {body_doc, state} = block_to_algebra(body, min_line, max_line, state)\n\n doc =\n \"(-> \"\n |> concat(nest(body_doc, :cursor))\n |> concat(\")\")\n |> maybe_force_clauses(clauses, state)\n |> group()\n\n {doc, state}\n end\n\n # (x -> y)\n # (x ->\n # y)\n defp paren_fun_to_algebra([{:->, meta, [args, body]}] = clauses, _min_line, max_line, state) do\n min_line = line(meta)\n {args_doc, state} = clause_args_to_algebra(args, min_line, state)\n {body_doc, state} = block_to_algebra(body, min_line, max_line, state)\n break_or_line = clause_break_or_line(clauses, state)\n\n doc =\n args_doc\n |> ungroup_if_group()\n |> concat(\" ->\")\n |> group()\n |> concat(break_or_line |> concat(body_doc) |> nest(2))\n |> wrap_in_parens()\n |> maybe_force_clauses(clauses, state)\n |> group()\n\n {doc, state}\n end\n\n # (\n # args1 ->\n # block1\n # args2 ->\n # block2\n # )\n defp paren_fun_to_algebra(clauses, min_line, max_line, state) do\n {clauses_doc, state} = clauses_to_algebra(clauses, min_line, max_line, state)\n {\"(\" |> line(clauses_doc) |> nest(2) |> line(\")\") |> force_unfit(), state}\n end\n\n ## Clauses\n\n defp multi_line_clauses?(clauses, state) do\n Enum.any?(clauses, fn {:->, meta, [_, block]} ->\n eol?(meta, state) or multi_line_block?(block)\n end)\n end\n\n defp multi_line_block?({:__block__, _, [_, _ | _]}), do: true\n defp multi_line_block?(_), do: false\n\n defp clause_break_or_line(clauses, state) do\n if multi_line_clauses?(clauses, state), do: line(), else: break()\n end\n\n defp maybe_force_clauses(doc, clauses, state) do\n if multi_line_clauses?(clauses, state), do: force_unfit(doc), else: doc\n end\n\n defp clauses_to_algebra([{:->, _, _} | _] = clauses, min_line, max_line, state) do\n [clause | clauses] = add_max_line_to_last_clause(clauses, max_line)\n {clause_doc, state} = clause_to_algebra(clause, min_line, state)\n\n {clauses_doc, state} =\n Enum.reduce(clauses, {clause_doc, state}, fn clause, {doc_acc, state_acc} ->\n {clause_doc, state_acc} = clause_to_algebra(clause, min_line, state_acc)\n\n doc_acc =\n doc_acc\n |> concat(maybe_empty_line())\n |> line(clause_doc)\n\n {doc_acc, state_acc}\n end)\n\n {clauses_doc |> maybe_force_clauses([clause | clauses], state) |> group(), state}\n end\n\n defp clauses_to_algebra(other, min_line, max_line, state) do\n case block_to_algebra(other, min_line, max_line, state) do\n {@empty, state} -> {@empty, state}\n {doc, state} -> {group(doc), state}\n end\n end\n\n defp clause_to_algebra({:->, meta, [[], body]}, _min_line, state) do\n {body_doc, state} = block_to_algebra(body, line(meta), closing_line(meta), state)\n {\"() ->\" |> glue(body_doc) |> nest(2), state}\n end\n\n defp clause_to_algebra({:->, meta, [args, body]}, min_line, state) do\n %{operand_nesting: nesting} = state\n\n state = %{state | operand_nesting: nesting + 2}\n {args_doc, state} = clause_args_to_algebra(args, min_line, state)\n\n state = %{state | operand_nesting: nesting}\n {body_doc, state} = block_to_algebra(body, min_line, closing_line(meta), state)\n\n doc =\n args_doc\n |> ungroup_if_group()\n |> concat(\" ->\")\n |> group()\n |> concat(break() |> concat(body_doc) |> nest(2))\n\n {doc, state}\n end\n\n defp add_max_line_to_last_clause([{op, meta, args}], max_line) do\n [{op, [closing: [line: max_line]] ++ meta, args}]\n end\n\n defp add_max_line_to_last_clause([clause | clauses], max_line) do\n [clause | add_max_line_to_last_clause(clauses, max_line)]\n end\n\n defp clause_args_to_algebra(args, min_line, state) do\n arg_to_algebra = fn arg, _args, state ->\n {doc, state} = clause_args_to_algebra(arg, state)\n {{doc, @empty, 1}, state}\n end\n\n {args_docs, comments?, state} =\n quoted_to_algebra_with_comments([args], [], min_line, @min_line, state, arg_to_algebra)\n\n if comments? do\n {Enum.reduce(args_docs, &line(&2, &1)), state}\n else\n {Enum.reduce(args_docs, &glue(&2, &1)), state}\n end\n end\n\n # fn a, b, c when d -> e end\n defp clause_args_to_algebra([{:when, meta, args}], state) do\n {args, right} = split_last(args)\n\n # If there are any keywords, wrap them in lists\n args =\n Enum.map(args, fn\n [_ | _] = keyword -> {:__block__, [], [keyword]}\n other -> other\n end)\n\n left = {{:special, :clause_args}, meta, [args]}\n binary_op_to_algebra(:when, \"when\", meta, left, right, :no_parens_arg, state)\n end\n\n # fn () -> e end\n defp clause_args_to_algebra([], state) do\n {\"()\", state}\n end\n\n # fn a, b, c -> e end\n defp clause_args_to_algebra(args, state) do\n many_args_to_algebra(args, state, "ed_to_algebra(&1, :no_parens_arg, &2))\n end\n\n ## Quoted helpers for comments\n\n defp quoted_to_algebra_with_comments(args, acc, min_line, max_line, state, fun) do\n {pre_comments, state} =\n get_and_update_in(state.comments, fn comments ->\n Enum.split_while(comments, fn %{line: line} -> line <= min_line end)\n end)\n\n {reverse_docs, comments?, state} =\n if state.comments == [] do\n each_quoted_to_algebra_without_comments(args, acc, state, fun)\n else\n each_quoted_to_algebra_with_comments(args, acc, max_line, state, false, fun)\n end\n\n docs = merge_algebra_with_comments(Enum.reverse(reverse_docs), @empty)\n {docs, comments?, update_in(state.comments, &(pre_comments ++ &1))}\n end\n\n defp each_quoted_to_algebra_without_comments([], acc, state, _fun) do\n {acc, false, state}\n end\n\n defp each_quoted_to_algebra_without_comments([arg | args], acc, state, fun) do\n {doc_triplet, state} = fun.(arg, args, state)\n acc = [doc_triplet | acc]\n each_quoted_to_algebra_without_comments(args, acc, state, fun)\n end\n\n defp each_quoted_to_algebra_with_comments([], acc, max_line, state, comments?, _fun) do\n {acc, comments, comments?} = extract_comments_before(max_line, acc, state.comments, comments?)\n {acc, comments?, %{state | comments: comments}}\n end\n\n defp each_quoted_to_algebra_with_comments([arg | args], acc, max_line, state, comments?, fun) do\n case traverse_line(arg, {@max_line, @min_line}) do\n {@max_line, @min_line} ->\n {doc_triplet, state} = fun.(arg, args, state)\n acc = [doc_triplet | acc]\n each_quoted_to_algebra_with_comments(args, acc, max_line, state, comments?, fun)\n\n {doc_start, doc_end} ->\n {acc, comments, comments?} =\n extract_comments_before(doc_start, acc, state.comments, comments?)\n\n {doc_triplet, state} = fun.(arg, args, %{state | comments: comments})\n\n {acc, comments, comments?} =\n extract_comments_trailing(doc_start, doc_end, acc, state.comments, comments?)\n\n acc = [adjust_trailing_newlines(doc_triplet, doc_end, comments) | acc]\n state = %{state | comments: comments}\n each_quoted_to_algebra_with_comments(args, acc, max_line, state, comments?, fun)\n end\n end\n\n defp extract_comments_before(max, acc, [%{line: line} = comment | rest], _) when line < max do\n %{previous_eol_count: previous, next_eol_count: next, text: doc} = comment\n acc = [{doc, @empty, next} | add_previous_to_acc(acc, previous)]\n extract_comments_before(max, acc, rest, true)\n end\n\n defp extract_comments_before(_max, acc, rest, comments?) do\n {acc, rest, comments?}\n end\n\n defp add_previous_to_acc([{doc, next_line, newlines} | acc], previous) when newlines < previous,\n do: [{doc, next_line, previous} | acc]\n\n defp add_previous_to_acc(acc, _previous),\n do: acc\n\n defp extract_comments_trailing(min, max, acc, [%{line: line, text: doc_comment} | rest], _)\n when line >= min and line <= max do\n acc = [{doc_comment, @empty, 1} | acc]\n extract_comments_trailing(min, max, acc, rest, true)\n end\n\n defp extract_comments_trailing(_min, _max, acc, rest, comments?) do\n {acc, rest, comments?}\n end\n\n # If the document is immediately followed by comment which is followed by newlines,\n # its newlines wouldn't have considered the comment, so we need to adjust it.\n defp adjust_trailing_newlines({doc, next_line, newlines}, doc_end, [%{line: line} | _])\n when newlines > 1 and line == doc_end + 1 do\n {doc, next_line, 1}\n end\n\n defp adjust_trailing_newlines(doc_triplet, _, _), do: doc_triplet\n\n defp traverse_line({expr, meta, args}, {min, max}) do\n # This is a hot path, so use :lists.keyfind/3 instead Keyword.fetch!/2\n acc =\n case :lists.keyfind(:line, 1, meta) do\n {:line, line} -> {min(line, min), max(line, max)}\n false -> {min, max}\n end\n\n traverse_line(args, traverse_line(expr, acc))\n end\n\n defp traverse_line({left, right}, acc) do\n traverse_line(right, traverse_line(left, acc))\n end\n\n defp traverse_line(args, acc) when is_list(args) do\n Enum.reduce(args, acc, &traverse_line/2)\n end\n\n defp traverse_line(_, acc) do\n acc\n end\n\n # Below are the rules for line rendering in the formatter:\n #\n # 1. respect the user's choice\n # 2. and add empty lines around expressions that take multiple lines\n # (except for module attributes)\n # 3. empty lines are collapsed as to not exceed more than one\n #\n defp merge_algebra_with_comments([{doc, next_line, newlines} | docs], left) do\n right = if newlines >= @newlines, do: line(), else: next_line\n\n doc =\n if left != @empty do\n concat(left, doc)\n else\n doc\n end\n\n doc =\n if docs != [] and right != @empty do\n concat(doc, concat(collapse_lines(2), right))\n else\n doc\n end\n\n [group(doc) | merge_algebra_with_comments(docs, right)]\n end\n\n defp merge_algebra_with_comments([], _) do\n []\n end\n\n ## Quoted helpers\n\n defp left_op_context(context), do: force_many_args_or_operand(context, :parens_arg)\n defp right_op_context(context), do: force_many_args_or_operand(context, :operand)\n\n defp force_many_args_or_operand(:no_parens_one_arg, _choice), do: :no_parens_arg\n defp force_many_args_or_operand(:parens_one_arg, _choice), do: :parens_arg\n defp force_many_args_or_operand(:no_parens_arg, _choice), do: :no_parens_arg\n defp force_many_args_or_operand(:parens_arg, _choice), do: :parens_arg\n defp force_many_args_or_operand(:operand, choice), do: choice\n defp force_many_args_or_operand(:block, choice), do: choice\n\n defp quoted_to_algebra_with_parens_if_operator(ast, context, state) do\n {doc, state} = quoted_to_algebra(ast, context, state)\n {wrap_in_parens_if_operator(doc, ast), state}\n end\n\n defp wrap_in_parens_if_operator(doc, {:__block__, _, [expr]}) do\n wrap_in_parens_if_operator(doc, expr)\n end\n\n defp wrap_in_parens_if_operator(doc, quoted) do\n if operator?(quoted) and not module_attribute_read?(quoted) and not integer_capture?(quoted) do\n wrap_in_parens(doc)\n else\n doc\n end\n end\n\n defp wrap_in_parens_if_binary_operator(doc, quoted) do\n if binary_operator?(quoted) do\n wrap_in_parens(doc)\n else\n doc\n end\n end\n\n defp wrap_in_parens_if_inspected_atom(\":\" <> _ = doc) do\n \"(\" <> doc <> \")\"\n end\n\n defp wrap_in_parens_if_inspected_atom(doc) do\n doc\n end\n\n defp wrap_in_parens(doc) do\n concat(concat(\"(\", nest(doc, :cursor)), \")\")\n end\n\n defp many_args_to_algebra([arg | args], state, fun) do\n Enum.reduce(args, fun.(arg, state), fn arg, {doc_acc, state_acc} ->\n {arg_doc, state_acc} = fun.(arg, state_acc)\n {glue(concat(doc_acc, \",\"), arg_doc), state_acc}\n end)\n end\n\n defp module_attribute_read?({:@, _, [{var, _, var_context}]})\n when is_atom(var) and is_atom(var_context) do\n Macro.classify_atom(var) == :identifier\n end\n\n defp module_attribute_read?(_), do: false\n\n defp integer_capture?({:&, _, [integer]}) when is_integer(integer), do: true\n defp integer_capture?(_), do: false\n\n defp operator?(quoted) do\n unary_operator?(quoted) or binary_operator?(quoted)\n end\n\n # We convert ..// into two operators for simplicity,\n # so we need to augment the binary table.\n defp augmented_binary_op(:\"//\"), do: {:right, 190}\n defp augmented_binary_op(op), do: Code.Identifier.binary_op(op)\n\n defp binary_operator?(quoted) do\n case quoted do\n {op, _, [_, _, _]} when op in @multi_binary_operators -> true\n {op, _, [_, _]} when is_atom(op) -> augmented_binary_op(op) != :error\n _ -> false\n end\n end\n\n defp unary_operator?(quoted) do\n case quoted do\n {op, _, [_]} when is_atom(op) -> Code.Identifier.unary_op(op) != :error\n _ -> false\n end\n end\n\n defp with_next_break_fits(condition, doc, fun) do\n if condition do\n doc\n |> group(:optimistic)\n |> fun.()\n |> group(:pessimistic)\n else\n doc\n |> group()\n |> fun.()\n |> group()\n end\n end\n\n defp next_break_fits?({:{}, meta, _args}, state) do\n eol_or_comments?(meta, state)\n end\n\n defp next_break_fits?({:__block__, meta, [{_, _}]}, state) do\n eol_or_comments?(meta, state)\n end\n\n defp next_break_fits?({:<<>>, meta, [_ | _] = entries}, state) do\n meta[:delimiter] == ~s[\"\"\"] or\n (not interpolated?(entries) and eol_or_comments?(meta, state))\n end\n\n # TODO: Remove this clause on Elixir v2.0 once single-quoted charlists are removed\n defp next_break_fits?({{:., _, [List, :to_charlist]}, meta, [[_ | _]]}, _state) do\n meta[:delimiter] == ~s[''']\n end\n\n defp next_break_fits?({{:., _, [_left, :{}]}, _, _}, _state) do\n true\n end\n\n defp next_break_fits?({:__block__, meta, [string]}, _state) when is_binary(string) do\n meta[:delimiter] == ~s[\"\"\"]\n end\n\n defp next_break_fits?({:__block__, meta, [list]}, _state) when is_list(list) do\n meta[:delimiter] != ~s[']\n end\n\n defp next_break_fits?({form, _, [_ | _]}, _state) when form in [:fn, :%{}, :%] do\n true\n end\n\n defp next_break_fits?({fun, meta, args}, _state) when is_atom(fun) and is_list(args) do\n meta[:delimiter] in [@double_heredoc, @single_heredoc] and\n fun |> Atom.to_string() |> String.starts_with?(\"sigil_\")\n end\n\n defp next_break_fits?({{:__block__, _, [atom]}, expr}, state) when is_atom(atom) do\n next_break_fits?(expr, state)\n end\n\n defp next_break_fits?(_, _state) do\n false\n end\n\n defp eol_or_comments?(meta, %{comments: comments} = state) do\n eol?(meta, state) or\n (\n min_line = line(meta)\n max_line = closing_line(meta)\n Enum.any?(comments, fn %{line: line} -> line > min_line and line < max_line end)\n )\n end\n\n # A literal list is a keyword or (... -> ...)\n defp last_arg_to_keyword([_ | _] = arg, _list_to_keyword?, _skip_parens?, _comments) do\n {keyword?(arg), arg}\n end\n\n # This is a list of tuples, it can be converted to keywords.\n defp last_arg_to_keyword(\n {:__block__, meta, [[_ | _] = arg]} = block,\n true,\n skip_parens?,\n comments\n ) do\n cond do\n not keyword?(arg) ->\n {false, block}\n\n skip_parens? ->\n block_line = line(meta)\n {{_, arg_meta, _}, _} = hd(arg)\n first_line = line(arg_meta)\n\n case Enum.drop_while(comments, fn %{line: line} -> line <= block_line end) do\n [%{line: line} | _] when line <= first_line ->\n {false, block}\n\n _ ->\n {true, arg}\n end\n\n true ->\n {true, arg}\n end\n end\n\n # Otherwise we don't have a keyword.\n defp last_arg_to_keyword(arg, _list_to_keyword?, _skip_parens?, _comments) do\n {false, arg}\n end\n\n defp force_args?(args) do\n match?([_ | _], args) and force_args?(args, %{})\n end\n\n defp force_args?([[arg | _] | args], lines) do\n force_args?([arg | args], lines)\n end\n\n defp force_args?([arg | args], lines) do\n line =\n case arg do\n {{_, meta, _}, _} -> meta[:line]\n {_, meta, _} -> meta[:line]\n end\n\n cond do\n # Line may be missing from non-formatter AST\n is_nil(line) -> force_args?(args, lines)\n Map.has_key?(lines, line) -> false\n true -> force_args?(args, Map.put(lines, line, true))\n end\n end\n\n defp force_args?([], lines), do: map_size(lines) >= 2\n\n defp force_keyword(doc, arg) do\n if force_args?(arg), do: force_unfit(doc), else: doc\n end\n\n defp keyword?([{_, _} | list]), do: keyword?(list)\n defp keyword?(rest), do: rest == []\n\n defp keyword_key?({:__block__, meta, [atom]}) when is_atom(atom),\n do: meta[:format] == :keyword\n\n defp keyword_key?({{:., _, [:erlang, :binary_to_atom]}, meta, [{:<<>>, _, _}, :utf8]}),\n do: meta[:format] == :keyword\n\n defp keyword_key?(_),\n do: false\n\n defp eol?(_meta, %{skip_eol: true}), do: false\n defp eol?(meta, _state), do: Keyword.get(meta, :newlines, 0) > 0\n\n defp meta?(meta, key) do\n is_list(meta[key])\n end\n\n defp line(meta) do\n meta[:line] || @max_line\n end\n\n defp end_line(meta) do\n meta[:end][:line] || @min_line\n end\n\n defp closing_line(meta) do\n meta[:closing][:line] || @min_line\n end\n\n defp escape_atom(string, char) do\n String.replace(string, <>, <>)\n end\n\n ## Algebra helpers\n\n # Relying on the inner document is brittle and error prone.\n # It would be best if we had a mechanism to apply this.\n defp concat_to_last_group([left | right], concat) do\n [left | concat_to_last_group(right, concat)]\n end\n\n defp concat_to_last_group({:doc_group, group, mode}, concat) do\n {:doc_group, concat(group, concat), mode}\n end\n\n defp concat_to_last_group(other, concat) do\n concat(other, concat)\n end\n\n defp ungroup_if_group({:doc_group, group, _mode}), do: group\n defp ungroup_if_group(other), do: other\n\n defp format_to_string(doc) do\n doc |> Inspect.Algebra.format(:infinity) |> IO.iodata_to_binary()\n end\n\n defp maybe_empty_line() do\n nest(break(\"\"), :reset)\n end\n\n defp surround(left, doc, right) do\n if doc == @empty do\n concat(left, right)\n else\n group(glue(nest(glue(left, \"\", doc), 2, :break), \"\", right))\n end\n end\n\n defp nest_by_length(doc, string) do\n nest(doc, String.length(string))\n end\n\n defp split_last(list) do\n {left, [right]} = Enum.split(list, -1)\n {left, right}\n end\n\n defp get_charlist_quotes(:heredoc, state) do\n if state.migrate_charlists_as_sigils do\n {@sigil_c_heredoc, @double_heredoc}\n else\n {@single_heredoc, @single_heredoc}\n end\n end\n\n defp get_charlist_quotes({:regular, chunks}, state) do\n cond do\n !state.migrate_charlists_as_sigils -> {@single_quote, @single_quote}\n Enum.any?(chunks, &has_double_quote?/1) -> {@sigil_c_single, @single_quote}\n true -> {@sigil_c_double, @double_quote}\n end\n end\n\n defp has_double_quote?(chunk) do\n is_binary(chunk) and chunk =~ @double_quote\n end\n\n # Migration rewrites\n\n @bool_operators [\n :>,\n :>=,\n :<,\n :<=,\n :in\n ]\n @guards [\n :is_atom,\n :is_boolean,\n :is_nil,\n :is_number,\n :is_integer,\n :is_float,\n :is_binary,\n :is_map,\n :is_struct,\n :is_non_struct_map,\n :is_exception,\n :is_list,\n :is_tuple,\n :is_function,\n :is_reference,\n :is_pid,\n :is_port\n ]\n\n defp negate_condition(condition) do\n case condition do\n {neg, _, [condition]} when neg in [:!, :not] -> condition\n {op, _, [_, _]} when op in @bool_operators -> {:not, [], [condition]}\n {guard, _, [_ | _]} when guard in @guards -> {:not, [], [condition]}\n {:==, meta, [left, right]} -> {:!=, meta, [left, right]}\n {:===, meta, [left, right]} -> {:!==, meta, [left, right]}\n {:!=, meta, [left, right]} -> {:==, meta, [left, right]}\n {:!==, meta, [left, right]} -> {:===, meta, [left, right]}\n _ -> {:!, [], [condition]}\n end\n end\nend\n" }, { "path": "lib/elixir/lib/code/fragment.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\ndefmodule Code.Fragment do\n @moduledoc \"\"\"\n This module provides conveniences for analyzing fragments of\n textual code and extract available information whenever possible.\n\n This module should be considered experimental.\n \"\"\"\n\n @type position :: {line :: pos_integer(), column :: pos_integer()}\n\n @typedoc \"\"\"\n Options for cursor context functions.\n\n Currently, these options are not used but reserved for future extensibility.\n \"\"\"\n @type cursor_opts :: []\n\n @typedoc \"\"\"\n Options for converting code fragments to quoted expressions.\n \"\"\"\n @type container_cursor_to_quoted_opts :: [\n file: String.t(),\n line: pos_integer(),\n column: pos_integer(),\n columns: boolean(),\n token_metadata: boolean(),\n literal_encoder: (term(), Macro.metadata() -> term()),\n trailing_fragment: String.t()\n ]\n\n @doc ~S\"\"\"\n Returns the list of lines in the given string, preserving their line endings.\n\n Only the line endings recognized by the Elixir compiler are\n considered, namely `\\r\\n` and `\\n`. If you would like the retrieve\n lines without their line endings, use `String.split(string, [\"\\r\\n\", \"\\n\"])`.\n\n ## Examples\n\n iex> Code.Fragment.lines(\"foo\\r\\nbar\\r\\nbaz\")\n [\"foo\\r\\n\", \"bar\\r\\n\", \"baz\"]\n\n iex> Code.Fragment.lines(\"foo\\nbar\\nbaz\")\n [\"foo\\n\", \"bar\\n\", \"baz\"]\n\n iex> Code.Fragment.lines(\"\")\n [\"\"]\n\n \"\"\"\n @doc since: \"1.19.0\"\n def lines(string) do\n lines(string, <<>>)\n end\n\n defp lines(<>, acc),\n do: [<> | lines(rest, <<>>)]\n\n defp lines(<>, acc),\n do: lines(rest, <>)\n\n defp lines(<<>>, acc),\n do: [acc]\n\n @doc \"\"\"\n Receives a string and returns the cursor context.\n\n This function receives a string with an Elixir code fragment,\n representing a cursor position, and based on the string, it\n provides contextual information about the latest token.\n The return of this function can then be used to provide tips,\n suggestions, and autocompletion functionality.\n\n This function performs its analyses on tokens. This means\n it does not understand how constructs are nested within each\n other. See the \"Limitations\" section below.\n\n Consider adding a catch-all clause when handling the return\n type of this function as new cursor information may be added\n in future releases.\n\n ## Examples\n\n iex> Code.Fragment.cursor_context(\"\")\n :expr\n\n iex> Code.Fragment.cursor_context(\"hello_wor\")\n {:local_or_var, ~c\"hello_wor\"}\n\n ## Return values\n\n * `{:alias, charlist}` - the context is an alias, potentially\n a nested one, such as `Hello.Wor` or `HelloWor`\n\n * `{:alias, inside_alias, charlist}` - the context is an alias, potentially\n a nested one, where `inside_alias` is an expression `{:module_attribute, charlist}`\n or `{:local_or_var, charlist}` and `charlist` is a static part\n Examples are `__MODULE__.Submodule` or `@hello.Submodule`\n\n * `{:block_keyword_or_binary_operator, charlist}` - may be a block keyword (do, end, after,\n catch, else, rescue) or a binary operator\n\n * `{:dot, inside_dot, charlist}` - the context is a dot\n where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`,\n `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot`\n itself. If a var is given, this may either be a remote call or a map\n field access. Examples are `Hello.wor`, `:hello.wor`, `hello.wor`,\n `Hello.nested.wor`, `hello.nested.wor`, and `@hello.world`. If `charlist`\n is empty and `inside_dot` is an alias, then the autocompletion may either\n be an alias or a remote call.\n\n * `{:dot_arity, inside_dot, charlist}` - the context is a dot arity\n where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`,\n `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot`\n itself. If a var is given, it must be a remote arity. Examples are\n `Hello.world/`, `:hello.world/`, `hello.world/2`, and `@hello.world/2`\n\n * `{:dot_call, inside_dot, charlist}` - the context is a dot\n call. This means parentheses or space have been added after the expression.\n where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`,\n `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot`\n itself. If a var is given, it must be a remote call. Examples are\n `Hello.world(`, `:hello.world(`, `Hello.world `, `hello.world(`, `hello.world `,\n and `@hello.world(`\n\n * `:expr` - may be any expression. Autocompletion may suggest an alias,\n local or var\n\n * `{:local_or_var, charlist}` - the context is a variable or a local\n (import or local) call, such as `hello_wor`\n\n * `{:local_arity, charlist}` - the context is a local (import or local)\n arity, such as `hello_world/`\n\n * `{:local_call, charlist}` - the context is a local (import or local)\n call, such as `hello_world(` and `hello_world `\n\n * `{:anonymous_call, inside_caller}` - the context is an anonymous\n call, such as `fun.(` and `@fun.(`.\n\n * `{:module_attribute, charlist}` - the context is a module attribute,\n such as `@hello_wor`\n\n * `{:operator, charlist}` - the context is an operator, such as `+` or\n `==`. Note textual operators, such as `when` do not appear as operators\n but rather as `:local_or_var`. `@` is never an `:operator` and always a\n `:module_attribute`\n\n * `{:operator_arity, charlist}` - the context is an operator arity, which\n is an operator followed by /, such as `+/`, `not/` or `when/`\n\n * `{:operator_call, charlist}` - the context is an operator call, which is\n an operator followed by space, such as `left + `, `not ` or `x when `\n\n * `:none` - no context possible\n\n * `{:sigil, charlist}` - the context is a sigil. It may be either the beginning\n of a sigil, such as `~` or `~s`, or an operator starting with `~`, such as\n `~>` and `~>>`\n\n * `{:struct, inside_struct}` - the context is a struct, such as `%`, `%UR` or `%URI`.\n `inside_struct` can either be a `charlist` in case of a static alias or an\n expression `{:alias, inside_alias, charlist}`, `{:module_attribute, charlist}`,\n `{:local_or_var, charlist}`, `{:dot, inside_dot, charlist}`\n\n * `{:unquoted_atom, charlist}` - the context is an unquoted atom. This\n can be any atom or an atom representing a module\n\n We recommend looking at the test suite of this function for a complete list\n of examples and their return values.\n\n ## Limitations\n\n The analysis is based on the current token, by analysing the last line of\n the input. For example, this code:\n\n iex> Code.Fragment.cursor_context(\"%URI{\")\n :expr\n\n returns `:expr`, which suggests any variable, local function or alias\n could be used. However, given we are inside a struct, the best suggestion\n would be a struct field. In such cases, you can use\n `container_cursor_to_quoted`, which will return the container of the AST\n the cursor is currently within. You can then analyse this AST to provide\n completion of field names.\n\n As a consequence of its token-based implementation, this function considers\n only the last line of the input. This means it will show suggestions inside\n strings, heredocs, etc, which is intentional as it helps with doctests,\n references, and more.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec cursor_context(List.Chars.t(), cursor_opts()) ::\n {:alias, charlist}\n | {:alias, inside_alias, charlist}\n | {:block_keyword_or_binary_operator, charlist}\n | {:dot, inside_dot, charlist}\n | {:dot_arity, inside_dot, charlist}\n | {:dot_call, inside_dot, charlist}\n | :expr\n | {:local_or_var, charlist}\n | {:local_arity, charlist}\n | {:local_call, charlist}\n | {:anonymous_call, inside_caller}\n | {:module_attribute, charlist}\n | {:operator, charlist}\n | {:operator_arity, charlist}\n | {:operator_call, charlist}\n | :none\n | {:sigil, charlist}\n | {:struct, inside_struct}\n | {:unquoted_atom, charlist}\n when inside_dot:\n {:alias, charlist}\n | {:alias, inside_alias, charlist}\n | {:dot, inside_dot, charlist}\n | {:module_attribute, charlist}\n | {:unquoted_atom, charlist}\n | {:var, charlist}\n | :expr,\n inside_alias:\n {:local_or_var, charlist}\n | {:module_attribute, charlist},\n inside_struct:\n charlist\n | {:alias, inside_alias, charlist}\n | {:local_or_var, charlist}\n | {:module_attribute, charlist}\n | {:dot, inside_dot, charlist},\n inside_caller: {:var, charlist} | {:module_attribute, charlist}\n def cursor_context(fragment, opts \\\\ [])\n\n def cursor_context(fragment, opts)\n when (is_binary(fragment) or is_list(fragment)) and is_list(opts) do\n fragment\n |> last_line()\n |> :lists.reverse()\n |> codepoint_cursor_context(opts)\n |> elem(0)\n end\n\n def cursor_context(other, opts) when is_list(opts) do\n cursor_context(to_charlist(other), opts)\n end\n\n @operators ~c\"\\\\<>+-*/:=|&~^%!$\"\n @starting_punctuation ~c\",([{;\"\n @closing_punctuation ~c\")]}\\\"'\"\n @space ~c\"\\t\\s\"\n @trailing_identifier ~c\"?!\"\n @tilde_op_prefix ~c\"<=~\"\n\n @non_identifier @trailing_identifier ++\n @operators ++ @starting_punctuation ++ @closing_punctuation ++ @space ++ [?.]\n\n @textual_operators ~w(when not and or in)c\n @keywords ~w(do end after else catch rescue fn true false nil)c\n\n defp codepoint_cursor_context(reverse, _opts) do\n {stripped, spaces} = strip_spaces(reverse, 0)\n\n case stripped do\n # It is empty\n [] -> {:expr, 0}\n # Structs\n [?%, ?:, ?: | _] -> {{:struct, ~c\"\"}, 1}\n [?%, ?: | _] -> {{:unquoted_atom, ~c\"%\"}, 2}\n [?% | _] -> {{:struct, ~c\"\"}, 1}\n # Token/AST only operators\n [?>, ?= | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0}\n [?>, ?- | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0}\n # Two-digit containers\n [?<, ?< | rest] when rest == [] or hd(rest) != ?< -> {:expr, 0}\n # Ambiguity around :\n [?: | rest] when rest == [] or hd(rest) != ?: -> unquoted_atom_or_expr(spaces)\n # Dots\n [?.] -> {:none, 0}\n [?. | rest] when hd(rest) not in ~c\".:\" -> dot(rest, spaces + 1, ~c\"\")\n # It is a local or remote call with parens\n [?( | rest] -> call_to_cursor_context(strip_spaces(rest, spaces + 1))\n # A local arity definition\n [?/ | rest] -> arity_to_cursor_context(strip_spaces(rest, spaces + 1))\n # Starting a new expression\n [h | _] when h in @starting_punctuation -> {:expr, 0}\n # It is keyword, binary operator, a local or remote call without parens\n rest when spaces > 0 -> closing_or_call_to_cursor_context({rest, spaces})\n # It is an identifier\n _ -> identifier_to_cursor_context(reverse, spaces, false)\n end\n end\n\n defp strip_spaces([h | rest], count) when h in @space, do: strip_spaces(rest, count + 1)\n defp strip_spaces(rest, count), do: {rest, count}\n\n defp unquoted_atom_or_expr(0), do: {{:unquoted_atom, ~c\"\"}, 1}\n defp unquoted_atom_or_expr(_), do: {:expr, 0}\n\n defp arity_to_cursor_context({reverse, spaces}) do\n case identifier_to_cursor_context(reverse, spaces, true) do\n {{:local_or_var, acc}, count} -> {{:local_arity, acc}, count}\n {{:dot, base, acc}, count} -> {{:dot_arity, base, acc}, count}\n {{:operator, acc}, count} -> {{:operator_arity, acc}, count}\n {{:sigil, _}, _} -> {:none, 0}\n {_, _} -> {{:operator, ~c\"/\"}, 1}\n end\n end\n\n defp call_to_cursor_context({reverse, spaces}) do\n with [?. | rest] <- reverse,\n {rest, spaces} = strip_spaces(rest, spaces),\n [h | _] when h not in @non_identifier <- rest do\n case identifier_to_cursor_context(rest, spaces, true) do\n {{:local_or_var, acc}, count} -> {{:anonymous_call, {:var, acc}}, count + 1}\n {{:module_attribute, _} = attr, count} -> {{:anonymous_call, attr}, count + 1}\n {_, _} -> {:none, 0}\n end\n else\n _ ->\n case identifier_to_cursor_context(reverse, spaces, true) do\n {{:local_or_var, acc}, count} -> {{:local_call, acc}, count}\n {{:dot, base, acc}, count} -> {{:dot_call, base, acc}, count}\n {{:operator, acc}, count} -> {{:operator_call, acc}, count}\n {_, _} -> {:none, 0}\n end\n end\n end\n\n defp closing_or_call_to_cursor_context({reverse, spaces}) do\n if closing?(reverse) do\n {{:block_keyword_or_binary_operator, ~c\"\"}, 0}\n else\n call_to_cursor_context({reverse, spaces})\n end\n end\n\n defp identifier_to_cursor_context([?., ?., ?: | _], n, _), do: {{:unquoted_atom, ~c\"..\"}, n + 3}\n defp identifier_to_cursor_context([?., ?., ?. | _], n, _), do: {{:operator, ~c\"...\"}, n + 3}\n defp identifier_to_cursor_context([?., ?: | _], n, _), do: {{:unquoted_atom, ~c\".\"}, n + 2}\n defp identifier_to_cursor_context([?., ?. | _], n, _), do: {{:operator, ~c\"..\"}, n + 2}\n\n defp identifier_to_cursor_context(reverse, count, call_op?) do\n case identifier(reverse, count) do\n :none ->\n {:none, 0}\n\n :operator ->\n operator(reverse, count, [], call_op?)\n\n {:struct, {:module_attribute, acc}, count} ->\n {{:struct, {:module_attribute, acc}}, count + 1}\n\n {:module_attribute, acc, count} ->\n {{:module_attribute, acc}, count}\n\n {:sigil, acc, count} ->\n {{:sigil, acc}, count}\n\n {:unquoted_atom, acc, count} ->\n {{:unquoted_atom, acc}, count}\n\n {:alias, rest, acc, count} ->\n case strip_spaces(rest, count) do\n {~c\".\" ++ rest, count} when rest == [] or hd(rest) != ?. ->\n nested_alias(rest, count + 1, acc)\n\n {~c\"%\" ++ _, count} ->\n {{:struct, acc}, count + 1}\n\n _ ->\n {{:alias, acc}, count}\n end\n\n {:identifier, _, acc, count} when call_op? and acc in @textual_operators ->\n {{:operator, acc}, count}\n\n {:identifier, [?%], acc, count} ->\n case identifier_to_cursor_context(acc |> Enum.reverse(), count, true) do\n {{:local_or_var, _} = identifier, _} -> {{:struct, identifier}, count + 1}\n _ -> {:none, 0}\n end\n\n {:identifier, rest, acc, count} ->\n case strip_spaces(rest, count) do\n {~c\".\" ++ rest, count} when rest == [] or hd(rest) != ?. ->\n dot(rest, count + 1, acc)\n\n {rest, rest_count} ->\n response =\n if rest_count > count and closing?(rest),\n do: :block_keyword_or_binary_operator,\n else: :local_or_var\n\n {{response, acc}, count}\n end\n\n {:capture_arg, acc, count} ->\n {{:capture_arg, acc}, count}\n end\n end\n\n # If it is a closing punctuation\n defp closing?([h | _]) when h in @closing_punctuation, do: true\n # Closing bitstring (but deal with operators)\n defp closing?([?>, ?> | rest]), do: rest == [] or hd(rest) not in [?>, ?~]\n # Keywords\n defp closing?(rest) do\n case split_non_identifier(rest, []) do\n {~c\"nil\", _} -> true\n {~c\"true\", _} -> true\n {~c\"false\", _} -> true\n {[digit | _], _} when digit in ?0..?9 -> true\n {[upper | _], _} when upper in ?A..?Z -> true\n {[_ | _], [?: | rest]} -> rest == [] or hd(rest) != ?:\n {_, _} -> false\n end\n end\n\n defp split_non_identifier([h | t], acc) when h not in @non_identifier,\n do: split_non_identifier(t, [h | acc])\n\n defp split_non_identifier(rest, acc), do: {acc, rest}\n\n defp identifier([?? | rest], count), do: check_identifier(rest, count + 1, [??])\n defp identifier([?! | rest], count), do: check_identifier(rest, count + 1, [?!])\n defp identifier(rest, count), do: check_identifier(rest, count, [])\n\n defp check_identifier([h | t], count, acc) when h not in @non_identifier,\n do: rest_identifier(t, count + 1, [h | acc])\n\n defp check_identifier(_, _, _), do: :operator\n\n defp rest_identifier([h | rest], count, acc) when h not in @non_identifier do\n rest_identifier(rest, count + 1, [h | acc])\n end\n\n defp rest_identifier(rest, count, [?@ | acc]) do\n case tokenize_identifier(rest, count, acc) do\n {:identifier, [?% | _rest], acc, count} -> {:struct, {:module_attribute, acc}, count}\n {:identifier, _rest, acc, count} -> {:module_attribute, acc, count}\n :none when acc == [] -> {:module_attribute, ~c\"\", count}\n _ -> :none\n end\n end\n\n defp rest_identifier([?~ | rest], count, [letter])\n when (letter in ?A..?Z or letter in ?a..?z) and\n (rest == [] or hd(rest) not in @tilde_op_prefix) do\n {:sigil, [letter], count + 1}\n end\n\n defp rest_identifier([?: | rest], count, acc) when rest == [] or hd(rest) != ?: do\n case String.Tokenizer.tokenize(acc) do\n {_, _, [], _, _, _} -> {:unquoted_atom, acc, count + 1}\n _ -> :none\n end\n end\n\n defp rest_identifier([?? | _], _count, _acc) do\n :none\n end\n\n defp rest_identifier([?& | tail] = rest, count, acc) when tail == [] or hd(tail) != ?& do\n if Enum.all?(acc, &(&1 in ?0..?9)) do\n {:capture_arg, [?& | acc], count + 1}\n else\n tokenize_identifier(rest, count, acc)\n end\n end\n\n defp rest_identifier(rest, count, acc) do\n tokenize_identifier(rest, count, acc)\n end\n\n defp tokenize_identifier(rest, count, acc) do\n case String.Tokenizer.tokenize(acc) do\n # Not actually an atom cause rest is not a :\n {:atom, _, _, _, _, _} ->\n :none\n\n # Aliases must be ascii only\n {:alias, _, _, _, false, _} ->\n :none\n\n {kind, _, [], _, _, extra} ->\n if :at in extra do\n :none\n else\n {kind, rest, acc, count}\n end\n\n _ ->\n :none\n end\n end\n\n defp nested_alias(rest, count, acc) do\n {rest, count} = strip_spaces(rest, count)\n\n case identifier_to_cursor_context(rest, count, true) do\n {{:struct, prev}, count} when is_list(prev) ->\n {{:struct, prev ++ ~c\".\" ++ acc}, count}\n\n {{:struct, {:alias, parent, prev}}, count} ->\n {{:struct, {:alias, parent, prev ++ ~c\".\" ++ acc}}, count}\n\n {{:struct, prev}, count} ->\n {{:struct, {:alias, prev, acc}}, count}\n\n {{:alias, prev}, count} ->\n {{:alias, prev ++ ~c\".\" ++ acc}, count}\n\n {{:alias, parent, prev}, count} ->\n {{:alias, parent, prev ++ ~c\".\" ++ acc}, count}\n\n {{:local_or_var, prev}, count} ->\n {{:alias, {:local_or_var, prev}, acc}, count}\n\n {{:module_attribute, prev}, count} ->\n {{:alias, {:module_attribute, prev}, acc}, count}\n\n _ ->\n {:none, 0}\n end\n end\n\n defp dot(rest, count, acc) do\n {rest, count} = strip_spaces(rest, count)\n\n case identifier_to_cursor_context(rest, count, true) do\n {{:local_or_var, var}, count} ->\n {{:dot, {:var, var}, acc}, count}\n\n {{:unquoted_atom, _} = prev, count} ->\n {{:dot, prev, acc}, count}\n\n {{:alias, _} = prev, count} ->\n {{:dot, prev, acc}, count}\n\n {{:alias, _, _} = prev, count} ->\n {{:dot, prev, acc}, count}\n\n {{:struct, inner}, count} when is_list(inner) ->\n {{:struct, {:dot, {:alias, inner}, acc}}, count}\n\n {{:struct, inner}, count} ->\n {{:struct, {:dot, inner, acc}}, count}\n\n {{:dot, _, _} = prev, count} ->\n {{:dot, prev, acc}, count}\n\n {{:module_attribute, _} = prev, count} ->\n {{:dot, prev, acc}, count}\n\n {:expr, count} ->\n {{:dot, :expr, acc}, count}\n\n {_, _} ->\n {:none, 0}\n end\n end\n\n defp operator([h | rest], count, acc, call_op?) when h in @operators do\n operator(rest, count + 1, [h | acc], call_op?)\n end\n\n # If we are opening a sigil, ignore the operator.\n defp operator([letter, ?~ | rest], _count, [op], _call_op?)\n when op in ~c\"<|/\" and (letter in ?A..?Z or letter in ?a..?z) and\n (rest == [] or hd(rest) not in @tilde_op_prefix) do\n {:none, 0}\n end\n\n defp operator(rest, count, ~c\"~\", call_op?) do\n {rest, _} = strip_spaces(rest, count)\n\n if call_op? or match?([?. | rest] when rest == [] or hd(rest) != ?., rest) do\n {:none, 0}\n else\n {{:sigil, ~c\"\"}, count}\n end\n end\n\n defp operator([?) | rest], _, [], true) when hd(rest) != ?? do\n {:expr, 0}\n end\n\n defp operator(rest, count, acc, _call_op?) do\n case :elixir_tokenizer.tokenize(acc, 1, 1, []) do\n {:ok, _, _, _, [{:atom, _, _}], []} ->\n {{:unquoted_atom, tl(acc)}, count}\n\n {:ok, _, _, _, [{_, _, op}], []} ->\n {rest, dot_count} = strip_spaces(rest, count)\n\n cond do\n Code.Identifier.unary_op(op) == :error and Code.Identifier.binary_op(op) == :error ->\n {:none, 0}\n\n match?([?. | rest] when rest == [] or hd(rest) != ?., rest) ->\n dot(tl(rest), dot_count + 1, acc)\n\n true ->\n {{:operator, acc}, count}\n end\n\n _ ->\n {:none, 0}\n end\n end\n\n @doc \"\"\"\n Receives a string and returns the surround context.\n\n This function receives a string with an Elixir code fragment\n and a `position`. It returns a map containing the beginning\n and ending of the identifier alongside its context, or `:none`\n if there is nothing with a known context. This is useful to\n provide mouse-over and highlight functionality in editors.\n\n The difference between `cursor_context/2` and `surround_context/3`\n is that the former assumes the expression in the code fragment\n is incomplete. For example, `do` in `cursor_context/2` may be\n a keyword or a variable or a local call, while `surround_context/3`\n assumes the expression in the code fragment is complete, therefore\n `do` would always be a keyword.\n\n The `position` contains both the `line` and `column`, both starting\n with the index of 1. The column must precede the surrounding expression.\n For example, the expression `foo`, will return something for the columns\n 1, 2, and 3, but not 4:\n\n foo\n ^ column 1\n\n foo\n ^ column 2\n\n foo\n ^ column 3\n\n foo\n ^ column 4\n\n The returned map contains the column the expression starts and the\n first column after the expression ends.\n\n Similar to `cursor_context/2`, this function is also token-based\n and may not be accurate under all circumstances. See the\n \"Return values\" and \"Limitations\" section under `cursor_context/2`\n for more information.\n\n ## Examples\n\n iex> Code.Fragment.surround_context(\"foo\", {1, 1})\n %{begin: {1, 1}, context: {:local_or_var, ~c\"foo\"}, end: {1, 4}}\n\n ## Differences to `cursor_context/2`\n\n Because `surround_context/3` attempts to capture complex expressions,\n it has some differences to `cursor_context/2`:\n\n * `dot_call`/`dot_arity` and `operator_call`/`operator_arity`\n are collapsed into `dot` and `operator` contexts respectively\n as there aren't any meaningful distinctions between them\n\n * On the other hand, this function still makes a distinction between\n `local_call`/`local_arity` and `local_or_var`, since the latter can\n be a local or variable\n\n * `@` when not followed by any identifier is returned as `{:operator, ~c\"@\"}`\n (in contrast to `{:module_attribute, ~c\"\"}` in `cursor_context/2`\n\n * This function never returns empty sigils `{:sigil, ~c\"\"}` or empty structs\n `{:struct, ~c\"\"}` as context\n\n * This function returns keywords as `{:keyword, ~c\"do\"}`\n\n * This function never returns `:expr`\n\n We recommend looking at the test suite of this function for a complete list\n of examples and their return values.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec surround_context(List.Chars.t(), position(), cursor_opts()) ::\n %{begin: position, end: position, context: context} | :none\n when context:\n {:alias, charlist}\n | {:alias, inside_alias, charlist}\n | {:dot, inside_dot, charlist}\n | {:local_or_var, charlist}\n | {:local_arity, charlist}\n | {:local_call, charlist}\n | {:module_attribute, charlist}\n | {:operator, charlist}\n | {:sigil, charlist}\n | {:struct, inside_struct}\n | {:unquoted_atom, charlist}\n | {:keyword, charlist}\n | {:key, charlist}\n | {:capture_arg, charlist},\n inside_dot:\n {:alias, charlist}\n | {:alias, inside_alias, charlist}\n | {:dot, inside_dot, charlist}\n | {:module_attribute, charlist}\n | {:unquoted_atom, charlist}\n | {:var, charlist}\n | :expr,\n inside_alias:\n {:local_or_var, charlist}\n | {:module_attribute, charlist},\n inside_struct:\n charlist\n | {:alias, inside_alias, charlist}\n | {:local_or_var, charlist}\n | {:module_attribute, charlist}\n | {:dot, inside_dot, charlist}\n def surround_context(fragment, position, options \\\\ [])\n\n def surround_context(string, {line, column}, opts)\n when (is_binary(string) or is_list(string)) and is_list(opts) do\n {charlist, lines_before_lengths, lines_current_and_after_lengths} =\n surround_line(string, line, column)\n\n prepended_columns = Enum.sum(lines_before_lengths)\n\n charlist\n |> position_surround_context(line, column + prepended_columns, opts)\n |> to_multiline_range(\n prepended_columns,\n lines_before_lengths,\n lines_current_and_after_lengths\n )\n end\n\n def surround_context(other, {_, _} = position, opts) do\n surround_context(to_charlist(other), position, opts)\n end\n\n defp position_surround_context(charlist, line, column, opts)\n when is_integer(line) and line >= 1 and is_integer(column) and column >= 1 do\n {reversed_pre, post} = string_reverse_at(charlist, column - 1, [])\n {reversed_pre, post} = adjust_position(reversed_pre, post)\n\n case take_identifier(post, []) do\n {_, [], _} ->\n maybe_operator(reversed_pre, post, line, opts)\n\n {:identifier, reversed_post, rest} ->\n {keyword_key?, rest} =\n case rest do\n [?: | tail] when tail == [] or hd(tail) in @space ->\n {true, rest}\n\n _ ->\n {rest, _} = strip_spaces(rest, 0)\n {false, rest}\n end\n\n reversed = reversed_post ++ reversed_pre\n\n case codepoint_cursor_context(reversed, opts) do\n {{:struct, acc}, offset} ->\n build_surround({:struct, acc}, reversed, line, offset)\n\n {{:alias, acc}, offset} ->\n build_surround({:alias, acc}, reversed, line, offset)\n\n {{:alias, parent, acc}, offset} ->\n build_surround({:alias, parent, acc}, reversed, line, offset)\n\n {{:dot, _, [_ | _]} = dot, offset} ->\n build_surround(dot, reversed, line, offset)\n\n {{:local_or_var, acc}, offset} when keyword_key? ->\n build_surround({:key, acc}, reversed, line, offset)\n\n {{:local_or_var, acc}, offset} when hd(rest) == ?( ->\n build_surround({:local_call, acc}, reversed, line, offset)\n\n {{:local_or_var, acc}, offset} when hd(rest) == ?/ ->\n build_surround({:local_arity, acc}, reversed, line, offset)\n\n {{:local_or_var, acc}, offset} when acc in @textual_operators ->\n build_surround({:operator, acc}, reversed, line, offset)\n\n {{:local_or_var, acc}, offset} when acc in @keywords ->\n build_surround({:keyword, acc}, reversed, line, offset)\n\n {{:local_or_var, acc}, offset} ->\n build_surround({:local_or_var, acc}, reversed, line, offset)\n\n {{:block_keyword_or_binary_operator, acc}, offset} when acc in @textual_operators ->\n build_surround({:operator, acc}, reversed, line, offset)\n\n {{:block_keyword_or_binary_operator, acc}, offset} when acc in @keywords ->\n build_surround({:keyword, acc}, reversed, line, offset)\n\n {{:module_attribute, ~c\"\"}, offset} ->\n build_surround({:operator, ~c\"@\"}, reversed, line, offset)\n\n {{:module_attribute, acc}, offset} ->\n build_surround({:module_attribute, acc}, reversed, line, offset)\n\n {{:sigil, acc}, offset} ->\n build_surround({:sigil, acc}, reversed, line, offset)\n\n {{:unquoted_atom, acc}, offset} ->\n build_surround({:unquoted_atom, acc}, reversed, line, offset)\n\n {{:capture_arg, acc}, offset} ->\n build_surround({:capture_arg, acc}, reversed, line, offset)\n\n _ ->\n maybe_operator(reversed_pre, post, line, opts)\n end\n\n {:alias, reversed_post, _rest} ->\n reversed = reversed_post ++ reversed_pre\n\n case codepoint_cursor_context(reversed, opts) do\n {{:alias, acc}, offset} ->\n build_surround({:alias, acc}, reversed, line, offset)\n\n {{:alias, parent, acc}, offset} ->\n build_surround({:alias, parent, acc}, reversed, line, offset)\n\n {{:struct, acc}, offset} ->\n build_surround({:struct, acc}, reversed, line, offset)\n\n _ ->\n :none\n end\n end\n end\n\n defp maybe_operator(reversed_pre, post, line, opts) do\n case take_operator(post, []) do\n {[], _rest} ->\n :none\n\n {reversed_post, rest} ->\n reversed = reversed_post ++ reversed_pre\n\n case codepoint_cursor_context(reversed, opts) do\n {{:operator, ~c\"&\"}, offset} when hd(rest) in ?0..?9 ->\n arg = Enum.take_while(rest, &(&1 in ?0..?9))\n\n build_surround(\n {:capture_arg, ~c\"&\" ++ arg},\n :lists.reverse(arg, reversed),\n line,\n offset + length(arg)\n )\n\n {{:operator, acc}, offset} ->\n build_surround({:operator, acc}, reversed, line, offset)\n\n {{:sigil, ~c\"\"}, offset} when hd(rest) in ?A..?Z or hd(rest) in ?a..?z ->\n build_surround({:sigil, [hd(rest)]}, [hd(rest) | reversed], line, offset + 1)\n\n {{:dot, _, [_ | _]} = dot, offset} ->\n build_surround(dot, reversed, line, offset)\n\n _ ->\n :none\n end\n end\n end\n\n defp build_surround(context, reversed, line, offset) do\n {post, reversed_pre} = enum_reverse_at(reversed, offset, [])\n pre = :lists.reverse(reversed_pre)\n pre_length = :string.length(pre) + 1\n\n %{\n context: context,\n begin: {line, pre_length},\n end: {line, pre_length + :string.length(post)}\n }\n end\n\n defp take_identifier([h | t], acc) when h in @trailing_identifier,\n do: {:identifier, [h | acc], t}\n\n defp take_identifier([h | t], acc) when h not in @non_identifier,\n do: take_identifier(t, [h | acc])\n\n defp take_identifier(rest, acc) do\n with {[?. | t], _} <- strip_spaces(rest, 0),\n {[h | _], _} when h in ?A..?Z <- strip_spaces(t, 0) do\n take_alias(rest, acc)\n else\n _ -> {:identifier, acc, rest}\n end\n end\n\n defp take_alias([h | t], acc) when h in ?A..?Z or h in ?a..?z or h in ?0..?9 or h == ?_,\n do: take_alias(t, [h | acc])\n\n defp take_alias(rest, acc) do\n with {[?. | t], acc} <- move_spaces(rest, acc),\n {[h | t], acc} when h in ?A..?Z <- move_spaces(t, [?. | acc]) do\n take_alias(t, [h | acc])\n else\n _ -> {:alias, acc, rest}\n end\n end\n\n defp take_operator([h | t], acc) when h in @operators, do: take_operator(t, [h | acc])\n defp take_operator([h | t], acc) when h == ?., do: take_operator(t, [h | acc])\n defp take_operator(rest, acc), do: {acc, rest}\n\n # Unquoted atom handling\n defp adjust_position(reversed_pre, [?: | post])\n when hd(post) != ?: and (reversed_pre == [] or hd(reversed_pre) != ?:) do\n {[?: | reversed_pre], post}\n end\n\n defp adjust_position(reversed_pre, [?% | post]) do\n adjust_position([?% | reversed_pre], post)\n end\n\n # Dot/struct handling\n defp adjust_position(reversed_pre, post) do\n case move_spaces(post, reversed_pre) do\n # If we are between spaces and a dot, move past the dot\n {[?. | post], reversed_pre} when hd(post) != ?. and hd(reversed_pre) != ?. ->\n {post, reversed_pre} = move_spaces(post, [?. | reversed_pre])\n {reversed_pre, post}\n\n _ ->\n case strip_spaces(reversed_pre, 0) do\n # If there is a dot to our left, make sure to move to the first character\n {[?. | rest], _} when rest == [] or hd(rest) not in ~c\".:\" ->\n {post, reversed_pre} = move_spaces(post, reversed_pre)\n {reversed_pre, post}\n\n # If there is a % to our left, make sure to move to the first character\n {[?% | _], _} ->\n case move_spaces(post, reversed_pre) do\n {[h | _] = post, reversed_pre} when h in ?A..?Z ->\n {reversed_pre, post}\n\n _ ->\n {reversed_pre, post}\n end\n\n _ ->\n {reversed_pre, post}\n end\n end\n end\n\n defp move_spaces([h | t], acc) when h in @space, do: move_spaces(t, [h | acc])\n defp move_spaces(t, acc), do: {t, acc}\n\n defp string_reverse_at(charlist, 0, acc), do: {acc, charlist}\n\n defp string_reverse_at(charlist, n, acc) do\n case :unicode_util.gc(charlist) do\n [gc | cont] when is_integer(gc) -> string_reverse_at(cont, n - 1, [gc | acc])\n [gc | cont] when is_list(gc) -> string_reverse_at(cont, n - 1, :lists.reverse(gc, acc))\n [] -> {acc, []}\n end\n end\n\n defp enum_reverse_at([h | t], n, acc) when n > 0, do: enum_reverse_at(t, n - 1, [h | acc])\n defp enum_reverse_at(rest, _, acc), do: {acc, rest}\n\n defp last_line(binary) when is_binary(binary) do\n [last_line | lines_reverse] =\n binary\n |> String.split([\"\\r\\n\", \"\\n\"])\n |> Enum.reverse()\n\n prepend_cursor_lines(lines_reverse, String.to_charlist(last_line))\n end\n\n defp last_line(charlist) when is_list(charlist) do\n [last_line | lines_reverse] =\n charlist\n |> :string.replace(~c\"\\r\\n\", ~c\"\\n\", :all)\n |> :string.join(~c\"\")\n |> :string.split(~c\"\\n\", :all)\n |> Enum.reverse()\n\n prepend_cursor_lines(lines_reverse, last_line)\n end\n\n defp prepend_cursor_lines(lines, last_line) do\n with [line | lines] <- lines,\n {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true),\n true <- incomplete? or starts_with_dot?(last_line) do\n prepend_cursor_lines(lines, Enum.reverse(trimmed_line, last_line))\n else\n _ -> last_line\n end\n end\n\n defp starts_with_dot?([?. | _]), do: true\n defp starts_with_dot?([h | t]) when h in @space, do: starts_with_dot?(t)\n defp starts_with_dot?(_), do: false\n\n defp ends_as_incomplete([?# | _], acc, incomplete?),\n do: {acc, incomplete?}\n\n defp ends_as_incomplete([h | t], acc, _incomplete?) when h in [?(, ?.],\n do: ends_as_incomplete(t, [h | acc], true)\n\n defp ends_as_incomplete([h | t], acc, incomplete?) when h in @space,\n do: ends_as_incomplete(t, [h | acc], incomplete?)\n\n defp ends_as_incomplete([h | t], acc, _incomplete?),\n do: ends_as_incomplete(t, [h | acc], false)\n\n defp ends_as_incomplete([], acc, incomplete?),\n do: {acc, incomplete?}\n\n defp surround_line(binary, line, column) when is_binary(binary) do\n binary\n |> String.split([\"\\r\\n\", \"\\n\"])\n |> Enum.map(&String.to_charlist/1)\n |> surround_lines(line, column)\n end\n\n defp surround_line(charlist, line, column) when is_list(charlist) do\n charlist\n |> :string.replace(~c\"\\r\\n\", ~c\"\\n\", :all)\n |> :string.join(~c\"\")\n |> :string.split(~c\"\\n\", :all)\n |> surround_lines(line, column)\n end\n\n defp surround_lines(lines, line, column) do\n {lines_before_reverse, cursor_line, lines_after} = split_at(lines, line, [])\n {trimmed_cursor_line, incomplete?} = ends_as_incomplete(to_charlist(cursor_line), [], true)\n\n reversed_cursor_line =\n if column - 1 > length(trimmed_cursor_line) do\n # Don't strip comments if cursor is inside a comment\n Enum.reverse(cursor_line)\n else\n trimmed_cursor_line\n end\n\n {cursor_line, after_lengths} =\n append_surround_lines(lines_after, [], [reversed_cursor_line], incomplete?)\n\n {cursor_line, before_lengths} = prepend_surround_lines(lines_before_reverse, [], cursor_line)\n {cursor_line, before_lengths, [length(reversed_cursor_line) | after_lengths]}\n end\n\n defp split_at([line], _, acc), do: {acc, line, []}\n defp split_at([line | lines], 1, acc), do: {acc, line, lines}\n defp split_at([line | lines], count, acc), do: split_at(lines, count - 1, [line | acc])\n\n defp prepend_surround_lines(lines, lengths, last_line) do\n with [line | lines] <- lines,\n {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true),\n true <- incomplete? or starts_with_dot?(last_line) do\n lengths = [length(trimmed_line) | lengths]\n prepend_surround_lines(lines, lengths, Enum.reverse(trimmed_line, last_line))\n else\n _ -> {last_line, Enum.reverse(lengths)}\n end\n end\n\n defp append_surround_lines(lines, lengths, acc_lines, incomplete?) do\n with [line | lines] <- lines,\n line = to_charlist(line),\n true <- incomplete? or starts_with_dot?(line) do\n {trimmed_line, incomplete?} = ends_as_incomplete(line, [], true)\n lengths = [length(trimmed_line) | lengths]\n append_surround_lines(lines, lengths, [trimmed_line | acc_lines], incomplete?)\n else\n _ -> {Enum.reduce(acc_lines, [], &Enum.reverse/2), Enum.reverse(lengths)}\n end\n end\n\n defp to_multiline_range(:none, _, _, _), do: :none\n\n defp to_multiline_range(\n %{begin: {begin_line, begin_column}, end: {end_line, end_column}} = context,\n prepended,\n lines_before_lengths,\n lines_current_and_after_lengths\n ) do\n {begin_line, begin_column} =\n Enum.reduce_while(lines_before_lengths, {begin_line, begin_column - prepended}, fn\n line_length, {acc_line, acc_column} ->\n if acc_column < 1 do\n {:cont, {acc_line - 1, acc_column + line_length}}\n else\n {:halt, {acc_line, acc_column}}\n end\n end)\n\n {end_line, end_column} =\n Enum.reduce_while(lines_current_and_after_lengths, {end_line, end_column - prepended}, fn\n line_length, {acc_line, acc_column} ->\n if acc_column > line_length + 1 do\n {:cont, {acc_line + 1, acc_column - line_length}}\n else\n {:halt, {acc_line, acc_column}}\n end\n end)\n\n %{context | begin: {begin_line, begin_column}, end: {end_line, end_column}}\n end\n\n @doc \"\"\"\n Receives a string and returns a quoted expression\n with the cursor AST position within its parent expression.\n\n This function receives a string with an Elixir code fragment,\n representing a cursor position, and converts such string to\n AST with the inclusion of special `__cursor__()` node representing\n the cursor position within its container (i.e. its parent).\n\n For example, take this code, which would be given as input:\n\n max(some_value,\n\n This function will return the AST equivalent to:\n\n max(some_value, __cursor__())\n\n In other words, this function is capable of closing any open\n brackets and insert the cursor position. Other content at the\n cursor position which is not a parent is discarded.\n For example, if this is given as input:\n\n max(some_value, another_val\n\n It will return the same AST:\n\n max(some_value, __cursor__())\n\n Similarly, if only this is given:\n\n max(some_va\n\n Then it returns:\n\n max(__cursor__())\n\n Calls without parenthesis are also supported, as we assume the\n brackets are implicit.\n\n Tuples, lists, maps, and binaries all retain the cursor position:\n\n max(some_value, [1, 2,\n\n Returns the following AST:\n\n max(some_value, [1, 2, __cursor__()])\n\n Keyword lists (and do-end blocks) are also retained. The following:\n\n if(some_value, do:\n if(some_value, do: :token\n if(some_value, do: 1 + val\n\n all return:\n\n if(some_value, do: __cursor__())\n\n For multi-line blocks, all previous lines are preserved.\n\n The AST returned by this function is not safe to evaluate but\n it can be analyzed and expanded.\n\n ## Examples\n\n Function call:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"max(some_value, \")\n {:ok, {:max, [line: 1], [{:some_value, [line: 1], nil}, {:__cursor__, [line: 1], []}]}}\n\n Containers (for example, a list):\n\n iex> Code.Fragment.container_cursor_to_quoted(\"[some, value\")\n {:ok, [{:some, [line: 1], nil}, {:__cursor__, [line: 1], []}]}\n\n If an expression is complete, then the whole expression is discarded\n and only the parent is returned:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"if(is_atom(var)\")\n {:ok, {:if, [line: 1], [{:__cursor__, [line: 1], []}]}}\n\n this means complete expressions themselves return only the cursor:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"if(is_atom(var))\")\n {:ok, {:__cursor__, [line: 1], []}}\n\n Operators are also included from Elixir v1.15:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"foo +\")\n {:ok, {:+, [line: 1], [{:foo, [line: 1], nil}, {:__cursor__, [line: 1], []}]}}\n\n In order to parse the left-side of `->` properly, which appears both\n in anonymous functions and do-end blocks, the trailing fragment option\n must be given with the rest of the contents:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"fn x\", trailing_fragment: \" -> :ok end\")\n {:ok, {:fn, [line: 1], [{:->, [line: 1], [[{:__cursor__, [line: 1], []}], :ok]}]}}\n\n ## Options\n\n * `:file` - the filename to be reported in case of parsing errors.\n Defaults to `\"nofile\"`.\n\n * `:line` - the starting line of the string being parsed.\n Defaults to `1`.\n\n * `:column` - the starting column of the string being parsed.\n Defaults to `1`.\n\n * `:columns` - when `true`, attach a `:column` key to the quoted\n metadata. Defaults to `false`.\n\n * `:token_metadata` - when `true`, includes token-related\n metadata in the expression AST, such as metadata for `do` and `end`\n tokens, for closing tokens, end of expressions, as well as delimiters\n for sigils. See `t:Macro.metadata/0`. Defaults to `false`.\n\n * `:literal_encoder` - a function to encode literals in the AST.\n See the documentation for `Code.string_to_quoted/2` for more information.\n\n * `:trailing_fragment` (since v1.18.0) - the rest of the contents after\n the cursor. This is necessary to correctly complete anonymous functions\n and the left-hand side of `->`\n\n * `:preserve_sigils` (since v1.20.0) - preserve sigil cursor location\n (see \"Tracking sigils\" section below)\n\n ## Tracking sigils\n\n The `:preserve_sigils` option can be used to track cursor positions inside\n a sigil.\n\n If the sigil is terminated abruptly, the `sigil_*` call will have the cursor\n as the second argument:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"~r/foo\", preserve_sigils: true)\n {:ok,\n {:sigil_r, [delimiter: \"/\", line: 1],\n [{:<<>>, [line: 1], [\"foo\"]}, {:__cursor__, [line: 1, column: 7], []}]}}\n\n In case the sigil is completed and has zero or more modifiers, the cursor will\n be nested in the list, with all previous delimiters specified:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"~r/foo/i\", preserve_sigils: true)\n {:ok,\n {:sigil_r, [delimiter: \"/\", line: 1],\n [{:<<>>, [line: 1], [\"foo\"]}, [105, {:__cursor__, [line: 1, column: 9], []}]]}}\n\n If the cursor is after the sigil, then it is discarded as everything else:\n\n iex> Code.Fragment.container_cursor_to_quoted(\"~r/foo/i \", preserve_sigils: true)\n {:ok, {:__cursor__, [line: 1], []}}\n \"\"\"\n @doc since: \"1.13.0\"\n @spec container_cursor_to_quoted(List.Chars.t(), container_cursor_to_quoted_opts()) ::\n {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}}\n def container_cursor_to_quoted(fragment, opts \\\\ []) do\n {trailing_fragment, opts} = Keyword.pop(opts, :trailing_fragment)\n {preserve_sigils?, opts} = Keyword.pop(opts, :preserve_sigils, false)\n opts = Keyword.take(opts, [:columns, :token_metadata, :literal_encoder])\n opts = [check_terminators: {:cursor, preserve_sigils?, []}] ++ opts\n\n file = Keyword.get(opts, :file, \"nofile\")\n line = Keyword.get(opts, :line, 1)\n column = Keyword.get(opts, :column, 1)\n\n case :elixir_tokenizer.tokenize(to_charlist(fragment), line, column, opts) do\n {:ok, line, column, _warnings, rev_tokens, rev_terminators}\n when trailing_fragment == nil ->\n {rev_tokens, rev_terminators} =\n with [close, open, {_, _, :__cursor__} = cursor | rev_tokens] <- rev_tokens,\n {_, [_ | after_fn]} <- Enum.split_while(rev_terminators, &(elem(&1, 0) != :fn)),\n true <- maybe_missing_stab?(rev_tokens, false),\n [_ | rev_tokens] <- Enum.drop_while(rev_tokens, &(elem(&1, 0) != :fn)) do\n {[close, open, cursor | rev_tokens], after_fn}\n else\n _ -> {rev_tokens, rev_terminators}\n end\n\n tokens = reverse_tokens(line, column, rev_tokens, rev_terminators)\n\n with {:ok, forms, _warnings} <- :elixir.tokens_to_quoted(tokens, file, opts) do\n {:ok, forms}\n end\n\n {:ok, line, column, _warnings, rev_tokens, rev_terminators} ->\n tokens =\n with {before_start, [_ | _] = after_start} <-\n Enum.split_while(rev_terminators, &(elem(&1, 0) not in [:do, :fn])),\n true <- maybe_missing_stab?(rev_tokens, true),\n opts =\n Keyword.put(opts, :check_terminators, {:cursor, false, before_start}),\n {:error, {meta, _, ~c\"end\"}, _rest, _warnings, trailing_rev_tokens} <-\n :elixir_tokenizer.tokenize(to_charlist(trailing_fragment), line, column, opts) do\n trailing_tokens =\n reverse_tokens(meta[:line], meta[:column], trailing_rev_tokens, after_start)\n\n # If the cursor has its own line, then we do not trim new lines trailing tokens.\n # Otherwise we want to drop any newline so we drop the next tokens after eol.\n trailing_tokens =\n case rev_tokens do\n [_close, _open, {_, _, :__cursor__}, {:eol, _} | _] -> trailing_tokens\n _ -> Enum.drop_while(trailing_tokens, &match?({:eol, _}, &1))\n end\n\n Enum.reverse(rev_tokens, drop_tokens(trailing_tokens, 0))\n else\n _ -> reverse_tokens(line, column, rev_tokens, rev_terminators)\n end\n\n with {:ok, forms, _warnings} <- :elixir.tokens_to_quoted(tokens, file, opts) do\n {:ok, forms}\n end\n\n {:error, info, _rest, _warnings, _so_far} ->\n {:error, :elixir_tokenizer.format_error(info)}\n end\n end\n\n defp reverse_tokens(line, column, tokens, terminators) do\n {terminators, _} =\n Enum.map_reduce(terminators, column, fn {start, _, _}, column ->\n atom = :elixir_tokenizer.terminator(start)\n\n {{atom, {line, column, nil}}, column + length(Atom.to_charlist(atom))}\n end)\n\n Enum.reverse(tokens, terminators)\n end\n\n # Otherwise we drop all tokens, trying to build a minimal AST\n # for cursor completion.\n defp drop_tokens([{:\"}\", _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:\"]\", _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:\")\", _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:\">>\", _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:end, _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:\",\", _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:\";\", _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:eol, _} | _] = tokens, 0), do: tokens\n defp drop_tokens([{:stab_op, _, :->} | _] = tokens, 0), do: tokens\n\n defp drop_tokens([{:\"}\", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)\n defp drop_tokens([{:\"]\", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)\n defp drop_tokens([{:\")\", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)\n defp drop_tokens([{:\">>\", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)\n defp drop_tokens([{:end, _} | tokens], counter), do: drop_tokens(tokens, counter - 1)\n\n defp drop_tokens([{:\"{\", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)\n defp drop_tokens([{:\"[\", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)\n defp drop_tokens([{:\"(\", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)\n defp drop_tokens([{:\"<<\", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)\n defp drop_tokens([{:fn, _} | tokens], counter), do: drop_tokens(tokens, counter + 1)\n defp drop_tokens([{:do, _} | tokens], counter), do: drop_tokens(tokens, counter + 1)\n\n defp drop_tokens([_ | tokens], counter), do: drop_tokens(tokens, counter)\n defp drop_tokens([], _counter), do: []\n\n defp maybe_missing_stab?([{:after, _} | _], _stab_choice?), do: true\n defp maybe_missing_stab?([{:do, _} | _], _stab_choice?), do: true\n defp maybe_missing_stab?([{:fn, _} | _], _stab_choice?), do: true\n defp maybe_missing_stab?([{:else, _} | _], _stab_choice?), do: true\n defp maybe_missing_stab?([{:catch, _} | _], _stab_choice?), do: true\n defp maybe_missing_stab?([{:rescue, _} | _], _stab_choice?), do: true\n defp maybe_missing_stab?([{:stab_op, _, :->} | _], stab_choice?), do: stab_choice?\n defp maybe_missing_stab?([_ | tail], stab_choice?), do: maybe_missing_stab?(tail, stab_choice?)\n defp maybe_missing_stab?([], _stab_choice?), do: false\nend\n" }, { "path": "lib/elixir/lib/code/identifier.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Code.Identifier do\n @moduledoc false\n\n @doc \"\"\"\n Checks if the given identifier is an unary op.\n\n ## Examples\n\n iex> Code.Identifier.unary_op(:+)\n {:non_associative, 300}\n\n \"\"\"\n @spec unary_op(atom) :: {:non_associative, precedence :: pos_integer} | :error\n def unary_op(op) do\n cond do\n op in [:&, :...] -> {:non_associative, 90}\n op in [:!, :^, :not, :+, :-, :\"~~~\"] -> {:non_associative, 300}\n op in [:@] -> {:non_associative, 320}\n true -> :error\n end\n end\n\n @doc \"\"\"\n Checks if the given identifier is a binary op.\n\n ## Examples\n\n iex> Code.Identifier.binary_op(:+)\n {:left, 210}\n\n \"\"\"\n @spec binary_op(atom) :: {:left | :right, precedence :: pos_integer} | :error\n def binary_op(op) do\n cond do\n op in [:<-, :\\\\] -> {:left, 40}\n op in [:when] -> {:right, 50}\n op in [:\"::\"] -> {:right, 60}\n op in [:|] -> {:right, 70}\n op in [:=] -> {:right, 100}\n op in [:||, :|||, :or] -> {:left, 120}\n op in [:&&, :&&&, :and] -> {:left, 130}\n op in [:==, :!=, :=~, :===, :!==] -> {:left, 140}\n op in [:<, :<=, :>=, :>] -> {:left, 150}\n op in [:|>, :<<<, :>>>, :<~, :~>, :<<~, :~>>, :<~>, :\"<|>\"] -> {:left, 160}\n op in [:in] -> {:left, 170}\n op in [:\"^^^\"] -> {:left, 180}\n op in [:++, :--, :.., :<>, :+++, :---] -> {:right, 200}\n op in [:+, :-] -> {:left, 210}\n op in [:*, :/] -> {:left, 220}\n op in [:**] -> {:left, 230}\n op in [:.] -> {:left, 310}\n true -> :error\n end\n end\n\n @doc \"\"\"\n Extracts the name and arity of the parent from the anonymous function identifier.\n \"\"\"\n # Example of this format: -NAME/ARITY-fun-COUNT-\n def extract_anonymous_fun_parent(atom) when is_atom(atom) do\n with \"-\" <> rest <- Atom.to_string(atom),\n [trailing | reversed] = rest |> String.split(\"/\") |> Enum.reverse(),\n [arity, _inner, _count, \"\"] <- String.split(trailing, \"-\") do\n {reversed |> Enum.reverse() |> Enum.join(\"/\") |> String.to_atom(), arity}\n else\n _ -> :error\n end\n end\n\n @doc \"\"\"\n Escapes the given identifier.\n \"\"\"\n @spec escape(binary(), char() | nil, :infinity | non_neg_integer, (char() -> iolist() | false)) ::\n {escaped :: binary(), remaining :: binary()}\n def escape(binary, char, limit \\\\ :infinity, fun \\\\ &escape_map/1)\n when (is_binary(binary) and ((char in 0..0x10FFFF or is_nil(char)) and limit == :infinity)) or\n (is_integer(limit) and limit >= 0) do\n escape(binary, char, limit, <<>>, fun)\n end\n\n defp escape(<<_, _::binary>> = binary, _char, 0, acc, _fun) do\n {acc, binary}\n end\n\n defp escape(<>, char, count, acc, fun) do\n escape(t, char, decrement(count), <>, fun)\n end\n\n defp escape(<>, char, count, acc, fun) do\n escape(t, char, decrement(count), <>, fun)\n end\n\n defp escape(<>, char, count, acc, fun) do\n if value = fun.(h) do\n value = IO.iodata_to_binary(value)\n escape(t, char, decrement(count), <>, fun)\n else\n escape(t, char, decrement(count), escape_char(h, acc), fun)\n end\n end\n\n defp escape(<>, char, count, acc, fun) do\n escape(t, char, decrement(count), <>, fun)\n end\n\n defp escape(<<>>, _char, _count, acc, _fun) do\n {acc, <<>>}\n end\n\n defp escape_char(0, acc), do: <>\n\n defp escape_char(char, acc)\n # Some characters that are confusing (zero-width / alternative spaces) are displayed\n # using their unicode representation:\n # https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Special-purpose_characters\n\n # BOM\n when char == 0xFEFF\n # Mathematical invisibles\n when char in 0x2061..0x2064\n # Bidirectional neutral\n when char in [0x061C, 0x200E, 0x200F]\n # Bidirectional general (source of vulnerabilities)\n when char in 0x202A..0x202E\n when char in 0x2066..0x2069\n # Interlinear annotations\n when char in 0xFFF9..0xFFFC\n # Zero-width joiners and non-joiners\n when char in [0x200C, 0x200D, 0x034F]\n # Non-break space / zero-width space\n when char in [0x00A0, 0x200B, 0x2060]\n # Line/paragraph separators\n when char in [0x2028, 0x2029]\n # Spaces\n when char in 0x2000..0x200A\n when char == 0x205F do\n <> = <>\n <>\n end\n\n defp escape_char(char, acc)\n when char in 0x20..0x7E\n when char in 0xA0..0xD7FF\n when char in 0xE000..0xFFFD\n when char in 0x10000..0x10FFFF do\n <>\n end\n\n defp escape_char(char, acc) when char < 0x100 do\n <> = <>\n <>\n end\n\n defp escape_char(char, acc) when char < 0x10000 do\n <> = <>\n <>\n end\n\n defp escape_char(char, acc) when char < 0x1000000 do\n <> = <>\n\n <>\n end\n\n defp escape_map(?\\a), do: \"\\\\a\"\n defp escape_map(?\\b), do: \"\\\\b\"\n defp escape_map(?\\d), do: \"\\\\d\"\n defp escape_map(?\\e), do: \"\\\\e\"\n defp escape_map(?\\f), do: \"\\\\f\"\n defp escape_map(?\\n), do: \"\\\\n\"\n defp escape_map(?\\r), do: \"\\\\r\"\n defp escape_map(?\\t), do: \"\\\\t\"\n defp escape_map(?\\v), do: \"\\\\v\"\n defp escape_map(?\\\\), do: \"\\\\\\\\\"\n defp escape_map(_), do: false\n\n @compile {:inline, to_hex: 1, decrement: 1}\n defp to_hex(c) when c in 0..9, do: ?0 + c\n defp to_hex(c) when c in 10..15, do: ?A + c - 10\n\n defp decrement(:infinity), do: :infinity\n defp decrement(counter), do: counter - 1\nend\n" }, { "path": "lib/elixir/lib/code/normalizer.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\ndefmodule Code.Normalizer do\n @moduledoc false\n\n defguard is_literal(x)\n when is_integer(x) or\n is_float(x) or\n is_binary(x) or\n is_atom(x)\n\n @doc \"\"\"\n Wraps literals in the quoted expression to conform to the AST format expected\n by the formatter.\n \"\"\"\n @spec normalize(Macro.t(), keyword()) :: Macro.t()\n def normalize(quoted, opts \\\\ []) do\n line = Keyword.get(opts, :line, nil)\n escape = Keyword.get(opts, :escape, true)\n locals_without_parens = Keyword.get(opts, :locals_without_parens, [])\n\n state = %{\n escape: escape,\n parent_meta: [line: line],\n locals_without_parens: locals_without_parens ++ Code.Formatter.locals_without_parens()\n }\n\n do_normalize(quoted, state)\n end\n\n # Wrapped literals should receive the block meta\n defp do_normalize({:__block__, meta, [literal]}, state)\n when not is_tuple(literal) or tuple_size(literal) == 2 do\n normalize_literal(literal, meta, state)\n end\n\n # Only normalize the first argument of an alias if it's not an atom\n defp do_normalize({:__aliases__, meta, [first | rest]}, state) when not is_atom(first) do\n meta = patch_meta_line(meta, state.parent_meta)\n first = do_normalize(first, %{state | parent_meta: meta})\n {:__aliases__, meta, [first | rest]}\n end\n\n defp do_normalize({:__aliases__, _, _} = quoted, _state) do\n quoted\n end\n\n # Skip captured arguments like &1\n defp do_normalize({:&, meta, [term]}, state) when is_integer(term) do\n meta = patch_meta_line(meta, state.parent_meta)\n {:&, meta, [term]}\n end\n\n # Ranges\n defp do_normalize(left..right//step, state) do\n left = do_normalize(left, state)\n right = do_normalize(right, state)\n meta = meta_line(state)\n\n if step == 1 do\n {:.., meta, [left, right]}\n else\n step = do_normalize(step, state)\n {:..//, meta, [left, right, step]}\n end\n end\n\n # Bit containers\n defp do_normalize({:<<>>, _, args} = quoted, state) when is_list(args) do\n normalize_bitstring(quoted, state)\n end\n\n # Atoms with interpolations\n defp do_normalize(\n {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta,\n [{:<<>>, _, parts} = string, :utf8]},\n state\n )\n when is_list(parts) do\n dot_meta = patch_meta_line(dot_meta, state.parent_meta)\n call_meta = patch_meta_line(call_meta, dot_meta)\n\n utf8 =\n if parts == [] or binary_interpolated?(parts) do\n # a non-normalized :utf8 atom signals an atom interpolation\n :utf8\n else\n normalize_literal(:utf8, [], state)\n end\n\n string =\n if state.escape do\n normalize_bitstring(string, state, true)\n else\n normalize_bitstring(string, state)\n end\n\n {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta, [string, utf8]}\n end\n\n # Charlists with interpolations\n # TODO: Remove this clause on Elixir v2.0 once single-quoted charlists are removed\n defp do_normalize({{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]} = quoted, state) do\n if list_interpolated?(parts) do\n parts =\n Enum.map(parts, fn\n {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args} ->\n args = normalize_args(args, state)\n\n {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args}\n\n part when is_binary(part) ->\n if state.escape do\n maybe_escape_literal(part, state)\n else\n part\n end\n end)\n\n {{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]}\n else\n normalize_call(quoted, state)\n end\n end\n\n # Don't normalize the `Access` atom in access syntax\n defp do_normalize({:., meta, [Access, :get]}, state) do\n meta = patch_meta_line(meta, state.parent_meta)\n {:., meta, [Access, :get]}\n end\n\n # The right hand side is an atom in the AST but it's not an atom literal, so\n # it should not be wrapped. However, it should be escaped if applicable.\n defp do_normalize({:., meta, [left, right]}, state) when is_atom(right) do\n meta = patch_meta_line(meta, state.parent_meta)\n\n left = do_normalize(left, %{state | parent_meta: meta})\n right = maybe_escape_literal(right, state)\n\n {:., meta, [left, right]}\n end\n\n # left -> right\n defp do_normalize({:->, meta, [left, right]}, state) do\n meta = patch_meta_line(meta, state.parent_meta)\n\n left = normalize_args(left, %{state | parent_meta: meta})\n right = do_normalize(right, %{state | parent_meta: meta})\n {:->, meta, [left, right]}\n end\n\n # Maps\n defp do_normalize({:%{}, meta, args}, state) when is_list(args) do\n meta =\n if meta == [] do\n line = state.parent_meta[:line]\n [line: line, closing: [line: line]]\n else\n meta\n end\n\n state = %{state | parent_meta: meta}\n\n args =\n case args do\n [{:|, pipe_meta, [left, right]}] ->\n left = do_normalize(left, state)\n right = normalize_map_args(right, state)\n [{:|, pipe_meta, [left, right]}]\n\n args ->\n normalize_map_args(args, state)\n end\n\n {:%{}, meta, args}\n end\n\n # Sigils\n defp do_normalize({sigil, meta, [{:<<>>, _, args} = string, modifiers]} = quoted, state)\n when is_atom(sigil) and is_list(args) and is_list(modifiers) do\n with \"sigil_\" <> _ <- Atom.to_string(sigil),\n true <- binary_interpolated?(args),\n true <- List.ascii_printable?(modifiers) do\n meta =\n meta\n |> patch_meta_line(state.parent_meta)\n |> Keyword.put_new(:delimiter, \"\\\"\")\n\n {sigil, meta, [do_normalize(string, %{state | parent_meta: meta}), modifiers]}\n else\n _ ->\n normalize_call(quoted, state)\n end\n end\n\n # Tuples\n defp do_normalize({:{}, meta, args} = quoted, state) when is_list(args) do\n {last_arg, args} = List.pop_at(args, -1)\n\n if args != [] and match?([_ | _], last_arg) and keyword?(last_arg) do\n args = normalize_args(args, state)\n kw_list = normalize_kw_args(last_arg, state, true)\n {:{}, meta, args ++ kw_list}\n else\n normalize_call(quoted, state)\n end\n end\n\n # Module attributes\n defp do_normalize({:@, meta, [{name, name_meta, [value]}]}, state) do\n value =\n cond do\n keyword?(value) and value != [] ->\n normalize_kw_args(value, state, true)\n\n is_list(value) ->\n normalize_literal(value, meta, state)\n\n true ->\n do_normalize(value, state)\n end\n\n {:@, meta, [{name, name_meta, [value]}]}\n end\n\n # Regular blocks\n defp do_normalize({:__block__, meta, args}, state) when is_list(args) do\n {:__block__, meta, normalize_args(args, state)}\n end\n\n # Calls\n defp do_normalize({_, _, args} = quoted, state) when is_list(args) do\n normalize_call(quoted, state)\n end\n\n # Vars\n defp do_normalize({_, _, context} = quoted, _state) when is_atom(context) do\n quoted\n end\n\n # Literals\n defp do_normalize(quoted, state) do\n normalize_literal(quoted, [], state)\n end\n\n # Numbers\n defp normalize_literal(number, meta, state) when is_number(number) do\n meta =\n meta\n |> Keyword.put_new(:token, inspect(number))\n |> patch_meta_line(state.parent_meta)\n\n {:__block__, meta, [number]}\n end\n\n # Atom, Strings\n defp normalize_literal(literal, meta, state) when is_atom(literal) or is_binary(literal) do\n meta = patch_meta_line(meta, state.parent_meta)\n literal = maybe_escape_literal(literal, state)\n\n if is_atom(literal) and Macro.classify_atom(literal) == :alias and\n is_nil(meta[:delimiter]) do\n segments =\n case Atom.to_string(literal) do\n \"Elixir\" ->\n [:\"Elixir\"]\n\n \"Elixir.\" <> segments ->\n segments\n |> String.split(\".\")\n |> Enum.map(&String.to_atom/1)\n end\n\n {:__aliases__, meta, segments}\n else\n {:__block__, meta, [literal]}\n end\n end\n\n # 2-tuples\n defp normalize_literal({left, right}, meta, state) do\n meta = patch_meta_line(meta, state.parent_meta)\n state = %{state | parent_meta: meta}\n\n if match?([_ | _], right) and keyword?(right) do\n {:__block__, meta, [{do_normalize(left, state), normalize_kw_args(right, state, true)}]}\n else\n {:__block__, meta, [{do_normalize(left, state), do_normalize(right, state)}]}\n end\n end\n\n # Lists\n defp normalize_literal(list, meta, state) when is_list(list) do\n if list != [] and List.ascii_printable?(list) do\n # It's a charlist, we normalize it as a ~C sigil\n string =\n if state.escape do\n {iolist, _} = Code.Identifier.escape(IO.chardata_to_string(list), nil)\n IO.iodata_to_binary(iolist)\n else\n List.to_string(list)\n end\n\n meta = patch_meta_line([delimiter: \"\\\"\"], state.parent_meta)\n\n {:sigil_c, meta, [{:<<>>, [], [string]}, []]}\n else\n meta =\n if line = state.parent_meta[:line] do\n meta\n |> Keyword.put_new(:closing, line: line)\n |> patch_meta_line(state.parent_meta)\n else\n meta\n end\n\n {:__block__, meta, [normalize_kw_args(list, state, false)]}\n end\n end\n\n # Probably an invalid value, wrap it and send it upstream\n defp normalize_literal(quoted, meta, _state) do\n {:__block__, meta, [quoted]}\n end\n\n defp normalize_call({form, meta, args}, state) do\n meta = patch_meta_line(meta, state.parent_meta)\n arity = length(args)\n\n # Only normalize the form if it's a qualified call\n form =\n if is_atom(form) do\n form\n else\n do_normalize(form, %{state | parent_meta: meta})\n end\n\n meta =\n if is_nil(meta[:no_parens]) and is_nil(meta[:closing]) and is_nil(meta[:do]) and\n not Code.Formatter.local_without_parens?(form, arity, state.locals_without_parens) do\n [closing: [line: meta[:line]]] ++ meta\n else\n meta\n end\n\n last = List.last(args)\n\n cond do\n not allow_keyword?(form, arity) ->\n args = normalize_args(args, %{state | parent_meta: meta})\n {form, meta, args}\n\n Keyword.has_key?(meta, :do) ->\n # def foo do :ok end\n # def foo, do: :ok\n normalize_kw_blocks(form, meta, args, state)\n\n match?([{:do, _} | _], last) and Keyword.keyword?(last) ->\n # Non normalized kw blocks\n line = state.parent_meta[:line] || meta[:line]\n meta = meta ++ [do: [line: line], end: [line: line]]\n normalize_kw_blocks(form, meta, args, state)\n\n true ->\n args = normalize_args(args, %{state | parent_meta: meta})\n {last_arg, leading_args} = List.pop_at(args, -1, [])\n\n last_args =\n case last_arg do\n {:__block__, _meta, [[{{:__block__, key_meta, _}, _} | _] = keyword]} ->\n cond do\n key_meta[:format] == :keyword ->\n [keyword]\n\n block_keyword?(keyword) ->\n [\n Enum.map(keyword, fn {{:__block__, meta, args}, value} ->\n {{:__block__, [format: :keyword] ++ meta, args}, value}\n end)\n ]\n\n true ->\n [last_arg]\n end\n\n [] ->\n []\n\n _ ->\n [last_arg]\n end\n\n {form, meta, leading_args ++ last_args}\n end\n end\n\n defp block_keyword?([{{:__block__, _, [key]}, _val} | tail]) when is_atom(key),\n do: block_keyword?(tail)\n\n defp block_keyword?([]), do: true\n defp block_keyword?(_), do: false\n\n defp allow_keyword?(:when, 2), do: true\n defp allow_keyword?(:{}, _), do: false\n defp allow_keyword?(op, arity), do: not is_atom(op) or not Macro.operator?(op, arity)\n\n defp normalize_bitstring({:<<>>, meta, parts}, state, escape_interpolation \\\\ false) do\n meta = patch_meta_line(meta, state.parent_meta)\n\n parts =\n if binary_interpolated?(parts) do\n normalize_interpolation_parts(parts, %{state | parent_meta: meta}, escape_interpolation)\n else\n state = %{state | parent_meta: meta}\n\n Enum.map(parts, fn part ->\n with {:\"::\", meta, [left, _]} <- part,\n true <- meta[:inferred_bitstring_spec] do\n do_normalize(left, state)\n else\n _ -> do_normalize(part, state)\n end\n end)\n end\n\n {:<<>>, meta, parts}\n end\n\n defp normalize_interpolation_parts(parts, state, escape_interpolation) do\n Enum.map(parts, fn\n {:\"::\", interpolation_meta,\n [\n {{:., dot_meta, [Kernel, :to_string]}, middle_meta, [middle]},\n {:binary, binary_meta, context}\n ]} ->\n middle = do_normalize(middle, %{state | parent_meta: dot_meta})\n\n {:\"::\", interpolation_meta,\n [\n {{:., dot_meta, [Kernel, :to_string]}, middle_meta, [middle]},\n {:binary, binary_meta, context}\n ]}\n\n part ->\n if escape_interpolation do\n maybe_escape_literal(part, state)\n else\n part\n end\n end)\n end\n\n defp normalize_map_args(args, state) do\n Enum.map(normalize_kw_args(args, state, false), fn\n {:__block__, _, [{_, _} = pair]} -> pair\n pair -> pair\n end)\n end\n\n defp normalize_kw_blocks(form, meta, args, state) do\n {kw_blocks, leading_args} = List.pop_at(args, -1)\n\n kw_blocks =\n Enum.map(kw_blocks, fn {tag, block} ->\n block = do_normalize(block, %{state | parent_meta: meta})\n\n block =\n case block do\n {_, _, [[{:->, _, _} | _] = block]} -> block\n block -> block\n end\n\n # Only wrap the tag if it isn't already wrapped\n tag =\n case tag do\n {:__block__, _, _} -> tag\n _ -> {:__block__, [line: meta[:line]], [tag]}\n end\n\n {tag, block}\n end)\n\n leading_args = normalize_args(leading_args, %{state | parent_meta: meta})\n {form, meta, leading_args ++ [kw_blocks]}\n end\n\n defp normalize_kw_args(elems, state, keyword?)\n\n defp normalize_kw_args(\n [{{:__block__, key_meta, [key]}, value} = first | rest] = current,\n state,\n keyword?\n )\n when is_atom(key) do\n keyword? = keyword? or keyword?(current)\n\n first =\n if key_meta[:format] == :keyword and not keyword? do\n key_meta = Keyword.delete(key_meta, :format)\n line = key_meta[:line] || meta_line(state)\n {:__block__, [line: line], [{{:__block__, key_meta, [key]}, value}]}\n else\n first\n end\n\n [first | normalize_kw_args(rest, state, keyword?)]\n end\n\n defp normalize_kw_args([{left, right} | rest] = current, state, keyword?) do\n keyword? = keyword? or keyword?(current)\n\n left =\n if keyword? do\n meta = [format: :keyword] ++ meta_line(state)\n {:__block__, meta, [maybe_escape_literal(left, state)]}\n else\n do_normalize(left, state)\n end\n\n right = do_normalize(right, state)\n\n pair =\n with {:__block__, meta, _} <- left,\n :keyword <- meta[:format] do\n {left, right}\n else\n _ -> {:__block__, meta_line(state), [{left, right}]}\n end\n\n [pair | normalize_kw_args(rest, state, keyword?)]\n end\n\n defp normalize_kw_args([first | rest], state, keyword?) do\n [do_normalize(first, state) | normalize_kw_args(rest, state, keyword?)]\n end\n\n defp normalize_kw_args([], _state, _keyword?) do\n []\n end\n\n defp normalize_args(args, state) do\n Enum.map(args, &do_normalize(&1, state))\n end\n\n defp maybe_escape_literal(string, %{escape: true}) when is_binary(string) do\n {string, _} = Code.Identifier.escape(string, nil)\n IO.iodata_to_binary(string)\n end\n\n defp maybe_escape_literal(atom, %{escape: true} = state) when is_atom(atom) do\n atom\n |> Atom.to_string()\n |> maybe_escape_literal(state)\n |> String.to_atom()\n end\n\n defp maybe_escape_literal(term, _) do\n term\n end\n\n defp binary_interpolated?(parts) do\n Enum.all?(parts, fn\n {:\"::\", _, [{{:., _, [Kernel, :to_string]}, _, [_]}, {:binary, _, _}]} -> true\n binary when is_binary(binary) -> true\n _ -> false\n end)\n end\n\n defp list_interpolated?(parts) do\n Enum.all?(parts, fn\n {{:., _, [Kernel, :to_string]}, _, [_]} -> true\n binary when is_binary(binary) -> true\n _ -> false\n end)\n end\n\n defp patch_meta_line(meta, parent_meta) do\n with nil <- meta[:line],\n line when is_integer(line) <- parent_meta[:line] do\n [line: line] ++ meta\n else\n _ -> meta\n end\n end\n\n defp meta_line(state) do\n if line = state.parent_meta[:line] do\n [line: line]\n else\n []\n end\n end\n\n defp keyword?([{{:__block__, key_meta, [key]}, _} | rest]) when is_atom(key) do\n if key_meta[:format] == :keyword do\n keyword?(rest)\n else\n false\n end\n end\n\n defp keyword?([{key, _value} | rest]) when is_atom(key) do\n case Atom.to_charlist(key) do\n ~c\"Elixir.\" ++ _ -> false\n _ -> keyword?(rest)\n end\n end\n\n defp keyword?([]), do: true\n defp keyword?(_other), do: false\nend\n" }, { "path": "lib/elixir/lib/code/typespec.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Code.Typespec do\n @moduledoc false\n\n @doc \"\"\"\n Converts a spec clause back to Elixir quoted expression.\n \"\"\"\n @spec spec_to_quoted(atom, tuple) :: {atom, keyword, [Macro.t()]}\n def spec_to_quoted(name, spec)\n\n def spec_to_quoted(name, {:type, anno, :fun, [{:type, _, :product, args}, result]})\n when is_atom(name) do\n meta = meta(anno)\n body = {name, meta, Enum.map(args, &typespec_to_quoted/1)}\n\n vars =\n for type_expr <- args ++ [result],\n var <- collect_vars(type_expr),\n uniq: true,\n do: {var, {:var, meta, nil}}\n\n spec = {:\"::\", meta, [body, typespec_to_quoted(result)]}\n\n if vars == [] do\n spec\n else\n {:when, meta, [spec, vars]}\n end\n end\n\n def spec_to_quoted(name, {:type, anno, :bounded_fun, [type, constrs]}) when is_atom(name) do\n meta = meta(anno)\n {:type, _, :fun, [{:type, _, :product, args}, result]} = type\n\n guards =\n for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constrs do\n {erl_to_ex_var(var), typespec_to_quoted(type)}\n end\n\n ignore_vars = Keyword.keys(guards)\n\n vars =\n for type_expr <- args ++ [result],\n var <- collect_vars(type_expr),\n var not in ignore_vars,\n uniq: true,\n do: {var, {:var, meta, nil}}\n\n args = for arg <- args, do: typespec_to_quoted(arg)\n\n when_args = [\n {:\"::\", meta, [{name, meta, args}, typespec_to_quoted(result)]},\n guards ++ vars\n ]\n\n {:when, meta, when_args}\n end\n\n @doc \"\"\"\n Converts a type clause back to Elixir AST.\n \"\"\"\n def type_to_quoted(type)\n\n def type_to_quoted({{:record, record}, fields, args}) when is_atom(record) do\n fields = for field <- fields, do: typespec_to_quoted(field)\n args = for arg <- args, do: typespec_to_quoted(arg)\n type = {:{}, [], [record | fields]}\n quote(do: unquote(record)(unquote_splicing(args)) :: unquote(type))\n end\n\n def type_to_quoted({name, type, args}) when is_atom(name) do\n args = for arg <- args, do: typespec_to_quoted(arg)\n quote(do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_quoted(type)))\n end\n\n @doc \"\"\"\n Returns all types available from the module's BEAM code.\n\n The result is returned as a list of tuples where the first\n element is the type (`:typep`, `:type` and `:opaque`).\n\n The module must have a corresponding BEAM file which can be\n located by the runtime system. The types will be in the Erlang\n Abstract Format.\n \"\"\"\n @spec fetch_types(module | binary) :: {:ok, [tuple]} | :error\n def fetch_types(module) when is_atom(module) or is_binary(module) do\n case typespecs_abstract_code(module) do\n {:ok, abstract_code} ->\n exported_types = for {:attribute, _, :export_type, types} <- abstract_code, do: types\n exported_types = List.flatten(exported_types)\n\n types =\n for {:attribute, _, kind, {name, _, args} = type} <- abstract_code,\n kind in [:opaque, :type] do\n cond do\n kind == :opaque -> {:opaque, type}\n {name, length(args)} in exported_types -> {:type, type}\n true -> {:typep, type}\n end\n end\n\n {:ok, types}\n\n _ ->\n :error\n end\n end\n\n @doc \"\"\"\n Returns all specs available from the module's BEAM code.\n\n The result is returned as a list of tuples where the first\n element is spec name and arity and the second is the spec.\n\n The module must have a corresponding BEAM file which can be\n located by the runtime system. The types will be in the Erlang\n Abstract Format.\n \"\"\"\n @spec fetch_specs(module | binary) :: {:ok, [tuple]} | :error\n def fetch_specs(module) when is_atom(module) or is_binary(module) do\n case typespecs_abstract_code(module) do\n {:ok, abstract_code} ->\n {:ok, for({:attribute, _, :spec, value} <- abstract_code, do: value)}\n\n :error ->\n :error\n end\n end\n\n @doc \"\"\"\n Returns all callbacks available from the module's BEAM code.\n\n The result is returned as a list of tuples where the first\n element is spec name and arity and the second is the spec.\n\n The module must have a corresponding BEAM file\n which can be located by the runtime system. The types will be\n in the Erlang Abstract Format.\n \"\"\"\n @spec fetch_callbacks(module | binary) :: {:ok, [tuple]} | :error\n def fetch_callbacks(module) when is_atom(module) or is_binary(module) do\n case typespecs_abstract_code(module) do\n {:ok, abstract_code} ->\n {:ok, for({:attribute, _, :callback, value} <- abstract_code, do: value)}\n\n :error ->\n :error\n end\n end\n\n defp typespecs_abstract_code(module) do\n with {module, binary} <- get_module_and_beam(module),\n {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} <-\n :beam_lib.chunks(binary, [:debug_info]) do\n case data do\n {:elixir_v1, %{}, specs} ->\n # Fast path to avoid translation to Erlang from Elixir.\n {:ok, specs}\n\n _ ->\n case backend.debug_info(:erlang_v1, module, data, []) do\n {:ok, abstract_code} -> {:ok, abstract_code}\n _ -> :error\n end\n end\n else\n _ -> :error\n end\n end\n\n defp get_module_and_beam(module) when is_atom(module) do\n with {^module, beam, _filename} <- :code.get_object_code(module),\n info_pairs when is_list(info_pairs) <- :beam_lib.info(beam),\n {:ok, ^module} <- Keyword.fetch(info_pairs, :module) do\n {module, beam}\n else\n _ -> :error\n end\n end\n\n defp get_module_and_beam(beam) when is_binary(beam) do\n case :beam_lib.info(beam) do\n [_ | _] = info -> {info[:module], beam}\n _ -> :error\n end\n end\n\n ## To AST conversion\n\n defp collect_vars({:ann_type, _anno, args}) when is_list(args) do\n []\n end\n\n defp collect_vars({:type, _anno, _kind, args}) when is_list(args) do\n Enum.flat_map(args, &collect_vars/1)\n end\n\n defp collect_vars({:remote_type, _anno, args}) when is_list(args) do\n Enum.flat_map(args, &collect_vars/1)\n end\n\n defp collect_vars({:typed_record_field, _anno, type}) do\n collect_vars(type)\n end\n\n defp collect_vars({:paren_type, _anno, [type]}) do\n collect_vars(type)\n end\n\n defp collect_vars({:var, _anno, var}) do\n [erl_to_ex_var(var)]\n end\n\n defp collect_vars(_) do\n []\n end\n\n defp typespec_to_quoted({:user_type, anno, name, args}) do\n args = for arg <- args, do: typespec_to_quoted(arg)\n {name, meta(anno), args}\n end\n\n defp typespec_to_quoted({:type, anno, :tuple, :any}) do\n {:tuple, meta(anno), []}\n end\n\n defp typespec_to_quoted({:type, anno, :tuple, args}) do\n args = for arg <- args, do: typespec_to_quoted(arg)\n {:{}, meta(anno), args}\n end\n\n defp typespec_to_quoted({:type, _anno, :list, [{:type, _, :union, unions} = arg]}) do\n case unpack_typespec_kw(unions, []) do\n {:ok, ast} -> ast\n :error -> [typespec_to_quoted(arg)]\n end\n end\n\n defp typespec_to_quoted({:type, anno, :list, []}) do\n {:list, meta(anno), []}\n end\n\n defp typespec_to_quoted({:type, _anno, :list, [arg]}) do\n [typespec_to_quoted(arg)]\n end\n\n defp typespec_to_quoted({:type, anno, :nonempty_list, []}) do\n [{:..., meta(anno), nil}]\n end\n\n defp typespec_to_quoted({:type, anno, :nonempty_list, [arg]}) do\n [typespec_to_quoted(arg), {:..., meta(anno), nil}]\n end\n\n defp typespec_to_quoted({:type, anno, :map, :any}) do\n {:map, meta(anno), []}\n end\n\n defp typespec_to_quoted({:type, anno, :map, fields}) do\n fields =\n Enum.map(fields, fn\n {:type, _, :map_field_assoc, :any} ->\n {{:optional, [], [{:any, [], []}]}, {:any, [], []}}\n\n {:type, _, :map_field_exact, [{:atom, _, k}, v]} ->\n {k, typespec_to_quoted(v)}\n\n {:type, _, :map_field_exact, [k, v]} ->\n {{:required, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}\n\n {:type, _, :map_field_assoc, [k, v]} ->\n {{:optional, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}\n end)\n\n case List.keytake(fields, :__struct__, 0) do\n {{:__struct__, struct}, fields_pruned} when is_atom(struct) and struct != nil ->\n map_pruned = {:%{}, meta(anno), fields_pruned}\n {:%, meta(anno), [struct, map_pruned]}\n\n _ ->\n {:%{}, meta(anno), fields}\n end\n end\n\n defp typespec_to_quoted({:type, anno, :binary, [arg1, arg2]}) do\n line = meta(anno)[:line]\n\n case {typespec_to_quoted(arg1), typespec_to_quoted(arg2)} do\n {arg1, 0} ->\n quote(line: line, do: <<_::unquote(arg1)>>)\n\n {0, arg2} ->\n quote(line: line, do: <<_::_*unquote(arg2)>>)\n\n {arg1, arg2} ->\n quote(line: line, do: <<_::unquote(arg1), _::_*unquote(arg2)>>)\n end\n end\n\n defp typespec_to_quoted({:type, anno, :union, args}) do\n args = for arg <- args, do: typespec_to_quoted(arg)\n Enum.reduce(Enum.reverse(args), fn arg, expr -> {:|, meta(anno), [arg, expr]} end)\n end\n\n defp typespec_to_quoted({:type, anno, :fun, [{:type, _, :product, args}, result]}) do\n args = for arg <- args, do: typespec_to_quoted(arg)\n [{:->, meta(anno), [args, typespec_to_quoted(result)]}]\n end\n\n defp typespec_to_quoted({:type, anno, :fun, [args, result]}) do\n [{:->, meta(anno), [[typespec_to_quoted(args)], typespec_to_quoted(result)]}]\n end\n\n defp typespec_to_quoted({:type, anno, :range, [left, right]}) do\n {:.., meta(anno), [typespec_to_quoted(left), typespec_to_quoted(right)]}\n end\n\n defp typespec_to_quoted({:type, _anno, nil, []}) do\n []\n end\n\n defp typespec_to_quoted({:type, anno, name, args}) do\n args = for arg <- args, do: typespec_to_quoted(arg)\n {name, meta(anno), args}\n end\n\n defp typespec_to_quoted({:var, anno, var}) do\n {erl_to_ex_var(var), meta(anno), nil}\n end\n\n defp typespec_to_quoted({:op, anno, op, arg}) when op in [:+, :-] do\n {op, meta(anno), [typespec_to_quoted(arg)]}\n end\n\n defp typespec_to_quoted({:op, anno, :*, arg1, arg2}) do\n {:*, meta(anno), [typespec_to_quoted(arg1), typespec_to_quoted(arg2)]}\n end\n\n defp typespec_to_quoted({:remote_type, anno, [mod, name, args]}) do\n remote_type(anno, mod, name, args)\n end\n\n defp typespec_to_quoted({:ann_type, anno, [var, type]}) do\n {:\"::\", meta(anno), [typespec_to_quoted(var), typespec_to_quoted(type)]}\n end\n\n defp typespec_to_quoted(\n {:typed_record_field, {:record_field, anno1, {:atom, anno2, name}}, type}\n ) do\n typespec_to_quoted({:ann_type, anno1, [{:var, anno2, name}, type]})\n end\n\n defp typespec_to_quoted({:type, _, :any}) do\n quote(do: ...)\n end\n\n defp typespec_to_quoted({:paren_type, _, [type]}) do\n typespec_to_quoted(type)\n end\n\n defp typespec_to_quoted({type, _anno, atom}) when is_atom(type) do\n atom\n end\n\n defp typespec_to_quoted(other), do: other\n\n ## Helpers\n\n defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :charlist}, []) do\n typespec_to_quoted({:type, anno, :charlist, []})\n end\n\n defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []) do\n typespec_to_quoted({:type, anno, :nonempty_charlist, []})\n end\n\n defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :struct}, []) do\n typespec_to_quoted({:type, anno, :struct, []})\n end\n\n defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]) do\n typespec_to_quoted({:type, anno, :as_boolean, [arg]})\n end\n\n defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :keyword}, args) do\n typespec_to_quoted({:type, anno, :keyword, args})\n end\n\n defp remote_type(anno, mod, name, args) do\n args = for arg <- args, do: typespec_to_quoted(arg)\n dot = {:., meta(anno), [typespec_to_quoted(mod), typespec_to_quoted(name)]}\n {dot, meta(anno), args}\n end\n\n defp erl_to_ex_var(var) do\n case Atom.to_string(var) do\n <<\"_\", c::utf8, rest::binary>> ->\n String.to_atom(\"_#{String.downcase(<>)}#{rest}\")\n\n <> ->\n String.to_atom(\"#{String.downcase(<>)}#{rest}\")\n end\n end\n\n defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do\n unpack_typespec_kw(t, [{atom, typespec_to_quoted(type)} | acc])\n end\n\n defp unpack_typespec_kw([], acc) do\n {:ok, Enum.reverse(acc)}\n end\n\n defp unpack_typespec_kw(_, _acc) do\n :error\n end\n\n defp meta(anno) do\n case :erl_anno.location(anno) do\n {line, column} ->\n [line: line, column: column]\n\n line when is_integer(line) ->\n [line: line]\n end\n end\nend\n" }, { "path": "lib/elixir/lib/code.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Code do\n @moduledoc ~S\"\"\"\n Utilities for managing code compilation, code evaluation, and code loading.\n\n This module complements Erlang's [`:code` module](`:code`)\n to add behavior which is specific to Elixir. For functions to\n manipulate Elixir's AST (rather than evaluating it), see the\n `Macro` module.\n\n ## Working with files\n\n This module contains three functions for compiling and evaluating files.\n Here is a summary of them and their behavior:\n\n * `require_file/2` - compiles a file and tracks its name. It does not\n compile the file again if it has been previously required.\n\n * `compile_file/2` - compiles a file without tracking its name. Compiles the\n file multiple times when invoked multiple times.\n\n * `eval_file/2` - evaluates the file contents without tracking its name. It\n returns the result of the last expression in the file, instead of the modules\n defined in it. Evaluated files do not trigger the compilation tracers described\n in the next section.\n\n In a nutshell, the first must be used when you want to keep track of the files\n handled by the system, to avoid the same file from being compiled multiple\n times. This is common in scripts.\n\n `compile_file/2` must be used when you are interested in the modules defined in a\n file, without tracking. `eval_file/2` should be used when you are interested in\n the result of evaluating the file rather than the modules it defines.\n\n The functions above work with Elixir source. If you want to work\n with modules compiled to bytecode, which have the `.beam` extension\n and are typically found below the _build directory of a Mix project,\n see the functions in Erlang's [`:code`](`:code`) module.\n\n ## Code loading on the Erlang VM\n\n Erlang has two modes to load code: interactive and embedded.\n\n By default, the Erlang VM runs in interactive mode, where modules\n are loaded as needed. In embedded mode the opposite happens, as all\n modules need to be loaded upfront or explicitly.\n\n You can use `ensure_loaded/1` (as well as `ensure_loaded?/1` and\n `ensure_loaded!/1`) to check if a module is loaded before using it and\n act.\n\n ## `ensure_compiled/1` and `ensure_compiled!/1`\n\n Elixir also includes `ensure_compiled/1` and `ensure_compiled!/1`\n functions that are a superset of `ensure_loaded/1`.\n\n Since Elixir's compilation happens in parallel, in some situations\n you may need to use a module that was not yet compiled, therefore\n it can't even be loaded.\n\n When invoked, `ensure_compiled/1` and `ensure_compiled!/1` halt the\n compilation of the caller until the module becomes available. Note that\n the distinction between `ensure_compiled/1` and `ensure_compiled!/1`\n is important: if you are using `ensure_compiled!/1`, you are\n indicating to the compiler that you can only continue if said module\n is available.\n\n If you are using `Code.ensure_compiled/1`, you are implying you may\n continue without the module and therefore Elixir may return\n `{:error, :unavailable}` for cases where the module is not yet available\n (but may be available later on).\n\n For those reasons, developers must typically use `Code.ensure_compiled!/1`.\n In particular, do not do this:\n\n case Code.ensure_compiled(module) do\n {:module, _} -> module\n {:error, _} -> raise ...\n end\n\n Finally, note you only need `ensure_compiled!/1` to check for modules\n being defined within the same project. It does not apply to modules from\n dependencies as dependencies are always compiled upfront.\n\n In most cases, `ensure_loaded/1` is enough. `ensure_compiled!/1`\n must be used in rare cases, usually involving macros that need to\n invoke a module for callback information. The use of `ensure_compiled/1`\n is even less likely.\n\n ## Compilation tracers\n\n Elixir supports compilation tracers, which allow modules to observe constructs\n handled by the Elixir compiler when compiling files. A tracer is a module\n that implements the `trace/2` function. The function receives the event name\n as first argument and `Macro.Env` as second and it must return `:ok`. It is\n very important for a tracer to do as little work as possible synchronously\n and dispatch the bulk of the work to a separate process. **Slow tracers will\n slow down compilation**.\n\n You can configure your list of tracers via `put_compiler_option/2`. The\n following events are available to tracers:\n\n * `:start` - (since v1.11.0) invoked whenever the compiler starts to trace\n a new lexical context. A lexical context is started when compiling a new\n file or when defining a module within a function. Note evaluated code\n does not start a new lexical context (because they don't track unused\n aliases, imports, etc) but defining a module inside evaluated code will.\n\n Note this event may be emitted in parallel, where multiple files/modules\n invoke `:start` and run at the same time. The value of the `lexical_tracker`\n of the macro environment, albeit opaque, can be used to uniquely identify\n the environment.\n\n * `:stop` - (since v1.11.0) invoked whenever the compiler stops tracing a\n new lexical context, such as a new file.\n\n * `{:import, meta, module, opts}` - traced whenever `module` is imported.\n `meta` is the import AST metadata and `opts` are the import options.\n\n * `{:imported_function, meta, module, name, arity}` and\n `{:imported_macro, meta, module, name, arity}` - traced whenever an\n imported function or macro is invoked. `meta` is the call AST metadata,\n `module` is the module the import is from, followed by the `name` and `arity`\n of the imported function/macro. A :remote_function/:remote_macro event\n may still be emitted for the imported module/name/arity.\n\n * `{:imported_quoted, meta, module, name, [arity]}` - traced whenever an\n imported function or macro is processed inside a `quote/2`. `meta` is the\n call AST metadata, `module` is the module the import is from, followed by\n the `name` and a list of `arities` of the imported function/macro.\n\n * `{:alias, meta, alias, as, opts}` - traced whenever `alias` is aliased\n to `as`. `meta` is the alias AST metadata and `opts` are the alias options.\n\n * `{:alias_expansion, meta, as, alias}` traced whenever there is an alias\n expansion for a previously defined `alias`, i.e. when the user writes `as`\n which is expanded to `alias`. `meta` is the alias expansion AST metadata.\n\n * `{:alias_reference, meta, module}` - traced whenever there is an alias\n in the code, i.e. whenever the user writes `MyModule.Foo.Bar` in the code,\n regardless if it was expanded or not.\n\n * `{:require, meta, module, opts}` - traced whenever `module` is required.\n `meta` is the require AST metadata and `opts` are the require options.\n If the `meta` option contains the `:from_macro`, then module was called\n from within a macro and therefore must be treated as a compile-time dependency.\n\n * `{:struct_expansion, meta, module, keys}` - traced whenever `module`'s struct\n is expanded. `meta` is the struct AST metadata and `keys` are the keys being\n used by expansion\n\n * `{:remote_function, meta, module, name, arity}` and\n `{:remote_macro, meta, module, name, arity}` - traced whenever a remote\n function or macro is referenced. `meta` is the call AST metadata, `module`\n is the invoked module, followed by the `name` and `arity`.\n\n * `{:local_function, meta, name, arity}` and\n `{:local_macro, meta, name, arity}` - traced whenever a local\n function or macro is referenced. `meta` is the call AST metadata, followed by\n the `name` and `arity`.\n\n * `{:compile_env, app, path, return}` - traced whenever `Application.compile_env/3`\n or `Application.compile_env!/2` are called. `app` is an atom, `path` is a list\n of keys to traverse in the application environment and `return` is either\n `{:ok, value}` or `:error`.\n\n * `:defmodule` - (since v1.16.2) traced as soon as the definition of a module\n starts. This is invoked early on in the module life cycle, `Module.open?/1`\n still returns `false` for such traces\n\n * `{:on_module, bytecode, _ignore}` - (since v1.13.0) traced whenever a module\n is defined. This is equivalent to the `@after_compile` callback and invoked\n after any `@after_compile` in the given module. The third element is currently\n `:none` but it may provide more metadata in the future. It is best to ignore\n it at the moment. Note that `Module` functions expecting not yet compiled modules\n (such as `Module.definitions_in/1`) are still available at the time this event\n is emitted.\n\n The `:tracers` compiler option can be combined with the `:parser_options`\n compiler option to enrich the metadata of the traced events above.\n\n New events may be added at any time in the future, therefore it is advised\n for the `trace/2` function to have a \"catch-all\" clause.\n\n Below is an example tracer that prints all remote function invocations:\n\n defmodule MyTracer do\n def trace({:remote_function, _meta, module, name, arity}, env) do\n IO.puts(\"#{env.file}:#{env.line} #{inspect(module)}.#{name}/#{arity}\")\n :ok\n end\n\n def trace(_event, _env) do\n :ok\n end\n end\n \"\"\"\n\n @typedoc \"\"\"\n A list with all variables and their values.\n\n The binding keys are usually atoms, but they may be a tuple for variables\n defined in a different context.\n \"\"\"\n @type binding :: [{atom() | tuple(), any}]\n\n @typedoc \"\"\"\n Diagnostics returned by the compiler and code evaluation.\n\n The file and position relate to where the diagnostic should be shown.\n If there is a file and position, then the diagnostic is precise\n and you can use the given file and position for generating snippets,\n IDEs annotations, and so on. An optional span is available with\n the line and column the diagnostic ends.\n\n Otherwise, a stacktrace may be given, which you can place your own\n heuristics to provide better reporting.\n\n The source field points to the source file the compiler tracked\n the error to. For example, a file `lib/foo.ex` may embed `.eex`\n templates from `lib/foo/bar.eex`. A syntax error on the EEx template\n will point to file `lib/foo/bar.eex` but the source is `lib/foo.ex`.\n \"\"\"\n @type diagnostic(severity) :: %{\n required(:source) => Path.t() | nil,\n required(:file) => Path.t() | nil,\n required(:severity) => severity,\n required(:message) => String.t(),\n required(:position) => position(),\n required(:stacktrace) => Exception.stacktrace(),\n required(:span) => {line :: pos_integer(), column :: pos_integer()} | nil,\n optional(:details) => term(),\n optional(any()) => any()\n }\n\n @typedoc \"The line. 0 indicates no line.\"\n @type line() :: non_neg_integer()\n\n @typedoc \"\"\"\n The position of the diagnostic.\n\n Can be either a line number or a `{line, column}`.\n Line and columns numbers are one-based.\n A position of `0` represents unknown.\n \"\"\"\n @type position() :: line() | {line :: pos_integer(), column :: pos_integer()}\n\n @typedoc \"\"\"\n Options for code formatting functions.\n \"\"\"\n @type format_opt ::\n {:file, binary()}\n | {:line, pos_integer()}\n | {:line_length, pos_integer()}\n | {:locals_without_parens, keyword()}\n | {:force_do_end_blocks, boolean()}\n | {:migrate, boolean()}\n | {:migrate_bitstring_modifiers, boolean()}\n | {:migrate_call_parens_on_pipe, boolean()}\n | {:migrate_charlists_as_sigils, boolean()}\n | {:migrate_unless, boolean()}\n | {atom(), term()}\n\n @typedoc \"\"\"\n Options for `quoted_to_algebra/2`.\n \"\"\"\n @type quoted_to_algebra_opt ::\n {:line, pos_integer() | nil}\n | {:escape, boolean()}\n | {:locals_without_parens, keyword()}\n | {:comments, [term()]}\n\n @typedoc \"\"\"\n Options for parsing functions that convert strings to quoted expressions.\n \"\"\"\n @type parser_opts :: [\n file: binary(),\n line: pos_integer(),\n column: pos_integer(),\n indentation: non_neg_integer(),\n columns: boolean(),\n unescape: boolean(),\n existing_atoms_only: boolean(),\n token_metadata: boolean(),\n literal_encoder: (term(), Macro.metadata() -> term()),\n static_atoms_encoder: (atom() -> term()),\n emit_warnings: boolean()\n ]\n\n @typedoc \"\"\"\n Options for evaluation environment, accepted by `env_for_eval/1`.\n \"\"\"\n @type env_eval_opt ::\n {:file, binary()}\n | {:line, pos_integer()}\n | {:module, module()}\n\n @typedoc \"\"\"\n Options for evaluation functions like `eval_string/3`, `eval_quoted/3`\n and `eval_quoted_with_env/4`.\n \"\"\"\n @type eval_opt ::\n {:prune_binding, boolean()}\n | {:dbg_callback, {module(), atom(), list()}}\n\n @boolean_compiler_options [\n :docs,\n :debug_info,\n :ignore_already_consolidated,\n :ignore_module_conflict,\n :relative_paths\n ]\n\n @list_compiler_options [:tracers, :parser_options]\n\n @available_compiler_options @boolean_compiler_options ++\n @list_compiler_options ++\n [\n :on_undefined_variable,\n :infer_signatures,\n :no_warn_undefined,\n :module_definition\n ]\n\n @doc \"\"\"\n Lists all required files.\n\n ## Examples\n\n Code.require_file(\"../eex/test/eex_test.exs\")\n List.first(Code.required_files()) =~ \"eex_test.exs\"\n #=> true\n\n \"\"\"\n @doc since: \"1.7.0\"\n @spec required_files() :: [binary]\n def required_files do\n :elixir_code_server.call(:required)\n end\n\n @deprecated \"Use Code.required_files/0 instead\"\n @doc false\n def loaded_files do\n required_files()\n end\n\n @doc false\n @deprecated \"Use Code.Fragment.cursor_context/2 instead\"\n def cursor_context(code, options \\\\ []) do\n Code.Fragment.cursor_context(code, options)\n end\n\n @doc \"\"\"\n Removes files from the required files list.\n\n The modules defined in the file are not removed;\n calling this function only removes them from the list,\n allowing them to be required again.\n\n The list of files is managed per Erlang VM node.\n\n ## Examples\n\n # Require EEx test code\n Code.require_file(\"../eex/test/eex_test.exs\")\n\n # Now unrequire all files\n Code.unrequire_files(Code.required_files())\n\n # Note that modules are still available\n function_exported?(EExTest.Compiled, :before_compile, 0)\n #=> true\n\n \"\"\"\n @doc since: \"1.7.0\"\n @spec unrequire_files([binary]) :: :ok\n def unrequire_files(files) when is_list(files) do\n :elixir_code_server.cast({:unrequire_files, files})\n end\n\n @deprecated \"Use Code.unrequire_files/1 instead\"\n @doc false\n def unload_files(files) do\n unrequire_files(files)\n end\n\n @doc \"\"\"\n Appends a path to the Erlang VM code path list.\n\n This is the list of directories the Erlang VM uses for\n finding module code. The list of files is managed per Erlang\n VM node.\n\n The path is expanded with `Path.expand/1` before being appended.\n It requires the path to exist. Returns a boolean indicating if\n the path was successfully added.\n\n ## Examples\n\n Code.append_path(\".\")\n #=> true\n\n Code.append_path(\"/does_not_exist\")\n #=> false\n\n ## Options\n\n * `:cache` - (since v1.15.0) when true, the code path is cached\n the first time it is traversed in order to reduce file system\n operations.\n\n \"\"\"\n @spec append_path(Path.t(), cache: boolean()) :: true | false\n def append_path(path, opts \\\\ []) do\n apply(:code, :add_pathz, [to_charlist(Path.expand(path)) | cache(opts)]) == true\n end\n\n @doc \"\"\"\n Prepends a path to the Erlang VM code path list.\n\n This is the list of directories the Erlang VM uses for\n finding module code. The list of files is managed per Erlang\n VM node.\n\n The path is expanded with `Path.expand/1` before being prepended.\n It requires the path to exist. Returns a boolean indicating if\n the path was successfully added.\n\n ## Examples\n\n Code.prepend_path(\".\")\n #=> true\n\n Code.prepend_path(\"/does_not_exist\")\n #=> false\n\n ## Options\n\n * `:cache` - (since v1.15.0) when true, the code path is cached\n the first time it is traversed in order to reduce file system\n operations.\n\n \"\"\"\n @spec prepend_path(Path.t(), cache: boolean()) :: boolean()\n def prepend_path(path, opts \\\\ []) do\n apply(:code, :add_patha, [to_charlist(Path.expand(path)) | cache(opts)]) == true\n end\n\n @doc \"\"\"\n Prepends a list of `paths` to the Erlang VM code path list.\n\n This is the list of directories the Erlang VM uses for\n finding module code. The list of files is managed per Erlang\n VM node.\n\n All paths are expanded with `Path.expand/1` before being prepended.\n Only existing paths are prepended. This function always returns `:ok`,\n regardless of how many paths were prepended. Use `prepend_path/1`\n if you need more control.\n\n ## Examples\n\n Code.prepend_paths([\".\", \"/does_not_exist\"])\n #=> :ok\n\n ## Options\n\n * `:cache` - when true, the code path is cached the first time\n it is traversed in order to reduce file system operations.\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec prepend_paths([Path.t()], cache: boolean()) :: :ok\n def prepend_paths(paths, opts \\\\ []) when is_list(paths) do\n apply(:code, :add_pathsa, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)])\n end\n\n @doc \"\"\"\n Appends a list of `paths` to the Erlang VM code path list.\n\n This is the list of directories the Erlang VM uses for\n finding module code. The list of files is managed per Erlang\n VM node.\n\n All paths are expanded with `Path.expand/1` before being appended.\n Only existing paths are appended. This function always returns `:ok`,\n regardless of how many paths were appended. Use `append_path/1`\n if you need more control.\n\n ## Examples\n\n Code.append_paths([\".\", \"/does_not_exist\"])\n #=> :ok\n\n ## Options\n\n * `:cache` - when true, the code path is cached the first time\n it is traversed in order to reduce file system operations.\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec append_paths([Path.t()], cache: boolean()) :: :ok\n def append_paths(paths, opts \\\\ []) when is_list(paths) do\n apply(:code, :add_pathsz, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)])\n end\n\n defp cache(opts) do\n if function_exported?(:code, :add_path, 2) do\n if opts[:cache], do: [:cache], else: [:nocache]\n else\n []\n end\n end\n\n @doc \"\"\"\n Deletes a path from the Erlang VM code path list.\n\n This is the list of directories the Erlang VM uses for finding\n module code. The list of files is managed per Erlang VM node.\n\n The path is expanded with `Path.expand/1` before being deleted. If the\n path does not exist, this function returns `false`.\n\n ## Examples\n\n Code.prepend_path(\".\")\n Code.delete_path(\".\")\n #=> true\n\n Code.delete_path(\"/does_not_exist\")\n #=> false\n\n \"\"\"\n @spec delete_path(Path.t()) :: boolean\n def delete_path(path) do\n case :code.del_path(to_charlist(Path.expand(path))) do\n result when is_boolean(result) ->\n result\n\n {:error, :bad_name} ->\n raise ArgumentError,\n \"invalid argument #{inspect(path)}\"\n end\n end\n\n @doc \"\"\"\n Deletes a list of paths from the Erlang VM code path list.\n\n This is the list of directories the Erlang VM uses for finding\n module code. The list of files is managed per Erlang VM node.\n\n The path is expanded with `Path.expand/1` before being deleted. If the\n path does not exist, this function returns `false`.\n \"\"\"\n @doc since: \"1.15.0\"\n @spec delete_paths([Path.t()]) :: :ok\n def delete_paths(paths) when is_list(paths) do\n for path <- paths do\n _ = :code.del_path(to_charlist(Path.expand(path)))\n end\n\n :ok\n end\n\n @doc \"\"\"\n Evaluates the contents given by `string`.\n\n The `binding` argument is a list of all variables and their values.\n The `opts` argument is a keyword list of environment options.\n\n **Warning**: `string` can be any Elixir code and will be executed with\n the same privileges as the Erlang VM: this means that such code could\n compromise the machine (for example by executing system commands).\n Don't use `eval_string/3` with untrusted input (such as strings coming\n from the network).\n\n ## Options\n\n It accepts the same options as both `env_for_eval/1` and\n `eval_quoted_with_env/4`. Additionally, you may also pass an environment\n as third argument, so the evaluation happens within that environment.\n\n ## Return\n\n Returns a tuple of the form `{value, binding}`, where `value` is the value\n returned from evaluating `string`. If an error occurs while evaluating\n `string`, an exception will be raised.\n\n `binding` is a list with all variable names and their values after evaluating\n `string`. The binding keys are usually atoms, but they may be a tuple for variables\n defined in a different context. The names are in no particular order.\n\n ## Examples\n\n iex> {result, binding} = Code.eval_string(\"a + b\", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)\n iex> result\n 3\n iex> Enum.sort(binding)\n [a: 1, b: 2]\n\n iex> {result, binding} = Code.eval_string(\"c = a + b\", [a: 1, b: 2], __ENV__)\n iex> result\n 3\n iex> Enum.sort(binding)\n [a: 1, b: 2, c: 3]\n\n iex> {result, binding} = Code.eval_string(\"a = a + b\", [a: 1, b: 2])\n iex> result\n 3\n iex> Enum.sort(binding)\n [a: 3, b: 2]\n\n For convenience, you can pass `__ENV__/0` as the `opts_or_env` argument and\n all imports, requires and aliases defined in the current environment\n will be automatically carried over:\n\n iex> require Integer, warn: false\n iex> {result, binding} = Code.eval_string(\"if Integer.is_odd(a), do: a + b\", [a: 1, b: 2], __ENV__)\n iex> result\n 3\n iex> Enum.sort(binding)\n [a: 1, b: 2]\n\n \"\"\"\n @spec eval_string(List.Chars.t(), binding, Macro.Env.t() | [eval_opt | env_eval_opt]) ::\n {term, binding}\n def eval_string(string, binding \\\\ [], opts_or_env \\\\ [])\n\n def eval_string(string, binding, %Macro.Env{} = env) do\n validated_eval_string(string, validate_binding(binding), env_for_eval(env), [])\n end\n\n def eval_string(string, binding, opts) when is_list(opts) do\n validated_eval_string(string, validate_binding(binding), env_for_eval(opts), opts)\n end\n\n defp validate_binding(binding) when is_list(binding), do: binding\n\n defp validate_binding(binding) do\n raise ArgumentError, \"binding must be a list, got: #{inspect(binding)}\"\n end\n\n defp validated_eval_string(string, binding, env, opts) do\n %{line: line, file: file} = env\n forms = :elixir.string_to_quoted!(to_charlist(string), line, 1, file, [])\n {value, binding, _env} = eval_verify(:eval_forms, [forms, binding, env, opts])\n {value, binding}\n end\n\n defp eval_verify(fun, args) do\n Module.ParallelChecker.verify(fn ->\n apply(:elixir, fun, args)\n end)\n end\n\n @doc \"\"\"\n Executes the given `fun` and capture all diagnostics.\n\n Diagnostics are warnings and errors emitted during code\n evaluation or single-file compilation and by functions\n such as `IO.warn/2`.\n\n If using `mix compile` or `Kernel.ParallelCompiler`,\n note they already capture and return diagnostics.\n\n ## Options\n\n * `:log` - if the diagnostics should be logged as they happen.\n Defaults to `false`.\n\n > #### Rescuing errors {: .info}\n >\n > `with_diagnostics/2` does not automatically handle exceptions.\n > You may capture them by adding a `try/1` in `fun`:\n >\n > {result, all_errors_and_warnings} =\n > Code.with_diagnostics(fn ->\n > try do\n > {:ok, Code.compile_quoted(quoted)}\n > rescue\n > err -> {:error, err}\n > end\n > end)\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec with_diagnostics([log: boolean()], (-> result)) ::\n {result, [diagnostic(:warning | :error)]}\n when result: term()\n def with_diagnostics(opts \\\\ [], fun) do\n value = :erlang.get(:elixir_code_diagnostics)\n log = Keyword.get(opts, :log, false)\n :erlang.put(:elixir_code_diagnostics, {[], log})\n\n try do\n result = fun.()\n {diagnostics, _log?} = :erlang.get(:elixir_code_diagnostics)\n {result, Enum.reverse(diagnostics)}\n after\n if value == :undefined do\n :erlang.erase(:elixir_code_diagnostics)\n else\n :erlang.put(:elixir_code_diagnostics, value)\n end\n end\n end\n\n @doc \"\"\"\n Prints a diagnostic into the standard error.\n\n A diagnostic is either returned by `Kernel.ParallelCompiler`\n or by `Code.with_diagnostics/2`.\n\n ## Options\n\n * `:snippet` - whether to read the code snippet in the diagnostic location.\n As it may impact performance, it is not recommended to be used in runtime.\n Defaults to `true`.\n \"\"\"\n @doc since: \"1.15.0\"\n @spec print_diagnostic(diagnostic(:warning | :error), snippet: boolean()) :: :ok\n def print_diagnostic(diagnostic, opts \\\\ []) do\n read_snippet? = Keyword.get(opts, :snippet, true)\n :elixir_errors.print_diagnostic(diagnostic, read_snippet?)\n :ok\n end\n\n @doc ~S\"\"\"\n Formats the given code `string`.\n\n The formatter receives a string representing Elixir code and\n returns iodata representing the formatted code according to\n pre-defined rules.\n\n ## Options\n\n Regular options (do not change the AST):\n\n * `:file` - the file which contains the string, used for error\n reporting\n\n * `:line` - the line the string starts, used for error reporting\n\n * `:line_length` - the line length to aim for when formatting\n the document. Defaults to `98`. This value indicates when an expression\n should be broken over multiple lines but it is not guaranteed\n to do so. See the \"Line length\" section below for more information\n\n * `:locals_without_parens` - a keyword list of name and arity\n pairs that should be kept without parens whenever possible.\n The arity may be the atom `:*`, which implies all arities of\n that name. The formatter already includes a list of functions\n and this option augments this list.\n\n * `:force_do_end_blocks` (since v1.9.0) - when `true`, converts all\n inline usages of `do: ...`, `else: ...` and friends into `do`-`end`\n blocks. Defaults to `false`. Note that this option is convergent:\n once you set it to `true`, **all keywords** will be converted.\n If you set it to `false` later on, `do`-`end` blocks won't be\n converted back to keywords.\n\n Migration options (change the AST), see the \"Migration formatting\" section below:\n\n * `:migrate` (since v1.18.0) - when `true`, sets all other migration options\n to `true` by default. Defaults to `false`.\n\n * `:migrate_bitstring_modifiers` (since v1.18.0) - when `true`,\n removes unnecessary parentheses in known bitstring\n [modifiers](`<<>>/1`), for example `<>`\n becomes `<>`, or adds parentheses for custom\n modifiers, where `<>` becomes `<>`.\n Defaults to the value of the `:migrate` option. This option changes the AST.\n\n * `:migrate_call_parens_on_pipe` (since v1.19.0) - when `true`,\n formats calls on the right-hand side of the pipe operator to always include\n parentheses, for example `foo |> bar` becomes `foo |> bar()` and\n `foo |> mod.fun` becomes `foo |> mod.fun()`.\n Parentheses are always added for qualified calls like `foo |> Bar.bar` even\n when this option is `false`.\n Defaults to the value of the `:migrate` option. This option changes the AST.\n\n * `:migrate_charlists_as_sigils` (since v1.18.0) - when `true`,\n formats charlists as [`~c`](`Kernel.sigil_c/2`) sigils, for example\n `'foo'` becomes `~c\"foo\"`.\n Defaults to the value of the `:migrate` option. This option changes the AST.\n\n * `:migrate_unless` (since v1.18.0) - when `true`,\n rewrites `unless` expressions using `if` with a negated condition, for example\n `unless foo, do:` becomes `if !foo, do:`.\n Defaults to the value of the `:migrate` option. This option changes the AST.\n\n ## Design principles\n\n The formatter was designed under three principles.\n\n First, the formatter never changes the semantics of the code by default.\n This means the input AST and the output AST are almost always equivalent.\n\n The second principle is to provide as little configuration as possible.\n This eases the formatter adoption by removing contention points while\n making sure a single style is followed consistently by the community as\n a whole.\n\n The formatter does not hard code names. The formatter will not behave\n specially because a function is named `defmodule`, `def`, or the like. This\n principle mirrors Elixir's goal of being an extensible language where\n developers can extend the language with new constructs as if they were\n part of the language. When it is absolutely necessary to change behavior\n based on the name, this behavior should be configurable, such as the\n `:locals_without_parens` option.\n\n ## Running the formatter\n\n The formatter attempts to fit the most it can on a single line and\n introduces line breaks wherever possible when it cannot.\n\n In some cases, this may lead to undesired formatting. Therefore, **some\n code generated by the formatter may not be aesthetically pleasing and\n may require explicit intervention from the developer**. That's why we\n do not recommend to run the formatter blindly in an existing codebase.\n Instead you should format and sanity check each formatted file.\n\n For example, the formatter may break a long function definition over\n multiple clauses:\n\n def my_function(\n %User{name: name, age: age, ...},\n arg1,\n arg2\n ) do\n ...\n end\n\n While the code above is completely valid, you may prefer to match on\n the struct variables inside the function body in order to keep the\n definition on a single line:\n\n def my_function(%User{} = user, arg1, arg2) do\n %{name: name, age: age, ...} = user\n ...\n end\n\n In some situations, you can use the fact the formatter does not generate\n elegant code as a hint for refactoring. Take this code:\n\n def board?(board_id, %User{} = user, available_permissions, required_permissions) do\n Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and\n required_permissions == Enum.to_list(MapSet.intersection(MapSet.new(required_permissions), MapSet.new(available_permissions)))\n end\n\n The code above has very long lines and running the formatter is not going\n to address this issue. In fact, the formatter may make it more obvious that\n you have complex expressions:\n\n def board?(board_id, %User{} = user, available_permissions, required_permissions) do\n Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and\n required_permissions ==\n Enum.to_list(\n MapSet.intersection(\n MapSet.new(required_permissions),\n MapSet.new(available_permissions)\n )\n )\n end\n\n Take such cases as a suggestion that your code should be refactored:\n\n def board?(board_id, %User{} = user, available_permissions, required_permissions) do\n Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and\n matching_permissions?(required_permissions, available_permissions)\n end\n\n defp matching_permissions?(required_permissions, available_permissions) do\n intersection =\n required_permissions\n |> MapSet.new()\n |> MapSet.intersection(MapSet.new(available_permissions))\n |> Enum.to_list()\n\n required_permissions == intersection\n end\n\n To sum it up: since the formatter cannot change the semantics of your\n code, sometimes it is necessary to tweak or refactor the code to get\n optimal formatting. To help better understand how to control the formatter,\n we describe in the next sections the cases where the formatter keeps the\n user encoding and how to control multiline expressions.\n\n ## Line length\n\n Another point about the formatter is that the `:line_length` configuration\n indicates when an expression should be broken over multiple lines but it is\n not guaranteed to do so. In many cases, it is not possible for the formatter\n to break your code apart, which means it will go over the line length.\n For example, if you have a long string:\n\n \"this is a very long string that will go over the line length\"\n\n The formatter doesn't know how to break it apart without changing the\n code underlying syntax representation, so it is up to you to step in:\n\n \"this is a very long string \" <>\n \"that will go over the line length\"\n\n The string concatenation makes the code fit on a single line and also\n gives more options to the formatter.\n\n This may also appear in keywords such as do/end blocks and operators,\n where the `do` keyword may go over the line length because there is no\n opportunity for the formatter to introduce a line break in a readable way.\n For example, if you do:\n\n case very_long_expression() do\n end\n\n And only the `do` keyword is beyond the line length, Elixir **will not**\n emit this:\n\n case very_long_expression()\n do\n end\n\n So it prefers to not touch the line at all and leave `do` above the\n line limit.\n\n ## Keeping user's formatting\n\n The formatter respects the input format in some cases. Those are\n listed below:\n\n * Insignificant digits in numbers are kept as is. The formatter,\n however, always inserts underscores for decimal numbers with more\n than 5 digits and converts hexadecimal digits to uppercase\n\n * Strings, charlists, atoms and sigils are kept as is. No character\n is automatically escaped or unescaped. The choice of delimiter is\n also respected from the input\n\n * Newlines inside blocks are kept as in the input except for:\n 1) expressions that take multiple lines will always have an empty\n line before and after and 2) empty lines are always squeezed\n together into a single empty line\n\n * The choice between `:do` keyword and `do`-`end` blocks is left\n to the user\n\n * Lists, tuples, bitstrings, maps, structs and function calls will be\n broken into multiple lines if they are followed by a newline in the\n opening bracket and preceded by a new line in the closing bracket\n\n * Newlines before certain operators (such as the pipeline operators)\n and before other operators (such as comparison operators)\n\n The behaviors above are not guaranteed. We may remove or add new\n rules in the future. The goal of documenting them is to provide better\n understanding on what to expect from the formatter.\n\n ### Multi-line lists, maps, tuples, and the like\n\n You can force lists, tuples, bitstrings, maps, structs and function\n calls to have one entry per line by adding a newline after the opening\n bracket and a new line before the closing bracket lines. For example:\n\n [\n foo,\n bar\n ]\n\n If there are no newlines around the brackets, then the formatter will\n try to fit everything on a single line, such that the snippet below\n\n [foo,\n bar]\n\n will be formatted as\n\n [foo, bar]\n\n You can also force function calls and keywords to be rendered on multiple\n lines by having each entry on its own line:\n\n defstruct name: nil,\n age: 0\n\n The code above will be kept with one keyword entry per line by the\n formatter. To avoid that, just squash everything into a single line.\n\n ### Parens and no parens in function calls\n\n Elixir has two syntaxes for function calls. With parens and no parens.\n By default, Elixir will add parens to all calls except for:\n\n 1. calls that have `do`-`end` blocks\n 2. local calls without parens where the name and arity of the local\n call is also listed under `:locals_without_parens` (except for\n calls with arity 0, where the compiler always require parens)\n\n The choice of parens and no parens also affects indentation. When a\n function call with parens doesn't fit on the same line, the formatter\n introduces a newline around parens and indents the arguments with two\n spaces:\n\n some_call(\n arg1,\n arg2,\n arg3\n )\n\n On the other hand, function calls without parens are always indented\n by the function call length itself, like this:\n\n some_call arg1,\n arg2,\n arg3\n\n If the last argument is a data structure, such as maps and lists, and\n the beginning of the data structure fits on the same line as the function\n call, then no indentation happens, this allows code like this:\n\n Enum.reduce(some_collection, initial_value, fn element, acc ->\n # code\n end)\n\n some_function_without_parens %{\n foo: :bar,\n baz: :bat\n }\n\n ## Code comments\n\n The formatter handles code comments and guarantees a space is always added\n between the beginning of the comment (#) and the next character.\n\n The formatter also extracts all trailing comments to their previous line.\n For example, the code below\n\n hello #world\n\n will be rewritten to\n\n # world\n hello\n\n While the formatter attempts to preserve comments in most situations,\n that's not always possible, because code comments are handled apart from\n the code representation (AST). While the formatter can preserve code\n comments between expressions and function arguments, the formatter\n cannot currently preserve them around operators. For example, the following\n code:\n\n foo() ||\n # also check for bar\n bar()\n\n will move the code comments to before the operator usage:\n\n # also check for bar\n foo() ||\n bar()\n\n In some situations, code comments can be seen as ambiguous by the formatter.\n For example, the comment in the anonymous function below\n\n fn\n arg1 ->\n body1\n # comment\n\n arg2 ->\n body2\n end\n\n and in this one\n\n fn\n arg1 ->\n body1\n\n # comment\n arg2 ->\n body2\n end\n\n are considered equivalent (the nesting is discarded alongside most of\n user formatting). In such cases, the code formatter will always format to\n the latter.\n\n ## Newlines\n\n The formatter converts all newlines in code from `\\r\\n` to `\\n`.\n\n ## Migration formatting\n\n As part of the Elixir release cycle, deprecations are being introduced,\n emitting warnings which might require existing code to be changed.\n In order to reduce the burden on developers when upgrading Elixir to the\n next version, the formatter exposes some options, disabled by default,\n in order to automate this process.\n\n These options should address most of the typical use cases, but given they\n introduce changes to the AST, there is a non-zero risk for meta-programming\n heavy projects that relied on a specific AST, or projects that are\n re-defining functions from the `Kernel`. In such cases, migrations cannot\n be applied blindly and some extra changes might be needed in order to\n address the deprecation warnings.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec format_string!(binary, [format_opt]) :: iodata\n def format_string!(string, opts \\\\ []) when is_binary(string) and is_list(opts) do\n {line_length, opts} = Keyword.pop(opts, :line_length, 98)\n\n to_quoted_opts =\n [\n unescape: false,\n literal_encoder: &{:ok, {:__block__, &2, [&1]}},\n token_metadata: true,\n emit_warnings: false\n ] ++ opts\n\n {forms, comments} = string_to_quoted_with_comments!(string, to_quoted_opts)\n to_algebra_opts = [comments: comments] ++ opts\n doc = Code.Formatter.to_algebra(forms, to_algebra_opts)\n Inspect.Algebra.format(doc, line_length)\n end\n\n @doc \"\"\"\n Formats a file.\n\n See `format_string!/2` for more information on code formatting and\n available options.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec format_file!(binary, [format_opt]) :: iodata\n def format_file!(file, opts \\\\ []) when is_binary(file) and is_list(opts) do\n string = File.read!(file)\n formatted = format_string!(string, [file: file, line: 1] ++ opts)\n [formatted, ?\\n]\n end\n\n @doc \"\"\"\n Evaluates the quoted contents.\n\n **Warning**: Calling this function inside a macro is considered bad\n practice as it will attempt to evaluate runtime values at compile time.\n Macro arguments are typically transformed by unquoting them into the\n returned quoted expressions (instead of evaluated).\n\n See `eval_string/3` for a description of arguments and return types.\n It accepts the same options as both `env_for_eval/1` and\n `eval_quoted_with_env/4`.\n\n ## Examples\n\n iex> contents = quote(do: var!(a) + var!(b))\n iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)\n iex> result\n 3\n iex> Enum.sort(binding)\n [a: 1, b: 2]\n\n For convenience, you can pass `__ENV__/0` as the `opts` argument and\n all options will be automatically extracted from the current environment:\n\n iex> contents = quote(do: var!(a) + var!(b))\n iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)\n iex> result\n 3\n iex> Enum.sort(binding)\n [a: 1, b: 2]\n\n \"\"\"\n @spec eval_quoted(Macro.t(), binding, Macro.Env.t() | [eval_opt | env_eval_opt]) ::\n {term, binding}\n def eval_quoted(quoted, binding \\\\ [], env_or_opts \\\\ [])\n\n def eval_quoted(quoted, binding, %Macro.Env{} = env) do\n eval_quoted(quoted, validate_binding(binding), env_for_eval(env), [])\n end\n\n def eval_quoted(quoted, binding, opts) when is_list(opts) do\n eval_quoted(quoted, validate_binding(binding), env_for_eval(opts), opts)\n end\n\n defp eval_quoted(quoted, binding, env, opts) do\n {value, binding, _env} = eval_verify(:eval_quoted, [quoted, binding, env, opts])\n {value, binding}\n end\n\n @doc \"\"\"\n Returns an environment for evaluation.\n\n It accepts either a `Macro.Env`, that is then pruned and prepared,\n or a list of options. It returns an environment that is ready for\n evaluation.\n\n Most functions in this module will automatically prepare the given\n environment for evaluation, so you don't need to explicitly call\n this function, with the exception of `eval_quoted_with_env/3`,\n which was designed precisely to be called in a loop, to implement\n features such as interactive shells or anything else with multiple\n evaluations.\n\n ## Options\n\n If an env is not given, the options can be:\n\n * `:file` - the file to be considered in the evaluation\n\n * `:line` - the line on which the script starts\n\n * `:module` - the module to run the environment on\n\n \"\"\"\n @doc since: \"1.14.0\"\n @spec env_for_eval(Macro.Env.t() | [env_eval_opt]) :: Macro.Env.t()\n def env_for_eval(env_or_opts), do: :elixir.env_for_eval(env_or_opts)\n\n @doc \"\"\"\n Evaluates the given `quoted` contents with `binding` and `env`.\n\n This function is meant to be called in a loop, to implement features\n such as interactive shells or anything else with multiple evaluations.\n Therefore, the first time you call this function, you must compute\n the initial environment with `env_for_eval/1`. The remaining calls\n must pass the environment that was returned by this function.\n\n ## Options\n\n * `:prune_binding` - (since v1.14.2) prune binding to keep only\n variables read or written by the evaluated code. Note that\n variables used by modules are always pruned, even if later used\n by the modules. You can submit to the `:on_module` tracer event\n and access the variables used by the module from its environment.\n\n * `:dbg_callback` - (since v1.20.0) overrides the behaviour of `dbg/2`\n used in the evaluated code. It must be a `{module, function, args}`\n tuple, see `dbg/2` for more details.\n\n \"\"\"\n @doc since: \"1.14.0\"\n @spec eval_quoted_with_env(Macro.t(), binding, Macro.Env.t(), [eval_opt]) ::\n {term, binding, Macro.Env.t()}\n def eval_quoted_with_env(quoted, binding, %Macro.Env{} = env, opts \\\\ [])\n when is_list(binding) do\n eval_verify(:eval_quoted, [quoted, binding, env, opts])\n end\n\n @doc ~S\"\"\"\n Converts the given string to its quoted form.\n\n Returns `{:ok, quoted_form}` if it succeeds,\n `{:error, {meta, message_info, token}}` otherwise.\n\n ## Options\n\n * `:file` - the filename to be reported in case of parsing errors.\n Defaults to `\"nofile\"`.\n\n * `:line` - the starting line of the string being parsed.\n Defaults to `1`.\n\n * `:column` - (since v1.11.0) the starting column of the string being parsed.\n Defaults to `1`.\n\n * `:indentation` - (since v1.19.0) the indentation for the string being parsed.\n This is useful when the code parsed is embedded within another document.\n Defaults to `0`.\n\n * `:columns` - when `true`, attach a `:column` key to the quoted\n metadata. Defaults to `false`.\n\n * `:unescape` (since v1.10.0) - when `false`, preserves escaped sequences.\n For example, `\"null byte\\\\t\\\\x00\"` will be kept as is instead of being\n converted to a bitstring literal. Note if you set this option to false, the\n resulting AST is no longer valid, but it can be useful to analyze/transform\n source code, typically in combination with `quoted_to_algebra/2`.\n Defaults to `true`.\n\n * `:existing_atoms_only` - when `true`, raises an error\n when non-existing atoms are found by the tokenizer.\n Defaults to `false`.\n\n * `:token_metadata` (since v1.10.0) - when `true`, includes token-related\n metadata in the expression AST, such as metadata for `do` and `end`\n tokens, for closing tokens, end of expressions, as well as delimiters\n for sigils. See `t:Macro.metadata/0`. Defaults to `false`.\n\n * `:literal_encoder` (since v1.10.0) - how to encode literals in the AST.\n It must be a function that receives two arguments, the literal and its\n metadata, and it must return `{:ok, ast :: Macro.t}` or\n `{:error, reason :: binary}`. If you return anything than the literal\n itself as the `term`, then the AST is no longer valid. This option\n may still useful for textual analysis of the source code.\n\n * `:static_atoms_encoder` - the static atom encoder function, see\n \"The `:static_atoms_encoder` function\" section below. Note this\n option overrides the `:existing_atoms_only` behavior for static\n atoms but `:existing_atoms_only` is still used for dynamic atoms,\n such as atoms with interpolations.\n\n * `:emit_warnings` (since v1.16.0) - when `false`, does not emit\n tokenizing/parsing related warnings. Defaults to `true`.\n\n ## `Macro.to_string/2`\n\n The opposite of converting a string to its quoted form is\n `Macro.to_string/2`, which converts a quoted form to a string/binary\n representation.\n\n ## The `:static_atoms_encoder` function\n\n When `static_atoms_encoder: &my_encoder/2` is passed as an argument,\n `my_encoder/2` is called every time the tokenizer needs to create a\n \"static\" atom. Static atoms are atoms in the AST that function as\n aliases, remote calls, local calls, variable names, regular atoms\n and keyword lists.\n\n The encoder function will receive the atom name (as a binary) and a\n keyword list with the current file, line and column. It must return\n `{:ok, token :: term} | {:error, reason :: binary}`.\n\n The encoder function is supposed to create an atom from the given\n string. To produce a valid AST, it is required to return `{:ok, term}`,\n where `term` is an atom. It is possible to return something other than an atom,\n however, in that case the AST is no longer \"valid\" in that it cannot\n be used to compile or evaluate Elixir code. A use case for this is\n if you want to use the Elixir parser in a user-facing situation, but\n you don't want to exhaust the atom table.\n\n The atom encoder is not called for *all* atoms that are present in\n the AST. It won't be invoked for the following atoms:\n\n * operators (`:+`, `:-`, and so on)\n\n * syntax keywords (`fn`, `do`, `else`, and so on)\n\n * atoms containing interpolation (`:\"#{1 + 1} is two\"`), as these\n atoms are constructed at runtime\n\n * atoms used to represent single-letter sigils like `:sigil_X`\n (but multi-letter sigils like `:sigil_XYZ` are encoded).\n\n ## Examples\n\n iex> Code.string_to_quoted(\"1 + 3\")\n {:ok, {:+, [line: 1], [1, 3]}}\n\n iex> Code.string_to_quoted(\"1 \\ 3\")\n {:error, {[line: 1, column: 4], \"syntax error before: \", \"\\\"3\\\"\"}}\n\n \"\"\"\n @spec string_to_quoted(List.Chars.t(), parser_opts) ::\n {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}}\n def string_to_quoted(string, opts \\\\ []) when is_list(opts) do\n file = Keyword.get(opts, :file, \"nofile\")\n line = Keyword.get(opts, :line, 1)\n column = Keyword.get(opts, :column, 1)\n :elixir.string_to_quoted(to_charlist(string), line, column, file, opts)\n end\n\n @doc \"\"\"\n Converts the given string to its quoted form.\n\n It returns the AST if it succeeds,\n raises an exception otherwise. The exception is a `TokenMissingError`\n in case a token is missing (usually because the expression is incomplete),\n `MismatchedDelimiterError` (in case of mismatched opening and closing delimiters) and\n `SyntaxError` otherwise.\n\n Check `string_to_quoted/2` for options information.\n \"\"\"\n @spec string_to_quoted!(List.Chars.t(), parser_opts) :: Macro.t()\n def string_to_quoted!(string, opts \\\\ []) when is_list(opts) do\n file = Keyword.get(opts, :file, \"nofile\")\n line = Keyword.get(opts, :line, 1)\n column = Keyword.get(opts, :column, 1)\n :elixir.string_to_quoted!(to_charlist(string), line, column, file, opts)\n end\n\n @doc \"\"\"\n Converts the given string to its quoted form and a list of comments.\n\n This function is useful when performing textual changes to the source code,\n while preserving information like comments and literals position.\n\n Returns `{:ok, quoted_form, comments}` if it succeeds,\n `{:error, {line, error, token}}` otherwise.\n\n Comments are maps with the following fields:\n\n * `:line` - The line number of the source code\n\n * `:text` - The full text of the comment, including the leading `#`\n\n * `:previous_eol_count` - How many end of lines there are between the comment and the previous AST node or comment\n\n * `:next_eol_count` - How many end of lines there are between the comment and the next AST node or comment\n\n Check `string_to_quoted/2` for options information.\n\n ## Examples\n\n iex> Code.string_to_quoted_with_comments(\"\\\"\"\n ...> :foo\n ...>\n ...> # Hello, world!\n ...>\n ...>\n ...> # Some more comments!\n ...> \"\\\"\")\n {:ok, :foo, [\n %{line: 3, column: 1, previous_eol_count: 2, next_eol_count: 3, text: \"\\# Hello, world!\"},\n %{line: 6, column: 1, previous_eol_count: 3, next_eol_count: 1, text: \"\\# Some more comments!\"},\n ]}\n\n iex> Code.string_to_quoted_with_comments(\":foo # :bar\")\n {:ok, :foo, [\n %{line: 1, column: 6, previous_eol_count: 0, next_eol_count: 0, text: \"\\# :bar\"}\n ]}\n\n \"\"\"\n @doc since: \"1.13.0\"\n @spec string_to_quoted_with_comments(List.Chars.t(), parser_opts) ::\n {:ok, Macro.t(), list(map())} | {:error, {location :: keyword, term, term}}\n def string_to_quoted_with_comments(string, opts \\\\ []) when is_list(opts) do\n charlist = to_charlist(string)\n file = Keyword.get(opts, :file, \"nofile\")\n line = Keyword.get(opts, :line, 1)\n column = Keyword.get(opts, :column, 1)\n\n Process.put(:code_formatter_comments, [])\n opts = [preserve_comments: &preserve_comments/5] ++ opts\n\n with {:ok, forms} <- :elixir.string_to_quoted(charlist, line, column, file, opts) do\n comments = Enum.reverse(Process.get(:code_formatter_comments))\n {:ok, forms, comments}\n end\n after\n Process.delete(:code_formatter_comments)\n end\n\n @doc \"\"\"\n Converts the given string to its quoted form and a list of comments.\n\n Returns the AST and a list of comments if it succeeds, raises an exception\n otherwise. The exception is a `TokenMissingError` in case a token is missing\n (usually because the expression is incomplete), `SyntaxError` otherwise.\n\n Check `string_to_quoted/2` for options information.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec string_to_quoted_with_comments!(List.Chars.t(), parser_opts) :: {Macro.t(), list(map())}\n def string_to_quoted_with_comments!(string, opts \\\\ []) do\n charlist = to_charlist(string)\n\n case string_to_quoted_with_comments(charlist, opts) do\n {:ok, forms, comments} ->\n {forms, comments}\n\n {:error, {location, error, token}} ->\n file = Keyword.get(opts, :file, \"nofile\")\n line = Keyword.get(opts, :line, 1)\n column = Keyword.get(opts, :column, 1)\n input = {charlist, line, column, Keyword.get(opts, :indentation, 0)}\n :elixir_errors.parse_error(location, file, error, token, input)\n end\n end\n\n defp preserve_comments(line, column, tokens, comment, rest) do\n comments = Process.get(:code_formatter_comments)\n\n comment = %{\n line: line,\n column: column,\n previous_eol_count: min(previous_eol_count(tokens), last_comment_distance(comments, line)),\n next_eol_count: next_eol_count(rest, 0),\n text: List.to_string(comment)\n }\n\n Process.put(:code_formatter_comments, [comment | comments])\n end\n\n defp next_eol_count([?\\s | rest], count), do: next_eol_count(rest, count)\n defp next_eol_count([?\\t | rest], count), do: next_eol_count(rest, count)\n defp next_eol_count([?\\n | rest], count), do: next_eol_count(rest, count + 1)\n defp next_eol_count([?\\r, ?\\n | rest], count), do: next_eol_count(rest, count + 1)\n defp next_eol_count(_, count), do: count\n\n defp last_comment_distance([%{line: last_line} | _], line), do: line - last_line\n defp last_comment_distance([], _line), do: :infinity\n\n defp previous_eol_count([{token, {_, _, count}} | _])\n when token in [:eol, :\",\", :\";\"] and count > 0 do\n count\n end\n\n defp previous_eol_count([]), do: 1\n defp previous_eol_count(_), do: 0\n\n @doc ~S\"\"\"\n Converts a quoted expression to an algebra document using Elixir's formatter rules.\n\n The algebra document can be converted into a string by calling:\n\n doc\n |> Inspect.Algebra.format(:infinity)\n |> IO.iodata_to_binary()\n\n For a high-level function that does the same, see `Macro.to_string/1`.\n\n ## Formatting considerations\n\n The Elixir AST does not contain metadata for literals like strings, lists, or\n tuples with two elements, which means that the produced algebra document will\n not respect all of the user preferences and comments may be misplaced.\n To get better results, you can use the `:token_metadata`, `:unescape` and\n `:literal_encoder` options to `string_to_quoted/2` to provide additional\n information to the formatter:\n\n [\n literal_encoder: &{:ok, {:__block__, &2, [&1]}},\n token_metadata: true,\n unescape: false\n ]\n\n This will produce an AST that contains information such as `do` blocks start\n and end lines or sigil delimiters, and by wrapping literals in blocks they can\n now hold metadata like line number, string delimiter and escaped sequences, or\n integer formatting (such as `0x2a` instead of `47`). However, **note this AST is\n not valid**. If you evaluate it, it won't have the same semantics as the regular\n Elixir AST due to the `:unescape` and `:literal_encoder` options. However,\n those options are useful if you're doing source code manipulation, where it's\n important to preserve user choices and comments placing.\n\n ## Options\n\n This function accepts all options supported by `format_string!/2` for controlling\n code formatting, plus these additional options:\n\n * `:comments` - the list of comments associated with the quoted expression.\n Defaults to `[]`. It is recommended that both `:token_metadata` and\n `:literal_encoder` options are given to `string_to_quoted_with_comments/2`\n in order to get proper placement for comments\n\n * `:escape` - when `true`, escaped sequences like `\\n` will be escaped into\n `\\\\n`. If the `:unescape` option was set to `false` when using\n `string_to_quoted/2`, setting this option to `false` will prevent it from\n escaping the sequences twice. Defaults to `true`.\n\n See `format_string!/2` for the full list of formatting options including\n `:file`, `:line`, `:line_length`, `:locals_without_parens`, `:force_do_end_blocks`,\n `:syntax_colors`, and all migration options like `:migrate_charlists_as_sigils`.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec quoted_to_algebra(Macro.t(), [format_opt() | quoted_to_algebra_opt()]) ::\n Inspect.Algebra.t()\n def quoted_to_algebra(quoted, opts \\\\ []) do\n quoted\n |> Code.Normalizer.normalize(opts)\n |> Code.Formatter.to_algebra(opts)\n end\n\n @doc \"\"\"\n Evaluates the given file.\n\n Accepts `relative_to` as an argument to tell where the file is located.\n\n While `require_file/2` and `compile_file/2` return the loaded modules and their\n bytecode, `eval_file/2` simply evaluates the file contents and returns the\n evaluation result and its binding (exactly the same return value as `eval_string/3`).\n \"\"\"\n @spec eval_file(binary, nil | binary) :: {term, binding}\n def eval_file(file, relative_to \\\\ nil) when is_binary(file) do\n {charlist, file} = find_file!(file, relative_to)\n eval_string(charlist, [], file: file, line: 1)\n end\n\n @deprecated \"Use Code.require_file/2 or Code.compile_file/2 instead\"\n @doc false\n def load_file(file, relative_to \\\\ nil) when is_binary(file) do\n {charlist, file} = find_file!(file, relative_to)\n :elixir_code_server.call({:acquire, file})\n\n loaded =\n Module.ParallelChecker.verify(fn ->\n :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)\n end)\n\n :elixir_code_server.cast({:required, file})\n loaded\n end\n\n @doc \"\"\"\n Requires the given `file`.\n\n Accepts `relative_to` as an argument to tell where the file is located.\n If the file was already required, `require_file/2` doesn't do anything and\n returns `nil`.\n\n Note that if `require_file/2` is invoked by different processes concurrently,\n the first process to invoke `require_file/2` acquires a lock and the remaining\n ones will block until the file is available. This means that if `require_file/2`\n is called more than once with a given file, that file will be compiled only once.\n The first process to call `require_file/2` will get the list of loaded modules,\n others will get `nil`. The list of required files is managed per Erlang VM node.\n\n See `compile_file/2` if you would like to compile a file without tracking its\n filenames. Finally, if you would like to get the result of evaluating a file rather\n than the modules defined in it, see `eval_file/2`.\n\n ## Examples\n\n If the file has not been required, it returns the list of modules:\n\n modules = Code.require_file(\"eex_test.exs\", \"../eex/test\")\n List.first(modules)\n #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}\n\n If the file has been required, it returns `nil`:\n\n Code.require_file(\"eex_test.exs\", \"../eex/test\")\n #=> nil\n\n \"\"\"\n @spec require_file(binary, nil | binary) :: [{module, binary}] | nil\n def require_file(file, relative_to \\\\ nil) when is_binary(file) do\n {charlist, file} = find_file!(file, relative_to)\n\n case :elixir_code_server.call({:acquire, file}) do\n :required ->\n nil\n\n :proceed ->\n loaded =\n Module.ParallelChecker.verify(fn ->\n :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)\n end)\n\n :elixir_code_server.cast({:required, file})\n loaded\n end\n end\n\n @doc \"\"\"\n Gets all compilation options from the code server.\n\n To get individual options, see `get_compiler_option/1`.\n For a description of all options, see `put_compiler_option/2`.\n\n ## Examples\n\n Code.compiler_options()\n #=> %{debug_info: true, docs: true, ...}\n\n \"\"\"\n @spec compiler_options :: map\n def compiler_options do\n for key <- @available_compiler_options, into: %{} do\n {key, :elixir_config.get(key)}\n end\n end\n\n @doc \"\"\"\n Stores all given compilation options.\n\n Changing the compilation options affect all processes\n running in a given Erlang VM node. To store individual\n options and for a description of all options, see\n `put_compiler_option/2`.\n\n Returns a map with previous values.\n\n ## Examples\n\n Code.compiler_options(infer_signatures: false)\n #=> %{infer_signatures: [:elixir]}\n\n \"\"\"\n @spec compiler_options(Enumerable.t({atom, term})) :: %{optional(atom) => term}\n def compiler_options(opts) do\n for {key, value} <- opts, into: %{} do\n previous = get_compiler_option(key)\n put_compiler_option(key, value)\n {key, previous}\n end\n end\n\n @doc \"\"\"\n Returns the value of a given compiler option.\n\n For a description of all options, see `put_compiler_option/2`.\n\n ## Examples\n\n Code.get_compiler_option(:debug_info)\n #=> true\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec get_compiler_option(atom) :: term\n def get_compiler_option(key) when key in @available_compiler_options do\n :elixir_config.get(key)\n end\n\n # TODO: Remove me in Elixir v2.0\n def get_compiler_option(:warnings_as_errors) do\n IO.warn(\":warnings_as_errors is deprecated as part of Code.get_compiler_option/1\")\n :ok\n end\n\n @doc \"\"\"\n Returns a list with all available compiler options.\n\n For a description of all options, see `put_compiler_option/2`.\n\n ## Examples\n\n Code.available_compiler_options()\n #=> [:docs, :debug_info, ...]\n\n \"\"\"\n @spec available_compiler_options() :: [atom]\n def available_compiler_options do\n @available_compiler_options\n end\n\n @doc \"\"\"\n Stores a compilation option.\n\n Changing the compilation options affect all processes running in a\n given Erlang VM node.\n\n Available options are:\n\n * `:debug_info` - when `true`, retains debug information in the compiled\n module. This option can also be overridden per module using the `@compile`\n directive. Defaults to `true`.\n\n This enables tooling to partially reconstruct the original source code,\n for instance, to perform static analysis of code. Therefore, disabling\n `:debug_info` is not recommended as it removes the ability of the\n Elixir compiler and other tools to provide feedback. If you want to\n remove the `:debug_info` while deploying, tools like `mix release`\n already do such by default.\n\n Other environments, such as `mix test`, automatically disables this\n via the `:test_elixirc_options` project configuration, as there is\n typically no need to store debug chunks for test files.\n\n * `:docs` - when `true`, retains documentation in the compiled module.\n Defaults to `true`.\n\n * `:ignore_already_consolidated` (since v1.10.0) - when `true`, does not warn\n when a protocol has already been consolidated and a new implementation is added.\n Defaults to `false`.\n\n * `:ignore_module_conflict` - when `true`, does not warn when a module has\n already been defined. Defaults to `false`.\n\n * `:infer_signatures` (since v1.18.0) - a list of applications of which modules\n should be using during type inference. When `false`, it disables module-local\n signature inference used when type checking remote calls to the compiled\n module. Type checking will be executed regardless of the value of this option.\n Defaults to `true`, which is equivalent to setting it to `[:elixir]` only.\n\n When setting this option, we recommend running `mix clean` so the modules can be\n recompiled with the new behaviour. `mix test` automatically disables this option\n via the `:test_elixirc_options` project configuration, as there is typically no\n need to infer signatures for test files.\n\n * `:module_definition` (since v1.20.0) - stores if the module definition should\n be `:compiled` (the default) or `:interpreted`. Note this does not affect the\n `.beam` file written to disk, only how the contents inside `defmodule` are\n executed. Using the `:interpreted` mode may offer better compilation times for\n large projects, especially on machines with high core count, however, it comes\n with some downsides:\n\n * Errors during compilation may have less precise stacktraces\n\n * Anonymous functions within `defmodule` can have only up to 20 arguments.\n If this is an issue, you can use maps or tuples to group the data.\n Note the functions themselves inside `defmodule`, such as the ones defined\n inside `def` and friends, can still have up to 255 arguments\n\n * `:no_warn_undefined` (since v1.10.0) - list of modules and `{Mod, fun, arity}`\n tuples that will not emit warnings that the module or function does not exist\n at compilation time. Pass atom `:all` to skip warning for all undefined\n functions. This can be useful when doing dynamic compilation. Defaults to `[]`.\n\n * `:on_undefined_variable` (since v1.15.0) - either `:raise` or `:warn`.\n When `:raise` (the default), undefined variables will trigger a compilation\n error. You may be set it to `:warn` if you want undefined variables to\n emit a warning and expand as to a local call to the zero-arity function\n of the same name (for example, `node` would be expanded as `node()`).\n This `:warn` behavior only exists for compatibility reasons when working\n with old dependencies, its usage is discouraged and it will be removed\n in future releases.\n\n * `:parser_options` (since v1.10.0) - a keyword list of options to be given\n to the parser when compiling files. It accepts the same options as\n `string_to_quoted/2` (except by the options that change the AST itself).\n This can be used in combination with the tracer to retrieve localized\n information about events happening during compilation. Defaults to `[columns: true]`.\n This option only affects code compilation functions, such as `compile_string/2`\n and `compile_file/2` but not `string_to_quoted/2` and friends, as the\n latter is used for other purposes beyond compilation.\n\n * `:relative_paths` - when `true`, uses relative paths in quoted nodes,\n warnings, and errors generated by the compiler. Note disabling this option\n won't affect runtime warnings and errors. Defaults to `true`.\n\n * `:tracers` (since v1.10.0) - a list of tracers (modules) to be used during\n compilation. See the module docs for more information. Defaults to `[]`.\n\n It always returns `:ok`. Raises an error for invalid options.\n\n ## Examples\n\n Code.put_compiler_option(:debug_info, true)\n #=> :ok\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec put_compiler_option(atom, term) :: :ok\n def put_compiler_option(key, value) when key in @boolean_compiler_options do\n if not is_boolean(value) do\n raise \"compiler option #{inspect(key)} should be a boolean, got: #{inspect(value)}\"\n end\n\n :elixir_config.put(key, value)\n :ok\n end\n\n def put_compiler_option(key, value) when key in @list_compiler_options do\n if not is_list(value) do\n raise \"compiler option #{inspect(key)} should be a list, got: #{inspect(value)}\"\n end\n\n if key == :parser_options and not Keyword.keyword?(value) do\n raise \"compiler option #{inspect(key)} should be a keyword list, \" <>\n \"got: #{inspect(value)}\"\n end\n\n if key == :tracers and not Enum.all?(value, &is_atom/1) do\n raise \"compiler option #{inspect(key)} should be a list of modules, \" <>\n \"got: #{inspect(value)}\"\n end\n\n :elixir_config.put(key, value)\n :ok\n end\n\n def put_compiler_option(:module_definition, value) do\n if value not in [:interpreted, :compiled] do\n raise \"compiler option :module_definition should be either :interpreted or :compiled, got: #{inspect(value)}\"\n end\n\n :elixir_config.put(:module_definition, value)\n :ok\n end\n\n def put_compiler_option(:infer_signatures, value) do\n value =\n cond do\n value == false ->\n false\n\n value == true ->\n [:elixir]\n\n is_list(value) and Enum.all?(value, &is_atom/1) ->\n value\n\n true ->\n raise \"compiler option :infer_signatures should be a boolean or a list of applications, got: #{inspect(value)}\"\n end\n\n :elixir_config.put(:infer_signatures, value)\n :ok\n end\n\n def put_compiler_option(:no_warn_undefined, value) do\n if value != :all and not is_list(value) do\n raise \"compiler option :no_warn_undefined should be a list or the atom :all, \" <>\n \"got: #{inspect(value)}\"\n end\n\n :elixir_config.put(:no_warn_undefined, value)\n :ok\n end\n\n # TODO: Remove me in Elixir v2.0\n def put_compiler_option(:warnings_as_errors, _value) do\n IO.warn(\n \":warnings_as_errors is deprecated as part of Code.put_compiler_option/2, \" <>\n \"instead you must pass it as a --warnings-as-errors flag. \" <>\n \"If you need to set it as a default in a mix task, you can also set it under aliases: \" <>\n \"[compile: \\\"compile --warnings-as-errors\\\"]\"\n )\n\n :ok\n end\n\n # TODO: Remove me in Elixir v2.0\n def put_compiler_option(:on_undefined_variable, value) when value in [:raise, :warn] do\n if value == :warn do\n IO.warn_once(\n {__MODULE__, :on_undefined_variable},\n fn ->\n \"setting :on_undefined_variable to :warn is deprecated. \" <>\n \"The warning behaviour will be removed in future releases\"\n end,\n 3\n )\n end\n\n :elixir_config.put(:on_undefined_variable, value)\n :ok\n end\n\n def put_compiler_option(key, _value) do\n raise \"unknown compiler option: #{inspect(key)}\"\n end\n\n @doc \"\"\"\n Purge compiler modules.\n\n The compiler utilizes temporary modules to compile code. For example,\n `elixir_compiler_1`, `elixir_compiler_2`, and so on. In case the compiled code\n stores references to anonymous functions or similar, the Elixir compiler\n may be unable to reclaim those modules, keeping an unnecessary amount of\n code in memory and eventually leading to modules such as `elixir_compiler_12345`.\n\n This function purges all modules currently kept by the compiler, allowing\n old compiler module names to be reused. If there are any processes running\n any code from such modules, they will be terminated too.\n\n This function is only meant to be called if you have a long running node\n that is constantly evaluating code.\n\n It returns `{:ok, number_of_modules_purged}`.\n \"\"\"\n @doc since: \"1.7.0\"\n @spec purge_compiler_modules() :: {:ok, non_neg_integer()}\n def purge_compiler_modules() do\n :elixir_code_server.call(:purge_compiler_modules)\n end\n\n @doc \"\"\"\n Compiles the given string.\n\n Returns a list of tuples where the first element is the module name\n and the second one is its bytecode (as a binary). A `file` can be\n given as a second argument which will be used for reporting warnings\n and errors.\n\n **Warning**: `string` can be any Elixir code and code can be executed with\n the same privileges as the Erlang VM: this means that such code could\n compromise the machine (for example by executing system commands).\n Don't use `compile_string/2` with untrusted input (such as strings coming\n from the network).\n \"\"\"\n @spec compile_string(List.Chars.t(), binary) :: [{module, binary}]\n def compile_string(string, file \\\\ \"nofile\") when is_binary(file) do\n Module.ParallelChecker.verify(fn ->\n :elixir_compiler.string(to_charlist(string), file, fn _, _ -> :ok end)\n end)\n end\n\n @doc \"\"\"\n Compiles the quoted expression.\n\n Returns a list of tuples where the first element is the module name and\n the second one is its bytecode (as a binary). A `file` can be\n given as second argument which will be used for reporting warnings\n and errors.\n \"\"\"\n @spec compile_quoted(Macro.t(), binary) :: [{module, binary}]\n def compile_quoted(quoted, file \\\\ \"nofile\") when is_binary(file) do\n Module.ParallelChecker.verify(fn ->\n :elixir_compiler.quoted(quoted, file, fn _, _ -> :ok end)\n end)\n end\n\n @doc \"\"\"\n Compiles the given file.\n\n Accepts `relative_to` as an argument to tell where the file is located.\n\n Returns a list of tuples where the first element is the module name and\n the second one is its bytecode (as a binary). Opposite to `require_file/2`,\n it does not track the filename of the compiled file.\n\n If you would like to get the result of evaluating file rather than the\n modules defined in it, see `eval_file/2`.\n\n For compiling many files concurrently, see `Kernel.ParallelCompiler.compile/2`.\n \"\"\"\n @doc since: \"1.7.0\"\n @spec compile_file(binary, nil | binary) :: [{module, binary}]\n def compile_file(file, relative_to \\\\ nil) when is_binary(file) do\n Module.ParallelChecker.verify(fn ->\n {charlist, file} = find_file!(file, relative_to)\n :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)\n end)\n end\n\n @doc \"\"\"\n Ensures the given module is loaded.\n\n If the module is already loaded, this works as no-op. If the module\n was not yet loaded, it tries to load it.\n\n If it succeeds in loading the module, it returns `{:module, module}`.\n If not, returns `{:error, reason}` with the error reason.\n\n See the module documentation for more information on code loading.\n\n ## Examples\n\n iex> Code.ensure_loaded(Atom)\n {:module, Atom}\n\n iex> Code.ensure_loaded(DoesNotExist)\n {:error, :nofile}\n\n \"\"\"\n @spec ensure_loaded(module) ::\n {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure}\n def ensure_loaded(module) when is_atom(module) do\n :code.ensure_loaded(module)\n end\n\n @doc \"\"\"\n Ensures the given module is loaded.\n\n Similar to `ensure_loaded/1`, but returns `true` if the module\n is already loaded or was successfully loaded. Returns `false`\n otherwise.\n\n ## Examples\n\n iex> Code.ensure_loaded?(String)\n true\n\n \"\"\"\n @spec ensure_loaded?(module) :: boolean\n def ensure_loaded?(module) when is_atom(module) do\n match?({:module, ^module}, ensure_loaded(module))\n end\n\n @doc \"\"\"\n Same as `ensure_loaded/1` but raises if the module cannot be loaded.\n \"\"\"\n @doc since: \"1.12.0\"\n @spec ensure_loaded!(module) :: module\n def ensure_loaded!(module) do\n case ensure_loaded(module) do\n {:module, module} ->\n module\n\n {:error, reason} ->\n raise ArgumentError,\n \"could not load module #{inspect(module)} due to reason #{inspect(reason)}\"\n end\n end\n\n @doc \"\"\"\n Ensures the given modules are loaded.\n\n Similar to `ensure_loaded/1`, but accepts a list of modules instead of a single\n module, and loads all of them.\n\n If all modules load successfully, returns `:ok`. Otherwise, returns `{:error, errors}`\n where `errors` is a list of tuples made of the module and the reason it failed to load.\n\n ## Examples\n\n iex> Code.ensure_all_loaded([Atom, String])\n :ok\n\n iex> Code.ensure_all_loaded([Atom, DoesNotExist])\n {:error, [{DoesNotExist, :nofile}]}\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec ensure_all_loaded([module]) :: :ok | {:error, [{module, reason}]}\n when reason: :badfile | :nofile | :on_load_failure\n def ensure_all_loaded(modules) when is_list(modules) do\n :code.ensure_modules_loaded(modules)\n end\n\n @doc \"\"\"\n Same as `ensure_all_loaded/1` but raises if any of the modules cannot be loaded.\n \"\"\"\n @doc since: \"1.15.0\"\n @spec ensure_all_loaded!([module]) :: :ok\n def ensure_all_loaded!(modules) do\n case ensure_all_loaded(modules) do\n :ok ->\n :ok\n\n {:error, errors} ->\n formatted_errors =\n errors\n |> Enum.sort()\n |> Enum.map_join(\"\\n\", fn {module, reason} ->\n \" * #{inspect(module)} due to reason #{inspect(reason)}\"\n end)\n\n raise ArgumentError, \"could not load the following modules:\\n\\n\" <> formatted_errors\n end\n end\n\n @doc \"\"\"\n Similar to `ensure_compiled!/1` but indicates you can continue without said module.\n\n While `ensure_compiled!/1` indicates to the Elixir compiler you can\n only continue when said module is available, this function indicates\n you may continue compilation without said module.\n\n If it succeeds in loading the module, it returns `{:module, module}`.\n If not, returns `{:error, reason}` with the error reason.\n If the module being checked is currently in a compiler deadlock,\n this function returns `{:error, :unavailable}`. Unavailable doesn't\n necessarily mean the module doesn't exist, just that it is not currently\n available, but it (or may not) become available in the future.\n\n Therefore, if you can only continue if the module is available, use\n `ensure_compiled!/1` instead. In particular, do not do this:\n\n case Code.ensure_compiled(module) do\n {:module, _} -> module\n {:error, _} -> raise ...\n end\n\n See the module documentation for more information on code loading.\n \"\"\"\n @spec ensure_compiled(module) ::\n {:module, module}\n | {:error, :embedded | :badfile | :nofile | :on_load_failure | :unavailable}\n def ensure_compiled(module) when is_atom(module) do\n ensure_compiled(module, :soft)\n end\n\n @doc \"\"\"\n Ensures the given module is compiled and loaded.\n\n If the module is already loaded, it works as no-op. If the module was\n not compiled yet, `ensure_compiled!/1` halts the compilation of the caller\n until the module given to `ensure_compiled!/1` becomes available or\n all files for the current project have been compiled. If compilation\n finishes and the module is not available or is in a deadlock, an error\n is raised.\n\n Given this function halts compilation, use it carefully. In particular,\n avoid using it to guess which modules are in the system. Overuse of this\n function can also lead to deadlocks, where two modules check at the same time\n if the other is compiled. This returns a specific unavailable error code,\n where we cannot successfully verify a module is available or not.\n\n See the module documentation for more information on code loading.\n \"\"\"\n @doc since: \"1.12.0\"\n @spec ensure_compiled!(module) :: module\n def ensure_compiled!(module) do\n case ensure_compiled(module, :hard) do\n {:module, module} ->\n module\n\n {:error, reason} ->\n raise ArgumentError,\n \"could not load module #{inspect(module)} due to reason #{inspect(reason)}\"\n end\n end\n\n defp ensure_compiled(module, mode) do\n case :code.ensure_loaded(module) do\n {:error, :nofile} = error ->\n if can_await_module_compilation?() do\n case Kernel.ErrorHandler.ensure_compiled(module, :module, mode, nil) do\n :found -> {:module, module}\n :deadlock -> {:error, :unavailable}\n :not_found -> {:error, :nofile}\n end\n else\n error\n end\n\n other ->\n other\n end\n end\n\n @doc \"\"\"\n Returns `true` if the module is loaded.\n\n This function doesn't attempt to load the module. For such behavior,\n `ensure_loaded?/1` can be used.\n\n ## Examples\n\n iex> Code.loaded?(String)\n true\n\n iex> Code.loaded?(NotYetLoaded)\n false\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec loaded?(module) :: boolean\n def loaded?(module) do\n :erlang.module_loaded(module)\n end\n\n @doc \"\"\"\n Returns `true` if the current process can await for module compilation.\n\n When compiling Elixir code via `Kernel.ParallelCompiler`, which is\n used by Mix and `elixirc`, calling a module that has not yet been\n compiled will block the caller until the module becomes available.\n Executing Elixir scripts, such as passing a filename to `elixir`,\n does not await.\n \"\"\"\n @doc since: \"1.11.0\"\n @spec can_await_module_compilation? :: boolean\n def can_await_module_compilation? do\n :erlang.process_info(self(), :error_handler) == {:error_handler, Kernel.ErrorHandler}\n end\n\n @doc false\n @deprecated \"Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)\"\n def ensure_compiled?(module) when is_atom(module) do\n match?({:module, ^module}, ensure_compiled(module))\n end\n\n @doc ~S\"\"\"\n Returns the docs for the given module or path to `.beam` file.\n\n When given a module name, it finds its BEAM code and reads the docs from it.\n\n When given a path to a `.beam` file, it will load the docs directly from that\n file.\n\n It returns the term stored in the documentation chunk in the format defined by\n [EEP 48](https://www.erlang.org/eeps/eep-0048.html) or `{:error, reason}` if\n the chunk is not available.\n\n ## Examples\n\n # Module documentation of an existing module\n iex> {:docs_v1, _, :elixir, _, %{\"en\" => module_doc}, _, _} = Code.fetch_docs(Atom)\n iex> module_doc |> String.split(\"\\n\") |> Enum.at(0)\n \"Atoms are constants whose values are their own name.\"\n\n # A module that doesn't exist\n iex> Code.fetch_docs(ModuleNotGood)\n {:error, :module_not_found}\n\n \"\"\"\n @doc since: \"1.7.0\"\n @spec fetch_docs(module | String.t()) ::\n {:docs_v1, annotation, beam_language, format, module_doc :: doc_content, metadata,\n docs :: [doc_element]}\n | {:error,\n :module_not_found\n | :chunk_not_found\n | {:invalid_chunk, binary}\n | :invalid_beam}\n when annotation: :erl_anno.anno(),\n beam_language: :elixir | :erlang | atom(),\n doc_content: %{optional(binary) => binary} | :none | :hidden,\n doc_element:\n {{kind :: atom, function_name :: atom, arity}, annotation, signature, doc_content,\n metadata},\n format: binary,\n signature: [binary],\n metadata: map\n def fetch_docs(module_or_path)\n\n def fetch_docs(module) when is_atom(module) do\n case get_beam_and_path(module) do\n {bin, beam_path} ->\n case fetch_docs_from_beam(bin) do\n {:error, :chunk_not_found} ->\n app_root = Path.expand(Path.join([\"..\", \"..\"]), beam_path)\n path = Path.join([app_root, \"doc\", \"chunks\", \"#{module}.chunk\"])\n fetch_docs_from_chunk(path)\n\n other ->\n other\n end\n\n :error ->\n case :code.is_loaded(module) do\n {:file, :preloaded} ->\n # The ERTS directory is not necessarily included in releases\n # unless it is listed as an extra application.\n case :code.lib_dir(:erts) do\n path when is_list(path) ->\n path = Path.join([path, \"doc\", \"chunks\", \"#{module}.chunk\"])\n fetch_docs_from_chunk(path)\n\n {:error, _} ->\n {:error, :chunk_not_found}\n end\n\n _ ->\n {:error, :module_not_found}\n end\n end\n end\n\n def fetch_docs(path) when is_binary(path) do\n fetch_docs_from_beam(String.to_charlist(path))\n end\n\n defp get_beam_and_path(module) do\n with {^module, beam, filename} <- :code.get_object_code(module),\n info_pairs when is_list(info_pairs) <- :beam_lib.info(beam),\n {:ok, ^module} <- Keyword.fetch(info_pairs, :module) do\n {beam, filename}\n else\n _ -> :error\n end\n end\n\n @docs_chunk [?D, ?o, ?c, ?s]\n\n defp fetch_docs_from_beam(bin_or_path) do\n case :beam_lib.chunks(bin_or_path, [@docs_chunk]) do\n {:ok, {_module, [{@docs_chunk, bin}]}} ->\n load_docs_chunk(bin)\n\n {:error, :beam_lib, {:missing_chunk, _, @docs_chunk}} ->\n {:error, :chunk_not_found}\n\n {:error, :beam_lib, {:file_error, _, :enoent}} ->\n {:error, :module_not_found}\n\n {:error, :beam_lib, _} ->\n {:error, :invalid_beam}\n end\n end\n\n defp fetch_docs_from_chunk(path) do\n case File.read(path) do\n {:ok, bin} ->\n load_docs_chunk(bin)\n\n {:error, _} ->\n {:error, :chunk_not_found}\n end\n end\n\n defp load_docs_chunk(bin) do\n :erlang.binary_to_term(bin)\n rescue\n _ ->\n {:error, {:invalid_chunk, bin}}\n end\n\n @doc false\n @deprecated \"Code.get_docs/2 always returns nil as its outdated documentation is no longer stored on BEAM files. Use Code.fetch_docs/1 instead\"\n def get_docs(_module, _kind) do\n nil\n end\n\n ## Helpers\n\n # Finds the file given the relative_to path.\n #\n # If the file is found, returns its path in binary, fails otherwise.\n defp find_file!(file, relative_to) do\n file =\n if relative_to do\n Path.expand(file, relative_to)\n else\n Path.expand(file)\n end\n\n case File.read(file) do\n {:ok, bin} -> {String.to_charlist(bin), file}\n {:error, reason} -> raise Code.LoadError, file: file, reason: reason\n end\n end\nend\n" }, { "path": "lib/elixir/lib/collectable.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefprotocol Collectable do\n @moduledoc \"\"\"\n A protocol to traverse data structures.\n\n The `Enum.into/2` function uses this protocol to insert an\n enumerable into a collection:\n\n iex> Enum.into([a: 1, b: 2], %{})\n %{a: 1, b: 2}\n\n ## Why Collectable?\n\n The `Enumerable` protocol is useful to take values out of a collection.\n In order to support a wide range of values, the functions provided by\n the `Enumerable` protocol do not keep shape. For example, passing a\n map to `Enum.map/2` always returns a list.\n\n This design is intentional. `Enumerable` was designed to support infinite\n collections, resources and other structures with fixed shape. For example,\n it doesn't make sense to insert values into a `Range`, as it has a\n fixed shape where only the range limits and step are stored.\n\n The `Collectable` module was designed to fill the gap left by the\n `Enumerable` protocol. `Collectable.into/1` can be seen as the opposite of\n `Enumerable.reduce/3`. If the functions in `Enumerable` are about taking values out,\n then `Collectable.into/1` is about collecting those values into a structure.\n\n ## Examples\n\n To show how to manually use the `Collectable` protocol, let's play with a\n simplified implementation for `MapSet`.\n\n iex> {initial_acc, collector_fun} = Collectable.into(MapSet.new())\n iex> updated_acc = Enum.reduce([1, 2, 3], initial_acc, fn elem, acc ->\n ...> collector_fun.(acc, {:cont, elem})\n ...> end)\n iex> collector_fun.(updated_acc, :done)\n MapSet.new([1, 2, 3])\n\n To show how the protocol can be implemented, we can again look at the\n simplified implementation for `MapSet`. In this implementation \"collecting\" elements\n simply means inserting them in the set through `MapSet.put/2`.\n\n defimpl Collectable, for: MapSet do\n def into(map_set) do\n collector_fun = fn\n map_set_acc, {:cont, elem} ->\n MapSet.put(map_set_acc, elem)\n\n map_set_acc, :done ->\n map_set_acc\n\n _map_set_acc, :halt ->\n :ok\n end\n\n initial_acc = map_set\n\n {initial_acc, collector_fun}\n end\n end\n\n So now we can call `Enum.into/2`:\n\n iex> Enum.into([1, 2, 3], MapSet.new())\n MapSet.new([1, 2, 3])\n\n \"\"\"\n\n @type command :: {:cont, term} | :done | :halt\n\n @doc \"\"\"\n Returns an initial accumulator and a \"collector\" function.\n\n Receives a `collectable` which can be used as the initial accumulator that will\n be passed to the function.\n\n The collector function receives a term and a command and injects the term into\n the collectable accumulator on every `{:cont, term}` command.\n\n `:done` is passed as a command when no further values will be injected. This\n is useful when there's a need to close resources or normalizing values. A\n collectable must be returned when the command is `:done`.\n\n If injection is suddenly interrupted, `:halt` is passed and the function\n can return any value as it won't be used.\n\n For examples on how to use the `Collectable` protocol and `into/1` see the\n module documentation.\n \"\"\"\n @spec into(t) :: {initial_acc :: term, collector :: (term, command -> t | term)}\n def into(collectable)\nend\n\ndefimpl Collectable, for: List do\n def into(list) do\n # TODO: Change the behavior so the into always comes last on Elixir v2.0\n if list != [] do\n IO.warn(\n \"the Collectable protocol is deprecated for non-empty lists. The behavior of \" <>\n \"Enum.into/2 and \\\"for\\\" comprehensions with an :into option is incorrect \" <>\n \"when collecting into non-empty lists. If you're collecting into a non-empty keyword \" <>\n \"list, consider using Keyword.merge/2 instead. If you're collecting into a non-empty \" <>\n \"list, consider concatenating the two lists with the ++ operator.\"\n )\n end\n\n fun = fn\n list_acc, {:cont, elem} ->\n [elem | list_acc]\n\n list_acc, :done ->\n list ++ :lists.reverse(list_acc)\n\n _list_acc, :halt ->\n :ok\n end\n\n {[], fun}\n end\nend\n\ndefimpl Collectable, for: BitString do\n def into(binary) when is_binary(binary) do\n fun = fn\n acc, {:cont, x} when is_binary(x) and is_list(acc) ->\n [acc | x]\n\n acc, {:cont, x} when is_bitstring(x) and is_bitstring(acc) ->\n <>\n\n acc, {:cont, x} when is_bitstring(x) ->\n <>\n\n acc, :done when is_bitstring(acc) ->\n acc\n\n acc, :done ->\n IO.iodata_to_binary(acc)\n\n __acc, :halt ->\n :ok\n\n _acc, {:cont, other} ->\n raise ArgumentError,\n \"collecting into a binary requires a bitstring, got: #{inspect(other)}\"\n end\n\n {[binary], fun}\n end\n\n def into(bitstring) do\n fun = fn\n acc, {:cont, x} when is_bitstring(x) ->\n <>\n\n acc, :done ->\n acc\n\n _acc, :halt ->\n :ok\n\n _acc, {:cont, other} ->\n raise ArgumentError,\n \"collecting into a bitstring requires a bitstring, got: #{inspect(other)}\"\n end\n\n {bitstring, fun}\n end\nend\n\ndefimpl Collectable, for: Map do\n def into(map) do\n fun = fn\n map_acc, {:cont, {key, value}} ->\n Map.put(map_acc, key, value)\n\n map_acc, :done ->\n map_acc\n\n _map_acc, :halt ->\n :ok\n\n _map_acc, {:cont, other} ->\n raise ArgumentError,\n \"collecting into a map requires {key, value} tuples, got: #{inspect(other)}\"\n end\n\n {map, fun}\n end\nend\n" }, { "path": "lib/elixir/lib/config/provider.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Config.Provider do\n @moduledoc \"\"\"\n Specifies a provider API that loads configuration during boot.\n\n Config providers are typically used during releases to load\n external configuration while the system boots. This is done\n by starting the VM with the minimum amount of applications\n running, then invoking all of the providers, and then\n restarting the system. This requires a mutable configuration\n file on disk, as the results of the providers are written to\n the file system. For more information on runtime configuration,\n see `mix release`.\n\n ## Multiple config files\n\n One common use of config providers is to specify multiple\n configuration files in a release. Elixir ships with one provider,\n called `Config.Reader`, which is capable of handling Elixir's\n built-in config files.\n\n For example, imagine you want to list some basic configuration\n on Mix's built-in `config/runtime.exs` file, but you also want\n to support additional configuration files. To do so, you can add\n this inside the `def project` portion of your `mix.exs`:\n\n releases: [\n demo: [\n config_providers: [\n {Config.Reader, {:system, \"RELEASE_ROOT\", \"/extra_config.exs\"}}\n ]\n ]\n ]\n\n You can place this `extra_config.exs` file in your release in\n multiple ways:\n\n 1. If it is available on the host when assembling the release,\n you can place it on \"rel/overlays/extra_config.exs\" and it\n will be automatically copied to the release root\n\n 2. If it is available on the target during deployment, you can\n simply copy it to the release root as a step in your deployment\n\n Now once the system boots, it will load both `config/runtime.exs`\n and `extra_config.exs` early in the boot process. You can learn\n more options on `Config.Reader`.\n\n ## Custom config provider\n\n You can also implement custom config providers, similar to how\n `Config.Reader` works. For example, imagine you need to load\n some configuration from a JSON file and load that into the system.\n Said configuration provider would look like:\n\n defmodule JSONConfigProvider do\n @behaviour Config.Provider\n\n # Let's pass the path to the JSON file as config\n @impl true\n def init(path) when is_binary(path), do: path\n\n @impl true\n def load(config, path) do\n # We need to start any app we may depend on.\n {:ok, _} = Application.ensure_all_started(:jason)\n\n json = path |> File.read!() |> Jason.decode!()\n\n Config.Reader.merge(\n config,\n my_app: [\n some_value: json[\"my_app_some_value\"],\n another_value: json[\"my_app_another_value\"],\n ]\n )\n end\n end\n\n Then, when specifying your release, you can specify the provider in\n the release configuration:\n\n releases: [\n demo: [\n config_providers: [\n {JSONConfigProvider, \"/etc/config.json\"}\n ]\n ]\n ]\n\n \"\"\"\n\n @type config :: keyword\n @type state :: term\n\n @typedoc \"\"\"\n A path pointing to a configuration file.\n\n Since configuration files are often accessed on target machines,\n it can be expressed either as:\n\n * a binary representing an absolute path\n\n * a `{:system, system_var, path}` tuple where the config is the\n concatenation of the environment variable `system_var` with\n the given `path`\n\n \"\"\"\n @type config_path :: {:system, binary(), binary()} | binary()\n\n @typedoc \"\"\"\n Options for `init/3`.\n \"\"\"\n @type init_opts :: [\n extra_config: config(),\n prune_runtime_sys_config_after_boot: boolean(),\n reboot_system_after_config: boolean(),\n validate_compile_env: [{atom(), [atom()], term()}]\n ]\n\n @doc \"\"\"\n Invoked when initializing a config provider.\n\n A config provider is typically initialized on the machine\n where the system is assembled and not on the target machine.\n The `c:init/1` callback is useful to verify the arguments\n given to the provider and prepare the state that will be\n given to `c:load/2`.\n\n Furthermore, because the state returned by `c:init/1` can\n be written to text-based config files, it should be\n restricted only to simple data types, such as integers,\n strings, atoms, tuples, maps, and lists. Entries such as\n PIDs, references, and functions cannot be serialized.\n \"\"\"\n @callback init(term) :: state\n\n @doc \"\"\"\n Loads configuration (typically during system boot).\n\n It receives the current `config` and the `state` returned by\n `c:init/1`. Then, you typically read the extra configuration\n from an external source and merge it into the received `config`.\n Merging should be done with `Config.Reader.merge/2`, as it\n performs deep merge. It should return the updated config.\n\n Note that `c:load/2` is typically invoked very early in the\n boot process, therefore if you need to use an application\n in the provider, it is your responsibility to start it.\n \"\"\"\n @callback load(config, state) :: config\n\n @doc false\n defstruct [\n :providers,\n :config_path,\n extra_config: [],\n prune_runtime_sys_config_after_boot: false,\n reboot_system_after_config: false,\n validate_compile_env: false\n ]\n\n @reserved_apps [:kernel, :stdlib]\n\n @doc \"\"\"\n Validates a `t:config_path/0`.\n \"\"\"\n @doc since: \"1.9.0\"\n @spec validate_config_path!(config_path) :: :ok\n def validate_config_path!({:system, name, path})\n when is_binary(name) and is_binary(path),\n do: :ok\n\n def validate_config_path!(path) do\n if is_binary(path) and Path.type(path) != :relative do\n :ok\n else\n raise ArgumentError, \"\"\"\n expected configuration path to be:\n\n * a binary representing an absolute path\n * a tuple {:system, system_var, path} where the config is the \\\n concatenation of the `system_var` with the given `path`\n\n Got: #{inspect(path)}\n \"\"\"\n end\n end\n\n @doc \"\"\"\n Resolves a `t:config_path/0` to an actual path.\n \"\"\"\n @doc since: \"1.9.0\"\n @spec resolve_config_path!(config_path) :: binary\n def resolve_config_path!(path) when is_binary(path), do: path\n def resolve_config_path!({:system, name, path}), do: System.fetch_env!(name) <> path\n\n # Private keys\n @init_key :config_provider_init\n @booted_key :config_provider_booted\n\n # Public keys\n @reboot_mode_key :config_provider_reboot_mode\n\n @doc false\n @spec init([{module(), term()}], config_path(), init_opts()) :: config()\n def init(providers, config_path, opts \\\\ []) when is_list(providers) and is_list(opts) do\n validate_config_path!(config_path)\n providers = for {provider, init} <- providers, do: {provider, provider.init(init)}\n init = struct!(%Config.Provider{config_path: config_path, providers: providers}, opts)\n [elixir: [{@init_key, init}]]\n end\n\n @doc false\n def boot(reboot_fun \\\\ &restart_and_sleep/0) do\n # The config provider typically runs very early in the\n # release process, so we need to make sure Elixir is started\n # before we go around running Elixir code.\n {:ok, _} = :application.ensure_all_started(:elixir)\n\n case Application.fetch_env(:elixir, @booted_key) do\n {:ok, {:booted, path}} ->\n path && File.rm(path)\n\n with {:ok, %Config.Provider{} = provider} <- Application.fetch_env(:elixir, @init_key) do\n maybe_validate_compile_env(provider)\n end\n\n :booted\n\n _ ->\n case Application.fetch_env(:elixir, @init_key) do\n {:ok, %Config.Provider{} = provider} ->\n path = resolve_config_path!(provider.config_path)\n reboot_config = [elixir: [{@booted_key, booted_value(provider, path)}]]\n boot_providers(path, provider, reboot_config, reboot_fun)\n\n _ ->\n :skip\n end\n end\n end\n\n defp boot_providers(path, provider, reboot_config, reboot_fun) do\n original_config = read_config!(path)\n\n config =\n original_config\n |> Config.__merge__(provider.extra_config)\n |> run_providers(provider)\n\n if provider.reboot_system_after_config do\n config\n |> Config.__merge__(reboot_config)\n |> write_config!(path)\n\n reboot_fun.()\n else\n for app <- @reserved_apps, config[app] != original_config[app] do\n abort(\"\"\"\n Cannot configure #{inspect(app)} because :reboot_system_after_config has been set \\\n to false and #{inspect(app)} has already been loaded, meaning any further \\\n configuration won't have an effect.\n\n The configuration for #{inspect(app)} before config providers was:\n\n #{inspect(original_config[app])}\n\n The configuration for #{inspect(app)} after config providers was:\n\n #{inspect(config[app])}\n \"\"\")\n end\n\n _ = Application.put_all_env(config, persistent: true)\n maybe_validate_compile_env(provider)\n :ok\n end\n end\n\n defp maybe_validate_compile_env(provider) do\n with [_ | _] = compile_env <- provider.validate_compile_env,\n {:error, message} <- validate_compile_env(compile_env) do\n abort(message)\n end\n end\n\n @doc false\n def valid_compile_env?(compile_env) do\n Enum.all?(compile_env, fn {app, [key | path], compile_return} ->\n try do\n traverse_env(Application.fetch_env(app, key), path) == compile_return\n rescue\n _ -> false\n end\n end)\n end\n\n @doc false\n def validate_compile_env(compile_env, ensure_loaded? \\\\ true)\n\n def validate_compile_env([{app, [key | path], compile_return} | compile_env], ensure_loaded?) do\n if ensure_app_loaded?(app, ensure_loaded?) do\n try do\n traverse_env(Application.fetch_env(app, key), path)\n rescue\n e ->\n {:error,\n \"\"\"\n application #{inspect(app)} failed reading its compile environment #{path(key, path)}:\n\n #{Exception.format(:error, e, __STACKTRACE__)}\n\n Expected it to match the compile time value of #{return_to_text(compile_return)}.\n\n #{compile_env_tips(app)}\n \"\"\"}\n else\n ^compile_return ->\n validate_compile_env(compile_env, ensure_loaded?)\n\n runtime_return ->\n {:error,\n \"\"\"\n the application #{inspect(app)} has a different value set #{path(key, path)} \\\n during runtime compared to compile time. Since this application environment entry was \\\n marked as compile time, this difference can lead to different behavior than expected:\n\n * Compile time value #{return_to_text(compile_return)}\n * Runtime value #{return_to_text(runtime_return)}\n\n #{compile_env_tips(app)}\n \"\"\"}\n end\n else\n validate_compile_env(compile_env, ensure_loaded?)\n end\n end\n\n def validate_compile_env([], _ensure_loaded?) do\n :ok\n end\n\n defp ensure_app_loaded?(app, true), do: Application.ensure_loaded(app) == :ok\n defp ensure_app_loaded?(app, false), do: Application.spec(app, :vsn) != nil\n\n defp path(key, []), do: \"for key #{inspect(key)}\"\n defp path(key, path), do: \"for path #{inspect(path)} inside key #{inspect(key)}\"\n\n defp compile_env_tips(app),\n do: \"\"\"\n To fix this error, you might:\n\n * Make the runtime value match the compile time one\n\n * Recompile your project. If the misconfigured application is a dependency, \\\n you may need to run \"mix deps.clean #{app} --build\"\n\n * Alternatively, you can disable this check. If you are using releases, you can \\\n set :validate_compile_env to false in your release configuration. If you are \\\n using Mix to start your system, you can pass the --no-validate-compile-env flag\n \"\"\"\n\n defp return_to_text({:ok, value}), do: \"was set to: #{inspect(value)}\"\n defp return_to_text(:error), do: \"was not set\"\n\n defp traverse_env(return, []), do: return\n defp traverse_env(:error, _paths), do: :error\n defp traverse_env({:ok, value}, [key | keys]), do: traverse_env(Access.fetch(value, key), keys)\n\n @compile {:no_warn_undefined, {:init, :restart, 1}}\n defp restart_and_sleep() do\n mode = Application.get_env(:elixir, @reboot_mode_key)\n\n if mode in [:embedded, :interactive] do\n :init.restart(mode: mode)\n else\n :init.restart()\n end\n\n Process.sleep(:infinity)\n end\n\n defp booted_value(%{prune_runtime_sys_config_after_boot: true}, path), do: {:booted, path}\n defp booted_value(%{prune_runtime_sys_config_after_boot: false}, _path), do: {:booted, nil}\n\n defp read_config!(path) do\n case :file.consult(path) do\n {:ok, [inner]} ->\n inner\n\n {:error, reason} ->\n bad_path_abort(\n \"Could not read runtime configuration due to reason: #{inspect(reason)}\",\n path\n )\n end\n end\n\n defp run_providers(config, %{providers: providers}) do\n Enum.reduce(providers, config, fn {provider, state}, acc ->\n try do\n provider.load(acc, state)\n catch\n kind, error ->\n IO.puts(:stderr, \"ERROR! Config provider #{inspect(provider)} failed with:\")\n IO.puts(:stderr, Exception.format(kind, error, __STACKTRACE__))\n :erlang.raise(kind, error, __STACKTRACE__)\n else\n term when is_list(term) ->\n term\n\n term ->\n abort(\"Expected provider #{inspect(provider)} to return a list, got: #{inspect(term)}\")\n end\n end)\n end\n\n defp write_config!(config, path) do\n contents = :io_lib.format(\"%% coding: utf-8~n~tw.~n\", [config])\n\n case File.write(path, IO.chardata_to_string(contents)) do\n :ok ->\n :ok\n\n {:error, reason} ->\n bad_path_abort(\n \"Could not write runtime configuration due to reason: #{inspect(reason)}\",\n path\n )\n end\n end\n\n defp bad_path_abort(msg, path) do\n abort(\n msg <>\n \". Please make sure #{inspect(path)} is writable and accessible \" <>\n \"or choose a different path\"\n )\n end\n\n defp abort(msg) do\n IO.puts(\"ERROR! \" <> msg)\n :erlang.raise(:error, \"aborting boot\", [{Config.Provider, :boot, 2, []}])\n end\nend\n" }, { "path": "lib/elixir/lib/config/reader.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Config.Reader do\n @moduledoc \"\"\"\n API for reading config files defined with `Config`.\n\n ## As a provider\n\n `Config.Reader` can also be used as a `Config.Provider`. A config\n provider is used during releases to customize how applications are\n configured. When used as a provider, it expects a single argument:\n the configuration path (as outlined in `t:Config.Provider.config_path/0`)\n for the file to be read and loaded during the system boot.\n\n For example, if you expect the target system to have a config file\n in an absolute path, you can add this inside the `def project` portion\n of your `mix.exs`:\n\n releases: [\n demo: [\n config_providers: [\n {Config.Reader, \"/etc/config.exs\"}\n ]\n ]\n ]\n\n Or if you want to read a custom path inside the release:\n\n config_providers: [{Config.Reader, {:system, \"RELEASE_ROOT\", \"/config.exs\"}}]\n\n You can also pass a keyword list of options to the reader,\n where the `:path` is a required key:\n\n config_providers: [\n {Config.Reader,\n path: \"/etc/config.exs\",\n env: :prod,\n imports: :disabled}\n ]\n\n Remember Mix already loads `config/runtime.exs` by default.\n For more examples and scenarios, see the `Config.Provider` module.\n \"\"\"\n\n @behaviour Config.Provider\n\n @type config_opts :: [\n imports: [Path.t()] | :disabled,\n env: atom(),\n target: atom()\n ]\n\n @impl true\n def init(opts) when is_list(opts) do\n {path, opts} = Keyword.pop!(opts, :path)\n Config.Provider.validate_config_path!(path)\n {path, opts}\n end\n\n def init(path) do\n init(path: path)\n end\n\n @impl true\n def load(config, {path, opts}) do\n merge(config, path |> Config.Provider.resolve_config_path!() |> read!(opts))\n end\n\n @doc \"\"\"\n Evaluates the configuration `contents` for the given `file`.\n\n Accepts the same options as `read!/2`.\n \"\"\"\n @doc since: \"1.11.0\"\n @spec eval!(Path.t(), binary, config_opts) :: keyword\n def eval!(file, contents, opts \\\\ [])\n when is_binary(file) and is_binary(contents) and is_list(opts) do\n Config.__eval__!(Path.expand(file), contents, opts) |> elem(0)\n end\n\n @doc \"\"\"\n Reads the configuration file.\n\n ## Options\n\n * `:imports` - a list of already imported paths or `:disabled`\n to disable imports\n\n * `:env` - the environment the configuration file runs on.\n See `Config.config_env/0` for sample usage\n\n * `:target` - the target the configuration file runs on.\n See `Config.config_target/0` for sample usage\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec read!(Path.t(), config_opts) :: keyword\n def read!(file, opts \\\\ []) when is_binary(file) and is_list(opts) do\n file = Path.expand(file)\n Config.__eval__!(file, File.read!(file), opts) |> elem(0)\n end\n\n @doc \"\"\"\n Reads the given configuration file and returns the configuration\n with its imports.\n\n Accepts the same options as `read!/2`. Although note the `:imports`\n option cannot be disabled in `read_imports!/2`.\n \"\"\"\n @doc since: \"1.9.0\"\n @spec read_imports!(Path.t(), config_opts) :: {keyword, [Path.t()]}\n def read_imports!(file, opts \\\\ []) when is_binary(file) and is_list(opts) do\n if opts[:imports] == :disabled do\n raise ArgumentError, \":imports must be a list of paths\"\n end\n\n file = Path.expand(file)\n Config.__eval__!(file, File.read!(file), opts)\n end\n\n @doc \"\"\"\n Merges two configurations.\n\n The configurations are merged together with the values in\n the second one having higher preference than the first in\n case of conflicts. In case both values are set to keyword\n lists, it deep merges them.\n\n ## Examples\n\n iex> Config.Reader.merge([app: [k: :v1]], [app: [k: :v2]])\n [app: [k: :v2]]\n\n iex> Config.Reader.merge([app: [k: [v1: 1, v2: 2]]], [app: [k: [v2: :a, v3: :b]]])\n [app: [k: [v1: 1, v2: :a, v3: :b]]]\n\n iex> Config.Reader.merge([app1: []], [app2: []])\n [app1: [], app2: []]\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec merge(keyword, keyword) :: keyword\n def merge(config1, config2) when is_list(config1) and is_list(config2) do\n Config.__merge__(config1, config2)\n end\nend\n" }, { "path": "lib/elixir/lib/config.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Config do\n @moduledoc ~S\"\"\"\n A simple keyword-based configuration API.\n\n ## Example\n\n This module is most commonly used to define application configuration,\n typically in `config/config.exs`:\n\n import Config\n\n config :some_app,\n key1: \"value1\",\n key2: \"value2\"\n\n import_config \"#{config_env()}.exs\"\n\n `import Config` will import the functions `config/2`, `config/3`\n `config_env/0`, `config_target/0`, and `import_config/1`\n to help you manage your configuration.\n\n `config/2` and `config/3` are used to define key-value configuration\n for a given application. Once Mix starts, it will automatically\n evaluate the configuration file and persist the configuration above\n into `:some_app`'s application environment, which can be accessed in\n as follows:\n\n \"value1\" = Application.fetch_env!(:some_app, :key1)\n\n Finally, the line `import_config \"#{config_env()}.exs\"` will import\n other config files based on the current configuration environment,\n such as `config/dev.exs` and `config/test.exs`.\n\n `Config` also provides a low-level API for evaluating and reading\n configuration, under the `Config.Reader` module.\n\n > #### Avoid application environment in libraries {: .info}\n >\n > If you are writing a library to be used by other developers,\n > it is generally recommended to avoid the application environment, as the\n > application environment is effectively a global storage. Also note that\n > the `config/config.exs` of a library is not evaluated when the library is\n > used as a dependency, as configuration is always meant to configure the\n > current project. For more information, see [\"Using application configuration for\n > libraries\"](design-anti-patterns.md#using-application-configuration-for-libraries).\n\n ## Migrating from `use Mix.Config`\n\n The `Config` module in Elixir was introduced in v1.9 as a replacement to\n `use Mix.Config`, which was specific to Mix and has been deprecated.\n\n You can leverage `Config` instead of `use Mix.Config` in three steps. The first\n step is to replace `use Mix.Config` at the top of your config files by\n `import Config`.\n\n The second is to make sure your `import_config/1` calls do not have a\n wildcard character. If so, you need to perform the wildcard lookup\n manually. For example, if you did:\n\n import_config \"../apps/*/config/config.exs\"\n\n It has to be replaced by:\n\n for config <- \"../apps/*/config/config.exs\" |> Path.expand(__DIR__) |> Path.wildcard() do\n import_config config\n end\n\n The last step is to replace all `Mix.env()` calls in the config files with `config_env()`.\n\n Keep in mind you must also avoid using `Mix.env()` inside your project files.\n To check the environment at _runtime_, you may add a configuration key:\n\n # config.exs\n ...\n config :my_app, env: config_env()\n\n Then, in other scripts and modules, you may get the environment with\n `Application.fetch_env!/2`:\n\n # router.exs\n ...\n if Application.fetch_env!(:my_app, :env) == :prod do\n ...\n end\n\n The only places where you may access functions from the `Mix` module are\n the `mix.exs` file and inside custom Mix tasks, which are always within\n the `Mix.Tasks` namespace.\n\n ## `config/runtime.exs`\n\n For runtime configuration, you can use the `config/runtime.exs` file.\n It is executed right before applications start in both Mix and releases\n (assembled with `mix release`).\n \"\"\"\n\n @type config_opts :: [\n imports: [Path.t()] | :disabled,\n env: atom(),\n target: atom()\n ]\n\n @opts_key {__MODULE__, :opts}\n @config_key {__MODULE__, :config}\n @imports_key {__MODULE__, :imports}\n\n defp get_opts!(), do: Process.get(@opts_key) || raise_improper_use!()\n defp put_opts(value), do: Process.put(@opts_key, value)\n defp delete_opts(), do: Process.delete(@opts_key)\n\n defp get_config!(), do: Process.get(@config_key) || raise_improper_use!()\n defp put_config(value), do: Process.put(@config_key, value)\n defp delete_config(), do: Process.delete(@config_key)\n\n defp get_imports!(), do: Process.get(@imports_key) || raise_improper_use!()\n defp put_imports(value), do: Process.put(@imports_key, value)\n defp delete_imports(), do: Process.delete(@imports_key)\n\n defp raise_improper_use!() do\n raise \"could not set configuration via Config. \" <>\n \"This usually means you are trying to execute a configuration file \" <>\n \"directly, instead of reading it with Config.Reader\"\n end\n\n @doc \"\"\"\n Configures the given `root_key`.\n\n Keyword lists are always deep-merged.\n\n ## Examples\n\n The given `opts` are merged into the existing configuration\n for the given `root_key`. Conflicting keys are overridden by the\n ones specified in `opts`, unless they are keywords, which are\n deep merged recursively. For example, the application configuration\n below\n\n config :logger,\n level: :warn,\n\n config :logger,\n level: :info,\n truncate: 1024\n\n will have a final configuration for `:logger` of:\n\n [level: :info, truncate: 1024]\n\n \"\"\"\n @doc since: \"1.9.0\"\n def config(root_key, opts) when is_atom(root_key) and is_list(opts) do\n if not Keyword.keyword?(opts) do\n raise ArgumentError, \"config/2 expected a keyword list, got: #{inspect(opts)}\"\n end\n\n get_config!()\n |> __merge__([{root_key, opts}])\n |> put_config()\n end\n\n @doc \"\"\"\n Configures the given `key` for the given `root_key`.\n\n Keyword lists are always deep merged.\n\n ## Examples\n\n The given `opts` are merged into the existing values for `key`\n in the given `root_key`. Conflicting keys are overridden by the\n ones specified in `opts`, unless they are keywords, which are\n deep merged recursively. For example, the application configuration\n below\n\n config :ecto, Repo,\n log_level: :warn,\n adapter: Ecto.Adapters.Postgres,\n metadata: [read_only: true]\n\n config :ecto, Repo,\n log_level: :info,\n pool_size: 10,\n metadata: [replica: true]\n\n will have a final value of the configuration for the `Repo`\n key in the `:ecto` application of:\n\n Application.get_env(:ecto, Repo)\n #=> [\n #=> log_level: :info,\n #=> pool_size: 10,\n #=> adapter: Ecto.Adapters.Postgres,\n #=> metadata: [read_only: true, replica: true]\n #=> ]\n\n \"\"\"\n @doc since: \"1.9.0\"\n def config(root_key, key, opts) when is_atom(root_key) and is_atom(key) do\n get_config!()\n |> __merge__([{root_key, [{key, opts}]}])\n |> put_config()\n end\n\n @doc \"\"\"\n Reads the configuration for the given root key.\n\n This function only reads the configuration from a previous\n `config/2` or `config/3` call. If `root_key` points to an\n application, it does not read its actual application environment.\n Its main use case is to make it easier to access and share\n configuration values across files.\n\n If the `root_key` was not configured, it returns `nil`.\n\n ## Examples\n\n # In config/config.exs\n config :my_app, foo: :bar\n\n # In config/dev.exs\n config :another_app, foo: read_config(:my_app)[:foo] || raise \"missing parent configuration\"\n\n \"\"\"\n @doc since: \"1.18.0\"\n def read_config(root_key) when is_atom(root_key) do\n get_config!()[root_key]\n end\n\n @doc \"\"\"\n Returns the environment this configuration file is executed on.\n\n In Mix projects this function returns the environment this configuration\n file is executed on. \n In releases, returns the `MIX_ENV` specified when running `mix release`.\n\n This is most often used to execute conditional code:\n\n if config_env() == :prod do\n config :my_app, :debug, false\n end\n\n \"\"\"\n @doc since: \"1.11.0\"\n defmacro config_env() do\n quote do\n Config.__env__!()\n end\n end\n\n @doc false\n @spec __env__!() :: atom()\n def __env__!() do\n elem(get_opts!(), 0) || raise \"no :env key was given to this configuration file\"\n end\n\n @doc \"\"\"\n Returns the target this configuration file is executed on.\n\n This is most often used to execute conditional code:\n\n if config_target() == :host do\n config :my_app, :debug, false\n end\n\n \"\"\"\n @doc since: \"1.11.0\"\n defmacro config_target() do\n quote do\n Config.__target__!()\n end\n end\n\n @doc false\n @spec __target__!() :: atom()\n def __target__!() do\n elem(get_opts!(), 1) || raise \"no :target key was given to this configuration file\"\n end\n\n @doc ~S\"\"\"\n Imports configuration from the given file.\n\n In case the file doesn't exist, an error is raised.\n\n If file is a relative, it will be expanded relatively to the\n directory the current configuration file is in.\n\n ## Examples\n\n This is often used to emulate configuration across environments:\n\n import_config \"#{config_env()}.exs\"\n\n Note, however, some configuration files, such as `config/runtime.exs`\n does not support imports, as they are meant to be copied across\n systems.\n \"\"\"\n @doc since: \"1.9.0\"\n defmacro import_config(file) do\n quote do\n Config.__import__!(Path.expand(unquote(file), __DIR__))\n :ok\n end\n end\n\n @doc false\n @spec __import__!(Path.t()) :: {term, Code.binding()}\n def __import__!(file) when is_binary(file) do\n import_config!(file, File.read!(file), true)\n end\n\n @doc false\n @spec __eval__!(Path.t(), binary(), config_opts) :: {keyword, [Path.t()] | :disabled}\n def __eval__!(file, content, opts \\\\ []) when is_binary(file) and is_list(opts) do\n env = Keyword.get(opts, :env)\n target = Keyword.get(opts, :target)\n imports = Keyword.get(opts, :imports, [])\n\n previous_opts = put_opts({env, target})\n previous_config = put_config([])\n previous_imports = put_imports(imports)\n\n try do\n {eval_config, _} = import_config!(file, content, false)\n\n case get_config!() do\n [] when is_list(eval_config) ->\n {validate!(eval_config, file), get_imports!()}\n\n pdict_config ->\n {pdict_config, get_imports!()}\n end\n after\n if previous_opts, do: put_opts(previous_opts), else: delete_opts()\n if previous_config, do: put_config(previous_config), else: delete_config()\n if previous_imports, do: put_imports(previous_imports), else: delete_imports()\n end\n end\n\n defp import_config!(file, contents, raise_when_disabled?) do\n current_imports = get_imports!()\n\n cond do\n current_imports == :disabled ->\n if raise_when_disabled? do\n raise \"import_config/1 is not enabled for this configuration file. \" <>\n \"Some configuration files do not allow importing other files \" <>\n \"as they are often copied to external systems\"\n end\n\n file in current_imports ->\n raise ArgumentError,\n \"attempting to load configuration #{Path.relative_to_cwd(file)} recursively\"\n\n true ->\n put_imports([file | current_imports])\n :ok\n end\n\n Code.eval_string(contents, [], file: file)\n end\n\n @doc false\n def __merge__(config1, config2) when is_list(config1) and is_list(config2) do\n Keyword.merge(config1, config2, fn _, app1, app2 ->\n Keyword.merge(app1, app2, &deep_merge/3)\n end)\n end\n\n defp deep_merge(_key, value1, value2) do\n if Keyword.keyword?(value1) and Keyword.keyword?(value2) do\n Keyword.merge(value1, value2, &deep_merge/3)\n else\n value2\n end\n end\n\n defp validate!(config, file) do\n Enum.all?(config, fn\n {app, value} when is_atom(app) ->\n if Keyword.keyword?(value) do\n true\n else\n raise ArgumentError,\n \"expected config for app #{inspect(app)} in #{Path.relative_to_cwd(file)} \" <>\n \"to return keyword list, got: #{inspect(value)}\"\n end\n\n _ ->\n false\n end)\n\n config\n end\nend\n" }, { "path": "lib/elixir/lib/dict.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Dict do\n @moduledoc ~S\"\"\"\n Generic API for dictionaries.\n\n If you need a general dictionary, use the `Map` module.\n If you need to manipulate keyword lists, use `Keyword`.\n\n To convert maps into keywords and vice-versa, use the\n `new` function in the respective modules.\n \"\"\"\n\n @moduledoc deprecated: \"Use Map or Keyword modules instead\"\n\n @type key :: any\n @type value :: any\n @type t :: list | map\n\n message =\n \"Use the Map module for working with maps or the Keyword module for working with keyword lists\"\n\n defmacro __using__(_) do\n # Use this import to guarantee proper code expansion\n import Kernel, except: [size: 1]\n\n if __CALLER__.module != HashDict do\n IO.warn(\"use Dict is deprecated. \" <> unquote(message), __CALLER__)\n end\n\n quote do\n message = \"Use maps and the Map module instead\"\n\n @deprecated message\n def get(dict, key, default \\\\ nil) do\n case fetch(dict, key) do\n {:ok, value} -> value\n :error -> default\n end\n end\n\n @deprecated message\n def get_lazy(dict, key, fun) when is_function(fun, 0) do\n case fetch(dict, key) do\n {:ok, value} -> value\n :error -> fun.()\n end\n end\n\n @deprecated message\n def get_and_update(dict, key, fun) do\n current_value = get(dict, key)\n {get, new_value} = fun.(current_value)\n {get, put(dict, key, new_value)}\n end\n\n @deprecated message\n def fetch!(dict, key) do\n case fetch(dict, key) do\n {:ok, value} -> value\n :error -> raise KeyError, key: key, term: dict\n end\n end\n\n @deprecated message\n def has_key?(dict, key) do\n match?({:ok, _}, fetch(dict, key))\n end\n\n @deprecated message\n def put_new(dict, key, value) do\n case has_key?(dict, key) do\n true -> dict\n false -> put(dict, key, value)\n end\n end\n\n @deprecated message\n def put_new_lazy(dict, key, fun) when is_function(fun, 0) do\n case has_key?(dict, key) do\n true -> dict\n false -> put(dict, key, fun.())\n end\n end\n\n @deprecated message\n def drop(dict, keys) do\n Enum.reduce(keys, dict, &delete(&2, &1))\n end\n\n @deprecated message\n def take(dict, keys) do\n Enum.reduce(keys, new(), fn key, acc ->\n case fetch(dict, key) do\n {:ok, value} -> put(acc, key, value)\n :error -> acc\n end\n end)\n end\n\n @deprecated message\n def to_list(dict) do\n reduce(dict, {:cont, []}, fn kv, acc -> {:cont, [kv | acc]} end)\n |> elem(1)\n |> :lists.reverse()\n end\n\n @deprecated message\n def keys(dict) do\n reduce(dict, {:cont, []}, fn {k, _}, acc -> {:cont, [k | acc]} end)\n |> elem(1)\n |> :lists.reverse()\n end\n\n @deprecated message\n def values(dict) do\n reduce(dict, {:cont, []}, fn {_, v}, acc -> {:cont, [v | acc]} end)\n |> elem(1)\n |> :lists.reverse()\n end\n\n @deprecated message\n def equal?(dict1, dict2) do\n # Use this import to avoid conflicts in the user code\n import Kernel, except: [size: 1]\n\n case size(dict1) == size(dict2) do\n false ->\n false\n\n true ->\n reduce(dict1, {:cont, true}, fn {k, v}, _acc ->\n case fetch(dict2, k) do\n {:ok, ^v} -> {:cont, true}\n _ -> {:halt, false}\n end\n end)\n |> elem(1)\n end\n end\n\n @deprecated message\n def merge(dict1, dict2, fun \\\\ fn _k, _v1, v2 -> v2 end) do\n # Use this import to avoid conflicts in the user code\n import Kernel, except: [size: 1]\n\n if size(dict1) < size(dict2) do\n reduce(dict1, {:cont, dict2}, fn {k, v1}, acc ->\n {:cont, update(acc, k, v1, &fun.(k, v1, &1))}\n end)\n else\n reduce(dict2, {:cont, dict1}, fn {k, v2}, acc ->\n {:cont, update(acc, k, v2, &fun.(k, &1, v2))}\n end)\n end\n |> elem(1)\n end\n\n @deprecated message\n def update(dict, key, default, fun) do\n case fetch(dict, key) do\n {:ok, value} ->\n put(dict, key, fun.(value))\n\n :error ->\n put(dict, key, default)\n end\n end\n\n @deprecated message\n def update!(dict, key, fun) do\n case fetch(dict, key) do\n {:ok, value} ->\n put(dict, key, fun.(value))\n\n :error ->\n raise KeyError, key: key, term: dict\n end\n end\n\n @deprecated message\n def pop(dict, key, default \\\\ nil) do\n case fetch(dict, key) do\n {:ok, value} ->\n {value, delete(dict, key)}\n\n :error ->\n {default, dict}\n end\n end\n\n @deprecated message\n def pop_lazy(dict, key, fun) when is_function(fun, 0) do\n case fetch(dict, key) do\n {:ok, value} ->\n {value, delete(dict, key)}\n\n :error ->\n {fun.(), dict}\n end\n end\n\n @deprecated message\n def split(dict, keys) do\n Enum.reduce(keys, {new(), dict}, fn key, {inc, exc} = acc ->\n case fetch(exc, key) do\n {:ok, value} ->\n {put(inc, key, value), delete(exc, key)}\n\n :error ->\n acc\n end\n end)\n end\n\n defoverridable merge: 2,\n merge: 3,\n equal?: 2,\n to_list: 1,\n keys: 1,\n values: 1,\n take: 2,\n drop: 2,\n get: 2,\n get: 3,\n fetch!: 2,\n has_key?: 2,\n put_new: 3,\n pop: 2,\n pop: 3,\n split: 2,\n update: 4,\n update!: 3,\n get_and_update: 3,\n get_lazy: 3,\n pop_lazy: 3,\n put_new_lazy: 3\n end\n end\n\n defmacrop target(dict) do\n quote do\n case unquote(dict) do\n %module{} -> module\n %{} -> Map\n dict when is_list(dict) -> Keyword\n dict -> unsupported_dict(dict)\n end\n end\n end\n\n @deprecated message\n @spec keys(t) :: [key]\n def keys(dict) do\n target(dict).keys(dict)\n end\n\n @deprecated message\n @spec values(t) :: [value]\n def values(dict) do\n target(dict).values(dict)\n end\n\n @deprecated message\n @spec size(t) :: non_neg_integer\n def size(dict) do\n target(dict).size(dict)\n end\n\n @deprecated message\n @spec has_key?(t, key) :: boolean\n def has_key?(dict, key) do\n target(dict).has_key?(dict, key)\n end\n\n @deprecated message\n @spec get(t, key, value) :: value\n def get(dict, key, default \\\\ nil) do\n target(dict).get(dict, key, default)\n end\n\n @deprecated message\n @spec get_lazy(t, key, (-> value)) :: value\n def get_lazy(dict, key, fun) do\n target(dict).get_lazy(dict, key, fun)\n end\n\n @deprecated message\n @spec get_and_update(t, key, (value -> {value, value})) :: {value, t}\n def get_and_update(dict, key, fun) do\n target(dict).get_and_update(dict, key, fun)\n end\n\n @deprecated message\n @spec fetch(t, key) :: value\n def fetch(dict, key) do\n target(dict).fetch(dict, key)\n end\n\n @deprecated message\n @spec fetch!(t, key) :: value\n def fetch!(dict, key) do\n target(dict).fetch!(dict, key)\n end\n\n @deprecated message\n @spec put(t, key, value) :: t\n def put(dict, key, val) do\n target(dict).put(dict, key, val)\n end\n\n @deprecated message\n @spec put_new(t, key, value) :: t\n def put_new(dict, key, val) do\n target(dict).put_new(dict, key, val)\n end\n\n @deprecated message\n @spec put_new_lazy(t, key, (-> value)) :: t\n def put_new_lazy(dict, key, fun) do\n target(dict).put_new_lazy(dict, key, fun)\n end\n\n @deprecated message\n @spec delete(t, key) :: t\n def delete(dict, key) do\n target(dict).delete(dict, key)\n end\n\n @deprecated message\n @spec merge(t, t) :: t\n def merge(dict1, dict2) do\n target1 = target(dict1)\n target2 = target(dict2)\n\n if target1 == target2 do\n target1.merge(dict1, dict2)\n else\n do_merge(target1, dict1, dict2, fn _k, _v1, v2 -> v2 end)\n end\n end\n\n @deprecated message\n @spec merge(t, t, (key, value, value -> value)) :: t\n def merge(dict1, dict2, fun) do\n target1 = target(dict1)\n target2 = target(dict2)\n\n if target1 == target2 do\n target1.merge(dict1, dict2, fun)\n else\n do_merge(target1, dict1, dict2, fun)\n end\n end\n\n defp do_merge(target1, dict1, dict2, fun) do\n Enumerable.reduce(dict2, {:cont, dict1}, fn {k, v}, acc ->\n {:cont, target1.update(acc, k, v, fn other -> fun.(k, other, v) end)}\n end)\n |> elem(1)\n end\n\n @deprecated message\n @spec pop(t, key, value) :: {value, t}\n def pop(dict, key, default \\\\ nil) do\n target(dict).pop(dict, key, default)\n end\n\n @deprecated message\n @spec pop_lazy(t, key, (-> value)) :: {value, t}\n def pop_lazy(dict, key, fun) do\n target(dict).pop_lazy(dict, key, fun)\n end\n\n @deprecated message\n @spec update!(t, key, (value -> value)) :: t\n def update!(dict, key, fun) do\n target(dict).update!(dict, key, fun)\n end\n\n @deprecated message\n @spec update(t, key, value, (value -> value)) :: t\n def update(dict, key, default, fun) do\n target(dict).update(dict, key, default, fun)\n end\n\n @deprecated message\n @spec split(t, [key]) :: {t, t}\n def split(dict, keys) do\n target(dict).split(dict, keys)\n end\n\n @deprecated message\n @spec drop(t, [key]) :: t\n def drop(dict, keys) do\n target(dict).drop(dict, keys)\n end\n\n @deprecated message\n @spec take(t, [key]) :: t\n def take(dict, keys) do\n target(dict).take(dict, keys)\n end\n\n @deprecated message\n @spec empty(t) :: t\n def empty(dict) do\n target(dict).empty(dict)\n end\n\n @deprecated message\n @spec equal?(t, t) :: boolean\n def equal?(dict1, dict2) do\n target1 = target(dict1)\n target2 = target(dict2)\n\n cond do\n target1 == target2 ->\n target1.equal?(dict1, dict2)\n\n target1.size(dict1) == target2.size(dict2) ->\n Enumerable.reduce(dict2, {:cont, true}, fn {k, v}, _acc ->\n case target1.fetch(dict1, k) do\n {:ok, ^v} -> {:cont, true}\n _ -> {:halt, false}\n end\n end)\n |> elem(1)\n\n true ->\n false\n end\n end\n\n @deprecated message\n @spec to_list(t) :: list\n def to_list(dict) do\n target(dict).to_list(dict)\n end\n\n @spec unsupported_dict(t) :: no_return\n defp unsupported_dict(dict) do\n raise ArgumentError, \"unsupported dict: #{inspect(dict)}\"\n end\nend\n" }, { "path": "lib/elixir/lib/dynamic_supervisor.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule DynamicSupervisor do\n @moduledoc ~S\"\"\"\n A supervisor optimized to only start children dynamically.\n\n The `Supervisor` module was designed to handle mostly static children\n that are started in the given order when the supervisor starts. A\n `DynamicSupervisor` starts with no children. Instead, children are\n started on demand via `start_child/2` and there is no ordering between\n children. This allows the `DynamicSupervisor` to hold millions of\n children by using efficient data structures and to execute certain\n operations, such as shutting down, concurrently.\n\n ## Examples\n\n A dynamic supervisor is started with no children and often with a name:\n\n children = [\n {DynamicSupervisor, name: MyApp.DynamicSupervisor, strategy: :one_for_one}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n\n The options given in the child specification are documented in `start_link/1`.\n\n Once the dynamic supervisor is running, we can use it to start children\n on demand. Given this sample `GenServer`:\n\n defmodule Counter do\n use GenServer\n\n def start_link(initial) do\n GenServer.start_link(__MODULE__, initial)\n end\n\n def inc(pid) do\n GenServer.call(pid, :inc)\n end\n\n def init(initial) do\n {:ok, initial}\n end\n\n def handle_call(:inc, _, count) do\n {:reply, count, count + 1}\n end\n end\n\n We can use `start_child/2` with a child specification to start a `Counter`\n server:\n\n {:ok, counter1} = DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 0})\n Counter.inc(counter1)\n #=> 0\n\n {:ok, counter2} = DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 10})\n Counter.inc(counter2)\n #=> 10\n\n DynamicSupervisor.count_children(MyApp.DynamicSupervisor)\n #=> %{active: 2, specs: 2, supervisors: 0, workers: 2}\n\n ## Scalability and partitioning\n\n The `DynamicSupervisor` is a single process responsible for starting\n other processes. In some applications, the `DynamicSupervisor` may\n become a bottleneck. To address this, you can start multiple instances\n of the `DynamicSupervisor` and then pick a \"random\" instance to start\n the child on.\n\n Instead of:\n\n children = [\n {DynamicSupervisor, name: MyApp.DynamicSupervisor}\n ]\n\n and:\n\n DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 0})\n\n You can do this:\n\n children = [\n {PartitionSupervisor,\n child_spec: DynamicSupervisor,\n name: MyApp.DynamicSupervisors}\n ]\n\n and then:\n\n DynamicSupervisor.start_child(\n {:via, PartitionSupervisor, {MyApp.DynamicSupervisors, self()}},\n {Counter, 0}\n )\n\n In the code above, we start a partition supervisor that will by default\n start a dynamic supervisor for each core in your machine. Then, instead\n of calling the `DynamicSupervisor` by name, you call it through the\n partition supervisor, using `self()` as the routing key. This means each\n process will be assigned one of the existing dynamic supervisors.\n Read the `PartitionSupervisor` docs for more information.\n\n ## Module-based supervisors\n\n Similar to `Supervisor`, dynamic supervisors also support module-based\n supervisors.\n\n defmodule MyApp.DynamicSupervisor do\n # Automatically defines child_spec/1\n use DynamicSupervisor\n\n def start_link(init_arg) do\n DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)\n end\n\n @impl true\n def init(_init_arg) do\n DynamicSupervisor.init(strategy: :one_for_one)\n end\n end\n\n See the `Supervisor` docs for a discussion of when you may want to use\n module-based supervisors. A `@doc` annotation immediately preceding\n `use DynamicSupervisor` will be attached to the generated `child_spec/1`\n function.\n\n > #### `use DynamicSupervisor` {: .info}\n >\n > When you `use DynamicSupervisor`, the `DynamicSupervisor` module will\n > set `@behaviour DynamicSupervisor` and define a `child_spec/1`\n > function, so your module can be used as a child in a supervision tree.\n\n ## Name registration\n\n A supervisor is bound to the same name registration rules as a `GenServer`.\n Read more about these rules in the documentation for `GenServer`.\n \"\"\"\n\n @behaviour GenServer\n\n @doc \"\"\"\n Callback invoked to start the supervisor and during hot code upgrades.\n\n Developers typically invoke `DynamicSupervisor.init/1` at the end of\n their init callback to return the proper supervision flags.\n \"\"\"\n @callback init(init_arg :: term) :: {:ok, sup_flags()} | :ignore\n\n @typedoc \"The supervisor flags returned on init\"\n @type sup_flags() :: %{\n strategy: strategy(),\n intensity: non_neg_integer(),\n period: pos_integer(),\n max_children: non_neg_integer() | :infinity,\n extra_arguments: [term()]\n }\n\n @typedoc \"Options given to `start_link/1` and `init/1` functions\"\n @type init_option ::\n {:strategy, strategy()}\n | {:max_restarts, non_neg_integer()}\n | {:max_seconds, pos_integer()}\n | {:max_children, non_neg_integer() | :infinity}\n | {:extra_arguments, [term()]}\n\n @typedoc \"Supported strategies\"\n @type strategy :: :one_for_one\n\n @typedoc \"\"\"\n Return values of `start_child` functions.\n\n Unlike `Supervisor`, this module ignores the child spec ids,\n so `{:error, {:already_started, pid}}` is not returned for child specs\n given with the same id. `{:error, {:already_started, pid}}` is returned\n however if a duplicate name is used when using\n [name registration](`m:GenServer#module-name-registration`).\n \"\"\"\n @type on_start_child ::\n {:ok, pid}\n | {:ok, pid, info :: term}\n | :ignore\n | {:error, {:already_started, pid} | :max_children | term}\n\n # In this struct, `args` refers to the arguments passed to init/1 (the `init_arg`).\n defstruct [\n :args,\n :extra_arguments,\n :mod,\n :name,\n :strategy,\n :max_children,\n :max_restarts,\n :max_seconds,\n children: %{},\n restarts: []\n ]\n\n @doc \"\"\"\n Returns a specification to start a dynamic supervisor under a supervisor.\n\n It accepts the same options as `start_link/1`.\n\n See `Supervisor` for more information about child specifications.\n \"\"\"\n @doc since: \"1.6.1\"\n @spec child_spec([init_option() | GenServer.option()]) :: Supervisor.child_spec()\n def child_spec(options) when is_list(options) do\n id =\n case Keyword.get(options, :name, DynamicSupervisor) do\n name when is_atom(name) -> name\n {:global, name} -> name\n {:via, _module, name} -> name\n end\n\n %{\n id: id,\n start: {DynamicSupervisor, :start_link, [options]},\n type: :supervisor\n }\n end\n\n @doc false\n defmacro __using__(opts) do\n quote location: :keep, bind_quoted: [opts: opts] do\n @behaviour DynamicSupervisor\n if not Module.has_attribute?(__MODULE__, :doc) do\n @doc \"\"\"\n Returns a specification to start this module under a supervisor.\n\n See `Supervisor`.\n \"\"\"\n end\n\n def child_spec(arg) do\n default = %{\n id: __MODULE__,\n start: {__MODULE__, :start_link, [arg]},\n type: :supervisor\n }\n\n Supervisor.child_spec(default, unquote(Macro.escape(opts)))\n end\n\n defoverridable child_spec: 1\n end\n end\n\n @doc \"\"\"\n Starts a supervisor with the given options.\n\n This function is typically not invoked directly, instead it is invoked\n when using a `DynamicSupervisor` as a child of another supervisor:\n\n children = [\n {DynamicSupervisor, name: MySupervisor}\n ]\n\n If the supervisor is successfully spawned, this function returns\n `{:ok, pid}`, where `pid` is the PID of the supervisor. If the supervisor\n is given a name and a process with the specified name already exists,\n the function returns `{:error, {:already_started, pid}}`, where `pid`\n is the PID of that process.\n\n Note that a supervisor started with this function is linked to the parent\n process and exits not only on crashes but also if the parent process exits\n with `:normal` reason.\n\n ## Options\n\n * `:name` - registers the supervisor under the given name.\n The supported values are described under the \"Name registration\"\n section in the `GenServer` module docs.\n\n * `:strategy` - the restart strategy option. The only supported\n value is `:one_for_one` which means that no other child is\n terminated if a child process terminates. You can learn more\n about strategies in the `Supervisor` module docs.\n\n * `:max_restarts` - the maximum number of restarts allowed in\n a time frame. Defaults to `3`.\n\n * `:max_seconds` - the time frame in which `:max_restarts` applies.\n Defaults to `5`.\n\n * `:max_children` - the maximum amount of children to be running\n under this supervisor at the same time. When `:max_children` is\n exceeded, `start_child/2` returns `{:error, :max_children}`. Defaults\n to `:infinity`.\n\n * `:extra_arguments` - arguments that are prepended to the arguments\n specified in the child spec given to `start_child/2`. Defaults to\n an empty list.\n\n * Any of the standard [GenServer options](`t:GenServer.option/0`)\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec start_link([init_option | GenServer.option()]) :: Supervisor.on_start()\n def start_link(options) when is_list(options) do\n keys = [:extra_arguments, :max_children, :max_seconds, :max_restarts, :strategy]\n {sup_opts, start_opts} = Keyword.split(options, keys)\n start_link(Supervisor.Default, init(sup_opts), start_opts)\n end\n\n @doc \"\"\"\n Starts a module-based supervisor process with the given `module` and `init_arg`.\n\n To start the supervisor, the `c:init/1` callback will be invoked in the given\n `module`, with `init_arg` as its argument. The `c:init/1` callback must return a\n supervisor specification which can be created with the help of the `init/1`\n function.\n\n If the `c:init/1` callback returns `:ignore`, this function returns\n `:ignore` as well and the supervisor terminates with reason `:normal`.\n If it fails or returns an incorrect value, this function returns\n `{:error, term}` where `term` is a term with information about the\n error, and the supervisor terminates with reason `term`.\n\n The `:name` option can also be given in order to register a supervisor\n name, the supported values are described in the \"Name registration\"\n section in the `GenServer` module docs.\n\n If the supervisor is successfully spawned, this function returns\n `{:ok, pid}`, where `pid` is the PID of the supervisor. If the supervisor\n is given a name and a process with the specified name already exists,\n the function returns `{:error, {:already_started, pid}}`, where `pid`\n is the PID of that process.\n\n Note that a supervisor started with this function is linked to the parent\n process and exits not only on crashes but also if the parent process exits\n with `:normal` reason.\n\n ## Options\n\n This function accepts any regular [`GenServer` options](`t:GenServer.option/0`).\n Options specific to `DynamicSupervisor` must be returned from the `c:init/1`\n callback.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec start_link(module, term, [GenServer.option()]) :: Supervisor.on_start()\n def start_link(module, init_arg, opts \\\\ []) do\n GenServer.start_link(__MODULE__, {module, init_arg, opts[:name]}, opts)\n end\n\n @doc \"\"\"\n Dynamically adds a child specification to `supervisor` and starts that child.\n\n `child_spec` should be a valid [child specification](`m:Supervisor#module-child-specification`).\n The child process will be started as defined in the child specification. Note that while\n the `:id` field is still required in the spec, the value is ignored and\n therefore does not need to be unique. Unlike `Supervisor`, this module does not\n return `{:error, {:already_started, pid}}` for child specs given with the same id.\n `{:error, {:already_started, pid}}` is returned however if a duplicate name is\n used when using [name registration](`m:GenServer#module-name-registration`).\n\n This function will block the `DynamicSupervisor` until the child initializes.\n When starting too many processes dynamically, you may want to use a\n `PartitionSupervisor` to split the work across multiple processes.\n\n If the child process start function returns `{:ok, child}` or `{:ok, child,\n info}`, then child specification and PID are added to the supervisor and\n this function returns the same value.\n\n If the child process start function returns `:ignore`, then no child is added\n to the supervision tree and this function returns `:ignore` too.\n\n If the child process start function returns an error tuple or an erroneous\n value, or if it fails, the child specification is discarded and this function\n returns `{:error, error}` where `error` is the error or erroneous value\n returned from child process start function, or failure reason if it fails.\n\n If the supervisor already has N children in a way that N exceeds the amount\n of `:max_children` set on the supervisor initialization (see `init/1`), then\n this function returns `{:error, :max_children}`.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec start_child(\n Supervisor.supervisor(),\n Supervisor.child_spec()\n | {module, term}\n | module\n | (old_erlang_child_spec :: :supervisor.child_spec())\n ) ::\n on_start_child()\n def start_child(supervisor, {_, _, _, _, _, _} = child_spec) do\n validate_and_start_child(supervisor, child_spec)\n end\n\n def start_child(supervisor, child_spec) do\n validate_and_start_child(supervisor, Supervisor.child_spec(child_spec, []))\n end\n\n defp validate_and_start_child(supervisor, child_spec) do\n case validate_child(child_spec) do\n {:ok, child} -> call(supervisor, {:start_child, child})\n error -> {:error, error}\n end\n end\n\n defp validate_child(%{id: _, start: {mod, _, _} = start} = child) do\n restart = Map.get(child, :restart, :permanent)\n type = Map.get(child, :type, :worker)\n modules = Map.get(child, :modules, [mod])\n significant = Map.get(child, :significant, false)\n\n shutdown =\n case type do\n :worker -> Map.get(child, :shutdown, 5_000)\n :supervisor -> Map.get(child, :shutdown, :infinity)\n end\n\n validate_child(start, restart, shutdown, type, modules, significant)\n end\n\n defp validate_child({_, start, restart, shutdown, type, modules}) do\n validate_child(start, restart, shutdown, type, modules, false)\n end\n\n defp validate_child(other) do\n {:invalid_child_spec, other}\n end\n\n defp validate_child(start, restart, shutdown, type, modules, significant) do\n with :ok <- validate_start(start),\n :ok <- validate_restart(restart),\n :ok <- validate_shutdown(shutdown),\n :ok <- validate_type(type),\n :ok <- validate_modules(modules),\n :ok <- validate_significant(significant) do\n {:ok, {start, restart, shutdown, type, modules}}\n end\n end\n\n defp validate_start({m, f, args}) when is_atom(m) and is_atom(f) and is_list(args), do: :ok\n defp validate_start(mfa), do: {:invalid_mfa, mfa}\n\n defp validate_type(type) when type in [:supervisor, :worker], do: :ok\n defp validate_type(type), do: {:invalid_child_type, type}\n\n defp validate_restart(restart) when restart in [:permanent, :temporary, :transient], do: :ok\n defp validate_restart(restart), do: {:invalid_restart_type, restart}\n\n defp validate_shutdown(shutdown) when is_integer(shutdown) and shutdown >= 0, do: :ok\n defp validate_shutdown(shutdown) when shutdown in [:infinity, :brutal_kill], do: :ok\n defp validate_shutdown(shutdown), do: {:invalid_shutdown, shutdown}\n\n defp validate_significant(false), do: :ok\n defp validate_significant(significant), do: {:invalid_significant, significant}\n\n defp validate_modules(:dynamic), do: :ok\n\n defp validate_modules(mods) do\n if is_list(mods) and Enum.all?(mods, &is_atom/1) do\n :ok\n else\n {:invalid_modules, mods}\n end\n end\n\n @doc \"\"\"\n Terminates the given child identified by `pid`.\n\n This function will block the `DynamicSupervisor` until the child\n terminates, which may take an arbitrary amount of time if the child\n is trapping exits and implements its own terminate callback.\n For this reason, it is often better to ask the child process\n itself to terminate, often by declaring in its child spec it has\n a restart strategy of `:transient` (or `:temporary`) and then\n sending it a message to stop with reason `:shutdown`.\n\n If successful, this function returns `:ok`. If there is no process with\n the given PID, this function returns `{:error, :not_found}`.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec terminate_child(Supervisor.supervisor(), pid) :: :ok | {:error, :not_found}\n def terminate_child(supervisor, pid) when is_pid(pid) do\n call(supervisor, {:terminate_child, pid})\n end\n\n @doc \"\"\"\n Returns a list with information about all children of the given supervisor.\n\n Note that calling this function when supervising a large number\n of children under low memory conditions can bring the system down due to an\n out of memory error.\n\n This function returns a list of tuples containing:\n\n * `id` - it is always `:undefined` for dynamic supervisors\n\n * `child` - the PID of the corresponding child process or the\n atom `:restarting` if the process is about to be restarted\n\n * `type` - `:worker` or `:supervisor` as defined in the child\n specification\n\n * `modules` - as defined in the child specification\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec which_children(Supervisor.supervisor()) :: [\n # module() | :dynamic here because :supervisor.modules() is not exported\n {:undefined, pid | :restarting, :worker | :supervisor, [module()] | :dynamic}\n ]\n def which_children(supervisor) do\n call(supervisor, :which_children)\n end\n\n @doc \"\"\"\n Returns a map containing count values for the supervisor.\n\n The map contains the following keys:\n\n * `:specs` - the number of children processes\n\n * `:active` - the count of all actively running child processes managed by\n this supervisor\n\n * `:supervisors` - the count of all supervisors whether or not the child\n process is still alive\n\n * `:workers` - the count of all workers, whether or not the child process\n is still alive\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec count_children(Supervisor.supervisor()) :: %{\n specs: non_neg_integer,\n active: non_neg_integer,\n supervisors: non_neg_integer,\n workers: non_neg_integer\n }\n def count_children(supervisor) do\n call(supervisor, :count_children) |> :maps.from_list()\n end\n\n @doc \"\"\"\n Synchronously stops the given supervisor with the given `reason`.\n\n It returns `:ok` if the supervisor terminates with the given\n reason. If it terminates with another reason, the call exits.\n\n This function keeps OTP semantics regarding error reporting.\n If the reason is any other than `:normal`, `:shutdown` or\n `{:shutdown, _}`, an error report is logged.\n \"\"\"\n @doc since: \"1.7.0\"\n @spec stop(Supervisor.supervisor(), reason :: term, timeout) :: :ok\n def stop(supervisor, reason \\\\ :normal, timeout \\\\ :infinity) do\n GenServer.stop(supervisor, reason, timeout)\n end\n\n @doc \"\"\"\n Receives a set of `options` that initializes a dynamic supervisor.\n\n This is typically invoked at the end of the `c:init/1` callback of\n module-based supervisors. See the \"Module-based supervisors\" section\n in the module documentation for more information.\n\n It accepts the same `options` as `start_link/1` (except for `:name`)\n and it returns a tuple containing the supervisor options.\n\n ## Examples\n\n def init(_arg) do\n DynamicSupervisor.init(max_children: 1000)\n end\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec init([init_option]) :: {:ok, sup_flags()}\n def init(options) when is_list(options) do\n strategy = Keyword.get(options, :strategy, :one_for_one)\n intensity = Keyword.get(options, :max_restarts, 3)\n period = Keyword.get(options, :max_seconds, 5)\n max_children = Keyword.get(options, :max_children, :infinity)\n extra_arguments = Keyword.get(options, :extra_arguments, [])\n\n flags = %{\n strategy: strategy,\n intensity: intensity,\n period: period,\n max_children: max_children,\n extra_arguments: extra_arguments\n }\n\n {:ok, flags}\n end\n\n ## Callbacks\n\n @impl true\n def init({mod, init_arg, name}) do\n Process.put(:\"$initial_call\", {:supervisor, mod, 1})\n Process.flag(:trap_exit, true)\n\n case mod.init(init_arg) do\n {:ok, flags} when is_map(flags) ->\n name =\n cond do\n is_nil(name) -> {self(), mod}\n is_atom(name) -> {:local, name}\n is_tuple(name) -> name\n end\n\n state = %DynamicSupervisor{mod: mod, args: init_arg, name: name}\n\n case init(state, flags) do\n {:ok, state} -> {:ok, state}\n {:error, reason} -> {:stop, {:supervisor_data, reason}}\n end\n\n :ignore ->\n :ignore\n\n other ->\n {:stop, {:bad_return, {mod, :init, other}}}\n end\n end\n\n defp init(state, flags) do\n extra_arguments = Map.get(flags, :extra_arguments, [])\n max_children = Map.get(flags, :max_children, :infinity)\n max_restarts = Map.get(flags, :intensity, 1)\n max_seconds = Map.get(flags, :period, 5)\n strategy = Map.get(flags, :strategy, :one_for_one)\n auto_shutdown = Map.get(flags, :auto_shutdown, :never)\n\n with :ok <- validate_strategy(strategy),\n :ok <- validate_restarts(max_restarts),\n :ok <- validate_seconds(max_seconds),\n :ok <- validate_dynamic(max_children),\n :ok <- validate_extra_arguments(extra_arguments),\n :ok <- validate_auto_shutdown(auto_shutdown) do\n {:ok,\n %{\n state\n | extra_arguments: extra_arguments,\n max_children: max_children,\n max_restarts: max_restarts,\n max_seconds: max_seconds,\n strategy: strategy\n }}\n end\n end\n\n defp validate_strategy(strategy) when strategy in [:one_for_one], do: :ok\n defp validate_strategy(strategy), do: {:error, {:invalid_strategy, strategy}}\n\n defp validate_restarts(restart) when is_integer(restart) and restart >= 0, do: :ok\n defp validate_restarts(restart), do: {:error, {:invalid_intensity, restart}}\n\n defp validate_seconds(seconds) when is_integer(seconds) and seconds > 0, do: :ok\n defp validate_seconds(seconds), do: {:error, {:invalid_period, seconds}}\n\n defp validate_dynamic(:infinity), do: :ok\n defp validate_dynamic(dynamic) when is_integer(dynamic) and dynamic >= 0, do: :ok\n defp validate_dynamic(dynamic), do: {:error, {:invalid_max_children, dynamic}}\n\n defp validate_extra_arguments(list) when is_list(list), do: :ok\n defp validate_extra_arguments(extra), do: {:error, {:invalid_extra_arguments, extra}}\n\n defp validate_auto_shutdown(auto_shutdown) when auto_shutdown in [:never], do: :ok\n\n defp validate_auto_shutdown(auto_shutdown),\n do: {:error, {:invalid_auto_shutdown, auto_shutdown}}\n\n @impl true\n def handle_call(:which_children, _from, state) do\n %{children: children} = state\n\n reply =\n for {pid, args} <- children do\n case args do\n {:restarting, {_, _, _, type, modules}} ->\n {:undefined, :restarting, type, modules}\n\n {_, _, _, type, modules} ->\n {:undefined, pid, type, modules}\n end\n end\n\n {:reply, reply, state}\n end\n\n def handle_call(:count_children, _from, state) do\n %{children: children} = state\n specs = map_size(children)\n\n {active, workers, supervisors} =\n Enum.reduce(children, {0, 0, 0}, fn\n {_pid, {:restarting, {_, _, _, :worker, _}}}, {active, worker, supervisor} ->\n {active, worker + 1, supervisor}\n\n {_pid, {:restarting, {_, _, _, :supervisor, _}}}, {active, worker, supervisor} ->\n {active, worker, supervisor + 1}\n\n {_pid, {_, _, _, :worker, _}}, {active, worker, supervisor} ->\n {active + 1, worker + 1, supervisor}\n\n {_pid, {_, _, _, :supervisor, _}}, {active, worker, supervisor} ->\n {active + 1, worker, supervisor + 1}\n end)\n\n reply = [specs: specs, active: active, supervisors: supervisors, workers: workers]\n {:reply, reply, state}\n end\n\n def handle_call({:terminate_child, pid}, _from, %{children: children} = state) do\n case children do\n %{^pid => info} ->\n :ok = terminate_children(%{pid => info}, state)\n {:reply, :ok, delete_child(pid, state)}\n\n %{} ->\n {:reply, {:error, :not_found}, state}\n end\n end\n\n def handle_call({:start_task, args, restart, shutdown}, from, state) do\n {init_restart, init_shutdown} = Process.get(Task.Supervisor)\n\n if restart == nil and init_restart != :temporary do\n {:reply, {:restart, init_restart}, state}\n else\n restart = restart || init_restart\n shutdown = shutdown || init_shutdown\n\n child =\n {{Task.Supervised, :start_link, args}, restart, shutdown, :worker, [Task.Supervised]}\n\n handle_call({:start_child, child}, from, state)\n end\n end\n\n def handle_call({:start_child, child}, _from, state) do\n %{children: children, max_children: max_children} = state\n\n if map_size(children) < max_children do\n handle_start_child(child, state)\n else\n {:reply, {:error, :max_children}, state}\n end\n end\n\n defp handle_start_child({{m, f, args} = mfa, restart, shutdown, type, modules}, state) do\n %{extra_arguments: extra} = state\n\n case reply = start_child(m, f, extra ++ args) do\n {:ok, pid, _} ->\n {:reply, reply, save_child(pid, mfa, restart, shutdown, type, modules, state)}\n\n {:ok, pid} ->\n {:reply, reply, save_child(pid, mfa, restart, shutdown, type, modules, state)}\n\n _ ->\n {:reply, reply, state}\n end\n end\n\n defp start_child(m, f, a) do\n try do\n apply(m, f, a)\n catch\n kind, reason ->\n {:error, exit_reason(kind, reason, __STACKTRACE__)}\n else\n {:ok, pid, extra} when is_pid(pid) -> {:ok, pid, extra}\n {:ok, pid} when is_pid(pid) -> {:ok, pid}\n :ignore -> :ignore\n {:error, _} = error -> error\n other -> {:error, other}\n end\n end\n\n defp save_child(pid, mfa, restart, shutdown, type, modules, state) do\n mfa = mfa_for_restart(mfa, restart)\n put_in(state.children[pid], {mfa, restart, shutdown, type, modules})\n end\n\n defp mfa_for_restart({m, f, _}, :temporary), do: {m, f, :undefined}\n defp mfa_for_restart(mfa, _), do: mfa\n\n defp exit_reason(:exit, reason, _), do: reason\n defp exit_reason(:error, reason, stack), do: {reason, stack}\n defp exit_reason(:throw, value, stack), do: {{:nocatch, value}, stack}\n\n @impl true\n def handle_cast(_msg, state) do\n {:noreply, state}\n end\n\n @impl true\n def handle_info({:EXIT, pid, reason}, state) do\n case maybe_restart_child(pid, reason, state) do\n {:ok, state} -> {:noreply, state}\n {:shutdown, state} -> {:stop, :shutdown, state}\n end\n end\n\n def handle_info({:\"$gen_restart\", pid}, state) do\n %{children: children} = state\n\n case children do\n %{^pid => restarting_args} ->\n {:restarting, child} = restarting_args\n\n case restart_child(pid, child, state) do\n {:ok, state} -> {:noreply, state}\n {:shutdown, state} -> {:stop, :shutdown, state}\n end\n\n # We may hit clause if we send $gen_restart and then\n # someone calls terminate_child, removing the child.\n %{} ->\n {:noreply, state}\n end\n end\n\n def handle_info(msg, state) do\n :logger.error(\n %{\n label: {DynamicSupervisor, :unexpected_msg},\n report: %{\n msg: msg\n }\n },\n %{\n domain: [:otp, :elixir],\n error_logger: %{tag: :error_msg},\n report_cb: &__MODULE__.format_report/1\n }\n )\n\n {:noreply, state}\n end\n\n @impl true\n def code_change(_, %{mod: mod, args: init_arg} = state, _) do\n case mod.init(init_arg) do\n {:ok, flags} when is_map(flags) ->\n case init(state, flags) do\n {:ok, state} -> {:ok, state}\n {:error, reason} -> {:error, {:supervisor_data, reason}}\n end\n\n :ignore ->\n {:ok, state}\n\n error ->\n error\n end\n end\n\n @impl true\n def terminate(_, %{children: children} = state) do\n :ok = terminate_children(children, state)\n end\n\n defp terminate_children(children, state) do\n {pids, times, stacks} = monitor_children(children)\n size = map_size(pids)\n\n timers =\n Enum.reduce(times, %{}, fn {time, pids}, acc ->\n Map.put(acc, :erlang.start_timer(time, self(), :kill), pids)\n end)\n\n stacks = wait_children(pids, size, timers, stacks)\n\n for {pid, {child, reason}} <- stacks do\n report_error(:shutdown_error, reason, pid, child, state)\n end\n\n :ok\n end\n\n defp monitor_children(children) do\n Enum.reduce(children, {%{}, %{}, %{}}, fn\n {_, {:restarting, _}}, acc ->\n acc\n\n {pid, {_, restart, _, _, _} = child}, {pids, times, stacks} ->\n case monitor_child(pid) do\n :ok ->\n times = exit_child(pid, child, times)\n {Map.put(pids, pid, child), times, stacks}\n\n {:error, :normal} when restart != :permanent ->\n {pids, times, stacks}\n\n {:error, reason} ->\n {pids, times, Map.put(stacks, pid, {child, reason})}\n end\n end)\n end\n\n defp monitor_child(pid) do\n ref = Process.monitor(pid)\n Process.unlink(pid)\n\n receive do\n {:EXIT, ^pid, reason} ->\n receive do\n {:DOWN, ^ref, :process, ^pid, _} -> {:error, reason}\n end\n after\n 0 -> :ok\n end\n end\n\n defp exit_child(pid, {_, _, shutdown, _, _}, times) do\n case shutdown do\n :brutal_kill ->\n Process.exit(pid, :kill)\n times\n\n :infinity ->\n Process.exit(pid, :shutdown)\n times\n\n time ->\n Process.exit(pid, :shutdown)\n Map.update(times, time, [pid], &[pid | &1])\n end\n end\n\n defp wait_children(_pids, 0, timers, stacks) do\n for {timer, _} <- timers do\n _ = :erlang.cancel_timer(timer)\n\n receive do\n {:timeout, ^timer, :kill} -> :ok\n after\n 0 -> :ok\n end\n end\n\n stacks\n end\n\n defp wait_children(pids, size, timers, stacks) do\n receive do\n {:DOWN, _ref, :process, pid, reason} ->\n case pids do\n %{^pid => child} ->\n stacks = wait_child(pid, child, reason, stacks)\n wait_children(pids, size - 1, timers, stacks)\n\n %{} ->\n wait_children(pids, size, timers, stacks)\n end\n\n {:timeout, timer, :kill} ->\n for pid <- Map.fetch!(timers, timer), do: Process.exit(pid, :kill)\n wait_children(pids, size, Map.delete(timers, timer), stacks)\n end\n end\n\n defp wait_child(pid, {_, _, :brutal_kill, _, _} = child, reason, stacks) do\n case reason do\n :killed -> stacks\n _ -> Map.put(stacks, pid, {child, reason})\n end\n end\n\n defp wait_child(pid, {_, restart, _, _, _} = child, reason, stacks) do\n case reason do\n {:shutdown, _} -> stacks\n :shutdown -> stacks\n :normal when restart != :permanent -> stacks\n reason -> Map.put(stacks, pid, {child, reason})\n end\n end\n\n defp maybe_restart_child(pid, reason, %{children: children} = state) do\n case children do\n %{^pid => {_, restart, _, _, _} = child} ->\n maybe_restart_child(restart, reason, pid, child, state)\n\n %{} ->\n {:ok, state}\n end\n end\n\n defp maybe_restart_child(:permanent, reason, pid, child, state) do\n report_error(:child_terminated, reason, pid, child, state)\n restart_child(pid, child, state)\n end\n\n defp maybe_restart_child(_, :normal, pid, _child, state) do\n {:ok, delete_child(pid, state)}\n end\n\n defp maybe_restart_child(_, :shutdown, pid, _child, state) do\n {:ok, delete_child(pid, state)}\n end\n\n defp maybe_restart_child(_, {:shutdown, _}, pid, _child, state) do\n {:ok, delete_child(pid, state)}\n end\n\n defp maybe_restart_child(:transient, reason, pid, child, state) do\n report_error(:child_terminated, reason, pid, child, state)\n restart_child(pid, child, state)\n end\n\n defp maybe_restart_child(:temporary, reason, pid, child, state) do\n report_error(:child_terminated, reason, pid, child, state)\n {:ok, delete_child(pid, state)}\n end\n\n defp delete_child(pid, %{children: children} = state) do\n %{state | children: Map.delete(children, pid)}\n end\n\n defp restart_child(pid, child, state) do\n case add_restart(state) do\n {:ok, %{strategy: strategy} = state} ->\n case restart_child(strategy, pid, child, state) do\n {:ok, state} ->\n {:ok, state}\n\n {:try_again, state} ->\n send(self(), {:\"$gen_restart\", pid})\n {:ok, state}\n end\n\n {:shutdown, state} ->\n report_error(:shutdown, :reached_max_restart_intensity, pid, child, state)\n {:shutdown, delete_child(pid, state)}\n end\n end\n\n defp add_restart(state) do\n %{max_seconds: max_seconds, max_restarts: max_restarts, restarts: restarts} = state\n\n now = :erlang.monotonic_time(1)\n restarts = add_restart([now | restarts], now, max_seconds)\n state = %{state | restarts: restarts}\n\n if length(restarts) <= max_restarts do\n {:ok, state}\n else\n {:shutdown, state}\n end\n end\n\n defp add_restart(restarts, now, period) do\n for then <- restarts, now <= then + period, do: then\n end\n\n defp restart_child(:one_for_one, current_pid, child, state) do\n {{m, f, args} = mfa, restart, shutdown, type, modules} = child\n %{extra_arguments: extra} = state\n\n case start_child(m, f, extra ++ args) do\n {:ok, pid, _} ->\n state = delete_child(current_pid, state)\n {:ok, save_child(pid, mfa, restart, shutdown, type, modules, state)}\n\n {:ok, pid} ->\n state = delete_child(current_pid, state)\n {:ok, save_child(pid, mfa, restart, shutdown, type, modules, state)}\n\n :ignore ->\n {:ok, delete_child(current_pid, state)}\n\n {:error, reason} ->\n report_error(:start_error, reason, {:restarting, current_pid}, child, state)\n state = put_in(state.children[current_pid], {:restarting, child})\n {:try_again, state}\n end\n end\n\n defp report_error(error, reason, pid, child, %{name: name, extra_arguments: extra}) do\n :logger.error(\n %{\n label: {:supervisor, error},\n report: [\n {:supervisor, name},\n {:errorContext, error},\n {:reason, reason},\n {:offender, extract_child(pid, child, extra)}\n ]\n },\n %{\n domain: [:otp, :sasl],\n report_cb: &:logger.format_otp_report/1,\n logger_formatter: %{title: \"SUPERVISOR REPORT\"},\n error_logger: %{tag: :error_report, type: :supervisor_report}\n }\n )\n end\n\n defp extract_child(pid, {{m, f, args}, restart, shutdown, type, _modules}, extra) do\n [\n pid: pid,\n id: :undefined,\n mfargs: {m, f, extra ++ args},\n restart_type: restart,\n shutdown: shutdown,\n child_type: type\n ]\n end\n\n ## Helpers\n\n @compile {:inline, call: 2}\n\n defp call(supervisor, req) do\n GenServer.call(supervisor, req, :infinity)\n end\n\n @doc false\n def format_report(%{\n label: {__MODULE__, :unexpected_msg},\n report: %{msg: msg}\n }) do\n {~c\"DynamicSupervisor received unexpected message: ~p~n\", [msg]}\n end\nend\n" }, { "path": "lib/elixir/lib/enum.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefprotocol Enumerable do\n @moduledoc \"\"\"\n Enumerable protocol used by `Enum` and `Stream` modules.\n\n When you invoke a function in the `Enum` module, the first argument\n is usually a collection that must implement this protocol.\n For example, the expression `Enum.map([1, 2, 3], &(&1 * 2))`\n invokes `Enumerable.reduce/3` to perform the reducing operation that\n builds a mapped list by calling the mapping function `&(&1 * 2)` on\n every element in the collection and consuming the element with an\n accumulated list.\n\n Internally, `Enum.map/2` is implemented as follows:\n\n def map(enumerable, fun) do\n reducer = fn x, acc -> {:cont, [fun.(x) | acc]} end\n Enumerable.reduce(enumerable, {:cont, []}, reducer) |> elem(1) |> :lists.reverse()\n end\n\n Note that the user-supplied function is wrapped into a `t:reducer/0` function.\n The `t:reducer/0` function must return a tagged tuple after each step,\n as described in the `t:acc/0` type. At the end, `Enumerable.reduce/3`\n returns `t:result/0`.\n\n This protocol uses tagged tuples to exchange information between the\n reducer function and the data type that implements the protocol. This\n allows enumeration of resources, such as files, to be done efficiently\n while also guaranteeing the resource will be closed at the end of the\n enumeration. This protocol also allows suspension of the enumeration,\n which is useful when interleaving between many enumerables is required\n (as in the `zip/1` and `zip/2` functions).\n\n This protocol requires four functions to be implemented, `reduce/3`,\n `count/1`, `member?/2`, and `slice/1`. The core of the protocol is the\n `reduce/3` function. All other functions exist as optimizations paths\n for data structures that can implement certain properties in better\n than linear time.\n\n ## Default implementation for lists\n\n Sometimes you may want to implement this protocol for a list contained\n in struct. This can be done by delegating to the `Enumerable.List` module\n in the `reduce/3` implementation and providing a straight-forward\n implementation for the remaining ones:\n\n defimpl Enumerable, for: CustomStruct do\n def count(struct), do: {:ok, length(struct.items)}\n def member?(struct, value), do: {:ok, value in struct.items}\n def slice(struct), do: {:error, __MODULE__}\n def reduce(struct, acc, fun), do: Enumerable.List.reduce(struct.items, acc, fun)\n end\n \"\"\"\n\n @typedoc \"\"\"\n An enumerable of elements of type `element`.\n\n This type is equivalent to `t:t/0` but is especially useful for documentation.\n\n For example, imagine you define a function that expects an enumerable of\n integers and returns an enumerable of strings:\n\n @spec integers_to_strings(Enumerable.t(integer())) :: Enumerable.t(String.t())\n def integers_to_strings(integers) do\n Stream.map(integers, &Integer.to_string/1)\n end\n\n \"\"\"\n @typedoc since: \"1.14.0\"\n @type t(_element) :: t()\n\n @typedoc \"\"\"\n The accumulator value for each step.\n\n It must be a tagged tuple with one of the following \"tags\":\n\n * `:cont` - the enumeration should continue\n * `:halt` - the enumeration should halt immediately\n * `:suspend` - the enumeration should be suspended immediately\n\n Depending on the accumulator value, the result returned by\n `Enumerable.reduce/3` will change. Please check the `t:result/0`\n type documentation for more information.\n\n In case a `t:reducer/0` function returns a `:suspend` accumulator,\n it must be explicitly handled by the caller and never leak.\n \"\"\"\n @type acc :: {:cont, term} | {:halt, term} | {:suspend, term}\n\n @typedoc \"\"\"\n The reducer function.\n\n Should be called with the `enumerable` element and the\n accumulator contents.\n\n Returns the accumulator for the next enumeration step.\n \"\"\"\n @type reducer :: (element :: term, element_acc :: term -> acc)\n\n @typedoc \"\"\"\n The result of the reduce operation.\n\n It may be *done* when the enumeration is finished by reaching\n its end, or *halted*/*suspended* when the enumeration was halted\n or suspended by the tagged accumulator.\n\n In case the tagged `:halt` accumulator is given, the `:halted` tuple\n with the accumulator must be returned. Functions like `Enum.take_while/2`\n use `:halt` underneath and can be used to test halting enumerables.\n\n In case the tagged `:suspend` accumulator is given, the caller must\n return the `:suspended` tuple with the accumulator and a continuation.\n The caller is then responsible of managing the continuation and the\n caller must always call the continuation, eventually halting or continuing\n until the end. `Enum.zip/2` uses suspension, so it can be used to test\n whether your implementation handles suspension correctly. You can also use\n `Stream.zip/2` with `Enum.take_while/2` to test the combination of\n `:suspend` with `:halt`.\n \"\"\"\n @type result ::\n {:done, term}\n | {:halted, term}\n | {:suspended, term, continuation}\n\n @typedoc \"\"\"\n A partially applied reduce function.\n\n The continuation is the closure returned as a result when\n the enumeration is suspended. When invoked, it expects\n a new accumulator and it returns the result.\n\n A continuation can be trivially implemented as long as the reduce\n function is defined in a tail recursive fashion. If the function\n is tail recursive, all the state is passed as arguments, so\n the continuation is the reducing function partially applied.\n \"\"\"\n @type continuation :: (acc -> result)\n\n @typedoc \"\"\"\n A slicing function that receives the initial position,\n the number of elements in the slice, and the step.\n\n The `start` position is a number `>= 0` and guaranteed to\n exist in the `enumerable`. The length is a number `>= 1`\n in a way that `start + length * step <= count`, where\n `count` is the maximum amount of elements in the enumerable.\n\n The function should return a non empty list where\n the amount of elements is equal to `length`.\n \"\"\"\n @type slicing_fun ::\n (start :: non_neg_integer, length :: pos_integer, step :: pos_integer -> [term()])\n\n @typedoc \"\"\"\n Receives an enumerable and returns a list.\n \"\"\"\n @type to_list_fun :: (t -> [term()])\n\n @doc \"\"\"\n Reduces the `enumerable` into an element.\n\n Most of the operations in `Enum` are implemented in terms of reduce.\n This function should apply the given `t:reducer/0` function to each\n element in the `enumerable` and proceed as expected by the returned\n accumulator.\n\n See the documentation of the types `t:result/0` and `t:acc/0` for\n more information.\n\n ## Examples\n\n As an example, here is the implementation of `reduce` for lists:\n\n def reduce(_list, {:halt, acc}, _fun), do: {:halted, acc}\n def reduce(list, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}\n def reduce([], {:cont, acc}, _fun), do: {:done, acc}\n def reduce([head | tail], {:cont, acc}, fun), do: reduce(tail, fun.(head, acc), fun)\n\n \"\"\"\n @spec reduce(t, acc, reducer) :: result\n def reduce(enumerable, acc, fun)\n\n @doc \"\"\"\n Retrieves the number of elements in the `enumerable`.\n\n It should return `{:ok, count}` if you can count the number of elements\n in `enumerable` in a faster way than fully traversing it.\n\n Otherwise it should return `{:error, __MODULE__}` and a default algorithm\n built on top of `reduce/3` that runs in linear time will be used.\n \"\"\"\n @spec count(t) :: {:ok, non_neg_integer} | {:error, module}\n def count(enumerable)\n\n @doc \"\"\"\n Checks if an `element` exists within the `enumerable`.\n\n It should return `{:ok, boolean}` if you can check the membership of a\n given element in `enumerable` with `===/2` without traversing the whole\n of it.\n\n Otherwise it should return `{:error, __MODULE__}` and a default algorithm\n built on top of `reduce/3` that runs in linear time will be used.\n\n When called outside guards, the [`in`](`in/2`) and [`not in`](`in/2`)\n operators work by using this function.\n \"\"\"\n @spec member?(t, term) :: {:ok, boolean} | {:error, module}\n def member?(enumerable, element)\n\n @doc \"\"\"\n Returns a function that slices the data structure contiguously.\n\n It should return either:\n\n * `{:ok, size, slicing_fun}` - if the `enumerable` has a known\n bound and can access a position in the `enumerable` without\n traversing all previous elements. The `slicing_fun` will receive\n a `start` position, the `amount` of elements to fetch, and a\n `step`.\n\n * `{:ok, size, to_list_fun}` - if the `enumerable` has a known bound\n and can access a position in the `enumerable` by first converting\n it to a list via `to_list_fun`.\n\n * `{:error, __MODULE__}` - the enumerable cannot be sliced efficiently\n and a default algorithm built on top of `reduce/3` that runs in\n linear time will be used.\n\n ## Differences to `count/1`\n\n The `size` value returned by this function is used for boundary checks,\n therefore it is extremely important that this function only returns `:ok`\n if retrieving the `size` of the `enumerable` is cheap, fast, and takes\n constant time. Otherwise the simplest of operations, such as\n `Enum.at(enumerable, 0)`, will become too expensive.\n\n On the other hand, the `count/1` function in this protocol should be\n implemented whenever you can count the number of elements in the collection\n without traversing it.\n \"\"\"\n @spec slice(t) ::\n {:ok, size :: non_neg_integer(), slicing_fun() | to_list_fun()}\n | {:error, module()}\n def slice(enumerable)\nend\n\ndefmodule Enum do\n import Kernel, except: [max: 2, min: 2]\n\n @moduledoc \"\"\"\n Functions for working with collections (known as enumerables).\n\n In Elixir, an enumerable is any data type that implements the\n `Enumerable` protocol. `List`s (`[1, 2, 3]`), `Map`s (`%{foo: 1, bar: 2}`)\n and `Range`s (`1..3`) are common data types used as enumerables:\n\n iex> Enum.map([1, 2, 3], fn x -> x * 2 end)\n [2, 4, 6]\n\n iex> Enum.sum([1, 2, 3])\n 6\n\n iex> Enum.map(1..3, fn x -> x * 2 end)\n [2, 4, 6]\n\n iex> Enum.sum(1..3)\n 6\n\n iex> map = %{\"a\" => 1, \"b\" => 2}\n iex> Enum.map(map, fn {k, v} -> {k, v * 2} end)\n [{\"a\", 2}, {\"b\", 4}]\n\n Many other enumerables exist in the language, such as `MapSet`s\n and the data type returned by `File.stream!/3` which allows a file to be\n traversed as if it was an enumerable.\n\n For a general overview of all functions in the `Enum` module, see\n [the `Enum` cheatsheet](enum-cheat.cheatmd).\n\n The functions in this module work in linear time. This means that, the\n time it takes to perform an operation grows at the same rate as the length\n of the enumerable. This is expected on operations such as `Enum.map/2`.\n After all, if we want to traverse every element on a list, the longer the\n list, the more elements we need to traverse, and the longer it will take.\n\n This linear behavior should also be expected on operations like `count/1`,\n `member?/2`, `at/2` and similar. While Elixir does allow data types to\n provide performant variants for such operations, you should not expect it\n to always be available, since the `Enum` module is meant to work with a\n large variety of data types and not all data types can provide optimized\n behavior.\n\n Finally, note the functions in the `Enum` module are eager: they will\n traverse the enumerable as soon as they are invoked. This is particularly\n dangerous when working with infinite enumerables. In such cases, you should\n use the `Stream` module, which allows you to lazily express computations,\n without traversing collections, and work with possibly infinite collections.\n See the `Stream` module for examples and documentation.\n \"\"\"\n\n @compile :inline_list_funcs\n\n @type t :: Enumerable.t()\n @type acc :: any\n @type element :: any\n\n @typedoc \"Zero-based index. It can also be a negative integer.\"\n @type index :: integer\n\n @type default :: any\n\n require Stream.Reducers, as: R\n\n defmacrop skip(acc) do\n acc\n end\n\n defmacrop next(_, entry, acc) do\n quote(do: [unquote(entry) | unquote(acc)])\n end\n\n defmacrop acc(head, state, _) do\n quote(do: {unquote(head), unquote(state)})\n end\n\n defmacrop next_with_acc(_, entry, head, state, _) do\n quote do\n {[unquote(entry) | unquote(head)], unquote(state)}\n end\n end\n\n @doc \"\"\"\n Returns `true` if all elements in `enumerable` are truthy.\n\n When an element has a falsy value (`false` or `nil`) iteration stops immediately\n and `false` is returned. In all other cases `true` is returned.\n\n ## Examples\n\n iex> Enum.all?([1, 2, 3])\n true\n\n iex> Enum.all?([1, nil, 3])\n false\n\n iex> Enum.all?([])\n true\n\n \"\"\"\n @spec all?(t) :: boolean\n def all?(enumerable) when is_list(enumerable) do\n all_list(enumerable)\n end\n\n def all?(enumerable) do\n Enumerable.reduce(enumerable, {:cont, true}, fn entry, _ ->\n if entry, do: {:cont, true}, else: {:halt, false}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Returns `true` if `fun.(element)` is truthy for all elements in `enumerable`.\n\n Iterates over `enumerable` and invokes `fun` on each element. If `fun` ever\n returns a falsy value (`false` or `nil`), iteration stops immediately and\n `false` is returned. Otherwise, `true` is returned.\n\n ## Examples\n\n iex> Enum.all?([2, 4, 6], fn x -> rem(x, 2) == 0 end)\n true\n\n iex> Enum.all?([2, 3, 4], fn x -> rem(x, 2) == 0 end)\n false\n\n iex> Enum.all?([], fn _ -> nil end)\n true\n\n As the last example shows, `Enum.all?/2` returns `true` if `enumerable` is\n empty, regardless of `fun`. In an empty enumerable there is no element for\n which `fun` returns a falsy value, so the result must be `true`. This is a\n well-defined logical argument for empty collections.\n\n \"\"\"\n @spec all?(t, (element -> as_boolean(term))) :: boolean\n def all?(enumerable, fun) when is_list(enumerable) do\n predicate_list(enumerable, true, fun)\n end\n\n def all?(first..last//step, fun) do\n predicate_range(first, last, step, true, fun)\n end\n\n def all?(enumerable, fun) do\n Enumerable.reduce(enumerable, {:cont, true}, fn entry, _ ->\n if fun.(entry), do: {:cont, true}, else: {:halt, false}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Returns `true` if at least one element in `enumerable` is truthy.\n\n When an element has a truthy value (neither `false` nor `nil`) iteration stops\n immediately and `true` is returned. In all other cases `false` is returned.\n\n ## Examples\n\n iex> Enum.any?([false, false, false])\n false\n\n iex> Enum.any?([false, true, false])\n true\n\n iex> Enum.any?([])\n false\n\n \"\"\"\n @spec any?(t) :: boolean\n def any?(enumerable) when is_list(enumerable) do\n any_list(enumerable)\n end\n\n def any?(enumerable) do\n Enumerable.reduce(enumerable, {:cont, false}, fn entry, _ ->\n if entry, do: {:halt, true}, else: {:cont, false}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Returns `true` if `fun.(element)` is truthy for at least one element in `enumerable`.\n\n Iterates over the `enumerable` and invokes `fun` on each element. When an invocation\n of `fun` returns a truthy value (neither `false` nor `nil`) iteration stops\n immediately and `true` is returned. In all other cases `false` is returned.\n\n ## Examples\n\n iex> Enum.any?([2, 4, 6], fn x -> rem(x, 2) == 1 end)\n false\n\n iex> Enum.any?([2, 3, 4], fn x -> rem(x, 2) == 1 end)\n true\n\n iex> Enum.any?([], fn x -> x > 0 end)\n false\n\n \"\"\"\n @spec any?(t, (element -> as_boolean(term))) :: boolean\n def any?(enumerable, fun) when is_list(enumerable) do\n predicate_list(enumerable, false, fun)\n end\n\n def any?(first..last//step, fun) do\n predicate_range(first, last, step, false, fun)\n end\n\n def any?(enumerable, fun) do\n Enumerable.reduce(enumerable, {:cont, false}, fn entry, _ ->\n if fun.(entry), do: {:halt, true}, else: {:cont, false}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Finds the element at the given `index` (zero-based).\n\n Returns `default` if `index` is out of bounds.\n\n A negative `index` can be passed, which means the `enumerable` is\n enumerated once and the `index` is counted from the end (for example,\n `-1` finds the last element).\n\n ## Examples\n\n iex> Enum.at([2, 4, 6], 0)\n 2\n\n iex> Enum.at([2, 4, 6], 2)\n 6\n\n iex> Enum.at([2, 4, 6], 4)\n nil\n\n iex> Enum.at([2, 4, 6], 4, :none)\n :none\n\n \"\"\"\n @spec at(t, index, default) :: element | default\n def at(enumerable, index, default \\\\ nil) when is_integer(index) do\n case slice_forward(enumerable, index, 1, 1) do\n [value] -> value\n [] -> default\n end\n end\n\n @doc false\n @deprecated \"Use Enum.chunk_every/2 instead\"\n def chunk(enumerable, count), do: chunk(enumerable, count, count, nil)\n\n @doc false\n @deprecated \"Use Enum.chunk_every/3 instead\"\n def chunk(enum, n, step) do\n chunk_every(enum, n, step, :discard)\n end\n\n @doc false\n @deprecated \"Use Enum.chunk_every/4 instead\"\n def chunk(enumerable, count, step, leftover) do\n chunk_every(enumerable, count, step, leftover || :discard)\n end\n\n @doc \"\"\"\n Shortcut to `chunk_every(enumerable, count, count)`.\n \"\"\"\n @doc since: \"1.5.0\"\n @spec chunk_every(t, pos_integer) :: [list]\n def chunk_every(enumerable, count), do: chunk_every(enumerable, count, count, [])\n\n @doc \"\"\"\n Returns list of lists containing `count` elements each, where\n each new chunk starts `step` elements into the `enumerable`.\n\n `step` is optional and, if not passed, defaults to `count`, i.e.\n chunks do not overlap. Chunking will stop as soon as the collection\n ends or when we emit an incomplete chunk.\n\n If the last chunk does not have `count` elements to fill the chunk,\n elements are taken from `leftover` to fill in the chunk. If `leftover`\n does not have enough elements to fill the chunk, then a partial chunk\n is returned with less than `count` elements.\n\n If `:discard` is given in `leftover`, the last chunk is discarded\n unless it has exactly `count` elements.\n\n ## Examples\n\n iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 2)\n [[1, 2], [3, 4], [5, 6]]\n\n iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard)\n [[1, 2, 3], [3, 4, 5]]\n\n iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, [7])\n [[1, 2, 3], [3, 4, 5], [5, 6, 7]]\n\n iex> Enum.chunk_every([1, 2, 3, 4], 3, 3, [])\n [[1, 2, 3], [4]]\n\n iex> Enum.chunk_every([1, 2, 3, 4], 10)\n [[1, 2, 3, 4]]\n\n iex> Enum.chunk_every([1, 2, 3, 4, 5], 2, 3, [])\n [[1, 2], [4, 5]]\n\n iex> Enum.chunk_every([1, 2, 3, 4], 3, 3, Stream.cycle([0]))\n [[1, 2, 3], [4, 0, 0]]\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec chunk_every(t, pos_integer, pos_integer, t | :discard) :: [list]\n def chunk_every(enumerable, count, step, leftover \\\\ [])\n when is_integer(count) and count > 0 and is_integer(step) and step > 0 do\n R.chunk_every(&chunk_while/4, enumerable, count, step, leftover)\n end\n\n @doc \"\"\"\n Chunks the `enumerable` with fine grained control when every chunk is emitted.\n\n `chunk_fun` receives the current element and the accumulator and must return:\n\n * `{:cont, chunk, acc}` to emit a chunk and continue with the accumulator\n * `{:cont, acc}` to not emit any chunk and continue with the accumulator\n * `{:halt, acc}` to halt chunking over the `enumerable`.\n\n `after_fun` is invoked with the final accumulator when iteration is\n finished (or `halt`ed) to handle any trailing elements that were returned\n as part of an accumulator, but were not emitted as a chunk by `chunk_fun`.\n It must return:\n\n * `{:cont, chunk, acc}` to emit a chunk. The chunk will be appended to the\n list of already emitted chunks.\n * `{:cont, acc}` to not emit a chunk\n\n The `acc` in `after_fun` is required in order to mirror the tuple format\n from `chunk_fun` but it will be discarded since the traversal is complete.\n\n Returns a list of emitted chunks.\n\n ## Examples\n\n iex> chunk_fun = fn element, acc ->\n ...> if rem(element, 2) == 0 do\n ...> {:cont, Enum.reverse([element | acc]), []}\n ...> else\n ...> {:cont, [element | acc]}\n ...> end\n ...> end\n iex> after_fun = fn\n ...> [] -> {:cont, []}\n ...> acc -> {:cont, Enum.reverse(acc), []}\n ...> end\n iex> Enum.chunk_while(1..10, [], chunk_fun, after_fun)\n [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]\n iex> Enum.chunk_while([1, 2, 3, 5, 7], [], chunk_fun, after_fun)\n [[1, 2], [3, 5, 7]]\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec chunk_while(\n t,\n acc,\n (element, acc -> {:cont, chunk, acc} | {:cont, acc} | {:halt, acc}),\n (acc -> {:cont, chunk, acc} | {:cont, acc})\n ) :: Enumerable.t()\n when chunk: any\n def chunk_while(enumerable, acc, chunk_fun, after_fun) do\n {_, {res, acc}} =\n Enumerable.reduce(enumerable, {:cont, {[], acc}}, fn entry, {buffer, acc} ->\n case chunk_fun.(entry, acc) do\n {:cont, chunk, acc} -> {:cont, {[chunk | buffer], acc}}\n {:cont, acc} -> {:cont, {buffer, acc}}\n {:halt, acc} -> {:halt, {buffer, acc}}\n end\n end)\n\n case after_fun.(acc) do\n {:cont, _acc} -> :lists.reverse(res)\n {:cont, chunk, _acc} -> :lists.reverse([chunk | res])\n end\n end\n\n @doc \"\"\"\n Splits enumerable on every element for which `fun` returns a new\n value.\n\n Returns a list of lists.\n\n ## Examples\n\n iex> Enum.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1))\n [[1], [2, 2], [3], [4, 4, 6], [7, 7]]\n\n \"\"\"\n @spec chunk_by(t, (element -> any)) :: [list]\n def chunk_by(enumerable, fun) do\n R.chunk_by(&chunk_while/4, enumerable, fun)\n end\n\n @doc \"\"\"\n Given an enumerable of enumerables, concatenates the `enumerables` into\n a single list.\n\n ## Examples\n\n iex> Enum.concat([1..3, 4..6, 7..9])\n [1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n iex> Enum.concat([[1, [2], 3], [4], [5, 6]])\n [1, [2], 3, 4, 5, 6]\n\n \"\"\"\n @spec concat(t) :: t\n def concat(enumerables)\n\n def concat(list) when is_list(list) do\n concat_list(list)\n end\n\n def concat(enums) do\n concat_enum(enums)\n end\n\n @doc \"\"\"\n Concatenates the enumerable on the `right` with the enumerable on the\n `left`.\n\n This function produces the same result as the `++/2` operator\n for lists.\n\n ## Examples\n\n iex> Enum.concat(1..3, 4..6)\n [1, 2, 3, 4, 5, 6]\n\n iex> Enum.concat([1, 2, 3], [4, 5, 6])\n [1, 2, 3, 4, 5, 6]\n\n \"\"\"\n @spec concat(t, t) :: t\n def concat(left, right) when is_list(left) and is_list(right) do\n left ++ right\n end\n\n def concat(left, right) do\n concat_enum([left, right])\n end\n\n @doc \"\"\"\n Returns the size of the `enumerable`.\n\n ## Examples\n\n iex> Enum.count([1, 2, 3])\n 3\n\n \"\"\"\n @spec count(t) :: non_neg_integer\n def count(enumerable) when is_list(enumerable) do\n length(enumerable)\n end\n\n def count(enumerable) do\n case Enumerable.count(enumerable) do\n {:ok, value} when is_integer(value) ->\n value\n\n {:error, module} ->\n enumerable |> module.reduce({:cont, 0}, fn _, acc -> {:cont, acc + 1} end) |> elem(1)\n end\n end\n\n @doc \"\"\"\n Returns the count of elements in the `enumerable` for which `fun` returns\n a truthy value.\n\n ## Examples\n\n iex> Enum.count([1, 2, 3, 4, 5], fn x -> rem(x, 2) == 0 end)\n 2\n\n \"\"\"\n @spec count(t, (element -> as_boolean(term))) :: non_neg_integer\n def count(enumerable, fun) do\n reduce(enumerable, 0, fn entry, acc ->\n if(fun.(entry), do: acc + 1, else: acc)\n end)\n end\n\n @doc \"\"\"\n Counts the enumerable stopping at `limit`.\n\n This is useful for checking certain properties of the count of an enumerable\n without having to actually count the entire enumerable. For example, if you\n wanted to check that the count was exactly, at least, or more than a value.\n\n If the enumerable implements `c:Enumerable.count/1`, the enumerable is\n not traversed and we return the lower of the two numbers. To force\n enumeration, use `count_until/3` with `fn _ -> true end` as the second\n argument.\n\n ## Examples\n\n iex> Enum.count_until(1..20, 5)\n 5\n iex> Enum.count_until(1..20, 50)\n 20\n iex> Enum.count_until(1..10, 10) == 10 # At least 10\n true\n iex> Enum.count_until(1..11, 10 + 1) > 10 # More than 10\n true\n iex> Enum.count_until(1..5, 10) < 10 # Less than 10\n true\n iex> Enum.count_until(1..10, 10 + 1) == 10 # Exactly ten\n true\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec count_until(t, pos_integer) :: non_neg_integer\n def count_until(enumerable, limit) when is_integer(limit) and limit > 0 do\n case enumerable do\n list when is_list(list) -> count_until_list(list, limit, 0)\n _ -> count_until_enum(enumerable, limit)\n end\n end\n\n def count_until(_enumerable, limit) when is_integer(limit) do\n raise ArgumentError, \"expected limit to be greater than 0, got: #{limit}\"\n end\n\n @doc \"\"\"\n Counts the elements in the enumerable for which `fun` returns a truthy value, stopping at `limit`.\n\n See `count/2` and `count_until/2` for more information.\n\n ## Examples\n\n iex> Enum.count_until(1..20, fn x -> rem(x, 2) == 0 end, 7)\n 7\n iex> Enum.count_until(1..20, fn x -> rem(x, 2) == 0 end, 11)\n 10\n \"\"\"\n @doc since: \"1.12.0\"\n @spec count_until(t, (element -> as_boolean(term)), pos_integer) :: non_neg_integer\n def count_until(enumerable, fun, limit) when is_integer(limit) and limit > 0 do\n case enumerable do\n list when is_list(list) -> count_until_list(list, fun, limit, 0)\n _ -> count_until_enum(enumerable, fun, limit)\n end\n end\n\n def count_until(_enumerable, _fun, limit) when is_integer(limit) do\n raise ArgumentError, \"expected limit to be greater than 0, got: #{limit}\"\n end\n\n @doc \"\"\"\n Enumerates the `enumerable`, returning a list where all consecutive\n duplicate elements are collapsed to a single element.\n\n Elements are compared using `===/2`.\n\n If you want to remove all duplicate elements, regardless of order,\n see `uniq/1`.\n\n ## Examples\n\n iex> Enum.dedup([1, 2, 3, 3, 2, 1])\n [1, 2, 3, 2, 1]\n\n iex> Enum.dedup([1, 1, 2, 2.0, :three, :three])\n [1, 2, 2.0, :three]\n\n \"\"\"\n @spec dedup(t) :: list\n def dedup(enumerable) when is_list(enumerable) do\n dedup_list(enumerable, []) |> :lists.reverse()\n end\n\n def dedup(enumerable) do\n reduce(enumerable, [], fn x, acc ->\n case acc do\n [^x | _] -> acc\n _ -> [x | acc]\n end\n end)\n |> :lists.reverse()\n end\n\n @doc \"\"\"\n Enumerates the `enumerable`, returning a list where all consecutive\n duplicate elements are collapsed to a single element.\n\n The function `fun` maps every element to a term which is used to\n determine if two elements are duplicates.\n\n ## Examples\n\n iex> Enum.dedup_by([{1, :a}, {2, :b}, {2, :c}, {1, :a}], fn {x, _} -> x end)\n [{1, :a}, {2, :b}, {1, :a}]\n\n iex> Enum.dedup_by([5, 1, 2, 3, 2, 1], fn x -> x > 2 end)\n [5, 1, 3, 2]\n\n \"\"\"\n @spec dedup_by(t, (element -> term)) :: list\n def dedup_by(enumerable, fun) do\n {list, _} = reduce(enumerable, {[], []}, R.dedup(fun))\n :lists.reverse(list)\n end\n\n @doc \"\"\"\n Drops the `amount` of elements from the `enumerable`.\n\n If a negative `amount` is given, the `amount` of last values will be dropped.\n The `enumerable` will be enumerated once to retrieve the proper index and\n the remaining calculation is performed from the end.\n\n ## Examples\n\n iex> Enum.drop([1, 2, 3], 2)\n [3]\n\n iex> Enum.drop([1, 2, 3], 10)\n []\n\n iex> Enum.drop([1, 2, 3], 0)\n [1, 2, 3]\n\n iex> Enum.drop([1, 2, 3], -1)\n [1, 2]\n\n \"\"\"\n @spec drop(t, integer) :: list\n def drop(enumerable, amount)\n when is_list(enumerable) and is_integer(amount) and amount >= 0 do\n drop_list(enumerable, amount)\n end\n\n def drop(enumerable, 0) do\n to_list(enumerable)\n end\n\n def drop(enumerable, amount) when is_integer(amount) and amount > 0 do\n {result, _} = reduce(enumerable, {[], amount}, R.drop())\n if is_list(result), do: :lists.reverse(result), else: []\n end\n\n def drop(enumerable, amount) when is_integer(amount) and amount < 0 do\n {count, fun} = slice_count_and_fun(enumerable, 1)\n amount = Kernel.min(amount + count, count)\n\n if amount > 0 do\n fun.(0, amount, 1)\n else\n []\n end\n end\n\n @doc \"\"\"\n Returns a list of every `nth` element in the `enumerable` dropped,\n starting with the first element.\n\n The first element is always dropped, unless `nth` is 0.\n\n The second argument specifying every `nth` element must be a non-negative\n integer.\n\n ## Examples\n\n iex> Enum.drop_every(1..10, 2)\n [2, 4, 6, 8, 10]\n\n iex> Enum.drop_every(1..10, 0)\n [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\n iex> Enum.drop_every([1, 2, 3], 1)\n []\n\n \"\"\"\n @spec drop_every(t, non_neg_integer) :: list\n def drop_every(enumerable, nth)\n\n def drop_every(_enumerable, 1), do: []\n def drop_every(enumerable, 0), do: to_list(enumerable)\n def drop_every([], nth) when is_integer(nth), do: []\n\n def drop_every(enumerable, nth) when is_integer(nth) and nth > 1 do\n {res, _} = reduce(enumerable, {[], :first}, R.drop_every(nth))\n :lists.reverse(res)\n end\n\n @doc \"\"\"\n Drops elements at the beginning of the `enumerable` while `fun` returns a\n truthy value.\n\n ## Examples\n\n iex> Enum.drop_while([1, 2, 3, 2, 1], fn x -> x < 3 end)\n [3, 2, 1]\n\n \"\"\"\n @spec drop_while(t, (element -> as_boolean(term))) :: list\n def drop_while(enumerable, fun) when is_list(enumerable) do\n drop_while_list(enumerable, fun)\n end\n\n def drop_while(enumerable, fun) do\n {res, _} = reduce(enumerable, {[], true}, R.drop_while(fun))\n :lists.reverse(res)\n end\n\n @doc \"\"\"\n Invokes the given `fun` for each element in the `enumerable`.\n\n Returns `:ok`.\n\n ## Examples\n\n Enum.each([\"some\", \"example\"], fn x -> IO.puts(x) end)\n some\n example\n #=> :ok\n\n \"\"\"\n @spec each(t, (element -> any)) :: :ok\n def each(enumerable, fun) when is_list(enumerable) do\n :lists.foreach(fun, enumerable)\n end\n\n def each(enumerable, fun) do\n reduce(enumerable, nil, fn entry, _ ->\n fun.(entry)\n nil\n end)\n\n :ok\n end\n\n @doc \"\"\"\n Determines if the `enumerable` is empty.\n\n Returns `true` if `enumerable` is empty, otherwise `false`.\n\n ## Examples\n\n iex> Enum.empty?([])\n true\n\n iex> Enum.empty?([1, 2, 3])\n false\n\n \"\"\"\n @spec empty?(t) :: boolean\n def empty?(enumerable) when is_list(enumerable) do\n enumerable == []\n end\n\n def empty?(enumerable) do\n case Enumerable.slice(enumerable) do\n {:ok, value, _} ->\n value == 0\n\n {:error, module} ->\n enumerable\n |> module.reduce({:cont, true}, fn _, _ -> {:halt, false} end)\n |> elem(1)\n end\n end\n\n @doc \"\"\"\n Finds the element at the given `index` (zero-based).\n\n Returns `{:ok, element}` if found, otherwise `:error`.\n\n A negative `index` can be passed, which means the `enumerable` is\n enumerated once and the `index` is counted from the end (for example,\n `-1` fetches the last element).\n\n ## Examples\n\n iex> Enum.fetch([2, 4, 6], 0)\n {:ok, 2}\n\n iex> Enum.fetch([2, 4, 6], -3)\n {:ok, 2}\n\n iex> Enum.fetch([2, 4, 6], 2)\n {:ok, 6}\n\n iex> Enum.fetch([2, 4, 6], 4)\n :error\n\n \"\"\"\n @spec fetch(t, index) :: {:ok, element} | :error\n def fetch(enumerable, index) when is_integer(index) do\n case slice_forward(enumerable, index, 1, 1) do\n [value] -> {:ok, value}\n [] -> :error\n end\n end\n\n @doc \"\"\"\n Finds the element at the given `index` (zero-based).\n\n Raises `OutOfBoundsError` if the given `index` is outside the range of\n the `enumerable`.\n\n ## Examples\n\n iex> Enum.fetch!([2, 4, 6], 0)\n 2\n\n iex> Enum.fetch!([2, 4, 6], 2)\n 6\n\n iex> Enum.fetch!([2, 4, 6], 4)\n ** (Enum.OutOfBoundsError) out of bounds error at position 4 when traversing enumerable [2, 4, 6]\n\n \"\"\"\n @spec fetch!(t, index) :: element\n def fetch!(enumerable, index) when is_integer(index) do\n case slice_forward(enumerable, index, 1, 1) do\n [value] -> value\n [] -> raise Enum.OutOfBoundsError, index: index, enumerable: enumerable\n end\n end\n\n @doc \"\"\"\n Filters the `enumerable`, i.e. returns only those elements\n for which `fun` returns a truthy value.\n\n See also `reject/2` which discards all elements where the\n function returns a truthy value.\n\n ## Examples\n\n iex> Enum.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end)\n [2]\n iex> Enum.filter([\"apple\", \"pear\", \"banana\"], fn fruit -> String.contains?(fruit, \"a\") end)\n [\"apple\", \"pear\", \"banana\"]\n iex> Enum.filter([4, 21, 24, 904], fn seconds -> seconds > 1000 end)\n []\n\n Keep in mind that `filter` is not capable of filtering and\n transforming an element at the same time. If you would like\n to do so, consider using `flat_map/2`. For example, if you\n want to convert all strings that represent an integer and\n discard the invalid one in one pass:\n\n strings = [\"1234\", \"abc\", \"12ab\"]\n\n Enum.flat_map(strings, fn string ->\n case Integer.parse(string) do\n # transform to integer\n {int, _rest} -> [int]\n # skip the value\n :error -> []\n end\n end)\n\n \"\"\"\n @spec filter(t, (element -> as_boolean(term))) :: list\n def filter(enumerable, fun) when is_list(enumerable) do\n filter_list(enumerable, fun)\n end\n\n def filter(enumerable, fun) do\n reduce(enumerable, [], R.filter(fun)) |> :lists.reverse()\n end\n\n @doc false\n @deprecated \"Use Enum.filter/2 + Enum.map/2 or for comprehensions instead\"\n def filter_map(enumerable, filter, mapper) when is_list(enumerable) do\n for element <- enumerable, filter.(element), do: mapper.(element)\n end\n\n def filter_map(enumerable, filter, mapper) do\n enumerable\n |> reduce([], R.filter_map(filter, mapper))\n |> :lists.reverse()\n end\n\n @doc \"\"\"\n Returns the first element for which `fun` returns a truthy value.\n If no such element is found, returns `default`.\n\n ## Examples\n\n iex> Enum.find([2, 3, 4], fn x -> rem(x, 2) == 1 end)\n 3\n\n iex> Enum.find([2, 4, 6], fn x -> rem(x, 2) == 1 end)\n nil\n iex> Enum.find([2, 4, 6], 0, fn x -> rem(x, 2) == 1 end)\n 0\n\n \"\"\"\n @spec find(t, default, (element -> any)) :: element | default\n def find(enumerable, default \\\\ nil, fun)\n\n def find(enumerable, default, fun) when is_list(enumerable) do\n find_list(enumerable, default, fun)\n end\n\n def find(enumerable, default, fun) do\n Enumerable.reduce(enumerable, {:cont, default}, fn entry, default ->\n if fun.(entry), do: {:halt, entry}, else: {:cont, default}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Similar to `find/3`, but returns the index (zero-based)\n of the element instead of the element itself.\n\n ## Examples\n\n iex> Enum.find_index([2, 4, 6], fn x -> rem(x, 2) == 1 end)\n nil\n\n iex> Enum.find_index([2, 3, 4], fn x -> rem(x, 2) == 1 end)\n 1\n\n \"\"\"\n @spec find_index(t, (element -> any)) :: non_neg_integer | nil\n def find_index(enumerable, fun) when is_list(enumerable) do\n find_index_list(enumerable, 0, fun)\n end\n\n def find_index(enumerable, fun) do\n result =\n Enumerable.reduce(enumerable, {:cont, {:not_found, 0}}, fn entry, {_, index} ->\n if fun.(entry), do: {:halt, {:found, index}}, else: {:cont, {:not_found, index + 1}}\n end)\n\n case elem(result, 1) do\n {:found, index} -> index\n {:not_found, _} -> nil\n end\n end\n\n @doc \"\"\"\n Similar to `find/3`, but returns the value of the function\n invocation instead of the element itself.\n\n The return value is considered to be found when the result is truthy\n (neither `nil` nor `false`).\n\n ## Examples\n\n iex> Enum.find_value([2, 3, 4], fn x ->\n ...> if x > 2, do: x * x\n ...> end)\n 9\n\n iex> Enum.find_value([2, 4, 6], fn x -> rem(x, 2) == 1 end)\n nil\n\n iex> Enum.find_value([2, 3, 4], fn x -> rem(x, 2) == 1 end)\n true\n\n iex> Enum.find_value([1, 2, 3], \"no bools!\", &is_boolean/1)\n \"no bools!\"\n\n \"\"\"\n @spec find_value(t, default, (element -> found_value)) :: found_value | default\n when found_value: term\n def find_value(enumerable, default \\\\ nil, fun)\n\n def find_value(enumerable, default, fun) when is_list(enumerable) do\n find_value_list(enumerable, default, fun)\n end\n\n def find_value(enumerable, default, fun) do\n Enumerable.reduce(enumerable, {:cont, default}, fn entry, default ->\n fun_entry = fun.(entry)\n if fun_entry, do: {:halt, fun_entry}, else: {:cont, default}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Maps the given `fun` over `enumerable` and flattens the result only one level deep.\n\n This function returns a new enumerable built by appending the result of invoking `fun`\n on each element of `enumerable` together; conceptually, this is similar to a\n combination of `map/2` and `concat/1`.\n\n ## Examples\n\n iex> Enum.flat_map([:a, :b, :c], fn x -> [x, x] end)\n [:a, :a, :b, :b, :c, :c]\n\n iex> Enum.flat_map([{1, 3}, {4, 6}], fn {x, y} -> x..y end)\n [1, 2, 3, 4, 5, 6]\n\n iex> Enum.flat_map([:a, :b, :c], fn x -> [[x]] end)\n [[:a], [:b], [:c]]\n\n This is frequently used to transform and filter in one pass, returning empty\n lists to exclude results:\n\n iex> Enum.flat_map([4, 0, 2, 0], fn x ->\n ...> if x != 0, do: [1 / x], else: []\n ...> end)\n [0.25, 0.5]\n\n \"\"\"\n @spec flat_map(t, (element -> t)) :: list\n def flat_map(enumerable, fun) when is_list(enumerable) do\n flat_map_list(enumerable, fun)\n end\n\n def flat_map(enumerable, fun) do\n reduce(enumerable, [], fn entry, acc ->\n case fun.(entry) do\n [] -> acc\n list when is_list(list) -> [list | acc]\n other -> [to_list(other) | acc]\n end\n end)\n |> flat_reverse([])\n end\n\n # the first clause is an optimization\n defp flat_reverse([[elem] | t], acc), do: flat_reverse(t, [elem | acc])\n defp flat_reverse([h | t], acc), do: flat_reverse(t, h ++ acc)\n defp flat_reverse([], acc), do: acc\n\n @doc \"\"\"\n Maps and reduces an `enumerable`, flattening the results only one level deep.\n\n It expects an accumulator and a function that receives each enumerable\n element, and must return a tuple containing a new enumerable (often a list)\n with the new accumulator or a tuple with `:halt` as first element and\n the accumulator as second.\n\n Returns a 2-element tuple where the first element is the results flattened one level deep and\n the second element is the last accumulator.\n\n ## Examples\n\n iex> enumerable = 1..100\n iex> n = 3\n iex> Enum.flat_map_reduce(enumerable, 0, fn x, acc ->\n ...> if acc < n, do: {[x], acc + 1}, else: {:halt, acc}\n ...> end)\n {[1, 2, 3], 3}\n\n iex> Enum.flat_map_reduce(1..5, 0, fn x, acc -> {[[x]], acc + x} end)\n {[[1], [2], [3], [4], [5]], 15}\n\n \"\"\"\n @spec flat_map_reduce(t, acc, fun) :: {[any], acc}\n when fun: (element, acc -> {t, acc} | {:halt, acc})\n def flat_map_reduce(enumerable, acc, fun) do\n {_, {list, acc}} =\n Enumerable.reduce(enumerable, {:cont, {[], acc}}, fn entry, {list, acc} ->\n case fun.(entry, acc) do\n {:halt, acc} ->\n {:halt, {list, acc}}\n\n {[], acc} ->\n {:cont, {list, acc}}\n\n {[entry], acc} ->\n {:cont, {[entry | list], acc}}\n\n {entries, acc} ->\n {:cont, {reduce(entries, list, &[&1 | &2]), acc}}\n end\n end)\n\n {:lists.reverse(list), acc}\n end\n\n @doc \"\"\"\n Returns a map with keys as unique elements of `enumerable` and values\n as the count of every element.\n\n ## Examples\n\n iex> Enum.frequencies(~w{ant buffalo ant ant buffalo dingo})\n %{\"ant\" => 3, \"buffalo\" => 2, \"dingo\" => 1}\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec frequencies(t) :: map\n def frequencies(enumerable) do\n reduce(enumerable, %{}, fn key, acc ->\n case acc do\n %{^key => value} -> %{acc | key => value + 1}\n %{} -> Map.put(acc, key, 1)\n end\n end)\n end\n\n @doc \"\"\"\n Returns a map with keys as unique elements given by `key_fun` and values\n as the count of every element.\n\n ## Examples\n\n iex> Enum.frequencies_by(~w{aa aA bb cc}, &String.downcase/1)\n %{\"aa\" => 2, \"bb\" => 1, \"cc\" => 1}\n\n iex> Enum.frequencies_by(~w{aaa aA bbb cc c}, &String.length/1)\n %{3 => 2, 2 => 2, 1 => 1}\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec frequencies_by(t, (element -> any)) :: map\n def frequencies_by(enumerable, key_fun) when is_function(key_fun) do\n reduce(enumerable, %{}, fn entry, acc ->\n key = key_fun.(entry)\n\n case acc do\n %{^key => value} -> %{acc | key => value + 1}\n %{} -> Map.put(acc, key, 1)\n end\n end)\n end\n\n @doc \"\"\"\n Splits the `enumerable` into groups based on `key_fun`.\n\n The result is a map where each key is given by `key_fun`\n and each value is a list of elements given by `value_fun`.\n The order of elements within each list is preserved from the `enumerable`.\n However, like all maps, the resulting map is unordered.\n\n ## Examples\n\n iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1)\n %{3 => [\"ant\", \"cat\"], 5 => [\"dingo\"], 7 => [\"buffalo\"]}\n\n iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1, &String.first/1)\n %{3 => [\"a\", \"c\"], 5 => [\"d\"], 7 => [\"b\"]}\n\n The key can be any Elixir value. For example, you may use a tuple\n to group by multiple keys:\n\n iex> collection = [\n ...> %{id: 1, lang: \"Elixir\", seq: 1},\n ...> %{id: 1, lang: \"Java\", seq: 1},\n ...> %{id: 1, lang: \"Ruby\", seq: 2},\n ...> %{id: 2, lang: \"Python\", seq: 1},\n ...> %{id: 2, lang: \"C#\", seq: 2},\n ...> %{id: 2, lang: \"Haskell\", seq: 2},\n ...> ]\n iex> Enum.group_by(collection, &{&1.id, &1.seq})\n %{\n {1, 1} => [%{id: 1, lang: \"Elixir\", seq: 1}, %{id: 1, lang: \"Java\", seq: 1}],\n {1, 2} => [%{id: 1, lang: \"Ruby\", seq: 2}],\n {2, 1} => [%{id: 2, lang: \"Python\", seq: 1}],\n {2, 2} => [%{id: 2, lang: \"C#\", seq: 2}, %{id: 2, lang: \"Haskell\", seq: 2}]\n }\n iex> Enum.group_by(collection, &{&1.id, &1.seq}, &{&1.id, &1.lang})\n %{\n {1, 1} => [{1, \"Elixir\"}, {1, \"Java\"}],\n {1, 2} => [{1, \"Ruby\"}],\n {2, 1} => [{2, \"Python\"}],\n {2, 2} => [{2, \"C#\"}, {2, \"Haskell\"}]\n }\n\n \"\"\"\n @spec group_by(t, (element -> any), (element -> any)) :: map\n def group_by(enumerable, key_fun, value_fun \\\\ fn x -> x end)\n\n def group_by(enumerable, key_fun, value_fun) when is_function(key_fun) do\n reduce(reverse(enumerable), %{}, fn entry, acc ->\n key = key_fun.(entry)\n value = value_fun.(entry)\n\n case acc do\n %{^key => existing} -> %{acc | key => [value | existing]}\n %{} -> Map.put(acc, key, [value])\n end\n end)\n end\n\n def group_by(enumerable, dict, fun) do\n IO.warn(\n \"Enum.group_by/3 with a map/dictionary as second element is deprecated. \" <>\n \"A map is used by default and it is no longer required to pass one to this function\"\n )\n\n # Avoid warnings about Dict\n dict_module = String.to_atom(\"Dict\")\n\n reduce(reverse(enumerable), dict, fn entry, categories ->\n dict_module.update(categories, fun.(entry), [entry], &[entry | &1])\n end)\n end\n\n @doc \"\"\"\n Intersperses `separator` between each element of the enumeration.\n\n ## Examples\n\n iex> Enum.intersperse([1, 2, 3], 0)\n [1, 0, 2, 0, 3]\n\n iex> Enum.intersperse([1], 0)\n [1]\n\n iex> Enum.intersperse([], 0)\n []\n\n \"\"\"\n @spec intersperse(t, element) :: list\n def intersperse(enumerable, separator) when is_list(enumerable) do\n case enumerable do\n [] -> []\n list -> intersperse_non_empty_list(list, separator)\n end\n end\n\n def intersperse(enumerable, separator) do\n list =\n enumerable\n |> reduce([], fn x, acc -> [x, separator | acc] end)\n |> :lists.reverse()\n\n # Head is a superfluous separator\n case list do\n [] -> []\n [_ | t] -> t\n end\n end\n\n @doc \"\"\"\n Inserts the given `enumerable` into a `collectable`.\n\n Note that passing a non-empty list as the `collectable` is deprecated.\n If you're collecting into a non-empty keyword list, consider using\n `Keyword.merge(collectable, Enum.to_list(enumerable))`. If you're collecting\n into a non-empty list, consider something like `Enum.to_list(enumerable) ++ collectable`.\n\n ## Examples\n\n iex> Enum.into([1, 2], [])\n [1, 2]\n\n iex> Enum.into([a: 1, b: 2], %{})\n %{a: 1, b: 2}\n\n iex> Enum.into(%{a: 1}, %{b: 2})\n %{a: 1, b: 2}\n\n iex> Enum.into([a: 1, a: 2], %{})\n %{a: 2}\n\n iex> Enum.into([a: 2], %{a: 1, b: 3})\n %{a: 2, b: 3}\n\n \"\"\"\n @spec into(Enumerable.t(), Collectable.t()) :: Collectable.t()\n def into(enumerable, collectable)\n\n def into(enumerable, []) do\n to_list(enumerable)\n end\n\n def into(enumerable, collectable) when is_struct(collectable, MapSet) do\n if MapSet.size(collectable) == 0 do\n MapSet.new(enumerable)\n else\n MapSet.new(enumerable) |> MapSet.union(collectable)\n end\n end\n\n def into(%_{} = enumerable, collectable) do\n into_protocol(enumerable, collectable)\n end\n\n def into(enumerable, %_{} = collectable) do\n into_protocol(enumerable, collectable)\n end\n\n def into(enumerable, %{} = collectable) do\n if map_size(collectable) == 0 do\n into_map(enumerable)\n else\n into_map(enumerable, collectable)\n end\n end\n\n def into(enumerable, collectable) do\n into_protocol(enumerable, collectable)\n end\n\n defp into_map(%{} = enumerable), do: enumerable\n defp into_map(enumerable) when is_list(enumerable), do: :maps.from_list(enumerable)\n defp into_map(enumerable), do: enumerable |> Enum.to_list() |> :maps.from_list()\n\n defp into_map(%{} = enumerable, collectable), do: Map.merge(collectable, enumerable)\n\n defp into_map(enumerable, collectable) when is_list(enumerable),\n do: Map.merge(collectable, :maps.from_list(enumerable))\n\n defp into_map(enumerable, collectable),\n do: reduce(enumerable, collectable, fn {key, val}, acc -> Map.put(acc, key, val) end)\n\n defp into_protocol(enumerable, collectable) do\n {initial, fun} = Collectable.into(collectable)\n\n try do\n reduce_into_protocol(enumerable, initial, fun)\n catch\n kind, reason ->\n fun.(initial, :halt)\n :erlang.raise(kind, reason, __STACKTRACE__)\n else\n acc -> fun.(acc, :done)\n end\n end\n\n defp reduce_into_protocol(enumerable, initial, fun) when is_list(enumerable) do\n :lists.foldl(fn x, acc -> fun.(acc, {:cont, x}) end, initial, enumerable)\n end\n\n defp reduce_into_protocol(enumerable, initial, fun) do\n enumerable\n |> Enumerable.reduce({:cont, initial}, fn x, acc ->\n {:cont, fun.(acc, {:cont, x})}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Inserts the given `enumerable` into a `collectable` according to the\n transformation function.\n\n ## Examples\n\n iex> Enum.into([1, 2, 3], [], fn x -> x * 3 end)\n [3, 6, 9]\n\n iex> Enum.into(%{a: 1, b: 2}, %{c: 3}, fn {k, v} -> {k, v * 2} end)\n %{a: 2, b: 4, c: 3}\n\n \"\"\"\n @spec into(Enumerable.t(), Collectable.t(), (term -> term)) :: Collectable.t()\n def into(enumerable, [], transform) do\n map(enumerable, transform)\n end\n\n def into(enumerable, collectable, transform) when is_struct(collectable, MapSet) do\n if MapSet.size(collectable) == 0 do\n MapSet.new(enumerable, transform)\n else\n MapSet.new(enumerable, transform) |> MapSet.union(collectable)\n end\n end\n\n def into(enumerable, %_{} = collectable, transform) do\n into_protocol(enumerable, collectable, transform)\n end\n\n def into(enumerable, %{} = collectable, transform) do\n if map_size(collectable) == 0 do\n enumerable |> map(transform) |> :maps.from_list()\n else\n reduce(enumerable, collectable, fn entry, acc ->\n {key, val} = transform.(entry)\n Map.put(acc, key, val)\n end)\n end\n end\n\n def into(enumerable, collectable, transform) do\n into_protocol(enumerable, collectable, transform)\n end\n\n defp into_protocol(enumerable, collectable, transform) do\n {initial, fun} = Collectable.into(collectable)\n\n try do\n reduce_into_protocol(enumerable, initial, transform, fun)\n catch\n kind, reason ->\n fun.(initial, :halt)\n :erlang.raise(kind, reason, __STACKTRACE__)\n else\n acc -> fun.(acc, :done)\n end\n end\n\n defp reduce_into_protocol(enumerable, initial, transform, fun) when is_list(enumerable) do\n :lists.foldl(fn x, acc -> fun.(acc, {:cont, transform.(x)}) end, initial, enumerable)\n end\n\n defp reduce_into_protocol(enumerable, initial, transform, fun) do\n enumerable\n |> Enumerable.reduce({:cont, initial}, fn x, acc ->\n {:cont, fun.(acc, {:cont, transform.(x)})}\n end)\n |> elem(1)\n end\n\n @doc \"\"\"\n Joins the given `enumerable` into a string using `joiner` as a\n separator.\n\n If `joiner` is not passed at all, it defaults to an empty string.\n\n All elements in the `enumerable` must be convertible to a string\n or be a binary, otherwise an error is raised.\n\n ## Examples\n\n iex> Enum.join([1, 2, 3])\n \"123\"\n\n iex> Enum.join([1, 2, 3], \" = \")\n \"1 = 2 = 3\"\n\n iex> Enum.join([[\"a\", \"b\"], [\"c\", \"d\", \"e\", [\"f\", \"g\"]], \"h\", \"i\"], \" \")\n \"ab cdefg h i\"\n\n \"\"\"\n @spec join(t, binary()) :: binary()\n def join(enumerable, joiner \\\\ \"\")\n\n def join(enumerable, \"\") do\n enumerable\n |> map(&entry_to_string(&1))\n |> IO.iodata_to_binary()\n end\n\n def join(enumerable, joiner) when is_list(enumerable) and is_binary(joiner) do\n join_list(enumerable, joiner)\n end\n\n def join(enumerable, joiner) when is_binary(joiner) do\n reduced =\n reduce(enumerable, :first, fn\n entry, :first -> entry_to_string(entry)\n entry, acc -> [acc, joiner | entry_to_string(entry)]\n end)\n\n if reduced == :first do\n \"\"\n else\n IO.iodata_to_binary(reduced)\n end\n end\n\n @doc \"\"\"\n Returns a list where each element is the result of invoking\n `fun` on each corresponding element of `enumerable`.\n\n For maps, the function expects a key-value tuple.\n\n ## Examples\n\n iex> Enum.map([1, 2, 3], fn x -> x * 2 end)\n [2, 4, 6]\n\n iex> Enum.map([a: 1, b: 2], fn {k, v} -> {k, -v} end)\n [a: -1, b: -2]\n\n \"\"\"\n @spec map(t, (element -> any)) :: list\n def map(enumerable, fun)\n\n def map(enumerable, fun) when is_list(enumerable) do\n :lists.map(fun, enumerable)\n end\n\n def map(first..last//step, fun) do\n map_range(first, last, step, fun)\n end\n\n def map(enumerable, fun) do\n reduce(enumerable, [], R.map(fun)) |> :lists.reverse()\n end\n\n @doc \"\"\"\n Returns a list of results of invoking `fun` on every `nth`\n element of `enumerable`, starting with the first element.\n\n The first element is always passed to the given function, unless `nth` is `0`.\n\n The second argument specifying every `nth` element must be a non-negative\n integer.\n\n If `nth` is `0`, then `enumerable` is directly converted to a list,\n without `fun` being ever applied.\n\n ## Examples\n\n iex> Enum.map_every(1..10, 2, fn x -> x + 1000 end)\n [1001, 2, 1003, 4, 1005, 6, 1007, 8, 1009, 10]\n\n iex> Enum.map_every(1..10, 3, fn x -> x + 1000 end)\n [1001, 2, 3, 1004, 5, 6, 1007, 8, 9, 1010]\n\n iex> Enum.map_every(1..5, 0, fn x -> x + 1000 end)\n [1, 2, 3, 4, 5]\n\n iex> Enum.map_every([1, 2, 3], 1, fn x -> x + 1000 end)\n [1001, 1002, 1003]\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec map_every(t, non_neg_integer, (element -> any)) :: list\n def map_every(enumerable, nth, fun)\n\n def map_every(enumerable, 1, fun), do: map(enumerable, fun)\n def map_every(enumerable, 0, _fun), do: to_list(enumerable)\n def map_every([], nth, _fun) when is_integer(nth) and nth > 1, do: []\n\n def map_every(enumerable, nth, fun) when is_integer(nth) and nth > 1 do\n {res, _} = reduce(enumerable, {[], :first}, R.map_every(nth, fun))\n :lists.reverse(res)\n end\n\n @doc \"\"\"\n Maps and intersperses the given enumerable in one pass.\n\n ## Examples\n\n iex> Enum.map_intersperse([1, 2, 3], :a, &(&1 * 2))\n [2, :a, 4, :a, 6]\n \"\"\"\n @doc since: \"1.10.0\"\n @spec map_intersperse(t, element(), (element -> any())) :: list()\n def map_intersperse(enumerable, separator, mapper)\n\n def map_intersperse(enumerable, separator, mapper) when is_list(enumerable) do\n map_intersperse_list(enumerable, separator, mapper)\n end\n\n def map_intersperse(enumerable, separator, mapper) do\n reduced =\n reduce(enumerable, :first, fn\n entry, :first -> [mapper.(entry)]\n entry, acc -> [mapper.(entry), separator | acc]\n end)\n\n if reduced == :first do\n []\n else\n :lists.reverse(reduced)\n end\n end\n\n @doc \"\"\"\n Maps and joins the given `enumerable` in one pass.\n\n If `joiner` is not passed at all, it defaults to an empty string.\n\n All elements returned from invoking the `mapper` must be convertible to\n a string, otherwise an error is raised.\n\n ## Examples\n\n iex> Enum.map_join([1, 2, 3], &(&1 * 2))\n \"246\"\n\n iex> Enum.map_join([1, 2, 3], \" = \", &(&1 * 2))\n \"2 = 4 = 6\"\n\n \"\"\"\n @spec map_join(t, String.t(), (element -> String.Chars.t())) :: String.t()\n def map_join(enumerable, joiner \\\\ \"\", mapper) when is_binary(joiner) do\n enumerable\n |> map_intersperse(joiner, &entry_to_string(mapper.(&1)))\n |> IO.iodata_to_binary()\n end\n\n @doc \"\"\"\n Invokes the given function to each element in the `enumerable` to reduce\n it to a single element, while keeping an accumulator.\n\n Returns a tuple where the first element is the mapped enumerable and\n the second one is the final accumulator.\n\n The function, `fun`, receives two arguments: the first one is the\n element, and the second one is the accumulator. `fun` must return\n a tuple with two elements in the form of `{result, accumulator}`.\n\n For maps, the first tuple element must be a `{key, value}` tuple.\n\n ## Examples\n\n iex> Enum.map_reduce([1, 2, 3], 0, fn x, acc -> {x * 2, x + acc} end)\n {[2, 4, 6], 6}\n\n \"\"\"\n @spec map_reduce(t, acc, (element, acc -> {element, acc})) :: {list, acc}\n def map_reduce(enumerable, acc, fun) when is_list(enumerable) do\n :lists.mapfoldl(fun, acc, enumerable)\n end\n\n def map_reduce(enumerable, acc, fun) do\n {list, acc} =\n reduce(enumerable, {[], acc}, fn entry, {list, acc} ->\n {new_entry, acc} = fun.(entry, acc)\n {[new_entry | list], acc}\n end)\n\n {:lists.reverse(list), acc}\n end\n\n @doc false\n def max(list = [_ | _]), do: :lists.max(list)\n\n @doc false\n def max(list = [_ | _], empty_fallback) when is_function(empty_fallback, 0) do\n :lists.max(list)\n end\n\n @doc false\n @spec max(t, (-> empty_result)) :: element | empty_result when empty_result: any\n def max(enumerable, empty_fallback) when is_function(empty_fallback, 0) do\n max(enumerable, &>=/2, empty_fallback)\n end\n\n @doc \"\"\"\n Returns the maximal element in the `enumerable` according\n to Erlang's term ordering.\n\n By default, the comparison is done with the [`>=`](`>=/2`) sorter function.\n If multiple elements are considered maximal, the first one that\n was found is returned. If you want the last element considered\n maximal to be returned, the sorter function should not return true\n for equal elements.\n\n If the enumerable is empty, the provided `empty_fallback` is called.\n The default `empty_fallback` raises `Enum.EmptyError`.\n\n ## Examples\n\n iex> Enum.max([1, 2, 3])\n 3\n\n The fact this function uses Erlang's term ordering means that the comparison\n is structural and not semantic. For example:\n\n iex> Enum.max([~D[2017-03-31], ~D[2017-04-01]])\n ~D[2017-03-31]\n\n In the example above, `max/2` returned March 31st instead of April 1st\n because the structural comparison compares the day before the year.\n For this reason, most structs provide a \"compare\" function, such as\n `Date.compare/2`, which receives two structs and returns `:lt` (less-than),\n `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the\n sorting function, Elixir will automatically use the `compare/2` function\n of said module:\n\n iex> Enum.max([~D[2017-03-31], ~D[2017-04-01]], Date)\n ~D[2017-04-01]\n\n Finally, if you don't want to raise on empty enumerables, you can pass\n the empty fallback:\n\n iex> Enum.max([], &>=/2, fn -> 0 end)\n 0\n\n \"\"\"\n @spec max(t, (element, element -> boolean) | module()) ::\n element | empty_result\n when empty_result: any\n @spec max(t, (element, element -> boolean) | module(), (-> empty_result)) ::\n element | empty_result\n when empty_result: any\n def max(enumerable, sorter \\\\ &>=/2, empty_fallback \\\\ fn -> raise Enum.EmptyError end) do\n aggregate(enumerable, max_sort_fun(sorter), empty_fallback)\n end\n\n defp max_sort_fun(sorter) when is_function(sorter, 2), do: sorter\n defp max_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :lt)\n\n @doc false\n @spec max_by(\n t,\n (element -> any),\n (-> empty_result) | (element, element -> boolean) | module()\n ) :: element | empty_result\n when empty_result: any\n def max_by(enumerable, fun, empty_fallback)\n when is_function(fun, 1) and is_function(empty_fallback, 0) do\n max_by(enumerable, fun, &>=/2, empty_fallback)\n end\n\n @doc \"\"\"\n Returns the maximal element in the `enumerable` as calculated\n by the given `fun`.\n\n By default, the comparison is done with the [`>=`](`>=/2`) sorter function.\n If multiple elements are considered maximal, the first one that\n was found is returned. If you want the last element considered\n maximal to be returned, the sorter function should not return true\n for equal elements.\n\n Calls the provided `empty_fallback` function and returns its value if\n `enumerable` is empty. The default `empty_fallback` raises `Enum.EmptyError`.\n\n ## Examples\n\n iex> Enum.max_by([\"a\", \"aa\", \"aaa\"], fn x -> String.length(x) end)\n \"aaa\"\n\n iex> Enum.max_by([\"a\", \"aa\", \"aaa\", \"b\", \"bbb\"], &String.length/1)\n \"aaa\"\n\n The fact this function uses Erlang's term ordering means that the\n comparison is structural and not semantic. Therefore, if you want\n to compare structs, most structs provide a \"compare\" function, such as\n `Date.compare/2`, which receives two structs and returns `:lt` (less-than),\n `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the\n sorting function, Elixir will automatically use the `compare/2` function\n of said module:\n\n iex> users = [\n ...> %{name: \"Ellis\", birthday: ~D[1943-05-11]},\n ...> %{name: \"Lovelace\", birthday: ~D[1815-12-10]},\n ...> %{name: \"Turing\", birthday: ~D[1912-06-23]}\n ...> ]\n iex> Enum.max_by(users, &(&1.birthday), Date)\n %{name: \"Ellis\", birthday: ~D[1943-05-11]}\n\n Finally, if you don't want to raise on empty enumerables, you can pass\n the empty fallback:\n\n iex> Enum.max_by([], &String.length/1, fn -> nil end)\n nil\n\n \"\"\"\n @spec max_by(\n t,\n (element -> any),\n (element, element -> boolean) | module(),\n (-> empty_result)\n ) :: element | empty_result\n when empty_result: any\n def max_by(enumerable, fun, sorter \\\\ &>=/2, empty_fallback \\\\ fn -> raise Enum.EmptyError end)\n when is_function(fun, 1) do\n aggregate_by(enumerable, fun, max_sort_fun(sorter), empty_fallback)\n end\n\n @doc \"\"\"\n Checks if `element` exists within the `enumerable`.\n\n Membership is tested with the match (`===/2`) operator.\n\n ## Examples\n\n iex> Enum.member?(1..10, 5)\n true\n iex> Enum.member?(1..10, 5.0)\n false\n\n iex> Enum.member?([1.0, 2.0, 3.0], 2)\n false\n iex> Enum.member?([1.0, 2.0, 3.0], 2.000)\n true\n\n iex> Enum.member?([:a, :b, :c], :d)\n false\n\n\n When called outside guards, the [`in`](`in/2`) and [`not in`](`in/2`)\n operators work by using this function.\n \"\"\"\n @spec member?(t, element) :: boolean\n def member?(enumerable, element) when is_list(enumerable) do\n :lists.member(element, enumerable)\n end\n\n def member?(enumerable, element) do\n case Enumerable.member?(enumerable, element) do\n {:ok, element} when is_boolean(element) ->\n element\n\n {:error, module} ->\n module.reduce(enumerable, {:cont, false}, fn\n v, _ when v === element -> {:halt, true}\n _, _ -> {:cont, false}\n end)\n |> elem(1)\n end\n end\n\n @doc false\n def min(list = [_ | _]), do: :lists.min(list)\n\n @doc false\n def min(list = [_ | _], empty_fallback) when is_function(empty_fallback, 0) do\n :lists.min(list)\n end\n\n @doc false\n @spec min(t, (-> empty_result)) :: element | empty_result when empty_result: any\n def min(enumerable, empty_fallback) when is_function(empty_fallback, 0) do\n min(enumerable, &<=/2, empty_fallback)\n end\n\n @doc \"\"\"\n Returns the minimal element in the `enumerable` according\n to Erlang's term ordering.\n\n By default, the comparison is done with the [`<=`](`<=/2`) sorter function.\n If multiple elements are considered minimal, the first one that\n was found is returned. If you want the last element considered\n minimal to be returned, the sorter function should not return true\n for equal elements.\n\n If the enumerable is empty, the provided `empty_fallback` is called.\n The default `empty_fallback` raises `Enum.EmptyError`.\n\n ## Examples\n\n iex> Enum.min([1, 2, 3])\n 1\n\n The fact this function uses Erlang's term ordering means that the comparison\n is structural and not semantic. For example:\n\n iex> Enum.min([~D[2017-03-31], ~D[2017-04-01]])\n ~D[2017-04-01]\n\n In the example above, `min/2` returned April 1st instead of March 31st\n because the structural comparison compares the day before the year.\n For this reason, most structs provide a \"compare\" function, such as\n `Date.compare/2`, which receives two structs and returns `:lt` (less-than),\n `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the\n sorting function, Elixir will automatically use the `compare/2` function\n of said module:\n\n iex> Enum.min([~D[2017-03-31], ~D[2017-04-01]], Date)\n ~D[2017-03-31]\n\n Finally, if you don't want to raise on empty enumerables, you can pass\n the empty fallback:\n\n iex> Enum.min([], fn -> 0 end)\n 0\n\n \"\"\"\n @spec min(t, (element, element -> boolean) | module()) ::\n element | empty_result\n when empty_result: any\n @spec min(t, (element, element -> boolean) | module(), (-> empty_result)) ::\n element | empty_result\n when empty_result: any\n def min(enumerable, sorter \\\\ &<=/2, empty_fallback \\\\ fn -> raise Enum.EmptyError end) do\n aggregate(enumerable, min_sort_fun(sorter), empty_fallback)\n end\n\n defp min_sort_fun(sorter) when is_function(sorter, 2), do: sorter\n defp min_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :gt)\n\n @doc false\n @spec min_by(\n t,\n (element -> any),\n (-> empty_result) | (element, element -> boolean) | module()\n ) :: element | empty_result\n when empty_result: any\n def min_by(enumerable, fun, empty_fallback)\n when is_function(fun, 1) and is_function(empty_fallback, 0) do\n min_by(enumerable, fun, &<=/2, empty_fallback)\n end\n\n @doc \"\"\"\n Returns the minimal element in the `enumerable` as calculated\n by the given `fun`.\n\n By default, the comparison is done with the [`<=`](`<=/2`) sorter function.\n If multiple elements are considered minimal, the first one that\n was found is returned. If you want the last element considered\n minimal to be returned, the sorter function should not return true\n for equal elements.\n\n Calls the provided `empty_fallback` function and returns its value if\n `enumerable` is empty. The default `empty_fallback` raises `Enum.EmptyError`.\n\n ## Examples\n\n iex> Enum.min_by([\"a\", \"aa\", \"aaa\"], fn x -> String.length(x) end)\n \"a\"\n\n iex> Enum.min_by([\"a\", \"aa\", \"aaa\", \"b\", \"bbb\"], &String.length/1)\n \"a\"\n\n The fact this function uses Erlang's term ordering means that the\n comparison is structural and not semantic. Therefore, if you want\n to compare structs, most structs provide a \"compare\" function, such as\n `Date.compare/2`, which receives two structs and returns `:lt` (less-than),\n `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the\n sorting function, Elixir will automatically use the `compare/2` function\n of said module:\n\n iex> users = [\n ...> %{name: \"Ellis\", birthday: ~D[1943-05-11]},\n ...> %{name: \"Lovelace\", birthday: ~D[1815-12-10]},\n ...> %{name: \"Turing\", birthday: ~D[1912-06-23]}\n ...> ]\n iex> Enum.min_by(users, &(&1.birthday), Date)\n %{name: \"Lovelace\", birthday: ~D[1815-12-10]}\n\n Finally, if you don't want to raise on empty enumerables, you can pass\n the empty fallback:\n\n iex> Enum.min_by([], &String.length/1, fn -> nil end)\n nil\n\n \"\"\"\n @spec min_by(\n t,\n (element -> any),\n (element, element -> boolean) | module(),\n (-> empty_result)\n ) :: element | empty_result\n when empty_result: any\n def min_by(enumerable, fun, sorter \\\\ &<=/2, empty_fallback \\\\ fn -> raise Enum.EmptyError end)\n when is_function(fun, 1) do\n aggregate_by(enumerable, fun, min_sort_fun(sorter), empty_fallback)\n end\n\n @doc \"\"\"\n Returns a tuple with the minimal and the maximal elements in the\n enumerable.\n\n By default, the comparison is done with the [`<`](` Enum.min_max([2, 3, 1])\n {1, 3}\n\n iex> Enum.min_max([\"foo\", \"bar\", \"baz\"])\n {\"bar\", \"foo\"}\n\n iex> Enum.min_max([], fn -> {nil, nil} end)\n {nil, nil}\n\n The fact this function uses Erlang's term ordering means that the\n comparison is structural and not semantic. Therefore, if you want\n to compare structs, most structs provide a \"compare\" function, such as\n `Date.compare/2`, which receives two structs and returns `:lt` (less-than),\n `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the\n sorting function, Elixir will automatically use the `compare/2` function\n of said module:\n\n iex> dates = [\n ...> ~D[2019-01-01],\n ...> ~D[2020-01-01],\n ...> ~D[2018-01-01]\n ...> ]\n iex> Enum.min_max(dates, Date)\n {~D[2018-01-01], ~D[2020-01-01]}\n\n You can also pass a custom sorting function:\n\n iex> Enum.min_max([2, 3, 1], &>/2)\n {3, 1}\n\n Finally, if you don't want to raise on empty enumerables, you can pass\n the empty fallback:\n\n iex> Enum.min_max([], fn -> nil end)\n nil\n\n \"\"\"\n @spec min_max(t, (element, element -> boolean) | module()) :: {element, element}\n @spec min_max(t, (-> empty_result)) :: {element, element} | empty_result when empty_result: any\n @spec min_max(t, (element, element -> boolean) | module(), (-> empty_result)) ::\n {element, element} | empty_result\n when empty_result: any\n\n def min_max(enumerable, sorter_or_empty_fallback \\\\ fn -> raise Enum.EmptyError end)\n\n def min_max(first..last//step = range, empty_fallback)\n when is_function(empty_fallback, 0) do\n case Range.size(range) do\n 0 ->\n empty_fallback.()\n\n _ ->\n last = last - rem(last - first, step)\n {Kernel.min(first, last), Kernel.max(first, last)}\n end\n end\n\n def min_max(enumerable, empty_fallback)\n when is_function(empty_fallback, 0) do\n min_max(enumerable, & raise Enum.EmptyError end)\n end\n\n def min_max(enumerable, sorter, empty_fallback)\n when is_atom(sorter) and is_function(empty_fallback, 0) do\n min_max(enumerable, min_max_sort_fun(sorter), empty_fallback)\n end\n\n def min_max(enumerable, sorter, empty_fallback)\n when is_function(sorter, 2) and is_function(empty_fallback, 0) do\n first_fun = &[&1 | &1]\n\n reduce_fun = fn entry, [min | max] = acc ->\n cond do\n sorter.(entry, min) ->\n [entry | max]\n\n sorter.(max, entry) ->\n [min | entry]\n\n true ->\n acc\n end\n end\n\n case reduce_by(enumerable, first_fun, reduce_fun) do\n :empty -> empty_fallback.()\n [min | max] -> {min, max}\n end\n end\n\n @doc false\n @spec min_max_by(t, (element -> any), (-> empty_result)) :: {element, element} | empty_result\n when empty_result: any\n def min_max_by(enumerable, fun, empty_fallback)\n when is_function(fun, 1) and is_function(empty_fallback, 0) do\n min_max_by(enumerable, fun, & Enum.min_max_by([\"aaa\", \"bb\", \"c\"], fn x -> String.length(x) end)\n {\"c\", \"aaa\"}\n\n iex> Enum.min_max_by([\"aaa\", \"a\", \"bb\", \"c\", \"ccc\"], &String.length/1)\n {\"a\", \"aaa\"}\n\n iex> Enum.min_max_by([], &String.length/1, fn -> {nil, nil} end)\n {nil, nil}\n\n The fact this function uses Erlang's term ordering means that the\n comparison is structural and not semantic. Therefore, if you want\n to compare structs, most structs provide a \"compare\" function, such as\n `Date.compare/2`, which receives two structs and returns `:lt` (less-than),\n `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the\n sorting function, Elixir will automatically use the `compare/2` function\n of said module:\n\n iex> users = [\n ...> %{name: \"Ellis\", birthday: ~D[1943-05-11]},\n ...> %{name: \"Lovelace\", birthday: ~D[1815-12-10]},\n ...> %{name: \"Turing\", birthday: ~D[1912-06-23]}\n ...> ]\n iex> Enum.min_max_by(users, &(&1.birthday), Date)\n {\n %{name: \"Lovelace\", birthday: ~D[1815-12-10]},\n %{name: \"Ellis\", birthday: ~D[1943-05-11]}\n }\n\n Finally, if you don't want to raise on empty enumerables, you can pass\n the empty fallback:\n\n iex> Enum.min_max_by([], &String.length/1, fn -> nil end)\n nil\n\n \"\"\"\n @spec min_max_by(t, (element -> any), (element, element -> boolean) | module()) ::\n {element, element} | empty_result\n when empty_result: any\n @spec min_max_by(\n t,\n (element -> any),\n (element, element -> boolean) | module(),\n (-> empty_result)\n ) :: {element, element} | empty_result\n when empty_result: any\n def min_max_by(\n enumerable,\n fun,\n sorter_or_empty_fallback \\\\ & raise Enum.EmptyError end\n )\n\n def min_max_by(enumerable, fun, sorter, empty_fallback)\n when is_function(fun, 1) and is_atom(sorter) and is_function(empty_fallback, 0) do\n min_max_by(enumerable, fun, min_max_sort_fun(sorter), empty_fallback)\n end\n\n def min_max_by(enumerable, fun, sorter, empty_fallback)\n when is_function(fun, 1) and is_function(sorter, 2) and is_function(empty_fallback, 0) do\n first_fun = fn entry ->\n fun_entry = fun.(entry)\n {entry, entry, fun_entry, fun_entry}\n end\n\n reduce_fun = fn entry, {prev_min, prev_max, fun_min, fun_max} = acc ->\n fun_entry = fun.(entry)\n\n cond do\n sorter.(fun_entry, fun_min) ->\n {entry, prev_max, fun_entry, fun_max}\n\n sorter.(fun_max, fun_entry) ->\n {prev_min, entry, fun_min, fun_entry}\n\n true ->\n acc\n end\n end\n\n case reduce_by(enumerable, first_fun, reduce_fun) do\n :empty -> empty_fallback.()\n {min, max, _, _} -> {min, max}\n end\n end\n\n defp min_max_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) == :lt)\n\n @doc \"\"\"\n Splits the `enumerable` in two lists according to the given function `fun`.\n\n Splits the given `enumerable` in two lists by calling `fun` with each element\n in the `enumerable` as its only argument. Returns a tuple with the first list\n containing all the elements in `enumerable` for which applying `fun` returned\n a truthy value, and a second list with all the elements for which applying\n `fun` returned a falsy value (`false` or `nil`).\n\n The elements in both the returned lists are in the same relative order as they\n were in the original enumerable (if such enumerable was ordered, like a\n list). See the examples below.\n\n ## Examples\n\n iex> Enum.split_with([5, 4, 3, 2, 1, 0], fn x -> rem(x, 2) == 0 end)\n {[4, 2, 0], [5, 3, 1]}\n\n iex> Enum.split_with([a: 1, b: -2, c: 1, d: -3], fn {_k, v} -> v < 0 end)\n {[b: -2, d: -3], [a: 1, c: 1]}\n\n iex> Enum.split_with([a: 1, b: -2, c: 1, d: -3], fn {_k, v} -> v > 50 end)\n {[], [a: 1, b: -2, c: 1, d: -3]}\n\n iex> Enum.split_with([], fn {_k, v} -> v > 50 end)\n {[], []}\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec split_with(t, (element -> as_boolean(term))) :: {list, list}\n def split_with(enumerable, fun) do\n {acc1, acc2} =\n reduce(enumerable, {[], []}, fn entry, {acc1, acc2} ->\n if fun.(entry) do\n {[entry | acc1], acc2}\n else\n {acc1, [entry | acc2]}\n end\n end)\n\n {:lists.reverse(acc1), :lists.reverse(acc2)}\n end\n\n @doc false\n @deprecated \"Use Enum.split_with/2 instead\"\n def partition(enumerable, fun) do\n split_with(enumerable, fun)\n end\n\n @doc \"\"\"\n Returns a random element of an `enumerable`.\n\n Raises `Enum.EmptyError` if `enumerable` is empty.\n\n This function uses Erlang's [`:rand` module](`:rand`) to calculate\n the random value. Check its documentation for setting a\n different random algorithm or a different seed.\n\n If a range is passed into the function, this function will pick a\n random value between the range limits, without traversing the whole\n range (thus executing in constant time and constant memory).\n\n ## Examples\n\n The examples below use the `:exsss` pseudorandom algorithm since it's\n the default from Erlang/OTP 22:\n\n # Although not necessary, let's seed the random algorithm\n iex> :rand.seed(:exsss, {100, 101, 102})\n iex> Enum.random([1, 2, 3])\n 2\n iex> Enum.random([1, 2, 3])\n 1\n iex> Enum.random(1..1_000)\n 309\n\n ## Implementation\n\n The random functions in this module implement reservoir sampling,\n which allows them to sample infinite collections. In particular,\n we implement Algorithm L, as described in by Kim-Hung Li in\n \"Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))\".\n \"\"\"\n @spec random(t) :: element\n def random(enumerable)\n\n def random(enumerable) when is_list(enumerable) do\n case length(enumerable) do\n 0 -> raise Enum.EmptyError\n length -> enumerable |> drop_list(random_count(length)) |> hd()\n end\n end\n\n def random(first.._//step = range) do\n case Range.size(range) do\n 0 -> raise Enum.EmptyError\n size -> first + random_count(size) * step\n end\n end\n\n def random(enumerable) do\n result =\n case Enumerable.slice(enumerable) do\n {:ok, 0, _} ->\n []\n\n {:ok, count, fun} when is_function(fun, 1) ->\n slice_list(fun.(enumerable), random_count(count), 1, 1)\n\n {:ok, count, fun} when is_function(fun, 3) ->\n fun.(random_count(count), 1, 1)\n\n # TODO: Remove me on v2.0\n {:ok, count, fun} when is_function(fun, 2) ->\n IO.warn(\n \"#{inspect(Enumerable.impl_for(enumerable))} must return a three arity function on slice/1\"\n )\n\n fun.(random_count(count), 1)\n\n {:error, _} ->\n take_random(enumerable, 1)\n end\n\n case result do\n [] -> raise Enum.EmptyError\n [elem] -> elem\n end\n end\n\n defp random_count(count) do\n :rand.uniform(count) - 1\n end\n\n @doc \"\"\"\n Invokes `fun` for each element in the `enumerable` with the\n accumulator.\n\n Raises `Enum.EmptyError` if `enumerable` is empty.\n\n The first element of the `enumerable` is used as the initial value\n of the accumulator. Then, the function is invoked with the next\n element and the accumulator. The result returned by the function\n is used as the accumulator for the next iteration, recursively.\n When the `enumerable` is done, the last accumulator is returned.\n\n Since the first element of the enumerable is used as the initial\n value of the accumulator, `fun` will only be executed `n - 1` times\n where `n` is the length of the enumerable. This function won't call\n the specified function for enumerables that are one-element long.\n\n If you wish to use another value for the accumulator, use\n `Enum.reduce/3`.\n\n ## Examples\n\n iex> Enum.reduce([1, 2, 3, 4], fn x, acc -> x * acc end)\n 24\n\n \"\"\"\n @spec reduce(t, (element, acc -> acc)) :: acc\n def reduce(enumerable, fun)\n\n def reduce([h | t], fun) do\n reduce(t, h, fun)\n end\n\n def reduce([], _fun) do\n raise Enum.EmptyError\n end\n\n def reduce(enumerable, fun) do\n Enumerable.reduce(enumerable, {:cont, :first}, fn\n x, {:acc, acc} -> {:cont, {:acc, fun.(x, acc)}}\n x, :first -> {:cont, {:acc, x}}\n end)\n |> elem(1)\n |> case do\n :first -> raise Enum.EmptyError\n {:acc, acc} -> acc\n end\n end\n\n @doc \"\"\"\n Invokes `fun` for each element in the `enumerable` with the accumulator.\n\n The initial value of the accumulator is `acc`. The function is invoked for\n each element in the enumerable with the accumulator. The result returned\n by the function is used as the accumulator for the next iteration.\n The function returns the last accumulator.\n\n ## Examples\n\n iex> Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end)\n 6\n\n iex> Enum.reduce(%{a: 2, b: 3, c: 4}, 0, fn {_key, val}, acc -> acc + val end)\n 9\n\n ## Reduce as a building block\n\n Reduce (sometimes called `fold`) is a basic building block in functional\n programming. Almost all of the functions in the `Enum` module can be\n implemented on top of reduce. Those functions often rely on other operations,\n such as `Enum.reverse/1`, which are optimized by the runtime.\n\n For example, we could implement `map/2` in terms of `reduce/3` as follows:\n\n def my_map(enumerable, fun) do\n enumerable\n |> Enum.reduce([], fn x, acc -> [fun.(x) | acc] end)\n |> Enum.reverse()\n end\n\n In the example above, `Enum.reduce/3` accumulates the result of each call\n to `fun` into a list in reverse order, which is correctly ordered at the\n end by calling `Enum.reverse/1`.\n\n Implementing functions like `map/2`, `filter/2` and others are a good\n exercise for understanding the power behind `Enum.reduce/3`. When an\n operation cannot be expressed by any of the functions in the `Enum`\n module, developers will most likely resort to `reduce/3`.\n \"\"\"\n @spec reduce(t, acc, (element, acc -> acc)) :: acc\n def reduce(enumerable, acc, fun) when is_list(enumerable) do\n :lists.foldl(fun, acc, enumerable)\n end\n\n def reduce(first..last//step, acc, fun) do\n reduce_range(first, last, step, acc, fun)\n end\n\n def reduce(%_{} = enumerable, acc, fun) do\n reduce_enumerable(enumerable, acc, fun)\n end\n\n def reduce(%{} = enumerable, acc, fun) do\n :maps.fold(fn k, v, acc -> fun.({k, v}, acc) end, acc, enumerable)\n end\n\n def reduce(enumerable, acc, fun) do\n reduce_enumerable(enumerable, acc, fun)\n end\n\n @doc \"\"\"\n Reduces `enumerable` until `fun` returns `{:halt, term}`.\n\n The return value for `fun` is expected to be\n\n * `{:cont, acc}` to continue the reduction with `acc` as the new\n accumulator or\n * `{:halt, acc}` to halt the reduction\n\n If `fun` returns `{:halt, acc}` the reduction is halted and the function\n returns `acc`. Otherwise, if the enumerable is exhausted, the function returns\n the accumulator of the last `{:cont, acc}`.\n\n ## Examples\n\n iex> Enum.reduce_while(1..100, 0, fn x, acc ->\n ...> if x < 5 do\n ...> {:cont, acc + x}\n ...> else\n ...> {:halt, acc}\n ...> end\n ...> end)\n 10\n iex> Enum.reduce_while(1..100, 0, fn x, acc ->\n ...> if x > 0 do\n ...> {:cont, acc + x}\n ...> else\n ...> {:halt, acc}\n ...> end\n ...> end)\n 5050\n\n \"\"\"\n @spec reduce_while(t, any, (element, any -> {:cont, any} | {:halt, any})) :: any\n def reduce_while(enumerable, acc, fun) do\n Enumerable.reduce(enumerable, {:cont, acc}, fun) |> elem(1)\n end\n\n @doc \"\"\"\n Returns a list of elements in `enumerable` excluding those for which the function `fun` returns\n a truthy value.\n\n See also `filter/2`.\n\n ## Examples\n\n iex> Enum.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end)\n [1, 3]\n\n \"\"\"\n @spec reject(t, (element -> as_boolean(term))) :: list\n def reject(enumerable, fun) when is_list(enumerable) do\n reject_list(enumerable, fun)\n end\n\n def reject(enumerable, fun) do\n reduce(enumerable, [], R.reject(fun)) |> :lists.reverse()\n end\n\n @doc \"\"\"\n Returns a list of elements in `enumerable` in reverse order.\n\n ## Examples\n\n iex> Enum.reverse([1, 2, 3])\n [3, 2, 1]\n\n \"\"\"\n @spec reverse(t) :: list\n def reverse(enumerable)\n\n def reverse([]), do: []\n def reverse([_] = list), do: list\n def reverse([element1, element2]), do: [element2, element1]\n def reverse([element1, element2 | rest]), do: :lists.reverse(rest, [element2, element1])\n def reverse(enumerable), do: reduce(enumerable, [], &[&1 | &2])\n\n @doc \"\"\"\n Reverses the elements in `enumerable`, appends the `tail`, and returns\n it as a list.\n\n This is an optimization for\n `enumerable |> Enum.reverse() |> Enum.concat(tail)`.\n\n ## Examples\n\n iex> Enum.reverse([1, 2, 3], [4, 5, 6])\n [3, 2, 1, 4, 5, 6]\n\n \"\"\"\n @spec reverse(t, t) :: list\n def reverse(enumerable, tail) when is_list(enumerable) do\n :lists.reverse(enumerable, to_list(tail))\n end\n\n def reverse(enumerable, tail) do\n reduce(enumerable, to_list(tail), fn entry, acc ->\n [entry | acc]\n end)\n end\n\n @doc \"\"\"\n Reverses the `enumerable` in the range from initial `start_index`\n through `count` elements.\n\n If `count` is greater than the size of the rest of the `enumerable`,\n then this function will reverse the rest of the enumerable.\n\n ## Examples\n\n iex> Enum.reverse_slice([1, 2, 3, 4, 5, 6], 2, 4)\n [1, 2, 6, 5, 4, 3]\n\n \"\"\"\n @spec reverse_slice(t, non_neg_integer, non_neg_integer) :: list\n def reverse_slice(enumerable, start_index, count)\n when is_integer(start_index) and start_index >= 0 and is_integer(count) and count >= 0 do\n list = reverse(enumerable)\n length = length(list)\n count = Kernel.min(count, length - start_index)\n\n if count > 0 do\n reverse_slice(list, length, start_index + count, count, [])\n else\n :lists.reverse(list)\n end\n end\n\n @doc \"\"\"\n Slides a single or multiple elements given by `range_or_single_index` from `enumerable`\n to `insertion_index`.\n\n The semantics of the range to be moved match the semantics of `Enum.slice/2`.\n Specifically, that means:\n\n * Indices are normalized, meaning that negative indexes will be counted from the end\n (for example, -1 means the last element of the enumerable). This will result in *two*\n traversals of your enumerable on types like lists that don't provide a constant-time count.\n\n * If the normalized index range's `last` is out of bounds, the range is truncated to the last element.\n\n * If the normalized index range's `first` is out of bounds, the selected range for sliding\n will be empty, so you'll get back your input list.\n\n * Decreasing ranges (such as `5..0//1`) also select an empty range to be moved,\n so you'll get back your input list.\n\n * Ranges with any step but 1 will raise an error.\n\n ## Examples\n\n # Slide a single element\n iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 5, 1)\n [:a, :f, :b, :c, :d, :e, :g]\n\n # Slide a range of elements towards the head of the list\n iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 3..5, 1)\n [:a, :d, :e, :f, :b, :c, :g]\n\n # Slide a range of elements towards the tail of the list\n iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 1..3, 5)\n [:a, :e, :f, :b, :c, :d, :g]\n\n # Slide with negative indices (counting from the end)\n iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 3..-1//1, 2)\n [:a, :b, :d, :e, :f, :g, :c]\n iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], -4..-2, 1)\n [:a, :d, :e, :f, :b, :c, :g]\n\n # Insert at negative indices (counting from the end)\n iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 3, -1)\n [:a, :b, :c, :e, :f, :g, :d]\n\n \"\"\"\n @doc since: \"1.13.0\"\n @spec slide(t, Range.t() | index, index) :: list\n def slide(enumerable, range_or_single_index, insertion_index)\n\n def slide(enumerable, single_index, insertion_index) when is_integer(single_index) do\n slide(enumerable, single_index..single_index, insertion_index)\n end\n\n # This matches the behavior of Enum.slice/2\n def slide(_, _.._//step = index_range, _insertion_index) when step != 1 do\n raise ArgumentError,\n \"Enum.slide/3 does not accept ranges with custom steps, got: #{inspect(index_range)}\"\n end\n\n # Normalize negative input ranges like Enum.slice/2\n def slide(enumerable, first..last//_, insertion_index)\n when first < 0 or last < 0 or insertion_index < 0 do\n count = Enum.count(enumerable)\n normalized_first = if first >= 0, do: first, else: Kernel.max(first + count, 0)\n normalized_last = if last >= 0, do: last, else: last + count\n\n normalized_insertion_index =\n if insertion_index >= 0, do: insertion_index, else: insertion_index + count\n\n if normalized_first < count and normalized_first != normalized_insertion_index do\n normalized_range = normalized_first..normalized_last//1\n slide(enumerable, normalized_range, normalized_insertion_index)\n else\n Enum.to_list(enumerable)\n end\n end\n\n def slide(enumerable, insertion_index.._//_, insertion_index) do\n Enum.to_list(enumerable)\n end\n\n def slide(_, first..last//_, insertion_index)\n when insertion_index > first and insertion_index <= last do\n raise ArgumentError,\n \"insertion index for slide must be outside the range being moved \" <>\n \"(tried to insert #{first}..#{last} at #{insertion_index})\"\n end\n\n def slide(enumerable, first..last//_, _insertion_index) when first > last do\n Enum.to_list(enumerable)\n end\n\n # Guarantees at this point: step size == 1 and first <= last and (insertion_index < first or insertion_index > last)\n def slide(enumerable, first..last//_, insertion_index) do\n impl = if is_list(enumerable), do: &slide_list_start/4, else: &slide_any/4\n\n cond do\n insertion_index <= first -> impl.(enumerable, insertion_index, first, last)\n insertion_index > last -> impl.(enumerable, first, last + 1, insertion_index)\n end\n end\n\n # Takes the range from middle..last and moves it to be in front of index start\n defp slide_any(enumerable, start, middle, last) do\n # We're going to deal with 4 \"chunks\" of the enumerable:\n # 0. \"Head,\" before the start index\n # 1. \"Slide back,\" between start (inclusive) and middle (exclusive)\n # 2. \"Slide front,\" between middle (inclusive) and last (inclusive)\n # 3. \"Tail,\" after last\n #\n # But, we're going to accumulate these into only two lists: pre and post.\n # We'll reverse-accumulate the head into our pre list, then \"slide back\" into post,\n # then \"slide front\" into pre, then \"tail\" into post.\n #\n # Then at the end, we're going to reassemble and reverse them, and end up with the\n # chunks in the correct order.\n {_size, pre, post} =\n reduce(enumerable, {0, [], []}, fn item, {index, pre, post} ->\n {pre, post} =\n cond do\n index < start -> {[item | pre], post}\n index >= start and index < middle -> {pre, [item | post]}\n index >= middle and index <= last -> {[item | pre], post}\n true -> {pre, [item | post]}\n end\n\n {index + 1, pre, post}\n end)\n\n :lists.reverse(pre, :lists.reverse(post))\n end\n\n # Like slide_any/4 above, this optimized implementation of slide for lists depends\n # on the indices being sorted such that we're moving middle..last to be in front of start.\n defp slide_list_start([h | t], start, middle, last)\n when start > 0 and start <= middle and middle <= last do\n [h | slide_list_start(t, start - 1, middle - 1, last - 1)]\n end\n\n defp slide_list_start(list, 0, middle, last), do: slide_list_middle(list, middle, last, [])\n defp slide_list_start([], _start, _middle, _last), do: []\n\n defp slide_list_middle([h | t], middle, last, acc) when middle > 0 do\n slide_list_middle(t, middle - 1, last - 1, [h | acc])\n end\n\n defp slide_list_middle(list, 0, last, start_to_middle) do\n {slid_range, tail} = slide_list_last(list, last + 1, [])\n slid_range ++ :lists.reverse(start_to_middle, tail)\n end\n\n # You asked for a middle index off the end of the list... you get what we've got\n defp slide_list_middle([], _, _, acc) do\n :lists.reverse(acc)\n end\n\n defp slide_list_last([h | t], last, acc) when last > 0 do\n slide_list_last(t, last - 1, [h | acc])\n end\n\n defp slide_list_last(rest, 0, acc) do\n {:lists.reverse(acc), rest}\n end\n\n defp slide_list_last([], _, acc) do\n {:lists.reverse(acc), []}\n end\n\n @doc \"\"\"\n Passes each element from `enumerable` to the `fun` as the first argument,\n stores the `fun` result in a list and passes the result as the second argument\n for the next computation.\n\n The `fun` isn't applied for the first element of the `enumerable`,\n the element is taken as it is.\n\n ## Examples\n\n iex> Enum.scan([\"a\", \"b\", \"c\", \"d\", \"e\"], fn element, acc -> element <> String.first(acc) end)\n [\"a\", \"ba\", \"cb\", \"dc\", \"ed\"]\n\n iex> Enum.scan(1..5, fn element, acc -> element + acc end)\n [1, 3, 6, 10, 15]\n\n \"\"\"\n @spec scan(t, (element, any -> any)) :: list\n def scan(enumerable, fun)\n\n def scan([], _fun), do: []\n\n def scan([elem | rest], fun) do\n scanned = scan_list(rest, elem, fun)\n [elem | scanned]\n end\n\n def scan(enumerable, fun) do\n {res, _} = reduce(enumerable, {[], :first}, R.scan2(fun))\n :lists.reverse(res)\n end\n\n @doc \"\"\"\n Passes each element from `enumerable` to the `fun` as the first argument,\n stores the `fun` result in a list and passes the result as the second argument\n for the next computation.\n\n Passes the given `acc` as the second argument for the `fun` with the first element.\n\n ## Examples\n\n iex> Enum.scan([\"a\", \"b\", \"c\", \"d\", \"e\"], \"_\", fn element, acc -> element <> String.first(acc) end)\n [\"a_\", \"ba\", \"cb\", \"dc\", \"ed\"]\n\n iex> Enum.scan(1..5, 0, fn element, acc -> element + acc end)\n [1, 3, 6, 10, 15]\n\n \"\"\"\n @spec scan(t, any, (element, any -> any)) :: list\n def scan(enumerable, acc, fun) when is_list(enumerable) do\n scan_list(enumerable, acc, fun)\n end\n\n def scan(enumerable, acc, fun) do\n {res, _} = reduce(enumerable, {[], acc}, R.scan3(fun))\n :lists.reverse(res)\n end\n\n @doc \"\"\"\n Returns a list with the elements of `enumerable` shuffled.\n\n This function uses Erlang's [`:rand` module](`:rand`) to calculate\n the random value. Check its documentation for setting a\n different random algorithm or a different seed.\n\n ## Examples\n\n The examples below use the `:exsss` pseudorandom algorithm since it's\n the default from Erlang/OTP 22:\n\n # Although not necessary, let's seed the random algorithm\n iex> :rand.seed(:exsss, {11, 22, 33})\n iex> Enum.shuffle([1, 2, 3])\n [2, 1, 3]\n iex> Enum.shuffle([1, 2, 3])\n [2, 3, 1]\n\n \"\"\"\n @spec shuffle(t) :: list\n def shuffle(enumerable) do\n randomized =\n reduce(enumerable, [], fn x, acc ->\n [{:rand.uniform(), x} | acc]\n end)\n\n shuffle_unwrap(:lists.keysort(1, randomized))\n end\n\n defp shuffle_unwrap([{_, h} | rest]), do: [h | shuffle_unwrap(rest)]\n defp shuffle_unwrap([]), do: []\n\n @doc \"\"\"\n Returns a subset list of the given `enumerable` by `index_range`.\n\n `index_range` must be a `Range`. Given an `enumerable`, it drops\n elements before `index_range.first` (zero-base), then it takes elements\n until element `index_range.last` (inclusively).\n\n Indexes are normalized, meaning that negative indexes will be counted\n from the end (for example, `-1` means the last element of the `enumerable`).\n\n If `index_range.last` is out of bounds, then it is assigned as the index\n of the last element.\n\n If the normalized `index_range.first` is out of bounds of the given\n `enumerable`, or this one is greater than the normalized `index_range.last`,\n then `[]` is returned.\n\n If a step `n` (other than `1`) is used in `index_range`, then it takes\n every `n`th element from `index_range.first` to `index_range.last`\n (according to the same rules described above).\n\n ## Examples\n\n iex> Enum.slice([1, 2, 3, 4, 5], 1..3)\n [2, 3, 4]\n\n iex> Enum.slice([1, 2, 3, 4, 5], 3..10)\n [4, 5]\n\n # Last three elements (negative indexes)\n iex> Enum.slice([1, 2, 3, 4, 5], -3..-1)\n [3, 4, 5]\n\n For ranges where `start > stop`, you need to explicit\n mark them as increasing:\n\n iex> Enum.slice([1, 2, 3, 4, 5], 1..-2//1)\n [2, 3, 4]\n\n The step can be any positive number. For example, to\n get every 2 elements of the collection:\n\n iex> Enum.slice([1, 2, 3, 4, 5], 0..-1//2)\n [1, 3, 5]\n\n To get every third element of the first ten elements:\n\n iex> integers = Enum.to_list(1..20)\n iex> Enum.slice(integers, 0..9//3)\n [1, 4, 7, 10]\n\n If the first position is after the end of the enumerable\n or after the last position of the range, it returns an\n empty list:\n\n iex> Enum.slice([1, 2, 3, 4, 5], 6..10)\n []\n\n # first is greater than last\n iex> Enum.slice([1, 2, 3, 4, 5], 6..5//1)\n []\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec slice(t, Range.t()) :: list\n def slice(enumerable, first..last//step = index_range) do\n # TODO: Support negative steps as a reverse on Elixir v2.0.\n cond do\n step > 0 ->\n slice_range(enumerable, first, last, step)\n\n step == -1 and first > last ->\n IO.warn(\n \"negative steps are not supported in Enum.slice/2, pass #{first}..#{last}//1 instead\"\n )\n\n slice_range(enumerable, first, last, 1)\n\n true ->\n raise ArgumentError,\n \"Enum.slice/2 does not accept ranges with negative steps, got: #{inspect(index_range)}\"\n end\n end\n\n # TODO: Remove me on v2.0\n def slice(enumerable, %{__struct__: Range, first: first, last: last} = index_range) do\n step = if first <= last, do: 1, else: -1\n slice(enumerable, Map.put(index_range, :step, step))\n end\n\n defp slice_range(enumerable, first, -1, step) when first >= 0 do\n if step == 1 do\n drop(enumerable, first)\n else\n enumerable |> drop(first) |> take_every_list(step - 1)\n end\n end\n\n defp slice_range(enumerable, first, last, step)\n when last >= first and last >= 0 and first >= 0 do\n slice_forward(enumerable, first, last - first + 1, step)\n end\n\n defp slice_range(enumerable, first, last, step) do\n {count, fun} = slice_count_and_fun(enumerable, step)\n first = if first >= 0, do: first, else: Kernel.max(first + count, 0)\n last = if last >= 0, do: last, else: last + count\n amount = last - first + 1\n\n if first < count and amount > 0 do\n amount = Kernel.min(amount, count - first)\n amount = amount_with_step(amount, step)\n fun.(first, amount, step)\n else\n []\n end\n end\n\n defp amount_with_step(amount, 1), do: amount\n defp amount_with_step(amount, step), do: div(amount - 1, step) + 1\n\n @doc \"\"\"\n Returns a subset list of the given `enumerable`, from `start_index` (zero-based)\n with `amount` number of elements if available.\n\n Given an `enumerable`, it drops elements right before element `start_index`;\n then, it takes `amount` of elements, returning as many elements as possible if\n there are not enough elements.\n\n A negative `start_index` can be passed, which means the `enumerable` is\n enumerated once and the index is counted from the end (for example,\n `-1` starts slicing from the last element).\n\n It returns `[]` if `amount` is `0` or if `start_index` is out of bounds.\n\n ## Examples\n\n iex> Enum.slice(1..100, 5, 10)\n [6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n\n # amount to take is greater than the number of elements\n iex> Enum.slice(1..10, 5, 100)\n [6, 7, 8, 9, 10]\n\n iex> Enum.slice(1..10, 5, 0)\n []\n\n # using a negative start index\n iex> Enum.slice(1..10, -6, 3)\n [5, 6, 7]\n iex> Enum.slice(1..10, -11, 5)\n [1, 2, 3, 4, 5]\n\n # out of bound start index\n iex> Enum.slice(1..10, 10, 5)\n []\n\n \"\"\"\n @spec slice(t, index, non_neg_integer) :: list\n def slice(_enumerable, start_index, 0) when is_integer(start_index), do: []\n\n def slice(enumerable, start_index, amount)\n when is_integer(start_index) and start_index < 0 and is_integer(amount) and amount >= 0 do\n {count, fun} = slice_count_and_fun(enumerable, 1)\n start_index = Kernel.max(count + start_index, 0)\n amount = Kernel.min(amount, count - start_index)\n\n if amount > 0 do\n fun.(start_index, amount, 1)\n else\n []\n end\n end\n\n def slice(enumerable, start_index, amount)\n when is_integer(start_index) and is_integer(amount) and amount >= 0 do\n slice_forward(enumerable, start_index, amount, 1)\n end\n\n @doc \"\"\"\n Sorts the `enumerable` according to Erlang's term ordering.\n\n This function uses the merge sort algorithm. Do not use this\n function to sort structs, see `sort/2` for more information.\n\n ## Examples\n\n iex> Enum.sort([3, 2, 1])\n [1, 2, 3]\n\n \"\"\"\n @spec sort(t) :: list\n def sort(enumerable) when is_list(enumerable) do\n :lists.sort(enumerable)\n end\n\n def sort(enumerable) do\n sort(enumerable, &(&1 <= &2))\n end\n\n @doc \"\"\"\n Sorts the `enumerable` by the given function.\n\n This function uses the merge sort algorithm. The given function should compare\n two arguments, and return `true` if the first argument precedes or is in the\n same place as the second one.\n\n ## Examples\n\n iex> Enum.sort([1, 2, 3], &(&1 >= &2))\n [3, 2, 1]\n\n The sorting algorithm will be stable as long as the given function\n returns `true` for values considered equal:\n\n iex> Enum.sort([\"some\", \"kind\", \"of\", \"monster\"], &(byte_size(&1) <= byte_size(&2)))\n [\"of\", \"some\", \"kind\", \"monster\"]\n\n If the function does not return `true` for equal values, the sorting\n is not stable and the order of equal terms may be shuffled.\n For example:\n\n iex> Enum.sort([\"some\", \"kind\", \"of\", \"monster\"], &(byte_size(&1) < byte_size(&2)))\n [\"of\", \"kind\", \"some\", \"monster\"]\n\n ## Ascending and descending (since v1.10.0)\n\n `sort/2` allows a developer to pass `:asc` or `:desc` as the sorter, which is a convenience for\n [`&<=/2`](`<=/2`) and [`&>=/2`](`>=/2`) respectively.\n\n iex> Enum.sort([2, 3, 1], :asc)\n [1, 2, 3]\n iex> Enum.sort([2, 3, 1], :desc)\n [3, 2, 1]\n\n ## Sorting structs\n\n Do not use `/2`, `>=/2` and friends when sorting structs.\n That's because the built-in operators above perform structural comparison\n and not a semantic one. Imagine we sort the following list of dates:\n\n iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]\n iex> Enum.sort(dates)\n [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]\n\n Note that the returned result is incorrect, because `sort/1` by default uses\n `<=/2`, which will compare their structure. When comparing structures, the\n fields are compared in alphabetical order, which means the dates above will\n be compared by `day`, `month` and then `year`, which is the opposite of what\n we want.\n\n For this reason, most structs provide a \"compare\" function, such as\n `Date.compare/2`, which receives two structs and returns `:lt` (less-than),\n `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the\n sorting function, Elixir will automatically use the `compare/2` function\n of said module:\n\n iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]\n iex> Enum.sort(dates, Date)\n [~D[2019-01-01], ~D[2019-06-06], ~D[2020-03-02]]\n\n To retrieve all dates in descending order, you can wrap the module in\n a tuple with `:asc` or `:desc` as first element:\n\n iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]\n iex> Enum.sort(dates, {:asc, Date})\n [~D[2019-01-01], ~D[2019-06-06], ~D[2020-03-02]]\n iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]\n iex> Enum.sort(dates, {:desc, Date})\n [~D[2020-03-02], ~D[2019-06-06], ~D[2019-01-01]]\n\n \"\"\"\n @spec sort(\n t,\n (element, element -> boolean) | :asc | :desc | module() | {:asc | :desc, module()}\n ) :: list\n def sort(enumerable, sorter) when is_list(enumerable) do\n case sorter do\n :asc -> :lists.sort(enumerable)\n :desc -> :lists.sort(enumerable) |> :lists.reverse()\n _ -> :lists.sort(to_sort_fun(sorter), enumerable)\n end\n end\n\n def sort(enumerable, sorter) do\n fun = to_sort_fun(sorter)\n\n reduce(enumerable, [], &sort_reducer(&1, &2, fun))\n |> sort_terminator(fun)\n end\n\n defp to_sort_fun(sorter) when is_function(sorter, 2), do: sorter\n defp to_sort_fun(:asc), do: &<=/2\n defp to_sort_fun(:desc), do: &>=/2\n defp to_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :gt)\n defp to_sort_fun({:asc, module}) when is_atom(module), do: &(module.compare(&1, &2) != :gt)\n defp to_sort_fun({:desc, module}) when is_atom(module), do: &(module.compare(&1, &2) != :lt)\n\n @doc \"\"\"\n Sorts the mapped results of the `enumerable` according to the provided `sorter`\n function.\n\n This function maps each element of the `enumerable` using the\n provided `mapper` function. The enumerable is then sorted by\n the mapped elements using the `sorter`, which defaults to `:asc`\n and sorts the elements ascendingly.\n\n `sort_by/3` differs from `sort/2` in that it only calculates the\n comparison value for each element in the enumerable once instead of\n once for each element in each comparison. If the same function is\n being called on both elements, it's more efficient to use `sort_by/3`.\n\n ## Ascending and descending (since v1.10.0)\n\n `sort_by/3` allows a developer to pass `:asc` or `:desc` as the sorter,\n which is a convenience for [`&<=/2`](`<=/2`) and [`&>=/2`](`>=/2`) respectively:\n iex> Enum.sort_by([2, 3, 1], &(&1), :asc)\n [1, 2, 3]\n\n iex> Enum.sort_by([2, 3, 1], &(&1), :desc)\n [3, 2, 1]\n\n ## Examples\n\n Using the default `sorter` of `:asc` :\n\n iex> Enum.sort_by([\"some\", \"kind\", \"of\", \"monster\"], &byte_size/1)\n [\"of\", \"some\", \"kind\", \"monster\"]\n\n Sorting by multiple properties - first by size, then by first letter\n (this takes advantage of the fact that tuples are compared element-by-element):\n\n iex> Enum.sort_by([\"some\", \"kind\", \"of\", \"monster\"], &{byte_size(&1), String.first(&1)})\n [\"of\", \"kind\", \"some\", \"monster\"]\n\n Similar to `sort/2`, you can pass a custom sorter:\n\n iex> Enum.sort_by([\"some\", \"kind\", \"of\", \"monster\"], &byte_size/1, :desc)\n [\"monster\", \"some\", \"kind\", \"of\"]\n\n As in `sort/2`, avoid using the default sorting function to sort\n structs, as by default it performs structural comparison instead of\n a semantic one. In such cases, you shall pass a sorting function as\n third element or any module that implements a `compare/2` function.\n For example, to sort users by their birthday in both ascending and\n descending order respectively:\n\n iex> users = [\n ...> %{name: \"Ellis\", birthday: ~D[1943-05-11]},\n ...> %{name: \"Lovelace\", birthday: ~D[1815-12-10]},\n ...> %{name: \"Turing\", birthday: ~D[1912-06-23]}\n ...> ]\n iex> Enum.sort_by(users, &(&1.birthday), Date)\n [\n %{name: \"Lovelace\", birthday: ~D[1815-12-10]},\n %{name: \"Turing\", birthday: ~D[1912-06-23]},\n %{name: \"Ellis\", birthday: ~D[1943-05-11]}\n ]\n iex> Enum.sort_by(users, &(&1.birthday), {:desc, Date})\n [\n %{name: \"Ellis\", birthday: ~D[1943-05-11]},\n %{name: \"Turing\", birthday: ~D[1912-06-23]},\n %{name: \"Lovelace\", birthday: ~D[1815-12-10]}\n ]\n\n ## Performance characteristics\n\n As detailed in the initial section, `sort_by/3` calculates the comparison\n value for each element in the enumerable once instead of once for each\n element in each comparison. This implies `sort_by/3` must do an initial\n pass on the data to compute those values.\n\n However, if those values are cheap to compute, for example, you have\n already extracted the field you want to sort by into a tuple, then those\n extra passes become overhead. In such cases, consider using `List.keysort/3`\n instead.\n\n Let's see an example. Imagine you have a list of products and you have a\n list of IDs. You want to keep all products that are in the given IDs and\n return their names sorted by their price. You could write it like this:\n\n for(\n product <- products,\n product.id in ids,\n do: product\n )\n |> Enum.sort_by(& &1.price)\n |> Enum.map(& &1.name)\n\n However, you could also write it like this:\n\n for(\n product <- products,\n product.id in ids,\n do: {product.name, product.price}\n )\n |> List.keysort(1)\n |> Enum.map(&elem(&1, 0))\n\n Using `List.keysort/3` will be a better choice for performance sensitive\n code as it avoids additional traversals.\n \"\"\"\n @spec sort_by(\n t,\n (element -> mapped_element),\n (element, element -> boolean) | :asc | :desc | module() | {:asc | :desc, module()}\n ) ::\n list\n when mapped_element: element\n def sort_by(enumerable, mapper, sorter \\\\ :asc)\n\n def sort_by(enumerable, mapper, :desc) when is_function(mapper, 1) do\n enumerable\n |> reduce([], &[{&1, mapper.(&1)} | &2])\n |> List.keysort(1, :asc)\n |> List.foldl([], &[elem(&1, 0) | &2])\n end\n\n def sort_by(enumerable, mapper, sorter) when is_function(mapper, 1) do\n enumerable\n |> map(&{&1, mapper.(&1)})\n |> List.keysort(1, sorter)\n |> map(&elem(&1, 0))\n end\n\n @doc \"\"\"\n Splits the `enumerable` into two enumerables, leaving `count`\n elements in the first one.\n\n If `count` is a negative number, it starts counting from the\n back to the beginning of the `enumerable`.\n\n Be aware that a negative `count` implies the `enumerable`\n will be enumerated twice: once to calculate the position, and\n a second time to do the actual splitting.\n\n ## Examples\n\n iex> Enum.split([1, 2, 3], 2)\n {[1, 2], [3]}\n\n iex> Enum.split([1, 2, 3], 10)\n {[1, 2, 3], []}\n\n iex> Enum.split([1, 2, 3], 0)\n {[], [1, 2, 3]}\n\n iex> Enum.split([1, 2, 3], -1)\n {[1, 2], [3]}\n\n iex> Enum.split([1, 2, 3], -5)\n {[], [1, 2, 3]}\n\n \"\"\"\n @spec split(t, integer) :: {list, list}\n def split(enumerable, count) when is_list(enumerable) and is_integer(count) and count >= 0 do\n split_list(enumerable, count, [])\n end\n\n def split(enumerable, count) when is_integer(count) and count >= 0 do\n {_, list1, list2} =\n reduce(enumerable, {count, [], []}, fn entry, {counter, acc1, acc2} ->\n if counter > 0 do\n {counter - 1, [entry | acc1], acc2}\n else\n {counter, acc1, [entry | acc2]}\n end\n end)\n\n {:lists.reverse(list1), :lists.reverse(list2)}\n end\n\n def split(enumerable, count) when is_integer(count) and count < 0 do\n split_reverse_list(reverse(enumerable), -count, [])\n end\n\n @doc \"\"\"\n Splits enumerable in two at the position of the element for which\n `fun` returns a falsy value (`false` or `nil`) for the first time.\n\n It returns a two-element tuple with two lists of elements.\n The element that triggered the split is part of the second list.\n\n ## Examples\n\n iex> Enum.split_while([1, 2, 3, 4], fn x -> x < 3 end)\n {[1, 2], [3, 4]}\n\n iex> Enum.split_while([1, 2, 3, 4], fn x -> x < 0 end)\n {[], [1, 2, 3, 4]}\n\n iex> Enum.split_while([1, 2, 3, 4], fn x -> x > 0 end)\n {[1, 2, 3, 4], []}\n\n \"\"\"\n @spec split_while(t, (element -> as_boolean(term))) :: {list, list}\n def split_while(enumerable, fun) when is_list(enumerable) do\n split_while_list(enumerable, fun, [])\n end\n\n def split_while(enumerable, fun) do\n {list1, list2} =\n reduce(enumerable, {[], []}, fn\n entry, {acc1, []} ->\n if(fun.(entry), do: {[entry | acc1], []}, else: {acc1, [entry]})\n\n entry, {acc1, acc2} ->\n {acc1, [entry | acc2]}\n end)\n\n {:lists.reverse(list1), :lists.reverse(list2)}\n end\n\n @doc \"\"\"\n Returns the sum of all elements.\n\n Raises `ArithmeticError` if `enumerable` contains a non-numeric value.\n\n If you need to apply a transformation first, consider using `Enum.sum_by/2` instead.\n\n ## Examples\n\n iex> Enum.sum([1, 2, 3])\n 6\n\n iex> Enum.sum(1..10)\n 55\n\n iex> Enum.sum(1..10//2)\n 25\n\n \"\"\"\n @spec sum(t) :: number\n def sum(enumerable)\n\n def sum(first..last//step = range) do\n range\n |> Range.size()\n |> Kernel.*(first + last - rem(last - first, step))\n |> div(2)\n end\n\n def sum(enumerable) do\n reduce(enumerable, 0, &+/2)\n end\n\n @doc \"\"\"\n Maps and sums the given `enumerable` in one pass.\n\n Raises `ArithmeticError` if `mapper` returns a non-numeric value.\n\n ## Examples\n\n iex> Enum.sum_by([%{count: 1}, %{count: 2}, %{count: 3}], fn x -> x.count end)\n 6\n\n iex> Enum.sum_by(1..3, fn x -> x ** 2 end)\n 14\n\n iex> Enum.sum_by([], fn x -> x.count end)\n 0\n\n Filtering can be achieved by returning `0` to ignore elements:\n\n iex> Enum.sum_by([1, -2, 3], fn x -> if x > 0, do: x, else: 0 end)\n 4\n\n \"\"\"\n @doc since: \"1.18.0\"\n @spec sum_by(t, (element -> number)) :: number\n def sum_by(enumerable, mapper)\n\n def sum_by(list, mapper) when is_list(list) and is_function(mapper, 1) do\n sum_by_list(list, mapper, 0)\n end\n\n def sum_by(enumerable, mapper) when is_function(mapper, 1) do\n reduce(enumerable, 0, fn x, acc -> acc + mapper.(x) end)\n end\n\n @doc \"\"\"\n Returns the product of all elements.\n\n Raises `ArithmeticError` if `enumerable` contains a non-numeric value.\n\n If you need to apply a transformation first, consider using `Enum.product_by/2` instead.\n\n ## Examples\n\n iex> Enum.product([])\n 1\n iex> Enum.product([2, 3, 4])\n 24\n iex> Enum.product([2.0, 3.0, 4.0])\n 24.0\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec product(t) :: number\n def product(enumerable) do\n reduce(enumerable, 1, &*/2)\n end\n\n @doc \"\"\"\n Maps and computes the product of the given `enumerable` in one pass.\n\n Raises `ArithmeticError` if `mapper` returns a non-numeric value.\n\n ## Examples\n\n iex> Enum.product_by([%{count: 2}, %{count: 4}, %{count: 3}], fn x -> x.count end)\n 24\n\n iex> Enum.product_by(1..3, fn x -> x ** 2 end)\n 36\n\n iex> Enum.product_by([], fn x -> x.count end)\n 1\n\n Filtering can be achieved by returning `1` to ignore elements:\n\n iex> Enum.product_by([2, -1, 3], fn x -> if x > 0, do: x, else: 1 end)\n 6\n\n \"\"\"\n @doc since: \"1.18.0\"\n @spec product_by(t, (element -> number)) :: number\n def product_by(enumerable, mapper)\n\n def product_by(list, mapper) when is_list(list) and is_function(mapper, 1) do\n product_by_list(list, mapper, 1)\n end\n\n def product_by(enumerable, mapper) when is_function(mapper, 1) do\n reduce(enumerable, 1, fn x, acc -> acc * mapper.(x) end)\n end\n\n @doc \"\"\"\n Takes an `amount` of elements from the beginning or the end of the `enumerable`.\n\n If a positive `amount` is given, it takes the `amount` elements from the\n beginning of the `enumerable`.\n\n If a negative `amount` is given, the `amount` of elements will be taken from the end.\n The `enumerable` will be enumerated once to retrieve the proper index and\n the remaining calculation is performed from the end.\n\n If amount is `0`, it returns `[]`.\n\n ## Examples\n\n iex> Enum.take([1, 2, 3], 2)\n [1, 2]\n\n iex> Enum.take([1, 2, 3], 10)\n [1, 2, 3]\n\n iex> Enum.take([1, 2, 3], 0)\n []\n\n iex> Enum.take([1, 2, 3], -1)\n [3]\n\n \"\"\"\n @spec take(t, integer) :: list\n def take(enumerable, amount)\n\n def take(_enumerable, 0), do: []\n\n def take(enumerable, amount)\n when is_list(enumerable) and is_integer(amount) and amount > 0 do\n take_list(enumerable, amount)\n end\n\n def take(enumerable, amount) when is_integer(amount) and amount > 0 do\n {_, {res, _}} =\n Enumerable.reduce(enumerable, {:cont, {[], amount}}, fn entry, {list, n} ->\n case n do\n 1 -> {:halt, {[entry | list], n - 1}}\n _ -> {:cont, {[entry | list], n - 1}}\n end\n end)\n\n :lists.reverse(res)\n end\n\n def take(enumerable, amount) when is_integer(amount) and amount < 0 do\n case slice_count_and_fun(enumerable, 1) do\n {0, _fun} ->\n []\n\n {count, fun} ->\n first = Kernel.max(amount + count, 0)\n fun.(first, count - first, 1)\n end\n end\n\n @doc \"\"\"\n Returns a list of every `nth` element in the `enumerable`,\n starting with the first element.\n\n The first element is always included, unless `nth` is 0.\n\n The second argument specifying every `nth` element must be a non-negative\n integer.\n\n ## Examples\n\n iex> Enum.take_every(1..10, 2)\n [1, 3, 5, 7, 9]\n\n iex> Enum.take_every(1..10, 0)\n []\n\n iex> Enum.take_every([1, 2, 3], 1)\n [1, 2, 3]\n\n \"\"\"\n @spec take_every(t, non_neg_integer) :: list\n def take_every(enumerable, nth)\n\n def take_every(_enumerable, 0), do: []\n def take_every(enumerable, 1), do: to_list(enumerable)\n\n def take_every(list, nth) when is_list(list) and is_integer(nth) and nth > 1 do\n take_every_list(list, nth - 1)\n end\n\n def take_every(enumerable, nth) when is_integer(nth) and nth > 1 do\n {res, _} = reduce(enumerable, {[], :first}, R.take_every(nth))\n :lists.reverse(res)\n end\n\n @doc \"\"\"\n Takes `count` random elements from `enumerable`.\n\n Note that this function will traverse the whole `enumerable` to\n get the random sublist.\n\n See `random/1` for notes on implementation and random seed.\n\n ## Examples\n\n # Although not necessary, let's seed the random algorithm\n iex> :rand.seed(:exsss, {1, 2, 3})\n iex> Enum.take_random(1..10, 2)\n [6, 1]\n iex> Enum.take_random(?a..?z, 5)\n ~c\"bkzmt\"\n\n \"\"\"\n @spec take_random(t, non_neg_integer) :: list\n def take_random(enumerable, count)\n def take_random(_enumerable, 0), do: []\n def take_random([], _), do: []\n\n def take_random(enumerable, 1) do\n enumerable\n |> reduce({0, 0, 1.0, nil}, fn\n elem, {idx, idx, w, _current} ->\n {jdx, w} = take_jdx_w(idx, w, 1)\n {idx + 1, jdx, w, elem}\n\n _elem, {idx, jdx, w, current} ->\n {idx + 1, jdx, w, current}\n end)\n |> case do\n {0, 0, 1.0, nil} -> []\n {_idx, _jdx, _w, current} -> [current]\n end\n end\n\n def take_random(enumerable, count) when count in 0..128 do\n sample = Tuple.duplicate(nil, count)\n\n reducer = fn\n elem, {idx, jdx, w, sample} when idx < count ->\n rand = take_index(idx)\n sample = sample |> put_elem(idx, elem(sample, rand)) |> put_elem(rand, elem)\n\n if idx == jdx do\n {jdx, w} = take_jdx_w(idx, w, count)\n {idx + 1, jdx, w, sample}\n else\n {idx + 1, jdx, w, sample}\n end\n\n elem, {idx, idx, w, sample} ->\n pos = :rand.uniform(count) - 1\n {jdx, w} = take_jdx_w(idx, w, count)\n {idx + 1, jdx, w, put_elem(sample, pos, elem)}\n\n _elem, {idx, jdx, w, sample} ->\n {idx + 1, jdx, w, sample}\n end\n\n {size, _, _, sample} = reduce(enumerable, {0, count - 1, 1.0, sample}, reducer)\n\n if count < size do\n Tuple.to_list(sample)\n else\n take_tupled(sample, size, [])\n end\n end\n\n def take_random(enumerable, count) when is_integer(count) and count >= 0 do\n reducer = fn\n elem, {idx, jdx, w, sample} when idx < count ->\n rand = take_index(idx)\n sample = sample |> Map.put(idx, Map.get(sample, rand)) |> Map.put(rand, elem)\n\n if idx == jdx do\n {jdx, w} = take_jdx_w(idx, w, count)\n {idx + 1, jdx, w, sample}\n else\n {idx + 1, jdx, w, sample}\n end\n\n elem, {idx, idx, w, sample} ->\n pos = :rand.uniform(count) - 1\n {jdx, w} = take_jdx_w(idx, w, count)\n {idx + 1, jdx, w, %{sample | pos => elem}}\n\n _elem, {idx, jdx, w, sample} ->\n {idx + 1, jdx, w, sample}\n end\n\n {size, _, _, sample} = reduce(enumerable, {0, count - 1, 1.0, %{}}, reducer)\n take_mapped(sample, Kernel.min(count, size), [])\n end\n\n @compile {:inline, take_jdx_w: 3, take_index: 1}\n defp take_jdx_w(idx, w, count) do\n w = w * :math.exp(:math.log(:rand.uniform()) / count)\n jdx = idx + floor(:math.log(:rand.uniform()) / :math.log(1 - w)) + 1\n {jdx, w}\n end\n\n defp take_index(0), do: 0\n defp take_index(idx), do: :rand.uniform(idx + 1) - 1\n\n defp take_tupled(_sample, 0, acc), do: acc\n\n defp take_tupled(sample, position, acc) do\n position = position - 1\n take_tupled(sample, position, [elem(sample, position) | acc])\n end\n\n defp take_mapped(_sample, 0, acc), do: acc\n\n defp take_mapped(sample, position, acc) do\n position = position - 1\n take_mapped(sample, position, [Map.fetch!(sample, position) | acc])\n end\n\n @doc \"\"\"\n Takes the elements from the beginning of the `enumerable` while `fun` returns\n a truthy value.\n\n ## Examples\n\n iex> Enum.take_while([1, 2, 3], fn x -> x < 3 end)\n [1, 2]\n\n \"\"\"\n @spec take_while(t, (element -> as_boolean(term))) :: list\n def take_while(enumerable, fun) when is_list(enumerable) do\n take_while_list(enumerable, fun)\n end\n\n def take_while(enumerable, fun) do\n {_, res} =\n Enumerable.reduce(enumerable, {:cont, []}, fn entry, acc ->\n if fun.(entry) do\n {:cont, [entry | acc]}\n else\n {:halt, acc}\n end\n end)\n\n :lists.reverse(res)\n end\n\n @doc \"\"\"\n Converts `enumerable` to a list.\n\n ## Examples\n\n iex> Enum.to_list(1..3)\n [1, 2, 3]\n\n \"\"\"\n @spec to_list(t) :: [element]\n def to_list(enumerable) when is_list(enumerable), do: enumerable\n def to_list(%{__struct__: Range} = range), do: Range.to_list(range)\n def to_list(%_{} = enumerable), do: reverse(enumerable) |> :lists.reverse()\n def to_list(%{} = enumerable), do: Map.to_list(enumerable)\n def to_list(enumerable), do: reverse(enumerable) |> :lists.reverse()\n\n @doc \"\"\"\n Enumerates the `enumerable`, removing all duplicate elements.\n\n The first occurrence of each element is kept and all following\n duplicates are removed. The overall order is preserved.\n\n ## Examples\n\n iex> Enum.uniq([1, 2, 3, 3, 2, 1])\n [1, 2, 3]\n\n \"\"\"\n @spec uniq(t) :: list\n def uniq(enumerable) do\n uniq_by(enumerable, fn x -> x end)\n end\n\n @doc false\n @deprecated \"Use Enum.uniq_by/2 instead\"\n def uniq(enumerable, fun) do\n uniq_by(enumerable, fun)\n end\n\n @doc \"\"\"\n Enumerates the `enumerable`, by removing the elements for which\n function `fun` returned duplicate elements.\n\n The function `fun` maps every element to a term. Two elements are\n considered duplicates if the return value of `fun` is equal for\n both of them.\n\n The first occurrence of each element is kept and all following\n duplicates are removed. The overall order is preserved.\n\n ## Example\n\n iex> Enum.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end)\n [{1, :x}, {2, :y}]\n\n iex> Enum.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end)\n [a: {:tea, 2}, c: {:coffee, 1}]\n\n \"\"\"\n @spec uniq_by(t, (element -> term)) :: list\n\n def uniq_by(enumerable, fun) when is_list(enumerable) do\n uniq_list(enumerable, %{}, fun)\n end\n\n def uniq_by(enumerable, fun) do\n {list, _} = reduce(enumerable, {[], %{}}, R.uniq_by(fun))\n :lists.reverse(list)\n end\n\n @doc \"\"\"\n Opposite of `zip/2`. Extracts two-element tuples from the\n given `enumerable` and groups them together.\n\n It takes an `enumerable` with elements being two-element tuples and returns\n a tuple with two lists, each of which is formed by the first and\n second element of each tuple, respectively.\n\n This function fails unless `enumerable` is or can be converted into a\n list of tuples with *exactly* two elements in each tuple.\n\n ## Examples\n\n iex> Enum.unzip([{:a, 1}, {:b, 2}, {:c, 3}])\n {[:a, :b, :c], [1, 2, 3]}\n\n \"\"\"\n @spec unzip(t) :: {[element], [element]}\n def unzip(enumerable)\n\n def unzip([_ | _] = list) do\n :lists.reverse(list) |> unzip([], [])\n end\n\n def unzip([]) do\n {[], []}\n end\n\n def unzip(enumerable) do\n {list1, list2} =\n reduce(enumerable, {[], []}, fn {el1, el2}, {list1, list2} ->\n {[el1 | list1], [el2 | list2]}\n end)\n\n {:lists.reverse(list1), :lists.reverse(list2)}\n end\n\n defp unzip([{el1, el2} | reversed_list], list1, list2) do\n unzip(reversed_list, [el1 | list1], [el2 | list2])\n end\n\n defp unzip([], list1, list2) do\n {list1, list2}\n end\n\n @doc \"\"\"\n Returns the `enumerable` with each element wrapped in a tuple\n alongside its index or according to a given function.\n\n If an integer offset is given as `fun_or_offset`, it will index from the given\n offset instead of from zero.\n\n If a 2-arity function is given as `fun_or_offset`, the function will be invoked\n for each element in `enumerable` as the first argument and with a zero-based\n index as the second. `with_index/2` returns a list with the result of each invocation.\n\n ## Examples\n\n iex> Enum.with_index([:a, :b, :c])\n [a: 0, b: 1, c: 2]\n\n iex> Enum.with_index([:a, :b, :c], 3)\n [a: 3, b: 4, c: 5]\n\n iex> Enum.with_index([:a, :b, :c], fn element, index -> {index, element} end)\n [{0, :a}, {1, :b}, {2, :c}]\n\n \"\"\"\n @spec with_index(t, integer) :: [{term, integer}]\n @spec with_index(t, (element, index -> value)) :: [value] when value: any\n def with_index(enumerable, fun_or_offset \\\\ 0)\n\n def with_index(enumerable, offset) when is_list(enumerable) and is_integer(offset) do\n with_index_list(enumerable, offset)\n end\n\n def with_index(enumerable, fun) when is_list(enumerable) and is_function(fun, 2) do\n with_index_list(enumerable, 0, fun)\n end\n\n def with_index(enumerable, offset) when is_integer(offset) do\n enumerable\n |> map_reduce(offset, fn x, i -> {{x, i}, i + 1} end)\n |> elem(0)\n end\n\n def with_index(enumerable, fun) when is_function(fun, 2) do\n enumerable\n |> map_reduce(0, fn x, i -> {fun.(x, i), i + 1} end)\n |> elem(0)\n end\n\n @doc \"\"\"\n Zips corresponding elements from two enumerables into a list\n of tuples.\n\n Because a list of two-element tuples with atoms as the first\n tuple element is a keyword list (`Keyword`), zipping a first list\n of atoms with a second list of any kind creates a keyword list.\n\n The zipping finishes as soon as either enumerable completes.\n\n ## Examples\n\n iex> Enum.zip([1, 2, 3], [:a, :b, :c])\n [{1, :a}, {2, :b}, {3, :c}]\n\n iex> Enum.zip([:a, :b, :c], [1, 2, 3])\n [a: 1, b: 2, c: 3]\n\n iex> Enum.zip([1, 2, 3, 4, 5], [:a, :b, :c])\n [{1, :a}, {2, :b}, {3, :c}]\n\n \"\"\"\n @spec zip(t, t) :: [{any, any}]\n def zip(enumerable1, enumerable2) when is_list(enumerable1) and is_list(enumerable2) do\n zip_list(enumerable1, enumerable2, [])\n end\n\n def zip(enumerable1, enumerable2) do\n zip([enumerable1, enumerable2])\n end\n\n @doc \"\"\"\n Zips corresponding elements from a finite collection of enumerables\n into a list of tuples.\n\n The zipping finishes as soon as any enumerable in the given collection completes.\n\n ## Examples\n\n iex> Enum.zip([[1, 2, 3], [:a, :b, :c], [\"foo\", \"bar\", \"baz\"]])\n [{1, :a, \"foo\"}, {2, :b, \"bar\"}, {3, :c, \"baz\"}]\n\n iex> Enum.zip([[1, 2, 3, 4, 5], [:a, :b, :c]])\n [{1, :a}, {2, :b}, {3, :c}]\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec zip(enumerables) :: [tuple()] when enumerables: [t()] | t()\n def zip([]), do: []\n\n def zip(enumerables) do\n zip_reduce(enumerables, [], &[List.to_tuple(&1) | &2])\n |> :lists.reverse()\n end\n\n @doc \"\"\"\n Zips corresponding elements from two enumerables into a list, transforming them with\n the `zip_fun` function as it goes.\n\n The corresponding elements from each collection are passed to the provided two-arity `zip_fun`\n function in turn. Returns a list that contains the result of calling `zip_fun` for each pair of\n elements.\n\n The zipping finishes as soon as either enumerable runs out of elements.\n\n ## Zipping Maps\n\n It's important to remember that zipping inherently relies on order.\n If you zip two lists you get the element at the index from each list in turn.\n If we zip two maps together it's tempting to think that you will get the given\n key in the left map and the matching key in the right map, but there is no such\n guarantee because map keys are not ordered! Consider the following:\n\n left = %{:a => 1, 1 => 3}\n right = %{:a => 1, :b => :c}\n Enum.zip(left, right)\n #=> [{{1, 3}, {:a, 1}}, {{:a, 1}, {:b, :c}}]\n\n As you can see `:a` does not get paired with `:a`. If this is what you want,\n you should use `Map.merge/3`.\n\n ## Examples\n\n iex> Enum.zip_with([1, 2], [3, 4], fn x, y -> x + y end)\n [4, 6]\n\n iex> Enum.zip_with([1, 2], [3, 4, 5, 6], fn x, y -> x + y end)\n [4, 6]\n\n iex> Enum.zip_with([1, 2, 5, 6], [3, 4], fn x, y -> x + y end)\n [4, 6]\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec zip_with(t, t, (enum1_elem :: term, enum2_elem :: term -> term)) :: [term]\n def zip_with(enumerable1, enumerable2, zip_fun)\n when is_list(enumerable1) and is_list(enumerable2) and is_function(zip_fun, 2) do\n zip_with_list(enumerable1, enumerable2, zip_fun)\n end\n\n def zip_with(enumerable1, enumerable2, zip_fun) when is_function(zip_fun, 2) do\n zip_reduce(enumerable1, enumerable2, [], fn l, r, acc -> [zip_fun.(l, r) | acc] end)\n |> :lists.reverse()\n end\n\n @doc \"\"\"\n Zips corresponding elements from a finite collection of enumerables\n into list, transforming them with the `zip_fun` function as it goes.\n\n The first element from each of the enums in `enumerables` will be put\n into a list which is then passed to the one-arity `zip_fun` function.\n Then, the second elements from each of the enums are put into a list\n and passed to `zip_fun`, and so on until any one of the enums in\n `enumerables` runs out of elements.\n\n Returns a list with all the results of calling `zip_fun`.\n\n ## Examples\n\n iex> Enum.zip_with([[1, 2], [3, 4], [5, 6]], fn [x, y, z] -> x + y + z end)\n [9, 12]\n\n iex> Enum.zip_with([[1, 2], [3, 4]], fn [x, y] -> x + y end)\n [4, 6]\n\n `zip_with/2` can be used to transpose lists of lists:\n\n iex> Enum.zip_with([[1, 2,], [3, 4]], & &1)\n [[1, 3], [2, 4]]\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec zip_with(t, ([term] -> term)) :: [term]\n def zip_with([], _fun), do: []\n\n def zip_with(enumerables, zip_fun) do\n zip_reduce(enumerables, [], fn values, acc -> [zip_fun.(values) | acc] end)\n |> :lists.reverse()\n end\n\n @doc \"\"\"\n Reduces over two enumerables halting as soon as either enumerable is empty.\n\n In practice, the behavior provided by this function can be achieved with:\n\n Enum.reduce(Stream.zip(left, right), acc, reducer)\n\n But `zip_reduce/4` exists for convenience purposes.\n\n ## Examples\n\n iex> Enum.zip_reduce([1, 2], [3, 4], 0, fn x, y, acc -> x + y + acc end)\n 10\n\n If one of the lists has more entries than the others,\n those entries are discarded:\n\n iex> Enum.zip_reduce([1, 2, 3], [4, 5], [], fn x, y, acc -> [x + y | acc] end)\n [7, 5]\n \"\"\"\n @doc since: \"1.12.0\"\n @spec zip_reduce(t, t, acc, (enum1_elem :: term, enum2_elem :: term, acc -> acc)) :: acc\n when acc: term\n def zip_reduce(left, right, acc, reducer)\n when is_list(left) and is_list(right) and is_function(reducer, 3) do\n zip_reduce_list(left, right, acc, reducer)\n end\n\n def zip_reduce(left, right, acc, reducer) when is_function(reducer, 3) do\n reduce = fn [l, r], acc -> {:cont, reducer.(l, r, acc)} end\n R.zip_with([left, right], & &1).({:cont, acc}, reduce) |> elem(1)\n end\n\n @doc \"\"\"\n Reduces over all of the given enumerables, halting as soon as any enumerable is\n empty.\n\n The reducer will receive 2 args: a list of elements (one from each enum) and the\n accumulator.\n\n In practice, the behavior provided by this function can be achieved with:\n\n Enum.reduce(Stream.zip(enums), acc, reducer)\n\n But `zip_reduce/3` exists for convenience purposes.\n\n ## Examples\n\n iex> enums = [[1, 1], [2, 2], [3, 3]]\n ...> Enum.zip_reduce(enums, [], fn elements, acc ->\n ...> [List.to_tuple(elements) | acc]\n ...> end)\n [{1, 2, 3}, {1, 2, 3}]\n\n If one of the lists has more entries than the others,\n those entries are discarded:\n\n iex> enums = [[1, 2], [a: 3, b: 4], [5, 6, 7]]\n ...> Enum.zip_reduce(enums, [], fn elements, acc ->\n ...> [List.to_tuple(elements) | acc]\n ...> end)\n [{2, {:b, 4}, 6}, {1, {:a, 3}, 5}]\n \"\"\"\n @doc since: \"1.12.0\"\n @spec zip_reduce(t, acc, ([term], acc -> acc)) :: acc when acc: term\n def zip_reduce([], acc, reducer) when is_function(reducer, 2), do: acc\n\n def zip_reduce(enumerables, acc, reducer) when is_function(reducer, 2) do\n R.zip_with(enumerables, & &1).({:cont, acc}, &{:cont, reducer.(&1, &2)}) |> elem(1)\n end\n\n ## Helpers\n\n @compile {:inline,\n entry_to_string: 1,\n reduce: 3,\n reduce_by: 3,\n reduce_enumerable: 3,\n reduce_range: 5,\n map_range: 4}\n\n defp entry_to_string(entry) when is_binary(entry), do: entry\n defp entry_to_string(entry), do: String.Chars.to_string(entry)\n\n defp aggregate([head | tail], fun, _empty) do\n aggregate_list(tail, head, fun)\n end\n\n defp aggregate([], _fun, empty) do\n empty.()\n end\n\n defp aggregate(first..last//step = range, fun, empty) do\n case Range.size(range) do\n 0 ->\n empty.()\n\n _ ->\n last = last - rem(last - first, step)\n\n case fun.(first, last) do\n true -> first\n false -> last\n end\n end\n end\n\n defp aggregate(enumerable, fun, empty) do\n ref = make_ref()\n\n enumerable\n |> reduce(ref, fn\n element, ^ref ->\n element\n\n element, acc ->\n case fun.(acc, element) do\n true -> acc\n false -> element\n end\n end)\n |> case do\n ^ref -> empty.()\n result -> result\n end\n end\n\n defp aggregate_list([head | tail], acc, fun) do\n acc =\n case fun.(acc, head) do\n true -> acc\n false -> head\n end\n\n aggregate_list(tail, acc, fun)\n end\n\n defp aggregate_list([], acc, _fun), do: acc\n\n defp aggregate_by(enumerable, fun, sorter, empty_fallback) do\n first_fun = &[&1 | fun.(&1)]\n\n reduce_fun = fn entry, [_ | fun_ref] = old ->\n fun_entry = fun.(entry)\n\n case sorter.(fun_ref, fun_entry) do\n true -> old\n false -> [entry | fun_entry]\n end\n end\n\n case reduce_by(enumerable, first_fun, reduce_fun) do\n :empty -> empty_fallback.()\n [entry | _] -> entry\n end\n end\n\n defp reduce_by([head | tail], first, fun) do\n :lists.foldl(fun, first.(head), tail)\n end\n\n defp reduce_by([], _first, _fun) do\n :empty\n end\n\n defp reduce_by(enumerable, first, fun) do\n reduce(enumerable, :empty, fn\n element, :empty -> first.(element)\n element, acc -> fun.(element, acc)\n end)\n end\n\n ## Implementations\n\n ## all?/1\n\n defp all_list([h | t]) do\n if h do\n all_list(t)\n else\n false\n end\n end\n\n defp all_list([]) do\n true\n end\n\n ## any?/1\n\n defp any_list([h | t]) do\n if h do\n true\n else\n any_list(t)\n end\n end\n\n defp any_list([]) do\n false\n end\n\n ## any?/2 all?/2\n\n defp predicate_list([h | t], initial, fun) do\n if !!fun.(h) == initial do\n predicate_list(t, initial, fun)\n else\n not initial\n end\n end\n\n defp predicate_list([], initial, _) do\n initial\n end\n\n defp predicate_range(first, last, step, initial, fun)\n when step > 0 and first <= last\n when step < 0 and first >= last do\n if !!fun.(first) == initial do\n predicate_range(first + step, last, step, initial, fun)\n else\n not initial\n end\n end\n\n defp predicate_range(_first, _last, _step, initial, _fun) do\n initial\n end\n\n ## concat\n\n defp concat_list([h | t]) when is_list(h), do: h ++ concat_list(t)\n defp concat_list([h | t]), do: concat_enum([h | t])\n defp concat_list([]), do: []\n\n defp concat_enum(enum) do\n fun = &[&1 | &2]\n enum |> reduce([], &reduce(&1, &2, fun)) |> :lists.reverse()\n end\n\n # count_until\n\n @compile {:inline, count_until_list: 3}\n\n defp count_until_list([], _limit, acc), do: acc\n\n defp count_until_list([_head | tail], limit, acc) do\n case acc + 1 do\n ^limit -> limit\n acc -> count_until_list(tail, limit, acc)\n end\n end\n\n defp count_until_enum(enumerable, limit) do\n case Enumerable.count(enumerable) do\n {:ok, value} ->\n Kernel.min(value, limit)\n\n {:error, module} ->\n module.reduce(enumerable, {:cont, 0}, fn _entry, acc ->\n case acc + 1 do\n ^limit -> {:halt, limit}\n acc -> {:cont, acc}\n end\n end)\n |> elem(1)\n end\n end\n\n @compile {:inline, count_until_list: 4}\n\n defp count_until_list([], _fun, _limit, acc), do: acc\n\n defp count_until_list([head | tail], fun, limit, acc) do\n if fun.(head) do\n case acc + 1 do\n ^limit -> limit\n acc -> count_until_list(tail, fun, limit, acc)\n end\n else\n count_until_list(tail, fun, limit, acc)\n end\n end\n\n defp count_until_enum(enumerable, fun, limit) do\n Enumerable.reduce(enumerable, {:cont, 0}, fn entry, acc ->\n if fun.(entry) do\n case acc + 1 do\n ^limit -> {:halt, limit}\n acc -> {:cont, acc}\n end\n else\n {:cont, acc}\n end\n end)\n |> elem(1)\n end\n\n # dedup\n\n defp dedup_list([value | tail], acc) do\n acc =\n case acc do\n [^value | _] -> acc\n _ -> [value | acc]\n end\n\n dedup_list(tail, acc)\n end\n\n defp dedup_list([], acc) do\n acc\n end\n\n ## drop\n\n defp drop_list(list, 0), do: list\n defp drop_list([_ | tail], counter), do: drop_list(tail, counter - 1)\n defp drop_list([], _), do: []\n\n ## drop_while\n\n defp drop_while_list([head | tail], fun) do\n if fun.(head) do\n drop_while_list(tail, fun)\n else\n [head | tail]\n end\n end\n\n defp drop_while_list([], _) do\n []\n end\n\n ## filter\n\n defp filter_list([head | tail], fun) do\n if fun.(head) do\n [head | filter_list(tail, fun)]\n else\n filter_list(tail, fun)\n end\n end\n\n defp filter_list([], _fun) do\n []\n end\n\n ## find\n\n defp find_list([head | tail], default, fun) do\n if fun.(head) do\n head\n else\n find_list(tail, default, fun)\n end\n end\n\n defp find_list([], default, _) do\n default\n end\n\n ## find_index\n\n defp find_index_list([head | tail], counter, fun) do\n if fun.(head) do\n counter\n else\n find_index_list(tail, counter + 1, fun)\n end\n end\n\n defp find_index_list([], _, _) do\n nil\n end\n\n ## find_value\n\n defp find_value_list([head | tail], default, fun) do\n fun.(head) || find_value_list(tail, default, fun)\n end\n\n defp find_value_list([], default, _) do\n default\n end\n\n ## flat_map\n\n defp flat_map_list([head | tail], fun) do\n case fun.(head) do\n # the two first clauses are an optimization\n [] -> flat_map_list(tail, fun)\n [elem] -> [elem | flat_map_list(tail, fun)]\n list when is_list(list) -> list ++ flat_map_list(tail, fun)\n other -> to_list(other) ++ flat_map_list(tail, fun)\n end\n end\n\n defp flat_map_list([], _fun) do\n []\n end\n\n ## intersperse\n\n defp intersperse_non_empty_list([head], _separator), do: [head]\n\n defp intersperse_non_empty_list([head | rest], separator) do\n [head, separator | intersperse_non_empty_list(rest, separator)]\n end\n\n ## join\n\n defp join_list([], _joiner), do: \"\"\n\n defp join_list(list, joiner) do\n join_non_empty_list(list, joiner, [])\n |> :lists.reverse()\n |> IO.iodata_to_binary()\n end\n\n defp join_non_empty_list([first], _joiner, acc), do: [entry_to_string(first) | acc]\n\n defp join_non_empty_list([first | rest], joiner, acc) do\n join_non_empty_list(rest, joiner, [joiner, entry_to_string(first) | acc])\n end\n\n ## map\n\n defp map_range(first, last, step, fun)\n when step > 0 and first <= last\n when step < 0 and first >= last do\n [fun.(first) | map_range(first + step, last, step, fun)]\n end\n\n defp map_range(_first, _last, _step, _fun) do\n []\n end\n\n ## map_intersperse\n\n defp map_intersperse_list([], _, _),\n do: []\n\n defp map_intersperse_list([last], _, mapper),\n do: [mapper.(last)]\n\n defp map_intersperse_list([head | rest], separator, mapper),\n do: [mapper.(head), separator | map_intersperse_list(rest, separator, mapper)]\n\n ## reduce\n\n defp reduce_range(first, last, step, acc, fun)\n when step > 0 and first <= last\n when step < 0 and first >= last do\n reduce_range(first + step, last, step, fun.(first, acc), fun)\n end\n\n defp reduce_range(_first, _last, _step, acc, _fun) do\n acc\n end\n\n defp reduce_enumerable(enumerable, acc, fun) do\n Enumerable.reduce(enumerable, {:cont, acc}, fn x, acc -> {:cont, fun.(x, acc)} end) |> elem(1)\n end\n\n ## reject\n\n defp reject_list([head | tail], fun) do\n if fun.(head) do\n reject_list(tail, fun)\n else\n [head | reject_list(tail, fun)]\n end\n end\n\n defp reject_list([], _fun) do\n []\n end\n\n ## reverse_slice\n\n defp reverse_slice(rest, idx, idx, count, acc) do\n {slice, rest} = head_slice(rest, count, [])\n :lists.reverse(rest, :lists.reverse(slice, acc))\n end\n\n defp reverse_slice([elem | rest], idx, start, count, acc) do\n reverse_slice(rest, idx - 1, start, count, [elem | acc])\n end\n\n defp head_slice(rest, 0, acc), do: {acc, rest}\n\n defp head_slice([elem | rest], count, acc) do\n head_slice(rest, count - 1, [elem | acc])\n end\n\n ## scan\n\n defp scan_list([], _acc, _fun), do: []\n\n defp scan_list([elem | rest], acc, fun) do\n acc = fun.(elem, acc)\n [acc | scan_list(rest, acc, fun)]\n end\n\n ## slice\n\n defp slice_forward(enumerable, start, amount, step) when start < 0 do\n {count, fun} = slice_count_and_fun(enumerable, step)\n start = count + start\n\n if start >= 0 do\n amount = Kernel.min(amount, count - start)\n amount = amount_with_step(amount, step)\n fun.(start, amount, step)\n else\n []\n end\n end\n\n defp slice_forward(list, start, amount, step) when is_list(list) do\n amount = amount_with_step(amount, step)\n slice_list(list, start, amount, step)\n end\n\n defp slice_forward(enumerable, start, amount, step) do\n case Enumerable.slice(enumerable) do\n {:ok, count, _} when start >= count ->\n []\n\n {:ok, count, fun} when is_function(fun, 1) ->\n amount = Kernel.min(amount, count - start) |> amount_with_step(step)\n enumerable |> fun.() |> slice_exact(start, amount, step, count)\n\n {:ok, count, fun} when is_function(fun, 3) ->\n amount = Kernel.min(amount, count - start) |> amount_with_step(step)\n fun.(start, amount, step)\n\n # TODO: Remove me on v2.0\n {:ok, count, fun} when is_function(fun, 2) ->\n IO.warn(\n \"#{inspect(Enumerable.impl_for(enumerable))} must return a three arity function on slice/1\"\n )\n\n amount = Kernel.min(amount, count - start)\n\n if step == 1 do\n fun.(start, amount)\n else\n fun.(start, Kernel.min(amount * step, count - start))\n |> take_every_list(amount, step - 1)\n end\n\n {:error, module} ->\n slice_enum(enumerable, module, start, amount, step)\n end\n end\n\n defp slice_list(list, start, amount, step) do\n if step == 1 do\n list |> drop_list(start) |> take_list(amount)\n else\n list |> drop_list(start) |> take_every_list(amount, step - 1)\n end\n end\n\n defp slice_enum(enumerable, module, start, amount, 1) do\n {_, {_, _, slice}} =\n module.reduce(enumerable, {:cont, {start, amount, []}}, fn\n _entry, {start, amount, _list} when start > 0 ->\n {:cont, {start - 1, amount, []}}\n\n entry, {start, amount, list} when amount > 1 ->\n {:cont, {start, amount - 1, [entry | list]}}\n\n entry, {start, amount, list} ->\n {:halt, {start, amount, [entry | list]}}\n end)\n\n :lists.reverse(slice)\n end\n\n defp slice_enum(enumerable, module, start, amount, step) do\n {_, {_, _, _, slice}} =\n module.reduce(enumerable, {:cont, {start, amount, 1, []}}, fn\n _entry, {start, amount, to_drop, _list} when start > 0 ->\n {:cont, {start - 1, amount, to_drop, []}}\n\n entry, {start, amount, to_drop, list} when amount > 1 ->\n case to_drop do\n 1 -> {:cont, {start, amount - 1, step, [entry | list]}}\n _ -> {:cont, {start, amount - 1, to_drop - 1, list}}\n end\n\n entry, {start, amount, to_drop, list} ->\n case to_drop do\n 1 -> {:halt, {start, amount, to_drop, [entry | list]}}\n _ -> {:halt, {start, amount, to_drop, list}}\n end\n end)\n\n :lists.reverse(slice)\n end\n\n defp slice_count_and_fun(list, _step) when is_list(list) do\n length = length(list)\n {length, &slice_exact(list, &1, &2, &3, length)}\n end\n\n defp slice_count_and_fun(enumerable, step) do\n case Enumerable.slice(enumerable) do\n {:ok, count, fun} when is_function(fun, 1) ->\n {count, &slice_exact(fun.(enumerable), &1, &2, &3, count)}\n\n {:ok, count, fun} when is_function(fun, 3) ->\n {count, fun}\n\n # TODO: Remove me on v2.0\n {:ok, count, fun} when is_function(fun, 2) ->\n IO.warn(\n \"#{inspect(Enumerable.impl_for(enumerable))} must return a three arity function on slice/1\"\n )\n\n if step == 1 do\n {count, fn start, amount, 1 -> fun.(start, amount) end}\n else\n {count,\n fn start, amount, step ->\n fun.(start, Kernel.min(amount * step, count - start))\n |> take_every_list(amount, step - 1)\n end}\n end\n\n {:error, module} ->\n {list, count} =\n enumerable\n |> module.reduce({:cont, {[], 0}}, fn elem, {acc, count} ->\n {:cont, {[elem | acc], count + 1}}\n end)\n |> elem(1)\n\n {count,\n fn start, amount, step ->\n list |> :lists.reverse() |> slice_exact(start, amount, step, count)\n end}\n end\n end\n\n # Slice a list when we know the bounds\n defp slice_exact(_list, _start, 0, _step, _), do: []\n\n defp slice_exact(list, start, amount, 1, size) when start + amount == size,\n do: list |> drop_exact(start)\n\n defp slice_exact(list, start, amount, 1, _),\n do: list |> drop_exact(start) |> take_exact(amount)\n\n defp slice_exact(list, start, amount, step, _),\n do: list |> drop_exact(start) |> take_every_list(amount, step - 1)\n\n defp drop_exact(list, 0), do: list\n defp drop_exact([_ | tail], amount), do: drop_exact(tail, amount - 1)\n\n defp take_exact(_list, 0), do: []\n defp take_exact([head | tail], amount), do: [head | take_exact(tail, amount - 1)]\n\n ## sort\n\n defp sort_reducer(entry, {:split, y, x, r, rs, bool}, fun) do\n cond do\n fun.(y, entry) == bool ->\n {:split, entry, y, [x | r], rs, bool}\n\n fun.(x, entry) == bool ->\n {:split, y, entry, [x | r], rs, bool}\n\n r == [] ->\n {:split, y, x, [entry], rs, bool}\n\n true ->\n {:pivot, y, x, r, rs, entry, bool}\n end\n end\n\n defp sort_reducer(entry, {:pivot, y, x, r, rs, s, bool}, fun) do\n cond do\n fun.(y, entry) == bool ->\n {:pivot, entry, y, [x | r], rs, s, bool}\n\n fun.(x, entry) == bool ->\n {:pivot, y, entry, [x | r], rs, s, bool}\n\n fun.(s, entry) == bool ->\n {:split, entry, s, [], [[y, x | r] | rs], bool}\n\n true ->\n {:split, s, entry, [], [[y, x | r] | rs], bool}\n end\n end\n\n defp sort_reducer(entry, [x], fun) do\n {:split, entry, x, [], [], fun.(x, entry)}\n end\n\n defp sort_reducer(entry, acc, _fun) do\n [entry | acc]\n end\n\n defp sort_terminator({:split, y, x, r, rs, bool}, fun) do\n sort_merge([[y, x | r] | rs], fun, bool)\n end\n\n defp sort_terminator({:pivot, y, x, r, rs, s, bool}, fun) do\n sort_merge([[s], [y, x | r] | rs], fun, bool)\n end\n\n defp sort_terminator(acc, _fun) do\n acc\n end\n\n defp sort_merge(list, fun, true), do: reverse_sort_merge(list, [], fun, true)\n\n defp sort_merge(list, fun, false), do: sort_merge(list, [], fun, false)\n\n defp sort_merge([t1, [h2 | t2] | l], acc, fun, true),\n do: sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, false) | acc], fun, true)\n\n defp sort_merge([[h2 | t2], t1 | l], acc, fun, false),\n do: sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, false) | acc], fun, false)\n\n defp sort_merge([l], [], _fun, _bool), do: l\n\n defp sort_merge([l], acc, fun, bool),\n do: reverse_sort_merge([:lists.reverse(l, []) | acc], [], fun, bool)\n\n defp sort_merge([], acc, fun, bool), do: reverse_sort_merge(acc, [], fun, bool)\n\n defp reverse_sort_merge([[h2 | t2], t1 | l], acc, fun, true),\n do: reverse_sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, true) | acc], fun, true)\n\n defp reverse_sort_merge([t1, [h2 | t2] | l], acc, fun, false),\n do: reverse_sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, true) | acc], fun, false)\n\n defp reverse_sort_merge([l], acc, fun, bool),\n do: sort_merge([:lists.reverse(l, []) | acc], [], fun, bool)\n\n defp reverse_sort_merge([], acc, fun, bool), do: sort_merge(acc, [], fun, bool)\n\n defp sort_merge1([h1 | t1], h2, t2, m, fun, bool) do\n if fun.(h1, h2) == bool do\n sort_merge2(h1, t1, t2, [h2 | m], fun, bool)\n else\n sort_merge1(t1, h2, t2, [h1 | m], fun, bool)\n end\n end\n\n defp sort_merge1([], h2, t2, m, _fun, _bool), do: :lists.reverse(t2, [h2 | m])\n\n defp sort_merge2(h1, t1, [h2 | t2], m, fun, bool) do\n if fun.(h1, h2) == bool do\n sort_merge2(h1, t1, t2, [h2 | m], fun, bool)\n else\n sort_merge1(t1, h2, t2, [h1 | m], fun, bool)\n end\n end\n\n defp sort_merge2(h1, t1, [], m, _fun, _bool), do: :lists.reverse(t1, [h1 | m])\n\n ## split\n\n defp split_list([head | tail], counter, acc) when counter > 0 do\n split_list(tail, counter - 1, [head | acc])\n end\n\n defp split_list(list, 0, acc) do\n {:lists.reverse(acc), list}\n end\n\n defp split_list([], _, acc) do\n {:lists.reverse(acc), []}\n end\n\n defp split_reverse_list([head | tail], counter, acc) when counter > 0 do\n split_reverse_list(tail, counter - 1, [head | acc])\n end\n\n defp split_reverse_list(list, 0, acc) do\n {:lists.reverse(list), acc}\n end\n\n defp split_reverse_list([], _, acc) do\n {[], acc}\n end\n\n ## split_while\n\n defp split_while_list([head | tail], fun, acc) do\n if fun.(head) do\n split_while_list(tail, fun, [head | acc])\n else\n {:lists.reverse(acc), [head | tail]}\n end\n end\n\n defp split_while_list([], _, acc) do\n {:lists.reverse(acc), []}\n end\n\n ## sum_by\n\n defp sum_by_list([], _, acc), do: acc\n defp sum_by_list([h | t], mapper, acc), do: sum_by_list(t, mapper, acc + mapper.(h))\n\n ## product_by\n\n defp product_by_list([], _, acc), do: acc\n defp product_by_list([h | t], mapper, acc), do: product_by_list(t, mapper, acc * mapper.(h))\n\n ## take\n\n defp take_list(_list, 0), do: []\n defp take_list([head | tail], counter), do: [head | take_list(tail, counter - 1)]\n defp take_list([], _counter), do: []\n\n defp take_every_list([head | tail], to_drop),\n do: [head | tail |> drop_list(to_drop) |> take_every_list(to_drop)]\n\n defp take_every_list([], _to_drop), do: []\n\n defp take_every_list(_list, 0, _to_drop), do: []\n\n defp take_every_list([head | tail], counter, to_drop),\n do: [head | tail |> drop_list(to_drop) |> take_every_list(counter - 1, to_drop)]\n\n defp take_every_list([], _counter, _to_drop), do: []\n\n ## take_while\n\n defp take_while_list([head | tail], fun) do\n if fun.(head) do\n [head | take_while_list(tail, fun)]\n else\n []\n end\n end\n\n defp take_while_list([], _) do\n []\n end\n\n ## uniq\n\n defp uniq_list([head | tail], set, fun) do\n value = fun.(head)\n\n case set do\n %{^value => true} -> uniq_list(tail, set, fun)\n %{} -> [head | uniq_list(tail, Map.put(set, value, true), fun)]\n end\n end\n\n defp uniq_list([], _set, _fun) do\n []\n end\n\n ## with_index\n\n defp with_index_list([head | tail], offset) do\n [{head, offset} | with_index_list(tail, offset + 1)]\n end\n\n defp with_index_list([], _offset), do: []\n\n defp with_index_list([head | tail], offset, fun) do\n [fun.(head, offset) | with_index_list(tail, offset + 1, fun)]\n end\n\n defp with_index_list([], _offset, _fun), do: []\n\n ## zip\n\n defp zip_list([head1 | next1], [head2 | next2], acc) do\n zip_list(next1, next2, [{head1, head2} | acc])\n end\n\n defp zip_list([], _, acc), do: :lists.reverse(acc)\n defp zip_list(_, [], acc), do: :lists.reverse(acc)\n\n defp zip_with_list([head1 | next1], [head2 | next2], fun) do\n [fun.(head1, head2) | zip_with_list(next1, next2, fun)]\n end\n\n defp zip_with_list(_, [], _fun), do: []\n defp zip_with_list([], _, _fun), do: []\n\n defp zip_reduce_list([head1 | next1], [head2 | next2], acc, fun) do\n zip_reduce_list(next1, next2, fun.(head1, head2, acc), fun)\n end\n\n defp zip_reduce_list(_, [], acc, _fun), do: acc\n defp zip_reduce_list([], _, acc, _fun), do: acc\nend\n\ndefimpl Enumerable, for: List do\n def count(list), do: {:ok, length(list)}\n\n def member?(list, value), do: {:ok, :lists.member(value, list)}\n\n def slice([]), do: {:ok, 0, fn _, _, _ -> [] end}\n def slice(_list), do: {:error, __MODULE__}\n\n def reduce(_list, {:halt, acc}, _fun), do: {:halted, acc}\n def reduce(list, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}\n def reduce([], {:cont, acc}, _fun), do: {:done, acc}\n def reduce([head | tail], {:cont, acc}, fun), do: reduce(tail, fun.(head, acc), fun)\nend\n\ndefimpl Enumerable, for: Map do\n def count(map) do\n {:ok, map_size(map)}\n end\n\n def member?(map, {key, value}) do\n {:ok, match?(%{^key => ^value}, map)}\n end\n\n def member?(_map, _other) do\n {:ok, false}\n end\n\n def slice(map) do\n size = map_size(map)\n {:ok, size, &:maps.to_list/1}\n end\n\n def reduce(map, acc, fun) do\n Enumerable.List.reduce(:maps.to_list(map), acc, fun)\n end\nend\n\ndefimpl Enumerable, for: Function do\n def count(_function), do: {:error, __MODULE__}\n def member?(_function, _value), do: {:error, __MODULE__}\n def slice(_function), do: {:error, __MODULE__}\n\n def reduce(function, acc, fun) when is_function(function, 2), do: function.(acc, fun)\n\n def reduce(function, _acc, _fun) do\n raise Protocol.UndefinedError,\n protocol: @protocol,\n value: function,\n description: \"only anonymous functions of arity 2 are enumerable\"\n end\nend\n\ndefimpl Enumerable, for: Range do\n def reduce(first..last//step, acc, fun) do\n reduce(first, last, acc, fun, step)\n end\n\n # TODO: Remove me on v2.0\n reduce =\n quote generated: true do\n reduce(\n %{__struct__: Range, first: var!(first), last: var!(last)} = var!(range),\n var!(acc),\n var!(fun)\n )\n end\n\n def unquote(reduce) do\n step = if first <= last, do: 1, else: -1\n reduce(Map.put(range, :step, step), acc, fun)\n end\n\n defp reduce(_first, _last, {:halt, acc}, _fun, _step) do\n {:halted, acc}\n end\n\n defp reduce(first, last, {:suspend, acc}, fun, step) do\n {:suspended, acc, &reduce(first, last, &1, fun, step)}\n end\n\n defp reduce(first, last, {:cont, acc}, fun, step)\n when step > 0 and first <= last\n when step < 0 and first >= last do\n reduce(first + step, last, fun.(first, acc), fun, step)\n end\n\n defp reduce(_, _, {:cont, acc}, _fun, _up) do\n {:done, acc}\n end\n\n def member?(first..last//step, value) when is_integer(value) and step > 0 do\n {:ok, first <= value and value <= last and rem(value - first, step) == 0}\n end\n\n def member?(first..last//step, value) when is_integer(value) and step < 0 do\n {:ok, last <= value and value <= first and rem(value - first, step) == 0}\n end\n\n # TODO: Remove me on v2.0\n def member?(%{__struct__: Range, first: first, last: last} = range, value)\n when is_integer(value) do\n step = if first <= last, do: 1, else: -1\n member?(Map.put(range, :step, step), value)\n end\n\n def member?(_, _value) do\n {:ok, false}\n end\n\n def count(range) do\n {:ok, Range.size(range)}\n end\n\n def slice(first.._//step = range) do\n {:ok, Range.size(range), &slice(first + &1 * step, step * &3, &2)}\n end\n\n # TODO: Remove me on v2.0\n\n slice =\n quote generated: true do\n slice(%{__struct__: Range, first: var!(first), last: var!(last)} = var!(range))\n end\n\n def unquote(slice) do\n step = if first <= last, do: 1, else: -1\n slice(Map.put(range, :step, step))\n end\n\n defp slice(current, _step, 1), do: [current]\n\n defp slice(current, step, remaining) when remaining > 1 do\n [current | slice(current + step, step, remaining - 1)]\n end\nend\n" }, { "path": "lib/elixir/lib/exception.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Exception do\n @moduledoc \"\"\"\n Functions for dealing with throw/catch/exit and exceptions.\n\n This module also defines the behaviour required by custom\n exceptions. To define your own, see `defexception/1`.\n\n ## Formatting functions\n\n Several functions in this module help format exceptions.\n Some of these functions expect the stacktrace as argument.\n The stacktrace is typically available inside catch and\n rescue by using the `__STACKTRACE__/0` variable.\n\n Do not rely on the particular format returned by the\n functions in this module. They may be changed in future releases\n in order to better suit Elixir's tool chain. In other words,\n by using the functions in this module it is guaranteed you will\n format exceptions as in the current Elixir version being used.\n \"\"\"\n\n @typedoc \"The exception type\"\n @type t :: %{\n required(:__struct__) => module,\n required(:__exception__) => true,\n optional(atom) => any\n }\n\n @typedoc \"The kind handled by formatting functions\"\n @type kind :: :error | non_error_kind\n @type non_error_kind :: :exit | :throw | {:EXIT, pid}\n\n @type stacktrace :: [stacktrace_entry]\n @type stacktrace_entry ::\n {module, atom, arity_or_args, location}\n | {(... -> any), arity_or_args, location}\n\n @type arity_or_args :: non_neg_integer | list\n @type location :: keyword\n\n @doc \"\"\"\n Receives the arguments given to `raise/2` and returns the exception struct.\n\n The default implementation accepts either a set of keyword arguments\n that is merged into the struct or a string to be used as the exception's message.\n \"\"\"\n @callback exception(term) :: t\n\n @doc \"\"\"\n Receives the exception struct and must return its message.\n\n Many exceptions have a message field which by default is accessed\n by this function. However, if an exception does not have a message field,\n this function must be explicitly implemented.\n \"\"\"\n @callback message(t) :: String.t()\n\n @doc \"\"\"\n Called from `Exception.blame/3` to augment the exception struct.\n\n Can be used to collect additional information about the exception\n or do some additional expensive computation.\n \"\"\"\n @callback blame(t, stacktrace) :: {t, stacktrace}\n @optional_callbacks [blame: 2]\n\n @doc false\n # Callback for formatting Erlang exceptions\n def format_error(%struct{} = exception, _stacktrace) do\n %{general: message(exception), reason: \"#\" <> Atom.to_string(struct)}\n end\n\n @doc false\n @deprecated \"Use Kernel.is_exception/1 instead\"\n def exception?(term)\n def exception?(%_{__exception__: true}), do: true\n def exception?(_), do: false\n\n @doc \"\"\"\n Gets the message for an `exception`.\n\n This function will invoke the `c:message/1` callback on the exception\n module to retrieve the message. If the callback raises an exception or\n returns a non-binary value, this function will rescue the error and\n return a descriptive error message instead.\n \"\"\"\n @spec message(t) :: String.t()\n def message(%module{__exception__: true} = exception) do\n try do\n module.message(exception)\n rescue\n caught_exception ->\n \"got #{inspect(caught_exception.__struct__)} with message \" <>\n \"#{inspect(message(caught_exception))} while retrieving Exception.message/1 \" <>\n \"for #{inspect(exception)}. Stacktrace:\\n#{format_stacktrace(__STACKTRACE__)}\"\n else\n result when is_binary(result) ->\n result\n\n result ->\n \"got #{inspect(result)} \" <>\n \"while retrieving Exception.message/1 for #{inspect(exception)} \" <>\n \"(expected a string)\"\n end\n end\n\n @doc \"\"\"\n Normalizes an exception, converting Erlang exceptions\n to Elixir exceptions.\n\n It takes the `kind` spilled by `catch` as an argument and\n normalizes only `:error`, returning the untouched payload\n for others.\n\n The third argument is the stacktrace which is used to enrich\n a normalized error with more information. It is only used when\n the kind is an error.\n \"\"\"\n @spec normalize(:error, any, stacktrace) :: t\n @spec normalize(non_error_kind, payload, stacktrace) :: payload when payload: var\n def normalize(kind, payload, stacktrace \\\\ [])\n def normalize(:error, %_{__exception__: true} = payload, _stacktrace), do: payload\n def normalize(:error, payload, stacktrace), do: ErlangError.normalize(payload, stacktrace)\n def normalize(_kind, payload, _stacktrace), do: payload\n\n @doc \"\"\"\n Normalizes and formats any throw/error/exit.\n\n The message is formatted and displayed in the same\n format as used by Elixir's CLI.\n\n The third argument is the stacktrace which is used to enrich\n a normalized error with more information. It is only used when\n the kind is an error.\n \"\"\"\n @spec format_banner(kind, any, stacktrace) :: String.t()\n def format_banner(kind, exception, stacktrace \\\\ [])\n\n def format_banner(:error, exception, stacktrace) do\n exception = normalize(:error, exception, stacktrace)\n \"** (\" <> inspect(exception.__struct__) <> \") \" <> message(exception)\n end\n\n def format_banner(:throw, reason, _stacktrace) do\n \"** (throw) \" <> inspect(reason)\n end\n\n def format_banner(:exit, reason, _stacktrace) do\n \"** (exit) \" <> format_exit(reason, <<\"\\n \">>)\n end\n\n def format_banner({:EXIT, pid}, reason, _stacktrace) do\n \"** (EXIT from #{inspect(pid)}) \" <> format_exit(reason, <<\"\\n \">>)\n end\n\n @doc \"\"\"\n Normalizes and formats throws/errors/exits and stacktraces.\n\n It relies on `format_banner/3` and `format_stacktrace/1`\n to generate the final format.\n\n If `kind` is `{:EXIT, pid}`, it does not generate a stacktrace,\n as such exits are retrieved as messages without stacktraces.\n \"\"\"\n @spec format(kind, any, stacktrace) :: String.t()\n def format(kind, payload, stacktrace \\\\ [])\n\n def format({:EXIT, _} = kind, any, _) do\n format_banner(kind, any)\n end\n\n def format(kind, payload, stacktrace) do\n message = format_banner(kind, payload, stacktrace)\n\n case stacktrace do\n [] -> message\n _ -> message <> \"\\n\" <> format_stacktrace(stacktrace)\n end\n end\n\n @doc false\n def __format_message_with_term__(message, term) do\n inspected =\n term\n |> inspect(pretty: true)\n |> String.split(\"\\n\")\n |> Enum.map_intersperse(\"\\n\", fn\n \"\" -> \"\"\n line -> \" \" <> line\n end)\n\n IO.iodata_to_binary([message, \"\\n\\n\", inspected, \"\\n\"])\n end\n\n @doc \"\"\"\n Attaches information to throws/errors/exits for extra debugging.\n\n This operation is potentially expensive, as it reads data\n from the file system, parses beam files, evaluates code and\n so on.\n\n If `kind` argument is `:error` and the `error` is an Erlang exception, this function will\n normalize it. If the `error` argument is an Elixir exception, this function will invoke\n the optional `c:blame/2` callback on the exception module if it is implemented.\n Unlike `message/1`, this function will not rescue errors - if the callback raises an exception,\n the error will propagate to the caller. It is your choice if you want to rescue and return\n the original exception, return a different exception, or let it cascade.\n \"\"\"\n @doc since: \"1.5.0\"\n @spec blame(:error, any, stacktrace) :: {t, stacktrace}\n @spec blame(non_error_kind, payload, stacktrace) :: {payload, stacktrace} when payload: var\n def blame(kind, error, stacktrace)\n\n def blame(:error, error, stacktrace) do\n %module{} = struct = normalize(:error, error, stacktrace)\n\n if Code.ensure_loaded?(module) and function_exported?(module, :blame, 2) do\n module.blame(struct, stacktrace)\n else\n {struct, stacktrace}\n end\n end\n\n def blame(_kind, reason, stacktrace) do\n {reason, stacktrace}\n end\n\n @doc \"\"\"\n Blames the invocation of the given module, function and arguments.\n\n This function will retrieve the available clauses from bytecode\n and evaluate them against the given arguments. The clauses are\n returned as a list of `{args, guards}` pairs where each argument\n and each top-level condition in a guard separated by `and`/`or`\n is wrapped in a tuple with blame metadata.\n\n This function returns either `{:ok, definition, clauses}` or `:error`.\n Where `definition` is `:def`, `:defp`, `:defmacro` or `:defmacrop`.\n \"\"\"\n @doc since: \"1.5.0\"\n @spec blame_mfa(module, function :: atom, args :: [term]) ::\n {:ok, :def | :defp | :defmacro | :defmacrop, [{args :: [term], guards :: [term]}]}\n | :error\n def blame_mfa(module, function, args)\n when is_atom(module) and is_atom(function) and is_list(args) do\n try do\n blame_mfa(module, function, length(args), args)\n rescue\n _ -> :error\n end\n end\n\n defp blame_mfa(module, function, arity, call_args) do\n with [_ | _] = path <- :code.which(module),\n {:ok, {_, [debug_info: debug_info]}} <- :beam_lib.chunks(path, [:debug_info]),\n {:debug_info_v1, backend, data} <- debug_info,\n {:ok, %{definitions: defs}} <- backend.debug_info(:elixir_v1, module, data, []),\n {_, kind, _, clauses} <- List.keyfind(defs, {function, arity}, 0) do\n clauses =\n for {meta, ex_args, guards, _block} <- clauses do\n scope = :elixir_erl.scope(meta, true)\n ann = :elixir_erl.get_ann(meta)\n\n {erl_args, scope} =\n :elixir_erl_clauses.match(ann, &:elixir_erl_pass.translate_args/3, ex_args, scope)\n\n {args, binding} =\n [call_args, ex_args, erl_args]\n |> Enum.zip()\n |> Enum.map_reduce([], &blame_arg/2)\n\n guards =\n guards\n |> Enum.map(&blame_guard(&1, ann, scope, binding))\n |> Enum.map(&Macro.prewalk(&1, fn guard -> translate_guard(guard) end))\n\n {args, guards}\n end\n\n {:ok, kind, clauses}\n else\n _ -> :error\n end\n end\n\n defp map_node?({:is_map, _, [_]}), do: true\n defp map_node?(_), do: false\n defp map_key_node?({:is_map_key, _, [_, _]}), do: true\n defp map_key_node?(_), do: false\n\n defp struct_validation_node?(\n {:is_atom, _, [{{:., [], [:erlang, :map_get]}, _, [:__struct__, _]}]}\n ),\n do: true\n\n defp struct_validation_node?(\n {:==, _, [{{:., [], [:erlang, :map_get]}, _, [:__struct__, _]}, _module]}\n ),\n do: true\n\n defp struct_validation_node?(_), do: false\n\n defp struct_macro?(\n {:and, _,\n [\n {:and, _, [%{node: node_1 = {_, _, [arg]}}, %{node: node_2 = {_, _, [arg, _]}}]},\n %{node: node_3 = {_, _, [{_, _, [_, arg]}]}}\n ]}\n ),\n do: map_node?(node_1) and map_key_node?(node_2) and struct_validation_node?(node_3)\n\n defp struct_macro?(\n {:and, _,\n [\n {:and, _,\n [\n {:and, _,\n [\n %{node: node_1 = {_, _, [arg]}},\n {:or, _, [%{node: {:is_atom, _, [_]}}, %{node: :fail}]}\n ]},\n %{node: node_2 = {_, _, [arg, _]}}\n ]},\n %{node: node_3 = {_, _, [{_, _, [_, arg]}, _]}}\n ]}\n ),\n do: map_node?(node_1) and map_key_node?(node_2) and struct_validation_node?(node_3)\n\n defp struct_macro?(_), do: false\n\n defp translate_guard(guard) do\n if struct_macro?(guard) do\n undo_is_struct_guard(guard)\n else\n guard\n end\n end\n\n defp undo_is_struct_guard({:and, meta, [_, %{node: {_, _, [{_, _, [_, arg]} | optional]}}]}) do\n args =\n case optional do\n [] -> [arg]\n [module] -> [arg, module]\n end\n\n %{match?: meta[:value], node: {:is_struct, meta, args}}\n end\n\n defp blame_arg({call_arg, ex_arg, erl_arg}, binding) do\n {match?, binding} = blame_arg(erl_arg, call_arg, binding)\n {blame_wrap(match?, rewrite_arg(ex_arg)), binding}\n end\n\n defp blame_arg(erl_arg, call_arg, binding) do\n binding = :orddict.store(:VAR, call_arg, binding)\n\n try do\n ann = :erl_anno.new(0)\n\n {:value, _, binding} =\n :erl_eval.expr({:match, ann, erl_arg, {:var, ann, :VAR}}, binding, :none)\n\n {true, binding}\n rescue\n _ -> {false, binding}\n end\n end\n\n defp rewrite_arg(arg) do\n Macro.prewalk(arg, fn\n {:%{}, meta, [__struct__: Range, first: first, last: last, step: step]} ->\n {:..//, meta, [first, last, step]}\n\n other ->\n other\n end)\n end\n\n defp blame_guard({{:., _, [:erlang, op]}, meta, [left, right]}, ann, scope, binding)\n when op == :andalso or op == :orelse do\n guards = [\n blame_guard(left, ann, scope, binding),\n blame_guard(right, ann, scope, binding)\n ]\n\n kernel_op =\n case op do\n :orelse -> :or\n :andalso -> :and\n end\n\n evaluate_guard(kernel_op, meta, guards)\n end\n\n defp blame_guard(ex_guard, ann, scope, binding) do\n ex_guard\n |> blame_guard?(binding, ann, scope)\n |> blame_wrap(rewrite_guard(ex_guard))\n end\n\n defp blame_guard?(ex_guard, binding, ann, scope) do\n {erl_guard, _} = :elixir_erl_pass.translate(ex_guard, ann, scope)\n {:value, true, _} = :erl_eval.expr(erl_guard, binding, :none)\n true\n rescue\n _ -> false\n end\n\n defp evaluate_guard(kernel_op, meta, guards = [_, _]) do\n [x, y] = Enum.map(guards, &evaluate_guard/1)\n\n logic_value =\n case kernel_op do\n :or -> x or y\n :and -> x and y\n end\n\n {kernel_op, Keyword.put(meta, :value, logic_value), guards}\n end\n\n defp evaluate_guard(%{match?: value}), do: value\n defp evaluate_guard({_, meta, _}) when is_list(meta), do: meta[:value]\n\n defp rewrite_guard(guard) do\n Macro.prewalk(guard, fn\n {{:., _, [mod, fun]}, meta, args} -> erl_to_ex(mod, fun, args, meta)\n other -> other\n end)\n end\n\n defp erl_to_ex(mod, fun, args, meta) do\n case :elixir_rewrite.erl_to_ex(mod, fun, args) do\n {Kernel, fun, args, _} -> {fun, meta, args}\n {mod, fun, args, _} -> {{:., [], [mod, fun]}, meta, args}\n end\n end\n\n defp blame_wrap(match?, ast), do: %{match?: match?, node: ast}\n\n @doc \"\"\"\n Formats an exit. It returns a string.\n\n Often there are errors/exceptions inside exits. Exits are often\n wrapped by the caller and provide stacktraces too. This function\n formats exits in a way to nicely show the exit reason, caller\n and stacktrace.\n \"\"\"\n @spec format_exit(any) :: String.t()\n def format_exit(reason) do\n format_exit(reason, <<\"\\n \">>)\n end\n\n # 2-Tuple could be caused by an error if the second element is a stacktrace.\n defp format_exit({exception, maybe_stacktrace} = reason, joiner)\n when is_list(maybe_stacktrace) and maybe_stacktrace !== [] do\n try do\n Enum.map(maybe_stacktrace, &format_stacktrace_entry/1)\n catch\n :error, _ ->\n # Not a stacktrace, was an exit.\n format_exit_reason(reason)\n else\n formatted_stacktrace ->\n # Assume a non-empty list formattable as stacktrace is a\n # stacktrace, so exit was caused by an error.\n message =\n \"an exception was raised:\" <>\n joiner <> format_banner(:error, exception, maybe_stacktrace)\n\n Enum.join([message | formatted_stacktrace], joiner <> <<\" \">>)\n end\n end\n\n # :supervisor.start_link returns this error reason when it fails to init\n # because a child's start_link raises.\n defp format_exit({:shutdown, {:failed_to_start_child, child, {:EXIT, reason}}}, joiner) do\n format_start_child(child, reason, joiner)\n end\n\n # :supervisor.start_link returns this error reason when it fails to init\n # because a child's start_link returns {:error, reason}.\n defp format_exit({:shutdown, {:failed_to_start_child, child, reason}}, joiner) do\n format_start_child(child, reason, joiner)\n end\n\n # 2-Tuple could be an exit caused by mfa if second element is mfa, args\n # must be a list of arguments - max length 255 due to max arity.\n defp format_exit({reason2, {mod, fun, args}} = reason, joiner)\n when length(args) < 256 do\n try do\n format_mfa(mod, fun, args)\n catch\n :error, _ ->\n # Not an mfa, was an exit.\n format_exit_reason(reason)\n else\n mfa ->\n # Assume tuple formattable as an mfa is an mfa,\n # so exit was caused by failed mfa.\n \"exited in: \" <>\n mfa <> joiner <> \"** (EXIT) \" <> format_exit(reason2, joiner <> <<\" \">>)\n end\n end\n\n defp format_exit(reason, _joiner) do\n format_exit_reason(reason)\n end\n\n defp format_exit_reason(:normal), do: \"normal\"\n defp format_exit_reason(:shutdown), do: \"shutdown\"\n\n defp format_exit_reason({:shutdown, reason}) do\n \"shutdown: #{inspect(reason)}\"\n end\n\n defp format_exit_reason(:calling_self), do: \"process attempted to call itself\"\n defp format_exit_reason(:timeout), do: \"time out\"\n defp format_exit_reason(:killed), do: \"killed\"\n defp format_exit_reason(:noconnection), do: \"no connection\"\n\n defp format_exit_reason(:noproc) do\n \"no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started\"\n end\n\n defp format_exit_reason({:nodedown, node_name}) when is_atom(node_name) do\n \"no connection to #{node_name}\"\n end\n\n # :gen_server exit reasons\n\n defp format_exit_reason({:already_started, pid}) do\n \"already started: \" <> inspect(pid)\n end\n\n defp format_exit_reason({:bad_return_value, value}) do\n \"bad return value: \" <> inspect(value)\n end\n\n defp format_exit_reason({:bad_call, request}) do\n \"bad call: \" <> inspect(request)\n end\n\n defp format_exit_reason({:bad_cast, request}) do\n \"bad cast: \" <> inspect(request)\n end\n\n # :supervisor.start_link error reasons\n\n # If value is a list will be formatted by mfa exit in format_exit/1\n defp format_exit_reason({:bad_return, {mod, :init, value}})\n when is_atom(mod) do\n format_mfa(mod, :init, 1) <> \" returned a bad value: \" <> inspect(value)\n end\n\n defp format_exit_reason({:bad_start_spec, start_spec}) do\n \"bad child specification, invalid children: \" <> inspect(start_spec)\n end\n\n defp format_exit_reason({:start_spec, start_spec}) do\n \"bad child specification, \" <> format_sup_spec(start_spec)\n end\n\n defp format_exit_reason({:supervisor_data, data}) do\n \"bad supervisor configuration, \" <> format_sup_data(data)\n end\n\n defp format_exit_reason(reason), do: inspect(reason)\n\n defp format_start_child(child, reason, joiner) do\n \"shutdown: failed to start child: \" <>\n inspect(child) <> joiner <> \"** (EXIT) \" <> format_exit(reason, joiner <> <<\" \">>)\n end\n\n defp format_sup_data({:invalid_type, type}) do\n \"invalid type: \" <> inspect(type)\n end\n\n defp format_sup_data({:invalid_strategy, strategy}) do\n \"invalid strategy: \" <> inspect(strategy)\n end\n\n defp format_sup_data({:invalid_intensity, intensity}) do\n \"invalid max_restarts (intensity): \" <> inspect(intensity)\n end\n\n defp format_sup_data({:invalid_period, period}) do\n \"invalid max_seconds (period): \" <> inspect(period)\n end\n\n defp format_sup_data({:invalid_max_children, max_children}) do\n \"invalid max_children: \" <> inspect(max_children)\n end\n\n defp format_sup_data({:invalid_extra_arguments, extra}) do\n \"invalid extra_arguments: \" <> inspect(extra)\n end\n\n defp format_sup_data(other), do: \"got: #{inspect(other)}\"\n\n defp format_sup_spec({:duplicate_child_name, id}) do\n \"\"\"\n more than one child specification has the id: #{inspect(id)}.\n If using maps as child specifications, make sure the :id keys are unique.\n If using a module or {module, arg} as child, use Supervisor.child_spec/2 to change the :id, for example:\n\n children = [\n Supervisor.child_spec({MyWorker, arg}, id: :my_worker_1),\n Supervisor.child_spec({MyWorker, arg}, id: :my_worker_2)\n ]\n \"\"\"\n end\n\n defp format_sup_spec({:invalid_child_spec, child_spec}) do\n \"invalid child specification: #{inspect(child_spec)}\"\n end\n\n defp format_sup_spec({:invalid_child_type, type}) do\n \"invalid child type: #{inspect(type)}. Must be :worker or :supervisor.\"\n end\n\n defp format_sup_spec({:invalid_mfa, mfa}) do\n \"invalid mfa: #{inspect(mfa)}\"\n end\n\n defp format_sup_spec({:invalid_restart_type, restart}) do\n \"invalid restart type: #{inspect(restart)}. Must be :permanent, :transient or :temporary.\"\n end\n\n defp format_sup_spec({:invalid_shutdown, shutdown}) do\n \"invalid shutdown: #{inspect(shutdown)}. Must be an integer >= 0, :infinity or :brutal_kill.\"\n end\n\n defp format_sup_spec({:invalid_module, mod}) do\n \"invalid module: #{inspect(mod)}. Must be an atom.\"\n end\n\n defp format_sup_spec({:invalid_modules, modules}) do\n \"invalid modules: #{inspect(modules)}. Must be a list of atoms or :dynamic.\"\n end\n\n defp format_sup_spec(other), do: \"got: #{inspect(other)}\"\n\n @doc \"\"\"\n Receives a stacktrace entry and formats it into a string.\n \"\"\"\n @spec format_stacktrace_entry(stacktrace_entry) :: String.t()\n def format_stacktrace_entry(entry)\n\n # From Macro.Env.stacktrace\n def format_stacktrace_entry({module, :__MODULE__, 0, location}) do\n format_location(location) <> inspect(module) <> \" (module)\"\n end\n\n # From :elixir_compiler_*\n def format_stacktrace_entry({_module, :__MODULE__, 1, location}) do\n format_location(location) <> \"(module)\"\n end\n\n # From :elixir_compiler_*\n def format_stacktrace_entry({_module, :__FILE__, 1, location}) do\n format_location(location) <> \"(file)\"\n end\n\n def format_stacktrace_entry({module, fun, arity, location}) do\n format_application(module) <> format_location(location) <> format_mfa(module, fun, arity)\n end\n\n def format_stacktrace_entry({fun, arity, location}) do\n format_location(location) <> format_fa(fun, arity)\n end\n\n defp format_application(module) do\n # We cannot use Application due to bootstrap issues\n case :application.get_application(module) do\n {:ok, app} ->\n case :application.get_key(app, :vsn) do\n {:ok, vsn} when is_list(vsn) ->\n \"(\" <> Atom.to_string(app) <> \" \" <> List.to_string(vsn) <> \") \"\n\n _ ->\n \"(\" <> Atom.to_string(app) <> \") \"\n end\n\n :undefined ->\n \"\"\n end\n end\n\n @doc \"\"\"\n Formats the stacktrace.\n\n A stacktrace must be given as an argument. If not, the stacktrace\n is retrieved from `Process.info/2`.\n \"\"\"\n @spec format_stacktrace(stacktrace | nil) :: String.t()\n def format_stacktrace(trace \\\\ nil) do\n trace =\n if trace do\n trace\n else\n case Process.info(self(), :current_stacktrace) do\n {:current_stacktrace, t} -> Enum.drop(t, 3)\n end\n end\n\n case trace do\n [] -> \"\\n\"\n _ -> \" \" <> Enum.map_join(trace, \"\\n \", &format_stacktrace_entry(&1)) <> \"\\n\"\n end\n end\n\n @doc \"\"\"\n Receives an anonymous function and arity and formats it as\n shown in stacktraces. The arity may also be a list of arguments.\n\n ## Examples\n\n Exception.format_fa(fn -> nil end, 1)\n #=> \"#Function<...>/1\"\n\n \"\"\"\n @spec format_fa(fun, arity) :: String.t()\n def format_fa(fun, arity) when is_function(fun) do\n \"#{inspect(fun)}#{format_arity(arity)}\"\n end\n\n @doc \"\"\"\n Receives a module, fun and arity and formats it\n as shown in stacktraces. The arity may also be a list\n of arguments.\n\n ## Examples\n\n iex> Exception.format_mfa(Foo, :bar, 1)\n \"Foo.bar/1\"\n\n iex> Exception.format_mfa(Foo, :bar, [])\n \"Foo.bar()\"\n\n iex> Exception.format_mfa(nil, :bar, [])\n \"nil.bar()\"\n\n Anonymous functions are reported as -func/arity-anonfn-count-,\n where func is the name of the enclosing function. Convert to\n \"anonymous fn in func/arity\"\n \"\"\"\n @spec format_mfa(module, atom, arity_or_args) :: String.t()\n def format_mfa(module, fun, arity) when is_atom(module) and is_atom(fun) do\n case Code.Identifier.extract_anonymous_fun_parent(fun) do\n {outer_name, outer_arity} ->\n \"anonymous fn#{format_arity(arity)} in \" <>\n \"#{Macro.inspect_atom(:literal, module)}.\" <>\n \"#{Macro.inspect_atom(:remote_call, outer_name)}/#{outer_arity}\"\n\n :error ->\n \"#{Macro.inspect_atom(:literal, module)}.\" <>\n \"#{Macro.inspect_atom(:remote_call, fun)}#{format_arity(arity)}\"\n end\n end\n\n defp format_arity(arity) when is_list(arity) do\n inspected = for x <- arity, do: inspect(x)\n \"(#{Enum.join(inspected, \", \")})\"\n end\n\n defp format_arity(arity) when is_integer(arity) do\n \"/\" <> Integer.to_string(arity)\n end\n\n @doc \"\"\"\n Formats the given `file` and `line` as shown in stacktraces.\n\n If any of the values are `nil`, they are omitted.\n\n ## Examples\n\n iex> Exception.format_file_line(\"foo\", 1)\n \"foo:1:\"\n\n iex> Exception.format_file_line(\"foo\", nil)\n \"foo:\"\n\n iex> Exception.format_file_line(nil, nil)\n \"\"\n\n \"\"\"\n @spec format_file_line(String.t() | nil, non_neg_integer | nil, String.t()) :: String.t()\n def format_file_line(file, line, suffix \\\\ \"\") do\n cond do\n is_nil(file) -> \"\"\n is_nil(line) or line == 0 -> \"#{file}:#{suffix}\"\n true -> \"#{file}:#{line}:#{suffix}\"\n end\n end\n\n @doc \"\"\"\n Formats the given `file`, `line`, and `column` as shown in stacktraces.\n\n If any of the values are `nil`, they are omitted.\n\n ## Examples\n\n iex> Exception.format_file_line_column(\"foo\", 1, 2)\n \"foo:1:2:\"\n\n iex> Exception.format_file_line_column(\"foo\", 1, nil)\n \"foo:1:\"\n\n iex> Exception.format_file_line_column(\"foo\", nil, nil)\n \"foo:\"\n\n iex> Exception.format_file_line_column(\"foo\", nil, 2)\n \"foo:\"\n\n iex> Exception.format_file_line_column(nil, nil, nil)\n \"\"\n\n \"\"\"\n @spec format_file_line_column(\n String.t() | nil,\n non_neg_integer | nil,\n non_neg_integer | nil,\n String.t()\n ) :: String.t()\n def format_file_line_column(file, line, column, suffix \\\\ \"\") do\n cond do\n is_nil(file) -> \"\"\n is_nil(line) or line == 0 -> \"#{file}:#{suffix}\"\n is_nil(column) or column == 0 -> \"#{file}:#{line}:#{suffix}\"\n true -> \"#{file}:#{line}:#{column}:#{suffix}\"\n end\n end\n\n defp format_location(opts) when is_list(opts) do\n case opts[:column] do\n nil -> format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line), \" \")\n col -> format_file_line_column(Keyword.get(opts, :file), Keyword.get(opts, :line), col, \" \")\n end\n end\n\n @doc false\n def format_delimiter(delimiter) do\n if delimiter |> Atom.to_string() |> String.contains?([\"\\\"\", \"'\"]),\n do: delimiter,\n else: ~s(\"#{delimiter}\")\n end\n\n @doc false\n def format_snippet(\n {start_line, _start_column} = start_pos,\n {end_line, end_column} = end_pos,\n description,\n file,\n lines,\n start_message,\n end_message\n )\n when start_line < end_line do\n max_digits = digits(end_line)\n general_padding = max(2, max_digits) + 1\n padding = n_spaces(general_padding)\n\n relevant_lines =\n if end_line - start_line < 5 do\n line_range(lines, start_pos, end_pos, padding, max_digits, start_message, end_message)\n else\n trimmed_inbetween_lines(\n lines,\n start_pos,\n end_pos,\n padding,\n max_digits,\n start_message,\n end_message\n )\n end\n\n \"\"\"\n #{padding}#{red(\"error:\")} #{pad_message(description, padding)}\n #{padding}│\n #{relevant_lines}\n #{padding}│\n #{padding}└─ #{Path.relative_to_cwd(file)}:#{end_line}:#{end_column}\\\n \"\"\"\n end\n\n def format_snippet(\n {start_line, start_column},\n {end_line, end_column},\n description,\n file,\n lines,\n start_message,\n end_message\n )\n when start_line == end_line do\n max_digits = digits(end_line)\n general_padding = max(2, max_digits) + 1\n padding = n_spaces(general_padding)\n formatted_line = [line_padding(end_line, max_digits), to_string(end_line), \" │ \", hd(lines)]\n\n mismatched_closing_line =\n [\n n_spaces(start_column - 1),\n red(\"│\"),\n format_end_message(end_column - start_column, end_message)\n ]\n\n unclosed_delimiter_line =\n [padding, \" │ \", format_start_message(start_column, start_message)]\n\n below_line = [padding, \" │ \", mismatched_closing_line, \"\\n\", unclosed_delimiter_line]\n\n \"\"\"\n #{padding}#{red(\"error:\")} #{pad_message(description, padding)}\n #{padding}│\n #{formatted_line}\n #{below_line}\n #{padding}│\n #{padding}└─ #{Path.relative_to_cwd(file)}:#{end_line}:#{end_column}\\\n \"\"\"\n end\n\n defp line_padding(line_number, max_digits) do\n line_digits = digits(line_number)\n\n spacing =\n if line_digits == 1 do\n max(2, max_digits)\n else\n max_digits - line_digits + 1\n end\n\n n_spaces(spacing)\n end\n\n defp n_spaces(n), do: String.duplicate(\" \", n)\n\n defp digits(number, acc \\\\ 1)\n defp digits(number, acc) when number < 10, do: acc\n defp digits(number, acc), do: digits(div(number, 10), acc + 1)\n\n defp trimmed_inbetween_lines(\n lines,\n {start_line, start_column},\n {end_line, end_column},\n padding,\n max_digits,\n start_message,\n end_message\n ) do\n start_padding = line_padding(start_line, max_digits)\n end_padding = line_padding(end_line, max_digits)\n first_line = hd(lines)\n last_line = List.last(lines)\n\n \"\"\"\n #{start_padding}#{start_line} │ #{first_line}\n #{padding}│ #{format_start_message(start_column, start_message)}\n ...\n #{end_padding}#{end_line} │ #{last_line}\n #{padding}│ #{format_end_message(end_column, end_message)}\\\n \"\"\"\n end\n\n defp line_range(\n lines,\n {start_line, start_column},\n {end_line, end_column},\n padding,\n max_digits,\n start_message,\n end_message\n ) do\n Enum.zip_with(lines, start_line..end_line, fn line, line_number ->\n line_padding = line_padding(line_number, max_digits)\n\n cond do\n line_number == start_line ->\n [\n line_padding,\n to_string(line_number),\n \" │ \",\n line,\n \"\\n\",\n padding,\n \" │ \",\n format_start_message(start_column, start_message)\n ]\n\n line_number == end_line ->\n [\n line_padding,\n to_string(line_number),\n \" │ \",\n line,\n \"\\n\",\n padding,\n \" │ \",\n format_end_message(end_column, end_message)\n ]\n\n true ->\n [line_padding, to_string(line_number), \" │ \", line]\n end\n end)\n |> Enum.intersperse(\"\\n\")\n end\n\n defp format_end_message(end_column, message),\n do: [\n n_spaces(end_column - 1),\n red(message)\n ]\n\n defp format_start_message(start_column, message),\n do: [n_spaces(start_column - 1), red(message)]\n\n defp pad_message(message, padding), do: String.replace(message, \"\\n\", \"\\n #{padding}\")\n\n defp red(string) do\n if IO.ANSI.enabled?() do\n [IO.ANSI.red(), string, IO.ANSI.reset()]\n else\n string\n end\n end\nend\n\n# Some exceptions implement \"message/1\" instead of \"exception/1\" mostly\n# for bootstrap reasons. It is recommended for applications to implement\n# \"exception/1\" instead of \"message/1\" as described in \"defexception/1\"\n# docs.\n\ndefmodule RuntimeError do\n @moduledoc \"\"\"\n An exception for a generic runtime error.\n\n This is the exception that `raise/1` raises when you pass it only a string as\n a message:\n\n iex> raise \"oops!\"\n ** (RuntimeError) oops!\n\n You should use this exceptions sparingly, since most of the time it might be\n better to define your own exceptions specific to your application or library.\n Sometimes, however, there are situations in which you don't expect a condition to\n happen, but you want to give a meaningful error message if it does. In those cases,\n `RuntimeError` can be a good choice.\n\n ## Fields\n\n `RuntimeError` exceptions have a single field, `:message` (a `t:String.t/0`),\n which is public and can be accessed freely when reading or creating `RuntimeError`\n exceptions.\n \"\"\"\n\n defexception message: \"runtime error\"\nend\n\ndefmodule ArgumentError do\n @moduledoc \"\"\"\n An exception raised when an argument to a function is invalid.\n\n You can raise this exception when you want to signal that an argument to\n a function is invalid. For example, this exception is raised when calling\n `Integer.to_string/1` with an invalid argument:\n\n iex> Integer.to_string(1.0)\n ** (ArgumentError) errors were found at the given arguments:\n ...\n\n `ArgumentError` exceptions have a single field, `:message` (a `t:String.t/0`),\n which is public and can be accessed freely when reading or creating `ArgumentError`\n exceptions.\n \"\"\"\n\n defexception message: \"argument error\"\nend\n\ndefmodule ArithmeticError do\n @moduledoc \"\"\"\n An exception raised on invalid arithmetic operations.\n\n For example, this exception is raised if you divide by `0`:\n\n iex> 1 / 0\n ** (ArithmeticError) bad argument in arithmetic expression\n \"\"\"\n\n defexception message: \"bad argument in arithmetic expression\"\n\n @unary_ops [:+, :-]\n @binary_ops [:+, :-, :*, :/]\n @binary_funs [:div, :rem]\n @bitwise_binary_funs [:band, :bor, :bxor, :bsl, :bsr]\n\n @impl true\n def blame(%{message: message} = exception, [{:erlang, fun, args, _} | _] = stacktrace) do\n message =\n message <>\n case {fun, args} do\n {op, [a]} when op in @unary_ops ->\n \": #{op}(#{inspect(a)})\"\n\n {op, [a, b]} when op in @binary_ops ->\n \": #{inspect(a)} #{op} #{inspect(b)}\"\n\n {fun, [a, b]} when fun in @binary_funs ->\n \": #{fun}(#{inspect(a)}, #{inspect(b)})\"\n\n {fun, [a, b]} when fun in @bitwise_binary_funs ->\n \": Bitwise.#{fun}(#{inspect(a)}, #{inspect(b)})\"\n\n {:bnot, [a]} ->\n \": Bitwise.bnot(#{inspect(a)})\"\n\n _ ->\n \"\"\n end\n\n {%{exception | message: message}, stacktrace}\n end\n\n def blame(exception, stacktrace) do\n {exception, stacktrace}\n end\nend\n\ndefmodule SystemLimitError do\n @moduledoc \"\"\"\n An exception raised when a system limit has been reached.\n\n For example, this can happen if you try to create an atom that is too large:\n\n iex> String.to_atom(String.duplicate(\"a\", 100_000))\n ** (SystemLimitError) a system limit has been reached\n \"\"\"\n\n defexception message: \"a system limit has been reached\"\nend\n\ndefmodule MismatchedDelimiterError do\n @moduledoc \"\"\"\n An exception raised when a mismatched delimiter is found when parsing code.\n\n For example:\n\n iex> Code.eval_string(\"[1, 2, 3}\")\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:1:9:\n ...\n\n The following fields of this exceptions are public and can be accessed freely:\n\n * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if\n the error occurred in code that did not come from a file\n * `:line` - the line for the opening delimiter\n * `:column` - the column for the opening delimiter\n * `:end_line` - the line for the mismatched closing delimiter\n * `:end_column` - the column for the mismatched closing delimiter\n * `:opening_delimiter` - an atom representing the opening delimiter\n * `:closing_delimiter` - an atom representing the mismatched closing delimiter\n * `:expected_delimiter` - an atom representing the closing delimiter\n * `:description` - a description of the mismatched delimiter error\n \"\"\"\n\n defexception [\n :file,\n :line,\n :column,\n :end_line,\n :end_column,\n :opening_delimiter,\n :closing_delimiter,\n :expected_delimiter,\n :snippet,\n description: \"mismatched delimiter error\"\n ]\n\n @impl true\n def message(%{\n line: start_line,\n column: start_column,\n end_line: end_line,\n end_column: end_column,\n description: description,\n expected_delimiter: expected_delimiter,\n file: file,\n snippet: snippet\n }) do\n start_pos = {start_line, start_column}\n end_pos = {end_line, end_column}\n lines = String.split(snippet, \"\\n\")\n expected_delimiter = Exception.format_delimiter(expected_delimiter)\n\n start_message = \"└ unclosed delimiter\"\n end_message = ~s/└ mismatched closing delimiter (expected #{expected_delimiter})/\n\n snippet =\n Exception.format_snippet(\n start_pos,\n end_pos,\n description,\n file,\n lines,\n start_message,\n end_message\n )\n\n format_message(file, end_line, end_column, snippet)\n end\n\n defp format_message(file, line, column, message) do\n location = Exception.format_file_line_column(Path.relative_to_cwd(file), line, column)\n \"mismatched delimiter found on \" <> location <> \"\\n\" <> message\n end\nend\n\ndefmodule SyntaxError do\n @moduledoc \"\"\"\n An exception raised when there's a syntax error when parsing code.\n\n For example:\n\n iex> Code.eval_string(\"5 + 5h\")\n ** (SyntaxError) invalid syntax found on nofile:1:5:\n ...\n\n The following fields of this exceptions are public and can be accessed freely:\n\n * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if\n the error occurred in code that did not come from a file\n * `:line` - the line where the error occurred\n * `:column` - the column where the error occurred\n * `:description` - a description of the syntax error\n \"\"\"\n\n defexception [:file, :line, :column, :snippet, description: \"syntax error\"]\n\n @impl true\n def message(%{\n file: file,\n line: line,\n column: column,\n description: description,\n snippet: snippet\n })\n when not is_nil(snippet) and not is_nil(column) do\n snippet =\n :elixir_errors.format_snippet(:error, {line, column}, file, description, snippet, %{})\n\n format_message(file, line, column, snippet)\n end\n\n @impl true\n def message(%{\n file: file,\n line: line,\n column: column,\n description: description\n }) do\n snippet =\n :elixir_errors.format_snippet(:error, {line, column}, file, description, nil, %{})\n\n padded = \" \" <> String.replace(snippet, \"\\n\", \"\\n \")\n format_message(file, line, column, padded)\n end\n\n defp format_message(file, line, column, message) do\n location = Exception.format_file_line_column(Path.relative_to_cwd(file), line, column)\n \"invalid syntax found on \" <> location <> \"\\n\" <> message\n end\nend\n\ndefmodule TokenMissingError do\n @moduledoc \"\"\"\n An exception raised when a token is missing when parsing code.\n\n For example:\n\n iex> Code.eval_string(\"[1, 2, 3\")\n ** (TokenMissingError) token missing on nofile:1:9:\n ...\n\n The following fields of this exceptions are public and can be accessed freely:\n\n * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if\n the error occurred in code that did not come from a file\n * `:line` - the line for the opening delimiter\n * `:column` - the column for the opening delimiter\n * `:end_line` - the line for the end of the string\n * `:end_column` - the column for the end of the string\n * `:opening_delimiter` - an atom representing the opening delimiter\n * `:expected_delimiter` - an atom representing the expected delimiter\n * `:description` - a description of the missing token error\n\n This is mostly raised by Elixir tooling when compiling and evaluating code.\n \"\"\"\n\n defexception [\n :file,\n :line,\n :column,\n :end_line,\n :end_column,\n :snippet,\n :opening_delimiter,\n :expected_delimiter,\n description: \"expression is incomplete\"\n ]\n\n @impl true\n def message(%{\n file: file,\n line: line,\n column: column,\n end_line: end_line,\n description: description,\n expected_delimiter: expected_delimiter,\n snippet: snippet\n })\n when not is_nil(snippet) and not is_nil(column) and not is_nil(end_line) do\n {trimmed, [last_line | _] = reversed_lines} =\n snippet\n |> String.split(\"\\n\")\n |> Enum.reverse()\n |> Enum.split_while(&(&1 == \"\"))\n\n end_line = end_line - length(trimmed)\n end_column = String.length(last_line) + 1\n\n start_pos = {line, column}\n end_pos = {end_line, end_column}\n expected_delimiter = Exception.format_delimiter(expected_delimiter)\n\n start_message = ~s/└ unclosed delimiter/\n end_message = ~s/└ missing closing delimiter (expected #{expected_delimiter})/\n\n snippet =\n Exception.format_snippet(\n start_pos,\n end_pos,\n description,\n file,\n Enum.reverse(reversed_lines),\n start_message,\n end_message\n )\n\n format_message(file, end_line, end_column, snippet)\n end\n\n @impl true\n def message(%{\n file: file,\n line: line,\n column: column,\n snippet: snippet,\n description: description\n }) do\n snippet =\n :elixir_errors.format_snippet(:error, {line, column}, file, description, snippet, %{})\n\n format_message(file, line, column, snippet)\n end\n\n defp format_message(file, line, column, message) do\n location = Exception.format_file_line_column(Path.relative_to_cwd(file), line, column)\n \"token missing on \" <> location <> \"\\n\" <> message\n end\nend\n\ndefmodule CompileError do\n @moduledoc \"\"\"\n An exception raised when there's an error when compiling code.\n\n For example:\n\n 1 = y\n ** (CompileError) iex:1: undefined variable \"y\"\n\n The following fields of this exceptions are public and can be accessed freely:\n\n * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if\n the error occurred in code that did not come from a file\n * `:line` (`t:non_neg_integer/0`) - the line where the error occurred\n * `:description` (`t:String.t/0`) - a description of the compile error\n\n This is mostly raised by Elixir tooling when compiling and evaluating code.\n \"\"\"\n\n defexception [:file, :line, description: \"compile error\"]\n\n @impl true\n def message(%{file: file, line: line, description: description}) do\n case Exception.format_file_line(file && Path.relative_to_cwd(file), line) do\n \"\" -> description\n formatted -> formatted <> \" \" <> description\n end\n end\nend\n\ndefmodule Kernel.TypespecError do\n @moduledoc \"\"\"\n An exception raised when there's an error in a typespec.\n\n For example, if your typespec definition points to an invalid type, you get an exception:\n\n @type my_type :: intger()\n\n will raise:\n\n ** (Kernel.TypespecError) type intger/0 undefined\n\n The following fields of this exceptions are public and can be accessed freely:\n\n * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if\n the error occurred in code that did not come from a file\n * `:line` (`t:non_neg_integer/0`) - the line where the error occurred\n \"\"\"\n\n defexception [:file, :line, :description]\n\n @impl true\n def message(%{file: file, line: line, description: description}) do\n case Exception.format_file_line(file && Path.relative_to_cwd(file), line) do\n \"\" -> description\n formatted -> formatted <> \" \" <> description\n end\n end\nend\n\ndefmodule BadFunctionError do\n @moduledoc \"\"\"\n An exception raised when a function is expected, but something else was given.\n\n For example:\n\n iex> value = \"hello\"\n iex> value.()\n ** (BadFunctionError) expected a function, got: \"hello\"\n \"\"\"\n\n defexception [:term]\n\n @impl true\n def message(%{term: term}) when is_function(term) do\n \"function #{inspect(term)} is invalid, likely because it points to an old version of the code\"\n end\n\n def message(exception) do\n \"expected a function, got: #{inspect(exception.term)}\"\n end\nend\n\ndefmodule BadMapError do\n @moduledoc \"\"\"\n An exception raised when a map is expected, but something else was given.\n\n For example:\n\n iex> value = \"hello\"\n iex> %{value | key: \"value\"}\n ** (BadMapError) expected a map, got:\n ...\n \"\"\"\n\n defexception [:term]\n\n @impl true\n def message(exception) do\n Exception.__format_message_with_term__(\n \"expected a map, got:\",\n exception.term\n )\n end\nend\n\ndefmodule BadBooleanError do\n @moduledoc \"\"\"\n An exception raised when a boolean is expected, but something else was given.\n\n This exception is raised by `and` and `or` when the first argument is not a boolean:\n\n iex> 123 and true\n ** (BadBooleanError) expected a boolean on left-side of \"and\", got:\n ...\n \"\"\"\n\n defexception [:term, :operator]\n\n @impl true\n def message(exception) do\n Exception.__format_message_with_term__(\n \"expected a boolean on left-side of \\\"#{exception.operator}\\\", got:\",\n exception.term\n )\n end\nend\n\ndefmodule MatchError do\n @moduledoc \"\"\"\n An exception raised when a pattern match (`=/2`) fails.\n\n For example:\n\n iex> [_ | _] = []\n ** (MatchError) no match of right hand side value:\n ...\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:term` (`t:term/0`) - the term that did not match the pattern\n\n \"\"\"\n\n defexception [:term]\n\n @impl true\n def message(exception) do\n Exception.__format_message_with_term__(\n \"no match of right hand side value:\",\n exception.term\n )\n end\nend\n\ndefmodule CaseClauseError do\n @moduledoc \"\"\"\n An exception raised when a term in a `case/2` expression\n does not match any of the defined `->` clauses.\n\n For example:\n\n iex> case System.unique_integer() do\n ...> bin when is_binary(bin) -> :oops\n ...> :ok -> :neither_this_one\n ...> end\n ** (CaseClauseError) no case clause matching:\n ...\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:term` (`t:term/0`) - the term that did not match any of the clauses\n \"\"\"\n\n defexception [:term]\n\n @impl true\n def message(exception) do\n Exception.__format_message_with_term__(\n \"no case clause matching:\",\n exception.term\n )\n end\nend\n\ndefmodule WithClauseError do\n @moduledoc \"\"\"\n An exception raised when a term in a `with/1` expression\n does not match any of the defined `->` clauses in its `else`.\n\n For example, this exception gets raised for a `with/1` like the following, because\n the `{:ok, 2}` term does not match the `:error` or `{:error, _}` clauses in the\n `else`:\n\n iex> with {:ok, 1} <- {:ok, 2} do\n ...> :woah\n ...> else\n ...> :error -> :error\n ...> {:error, _} -> :error\n ...> end\n ** (WithClauseError) no with clause matching:\n ...\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:term` (`t:term/0`) - the term that did not match any of the clauses\n \"\"\"\n\n defexception [:term]\n\n @impl true\n def message(exception) do\n Exception.__format_message_with_term__(\n \"no with clause matching:\",\n exception.term\n )\n end\nend\n\ndefmodule CondClauseError do\n @moduledoc \"\"\"\n An exception raised when no clauses in a `cond/1` expression evaluate to a truthy value.\n\n For example, this exception gets raised for a `cond/1` like the following:\n\n iex> cond do\n ...> 1 + 1 == 3 -> :woah\n ...> nil -> \"yeah this won't happen\"\n ...> end\n ** (CondClauseError) no cond clause evaluated to a truthy value\n \"\"\"\n\n defexception []\n\n @impl true\n def message(_exception) do\n \"no cond clause evaluated to a truthy value\"\n end\nend\n\ndefmodule TryClauseError do\n @moduledoc \"\"\"\n An exception raised when none of the `else` clauses in a `try/1` match.\n\n For example:\n\n iex> try do\n ...> :ok\n ...> rescue\n ...> e -> e\n ...> else\n ...> # :ok -> :ok is missing\n ...> :not_ok -> :not_ok\n ...> end\n ** (TryClauseError) no try clause matching:\n ...\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:term` (`t:term/0`) - the term that did not match any of the clauses\n\n \"\"\"\n defexception [:term]\n\n @impl true\n def message(exception) do\n Exception.__format_message_with_term__(\n \"no try clause matching:\",\n exception.term\n )\n end\nend\n\ndefmodule BadArityError do\n @moduledoc \"\"\"\n An exception raised when a function is called with the wrong number of arguments.\n\n For example:\n\n my_function = fn x, y -> x + y end\n my_function.(42)\n ** (BadArityError) #Function<41.39164016/2 in :erl_eval.expr/6> with arity 2 called with 1 argument (42)\n \"\"\"\n\n defexception [:function, :args]\n\n @impl true\n def message(exception) do\n fun = exception.function\n args = exception.args\n insp = Enum.map_join(args, \", \", &inspect/1)\n {:arity, arity} = Function.info(fun, :arity)\n \"#{inspect(fun)} with arity #{arity} called with #{count(length(args), insp)}\"\n end\n\n defp count(0, _insp), do: \"no arguments\"\n defp count(1, insp), do: \"1 argument (#{insp})\"\n defp count(x, insp), do: \"#{x} arguments (#{insp})\"\nend\n\ndefmodule UndefinedFunctionError do\n @moduledoc \"\"\"\n An exception raised when a function is invoked that is not defined.\n\n For example:\n\n # Let's use apply/3 as otherwise Elixir emits a compile-time warning\n iex> apply(String, :non_existing_fun, [\"hello\"])\n ** (UndefinedFunctionError) function String.non_existing_fun/1 is undefined or private\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:module` (`t:module/0`) - the module name\n * `:function` (`t:atom/0`) - the function name\n * `:arity` (`t:non_neg_integer/0`) - the arity of the function\n \"\"\"\n\n @function_threshold 0.77\n @max_suggestions 5\n defexception [:module, :function, :arity, :reason, :message]\n\n @impl true\n def message(%{message: nil} = exception) do\n %{reason: reason, module: module, function: function, arity: arity} = exception\n {message, hint_type} = message(reason, module, function, arity)\n message <> if(hint_type == :suggest_module, do: hint_for_missing_alias(module), else: \"\")\n end\n\n def message(%{message: message}) do\n message\n end\n\n defp message(nil, module, function, arity) do\n cond do\n is_nil(function) or is_nil(arity) ->\n {\"undefined function\", :suggest_module}\n\n is_nil(module) ->\n formatted_fun = Exception.format_mfa(module, function, arity)\n {\"function #{formatted_fun} is undefined\", :suggest_module}\n\n function_exported?(module, :module_info, 0) ->\n message(:\"function not exported\", module, function, arity)\n\n true ->\n message(:\"module could not be loaded\", module, function, arity)\n end\n end\n\n defp message(:\"module could not be loaded\", module, function, arity) do\n formatted_fun = Exception.format_mfa(module, function, arity)\n\n {\"function #{formatted_fun} is undefined (module #{inspect(module)} is not available)\",\n :suggest_module}\n end\n\n defp message(:\"function not exported\", module, function, arity) do\n formatted_fun = Exception.format_mfa(module, function, arity)\n {\"function #{formatted_fun} is undefined or private\", :suggest_function}\n end\n\n defp message(:\"undefined local\", nil, function, arity) do\n {\"function #{function}/#{arity} is undefined (there is no such import)\", :no_hint}\n end\n\n defp message(reason, module, function, arity) do\n formatted_fun = Exception.format_mfa(module, function, arity)\n {\"function #{formatted_fun} is undefined (#{reason})\", :suggest_module}\n end\n\n @impl true\n def blame(exception, stacktrace) do\n %{reason: reason, module: module, function: function, arity: arity} = exception\n {message, hint_type} = message(reason, module, function, arity)\n message = message <> hint(module, function, arity, hint_type)\n {%{exception | message: message}, stacktrace}\n end\n\n defp hint(_, _, _, :no_hint), do: \"\"\n\n defp hint(nil, _function, 0, _hint_type) do\n \". If you are using the dot syntax, such as module.function(), \" <>\n \"make sure the left-hand side of the dot is a module atom\"\n end\n\n defp hint(module, function, arity, :suggest_function) do\n hint_for_behaviour(module, function, arity) <>\n hint_for_loaded_module(module, function, arity)\n end\n\n defp hint(module, function, arity, :suggest_module) do\n hint_for_missing_module(module, function, arity)\n end\n\n defp hint_for_missing_alias(module) do\n with \"Elixir.\" <> rest <- Atom.to_string(module),\n false <- rest =~ \".\" do\n \". Make sure the module name is correct and has been specified in full (or that an alias has been defined)\"\n else\n _ -> \"\"\n end\n end\n\n @doc false\n def hint_for_missing_module(module, function, arity) do\n downcased_module = downcase_module_name(module)\n stripped_module = module |> Atom.to_string() |> String.replace_leading(\"Elixir.\", \"\")\n\n candidates =\n for {name, _, _} = candidate <- :code.all_available(),\n downcase_module_name(name) == downcased_module or\n String.ends_with?(List.to_string(name), stripped_module),\n {:module, module} <- [load_module(candidate)],\n function_exported?(module, function, arity),\n do: module\n\n if candidates != [] do\n suggestions =\n candidates\n |> Enum.take(@max_suggestions)\n |> Enum.sort(:asc)\n |> Enum.map(fn module ->\n [\"\\n * \", Exception.format_mfa(module, function, arity)]\n end)\n\n \". Did you mean:\\n#{suggestions}\\n\"\n else\n hint_for_missing_alias(module)\n end\n end\n\n defp load_module({name, _path, _loaded?}) do\n name\n |> List.to_atom()\n |> Code.ensure_loaded()\n end\n\n defp downcase_module_name(module) do\n module\n |> to_string()\n |> String.downcase(:ascii)\n end\n\n @doc false\n def hint_for_loaded_module(module, function, arity) do\n cond do\n macro_exported?(module, function, arity) ->\n \". However, there is a macro with the same name and arity. \" <>\n \"Be sure to require #{inspect(module)} if you intend to invoke this macro\"\n\n message = otp_obsolete(module, function, arity) ->\n \", #{message}\"\n\n true ->\n IO.iodata_to_binary(did_you_mean(module, function))\n end\n end\n\n defp otp_obsolete(module, function, arity) do\n case :otp_internal.obsolete(module, function, arity) do\n {:removed, [_ | _] = string} -> string\n _ -> nil\n end\n end\n\n defp hint_for_behaviour(module, function, arity) do\n case behaviours_for(module) do\n [] ->\n \"\"\n\n behaviours ->\n case Enum.find(behaviours, &expects_callback?(&1, function, arity)) do\n nil -> \"\"\n behaviour -> \", but the behaviour #{inspect(behaviour)} expects it to be present\"\n end\n end\n rescue\n # In case the module was removed while we are computing this\n UndefinedFunctionError -> \"\"\n end\n\n defp behaviours_for(module) do\n :attributes\n |> module.module_info()\n |> Keyword.get(:behaviour, [])\n end\n\n defp expects_callback?(behaviour, function, arity) do\n callbacks =\n behaviour.behaviour_info(:callbacks) -- behaviour.behaviour_info(:optional_callbacks)\n\n Enum.member?(callbacks, {function, arity})\n end\n\n ## Shared helpers across hints\n\n defp did_you_mean(module, function) do\n exports = exports_for(module)\n\n result =\n case Keyword.take(exports, [function]) do\n [] ->\n candidates = exports -- deprecated_functions_for(module)\n base = Atom.to_string(function)\n\n for {key, val} <- candidates,\n dist = String.jaro_distance(base, Atom.to_string(key)),\n dist >= @function_threshold,\n do: {dist, key, val}\n\n arities ->\n for {key, val} <- arities, do: {1.0, key, val}\n end\n |> Enum.sort(&(elem(&1, 0) >= elem(&2, 0)))\n |> Enum.take(@max_suggestions)\n |> Enum.sort(&(elem(&1, 1) <= elem(&2, 1)))\n\n case result do\n [] -> []\n suggestions -> [\". Did you mean:\\n\\n\" | Enum.map(suggestions, &format_fa/1)]\n end\n end\n\n defp format_fa({_dist, fun, arity}) do\n [\" * \", Macro.inspect_atom(:remote_call, fun), ?/, Integer.to_string(arity), ?\\n]\n end\n\n defp exports_for(module) do\n if function_exported?(module, :__info__, 1) do\n module.__info__(:macros) ++ module.__info__(:functions)\n else\n module.module_info(:exports)\n end\n rescue\n # In case the module was removed while we are computing this\n UndefinedFunctionError -> []\n end\n\n defp deprecated_functions_for(module) do\n if function_exported?(module, :__info__, 1) do\n for {name_arity, _message} <- module.__info__(:deprecated), do: name_arity\n else\n []\n end\n rescue\n # In case the module was removed while we are computing this\n UndefinedFunctionError -> []\n end\nend\n\ndefmodule FunctionClauseError do\n @moduledoc \"\"\"\n An exception raised when a function call doesn't match any defined clause.\n\n For example:\n\n iex> List.duplicate(:ok, -3)\n ** (FunctionClauseError) no function clause matching in List.duplicate/2\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:module` (`t:module/0`) - the module name\n * `:function` (`t:atom/0`) - the function name\n * `:arity` (`t:non_neg_integer/0`) - the arity of the function\n \"\"\"\n\n defexception [:module, :function, :arity, :kind, :args, :clauses]\n\n @clause_limit 10\n\n @impl true\n def message(exception) do\n case exception do\n %{function: nil} ->\n \"no function clause matches\"\n\n %{module: module, function: function, arity: arity} ->\n formatted = Exception.format_mfa(module, function, arity)\n blamed = blame(exception, &inspect/1, &blame_match/1)\n \"no function clause matching in #{formatted}\" <> blamed\n end\n end\n\n @impl true\n def blame(%{module: module, function: function, arity: arity} = exception, stacktrace) do\n case stacktrace do\n [{^module, ^function, args, meta} | rest] when length(args) == arity ->\n exception =\n case Exception.blame_mfa(module, function, args) do\n {:ok, kind, clauses} -> %{exception | args: args, kind: kind, clauses: clauses}\n :error -> %{exception | args: args}\n end\n\n {exception, [{module, function, arity, meta} | rest]}\n\n stacktrace ->\n {exception, stacktrace}\n end\n end\n\n defp blame_match(%{match?: true, node: node}), do: Macro.to_string(node)\n defp blame_match(%{match?: false, node: node}), do: \"-\" <> Macro.to_string(node) <> \"-\"\n\n @doc false\n def blame(%{args: nil}, _, _) do\n \"\"\n end\n\n def blame(exception, inspect_fun, fun) do\n %{module: module, function: function, arity: arity, kind: kind, args: args, clauses: clauses} =\n exception\n\n mfa = Exception.format_mfa(module, function, arity)\n\n format_clause_fun = fn {args, guards} ->\n args = Enum.map_join(args, \", \", fun)\n base = \" #{kind} #{function}(#{args})\"\n Enum.reduce(guards, base, &\"#{&2} when #{clause_to_string(&1, fun, 0)}\") <> \"\\n\"\n end\n\n \"\\n\\nThe following arguments were given to #{mfa}:\\n\" <>\n \"#{format_args(args, inspect_fun)}\" <>\n \"#{format_clauses(clauses, format_clause_fun, @clause_limit)}\"\n end\n\n defp clause_to_string({op, _, [left, right]} = node, fun, parent) do\n case Code.Identifier.binary_op(op) do\n {_side, precedence} ->\n left = clause_to_string(left, fun, precedence)\n right = clause_to_string(right, fun, precedence)\n\n if parent > precedence do\n \"(\" <> left <> \" #{op} \" <> right <> \")\"\n else\n left <> \" #{op} \" <> right\n end\n\n _ ->\n fun.(node)\n end\n end\n\n defp clause_to_string(node, fun, _precedence), do: fun.(node)\n\n defp format_args(args, inspect_fun) do\n args\n |> Enum.with_index(1)\n |> Enum.map(fn {arg, i} ->\n [pad(\"\\n# \"), Integer.to_string(i), pad(\"\\n\"), pad(inspect_fun.(arg)), \"\\n\"]\n end)\n end\n\n defp format_clauses(clauses, format_clause_fun, limit)\n defp format_clauses(nil, _, _), do: \"\"\n defp format_clauses([], _, _), do: \"\"\n\n defp format_clauses(clauses, format_clause_fun, limit) do\n top_clauses =\n clauses\n |> Enum.take(limit)\n |> Enum.map(format_clause_fun)\n\n [\n \"\\nAttempted function clauses (showing #{length(top_clauses)} out of #{length(clauses)}):\",\n \"\\n\\n\",\n top_clauses,\n non_visible_clauses(length(clauses) - limit)\n ]\n end\n\n defp non_visible_clauses(n) when n <= 0, do: []\n defp non_visible_clauses(1), do: [\" ...\\n (1 clause not shown)\\n\"]\n defp non_visible_clauses(n), do: [\" ...\\n (#{n} clauses not shown)\\n\"]\n\n defp pad(string) do\n String.replace(string, \"\\n\", \"\\n \")\n end\nend\n\ndefmodule Code.LoadError do\n @moduledoc \"\"\"\n An exception raised when a file cannot be loaded.\n\n This is typically raised by functions in the `Code` module, for example:\n\n Code.require_file(\"missing_file.exs\")\n ** (Code.LoadError) could not load missing_file.exs. Reason: enoent\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:file` (`t:String.t/0`) - the file name\n * `:reason` (`t:term/0`) - the reason why the file could not be loaded\n \"\"\"\n\n defexception [:file, :message, :reason]\n\n def exception(opts) do\n file = Keyword.fetch!(opts, :file)\n reason = Keyword.fetch!(opts, :reason)\n message = \"could not load #{file}. Reason: #{reason}\"\n %Code.LoadError{message: message, file: file, reason: reason}\n end\nend\n\ndefmodule Protocol.UndefinedError do\n @moduledoc \"\"\"\n An exception raised when a protocol is not implemented for a given value.\n\n For example:\n\n iex> Enum.at(\"A string!\", 0)\n ** (Protocol.UndefinedError) protocol Enumerable not implemented for BitString\n ...\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:protocol` (`t:module/0`) - the protocol that is not implemented\n * `:value` (`t:term/0`) - the value that does not implement the protocol\n \"\"\"\n\n defexception [:protocol, :value, description: \"\"]\n\n @impl true\n def message(%{protocol: protocol, value: value, description: description}) do\n inspected =\n value\n |> inspect(pretty: true)\n # Indent only lines with contents on them\n |> String.replace(~r/^(?=.+)/m, \" \")\n\n \"protocol #{inspect(protocol)} not implemented for \" <>\n value_type(value) <>\n maybe_description(description) <>\n maybe_available(protocol) <>\n \"\"\"\n\n\n Got value:\n\n #{inspected}\n \"\"\"\n end\n\n defp value_type(%{__struct__: struct}), do: \"#{inspect(struct)} (a struct)\"\n defp value_type(value) when is_atom(value), do: \"Atom\"\n defp value_type(value) when is_bitstring(value), do: \"BitString\"\n defp value_type(value) when is_float(value), do: \"Float\"\n defp value_type(value) when is_function(value), do: \"Function\"\n defp value_type(value) when is_integer(value), do: \"Integer\"\n defp value_type(value) when is_list(value), do: \"List\"\n defp value_type(value) when is_map(value), do: \"Map\"\n defp value_type(value) when is_pid(value), do: \"PID\"\n defp value_type(value) when is_port(value), do: \"Port\"\n defp value_type(value) when is_reference(value), do: \"Reference\"\n defp value_type(value) when is_tuple(value), do: \"Tuple\"\n\n defp maybe_description(\"\"), do: \"\"\n defp maybe_description(description), do: \", \" <> description\n\n defp maybe_available(protocol) do\n case protocol.__protocol__(:impls) do\n {:consolidated, []} ->\n \". There are no implementations for this protocol.\"\n\n {:consolidated, types} ->\n \". This protocol is implemented for: \" <>\n Enum.map_join(types, \", \", &inspect/1)\n\n :not_consolidated ->\n \"\"\n end\n end\nend\n\ndefmodule KeyError do\n @moduledoc \"\"\"\n An exception raised when a key is not found in a data structure.\n\n For example, this is raised by `Map.fetch!/2` when the given key\n cannot be found in the given map:\n\n iex> map = %{name: \"Alice\", age: 25}\n iex> Map.fetch!(map, :first_name)\n ** (KeyError) key :first_name not found in:\n ...\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:term` (`t:term/0`) - the data structure that was searched\n * `:key` (`t:term/0`) - the key that was not found\n \"\"\"\n\n defexception [:key, :term, :message]\n\n @impl true\n def message(exception = %{message: nil}), do: message(exception.key, exception.term)\n def message(%{message: message}), do: message\n\n defp message(key, term) do\n message = \"key #{inspect(key)} not found\"\n\n cond do\n term == nil ->\n message\n\n is_atom(term) and is_atom(key) ->\n message <>\n \" in: #{inspect(term)} (if instead you want to invoke #{inspect(term)}.#{key}(), \" <>\n \"make sure to add parentheses after the function name)\"\n\n true ->\n Exception.__format_message_with_term__(\n message <> \" in:\",\n term\n )\n end\n end\n\n @impl true\n def blame(exception = %{message: message}, stacktrace) when is_binary(message) do\n {exception, stacktrace}\n end\n\n def blame(exception, stacktrace) do\n %{term: term, key: key} = exception\n message = message(key, term)\n\n if is_atom(key) and (map_with_atom_keys_only?(term) or Keyword.keyword?(term)) do\n hint = did_you_mean(key, available_keys(term))\n message = message <> IO.iodata_to_binary(hint)\n {%{exception | message: message}, stacktrace}\n else\n {%{exception | message: message}, stacktrace}\n end\n end\n\n defp map_with_atom_keys_only?(term) do\n is_map(term) and Enum.all?(Map.to_list(term), fn {k, _} -> is_atom(k) end)\n end\n\n defp available_keys(term) when is_map(term), do: Map.keys(term)\n defp available_keys(term) when is_list(term), do: Keyword.keys(term)\n\n @threshold 0.77\n @max_suggestions 5\n defp did_you_mean(missing_key, available_keys) do\n stringified_key = Atom.to_string(missing_key)\n\n suggestions =\n for key <- available_keys,\n distance = String.jaro_distance(stringified_key, Atom.to_string(key)),\n distance >= @threshold,\n do: {distance, key}\n\n case suggestions do\n [] -> []\n suggestions -> [\"\\nDid you mean:\\n\\n\" | format_suggestions(suggestions)]\n end\n end\n\n defp format_suggestions(suggestions) do\n suggestions\n |> Enum.sort(&(elem(&1, 0) >= elem(&2, 0)))\n |> Enum.take(@max_suggestions)\n |> Enum.sort(&(elem(&1, 1) <= elem(&2, 1)))\n |> Enum.map(fn {_, key} -> [\" * \", inspect(key), ?\\n] end)\n end\nend\n\ndefmodule UnicodeConversionError do\n @moduledoc \"\"\"\n An exception raised when converting data to or from Unicode.\n\n For example:\n\n iex> String.to_charlist(<<0xFF>>)\n ** (UnicodeConversionError) invalid encoding starting at <<255>>\n\n \"\"\"\n defexception [:encoded, :message]\n\n def exception(opts) do\n %UnicodeConversionError{\n encoded: Keyword.fetch!(opts, :encoded),\n message: \"#{Keyword.fetch!(opts, :kind)} #{detail(Keyword.fetch!(opts, :rest))}\"\n }\n end\n\n defp detail(rest) when is_binary(rest) do\n \"encoding starting at #{inspect(rest)}\"\n end\n\n defp detail([h | _]) when is_integer(h) do\n \"code point #{h}\"\n end\n\n defp detail([h | _]) do\n detail(h)\n end\nend\n\ndefmodule MissingApplicationsError do\n @moduledoc \"\"\"\n An exception that is raised when an application depends on one or more\n missing applications.\n\n This exception is used by Mix and other tools. It can also be used by library authors\n when their library only requires an external application (like a dependency) for a subset\n of features.\n\n The fields of this exception are public. See `t:t/0`.\n\n *Available since v1.18.0.*\n\n ## Examples\n\n unless Application.spec(:plug, :vsn) do\n raise MissingApplicationsError,\n description: \"application :plug is required for testing Plug-related functionality\",\n apps: [{:plug, \"~> 1.0\"}]\n end\n\n \"\"\"\n\n @moduledoc since: \"1.18.0\"\n\n @type t() :: %__MODULE__{\n apps: [{Application.app(), Version.requirement()}, ...],\n description: String.t()\n }\n\n defexception apps: [], description: \"missing applications found\"\n\n @impl true\n def message(%__MODULE__{apps: apps, description: description}) do\n # We explicitly format these as tuples so that they're easier to copy-paste\n # into dependencies.\n formatted_apps =\n Enum.map(apps, fn {app_name, requirement} ->\n ~s(\\n {#{inspect(app_name)}, \"#{requirement}\"})\n end)\n\n \"\"\"\n #{description}\n\n To address this, include these applications as your dependencies:\n #{formatted_apps}\\\n \"\"\"\n end\nend\n\ndefmodule Enum.OutOfBoundsError do\n @moduledoc \"\"\"\n An exception that is raised when a function expects an enumerable to have\n a certain size but finds that it is too small.\n\n For example:\n\n iex> Enum.fetch!([1, 2, 3], 5)\n ** (Enum.OutOfBoundsError) out of bounds error at position 5 when traversing enumerable [1, 2, 3]\n \"\"\"\n\n defexception [:enumerable, :index, :message]\n\n @impl true\n def message(exception = %{message: nil}), do: message(exception.index, exception.enumerable)\n def message(%{message: message}), do: message\n\n def message(index, enumerable) do\n \"out of bounds error\" <>\n if index do\n \" at position #{index}\"\n else\n \"\"\n end <>\n if enumerable do\n \" when traversing enumerable #{inspect(enumerable)}\"\n else\n \"\"\n end\n end\nend\n\ndefmodule Enum.EmptyError do\n @moduledoc \"\"\"\n An exception that is raised when something expects a non-empty enumerable\n but finds an empty one.\n\n For example:\n\n iex> Enum.min([])\n ** (Enum.EmptyError) empty error\n\n \"\"\"\n\n defexception message: \"empty error\"\nend\n\ndefmodule File.Error do\n @moduledoc \"\"\"\n An exception that is raised when a file operation fails.\n\n For example, this exception is raised, when trying to read a non existent file:\n\n iex> File.read!(\"nonexistent_file.txt\")\n ** (File.Error) could not read file \"nonexistent_file.txt\": no such file or directory\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:path` (`t:Path.t/0`) - the path of the file that caused the error\n * `:reason` (`t:File.posix/0`) - the reason for the error\n\n \"\"\"\n\n defexception [:reason, :path, action: \"\"]\n\n @impl true\n def message(%{action: action, reason: reason, path: path}) do\n formatted =\n case {action, reason} do\n {\"remove directory\", :eexist} ->\n \"directory is not empty\"\n\n _ ->\n IO.iodata_to_binary(:file.format_error(reason))\n end\n\n \"could not #{action} #{inspect(path)}: #{formatted}\"\n end\nend\n\ndefmodule File.CopyError do\n @moduledoc \"\"\"\n An exception that is raised when copying a file fails.\n\n For example, this exception is raised when trying to copy to file or directory that isn't present:\n\n iex> File.cp_r!(\"non_existent\", \"source_dir/subdir\")\n ** (File.CopyError) could not copy recursively from \"non_existent\" to \"source_dir/subdir\". non_existent: no such file or directory\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:source` (`t:Path.t/0`) - the source path\n * `:destination` (`t:Path.t/0`) - the destination path\n * `:reason` (`t:File.posix/0`) - the reason why the file could not be copied\n\n \"\"\"\n\n defexception [:reason, :source, :destination, on: \"\", action: \"\"]\n\n @impl true\n def message(exception) do\n formatted = IO.iodata_to_binary(:file.format_error(exception.reason))\n\n location =\n case exception.on do\n \"\" -> \"\"\n on -> \". #{on}\"\n end\n\n \"could not #{exception.action} from #{inspect(exception.source)} to \" <>\n \"#{inspect(exception.destination)}#{location}: #{formatted}\"\n end\nend\n\ndefmodule File.RenameError do\n @moduledoc \"\"\"\n An exception that is raised when renaming a file fails.\n\n For example, this exception is raised when trying to rename a file that isn't present:\n\n iex> File.rename!(\"source.txt\", \"target.txt\")\n ** (File.RenameError) could not rename from \"source.txt\" to \"target.txt\": no such file or directory\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:source` (`t:Path.t/0`) - the source path\n * `:destination` (`t:Path.t/0`) - the destination path\n * `:reason` (`t:File.posix/0`) - the reason why the file could not be renamed\n\n \"\"\"\n\n defexception [:reason, :source, :destination, on: \"\", action: \"\"]\n\n @impl true\n def message(exception) do\n formatted = IO.iodata_to_binary(:file.format_error(exception.reason))\n\n location =\n case exception.on do\n \"\" -> \"\"\n on -> \". #{on}\"\n end\n\n \"could not #{exception.action} from #{inspect(exception.source)} to \" <>\n \"#{inspect(exception.destination)}#{location}: #{formatted}\"\n end\nend\n\ndefmodule File.LinkError do\n @moduledoc \"\"\"\n An exception that is raised when linking a file fails.\n\n For example, this exception is raised when trying to link to file that isn't present:\n\n iex> File.ln!(\"existing.txt\", \"link.txt\")\n ** (File.LinkError) could not create hard link from \"link.txt\" to \"existing.txt\": no such file or directory\n\n The following fields of this exception are public and can be accessed freely:\n\n * `:existing` (`t:Path.t/0`) - the existing file to link\n * `:new` (`t:Path.t/0`) - the link destination\n * `:reason` (`t:File.posix/0`) - the reason why the file could not be linked\n\n \"\"\"\n\n defexception [:reason, :existing, :new, action: \"\"]\n\n @impl true\n def message(exception) do\n formatted = IO.iodata_to_binary(:file.format_error(exception.reason))\n\n \"could not #{exception.action} from #{inspect(exception.new)} to \" <>\n \"#{inspect(exception.existing)}: #{formatted}\"\n end\nend\n\ndefmodule ErlangError do\n @moduledoc \"\"\"\n An exception raised when invoking an Erlang code that errors\n with a value not handled by Elixir.\n\n Most common error reasons, such as `:badarg` are automatically\n converted into exceptions by Elixir. However, you may invoke some\n code that emits a custom error reason and those get wrapped into\n `ErlangError`:\n\n iex> :erlang.error(:some_invalid_error)\n ** (ErlangError) Erlang error: :some_invalid_error\n \"\"\"\n\n defexception [:original, :reason]\n\n @impl true\n def message(exception)\n\n def message(%__MODULE__{original: original, reason: nil}) do\n \"Erlang error: #{inspect(original)}\"\n end\n\n def message(%__MODULE__{original: original, reason: reason}) do\n IO.iodata_to_binary([\"Erlang error: \", inspect(original), reason])\n end\n\n @doc false\n def normalize(:badarg, stacktrace) do\n case stacktrace do\n [{:erlang, :apply, [module, function, args], _} | _] when not is_atom(module) ->\n message =\n cond do\n is_map(module) and is_atom(function) and is_map_key(module, function) ->\n \"you attempted to apply a function named #{inspect(function)} on a map/struct. \" <>\n \"If you are using Kernel.apply/3, make sure the module is an atom. \" <>\n if is_function(Map.get(module, function)) do\n \"If you are trying to invoke an anonymous function in a map/struct, \" <>\n \"add a dot between the function name and the parenthesis: map.#{function}.()\"\n else\n \"If you are using the dot syntax, ensure there are no parentheses \" <>\n \"after the field name, such as map.#{function}\"\n end\n\n is_atom(function) and args == [] ->\n \"you attempted to apply a function named #{inspect(function)} on #{inspect(module)}. \" <>\n \"If you are using Kernel.apply/3, make sure the module is an atom. \" <>\n \"If you are using the dot syntax, such as module.function(), \" <>\n \"make sure the left-hand side of the dot is an atom representing a module\"\n\n true ->\n \"you attempted to apply a function on #{inspect(module)}. \" <>\n \"Modules (the first argument of apply) must always be an atom\"\n end\n\n %ArgumentError{message: message}\n\n _ ->\n case error_info(:badarg, stacktrace, \"errors were found at the given arguments\") do\n {:ok, reason, details} -> %ArgumentError{message: reason <> details}\n :error -> %ArgumentError{}\n end\n end\n end\n\n def normalize(:badarith, _stacktrace) do\n %ArithmeticError{}\n end\n\n def normalize(:system_limit, stacktrace) do\n default_reason = \"a system limit has been reached due to errors at the given arguments\"\n\n case error_info(:system_limit, stacktrace, default_reason) do\n {:ok, reason, details} -> %SystemLimitError{message: reason <> details}\n :error -> %SystemLimitError{}\n end\n end\n\n def normalize(:cond_clause, _stacktrace) do\n %CondClauseError{}\n end\n\n def normalize({:badarity, {fun, args}}, _stacktrace) do\n %BadArityError{function: fun, args: args}\n end\n\n def normalize({:badfun, term}, _stacktrace) do\n %BadFunctionError{term: term}\n end\n\n def normalize({:badmatch, term}, _stacktrace) do\n %MatchError{term: term}\n end\n\n def normalize({:badmap, term}, _stacktrace) do\n %BadMapError{term: term}\n end\n\n def normalize({:badbool, op, term}, _stacktrace) do\n %BadBooleanError{operator: op, term: term}\n end\n\n def normalize({:badkey, key}, stacktrace) do\n term =\n case stacktrace do\n [{Map, :get_and_update!, [map, _, _], _} | _] -> map\n [{Map, :update!, [map, _, _], _} | _] -> map\n [{:maps, :update, [_, _, map], _} | _] -> map\n [{:maps, :get, [_, map], _} | _] -> map\n [{:erlang, :map_get, [_, map], _} | _] -> map\n _ -> nil\n end\n\n %KeyError{key: key, term: term}\n end\n\n def normalize({:badkey, key, map}, _stacktrace) when is_map(map) do\n %KeyError{key: key, term: map}\n end\n\n def normalize({:badkey, key, term}, _stacktrace) do\n message =\n \"key #{inspect(key)} not found in: #{inspect(term, pretty: true, limit: :infinity)}\\n\\n\" <>\n \"If you are using the dot syntax, such as map.field, \" <>\n \"make sure the left-hand side of the dot is a map\"\n\n %KeyError{key: key, term: term, message: message}\n end\n\n def normalize({:case_clause, term}, _stacktrace) do\n %CaseClauseError{term: term}\n end\n\n # :else_clause is aligned on what Erlang returns for `maybe`\n def normalize({:else_clause, term}, _stacktrace) do\n %WithClauseError{term: term}\n end\n\n def normalize({:try_clause, term}, _stacktrace) do\n %TryClauseError{term: term}\n end\n\n def normalize(:undef, stacktrace) do\n {mod, fun, arity} = from_stacktrace(stacktrace)\n %UndefinedFunctionError{module: mod, function: fun, arity: arity}\n end\n\n def normalize(:function_clause, stacktrace) do\n {mod, fun, arity} = from_stacktrace(stacktrace)\n %FunctionClauseError{module: mod, function: fun, arity: arity}\n end\n\n def normalize({:badarg, payload}, _stacktrace) do\n %ArgumentError{message: \"argument error: #{inspect(payload)}\"}\n end\n\n def normalize(other, stacktrace) do\n case error_info(other, stacktrace, \"\") do\n {:ok, _reason, details} -> %ErlangError{original: other, reason: details}\n :error -> %ErlangError{original: other}\n end\n end\n\n defp from_stacktrace([{module, function, args, _} | _]) when is_list(args) do\n {module, function, length(args)}\n end\n\n defp from_stacktrace([{module, function, arity, _} | _]) do\n {module, function, arity}\n end\n\n defp from_stacktrace(_) do\n {nil, nil, nil}\n end\n\n defp error_info(erl_exception, stacktrace, default_reason) do\n with [{module, fun, args_or_arity, opts} | tail] <- stacktrace,\n %{} = error_info <- opts[:error_info] do\n error_module = Map.get(error_info, :module, module)\n error_fun = Map.get(error_info, :function, :format_error)\n\n error_info = Map.put(error_info, :pretty_printer, &inspect/1)\n head = {module, fun, args_or_arity, Keyword.put(opts, :error_info, error_info)}\n\n extra =\n try do\n apply(error_module, error_fun, [erl_exception, [head | tail]])\n rescue\n _ -> %{}\n end\n\n arity = if is_integer(args_or_arity), do: args_or_arity, else: length(args_or_arity)\n args_errors = Map.take(extra, Enum.to_list(1..arity//1))\n reason = Map.get(extra, :reason, default_reason)\n\n cond do\n map_size(args_errors) > 0 ->\n {:ok, reason, IO.iodata_to_binary([\":\\n\\n\" | Enum.map(args_errors, &arg_error/1)])}\n\n general = extra[:general] ->\n {:ok, reason, \": \" <> IO.chardata_to_string(general)}\n\n true ->\n :error\n end\n else\n _ -> :error\n end\n end\n\n defp arg_error({n, message}), do: \" * #{nth(n)} argument: #{message}\\n\"\n\n defp nth(1), do: \"1st\"\n defp nth(2), do: \"2nd\"\n defp nth(3), do: \"3rd\"\n defp nth(n), do: \"#{n}th\"\nend\n" }, { "path": "lib/elixir/lib/file/stat.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nrequire Record\n\ndefmodule File.Stat do\n @moduledoc \"\"\"\n A struct that holds file information.\n\n In Erlang, this struct is represented by a `:file_info` record.\n Therefore this module also provides functions for converting\n between the Erlang record and the Elixir struct.\n\n Its fields are:\n\n * `size` - size of file in bytes.\n\n * `type` - `:device | :directory | :regular | :other | :symlink`; the type of the\n file.\n\n * `access` - `:read | :write | :read_write | :none`; the current system\n access to the file.\n\n * `atime` - the last time the file was read.\n\n * `mtime` - the last time the file was written.\n\n * `ctime` - the interpretation of this time field depends on the operating\n system. On Unix-like operating systems, it is the last time the file or the inode was changed.\n In Windows, it is the time of creation.\n\n * `mode` - the file permissions.\n\n * `links` - the number of links to this file. This is always 1 for file\n systems which have no concept of links.\n\n * `major_device` - identifies the file system where the file is located.\n In Windows, the number indicates a drive as follows: 0 means A:, 1 means\n B:, and so on.\n\n * `minor_device` - only valid for character devices on Unix-like systems. In all other\n cases, this field is zero.\n\n * `inode` - gives the inode number. On non-Unix-like file systems, this field\n will be zero.\n\n * `uid` - indicates the owner of the file. Will be zero for non-Unix-like file\n systems.\n\n * `gid` - indicates the group that owns the file. Will be zero for\n non-Unix-like file systems.\n\n The time type returned in `atime`, `mtime`, and `ctime` is dependent on the\n time type set in options. `{:time, type}` where type can be `:local`,\n `:universal`, or `:posix`. Default is `:universal`.\n \"\"\"\n\n record = Record.extract(:file_info, from_lib: \"kernel/include/file.hrl\")\n keys = :lists.map(&elem(&1, 0), record)\n vals = :lists.map(&{&1, [], nil}, keys)\n pairs = :lists.zip(keys, vals)\n\n defstruct keys\n\n @type t :: %__MODULE__{\n size: non_neg_integer() | :undefined,\n type: :device | :directory | :regular | :other | :symlink | :undefined,\n access: :read | :write | :read_write | :none | :undefined,\n atime: :calendar.datetime() | integer() | :undefined,\n mtime: :calendar.datetime() | integer() | :undefined,\n ctime: :calendar.datetime() | integer() | :undefined,\n mode: non_neg_integer() | :undefined,\n links: non_neg_integer() | :undefined,\n major_device: non_neg_integer() | :undefined,\n minor_device: non_neg_integer() | :undefined,\n inode: non_neg_integer() | :undefined,\n uid: non_neg_integer() | :undefined,\n gid: non_neg_integer() | :undefined\n }\n\n @doc \"\"\"\n Converts a `File.Stat` struct to a `:file_info` record.\n \"\"\"\n @spec to_record(t()) :: :file.file_info()\n def to_record(%File.Stat{unquote_splicing(pairs)}) do\n {:file_info, unquote_splicing(vals)}\n end\n\n @doc \"\"\"\n Converts a `:file_info` record into a `File.Stat`.\n \"\"\"\n @spec from_record(:file.file_info()) :: t()\n def from_record(file_info)\n\n def from_record({:file_info, unquote_splicing(vals)}) do\n %File.Stat{unquote_splicing(pairs)}\n end\nend\n" }, { "path": "lib/elixir/lib/file/stream.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule File.Stream do\n @moduledoc \"\"\"\n Defines a `File.Stream` struct returned by `File.stream!/3`.\n\n The following fields are public:\n\n * `path` - the file path\n * `modes` - the file modes\n * `raw` - a boolean indicating if bin functions should be used\n * `line_or_bytes` - if reading should read lines or a given number of bytes\n * `node` - the node the file belongs to\n\n \"\"\"\n\n defstruct path: nil, modes: [], line_or_bytes: :line, raw: true, node: nil\n\n @type t :: %__MODULE__{}\n\n @doc false\n def __build__(path, line_or_bytes, modes) do\n with {:read_offset, offset} <- :lists.keyfind(:read_offset, 1, modes),\n false <- is_integer(offset) and offset >= 0 do\n raise ArgumentError,\n \"expected :read_offset to be a non-negative integer, got: #{inspect(offset)}\"\n end\n\n raw = :lists.keyfind(:encoding, 1, modes) == false\n\n modes =\n case raw do\n true ->\n case :lists.keyfind(:read_ahead, 1, modes) do\n {:read_ahead, false} -> [:raw | :lists.keydelete(:read_ahead, 1, modes)]\n {:read_ahead, _} -> [:raw | modes]\n false -> [:raw, :read_ahead | modes]\n end\n\n false ->\n modes\n end\n\n %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes, node: node()}\n end\n\n @doc false\n def __open__(%File.Stream{path: path, node: node}, modes) when node == node() do\n :file.open(path, modes)\n end\n\n @doc false\n def __open__(%File.Stream{path: path, node: node}, modes) do\n :erpc.call(node, :file_io_server, :start, [self(), path, List.delete(modes, :raw)])\n end\n\n defimpl Collectable do\n def into(%{modes: modes, raw: raw} = stream) do\n modes = for mode <- modes, mode not in [:read], do: mode\n\n case File.Stream.__open__(stream, [:write | modes]) do\n {:ok, device} ->\n {:ok, into(device, stream, raw)}\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"stream\", path: stream.path\n end\n end\n\n defp into(device, stream, raw) do\n fn\n :ok, {:cont, x} ->\n case raw do\n true -> IO.binwrite(device, x)\n false -> IO.write(device, x)\n end\n\n :ok, :done ->\n # If delayed_write option is used and the last write failed will\n # MatchError here as {:error, _} is returned.\n :ok = :file.close(device)\n stream\n\n :ok, :halt ->\n # If delayed_write option is used and the last write failed will\n # MatchError here as {:error, _} is returned.\n :ok = :file.close(device)\n end\n end\n end\n\n defimpl Enumerable do\n @read_ahead_size 64 * 1024\n\n def reduce(%{modes: modes, line_or_bytes: line_or_bytes, raw: raw} = stream, acc, fun) do\n start_fun = fn ->\n case File.Stream.__open__(stream, read_modes(modes)) do\n {:ok, device} ->\n skip_bom_and_offset(device, raw, modes)\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"stream\", path: stream.path\n end\n end\n\n next_fun =\n case raw do\n true -> &IO.each_binstream(&1, line_or_bytes)\n false -> &IO.each_stream(&1, line_or_bytes)\n end\n\n Stream.resource(start_fun, next_fun, &:file.close/1).(acc, fun)\n end\n\n def count(%{modes: modes, line_or_bytes: :line, path: path, raw: raw} = stream) do\n pattern = :binary.compile_pattern(\"\\n\")\n\n counter = fn device ->\n device = skip_bom_and_offset(device, raw, modes)\n count_lines(device, path, pattern, read_function(stream), 0, :empty)\n end\n\n {:ok, open!(stream, modes, counter)}\n end\n\n def count(%{path: path, line_or_bytes: bytes, raw: true, modes: modes, node: node} = stream) do\n case :erpc.call(node, File, :stat, [path]) do\n {:ok, %{size: 0}} ->\n {:error, __MODULE__}\n\n {:ok, %{size: size}} ->\n bom_offset = count_raw_bom(stream, modes)\n offset = get_read_offset(modes)\n size = max(size - bom_offset - offset, 0)\n remainder = if rem(size, bytes) == 0, do: 0, else: 1\n {:ok, div(size, bytes) + remainder}\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"stream\", path: path\n end\n end\n\n def count(_stream) do\n {:error, __MODULE__}\n end\n\n def member?(_stream, _term) do\n {:error, __MODULE__}\n end\n\n def slice(_stream) do\n {:error, __MODULE__}\n end\n\n defp open!(stream, modes, fun) do\n case File.Stream.__open__(stream, read_modes(modes)) do\n {:ok, device} ->\n try do\n fun.(device)\n after\n :file.close(device)\n end\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"stream\", path: stream.path\n end\n end\n\n defp count_raw_bom(stream, modes) do\n if :trim_bom in modes do\n open!(stream, read_modes(modes), &(&1 |> trim_bom(true) |> elem(1)))\n else\n 0\n end\n end\n\n defp skip_bom_and_offset(device, raw, modes) do\n device =\n if :trim_bom in modes do\n device |> trim_bom(raw) |> elem(0)\n else\n device\n end\n\n offset = get_read_offset(modes)\n\n if offset > 0 do\n {:ok, _} = :file.position(device, {:cur, offset})\n end\n\n device\n end\n\n defp trim_bom(device, true) do\n bom_length = device |> IO.binread(4) |> bom_length()\n {:ok, new_pos} = :file.position(device, bom_length)\n {device, new_pos}\n end\n\n defp trim_bom(device, false) do\n # Or we read the bom in the correct amount or it isn't there\n case bom_length(IO.read(device, 1)) do\n 0 ->\n {:ok, _} = :file.position(device, 0)\n {device, 0}\n\n _ ->\n {device, 1}\n end\n end\n\n defp bom_length(<<239, 187, 191, _rest::binary>>), do: 3\n defp bom_length(<<254, 255, _rest::binary>>), do: 2\n defp bom_length(<<255, 254, _rest::binary>>), do: 2\n defp bom_length(<<0, 0, 254, 255, _rest::binary>>), do: 4\n defp bom_length(<<254, 255, 0, 0, _rest::binary>>), do: 4\n defp bom_length(_binary), do: 0\n\n def get_read_offset(modes) do\n case :lists.keyfind(:read_offset, 1, modes) do\n {:read_offset, offset} -> offset\n false -> 0\n end\n end\n\n defp read_modes(modes) do\n for mode <- modes, mode not in [:write, :append, :trim_bom], do: mode\n end\n\n defp count_lines(device, path, pattern, read, count, last_byte) do\n case read.(device) do\n data when is_binary(data) and byte_size(data) > 0 ->\n newlines = length(:binary.matches(data, pattern))\n last = :binary.last(data)\n count_lines(device, path, pattern, read, count + newlines, last)\n\n data when is_binary(data) ->\n count_lines(device, path, pattern, read, count, last_byte)\n\n :eof ->\n case last_byte do\n :empty -> 0\n ?\\n -> count\n _ -> count + 1\n end\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"stream\", path: path\n end\n end\n\n defp read_function(%{raw: true}), do: &IO.binread(&1, @read_ahead_size)\n defp read_function(%{raw: false}), do: &IO.read(&1, @read_ahead_size)\n end\nend\n" }, { "path": "lib/elixir/lib/file.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule File do\n @moduledoc ~S\"\"\"\n This module contains functions to manipulate files.\n\n Some of those functions are low-level, allowing the user\n to interact with files or IO devices, like `open/2`,\n `copy/3` and others. This module also provides higher\n level functions that work with filenames and have their naming\n based on Unix variants. For example, one can copy a file\n via `cp/3` and remove files and directories recursively\n via `rm_rf/1`.\n\n Paths given to functions in this module can be either relative to the\n current working directory (as returned by `File.cwd/0`), or absolute\n paths. Shell conventions like `~` are not expanded automatically.\n To use paths like `~/Downloads`, you can use `Path.expand/1` or\n `Path.expand/2` to expand your path to an absolute path.\n\n ## Encoding\n\n In order to write and read files, one must use the functions\n in the `IO` module. By default, a file is opened in binary mode,\n which requires the functions `IO.binread/2` and `IO.binwrite/2`\n to interact with the file. A developer may pass `:utf8` as an\n option when opening the file, then the slower `IO.read/2` and\n `IO.write/2` functions must be used as they are responsible for\n doing the proper conversions and providing the proper data guarantees.\n\n Note that filenames when given as charlists in Elixir are\n always treated as UTF-8. In particular, we expect that the\n shell and the operating system are configured to use UTF-8\n encoding. Binary filenames are considered raw and passed\n to the operating system as is.\n\n ## API\n\n Most of the functions in this module return `:ok` or\n `{:ok, result}` in case of success, `{:error, reason}`\n otherwise. Those functions also have a variant\n that ends with `!` which returns the result (instead of the\n `{:ok, result}` tuple) in case of success or raises an\n exception in case it fails. For example:\n\n File.read(\"hello.txt\")\n #=> {:ok, \"World\"}\n\n File.read(\"invalid.txt\")\n #=> {:error, :enoent}\n\n File.read!(\"hello.txt\")\n #=> \"World\"\n\n File.read!(\"invalid.txt\")\n #=> raises File.Error\n\n In general, a developer should use the former in case they want\n to react if the file does not exist. The latter should be used\n when the developer expects their software to fail in case the\n file cannot be read (i.e. it is literally an exception).\n\n ## Processes and raw files\n\n Every time a file is opened, Elixir spawns a new process. Writing\n to a file is equivalent to sending messages to the process that\n writes to the file descriptor.\n\n This means files can be passed between nodes and message passing\n guarantees they can write to the same file in a network.\n\n However, you may not always want to pay the price for this abstraction.\n In such cases, a file can be opened in `:raw` mode. The options `:read_ahead`\n and `:delayed_write` are also useful when operating on large files or\n working with files in tight loops.\n\n Check `:file.open/2` for more information about such options and\n other performance considerations.\n\n ## Seeking within a file\n\n You may also use any of the functions from the [`:file`](`:file`)\n module to interact with files returned by Elixir. For example,\n to read from a specific position in a file, use `:file.pread/3`:\n\n File.write!(\"example.txt\", \"Eats, Shoots & Leaves\")\n file = File.open!(\"example.txt\")\n :file.pread(file, 15, 6)\n #=> {:ok, \"Leaves\"}\n\n Alternatively, if you need to keep track of the current position,\n use `:file.position/2` and `:file.read/2`:\n\n :file.position(file, 6)\n #=> {:ok, 6}\n :file.read(file, 6)\n #=> {:ok, \"Shoots\"}\n :file.position(file, {:cur, -12})\n #=> {:ok, 0}\n :file.read(file, 4)\n #=> {:ok, \"Eats\"}\n \"\"\"\n\n @type posix :: :file.posix()\n @type io_device :: :file.io_device()\n @type file_descriptor :: :file.fd()\n @type stat_options :: [time: :local | :universal | :posix]\n @type mode ::\n :append\n | :binary\n | :charlist\n | :compressed\n | :delayed_write\n | :exclusive\n | :raw\n | :read\n | :read_ahead\n | :sync\n | :write\n | {:read_ahead, pos_integer}\n | {:delayed_write, non_neg_integer, non_neg_integer}\n | encoding_mode()\n\n @type encoding_mode ::\n :utf8\n | {\n :encoding,\n :latin1\n | :unicode\n | :utf8\n | :utf16\n | :utf32\n | {:utf16, :big | :little}\n | {:utf32, :big | :little}\n }\n\n @type stream_mode ::\n encoding_mode()\n | read_offset_mode()\n | :append\n | :compressed\n | :delayed_write\n | :trim_bom\n | {:read_ahead, pos_integer | false}\n | {:delayed_write, non_neg_integer, non_neg_integer}\n\n @type read_offset_mode :: {:read_offset, non_neg_integer()}\n\n @type erlang_time ::\n {{year :: non_neg_integer(), month :: 1..12, day :: 1..31},\n {hour :: 0..23, minute :: 0..59, second :: 0..59}}\n\n @type posix_time :: integer()\n\n @type on_conflict_callback :: (Path.t(), Path.t() -> boolean)\n\n @doc \"\"\"\n Returns `true` if the path is a regular file.\n\n This function follows symbolic links, so if a symbolic link points to a\n regular file, `true` is returned.\n\n ## Options\n\n The supported options are:\n\n * `:raw` - a single atom to bypass the file server and only check\n for the file locally\n\n ## Examples\n\n File.regular?(__ENV__.file)\n #=> true\n\n \"\"\"\n @spec regular?(Path.t(), [regular_option]) :: boolean\n when regular_option: :raw\n def regular?(path, opts \\\\ []) do\n :elixir_utils.read_file_type(IO.chardata_to_string(path), opts) == {:ok, :regular}\n end\n\n @doc \"\"\"\n Returns `true` if the given path is a directory.\n\n This function follows symbolic links, so if a symbolic link points to a\n directory, `true` is returned.\n\n ## Options\n\n The supported options are:\n\n * `:raw` - a single atom to bypass the file server and only check\n for the file locally\n\n ## Examples\n\n File.dir?(\"./test\")\n #=> true\n\n File.dir?(\"test\")\n #=> true\n\n File.dir?(\"/usr/bin\")\n #=> true\n\n File.dir?(\"~/Downloads\")\n #=> false\n\n \"~/Downloads\" |> Path.expand() |> File.dir?()\n #=> true\n\n \"\"\"\n @spec dir?(Path.t(), [dir_option]) :: boolean\n when dir_option: :raw\n def dir?(path, opts \\\\ []) do\n :elixir_utils.read_file_type(IO.chardata_to_string(path), opts) == {:ok, :directory}\n end\n\n @doc \"\"\"\n Returns `true` if the given path exists.\n\n It can be a regular file, directory, socket, symbolic link, named pipe, or device file.\n Returns `false` for symbolic links pointing to non-existing targets.\n\n ## Options\n\n The supported options are:\n\n * `:raw` - a single atom to bypass the file server and only check\n for the file locally\n\n ## Examples\n\n File.exists?(\"test/\")\n #=> true\n\n File.exists?(\"missing.txt\")\n #=> false\n\n File.exists?(\"/dev/null\")\n #=> true\n\n \"\"\"\n @spec exists?(Path.t(), [exists_option]) :: boolean\n when exists_option: :raw\n def exists?(path, opts \\\\ []) do\n opts = [{:time, :posix}] ++ opts\n match?({:ok, _}, :file.read_file_info(IO.chardata_to_string(path), opts))\n end\n\n @doc \"\"\"\n Tries to create the directory `path`.\n\n Missing parent directories are not created.\n Returns `:ok` if successful, or `{:error, reason}` if an error occurs.\n\n Typical error reasons are:\n\n * `:eacces` - missing search or write permissions for the parent\n directories of `path`\n * `:eexist` - there is already a file or directory named `path`\n * `:enoent` - a component of `path` does not exist\n * `:enospc` - there is no space left on the device\n * `:enotdir` - a component of `path` is not a directory;\n on some platforms, `:enoent` is returned instead\n\n ## Examples\n\n File.mkdir(\"test/unit\")\n #=> :ok\n\n File.mkdir(\"non/existing\")\n #=> {:error, :enoent}\n \"\"\"\n @spec mkdir(Path.t()) :: :ok | {:error, posix | :badarg}\n def mkdir(path) do\n :file.make_dir(IO.chardata_to_string(path))\n end\n\n @doc \"\"\"\n Same as `mkdir/1`, but raises a `File.Error` exception in case of failure.\n Otherwise `:ok`.\n\n ## Examples\n\n File.mkdir!(\"test/unit\")\n #=> :ok\n\n File.mkdir!(\"non/existing\")\n ** (File.Error) could not make directory \"non/existing\": no such file or directory\n \"\"\"\n @spec mkdir!(Path.t()) :: :ok\n def mkdir!(path) do\n case mkdir(path) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"make directory\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Tries to create the directory `path`.\n\n Missing parent directories are created. Returns `:ok` if successful, or\n `{:error, reason}` if an error occurs.\n\n Typical error reasons are:\n\n * `:eacces` - missing search or write permissions for the parent\n directories of `path`\n * `:enospc` - there is no space left on the device\n * `:enotdir` - a component of `path` is not a directory\n * `:eperm` - missed required permissions\n\n ## Examples\n\n File.mkdir_p(\"non/existing/parents\")\n #=> :ok\n\n File.mkdir_p(\"/usr/sbin/temp\")\n #=> {:error, :eperm}\n \"\"\"\n @spec mkdir_p(Path.t()) :: :ok | {:error, posix | :badarg}\n def mkdir_p(path) do\n do_mkdir_p(IO.chardata_to_string(path))\n end\n\n defp do_mkdir_p(\"/\") do\n :ok\n end\n\n defp do_mkdir_p(path) do\n parent = Path.dirname(path)\n\n if parent == path do\n :ok\n else\n case do_mkdir_p(parent) do\n :ok ->\n case :file.make_dir(path) do\n {:error, :eexist} ->\n if dir?(path), do: :ok, else: {:error, :enotdir}\n\n other ->\n other\n end\n\n e ->\n e\n end\n end\n end\n\n @doc \"\"\"\n Same as `mkdir_p/1`, but raises a `File.Error` exception in case of failure.\n Otherwise `:ok`.\n\n ## Examples\n\n File.mkdir_p!(\"non/existing/parents\")\n #=> :ok\n\n File.mkdir_p!(\"/usr/sbin/temp\")\n ** (File.Error) could not make directory (with -p) \"/usr/sbin/temp\": not owner\n \"\"\"\n @spec mkdir_p!(Path.t()) :: :ok\n def mkdir_p!(path) do\n case mkdir_p(path) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"make directory (with -p)\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Returns `{:ok, binary}`, where `binary` is a binary data object that contains the contents\n of `path`, or `{:error, reason}` if an error occurs.\n\n Typical error reasons:\n\n * `:enoent` - the file does not exist\n * `:eacces` - missing permission for reading the file,\n or for searching one of the parent directories\n * `:eisdir` - the named file is a directory\n * `:enotdir` - a component of the file name is not a directory;\n on some platforms, `:enoent` is returned instead\n * `:enomem` - there is not enough memory for the contents of the file\n\n You can use `:file.format_error/1` to get a descriptive string of the error.\n\n ## Options (since v1.20)\n\n The supported options are:\n\n * `:raw` - a single atom to bypass the file server and only check\n for the file locally\n\n ## Examples\n\n File.read(\"hello.txt\")\n #=> {:ok, \"world\"}\n\n File.read(\"non_existing.txt\")\n #=> {:error, :enoent}\n \"\"\"\n @spec read(Path.t(), [exists_option]) ::\n {:ok, binary} | {:error, posix | :badarg | :terminated | :system_limit}\n when exists_option: :raw\n def read(path, opts \\\\ []) do\n :file.read_file(IO.chardata_to_string(path), opts)\n end\n\n @doc \"\"\"\n Returns a binary with the contents of the given filename,\n or raises a `File.Error` exception if an error occurs.\n\n ## Options (since v1.20)\n\n The supported options are:\n\n * `:raw` - a single atom to bypass the file server and only check\n for the file locally\n\n ## Examples\n\n File.read!(\"hello.txt\")\n #=> \"world\"\n\n File.read!(\"non_existing.txt\")\n ** (File.Error) could not read file \"non_existing.txt\": no such file or directory\n \"\"\"\n @spec read!(Path.t(), [exists_option]) :: binary when exists_option: :raw\n def read!(path, opts \\\\ []) do\n case read(path, opts) do\n {:ok, binary} ->\n binary\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"read file\", path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Returns information about the `path`. If it exists, it\n returns a `{:ok, info}` tuple, where info is a\n `File.Stat` struct. Returns `{:error, reason}` with\n the same reasons as `read/1` if a failure occurs.\n\n ## Options\n\n The accepted options are:\n\n * `:time` - configures how the file timestamps are returned\n\n The values for `:time` can be:\n\n * `:universal` - returns a `{date, time}` tuple in UTC (default)\n * `:local` - returns a `{date, time}` tuple using the same time zone as the\n machine\n * `:posix` - returns the time as integer seconds since epoch\n\n Note: Since file times are stored in POSIX time format on most operating systems,\n it is faster to retrieve file information with the `time: :posix` option.\n\n ## Examples\n\n File.stat(\"hello.txt\")\n #=> {:ok, %File.Stat{...}}\n\n File.stat(\"non_existing.txt\", time: :posix)\n #=> {:error, :enoent}\n \"\"\"\n @spec stat(Path.t(), stat_options) :: {:ok, File.Stat.t()} | {:error, posix | :badarg}\n def stat(path, opts \\\\ []) do\n opts = Keyword.put_new(opts, :time, :universal)\n\n case :file.read_file_info(IO.chardata_to_string(path), opts) do\n {:ok, fileinfo} ->\n {:ok, File.Stat.from_record(fileinfo)}\n\n error ->\n error\n end\n end\n\n @doc \"\"\"\n Same as `stat/2` but returns the `File.Stat` directly,\n or raises a `File.Error` exception if an error is returned.\n\n ## Examples\n\n File.stat!(\"hello.txt\")\n #=> %File.Stat{...}\n\n File.stat!(\"non_existing.txt\", time: :posix)\n ** (File.Error) could not read file stats \"non_existing.txt\": no such file or directory\n \"\"\"\n @spec stat!(Path.t(), stat_options) :: File.Stat.t()\n def stat!(path, opts \\\\ []) do\n case stat(path, opts) do\n {:ok, info} ->\n info\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"read file stats\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Returns information about the `path`. If the file is a symlink, sets\n the `type` to `:symlink` and returns a `File.Stat` struct for the link. For any\n other file, returns exactly the same values as `stat/2`.\n\n For more details, see `:file.read_link_info/2`.\n\n ## Options\n\n The accepted options are:\n\n * `:time` - configures how the file timestamps are returned\n\n The values for `:time` can be:\n\n * `:universal` - returns a `{date, time}` tuple in UTC (default)\n * `:local` - returns a `{date, time}` tuple using the machine time\n * `:posix` - returns the time as integer seconds since epoch\n\n Note: Since file times are stored in POSIX time format on most operating systems,\n it is faster to retrieve file information with the `time: :posix` option.\n\n ## Examples\n\n File.lstat(\"link_to_hello\")\n #=> {:ok, %File.Stat{type: :symlink, ...}}\n\n File.lstat(\"non_existing.txt\", time: :posix)\n #=> {:error, :enoent}\n \"\"\"\n @spec lstat(Path.t(), stat_options) :: {:ok, File.Stat.t()} | {:error, posix | :badarg}\n def lstat(path, opts \\\\ []) do\n opts = Keyword.put_new(opts, :time, :universal)\n\n case :file.read_link_info(IO.chardata_to_string(path), opts) do\n {:ok, fileinfo} ->\n {:ok, File.Stat.from_record(fileinfo)}\n\n error ->\n error\n end\n end\n\n @doc \"\"\"\n Same as `lstat/2` but returns the `File.Stat` struct directly,\n or raises a `File.Error` exception if an error is returned.\n\n ## Examples\n\n File.lstat!(\"link_to_hello\")\n #=> %File.Stat{type: :symlink, ...}\n\n File.lstat!(\"non_existing.txt\", time: :posix)\n ** (File.Error) could not read file stats \"non_existing.txt\": no such file or directory\n \"\"\"\n @spec lstat!(Path.t(), stat_options) :: File.Stat.t()\n def lstat!(path, opts \\\\ []) do\n case lstat(path, opts) do\n {:ok, info} ->\n info\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"read file stats\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Reads the symbolic link at `path`.\n\n If `path` exists and is a symlink, returns `{:ok, target}`, otherwise returns\n `{:error, reason}`.\n\n For more details, see `:file.read_link/1`.\n\n Typical error reasons are:\n\n * `:einval` - path is not a symbolic link\n * `:enoent` - path does not exist\n * `:enotsup` - symbolic links are not supported on the current platform\n\n ## Examples\n\n File.read_link(\"link_to_hello\")\n #=> {:ok, \"hello.txt\"}\n\n File.read_link(\"hello.txt\")\n #=> {:error, :einval}\n \"\"\"\n @doc since: \"1.5.0\"\n @spec read_link(Path.t()) :: {:ok, binary} | {:error, posix | :badarg}\n def read_link(path) do\n case path |> IO.chardata_to_string() |> :file.read_link() do\n {:ok, target} -> {:ok, IO.chardata_to_string(target)}\n error -> error\n end\n end\n\n @doc \"\"\"\n Same as `read_link/1` but returns the target directly,\n or raises a `File.Error` exception if an error is returned.\n\n ## Examples\n\n File.read_link!(\"link_to_hello\")\n #=> \"hello.txt\"\n\n File.read_link!(\"hello.txt\")\n ** (File.Error) could not read link \"hello.txt\": invalid argument\n \"\"\"\n @doc since: \"1.5.0\"\n @spec read_link!(Path.t()) :: binary\n def read_link!(path) do\n case read_link(path) do\n {:ok, resolved} ->\n resolved\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"read link\", path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Writes the given `File.Stat` back to the file system at the given\n path. Returns `:ok` or `{:error, reason}`.\n\n ## Examples\n\n File.write_stat(\"hello.txt\", new_stat)\n #=> :ok\n\n File.write_stat(\"non_existing.txt\", new_stat)\n #=> {:error, :enoent}\n \"\"\"\n @spec write_stat(Path.t(), File.Stat.t(), stat_options) :: :ok | {:error, posix | :badarg}\n def write_stat(path, stat, opts \\\\ []) do\n opts = Keyword.put_new(opts, :time, :universal)\n :file.write_file_info(IO.chardata_to_string(path), File.Stat.to_record(stat), opts)\n end\n\n @doc \"\"\"\n Same as `write_stat/3` but raises a `File.Error` exception if it fails.\n Returns `:ok` otherwise.\n\n ## Examples\n\n File.write_stat!(\"hello.txt\", new_stat)\n #=> :ok\n\n File.write_stat!(\"non_existing.txt\", new_stat)\n ** (File.Error) could not write file stats \"non_existing.txt\": no such file or directory\n \"\"\"\n @spec write_stat!(Path.t(), File.Stat.t(), stat_options) :: :ok\n def write_stat!(path, stat, opts \\\\ []) do\n case write_stat(path, stat, opts) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"write file stats\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Updates modification time (mtime) and access time (atime) of\n the given file.\n\n The file is created if it doesn't exist. Requires datetime in UTC\n (as returned by `:erlang.universaltime()`) or an integer\n representing the POSIX timestamp (as returned by `System.os_time(:second)`).\n\n In Unix-like systems, changing the modification time may require\n you to be either `root` or the owner of the file. Having write\n access may not be enough. In those cases, touching the file the\n first time (to create it) will succeed, but touching an existing\n file with fail with `{:error, :eperm}`.\n\n ## Examples\n\n File.touch(\"/tmp/a.txt\", {{2018, 1, 30}, {13, 59, 59}})\n #=> :ok\n File.touch(\"/fakedir/b.txt\", {{2018, 1, 30}, {13, 59, 59}})\n {:error, :enoent}\n\n File.touch(\"/tmp/a.txt\", 1_544_519_753)\n #=> :ok\n\n \"\"\"\n @spec touch(Path.t(), erlang_time() | posix_time()) ::\n :ok | {:error, posix | :badarg | :terminated | :system_limit}\n def touch(path, time \\\\ System.os_time(:second))\n\n def touch(path, time) when is_tuple(time) do\n path = IO.chardata_to_string(path)\n\n with {:error, :enoent} <- :elixir_utils.change_universal_time(path, time),\n :ok <- write(path, \"\", [:raw, :append]),\n do: :elixir_utils.change_universal_time(path, time)\n end\n\n def touch(path, time) when is_integer(time) do\n path = IO.chardata_to_string(path)\n\n with {:error, :enoent} <- :elixir_utils.change_posix_time(path, time),\n :ok <- write(path, \"\", [:raw, :append]),\n do: :elixir_utils.change_posix_time(path, time)\n end\n\n @doc \"\"\"\n Same as `touch/2` but raises a `File.Error` exception if it fails.\n Returns `:ok` otherwise.\n\n The file is created if it doesn't exist. Requires datetime in UTC\n (as returned by `:erlang.universaltime()`) or an integer\n representing the POSIX timestamp (as returned by `System.os_time(:second)`).\n\n ## Examples\n\n File.touch!(\"/tmp/a.txt\", {{2018, 1, 30}, {13, 59, 59}})\n #=> :ok\n File.touch!(\"/fakedir/b.txt\", {{2018, 1, 30}, {13, 59, 59}})\n ** (File.Error) could not touch \"/fakedir/b.txt\": no such file or directory\n\n File.touch!(\"/tmp/a.txt\", 1_544_519_753)\n\n \"\"\"\n @spec touch!(Path.t(), erlang_time() | posix_time()) :: :ok\n def touch!(path, time \\\\ System.os_time(:second)) do\n case touch(path, time) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"touch\", path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Creates a hard link `new` to the file `existing`.\n\n Returns `:ok` if successful, `{:error, reason}` otherwise.\n If the operating system does not support hard links, returns\n `{:error, :enotsup}`.\n\n ## Examples\n\n File.ln(\"hello.txt\", \"hard_link_to_hello\")\n #=> :ok\n\n File.ln(\"non_existing.txt\", \"link\")\n #=> {:error, :enoent}\n \"\"\"\n @doc since: \"1.5.0\"\n @spec ln(Path.t(), Path.t()) :: :ok | {:error, posix | :badarg}\n def ln(existing, new) do\n :file.make_link(IO.chardata_to_string(existing), IO.chardata_to_string(new))\n end\n\n @doc \"\"\"\n Same as `ln/2` but raises a `File.LinkError` exception if it fails.\n Returns `:ok` otherwise.\n\n ## Examples\n\n File.ln!(\"hello.txt\", \"hard_link_to_hello\")\n #=> :ok\n\n File.ln!(\"non_existing.txt\", \"link\")\n ** (File.LinkError) could not create hard link from \"non_existing.txt\" to \"link\": no such file or directory\n \"\"\"\n @doc since: \"1.5.0\"\n @spec ln!(Path.t(), Path.t()) :: :ok\n def ln!(existing, new) do\n case ln(existing, new) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.LinkError,\n reason: reason,\n action: \"create hard link\",\n existing: IO.chardata_to_string(existing),\n new: IO.chardata_to_string(new)\n end\n end\n\n @doc \"\"\"\n Creates a symbolic link `new` to the file or directory `existing`.\n\n Returns `:ok` if successful, `{:error, reason}` otherwise.\n If the operating system does not support symlinks, returns\n `{:error, :enotsup}`.\n\n Creates a symlink even if the `existing` target actually doesn't exist\n\n ## Examples\n\n File.ln_s(\"hello.txt\", \"link_to_hello\")\n #=> :ok\n\n File.ln_s(\"non_existing.txt\", \"link\")\n #=> :ok\n\n # Returns error if `new` file exists\n File.ln_s(\"non_existing.txt\", \"existed_link\")\n #=> {:error, :eexist}\n \"\"\"\n @doc since: \"1.5.0\"\n @spec ln_s(Path.t(), Path.t()) :: :ok | {:error, posix | :badarg}\n def ln_s(existing, new) do\n :file.make_symlink(IO.chardata_to_string(existing), IO.chardata_to_string(new))\n end\n\n @doc \"\"\"\n Same as `ln_s/2` but raises a `File.LinkError` exception if it fails.\n Returns `:ok` otherwise.\n\n ## Examples\n\n File.ln_s!(\"hello.txt\", \"link_to_hello\")\n #=> :ok\n\n # Raises if `new` file exists\n File.ln_s!(\"non_existing.txt\", \"existed_link\")\n ** (File.LinkError) could not create symlink from \"non_existing.txt\" to \"existed_link\": file already exists\n \"\"\"\n @spec ln_s!(Path.t(), Path.t()) :: :ok\n def ln_s!(existing, new) do\n case ln_s(existing, new) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.LinkError,\n reason: reason,\n action: \"create symlink\",\n existing: IO.chardata_to_string(existing),\n new: IO.chardata_to_string(new)\n end\n end\n\n @doc \"\"\"\n Copies the contents of `source` to `destination`.\n\n Both parameters can be a filename or an IO device opened\n with `open/2`. `bytes_count` specifies the number of\n bytes to copy, the default being `:infinity`.\n\n If file `destination` already exists, it is overwritten\n by the contents in `source`.\n\n Returns `{:ok, bytes_copied}` if successful,\n `{:error, reason}` otherwise.\n\n Compared to the `cp/3`, this function is more low-level,\n allowing a copy from device to device limited by a number of\n bytes. On the other hand, `cp/3` performs more extensive\n checks on both source and destination and it also preserves\n the file mode after copy.\n\n Typical error reasons are the same as in `open/2`,\n `read/1` and `write/3`.\n\n ## Examples\n\n File.copy(\"hello.txt\", \"hello_copy.txt\")\n #=> {:ok, 6}\n\n File.copy(\"non_existing.txt\", \"copy.txt\")\n #=> {:error, :enoent}\n \"\"\"\n @spec copy(Path.t() | io_device, Path.t() | io_device, pos_integer | :infinity) ::\n {:ok, non_neg_integer} | {:error, posix | :badarg | :terminated}\n def copy(source, destination, bytes_count \\\\ :infinity) do\n source = normalize_path_or_io_device(source)\n destination = normalize_path_or_io_device(destination)\n\n :file.copy(source, destination, bytes_count)\n end\n\n @doc \"\"\"\n The same as `copy/3` but raises a `File.CopyError` exception if it fails.\n Returns the `bytes_copied` otherwise.\n\n ## Examples\n\n File.copy!(\"hello.txt\", \"hello_copy.txt\")\n #=> 6\n\n File.copy!(\"non_existing.txt\", \"copy.txt\")\n ** (File.CopyError) could not copy from \"non_existing.txt\" to \"copy.txt\": no such file or directory\n \"\"\"\n @spec copy!(Path.t() | io_device, Path.t() | io_device, pos_integer | :infinity) ::\n non_neg_integer\n def copy!(source, destination, bytes_count \\\\ :infinity) do\n case copy(source, destination, bytes_count) do\n {:ok, bytes_count} ->\n bytes_count\n\n {:error, reason} ->\n raise File.CopyError,\n reason: reason,\n action: \"copy\",\n source: normalize_path_or_io_device(source),\n destination: normalize_path_or_io_device(destination)\n end\n end\n\n @doc \"\"\"\n Renames the `source` file to `destination` file. It can be used to move files\n (and directories) between directories. If moving a file, you must fully\n specify the `destination` filename, it is not sufficient to simply specify\n its directory.\n\n Returns `:ok` in case of success, `{:error, reason}` otherwise.\n\n Note: The command `mv` in Unix-like systems behaves differently depending on\n whether `source` is a file and the `destination` is an existing directory.\n We have chosen to explicitly disallow this behavior.\n\n ## Examples\n\n # Rename file \"a.txt\" to \"b.txt\"\n File.rename(\"a.txt\", \"b.txt\")\n #=> :ok\n\n # Rename directory \"samples\" to \"tmp\"\n File.rename(\"samples\", \"tmp\")\n #=> :ok\n\n File.rename(\"non_existing.txt\", \"existing.txt\")\n #=> {:error, :enoent}\n \"\"\"\n @doc since: \"1.1.0\"\n @spec rename(Path.t(), Path.t()) :: :ok | {:error, posix | :badarg}\n def rename(source, destination) do\n source = IO.chardata_to_string(source)\n destination = IO.chardata_to_string(destination)\n :file.rename(source, destination)\n end\n\n @doc \"\"\"\n The same as `rename/2` but raises a `File.RenameError` exception if it fails.\n Returns `:ok` otherwise.\n\n ## Examples\n\n File.rename!(\"samples\", \"tmp\")\n #=> :ok\n\n File.rename!(\"non_existing.txt\", \"existing.txt\")\n ** (File.RenameError) could not rename from \"non_existing.txt\" to \"existing.txt\": no such file or directory\n \"\"\"\n @doc since: \"1.9.0\"\n @spec rename!(Path.t(), Path.t()) :: :ok\n def rename!(source, destination) do\n case rename(source, destination) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.RenameError,\n reason: reason,\n action: \"rename\",\n source: IO.chardata_to_string(source),\n destination: IO.chardata_to_string(destination)\n end\n end\n\n @doc ~S\"\"\"\n Copies the contents of `source_file` to `destination_file` preserving its modes.\n\n `source_file` must be a file or a symbolic link to one. `destination_file` must\n be a path to a non-existent file. If either is a directory, `{:error, :eisdir}`\n will be returned.\n\n The function returns `:ok` in case of success. Otherwise, it returns\n `{:error, reason}`.\n\n If you want to copy contents from an IO device to another device\n or do a straight copy from a source to a destination without\n preserving modes, check `copy/3` instead.\n\n Note: The command `cp` in Unix-like systems behaves differently depending on\n whether the destination is an existing directory or not. We have chosen to\n explicitly disallow copying to a destination which is a directory,\n and an error will be returned if tried.\n\n ## Options\n\n * `:on_conflict` - (since v1.14.0) Invoked when a file already exists in the destination.\n The function receives arguments for `source_file` and `destination_file`. It should\n return `true` if the existing file should be overwritten, `false` if otherwise.\n The default callback returns `true`. On earlier versions, this callback could be\n given as third argument, but such behavior is now deprecated.\n\n ## Examples\n\n File.cp(\"hello.txt\", \"hello_copy.txt\")\n #=> :ok\n\n File.cp(\"hello.txt\", \"hello_copy.txt\", on_conflict: fn source, destination ->\n IO.gets(\"Overwriting #{destination} by #{source}. Type y to confirm. \") == \"y\\n\"\n end)\n #=> :ok\n\n File.cp(\"non_existing.txt\", \"copy.txt\")\n #=> {:error, :enoent}\n \"\"\"\n @spec cp(Path.t(), Path.t(), on_conflict: on_conflict_callback) ::\n :ok | {:error, posix | :badarg | :terminated}\n def cp(source_file, destination_file, options \\\\ [])\n\n # TODO: Deprecate me on Elixir v1.19\n def cp(source_file, destination_file, callback) when is_function(callback, 2) do\n IO.warn_once(\n {__MODULE__, :cp},\n fn ->\n \"passing a callback to File.cp/3 is deprecated, pass it as a on_conflict: callback option instead\"\n end,\n 3\n )\n\n cp(source_file, destination_file, on_conflict: callback)\n end\n\n def cp(source_file, destination_file, options) when is_list(options) do\n on_conflict = Keyword.get(options, :on_conflict, fn _, _ -> true end)\n source_file = IO.chardata_to_string(source_file)\n destination_file = IO.chardata_to_string(destination_file)\n\n case do_cp_file(source_file, destination_file, on_conflict, []) do\n {:error, reason, _} -> {:error, reason}\n _ -> :ok\n end\n end\n\n defp path_differs?(path, path), do: false\n\n defp path_differs?(p1, p2) do\n Path.expand(p1) !== Path.expand(p2)\n end\n\n @doc ~S\"\"\"\n The same as `cp/3`, but raises a `File.CopyError` exception if it fails.\n Returns `:ok` otherwise.\n\n ## Examples\n\n File.cp!(\"hello.txt\", \"hello_copy.txt\")\n #=> :ok\n\n File.cp!(\"hello.txt\", \"hello_copy.txt\", on_conflict: fn source, destination ->\n IO.gets(\"Overwriting #{destination} by #{source}. Type y to confirm. \") == \"y\\n\"\n end)\n #=> :ok\n\n File.cp!(\"non_existing.txt\", \"copy.txt\")\n ** (File.CopyError) could not copy from \"non_existing.txt\" to \"copy.txt\": no such file or directory\n \"\"\"\n @spec cp!(Path.t(), Path.t(), on_conflict: on_conflict_callback) :: :ok\n def cp!(source_file, destination_file, options \\\\ []) do\n case cp(source_file, destination_file, options) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.CopyError,\n reason: reason,\n action: \"copy\",\n source: IO.chardata_to_string(source_file),\n destination: IO.chardata_to_string(destination_file)\n end\n end\n\n @doc ~S\"\"\"\n Copies the contents in `source` to `destination` recursively, maintaining the\n source directory structure and modes.\n\n If `source` is a file or a symbolic link to it, `destination` must be a path\n to an existent file, a symbolic link to one, or a path to a non-existent file.\n\n If `source` is a directory, or a symbolic link to it, then `destination` must\n be an existent `directory` or a symbolic link to one, or a path to a non-existent directory.\n\n If the source is a file, it copies `source` to `destination`. If the `source`\n is a directory, it copies the contents inside source into the `destination` directory.\n\n If a file already exists in the destination, it invokes the optional `on_conflict`\n callback given as an option. See \"Options\" for more information.\n\n This function may fail while copying files, in such cases, it will leave the\n destination directory in a dirty state, where file which have already been\n copied won't be removed.\n\n The function returns `{:ok, files_and_directories}` in case of\n success, `files_and_directories` lists all files and directories copied in no\n specific order. It returns `{:error, reason, file}` otherwise.\n\n Note: The command `cp` in Unix-like systems behaves differently depending on\n whether `destination` is an existing directory or not. We have chosen to\n explicitly disallow this behavior. If `source` is a `file` and `destination`\n is a directory, `{:error, :eisdir}` will be returned.\n\n Special files such as device files, sockets, and named pipes are not copied.\n\n Typical error reasons are:\n\n * `:enoent` - `source` does not exist\n * `:eisdir` - `source` is a file and `destination` is a directory\n * `:einval` - `destination` is the same as or a subdirectory of `source`\n\n ## Options\n\n * `:on_conflict` - (since v1.14.0) Invoked when a file already exists in the destination.\n The function receives arguments for `source` and `destination`. It should return\n `true` if the existing file should be overwritten, `false` if otherwise. The default\n callback returns `true`. On earlier versions, this callback could be given as third\n argument, but such behavior is now deprecated.\n\n * `:dereference_symlinks` - (since v1.14.0) By default, this function will copy symlinks\n by creating symlinks that point to the same location. This option forces symlinks to be\n dereferenced and have their contents copied instead when set to `true`. If the dereferenced\n files do not exist, than the operation fails. The default is `false`.\n\n ## Examples\n\n # Copies file \"a.txt\" to \"b.txt\"\n File.cp_r(\"a.txt\", \"b.txt\")\n #=> {:ok, [\"b.txt\"]}\n\n # Copies all files in \"samples\" to \"tmp\"\n File.cp_r(\"samples\", \"tmp\")\n #=> {:ok, [\"z.txt\", \"y.txt\", \"x.txt]}\n\n # Same as before, but asks the user how to proceed in case of conflicts\n File.cp_r(\"samples\", \"tmp\", on_conflict: fn source, destination ->\n IO.gets(\"Overwriting #{destination} by #{source}. Type y to confirm. \") == \"y\\n\"\n end)\n #=> {:ok, [\"z.txt\", \"y.txt\", \"x.txt]}\n\n File.cp_r(\"non_existing.txt\", \"copy.txt\")\n #=> {:error, :enoent, \"non_existing.txt\"}\n\n # Copying into a subdirectory of source is not allowed\n File.cp_r(\"src\", \"src/dest\")\n #=> {:error, :einval, \"src/dest\"}\n \"\"\"\n @spec cp_r(Path.t(), Path.t(),\n on_conflict: on_conflict_callback,\n dereference_symlinks: boolean()\n ) ::\n {:ok, [binary]} | {:error, posix | :badarg | :terminated, binary}\n\n def cp_r(source, destination, options \\\\ [])\n\n # TODO: Deprecate me on Elixir v1.19\n def cp_r(source, destination, callback) when is_function(callback, 2) do\n IO.warn_once(\n {__MODULE__, :cp_r},\n fn ->\n \"passing a callback to File.cp_r/3 is deprecated, pass it as a on_conflict: callback option instead\"\n end,\n 3\n )\n\n cp_r(source, destination, on_conflict: callback)\n end\n\n def cp_r(source, destination, options) when is_list(options) do\n on_conflict = Keyword.get(options, :on_conflict, fn _, _ -> true end)\n dereference? = Keyword.get(options, :dereference_symlinks, false)\n\n source =\n source\n |> IO.chardata_to_string()\n |> assert_no_null_byte!(\"File.cp_r/3\")\n\n destination =\n destination\n |> IO.chardata_to_string()\n |> assert_no_null_byte!(\"File.cp_r/3\")\n\n source_parts = source |> Path.expand() |> Path.split()\n dest_parts = destination |> Path.expand() |> Path.split()\n\n if source_parts != dest_parts and List.starts_with?(dest_parts, source_parts) do\n {:error, :einval, destination}\n else\n dereference = if dereference?, do: MapSet.new(), else: nil\n\n case do_cp_r(source, destination, on_conflict, dereference, []) do\n {:error, _, _} = error -> error\n res -> {:ok, res}\n end\n end\n end\n\n @doc \"\"\"\n The same as `cp_r/3`, but raises a `File.CopyError` exception if it fails.\n Returns the list of copied files otherwise.\n\n ## Examples\n\n File.cp_r!(\"a.txt\", \"b.txt\")\n #=> [\"b.txt\"]\n\n File.cp_r!(\"samples\", \"tmp\")\n #=> [\"z.txt\", \"y.txt\", \"x.txt]\n\n File.cp_r!(\"non_existing.txt\", \"copy.txt\")\n ** (File.CopyError) could not copy recursively from \"non_existing.txt\" to \"copy.txt\". non_existing.txt: no such file or directory\n \"\"\"\n @spec cp_r!(Path.t(), Path.t(),\n on_conflict: on_conflict_callback,\n dereference_symlinks: boolean()\n ) :: [binary]\n def cp_r!(source, destination, options \\\\ []) do\n case cp_r(source, destination, options) do\n {:ok, files} ->\n files\n\n {:error, reason, file} ->\n raise File.CopyError,\n reason: reason,\n action: \"copy recursively\",\n on: file,\n source: IO.chardata_to_string(source),\n destination: IO.chardata_to_string(destination)\n end\n end\n\n defp do_cp_r(src, dest, on_conflict, dereference, acc) when is_list(acc) do\n case :elixir_utils.read_link_type(src) do\n {:ok, :regular} ->\n case do_cp_file(src, dest, on_conflict, acc) do\n # we don't have a way to make a distinction between a non-existing src\n # or dest being a non-existing dir in the case of :enoent,\n # but we already know that src exists here.\n {:error, :enoent, _} -> {:error, :enoent, dest}\n other -> other\n end\n\n {:ok, :symlink} ->\n case :file.read_link(src) do\n {:ok, link} when dereference != nil ->\n resolved = Path.expand(link, Path.dirname(src))\n\n if MapSet.member?(dereference, resolved) do\n {:error, :eloop, src}\n else\n dereference = MapSet.put(dereference, resolved)\n do_cp_r(resolved, dest, on_conflict, dereference, acc)\n end\n\n {:ok, link} ->\n do_cp_link(link, src, dest, on_conflict, acc)\n\n {:error, reason} ->\n {:error, reason, src}\n end\n\n {:ok, :directory} ->\n case :file.list_dir(src) do\n {:ok, files} ->\n case mkdir(dest) do\n success when success in [:ok, {:error, :eexist}] ->\n case copy_file_mode(src, dest) do\n :ok ->\n Enum.reduce_while(files, [dest | acc], fn x, acc ->\n case do_cp_r(\n Path.join(src, x),\n Path.join(dest, x),\n on_conflict,\n dereference,\n acc\n ) do\n {:error, _, _} = error -> {:halt, error}\n acc -> {:cont, acc}\n end\n end)\n\n {:error, reason} ->\n {:error, reason, src}\n end\n\n {:error, reason} ->\n {:error, reason, dest}\n end\n\n {:error, reason} ->\n {:error, reason, src}\n end\n\n {:ok, _} ->\n acc\n\n {:error, reason} ->\n {:error, reason, src}\n end\n end\n\n # If we reach this clause, there was an error while processing a file.\n defp do_cp_r(_, _, _, _, acc) do\n acc\n end\n\n defp copy_file_mode(src, dest) do\n with {:ok, dest_fileinfo} <- stat(dest),\n {:ok, src_fileinfo} <- stat(src) do\n write_stat(dest, %{dest_fileinfo | mode: src_fileinfo.mode})\n end\n end\n\n # Both src and dest are files.\n defp do_cp_file(src, dest, on_conflict, acc) do\n case :file.copy(src, {dest, [:exclusive]}) do\n {:ok, _} ->\n case copy_file_mode(src, dest) do\n :ok ->\n [dest | acc]\n\n {:error, reason} ->\n {:error, reason, src}\n end\n\n {:error, :eexist} ->\n if path_differs?(src, dest) and on_conflict.(src, dest) do\n case copy(src, dest) do\n {:ok, _} ->\n case copy_file_mode(src, dest) do\n :ok ->\n [dest | acc]\n\n {:error, reason} ->\n {:error, reason, src}\n end\n\n {:error, reason} ->\n {:error, reason, src}\n end\n else\n acc\n end\n\n {:error, reason} ->\n {:error, reason, src}\n end\n end\n\n # Both src and dest are files.\n defp do_cp_link(link, src, dest, on_conflict, acc) do\n case :file.make_symlink(link, dest) do\n :ok ->\n [dest | acc]\n\n {:error, :eexist} ->\n if path_differs?(src, dest) and on_conflict.(src, dest) do\n # If rm/1 fails, :file.make_symlink/2 will fail\n _ = rm(dest)\n\n case :file.make_symlink(link, dest) do\n :ok -> [dest | acc]\n {:error, reason} -> {:error, reason, src}\n end\n else\n acc\n end\n\n {:error, reason} ->\n {:error, reason, src}\n end\n end\n\n @doc \"\"\"\n Writes `content` to the file `path`.\n\n The file is created if it does not exist. If it exists, the previous\n contents are overwritten. Returns `:ok` if successful, or `{:error, reason}`\n if an error occurs.\n\n `content` must be `iodata` (a list of bytes or a binary). Setting the\n encoding for this function has no effect.\n\n **Warning:** Every time this function is invoked, a file descriptor is opened\n and a new process is spawned to write to the file. For this reason, if you are\n doing multiple writes in a loop, opening the file via `File.open/2` and using\n the functions in `IO` to write to the file will yield much better performance\n than calling this function multiple times.\n\n Typical error reasons are:\n\n * `:enoent` - a component of the file name does not exist\n * `:enotdir` - a component of the file name is not a directory;\n on some platforms, `:enoent` is returned instead\n * `:enospc` - there is no space left on the device\n * `:eacces` - missing permission for writing the file or searching one of\n the parent directories\n * `:eisdir` - the named file is a directory\n\n Check `File.open/2` for the list of available `modes`.\n\n ## Examples\n\n File.write(\"hello.txt\", \"world!\")\n #=> :ok\n\n File.write(\"temp\", \"world!\")\n #=> {:error, :eisdir}\n\n \"\"\"\n @spec write(Path.t(), iodata, [mode]) ::\n :ok | {:error, posix | :badarg | :terminated | :system_limit}\n def write(path, content, modes \\\\ []) do\n modes = normalize_modes(modes, false)\n :file.write_file(IO.chardata_to_string(path), content, modes)\n end\n\n @doc \"\"\"\n Same as `write/3` but raises a `File.Error` exception if it fails.\n Returns `:ok` otherwise.\n\n ## Examples\n\n File.write!(\"hello.txt\", \"world!\")\n #=> :ok\n\n File.write!(\"temp\", \"world!\")\n ** (File.Error) could not write to file \"temp\": illegal operation on a directory\n \"\"\"\n @spec write!(Path.t(), iodata, [mode]) :: :ok\n def write!(path, content, modes \\\\ []) do\n case write(path, content, modes) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"write to file\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Tries to delete the file `path`.\n\n Returns `:ok` if successful, or `{:error, reason}` if an error occurs.\n\n Note the file is deleted even if in read-only mode.\n\n Typical error reasons are:\n\n * `:enoent` - the file does not exist\n * `:eacces` - missing permission for the file or one of its parents\n * `:eperm` - the file is a directory and user is not super-user\n * `:enotdir` - a component of the file name is not a directory;\n on some platforms, `:enoent` is returned instead\n * `:einval` - filename had an improper type, such as tuple\n\n ## Examples\n\n File.rm(\"file.txt\")\n #=> :ok\n\n File.rm(\"tmp_dir/\")\n #=> {:error, :eperm}\n \"\"\"\n @spec rm(Path.t()) :: :ok | {:error, posix | :badarg}\n def rm(path) do\n path = IO.chardata_to_string(path)\n\n case :file.delete(path) do\n :ok ->\n :ok\n\n {:error, :eacces} = e ->\n change_mode_windows(path) || e\n\n {:error, _} = e ->\n e\n end\n end\n\n defp change_mode_windows(path) do\n if match?({:win32, _}, :os.type()) do\n case :file.read_file_info(path) do\n {:ok, file_info} when elem(file_info, 3) in [:read, :none] ->\n change_mode_windows(path, file_info)\n\n _ ->\n nil\n end\n end\n end\n\n defp change_mode_windows(path, file_info) do\n case chmod(path, elem(file_info, 7) + 0o200) do\n :ok -> :file.delete(path)\n {:error, _reason} = error -> error\n end\n end\n\n @doc \"\"\"\n Same as `rm/1`, but raises a `File.Error` exception in case of failure.\n Otherwise `:ok`.\n\n ## Examples\n\n File.rm!(\"file.txt\")\n #=> :ok\n\n File.rm!(\"non_existing/\")\n ** (File.Error) could not remove file \"non_existing/\": no such file or directory\n \"\"\"\n @spec rm!(Path.t()) :: :ok\n def rm!(path) do\n case rm(path) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"remove file\", path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Tries to delete the dir at `path`.\n\n Returns `:ok` if successful, or `{:error, reason}` if an error occurs.\n It returns `{:error, :eexist}` if the directory is not empty.\n\n ## Examples\n\n File.rmdir(\"tmp_dir\")\n #=> :ok\n\n File.rmdir(\"non_empty_dir\")\n #=> {:error, :eexist}\n\n File.rmdir(\"file.txt\")\n #=> {:error, :enotdir}\n \"\"\"\n @spec rmdir(Path.t()) :: :ok | {:error, posix | :badarg}\n def rmdir(path) do\n :file.del_dir(IO.chardata_to_string(path))\n end\n\n @doc \"\"\"\n Same as `rmdir/1`, but raises a `File.Error` exception in case of failure.\n Otherwise `:ok`.\n\n ## Examples\n\n File.rmdir!(\"tmp_dir\")\n #=> :ok\n\n File.rmdir!(\"non_empty_dir\")\n ** (File.Error) could not remove directory \"non_empty_dir\": directory is not empty\n\n File.rmdir!(\"file.txt\")\n ** (File.Error) could not remove directory \"file.txt\": not a directory\n \"\"\"\n @spec rmdir!(Path.t()) :: :ok\n def rmdir!(path) do\n case rmdir(path) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"remove directory\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Removes files and directories recursively at the given `path`.\n Symlinks are not followed but simply removed, non-existing\n files are simply ignored (i.e. doesn't make this function fail).\n\n Returns `{:ok, files_and_directories}` with all files and\n directories removed in no specific order, `{:error, reason, file}`\n otherwise.\n\n ## Examples\n\n File.rm_rf(\"samples\")\n #=> {:ok, [\"samples\", \"samples/1.txt\"]}\n\n File.rm_rf(\"unknown\")\n #=> {:ok, []}\n\n File.rm_rf(\"/tmp\")\n #=> {:error, :eperm, \"/tmp\"}\n \"\"\"\n @spec rm_rf(Path.t()) :: {:ok, [binary]} | {:error, posix | :badarg, binary}\n def rm_rf(path) do\n {major, _} = :os.type()\n\n path\n |> IO.chardata_to_string()\n |> assert_no_null_byte!(\"File.rm_rf/1\")\n |> do_rm_rf([], major)\n end\n\n defp do_rm_rf(path, acc, major) do\n case safe_list_dir(path, major) do\n {:ok, files} when is_list(files) ->\n acc =\n Enum.reduce(files, acc, fn file, acc ->\n # In case we can't delete, continue anyway, we might succeed\n # to delete it on Windows due to how they handle symlinks.\n case do_rm_rf(Path.join(path, file), acc, major) do\n {:ok, acc} -> acc\n {:error, _, _} -> acc\n end\n end)\n\n case rmdir(path) do\n :ok -> {:ok, [path | acc]}\n {:error, :enoent} -> {:ok, acc}\n {:error, reason} -> {:error, reason, path}\n end\n\n {:ok, :directory} ->\n do_rm_directory(path, acc)\n\n {:ok, :regular} ->\n do_rm_regular(path, acc)\n\n {:error, reason} when reason in [:enoent, :enotdir] ->\n {:ok, acc}\n\n {:error, reason} ->\n {:error, reason, path}\n end\n end\n\n defp do_rm_regular(path, acc) do\n case rm(path) do\n :ok -> {:ok, [path | acc]}\n {:error, :enoent} -> {:ok, acc}\n {:error, reason} -> {:error, reason, path}\n end\n end\n\n # On Windows, symlinks are treated as directory and must be removed\n # with rmdir/1. But on Unix-like systems, we remove them via rm/1.\n # So we first try to remove it as a directory and, if we get :enotdir,\n # we fall back to a file removal.\n defp do_rm_directory(path, acc) do\n case rmdir(path) do\n :ok -> {:ok, [path | acc]}\n {:error, :enotdir} -> do_rm_regular(path, acc)\n {:error, :enoent} -> {:ok, acc}\n {:error, reason} -> {:error, reason, path}\n end\n end\n\n defp safe_list_dir(path, major) do\n case :elixir_utils.read_link_type(path) do\n {:ok, :directory} ->\n # If we cannot read the files, try to delete it anyway\n case :file.list_dir_all(path) do\n {:ok, files} -> {:ok, files}\n {:error, _} -> {:ok, :directory}\n end\n\n {:ok, :symlink} when major == :win32 ->\n case :elixir_utils.read_file_type(path) do\n {:ok, :directory} -> {:ok, :directory}\n _ -> {:ok, :regular}\n end\n\n {:ok, _} ->\n {:ok, :regular}\n\n {:error, :eio} when major == :win32 ->\n # unix domain socket returns `{:error, :eio}`\n # on other platforms the result is `{:ok, :regular}`\n {:ok, :regular}\n\n {:error, reason} ->\n {:error, reason}\n end\n end\n\n @doc \"\"\"\n Same as `rm_rf/1` but raises a `File.Error` exception in case of failures,\n otherwise returns the list of files or directories removed.\n\n ## Examples\n\n File.rm_rf!(\"samples\")\n #=> [\"samples\", \"samples/1.txt\"]\n\n File.rm_rf!(\"unknown\")\n #=> []\n\n File.rm_rf!(\"/tmp\")\n ** (File.Error) could not remove files and directories recursively from \"/tmp\": not owner\n \"\"\"\n @spec rm_rf!(Path.t()) :: [binary]\n def rm_rf!(path) do\n case rm_rf(path) do\n {:ok, files} ->\n files\n\n {:error, reason, _} ->\n raise File.Error,\n reason: reason,\n path: IO.chardata_to_string(path),\n action: \"remove files and directories recursively from\"\n end\n end\n\n @doc ~S\"\"\"\n Opens the given `path`.\n\n `modes_or_function` can either be a list of modes or a function. If it's a\n list, it's considered to be a list of modes (that are documented below). If\n it's a function, then it's equivalent to calling `open(path, [],\n modes_or_function)`. See the documentation for `open/3` for more information\n on this function.\n\n The allowed modes:\n\n * `:binary` - opens the file in binary mode, disabling special handling of\n Unicode sequences (default mode).\n\n * `:read` - the file, which must exist, is opened for reading.\n\n * `:write` - the file is opened for writing. It is created if it does not\n exist.\n\n If the file does exist, and if write is not combined with read, the file\n will be truncated.\n\n * `:append` - the file will be opened for writing, and it will be created\n if it does not exist. Every write operation to a file opened with append\n will take place at the end of the file.\n\n * `:exclusive` - the file, when opened for writing, is created if it does\n not exist. If the file exists, open will return `{:error, :eexist}`.\n\n * `:charlist` - when this term is given, read operations on the file will\n return charlists rather than binaries.\n\n * `:compressed` - makes it possible to read or write gzip compressed files.\n\n The compressed option must be combined with either read or write, but not\n both. Note that the file size obtained with `stat/1` will most probably\n not match the number of bytes that can be read from a compressed file.\n\n * `:utf8` - this option denotes how data is actually stored in the disk\n file and makes the file perform automatic translation of characters to\n and from UTF-8.\n\n If data is sent to a file in a format that cannot be converted to the\n UTF-8 or if data is read by a function that returns data in a format that\n cannot cope with the character range of the data, an error occurs and the\n file will be closed.\n\n * `:delayed_write`, `:raw`, `:ram`, `:read_ahead`, `:sync`, `{:encoding, ...}`,\n `{:read_ahead, pos_integer}`, `{:delayed_write, non_neg_integer, non_neg_integer}` -\n for more information about these options see `:file.open/2`.\n\n This function returns:\n\n * `{:ok, io_device | file_descriptor}` - the file has been opened in\n the requested mode. We explore the differences between these two results\n in the following section\n\n * `{:error, reason}` - the file could not be opened due to `reason`.\n\n ## IO devices\n\n By default, this function returns an IO device. An `io_device` is\n a process which handles the file and you can interact with it using\n the functions in the `IO` module. By default, a file is opened in\n `:binary` mode, which requires the functions `IO.binread/2` and\n `IO.binwrite/2` to interact with the file. A developer may pass `:utf8`\n as a mode when opening the file and then all other functions from\n `IO` are available, since they work directly with Unicode data.\n\n Given the IO device is a file, if the owner process terminates,\n the file is closed and the process itself terminates too. If any\n process to which the `io_device` is linked terminates, the file\n will be closed and the process itself will be terminated.\n\n ## File descriptors\n\n When the `:raw` or `:ram` modes are given, this function returns\n a low-level file descriptors. This avoids creating a process but\n requires using the functions in the [`:file`](`:file`) module to\n interact with it.\n\n ## Examples\n\n {:ok, file} = File.open(\"foo.tar.gz\", [:read, :compressed])\n IO.read(file, :line)\n File.close(file)\n\n \"\"\"\n @spec open(Path.t(), [mode | :ram]) ::\n {:ok, io_device | file_descriptor} | {:error, posix | :badarg | :system_limit}\n @spec open(Path.t(), (io_device | file_descriptor -> res)) ::\n {:ok, res} | {:error, posix | :badarg | :system_limit}\n when res: var\n def open(path, modes_or_function \\\\ [])\n\n def open(path, modes) when is_list(modes) do\n :file.open(IO.chardata_to_string(path), normalize_modes(modes, true))\n end\n\n def open(path, function) when is_function(function, 1) do\n open(path, [], function)\n end\n\n @doc \"\"\"\n Similar to `open/2` but expects a function as its last argument.\n\n The file is opened, given to the function as an argument and\n automatically closed after the function returns, regardless\n if there was an error when executing the function.\n\n Returns `{:ok, function_result}` in case of success,\n `{:error, reason}` otherwise.\n\n This function expects the file to be closed with success,\n which is usually the case unless the `:delayed_write` option\n is given. For this reason, we do not recommend passing\n `:delayed_write` to this function.\n\n See `open/2` for the list of available `modes`.\n\n ## Examples\n\n File.open(\"file.txt\", [:read, :write], fn file ->\n IO.read(file, :line)\n end)\n #=> {:ok, \"file content\"}\n \"\"\"\n @spec open(Path.t(), [mode | :ram], (io_device | file_descriptor -> res)) ::\n {:ok, res} | {:error, posix | :badarg | :system_limit}\n when res: var\n def open(path, modes, function) when is_list(modes) and is_function(function, 1) do\n case open(path, modes) do\n {:ok, io_device} ->\n try do\n {:ok, function.(io_device)}\n after\n :ok = close(io_device)\n end\n\n other ->\n other\n end\n end\n\n @doc \"\"\"\n Similar to `open/2` but raises a `File.Error` exception if the file\n could not be opened. Returns the IO device otherwise.\n\n See `open/2` for the list of available modes.\n\n ## Examples\n\n File.open!(\"file.txt\", fn file ->\n IO.read(file, :line)\n end)\n #=> \"file content\"\n \"\"\"\n @spec open!(Path.t(), [mode | :ram]) :: io_device | file_descriptor\n @spec open!(Path.t(), (io_device | file_descriptor -> res)) :: res when res: var\n def open!(path, modes_or_function \\\\ []) do\n case open(path, modes_or_function) do\n {:ok, io_device_or_function_result} ->\n io_device_or_function_result\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"open\", path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Similar to `open/3` but raises a `File.Error` exception if the file\n could not be opened.\n\n If it succeeds opening the file, it returns the `function` result on the IO device.\n\n See `open/2` for the list of available `modes`.\n\n ## Examples\n\n File.open!(\"file.txt\", [:read, :write], fn file ->\n IO.read(file, :line)\n end)\n #=> \"file content\"\n \"\"\"\n @spec open!(Path.t(), [mode | :ram], (io_device | file_descriptor -> res)) :: res when res: var\n def open!(path, modes, function) do\n case open(path, modes, function) do\n {:ok, function_result} ->\n function_result\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"open\", path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Gets the current working directory.\n\n In rare circumstances, this function can fail on Unix-like systems. It may happen\n if read permissions do not exist for the parent directories of the\n current directory. For this reason, returns `{:ok, cwd}` in case\n of success, `{:error, reason}` otherwise.\n\n ## Examples\n\n File.cwd()\n #=> {:ok, \"/Users/user/elixir/elixir_lang\"}\n\n # Missing read permission for one of the parents of the current directory\n File.cwd()\n #=> {:error, :eacces}\n \"\"\"\n @spec cwd() :: {:ok, binary} | {:error, posix | :badarg}\n def cwd() do\n case :file.get_cwd() do\n {:ok, base} -> {:ok, IO.chardata_to_string(fix_drive_letter(base))}\n {:error, _} = error -> error\n end\n end\n\n defp fix_drive_letter([l, ?:, ?/ | rest] = original) when l in ?A..?Z do\n case :os.type() do\n {:win32, _} -> [l + ?a - ?A, ?:, ?/ | rest]\n _ -> original\n end\n end\n\n defp fix_drive_letter(original), do: original\n\n @doc \"\"\"\n The same as `cwd/0`, but raises a `File.Error` exception if it fails.\n\n ## Examples\n\n File.cwd!()\n #=> \"/Users/user/elixir/elixir_lang\"\n \"\"\"\n @spec cwd!() :: binary\n def cwd!() do\n case cwd() do\n {:ok, cwd} ->\n cwd\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"get current working directory\"\n end\n end\n\n @doc \"\"\"\n Sets the current working directory.\n\n The current working directory is set for the BEAM globally. This can lead to\n race conditions if multiple processes are changing the current working\n directory concurrently. To run an external command in a given directory\n without changing the global current working directory, use the `:cd` option\n of `System.cmd/3` and `Port.open/2`.\n\n Returns `:ok` if successful, `{:error, reason}` otherwise.\n\n ## Examples\n\n File.cd(\"bin\")\n #=> :ok\n\n File.cd(\"non_existing_dir\")\n #=> {:error, :enoent}\n \"\"\"\n @spec cd(Path.t()) :: :ok | {:error, posix | :badarg | :no_translation}\n def cd(path) do\n :file.set_cwd(IO.chardata_to_string(path))\n end\n\n @doc \"\"\"\n The same as `cd/1`, but raises a `File.Error` exception if it fails.\n\n ## Examples\n\n File.cd!(\"bin\")\n #=> :ok\n\n File.cd!(\"non_existing_dir\")\n ** (File.Error) could not set current working directory to \"non_existing_dir\": no such file or directory\n \"\"\"\n @spec cd!(Path.t()) :: :ok\n def cd!(path) do\n case cd(path) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"set current working directory to\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Changes the current directory to the given `path`,\n executes the given function and then reverts back\n to the previous path regardless of whether there is an exception.\n\n The current working directory is temporarily set for the BEAM globally. This\n can lead to race conditions if multiple processes are changing the current\n working directory concurrently. To run an external command in a given\n directory without changing the global current working directory, use the\n `:cd` option of `System.cmd/3` and `Port.open/2`.\n\n Raises an error if retrieving or changing the current\n directory fails.\n\n ## Examples\n\n File.cd!(\"bin\", fn -> do_something() end)\n #=> :result_of_do_something\n\n File.cd!(\"non_existing_dir\", fn -> do_something() end)\n ** (File.Error) could not set current working directory to \"non_existing_dir\": no such file or directory\n \"\"\"\n @spec cd!(Path.t(), (-> res)) :: res when res: var\n def cd!(path, function) do\n old = cwd!()\n cd!(path)\n\n try do\n function.()\n after\n cd!(old)\n end\n end\n\n @doc \"\"\"\n Returns the list of files in the given directory.\n\n Hidden files are not ignored and the results are *not* sorted.\n\n Since directories are considered files by the file system,\n they are also included in the returned value.\n\n Returns `{:ok, files}` in case of success,\n `{:error, reason}` otherwise.\n\n ## Examples\n\n File.ls(\"bin\")\n #=> {:ok, [\"iex\", \"elixir\"]}\n\n File.ls(\"non_existing_dir\")\n #=> {:error, :enoent}\n \"\"\"\n @spec ls(Path.t()) :: {:ok, [binary]} | {:error, posix | :badarg | {:no_translation, binary}}\n def ls(path \\\\ \".\") do\n case :file.list_dir(IO.chardata_to_string(path)) do\n {:ok, file_list} -> {:ok, Enum.map(file_list, &IO.chardata_to_string/1)}\n {:error, _} = error -> error\n end\n end\n\n @doc \"\"\"\n The same as `ls/1` but raises a `File.Error` exception in case of an error.\n\n ## Examples\n\n File.ls!(\"bin\")\n #=> [\"iex\", \"elixir\"]\n\n File.ls!(\"non_existing_dir\")\n ** (File.Error) could not list directory \"non_existing_dir\": no such file or directory\n \"\"\"\n @spec ls!(Path.t()) :: [binary]\n def ls!(path \\\\ \".\") do\n case ls(path) do\n {:ok, value} ->\n value\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"list directory\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Closes the file referenced by `io_device`. It mostly returns `:ok`, except\n for some severe errors such as out of memory.\n\n Note that if the option `:delayed_write` was used when opening the file,\n `close/1` might return an old write error and not even try to close the file.\n See `open/2` for more information.\n\n ## Examples\n\n {:ok, file} = File.open(\"hello.txt\")\n File.close(file)\n #=> :ok\n\n File.close(:not_an_io_device)\n #=> {:error, :badarg}\n \"\"\"\n @spec close(io_device) :: :ok | {:error, posix | :badarg | :terminated}\n def close(io_device) do\n :file.close(io_device)\n end\n\n @doc \"\"\"\n Shortcut for `File.stream!/3`.\n \"\"\"\n @spec stream!(Path.t(), :line | pos_integer | [stream_mode]) :: File.Stream.t()\n def stream!(path, line_or_bytes_modes \\\\ [])\n\n def stream!(path, modes) when is_list(modes),\n do: stream!(path, :line, modes)\n\n def stream!(path, line_or_bytes) when is_integer(line_or_bytes) or line_or_bytes == :line,\n do: stream!(path, line_or_bytes, [])\n\n @doc ~S\"\"\"\n Returns a `File.Stream` for the given `path` with the given `modes`.\n\n The stream implements both `Enumerable` and `Collectable` protocols,\n which means it can be used both for read and write.\n\n The `line_or_bytes` argument configures how the file is read when\n streaming, by `:line` (default) or by a given number of bytes. When\n using the `:line` option, CRLF line breaks (`\"\\r\\n\"`) are normalized\n to LF (`\"\\n\"`).\n\n Similar to other file operations, a stream can be created in one node\n and forwarded to another node. Once the stream is opened in another node,\n a request will be sent to the creator node to spawn a process for file\n streaming.\n\n Operating the stream can fail on open for the same reasons as\n `File.open!/2`. Note that the file is automatically opened each time streaming\n begins. There is no need to pass `:read` and `:write` modes, as those are\n automatically set by Elixir.\n\n ## Raw files\n\n Since Elixir controls when the streamed file is opened, the underlying\n device cannot be shared and as such it is convenient to open the file\n in raw mode for performance reasons. Therefore, Elixir **will** open\n streams in `:raw` mode with the `:read_ahead` option if the stream is\n open in the same node as it is created and no encoding has been specified.\n This means any data streamed into the file must be converted to `t:iodata/0`\n type. If you pass, for example, `[encoding: :utf8]` or\n `[encoding: {:utf16, :little}]` in the modes parameter, the underlying stream\n will use `IO.write/2` and the `String.Chars` protocol to convert the data.\n See `IO.binwrite/2` and `IO.write/2` .\n\n One may also consider passing the `:delayed_write` option if the stream\n is meant to be written to under a tight loop.\n\n ## Byte order marks and read offset\n\n If you pass `:trim_bom` in the modes parameter, the stream will\n trim UTF-8, UTF-16 and UTF-32 byte order marks when reading from file.\n\n Note that this function does not try to discover the file encoding\n based on BOM. From Elixir v1.16.0, you may also pass a `:read_offset`\n that is skipped whenever enumerating the stream (if both `:read_offset`\n and `:trim_bom` are given, the offset is skipped after the BOM).\n\n See `Stream.run/1` for an example of streaming into a file.\n\n ## Examples\n\n # Read a utf8 text file which may include BOM\n File.stream!(\"./test/test.txt\", [:trim_bom, encoding: :utf8])\n #=> %File.Stream{path: \"./test/test.txt\", ...}\n\n # Read in 2048 byte chunks rather than lines\n File.stream!(\"./test/test.data\", 2048)\n #=> %File.Stream{path: \"./test/test.data\", ...}\n \"\"\"\n @spec stream!(Path.t(), :line | pos_integer, [stream_mode]) :: File.Stream.t()\n def stream!(path, line_or_bytes, modes)\n\n def stream!(path, modes, line_or_bytes) when is_list(modes) do\n # TODO: Remove me on Elixir 2.0\n IO.warn(\n \"File.stream!(path, modes, line_or_byte) is deprecated, \" <>\n \"invoke File.stream!(path, line_or_bytes, modes) instead\"\n )\n\n stream!(path, line_or_bytes, modes)\n end\n\n def stream!(path, line_or_bytes, modes) do\n modes = normalize_modes(modes, true)\n File.Stream.__build__(IO.chardata_to_string(path), line_or_bytes, modes)\n end\n\n @doc \"\"\"\n Changes the `mode` for a given `file`.\n\n Returns `:ok` on success, or `{:error, reason}` on failure.\n\n ## Permissions\n\n File permissions are specified by adding together the following octal modes:\n\n * `0o400` - read permission: owner\n * `0o200` - write permission: owner\n * `0o100` - execute permission: owner\n\n * `0o040` - read permission: group\n * `0o020` - write permission: group\n * `0o010` - execute permission: group\n\n * `0o004` - read permission: other\n * `0o002` - write permission: other\n * `0o001` - execute permission: other\n\n For example, setting the mode `0o755` gives it\n write, read and execute permission to the owner\n and both read and execute permission to group\n and others.\n\n ## Examples\n\n File.chmod(\"hello.txt\", 0o755)\n #=> :ok\n\n File.chmod(\"non_existing.txt\", 0o755)\n #=> {:error, :enoent}\n \"\"\"\n @spec chmod(Path.t(), non_neg_integer) :: :ok | {:error, posix | :badarg}\n def chmod(path, mode) do\n :file.change_mode(IO.chardata_to_string(path), mode)\n end\n\n @doc \"\"\"\n Same as `chmod/2`, but raises a `File.Error` exception in case of failure.\n Otherwise `:ok`.\n\n ## Examples\n\n File.chmod!(\"hello.txt\", 0o755)\n #=> :ok\n\n File.chmod!(\"non_existing.txt\", 0o755)\n ** (File.Error) could not change mode for \"non_existing.txt\": no such file or directory\n \"\"\"\n @spec chmod!(Path.t(), non_neg_integer) :: :ok\n def chmod!(path, mode) do\n case chmod(path, mode) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"change mode for\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Changes the group given by the group ID `gid`\n for a given `file`. Returns `:ok` on success, or\n `{:error, reason}` on failure.\n\n ## Examples\n\n File.chgrp(\"hello.txt\", 10)\n #=> :ok\n\n File.chgrp(\"non_existing.txt\", 10)\n #=> {:error, :enoent}\n \"\"\"\n @spec chgrp(Path.t(), non_neg_integer) :: :ok | {:error, posix | :badarg}\n def chgrp(path, gid) do\n :file.change_group(IO.chardata_to_string(path), gid)\n end\n\n @doc \"\"\"\n Same as `chgrp/2`, but raises a `File.Error` exception in case of failure.\n Otherwise `:ok`.\n\n ## Examples\n\n File.chgrp!(\"hello.txt\", 10)\n #=> :ok\n\n File.chgrp!(\"non_existing.txt\", 10)\n ** (File.Error) could not change group for \"non_existing.txt\": no such file or directory\n \"\"\"\n @spec chgrp!(Path.t(), non_neg_integer) :: :ok\n def chgrp!(path, gid) do\n case chgrp(path, gid) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"change group for\",\n path: IO.chardata_to_string(path)\n end\n end\n\n @doc \"\"\"\n Changes the owner given by the user ID `uid`\n for a given `file`. Returns `:ok` on success,\n or `{:error, reason}` on failure.\n\n ## Examples\n\n File.chown(\"hello.txt\", 15)\n #=> :ok\n\n File.chown(\"secret.txt\", 15)\n #=> {:error, :eperm}\n \"\"\"\n @spec chown(Path.t(), non_neg_integer) :: :ok | {:error, posix | :badarg}\n def chown(path, uid) do\n :file.change_owner(IO.chardata_to_string(path), uid)\n end\n\n @doc \"\"\"\n Same as `chown/2`, but raises a `File.Error` exception in case of failure.\n Otherwise `:ok`.\n\n ## Examples\n\n File.chown!(\"hello.txt\", 15)\n #=> :ok\n\n File.chown!(\"secret.txt\", 15)\n ** (File.Error) could not change owner for \"secret.txt\": not owner\n \"\"\"\n @spec chown!(Path.t(), non_neg_integer) :: :ok\n def chown!(path, uid) do\n case chown(path, uid) do\n :ok ->\n :ok\n\n {:error, reason} ->\n raise File.Error,\n reason: reason,\n action: \"change owner for\",\n path: IO.chardata_to_string(path)\n end\n end\n\n ## Helpers\n\n @read_ahead_size 64 * 1024\n\n defp assert_no_null_byte!(binary, operation) do\n case :binary.match(binary, \"\\0\") do\n {_, _} ->\n raise ArgumentError,\n \"cannot execute #{operation} for path with null byte, got: #{inspect(binary)}\"\n\n :nomatch ->\n binary\n end\n end\n\n defp normalize_modes([:utf8 | rest], binary?) do\n [encoding: :utf8] ++ normalize_modes(rest, binary?)\n end\n\n defp normalize_modes([:read_ahead | rest], binary?) do\n [read_ahead: @read_ahead_size] ++ normalize_modes(rest, binary?)\n end\n\n # TODO: Remove :char_list mode on v2.0\n defp normalize_modes([mode | rest], _binary?) when mode in [:charlist, :char_list] do\n if mode == :char_list do\n IO.warn(\"the :char_list mode is deprecated, use :charlist\")\n end\n\n normalize_modes(rest, false)\n end\n\n defp normalize_modes([mode | rest], binary?) do\n [mode | normalize_modes(rest, binary?)]\n end\n\n defp normalize_modes([], true), do: [:binary]\n defp normalize_modes([], false), do: []\n\n defp normalize_path_or_io_device(path) when is_list(path), do: IO.chardata_to_string(path)\n defp normalize_path_or_io_device(path) when is_binary(path), do: path\n defp normalize_path_or_io_device(io_device) when is_pid(io_device), do: io_device\n defp normalize_path_or_io_device(io_device = {:file_descriptor, _, _}), do: io_device\nend\n" }, { "path": "lib/elixir/lib/float.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nimport Kernel, except: [round: 1]\n\ndefmodule Float do\n @moduledoc \"\"\"\n Functions for working with floating-point numbers.\n\n For mathematical operations on top of floating-points,\n see Erlang's [`:math`](`:math`) module.\n\n ## Kernel functions\n\n There are functions related to floating-point numbers on the `Kernel` module\n too. Here is a list of them:\n\n * `Kernel.round/1`: rounds a number to the nearest integer.\n * `Kernel.trunc/1`: returns the integer part of a number.\n\n ## Known issues\n\n There are some very well known problems with floating-point numbers\n and arithmetic due to the fact most decimal fractions cannot be\n represented by a floating-point binary and most operations are not exact,\n but operate on approximations. Those issues are not specific\n to Elixir, they are a property of floating point representation itself.\n\n For example, the numbers 0.1 and 0.01 are two of them, what means the result\n of squaring 0.1 does not give 0.01 neither the closest representable. Here is\n what happens in this case:\n\n * The closest representable number to 0.1 is 0.1000000014\n * The closest representable number to 0.01 is 0.0099999997\n * Doing 0.1 * 0.1 should return 0.01, but because 0.1 is actually 0.1000000014,\n the result is 0.010000000000000002, and because this is not the closest\n representable number to 0.01, you'll get the wrong result for this operation\n\n There are also other known problems like flooring or rounding numbers. See\n `round/2` and `floor/2` for more details about them.\n\n To learn more about floating-point arithmetic visit:\n\n * [0.30000000000000004.com](https://0.30000000000000004.com/)\n * [What Every Programmer Should Know About Floating-Point Arithmetic](https://floating-point-gui.de/)\n\n \"\"\"\n\n import Bitwise\n\n @power_of_2_to_52 4_503_599_627_370_496\n @precision_range 0..15\n @type precision_range :: 0..15\n\n @min_finite then(<<0xFFEFFFFFFFFFFFFF::64>>, fn <> -> num end)\n @max_finite then(<<0x7FEFFFFFFFFFFFFF::64>>, fn <> -> num end)\n\n @doc \"\"\"\n Returns the maximum finite value for a float.\n\n ## Examples\n\n iex> Float.max_finite()\n 1.7976931348623157e308\n\n \"\"\"\n @spec max_finite() :: float\n def max_finite, do: @max_finite\n\n @doc \"\"\"\n Returns the minimum finite value for a float.\n\n ## Examples\n\n iex> Float.min_finite()\n -1.7976931348623157e308\n\n \"\"\"\n @spec min_finite() :: float\n def min_finite, do: @min_finite\n\n @doc \"\"\"\n Computes `base` raised to power of `exponent`.\n\n `base` must be a float and `exponent` can be any number.\n However, if a negative base and a fractional exponent\n are given, it raises `ArithmeticError`.\n\n It always returns a float. See `Integer.pow/2` for\n exponentiation that returns integers.\n\n ## Examples\n\n iex> Float.pow(2.0, 0)\n 1.0\n iex> Float.pow(2.0, 1)\n 2.0\n iex> Float.pow(2.0, 10)\n 1024.0\n iex> Float.pow(2.0, -1)\n 0.5\n iex> Float.pow(2.0, -3)\n 0.125\n\n iex> Float.pow(3.0, 1.5)\n 5.196152422706632\n\n iex> Float.pow(-2.0, 3)\n -8.0\n iex> Float.pow(-2.0, 4)\n 16.0\n\n iex> Float.pow(-1.0, 0.5)\n ** (ArithmeticError) bad argument in arithmetic expression\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec pow(float, number) :: float\n def pow(base, exponent) when is_float(base) and is_number(exponent),\n do: :math.pow(base, exponent)\n\n @doc \"\"\"\n Parses a binary into a float.\n\n If successful, returns a tuple in the form of `{float, remainder_of_binary}`;\n when the binary cannot be coerced into a valid float, the atom `:error` is\n returned.\n\n If the size of float exceeds the maximum size of `1.7976931348623157e+308`,\n `:error` is returned even though the textual representation itself might be\n well formed.\n\n If you want to convert a string-formatted float directly to a float,\n `String.to_float/1` can be used instead.\n\n ## Examples\n\n iex> Float.parse(\"34\")\n {34.0, \"\"}\n iex> Float.parse(\"34.25\")\n {34.25, \"\"}\n iex> Float.parse(\"56.5xyz\")\n {56.5, \"xyz\"}\n\n iex> Float.parse(\".12\")\n :error\n iex> Float.parse(\"pi\")\n :error\n iex> Float.parse(\"1.7976931348623159e+308\")\n :error\n\n \"\"\"\n @spec parse(binary) :: {float, binary} | :error\n def parse(\"-\" <> binary) do\n case parse_unsigned(binary) do\n :error -> :error\n {number, remainder} -> {-number, remainder}\n end\n end\n\n def parse(\"+\" <> binary) do\n parse_unsigned(binary)\n end\n\n def parse(binary) do\n parse_unsigned(binary)\n end\n\n defp parse_unsigned(<>) when digit in ?0..?9,\n do: parse_unsigned(rest, false, false, [digit])\n\n defp parse_unsigned(binary) when is_binary(binary), do: :error\n\n defp parse_unsigned(<>, dot?, e?, acc) when digit in ?0..?9,\n do: parse_unsigned(rest, dot?, e?, [digit | acc])\n\n defp parse_unsigned(<>, false, false, acc) when digit in ?0..?9,\n do: parse_unsigned(rest, true, false, [digit, ?. | acc])\n\n defp parse_unsigned(<>, dot?, false, acc)\n when exp_marker in ~c\"eE\" and digit in ?0..?9,\n do: parse_unsigned(rest, true, true, [digit, ?e | add_dot(acc, dot?)])\n\n defp parse_unsigned(<>, dot?, false, acc)\n when exp_marker in ~c\"eE\" and sign in ~c\"-+\" and digit in ?0..?9,\n do: parse_unsigned(rest, true, true, [digit, sign, ?e | add_dot(acc, dot?)])\n\n # :erlang.binary_to_float/1 can raise an ArgumentError if the e exponent is too big. For example,\n # \"1.0e400\". Because of this, we rescue the ArgumentError here and return an error.\n defp parse_unsigned(rest, dot?, _, acc) do\n acc\n |> add_dot(dot?)\n |> :lists.reverse()\n |> :erlang.list_to_float()\n rescue\n ArgumentError -> :error\n else\n float -> {float, rest}\n end\n\n defp add_dot(acc, true), do: acc\n defp add_dot(acc, false), do: [?0, ?. | acc]\n\n @doc \"\"\"\n Rounds a float to the largest float less than or equal to `number`.\n\n `floor/2` also accepts a precision to round a floating-point value down\n to an arbitrary number of fractional digits (between 0 and 15).\n The operation is performed on the binary floating point, without a\n conversion to decimal.\n\n This function always returns a float. `Kernel.trunc/1` may be used instead to\n truncate the result to an integer afterwards.\n\n ## Known issues\n\n The behavior of `floor/2` for floats can be surprising. For example:\n\n iex> Float.floor(12.52, 2)\n 12.51\n\n One may have expected it to floor to 12.52. This is not a bug.\n Most decimal fractions cannot be represented as a binary floating point\n and therefore the number above is internally represented as 12.51999999,\n which explains the behavior above.\n\n ## Examples\n\n iex> Float.floor(34.25)\n 34.0\n iex> Float.floor(-56.5)\n -57.0\n iex> Float.floor(34.259, 2)\n 34.25\n\n \"\"\"\n @spec floor(float, precision_range) :: float\n def floor(number, precision \\\\ 0)\n\n def floor(number, 0) when is_float(number) do\n :math.floor(number)\n end\n\n def floor(number, precision) when is_float(number) and precision in @precision_range do\n round(number, precision, :floor)\n end\n\n def floor(number, precision) when is_float(number) do\n raise ArgumentError, invalid_precision_message(precision)\n end\n\n @doc \"\"\"\n Rounds a float to the smallest float greater than or equal to `number`.\n\n `ceil/2` also accepts a precision to round a floating-point value down\n to an arbitrary number of fractional digits (between 0 and 15).\n\n The operation is performed on the binary floating point, without a\n conversion to decimal.\n\n The behavior of `ceil/2` for floats can be surprising. For example:\n\n iex> Float.ceil(-12.52, 2)\n -12.51\n\n One may have expected it to ceil to -12.52. This is not a bug.\n Most decimal fractions cannot be represented as a binary floating point\n and therefore the number above is internally represented as -12.51999999,\n which explains the behavior above.\n\n This function always returns floats. `Kernel.trunc/1` may be used instead to\n truncate the result to an integer afterwards.\n\n ## Examples\n\n iex> Float.ceil(34.25)\n 35.0\n iex> Float.ceil(-56.5)\n -56.0\n iex> Float.ceil(34.251, 2)\n 34.26\n iex> Float.ceil(-0.01)\n -0.0\n\n \"\"\"\n @spec ceil(float, precision_range) :: float\n def ceil(number, precision \\\\ 0)\n\n def ceil(number, 0) when is_float(number) do\n :math.ceil(number)\n end\n\n def ceil(number, precision) when is_float(number) and precision in @precision_range do\n round(number, precision, :ceil)\n end\n\n def ceil(number, precision) when is_float(number) do\n raise ArgumentError, invalid_precision_message(precision)\n end\n\n @doc \"\"\"\n Rounds a floating-point value to an arbitrary number of fractional\n digits (between 0 and 15).\n\n The rounding direction always ties to half up. The operation is\n performed on the binary floating point, without a conversion to decimal.\n\n This function only accepts floats and always returns a float. Use\n `Kernel.round/1` if you want a function that accepts both floats\n and integers and always returns an integer.\n\n ## Known issues\n\n The behavior of `round/2` for floats can be surprising. For example:\n\n iex> Float.round(5.5675, 3)\n 5.567\n\n One may have expected it to round to the half up 5.568. This is not a bug.\n Most decimal fractions cannot be represented as a binary floating point\n and therefore the number above is internally represented as 5.567499999,\n which explains the behavior above. If you want exact rounding for decimals,\n you must use a decimal library. The behavior above is also in accordance\n to reference implementations, such as \"Correctly Rounded Binary-Decimal and\n Decimal-Binary Conversions\" by David M. Gay.\n\n ## Examples\n\n iex> Float.round(12.5)\n 13.0\n iex> Float.round(5.5674, 3)\n 5.567\n iex> Float.round(5.5675, 3)\n 5.567\n iex> Float.round(-5.5674, 3)\n -5.567\n iex> Float.round(-5.5675)\n -6.0\n iex> Float.round(12.341444444444441, 15)\n 12.341444444444441\n iex> Float.round(-0.01)\n -0.0\n\n \"\"\"\n @spec round(float, precision_range) :: float\n # This implementation is slow since it relies on big integers.\n # Faster implementations are available on more recent papers\n # and could be implemented in the future.\n def round(float, precision \\\\ 0)\n\n def round(float, 0) when float == 0.0, do: float\n\n def round(float, 0) when is_float(float) do\n case float |> :erlang.round() |> :erlang.float() do\n zero when zero == 0.0 and float < 0.0 -> -0.0\n rounded -> rounded\n end\n end\n\n def round(float, precision) when is_float(float) and precision in @precision_range do\n round(float, precision, :half_up)\n end\n\n def round(float, precision) when is_float(float) do\n raise ArgumentError, invalid_precision_message(precision)\n end\n\n defp round(num, _precision, _rounding) when is_float(num) and num == 0.0, do: num\n\n defp round(float, precision, rounding) do\n <> = <>\n {num, count} = decompose(significant, 1)\n count = count - exp + 1023\n\n cond do\n # Precision beyond 15 digits\n count >= 104 ->\n case rounding do\n :ceil when sign === 0 -> 1 / power_of_10(precision)\n :floor when sign === 1 -> -1 / power_of_10(precision)\n :ceil when sign === 1 -> -0.0\n :half_up when sign === 1 -> -0.0\n _ -> 0.0\n end\n\n # We are asking more precision than we have\n count <= precision ->\n float\n\n true ->\n # Difference in precision between float and asked precision\n # We subtract 1 because we need to calculate the remainder too\n diff = count - precision - 1\n\n # Get up to latest so we calculate the remainder\n power_of_10 = power_of_10(diff)\n\n # Convert the numerand to decimal base\n num = num * power_of_5(count)\n\n # Move to the given precision - 1\n num = div(num, power_of_10)\n div = div(num, 10)\n num = rounding(rounding, sign, num, div)\n\n # Convert back to float without loss\n # https://www.exploringbinary.com/correct-decimal-to-floating-point-using-big-integers/\n den = power_of_10(precision)\n boundary = den <<< 52\n\n cond do\n num == 0 and sign == 1 ->\n -0.0\n\n num == 0 ->\n 0.0\n\n num >= boundary ->\n {den, exp} = scale_down(num, boundary, 52)\n decimal_to_float(sign, num, den, exp)\n\n true ->\n {num, exp} = scale_up(num, boundary, 52)\n decimal_to_float(sign, num, den, exp)\n end\n end\n end\n\n defp decompose(significant, initial) do\n decompose(significant, 1, 0, initial)\n end\n\n defp decompose(<<1::1, bits::bitstring>>, count, last_count, acc) do\n decompose(bits, count + 1, count, (acc <<< (count - last_count)) + 1)\n end\n\n defp decompose(<<0::1, bits::bitstring>>, count, last_count, acc) do\n decompose(bits, count + 1, last_count, acc)\n end\n\n defp decompose(<<>>, _count, last_count, acc) do\n {acc, last_count}\n end\n\n defp scale_up(num, boundary, exp) when num >= boundary, do: {num, exp}\n defp scale_up(num, boundary, exp), do: scale_up(num <<< 1, boundary, exp - 1)\n\n defp scale_down(num, den, exp) do\n new_den = den <<< 1\n\n if num < new_den do\n {den >>> 52, exp}\n else\n scale_down(num, new_den, exp + 1)\n end\n end\n\n defp decimal_to_float(sign, num, den, exp) do\n quo = div(num, den)\n rem = num - quo * den\n\n tmp =\n case den >>> 1 do\n den when rem > den -> quo + 1\n den when rem < den -> quo\n _ when (quo &&& 1) === 1 -> quo + 1\n _ -> quo\n end\n\n tmp = tmp - @power_of_2_to_52\n <> = <>\n tmp\n end\n\n defp rounding(:floor, 1, _num, div), do: div + 1\n defp rounding(:ceil, 0, _num, div), do: div + 1\n\n defp rounding(:half_up, _sign, num, div) do\n case rem(num, 10) do\n rem when rem < 5 -> div\n rem when rem >= 5 -> div + 1\n end\n end\n\n defp rounding(_, _, _, div), do: div\n\n Enum.reduce(0..104, 1, fn x, acc ->\n defp power_of_10(unquote(x)), do: unquote(acc)\n acc * 10\n end)\n\n Enum.reduce(0..104, 1, fn x, acc ->\n defp power_of_5(unquote(x)), do: unquote(acc)\n acc * 5\n end)\n\n @doc \"\"\"\n Returns a pair of integers whose ratio is exactly equal\n to the original float and with a positive denominator.\n\n ## Examples\n\n iex> Float.ratio(0.0)\n {0, 1}\n iex> Float.ratio(3.14)\n {7070651414971679, 2251799813685248}\n iex> Float.ratio(-3.14)\n {-7070651414971679, 2251799813685248}\n iex> Float.ratio(1.5)\n {3, 2}\n iex> Float.ratio(-1.5)\n {-3, 2}\n iex> Float.ratio(16.0)\n {16, 1}\n iex> Float.ratio(-16.0)\n {-16, 1}\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec ratio(float) :: {integer, pos_integer}\n def ratio(float) when is_float(float) and float == 0.0, do: {0, 1}\n\n def ratio(float) when is_float(float) do\n <> = <>\n\n {num, den_exp} =\n if exp != 0 do\n # Floats are expressed like this:\n # (2**52 + mantissa) * 2**(-52 + exp - 1023)\n #\n # We compute the root factors of the mantissa so we have this:\n # (2**52 + mantissa * 2**count) * 2**(-52 + exp - 1023)\n {mantissa, count} = root_factors(mantissa, 0)\n\n # Now we can move the count around so we have this:\n # (2**(52-count) + mantissa) * 2**(count + -52 + exp - 1023)\n if mantissa == 0 do\n {1, exp - 1023}\n else\n num = (1 <<< (52 - count)) + mantissa\n den_exp = count - 52 + exp - 1023\n {num, den_exp}\n end\n else\n # Subnormals are expressed like this:\n # (mantissa) * 2**(-52 + 1 - 1023)\n #\n # So we compute it to this:\n # (mantissa * 2**(count)) * 2**(-52 + 1 - 1023)\n #\n # Which becomes:\n # mantissa * 2**(count-1074)\n root_factors(mantissa, -1074)\n end\n\n if den_exp > 0 do\n {sign(sign, num <<< den_exp), 1}\n else\n {sign(sign, num), 1 <<< -den_exp}\n end\n end\n\n defp root_factors(mantissa, count) when mantissa != 0 and (mantissa &&& 1) == 0,\n do: root_factors(mantissa >>> 1, count + 1)\n\n defp root_factors(mantissa, count),\n do: {mantissa, count}\n\n @compile {:inline, sign: 2}\n defp sign(0, num), do: num\n defp sign(1, num), do: -num\n\n @doc \"\"\"\n Returns a charlist which corresponds to the shortest text representation\n of the given float.\n\n It uses the algorithm presented in \"Ryū: fast float-to-string conversion\"\n in Proceedings of the SIGPLAN '2018 Conference on Programming Language\n Design and Implementation.\n\n For a configurable representation, use `:erlang.float_to_list/2`.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Float.to_charlist(7.0)\n ~c\"7.0\"\n\n \"\"\"\n @spec to_charlist(float) :: charlist\n def to_charlist(float) do\n :erlang.float_to_list(float, [:short])\n end\n\n @doc \"\"\"\n Returns a binary which corresponds to the shortest text representation\n of the given float.\n\n The underlying algorithm changes depending on the Erlang/OTP version:\n\n * For OTP >= 24, it uses the algorithm presented in \"Ryū: fast\n float-to-string conversion\" in Proceedings of the SIGPLAN '2018\n Conference on Programming Language Design and Implementation.\n\n * For OTP < 24, it uses the algorithm presented in \"Printing Floating-Point\n Numbers Quickly and Accurately\" in Proceedings of the SIGPLAN '1996\n Conference on Programming Language Design and Implementation.\n\n For a configurable representation, use `:erlang.float_to_binary/2`.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Float.to_string(7.0)\n \"7.0\"\n\n \"\"\"\n @spec to_string(float) :: String.t()\n def to_string(float) do\n :erlang.float_to_binary(float, [:short])\n end\n\n @doc false\n @deprecated \"Use Float.to_charlist/1 instead\"\n def to_char_list(float), do: Float.to_charlist(float)\n\n @doc false\n @deprecated \"Use :erlang.float_to_list/2 instead\"\n def to_char_list(float, options) do\n :erlang.float_to_list(float, expand_compact(options))\n end\n\n @doc false\n @deprecated \"Use :erlang.float_to_binary/2 instead\"\n def to_string(float, options) do\n :erlang.float_to_binary(float, expand_compact(options))\n end\n\n defp invalid_precision_message(precision) do\n \"precision #{precision} is out of valid range of #{inspect(@precision_range)}\"\n end\n\n defp expand_compact([{:compact, false} | t]), do: expand_compact(t)\n defp expand_compact([{:compact, true} | t]), do: [:compact | expand_compact(t)]\n defp expand_compact([h | t]), do: [h | expand_compact(t)]\n defp expand_compact([]), do: []\nend\n" }, { "path": "lib/elixir/lib/function.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Function do\n @moduledoc \"\"\"\n A set of functions for working with functions.\n\n Anonymous functions are typically created by using `fn`:\n\n iex> add = fn a, b -> a + b end\n iex> add.(1, 2)\n 3\n\n Anonymous functions can also have multiple clauses. All clauses\n should expect the same number of arguments:\n\n iex> negate = fn\n ...> true -> false\n ...> false -> true\n ...> end\n iex> negate.(false)\n true\n\n ## The capture operator\n\n It is also possible to capture public module functions and pass them\n around as if they were anonymous functions by using the capture\n operator `&/1`:\n\n iex> add = &Kernel.+/2\n iex> add.(1, 2)\n 3\n\n iex> length = &String.length/1\n iex> length.(\"hello\")\n 5\n\n To capture a definition within the current module, you can skip the\n module prefix, such as `&my_fun/2`. In those cases, the captured\n function can be public (`def`) or private (`defp`).\n\n The capture operator can also be used to create anonymous functions\n that expect at least one argument:\n\n iex> add = &(&1 + &2)\n iex> add.(1, 2)\n 3\n\n In such cases, using the capture operator is no different than using `fn`.\n\n ## Internal and external functions\n\n We say that functions that point to definitions residing in modules, such\n as `&String.length/1`, are **external** functions. All other functions are\n **local** and they are always bound to the file or module that defined them.\n\n Besides the functions in this module to work with functions, `Kernel` also\n has an `apply/2` function that invokes a function with a dynamic number of\n arguments, as well as `is_function/1` and `is_function/2`, to check\n respectively if a given value is a function or a function of a given arity.\n \"\"\"\n\n @type information ::\n :arity\n | :env\n | :index\n | :module\n | :name\n | :new_index\n | :new_uniq\n | :pid\n | :type\n | :uniq\n\n @doc \"\"\"\n Captures the given function.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Function.capture(String, :length, 1)\n &String.length/1\n\n \"\"\"\n @doc since: \"1.7.0\"\n @spec capture(module, atom, arity) :: fun\n def capture(module, function_name, arity) do\n :erlang.make_fun(module, function_name, arity)\n end\n\n @doc \"\"\"\n Returns a keyword list with information about a function.\n\n The returned keys (with the corresponding possible values) for\n all types of functions (local and external) are the following:\n\n * `:type` - `:local` (for anonymous functions) or `:external` (for\n named functions).\n\n * `:module` - an atom which is the module where the function is defined when\n anonymous or the module which the function refers to when it's a named function.\n\n * `:arity` - (integer) the number of arguments the function is to be called with.\n\n * `:name` - (atom) the name of the function.\n\n * `:env` - a list of the environment or free variables. For named\n functions, the returned list is always empty.\n\n When `fun` is an anonymous function (that is, the type is `:local`), the following\n additional keys are returned:\n\n * `:pid` - PID of the process that originally created the function.\n\n * `:index` - (integer) an index into the module function table.\n\n * `:new_index` - (integer) an index into the module function table.\n\n * `:new_uniq` - (binary) a unique value for this function. It's\n calculated from the compiled code for the entire module.\n\n * `:uniq` - (integer) a unique value for this function. This integer is\n calculated from the compiled code for the entire module.\n\n **Note**: this function must be used only for debugging purposes.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> fun = fn x -> x end\n iex> info = Function.info(fun)\n iex> Keyword.get(info, :arity)\n 1\n iex> Keyword.get(info, :type)\n :local\n\n iex> fun = &String.length/1\n iex> info = Function.info(fun)\n iex> Keyword.get(info, :type)\n :external\n iex> Keyword.get(info, :name)\n :length\n\n \"\"\"\n @doc since: \"1.7.0\"\n @spec info(fun) :: [{information, term}]\n def info(fun), do: :erlang.fun_info(fun)\n\n @doc \"\"\"\n Returns a specific information about the function.\n\n The returned information is a two-element tuple in the shape of\n `{info, value}`.\n\n For any function, the information asked for can be any of the atoms\n `:module`, `:name`, `:arity`, `:env`, or `:type`.\n\n For anonymous functions, there is also information about any of the\n atoms `:index`, `:new_index`, `:new_uniq`, `:uniq`, and `:pid`.\n For a named function, the value of any of these items is always the\n atom `:undefined`.\n\n For more information on each of the possible returned values, see\n `info/1`.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> f = fn x -> x end\n iex> Function.info(f, :arity)\n {:arity, 1}\n iex> Function.info(f, :type)\n {:type, :local}\n\n iex> fun = &String.length/1\n iex> Function.info(fun, :name)\n {:name, :length}\n iex> Function.info(fun, :pid)\n {:pid, :undefined}\n\n \"\"\"\n @doc since: \"1.7.0\"\n @spec info(fun, item) :: {item, term} when item: information\n def info(fun, item), do: :erlang.fun_info(fun, item)\n\n @doc \"\"\"\n Returns its input `value`. This function can be passed as an anonymous function\n to transformation functions.\n\n ## Examples\n\n iex> Function.identity(\"Hello world!\")\n \"Hello world!\"\n\n iex> ~c\"abcdaabccc\" |> Enum.sort() |> Enum.chunk_by(&Function.identity/1)\n [~c\"aaa\", ~c\"bb\", ~c\"cccc\", ~c\"d\"]\n\n iex> Enum.group_by(~c\"abracadabra\", &Function.identity/1)\n %{97 => ~c\"aaaaa\", 98 => ~c\"bb\", 99 => ~c\"c\", 100 => ~c\"d\", 114 => ~c\"rr\"}\n\n iex> Enum.map([1, 2, 3, 4], &Function.identity/1)\n [1, 2, 3, 4]\n\n \"\"\"\n @doc since: \"1.10.0\"\n @spec identity(value) :: value when value: var\n def identity(value), do: value\nend\n" }, { "path": "lib/elixir/lib/gen_event/stream.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule GenEvent.Stream do\n @moduledoc false\n @moduledoc deprecated: \"This functionality is no longer supported\"\n defstruct manager: nil, timeout: :infinity\n\n @type t :: %__MODULE__{manager: GenEvent.manager(), timeout: timeout}\n\n @doc false\n def init({_pid, _ref} = state) do\n {:ok, state}\n end\n\n @doc false\n def handle_event(event, _state) do\n # We do this to trick Dialyzer to not complain about non-local returns.\n case :erlang.phash2(1, 1) do\n 0 -> exit({:bad_event, event})\n 1 -> :remove_handler\n end\n end\n\n @doc false\n def handle_call(msg, _state) do\n # We do this to trick Dialyzer to not complain about non-local returns.\n reason = {:bad_call, msg}\n\n case :erlang.phash2(1, 1) do\n 0 -> exit(reason)\n 1 -> {:remove_handler, reason}\n end\n end\n\n @doc false\n def handle_info(_msg, state) do\n {:ok, state}\n end\n\n @doc false\n def terminate(_reason, _state) do\n :ok\n end\n\n @doc false\n def code_change(_old, state, _extra) do\n {:ok, state}\n end\nend\n\ndefimpl Enumerable, for: GenEvent.Stream do\n @moduledoc false\n @moduledoc deprecated: \"This functionality is no longer supported\"\n\n def reduce(stream, acc, fun) do\n start_fun = fn -> start(stream) end\n next_fun = &next(stream, &1)\n stop_fun = &stop(stream, &1)\n Stream.resource(start_fun, next_fun, stop_fun).(acc, wrap_reducer(fun))\n end\n\n def count(_stream) do\n {:error, __MODULE__}\n end\n\n def member?(_stream, _item) do\n {:error, __MODULE__}\n end\n\n def slice(_stream) do\n {:error, __MODULE__}\n end\n\n defp wrap_reducer(fun) do\n fn\n {:ack, manager, ref, event}, acc ->\n send(manager, {ref, :ok})\n fun.(event, acc)\n\n {:async, _manager, _ref, event}, acc ->\n fun.(event, acc)\n\n {:sync, manager, ref, event}, acc ->\n try do\n fun.(event, acc)\n after\n send(manager, {ref, :ok})\n end\n end\n end\n\n defp start(%{manager: manager} = stream) do\n try do\n {:ok, {pid, ref}} =\n :gen.call(manager, self(), {:add_process_handler, self(), self()}, :infinity)\n\n mon_ref = Process.monitor(pid)\n {pid, ref, mon_ref}\n catch\n :exit, reason -> exit({reason, {__MODULE__, :start, [stream]}})\n end\n end\n\n defp next(%{timeout: timeout} = stream, {pid, ref, mon_ref} = acc) do\n self = self()\n\n receive do\n # Got an async event.\n {_from, {^pid, ^ref}, {:notify, event}} ->\n {[{:async, pid, ref, event}], acc}\n\n # Got a sync event.\n {_from, {^pid, ^ref}, {:sync_notify, event}} ->\n {[{:sync, pid, ref, event}], acc}\n\n # Got an ack event.\n {_from, {^pid, ^ref}, {:ack_notify, event}} ->\n {[{:ack, pid, ref, event}], acc}\n\n # The handler was removed. Stop iteration, resolve the\n # event later. We need to demonitor now, otherwise DOWN\n # appears with higher priority in the shutdown process.\n {:gen_event_EXIT, {^pid, ^ref}, _reason} = event ->\n Process.demonitor(mon_ref, [:flush])\n send(self, event)\n {:halt, {:removed, acc}}\n\n # The manager died. Stop iteration, resolve the event later.\n {:DOWN, ^mon_ref, _, _, _} = event ->\n send(self, event)\n {:halt, {:removed, acc}}\n after\n timeout ->\n exit({:timeout, {__MODULE__, :next, [stream, acc]}})\n end\n end\n\n # If we reach this branch, we know the handler was already\n # removed, so we don't trigger a request for doing so.\n defp stop(stream, {:removed, {pid, ref, mon_ref} = acc}) do\n case wait_for_handler_removal(pid, ref, mon_ref) do\n :ok ->\n flush_events(ref)\n\n {:error, reason} ->\n exit({reason, {__MODULE__, :stop, [stream, acc]}})\n end\n end\n\n # If we reach this branch, the handler was not removed yet,\n # so we trigger a request for doing so.\n defp stop(stream, {pid, ref, _} = acc) do\n _ = :gen_event.delete_handler(pid, {pid, ref}, :shutdown)\n stop(stream, {:removed, acc})\n end\n\n defp wait_for_handler_removal(pid, ref, mon_ref) do\n receive do\n {:gen_event_EXIT, {^pid, ^ref}, _reason} ->\n Process.demonitor(mon_ref, [:flush])\n :ok\n\n {:DOWN, ^mon_ref, _, _, reason} ->\n {:error, reason}\n end\n end\n\n defp flush_events(ref) do\n receive do\n {_from, {_pid, ^ref}, {notify, _event}}\n when notify in [:notify, :ack_notify, :sync_notify] ->\n flush_events(ref)\n after\n 0 -> :ok\n end\n end\nend\n" }, { "path": "lib/elixir/lib/gen_event.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule GenEvent do\n # Functions from this module are deprecated in elixir_dispatch.\n\n @moduledoc \"\"\"\n An event manager with event handlers behaviour.\n\n If you are interested in implementing an event manager, please read the\n \"Alternatives\" section below. If you have to implement an event handler to\n integrate with an existing system, such as Elixir's Logger, please use\n [`:gen_event`](`:gen_event`) instead.\n\n ## Alternatives\n\n There are a few suitable alternatives to replace GenEvent. Each of them can be\n the most beneficial based on the use case.\n\n ### Supervisor and GenServers\n\n One alternative to GenEvent is a very minimal solution consisting of using a\n supervisor and multiple GenServers started under it. The supervisor acts as\n the \"event manager\" and the children GenServers act as the \"event handlers\".\n This approach has some shortcomings (it provides no back-pressure for example)\n but can still replace GenEvent for low-profile usages of it. [This blog post\n by José\n Valim](https://dashbit.co/blog/replacing-genevent-by-a-supervisor-plus-genserver)\n has more detailed information on this approach.\n\n ### GenStage\n\n If the use case where you were using GenEvent requires more complex logic,\n [GenStage](https://github.com/elixir-lang/gen_stage) provides a great\n alternative. GenStage is an external Elixir library maintained by the Elixir\n team; it provides a tool to implement systems that exchange events in a\n demand-driven way with built-in support for back-pressure. See the [GenStage\n documentation](https://hexdocs.pm/gen_stage) for more information.\n\n ### `:gen_event`\n\n If your use case requires exactly what GenEvent provided, or you have to\n integrate with an existing `:gen_event`-based system, you can still use the\n [`:gen_event`](`:gen_event`) Erlang module.\n \"\"\"\n\n @moduledoc deprecated: \"Use Erlang/OTP's :gen_event module instead\"\n\n @callback init(args :: term) ::\n {:ok, state}\n | {:ok, state, :hibernate}\n | {:error, reason :: term}\n when state: term\n\n @callback handle_event(event :: term, state :: term) ::\n {:ok, new_state}\n | {:ok, new_state, :hibernate}\n | :remove_handler\n when new_state: term\n\n @callback handle_call(request :: term, state :: term) ::\n {:ok, reply, new_state}\n | {:ok, reply, new_state, :hibernate}\n | {:remove_handler, reply}\n when reply: term, new_state: term\n\n @callback handle_info(msg :: term, state :: term) ::\n {:ok, new_state}\n | {:ok, new_state, :hibernate}\n | :remove_handler\n when new_state: term\n\n @callback terminate(reason, state :: term) :: term\n when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term\n\n @callback code_change(old_vsn, state :: term, extra :: term) :: {:ok, new_state :: term}\n when old_vsn: term | {:down, term}\n\n @type on_start :: {:ok, pid} | {:error, {:already_started, pid}}\n\n @type name :: atom | {:global, term} | {:via, module, term}\n\n @type options :: [name: name]\n\n @type manager :: pid | name | {atom, node}\n\n @type handler :: atom | {atom, term}\n\n message = \"Use one of the alternatives described in the documentation for the GenEvent module\"\n\n @deprecated message\n @doc false\n defmacro __using__(_) do\n deprecation_message =\n \"the GenEvent module is deprecated, see its documentation for alternatives\"\n\n IO.warn(deprecation_message, __CALLER__)\n\n quote location: :keep do\n @behaviour :gen_event\n\n @doc false\n def init(args) do\n {:ok, args}\n end\n\n @doc false\n def handle_event(_event, state) do\n {:ok, state}\n end\n\n @doc false\n def handle_call(msg, state) do\n proc =\n case Process.info(self(), :registered_name) do\n {_, []} -> self()\n {_, name} -> name\n end\n\n # We do this to trick Dialyzer to not complain about non-local returns.\n case :erlang.phash2(1, 1) do\n 0 ->\n raise \"attempted to call GenEvent #{inspect(proc)} but no handle_call/2 clause was provided\"\n\n 1 ->\n {:remove_handler, {:bad_call, msg}}\n end\n end\n\n @doc false\n def handle_info(_msg, state) do\n {:ok, state}\n end\n\n @doc false\n def terminate(_reason, _state) do\n :ok\n end\n\n @doc false\n def code_change(_old, state, _extra) do\n {:ok, state}\n end\n\n defoverridable init: 1,\n handle_event: 2,\n handle_call: 2,\n handle_info: 2,\n terminate: 2,\n code_change: 3\n end\n end\n\n @doc false\n @deprecated message\n @spec start_link(options) :: on_start\n def start_link(options \\\\ []) when is_list(options) do\n do_start(:link, options)\n end\n\n @doc false\n @deprecated message\n @spec start(options) :: on_start\n def start(options \\\\ []) when is_list(options) do\n do_start(:nolink, options)\n end\n\n @no_callback :\"no callback module\"\n\n defp do_start(mode, options) do\n case Keyword.get(options, :name) do\n nil ->\n :gen.start(GenEvent, mode, @no_callback, [], [])\n\n atom when is_atom(atom) ->\n :gen.start(GenEvent, mode, {:local, atom}, @no_callback, [], [])\n\n {:global, _term} = tuple ->\n :gen.start(GenEvent, mode, tuple, @no_callback, [], [])\n\n {:via, via_module, _term} = tuple when is_atom(via_module) ->\n :gen.start(GenEvent, mode, tuple, @no_callback, [], [])\n\n other ->\n raise ArgumentError, \"\"\"\n expected :name option to be one of the following:\n\n * nil\n * atom\n * {:global, term}\n * {:via, module, term}\n\n Got: #{inspect(other)}\n \"\"\"\n end\n end\n\n @doc false\n @deprecated message\n @spec stream(manager, keyword) :: GenEvent.Stream.t()\n def stream(manager, options \\\\ []) do\n %GenEvent.Stream{manager: manager, timeout: Keyword.get(options, :timeout, :infinity)}\n end\n\n @doc false\n @deprecated message\n @spec add_handler(manager, handler, term) :: :ok | {:error, term}\n def add_handler(manager, handler, args) do\n rpc(manager, {:add_handler, handler, args})\n end\n\n @doc false\n @deprecated message\n @spec add_mon_handler(manager, handler, term) :: :ok | {:error, term}\n def add_mon_handler(manager, handler, args) do\n rpc(manager, {:add_mon_handler, handler, args, self()})\n end\n\n @doc false\n @deprecated message\n @spec notify(manager, term) :: :ok\n def notify(manager, event)\n\n def notify({:global, name}, msg) do\n try do\n :global.send(name, {:notify, msg})\n :ok\n catch\n _, _ -> :ok\n end\n end\n\n def notify({:via, mod, name}, msg) when is_atom(mod) do\n try do\n mod.send(name, {:notify, msg})\n :ok\n catch\n _, _ -> :ok\n end\n end\n\n def notify(manager, msg)\n when is_pid(manager)\n when is_atom(manager)\n when tuple_size(manager) == 2 and is_atom(elem(manager, 0)) and is_atom(elem(manager, 1)) do\n send(manager, {:notify, msg})\n :ok\n end\n\n @doc false\n @deprecated message\n @spec sync_notify(manager, term) :: :ok\n def sync_notify(manager, event) do\n rpc(manager, {:sync_notify, event})\n end\n\n @doc false\n @deprecated message\n @spec ack_notify(manager, term) :: :ok\n def ack_notify(manager, event) do\n rpc(manager, {:ack_notify, event})\n end\n\n @doc false\n @deprecated message\n @spec call(manager, handler, term, timeout) :: term | {:error, term}\n def call(manager, handler, request, timeout \\\\ 5000) do\n try do\n :gen.call(manager, self(), {:call, handler, request}, timeout)\n catch\n :exit, reason ->\n exit({reason, {__MODULE__, :call, [manager, handler, request, timeout]}})\n else\n {:ok, res} -> res\n end\n end\n\n @doc false\n @deprecated message\n @spec remove_handler(manager, handler, term) :: term | {:error, term}\n def remove_handler(manager, handler, args) do\n rpc(manager, {:delete_handler, handler, args})\n end\n\n @doc false\n @deprecated message\n @spec swap_handler(manager, handler, term, handler, term) :: :ok | {:error, term}\n def swap_handler(manager, handler1, args1, handler2, args2) do\n rpc(manager, {:swap_handler, handler1, args1, handler2, args2})\n end\n\n @doc false\n @deprecated message\n @spec swap_mon_handler(manager, handler, term, handler, term) :: :ok | {:error, term}\n def swap_mon_handler(manager, handler1, args1, handler2, args2) do\n rpc(manager, {:swap_mon_handler, handler1, args1, handler2, args2, self()})\n end\n\n @doc false\n @deprecated message\n @spec which_handlers(manager) :: [handler]\n def which_handlers(manager) do\n rpc(manager, :which_handlers)\n end\n\n @doc false\n @deprecated message\n @spec stop(manager, reason :: term, timeout) :: :ok\n def stop(manager, reason \\\\ :normal, timeout \\\\ :infinity) do\n :gen.stop(manager, reason, timeout)\n end\n\n defp rpc(module, cmd) do\n {:ok, reply} = :gen.call(module, self(), cmd, :infinity)\n reply\n end\n\n ## Init callbacks\n\n require Record\n Record.defrecordp(:handler, [:module, :id, :state, :pid, :ref])\n\n @doc false\n def init_it(starter, :self, name, mod, args, options) do\n init_it(starter, self(), name, mod, args, options)\n end\n\n def init_it(starter, parent, name, _mod, _args, options) do\n Process.put(:\"$initial_call\", {__MODULE__, :init_it, 6})\n debug = :gen.debug_options(name, options)\n :proc_lib.init_ack(starter, {:ok, self()})\n loop(parent, name(name), [], debug, false)\n end\n\n @doc false\n def init_hib(parent, name, handlers, debug) do\n fetch_msg(parent, name, handlers, debug, true)\n end\n\n defp name({:local, name}), do: name\n defp name({:global, name}), do: name\n defp name({:via, _, name}), do: name\n defp name(pid) when is_pid(pid), do: pid\n\n ## Loop\n\n defp loop(parent, name, handlers, debug, true) do\n :proc_lib.hibernate(__MODULE__, :init_hib, [parent, name, handlers, debug])\n end\n\n defp loop(parent, name, handlers, debug, false) do\n fetch_msg(parent, name, handlers, debug, false)\n end\n\n defp fetch_msg(parent, name, handlers, debug, hib) do\n receive do\n {:system, from, req} ->\n :sys.handle_system_msg(req, from, parent, __MODULE__, debug, [name, handlers, hib], hib)\n\n {:EXIT, ^parent, reason} ->\n server_terminate(reason, parent, handlers, name)\n\n msg when debug == [] ->\n handle_msg(msg, parent, name, handlers, [])\n\n msg ->\n debug = :sys.handle_debug(debug, &print_event/3, name, {:in, msg})\n handle_msg(msg, parent, name, handlers, debug)\n end\n end\n\n defp handle_msg(msg, parent, name, handlers, debug) do\n case msg do\n {:notify, event} ->\n {hib, handlers} = server_event(:async, event, handlers, name)\n loop(parent, name, handlers, debug, hib)\n\n {_from, _tag, {:notify, event}} ->\n {hib, handlers} = server_event(:async, event, handlers, name)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, {:ack_notify, event}} ->\n reply(tag, :ok)\n {hib, handlers} = server_event(:ack, event, handlers, name)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, {:sync_notify, event}} ->\n {hib, handlers} = server_event(:sync, event, handlers, name)\n reply(tag, :ok)\n loop(parent, name, handlers, debug, hib)\n\n {:DOWN, ref, :process, _pid, reason} = other ->\n case handle_down(ref, reason, handlers, name) do\n {:ok, handlers} ->\n loop(parent, name, handlers, debug, false)\n\n :error ->\n {hib, handlers} = server_info(other, handlers, name)\n loop(parent, name, handlers, debug, hib)\n end\n\n {_from, tag, {:call, handler, query}} ->\n {hib, reply, handlers} = server_call(handler, query, handlers, name)\n reply(tag, reply)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, {:add_handler, handler, args}} ->\n {hib, reply, handlers} = server_add_handler(handler, args, handlers)\n reply(tag, reply)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, {:add_mon_handler, handler, args, notify}} ->\n {hib, reply, handlers} = server_add_mon_handler(handler, args, handlers, notify)\n reply(tag, reply)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, {:add_process_handler, pid, notify}} ->\n {hib, reply, handlers} = server_add_process_handler(pid, handlers, notify)\n reply(tag, reply)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, {:delete_handler, handler, args}} ->\n {reply, handlers} = server_remove_handler(handler, args, handlers, name)\n reply(tag, reply)\n loop(parent, name, handlers, debug, false)\n\n {_from, tag, {:swap_handler, handler1, args1, handler2, args2}} ->\n {hib, reply, handlers} =\n server_swap_handler(handler1, args1, handler2, args2, handlers, nil, name)\n\n reply(tag, reply)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, {:swap_mon_handler, handler1, args1, handler2, args2, mon}} ->\n {hib, reply, handlers} =\n server_swap_handler(handler1, args1, handler2, args2, handlers, mon, name)\n\n reply(tag, reply)\n loop(parent, name, handlers, debug, hib)\n\n {_from, tag, :which_handlers} ->\n reply(tag, server_which_handlers(handlers))\n loop(parent, name, handlers, debug, false)\n\n {_from, tag, :get_modules} ->\n reply(tag, server_get_modules(handlers))\n loop(parent, name, handlers, debug, false)\n\n other ->\n {hib, handlers} = server_info(other, handlers, name)\n loop(parent, name, handlers, debug, hib)\n end\n end\n\n ## System callbacks\n\n @doc false\n def system_continue(parent, debug, [name, handlers, hib]) do\n loop(parent, name, handlers, debug, hib)\n end\n\n @doc false\n def system_terminate(reason, parent, _debug, [name, handlers, _hib]) do\n server_terminate(reason, parent, handlers, name)\n end\n\n @doc false\n def system_code_change([name, handlers, hib], module, old_vsn, extra) do\n handlers =\n for handler <- handlers do\n if handler(handler, :module) == module do\n {:ok, state} = module.code_change(old_vsn, handler(handler, :state), extra)\n handler(handler, state: state)\n else\n handler\n end\n end\n\n {:ok, [name, handlers, hib]}\n end\n\n @doc false\n def system_get_state([_name, handlers, _hib]) do\n tuples =\n for handler(module: mod, id: id, state: state) <- handlers do\n {mod, id, state}\n end\n\n {:ok, tuples}\n end\n\n @doc false\n def system_replace_state(fun, [name, handlers, hib]) do\n {handlers, states} =\n :lists.unzip(\n for handler <- handlers do\n handler(module: mod, id: id, state: state) = handler\n cur = {mod, id, state}\n\n try do\n new = {^mod, ^id, new_state} = fun.(cur)\n {handler(handler, state: new_state), new}\n catch\n _, _ ->\n {handler, cur}\n end\n end\n )\n\n {:ok, states, [name, handlers, hib]}\n end\n\n # Keeping deprecated format_status/2 since the current implementation is not\n # compatible with format_status/1 and GenEvent is deprecated anyway\n @doc false\n def format_status(opt, status_data) do\n [pdict, sys_state, parent, _debug, [name, handlers, _hib]] = status_data\n header = :gen.format_status_header(~c\"Status for event handler\", name)\n\n formatted =\n for handler <- handlers do\n handler(module: module, state: state) = handler\n\n if function_exported?(module, :format_status, 2) do\n try do\n state = module.format_status(opt, [pdict, state])\n handler(handler, state: state)\n catch\n _, _ -> handler\n end\n else\n handler\n end\n end\n\n [\n header: header,\n data: [{~c\"Status\", sys_state}, {~c\"Parent\", parent}],\n items: {~c\"Installed handlers\", formatted}\n ]\n end\n\n ## Loop helpers\n\n defp print_event(dev, {:in, msg}, name) do\n case msg do\n {:notify, event} ->\n IO.puts(dev, \"*DBG* #{inspect(name)} got event #{inspect(event)}\")\n\n {_, _, {:call, handler, query}} ->\n IO.puts(\n dev,\n \"*DBG* #{inspect(name)} (handler #{inspect(handler)}) got call #{inspect(query)}\"\n )\n\n _ ->\n IO.puts(dev, \"*DBG* #{inspect(name)} got #{inspect(msg)}\")\n end\n end\n\n defp print_event(dev, dbg, name) do\n IO.puts(dev, \"*DBG* #{inspect(name)}: #{inspect(dbg)}\")\n end\n\n defp server_add_handler({module, id}, args, handlers) do\n handler = handler(module: module, id: {module, id})\n do_add_handler(module, handler, args, handlers, :ok)\n end\n\n defp server_add_handler(module, args, handlers) do\n handler = handler(module: module, id: module)\n do_add_handler(module, handler, args, handlers, :ok)\n end\n\n defp server_add_mon_handler({module, id}, args, handlers, notify) do\n ref = Process.monitor(notify)\n handler = handler(module: module, id: {module, id}, pid: notify, ref: ref)\n do_add_handler(module, handler, args, handlers, :ok)\n end\n\n defp server_add_mon_handler(module, args, handlers, notify) do\n ref = Process.monitor(notify)\n handler = handler(module: module, id: module, pid: notify, ref: ref)\n do_add_handler(module, handler, args, handlers, :ok)\n end\n\n defp server_add_process_handler(pid, handlers, notify) do\n ref = Process.monitor(pid)\n handler = handler(module: GenEvent.Stream, id: {self(), ref}, pid: notify, ref: ref)\n do_add_handler(GenEvent.Stream, handler, {pid, ref}, handlers, {self(), ref})\n end\n\n defp server_remove_handler(module, args, handlers, name) do\n do_take_handler(module, args, handlers, name, :remove, :normal)\n end\n\n defp server_swap_handler(module1, args1, module2, args2, handlers, sup, name) do\n {state, handlers} =\n do_take_handler(module1, args1, handlers, name, :swapped, {:swapped, module2, sup})\n\n if sup do\n server_add_mon_handler(module2, {args2, state}, handlers, sup)\n else\n server_add_handler(module2, {args2, state}, handlers)\n end\n end\n\n defp server_info(event, handlers, name) do\n handlers = :lists.reverse(handlers)\n server_notify(event, :handle_info, handlers, name, handlers, [], false)\n end\n\n defp server_event(mode, event, handlers, name) do\n {handlers, streams} = server_split_process_handlers(mode, event, handlers, [], [])\n {hib, handlers} = server_notify(event, :handle_event, handlers, name, handlers, [], false)\n {hib, server_collect_process_handlers(mode, event, streams, handlers, name)}\n end\n\n defp server_split_process_handlers(mode, event, [handler | t], handlers, streams) do\n case handler(handler, :id) do\n {pid, _ref} when is_pid(pid) ->\n server_process_notify(mode, event, handler)\n server_split_process_handlers(mode, event, t, handlers, [handler | streams])\n\n _ ->\n server_split_process_handlers(mode, event, t, [handler | handlers], streams)\n end\n end\n\n defp server_split_process_handlers(_mode, _event, [], handlers, streams) do\n {handlers, streams}\n end\n\n defp server_process_notify(mode, event, handler(state: {pid, ref})) do\n send(pid, {self(), {self(), ref}, {mode_to_tag(mode), event}})\n end\n\n defp mode_to_tag(:ack), do: :ack_notify\n defp mode_to_tag(:sync), do: :sync_notify\n defp mode_to_tag(:async), do: :notify\n\n defp server_notify(event, fun, [handler | t], name, handlers, acc, hib) do\n case server_update(handler, fun, event, name, handlers) do\n {new_hib, handler} ->\n server_notify(event, fun, t, name, handlers, [handler | acc], hib or new_hib)\n\n :error ->\n server_notify(event, fun, t, name, handlers, acc, hib)\n end\n end\n\n defp server_notify(_, _, [], _, _, acc, hib) do\n {hib, acc}\n end\n\n defp server_update(handler, fun, event, name, _handlers) do\n handler(module: module, state: state) = handler\n\n case do_handler(module, fun, [event, state]) do\n {:ok, res} ->\n case res do\n {:ok, state} ->\n {false, handler(handler, state: state)}\n\n {:ok, state, :hibernate} ->\n {true, handler(handler, state: state)}\n\n :remove_handler ->\n do_terminate(handler, :remove_handler, event, name, :normal)\n :error\n\n other ->\n reason = {:bad_return_value, other}\n do_terminate(handler, {:error, reason}, event, name, reason)\n :error\n end\n\n {:error, reason} ->\n do_terminate(handler, {:error, reason}, event, name, reason)\n :error\n end\n end\n\n defp server_collect_process_handlers(:async, event, [handler | t], handlers, name) do\n server_collect_process_handlers(:async, event, t, [handler | handlers], name)\n end\n\n defp server_collect_process_handlers(mode, event, [handler | t], handlers, name)\n when mode in [:sync, :ack] do\n handler(ref: ref, id: id) = handler\n\n receive do\n {^ref, :ok} ->\n server_collect_process_handlers(mode, event, t, [handler | handlers], name)\n\n {_from, tag, {:delete_handler, ^id, args}} ->\n do_terminate(handler, args, :remove, name, :normal)\n reply(tag, :ok)\n server_collect_process_handlers(mode, event, t, handlers, name)\n\n {:DOWN, ^ref, _, _, reason} ->\n do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)\n server_collect_process_handlers(mode, event, t, handlers, name)\n end\n end\n\n defp server_collect_process_handlers(_mode, _event, [], handlers, _name) do\n handlers\n end\n\n defp server_call(module, query, handlers, name) do\n case :lists.keyfind(module, handler(:id) + 1, handlers) do\n false ->\n {false, {:error, :not_found}, handlers}\n\n handler ->\n case server_call_update(handler, query, name, handlers) do\n {{hib, handler}, reply} ->\n {hib, reply, :lists.keyreplace(module, handler(:id) + 1, handlers, handler)}\n\n {:error, reply} ->\n {false, reply, :lists.keydelete(module, handler(:id) + 1, handlers)}\n end\n end\n end\n\n defp server_call_update(handler, query, name, _handlers) do\n handler(module: module, state: state) = handler\n\n case do_handler(module, :handle_call, [query, state]) do\n {:ok, res} ->\n case res do\n {:ok, reply, state} ->\n {{false, handler(handler, state: state)}, reply}\n\n {:ok, reply, state, :hibernate} ->\n {{true, handler(handler, state: state)}, reply}\n\n {:remove_handler, reply} ->\n do_terminate(handler, :remove_handler, query, name, :normal)\n {:error, reply}\n\n other ->\n reason = {:bad_return_value, other}\n do_terminate(handler, {:error, reason}, query, name, reason)\n {:error, {:error, reason}}\n end\n\n {:error, reason} ->\n do_terminate(handler, {:error, reason}, query, name, reason)\n {:error, {:error, reason}}\n end\n end\n\n defp server_get_modules(handlers) do\n for(handler(module: module) <- handlers, do: module)\n |> :ordsets.from_list()\n |> :ordsets.to_list()\n end\n\n defp server_which_handlers(handlers) do\n for handler(id: id) <- handlers, do: id\n end\n\n defp server_terminate(reason, _parent, handlers, name) do\n _ =\n for handler <- handlers do\n do_terminate(handler, :stop, :stop, name, :shutdown)\n end\n\n exit(reason)\n end\n\n defp reply({from, ref}, msg) do\n send(from, {ref, msg})\n end\n\n defp handle_down(ref, reason, handlers, name) do\n case :lists.keyfind(ref, handler(:ref) + 1, handlers) do\n false ->\n :error\n\n handler ->\n do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)\n {:ok, :lists.keydelete(ref, handler(:ref) + 1, handlers)}\n end\n end\n\n defp do_add_handler(module, handler, arg, handlers, succ) do\n case :lists.keyfind(handler(handler, :id), handler(:id) + 1, handlers) do\n false ->\n case do_handler(module, :init, [arg]) do\n {:ok, res} ->\n case res do\n {:ok, state} ->\n {false, succ, [handler(handler, state: state) | handlers]}\n\n {:ok, state, :hibernate} ->\n {true, succ, [handler(handler, state: state) | handlers]}\n\n {:error, _} = error ->\n {false, error, handlers}\n\n other ->\n {false, {:error, {:bad_return_value, other}}, handlers}\n end\n\n {:error, _} = error ->\n {false, error, handlers}\n end\n\n _ ->\n {false, {:error, :already_present}, handlers}\n end\n end\n\n defp do_take_handler(module, args, handlers, name, last_in, reason) do\n case :lists.keytake(module, handler(:id) + 1, handlers) do\n {:value, handler, handlers} ->\n {do_terminate(handler, args, last_in, name, reason), handlers}\n\n false ->\n {{:error, :not_found}, handlers}\n end\n end\n\n defp do_terminate(handler, arg, last_in, name, reason) do\n handler(module: module, state: state) = handler\n\n res =\n case do_handler(module, :terminate, [arg, state]) do\n {:ok, res} -> res\n {:error, _} = error -> error\n end\n\n report_terminate(handler, reason, state, last_in, name)\n res\n end\n\n defp do_handler(mod, fun, args) do\n try do\n apply(mod, fun, args)\n catch\n :throw, val -> {:ok, val}\n :error, val -> {:error, {val, __STACKTRACE__}}\n :exit, val -> {:error, val}\n else\n res -> {:ok, res}\n end\n end\n\n defp report_terminate(handler, reason, state, last_in, name) do\n report_error(handler, reason, state, last_in, name)\n\n if ref = handler(handler, :ref) do\n Process.demonitor(ref, [:flush])\n end\n\n if pid = handler(handler, :pid) do\n send(pid, {:gen_event_EXIT, handler(handler, :id), reason})\n end\n end\n\n defp report_error(_handler, :normal, _, _, _), do: :ok\n defp report_error(_handler, :shutdown, _, _, _), do: :ok\n defp report_error(_handler, {:swapped, _, _}, _, _, _), do: :ok\n\n defp report_error(handler, reason, state, last_in, name) do\n reason =\n case reason do\n {:undef, [{m, f, a, _} | _] = mfas} ->\n cond do\n :code.is_loaded(m) == false ->\n {:\"module could not be loaded\", mfas}\n\n function_exported?(m, f, length(a)) ->\n reason\n\n true ->\n {:\"function not exported\", mfas}\n end\n\n _ ->\n reason\n end\n\n formatted = report_status(handler, state)\n\n :error_logger.error_msg(\n ~c\"** gen_event handler ~p crashed.~n\" ++\n ~c\"** Was installed in ~p~n\" ++\n ~c\"** Last event was: ~p~n\" ++ ~c\"** When handler state == ~p~n\" ++ ~c\"** Reason == ~p~n\",\n [handler(handler, :id), name, last_in, formatted, reason]\n )\n end\n\n defp report_status(handler(module: module), state) do\n if function_exported?(module, :format_status, 2) do\n try do\n module.format_status(:terminate, [Process.get(), state])\n catch\n _, _ -> state\n end\n else\n state\n end\n end\nend\n" }, { "path": "lib/elixir/lib/gen_server.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule GenServer do\n @moduledoc \"\"\"\n A behaviour module for implementing the server of a client-server relation.\n\n A GenServer is a process like any other Elixir process and it can be used\n to keep state, execute code asynchronously and so on. The advantage of using\n a generic server process (GenServer) implemented using this module is that it\n will have a standard set of interface functions and include functionality for\n tracing and error reporting. It will also fit into a supervision tree.\n\n ```mermaid\n graph BT\n C(Client #3) ~~~ B(Client #2) ~~~ A(Client #1)\n A & B & C -->|request| GenServer\n GenServer -.->|reply| A & B & C\n ```\n\n ## Example\n\n The GenServer behaviour abstracts the common client-server interaction.\n Developers are only required to implement the callbacks and functionality\n they are interested in.\n\n Let's start with a code example and then explore the available callbacks.\n Imagine we want to implement a service with a GenServer that works\n like a stack, allowing us to push and pop elements. We'll customize a\n generic GenServer with our own module by implementing three callbacks.\n\n `c:init/1` transforms our initial argument to the initial state for the\n GenServer. `c:handle_call/3` fires when the server receives a synchronous\n `pop` message, popping an element from the stack and returning it to the\n user. `c:handle_cast/2` will fire when the server receives an asynchronous\n `push` message, pushing an element onto the stack:\n\n defmodule Stack do\n use GenServer\n\n # Callbacks\n\n @impl true\n def init(elements) do\n initial_state = String.split(elements, \",\", trim: true)\n {:ok, initial_state}\n end\n\n @impl true\n def handle_call(:pop, _from, state) do\n [to_caller | new_state] = state\n {:reply, to_caller, new_state}\n end\n\n @impl true\n def handle_cast({:push, element}, state) do\n new_state = [element | state]\n {:noreply, new_state}\n end\n end\n\n We leave the process machinery of startup, message passing, and the message\n loop to the GenServer behaviour and focus only on the stack\n implementation. We can now use the GenServer API to interact with\n the service by creating a process and sending it messages:\n\n # Start the server\n {:ok, pid} = GenServer.start_link(Stack, \"hello,world\")\n\n # This is the client\n GenServer.call(pid, :pop)\n #=> \"hello\"\n\n GenServer.cast(pid, {:push, \"elixir\"})\n #=> :ok\n\n GenServer.call(pid, :pop)\n #=> \"elixir\"\n\n We start our `Stack` by calling `start_link/2`, passing the module\n with the server implementation and its initial argument with a\n comma-separated list of elements. The GenServer behaviour calls the\n `c:init/1` callback to establish the initial GenServer state. From\n this point on, the GenServer has control so we interact with it by\n sending two types of messages on the client. **call** messages expect\n a reply from the server (and are therefore synchronous) while **cast**\n messages do not.\n\n Each call to `GenServer.call/3` results in a message\n that must be handled by the `c:handle_call/3` callback in the GenServer.\n A `cast/2` message must be handled by `c:handle_cast/2`. `GenServer`\n supports 8 callbacks, but only `c:init/1` is required.\n\n > #### `use GenServer` {: .info}\n >\n > When you `use GenServer`, the `GenServer` module will\n > set `@behaviour GenServer` and define a `child_spec/1`\n > function, so your module can be used as a child\n > in a supervision tree.\n\n ## Client / Server APIs\n\n Although in the example above we have used `GenServer.start_link/3` and\n friends to directly start and communicate with the server, most of the\n time we don't call the `GenServer` functions directly. Instead, we wrap\n the calls in new functions representing the public API of the server.\n These thin wrappers are called the **client API**.\n\n Here is a better implementation of our Stack module:\n\n defmodule Stack do\n use GenServer\n\n # Client\n\n def start_link(default) when is_binary(default) do\n GenServer.start_link(__MODULE__, default)\n end\n\n def push(pid, element) do\n GenServer.cast(pid, {:push, element})\n end\n\n def pop(pid) do\n GenServer.call(pid, :pop)\n end\n\n # Server (callbacks)\n\n @impl true\n def init(elements) do\n initial_state = String.split(elements, \",\", trim: true)\n {:ok, initial_state}\n end\n\n @impl true\n def handle_call(:pop, _from, state) do\n [to_caller | new_state] = state\n {:reply, to_caller, new_state}\n end\n\n @impl true\n def handle_cast({:push, element}, state) do\n new_state = [element | state]\n {:noreply, new_state}\n end\n end\n\n In practice, it is common to have both server and client functions in\n the same module. If the server and/or client implementations are growing\n complex, you may want to have them in different modules.\n\n The following diagram summarizes the interactions between client and server.\n Both Client and Server are processes and communication happens via messages\n (continuous line). The Server <-> Module interaction happens when the\n GenServer process calls your code (dotted lines):\n\n ```mermaid\n sequenceDiagram\n participant C as Client (Process)\n participant S as Server (Process)\n participant M as Module (Code)\n\n note right of C: Typically started by a supervisor\n C->>+S: GenServer.start_link(module, arg, options)\n S-->>+M: init(arg)\n M-->>-S: {:ok, state} | :ignore | {:error, reason}\n S->>-C: {:ok, pid} | :ignore | {:error, reason}\n\n note right of C: call is synchronous\n C->>+S: GenServer.call(pid, message)\n S-->>+M: handle_call(message, from, state)\n M-->>-S: {:reply, reply, state} | {:stop, reason, reply, state}\n S->>-C: reply\n\n note right of C: cast is asynchronous\n C-)S: GenServer.cast(pid, message)\n S-->>+M: handle_cast(message, state)\n M-->>-S: {:noreply, state} | {:stop, reason, state}\n\n note right of C: send is asynchronous\n C-)S: Kernel.send(pid, message)\n S-->>+M: handle_info(message, state)\n M-->>-S: {:noreply, state} | {:stop, reason, state}\n ```\n\n ## How to supervise\n\n A `GenServer` is most commonly started under a supervision tree.\n When we invoke `use GenServer`, it automatically defines a `child_spec/1`\n function that allows us to start the `Stack` directly under a supervisor.\n To start a default stack of `[\"hello\", \"world\"]` under a supervisor,\n we can do:\n\n children = [\n {Stack, \"hello,world\"}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_all)\n\n Note that specifying a module `MyServer` would be the same as specifying\n the tuple `{MyServer, []}`.\n\n `use GenServer` also accepts a list of options which configures the\n child specification and therefore how it runs under a supervisor.\n The generated `child_spec/1` can be customized with the following options:\n\n * `:id` - the child specification identifier, defaults to the current module\n * [`:restart`](`m:Supervisor#module-restart-values-restart`) - when the\n child should be restarted, defaults to `:permanent`\n * [`:shutdown`](`m:Supervisor#module-shutdown-values-shutdown`) - how to\n shut down the child, either immediately or by giving it time to shut down,\n defaults to `5_000`\n\n For example:\n\n use GenServer, restart: :transient, shutdown: 10_000\n\n See the [\"Child specification\"](`m:Supervisor#module-child-specification`) section in the `Supervisor` module for more\n detailed information. The `@doc` annotation immediately preceding\n `use GenServer` will be attached to the generated `child_spec/1` function.\n\n When stopping the GenServer, for example by returning a `{:stop, reason, new_state}`\n tuple from a callback, the exit reason is used by the supervisor to determine\n whether the GenServer needs to be restarted. See the \"Exit reasons and restarts\"\n section in the `Supervisor` module.\n\n ## Name registration\n\n Both `start_link/3` and `start/3` support the `GenServer` to register\n a name on start via the `:name` option. Registered names are also\n automatically cleaned up on termination. The supported values are:\n\n * `nil` (default) - the GenServer is not registered with a name.\n\n * an atom - the GenServer is registered locally (to the current node)\n with the given name using `Process.register/2`.\n\n * `{:global, term}` - the GenServer is registered globally with the given\n term using the functions in the [`:global` module](`:global`).\n\n * `{:via, module, term}` - the GenServer is registered with the given\n mechanism and name. The `:via` option expects a module that exports\n `register_name/2`, `unregister_name/1`, `whereis_name/1` and `send/2`.\n One such example is the [`:global` module](`:global`) which uses these functions\n for keeping the list of names of processes and their associated PIDs\n that are available globally for a network of Elixir nodes. Elixir also\n ships with a local, decentralized and scalable registry called `Registry`\n for locally storing names that are generated dynamically.\n\n For example, we could start and register our `Stack` server locally as follows:\n\n # Start the server and register it locally with name MyStack\n {:ok, _} = GenServer.start_link(Stack, \"hello\", name: MyStack)\n\n # Now messages can be sent directly to MyStack\n GenServer.call(MyStack, :pop)\n #=> \"hello\"\n\n Once the server is started, the remaining functions in this module (`call/3`,\n `cast/2`, and friends) will also accept an atom, or any `{:global, ...}` or\n `{:via, ...}` tuples. In general, the following formats are supported:\n\n * a PID\n * an atom if the server is locally registered\n * `{atom, node}` if the server is locally registered at another node\n * `{:global, term}` if the server is globally registered\n * `{:via, module, name}` if the server is registered through an alternative\n registry\n\n If there is an interest to register dynamic names locally, do not use\n atoms, as atoms are never garbage-collected and therefore dynamically\n generated atoms won't be garbage-collected. For such cases, you can\n set up your own local registry by using the `Registry` module.\n\n For example:\n\n {:ok, _} = Registry.start_link(keys: :unique, name: :stacks)\n name = {:via, Registry, {:stacks, \"stack 1\"}}\n {:ok, _pid} = GenServer.start_link(Stack, \"hello\", name: name)\n GenServer.whereis(name)\n #=> #PID<0.150.0>\n\n ## Receiving \"regular\" messages\n\n The goal of a `GenServer` is to abstract the \"receive\" loop for developers,\n automatically handling system messages, supporting code change, synchronous\n calls and more. Therefore, you should never call your own \"receive\" inside\n the GenServer callbacks as doing so will cause the GenServer to misbehave.\n\n Besides the synchronous and asynchronous communication provided by `call/3`\n and `cast/2`, \"regular\" messages sent by functions such as `send/2`,\n `Process.send_after/4` and similar, can be handled inside the `c:handle_info/2`\n callback.\n\n `c:handle_info/2` can be used in many situations, such as handling monitor\n DOWN messages sent by `Process.monitor/1`. Another use case for `c:handle_info/2`\n is to perform periodic work, with the help of `Process.send_after/4`:\n\n defmodule MyApp.Periodically do\n use GenServer\n\n def start_link(_) do\n GenServer.start_link(__MODULE__, %{})\n end\n\n @impl true\n def init(state) do\n # Schedule work to be performed on start\n schedule_work()\n\n {:ok, state}\n end\n\n @impl true\n def handle_info(:work, state) do\n # Do the desired work here\n # ...\n\n # Reschedule once more\n schedule_work()\n\n {:noreply, state}\n end\n\n defp schedule_work do\n # We schedule the work to happen in 2 hours (written in milliseconds).\n # Alternatively, one might write :timer.hours(2)\n Process.send_after(self(), :work, 2 * 60 * 60 * 1000)\n end\n end\n\n ## Timeouts\n\n The return value of `c:init/1` or any of the `handle_*` callbacks may include\n a timeout value in milliseconds; if not, `:infinity` is assumed.\n The timeout can be used to detect a lull in incoming messages.\n\n The `timeout()` value is used as follows:\n\n * If the process has any message already waiting when the `timeout()` value\n is returned, the timeout is ignored and the waiting message is handled as\n usual. This means that even a timeout of `0` milliseconds is not guaranteed\n to execute (if you want to take another action immediately and unconditionally,\n use a `:continue` instruction instead).\n\n * If any message arrives before the specified number of milliseconds\n elapse, the timeout is cleared and that message is handled as usual.\n\n * Otherwise, when the specified number of milliseconds have elapsed with no\n message arriving, `handle_info/2` is called with `:timeout` as the first\n argument.\n\n For example:\n\n defmodule Counter do\n use GenServer\n\n @timeout to_timeout(second: 5)\n\n @impl true\n def init(count) do\n {:ok, count, @timeout}\n end\n\n @impl true\n def handle_call(:increment, _from, count) do\n new_count = count + 1\n {:reply, new_count, new_count, @timeout}\n end\n\n @impl true\n def handle_info(:timeout, count) do\n {:stop, :normal, count}\n end\n end\n\n A `Counter` server will exit with `:normal` if there are no messages in 5 seconds\n after the initialization or after the last `:increment` call:\n\n {:ok, counter_pid} = GenServer.start(Counter, 50)\n GenServer.call(counter_pid, :increment)\n #=> 51\n\n # After 5 seconds\n Process.alive?(counter_pid)\n #=> false\n\n ## When (not) to use a GenServer\n\n So far, we have learned that a `GenServer` can be used as a supervised process\n that handles sync and async calls. It can also handle system messages, such as\n periodic messages and monitoring events. GenServer processes may also be named.\n\n A GenServer, or a process in general, must be used to model runtime characteristics\n of your system. A GenServer must never be used for code organization purposes.\n\n In Elixir, code organization is done by modules and functions, processes are not\n necessary. For example, imagine you are implementing a calculator and you decide\n to put all the calculator operations behind a GenServer:\n\n def add(a, b) do\n GenServer.call(__MODULE__, {:add, a, b})\n end\n\n def subtract(a, b) do\n GenServer.call(__MODULE__, {:subtract, a, b})\n end\n\n def handle_call({:add, a, b}, _from, state) do\n {:reply, a + b, state}\n end\n\n def handle_call({:subtract, a, b}, _from, state) do\n {:reply, a - b, state}\n end\n\n This is an anti-pattern not only because it convolutes the calculator logic but\n also because you put the calculator logic behind a single process that will\n potentially become a bottleneck in your system, especially as the number of\n calls grow. Instead just define the functions directly:\n\n def add(a, b) do\n a + b\n end\n\n def subtract(a, b) do\n a - b\n end\n\n If you don't need a process, then you don't need a process. Use processes only to\n model runtime properties, such as mutable state, concurrency and failures, never\n for code organization.\n\n ## Debugging with the :sys module\n\n GenServers, as [special processes](https://www.erlang.org/doc/design_principles/spec_proc.html),\n can be debugged using the [`:sys` module](`:sys`).\n Through various hooks, this module allows developers to introspect the state of\n the process and trace system events that happen during its execution, such as\n received messages, sent replies and state changes.\n\n Let's explore the basic functions from the\n [`:sys` module](`:sys`) used for debugging:\n\n * `:sys.get_state/2` - allows retrieval of the state of the process.\n In the case of a GenServer process, it will be the callback module state,\n as passed into the callback functions as last argument.\n * `:sys.get_status/2` - allows retrieval of the status of the process.\n This status includes the process dictionary, if the process is running\n or is suspended, the parent PID, the debugger state, and the state of\n the behaviour module, which includes the callback module state\n (as returned by `:sys.get_state/2`). It's possible to change how this\n status is represented by defining the optional `c:GenServer.format_status/1`\n callback.\n * `:sys.trace/3` - prints all the system events to `:stdio`.\n * `:sys.statistics/3` - manages collection of process statistics.\n * `:sys.no_debug/2` - turns off all debug handlers for the given process.\n It is very important to switch off debugging once we're done. Excessive\n debug handlers or those that should be turned off, but weren't, can\n seriously damage the performance of the system.\n * `:sys.suspend/2` - allows to suspend a process so that it only\n replies to system messages but no other messages. A suspended process\n can be reactivated via `:sys.resume/2`.\n\n Let's see how we could use those functions for debugging the stack server\n we defined earlier.\n\n iex> {:ok, pid} = Stack.start_link(\"\")\n iex> :sys.statistics(pid, true) # turn on collecting process statistics\n iex> :sys.trace(pid, true) # turn on event printing\n iex> Stack.push(pid, 1)\n *DBG* <0.122.0> got cast {push,1}\n *DBG* <0.122.0> new state [1]\n :ok\n\n iex> :sys.get_state(pid)\n [1]\n\n iex> Stack.pop(pid)\n *DBG* <0.122.0> got call pop from <0.80.0>\n *DBG* <0.122.0> sent 1 to <0.80.0>, new state []\n 1\n\n iex> :sys.statistics(pid, :get)\n {:ok,\n [\n start_time: {{2016, 7, 16}, {12, 29, 41}},\n current_time: {{2016, 7, 16}, {12, 29, 50}},\n reductions: 117,\n messages_in: 2,\n messages_out: 0\n ]}\n\n iex> :sys.no_debug(pid) # turn off all debug handlers\n :ok\n\n iex> :sys.get_status(pid)\n {:status, #PID<0.122.0>, {:module, :gen_server},\n [\n [\n \"$initial_call\": {Stack, :init, 1}, # process dictionary\n \"$ancestors\": [#PID<0.80.0>, #PID<0.51.0>]\n ],\n :running, # :running | :suspended\n #PID<0.80.0>, # parent\n [], # debugger state\n [\n header: 'Status for generic server <0.122.0>', # module status\n data: [\n {'Status', :running},\n {'Parent', #PID<0.80.0>},\n {'Logged events', []}\n ],\n data: [{'State', [1]}]\n ]\n ]}\n\n ## Learn more\n\n If you wish to find out more about GenServers, the Elixir Getting Started\n guide provides a tutorial-like introduction. The documentation and links\n in Erlang can also provide extra insight.\n\n * [GenServer - Elixir's Getting Started Guide](genservers.md)\n * [`:gen_server` module documentation](`:gen_server`)\n * [gen_server Behaviour - OTP Design Principles](https://www.erlang.org/doc/design_principles/gen_server_concepts.html)\n * [Clients and Servers - Learn You Some Erlang for Great Good!](https://learnyousomeerlang.com/clients-and-servers)\n\n \"\"\"\n\n @doc \"\"\"\n Invoked when the server is started. `start_link/3` or `start/3` will\n block until it returns.\n\n `init_arg` is the argument term (second argument) passed to `start_link/3`.\n\n Returning `{:ok, state}` will cause `start_link/3` to return\n `{:ok, pid}` and the process to enter its loop.\n\n Returning `{:ok, state, timeout}` is similar to `{:ok, state}`,\n except that it also sets a timeout. See the \"Timeouts\" section\n in the module documentation for more information.\n\n Returning `{:ok, state, :hibernate}` is similar to `{:ok, state}`\n except the process is hibernated before entering the loop. See\n `c:handle_call/3` for more information on hibernation.\n\n Returning `{:ok, state, {:continue, continue_arg}}` is similar to\n `{:ok, state}` except that immediately after entering the loop,\n the `c:handle_continue/2` callback will be invoked with `continue_arg`\n as the first argument and `state` as the second one.\n\n Returning `:ignore` will cause `start_link/3` to return `:ignore` and\n the process will exit normally without entering the loop or calling\n `c:terminate/2`. If used when part of a supervision tree the parent\n supervisor will not fail to start nor immediately try to restart the\n `GenServer`. The remainder of the supervision tree will be started\n and so the `GenServer` should not be required by other processes.\n It can be started later with `Supervisor.restart_child/2` as the child\n specification is saved in the parent supervisor. The main use cases for\n this are:\n\n * The `GenServer` is disabled by configuration but might be enabled later.\n * An error occurred and it will be handled by a different mechanism than the\n `Supervisor`. Likely this approach involves calling `Supervisor.restart_child/2`\n after a delay to attempt a restart.\n\n Returning `{:stop, reason}` will cause `start_link/3` to return\n `{:error, reason}` and the process to exit with reason `reason` without\n entering the loop or calling `c:terminate/2`.\n \"\"\"\n @callback init(init_arg :: term) ::\n {:ok, state}\n | {:ok, state, timeout | :hibernate | {:continue, continue_arg :: term}}\n | :ignore\n | {:stop, reason :: term}\n when state: term\n\n @doc \"\"\"\n Invoked to handle synchronous `call/3` messages. `call/3` will block until a\n reply is received (unless the call times out or nodes are disconnected).\n\n `request` is the request message sent by a `call/3`, `from` is a 2-tuple\n containing the caller's PID and a term that uniquely identifies the call, and\n `state` is the current state of the `GenServer`.\n\n Returning `{:reply, reply, new_state}` sends the response `reply` to the\n caller and continues the loop with new state `new_state`.\n\n Returning `{:reply, reply, new_state, timeout}` is similar to\n `{:reply, reply, new_state}` except that it also sets a timeout.\n See the \"Timeouts\" section in the module documentation for more information.\n\n Returning `{:reply, reply, new_state, :hibernate}` is similar to\n `{:reply, reply, new_state}` except the process is hibernated and will\n continue the loop once a message is in its message queue. However, if a message is\n already in the message queue, the process will continue the loop immediately.\n Hibernating a `GenServer` causes garbage collection and leaves a continuous\n heap that minimises the memory used by the process.\n\n Hibernating should not be used aggressively as too much time could be spent\n garbage collecting, which would delay the processing of incoming messages.\n Normally it should only be used when you are not expecting new messages to\n immediately arrive and minimising the memory of the process is shown to be\n beneficial.\n\n Returning `{:reply, reply, new_state, {:continue, continue_arg}}` is similar to\n `{:reply, reply, new_state}` except that `c:handle_continue/2` will be invoked\n immediately after with `continue_arg` as the first argument and\n `state` as the second one.\n\n Returning `{:noreply, new_state}` does not send a response to the caller and\n continues the loop with new state `new_state`. The response must be sent with\n `reply/2`.\n\n There are three main use cases for not replying using the return value:\n\n * To reply before returning from the callback because the response is known\n before calling a slow function.\n * To reply after returning from the callback because the response is not yet\n available.\n * To reply from another process, such as a task.\n\n When replying from another process the `GenServer` should exit if the other\n process exits without replying as the caller will be blocking awaiting a\n reply.\n\n Returning `{:noreply, new_state, timeout | :hibernate | {:continue, continue_arg}}`\n is similar to `{:noreply, new_state}` except a timeout, hibernation or continue\n occurs as with a `:reply` tuple.\n\n Returning `{:stop, reason, reply, new_state}` stops the loop and `c:terminate/2`\n is called with reason `reason` and state `new_state`. Then, the `reply` is sent\n as the response to call and the process exits with reason `reason`.\n\n Returning `{:stop, reason, new_state}` is similar to\n `{:stop, reason, reply, new_state}` except a reply is not sent.\n\n This callback is optional. If one is not implemented, the server will fail\n if a call is performed against it.\n \"\"\"\n @callback handle_call(request :: term, from, state :: term) ::\n {:reply, reply, new_state}\n | {:reply, reply, new_state,\n timeout | :hibernate | {:continue, continue_arg :: term}}\n | {:noreply, new_state}\n | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg :: term}}\n | {:stop, reason, reply, new_state}\n | {:stop, reason, new_state}\n when reply: term, new_state: term, reason: term\n\n @doc \"\"\"\n Invoked to handle asynchronous `cast/2` messages.\n\n `request` is the request message sent by a `cast/2` and `state` is the current\n state of the `GenServer`.\n\n Returning `{:noreply, new_state}` continues the loop with new state `new_state`.\n\n Returning `{:noreply, new_state, timeout}` is similar to `{:noreply, new_state}`\n except that it also sets a timeout. See the \"Timeouts\" section in the module\n documentation for more information.\n\n Returning `{:noreply, new_state, :hibernate}` is similar to\n `{:noreply, new_state}` except the process is hibernated before continuing the\n loop. See `c:handle_call/3` for more information.\n\n Returning `{:noreply, new_state, {:continue, continue_arg}}` is similar to\n `{:noreply, new_state}` except `c:handle_continue/2` will be invoked\n immediately after with `continue_arg` as the first argument and\n `state` as the second one.\n\n Returning `{:stop, reason, new_state}` stops the loop and `c:terminate/2` is\n called with the reason `reason` and state `new_state`. The process exits with\n reason `reason`.\n\n This callback is optional. If one is not implemented, the server will fail\n if a cast is performed against it.\n \"\"\"\n @callback handle_cast(request :: term, state :: term) ::\n {:noreply, new_state}\n | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg :: term}}\n | {:stop, reason :: term, new_state}\n when new_state: term\n\n @doc \"\"\"\n Invoked to handle all other messages.\n\n `msg` is the message and `state` is the current state of the `GenServer`. When\n a timeout occurs the message is `:timeout`.\n\n Return values are the same as `c:handle_cast/2`.\n\n This callback is optional. If one is not implemented, the received message\n will be logged.\n \"\"\"\n @callback handle_info(msg :: :timeout | term, state :: term) ::\n {:noreply, new_state}\n | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg :: term}}\n | {:stop, reason :: term, new_state}\n when new_state: term\n\n @doc \"\"\"\n Invoked to handle continue instructions.\n\n It is useful for performing work after initialization or for splitting the work\n in a callback in multiple steps, updating the process state along the way.\n\n Return values are the same as `c:handle_cast/2`.\n\n This callback is optional. If one is not implemented, the server will fail\n if a continue instruction is used.\n \"\"\"\n @callback handle_continue(continue_arg, state :: term) ::\n {:noreply, new_state}\n | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg}}\n | {:stop, reason :: term, new_state}\n when new_state: term, continue_arg: term\n\n @doc \"\"\"\n Invoked when the server is about to exit. It should do any cleanup required.\n\n `reason` is exit reason and `state` is the current state of the `GenServer`.\n The return value is ignored.\n\n `c:terminate/2` is useful for cleanup that requires access to the\n `GenServer`'s state. However, it is **not guaranteed** that `c:terminate/2`\n is called when a `GenServer` exits. Therefore, important cleanup should be\n done using process links and/or monitors. A monitoring process will receive the\n same exit `reason` that would be passed to `c:terminate/2`.\n\n `c:terminate/2` is called if:\n\n * the `GenServer` traps exits (using `Process.flag/2`) *and* the parent\n process (the one which called `start_link/1`) sends an exit signal\n\n * a callback (except `c:init/1`) does one of the following:\n\n * returns a `:stop` tuple\n\n * raises (via `raise/2`) or exits (via `exit/1`)\n\n * returns an invalid value\n\n If part of a supervision tree, a `GenServer` will receive an exit signal from\n its parent process (its supervisor) when the tree is shutting down. The exit\n signal is based on the shutdown strategy in the child's specification, where\n this value can be:\n\n * `:brutal_kill`: the `GenServer` is killed and so `c:terminate/2` is not called.\n\n * a timeout value, where the supervisor will send the exit signal `:shutdown` and\n the `GenServer` will have the duration of the timeout to terminate.\n If after duration of this timeout the process is still alive, it will be killed\n immediately.\n\n For a more in-depth explanation, please read the \"Shutdown values (:shutdown)\"\n section in the `Supervisor` module.\n\n If the `GenServer` receives an exit signal (that is not `:normal`) from any\n process when it is not trapping exits it will exit abruptly with the same\n reason and so not call `c:terminate/2`. Note that a process does *NOT* trap\n exits by default and an exit signal is sent when a linked process exits or its\n node is disconnected.\n\n `c:terminate/2` is only called after the `GenServer` finishes processing all\n messages which arrived in its mailbox prior to the exit signal. If it\n receives a `:kill` signal before it finishes processing those,\n `c:terminate/2` will not be called. If `c:terminate/2` is called, any\n messages received after the exit signal will still be in the mailbox.\n\n There is no cleanup needed when the `GenServer` controls a `port` (for example,\n `:gen_tcp.socket`) or `t:File.io_device/0`, because these will be closed on\n receiving a `GenServer`'s exit signal and do not need to be closed manually\n in `c:terminate/2`.\n\n If `reason` is neither `:normal`, `:shutdown`, nor `{:shutdown, term}` an error is\n logged.\n\n This callback is optional.\n \"\"\"\n @callback terminate(reason, state :: term) :: term\n when reason: :normal | :shutdown | {:shutdown, term} | term\n\n @doc \"\"\"\n Invoked to change the state of the `GenServer` when a different version of a\n module is loaded (hot code swapping) and the state's term structure should be\n changed.\n\n `old_vsn` is the previous version of the module (defined by the `@vsn`\n attribute) when upgrading. When downgrading the previous version is wrapped in\n a 2-tuple with first element `:down`. `state` is the current state of the\n `GenServer` and `extra` is any extra data required to change the state.\n\n Returning `{:ok, new_state}` changes the state to `new_state` and the code\n change is successful.\n\n Returning `{:error, reason}` fails the code change with reason `reason` and\n the state remains as the previous state.\n\n If `c:code_change/3` raises the code change fails and the loop will continue\n with its previous state. Therefore this callback does not usually contain side effects.\n\n This callback is optional.\n \"\"\"\n @callback code_change(old_vsn, state :: term, extra :: term) ::\n {:ok, new_state :: term}\n | {:error, reason :: term}\n when old_vsn: term | {:down, term}\n\n @doc \"\"\"\n This function is called by a `GenServer` process in the following situations:\n\n * [`:sys.get_status/1,2`](`:sys.get_status/1`) is invoked to get the `GenServer` status.\n * The `GenServer` process terminates abnormally and logs an error.\n\n This callback is used to limit the status of the process returned by\n [`:sys.get_status/1,2`](`:sys.get_status/1`) or sent to logger.\n\n The callback gets a map `status` describing the current status and shall return\n a map `new_status` with the same keys, but it may transform some values.\n\n Two possible use cases for this callback is to remove sensitive information\n from the state to prevent it from being printed in log files, or to compact\n large irrelevant status items that would only clutter the logs.\n\n ## Example\n\n @impl GenServer\n def format_status(status) do\n Map.new(status, fn\n {:state, state} -> {:state, Map.delete(state, :private_key)}\n {:message, {:password, _}} -> {:message, {:password, \"redacted\"}}\n key_value -> key_value\n end)\n end\n\n \"\"\"\n @doc since: \"1.17.0\"\n @callback format_status(status :: :gen_server.format_status()) ::\n new_status :: :gen_server.format_status()\n\n # TODO: Remove this on v2.0\n @doc deprecated: \"Use format_status/1 callback instead\"\n @callback format_status(reason, pdict_and_state :: list) :: term\n when reason: :normal | :terminate\n\n @optional_callbacks code_change: 3,\n terminate: 2,\n handle_info: 2,\n handle_cast: 2,\n handle_call: 3,\n format_status: 1,\n format_status: 2,\n handle_continue: 2\n\n @typedoc \"Return values of `start*` functions\"\n @type on_start :: {:ok, pid} | :ignore | {:error, {:already_started, pid} | term}\n\n @typedoc \"The GenServer name\"\n @type name :: nil | atom | {:global, term} | {:via, module, term}\n\n @typedoc \"Options used by the `start*` functions\"\n @type options :: [option]\n\n @typedoc \"Option values used by the `start*` functions\"\n @type option ::\n {:debug, debug}\n | {:name, name}\n | {:timeout, timeout}\n | {:spawn_opt, [Process.spawn_opt()]}\n | {:hibernate_after, timeout}\n\n @typedoc \"Debug options supported by the `start*` functions\"\n @type debug :: [:trace | :log | :statistics | {:log_to_file, Path.t()}]\n\n @typedoc \"\"\"\n The server reference.\n\n This is either a plain PID or a value representing a registered name.\n See the \"Name registration\" section of this document for more information.\n \"\"\"\n @type server :: pid | name | {atom, node}\n\n @typedoc \"\"\"\n Tuple describing the client of a call request.\n\n `pid` is the PID of the caller and `tag` is a unique term used to identify the\n call.\n \"\"\"\n @type from :: {pid, tag :: term}\n\n @doc false\n defmacro __using__(opts) do\n quote location: :keep, bind_quoted: [opts: opts] do\n @behaviour GenServer\n\n if not Module.has_attribute?(__MODULE__, :doc) do\n @doc \"\"\"\n Returns a specification to start this module under a supervisor.\n\n See `Supervisor`.\n \"\"\"\n end\n\n def child_spec(init_arg) do\n default = %{\n id: __MODULE__,\n start: {__MODULE__, :start_link, [init_arg]}\n }\n\n Supervisor.child_spec(default, unquote(Macro.escape(opts)))\n end\n\n defoverridable child_spec: 1\n\n # TODO: Remove this on v2.0\n @before_compile GenServer\n\n @doc false\n def handle_call(msg, _from, state) do\n proc =\n case Process.info(self(), :registered_name) do\n {_, []} -> self()\n {_, name} -> name\n end\n\n # We do this to trick Dialyzer to not complain about non-local returns.\n case :erlang.phash2(1, 1) do\n 0 ->\n raise \"attempted to call GenServer #{inspect(proc)} but no handle_call/3 clause was provided\"\n\n 1 ->\n {:stop, {:bad_call, msg}, state}\n end\n end\n\n @doc false\n def handle_info(msg, state) do\n proc =\n case Process.info(self(), :registered_name) do\n {_, []} -> self()\n {_, name} -> name\n end\n\n :logger.error(\n %{\n label: {GenServer, :no_handle_info},\n report: %{\n module: __MODULE__,\n message: msg,\n name: proc\n }\n },\n %{\n domain: [:otp, :elixir],\n error_logger: %{tag: :error_msg},\n report_cb: &GenServer.format_report/1\n }\n )\n\n {:noreply, state}\n end\n\n @doc false\n def handle_cast(msg, state) do\n proc =\n case Process.info(self(), :registered_name) do\n {_, []} -> self()\n {_, name} -> name\n end\n\n # We do this to trick Dialyzer to not complain about non-local returns.\n case :erlang.phash2(1, 1) do\n 0 ->\n raise \"attempted to cast GenServer #{inspect(proc)} but no handle_cast/2 clause was provided\"\n\n 1 ->\n {:stop, {:bad_cast, msg}, state}\n end\n end\n\n @doc false\n def terminate(_reason, _state) do\n :ok\n end\n\n @doc false\n def code_change(_old, state, _extra) do\n {:ok, state}\n end\n\n defoverridable code_change: 3, terminate: 2, handle_info: 2, handle_cast: 2, handle_call: 3\n end\n end\n\n defmacro __before_compile__(env) do\n if not Module.defines?(env.module, {:init, 1}) do\n message = \"\"\"\n function init/1 required by behaviour GenServer is not implemented \\\n (in module #{inspect(env.module)}).\n\n We will inject a default implementation for now:\n\n def init(init_arg) do\n {:ok, init_arg}\n end\n\n You can copy the implementation above or define your own that converts \\\n the arguments given to GenServer.start_link/3 to the server state.\n \"\"\"\n\n IO.warn(message, env)\n\n quote do\n @doc false\n def init(init_arg) do\n {:ok, init_arg}\n end\n\n defoverridable init: 1\n end\n end\n end\n\n @doc \"\"\"\n Starts a `GenServer` process linked to the current process.\n\n This is often used to start the `GenServer` as part of a supervision tree.\n\n Once the server is started, the `c:init/1` function of the given `module` is\n called with `init_arg` as its argument to initialize the server. To ensure a\n synchronized start-up procedure, this function does not return until `c:init/1`\n has returned.\n\n Note that a `GenServer` started with `start_link/3` is linked to the\n parent process and will exit in case of crashes from the parent. The GenServer\n will also exit due to the `:normal` reasons in case it is configured to trap\n exits in the `c:init/1` callback.\n\n ## Options\n\n * `:name` - used for name registration as described in the \"Name\n registration\" section in the documentation for `GenServer`\n\n * `:timeout` - if present, the server is allowed to spend the given number of\n milliseconds initializing or it will be terminated and the start function\n will return `{:error, :timeout}`\n\n * `:debug` - if present, the corresponding function in the [`:sys` module](`:sys`) is invoked\n\n * `:spawn_opt` - if present, its value is passed as options to the\n underlying process as in `Process.spawn/4`\n\n * `:hibernate_after` - if present, the GenServer process awaits any message for\n the given number of milliseconds and if no message is received, the process goes\n into hibernation automatically (by calling `:proc_lib.hibernate/3`).\n\n ## Return values\n\n If the server is successfully created and initialized, this function returns\n `{:ok, pid}`, where `pid` is the PID of the server. If a process with the\n specified server name already exists, this function returns\n `{:error, {:already_started, pid}}` with the PID of that process.\n\n If the `c:init/1` callback fails with `reason`, this function returns\n `{:error, reason}`. Otherwise, if it returns `{:stop, reason}`\n or `:ignore`, the process is terminated and this function returns\n `{:error, reason}` or `:ignore`, respectively.\n \"\"\"\n @spec start_link(module, term, options) :: on_start\n def start_link(module, init_arg, options \\\\ []) when is_atom(module) and is_list(options) do\n do_start(:link, module, init_arg, options)\n end\n\n @doc \"\"\"\n Starts a `GenServer` process without links (outside of a supervision tree).\n\n See `start_link/3` for more information.\n \"\"\"\n @spec start(module, term, options) :: on_start\n def start(module, init_arg, options \\\\ []) when is_atom(module) and is_list(options) do\n do_start(:nolink, module, init_arg, options)\n end\n\n defp do_start(link, module, init_arg, options) do\n case Keyword.pop(options, :name) do\n {nil, opts} ->\n :gen.start(:gen_server, link, module, init_arg, opts)\n\n {atom, opts} when is_atom(atom) ->\n :gen.start(:gen_server, link, {:local, atom}, module, init_arg, opts)\n\n {{:global, _term} = tuple, opts} ->\n :gen.start(:gen_server, link, tuple, module, init_arg, opts)\n\n {{:via, via_module, _term} = tuple, opts} when is_atom(via_module) ->\n :gen.start(:gen_server, link, tuple, module, init_arg, opts)\n\n {other, _} ->\n raise ArgumentError, \"\"\"\n expected :name option to be one of the following:\n\n * nil\n * atom\n * {:global, term}\n * {:via, module, term}\n\n Got: #{inspect(other)}\n \"\"\"\n end\n end\n\n @doc \"\"\"\n Synchronously stops the server with the given `reason`.\n\n The `c:terminate/2` callback of the given `server` will be invoked before\n exiting. This function returns `:ok` if the server terminates with the\n given reason; if it terminates with another reason, the call exits.\n\n This function keeps OTP semantics regarding error reporting.\n If the reason is any other than `:normal`, `:shutdown` or\n `{:shutdown, _}`, an error report is logged.\n \"\"\"\n @spec stop(server, reason :: term, timeout) :: :ok\n def stop(server, reason \\\\ :normal, timeout \\\\ :infinity) do\n case whereis(server) do\n nil ->\n exit({:noproc, {__MODULE__, :stop, [server, reason, timeout]}})\n\n pid when pid == self() ->\n exit({:calling_self, {__MODULE__, :stop, [server, reason, timeout]}})\n\n pid ->\n try do\n :proc_lib.stop(pid, reason, timeout)\n catch\n :exit, err ->\n exit({err, {__MODULE__, :stop, [server, reason, timeout]}})\n end\n end\n end\n\n @doc \"\"\"\n Makes a synchronous call to the `server` and waits for its reply.\n\n The client sends the given `request` to the server and waits until a reply\n arrives or a timeout occurs. `c:handle_call/3` will be called on the server\n to handle the request.\n\n `server` can be a PID or any of the other values described in the\n \"Name registration\" section of the documentation for this module.\n\n ## Timeouts\n\n `timeout` is an integer greater than zero which specifies how many\n milliseconds to wait for a reply, or the atom `:infinity` to wait\n indefinitely. The default value is `5000`. If no reply is received within\n the specified time, the function call fails and the caller exits. If the\n caller catches the failure and continues running, and the server is just late\n with the reply, it may arrive at any time later into the caller's message\n queue. The caller must in this case be prepared for this and discard any such\n garbage messages that are two-element tuples with a reference as the first\n element.\n \"\"\"\n @spec call(server, term, timeout) :: term\n def call(server, request, timeout \\\\ 5000)\n when (is_integer(timeout) and timeout >= 0) or timeout == :infinity do\n case whereis(server) do\n nil ->\n exit({:noproc, {__MODULE__, :call, [server, request, timeout]}})\n\n pid ->\n try do\n :gen.call(pid, :\"$gen_call\", request, timeout)\n catch\n :exit, reason ->\n exit({reason, {__MODULE__, :call, [server, request, timeout]}})\n else\n {:ok, res} -> res\n end\n end\n end\n\n @doc \"\"\"\n Casts a request to the `server` without waiting for a response.\n\n This function always returns `:ok` regardless of whether\n the destination `server` (or node) exists. Therefore it\n is unknown whether the destination `server` successfully\n handled the request.\n\n `server` can be any of the values described in the \"Name registration\"\n section of the documentation for this module.\n \"\"\"\n @spec cast(server, term) :: :ok\n def cast(server, request)\n\n def cast({:global, name}, request) do\n try do\n :global.send(name, cast_msg(request))\n :ok\n catch\n _, _ -> :ok\n end\n end\n\n def cast({:via, mod, name}, request) do\n try do\n mod.send(name, cast_msg(request))\n :ok\n catch\n _, _ -> :ok\n end\n end\n\n def cast({name, node}, request) when is_atom(name) and is_atom(node),\n do: do_send({name, node}, cast_msg(request))\n\n def cast(dest, request) when is_atom(dest) or is_pid(dest), do: do_send(dest, cast_msg(request))\n\n @doc \"\"\"\n Casts all servers locally registered as `name` at the specified nodes.\n\n This function returns immediately and ignores nodes that do not exist, or where the\n server name does not exist.\n\n See `multi_call/4` for more information.\n \"\"\"\n @spec abcast([node], name :: atom, term) :: :abcast\n def abcast(nodes \\\\ [node() | Node.list()], name, request)\n when is_list(nodes) and is_atom(name) do\n msg = cast_msg(request)\n _ = for node <- nodes, do: do_send({name, node}, msg)\n :abcast\n end\n\n defp cast_msg(req) do\n {:\"$gen_cast\", req}\n end\n\n defp do_send(dest, msg) do\n try do\n send(dest, msg)\n :ok\n catch\n _, _ -> :ok\n end\n end\n\n @doc \"\"\"\n Calls all servers locally registered as `name` at the specified `nodes`.\n\n First, the `request` is sent to every node in `nodes`; then, the caller waits\n for the replies. This function returns a two-element tuple `{replies,\n bad_nodes}` where:\n\n * `replies` - is a list of `{node, reply}` tuples where `node` is the node\n that replied and `reply` is its reply\n * `bad_nodes` - is a list of nodes that either did not exist or where a\n server with the given `name` did not exist or did not reply\n\n `nodes` is a list of node names to which the request is sent. The default\n value is the list of all known nodes (including this node).\n\n ## Examples\n\n Assuming the `Stack` GenServer mentioned in the docs for the `GenServer`\n module is registered as `Stack` in the `:\"foo@my-machine\"` and\n `:\"bar@my-machine\"` nodes:\n\n GenServer.multi_call(Stack, :pop)\n #=> {[{:\"foo@my-machine\", :hello}, {:\"bar@my-machine\", :world}], []}\n\n \"\"\"\n @spec multi_call([node], name :: atom, term, timeout) ::\n {replies :: [{node, term}], bad_nodes :: [node]}\n def multi_call(nodes \\\\ [node() | Node.list()], name, request, timeout \\\\ :infinity) do\n :gen_server.multi_call(nodes, name, request, timeout)\n end\n\n @doc \"\"\"\n Replies to a client.\n\n This function can be used to explicitly send a reply to a client that called\n `call/3` or `multi_call/4` when the reply cannot be specified in the return\n value of `c:handle_call/3`.\n\n `client` must be the `from` argument (the second argument) accepted by\n `c:handle_call/3` callbacks. `reply` is an arbitrary term which will be given\n back to the client as the return value of the call.\n\n Note that `reply/2` can be called from any process, not just the GenServer\n that originally received the call (as long as that GenServer communicated the\n `from` argument somehow).\n\n This function always returns `:ok`.\n\n ## Examples\n\n def handle_call(:reply_in_one_second, from, state) do\n Process.send_after(self(), {:reply, from}, 1_000)\n {:noreply, state}\n end\n\n def handle_info({:reply, from}, state) do\n GenServer.reply(from, :one_second_has_passed)\n {:noreply, state}\n end\n\n \"\"\"\n @spec reply(from, term) :: :ok\n def reply(client, reply) do\n :gen.reply(client, reply)\n end\n\n @doc \"\"\"\n Returns the `pid` or `{name, node}` of a GenServer process, `nil` otherwise.\n\n To be precise, `nil` is returned whenever a `pid` or `{name, node}` cannot\n be returned. Note there is no guarantee the returned `pid` or `{name, node}`\n is alive, as a process could terminate immediately after it is looked up.\n\n ## Examples\n\n For example, to lookup a server process, monitor it and send a cast to it:\n\n process = GenServer.whereis(server)\n monitor = Process.monitor(process)\n GenServer.cast(process, :hello)\n\n \"\"\"\n @spec whereis(server) :: pid | {atom, node} | nil\n def whereis(server)\n\n def whereis(pid) when is_pid(pid), do: pid\n\n def whereis(name) when is_atom(name) do\n Process.whereis(name)\n end\n\n def whereis({:global, name}) do\n case :global.whereis_name(name) do\n pid when is_pid(pid) -> pid\n :undefined -> nil\n end\n end\n\n def whereis({:via, mod, name}) do\n case apply(mod, :whereis_name, [name]) do\n pid when is_pid(pid) -> pid\n :undefined -> nil\n end\n end\n\n def whereis({name, local}) when is_atom(name) and local == node() do\n Process.whereis(name)\n end\n\n def whereis({name, node} = server) when is_atom(name) and is_atom(node) do\n server\n end\n\n @doc false\n def format_report(%{\n label: {GenServer, :no_handle_info},\n report: %{module: mod, message: msg, name: proc}\n }) do\n {~c\"~p ~p received unexpected message in handle_info/2: ~p~n\", [mod, proc, msg]}\n end\nend\n" }, { "path": "lib/elixir/lib/hash_dict.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule HashDict do\n @moduledoc \"\"\"\n Tuple-based HashDict implementation.\n\n This module is deprecated. Use the `Map` module instead.\n \"\"\"\n\n @moduledoc deprecated: \"Use Map instead\"\n\n use Dict\n\n @node_bitmap 0b111\n @node_shift 3\n @node_size 8\n @node_template :erlang.make_tuple(@node_size, [])\n\n @opaque t :: %__MODULE__{size: non_neg_integer, root: term}\n @doc false\n defstruct size: 0, root: @node_template\n\n # Inline common instructions\n @compile :inline_list_funcs\n @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}\n\n message = \"Use maps and the Map module instead\"\n\n @doc \"\"\"\n Creates a new empty dict.\n \"\"\"\n @spec new :: Dict.t()\n @deprecated message\n def new do\n %HashDict{}\n end\n\n @deprecated message\n def put(%HashDict{root: root, size: size}, key, value) do\n {root, counter} = do_put(root, key, value, key_hash(key))\n %HashDict{root: root, size: size + counter}\n end\n\n @deprecated message\n def update!(%HashDict{root: root, size: size} = dict, key, fun) when is_function(fun, 1) do\n {root, counter} =\n do_update(root, key, fn -> raise KeyError, key: key, term: dict end, fun, key_hash(key))\n\n %HashDict{root: root, size: size + counter}\n end\n\n @deprecated message\n def update(%HashDict{root: root, size: size}, key, default, fun) when is_function(fun, 1) do\n {root, counter} = do_update(root, key, fn -> default end, fun, key_hash(key))\n %HashDict{root: root, size: size + counter}\n end\n\n @deprecated message\n def fetch(%HashDict{root: root}, key) do\n do_fetch(root, key, key_hash(key))\n end\n\n @deprecated message\n def delete(dict, key) do\n case dict_delete(dict, key) do\n {dict, _value} -> dict\n :error -> dict\n end\n end\n\n @deprecated message\n def pop(dict, key, default \\\\ nil) do\n case dict_delete(dict, key) do\n {dict, value} -> {value, dict}\n :error -> {default, dict}\n end\n end\n\n @deprecated message\n def size(%HashDict{size: size}) do\n size\n end\n\n @doc false\n @deprecated message\n def reduce(%HashDict{root: root}, acc, fun) do\n do_reduce(root, acc, fun, @node_size, fn\n {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}\n {:halt, acc} -> {:halted, acc}\n {:cont, acc} -> {:done, acc}\n end)\n end\n\n ## General helpers\n\n @doc false\n def dict_delete(%HashDict{root: root, size: size}, key) do\n case do_delete(root, key, key_hash(key)) do\n {root, value} -> {%HashDict{root: root, size: size - 1}, value}\n :error -> :error\n end\n end\n\n ## Dict manipulation\n\n defp do_fetch(node, key, hash) do\n index = key_mask(hash)\n\n case elem(node, index) do\n [^key | v] -> {:ok, v}\n {^key, v, _} -> {:ok, v}\n {_, _, n} -> do_fetch(n, key, key_shift(hash))\n _ -> :error\n end\n end\n\n defp do_put(node, key, value, hash) do\n index = key_mask(hash)\n\n case elem(node, index) do\n [] ->\n {put_elem(node, index, [key | value]), 1}\n\n [^key | _] ->\n {put_elem(node, index, [key | value]), 0}\n\n [k | v] ->\n n = put_elem(@node_template, key_mask(key_shift(hash)), [key | value])\n {put_elem(node, index, {k, v, n}), 1}\n\n {^key, _, n} ->\n {put_elem(node, index, {key, value, n}), 0}\n\n {k, v, n} ->\n {n, counter} = do_put(n, key, value, key_shift(hash))\n {put_elem(node, index, {k, v, n}), counter}\n end\n end\n\n defp do_update(node, key, default, fun, hash) do\n index = key_mask(hash)\n\n case elem(node, index) do\n [] ->\n {put_elem(node, index, [key | default.()]), 1}\n\n [^key | value] ->\n {put_elem(node, index, [key | fun.(value)]), 0}\n\n [k | v] ->\n n = put_elem(@node_template, key_mask(key_shift(hash)), [key | default.()])\n {put_elem(node, index, {k, v, n}), 1}\n\n {^key, value, n} ->\n {put_elem(node, index, {key, fun.(value), n}), 0}\n\n {k, v, n} ->\n {n, counter} = do_update(n, key, default, fun, key_shift(hash))\n {put_elem(node, index, {k, v, n}), counter}\n end\n end\n\n defp do_delete(node, key, hash) do\n index = key_mask(hash)\n\n case elem(node, index) do\n [] ->\n :error\n\n [^key | value] ->\n {put_elem(node, index, []), value}\n\n [_ | _] ->\n :error\n\n {^key, value, n} ->\n {put_elem(node, index, do_compact_node(n)), value}\n\n {k, v, n} ->\n case do_delete(n, key, key_shift(hash)) do\n {@node_template, value} ->\n {put_elem(node, index, [k | v]), value}\n\n {n, value} ->\n {put_elem(node, index, {k, v, n}), value}\n\n :error ->\n :error\n end\n end\n end\n\n Enum.each(0..(@node_size - 1), fn index ->\n defp do_compact_node(node) when elem(node, unquote(index)) != [] do\n case elem(node, unquote(index)) do\n [k | v] ->\n case put_elem(node, unquote(index), []) do\n @node_template -> [k | v]\n n -> {k, v, n}\n end\n\n {k, v, n} ->\n {k, v, put_elem(node, unquote(index), do_compact_node(n))}\n end\n end\n end)\n\n ## Dict reduce\n\n defp do_reduce_each(_node, {:halt, acc}, _fun, _next) do\n {:halted, acc}\n end\n\n defp do_reduce_each(node, {:suspend, acc}, fun, next) do\n {:suspended, acc, &do_reduce_each(node, &1, fun, next)}\n end\n\n defp do_reduce_each([], acc, _fun, next) do\n next.(acc)\n end\n\n defp do_reduce_each([k | v], {:cont, acc}, fun, next) do\n next.(fun.({k, v}, acc))\n end\n\n defp do_reduce_each({k, v, n}, {:cont, acc}, fun, next) do\n do_reduce(n, fun.({k, v}, acc), fun, @node_size, next)\n end\n\n defp do_reduce(node, acc, fun, count, next) when count > 0 do\n do_reduce_each(\n :erlang.element(count, node),\n acc,\n fun,\n &do_reduce(node, &1, fun, count - 1, next)\n )\n end\n\n defp do_reduce(_node, acc, _fun, 0, next) do\n next.(acc)\n end\n\n ## Key operations\n\n import Bitwise\n\n defp key_hash(key) do\n :erlang.phash2(key)\n end\n\n defp key_mask(hash) do\n hash &&& @node_bitmap\n end\n\n defp key_shift(hash) do\n hash >>> @node_shift\n end\nend\n\ndefimpl Enumerable, for: HashDict do\n @moduledoc false\n @moduledoc deprecated: \"Use Map instead\"\n\n def reduce(dict, acc, fun) do\n # Avoid warnings about HashDict being deprecated.\n module = String.to_atom(\"HashDict\")\n module.reduce(dict, acc, fun)\n end\n\n def member?(dict, {key, value}) do\n # Avoid warnings about HashDict being deprecated.\n module = String.to_atom(\"HashDict\")\n {:ok, match?({:ok, ^value}, module.fetch(dict, key))}\n end\n\n def member?(_dict, _) do\n {:ok, false}\n end\n\n def count(dict) do\n # Avoid warnings about HashDict being deprecated.\n module = String.to_atom(\"HashDict\")\n {:ok, module.size(dict)}\n end\n\n def slice(_dict) do\n {:error, __MODULE__}\n end\nend\n\ndefimpl Collectable, for: HashDict do\n @moduledoc false\n @moduledoc deprecated: \"Use Map instead\"\n\n def into(original) do\n # Avoid warnings about HashDict being deprecated.\n module = String.to_atom(\"HashDict\")\n\n collector_fun = fn\n dict, {:cont, {key, value}} -> module.put(dict, key, value)\n dict, :done -> dict\n _, :halt -> :ok\n end\n\n {original, collector_fun}\n end\nend\n\ndefimpl Inspect, for: HashDict do\n @moduledoc false\n @moduledoc deprecated: \"Use Map instead\"\n import Inspect.Algebra\n\n def inspect(dict, opts) do\n # Avoid warnings about HashDict being deprecated.\n module = String.to_atom(\"HashDict\")\n concat([\"#HashDict<\", Inspect.List.inspect(module.to_list(dict), opts), \">\"])\n end\nend\n" }, { "path": "lib/elixir/lib/hash_set.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule HashSet do\n @moduledoc \"\"\"\n Tuple-based HashSet implementation.\n\n This module is deprecated. Use the `MapSet` module instead.\n \"\"\"\n\n @moduledoc deprecated: \"Use MapSet instead\"\n\n @node_bitmap 0b111\n @node_shift 3\n @node_size 8\n @node_template :erlang.make_tuple(@node_size, [])\n\n message = \"Use the MapSet module instead\"\n\n @opaque t :: %__MODULE__{size: non_neg_integer, root: term}\n @doc false\n defstruct size: 0, root: @node_template\n\n # Inline common instructions\n @compile :inline_list_funcs\n @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}\n\n @deprecated message\n @spec new :: Set.t()\n def new do\n %HashSet{}\n end\n\n @deprecated message\n def union(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) when size1 <= size2 do\n set_fold(set1, set2, fn v, acc -> put(acc, v) end)\n end\n\n @deprecated message\n def union(%HashSet{} = set1, %HashSet{} = set2) do\n set_fold(set2, set1, fn v, acc -> put(acc, v) end)\n end\n\n @deprecated message\n def intersection(%HashSet{} = set1, %HashSet{} = set2) do\n set_fold(set1, %HashSet{}, fn v, acc ->\n if member?(set2, v), do: put(acc, v), else: acc\n end)\n end\n\n @deprecated message\n def difference(%HashSet{} = set1, %HashSet{} = set2) do\n set_fold(set2, set1, fn v, acc -> delete(acc, v) end)\n end\n\n @deprecated message\n def to_list(set) do\n set_fold(set, [], &[&1 | &2]) |> :lists.reverse()\n end\n\n @deprecated message\n def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do\n case size1 do\n ^size2 -> subset?(set1, set2)\n _ -> false\n end\n end\n\n @deprecated message\n def subset?(%HashSet{} = set1, %HashSet{} = set2) do\n reduce(set1, {:cont, true}, fn member, acc ->\n case member?(set2, member) do\n true -> {:cont, acc}\n _ -> {:halt, false}\n end\n end)\n |> elem(1)\n end\n\n @deprecated message\n def disjoint?(%HashSet{} = set1, %HashSet{} = set2) do\n reduce(set2, {:cont, true}, fn member, acc ->\n case member?(set1, member) do\n false -> {:cont, acc}\n _ -> {:halt, false}\n end\n end)\n |> elem(1)\n end\n\n @deprecated message\n def member?(%HashSet{root: root}, term) do\n do_member?(root, term, key_hash(term))\n end\n\n @deprecated message\n def put(%HashSet{root: root, size: size}, term) do\n {root, counter} = do_put(root, term, key_hash(term))\n %HashSet{root: root, size: size + counter}\n end\n\n @deprecated message\n def delete(%HashSet{root: root, size: size} = set, term) do\n case do_delete(root, term, key_hash(term)) do\n {:ok, root} -> %HashSet{root: root, size: size - 1}\n :error -> set\n end\n end\n\n @doc false\n def reduce(%HashSet{root: root}, acc, fun) do\n do_reduce(root, acc, fun, @node_size, fn\n {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}\n {:halt, acc} -> {:halted, acc}\n {:cont, acc} -> {:done, acc}\n end)\n end\n\n @deprecated message\n def size(%HashSet{size: size}) do\n size\n end\n\n ## Set helpers\n\n defp set_fold(%HashSet{root: root}, acc, fun) do\n do_fold(root, acc, fun, @node_size)\n end\n\n ## Set manipulation\n\n defp do_member?(node, term, hash) do\n index = key_mask(hash)\n\n case elem(node, index) do\n [] -> false\n [^term | _] -> true\n [_] -> false\n [_ | n] -> do_member?(n, term, key_shift(hash))\n end\n end\n\n defp do_put(node, term, hash) do\n index = key_mask(hash)\n\n case elem(node, index) do\n [] ->\n {put_elem(node, index, [term]), 1}\n\n [^term | _] ->\n {node, 0}\n\n [t] ->\n n = put_elem(@node_template, key_mask(key_shift(hash)), [term])\n {put_elem(node, index, [t | n]), 1}\n\n [t | n] ->\n {n, counter} = do_put(n, term, key_shift(hash))\n {put_elem(node, index, [t | n]), counter}\n end\n end\n\n defp do_delete(node, term, hash) do\n index = key_mask(hash)\n\n case elem(node, index) do\n [] ->\n :error\n\n [^term] ->\n {:ok, put_elem(node, index, [])}\n\n [_] ->\n :error\n\n [^term | n] ->\n {:ok, put_elem(node, index, do_compact_node(n))}\n\n [t | n] ->\n case do_delete(n, term, key_shift(hash)) do\n {:ok, @node_template} ->\n {:ok, put_elem(node, index, [t])}\n\n {:ok, n} ->\n {:ok, put_elem(node, index, [t | n])}\n\n :error ->\n :error\n end\n end\n end\n\n Enum.each(0..(@node_size - 1), fn index ->\n defp do_compact_node(node) when elem(node, unquote(index)) != [] do\n case elem(node, unquote(index)) do\n [t] ->\n case put_elem(node, unquote(index), []) do\n @node_template -> [t]\n n -> [t | n]\n end\n\n [t | n] ->\n [t | put_elem(node, unquote(index), do_compact_node(n))]\n end\n end\n end)\n\n ## Set fold\n\n defp do_fold_each([], acc, _fun), do: acc\n defp do_fold_each([t], acc, fun), do: fun.(t, acc)\n defp do_fold_each([t | n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)\n\n defp do_fold(node, acc, fun, count) when count > 0 do\n acc = do_fold_each(:erlang.element(count, node), acc, fun)\n do_fold(node, acc, fun, count - 1)\n end\n\n defp do_fold(_node, acc, _fun, 0) do\n acc\n end\n\n ## Set reduce\n\n defp do_reduce_each(_node, {:halt, acc}, _fun, _next) do\n {:halted, acc}\n end\n\n defp do_reduce_each(node, {:suspend, acc}, fun, next) do\n {:suspended, acc, &do_reduce_each(node, &1, fun, next)}\n end\n\n defp do_reduce_each([], acc, _fun, next) do\n next.(acc)\n end\n\n defp do_reduce_each([t], {:cont, acc}, fun, next) do\n next.(fun.(t, acc))\n end\n\n defp do_reduce_each([t | n], {:cont, acc}, fun, next) do\n do_reduce(n, fun.(t, acc), fun, @node_size, next)\n end\n\n defp do_reduce(node, acc, fun, count, next) when count > 0 do\n do_reduce_each(\n :erlang.element(count, node),\n acc,\n fun,\n &do_reduce(node, &1, fun, count - 1, next)\n )\n end\n\n defp do_reduce(_node, acc, _fun, 0, next) do\n next.(acc)\n end\n\n ## Key operations\n\n import Bitwise\n\n defp key_hash(key) do\n :erlang.phash2(key)\n end\n\n defp key_mask(hash) do\n hash &&& @node_bitmap\n end\n\n defp key_shift(hash) do\n hash >>> @node_shift\n end\nend\n\ndefimpl Enumerable, for: HashSet do\n @moduledoc false\n @moduledoc deprecated: \"Use MapSet instead\"\n\n def reduce(set, acc, fun) do\n # Avoid warnings about HashSet being deprecated.\n module = String.to_atom(\"HashSet\")\n module.reduce(set, acc, fun)\n end\n\n def member?(set, term) do\n # Avoid warnings about HashSet being deprecated.\n module = String.to_atom(\"HashSet\")\n {:ok, module.member?(set, term)}\n end\n\n def count(set) do\n # Avoid warnings about HashSet being deprecated.\n module = String.to_atom(\"HashSet\")\n {:ok, module.size(set)}\n end\n\n def slice(_set) do\n {:error, __MODULE__}\n end\nend\n\ndefimpl Collectable, for: HashSet do\n @moduledoc false\n @moduledoc deprecated: \"Use MapSet instead\"\n\n def into(original) do\n # Avoid warnings about HashSet being deprecated.\n module = String.to_atom(\"HashSet\")\n\n collector_fun = fn\n set, {:cont, term} -> module.put(set, term)\n set, :done -> set\n _, :halt -> :ok\n end\n\n {original, collector_fun}\n end\nend\n\ndefimpl Inspect, for: HashSet do\n @moduledoc false\n @moduledoc deprecated: \"Use MapSet instead\"\n import Inspect.Algebra\n\n def inspect(set, opts) do\n # Avoid warnings about HashSet being deprecated.\n module = String.to_atom(\"HashSet\")\n concat([\"#HashSet<\", Inspect.List.inspect(module.to_list(set), opts), \">\"])\n end\nend\n" }, { "path": "lib/elixir/lib/inspect/algebra.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Inspect.Opts do\n @moduledoc \"\"\"\n Defines the options used by the `Inspect` protocol.\n\n The following fields are available:\n\n * `:base` - prints integers and binaries as `:binary`, `:octal`, `:decimal`,\n or `:hex`. Defaults to `:decimal`.\n\n * `:binaries` - when `:as_binaries` all binaries will be printed in bit\n syntax.\n\n When `:as_strings` all binaries will be printed as strings, non-printable\n bytes will be escaped.\n\n When the default `:infer`, the binary will be printed as a string if `:base`\n is `:decimal` and if it is printable, otherwise in bit syntax. See\n `String.printable?/1` to learn when a string is printable.\n\n * `:charlists` - when `:as_charlists` all lists will be printed as charlists,\n non-printable elements will be escaped.\n\n When `:as_lists` all lists will be printed as lists.\n\n When the default `:infer`, the list will be printed as a charlist if it\n is printable, otherwise as list. See `List.ascii_printable?/1` to learn\n when a charlist is printable.\n\n * `:custom_options` (since v1.9.0) - a keyword list storing custom user-defined\n options. Useful when implementing the `Inspect` protocol for nested structs\n to pass the custom options through.\n\n It supports some pre-defined keys:\n\n - `:sort_maps` (since v1.14.4) - if set to `true`, sorts key-value pairs\n in maps. This can be helpful to make map inspection deterministic for\n testing, given maps key order is random.\n\n * `:inspect_fun` (since v1.9.0) - a function to build algebra documents.\n Defaults to `Inspect.Opts.default_inspect_fun/0`.\n\n * `:limit` - limits the number of items that are inspected for tuples,\n bitstrings, maps, lists and any other collection of items, with the exception of\n printable strings and printable charlists which use the `:printable_limit` option.\n It accepts a positive integer or `:infinity`. It defaults to `100` since\n `Elixir v1.19.0`, as it has better defaults to deal with nested collections.\n\n * `:pretty` - if set to `true` enables pretty printing. Defaults to `false`.\n\n * `:printable_limit` - limits the number of characters that are inspected\n on printable strings and printable charlists. You can use `String.printable?/1`\n and `List.ascii_printable?/1` to check if a given string or charlist is\n printable. If you don't want to limit the number of characters to a particular\n number, use `:infinity`. It accepts a positive integer or `:infinity`.\n Defaults to `4096`.\n\n * `:safe` - when `false`, failures while inspecting structs will be raised\n as errors instead of being wrapped in the `Inspect.Error` exception. This\n is useful when debugging failures and crashes for custom inspect\n implementations. Defaults to `true`.\n\n * `:structs` - when `false`, structs are not formatted by the inspect\n protocol, they are instead printed as maps. Defaults to `true`.\n\n * `:syntax_colors` - when set to a keyword list of colors the output is\n colorized. The keys are types and the values are the colors to use for\n each type (for example, `[number: :red, atom: :blue]`). Types can include\n `:atom`, `:binary`, `:boolean`, `:list`, `:map`, `:number`, `:regex`,\n `:string`, `:tuple`, or some types to represent AST like `:variable`,\n `:call`, and `:operator`.\n Custom data types may provide their own options.\n Colors can be any `t:IO.ANSI.ansidata/0` as accepted by `IO.ANSI.format/1`.\n A default list of colors can be retrieved from `IO.ANSI.syntax_colors/0`.\n\n * `:width` - number of characters per line used when pretty is `true` or when\n printing to IO devices. Set to `0` to force each item to be printed on its\n own line. If you don't want to limit the number of items to a particular\n number, use `:infinity`. Defaults to `80`.\n\n \"\"\"\n\n # TODO: Remove :char_lists key on v2.0\n defstruct base: :decimal,\n binaries: :infer,\n char_lists: :infer,\n charlists: :infer,\n custom_options: [],\n inspect_fun: &Inspect.inspect/2,\n limit: 100,\n pretty: false,\n printable_limit: 4096,\n safe: true,\n structs: true,\n syntax_colors: [],\n width: 80\n\n @type color_key :: atom\n\n @type t :: %__MODULE__{\n base: :decimal | :binary | :hex | :octal,\n binaries: :infer | :as_binaries | :as_strings,\n charlists: :infer | :as_lists | :as_charlists,\n custom_options: keyword,\n inspect_fun: (any, t -> Inspect.Algebra.t()),\n limit: non_neg_integer | :infinity,\n pretty: boolean,\n printable_limit: non_neg_integer | :infinity,\n safe: boolean,\n structs: boolean,\n syntax_colors: [{color_key, IO.ANSI.ansidata()}],\n width: non_neg_integer | :infinity\n }\n\n @typedoc \"\"\"\n Options for building an `Inspect.Opts` struct with `new/1`.\n \"\"\"\n @type new_opt ::\n {:base, :decimal | :binary | :hex | :octal}\n | {:binaries, :infer | :as_binaries | :as_strings}\n | {:charlists, :infer | :as_lists | :as_charlists}\n | {:custom_options, keyword}\n | {:inspect_fun, (any, t -> Inspect.Algebra.t())}\n | {:limit, non_neg_integer | :infinity}\n | {:pretty, boolean}\n | {:printable_limit, non_neg_integer | :infinity}\n | {:safe, boolean}\n | {:structs, boolean}\n | {:syntax_colors, [{color_key, IO.ANSI.ansidata()}]}\n | {:width, non_neg_integer | :infinity}\n\n @doc \"\"\"\n Builds an `Inspect.Opts` struct.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec new([new_opt()]) :: t\n def new(opts) do\n struct(%Inspect.Opts{inspect_fun: default_inspect_fun()}, opts)\n end\n\n @doc \"\"\"\n Returns the default inspect function.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec default_inspect_fun() :: (term, t -> Inspect.Algebra.t())\n def default_inspect_fun do\n :persistent_term.get({__MODULE__, :inspect_fun}, &Inspect.inspect/2)\n end\n\n @doc \"\"\"\n Sets the default inspect function.\n\n Set this option with care as it will change how all values\n in the system are inspected. The main use of this functionality\n is to provide an entry point to filter inspected values,\n in order for entities to comply with rules and legislations\n on data security and data privacy.\n\n It is **extremely discouraged** for libraries to set their own\n function as this must be controlled by applications. Libraries\n should instead define their own structs with custom inspect\n implementations. If a library must change the default inspect\n function, then it is best to ask users of your library to explicitly\n call `default_inspect_fun/1` with your function of choice.\n\n The default is `Inspect.inspect/2`.\n\n ## Examples\n\n previous_fun = Inspect.Opts.default_inspect_fun()\n\n Inspect.Opts.default_inspect_fun(fn\n %{address: _} = map, opts ->\n previous_fun.(%{map | address: \"[REDACTED]\"}, opts)\n\n value, opts ->\n previous_fun.(value, opts)\n end)\n\n \"\"\"\n @doc since: \"1.13.0\"\n @spec default_inspect_fun((term, t -> Inspect.Algebra.t())) :: :ok\n def default_inspect_fun(fun) when is_function(fun, 2) do\n :persistent_term.put({__MODULE__, :inspect_fun}, fun)\n end\nend\n\ndefmodule Inspect.Algebra do\n @moduledoc ~S\"\"\"\n A set of functions for creating and manipulating algebra\n documents.\n\n This module implements the functionality described in\n [\"Strictly Pretty\" (2000) by Christian Lindig][0] with small\n additions, like support for binary nodes and a break mode that\n maximises use of horizontal space.\n\n iex> Inspect.Algebra.line()\n :doc_line\n\n iex> \"foo\"\n \"foo\"\n\n With the functions in this module, we can concatenate different\n elements together and render them:\n\n iex> doc = Inspect.Algebra.concat(Inspect.Algebra.empty(), \"foo\")\n iex> Inspect.Algebra.format(doc, 80)\n \"foo\"\n\n The functions `nest/2`, `space/2` and `line/2` help you put the\n document together into a rigid structure. However, the document\n algebra gets interesting when using functions like `glue/3` and\n `group/1`. A glue inserts a break between two documents. A group\n indicates a document that must fit the current line, otherwise\n breaks are rendered as new lines. Let's glue two docs together\n with a break, group it and then render it:\n\n iex> doc = Inspect.Algebra.glue(\"a\", \" \", \"b\")\n iex> doc = Inspect.Algebra.group(doc)\n iex> Inspect.Algebra.format(doc, 80)\n \"a b\"\n\n Note that the break was represented as is, because we haven't reached\n a line limit. Once we do, it is replaced by a newline:\n\n iex> doc = Inspect.Algebra.glue(String.duplicate(\"a\", 20), \" \", \"b\")\n iex> doc = Inspect.Algebra.group(doc)\n iex> Inspect.Algebra.format(doc, 10)\n \"aaaaaaaaaaaaaaaaaaaa\\nb\"\n\n This module uses the byte size to compute how much space there is\n left. If your document contains strings, then those need to be\n wrapped in `string/1`, which then relies on `String.length/1` to\n precompute the document size.\n\n Finally, this module also contains Elixir related functions, a bit\n tied to Elixir formatting, such as `to_doc/2`.\n\n ## Implementation details\n\n The implementation of `Inspect.Algebra` is based on the Strictly Pretty\n paper by [Lindig][0] which builds on top of previous pretty printing\n algorithms but is tailored to strict languages, such as Elixir.\n The core idea in the paper is the use of explicit document groups which\n are rendered as flat (breaks as spaces) or as break (breaks as newlines).\n\n This implementation provides two types of breaks: `:strict` and `:flex`.\n When a group does not fit, all strict breaks are treated as newlines.\n Flex breaks, however, are re-evaluated on every occurrence and may still\n be rendered flat. See `break/1` and `flex_break/1` for more information.\n\n This implementation also adds `force_unfit/1` and optimistic/pessimistic\n groups which give more control over the document fitting.\n\n [0]: https://lindig.github.io/papers/strictly-pretty-2000.pdf\n\n \"\"\"\n\n @container_separator \",\"\n @tail_separator \" |\"\n @newline \"\\n\"\n\n # Functional interface to \"doc\" records\n\n @type t ::\n binary\n | doc_nil\n | doc_cons\n | doc_line\n | doc_break\n | doc_collapse\n | doc_color\n | doc_fits\n | doc_force\n | doc_group\n | doc_nest\n | doc_string\n | doc_limit\n\n @typep doc_nil :: []\n defmacrop doc_nil do\n []\n end\n\n @typep doc_line :: :doc_line\n defmacrop doc_line do\n :doc_line\n end\n\n @typep doc_cons :: nonempty_improper_list(t, t)\n defmacrop doc_cons(left, right) do\n quote do: [unquote(left) | unquote(right)]\n end\n\n @typep doc_string :: {:doc_string, binary, non_neg_integer}\n defmacrop doc_string(string, length) do\n quote do: {:doc_string, unquote(string), unquote(length)}\n end\n\n @typep doc_limit :: {:doc_limit, t, pos_integer | :infinity}\n defmacrop doc_limit(doc, limit) do\n quote do: {:doc_limit, unquote(doc), unquote(limit)}\n end\n\n @typep doc_nest :: {:doc_nest, t, :cursor | :reset | non_neg_integer, :always | :break}\n defmacrop doc_nest(doc, indent, always_or_break) do\n quote do: {:doc_nest, unquote(doc), unquote(indent), unquote(always_or_break)}\n end\n\n @typep doc_break :: {:doc_break, binary, :flex | :strict}\n defmacrop doc_break(break, mode) do\n quote do: {:doc_break, unquote(break), unquote(mode)}\n end\n\n @typep doc_group :: {:doc_group, t, :normal | :optimistic | :pessimistic | :inherit}\n defmacrop doc_group(group, mode) do\n quote do: {:doc_group, unquote(group), unquote(mode)}\n end\n\n @typep doc_fits :: {:doc_fits, t, :enabled | :disabled}\n defmacrop doc_fits(group, mode) do\n quote do: {:doc_fits, unquote(group), unquote(mode)}\n end\n\n @typep doc_force :: {:doc_force, t}\n defmacrop doc_force(group) do\n quote do: {:doc_force, unquote(group)}\n end\n\n @typep doc_collapse :: {:doc_collapse, pos_integer()}\n defmacrop doc_collapse(count) do\n quote do: {:doc_collapse, unquote(count)}\n end\n\n @typep doc_color :: {:doc_color, t, IO.ANSI.ansidata()}\n defmacrop doc_color(doc, color) do\n quote do: {:doc_color, unquote(doc), unquote(color)}\n end\n\n @typedoc \"\"\"\n Options for container documents.\n \"\"\"\n @type container_opts :: [\n separator: String.t(),\n break: :strict | :flex | :maybe\n ]\n\n @docs [\n :doc_break,\n :doc_collapse,\n :doc_color,\n :doc_cons,\n :doc_fits,\n :doc_force,\n :doc_group,\n :doc_nest,\n :doc_string,\n :doc_limit\n ]\n\n defguard is_doc(doc)\n when is_list(doc) or is_binary(doc) or doc == doc_line() or\n (is_tuple(doc) and elem(doc, 0) in @docs)\n\n defguardp is_width(width) when width == :infinity or (is_integer(width) and width >= 0)\n\n # Elixir + Inspect.Opts conveniences\n # These have the _doc suffix.\n\n @doc \"\"\"\n Converts an Elixir term to an algebra document\n according to the `Inspect` protocol.\n\n In practice, one must prefer to use `to_doc_with_opts/2`\n over this function, as `to_doc_with_opts/2` returns the\n updated options from inspection.\n \"\"\"\n @spec to_doc(any, Inspect.Opts.t()) :: t\n def to_doc(term, opts) do\n to_doc_with_opts(term, opts) |> elem(0)\n end\n\n @doc \"\"\"\n Converts an Elixir term to an algebra document\n according to the `Inspect` protocol, alongside the updated options.\n\n This function is used when implementing the inspect protocol for\n a given type and you must convert nested terms to documents too.\n \"\"\"\n @doc since: \"1.19.0\"\n @spec to_doc_with_opts(any, Inspect.Opts.t()) :: {t, Inspect.Opts.t()}\n def to_doc_with_opts(term, opts)\n\n def to_doc_with_opts(%_{} = struct, %Inspect.Opts{inspect_fun: fun} = opts) do\n if opts.structs and valid_struct?(struct) do\n try do\n fun.(struct, opts)\n rescue\n caught_exception ->\n # Because we try to raise a nice error message in case\n # we can't inspect a struct, there is a chance the error\n # message itself relies on the struct being printed, so\n # we need to trap the inspected messages to guarantee\n # we won't try to render any failed instruct when building\n # the error message.\n if Process.get(:inspect_trap) do\n Inspect.Map.inspect_as_map(struct, opts)\n else\n try do\n Process.put(:inspect_trap, true)\n\n {doc_struct, _opts} =\n Inspect.Map.inspect_as_map(struct, %{\n opts\n | syntax_colors: [],\n inspect_fun: Inspect.Opts.default_inspect_fun()\n })\n\n inspected_struct =\n doc_struct\n |> format(opts.width)\n |> IO.iodata_to_binary()\n\n inspect_error =\n Inspect.Error.exception(\n exception: caught_exception,\n stacktrace: __STACKTRACE__,\n inspected_struct: inspected_struct\n )\n\n if opts.safe do\n opts = %{opts | inspect_fun: Inspect.Opts.default_inspect_fun()}\n Inspect.inspect(inspect_error, opts)\n else\n reraise(inspect_error, __STACKTRACE__)\n end\n after\n Process.delete(:inspect_trap)\n end\n end\n end\n else\n Inspect.Map.inspect_as_map(struct, opts)\n end\n |> pack_opts(opts)\n end\n\n def to_doc_with_opts(arg, %Inspect.Opts{inspect_fun: fun} = opts) do\n fun.(arg, opts) |> pack_opts(opts)\n end\n\n defp valid_struct?(%module{} = struct) do\n try do\n module.__info__(:struct)\n rescue\n _ -> false\n else\n info ->\n valid_struct?(info, struct, map_size(struct) - 1)\n end\n end\n\n defp valid_struct?([%{field: field} | info], struct, count) when is_map_key(struct, field),\n do: valid_struct?(info, struct, count - 1)\n\n defp valid_struct?([], _struct, 0),\n do: true\n\n defp valid_struct?(_fields, _struct, _count),\n do: false\n\n defp pack_opts({_doc, %Inspect.Opts{}} = doc_opts, _opts), do: doc_opts\n defp pack_opts(doc, opts), do: {doc, opts}\n\n @doc ~S\"\"\"\n Wraps `collection` in `left` and `right` according to limit and contents\n and returns only the container document.\n\n In practice, one must prefer to use `container_doc_with_opts/6`\n over this function, as `container_doc_with_opts/6` returns the\n updated options from inspection.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec container_doc(\n t,\n [term],\n t,\n Inspect.Opts.t(),\n (term, Inspect.Opts.t() -> t),\n container_opts()\n ) ::\n t\n def container_doc(left, collection, right, inspect_opts, fun, opts \\\\ []) do\n container_doc_with_opts(left, collection, right, inspect_opts, fun, opts) |> elem(0)\n end\n\n @doc ~S\"\"\"\n Wraps `collection` in `left` and `right` according to limit and contents.\n\n It uses the given `left` and `right` documents as surrounding and the\n separator document `separator` to separate items in `docs`. If all entries\n in the collection are simple documents (texts or strings), then this function\n attempts to put as much as possible on the same line. If they are not simple,\n only one entry is shown per line if they do not fit.\n\n The limit in the given `inspect_opts` is respected and when reached this\n function stops processing and outputs `\"...\"` instead.\n\n It returns a tuple with the algebra document and the updated options.\n\n ## Options\n\n * `:separator` - the separator used between each doc\n * `:break` - If `:strict`, always break between each element. If `:flex`,\n breaks only when necessary. If `:maybe`, chooses `:flex` only if all\n elements are text-based, otherwise is `:strict`\n\n ## Examples\n\n iex> inspect_opts = %Inspect.Opts{limit: :infinity}\n iex> fun = fn i, _opts -> to_string(i) end\n iex> {doc, _opts} = Inspect.Algebra.container_doc_with_opts(\"[\", Enum.to_list(1..5), \"]\", inspect_opts, fun)\n iex> Inspect.Algebra.format(doc, 5) |> IO.iodata_to_binary()\n \"[1,\\n 2,\\n 3,\\n 4,\\n 5]\"\n\n iex> inspect_opts = %Inspect.Opts{limit: 3}\n iex> fun = fn i, _opts -> to_string(i) end\n iex> {doc, _opts} = Inspect.Algebra.container_doc_with_opts(\"[\", Enum.to_list(1..5), \"]\", inspect_opts, fun)\n iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary()\n \"[1, 2, 3, ...]\"\n\n iex> inspect_opts = %Inspect.Opts{limit: 3}\n iex> fun = fn i, _opts -> to_string(i) end\n iex> opts = [separator: \"!\"]\n iex> {doc, _opts} = Inspect.Algebra.container_doc_with_opts(\"[\", Enum.to_list(1..5), \"]\", inspect_opts, fun, opts)\n iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary()\n \"[1! 2! 3! ...]\"\n\n \"\"\"\n @doc since: \"1.19.0\"\n @spec container_doc_with_opts(\n t,\n [term],\n t,\n Inspect.Opts.t(),\n (term, Inspect.Opts.t() -> t),\n container_opts()\n ) ::\n {t, Inspect.Opts.t()}\n def container_doc_with_opts(left, collection, right, inspect_opts, fun, opts \\\\ [])\n when is_doc(left) and is_list(collection) and is_doc(right) and is_function(fun, 2) and\n is_list(opts) do\n case collection do\n [] ->\n {concat(left, right), inspect_opts}\n\n _ ->\n break = Keyword.get(opts, :break, :maybe)\n separator = Keyword.get(opts, :separator, @container_separator)\n\n {docs, simple?, inspect_opts} =\n container_each(collection, inspect_opts, fun, [], break == :maybe)\n\n flex? = simple? or break == :flex\n docs = fold(docs, &join(&1, &2, flex?, separator))\n\n group =\n case flex? do\n true -> doc_group(concat(concat(left, nest(docs, 1)), right), :normal)\n false -> doc_group(glue(nest(glue(left, \"\", docs), 2), \"\", right), :normal)\n end\n\n {group, inspect_opts}\n end\n end\n\n defp container_each([], opts, _fun, acc, simple?) do\n {:lists.reverse(acc), simple?, opts}\n end\n\n defp container_each(_, opts, _fun, acc, simple?) when opts.limit <= 0 do\n {:lists.reverse([\"...\" | acc]), simple?, opts}\n end\n\n defp container_each([term | terms], opts, fun, acc, simple?) when is_list(terms) do\n {doc, opts} = call_container_fun(fun, term, opts)\n container_each(terms, opts, fun, [doc | acc], simple? and simple?(doc))\n end\n\n defp container_each([left | right], opts, fun, acc, simple?) do\n {left, opts} = call_container_fun(fun, left, opts)\n {right, _opts} = call_container_fun(fun, right, opts)\n simple? = simple? and simple?(left) and simple?(right)\n doc = join(left, right, simple?, @tail_separator)\n {:lists.reverse([doc | acc]), simple?, opts}\n end\n\n defp call_container_fun(fun, term, %{limit: bounded} = opts)\n when bounded <= 0 or bounded == :infinity do\n case fun.(term, opts) do\n {doc, %Inspect.Opts{} = opts} -> {doc, opts}\n doc -> {doc, opts}\n end\n end\n\n defp call_container_fun(fun, term, %{limit: limit} = opts) do\n changed_opts = %{opts | limit: limit - 1}\n\n case fun.(term, changed_opts) do\n {doc, %Inspect.Opts{} = opts} -> {doc, opts}\n doc_nil() -> {doc_nil(), opts}\n doc -> {doc, changed_opts}\n end\n end\n\n defp join(doc_nil(), doc_nil(), _, _), do: doc_nil()\n defp join(left, doc_nil(), _, _), do: left\n defp join(doc_nil(), right, _, _), do: right\n defp join(left, right, true, sep), do: flex_glue(concat(left, sep), right)\n defp join(left, right, false, sep), do: glue(concat(left, sep), right)\n\n defp simple?(doc_cons(left, right)), do: simple?(left) and simple?(right)\n defp simple?(doc_color(doc, _)), do: simple?(doc)\n defp simple?(doc_string(_, _)), do: true\n defp simple?(doc_nil()), do: true\n defp simple?(other), do: is_binary(other)\n\n @doc false\n @deprecated \"Use a combination of concat/2 and nest/2 instead\"\n def surround(left, doc, right) when is_doc(left) and is_doc(doc) and is_doc(right) do\n concat(concat(left, nest(doc, 1)), right)\n end\n\n @doc false\n @deprecated \"Use Inspect.Algebra.container_doc/6 instead\"\n def surround_many(\n left,\n docs,\n right,\n %Inspect.Opts{} = inspect,\n fun,\n separator \\\\ @container_separator\n )\n when is_doc(left) and is_list(docs) and is_doc(right) and is_function(fun, 2) do\n container_doc(left, docs, right, inspect, fun, separator: separator)\n end\n\n # TODO: Deprecate me on Elixir v1.23\n @doc deprecated: \"Use color_doc/3 instead\"\n def color(doc, key, opts) do\n color_doc(doc, key, opts)\n end\n\n @doc ~S\"\"\"\n Colors a document if the `color_key` has a color in the options.\n \"\"\"\n @doc since: \"1.18.0\"\n @spec color_doc(t, Inspect.Opts.color_key(), Inspect.Opts.t()) :: t\n def color_doc(doc, color_key, %Inspect.Opts{syntax_colors: syntax_colors}) when is_doc(doc) do\n if precolor = Keyword.get(syntax_colors, color_key) do\n postcolor = Keyword.get(syntax_colors, :reset, :reset)\n concat(doc_color(doc, ansi(precolor)), doc_color(empty(), ansi(postcolor)))\n else\n doc\n end\n end\n\n defp ansi(color) do\n color\n |> IO.ANSI.format_fragment(true)\n |> IO.iodata_to_binary()\n end\n\n # Algebra API\n\n @compile {:inline,\n empty: 0,\n concat: 2,\n break: 0,\n break: 1,\n glue: 2,\n glue: 3,\n flex_break: 0,\n flex_break: 1,\n flex_glue: 2,\n flex_glue: 3}\n\n @doc \"\"\"\n Returns a document entity used to represent nothingness.\n\n ## Examples\n\n iex> Inspect.Algebra.empty()\n []\n\n \"\"\"\n @spec empty() :: doc_nil()\n def empty, do: doc_nil()\n\n @doc ~S\"\"\"\n Creates a document represented by string.\n\n While `Inspect.Algebra` accepts binaries as documents,\n those are counted by binary size. On the other hand,\n `string` documents are measured in terms of graphemes\n towards the document size.\n\n ## Examples\n\n The following document has 10 bytes and therefore it\n does not format to width 9 without breaks:\n\n iex> doc = Inspect.Algebra.glue(\"olá\", \" \", \"mundo\")\n iex> doc = Inspect.Algebra.group(doc)\n iex> Inspect.Algebra.format(doc, 9)\n \"olá\\nmundo\"\n\n However, if we use `string`, then the string length is\n used, instead of byte size, correctly fitting:\n\n iex> string = Inspect.Algebra.string(\"olá\")\n iex> doc = Inspect.Algebra.glue(string, \" \", \"mundo\")\n iex> doc = Inspect.Algebra.group(doc)\n iex> Inspect.Algebra.format(doc, 9)\n \"olá mundo\"\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec string(String.t()) :: doc_string\n def string(string) when is_binary(string) do\n doc_string(string, String.length(string))\n end\n\n @doc ~S\"\"\"\n Concatenates two document entities returning a new document.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.concat(\"hello\", \"world\")\n iex> Inspect.Algebra.format(doc, 80)\n \"helloworld\"\n\n \"\"\"\n @spec concat(t, t) :: t\n def concat(doc1, doc2) when is_doc(doc1) and is_doc(doc2) do\n doc_cons(doc1, doc2)\n end\n\n @doc ~S\"\"\"\n Disable any rendering limit while rendering the given document.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.glue(\"hello\", \"world\") |> Inspect.Algebra.group()\n iex> Inspect.Algebra.format(doc, 10)\n \"hello\\nworld\"\n iex> doc = Inspect.Algebra.no_limit(doc)\n iex> Inspect.Algebra.format(doc, 10)\n \"hello world\"\n\n \"\"\"\n @doc since: \"1.14.0\"\n @spec no_limit(t) :: t\n def no_limit(doc) do\n doc_limit(doc, :infinity)\n end\n\n @doc ~S\"\"\"\n Concatenates a list of documents returning a new document.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.concat([\"a\", \"b\", \"c\"])\n iex> Inspect.Algebra.format(doc, 80)\n \"abc\"\n\n \"\"\"\n @spec concat([t]) :: t\n def concat(docs) when is_list(docs) do\n fold(docs, &concat(&1, &2))\n end\n\n @doc ~S\"\"\"\n Colors a document with the given color (preceding the document itself).\n \"\"\"\n @doc since: \"1.18.0\"\n @spec color(t, binary) :: t\n def color(doc, color) when is_doc(doc) and is_binary(color) do\n doc_color(doc, color)\n end\n\n @doc ~S\"\"\"\n Nests the given document at the given `level`.\n\n If `level` is an integer, that's the indentation appended\n to line breaks whenever they occur. If the level is `:cursor`,\n the current position of the \"cursor\" in the document becomes\n the nesting. If the level is `:reset`, it is set back to 0.\n\n `mode` can be `:always`, which means nesting always happen,\n or `:break`, which means nesting only happens inside a group\n that has been broken.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.nest(Inspect.Algebra.glue(\"hello\", \"world\"), 5)\n iex> doc = Inspect.Algebra.group(doc)\n iex> Inspect.Algebra.format(doc, 5)\n \"hello\\n world\"\n\n \"\"\"\n @spec nest(t, non_neg_integer | :cursor | :reset, :always | :break) :: doc_nest | t\n def nest(doc, level, mode \\\\ :always)\n\n def nest(doc, :cursor, mode) when is_doc(doc) and mode in [:always, :break] do\n doc_nest(doc, :cursor, mode)\n end\n\n def nest(doc, :reset, mode) when is_doc(doc) and mode in [:always, :break] do\n doc_nest(doc, :reset, mode)\n end\n\n def nest(doc, 0, _mode) when is_doc(doc) do\n doc\n end\n\n def nest(doc, level, mode)\n when is_doc(doc) and is_integer(level) and level > 0 and mode in [:always, :break] do\n doc_nest(doc, level, mode)\n end\n\n @doc ~S\"\"\"\n Returns a break document based on the given `string`.\n\n This break can be rendered as a linebreak or as the given `string`,\n depending on the `mode` of the chosen layout.\n\n ## Examples\n\n Let's create a document by concatenating two strings with a break between\n them:\n\n iex> doc = Inspect.Algebra.concat([\"a\", Inspect.Algebra.break(\"\\t\"), \"b\"])\n iex> Inspect.Algebra.format(doc, 80)\n \"a\\tb\"\n\n Note that the break was represented with the given string, because we didn't\n reach a line limit. Once we do, it is replaced by a newline:\n\n iex> break = Inspect.Algebra.break(\"\\t\")\n iex> doc = Inspect.Algebra.concat([String.duplicate(\"a\", 20), break, \"b\"])\n iex> doc = Inspect.Algebra.group(doc)\n iex> Inspect.Algebra.format(doc, 10)\n \"aaaaaaaaaaaaaaaaaaaa\\nb\"\n\n \"\"\"\n @spec break(binary) :: doc_break\n def break(string \\\\ \" \") when is_binary(string) do\n doc_break(string, :strict)\n end\n\n @doc \"\"\"\n Collapse any new lines and whitespace following this\n node, emitting up to `max` new lines.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec collapse_lines(pos_integer) :: doc_collapse\n def collapse_lines(max) when is_integer(max) and max > 0 do\n doc_collapse(max)\n end\n\n @doc \"\"\"\n Considers the next break as fit.\n \"\"\"\n # TODO: Deprecate me on Elixir v1.23\n @doc deprecated: \"Pass the optimistic/pessimistic type to group/2 instead\"\n @spec next_break_fits(t, :enabled | :disabled) :: doc_fits\n def next_break_fits(doc, mode \\\\ :enabled)\n when is_doc(doc) and mode in [:enabled, :disabled] do\n doc_fits(doc, mode)\n end\n\n @doc \"\"\"\n Forces the current group to be unfit.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec force_unfit(t) :: doc_force\n def force_unfit(doc) when is_doc(doc) do\n doc_force(doc)\n end\n\n @doc \"\"\"\n Returns a flex break document based on the given `string`.\n\n A flex break still causes a group to break, like `break/1`,\n but it is re-evaluated when the documented is rendered.\n\n For example, take a group document represented as `[1, 2, 3]`\n where the space after every comma is a break. When the document\n above does not fit a single line, all breaks are enabled,\n causing the document to be rendered as:\n\n [1,\n 2,\n 3]\n\n However, if flex breaks are used, then each break is re-evaluated\n when rendered, so the document could be possible rendered as:\n\n [1, 2,\n 3]\n\n Hence the name \"flex\". they are more flexible when it comes\n to the document fitting. On the other hand, they are more expensive\n since each break needs to be re-evaluated.\n\n This function is used by `container_doc/6` and friends to the\n maximum number of entries on the same line.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec flex_break(binary) :: doc_break\n def flex_break(string \\\\ \" \") when is_binary(string) do\n doc_break(string, :flex)\n end\n\n @doc \"\"\"\n Glues two documents (`doc1` and `doc2`) inserting a\n `flex_break/1` given by `break_string` between them.\n\n This function is used by `container_doc/6` and friends\n to the maximum number of entries on the same line.\n \"\"\"\n @doc since: \"1.6.0\"\n @spec flex_glue(t, binary, t) :: t\n def flex_glue(doc1, break_string \\\\ \" \", doc2) when is_binary(break_string) do\n concat(doc1, concat(flex_break(break_string), doc2))\n end\n\n @doc ~S\"\"\"\n Glues two documents (`doc1` and `doc2`) inserting the given\n break `break_string` between them.\n\n For more information on how the break is inserted, see `break/1`.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.glue(\"hello\", \"world\")\n iex> Inspect.Algebra.format(doc, 80)\n \"hello world\"\n\n iex> doc = Inspect.Algebra.glue(\"hello\", \"\\t\", \"world\")\n iex> Inspect.Algebra.format(doc, 80)\n \"hello\\tworld\"\n\n \"\"\"\n @spec glue(t, binary, t) :: t\n def glue(doc1, break_string \\\\ \" \", doc2) when is_binary(break_string) do\n concat(doc1, concat(break(break_string), doc2))\n end\n\n @doc ~S\"\"\"\n Returns a group containing the specified document `doc`.\n\n Documents in a group are attempted to be rendered together\n to the best of the renderer ability. If there are `break/1`s\n in the group and the group does not fit the given width,\n the breaks are converted into lines. Otherwise the breaks\n are rendered as text based on their string contents.\n\n There are three types of groups, described next.\n\n ## Group modes\n\n * `:normal` - the group fits if it fits within the given width\n\n * `:optimistic` - the group fits if it fits within the given\n width. However, when nested within another group, the parent\n group will assume this group fits as long as it has a single\n break, even if the optimistic group has a `force_unfit/1`\n document within it. Overall, this has an effect similar\n to swapping the order groups break. For example, if you have\n a `parent_group(child_group)` and they do not fit, the parent\n converts breaks into newlines first, allowing the child to compute\n if it fits. However, if the child group is optimistic and it\n has breaks, then the parent assumes it fits, leaving the overall\n fitting decision to the child\n\n * `:pessimistic` - the group fits if it fits within the given\n width. However it disables any optimistic group within it\n\n ## Examples\n\n iex> doc =\n ...> Inspect.Algebra.group(\n ...> Inspect.Algebra.concat(\n ...> Inspect.Algebra.group(\n ...> Inspect.Algebra.concat(\n ...> \"Hello,\",\n ...> Inspect.Algebra.concat(\n ...> Inspect.Algebra.break(),\n ...> \"A\"\n ...> )\n ...> )\n ...> ),\n ...> Inspect.Algebra.concat(\n ...> Inspect.Algebra.break(),\n ...> \"B\"\n ...> )\n ...> )\n ...> )\n iex> Inspect.Algebra.format(doc, 80)\n \"Hello, A B\"\n iex> Inspect.Algebra.format(doc, 6)\n \"Hello,\\nA\\nB\"\n\n ## Mode examples\n\n The different groups modes are used by Elixir's code formatter\n to avoid breaking code at some specific locations. For example,\n consider this code:\n\n some_function_call(%{..., key: value, ...})\n\n Now imagine that this code does not fit its line. The code\n formatter introduces breaks inside `(` and `)` and inside\n `%{` and `}`, each within their own group. Therefore the\n document would break as:\n\n some_function_call(\n %{\n ...,\n key: value,\n ...\n }\n )\n\n To address this, the formatter marks the inner group as optimistic.\n This means the first group, which is `(...)` will consider the document\n fits and avoids adding breaks around the parens. So overall the code\n is formatted as:\n\n some_function_call(%{\n ...,\n key: value,\n ...\n })\n\n \"\"\"\n @spec group(t, :normal | :optimistic | :pessimistic) :: doc_group\n def group(doc, mode \\\\ :normal) when is_doc(doc) do\n doc_group(\n doc,\n case mode do\n # TODO: Deprecate :self and :inherit on Elixir v1.23\n :self -> :normal\n :inherit -> :inherit\n mode when mode in [:normal, :optimistic, :pessimistic] -> mode\n end\n )\n end\n\n @doc ~S\"\"\"\n Inserts a mandatory single space between two documents.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.space(\"Hughes\", \"Wadler\")\n iex> Inspect.Algebra.format(doc, 5)\n \"Hughes Wadler\"\n\n \"\"\"\n @spec space(t, t) :: t\n def space(doc1, doc2), do: concat(doc1, concat(\" \", doc2))\n\n @doc ~S\"\"\"\n A mandatory linebreak.\n\n A group with linebreaks will fit if all lines in the group fit.\n\n ## Examples\n\n iex> doc =\n ...> Inspect.Algebra.concat(\n ...> Inspect.Algebra.concat(\n ...> \"Hughes\",\n ...> Inspect.Algebra.line()\n ...> ),\n ...> \"Wadler\"\n ...> )\n iex> Inspect.Algebra.format(doc, 80)\n \"Hughes\\nWadler\"\n\n \"\"\"\n @doc since: \"1.6.0\"\n @spec line() :: t\n def line(), do: doc_line()\n\n @doc ~S\"\"\"\n Inserts a mandatory linebreak between two documents.\n\n See `line/0`.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.line(\"Hughes\", \"Wadler\")\n iex> Inspect.Algebra.format(doc, 80)\n \"Hughes\\nWadler\"\n\n \"\"\"\n @spec line(t, t) :: t\n def line(doc1, doc2), do: concat(doc1, concat(line(), doc2))\n\n # TODO: Deprecate me on Elixir v1.23\n @doc deprecated: \"Use fold/2 instead\"\n def fold_doc(docs, folder_fun), do: fold(docs, folder_fun)\n\n @doc ~S\"\"\"\n Folds a list of documents into a document using the given folder function.\n\n The list of documents is folded \"from the right\"; in that, this function is\n similar to `List.foldr/3`, except that it doesn't expect an initial\n accumulator and uses the last element of `docs` as the initial accumulator.\n\n ## Examples\n\n iex> docs = [\"A\", \"B\", \"C\"]\n iex> docs =\n ...> Inspect.Algebra.fold(docs, fn doc, acc ->\n ...> Inspect.Algebra.concat([doc, \"!\", acc])\n ...> end)\n iex> Inspect.Algebra.format(docs, 80)\n \"A!B!C\"\n\n \"\"\"\n @doc since: \"1.18.0\"\n @spec fold([t], (t, t -> t)) :: t\n def fold(docs, folder_fun)\n\n def fold([], _folder_fun), do: empty()\n def fold([doc], _folder_fun), do: doc\n\n def fold([doc | docs], folder_fun) when is_function(folder_fun, 2),\n do: folder_fun.(doc, fold(docs, folder_fun))\n\n @doc ~S\"\"\"\n Formats a given document for a given width.\n\n Takes the maximum width and a document to print as its arguments\n and returns an IO data representation of the best layout for the\n document to fit in the given width.\n\n The document starts flat (without breaks) until a group is found.\n\n ## Examples\n\n iex> doc = Inspect.Algebra.glue(\"hello\", \" \", \"world\")\n iex> doc = Inspect.Algebra.group(doc)\n iex> doc |> Inspect.Algebra.format(30) |> IO.iodata_to_binary()\n \"hello world\"\n iex> doc |> Inspect.Algebra.format(10) |> IO.iodata_to_binary()\n \"hello\\nworld\"\n\n \"\"\"\n @spec format(t, non_neg_integer | :infinity) :: iodata\n def format(doc, width) when is_doc(doc) and is_width(width) do\n format(width, 0, [{0, :flat, doc}], <<>>)\n end\n\n # Type representing the document mode to be rendered:\n #\n # * flat - represents a document with breaks as flats (a break may fit, as it may break)\n # * break - represents a document with breaks as breaks (a break always fits, since it breaks)\n #\n # These other two modes only affect fitting:\n #\n # * flat_no_break - represents a document with breaks as flat not allowed to enter in break mode\n # * break_no_flat - represents a document with breaks as breaks not allowed to enter in flat mode\n #\n @typep mode :: :flat | :flat_no_break | :break | :break_no_flat\n\n @spec fits?(\n width :: non_neg_integer() | :infinity,\n column :: non_neg_integer(),\n break? :: boolean(),\n entries\n ) :: boolean()\n when entries:\n maybe_improper_list(\n {integer(), mode(), t()} | :group_over,\n {:tail, boolean(), entries} | []\n )\n\n # We need at least a break to consider the document does not fit since a\n # large document without breaks has no option but fitting its current line.\n #\n # In case we have groups and the group fits, we need to consider the group\n # parent without the child breaks, hence {:tail, b?, t} below.\n defp fits?(w, k, b?, _) when k > w and b?, do: false\n defp fits?(_, _, _, []), do: true\n defp fits?(w, k, _, {:tail, b?, t}), do: fits?(w, k, b?, t)\n\n ## Group over\n # If we get to the end of the group and if fits, it is because\n # something already broke elsewhere, so we can consider the group\n # fits. This only appears when checking if a flex break and fitting.\n\n defp fits?(_w, _k, b?, [:group_over | _]),\n do: b?\n\n ## Flat no break\n\n defp fits?(w, k, b?, [{i, _, doc_fits(x, :disabled)} | t]),\n do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])\n\n defp fits?(w, k, b?, [{i, :flat_no_break, doc_fits(x, _)} | t]),\n do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])\n\n defp fits?(w, k, b?, [{i, _, doc_group(x, :pessimistic)} | t]),\n do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])\n\n defp fits?(w, k, b?, [{i, :flat_no_break, doc_group(x, _)} | t]),\n do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])\n\n ## Breaks no flat\n\n defp fits?(w, k, b?, [{i, _, doc_fits(x, :enabled)} | t]),\n do: fits?(w, k, b?, [{i, :break_no_flat, x} | t])\n\n defp fits?(w, k, b?, [{i, _, doc_group(x, :optimistic)} | t]),\n do: fits?(w, k, b?, [{i, :break_no_flat, x} | t])\n\n defp fits?(w, k, b?, [{i, :break_no_flat, doc_force(x)} | t]),\n do: fits?(w, k, b?, [{i, :break_no_flat, x} | t])\n\n defp fits?(_, _, _, [{_, :break_no_flat, doc_break(_, _)} | _]), do: true\n defp fits?(_, _, _, [{_, :break_no_flat, doc_line()} | _]), do: true\n\n ## Breaks\n\n defp fits?(_, _, _, [{_, :break, doc_break(_, _)} | _]), do: true\n defp fits?(_, _, _, [{_, :break, doc_line()} | _]), do: true\n\n defp fits?(w, k, b?, [{i, :break, doc_group(x, _)} | t]),\n do: fits?(w, k, b?, [{i, :flat, x} | {:tail, b?, t}])\n\n ## Catch all\n\n defp fits?(w, _, _, [{i, _, doc_line()} | t]), do: fits?(w, i, false, t)\n defp fits?(w, k, b?, [{_, _, doc_nil()} | t]), do: fits?(w, k, b?, t)\n defp fits?(w, _, b?, [{i, _, doc_collapse(_)} | t]), do: fits?(w, i, b?, t)\n defp fits?(w, k, b?, [{i, m, doc_color(x, _)} | t]), do: fits?(w, k, b?, [{i, m, x} | t])\n defp fits?(w, k, b?, [{_, _, doc_string(_, l)} | t]), do: fits?(w, k + l, b?, t)\n defp fits?(w, k, b?, [{_, _, s} | t]) when is_binary(s), do: fits?(w, k + byte_size(s), b?, t)\n defp fits?(_, _, _, [{_, _, doc_force(_)} | _]), do: false\n defp fits?(w, k, _, [{_, _, doc_break(s, _)} | t]), do: fits?(w, k + byte_size(s), true, t)\n defp fits?(w, k, b?, [{i, m, doc_nest(x, _, :break)} | t]), do: fits?(w, k, b?, [{i, m, x} | t])\n\n defp fits?(w, k, b?, [{i, m, doc_nest(x, j, _)} | t]),\n do: fits?(w, k, b?, [{apply_nesting(i, k, j), m, x} | t])\n\n defp fits?(w, k, b?, [{i, m, doc_cons(x, y)} | t]),\n do: fits?(w, k, b?, [{i, m, x}, {i, m, y} | t])\n\n defp fits?(w, k, b?, [{i, m, doc_group(x, _)} | t]),\n do: fits?(w, k, b?, [{i, m, x} | {:tail, b?, t}])\n\n defp fits?(w, k, b?, [{i, m, doc_limit(x, :infinity)} | t]) when w != :infinity,\n do: fits?(:infinity, k, b?, [{i, :flat, x}, {i, m, doc_limit(empty(), w)} | t])\n\n defp fits?(_w, k, b?, [{i, m, doc_limit(x, w)} | t]),\n do: fits?(w, k, b?, [{i, m, x} | t])\n\n @spec format(\n width :: non_neg_integer() | :infinity,\n column :: non_neg_integer(),\n [{integer, mode, t} | :group_over],\n binary\n ) :: iodata\n defp format(_, _, [], acc), do: acc\n\n defp format(w, k, [{_, _, doc_nil()} | t], acc),\n do: format(w, k, t, acc)\n\n defp format(w, _, [{i, _, doc_line()} | t], acc),\n do: format(w, i, t, <>)\n\n defp format(w, k, [{i, m, doc_cons(x, y)} | t], acc),\n do: format(w, k, [{i, m, x}, {i, m, y} | t], acc)\n\n defp format(w, k, [{i, m, doc_color(x, c)} | t], acc),\n do: format(w, k, [{i, m, x} | t], <>)\n\n defp format(w, k, [{_, _, doc_string(s, l)} | t], acc),\n do: format(w, k + l, t, <>)\n\n defp format(w, k, [{_, _, s} | t], acc) when is_binary(s),\n do: format(w, k + byte_size(s), t, <>)\n\n defp format(w, k, [{i, m, doc_force(x)} | t], acc),\n do: format(w, k, [{i, m, x} | t], acc)\n\n defp format(w, k, [{i, m, doc_fits(x, _)} | t], acc),\n do: format(w, k, [{i, m, x} | t], acc)\n\n defp format(w, _, [{i, _, doc_collapse(max)} | t], acc),\n do: [acc | collapse(List.wrap(format(w, i, t, <<>>)), max, 0, i)]\n\n # Flex breaks are conditional to the document and the mode\n defp format(w, k, [{i, m, doc_break(s, :flex)} | t], acc) do\n k = k + byte_size(s)\n\n if w == :infinity or m == :flat or fits?(w, k, true, t) do\n format(w, k, t, <>)\n else\n format(w, i, t, <>)\n end\n end\n\n # Strict breaks are conditional to the mode\n defp format(w, k, [{i, mode, doc_break(s, :strict)} | t], acc) do\n if mode == :break do\n format(w, i, t, <>)\n else\n format(w, k + byte_size(s), t, <>)\n end\n end\n\n # Nesting is conditional to the mode.\n defp format(w, k, [{i, mode, doc_nest(x, j, nest)} | t], acc) do\n if nest == :always or (nest == :break and mode == :break) do\n format(w, k, [{apply_nesting(i, k, j), mode, x} | t], acc)\n else\n format(w, k, [{i, mode, x} | t], acc)\n end\n end\n\n # Groups must do the fitting decision.\n defp format(w, k, [:group_over | t], acc) do\n format(w, k, t, acc)\n end\n\n # TODO: Deprecate me in Elixir v1.23\n defp format(w, k, [{i, :break, doc_group(x, :inherit)} | t], acc) do\n format(w, k, [{i, :break, x} | t], acc)\n end\n\n defp format(w, k, [{i, :flat, doc_group(x, :optimistic)} | t], acc) do\n if w == :infinity or fits?(w, k, false, [{i, :flat, x} | t]) do\n format(w, k, [{i, :flat, x}, :group_over | t], acc)\n else\n format(w, k, [{i, :break, x}, :group_over | t], acc)\n end\n end\n\n defp format(w, k, [{i, _, doc_group(x, _)} | t], acc) do\n if w == :infinity or fits?(w, k, false, [{i, :flat, x}]) do\n format(w, k, [{i, :flat, x}, :group_over | t], acc)\n else\n format(w, k, [{i, :break, x}, :group_over | t], acc)\n end\n end\n\n # Limit is set to infinity and then reverts\n defp format(w, k, [{i, m, doc_limit(x, :infinity)} | t], acc) when w != :infinity do\n format(:infinity, k, [{i, :flat, x}, {i, m, doc_limit(empty(), w)} | t], acc)\n end\n\n defp format(_w, k, [{i, m, doc_limit(x, w)} | t], acc) do\n format(w, k, [{i, m, x} | t], acc)\n end\n\n defp collapse([\"\\n\" <> rest | t], max, count, i) do\n collapse([strip_whitespace(rest) | t], max, count + 1, i)\n end\n\n defp collapse([\"\" | t], max, count, i) do\n collapse(t, max, count, i)\n end\n\n defp collapse(t, max, count, i) do\n [:binary.copy(\"\\n\", min(max, count)), :binary.copy(\" \", i) | t]\n end\n\n defp strip_whitespace(\" \" <> rest), do: strip_whitespace(rest)\n defp strip_whitespace(rest), do: rest\n\n defp apply_nesting(_, k, :cursor), do: k\n defp apply_nesting(_, _, :reset), do: 0\n defp apply_nesting(i, _, j), do: i + j\n\n defp indent(0), do: @newline\n defp indent(i), do: @newline <> :binary.copy(\" \", i)\nend\n" }, { "path": "lib/elixir/lib/inspect/error.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\ndefmodule Inspect.Error do\n @moduledoc \"\"\"\n Raised when a struct cannot be inspected.\n \"\"\"\n @enforce_keys [:exception_module, :exception_message, :stacktrace, :inspected_struct]\n defexception @enforce_keys\n\n @impl true\n def exception(arguments) when is_list(arguments) do\n exception = Keyword.fetch!(arguments, :exception)\n exception_module = exception.__struct__\n exception_message = Exception.message(exception) |> String.trim_trailing(\"\\n\")\n stacktrace = Keyword.fetch!(arguments, :stacktrace)\n inspected_struct = Keyword.fetch!(arguments, :inspected_struct)\n\n %Inspect.Error{\n exception_module: exception_module,\n exception_message: exception_message,\n stacktrace: stacktrace,\n inspected_struct: inspected_struct\n }\n end\n\n @impl true\n def message(%__MODULE__{\n exception_module: exception_module,\n exception_message: exception_message,\n inspected_struct: inspected_struct\n }) do\n ~s'''\n got #{inspect(exception_module)} with message:\n\n \"\"\"\n #{pad(exception_message, 4)}\n \"\"\"\n\n while inspecting:\n\n #{pad(inspected_struct, 4)}\n '''\n end\n\n @doc false\n def pad(message, padding_length)\n when is_binary(message) and is_integer(padding_length) and padding_length >= 0 do\n padding = String.duplicate(\" \", padding_length)\n\n message\n |> String.split(\"\\n\")\n |> Enum.map(fn\n \"\" -> \"\\n\"\n line -> [padding, line, ?\\n]\n end)\n |> IO.iodata_to_binary()\n |> String.trim_trailing(\"\\n\")\n end\nend\n\ndefimpl Inspect, for: Inspect.Error do\n @impl true\n def inspect(%{stacktrace: stacktrace} = inspect_error, _opts) do\n message = Exception.message(inspect_error)\n format_output(message, stacktrace)\n end\n\n defp format_output(message, [_ | _] = stacktrace) do\n stacktrace = Exception.format_stacktrace(stacktrace)\n\n \"\"\"\n #Inspect.Error<\n #{Inspect.Error.pad(message, 2)}\n\n Stacktrace:\n\n #{stacktrace}\n >\\\n \"\"\"\n end\n\n defp format_output(message, []) do\n \"\"\"\n #Inspect.Error<\n #{Inspect.Error.pad(message, 2)}\n >\\\n \"\"\"\n end\nend\n" }, { "path": "lib/elixir/lib/inspect.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nimport Kernel, except: [inspect: 1]\nimport Inspect.Algebra\n\nalias Code.Identifier\n\ndefprotocol Inspect do\n @moduledoc \"\"\"\n The `Inspect` protocol converts an Elixir data structure into an\n algebra document.\n\n This is typically done when you want to customize how your own\n structs are inspected in logs and the terminal.\n\n This documentation refers to implementing the `Inspect` protocol\n for your own data structures. To learn more about using inspect,\n see `Kernel.inspect/2` and `IO.inspect/2`.\n\n ## Inspect representation\n\n There are typically three choices of inspect representation. In order\n to understand them, let's imagine we have the following `User` struct:\n\n defmodule User do\n defstruct [:id, :name, :address]\n end\n\n Our choices are:\n\n 1. Print the struct using Elixir's struct syntax, for example:\n `%User{address: \"Earth\", id: 13, name: \"Jane\"}`. This is the\n default representation and best choice if all struct fields\n are public.\n\n 2. Print using the `#User<...>` notation, for example: `#User`.\n This notation does not emit valid Elixir code and is typically\n used when the struct has private fields (for example, you may want\n to hide the field `:address` to redact person identifiable information).\n\n 3. Print the struct using the expression syntax, for example:\n `User.new(13, \"Jane\", \"Earth\")`. This assumes there is a `User.new/3`\n function. This option is mostly used as an alternative to option 2\n for representing custom data structures, such as `MapSet`, `Date.Range`,\n and others.\n\n You can implement the Inspect protocol for your own structs while\n adhering to the conventions above. Option 1 is the default representation\n and you can quickly achieve option 2 by deriving the `Inspect` protocol.\n For option 3, you need your custom implementation.\n\n ## Deriving\n\n The `Inspect` protocol can be derived to customize the order of fields\n (the default is alphabetical) and hide certain fields from structs,\n so they don't show up in logs, inspects and similar. The latter is\n especially useful for fields containing private information.\n\n The supported options are:\n\n * `:only` - only include the given fields when inspecting.\n\n * `:except` - remove the given fields when inspecting.\n\n * `:optional` - (since v1.14.0) a list of fields that should not be\n included when they match their default value. This can be used to\n simplify the struct representation at the cost of hiding\n information. Since v1.19.0, the `:all` atom can be passed to\n mark all fields as optional.\n\n Whenever `:only` or `:except` are used to restrict fields,\n the struct will be printed using the `#User<...>` notation,\n as the struct can no longer be copy and pasted as valid Elixir\n code. Let's see an example:\n\n defmodule User do\n @derive {Inspect, only: [:id, :name]}\n defstruct [:id, :name, :address]\n end\n\n inspect(%User{id: 1, name: \"Jane\", address: \"Earth\"})\n #=> #User\n\n If you use only the `:optional` option, the struct will still be\n printed as a valid struct.\n\n defmodule Point do\n @derive {Inspect, optional: [:z]}\n defstruct [x: 0, y: 0, z: 0]\n end\n\n inspect(%Point{x: 1})\n %Point{x: 1, y: 0}\n\n ## Custom implementation\n\n You can also define your custom protocol implementation by\n defining the `inspect/2` function. The function receives the\n entity to be inspected followed by the inspecting options,\n represented by the struct `Inspect.Opts` and it must return\n an algebra document alongside the updated options (or, optionally,\n just the algebra document). Building of the algebra document\n is done with `Inspect.Algebra`.\n\n Many times, inspecting a structure can be implemented in function\n of existing entities. For example, here is `MapSet`'s `inspect/2`\n implementation:\n\n defimpl Inspect, for: MapSet do\n import Inspect.Algebra\n\n def inspect(map_set, opts) do\n {doc, opts} = to_doc_with_opts(MapSet.to_list(map_set), opts)\n {concat([\"MapSet.new(\", doc, \")\"]), opts}\n end\n end\n\n First [`to_doc_with_opts/2`](`Inspect.Algebra.to_doc_with_opts/2`) is\n used to convert another data structure into its algebra document and\n then [`concat/1`](`Inspect.Algebra.concat/1`) concatenates algebra\n documents together.\n\n In the example above it is concatenating the string `\"MapSet.new(\"`,\n the document returned by `to_doc_with_opts/2`, and the final string `\")\"`.\n Therefore, the MapSet with the numbers 1, 2, and 3 will be printed as:\n\n iex> MapSet.new([1, 2, 3], fn x -> x * 2 end)\n MapSet.new([2, 4, 6])\n\n In other words, `MapSet`'s inspect representation returns an expression\n that, when evaluated, builds the `MapSet` itself.\n\n ### Error handling\n\n In case there is an error while your structure is being inspected,\n Elixir will raise an `ArgumentError` error and will automatically fall back\n to a raw representation for printing the structure. Furthermore, you\n must be careful when debugging your own Inspect implementation, as calls\n to `IO.inspect/2` or `dbg/1` may trigger an infinite loop (as in order to\n inspect/debug the data structure, you must call `inspect` itself).\n\n Here are some tips:\n\n * For debugging, use `IO.inspect/2` with the `structs: false` option,\n which disables custom printing and avoids calling the Inspect\n implementation recursively\n\n * To access the underlying error on your custom `Inspect` implementation,\n you may invoke the protocol directly. For example, we could invoke the\n `Inspect.MapSet` implementation above as:\n\n Inspect.MapSet.inspect(MapSet.new(), %Inspect.Opts{})\n\n Note that, from Elixir v1.19, the inspect protocol was augmented to\n allow a two-element tuple with the document and the updated options\n to be returned from the protocol.\n \"\"\"\n\n # Handle structs in Any\n @fallback_to_any true\n\n @impl true\n defmacro __deriving__(module, options) do\n info = Macro.struct_info!(module, __CALLER__)\n fields = Enum.sort(Enum.map(info, & &1.field) -- [:__exception__, :__struct__])\n\n only = Keyword.get(options, :only, fields)\n except = Keyword.get(options, :except, [])\n\n :ok = validate_option(:only, only, fields, module)\n :ok = validate_option(:except, except, fields, module)\n\n optional =\n case Keyword.get(options, :optional, []) do\n :all ->\n fields\n\n optional ->\n :ok = validate_option(:optional, optional, fields, module)\n optional\n end\n\n inspect_module =\n if fields == Enum.sort(only) and except == [] do\n Inspect.Map\n else\n Inspect.Any\n end\n\n filtered_fields =\n fields\n |> Enum.reject(&(&1 in except))\n |> Enum.filter(&(&1 in only))\n\n filtered_guard =\n quote do\n var!(field) in unquote(filtered_fields)\n end\n\n field_guard =\n if optional == [] do\n filtered_guard\n else\n optional_map =\n for field <- optional, into: %{} do\n default = Enum.find(info, %{}, &(&1.field == field)) |> Map.get(:default, nil)\n {field, default}\n end\n\n quote do\n unquote(filtered_guard) and\n not case unquote(Macro.escape(optional_map)) do\n %{^var!(field) => var!(default)} ->\n var!(default) == Map.get(var!(struct), var!(field))\n\n %{} ->\n false\n end\n end\n end\n\n quote do\n defimpl Inspect, for: unquote(module) do\n def inspect(var!(struct), var!(opts)) do\n var!(infos) =\n for %{field: var!(field)} = var!(info) <- unquote(module).__info__(:struct),\n unquote(field_guard),\n do: var!(info)\n\n var!(name) = Macro.inspect_atom(:literal, unquote(module))\n\n unquote(inspect_module).inspect_as_struct(\n var!(struct),\n var!(name),\n var!(infos),\n var!(opts)\n )\n end\n end\n end\n end\n\n defp validate_option(option, option_list, fields, module) do\n if not is_list(option_list) do\n raise ArgumentError,\n \"invalid value #{Kernel.inspect(option_list)} in #{Kernel.inspect(option)} \" <>\n \"when deriving the Inspect protocol for #{Kernel.inspect(module)} \" <>\n \"(expected a list)\"\n end\n\n case option_list -- fields do\n [] ->\n :ok\n\n unknown_fields ->\n raise ArgumentError,\n \"unknown fields #{Kernel.inspect(unknown_fields)} in #{Kernel.inspect(option)} \" <>\n \"when deriving the Inspect protocol for #{Kernel.inspect(module)}\"\n end\n end\n\n @doc \"\"\"\n Converts `term` into an algebra document.\n\n This function shouldn't be invoked directly, unless when implementing\n a custom `inspect_fun` to be given to `Inspect.Opts`. Everywhere else,\n `Inspect.Algebra.to_doc/2` should be preferred as it handles structs\n and exceptions.\n \"\"\"\n @spec inspect(t, Inspect.Opts.t()) ::\n Inspect.Algebra.t() | {Inspect.Algebra.t(), Inspect.Opts.t()}\n def inspect(term, opts)\nend\n\ndefimpl Inspect, for: Atom do\n def inspect(atom, opts) do\n color_doc(Macro.inspect_atom(:literal, atom), color_key(atom), opts)\n end\n\n defp color_key(atom) when is_boolean(atom), do: :boolean\n defp color_key(nil), do: nil\n defp color_key(_), do: :atom\nend\n\ndefimpl Inspect, for: BitString do\n def inspect(term, opts) when is_binary(term) do\n %Inspect.Opts{binaries: bins, base: base, printable_limit: printable_limit} = opts\n\n if bins == :as_strings or\n (bins == :infer and String.printable?(term, printable_limit) and base == :decimal) do\n inspected =\n case Identifier.escape(term, ?\", printable_limit) do\n {escaped, \"\"} -> [?\", escaped, ?\"]\n {escaped, _} -> [?\", escaped, ?\", \" <> ...\"]\n end\n\n color_doc(IO.iodata_to_binary(inspected), :string, opts)\n else\n inspect_bitstring(term, opts)\n end\n end\n\n def inspect(term, opts) do\n inspect_bitstring(term, opts)\n end\n\n defp inspect_bitstring(\"\", opts) do\n color_doc(\"<<>>\", :binary, opts)\n end\n\n defp inspect_bitstring(bitstring, %{limit: limit} = opts) do\n left = color_doc(\"<<\", :binary, opts)\n right = color_doc(\">>\", :binary, opts)\n inner = each_bit(bitstring, limit, opts)\n doc = group(concat(concat(left, nest(inner, 2)), right))\n new_limit = if limit == :infinity, do: limit, else: max(0, limit - byte_size(bitstring))\n {doc, %{opts | limit: new_limit}}\n end\n\n defp each_bit(_, 0, _) do\n \"...\"\n end\n\n defp each_bit(<<>>, _counter, _opts) do\n Inspect.Algebra.empty()\n end\n\n defp each_bit(<>, _counter, opts) do\n Inspect.Integer.inspect(h, opts)\n end\n\n defp each_bit(<>, counter, opts) do\n flex_glue(\n concat(Inspect.Integer.inspect(h, opts), \",\"),\n each_bit(t, decrement(counter), opts)\n )\n end\n\n defp each_bit(bitstring, _counter, opts) do\n size = bit_size(bitstring)\n <> = bitstring\n concat(Inspect.Integer.inspect(h, opts), \"::size(\" <> Integer.to_string(size) <> \")\")\n end\n\n @compile {:inline, decrement: 1}\n defp decrement(:infinity), do: :infinity\n defp decrement(counter), do: counter - 1\nend\n\ndefimpl Inspect, for: List do\n def inspect([], opts) do\n color_doc(\"[]\", :list, opts)\n end\n\n # TODO: Remove :char_list and :as_char_lists handling on v2.0\n def inspect(term, opts) do\n %Inspect.Opts{\n charlists: lists,\n char_lists: lists_deprecated,\n printable_limit: printable_limit\n } = opts\n\n lists =\n if lists == :infer and lists_deprecated != :infer do\n case lists_deprecated do\n :as_char_lists ->\n IO.warn(\n \"the :char_lists inspect option and its :as_char_lists \" <>\n \"value are deprecated, use the :charlists option and its \" <>\n \":as_charlists value instead\"\n )\n\n :as_charlists\n\n _ ->\n IO.warn(\"the :char_lists inspect option is deprecated, use :charlists instead\")\n lists_deprecated\n end\n else\n lists\n end\n\n open = color_doc(\"[\", :list, opts)\n sep = color_doc(\",\", :list, opts)\n close = color_doc(\"]\", :list, opts)\n\n cond do\n lists == :as_charlists or (lists == :infer and List.ascii_printable?(term, printable_limit)) ->\n inspected =\n case Identifier.escape(IO.chardata_to_string(term), ?\", printable_limit) do\n {escaped, \"\"} -> [?~, ?c, ?\", escaped, ?\"]\n {escaped, _} -> [?~, ?c, ?\", escaped, ?\", \" ++ ...\"]\n end\n\n color_doc(IO.iodata_to_binary(inspected), :charlist, opts)\n\n keyword?(term) ->\n container_doc_with_opts(open, term, close, opts, &keyword/2,\n separator: sep,\n break: :strict\n )\n\n true ->\n container_doc_with_opts(open, term, close, opts, &to_doc_with_opts/2, separator: sep)\n end\n end\n\n @doc false\n def keyword({key, value}, opts) do\n key = color_doc(Macro.inspect_atom(:key, key), :atom, opts)\n {doc, opts} = to_doc_with_opts(value, opts)\n {concat(key, concat(\" \", doc)), opts}\n end\n\n @doc false\n def keyword?([{key, _value} | rest]) when is_atom(key) do\n case Atom.to_charlist(key) do\n [?E, ?l, ?i, ?x, ?i, ?r, ?.] ++ _ -> false\n _ -> keyword?(rest)\n end\n end\n\n def keyword?([]), do: true\n def keyword?(_other), do: false\nend\n\ndefimpl Inspect, for: Tuple do\n def inspect(tuple, opts) do\n open = color_doc(\"{\", :tuple, opts)\n sep = color_doc(\",\", :tuple, opts)\n close = color_doc(\"}\", :tuple, opts)\n container_opts = [separator: sep, break: :flex]\n\n container_doc_with_opts(\n open,\n Tuple.to_list(tuple),\n close,\n opts,\n &to_doc_with_opts/2,\n container_opts\n )\n end\nend\n\ndefimpl Inspect, for: Map do\n def inspect(map, opts) do\n inspect_as_map(map, opts)\n end\n\n def inspect_as_map(map, opts) do\n list =\n if Keyword.get(opts.custom_options, :sort_maps) do\n map |> Map.to_list() |> :lists.sort()\n else\n Map.to_list(map)\n end\n\n fun =\n if Inspect.List.keyword?(list) do\n &Inspect.List.keyword/2\n else\n sep = color_doc(\" => \", :map, opts)\n &to_assoc(&1, &2, sep)\n end\n\n map_container_doc(list, \"\", opts, fun)\n end\n\n def inspect_as_struct(map, name, infos, opts) do\n fun = fn %{field: field}, opts -> Inspect.List.keyword({field, Map.get(map, field)}, opts) end\n map_container_doc(infos, name, opts, fun)\n end\n\n defp to_assoc({key, value}, opts, sep) do\n {key_doc, opts} = to_doc_with_opts(key, opts)\n {value_doc, opts} = to_doc_with_opts(value, opts)\n {concat(concat(key_doc, sep), value_doc), opts}\n end\n\n defp map_container_doc(list, name, opts, fun) do\n open = color_doc(\"%\" <> name <> \"{\", :map, opts)\n sep = color_doc(\",\", :map, opts)\n close = color_doc(\"}\", :map, opts)\n container_doc_with_opts(open, list, close, opts, fun, separator: sep, break: :strict)\n end\nend\n\ndefimpl Inspect, for: Integer do\n def inspect(term, %Inspect.Opts{base: base} = opts) do\n inspected = Integer.to_string(term, base_to_value(base)) |> prepend_prefix(base)\n color_doc(inspected, :number, opts)\n end\n\n defp base_to_value(base) do\n case base do\n :binary -> 2\n :decimal -> 10\n :octal -> 8\n :hex -> 16\n end\n end\n\n defp prepend_prefix(value, :decimal), do: value\n\n defp prepend_prefix(<>, base) do\n \"-\" <> prepend_prefix(value, base)\n end\n\n defp prepend_prefix(value, base) do\n prefix =\n case base do\n :binary -> \"0b\"\n :octal -> \"0o\"\n :hex -> \"0x\"\n end\n\n prefix <> value\n end\nend\n\ndefimpl Inspect, for: Float do\n def inspect(float, opts) do\n abs = abs(float)\n\n formatted =\n if abs >= 1.0 and abs < 1.0e16 and trunc(float) == float do\n [Integer.to_string(trunc(float)), ?., ?0]\n else\n Float.to_charlist(float)\n end\n\n color_doc(IO.iodata_to_binary(formatted), :number, opts)\n end\nend\n\ndefimpl Inspect, for: Regex do\n def inspect(regex = %{opts: regex_opts}, opts) when is_list(regex_opts) do\n case translate_options(regex_opts, []) do\n :error ->\n concat([\n \"Regex.compile!(\",\n to_doc(regex.source, opts),\n \", \",\n to_doc(regex_opts, opts),\n \")\"\n ])\n\n translated_opts ->\n {escaped, _} =\n regex.source\n |> normalize(<<>>)\n |> Identifier.escape(?/, :infinity, &escape_map/1)\n\n source = IO.iodata_to_binary([?~, ?r, ?/, escaped, ?/, translated_opts])\n color_doc(source, :regex, opts)\n end\n end\n\n defp translate_options([:dotall, {:newline, :anycrlf} | t], acc),\n do: translate_options(t, [?s | acc])\n\n defp translate_options([:unicode, :ucp | t], acc), do: translate_options(t, [?u | acc])\n defp translate_options([:caseless | t], acc), do: translate_options(t, [?i | acc])\n defp translate_options([:extended | t], acc), do: translate_options(t, [?x | acc])\n defp translate_options([:firstline | t], acc), do: translate_options(t, [?f | acc])\n defp translate_options([:ungreedy | t], acc), do: translate_options(t, [?U | acc])\n defp translate_options([:multiline | t], acc), do: translate_options(t, [?m | acc])\n defp translate_options([:export | t], acc), do: translate_options(t, [?E | acc])\n defp translate_options([], acc), do: acc\n defp translate_options(_t, _acc), do: :error\n\n defp normalize(<>, acc), do: normalize(rest, <>)\n defp normalize(<>, acc), do: normalize(rest, <>)\n defp normalize(<>, acc), do: normalize(rest, <>)\n defp normalize(<>, acc), do: normalize(rest, <>)\n defp normalize(<<>>, acc), do: acc\n\n defp escape_map(?\\a), do: [?\\\\, ?a]\n defp escape_map(?\\f), do: [?\\\\, ?f]\n defp escape_map(?\\n), do: [?\\\\, ?n]\n defp escape_map(?\\r), do: [?\\\\, ?r]\n defp escape_map(?\\t), do: [?\\\\, ?t]\n defp escape_map(?\\v), do: [?\\\\, ?v]\n defp escape_map(_), do: false\nend\n\ndefimpl Inspect, for: Function do\n @elixir_compiler :binary.bin_to_list(\"elixir_compiler_\")\n\n def inspect(function, _opts) do\n fun_info = Function.info(function)\n mod = fun_info[:module]\n name = fun_info[:name]\n\n cond do\n not is_atom(mod) ->\n \"#Function<#{uniq(fun_info)}/#{fun_info[:arity]}>\"\n\n fun_info[:type] == :external and fun_info[:env] == [] ->\n inspected_as_atom = Macro.inspect_atom(:literal, mod)\n inspected_as_function = Macro.inspect_atom(:remote_call, name)\n \"&#{inspected_as_atom}.#{inspected_as_function}/#{fun_info[:arity]}\"\n\n match?(@elixir_compiler ++ _, Atom.to_charlist(mod)) ->\n if function_exported?(mod, :__RELATIVE__, 0) do\n \"#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__()}>\"\n else\n default_inspect(mod, fun_info)\n end\n\n true ->\n default_inspect(mod, fun_info)\n end\n end\n\n defp default_inspect(mod, fun_info) do\n inspected_as_atom = Macro.inspect_atom(:literal, mod)\n extracted_name = extract_name(fun_info[:name])\n \"#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in #{inspected_as_atom}#{extracted_name}>\"\n end\n\n defp extract_name([]) do\n \"\"\n end\n\n defp extract_name(name) do\n case Identifier.extract_anonymous_fun_parent(name) do\n {name, arity} ->\n \".\" <> Macro.inspect_atom(:remote_call, name) <> \"/\" <> arity\n\n :error ->\n \".\" <> Macro.inspect_atom(:remote_call, name)\n end\n end\n\n defp uniq(fun_info) do\n Integer.to_string(fun_info[:new_index]) <> \".\" <> Integer.to_string(fun_info[:uniq])\n end\nend\n\ndefimpl Inspect, for: PID do\n def inspect(pid, _opts) do\n \"#PID\" <> IO.iodata_to_binary(:erlang.pid_to_list(pid))\n end\nend\n\ndefimpl Inspect, for: Port do\n def inspect(port, _opts) do\n IO.iodata_to_binary(:erlang.port_to_list(port))\n end\nend\n\ndefimpl Inspect, for: Reference do\n def inspect(ref, _opts) do\n [?#, ?R, ?e, ?f] ++ rest = :erlang.ref_to_list(ref)\n \"#Reference\" <> IO.iodata_to_binary(rest)\n end\nend\n\ndefimpl Inspect, for: Any do\n def inspect(%module{} = struct, opts) do\n info =\n for %{field: field} = map <- module.__info__(:struct),\n field != :__exception__,\n do: map\n\n Inspect.Map.inspect_as_struct(struct, Macro.inspect_atom(:literal, module), info, opts)\n end\n\n def inspect_as_struct(map, name, infos, opts) do\n open = color_doc(\"#\" <> name <> \"<\", :map, opts)\n sep = color_doc(\",\", :map, opts)\n close = color_doc(\">\", :map, opts)\n\n fun = fn\n %{field: field}, opts -> Inspect.List.keyword({field, Map.get(map, field)}, opts)\n :..., _opts -> \"...\"\n end\n\n container_doc(open, infos ++ [:...], close, opts, fun, separator: sep, break: :strict)\n end\nend\n\ndefimpl Inspect, for: Range do\n import Inspect.Algebra\n import Kernel, except: [inspect: 2]\n\n def inspect(first..last//1, opts) when last >= first do\n concat([to_doc(first, opts), \"..\", to_doc(last, opts)])\n end\n\n def inspect(first..last//step, opts) do\n concat([to_doc(first, opts), \"..\", to_doc(last, opts), \"//\", to_doc(step, opts)])\n end\n\n # TODO: Remove me on v2.0\n inspect =\n quote generated: true do\n inspect(\n %{__struct__: Range, first: var!(first), last: var!(last)} = var!(range),\n var!(opts)\n )\n end\n\n def unquote(inspect) do\n step = if first <= last, do: 1, else: -1\n inspect(Map.put(range, :step, step), opts)\n end\nend\n\nrequire Protocol\n\nProtocol.derive(\n Inspect,\n Macro.Env,\n only: [\n :module,\n :file,\n :line,\n :function,\n :context,\n :aliases,\n :requires,\n :functions,\n :macros,\n :macro_aliases,\n :context_modules,\n :lexical_tracker\n ]\n)\n" }, { "path": "lib/elixir/lib/integer.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Integer do\n @moduledoc \"\"\"\n Functions for working with integers.\n\n Some functions that work on integers are found in `Kernel`:\n\n * `Kernel.abs/1`\n * `Kernel.div/2`\n * `Kernel.max/2`\n * `Kernel.min/2`\n * `Kernel.rem/2`\n\n \"\"\"\n\n import Bitwise\n\n @doc \"\"\"\n Counts the number of set bits (1) in the binary representation of a non-negative `integer`.\n\n This operation is known as the Hamming weight or population count.\n\n Raises an `ArithmeticError` if `integer` is negative.\n\n ## Examples\n\n iex> Integer.popcount(0)\n 0\n\n iex> Integer.popcount(1)\n 1\n\n iex> Integer.popcount(0b10110101)\n 5\n\n iex> Integer.popcount(255)\n 8\n\n iex> Integer.popcount(0b1111111111111111)\n 16\n\n iex> Integer.popcount(-1)\n ** (ArithmeticError) bad argument in arithmetic expression\n\n \"\"\"\n @doc since: \"1.20.0\"\n @spec popcount(non_neg_integer) :: non_neg_integer\n def popcount(integer) when is_integer(integer) and integer < 0,\n do: :erlang.error(:badarith, [integer])\n\n def popcount(integer) when is_integer(integer),\n do: popcount(integer, 0)\n\n defp popcount(0, acc), do: acc\n defp popcount(n, acc), do: popcount(n &&& n - 1, acc + 1)\n\n @doc \"\"\"\n Determines if `integer` is odd.\n\n Returns `true` if the given `integer` is an odd number,\n otherwise it returns `false`.\n\n Allowed in guard clauses.\n\n ## Examples\n\n iex> Integer.is_odd(5)\n true\n\n iex> Integer.is_odd(6)\n false\n\n iex> Integer.is_odd(-5)\n true\n\n iex> Integer.is_odd(0)\n false\n\n \"\"\"\n defguard is_odd(integer) when is_integer(integer) and (integer &&& 1) == 1\n\n @doc \"\"\"\n Determines if an `integer` is even.\n\n Returns `true` if the given `integer` is an even number,\n otherwise it returns `false`.\n\n Allowed in guard clauses.\n\n ## Examples\n\n iex> Integer.is_even(10)\n true\n\n iex> Integer.is_even(5)\n false\n\n iex> Integer.is_even(-10)\n true\n\n iex> Integer.is_even(0)\n true\n\n \"\"\"\n defguard is_even(integer) when is_integer(integer) and (integer &&& 1) == 0\n\n @doc \"\"\"\n Computes `base` raised to power of `exponent`.\n\n Both `base` and `exponent` must be integers.\n The exponent must be zero or positive.\n\n See `Float.pow/2` for exponentiation of negative\n exponents as well as floats.\n\n ## Examples\n\n iex> Integer.pow(2, 0)\n 1\n iex> Integer.pow(2, 1)\n 2\n iex> Integer.pow(2, 10)\n 1024\n iex> Integer.pow(2, 11)\n 2048\n iex> Integer.pow(2, 64)\n 0x10000000000000000\n\n iex> Integer.pow(3, 4)\n 81\n iex> Integer.pow(4, 3)\n 64\n\n iex> Integer.pow(-2, 3)\n -8\n iex> Integer.pow(-2, 4)\n 16\n\n iex> Integer.pow(2, -2)\n ** (ArithmeticError) bad argument in arithmetic expression\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec pow(integer, non_neg_integer) :: integer\n def pow(base, exponent) when is_integer(base) and is_integer(exponent) do\n if exponent < 0, do: :erlang.error(:badarith, [base, exponent])\n base ** exponent\n end\n\n @doc \"\"\"\n Computes the modulo remainder of an integer division.\n\n This function performs a [floored division](`floor_div/2`), which means that\n the result will always have the sign of the `divisor`.\n\n Raises an `ArithmeticError` exception if one of the arguments is not an\n integer, or when the `divisor` is `0`.\n\n ## Examples\n\n iex> Integer.mod(5, 2)\n 1\n iex> Integer.mod(6, -4)\n -2\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec mod(integer, neg_integer | pos_integer) :: integer\n def mod(dividend, divisor) do\n remainder = rem(dividend, divisor)\n\n if remainder * divisor < 0 do\n remainder + divisor\n else\n remainder\n end\n end\n\n @doc \"\"\"\n Performs a floored integer division.\n\n Raises an `ArithmeticError` exception if one of the arguments is not an\n integer, or when the `divisor` is `0`.\n\n This function performs a *floored* integer division, which means that\n the result will always be rounded towards negative infinity.\n\n If you want to perform truncated integer division (rounding towards zero),\n use `Kernel.div/2` instead.\n\n ## Examples\n\n iex> Integer.floor_div(5, 2)\n 2\n iex> Integer.floor_div(6, -4)\n -2\n iex> Integer.floor_div(-99, 2)\n -50\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec floor_div(integer, neg_integer | pos_integer) :: integer\n def floor_div(dividend, divisor) do\n if :erlang.xor(dividend < 0, divisor < 0) and rem(dividend, divisor) != 0 do\n div(dividend, divisor) - 1\n else\n div(dividend, divisor)\n end\n end\n\n @doc \"\"\"\n Performs a ceiled integer division.\n\n Raises an `ArithmeticError` exception if one of the arguments is not an\n integer, or when the `divisor` is `0`.\n\n This function performs a *ceiled* integer division, which means that\n the result will always be rounded towards positive infinity.\n\n ## Examples\n\n iex> Integer.ceil_div(5, 2)\n 3\n iex> Integer.ceil_div(6, -4)\n -1\n iex> Integer.ceil_div(-99, 2)\n -49\n\n \"\"\"\n @doc since: \"1.20.0\"\n @spec ceil_div(integer, neg_integer | pos_integer) :: integer\n def ceil_div(dividend, divisor) do\n if not :erlang.xor(dividend < 0, divisor < 0) and rem(dividend, divisor) != 0 do\n div(dividend, divisor) + 1\n else\n div(dividend, divisor)\n end\n end\n\n @doc \"\"\"\n Returns the ordered digits for the given `integer`.\n\n An optional `base` value may be provided representing the radix for the returned\n digits. This one must be an integer >= 2.\n\n ## Examples\n\n iex> Integer.digits(123)\n [1, 2, 3]\n\n iex> Integer.digits(170, 2)\n [1, 0, 1, 0, 1, 0, 1, 0]\n\n iex> Integer.digits(-170, 2)\n [-1, 0, -1, 0, -1, 0, -1, 0]\n\n \"\"\"\n @spec digits(integer, pos_integer) :: [integer, ...]\n def digits(integer, base \\\\ 10)\n when is_integer(integer) and is_integer(base) and base >= 2 do\n case integer do\n 0 -> [0]\n _integer -> digits(integer, base, [])\n end\n end\n\n defp digits(0, _base, acc), do: acc\n\n defp digits(integer, base, acc),\n do: digits(div(integer, base), base, [rem(integer, base) | acc])\n\n @doc \"\"\"\n Returns the integer represented by the ordered `digits`.\n\n An optional `base` value may be provided representing the radix for the `digits`.\n Base has to be an integer greater than or equal to `2`.\n\n ## Examples\n\n iex> Integer.undigits([1, 2, 3])\n 123\n\n iex> Integer.undigits([1, 4], 16)\n 20\n\n iex> Integer.undigits([])\n 0\n\n \"\"\"\n @spec undigits([integer], pos_integer) :: integer\n def undigits(digits, base \\\\ 10) when is_list(digits) and is_integer(base) and base >= 2 do\n undigits(digits, base, 0)\n end\n\n defp undigits([], _base, acc), do: acc\n\n defp undigits([digit | _], base, _)\n when is_integer(digit) and (digit >= base or digit <= -base),\n do: raise(ArgumentError, \"invalid digit #{digit} in base #{base}\")\n\n defp undigits([digit | tail], base, acc) when is_integer(digit),\n do: undigits(tail, base, acc * base + digit)\n\n @doc \"\"\"\n Parses a text representation of an integer.\n\n An optional `base` to the corresponding integer can be provided.\n If `base` is not given, 10 will be used.\n\n If successful, returns a tuple in the form of `{integer, remaining_string}`.\n Otherwise `:error`.\n\n Raises an error if `base` is less than 2 or more than 36.\n\n If you want to convert a string-formatted integer directly to an integer,\n `String.to_integer/1` or `String.to_integer/2` can be used instead.\n\n ## Examples\n\n iex> Integer.parse(\"34\")\n {34, \"\"}\n\n iex> Integer.parse(\"34.5\")\n {34, \".5\"}\n\n iex> Integer.parse(\"three\")\n :error\n\n iex> Integer.parse(\"404 not found\")\n {404, \" not found\"}\n\n iex> Integer.parse(\"34\", 10)\n {34, \"\"}\n\n iex> Integer.parse(\"f4\", 16)\n {244, \"\"}\n\n iex> Integer.parse(\"Awww++\", 36)\n {509216, \"++\"}\n\n iex> Integer.parse(\"fab\", 10)\n :error\n\n iex> Integer.parse(\"a2\", 38)\n ** (ArgumentError) invalid base 38\n\n \"\"\"\n @spec parse(binary, 2..36) :: {integer, remainder_of_binary :: binary} | :error\n def parse(binary, base \\\\ 10)\n\n def parse(_binary, base) when base not in 2..36 do\n raise ArgumentError, \"invalid base #{inspect(base)}\"\n end\n\n def parse(binary, base) when is_binary(binary) do\n case count_digits(binary, base) do\n 0 ->\n :error\n\n count ->\n {digits, rem} = :erlang.split_binary(binary, count)\n {:erlang.binary_to_integer(digits, base), rem}\n end\n end\n\n defp count_digits(<>, base) when sign in ~c\"+-\" do\n case count_digits_nosign(rest, base, 1) do\n 1 -> 0\n count -> count\n end\n end\n\n defp count_digits(<>, base) do\n count_digits_nosign(rest, base, 0)\n end\n\n digits = [{?0..?9, -?0}, {?A..?Z, 10 - ?A}, {?a..?z, 10 - ?a}]\n\n for {chars, diff} <- digits,\n char <- chars do\n digit = char + diff\n\n defp count_digits_nosign(<>, base, count)\n when base > unquote(digit) do\n count_digits_nosign(rest, base, count + 1)\n end\n end\n\n defp count_digits_nosign(<<_::bits>>, _, count), do: count\n\n @doc \"\"\"\n Returns a binary which corresponds to the text representation\n of `integer` in the given `base`.\n\n `base` can be an integer between 2 and 36. If no `base` is given,\n it defaults to `10`.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Integer.to_string(123)\n \"123\"\n\n iex> Integer.to_string(+456)\n \"456\"\n\n iex> Integer.to_string(-789)\n \"-789\"\n\n iex> Integer.to_string(0123)\n \"123\"\n\n iex> Integer.to_string(100, 16)\n \"64\"\n\n iex> Integer.to_string(-100, 16)\n \"-64\"\n\n iex> Integer.to_string(882_681_651, 36)\n \"ELIXIR\"\n\n \"\"\"\n @spec to_string(integer, 2..36) :: String.t()\n def to_string(integer, base \\\\ 10) do\n :erlang.integer_to_binary(integer, base)\n end\n\n @doc \"\"\"\n Returns a charlist which corresponds to the text representation\n of `integer` in the given `base`.\n\n `base` can be an integer between 2 and 36. If no `base` is given,\n it defaults to `10`.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Integer.to_charlist(123)\n ~c\"123\"\n\n iex> Integer.to_charlist(+456)\n ~c\"456\"\n\n iex> Integer.to_charlist(-789)\n ~c\"-789\"\n\n iex> Integer.to_charlist(0123)\n ~c\"123\"\n\n iex> Integer.to_charlist(100, 16)\n ~c\"64\"\n\n iex> Integer.to_charlist(-100, 16)\n ~c\"-64\"\n\n iex> Integer.to_charlist(882_681_651, 36)\n ~c\"ELIXIR\"\n\n \"\"\"\n @spec to_charlist(integer, 2..36) :: charlist\n def to_charlist(integer, base \\\\ 10) do\n :erlang.integer_to_list(integer, base)\n end\n\n @doc \"\"\"\n Returns the greatest common divisor of the two given integers.\n\n The greatest common divisor (GCD) of `integer1` and `integer2` is the largest positive\n integer that divides both `integer1` and `integer2` without leaving a remainder.\n\n By convention, `gcd(0, 0)` returns `0`.\n\n ## Examples\n\n iex> Integer.gcd(2, 3)\n 1\n\n iex> Integer.gcd(8, 12)\n 4\n\n iex> Integer.gcd(8, -12)\n 4\n\n iex> Integer.gcd(10, 0)\n 10\n\n iex> Integer.gcd(7, 7)\n 7\n\n iex> Integer.gcd(0, 0)\n 0\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec gcd(integer, integer) :: non_neg_integer\n def gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do\n gcd_positive(abs(integer1), abs(integer2))\n end\n\n defp gcd_positive(0, integer2), do: integer2\n defp gcd_positive(integer1, 0), do: integer1\n defp gcd_positive(integer1, integer2), do: gcd_positive(integer2, rem(integer1, integer2))\n\n @doc \"\"\"\n Returns the extended greatest common divisor of the two given integers.\n\n This function uses the extended Euclidean algorithm to return a three-element tuple with the `gcd`\n and the coefficients `m` and `n` of Bézout's identity such that:\n\n gcd(a, b) = m*a + n*b\n\n By convention, `extended_gcd(0, 0)` returns `{0, 0, 0}`.\n\n ## Examples\n\n iex> Integer.extended_gcd(240, 46)\n {2, -9, 47}\n iex> Integer.extended_gcd(46, 240)\n {2, 47, -9}\n iex> Integer.extended_gcd(-46, 240)\n {2, -47, -9}\n iex> Integer.extended_gcd(-46, -240)\n {2, -47, 9}\n\n iex> Integer.extended_gcd(14, 21)\n {7, -1, 1}\n\n iex> Integer.extended_gcd(10, 0)\n {10, 1, 0}\n iex> Integer.extended_gcd(-10, 0)\n {10, -1, 0}\n iex> Integer.extended_gcd(0, 10)\n {10, 0, 1}\n iex> Integer.extended_gcd(0, -10)\n {10, 0, -1}\n iex> Integer.extended_gcd(0, 0)\n {0, 0, 0}\n\n \"\"\"\n @doc since: \"1.12.0\"\n @spec extended_gcd(integer, integer) :: {non_neg_integer, integer, integer}\n def extended_gcd(0, 0), do: {0, 0, 0}\n def extended_gcd(0, b) when b > 0, do: {b, 0, 1}\n def extended_gcd(0, b) when b < 0, do: {-b, 0, -1}\n def extended_gcd(a, 0) when a > 0, do: {a, 1, 0}\n def extended_gcd(a, 0) when a < 0, do: {-a, -1, 0}\n\n def extended_gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do\n extended_gcd(integer2, integer1, 0, 1, 1, 0)\n end\n\n defp extended_gcd(r1, r0, s1, s0, t1, t0) do\n div = div(r0, r1)\n\n case r0 - div * r1 do\n 0 when r1 > 0 -> {r1, s1, t1}\n 0 when r1 < 0 -> {-r1, -s1, -t1}\n r2 -> extended_gcd(r2, r1, s0 - div * s1, s1, t0 - div * t1, t1)\n end\n end\n\n @doc false\n @deprecated \"Use Integer.to_charlist/1 instead\"\n def to_char_list(integer), do: Integer.to_charlist(integer)\n\n @doc false\n @deprecated \"Use Integer.to_charlist/2 instead\"\n def to_char_list(integer, base), do: Integer.to_charlist(integer, base)\nend\n" }, { "path": "lib/elixir/lib/io/ansi/docs.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule IO.ANSI.Docs do\n @moduledoc false\n\n @type print_opts :: [\n enabled: boolean(),\n doc_bold: [IO.ANSI.ansicode()],\n doc_code: [IO.ANSI.ansicode()],\n doc_headings: [IO.ANSI.ansicode()],\n doc_metadata: [IO.ANSI.ansicode()],\n doc_quote: [IO.ANSI.ansicode()],\n doc_inline_code: [IO.ANSI.ansicode()],\n doc_table_heading: [IO.ANSI.ansicode()],\n doc_title: [IO.ANSI.ansicode()],\n doc_underline: [IO.ANSI.ansicode()],\n width: pos_integer()\n ]\n\n @bullet_text_unicode \"• \"\n @bullet_text_ascii \"* \"\n @bullets [?*, ?-, ?+]\n @spaces [\" \", \"\\n\", \"\\t\"]\n\n @doc \"\"\"\n The default options used by this module.\n\n The supported keys are:\n\n * `:enabled` - toggles coloring on and off (true)\n * `:doc_bold` - bold text (bright)\n * `:doc_code` - code blocks (cyan)\n * `:doc_headings` - h1, h2, h3, h4, h5, h6 headings (yellow)\n * `:doc_metadata` - documentation metadata keys (yellow)\n * `:doc_quote` - leading quote character `> ` (light black)\n * `:doc_inline_code` - inline code (cyan)\n * `:doc_table_heading` - the style for table headings\n * `:doc_title` - top level heading (reverse, yellow)\n * `:doc_underline` - underlined text (underline)\n * `:width` - the width to format the text (80)\n\n Values for the color settings are strings with\n comma-separated ANSI values.\n \"\"\"\n @spec default_options() :: print_opts\n def default_options do\n [\n enabled: true,\n doc_bold: [:bright],\n doc_code: [:cyan],\n doc_headings: [:yellow],\n doc_metadata: [:yellow],\n doc_quote: [:light_black],\n doc_inline_code: [:cyan],\n doc_table_heading: [:reverse],\n doc_title: [:reverse, :yellow],\n doc_underline: [:underline],\n width: 80\n ]\n end\n\n @doc \"\"\"\n Prints the head of the documentation (i.e. the function signature).\n\n See `default_options/0` for docs on the supported options.\n \"\"\"\n @spec print_headings([String.t()], print_opts) :: :ok\n def print_headings(headings, options \\\\ []) do\n # It's possible for some of the headings to contain newline characters (`\\n`), so in order to prevent it from\n # breaking the output from `print_headings/2`, as `print_headings/2` tries to pad the whole heading, we first split\n # any heading containgin newline characters into multiple headings, that way each one is padded on its own.\n headings = Enum.flat_map(headings, fn heading -> String.split(heading, \"\\n\") end)\n options = Keyword.merge(default_options(), options)\n newline_after_block(options)\n width = options[:width]\n\n for heading <- headings do\n padding = div(width + String.length(heading), 2)\n heading = String.pad_leading(heading, padding)\n heading = if options[:enabled], do: String.pad_trailing(heading, width), else: heading\n write(:doc_title, heading, options)\n end\n\n newline_after_block(options)\n end\n\n @doc \"\"\"\n Prints documentation metadata (only `delegate_to`, `deprecated`, `guard`, and `since` for now).\n\n See `default_options/0` for docs on the supported options.\n \"\"\"\n @spec print_metadata(map, print_opts) :: :ok\n def print_metadata(metadata, options \\\\ []) when is_map(metadata) do\n options = Keyword.merge(default_options(), options)\n print_each_metadata(metadata, options) && IO.write(\"\\n\")\n end\n\n @metadata_filter [:deprecated, :guard, :since]\n\n defp print_each_metadata(metadata, options) do\n metadata\n |> Enum.sort()\n |> Enum.reduce(false, fn\n {key, value}, _printed when is_binary(value) and key in @metadata_filter ->\n label = metadata_label(key, options)\n indent = String.duplicate(\" \", length_without_escape(label, 0) + 1)\n write_with_wrap([label | String.split(value, @spaces)], options[:width], indent, true, \"\")\n\n {key, value}, _printed when is_boolean(value) and key in @metadata_filter ->\n IO.puts([metadata_label(key, options), ?\\s, to_string(value)])\n\n {:delegate_to, {m, f, a}}, _printed ->\n label = metadata_label(:delegate_to, options)\n IO.puts([label, ?\\s, Exception.format_mfa(m, f, a)])\n\n _metadata, printed ->\n printed\n end)\n end\n\n defp metadata_label(key, options) do\n \"#{color(:doc_metadata, options)}#{key}:#{maybe_reset(options)}\"\n end\n\n @doc \"\"\"\n Prints the documentation body `doc` according to `format`.\n\n It takes a set of `options` defined in `default_options/0`.\n \"\"\"\n @spec print(term(), String.t(), print_opts) :: :ok\n def print(doc, format, options \\\\ [])\n\n def print(doc, \"text/markdown\", options) when is_binary(doc) and is_list(options) do\n print_markdown(doc, options)\n end\n\n def print(_doc, format, options) when is_binary(format) and is_list(options) do\n IO.puts(\"\\nUnknown documentation format #{inspect(format)}\\n\")\n end\n\n ## Markdown\n\n def print_markdown(doc, options) do\n options = Keyword.merge(default_options(), options)\n\n doc\n |> String.split([\"\\r\\n\", \"\\n\"], trim: false)\n |> Enum.map(&String.trim_trailing/1)\n |> process([], \"\", options)\n end\n\n defp process([], text, indent, options) do\n write_text(text, indent, options)\n end\n\n defp process([\"# \" <> _ = heading | rest], text, indent, options) do\n write_heading(heading, rest, text, indent, options)\n end\n\n defp process([\"## \" <> _ = heading | rest], text, indent, options) do\n write_heading(heading, rest, text, indent, options)\n end\n\n defp process([\"### \" <> _ = heading | rest], text, indent, options) do\n write_heading(heading, rest, text, indent, options)\n end\n\n defp process([\"#### \" <> _ = heading | rest], text, indent, options) do\n write_heading(heading, rest, text, indent, options)\n end\n\n defp process([\"##### \" <> _ = heading | rest], text, indent, options) do\n write_heading(heading, rest, text, indent, options)\n end\n\n defp process([\"###### \" <> _ = heading | rest], text, indent, options) do\n write_heading(heading, rest, text, indent, options)\n end\n\n defp process([\">\" <> line | rest], text, indent, options) do\n write_text(text, indent, options)\n process_quote(rest, [line], indent, options)\n end\n\n defp process([\"\" | rest], text, indent, options) do\n write_text(text, indent, options)\n process(rest, [], indent, options)\n end\n\n defp process([\" \" <> line | rest], text, indent, options) do\n write_text(text, indent, options)\n process_code(rest, [line], indent, options)\n end\n\n defp process([\"```mermaid\" <> _line | rest], text, indent, options) do\n write_text(text, indent, options)\n\n rest\n |> Enum.drop_while(&(&1 != \"```\"))\n |> Enum.drop(1)\n |> process([], indent, options)\n end\n\n defp process([\"```\" <> _line | rest], text, indent, options) do\n process_fenced_code_block(rest, text, indent, options, _delimiter = \"```\")\n end\n\n defp process([\"\")\n rest\n end\n\n defp drop_comment([line | rest]) do\n case :binary.split(line, \"-->\") do\n [_] -> drop_comment(rest)\n [_, line] -> [line | rest]\n end\n end\n\n defp drop_comment([]) do\n []\n end\n\n # We have four entries: **, __, *, _ and `.\n #\n # The first four behave the same while the last one is simpler\n # when it comes to delimiters as it ignores spaces and escape\n # characters. But, since the first two has two characters,\n # we need to handle 3 cases:\n #\n # 1. __ and **\n # 2. _ and *\n # 3. `\n #\n # Where the first two should have the same code but match differently.\n @single [?_, ?*]\n\n # Characters that can mark the beginning or the end of a word.\n # Only support the most common ones at this moment.\n @delimiters [?\\s, ?', ?\", ?!, ?@, ?#, ?$, ?%, ?^, ?&] ++\n [?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]\n\n ### Inline start\n\n defp handle_inline(<>, options) when mark in @single do\n handle_inline(rest, [mark | mark], [<>], [], options)\n end\n\n defp handle_inline(<>, options) when mark in @single do\n handle_inline(rest, mark, [<>], [], options)\n end\n\n defp handle_inline(rest, options) do\n handle_inline(rest, nil, [], [], options)\n end\n\n ### Inline delimiters\n\n defp handle_inline(\">+M: module.child_spec(arg)\n M-->>-S: %{id: term, start: {module, :start_link, [arg]}}\n S-->>+M: module.start_link(arg)\n M->>M: Spawns child process (child_pid)\n M-->>-S: {:ok, child_pid} | :ignore | {:error, reason}\n S->>-C: {:ok, supervisor_pid} | {:error, reason}\n ```\n\n Luckily for us, `use GenServer` already defines a `Counter.child_spec/1`\n exactly like above, so you don't need to write the definition above yourself.\n If you want to customize the automatically generated `child_spec/1` function,\n you can pass the options directly to `use GenServer`:\n\n use GenServer, restart: :transient\n\n Finally, note it is also possible to simply pass the `Counter` module as\n a child:\n\n children = [\n Counter\n ]\n\n When only the module name is given, it is equivalent to `{Counter, []}`,\n which in our case would be invalid, which is why we always pass the initial\n counter explicitly.\n\n By replacing the child specification with `{Counter, 0}`, we keep it\n encapsulated in the `Counter` module. We could now share our\n `Counter` implementation with other developers and they can add it directly\n to their supervision tree without worrying about the low-level details of\n the counter.\n\n Overall, a child specification can be one of the following:\n\n * a map representing the child specification itself - as outlined in the\n \"Child specification\" section\n\n * a tuple with a module as first element and the start argument as second -\n such as `{Counter, 0}`. In this case, `Counter.child_spec(0)` is called\n to retrieve the child specification\n\n * a module - such as `Counter`. In this case, `Counter.child_spec([])`\n would be called, which is invalid for the counter, but it is useful in\n many other cases, especially when you want to pass a list of options\n to the child process\n\n If you need to convert a `{module, arg}` tuple or a module child specification to a\n [child specification](`t:child_spec/0`) or modify a child specification itself,\n you can use the `Supervisor.child_spec/2` function.\n For example, to run the counter with a different `:id` and a `:shutdown` value of\n 10 seconds (10_000 milliseconds):\n\n children = [\n Supervisor.child_spec({Counter, 0}, id: MyCounter, shutdown: 10_000)\n ]\n\n ## Supervisor strategies and options\n\n So far we have started the supervisor passing a single child as a tuple\n as well as a strategy called `:one_for_one`:\n\n children = [\n {Counter, 0}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n\n The first argument given to `start_link/2` is a list of child\n specifications as defined in the \"child_spec/1\" section above.\n\n The second argument is a keyword list of options:\n\n * `:strategy` - the supervision strategy option. It can be either\n `:one_for_one`, `:rest_for_one` or `:one_for_all`. Required.\n See the \"Strategies\" section.\n\n * `:max_restarts` - the maximum number of restarts allowed in\n a time frame. Defaults to `3`.\n\n * `:max_seconds` - the time frame in which `:max_restarts` applies.\n Defaults to `5`.\n\n * `:auto_shutdown` - the automatic shutdown option. It can be\n `:never`, `:any_significant`, or `:all_significant`. Optional.\n See the \"Automatic shutdown\" section.\n\n * `:name` - a name to register the supervisor process. Supported values are\n explained in the \"Name registration\" section in the documentation for\n `GenServer`. Optional.\n\n ### Strategies\n\n Supervisors support different supervision strategies (through the\n `:strategy` option, as seen above):\n\n * `:one_for_one` - if a child process terminates, only that\n process is restarted.\n\n * `:one_for_all` - if a child process terminates, all other child\n processes are terminated and then all child processes (including\n the terminated one) are restarted.\n\n * `:rest_for_one` - if a child process terminates, the terminated child\n process and the rest of the children started after it, are terminated and\n restarted.\n\n In the above, process termination refers to unsuccessful termination, which\n is determined by the `:restart` option.\n\n To efficiently supervise children started dynamically, see `DynamicSupervisor`.\n\n ### Automatic shutdown\n\n Supervisors have the ability to automatically shut themselves down when child\n processes marked as `:significant` exit.\n\n Supervisors support different automatic shutdown options (through\n the `:auto_shutdown` option, as seen above):\n\n * `:never` - this is the default, automatic shutdown is disabled.\n\n * `:any_significant` - if any significant child process exits, the supervisor\n will automatically shut down its children, then itself.\n\n * `:all_significant` - when all significant child processes have exited,\n the supervisor will automatically shut down its children, then itself.\n\n Only `:transient` and `:temporary` child processes can be marked as significant,\n and this configuration affects the behavior. Significant `:transient` child\n processes must exit normally for automatic shutdown to be considered, where\n `:temporary` child processes may exit for any reason.\n\n ### Name registration\n\n A supervisor is bound to the same name registration rules as a `GenServer`.\n Read more about these rules in the documentation for `GenServer`.\n\n ## Module-based supervisors\n\n In the example so far, the supervisor was started by passing the supervision\n structure to `start_link/2`. However, supervisors can also be created by\n explicitly defining a supervision module:\n\n defmodule MyApp.Supervisor do\n # Automatically defines child_spec/1\n use Supervisor\n\n def start_link(init_arg) do\n Supervisor.start_link(__MODULE__, init_arg, name: __MODULE__)\n end\n\n @impl true\n def init(_init_arg) do\n children = [\n {Counter, 0}\n ]\n\n Supervisor.init(children, strategy: :one_for_one)\n end\n end\n\n The difference between the two approaches is that a module-based\n supervisor gives you more direct control over how the supervisor\n is initialized. Instead of calling `Supervisor.start_link/2` with\n a list of child specifications that are implicitly initialized for us,\n we must explicitly initialize the children by calling `Supervisor.init/2`\n inside its `c:init/1` callback. `Supervisor.init/2` accepts the same\n `:strategy`, `:max_restarts`, and `:max_seconds` options as `start_link/2`.\n\n > #### `use Supervisor` {: .info}\n >\n > When you `use Supervisor`, the `Supervisor` module will\n > set `@behaviour Supervisor` and define a `child_spec/1`\n > function, so your module can be used as a child\n > in a supervision tree.\n\n `use Supervisor` also defines a `child_spec/1` function which allows\n us to run `MyApp.Supervisor` as a child of another supervisor or\n at the top of your supervision tree as:\n\n children = [\n MyApp.Supervisor\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n\n A general guideline is to use the supervisor without a callback\n module only at the top of your supervision tree, generally in the\n `c:Application.start/2` callback. We recommend using module-based\n supervisors for any other supervisor in your application, so they\n can run as a child of another supervisor in the tree. The `child_spec/1`\n generated automatically by `Supervisor` can be customized with the\n following options:\n\n * `:id` - the child specification identifier, defaults to the current module\n * `:restart` - when the supervisor should be restarted, defaults to `:permanent`\n\n The `@doc` annotation immediately preceding `use Supervisor` will be\n attached to the generated `child_spec/1` function.\n\n ## Start and shutdown\n\n When the supervisor starts, it traverses all child specifications and\n then starts each child in the order they are defined. This is done by\n calling the function defined under the `:start` key in the child\n specification and typically defaults to `start_link/1`.\n\n The `start_link/1` (or a custom) is then called for each child process.\n The `start_link/1` function must return `{:ok, pid}` where `pid` is the\n process identifier of a new process that is linked to the supervisor.\n The child process usually starts its work by executing the `c:init/1`\n callback. Generally speaking, the `init` callback is where we initialize\n and configure the child process.\n\n The shutdown process happens in reverse order.\n\n When a supervisor shuts down, it terminates all children in the opposite\n order they are listed. The termination happens by sending a shutdown exit\n signal, via `Process.exit(child_pid, :shutdown)`, to the child process and\n then awaiting for a time interval for the child process to terminate. This\n interval defaults to 5000 milliseconds. If the child process does not\n terminate in this interval, the supervisor abruptly terminates the child\n with reason `:kill`. The shutdown time can be configured in the child\n specification which is fully detailed in the next section.\n\n If the child process is not trapping exits, it will shutdown immediately\n when it receives the first exit signal. If the child process is trapping\n exits, then the `terminate` callback is invoked, and the child process\n must terminate in a reasonable time interval before being abruptly\n terminated by the supervisor.\n\n In other words, if it is important that a process cleans after itself\n when your application or the supervision tree is shutting down, then\n this process must trap exits and its child specification should specify\n the proper `:shutdown` value, ensuring it terminates within a reasonable\n interval.\n\n ## Exit reasons and restarts\n\n A supervisor restarts a child process depending on its `:restart` configuration.\n For example, when `:restart` is set to `:transient`, the supervisor does not\n restart the child in case it exits with reason `:normal`, `:shutdown` or\n `{:shutdown, term}`.\n\n Those exits also impact logging. By default, behaviours such as GenServers\n do not emit error logs when the exit reason is `:normal`, `:shutdown` or\n `{:shutdown, term}`.\n\n So one may ask: which exit reason should I choose? There are three options:\n\n * `:normal` - in such cases, the exit won't be logged, there is no restart\n in transient mode, and linked processes do not exit\n\n * `:shutdown` or `{:shutdown, term}` - in such cases, the exit won't be\n logged, there is no restart in transient mode, and linked processes exit\n with the same reason unless they're trapping exits\n\n * any other term - in such cases, the exit will be logged, there are\n restarts in transient mode, and linked processes exit with the same\n reason unless they're trapping exits\n\n Generally speaking, if you are exiting for expected reasons, you want to use\n `:shutdown` or `{:shutdown, term}`.\n\n Note that the supervisor that reaches maximum restart intensity will exit with\n `:shutdown` reason. In this case the supervisor will only be restarted if its\n child specification was defined with the `:restart` option set to `:permanent`\n (the default).\n \"\"\"\n\n @doc false\n defmacro __using__(opts) do\n quote location: :keep, bind_quoted: [opts: opts] do\n import Supervisor.Spec\n @behaviour Supervisor\n\n if not Module.has_attribute?(__MODULE__, :doc) do\n @doc \"\"\"\n Returns a specification to start this module under a supervisor.\n\n See `Supervisor`.\n \"\"\"\n end\n\n def child_spec(init_arg) do\n default = %{\n id: __MODULE__,\n start: {__MODULE__, :start_link, [init_arg]},\n type: :supervisor\n }\n\n Supervisor.child_spec(default, unquote(Macro.escape(opts)))\n end\n\n defoverridable child_spec: 1\n end\n end\n\n @doc \"\"\"\n Callback invoked to start the supervisor and during hot code upgrades.\n\n Developers typically invoke `Supervisor.init/2` at the end of their\n init callback to return the proper supervision flags.\n \"\"\"\n @callback init(init_arg :: term) ::\n {:ok,\n {sup_flags(), [child_spec() | (old_erlang_child_spec :: :supervisor.child_spec())]}}\n | :ignore\n\n @typedoc \"Return values of `start_link/2` and `start_link/3`.\"\n @type on_start ::\n {:ok, pid}\n | :ignore\n | {:error, {:already_started, pid} | {:shutdown, term} | term}\n\n @typedoc \"Return values of `start_child/2`.\"\n @type on_start_child ::\n {:ok, child}\n | {:ok, child, info :: term}\n | {:error, {:already_started, child} | :already_present | term}\n\n @typedoc \"\"\"\n A child process.\n\n It can be a PID when the child process was started, or `:undefined` when\n the child was created by a [dynamic supervisor](`DynamicSupervisor`).\n \"\"\"\n @type child :: pid | :undefined\n\n @typedoc \"The supervisor name.\"\n @type name :: atom | {:global, term} | {:via, module, term}\n\n @typedoc \"Option values used by the `start_link/2` and `start_link/3` functions.\"\n @type option :: {:name, name}\n\n @typedoc \"The supervisor flags returned on init.\"\n @type sup_flags() :: %{\n strategy: strategy(),\n intensity: non_neg_integer(),\n period: pos_integer(),\n auto_shutdown: auto_shutdown()\n }\n\n @typedoc \"The supervisor reference.\"\n @type supervisor :: pid | name | {atom, node}\n\n @typedoc \"Options given to `start_link/2` and `init/2`.\"\n @type init_option ::\n {:strategy, strategy}\n | {:max_restarts, non_neg_integer}\n | {:max_seconds, pos_integer}\n | {:auto_shutdown, auto_shutdown}\n\n @typedoc \"Supported restart options.\"\n @type restart :: :permanent | :transient | :temporary\n\n @typedoc \"Supported shutdown options.\"\n @type shutdown :: timeout() | :brutal_kill\n\n @typedoc \"Supported strategies.\"\n @type strategy :: :one_for_one | :one_for_all | :rest_for_one\n\n @typedoc \"Supported automatic shutdown options.\"\n @type auto_shutdown :: :never | :any_significant | :all_significant\n\n @typedoc \"\"\"\n Type of a supervised child.\n\n Whether the supervised child is a worker or a supervisor.\n \"\"\"\n @type type :: :worker | :supervisor\n\n # Note we have inlined all types for readability\n @typedoc \"\"\"\n The supervisor child specification.\n\n It defines how the supervisor should start, stop and restart each of its children.\n \"\"\"\n @type child_spec :: %{\n required(:id) => atom() | term(),\n required(:start) => {module(), function_name :: atom(), args :: [term()]},\n optional(:restart) => restart(),\n optional(:shutdown) => shutdown(),\n optional(:type) => type(),\n optional(:modules) => [module()] | :dynamic,\n optional(:significant) => boolean()\n }\n\n @typedoc \"\"\"\n A module-based child spec.\n\n This is a form of child spec that you can pass to functions such as `child_spec/2`,\n `start_child/2`, and `start_link/2`, in addition to the normalized `t:child_spec/0`.\n\n A module-based child spec can be:\n\n * a **module** — the supervisor calls `module.child_spec([])` to retrieve the\n child specification\n\n * a **two-element tuple** in the shape of `{module, arg}` — the supervisor\n calls `module.child_spec(arg)` to retrieve the child specification\n\n \"\"\"\n @typedoc since: \"1.16.0\"\n @type module_spec :: {module(), args :: term()} | module()\n\n @typedoc \"\"\"\n Options for overriding child specification fields.\n \"\"\"\n @type child_spec_overrides :: [\n id: atom() | term(),\n start: {module(), atom(), [term()]},\n restart: restart(),\n shutdown: shutdown(),\n type: type(),\n modules: [module()] | :dynamic,\n significant: boolean()\n ]\n\n @doc \"\"\"\n Starts a supervisor with the given children.\n\n `children` is a list of the following forms:\n\n * a child specification (see `t:child_spec/0`)\n\n * a module, where the supervisor calls `module.child_spec([])`\n to retrieve the child specification (see `t:module_spec/0`)\n\n * a `{module, arg}` tuple, where the supervisor calls `module.child_spec(arg)`\n to retrieve the child specification (see `t:module_spec/0`)\n\n * a (old) Erlang-style child specification (see\n [`:supervisor.child_spec()`](`t::supervisor.child_spec/0`))\n\n A strategy is required to be provided through the `:strategy` option. See\n \"Supervisor strategies and options\" for examples and other options.\n\n The options can also be used to register a supervisor name.\n The supported values are described under the \"Name registration\"\n section in the `GenServer` module docs.\n\n If the supervisor and all child processes are successfully spawned\n (if the start function of each child process returns `{:ok, child}`,\n `{:ok, child, info}`, or `:ignore`), this function returns\n `{:ok, pid}`, where `pid` is the PID of the supervisor. If the supervisor\n is given a name and a process with the specified name already exists,\n the function returns `{:error, {:already_started, pid}}`, where `pid`\n is the PID of that process.\n\n If the start function of any of the child processes fails or returns an error\n tuple or an erroneous value, the supervisor first terminates with reason\n `:shutdown` all the child processes that have already been started, and then\n terminates itself and returns `{:error, {:shutdown, reason}}`.\n\n Note that a supervisor started with this function is linked to the parent\n process and exits not only on crashes but also if the parent process exits\n with `:normal` reason.\n \"\"\"\n @spec start_link(\n [child_spec | module_spec | (old_erlang_child_spec :: :supervisor.child_spec())],\n [option | init_option]\n ) ::\n {:ok, pid} | {:error, {:already_started, pid} | {:shutdown, term} | term}\n def start_link(children, options) when is_list(children) do\n {sup_opts, start_opts} =\n Keyword.split(options, [:strategy, :max_seconds, :max_restarts, :auto_shutdown])\n\n start_link(Supervisor.Default, init(children, sup_opts), start_opts)\n end\n\n @doc \"\"\"\n Receives a list of child specifications to initialize and a set of `options`.\n\n This is typically invoked at the end of the `c:init/1` callback of\n module-based supervisors. See the sections \"Supervisor strategies and options\" and\n \"Module-based supervisors\" in the module documentation for more information.\n\n This function returns a tuple containing the supervisor\n flags and child specifications.\n\n ## Examples\n\n def init(_init_arg) do\n children = [\n {Counter, 0}\n ]\n\n Supervisor.init(children, strategy: :one_for_one)\n end\n\n ## Options\n\n * `:strategy` - the supervision strategy option. It can be either\n `:one_for_one`, `:rest_for_one`, or `:one_for_all`\n\n * `:max_restarts` - the maximum number of restarts allowed in\n a time frame. Defaults to `3`.\n\n * `:max_seconds` - the time frame in seconds in which `:max_restarts`\n applies. Defaults to `5`.\n\n * `:auto_shutdown` - the automatic shutdown option. It can be either\n `:never`, `:any_significant`, or `:all_significant`\n\n The `:strategy` option is required and by default a maximum of 3 restarts\n is allowed within 5 seconds. Check the `Supervisor` module for a detailed\n description of the available strategies.\n \"\"\"\n @doc since: \"1.5.0\"\n @spec init(\n [child_spec | module_spec | (old_erlang_child_spec :: :supervisor.child_spec())],\n [init_option]\n ) ::\n {:ok,\n {sup_flags(), [child_spec() | (old_erlang_child_spec :: :supervisor.child_spec())]}}\n def init(children, options) when is_list(children) and is_list(options) do\n strategy =\n case options[:strategy] do\n nil ->\n raise ArgumentError, \"expected :strategy option to be given\"\n\n :simple_one_for_one ->\n IO.warn(\n \":simple_one_for_one strategy is deprecated, please use DynamicSupervisor instead\"\n )\n\n :simple_one_for_one\n\n other ->\n other\n end\n\n intensity = Keyword.get(options, :max_restarts, 3)\n period = Keyword.get(options, :max_seconds, 5)\n auto_shutdown = Keyword.get(options, :auto_shutdown, :never)\n\n flags = %{\n strategy: strategy,\n intensity: intensity,\n period: period,\n auto_shutdown: auto_shutdown\n }\n\n {:ok, {flags, Enum.map(children, &init_child/1)}}\n end\n\n defp init_child(module) when is_atom(module) do\n init_child({module, []})\n end\n\n defp init_child({module, arg}) when is_atom(module) do\n try do\n module.child_spec(arg)\n rescue\n e in UndefinedFunctionError ->\n case __STACKTRACE__ do\n [{^module, :child_spec, [^arg], _} | _] ->\n raise ArgumentError, child_spec_error(module)\n\n stack ->\n reraise e, stack\n end\n end\n end\n\n defp init_child(map) when is_map(map) do\n map\n end\n\n defp init_child({_, _, _, _, _, _} = tuple) do\n tuple\n end\n\n defp init_child(other) do\n raise ArgumentError, \"\"\"\n supervisors expect each child to be one of the following:\n\n * a module\n * a {module, arg} tuple\n * a child specification as a map with at least the :id and :start fields\n * or a tuple with 6 elements generated by Supervisor.Spec (deprecated)\n\n Got: #{inspect(other)}\n \"\"\"\n end\n\n defp child_spec_error(module) do\n if Code.ensure_loaded?(module) do\n \"\"\"\n The module #{inspect(module)} was given as a child to a supervisor\n but it does not implement child_spec/1.\n\n If you own the given module, please define a child_spec/1 function\n that receives an argument and returns a child specification as a map.\n For example:\n\n def child_spec(opts) do\n %{\n id: __MODULE__,\n start: {__MODULE__, :start_link, [opts]},\n type: :worker,\n restart: :permanent,\n shutdown: 500\n }\n end\n\n Note that \"use Agent\", \"use GenServer\" and so on automatically define\n this function for you.\n\n However, if you don't own the given module and it doesn't implement\n child_spec/1, instead of passing the module name directly as a supervisor\n child, you will have to pass a child specification as a map:\n\n %{\n id: #{inspect(module)},\n start: {#{inspect(module)}, :start_link, [arg1, arg2]}\n }\n\n See the Supervisor documentation for more information\n \"\"\"\n else\n \"The module #{inspect(module)} was given as a child to a supervisor but it does not exist\"\n end\n end\n\n @doc \"\"\"\n Builds and overrides a child specification.\n\n Similar to `start_link/2` and `init/2`, it expects a module, `{module, arg}`,\n or a [child specification](`t:child_spec/0`).\n\n If a two-element tuple in the shape of `{module, arg}` is given,\n the child specification is retrieved by calling `module.child_spec(arg)`.\n\n If a module is given, the child specification is retrieved by calling\n `module.child_spec([])`.\n\n After the child specification is retrieved, the fields on `overrides`\n are directly applied to the child spec. If `overrides` has keys that\n do not map to any child specification field, an error is raised.\n\n See the \"Child specification\" section in the module documentation\n for all of the available keys for overriding.\n\n ## Examples\n\n This function is often used to set an `:id` option when\n the same module needs to be started multiple times in the\n supervision tree:\n\n Supervisor.child_spec({Agent, fn -> :ok end}, id: {Agent, 1})\n #=> %{id: {Agent, 1},\n #=> start: {Agent, :start_link, [fn -> :ok end]}}\n\n \"\"\"\n @spec child_spec(child_spec() | module_spec(), child_spec_overrides()) :: child_spec()\n def child_spec(module_or_map, overrides)\n\n def child_spec({_, _, _, _, _, _} = tuple, _overrides) do\n raise ArgumentError,\n \"old tuple-based child specification #{inspect(tuple)} \" <>\n \"is not supported in Supervisor.child_spec/2\"\n end\n\n def child_spec(module_or_map, overrides) do\n Enum.reduce(overrides, init_child(module_or_map), fn\n {key, value}, acc\n when key in [:id, :start, :restart, :shutdown, :type, :modules, :significant] ->\n Map.put(acc, key, value)\n\n {key, _value}, _acc ->\n raise ArgumentError, \"unknown key #{inspect(key)} in child specification override\"\n end)\n end\n\n @doc \"\"\"\n Starts a module-based supervisor process with the given `module` and `init_arg`.\n\n To start the supervisor, the `c:init/1` callback will be invoked in the given\n `module`, with `init_arg` as its argument. The `c:init/1` callback must return a\n supervisor specification which can be created with the help of the `init/2`\n function.\n\n If the `c:init/1` callback returns `:ignore`, this function returns\n `:ignore` as well and the supervisor terminates with reason `:normal`.\n If it fails or returns an incorrect value, this function returns\n `{:error, term}` where `term` is a term with information about the\n error, and the supervisor terminates with reason `term`.\n\n The `:name` option can also be given in order to register a supervisor\n name, the supported values are described in the \"Name registration\"\n section in the `GenServer` module docs.\n \"\"\"\n\n # It is important to keep the two-arity spec because it is a catch-all\n # to start_link(children, options).\n @spec start_link(module, term) :: on_start\n @spec start_link(module, term, [option]) :: on_start\n def start_link(module, init_arg, options \\\\ []) when is_list(options) do\n case Keyword.get(options, :name) do\n nil ->\n :supervisor.start_link(module, init_arg)\n\n atom when is_atom(atom) ->\n :supervisor.start_link({:local, atom}, module, init_arg)\n\n {:global, _term} = tuple ->\n :supervisor.start_link(tuple, module, init_arg)\n\n {:via, via_module, _term} = tuple when is_atom(via_module) ->\n :supervisor.start_link(tuple, module, init_arg)\n\n other ->\n raise ArgumentError, \"\"\"\n expected :name option to be one of the following:\n\n * nil\n * atom\n * {:global, term}\n * {:via, module, term}\n\n Got: #{inspect(other)}\n \"\"\"\n end\n end\n\n @doc \"\"\"\n Adds a child specification to `supervisor` and starts that child.\n\n `child_spec` should be a valid child specification. The child process will\n be started as defined in the child specification.\n\n If a child specification with the specified ID already exists, `child_spec` is\n discarded and this function returns an error with `:already_started` or\n `:already_present` if the corresponding child process is running or not,\n respectively.\n\n If the child process start function returns `{:ok, child}` or `{:ok, child,\n info}`, then child specification and PID are added to the supervisor and\n this function returns the same value.\n\n If the child process start function returns `:ignore`, the child specification\n is added to the supervisor, the PID is set to `:undefined` and this function\n returns `{:ok, :undefined}`.\n\n If the child process start function returns an error tuple or an erroneous\n value, or if it fails, the child specification is discarded and this function\n returns `{:error, error}` where `error` is a term containing information about\n the error and child specification.\n\n > #### Order Among Children {: .tip}\n >\n > The child specification is **appended** to the children of `supervisor`.\n > This guarantees that semantics of things such as the `:rest_for_one` strategy\n > are preserved correctly.\n \"\"\"\n @spec start_child(\n supervisor,\n child_spec | module_spec | (old_erlang_child_spec :: :supervisor.child_spec())\n ) :: on_start_child\n def start_child(supervisor, {_, _, _, _, _, _} = child_spec) do\n call(supervisor, {:start_child, child_spec})\n end\n\n def start_child(supervisor, args) when is_list(args) do\n IO.warn_once(\n {__MODULE__, :start_child},\n fn ->\n \"Supervisor.start_child/2 with a list of args is deprecated, please use DynamicSupervisor instead\"\n end,\n _stacktrace_drop_levels = 2\n )\n\n call(supervisor, {:start_child, args})\n end\n\n def start_child(supervisor, child_spec) do\n call(supervisor, {:start_child, Supervisor.child_spec(child_spec, [])})\n end\n\n @doc \"\"\"\n Terminates the given child identified by `child_id`.\n\n The process is terminated, if there's one. The child specification is\n kept unless the child is temporary.\n\n A non-temporary child process may later be restarted by the supervisor.\n The child process can also be restarted explicitly by calling `restart_child/2`.\n Use `delete_child/2` to remove the child specification.\n\n If successful, this function returns `:ok`. If there is no child\n specification for the given child ID, this function returns\n `{:error, :not_found}`.\n \"\"\"\n @spec terminate_child(supervisor, term()) :: :ok | {:error, :not_found}\n def terminate_child(supervisor, child_id)\n\n def terminate_child(supervisor, pid) when is_pid(pid) do\n IO.warn(\n \"Supervisor.terminate_child/2 with a PID is deprecated, please use DynamicSupervisor instead\"\n )\n\n call(supervisor, {:terminate_child, pid})\n end\n\n def terminate_child(supervisor, child_id) do\n call(supervisor, {:terminate_child, child_id})\n end\n\n @doc \"\"\"\n Deletes the child specification identified by `child_id`.\n\n The corresponding child process must not be running; use `terminate_child/2`\n to terminate it if it's running.\n\n If successful, this function returns `:ok`. This function may return an error\n with an appropriate error tuple if the `child_id` is not found, or if the\n current process is running or being restarted.\n \"\"\"\n @spec delete_child(supervisor, term()) :: :ok | {:error, error}\n when error: :not_found | :running | :restarting\n def delete_child(supervisor, child_id) do\n call(supervisor, {:delete_child, child_id})\n end\n\n @doc \"\"\"\n Restarts a child process identified by `child_id`.\n\n The child specification must exist and the corresponding child process must not\n be running.\n\n Note that for temporary children, the child specification is automatically deleted\n when the child terminates, and thus it is not possible to restart such children.\n\n If the child process start function returns `{:ok, child}` or `{:ok, child, info}`,\n the PID is added to the supervisor and this function returns the same value.\n\n If the child process start function returns `:ignore`, the PID remains set to\n `:undefined` and this function returns `{:ok, :undefined}`.\n\n This function may return an error with an appropriate error tuple if the\n `child_id` is not found, or if the current process is running or being\n restarted.\n\n If the child process start function returns an error tuple or an erroneous value,\n or if it fails, this function returns `{:error, error}`.\n \"\"\"\n @spec restart_child(supervisor, term()) :: {:ok, child} | {:ok, child, term} | {:error, error}\n when error: :not_found | :running | :restarting | term\n def restart_child(supervisor, child_id) do\n call(supervisor, {:restart_child, child_id})\n end\n\n @doc \"\"\"\n Returns a list with information about all children of the given supervisor.\n\n Note that calling this function when supervising a large number of children\n under low memory conditions can bring the system down due to an out of memory\n error.\n\n This function returns a list of `{id, child, type, modules}` tuples, where:\n\n * `id` - as defined in the child specification\n\n * `child` - the PID of the corresponding child process, `:restarting` if the\n process is about to be restarted, or `:undefined` if there is no such\n process\n\n * `type` - `:worker` or `:supervisor`, as specified by the child specification\n\n * `modules` - as specified by the child specification\n\n \"\"\"\n @spec which_children(supervisor) :: [\n # inlining module() | :dynamic here because :supervisor.modules() is not exported\n {term() | :undefined, child | :restarting, :worker | :supervisor, [module()] | :dynamic}\n ]\n def which_children(supervisor) do\n call(supervisor, :which_children)\n end\n\n @doc \"\"\"\n Returns a map containing count values for the given supervisor.\n\n The map contains the following keys:\n\n * `:specs` - the total count of children, dead or alive\n\n * `:active` - the count of all actively running child processes managed by\n this supervisor\n\n * `:supervisors` - the count of all supervisors whether or not these\n child supervisors are still alive\n\n * `:workers` - the count of all workers, whether or not these child workers\n are still alive\n\n \"\"\"\n @spec count_children(supervisor) :: %{\n specs: non_neg_integer,\n active: non_neg_integer,\n supervisors: non_neg_integer,\n workers: non_neg_integer\n }\n def count_children(supervisor) do\n call(supervisor, :count_children) |> :maps.from_list()\n end\n\n @doc \"\"\"\n Synchronously stops the given supervisor with the given `reason`.\n\n It returns `:ok` if the supervisor terminates with the given\n reason. If it terminates with another reason, the call exits.\n\n This function keeps OTP semantics regarding error reporting.\n If the reason is any other than `:normal`, `:shutdown` or\n `{:shutdown, _}`, an error report is logged.\n \"\"\"\n @spec stop(supervisor, reason :: term, timeout) :: :ok\n def stop(supervisor, reason \\\\ :normal, timeout \\\\ :infinity) do\n GenServer.stop(supervisor, reason, timeout)\n end\n\n @compile {:inline, call: 2}\n\n defp call(supervisor, req) do\n GenServer.call(supervisor, req, :infinity)\n end\nend\n" }, { "path": "lib/elixir/lib/system.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule System do\n @moduledoc \"\"\"\n The `System` module provides functions that interact directly\n with the VM or the host system.\n\n ## Time\n\n The `System` module also provides functions that work with time,\n returning different times kept by the system with support for\n different time units.\n\n One of the complexities in relying on system times is that they\n may be adjusted. For example, when you enter and leave daylight\n saving time, the system clock will be adjusted, often adding\n or removing one hour. We call such changes \"time warps\". In\n order to understand how such changes may be harmful, imagine\n the following code:\n\n ## DO NOT DO THIS\n prev = System.os_time()\n # ... execute some code ...\n next = System.os_time()\n diff = next - prev\n\n If, while the code is executing, the system clock changes,\n some code that executed in 1 second may be reported as taking\n over 1 hour! To address such concerns, the VM provides a\n monotonic time via `System.monotonic_time/0` which never\n decreases and does not leap:\n\n ## DO THIS\n prev = System.monotonic_time()\n # ... execute some code ...\n next = System.monotonic_time()\n diff = next - prev\n\n Generally speaking, the VM provides three time measurements:\n\n * `os_time/0` - the time reported by the operating system (OS). This time may be\n adjusted forwards or backwards in time with no limitation;\n\n * `system_time/0` - the VM view of the `os_time/0`. The system time and operating\n system time may not match in case of time warps although the VM works towards\n aligning them. This time is not monotonic (i.e., it may decrease)\n as its behavior is configured [by the VM time warp\n mode](https://www.erlang.org/doc/apps/erts/time_correction.html#Time_Warp_Modes);\n\n * `monotonic_time/0` - a monotonically increasing time provided\n by the Erlang VM. This is not strictly monotonically increasing. Multiple\n sequential calls of the function may return the same value.\n\n The time functions in this module work in the `:native` unit\n (unless specified otherwise), which is operating system dependent. Most of\n the time, all calculations are done in the `:native` unit, to\n avoid loss of precision, with `convert_time_unit/3` being\n invoked at the end to convert to a specific time unit like\n `:millisecond` or `:microsecond`. See the `t:time_unit/0` type for\n more information.\n\n For a more complete rundown on the VM support for different\n times, see the [chapter on time and time\n correction](https://www.erlang.org/doc/apps/erts/time_correction.html)\n in the Erlang docs.\n \"\"\"\n\n defmodule EnvError do\n @moduledoc \"\"\"\n An exception raised when a system environment variable is not set.\n\n For example, see `System.fetch_env!/1`.\n \"\"\"\n\n defexception [:env]\n\n @impl true\n def message(%{env: env}) do\n \"could not fetch environment variable #{inspect(env)} because it is not set\"\n end\n end\n\n @typedoc \"\"\"\n The time unit to be passed to functions like `monotonic_time/1` and others.\n\n The `:second`, `:millisecond`, `:microsecond` and `:nanosecond` time\n units controls the return value of the functions that accept a time unit.\n\n A time unit can also be a strictly positive integer. In this case, it\n represents the \"parts per second\": the time will be returned in `1 /\n parts_per_second` seconds. For example, using the `:millisecond` time unit\n is equivalent to using `1000` as the time unit (as the time will be returned\n in 1/1000 seconds - milliseconds).\n \"\"\"\n @type time_unit ::\n :second\n | :millisecond\n | :microsecond\n | :nanosecond\n | pos_integer\n\n @type signal ::\n :sigabrt\n | :sigalrm\n | :sigchld\n | :sighup\n | :sigquit\n | :sigstop\n | :sigterm\n | :sigtstp\n | :sigusr1\n | :sigusr2\n\n @type cmd_opts :: [\n into: Collectable.t(),\n lines: pos_integer(),\n cd: Path.t(),\n env: [{binary(), binary() | nil}],\n arg0: binary(),\n stderr_to_stdout: boolean(),\n use_stdio: boolean(),\n parallelism: boolean()\n ]\n\n @type shell_opts :: [\n into: Collectable.t(),\n lines: pos_integer(),\n cd: Path.t(),\n env: [{binary(), binary() | nil}],\n stderr_to_stdout: boolean(),\n use_stdio: boolean(),\n parallelism: boolean(),\n close_stdin: boolean()\n ]\n\n @vm_signals [:sigquit, :sigterm, :sigusr1]\n @os_signals [:sighup, :sigabrt, :sigalrm, :sigusr2, :sigchld, :sigstop, :sigtstp]\n @signals @vm_signals ++ @os_signals\n\n @base_dir :filename.join(__DIR__, \"../../..\")\n @version_file :filename.join(@base_dir, \"VERSION\")\n\n defp strip(iodata) do\n :re.replace(iodata, \"^[\\s\\r\\n\\t]+|[\\s\\r\\n\\t]+$\", \"\", [:global, return: :binary])\n end\n\n defp read_stripped(path) do\n case :file.read_file(path) do\n {:ok, binary} ->\n strip(binary)\n\n _ ->\n \"\"\n end\n end\n\n # Read and strip the version from the VERSION file.\n defmacrop get_version do\n case read_stripped(@version_file) do\n \"\" -> raise \"could not read the version number from VERSION\"\n data -> data\n end\n end\n\n # Returns OTP version that Elixir was compiled with.\n defmacrop get_otp_release do\n :erlang.list_to_binary(:erlang.system_info(:otp_release))\n end\n\n # Tries to run \"git rev-parse --short=7 HEAD\". In the case of success returns\n # the short revision hash. If that fails, returns an empty string.\n defmacrop get_revision do\n null =\n case :os.type() do\n {:win32, _} -> ~c\"NUL\"\n _ -> ~c\"/dev/null\"\n end\n\n ~c\"git rev-parse --short=7 HEAD 2> \"\n |> Kernel.++(null)\n |> :os.cmd()\n |> strip()\n end\n\n defp revision, do: get_revision()\n\n # Get the date at compilation time.\n # Follows https://reproducible-builds.org/specs/source-date-epoch/\n defmacrop get_date do\n unix_epoch =\n if source_date_epoch = :os.getenv(~c\"SOURCE_DATE_EPOCH\") do\n try do\n List.to_integer(source_date_epoch)\n rescue\n _ -> nil\n end\n end\n\n unix_epoch = unix_epoch || :os.system_time(:second)\n\n {{year, month, day}, {hour, minute, second}} =\n :calendar.gregorian_seconds_to_datetime(unix_epoch + 62_167_219_200)\n\n \"~4..0b-~2..0b-~2..0bT~2..0b:~2..0b:~2..0bZ\"\n |> :io_lib.format([year, month, day, hour, minute, second])\n |> :erlang.iolist_to_binary()\n end\n\n @doc \"\"\"\n Returns the endianness.\n \"\"\"\n @spec endianness() :: :little | :big\n def endianness do\n :erlang.system_info(:endian)\n end\n\n @doc \"\"\"\n Returns the endianness the system was compiled with.\n \"\"\"\n @endianness :erlang.system_info(:endian)\n @spec compiled_endianness() :: :little | :big\n def compiled_endianness do\n @endianness\n end\n\n @doc \"\"\"\n Elixir version information.\n\n Returns Elixir's version as binary.\n \"\"\"\n @spec version() :: String.t()\n def version, do: get_version()\n\n @doc \"\"\"\n Elixir build information.\n\n Returns a map with the Elixir version, the Erlang/OTP release it was compiled\n with, a short Git revision hash and the date and time it was built.\n\n Every value in the map is a string, and these are:\n\n * `:build` - the Elixir version, short Git revision hash and\n Erlang/OTP release it was compiled with\n * `:date` - a string representation of the ISO8601 date and time it was built\n * `:otp_release` - OTP release it was compiled with\n * `:revision` - short Git revision hash. If Git was not available at building\n time, it is set to `\"\"`\n * `:version` - the Elixir version\n\n One should not rely on the specific formats returned by each of those fields.\n Instead one should use specialized functions, such as `version/0` to retrieve\n the Elixir version and `otp_release/0` to retrieve the Erlang/OTP release.\n\n ## Examples\n\n iex> System.build_info()\n %{\n build: \"1.9.0-dev (772a00a0c) (compiled with Erlang/OTP 21)\",\n date: \"2018-12-24T01:09:21Z\",\n otp_release: \"21\",\n revision: \"772a00a0c\",\n version: \"1.9.0-dev\"\n }\n\n \"\"\"\n @spec build_info() :: %{\n build: String.t(),\n date: String.t(),\n revision: String.t(),\n version: String.t(),\n otp_release: String.t()\n }\n def build_info do\n %{\n build: build(),\n date: get_date(),\n revision: revision(),\n version: version(),\n otp_release: get_otp_release()\n }\n end\n\n # Returns a string of the build info\n defp build do\n {:ok, v} = Version.parse(version())\n\n revision_string = if v.pre != [] and revision() != \"\", do: \" (#{revision()})\", else: \"\"\n otp_version_string = \" (compiled with Erlang/OTP #{get_otp_release()})\"\n\n version() <> revision_string <> otp_version_string\n end\n\n @doc \"\"\"\n Lists command line arguments.\n\n Returns the list of command line arguments passed to the program.\n \"\"\"\n @spec argv() :: [String.t()]\n def argv do\n :elixir_config.get(:argv)\n end\n\n @doc \"\"\"\n Modifies command line arguments.\n\n Changes the list of command line arguments. Use it with caution,\n as it destroys any previous argv information.\n \"\"\"\n @spec argv([String.t()]) :: :ok\n def argv(args) do\n :elixir_config.put(:argv, args)\n end\n\n @doc \"\"\"\n Marks if the system should halt or not at the end of ARGV processing.\n \"\"\"\n @doc since: \"1.9.0\"\n @spec no_halt(boolean) :: :ok\n def no_halt(boolean) when is_boolean(boolean) do\n :elixir_config.put(:no_halt, boolean)\n end\n\n @doc \"\"\"\n Checks if the system will halt or not at the end of ARGV processing.\n \"\"\"\n @doc since: \"1.9.0\"\n @spec no_halt() :: boolean\n def no_halt() do\n :elixir_config.get(:no_halt)\n end\n\n @doc \"\"\"\n Current working directory.\n\n Returns the current working directory or `nil` if one\n is not available.\n \"\"\"\n @deprecated \"Use File.cwd/0 instead\"\n @spec cwd() :: String.t() | nil\n def cwd do\n case File.cwd() do\n {:ok, cwd} -> cwd\n _ -> nil\n end\n end\n\n @doc \"\"\"\n Current working directory, exception on error.\n\n Returns the current working directory or raises `RuntimeError`.\n \"\"\"\n @deprecated \"Use File.cwd!/0 instead\"\n @spec cwd!() :: String.t()\n def cwd! do\n case File.cwd() do\n {:ok, cwd} ->\n cwd\n\n _ ->\n raise \"could not get a current working directory, the current location is not accessible\"\n end\n end\n\n @doc \"\"\"\n User home directory.\n\n Returns the user home directory (platform independent).\n \"\"\"\n @spec user_home() :: String.t() | nil\n def user_home do\n case :init.get_argument(:home) do\n {:ok, [[home] | _]} ->\n encoding = :file.native_name_encoding()\n :unicode.characters_to_binary(home, encoding, encoding)\n\n _ ->\n nil\n end\n end\n\n @doc \"\"\"\n User home directory, exception on error.\n\n Same as `user_home/0` but raises `RuntimeError`\n instead of returning `nil` if no user home is set.\n \"\"\"\n @spec user_home!() :: String.t()\n def user_home! do\n user_home() || raise \"could not find the user home, please set the HOME environment variable\"\n end\n\n @doc ~S\"\"\"\n Writable temporary directory.\n\n Returns a writable temporary directory.\n Searches for directories in the following order:\n\n 1. the directory named by the TMPDIR environment variable\n 2. the directory named by the TEMP environment variable\n 3. the directory named by the TMP environment variable\n 4. `C:\\TMP` on Windows or `/tmp` on Unix-like operating systems\n 5. as a last resort, the current working directory\n\n Returns `nil` if none of the above are writable.\n \"\"\"\n @spec tmp_dir() :: String.t() | nil\n def tmp_dir do\n write_env_tmp_dir(~c\"TMPDIR\") || write_env_tmp_dir(~c\"TEMP\") || write_env_tmp_dir(~c\"TMP\") ||\n write_tmp_dir(~c\"/tmp\") || write_cwd_tmp_dir()\n end\n\n defp write_cwd_tmp_dir do\n case File.cwd() do\n {:ok, cwd} -> write_tmp_dir(cwd)\n _ -> nil\n end\n end\n\n @doc \"\"\"\n Writable temporary directory, exception on error.\n\n Same as `tmp_dir/0` but raises `RuntimeError`\n instead of returning `nil` if no temp dir is set.\n \"\"\"\n @spec tmp_dir!() :: String.t()\n def tmp_dir! do\n tmp_dir() ||\n raise \"could not get a writable temporary directory, please set the TMPDIR environment variable\"\n end\n\n defp write_env_tmp_dir(env) do\n case :os.getenv(env) do\n false -> nil\n tmp -> write_tmp_dir(tmp)\n end\n end\n\n defp write_tmp_dir(dir) do\n case File.stat(dir) do\n {:ok, stat} ->\n case {stat.type, stat.access} do\n {:directory, access} when access in [:read_write, :write] ->\n IO.chardata_to_string(dir)\n\n _ ->\n nil\n end\n\n {:error, _} ->\n nil\n end\n end\n\n @doc \"\"\"\n Registers a program exit handler function.\n\n Registers a function that will be invoked at the end of an Elixir script.\n A script is typically started via the command line via the `elixir` and\n `mix` executables.\n\n The handler always executes in a different process from the one it was\n registered in. As a consequence, any resources managed by the calling process\n (ETS tables, open files, and others) won't be available by the time the handler\n function is invoked.\n\n The function must receive the exit status code as an argument.\n\n If the VM terminates programmatically, via `System.stop/1`, `System.halt/1`,\n or exit signals, the `at_exit/1` callbacks are not guaranteed to be executed.\n \"\"\"\n @spec at_exit((non_neg_integer -> any)) :: :ok\n def at_exit(fun) when is_function(fun, 1) do\n :elixir_config.update(:at_exit, &[fun | &1])\n :ok\n end\n\n defmodule SignalHandler do\n @moduledoc false\n @behaviour :gen_event\n\n @impl true\n def init({event, fun}) do\n {:ok, {event, fun}}\n end\n\n @impl true\n def handle_call(_message, state) do\n {:ok, :ok, state}\n end\n\n @impl true\n def handle_event(signal, {event, fun}) do\n if signal == event, do: :ok = fun.()\n {:ok, {event, fun}}\n end\n\n @impl true\n def handle_info(_, {event, fun}) do\n {:ok, {event, fun}}\n end\n end\n\n @doc \"\"\"\n Traps the given `signal` to execute the `fun`.\n\n > #### Avoid setting traps in libraries {: .warning}\n >\n > Trapping signals may have strong implications\n > on how a system shuts down and behaves in production and\n > therefore it is extremely discouraged for libraries to\n > set their own traps. Instead, they should redirect users\n > to configure them themselves. The only cases where it is\n > acceptable for libraries to set their own traps is when\n > using Elixir in script mode, such as in `.exs` files and\n > via Mix tasks.\n\n An optional `id` that uniquely identifies the function\n can be given, otherwise a unique one is automatically\n generated. If a previously registered `id` is given,\n this function returns an error tuple. The `id` can be\n used to remove a registered signal by calling\n `untrap_signal/2`.\n\n The given `fun` receives no arguments and it must return\n `:ok`.\n\n It returns `{:ok, id}` in case of success,\n `{:error, :already_registered}` in case the id has already\n been registered for the given signal, or `{:error, :not_sup}`\n in case trapping exists is not supported by the current OS.\n\n The first time a signal is trapped, it will override the\n default behavior from the operating system. If the same\n signal is trapped multiple times, subsequent functions\n given to `trap_signal` will execute *first*. In other\n words, you can consider each function is prepended to\n the signal handler.\n\n By default, the Erlang VM register traps to the three\n signals:\n\n * `:sigstop` - gracefully shuts down the VM with `stop/0`\n * `:sigquit` - halts the VM via `halt/0`\n * `:sigusr1` - halts the VM via status code of 1\n\n Therefore, if you add traps to the signals above, the\n default behavior above will be executed after all user\n signals.\n\n ## Implementation notes\n\n All signals run from a single process. Therefore, blocking the\n `fun` will block subsequent traps. It is also not possible to add\n or remove traps from within a trap itself.\n\n Internally, this functionality is built on top of `:os.set_signal/2`.\n When you register a trap, Elixir automatically sets it to `:handle`\n and it reverts it back to `:default` once all traps are removed\n (except for `:sigquit`, `:sigterm`, and `:sigusr1` which are always\n handled). If you or a library call `:os.set_signal/2` directly,\n it may disable Elixir traps (or Elixir may override your configuration).\n \"\"\"\n @doc since: \"1.12.0\"\n @spec trap_signal(signal, (-> :ok)) :: {:ok, reference()} | {:error, :not_sup}\n @spec trap_signal(signal, id, (-> :ok)) ::\n {:ok, id} | {:error, :already_registered} | {:error, :not_sup}\n when id: term()\n def trap_signal(signal, id \\\\ make_ref(), fun)\n when signal in @signals and is_function(fun, 0) do\n :elixir_config.serial(fn ->\n gen_id = {signal, id}\n\n if {SignalHandler, gen_id} in signal_handlers() do\n {:error, :already_registered}\n else\n try do\n :os.set_signal(signal, :handle)\n rescue\n _ -> {:error, :not_sup}\n else\n :ok ->\n :ok =\n :gen_event.add_handler(:erl_signal_server, {SignalHandler, gen_id}, {signal, fun})\n\n {:ok, id}\n end\n end\n end)\n end\n\n @doc \"\"\"\n Removes a previously registered `signal` with `id`.\n \"\"\"\n @doc since: \"1.12.0\"\n @spec untrap_signal(signal, id) :: :ok | {:error, :not_found} when id: term\n def untrap_signal(signal, id) when signal in @signals do\n :elixir_config.serial(fn ->\n gen_id = {signal, id}\n\n case :gen_event.delete_handler(:erl_signal_server, {SignalHandler, gen_id}, :delete) do\n :ok ->\n if not trapping?(signal) do\n :os.set_signal(signal, :default)\n end\n\n :ok\n\n {:error, :module_not_found} ->\n {:error, :not_found}\n end\n end)\n end\n\n defp trapping?(signal) do\n signal in @vm_signals or\n Enum.any?(signal_handlers(), &match?({_, {^signal, _}}, &1))\n end\n\n defp signal_handlers do\n :gen_event.which_handlers(:erl_signal_server)\n end\n\n @doc \"\"\"\n Locates an executable on the system.\n\n This function looks up an executable program given\n its name using the environment variable PATH on Windows and Unix-like\n operating systems. It also considers the proper executable\n extension for each operating system, so for Windows it will try to\n lookup files with `.com`, `.cmd` or similar extensions.\n \"\"\"\n @spec find_executable(binary) :: binary | nil\n def find_executable(program) when is_binary(program) do\n assert_no_null_byte!(program, \"System.find_executable/1\")\n\n case :os.find_executable(String.to_charlist(program)) do\n false -> nil\n other -> List.to_string(other)\n end\n end\n\n @doc \"\"\"\n Returns all system environment variables.\n\n The returned value is a map containing name-value pairs.\n Variable names and their values are strings.\n \"\"\"\n @spec get_env() :: %{optional(String.t()) => String.t()}\n def get_env do\n Map.new(:os.env(), fn {k, v} ->\n {IO.chardata_to_string(k), IO.chardata_to_string(v)}\n end)\n end\n\n @doc \"\"\"\n Returns the value of the given environment variable.\n\n The returned value of the environment variable\n `varname` is a string. If the environment variable\n is not set, returns the string specified in `default` or\n `nil` if none is specified.\n\n ## Examples\n\n iex> System.get_env(\"PORT\")\n \"4000\"\n\n iex> System.get_env(\"NOT_SET\")\n nil\n\n iex> System.get_env(\"NOT_SET\", \"4001\")\n \"4001\"\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec get_env(String.t(), String.t()) :: String.t()\n @spec get_env(String.t(), nil) :: String.t() | nil\n def get_env(varname, default \\\\ nil)\n when is_binary(varname) and\n (is_binary(default) or is_nil(default)) do\n case :os.getenv(String.to_charlist(varname)) do\n false -> default\n other -> List.to_string(other)\n end\n end\n\n @doc \"\"\"\n Returns the value of the given environment variable or `:error` if not found.\n\n If the environment variable `varname` is set, then `{:ok, value}` is returned\n where `value` is a string. If `varname` is not set, `:error` is returned.\n\n ## Examples\n\n iex> System.fetch_env(\"PORT\")\n {:ok, \"4000\"}\n\n iex> System.fetch_env(\"NOT_SET\")\n :error\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec fetch_env(String.t()) :: {:ok, String.t()} | :error\n def fetch_env(varname) when is_binary(varname) do\n case :os.getenv(String.to_charlist(varname)) do\n false -> :error\n other -> {:ok, List.to_string(other)}\n end\n end\n\n @doc \"\"\"\n Returns the value of the given environment variable or raises if not found.\n\n Same as `get_env/1` but raises instead of returning `nil` when the variable is\n not set.\n\n ## Examples\n\n iex> System.fetch_env!(\"PORT\")\n \"4000\"\n\n iex> System.fetch_env!(\"NOT_SET\")\n ** (System.EnvError) could not fetch environment variable \"NOT_SET\" because it is not set\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec fetch_env!(String.t()) :: String.t()\n def fetch_env!(varname) when is_binary(varname) do\n get_env(varname) || raise(EnvError, env: varname)\n end\n\n @doc \"\"\"\n Erlang VM process identifier.\n\n Returns the process identifier of the current Erlang emulator\n in the format most commonly used by the operating system environment.\n\n For more information, see `:os.getpid/0`.\n \"\"\"\n @deprecated \"Use System.pid/0 instead\"\n @spec get_pid() :: binary\n def get_pid, do: IO.iodata_to_binary(:os.getpid())\n\n @doc \"\"\"\n Sets an environment variable value.\n\n Sets a new `value` for the environment variable `varname`.\n \"\"\"\n @spec put_env(binary, binary) :: :ok\n def put_env(varname, value) when is_binary(varname) and is_binary(value) do\n case :binary.match(varname, \"=\") do\n {_, _} ->\n raise ArgumentError,\n \"cannot execute System.put_env/2 for key with \\\"=\\\", got: #{inspect(varname)}\"\n\n :nomatch ->\n :os.putenv(String.to_charlist(varname), String.to_charlist(value))\n :ok\n end\n end\n\n @doc \"\"\"\n Sets multiple environment variables.\n\n Sets a new value for each environment variable corresponding\n to each `{key, value}` pair in `enum`. Keys and non-nil values\n are automatically converted to charlists. `nil` values erase\n the given keys.\n\n Overall, this is a convenience wrapper around `put_env/2` and\n `delete_env/2` with support for different key and value formats.\n \"\"\"\n @spec put_env(Enumerable.t()) :: :ok\n def put_env(enum) do\n Enum.each(enum, fn\n {key, nil} ->\n :os.unsetenv(to_charlist(key))\n\n {key, val} ->\n key = to_charlist(key)\n\n case :string.find(key, \"=\") do\n :nomatch ->\n :os.putenv(key, to_charlist(val))\n\n _ ->\n raise ArgumentError,\n \"cannot execute System.put_env/1 for key with \\\"=\\\", got: #{inspect(key)}\"\n end\n end)\n end\n\n @doc \"\"\"\n Deletes an environment variable.\n\n Removes the variable `varname` from the environment.\n \"\"\"\n @spec delete_env(String.t()) :: :ok\n def delete_env(varname) do\n :os.unsetenv(String.to_charlist(varname))\n :ok\n end\n\n @doc \"\"\"\n Deprecated mechanism to retrieve the last exception stacktrace.\n\n It always return an empty list.\n \"\"\"\n @deprecated \"Use __STACKTRACE__ instead\"\n def stacktrace do\n []\n end\n\n @doc \"\"\"\n Immediately halts the Erlang runtime system.\n\n Terminates the Erlang runtime system without properly shutting down\n applications and ports. Please see `stop/1` for a careful shutdown of the\n system.\n\n `status` must be a non-negative integer, the atom `:abort` or a binary.\n\n * If an integer, the runtime system exits with the integer value which\n is returned to the operating system.\n\n * If `:abort`, the runtime system aborts producing a core dump, if that is\n enabled in the operating system.\n\n * If a string, an Erlang crash dump is produced with status as slogan,\n and then the runtime system exits with status code 1.\n\n Note that on many platforms, only the status codes 0-255 are supported\n by the operating system.\n\n For more information, see `:erlang.halt/1`.\n\n ## Examples\n\n System.halt(0)\n System.halt(1)\n System.halt(:abort)\n\n \"\"\"\n @spec halt() :: no_return\n @spec halt(non_neg_integer | binary | :abort) :: no_return\n def halt(status \\\\ 0)\n\n def halt(status) when is_integer(status) or status == :abort do\n :erlang.halt(status)\n end\n\n def halt(status) when is_binary(status) do\n :erlang.halt(String.to_charlist(status))\n end\n\n @doc \"\"\"\n Returns the operating system PID for the current Erlang runtime system instance.\n\n Returns a string containing the (usually) numerical identifier for a process.\n On Unix-like operating systems, this is typically the return value of the `getpid()` system call.\n On Windows, the process ID as returned by the `GetCurrentProcessId()` system\n call is used.\n\n ## Examples\n\n System.pid()\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec pid :: String.t()\n def pid do\n List.to_string(:os.getpid())\n end\n\n @doc \"\"\"\n Restarts all applications in the Erlang runtime system.\n\n All applications are taken down smoothly, all code is unloaded, and all ports\n are closed before the system starts all applications once again.\n\n ## Examples\n\n System.restart()\n\n \"\"\"\n @doc since: \"1.9.0\"\n @spec restart :: :ok\n defdelegate restart(), to: :init\n\n @doc \"\"\"\n Asynchronously and carefully stops the Erlang runtime system.\n\n All applications are taken down smoothly, all code is unloaded, and all ports\n are closed before the system terminates by calling `halt/1`.\n\n `status` must be a non-negative integer or a binary.\n\n * If an integer, the runtime system exits with the integer value which is\n returned to the operating system. On many platforms, only the status codes\n 0-255 are supported by the operating system.\n\n * If a binary, an Erlang crash dump is produced with status as slogan, and\n then the runtime system exits with status code 1.\n\n Note this function is asynchronous and the current process will continue\n executing after this function is invoked. In case you want to block the\n current process until the system effectively shuts down, you can invoke\n `Process.sleep(:infinity)`.\n\n ## Examples\n\n System.stop(0)\n System.stop(1)\n\n \"\"\"\n @doc since: \"1.5.0\"\n @spec stop(non_neg_integer | binary) :: :ok\n def stop(status \\\\ 0)\n\n def stop(status) when is_integer(status) do\n at_exit(fn _ -> Process.sleep(:infinity) end)\n :init.stop(status)\n end\n\n def stop(status) when is_binary(status) do\n at_exit(fn _ -> Process.sleep(:infinity) end)\n :init.stop(String.to_charlist(status))\n end\n\n @doc ~S\"\"\"\n Executes the given `command` in the OS shell.\n\n It uses `sh` for Unix-like systems and `cmd` for Windows.\n\n > #### Watch out {: .warning}\n >\n > Use this function with care. In particular, **never\n > pass untrusted user input to this function**, as the user would be\n > able to perform \"command injection attacks\" by executing any code\n > directly on the machine. Generally speaking, prefer to use `cmd/3`\n > over this function.\n\n ## Examples\n\n iex> System.shell(\"echo hello\")\n {\"hello\\n\", 0}\n\n If you want to stream the output to Standard IO as it arrives:\n\n iex> System.shell(\"echo hello\", into: IO.stream())\n hello\n {%IO.Stream{}, 0}\n\n ## Options\n\n It accepts the same options as `cmd/3` (except for `arg0`).\n It also accepts the following exclusive options:\n\n * `:close_stdin` (since v1.14.1) - if the stdin should be closed\n on Unix systems, forcing any command that waits on stdin to\n immediately terminate. Defaults to `false`.\n \"\"\"\n @doc since: \"1.12.0\"\n @spec shell(binary, shell_opts) :: {Collectable.t(), exit_status :: non_neg_integer}\n def shell(command, opts \\\\ []) when is_binary(command) do\n command |> String.trim() |> do_shell(opts)\n end\n\n defp do_shell(\"\", _opts), do: {\"\", 0}\n\n defp do_shell(command, opts) do\n assert_no_null_byte!(command, \"System.shell/2\")\n {close_stdin?, opts} = Keyword.pop(opts, :close_stdin, false)\n\n # Finding shell command logic from :os.cmd in OTP\n # https://github.com/erlang/otp/blob/8deb96fb1d017307e22d2ab88968b9ef9f1b71d0/lib/kernel/src/os.erl#L184\n case :os.type() do\n {:unix, _} ->\n shell_path = :os.find_executable(~c\"sh\") || :erlang.error(:enoent, [command, opts])\n close_stdin = if close_stdin?, do: \" \n command = String.to_charlist(command)\n\n command =\n case {System.get_env(\"COMSPEC\"), osname} do\n {nil, :windows} -> ~c\"command.com /s /c \" ++ command\n {nil, _} -> ~c\"cmd /s /c \" ++ command\n {cmd, _} -> ~c\"#{cmd} /s /c \" ++ command\n end\n\n do_cmd({:spawn, command}, [], opts)\n end\n end\n\n @doc ~S\"\"\"\n Executes the given `command` with `args`.\n\n `command` is expected to be an executable available in PATH\n unless an absolute path is given.\n\n `args` must be a list of binaries which the executable will receive\n as its arguments as is. This means that:\n\n * environment variables will not be interpolated\n * wildcard expansion will not happen (unless `Path.wildcard/2` is used\n explicitly)\n * arguments do not need to be escaped or quoted for shell safety\n\n This function returns a tuple containing the collected result\n and the command exit status.\n\n Internally, this function uses a `Port` for interacting with the\n outside world. However, if you plan to run a long-running program,\n ports guarantee stdin/stdout devices will be closed but it does not\n automatically terminate the program. The documentation for the\n `Port` module describes this problem and possible solutions under\n the \"Orphan operating system processes\" section.\n\n > #### Windows argument splitting and untrusted arguments {: .warning}\n >\n > On Unix systems, arguments are passed to a new operating system\n > process as an array of strings but on Windows it is up to the child\n > process to parse them and some Windows programs may apply their own\n > rules, which are inconsistent with the standard C runtime `argv` parsing\n >\n > This is particularly troublesome when invoking `.bat` or `.com` files\n > as these run implicitly through `cmd.exe`, whose argument parsing is\n > vulnerable to malicious input and can be used to run arbitrary shell\n > commands.\n >\n > Therefore, if you are running on Windows and you execute batch\n > files or `.com` applications, you must not pass untrusted input as\n > arguments to the program. You may avoid accidentally executing them\n > by explicitly passing the extension of the program you want to run,\n > such as `.exe`, and double check the program is indeed not a batch\n > file or `.com` application.\n\n ## Options\n\n * `:into` - injects the result into the given collectable, defaults to `\"\"`\n\n * `:lines` - (since v1.15.0) reads the output by lines instead of in bytes. It expects a\n number of maximum bytes to buffer internally (1024 is a reasonable default).\n The collectable will be called with each finished line (regardless of buffer\n size) and without the EOL character\n\n * `:cd` - the directory to run the command in\n\n * `:env` - an enumerable of tuples containing environment key-value as\n binary. The child process inherits all environment variables from its\n parent process, the Elixir application, except those overwritten or\n cleared using this option. Specify a value of `nil` to clear (unset) an\n environment variable, which is useful for preventing credentials passed\n to the application from leaking into child processes\n\n * `:arg0` - sets the command arg0\n\n * `:stderr_to_stdout` - redirects stderr to stdout when `true`, no effect\n if `use_stdio` is `false`.\n\n * `:use_stdio` - `true` by default, setting it to false allows direct\n interaction with the terminal from the callee\n\n * `:parallelism` - when `true`, the VM will schedule port tasks to improve\n parallelism in the system. If set to `false`, the VM will try to perform\n commands immediately, improving latency at the expense of parallelism.\n The default is `false`, and can be set on system startup by passing the\n [`+spp`](https://www.erlang.org/doc/man/erl.html#+spp) flag to `--erl`.\n Use `:erlang.system_info(:port_parallelism)` to check if enabled.\n\n ## Error reasons\n\n If invalid arguments are given, `ArgumentError` is raised by\n `System.cmd/3`. `System.cmd/3` also expects a strict set of\n options and will raise if unknown or invalid options are given.\n\n Furthermore, `System.cmd/3` may fail with one of the POSIX reasons\n detailed below:\n\n * `:system_limit` - all available ports in the Erlang emulator are in use\n\n * `:enomem` - there was not enough memory to create the port\n\n * `:eagain` - there are no more available operating system processes\n\n * `:enametoolong` - the external command given was too long\n\n * `:emfile` - there are no more available file descriptors\n (for the operating system process that the Erlang emulator runs in)\n\n * `:enfile` - the file table is full (for the entire operating system)\n\n * `:eacces` - the command does not point to an executable file\n\n * `:enoent` - the command does not point to an existing file\n\n ## Shell commands\n\n If you desire to execute a trusted command inside a shell, with pipes,\n redirecting and so on, please check `shell/2`.\n\n ## Examples\n\n iex> System.cmd(\"echo\", [\"hello\"])\n {\"hello\\n\", 0}\n\n iex> System.cmd(\"echo\", [\"hello\"], env: [{\"MIX_ENV\", \"test\"}])\n {\"hello\\n\", 0}\n\n If you want to stream the output to Standard IO as it arrives:\n\n iex> System.cmd(\"echo\", [\"hello\"], into: IO.stream())\n hello\n {%IO.Stream{}, 0}\n\n If you want to read lines:\n\n iex> System.cmd(\"echo\", [\"hello\\nworld\"], into: [], lines: 1024)\n {[\"hello\", \"world\"], 0}\n\n \"\"\"\n @spec cmd(binary, [binary], cmd_opts) :: {Collectable.t(), exit_status :: non_neg_integer}\n def cmd(command, args, opts \\\\ []) when is_binary(command) and is_list(args) do\n assert_no_null_byte!(command, \"System.cmd/3\")\n\n if not Enum.all?(args, &is_binary/1) do\n raise ArgumentError, \"all arguments for System.cmd/3 must be binaries\"\n end\n\n cmd = String.to_charlist(command)\n\n cmd =\n if Path.type(cmd) == :absolute do\n cmd\n else\n :os.find_executable(cmd) || :erlang.error(:enoent, [command, args, opts])\n end\n\n do_cmd({:spawn_executable, cmd}, [args: args], opts)\n end\n\n defp do_cmd(port_init, base_opts, opts) do\n {use_stdio?, opts} = Keyword.pop(opts, :use_stdio, true)\n\n {into, line, opts} =\n cmd_opts(opts, [:exit_status, :binary, :hide] ++ base_opts, \"\", false, use_stdio?)\n\n {initial, fun} = Collectable.into(into)\n\n try do\n case line do\n true -> do_port_line(Port.open(port_init, opts), initial, fun, [])\n false -> do_port_byte(Port.open(port_init, opts), initial, fun)\n end\n catch\n kind, reason ->\n fun.(initial, :halt)\n :erlang.raise(kind, reason, __STACKTRACE__)\n else\n {acc, status} -> {fun.(acc, :done), status}\n end\n end\n\n defp do_port_byte(port, acc, fun) do\n receive do\n {^port, {:data, data}} ->\n do_port_byte(port, fun.(acc, {:cont, data}), fun)\n\n {^port, {:exit_status, status}} ->\n {acc, status}\n end\n end\n\n defp do_port_line(port, acc, fun, buffer) do\n receive do\n {^port, {:data, {:noeol, data}}} ->\n do_port_line(port, acc, fun, [data | buffer])\n\n {^port, {:data, {:eol, data}}} ->\n data = [data | buffer] |> Enum.reverse() |> IO.iodata_to_binary()\n do_port_line(port, fun.(acc, {:cont, data}), fun, [])\n\n {^port, {:exit_status, status}} ->\n # Data may arrive after exit status on line mode\n receive do\n {^port, {:data, {_, data}}} ->\n data = [data | buffer] |> Enum.reverse() |> IO.iodata_to_binary()\n {fun.(acc, {:cont, data}), status}\n after\n 0 -> {acc, status}\n end\n end\n end\n\n defp cmd_opts([{:into, any} | t], opts, _into, line, stdio?),\n do: cmd_opts(t, opts, any, line, stdio?)\n\n defp cmd_opts([{:cd, bin} | t], opts, into, line, stdio?) when is_binary(bin),\n do: cmd_opts(t, [{:cd, bin} | opts], into, line, stdio?)\n\n defp cmd_opts([{:arg0, bin} | t], opts, into, line, stdio?) when is_binary(bin),\n do: cmd_opts(t, [{:arg0, bin} | opts], into, line, stdio?)\n\n defp cmd_opts([{:stderr_to_stdout, true} | t], opts, into, line, true),\n do: cmd_opts(t, [:stderr_to_stdout | opts], into, line, true)\n\n defp cmd_opts([{:stderr_to_stdout, true} | _], _opts, _into, _line, false),\n do: raise(ArgumentError, \"cannot use \\\"stderr_to_stdout: true\\\" and \\\"use_stdio: false\\\"\")\n\n defp cmd_opts([{:stderr_to_stdout, false} | t], opts, into, line, stdio?),\n do: cmd_opts(t, opts, into, line, stdio?)\n\n defp cmd_opts([{:parallelism, bool} | t], opts, into, line, stdio?) when is_boolean(bool),\n do: cmd_opts(t, [{:parallelism, bool} | opts], into, line, stdio?)\n\n defp cmd_opts([{:env, enum} | t], opts, into, line, stdio?),\n do: cmd_opts(t, [{:env, validate_env(enum)} | opts], into, line, stdio?)\n\n defp cmd_opts([{:lines, max_line_length} | t], opts, into, _line, stdio?)\n when is_integer(max_line_length) and max_line_length > 0,\n do: cmd_opts(t, [{:line, max_line_length} | opts], into, true, stdio?)\n\n defp cmd_opts([{key, val} | _], _opts, _into, _line, _stdio?),\n do: raise(ArgumentError, \"invalid option #{inspect(key)} with value #{inspect(val)}\")\n\n defp cmd_opts([], opts, into, line, stdio?) do\n opt = if stdio?, do: :use_stdio, else: :nouse_stdio\n {into, line, [opt | opts]}\n end\n\n defp validate_env(enum) do\n Enum.map(enum, fn\n {k, nil} ->\n {String.to_charlist(k), false}\n\n {k, v} ->\n {String.to_charlist(k), String.to_charlist(v)}\n\n other ->\n raise ArgumentError, \"invalid environment key-value #{inspect(other)}\"\n end)\n end\n\n @doc \"\"\"\n Returns the current monotonic time in the `:native` time unit.\n\n This time is monotonically increasing and starts in an unspecified\n point in time. This is not strictly monotonically increasing. Multiple\n sequential calls of the function may return the same value.\n\n Inlined by the compiler.\n \"\"\"\n @spec monotonic_time() :: integer\n def monotonic_time do\n :erlang.monotonic_time()\n end\n\n @doc \"\"\"\n Returns the current monotonic time in the given time unit.\n\n This time is monotonically increasing and starts in an unspecified\n point in time.\n \"\"\"\n @spec monotonic_time(time_unit | :native) :: integer\n def monotonic_time(unit) do\n :erlang.monotonic_time(normalize_time_unit(unit))\n end\n\n @doc \"\"\"\n Returns the current system time in the `:native` time unit.\n\n It is the VM view of the `os_time/0`. They may not match in\n case of time warps although the VM works towards aligning\n them. This time is not monotonic.\n\n Inlined by the compiler.\n \"\"\"\n @spec system_time() :: integer\n def system_time do\n :erlang.system_time()\n end\n\n @doc \"\"\"\n Returns the current system time in the given time unit.\n\n It is the VM view of the `os_time/0`. They may not match in\n case of time warps although the VM works towards aligning\n them. This time is not monotonic.\n \"\"\"\n @spec system_time(time_unit | :native) :: integer\n def system_time(unit) do\n :erlang.system_time(normalize_time_unit(unit))\n end\n\n @doc \"\"\"\n Converts `time` from time unit `from_unit` to time unit `to_unit`.\n\n The result is rounded via the floor function.\n\n `convert_time_unit/3` accepts an additional time unit (other than the\n ones in the `t:time_unit/0` type) called `:native`. `:native` is the time\n unit used by the Erlang runtime system. It's determined when the runtime\n starts and stays the same until the runtime is stopped, but could differ\n the next time the runtime is started on the same machine. For this reason,\n you should use this function to convert `:native` time units to a predictable\n unit before you display them to humans.\n\n To determine how many seconds the `:native` unit represents in your current\n runtime, you can call this function to convert 1 second to the `:native`\n time unit: `System.convert_time_unit(1, :second, :native)`.\n \"\"\"\n @spec convert_time_unit(integer, time_unit | :native, time_unit | :native) :: integer\n def convert_time_unit(time, from_unit, to_unit) do\n :erlang.convert_time_unit(time, normalize_time_unit(from_unit), normalize_time_unit(to_unit))\n end\n\n @doc \"\"\"\n Returns the current time offset between the Erlang VM monotonic\n time and the Erlang VM system time.\n\n The result is returned in the `:native` time unit.\n\n See `time_offset/1` for more information.\n\n Inlined by the compiler.\n \"\"\"\n @spec time_offset() :: integer\n def time_offset do\n :erlang.time_offset()\n end\n\n @doc \"\"\"\n Returns the current time offset between the Erlang VM monotonic\n time and the Erlang VM system time.\n\n The result is returned in the given time unit `unit`. The returned\n offset, added to an Erlang monotonic time (for instance, one obtained with\n `monotonic_time/1`), gives the Erlang system time that corresponds\n to that monotonic time.\n \"\"\"\n @spec time_offset(time_unit | :native) :: integer\n def time_offset(unit) do\n :erlang.time_offset(normalize_time_unit(unit))\n end\n\n @doc \"\"\"\n Returns the current operating system (OS) time.\n\n The result is returned in the `:native` time unit.\n\n This time may be adjusted forwards or backwards in time\n with no limitation and is not monotonic.\n\n Inlined by the compiler.\n \"\"\"\n @spec os_time() :: integer\n @doc since: \"1.3.0\"\n def os_time do\n :os.system_time()\n end\n\n @doc \"\"\"\n Returns the current operating system (OS) time in the given time `unit`.\n\n This time may be adjusted forwards or backwards in time\n with no limitation and is not monotonic.\n \"\"\"\n @spec os_time(time_unit | :native) :: integer\n @doc since: \"1.3.0\"\n def os_time(unit) do\n :os.system_time(normalize_time_unit(unit))\n end\n\n @doc \"\"\"\n Returns the Erlang/OTP release number.\n \"\"\"\n @spec otp_release :: String.t()\n @doc since: \"1.3.0\"\n def otp_release do\n :erlang.list_to_binary(:erlang.system_info(:otp_release))\n end\n\n @doc \"\"\"\n Returns the number of schedulers in the VM.\n \"\"\"\n @spec schedulers :: pos_integer\n @doc since: \"1.3.0\"\n def schedulers do\n :erlang.system_info(:schedulers)\n end\n\n @doc \"\"\"\n Returns the number of schedulers online in the VM.\n \"\"\"\n @spec schedulers_online :: pos_integer\n @doc since: \"1.3.0\"\n def schedulers_online do\n :erlang.system_info(:schedulers_online)\n end\n\n @doc \"\"\"\n Generates and returns an integer that is unique in the current runtime\n instance.\n\n \"Unique\" means that this function, called with the same list of `modifiers`,\n will never return the same integer more than once on the current runtime\n instance.\n\n If `modifiers` is `[]`, then a unique integer (that can be positive or negative) is returned.\n Other modifiers can be passed to change the properties of the returned integer:\n\n * `:positive` - the returned integer is guaranteed to be positive.\n * `:monotonic` - the returned integer is monotonically increasing. This\n means that, on the same runtime instance (but even on different\n processes), integers returned using the `:monotonic` modifier will always\n be strictly less than integers returned by successive calls with the\n `:monotonic` modifier.\n\n All modifiers listed above can be combined; repeated modifiers in `modifiers`\n will be ignored.\n\n Inlined by the compiler.\n \"\"\"\n @spec unique_integer([:positive | :monotonic]) :: integer\n def unique_integer(modifiers \\\\ []) do\n :erlang.unique_integer(modifiers)\n end\n\n defp assert_no_null_byte!(binary, operation) do\n case :binary.match(binary, \"\\0\") do\n {_, _} ->\n raise ArgumentError,\n \"cannot execute #{operation} for program with null byte, got: #{inspect(binary)}\"\n\n :nomatch ->\n binary\n end\n end\n\n defp normalize_time_unit(:native), do: :native\n\n defp normalize_time_unit(:second), do: :second\n defp normalize_time_unit(:millisecond), do: :millisecond\n defp normalize_time_unit(:microsecond), do: :microsecond\n defp normalize_time_unit(:nanosecond), do: :nanosecond\n\n defp normalize_time_unit(:seconds), do: warn(:seconds, :second)\n defp normalize_time_unit(:milliseconds), do: warn(:milliseconds, :millisecond)\n defp normalize_time_unit(:microseconds), do: warn(:microseconds, :microsecond)\n defp normalize_time_unit(:nanoseconds), do: warn(:nanoseconds, :nanosecond)\n\n defp normalize_time_unit(:milli_seconds), do: warn(:milli_seconds, :millisecond)\n defp normalize_time_unit(:micro_seconds), do: warn(:micro_seconds, :microsecond)\n defp normalize_time_unit(:nano_seconds), do: warn(:nano_seconds, :nanosecond)\n\n defp normalize_time_unit(unit) when is_integer(unit) and unit > 0, do: unit\n\n defp normalize_time_unit(other) do\n raise ArgumentError,\n \"unsupported time unit. Expected :second, :millisecond, \" <>\n \":microsecond, :nanosecond, or a positive integer, \" <> \"got #{inspect(other)}\"\n end\n\n defp warn(unit, replacement_unit) do\n IO.warn_once(\n {__MODULE__, unit},\n fn ->\n \"deprecated time unit: #{inspect(unit)}. A time unit should be \" <>\n \":second, :millisecond, :microsecond, :nanosecond, or a positive integer\"\n end,\n _stacktrace_drop_levels = 4\n )\n\n replacement_unit\n end\nend\n" }, { "path": "lib/elixir/lib/task/supervised.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Task.Supervised do\n @moduledoc false\n @ref_timeout 5000\n\n def start(owner, callers, fun) do\n {:ok, spawn(__MODULE__, :noreply, [owner, get_ancestors(), callers, fun])}\n end\n\n def start_link(owner, callers, fun) do\n {:ok, spawn_link(__MODULE__, :noreply, [owner, get_ancestors(), callers, fun])}\n end\n\n def start_link(owner, monitor) do\n {:ok, spawn_link(__MODULE__, :reply, [owner, get_ancestors(), monitor])}\n end\n\n def reply({_, _, owner_pid} = owner, ancestors, monitor) do\n put_ancestors(ancestors)\n\n case monitor do\n :monitor ->\n mref = Process.monitor(owner_pid)\n reply(owner, owner_pid, mref, @ref_timeout)\n\n :nomonitor ->\n reply(owner, owner_pid, nil, :infinity)\n end\n end\n\n defp reply(owner, owner_pid, mref, timeout) do\n receive do\n {^owner_pid, ref, reply_to, callers, mfa} ->\n put_initial_call(mfa)\n put_callers(callers)\n _ = is_reference(mref) && Process.demonitor(mref, [:flush])\n send(reply_to, {ref, invoke_mfa(owner, mfa)})\n\n {:DOWN, ^mref, _, _, reason} ->\n exit({:shutdown, reason})\n after\n # There is a race condition on this operation when working across\n # node that manifests if a \"Task.Supervisor.async/2\" call is made\n # while the supervisor is busy spawning previous tasks.\n #\n # Imagine the following workflow:\n #\n # 1. The nodes disconnect\n # 2. The async call fails and is caught, the calling process does not exit\n # 3. The task is spawned and links to the calling process, causing the nodes to reconnect\n # 4. The calling process has not exited and so does not send its monitor reference\n # 5. The spawned task waits forever for the monitor reference so it can begin\n #\n # We have solved this by specifying a timeout of 5000 milliseconds.\n # Given no work is done in the client between the task start and\n # sending the reference, 5000 should be enough to not raise false\n # negatives unless the nodes are indeed not available.\n #\n # The same situation could occur with \"Task.Supervisor.async_nolink/2\",\n # except a monitor is used instead of a link.\n timeout ->\n exit(:timeout)\n end\n end\n\n def noreply(owner, ancestors, callers, mfa) do\n put_initial_call(mfa)\n put_ancestors(ancestors)\n put_callers(callers)\n invoke_mfa(owner, mfa)\n end\n\n defp get_ancestors() do\n case :erlang.get(:\"$ancestors\") do\n ancestors when is_list(ancestors) -> [self() | ancestors]\n _ -> [self()]\n end\n end\n\n defp put_ancestors(ancestors) do\n Process.put(:\"$ancestors\", ancestors)\n end\n\n defp put_callers(callers) do\n Process.put(:\"$callers\", callers)\n end\n\n defp put_initial_call(mfa) do\n Process.put(:\"$initial_call\", get_initial_call(mfa))\n end\n\n defp get_initial_call({:erlang, :apply, [fun, []]}) when is_function(fun, 0) do\n :erlang.fun_info_mfa(fun)\n end\n\n defp get_initial_call({mod, fun, args}) do\n {mod, fun, length(args)}\n end\n\n defp invoke_mfa(owner, {module, fun, args} = mfa) do\n try do\n apply(module, fun, args)\n catch\n :exit, value\n when value == :normal\n when value == :shutdown\n when tuple_size(value) == 2 and elem(value, 0) == :shutdown ->\n :erlang.raise(:exit, value, __STACKTRACE__)\n\n kind, value ->\n {fun, args} = get_running(mfa)\n\n :logger.error(\n %{\n label: {Task.Supervisor, :terminating},\n report: %{\n name: self(),\n starter: get_from(owner),\n function: fun,\n args: args,\n reason: {log_value(kind, value), __STACKTRACE__},\n # using :proc_lib over Process because we want the :undefined default, not nil\n process_label: :proc_lib.get_label(self())\n }\n },\n %{\n domain: [:otp, :elixir],\n error_logger: %{tag: :error_msg},\n report_cb: &__MODULE__.format_report/1,\n callers: Process.get(:\"$callers\")\n }\n )\n\n :erlang.raise(:exit, exit_reason(kind, value, __STACKTRACE__), __STACKTRACE__)\n end\n end\n\n defp exit_reason(:error, reason, stacktrace), do: {reason, stacktrace}\n defp exit_reason(:exit, reason, _stacktrace), do: reason\n defp exit_reason(:throw, reason, stacktrace), do: {{:nocatch, reason}, stacktrace}\n\n defp log_value(:throw, value), do: {:nocatch, value}\n defp log_value(_, value), do: value\n\n @doc false\n def format_report(%{\n label: {Task.Supervisor, :terminating},\n report: %{\n name: name,\n starter: starter,\n function: fun,\n args: args,\n reason: reason,\n process_label: process_label\n }\n }) do\n message =\n ~c\"** Started from ~p~n\" ++\n ~c\"** When function == ~p~n\" ++\n ~c\"** arguments == ~p~n\" ++ ~c\"** Reason for termination == ~n\" ++ ~c\"** ~p~n\"\n\n terms = [starter, fun, args, get_reason(reason)]\n\n {message, terms} =\n case process_label do\n :undefined -> {message, terms}\n _ -> {~c\"** Process Label == ~p~n\" ++ message, [process_label | terms]}\n end\n\n message =\n ~c\"** Task ~p terminating~n\" ++ message\n\n {message, [name | terms]}\n end\n\n defp get_from({node, pid_or_name, _pid}) when node == node(), do: pid_or_name\n defp get_from({node, name, _pid}) when is_atom(name), do: {node, name}\n defp get_from({_node, _name, pid}), do: pid\n\n defp get_running({:erlang, :apply, [fun, []]}) when is_function(fun, 0), do: {fun, []}\n defp get_running({mod, fun, args}), do: {Function.capture(mod, fun, length(args)), args}\n\n defp get_reason({:undef, [{mod, fun, args, _info} | _] = stacktrace} = reason)\n when is_atom(mod) and is_atom(fun) do\n cond do\n not Code.loaded?(mod) ->\n {:\"module could not be loaded\", stacktrace}\n\n is_list(args) and not function_exported?(mod, fun, length(args)) ->\n {:\"function not exported\", stacktrace}\n\n is_integer(args) and not function_exported?(mod, fun, args) ->\n {:\"function not exported\", stacktrace}\n\n true ->\n reason\n end\n end\n\n defp get_reason(reason) do\n reason\n end\n\n ## Stream\n\n def validate_stream_options(options) do\n max_concurrency = Keyword.get_lazy(options, :max_concurrency, &System.schedulers_online/0)\n on_timeout = Keyword.get(options, :on_timeout, :exit)\n timeout = Keyword.get(options, :timeout, 5000)\n ordered = Keyword.get(options, :ordered, true)\n zip_input_on_exit = Keyword.get(options, :zip_input_on_exit, false)\n\n if not (is_integer(max_concurrency) and max_concurrency > 0) do\n raise ArgumentError, \":max_concurrency must be an integer greater than zero\"\n end\n\n if on_timeout not in [:exit, :kill_task] do\n raise ArgumentError, \":on_timeout must be either :exit or :kill_task\"\n end\n\n if not ((is_integer(timeout) and timeout >= 0) or timeout == :infinity) do\n raise ArgumentError, \":timeout must be either a positive integer or :infinity\"\n end\n\n %{\n max_concurrency: max_concurrency,\n on_timeout: on_timeout,\n timeout: timeout,\n ordered: ordered,\n zip_input_on_exit: zip_input_on_exit\n }\n end\n\n def stream(enumerable, acc, reducer, callers, mfa, options, spawn) when is_map(options) do\n next = &Enumerable.reduce(enumerable, &1, fn x, acc -> {:suspend, [x | acc]} end)\n parent = self()\n\n {:trap_exit, trap_exit?} = Process.info(self(), :trap_exit)\n\n # Start a process responsible for spawning processes and translating \"down\"\n # messages. This process will trap exits if the current process is trapping\n # exit, or it won't trap exits otherwise.\n spawn_opts = [:link, :monitor]\n\n {monitor_pid, monitor_ref} =\n Process.spawn(\n fn -> stream_monitor(parent, spawn, trap_exit?, options.timeout) end,\n spawn_opts\n )\n\n # Now that we have the pid of the \"monitor\" process and the reference of the\n # monitor we use to monitor such process, we can inform the monitor process\n # about our reference to it.\n send(monitor_pid, {parent, monitor_ref})\n\n config =\n Map.merge(\n options,\n %{\n reducer: reducer,\n monitor_pid: monitor_pid,\n monitor_ref: monitor_ref,\n callers: callers,\n mfa: mfa\n }\n )\n\n stream_reduce(\n acc,\n options.max_concurrency,\n _spawned = 0,\n _delivered = 0,\n _waiting = %{},\n next,\n config\n )\n end\n\n defp stream_reduce({:halt, acc}, _max, _spawned, _delivered, _waiting, next, config) do\n stream_close(config)\n is_function(next) && next.({:halt, []})\n {:halted, acc}\n end\n\n defp stream_reduce({:suspend, acc}, max, spawned, delivered, waiting, next, config) do\n continuation = &stream_reduce(&1, max, spawned, delivered, waiting, next, config)\n {:suspended, acc, continuation}\n end\n\n # All spawned, all delivered, next is :done.\n defp stream_reduce({:cont, acc}, _max, spawned, delivered, _waiting, next, config)\n when spawned == delivered and next == :done do\n stream_close(config)\n {:done, acc}\n end\n\n # No more tasks to spawn because max == 0 or next is :done. We wait for task\n # responses or tasks going down.\n defp stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config)\n when max == 0\n when next == :done do\n %{\n monitor_pid: monitor_pid,\n monitor_ref: monitor_ref,\n timeout: timeout,\n on_timeout: on_timeout,\n zip_input_on_exit: zip_input_on_exit?,\n ordered: ordered?\n } = config\n\n receive do\n # The task at position \"position\" replied with \"value\". We put the\n # response in the \"waiting\" map and do nothing, since we'll only act on\n # this response when the replying task dies (we'll see this in the :down\n # message).\n {{^monitor_ref, position}, reply} ->\n %{^position => {pid, :running, _element}} = waiting\n waiting = Map.put(waiting, position, {pid, {:ok, reply}})\n stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config)\n\n # The task at position \"position\" died for some reason. We check if it\n # replied already (then the death is peaceful) or if it's still running\n # (then the reply from this task will be {:exit, reason}). This message is\n # sent to us by the monitor process, not by the dying task directly.\n {kind, {^monitor_ref, position}, reason}\n when kind in [:down, :timed_out] ->\n result =\n case waiting do\n # If the task replied, we don't care whether it went down for timeout\n # or for normal reasons.\n %{^position => {_, {:ok, _} = ok}} ->\n ok\n\n # If the task exited by itself before replying, we emit {:exit, reason}.\n %{^position => {_, :running, element}}\n when kind == :down ->\n if zip_input_on_exit?, do: {:exit, {element, reason}}, else: {:exit, reason}\n\n # If the task timed out before replying, we either exit (on_timeout: :exit)\n # or emit {:exit, :timeout} (on_timeout: :kill_task) (note the task is already\n # dead at this point).\n %{^position => {_, :running, element}}\n when kind == :timed_out ->\n if on_timeout == :exit do\n stream_cleanup_inbox(monitor_pid, monitor_ref)\n exit({:timeout, {__MODULE__, :stream, [timeout]}})\n else\n if zip_input_on_exit?, do: {:exit, {element, :timeout}}, else: {:exit, :timeout}\n end\n end\n\n if ordered? do\n waiting = Map.put(waiting, position, {:done, result})\n stream_deliver({:cont, acc}, max + 1, spawned, delivered, waiting, next, config)\n else\n pair = deliver_now(result, acc, next, config)\n waiting = Map.delete(waiting, position)\n stream_reduce(pair, max + 1, spawned, delivered + 1, waiting, next, config)\n end\n\n # The monitor process died. We just cleanup the messages from the monitor\n # process and exit.\n {:DOWN, ^monitor_ref, _, _, reason} ->\n stream_cleanup_inbox(monitor_pid, monitor_ref)\n exit({reason, {__MODULE__, :stream, [timeout]}})\n end\n end\n\n defp stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config) do\n try do\n next.({:cont, []})\n catch\n kind, reason ->\n stream_close(config)\n :erlang.raise(kind, reason, __STACKTRACE__)\n else\n {:suspended, [value], next} ->\n waiting = stream_spawn(value, spawned, waiting, config)\n stream_reduce({:cont, acc}, max - 1, spawned + 1, delivered, waiting, next, config)\n\n {_, [value]} ->\n waiting = stream_spawn(value, spawned, waiting, config)\n stream_reduce({:cont, acc}, max - 1, spawned + 1, delivered, waiting, :done, config)\n\n {_, []} ->\n stream_reduce({:cont, acc}, max, spawned, delivered, waiting, :done, config)\n end\n end\n\n defp deliver_now(reply, acc, next, config) do\n %{reducer: reducer} = config\n\n try do\n reducer.(reply, acc)\n catch\n kind, reason ->\n is_function(next) && next.({:halt, []})\n stream_close(config)\n :erlang.raise(kind, reason, __STACKTRACE__)\n end\n end\n\n defp stream_deliver({:suspend, acc}, max, spawned, delivered, waiting, next, config) do\n continuation = &stream_deliver(&1, max, spawned, delivered, waiting, next, config)\n {:suspended, acc, continuation}\n end\n\n defp stream_deliver({:halt, acc}, max, spawned, delivered, waiting, next, config) do\n stream_reduce({:halt, acc}, max, spawned, delivered, waiting, next, config)\n end\n\n defp stream_deliver({:cont, acc}, max, spawned, delivered, waiting, next, config) do\n %{reducer: reducer} = config\n\n case waiting do\n %{^delivered => {:done, reply}} ->\n try do\n reducer.(reply, acc)\n catch\n kind, reason ->\n is_function(next) && next.({:halt, []})\n stream_close(config)\n :erlang.raise(kind, reason, __STACKTRACE__)\n else\n pair ->\n waiting = Map.delete(waiting, delivered)\n stream_deliver(pair, max, spawned, delivered + 1, waiting, next, config)\n end\n\n %{} ->\n stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config)\n end\n end\n\n defp stream_close(%{monitor_pid: monitor_pid, monitor_ref: monitor_ref, timeout: timeout}) do\n send(monitor_pid, {:stop, monitor_ref})\n\n receive do\n {:DOWN, ^monitor_ref, _, _, :normal} ->\n stream_cleanup_inbox(monitor_pid, monitor_ref)\n :ok\n\n {:DOWN, ^monitor_ref, _, _, reason} ->\n stream_cleanup_inbox(monitor_pid, monitor_ref)\n exit({reason, {__MODULE__, :stream, [timeout]}})\n end\n end\n\n defp stream_cleanup_inbox(monitor_pid, monitor_ref) do\n receive do\n {:EXIT, ^monitor_pid, _} -> stream_cleanup_inbox(monitor_ref)\n after\n 0 -> stream_cleanup_inbox(monitor_ref)\n end\n end\n\n defp stream_cleanup_inbox(monitor_ref) do\n receive do\n {{^monitor_ref, _}, _} ->\n stream_cleanup_inbox(monitor_ref)\n\n {kind, {^monitor_ref, _}, _} when kind in [:down, :timed_out] ->\n stream_cleanup_inbox(monitor_ref)\n after\n 0 ->\n :ok\n end\n end\n\n # This function spawns a task for the given \"value\", and puts the pid of this\n # new task in the map of \"waiting\" tasks, which is returned.\n defp stream_spawn(value, spawned, waiting, config) do\n %{\n monitor_pid: monitor_pid,\n monitor_ref: monitor_ref,\n timeout: timeout,\n callers: callers,\n mfa: mfa,\n zip_input_on_exit: zip_input_on_exit?\n } = config\n\n send(monitor_pid, {:spawn, spawned})\n\n receive do\n {:spawned, {^monitor_ref, ^spawned}, pid} ->\n mfa_with_value = normalize_mfa_with_arg(mfa, value)\n send(pid, {self(), {monitor_ref, spawned}, self(), callers, mfa_with_value})\n stored_value = if zip_input_on_exit?, do: value, else: nil\n Map.put(waiting, spawned, {pid, :running, stored_value})\n\n {:max_children, ^monitor_ref} ->\n stream_close(config)\n\n raise \"\"\"\n reached the maximum number of tasks for this task supervisor. The maximum number \\\n of tasks that are allowed to run at the same time under this supervisor can be \\\n configured with the :max_children option passed to Task.Supervisor.start_link/1. When \\\n using async_stream or async_stream_nolink, make sure to configure :max_concurrency to \\\n be lower or equal to :max_children and pay attention to whether other tasks are also \\\n spawned under the same task supervisor.\\\n \"\"\"\n\n {:DOWN, ^monitor_ref, _, ^monitor_pid, reason} ->\n stream_cleanup_inbox(monitor_pid, monitor_ref)\n exit({reason, {__MODULE__, :stream, [timeout]}})\n end\n end\n\n defp stream_monitor(parent_pid, spawn, trap_exit?, timeout) do\n Process.flag(:trap_exit, trap_exit?)\n parent_ref = Process.monitor(parent_pid)\n\n # Let's wait for the parent process to tell this process the monitor ref\n # it's using to monitor this process. If the parent process dies while this\n # process waits, this process dies with the same reason.\n receive do\n {^parent_pid, monitor_ref} ->\n config = %{\n parent_pid: parent_pid,\n parent_ref: parent_ref,\n spawn: spawn,\n monitor_ref: monitor_ref,\n timeout: timeout\n }\n\n stream_monitor_loop(_running_tasks = %{}, config)\n\n {:DOWN, ^parent_ref, _, _, reason} ->\n exit(reason)\n end\n end\n\n defp stream_monitor_loop(running_tasks, config) do\n %{\n spawn: spawn,\n parent_pid: parent_pid,\n monitor_ref: monitor_ref,\n timeout: timeout\n } = config\n\n receive do\n # The parent process is telling us to spawn a new task to process\n # \"value\". We spawn it and notify the parent about its pid.\n {:spawn, position} ->\n case spawn.() do\n {:ok, type, pid} ->\n ref = Process.monitor(pid)\n\n # Schedule a timeout message to ourselves, unless the timeout was set to :infinity\n timer_ref =\n case timeout do\n :infinity -> nil\n timeout -> Process.send_after(self(), {:timeout, {monitor_ref, ref}}, timeout)\n end\n\n send(parent_pid, {:spawned, {monitor_ref, position}, pid})\n\n running_tasks =\n Map.put(running_tasks, ref, %{\n position: position,\n type: type,\n pid: pid,\n timer_ref: timer_ref,\n timed_out?: false\n })\n\n stream_monitor_loop(running_tasks, config)\n\n {:error, :max_children} ->\n send(parent_pid, {:max_children, monitor_ref})\n stream_waiting_for_stop_loop(running_tasks, config)\n end\n\n # One of the spawned processes went down. We inform the parent process of\n # this and keep going.\n {:DOWN, ref, _, _, reason} when is_map_key(running_tasks, ref) ->\n {task, running_tasks} = Map.pop(running_tasks, ref)\n %{position: position, timer_ref: timer_ref, timed_out?: timed_out?} = task\n\n if timer_ref != nil do\n :ok = Process.cancel_timer(timer_ref, async: true, info: false)\n end\n\n message_kind = if(timed_out?, do: :timed_out, else: :down)\n send(parent_pid, {message_kind, {monitor_ref, position}, reason})\n stream_monitor_loop(running_tasks, config)\n\n # One of the spawned processes timed out. We kill that process here\n # regardless of the value of :on_timeout. We then send a message to the\n # parent process informing it that a task timed out, and the parent\n # process decides what to do.\n {:timeout, {^monitor_ref, ref}} ->\n running_tasks =\n case running_tasks do\n %{^ref => %{pid: pid, timed_out?: false} = task_info} ->\n unlink_and_kill(pid)\n Map.put(running_tasks, ref, %{task_info | timed_out?: true})\n\n _other ->\n running_tasks\n end\n\n stream_monitor_loop(running_tasks, config)\n\n {:EXIT, _, _} ->\n stream_monitor_loop(running_tasks, config)\n\n other ->\n handle_stop_or_parent_down(other, running_tasks, config)\n stream_monitor_loop(running_tasks, config)\n end\n end\n\n defp stream_waiting_for_stop_loop(running_tasks, config) do\n receive do\n message ->\n handle_stop_or_parent_down(message, running_tasks, config)\n stream_waiting_for_stop_loop(running_tasks, config)\n end\n end\n\n # The parent process is telling us to stop because the stream is being\n # closed. In this case, we forcibly kill all spawned processes and then\n # exit gracefully ourselves.\n defp handle_stop_or_parent_down(\n {:stop, monitor_ref},\n running_tasks,\n %{monitor_ref: monitor_ref}\n ) do\n Process.flag(:trap_exit, true)\n\n for {_ref, %{pid: pid}} <- running_tasks, do: Process.exit(pid, :kill)\n\n for {ref, _task} <- running_tasks do\n receive do\n {:DOWN, ^ref, _, _, _} -> :ok\n end\n end\n\n exit(:normal)\n end\n\n # The parent process went down with a given reason. We kill all the\n # spawned processes (that are also linked) with the same reason, and then\n # exit ourselves with the same reason.\n defp handle_stop_or_parent_down(\n {:DOWN, parent_ref, _, _, reason},\n running_tasks,\n %{parent_ref: parent_ref}\n ) do\n for {_ref, %{type: :link, pid: pid}} <- running_tasks do\n Process.exit(pid, reason)\n end\n\n exit(reason)\n end\n\n # We ignore all other messages.\n defp handle_stop_or_parent_down(_other, _running_tasks, _config) do\n :ok\n end\n\n defp unlink_and_kill(pid) do\n caller = self()\n ref = make_ref()\n\n enforcer =\n spawn(fn ->\n mon = Process.monitor(caller)\n\n receive do\n {:done, ^ref} -> :ok\n {:DOWN, ^mon, _, _, _} -> Process.exit(pid, :kill)\n end\n end)\n\n Process.unlink(pid)\n Process.exit(pid, :kill)\n send(enforcer, {:done, ref})\n end\n\n defp normalize_mfa_with_arg({mod, fun, args}, arg), do: {mod, fun, [arg | args]}\n defp normalize_mfa_with_arg(fun, arg), do: {:erlang, :apply, [fun, [arg]]}\nend\n" }, { "path": "lib/elixir/lib/task/supervisor.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Task.Supervisor do\n @moduledoc \"\"\"\n A task supervisor.\n\n This module defines a supervisor which can be used to dynamically\n supervise tasks.\n\n A task supervisor is started with no children, often under a\n supervisor and a name:\n\n children = [\n {Task.Supervisor, name: MyApp.TaskSupervisor}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n\n The options given in the child specification are documented in `start_link/1`.\n\n Once started, you can start tasks directly under the supervisor, for example:\n\n task = Task.Supervisor.async(MyApp.TaskSupervisor, fn ->\n :do_some_work\n end)\n\n See the `Task` module for more examples.\n\n ## Scalability and partitioning\n\n The `Task.Supervisor` is a single process responsible for starting\n other processes. In some applications, the `Task.Supervisor` may\n become a bottleneck. To address this, you can start multiple instances\n of the `Task.Supervisor` and then pick a random instance to start\n the task on.\n\n Instead of:\n\n children = [\n {Task.Supervisor, name: MyApp.TaskSupervisor}\n ]\n\n and:\n\n Task.Supervisor.async(MyApp.TaskSupervisor, fn -> :do_some_work end)\n\n You can do this:\n\n children = [\n {PartitionSupervisor,\n child_spec: Task.Supervisor,\n name: MyApp.TaskSupervisors}\n ]\n\n and then:\n\n Task.Supervisor.async(\n {:via, PartitionSupervisor, {MyApp.TaskSupervisors, self()}},\n fn -> :do_some_work end\n )\n\n In the code above, we start a partition supervisor that will by default\n start a dynamic supervisor for each core in your machine. Then, instead\n of calling the `Task.Supervisor` by name, you call it through the\n partition supervisor using the `{:via, PartitionSupervisor, {name, key}}`\n format, where `name` is the name of the partition supervisor and `key`\n is the routing key. We picked `self()` as the routing key, which means\n each process will be assigned one of the existing task supervisors.\n Read the `PartitionSupervisor` docs for more information.\n\n ## Name registration\n\n A `Task.Supervisor` is bound to the same name registration rules as a\n `GenServer`. Read more about them in the `GenServer` docs.\n \"\"\"\n\n @typedoc \"Option values used by `start_link`\"\n @type option ::\n GenServer.option()\n | DynamicSupervisor.init_option()\n\n @typedoc \"\"\"\n Options given to `async_stream` and `async_stream_nolink` functions.\n \"\"\"\n @typedoc since: \"1.17.0\"\n @type async_stream_option :: Task.async_stream_option() | {:shutdown, Supervisor.shutdown()}\n\n @typedoc \"\"\"\n Options for `async/3`, `async/5`, `async_nolink/3`, and `async_nolink/5` functions.\n \"\"\"\n @type async_opts :: [\n shutdown: :brutal_kill | timeout()\n ]\n\n @type start_child_opts :: [\n restart: :temporary | :transient | :permanent,\n shutdown: :brutal_kill | timeout()\n ]\n\n @doc false\n def child_spec(opts) when is_list(opts) do\n id =\n case Keyword.get(opts, :name, Task.Supervisor) do\n name when is_atom(name) -> name\n {:global, name} -> name\n {:via, _module, name} -> name\n end\n\n %{\n id: id,\n start: {Task.Supervisor, :start_link, [opts]},\n type: :supervisor\n }\n end\n\n @doc \"\"\"\n Starts a new supervisor.\n\n ## Examples\n\n A task supervisor is typically started under a supervision tree using\n the tuple format:\n\n {Task.Supervisor, name: MyApp.TaskSupervisor}\n\n You can also start it by calling `start_link/1` directly:\n\n Task.Supervisor.start_link(name: MyApp.TaskSupervisor)\n\n But this is recommended only for scripting and should be avoided in\n production code. Generally speaking, processes should always be started\n inside supervision trees.\n\n ## Options\n\n * `:name` - used to register a supervisor name, the supported values are\n described under the `Name Registration` section in the `GenServer` module\n docs;\n\n * `:max_restarts`, `:max_seconds`, and `:max_children` - as specified in\n `DynamicSupervisor`;\n\n This function could also receive `:restart` and `:shutdown` as options\n but those two options have been deprecated and it is now preferred to\n give them directly to `start_child`.\n \"\"\"\n @spec start_link([option]) :: Supervisor.on_start()\n def start_link(options \\\\ []) do\n {restart, options} = Keyword.pop(options, :restart)\n {shutdown, options} = Keyword.pop(options, :shutdown)\n\n if restart || shutdown do\n IO.warn(\n \":restart and :shutdown options in Task.Supervisor.start_link/1 \" <>\n \"are deprecated. Please pass those options on start_child/3 instead\"\n )\n end\n\n keys = [:max_children, :max_seconds, :max_restarts]\n {sup_opts, start_opts} = Keyword.split(options, keys)\n restart_and_shutdown = {restart || :temporary, shutdown || 5000}\n DynamicSupervisor.start_link(__MODULE__, {restart_and_shutdown, sup_opts}, start_opts)\n end\n\n @doc false\n def init({{_restart, _shutdown} = arg, options}) do\n Process.put(__MODULE__, arg)\n DynamicSupervisor.init([strategy: :one_for_one] ++ options)\n end\n\n @doc \"\"\"\n Starts a task that can be awaited on.\n\n The `supervisor` must be a reference as defined in `Supervisor`.\n The task will still be linked to the caller, see `Task.async/1` for\n more information and `async_nolink/3` for a non-linked variant.\n\n Raises an error if `supervisor` has reached the maximum number of\n children.\n\n ## Options\n\n * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown\n or an integer indicating the timeout value, defaults to 5000 milliseconds.\n The tasks must trap exits for the timeout to have an effect.\n\n \"\"\"\n @spec async(Supervisor.supervisor(), (-> any), async_opts) :: Task.t()\n def async(supervisor, fun, options \\\\ []) do\n async(supervisor, :erlang, :apply, [fun, []], options)\n end\n\n @doc \"\"\"\n Starts a task that can be awaited on.\n\n The `supervisor` must be a reference as defined in `Supervisor`.\n The task will still be linked to the caller, see `Task.async/1` for\n more information and `async_nolink/3` for a non-linked variant.\n\n Raises an error if `supervisor` has reached the maximum number of\n children.\n\n ## Options\n\n * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown\n or an integer indicating the timeout value, defaults to 5000 milliseconds.\n The tasks must trap exits for the timeout to have an effect.\n\n \"\"\"\n @spec async(Supervisor.supervisor(), module, atom, [term], async_opts) :: Task.t()\n def async(supervisor, module, fun, args, options \\\\ []) do\n async(supervisor, :link, module, fun, args, options)\n end\n\n @doc \"\"\"\n Starts a task that can be awaited on.\n\n The `supervisor` must be a reference as defined in `Supervisor`.\n The task won't be linked to the caller, see `Task.async/1` for\n more information.\n\n Raises an error if `supervisor` has reached the maximum number of\n children.\n\n Note this function requires the task supervisor to have `:temporary`\n as the `:restart` option (the default), as `async_nolink/3` keeps a\n direct reference to the task which is lost if the task is restarted.\n\n ## Options\n\n * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown\n or an integer indicating the timeout value, defaults to 5000 milliseconds.\n The tasks must trap exits for the timeout to have an effect.\n\n ## Compatibility with OTP behaviours\n\n If you create a task using `async_nolink` inside an OTP behaviour\n like `GenServer`, you should match on the message coming from the\n task inside your `c:GenServer.handle_info/2` callback.\n\n The reply sent by the task will be in the format `{ref, result}`,\n where `ref` is the monitor reference held by the task struct\n and `result` is the return value of the task function.\n\n Keep in mind that, regardless of how the task created with `async_nolink`\n terminates, the caller's process will always receive a `:DOWN` message\n with the same `ref` value that is held by the task struct. If the task\n terminates normally, the reason in the `:DOWN` message will be `:normal`.\n\n ## Examples\n\n Typically, you use `async_nolink/3` when there is a reasonable expectation that\n the task may fail, and you don't want it to take down the caller. Let's see an\n example where a `GenServer` is meant to run a single task and track its status:\n\n defmodule MyApp.Server do\n use GenServer\n\n # ...\n\n def start_task do\n GenServer.call(__MODULE__, :start_task)\n end\n\n # In this case the task is already running, so we just return :ok.\n def handle_call(:start_task, _from, %{ref: ref} = state) when is_reference(ref) do\n {:reply, :ok, state}\n end\n\n # The task is not running yet, so let's start it.\n def handle_call(:start_task, _from, %{ref: nil} = state) do\n task =\n Task.Supervisor.async_nolink(MyApp.TaskSupervisor, fn ->\n ...\n end)\n\n # We return :ok and the server will continue running\n {:reply, :ok, %{state | ref: task.ref}}\n end\n\n # The task completed successfully\n def handle_info({ref, answer}, %{ref: ref} = state) do\n # We don't care about the DOWN message now, so let's demonitor and flush it\n Process.demonitor(ref, [:flush])\n # Do something with the result and then return\n {:noreply, %{state | ref: nil}}\n end\n\n # The task failed\n def handle_info({:DOWN, ref, :process, _pid, _reason}, %{ref: ref} = state) do\n # Log and possibly restart the task...\n {:noreply, %{state | ref: nil}}\n end\n end\n\n \"\"\"\n @spec async_nolink(Supervisor.supervisor(), (-> any), async_opts) :: Task.t()\n def async_nolink(supervisor, fun, options \\\\ []) do\n async_nolink(supervisor, :erlang, :apply, [fun, []], options)\n end\n\n @doc \"\"\"\n Starts a task that can be awaited on.\n\n The `supervisor` must be a reference as defined in `Supervisor`.\n The task won't be linked to the caller, see `Task.async/1` for\n more information.\n\n Raises an error if `supervisor` has reached the maximum number of\n children.\n\n Note this function requires the task supervisor to have `:temporary`\n as the `:restart` option (the default), as `async_nolink/5` keeps a\n direct reference to the task which is lost if the task is restarted.\n \"\"\"\n @spec async_nolink(Supervisor.supervisor(), module, atom, [term], async_opts) :: Task.t()\n def async_nolink(supervisor, module, fun, args, options \\\\ []) do\n async(supervisor, :nolink, module, fun, args, options)\n end\n\n @doc \"\"\"\n Returns a stream where the given function (`module` and `function`)\n is mapped concurrently on each element in `enumerable`.\n\n Each element will be prepended to the given `args` and processed by its\n own task. The tasks will be spawned under the given `supervisor` and\n linked to the caller process, similarly to `async/5`.\n\n When streamed, each task will emit `{:ok, value}` upon successful\n completion or `{:exit, reason}` if the caller is trapping exits.\n The order of results depends on the value of the `:ordered` option.\n\n The level of concurrency and the time tasks are allowed to run can\n be controlled via options (see the \"Options\" section below).\n\n If you find yourself trapping exits to handle exits inside\n the async stream, consider using `async_stream_nolink/6` to start tasks\n that are not linked to the calling process.\n\n ## Options\n\n * `:max_concurrency` - sets the maximum number of tasks to run\n at the same time. Defaults to `System.schedulers_online/0`.\n\n * `:ordered` - whether the results should be returned in the same order\n as the input stream. This option is useful when you have large\n streams and don't want to buffer results before they are delivered.\n This is also useful when you're using the tasks for side effects.\n Defaults to `true`.\n\n * `:timeout` - the maximum amount of time to wait (in milliseconds)\n without receiving a task reply (across all running tasks).\n Defaults to `5000`.\n\n * `:on_timeout` - what do to when a task times out. The possible\n values are:\n * `:exit` (default) - the process that spawned the tasks exits.\n * `:kill_task` - the task that timed out is killed. The value\n emitted for that task is `{:exit, :timeout}`.\n\n * `:zip_input_on_exit` - (since v1.14.0) adds the original\n input to `:exit` tuples. The value emitted for that task is\n `{:exit, {input, reason}}`, where `input` is the collection element\n that caused an exited during processing. Defaults to `false`.\n\n * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown\n or an integer indicating the timeout value. Defaults to `5000` milliseconds.\n The tasks must trap exits for the timeout to have an effect.\n\n ## Examples\n\n Let's build a stream and then enumerate it:\n\n stream = Task.Supervisor.async_stream(MySupervisor, collection, Mod, :expensive_fun, [])\n Enum.to_list(stream)\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec async_stream(\n Supervisor.supervisor(),\n Enumerable.t(),\n module,\n atom,\n [term],\n [async_stream_option]\n ) :: Enumerable.t()\n def async_stream(supervisor, enumerable, module, function, args, options \\\\ [])\n when is_atom(module) and is_atom(function) and is_list(args) do\n build_stream(supervisor, :link, enumerable, {module, function, args}, options)\n end\n\n @doc \"\"\"\n Returns a stream that runs the given function `fun` concurrently\n on each element in `enumerable`.\n\n Each element in `enumerable` is passed as argument to the given function `fun`\n and processed by its own task. The tasks will be spawned under the given\n `supervisor` and linked to the caller process, similarly to `async/3`.\n\n See `async_stream/6` for discussion, options, and examples.\n \"\"\"\n @doc since: \"1.4.0\"\n @spec async_stream(\n Supervisor.supervisor(),\n Enumerable.t(),\n (term -> term),\n [async_stream_option]\n ) :: Enumerable.t()\n def async_stream(supervisor, enumerable, fun, options \\\\ []) when is_function(fun, 1) do\n build_stream(supervisor, :link, enumerable, fun, options)\n end\n\n @doc \"\"\"\n Returns a stream where the given function (`module` and `function`)\n is mapped concurrently on each element in `enumerable`.\n\n Each element in `enumerable` will be prepended to the given `args` and processed\n by its own task. The tasks will be spawned under the given `supervisor` and\n will not be linked to the caller process, similarly to `async_nolink/5`.\n\n See `async_stream/6` for discussion, options, and examples.\n \"\"\"\n @doc since: \"1.4.0\"\n @spec async_stream_nolink(\n Supervisor.supervisor(),\n Enumerable.t(),\n module,\n atom,\n [term],\n [async_stream_option]\n ) :: Enumerable.t()\n def async_stream_nolink(supervisor, enumerable, module, function, args, options \\\\ [])\n when is_atom(module) and is_atom(function) and is_list(args) do\n build_stream(supervisor, :nolink, enumerable, {module, function, args}, options)\n end\n\n @doc ~S\"\"\"\n Returns a stream that runs the given `function` concurrently on each\n element in `enumerable`.\n\n Each element in `enumerable` is passed as argument to the given function `fun`\n and processed by its own task. The tasks will be spawned under the given\n `supervisor` and will not be linked to the caller process, similarly\n to `async_nolink/3`.\n\n See `async_stream/6` for discussion and examples.\n\n ## Error handling and cleanup\n\n Even if tasks are not linked to the caller, there is no risk of leaving dangling tasks\n running after the stream halts.\n\n Consider the following example:\n\n Task.Supervisor.async_stream_nolink(MySupervisor, collection, fun, on_timeout: :kill_task, ordered: false)\n |> Enum.each(fn\n {:ok, _} -> :ok\n {:exit, reason} -> raise \"Task exited: #{Exception.format_exit(reason)}\"\n end)\n\n If one task raises or times out:\n\n 1. the second clause gets called\n 2. an exception is raised\n 3. the stream halts\n 4. all ongoing tasks will be shut down\n\n Here is another example:\n\n Task.Supervisor.async_stream_nolink(MySupervisor, collection, fun, on_timeout: :kill_task, ordered: false)\n |> Stream.filter(&match?({:ok, _}, &1))\n |> Enum.take(3)\n\n This will return the three first tasks to succeed, ignoring timeouts and errors, and shut down\n every ongoing task.\n\n Just running the stream with `Stream.run/1` on the other hand would ignore errors and process the whole stream.\n\n \"\"\"\n @doc since: \"1.4.0\"\n @spec async_stream_nolink(\n Supervisor.supervisor(),\n Enumerable.t(),\n (term -> term),\n [async_stream_option]\n ) :: Enumerable.t()\n def async_stream_nolink(supervisor, enumerable, fun, options \\\\ []) when is_function(fun, 1) do\n build_stream(supervisor, :nolink, enumerable, fun, options)\n end\n\n @doc \"\"\"\n Terminates the child with the given `pid`.\n \"\"\"\n @spec terminate_child(Supervisor.supervisor(), pid) :: :ok | {:error, :not_found}\n def terminate_child(supervisor, pid) when is_pid(pid) do\n DynamicSupervisor.terminate_child(supervisor, pid)\n end\n\n @doc \"\"\"\n Returns all children PIDs except those that are restarting.\n\n Note that calling this function when supervising a large number\n of children under low memory conditions can bring the system down due to an\n out of memory error.\n \"\"\"\n @spec children(Supervisor.supervisor()) :: [pid]\n def children(supervisor) do\n for {_, pid, _, _} <- DynamicSupervisor.which_children(supervisor), is_pid(pid), do: pid\n end\n\n @doc \"\"\"\n Starts a task as a child of the given `supervisor`.\n\n Task.Supervisor.start_child(MyTaskSupervisor, fn ->\n IO.puts(\"I am running in a task\")\n end)\n\n Note that the spawned process is not linked to the caller, but\n only to the supervisor. This command is useful in case the\n task needs to perform side-effects (like I/O) and you have no\n interest in its results nor if it completes successfully.\n\n ## Options\n\n * `:restart` - the restart strategy, may be `:temporary` (the default),\n `:transient` or `:permanent`. `:temporary` means the task is never\n restarted, `:transient` means it is restarted if the exit is not\n `:normal`, `:shutdown` or `{:shutdown, reason}`. A `:permanent` restart\n strategy means it is always restarted.\n\n * `:shutdown` - `:brutal_kill` if the task must be killed directly on shutdown\n or an integer indicating the timeout value, defaults to 5000 milliseconds.\n The task must trap exits for the timeout to have an effect.\n\n \"\"\"\n @spec start_child(Supervisor.supervisor(), (-> any), start_child_opts) ::\n DynamicSupervisor.on_start_child()\n def start_child(supervisor, fun, options \\\\ []) do\n restart = options[:restart]\n shutdown = options[:shutdown]\n args = [get_owner(self()), get_callers(self()), {:erlang, :apply, [fun, []]}]\n start_child_with_spec(supervisor, args, restart, shutdown)\n end\n\n @doc \"\"\"\n Starts a task as a child of the given `supervisor`.\n\n Similar to `start_child/3` except the task is specified\n by the given `module`, `fun` and `args`.\n \"\"\"\n @spec start_child(Supervisor.supervisor(), module, atom, [term], start_child_opts) ::\n DynamicSupervisor.on_start_child()\n def start_child(supervisor, module, fun, args, options \\\\ [])\n when is_atom(fun) and is_list(args) do\n restart = options[:restart]\n shutdown = options[:shutdown]\n mfa = {module, fun, args}\n owner = get_owner(self())\n callers = get_callers(self())\n\n if restart == :temporary or restart == nil do\n start_child_maybe_temporary(supervisor, owner, callers, restart, shutdown, mfa)\n else\n start_child_with_spec(supervisor, [owner, callers, mfa], restart, shutdown)\n end\n end\n\n defp start_child_maybe_temporary(supervisor, owner, callers, restart, shutdown, mfa) do\n case start_child_with_spec(supervisor, [owner, :monitor], restart, shutdown) do\n # TODO: This only exists because we need to support reading restart/shutdown\n # from two different places. Remove this, the init function and the associated\n # clause in DynamicSupervisor on Elixir v2.0\n {:restart, restart} ->\n start_child_with_spec(supervisor, [owner, callers, mfa], restart, shutdown)\n\n {:ok, pid} ->\n # We mimic async but there is nothing to reply to\n alias = make_ref()\n send(pid, {self(), alias, alias, callers, mfa})\n {:ok, pid}\n\n {:error, _} = error ->\n error\n end\n end\n\n defp start_child_with_spec(supervisor, args, restart, shutdown) do\n GenServer.call(supervisor, {:start_task, args, restart, shutdown}, :infinity)\n end\n\n defp get_owner(pid) do\n self_or_name =\n case Process.info(pid, :registered_name) do\n {:registered_name, name} when is_atom(name) -> name\n _ -> pid\n end\n\n {node(), self_or_name, pid}\n end\n\n defp get_callers(owner) do\n case :erlang.get(:\"$callers\") do\n [_ | _] = list -> [owner | list]\n _ -> [owner]\n end\n end\n\n defp async(supervisor, link_type, module, fun, args, options) do\n owner = self()\n shutdown = options[:shutdown]\n\n case start_child_with_spec(supervisor, [get_owner(owner), :monitor], :temporary, shutdown) do\n {:ok, pid} ->\n if link_type == :link, do: Process.link(pid)\n alias = Task.__alias__(pid)\n send(pid, {owner, alias, alias, get_callers(owner), {module, fun, args}})\n %Task{pid: pid, ref: alias, owner: owner, mfa: {module, fun, length(args)}}\n\n {:error, :max_children} ->\n raise \"\"\"\n reached the maximum number of tasks for this task supervisor. The maximum number \\\n of tasks that are allowed to run at the same time under this supervisor can be \\\n configured with the :max_children option passed to Task.Supervisor.start_link/1\\\n \"\"\"\n end\n end\n\n defp build_stream(supervisor, link_type, enumerable, fun, options) do\n shutdown = Keyword.get(options, :shutdown, 5000)\n\n if not ((is_integer(shutdown) and shutdown >= 0) or shutdown == :brutal_kill) do\n raise ArgumentError, \":shutdown must be either a positive integer or :brutal_kill\"\n end\n\n options = Task.Supervised.validate_stream_options(options)\n\n fn acc, acc_fun ->\n owner = get_owner(self())\n\n Task.Supervised.stream(enumerable, acc, acc_fun, get_callers(self()), fun, options, fn ->\n args = [owner, :monitor]\n\n case start_child_with_spec(supervisor, args, :temporary, shutdown) do\n {:ok, pid} ->\n if link_type == :link, do: Process.link(pid)\n {:ok, link_type, pid}\n\n {:error, :max_children} ->\n {:error, :max_children}\n end\n end)\n end\n end\nend\n" }, { "path": "lib/elixir/lib/task.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Task do\n @moduledoc \"\"\"\n Conveniences for spawning and awaiting tasks.\n\n Tasks are processes meant to execute one particular\n action throughout their lifetime, often with little or no\n communication with other processes. The most common use case\n for tasks is to convert sequential code into concurrent code\n by computing a value asynchronously:\n\n task = Task.async(fn -> do_some_work() end)\n res = do_some_other_work()\n res + Task.await(task)\n\n Tasks spawned with `async` can be awaited on by their caller\n process (and only their caller) as shown in the example above.\n They are implemented by spawning a process that sends a message\n to the caller once the given computation is performed.\n\n Compared to plain processes, started with `spawn/1`, tasks\n include monitoring metadata and logging in case of errors.\n\n Besides `async/1` and `await/2`, tasks can also be\n started as part of a supervision tree and dynamically spawned\n on remote nodes. We will explore these scenarios next.\n\n ## async and await\n\n One of the common uses of tasks is to convert sequential code\n into concurrent code with `Task.async/1` while keeping its semantics.\n When invoked, a new process will be created, linked and monitored\n by the caller. Once the task action finishes, a message will be sent\n to the caller with the result.\n\n `Task.await/2` is used to read the message sent by the task.\n\n There are two important things to consider when using `async`:\n\n 1. If you are using async tasks, you **must await** a reply\n as they are *always* sent. If you are not expecting a reply,\n consider using `Task.start_link/1` as detailed below.\n\n 2. Async tasks link the caller and the spawned process. This\n means that, if the caller crashes, the task will crash\n too and vice-versa. This is on purpose: if the process\n meant to receive the result no longer exists, there is\n no purpose in completing the computation. If this is not\n desired, you will want to use supervised tasks, described\n in a subsequent section.\n\n ## Tasks are processes\n\n Tasks are processes and so data will need to be completely copied\n to them. Take the following code as an example:\n\n large_data = fetch_large_data()\n task = Task.async(fn -> do_some_work(large_data) end)\n res = do_some_other_work()\n res + Task.await(task)\n\n The code above copies over all of `large_data`, which can be\n resource intensive depending on the size of the data.\n There are two ways to address this.\n\n First, if you need to access only part of `large_data`,\n consider extracting it before the task:\n\n large_data = fetch_large_data()\n subset_data = large_data.some_field\n task = Task.async(fn -> do_some_work(subset_data) end)\n\n Alternatively, if you can move the data loading altogether\n to the task, it may be even better:\n\n task = Task.async(fn ->\n large_data = fetch_large_data()\n do_some_work(large_data)\n end)\n\n ## Dynamically supervised tasks\n\n The `Task.Supervisor` module allows developers to dynamically\n create multiple supervised tasks.\n\n A short example is:\n\n {:ok, pid} = Task.Supervisor.start_link()\n\n task =\n Task.Supervisor.async(pid, fn ->\n # Do something\n end)\n\n Task.await(task)\n\n However, in the majority of cases, you want to add the task supervisor\n to your supervision tree:\n\n Supervisor.start_link([\n {Task.Supervisor, name: MyApp.TaskSupervisor}\n ], strategy: :one_for_one)\n\n And now you can use async/await by passing the name of\n the supervisor instead of the PID:\n\n Task.Supervisor.async(MyApp.TaskSupervisor, fn ->\n # Do something\n end)\n |> Task.await()\n\n We encourage developers to rely on supervised tasks as much as possible.\n Supervised tasks improve the visibility of how many tasks are running\n at a given moment and enable a variety of patterns that give you\n explicit control on how to handle the results, errors, and timeouts.\n Here is a summary:\n\n * Using `Task.Supervisor.start_child/2` allows you to start a fire-and-forget\n task when you don't care about its results or if it completes successfully or not.\n\n * Using `Task.Supervisor.async/2` + `Task.await/2` allows you to execute\n tasks concurrently and retrieve its result. If the task fails,\n the caller will also fail.\n\n * Using `Task.Supervisor.async_nolink/2` + `Task.yield/2` + `Task.shutdown/2`\n allows you to execute tasks concurrently and retrieve their results\n or the reason they failed within a given time frame. If the task fails,\n the caller won't fail. You will receive the error reason either on\n `yield` or `shutdown`.\n\n Furthermore, the supervisor guarantees all tasks terminate within a\n configurable shutdown period when your application shuts down. See the\n `Task.Supervisor` module for details on the supported operations.\n\n ### Distributed tasks\n\n With `Task.Supervisor`, it is easy to dynamically start tasks across nodes:\n\n # First on the remote node named :remote@local\n Task.Supervisor.start_link(name: MyApp.DistSupervisor)\n\n # Then on the local client node\n supervisor = {MyApp.DistSupervisor, :remote@local}\n Task.Supervisor.async(supervisor, MyMod, :my_fun, [arg1, arg2, arg3])\n\n Note that, as above, when working with distributed tasks, one should use the\n `Task.Supervisor.async/5` function that expects explicit module, function,\n and arguments, instead of `Task.Supervisor.async/3` that works with anonymous\n functions. That's because anonymous functions expect the same module version\n to exist on all involved nodes. Check the `Agent` module documentation for\n more information on distributed processes as the limitations described there\n apply to the whole ecosystem.\n\n ## Statically supervised tasks\n\n The `Task` module implements the `child_spec/1` function, which\n allows it to be started directly under a regular `Supervisor` -\n instead of a `Task.Supervisor` - by passing a tuple with a function\n to run:\n\n Supervisor.start_link([\n {Task, fn -> :some_work end}\n ], strategy: :one_for_one)\n\n This is often useful when you need to execute code concurrently while\n setting up your supervision tree. For example: to warm up caches,\n log the initialization status, and such.\n\n If you don't want to put the Task code directly under the `Supervisor`,\n you can wrap the `Task` in its own module, similar to how you would\n do with a `GenServer` or an `Agent`:\n\n defmodule MyTask do\n use Task\n\n def start_link(arg) do\n Task.start_link(__MODULE__, :run, [arg])\n end\n\n def run(arg) do\n # ...\n end\n end\n\n And then passing it to the supervisor:\n\n Supervisor.start_link([\n {MyTask, arg}\n ], strategy: :one_for_one)\n\n Since these tasks are supervised and not directly linked to the caller,\n they cannot be awaited on. By default, the functions `Task.start/1`\n and `Task.start_link/1` are for fire-and-forget tasks, where you don't\n care about the results or if it completes successfully or not.\n\n Keep in mind the Supervisor will not wait for the task to finish running\n before starting the next child or returning. If you need synchronous\n initialization, then either use an `Agent` or a `GenServer`.\n\n > #### `use Task` {: .info}\n >\n > When you `use Task`, the `Task` module will define a\n > `child_spec/1` function, so your module can be used\n > as a child in a supervision tree.\n\n The generated `child_spec/1` can be customized with the following options:\n\n * `:id` - the child specification identifier, defaults to the current module\n * `:restart` - when the child should be restarted, defaults to `:temporary`\n * `:shutdown` - how to shut down the child, either immediately or by giving it time to shut down\n\n Opposite to `GenServer`, `Agent` and `Supervisor`, a Task has\n a default `:restart` of `:temporary`. This means the task will\n not be restarted even if it crashes. If you desire the task to\n be restarted for non-successful exits, do:\n\n use Task, restart: :transient\n\n If you want the task to always be restarted:\n\n use Task, restart: :permanent\n\n See the \"Child specification\" section in the `Supervisor` module\n for more detailed information. The `@doc` annotation immediately\n preceding `use Task` will be attached to the generated `child_spec/1`\n function.\n\n ## Ancestor and Caller Tracking\n\n Whenever you start a new process, Elixir annotates the process with the parent\n through the `$ancestors` key in the process dictionary. This is often used to\n track the hierarchy inside a supervision tree.\n\n For example, we recommend developers to always start tasks under a supervisor.\n This provides more visibility and allows you to control how those tasks are\n terminated when a node shuts down. That might look something like\n `Task.Supervisor.start_child(MySupervisor, task_function)`. This means\n that, although your code is the one invoking the task, the actual ancestor of\n the task is the supervisor, as the supervisor is the one effectively starting it.\n\n To track the relationship between your code and the task, we use the `$callers`\n key in the process dictionary. Therefore, assuming the `Task.Supervisor` call\n above, we have:\n\n [your code] -- calls --> [supervisor] ---- spawns --> [task]\n\n Which means we store the following relationships:\n\n [your code] [supervisor] <-- ancestor -- [task]\n ^ |\n |--------------------- caller ---------------------|\n\n The list of callers of the current process can be retrieved from the Process\n dictionary with `Process.get(:\"$callers\")`. This will return either `nil` or\n a list `[pid_n, ..., pid2, pid1]` with at least one entry where `pid_n` is\n the PID that called the current process, `pid2` called `pid_n`, and `pid2` was\n called by `pid1`.\n\n If a task crashes, the callers field is included as part of the log message\n metadata under the `:callers` key.\n \"\"\"\n\n @doc \"\"\"\n The Task struct.\n\n It contains these fields:\n\n * `:mfa` - a three-element tuple containing the module, function name,\n and arity invoked to start the task in `async/1` and `async/3`\n\n * `:owner` - the PID of the process that started the task\n\n * `:pid` - the PID of the task process; `nil` if there is no process\n specifically assigned for the task\n\n * `:ref` - an opaque term used as the task monitor reference\n\n \"\"\"\n @enforce_keys [:mfa, :owner, :pid, :ref]\n defstruct @enforce_keys\n\n @typedoc \"\"\"\n The Task type.\n\n See [`%Task{}`](`__struct__/0`) for information about each field of the structure.\n \"\"\"\n @type t :: %__MODULE__{\n mfa: mfa(),\n owner: pid(),\n pid: pid() | nil,\n ref: ref()\n }\n\n @typedoc \"\"\"\n The task opaque reference.\n \"\"\"\n @opaque ref :: reference()\n\n @typedoc \"\"\"\n Options given to `async_stream` functions.\n \"\"\"\n @typedoc since: \"1.17.0\"\n @type async_stream_option ::\n {:max_concurrency, pos_integer()}\n | {:ordered, boolean()}\n | {:timeout, timeout()}\n | {:on_timeout, :exit | :kill_task}\n | {:zip_input_on_exit, boolean()}\n\n defguardp is_timeout(timeout)\n when timeout == :infinity or (is_integer(timeout) and timeout >= 0)\n\n @doc \"\"\"\n Returns a specification to start a task under a supervisor.\n\n `arg` is passed as the argument to `Task.start_link/1` in the `:start` field\n of the spec.\n\n For more information, see the `Supervisor` module,\n the `Supervisor.child_spec/2` function and the `t:Supervisor.child_spec/0` type.\n \"\"\"\n @doc since: \"1.5.0\"\n @spec child_spec(term) :: Supervisor.child_spec()\n def child_spec(arg) do\n %{\n id: Task,\n start: {Task, :start_link, [arg]},\n restart: :temporary\n }\n end\n\n @doc false\n defmacro __using__(opts) do\n quote location: :keep, bind_quoted: [opts: opts] do\n if not Module.has_attribute?(__MODULE__, :doc) do\n @doc \"\"\"\n Returns a specification to start this module under a supervisor.\n\n `arg` is passed as the argument to `Task.start_link/1` in the `:start` field\n of the spec.\n\n For more information, see the `Supervisor` module,\n the `Supervisor.child_spec/2` function and the `t:Supervisor.child_spec/0` type.\n \"\"\"\n end\n\n def child_spec(arg) do\n default = %{\n id: __MODULE__,\n start: {__MODULE__, :start_link, [arg]},\n restart: :temporary\n }\n\n Supervisor.child_spec(default, unquote(Macro.escape(opts)))\n end\n\n defoverridable child_spec: 1\n end\n end\n\n @doc \"\"\"\n Starts a task as part of a supervision tree with the given `fun`.\n\n `fun` must be a zero-arity anonymous function.\n\n This is used to start a statically supervised task under a supervision tree.\n \"\"\"\n @spec start_link((-> any)) :: {:ok, pid}\n def start_link(fun) when is_function(fun, 0) do\n start_link(:erlang, :apply, [fun, []])\n end\n\n @doc \"\"\"\n Starts a task as part of a supervision tree with the given\n `module`, `function`, and `args`.\n\n This is used to start a statically supervised task under a supervision tree.\n \"\"\"\n @spec start_link(module, atom, [term]) :: {:ok, pid}\n def start_link(module, function, args)\n when is_atom(module) and is_atom(function) and is_list(args) do\n mfa = {module, function, args}\n Task.Supervised.start_link(get_owner(self()), get_callers(self()), mfa)\n end\n\n @doc \"\"\"\n Starts a task.\n\n `fun` must be a zero-arity anonymous function.\n\n This should only used when the task is used for side-effects\n (like I/O) and you have no interest on its results nor if it\n completes successfully.\n\n If the current node is shutdown, the node will terminate even\n if the task was not completed. For this reason, we recommend\n to use `Task.Supervisor.start_child/2` instead, which allows\n you to control the shutdown time via the `:shutdown` option.\n \"\"\"\n @spec start((-> any)) :: {:ok, pid}\n def start(fun) when is_function(fun, 0) do\n start(:erlang, :apply, [fun, []])\n end\n\n @doc \"\"\"\n Starts a task.\n\n This should only used when the task is used for side-effects\n (like I/O) and you have no interest on its results nor if it\n completes successfully.\n\n If the current node is shutdown, the node will terminate even\n if the task was not completed. For this reason, we recommend\n to use `Task.Supervisor.start_child/2` instead, which allows\n you to control the shutdown time via the `:shutdown` option.\n \"\"\"\n @spec start(module, atom, [term]) :: {:ok, pid}\n def start(module, function_name, args)\n when is_atom(module) and is_atom(function_name) and is_list(args) do\n mfa = {module, function_name, args}\n Task.Supervised.start(get_owner(self()), get_callers(self()), mfa)\n end\n\n @doc \"\"\"\n Starts a task that must be awaited on.\n\n `fun` must be a zero-arity anonymous function. This function\n spawns a process that is linked to and monitored by the caller\n process. A `Task` struct is returned containing the relevant\n information.\n\n If you start an `async`, you **must await**. This is either done\n by calling `Task.await/2` or `Task.yield/2` followed by\n `Task.shutdown/2` on the returned task. Alternatively, if you\n spawn a task inside a `GenServer`, then the `GenServer` will\n automatically await for you and call `c:GenServer.handle_info/2`\n with the task response and associated `:DOWN` message.\n\n Read the `Task` module documentation for more information about\n the general usage of async tasks.\n\n ## Linking\n\n This function spawns a process that is linked to and monitored\n by the caller process. The linking part is important because it\n aborts the task if the parent process dies. It also guarantees\n the code before async/await has the same properties after you\n add the async call. For example, imagine you have this:\n\n x = heavy_function()\n y = some_function()\n x + y\n\n Now you want to make the `heavy_function()` async:\n\n x = Task.async(&heavy_function/0)\n y = some_function()\n Task.await(x) + y\n\n As before, if `heavy_function/0` fails, the whole computation will\n fail, including the caller process. If you don't want the task\n to fail then you must change the `heavy_fun/0` code in the\n same way you would achieve it if you didn't have the async call.\n For example, to either return `{:ok, val} | :error` results or,\n in more extreme cases, by using `try/rescue`. In other words,\n an asynchronous task should be thought of as an extension of the\n caller process rather than a mechanism to isolate it from all errors.\n\n If you don't want to link the caller to the task, then you\n must use a supervised task with `Task.Supervisor` and call\n `Task.Supervisor.async_nolink/2`.\n\n In any case, avoid any of the following:\n\n * Setting `:trap_exit` to `true` - trapping exits should be\n used only in special circumstances as it would make your\n process immune to not only exits from the task but from\n any other processes.\n\n Moreover, even when trapping exits, calling `await` will\n still exit if the task has terminated without sending its\n result back.\n\n * Unlinking the task process started with `async`/`await`.\n If you unlink the processes and the task does not belong\n to any supervisor, you may leave dangling tasks in case\n the caller process dies.\n\n ## Metadata\n\n The task created with this function stores `:erlang.apply/2` in\n its `:mfa` metadata field, which is used internally to apply\n the anonymous function. Use `async/3` if you want another function\n to be used as metadata.\n \"\"\"\n @spec async((-> any)) :: t\n def async(fun) when is_function(fun, 0) do\n async(:erlang, :apply, [fun, []])\n end\n\n @doc \"\"\"\n Starts a task that must be awaited on.\n\n Similar to `async/1` except the function to be started is\n specified by the given `module`, `function_name`, and `args`.\n The `module`, `function_name`, and its arity are stored as\n a tuple in the `:mfa` field for reflection purposes.\n \"\"\"\n @spec async(module, atom, [term]) :: t\n def async(module, function_name, args)\n when is_atom(module) and is_atom(function_name) and is_list(args) do\n mfargs = {module, function_name, args}\n owner = self()\n # No need to monitor because the processes are linked\n {:ok, pid} = Task.Supervised.start_link(get_owner(owner), :nomonitor)\n\n alias = build_alias(pid)\n send(pid, {owner, alias, alias, get_callers(owner), mfargs})\n %Task{pid: pid, ref: alias, owner: owner, mfa: {module, function_name, length(args)}}\n end\n\n @doc \"\"\"\n Starts a task that immediately completes with the given `result`.\n\n Unlike `async/1`, this task does not spawn a linked process. It can\n be awaited or yielded like any other task.\n\n ## Usage\n\n In some cases, it is useful to create a \"completed\" task that represents\n a task that has already run and generated a result. For example, when\n processing data you may be able to determine that certain inputs are\n invalid before dispatching them for further processing:\n\n def process(data) do\n tasks =\n for entry <- data do\n if invalid_input?(entry) do\n Task.completed({:error, :invalid_input})\n else\n Task.async(fn -> further_process(entry) end)\n end\n end\n\n Task.await_many(tasks)\n end\n\n In many cases, `Task.completed/1` may be avoided in favor of returning the\n result directly. You should generally only require this variant when working\n with mixed asynchrony, when a group of inputs will be handled partially\n synchronously and partially asynchronously.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec completed(any) :: t\n def completed(result) do\n ref = make_ref()\n owner = self()\n\n # \"complete\" the task immediately\n send(owner, {ref, result})\n\n %Task{pid: nil, ref: ref, owner: owner, mfa: {Task, :completed, 1}}\n end\n\n @doc \"\"\"\n Returns a stream where the given function (`module` and `function_name`)\n is mapped concurrently on each element in `enumerable`.\n\n Each element of `enumerable` will be prepended to the given `args` and\n processed by its own task. Those tasks will be linked to an intermediate\n process that is then linked to the caller process. This means a failure\n in a task terminates the caller process and a failure in the caller\n process terminates all tasks.\n\n When streamed, each task will emit `{:ok, value}` upon successful\n completion or `{:exit, reason}` if the caller is trapping exits.\n It's possible to have `{:exit, {element, reason}}` for exits\n using the `:zip_input_on_exit` option. The order of results depends\n on the value of the `:ordered` option.\n\n The level of concurrency and the time tasks are allowed to run can\n be controlled via options (see the \"Options\" section below).\n\n Consider using `Task.Supervisor.async_stream/6` to start tasks\n under a supervisor. If you find yourself trapping exits to ensure\n errors in the tasks do not terminate the caller process, consider\n using `Task.Supervisor.async_stream_nolink/6` to start tasks that\n are not linked to the caller process.\n\n ## Options\n\n * `:max_concurrency` - sets the maximum number of tasks to run\n at the same time. Defaults to `System.schedulers_online/0`.\n\n * `:ordered` - whether the results should be returned in the same order\n as the input stream. When the output is ordered, Elixir may need to\n buffer results to emit them in the original order. Setting this option\n to false disables the need to buffer at the cost of removing ordering.\n This is also useful when you're using the tasks only for the side effects.\n Note that regardless of what `:ordered` is set to, the tasks will\n process asynchronously. If you need to process elements in order,\n consider using `Enum.map/2` or `Enum.each/2` instead. Defaults to `true`.\n\n * `:timeout` - the maximum amount of time (in milliseconds or `:infinity`)\n each task is allowed to execute for. Defaults to `5000`.\n\n * `:on_timeout` - what to do when a task times out. The possible\n values are:\n * `:exit` (default) - the caller (the process that spawned the tasks) exits.\n * `:kill_task` - the task that timed out is killed. The value\n emitted for that task is `{:exit, :timeout}`.\n\n * `:zip_input_on_exit` - (since v1.14.0) adds the original\n input to `:exit` tuples. The value emitted for that task is\n `{:exit, {input, reason}}`, where `input` is the collection element\n that caused an exit during processing. Defaults to `false`.\n\n ## Example\n\n Let's build a stream and then enumerate it:\n\n stream = Task.async_stream(collection, Mod, :expensive_fun, [])\n Enum.to_list(stream)\n\n The concurrency can be increased or decreased using the `:max_concurrency`\n option. For example, if the tasks are IO heavy, the value can be increased:\n\n max_concurrency = System.schedulers_online() * 2\n stream = Task.async_stream(collection, Mod, :expensive_fun, [], max_concurrency: max_concurrency)\n Enum.to_list(stream)\n\n If you do not care about the results of the computation, you can run\n the stream with `Stream.run/1`. Also set `ordered: false`, as you don't\n care about the order of the results either:\n\n stream = Task.async_stream(collection, Mod, :expensive_fun, [], ordered: false)\n Stream.run(stream)\n\n ## First async tasks to complete\n\n You can also use `async_stream/3` to execute M tasks and find the N tasks\n to complete. For example:\n\n [\n &heavy_call_1/0,\n &heavy_call_2/0,\n &heavy_call_3/0\n ]\n |> Task.async_stream(fn fun -> fun.() end, ordered: false, max_concurrency: 3)\n |> Stream.filter(&match?({:ok, _}, &1))\n |> Enum.take(2)\n\n In the example above, we are executing three tasks and waiting for the\n first 2 to complete. We use `Stream.filter/2` to restrict ourselves only\n to successfully completed tasks, and then use `Enum.take/2` to retrieve\n N items. Note it is important to set both `ordered: false` and\n `max_concurrency: M`, where M is the number of tasks, to make sure all\n calls execute concurrently.\n\n ### Attention: unbound async + take\n\n If you want to potentially process a high number of items and keep only\n part of the results, you may end-up processing more items than desired.\n Let's see an example:\n\n 1..100\n |> Task.async_stream(fn i ->\n Process.sleep(100)\n IO.puts(to_string(i))\n end)\n |> Enum.take(10)\n\n Running the example above in a machine with 8 cores will process 16 items,\n even though you want only 10 elements, since `async_stream/3` process items\n concurrently. That's because it will process 8 elements at once. Then all 8\n elements complete at roughly the same time, causing 8 elements to be kicked\n off for processing. Out of these extra 8, only 2 will be used, and the rest\n will be terminated.\n\n Depending on the problem, you can filter or limit the number of elements\n upfront:\n\n 1..100\n |> Stream.take(10)\n |> Task.async_stream(fn i ->\n Process.sleep(100)\n IO.puts(to_string(i))\n end)\n |> Enum.to_list()\n\n In other cases, you likely want to tweak `:max_concurrency` to limit how\n many elements may be over processed at the cost of reducing concurrency.\n You can also set the number of elements to take to be a multiple of\n `:max_concurrency`. For instance, setting `max_concurrency: 5` in the\n example above.\n \"\"\"\n @doc since: \"1.4.0\"\n @spec async_stream(Enumerable.t(), module, atom, [term], [async_stream_option]) ::\n Enumerable.t()\n def async_stream(enumerable, module, function_name, args, options \\\\ [])\n when is_atom(module) and is_atom(function_name) and is_list(args) do\n build_stream(enumerable, {module, function_name, args}, options)\n end\n\n @doc \"\"\"\n Returns a stream that runs the given function `fun` concurrently\n on each element in `enumerable`.\n\n Works the same as `async_stream/5` but with an anonymous function instead of a\n module-function-arguments tuple. `fun` must be a one-arity anonymous function.\n\n Each `enumerable` element is passed as argument to the given function `fun` and\n processed by its own task. The tasks will be linked to the caller process, similarly\n to `async/1`.\n\n ## Example\n\n Count the code points in each string asynchronously, then add the counts together using reduce.\n\n iex> strings = [\"long string\", \"longer string\", \"there are many of these\"]\n iex> stream = Task.async_stream(strings, fn text -> text |> String.codepoints() |> Enum.count() end)\n iex> Enum.sum_by(stream, fn {:ok, num} -> num end)\n 47\n\n See `async_stream/5` for discussion, options, and more examples.\n \"\"\"\n @doc since: \"1.4.0\"\n @spec async_stream(Enumerable.t(), (term -> term), [async_stream_option]) :: Enumerable.t()\n def async_stream(enumerable, fun, options \\\\ [])\n when is_function(fun, 1) and is_list(options) do\n build_stream(enumerable, fun, options)\n end\n\n defp build_stream(enumerable, fun, options) do\n options = Task.Supervised.validate_stream_options(options)\n\n fn acc, acc_fun ->\n owner = get_owner(self())\n\n Task.Supervised.stream(enumerable, acc, acc_fun, get_callers(self()), fun, options, fn ->\n # No need to monitor because the processes are linked\n {:ok, pid} = Task.Supervised.start_link(owner, :nomonitor)\n {:ok, :link, pid}\n end)\n end\n end\n\n # Returns a tuple with the node where this is executed and either the\n # registered name of the given PID or the PID of where this is executed. Used\n # when exiting from tasks to print out from where the task was started.\n defp get_owner(pid) do\n self_or_name =\n case Process.info(pid, :registered_name) do\n {:registered_name, name} when is_atom(name) -> name\n _ -> pid\n end\n\n {node(), self_or_name, pid}\n end\n\n defp get_callers(owner) do\n case :erlang.get(:\"$callers\") do\n [_ | _] = list -> [owner | list]\n _ -> [owner]\n end\n end\n\n @doc ~S\"\"\"\n Awaits a task reply and returns it.\n\n In case the task process dies, the caller process will exit with the same\n reason as the task.\n\n A timeout, in milliseconds or `:infinity`, can be given with a default value\n of `5000`. If the timeout is exceeded, then the caller process will exit.\n If the task process is linked to the caller process which is the case when\n a task is started with `async`, then the task process will also exit. If the\n task process is trapping exits or not linked to the caller process, then it\n will continue to run.\n\n This function assumes the task's monitor is still active or the monitor's\n `:DOWN` message is in the message queue. If it has been demonitored, or the\n message already received, this function will wait for the duration of the\n timeout awaiting the message.\n\n This function can only be called once for any given task. If you want\n to be able to check multiple times if a long-running task has finished\n its computation, use `yield/2` instead.\n\n ## Examples\n\n iex> task = Task.async(fn -> 1 + 1 end)\n iex> Task.await(task)\n 2\n\n ## Compatibility with OTP behaviours\n\n It is not recommended to `await` a long-running task inside an OTP\n behaviour such as `GenServer`. Instead, you should match on the message\n coming from a task inside your `c:GenServer.handle_info/2` callback.\n\n A GenServer will receive two messages on `handle_info/2`:\n\n * `{ref, result}` - the reply message where `ref` is the monitor\n reference returned by the `task.ref` and `result` is the task\n result\n\n * `{:DOWN, ref, :process, pid, reason}` - since all tasks are also\n monitored, you will also receive the `:DOWN` message delivered by\n `Process.monitor/1`. If you receive the `:DOWN` message without a\n a reply, it means the task crashed\n\n Another consideration to have in mind is that tasks started by `Task.async/1`\n are always linked to their callers and you may not want the GenServer to\n crash if the task crashes. Therefore, it is preferable to instead use\n `Task.Supervisor.async_nolink/3` inside OTP behaviours. For completeness, here\n is an example of a GenServer that start tasks and handles their results:\n\n defmodule GenServerTaskExample do\n use GenServer\n\n def start_link(opts) do\n GenServer.start_link(__MODULE__, :ok, opts)\n end\n\n def init(_opts) do\n # We will keep all running tasks in a map\n {:ok, %{tasks: %{}}}\n end\n\n # Imagine we invoke a task from the GenServer to access a URL...\n def handle_call(:some_message, _from, state) do\n url = ...\n task = Task.Supervisor.async_nolink(MyApp.TaskSupervisor, fn -> fetch_url(url) end)\n\n # After we start the task, we store its reference and the url it is fetching\n state = put_in(state.tasks[task.ref], url)\n\n {:reply, :ok, state}\n end\n\n # If the task succeeds...\n def handle_info({ref, result}, state) do\n # The task succeed so we can demonitor its reference\n Process.demonitor(ref, [:flush])\n\n {url, state} = pop_in(state.tasks[ref])\n IO.puts(\"Got #{inspect(result)} for URL #{inspect url}\")\n {:noreply, state}\n end\n\n # If the task fails...\n def handle_info({:DOWN, ref, _, _, reason}, state) do\n {url, state} = pop_in(state.tasks[ref])\n IO.puts(\"URL #{inspect url} failed with reason #{inspect(reason)}\")\n {:noreply, state}\n end\n end\n\n With the server defined, you will want to start the task supervisor\n above and the GenServer in your supervision tree:\n\n children = [\n {Task.Supervisor, name: MyApp.TaskSupervisor},\n {GenServerTaskExample, name: MyApp.GenServerTaskExample}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n\n \"\"\"\n @spec await(t, timeout) :: term\n def await(%Task{ref: ref, owner: owner} = task, timeout \\\\ 5000) when is_timeout(timeout) do\n if owner != self() do\n raise ArgumentError, invalid_owner_error(task)\n end\n\n await_receive(ref, task, timeout)\n end\n\n defp await_receive(ref, task, timeout) do\n receive do\n {^ref, reply} ->\n demonitor(ref)\n reply\n\n {:DOWN, ^ref, _, proc, reason} ->\n exit({reason(reason, proc), {__MODULE__, :await, [task, timeout]}})\n after\n timeout ->\n demonitor(ref)\n exit({:timeout, {__MODULE__, :await, [task, timeout]}})\n end\n end\n\n @doc \"\"\"\n Ignores an existing task.\n\n This means the task will continue running, but it will be unlinked\n and you can no longer yield, await or shut it down.\n\n Returns `{:ok, reply}` if the reply is received before ignoring the task,\n `{:exit, reason}` if the task died before ignoring it, otherwise `nil`.\n\n Important: avoid using [`Task.async/1,3`](`async/1`) and then immediately ignoring\n the task. If you want to start tasks you don't care about their\n results, use `Task.Supervisor.start_child/2` instead.\n \"\"\"\n @doc since: \"1.13.0\"\n @spec ignore(t) :: {:ok, term} | {:exit, term} | nil\n def ignore(%Task{ref: ref, pid: pid, owner: owner} = task) do\n if owner != self() do\n raise ArgumentError, invalid_owner_error(task)\n end\n\n ignore_receive(ref, pid, task)\n end\n\n defp ignore_receive(ref, pid, task) do\n receive do\n {^ref, reply} ->\n pid && Process.unlink(pid)\n demonitor(ref)\n {:ok, reply}\n\n {:DOWN, ^ref, _, proc, :noconnection} ->\n exit({reason(:noconnection, proc), {__MODULE__, :ignore, [task]}})\n\n {:DOWN, ^ref, _, _, reason} ->\n {:exit, reason}\n after\n 0 ->\n pid && Process.unlink(pid)\n demonitor(ref)\n nil\n end\n end\n\n @doc \"\"\"\n Awaits replies from multiple tasks and returns them.\n\n This function receives a list of tasks and waits for their replies in the\n given time interval. It returns a list of the results, in the same order as\n the tasks supplied in the `tasks` input argument.\n\n If any of the task processes dies, the caller process will exit with the same\n reason as that task.\n\n A timeout, in milliseconds or `:infinity`, can be given with a default value\n of `5000`. If the timeout is exceeded, then the caller process will exit.\n Any task processes that are linked to the caller process (which is the case\n when a task is started with `async`) will also exit. Any task processes that\n are trapping exits or not linked to the caller process will continue to run.\n\n This function assumes the tasks' monitors are still active or the monitor's\n `:DOWN` message is in the message queue. If any tasks have been demonitored,\n or the message already received, this function will wait for the duration of\n the timeout.\n\n This function can only be called once for any given task. If you want to be\n able to check multiple times if a long-running task has finished its\n computation, use `yield_many/2` instead.\n\n ## Compatibility with OTP behaviours\n\n It is not recommended to `await` long-running tasks inside an OTP behaviour\n such as `GenServer`. See `await/2` for more information.\n\n ## Examples\n\n iex> tasks = [\n ...> Task.async(fn -> 1 + 1 end),\n ...> Task.async(fn -> 2 + 3 end)\n ...> ]\n iex> Task.await_many(tasks)\n [2, 5]\n\n \"\"\"\n @doc since: \"1.11.0\"\n @spec await_many([t], timeout) :: [term]\n def await_many(tasks, timeout \\\\ 5000) when is_timeout(timeout) do\n awaiting =\n Map.new(tasks, fn %Task{ref: ref, owner: owner} = task ->\n if owner != self() do\n raise ArgumentError, invalid_owner_error(task)\n end\n\n {ref, true}\n end)\n\n timeout_ref = make_ref()\n\n timer_ref =\n if timeout != :infinity do\n Process.send_after(self(), timeout_ref, timeout)\n end\n\n try do\n await_many(tasks, timeout, awaiting, %{}, timeout_ref)\n after\n timer_ref && Process.cancel_timer(timer_ref)\n receive do: (^timeout_ref -> :ok), after: (0 -> :ok)\n end\n end\n\n defp await_many(tasks, _timeout, awaiting, replies, _timeout_ref)\n when map_size(awaiting) == 0 do\n for %{ref: ref} <- tasks, do: Map.fetch!(replies, ref)\n end\n\n defp await_many(tasks, timeout, awaiting, replies, timeout_ref) do\n receive do\n ^timeout_ref ->\n demonitor_pending_tasks(awaiting)\n exit({:timeout, {__MODULE__, :await_many, [tasks, timeout]}})\n\n {:DOWN, ref, _, proc, reason} when is_map_key(awaiting, ref) ->\n demonitor_pending_tasks(awaiting)\n exit({reason(reason, proc), {__MODULE__, :await_many, [tasks, timeout]}})\n\n {ref, reply} when is_map_key(awaiting, ref) ->\n demonitor(ref)\n\n await_many(\n tasks,\n timeout,\n Map.delete(awaiting, ref),\n Map.put(replies, ref, reply),\n timeout_ref\n )\n end\n end\n\n defp demonitor_pending_tasks(awaiting) do\n Enum.each(awaiting, fn {ref, _} ->\n demonitor(ref)\n end)\n end\n\n @doc false\n @deprecated \"Pattern match directly on the message instead\"\n def find(tasks, {ref, reply}) when is_reference(ref) do\n Enum.find_value(tasks, fn\n %Task{ref: ^ref} = task ->\n demonitor(ref)\n {reply, task}\n\n %Task{} ->\n nil\n end)\n end\n\n def find(tasks, {:DOWN, ref, _, proc, reason} = msg) when is_reference(ref) do\n find = fn %Task{ref: task_ref} -> task_ref == ref end\n\n if Enum.find(tasks, find) do\n exit({reason(reason, proc), {__MODULE__, :find, [tasks, msg]}})\n end\n end\n\n def find(_tasks, _msg) do\n nil\n end\n\n @doc ~S\"\"\"\n Temporarily blocks the caller process waiting for a task reply.\n\n Returns `{:ok, reply}` if the reply is received, `nil` if\n no reply has arrived, or `{:exit, reason}` if the task has already\n exited. Keep in mind that normally a task failure also causes\n the process owning the task to exit. Therefore this function can\n return `{:exit, reason}` if at least one of the conditions below apply:\n\n * the task process exited with the reason `:normal`\n * the task isn't linked to the caller (the task was started\n with `Task.Supervisor.async_nolink/2` or `Task.Supervisor.async_nolink/4`)\n * the caller is trapping exits\n\n A timeout, in milliseconds or `:infinity`, can be given with a default value\n of `5000`. If the time runs out before a message from the task is received,\n this function will return `nil` and the monitor will remain active. Therefore\n `yield/2` can be called multiple times on the same task.\n\n This function assumes the task's monitor is still active or the\n monitor's `:DOWN` message is in the message queue. If it has been\n demonitored or the message already received, this function will wait\n for the duration of the timeout awaiting the message.\n\n If you intend to shut the task down if it has not responded within `timeout`\n milliseconds, you should chain this together with `shutdown/1`, like so:\n\n case Task.yield(task, timeout) || Task.shutdown(task) do\n {:ok, result} ->\n result\n\n nil ->\n Logger.warning(\"Failed to get a result in #{timeout}ms\")\n nil\n end\n\n If you intend to check on the task but leave it running after the timeout,\n you can chain this together with `ignore/1`, like so:\n\n case Task.yield(task, timeout) || Task.ignore(task) do\n {:ok, result} ->\n result\n\n nil ->\n Logger.warning(\"Failed to get a result in #{timeout}ms\")\n nil\n end\n\n That ensures that if the task completes after the `timeout` but before `shutdown/1`\n has been called, you will still get the result, since `shutdown/1` is designed to\n handle this case and return the result.\n \"\"\"\n @spec yield(t, timeout) :: {:ok, term} | {:exit, term} | nil\n def yield(%Task{ref: ref, owner: owner} = task, timeout \\\\ 5000) when is_timeout(timeout) do\n if owner != self() do\n raise ArgumentError, invalid_owner_error(task)\n end\n\n yield_receive(ref, task, timeout)\n end\n\n defp yield_receive(ref, task, timeout) do\n receive do\n {^ref, reply} ->\n demonitor(ref)\n {:ok, reply}\n\n {:DOWN, ^ref, _, proc, :noconnection} ->\n exit({reason(:noconnection, proc), {__MODULE__, :yield, [task, timeout]}})\n\n {:DOWN, ^ref, _, _, reason} ->\n {:exit, reason}\n after\n timeout ->\n nil\n end\n end\n\n @doc \"\"\"\n Yields to multiple tasks in the given time interval.\n\n This function receives a list of tasks and waits for their\n replies in the given time interval. It returns a list\n of two-element tuples, with the task as the first element\n and the yielded result as the second. The tasks in the returned\n list will be in the same order as the tasks supplied in the `tasks`\n input argument.\n\n Similarly to `yield/2`, each task's result will be\n\n * `{:ok, term}` if the task has successfully reported its\n result back in the given time interval\n * `{:exit, reason}` if the task has died\n * `nil` if the task keeps running, either because a limit\n has been reached or past the timeout\n\n Check `yield/2` for more information.\n\n ## Example\n\n `Task.yield_many/2` allows developers to spawn multiple tasks\n and retrieve the results received in a given time frame.\n If we combine it with `Task.shutdown/2` (or `Task.ignore/1`),\n it allows us to gather those results and cancel (or ignore)\n the tasks that have not replied in time.\n\n Let's see an example.\n\n tasks =\n for i <- 1..10 do\n Task.async(fn ->\n Process.sleep(i * 1000)\n i\n end)\n end\n\n tasks_with_results = Task.yield_many(tasks, timeout: 5000)\n\n results =\n Enum.map(tasks_with_results, fn {task, res} ->\n # Shut down the tasks that did not reply nor exit\n res || Task.shutdown(task, :brutal_kill)\n end)\n\n # Here we are matching only on {:ok, value} and\n # ignoring {:exit, _} (crashed tasks) and `nil` (no replies)\n for {:ok, value} <- results do\n IO.inspect(value)\n end\n\n In the example above, we create tasks that sleep from 1\n up to 10 seconds and return the number of seconds they slept for.\n If you execute the code all at once, you should see 1 up to 5\n printed, as those were the tasks that have replied in the\n given time. All other tasks will have been shut down using\n the `Task.shutdown/2` call.\n\n As a convenience, you can achieve a similar behavior to above\n by specifying the `:on_timeout` option to be `:kill_task` (or\n `:ignore`). See `Task.await_many/2` if you would rather exit\n the caller process on timeout.\n\n ## Options\n\n The second argument is either a timeout or options, which defaults\n to this:\n\n * `:limit` - the maximum amount of tasks to wait for.\n If the limit is reached before the timeout, this function\n returns immediately without triggering the `:on_timeout` behaviour\n\n * `:timeout` - the maximum amount of time (in milliseconds or `:infinity`)\n each task is allowed to execute for. Defaults to `5000`.\n\n * `:on_timeout` - what to do when a task times out. The possible\n values are:\n * `:nothing` - do nothing (default). The tasks can still be\n awaited on, yielded on, ignored, or shut down later.\n * `:ignore` - the results of the task will be ignored.\n * `:kill_task` - the task that timed out is killed.\n \"\"\"\n @spec yield_many([t], timeout) :: [{t, {:ok, term} | {:exit, term} | nil}]\n @spec yield_many([t],\n limit: pos_integer(),\n timeout: timeout,\n on_timeout: :nothing | :ignore | :kill_task\n ) ::\n [{t, {:ok, term} | {:exit, term} | nil}]\n def yield_many(tasks, opts \\\\ [])\n\n def yield_many(tasks, timeout) when is_timeout(timeout) do\n yield_many(tasks, timeout: timeout)\n end\n\n def yield_many(tasks, opts) when is_list(opts) do\n refs =\n Map.new(tasks, fn %Task{ref: ref, owner: owner} = task ->\n if owner != self() do\n raise ArgumentError, invalid_owner_error(task)\n end\n\n {ref, nil}\n end)\n\n on_timeout = Keyword.get(opts, :on_timeout, :nothing)\n timeout = Keyword.get(opts, :timeout, 5_000)\n limit = Keyword.get(opts, :limit, map_size(refs))\n timeout_ref = make_ref()\n\n timer_ref =\n if timeout != :infinity do\n Process.send_after(self(), timeout_ref, timeout)\n end\n\n try do\n yield_many(limit, refs, timeout_ref, timer_ref)\n catch\n {:noconnection, reason} ->\n exit({reason, {__MODULE__, :yield_many, [tasks, timeout]}})\n else\n {timed_out?, refs} ->\n for task <- tasks do\n value =\n with nil <- Map.fetch!(refs, task.ref) do\n case on_timeout do\n _ when not timed_out? -> nil\n :nothing -> nil\n :kill_task -> shutdown(task, :brutal_kill)\n :ignore -> ignore(task)\n end\n end\n\n {task, value}\n end\n end\n end\n\n defp yield_many(0, refs, timeout_ref, timer_ref) do\n timer_ref && Process.cancel_timer(timer_ref)\n receive do: (^timeout_ref -> :ok), after: (0 -> :ok)\n {false, refs}\n end\n\n defp yield_many(limit, refs, timeout_ref, timer_ref) do\n receive do\n {ref, reply} when is_map_key(refs, ref) ->\n demonitor(ref)\n yield_many(limit - 1, %{refs | ref => {:ok, reply}}, timeout_ref, timer_ref)\n\n {:DOWN, ref, _, proc, reason} when is_map_key(refs, ref) ->\n if reason == :noconnection do\n throw({:noconnection, reason(:noconnection, proc)})\n else\n yield_many(limit - 1, %{refs | ref => {:exit, reason}}, timeout_ref, timer_ref)\n end\n\n ^timeout_ref ->\n {true, refs}\n end\n end\n\n @doc \"\"\"\n Unlinks and shuts down the task, and then checks for a reply.\n\n Returns `{:ok, reply}` if the reply is received while shutting down the task,\n `{:exit, reason}` if the task died, otherwise `nil`. Once shut down,\n you can no longer await or yield it.\n\n The second argument is either a timeout or `:brutal_kill`. In case\n of a timeout, a `:shutdown` exit signal is sent to the task process\n and if it does not exit within the timeout, it is killed. With `:brutal_kill`\n the task is killed straight away. In case the task terminates abnormally\n (possibly killed by another process), this function will exit with the same reason.\n\n It is not required to call this function when terminating the caller, unless\n exiting with reason `:normal` or if the task is trapping exits. If the caller is\n exiting with a reason other than `:normal` and the task is not trapping exits, the\n caller's exit signal will stop the task. The caller can exit with reason\n `:shutdown` to shut down all of its linked processes, including tasks, that\n are not trapping exits without generating any log messages.\n\n If there is no process linked to the task, such as tasks started by\n `Task.completed/1`, we check for a response or error accordingly, but without\n shutting a process down.\n\n If a task's monitor has already been demonitored or received and there is not\n a response waiting in the message queue this function will return\n `{:exit, :noproc}` as the result or exit reason can not be determined.\n \"\"\"\n @spec shutdown(t, timeout | :brutal_kill) :: {:ok, term} | {:exit, term} | nil\n def shutdown(task, shutdown \\\\ 5000)\n\n def shutdown(%Task{pid: nil} = task, _) do\n ignore(task)\n end\n\n def shutdown(%Task{owner: owner} = task, _) when owner != self() do\n raise ArgumentError, invalid_owner_error(task)\n end\n\n def shutdown(%Task{pid: pid, ref: ref} = task, :brutal_kill) do\n mon = build_monitor(pid)\n shutdown_send(pid, :kill)\n\n case shutdown_receive(ref, mon, task, :brutal_kill, :infinity) do\n {:down, proc, :noconnection} ->\n exit({reason(:noconnection, proc), {__MODULE__, :shutdown, [task, :brutal_kill]}})\n\n {:down, _, reason} ->\n {:exit, reason}\n\n result ->\n result\n end\n end\n\n def shutdown(%Task{pid: pid, ref: ref} = task, timeout) when is_timeout(timeout) do\n mon = build_monitor(pid)\n shutdown_send(pid, :shutdown)\n\n case shutdown_receive(ref, mon, task, :shutdown, timeout) do\n {:down, proc, :noconnection} ->\n exit({reason(:noconnection, proc), {__MODULE__, :shutdown, [task, timeout]}})\n\n {:down, _, reason} ->\n {:exit, reason}\n\n result ->\n result\n end\n end\n\n # Spawn a process to ensure task gets exit signal\n # if process dies from exit signal between unlink and exit.\n defp shutdown_send(pid, reason) do\n caller = self()\n ref = make_ref()\n enforcer = spawn(fn -> shutdown_send(pid, reason, caller, ref) end)\n Process.unlink(pid)\n Process.exit(pid, reason)\n send(enforcer, {:done, ref})\n :ok\n end\n\n defp shutdown_send(pid, reason, caller, ref) do\n mon = Process.monitor(caller)\n\n receive do\n {:done, ^ref} -> :ok\n {:DOWN, ^mon, _, _, _} -> Process.exit(pid, reason)\n end\n end\n\n defp shutdown_receive(ref, mon, task, type, timeout) do\n receive do\n {:DOWN, ^mon, _, _, :shutdown} when type in [:shutdown, :timeout_kill] ->\n demonitor(ref)\n flush_reply(ref)\n\n {:DOWN, ^mon, _, _, :killed} when type == :brutal_kill ->\n demonitor(ref)\n flush_reply(ref)\n\n {:DOWN, ^mon, _, proc, :noproc} ->\n reason = flush_noproc(ref, proc, type)\n flush_reply(ref) || reason\n\n {:DOWN, ^mon, _, proc, reason} ->\n demonitor(ref)\n flush_reply(ref) || {:down, proc, reason}\n after\n timeout ->\n Process.exit(task.pid, :kill)\n shutdown_receive(ref, mon, task, :timeout_kill, :infinity)\n end\n end\n\n defp flush_reply(ref) do\n receive do\n {^ref, reply} -> {:ok, reply}\n after\n 0 -> nil\n end\n end\n\n defp flush_noproc(ref, proc, type) do\n receive do\n {:DOWN, ^ref, _, _, :shutdown} when type in [:shutdown, :timeout_kill] ->\n nil\n\n {:DOWN, ^ref, _, _, :killed} when type == :brutal_kill ->\n nil\n\n {:DOWN, ^ref, _, _, reason} ->\n {:down, proc, reason}\n after\n 0 ->\n demonitor(ref)\n {:down, proc, :noproc}\n end\n end\n\n # exported only to avoid dialyzer opaqueness check in internal Task modules\n @doc false\n @spec __alias__(pid()) :: Task.ref()\n def __alias__(pid) do\n build_alias(pid)\n end\n\n ## Optimizations\n\n defp build_monitor(pid) do\n :erlang.monitor(:process, pid)\n end\n\n defp build_alias(pid) do\n :erlang.monitor(:process, pid, alias: :demonitor)\n end\n\n @doc false\n # This instructs the Erlang compiler to apply selective\n # receive optimizations to several functions in this module.\n # This function is never invoked directly, it is only here\n # for compiler optimization purposes.\n #\n # To verify which functions have been optimized, run the\n # following command after Elixir is compiled from the project\n # root:\n #\n # ERL_COMPILER_OPTIONS=recv_opt_info elixir lib/elixir/lib/task.ex\n #\n def __recv_opt_info__(pid, task) do\n await_receive(build_alias(pid), task, :infinity)\n shutdown_receive(build_alias(pid), build_monitor(pid), task, :shutdown, :infinity)\n yield_receive(build_alias(pid), task, :infinity)\n ignore_receive(build_alias(pid), pid, task)\n end\n\n ## Helpers\n\n defp demonitor(ref) when is_reference(ref) do\n Process.demonitor(ref, [:flush])\n :ok\n end\n\n defp reason(:noconnection, proc), do: {:nodedown, monitor_node(proc)}\n defp reason(reason, _), do: reason\n\n defp monitor_node(pid) when is_pid(pid), do: node(pid)\n defp monitor_node({_, node}), do: node\n\n defp invalid_owner_error(task) do\n \"task #{inspect(task)} must be queried from the owner but was queried from #{inspect(self())}\"\n end\nend\n" }, { "path": "lib/elixir/lib/tuple.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Tuple do\n @moduledoc \"\"\"\n Functions for working with tuples.\n\n Please note the following functions for tuples are found in `Kernel`:\n\n * `elem/2` - accesses a tuple by index\n * `put_elem/3` - inserts a value into a tuple by index\n * `tuple_size/1` - gets the number of elements in a tuple\n\n Tuples are intended as fixed-size containers for multiple elements.\n To manipulate a collection of elements, use a list instead. `Enum`\n functions do not work on tuples.\n\n Tuples are denoted with curly braces:\n\n iex> {}\n {}\n iex> {1, :two, \"three\"}\n {1, :two, \"three\"}\n\n A tuple may contain elements of different types, which are stored\n contiguously in memory. Accessing any element takes constant time,\n but modifying a tuple, which produces a shallow copy, takes linear time.\n Tuples are good for reading data while lists are better for traversals.\n\n Tuples are typically used either when a function has multiple return values\n or for error handling. `File.read/1` returns `{:ok, contents}` if reading\n the given file is successful, or else `{:error, reason}` such as when\n the file does not exist.\n\n The functions in this module that add and remove elements from tuples are\n rarely used in practice, as they typically imply tuples are being used as\n collections. To append to a tuple, it is preferable to extract the elements\n from the old tuple with pattern matching, and then create a new tuple:\n\n tuple = {:ok, :example}\n\n # Avoid\n result = Tuple.insert_at(tuple, 2, %{})\n\n # Prefer\n {:ok, atom} = tuple\n result = {:ok, atom, %{}}\n\n \"\"\"\n\n @doc \"\"\"\n Creates a new tuple.\n\n Creates a tuple of `size` containing the\n given `data` at every position.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> Tuple.duplicate(:hello, 3)\n {:hello, :hello, :hello}\n\n \"\"\"\n @spec duplicate(term, non_neg_integer) :: tuple\n def duplicate(data, size) when is_integer(size) and size >= 0 do\n :erlang.make_tuple(size, data)\n end\n\n @doc \"\"\"\n Inserts an element into a tuple.\n\n Inserts `value` into `tuple` at the given `index`.\n Raises an `ArgumentError` if `index` is negative or greater than the\n length of `tuple`. Index is zero-based.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> tuple = {:bar, :baz}\n iex> Tuple.insert_at(tuple, 0, :foo)\n {:foo, :bar, :baz}\n iex> Tuple.insert_at(tuple, 2, :bong)\n {:bar, :baz, :bong}\n\n \"\"\"\n @spec insert_at(tuple, non_neg_integer, term) :: tuple\n def insert_at(tuple, index, value) when is_integer(index) and index >= 0 do\n :erlang.insert_element(index + 1, tuple, value)\n end\n\n @doc false\n @deprecated \"Use insert_at instead\"\n def append(tuple, value) do\n :erlang.append_element(tuple, value)\n end\n\n @doc \"\"\"\n Removes an element from a tuple.\n\n Deletes the element at the given `index` from `tuple`.\n Raises an `ArgumentError` if `index` is negative or greater than\n or equal to the length of `tuple`. Index is zero-based.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> tuple = {:foo, :bar, :baz}\n iex> Tuple.delete_at(tuple, 0)\n {:bar, :baz}\n\n \"\"\"\n @spec delete_at(tuple, non_neg_integer) :: tuple\n def delete_at(tuple, index) when is_integer(index) and index >= 0 do\n :erlang.delete_element(index + 1, tuple)\n end\n\n @doc \"\"\"\n Computes a sum of tuple elements.\n\n ## Examples\n\n iex> Tuple.sum({255, 255})\n 510\n iex> Tuple.sum({255, 0.0})\n 255.0\n iex> Tuple.sum({})\n 0\n \"\"\"\n @doc since: \"1.12.0\"\n @spec sum(tuple) :: number()\n def sum(tuple), do: sum(tuple, tuple_size(tuple))\n\n defp sum(_tuple, 0), do: 0\n defp sum(tuple, index), do: :erlang.element(index, tuple) + sum(tuple, index - 1)\n\n @doc \"\"\"\n Computes a product of tuple elements.\n\n ## Examples\n\n iex> Tuple.product({255, 255})\n 65025\n iex> Tuple.product({255, 1.0})\n 255.0\n iex> Tuple.product({})\n 1\n \"\"\"\n @doc since: \"1.12.0\"\n @spec product(tuple) :: number()\n def product(tuple), do: product(tuple, tuple_size(tuple))\n\n defp product(_tuple, 0), do: 1\n defp product(tuple, index), do: :erlang.element(index, tuple) * product(tuple, index - 1)\n\n @doc \"\"\"\n Converts a tuple to a list.\n\n Returns a new list with all the tuple elements.\n\n Inlined by the compiler.\n\n ## Examples\n\n iex> tuple = {:foo, :bar, :baz}\n iex> Tuple.to_list(tuple)\n [:foo, :bar, :baz]\n\n \"\"\"\n @spec to_list(tuple) :: list\n def to_list(tuple) do\n :erlang.tuple_to_list(tuple)\n end\nend\n" }, { "path": "lib/elixir/lib/uri.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule URI do\n @moduledoc \"\"\"\n Utilities for working with URIs.\n\n This module provides functions for working with URIs (for example, parsing\n URIs or encoding query strings). The functions in this module are implemented\n according to [RFC 3986](https://tools.ietf.org/html/rfc3986) and it also\n provides additional functionality for handling \"application/x-www-form-urlencoded\"\n segments.\n\n Additionally, the Erlang [`:uri_string` module](`:uri_string`) provides additional\n functionality such as RFC 3986 compliant URI normalization.\n \"\"\"\n\n @doc \"\"\"\n The URI struct.\n\n The fields are defined to match the following URI representation\n (with field names between brackets):\n\n [scheme]://[userinfo]@[host]:[port][path]?[query]#[fragment]\n\n\n Note the `authority` field is deprecated. `parse/1` will still\n populate it for backwards compatibility but you should generally\n avoid setting or getting it.\n \"\"\"\n @derive {Inspect, optional: [:authority]}\n defstruct [:scheme, :authority, :userinfo, :host, :port, :path, :query, :fragment]\n\n # We don't use opaque because URIs can be inlined,\n # either via module attributes or by the compiler.\n @typedoc deprecated: \"The authority field is deprecated\"\n @type authority :: nil | binary\n\n @type t :: %__MODULE__{\n scheme: nil | binary,\n authority: authority,\n userinfo: nil | binary,\n host: nil | binary,\n port: nil | :inet.port_number(),\n path: nil | binary,\n query: nil | binary,\n fragment: nil | binary\n }\n\n defmodule Error do\n @moduledoc \"\"\"\n An exception raised when an error occurs when a `URI` is invalid.\n\n For example, see `URI.new!/1`.\n \"\"\"\n\n defexception [:action, :reason, :part]\n\n @doc false\n def message(%Error{action: action, reason: reason, part: part}) do\n \"cannot #{action} due to reason #{reason}: #{inspect(part)}\"\n end\n end\n\n import Bitwise\n\n @reserved_characters ~c\":/?#[]@!$&'()*+,;=\"\n @formatted_reserved_characters Enum.map_join(@reserved_characters, \", \", &<>)\n\n @doc \"\"\"\n Returns the default port for a given `scheme`.\n\n If the scheme is unknown to the `URI` module, this function returns\n `nil`. The default port for any scheme can be configured globally\n via `default_port/2`.\n\n ## Examples\n\n iex> URI.default_port(\"ftp\")\n 21\n\n iex> URI.default_port(\"ponzi\")\n nil\n\n \"\"\"\n @spec default_port(binary) :: nil | non_neg_integer\n def default_port(scheme) when is_binary(scheme) do\n :elixir_config.get({:uri, scheme}, nil)\n end\n\n @doc \"\"\"\n Registers the default `port` for the given `scheme`.\n\n After this function is called, `port` will be returned by\n `default_port/1` for the given scheme `scheme`. Note that this function\n changes the default port for the given `scheme` *globally*, meaning for\n every application.\n\n It is recommended for this function to be invoked in your\n application's start callback in case you want to register\n new URIs.\n \"\"\"\n @spec default_port(binary, non_neg_integer) :: :ok\n def default_port(scheme, port) when is_binary(scheme) and is_integer(port) and port >= 0 do\n :elixir_config.put({:uri, scheme}, port)\n end\n\n @doc \"\"\"\n Encodes `enumerable` into a query string using `encoding`.\n\n Takes an enumerable that enumerates as a list of two-element\n tuples (for instance, a map or a keyword list) and returns a string\n in the form of `key1=value1&key2=value2...`.\n\n Keys and values can be any term that implements the `String.Chars`\n protocol with the exception of lists, which are explicitly forbidden.\n\n You can specify one of the following `encoding` strategies:\n\n * `:www_form` - (default, since v1.12.0) keys and values are URL encoded as\n per `encode_www_form/1`. This is the format typically used by browsers on\n query strings and form data. It encodes \" \" as \"+\".\n\n * `:rfc3986` - (since v1.12.0) the same as `:www_form` except it encodes\n \" \" as \"%20\" according [RFC 3986](https://tools.ietf.org/html/rfc3986).\n This is the best option if you are encoding in a non-browser situation,\n since encoding spaces as \"+\" can be ambiguous to URI parsers. This can\n inadvertently lead to spaces being interpreted as literal plus signs.\n\n Encoding defaults to `:www_form` for backward compatibility.\n\n ## Examples\n\n iex> query = %{\"foo\" => 1, \"bar\" => 2}\n iex> URI.encode_query(query)\n \"bar=2&foo=1\"\n\n iex> query = %{\"key\" => \"value with spaces\"}\n iex> URI.encode_query(query)\n \"key=value+with+spaces\"\n\n iex> query = %{\"key\" => \"value with spaces\"}\n iex> URI.encode_query(query, :rfc3986)\n \"key=value%20with%20spaces\"\n\n iex> URI.encode_query(%{key: [:a, :list]})\n ** (ArgumentError) encode_query/2 values cannot be lists, got: [:a, :list]\n\n \"\"\"\n @spec encode_query(Enumerable.t(), :rfc3986 | :www_form) :: binary\n def encode_query(enumerable, encoding \\\\ :www_form) do\n Enum.map_join(enumerable, \"&\", &encode_kv_pair(&1, encoding))\n end\n\n defp encode_kv_pair({key, _}, _encoding) when is_list(key) do\n raise ArgumentError, \"encode_query/2 keys cannot be lists, got: #{inspect(key)}\"\n end\n\n defp encode_kv_pair({_, value}, _encoding) when is_list(value) do\n raise ArgumentError, \"encode_query/2 values cannot be lists, got: #{inspect(value)}\"\n end\n\n defp encode_kv_pair({key, value}, :rfc3986) do\n encode(Kernel.to_string(key), &char_unreserved?/1) <>\n \"=\" <> encode(Kernel.to_string(value), &char_unreserved?/1)\n end\n\n defp encode_kv_pair({key, value}, :www_form) do\n encode_www_form(Kernel.to_string(key)) <> \"=\" <> encode_www_form(Kernel.to_string(value))\n end\n\n @doc \"\"\"\n Decodes `query` into a map.\n\n Given a query string in the form of `key1=value1&key2=value2...`, this\n function inserts each key-value pair in the query string as one entry in the\n given `map`. Keys and values in the resulting map will be binaries. Keys and\n values will be percent-unescaped.\n\n You can specify one of the following `encoding` options:\n\n * `:www_form` - (default, since v1.12.0) keys and values are decoded as per\n `decode_www_form/1`. This is the format typically used by browsers on\n query strings and form data. It decodes \"+\" as \" \".\n\n * `:rfc3986` - (since v1.12.0) keys and values are decoded as per\n `decode/1`. The result is the same as `:www_form` except for leaving \"+\"\n as is in line with [RFC 3986](https://tools.ietf.org/html/rfc3986).\n\n Encoding defaults to `:www_form` for backward compatibility.\n\n Use `query_decoder/1` if you want to iterate over each value manually.\n\n ## Examples\n\n iex> URI.decode_query(\"foo=1&bar=2\")\n %{\"bar\" => \"2\", \"foo\" => \"1\"}\n\n iex> URI.decode_query(\"percent=oh+yes%21\", %{\"starting\" => \"map\"})\n %{\"percent\" => \"oh yes!\", \"starting\" => \"map\"}\n\n iex> URI.decode_query(\"percent=oh+yes%21\", %{}, :rfc3986)\n %{\"percent\" => \"oh+yes!\"}\n\n \"\"\"\n @spec decode_query(binary, %{optional(binary) => binary}, :rfc3986 | :www_form) :: %{\n optional(binary) => binary\n }\n def decode_query(query, map \\\\ %{}, encoding \\\\ :www_form)\n\n def decode_query(query, %_{} = dict, encoding) when is_binary(query) do\n IO.warn(\n \"URI.decode_query/3 expects the second argument to be a map, other usage is deprecated\"\n )\n\n decode_query_into_dict(query, dict, encoding)\n end\n\n def decode_query(query, map, encoding) when is_binary(query) and is_map(map) do\n decode_query_into_map(query, map, encoding)\n end\n\n def decode_query(query, dict, encoding) when is_binary(query) do\n IO.warn(\n \"URI.decode_query/3 expects the second argument to be a map, other usage is deprecated\"\n )\n\n decode_query_into_dict(query, dict, encoding)\n end\n\n defp decode_query_into_map(query, map, encoding) do\n case decode_next_query_pair(query, encoding) do\n nil ->\n map\n\n {{key, value}, rest} ->\n decode_query_into_map(rest, Map.put(map, key, value), encoding)\n end\n end\n\n defp decode_query_into_dict(query, dict, encoding) do\n case decode_next_query_pair(query, encoding) do\n nil ->\n dict\n\n {{key, value}, rest} ->\n # Avoid warnings about Dict being deprecated\n dict_module = String.to_atom(\"Dict\")\n decode_query_into_dict(rest, dict_module.put(dict, key, value), encoding)\n end\n end\n\n @doc \"\"\"\n Returns a stream of two-element tuples representing key-value pairs in the\n given `query`.\n\n Key and value in each tuple will be binaries and will be percent-unescaped.\n\n You can specify one of the following `encoding` options:\n\n * `:www_form` - (default, since v1.12.0) keys and values are decoded as per\n `decode_www_form/1`. This is the format typically used by browsers on\n query strings and form data. It decodes \"+\" as \" \".\n\n * `:rfc3986` - (since v1.12.0) keys and values are decoded as per\n `decode/1`. The result is the same as `:www_form` except for leaving \"+\"\n as is in line with [RFC 3986](https://tools.ietf.org/html/rfc3986).\n\n Encoding defaults to `:www_form` for backward compatibility.\n\n ## Examples\n\n iex> URI.query_decoder(\"foo=1&bar=2\") |> Enum.to_list()\n [{\"foo\", \"1\"}, {\"bar\", \"2\"}]\n\n iex> URI.query_decoder(\"food=bread%26butter&drinks=tap%20water+please\") |> Enum.to_list()\n [{\"food\", \"bread&butter\"}, {\"drinks\", \"tap water please\"}]\n\n iex> URI.query_decoder(\"food=bread%26butter&drinks=tap%20water+please\", :rfc3986) |> Enum.to_list()\n [{\"food\", \"bread&butter\"}, {\"drinks\", \"tap water+please\"}]\n\n \"\"\"\n @spec query_decoder(binary, :rfc3986 | :www_form) :: Enumerable.t()\n def query_decoder(query, encoding \\\\ :www_form) when is_binary(query) do\n Stream.unfold(query, &decode_next_query_pair(&1, encoding))\n end\n\n defp decode_next_query_pair(\"\", _encoding) do\n nil\n end\n\n defp decode_next_query_pair(query, encoding) do\n {undecoded_next_pair, rest} =\n case :binary.split(query, \"&\") do\n [next_pair, rest] -> {next_pair, rest}\n [next_pair] -> {next_pair, \"\"}\n end\n\n next_pair =\n case :binary.split(undecoded_next_pair, \"=\") do\n [key, value] ->\n {decode_with_encoding(key, encoding), decode_with_encoding(value, encoding)}\n\n [key] ->\n {decode_with_encoding(key, encoding), \"\"}\n end\n\n {next_pair, rest}\n end\n\n defp decode_with_encoding(string, :www_form) do\n decode_www_form(string)\n end\n\n defp decode_with_encoding(string, :rfc3986) do\n decode(string)\n end\n\n @doc ~s\"\"\"\n Checks if `character` is a reserved one in a URI.\n\n As specified in [RFC 3986, section 2.2](https://tools.ietf.org/html/rfc3986#section-2.2),\n the following characters are reserved: #{@formatted_reserved_characters}\n\n ## Examples\n\n iex> URI.char_reserved?(?+)\n true\n\n \"\"\"\n @spec char_reserved?(byte) :: boolean\n def char_reserved?(character) do\n character in @reserved_characters\n end\n\n @doc \"\"\"\n Checks if `character` is an unreserved one in a URI.\n\n As specified in [RFC 3986, section 2.3](https://tools.ietf.org/html/rfc3986#section-2.3),\n the following characters are unreserved:\n\n * Alphanumeric characters: `A-Z`, `a-z`, `0-9`\n * `~`, `_`, `-`, `.`\n\n ## Examples\n\n iex> URI.char_unreserved?(?_)\n true\n\n \"\"\"\n @spec char_unreserved?(byte) :: boolean\n def char_unreserved?(character) do\n character in ?0..?9 or character in ?a..?z or character in ?A..?Z or character in ~c\"~_-.\"\n end\n\n @doc \"\"\"\n Checks if `character` is allowed unescaped in a URI.\n\n This is the default used by `URI.encode/2` where both\n [reserved](`char_reserved?/1`) and [unreserved characters](`char_unreserved?/1`)\n are kept unescaped.\n\n ## Examples\n\n iex> URI.char_unescaped?(?{)\n false\n\n \"\"\"\n @spec char_unescaped?(byte) :: boolean\n def char_unescaped?(character) do\n char_reserved?(character) or char_unreserved?(character)\n end\n\n @doc \"\"\"\n Percent-encodes all characters that require escaping in `string`.\n\n The optional `predicate` argument specifies a function used to detect whether\n a byte in the `string` should be escaped:\n\n * if the function returns a truthy value, the byte should be kept as-is.\n * if the function returns a falsy value, the byte should be escaped.\n\n The `predicate` argument can use some built-in functions:\n\n * `URI.char_unescaped?/1` (default) - reserved characters (such as `:`\n and `/`) or unreserved (such as letters and numbers) are kept as-is.\n It's typically used to encode the whole URI.\n * `URI.char_unreserved?/1` - unreserved characters (such as letters and\n numbers) are kept as-is. It's typically used to encode components in\n a URI, such as query or fragment.\n * `URI.char_reserved?/1` - Reserved characters (such as `:` and `/`) are\n kept as-is.\n\n And, you can also use custom functions.\n\n See `encode_www_form/1` if you are interested in encoding `string` as\n \"x-www-form-urlencoded\".\n\n ## Examples\n\n iex> URI.encode(\"ftp://s-ite.tld/?value=put it+й\")\n \"ftp://s-ite.tld/?value=put%20it+%D0%B9\"\n\n iex> URI.encode(\"a string\", &(&1 != ?i))\n \"a str%69ng\"\n\n \"\"\"\n @spec encode(binary, (byte -> as_boolean(term))) :: binary\n def encode(string, predicate \\\\ &char_unescaped?/1)\n when is_binary(string) and is_function(predicate, 1) do\n for <>, into: \"\", do: percent(byte, predicate)\n end\n\n @doc \"\"\"\n Encodes `string` as \"x-www-form-urlencoded\".\n\n Note \"x-www-form-urlencoded\" is not specified as part of\n RFC 3986. However, it is a commonly used format to encode\n query strings and form data by browsers.\n\n ## Example\n\n iex> URI.encode_www_form(\"put: it+й\")\n \"put%3A+it%2B%D0%B9\"\n\n \"\"\"\n @spec encode_www_form(binary) :: binary\n def encode_www_form(string) when is_binary(string) do\n for <>, into: \"\" do\n case percent(byte, &char_unreserved?/1) do\n \"%20\" -> \"+\"\n percent -> percent\n end\n end\n end\n\n defp percent(char, predicate) do\n if predicate.(char) do\n <>\n else\n <<\"%\", hex(bsr(char, 4)), hex(band(char, 15))>>\n end\n end\n\n defp hex(n) when n <= 9, do: n + ?0\n defp hex(n), do: n + ?A - 10\n\n @doc \"\"\"\n Percent-unescapes a URI.\n\n ## Examples\n\n iex> URI.decode(\"https%3A%2F%2Felixir-lang.org\")\n \"https://elixir-lang.org\"\n\n \"\"\"\n @spec decode(binary) :: binary\n def decode(uri) do\n unpercent(uri, \"\", false)\n end\n\n @doc \"\"\"\n Decodes `string` as \"x-www-form-urlencoded\".\n\n Note \"x-www-form-urlencoded\" is not specified as part of\n RFC 3986. However, it is a commonly used format to encode\n query strings and form data by browsers.\n\n ## Examples\n\n iex> URI.decode_www_form(\"%3Call+in%2F\")\n \">, acc, spaces = true) do\n unpercent(tail, <>, spaces)\n end\n\n defp unpercent(<>, acc, spaces) do\n with <> <- tail,\n dec1 when is_integer(dec1) <- hex_to_dec(hex1),\n dec2 when is_integer(dec2) <- hex_to_dec(hex2) do\n unpercent(tail, <>, spaces)\n else\n _ -> unpercent(tail, <>, spaces)\n end\n end\n\n defp unpercent(<>, acc, spaces) do\n unpercent(tail, <>, spaces)\n end\n\n defp unpercent(<<>>, acc, _spaces), do: acc\n\n @compile {:inline, hex_to_dec: 1}\n defp hex_to_dec(n) when n in ?A..?F, do: n - ?A + 10\n defp hex_to_dec(n) when n in ?a..?f, do: n - ?a + 10\n defp hex_to_dec(n) when n in ?0..?9, do: n - ?0\n defp hex_to_dec(_n), do: nil\n\n @doc \"\"\"\n Creates a new URI struct by parsing and validating a string or from an existing URI.\n\n If a `%URI{}` struct is given, it returns `{:ok, uri}` as is. If a string is\n given, it will parse and validate it. If the string is valid, it returns\n `{:ok, uri}`, otherwise it returns `{:error, part}` with the invalid part\n of the URI. For parsing URIs without further validation, see `parse/1`.\n\n This function can parse both absolute and relative URLs. You can check\n if a URI is absolute or relative by checking if the `scheme` field is\n `nil` or not.\n\n When a URI is given without a port, the value returned by `URI.default_port/1`\n for the URI's scheme is used for the `:port` field. The scheme is also\n normalized to lowercase.\n\n > #### Browser compatibility {: .warning}\n >\n > This function does not follow the same parsing rules as browsers.\n > Browsers adhere to the WHATWG URL standard, while this function\n > implements RFC 3986. You should expect different behaviours between\n > them and this function will often reject URLs that are accepted by\n > browsers (as they tend to be permissive). Common examples include\n > unencoded square brackets in query strings (such as `foo[bar]=baz`)\n > and backslashes used as path separators.\n\n ## Examples\n\n iex> URI.new(\"https://elixir-lang.org/\")\n {:ok, %URI{\n fragment: nil,\n host: \"elixir-lang.org\",\n path: \"/\",\n port: 443,\n query: nil,\n scheme: \"https\",\n userinfo: nil\n }}\n\n iex> URI.new(\"//elixir-lang.org/\")\n {:ok, %URI{\n fragment: nil,\n host: \"elixir-lang.org\",\n path: \"/\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }}\n\n iex> URI.new(\"/foo/bar\")\n {:ok, %URI{\n fragment: nil,\n host: nil,\n path: \"/foo/bar\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }}\n\n iex> URI.new(\"foo/bar\")\n {:ok, %URI{\n fragment: nil,\n host: nil,\n path: \"foo/bar\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }}\n\n iex> URI.new(\"//[fe80::]/\")\n {:ok, %URI{\n fragment: nil,\n host: \"fe80::\",\n path: \"/\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }}\n\n iex> URI.new(\"https:?query\")\n {:ok, %URI{\n fragment: nil,\n host: nil,\n path: nil,\n port: 443,\n query: \"query\",\n scheme: \"https\",\n userinfo: nil\n }}\n\n iex> URI.new(\"/invalid_greater_than_in_path/>\")\n {:error, \">\"}\n\n Giving an existing URI simply returns it wrapped in a tuple:\n\n iex> {:ok, uri} = URI.new(\"https://elixir-lang.org/\")\n iex> URI.new(uri)\n {:ok, %URI{\n fragment: nil,\n host: \"elixir-lang.org\",\n path: \"/\",\n port: 443,\n query: nil,\n scheme: \"https\",\n userinfo: nil\n }}\n \"\"\"\n @doc since: \"1.13.0\"\n @spec new(t() | String.t()) :: {:ok, t()} | {:error, String.t()}\n def new(%URI{} = uri), do: {:ok, uri}\n\n def new(binary) when is_binary(binary) do\n case :uri_string.parse(binary) do\n %{} = map -> {:ok, uri_from_map(map)}\n {:error, :invalid_uri, term} -> {:error, Kernel.to_string(term)}\n end\n end\n\n @doc \"\"\"\n Similar to `new/1` but raises `URI.Error` if an invalid string is given.\n\n ## Examples\n\n iex> URI.new!(\"https://elixir-lang.org/\")\n %URI{\n fragment: nil,\n host: \"elixir-lang.org\",\n path: \"/\",\n port: 443,\n query: nil,\n scheme: \"https\",\n userinfo: nil\n }\n\n iex> URI.new!(\"/invalid_greater_than_in_path/>\")\n ** (URI.Error) cannot parse due to reason invalid_uri: \">\"\n\n Giving an existing URI simply returns it:\n\n iex> uri = URI.new!(\"https://elixir-lang.org/\")\n iex> URI.new!(uri)\n %URI{\n fragment: nil,\n host: \"elixir-lang.org\",\n path: \"/\",\n port: 443,\n query: nil,\n scheme: \"https\",\n userinfo: nil\n }\n \"\"\"\n @doc since: \"1.13.0\"\n @spec new!(t() | String.t()) :: t()\n def new!(%URI{} = uri), do: uri\n\n def new!(binary) when is_binary(binary) do\n case :uri_string.parse(binary) do\n %{} = map ->\n uri_from_map(map)\n\n {:error, reason, part} ->\n raise Error, action: :parse, reason: reason, part: Kernel.to_string(part)\n end\n end\n\n defp uri_from_map(%{path: \"\"} = map), do: uri_from_map(%{map | path: nil})\n\n defp uri_from_map(map) do\n uri = Map.merge(%URI{}, map)\n\n case map do\n %{scheme: scheme} ->\n scheme = String.downcase(scheme, :ascii)\n\n case map do\n %{port: port} when is_integer(port) ->\n %{uri | scheme: scheme}\n\n %{} ->\n %{uri | scheme: scheme, port: default_port(scheme)}\n end\n\n %{port: :undefined} ->\n %{uri | port: nil}\n\n %{} ->\n uri\n end\n end\n\n @doc \"\"\"\n Parses a URI into its components, without further validation.\n\n This function can parse both absolute and relative URLs. You can check\n if a URI is absolute or relative by checking if the `scheme` field is\n nil or not.\n\n This function expects both absolute and relative URIs to be well-formed\n and does not perform any validation, it simply breaks the URL into parts.\n Use `new/1` if you want to validate the URI fields after parsing.\n\n When a URI is given without a port, the value returned by `URI.default_port/1`\n for the URI's scheme is used for the `:port` field. The scheme is also\n normalized to lowercase.\n\n If a `URI` struct is given to this function, this function returns it\n unmodified.\n\n > #### Browser compatibility {: .warning}\n >\n > This function does not follow the same parsing rules as browsers.\n > Browsers adhere to the WHATWG URL standard, while this function\n > implements RFC 3986. You should expect different behaviours between\n > them, especially around corner cases.\n\n > #### `:authority` field {: .info}\n >\n > This function sets the deprecated field `:authority` for backwards-compatibility reasons.\n\n ## Examples\n\n iex> URI.parse(\"https://elixir-lang.org/\")\n %URI{\n authority: \"elixir-lang.org\",\n fragment: nil,\n host: \"elixir-lang.org\",\n path: \"/\",\n port: 443,\n query: nil,\n scheme: \"https\",\n userinfo: nil\n }\n\n iex> URI.parse(\"//elixir-lang.org/\")\n %URI{\n authority: \"elixir-lang.org\",\n fragment: nil,\n host: \"elixir-lang.org\",\n path: \"/\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }\n\n iex> URI.parse(\"/foo/bar\")\n %URI{\n fragment: nil,\n host: nil,\n path: \"/foo/bar\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }\n\n iex> URI.parse(\"foo/bar\")\n %URI{\n fragment: nil,\n host: nil,\n path: \"foo/bar\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }\n\n In contrast to `URI.new/1`, this function will accept poorly-formed\n URIs and break them into components, as it does not perform validation.\n For example:\n\n iex> URI.parse(\"/invalid_greater_than_in_path/>\")\n %URI{\n fragment: nil,\n host: nil,\n path: \"/invalid_greater_than_in_path/>\",\n port: nil,\n query: nil,\n scheme: nil,\n userinfo: nil\n }\n\n Another example is a URI with brackets in query strings. It is accepted\n by `parse/1` for the same reasons as above (no validation), but it will\n be refused by `new/1`:\n\n iex> URI.parse(\"/?foo[bar]=baz\")\n %URI{\n fragment: nil,\n host: nil,\n path: \"/\",\n port: nil,\n query: \"foo[bar]=baz\",\n scheme: nil,\n userinfo: nil\n }\n\n Generally speaking, square brackets are strictly invalid even in the WHATWG\n URL standard used by browsers, but browsers tend to be permissive and often\n allow invalid characters to pass through.\n \"\"\"\n @spec parse(t | binary) :: t\n def parse(%URI{} = uri), do: uri\n\n def parse(string) when is_binary(string) do\n # From https://tools.ietf.org/html/rfc3986#appendix-B\n # Parts: 12 3 4 5 6 7 8 9\n regex = ~r{^(([a-z][a-z0-9\\+\\-\\.]*):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?}i\n\n parts = Regex.run(regex, string)\n\n destructure [\n _full,\n # 1\n _scheme_with_colon,\n # 2\n scheme,\n # 3\n authority_with_slashes,\n # 4\n _authority,\n # 5\n path,\n # 6\n query_with_question_mark,\n # 7\n _query,\n # 8\n _fragment_with_hash,\n # 9\n fragment\n ],\n parts\n\n path = nilify(path)\n scheme = nilify(scheme)\n query = nilify_query(query_with_question_mark)\n {authority, userinfo, host, port} = split_authority(authority_with_slashes)\n\n scheme = scheme && String.downcase(scheme)\n port = port || (scheme && default_port(scheme))\n\n %URI{\n scheme: scheme,\n path: path,\n query: query,\n fragment: fragment,\n authority: authority,\n userinfo: userinfo,\n host: host,\n port: port\n }\n end\n\n defp nilify_query(\"?\" <> query), do: query\n defp nilify_query(_other), do: nil\n\n # Split an authority into its userinfo, host and port parts.\n #\n # Note that the host field is returned *without* [] even if, according to\n # RFC3986 grammar, a native IPv6 address requires them.\n defp split_authority(\"\") do\n {nil, nil, nil, nil}\n end\n\n defp split_authority(\"//\") do\n {\"\", nil, \"\", nil}\n end\n\n defp split_authority(\"//\" <> authority) do\n regex = ~r/(^(.*)@)?(\\[[a-zA-Z0-9:.]*\\]|[^:]*)(:(\\d*))?/\n components = Regex.run(regex, authority)\n\n destructure [_, _, userinfo, host, _, port], components\n userinfo = nilify(userinfo)\n host = if nilify(host), do: host |> String.trim_leading(\"[\") |> String.trim_trailing(\"]\")\n port = if nilify(port), do: String.to_integer(port)\n\n {authority, userinfo, host, port}\n end\n\n # Regex.run returns empty strings sometimes. We want\n # to replace those with nil for consistency.\n defp nilify(\"\"), do: nil\n defp nilify(other), do: other\n\n @doc \"\"\"\n Returns the string representation of the given [URI struct](`t:t/0`).\n\n ## Examples\n\n iex> uri = URI.parse(\"http://google.com\")\n iex> URI.to_string(uri)\n \"http://google.com\"\n\n iex> uri = URI.parse(\"foo://bar.baz\")\n iex> URI.to_string(uri)\n \"foo://bar.baz\"\n\n \"\"\"\n @spec to_string(t) :: binary\n defdelegate to_string(uri), to: String.Chars.URI\n\n @doc ~S\"\"\"\n Merges two URIs.\n\n This function merges two URIs as per\n [RFC 3986, section 5.2](https://tools.ietf.org/html/rfc3986#section-5.2).\n\n ## Examples\n\n iex> URI.merge(URI.parse(\"http://google.com\"), \"/query\") |> to_string()\n \"http://google.com/query\"\n\n iex> URI.merge(\"http://example.com\", \"http://google.com\") |> to_string()\n \"http://google.com\"\n\n \"\"\"\n @spec merge(t | binary, t | binary) :: t\n def merge(uri, rel)\n\n def merge(%URI{scheme: nil}, _rel) do\n raise ArgumentError, \"you must merge onto an absolute URI\"\n end\n\n def merge(_base, %URI{scheme: rel_scheme} = rel) when rel_scheme != nil do\n %{rel | path: remove_dot_segments_from_path(rel.path)}\n end\n\n def merge(%URI{} = base, %URI{host: host} = rel) when host != nil do\n %{rel | scheme: base.scheme, path: remove_dot_segments_from_path(rel.path)}\n end\n\n def merge(%URI{} = base, %URI{path: nil} = rel) do\n %{base | query: rel.query || base.query, fragment: rel.fragment}\n end\n\n def merge(%URI{host: nil, path: nil} = base, %URI{} = rel) do\n %{\n base\n | path: remove_dot_segments_from_path(rel.path),\n query: rel.query,\n fragment: rel.fragment\n }\n end\n\n def merge(%URI{} = base, %URI{} = rel) do\n new_path = merge_paths(base.path, rel.path)\n %{base | path: new_path, query: rel.query, fragment: rel.fragment}\n end\n\n def merge(base, rel) do\n merge(parse(base), parse(rel))\n end\n\n defp merge_paths(nil, rel_path), do: merge_paths(\"/\", rel_path)\n defp merge_paths(\"\", rel_path), do: merge_paths(\"/\", rel_path)\n defp merge_paths(_, \"/\" <> _ = rel_path), do: remove_dot_segments_from_path(rel_path)\n\n defp merge_paths(base_path, rel_path) do\n (path_to_segments(base_path) ++ [:+] ++ path_to_segments(rel_path))\n |> remove_dot_segments([])\n |> join_reversed_segments()\n end\n\n defp remove_dot_segments_from_path(nil), do: nil\n\n defp remove_dot_segments_from_path(path) do\n path_to_segments(path)\n |> remove_dot_segments([])\n |> join_reversed_segments()\n end\n\n defp path_to_segments(path) do\n case String.split(path, \"/\") do\n [\"\" | tail] -> [:/ | tail]\n segments -> segments\n end\n end\n\n defp remove_dot_segments([], acc), do: acc\n defp remove_dot_segments([:/ | tail], acc), do: remove_dot_segments(tail, [:/ | acc])\n defp remove_dot_segments([_, :+ | tail], acc), do: remove_dot_segments(tail, acc)\n defp remove_dot_segments([\".\"], acc), do: remove_dot_segments([], [\"\" | acc])\n defp remove_dot_segments([\".\" | tail], acc), do: remove_dot_segments(tail, acc)\n defp remove_dot_segments([\"..\" | tail], [:/]), do: remove_dot_segments(tail, [:/])\n defp remove_dot_segments([\"..\"], [_ | acc]), do: remove_dot_segments([], [\"\" | acc])\n defp remove_dot_segments([\"..\" | tail], [_ | acc]), do: remove_dot_segments(tail, acc)\n defp remove_dot_segments([head | tail], acc), do: remove_dot_segments(tail, [head | acc])\n\n defp join_reversed_segments([:/]), do: \"/\"\n\n defp join_reversed_segments(segments) do\n case Enum.reverse(segments) do\n [:/ | tail] -> [\"\" | tail]\n list -> list\n end\n |> Enum.join(\"/\")\n end\n\n @doc \"\"\"\n Appends `query` to the given `uri`.\n\n The given `query` is not automatically encoded, use `encode/2` or `encode_www_form/1`.\n\n ## Examples\n\n iex> URI.append_query(URI.parse(\"http://example.com/\"), \"x=1\") |> URI.to_string()\n \"http://example.com/?x=1\"\n\n iex> URI.append_query(URI.parse(\"http://example.com/?x=1\"), \"y=2\") |> URI.to_string()\n \"http://example.com/?x=1&y=2\"\n\n iex> URI.append_query(URI.parse(\"http://example.com/?x=1\"), \"x=2\") |> URI.to_string()\n \"http://example.com/?x=1&x=2\"\n \"\"\"\n @doc since: \"1.14.0\"\n @spec append_query(t(), binary()) :: t()\n def append_query(%URI{} = uri, query) when is_binary(query) and uri.query in [nil, \"\"] do\n %{uri | query: query}\n end\n\n def append_query(%URI{} = uri, query) when is_binary(query) do\n if String.ends_with?(uri.query, \"&\") do\n %{uri | query: uri.query <> query}\n else\n %{uri | query: uri.query <> \"&\" <> query}\n end\n end\n\n @doc \"\"\"\n Appends `path` to the given `uri`.\n\n Path must start with `/` and cannot contain additional URL components like\n fragments or query strings. This function further assumes the path is valid and\n it does not contain a query string or fragment parts.\n\n ## Examples\n\n iex> URI.append_path(URI.parse(\"http://example.com/foo/?x=1\"), \"/my-path\") |> URI.to_string()\n \"http://example.com/foo/my-path?x=1\"\n\n iex> URI.append_path(URI.parse(\"http://example.com\"), \"my-path\")\n ** (ArgumentError) path must start with \"/\", got: \"my-path\"\n\n \"\"\"\n @doc since: \"1.15.0\"\n @spec append_path(t(), String.t()) :: t()\n def append_path(%URI{}, \"//\" <> _ = path) do\n raise ArgumentError, ~s|path cannot start with \"//\", got: #{inspect(path)}|\n end\n\n def append_path(%URI{path: path} = uri, \"/\" <> rest = all) do\n cond do\n path == nil -> %{uri | path: all}\n path != \"\" and :binary.last(path) == ?/ -> %{uri | path: path <> rest}\n true -> %{uri | path: path <> all}\n end\n end\n\n def append_path(%URI{}, path) when is_binary(path) do\n raise ArgumentError, ~s|path must start with \"/\", got: #{inspect(path)}|\n end\nend\n\ndefimpl String.Chars, for: URI do\n def to_string(%{host: host, path: path} = uri)\n when host != nil and is_binary(path) and\n path != \"\" and binary_part(path, 0, 1) != \"/\" do\n raise ArgumentError,\n \":path in URI must be empty or an absolute path if URL has a :host, got: #{inspect(uri)}\"\n end\n\n def to_string(%{scheme: scheme, port: port, path: path, query: query, fragment: fragment} = uri) do\n uri =\n case scheme && URI.default_port(scheme) do\n ^port -> %{uri | port: nil}\n _ -> uri\n end\n\n # Based on https://tools.ietf.org/html/rfc3986#section-5.3\n authority = extract_authority(uri)\n\n IO.iodata_to_binary([\n if(scheme, do: [scheme, ?:], else: []),\n if(authority, do: [\"//\" | authority], else: []),\n if(path, do: path, else: []),\n if(query, do: [\"?\" | query], else: []),\n if(fragment, do: [\"#\" | fragment], else: [])\n ])\n end\n\n defp extract_authority(%{host: nil, authority: authority}) do\n authority\n end\n\n defp extract_authority(%{host: host, userinfo: userinfo, port: port}) do\n # According to the grammar at\n # https://tools.ietf.org/html/rfc3986#appendix-A, a \"host\" can have a colon\n # in it only if it's an IPv6 or \"IPvFuture\" address, so if there's a colon\n # in the host we can safely surround it with [].\n [\n if(userinfo, do: [userinfo | \"@\"], else: []),\n if(String.contains?(host, \":\"), do: [\"[\", host | \"]\"], else: host),\n if(port, do: [\":\" | Integer.to_string(port)], else: [])\n ]\n end\nend\n" }, { "path": "lib/elixir/lib/version.ex", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Version do\n @moduledoc ~S\"\"\"\n Functions for parsing and matching versions against requirements.\n\n A version is a string in a specific format or a `Version`\n generated after parsing via `Version.parse/1`.\n\n Although Elixir projects are not required to follow SemVer,\n they must follow the format outlined on [SemVer 2.0 schema](https://semver.org/).\n\n ## Versions\n\n In a nutshell, a version is represented by three numbers:\n\n MAJOR.MINOR.PATCH\n\n Pre-releases are supported by optionally appending a hyphen and a series of\n period-separated identifiers immediately following the patch version.\n Identifiers consist of only ASCII alphanumeric characters and hyphens (`[0-9A-Za-z-]`):\n\n \"1.0.0-alpha.3\"\n\n Build information can be added by appending a plus sign and a series of\n dot-separated identifiers immediately following the patch or pre-release version.\n Identifiers consist of only ASCII alphanumeric characters and hyphens (`[0-9A-Za-z-]`):\n\n \"1.0.0-alpha.3+20130417140000.amd64\"\n\n ## Requirements\n\n Requirements allow you to specify which versions of a given\n dependency you are willing to work against. Requirements support the common\n comparison operators such as `>`, `>=`, `<`, `<=`, and `==` that work as one\n would expect, and additionally the special operator `~>` described in detail\n further below.\n\n # Only version 2.0.0\n \"== 2.0.0\"\n\n # Anything later than 2.0.0\n \"> 2.0.0\"\n\n You can skip the operator, which is equivalent to `==`:\n\n # Only version 2.0.0\n \"2.0.0\"\n\n Requirements also support `and` and `or` for complex conditions:\n\n # 2.0.0 and later until 2.1.0\n \">= 2.0.0 and < 2.1.0\"\n\n Since the example above is such a common requirement, it can\n be expressed as:\n\n \"~> 2.0.0\"\n\n `~>` will never include pre-release versions of its upper bound,\n regardless of the usage of the `:allow_pre` option, or whether the operand\n is a pre-release version. It can also be used to set an upper bound on only the major\n version part. See the table below for `~>` requirements and\n their corresponding translations.\n\n `~>` | Translation\n :------------- | :---------------------\n `~> 2.0.0` | `>= 2.0.0 and < 2.1.0`\n `~> 2.1.2` | `>= 2.1.2 and < 2.2.0`\n `~> 2.1.3-dev` | `>= 2.1.3-dev and < 2.2.0`\n `~> 2.0` | `>= 2.0.0 and < 3.0.0`\n `~> 2.1` | `>= 2.1.0 and < 3.0.0`\n\n The requirement operand after the `~>` is allowed to omit the patch version,\n allowing us to express `~> 2.1` or `~> 2.1-dev`, something that wouldn't be allowed\n when using the common comparison operators.\n\n When the `:allow_pre` option is set `false` in `Version.match?/3`, the requirement\n will not match a pre-release version unless the operand is a pre-release version.\n The default is to always allow pre-releases but note that in\n Hex `:allow_pre` is set to `false`. See the table below for examples.\n\n Requirement | Version | `:allow_pre` | Matches\n :------------- | :---------- | :---------------- | :------\n `~> 2.0` | `2.1.0` | `true` or `false` | `true`\n `~> 2.0` | `3.0.0` | `true` or `false` | `false`\n `~> 2.0.0` | `2.0.5` | `true` or `false` | `true`\n `~> 2.0.0` | `2.1.0` | `true` or `false` | `false`\n `~> 2.1.2` | `2.1.6-dev` | `true` | `true`\n `~> 2.1.2` | `2.1.6-dev` | `false` | `false`\n `~> 2.1-dev` | `2.2.0-dev` | `true` or `false` | `true`\n `~> 2.1.2-dev` | `2.1.6-dev` | `true` or `false` | `true`\n `>= 2.1.0` | `2.2.0-dev` | `true` | `true`\n `>= 2.1.0` | `2.2.0-dev` | `false` | `false`\n `>= 2.1.0-dev` | `2.2.6-dev` | `true` or `false` | `true`\n\n \"\"\"\n\n import Kernel, except: [match?: 2]\n\n @doc \"\"\"\n The Version struct.\n\n It contains the fields `:major`, `:minor`, `:patch`, `:pre`, and\n `:build` according to SemVer 2.0, where `:pre` is a list.\n\n You can read those fields but you should not create a new `Version`\n directly via the struct syntax. Instead use the functions in this\n module.\n \"\"\"\n @enforce_keys [:major, :minor, :patch]\n @derive {Inspect, optional: [:pre, :build]}\n defstruct [:major, :minor, :patch, pre: [], build: nil]\n\n @type version :: String.t() | t\n @type requirement :: String.t() | Version.Requirement.t()\n @type major :: non_neg_integer\n @type minor :: non_neg_integer\n @type patch :: non_neg_integer\n @type pre :: [String.t() | non_neg_integer]\n @type build :: String.t() | nil\n @type t :: %__MODULE__{major: major, minor: minor, patch: patch, pre: pre, build: build}\n\n @type match_opts :: [allow_pre: boolean()]\n\n defmodule Requirement do\n @moduledoc \"\"\"\n A struct that holds version requirement information.\n\n The struct fields are private and should not be accessed.\n\n See the \"Requirements\" section in the `Version` module\n for more information.\n \"\"\"\n\n defstruct [:source, :lexed]\n\n @opaque t :: %__MODULE__{\n source: String.t(),\n lexed: [atom | matchable]\n }\n\n @typep matchable ::\n {Version.major(), Version.minor(), Version.patch(), Version.pre(), Version.build()}\n\n @compile inline: [compare: 2]\n\n @doc false\n @spec new(String.t(), [atom | matchable]) :: t\n def new(source, lexed) do\n %__MODULE__{source: source, lexed: lexed}\n end\n\n @doc false\n @spec compile_requirement(t) :: t\n def compile_requirement(%Requirement{} = requirement) do\n requirement\n end\n\n @doc false\n @spec match?(t, tuple) :: boolean\n def match?(%__MODULE__{lexed: [operator, req | rest]}, version) do\n match_lexed?(rest, version, match_op?(operator, req, version))\n end\n\n defp match_lexed?([:and, operator, req | rest], version, acc),\n do: match_lexed?(rest, version, acc and match_op?(operator, req, version))\n\n defp match_lexed?([:or, operator, req | rest], version, acc),\n do: acc or match_lexed?(rest, version, match_op?(operator, req, version))\n\n defp match_lexed?([], _version, acc),\n do: acc\n\n defp match_op?(:==, req, version) do\n compare(version, req) == :eq\n end\n\n defp match_op?(:!=, req, version) do\n compare(version, req) != :eq\n end\n\n defp match_op?(:~>, {major, minor, nil, req_pre, _}, {_, _, _, pre, allow_pre} = version) do\n compare(version, {major, minor, 0, req_pre, nil}) in [:eq, :gt] and\n compare(version, {major + 1, 0, 0, [0], nil}) == :lt and\n (allow_pre or req_pre != [] or pre == [])\n end\n\n defp match_op?(:~>, {major, minor, _, req_pre, _} = req, {_, _, _, pre, allow_pre} = version) do\n compare(version, req) in [:eq, :gt] and\n compare(version, {major, minor + 1, 0, [0], nil}) == :lt and\n (allow_pre or req_pre != [] or pre == [])\n end\n\n defp match_op?(:>, {_, _, _, req_pre, _} = req, {_, _, _, pre, allow_pre} = version) do\n compare(version, req) == :gt and (allow_pre or req_pre != [] or pre == [])\n end\n\n defp match_op?(:>=, {_, _, _, req_pre, _} = req, {_, _, _, pre, allow_pre} = version) do\n compare(version, req) in [:eq, :gt] and (allow_pre or req_pre != [] or pre == [])\n end\n\n defp match_op?(:<, req, version) do\n compare(version, req) == :lt\n end\n\n defp match_op?(:<=, req, version) do\n compare(version, req) in [:eq, :lt]\n end\n\n defp compare({major1, minor1, patch1, pre1, _}, {major2, minor2, patch2, pre2, _}) do\n cond do\n major1 > major2 -> :gt\n major1 < major2 -> :lt\n minor1 > minor2 -> :gt\n minor1 < minor2 -> :lt\n patch1 > patch2 -> :gt\n patch1 < patch2 -> :lt\n pre1 == [] and pre2 != [] -> :gt\n pre1 != [] and pre2 == [] -> :lt\n pre1 > pre2 -> :gt\n pre1 < pre2 -> :lt\n true -> :eq\n end\n end\n end\n\n defmodule InvalidRequirementError do\n @moduledoc \"\"\"\n An exception raised when a version requirement is invalid.\n\n For example, see `Version.parse_requirement!/1`.\n \"\"\"\n\n defexception [:requirement]\n\n @impl true\n def exception(requirement) when is_binary(requirement) do\n %__MODULE__{requirement: requirement}\n end\n\n @impl true\n def message(%{requirement: requirement}) do\n \"invalid requirement: #{inspect(requirement)}\"\n end\n end\n\n defmodule InvalidVersionError do\n @moduledoc \"\"\"\n An exception raised when a version is invalid.\n\n For example, see `Version.parse!/1`.\n \"\"\"\n\n defexception [:version]\n\n @impl true\n def exception(version) when is_binary(version) do\n %__MODULE__{version: version}\n end\n\n @impl true\n def message(%{version: version}) do\n \"invalid version: #{inspect(version)}\"\n end\n end\n\n @doc \"\"\"\n Checks if the given version matches the specification.\n\n Returns `true` if `version` satisfies `requirement`, `false` otherwise.\n Raises a `Version.InvalidRequirementError` exception if `requirement` is not\n parsable, or a `Version.InvalidVersionError` exception if `version` is not parsable.\n If given an already parsed version and requirement this function won't\n raise.\n\n ## Options\n\n * `:allow_pre` (boolean) - when `false`, pre-release versions will not match\n unless the operand is a pre-release version. Defaults to `true`.\n For examples, please refer to the table above under the \"Requirements\" section.\n\n ## Examples\n\n iex> Version.match?(\"2.0.0\", \"> 1.0.0\")\n true\n\n iex> Version.match?(\"2.0.0\", \"== 1.0.0\")\n false\n\n iex> Version.match?(\"2.1.6-dev\", \"~> 2.1.2\")\n true\n\n iex> Version.match?(\"2.1.6-dev\", \"~> 2.1.2\", allow_pre: false)\n false\n\n iex> Version.match?(\"foo\", \"== 1.0.0\")\n ** (Version.InvalidVersionError) invalid version: \"foo\"\n\n iex> Version.match?(\"2.0.0\", \"== == 1.0.0\")\n ** (Version.InvalidRequirementError) invalid requirement: \"== == 1.0.0\"\n\n \"\"\"\n @spec match?(version, requirement, match_opts) :: boolean\n def match?(version, requirement, opts \\\\ [])\n\n def match?(version, requirement, opts) when is_binary(requirement) do\n match?(version, parse_requirement!(requirement), opts)\n end\n\n def match?(version, requirement, opts) do\n allow_pre = Keyword.get(opts, :allow_pre, true)\n matchable_pattern = to_matchable(version, allow_pre)\n\n Requirement.match?(requirement, matchable_pattern)\n end\n\n @doc \"\"\"\n Compares two versions.\n\n Returns `:gt` if the first version is greater than the second one, and `:lt`\n for vice versa. If the two versions are equal, `:eq` is returned.\n\n Pre-releases are strictly less than their corresponding release versions.\n\n Patch segments are compared lexicographically if they are alphanumeric, and\n numerically otherwise.\n\n Build segments are ignored: if two versions differ only in their build segment\n they are considered to be equal.\n\n Raises a `Version.InvalidVersionError` exception if any of the two given\n versions are not parsable. If given an already parsed version this function\n won't raise.\n\n ## Examples\n\n iex> Version.compare(\"2.0.1-alpha1\", \"2.0.0\")\n :gt\n\n iex> Version.compare(\"1.0.0-beta\", \"1.0.0-rc1\")\n :lt\n\n iex> Version.compare(\"1.0.0-10\", \"1.0.0-2\")\n :gt\n\n iex> Version.compare(\"2.0.1+build0\", \"2.0.1\")\n :eq\n\n iex> Version.compare(\"invalid\", \"2.0.1\")\n ** (Version.InvalidVersionError) invalid version: \"invalid\"\n\n \"\"\"\n @spec compare(version, version) :: :gt | :eq | :lt\n def compare(version1, version2) do\n do_compare(to_matchable(version1, true), to_matchable(version2, true))\n end\n\n defp do_compare({major1, minor1, patch1, pre1, _}, {major2, minor2, patch2, pre2, _}) do\n cond do\n major1 > major2 -> :gt\n major1 < major2 -> :lt\n minor1 > minor2 -> :gt\n minor1 < minor2 -> :lt\n patch1 > patch2 -> :gt\n patch1 < patch2 -> :lt\n pre1 == [] and pre2 != [] -> :gt\n pre1 != [] and pre2 == [] -> :lt\n pre1 > pre2 -> :gt\n pre1 < pre2 -> :lt\n true -> :eq\n end\n end\n\n @doc \"\"\"\n Parses a version string into a `Version` struct.\n\n ## Examples\n\n iex> Version.parse(\"2.0.1-alpha1\")\n {:ok, %Version{major: 2, minor: 0, patch: 1, pre: [\"alpha1\"]}}\n\n iex> Version.parse(\"2.0-alpha1\")\n :error\n\n \"\"\"\n @spec parse(String.t()) :: {:ok, t} | :error\n def parse(string) when is_binary(string) do\n case Version.Parser.parse_version(string) do\n {:ok, {major, minor, patch, pre, build_parts}} ->\n build = if build_parts == [], do: nil, else: Enum.join(build_parts, \".\")\n version = %Version{major: major, minor: minor, patch: patch, pre: pre, build: build}\n {:ok, version}\n\n :error ->\n :error\n end\n end\n\n @doc \"\"\"\n Parses a version string into a `Version`.\n\n If `string` is an invalid version, a `Version.InvalidVersionError` is raised.\n\n ## Examples\n\n iex> Version.parse!(\"2.0.1-alpha1\")\n %Version{major: 2, minor: 0, patch: 1, pre: [\"alpha1\"]}\n\n iex> Version.parse!(\"2.0-alpha1\")\n ** (Version.InvalidVersionError) invalid version: \"2.0-alpha1\"\n\n \"\"\"\n @spec parse!(String.t()) :: t\n def parse!(string) when is_binary(string) do\n case parse(string) do\n {:ok, version} -> version\n :error -> raise InvalidVersionError, string\n end\n end\n\n @doc \"\"\"\n Parses a version requirement string into a `Version.Requirement` struct.\n\n ## Examples\n\n iex> {:ok, requirement} = Version.parse_requirement(\"== 2.0.1\")\n iex> requirement\n Version.parse_requirement!(\"== 2.0.1\")\n\n iex> Version.parse_requirement(\"== == 2.0.1\")\n :error\n\n \"\"\"\n @spec parse_requirement(String.t()) :: {:ok, Requirement.t()} | :error\n def parse_requirement(string) when is_binary(string) do\n case Version.Parser.parse_requirement(string) do\n {:ok, lexed} -> {:ok, Requirement.new(string, lexed)}\n :error -> :error\n end\n end\n\n @doc \"\"\"\n Parses a version requirement string into a `Version.Requirement` struct.\n\n If `string` is an invalid requirement, a `Version.InvalidRequirementError` is raised.\n\n ## Examples\n\n iex> Version.parse_requirement!(\"== 2.0.1\")\n Version.parse_requirement!(\"== 2.0.1\")\n\n iex> Version.parse_requirement!(\"== == 2.0.1\")\n ** (Version.InvalidRequirementError) invalid requirement: \"== == 2.0.1\"\n\n \"\"\"\n @doc since: \"1.8.0\"\n @spec parse_requirement!(String.t()) :: Requirement.t()\n def parse_requirement!(string) when is_binary(string) do\n case parse_requirement(string) do\n {:ok, requirement} -> requirement\n :error -> raise InvalidRequirementError, string\n end\n end\n\n @doc \"\"\"\n Compiles a requirement to an internal representation that may optimize matching.\n\n The internal representation is opaque.\n \"\"\"\n @spec compile_requirement(Requirement.t()) :: Requirement.t()\n defdelegate compile_requirement(requirement), to: Requirement\n\n defp to_matchable(%Version{major: major, minor: minor, patch: patch, pre: pre}, allow_pre?) do\n {major, minor, patch, pre, allow_pre?}\n end\n\n defp to_matchable(string, allow_pre?) do\n case Version.Parser.parse_version(string) do\n {:ok, {major, minor, patch, pre, _build_parts}} ->\n {major, minor, patch, pre, allow_pre?}\n\n :error ->\n raise InvalidVersionError, string\n end\n end\n\n @doc \"\"\"\n Converts the given version to a string.\n\n ## Examples\n\n iex> Version.to_string(%Version{major: 1, minor: 2, patch: 3})\n \"1.2.3\"\n iex> Version.to_string(Version.parse!(\"1.14.0-rc.0+build0\"))\n \"1.14.0-rc.0+build0\"\n \"\"\"\n @doc since: \"1.14.0\"\n @spec to_string(Version.t()) :: String.t()\n def to_string(%Version{} = version) do\n pre = pre_to_string(version.pre)\n build = if build = version.build, do: \"+#{build}\"\n \"#{version.major}.#{version.minor}.#{version.patch}#{pre}#{build}\"\n end\n\n defp pre_to_string([]) do\n \"\"\n end\n\n defp pre_to_string(pre) do\n \"-\" <>\n Enum.map_join(pre, \".\", fn\n int when is_integer(int) -> Integer.to_string(int)\n string when is_binary(string) -> string\n end)\n end\n\n defmodule Parser do\n @moduledoc false\n\n operators = [\n {\">=\", :>=},\n {\"<=\", :<=},\n {\"~>\", :~>},\n {\">\", :>},\n {\"<\", :<},\n {\"==\", :==},\n {\" or \", :or},\n {\" and \", :and}\n ]\n\n def lexer(string) do\n lexer(string, \"\", [])\n end\n\n for {string_op, atom_op} <- operators do\n defp lexer(unquote(string_op) <> rest, buffer, acc) do\n lexer(rest, \"\", [unquote(atom_op) | maybe_prepend_buffer(buffer, acc)])\n end\n end\n\n defp lexer(\"!=\" <> rest, buffer, acc) do\n IO.warn(\"!= inside Version requirements is deprecated, use ~> or >= instead\")\n lexer(rest, \"\", [:!= | maybe_prepend_buffer(buffer, acc)])\n end\n\n defp lexer(\"!\" <> rest, buffer, acc) do\n IO.warn(\"! inside Version requirements is deprecated, use ~> or >= instead\")\n lexer(rest, \"\", [:!= | maybe_prepend_buffer(buffer, acc)])\n end\n\n defp lexer(\" \" <> rest, buffer, acc) do\n lexer(rest, \"\", maybe_prepend_buffer(buffer, acc))\n end\n\n defp lexer(<>, buffer, acc) do\n lexer(rest, <>, acc)\n end\n\n defp lexer(<<>>, buffer, acc) do\n maybe_prepend_buffer(buffer, acc)\n end\n\n defp maybe_prepend_buffer(\"\", acc), do: acc\n\n defp maybe_prepend_buffer(buffer, [head | _] = acc)\n when is_atom(head) and head not in [:and, :or],\n do: [buffer | acc]\n\n defp maybe_prepend_buffer(buffer, acc),\n do: [buffer, :== | acc]\n\n defp revert_lexed([version, op, cond | rest], acc)\n when is_binary(version) and is_atom(op) and cond in [:or, :and] do\n with {:ok, version} <- validate_requirement(op, version) do\n revert_lexed(rest, [cond, op, version | acc])\n end\n end\n\n defp revert_lexed([version, op], acc) when is_binary(version) and is_atom(op) do\n with {:ok, version} <- validate_requirement(op, version) do\n {:ok, [op, version | acc]}\n end\n end\n\n defp revert_lexed(_rest, _acc), do: :error\n\n defp validate_requirement(op, version) do\n case parse_version(version, true) do\n {:ok, version} when op == :~> -> {:ok, version}\n {:ok, {_, _, patch, _, _} = version} when is_integer(patch) -> {:ok, version}\n _ -> :error\n end\n end\n\n @spec parse_requirement(String.t()) :: {:ok, term} | :error\n def parse_requirement(source) do\n revert_lexed(lexer(source), [])\n end\n\n def parse_version(string, approximate? \\\\ false) when is_binary(string) do\n destructure [version_with_pre, build], String.split(string, \"+\", parts: 2)\n destructure [version, pre], String.split(version_with_pre, \"-\", parts: 2)\n destructure [major, minor, patch, next], String.split(version, \".\")\n\n with nil <- next,\n {:ok, major} <- require_digits(major),\n {:ok, minor} <- require_digits(minor),\n {:ok, patch} <- maybe_patch(patch, approximate?),\n {:ok, pre_parts} <- optional_dot_separated(pre),\n {:ok, pre_parts} <- convert_parts_to_integer(pre_parts, []),\n {:ok, build_parts} <- optional_dot_separated(build) do\n {:ok, {major, minor, patch, pre_parts, build_parts}}\n else\n _other -> :error\n end\n end\n\n defp require_digits(nil), do: :error\n\n defp require_digits(string) do\n if leading_zero?(string), do: :error, else: parse_digits(string, \"\")\n end\n\n defp leading_zero?(<>), do: true\n defp leading_zero?(_), do: false\n\n defp parse_digits(<>, acc) when char in ?0..?9,\n do: parse_digits(rest, <>)\n\n defp parse_digits(<<>>, acc) when byte_size(acc) > 0, do: {:ok, String.to_integer(acc)}\n defp parse_digits(_, _acc), do: :error\n\n defp maybe_patch(patch, approximate?)\n defp maybe_patch(nil, true), do: {:ok, nil}\n defp maybe_patch(patch, _), do: require_digits(patch)\n\n defp optional_dot_separated(nil), do: {:ok, []}\n\n defp optional_dot_separated(string) do\n parts = String.split(string, \".\")\n\n if Enum.all?(parts, &(&1 != \"\" and valid_identifier?(&1))) do\n {:ok, parts}\n else\n :error\n end\n end\n\n defp convert_parts_to_integer([part | rest], acc) do\n case parse_digits(part, \"\") do\n {:ok, integer} ->\n if leading_zero?(part) do\n :error\n else\n convert_parts_to_integer(rest, [integer | acc])\n end\n\n :error ->\n convert_parts_to_integer(rest, [part | acc])\n end\n end\n\n defp convert_parts_to_integer([], acc) do\n {:ok, Enum.reverse(acc)}\n end\n\n defp valid_identifier?(<>)\n when char in ?0..?9\n when char in ?a..?z\n when char in ?A..?Z\n when char == ?- do\n valid_identifier?(rest)\n end\n\n defp valid_identifier?(<<>>) do\n true\n end\n\n defp valid_identifier?(_other) do\n false\n end\n end\nend\n\ndefimpl String.Chars, for: Version do\n defdelegate to_string(version), to: Version\nend\n\ndefimpl String.Chars, for: Version.Requirement do\n def to_string(%Version.Requirement{source: source}) do\n source\n end\nend\n\ndefimpl Inspect, for: Version.Requirement do\n def inspect(%Version.Requirement{source: source}, opts) do\n colorized = Inspect.Algebra.color_doc(\"\\\"\" <> source <> \"\\\"\", :string, opts)\n\n Inspect.Algebra.concat([\"Version.parse_requirement!(\", colorized, \")\"])\n end\nend\n" }, { "path": "lib/elixir/mix.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Elixir.MixProject do\n use Mix.Project\n\n def project do\n [\n app: :elixir,\n version: System.version(),\n build_per_environment: false\n ]\n end\nend\n" }, { "path": "lib/elixir/pages/anti-patterns/code-anti-patterns.md", "content": "\n\n# Code-related anti-patterns\n\nThis document outlines potential anti-patterns related to your code and particular Elixir idioms and features.\n\n## Comments overuse\n\n#### Problem\n\nWhen you overuse comments or comment self-explanatory code, it can have the effect of making code *less readable*.\n\n#### Example\n\n```elixir\n# Returns the Unix timestamp of 5 minutes from the current time\ndefp unix_five_min_from_now do\n # Get the current time\n now = DateTime.utc_now()\n\n # Convert it to a Unix timestamp\n unix_now = DateTime.to_unix(now, :second)\n\n # Add five minutes in seconds\n unix_now + (60 * 5)\nend\n```\n\n#### Refactoring\n\nPrefer clear and self-explanatory function names, module names, and variable names when possible. In the example above, the function name explains well what the function does, so you likely won't need the comment before it. The code also explains the operations well through variable names and clear function calls.\n\nYou could refactor the code above like this:\n\n```elixir\n@five_min_in_seconds 60 * 5\n\ndefp unix_five_min_from_now do\n now = DateTime.utc_now()\n unix_now = DateTime.to_unix(now, :second)\n unix_now + @five_min_in_seconds\nend\n```\n\nWe removed the unnecessary comments. We also added a `@five_min_in_seconds` module attribute, which serves the additional purpose of giving a name to the \"magic\" number `60 * 5`, making the code clearer and more expressive.\n\n#### Additional remarks\n\nElixir makes a clear distinction between **documentation** and code comments. The language has built-in first-class support for documentation through `@doc`, `@moduledoc`, and more. See the [\"Writing documentation\"](../getting-started/writing-documentation.md) guide for more information.\n\n## Complex `else` clauses in `with`\n\n#### Problem\n\nThis anti-pattern refers to `with` expressions that flatten all its error clauses into a single complex `else` block. This situation is harmful to the code readability and maintainability because it's difficult to know from which clause the error value came.\n\n#### Example\n\nAn example of this anti-pattern, as shown below, is a function `open_decoded_file/1` that reads a Base64-encoded string content from a file and returns a decoded binary string. This function uses a `with` expression that needs to handle two possible errors, all of which are concentrated in a single complex `else` block.\n\n```elixir\ndef open_decoded_file(path) do\n with {:ok, encoded} <- File.read(path),\n {:ok, decoded} <- Base.decode64(encoded) do\n {:ok, String.trim(decoded)}\n else\n {:error, _} -> {:error, :badfile}\n :error -> {:error, :badencoding}\n end\nend\n```\n\nIn the code above, it is unclear how each pattern on the left side of `<-` relates to their error at the end. The more patterns in a `with`, the less clear the code gets, and the more likely it is that unrelated failures will overlap each other.\n\n#### Refactoring\n\nIn this situation, instead of concentrating all error handling within a single complex `else` block, it is better to normalize the return types in specific private functions. In this way, `with` can focus on the success case and the errors are normalized closer to where they happen, leading to better organized and maintainable code.\n\n```elixir\ndef open_decoded_file(path) do\n with {:ok, encoded} <- file_read(path),\n {:ok, decoded} <- base_decode64(encoded) do\n {:ok, String.trim(decoded)}\n end\nend\n\ndefp file_read(path) do\n case File.read(path) do\n {:ok, contents} -> {:ok, contents}\n {:error, _} -> {:error, :badfile}\n end\nend\n\ndefp base_decode64(contents) do\n case Base.decode64(contents) do\n {:ok, decoded} -> {:ok, decoded}\n :error -> {:error, :badencoding}\n end\nend\n```\n\n## Complex extractions in clauses\n\n#### Problem\n\nWhen we use multi-clause functions, it is possible to extract values in the clauses for further usage and for pattern matching/guard checking. This extraction itself does not represent an anti-pattern, but when you have *extractions made across several clauses and several arguments of the same function*, it becomes hard to know which extracted parts are used for pattern/guards and what is used only inside the function body. This anti-pattern is related to [Unrelated multi-clause function](design-anti-patterns.md#unrelated-multi-clause-function), but with implications of its own. It impairs the code readability in a different way.\n\n#### Example\n\nThe multi-clause function `drive/1` is extracting fields of an `%User{}` struct for usage in the clause expression (`age`) and for usage in the function body (`name`):\n\n```elixir\ndef drive(%User{name: name, age: age}) when age >= 18 do\n \"#{name} can drive\"\nend\n\ndef drive(%User{name: name, age: age}) when age < 18 do\n \"#{name} cannot drive\"\nend\n```\n\nWhile the example above is small and does not constitute an anti-pattern, it is an example of mixed extraction and pattern matching. A situation where `drive/1` was more complex, having many more clauses, arguments, and extractions, would make it hard to know at a glance which variables are used for pattern/guards and which ones are not.\n\n#### Refactoring\n\nAs shown below, a possible solution to this anti-pattern is to extract only pattern/guard related variables in the signature once you have many arguments or multiple clauses:\n\n```elixir\ndef drive(%User{age: age} = user) when age >= 18 do\n %User{name: name} = user\n \"#{name} can drive\"\nend\n\ndef drive(%User{age: age} = user) when age < 18 do\n %User{name: name} = user\n \"#{name} cannot drive\"\nend\n```\n\n## Dynamic atom creation\n\n#### Problem\n\nAn `Atom` is an Elixir basic type whose value is its own name. Atoms are often useful to identify resources or express the state, or result, of an operation. Creating atoms dynamically is not an anti-pattern by itself. However, atoms are not garbage collected by the Erlang Virtual Machine, so values of this type live in memory during a software's entire execution lifetime. The Erlang VM limits the number of atoms that can exist in an application by default to *1 048 576*, which is more than enough to cover all atoms defined in a program, but attempts to serve as an early limit for applications which are \"leaking atoms\" through dynamic creation.\n\nFor these reasons, creating atoms dynamically can be considered an anti-pattern when the developer has no control over how many atoms will be created during the software execution. This unpredictable scenario can expose the software to unexpected behavior caused by excessive memory usage, or even by reaching the maximum number of *atoms* possible.\n\n#### Example\n\nPicture yourself implementing code that converts string values into atoms. These strings could have been received from an external system, either as part of a request into our application, or as part of a response to your application. This dynamic and unpredictable scenario poses a security risk, as these uncontrolled conversions can potentially trigger out-of-memory errors.\n\n```elixir\ndefmodule MyRequestHandler do\n def parse(%{\"status\" => status, \"message\" => message} = _payload) do\n %{status: String.to_atom(status), message: message}\n end\nend\n```\n\n```elixir\niex> MyRequestHandler.parse(%{\"status\" => \"ok\", \"message\" => \"all good\"})\n%{status: :ok, message: \"all good\"}\n```\n\nWhen we use the `String.to_atom/1` function to dynamically create an atom, it essentially gains potential access to create arbitrary atoms in our system, causing us to lose control over adhering to the limits established by the BEAM. This issue could be exploited by someone to create enough atoms to shut down a system.\n\n#### Refactoring\n\nTo eliminate this anti-pattern, developers must either perform explicit conversions by mapping strings to atoms or replace the use of `String.to_atom/1` with `String.to_existing_atom/1`. An explicit conversion could be done as follows:\n\n```elixir\ndefmodule MyRequestHandler do\n def parse(%{\"status\" => status, \"message\" => message} = _payload) do\n %{status: convert_status(status), message: message}\n end\n\n defp convert_status(\"ok\"), do: :ok\n defp convert_status(\"error\"), do: :error\n defp convert_status(\"redirect\"), do: :redirect\nend\n```\n\n```elixir\niex> MyRequestHandler.parse(%{\"status\" => \"status_not_seen_anywhere\", \"message\" => \"all good\"})\n** (FunctionClauseError) no function clause matching in MyRequestHandler.convert_status/1\n```\n\nBy explicitly listing all supported statuses, you guarantee only a limited number of conversions may happen. Passing an invalid status will lead to a function clause error.\n\nAn alternative is to use `String.to_existing_atom/1`, which will only convert a string to atom if the atom already exists in the system:\n\n```elixir\ndefmodule MyRequestHandler do\n def parse(%{\"status\" => status, \"message\" => message} = _payload) do\n %{status: String.to_existing_atom(status), message: message}\n end\nend\n```\n\n```elixir\niex> MyRequestHandler.parse(%{\"status\" => \"status_not_seen_anywhere\", \"message\" => \"all good\"})\n** (ArgumentError) errors were found at the given arguments:\n\n * 1st argument: not an already existing atom\n```\n\nIn such cases, passing an unknown status will raise as long as the status was not defined anywhere as an atom in the system. However, assuming `status` can be either `:ok`, `:error`, or `:redirect`, how can you guarantee those atoms exist? You must ensure those atoms exist somewhere **in the same module** where `String.to_existing_atom/1` is called. For example, if you had this code:\n\n```elixir\ndefmodule MyRequestHandler do\n def parse(%{\"status\" => status, \"message\" => message} = _payload) do\n %{status: String.to_existing_atom(status), message: message}\n end\n\n def handle(%{status: status}) do\n case status do\n :ok -> ...\n :error -> ...\n :redirect -> ...\n end\n end\nend\n```\n\nAll valid statuses are defined as atoms within the same module, and that's enough. If you want to be explicit, you could also have a function that lists them:\n\n```elixir\ndef valid_statuses do\n [:ok, :error, :redirect]\nend\n```\n\nHowever, keep in mind using a module attribute or defining the atoms in the module body, outside of a function, are not sufficient, as the module body is only executed during compilation and it is not necessarily part of the compiled module loaded at runtime.\n\n## Long parameter list\n\n#### Problem\n\nIn a functional language like Elixir, functions tend to explicitly receive all inputs and return all relevant outputs, instead of relying on mutations or side-effects. As functions grow in complexity, the amount of arguments (parameters) they need to work with may grow, to a point where the function's interface becomes confusing and prone to errors during use.\n\n#### Example\n\nIn the following example, the `loan/6` functions takes too many arguments, causing its interface to be confusing and potentially leading developers to introduce errors during calls to this function.\n\n```elixir\ndefmodule Library do\n # Too many parameters that can be grouped!\n def loan(user_name, email, password, user_alias, book_title, book_ed) do\n ...\n end\nend\n```\n\n#### Refactoring\n\nTo address this anti-pattern, related arguments can be grouped using key-value data structures, such as maps, structs, or even keyword lists in the case of optional arguments. This effectively reduces the number of arguments and the key-value data structures adds clarity to the caller.\n\nFor this particular example, the arguments to `loan/6` can be grouped into two different maps, thereby reducing its arity to `loan/2`:\n\n```elixir\ndefmodule Library do\n def loan(%{name: name, email: email, password: password, alias: alias} = user, %{title: title, ed: ed} = book) do\n ...\n end\nend\n```\n\nIn some cases, the function with too many arguments may be a private function, which gives us more flexibility over how to separate the function arguments. One possible suggestion for such scenarios is to split the arguments in two maps (or tuples): one map keeps the data that may change, and the other keeps the data that won't change (read-only). This gives us a mechanical option to refactor the code.\n\nOther times, a function may legitimately take half a dozen or more completely unrelated arguments. This may suggest the function is trying to do too much and would be better broken into multiple functions, each responsible for a smaller piece of the overall responsibility.\n\n## Namespace trespassing\n\n#### Problem\n\nThis anti-pattern manifests when a package author or a library defines modules outside of its \"namespace\". A library should use its name as a \"prefix\" for all of its modules. For example, a package named `:my_lib` should define all of its modules within the `MyLib` namespace, such as `MyLib.User`, `MyLib.SubModule`, `MyLib.Application`, and `MyLib` itself.\n\nThis is important because the Erlang VM can only load one instance of a module at a time. So if there are multiple libraries that define the same module, then they are incompatible with each other due to this limitation. By always using the library name as a prefix, it avoids module name clashes due to the unique prefix.\n\n#### Example\n\nThis problem commonly manifests when writing an extension of another library. For example, imagine you are writing a package that adds authentication to [Plug](https://github.com/elixir-plug/plug) called `:plug_auth`. You must avoid defining modules within the `Plug` namespace:\n\n```elixir\ndefmodule Plug.Auth do\n # ...\nend\n```\n\nEven if `Plug` does not currently define a `Plug.Auth` module, it may add such a module in the future, which would ultimately conflict with `plug_auth`'s definition.\n\n#### Refactoring\n\nGiven the package is named `:plug_auth`, it must define modules inside the `PlugAuth` namespace:\n\n```elixir\ndefmodule PlugAuth do\n # ...\nend\n```\n\n#### Additional remarks\n\nThere are few known exceptions to this anti-pattern:\n\n * [Protocol implementations](`Kernel.defimpl/2`) are, by design, defined under the protocol namespace\n\n * In some scenarios, the namespace owner may allow exceptions to this rule. For example, in Elixir itself, you defined [custom Mix tasks](`Mix.Task`) by placing them under the `Mix.Tasks` namespace, such as `Mix.Tasks.PlugAuth`\n\n * If you are the maintainer for both `plug` and `plug_auth`, then you may allow `plug_auth` to define modules with the `Plug` namespace, such as `Plug.Auth`. However, you are responsible for avoiding or managing any conflicts that may arise in the future\n\n## Non-assertive map access\n\n#### Problem\n\nIn Elixir, it is possible to access values from `Map`s, which are key-value data structures, either statically or dynamically.\n\nWhen a key is expected to exist in a map, it must be accessed using the `map.key` notation, making it clear to developers (and the compiler) that the key must exist. If the key does not exist, an exception is raised (and in some cases also compiler warnings). This is also known as the static notation, as the key is known at the time of writing the code.\n\nWhen a key is optional, the `map[:key]` notation must be used instead. This way, if the informed key does not exist, `nil` is returned. This is the dynamic notation, as it also supports dynamic key access, such as `map[some_var]`.\n\nWhen you use `map[:key]` to access a key that always exists in the map, you are making the code less clear for developers and for the compiler, as they now need to work with the assumption the key may not be there. This mismatch may also make it harder to track certain bugs. If the key is unexpectedly missing, you will have a `nil` value propagate through the system, instead of raising on map access.\n\n##### Table: Comparison of map access notations\n\n| Access notation | Key exists | Key doesn't exist | Use case |\n| --------------- | ---------- | ----------------- | -------- |\n| `map.key` | Returns the value | Raises `KeyError` | Structs and maps with known atom keys |\n| `map[:key]` | Returns the value | Returns `nil` | Any `Access`-based data structure, optional keys |\n\n#### Example\n\nThe function `plot/1` tries to draw a graphic to represent the position of a point in a Cartesian plane. This function receives a parameter of `Map` type with the point attributes, which can be a point of a 2D or 3D Cartesian coordinate system. This function uses dynamic access to retrieve values for the map keys:\n\n```elixir\ndefmodule Graphics do\n def plot(point) do\n # Some other code...\n {point[:x], point[:y], point[:z]}\n end\nend\n```\n\n```elixir\niex> point_2d = %{x: 2, y: 3}\n%{x: 2, y: 3}\niex> point_3d = %{x: 5, y: 6, z: 7}\n%{x: 5, y: 6, z: 7}\niex> Graphics.plot(point_2d)\n{2, 3, nil}\niex> Graphics.plot(point_3d)\n{5, 6, 7}\n```\n\nGiven we want to plot both 2D and 3D points, the behavior above is expected. But what happens if we forget to pass a point with either `:x` or `:y`?\n\n```elixir\niex> bad_point = %{y: 3, z: 4}\n%{y: 3, z: 4}\niex> Graphics.plot(bad_point)\n{nil, 3, 4}\n```\n\nThe behavior above is unexpected because our function should not work with points without a `:x` key. This leads to subtle bugs, as we may now pass `nil` to another function, instead of raising early on, as shown next:\n\n```iex\niex> point_without_x = %{y: 10}\n%{y: 10}\niex> {x, y, _} = Graphics.plot(point_without_x)\n{nil, 10, nil}\niex> distance_from_origin = :math.sqrt(x * x + y * y)\n** (ArithmeticError) bad argument in arithmetic expression\n :erlang.*(nil, nil)\n```\n\nThe error above occurs later in the code because `nil` (from missing `:x`) is invalid for arithmetic operations, making it harder to identify the original issue.\n\n#### Refactoring\n\nTo remove this anti-pattern, we must use the dynamic `map[:key]` syntax and the static `map.key` notation according to our requirements. We expect `:x` and `:y` to always exist, but not `:z`. The next code illustrates the refactoring of `plot/1`, removing this anti-pattern:\n\n```elixir\ndefmodule Graphics do\n def plot(point) do\n # Some other code...\n {point.x, point.y, point[:z]}\n end\nend\n```\n\n```elixir\niex> Graphics.plot(point_2d)\n{2, 3, nil}\niex> Graphics.plot(bad_point)\n** (KeyError) key :x not found in: %{y: 3, z: 4}\n graphic.ex:4: Graphics.plot/1\n```\n\nThis is beneficial because:\n\n1. It makes your expectations clear to others reading the code\n2. It fails fast when required data is missing\n3. It allows the compiler to provide warnings when accessing non-existent fields, particularly in compile-time structures like structs\n\nOverall, the usage of `map.key` and `map[:key]` encode important information about your data structure, allowing developers to be clear about their intent. The `Access` module documentation also provides useful reference on this topic. You can also consider the `Map` module when working with maps of any keys, which contains functions for fetching keys (with or without default values), updating and removing keys, traversals, and more.\n\nAn alternative to refactor this anti-pattern is to use pattern matching, defining explicit clauses for 2D vs 3D points:\n\n```elixir\ndefmodule Graphics do\n # 3d\n def plot(%{x: x, y: y, z: z}) do\n # Some other code...\n {x, y, z}\n end\n\n # 2d\n def plot(%{x: x, y: y}) do\n # Some other code...\n {x, y}\n end\nend\n```\n\nPattern-matching is specially useful when matching over multiple keys as well as on the values themselves at once. In the example above, the code will not only extract the values but also verify that the required keys exist. If we try to call `plot/1` with a map that doesn't have the required keys, we'll get a `FunctionClauseError`:\n\n```elixir\niex> incomplete_point = %{x: 5}\n%{x: 5}\niex> Graphics.plot(incomplete_point)\n** (FunctionClauseError) no function clause matching in Graphics.plot/1\n\n The following arguments were given to Graphics.plot/1:\n\n # 1\n %{x: 5}\n```\n\nAnother option is to use structs. By default, structs only support static access to its fields. In such scenarios, you may consider defining structs for both 2D and 3D points:\n\n```elixir\ndefmodule Point2D do\n @enforce_keys [:x, :y]\n defstruct [x: nil, y: nil]\nend\n```\n\nGenerally speaking, structs are useful when sharing data structures across modules, at the cost of adding a compile time dependency between these modules. If module `A` uses a struct defined in module `B`, `A` must be recompiled if the fields in the struct `B` change.\n\nIn summary, Elixir provides several ways to access map values, each with different behaviors:\n\n1. **Static access** (`map.key`): Fails fast when keys are missing, ideal for structs and maps with known atom keys\n2. **Dynamic access** (`map[:key]`): Works with any `Access` data structure, suitable for optional fields, returns nil for missing keys\n3. **Pattern matching**: Provides a powerful way to both extract values and ensure required map/struct keys exist in one operation\n\nChoosing the right approach depends if the keys are known upfront or not. Static access and pattern matching are mostly equivalent (although pattern matching allows you to match on multiple keys at once, including matching on the struct name).\n\n#### Additional remarks\n\nThis anti-pattern was formerly known as [Accessing non-existent map/struct fields](https://github.com/lucasvegi/Elixir-Code-Smells#accessing-non-existent-mapstruct-fields).\n\n## Non-assertive pattern matching\n\n#### Problem\n\nOverall, Elixir systems are composed of many supervised processes, so the effects of an error are localized to a single process, and don't propagate to the entire application. A supervisor detects the failing process, reports it, and possibly restarts it. This anti-pattern arises when developers write defensive or imprecise code, capable of returning incorrect values which were not planned for, instead of programming in an assertive style through pattern matching and guards.\n\n#### Example\n\nThe function `get_value/2` tries to extract a value from a specific key of a URL query string. As it is not implemented using pattern matching, `get_value/2` always returns a value, regardless of the format of the URL query string passed as a parameter in the call. Sometimes the returned value will be valid. However, if a URL query string with an unexpected format is used in the call, `get_value/2` will extract incorrect values from it:\n\n```elixir\ndefmodule Extract do\n def get_value(string, desired_key) do\n parts = String.split(string, \"&\")\n\n Enum.find_value(parts, fn pair ->\n key_value = String.split(pair, \"=\")\n Enum.at(key_value, 0) == desired_key && Enum.at(key_value, 1)\n end)\n end\nend\n```\n\n```elixir\n# URL query string with the planned format - OK!\niex> Extract.get_value(\"name=Lucas&university=UFMG&lab=ASERG\", \"lab\")\n\"ASERG\"\niex> Extract.get_value(\"name=Lucas&university=UFMG&lab=ASERG\", \"university\")\n\"UFMG\"\n# Unplanned URL query string format - Unplanned value extraction!\niex> Extract.get_value(\"name=Lucas&university=institution=UFMG&lab=ASERG\", \"university\")\n\"institution\" # <= why not \"institution=UFMG\"? or only \"UFMG\"?\n```\n\n#### Refactoring\n\nTo remove this anti-pattern, `get_value/2` can be refactored through the use of pattern matching. So, if an unexpected URL query string format is used, the function will crash instead of returning an invalid value. This behavior, shown below, allows clients to decide how to handle these errors and doesn't give a false impression that the code is working correctly when unexpected values are extracted:\n\n```elixir\ndefmodule Extract do\n def get_value(string, desired_key) do\n parts = String.split(string, \"&\")\n\n Enum.find_value(parts, fn pair ->\n [key, value] = String.split(pair, \"=\") # <= pattern matching\n key == desired_key && value\n end)\n end\nend\n```\n\n```elixir\n# URL query string with the planned format - OK!\niex> Extract.get_value(\"name=Lucas&university=UFMG&lab=ASERG\", \"name\")\n\"Lucas\"\n# Unplanned URL query string format - Crash explaining the problem to the client!\niex> Extract.get_value(\"name=Lucas&university=institution=UFMG&lab=ASERG\", \"university\")\n** (MatchError) no match of right hand side value: [\"university\", \"institution\", \"UFMG\"]\n extract.ex:7: anonymous fn/2 in Extract.get_value/2 # <= left hand: [key, value] pair\niex> Extract.get_value(\"name=Lucas&university&lab=ASERG\", \"university\")\n** (MatchError) no match of right hand side value: [\"university\"]\n extract.ex:7: anonymous fn/2 in Extract.get_value/2 # <= left hand: [key, value] pair\n```\n\nElixir and pattern matching promote an assertive style of programming where you handle the known cases. Once an unexpected scenario arises, you can decide to address it accordingly based on practical examples, or conclude the scenario is indeed invalid and the exception is the desired choice.\n\n`case/2` is another important construct in Elixir that help us write assertive code, by matching on specific patterns. For example, if a function returns `{:ok, ...}` or `{:error, ...}`, prefer to explicitly match on both patterns:\n\n```elixir\ncase some_function(arg) do\n {:ok, value} -> # ...\n {:error, _} -> # ...\nend\n```\n\nIn particular, avoid matching solely on `_`, as shown below:\n\n```elixir\ncase some_function(arg) do\n {:ok, value} -> # ...\n _ -> # ...\nend\n```\n\n Matching on `_` is less clear in intent and it may hide bugs if `some_function/1` adds new return values in the future.\n\n#### Additional remarks\n\nThis anti-pattern was formerly known as [Speculative assumptions](https://github.com/lucasvegi/Elixir-Code-Smells#speculative-assumptions).\n\n## Non-assertive truthiness\n\n#### Problem\n\nElixir provides the concept of truthiness: `nil` and `false` are considered \"falsy\" and all other values are \"truthy\". Many constructs in the language, such as `&&/2`, `||/2`, and `!/1` handle truthy and falsy values. Using those operators is not an anti-pattern. However, using those operators when all operands are expected to be booleans, may be an anti-pattern.\n\n#### Example\n\nThe simplest scenario where this anti-pattern manifests is in conditionals, such as:\n\n```elixir\nif is_binary(name) && is_integer(age) do\n # ...\nelse\n # ...\nend\n```\n\nGiven both operands of `&&/2` are booleans, the code is more generic than necessary, and potentially unclear.\n\n#### Refactoring\n\nTo remove this anti-pattern, we can replace `&&/2`, `||/2`, and `!/1` by `and/2`, `or/2`, and `not/1` respectively. These operators assert at least their first argument is a boolean:\n\n```elixir\nif is_binary(name) and is_integer(age) do\n # ...\nelse\n # ...\nend\n```\n\nThis technique may be particularly important when working with Erlang code. Erlang does not have the concept of truthiness. It never returns `nil`, instead its functions may return `:error` or `:undefined` in places an Elixir developer would return `nil`. Therefore, to avoid accidentally interpreting `:undefined` or `:error` as a truthy value, you may prefer to use `and/2`, `or/2`, and `not/1` exclusively when interfacing with Erlang APIs.\n\n## Structs with 32 fields or more\n\n#### Problem\n\nStructs in Elixir are implemented as compile-time maps, which have a predefined amount of fields. When structs have 32 or more fields, their internal representation in the Erlang Virtual Machines changes, potentially leading to bloating and higher memory usage.\n\n#### Example\n\nAny struct with 32 or more fields will be problematic:\n\n```elixir\ndefmodule MyExample do\n defstruct [\n :field1,\n :field2,\n ...,\n :field35\n ]\nend\n```\n\nThe Erlang VM has two internal representations for maps: a flat map and a hash map. A flat map is represented internally as two tuples: one tuple containing the keys and another tuple holding the values. Whenever you update a flat map, the tuple keys are shared, reducing the amount of memory used by the update. A hash map has a more complex structure, which is efficient for a large amount of keys, but it does not share the key space.\n\nMaps of up to 32 keys are represented as flat maps. All others are hash map. Structs *are* maps (with a metadata field called `__struct__`) and so any struct with fewer than 32 fields is represented as a flat map. This allows us to optimize several struct operations, as we never add or remove fields to structs, we simply update them.\n\nFurthermore, structs of the same name \"instantiated\" in the same module will share the same \"tuple keys\" at compilation times, as long as they have fewer than 32 fields. For example, in the following code:\n\n```elixir\ndefmodule Example do\n def users do\n [%User{name: \"John\"}, %User{name: \"Meg\"}, ...]\n end\nend\n```\n\nAll user structs will point to the same tuple keys at compile-time, also reducing the memory cost of instantiating structs with `%MyStruct{...}` notation. This optimization is also not available if the struct has 32 keys or more.\n\n#### Refactoring\n\nRemoving this anti-pattern, in a nutshell, requires ensuring your struct has fewer than 32 fields. There are a few techniques you could apply:\n\n * If the struct has \"optional\" fields, for example, fields which are initialized with nil, you could nest all optional fields into other field, called `:metadata`, `:optionals`, or similar. This could lead to benefits such as being able to use pattern matching to check if a field exists or not, instead of relying on `nil` values\n\n * You could nest structs, by storing structs within other fields. Fields that are rarely read or written to are good candidates to be moved to a nested struct\n\n * You could nest fields as tuples. For example, if two fields are always read or updated together, they could be moved to a tuple (or another composite data structure)\n\nThe challenge is to balance the changes above with API ergonomics, in particular, when fields may be frequently read and written to.\n" }, { "path": "lib/elixir/pages/anti-patterns/design-anti-patterns.md", "content": "\n\n# Design-related anti-patterns\n\nThis document outlines potential anti-patterns related to your modules, functions, and the role they play within a codebase.\n\n## Alternative return types\n\n#### Problem\n\nThis anti-pattern refers to functions that receive options (typically as a *keyword list* parameter) that drastically change their return type. Because options are optional and sometimes set dynamically, if they also change the return type, it may be hard to understand what the function actually returns.\n\n#### Example\n\nAn example of this anti-pattern, as shown below, is when a function has many alternative return types, depending on the options received as a parameter.\n\n```elixir\ndefmodule AlternativeInteger do\n @spec parse(String.t(), keyword()) :: integer() | {integer(), String.t()} | :error\n def parse(string, options \\\\ []) when is_list(options) do\n if Keyword.get(options, :discard_rest, false) do\n case Integer.parse(string) do\n {int, _rest} -> int\n :error -> :error\n end\n else\n Integer.parse(string)\n end\n end\nend\n```\n\n```elixir\niex> AlternativeInteger.parse(\"13\")\n{13, \"\"}\niex> AlternativeInteger.parse(\"13\", discard_rest: false)\n{13, \"\"}\niex> AlternativeInteger.parse(\"13\", discard_rest: true)\n13\n```\n\n#### Refactoring\n\nTo refactor this anti-pattern, as shown next, add a specific function for each return type (for example, `parse_discard_rest/1`), no longer delegating this to options passed as arguments.\n\n```elixir\ndefmodule AlternativeInteger do\n @spec parse(String.t()) :: {integer(), String.t()} | :error\n def parse(string) do\n Integer.parse(string)\n end\n\n @spec parse_discard_rest(String.t()) :: integer() | :error\n def parse_discard_rest(string) do\n case Integer.parse(string) do\n {int, _rest} -> int\n :error -> :error\n end\n end\nend\n```\n\n```elixir\niex> AlternativeInteger.parse(\"13\")\n{13, \"\"}\niex> AlternativeInteger.parse_discard_rest(\"13\")\n13\n```\n\n## Boolean obsession\n\n#### Problem\n\nThis anti-pattern happens when booleans are used instead of atoms to encode information. The usage of booleans themselves is not an anti-pattern, but whenever multiple booleans are used with overlapping states, replacing the booleans by atoms (or composite data types such as *tuples*) may lead to clearer code.\n\nThis is a special case of [*Primitive obsession*](#primitive-obsession), specific to boolean values.\n\n#### Example\n\nAn example of this anti-pattern is a function that receives two or more options, such as `editor: true` and `admin: true`, to configure its behavior in overlapping ways. In the code below, the `:editor` option has no effect if `:admin` is set, meaning that the `:admin` option has higher priority than `:editor`, and they are ultimately related.\n\n```elixir\ndefmodule MyApp do\n def process(invoice, options \\\\ []) do\n cond do\n options[:admin] -> # Is an admin\n options[:editor] -> # Is an editor\n true -> # Is none\n end\n end\nend\n```\n\n#### Refactoring\n\nInstead of using multiple options, the code above could be refactored to receive a single option, called `:role`, that can be either `:admin`, `:editor`, or `:default`:\n\n```elixir\ndefmodule MyApp do\n def process(invoice, options \\\\ []) do\n case Keyword.get(options, :role, :default) do\n :admin -> # Is an admin\n :editor -> # Is an editor\n :default -> # Is none\n end\n end\nend\n```\n\nThis anti-pattern may also happen in our own data structures. For example, we may define a `User` struct with two boolean fields, `:editor` and `:admin`, while a single field named `:role` may be preferred.\n\nFinally, it is worth noting that using atoms may be preferred even when we have a single boolean argument/option. For example, consider an invoice which may be set as approved/unapproved. One option is to provide a function that expects a boolean:\n\n```elixir\nMyApp.update(invoice, approved: true)\n```\n\nHowever, using atoms may read better and make it simpler to add further states (such as pending) in the future:\n\n```elixir\nMyApp.update(invoice, status: :approved)\n```\n\nRemember booleans are internally represented as atoms. Therefore there is no performance penalty in one approach over the other.\n\n## Exceptions for control-flow\n\n#### Problem\n\nThis anti-pattern refers to code that uses `Exception`s for control flow. Exception handling itself does not represent an anti-pattern, but developers must prefer to use `case` and pattern matching to change the flow of their code, instead of `try/rescue`. In turn, library authors should provide developers with APIs to handle errors without relying on exception handling. When developers have no freedom to decide if an error is exceptional or not, this is considered an anti-pattern.\n\n#### Example\n\nAn example of this anti-pattern, as shown below, is using `try/rescue` to deal with file operations:\n\n```elixir\ndefmodule MyModule do\n def print_file(file) do\n try do\n IO.puts(File.read!(file))\n rescue\n e -> IO.puts(:stderr, Exception.message(e))\n end\n end\nend\n```\n\n```elixir\niex> MyModule.print_file(\"valid_file\")\nThis is a valid file!\n:ok\niex> MyModule.print_file(\"invalid_file\")\ncould not read file \"invalid_file\": no such file or directory\n:ok\n```\n\n#### Refactoring\n\nTo refactor this anti-pattern, as shown next, use `File.read/1`, which returns tuples instead of raising when a file cannot be read:\n\n```elixir\ndefmodule MyModule do\n def print_file(file) do\n case File.read(file) do\n {:ok, binary} -> IO.puts(binary)\n {:error, reason} -> IO.puts(:stderr, \"could not read file #{file}: #{reason}\")\n end\n end\nend\n```\n\nThis is only possible because the `File` module provides APIs for reading files with tuples as results (`File.read/1`), as well as a version that raises an exception (`File.read!/1`). The bang (exclamation point) is effectively part of [Elixir's naming conventions](naming-conventions.md#trailing-bang-foo).\n\nLibrary authors are encouraged to follow the same practices. In practice, the bang variant is implemented on top of the non-raising version of the code. For example, `File.read!/1` is implemented as:\n\n```elixir\ndef read!(path) do\n case read(path) do\n {:ok, binary} ->\n binary\n\n {:error, reason} ->\n raise File.Error, reason: reason, action: \"read file\", path: IO.chardata_to_string(path)\n end\nend\n```\n\nA common practice followed by the community is to make the non-raising version return `{:ok, result}` or `{:error, Exception.t}`. For example, an HTTP client may return `{:ok, %HTTP.Response{}}` on success cases and `{:error, %HTTP.Error{}}` for failures, where `HTTP.Error` is [implemented as an exception](`Kernel.defexception/1`). This makes it convenient for anyone to raise an exception by simply calling `Kernel.raise/1`.\n\n#### Additional remarks\n\nThis anti-pattern is of special importance to library authors and whenever writing functions that will be invoked by other developers and third-party code. Nevertheless, there are still scenarios where developers can afford to raise exceptions directly, for example:\n\n * invalid arguments: it is expected that functions will raise for invalid arguments, as those are structural error and not semantic errors. For example, `File.read(123)` will always raise, because `123` is never a valid filename\n\n * during tests, scripts, etc: those are common scenarios where you want your code to fail as soon as possible in case of errors. Using `!` functions, such as `File.read!/1`, allows you to do so quickly and with clear error messages\n\n * some frameworks, such as [Phoenix](https://phoenixframework.org), allow developers to raise exceptions in their code and uses a protocol to convert these exceptions into semantic HTTP responses\n\nThis anti-pattern was formerly known as [Using exceptions for control-flow](https://github.com/lucasvegi/Elixir-Code-Smells#using-exceptions-for-control-flow).\n\n## Primitive obsession\n\n#### Problem\n\nThis anti-pattern happens when Elixir basic types (for example, *integer*, *float*, and *string*) are excessively used to carry structured information, rather than creating specific composite data types (for example, *tuples*, *maps*, and *structs*) that can better represent a domain.\n\n#### Example\n\nAn example of this anti-pattern is the use of a single *string* to represent an `Address`. An `Address` is a more complex structure than a simple basic (aka, primitive) value.\n\n```elixir\ndefmodule MyApp do\n def extract_postal_code(address) when is_binary(address) do\n # Extract postal code with address...\n end\n\n def fill_in_country(address) when is_binary(address) do\n # Fill in missing country...\n end\nend\n```\n\nWhile you may receive the `address` as a string from a database, web request, or a third-party, if you find yourself frequently manipulating or extracting information from the string, it is a good indicator you should convert the address into structured data:\n\nAnother example of this anti-pattern is using floating numbers to model money and currency, when [richer data structures should be preferred](https://hexdocs.pm/ex_money/).\n\n#### Refactoring\n\nPossible solutions to this anti-pattern is to use maps or structs to model our address. The example below creates an `Address` struct, better representing this domain through a composite type. Additionally, we introduce a `parse/1` function, that converts the string into an `Address`, which will simplify the logic of remaining functions. With this modification, we can extract each field of this composite type individually when needed.\n\n```elixir\ndefmodule Address do\n defstruct [:street, :city, :state, :postal_code, :country]\nend\n```\n\n```elixir\ndefmodule MyApp do\n def parse(address) when is_binary(address) do\n # Returns %Address{}\n end\n\n def extract_postal_code(%Address{} = address) do\n # Extract postal code with address...\n end\n\n def fill_in_country(%Address{} = address) do\n # Fill in missing country...\n end\nend\n```\n\n## Unrelated multi-clause function\n\n#### Problem\n\nUsing multi-clause functions is a powerful Elixir feature. However, some developers may abuse this feature to group *unrelated* functionality, which is an anti-pattern.\n\n#### Example\n\nA frequent example of this usage of multi-clause functions occurs when developers mix unrelated business logic into the same function definition, in a way that the behavior of each clause becomes completely distinct from the others. Such functions often have too broad specifications, making it difficult for other developers to understand and maintain them.\n\nSome developers may use documentation mechanisms such as `@doc` annotations to compensate for poor code readability, however the documentation itself may end-up full of conditionals to describe how the function behaves for each different argument combination. This is a good indicator that the clauses are ultimately unrelated.\n\n```elixir\n@doc \"\"\"\nUpdates a struct.\n\nIf given a product, it will...\n\nIf given an animal, it will...\n\"\"\"\ndef update(%Product{count: count, material: material}) do\n # ...\nend\n\ndef update(%Animal{count: count, skin: skin}) do\n # ...\nend\n```\n\nIf updating an animal is completely different from updating a product and requires a different set of rules, it may be worth splitting those over different functions or even different modules.\n\n#### Refactoring\n\nAs shown below, a possible solution to this anti-pattern is to break the business rules that are mixed up in a single unrelated multi-clause function in simple functions. Each function can have a specific name and `@doc`, describing its behavior and parameters received. While this refactoring sounds simple, it can impact the function's callers, so be careful!\n\n```elixir\n@doc \"\"\"\nUpdates a product.\n\nIt will...\n\"\"\"\ndef update_product(%Product{count: count, material: material}) do\n # ...\nend\n\n@doc \"\"\"\nUpdates an animal.\n\nIt will...\n\"\"\"\ndef update_animal(%Animal{count: count, skin: skin}) do\n # ...\nend\n```\n\nThese functions may still be implemented with multiple clauses, as long as the clauses group related functionality. For example, `update_product` could be in practice implemented as follows:\n\n```elixir\ndef update_product(%Product{count: 0}) do\n # ...\nend\n\ndef update_product(%Product{material: material})\n when material in [\"metal\", \"glass\"] do\n # ...\nend\n\ndef update_product(%Product{material: material})\n when material not in [\"metal\", \"glass\"] do\n # ...\nend\n```\n\nYou can see this pattern in practice within Elixir itself. The `+/2` operator can add `Integer`s and `Float`s together, but not `String`s, which instead use the `<>/2` operator. In this sense, it is reasonable to handle integers and floats in the same operation, but strings are unrelated enough to deserve their own function.\n\nYou will also find examples in Elixir of functions that work with any struct, which would seemingly be an occurrence of this anti-pattern, such as `struct/2`:\n\n```elixir\niex> struct(URI.parse(\"/foo/bar\"), path: \"/bar/baz\")\n%URI{\n scheme: nil,\n userinfo: nil,\n host: nil,\n port: nil,\n path: \"/bar/baz\",\n query: nil,\n fragment: nil\n}\n```\n\nThe difference here is that the `struct/2` function behaves precisely the same for any struct given, therefore there is no question of how the function handles different inputs. If the behavior is clear and consistent for all inputs, then the anti-pattern does not take place.\n\n## Using application configuration for libraries\n\n#### Problem\n\nThe [*application environment*](https://hexdocs.pm/elixir/Application.html#module-the-application-environment) can be used to parameterize global values that can be used in an Elixir system. This mechanism can be very useful and therefore is not considered an anti-pattern by itself. However, library authors should avoid using the application environment to configure their library. The reason is exactly that the application environment is a **global** state, so there can only be a single value for each key in the environment for an application. This makes it impossible for multiple applications depending on the same library to configure the same aspect of the library in different ways.\n\n#### Example\n\nThe `DashSplitter` module represents a library that configures the behavior of its functions through the global application environment. These configurations are concentrated in the *config/config.exs* file, shown below:\n\n```elixir\nimport Config\n\nconfig :app_config,\n parts: 3\n\nimport_config \"#{config_env()}.exs\"\n```\n\nOne of the functions implemented by the `DashSplitter` library is `split/1`. This function aims to separate a string received via a parameter into a certain number of parts. The character used as a separator in `split/1` is always `\"-\"` and the number of parts the string is split into is defined globally by the application environment. This value is retrieved by the `split/1` function by calling `Application.fetch_env!/2`, as shown next:\n\n```elixir\ndefmodule DashSplitter do\n def split(string) when is_binary(string) do\n parts = Application.fetch_env!(:app_config, :parts) # <= retrieve parameterized value\n String.split(string, \"-\", parts: parts) # <= parts: 3\n end\nend\n```\n\nDue to this parameterized value used by the `DashSplitter` library, all applications dependent on it can only use the `split/1` function with identical behavior about the number of parts generated by string separation. Currently, this value is equal to 3, as we can see in the use examples shown below:\n\n```elixir\niex> DashSplitter.split(\"Lucas-Francisco-Vegi\")\n[\"Lucas\", \"Francisco\", \"Vegi\"]\niex> DashSplitter.split(\"Lucas-Francisco-da-Matta-Vegi\")\n[\"Lucas\", \"Francisco\", \"da-Matta-Vegi\"]\n```\n\n#### Refactoring\n\nTo remove this anti-pattern, this type of configuration should be performed using a parameter passed to the function. The code shown below performs the refactoring of the `split/1` function by accepting [keyword lists](`Keyword`) as a new optional parameter. With this new parameter, it is possible to modify the default behavior of the function at the time of its call, allowing multiple different ways of using `split/2` within the same application:\n\n```elixir\ndefmodule DashSplitter do\n def split(string, opts \\\\ []) when is_binary(string) and is_list(opts) do\n parts = Keyword.get(opts, :parts, 2) # <= default config of parts == 2\n String.split(string, \"-\", parts: parts)\n end\nend\n```\n\n```elixir\niex> DashSplitter.split(\"Lucas-Francisco-da-Matta-Vegi\", [parts: 5])\n[\"Lucas\", \"Francisco\", \"da\", \"Matta\", \"Vegi\"]\niex> DashSplitter.split(\"Lucas-Francisco-da-Matta-Vegi\") #<= default config is used!\n[\"Lucas\", \"Francisco-da-Matta-Vegi\"]\n```\n\nOf course, not all uses of the application environment by libraries are incorrect. One example is using configuration to replace a component (or dependency) of a library by another that must behave the exact same. Consider a library that needs to parse CSV files. The library author may pick one package to use as default parser but allow its users to swap to different implementations via the application environment. At the end of the day, choosing a different CSV parser should not change the outcome, and library authors can even enforce this by [defining behaviours](../references/typespecs.md#behaviours) with the exact semantics they expect.\n\n#### Additional remarks: Supervision trees\n\nIn practice, libraries may require additional configuration beyond keyword lists. For example, if a library needs to start a supervision tree, how can the user of said library customize its supervision tree? Given the supervision tree itself is global (as it belongs to the library), library authors may be tempted to use the application configuration once more.\n\nOne solution is for the library to provide its own child specification, instead of starting the supervision tree itself. This allows the user to start all necessary processes under its own supervision tree, potentially passing custom configuration options during initialization.\n\nYou can see this pattern in practice in projects like [Nx](https://github.com/elixir-nx/nx) and [DNS Cluster](https://github.com/phoenixframework/dns_cluster). These libraries require that you list processes under your own supervision tree:\n\n```elixir\nchildren = [\n {DNSCluster, query: \"my.subdomain\"}\n]\n```\n\nIn such cases, if the users of `DNSCluster` need to configure DNSCluster per environment, they can be the ones reading from the application environment, without the library forcing them to:\n\n```elixir\nchildren = [\n {DNSCluster, query: Application.get_env(:my_app, :dns_cluster_query) || :ignore}\n]\n```\n\nSome libraries, such as [Ecto](https://github.com/elixir-ecto/ecto), allow you to pass your application name as an option (called `:otp_app` or similar) and then automatically read the environment from *your* application. While this addresses the issue with the application environment being global, as they read from each individual application, it comes at the cost of some indirection, compared to the example above where users explicitly read their application environment from their own code, whenever desired.\n\n#### Additional remarks: Compile-time configuration\n\nA similar discussion entails compile-time configuration. What if a library author requires some configuration to be provided at compilation time?\n\nOnce again, instead of forcing users of your library to provide compile-time configuration, you may want to allow users of your library to generate the code themselves. That's the approach taken by libraries such as [Ecto](https://github.com/elixir-ecto/ecto):\n\n```elixir\ndefmodule MyApp.Repo do\n use Ecto.Repo, adapter: Ecto.Adapters.Postgres\nend\n```\n\nInstead of forcing developers to share a single repository, Ecto allows its users to define as many repositories as they want. Given the `:adapter` configuration is required at compile-time, it is a required value on `use Ecto.Repo`. If developers want to configure the adapter per environment, then it is their choice:\n\n```elixir\ndefmodule MyApp.Repo do\n use Ecto.Repo, adapter: Application.compile_env(:my_app, :repo_adapter)\nend\n```\n\nOn the other hand, [code generation comes with its own anti-patterns](macro-anti-patterns.md), and must be considered carefully. That's to say: while using the application environment for libraries is discouraged, especially compile-time configuration, in some cases they may be the best option. For example, consider a library needs to parse CSV or JSON files to generate code based on data files. In such cases, it is best to provide reasonable defaults and make them customizable via the application environment, instead of asking each user of your library to generate the exact same code.\n\n#### Additional remarks: Mix tasks\n\nFor Mix tasks and related tools, it may be necessary to provide per-project configuration. For example, imagine you have a `:linter` project, which supports setting the output file and the verbosity level. You may choose to configure it through application environment:\n\n```elixir\nconfig :linter,\n output_file: \"/path/to/output.json\",\n verbosity: 3\n```\n\nHowever, `Mix` allows tasks to read per-project configuration via `Mix.Project.config/0`. In this case, you can configure the `:linter` directly in the `mix.exs` file:\n\n```elixir\ndef project do\n [\n app: :my_app,\n version: \"1.0.0\",\n linter: [\n output_file: \"/path/to/output.json\",\n verbosity: 3\n ],\n ...\n ]\nend\n```\n\nAdditionally, if a Mix task is available, you can also accept these options as command line arguments (see `OptionParser`):\n\n```bash\nmix linter --output-file /path/to/output.json --verbosity 3\n```\n" }, { "path": "lib/elixir/pages/anti-patterns/macro-anti-patterns.md", "content": "\n\n# Meta-programming anti-patterns\n\nThis document outlines potential anti-patterns related to meta-programming.\n\n## Compile-time dependencies\n\n#### Problem\n\nThis anti-pattern is related to dependencies between files in Elixir. Because macros are used at compile-time, the use of any macro in Elixir adds a compile-time dependency to the module that defines the macro.\n\nHowever, when macros are used in the body of a module, the arguments to the macro themselves may become compile-time dependencies. These dependencies may lead to dependency graphs where changing a single file causes several files to be recompiled.\n\n#### Example\n\nLet's take the [`Plug`](https://github.com/elixir-plug/plug) library as an example. The `Plug` project allows you to specify several modules, also known as plugs, which will be invoked whenever there is a request. As a user of `Plug`, you would use it as follows:\n\n```elixir\ndefmodule MyApp do\n use Plug.Builder\n\n plug MyApp.Authentication\nend\n```\n\nAnd imagine `Plug` has the following definitions of the macros above (simplified):\n\n```elixir\ndefmodule Plug.Builder do\n defmacro __using__(_opts) do\n quote do\n Module.register_attribute(__MODULE__, :plugs, accumulate: true)\n @before_compile Plug.Builder\n end\n end\n\n defmacro plug(mod) do\n quote do\n @plugs unquote(mod)\n end\n end\n\n ...\nend\n```\n\nThe implementation accumulates all modules inside the `@plugs` module attribute. Right before the module is compiled, `Plug.Builder` will reads all modules stored in `@plugs` and compile them into a function, like this:\n\n```elixir\ndef call(conn, _opts) do\n MyApp.Authentication.call(conn)\nend\n```\n\nThe trouble with the code above is that, because the `plug MyApp.Authentication` was invoked at compile-time, the module `MyApp.Authentication` is now a compile-time dependency of `MyApp`, even though `MyApp.Authentication` is never used at compile-time. If `MyApp.Authentication` depends on other modules, even at runtime, this can now lead to a large recompilation graph in case of changes.\n\n#### Refactoring\n\nTo address this anti-pattern, a macro can expand literals within the context they are meant to be used, as follows:\n\n```elixir\n defmacro plug(mod) do\n mod = Macro.expand_literals(mod, %{__CALLER__ | function: {:call, 2}})\n\n quote do\n @plugs unquote(mod)\n end\n end\n```\n\nIn the example above, since `mod` is used only within the `call/2` function, we prematurely expand module reference as if it was inside the `call/2` function. Now `MyApp.Authentication` is only a runtime dependency of `MyApp`, no longer a compile-time one.\n\nNote, however, the above must only be done if your macros do not attempt to invoke any function, access any struct, or any other metadata of the module at compile-time. If you interact with the module given to a macro anywhere outside of definition of a function, then you effectively have a compile-time dependency. And, even though you generally want to avoid them, it is not always possible.\n\nIn actual projects, developers may use `mix xref trace path/to/file.ex` to execute a file and have it print information about which modules it depends on, and if those modules are compile-time, runtime, or export dependencies. See `mix xref` for more information.\n\n## Large code generation\n\n#### Problem\n\nThis anti-pattern is related to macros that generate too much code. When a macro generates a large amount of code, it impacts how the compiler and/or the runtime work. The reason for this is that Elixir may have to expand, compile, and execute the code multiple times, which will make compilation slower and the resulting compiled artifacts larger.\n\n#### Example\n\nImagine you are defining a router for a web application, where you could have macros like `get/2`. On every invocation of the macro (which could be hundreds), the code inside `get/2` will be expanded and compiled, which can generate a large volume of code overall.\n\n```elixir\ndefmodule Routes do\n defmacro get(route, handler) do\n quote do\n route = unquote(route)\n handler = unquote(handler)\n\n if not is_binary(route) do\n raise ArgumentError, \"route must be a binary\"\n end\n\n if not is_atom(handler) do\n raise ArgumentError, \"handler must be a module\"\n end\n\n @store_route_for_compilation {route, handler}\n end\n end\nend\n```\n\n#### Refactoring\n\nTo remove this anti-pattern, the developer should simplify the macro, delegating part of its work to other functions. As shown below, by encapsulating the code inside `quote/1` inside the function `__define__/3` instead, we reduce the code that is expanded and compiled on every invocation of the macro, and instead we dispatch to a function to do the bulk of the work.\n\n```elixir\ndefmodule Routes do\n defmacro get(route, handler) do\n quote do\n Routes.__define__(__MODULE__, unquote(route), unquote(handler))\n end\n end\n\n def __define__(module, route, handler) do\n if not is_binary(route) do\n raise ArgumentError, \"route must be a binary\"\n end\n\n if not is_atom(handler) do\n raise ArgumentError, \"handler must be a module\"\n end\n\n Module.put_attribute(module, :store_route_for_compilation, {route, handler})\n end\nend\n```\n\n## Unnecessary macros\n\n#### Problem\n\n*Macros* are powerful meta-programming mechanisms that can be used in Elixir to extend the language. While using macros is not an anti-pattern in itself, this meta-programming mechanism should only be used when absolutely necessary. Whenever a macro is used, but it would have been possible to solve the same problem using functions or other existing Elixir structures, the code becomes unnecessarily more complex and less readable. Because macros are more difficult to implement and reason about, their indiscriminate use can compromise the evolution of a system, reducing its maintainability.\n\n#### Example\n\nThe `MyMath` module implements the `sum/2` macro to perform the sum of two numbers received as parameters. While this code has no syntax errors and can be executed correctly to get the desired result, it is unnecessarily more complex. By implementing this functionality as a macro rather than a conventional function, the code became less clear:\n\n```elixir\ndefmodule MyMath do\n defmacro sum(v1, v2) do\n quote do\n unquote(v1) + unquote(v2)\n end\n end\nend\n```\n\n```elixir\niex> require MyMath\nMyMath\niex> MyMath.sum(3, 5)\n8\niex> MyMath.sum(3 + 1, 5 + 6)\n15\n```\n\n#### Refactoring\n\nTo remove this anti-pattern, the developer must replace the unnecessary macro with structures that are simpler to write and understand, such as named functions. The code shown below is the result of the refactoring of the previous example. Basically, the `sum/2` macro has been transformed into a conventional named function. Note that the `require/2` call is no longer needed:\n\n```elixir\ndefmodule MyMath do\n def sum(v1, v2) do # <= The macro became a named function\n v1 + v2\n end\nend\n```\n\n```elixir\niex> MyMath.sum(3, 5)\n8\niex> MyMath.sum(3+1, 5+6)\n15\n```\n\n## `use` instead of `import`\n\n#### Problem\n\nElixir has mechanisms such as `import/1`, `alias/1`, and `use/1` to establish dependencies between modules. Code implemented with these mechanisms does not characterize a smell by itself. However, while the `import/1` and `alias/1` directives have lexical scope and only facilitate a module calling functions of another, the `use/1` directive has a *broader scope*, which can be problematic.\n\nThe `use/1` directive allows a module to inject any type of code into another, including propagating dependencies. In this way, using the `use/1` directive makes code harder to read, because to understand exactly what will happen when it references a module, it is necessary to have knowledge of the internal details of the referenced module.\n\n#### Example\n\nThe code shown below is an example of this anti-pattern. It defines three modules -- `ModuleA`, `Library`, and `ClientApp`. `ClientApp` is reusing code from the `Library` via the `use/1` directive, but is unaware of its internal details. This makes it harder for the author of `ClientApp` to visualize which modules and functionality are now available within its module. To make matters worse, `Library` also imports `ModuleA`, which defines a `foo/0` function that conflicts with a local function defined in `ClientApp`:\n\n```elixir\ndefmodule ModuleA do\n def foo do\n \"From Module A\"\n end\nend\n```\n\n```elixir\ndefmodule Library do\n defmacro __using__(_opts) do\n quote do\n import Library\n import ModuleA # <= propagating dependencies!\n end\n end\n\n def from_lib do\n \"From Library\"\n end\nend\n```\n\n```elixir\ndefmodule ClientApp do\n use Library\n\n def foo do\n \"Local function from client app\"\n end\n\n def from_client_app do\n from_lib() <> \" - \" <> foo()\n end\nend\n```\n\nWhen we try to compile `ClientApp`, Elixir detects the conflict and throws the following error:\n\n```text\nerror: imported ModuleA.foo/0 conflicts with local function\n └ client_app.ex:4:\n```\n\n#### Refactoring\n\nTo remove this anti-pattern, we recommend library authors avoid providing `__using__/1` callbacks whenever it can be replaced by `alias/1` or `import/1` directives. In the following code, we assume `use Library` is no longer available and `ClientApp` was refactored in this way, and with that, the code is clearer and the conflict as previously shown no longer exists:\n\n```elixir\ndefmodule ClientApp do\n import Library\n\n def foo do\n \"Local function from client app\"\n end\n\n def from_client_app do\n from_lib() <> \" - \" <> foo()\n end\nend\n```\n\n```elixir\niex> ClientApp.from_client_app()\n\"From Library - Local function from client app\"\n```\n\n#### Additional remarks\n\nIn situations where you need to do more than importing and aliasing modules, providing `use MyModule` may be necessary, as it provides a common extension point within the Elixir ecosystem.\n\nTherefore, to provide guidance and clarity, we recommend library authors to include an admonition block in their `@moduledoc` that explains how `use MyModule` impacts the developer's code. As an example, the `GenServer` documentation outlines:\n\n> #### `use GenServer` {: .info}\n>\n> When you `use GenServer`, the `GenServer` module will\n> set `@behaviour GenServer` and define a `child_spec/1`\n> function, so your module can be used as a child\n> in a supervision tree.\n\nThink of this summary as a [\"Nutrition facts label\"](https://en.wikipedia.org/wiki/Nutrition_facts_label) for code generation. Make sure to only list changes made to the public API of the module. For example, if `use Library` sets an internal attribute called `@_some_module_info` and this attribute is never meant to be public, avoid documenting it in the nutrition facts.\n\nFor convenience, the markup notation to generate the admonition block above is this:\n\n```markdown\n> #### `use GenServer` {: .info}\n>\n> When you `use GenServer`, the `GenServer` module will\n> set `@behaviour GenServer` and define a `child_spec/1`\n> function, so your module can be used as a child\n> in a supervision tree.\n```\n\n## Untracked compile-time dependencies\n\n#### Problem\n\nThis anti-pattern is the opposite of [\"Compile-time dependencies\"](#compile-time-dependencies) and it happens when a compile-time dependency is accidentally bypassed, making the Elixir compiler unable to track dependencies and recompile files correctly. This happens when building aliases (in other words, module names) dynamically, either within a module or within a macro.\n\n#### Example\n\nFor example, imagine you invoke a module at compile-time, you could write it as such:\n\n```elixir\ndefmodule MyModule do\n SomeOtherModule.example()\nend\n```\n\nIn this case, Elixir knows `MyModule` is invoked `SomeOtherModule.example/0` outside of a function, and therefore at compile-time.\n\nElixir can also track module names even during dynamic calls:\n\n```elixir\ndefmodule MyModule do\n mods = [OtherModule.Foo, OtherModule.Bar]\n\n for mod <- mods do\n mod.example()\n end\nend\n```\n\nIn the previous example, even though Elixir does not know which modules the function `example/0` was invoked on, it knows the modules `OtherModule.Foo` and `OtherModule.Bar` are referred outside of a function and therefore they become compile-time dependencies. If any of them change, Elixir will recompile `MyModule` itself.\n\nHowever, you should not programmatically generate the module names themselves, as that would make it impossible for Elixir to track them. More precisely, do not do this:\n\n```elixir\ndefmodule MyModule do\n parts = [:Foo, :Bar]\n\n for part <- parts do\n Module.concat(OtherModule, part).example()\n end\nend\n```\n\nIn this case, because the whole module was generated, Elixir sees a dependency only to `OtherModule`, never to `OtherModule.Foo` and `OtherModule.Bar`, potentially leading to inconsistencies when recompiling projects.\n\nA similar bug can happen when abusing the property that aliases are simply atoms, defining the atoms directly. In the case below, Elixir never sees the aliases, leading to untracked compile-time dependencies:\n\n```elixir\ndefmodule MyModule do\n mods = [:\"Elixir.OtherModule.Foo\", :\"Elixir.OtherModule.Bar\"]\n\n for mod <- mods do\n mod.example()\n end\nend\n```\n\n#### Refactoring\n\nTo address this anti-pattern, you should avoid defining module names programmatically. For example, if you need to dispatch to multiple modules, do so by using full module names.\n\nInstead of:\n\n```elixir\ndefmodule MyModule do\n parts = [:Foo, :Bar]\n\n for part <- parts do\n Module.concat(OtherModule, part).example()\n end\nend\n```\n\nDo:\n\n```elixir\ndefmodule MyModule do\n mods = [OtherModule.Foo, OtherModule.Bar]\n\n for mod <- mods do\n mod.example()\n end\nend\n```\n\nIf you really need to define modules dynamically, you can do so via meta-programming, building the whole module name at compile-time:\n\n```elixir\ndefmodule MyMacro do\n defmacro call_examples(parts) do\n for part <- parts do\n quote do\n # This builds OtherModule.Foo at compile-time\n OtherModule.unquote(part).example()\n end\n end\n end\nend\n\ndefmodule MyModule do\n import MyMacro\n call_examples [:Foo, :Bar]\nend\n```\n\nIn actual projects, developers may use `mix xref trace path/to/file.ex` to execute a file and have it print information about which modules it depends on, and if those modules are compile-time, runtime, or export dependencies. This can help you debug if the dependencies are being properly tracked in relation to external modules. See `mix xref` for more information.\n" }, { "path": "lib/elixir/pages/anti-patterns/process-anti-patterns.md", "content": "\n\n# Process-related anti-patterns\n\nThis document outlines potential anti-patterns related to processes and process-based abstractions.\n\n## Code organization by process\n\n#### Problem\n\nThis anti-pattern refers to code that is unnecessarily organized by processes. A process itself does not represent an anti-pattern, but it should only be used to model runtime properties (such as concurrency, access to shared resources, error isolation, etc). When you use a process for code organization, it can create bottlenecks in the system.\n\n#### Example\n\nAn example of this anti-pattern, as shown below, is a module that implements arithmetic operations (like `add` and `subtract`) by means of a `GenServer` process. If the number of calls to this single process grows, this code organization can compromise the system performance, therefore becoming a bottleneck.\n\n```elixir\ndefmodule Calculator do\n @moduledoc \"\"\"\n Calculator that performs basic arithmetic operations.\n\n This code is unnecessarily organized in a GenServer process.\n \"\"\"\n\n use GenServer\n\n def add(a, b, pid) do\n GenServer.call(pid, {:add, a, b})\n end\n\n def subtract(a, b, pid) do\n GenServer.call(pid, {:subtract, a, b})\n end\n\n @impl GenServer\n def init(init_arg) do\n {:ok, init_arg}\n end\n\n @impl GenServer\n def handle_call({:add, a, b}, _from, state) do\n {:reply, a + b, state}\n end\n\n def handle_call({:subtract, a, b}, _from, state) do\n {:reply, a - b, state}\n end\nend\n```\n\n```elixir\niex> {:ok, pid} = GenServer.start_link(Calculator, :init)\n{:ok, #PID<0.132.0>}\niex> Calculator.add(1, 5, pid)\n6\niex> Calculator.subtract(2, 3, pid)\n-1\n```\n\n#### Refactoring\n\nIn Elixir, as shown next, code organization must be done only through modules and functions. Whenever possible, a library should not impose specific behavior (such as parallelization) on its users. It is better to delegate this behavioral decision to the developers of clients, thus increasing the potential for code reuse of a library.\n\n```elixir\ndefmodule Calculator do\n def add(a, b) do\n a + b\n end\n\n def subtract(a, b) do\n a - b\n end\nend\n```\n\n```elixir\niex> Calculator.add(1, 5)\n6\niex> Calculator.subtract(2, 3)\n-1\n```\n\n## Scattered process interfaces\n\n#### Problem\n\nIn Elixir, the use of an `Agent`, a `GenServer`, or any other process abstraction is not an anti-pattern in itself. However, when the responsibility for direct interaction with a process is spread throughout the entire system, it can become problematic. This bad practice can increase the difficulty of code maintenance and make the code more prone to bugs.\n\n#### Example\n\nThe following code seeks to illustrate this anti-pattern. The responsibility for interacting directly with the `Agent` is spread across four different modules (`A`, `B`, `C`, and `D`).\n\n```elixir\ndefmodule A do\n def update(process) do\n # Some other code...\n Agent.update(process, fn _list -> 123 end)\n end\nend\n```\n\n```elixir\ndefmodule B do\n def update(process) do\n # Some other code...\n Agent.update(process, fn content -> %{a: content} end)\n end\nend\n```\n\n```elixir\ndefmodule C do\n def update(process) do\n # Some other code...\n Agent.update(process, fn content -> [:atom_value | content] end)\n end\nend\n```\n\n```elixir\ndefmodule D do\n def get(process) do\n # Some other code...\n Agent.get(process, fn content -> content end)\n end\nend\n```\n\nThis spreading of responsibility can generate duplicated code and make code maintenance more difficult. Also, due to the lack of control over the format of the shared data, complex composed data can be shared. This freedom to use any format of data is dangerous and can induce developers to introduce bugs.\n\n```elixir\n# start an agent with initial state of an empty list\niex> {:ok, agent} = Agent.start_link(fn -> [] end)\n{:ok, #PID<0.135.0>}\n\n# many data formats (for example, List, Map, Integer, Atom) are\n# combined through direct access spread across the entire system\niex> A.update(agent)\niex> B.update(agent)\niex> C.update(agent)\n\n# state of shared information\niex> D.get(agent)\n[:atom_value, %{a: 123}]\n```\n\nFor a `GenServer` and other behaviours, this anti-pattern will manifest when scattering calls to `GenServer.call/3` and `GenServer.cast/2` throughout multiple modules, instead of encapsulating all the interaction with the `GenServer` in a single place.\n\n#### Refactoring\n\nInstead of spreading direct access to a process abstraction, such as `Agent`, over many places in the code, it is better to refactor this code by centralizing the responsibility for interacting with a process in a single module. This refactoring improves maintainability by removing duplicated code; it also allows you to limit the accepted format for shared data, reducing bug-proneness. As shown below, the module `Foo.Bucket` is centralizing the responsibility for interacting with the `Agent`. Any other place in the code that needs to access shared data must now delegate this action to `Foo.Bucket`. Also, `Foo.Bucket` now only allows data to be shared in `Map` format.\n\n```elixir\ndefmodule Foo.Bucket do\n use Agent\n\n def start_link(_opts) do\n Agent.start_link(fn -> %{} end)\n end\n\n def get(bucket, key) do\n Agent.get(bucket, &Map.get(&1, key))\n end\n\n def put(bucket, key, value) do\n Agent.update(bucket, &Map.put(&1, key, value))\n end\nend\n```\n\nThe following are examples of how to delegate access to shared data (provided by an `Agent`) to `Foo.Bucket`.\n\n```elixir\n# start an agent through `Foo.Bucket`\niex> {:ok, bucket} = Foo.Bucket.start_link(%{})\n{:ok, #PID<0.114.0>}\n\n# add shared values to the keys `milk` and `beer`\niex> Foo.Bucket.put(bucket, \"milk\", 3)\niex> Foo.Bucket.put(bucket, \"beer\", 7)\n\n# access shared data of specific keys\niex> Foo.Bucket.get(bucket, \"beer\")\n7\niex> Foo.Bucket.get(bucket, \"milk\")\n3\n```\n\n#### Additional remarks\n\nThis anti-pattern was formerly known as [Agent obsession](https://github.com/lucasvegi/Elixir-Code-Smells/tree/main#agent-obsession).\n\n## Sending unnecessary data\n\n#### Problem\n\nSending a message to a process can be an expensive operation if the message is big enough. That's because that message will be fully copied to the receiving process, which may be CPU and memory intensive. This is due to Erlang's \"share nothing\" architecture, where each process has its own memory, which simplifies and speeds up garbage collection.\n\nThis is more obvious when using `send/2`, `GenServer.call/3`, or the initial data in `GenServer.start_link/3`. Notably this also happens when using `spawn/1`, `Task.async/1`, `Task.async_stream/3`, and so on. It is more subtle here as the anonymous function passed to these functions captures the variables it references, and all captured variables will be copied over. By doing this, you can accidentally send way more data to a process than you actually need.\n\n#### Example\n\nImagine you were to implement some simple reporting of IP addresses that made requests against your application. You want to do this asynchronously and not block processing, so you decide to use `spawn/1`. It may seem like a good idea to hand over the whole connection because we might need more data later. However passing the connection results in copying a lot of unnecessary data like the request body, params, etc.\n\n```elixir\n# log_request_ip send the ip to some external service\nspawn(fn -> log_request_ip(conn) end)\n```\n\nThis problem also occurs when accessing only the relevant parts:\n\n```elixir\nspawn(fn -> log_request_ip(conn.remote_ip) end)\n```\n\nThis will still copy over all of `conn`, because the `conn` variable is being captured inside the spawned function. The function then extracts the `remote_ip` field, but only after the whole `conn` has been copied over.\n\n`send/2` and the `GenServer` APIs also rely on message passing. In the example below, the `conn` is once again copied to the underlying `GenServer`:\n\n```elixir\nGenServer.cast(pid, {:report_ip_address, conn})\n```\n\n#### Refactoring\n\nThis anti-pattern has many potential remedies:\n\n * Limit the data you send to the absolute necessary minimum instead of sending an entire struct. For example, don't send an entire `conn` struct if all you need is a couple of fields.\n\n * If the only process that needs data is the one you are sending to, consider making the process fetch that data instead of passing it.\n\n * Some abstractions, such as [`:persistent_term`](`:persistent_term`), allows you to share data between processes, as long as such data changes infrequently.\n\nIn our case, limiting the input data is a reasonable strategy. If all we need *right now* is the IP address, then let's only work with that and make sure we're only passing the IP address into the closure, like so:\n\n```elixir\nip_address = conn.remote_ip\nspawn(fn -> log_request_ip(ip_address) end)\n```\n\nOr in the `GenServer` case:\n\n```elixir\nGenServer.cast(pid, {:report_ip_address, conn.remote_ip})\n```\n\n## Unsupervised processes\n\n#### Problem\n\nIn Elixir, creating a process outside a supervision tree is not an anti-pattern in itself. However, when you spawn many long-running processes outside of supervision trees, this can make visibility and monitoring of these processes difficult, preventing developers from fully controlling their lifecycle.\n\n#### Example\n\nThe following code example seeks to illustrate a library responsible for maintaining a numerical `Counter` through a `Agent` process *outside a supervision tree*.\n\n```elixir\ndefmodule Counter do\n @moduledoc \"\"\"\n Global counter implemented as an Agent.\n \"\"\"\n\n use Agent\n\n @doc \"Starts a counter process.\"\n def start_link(opts \\\\ []) do\n initial_state = Keyword.get(opts, :initial_value, 0)\n name = Keyword.get(opts, :name, __MODULE__)\n Agent.start_link(fn -> initial_state end, name: name)\n end\n\n @doc \"Gets the current value of the given counter.\"\n def get(name \\\\ __MODULE__) do\n Agent.get(name, fn state -> state end)\n end\n\n @doc \"Bumps the value of the given counter.\"\n def bump(name \\\\ __MODULE__, value) do\n Agent.get_and_update(fn state -> {state, value + state} end)\n end\nend\n```\n\nWhile it is possible to start the process outside of a supervision tree:\n\n```elixir\niex> Counter.start_link()\n{:ok, #PID<0.115.0>}\niex> Counter.bump(13)\n0\niex> Counter.get()\n13\n```\n\nSuch processes are harder to observe and control their lifecycle. For example, if you have other processes that depend on the `Counter` above, you will need ad-hoc mechanisms to make sure they are initialized in order. Furthermore, when your application is shutting down, there is no guarantee when they are terminated.\n\n#### Refactoring\n\nTo ensure that clients of a library have full control over their systems, regardless of the number of processes used and the lifetime of each one, all processes must be started inside a supervision tree. As shown below, this code uses a `Supervisor` as a supervision tree.\n\n```elixir\ndefmodule SupervisedProcess.Application do\n use Application\n\n @impl true\n def start(_type, _args) do\n children = [\n # With the default values for counter and name\n Counter,\n # With custom values for counter, name, and a custom ID\n Supervisor.child_spec(\n {Counter, name: :other_counter, initial_value: 15},\n id: :other_counter\n )\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one, name: App.Supervisor)\n end\nend\n```\n\nBesides having a deterministic order in which processes are started, supervision trees also guarantee they are terminated in reverse order, allowing you to perform any necessary clean up during shut down. Furthermore, supervision strategies allows us to configure exactly how process should act in case of unexpected failures.\n\nFinally, applications and supervision trees can be introspected through applications like the [Phoenix.LiveDashboard](https://github.com/phoenixframework/phoenix_live_dashboard) and [Erlang's built-in observer](https://www.erlang.org/doc/apps/observer/observer_ug):\n\n\"Observer\n" }, { "path": "lib/elixir/pages/anti-patterns/what-anti-patterns.md", "content": "\n\n# What are anti-patterns?\n\nAnti-patterns describe common mistakes or indicators of problems in code.\nThey are also known as \"code smells\".\n\nThe goal of these guides is to document potential anti-patterns found in Elixir software\nand teach developers how to identify them and their pitfalls. If an existing piece\nof code matches an anti-pattern, it does not mean your code must be rewritten.\nSometimes, even if a snippet matches a potential anti-pattern and its limitations,\nit may be the best approach to the problem at hand. No codebase is free of anti-patterns\nand one should not aim to remove all of them.\n\nThe anti-patterns in these guides are broken into 4 main categories:\n\n * **Code-related anti-patterns:** related to your code and particular\n language idioms and features;\n\n * **Design-related anti-patterns:** related to your modules, functions,\n and the role they play within a codebase;\n\n * **Process-related anti-patterns:** related to processes and process-based\n abstractions;\n\n * **Meta-programming anti-patterns:** related to meta-programming.\n\nEach anti-pattern is documented using the following structure:\n\n * **Name:** Unique identifier of the anti-pattern. This name is important to facilitate\n communication between developers;\n\n * **Problem:** How the anti-pattern can harm code quality and what impacts this can have\n for developers;\n\n * **Example:** Code and textual descriptions to illustrate the occurrence of the anti-pattern;\n\n * **Refactoring:** Ways to change your code to improve its qualities. Examples of refactored\n code are presented to illustrate these changes.\n\nAn additional section with \"Additional Remarks\" may be provided. Those may include known scenarios where the anti-pattern does not apply.\n\nThe initial catalog of anti-patterns was proposed by Lucas Vegi and Marco Tulio Valente, from [ASERG/DCC/UFMG](http://aserg.labsoft.dcc.ufmg.br/). For more info, see [Understanding Code Smells in Elixir Functional Language](https://github.com/lucasvegi/Elixir-Code-Smells/blob/main/etc/2023-emse-code-smells-elixir.pdf) and [the associated code repository](https://github.com/lucasvegi/Elixir-Code-Smells).\n\nAdditionally, the Security Working Group of the [Erlang Ecosystem Foundation](https://security.erlef.org) publishes [documents with security resources and best-practices of both Erlang and Elixir, including detailed guides for web applications](https://security.erlef.org).\n" }, { "path": "lib/elixir/pages/cheatsheets/enum-cheat.cheatmd", "content": "\n\n# Enum cheatsheet\n\nA quick reference into the `Enum` module, a module for working with collections (known as enumerables). Most of the examples below use the following data structure:\n\n```elixir\ncart = [\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n]\n```\n\nSome examples use the [`string =~ part`](`=~/2`) operator, which checks the string on the left contains the part on the right.\n\n## Predicates\n{: .col-2}\n\n### [`any?(enum, fun)`](`Enum.any?/2`)\n\n```elixir\niex> Enum.any?(cart, & &1.fruit == \"orange\")\ntrue\niex> Enum.any?(cart, & &1.fruit == \"pear\")\nfalse\n```\n\n`any?` with an empty collection is always false:\n\n```elixir\niex> Enum.any?([], & &1.fruit == \"orange\")\nfalse\n```\n\n### [`all?(enum, fun)`](`Enum.all?/2`)\n\n```elixir\niex> Enum.all?(cart, & &1.count > 0)\ntrue\niex> Enum.all?(cart, & &1.count > 1)\nfalse\n```\n\n`all?` with an empty collection is always true:\n\n```elixir\niex> Enum.all?([], & &1.count > 0)\ntrue\n```\n\n### [`member?(enum, value)`](`Enum.member?/2`)\n\n```elixir\niex> Enum.member?(cart, %{fruit: \"apple\", count: 3})\ntrue\niex> Enum.member?(cart, :something_else)\nfalse\n```\n\n`item in enum` is equivalent to `Enum.member?(enum, item)`:\n\n```elixir\niex> %{fruit: \"apple\", count: 3} in cart\ntrue\niex> :something_else in cart\nfalse\n```\n\n### [`empty?(enum)`](`Enum.empty?/1`)\n\n```elixir\niex> Enum.empty?(cart)\nfalse\niex> Enum.empty?([])\ntrue\n```\n\n## Filtering\n{: .col-2}\n\n### [`filter(enum, fun)`](`Enum.filter/2`)\n\n```elixir\niex> Enum.filter(cart, &(&1.fruit =~ \"o\"))\n[%{fruit: \"orange\", count: 6}]\niex> Enum.filter(cart, &(&1.fruit =~ \"e\"))\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6}\n]\n```\n\n### [`reject(enum, fun)`](`Enum.reject/2`)\n\n```elixir\niex> Enum.reject(cart, &(&1.fruit =~ \"o\"))\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n]\n```\n\n### [`flat_map(enum, fun)`](`Enum.flat_map/2`)\n\nThis function (also listed [below](#concatenating-flattening)) can\nbe used to transform and filter in one pass, returning empty lists\nto exclude results:\n\n```elixir\niex> Enum.flat_map(cart, fn item ->\n...> if item.count > 1, do: [item.fruit], else: []\n...> end)\n[\"apple\", \"orange\"]\n```\n\n### [`Comprehension`](`for/1`)\n\nFiltering can also be done with comprehensions:\n\n```elixir\niex> for item <- cart, item.fruit =~ \"e\" do\n...> item\n...> end\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6}\n]\n```\n\nPattern-matching in comprehensions acts as a filter as well:\n\n```elixir\niex> for %{count: 1, fruit: fruit} <- cart do\n...> fruit\n...> end\n[\"banana\"]\n```\n\n## Mapping\n{: .col-2}\n\n### [`map(enum, fun)`](`Enum.map/2`)\n\n```elixir\niex> Enum.map(cart, & &1.fruit)\n[\"apple\", \"banana\", \"orange\"]\niex> Enum.map(cart, fn item ->\n...> %{item | count: item.count + 10}\n...> end)\n[\n %{fruit: \"apple\", count: 13},\n %{fruit: \"banana\", count: 11},\n %{fruit: \"orange\", count: 16}\n]\n```\n\n### [`map_every(enum, nth, fun)`](`Enum.map_every/3`)\n\n```elixir\niex> Enum.map_every(cart, 2, fn item ->\n...> %{item | count: item.count + 10}\n...> end)\n[\n %{fruit: \"apple\", count: 13},\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 16}\n]\n```\n\n### [`Comprehension`](`for/1`)\n\nMapping can also be done with comprehensions:\n\n```elixir\niex> for item <- cart do\n...> item.fruit\n...> end\n[\"apple\", \"banana\", \"orange\"]\n```\n\nYou can also filter and map at once:\n\n```elixir\niex> for item <- cart, item.fruit =~ \"e\" do\n...> item.fruit\n...> end\n[\"apple\", \"orange\"]\n```\n\n## Side-effects\n{: .col-2}\n\n### [`each(enum, fun)`](`Enum.each/2`)\n\n```elixir\niex> Enum.each(cart, &IO.puts(&1.fruit))\napple\nbanana\norange\n:ok\n```\n\n`Enum.each/2` is used exclusively for side-effects.\n\n## Accumulating\n{: .col-2}\n\n### [`reduce(enum, acc, fun)`](`Enum.reduce/3`)\n\n```elixir\niex> Enum.reduce(cart, 0, fn item, acc ->\n...> item.count + acc\n...> end)\n10\n```\n\n### [`map_reduce(enum, acc, fun)`](`Enum.map_reduce/3`)\n\n```elixir\niex> Enum.map_reduce(cart, 0, fn item, acc ->\n...> {item.fruit, item.count + acc}\n...> end)\n{[\"apple\", \"banana\", \"orange\"], 10}\n```\n\n### [`scan(enum, acc, fun)`](`Enum.scan/3`)\n\n```elixir\niex> Enum.scan(cart, 0, fn item, acc ->\n...> item.count + acc\n...> end)\n[3, 4, 10]\n```\n\n### [`reduce_while(enum, acc, fun)`](`Enum.reduce_while/3`)\n\n```elixir\niex> Enum.reduce_while(cart, 0, fn item, acc ->\n...> if item.fruit == \"orange\" do\n...> {:halt, acc}\n...> else\n...> {:cont, item.count + acc}\n...> end\n...> end)\n4\n```\n\n### [`Comprehension`](`for/1`)\n\nReducing can also be done with comprehensions:\n\n```elixir\niex> for item <- cart, reduce: 0 do\n...> acc -> item.count + acc\n...> end\n10\n```\n\nYou can also filter and reduce at once:\n\n```elixir\niex> for item <- cart, item.fruit =~ \"e\", reduce: 0 do\n...> acc -> item.count + acc\n...> end\n9\n```\n\n## Aggregations\n{: .col-2}\n\n### [`count(enum)`](`Enum.count/1`)\n\n```elixir\niex> Enum.count(cart)\n3\n```\n\nSee `Enum.count_until/2` to count until a limit.\n\n### [`frequencies(enum)`](`Enum.frequencies/1`)\n\n```elixir\niex> Enum.frequencies([\"apple\", \"banana\", \"orange\", \"apple\"])\n%{\"apple\" => 2, \"banana\" => 1, \"orange\" => 1}\n```\n\n### [`frequencies_by(enum, key_fun)`](`Enum.frequencies_by/2`)\n\nFrequencies of the last letter of the fruit:\n\n```elixir\niex> Enum.frequencies_by(cart, &String.last(&1.fruit))\n%{\"a\" => 1, \"e\" => 2}\n```\n\n### [`count(enum, fun)`](`Enum.count/2`)\n\n```elixir\niex> Enum.count(cart, &(&1.fruit =~ \"e\"))\n2\niex> Enum.count(cart, &(&1.fruit =~ \"y\"))\n0\n```\n\nSee `Enum.count_until/3` to count until a limit with a function.\n\n### [`sum(enum)`](`Enum.sum/1`)\n\n```elixir\niex> cart |> Enum.map(& &1.count) |> Enum.sum()\n10\n```\n\nNote: this should typically be done in one pass using `Enum.sum_by/2`.\n\n### [`sum_by(enum, mapper)`](`Enum.sum_by/2`)\n\n```elixir\niex> Enum.sum_by(cart, & &1.count)\n10\n```\n\n### [`product(enum)`](`Enum.product/1`)\n\n```elixir\niex> cart |> Enum.map(& &1.count) |> Enum.product()\n18\n```\n\nNote: this should typically be done in one pass using `Enum.product_by/2`.\n\n### [`product_by(enum, mapper)`](`Enum.product_by/2`)\n\n```elixir\niex> Enum.product_by(cart, & &1.count)\n18\n```\n\n## Sorting\n{: .col-2}\n\n### [`sort(enum, sorter \\\\ :asc)`](`Enum.sort/2`)\n\n```elixir\niex> cart |> Enum.map(& &1.fruit) |> Enum.sort()\n[\"apple\", \"banana\", \"orange\"]\niex> cart |> Enum.map(& &1.fruit) |> Enum.sort(:desc)\n[\"orange\", \"banana\", \"apple\"]\n```\n\nWhen sorting structs, use `Enum.sort/2` with a module as sorter.\n\n### [`sort_by(enum, mapper, sorter \\\\ :asc)`](`Enum.sort_by/2`)\n\n```elixir\niex> Enum.sort_by(cart, & &1.count)\n[\n %{fruit: \"banana\", count: 1},\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6}\n]\niex> Enum.sort_by(cart, & &1.count, :desc)\n[\n %{fruit: \"orange\", count: 6},\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n]\n```\n\nWhen the sorted by value is a struct, use `Enum.sort_by/3` with a module as sorter.\n\n### [`min(enum)`](`Enum.min/1`)\n\n```elixir\niex> cart |> Enum.map(& &1.count) |> Enum.min()\n1\n```\n\nWhen comparing structs, use `Enum.min/2` with a module as sorter.\n\n### [`min_by(enum, mapper)`](`Enum.min_by/2`)\n\n```elixir\niex> Enum.min_by(cart, & &1.count)\n%{fruit: \"banana\", count: 1}\n```\n\nWhen comparing structs, use `Enum.min_by/3` with a module as sorter.\n\n### [`max(enum)`](`Enum.max/1`)\n\n```elixir\niex> cart |> Enum.map(& &1.count) |> Enum.max()\n6\n```\n\nWhen comparing structs, use `Enum.max/2` with a module as sorter.\n\n### [`max_by(enum, mapper)`](`Enum.max_by/2`)\n\n```elixir\niex> Enum.max_by(cart, & &1.count)\n%{fruit: \"orange\", count: 6}\n```\n\nWhen comparing structs, use `Enum.max_by/3` with a module as sorter.\n\n## Concatenating & flattening\n{: .col-2}\n\n### [`concat(enums)`](`Enum.concat/1`)\n\n```elixir\niex> Enum.concat([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\n```\n\n### [`concat(left, right)`](`Enum.concat/2`)\n\n```elixir\niex> Enum.concat([1, 2, 3], [4, 5, 6])\n[1, 2, 3, 4, 5, 6]\n```\n\n### [`flat_map(enum, fun)`](`Enum.flat_map/2`)\n\n```elixir\niex> Enum.flat_map(cart, fn item ->\n...> List.duplicate(item.fruit, item.count)\n...> end)\n[\"apple\", \"apple\", \"apple\", \"banana\", \"orange\",\n \"orange\", \"orange\", \"orange\", \"orange\", \"orange\"]\n```\n\n### [`flat_map_reduce(enum, acc, fun)`](`Enum.flat_map_reduce/3`)\n\n```elixir\niex> Enum.flat_map_reduce(cart, 0, fn item, acc ->\n...> list = List.duplicate(item.fruit, item.count)\n...> acc = acc + item.count\n...> {list, acc}\n...> end)\n{[\"apple\", \"apple\", \"apple\", \"banana\", \"orange\",\n \"orange\", \"orange\", \"orange\", \"orange\", \"orange\"], 10}\n```\n\n### [`Comprehension`](`for/1`)\n\nFlattening can also be done with comprehensions:\n\n```elixir\niex> for item <- cart,\n...> fruit <- List.duplicate(item.fruit, item.count) do\n...> fruit\n...> end\n[\"apple\", \"apple\", \"apple\", \"banana\", \"orange\",\n \"orange\", \"orange\", \"orange\", \"orange\", \"orange\"]\n```\n\n## Conversion\n{: .col-2}\n\n### [`into(enum, collectable)`](`Enum.into/2`)\n\n```elixir\niex> pairs = [{\"apple\", 3}, {\"banana\", 1}, {\"orange\", 6}]\niex> Enum.into(pairs, %{})\n%{\"apple\" => 3, \"banana\" => 1, \"orange\" => 6}\n```\n\n### [`into(enum, collectable, transform)`](`Enum.into/3`)\n\n```elixir\niex> Enum.into(cart, %{}, fn item ->\n...> {item.fruit, item.count}\n...> end)\n%{\"apple\" => 3, \"banana\" => 1, \"orange\" => 6}\n```\n\n### [`to_list(enum)`](`Enum.to_list/1`)\n\n```elixir\niex> Enum.to_list(1..5)\n[1, 2, 3, 4, 5]\n```\n\n### [`Comprehension`](`for/1`)\n\nConversion can also be done with comprehensions:\n\n```elixir\niex> for item <- cart, into: %{} do\n...> {item.fruit, item.count}\n...> end\n%{\"apple\" => 3, \"banana\" => 1, \"orange\" => 6}\n```\n\n## Duplicates & uniques\n{: .col-2}\n\n### [`dedup(enum)`](`Enum.dedup/1`)\n\n`dedup` only removes contiguous duplicates:\n\n```elixir\niex> Enum.dedup([1, 2, 2, 3, 3, 3, 1, 2, 3])\n[1, 2, 3, 1, 2, 3]\n```\n\n### [`dedup_by(enum, fun)`](`Enum.dedup_by/2`)\n\nRemove contiguous entries given a property:\n\n```elixir\niex> Enum.dedup_by(cart, & &1.fruit =~ \"a\")\n[%{fruit: \"apple\", count: 3}]\niex> Enum.dedup_by(cart, & &1.count < 5)\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6}\n]\n```\n\n### [`uniq(enum)`](`Enum.uniq/1`)\n\n`uniq` applies to the whole collection:\n\n```elixir\niex> Enum.uniq([1, 2, 2, 3, 3, 3, 1, 2, 3])\n[1, 2, 3]\n```\n\nComprehensions also support the `uniq: true` option.\n\n### [`uniq_by(enum, fun)`](`Enum.uniq_by/2`)\n\nGet entries which are unique by the last letter of the fruit:\n\n```elixir\niex> Enum.uniq_by(cart, &String.last(&1.fruit))\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n]\n```\n\n## Indexing\n{: .col-2}\n\n### [`at(enum, index, default \\\\ nil)`](`Enum.at/2`)\n\n```elixir\niex> Enum.at(cart, 0)\n%{fruit: \"apple\", count: 3}\niex> Enum.at(cart, 10)\nnil\niex> Enum.at(cart, 10, :none)\n:none\n```\n\nAccessing a list by index in a loop is discouraged.\n\n### [`fetch(enum, index)`](`Enum.fetch/2`)\n\n```elixir\niex> Enum.fetch(cart, 0)\n{:ok, %{fruit: \"apple\", count: 3}}\niex> Enum.fetch(cart, 10)\n:error\n```\n\n### [`fetch!(enum, index)`](`Enum.fetch!/2`)\n\n```elixir\niex> Enum.fetch!(cart, 0)\n%{fruit: \"apple\", count: 3}\niex> Enum.fetch!(cart, 10)\n** (Enum.OutOfBoundsError) out of bounds error\n```\n\n### [`with_index(enum)`](`Enum.with_index/1`)\n\n```elixir\niex> Enum.with_index(cart)\n[\n {%{fruit: \"apple\", count: 3}, 0},\n {%{fruit: \"banana\", count: 1}, 1},\n {%{fruit: \"orange\", count: 6}, 2}\n]\n```\n\n### [`with_index(enum, fun)`](`Enum.with_index/2`)\n\n```elixir\niex> Enum.with_index(cart, fn item, index ->\n...> {item.fruit, index}\n...> end)\n[\n {\"apple\", 0},\n {\"banana\", 1},\n {\"orange\", 2}\n]\n```\n\n## Finding\n{: .col-2}\n\n### [`find(enum, default \\\\ nil, fun)`](`Enum.find/2`)\n\n```elixir\niex> Enum.find(cart, &(&1.fruit =~ \"o\"))\n%{fruit: \"orange\", count: 6}\niex> Enum.find(cart, &(&1.fruit =~ \"y\"))\nnil\niex> Enum.find(cart, :none, &(&1.fruit =~ \"y\"))\n:none\n```\n\n### [`find_index(enum, fun)`](`Enum.find_index/2`)\n\n```elixir\niex> Enum.find_index(cart, &(&1.fruit =~ \"o\"))\n2\niex> Enum.find_index(cart, &(&1.fruit =~ \"y\"))\nnil\n```\n\n### [`find_value(enum, default \\\\ nil, fun)`](`Enum.find_value/2`)\n\n```elixir\niex> Enum.find_value(cart, fn item ->\n...> if item.count == 1, do: item.fruit, else: nil\n...> end)\n\"banana\"\niex> Enum.find_value(cart, :none, fn item ->\n...> if item.count == 100, do: item.fruit, else: nil\n...> end)\n:none\n```\n\n## Grouping\n{: .col-2}\n\n### [`group_by(enum, key_fun)`](`Enum.group_by/2`)\n\nGroup by the last letter of the fruit:\n\n```elixir\niex> Enum.group_by(cart, &String.last(&1.fruit))\n%{\n \"a\" => [%{fruit: \"banana\", count: 1}],\n \"e\" => [\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6}\n ]\n}\n```\n\n### [`group_by(enum, key_fun, value_fun)`](`Enum.group_by/3`)\n\nGroup by the last letter of the fruit with custom value:\n\n```elixir\niex> Enum.group_by(cart, &String.last(&1.fruit), & &1.fruit)\n%{\n \"a\" => [\"banana\"],\n \"e\" => [\"apple\", \"orange\"]\n}\n```\n\n## Joining & interspersing\n{: .col-2}\n\n### [`join(enum, joiner \\\\ \"\")`](`Enum.join/2`)\n\n```elixir\niex> Enum.join([\"apple\", \"banana\", \"orange\"], \", \")\n\"apple, banana, orange\"\n```\n\n### [`map_join(enum, joiner \\\\ \"\", mapper)`](`Enum.map_join/3`)\n\n```elixir\niex> Enum.map_join(cart, \", \", & &1.fruit)\n\"apple, banana, orange\"\n```\n\n### [`intersperse(enum, separator \\\\ \"\")`](`Enum.intersperse/2`)\n\n```elixir\niex> Enum.intersperse([\"apple\", \"banana\", \"orange\"], \", \")\n[\"apple\", \", \", \"banana\", \", \", \"orange\"]\n```\n\n### [`map_intersperse(enum, separator \\\\ \"\", mapper)`](`Enum.map_intersperse/3`)\n\n```elixir\niex> Enum.map_intersperse(cart, \", \", & &1.fruit)\n[\"apple\", \", \", \"banana\", \", \", \"orange\"]\n```\n\n## Slicing\n{: .col-2}\n\n### [`slice(enum, index_range)`](`Enum.slice/2`)\n\n```elixir\niex> Enum.slice(cart, 0..1)\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n]\n```\n\nNegative ranges count from the back:\n\n```elixir\niex> Enum.slice(cart, -2..-1)\n[\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n]\n```\n\n### [`slice(enum, start_index, amount)`](`Enum.slice/3`)\n\n```elixir\niex> Enum.slice(cart, 1, 2)\n[\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n]\n```\n\n### [`slide(enum, range_or_single_index, insertion_index)`](`Enum.slide/3`)\n\n```elixir\nfruits = [\"apple\", \"banana\", \"grape\", \"orange\", \"pear\"]\niex> Enum.slide(fruits, 2, 0)\n[\"grape\", \"apple\", \"banana\", \"orange\", \"pear\"]\niex> Enum.slide(fruits, 2, 4)\n[\"apple\", \"banana\", \"orange\", \"pear\", \"grape\"]\niex> Enum.slide(fruits, 1..3, 0)\n[\"banana\", \"grape\", \"orange\", \"apple\", \"pear\"]\niex> Enum.slide(fruits, 1..3, 4)\n[\"apple\", \"pear\", \"banana\", \"grape\", \"orange\"]\n```\n\n## Reversing\n{: .col-2}\n\n### [`reverse(enum)`](`Enum.reverse/1`)\n\n```elixir\niex> Enum.reverse(cart)\n[\n %{fruit: \"orange\", count: 6},\n %{fruit: \"banana\", count: 1},\n %{fruit: \"apple\", count: 3}\n]\n```\n\n### [`reverse(enum, tail)`](`Enum.reverse/2`)\n\n```elixir\niex> Enum.reverse(cart, [:this_will_be, :the_tail])\n[\n %{fruit: \"orange\", count: 6},\n %{fruit: \"banana\", count: 1},\n %{fruit: \"apple\", count: 3},\n :this_will_be,\n :the_tail\n]\n```\n\n### [`reverse_slice(enum, start_index, count)`](`Enum.reverse_slice/3`)\n\n```elixir\niex> Enum.reverse_slice(cart, 1, 2)\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6},\n %{fruit: \"banana\", count: 1}\n]\n```\n\n## Splitting\n{: .col-2}\n\n### [`split(enum, amount)`](`Enum.split/2`)\n\n```elixir\niex> Enum.split(cart, 1)\n{[%{fruit: \"apple\", count: 3}],\n [\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n ]}\n```\n\nNegative indexes count from the back:\n\n```elixir\niex> Enum.split(cart, -1)\n{[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n ],\n [%{fruit: \"orange\", count: 6}]}\n```\n\n### [`split_while(enum, fun)`](`Enum.split_while/2`)\n\nStops splitting as soon as it is false:\n\n```elixir\niex> Enum.split_while(cart, &(&1.fruit =~ \"e\"))\n{[%{fruit: \"apple\", count: 3}],\n [\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n ]}\n```\n\n### [`split_with(enum, fun)`](`Enum.split_with/2`)\n\nSplits the whole collection:\n\n```elixir\niex> Enum.split_with(cart, &(&1.fruit =~ \"e\"))\n{[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6}\n ],\n [%{fruit: \"banana\", count: 1}]}\n```\n\n## Splitting (drop and take)\n{: .col-2}\n\n### [`drop(enum, amount)`](`Enum.drop/2`)\n\n```elixir\niex> Enum.drop(cart, 1)\n[\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n]\n```\n\nNegative indexes count from the back:\n\n```elixir\niex> Enum.drop(cart, -1)\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n]\n```\n\n### [`drop_every(enum, nth)`](`Enum.drop_every/2`)\n\n```elixir\niex> Enum.drop_every(cart, 2)\n[%{fruit: \"banana\", count: 1}]\n```\n\n### [`drop_while(enum, fun)`](`Enum.drop_while/2`)\n\n```elixir\niex> Enum.drop_while(cart, &(&1.fruit =~ \"e\"))\n[\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n]\n```\n\n### [`take(enum, amount)`](`Enum.take/2`)\n\n```elixir\niex> Enum.take(cart, 1)\n[%{fruit: \"apple\", count: 3}]\n```\n\nNegative indexes count from the back:\n\n```elixir\niex> Enum.take(cart, -1)\n[%{fruit: \"orange\", count: 6}]\n```\n\n### [`take_every(enum, nth)`](`Enum.take_every/2`)\n\n```elixir\niex> Enum.take_every(cart, 2)\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"orange\", count: 6}\n]\n```\n\n### [`take_while(enum, fun)`](`Enum.take_while/2`)\n\n```elixir\niex> Enum.take_while(cart, &(&1.fruit =~ \"e\"))\n[%{fruit: \"apple\", count: 3}]\n```\n\n## Random\n{: .col-2}\n\n### [`random(enum)`](`Enum.random/1`)\n\nResults will vary on every call:\n\n```elixir\niex> Enum.random(cart)\n%{fruit: \"orange\", count: 6}\n```\n\n### [`take_random(enum, count)`](`Enum.take_random/2`)\n\nResults will vary on every call:\n\n```elixir\niex> Enum.take_random(cart, 2)\n[\n %{fruit: \"orange\", count: 6},\n %{fruit: \"apple\", count: 3}\n]\n```\n\n### [`shuffle(enum)`](`Enum.shuffle/1`)\n\nResults will vary on every call:\n\n```elixir\niex> Enum.shuffle(cart)\n[\n %{fruit: \"orange\", count: 6},\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n]\n```\n\n## Chunking\n{: .col-2}\n\n### [`chunk_by(enum, fun)`](`Enum.chunk_by/2`)\n\n```elixir\niex> Enum.chunk_by(cart, &String.length(&1.fruit))\n[\n [%{fruit: \"apple\", count: 3}],\n [\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n ]\n]\n```\n\n### [`chunk_every(enum, count)`](`Enum.chunk_every/2`)\n\n```elixir\niex> Enum.chunk_every(cart, 2)\n[\n [\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n ],\n [%{fruit: \"orange\", count: 6}]\n]\n```\n\n### [`chunk_every(enum, count, step, leftover \\\\ [])`](`Enum.chunk_every/2`)\n\n```elixir\niex> Enum.chunk_every(cart, 2, 2, [:elements, :to_complete])\n[\n [\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n ],\n [\n %{fruit: \"orange\", count: 6},\n :elements\n ]\n]\niex> Enum.chunk_every(cart, 2, 1, :discard)\n[\n [\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1}\n ],\n [\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n ]\n]\n```\n\nSee `Enum.chunk_while/4` for custom chunking.\n\n## Zipping\n{: .col-2}\n\n### [`zip(enum1, enum2)`](`Enum.zip/2`)\n\n```elixir\niex> fruits = [\"apple\", \"banana\", \"orange\"]\niex> counts = [3, 1, 6]\niex> Enum.zip(fruits, counts)\n[{\"apple\", 3}, {\"banana\", 1}, {\"orange\", 6}]\n```\n\nSee `Enum.zip/1` for zipping many collections at once.\n\n### [`zip_with(enum1, enum2, fun)`](`Enum.zip_with/2`)\n\n```elixir\niex> fruits = [\"apple\", \"banana\", \"orange\"]\niex> counts = [3, 1, 6]\niex> Enum.zip_with(fruits, counts, fn fruit, count ->\n...> %{fruit: fruit, count: count}\n...> end)\n[\n %{fruit: \"apple\", count: 3},\n %{fruit: \"banana\", count: 1},\n %{fruit: \"orange\", count: 6}\n]\n```\n\nSee `Enum.zip_with/2` for zipping many collections at once.\n\n### [`zip_reduce(left, right, acc, fun)`](`Enum.zip_reduce/4`)\n\n```elixir\niex> fruits = [\"apple\", \"banana\", \"orange\"]\niex> counts = [3, 1, 6]\niex> Enum.zip_reduce(fruits, counts, 0, fn fruit, count, acc ->\n...> price = if fruit =~ \"e\", do: count * 2, else: count\n...> acc + price\n...> end)\n19\n```\n\nSee `Enum.zip_reduce/3` for zipping many collections at once.\n\n### [`unzip(list)`](`Enum.unzip/1`)\n\n```elixir\niex> cart |> Enum.map(&{&1.fruit, &1.count}) |> Enum.unzip()\n{[\"apple\", \"banana\", \"orange\"], [3, 1, 6]}\n```\n" }, { "path": "lib/elixir/pages/cheatsheets/types-cheat.cheatmd", "content": "\n\n# Set-theoretic types cheatsheet\n\n## Set operators\n\n#### Union\n\n```elixir\ntype1 or type2\n```\n\n#### Intersection\n\n```elixir\ntype1 and type2\n```\n\n#### Difference\n\n```elixir\ntype1 and not type2\n```\n\n#### Negation\n\n```elixir\nnot type\n```\n\n## Data types\n\n### Broad types\n\n```elixir\nbitstring()\nbinary()\nempty_list()\ninteger()\nfloat()\npid()\nport()\nreference()\n```\n\n`binary()` is a subtype of `bitstring()`.\n\n### Atoms\n\n#### All atoms\n\n```elixir\natom()\n```\n\n#### Individual atoms\n\n```elixir\n:ok\n:error\nSomeModule\n```\n\n### Functions\n\n#### All functions\n\n```elixir\nfunction()\n```\n\n#### `n`-arity functions\n\n```elixir\n(-> :ok)\n(integer() -> boolean())\n(binary(), binary() -> binary())\n```\n\n#### Multiple clauses\n\n```elixir\n(integer() -> binary()) and (binary() -> atom())\n```\n\n### Maps\n\n#### All maps\n\n```elixir\nmap()\n```\n\n#### Empty map\n\n```elixir\nempty_map()\n```\n\n#### Maps with atom keys\n\n```elixir\n# Only has the keys name and age\n%{name: binary(), age: integer()}\n\n# Has the name key and age is optional\n%{name: binary(), age: if_set(integer())}\n\n# Has the keys name and age and may have other keys (open map)\n%{..., name: binary(), age: integer()}\n\n# Has the key name, may have other keys, but age is not set\n%{..., name: binary(), age: not_set()}\n```\n\n#### Maps with domain keys (domain keys are always treated as optional)\n\n```elixir\n# Has atom and binary keys\n%{atom() => binary(), binary() => binary()}\n\n# Has atom and binary keys and may have other keys (open map)\n%{..., atom() => binary(), binary() => binary()}\n```\n\n#### Maps with mixed keys\n\n```elixir\n# Has atom keys with binary values but a `:root` key of type integer\n%{atom() => binary(), root: integer()}\n\n# Has atom keys with binary values but a `:root` key of type integer, and may have other keys\n%{..., atom() => binary(), root: integer()}\n```\n\n#### Domain keys are `atom()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, `tuple()`\n\n### Non-empty lists\n\n#### Proper lists\n\n```elixir\nnon_empty_list(elem_type)\n```\n\n#### Improper lists (as long as `tail_type` does not include lists)\n\n```elixir\nnon_empty_list(elem_type, tail_type)\n```\n\n### Tuples\n\n#### All tuples\n\n```elixir\ntuple()\n```\n\n#### n-element tuples\n\n```elixir\n{:ok, binary()}\n{:error, binary(), term()}\n{pid(), reference()}\n```\n\n#### At least n-element tuples\n\n```elixir\n{binary(), binary(), ...}\n```\n\n## Additional types for convenience\n\n#### Common aliases\n\n```elixir\nboolean() = true or false\nnumber() = integer() or float()\n```\n\n#### List aliases\n\n```elixir\nlist() = empty_list() or non_empty_list(term())\nlist(a) = empty_list() or non_empty_list(a)\nlist(a, b) = empty_list() or non_empty_list(a, b)\n```" }, { "path": "lib/elixir/pages/getting-started/alias-require-and-import.md", "content": "\n\n# alias, require, import, and use\n\nIn order to facilitate software reuse, Elixir provides three directives (`alias`, `require`, and `import`) plus a macro called `use` summarized below:\n\n```elixir\n# Alias the module so it can be called as Bar instead of Foo.Bar\nalias Foo.Bar, as: Bar\n\n# Require the module in order to use its macros\nrequire Foo\n\n# Import functions from Foo so they can be called without the `Foo.` prefix\nimport Foo\n\n# Invokes the custom code defined in Foo as an extension point\nuse Foo\n```\n\nWe are going to explore them in detail now. Keep in mind the first three are called directives because they have *lexical scope*, while `use` is a common extension point that allows the used module to inject code.\n\n## alias\n\n`alias` allows you to set up aliases for any given module name.\n\nImagine a module uses a specialized list implemented in `Math.List`. The `alias` directive allows referring to `Math.List` just as `List` within the module definition:\n\n```elixir\ndefmodule Stats do\n alias Math.List, as: List\n # In the remaining module definition List expands to Math.List.\nend\n```\n\nThe original `List` can still be accessed within `Stats` by the fully-qualified name `Elixir.List`.\n\n> All modules defined in Elixir are defined inside the main `Elixir` namespace, such as `Elixir.String`. However, for convenience, you can omit \"Elixir.\" when referencing them.\n\nAliases are frequently used to define shortcuts. In fact, calling `alias` without an `:as` option sets the alias automatically to the last part of the module name, for example:\n\n```elixir\nalias Math.List\n```\n\nIs the same as:\n\n```elixir\nalias Math.List, as: List\n```\n\nNote that `alias` is *lexically scoped*, which allows you to set aliases inside specific functions:\n\n```elixir\ndefmodule Math do\n def plus(a, b) do\n alias Math.List\n # ...\n end\n\n def minus(a, b) do\n # ...\n end\nend\n```\n\nIn the example above, since we are invoking `alias` inside the function `plus/2`, the alias will be valid only inside the function `plus/2`. `minus/2` won't be affected at all.\n\n## require\n\nElixir provides macros as a mechanism for meta-programming (writing code that generates code). Macros are expanded at compile time.\n\nPublic functions in modules are globally available, but in order to use macros, you need to opt-in by requiring the module they are defined in.\n\n```elixir\niex> Integer.is_odd(3)\n** (UndefinedFunctionError) function Integer.is_odd/1 is undefined or private. However, there is a macro with the same name and arity. Be sure to require Integer if you intend to invoke this macro\n (elixir) Integer.is_odd(3)\niex> require Integer\nInteger\niex> Integer.is_odd(3)\ntrue\n```\n\nIn Elixir, `Integer.is_odd/1` is defined as a macro so that it can be used as a guard. This means that, in order to invoke `Integer.is_odd/1`, we need to first require the `Integer` module.\n\nNote that like the `alias` directive, `require` is also lexically scoped. We will talk more about macros in a later chapter.\n\n## import\n\nWe use `import` whenever we want to access functions or macros from other modules without using the fully-qualified name. Note we can only import public functions, as private functions are never accessible externally.\n\nFor example, if we want to use the `duplicate/2` function from the `List` module several times, we can import it:\n\n```elixir\niex> import List, only: [duplicate: 2]\nList\niex> duplicate(:ok, 3)\n[:ok, :ok, :ok]\n```\n\nWe imported only the function `duplicate` (with arity 2) from `List`. Although `:only` is optional, its usage is recommended in order to avoid importing all the functions of a given module inside the current scope. `:except` could also be given as an option in order to import everything in a module except a list of functions.\n\nNote that `import` is *lexically scoped* too. This means that we can import specific macros or functions inside function definitions:\n\n```elixir\ndefmodule Math do\n def some_function do\n import List, only: [duplicate: 2]\n duplicate(:ok, 10)\n end\nend\n```\n\nIn the example above, the imported `List.duplicate/2` is only visible within that specific function. `duplicate/2` won't be available in any other function in that module (or any other module for that matter).\n\nWhile `import`s can be useful for frameworks and libraries to build abstractions, developers should generally prefer `alias` to `import` on their own codebases, as aliases make the origin of the function being invoked clearer.\n\n## use\n\nThe `use` macro is frequently used as an extension point. This means that, when you `use` a module `FooBar`, you allow that module to inject *any* code in the current module, such as importing itself or other modules, defining new functions, setting a module state, etc.\n\nFor example, in order to write tests using the ExUnit framework, a developer should use the `ExUnit.Case` module:\n\n```elixir\ndefmodule AssertionTest do\n use ExUnit.Case, async: true\n\n test \"always pass\" do\n assert true\n end\nend\n```\n\nBehind the scenes, `use` requires the given module and then calls the `__using__/1` callback on it allowing the module to inject some code into the current context. Some modules (for example, the above `ExUnit.Case`, but also `Supervisor` and `GenServer`) use this mechanism to populate your module with some basic behaviour, which your module is intended to override or complete.\n\nGenerally speaking, the following module:\n\n```elixir\ndefmodule Example do\n use Feature, option: :value\nend\n```\n\nis compiled into\n\n```elixir\ndefmodule Example do\n require Feature\n Feature.__using__(option: :value)\nend\n```\n\nSince `use` allows any code to run, we can't really know the side-effects of using a module without reading its documentation. Therefore use this function with care and only if strictly required. Don't use `use` where an `import` or `alias` would do.\n\n## Multi alias/import/require/use\n\nIt is possible to `alias`, `import`, `require`, or `use` multiple modules at once. This is particularly useful once we start nesting modules, which is very common when building Elixir applications. For example, imagine you have an application where all modules are nested under `MyApp`, you can alias the modules `MyApp.Foo`, `MyApp.Bar` and `MyApp.Baz` at once as follows:\n\n```elixir\nalias MyApp.{Foo, Bar, Baz}\n```\n\nWith this, we have finished our tour of Elixir modules.\n" }, { "path": "lib/elixir/pages/getting-started/anonymous-functions.md", "content": "\n\n# Anonymous functions\n\nAnonymous functions allow us to store and pass executable code around as if it was an integer or a string. Let's learn more.\n\n## Identifying functions and documentation\n\nBefore we move on to discuss anonymous functions, let's talk about how Elixir identifies named functions – the functions defined in [modules](modules-and-functions.md).\n\nFunctions in Elixir are identified by both their name and their arity. The arity of a function describes the number of arguments that the function takes. From this point on we will use both the function name and its arity to describe functions throughout the documentation. `trunc/1` identifies the function which is named `trunc` and takes `1` argument, whereas `trunc/2` identifies a different (nonexistent) function with the same name but with an arity of `2`.\n\nWe can also use this syntax to access documentation. The Elixir shell defines the [`h`](`IEx.Helpers.h/1`) function, which you can use to access documentation for any function. For example, typing `h trunc/1` is going to print the documentation for the `trunc/1` function:\n\n```elixir\niex> h trunc/1\n def trunc(number)\n\nReturns the integer part of number.\n```\n\n`h trunc/1` works because it is defined in the `Kernel` module. All functions in the `Kernel` module are automatically imported into our namespace. Most often you will also include the module name when looking up the documentation for a given function:\n\n```elixir\niex> h Kernel.trunc/1\n def trunc(number)\n\nReturns the integer part of number.\n```\n\nYou can use the module+function identifiers to lookup documentation for anything, including operators (try `h Kernel.+/2`). Invoking [`h`](`IEx.Helpers.h/1`) without arguments displays the documentation for `IEx.Helpers`, which is where `h` and other functionalities are defined.\n\n## Defining anonymous functions\n\nAnonymous functions in Elixir are delimited by the keywords `fn` and `end`:\n\n```elixir\niex> add = fn a, b -> a + b end\n#Function<12.71889879/2 in :erl_eval.expr/5>\n```\n\nIn the example above, we defined an anonymous function that receives two arguments, `a` and `b`, and returns the result of `a + b`. The arguments are always on the left-hand side of `->` and the code to be executed on the right-hand side. The anonymous function is stored in the variable `add`. You can see it returns a value represented by `#Function<...>`. While its representation is opaque, the `:erl_eval.expr` bit tells us the function was defined in the shell (during evaluation).\n\nWe can invoke anonymous functions by passing arguments to it, using a dot (`.`) between the variable and the opening parenthesis:\n\n```elixir\niex> add.(1, 2)\n3\n```\n\nThe dot makes it clear when you are calling an anonymous function, stored in the variable `add`, opposed to a function named `add/2`. For example, if you have an anonymous function stored in the variable `is_atom`, there is no ambiguity between `is_atom.(:foo)` and `is_atom(:foo)`. If both used the same `is_atom(:foo)` syntax, the only way to know the actual behavior of `is_atom(:foo)` would be by scanning all code thus far for a possible definition of the `is_atom` variable. This scanning hurts maintainability as it requires developers to track additional context in their head when reading and writing code.\n\nAnonymous functions in Elixir are also identified by the number of arguments they receive. We can check if a value is a function using `is_function/1` and also check its arity by using `is_function/2`:\n\n```elixir\niex> is_function(add)\ntrue\n# check if add is a function that expects exactly 2 arguments\niex> is_function(add, 2)\ntrue\n# check if add is a function that expects exactly 1 argument\niex> is_function(add, 1)\nfalse\n```\n\n## Closures\n\nAnonymous functions can also access variables that are in scope when the function is defined. This is typically referred to as closures, as they close over their scope. Let's define a new anonymous function that uses the `add` anonymous function we have previously defined:\n\n```elixir\niex> double = fn a -> add.(a, a) end\n#Function<6.71889879/1 in :erl_eval.expr/5>\niex> double.(2)\n4\n```\n\nA variable assigned inside a function does not affect its surrounding environment:\n\n```elixir\niex> x = 42\n42\niex> (fn -> x = 0 end).()\n0\niex> x\n42\n```\n\n## Clauses and guards\n\nSimilar to `case/2`, we can pattern match on the arguments of anonymous functions as well as define multiple clauses and guards:\n\n```elixir\niex> f = fn\n...> x, y when x > 0 -> x + y\n...> x, y -> x * y\n...> end\n#Function<12.71889879/2 in :erl_eval.expr/5>\niex> f.(1, 3)\n4\niex> f.(-1, 3)\n-3\n```\n\nThe number of arguments in each anonymous function clause needs to be the same, otherwise an error is raised.\n\n```elixir\niex> f2 = fn\n...> x, y when x > 0 -> x + y\n...> x, y, z -> x * y + z\n...> end\n** (CompileError) iex:1: cannot mix clauses with different arities in anonymous functions\n```\n\n## The capture operator\n\nThroughout this guide, we have been using the notation `name/arity` to refer to functions. It happens that this notation can actually be used to capture an existing function into a data-type we can pass around, similar to how anonymous functions behave.\n\n```elixir\niex> fun = &is_atom/1\n&:erlang.is_atom/1\niex> is_function(fun)\ntrue\niex> fun.(:hello)\ntrue\niex> fun.(123)\nfalse\n```\n\nAs you can see, once a function is captured, we can pass it as argument or invoke it using the anonymous function notation. The returned value above also hints we can capture functions defined in modules:\n\n```elixir\niex> fun = &String.length/1\n&String.length/1\niex> fun.(\"hello\")\n5\n```\n\nSince operators are functions in Elixir, you can also capture operators:\n\n```elixir\niex> add = &+/2\n&:erlang.+/2\niex> add.(1, 2)\n3\n```\n\nThe capture syntax can also be used as a shortcut for creating functions that wrap existing functions. For example, imagine you want to create an anonymous function that checks if a given function has arity 2. You could write it as:\n\n```elixir\niex> is_arity_2 = fn fun -> is_function(fun, 2) end\n#Function<8.71889879/1 in :erl_eval.expr/5>\niex> is_arity_2.(add)\ntrue\n```\n\nBut using the capture syntax, you can write it as:\n\n```elixir\niex> is_arity_2 = &is_function(&1, 2)\n#Function<8.71889879/1 in :erl_eval.expr/5>\niex> is_arity_2.(add)\ntrue\n```\n\nThe `&1` represents the first argument passed into the function. Therefore both `is_arity_2` anonymous functions defined above are equivalent.\n\nOnce again, given operators are function calls, the capture syntax shorthand also works with operators, or even string interpolation:\n\n```elixir\niex> fun = &(&1 + 1)\n#Function<6.71889879/1 in :erl_eval.expr/5>\niex> fun.(1)\n2\n\niex> fun2 = &\"Good #{&1}\"\n#Function<6.127694169/1 in :erl_eval.expr/5>\niex> fun2.(\"morning\")\n\"Good morning\"\n```\n\n`&(&1 + 1)` above is exactly the same as `fn x -> x + 1 end`. You can read more about the capture operator `&` in [its documentation](`&/1`).\n\nNext let's revisit some of the data-types we learned in the past and dig deeper into how they work.\n" }, { "path": "lib/elixir/pages/getting-started/basic-types.md", "content": "\n\n# Basic types\n\nIn this chapter we will learn more about Elixir basic types: integers, floats, booleans, atoms, and strings. Other data types, such as lists and tuples, will be explored in the next chapter.\n\n```elixir\niex> 1 # integer\niex> 0x1F # integer\niex> 1.0 # float\niex> true # boolean\niex> :atom # atom / symbol\niex> \"elixir\" # string\niex> [1, 2, 3] # list\niex> {1, 2, 3} # tuple\n```\n\n## Basic arithmetic\n\nOpen up `iex` and type the following expressions:\n\n```elixir\niex> 1 + 2\n3\niex> 5 * 5\n25\niex> 10 / 2\n5.0\n```\n\nNotice that `10 / 2` returned a float `5.0` instead of an integer `5`. This is expected. In Elixir, the operator [`/`](`//2`) always returns a float. If you want to do integer division or get the division remainder, you can invoke the [`div`](`div/2`) and [`rem`](`rem/2`) functions:\n\n```elixir\niex> div(10, 2)\n5\niex> div 10, 2\n5\niex> rem 10, 3\n1\n```\n\nNotice that Elixir allows you to drop the parentheses when invoking functions that expect one or more arguments. This feature gives a cleaner syntax when writing declarations and control-flow constructs. However, Elixir developers generally prefer to use parentheses.\n\nElixir also supports shortcut notations for entering binary, octal, and hexadecimal numbers:\n\n```elixir\niex> 0b1010\n10\niex> 0o777\n511\niex> 0x1F\n31\n```\n\nFloat numbers require a dot followed by at least one digit and also support `e` for scientific notation:\n\n```elixir\niex> 1.0\n1.0\niex> 1.0e-10\n1.0e-10\n```\n\nFloats in Elixir are 64-bit precision.\n\nYou can invoke the [`round`](`round/1`) function to get the closest integer to a given float, or the [`trunc`](`trunc/1`) function to get the integer part of a float.\n\n```elixir\niex> round(3.58)\n4\niex> trunc(3.58)\n3\n```\n\nFinally, we work with different data types, we will learn Elixir provides several predicate functions to check for the type of a value. For example, [`is_integer`](`is_integer/1`) can be used to check if a value is an integer or not:\n\n```elixir\niex> is_integer(1)\ntrue\niex> is_integer(2.0)\nfalse\n```\n\nYou can also use [`is_float`](`is_float/1`) or [`is_number`](`is_number/1`) to check, respectively, if an argument is a float, or either an integer or float.\n\n## Booleans and `nil`\n\nElixir supports `true` and `false` as booleans:\n\n```elixir\niex> true\ntrue\niex> true == false\nfalse\n```\n\nElixir also provides three boolean operators: [`or`](`or/2`), [`and`](`and/2`), and [`not`](`not/1`). These operators are strict in the sense that they expect something that evaluates to a boolean (`true` or `false`) as their first argument:\n\n```elixir\niex> true and true\ntrue\niex> false or is_boolean(true)\ntrue\n```\n\nProviding a non-boolean will raise an exception:\n\n```elixir\niex> 1 and true\n** (BadBooleanError) expected a boolean on left-side of \"and\", got: 1\n```\n\n`or` and `and` are short-circuit operators. They only execute the right side if the left side is not enough to determine the result:\n\n```elixir\niex> false and raise(\"This error will never be raised\")\nfalse\niex> true or raise(\"This error will never be raised\")\ntrue\n```\n\nElixir also provides the concept of `nil`, to indicate the absence of a value, and a set of logical operators that also manipulate `nil`: `||/2`, `&&/2`, and `!/1`. For these operators, `false` and `nil` are considered \"falsy\", all other values are considered \"truthy\":\n\n```elixir\n# or\niex> 1 || true\n1\niex> false || 11\n11\n\n# and\niex> nil && 13\nnil\niex> true && 17\n17\n\n# not\niex> !true\nfalse\niex> !1\nfalse\niex> !nil\ntrue\n```\n\nSimilarly, values like `0` and `\"\"`, which some other programming languages consider to be \"falsy\", are also \"truthy\" in Elixir.\n\nAs a rule of thumb, use `and`, `or` and `not` when you are expecting booleans. If any of the arguments are non-boolean, use `&&`, `||` and `!`.\n\n## Atoms\n\nAn atom is a constant whose value is its own name. Some other languages call these symbols. They are often useful to enumerate over distinct values, such as:\n\n```elixir\niex> :apple\n:apple\niex> :orange\n:orange\niex> :watermelon\n:watermelon\n```\n\nAtoms are equal if their names are equal.\n\n```elixir\niex> :apple == :apple\ntrue\niex> :apple == :orange\nfalse\n```\n\nOften they are used to express the state of an operation, by using values such as `:ok` and `:error`.\n\nThe booleans `true` and `false` are also atoms:\n\n```elixir\niex> true == :true\ntrue\niex> is_atom(false)\ntrue\niex> is_boolean(:false)\ntrue\n```\n\nElixir allows you to skip the leading `:` for the atoms `false`, `true` and `nil`.\n\n## Strings\n\nStrings in Elixir are delimited by double quotes, and they are encoded in UTF-8:\n\n```elixir\niex> \"hellö\"\n\"hellö\"\n```\n\n> Note: if you are running on Windows, there is a chance your terminal does not use UTF-8 by default. You can change the encoding of your current session by running `chcp 65001` before entering IEx.\n\nYou can concatenate two strings with the [`<>`](`<>/2`) operator:\n\n```elixir\niex> \"hello \" <> \"world!\"\n\"hello world!\"\n```\n\nElixir also supports string interpolation:\n\n```elixir\niex> string = \"world\"\niex> \"hello #{string}!\"\n\"hello world!\"\n```\n\nString concatenation requires both sides to be strings but interpolation supports any data type that may be converted to a string:\n\n```elixir\niex> number = 42\niex> \"i am #{number} years old!\"\n\"i am 42 years old!\"\n```\n\nStrings can have line breaks in them. You can introduce them using escape sequences:\n\n```elixir\niex> \"hello\n...> world\"\n\"hello\\nworld\"\niex> \"hello\\nworld\"\n\"hello\\nworld\"\n```\n\nYou can print a string using the [`IO.puts`](`IO.puts/1`) function from the `IO` module:\n\n```elixir\niex> IO.puts(\"hello\\nworld\")\nhello\nworld\n:ok\n```\n\nNotice that the [`IO.puts`](`IO.puts/1`) function returns the atom `:ok` after printing.\n\nStrings in Elixir are represented internally by contiguous sequences of bytes known as binaries:\n\n```elixir\niex> is_binary(\"hellö\")\ntrue\n```\n\nWe can also get the number of bytes in a string:\n\n```elixir\niex> byte_size(\"hellö\")\n6\n```\n\nNotice that the number of bytes in that string is 6, even though it has 5 graphemes. That's because the grapheme \"ö\" takes 2 bytes to be represented in UTF-8. We can get the actual length of the string, based on the number of graphemes, by using the [`String.length`](`String.length/1`) function:\n\n```elixir\niex> String.length(\"hellö\")\n5\n```\n\nThe `String` module contains a bunch of functions that operate on strings as defined in the Unicode standard:\n\n```elixir\niex> String.upcase(\"hellö\")\n\"HELLÖ\"\n```\n\n## Structural comparison\n\nElixir also provides [`==`](`==/2`), [`!=`](`!=/2`), [`<=`](`<=/2`), [`>=`](`>=/2`), [`<`](``](`>/2`) as comparison operators. We can compare numbers:\n\n```elixir\niex> 1 == 1\ntrue\niex> 1 != 2\ntrue\niex> 1 < 2\ntrue\n```\n\nBut also atoms, strings, booleans, etc:\n\n```elixir\niex> \"foo\" == \"foo\"\ntrue\niex> \"foo\" == \"bar\"\nfalse\n```\n\nIntegers and floats compare the same if they have the same value:\n\n```elixir\niex> 1 == 1.0\ntrue\niex> 1 == 2.0\nfalse\n```\n\nHowever, you can use the strict comparison operator [`===`](`===/2`) and [`!==`](`!==/2`) if you want to distinguish between integers and floats:\n\n```elixir\niex> 1 === 1.0\nfalse\n```\n\nThe comparison operators in Elixir can compare across any data type. We say these operators perform _structural comparison_. For more information, you can read our documentation on [Structural vs Semantic comparisons](`Kernel#module-structural-comparison`).\n\nElixir also provides data-types for expressing collections, such as lists and tuples, which we learn next. When we talk about concurrency and fault-tolerance via processes, we will also discuss ports, pids, and references, but that will come on later chapters. Let's move forward.\n" }, { "path": "lib/elixir/pages/getting-started/binaries-strings-and-charlists.md", "content": "\n\n# Binaries, strings, and charlists\n\nIn [\"Basic types\"](basic-types.md), we learned a bit about strings and we used the `is_binary/1` function for checks:\n\n```elixir\niex> string = \"hello\"\n\"hello\"\niex> is_binary(string)\ntrue\n```\n\nIn this chapter, we will gain clarity on what exactly binaries are and how they relate to strings. We will also learn about charlists, `~c\"like this\"`, which are often used for interoperability with Erlang.\n\nAlthough strings are one of the most common data types in computer languages, they are subtly complex and are often misunderstood. To understand strings in Elixir, let's first discuss [Unicode](https://en.wikipedia.org/wiki/Unicode) and character encodings, specifically the [UTF-8](https://en.wikipedia.org/wiki/UTF-8) encoding.\n\n## Unicode and Code Points\n\nIn order to facilitate meaningful communication between computers across multiple languages, a standard is required so that the ones and zeros on one machine mean the same thing when they are transmitted to another. The [Unicode Standard](https://unicode.org/standard/standard.html) acts as an official registry of virtually all the characters we know: this includes characters from classical and historical texts, emoji, and formatting and control characters as well.\n\nUnicode organizes all of the characters in its repertoire into code charts, and each character is given a unique numerical index. This numerical index is known as a [Code Point](https://en.wikipedia.org/wiki/Code_point).\n\nIn Elixir you can use a `?` in front of a character literal to reveal its code point:\n\n```elixir\niex> ?a\n97\niex> ?ł\n322\n```\n\nNote that most Unicode code charts will refer to a code point by its hexadecimal (hex) representation, e.g. `97` translates to `0061` in hex, and we can represent any Unicode character in an Elixir string by using the `\\uXXXX` notation and the hex representation of its code point number:\n\n```elixir\niex> \"\\u0061\" == \"a\"\ntrue\niex> 0x0061 = 97 = ?a\n97\n```\n\nThe hex representation will also help you look up information about a code point, e.g. [https://codepoints.net/U+0061](https://codepoints.net/U+0061) has a data sheet all about the lower case `a`, a.k.a. code point 97.\n\n## UTF-8 and Encodings\n\nNow that we understand what the Unicode standard is and what code points are, we can finally talk about encodings. Whereas the code point is **what** we store, an encoding deals with **how** we store it: encoding is an implementation. In other words, we need a mechanism to convert the code point numbers into bytes so they can be stored in memory, written to disk, etc.\n\nElixir uses UTF-8 to encode its strings, which means that code points are encoded as a series of 8-bit bytes. UTF-8 is a **variable width** character encoding that uses one to four bytes to store each code point. It is capable of encoding all valid Unicode code points. Let's see an example:\n\n```elixir\niex> string = \"héllo\"\n\"héllo\"\niex> String.length(string)\n5\niex> byte_size(string)\n6\n```\n\nAlthough the string above has 5 characters, it uses 6 bytes, as two bytes are used to represent the character `é`.\n\n> Note: if you are running on Windows, there is a chance your terminal does not use UTF-8 by default. You can change the encoding of your current session by running `chcp 65001` before entering `iex` (`iex.bat`).\n\nBesides defining characters, UTF-8 also provides a notion of graphemes. Graphemes may consist of multiple characters that are often perceived as one. For example, the [woman firefighter emoji](https://emojipedia.org/woman-firefighter/) is represented as the combination of three characters: the woman emoji (👩), a hidden zero-width joiner, and the fire engine emoji (🚒):\n\n```elixir\niex> String.codepoints(\"👩‍🚒\")\n[\"👩\", \"‍\", \"🚒\"]\niex> String.graphemes(\"👩‍🚒\")\n[\"👩‍🚒\"]\n```\n\nHowever, Elixir is smart enough to know they are seen as a single character, and therefore the length is still one:\n\n```elixir\niex> String.length(\"👩‍🚒\")\n1\n```\n\n> Note: if you can't see the emoji above in your terminal, you need to make sure your terminal supports emoji and that you are using a font that can render them.\n\nAlthough these rules may sound complicated, UTF-8 encoded documents are everywhere. This page itself is encoded in UTF-8. The encoding information is given to your browser which then knows how to render all of the bytes, characters, and graphemes accordingly.\n\nIf you want to see the exact bytes that a string would be stored in a file, a common trick is to concatenate the null byte `<<0>>` to it:\n\n```elixir\niex> \"hełło\" <> <<0>>\n<<104, 101, 197, 130, 197, 130, 111, 0>>\n```\n\nAlternatively, you can view a string's binary representation by using `IO.inspect/2`:\n\n```elixir\niex> IO.inspect(\"hełło\", binaries: :as_binaries)\n<<104, 101, 197, 130, 197, 130, 111>>\n```\n\nWe are getting a little bit ahead of ourselves. Let's talk about bitstrings to learn about what exactly the `<<>>` constructor means.\n\n## Bitstrings\n\nAlthough we have covered code points and UTF-8 encoding, we still need to go a bit deeper into how exactly we store the encoded bytes, and this is where we introduce the **bitstring**. A bitstring is a fundamental data type in Elixir, denoted with the [`<<>>`](`<<>>/1`) syntax. **A bitstring is a contiguous sequence of bits in memory.**\n\nBy default, 8 bits (i.e. 1 byte) is used to store each number in a bitstring, but you can manually specify the number of bits via a `::n` modifier to denote the size in `n` bits, or you can use the more verbose declaration `::size(n)`:\n\n```elixir\niex> <<42>> == <<42::8>>\ntrue\niex> <<3::4>>\n<<3::size(4)>>\n```\n\nFor example, the decimal number `3` when represented with 4 bits in base 2 would be `0011`, which is equivalent to the values `0`, `0`, `1`, `1`, each stored using 1 bit:\n\n```elixir\niex> <<0::1, 0::1, 1::1, 1::1>> == <<3::4>>\ntrue\n```\n\nAny value that exceeds what can be stored by the number of bits provisioned is truncated:\n\n```elixir\niex> <<1>> == <<257>>\ntrue\n```\n\nHere, 257 in base 2 would be represented as `100000001`, but since we have reserved only 8 bits for its representation (by default), the left-most bit is ignored and the value becomes truncated to `00000001`, or simply `1` in decimal.\n\nA complete reference for the bitstring constructor can be found in [`<<>>`](`<<>>/1`)'s documentation.\n\n## Binaries\n\n**A binary is a bitstring where the number of bits is divisible by 8.** That means that every binary is a bitstring, but not every bitstring is a binary. We can use the `is_bitstring/1` and `is_binary/1` functions to demonstrate this.\n\n```elixir\niex> is_bitstring(<<3::4>>)\ntrue\niex> is_binary(<<3::4>>)\nfalse\niex> is_bitstring(<<0, 255, 42>>)\ntrue\niex> is_binary(<<0, 255, 42>>)\ntrue\niex> is_binary(<<42::16>>)\ntrue\n```\n\nWe can pattern match on binaries / bitstrings:\n\n```elixir\niex> <<0, 1, x>> = <<0, 1, 2>>\n<<0, 1, 2>>\niex> x\n2\niex> <<0, 1, x>> = <<0, 1, 2, 3>>\n** (MatchError) no match of right hand side value: <<0, 1, 2, 3>>\n```\n\nNote that unless you explicitly use `::` modifiers, each entry in the binary pattern is expected to match a single byte (exactly 8 bits). If we want to match on a binary of unknown size, we can use the `binary` modifier at the end of the pattern:\n\n```elixir\niex> <<0, 1, x::binary>> = <<0, 1, 2, 3>>\n<<0, 1, 2, 3>>\niex> x\n<<2, 3>>\n```\n\nThere are a couple other modifiers that can be useful when doing pattern matches on binaries. The `binary-size(n)` modifier will match `n` bytes in a binary:\n\n```elixir\niex> <> = <<0, 1, 2, 3>>\n<<0, 1, 2, 3>>\niex> head\n<<0, 1>>\niex> rest\n<<2, 3>>\n```\n\n**A string is a UTF-8 encoded binary**, where the code point for each character is encoded using 1 to 4 bytes. Thus every string is a binary, but due to the UTF-8 standard encoding rules, not every binary is a valid string.\n\n```elixir\niex> is_binary(\"hello\")\ntrue\niex> is_binary(<<239, 191, 19>>)\ntrue\niex> String.valid?(<<239, 191, 19>>)\nfalse\n```\n\nThe string concatenation operator [`<>`](`<>/2`) is actually a binary concatenation operator:\n\n```elixir\niex> \"a\" <> \"ha\"\n\"aha\"\niex> <<0, 1>> <> <<2, 3>>\n<<0, 1, 2, 3>>\n```\n\nGiven that strings are binaries, we can also pattern match on strings:\n\n```elixir\niex> <> = \"banana\"\n\"banana\"\niex> head == ?b\ntrue\niex> rest\n\"anana\"\n```\n\nHowever, remember that binary pattern matching works on *bytes*, so matching on the string like \"über\" with multibyte characters won't match on the *character*, it will match on the *first byte of that character*:\n\n```elixir\niex> \"ü\" <> <<0>>\n<<195, 188, 0>>\niex> <> = \"über\"\n\"über\"\niex> x == ?ü\nfalse\niex> rest\n<<188, 98, 101, 114>>\n```\n\nAbove, `x` matched on only the first byte of the multibyte `ü` character.\n\nTherefore, when pattern matching on strings, it is important to use the `utf8` modifier:\n\n```elixir\niex> <> = \"über\"\n\"über\"\niex> x == ?ü\ntrue\niex> rest\n\"ber\"\n```\n\n## Charlists\n\nOur tour of our bitstrings, binaries, and strings is nearly complete, but we have one more data type to explain: the charlist.\n\n**A charlist is a list of integers where all the integers are valid code points.** In practice, you will not come across them often, only in specific scenarios such as interfacing with older Erlang libraries that do not accept binaries as arguments.\n\n```elixir\niex> ~c\"hello\"\n~c\"hello\"\niex> [?h, ?e, ?l, ?l, ?o]\n~c\"hello\"\n```\n\nThe [`~c`](`Kernel.sigil_c/2`) sigil (we'll cover sigils later in the [\"Sigils\"](sigils.md) chapter) indicates the fact that we are dealing with a charlist and not a regular string.\n\nInstead of containing bytes, a charlist contains integer code points. However, the list is only printed as a sigil if all code points are within the ASCII range:\n\n```elixir\niex> ~c\"hełło\"\n[104, 101, 322, 322, 111]\niex> is_list(~c\"hełło\")\ntrue\n```\n\nThis is done to ease interoperability with Erlang, even though it may lead to some surprising behavior. For example, if you are storing a list of integers that happen to range between 0 and 127, by default IEx will interpret this as a charlist and it will display the corresponding ASCII characters.\n\n```elixir\niex> heartbeats_per_minute = [99, 97, 116]\n~c\"cat\"\n```\n\nYou can always force charlists to be printed in their list representation by calling the `inspect/2` function:\n\n```elixir\niex> inspect(heartbeats_per_minute, charlists: :as_list)\n\"[99, 97, 116]\"\n```\n\nFurthermore, you can convert a charlist to a string and back by using the `to_string/1` and `to_charlist/1`:\n\n```elixir\niex> to_charlist(\"hełło\")\n[104, 101, 322, 322, 111]\niex> to_string(~c\"hełło\")\n\"hełło\"\niex> to_string(:hello)\n\"hello\"\niex> to_string(1)\n\"1\"\n```\n\nThe functions above are polymorphic, in other words, they accept many shapes: not only do they convert charlists to strings (and vice-versa), they can also convert integers, atoms, and so on.\n\nString (binary) concatenation uses the [`<>`](`<>/2`) operator but charlists, being lists, use the list concatenation operator [`++`](`++/2`):\n\n```elixir\niex> ~c\"this \" <> ~c\"fails\"\n** (ArgumentError) expected binary argument in <> operator but got: ~c\"this \"\n (elixir) lib/kernel.ex:1821: Kernel.wrap_concatenation/3\n (elixir) lib/kernel.ex:1808: Kernel.extract_concatenations/2\n (elixir) expanding macro: Kernel.<>/2\n iex:1: (file)\niex> ~c\"this \" ++ ~c\"works\"\n~c\"this works\"\niex> \"he\" ++ \"llo\"\n** (ArgumentError) argument error\n :erlang.++(\"he\", \"llo\")\niex> \"he\" <> \"llo\"\n\"hello\"\n```\n\nWith binaries, strings, and charlists out of the way, it is time to talk about key-value data structures.\n" }, { "path": "lib/elixir/pages/getting-started/case-cond-and-if.md", "content": "\n\n# case, cond, and if\n\nIn this chapter, we will learn about the [`case`](`case/2`), [`cond`](`cond/1`), and [`if`](`if/2`) control flow structures.\n\n## case\n\n[`case`](`case/2`) allows us to compare a value against many patterns until we find a matching one:\n\n```elixir\niex> case {1, 2, 3} do\n...> {4, 5, 6} ->\n...> \"This clause won't match\"\n...> {1, x, 3} ->\n...> \"This clause will match and bind x to 2 in this clause\"\n...> _ ->\n...> \"This clause would match any value\"\n...> end\n\"This clause will match and bind x to 2 in this clause\"\n```\n\nIf you want to pattern match against an existing variable, you need to use the [`^`](`^/1`) operator:\n\n```elixir\niex> x = 1\n1\niex> case 10 do\n...> ^x -> \"Won't match\"\n...> _ -> \"Will match\"\n...> end\n\"Will match\"\n```\n\nClauses also allow extra conditions to be specified via guards:\n\n```elixir\niex> case {1, 2, 3} do\n...> {1, x, 3} when x > 0 ->\n...> \"Will match\"\n...> _ ->\n...> \"Would match, if guard condition were not satisfied\"\n...> end\n\"Will match\"\n```\n\nThe first clause above will only match when `x` is positive.\n\nKeep in mind errors in guards do not leak but simply make the guard fail:\n\n```elixir\niex> hd(1)\n** (ArgumentError) argument error\niex> case 1 do\n...> x when hd(x) -> \"Won't match\"\n...> x -> \"Got #{x}\"\n...> end\n\"Got 1\"\n```\n\nIf none of the clauses match, an error is raised:\n\n```elixir\niex> case :ok do\n...> :error -> \"Won't match\"\n...> end\n** (CaseClauseError) no case clause matching: :ok\n```\n\nThe documentation for the `Kernel` module lists all available guards in its sidebar. You can also consult the complete [Patterns and Guards](../references/patterns-and-guards.md#guards) reference for in-depth documentation.\n\n## if\n\n[`case`](`case/2`) builds on pattern matching and guards to destructure and match on certain conditions. However, patterns and guards are limited only to certain expressions which are optimized by the compiler. In many situations, you need to write conditions that go beyond what can be expressed with [`case`](`case/2`). For those, [`if`](`if/2`) is a useful alternative:\n\n```elixir\niex> if true do\n...> \"This works!\"\n...> end\n\"This works!\"\niex> if false do\n...> \"This will never be seen\"\n...> end\nnil\n```\n\nIf the condition given to [`if`](`if/2`) returns `false` or `nil`, the body given between `do`-`end` is not executed and instead it returns `nil`.\n\n[`if`](`if/2`) also supports `else` blocks:\n\n```elixir\niex> if nil do\n...> \"This won't be seen\"\n...> else\n...> \"This will\"\n...> end\n\"This will\"\n```\n\n### Expressions\n\nSome programming languages make a distinction about expressions (code that returns a value) and statements (code that returns no value). In Elixir, there are only expressions, no statements. Everything you write in Elixir language returns some value.\n\nThis property allows variables to be scoped to individual blocks of code such as [`if`](`if/2`), [`case`](`case/2`), where declarations or changes are only visible inside the block. A change can't leak to outer blocks, which makes code easier to follow and understand. For example:\n\n```elixir\niex> x = 1\n1\niex> if true do\n...> x = x + 1\n...> end\n2\niex> x\n1\n```\n\nYou see the return value of the [`if`](`if/2`) expression as the resulting `2` here. To retain changes made within the [`if`](`if/2`) expression on the outer block you need to assign the returned value to a variable in the outer block.\n\n```elixir\niex> x = 1\n1\niex> x =\n...> if true do\n...> x + 1\n...> else\n...> x\n...> end\n2\n```\n\nWith all expressions returning a value there's also no need for alternative constructs, such as ternary operators posing as an alternative to [`if`](`if/2`). Elixir does include an inline notation for [`if`](`if/2`) and, as we will [learn later](keywords-and-maps.md#do-blocks-and-keywords), it is a syntactic variation on `if`'s arguments.\n\n> #### `if` is a macro {: .info}\n>\n> An interesting note regarding [`if`](`if/2`) is that it is implemented as a macro in the language: it isn't a special language construct as it would be in many languages. You can check the documentation and its source for more information.\n\nIf you find yourself nesting several [`if`](`if/2`) blocks, you may want to consider using [`cond`](`cond/1`) instead. Let's check it out.\n\n## cond\n\nWe have used `case` to find a matching clause from many patterns. We have used `if` to check for a single condition. If you need to check across several conditions and find the first one that does not evaluate to `nil` or `false`, [`cond`](`cond/1`) is a useful construct:\n\n```elixir\niex> cond do\n...> 2 + 2 == 5 ->\n...> \"This will not be true\"\n...> 2 * 2 == 3 ->\n...> \"Nor this\"\n...> 1 + 1 == 2 ->\n...> \"But this will\"\n...> end\n\"But this will\"\n```\n\nThis is equivalent to `else if` clauses in many imperative languages - although used less frequently in Elixir.\n\nIf all of the conditions return `nil` or `false`, an error (`CondClauseError`) is raised. For this reason, it may be necessary to add a final condition, equal to `true`, which will always match:\n\n```elixir\niex> cond do\n...> 2 + 2 == 5 ->\n...> \"This is never true\"\n...> 2 * 2 == 3 ->\n...> \"Nor this\"\n...> true ->\n...> \"This is always true (equivalent to else)\"\n...> end\n\"This is always true (equivalent to else)\"\n```\n\nSimilar to [`if`](`if/2`), [`cond`](`cond/1`) considers any value besides `nil` and `false` to be true:\n\n```elixir\niex> cond do\n...> hd([1, 2, 3]) ->\n...> \"1 is considered as true\"\n...> end\n\"1 is considered as true\"\n```\n\n## Summing up\n\nWe have concluded the introduction to the most fundamental control-flow constructs in Elixir. Generally speaking, Elixir developers prefer pattern matching and guards, using [`case`](`case/2`) and function definitions (which we will explore in future chapters), as they are succinct and precise. When your logic cannot be outlined within patterns and guards, you may consider [`if`](`if/2`), falling back to [`cond`](`cond/1`) when there are several conditions to check.\n" }, { "path": "lib/elixir/pages/getting-started/comprehensions.md", "content": "\n\n# Comprehensions\n\nIn Elixir, it is common to loop over an `Enumerable`, often filtering out some results and mapping values into another list. Comprehensions are syntactic sugar for such constructs: they group those common tasks into the `for` special form.\n\nFor example, we can map a list of integers into their squared values:\n\n```elixir\niex> for n <- [1, 2, 3, 4], do: n * n\n[1, 4, 9, 16]\n```\n\nA comprehension is made of three parts: generators, filters, and collectables.\n\n## Generators and filters\n\nIn the expression above, `n <- [1, 2, 3, 4]` is the **generator**. It is literally generating values to be used in the comprehension. Any enumerable can be passed on the right-hand side of the generator expression:\n\n```elixir\niex> for n <- 1..4, do: n * n\n[1, 4, 9, 16]\n```\n\nGenerator expressions also support pattern matching on their left-hand side; all non-matching patterns are *ignored*. Imagine that, instead of a range, we have a keyword list where the key is the atom `:good` or `:bad` and we only want to compute the square of the `:good` values:\n\n```elixir\niex> values = [good: 1, good: 2, bad: 3, good: 4]\niex> for {:good, n} <- values, do: n * n\n[1, 4, 16]\n```\n\nAlternatively to pattern matching, filters can be used to select some particular elements. For example, we can select the multiples of 3 and discard all others:\n\n```elixir\niex> for n <- 0..5, rem(n, 3) == 0, do: n * n\n[0, 9]\n```\n\nComprehensions discard all elements for which the filter expression returns `false` or `nil`; all other values are selected.\n\nComprehensions generally provide a much more concise representation than using the equivalent functions from the `Enum` and `Stream` modules. Furthermore, comprehensions also allow multiple generators and filters to be given. Here is an example that receives a list of directories and gets the size of each file in those directories:\n\n```elixir\ndirs = [\"/home/mikey\", \"/home/james\"]\n\nfor dir <- dirs,\n file <- File.ls!(dir),\n path = Path.join(dir, file),\n File.regular?(path) do\n File.stat!(path).size\nend\n```\n\nMultiple generators can also be used to calculate the Cartesian product of two lists:\n\n```elixir\niex> for i <- [:a, :b, :c], j <- [1, 2], do: {i, j}\n[a: 1, a: 2, b: 1, b: 2, c: 1, c: 2]\n```\n\nFinally, keep in mind that variable assignments inside the comprehension, be it in generators, filters or inside the block, are not reflected outside of the comprehension.\n\n## Bitstring generators\n\nBitstring generators are also supported and are very useful when you need to comprehend over bitstring streams. The example below receives a list of pixels from a binary with their respective red, green and blue values and converts them into tuples of three elements each:\n\n```elixir\niex> pixels = <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>>\niex> for <>, do: {r, g, b}\n[{213, 45, 132}, {64, 76, 32}, {76, 0, 0}, {234, 32, 15}]\n```\n\nA bitstring generator can be mixed with \"regular\" enumerable generators, and supports filters as well.\n\n## The `:into` option\n\nIn the examples above, all the comprehensions returned lists as their result. However, the result of a comprehension can be inserted into different data structures by passing the `:into` option to the comprehension.\n\nFor example, a bitstring generator can be used with the `:into` option in order to easily remove all spaces in a string:\n\n```elixir\niex> for <>, c != ?\\s, into: \"\", do: <>\n\"helloworld\"\n```\n\nSets, maps, and other dictionaries can also be given to the `:into` option. In general, `:into` accepts any structure that implements the `Collectable` protocol.\n\nA common use case of `:into` can be transforming values in a map:\n\n```elixir\niex> for {key, val} <- %{\"a\" => 1, \"b\" => 2}, into: %{}, do: {key, val * val}\n%{\"a\" => 1, \"b\" => 4}\n```\n\nLet's make another example using streams. Since the `IO` module provides streams (that are both `Enumerable`s and `Collectable`s), an echo terminal that echoes back the upcased version of whatever is typed can be implemented using comprehensions:\n\n```elixir\niex> stream = IO.stream(:stdio, :line)\niex> for line <- stream, into: stream do\n...> String.upcase(line) <> \"\\n\"\n...> end\n```\n\nNow type any string into the terminal and you will see that the same value will be printed in upper-case. Unfortunately, this example also got your IEx shell stuck in the comprehension, so you will need to hit `Ctrl+C` twice to get out of it. :)\n\n## Other options\n\nComprehensions support other options, such as `:reduce` and `:uniq`. Here are additional resources to learn more about comprehensions:\n\n * [`for` official reference in Elixir documentation](`for/1`)\n * [Mitchell Hanberg's comprehensive guide to Elixir's comprehensions](https://www.mitchellhanberg.com/the-comprehensive-guide-to-elixirs-for-comprehension/)\n" }, { "path": "lib/elixir/pages/getting-started/debugging.md", "content": "\n\n# Debugging\n\nThere are a number of ways to debug code in Elixir. In this chapter we will cover some of the more common ways of doing so.\n\n## IO.inspect/2\n\nWhat makes `IO.inspect(item, opts \\\\ [])` really useful in debugging is that it returns the `item` argument passed to it without affecting the behavior of the original code. Let's see an example.\n\n```elixir\n(1..10)\n|> IO.inspect()\n|> Enum.map(fn x -> x * 2 end)\n|> IO.inspect()\n|> Enum.sum()\n|> IO.inspect()\n```\n\nPrints:\n\n```elixir\n1..10\n[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n110\n```\n\nAs you can see `IO.inspect/2` makes it possible to \"spy\" on values almost anywhere in your code without altering the result, making it very helpful inside of a pipeline like in the above case.\n\n`IO.inspect/2` also provides the ability to decorate the output with a `label` option. The label will be printed before the inspected `item`:\n\n```elixir\n[1, 2, 3]\n|> IO.inspect(label: \"before\")\n|> Enum.map(&(&1 * 2))\n|> IO.inspect(label: \"after\")\n|> Enum.sum\n```\n\nPrints:\n\n```elixir\nbefore: [1, 2, 3]\nafter: [2, 4, 6]\n```\n\nIt is also very common to use `IO.inspect/2` with `binding/0`, which returns all variable names and their values:\n\n```elixir\ndef some_function(a, b, c) do\n IO.inspect(binding())\n ...\nend\n```\n\nWhen `some_function/3` is invoked with `:foo`, `\"bar\"`, `:baz` it prints:\n\n```elixir\n[a: :foo, b: \"bar\", c: :baz]\n```\n\nSee `IO.inspect/2` and `Inspect.Opts` respectively to learn more about the function and read about all supported options.\n\n## dbg/2\n\nElixir v1.14 introduced `dbg/2`. `dbg` is similar to `IO.inspect/2` but specifically tailored for debugging. It prints the value passed to it and returns it (just like `IO.inspect/2`), but it also prints the code and location.\n\n```elixir\n# In my_file.exs\nfeature = %{name: :dbg, inspiration: \"Rust\"}\ndbg(feature)\ndbg(Map.put(feature, :in_version, \"1.14.0\"))\n```\n\nThe code above prints this:\n\n```text\n[my_file.exs:2: (file)]\nfeature #=> %{inspiration: \"Rust\", name: :dbg}\n[my_file.exs:3: (file)]\nMap.put(feature, :in_version, \"1.14.0\") #=> %{in_version: \"1.14.0\", inspiration: \"Rust\", name: :dbg}\n```\n\nWhen talking about `IO.inspect/2`, we mentioned its usefulness when placed between steps of `|>` pipelines. `dbg` does it better: it understands Elixir code, so it will print values at _every step of the pipeline_.\n\n```elixir\n# In dbg_pipes.exs\n__ENV__.file\n|> String.split(\"/\", trim: true)\n|> List.last()\n|> File.exists?()\n|> dbg()\n```\n\nThis code prints:\n\n```text\n[dbg_pipes.exs:5: (file)]\n__ENV__.file #=> \"/home/myuser/dbg_pipes.exs\"\n|> String.split(\"/\", trim: true) #=> [\"home\", \"myuser\", \"dbg_pipes.exs\"]\n|> List.last() #=> \"dbg_pipes.exs\"\n|> File.exists?() #=> true\n```\n\nWhile `dbg` provides conveniences around Elixir constructs, you will need `IEx` if you want to execute code and set breakpoints while debugging.\n\n## Pry\n\nWhen using `IEx`, you may pass `--dbg pry` as an option to \"stop\" the code execution where the `dbg` call is:\n\n```console\n$ iex --dbg pry\n```\n\nOr to debug inside of a project:\n\n```console\n$ iex --dbg pry -S mix\n```\n\nNow any call to `dbg` will ask if you want to pry the existing code. If you accept, you'll be able to access all variables, as well as imports and aliases from the code, directly from IEx. This is called \"prying\". While the pry session is running, the code execution stops, until `continue` (or `c`) or `next` (or `n`) are called. Remember you can always run `iex` in the context of a project with `iex -S mix TASK`.\n\n\n\n## Breakpoints\n\n`dbg` calls require us to change the code we intend to debug and has limited stepping functionality. Luckily IEx also provides a `IEx.break!/2` function which allows you to set and manage breakpoints on any Elixir code without modifying its source:\n\n\n\nSimilar to `dbg`, once a breakpoint is reached, code execution stops until `continue` (or `c`) or `next` (or `n`) are invoked. Breakpoints can navigate line-by-line by default, however, they do not have access to aliases and imports when breakpoints are set on compiled modules.\n\nThe `mix test` task direct integration with breakpoints via the `-b`/`--breakpoints` flag. When the flag is used, a breakpoint is set at the beginning of every test that will run:\n\n\n\nHere are some commands you can use in practice:\n\n```console\n# Debug all failed tests\n$ iex -S mix test --breakpoints --failed\n# Debug the test at the given file:line\n$ iex -S mix test -b path/to/file:line\n```\n\n## Observer\n\nFor debugging complex systems, jumping at the code is not enough. It is necessary to have an understanding of the whole virtual machine, processes, applications, as well as set up tracing mechanisms. Luckily this can be achieved in Erlang with `:observer`. In your application:\n\n```elixir\n$ iex\niex> :observer.start()\n```\n\n> #### Missing dependencies {: .warning}\n>\n> When running `iex` inside a project with `iex -S mix`, `observer` won't be available as a dependency. To do so, you will need to call the following functions before:\n>\n> ```elixir\n> iex> Mix.ensure_application!(:observer)\n> iex> :observer.start()\n> ```\n>\n> If any of the calls above fail, here is what may have happened: some package managers default to installing a minimized Erlang without WX bindings for GUI support. In some package managers, you may be able to replace the headless Erlang with a more complete package (look for packages named `erlang` vs `erlang-nox` on Debian/Ubuntu/Arch). In others managers, you may need to install a separate `erlang-wx` (or similarly named) package.\n\nThe above will open another Graphical User Interface that provides many panes to fully understand and navigate the runtime and your project.\n\nWe explore the Observer in the context of an actual project [in the Dynamic Supervisor chapter of the Mix & OTP guide](../mix-and-otp/dynamic-supervisor.md). This is one of the debugging techniques [the Phoenix framework used to achieve 2 million connections on a single machine](https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections).\n\nIf you are using the Phoenix web framework, it ships with the [Phoenix LiveDashboard](https://github.com/phoenixframework/phoenix_live_dashboard), a web dashboard for production nodes which provides similar features to Observer.\n\nFinally, remember you can also get a mini-overview of the runtime info by calling `runtime_info/0` directly in IEx.\n\n## Other tools and community\n\nWe have just scratched the surface of what the Erlang VM has to offer, for example:\n\n * Alongside the observer application, Erlang also includes a [`:crashdump_viewer`](`:crashdump_viewer`) to view crash dumps\n\n * Integration with OS level tracers, such as [Linux Trace Toolkit](https://www.erlang.org/doc/apps/runtime_tools/lttng), [DTRACE](https://www.erlang.org/doc/apps/runtime_tools/dtrace), and [SystemTap](https://www.erlang.org/doc/apps/runtime_tools/systemtap)\n\n * [Microstate accounting](`:msacc`) measures how much time the runtime spends in several low-level tasks in a short time interval\n\n * Mix ships with many tasks under the `profile` namespace, such as `mix profile.cprof` and `mix profile.fprof`\n\n * For more advanced use cases, we recommend the excellent [Erlang in Anger](https://www.erlang-in-anger.com/), which is available as a free ebook\n\nHappy debugging!\n" }, { "path": "lib/elixir/pages/getting-started/enumerable-and-streams.md", "content": "\n\n# Enumerables and Streams\n\nWhile Elixir allows us to write recursive code, most operations we perform on collections is done with the help of the `Enum` and `Stream` modules. Let's learn how.\n\n## Enumerables\n\nElixir provides the concept of enumerables and the `Enum` module to work with them. We have already learned two enumerables: lists and maps.\n\n```elixir\niex> Enum.map([1, 2, 3], fn x -> x * 2 end)\n[2, 4, 6]\niex> Enum.map(%{1 => 2, 3 => 4}, fn {k, v} -> k * v end)\n[2, 12]\n```\n\nThe `Enum` module provides a huge range of functions to transform, sort, group, filter and retrieve items from enumerables. It is one of the modules developers use frequently in their Elixir code. For a general overview of all functions in the `Enum` module, see [the `Enum` cheatsheet](enum-cheat.cheatmd).\n\nElixir also provides ranges (see `Range`), which are also enumerable:\n\n```elixir\niex> Enum.map(1..3, fn x -> x * 2 end)\n[2, 4, 6]\niex> Enum.reduce(1..3, 0, &+/2)\n6\n```\n\nThe functions in the `Enum` module are limited to, as the name says, enumerating values in data structures. For specific operations, like inserting and updating particular elements, you may need to reach for modules specific to the data type. For example, if you want to insert an element at a given position in a list, you should use the `List.insert_at/3` function, as it would make little sense to insert a value into, for example, a range.\n\nWe say the functions in the `Enum` module are polymorphic because they can work with diverse data types. In particular, the functions in the `Enum` module can work with any data type that implements the `Enumerable` protocol. We are going to discuss Protocols in a later chapter, for now we are going to move on to a specific kind of enumerable called a stream.\n\n## Eager vs Lazy\n\nAll the functions in the `Enum` module are eager. Many functions expect an enumerable and return a list back:\n\n```elixir\niex> odd? = fn x -> rem(x, 2) != 0 end\n#Function<6.80484245/1 in :erl_eval.expr/5>\niex> Enum.filter(1..3, odd?)\n[1, 3]\n```\n\nThis means that when performing multiple operations with `Enum`, each operation is going to generate an intermediate list until we reach the result:\n\n```elixir\niex> 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum()\n7500000000\n```\n\nThe example above has a pipeline of operations. We start with a range and then multiply each element in the range by 3. This first operation will now create and return a list with `100_000` items. Then we keep all odd elements from the list, generating a new list, now with `50_000` items, and then we sum all entries.\n\n## The pipe operator\n\nThe `|>` symbol used in the snippet above is the **pipe operator**: it takes the output from the expression on its left side and passes it as the first argument to the function call on its right side. Its purpose is to highlight the data being transformed by a series of functions. To see how it can make the code cleaner, have a look at the example above rewritten without using the `|>` operator:\n\n```elixir\niex> Enum.sum(Enum.filter(Enum.map(1..100_000, &(&1 * 3)), odd?))\n7500000000\n```\n\nFind more about the pipe operator [by reading its documentation](`|>/2`).\n\n## Streams\n\nAs an alternative to `Enum`, Elixir provides the `Stream` module which supports lazy operations:\n\n```elixir\niex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum()\n7500000000\n```\n\nStreams are lazy, composable enumerables.\n\nIn the example above, `1..100_000 |> Stream.map(&(&1 * 3))` returns a data type, an actual stream, that represents the `map` computation over the range `1..100_000`:\n\n```elixir\niex> 1..100_000 |> Stream.map(&(&1 * 3))\n#Stream<[enum: 1..100000, funs: [#Function<34.16982430/1 in Stream.map/2>]]>\n```\n\nFurthermore, they are composable because we can pipe many stream operations:\n\n```elixir\niex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?)\n#Stream<[enum: 1..100000, funs: [...]]>\n```\n\nInstead of generating intermediate lists, streams build a series of computations that are invoked only when we pass the underlying stream to the `Enum` module. Streams are useful when working with large, *possibly infinite*, collections.\n\nMany functions in the `Stream` module accept any enumerable as an argument and return a stream as a result. It also provides functions for creating streams. For example, `Stream.cycle/1` can be used to create a stream that cycles a given enumerable infinitely. Be careful to not call a function like `Enum.map/2` on such streams, as they would cycle forever:\n\n```elixir\niex> stream = Stream.cycle([1, 2, 3])\n#Function<15.16982430/2 in Stream.unfold/2>\niex> Enum.take(stream, 10)\n[1, 2, 3, 1, 2, 3, 1, 2, 3, 1]\n```\n\nAnother interesting function is `Stream.resource/3` which can be used to wrap around resources, guaranteeing they are opened right before enumeration and closed afterwards, even in the case of failures. For example, `File.stream!/1` builds on top of `Stream.resource/3` to stream files:\n\n```elixir\niex> \"path/to/file\" |> File.stream!() |> Enum.take(10)\n```\n\nThe example above will fetch the first 10 lines of the file you have selected. This means streams can be very useful for handling large files or even slow resources like network resources.\n\nThe `Enum` and `Stream` modules provide a wide range of functions, but you don't have to know all of them by heart. Familiarize yourself with `Enum.map/2`, `Enum.reduce/3` and other functions with either `map` or `reduce` in their names, and you will naturally build an intuition around the most important use cases. You may also focus on the `Enum` module first and only move to `Stream` for the particular scenarios where laziness is required, to either deal with slow resources or large, possibly infinite, collections.\n\nNext, we'll look at a feature central to Elixir, Processes, which allows us to write concurrent, parallel and distributed programs in an easy and understandable way.\n" }, { "path": "lib/elixir/pages/getting-started/erlang-libraries.md", "content": "\n\n# Erlang libraries\n\nElixir provides excellent interoperability with Erlang libraries. In fact, Elixir discourages simply wrapping Erlang libraries in favor of directly interfacing with Erlang code. In this section, we will present some of the most common and useful Erlang functionality that is not found in Elixir.\n\nErlang modules have a different naming convention than in Elixir and start in lowercase. In both cases, module names are atoms and we invoke functions by dispatching to the module name:\n\n```elixir\niex> is_atom(String)\ntrue\niex> String.first(\"hello\")\n\"h\"\niex> is_atom(:binary)\ntrue\niex> :binary.first(\"hello\")\n104\n```\n\nAs you grow more proficient in Elixir, you may want to explore the Erlang [STDLIB Reference Manual](https://www.erlang.org/doc/apps/stdlib/index.html) in more detail.\n\n## The binary module\n\nThe built-in Elixir String module handles binaries that are UTF-8 encoded. [The `:binary` module](`:binary`) is useful when you are dealing with binary data that is not necessarily UTF-8 encoded.\n\n```elixir\niex> String.to_charlist(\"Ø\")\n[216]\niex> :binary.bin_to_list(\"Ø\")\n[195, 152]\n```\n\nThe above example shows the difference; the `String` module returns Unicode codepoints, while `:binary` deals with raw data bytes.\n\n## Formatted text output\n\nElixir does not contain a function similar to `printf` found in C and other languages. Luckily, the Erlang standard library functions `:io.format/2` and `:io_lib.format/2` may be used. The first formats to terminal output, while the second formats to an iolist. The format specifiers differ from `printf`, [refer to the Erlang documentation for details](`:io.format/2`).\n\n```elixir\niex> :io.format(\"Pi is approximately given by:~10.3f~n\", [:math.pi])\nPi is approximately given by: 3.142\n:ok\niex> to_string(:io_lib.format(\"Pi is approximately given by:~10.3f~n\", [:math.pi]))\n\"Pi is approximately given by: 3.142\\n\"\n```\n\n## The crypto module\n\n[The `:crypto` module](`:crypto`) contains hashing functions, digital signatures, encryption and more:\n\n```elixir\niex> Base.encode16(:crypto.hash(:sha256, \"Elixir\"))\n\"3315715A7A3AD57428298676C5AE465DADA38D951BDFAC9348A8A31E9C7401CB\"\n```\n\nThe `:crypto` module is part of the `:crypto` application that ships with Erlang. This means you must list the `:crypto` application as an additional application in your project configuration. To do this, edit your `mix.exs` file to include:\n\n```elixir\ndef application do\n [extra_applications: [:crypto]]\nend\n```\n\nAny module that is not part of the `:kernel` or `:stdlib` Erlang applications must have their application explicitly listed in your `mix.exs`. You can find the application name of any Erlang module in the Erlang documentation, immediately below the Erlang logo in the sidebar.\n\n## The digraph module\n\nThe [`:digraph`](`:digraph`) and [`:digraph_utils`](`:digraph_utils`) modules contain functions for dealing with directed graphs built of vertices and edges. After constructing the graph, the algorithms in there will help find, for instance, the shortest path between two vertices, or loops in the graph.\n\nGiven three vertices, find the shortest path from the first to the last.\n\n```elixir\niex> digraph = :digraph.new()\niex> coords = [{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}]\niex> [v0, v1, v2] = (for c <- coords, do: :digraph.add_vertex(digraph, c))\niex> :digraph.add_edge(digraph, v0, v1)\niex> :digraph.add_edge(digraph, v1, v2)\niex> :digraph.get_short_path(digraph, v0, v2)\n[{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}]\n```\n\nNote that the functions in `:digraph` alter the graph structure in-place, this\nis possible because they are implemented as ETS tables, explained next.\n\n## Erlang Term Storage (ETS)\n\nThe modules [`:ets`](`:ets`) and [`:dets`](`:dets`) handle storage of large data structures in memory or on disk respectively.\n\nETS lets you create a table containing tuples. By default, ETS tables are protected, which means only the owner process may write to the table but any other process can read. ETS has some functionality to allow a table to be used as a simple database, a key-value store or as a cache mechanism.\n\nThe functions in the `ets` module will modify the state of the table as a side-effect.\n\n```elixir\niex> table = :ets.new(:ets_test, [])\n# Store as tuples with {name, population}\niex> :ets.insert(table, {\"China\", 1_374_000_000})\niex> :ets.insert(table, {\"India\", 1_284_000_000})\niex> :ets.insert(table, {\"USA\", 322_000_000})\niex> :ets.i(table)\n<1 > {<<\"India\">>,1284000000}\n<2 > {<<\"USA\">>,322000000}\n<3 > {<<\"China\">>,1374000000}\n```\n\n## The math module\n\nThe [`:math`](`:math`) module contains common mathematical operations covering trigonometry, exponential, and logarithmic functions.\n\n```elixir\niex> angle_45_deg = :math.pi() * 45.0 / 180.0\niex> :math.sin(angle_45_deg)\n0.7071067811865475\niex> :math.exp(55.0)\n7.694785265142018e23\niex> :math.log(7.694785265142018e23)\n55.0\n```\n\n## The queue module\n\nThe [`:queue`](`:queue`) module provides a data structure that implements (double-ended) FIFO (first-in first-out) queues efficiently:\n\n```elixir\niex> q = :queue.new\niex> q = :queue.in(\"A\", q)\niex> q = :queue.in(\"B\", q)\niex> {value, q} = :queue.out(q)\niex> value\n{:value, \"A\"}\niex> {value, q} = :queue.out(q)\niex> value\n{:value, \"B\"}\niex> {value, q} = :queue.out(q)\niex> value\n:empty\n```\n\n## The rand module\n\nThe [`:rand`](`:rand`) has functions for returning random values and setting the random seed.\n\n```elixir\niex> :rand.uniform()\n0.8175669086010815\niex> _ = :rand.seed(:exs1024, {123, 123_534, 345_345})\niex> :rand.uniform()\n0.5820506340260994\niex> :rand.uniform(6)\n6\n```\n\n## The zip and zlib modules\n\nThe [`:zip`](`:zip`) module lets you read and write ZIP files to and from disk or memory, as well as extracting file information.\n\nThis code counts the number of files in a ZIP file:\n\n```elixir\niex> :zip.foldl(fn _, _, _, acc -> acc + 1 end, 0, :binary.bin_to_list(\"file.zip\"))\n{:ok, 633}\n```\n\nThe [`:zlib`](`:zlib`) module deals with data compression in zlib format, as found in the `gzip` command line utility found in Unix systems.\n\n```elixir\niex> song = \"\n...> Mary had a little lamb,\n...> His fleece was white as snow,\n...> And everywhere that Mary went,\n...> The lamb was sure to go.\"\niex> compressed = :zlib.compress(song)\niex> byte_size(song)\n110\niex> byte_size(compressed)\n99\niex> :zlib.uncompress(compressed)\n\"\\nMary had a little lamb,\\nHis fleece was white as snow,\\nAnd everywhere that Mary went,\\nThe lamb was sure to go.\"\n```\n\n## Learning Erlang\n\nIf you want to get deeper into Erlang, here's a list of online resources that cover Erlang's fundamentals and its more advanced features:\n\n * This [Erlang Syntax: A Crash Course](https://elixir-lang.org/crash-course.html) provides a concise intro to Erlang's syntax. Each code snippet is accompanied by equivalent code in Elixir. This is an opportunity for you to not only get some exposure to Erlang's syntax but also review what you learned about Elixir.\n\n * Erlang's official website has a short [tutorial](https://www.erlang.org/course). There is a chapter with pictures briefly describing Erlang's primitives for [concurrent programming](https://www.erlang.org/course/concurrent_programming.html).\n\n * [Learn You Some Erlang for Great Good!](https://learnyousomeerlang.com/) is an excellent introduction to Erlang, its design principles, standard library, best practices, and much more. Once you have read through the crash course mentioned above, you'll be able to safely skip the first couple of chapters in the book that mostly deal with the syntax. When you reach [The Hitchhiker's Guide to Concurrency](https://learnyousomeerlang.com/the-hitchhikers-guide-to-concurrency) chapter, that's where the real fun starts.\n\nOur last step is to take a look at existing Elixir (and Erlang) libraries you might use while debugging.\n" }, { "path": "lib/elixir/pages/getting-started/introduction.md", "content": "\n\n# Introduction\n\nWelcome!\n\nThis guide will teach you about Elixir fundamentals - the language syntax, how to define modules, the common data structures in the language, and more. This chapter will focus on ensuring that Elixir is installed and that you can successfully run Elixir's Interactive Shell, called IEx.\n\nLet's get started.\n\n## Installation\n\nIf you haven't yet installed Elixir, visit our [installation page](https://elixir-lang.org/install.html). Once you are done, you can run `elixir --version` to get the current Elixir version. The requirements for this guide are:\n\n * Elixir 1.18.0 onwards\n * Erlang/OTP 27 onwards\n\nIf you are looking for other resources for learning Elixir, you can also consult the [learning page](https://elixir-lang.org/learning.html) of the official website.\n\n## Interactive mode\n\nWhen you install Elixir, you will have three new command line executables: `iex`, `elixir` and `elixirc`.\n\nFor now, let's start by running `iex` (or `iex.bat` if you are on Windows PowerShell, where `iex` is a PowerShell command) which stands for Interactive Elixir. In interactive mode, we can type any Elixir expression and get its result. Let's warm up with some basic expressions.\n\nOpen up `iex` and type the following expressions:\n\n```elixir\nErlang/OTP 26 [64-bit] [smp:2:2] [...]\n\nInteractive Elixir - press Ctrl+C to exit\niex(1)> 40 + 2\n42\niex(2)> \"hello\" <> \" world\"\n\"hello world\"\n```\n\nPlease note that some details like version numbers may differ a bit in your session, that's not important. By executing the code above, you should evaluate expressions and see their results. To exit `iex` press `Ctrl+C` twice.\n\nIt seems we are ready to go! We will use the interactive shell quite a lot in the next chapters to get a bit more familiar with the language constructs and basic types, starting in the next chapter.\n\n## Running scripts\n\nAfter getting familiar with the basics of the language you may want to try writing simple programs. This can be accomplished by putting the following Elixir code into a file:\n\n```elixir\nIO.puts(\"Hello world from Elixir\")\n```\n\nSave it as `simple.exs` and execute it with `elixir`:\n\n```console\n$ elixir simple.exs\nHello world from Elixir\n```\n\n`iex` and `elixir` are all we need to learn the main language concepts. There is a separate guide named [\"Mix and OTP guide\"](../mix-and-otp/introduction-to-mix.md) that explores how to actually create, manage, and test full-blown Elixir projects. For now, let's move on to learn the basic data types in the language.\n" }, { "path": "lib/elixir/pages/getting-started/io-and-the-file-system.md", "content": "\n\n# IO and the file system\n\nThis chapter introduces the input/output mechanisms, file-system-related tasks, and related modules such as `IO`, `File`, and `Path`. The IO system provides a great opportunity to shed some light on some philosophies and curiosities of Elixir and the Erlang VM.\n\n## The `IO` module\n\nThe `IO` module is the main mechanism in Elixir for reading and writing to standard input/output (`:stdio`), standard error (`:stderr`), files, and other IO devices. Usage of the module is pretty straightforward:\n\n```elixir\niex> IO.puts(\"hello world\")\nhello world\n:ok\niex> IO.gets(\"yes or no? \")\nyes or no? yes\n\"yes\\n\"\n```\n\nBy default, functions in the `IO` module read from the standard input and write to the standard output. We can change that by passing, for example, `:stderr` as an argument (in order to write to the standard error device):\n\n```elixir\niex> IO.puts(:stderr, \"hello world\")\nhello world\n:ok\n```\n\n## The `File` module\n\nThe `File` module contains functions that allow us to open files as IO devices. By default, files are opened in binary mode, which requires developers to use the specific `IO.binread/2` and `IO.binwrite/2` functions from the `IO` module:\n\n> #### Potential data loss warning {: .warning}\n>\n> The following code opens a file for writing. If an existing file is available at the given path, its contents will be deleted.\n\n```elixir\niex> {:ok, file} = File.open(\"path/to/file/hello\", [:write])\n{:ok, #PID<0.47.0>}\niex> IO.binwrite(file, \"world\")\n:ok\niex> File.close(file)\n:ok\niex> File.read(\"path/to/file/hello\")\n{:ok, \"world\"}\n```\n\nThe file could be opened with the `:append` option, instead of `:write`, to preserve its contents. You may also pass the `:utf8` option, which tells the `File` module to interpret the bytes read from the file as UTF-8-encoded bytes.\n\nBesides functions for opening, reading and writing files, the `File` module has many functions to work with the file system. Those functions are named after their UNIX equivalents. For example, `File.rm/1` can be used to remove files, `File.mkdir/1` to create directories, `File.mkdir_p/1` to create directories and all their parent chain. There are even `File.cp_r/2` and `File.rm_rf/1` to respectively copy and remove files and directories recursively (i.e., copying and removing the contents of the directories too).\n\nYou will also notice that functions in the `File` module have two variants: one \"regular\" variant and another variant with a trailing bang (`!`). For example, when we read the `\"hello\"` file in the example above, we use `File.read/1`. Alternatively, we can use `File.read!/1`:\n\n```elixir\niex> File.read(\"path/to/file/hello\")\n{:ok, \"world\"}\niex> File.read!(\"path/to/file/hello\")\n\"world\"\niex> File.read(\"path/to/file/unknown\")\n{:error, :enoent}\niex> File.read!(\"path/to/file/unknown\")\n** (File.Error) could not read file \"path/to/file/unknown\": no such file or directory\n```\n\nNotice that the version with `!` returns the contents of the file instead of a tuple, and if anything goes wrong the function raises an error.\n\nThe version without `!` is preferred when you want to handle different outcomes using pattern matching:\n\n```elixir\ncase File.read(\"path/to/file/hello\") do\n {:ok, body} -> # do something with the `body`\n {:error, reason} -> # handle the error caused by `reason`\nend\n```\n\nHowever, if you expect the file to be there, the bang variation is more useful as it raises a meaningful error message. Avoid writing:\n\n```elixir\n{:ok, body} = File.read(\"path/to/file/unknown\")\n```\n\nas, in case of an error, `File.read/1` will return `{:error, reason}` and the pattern matching will fail. You will still get the desired result (a raised error), but the message will be about the pattern which doesn't match (thus being cryptic in respect to what the error actually is about).\n\nTherefore, if you don't want to handle the error outcomes, prefer to use the functions ending with an exclamation mark, such as `File.read!/1`.\n\n## The `Path` module\n\nThe majority of the functions in the `File` module expect paths as arguments. Most commonly, those paths will be regular binaries. The `Path` module provides facilities for working with such paths:\n\n```elixir\niex> Path.join(\"foo\", \"bar\")\n\"foo/bar\"\niex> Path.expand(\"~/hello\")\n\"/Users/jose/hello\"\n```\n\nUsing functions from the `Path` module as opposed to directly manipulating strings is preferred since the `Path` module takes care of different operating systems transparently. Finally, keep in mind that Elixir will automatically convert slashes (`/`) into backslashes (`\\`) on Windows when performing file operations.\n\nWith this, we have covered the main modules that Elixir provides for dealing with IO and interacting with the file system. In the next section, we will peek a bit under the covers and learn how the IO system is implemented in the VM.\n\n## Processes\n\nYou may have noticed that `File.open/2` returns a tuple like `{:ok, pid}`:\n\n```elixir\niex> {:ok, file} = File.open(\"hello\")\n{:ok, #PID<0.47.0>}\n```\n\nThis happens because the `IO` module actually works with processes (see [the previous chapter](processes.md)). Given a file is a process, when you write to a file that has been closed, you are actually sending a message to a process which has been terminated:\n\n```elixir\niex> File.close(file)\n:ok\niex> IO.write(file, \"is anybody out there\")\n** (ErlangError) Erlang error: :terminated:\n\n * 1st argument: the device has terminated\n\n (stdlib 5.0) io.erl:94: :io.put_chars(#PID<0.114.0>, \"is anybody out there\")\n iex:4: (file)\n```\n\nLet's see in more detail what happens when you request `IO.write(pid, binary)`. The `IO` module sends a message to the process identified by `pid` with the desired operation. A small ad-hoc process can help us see it:\n\n```elixir\niex> pid = spawn(fn ->\n...> receive do\n...> msg -> IO.inspect(msg)\n...> end\n...> end)\n#PID<0.57.0>\niex> IO.write(pid, \"hello\")\n{:io_request, #PID<0.41.0>, #Reference<0.0.8.91>,\n {:put_chars, :unicode, \"hello\"}}\n** (ErlangError) erlang error: :terminated\n```\n\nAfter `IO.write/2`, we can see the request sent by the `IO` module printed out (a four-elements tuple). Soon after that, we see that it fails since the `IO` module expected some kind of result, which we did not supply.\n\nBy modeling IO devices with processes, the Erlang VM allows us to even read and write to files across nodes. Neat!\n\n## `iodata` and `chardata`\n\nIn all of the examples above, we used binaries when writing to files. However, most of the IO functions in Elixir also accept either \"iodata\" or \"chardata\".\n\nOne of the main reasons for using \"iodata\" and \"chardata\" is for performance. For example,\nimagine you need to greet someone in your application:\n\n```elixir\nname = \"Mary\"\nIO.puts(\"Hello \" <> name <> \"!\")\n```\n\nGiven strings in Elixir are immutable, as most data structures, the example above will copy the string \"Mary\" into the new \"Hello Mary!\" string. While this is unlikely to matter for the short string as above, copying can be quite expensive for large strings! For this reason, the IO functions in Elixir allow you to pass instead a list of strings:\n\n```elixir\nname = \"Mary\"\nIO.puts([\"Hello \", name, \"!\"])\n```\n\nIn the example above, there is no copying. Instead we create a list that contains the original name. We call such lists either \"iodata\" or \"chardata\" and we will learn the precise difference between them soon.\n\nThose lists are very useful because it can actually simplify the processing strings in several scenarios. For example, imagine you have a list of values, such as `[\"apple\", \"banana\", \"lemon\"]` that you want to write to disk separated by commas. How can you achieve this?\n\nOne option is to use `Enum.join/2` and convert the values to a string:\n\n```elixir\niex> Enum.join([\"apple\", \"banana\", \"lemon\"], \",\")\n\"apple,banana,lemon\"\n```\n\nThe above returns a new string by copying each value into the new string. However, with the knowledge in this section, we know that we can pass a list of strings to the IO/File functions. So instead we can do:\n\n```elixir\niex> Enum.intersperse([\"apple\", \"banana\", \"lemon\"], \",\")\n[\"apple\", \",\", \"banana\", \",\", \"lemon\"]\n```\n\n\"iodata\" and \"chardata\" do not only contain strings, but they may contain arbitrary nested lists of strings too:\n\n```elixir\niex> IO.puts([\"apple\", [\",\", \"banana\", [\",\", \"lemon\"]]])\n```\n\n\"iodata\" and \"chardata\" may also contain integers. For example, we could print our comma separated list of values by using `?,` as separator, which is the integer representing a comma (`44`):\n\n```elixir\niex> IO.puts([\"apple\", ?,, \"banana\", ?,, \"lemon\"])\n```\n\nThe difference between \"iodata\" and \"chardata\" is precisely what said integer represents. For iodata, the integers represent bytes. For chardata, the integers represent Unicode codepoints. For ASCII characters, the byte representation is the same as the codepoint representation, so it fits both classifications. However, the default IO device works with chardata, which means we can do:\n\n```elixir\niex> IO.puts([?O, ?l, ?á, ?\\s, \"Mary\", ?!])\n```\n\nCharlists, such as `~c\"hello world\"`, are lists of integers, and therefore are chardata.\n\nWe packed a lot into this small section, so let's break it down:\n\n * iodata and chardata are lists of binaries and integers. Those binaries and integers can be arbitrarily nested inside lists. Their goal is to give flexibility and performance when working with IO devices and files;\n\n * the choice between iodata and chardata depends on the encoding of the IO device. If the file is opened without encoding, the file expects iodata, and the functions in the `IO` module starting with `bin*` must be used. The default IO device (`:stdio`) and files opened with `:utf8` encoding expect chardata and work with the remaining functions in the `IO` module;\n\nThis finishes our tour of IO devices and IO related functionality. We have learned about three Elixir modules - `IO`, `File`, and `Path` - as well as how the VM uses processes for the underlying IO mechanisms and how to use `chardata` and `iodata` for IO operations.\n" }, { "path": "lib/elixir/pages/getting-started/keywords-and-maps.md", "content": "\n\n# Keyword lists and maps\n\nNow let's talk about associative data structures. Associative data structures are able to associate a key to a certain value. Different languages call these different names like dictionaries, hashes, associative arrays, etc.\n\nIn Elixir, we have two main associative data structures: keyword lists and maps.\n\n## Keyword lists\n\nKeyword lists are a data-structure used to pass options to functions. Let's see a scenario where they may be useful.\n\nImagine you want to split a string of numbers. Initially, we can invoke `String.split/2` passing two strings as arguments:\n\n```elixir\niex> String.split(\"1 2 3 4\", \" \")\n[\"1\", \"2\", \"3\", \"4\"]\n```\n\nWhat if you only want to split at most 2 times? The `String.split/3` function allows the `parts` option to be set to the maximum number of entries in the result:\n\n```elixir\niex> String.split(\"1 2 3 4\", \" \", [parts: 3])\n[\"1\", \"2\", \"3 4\"]\n```\n\nAs you can see, we got 3 parts, the last one containing the remaining of the input without splitting it.\n\nNow imagine that some of the inputs you must split on contains additional spaces between the numbers:\n\n```elixir\niex> String.split(\"1 2 3 4\", \" \", [parts: 3])\n[\"1\", \"\", \"2 3 4\"]\n```\n\nAs you can see, the additional spaces lead to empty entries in the output. Luckily, we can also set the `trim` option to `true` to remove them:\n\n```elixir\niex> String.split(\"1 2 3 4\", \" \", [parts: 3, trim: true])\n[\"1\", \"2\", \" 3 4\"]\n```\n\nOnce again we got 3 parts, with the last one containing the leftovers.\n\n`[parts: 3]` and `[parts: 3, trim: true]` are keyword lists. When a keyword list is the last argument of a function, we can skip the brackets and write:\n\n```elixir\niex> String.split(\"1 2 3 4\", \" \", parts: 3, trim: true)\n[\"1\", \"2\", \" 3 4\"]\n```\n\nAs shown in the example above, keyword lists are mostly used as optional arguments to functions.\n\nAs the name implies, keyword lists are simply lists. In particular, they are lists consisting of 2-item tuples where the first element (the key) is an atom and the second element can be any value. Both representations are the same:\n\n```elixir\niex> [{:parts, 3}, {:trim, true}] == [parts: 3, trim: true]\ntrue\n```\n\nKeyword lists are important because they have three special characteristics:\n\n * Keys must be atoms.\n * Keys are ordered, as specified by the developer.\n * Keys can be given more than once.\n\nFor example, we use the fact that keys can be repeated when [importing functions](../getting-started/alias-require-and-import.md) in Elixir:\n\n```elixir\niex> import String, only: [split: 1, split: 2]\nString\niex> split(\"hello world\")\n[\"hello\", \"world\"]\n```\n\nIn the example above, we imported both `split/1` and `split/2` from the `String` module, allowing us to invoke them without typing the module name. We used a keyword list to list the functions to import.\n\nSince keyword lists are lists, we can use all operations available to lists. For example, we can use `++` to add new values to a keyword list:\n\n```elixir\niex> list = [a: 1, b: 2]\n[a: 1, b: 2]\niex> list ++ [c: 3]\n[a: 1, b: 2, c: 3]\niex> [a: 0] ++ list\n[a: 0, a: 1, b: 2]\n```\n\nYou can read the value of a keyword list using the brackets syntax, which will return the value of the first matching key. This is also known as the access syntax, as it is defined by the `Access` module:\n\n```elixir\niex> list[:a]\n1\niex> list[:b]\n2\n```\n\nAlthough we can pattern match on keyword lists, it is not done in practice since pattern matching on lists requires the number of items and their order to match:\n\n```elixir\niex> [a: a] = [a: 1]\n[a: 1]\niex> a\n1\niex> [a: a] = [a: 1, b: 2]\n** (MatchError) no match of right hand side value: [a: 1, b: 2]\niex> [b: b, a: a] = [a: 1, b: 2]\n** (MatchError) no match of right hand side value: [a: 1, b: 2]\n```\n\nFurthermore, given keyword lists are often used as optional arguments, they are used in situations where not all keys may be present, which would make it impossible to match on them. In a nutshell, do not pattern match on keyword lists.\n\nIn order to manipulate keyword lists, Elixir provides the `Keyword` module. Remember, though, keyword lists are simply lists, and as such they provide the same linear performance characteristics: the longer the list, the longer it will take to find a key, to count the number of items, and so on. If you need to store a large amount of keys in a key-value data structure, Elixir offers maps, which we will soon learn.\n\n### `do`-blocks and keywords\n\nAs we have seen, keywords are mostly used in the language to pass optional values. In fact, we have used keywords in earlier chapters. Let's look at the `if/2` macro:\n\n```elixir\niex> if true do\n...> \"This will be seen\"\n...> else\n...> \"This won't\"\n...> end\n\"This will be seen\"\n```\n\nIn the example above, the `do` and `else` blocks make up a keyword list. They are nothing more than a syntax convenience on top of keyword lists. We can rewrite the above to:\n\n```elixir\niex> if(true, do: \"This will be seen\", else: \"This won't\")\n\"This will be seen\"\n```\n\nPay close attention to both syntaxes. The second example uses keyword lists, exactly as in the `String.split/3` example, so we separate each key-value pair with commas and each key is followed by `:`. In the `do`-blocks, we use bare words, such as `do`, `else`, and `end`, and separate them by a newline. They are useful precisely when writing blocks of code. Most of the time, you will use the block syntax, but it is good to know they are equivalent.\n\nThe fact the block syntax is equivalent to keywords means we only need few data structures to represent the language, keeping it simple overall. We will come back to this topic when discussing [optional syntax](optional-syntax.md) and [meta-programming](../meta-programming/quote-and-unquote.md).\n\nWith this out of the way, let's talk about maps.\n\n## Maps as key-value pairs\n\nWhenever you need to store key-value pairs, maps are the \"go to\" data structure in Elixir. A map is created using the `%{}` syntax:\n\n```elixir\niex> map = %{:a => 1, 2 => :b}\n%{2 => :b, :a => 1}\niex> map[:a]\n1\niex> map[2]\n:b\niex> map[:c]\nnil\n```\n\nCompared to keyword lists, we can already see two differences:\n\n * Maps allow any value as a key.\n * Maps have their own internal ordering, which is not guaranteed to be the same across different maps, even if they have the same keys\n\nIn contrast to keyword lists, maps are very useful with pattern matching. When a map is used in a pattern, it will always match on a subset of the given value:\n\n```elixir\niex> %{} = %{:a => 1, 2 => :b}\n%{2 => :b, :a => 1}\niex> %{:a => a} = %{:a => 1, 2 => :b}\n%{2 => :b, :a => 1}\niex> a\n1\niex> %{:c => c} = %{:a => 1, 2 => :b}\n** (MatchError) no match of right hand side value: %{2 => :b, :a => 1}\n```\n\nAs shown above, a map matches as long as the keys in the pattern exist in the given map. Therefore, an empty map matches all maps.\n\nThe `Map` module provides a very similar API to the `Keyword` module with convenience functions to add, remove, and update maps keys:\n\n```elixir\niex> Map.get(%{:a => 1, 2 => :b}, :a)\n1\niex> Map.put(%{:a => 1, 2 => :b}, :c, 3)\n%{2 => :b, :a => 1, :c => 3}\niex> Map.to_list(%{:a => 1, 2 => :b})\n[{2, :b}, {:a, 1}]\n```\n\n## Maps of predefined keys\n\nIn the previous section, we have used maps as a key-value data structure where keys can be added or removed at any time. However, it is also common to create maps with a predefined set of keys. Their values may be updated, but new keys are never added nor removed. This is useful when we know the shape of the data we are working with and, if we get a different key, it likely means a mistake was done elsewhere. In such cases, the keys are most often atoms:\n\n```elixir\niex> map = %{:name => \"John\", :age => 23}\n%{name: \"John\", age: 23}\n```\n\nAs you can see from the printed result above, Elixir also allows you to write maps of atom keys using the same `key: value` syntax as keyword lists:\n\n```elixir\niex> map = %{name: \"John\", age: 23}\n%{name: \"John\", age: 23}\n```\n\nWhen a key is an atom, we can also access them using the `map.key` syntax:\n\n```elixir\niex> map.name\n\"John\"\niex> map.agee\n** (KeyError) key :agee not found in: %{name: \"John\", age: 23}\n```\n\nThere is also syntax for updating keys, which also raises if the key has not yet been defined:\n\n```elixir\niex> %{map | name: \"Mary\"}\n%{name: \"Mary\", age: 23}\niex> %{map | agee: 27}\n** (KeyError) key :agee not found in: %{name: \"John\", age: 23}\n```\n\nThese operations have one large benefit in that they raise if the key does not exist in the map and the compiler may even detect and warn when possible. This makes them useful to get quick feedback and spot bugs and typos early on. This is also the syntax used to power another Elixir feature called \"Structs\", which we will learn later on.\n\nElixir developers typically prefer to use the `map.key` syntax and pattern matching instead of the functions in the `Map` module when working with maps because they lead to an assertive style of programming. [This blog post by José Valim](https://dashbit.co/blog/writing-assertive-code-with-elixir) provides insight and examples on how you get more concise and faster software by writing assertive code in Elixir.\n\nIn a further chapter you'll learn about [\"Structs\"](structs.md), which further enforce the idea of a map with predefined keys.\n\n## Nested data structures\n\nOften we will have maps inside maps, or even keywords lists inside maps, and so forth. Elixir provides conveniences for manipulating nested data structures via the `get_in/1`, `put_in/2`, `update_in/2`, and other macros giving the same conveniences you would find in imperative languages while keeping the immutable properties of the language.\n\nImagine you have the following structure:\n\n```elixir\niex> users = [\n john: %{name: \"John\", age: 27, languages: [\"Erlang\", \"Ruby\", \"Elixir\"]},\n mary: %{name: \"Mary\", age: 29, languages: [\"Elixir\", \"F#\", \"Clojure\"]}\n]\n[\n john: %{age: 27, languages: [\"Erlang\", \"Ruby\", \"Elixir\"], name: \"John\"},\n mary: %{age: 29, languages: [\"Elixir\", \"F#\", \"Clojure\"], name: \"Mary\"}\n]\n```\n\nWe have a keyword list of users where each value is a map containing the name, age and a list of programming languages each user likes. If we wanted to access the age for john, we could write:\n\n```elixir\niex> users[:john].age\n27\n```\n\nIt happens we can also use this same syntax for updating the value:\n\n```elixir\niex> users = put_in(users[:john].age, 31)\n[\n john: %{age: 31, languages: [\"Erlang\", \"Ruby\", \"Elixir\"], name: \"John\"},\n mary: %{age: 29, languages: [\"Elixir\", \"F#\", \"Clojure\"], name: \"Mary\"}\n]\n```\n\nThe `update_in/2` macro is similar but allows us to pass a function that controls how the value changes. For example, let's remove \"Clojure\" from Mary's list of languages:\n\n```elixir\niex> users = update_in(users[:mary].languages, fn languages -> List.delete(languages, \"Clojure\") end)\n[\n john: %{age: 31, languages: [\"Erlang\", \"Ruby\", \"Elixir\"], name: \"John\"},\n mary: %{age: 29, languages: [\"Elixir\", \"F#\"], name: \"Mary\"}\n]\n```\n\n## Summary\n\nThere are two different data structures for working with key-value stores in Elixir. Alongside the `Access` module and pattern matching, they provide a rich set of tools for manipulating complex, potentially nested, data structures.\n\nAs we conclude this chapter, remember that you should:\n\n * Use keyword lists for passing optional values to functions\n\n * Use maps for general key-value data structures\n\n * Use maps when working with data that has a predefined set of keys\n\nNow let's talk about modules and functions.\n" }, { "path": "lib/elixir/pages/getting-started/lists-and-tuples.md", "content": "\n\n# Lists and tuples\n\nIn this chapter we will learn two of the most used collection data-types in Elixir: lists and tuples.\n\n## (Linked) Lists\n\nElixir uses square brackets to specify a list of values. Values can be of any type:\n\n```elixir\niex> [1, 2, true, 3]\n[1, 2, true, 3]\niex> length([1, 2, 3])\n3\n```\n\nTwo lists can be concatenated or subtracted using the [`++`](`++/2`) and [`--`](`--/2`) operators respectively:\n\n```elixir\niex> [1, 2, 3] ++ [4, 5, 6]\n[1, 2, 3, 4, 5, 6]\niex> [1, true, 2, false, 3, true] -- [true, false]\n[1, 2, 3, true]\n```\n\nList operators never modify the existing list. Concatenating to or removing elements from a list returns a new list. We say that Elixir data structures are *immutable*. One advantage of immutability is that it leads to clearer code. You can freely pass the data around with the guarantee no one will mutate it in memory - only transform it.\n\nThroughout the tutorial, we will talk a lot about the head and tail of a list. The head is the first element of a list and the tail is the remainder of the list. They can be retrieved with the functions [`hd`](`hd/1`) and [`tl`](`tl/1`). Let's assign a list to a variable and retrieve its head and tail:\n\n```elixir\niex> list = [1, 2, 3]\niex> hd(list)\n1\niex> tl(list)\n[2, 3]\n```\n\nGetting the head or the tail of an empty list throws an error:\n\n```elixir\niex> hd([])\n** (ArgumentError) argument error\n```\n\nSometimes you will create a list and it will return a quoted value preceded by `~c`. For example:\n\n```elixir\niex> [11, 12, 13]\n~c\"\\v\\f\\r\"\niex> [104, 101, 108, 108, 111]\n~c\"hello\"\n```\n\nWhen Elixir sees a list of printable ASCII numbers, Elixir will print that as a charlist (literally a list of characters). Charlists are quite common when interfacing with existing Erlang code. Whenever you see a value in IEx and you are not quite sure what it is, you can use [`i`](`IEx.Helpers.i/1`) to retrieve information about it:\n\n```elixir\niex> i ~c\"hello\"\nTerm\n i ~c\"hello\"\nData type\n List\nDescription\n ...\nRaw representation\n [104, 101, 108, 108, 111]\nReference modules\n List\nImplemented protocols\n ...\n```\n\nWe will talk more about charlists in the [\"Binaries, strings, and charlists\"](binaries-strings-and-charlists.md) chapter.\n\n> #### Single-quoted strings {: .info}\n>\n> In Elixir, you can also use `'hello'` to build charlists, but this notation has been soft-deprecated in Elixir v1.15 and will emit warnings in future versions. Prefer to write `~c\"hello\"` instead.\n\n## Tuples\n\nElixir uses curly brackets to define tuples. Like lists, tuples can hold any value:\n\n```elixir\niex> {:ok, \"hello\"}\n{:ok, \"hello\"}\niex> tuple_size({:ok, \"hello\"})\n2\n```\n\nTuples store elements contiguously in memory. This means accessing a tuple element by index or getting the tuple size is a fast operation. Indexes start from zero:\n\n```elixir\niex> tuple = {:ok, \"hello\"}\n{:ok, \"hello\"}\niex> elem(tuple, 1)\n\"hello\"\niex> tuple_size(tuple)\n2\n```\n\nIt is also possible to put an element at a particular index in a tuple with [`put_elem`](`put_elem/3`):\n\n```elixir\niex> tuple = {:ok, \"hello\"}\n{:ok, \"hello\"}\niex> put_elem(tuple, 1, \"world\")\n{:ok, \"world\"}\niex> tuple\n{:ok, \"hello\"}\n```\n\nNotice that [`put_elem`](`put_elem/3`) returned a new tuple. The original tuple stored in the `tuple` variable was not modified. Like lists, tuples are also immutable. Every operation on a tuple returns a new tuple, it never changes the given one.\n\n## Lists or tuples?\n\nWhat is the difference between lists and tuples?\n\nLists are stored in memory as linked lists, meaning that each element in a list holds its value and points to the following element until the end of the list is reached. This means accessing the length of a list is a linear operation: we need to traverse the whole list in order to figure out its size.\n\nSimilarly, the performance of list concatenation depends on the length of the left-hand list:\n\n```elixir\niex> list = [1, 2, 3]\n[1, 2, 3]\n\n# This is fast as we only need to traverse `[0]` to prepend to `list`\niex> [0] ++ list\n[0, 1, 2, 3]\n\n# This is slow as we need to traverse `list` to append 4\niex> list ++ [4]\n[1, 2, 3, 4]\n```\n\nTuples, on the other hand, are stored contiguously in memory. This means getting the tuple size or accessing an element by index is fast. On the other hand, updating or adding elements to tuples is expensive because it requires creating a new tuple in memory:\n\n```elixir\niex> tuple = {:a, :b, :c, :d}\n{:a, :b, :c, :d}\niex> put_elem(tuple, 2, :e)\n{:a, :b, :e, :d}\n```\n\nNote, however, the elements themselves are not copied. When you update a tuple, all entries are shared between the old and the new tuple, except for the entry that has been replaced. This rule applies to most data structures in Elixir. This reduces the amount of memory allocation the language needs to perform and is only possible thanks to the immutable semantics of the language.\n\nThose performance characteristics dictate the usage of those data structures. In a nutshell, lists are used when the number of elements returned may vary. Tuples have a fixed size. Let's see two examples from the `String` module:\n\n```elixir\niex> String.split(\"hello world\")\n[\"hello\", \"world\"]\niex> String.split(\"hello beautiful world\")\n[\"hello\", \"beautiful\", \"world\"]\n```\n\nThe [`String.split`](`String.split/1`) function breaks a string into a list of strings on every whitespace character. Since the amount of elements returned depends on the input, we use a list.\n\nOn the other hand, [`String.split_at`](`String.split_at/2`) splits a string in two parts at a given position. Since it always returns two entries, regardless of the input size, it returns tuples:\n\n```elixir\niex> String.split_at(\"hello world\", 3)\n{\"hel\", \"lo world\"}\niex> String.split_at(\"hello world\", -4)\n{\"hello w\", \"orld\"}\n```\n\nIt is also very common to use tuples and atoms to create \"tagged tuples\", which is a handy return value when an operation may succeed or fail. For example, [`File.read`](`File.read/1`) reads the contents of a file at a given path, which may or may not exist. It returns tagged tuples:\n\n```elixir\niex> File.read(\"path/to/existing/file\")\n{:ok, \"... contents ...\"}\niex> File.read(\"path/to/unknown/file\")\n{:error, :enoent}\n```\n\nIf the path given to [`File.read`](`File.read/1`) exists, it returns a tuple with the atom `:ok` as the first element and the file contents as the second. Otherwise, it returns a tuple with `:error` and the error description. As we will soon learn, Elixir allows us to *pattern match* on tagged tuples and effortlessly handle both success and failure cases.\n\nGiven Elixir consistently follows those rules, the choice between lists and tuples get clearer as you learn and use the language. Elixir often guides you to do the right thing. For example, there is an [`elem`](`elem/2`) function to access a tuple item:\n\n```elixir\niex> tuple = {:ok, \"hello\"}\n{:ok, \"hello\"}\niex> elem(tuple, 1)\n\"hello\"\n```\n\nHowever, given you often don't know the number of elements in a list, there is no built-in equivalent for accessing arbitrary entries in a lists, apart from its head.\n\n## Size or length?\n\nWhen counting the elements in a data structure, Elixir also abides by a simple rule: the function is named `size` if the operation is in constant time (the value is pre-calculated) or `length` if the operation is linear (calculating the length gets slower as the input grows). As a mnemonic, both \"length\" and \"linear\" start with \"l\".\n\nFor example, we have used 4 counting functions so far: [`byte_size`](`byte_size/1`) (for the number of bytes in a string), [`tuple_size`](`tuple_size/1`) (for tuple size), [`length`](`length/1`) (for list length) and [`String.length`](`String.length/1`) (for the number of graphemes in a string). We use [`byte_size`](`byte_size/1`) to get the number of bytes in a string, which is a cheap operation. Retrieving the number of Unicode graphemes, on the other hand, uses [`String.length`](`String.length/1`), and may be expensive as it relies on a traversal of the entire string.\n\nNow that we are familiar with the basic data-types in the language, let's learn important constructs for writing code, before we discuss more complex data structures.\n" }, { "path": "lib/elixir/pages/getting-started/module-attributes.md", "content": "\n\n# Module attributes\n\nModule attributes in Elixir serve three purposes:\n\n1. as module and function annotations\n2. as temporary module storage to be used during compilation\n3. as compile-time constants\n\nLet's check these examples.\n\n## As annotations\n\nElixir brings the concept of module attributes from Erlang. For example:\n\n```elixir\ndefmodule MyServer do\n @moduledoc \"My server code.\"\nend\n```\n\nIn the example above, we are defining the module documentation by using the module attribute syntax. Elixir has a handful of reserved attributes. Here are a few of them, the most commonly used ones:\n\n * `@moduledoc` — provides documentation for the current module.\n * `@doc` — provides documentation for the function or macro that follows the attribute.\n * `@spec` — provides a typespec for the function that follows the attribute.\n * `@behaviour` — (notice the British spelling) used for specifying an OTP or user-defined behaviour.\n\n`@moduledoc` and `@doc` are by far the most used attributes, and we expect you to use them a lot. Elixir treats documentation as first-class and provides many functions to access documentation. We will cover them [in their own chapter](writing-documentation.md).\n\nDocumentation is only accessible from compiled modules. So in order to give it a try, let's once again define the `Math` module, but this time within a file named `math.ex`:\n\n```elixir\ndefmodule Math do\n @moduledoc \"\"\"\n Provides math-related functions.\n\n ## Examples\n\n iex> Math.sum(1, 2)\n 3\n\n \"\"\"\n\n @doc \"\"\"\n Calculates the sum of two numbers.\n \"\"\"\n def sum(a, b), do: a + b\nend\n```\n\nElixir promotes the use of Markdown with heredocs to write readable documentation. Heredocs are multi-line strings, they start and end with triple double-quotes, keeping the formatting of the inner text.\n\nNow let's compile it. Start `iex` and then invoke [the `c/2` helper](`IEx.Helpers.c/2`):\n\n```elixir\niex> c(\"math.ex\", \".\")\n[Math]\n```\n\nAnd now we can access them:\n\n```elixir\niex> h Math # Docs for module Math\n...\niex> h Math.sum # Docs for the sum function\n...\n```\n\nWhen we compiled the module, you may have noticed Elixir created a `Elixir.Math.beam` file. That's the bytecode for the module and that's where the documentation is stored.\n\nIn our day to day, Elixir developers use the `Mix` build tool to compile code and projects like [ExDoc](https://github.com/elixir-lang/ex_doc) to generate HTML and EPUB pages from the documentation.\n\nTake a look at the docs for `Module` for a complete list of supported attributes.\n\n## As temporary storage\n\nSo far, we have seen how to define attributes, but how can we read them? Let's see an example:\n\n```elixir\ndefmodule MyServer do\n @service URI.parse(\"https://example.com\")\n IO.inspect(@service)\nend\n```\n\n> #### Newlines {: .warning}\n>\n> Do not add a newline between the attribute and its value, otherwise Elixir will assume you are reading the value, rather than setting it.\n\nTrying to access an attribute that was not defined will print a warning:\n\n```elixir\ndefmodule MyServer do\n @unknown\nend\nwarning: undefined module attribute @unknown, please remove access to @unknown or explicitly set it before access\n```\n\nAttributes can also be read inside functions:\n\n```elixir\ndefmodule MyApp.Status do\n @service URI.parse(\"https://example.com\")\n def status(email) do\n SomeHttpClient.get(@service)\n end\nend\n```\n\nThe module attribute is defined at compilation time and its *return value*, not the function call itself, is what will be substituted in for the attribute. So the above will effectively compile to this:\n\n```elixir\ndefmodule MyApp.Status do\n def status(email) do\n SomeHttpClient.get(%URI{\n authority: \"example.com\",\n host: \"example.com\",\n port: 443,\n scheme: \"https\"\n })\n end\nend\n```\n\nThis can be useful for pre-computing values and then injecting its results into the module. This is what we mean by temporary storage: after the module is compiled, the module attribute is discarded, except for the functions that have read the attribute. Note you cannot invoke functions defined in the same module as part of the attribute itself, as those functions have not yet been defined.\n\nEvery time we read an attribute inside a function, Elixir takes a snapshot of its current value. Therefore if you read the same attribute multiple times inside multiple functions, you end-up increasing compilation times as Elixir now has to compile every snapshot. Generally speaking, you want to avoid reading the same attribute multiple times and instead move it to function. For example, instead of this:\n\n```elixir\ndef some_function, do: do_something_with(@example)\ndef another_function, do: do_something_else_with(@example)\n```\n\nPrefer this:\n\n```elixir\ndef some_function, do: do_something_with(example())\ndef another_function, do: do_something_else_with(example())\ndefp example, do: @example\n```\n\n## As compile-time constants\n\nModule attributes may also be useful as compile-time constants. Generally speaking, functions themselves are sufficient for the role of constants in a codebase. For example, instead of defining:\n\n```elixir\n@hours_in_a_day 24\n```\n\nYou should prefer:\n\n```elixir\ndefp hours_in_a_day(), do: 24\n```\n\nYou may even define a public function if it needs to be shared across modules. It is common in many projects to have a module called `MyApp.Constants` that defines all constants used throughout the codebase.\n\nYou can even have composite data structures as constants, as long as they are made exclusively of other data types (no function calls, no operators, and no other expressions). For example, you may specify a system configuration constant as follows:\n\n```elixir\ndefp system_config(), do: %{timezone: \"Etc/UTC\", locale: \"pt-BR\"}\n```\n\nGiven data structures in Elixir are immutable, only a single instance of the data structure above is allocated and shared across all functions calls, as long as it doesn't have any executable expression.\n\nThe use case for module attributes arise when you need to do some work at compile-time and then inject its results inside a function. A common scenario is module attributes inside patterns and guards (as an alternative to `defguard/1`), since they only support a limited set of expressions:\n\n```elixir\n# Inside pattern\n@default_timezone \"Etc/UTC\"\ndef shift(@default_timezone), do: ...\n\n# Inside guards\n@time_periods [:am, :pm]\ndef shift(time, period) when period in @time_periods, do: ...\n```\n\nModule attributes as constants and as temporary storage are most often used together: the module attribute is used to compute and store an expensive value, and then exposed as constant from that module.\n\n## Going further\n\nLibraries and frameworks can leverage module attributes to provide custom annotations. To see an example, look no further than Elixir's unit test framework called `ExUnit`. `ExUnit` uses module attributes for multiple different purposes:\n\n```elixir\ndefmodule MyTest do\n use ExUnit.Case, async: true\n\n @tag :external\n @tag os: :unix\n test \"contacts external service\" do\n # ...\n end\nend\n```\n\nIn the example above, `ExUnit` stores the value of `async: true` in a module attribute to change how the module is compiled. Tags also work as annotations and they can be supplied multiple times, thanks to Elixir's ability to [accumulate attributes](`Module.register_attribute/3`). Then you can use tags to setup and filter tests, such as avoiding executing Unix specific tests while running your test suite on Windows.\n\nTo fully understand how `ExUnit` works, we'd need macros, so we will revisit this pattern in the Meta-programming guide and learn how to use module attributes as storage for custom annotations.\n\nIn the next chapters, we'll explore structs and protocols before moving to exception handling and other constructs like sigils and comprehensions.\n" }, { "path": "lib/elixir/pages/getting-started/modules-and-functions.md", "content": "\n\n# Modules and functions\n\nIn Elixir we group several functions into modules. We've already used many different modules in the previous chapters, such as the `String` module:\n\n```elixir\niex> String.length(\"hello\")\n5\n```\n\nIn order to create our own modules in Elixir, we use the [`defmodule`](`defmodule/2`) macro. The first letter of a module name (an alias, as described further down) must be in uppercase. We use the [`def`](`def/2`) macro to define functions in that module. The first letter of every function must be in lowercase (or underscore):\n\n```elixir\niex> defmodule Math do\n...> def sum(a, b) do\n...> a + b\n...> end\n...> end\n\niex> Math.sum(1, 2)\n3\n```\n\nIn this chapter we will define our own modules, with different levels of complexity. As our examples get longer in size, it can be tricky to type them all in the shell, so we will resort more frequently to scripting.\n\n## Scripting\n\nElixir has two file extensions `.ex` (Elixir) and `.exs` (Elixir scripts). Elixir treats both files exactly the same way, the only difference is in intention. `.ex` files are meant to be compiled while `.exs` files are used for scripting.\n\nLet's create a file named `math.exs`:\n\n```elixir\ndefmodule Math do\n def sum(a, b) do\n a + b\n end\nend\n\nIO.puts Math.sum(1, 2)\n```\n\nAnd execute it as:\n\n```console\n$ elixir math.exs\n```\n\nYou can also load the file within `iex` by running:\n\n```console\n$ iex math.exs\n```\n\nAnd then have direct access to the `Math` module.\n\n## Function definition\n\nInside a module, we can define functions with `def/2` and private functions with `defp/2`. A function defined with `def/2` can be invoked from other modules while a private function can only be invoked locally.\n\n```elixir\ndefmodule Math do\n def sum(a, b) do\n do_sum(a, b)\n end\n\n defp do_sum(a, b) do\n a + b\n end\nend\n\nIO.puts Math.sum(1, 2) #=> 3\nIO.puts Math.do_sum(1, 2) #=> ** (UndefinedFunctionError)\n```\n\nFunction declarations also support guards and multiple clauses. If a function has several clauses, Elixir will try each clause until it finds one that matches. Here is an implementation of a function that checks if the given number is zero or not:\n\n```elixir\ndefmodule Math do\n def zero?(0) do\n true\n end\n\n def zero?(x) when is_integer(x) do\n false\n end\nend\n\nIO.puts Math.zero?(0) #=> true\nIO.puts Math.zero?(1) #=> false\nIO.puts Math.zero?([1, 2, 3]) #=> ** (FunctionClauseError)\nIO.puts Math.zero?(0.0) #=> ** (FunctionClauseError)\n```\n\nThe trailing question mark in `zero?` means that this function returns a boolean. To learn more about the naming conventions for modules, function names, variables and more in Elixir, see [Naming Conventions](../references/naming-conventions.md).\n\nGiving an argument that does not match any of the clauses raises an error.\n\nSimilar to constructs like `if`, function definitions support both `do:` and `do`-block syntax, as [we learned in the previous chapter](keywords-and-maps.md#do-blocks-and-keywords). For example, we can edit `math.exs` to look like this:\n\n```elixir\ndefmodule Math do\n def zero?(0), do: true\n def zero?(x) when is_integer(x), do: false\nend\n```\n\nAnd it will provide the same behavior. You may use `do:` for one-liners but always use `do`-blocks for functions spanning multiple lines. If you prefer to be consistent, you can use `do`-blocks throughout your codebase.\n\n## Default arguments\n\nFunction definitions in Elixir also support default arguments:\n\n```elixir\ndefmodule Concat do\n def join(a, b, sep \\\\ \" \") do\n a <> sep <> b\n end\nend\n\nIO.puts(Concat.join(\"Hello\", \"world\")) #=> Hello world\nIO.puts(Concat.join(\"Hello\", \"world\", \"_\")) #=> Hello_world\n```\n\nAny expression is allowed to serve as a default value, but it won't be evaluated during the function definition. Every time the function is invoked and any of its default values have to be used, the expression for that default value will be evaluated:\n\n```elixir\ndefmodule DefaultTest do\n def dowork(x \\\\ \"hello\") do\n x\n end\nend\n```\n\n```elixir\niex> DefaultTest.dowork()\n\"hello\"\niex> DefaultTest.dowork(123)\n123\niex> DefaultTest.dowork()\n\"hello\"\n```\n\nIf a function with default values has multiple clauses, it is required to create a function head (a function definition without a body) for declaring defaults:\n\n```elixir\ndefmodule Concat do\n # A function head declaring defaults\n def join(a, b, sep \\\\ \" \")\n\n # The separator is unused in this case, so we prefix it with underscore\n def join(a, b, _sep) when b == \"\" do\n a\n end\n\n def join(a, b, sep) do\n a <> sep <> b\n end\nend\n\nIO.puts(Concat.join(\"Hello\", \"\")) #=> Hello\nIO.puts(Concat.join(\"Hello\", \"world\")) #=> Hello world\nIO.puts(Concat.join(\"Hello\", \"world\", \"_\")) #=> Hello_world\n```\n\nFunction heads cannot have patterns nor guards. They may only define the argument names and their default values.\n\n## Understanding Aliases\n\nAn alias in Elixir is a capitalized identifier (like `String`, `Keyword`, etc) which is converted to an atom during compilation. For instance, the `String` alias translates by default to the atom `:\"Elixir.String\"`:\n\n```elixir\niex> is_atom(String)\ntrue\niex> to_string(String)\n\"Elixir.String\"\niex> :\"Elixir.String\" == String\ntrue\n```\n\nBy using the `alias/2` directive, we are changing the atom the alias expands to.\n\nAliases expand to atoms because in the Erlang Virtual Machine (and consequently Elixir) modules are always represented by atoms. By namespacing those atoms, Elixir modules avoid conflicting with existing Erlang modules.\n\n```elixir\niex> List.flatten([1, [2], 3])\n[1, 2, 3]\niex> :\"Elixir.List\".flatten([1, [2], 3])\n[1, 2, 3]\n```\n\nThat's the mechanism we use to call Erlang modules:\n\n```elixir\niex> :lists.flatten([1, [2], 3])\n[1, 2, 3]\n```\n\n## Module nesting\n\nNow that we have talked about aliases, we can talk about nesting and how it works in Elixir. Consider the following example:\n\n```elixir\ndefmodule Foo do\n defmodule Bar do\n end\nend\n```\n\nThe example above will define two modules: `Foo` and `Foo.Bar`. The second can be accessed as `Bar` inside `Foo` as long as they are in the same lexical scope.\n\nIf, later, the `Bar` module is moved outside the `Foo` module definition, it must be referenced by its full name (`Foo.Bar`) or an alias must be set using the `alias` directive discussed above:\n\n```elixir\ndefmodule Foo.Bar do\nend\n\ndefmodule Foo do\n alias Foo.Bar\n # Can still access it as `Bar`\nend\n```\n\n> #### Module names are isolated {: .info}\n>\n> You don't have to define the `Foo` module before defining the `Foo.Bar` module, as they are effectively independent.\n\nAliasing a module only alias a single module, it doesn't alias any of its parents. Consider the following example:\n\n```elixir\ndefmodule Foo do\n defmodule Bar do\n defmodule Baz do\n end\n end\nend\n\nalias Foo.Bar.Baz\n# The module `Foo.Bar.Baz` is now available as `Baz`\n# However, the module `Foo.Bar` is *not* available as `Bar`\n```\n\nAs we will see in later chapters, aliases also work well with macros, to guarantee they are hygienic.\n" }, { "path": "lib/elixir/pages/getting-started/optional-syntax.md", "content": "\n\n# Optional syntax sheet\n\nIn the previous chapters, we learned that the Elixir syntax allows developers to omit delimiters in a few occasions to make code more readable. For example, we learned that parentheses are optional:\n\n```elixir\niex> length([1, 2, 3]) == length [1, 2, 3]\ntrue\n```\n\nand that `do`-`end` blocks are equivalent to keyword lists:\n\n```elixir\n# do-end blocks\niex> if true do\n...> :this\n...> else\n...> :that\n...> end\n:this\n\n# keyword lists\niex> if true, do: :this, else: :that\n:this\n```\n\nKeyword lists use Elixir's regular notation for separating arguments, where we separate each key-value pair with commas, and each key is followed by `:`. In the `do`-blocks, we get rid of the colons, the commas, and separate each keyword by a newline. They are useful exactly because they remove the verbosity when writing blocks of code. Most of the time, we use the block syntax, but it is good to know they are equivalent.\n\nThose conveniences, which we call here \"optional syntax\", allow the language syntax core to be small, without sacrificing the readability and expressiveness of your code. In this brief chapter, we will review the four rules provided by the language, using a short snippet as playground.\n\n## Walk-through\n\nTake the following code:\n\n```elixir\nif variable? do\n Call.this()\nelse\n Call.that()\nend\n```\n\nNow let's remove the conveniences one by one:\n\n1. `do`-`end` blocks are equivalent to keywords:\n\n ```elixir\n if variable?, do: Call.this(), else: Call.that()\n ```\n\n2. Keyword lists as last argument do not require square brackets, but let's add them:\n\n ```elixir\n if variable?, [do: Call.this(), else: Call.that()]\n ```\n\n3. Keyword lists are the same as lists of two-element tuples:\n\n ```elixir\n if variable?, [{:do, Call.this()}, {:else, Call.that()}]\n ```\n\n4. Finally, parentheses are optional on function calls, but let's add them:\n\n ```elixir\n if(variable?, [{:do, Call.this()}, {:else, Call.that()}])\n ```\n\nThat's it! Those four rules outline the optional syntax available in Elixir.\n\nTo understand why these rules matter, we can briefly compare Elixir with many other programming languages. Most programming languages have several keywords for defining methods, functions, conditionals, loops, and so forth. Each of those keywords have their own syntax rules attached to them.\n\nHowever, in Elixir, none of these language features require special \"keywords\", instead they all build from this small set of rules. The other benefit is that developers can also extend the language in a way that is consistent with the language itself, since the constructs for designing and extending the language are the same. We further explore this topic in [the \"Meta-programming\" guide](../meta-programming/quote-and-unquote.md).\n\nAt the end of the day, those rules are what enables us to write:\n\n```elixir\ndefmodule Math do\n def add(a, b) do\n a + b\n end\nend\n```\n\ninstead of:\n\n```elixir\ndefmodule(Math, [\n {:do, def(add(a, b), [{:do, a + b}])}\n])\n```\n\nWhenever you have any questions, this quick walk-through has you covered.\n\nFinally, if you are concerned about when to apply these rules, it's worth noting that the Elixir formatter handles those concerns for you. Most Elixir developers use the `mix format` task to format their codebases according to a well-defined set of rules defined by the Elixir team and the community. For instance, `mix format` will always add parentheses to function calls unless explicitly configured not to do so. This helps to maintain consistency across all codebases within organizations and the wider community.\n" }, { "path": "lib/elixir/pages/getting-started/pattern-matching.md", "content": "\n\n# Pattern matching\n\nIn this chapter, we will learn why the [`=`](`=/2`) operator in Elixir is called the match operator and how to use it to pattern match inside data structures. We will learn about the pin operator [`^`](`^/1`) used to access previously bound values.\n\n## The match operator\n\nWe have used the [`=`](`=/2`) operator a couple times to assign variables in Elixir:\n\n```elixir\niex> x = 1\n1\niex> x\n1\n```\n\nIn Elixir, the [`=`](`=/2`) operator is actually called *the match operator*. Let's see why:\n\n```elixir\niex> x = 1\n1\niex> 1 = x\n1\niex> 2 = x\n** (MatchError) no match of right hand side value: 1\n```\n\nNotice that `1 = x` is a valid expression, and it matched because both the left and right side are equal to `1`. When the sides do not match, a `MatchError` is raised.\n\nA variable can only be assigned on the left side of [`=`](`=/2`):\n\n```elixir\niex> 1 = unknown\n** (CompileError) iex:1: undefined variable \"unknown\"\n```\n\n## Pattern matching\n\nThe match operator is not only used to match against simple values, but it is also useful for destructuring more complex data types. For example, we can pattern match on tuples:\n\n```elixir\niex> {a, b, c} = {:hello, \"world\", 42}\n{:hello, \"world\", 42}\niex> a\n:hello\niex> b\n\"world\"\n```\n\nA pattern match error will occur if the sides can't be matched, for example if the tuples have different sizes:\n\n```elixir\niex> {a, b, c} = {:hello, \"world\"}\n** (MatchError) no match of right hand side value: {:hello, \"world\"}\n```\n\nAnd also when comparing different types, for example if matching a tuple on the left side with a list on the right side:\n\n```elixir\niex> {a, b, c} = [:hello, \"world\", 42]\n** (MatchError) no match of right hand side value: [:hello, \"world\", 42]\n```\n\nMore interestingly, we can match on specific values. The example below asserts that the left side will only match the right side when the right side is a tuple that starts with the atom `:ok`:\n\n```elixir\niex> {:ok, result} = {:ok, 13}\n{:ok, 13}\niex> result\n13\n\niex> {:ok, result} = {:error, :oops}\n** (MatchError) no match of right hand side value: {:error, :oops}\n```\n\nWe can pattern match on lists:\n\n```elixir\niex> [a, b, c] = [1, 2, 3]\n[1, 2, 3]\niex> a\n1\n```\n\nA list also supports matching on its own head and tail:\n\n```elixir\niex> [head | tail] = [1, 2, 3]\n[1, 2, 3]\niex> head\n1\niex> tail\n[2, 3]\n```\n\nSimilar to the [`hd`](`hd/1`) and [`tl`](`tl/1`) functions, we can't match an empty list with a head and tail pattern:\n\n```elixir\niex> [head | tail] = []\n** (MatchError) no match of right hand side value: []\n```\n\nThe `[head | tail]` format is not only used on pattern matching but also for prepending items to a list:\n\n```elixir\niex> list = [1, 2, 3]\n[1, 2, 3]\niex> [0 | list]\n[0, 1, 2, 3]\n```\n\nIn some cases, you don't care about a particular value in a pattern. It is a common practice to bind those values to the underscore, `_`. For example, if only the head of the list matters to us, we can assign the tail to underscore:\n\n```elixir\niex> [head | _] = [1, 2, 3]\n[1, 2, 3]\niex> head\n1\n```\n\nThe variable `_` is special in that it can never be read from. Trying to read from it gives a compile error:\n\n```elixir\niex> _\n** (CompileError) iex:1: invalid use of _. \"_\" represents a value to be ignored in a pattern and cannot be used in expressions\n```\n\nIf a variable is mentioned more than once in a pattern, all references must bind to the same value:\n\n```elixir\niex> {x, x} = {1, 1}\n{1, 1}\niex> {x, x} = {1, 2}\n** (MatchError) no match of right hand side value: {1, 2}\n```\n\nAlthough pattern matching allows us to build powerful constructs, its usage is limited. For instance, you cannot make function calls on the left side of a match. The following example is invalid:\n\n```elixir\niex> length([1, [2], 3]) = 3\n** (CompileError) iex:1: cannot invoke remote function :erlang.length/1 inside match\n```\n\nPattern matching allows developers to easily destructure data types such as tuples and lists. As we will see in the following chapters, it is one of the foundations of recursion in Elixir and applies to other types as well, like maps and binaries.\n\n## The pin operator\n\nVariables in Elixir can be rebound:\n\n```elixir\niex> x = 1\n1\niex> x = 2\n2\n```\n\nHowever, there are times when we don't want variables to be rebound.\n\nUse the pin operator [`^`](`^/1`) when you want to pattern match against a variable's *existing value* rather than rebinding the variable.\n\n```elixir\niex> x = 1\n1\niex> ^x = 2\n** (MatchError) no match of right hand side value: 2\n```\n\nBecause we have pinned `x` when it was bound to the value of `1`, it is equivalent to the following:\n\n```elixir\niex> 1 = 2\n** (MatchError) no match of right hand side value: 2\n```\n\nNotice that we even see the exact same error message.\n\nWe can use the pin operator inside other pattern matches, such as tuples or lists:\n\n```elixir\niex> x = 1\n1\niex> [^x, 2, 3] = [1, 2, 3]\n[1, 2, 3]\niex> {y, ^x} = {2, 1}\n{2, 1}\niex> y\n2\niex> {y, ^x} = {2, 2}\n** (MatchError) no match of right hand side value: {2, 2}\n```\n\nBecause `x` was bound to the value of `1` when it was pinned, this last example could have been written as:\n\n```elixir\niex> {y, 1} = {2, 2}\n** (MatchError) no match of right hand side value: {2, 2}\n```\n\nThis finishes our introduction to pattern matching. As we will see in the next chapter, pattern matching is very common in many language constructs and they can be further augmented with guards.\n" }, { "path": "lib/elixir/pages/getting-started/processes.md", "content": "\n\n# Processes\n\nIn Elixir, all code runs inside processes. Processes are isolated from each other, run concurrent to one another and communicate via message passing. Processes are not only the basis for concurrency in Elixir, but they also provide the means for building distributed and fault-tolerant programs.\n\nElixir's processes should not be confused with operating system processes. Processes in Elixir are extremely lightweight in terms of memory and CPU (even compared to threads as used in many other programming languages). Because of this, it is not uncommon to have tens or even hundreds of thousands of processes running simultaneously.\n\nIn this chapter, we will learn about the basic constructs for spawning new processes, as well as sending and receiving messages between processes.\n\n## Spawning processes\n\nThe basic mechanism for spawning new processes is the auto-imported `spawn/1` function:\n\n```elixir\niex> spawn(fn -> 1 + 2 end)\n#PID<0.43.0>\n```\n\n`spawn/1` takes a function which it will execute in another process.\n\nNotice `spawn/1` returns a PID (process identifier). At this point, the process you spawned is very likely dead. The spawned process will execute the given function and exit after the function is done:\n\n```elixir\niex> pid = spawn(fn -> 1 + 2 end)\n#PID<0.44.0>\niex> Process.alive?(pid)\nfalse\n```\n\n> Note: you will likely get different process identifiers than the ones we are showing in our snippets.\n\nWe can retrieve the PID of the current process by calling `self/0`:\n\n```elixir\niex> self()\n#PID<0.41.0>\niex> Process.alive?(self())\ntrue\n```\n\nProcesses get much more interesting when we are able to send and receive messages.\n\n## Sending and receiving messages\n\nWe can send messages to a process with `send/2` and receive them with `receive/1`:\n\n```elixir\niex> send(self(), {:hello, \"world\"})\n{:hello, \"world\"}\niex> receive do\n...> {:hello, msg} -> msg\n...> {:world, _msg} -> \"won't match\"\n...> end\n\"world\"\n```\n\nWhen a message is sent to a process, the message is stored in the process mailbox. The `receive/1` block goes through the current process mailbox searching for a message that matches any of the given patterns. `receive/1` supports guards and many clauses, exactly as `case/2`.\n\nThe process that sends the message does not block on `send/2`, it puts the message in the recipient's mailbox and continues. In particular, a process can send messages to itself.\n\nIf there is no message in the mailbox matching any of the patterns, the current process will wait until a matching message arrives. A timeout can also be specified:\n\n```elixir\niex> receive do\n...> {:hello, msg} -> msg\n...> after\n...> 1_000 -> \"nothing after 1s\"\n...> end\n\"nothing after 1s\"\n```\n\nA timeout of 0 can be given when you already expect the message to be in the mailbox.\n\nLet's put it all together and send messages between processes:\n\n```elixir\niex> parent = self()\n#PID<0.41.0>\niex> spawn(fn -> send(parent, {:hello, self()}) end)\n#PID<0.48.0>\niex> receive do\n...> {:hello, pid} -> \"Got hello from #{inspect pid}\"\n...> end\n\"Got hello from #PID<0.48.0>\"\n```\n\nThe `inspect/1` function is used to convert a data structure's internal representation into a string, typically for printing. Notice that when the `receive` block gets executed the sender process we have spawned may already be dead, as its only instruction was to send a message.\n\nWhile in the shell, you may find the helper `flush/0` quite useful. It flushes and prints all the messages in the mailbox.\n\n```elixir\niex> send(self(), :hello)\n:hello\niex> flush()\n:hello\n:ok\n```\n\n## Links\n\nThe majority of times we spawn processes in Elixir, we spawn them as linked processes. Before we show an example with `spawn_link/1`, let's see what happens when a process started with `spawn/1` fails:\n\n```elixir\niex> spawn(fn -> raise \"oops\" end)\n#PID<0.58.0>\n\n[error] Process #PID<0.58.00> raised an exception\n** (RuntimeError) oops\n (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6\n```\n\nIt merely logged an error but the parent process is still running. That's because processes are isolated. If we want the failure in one process to propagate to another one, we should link them. This can be done with `spawn_link/1`:\n\n```elixir\niex> self()\n#PID<0.41.0>\niex> spawn_link(fn -> raise \"oops\" end)\n\n** (EXIT from #PID<0.41.0>) evaluator process exited with reason: an exception was raised:\n ** (RuntimeError) oops\n (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6\n\n[error] Process #PID<0.289.0> raised an exception\n** (RuntimeError) oops\n (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6\n```\n\nBecause processes are linked, we now see a message saying the parent process, which is the shell process, has received an EXIT signal from another process causing the shell to terminate. IEx detects this situation and starts a new shell session.\n\nLinking can also be done manually by calling `Process.link/1`. We recommend that you take a look at the `Process` module for other functionality provided by processes.\n\nProcesses and links play an important role when building fault-tolerant systems. Elixir processes are isolated and don't share anything by default. Therefore, a failure in a process will never crash or corrupt the state of another process. Links, however, allow processes to establish a relationship in case of failure. We often link our processes to supervisors which will detect when a process dies and start a new process in its place.\n\nWhile other languages would require us to catch/handle exceptions, in Elixir we are actually fine with letting processes fail because we expect supervisors to properly restart our systems. \"Failing fast\" (sometimes referred as \"let it crash\") is a common philosophy when writing Elixir software!\n\n`spawn/1` and `spawn_link/1` are the basic primitives for creating processes in Elixir. Although we have used them exclusively so far, most of the time we are going to use abstractions that build on top of them. Let's see the most common one, called tasks.\n\n## Tasks\n\nTasks build on top of the spawn functions to provide better error reports and introspection:\n\n```elixir\niex> Task.start(fn -> raise \"oops\" end)\n{:ok, #PID<0.55.0>}\n\n15:22:33.046 [error] Task #PID<0.55.0> started from #PID<0.53.0> terminating\n** (RuntimeError) oops\n (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6\n (elixir) lib/task/supervised.ex:85: Task.Supervised.do_apply/2\n (stdlib) proc_lib.erl:247: :proc_lib.init_p_do_apply/3\nFunction: #Function<20.99386804/0 in :erl_eval.expr/5>\n Args: []\n```\n\nInstead of `spawn/1` and `spawn_link/1`, we use `Task.start/1` and `Task.start_link/1` which return `{:ok, pid}` rather than just the PID. This is what enables tasks to be used in supervision trees. Furthermore, `Task` provides convenience functions, like `Task.async/1` and `Task.await/1`, and functionality to ease distribution.\n\nWe will explore tasks and other abstractions around processes in the [\"Mix and OTP guide\"](../mix-and-otp/introduction-to-mix.md).\n\n## State\n\nWe haven't talked about state so far. If you are building an application that requires state, for example, to keep your application configuration, or you need to parse a file and keep it in memory, where would you store it?\n\nProcesses are the most common answer to this question. We can write processes that loop infinitely, maintain state, and send and receive messages. As an example, let's write a module that starts new processes that work as a key-value store in a file named `kv.exs`:\n\n```elixir\ndefmodule KV do\n def start_link do\n Task.start_link(fn -> loop(%{}) end)\n end\n\n defp loop(map) do\n receive do\n {:get, key, caller} ->\n send(caller, Map.get(map, key))\n loop(map)\n {:put, key, value} ->\n loop(Map.put(map, key, value))\n end\n end\nend\n```\n\nNote that the `start_link` function starts a new process that runs the `loop/1` function, starting with an empty map. The `loop/1` (private) function then waits for messages and performs the appropriate action for each message. We made `loop/1` private by using `defp` instead of `def`. In the case of a `:get` message, it sends a message back to the caller and calls `loop/1` again, to wait for a new message. While the `:put` message actually invokes `loop/1` with a new version of the map, with the given `key` and `value` stored.\n\nLet's give it a try by running `iex kv.exs`:\n\n```elixir\niex> {:ok, pid} = KV.start_link()\n{:ok, #PID<0.62.0>}\niex> send(pid, {:get, :hello, self()})\n{:get, :hello, #PID<0.41.0>}\niex> flush()\nnil\n:ok\n```\n\nAt first, the process map has no keys, so sending a `:get` message and then flushing the current process inbox returns `nil`. Let's send a `:put` message and try it again:\n\n```elixir\niex> send(pid, {:put, :hello, :world})\n{:put, :hello, :world}\niex> send(pid, {:get, :hello, self()})\n{:get, :hello, #PID<0.41.0>}\niex> flush()\n:world\n:ok\n```\n\nNotice how the process is keeping a state and we can get and update this state by sending the process messages. In fact, any process that knows the `pid` above will be able to send it messages and manipulate the state.\n\nIt is also possible to register the `pid`, giving it a name, and allowing everyone that knows the name to send it messages:\n\n```elixir\niex> Process.register(pid, :kv)\ntrue\niex> send(:kv, {:get, :hello, self()})\n{:get, :hello, #PID<0.41.0>}\niex> flush()\n:world\n:ok\n```\n\nUsing processes to maintain state and name registration are very common patterns in Elixir applications. However, most of the time, we won't implement those patterns manually as above, but by using one of the many abstractions that ship with Elixir. For example, Elixir provides `Agent`s, which are simple abstractions around state. Our code above could be directly written as:\n\n```elixir\niex> {:ok, pid} = Agent.start_link(fn -> %{} end)\n{:ok, #PID<0.72.0>}\niex> Agent.update(pid, fn map -> Map.put(map, :hello, :world) end)\n:ok\niex> Agent.get(pid, fn map -> Map.get(map, :hello) end)\n:world\n```\n\nA `:name` option could also be given to `Agent.start_link/2` and it would be automatically registered. Besides agents, Elixir provides an API for building generic servers (called `GenServer`), registries, and more, all powered by processes underneath. Those, along with supervision trees, will be explored with more detail in the [\"Mix and OTP guide\"](../mix-and-otp/introduction-to-mix.md), which will build a complete Elixir application from start to finish.\n\nFor now, let's move on and explore the world of I/O in Elixir.\n" }, { "path": "lib/elixir/pages/getting-started/protocols.md", "content": "\n\n# Protocols\n\nProtocols are a mechanism to achieve polymorphism in Elixir where you want the behavior to vary depending on the data type. We are already familiar with one way of solving this type of problem: via pattern matching and guard clauses. Consider a simple utility module that would tell us the type of input variable:\n\n```elixir\ndefmodule Utility do\n def type(value) when is_binary(value), do: \"string\"\n def type(value) when is_integer(value), do: \"integer\"\n # ... other implementations ...\nend\n```\n\nIf the use of this module were confined to your own project, you would be able to keep defining new `type/1` functions for each new data type. However, this code could be problematic if it was shared as a dependency by multiple apps because there would be no easy way to extend its functionality.\n\nThis is where protocols can help us: protocols allow us to extend the original behavior for as many data types as we need. That's because **dispatching on a protocol is available to any data type that has implemented the protocol** and a protocol can be implemented by anyone, at any time.\n\nHere's how we could write the same `Utility.type/1` functionality as a protocol:\n\n```elixir\ndefprotocol Utility do\n @spec type(t) :: String.t()\n def type(value)\nend\n\ndefimpl Utility, for: BitString do\n def type(_value), do: \"string\"\nend\n\ndefimpl Utility, for: Integer do\n def type(_value), do: \"integer\"\nend\n```\n\nWe define the protocol using `defprotocol/2` - its functions and specs may look similar to interfaces or abstract base classes in other languages. We can add as many implementations as we like using `defimpl/2`. The output is exactly the same as if we had a single module with multiple functions:\n\n```elixir\niex> Utility.type(\"foo\")\n\"string\"\niex> Utility.type(123)\n\"integer\"\n```\n\nWith protocols, however, we are no longer stuck having to continuously modify the same module to support more and more data types. For example, we could spread the `defimpl` calls above over multiple files and Elixir will dispatch the execution to the appropriate implementation based on the data type. Functions defined in a protocol may have more than one input, but the **dispatching will always be based on the data type of the first input**.\n\nOne of the most common protocols you may encounter is the `String.Chars` protocol: implementing its `to_string/1` function for your custom structs will tell the Elixir kernel how to represent them as strings. We will explore all the built-in protocols later. For now, let's implement our own.\n\n## Example\n\nNow that you have seen an example of the type of problem protocols help solve and how they solve them, let's look at a more in-depth example.\n\nIn Elixir, we have two idioms for checking how many items there are in a data structure: `length` and `size`. `length` means the information must be computed. For example, `length(list)` needs to traverse the whole list to calculate its length. On the other hand, `tuple_size(tuple)` and `byte_size(binary)` do not depend on the tuple and binary size as the size information is pre-computed in the data structure.\n\nEven if we have type-specific functions for getting the size built into Elixir (such as `tuple_size/1`), we could implement a generic `Size` protocol that all data structures for which size is pre-computed would implement.\n\nThe protocol definition would look like this:\n\n```elixir\ndefprotocol Size do\n @doc \"Calculates the size (and not the length!) of a data structure\"\n def size(data)\nend\n```\n\nThe `Size` protocol expects a function called `size` that receives one argument (the data structure we want to know the size of) to be implemented. We can now implement this protocol for the data structures that would have a compliant implementation:\n\n```elixir\ndefimpl Size, for: BitString do\n def size(string), do: byte_size(string)\nend\n\ndefimpl Size, for: Map do\n def size(map), do: map_size(map)\nend\n\ndefimpl Size, for: Tuple do\n def size(tuple), do: tuple_size(tuple)\nend\n```\n\nWe didn't implement the `Size` protocol for lists as there is no \"size\" information pre-computed for lists, and the length of a list has to be computed (with `length/1`).\n\nNow with the protocol defined and implementations in hand, we can start using it:\n\n```elixir\niex> Size.size(\"foo\")\n3\niex> Size.size({:ok, \"hello\"})\n2\niex> Size.size(%{label: \"some label\"})\n1\n```\n\nPassing a data type that doesn't implement the protocol raises an error:\n\n```elixir\niex> Size.size([1, 2, 3])\n** (Protocol.UndefinedError) protocol Size not implemented for [1, 2, 3] of type List\n```\n\nIt's possible to implement protocols for all Elixir data types:\n\n * `Atom`\n * `BitString`\n * `Float`\n * `Function`\n * `Integer`\n * `List`\n * `Map`\n * `PID`\n * `Port`\n * `Reference`\n * `Tuple`\n\n## Protocols and structs\n\nThe power of Elixir's extensibility comes when protocols and structs are used together.\n\nIn the [previous chapter](structs.md), we have learned that although structs are maps, they do not share protocol implementations with maps. For example, `MapSet`s (sets based on maps) are implemented as structs. Let's try to use the `Size` protocol with a `MapSet`:\n\n```elixir\niex> Size.size(%{})\n0\niex> set = %MapSet{} = MapSet.new\nMapSet.new([])\niex> Size.size(set)\n** (Protocol.UndefinedError) protocol Size not implemented for MapSet.new([]) of type MapSet (a struct)\n```\n\nInstead of sharing protocol implementation with maps, structs require their own protocol implementation. Since a `MapSet` has its size precomputed and accessible through `MapSet.size/1`, we can define a `Size` implementation for it:\n\n```elixir\ndefimpl Size, for: MapSet do\n def size(set), do: MapSet.size(set)\nend\n```\n\nIf desired, you could come up with your own semantics for the size of your struct. Not only that, you could use structs to build more robust data types, like queues, and implement all relevant protocols, such as `Enumerable` and possibly `Size`, for this data type.\n\n```elixir\ndefmodule User do\n defstruct [:name, :age]\nend\n\ndefimpl Size, for: User do\n def size(_user), do: 2\nend\n```\n\n## Implementing `Any`\n\nManually implementing protocols for all types can quickly become repetitive and tedious. In such cases, Elixir provides two options: we can explicitly derive the protocol implementation for our types or automatically implement the protocol for all types. In both cases, we need to implement the protocol for `Any`.\n\n### Deriving\n\nElixir allows us to derive a protocol implementation based on the `Any` implementation. Let's first implement `Any` as follows:\n\n```elixir\ndefimpl Size, for: Any do\n def size(_), do: 0\nend\n```\n\nThe implementation above is arguably not a reasonable one. For example, it makes no sense to say that the size of a `PID` or an `Integer` is `0`.\n\nHowever, should we be fine with the implementation for `Any`, in order to use such implementation we would need to tell our struct to explicitly derive the `Size` protocol:\n\n```elixir\ndefmodule OtherUser do\n @derive [Size]\n defstruct [:name, :age]\nend\n```\n\nWhen deriving, Elixir will implement the `Size` protocol for `OtherUser` based on the implementation provided for `Any`.\n\n### Fallback to `Any`\n\nAnother alternative to `@derive` is to explicitly tell the protocol to fallback to `Any` when an implementation cannot be found. This can be achieved by setting `@fallback_to_any` to `true` in the protocol definition:\n\n```elixir\ndefprotocol Size do\n @fallback_to_any true\n def size(data)\nend\n```\n\nAs we said in the previous section, the implementation of `Size` for `Any` is not one that can apply to any data type. That's one of the reasons why `@fallback_to_any` is an opt-in behavior. For the majority of protocols, raising an error when a protocol is not implemented is the proper behavior. That said, assuming we have implemented `Any` as in the previous section:\n\n```elixir\ndefimpl Size, for: Any do\n def size(_), do: 0\nend\n```\n\nNow all data types (including structs) that have not implemented the `Size` protocol will be considered to have a size of `0`.\n\nWhich technique is best between deriving and falling back to `Any` depends on the use case but, given Elixir developers prefer explicit over implicit, you may see many libraries pushing towards the `@derive` approach.\n\n## Built-in protocols\n\nElixir ships with some built-in protocols. In previous chapters, we have discussed the `Enum` module which provides many functions that work with any data structure that implements the `Enumerable` protocol:\n\n```elixir\niex> Enum.map([1, 2, 3], fn x -> x * 2 end)\n[2, 4, 6]\niex> Enum.reduce(1..3, 0, fn x, acc -> x + acc end)\n6\n```\n\nAnother useful example is the `String.Chars` protocol, which specifies how to convert a data structure to its human representation as a string. It's exposed via the `to_string` function:\n\n```elixir\niex> to_string(:hello)\n\"hello\"\n```\n\nNotice that string interpolation in Elixir calls the `to_string` function:\n\n```elixir\niex> \"age: #{25}\"\n\"age: 25\"\n```\n\nThe snippet above only works because numbers implement the `String.Chars` protocol. Passing a tuple, for example, will lead to an error:\n\n```elixir\niex> tuple = {1, 2, 3}\n{1, 2, 3}\niex> \"tuple: #{tuple}\"\n** (Protocol.UndefinedError) protocol String.Chars not implemented for {1, 2, 3} of type Tuple\n```\n\nWhen there is a need to \"print\" a more complex data structure, one can use the `inspect` function, based on the `Inspect` protocol:\n\n```elixir\niex> \"tuple: #{inspect(tuple)}\"\n\"tuple: {1, 2, 3}\"\n```\n\nThe `Inspect` protocol is the protocol used to transform any data structure into a readable textual representation. This is what tools like IEx use to print results:\n\n```elixir\niex> {1, 2, 3}\n{1, 2, 3}\niex> %User{}\n%User{name: \"john\", age: 27}\n```\n\nKeep in mind that, by convention, whenever the inspected value starts with `#`, it is representing a data structure in non-valid Elixir syntax. This means the inspect protocol is not reversible as information may be lost along the way:\n\n```elixir\niex> inspect &(&1+2)\n\"#Function<6.71889879/1 in :erl_eval.expr/5>\"\n```\n\nThere are other protocols in Elixir, but this covers the most common ones. You can learn more about protocols and implementations in the `Protocol` module.\n" }, { "path": "lib/elixir/pages/getting-started/recursion.md", "content": "\n\n# Recursion\n\nElixir does not provide loop constructs. Instead we leverage recursion and high-level functions for working with collections. This chapter will explore the former.\n\n## Loops through recursion\n\nDue to immutability, loops in Elixir (as in any functional programming language) are written differently from imperative languages. For example, in an imperative language like C, one would write:\n\n```c\nfor(i = 0; i < sizeof(array); i++) {\n array[i] = array[i] * 2;\n}\n```\n\nIn the example above, we are mutating both the array and the variable `i`. However, data structures in Elixir are immutable. For this reason, functional languages rely on recursion: a function is called recursively until a condition is reached that stops the recursive action from continuing. No data is mutated in this process. Consider the example below that prints a string an arbitrary number of times:\n\n```elixir\ndefmodule Recursion do\n def print_multiple_times(msg, n) when n > 0 do\n IO.puts(msg)\n print_multiple_times(msg, n - 1)\n end\n\n def print_multiple_times(_msg, 0) do\n :ok\n end\nend\n\nRecursion.print_multiple_times(\"Hello!\", 3)\n# Hello!\n# Hello!\n# Hello!\n:ok\n```\n\nSimilar to `case`, a function may have many clauses. A particular clause is executed when the arguments passed to the function match the clause's argument patterns and its guards evaluate to `true`.\n\nWhen `print_multiple_times/2` is initially called in the example above, the argument `n` is equal to `3`.\n\nThe first clause has a guard which says \"use this definition if and only if `n` is more than `0`\". Since this is the case, it prints the `msg` and then calls itself passing `n - 1` (`2`) as the second argument.\n\nNow we execute the same function again, starting from the first clause. Given the second argument, `n`, is still more than 0, we print the message and call ourselves once more, now with the second argument set to `1`. Then we print the message one last time and call `print_multiple_times(\"Hello!\", 0)`, starting from the top once again.\n\nWhen the second argument is zero, the guard `n > 0` evaluates to false, and the first function clause won't execute. Elixir then proceeds to try the next function clause, which explicitly matches on the case where `n` is `0`. This clause, also known as the termination clause, ignores the message argument by assigning it to the `_msg` variable and returns the atom `:ok`.\n\nFinally, if you pass an argument that does not match any clause, Elixir raises a `FunctionClauseError`:\n\n```elixir\niex> Recursion.print_multiple_times(\"Hello!\", -1)\n** (FunctionClauseError) no function clause matching in Recursion.print_multiple_times/2\n\n The following arguments were given to Recursion.print_multiple_times/2:\n\n # 1\n \"Hello!\"\n\n # 2\n -1\n\n iex:1: Recursion.print_multiple_times/2\n```\n\n## Reduce and map algorithms\n\nLet's now see how we can use the power of recursion to sum a list of numbers:\n\n```elixir\ndefmodule Math do\n def sum_list([head | tail], accumulator) do\n sum_list(tail, head + accumulator)\n end\n\n def sum_list([], accumulator) do\n accumulator\n end\nend\n\nIO.puts Math.sum_list([1, 2, 3], 0) #=> 6\n```\n\nWe invoke `sum_list` with the list `[1, 2, 3]` and the initial value `0` as arguments. We will try each clause until we find one that matches according to the pattern matching rules. In this case, the list `[1, 2, 3]` matches against `[head | tail]` which binds `head` to `1` and `tail` to `[2, 3]`; `accumulator` is set to `0`.\n\nThen, we add the head of the list to the accumulator `head + accumulator` and call `sum_list` again, recursively, passing the tail of the list as its first argument. The tail will once again match `[head | tail]` until the list is empty, as seen below:\n\n```elixir\nsum_list([1, 2, 3], 0)\nsum_list([2, 3], 1)\nsum_list([3], 3)\nsum_list([], 6)\n```\n\nWhen the list is empty, it will match the final clause which returns the final result of `6`.\n\nThe process of taking a list and _reducing_ it down to one value is known as a _reduce algorithm_ and is central to functional programming.\n\nWhat if we instead want to double all of the values in our list?\n\n```elixir\ndefmodule Math do\n def double_each([head | tail]) do\n [head * 2 | double_each(tail)]\n end\n\n def double_each([]) do\n []\n end\nend\n\nMath.double_each([1, 2, 3]) #=> [2, 4, 6]\n```\n\nHere we have used recursion to traverse a list, doubling each element and returning a new list. The process of taking a list and _mapping_ over it is known as a _map algorithm_.\n\nRecursion and [tail call](https://en.wikipedia.org/wiki/Tail_call) optimization are an important part of Elixir and are commonly used to create loops. However, when programming in Elixir you will rarely use recursion as above to manipulate lists.\n\nThe `Enum` module, which we're going to see in the next chapter already provides many conveniences for working with lists. For instance, the examples above could be written as:\n\n```elixir\niex> Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end)\n6\niex> Enum.map([1, 2, 3], fn x -> x * 2 end)\n[2, 4, 6]\n```\n\nOr, using the [capture syntax](`Kernel.SpecialForms.&/1`):\n\n```elixir\niex> Enum.reduce([1, 2, 3], 0, &+/2)\n6\niex> Enum.map([1, 2, 3], &(&1 * 2))\n[2, 4, 6]\n```\n\nLet's take a deeper look at `Enumerable` and, while we're at it, its lazy counterpart, `Stream`.\n" }, { "path": "lib/elixir/pages/getting-started/sigils.md", "content": "\n\n# Sigils\n\nElixir provides double-quoted strings as well as a concept called charlists, which are defined using the `~c\"hello world\"` sigil syntax. In this chapter, we will learn more about sigils and how to define our own.\n\nOne of Elixir's goals is extensibility: developers should be able to extend the language to fit any particular domain. Sigils provide the foundation for extending the language with custom textual representations. Sigils start with the tilde (`~`) character which is followed by either a single lower-case letter or one or more upper-case letters, and then a delimiter. Optional modifiers are added after the final delimiter.\n\n## Regular expressions\n\nThe most common sigil in Elixir is `~r`, which is used to create [regular expressions](https://en.wikipedia.org/wiki/Regular_Expressions):\n\n```elixir\n# A regular expression that matches strings which contain \"foo\" or \"bar\":\niex> regex = ~r/foo|bar/\n~r/foo|bar/\niex> \"foo\" =~ regex\ntrue\niex> \"bat\" =~ regex\nfalse\n```\n\nElixir provides Perl-compatible regular expressions (regexes), as implemented by the [PCRE](https://www.pcre.org/) library. Regexes also support modifiers. For example, the `i` modifier makes a regular expression case insensitive:\n\n```elixir\niex> \"HELLO\" =~ ~r/hello/\nfalse\niex> \"HELLO\" =~ ~r/hello/i\ntrue\n```\n\nCheck out the `Regex` module for more information on other modifiers and the supported operations with regular expressions.\n\nSo far, all examples have used `/` to delimit a regular expression. However, sigils support 8 different delimiters:\n\n```elixir\n~r/hello/\n~r|hello|\n~r\"hello\"\n~r'hello'\n~r(hello)\n~r[hello]\n~r{hello}\n~r\n```\n\nThe reason behind supporting different delimiters is to provide a way to write literals without escaped delimiters. For example, a regular expression with forward slashes like `~r(^https?://)` reads arguably better than `~r/^https?:\\/\\//`. Similarly, if the regular expression has forward slashes and capturing groups (that use `()`), you may then choose double quotes instead of parentheses.\n\n## Strings, charlists, and word lists sigils\n\nElixir ships with three sigils for building textual data structures. These allow you to choose an appropriate delimiter for your literal text such that you do not have to worry about escaping.\n\n### Strings\n\nThe `~s` sigil is used to generate strings, like double quotes are. The `~s` sigil is useful when a string contains double quotes:\n\n```elixir\niex> ~s(this is a string with \"double\" quotes, not 'single' ones)\n\"this is a string with \\\"double\\\" quotes, not 'single' ones\"\n```\n\n### Charlists\n\nThe `~c` sigil is the regular way to represent charlists.\n\n```elixir\niex> [?c, ?a, ?t]\n~c\"cat\"\niex> ~c(this is a char list containing \"double quotes\")\n~c\"this is a char list containing \\\"double quotes\\\"\"\n```\n\n### Word lists\n\nThe `~w` sigil is used to generate lists of words (*words* are just regular strings). Inside the `~w` sigil, words are separated by whitespace.\n\n```elixir\niex> ~w(foo bar bat)\n[\"foo\", \"bar\", \"bat\"]\n```\n\nThe `~w` sigil also accepts the `c`, `s` and `a` modifiers (for charlists, strings, and atoms, respectively), which specify the data type of the elements of the resulting list:\n\n```elixir\niex> ~w(foo bar bat)a\n[:foo, :bar, :bat]\n```\n\n## Interpolation and escaping in textual sigils\n\nSigils also help deal with escaping characters and interpolation. In particular, uppercase-letter textual sigils do not perform interpolation nor escaping, and most lowercase sigils have an uppercase variant. For example, although both `~s` and `~S` will return strings, the former allows escape codes and interpolation while the latter does not:\n\n```elixir\niex> ~s(String with escape codes \\x26 #{\"inter\" <> \"polation\"})\n\"String with escape codes & interpolation\"\niex> ~S(String without escape codes \\x26 without #{interpolation})\n\"String without escape codes \\\\x26 without \\#{interpolation}\"\n```\n\nThe following escape codes can be used in textual sigils:\n\n * `\\\\` – single backslash\n * `\\a` – bell/alert\n * `\\b` – backspace\n * `\\d` - delete\n * `\\e` - escape\n * `\\f` - form feed\n * `\\n` – newline\n * `\\r` – carriage return\n * `\\s` – space\n * `\\t` – tab\n * `\\v` – vertical tab\n * `\\0` - null byte\n * `\\xDD` - represents a single byte in hexadecimal (such as `\\x13`)\n * `\\uDDDD` and `\\u{D...}` - represents a Unicode codepoint in hexadecimal (such as `\\u{1F600}`)\n\nSigils also support heredocs, that is, three double-quotes or single-quotes as separators:\n\n```elixir\niex> ~s\"\"\"\n...> this is\n...> a heredoc string\n...> \"\"\"\n```\n\nThe most common use case for heredoc sigils is when writing documentation. For example, writing escape characters in the documentation would soon become error prone because of the need to double-escape some characters:\n\n```elixir\n@doc \"\"\"\nConverts double-quotes to single-quotes.\n\n## Examples\n\n iex> convert(\"\\\\\\\"foo\\\\\\\"\")\n \"'foo'\"\n\n\"\"\"\ndef convert(...)\n```\n\nBy using `~S`, this problem can be avoided altogether:\n\n```elixir\n@doc ~S\"\"\"\nConverts double-quotes to single-quotes.\n\n## Examples\n\n iex> convert(\"\\\"foo\\\"\")\n \"'foo'\"\n\n\"\"\"\ndef convert(...)\n```\n\n## Calendar sigils\n\nElixir offers sigils to deal with various flavors of times and dates.\n\n### Date\n\nA [%Date{}](`Date`) struct contains the fields `year`, `month`, `day`, and `calendar`. You can create one using the `~D` sigil:\n\n```elixir\niex> d = ~D[2019-10-31]\n~D[2019-10-31]\niex> d.day\n31\n```\n\n### Time\n\nThe [%Time{}](`Time`) struct contains the fields `hour`, `minute`, `second`, `microsecond`, and `calendar`. You can create one using the `~T` sigil:\n\n```elixir\niex> t = ~T[23:00:07.0]\n~T[23:00:07.0]\niex> t.second\n7\n```\n\n### NaiveDateTime\n\nThe [%NaiveDateTime{}](`NaiveDateTime`) struct contains fields from both `Date` and `Time`. You can create one using the `~N` sigil:\n\n```elixir\niex> ndt = ~N[2019-10-31 23:00:07]\n~N[2019-10-31 23:00:07]\n```\n\nWhy is it called naive? Because it does not contain timezone information. Therefore, the given datetime may not exist at all or it may exist twice in certain timezones - for example, when we move the clock back and forward for daylight saving time.\n\n### UTC DateTime\n\nA [%DateTime{}](`DateTime`) struct contains the same fields as a `NaiveDateTime` with the addition of fields to track timezones. The `~U` sigil allows developers to create a DateTime in the UTC timezone:\n\n```elixir\niex> dt = ~U[2019-10-31 19:59:03Z]\n~U[2019-10-31 19:59:03Z]\niex> %DateTime{minute: minute, time_zone: time_zone} = dt\n~U[2019-10-31 19:59:03Z]\niex> minute\n59\niex> time_zone\n\"Etc/UTC\"\n```\n\n## Custom sigils\n\nAs hinted at the beginning of this chapter, sigils in Elixir are extensible. In fact, using the sigil `~r/foo/i` is equivalent to calling `sigil_r` with a binary and a char list as the argument:\n\n```elixir\niex> sigil_r(<<\"foo\">>, [?i])\n~r\"foo\"i\n```\n\nWe can access the documentation for the `~r` sigil via `sigil_r`:\n\n```elixir\niex> h sigil_r\n...\n```\n\nWe can also provide our own sigils by implementing functions that follow the `sigil_{character}` pattern. For example, let's implement the `~i` sigil that returns an integer (with the optional `n` modifier to make it negative):\n\n```elixir\niex> defmodule MySigils do\n...> def sigil_i(string, []), do: String.to_integer(string)\n...> def sigil_i(string, [?n]), do: -String.to_integer(string)\n...> end\niex> import MySigils\niex> ~i(13)\n13\niex> ~i(42)n\n-42\n```\n\nCustom sigils may be either a single lowercase character, or an uppercase character followed by more uppercase characters and digits. In practice, they are often used to embed templating languages or even represent regular languages within Elixir itself. If you're interested in learning more, check out how sigils are implemented in the `Kernel` module (where the `sigil_*` functions/macros are defined) for a starting point.\n" }, { "path": "lib/elixir/pages/getting-started/structs.md", "content": "\n\n# Structs\n\nWe learned about maps [in earlier chapters](keywords-and-maps.md):\n\n```elixir\niex> map = %{a: 1, b: 2}\n%{a: 1, b: 2}\niex> map[:a]\n1\niex> %{map | a: 3}\n%{a: 3, b: 2}\n```\n\nStructs are extensions built on top of maps that provide compile-time checks and default values.\n\n## Defining structs\n\nTo define a struct, the `defstruct/1` construct is used:\n\n```elixir\niex> defmodule User do\n...> defstruct name: \"John\", age: 27\n...> end\n```\n\nThe keyword list used with `defstruct` defines what fields the struct will have along with their default values. Structs take the name of the module they're defined in. In the example above, we defined a struct named `User`.\n\nWe can now create `User` structs by using a syntax similar to the one used to create maps:\n\n```elixir\niex> %User{}\n%User{age: 27, name: \"John\"}\niex> %User{name: \"Jane\"}\n%User{age: 27, name: \"Jane\"}\n```\n\nStructs provide *compile-time* guarantees that only the fields defined through `defstruct` will be allowed to exist in a struct:\n\n```elixir\niex> %User{oops: :field}\n** (KeyError) key :oops not found expanding struct: User.__struct__/1\n```\n\n## Accessing and updating structs\n\nStructs share the same syntax for accessing and updating fields as maps of fixed keys:\n\n```elixir\niex> john = %User{}\n%User{age: 27, name: \"John\"}\niex> john.name\n\"John\"\niex> jane = %{john | name: \"Jane\"}\n%User{age: 27, name: \"Jane\"}\niex> %{jane | oops: :field}\n** (KeyError) key :oops not found in: %User{age: 27, name: \"Jane\"}\n```\n\nWhen using the update syntax (`|`), Elixir is aware that no new keys will be added to the struct, allowing the maps underneath to share their structure in memory. In the example above, both `john` and `jane` share the same key structure in memory.\n\nStructs can also be used in pattern matching, both for matching on the value of specific keys as well as for ensuring that the matching value is a struct of the same type as the matched value.\n\n```elixir\niex> %User{name: name} = john\n%User{age: 27, name: \"John\"}\niex> name\n\"John\"\niex> %User{} = %{}\n** (MatchError) no match of right hand side value: %{}\n```\n\nFor more details on creating, updating, and pattern matching structs, see the documentation for `%/2`.\n\n## Dynamic struct updates\n\nWhen you need to update structs with data from keyword lists or maps, use `Kernel.struct!/2`:\n\n```elixir\niex> john = %User{name: \"John\", age: 27}\n%User{age: 27, name: \"John\"}\niex> updates = [name: \"Jane\", age: 30]\n[name: \"Jane\", age: 30]\niex> struct!(john, updates)\n%User{age: 30, name: \"Jane\"}\n```\n\n`struct!/2` will raise an error if you try to set invalid fields:\n\n```elixir\niex> struct!(john, invalid: \"field\")\n** (KeyError) key :invalid not found in: %User{age: 27, name: \"John\"}\n```\n\nUse the map update syntax (`%{john | name: \"Jane\"}`) when you know the exact fields at compile time. Always use `struct!/2` instead of `Map` functions to preserve struct integrity.\n\n## Structs are bare maps underneath\n\nStructs are simply maps with a \"special\" field named `__struct__` that holds the name of the struct:\n\n```elixir\niex> is_map(john)\ntrue\niex> john.__struct__\nUser\n```\n\nHowever, structs do not inherit any of the protocols that maps do. For example, you can neither enumerate nor access a struct:\n\n```elixir\niex> john = %User{}\n%User{age: 27, name: \"John\"}\niex> john[:name]\n** (UndefinedFunctionError) function User.fetch/2 is undefined (User does not implement the Access behaviour)\n User.fetch(%User{age: 27, name: \"John\"}, :name)\niex> Enum.each(john, fn {field, value} -> IO.puts(value) end)\n** (Protocol.UndefinedError) protocol Enumerable not implemented for %User{age: 27, name: \"John\"} of type User (a struct)\n```\n\nStructs alongside protocols provide one of the most important features for Elixir developers: data polymorphism. That's what we will explore in the next chapter.\n\n## Default values and required keys\n\nIf you don't specify a default key value when defining a struct, `nil` will be assumed:\n\n```elixir\niex> defmodule Product do\n...> defstruct [:name]\n...> end\niex> %Product{}\n%Product{name: nil}\n```\n\nYou can define a structure combining both fields with explicit default values, and implicit `nil` values. In this case you must first specify the fields which implicitly default to `nil`:\n\n```elixir\niex> defmodule User do\n...> defstruct [:email, name: \"John\", age: 27]\n...> end\niex> %User{}\n%User{age: 27, email: nil, name: \"John\"}\n```\n\nDoing it in reverse order will raise a syntax error:\n\n```elixir\niex> defmodule User do\n...> defstruct [name: \"John\", age: 27, :email]\n...> end\n** (SyntaxError) iex:107: unexpected expression after keyword list. Keyword lists must always come last in lists and maps.\n```\n\nYou can also enforce that certain keys have to be specified when creating the struct via the `@enforce_keys` module attribute:\n\n```elixir\niex> defmodule Car do\n...> @enforce_keys [:make]\n...> defstruct [:model, :make]\n...> end\niex> %Car{}\n** (ArgumentError) the following keys must also be given when building struct Car: [:make]\n expanding struct: Car.__struct__/1\n```\n\nEnforcing keys provides a simple compile-time guarantee to aid developers when building structs. It is not enforced on updates and it does not provide any sort of value-validation.\n" }, { "path": "lib/elixir/pages/getting-started/try-catch-and-rescue.md", "content": "\n\n# try, catch, and rescue\n\nElixir has three error mechanisms: errors, throws, and exits. In this chapter, we will explore each of them and include remarks about when each should be used.\n\n## Errors\n\nErrors (or *exceptions*) are used when exceptional things happen in the code. A sample error can be retrieved by trying to add a number to an atom:\n\n```elixir\niex> :foo + 1\n** (ArithmeticError) bad argument in arithmetic expression\n :erlang.+(:foo, 1)\n```\n\nA runtime error can be raised any time by using `raise/1`:\n\n```elixir\niex> raise \"oops\"\n** (RuntimeError) oops\n```\n\nOther errors can be raised with `raise/2` passing the error name and a list of keyword arguments:\n\n```elixir\niex> raise ArgumentError, message: \"invalid argument foo\"\n** (ArgumentError) invalid argument foo\n```\n\nYou can also define your own errors by creating a module and using the `defexception/1` construct inside it. This way, you'll create an error with the same name as the module it's defined in. The most common case is to define a custom exception with a message field:\n\n```elixir\niex> defmodule MyError do\niex> defexception message: \"default message\"\niex> end\niex> raise MyError\n** (MyError) default message\niex> raise MyError, message: \"custom message\"\n** (MyError) custom message\n```\n\nErrors can be **rescued** using the `try/rescue` construct:\n\n```elixir\niex> try do\n...> raise \"oops\"\n...> rescue\n...> e in RuntimeError -> e\n...> end\n%RuntimeError{message: \"oops\"}\n```\n\nThe example above rescues the runtime error and returns the exception itself, which is then printed in the `iex` session.\n\nIf you don't have any use for the exception, you don't have to pass a variable to `rescue`:\n\n```elixir\niex> try do\n...> raise \"oops\"\n...> rescue\n...> RuntimeError -> \"Error!\"\n...> end\n\"Error!\"\n```\n\nIn practice, Elixir developers rarely use the `try/rescue` construct. For example, many languages would force you to rescue an error when a file cannot be opened successfully. Elixir instead provides a `File.read/1` function which returns a tuple containing information about whether the file was opened successfully:\n\n```elixir\niex> File.read(\"hello\")\n{:error, :enoent}\niex> File.write(\"hello\", \"world\")\n:ok\niex> File.read(\"hello\")\n{:ok, \"world\"}\n```\n\nThere is no `try/rescue` here. In case you want to handle multiple outcomes of opening a file, you can use pattern matching using the `case` construct:\n\n```elixir\niex> case File.read(\"hello\") do\n...> {:ok, body} -> IO.puts(\"Success: #{body}\")\n...> {:error, reason} -> IO.puts(\"Error: #{reason}\")\n...> end\n```\n\nFor the cases where you do expect a file to exist (and the lack of that file is truly an *error*) you may use `File.read!/1`:\n\n```elixir\niex> File.read!(\"unknown\")\n** (File.Error) could not read file \"unknown\": no such file or directory\n (elixir) lib/file.ex:272: File.read!/1\n```\n\nAt the end of the day, it's up to your application to decide if an error while opening a file is exceptional or not. That's why Elixir doesn't impose exceptions on `File.read/1` and many other functions. Instead, it leaves it up to the developer to choose the best way to proceed.\n\nMany functions in the standard library follow the pattern of having a counterpart that raises an exception instead of returning tuples to match against. The convention is to create a function (`foo`) which returns `{:ok, result}` or `{:error, reason}` tuples and another function (`foo!`, same name but with a trailing `!`) that takes the same arguments as `foo` but which raises an exception if there's an error. `foo!` should return the result (not wrapped in a tuple) if everything goes fine. The `File` module is a good example of this convention.\n\n### Fail fast / Let it crash\n\nOne saying that is common in the Erlang community, as well as Elixir's, is \"fail fast\" / \"let it crash\". The idea behind let it crash is that, in case something *unexpected* happens, it is best to let the exception happen, without rescuing it.\n\nIt is important to emphasize the word *unexpected*. For example, imagine you are building a script to process files. Your script receives filenames as inputs. It is expected that users may make mistakes and provide unknown filenames. In this scenario, while you could use `File.read!/1` to read files and let it crash in case of invalid filenames, it probably makes more sense to use `File.read/1` and provide users of your script with a clear and precise feedback of what went wrong.\n\nOther times, you may fully expect a certain file to exist, and in case it does not, it means something terribly wrong has happened elsewhere. In such cases, `File.read!/1` is all you need.\n\nThe second approach also works because, as discussed in the [Processes](processes.md) chapter, all Elixir code runs inside processes that are isolated and don't share anything by default. Therefore, an unhandled exception in a process will never crash or corrupt the state of another process. This allows us to define supervisor processes, which are meant to observe when a process terminates unexpectedly, and start a new one in its place.\n\nAt the end of the day, \"fail fast\" / \"let it crash\" is a way of saying that, when *something unexpected* happens, it is best to start from scratch within a new process, freshly started by a supervisor, rather than blindly trying to rescue all possible error cases without the full context of when and how they can happen.\n\n### Reraise\n\nWhile we generally avoid using `try/rescue` in Elixir, one situation where we may want to use such constructs is for observability/monitoring. Imagine you want to log that something went wrong, you could do:\n\n```elixir\ntry do\n ... some code ...\nrescue\n e ->\n Logger.error(Exception.format(:error, e, __STACKTRACE__))\n reraise e, __STACKTRACE__\nend\n```\n\nIn the example above, we rescued the exception, logged it, and then re-raised it. We use the `__STACKTRACE__` construct both when formatting the exception and when re-raising. This ensures we reraise the exception as is, without changing value or its origin.\n\nGenerally speaking, we take errors in Elixir literally: they are reserved for unexpected and/or exceptional situations, never for controlling the flow of our code. In case you actually need flow control constructs, *throws* should be used. That's what we are going to see next.\n\n## Throws\n\nIn Elixir, a value can be thrown and later be caught. `throw` and `catch` are reserved for situations where it is not possible to retrieve a value unless by using `throw` and `catch`.\n\nThose situations are quite uncommon in practice except when interfacing with libraries that do not provide a proper API. For example, let's imagine the `Enum` module did not provide any API for finding a value and that we needed to find the first multiple of 13 in a list of numbers:\n\n```elixir\niex> try do\n...> Enum.each(-50..50, fn x ->\n...> if rem(x, 13) == 0, do: throw(x)\n...> end)\n...> \"Got nothing\"\n...> catch\n...> x -> \"Got #{x}\"\n...> end\n\"Got -39\"\n```\n\nSince `Enum` *does* provide a proper API, in practice `Enum.find/2` is the way to go:\n\n```elixir\niex> Enum.find(-50..50, &(rem(&1, 13) == 0))\n-39\n```\n\n## Exits\n\nAll Elixir code runs inside processes that communicate with each other. When a process dies of \"natural causes\" (e.g., unhandled exceptions), it sends an `exit` signal. A process can also die by explicitly sending an `exit` signal:\n\n```elixir\niex> spawn_link(fn -> exit(1) end)\n** (EXIT from #PID<0.56.0>) shell process exited with reason: 1\n```\n\nIn the example above, the linked process died by sending an `exit` signal with a value of 1. The Elixir shell automatically handles those messages and prints them to the terminal.\n\n`exit` can also be \"caught\" using `try/catch`:\n\n```elixir\niex> try do\n...> exit(\"I am exiting\")\n...> catch\n...> :exit, _ -> \"not really\"\n...> end\n\"not really\"\n```\n\n`catch` can also be used within a function body without a matching `try`.\n\n```elixir\ndefmodule Example do\n def matched_catch do\n exit(:timeout)\n catch\n :exit, :timeout ->\n {:error, :timeout}\n end\n\n def mismatched_catch do\n exit(:timeout)\n catch\n # Since no clause matches, this catch will have no effect\n :exit, :explosion ->\n {:error, :explosion}\n end\nend\n```\n\nHowever, using `try/catch` is already uncommon and using it to catch exits is even rarer.\n\n`exit` signals are an important part of the fault tolerant system provided by the Erlang VM. Processes usually run under supervision trees which are themselves processes that listen to `exit` signals from the supervised processes. Once an `exit` signal is received, the supervision strategy kicks in and the supervised process is restarted.\n\nIt is exactly this supervision system that makes constructs like `try/catch` and `try/rescue` so uncommon in Elixir. Instead of rescuing an error, we'd rather \"fail fast\" since the supervision tree will guarantee our application will go back to a known initial state after the error.\n\n## After\n\nSometimes it's necessary to ensure that a resource is cleaned up after some action that could potentially raise an error. The `try/after` construct allows you to do that. For example, we can open a file and use an `after` clause to close it—even if something goes wrong:\n\n```elixir\niex> {:ok, file} = File.open(\"sample\", [:utf8, :write])\niex> try do\n...> IO.write(file, \"olá\")\n...> raise \"oops, something went wrong\"\n...> after\n...> File.close(file)\n...> end\n** (RuntimeError) oops, something went wrong\n```\n\nThe `after` clause will be executed regardless of whether or not the tried block succeeds. Note, however, that if a linked process exits,\nthis process will exit and the `after` clause will not get run. Thus `after` provides only a soft guarantee. Luckily, files in Elixir are also linked to the current processes and therefore they will always get closed if the current process crashes, independent of the\n`after` clause. You will find the same to be true for other resources like ETS tables, sockets, ports and more.\n\nSometimes you may want to wrap the entire body of a function in a `try` construct, often to guarantee some code will be executed afterwards. In such cases, Elixir allows you to omit the `try` line:\n\n```elixir\niex> defmodule RunAfter do\n...> def without_even_trying do\n...> raise \"oops\"\n...> after\n...> IO.puts(\"cleaning up!\")\n...> end\n...> end\niex> RunAfter.without_even_trying\ncleaning up!\n** (RuntimeError) oops\n```\n\nElixir will automatically wrap the function body in a `try` whenever one of `after`, `rescue` or `catch` is specified. The `after` block handles side effects and does not change the return value from the clauses above it.\n\n## Else\n\nIf an `else` block is present, it will match on the results of the `try` block whenever the `try` block finishes without a throw or an error.\n\n```elixir\niex> x = 2\n2\niex> try do\n...> 1 / x\n...> rescue\n...> ArithmeticError ->\n...> :infinity\n...> else\n...> y when y < 1 and y > -1 ->\n...> :small\n...> _ ->\n...> :large\n...> end\n:small\n```\n\nExceptions in the `else` block are not caught. If no pattern inside the `else` block matches, an exception will be raised; this exception is not caught by the current `try/catch/rescue/after` block.\n\n## Variables scope\n\nSimilar to `case`, `cond`, `if` and other constructs in Elixir, variables defined inside `try/catch/rescue/after` blocks do not leak to the outer context. In other words, this code is invalid:\n\n```elixir\niex> try do\n...> raise \"fail\"\n...> what_happened = :did_not_raise\n...> rescue\n...> _ -> what_happened = :rescued\n...> end\niex> what_happened\n** (CompileError) undefined variable \"what_happened\"\n```\n\nInstead, you should return the value of the `try` expression:\n\n```elixir\niex> what_happened =\n...> try do\n...> raise \"fail\"\n...> :did_not_raise\n...> rescue\n...> _ -> :rescued\n...> end\niex> what_happened\n:rescued\n```\n\nFurthermore, variables defined in the do-block of `try` are not available inside `rescue/after/else` either. This is because the `try` block may fail at any moment and therefore the variables may have never been bound in the first place. So this also isn't valid:\n\n```elixir\niex> try do\n...> raise \"fail\"\n...> another_what_happened = :did_not_raise\n...> rescue\n...> _ -> another_what_happened\n...> end\n** (CompileError) undefined variable \"another_what_happened\"\n```\n\nThis finishes our introduction on `try`, `catch`, and `rescue`. You will find they are used less frequently in Elixir than in other languages. Next we will talk about a very important subject to Elixir developers: writing documentation.\n" }, { "path": "lib/elixir/pages/getting-started/writing-documentation.md", "content": "\n\n# Writing documentation\n\nElixir treats documentation as a first-class citizen. Documentation must be easy to write and easy to read. In this guide you will learn how to write documentation in Elixir, covering constructs like module attributes, style practices, and doctests.\n\n## Markdown\n\nElixir documentation is written using Markdown. There are plenty of guides on Markdown online, we recommend the one from GitHub as a getting started point:\n\n * [Basic writing and formatting syntax](https://help.github.com/articles/basic-writing-and-formatting-syntax/)\n\n## Module Attributes\n\nDocumentation in Elixir is usually attached to module attributes. Let's see an example:\n\n```elixir\ndefmodule MyApp.Hello do\n @moduledoc \"\"\"\n This is the Hello module.\n \"\"\"\n @moduledoc since: \"1.0.0\"\n\n @doc \"\"\"\n Says hello to the given `name`.\n\n Returns `:ok`.\n\n ## Examples\n\n iex> MyApp.Hello.world(:john)\n :ok\n\n \"\"\"\n @doc since: \"1.3.0\"\n def world(name) do\n IO.puts(\"hello #{name}\")\n end\nend\n```\n\nThe `@moduledoc` attribute is used to add documentation to the module. `@doc` is used before a function to provide documentation for it. Besides the attributes above, `@typedoc` can also be used to attach documentation to types defined as part of typespecs.\n\n## Function arguments\n\nWhen documenting a function, argument names are inferred by the compiler. For example:\n\n```elixir\ndef size(%{size: size}) do\n size\nend\n```\n\nThe compiler will infer this argument as `map`. Sometimes the inference will be suboptimal, especially if the function contains multiple clauses with the argument matching on different values each time. You can specify the proper names for documentation by declaring only the function head at any moment before the implementation:\n\n```elixir\ndef size(map_with_size)\n\ndef size(%{size: size}) do\n size\nend\n```\n\n## Documentation metadata\n\nElixir allows developers to attach arbitrary metadata to the documentation. This is done by passing a keyword list to the relevant attribute (such as `@moduledoc`, `@typedoc`, and `@doc`).\n\nMetadata can have any key. Documentation tools often use metadata to provide more data to readers and to enrich the user experience. The following keys already have a predefined meaning used by tooling:\n\n### `:deprecated`\n\nAnother common metadata is `:deprecated`, which emits a warning in the documentation, explaining that its usage is discouraged:\n\n```elixir\n@doc deprecated: \"Use Foo.bar/2 instead\"\n```\n\nNote that the `:deprecated` key does not warn when a developer invokes the functions. If you want the code to also emit a warning, you can use the `@deprecated` attribute:\n\n```elixir\n@deprecated \"Use Foo.bar/2 instead\"\n```\n\n### `:group`\n\nThe group a function, callback or type belongs to. This is used in `iex` for autocompleting and also to automatically by [ExDoc](https://github.com/elixir-lang/ex_doc/) to group items in the sidebar:\n\n```elixir\n@doc group: \"Query\"\ndef all(query)\n\n@doc group: \"Schema\"\ndef insert(schema)\n```\n\n### `:since`\n\nIt annotates in which version that particular module, function, type, or callback was added:\n\n```elixir\n@doc since: \"1.3.0\"\ndef world(name) do\n IO.puts(\"hello #{name}\")\nend\n```\n\n## Recommendations\n\nWhen writing documentation:\n\n * Keep the first paragraph of the documentation concise and simple, typically one-line. Tools like [ExDoc](https://github.com/elixir-lang/ex_doc/) use the first line to generate a summary.\n\n * Reference modules by their full name. Markdown uses backticks (`` ` ``) to quote code. Elixir builds on top of that to automatically generate links when module or function names are referenced. For this reason, always use full module names. If you have a module called `MyApp.Hello`, always reference it as `` `MyApp.Hello` `` and never as `` `Hello` ``.\n\n * Reference functions by name and arity if they are local, as in `` `world/1` ``, or by module, name and arity if pointing to an external module: `` `MyApp.Hello.world/1` ``.\n\n * Reference a `@callback` by prepending `c:`, as in `` `c:world/1` ``.\n\n * Reference a `@type` by prepending `t:`, as in `` `t:values/0` ``.\n\n * Start new sections with second level Markdown headers `##`. First level headers are reserved for module and function names.\n\n * Place documentation before the first clause of multi-clause functions. Documentation is always per function and arity and not per clause.\n\n * Use the `:since` key in the documentation metadata to annotate whenever new functions or modules are added to your API.\n\n## Doctests\n\nWe advise developers to include examples in their documentation, often under their own `## Examples` heading. To ensure examples do not get out of date, Elixir's test framework (ExUnit) provides a feature called doctests that allows developers to test the examples in their documentation. Doctests work by parsing out code samples starting with `iex>` from the documentation. You can read more about them at `ExUnit.DocTest`.\n\n## Documentation != Code comments\n\nElixir treats documentation and code comments as different concepts. Documentation is an explicit contract between you and users of your Application Programming Interface (API), be they third-party developers, co-workers, or your future self. Modules and functions must always be documented if they are part of your API.\n\nCode comments are aimed at developers reading the code. They are useful for marking improvements, leaving notes (for example, why you had to resort to a workaround due to a bug in a library), and so forth. They are tied to the source code: you can completely rewrite a function and remove all existing code comments, and it will continue to behave the same, with no change to either its behavior or its documentation.\n\nBecause private functions cannot be accessed externally, Elixir will warn if a private function has a `@doc` attribute and will discard its content. However, you can add code comments to private functions, as with any other piece of code, and we recommend developers to do so whenever they believe it will add relevant information to the readers and maintainers of such code.\n\nIn summary, documentation is a contract with users of your API, who may not necessarily have access to the source code, whereas code comments are for those who interact directly with the source. You can learn and express different guarantees about your software by separating those two concepts.\n\n## Hiding internal modules and functions\n\nBesides the modules and functions libraries provide as part of their public interface, libraries may also implement important functionality that is not part of their API. While these modules and functions can be accessed, they are meant to be internal to the library and thus should not have documentation for end users.\n\nConveniently, Elixir allows developers to hide modules and functions from the documentation, by setting `@doc false` to hide a particular function, or `@moduledoc false` to hide the whole module. If a module is hidden, you may even document the functions in the module, but the module itself won't be listed in the documentation:\n\n```elixir\ndefmodule MyApp.Hidden do\n @moduledoc false\n\n @doc \"\"\"\n This function won't be listed in docs.\n \"\"\"\n def function_that_wont_be_listed_in_docs do\n # ...\n end\nend\n```\n\nIn case you don't want to hide a whole module, you can hide functions individually:\n\n```elixir\ndefmodule MyApp.Sample do\n @doc false\n def add(a, b), do: a + b\nend\n```\n\nHowever, keep in mind `@moduledoc false` or `@doc false` do not make a function private. The function above can still be invoked as `MyApp.Sample.add(1, 2)`. Not only that, if `MyApp.Sample` is imported, the `add/2` function will also be imported into the caller. For those reasons, be cautious when adding `@doc false` to functions, instead use one of these two options:\n\n * Move the undocumented function to a module with `@moduledoc false`, like `MyApp.Hidden`, ensuring the function won't be accidentally exposed or imported. Remember that you can use `@moduledoc false` to hide a whole module and still document each function with `@doc`. Tools will still ignore the module.\n\n * Start the function name with one or two underscores, for example, `__add__/2`. Functions starting with underscore are automatically treated as hidden, although you can also be explicit and add `@doc false`. The compiler does not import functions with leading underscores and they hint to anyone reading the code of their intended private usage.\n\n## `Code.fetch_docs/1`\n\nElixir stores documentation inside pre-defined chunks in the bytecode. Documentation is not loaded into memory when modules are loaded, instead, it can be read from the bytecode in disk using the `Code.fetch_docs/1` function. The downside is that modules defined in-memory, like the ones defined in IEx, cannot have their documentation accessed as they do not write their bytecode to disk.\n" }, { "path": "lib/elixir/pages/meta-programming/domain-specific-languages.md", "content": "\n\n# Domain-Specific Languages (DSLs)\n\n[Domain-specific Languages (DSLs)](https://en.wikipedia.org/wiki/Domain-specific_language) are languages tailored to a specific application domain. You don't need macros in order to have a DSL: every data structure and every function you define in your module is part of your domain-specific language.\n\nFor example, imagine we want to implement a `Validator` module which provides a data validation domain-specific language. We could implement it using data structures, functions, or macros. Let's see what those different DSLs would look like:\n\n```elixir\n# 1. Data structures\nimport Validator\nvalidate user, name: [length: 1..100], email: [matches: ~r/@/]\n\n# 2. Functions\nimport Validator\nuser\n|> validate_length(:name, 1..100)\n|> validate_matches(:email, ~r/@/)\n\n# 3. Macros + modules\ndefmodule MyValidator do\n use Validator\n validate_length :name, 1..100\n validate_matches :email, ~r/@/\nend\n\nMyValidator.validate(user)\n```\n\nOf all the approaches above, the first is definitely the most flexible. If our domain rules can be encoded with data structures, they are by far the easiest to compose and implement, as Elixir's standard library is filled with functions for manipulating different data types.\n\nThe second approach uses function calls which better suits more complex APIs (for example, if you need to pass many options) and reads nicely in Elixir thanks to the pipe operator.\n\nThe third approach uses macros, and is by far the most complex. It will take more lines of code to implement, it is hard and expensive to test (compared to testing simple functions), and it limits how the user may use the library since all validations need to be defined inside a module.\n\nTo drive the point home, imagine you want to validate a certain attribute only if a given condition is met. We could easily achieve it with the first solution, by manipulating the data structure accordingly, or with the second solution by using conditionals (if/else) before invoking the function. However, it is impossible to do so with the macros approach unless its DSL is augmented.\n\nIn other words:\n\n```text\ndata > functions > macros\n```\n\nThat said, there are still cases where using macros and modules to build domain-specific languages is useful. Since we have explored data structures and function definitions in the Getting Started guide, this chapter will explore how to use macros and module attributes to tackle more complex DSLs.\n\n## Building our own test case\n\nThe goal in this chapter is to build a module named `TestCase` that allows us to write the following:\n\n```elixir\ndefmodule MyTest do\n use TestCase\n\n test \"arithmetic operations\" do\n 4 = 2 + 2\n end\n\n test \"list operations\" do\n [1, 2, 3] = [1, 2] ++ [3]\n end\nend\n\nMyTest.run()\n```\n\nIn the example above, by using `TestCase`, we can write tests using the `test` macro, which defines a function named `run` to automatically run all tests for us. Our prototype will rely on the match operator (`=`) as a mechanism to do assertions.\n\n## The `test` macro\n\nLet's start by creating a module that defines and imports the `test` macro when used:\n\n```elixir\ndefmodule TestCase do\n # Callback invoked by `use`.\n #\n # For now it returns a quoted expression that\n # imports the module itself into the user code.\n @doc false\n defmacro __using__(_opts) do\n quote do\n import TestCase\n end\n end\n\n @doc \"\"\"\n Defines a test case with the given description.\n\n ## Examples\n\n test \"arithmetic operations\" do\n 4 = 2 + 2\n end\n\n \"\"\"\n defmacro test(description, do: block) do\n function_name = String.to_atom(\"test \" <> description)\n quote do\n def unquote(function_name)(), do: unquote(block)\n end\n end\nend\n```\n\nAssuming we defined `TestCase` in a file named `tests.exs`, we can open it up by running `iex tests.exs` and define our first tests:\n\n```elixir\niex> defmodule MyTest do\n...> use TestCase\n...>\n...> test \"hello\" do\n...> \"hello\" = \"world\"\n...> end\n...> end\n```\n\nFor now, we don't have a mechanism to run tests, but we know that a function named `test hello` was defined behind the scenes. When we invoke it, it should fail:\n\n```elixir\niex> MyTest.\"test hello\"()\n** (MatchError) no match of right hand side value: \"world\"\n```\n\n## Storing information with attributes\n\nIn order to finish our `TestCase` implementation, we need to be able to access all defined test cases. One way of doing this is by retrieving the tests at runtime via `__MODULE__.__info__(:functions)`, which returns a list of all functions in a given module. However, considering that we may want to store more information about each test besides the test name, a more flexible approach is required.\n\nWhen discussing module attributes in earlier chapters, we mentioned how they can be used as temporary storage. That's exactly the property we will apply in this section.\n\nIn the `__using__/1` implementation, we will initialize a module attribute named `@tests` to an empty list, then store the name of each defined test in this attribute so the tests can be invoked from the `run` function.\n\nHere is the updated code for the `TestCase` module:\n\n```elixir\ndefmodule TestCase do\n @doc false\n defmacro __using__(_opts) do\n quote do\n import TestCase\n\n # Initialize @tests to an empty list\n @tests []\n\n # Invoke TestCase.__before_compile__/1 before the module is compiled\n @before_compile TestCase\n end\n end\n\n @doc \"\"\"\n Defines a test case with the given description.\n\n ## Examples\n\n test \"arithmetic operations\" do\n 4 = 2 + 2\n end\n\n \"\"\"\n defmacro test(description, do: block) do\n function_name = String.to_atom(\"test \" <> description)\n quote do\n # Prepend the newly defined test to the list of tests\n @tests [unquote(function_name) | @tests]\n def unquote(function_name)(), do: unquote(block)\n end\n end\n\n # This will be invoked right before the target module is compiled\n # giving us the perfect opportunity to inject the `run/0` function\n @doc false\n defmacro __before_compile__(_env) do\n quote do\n def run do\n Enum.each(@tests, fn name ->\n IO.puts(\"Running #{name}\")\n apply(__MODULE__, name, [])\n end)\n end\n end\n end\nend\n```\n\nBy starting a new IEx session, we can now define our tests and run them:\n\n```elixir\niex> defmodule MyTest do\n...> use TestCase\n...>\n...> test \"hello\" do\n...> \"hello\" = \"world\"\n...> end\n...> end\niex> MyTest.run()\nRunning test hello\n** (MatchError) no match of right hand side value: \"world\"\n```\n\nAlthough we have overlooked some details, this is the main idea behind creating domain-specific languages in Elixir via modules and macros. Macros enable us to return quoted expressions that are executed in the caller, which we can then use to transform code and store relevant information in the target module via module attributes. Finally, callbacks such as `@before_compile` allow us to inject code into the module when its definition is complete.\n\nBesides `@before_compile`, there are other useful module attributes like `@on_definition` and `@after_compile`, which you can read more about in the docs for `Module`. You can also find useful information about macros and the compilation environment in the documentation for the `Macro` and `Macro.Env`.\n" }, { "path": "lib/elixir/pages/meta-programming/macros.md", "content": "\n\n# Macros\n\nEven though Elixir attempts its best to provide a safe environment for macros, most of the responsibility of writing clean code with macros falls on developers. Macros are harder to write than ordinary Elixir functions, and it's considered to be bad style to use them when they're not necessary. Write macros responsibly.\n\nElixir already provides mechanisms to write your everyday code in a simple and readable fashion by using its data structures and functions. Macros should only be used as a last resort. Remember that **explicit is better than implicit**. **Clear code is better than concise code.**\n\n## Our first macro\n\nMacros in Elixir are defined via `defmacro/2`.\n\n> For this guide, we will be using files instead of running code samples in IEx. That's because the code samples will span multiple lines of code and typing them all in IEx can be counter-productive. You should be able to run the code samples by saving them into a `macros.exs` file and running it with `elixir macros.exs` or `iex macros.exs`.\n\nIn order to better understand how macros work, let's create a new module where we are going to implement `unless` (which does the opposite of `if/2`), as a macro and as a function:\n\n```elixir\ndefmodule Unless do\n def fun_unless(clause, do: expression) do\n if(!clause, do: expression)\n end\n\n defmacro macro_unless(clause, do: expression) do\n quote do\n if(!unquote(clause), do: unquote(expression))\n end\n end\nend\n```\n\nThe function receives the arguments and passes them to `if/2`. However, as we learned in the [previous guide](quote-and-unquote.md), the macro will receive quoted expressions, inject them into the quote, and finally return another quoted expression.\n\nLet's start `iex` with the module above:\n\n```console\n$ iex macros.exs\n```\n\nand play with those definitions:\n\n```elixir\niex> require Unless\niex> Unless.macro_unless(true, do: IO.puts(\"this should never be printed\"))\nnil\niex> Unless.fun_unless(true, do: IO.puts(\"this should never be printed\"))\n\"this should never be printed\"\nnil\n```\n\nIn our *macro* implementation, the sentence was not printed, although it was printed in our *function* implementation. That's because the arguments to a function call are evaluated before calling the function. However, macros do not evaluate their arguments. Instead, they receive the arguments as quoted expressions which are then transformed into other quoted expressions. In this case, we have rewritten our `unless` macro to become an `if/2` behind the scenes.\n\nIn other words, when invoked as:\n\n```elixir\nUnless.macro_unless(true, do: IO.puts(\"this should never be printed\"))\n```\n\nOur `macro_unless` macro received the following:\n\n```elixir\nmacro_unless(true, [do: {{:., [], [{:__aliases__, [], [:IO]}, :puts]}, [], [\"this should never be printed\"]}])\n```\n\nand it then returned a quoted expression as follows:\n\n```elixir\n{:if, [],\n [{:!, [], [true]},\n [do: {{:., [],\n [{:__aliases__,\n [], [:IO]},\n :puts]}, [], [\"this should never be printed\"]}]]}\n```\n\nWe can actually verify that this is the case by using `Macro.expand_once/2`:\n\n```elixir\niex> expr = quote do: Unless.macro_unless(true, do: IO.puts(\"this should never be printed\"))\niex> res = Macro.expand_once(expr, __ENV__)\niex> IO.puts(Macro.to_string(res))\nif(!true) do\n IO.puts(\"this should never be printed\")\nend\n:ok\n```\n\n`Macro.expand_once/2` receives a quoted expression and expands it according to the current environment. In this case, it expanded/invoked the `Unless.macro_unless/2` macro and returned its result. We then proceeded to convert the returned quoted expression to a string and print it (we will talk about `__ENV__` later in this chapter).\n\nThat's what macros are all about. They are about receiving quoted expressions and transforming them into something else.\nIn fact, `if/2` in Elixir is implemented as a macro:\n\n```elixir\ndefmacro if(clause, do: expression) do\n quote do\n case unquote(clause) do\n x when x in [false, nil] -> nil\n _ -> unquote(expression)\n end\nend\n```\n\nConstructs such as `if/2`, `defmacro/2`, `def/2`, `defprotocol/2`, and many others used throughout the Elixir standard library are written in pure Elixir, often as a macro. This means that the constructs being used to build the language can be used by developers to extend the language to the domains they are working on.\n\nWe can define any function and macro we want, including ones that override the built-in definitions provided by Elixir. The only exceptions are Elixir special forms which are not implemented in Elixir and therefore cannot be overridden. The full list of special forms is available in `Kernel.SpecialForms`.\n\n## Macro hygiene\n\nElixir macros have \"late resolution\". This guarantees that a variable defined inside a quote won't conflict with a variable defined in the context where that macro is expanded. For example:\n\n```elixir\ndefmodule Hygiene do\n defmacro no_interference do\n quote do: a = 1\n end\nend\n\ndefmodule HygieneTest do\n def go do\n require Hygiene\n a = 13\n Hygiene.no_interference()\n a\n end\nend\n\nHygieneTest.go()\n# => 13\n```\n\nIn the example above, even though the macro injects `a = 1`, it does not affect the variable `a` defined by the `go/0` function. If a macro wants to explicitly affect the context, it can use `var!/1`:\n\n```elixir\ndefmodule Hygiene do\n defmacro interference do\n quote do: var!(a) = 1\n end\nend\n\ndefmodule HygieneTest do\n def go do\n require Hygiene\n a = 13\n Hygiene.interference()\n a\n end\nend\n\nHygieneTest.go()\n# => 1\n```\n\nThe code above will work but issue a warning: `variable \"a\" is unused`. The macro is overriding the original value and the original value is never used.\n\nVariable hygiene only works because Elixir annotates variables with their **context**. For example, a variable `x` defined on line 3 of a module would be represented as:\n\n```elixir\n{:x, [line: 3], nil}\n```\n\nHowever, a quoted variable would be represented as:\n\n```elixir\ndefmodule Sample do\n def quoted do\n quote do: x\n end\nend\n\nSample.quoted() #=> {:x, [line: 3], Sample}\n```\n\nNotice that the *third element* in the quoted variable is the atom `Sample`, instead of `nil`, which marks the variable as coming from the `Sample` module. Therefore, Elixir considers these two variables as coming from different contexts and handles them accordingly.\n\nElixir provides similar mechanisms for imports and aliases too. This guarantees that a macro will behave as specified by its source module rather than conflicting with the target module where the macro is expanded. Hygiene can be bypassed under specific situations by using macros like `var!/2` and `alias!/1`, although one must be careful when using those as they directly change the user environment.\n\nSometimes variable names might be dynamically created. In such cases, `Macro.var/2` can be used to define new variables:\n\n```elixir\ndefmodule Sample do\n defmacro initialize_to_char_count(variables) do\n Enum.map(variables, fn name ->\n var = Macro.var(name, nil)\n length = name |> Atom.to_string() |> String.length()\n\n quote do\n unquote(var) = unquote(length)\n end\n end)\n end\n\n def run do\n initialize_to_char_count([:red, :green, :yellow])\n [red, green, yellow]\n end\nend\n\n> Sample.run() #=> [3, 5, 6]\n```\n\nTake note of the second argument to `Macro.var/2`. This is the **context** being used and will determine hygiene as described in the next section. Check out also `Macro.unique_var/2`, for cases when you need to generate variables with unique names.\n\n## The environment\n\nWhen calling `Macro.expand_once/2` earlier in this chapter, we used the special form `__ENV__/0`.\n\n`__ENV__/0` returns a `Macro.Env` struct which contains useful information about the compilation environment, including the current module, file, and line, all variables defined in the current scope, as well as imports, requires, and more:\n\n```elixir\niex> __ENV__.module\nnil\niex> __ENV__.file\n\"iex\"\niex> __ENV__.requires\n[IEx.Helpers, Kernel, Kernel.Typespec]\niex> require Integer\nnil\niex> __ENV__.requires\n[IEx.Helpers, Integer, Kernel, Kernel.Typespec]\n```\n\nMany of the functions in the `Macro` module expect a `Macro.Env` environment. You can read more about these functions in `Macro` and learn more about the compilation environment in the `Macro.Env`.\n\n## Private macros\n\nElixir also supports **private macros** via `defmacrop`. Like private functions, these macros are only available inside the module that defines them, and only at compilation time.\n\nIt is important that a macro is defined before its usage. Failing to define a macro before its invocation will raise an error at runtime, since the macro won't be expanded and will be translated to a function call:\n\n```elixir\niex> defmodule Sample do\n...> def four, do: two() + two()\n...> defmacrop two, do: 2\n...> end\n** (CompileError) iex:2: function two/0 undefined\n```\n\n## Write macros responsibly\n\nMacros are a powerful construct and Elixir provides many mechanisms to ensure they are used responsibly.\n\n * Macros are **hygienic**: by default, variables defined inside a macro are not going to affect the user code. Furthermore, function calls and aliases available in the macro context are not going to leak into the user context.\n\n * Macros are **lexical**: it is impossible to inject code or macros globally. In order to use a macro, you need to explicitly `require` or `import` the module that defines the macro.\n\n * Macros are **explicit**: it is impossible to run a macro without explicitly invoking it. For example, some languages allow developers to completely rewrite functions behind the scenes, often via parse transforms or via some reflection mechanisms. In Elixir, a macro must be explicitly invoked in the caller during compilation time.\n\n * Macros' language is clear: many languages provide syntax shortcuts for `quote` and `unquote`. In Elixir, we preferred to have them explicitly spelled out, in order to clearly delimit the boundaries of a macro definition and its quoted expressions.\n\nEven with such guarantees, the developer plays a big role when writing macros responsibly. If you are confident you need to resort to macros, remember that macros are not your API. Keep your macro definitions short, including their quoted contents. For example, instead of writing a macro like this:\n\n```elixir\ndefmodule MyModule do\n defmacro my_macro(a, b, c) do\n quote do\n do_this(unquote(a))\n # ...\n do_that(unquote(b))\n # ...\n and_that(unquote(c))\n end\n end\nend\n```\n\nwrite:\n\n```elixir\ndefmodule MyModule do\n defmacro my_macro(a, b, c) do\n quote do\n # Keep what you need to do here to a minimum\n # and move everything else to a function\n MyModule.do_this_that_and_that(unquote(a), unquote(b), unquote(c))\n end\n end\n\n def do_this_that_and_that(a, b, c) do\n do_this(a)\n ...\n do_that(b)\n ...\n and_that(c)\n end\nend\n```\n\nThis makes your code clearer and easier to test and maintain, as you can invoke and test `do_this_that_and_that/3` directly. It also helps you design an actual API for developers that do not want to rely on macros.\n\nWith this guide, we finish our introduction to macros. The next guide is a brief discussion on **DSLs** that shows how we can mix macros and module attributes to annotate and extend modules and functions.\n" }, { "path": "lib/elixir/pages/meta-programming/quote-and-unquote.md", "content": "\n\n# Quote and unquote\n\nThis guide aims to introduce the meta-programming techniques available in Elixir. The ability to represent an Elixir program by its own data structures is at the heart of meta-programming. This chapter starts by exploring those structures and the associated `quote/2` and `unquote/1` constructs, so we can take a look at macros in the next guide, and finally build our own domain specific language.\n\n## Quoting\n\nThe building block of an Elixir program is a tuple with three elements. For example, the function call `sum(1, 2, 3)` is represented internally as:\n\n```elixir\n{:sum, [], [1, 2, 3]}\n```\n\nYou can get the representation of any expression by using the `quote/2` macro:\n\n```elixir\niex> quote do: sum(1, 2, 3)\n{:sum, [], [1, 2, 3]}\n```\n\nThe first element is the function name, the second is a keyword list containing metadata, and the third is the arguments list.\n\nOperators are also represented as such tuples:\n\n```elixir\niex> quote do: 1 + 2\n{:+, [context: Elixir, import: Kernel], [1, 2]}\n```\n\nEven a map is represented as a call to `%{}`:\n\n```elixir\niex> quote do: %{1 => 2}\n{:%{}, [], [{1, 2}]}\n```\n\nVariables are represented using such triplets, with the difference that the last element is an atom, instead of a list:\n\n```elixir\niex> quote do: x\n{:x, [], Elixir}\n```\n\nWhen quoting more complex expressions, we can see that the code is represented in such tuples, which are often nested inside each other in a structure resembling a tree. Many languages would call such representations an [*Abstract Syntax Tree*](https://en.wikipedia.org/wiki/Abstract_syntax_tree) (AST). Elixir calls them *quoted expressions*:\n\n```elixir\niex> quote do: sum(1, 2 + 3, 4)\n{:sum, [], [1, {:+, [context: Elixir, import: Kernel], [2, 3]}, 4]}\n```\n\nSometimes, when working with quoted expressions, it may be useful to get the textual code representation back. This can be done with `Macro.to_string/1`:\n\n```elixir\niex> Macro.to_string(quote do: sum(1, 2 + 3, 4))\n\"sum(1, 2 + 3, 4)\"\n```\n\nIn general, the tuples above are structured according to the following format:\n\n```elixir\n{atom | tuple, list, list | atom}\n```\n\n * The first element is an atom or another tuple in the same representation;\n * The second element is a keyword list containing metadata, like numbers and contexts;\n * The third element is either a list of arguments for the function call or an atom. When this element is an atom, it means the tuple represents a variable.\n\nBesides the tuple defined above, there are five Elixir literals that, when quoted, return themselves (and not a tuple). They are:\n\n```elixir\n:sum #=> Atoms\n1.0 #=> Numbers\n[1, 2] #=> Lists\n\"strings\" #=> Strings\n{key, value} #=> Tuples with two elements\n```\n\nMost Elixir code has a straight-forward translation to its underlying quoted expression. We recommend you try out different code samples and see what the results are. For example, what does `String.upcase(\"foo\")` expand to? We have also learned that `if(true, do: :this, else: :that)` is the same as `if true do :this else :that end`. How does this affirmation hold with quoted expressions?\n\n## Unquoting\n\nQuoting is about retrieving the inner representation of some particular chunk of code. However, sometimes it may be necessary to inject some other particular chunk of code inside the representation we want to retrieve.\n\nFor example, imagine you have a variable called `number` which contains the number you want to inject inside a quoted expression.\n\n```elixir\niex> number = 13\niex> Macro.to_string(quote do: 11 + number)\n\"11 + number\"\n```\n\nThat's not what we wanted, since the value of the `number` variable has not been injected and `number` has been quoted in the expression. In order to inject the *value* of the `number` variable, `unquote/1` has to be used inside the quoted representation:\n\n```elixir\niex> number = 13\niex> Macro.to_string(quote do: 11 + unquote(number))\n\"11 + 13\"\n```\n\n`unquote/1` can even be used to inject function names:\n\n```elixir\niex> fun = :hello\niex> Macro.to_string(quote do: unquote(fun)(:world))\n\"hello(:world)\"\n```\n\nIn some cases, it may be necessary to inject many values inside a list. For example, imagine you have a list containing `[1, 2, 6]`, and we want to inject `[3, 4, 5]` into it. Using `unquote/1` won't yield the desired result:\n\n```elixir\niex> inner = [3, 4, 5]\niex> Macro.to_string(quote do: [1, 2, unquote(inner), 6])\n\"[1, 2, [3, 4, 5], 6]\"\n```\n\nThat's when `unquote_splicing/1` comes in handy:\n\n```elixir\niex> inner = [3, 4, 5]\niex> Macro.to_string(quote do: [1, 2, unquote_splicing(inner), 6])\n\"[1, 2, 3, 4, 5, 6]\"\n```\n\nUnquoting is very useful when working with macros. When writing macros, developers are able to receive code chunks and inject them inside other code chunks, which can be used to transform code or write code that generates code during compilation.\n\n## Escaping\n\nAs we saw at the beginning of this chapter, only some values are valid quoted expressions in Elixir. For example, a map is not a valid quoted expression. Neither is a tuple with four elements. However, such values *can* be expressed as a quoted expression:\n\n```elixir\niex> quote do: %{1 => 2}\n{:%{}, [], [{1, 2}]}\n```\n\nIn some cases, you may need to inject such *values* into *quoted expressions*. To do that, we need to first escape those values into quoted expressions with the help of `Macro.escape/1`:\n\n```elixir\niex> map = %{hello: :world}\niex> Macro.escape(map)\n{:%{}, [], [hello: :world]}\n```\n\nMacros receive quoted expressions and must return quoted expressions. However, sometimes during the execution of a macro, you may need to work with values and making a distinction between values and quoted expressions will be required.\n\nIn other words, it is important to make a distinction between a regular Elixir value (like a list, a map, a process, a reference, and so on) and a quoted expression. Some values, such as integers, atoms, and strings, have a quoted expression equal to the value itself. Other values, like maps, need to be explicitly converted. Finally, values like functions and references cannot be converted to a quoted expression at all.\n\nWhen working with macros and code that generates code, check out the documentation for the `Macro` module, which contains many functions to work with Elixir's AST.\n\nIn this introduction, we have laid the groundwork to finally write our first macro. You can check that out in the [next guide](macros.md).\n" }, { "path": "lib/elixir/pages/mix-and-otp/agents.md", "content": "\n\n# Simple state with agents\n\nIn this chapter, we will learn how to keep and share state between multiple entities. If you have previous programming experience, you may think of globally shared variables, but the model we will learn here is quite different. The next chapters will generalize the concepts introduced here.\n\nIf you have skipped the *Getting Started* guide or read it long ago, be sure to re-read the [Processes](../getting-started/processes.md) chapter. We will use it as a starting point.\n\n## The trouble with (mutable) state\n\nElixir is an immutable language where nothing is shared by default. If we want to share information, this is typically done by sending messages between processes.\n\nWhen it comes to processes though, we rarely hand-roll our own, instead we use the abstractions available in Elixir and OTP:\n\n * `Agent` — Simple wrappers around state.\n * `GenServer` — \"Generic servers\" (processes) that encapsulate state, provide sync and async calls, support code reloading, and more.\n * `Task` — Asynchronous units of computation that allow spawning a process and potentially retrieving its result at a later time.\n\nHere, we will use agents, and create a module named `KV.Bucket`, responsible for storing our key-value entries in a way that allows them to be read and modified by other processes.\n\n## Agents 101\n\n`Agent`s are simple wrappers around state. If all you want from a process is to keep state, agents are a great fit. Let's start a `iex` session inside the project with:\n\n```console\n$ iex -S mix\n```\n\nAnd play a bit with agents:\n\n```elixir\niex> {:ok, agent} = Agent.start_link(fn -> [] end)\n{:ok, #PID<0.57.0>}\niex> Agent.update(agent, fn list -> [\"eggs\" | list] end)\n:ok\niex> Agent.get(agent, fn list -> list end)\n[\"eggs\"]\niex> Agent.stop(agent)\n:ok\n```\n\nWe started an agent with an initial state of an empty list. The `start_link/1` function returned the `:ok` tuple with a process identifier (PID) of the agent. We will use this PID for all further interactions. We then updated the agent's state, adding our new item to the head of the list. The second argument of `Agent.update/3` is a function that takes the agent's current state as input and returns its desired new state. Finally, we retrieved the whole list. The second argument of `Agent.get/3` is a function that takes the state as input and returns the value that `Agent.get/3` itself will return. Once we are done with the agent, we can call `Agent.stop/3` to terminate the agent process.\n\nThe `Agent.update/3` function accepts as a second argument any function that receives one argument and returns a value:\n\n```elixir\niex> {:ok, agent} = Agent.start_link(fn -> [] end)\n{:ok, #PID<0.338.0>}\niex> Agent.update(agent, fn _list -> 123 end)\n:ok\niex> Agent.update(agent, fn content -> %{a: content} end)\n:ok\niex> Agent.update(agent, fn content -> [12 | [content]] end)\n:ok\niex> Agent.update(agent, fn list -> [:nop | list] end)\n:ok\niex> Agent.get(agent, fn content -> content end)\n[:nop, 12, %{a: 123}]\n```\n\nAs you can see, we can modify the agent state in any way we want. Therefore, we most likely don't want to access the Agent API throughout many different places in our code. Instead, we want to encapsulate all Agent-related functionality in a single module, which we will call `KV.Bucket`. Before we implement it, let's write some tests which will outline the API exposed by our module.\n\nCreate a file at `test/kv/bucket_test.exs` (remember the `.exs` extension) with the following:\n\n```elixir\ndefmodule KV.BucketTest do\n use ExUnit.Case, async: true\n\n test \"stores values by key\" do\n {:ok, bucket} = KV.Bucket.start_link([])\n assert KV.Bucket.get(bucket, \"milk\") == nil\n\n KV.Bucket.put(bucket, \"milk\", 3)\n assert KV.Bucket.get(bucket, \"milk\") == 3\n end\nend\n```\n\n`use ExUnit.Case` is responsible for setting up our module for testing and imports many test-related functionality, such as the `test/2` macro.\n\nOur first test starts a new `KV.Bucket` by calling the `start_link/1` and passing an empty list of options. Then we perform some `get/2` and `put/3` operations on it, asserting the result.\n\nAlso note the `async: true` option passed to `ExUnit.Case`. This option makes the test case run in parallel with other `:async` test cases by using multiple cores in our machine. This is extremely useful to speed up our test suite. However, `:async` must *only* be set if the test case does not rely on or change any global values. For example, if the test requires writing to the file system or access a database, keep it synchronous (omit the `:async` option) to avoid race conditions between tests.\n\nAsync or not, our new test should obviously fail, as none of the functionality is implemented in the module being tested:\n\n```text\n1) test stores values by key (KV.BucketTest)\n test/kv/bucket_test.exs:4\n ** (UndefinedFunctionError) function KV.Bucket.start_link/1 is undefined (module KV.Bucket is not available)\n```\n\nIn order to fix the failing test, let's create a file at `lib/kv/bucket.ex` with the contents below. Feel free to give a try at implementing the `KV.Bucket` module yourself using agents before peeking at the implementation below.\n\n```elixir\ndefmodule KV.Bucket do\n use Agent\n\n @doc \"\"\"\n Starts a new bucket.\n\n All options are forwarded to `Agent.start_link/2`.\n \"\"\"\n def start_link(opts) do\n Agent.start_link(fn -> %{} end, opts)\n end\n\n @doc \"\"\"\n Gets a value from the `bucket` by `key`.\n \"\"\"\n def get(bucket, key) do\n Agent.get(bucket, &Map.get(&1, key))\n end\n\n @doc \"\"\"\n Puts the `value` for the given `key` in the `bucket`.\n \"\"\"\n def put(bucket, key, value) do\n Agent.update(bucket, &Map.put(&1, key, value))\n end\nend\n```\n\nThe first step in our implementation is to call `use Agent`. This is a pattern we will see throughout the guides and understand in depth in the next chapter.\n\nThen we define a `start_link/1` function, which will effectively start the agent. It is a convention to define a `start_link/1` function that always accepts a list of options. We then call `Agent.start_link/2` passing an anonymous function that returns the Agent's initial state and the same list of options we received.\n\nWe are keeping a map inside the agent to store our keys and values. Getting and putting values on the map is done with the Agent API and the capture operator `&`, introduced in [the Getting Started guide](../getting-started/anonymous-functions.md#the-capture-operator). The agent passes its state to the anonymous function via the `&1` argument when `Agent.get/2` and `Agent.update/2` are called.\n\nNow that the `KV.Bucket` module has been defined, our test should pass! You can try it yourself by running: `mix test`.\n\n## Naming processes\n\nWhen starting `KV.Bucket`, we pass a list of options which we forward to `Agent.start_link/2`. One of the options accepted by `Agent.start_link/2` is a name option which allows us to name a process, so we can interact with it using its name instead of its PID.\n\nLet's write a test as an example. Back on `KV.BucketTest`, add this:\n\n```elixir\n test \"stores values by key on a named process\" do\n {:ok, _} = KV.Bucket.start_link(name: :shopping_list)\n assert KV.Bucket.get(:shopping_list, \"milk\") == nil\n\n KV.Bucket.put(:shopping_list, \"milk\", 3)\n assert KV.Bucket.get(:shopping_list, \"milk\") == 3\n end\n```\n\nHowever, keep in mind that names are shared in the current node. If two tests attempt to create two processes named `:shopping_list` at the same time, one would succeed and the other would fail. For this reason, it is a common practice in Elixir to name processes started during tests after the test itself, like this:\n\n```elixir\n test \"stores values by key on a named process\", config do\n {:ok, _} = KV.Bucket.start_link(name: config.test)\n assert KV.Bucket.get(config.test, \"milk\") == nil\n\n KV.Bucket.put(config.test, \"milk\", 3)\n assert KV.Bucket.get(config.test, \"milk\") == 3\n end\n```\n\nThe `config` argument, passed after the test name, is the *test context* and it includes configuration and metadata about the current test, which is useful in scenarios like these.\n\n## Other agent actions\n\nBesides getting a value and updating the agent state, agents allow us to get a value and update the agent state in one function call via `Agent.get_and_update/2`. Let's implement a `KV.Bucket.delete/2` function that deletes a key from the bucket, returning its current value:\n\n```elixir\n@doc \"\"\"\nDeletes `key` from `bucket`.\n\nReturns the current value of `key`, if `key` exists.\n\"\"\"\ndef delete(bucket, key) do\n Agent.get_and_update(bucket, &Map.pop(&1, key))\nend\n```\n\nNow it is your turn to write a test for the functionality above! Also, be sure to explore [the documentation for the `Agent` module](`Agent`) to learn more about them.\n\n## Client/server in agents\n\nBefore we move on to the next chapter, let's discuss the client/server dichotomy in agents. Let's expand the `delete/2` function we have just implemented:\n\n```elixir\ndef delete(bucket, key) do\n Agent.get_and_update(bucket, fn map ->\n Map.pop(map, key)\n end)\nend\n```\n\nEverything that is inside the function we passed to the agent happens in the agent process. In this case, since the agent process is the one receiving and responding to our messages, we say the agent process is the server. Everything outside the function is happening in the client.\n\nThis distinction is important. If there are expensive actions to be done, you must consider if it will be better to perform these actions on the client or on the server. For example:\n\n```elixir\ndef delete(bucket, key) do\n Process.sleep(1000) # puts client to sleep\n Agent.get_and_update(bucket, fn map ->\n Process.sleep(1000) # puts server to sleep\n Map.pop(map, key)\n end)\nend\n```\n\nWhen a long action is performed on the server, all other requests to that particular server will wait until the action is done, which may cause some clients to timeout.\n\nSome APIs, such as GenServers, make a clearer distinction between client and server, and we will explore them in future chapters. Next let's talk about naming things, applications, and supervisors.\n" }, { "path": "lib/elixir/pages/mix-and-otp/config-and-distribution.md", "content": "\n\n# Configuration and distribution\n\nSo far we have hardcoded our applications to run a web server on port 4040. This has been somewhat problematic since we can't, for example, run our development server and tests at the same time. In this chapter, we will learn how to use the application environment for configuration, paving the way for us to enable distribution by running multiple development servers on the same machine (on different ports).\n\nIn this last guide, we will make the routing table for our distributed key-value store configurable, and then finally package the software for production.\n\nLet's do this.\n\n## Application environment\n\nIn the chapter [Registries, applications, and supervisors](supervisor-and-application.md), we have learned that our project is backed by an application, which bundles our modules and specifies how your supervision tree starts and shuts down. Each application can also have its own configuration, which in Erlang/OTP (and therefore Elixir) is called \"application environment\".\n\nWe can use the application environment to configure our own application, as well as others. Let's see the application environment in practice. Create a file `config/runtime.exs` with the following:\n\n```elixir\nimport Config\n\nport =\n cond do\n port_env = System.get_env(\"PORT\") ->\n String.to_integer(port_env)\n\n config_env() == :test ->\n 4040\n\n true ->\n 4050\n end\n\nconfig :kv, :port, port\n```\n\nThe above is attempting to read the \"PORT\" environment variable and use it as the port if defined. Otherwise, we default to port `4040` for tests and port `4050` for other environments, eliminating the conflict between environments we have seen in the past. Then we store its value under the `:port` key of our `:kv` application.\n\nNow we just need to read this configuration. Open up `lib/kv.ex` and the `start/2` function to the following:\n\n```elixir\n def start(_type, _args) do\n port = Application.fetch_env!(:kv, :port)\n\n children = [\n {Registry, name: KV, keys: :unique},\n {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},\n {Task.Supervisor, name: KV.ServerSupervisor},\n Supervisor.child_spec({Task, fn -> KV.Server.accept(port) end}, restart: :permanent)\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n end\n```\n\nRun `iex -S mix` and you will see the following message printed:\n\n```text\n[info] Accepting connections on port 4050\n```\n\nRun tests, without killing the development server, and you will see it running on port 4040.\n\nOur change was straight-forward. We used `Application.fetch_env!/2` to read the entry for `port` in `:kv`'s environment. We explicitly used `fetch_env!/2` (instead of `get_env/2` or `fetch_env`) because it will raise if the port was not configured (preventing the app from booting).\n\n## Compile vs runtime configuration\n\nConfiguration files provide a mechanism for us to configure the environment of any application. Elixir provides two configuration entry points:\n\n * `config/config.exs` — this file is read at build time, before we compile our application and before we even load our dependencies. This means we can't access the code in our application nor in our dependencies. However, it means we can control how they are compiled\n\n * `config/runtime.exs` — this file is read after our application and dependencies are compiled and therefore it can configure how our application works at runtime. If you want to read system environment variables (via `System.get_env/1`) or access external configuration, this is the appropriate place to do so\n\nYou can learn more about configuration in the `Config` and `Config.Provider` modules.\n\nGenerally speaking, we use `Application.fetch_env!/2` (and friends) to read runtime configuration. `Application.compile_env/2` is available for reading compile-time configuration. This allows Elixir to track which modules to recompile when the compilation environment changes.\n\nNow that we can start multiple servers, let's explore distribution.\n\n## Our first distributed code\n\nElixir ships with facilities to connect nodes and exchange information between them. In fact, we use the same concepts of processes, message passing and receiving messages when working in a distributed environment because Elixir processes are *location transparent*. This means that when sending a message, it doesn't matter if the recipient process is on the same node or on another node, the VM will be able to deliver the message in both cases.\n\nIn order to run distributed code, we need to start the VM with a name. The name can be short (when in the same network) or long (requires the full computer address). Let's start a new IEx session:\n\n```console\n$ iex --sname foo\n```\n\nYou can see now the prompt is slightly different and shows the node name followed by the computer name:\n\n Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)\n iex(foo@jv)1>\n\nMy computer is named `jv`, so I see `foo@jv` in the example above, but you will get a different result. We will use `foo@computer-name` in the following examples and you should update them accordingly when trying out the code.\n\nLet's define a module named `Hello` in this shell:\n\n```elixir\niex> defmodule Hello do\n...> def world, do: IO.puts(\"hello world\")\n...> end\n```\n\nIf you have another computer on the same network with both Erlang and Elixir installed, you can start another shell on it. If you don't, you can start another IEx session in another terminal. In either case, give it the short name of `bar`:\n\n```console\n$ iex --sname bar\n```\n\nNote that inside this new IEx session, we cannot access `Hello.world/0`:\n\n```elixir\niex> Hello.world\n** (UndefinedFunctionError) function Hello.world/0 is undefined (module Hello is not available)\n Hello.world()\n```\n\nHowever, we can spawn a new process on `foo@computer-name` from `bar@computer-name`! Let's give it a try (where `@computer-name` is the one you see locally):\n\n```elixir\niex> Node.spawn_link(:\"foo@computer-name\", fn -> Hello.world() end)\n#PID<9014.59.0>\nhello world\n```\n\nElixir spawned a process on another node and returned its PID. You can see the PID number no longer starts with zero, showing it belongs to another node. The code then executed on the other node where the `Hello.world/0` function exists and invoked that function. Note that the result of \"hello world\" was printed on the current node `bar` and not on `foo`. In other words, the message to be printed was sent back from `foo` to `bar`. This happens because the process spawned on the other node (`foo`) knows all the output should be sent back to the original node!\n\nWe can send and receive messages from the PID returned by `Node.spawn_link/2` as usual. Let's try a quick ping-pong example:\n\n```elixir\niex> pid = Node.spawn_link(:\"foo@computer-name\", fn ->\n...> receive do\n...> {:ping, client} -> send(client, :pong)\n...> end\n...> end)\n#PID<9014.59.0>\niex> send(pid, {:ping, self()})\n{:ping, #PID<0.73.0>}\niex> flush()\n:pong\n:ok\n```\n\nIn other words, we can spawn processes in other nodes, hold onto their PIDs, and then send messages to them as if they were running on the same machine. That's the *location transparency* principle. And because everything we have built so far was built on top of messaging passing, we should be able to adjust our key-value store to become a distributed one with little work.\n\n## Distributed naming registry with `:global`\n\nFirst, let's check that our code is not currently distributed. Start a new node like this:\n\n```console\n$ PORT=4100 iex --sname foo -S mix\n```\n\nAnd the other like this:\n\n```console\n$ PORT=4101 iex --sname bar -S mix\n```\n\nNow, within `foo@computer-name`, do this:\n\n```elixir\niex> :erpc.call(:\"bar@computer-name\", KV, :create_bucket, [\"shopping\"])\n{:ok, #PID<22121.164.0>}\n```\n\nInstead of using `Node.spawn_link/2`, we used [Erlang's builtin RPC module](`:erpc`) to call the function `create_bucket` in the `KV` module passing a one element list with the string \"shopping\" as the argument list. We could have used `Node.spawn_link/2`, but `:erpc.call/4` conveniently returns the result of the invocation.\n\nStill in `foo@computer-name`, let's try to access the bucket:\n\n```elixir\niex> KV.lookup_bucket(\"shopping\")\nnil\n```\n\nIt returns `nil`. However, if you run `KV.lookup_bucket(\"shopping\")` in `bar@computer-name`, it will return the proper bucket. In other words, the nodes can communicate with each other, but buckets spawned in one node are not visible to the other.\n\nThis is because we are using [Elixir's Registry](`Registry`) to name our buckets, which is a **local** process registry. In other words, it is designed for processes running on a single node and not for distribution.\n\nLuckily, Erlang ships with a distributed registry called [`:global`](`:global`), which is directly supported by the `:name` option by passing a `{:global, name}` tuple. All we need to do is update the `via/1` function in `lib/kv.ex` from this:\n\n```elixir\n defp via(name), do: {:via, Registry, {KV, name}}\n```\n\nto this:\n\n```elixir\n defp via(name), do: {:global, name}\n```\n\nDo the change above and restart both `foo@computer-name` and `bar@computer-name`. Now, back on `foo@computer-name`, let's give it another try:\n\n```elixir\niex> :erpc.call(:\"bar@computer-name\", KV, :create_bucket, [\"shopping\"])\n{:ok, #PID<21821.179.0>}\niex> KV.lookup_bucket(\"shopping\")\n#PID<21821.179.0>\n```\n\nAnd there you go! By simply changing which naming registry we used, we now have a distributed key value store. You can even try using `telnet` to connect to the servers on different ports and validate that changes in one session are visible in the other one. Exciting!\n\n## Node discovery and dependencies\n\nThere is one essential ingredient to wrap up our distributed key-value store. In order for the `:global` registry to work, we need to make sure the nodes are connected to each other. When we run `:erpc` call passing the node name:\n\n```elixir\n:erpc.call(:\"bar@computer-name\", KV, :create_bucket, [\"shopping\"])\n```\n\nElixir automatically connected the nodes together. This is easy to do in an IEx session when both instances are running on the same machine but it requires more work in a production environment, where instances are on different machines which may be started at any time and running on different IP addresses.\n\nLuckily for us, this is also a well-solved problem. For example, if you are using [the Phoenix web framework](https://phoenixframework.org) in production, it ships with [the `dns_cluster` package](https://github.com/phoenixframework/dns_cluster), which automatically runs DNS queries to find new nodes and connect them. If you are using Kubernetes or cloud providers, [packages like `libcluster`](https://github.com/bitwalker/libcluster) ship with different strategies to discover and connect nodes.\n\nInstalling dependencies in Elixir is simple. Most commonly, we use the [Hex Package Manager](https://hex.pm), by listing the dependency inside the deps function in our `mix.exs` file:\n\n```elixir\ndef deps do\n [{:dns_cluster, \"~> 0.2\"}]\nend\n```\n\nThis dependency refers to the latest version of `dns_cluster` in the 0.x version series that has been pushed to Hex. This is indicated by the `~>` preceding the version number. For more information on specifying version requirements, see the documentation for the `Version` module.\n\nTypically, stable releases are pushed to Hex. If you want to depend on an external dependency still in development, Mix is able to manage Git dependencies too:\n\n```elixir\ndef deps do\n [{:dns_cluster, git: \"https://github.com/phoenixframework/dns_cluster.git\"}]\nend\n```\n\nYou will notice that when you add a dependency to your project, Mix generates a `mix.lock` file that guarantees *repeatable builds*. The lock file must be checked in to your version control system, to guarantee that everyone who uses the project will use the same dependency versions as you.\n\nMix provides many tasks for working with dependencies, which can be seen in `mix help`:\n\n```console\n$ mix help\nmix deps # Lists dependencies and their status\nmix deps.clean # Deletes the given dependencies' files\nmix deps.compile # Compiles dependencies\nmix deps.get # Gets all out of date dependencies\nmix deps.tree # Prints the dependency tree\nmix deps.unlock # Unlocks the given dependencies\nmix deps.update # Updates the given dependencies\n```\n\nThe most common tasks are `mix deps.get` and `mix deps.update`. Once fetched, dependencies are automatically compiled for you. You can read more about deps by running `mix help deps`.\n\nTo wrap up this chapter, we will build a very simple node discovery mechanism, where the name of the nodes we should connect to are given on boot, using the lessons we learned in this chapter.\n\n## `Node.connect/1`\n\nWe will change our application to support a \"NODES\" environment variable with the name of all nodes each instance should connect to.\n\nOpen up `config/runtime.exs` and add this to the bottom:\n\n```elixir\nnodes =\n System.get_env(\"NODES\", \"\")\n |> String.split(\",\", trim: true)\n |> Enum.map(&String.to_atom/1)\n\nconfig :kv, :nodes, nodes\n```\n\nWe fetch the environment variable, split it on \",\" while discarding all empty strings, and then convert each entry to an atom, as node names are atoms.\n\nNow, in your `start/2` callback, we will add this to of the `start/2` function:\n\n```elixir\n def start(_type, _args) do\n for node <- Application.fetch_env!(:kv, :nodes) do\n Node.connect(node)\n end\n```\n\nNow we can start our nodes as:\n\n```console\n$ NODES=\"foo@computer-name,bar@computer-name\" PORT=4040 iex --sname foo -S mix\n$ NODES=\"foo@computer-name,bar@computer-name\" PORT=4041 iex --sname bar -S mix\n```\n\nAnd they should connect to each other. Give it a try!\n\nIn an actual production system, there is some additional care we must take. For example, we often use `--name` instead of `--sname` and give fully qualified node names.\n\nFurthermore, when connecting two instances, we must guarantee they have the same cookie, which is a secret Erlang uses to authorize the connection. When they run on the same machine, they share the same cookie by default, but it must be either explicitly set or shared in other ways when deploying in a cluster.\n\nWe will revisit these topics in the last chapter when we talk about releases.\n\n## Distributed system trade-offs\n\nIn this chapter, we made our key-value store distributed by using the `:global` naming registry. However, it is important to keep in mind that every distributed system, be it a library or a full-blown database, is designed with a series of trade-offs in mind.\n\nIn particular, `:global` requires consistency across all known nodes whenever a new bucket is created. For example, if your cluster has three nodes, creating a new bucket will require all three nodes to agree on its name. This means if one node is unresponsive, perhaps due to a [network partition](https://en.wikipedia.org/wiki/Network_partition), the node will have to either reconnect or be kicked out before registration succeeds. This also means that, as your cluster grows in size, registration becomes more expensive, although lookups are always cheap and immediate. Within the ecosystem, there are other named registries, which explore different trade-offs, such as [Syn](https://github.com/ostinelli/syn).\n\nFurther complications arise when we consider storage. Today, when our nodes terminate, we lose all data stored in the buckets. In our current design, since we allow each node to store their own buckets, it means we would need to backup each node. And, if we don't want data losses, we would also need to replicate the data.\n\nFor those reasons, it is still very common to use a database (or any storage system) when writing production applications in Elixir, and use Elixir to implement the realtime and collaborative aspects of your applications that extend beyond storage. For example, we can use Elixir to track which clients are connected to the cluster at any given moment or implement a feed where users are notified in realtime whenever items are added or removed from a bucket.\n\nIn fact, that's exactly what we will build in the next chapter. Allowing us to wrap up everything we have learned so far and also talk about one of the essential building blocks in Elixir software: GenServers.\n" }, { "path": "lib/elixir/pages/mix-and-otp/docs-tests-and-with.md", "content": "\n\n# Doctests, patterns, and with\n\nIn this chapter, we will implement the code that parses the commands we described in the first chapter:\n\n```text\nCREATE shopping\nOK\n\nPUT shopping milk 1\nOK\n\nPUT shopping eggs 3\nOK\n\nGET shopping milk\n1\nOK\n\nDELETE shopping eggs\nOK\n```\n\nAfter the parsing is done, we will update our server to dispatch the parsed commands to the relevant buckets.\n\n## Doctests\n\nOn the language homepage, we mention that Elixir makes documentation a first-class citizen in the language. We have explored this concept many times throughout this guide, be it via `mix help` or by typing `h Enum` or another module in an IEx console.\n\nIn this section, we will implement the parsing functionality, document it and make sure our documentation is up to date with doctests. This helps us provide documentation with accurate code samples.\n\nLet's create our command parser at `lib/kv/command.ex` and start with the doctest:\n\n```elixir\ndefmodule KV.Command do\n @doc ~S\"\"\"\n Parses the given `line` into a command.\n\n ## Examples\n\n iex> KV.Command.parse(\"CREATE shopping\\r\\n\")\n {:ok, {:create, \"shopping\"}}\n\n \"\"\"\n def parse(_line) do\n :not_implemented\n end\nend\n```\n\nDoctests are specified by an indentation of four spaces followed by the `iex>` prompt in a documentation string. If a command spans multiple lines, you can use `...>`, as in IEx. The expected result should start at the next line after `iex>` or `...>` line(s) and is terminated either by a newline or a new `iex>` prefix.\n\nAlso, note that we started the documentation string using `@doc ~S\"\"\"`. The `~S` prevents the `\\r\\n` characters from being converted to a carriage return and line feed until they are evaluated in the test.\n\nTo run our doctests, we'll create a file at `test/kv/command_test.exs` and call `doctest KV.Command` in the test case:\n\n```elixir\ndefmodule KV.CommandTest do\n use ExUnit.Case, async: true\n doctest KV.Command\nend\n```\n\nRun the test suite and the doctest should fail:\n\n```text\n 1) doctest KV.Command.parse/1 (1) (KV.CommandTest)\n test/kv/command_test.exs:3\n Doctest failed\n doctest:\n iex> KV.Command.parse(\"CREATE shopping\\r\\n\")\n {:ok, {:create, \"shopping\"}}\n code: KV.Command.parse \"CREATE shopping\\r\\n\" === {:ok, {:create, \"shopping\"}}\n left: :not_implemented\n right: {:ok, {:create, \"shopping\"}}\n stacktrace:\n lib/kv/command.ex:7: KV.Command (module)\n```\n\nExcellent!\n\nNow let's make the doctest pass. Let's implement the `parse/1` function:\n\n```elixir\ndef parse(line) do\n case String.split(line) do\n [\"CREATE\", bucket] -> {:ok, {:create, bucket}}\n end\nend\n```\n\nOur implementation splits the line on whitespace and then matches the command against a list. Using `String.split/1` means our commands will be whitespace-insensitive. Leading and trailing whitespace won't matter, nor will consecutive spaces between words. Let's add some new doctests to test this behavior along with the other commands:\n\n```elixir\n @doc ~S\"\"\"\n Parses the given `line` into a command.\n\n ## Examples\n\n iex> KV.Command.parse \"CREATE shopping\\r\\n\"\n {:ok, {:create, \"shopping\"}}\n\n iex> KV.Command.parse \"CREATE shopping \\r\\n\"\n {:ok, {:create, \"shopping\"}}\n\n iex> KV.Command.parse \"PUT shopping milk 1\\r\\n\"\n {:ok, {:put, \"shopping\", \"milk\", \"1\"}}\n\n iex> KV.Command.parse \"GET shopping milk\\r\\n\"\n {:ok, {:get, \"shopping\", \"milk\"}}\n\n iex> KV.Command.parse \"DELETE shopping eggs\\r\\n\"\n {:ok, {:delete, \"shopping\", \"eggs\"}}\n\n Unknown commands or commands with the wrong number of\n arguments return an error:\n\n iex> KV.Command.parse \"UNKNOWN shopping eggs\\r\\n\"\n {:error, :unknown_command}\n\n iex> KV.Command.parse \"GET shopping\\r\\n\"\n {:error, :unknown_command}\n\n \"\"\"\n```\n\nWith doctests at hand, it is your turn to make tests pass! Once you're ready, you can compare your work with our solution below:\n\n```elixir\n def parse(line) do\n case String.split(line) do\n [\"CREATE\", bucket] -> {:ok, {:create, bucket}}\n [\"GET\", bucket, key] -> {:ok, {:get, bucket, key}}\n [\"PUT\", bucket, key, value] -> {:ok, {:put, bucket, key, value}}\n [\"DELETE\", bucket, key] -> {:ok, {:delete, bucket, key}}\n _ -> {:error, :unknown_command}\n end\n end\n```\n\nNotice how we were able to elegantly parse the commands without adding a bunch of `if/else` clauses that check the command name and number of arguments!\n\nFinally, you may have observed that each doctest corresponds to a different test in our suite, which now reports a total of 7 doctests. That is because ExUnit considers the following to define two different doctests:\n\n```elixir\niex> KV.Command.parse(\"UNKNOWN shopping eggs\\r\\n\")\n{:error, :unknown_command}\n\niex> KV.Command.parse(\"GET shopping\\r\\n\")\n{:error, :unknown_command}\n```\n\nWithout new lines, as seen below, ExUnit compiles it into a single doctest:\n\n```elixir\niex> KV.Command.parse(\"UNKNOWN shopping eggs\\r\\n\")\n{:error, :unknown_command}\niex> KV.Command.parse(\"GET shopping\\r\\n\")\n{:error, :unknown_command}\n```\n\nAs the name says, doctest is documentation first and a test later. Their goal is not to replace tests but to provide up-to-date documentation. You can read more about doctests in the `ExUnit.DocTest` documentation.\n\n## Using `with`\n\nAs we are now able to parse commands, we can finally start implementing the logic that runs the commands. Let's add a stub definition for this function for now:\n\n```elixir\ndefmodule KV.Command do\n @doc \"\"\"\n Runs the given command.\n \"\"\"\n def run(command, socket) do\n :gen_tcp.send(socket, \"OK\\r\\n\")\n :ok\n end\nend\n```\n\nBefore we implement this function, let's change our server to start using our new `parse/1` and `run/1` functions. Remember, our `read_line/1` function was also crashing when the client closed the socket, so let's take the opportunity to fix it, too. Open up `lib/kv/server.ex` and replace the existing server definition:\n\n```elixir\n defp serve(socket) do\n socket\n |> read_line()\n |> write_line(socket)\n\n serve(socket)\n end\n\n defp read_line(socket) do\n {:ok, data} = :gen_tcp.recv(socket, 0)\n data\n end\n\n defp write_line(line, socket) do\n :gen_tcp.send(socket, line)\n end\n```\n\nby the following:\n\n```elixir\n defp serve(socket) do\n msg =\n case read_line(socket) do\n {:ok, data} ->\n case KV.Command.parse(data) do\n {:ok, command} ->\n KV.Command.run(command, socket)\n\n {:error, _} = err ->\n err\n end\n\n {:error, _} = err ->\n err\n end\n\n write_line(socket, msg)\n serve(socket)\n end\n\n defp read_line(socket) do\n :gen_tcp.recv(socket, 0)\n end\n\n defp write_line(_socket, :ok) do\n :ok\n end\n\n defp write_line(socket, {:error, :unknown_command}) do\n # Known error; write to the client\n :gen_tcp.send(socket, \"UNKNOWN COMMAND\\r\\n\")\n end\n\n defp write_line(_socket, {:error, :closed}) do\n # The connection was closed, exit politely\n exit(:shutdown)\n end\n\n defp write_line(socket, {:error, error}) do\n # Unknown error; write to the client and exit\n :gen_tcp.send(socket, \"ERROR\\r\\n\")\n exit(error)\n end\n```\n\nIf we start our server, we can now send commands to it. For now, we will get two different responses: \"OK\" when the command is known and \"UNKNOWN COMMAND\" otherwise:\n\n```console\n$ telnet 127.0.0.1 4040\nTrying 127.0.0.1...\nConnected to localhost.\nEscape character is '^]'.\nCREATE shopping\nOK\nHELLO\nUNKNOWN COMMAND\n```\n\nThis means our implementation is going in the correct direction, but it doesn't look very elegant, does it?\n\nThe previous implementation used pipelines which made the logic straightforward to follow. However, now that we need to handle different error codes along the way, our server logic is nested inside many `case` calls.\n\nThankfully, Elixir has the `with` construct, which allows you to simplify code like the above, replacing nested `case` calls with a chain of matching clauses. Let's rewrite the `serve/1` function to use `with`:\n\n```elixir\n defp serve(socket) do\n msg =\n with {:ok, data} <- read_line(socket),\n {:ok, command} <- KV.Command.parse(data),\n do: KV.Command.run(command, socket)\n\n write_line(socket, msg)\n serve(socket)\n end\n```\n\nMuch better! `with` will retrieve the value returned by the right-side of `<-` and match it against the pattern on the left side. If the value matches the pattern, `with` moves on to the next expression. In case there is no match, the non-matching value is returned.\n\nIn other words, we converted each expression given to `case/2` as a step in `with`. As soon as any of the steps return something that does not match `{:ok, x}`, `with` aborts, and returns the non-matching value.\n\nYou can read more about `with/1` in our documentation.\n\n## Running commands\n\nThe last step is to implement `KV.Command.run/1` to run the parsed commands on top of buckets. Its implementation is shown below:\n\n```elixir\n @doc \"\"\"\n Runs the given command.\n \"\"\"\n def run(command, socket)\n\n def run({:create, bucket}, socket) do\n KV.create_bucket(bucket)\n :gen_tcp.send(socket, \"OK\\r\\n\")\n :ok\n end\n\n def run({:get, bucket, key}, socket) do\n lookup(bucket, fn pid ->\n value = KV.Bucket.get(pid, key)\n :gen_tcp.send(socket, \"#{value}\\r\\nOK\\r\\n\")\n :ok\n end)\n end\n\n def run({:put, bucket, key, value}, socket) do\n lookup(bucket, fn pid ->\n KV.Bucket.put(pid, key, value)\n :gen_tcp.send(socket, \"OK\\r\\n\")\n :ok\n end)\n end\n\n def run({:delete, bucket, key}, socket) do\n lookup(bucket, fn pid ->\n KV.Bucket.delete(pid, key)\n :gen_tcp.send(socket, \"OK\\r\\n\")\n :ok\n end)\n end\n\n defp lookup(bucket, callback) do\n if bucket = KV.lookup_bucket(bucket) do\n callback.(bucket)\n else\n {:error, :not_found}\n end\n end\n```\n\nEach function clause dispatches the appropriate command to the appropriate bucket.\n\nYou might have noticed we have a function head, `def run(command, socket)`, without a body. In the [Modules and Functions](../getting-started/modules-and-functions.md#default-arguments) chapter, we learned that a bodiless function can be used to declare default arguments for a multi-clause function. Here is another use case where we use a function without a body to document what the arguments are.\n\nWe have also defined a private function named `lookup/2` to help with the common functionality of looking up a bucket and returning its `pid` if it exists, `{:error, :not_found}` otherwise.\n\nBy the way, since we are now returning `{:error, :not_found}`, we should amend the `write_line/2` function in `KV.Server` to print such error as well:\n\n```elixir\ndefp write_line(socket, {:error, :not_found}) do\n :gen_tcp.send(socket, \"NOT FOUND\\r\\n\")\nend\n```\n\nOur server functionality is almost complete. Only tests are missing.\n\n## Integration tests\n\n`KV.Command.run/1`'s implementation is sending commands directly to the `KV` module, which is using a local registry to name processes. This means if we have two tests sending messages to the same bucket, our tests will conflict with each other (and likely fail). One might think this would be a reason to use mocks and other strategies to keep our tests isolated, but such techniques often make our testing environment too distant from how our code actually runs in production, and you may end-up with bugs lurking.\n\nLuckily, there is a technique that we have been using throughout this guide that would be equally applicable here: it is ok to rely on the local registry as long as each test uses unique names. Using a combination of the test module and test name is more than enough to guarantee that.\n\nSo let's write integration tests that rely on unique names to exercise the whole stack from the TCP server to the bucket.\n\nCreate a new file at `test/kv/server_test.exs` as shown below:\n\n```elixir\ndefmodule KV.ServerTest do\n use ExUnit.Case, async: true\n\n @socket_options [:binary, packet: :line, active: false]\n\n setup config do\n {:ok, socket} = :gen_tcp.connect(~c\"localhost\", 4040, @socket_options)\n test_name = config.test |> Atom.to_string() |> String.replace(\" \", \"-\")\n %{socket: socket, name: \"#{config.module}-#{test_name}\"}\n end\n\n test \"server interaction\", %{socket: socket, name: name} do\n # CREATE\n assert send_and_recv(socket, \"CREATE #{name}\\r\\n\") == \"OK\\r\\n\"\n\n # PUT\n assert send_and_recv(socket, \"PUT #{name} eggs 3\\r\\n\") == \"OK\\r\\n\"\n\n # GET\n assert send_and_recv(socket, \"GET #{name} eggs\\r\\n\") == \"3\\r\\n\"\n assert send_and_recv(socket, \"\") == \"OK\\r\\n\"\n\n # DELETE\n assert send_and_recv(socket, \"DELETE #{name} eggs\\r\\n\") == \"OK\\r\\n\"\n\n # GET\n assert send_and_recv(socket, \"GET #{name} eggs\\r\\n\") == \"\\r\\n\"\n assert send_and_recv(socket, \"\") == \"OK\\r\\n\"\n end\n\n test \"unknown command\", %{socket: socket} do\n assert send_and_recv(socket, \"WHATEVER\\r\\n\") ==\n \"UNKNOWN COMMAND\\r\\n\"\n end\n\n test \"unknown bucket\", %{socket: socket} do\n assert send_and_recv(socket, \"GET whatever eggs\\r\\n\") ==\n \"NOT FOUND\\r\\n\"\n end\n\n defp send_and_recv(socket, command) do\n :ok = :gen_tcp.send(socket, command)\n {:ok, data} = :gen_tcp.recv(socket, 0, 1000)\n data\n end\nend\n```\n\nRun `mix test` and the tests should all pass. However, make sure to terminate any `iex -S mix` session you may have running, as currently tests and development environment are running on the same port (4040). We will address it in the next chapter.\n\nWe added three tests, the first one tests most bucket actions, while the other two deal with error cases. Given there is a lot of shared setup across these tests, we used the `setup/2` macro to deal with common boilerplate. The macro receives the same *test context* as tests and starts a client TCP connection per test. It also defines a unique bucket name using the module name and the test name, making sure any space in the test name is replaced by `-` as to not interfere with our command parsing logic.\n\nThen, in each test, we pattern matched on the *test context*, extracting the socket or name as necessary. This is similar to the code we wrote in `test/kv/bucket_test.exs`:\n\n```elixir\n test \"stores values by key on a named process\", config do\n```\n\nExcept back then we matched on all config and, this time around, we matched only on the data we needed.\n\nLet's move to the next chapter. We will finally make our system distributed by adding a tiny bit of configuration and, *spoiler alert*, changing one line of code.\n" }, { "path": "lib/elixir/pages/mix-and-otp/dynamic-supervisor.md", "content": "\n\n# Supervising dynamic children\n\nWe have successfully learned how our supervision tree is automatically started (and stopped) as part of our application's life cycle. We can also name our buckets via the `:name` option. We also learned that, in practice, we should always start new processes inside supervisors. Let's apply these insights by ensuring our buckets are named and supervised.\n\n## Child specs\n\nSupervisors know how to start processes because they are given \"child specifications\". In our `lib/kv.ex` file, we defined a list of children with a single child spec:\n\n```elixir\nchildren = [\n {Registry, name: KV, keys: :unique}\n]\n```\n\nWhen the child specification is a tuple (as above) or module, then it is equivalent to calling the `child_spec/1` function on said module, which then returns the full specification. The pair above is equivalent to:\n\n```elixir\niex> Registry.child_spec(name: KV, keys: :unique)\n%{\n id: KV,\n start: {Registry, :start_link, [[name: KV, keys: :unique]]},\n type: :supervisor\n}\n```\n\nThe underlying map returns the `:id` (required), the module-function-args triplet to invoke to start the process (required), the type of the process (optional), among other optional keys. In other words, the `child_spec/1` function allows us to compose and encapsulate specifications in modules.\n\nTherefore, if we want to supervise `KV.Bucket`, we only need to define a `child_spec/1` function. Luckily for us, whenever we invoke `use Agent` (or `use GenServer` or `use Supervisor` and so forth), an implementation with reasonable defaults is provided. So let's take it for a spin. Back on `iex -S mix`, try this:\n\n```elixir\niex> KV.Bucket.child_spec([])\n%{id: KV.Bucket, start: {KV.Bucket, :start_link, [[]]}}\niex> KV.Bucket.child_spec([name: :shopping])\n%{id: KV.Bucket, start: {KV.Bucket, :start_link, [[name: :shopping]]}}\n```\n\nLet's try to start it as part of a supervisor then, using the `{module, options}` format to pass the bucket name (let's also use an atom as the name for convenience):\n\n```elixir\niex> children = [{KV.Bucket, name: :shopping}]\niex> Supervisor.start_link(children, strategy: :one_for_one)\niex> KV.Bucket.put(:shopping, \"milk\", 1)\n:ok\niex> KV.Bucket.get(:shopping, \"milk\")\n1\n```\n\nWhat happens now if we explicitly kill the bucket process?\n\n```elixir\n# Find the pid for the given name\niex> pid = Process.whereis(:shopping)\n#PID<0.48.0>\n# Send it a kill exit signal\niex> Process.exit(pid, :kill)\ntrue\n# But a new process is alive in its place\niex> Process.whereis(:shopping)\n#PID<0.50.0>\n```\n\nGiven our buckets can already be supervised, it is time to hook them into our supervision tree.\n\n## Dynamic supervisors\n\nGiven our buckets can already be supervised, you may be thinking to start them as part of our application `start/2` callback, such as:\n\n```elixir\nchildren = [\n {Registry, name: KV, keys: :unique}\n {KV.Bucket, name: {:via, Registry, {KV, \"shopping\"}}}\n]\n```\n\nAnd while the above would definitely work, it comes with a huge caveat: it only starts a single bucket. In practice, we want the user to be able to create new buckets at any time. In other words, we need to start and supervise processes dynamically.\n\nWhile the `Supervisor` module has APIs for starting children after its initialization, it was not designed or optimized for the use case of having potentially millions of children. For this purpose, Elixir instead provides the `DynamicSupervisor` module. Using it is quite similar to `Supervisor` except that, instead of specifying the children during start, you do it afterwards. Let's take it for a spin:\n\n```elixir\niex> {:ok, sup_pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\niex> DynamicSupervisor.start_child(sup_pid, {KV.Bucket, name: :another_list})\niex> KV.Bucket.put(:another_list, \"milk\", 1)\n:ok\niex> KV.Bucket.get(:another_list, \"milk\")\n1\n```\n\nAnd it all works as expected. In fact, we can even give names to `DynamicSupervisor` themselves, instead of passing PIDs around and also use it to start buckets named using the registry:\n\n```elixir\niex> DynamicSupervisor.start_link(strategy: :one_for_one, name: :dyn_sup)\niex> name = {:via, Registry, {KV, \"yet_another_list\"}}\niex> DynamicSupervisor.start_child(:dyn_sup, {KV.Bucket, name: name})\niex> KV.Bucket.put(name, \"milk\", 1)\n:ok\niex> KV.Bucket.get(name, \"milk\")\n1\n```\n\nOverall, processes can be named and supervised, regardless if they are supervisors, agents, etc, since all of Elixir standard library was designed around those capabilities.\n\nWith all ingredients in place to supervise and name buckets, open up the `lib/kv.ex` module and let's add a new function called `KV.lookup_bucket/1`, which receives a name and either create or returns a bucket for the given name:\n\n```elixir\ndefmodule KV do\n use Application\n\n @impl true\n def start(_type, _args) do\n children = [\n {Registry, name: KV, keys: :unique},\n {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n end\n\n @doc \"\"\"\n Creates a bucket with the given name.\n \"\"\"\n def create_bucket(name) do\n DynamicSupervisor.start_child(KV.BucketSupervisor, {KV.Bucket, name: via(name)})\n end\n\n @doc \"\"\"\n Looks up the given bucket.\n \"\"\"\n def lookup_bucket(name) do\n GenServer.whereis(via(name))\n end\n\n defp via(name), do: {:via, Registry, {KV, name}}\nend\n```\n\nThe code is relatively simple. First we changed `start/2` to also start a dynamic supervisor named `KV.BucketSupervisor`. Then, when implemented `KV.create_bucket/1` which receives a bucket and starts with using our registry and dynamic supervisor. And we also added `KV.lookup_bucket/1` that receives the same name and attempts to find its PID.\n\nTo make sure it all works as expected, let's write a test. Open up `test/kv_test.exs` and add this:\n\n```elixir\ndefmodule KVTest do\n use ExUnit.Case, async: true\n\n test \"creates and looks up buckets by any name\" do\n name = \"a unique name that won't be shared\"\n assert is_nil(KV.lookup_bucket(name))\n\n assert {:ok, bucket} = KV.create_bucket(name)\n assert KV.lookup_bucket(name) == bucket\n\n assert KV.create_bucket(name) == {:error, {:already_started, bucket}}\n end\nend\n```\n\nThe test shows we are creating and locating buckets with any name, making sure we use a unique name to avoid conflicts between tests.\n\n## The `start_supervised` test helper\n\nBefore we move on, let's do some clean up.\n\nIn `test/kv/bucket_test.exs`, we explicitly invoked `KV.Bucket.start_link/1` to start our buckets. However, we now know that we should avoid calling `start_link/1` directly and instead start processes as part of supervision trees.\n\nIn order to aid testing, `ExUnit` already starts a supervision tree per test and provides the `start_supervised` function to start processes within test-specific supervision tree. One advantage of this approach is that `ExUnit` guarantees any started process is shut down at the end of the test too. Let's rewrite our tests to use it instead:\n\n```elixir\ndefmodule KV.BucketTest do\n use ExUnit.Case, async: true\n\n test \"stores values by key\" do\n {:ok, bucket} = start_supervised(KV.Bucket)\n assert KV.Bucket.get(bucket, \"milk\") == nil\n\n KV.Bucket.put(bucket, \"milk\", 3)\n assert KV.Bucket.get(bucket, \"milk\") == 3\n end\n\n test \"stores values by key on a named process\", config do\n {:ok, _} = start_supervised({KV.Bucket, name: config.test})\n assert KV.Bucket.get(config.test, \"milk\") == nil\n\n KV.Bucket.put(config.test, \"milk\", 3)\n assert KV.Bucket.get(config.test, \"milk\") == 3\n end\nend\n```\n\nIt is a small change, but our tests are now using all of the relevant best practices. Excellent!\n\n## Observer\n\nNow that we have defined our supervision tree, it is a great opportunity to introduce the Observer tool that ships with Erlang. Start your application with `iex -S mix` and key this in:\n\n```elixir\niex> :observer.start()\n```\n\n> #### Missing dependencies {: .warning}\n>\n> When running `iex` inside a project with `iex -S mix`, `observer` won't be available as a dependency. To do so, you will need to call the following functions:\n>\n> ```elixir\n> iex> Mix.ensure_application!(:observer)\n> iex> :observer.start()\n> ```\n>\n> If the call above fails, here is what may have happened: some package managers default to installing a minimized Erlang without WX bindings for GUI support. In some package managers, you may be able to replace the headless Erlang with a more complete package (look for packages named `erlang` vs `erlang-nox` on Debian/Ubuntu/Arch). In others managers, you may need to install a separate `erlang-wx` (or similarly named) package.\n>\n> There are conversations to improve this experience in future releases.\n\nA GUI should pop up containing all sorts of information about our system, from general statistics to load charts as well as a list of all running processes and applications.\n\nIn the Applications tab, you will see all applications currently running in your system alongside their supervision tree. You can select the `kv` application to explore it further:\n\n\"Observer\n\nNot only that, as you create new buckets on the terminal, you should see new processes spawned in the supervision tree shown in Observer:\n\n```elixir\niex> KV.create_bucket(\"shopping\")\n#PID<0.89.0>\n```\n\nWe will leave it up to you to further explore what Observer provides. Note you can double-click any process in the supervision tree to retrieve more information about it, as well as right-click a process to send \"a kill signal\", a perfect way to emulate failures and see if your supervisor reacts as expected.\n\nAt the end of the day, tools like Observer are one of the reasons you want to always start processes inside supervision trees, even if they are temporary, to ensure they are always reachable and introspectable.\n\nNow that our buckets are named and supervised, we are ready to start our server and start receiving requests.\n" }, { "path": "lib/elixir/pages/mix-and-otp/genservers.md", "content": "\n\n# Client-server with GenServer\n\nTo wrap up our distributed key-value store, we will implement a feature where a client can subscribe to a bucket and receive realtime notifications of any modification happening in the bucket, regardless of where in the cluster the bucket is located.\n\nWe will do by adding a new command, called SUBSCRIBE, to be used like this:\n\n```text\nSUBSCRIBE shopping\nmilk SET TO 1\neggs SET TO 10\nmilk DELETED\n```\n\nTo make this work, we must change our `KV.Bucket` implementation to track subscriptions and emit broadcasts. However, as we will see, we cannot implement such on top of agents, and we will need to rewrite our bucket implementation to a `GenServer`.\n\n## Links and monitors\n\nProcesses in Elixir are isolated. When they need to communicate, they do so by sending messages. However, how do you know when a process terminates, either because it has completed or due to a crash?\n\nWe have two options: links and monitors.\n\nWe have used links extensively. Whenever we started a process, we typically did so by using `start_link` or similar. The idea behind links is that, if any of the processes crash, the other will crash due to the link. We talked about them in the [Process chapter of the Getting Started guide](../getting-started/processes.md). Here is a refresher:\n\n```elixir\niex> self()\n#PID<0.115.0>\niex> spawn_link(fn -> :nothing_bad_will_happen end)\n#PID<0.116.0>\niex> self()\n#PID<0.115.0>\n```\n\n```elixir\niex> spawn_link(fn -> raise \"oops\" end)\n#PID<0.117.0>\n\n12:37:33.229 [error] Process #PID<0.117.0> raised an exception\nInteractive Elixir (1.18.4) - press Ctrl+C to exit (type h() ENTER for help)\niex> self()\n#PID<0.118.0>\n```\n\nThe reason why we links are so pervasive is because when we start a process inside a supervisor, we want our process to crash if the supervisor terminates. On the other hand, we don't want the supervisor to crash when a child terminates, and therefore supervisors trap exits from links by calling `Process.flag(:trap_exit, true)`.\n\nIn other words, links create an intrinsic relationship between the processes. If we simply want to track when a process dies, without tying their exit signals to each other, a better solution is to use monitors. When a monitored process terminates, we receive a message in our inbox, regardless of the reason:\n\n```elixir\niex> pid = spawn(fn -> Process.sleep(5000) end)\n#PID<0.119.0>\niex> Process.monitor(pid)\n#Reference<0.1076459149.2159017989.118674>\niex> flush()\n:ok\n# Wait five seconds\niex> flush()\n{:DOWN, #Reference<0.1076459149.2159017989.118674>, :process, #PID<0.119.0>, :normal}\n:ok\n```\n\nOnce the process terminates, we receive a \"DOWN message\", represented in a five-element tuple. The last element is the reason why it crashed (`:normal` means it terminated successfully).\n\nMonitors will play a very important role in our subscribe feature. When a client subscribes to a bucket, the bucket will store the client PID and send messages to it on every change. However, if the client terminates (for example because it was disconnected), the bucket must remove the client from its list of subscribers (otherwise the list would keep on growing forever as clients connect and disconnect).\n\nWe chose the `Agent` module to implement our `KV.Bucket` and, unfortunately, agents cannot receive messages. So the first step is to rewrite our `KV.Bucket` to a `GenServer`. The `GenServer` module documentation has a good overview on what they are and how to implement them. Give it a read and then we are ready to proceed.\n\n## GenServer callbacks\n\nA GenServer is a process that invokes a limited set of functions under specific conditions. When we used an `Agent`, we would keep both the client code and the server code side by side, like this:\n\n```elixir\ndef put(bucket, key, value) do\n Agent.update(bucket, &Map.put(&1, key, value))\nend\n```\n\nLet's break that code apart a bit:\n\n```elixir\ndef put(bucket, key, value) do\n # Here is the client code\n Agent.update(bucket, fn state ->\n # Here is the server code\n Map.put(state, key, value)\n end)\n # Back to the client code\nend\n```\n\nIn the code above, we have a process, which we call \"the client\" sending a request to an agent, \"the server\". The request contains an anonymous function, which must be executed by the server.\n\nIn a GenServer, the code above would be two separate functions, roughly like this:\n\n```elixir\ndef put(bucket, key, value) do\n # Send the server a :put \"instruction\"\n GenServer.call(bucket, {:put, key, value})\nend\n\n# Server callback\n\ndef handle_call({:put, key, value}, _from, state) do\n {:reply, :ok, Map.put(state, key, value)}\nend\n```\n\nLet's go ahead and rewrite `KV.Bucket` at once. Open up `lib/kv/bucket.ex` and replace its contents with this new version:\n\n```elixir\ndefmodule KV.Bucket do\n use GenServer\n\n @doc \"\"\"\n Starts a new bucket.\n \"\"\"\n def start_link(opts) do\n GenServer.start_link(__MODULE__, %{}, opts)\n end\n\n @doc \"\"\"\n Gets a value from the `bucket` by `key`.\n \"\"\"\n def get(bucket, key) do\n GenServer.call(bucket, {:get, key})\n end\n\n @doc \"\"\"\n Puts the `value` for the given `key` in the `bucket`.\n \"\"\"\n def put(bucket, key, value) do\n GenServer.call(bucket, {:put, key, value})\n end\n\n @doc \"\"\"\n Deletes `key` from `bucket`.\n\n Returns the current value of `key`, if `key` exists.\n \"\"\"\n def delete(bucket, key) do\n GenServer.call(bucket, {:delete, key})\n end\n\n ### Callbacks\n\n @impl true\n def init(bucket) do\n state = %{\n bucket: bucket\n }\n\n {:ok, state}\n end\n\n @impl true\n def handle_call({:get, key}, _from, state) do\n value = get_in(state.bucket[key])\n {:reply, value, state}\n end\n\n def handle_call({:put, key, value}, _from, state) do\n state = put_in(state.bucket[key], value)\n {:reply, :ok, state}\n end\n\n def handle_call({:delete, key}, _from, state) do\n {value, state} = pop_in(state.bucket[key])\n {:reply, value, state}\n end\nend\n```\n\nThe first function is `start_link/1`, which starts a new GenServer passing a list of options. `GenServer.start_link/3`, which takes three arguments:\n\n1. The module where the server callbacks are implemented, in this case `__MODULE__` (meaning the current module)\n\n2. The initialization arguments, in this case the empty bucket `%{}`\n\n3. A list of options which can be used to specify things like the name of the server. Once again, we forward the list of options that we receive on `start_link/1` to `GenServer.start_link/3`, as we did for agents\n\nOnce started, the GenServer will invoke the `init/1` callback, that receives the second argument given to `GenServer.start_link/3` and returns `{:ok, state}`, where state is a new map. We can already notice how the `GenServer` API makes the client/server segregation more apparent. `start_link/3` happens in the client, while `init/1` is the respective callback that runs on the server.\n\nThere are two types of requests you can send to a GenServer: calls and casts. Calls are synchronous and the server **must** send a response back to such requests. While the server computes the response, the client is **waiting**. Casts are asynchronous: the server won't send a response back and therefore the client won't wait for one. Both requests are messages sent to the server, and will be handled in sequence. So far we have only used `GenServer.call/2`, to keep the same semantics as the Agent, but we will give `cast` a try when implementing subscriptions. Given we kept the same behaviour, all tests will still pass.\n\nEach request must be implemented as a specific callback. For `call/2` requests, we implement a `handle_call/3` callback that receives the `request`, the process from which we received the request (`_from`), and the current server state (`state`). The `handle_call/3` callback returns a tuple in the format `{:reply, reply, updated_state}`. The first element of the tuple, `:reply`, indicates that the server should send a reply back to the client. The second element, `reply`, is what will be sent to the client while the third, `updated_state` is the new server state.\n\nAnother Elixir feature we used in the implementation above are the nested traversal functions: `get_in/1`, `put_in/2`, and `pop_in/1`. Instead of keeping the `bucket` as our GenServer state, we defined a state map with a `bucket` key inside. This will be important as we also need to track subscribers as part of the GenServer state. These new functions make it straight-forward to manipulate data structures nested in other data structures.\n\nWith our GenServer in place, let's work on subscription, starting with the tests.\n\n## Implementing subscriptions\n\nOur new test will subscribe to a bucket and then assert that, as operations are performed against the bucket, we receive messages of said events.\n\nOpen up `test/kv/bucket_test.exs` and key this in:\n\n```elixir\n test \"subscribes to puts and deletes\" do\n {:ok, bucket} = start_supervised(KV.Bucket)\n KV.Bucket.subscribe(bucket)\n\n KV.Bucket.put(bucket, \"milk\", 3)\n assert_receive {:put, \"milk\", 3}\n\n # Also check it works even from another process\n spawn(fn -> KV.Bucket.delete(bucket, \"milk\") end)\n assert_receive {:delete, \"milk\"}\n end\n```\n\nIn order to make the test pass, we need to implement the `KV.Bucket.subscribe/1`. So let's add these three new functions to `KV.Bucket`:\n\n```elixir\n @doc \"\"\"\n Subscribes the current process to the bucket.\n \"\"\"\n def subscribe(bucket) do\n GenServer.cast(bucket, {:subscribe, self()})\n end\n\n @impl true\n def handle_cast({:subscribe, pid}, state) do\n Process.monitor(pid)\n state = update_in(state.subscribers, &MapSet.put(&1, pid))\n {:noreply, state}\n end\n\n @impl true\n def handle_info({:DOWN, _ref, _type, pid, _reason}, state) do\n state = update_in(state.subscribers, &MapSet.delete(&1, pid))\n {:noreply, state}\n end\n```\n\nOn subscription, we send a `cast/2` request with the current process identifier and implement its `handle_cast/2` callback that receives the `request` and the current server state. We then proceed to monitor the given `pid` and add it to the list of subscribers, which we are implementing using `MapSet`. The `handle_cast/2` callback returns a tuple in the format `{:noreply, updated_state}`. Note that in a real application we would have probably implemented it with a synchronous call, as it provides back pressure, instead of an asynchronous cast. We are doing it this way to illustrate how to implement a cast callback.\n\nThen, because we have monitored a process, once that process terminates, we will receive a \"DOWN message\". GenServers handle regular messages using the `handle_info/2` callback, which also typically return `{:noreply, updated_state}`. In this callback, we remove the PID that terminated from our list of subscribers.\n\nWe are almost there. We can see both `handle_cast/2` and `handle_info/2` callbacks assume there is a subscribers key in our state with a `MapSet`. So let's add it by updating the existing `init/1` to the following:\n\n```elixir\n @impl true\n def init(bucket) do\n state = %{\n bucket: bucket,\n subscribers: MapSet.new()\n }\n\n {:ok, state}\n end\n```\n\nAnd finally let's update the callbacks for `put/3` and `delete/2` to broadcast messages whenever they are invoked, like this:\n\n```elixir\n def handle_call({:put, key, value}, _from, state) do\n state = put_in(state.bucket[key], value)\n broadcast(state, {:put, key, value})\n {:reply, :ok, state}\n end\n\n def handle_call({:delete, key}, _from, state) do\n {value, state} = pop_in(state.bucket[key])\n broadcast(state, {:delete, key})\n {:reply, value, state}\n end\n\n defp broadcast(state, message) do\n for pid <- state.subscribers do\n send(pid, message)\n end\n end\n```\n\nThere is no need to modify the callback for `get/2`. And that's it, run the tests again, and our new test should pass!\n\n## Wiring it all up\n\nNow that our bucket deals with subscriptions, we need to expose this new functionality in our server. Let's once again start with the test.\n\nOpen up `test/kv/server_test.exs` and add this new test:\n\n```elixir\n test \"subscribes to buckets\", %{socket: socket, name: name} do\n assert send_and_recv(socket, \"CREATE #{name}\\r\\n\") == \"OK\\r\\n\"\n :gen_tcp.send(socket, \"SUBSCRIBE #{name}\\r\\n\")\n\n {:ok, other} = :gen_tcp.connect(~c\"localhost\", 4040, @socket_options)\n\n assert send_and_recv(other, \"PUT #{name} milk 3\\r\\n\") == \"OK\\r\\n\"\n assert :gen_tcp.recv(socket, 0, 1000) == {:ok, \"milk SET TO 3\\r\\n\"}\n\n assert send_and_recv(other, \"DELETE #{name} milk\\r\\n\") == \"OK\\r\\n\"\n assert :gen_tcp.recv(socket, 0, 1000) == {:ok, \"milk DELETED\\r\\n\"}\n end\n```\n\nThe test creates a bucket and subscribes to it. Then it opens up another TCP connection to send commands. For each command sent, we expect the subscribed socket to receive a message.\n\nTo make the test pass, we need to change `KV.Command` to parse the new `SUBSCRIBE` command and then run it. Open up `lib/kv/commands.ex` and then first change the `parse/1` definition to the following:\n\n```elixir\n def parse(line) do\n case String.split(line) do\n [\"SUBSCRIBE\", bucket] -> {:ok, {:subscribe, bucket}}\n [\"CREATE\", bucket] -> {:ok, {:create, bucket}}\n [\"GET\", bucket, key] -> {:ok, {:get, bucket, key}}\n [\"PUT\", bucket, key, value] -> {:ok, {:put, bucket, key, value}}\n [\"DELETE\", bucket, key] -> {:ok, {:delete, bucket, key}}\n _ -> {:error, :unknown_command}\n end\n end\n```\n\nWe added a new clause that converts \"SUBSCRIBE\" into a tuple. Now we need to match on this tuple within `run/1`. We can do so by adding a new clause at the bottom of `run/1`, with the following code:\n\n```elixir\n def run({:subscribe, bucket}, socket) do\n lookup(bucket, fn pid ->\n KV.Bucket.subscribe(pid)\n :inet.setopts(socket, active: true)\n receive_messages(socket)\n end)\n end\n\n defp receive_messages(socket) do\n receive do\n {:put, key, value} ->\n :gen_tcp.send(socket, \"#{key} SET TO #{value}\\r\\n\")\n receive_messages(socket)\n\n {:delete, key} ->\n :gen_tcp.send(socket, \"#{key} DELETED\\r\\n\")\n receive_messages(socket)\n\n {:tcp_closed, ^socket} ->\n {:error, :closed}\n\n # If we receive any message, including socket writes, we discard them\n _ ->\n receive_messages(socket)\n end\n end\n```\n\nLet's go over it by parts. We use the existing `lookup/2` private function to lookup for a bucket. If one is found, we subscribe the current process to the bucket. Then we call `:inet.setopts(socket, active: true)` (which we will explain soon) and `receive_messages/1`.\n\n`receive_messages/1` awaits for messages from the bucket and then calls itself again, becoming a loop. We match on `{:put, key, value}` and `{:delete, key}` and write to those events to the socket. We also match on `{:tcp_closed, ^socket}`, which is a message that will be delivered if the TCP socket closes, and use it to abort the loop. We discard any other message.\n\nAt this point you may be wondering: where does `{:tcp_closed, ^socket}` come from?\n\nSo far, when receiving messages from the socket, we used `:gen_tcp.recv/3` to perform calls that will block the current process until content is available. This is known as \"passive mode\". However, we can also ask `:gen_tcp` to stream messages to the current process inbox as they arrive, which is known as \"active mode\", which is exactly what we configured when we called `:inet.setopts(socket, active: true)`. Those messages have the shape `{:tcp, socket, data}`. When the socket is in active mode and it is closed, it delivers a `{:tcp_closed, socket}` message. Once we receive this message, we exit the loop, which will exit the connection process. Since the bucket is monitoring the process, it will automatically remove the subscription too. You could verify this in practice by adding a `COUNT SUBSCRIPTIONS` command that returns the number of subscribers for a given bucket.\n\nIn practice, many systems would prefer to call `:inet.setopts(socket, active: :once)` to specify only a single TCP message should be delivered to avoid overflowing message queues. Once the message is received, they call `:inet.setopts/2` again. In our case, we are simply discarding anything that arrives over the socket, so setting `active: true` is equally fine. In all scenarios, the benefit of using active mode is that the process can receive TCP messages as well as messages from other processes at the same time, instead of blocking on `:gen_tcp.recv/3`.\n\nTo wrap it all up, you should give our new feature a try in a distributed setting too. Start two `NODES=... PORT=... iex --sname ... -S mix` instances. In one of them, create a bucket. In the other, subscribe to the same bucket. Once you go back to the first shell, you will see that, even as you send commands to the bucket in one machine, the messages will be streamed to the other one. In other words, our subscription system is also distributed, and all we had to do is to send messages!\n\n## `call`, `cast` or `info`?\n\nSo far we have used three callbacks: `handle_call/3`, `handle_cast/2` and `handle_info/2`. Here is what we should consider when deciding when to use each:\n\n1. `handle_call/3` must be used for synchronous requests. This should be the default choice as waiting for the server reply is a useful back-pressure mechanism.\n\n2. `handle_cast/2` must be used for asynchronous requests, when you don't care about a reply. A cast does not guarantee the server has received the message and, for this reason, should be used sparingly. For example, the `subscribe/1` function we have defined in this chapter should have used `call/2`. We have used `cast/2` for educational purposes.\n\n3. `handle_info/2` must be used for all other messages a server may receive that are not sent via `GenServer.call/2` or `GenServer.cast/2`, including regular messages sent with `send/2`. The monitoring `:DOWN` messages are an example of this.\n\nTo help developers remember the differences between call, cast and info, the supported return values and more, we have a tiny [GenServer cheat sheet](https://elixir-lang.org/downloads/cheatsheets/gen-server.pdf).\n\n## Agents or GenServers?\n\nBefore moving forward to the last chapter, you may be wondering: in the future, should you use an `Agent` or a `GenServer`?\n\nAs we saw throughout this guide, agents are straight-forward to get started but they are limited in what they can do. Agents are effectively a subset of GenServers. In fact, agents are implemented on top of GenServers. As well as supervisors, the `Registry` module, and many other features you will find in both Erlang and Elixir.\n\nIn other words, GenServers are the most essential component for building concurrent and fault-tolerant systems in Elixir. They provide a robust and flexible framework for managing state and coordinating interactions between processes.\n\nFor those reasons, many adopt a rule of thumb to never use Agents and jump straight into GenServers instead. On the other hand, others are more than fine with using agents to store a bit of state here and there. Either way, you will be fine!\n\nThis is the last feature we have implemented for our distributed key-value store. In the next chapter, we will learn how to package our application before shipping it to production.\n" }, { "path": "lib/elixir/pages/mix-and-otp/introduction-to-mix.md", "content": "\n\n# Introduction to Mix\n\nIn this guide, we will build a complete Elixir application, with its own supervision tree, configuration, tests, and more.\n\nThe requirements for this guide are (see `elixir -v`):\n\n * Elixir 1.18.0 onwards\n * Erlang/OTP 27 onwards\n\nThe application works as a distributed key-value store. We are going to organize key-value pairs into buckets and distribute those buckets across multiple nodes. We will also build a simple client that allows us to connect to any of those nodes and send requests such as:\n\n```text\nCREATE shopping\nOK\n\nPUT shopping milk 1\nOK\n\nPUT shopping eggs 3\nOK\n\nGET shopping milk\n1\nOK\n\nDELETE shopping eggs\nOK\n```\n\nIn order to build our key-value application, we are going to use three main tools:\n\n * ***OTP*** *(Open Telecom Platform)* is a set of libraries that ships with Erlang. Erlang developers use OTP to build robust, fault-tolerant applications. In this chapter we will explore how many aspects from OTP integrate with Elixir, including supervision trees, event managers and more;\n\n * ***[Mix](`Mix`)*** is a build tool that ships with Elixir that provides tasks for creating, compiling, testing your application, managing its dependencies and much more;\n\n * ***[ExUnit](`ExUnit`)*** is a unit-test based framework that ships with Elixir.\n\nIn this chapter, we will create our first project using Mix and explore different features in OTP, Mix, and ExUnit as we go.\n\n> #### Source code {: .info}\n>\n> The final code for the application built in this guide is in [this repository](https://github.com/josevalim/kv) and can be used as a reference.\n\n> #### Is this guide required reading? {: .info}\n>\n> This guide is not required reading in your Elixir journey. We'll explain.\n>\n> As an Elixir developer, you will most likely use one of the many existing frameworks when writing your Elixir code. [Phoenix](https://phoenixframework.org) covers web applications, [Ecto](https://github.com/elixir-ecto/ecto) communicates with databases, you can craft embedded software with [Nerves](https://nerves-project.org/), [Nx](https://github.com/elixir-nx) powers machine learning and AI projects, [Membrane](https://membrane.stream/) assembles audio/video processing pipelines, [Broadway](https://elixir-broadway.org/) handles data ingestion and processing, and many more. These frameworks handle the lower level details of concurrency, distribution, and fault-tolerance, so you, as a user, can focus on your own needs and demands.\n>\n> On the other hand, if you want to learn the foundations these frameworks are built upon, and the abstractions that power the Elixir ecosystem, this guide will give you a tour through several important concepts.\n\n## Our first project\n\nWhen you install Elixir, besides getting the `elixir`, `elixirc`, and `iex` executables, you also get an executable Elixir script named `mix`.\n\nLet's create our first project by invoking `mix new` from the command line. We'll pass the project path as the argument (`kv`, in this case). By default, the application name and module name will be retrieved from the path. So we tell Mix that our main module should be the all-uppercase `KV`, instead of the default, which would have been `Kv`:\n\n```console\n$ mix new kv --module KV\n```\n\nMix will create a directory named `kv` with a few files in it:\n\n```text\n* creating README.md\n* creating .formatter.exs\n* creating .gitignore\n* creating mix.exs\n* creating lib\n* creating lib/kv.ex\n* creating test\n* creating test/test_helper.exs\n* creating test/kv_test.exs\n```\n\nLet's take a brief look at those generated files.\n\n> #### Executables in the `PATH` {: .info}\n>\n> Mix is an Elixir executable. This means that in order to run `mix`, you need to have both `mix` and `elixir` executables in your [`PATH`](https://en.wikipedia.org/wiki/PATH_(variable)). That's what happens when you install Elixir.\n\n## Project compilation\n\nA file named `mix.exs` was generated inside our new project folder (`kv`) and its main responsibility is to configure our project. Let's take a look at it:\n\n```elixir\ndefmodule KV.MixProject do\n use Mix.Project\n\n def project do\n [\n app: :kv,\n version: \"0.1.0\",\n elixir: \"~> 1.11\",\n start_permanent: Mix.env() == :prod,\n deps: deps()\n ]\n end\n\n # Run \"mix help compile.app\" to learn about applications\n def application do\n [\n extra_applications: [:logger]\n ]\n end\n\n # Run \"mix help deps\" to learn about dependencies\n defp deps do\n [\n # {:dep_from_hexpm, \"~> 0.3.0\"},\n # {:dep_from_git, git: \"https://github.com/elixir-lang/my_dep.git\", tag: \"0.1.0\"},\n ]\n end\nend\n```\n\nOur `mix.exs` defines two public functions: `project`, which returns project configuration like the project name and version, and `application`, which is used to generate an application file.\n\nThere is also a private function named `deps`, which is invoked from the `project` function, that defines our project dependencies. Defining `deps` as a separate function is not required, but it helps keep the project configuration tidy.\n\nMix also generates a file at `lib/kv.ex` with a module containing exactly one function, called `hello`:\n\n```elixir\ndefmodule KV do\n @moduledoc \"\"\"\n Documentation for KV.\n \"\"\"\n\n @doc \"\"\"\n Hello world.\n\n ## Examples\n\n iex> KV.hello()\n :world\n\n \"\"\"\n def hello do\n :world\n end\nend\n\n```\n\nThis structure is enough to compile our project:\n\n```console\n$ cd kv\n$ mix compile\n```\n\nWill output:\n\n```text\nCompiling 1 file (.ex)\nGenerated kv app\n```\n\nThe `lib/kv.ex` file was compiled and an application manifest named `kv.app` was generated. All compilation artifacts are placed inside the `_build` directory using the options defined in the `mix.exs` file.\n\nOnce the project is compiled, you can start a `iex` session inside the project by running the command below. The `-S mix` is necessary to load the project in the interactive shell:\n\n```console\n$ iex -S mix\n```\n\nWe are going to work on this `kv` project, making modifications and trying out the latest changes from a `iex` session. While you may start a new session whenever there are changes to the project source code, you can also recompile the project from within `iex` with the `recompile` helper, like this:\n\n```elixir\niex> recompile()\nCompiling 1 file (.ex)\n:ok\niex> recompile()\n:noop\n```\n\nIf anything had to be compiled, you see some informative text, and get the `:ok` atom back, otherwise the function is silent, and returns `:noop`.\n\n## Running tests\n\nMix also generated the appropriate structure for running our project tests. Mix projects usually follow the convention of having a `_test.exs` file in the `test` directory for each file in the `lib` directory. For this reason, we can already find a `test/kv_test.exs` corresponding to our `lib/kv.ex` file. It doesn't do much at this point:\n\n```elixir\ndefmodule KVTest do\n use ExUnit.Case\n doctest KV\n\n test \"greets the world\" do\n assert KV.hello() == :world\n end\nend\n```\n\nIt is important to note a couple of things:\n\n1. the test file is an Elixir script file (`.exs`). This is convenient because we don't need to compile test files before running them;\n\n2. we define a test module named `KVTest`, in which we [`use ExUnit.Case`](`ExUnit.Case`) to inject the testing API;\n\n3. we use one of the imported macros, `ExUnit.DocTest.doctest/1`, to indicate that the `KV` module contains doctests (we will discuss those in a later chapter);\n\n4. we use the `ExUnit.Case.test/2` macro to define a simple test;\n\nMix also generated a file named `test/test_helper.exs` which is responsible for setting up the test framework:\n\n```elixir\nExUnit.start()\n```\n\nThis file will be required by Mix every time before we run our tests. We can run tests with:\n\n```console\n$ mix test\nCompiled lib/kv.ex\nGenerated kv app\nRunning ExUnit with seed: 540224, max_cases: 16\n..\n\nFinished in 0.04 seconds\n1 doctest, 1 test, 0 failures\n```\n\nNotice that by running `mix test`, Mix has compiled the source files and generated the application manifest once again. This happens because Mix supports multiple environments, which we will discuss later in this chapter.\n\nFurthermore, you can see that ExUnit prints a dot for each successful test and automatically randomizes tests too. Let's make the test fail on purpose and see what happens.\n\nChange the assertion in `test/kv_test.exs` to the following:\n\n```elixir\nassert KV.hello() == :oops\n```\n\nNow run `mix test` again (notice this time there will be no compilation):\n\n```text\n 1) test greets the world (KVTest)\n test/kv_test.exs:5\n Assertion with == failed\n code: assert KV.hello() == :oops\n left: :world\n right: :oops\n stacktrace:\n test/kv_test.exs:6: (test)\n\n.\n\nFinished in 0.05 seconds\n1 doctest, 1 test, 1 failure\n```\n\nFor each failure, ExUnit prints a detailed report, containing the test name with the test case, the code that failed and the values for the left side and right side (RHS) of the `==` operator.\n\nIn the second line of the failure, right below the test name, there is the location where the test was defined. If you copy the test location in full, including the file and line number, and append it to `mix test`, Mix will load and run just that particular test:\n\n```console\n$ mix test test/kv_test.exs:5\n```\n\nThis shortcut will be extremely useful as we build our project, allowing us to quickly iterate by running a single test.\n\nFinally, the stacktrace relates to the failure itself, giving information about the test and often the place the failure was generated from within the source files.\n\n## Automatic code formatting\n\nOne of the files generated by `mix new` is the `.formatter.exs`. Elixir ships with a code formatter that is capable of automatically formatting our codebase according to a consistent style. The formatter is triggered with the `mix format` task. The generated `.formatter.exs` file configures which files should be formatted when `mix format` runs.\n\nTo give the formatter a try, change a file in the `lib` or `test` directories to include extra spaces or extra newlines, such as `def hello do`, and then run `mix format`.\n\nMost editors provide built-in integration with the formatter, allowing a file to be formatted on save or via a chosen keybinding. If you are learning Elixir, editor integration gives you useful and quick feedback when learning the Elixir syntax.\n\nFor companies and teams, we recommend developers to run `mix format --check-formatted` on their continuous integration servers, ensuring all current and future code follows the standard.\n\nYou can learn more about the code formatter by checking [the format task documentation](`mix format`) or by reading [the release announcement for Elixir v1.6](https://elixir-lang.org/blog/2018/01/17/elixir-v1-6-0-released/), the first version to include the formatter.\n\n## Environments\n\nMix provides the concept of \"environments\". They allow a developer to customize compilation and other options for specific scenarios. By default, Mix understands three environments:\n\n * `:dev` — the one in which Mix tasks (like `compile`) run by default\n * `:test` — used by `mix test`\n * `:prod` — the one you will use to run your project in production\n\nThe environment applies only to the current project. As we will see in future chapters, any dependency you add to your project will by default run in the `:prod` environment.\n\nCustomization per environment can be done by accessing the `Mix.env/0` in your `mix.exs` file, which returns the current environment as an atom. That's what we have used in the `:start_permanent` options:\n\n```elixir\ndef project do\n [\n ...,\n start_permanent: Mix.env() == :prod,\n ...\n ]\nend\n```\n\nWhen true, the `:start_permanent` option starts your application in permanent mode, which means the Erlang VM will crash if your application's supervision tree shuts down. Notice we don't want this behavior in dev and test because it is useful to keep the VM instance running in those environments for troubleshooting purposes.\n\nMix will default to the `:dev` environment, except for the `test` task that will default to the `:test` environment. The environment can be changed via the `MIX_ENV` environment variable:\n\n```console\n$ MIX_ENV=prod mix compile\n```\n\nOr on Windows:\n\n```batch\n> set \"MIX_ENV=prod\" && mix compile\n```\n\n> #### Mix in production {: .warning}\n>\n> Mix is a **build tool** and, as such, it is not expected to be available in production. Therefore, it is recommended to access `Mix.env/0` only in configuration files and inside `mix.exs`, never in your application code (`lib`).\n\n## Exploring\n\nThere is much more to Mix, and we will continue to explore it as we build our project. A general overview is available on the [Mix documentation](`Mix`) and you can always invoke the help task to list all available tasks:\n\n```console\n$ mix help\n$ mix help compile\n```\n\nNow let's move forward and add the first modules and functions to our application.\n" }, { "path": "lib/elixir/pages/mix-and-otp/releases.md", "content": "\n\n# Releases\n\nNow that our application is ready, you may be wondering how we can package our application to run in production. After all, all of our code so far depends on Erlang and Elixir versions that are installed in your current system. To achieve this goal, Elixir provides releases.\n\nA release is a self-contained directory that consists of your application code, all of its dependencies, plus the whole Erlang Virtual Machine (VM) and runtime. Once a release is assembled, it can be packaged and deployed to a target as long as the target runs on the same operating system (OS) distribution and version as the machine that assembled the release.\n\nTo get started, simply run `mix release` while setting `MIX_ENV=prod`:\n\n```console\n$ MIX_ENV=prod mix release\nCompiling 4 files (.ex)\nGenerated kv app\n* assembling kv-0.1.0 on MIX_ENV=prod\n* using config/runtime.exs to configure the release at runtime\n\nRelease created at _build/prod/rel/kv\n\n # To start your system\n _build/prod/rel/kv/bin/kv start\n\nOnce the release is running:\n\n # To connect to it remotely\n _build/prod/rel/kv/bin/kv remote\n\n # To stop it gracefully (you may also send SIGINT/SIGTERM)\n _build/prod/rel/kv/bin/kv stop\n\nTo list all commands:\n\n _build/prod/rel/kv/bin/kv\n```\n\nExcellent! A release was assembled in `_build/prod/rel/kv`. Everything you need to run your application is inside that directory. In particular, there is a `bin/kv` file which is the entry point to your system. It supports multiple commands, such as:\n\n * `bin/kv start`, `bin/kv start_iex`, `bin/kv restart`, and `bin/kv stop` — for general management of the release\n\n * `bin/kv rpc COMMAND` and `bin/kv remote` — for running commands on the running system or to connect to the running system\n\n * `bin/kv eval COMMAND` — to start a fresh system that runs a single command and then shuts down\n\n * `bin/kv daemon` and `bin/kv daemon_iex` — to start the system as a daemon on Unix-like systems\n\n * `bin/kv install` — to install the system as a service on Windows machines\n\nIf you run `bin/kv start_iex` inside the release directory, it will start the system using a short name (`--sname`) equal to the release name, which in this case is `kv`. The next step is to start two instances, on different ports and different names, as we did earlier on. But before we do this, let's talk a bit about the benefits of releases.\n\n## Why releases?\n\nReleases allow developers to precompile and package all of their code and the runtime into a single unit. The benefits of releases are:\n\n * Code preloading. The VM has two mechanisms for loading code: interactive and embedded. By default, it runs in the interactive mode which dynamically loads modules when they are used for the first time. The first time your application calls `Enum.map/2`, the VM will find the `Enum` module and load it. There's a downside. When you start a new server in production, it may need to load many other modules, causing the first requests to have an unusual spike in response time. Releases run in embedded mode, which loads all available modules upfront, guaranteeing your system is ready to handle requests after booting.\n\n * Configuration and customization. Releases give developers fine grained control over system configuration and the VM flags used to start the system.\n\n * Self-contained. A release does not require the source code to be included in your production artifacts. All of the code is precompiled and packaged. Releases do not even require Erlang or Elixir on your servers, as they include the Erlang VM and its runtime by default. Furthermore, both Erlang and Elixir standard libraries are stripped to bring only the parts you are actually using.\n\n * Multiple releases. You can assemble different releases with different configuration per application or even with different applications altogether.\n\nWe have written extensive documentation on releases, so [please check the official documentation for more information](`mix release`). For now, we will continue exploring some of the features outlined above.\n\n## Configuring releases\n\nReleases also provide built-in hooks for configuring almost every need of the production system:\n\n * `config/config.exs` — provides build-time application configuration, which is executed before our application compiles. This file often imports configuration files based on the environment, such as `config/dev.exs` and `config/prod.exs`.\n\n * `config/runtime.exs` — provides runtime application configuration. It is executed every time the release boots and is further extensible via config providers.\n\n * `rel/env.sh.eex` and `rel/env.bat.eex` — template files that are copied into every release and executed on every command to set up environment variables, including ones specific to the VM, and the general environment.\n\n * `rel/vm.args.eex` — a template file that is copied into every release and provides static configuration of the Erlang Virtual Machine and other runtime flags.\n\nIn this case, we already have specified a `config/runtime.exs` that deals with both `PORT` and `NODES` environment variables. Furthermore, while releases don't accept a `--sname` parameter, they do allow us to set the name via the `RELEASE_NODE` env var. Therefore, we can start two copies of the system by jumping into `_build/prod/rel/kv` and typing this (remember to adjust `@computer-name` to your actual computer name):\n\n```console\n$ NODES=\"foo@computer-name,bar@computer-name\" PORT=4040 RELEASE_NODE=\"foo\" bin/kv start_iex\n```\n\n```console\n$ NODES=\"foo@computer-name,bar@computer-name\" PORT=4041 RELEASE_NODE=\"bar\" bin/kv start_iex\n```\n\nTo verify it all worked out, you can type `Node.list` in the IEx section and see if it returns the other node. If it doesn't, you can start diagnosing, first by comparing the node names within each `iex>` prompt and calling `Node.connect/1` directly. With applications running, you can `telnet` into them as usual too.\n\nWhile the above is enough to get started, you may want to perform advanced configuration based on the environment you are replying to. Releases provide scripts for that, which are great to automate based on host, network, or cloud settings.\n\n## Operating System scripts\n\nEvery release contains an environment file, named `env.sh` on Unix-like systems and `env.bat` on Windows machines, that executes before the Elixir system starts. In this file, you can execute any OS-level code, such as invoke other applications, set environment variables and so on. Some of those environment variables can even configure how the release itself runs.\n\nFor instance, releases run using short-names (`--sname`). However, if you want to actually run a distributed key-value store in production, you will need multiple nodes and start the release with the `--name` option. We can achieve this by setting the `RELEASE_DISTRIBUTION` environment variable inside the `env.sh` and `env.bat` files. Mix already has a template for said files which we can customize, so let's ask Mix to copy them to our application:\n\n $ mix release.init\n * creating rel/vm.args.eex\n * creating rel/remote.vm.args.eex\n * creating rel/env.sh.eex\n * creating rel/env.bat.eex\n\nIf you open up `rel/env.sh.eex`, you will see:\n\n```shell\n#!/bin/sh\n\n# # Sets and enables heart (recommended only in daemon mode)\n# case $RELEASE_COMMAND in\n# daemon*)\n# HEART_COMMAND=\"$RELEASE_ROOT/bin/$RELEASE_NAME $RELEASE_COMMAND\"\n# export HEART_COMMAND\n# export ELIXIR_ERL_OPTIONS=\"-heart\"\n# ;;\n# *)\n# ;;\n# esac\n\n# # Set the release to load code on demand (interactive) instead of preloading (embedded).\n# export RELEASE_MODE=interactive\n\n# # Set the release to work across nodes.\n# # RELEASE_DISTRIBUTION must be \"sname\" (local), \"name\" (distributed) or \"none\".\n# export RELEASE_DISTRIBUTION=name\n# export RELEASE_NODE=<%= @release.name %>\n```\n\nThe steps necessary to work across nodes is already commented out as an example. You can enable full distribution by setting the `RELEASE_DISTRIBUTION` variable to `name`.\n\nIf you are on Windows, you will have to open up `rel/env.bat.eex`, where you will find this:\n\n```bat\n@echo off\nrem Set the release to load code on demand (interactive) instead of preloading (embedded).\nrem set RELEASE_MODE=interactive\n\nrem Set the release to work across nodes.\nrem RELEASE_DISTRIBUTION must be \"sname\" (local), \"name\" (distributed) or \"none\".\nrem set RELEASE_DISTRIBUTION=name\nrem set RELEASE_NODE=<%= @release.name %>\n```\n\nOnce again, set the `RELEASE_DISTRIBUTION` variable to `name` and you are good to go!\n\n## VM arguments\n\nThe `rel/vm.args.eex` allows you to specify low-level flags that control how the Erlang VM and its runtime operate. You specify entries as if you were specifying arguments in the command line with code comments also supported. Here is the default generated file:\n\n ## Customize flags given to the VM: https://www.erlang.org/doc/man/erl.html\n ## -mode/-name/-sname/-setcookie are configured via env vars, do not set them here\n\n ## Increase number of concurrent ports/sockets\n ##+Q 65536\n\n ## Tweak GC to run more often\n ##-env ERL_FULLSWEEP_AFTER 10\n\nYou can see [a complete list of VM arguments and flags in the Erlang documentation](https://www.erlang.org/doc/man/erl.html).\n\n## Summing up\n\nThroughout the guide, we have built a very simple distributed key-value store as an opportunity to explore many constructs like generic servers, supervisors, tasks, agents, applications and more. Not only that, we have written tests for the whole application, got familiar with ExUnit, and learned how to use the Mix build tool to accomplish a wide range of tasks.\n\nIf you are looking for a distributed key-value store to use in production, you should definitely look into [Riak](https://riak.com/products/riak-kv/), which also runs in the Erlang VM. In Riak, the buckets are replicated and stored across several nodes to avoid data loss.\n\nOf course, Elixir can be used for much more than distributed key-value stores. Embedded systems, data-processing and data-ingestion, web applications, audio/video streaming systems, machine learning, and others are many of the different domains Elixir excels at. We hope this guide has prepared you to explore any of those domains or any future domain you may desire to bring Elixir into.\n\nHappy coding!\n" }, { "path": "lib/elixir/pages/mix-and-otp/supervisor-and-application.md", "content": "\n\n# Registries and supervision trees\n\nIn the [previous chapter](agents.md), we used agents to represent our buckets. In the [introduction to mix](introduction-to-mix.md), we specified we would like to name each bucket so we can do the following:\n\n```text\nCREATE shopping\nOK\n\nPUT shopping milk 1\nOK\n\nGET shopping milk\n1\nOK\n```\n\nIn the example session above we interacted with the \"shopping\" bucket by referencing its name. Therefore, an important feature in our key-value store is to give names to processes.\n\nWe have also learned in the previous chapter we can already name our buckets. For example:\n\n```elixir\niex> KV.Bucket.start_link(name: :shopping)\n{:ok, #PID<0.43.0>}\niex> KV.Bucket.put(:shopping, \"milk\", 1)\n:ok\niex> KV.Bucket.get(:shopping, \"milk\")\n1\n```\n\nHowever, naming dynamic processes with atoms is a terrible idea! If we use atoms, we would need to convert the bucket name (often received from an external client) to atoms, and **we should never convert user input to atoms**. This is because atoms are not garbage collected. Once an atom is created, it is never reclaimed. Generating atoms from user input would mean the user can inject enough different names to exhaust our system memory!\n\nIn practice, it is more likely you will reach the Erlang VM limit for the maximum number of atoms before you run out of memory, which will bring your system down regardless.\n\nLuckily, Elixir (and Erlang) comes with built-in abstractions for naming processes, called name registries, each with different trade-offs which we will explore throughout these guides.\n\n## Local, decentralized, and scalable registry\n\nElixir ships with a single-node process registry module aptly called `Registry`. Its main feature is that you can use any Elixir value to name a process, not only atoms. Let's take it for a spin in `iex`:\n\n```elixir\niex> Registry.start_link(name: KV, keys: :unique)\niex> name = {:via, Registry, {KV, \"shopping\"}}\niex> KV.Bucket.start_link(name: name)\n{:ok, #PID<0.43.0>}\niex> KV.Bucket.put(name, \"milk\", 1)\n:ok\niex> KV.Bucket.get(name, \"milk\")\n1\n```\n\nAs you can see, instead of passing an atom to the `:name` option, we pass a tuple of shape `{:via, registry_module, {registry_name, process_name}}`, and everything just worked. You could have used anything as the `process_name`, even an integer or a map! That's because all of Elixir built-in behaviours, agents, supervisors, tasks, etc, are compatible with naming registries, as long as you pass them using the \"via\" tuple format.\n\nTherefore, all we need to do to name our buckets is to start a `Registry`, using `Registry.start_link/1`. But you may be wondering, where exactly should we place that?\n\n## Understanding applications\n\nEvery Elixir project is an application. Elixir itself is defined in an application named `:elixir`. The `ExUnit.Case` module is part of the `:ex_unit` application. And so forth.\n\nIn fact, we have been working inside an application this entire time. Every time we changed a file and ran `mix compile`, we could see a `Generated kv app` message in the compilation output.\n\nWe can find the generated `.app` file at `_build/dev/lib/kv/ebin/kv.app`. Let's have a look at its contents:\n\n```erlang\n{application,kv,\n [{applications,[kernel,stdlib,elixir,logger]},\n {description,\"kv\"},\n {modules,['Elixir.KV','Elixir.KV.Bucket']},\n {registered,[]},\n {vsn,\"0.1.0\"}]}.\n```\n\nThis file contains Erlang terms (written using Erlang syntax). Even though we are not familiar with Erlang, it is easy to guess this file holds our application definition. It contains our application `version`, all the modules defined by it, as well as a list of applications we depend on, like Erlang's `kernel`, `elixir` itself, and `logger`.\n\n> The `logger` application ships as part of Elixir. We stated that our application needs it by specifying it in the `:extra_applications` list in `mix.exs`. See the [official documentation](`Logger`) for more information.\n\nIn a nutshell, an application consists of all the modules defined in the `.app` file, including the `.app` file itself. The application itself is located at the `_build/dev/lib/kv` folder and typically has only two directories: `ebin`, for Elixir artifacts, such as `.beam` and `.app` files, and `priv`, with any other artifact or asset you may need in your application.\n\nAlthough Mix generates and maintains the `.app` file for us, we can customize its contents by adding new entries to the `application/0` function inside the `mix.exs` project file. We are going to do our first customization soon.\n\n### Starting applications\n\nEach application in our system can be started and stopped. The rules for starting and stopping an application are also defined in the `.app` file. When we invoke `iex -S mix`, Mix compiles our application and then starts it.\n\nLet's see this in practice. Start a console with `iex -S mix` and try:\n\n```elixir\niex> Application.start(:kv)\n{:error, {:already_started, :kv}}\n```\n\nOops, it's already started. Mix starts the current application and all of its dependencies automatically. This is also true for `mix test` and many other Mix commands.\n\nWe can, however, stop our `:kv` application, as well as the `:logger` application:\n\n```elixir\niex> Application.stop(:kv)\n:ok\niex> Application.stop(:logger)\n:ok\n```\n\nAnd let's try to start our application again:\n\n```elixir\niex> Application.start(:kv)\n{:error, {:not_started, :logger}}\n```\n\nNow we get an error because an application that `:kv` depends on (`:logger` in this case) isn't started. We need to either start each application manually in the correct order or call `Application.ensure_all_started/1` as follows:\n\n```elixir\niex> Application.ensure_all_started(:kv)\n{:ok, [:logger, :kv]}\n```\n\nIn practice, our tools always start our applications for us, and you don't have to worry about the above, but it is good to know how it all works behind the scenes.\n\n### The application callback\n\nWhenever we invoke `iex -S mix`, Mix automatically starts our application by calling `Application.start(:kv)`. But can we customize what happens when our application starts? As a matter of fact, we can! To do so, we define an application callback.\n\nThe first step is to tell our application definition (for example, our `.app` file) which module is going to implement the application callback. Let's do so by opening `mix.exs` and changing `def application` to the following:\n\n```elixir\n def application do\n [\n extra_applications: [:logger],\n mod: {KV, []}\n ]\n end\n```\n\nThe `:mod` option specifies the \"application callback module\", followed by the arguments to be passed on application start. The application callback module can be any module that invokes `use Application`. Since we have specified `KV` as the module callback, let's change the `KV` module defined in `lib/kv.ex` to the following:\n\n```elixir\ndefmodule KV do\n use Application\nend\n```\n\nNow run `mix test` and you will see a couple things happening. First of all, you will get a compilation warning:\n\n```text\nCompiling 1 file (.ex)\n warning: function start/2 required by behaviour Application is not implemented (in module KV)\n │\n 1 │ defmodule KV do\n │ ~~~~~~~~~~~~~~~\n │\n └─ lib/kv.ex:1: KV (module)\n```\n\nThis warning is telling us that `use Application` actually defines a behaviour, which expects us to implement to a `start/2` function in our `KV` module.\n\nThen our application does not even boot because the `start/2` function is not actually implemented:\n\n```text\n18:29:39.109 [notice] Application kv exited: exited in: KV.start(:normal, [])\n ** (EXIT) an exception was raised:\n ** (UndefinedFunctionError) function KV.start/2 is undefined or private\n```\n\nImplementing the `start/2` callback is relatively straight-forward, all we need to do is to start a supervision tree, and return `{:ok, root_supervisor_pid}`. The `Supervisor.start_link/2` function does precisely that, it only expects a list of children and the supervision strategy. Let's just pass an empty list of children for now:\n\n```elixir\ndefmodule KV do\n use Application\n\n # The @impl true annotation says we are implementing a callback\n @impl true\n def start(_type, _args) do\n Supervisor.start_link([], strategy: :one_for_one)\n end\nend\n```\n\nNow run `mix test` again and our app should boot but we should see one failure. When we changed the `KV` module, we broke the boilerplate test case which tested the `KV.hello/0` function. You can simply remove that test case and we are back to a green suite.\n\nWe wrote very little code but we did something incredibly powerful. We now have a function, `KV.start/2` that is invoked whenever your application starts. This gives us the perfect place to start our key-value registry. The `Application` module also allows us to define a `stop/1` callback and other functionality. You can check the `Application` and `Supervisor` modules for extensive documentation on their uses.\n\nLet's finally start our registry.\n\n## Supervision trees\n\nNow that we have the `start/2` callback, we can finally go ahead and start our registry. You may be tempted to do it like this:\n\n```elixir\n def start(_type, _args) do\n Registry.start_link(name: KV, keys: :unique)\n Supervisor.start_link([], strategy: :one_for_one)\n end\n```\n\nHowever, this would not be a good idea. In Elixir, we typically start processes inside supervision trees. In fact, we rarely use the `start_link` functions to start processes (except at the root of the supervision tree itself). Instead, do this:\n\n```elixir\n def start(_type, _args) do\n children = [\n {Registry, name: KV, keys: :unique}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n end\n```\n\nA supervisor receives one or more child specifications that tell it exactly how to start each child. A child specification is typically represented by a `{module, options}` pair, as shown above, and often as simply the module name. Sometimes, these children are supervisors themselves, giving us supervision trees.\n\nLet's take it for a spin and see if we can indeed name our buckets using our new registry. Let's make sure to start a new `iex -S mix` (`recompile()` is not enough, as it does not reload your supervision tree) and then:\n\n```iex\niex> name = {:via, Registry, {KV, \"shopping\"}}\niex> KV.Bucket.start_link(name: name)\n{:ok, #PID<0.43.0>}\niex> KV.Bucket.put(name, \"milk\", 1)\n:ok\niex> KV.Bucket.get(name, \"milk\")\n1\n```\n\nPerfect, this time we didn't need to start the registry inside `iex`, as it was started as part of the application itself.\n\nBy starting processes inside supervisors, we gain important properties such as:\n\n * **Introspection**: for each application, you can fully introspect and visualize each process in its supervision tree, its memory usage, message queue, etc\n\n * **Resilience**: when a process fails for an unexpected reason, its supervisor controls if and how those processes should be restarted, leading to self-healing systems\n\n * **Graceful shutdown**: when your application is shutting down, the children of a supervision tree are terminated in the opposite order they were started, leading to graceful shutdowns\n\n## Projects or applications?\n\nMix makes a distinction between projects and applications. Based on the contents of our `mix.exs` file, we would say we have a Mix project that defines the `:kv` application.\n\nWhen we say \"project\" you should think about Mix. Mix is the tool that manages your project. It knows how to compile your project, test your project and more. It also knows how to compile and start the application relevant to your project.\n\nWhen we talk about applications, we talk about OTP. Applications are the entities that are started and stopped as a whole by the runtime. You can learn more about applications and how they relate to booting and shutting down of your system as a whole in the documentation for the `Application` module.\n\n## Summing up\n\nWe learned important concepts in this chapter:\n\n * Naming registries allow us to find processes in a given machine (or, as we will see in the future, even in a cluster)\n\n * Applications bundle our modules, its dependencies, and how code starts and stops\n\n * Processes are started as part of supervisors for introspection and fault-tolerance\n\nIn the next chapter, we will tie it all up by making sure all our buckets are named and supervised. To do so, we will learn a new tool called dynamic supervisors.\n" }, { "path": "lib/elixir/pages/mix-and-otp/task-and-gen-tcp.md", "content": "\n\n# Task and gen_tcp\n\nIn this chapter, we are going to learn how to use Erlang's [`:gen_tcp` module](`:gen_tcp`) to serve requests. This provides a great opportunity to explore Elixir's `Task` module. In future chapters, we will expand our server so that it can actually interact with buckets.\n\n## Echo server\n\nWe will start our TCP server by first implementing an echo server. It will send a response with the text it received in the request. We will slowly improve our server until it is supervised and ready to handle multiple connections.\n\nA TCP server, in broad strokes, performs the following steps:\n\n 1. Listens to a port until the port is available and it gets hold of the socket\n 2. Waits for a client connection on that port and accepts it\n 3. Reads the client request and writes a response back\n\nLet's implement those steps. Create a new `lib/kv/server.ex` and add the following functions:\n\n```elixir\ndefmodule KV.Server do\n require Logger\n\n def accept(port) do\n # The options below mean:\n #\n # 1. `:binary` - receives data as binaries (instead of lists)\n # 2. `packet: :line` - receives data line by line\n # 3. `active: false` - blocks on `:gen_tcp.recv/2` until data is available\n # 4. `reuseaddr: true` - allows us to reuse the address if the listener crashes\n #\n {:ok, socket} =\n :gen_tcp.listen(port, [:binary, packet: :line, active: false, reuseaddr: true])\n Logger.info(\"Accepting connections on port #{port}\")\n loop_acceptor(socket)\n end\n\n defp loop_acceptor(socket) do\n {:ok, client} = :gen_tcp.accept(socket)\n serve(client)\n loop_acceptor(socket)\n end\n\n defp serve(socket) do\n socket\n |> read_line()\n |> write_line(socket)\n\n serve(socket)\n end\n\n defp read_line(socket) do\n {:ok, data} = :gen_tcp.recv(socket, 0)\n data\n end\n\n defp write_line(line, socket) do\n :gen_tcp.send(socket, line)\n end\nend\n```\n\nWe are going to start our server by calling `KV.Server.accept(4040)`, where 4040 is the port. The first step in `accept/1` is to listen to the port until the socket becomes available and then call `loop_acceptor/1`. `loop_acceptor/1` is a loop accepting client connections. For each accepted connection, we call `serve/1`.\n\n`serve/1` is another loop that reads a line from the socket and writes those lines back to the socket. Note that the `serve/1` function uses the pipe operator `|>/2` to express this flow of operations. The pipe operator evaluates the left side and passes its result as the first argument to the function on the right side. The example above:\n\n```elixir\nsocket |> read_line() |> write_line(socket)\n```\n\nis equivalent to:\n\n```elixir\nwrite_line(read_line(socket), socket)\n```\n\nThe `read_line/1` implementation receives data from the socket using `:gen_tcp.recv/2` and `write_line/2` writes to the socket using `:gen_tcp.send/2`.\n\nNote that `serve/1` is an infinite loop called sequentially inside `loop_acceptor/1`, so the tail call to `loop_acceptor/1` is never reached and could be avoided. However, as we shall see, we will need to execute `serve/1` in a separate process, so we will need that tail call soon.\n\nThis is pretty much all we need to implement our echo server. Let's give it a try!\n\nStart an IEx session inside the `kv_server` application with `iex -S mix`. Inside IEx, run:\n\n```elixir\niex> KV.Server.accept(4040)\n```\n\nThe server is now running, and you will even notice the console is blocked. Let's use [a `telnet` client](https://en.wikipedia.org/wiki/Telnet) to access our server. There are clients available on most operating systems, and their command lines are generally similar:\n\n```console\n$ telnet 127.0.0.1 4040\nTrying 127.0.0.1...\nConnected to localhost.\nEscape character is '^]'.\nhello\nhello\nis it me\nis it me\nyou are looking for?\nyou are looking for?\n```\n\nType \"hello\", press enter, and you will get \"hello\" back. Excellent!\n\nMy particular telnet client can be exited by typing `ctrl + ]`, typing `quit`, and pressing ``, but your client may require different steps.\n\nOnce you exit the telnet client, you will likely see an error in the IEx session:\n\n```text\n** (MatchError) no match of right hand side value: {:error, :closed}\n (kv) lib/kv/server.ex:45: KV.Server.read_line/1\n (kv) lib/kv/server.ex:37: KV.Server.serve/1\n (kv) lib/kv/server.ex:30: KV.Server.loop_acceptor/1\n```\n\nThat's because we were expecting data from `:gen_tcp.recv/2` but the client closed the connection. We need to handle such cases better in future revisions of our server.\n\nFor now, there is a more important bug we need to fix: what happens if our TCP acceptor crashes? Since there is no supervision, the server dies and we won't be able to serve more requests, because it won't be restarted. That's why we must move our server to a supervision tree.\n\n## Tasks\n\nWhenever you have an existing function and you simply want to execute it when your application starts, the `Task` module is exactly what you need. For example, it has a `Task.start_link/1` function that receives an anonymous function and executes it inside a new process that will be part of a supervision tree.\n\nLet's give it a try. Open up `lib/kv.ex` and let's add a new child:\n\n```elixir\n def start(_type, _args) do\n children = [\n {Registry, name: KV, keys: :unique},\n {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},\n {Task, fn -> KV.Server.accept(4040) end}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n end\n```\n\nWith this change, we are saying that we want to run `KV.Server.accept(4040)` as a task. We are hardcoding the port for now but we will make this a configuration in later chapters. As usual, we've passed a two-element tuple as a child specification, which in turn will invoke `Task.start_link/1`.\n\nNow that the server is part of the supervision tree, it should start automatically when we run the application. Run `iex -S mix` to boot the app and use the `telnet` client to make sure that everything still works:\n\n```console\n$ telnet 127.0.0.1 4321\nTrying 127.0.0.1...\nConnected to localhost.\nEscape character is '^]'.\nsay you\nsay you\nsay me\nsay me\n```\n\nYes, it works! However, can it handle more than one client?\n\nTry to connect two telnet clients at the same time. When you do so, you will notice that the second client doesn't echo:\n\n```console\n$ telnet 127.0.0.1 4321\nTrying 127.0.0.1...\nConnected to localhost.\nEscape character is '^]'.\nhello\nhello?\nHELLOOOOOO?\n```\n\nIt doesn't seem to work at all. That's because we are serving requests in the same process that are accepting connections. When one client is connected, we can't accept another client.\n\n## Adding (flawed) concurrency\n\nIn order to make our server handle simultaneous connections, we need to have one process working as an acceptor that spawns other processes to serve requests. One solution would be to change:\n\n```elixir\ndefp loop_acceptor(socket) do\n {:ok, client} = :gen_tcp.accept(socket)\n serve(client)\n loop_acceptor(socket)\nend\n```\n\nto also use `Task.start_link/1`:\n\n```elixir\ndefp loop_acceptor(socket) do\n {:ok, client} = :gen_tcp.accept(socket)\n {:ok, pid} = Task.start_link(fn -> serve(client) end)\n :ok = :gen_tcp.controlling_process(client, pid)\n loop_acceptor(socket)\nend\n```\n\nIn the new acceptor loop, we are starting a new task every time there is a new client. Now, if you attempt to connect two clients at the same time, it should work!\n\nOr does it? For example, what happens when you exit one telnet session? The other session should crash! The reason of this crash is two fold:\n\n1. We have a bug in our server where we don't expect `:gen_tcp.recv/2` to return an `{:error, :closed}` tuple\n\n2. Because each server task is linked to the acceptor process, if one task crashes, the acceptor process will also crash, taking down all other tasks and clients\n\nAn important rule of thumb throughout this guide is to always start processes as children of supervisors. The code above is an excellent example of what happens when we don't. If we don't isolate the different parts of our systems, failures can now cascade through our system, as it would happen in other languages.\n\nTo fix this, we could use a `DynamicSupervisor`, but tasks also provide a specialized `Task.Supervisor` which has better ergonomics and is optimized for supervising tasks themselves. Let's give it a try.\n\n## Adding a task supervisor\n\nLet's change `start/2` in `lib/kv.ex` once more, to add the task supervisor to our tree:\n\n```elixir\n def start(_type, _args) do\n children = [\n {Registry, name: KV, keys: :unique},\n {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},\n {Task.Supervisor, name: KV.ServerSupervisor},\n {Task, fn -> KV.Server.accept(4040) end}\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n end\n```\n\nWe'll now start a `Task.Supervisor` process with name `KV.TaskSupervisor`. Keep in mind that the order children are started matters. For example, the acceptor must come last because, if it comes first, it means our application can start accepting requests before the `Task.Supervisor` is running or before we can locate buckets. Shutting down an application will also stop the children in reverse order, guaranteeing a clean termination.\n\nNow we need to change `loop_acceptor/1` to use `Task.Supervisor` to serve each request:\n\n```elixir\ndefp loop_acceptor(socket) do\n {:ok, client} = :gen_tcp.accept(socket)\n {:ok, pid} = Task.Supervisor.start_child(KV.ServerSupervisor, fn -> serve(client) end)\n :ok = :gen_tcp.controlling_process(client, pid)\n loop_acceptor(socket)\nend\n```\n\nYou might notice that we added a line, `:ok = :gen_tcp.controlling_process(client, pid)`. This makes the child process the \"controlling process\" of the `client` socket. If we didn't do this, the acceptor would bring down all the clients if it crashed because sockets would be tied to the process that accepted them (which is the default behavior).\n\nNow start a new server with `iex -S mix` and try to open up many concurrent telnet clients. You will notice that quitting a client does not bring the acceptor down, even though we haven't fixed the bug in `:gen_tcp.recv/2` yet (which we will address in the next chapter). Excellent!\n\n## Restart strategies\n\nThere is one important topic we haven't explored yet with the necessary depth. What happens when a supervised process crashes?\n\nIn the previous chapter, when we started a bucket and killed it, the supervisor automatically started one in its place:\n\n```elixir\niex> children = [{KV.Bucket, name: :shopping}]\niex> Supervisor.start_link(children, strategy: :one_for_one)\niex> KV.Bucket.put(:shopping, \"milk\", 1)\niex> pid = Process.whereis(:shopping)\n#PID<0.48.0>\niex> Process.exit(pid, :kill)\ntrue\niex> Process.whereis(:shopping)\n#PID<0.50.0>\n```\n\nWhat exactly happens when a process terminates is part of its child specification. For `KV.Bucket`, we have this:\n\n```elixir\niex> KV.Bucket.child_spec([])\n%{id: KV.Bucket, start: {KV.Bucket, :start_link, [[]]}}\n```\n\nHowever, for tasks, we have this:\n\n```elixir\niex> Task.child_spec(fn -> :ok end)\n%{\n id: Task,\n restart: :temporary,\n start: {Task, :start_link, [#Function<43.39164016/0 in :erl_eval.expr/6>]}\n}\n```\n\nNotice that a task says `:restart` is `:temporary`. `KV.Bucket` says nothing, which means it defaults to `:permanent`. `:temporary` means that a process is never restarted, regardless of why it crashed. `:permanent` means a process is always restarted, regardless of the exit reason. There is also `:transient`, which means it won't be restarted as long as it terminates successfully.\n\nNow we must ask ourselves, are those the correct settings?\n\nFor `KV.Bucket`, using `:permanent` seems logical, as we should not require the user to recreate a bucket they have previously created. Although currently we would lose the bucket data, in an actual system we would add mechanisms to recover it on initialization. However, for tasks, we have used them in two opposing ways in this chapter, which means at least one of them is wrong.\n\nWe use a task to start the acceptor. The acceptor is a critical component of our infrastructure. If it crashes, it means we won't accept further requests, and our server would then be useless as no one can connect to it. On the other hand, we also use `Task.Supervisor` to start tasks that deal with each connection. In this case, restarting may not be useful at all, given the reason we crashed could just as well be a connection issue, and attempting to restart over the same connection would lead to further failures.\n\nTherefore, we want the acceptor to actually run in `:permanent` mode, while we preserve the `Task.Supervisor` as `:temporary`. Luckily Elixir has an API that allows us to change an existing child specification, which we use below.\n\nLet's change `start/2` in `lib/kv.ex` once more to the following:\n\n```elixir\n def start(_type, _args) do\n children = [\n {Registry, name: KV, keys: :unique},\n {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},\n {Task.Supervisor, name: KV.ServerSupervisor},\n Supervisor.child_spec({Task, fn -> KV.Server.accept(4040) end}, restart: :permanent)\n ]\n\n Supervisor.start_link(children, strategy: :one_for_one)\n end\n```\n\nNow we have an always running acceptor that starts temporary task processes under an always running task supervisor.\n\n## Leveraging the ecosystem\n\nIn this chapter, we implemented a basic TCP acceptor while exploring concurrency and fault-tolerance. Our acceptor can manage concurrent connections, but it is still not ready for production. Production-ready TCP servers run a pool of acceptors, each with their own supervisor. Elixir's `PartitionSupervisor` might be used to partition and scale the acceptor, but it is out of scope for this guide. In practice, you will use existing packages tailored for this use-case, such as [Ranch](https://github.com/ninenines/ranch) (in Erlang) or [Thousand Island](https://github.com/mtrudel/thousand_island) (in Elixir).\n\nIn the next chapter, we will start parsing the client requests and sending responses, finishing our server.\n" }, { "path": "lib/elixir/pages/references/compatibility-and-deprecations.md", "content": "\n\n# Compatibility and deprecations\n\nElixir is versioned according to a vMAJOR.MINOR.PATCH schema.\n\nElixir is currently at major version v1. A new backwards compatible minor release happens every 6 months. Patch releases are not scheduled and are made whenever there are bug fixes or security patches.\n\nElixir applies bug fixes only to the latest minor branch. Security patches are available for the last 5 minor branches:\n\nElixir version | Support\n:------------- | :-----------------------------\n1.20 | Development\n1.19 | Bug fixes and security patches\n1.18 | Security patches only\n1.17 | Security patches only\n1.16 | Security patches only\n1.15 | Security patches only\n\nNew releases are announced in the read-only [announcements mailing list](https://groups.google.com/group/elixir-lang-ann). All security releases [will be tagged with `[security]`](https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date).\n\nThere are currently no plans for a major v2 release.\n\n## Between non-major Elixir versions\n\nElixir minor and patch releases are backwards compatible: well-defined behaviors and documented APIs in a given version will continue working on future versions.\n\nAlthough we expect the vast majority of programs to remain compatible over time, it is impossible to guarantee that no future change will break any program. Under some unlikely circumstances, we may introduce changes that break existing code:\n\n * Security: a security issue in the implementation may arise whose resolution requires backwards incompatible changes. We reserve the right to address such security issues.\n\n * Bugs: if an API has undesired behavior, a program that depends on the buggy behavior may break if the bug is fixed. We reserve the right to fix such bugs.\n\n * Compiler front-end: improvements may be done to the compiler, introducing new warnings for ambiguous modes and providing more detailed error messages. Those can lead to compilation errors (when running with `--warnings-as-errors`) or tooling failures when asserting on specific error messages (although one should avoid such). We reserve the right to do such improvements.\n\n * Imports: new functions may be added to the `Kernel` module, which is auto-imported. They may collide with local functions defined in your modules. Collisions can be resolved in a backwards compatible fashion using `import Kernel, except: [...]` with a list of all functions you don't want to be imported from `Kernel`. We reserve the right to do such additions.\n\nIn order to continue evolving the language without introducing breaking changes, Elixir will rely on deprecations to demote certain practices and promote new ones. Our deprecation policy is outlined in the [\"Deprecations\" section](#deprecations).\n\nThe only exception to the compatibility guarantees above are experimental features, which will be explicitly marked as such, and do not provide any compatibility guarantee until they are stabilized.\n\n## Between Elixir and Erlang/OTP\n\nErlang/OTP versioning is independent from the versioning of Elixir. Erlang releases a new major version yearly. Our goal is to support the last three Erlang major versions by the time Elixir is released. The compatibility table is shown below.\n\nElixir version | Supported Erlang/OTP versions\n:------------- | :-------------------------------\n1.20 | 27 - 29\n1.19 | 26 - 28\n1.18 | 25 - 27\n1.17 | 25 - 27\n1.16 | 24 - 26\n1.15 | 24 - 26\n1.14 | 23 - 25 (and Erlang/OTP 26 from v1.14.5)\n1.13 | 22 - 24 (and Erlang/OTP 25 from v1.13.4)\n1.12 | 22 - 24\n1.11 | 21 - 23 (and Erlang/OTP 24 from v1.11.4)\n1.10 | 21 - 22 (and Erlang/OTP 23 from v1.10.3)\n1.9 | 20 - 22\n1.8 | 20 - 22\n1.7 | 19 - 22\n1.6 | 19 - 20 (and Erlang/OTP 21 from v1.6.6)\n1.5 | 18 - 20\n1.4 | 18 - 19 (and Erlang/OTP 20 from v1.4.5)\n1.3 | 18 - 19\n1.2 | 18 - 18 (and Erlang/OTP 19 from v1.2.6)\n1.1 | 17 - 18\n1.0 | 17 - 17 (and Erlang/OTP 18 from v1.0.5)\n\nElixir may add compatibility to new Erlang/OTP versions on patch releases, such as support for Erlang/OTP 20 in v1.4.5. Those releases are made for convenience and typically contain the minimum changes for Elixir to run without errors, if any changes are necessary. Only the next minor release, in this case v1.5.0, effectively leverages the new features provided by the latest Erlang/OTP release.\n\n## Deprecations\n\n### Policy\n\nElixir deprecations happen in 3 steps:\n\n 1. The feature is soft-deprecated. It means both CHANGELOG and documentation must list the feature as deprecated but no warning is effectively emitted by running the code. There is no requirement to soft-deprecate a feature.\n\n 2. The feature is effectively deprecated by emitting warnings on usage. This is also known as hard-deprecation. In order to deprecate a feature, the proposed alternative MUST exist for AT LEAST THREE minor versions. For example, `Enum.uniq/2` was soft-deprecated in favor of `Enum.uniq_by/2` in Elixir v1.1. This means a deprecation warning may only be emitted by Elixir v1.4 or later.\n\n 3. The feature is removed. This can only happen on major releases. This means deprecated features in Elixir v1.x shall only be removed by Elixir v2.x.\n\n### Table of deprecations\n\nThe first column is the version the feature was hard deprecated. The second column shortly describes the deprecated feature and the third column explains the replacement and from which the version the replacement is available from.\n\nVersion | Deprecated feature | Replaced by (available since)\n:-------| :-------------------------------------------------- | :---------------------------------------------------------------\n[v1.20] | `<>` in patterns without `^` | `<>` (v1.15)\n[v1.20] | `File.stream!(path, modes, lines_or_bytes)` | `File.stream!(path, lines_or_bytes, modes)` (v1.16)\n[v1.20] | `Kernel.ParallelCompiler.async/1` | `Kernel.ParallelCompiler.pmap/2` (v1.16)\n[v1.20] | `Logger.*_backend` functions | The `LoggerBackends` module from [`:logger_backends`](https://hex.pm/packages/logger_backends) package\n[v1.20] | `Logger.enable/1` and `Logger.disable/1` | `Logger.put_process_level/2` and `Logger.delete_process_level/1` respectively (v1.15)\n[v1.19] | CLI configuration in `def project` inside `mix.exs` | Moving it to `def cli` (v1.14)\n[v1.19] | Using `,` to separate tasks in `mix do` | Using `+` (v1.14)\n[v1.19] | `Logger`'s `:backends` configuration | `Logger`'s `:default_handler` configuration (v1.15)\n[v1.19] | Passing a callback to `File.cp/3`, `File.cp!/3`, `File.cp_r/3`, and `File.cp_r!/3` | The `:on_conflict` option (v1.14)\n[v1.18] | `<%#` in EEx | `<%!--` (v1.14) or `<% #` (v1.0)\n[v1.18] | `EEx.Engine.handle_text/2` callback in EEx | `c:EEx.Engine.handle_text/3` (v1.14)\n[v1.18] | Returning a 2-arity function from `Enumerable.slice/1` | Returning a 3-arity function (v1.14)\n[v1.18] | Ranges with negative steps in `Range.new/2` | Explicit steps in ranges (v1.11)\n[v1.18] | `Tuple.append/2` | `Tuple.insert_at/3` (v1.0)\n[v1.18] | `mix cmd --app APP` | `mix do --app APP` (v1.14)\n[v1.18] | `List.zip/1` | `Enum.zip/1` (v1.0)\n[v1.18] | `Module.eval_quoted/3` | `Code.eval_quoted/3` (v1.0)\n[v1.17] | Single-quoted charlists (`'foo'`) | `~c\"foo\"` (v1.0)\n[v1.17] | `left..right` in patterns and guards | `left..right//step` (v1.11)\n[v1.17] | `ExUnit.Case.register_test/4` | `register_test/6` (v1.10)\n[v1.17] | `:all` in `IO.read/2` and `IO.binread/2` | `:eof` (v1.13)\n[v1.16] | `~R/.../` | `~r/.../` (v1.0)\n[v1.16] | Ranges with negative steps in `Enum.slice/2` | Explicit steps in ranges (v1.11)\n[v1.16] | Ranges with negative steps in `String.slice/2` | Explicit steps in ranges (v1.11)\n[v1.15] | `Calendar.ISO.day_of_week/3` | `Calendar.ISO.day_of_week/4` (v1.11)\n[v1.15] | `Exception.exception?/1` | `Kernel.is_exception/1` (v1.11)\n[v1.15] | `Regex.regex?/1` | `Kernel.is_struct/2` (`Kernel.is_struct(term, Regex)`) (v1.11)\n[v1.15] | `Logger.warn/2` | `Logger.warning/2` (v1.11)\n[v1.14] | `use Bitwise` | `import Bitwise` (v1.0)\n[v1.14] | `~~~/1` | `bnot/2` (v1.0)\n[v1.14] | `Application.get_env/3` and similar in module body | `Application.compile_env/3` (v1.10)\n[v1.14] | Compiled patterns in `String.starts_with?/2` | Pass a list of strings instead (v1.0)\n[v1.14] | `Mix.Tasks.Xref.calls/1` | Compilation tracers (outlined in `Code`) (v1.10)\n[v1.14] | `$levelpad` in Logger | *None*\n[v1.14] | `<\\|>` as a custom operator | Another custom operator (v1.0)\n[v1.13] | `!` and `!=` in Version requirements | `~>` or `>=` (v1.0)\n[v1.13] | `Mix.Config` | `Config` (v1.9)\n[v1.13] | `:strip_beam` config to `mix escript.build` | `:strip_beams` (v1.9)\n[v1.13] | `Macro.to_string/2` | `Macro.to_string/1` (v1.0)\n[v1.13] | `System.get_pid/0` | `System.pid/0` (v1.9)\n[v1.12] | `^^^/2` | `bxor/2` (v1.0)\n[v1.12] | `@foo()` to read module attributes | Remove the parenthesis (v1.0)\n[v1.12] | `use EEx.Engine` | Explicitly delegate to EEx.Engine instead (v1.0)\n[v1.12] | `:xref` compiler in Mix | Nothing (it always runs as part of the compiler now)\n[v1.11] | `Mix.Project.compile/2` | `Mix.Task.run(\"compile\", args)` (v1.0)\n[v1.11] | `Supervisor.Spec.worker/3` and `Supervisor.Spec.supervisor/3` | The new child specs outlined in `Supervisor` (v1.5)\n[v1.11] | `Supervisor.start_child/2` and `Supervisor.terminate_child/2` | `DynamicSupervisor` (v1.6)\n[v1.11] | `System.stacktrace/1` | `__STACKTRACE__` in `try/catch/rescue` (v1.7)\n[v1.10] | `Code.ensure_compiled?/1` | `Code.ensure_compiled/1` (v1.0)\n[v1.10] | `Code.load_file/2` | `Code.require_file/2` (v1.0) or `Code.compile_file/2` (v1.7)\n[v1.10] | `Code.loaded_files/0` | `Code.required_files/0` (v1.7)\n[v1.10] | `Code.unload_file/1` | `Code.unrequire_files/1` (v1.7)\n[v1.10] | Passing non-chardata to `Logger.log/2` | Explicitly convert to string with `to_string/1` (v1.0)\n[v1.10] | `:compile_time_purge_level` in `Logger` app environment | `:compile_time_purge_matching` in `Logger` app environment (v1.7)\n[v1.10] | `Supervisor.Spec.supervise/2` | The new child specs outlined in `Supervisor` (v1.5)\n[v1.10] | `:simple_one_for_one` strategy in `Supervisor` | `DynamicSupervisor` (v1.6)\n[v1.10] | `:restart` and `:shutdown` in `Task.Supervisor.start_link/1` | `:restart` and `:shutdown` in `Task.Supervisor.start_child/3` (v1.6)\n[v1.9] | Enumerable keys in `Map.drop/2`, `Map.split/2`, and `Map.take/2` | Call `Enum.to_list/1` on the second argument before hand (v1.0)\n[v1.9] | `Mix.Project.load_paths/1` | `Mix.Project.compile_path/1` (v1.0)\n[v1.9] | Passing `:insert_replaced` to `String.replace/4` | Use `:binary.replace/4` (v1.0)\n[v1.8] | Passing a non-empty list to `Collectable.into/1` | `++/2` or `Keyword.merge/2` (v1.0)\n[v1.8] | Passing a non-empty list to `:into` in `for/1` | `++/2` or `Keyword.merge/2` (v1.0)\n[v1.8] | Passing a non-empty list to `Enum.into/2` | `++/2` or `Keyword.merge/2` (v1.0)\n[v1.8] | Time units in its plural form, such as: `:seconds`, `:milliseconds`, and the like | Use the singular form, such as: `:second`, `:millisecond`, and so on (v1.4)\n[v1.8] | `Inspect.Algebra.surround/3` | `Inspect.Algebra.concat/2` and `Inspect.Algebra.nest/2` (v1.0)\n[v1.8] | `Inspect.Algebra.surround_many/6` | `Inspect.Algebra.container_doc/6` (v1.6)\n[v1.9] | `--detached` in `Kernel.CLI` | `--erl \"-detached\"` (v1.0)\n[v1.8] | `Kernel.ParallelCompiler.files/2` | `Kernel.ParallelCompiler.compile/2` (v1.6)\n[v1.8] | `Kernel.ParallelCompiler.files_to_path/2` | `Kernel.ParallelCompiler.compile_to_path/2` (v1.6)\n[v1.8] | `Kernel.ParallelRequire.files/2` | `Kernel.ParallelCompiler.require/2` (v1.6)\n[v1.8] | Returning `{:ok, contents}` or `:error` from `Mix.Compilers.Erlang.compile/6`'s callback | Return `{:ok, contents, warnings}` or `{:error, errors, warnings}` (v1.6)\n[v1.8] | `System.cwd/0` and `System.cwd!/0` | `File.cwd/0` and `File.cwd!/0` respectively (v1.0)\n[v1.7] | `Code.get_docs/2` | `Code.fetch_docs/1` (v1.7)\n[v1.7] | `Enum.chunk/2,3,4` | `Enum.chunk_every/2` and [`Enum.chunk_every/3,4`](`Enum.chunk_every/4`) (v1.5)\n[v1.7] | Calling `super/1` in`GenServer` callbacks | Implementing the behaviour explicitly without calling `super/1` (v1.0)\n[v1.7] | [`not left in right`](`in/2`) | [`left not in right`](`in/2`) (v1.5)\n[v1.7] | `Registry.start_link/3` | `Registry.start_link/1` (v1.5)\n[v1.7] | `Stream.chunk/2,3,4` | `Stream.chunk_every/2` and [`Stream.chunk_every/3,4`](`Stream.chunk_every/4`) (v1.5)\n[v1.6] | `Enum.partition/2` | `Enum.split_with/2` (v1.4)\n[v1.6] | `Macro.unescape_tokens/1,2` | Use `Enum.map/2` to traverse over the arguments (v1.0)\n[v1.6] | `Module.add_doc/6` | [`@doc`](`Module`) module attribute (v1.0)\n[v1.6] | `Range.range?/1` | Pattern match on [`_.._`](`../2`) (v1.0)\n[v1.5] | `()` to mean `nil` | `nil` (v1.0)\n[v1.5] | `char_list/0` type | `t:charlist/0` type (v1.3)\n[v1.5] | `Atom.to_char_list/1` | `Atom.to_charlist/1` (v1.3)\n[v1.5] | `Enum.filter_map/3` | `Enum.filter/2` + `Enum.map/2` or `for/1` comprehensions (v1.0)\n[v1.5] | `Float.to_char_list/1` | `Float.to_charlist/1` (v1.3)\n[v1.5] | `GenEvent` module | `Supervisor` and `GenServer` (v1.0)\n[v1.5] | `<%=` in middle and end expressions in `EEx` | Use `<%` (`<%=` is allowed only in start expressions) (v1.0)\n[v1.5] | `:as_char_lists` value in `t:Inspect.Opts.t/0` type | `:as_charlists` value (v1.3)\n[v1.5] | `:char_lists` key in `t:Inspect.Opts.t/0` type | `:charlists` key (v1.3)\n[v1.5] | `Integer.to_char_list/1,2` | `Integer.to_charlist/1` and `Integer.to_charlist/2` (v1.3)\n[v1.5] | `to_char_list/1` | `to_charlist/1` (v1.3)\n[v1.5] | `List.Chars.to_char_list/1` | `List.Chars.to_charlist/1` (v1.3)\n[v1.5] | `@compile {:parse_transform, _}` in `Module` | *None*\n[v1.5] | `Stream.filter_map/3` | `Stream.filter/2` + `Stream.map/2` (v1.0)\n[v1.5] | `String.ljust/3` and `String.rjust/3` | Use `String.pad_leading/3` and `String.pad_trailing/3` with a binary padding (v1.3)\n[v1.5] | `String.lstrip/1` and `String.rstrip/1` | `String.trim_leading/1` and `String.trim_trailing/1` (v1.3)\n[v1.5] | `String.lstrip/2` and `String.rstrip/2` | Use `String.trim_leading/2` and `String.trim_trailing/2` with a binary as second argument (v1.3)\n[v1.5] | `String.strip/1` and `String.strip/2` | `String.trim/1` and `String.trim/2` (v1.3)\n[v1.5] | `String.to_char_list/1` | `String.to_charlist/1` (v1.3)\n[v1.4] | Anonymous functions with no expression after `->` | Use an expression or explicitly return `nil` (v1.0)\n[v1.4] | Support for making [private functions](`defp/2`) overridable | Use [public functions](`def/2`) (v1.0)\n[v1.4] | Variable used as function call | Use parentheses (v1.0)\n[v1.4] | `Access.key/1` | `Access.key/2` (v1.3)\n[v1.4] | `Behaviour` module | `@callback` module attribute (v1.0)\n[v1.4] | `Enum.uniq/2` | `Enum.uniq_by/2` (v1.2)\n[v1.4] | `Float.to_char_list/2` | `:erlang.float_to_list/2` (Erlang/OTP 17)\n[v1.4] | `Float.to_string/2` | `:erlang.float_to_binary/2` (Erlang/OTP 17)\n[v1.4] | `HashDict` module | `Map` (v1.2)\n[v1.4] | `HashSet` module | `MapSet` (v1.1)\n[v1.4] | `IEx.Helpers.import_file/2` | `IEx.Helpers.import_file_if_available/1` (v1.3)\n[v1.4] | `Mix.Utils.camelize/1` | `Macro.camelize/1` (v1.2)\n[v1.4] | `Mix.Utils.underscore/1` | `Macro.underscore/1` (v1.2)\n[v1.4] | Multi-letter aliases in `OptionParser` | Use single-letter aliases (v1.0)\n[v1.4] | `Set` module | `MapSet` (v1.1)\n[v1.4] | `Stream.uniq/2` | `Stream.uniq_by/2` (v1.2)\n[v1.3] | `\\x{X*}` inside strings/sigils/charlists | `\\uXXXX` or `\\u{X*}` (v1.1)\n[v1.3] | `Dict` module | `Keyword` (v1.0) or `Map` (v1.2)\n[v1.3] | `:append_first` option in `defdelegate/2` | Define the function explicitly (v1.0)\n[v1.3] | Map/dictionary as 2nd argument in `Enum.group_by/3` | `Enum.reduce/3` (v1.0)\n[v1.3] | `Keyword.size/1` | `length/1` (v1.0)\n[v1.3] | `Map.size/1` | `map_size/1` (v1.0)\n[v1.3] | `/r` option in `Regex` | `/U` (v1.1)\n[v1.3] | `Set` behaviour | `MapSet` data structure (v1.1)\n[v1.3] | `String.valid_character?/1` | `String.valid?/1` (v1.0)\n[v1.3] | `Task.find/2` | Use direct message matching (v1.0)\n[v1.3] | Non-map as 2nd argument in `URI.decode_query/2` | Use a map (v1.0)\n[v1.2] | `Dict` behaviour | `Map` and `Keyword` (v1.0)\n[v1.1] | `?\\xHEX` | `0xHEX` (v1.0)\n[v1.1] | `Access` protocol | `Access` behaviour (v1.1)\n[v1.1] | `as: true \\| false` in `alias/2` and `require/2` | *None*\n\n[v1.1]: https://github.com/elixir-lang/elixir/blob/v1.1/CHANGELOG.md#4-deprecations\n[v1.2]: https://github.com/elixir-lang/elixir/blob/v1.2/CHANGELOG.md#changelog-for-elixir-v12\n[v1.3]: https://github.com/elixir-lang/elixir/blob/v1.3/CHANGELOG.md#4-deprecations\n[v1.4]: https://github.com/elixir-lang/elixir/blob/v1.4/CHANGELOG.md#4-deprecations\n[v1.5]: https://github.com/elixir-lang/elixir/blob/v1.5/CHANGELOG.md#4-deprecations\n[v1.6]: https://github.com/elixir-lang/elixir/blob/v1.6/CHANGELOG.md#4-deprecations\n[v1.7]: https://github.com/elixir-lang/elixir/blob/v1.7/CHANGELOG.md#4-hard-deprecations\n[v1.8]: https://github.com/elixir-lang/elixir/blob/v1.8/CHANGELOG.md#4-hard-deprecations\n[v1.9]: https://github.com/elixir-lang/elixir/blob/v1.9/CHANGELOG.md#4-hard-deprecations\n[v1.10]: https://github.com/elixir-lang/elixir/blob/v1.10/CHANGELOG.md#4-hard-deprecations\n[v1.11]: https://github.com/elixir-lang/elixir/blob/v1.11/CHANGELOG.md#4-hard-deprecations\n[v1.12]: https://github.com/elixir-lang/elixir/blob/v1.12/CHANGELOG.md#4-hard-deprecations\n[v1.13]: https://github.com/elixir-lang/elixir/blob/v1.13/CHANGELOG.md#4-hard-deprecations\n[v1.14]: https://github.com/elixir-lang/elixir/blob/v1.14/CHANGELOG.md#4-hard-deprecations\n[v1.15]: https://github.com/elixir-lang/elixir/blob/v1.15/CHANGELOG.md#4-hard-deprecations\n[v1.16]: https://github.com/elixir-lang/elixir/blob/v1.16/CHANGELOG.md#4-hard-deprecations\n[v1.17]: https://github.com/elixir-lang/elixir/blob/v1.17/CHANGELOG.md#4-hard-deprecations\n[v1.18]: https://github.com/elixir-lang/elixir/blob/v1.18/CHANGELOG.md#4-hard-deprecations\n[v1.19]: https://github.com/elixir-lang/elixir/blob/v1.19/CHANGELOG.md#4-hard-deprecations\n[v1.20]: https://github.com/elixir-lang/elixir/blob/main/CHANGELOG.md#4-hard-deprecations\n" }, { "path": "lib/elixir/pages/references/gradual-set-theoretic-types.md", "content": "\n\n# Gradual set-theoretic types\n\nElixir is in the process of incorporating set-theoretic types into the compiler. This document outlines the current stage of our implementation for this Elixir version. Elixir's type system is:\n\n * **sound** - the inferred and assigned by the type system align with the behaviour of the program\n\n * **gradual** - Elixir's type system includes the `dynamic()` type, which can be used when the type of a variable or expression is checked at runtime. However, instead of simply discarding all typing information, Elixir's `dynamic()` type works as a range. For example, if you write `dynamic(integer() or binary())`, Elixir's type system will still emit violations if none of those types are accepted. Furthermore, in the absence of `dynamic()`, Elixir's type system behaves as a static one\n\n * **developer friendly** - the types are described, implemented, and composed using basic set operations: unions, intersections, and negation (hence it is a set-theoretic type system)\n\nThe current milestone aims to infer types from existing programs and use them for type checking, enabling the Elixir compiler to find faults and bugs in codebases without requiring changes to existing software. User provided type signatures are planned for future releases. The underlying principles, theory, and roadmap of our work have been outlined in [\"The Design Principles of the Elixir Type System\" by Giuseppe Castagna, Guillaume Duboc, José Valim](https://arxiv.org/abs/2306.06391).\n\n## A gentle introduction\n\nTypes in Elixir are written using the type named followed by parentheses, such as `integer()` or `list(integer())`.\n\nThe basic types are:\n\n```elixir\natom()\nbinary()\nbitstring()\nempty_list()\ninteger()\nfloat()\nfunction()\nmap()\nnon_empty_list(elem_type, tail_type)\npid()\nport()\nreference()\ntuple()\n```\n\nMany of the types above can also be written more precisely. We will discuss their syntax in the next sections, but here are two examples:\n\n * While `atom()` represents all atoms, the atom `:ok` can also be represented in the type system as `:ok`\n\n * While `tuple()` represents all tuples, you can specify the type of a two-element tuple where the first element is the atom `:ok` and the second is an integer as `{:ok, integer()}`\n\nThere are also three special types: `none()` (represents an empty set), `term()` (represents all types), `dynamic()` (represents a range of the given types).\n\nGiven the types are set-theoretic, we can compose them using unions (`or`), intersections (`and`), and negations (`not`). For example, to say a function returns either atoms or integers, one could write: `atom() or integer()`.\n\nIntersections will find the elements in common between the operands. For example, `atom() and integer()`, which in this case is the empty set `none()`. You can combine intersections and negations to perform difference, for example, to say that a function expects all atoms, except `nil` (which is an atom), you could write: `atom() and not nil`.\n\nYou can find a complete reference in the [set-theoretic types cheatsheet](../cheatsheets/types-cheat.cheatmd).\n\n## The syntax of data types\n\nIn this section we will cover the syntax of all data types. At the moment, developers will interact with those types mostly through compiler warnings and diagnostics.\n\n### Broad types\n\nThese types are broad in that they cannot represent individual elements, only the whole set. For example, the numbers `1` and `42` are both represented by the type `integer()`.\n\nThey are: `binary()`, `bitstring()`, `integer()`, `float()`, `pid()`, `port()`, `reference()`.\n\nThe `binary()` type is a subtype of the less frequently used `bitstring()` type, as binaries are bitstrings where the number of bits is divisible by 8.\n\n### Atoms\n\nYou can represent all atoms as `atom()`. You can also represent each individual atom using their literal syntax. For instance, the atom `:foo` and `:hello_world` are also valid (distinct) types.\n\n`nil`, `true`, and `false` are also atoms and can be written as is. `boolean()` is a convenience type alias that represents `true or false`.\n\n### Tuples\n\nYou can represent all tuples as `tuple()`. Tuples may also be written using the curly brackets syntax, such as `{:ok, binary()}`.\n\nYou may use `...` at the end of the tuple to imply the overall size of the tuple is unknown. For example, the following tuple has at least two elements: `{:ok, binary(), ...}`.\n\n### Lists\n\nYou can represent all _proper_ lists as `list()`, which also includes the empty list.\n\nYou can also specify the type of the list element as argument. For example, `list(integer())` represents the values `[]` and `[1, 2, 3]`, but not `[1, \"two\", 3]`.\n\nInternally, Elixir represents the type `list(a)` as the union two distinct types, `empty_list()` and `not_empty_list(a)`. In other words, `list(integer())` is equivalent to `empty_list() or non_empty_list(integer())`.\n\n#### Improper lists\n\nWhile most developers will simply use `list(a)`, the type system can express all different representations of lists in Elixirby passing a second argument to `non_empty_list`, which represents the type of the tail.\n\nA proper list is one where the tail is the empty list itself. The type `non_empty_list(integer())` is equivalent to `non_empty_list(integer(), empty_list())`.\n\nIf the `tail_type` is anything but a list, then we have an improper list. For example, the value `[1, 2 | 3]` would have the type `non_empty_list(integer(), integer())`.\n\nIf you pass a list type as the tail, then the list type is merged into the element type. For example, `non_empty_list(integer(), list(binary()))` is the same as `non_empty_list(integer() or binary(), empty_list())`.\n\n### Maps\n\nYou can represent all maps as `map()`.\n\nMaps may also be written using their literal syntax:\n\n```elixir\n%{name: binary(), age: integer()}\n```\n\nwhich outlines a map with exactly two keys, `:name` and `:age`, and values of type `binary()` and `integer()` respectively. We say the map above is \"closed\": it only supports the keys explicitly defined. We can also mark a map as \"open\", by including `...` as its first element:\n\n```elixir\n%{..., name: binary(), age: integer()}\n```\n\nThe type above says the keys `:name` and `:age` must exist, with their respective types, but other keys may be present. The `map()` type is the same as `%{...}`. For the empty map, you may write `%{}`, although we recommend using `empty_map()` for clarity.\n\n#### Optional keys\n\nA key may be marked as optional using the `if_set/1` operation on its value type:\n\n```elixir\n%{name: binary(), age: if_set(integer())}\n```\n\nis a map that certainly has the `:name` key but it may have the `:age` key (and if it has such key, its value type is `integer()`).\n\nYou can also use `not_set()` to denote a key cannot be present:\n\n```elixir\n%{..., age: not_set()}\n```\n\nThe type above says the map may have any key, except the `:age` one. This is, for instance, the type returned by `Map.delete(map, :age)`.\n\n#### Domain types\n\nIn the examples above, all map keys were atoms, but we can also use other types as map keys. For example:\n\n```elixir\n# Closed map\n%{binary() or atom() => integer()}\n\n# Open map\n%{..., binary() or atom() => integer()}\n```\n\nCurrently, the type system only tracks the top of each individual type as the domain keys. For example, if you say:\n\n```elixir\n%{list(integer()) => integer(), list(binary()) => binary()}\n```\n\nThat's the same as specifying all lists:\n\n```elixir\n%{list() => integer() or binary()}\n```\n\nThe supported domain keys are `atom()`, `bitstring()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, and `tuple()`. In the case of maps, the `bitstring()` domain stores exclusively keys which are not binary. The ones which are `binary()` are stored under the `binary()` domain.\n\nFurthermore, it is important to note that domain keys are, by definition, optional. Whenever you have a `%{integer() => integer()}`and you try to fetch a key, we must assume the key may not exist (after all, it is not possible to store all integers as map keys as they are infinite).\n\n#### Mixed keys\n\nIt is also possible to mix domain and atom keys. For example, the following map says that all atom keys are of type `binary()`, except the `:root` key, which has type `integer()`:\n\n```elixir\n# Closed map\n%{atom() => binary(), root: integer()}\n\n# Open map\n%{..., atom() => binary(), root: integer()}\n```\n\nThe order of the keys is of increasing precision. `:root` is more precise than `atom()`, therefore it comes later. This mirrors the runtime semantics of maps, where duplicate keys override the value of earlier ones.\n\n### Functions\n\nYou can represent all functions as `function()`. However, in practice, most functions are represented as arrows. For example, a function that receives an integer and return boolean would be written as `(integer() -> boolean())`. A function that receives two integers and return a string (i.e. a binary) would be written as `(integer(), integer() -> binary())`.\n\nWhen representing functions with multiple clauses, which may take different input types, we use intersections. For example, imagine the following function:\n\n```elixir\ndef negate(x) when is_integer(x), do: -x\ndef negate(x) when is_boolean(x), do: not x\n```\n\nIf you give it an integer, it negates it. If you give it a boolean, it negates it.\n\nWe can say this function has the type `(integer() -> integer())` because it is capable of receiving an integer and returning an integer. In this case, `(integer() -> integer())` is a set that represents all functions that can receive an integer and return an integer. Even though this function can receive other arguments and return other values, it is still part of the `(integer() -> integer())` set.\n\nThis function also has the type `(boolean() -> boolean())`, because it also receives booleans and returns booleans. If you pass the function above to another function that expects `(boolean() -> boolean())`, type checking will succeed. Therefore, we can say the overall type of the function is `(integer() -> integer()) and (boolean() -> boolean())`. The intersection means the function belongs to both sets.\n\nAt this point, you may ask, why not a union? As a real-world example, take a t-shirt with green and yellow stripes. We can say the t-shirt belongs to the set of \"t-shirts with green color\". We can also say the t-shirt belongs to the set of \"t-shirts with yellow color\". Let's see the difference between unions and intersections:\n\n * `(t_shirts_with_green() or t_shirts_with_yellow())` - contains t-shirts with either green or yellow, such as green, green and red, green and yellow, but also only yellow, yellow and red, etc.\n\n * `(t_shirts_with_green() and t_shirts_with_yellow())` - contains t-shirts with both green and yellow (and maybe other colors)\n\nSince the t-shirt has both colors, we could say it belongs to the union of green and yellow t-shirts, but doing so would not capture the fact it is both green and yellow. Therefore it is more precise to say it belongs to the intersection of both sets. The same way that a function that goes from `(integer() -> integer())` and `(boolean() -> boolean())` is also an intersection. In practice, it is not useful to define the union of two functions in Elixir, so the compiler will point you to the right direction if you specify the wrong one.\n\n## The `dynamic()` type\n\nExisting Elixir programs do not have type declarations, but we still want to be able to type check them. This is done with the introduction of the `dynamic()` type.\n\nWhen Elixir sees the following function:\n\n```elixir\ndef negate(x) when is_integer(x), do: -x\ndef negate(x) when is_boolean(x), do: not x\n```\n\nElixir type checks it as if the function had the type `(dynamic() -> dynamic())`. Then, based on patterns and guards, we can refine the value of the variable `x` to be `dynamic() and integer()` and `dynamic() and boolean()` for each clause respectively. We say `dynamic()` is a gradual type, which leads us to _gradual set-theoretic types_.\n\nThe simplest way to reason about `dynamic()` in Elixir is that it is a range of types. If you have a type `atom() or integer()`, the underlying code needs to work with both `atom() or integer()`. For example, if you call `Integer.to_string(var)`, and `var` has type `atom() or integer()`, the type system will emit a warning, because `Integer.to_string/1` does not accept atoms.\n\nHowever, by intersecting a type with `dynamic()`, we make the type gradual and therefore only a subset of the type needs to be valid. For instance, if you call `Integer.to_string(var)`, and `var` has type `dynamic() and (atom() or integer())`, the type system will not emit a warning, because `Integer.to_string/1` works with at least one of the types. For convenience, most programs will write `dynamic(atom() or integer())` instead of the intersection. They are equivalent.\n\nCompared to other gradually typed languages, the `dynamic()` type in Elixir is quite powerful: it restricts our program to certain types, via intersections, while still emitting warnings once it is certain the code will fail. This makes `dynamic()` an excellent tool for typing existing Elixir code with meaningful warnings.\n\nIf the user provides their own types, and those types are not `dynamic()`, then Elixir's type system behaves as a statically typed one. This brings us to one last property of dynamic types in Elixir: dynamic types are always at the root. For example, when you write a tuple of type `{:ok, dynamic()}`, Elixir will rewrite it to `dynamic({:ok, term()})`. While this has the downside that you cannot make part of a tuple/map/list gradual, only the whole tuple/map/list, it comes with the upside that dynamic is always explicitly at the root, making it harder to accidentally sneak `dynamic()` in a statically typed program.\n\n## Type inference\n\nType inference (or reconstruction) is the ability of a type system to automatically deduce, either partially or fully, the type of an expression at compile time. Type inference may occur at different levels. For example, many programming languages can automatically infer the types of variables, also known \"local type inference\", but not all can infer type signatures of functions.\n\nInferring type signatures comes with a series of trade-offs:\n\n * Speed - type inference algorithms are often more computationally intensive than type checking algorithms.\n\n * Expressiveness - in any given type system, the constructs that support inference are always a subset of those that can be type-checked. Therefore, if a programming language is restricted to fully reconstructed types, it is less expressive than a solely type checked counterpart.\n\n * Incremental compilation - type inference complicates incremental compilation. If module A depends on module B, which depends on module C, a change to C may require the type signature in B to be reconstructed, which may then require A to be recomputed (and so on). This dependency chain may require large projects to explicitly add type signatures for stability and compilation efficiency.\n\n * Cascading errors - when a user accidentally makes type errors or the code has conflicting assumptions, type inference may lead to less clear error messages as the type system tries to reconcile diverging type assumptions across code paths.\n\nOn the other hand, type inference offers the benefit of enabling type checking for functions and codebases without requiring the user to add type annotations. To balance these trade-offs, Elixir aims to provide \"module type inference\": our goal is to infer the types of functions considering the current module, Elixir's standard library and your dependencies, while calls to modules within the same project are assumed to be `dynamic()`. Once types are inferred, then the whole project is type checked considering all modules and all types (inferred or otherwise).\n\nType inference in Elixir is best-effort: it doesn't guarantee it will find all possible type incompatibilities, only that it may find bugs where all combinations of a type _will_ fail, even in the absence of explicit type annotations. It is meant to be an efficient routine that brings developers some benefits of static typing without requiring any effort from them.\n\nIn the long term, Elixir developers who want typing guarantees must explicitly add type signatures to their functions (see \"Roadmap\"). Any function with an explicit type signature will be typed checked against the user-provided annotations, as in other statically typed languages, without performing type inference. In summary, type checking will rely on type signatures and only fallback to inferred types when no signature is available.\n\n## Roadmap\n\nThe current milestone is to implement type inference of existing codebases, as well as type checking of all language constructs, without changes to the Elixir language. At this stage, we want to collect feedback on the quality of error messages and performance, and therefore the type system has no user facing API. Full type inference of patterns was released in Elixir v1.18, and complete inference is expected as part of Elixir v1.20.\n\nIf the results are satisfactory, the next milestone will include a mechanism for defining typed structs. Elixir programs frequently pattern match on structs, which reveals information about the struct fields, but it knows nothing about their respective types. By propagating types from structs and their fields throughout the program, we will increase the type system’s ability to find errors while further straining our type system implementation. Proposals including the required changes to the language surface will be sent to the community once we reach this stage.\n\nThe third milestone is to introduce set-theoretic type signatures for functions. Unfortunately, the existing Erlang Typespecs are not precise enough for set-theoretic types and they will be phased out of the language and have their postprocessing moved into a separate library once this stage concludes.\n\n## Acknowledgements\n\nThe type system was made possible thanks to a partnership between [CNRS](https://www.cnrs.fr/) and [Remote](https://remote.com/). The development work is currently sponsored by [Fresha](https://www.fresha.com/), and [Tidewave](https://tidewave.ai/).\n" }, { "path": "lib/elixir/pages/references/library-guidelines.md", "content": "\n\n# Library guidelines\n\nThis document outlines general guidelines for those writing and publishing\nElixir libraries meant to be consumed by other developers.\n\n## Getting started\n\nYou can create a new Elixir library by running the `mix new` command:\n\n $ mix new my_library\n\nThe project name is given in the `snake_case` convention where all letters are lowercase and words are separate with underscores. This is the same convention used by variables, function names and atoms in Elixir. See the [Naming Conventions](naming-conventions.md) document for more information.\n\nEvery project has a `mix.exs` file, with instructions on how to build, compile, run tests, and so on. Libraries commonly have a `lib` directory, which includes Elixir source code, and a `test` directory. A `src` directory may also exist for Erlang sources.\n\nThe `mix new` command also allows the `--sup` option to scaffold a new project with a supervision tree out of the box. For more information on running your project, see the official [Mix & OTP guide](../mix-and-otp/introduction-to-mix.md) or [Mix documentation](`Mix`).\n\n## Publishing\n\nWriting code is only the first of many steps to publish a package. We strongly recommend developers to:\n\n * Choose a versioning schema. Elixir requires versions to be in the format `MAJOR.MINOR.PATCH` but the meaning of those numbers is up to you. Most projects choose [Semantic Versioning](https://semver.org/).\n\n * Choose a [license](https://choosealicense.com/). The most common licenses in the Elixir community are the [MIT License](https://choosealicense.com/licenses/mit/) and the [Apache License 2.0](https://choosealicense.com/licenses/apache-2.0/). The latter is also the one used by Elixir itself.\n\n * Run the [code formatter](`mix format`). The code formatter formats your code according to a consistent style shared by your library and the whole community, making it easier for other developers to understand your code and contribute.\n\n * Write tests. Elixir ships with a test-framework named [ExUnit](`ExUnit`). The project generated by `mix new` includes sample tests and doctests.\n\n * Write documentation. The Elixir community is proud of treating documentation as a first-class citizen and making documentation easily accessible. Libraries contribute to the status quo by providing complete API documentation with examples for their modules, types and functions. See the [Writing documentation](../getting-started/writing-documentation.md) chapter of the Getting Started guide for more information. Projects like [ExDoc](https://github.com/elixir-lang/ex_doc) can be used to generate HTML and EPUB documents from the documentation. ExDoc also supports \"extra pages\", like this one that you are reading. Such pages augment the documentation with tutorials, guides, references, and even cheat-sheets.\n\n * Follow best practices. The Elixir project documents [a series of anti-patterns](../anti-patterns/what-anti-patterns.md) that you may want to avoid in your code. The [process-related anti-patterns](../anti-patterns/process-anti-patterns.md) and [meta-programming anti-patterns](../anti-patterns/macro-anti-patterns.md) are of special attention to library authors.\n\nProjects are often made available to other developers [by publishing a Hex package](https://hex.pm/docs/publish). Hex also [supports private packages for organizations](https://hex.pm/pricing). If ExDoc is configured for the Mix project, publishing a package on Hex will also automatically publish the generated documentation to [HexDocs](https://hexdocs.pm).\n\n## Dependency handling\n\nWhen your library is used as a dependency, it runs by default in the `:prod` environment. Therefore, if your library has dependencies that are only useful in development or testing, you want to specify those dependencies with the `:only` option. You can also specify `:optional` dependencies in your library, which are not enforced upon users of your library. In such cases, you should also consider compiling your projects with the `mix compile --no-optional-deps --warnings-as-errors` in your test environments, to ensure your library compiles without warnings even if optional dependencies are missing. See `mix deps` for all available options.\n\nKeep in mind your library's [lockfile](`Mix.Project#module-configuration`) (usually named `mix.lock`) is _ignored by the host project_. Running `mix deps.get` in the host project attempts to get the latest possible versions of your library’s dependencies, as specified by the requirements in the `deps` section of your `mix.exs`. These versions might be greater than those stored in your `mix.lock` (and hence used in your tests / CI).\n\nOn the other hand, contributors of your library, need a deterministic build, which implies the presence of `mix.lock` in your Version Control System (VCS), such as `git`.\n\nIf you want to validate both scenarios, you should check the `mix.lock` into version control and run two different Continuous Integration (CI) workflows: one that relies on the `mix.lock` for deterministic builds, and another one, that starts with `mix deps.unlock --all` and always compiles your library and runs tests against latest versions of dependencies. The latter one might be even run nightly or otherwise recurrently to stay notified about any possible issue in regard to dependencies updates.\n\n### Dependency Version Requirements\n\nWhen depending on other libraries, the dependency version requirements are ultimately up to you. However, you should consider the effects that an overly strict dependency requirement can have on users of your library. Most dependencies adopt [Semantic Versioning](https://semver.org/), and therefore provide reasonable guarantees about what each release contains. For instance, if you use `{:some_dep, “== 0.2.3”}`, this prevents users from using any other version but the one that you specified, which means that they cannot receive bug fix upgrades to that package. When in doubt, use a dependency in the format of `\"~> x.y\"`. This prevents the user from using a higher major version of the library, but allows them to upgrade to newer minor and patch versions, which should only include bug fixes and non-breaking improvements.\n\nThe exception to this is pre 1.0 libraries using [Semantic Versioning](https://semver.org/), which provide [no guarantees](https://semver.org/spec/v2.0.0.html#spec-item-4) about what might change from one version to the next. In this scenario, depending on the full patch version, i.e `\"~> 0.1.2\"` is a better default.\n\nA common mistake is to use a dependency in the format of `\"~> x.y.z\"` to express \"a version greater than `x.y.z`\". For example, if you are depending on `\"~> 1.2\"`, and the dependency publishes a fix in version `1.2.1` that you need for the next version of your library. If you use `\"~> 1.2.1\"` to express that dependency, you are preventing users from upgrading to `\"1.3.0\"` or higher! Instead of `\"~> 1.2.1\"`, you should use `\"~> 1.2 and >= 1.2.1\"` as the version requirement. This allows users to use any version less than `2.0`, and greater than `1.2.1`.\n" }, { "path": "lib/elixir/pages/references/naming-conventions.md", "content": "\n\n# Naming conventions\n\nThis document is a reference of the naming conventions in Elixir, from casing to punctuation characters.\n\nThe naming convention is, by definition, a subset of the Elixir syntax. A convention aims to\nfollow and set best practices for language and the community. If instead you want a complete reference into the Elixir syntax, beyond its conventions, see [the Syntax reference](syntax-reference.md).\n\n## Casing\n\nElixir developers must use `snake_case` when defining variables, function names, module attributes, and the like:\n\n some_map = %{this_is_a_key: \"and a value\"}\n is_map(some_map)\n\nAliases, commonly used as module names, are an exception as they must be capitalized and written in `CamelCase`, like `OptionParser`. For aliases, capital letters are kept in acronyms, like `ExUnit.CaptureIO` or `Mix.SCM`.\n\nAtoms can be written either in `:snake_case` or `:CamelCase`, although the convention is to use the snake case version throughout Elixir.\n\nGenerally speaking, filenames follow the `snake_case` convention of the module they define. For example, `MyApp` should be defined inside the `my_app.ex` file. However, this is only a convention. At the end of the day any filename can be used as they do not affect the compiled code in any way.\n\n## Underscore (`_foo`)\n\nElixir relies on underscores in different situations.\n\nFor example, a value that is not meant to be used must be assigned to `_` or to a variable starting with underscore:\n\n iex> {:ok, _contents} = File.read(\"README.md\")\n\nFunction names may also start with an underscore. Such functions are never imported by default:\n\n iex> defmodule Example do\n ...> def _wont_be_imported do\n ...> :oops\n ...> end\n ...> end\n\n iex> import Example\n iex> _wont_be_imported()\n ** (CompileError) iex:1: undefined function _wont_be_imported/0\n\nDue to this property, Elixir relies on functions starting with underscore to attach compile-time metadata to modules. Such functions are most often in the `__foo__` format. For example, every module in Elixir has an [`__info__/1`](`c:Module.__info__/1`) function:\n\n iex> String.__info__(:functions)\n [at: 2, capitalize: 1, chunk: 2, ...]\n\nElixir also includes five special forms that follow the double underscore format: `__CALLER__/0`, `__DIR__/0`, `__ENV__/0`and `__MODULE__/0` retrieve compile-time information about the current environment, while `__STACKTRACE__/0` retrieves the stacktrace for the current exception.\n\n## Trailing bang (`foo!`)\n\nA trailing bang (exclamation mark) signifies a function or macro where failure cases raise an exception. They most often exist as a \"raising variant\" of a function that returns `:ok`/`:error` tuples (or `nil`).\n\nOne example is `File.read/1` and `File.read!/1`. `File.read/1` will return a success or failure tuple, whereas `File.read!/1` will return a plain value or else raise an exception:\n\n iex> File.read(\"file.txt\")\n {:ok, \"file contents\"}\n iex> File.read(\"no_such_file.txt\")\n {:error, :enoent}\n\n iex> File.read!(\"file.txt\")\n \"file contents\"\n iex> File.read!(\"no_such_file.txt\")\n ** (File.Error) could not read file no_such_file.txt: no such file or directory\n\nThe version without `!` is preferred when you want to handle different outcomes using pattern matching:\n\n case File.read(file) do\n {:ok, body} -> # do something with the `body`\n {:error, reason} -> # handle the error caused by `reason`\n end\n\nHowever, if you expect the outcome to always be successful (for instance, if you expect the file always to exist), the bang variation can be more convenient and will raise a more helpful error message (than a failed pattern match) on failure.\n\nWhen thinking about failure cases, we are often thinking about semantic errors related to the operation being performed, such as failing to open a file or trying to fetch key from a map. Errors that come from invalid argument types, or similar, must always raise regardless if the function has a bang or not. In such cases, the exception is often an `ArgumentError` or a detailed `FunctionClauseError`:\n\n iex(1)> File.read(123)\n ** (FunctionClauseError) no function clause matching in IO.chardata_to_string/1\n\n The following arguments were given to IO.chardata_to_string/1:\n\n # 1\n 123\n\n Attempted function clauses (showing 2 out of 2):\n\n def chardata_to_string(string) when is_binary(string)\n def chardata_to_string(list) when is_list(list)\n\nMore examples of paired functions: `Base.decode16/2` and `Base.decode16!/2`, `File.cwd/0` and `File.cwd!/0`. In some situations, you may have bang functions without a non-bang counterpart. They also imply the possibility of errors, such as: `Protocol.assert_protocol!/1` and `PartitionSupervisor.resize!/2`. This can be useful if you foresee the possibility of adding a non-raising variant in the future.\n\n## Trailing question mark (`foo?`)\n\nFunctions that return a boolean are named with a trailing question mark.\n\nExamples: `Keyword.keyword?/1`, `Mix.debug?/0`, `String.contains?/2`\n\nHowever, functions that return booleans and are valid in guards follow another convention, described next.\n\n## `is_` prefix (`is_foo`)\n\nType checks and other boolean checks that are allowed in guard clauses are named with an `is_` prefix.\n\nExamples: `Integer.is_even/1`, `is_list/1`\n\nThese functions and macros follow the Erlang convention of an `is_` prefix, instead of a trailing question mark, precisely to indicate that they are allowed in guard clauses. Type checks that are not valid in guard clauses do not follow this convention, such as `Keyword.keyword?/1`.\n\nA trailing question mark should not be used in combination with the `is_` prefix.\n\n## Special names\n\nSome names have specific meaning in Elixir. We detail those cases below.\n\n### length and size\n\nWhen you see `size` in a function name, it means the operation runs in constant time (also written as \"O(1) time\") because the size is stored alongside the data structure.\n\nExamples: `map_size/1`, `tuple_size/1`\n\nWhen you see `length`, the operation runs in linear time (\"O(n) time\") because the entire data structure has to be traversed.\n\nExamples: `length/1`, `String.length/1`\n\nIn other words, functions using the word \"size\" in its name will take the same amount of time whether the data structure is tiny or huge. Conversely, functions having \"length\" in its name will take more time as the data structure grows in size.\n\n### get, fetch, fetch!\n\nWhen you see the functions `get`, `fetch`, and `fetch!` for key-value data structures, you can expect the following behaviours:\n\n * `get` returns a default value (which itself defaults to `nil`) if the key is not present, or returns the requested value.\n * `fetch` returns `:error` if the key is not present, or returns `{:ok, value}` if it is.\n * `fetch!` *raises* if the key is not present, or returns the requested value.\n\nExamples: `Map.get/2`, `Map.fetch/2`, `Map.fetch!/2`, `Keyword.get/2`, `Keyword.fetch/2`, `Keyword.fetch!/2`\n\n### compare\n\nThe function `compare/2` should return `:lt` if the first term is less than the second, `:eq` if the two\nterms compare as equivalent, or `:gt` if the first term is greater than the second.\n\nExamples: `DateTime.compare/2`\n\nNote that this specific convention is important due to the expectations of `Enum.sort/2`\n" }, { "path": "lib/elixir/pages/references/operators.md", "content": "\n\n# Operators reference\n\nThis document is a complete reference of operators in Elixir, how they are parsed, how they can be defined, and how they can be overridden.\n\n## General operators\n\nElixir provides the following built-in operators:\n\n * [`+`](`+/1`) and [`-`](`-/1`) - unary positive/negative\n * [`+`](`+/2`), [`-`](`-/2`), [`*`](`*/2`), and [`/`](`//2`) - basic arithmetic operations\n * [`++`](`++/2`) and [`--`](`--/2`) - list concatenation and subtraction\n * [`and`](`and/2`) and [`&&`](`&&/2`) - strict and relaxed boolean \"and\"\n * [`or`](`or/2`) and [`||`](`||/2`) - strict and relaxed boolean \"or\"\n * [`not`](`not/1`) and [`!`](`!/1`) - strict and relaxed boolean \"not\"\n * [`in`](`in/2`) and [`not in`](`in/2`) - membership\n * [`@`](`@/1`) - module attribute\n * [`..`](`../0`), [`..`](`../2`), and [`..//`](`..///3`) - range creation\n * [`<>`](`<>/2`) - binary concatenation\n * [`|>`](`|>/2`) - pipeline\n * [`=~`](`=~/2`) - text-based match\n\nMany of those can be used in guards. Consult the [list of allowed guard functions and operators](patterns-and-guards.md#list-of-allowed-functions-and-operators).\n\nAdditionally, there are a few other operators that Elixir parses but doesn't actually use.\nSee [Custom and overridden operators](#custom-and-overridden-operators) below for a list and for guidelines about their use.\n\nSome other operators are special forms and cannot be overridden:\n\n * [`^`](`^/1`) - pin operator\n * [`.`](`./2`) - dot operator\n * [`=`](`=/2`) - match operator\n * [`&`](`&/1`) - capture operator\n * [`::`](`::/2`) - type operator\n\nFinally, these operators appear in the precedence table below but are only meaningful within certain constructs:\n\n * `=>` - see [`%{}`](`%{}/1`)\n * `when` - see [Guards](patterns-and-guards.md#guards)\n * `<-` - see [`for`](`for/1`) and [`with`](`with/1`)\n * `\\\\` - see [Default arguments](`Kernel#def/2-default-arguments`)\n\n## Comparison operators\n\nElixir provides the following built-in comparison operators (all of which can be used in guards):\n\n * [`==`](`==/2`) - equal to\n * [`===`](`===/2`) - strictly equal to\n * [`!=`](`!=/2`) - not equal to\n * [`!==`](`!==/2`) - strictly not equal to\n * [`<`](``](`>/2`) - greater-than\n * [`<=`](`<=/2`) - less-than or equal to\n * [`>=`](`>=/2`) - greater-than or equal to\n\nThe only difference between [`==`](`==/2`) and [`===`](`===/2`) is that [`===`](`===/2`) is strict when it comes to comparing integers and floats:\n\n```elixir\niex> 1 == 1.0\ntrue\niex> 1 === 1.0\nfalse\n```\n\n[`!=`](`!=/2`) and [`!==`](`!==/2`) act as the negation of [`==`](`==/2`) and [`===`](`===/2`), respectively.\n\n## Operator precedence and associativity\n\nThe following is a list of all operators that Elixir is capable of parsing, ordered from higher to lower precedence, alongside their associativity:\n\nOperator | Associativity\n---------------------------------------------- | -------------\n`@` | Unary\n`.` | Left\n`+` `-` `!` `^` `not` | Unary\n`**` | Left\n`*` `/` | Left\n`+` `-` | Left\n`++` `--` `+++` `---` `..` `<>` | Right\n`//` (valid only inside `..//`) | Right\n`in` `not in` | Left\n`\\|>` `<<<` `>>>` `<<~` `~>>` `<~` `~>` `<~>` | Left\n`<` `>` `<=` `>=` | Left\n`==` `!=` `=~` `===` `!==` | Left\n`&&` `&&&` `and` | Left\n`\\|\\|` `\\|\\|\\|` `or` | Left\n`=` | Right\n`&`, `...` | Unary\n`\\|` | Right\n`::` | Right\n`when` | Right\n`<-` `\\\\` | Left\n`=>` (valid only inside `%{}`) | None\n\nElixir also has two ternary operators:\n\nOperator | Associativity\n---------------------------------------------- | -------------\n`first..last//step` | Right\n`%{map \\| key => value, ...}` | None\n\n> #### Deprecated operator precedence {: .info}\n>\n> Elixir parses `not left in right` as `not(left in right)` and `!left in right` as `!(left in right)`, which mismatches the precedence table above, but such behaviour is deprecated and emits a warning. Both constructs must be written as `left not in right` instead. In future major versions, the parser will match the table above.\n\n## Custom and overridden operators\n\nElixir is capable of parsing a predefined set of operators. It's not possible to define new operators (as supported by some languages). However, not all operators that Elixir can parse are *used* by Elixir: for example, `+` and `||` are used by Elixir for addition and boolean *or*, but `<~>` is not used (but valid).\n\nTo define an operator, you can use the usual `def*` constructs (`def`, `defp`, `defmacro`, and so on) but with a syntax similar to how the operator is used:\n\n```elixir\ndefmodule MyOperators do\n # We define ~> to return the maximum of the given two numbers,\n # and <~ to return the minimum.\n\n def a ~> b, do: max(a, b)\n def a <~ b, do: min(a, b)\nend\n```\n\nTo use the newly defined operators, you **have to** import the module that defines them:\n\n```elixir\niex> import MyOperators\niex> 1 ~> 2\n2\niex> 1 <~ 2\n1\n```\n\nThe following is a table of all the operators that Elixir is capable of parsing, but that are not used by default:\n\n * `|||`\n * `&&&`\n * `<<<`\n * `>>>`\n * `<<~`\n * `~>>`\n * `<~`\n * `~>`\n * `<~>`\n * `+++`\n * `---`\n * `...`\n\nThe following operators are used by the `Bitwise` module when imported: [`&&&`](`Bitwise.&&&/2`), [`<<<`](`Bitwise.<<>>`](`Bitwise.>>>/2`), and [`|||`](`Bitwise.|||/2`). See the `Bitwise` documentation for more information.\n\nNote that the Elixir community generally discourages custom operators. They can be hard to read and even more to understand, as they don't have a descriptive name like functions do. That said, some specific cases or custom domain specific languages (DSLs) may justify these practices.\n\nIt is also possible to replace predefined operators, such as `+`, but doing so is extremely discouraged.\n" }, { "path": "lib/elixir/pages/references/patterns-and-guards.md", "content": "\n\n# Patterns and guards\n\nElixir provides pattern matching, which allows us to assert on the shape or extract values from data structures. Patterns are often augmented with guards, which give developers the ability to perform more complex checks, albeit limited.\n\nThis document provides a complete reference on patterns and guards, their semantics, where they are allowed, and how to extend them.\n\n## Patterns\n\nPatterns in Elixir are made of variables, literals, and data structure specific syntax. One of the most used constructs to perform pattern matching is the match operator ([`=`](`=/2`)):\n\n```iex\niex> x = 1\n1\niex> 1 = x\n1\n```\n\nIn the example above, `x` starts without a value and has `1` assigned to it. Then, we compare the value of `x` to the literal `1`, which succeeds as they are both `1`.\n\nMatching `x` against 2 would raise:\n\n```iex\niex> 2 = x\n** (MatchError) no match of right hand side value: 1\n```\n\nPatterns are not bidirectional. If you have a variable `y` that was never assigned to (often called an unbound variable) and you write `1 = y`, an error will be raised:\n\n```iex\niex> 1 = y\n** (CompileError) iex:2: undefined variable \"y\"\n```\n\nIn other words, patterns are allowed only on the left side of `=`. The right side of `=` follows the regular evaluation semantics of the language.\n\nNow let's cover the pattern matching rules for each construct and then for each relevant data types.\n\n### Variables\n\nVariables in patterns are always assigned to:\n\n```iex\niex> x = 1\n1\niex> x = 2\n2\niex> x\n2\n```\n\nIn other words, Elixir supports rebinding. In case you don't want the value of a variable to change, you can use the pin operator (`^`):\n\n```iex\niex> x = 1\n1\niex> ^x = 2\n** (MatchError) no match of right hand side value: 2\n```\n\nIf the same variable appears multiple times in the same pattern, then all of them must be bound to the same value:\n\n```iex\niex> {x, x} = {1, 1}\n{1, 1}\niex> {x, x} = {1, 2}\n** (MatchError) no match of right hand side value: {1, 2}\n```\n\nThe underscore variable (`_`) has a special meaning as it can never be bound to any value. It is especially useful when you don't care about certain value in a pattern:\n\n```iex\niex> {_, integer} = {:not_important, 1}\n{:not_important, 1}\niex> integer\n1\niex> _\n** (CompileError) iex:3: invalid use of _\n```\n\nA pinned value represents the value itself and not its – even if syntactically equal – pattern. The right hand side is compared to be equal to the pinned value:\n\n```iex\niex> x = %{}\n%{}\niex> {:ok, %{}} = {:ok, %{a: 13}}\n{:ok, %{a: 13}}\niex> {:ok, ^x} = {:ok, %{a: 13}}\n** (MatchError) no match of right hand side value: {:ok, %{a: 13}}\n (stdlib 6.2) erl_eval.erl:667: :erl_eval.expr/6\n iex:2: (file)\n```\n\n### Literals (numbers and atoms)\n\nAtoms and numbers (integers and floats) can appear in patterns and they are always represented as is. For example, an atom will only match an atom if they are the same atom:\n\n```iex\niex> :atom = :atom\n:atom\niex> :atom = :another_atom\n** (MatchError) no match of right hand side value: :another_atom\n```\n\nSimilar rule applies to numbers. Finally, note that numbers in patterns perform strict comparison. In other words, integers to do not match floats:\n\n```iex\niex> 1 = 1.0\n** (MatchError) no match of right hand side value: 1.0\n```\n\n### Tuples\n\nTuples may appear in patterns using the curly brackets syntax (`{}`). A tuple in a pattern will match only tuples of the same size, where each individual tuple element must also match:\n\n```iex\niex> {:ok, integer} = {:ok, 13}\n{:ok, 13}\n\n# won't match due to different size\niex> {:ok, integer} = {:ok, 11, 13}\n** (MatchError) no match of right hand side value: {:ok, 11, 13}\n\n# won't match due to mismatch on first element\niex> {:ok, binary} = {:error, :enoent}\n** (MatchError) no match of right hand side value: {:error, :enoent}\n```\n\n### Lists\n\nLists may appear in patterns using the square brackets syntax (`[]`). A list in a pattern will match only lists of the same size, where each individual list element must also match:\n\n```iex\niex> [:ok, integer] = [:ok, 13]\n[:ok, 13]\n\n# won't match due to different size\niex> [:ok, integer] = [:ok, 11, 13]\n** (MatchError) no match of right hand side value: [:ok, 11, 13]\n\n# won't match due to mismatch on first element\niex> [:ok, binary] = [:error, :enoent]\n** (MatchError) no match of right hand side value: [:error, :enoent]\n```\n\nOpposite to tuples, lists also allow matching on non-empty lists by using the `[head | tail]` notation, which matches on the `head` and `tail` of a list:\n\n```iex\niex> [head | tail] = [1, 2, 3]\n[1, 2, 3]\niex> head\n1\niex> tail\n[2, 3]\n```\n\nMultiple elements may prefix the `| tail` construct:\n\n```iex\niex> [first, second | tail] = [1, 2, 3]\n[1, 2, 3]\niex> tail\n[3]\n```\n\nNote `[head | tail]` does not match empty lists:\n\n```elixir\niex> [head | tail] = []\n** (MatchError) no match of right hand side value: []\n```\n\nGiven charlists are represented as a list of integers, one can also perform prefix matches on charlists using the list concatenation operator ([`++`](`++/2`)):\n\n```elixir\niex> ~c\"hello \" ++ world = ~c\"hello world\"\n~c\"hello world\"\niex> world\n~c\"world\"\n```\n\nWhich is equivalent to matching on `[?h, ?e, ?l, ?l, ?o, ?\\s | world]`. Suffix matches (`hello ++ ~c\" world\"`) are not valid patterns.\n\n### Maps\n\nMaps may appear in patterns using the percentage sign followed by the curly brackets syntax (`%{}`). Opposite to lists and tuples, maps perform a subset match. This means a map pattern will match any other map that has at least all of the keys in the pattern.\n\nHere is an example where all keys match:\n\n```iex\niex> %{name: name} = %{name: \"meg\"}\n%{name: \"meg\"}\niex> name\n\"meg\"\n```\n\nHere is when a subset of the keys match:\n\n```iex\niex> %{name: name} = %{name: \"meg\", age: 23}\n%{age: 23, name: \"meg\"}\niex> name\n\"meg\"\n```\n\nIf a key in the pattern is not available in the map, then they won't match:\n\n```iex\niex> %{name: name, age: age} = %{name: \"meg\"}\n** (MatchError) no match of right hand side value: %{name: \"meg\"}\n```\n\nNote that the empty map will match all maps, which is a contrast to tuples and lists, where an empty tuple or an empty list will only match empty tuples and empty lists respectively:\n\n```iex\niex> %{} = %{name: \"meg\"}\n%{name: \"meg\"}\n```\n\nFinally, note map keys in patterns must always be literals or previously bound variables matched with the pin operator.\n\n### Structs\n\nStructs may appear in patterns using the percentage sign, the struct module name or a variable followed by the curly brackets syntax (`%{}`).\n\nGiven the following struct:\n\n```elixir\ndefmodule User do\n defstruct [:name]\nend\n```\n\nHere is an example where all keys match:\n\n```iex\niex> %User{name: name} = %User{name: \"meg\"}\n%User{name: \"meg\"}\niex> name\n\"meg\"\n```\n\nIf an unknown key is given, the compiler will raise an error:\n\n```iex\niex> %User{type: type} = %User{name: \"meg\"}\n** (CompileError) iex: unknown key :type for struct User\n```\n\nThe struct name can be extracted when putting a variable instead of a module name:\n\n```elixir\niex> %struct_name{} = %User{name: \"meg\"}\n%User{name: \"meg\"}\niex> struct_name\nUser\n```\n\n### Binaries\n\nBinaries may appear in patterns using the double less-than/greater-than syntax ([`<<>>`](`<<>>/1`)). A binary in a pattern can match multiple segments at the same time, each with different type, size, and unit:\n\n```iex\niex> <> = <<123, 56>>\n\"{8\"\niex> val\n31544\n```\n\nSee the documentation for [`<<>>`](`<<>>/1`) for a complete definition of pattern matching for binaries.\n\nFinally, remember that strings in Elixir are UTF-8 encoded binaries. This means that, similar to charlists, prefix matches on strings are also possible with the binary concatenation operator ([`<>`](`<>/2`)):\n\n```elixir\niex> \"hello \" <> world = \"hello world\"\n\"hello world\"\niex> world\n\"world\"\n```\n\nSuffix matches (`hello <> \" world\"`) are not valid patterns.\n\n## Guards\n\nGuards are a way to augment pattern matching with more complex checks. They are allowed in a predefined set of constructs where pattern matching is allowed, such as function definitions, case clauses, and others.\n\nNot all expressions are allowed in guard clauses, but only a handful of them. This is a deliberate choice. This way, Elixir (through Erlang) ensures that all guards are predictable (no mutations or other side-effects) and they can be optimized and performed efficiently.\n\n### List of allowed functions and operators\n\nYou can find the built-in list of guards [in the `Kernel` module](`Kernel#guards`). Here is an overview:\n\n * comparison operators ([`==`](`==/2`), [`!=`](`!=/2`), [`===`](`===/2`), [`!==`](`!==/2`),\n [`<`](``](`>/2`), [`>=`](`>=/2`)), [`max`](`max/2`), [`min`](`min/2`)\n * strictly boolean operators ([`and`](`and/2`), [`or`](`or/2`), [`not`](`not/1`)). Note [`&&`](`&&/2`), [`||`](`||/2`), and [`!`](`!/1`) sibling operators are **not allowed** as they're not *strictly* boolean - meaning they don't require arguments to be booleans\n * arithmetic unary operators ([`+`](`+/1`), [`-`](`-/1`))\n * arithmetic binary operators ([`+`](`+/2`), [`-`](`-/2`), [`*`](`*/2`), [`/`](`//2`))\n * [`in`](`in/2`) and [`not in`](`in/2`) operators (as long as the right-hand side is a list or a range)\n * \"type-check\" functions (`is_list/1`, `is_number/1`, and the like)\n * functions that work on built-in data types (`abs/1`, `hd/1`, `map_size/1`, and others)\n * the `map.field` syntax\n\nThe module `Bitwise` also includes a handful of [Erlang bitwise operations as guards](Bitwise.html#guards).\n\nMacros constructed out of any combination of the above guards are also valid guards - for example, `Integer.is_even/1`. For more information, see the \"Custom patterns and guards expressions\" section shown below.\n\n### Why guards\n\nLet's see an example of a guard used in a function clause:\n\n```elixir\ndef empty_map?(map) when map_size(map) == 0, do: true\ndef empty_map?(map) when is_map(map), do: false\n```\n\nGuards start with the `when` operator, followed by a guard expression. The clause will be executed if and only if the guard expression returns `true`. Multiple boolean conditions can be combined with the [`and`](`and/2`) and [`or`](`or/2`) operators.\n\nWriting the `empty_map?/1` function by only using pattern matching would not be possible (as pattern matching on `%{}` would match *any* map, not only the empty ones).\n\n### Non-passing guards\n\nA function clause will be executed if and only if its guard expression evaluates to `true`. If any other value is returned, the function clause will be skipped. In particular, guards have no concept of \"truthy\" or \"falsy\".\n\nFor example, imagine a function that checks that the head of a list is not `nil`:\n\n```elixir\ndef not_nil_head?([head | _]) when head, do: true\ndef not_nil_head?(_), do: false\n\nnot_nil_head?([\"some_value\", \"another_value\"])\n#=> false\n```\n\nEven though the head of the list is not `nil`, the first clause for `not_nil_head?/1` fails because the expression does not evaluate to `true`, but to `\"some_value\"`, therefore triggering the second clause which returns `false`. To make the guard behave correctly, you must ensure that the guard evaluates to `true`, like so:\n\n```elixir\ndef not_nil_head?([head | _]) when head != nil, do: true\ndef not_nil_head?(_), do: false\n\nnot_nil_head?([\"some_value\", \"another_value\"])\n#=> true\n```\n\n### Errors in guards\n\nIn guards, when functions would normally raise exceptions, they cause the guard to fail instead.\n\nFor example, the `tuple_size/1` function only works with tuples. If we use it with anything else, an argument error is raised:\n\n```elixir\niex> tuple_size(\"hello\")\n** (ArgumentError) argument error\n```\n\nHowever, when used in guards, the corresponding clause will fail to match instead of raising an error:\n\n```elixir\niex> case \"hello\" do\n...> something when tuple_size(something) == 2 ->\n...> :worked\n...> _anything_else ->\n...> :failed\n...> end\n:failed\n```\n\nIn many cases, we can take advantage of this. In the code above, we used `tuple_size/1` to both check that the given value is a tuple *and* check its size (instead of using `is_tuple(something) and tuple_size(something) == 2`).\n\nHowever, if your guard has multiple conditions, such as checking for tuples or maps, it is best to call type-check functions like `is_tuple/1` before `tuple_size/1`, otherwise the whole guard will fail if a tuple is not given. Alternatively, your function clause can use multiple guards as shown in the following section.\n\n### Multiple guards in the same clause\n\nThere exists an additional way to simplify a chain of `or` expressions in guards: Elixir supports writing \"multiple guards\" in the same clause. The following code:\n\n```elixir\ndef categorize_number(term) when is_integer(term) or is_float(term) or is_nil(term),\n do: :maybe_number\ndef categorize_number(_other),\n do: :something_else\n```\n\ncan be alternatively written as:\n\n```elixir\ndef categorize_number(term)\n when is_integer(term)\n when is_float(term)\n when is_nil(term) do\n :maybe_number\nend\n\ndef categorize_number(_other) do\n :something_else\nend\n```\n\nIf each guard expression always returns a boolean, the two forms are equivalent. However, recall that if any function call in a guard raises an exception, the entire guard fails. To illustrate this, the following function will not detect empty tuples:\n\n```elixir\ndefmodule Check do\n # If given a tuple, map_size/1 will raise, and tuple_size/1 will not be evaluated\n def empty?(val) when map_size(val) == 0 or tuple_size(val) == 0, do: true\n def empty?(_val), do: false\nend\n\nCheck.empty?(%{})\n#=> true\n\nCheck.empty?({})\n#=> false # true was expected!\n```\n\nThis could be corrected by ensuring that no exception is raised, either via type checks like `is_map(val) and map_size(val) == 0`, or by using multiple guards, so that if an exception causes one guard to fail, the next one is evaluated.\n\n```elixir\ndefmodule Check do\n # If given a tuple, map_size/1 will raise, and the second guard will be evaluated\n def empty?(val)\n when map_size(val) == 0\n when tuple_size(val) == 0,\n do: true\n\n def empty?(_val), do: false\nend\n\nCheck.empty?(%{})\n#=> true\n\nCheck.empty?({})\n#=> true\n```\n\n## Where patterns and guards can be used\n\nIn the examples above, we have used the match operator ([`=`](`=/2`)) and function clauses to showcase patterns and guards respectively. Here is the list of the built-in constructs in Elixir that support patterns and guards.\n\n * `match?/2`:\n\n ```elixir\n match?({:ok, value} when value > 0, {:ok, 13})\n ```\n\n * function clauses:\n\n ```elixir\n def type(term) when is_integer(term), do: :integer\n def type(term) when is_float(term), do: :float\n ```\n\n * [`case`](`case/2`) expressions:\n\n ```elixir\n case x do\n 1 -> :one\n 2 -> :two\n n when is_integer(n) and n > 2 -> :larger_than_two\n end\n ```\n\n * anonymous functions (`fn/1`):\n\n ```elixir\n larger_than_two? = fn\n n when is_integer(n) and n > 2 -> true\n n when is_integer(n) -> false\n end\n ```\n\n * [`for`](`for/1`) and [`with`](`with/1`) support patterns and guards on the left side of `<-`:\n\n ```elixir\n for x when x >= 0 <- [1, -2, 3, -4], do: x\n ```\n\n `with` also supports the `else` keyword, which supports patterns matching and guards.\n\n * [`try`](`try/1`) supports patterns and guards on `catch` and `else`\n\n * [`receive`](`receive/1`) supports patterns and guards to match on the received messages.\n\n * custom guards can also be defined with `defguard/1` and `defguardp/1`. A custom guard can only be defined based on existing guards.\n\nNote that the match operator ([`=`](`=/2`)) does *not* support guards:\n\n```elixir\n{:ok, binary} = File.read(\"some/file\")\n```\n\n## Custom patterns and guards expressions\n\nOnly the constructs listed in this page are allowed in patterns and guards. However, we can take advantage of macros to write custom patterns guards that can simplify our programs or make them more domain-specific. At the end of the day, what matters is that the *output* of the macros boils down to a combination of the constructs above.\n\nFor example, the `Record` module in Elixir provides a series of macros to be used in patterns and guards that allows tuples to have named fields during compilation.\n\nFor defining your own guards, Elixir even provides conveniences in `defguard` and `defguardp`. Let's look at a quick case study: we want to check whether an argument is an even or an odd integer. With pattern matching this is impossible because there is an infinite number of integers, and therefore we can't pattern match on every single one of them. Therefore we must use guards. We will just focus on checking for even numbers since checking for the odd ones is almost identical.\n\nSuch a guard would look like this:\n\n```elixir\ndef my_function(number) when is_integer(number) and rem(number, 2) == 0 do\n # do stuff\nend\n```\n\nIt would be repetitive to write every time we need this check. Instead, you can use `defguard/1` and `defguardp/1` to create guard macros. Here's an example how:\n\n```elixir\ndefmodule MyInteger do\n defguard is_even(term) when is_integer(term) and rem(term, 2) == 0\nend\n```\n\nand then:\n\n```elixir\nimport MyInteger, only: [is_even: 1]\n\ndef my_function(number) when is_even(number) do\n # do stuff\nend\n```\n\nWhile it's possible to create custom guards with macros, it's recommended to define them using `defguard/1` and `defguardp/1` which perform additional compile-time checks.\n" }, { "path": "lib/elixir/pages/references/sbom.md", "content": "\n\n# Software Bill of Materials\n\nA Software Bill of Materials (SBoM) is a structured inventory of the components that make up a software system. This guide explains what SBoMs are, why they matter, and how to generate them for Elixir projects.\n\n## What is an SBoM?\n\nAn SBoM is a formal, machine-readable record of all components in a piece of software. Think of it as a detailed ingredient list for your application. A typical SBoM includes:\n\n * **Dependencies**: all libraries and packages your project uses\n * **Versions**: the exact version of each component\n * **Source locations**: where each component was obtained (Hex, GitHub, etc.)\n * **Checksums**: cryptographic hashes to verify integrity\n * **Licensing information**: the license under which each component is distributed\n\nTwo widely adopted standards exist for SBoM formats:\n\n * [CycloneDX](https://cyclonedx.org/): a lightweight standard designed for security contexts\n * [SPDX](https://spdx.dev/): a more comprehensive standard originally focused on licensing\n\nBoth formats are machine-readable (JSON, XML) and designed to be consumed by automated tooling.\n\n> #### SBoM is an inventory, not a certification {: .info}\n>\n> An SBoM does not claim that software is secure, compliant, or free of vulnerabilities.\n> It simply provides a detailed inventory that enables further analysis. Security and\n> compliance assessments are performed by separate tools that consume the SBoM.\n\n## Why generate SBoMs?\n\nThere are three main reasons to generate SBoMs for your projects.\n\n### Vulnerability analysis\n\nWhen a security vulnerability (CVE) is discovered in a library, you need to quickly determine if your projects are affected. SBoMs make this possible by providing a complete inventory of your dependencies.\n\nTools like [OWASP Dependency-Track](https://dependencytrack.org/) continuously monitor your SBoMs against vulnerability databases. When a new CVE is published, you get notified if any of your projects use the affected component.\n\nWithout an SBoM, answering \"are we affected by CVE-2024-XXXXX?\" means manually checking each project, which is time-consuming and error-prone.\n\n### Regulatory requirements\n\nSBoMs are required by some regulations and procurement policies:\n\n * **US Executive Order 14028** (2021) requires SBoMs for certain software supplied to the U.S. federal government, particularly for designated critical software\n * **EU Cyber Resilience Act** introduces requirements for component inventories (commonly fulfilled using SBoMs) for products with digital elements placed on the EU market\n * **Safety-critical industries** (medical devices, automotive, aerospace) often require detailed component inventories as part of certification\n\nCustomers and partners may also request SBoMs as part of their own compliance efforts.\n\n### License compliance\n\nEvery dependency in your project comes with a license. An SBoM provides a starting point for license review by listing the declared license for each package. This helps you:\n\n * Get an overview of licenses in your dependency tree\n * Flag packages that may need closer review\n * Support due diligence for acquisitions, audits, or legal review\n\nNote that package-level license information (as provided by mix_sbom) reflects what the package declares, not necessarily all licenses present in its source files. For thorough license compliance, file-level scanning tools like ORT provide deeper analysis.\n\n## Generating SBoMs with mix_sbom\n\n[mix_sbom](https://github.com/erlef/mix_sbom) is an EEF project that generates CycloneDX SBoMs for Elixir projects.\n\n### Installation\n\nThere are several ways to install mix_sbom:\n\n * **As a project dependency**: add `sbom` to your `mix.exs`\n * **As a global escript**: run `mix escript.install hex sbom` (requires Elixir 1.19.4+)\n * **As a standalone binary**: download from the [releases page](https://github.com/erlef/mix_sbom/releases)\n\nThe standalone binary is useful for CI environments or when you don't want to modify your project's dependencies. It requires no local Elixir or Erlang installation.\n\n### Basic usage\n\nTo generate an SBoM for your project using the standalone binary:\n\n```console\n$ mix_sbom cyclonedx /path/to/your/project\n```\n\nThis creates a `bom.cdx.json` file in CycloneDX format containing your project's complete dependency tree.\n\n### Common options\n\nThe most useful options are:\n\n * `-o, --output PATH`: specify the output file (default: `bom.cdx.json`)\n * `-t, --format FORMAT`: output format (`json`, `xml`, or `protobuf`)\n * `-s, --schema VERSION`: CycloneDX schema version\n\nFor example, to generate an XML format SBoM:\n\n```console\n$ mix_sbom cyclonedx --format xml --output sbom.xml /path/to/project\n```\n\n## CI integration\n\nFor automated SBoM generation, mix_sbom provides a GitHub Action:\n\n```yaml\nname: Generate SBoM\non:\n release:\n types: [published]\n\njobs:\n sbom:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - uses: erlef/mix_sbom@v0\n with:\n path: \".\"\n format: \"json\"\n - uses: actions/upload-artifact@v4\n with:\n name: sbom\n path: bom.cdx.json\n```\n\nThis workflow generates an SBoM whenever you publish a release and uploads it as a build artifact. See the [action's documentation](https://github.com/erlef/mix_sbom) for additional options.\n\n## Deeper analysis with ORT\n\nmix_sbom provides package-level license information based on what each dependency declares. However, some compliance workflows require file-level scanning. A package might declare an MIT license but contain individual files under different licenses, or include vendored code with its own licensing terms.\n\nThe [OSS Review Toolkit (ORT)](https://oss-review-toolkit.org/) addresses this by scanning actual source files for license headers and copyright notices. ORT supports Mix projects and provides:\n\n * **File-level license detection**: scans source code for license texts and SPDX identifiers\n * **Copyright holder identification**: extracts copyright notices from files\n * **Policy enforcement**: define rules for allowed and denied licenses\n * **Multi-ecosystem support**: analyze projects that span multiple package managers\n\nFor organizations with strict compliance requirements, ORT complements mix_sbom by providing the deeper analysis needed for thorough license audits.\n\nSee the [ORT Mix plugin documentation](https://oss-review-toolkit.org/ort/docs/plugins/package-managers/Mix) for details.\n\n## Next steps\n\n * [CycloneDX Specification](https://cyclonedx.org/specification/overview/): learn more about the SBoM format\n * [OWASP Dependency-Track](https://dependencytrack.org/): continuous SBoM analysis platform\n * [mix_sbom documentation](https://hexdocs.pm/sbom): full documentation and advanced options\n" }, { "path": "lib/elixir/pages/references/syntax-reference.md", "content": "\n\n# Syntax reference\n\nElixir syntax was designed to have a straightforward conversion to an abstract syntax tree (AST). This means the Elixir syntax is mostly uniform with a handful of \"syntax sugar\" constructs to reduce the noise in common Elixir idioms.\n\nThis document covers all of Elixir syntax constructs as a reference and then discuss their exact AST representation.\n\n## Reserved words\n\nThese are the reserved words in the Elixir language. They are detailed throughout this guide but summed up here for convenience:\n\n * `true`, `false`, `nil` - used as atoms\n * `when`, `and`, `or`, `not`, `in` - used as operators\n * `fn` - used for anonymous function definitions\n * `do`, `end`, `catch`, `rescue`, `after`, `else` - used in do-end blocks\n\n## Data types\n\n### Numbers\n\nIntegers (`1234`) and floats (`123.4`) in Elixir are represented as a sequence of digits that may be separated by underscore for readability purposes, such as `1_000_000`. Integers never contain a dot (`.`) in their representation. Floats contain a dot and at least one other digit after the dot. Floats also support the scientific notation, such as `123.4e10` or `123.4E10`.\n\n### Atoms\n\nUnquoted atoms start with a colon (`:`) which must be immediately followed by a Unicode letter or an underscore. The atom may continue using a sequence of Unicode letters, numbers, underscores, and `@`. Atoms may end in `!` or `?`. Valid unquoted atoms are: `:ok`, `:ISO8601`, and `:integer?`.\n\nIf the colon is immediately followed by a pair of double- or single-quotes surrounding the atom name, the atom is considered quoted. In contrast with an unquoted atom, this one can be made of any Unicode character (not only letters), such as `:'🌢 Elixir'`, `:\"++olá++\"`, and `:\"123\"`.\n\nQuoted and unquoted atoms with the same name are considered equivalent, so `:atom`, `:\"atom\"`, and `:'atom'` represent the same atom. The only catch is that the compiler will warn when quotes are used in atoms that do not need to be quoted.\n\nAll operators in Elixir are also valid atoms. Valid examples are `:foo`, `:FOO`, `:foo_42`, `:foo@bar`, and `:++`. Invalid examples are `:@foo` (`@` is not allowed at start), `:123` (numbers are not allowed at start), and `:(*)` (not a valid operator).\n\n`true`, `false`, and `nil` are reserved words that are represented by the atoms `:true`, `:false` and `:nil` respectively.\n\nTo learn more about all Unicode characters allowed in atom, see the [Unicode syntax](unicode-syntax.md) document.\n\n### Strings\n\nSingle-line strings in Elixir are written between double-quotes, such as `\"foo\"`. Any double-quote inside the string must be escaped with `\\ `. Strings support Unicode characters and are stored as UTF-8 encoded binaries.\n\nMulti-line strings in Elixir are called heredocs. They are written with three double-quotes, and can have unescaped quotes within them. The resulting string will end with a newline. The indentation of the last `\"\"\"` is used to strip indentation from the inner string. For example:\n\n```elixir\niex> test = \"\"\"\n...> this\n...> is\n...> a\n...> test\n...> \"\"\"\n\" this\\n is\\n a\\n test\\n\"\niex> test = \"\"\"\n...> This\n...> Is\n...> A\n...> Test\n...> \"\"\"\n\"This\\nIs\\nA\\nTest\\n\"\n```\n\nStrings are always represented as themselves in the AST.\n\n### Charlists\n\nCharlists are lists of non-negative integers where each integer represents a Unicode code point.\n\n```elixir\niex(6)> 'abc' === [97, 98, 99]\ntrue\n```\n\nCharlists are written in single-quotes, such as `'foo'`. Any single-quote inside the string must be escaped with `\\ `.\nMulti-line charlists are written with three single-quotes (`'''`), the same way multi-line strings are.\nHowever, this syntax is deprecated in favor of the charlist sigil `~c`.\n\nCharlists are always represented as themselves in the AST.\n\nFor more in-depth information, please read the \"Charlists\" section in the `List` module.\n\n### Lists, tuples and binaries\n\nData structures such as lists, tuples, and binaries are marked respectively by the delimiters `[...]`, `{...}`, and `<<...>>`. Each element is separated by comma. A trailing comma is also allowed, such as in `[1, 2, 3,]`.\n\n### Maps and keyword lists\n\nMaps use the `%{...}` notation and each key-value is given by pairs marked with `=>`, such as `%{\"hello\" => 1, 2 => \"world\"}`.\n\nBoth keyword lists (list of two-element tuples where the first element is an atom) and maps with atom keys support a keyword notation where the colon character `:` is moved to the end of the atom. `%{hello: \"world\"}` is equivalent to `%{:hello => \"world\"}` and `[foo: :bar]` is equivalent to `[{:foo, :bar}]`. We discuss keywords in later sections.\n\n### Structs\n\nStructs built on the map syntax by passing the struct name between `%` and `{`. For example, `%User{...}`.\n\n## Expressions\n\n### Variables\n\nVariables in Elixir must start with an underscore or a Unicode letter that is not in uppercase or titlecase. The variable may continue using a sequence of Unicode letters, numbers, and underscores. Variables may end in `?` or `!`. To learn more about all Unicode characters allowed in variables, see the [Unicode syntax](unicode-syntax.md) document.\n\n[Elixir's naming conventions](naming-conventions.md) recommend variables to be in `snake_case` format.\n\n### Non-qualified calls (local calls)\n\nNon-qualified calls, such as `add(1, 2)`, must start with characters and then follow the same rules as variables, which are optionally followed by parentheses, and then arguments.\n\nParentheses are required for zero-arity calls (i.e. calls without arguments), to avoid ambiguity with variables. If parentheses are used, they must immediately follow the function name *without spaces*. For example, `add (1, 2)` is a syntax error, since `(1, 2)` is treated as an invalid block which is attempted to be given as a single argument to `add`.\n\n[Elixir's naming conventions](naming-conventions.md) recommend calls to be in `snake_case` format.\n\n### Operators\n\nAs many programming languages, Elixir also support operators as non-qualified calls with their precedence and associativity rules. Constructs such as `=`, `when`, `&` and `@` are simply treated as operators. See [the Operators page](operators.md) for a full reference.\n\n### Qualified calls (remote calls)\n\nQualified calls, such as `Math.add(1, 2)`, must start with characters and then follow the same rules as variables, which are optionally followed by parentheses, and then arguments. Qualified calls also support operators, such as `Kernel.+(1, 2)`. Elixir also allows the function name to be written between double- or single-quotes, allowing any character in between the quotes, such as `Math.\"++add++\"(1, 2)`.\n\nSimilar to non-qualified calls, parentheses have different meaning for zero-arity calls (i.e. calls without arguments). If parentheses are used, such as `mod.fun()`, it means a function call. If parenthesis are skipped, such as `map.field`, it means accessing a field of a map.\n\n[Elixir's naming conventions](naming-conventions.md) recommend calls to be in `snake_case` format.\n\n### Aliases\n\nAliases are constructs that expand to atoms at compile-time. The alias `String` expands to the atom `:\"Elixir.String\"`. Aliases must start with an ASCII uppercase character which may be followed by any ASCII letter, number, or underscore. Non-ASCII characters are not supported in aliases.\n\nMultiple aliases can be joined with `.`, such as `MyApp.String`, and it expands to the atom `:\"Elixir.MyApp.String\"`. The dot is effectively part of the name but it can also be used for composition. If you define `alias MyApp.Example, as: Example` in your code, then `Example` will always expand to `:\"Elixir.MyApp.Example\"` and `Example.String` will expand to `:\"Elixir.MyApp.Example.String\"`.\n\n[Elixir's naming conventions](naming-conventions.md) recommend aliases to be in `CamelCase` format.\n\n### Module attributes\n\nModule attributes are module-specific storage and are written as the composition of the unary operator `@` with variables and local calls. For example, to write to a module attribute named `foo`, use `@foo \"value\"`, and use `@foo` to read from it. Given module attributes are written using existing constructs, they follow the same rules above defined for operators, variables, and local calls.\n\n### Blocks\n\nBlocks are multiple Elixir expressions separated by newlines or semi-colons. A new block may be created at any moment by using parentheses.\n\n### Left to right arrow\n\nThe left to right arrow (`->`) is used to establish a relationship between left and right, commonly referred as clauses. The left side may have zero, one, or more arguments; the right side is zero, one, or more expressions separated by new line. The `->` may appear one or more times between one of the following terminators: `do`-`end`, `fn`-`end` or `(`-`)`. When `->` is used, only other clauses are allowed between those terminators. Mixing clauses and regular expressions is invalid syntax.\n\nIt is seen on `case` and `cond` constructs between `do` and `end`:\n\n```elixir\ncase 1 do\n 2 -> 3\n 4 -> 5\nend\n\ncond do\n true -> false\nend\n```\n\nSeen in typespecs between `(` and `)`:\n\n```elixir\n(integer(), boolean() -> integer())\n```\n\nIt is also used between `fn` and `end` for building anonymous functions:\n\n```elixir\nfn\n x, y -> x + y\nend\n```\n\n### Sigils\n\nSigils start with `~` and are followed by one lowercase letter or by one or more uppercase letters, immediately followed by one of the following pairs:\n\n * `(` and `)`\n * `{` and `}`\n * `[` and `]`\n * `<` and `>`\n * `\"` and `\"`\n * `'` and `'`\n * `|` and `|`\n * `/` and `/`\n\nAfter closing the pair, zero or more ASCII letters and digits can be given as a modifier. Sigils are expressed as non-qualified calls prefixed with `sigil_` where the first argument is the sigil contents as a string and the second argument is a list of integers as modifiers:\n\nIf the sigil letter is in uppercase, no interpolation is allowed in the sigil, otherwise its contents may be dynamic. Compare the results of the sigils below for more information:\n\n```elixir\n~s/f#{\"o\"}o/\n~S/f#{\"o\"}o/\n```\n\nSigils are useful to encode text with their own escaping rules, such as regular expressions, datetimes, and others.\n\n## The Elixir AST\n\nElixir syntax was designed to have a straightforward conversion to an abstract syntax tree (AST). Elixir's AST is a regular Elixir data structure composed of the following elements:\n\n * atoms - such as `:foo`\n * integers - such as `42`\n * floats - such as `13.1`\n * strings - such as `\"hello\"`\n * lists - such as `[1, 2, 3]`\n * tuples with two elements - such as `{\"hello\", :world}`\n * tuples with three elements, representing calls or variables, as explained next\n\nThe building block of Elixir's AST is a call, such as:\n\n```elixir\nsum(1, 2, 3)\n```\n\nwhich is represented as a tuple with three elements:\n\n```elixir\n{:sum, meta, [1, 2, 3]}\n```\n\nthe first element is an atom (or another tuple), the second element is a list of two-element tuples with metadata (such as line numbers) and the third is a list of arguments.\n\nWe can retrieve the AST for any Elixir expression by calling `quote`:\n\n```elixir\nquote do\n sum()\nend\n#=> {:sum, [], []}\n```\n\nVariables are also represented using a tuple with three elements and a combination of lists and atoms, for example:\n\n```elixir\nquote do\n sum\nend\n#=> {:sum, [], Elixir}\n```\n\nYou can see that variables are also represented with a tuple, except the third element is an atom expressing the variable context.\n\nOver the course of this section, we will explore many Elixir syntax constructs alongside their AST representations.\n\n### Operators\n\nOperators are treated as non-qualified calls:\n\n```elixir\nquote do\n 1 + 2\nend\n#=> {:+, [], [1, 2]}\n```\n\nNote that `.` is also an operator. Remote calls use the dot in the AST with two arguments, where the second argument is always an atom:\n\n```elixir\nquote do\n foo.bar(1, 2, 3)\nend\n#=> {{:., [], [{:foo, [], Elixir}, :bar]}, [], [1, 2, 3]}\n```\n\nCalling anonymous functions uses the dot in the AST with a single argument, mirroring the fact the function name is \"missing\" from right side of the dot:\n\n```elixir\nquote do\n foo.(1, 2, 3)\nend\n#=> {{:., [], [{:foo, [], Elixir}]}, [], [1, 2, 3]}\n```\n\n### Aliases\n\nAliases are represented by an `__aliases__` call with each segment separated by a dot as an argument:\n\n```elixir\nquote do\n Foo.Bar.Baz\nend\n#=> {:__aliases__, [], [:Foo, :Bar, :Baz]}\n\nquote do\n __MODULE__.Bar.Baz\nend\n#=> {:__aliases__, [], [{:__MODULE__, [], Elixir}, :Bar, :Baz]}\n```\n\nAll arguments, except the first, are guaranteed to be atoms.\n\n### Data structures\n\nRemember that lists are literals, so they are represented as themselves in the AST:\n\n```elixir\nquote do\n [1, 2, 3]\nend\n#=> [1, 2, 3]\n```\n\nTuples have their own representation, except for two-element tuples, which are represented as themselves:\n\n```elixir\nquote do\n {1, 2}\nend\n#=> {1, 2}\n\nquote do\n {1, 2, 3}\nend\n#=> {:{}, [], [1, 2, 3]}\n```\n\nBinaries have a representation similar to tuples, except they are tagged with `:<<>>` instead of `:{}`:\n\n```elixir\nquote do\n <<1, 2, 3>>\nend\n#=> {:<<>>, [], [1, 2, 3]}\n```\n\nThe same applies to maps, where pairs are treated as a list of tuples with two elements:\n\n```elixir\nquote do\n %{1 => 2, 3 => 4}\nend\n#=> {:%{}, [], [{1, 2}, {3, 4}]}\n```\n\n### Blocks\n\nBlocks are represented as a `__block__` call with each line as a separate argument:\n\n```elixir\nquote do\n 1\n 2\n 3\nend\n#=> {:__block__, [], [1, 2, 3]}\n\nquote do 1; 2; 3; end\n#=> {:__block__, [], [1, 2, 3]}\n```\n\n### Left to right arrow\n\nThe left to right arrow (`->`) is represented similar to operators except that they are always part of a list, its left side represents a list of arguments and the right side is an expression.\n\nFor example, in `case` and `cond`:\n\n```elixir\nquote do\n case 1 do\n 2 -> 3\n 4 -> 5\n end\nend\n#=> {:case, [], [1, [do: [{:->, [], [[2], 3]}, {:->, [], [[4], 5]}]]]}\n\nquote do\n cond do\n true -> false\n end\nend\n#=> {:cond, [], [[do: [{:->, [], [[true], false]}]]]}\n```\n\nBetween `(` and `)`:\n\n```elixir\nquote do\n (1, 2 -> 3\n 4, 5 -> 6)\nend\n#=> [{:->, [], [[1, 2], 3]}, {:->, [], [[4, 5], 6]}]\n```\n\nBetween `fn` and `end`:\n\n```elixir\nquote do\n fn\n 1, 2 -> 3\n 4, 5 -> 6\n end\nend\n#=> {:fn, [], [{:->, [], [[1, 2], 3]}, {:->, [], [[4, 5], 6]}]}\n```\n\n### Qualified tuples\n\nQualified tuples (`foo.{bar, baz}`) are represented by a `{:., [], [expr, :{}]}` call, where the `expr` represents the left hand side of the dot, and the arguments represent the elements inside the curly braces. This is used in Elixir to provide multi aliases:\n\n```elixir\nquote do\n Foo.{Bar, Baz}\nend\n#=> {{:., [], [{:__aliases__, [], [:Foo]}, :{}]}, [], [{:__aliases__, [], [:Bar]}, {:__aliases__, [], [:Baz]}]}\n```\n\n### `do`-`end` blocks\n\nElixir's `do`-`end` blocks are equivalent to keywords as the last argument of a function call, where the block contents are wrapped in parentheses. For example:\n\n```elixir\nif true do\n this\nelse\n that\nend\n```\n\nis the same as:\n\n```elixir\nif(true, do: (this), else: (that))\n```\n\nWhile the construct above does not require custom nodes in Elixir's AST, they are restricted only to certain keywords, listed next:\n\n * `after`\n * `catch`\n * `else`\n * `rescue`\n\nYou will find them in constructs such as `receive`, `try`, and others. You can also find more examples in [the Optional Syntax chapter](../getting-started/optional-syntax.md).\n" }, { "path": "lib/elixir/pages/references/typespecs.md", "content": "\n\n# Typespecs reference\n\n> #### Typespecs are not set-theoretic types {: .warning}\n>\n> Elixir is in the process of implementing its\n> [own type system](./gradual-set-theoretic-types.md) based on set-theoretic types.\n> Typespecs, which are described in the following document, are a distinct notation\n> for declaring types and specifications based on Erlang.\n> Typespecs may be phased out as the set-theoretic type effort moves forward.\n\nElixir is a dynamically typed language, and as such, type specifications are never used by the compiler to optimize or modify code. Still, using type specifications is useful because:\n\n * they provide documentation (for example, tools such as [`ExDoc`](https://hexdocs.pm/ex_doc/) show type specifications in the documentation)\n * they're used by tools such as [Dialyzer](`:dialyzer`), that can analyze code with typespecs to find type inconsistencies and possible bugs\n\nType specifications (most often referred to as *typespecs*) are defined in different contexts using the following attributes:\n\n * `@type`\n * `@opaque`\n * `@typep`\n * `@spec`\n * `@callback`\n * `@macrocallback`\n\nIn addition, you can use `@typedoc` to document a custom `@type` definition.\n\nSee the \"User-defined types\" and \"Defining a specification\" sub-sections below for more information on defining types and typespecs.\n\n## A simple example\n\n defmodule StringHelpers do\n @typedoc \"A word from the dictionary\"\n @type word() :: String.t()\n\n @spec long_word?(word()) :: boolean()\n def long_word?(word) when is_binary(word) do\n String.length(word) > 8\n end\n end\n\nIn the example above:\n\n * We declare a new type (`word()`) that is equivalent to the string type (`String.t()`).\n\n * We describe the type using a `@typedoc`, which will be included in the generated documentation.\n\n * We specify that the `long_word?/1` function takes an argument of type `word()` and\n returns a boolean (`boolean()`), that is, either `true` or `false`.\n\n## Types and their syntax\n\nThe syntax Elixir provides for type specifications is similar to [the one in Erlang](https://www.erlang.org/doc/reference_manual/typespec.html). Most of the built-in types provided in Erlang (for example, `pid()`) are expressed in the same way: `pid()` (or simply `pid`). Parameterized types (such as `list(integer)`) are supported as well and so are remote types (such as [`Enum.t()`](`t:Enum.t/0`)). Integers and atom literals are allowed as types (for example, `1`, `:atom`, or `false`). All other types are built out of unions of predefined types. Some types can also be declared using their syntactical notation, such as `[type]` for lists, `{type1, type2, ...}` for tuples and `<<_ * _>>` for binaries.\n\nThe notation to represent the union of types is the pipe `|`. For example, the typespec `type :: atom() | pid() | tuple()` creates a type `type` that can be either an `atom`, a `pid`, or a `tuple`. This is usually called a [sum type](https://en.wikipedia.org/wiki/Tagged_union) in other languages\n\n> #### Differences with set-theoretic types {: .warning}\n>\n> While they do share some similarities, the types below do not map one-to-one\n> to the new types from the set-theoretic type system.\n>\n> For example, there is no plan to support subsets of the `integer()` type such\n> as positive, ranges or literals.\n>\n> Furthermore, set-theoretic types support the full range of set operations,\n> including intersections and negations.\n\n### Basic types\n\n type ::\n any() # the top type, the set of all terms\n | none() # the bottom type, contains no terms\n | atom()\n | map() # any map\n | pid() # process identifier\n | port() # port identifier\n | reference()\n | tuple() # tuple of any size\n\n ## Numbers\n | float()\n | integer()\n | neg_integer() # ..., -3, -2, -1\n | non_neg_integer() # 0, 1, 2, 3, ...\n | pos_integer() # 1, 2, 3, ...\n\n ## Lists\n | list(type) # proper list ([]-terminated)\n | nonempty_list(type) # non-empty proper list\n | maybe_improper_list(content_type, termination_type) # proper or improper list\n | nonempty_improper_list(content_type, termination_type) # improper list\n | nonempty_maybe_improper_list(content_type, termination_type) # non-empty proper or improper list\n\n | Literals # Described in section \"Literals\"\n | BuiltIn # Described in section \"Built-in types\"\n | Remotes # Described in section \"Remote types\"\n | UserDefined # Described in section \"User-defined types\"\n\n### Literals\n\nThe following literals are also supported in typespecs:\n\n type :: ## Atoms\n :atom # atoms: :foo, :bar, ...\n | true | false | nil # special atom literals\n\n ## Bitstrings\n | <<>> # empty bitstring\n | <<_::size>> # size is 0 or a positive integer\n | <<_::_*unit>> # unit is an integer from 1 to 256\n | <<_::size, _::_*unit>>\n\n ## (Anonymous) Functions\n | (-> type) # zero-arity, returns type\n | (type1, type2 -> type) # two-arity, returns type\n | (... -> type) # any arity, returns type\n\n ## Integers\n | 1 # integer\n | 1..10 # integer from 1 to 10\n\n ## Lists\n | [type] # list with any number of type elements\n | [] # empty list\n | [...] # shorthand for nonempty_list(any())\n | [type, ...] # shorthand for nonempty_list(type)\n | [key: value_type] # keyword list with optional key :key of value_type\n\n ## Maps\n | %{} # empty map\n | %{key: value_type} # map with required key :key of value_type\n | %{key_type => value_type} # map with required pairs of key_type and value_type\n | %{required(key_type) => value_type} # map with required pairs of key_type and value_type\n | %{optional(key_type) => value_type} # map with optional pairs of key_type and value_type\n | %SomeStruct{} # struct with all fields of any type\n | %SomeStruct{key: value_type} # struct with required key :key of value_type\n\n ## Tuples\n | {} # empty tuple\n | {:ok, type} # two-element tuple with an atom and any type\n\n### Built-in types\n\nThe following types are also provided by Elixir as shortcuts on top of the basic and literal types described above.\n\nBuilt-in type | Defined as\n:---------------------- | :---------\n`term()` | `any()`\n`arity()` | `0..255`\n`as_boolean(t)` | `t`\n`binary()` | `<<_::_*8>>`\n`nonempty_binary()` | `<<_::8, _::_*8>>`\n`bitstring()` | `<<_::_*1>>`\n`nonempty_bitstring()` | `<<_::1, _::_*1>>`\n`boolean()` | `true` \\| `false`\n`byte()` | `0..255`\n`char()` | `0..0x10FFFF`\n`charlist()` | `[char()]`\n`nonempty_charlist()` | `[char(), ...]`\n`fun()` | `(... -> any)`\n`function()` | `fun()`\n`identifier()` | `pid()` \\| `port()` \\| `reference()`\n`iodata()` | `iolist()` \\| `binary()`\n`iolist()` | `maybe_improper_list(byte() \\| binary() \\| iolist(), binary() \\| [])`\n`keyword()` | `[{atom(), any()}]`\n`keyword(t)` | `[{atom(), t}]`\n`list()` | `[any()]`\n`nonempty_list()` | `nonempty_list(any())`\n`maybe_improper_list()` | `maybe_improper_list(any(), any())`\n`nonempty_maybe_improper_list()` | `nonempty_maybe_improper_list(any(), any())`\n`mfa()` | `{module(), atom(), arity()}`\n`module()` | `atom()`\n`no_return()` | `none()`\n`node()` | `atom()`\n`number()` | `integer()` \\| `float()`\n`struct()` | `%{:__struct__ => atom(), optional(atom()) => any()}`\n`timeout()` | `:infinity` \\| `non_neg_integer()`\n\n`as_boolean(t)` exists to signal users that the given value will be treated as a boolean, where `nil` and `false` will be evaluated as `false` and everything else is `true`. For example, `Enum.filter/2` has the following specification: `filter(t, (element -> as_boolean(term))) :: list`.\n\n### Remote types\n\nAny module is also able to define its own types and the modules in Elixir are no exception. For example, the `Range` module defines a `t/0` type that represents a range: this type can be referred to as `t:Range.t/0`. In a similar fashion, a string is `t:String.t/0`, and so on.\n\n### Maps\n\nThe key types in maps are allowed to overlap, and if they do, the leftmost key takes precedence.\nA map value does not belong to this type if it contains a key that is not in the allowed map keys.\n\nIf you want to denote that keys that were not previously defined in the map are allowed,\nit is common to end a map type with `optional(any) => any`.\n\nNote that the syntactic representation of `map()` is `%{optional(any) => any}`, not `%{}`. The notation `%{}` specifies the singleton type for the empty map.\n\n### Keyword Lists\n\nBeyond `keyword()` and `keyword(t)`, it can be helpful to compose a spec for an expected keyword list.\nFor example:\n\n```elixir\n@type option :: {:name, String.t} | {:max, pos_integer} | {:min, pos_integer}\n@type options :: [option()]\n```\n\nThis makes it clear that only these options are allowed, none are required, and order does not matter.\n\nIt also allows composition with existing types.\nFor example:\n\n```elixir\n@type option :: {:my_option, String.t()} | GenServer.option()\n\n@spec start_link([option()]) :: GenServer.on_start()\ndef start_link(opts) do\n {my_opts, gen_server_opts} = Keyword.split(opts, [:my_option])\n GenServer.start_link(__MODULE__, my_opts, gen_server_opts)\nend\n```\n\nThe following spec syntaxes are equivalent:\n\n```elixir\n@type options [{:name, String.t} | {:max, pos_integer} | {:min, pos_integer}]\n\n@type options [name: String.t, max: pos_integer, min: pos_integer]\n```\n\n### User-defined types\n\nThe `@type`, `@typep`, and `@opaque` module attributes can be used to define new types:\n\n @type type_name :: type\n @typep type_name :: type\n @opaque type_name :: type\n\nA type defined with `@typep` is private. An opaque type, defined with `@opaque` is a type where the internal structure of the type will not be visible, but the type is still public.\n\nTypes can be parameterized by defining variables as parameters; these variables can then be used to define the type.\n\n @type dict(key, value) :: [{key, value}]\n\n## Defining a specification\n\nA specification for a function can be defined as follows:\n\n @spec function_name(type1, type2) :: return_type\n\nGuards can be used to restrict type variables given as arguments to the function.\n\n @spec function(arg) :: [arg] when arg: atom\n\nIf you want to specify more than one variable, you separate them by a comma.\n\n @spec function(arg1, arg2) :: {arg1, arg2} when arg1: atom, arg2: integer\n\nType variables with no restriction can also be defined using `var`.\n\n @spec function(arg) :: [arg] when arg: var\n\nThis guard notation only works with `@spec`, `@callback`, and `@macrocallback`.\n\nYou can also name your arguments in a typespec using `arg_name :: arg_type` syntax. This is particularly useful in documentation as a way to differentiate multiple arguments of the same type (or multiple elements of the same type in a type definition):\n\n @spec days_since_epoch(year :: integer, month :: integer, day :: integer) :: integer\n @type color :: {red :: integer, green :: integer, blue :: integer}\n\nSpecifications can be overloaded, just like ordinary functions.\n\n @spec function(integer) :: atom\n @spec function(atom) :: integer\n\n## Behaviours\n\nBehaviours in Elixir (and Erlang) are a way to separate and abstract the generic part of a component (which becomes the *behaviour module*) from the specific part (which becomes the *callback module*).\n\nA behaviour module defines a set of functions and macros (referred to as *callbacks*) that callback modules implementing that behaviour must export. This \"interface\" identifies the specific part of the component. For example, the `GenServer` behaviour and functions abstract away all the message-passing (sending and receiving) and error reporting that a \"server\" process will likely want to implement from the specific parts such as the actions that this server process has to perform.\n\nSay we want to implement a bunch of parsers, each parsing structured data: for example, a JSON parser and a MessagePack parser. Each of these two parsers will *behave* the same way: both will provide a `parse/1` function and an `extensions/0` function. The `parse/1` function will return an Elixir representation of the structured data, while the `extensions/0` function will return a list of file extensions that can be used for each type of data (e.g., `.json` for JSON files).\n\nWe can create a `Parser` behaviour:\n\n```elixir\ndefmodule Parser do\n @doc \"\"\"\n Parses a string.\n \"\"\"\n @callback parse(String.t) :: {:ok, term} | {:error, atom}\n\n @doc \"\"\"\n Lists all supported file extensions.\n \"\"\"\n @callback extensions() :: [String.t]\nend\n```\n\nAs seen in the example above, defining a callback is a matter of defining a specification for that callback, made of:\n\n * the callback name (`parse` or `extensions` in the example)\n * the arguments that the callback must accept (`String.t`)\n * the *expected* type of the callback return value\n\nModules adopting the `Parser` behaviour will have to implement all the functions defined with the `@callback` attribute. As you can see, `@callback` expects a function name but also a function specification like the ones used with the `@spec` attribute we saw above.\n\n### Implementing behaviours\n\nImplementing a behaviour is straightforward:\n\n```elixir\ndefmodule JSONParser do\n @behaviour Parser\n\n @impl Parser\n def parse(str), do: {:ok, \"some json \" <> str} # ... parse JSON\n\n @impl Parser\n def extensions, do: [\".json\"]\nend\n```\n\n```elixir\ndefmodule CSVParser do\n @behaviour Parser\n\n @impl Parser\n def parse(str), do: {:ok, \"some csv \" <> str} # ... parse CSV\n\n @impl Parser\n def extensions, do: [\".csv\"]\nend\n```\n\nIf a module adopting a given behaviour doesn't implement one of the callbacks required by that behaviour, a compile-time warning will be generated.\n\nFurthermore, with `@impl` you can also make sure that you are implementing the **correct** callbacks from the given behaviour in an explicit manner. For example, the following parser implements both `parse` and `extensions`. However, thanks to a typo, `BADParser` is implementing `parse/0` instead of `parse/1`.\n\n```elixir\ndefmodule BADParser do\n @behaviour Parser\n\n @impl Parser\n def parse, do: {:ok, \"something bad\"}\n\n @impl Parser\n def extensions, do: [\"bad\"]\nend\n```\n\nThis code generates a warning letting you know that you are mistakenly implementing `parse/0` instead of `parse/1`.\nYou can read more about `@impl` in the [module documentation](`Module#module-impl`).\n\n### Using behaviours\n\nBehaviours are useful because you can pass modules around as arguments and you can then *call back* to any of the functions specified in the behaviour. For example, we can have a function that receives a filename, several parsers, and parses the file based on its extension:\n\n```elixir\n@spec parse_path(Path.t(), [module()]) :: {:ok, term} | {:error, atom}\ndef parse_path(filename, parsers) do\n with {:ok, ext} <- parse_extension(filename),\n {:ok, parser} <- find_parser(ext, parsers),\n {:ok, contents} <- File.read(filename) do\n parser.parse(contents)\n end\nend\n\ndefp parse_extension(filename) do\n if ext = Path.extname(filename) do\n {:ok, ext}\n else\n {:error, :no_extension}\n end\nend\n\ndefp find_parser(ext, parsers) do\n if parser = Enum.find(parsers, fn parser -> ext in parser.extensions() end) do\n {:ok, parser}\n else\n {:error, :no_matching_parser}\n end\nend\n```\n\nYou could also invoke any parser directly: `CSVParser.parse(...)`.\n\nNote you don't need to define a behaviour in order to dynamically dispatch on a module, but those features often go hand in hand.\n\n### Optional callbacks\n\nOptional callbacks are callbacks that callback modules may implement if they want to, but are not required to. Usually, behaviour modules know if they should call those callbacks based on configuration, or they check if the callbacks are defined with `function_exported?/3` or `macro_exported?/3`.\n\n> ### Unloaded modules {: .warning}\n>\n> `function_exported?/3` (and `macro_exported?/3`) do *not* load the module in case it is not loaded and Elixir lazily loads modules by default (except on releases). So in practice you will want to invoke `Code.ensure_loaded?/1` before checking if the function/macro is exported. See the documentation for `function_exported?/3` for examples.\n\nOptional callbacks can be defined through the `@optional_callbacks` module attribute, which has to be a keyword list with function or macro name as key and arity as value. For example:\n\n defmodule MyBehaviour do\n @callback vital_fun() :: any\n @callback non_vital_fun() :: any\n @macrocallback non_vital_macro(arg :: any) :: Macro.t\n @optional_callbacks non_vital_fun: 0, non_vital_macro: 1\n end\n\nOne example of optional callback in Elixir's standard library is `c:GenServer.format_status/1`.\n\n### Inspecting behaviours\n\nThe `@callback` and `@optional_callbacks` attributes are used to create a `behaviour_info/1` function available on the defining module. This function can be used to retrieve the callbacks and optional callbacks defined by that module.\n\nFor example, for the `MyBehaviour` module defined in \"Optional callbacks\" above:\n\n MyBehaviour.behaviour_info(:callbacks)\n #=> [vital_fun: 0, \"MACRO-non_vital_macro\": 2, non_vital_fun: 0]\n MyBehaviour.behaviour_info(:optional_callbacks)\n #=> [\"MACRO-non_vital_macro\": 2, non_vital_fun: 0]\n\nWhen using `iex`, the `IEx.Helpers.b/1` helper is also available.\n\n## Pitfalls\n\nThere are some known pitfalls when using typespecs, they are documented next.\n\n## The `string()` type\n\nElixir discourages the use of the `string()` type. The `string()` type refers to Erlang strings, which are known as \"charlists\" in Elixir. They do not refer to Elixir strings, which are UTF-8 encoded binaries. To avoid confusion, if you attempt to use the type `string()`, Elixir will emit a warning. You should use `charlist()`, `nonempty_charlist()`, `binary()` or `String.t()` accordingly, or any of the several literal representations for these types.\n\nNote that `String.t()` and `binary()` are equivalent to analysis tools. Although, for those reading the documentation, `String.t()` implies it is a UTF-8 encoded binary.\n\n## Functions which raise an error\n\nTypespecs do not need to indicate that a function can raise an error; any function can fail any time if given invalid input.\nIn the past, the Elixir standard library sometimes used `no_return()` to indicate this, but these usages have been removed.\n\nThe `no_return()` type also should not be used for functions which do return but whose purpose is a \"side effect\", such as `IO.puts/1`.\nIn these cases, the expected return type is `:ok`.\n\nInstead, `no_return()` should be used as the return type for functions which can never return a value.\nThis includes functions which loop forever calling `receive`, or which exist specifically to raise an error, or which shut down the VM.\n" }, { "path": "lib/elixir/pages/references/unicode-syntax.md", "content": "\n\n# Unicode syntax\n\nElixir supports Unicode throughout the language. This document is a complete reference of how\nElixir supports Unicode in its syntax.\n\nStrings (`\"olá\"`) and charlists (`'olá'`) support Unicode since Elixir v1.0. Strings are UTF-8 encoded. Charlists are lists of Unicode code points. In such cases, the contents are kept as written by developers, without any transformation.\n\nElixir also supports Unicode in variables, atoms, and calls since Elixir v1.5. The focus of this document is to provide a high-level introduction to how Elixir allows Unicode in its syntax. We also provide technical documentation describing how Elixir complies with the Unicode specification.\n\nTo check the Unicode version of your current Elixir installation, run `String.Unicode.version()`.\n\n## Introduction\n\nElixir allows Unicode characters in its variables, atoms, and calls. However, the Unicode characters must still obey the rules of the language syntax. In particular, variables and calls cannot start with an uppercase letter. From now on, we will refer to those terms as identifiers.\n\nThe characters allowed in identifiers are the ones specified by Unicode. Generally speaking, it is restricted to characters typically used by the writing system of human languages still in activity. In particular, it excludes symbols such as emojis, alternate numeric representations, musical notes, and the like.\n\nElixir imposes many restrictions on identifiers for security purposes. For example, the word \"josé\" can be written in two ways in Unicode: as the combination of the characters `j o s é` and as a combination of the characters `j o s e ́ `, where the accent is its own character. The former is called NFC form and the latter is the NFD form. Elixir normalizes all characters to be the in the NFC form.\n\nElixir also disallows mixed-scripts which are not explicitly separated by `_`. For example, it is not possible to name a variable `аdmin`, where `а` is in Cyrillic and the remaining characters are in Latin. Doing so will raise the following error:\n\n```text\n** (SyntaxError) invalid mixed-script identifier found: аdmin\n\nMixed-script identifiers are not supported for security reasons. 'аdmin' is made of the following scripts:\n\n \\u0430 а {Cyrillic}\n \\u0064 d {Latin}\n \\u006D m {Latin}\n \\u0069 i {Latin}\n \\u006E n {Latin}\n\nMake sure all characters in the identifier resolve to a single script or a highly\nrestrictive script. See https://hexdocs.pm/elixir/unicode-syntax.html for more information.\n```\n\nFinally, Elixir will also warn of confusable identifiers in the same file. For example, Elixir will emit a warning if you use both variables `а` (Cyrillic) and `а` (Latin) in your code.\n\nThat's the overall introduction of how Unicode is used in Elixir identifiers. In a nutshell, its goal is to support different writing systems in use today while keeping the Elixir language itself clear and secure.\n\nFor the technical details, see the next sections that cover the technical Unicode requirements.\n\n## Unicode Standard Annex #31\n\nElixir conforms to the standards outlined in the [Unicode Standard Annex #31: Unicode Identifiers and Syntax](https://unicode.org/reports/tr31/), version 17.0.\n\n### R1. Default Identifiers\n\nThe general Elixir identifier rule is specified as:\n\n := * ?\n\nwhere `` uses the same categories as the spec but normalizes them to the NFC form (see R4):\n\n> characters derived from the Unicode General Category of uppercase letters, lowercase letters, titlecase letters, modifier letters, other letters, letter numbers, plus `Other_ID_Start`, minus `Pattern_Syntax` and `Pattern_White_Space` code points\n>\n> In set notation: `[\\p{L}\\p{Nl}\\p{Other_ID_Start}-\\p{Pattern_Syntax}-\\p{Pattern_White_Space}]`.\n\nand `` uses the same categories as the spec but normalizes them to the NFC form (see R4):\n\n> ID_Start characters, plus characters having the Unicode General Category of nonspacing marks, spacing combining marks, decimal number, connector punctuation, plus `Other_ID_Continue`, minus `Pattern_Syntax` and `Pattern_White_Space` code points.\n>\n> In set notation: `[\\p{ID_Start}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Pc}\\p{Other_ID_Continue}-\\p{Pattern_Syntax}-\\p{Pattern_White_Space}]`.\n\n`` is an addition specific to Elixir that includes only the code points `?` (003F) and `!` (0021).\n\nThe spec also provides a `` set, but Elixir does not include any character on this set. Therefore, the identifier rule has been simplified to consider this.\n\nElixir does not allow the use of ZWJ or ZWNJ in identifiers and therefore does not implement R1a. Bidirectional control characters are also not supported. R1b is guaranteed for backwards compatibility purposes.\n\n#### Atoms\n\nUnicode atoms in Elixir follow the identifier rule above with the following modifications:\n\n * `` additionally includes the code point `_` (005F)\n * `` additionally includes the code point `@` (0040)\n\nNote atoms can also be quoted, which allows any characters, such as `:\"hello elixir\"`. All Elixir operators are also valid atoms, such as `:+`, `:@`, `:|>`, and others. The full description of valid atoms is available in the [\"Atoms\" section in the syntax reference](syntax-reference.md#atoms).\n\n#### Variables, local calls, and remote calls\n\nVariables in Elixir follow the identifier rule above with the following modifications:\n\n * `` additionally includes the code point `_` (005F)\n * `` additionally excludes Lu (letter uppercase) and Lt (letter titlecase) characters\n\nIn set notation: `[\\u{005F}\\p{Ll}\\p{Lm}\\p{Lo}\\p{Nl}\\p{Other_ID_Start}-\\p{Pattern_Syntax}-\\p{Pattern_White_Space}]`.\n\n#### Aliases\n\nAliases in Elixir only allow ASCII characters, starting in uppercase, and no punctuation characters.\n\n### R3. Pattern_White_Space and Pattern_Syntax Characters\n\nElixir supports only code points `\\t` (0009), `\\n` (000A), `\\r` (000D) and `\\s` (0020) as whitespace and therefore does not follow requirement R3. R3 requires a wider variety of whitespace and syntax characters to be supported.\n\n### R4. Equivalent Normalized Identifiers\n\nIdentifiers in Elixir are case sensitive.\n\nElixir normalizes all atoms and variables to NFC form. Quoted-atoms and strings can, however, be in any form and are not verified by the parser.\n\nIn other words, the atom `:josé` can only be written with the code points `006A 006F 0073 00E9` or `006A 006F 0073 0065 0301`, but Elixir will rewrite it to the former (from Elixir 1.14). On the other hand, `:\"josé\"` may be written as `006A 006F 0073 00E9` or `006A 006F 0073 0065 0301` and its form will be retained, since it is written between quotes.\n\nChoosing requirement R4 automatically excludes requirements R5, R6, and R7.\n\n## Unicode Technical Standard #39\n\nElixir conforms to the clauses outlined in the [Unicode Technical Standard #39](https://unicode.org/reports/tr39/) on Security, version 17.0.\n\n### C1. General Security Profile for Identifiers\n\nElixir will not allow tokenization of identifiers with codepoints in `\\p{Identifier_Status=Restricted}`, except for the outlined 'Additional normalizations' section below.\n\n> An implementation following the General Security Profile does not permit any characters in \\p{Identifier_Status=Restricted}, ...\n\nFor instance, the 'HANGUL FILLER' (`ㅤ`) character, which is often invisible, is an uncommon codepoint and will trigger a warning.\n\n### C2. Confusable detection\n\nElixir will warn of identifiers that look the same, but aren't. Examples: in `а = a = 1`, the two 'a' characters are Cyrillic and Latin, and could be confused for each other; in `力 = カ = 1`, both are Japanese, but different codepoints, in different scripts of that writing system. Confusable identifiers can lead to hard-to-catch bugs (say, due to copy-pasted code) and can be unsafe, so we will warn of identifiers within a single file that could be confused with each other.\n\nWe use the means described in Section 4, 'Confusable Detection', with one noted modification:\n\n> Alternatively, it shall declare that it uses a modification, and provide a precise list of character mappings that are added to or removed from the provided ones.\n\nElixir will not warn about confusability for identifiers made up exclusively of characters in a-z, A-Z, 0-9, and _. This is because ASCII identifiers have existed for so long that the programming community has had their own means of dealing with confusability between identifiers like `l,1` or `O,0` (for instance, fonts designed for programming usually make it easy to differentiate between those characters).\n\n### C3. Mixed Script Detection\n\nElixir will not allow tokenization of mixed-script identifiers unless it is via chunks separated by an underscore, like `http_сервер`. We use the means described in Section 5.1, Mixed-Script Detection, to determine if script mixing is occurring, with the 'Additional Normalizations' documented in.\n\nExamples: Elixir allows an identifiers like `幻한`, even though it includes characters from multiple 'scripts', as Han characters may be mixed with Japanese and Korean, according to the rules from UTS 39 5.1. When mixing Latin and Japanese scripts, underscores are necessary, as in `:T_シャツ` (the Japanese word for 't-shirt' with an additional underscore separating the letter T).\n\nElixir does not allow code like `if аdmin, do: :ok, else: :err`, where the scriptset for the 'a' character is {Cyrillic} but all other characters have scriptsets of {Latin}. The scriptsets fail to resolve and a descriptive error is shown.\n\n### C4, C5 (inapplicable)\n\n'C4 - Restriction Level detection' conformance is not claimed and does not apply to identifiers in code; rather, it applies to classifying the level of safety of a given arbitrary string into one of 5 restriction levels.\n\n'C5 - Mixed number detection' conformance is inapplicable as Elixir does not support Unicode numbers.\n\n### Addition Normalizations\n\nAs of Elixir 1.14, some codepoints in `\\p{Identifier_Status=Restricted}` are *normalized* to other, unrestricted codepoints.\n\nThis is currently only applied to translate MICRO SIGN (`µ`) to Greek lowercase mu (`μ`).\n\nThe normalization avoids confusability and the mixed-script detection is modified to the extent that the normalized codepoint is given the union of scriptsets from both characters.\n\n * For instance, in the example of MICRO => MU, MICRO was a 'Common'-script character - the same script given to the '_' underscore codepoint - and thus the normalized character's scriptset will be {Greek, Common}. 'Common' intersects with all non-empty scriptsets, and thus the normalized character can be used in tokens written in any script without causing script mixing.\n\n * The code points normalized in this fashion are those that are in use in the community, and judged not likely to cause issues with unsafe script mixing. For instance, the MICRO or MU codepoint may be used in an atom or variable dealing with microseconds.\n" }, { "path": "lib/elixir/scripts/cover.exs", "content": "#!bin/elixir\n\n# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"cover_record.exs\", __DIR__)\ncover_pid = CoverageRecorder.enable_coverage()\n\ncoverdata_inputs =\n CoverageRecorder.cover_dir() |> Path.join(\"ex_unit_*.coverdata\") |> Path.wildcard()\n\ncoverdata_output = Path.join(CoverageRecorder.cover_dir(), \"combined.coverdata\")\n\nfor file <- coverdata_inputs do\n :ok = :cover.import(String.to_charlist(file))\nend\n\n:ok = :cover.export(String.to_charlist(coverdata_output))\n\n{:ok, _} = Application.ensure_all_started(:mix)\n\n# Silence analyse import messages emitted by cover\n{:ok, string_io} = StringIO.open(\"\")\nProcess.group_leader(cover_pid, string_io)\n\n:ok =\n Mix.Tasks.Test.Coverage.generate_cover_results(\n output: CoverageRecorder.cover_dir(),\n summary: [threshold: 0]\n )\n" }, { "path": "lib/elixir/scripts/cover_record.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\ndefmodule CoverageRecorder do\n def maybe_record(suite_name) do\n if enabled?() do\n record(suite_name)\n\n true\n else\n false\n end\n end\n\n def enable_coverage do\n _ = :cover.stop()\n {:ok, pid} = :cover.start()\n\n cover_compile_ebins()\n\n pid\n end\n\n def cover_dir, do: Path.join(root_dir(), \"cover\")\n\n defp enabled? do\n case System.fetch_env(\"COVER\") do\n {:ok, truthy} when truthy in ~w[1 true yes y] ->\n true\n\n _ ->\n false\n end\n end\n\n defp root_dir, do: Path.join(__DIR__, \"../../..\")\n defp ebins, do: root_dir() |> Path.join(\"lib/*/ebin\") |> Path.wildcard()\n\n defp record(suite_name) do\n file = Path.join(cover_dir(), \"ex_unit_#{suite_name}.coverdata\")\n\n enable_coverage()\n\n System.at_exit(fn _status ->\n File.mkdir_p!(cover_dir())\n\n :ok = :cover.export(String.to_charlist(file))\n end)\n end\n\n defp cover_compile_ebins do\n relevant_beam_files()\n |> Enum.map(&String.to_charlist/1)\n |> :cover.compile_beam()\n |> Enum.each(fn\n {:ok, _module} ->\n :ok\n\n {:error, reason} ->\n raise \"Failed to cover compile with reason: #{inspect(reason)}\"\n end)\n end\n\n defp relevant_beam_files do\n ebins()\n |> Enum.flat_map(fn ebin ->\n ebin |> Path.join(\"*.beam\") |> Path.wildcard()\n end)\n |> Enum.reject(&skip_from_coverage?/1)\n end\n\n @to_skip [\n # Tested via the CLI only\n :elixir_sup,\n :iex,\n Kernel.CLI,\n Mix.CLI,\n Mix.Compilers.Test,\n Mix.Tasks.Test,\n Mix.Tasks.Test.Coverage,\n\n # Bootstrap\n :elixir_bootstrap,\n Kernel.SpecialForms\n ]\n\n defp skip_from_coverage?(file) do\n mod = file |> Path.basename(\".beam\") |> String.to_atom()\n mod in @to_skip or match?({:docs_v1, _, _, _, _, %{deprecated: _}, _}, Code.fetch_docs(mod))\n end\nend\n" }, { "path": "lib/elixir/scripts/diff.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Diff do\n @moduledoc \"\"\"\n Utilities for comparing build artifacts.\n \"\"\"\n\n @atom_chunks ~w(\n atoms\n attributes\n compile_info\n debug_info\n exports\n labeled_exports\n imports\n indexed_imports\n locals\n labeled_locals\n )a\n\n @term_chunks ~w(\n ExCk\n Docs\n )c\n\n @binary_chunks ~w(\n Attr\n AtU8\n CInf\n Dbgi\n ExpT\n ImpT\n LocT\n )c\n\n @doc \"\"\"\n Compares the build artifacts of two build directories.\n \"\"\"\n @spec compare_dirs(Path.t(), Path.t()) ::\n {\n only1_paths :: list(Path.t()),\n only2_paths :: list(Path.t()),\n diff :: list({Path.t(), diff :: String.t()})\n }\n def compare_dirs(dir1, dir2) do\n dir1 = Path.expand(dir1)\n dir2 = Path.expand(dir2)\n\n assert_dir!(dir1)\n assert_dir!(dir2)\n\n dir1_paths = relative_paths(dir1)\n dir2_paths = relative_paths(dir2)\n\n only1_paths = dir1_paths -- dir2_paths\n only2_paths = dir2_paths -- dir1_paths\n common_paths = dir1_paths -- only1_paths\n common_files = Enum.reject(common_paths, &File.dir?/1)\n\n diff =\n Enum.flat_map(common_files, fn path ->\n file1 = Path.join(dir1, path)\n file2 = Path.join(dir2, path)\n\n case compare_files(file1, file2) do\n :eq -> []\n {:diff, diff} -> [{path, diff}]\n end\n end)\n\n {only1_paths, only2_paths, diff}\n end\n\n @doc \"\"\"\n Compares the contents of two files.\n\n If the files are BEAM files, it performs a more human-friendly\n \"BEAM-diff\".\n \"\"\"\n @spec compare_files(Path.t(), Path.t()) :: :eq | {:diff, diff :: String.t()}\n def compare_files(file1, file2) do\n content1 = File.read!(file1)\n content2 = File.read!(file2)\n\n if content1 == content2 do\n :eq\n else\n diff =\n if String.ends_with?(file1, \".beam\") do\n beam_diff(file1, content1, file2, content2)\n else\n file_diff(file1, file2)\n end\n\n {:diff, diff}\n end\n end\n\n defp inspect_all(data) do\n inspect(data, pretty: true, limit: :infinity)\n end\n\n defp beam_diff(file1, content1, file2, content2) do\n chunk_diff(content1, content2, @atom_chunks, &inspect_all(&1)) ||\n chunk_diff(content1, content2, @term_chunks, &inspect_all(:erlang.binary_to_term(&1))) ||\n chunk_diff(content1, content2, @binary_chunks, &(&1 |> write_tmp() |> xxd_dump())) ||\n (\n tmp_file1 =\n file1\n |> xxd_dump()\n |> write_tmp()\n\n tmp_file2 =\n file2\n |> xxd_dump()\n |> write_tmp()\n\n file_diff(tmp_file1, tmp_file2)\n )\n end\n\n defp chunk_diff(content1, content2, names, formatter) do\n with {:ok, {module, chunks1}} <- :beam_lib.chunks(content1, names),\n {:ok, {^module, chunks2}} <- :beam_lib.chunks(content2, names),\n true <- chunks1 != chunks2 do\n if length(chunks1) != length(chunks2) do\n \"\"\"\n Different chunks:\n * #{inspect(chunks1)}\n * #{inspect(chunks2)}\n \"\"\"\n else\n for {{name1, chunk1}, {name2, chunk2}} <- Enum.zip(chunks1, chunks2),\n true = name1 == name2,\n chunk1 != chunk2 do\n tmp_file1 = chunk1 |> formatter.() |> write_tmp()\n tmp_file2 = chunk2 |> formatter.() |> write_tmp()\n\n message =\n case file_diff(tmp_file1, tmp_file2) do\n \"\" -> \"DIFF IS EMPTY: most likely non-deterministic term_to_binary/2\"\n diff -> diff\n end\n\n [to_string(name1), ?\\n, message]\n end\n end\n else\n _ -> nil\n end\n end\n\n defp xxd_dump(file) do\n {dump, _} = System.cmd(\"xxd\", [file])\n dump\n end\n\n defp file_diff(file1, file2) do\n {diff, _} = System.cmd(\"diff\", [\"-U3\", file1, file2])\n diff\n end\n\n defp relative_paths(dir) do\n dir\n |> Path.join(\"**\")\n |> Path.wildcard()\n |> Enum.map(&Path.relative_to(&1, dir))\n end\n\n defp assert_dir!(dir) do\n if not File.dir?(dir) do\n raise ArgumentError, \"#{inspect(dir)} is not a directory\"\n end\n end\n\n defp write_tmp(content) do\n filename = \"tmp-#{System.unique_integer([:positive])}\"\n File.mkdir_p!(\"tmp\")\n File.write!(Path.join(\"tmp\", filename), content)\n Path.join(\"tmp\", filename)\n end\nend\n\nif :deterministic not in :compile.env_compiler_options() do\n IO.puts(\"Cannot validate if reproducible without setting ERL_COMPILER_OPTIONS=deterministic\")\n System.halt(1)\nend\n\ncase System.argv() do\n [dir1, dir2] ->\n case Diff.compare_dirs(dir1, dir2) do\n {[], [], []} ->\n IO.puts(\"#{inspect(dir1)} and #{inspect(dir2)} are equal\")\n\n {only1, only2, diff} ->\n for path <- only1, do: IO.puts(\"Only in #{dir1}: #{path}\")\n for path <- only2, do: IO.puts(\"Only in #{dir2}: #{path}\")\n for {path, diff} <- diff, do: IO.puts(\"Diff #{path}:\\n#{diff}\")\n\n System.halt(1)\n end\n\n _ ->\n IO.puts(\"Please, provide two directories as arguments\")\n System.halt(1)\nend\n" }, { "path": "lib/elixir/scripts/docs_config.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\n# Generate docs_config.js for version chooser in ExDoc\n[app] = System.argv()\nskipped = Version.parse!(\"1.0.3\")\nroot_dir = Path.expand(\"../../../\", __DIR__)\n\ngit_repo? =\n root_dir\n |> Path.join(\".git\")\n |> File.dir?()\n\nversions =\n if git_repo? do\n {text_tags, 0} = System.cmd(\"git\", [\"tag\"])\n\n for(\n \"v\" <> rest <- String.split(text_tags),\n not String.ends_with?(rest, \"-latest\"),\n version = Version.parse!(rest),\n Version.compare(version, skipped) == :gt,\n do: version\n )\n |> Enum.sort({:desc, Version})\n else\n IO.warn(\"skipping version dropdown\", [])\n\n []\n end\n\nlatest =\n if git_repo? do\n versions\n |> Stream.filter(&(&1.pre == []))\n |> Enum.fetch!(0)\n |> Version.to_string()\n else\n System.version()\n end\n\nversion_nodes =\n for version <- versions do\n version_string = Version.to_string(version)\n map = %{version: \"v#{version_string}\", url: \"https://hexdocs.pm/#{app}/#{version_string}\"}\n\n if version_string == latest do\n Map.put(map, :latest, true)\n else\n map\n end\n end\n\nsearch_nodes =\n for app <- ~w(eex elixir ex_unit iex logger mix)s do\n %{name: app, version: latest}\n end\n\nFile.mkdir_p!(\"doc/#{app}\")\n\nFile.write!(\"doc/#{app}/docs_config.js\", \"\"\"\nvar versionNodes = #{JSON.encode_to_iodata!(version_nodes)};\nvar searchNodes = #{JSON.encode_to_iodata!(search_nodes)};\n\"\"\")\n" }, { "path": "lib/elixir/scripts/elixir_docs.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\n# Returns config for Elixir docs (exclusively)\ncanonical = System.fetch_env!(\"CANONICAL\")\n\n[\n search: [\n %{\n name: \"Elixir + libraries\",\n help: \"Search Elixir, EEx, ExUnit, IEx, Logger, and Mix\",\n packages:\n Enum.map(\n [:elixir, :eex, :ex_unit, :iex, :logger, :mix],\n &{&1, String.trim(canonical, \"/\")}\n )\n },\n %{\n name: \"Current project\",\n help: \"Search only this project\"\n }\n ],\n assets: %{\"lib/elixir/pages/images\" => \"assets\"},\n extras: [\n \"lib/elixir/pages/getting-started/introduction.md\",\n \"lib/elixir/pages/getting-started/basic-types.md\",\n \"lib/elixir/pages/getting-started/lists-and-tuples.md\",\n \"lib/elixir/pages/getting-started/pattern-matching.md\",\n \"lib/elixir/pages/getting-started/case-cond-and-if.md\",\n \"lib/elixir/pages/getting-started/anonymous-functions.md\",\n \"lib/elixir/pages/getting-started/binaries-strings-and-charlists.md\",\n \"lib/elixir/pages/getting-started/keywords-and-maps.md\",\n \"lib/elixir/pages/getting-started/modules-and-functions.md\",\n \"lib/elixir/pages/getting-started/alias-require-and-import.md\",\n \"lib/elixir/pages/getting-started/module-attributes.md\",\n \"lib/elixir/pages/getting-started/structs.md\",\n \"lib/elixir/pages/getting-started/recursion.md\",\n \"lib/elixir/pages/getting-started/enumerable-and-streams.md\",\n \"lib/elixir/pages/getting-started/comprehensions.md\",\n \"lib/elixir/pages/getting-started/protocols.md\",\n \"lib/elixir/pages/getting-started/sigils.md\",\n \"lib/elixir/pages/getting-started/try-catch-and-rescue.md\",\n \"lib/elixir/pages/getting-started/processes.md\",\n \"lib/elixir/pages/getting-started/io-and-the-file-system.md\",\n \"lib/elixir/pages/getting-started/writing-documentation.md\",\n \"lib/elixir/pages/getting-started/optional-syntax.md\",\n \"lib/elixir/pages/getting-started/erlang-libraries.md\",\n \"lib/elixir/pages/getting-started/debugging.md\",\n \"lib/elixir/pages/cheatsheets/enum-cheat.cheatmd\",\n \"lib/elixir/pages/cheatsheets/types-cheat.cheatmd\",\n \"lib/elixir/pages/anti-patterns/what-anti-patterns.md\",\n \"lib/elixir/pages/anti-patterns/code-anti-patterns.md\",\n \"lib/elixir/pages/anti-patterns/design-anti-patterns.md\",\n \"lib/elixir/pages/anti-patterns/process-anti-patterns.md\",\n \"lib/elixir/pages/anti-patterns/macro-anti-patterns.md\",\n \"lib/elixir/pages/references/compatibility-and-deprecations.md\",\n \"lib/elixir/pages/references/gradual-set-theoretic-types.md\",\n \"lib/elixir/pages/references/library-guidelines.md\",\n \"lib/elixir/pages/references/naming-conventions.md\",\n \"lib/elixir/pages/references/operators.md\",\n \"lib/elixir/pages/references/patterns-and-guards.md\",\n \"lib/elixir/pages/references/syntax-reference.md\",\n \"lib/elixir/pages/references/sbom.md\",\n \"lib/elixir/pages/references/typespecs.md\",\n \"lib/elixir/pages/references/unicode-syntax.md\",\n \"lib/elixir/pages/mix-and-otp/introduction-to-mix.md\",\n \"lib/elixir/pages/mix-and-otp/agents.md\",\n \"lib/elixir/pages/mix-and-otp/supervisor-and-application.md\",\n \"lib/elixir/pages/mix-and-otp/dynamic-supervisor.md\",\n \"lib/elixir/pages/mix-and-otp/task-and-gen-tcp.md\",\n \"lib/elixir/pages/mix-and-otp/docs-tests-and-with.md\",\n \"lib/elixir/pages/mix-and-otp/config-and-distribution.md\",\n \"lib/elixir/pages/mix-and-otp/genservers.md\",\n \"lib/elixir/pages/mix-and-otp/releases.md\",\n \"lib/elixir/pages/meta-programming/quote-and-unquote.md\",\n \"lib/elixir/pages/meta-programming/macros.md\",\n \"lib/elixir/pages/meta-programming/domain-specific-languages.md\",\n \"CHANGELOG.md\"\n ],\n deps: [\n eex: \"https://hexdocs.pm/eex/#{canonical}\",\n ex_unit: \"https://hexdocs.pm/ex_unit/#{canonical}\",\n iex: \"https://hexdocs.pm/iex/#{canonical}\",\n logger: \"https://hexdocs.pm/logger/#{canonical}\",\n mix: \"https://hexdocs.pm/mix/#{canonical}\"\n ],\n groups_for_extras: [\n \"Getting started\": ~r\"pages/getting-started/.*\\.md$\",\n Cheatsheets: ~r\"pages/cheatsheets/.*\\.cheatmd$\",\n \"Mix & OTP\": ~r\"pages/mix-and-otp/.*\\.md$\",\n \"Anti-patterns\": ~r\"pages/anti-patterns/.*\\.md$\",\n \"Meta-programming\": ~r\"pages/meta-programming/.*\\.md$\",\n References: ~r\"pages/references/.*\\.md$\"\n ],\n groups_for_docs: [\n Guards: &(&1[:guard] == true)\n ],\n skip_undefined_reference_warnings_on: [\n \"lib/elixir/pages/references/compatibility-and-deprecations.md\"\n ],\n skip_code_autolink_to: [\n \"Enumerable.List\",\n \"Inspect.MapSet\"\n ],\n formatters: [\"html\", \"markdown\", \"epub\"],\n groups_for_modules: [\n # [Kernel, Kernel.SpecialForms],\n\n \"Data Types\": [\n Atom,\n Base,\n Bitwise,\n Date,\n DateTime,\n Duration,\n Exception,\n Float,\n Function,\n Integer,\n JSON,\n Module,\n NaiveDateTime,\n Record,\n Regex,\n String,\n Time,\n Tuple,\n URI,\n Version,\n Version.Requirement\n ],\n \"Collections & Enumerables\": [\n Access,\n Date.Range,\n Enum,\n Keyword,\n List,\n Map,\n MapSet,\n Range,\n Stream\n ],\n \"IO & System\": [\n File,\n File.Stat,\n File.Stream,\n IO,\n IO.ANSI,\n IO.Stream,\n OptionParser,\n Path,\n Port,\n StringIO,\n System\n ],\n Calendar: [\n Calendar,\n Calendar.ISO,\n Calendar.TimeZoneDatabase,\n Calendar.UTCOnlyTimeZoneDatabase\n ],\n \"Processes & Applications\": [\n Agent,\n Application,\n Config,\n Config.Provider,\n Config.Reader,\n DynamicSupervisor,\n GenServer,\n Node,\n PartitionSupervisor,\n Process,\n Registry,\n Supervisor,\n Task,\n Task.Supervisor\n ],\n Protocols: [\n Collectable,\n Enumerable,\n JSON.Encoder,\n Inspect,\n Inspect.Algebra,\n Inspect.Opts,\n List.Chars,\n Protocol,\n String.Chars\n ],\n \"Code & Macros\": [\n Code,\n Code.Fragment,\n Kernel.ParallelCompiler,\n Macro,\n Macro.Env\n ]\n\n ## Automatically detected groups\n\n # Deprecated: [\n # Behaviour,\n # Dict,\n # GenEvent,\n # HashDict,\n # HashSet,\n # Set,\n # Supervisor.Spec\n # ]\n ],\n before_closing_body_tag: fn\n :html ->\n \"\"\"\n \n \n \"\"\"\n\n _ ->\n \"\"\n end\n]\n" }, { "path": "lib/elixir/scripts/generate_app.escript", "content": "#!/usr/bin/env escript\n\n%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% -*- erlang -*-\n\nmain([Version]) ->\n Source = \"lib/elixir/src/elixir.app.src\",\n Target = \"lib/elixir/ebin/elixir.app\",\n {ok, [{application, Name, Props0}]} = file:consult(Source),\n Ebin = filename:dirname(Target),\n Files = filelib:wildcard(filename:join(Ebin, \"*.beam\")),\n Mods = [list_to_atom(filename:basename(F, \".beam\")) || F <- Files],\n Props1 = lists:keyreplace(modules, 1, Props0, {modules, Mods}),\n Props = lists:keyreplace(vsn, 1, Props1, {vsn, Version}),\n AppDef = io_lib:format(\"~tp.~n\", [{application, Name, Props}]),\n ok = file:write_file(Target, AppDef),\n io:format(\"Generated ~ts app~n\", [Name]).\n" }, { "path": "lib/elixir/scripts/infer.exs", "content": "# We disable type inference across modules by setting\n# infer_signatures to [] when compiling Elixir for\n# deterministic reasons. Now we do one additional pass\n# using the locally inferred types to infer all types\n# for stdlib itself.\nparent = self()\nebin = Path.expand(\"../ebin\", __DIR__)\n\n# Validate we are loading Elixir modules and that they are all in place\n[:elixir] = Code.get_compiler_option(:infer_signatures)\n\n[_ | _] =\n modules =\n for module <- Application.spec(:elixir, :modules),\n match?(\"Elixir.\" <> _, Atom.to_string(module)) do\n module\n end\n\n# Do a quick sanity check that some modules are defined\ntrue = URI in modules and Version.Requirement in modules\n\n{time, modules_paths} =\n :timer.tc(fn ->\n {:ok, checker} = Module.ParallelChecker.start_link()\n\n try do\n modules\n |> Task.async_stream(\n fn module ->\n path = Path.join(ebin, \"#{module}.beam\")\n Module.ParallelChecker.put(parent, checker)\n cache = Module.ParallelChecker.get()\n binary = File.read!(path)\n\n {:ok, {_, [{:debug_info, debug_info}, {_, checker_blob}]}} =\n :beam_lib.chunks(binary, [:debug_info, ~c\"ExCk\"])\n\n {:debug_info_v1, _backend, {:elixir_v1, module_map, _specs}} = debug_info\n\n %{module: module, file: file, attributes: attributes, definitions: definitions} =\n module_map\n\n {_, checker} = :erlang.binary_to_term(checker_blob)\n env = :elixir_env.new()\n\n # We assume that all private functions have been invoked at this point\n private =\n for {fun_arity, kind, _, _} <- definitions, kind in [:defp, :defmacrop], do: fun_arity\n\n {signatures, _} =\n Module.Types.infer(module, file, attributes, definitions, private, env, cache)\n\n checker =\n update_in(checker.exports, fn exports ->\n for {fun, info} <- exports do\n {fun, %{info | sig: Map.get(signatures, fun, info.sig)}}\n end\n end)\n\n [{\"ExCk\", checker_chunk}] = :elixir_erl.checker_chunk(checker, [:deterministic])\n {:ok, ^module, chunks} = :beam_lib.all_chunks(binary)\n\n {:ok, new_binary} =\n chunks\n |> List.keyreplace(~c\"ExCk\", 0, {~c\"ExCk\", checker_chunk})\n |> :beam_lib.build_module()\n\n {module, path, new_binary}\n end,\n timeout: :infinity\n )\n # Get all results first to avoid writing files\n # while we are still doing inference\n |> Enum.to_list()\n |> Enum.map(fn {:ok, {module, path, new_binary}} ->\n File.write!(path, new_binary)\n {module, path}\n end)\n after\n Module.ParallelChecker.stop(checker)\n end\n end)\n\nIO.puts(:stderr, [\"Type inferred stdlib in \", Integer.to_string(div(time, 1000)), \"ms\"])\n\n{time, _} =\n :timer.tc(fn ->\n # We start a new one so it uses the new cache\n {:ok, checker} = Module.ParallelChecker.start_link()\n Module.ParallelChecker.verify(checker, modules_paths)\n end)\n\nIO.puts(:stderr, [\"Type checked stdlib in \", Integer.to_string(div(time, 1000)), \"ms\"])\n" }, { "path": "lib/elixir/scripts/mix_docs.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\n# Returns config for other apps except Elixir\ncanonical = System.fetch_env!(\"CANONICAL\")\n\n[\n search: [\n %{\n name: \"Elixir + libraries\",\n help: \"Search Elixir, EEx, ExUnit, IEx, Logger, and Mix\",\n packages:\n Enum.map(\n [:elixir, :eex, :ex_unit, :iex, :logger, :mix],\n &{&1, String.trim(canonical, \"/\")}\n )\n },\n %{\n name: \"Current project\",\n help: \"Search only this project\"\n }\n ],\n deps: [\n eex: \"https://hexdocs.pm/eex/#{canonical}\",\n elixir: \"https://hexdocs.pm/elixir/#{canonical}\",\n ex_unit: \"https://hexdocs.pm/ex_unit/#{canonical}\",\n iex: \"https://hexdocs.pm/iex/#{canonical}\",\n logger: \"https://hexdocs.pm/logger/#{canonical}\",\n mix: \"https://hexdocs.pm/mix/#{canonical}\"\n ],\n formatters: [\"html\", \"markdown\", \"epub\"],\n before_closing_body_tag: fn\n :html ->\n \"\"\"\n \n \n \"\"\"\n\n _ ->\n \"\"\n end\n]\n" }, { "path": "lib/elixir/scripts/windows_installer/.gitignore", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ntmp/\n" }, { "path": "lib/elixir/scripts/windows_installer/build.sh", "content": "#!/bin/bash\n\n# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\n# Usage:\n#\n# With Elixir archive:\n#\n# ELIXIR_ZIP=Precompiled.zip OTP_VERSION=25.3.2.2 ./build.sh\nset -euo pipefail\n\nmkdir -p tmp\nrm -rf tmp/elixir\nunzip -d \"tmp/elixir\" \"${ELIXIR_ZIP}\"\n\nelixir_version=`cat tmp/elixir/VERSION`\notp_release=`erl -noshell -eval 'io:put_chars(erlang:system_info(otp_release)), halt().'`\notp_version=`erl -noshell -eval '{ok, Vsn} = file:read_file(code:root_dir() ++ \"/releases/\" ++ erlang:system_info(otp_release) ++ \"/OTP_VERSION\"), io:put_chars(Vsn), halt().'`\nelixir_exe=elixir-otp-${otp_release}.exe\n\n# brew install makensis\n# apt install -y nsis\n# choco install -y nsis\nexport PATH=\"/c/Program Files (x86)/NSIS:${PATH}\"\nmakensis \\\n -X\"OutFile tmp\\\\${elixir_exe}\" \\\n -DOTP_RELEASE=\"${otp_release}\" \\\n -DOTP_VERSION=${otp_version} \\\n -DELIXIR_DIR=tmp\\\\elixir \\\n -DELIXIR_VERSION=${elixir_version} \\\n installer.nsi\n\necho \"Installer path: tmp/${elixir_exe}\"\n" }, { "path": "lib/elixir/scripts/windows_installer/installer.nsi", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\n!include \"MUI2.nsh\"\n!include \"StrFunc.nsh\"\n${Using:StrFunc} UnStrStr\n\nName \"Elixir\"\nManifestDPIAware true\nUnicode True\nInstallDir \"$PROGRAMFILES64\\Elixir\"\n!define MUI_ICON \"assets\\Elixir.ico\"\n!define MUI_UNICON \"assets\\Elixir.ico\"\n\n; Install Page: Install Erlang/OTP\n\nPage custom CheckOTPPageShow CheckOTPPageLeave\n\nvar InstalledOTPRelease\nvar OTPPath\n\nvar Dialog\nvar NoOTPLabel\nvar NoOTPLabelCreated\nvar OTPMismatchLabel\nvar OTPMismatchLabelCreated\nvar DownloadOTPLink\nvar DownloadOTPLinkCreated\nvar VerifyOTPButton\nvar VerifyOTPButtonCreated\nFunction CheckOTPPageShow\n !insertmacro MUI_HEADER_TEXT \"Checking Erlang/OTP\" \"\"\n\n nsDialogs::Create 1018\n Pop $Dialog\n\n ${If} $Dialog == error\n Abort\n ${EndIf}\n\n Call VerifyOTP\n\n nsDialogs::Show\nFunctionEnd\n\nFunction VerifyOTP\n ${If} $NoOTPLabelCreated == \"true\"\n ShowWindow $NoOTPLabel ${SW_HIDE}\n ${EndIf}\n\n ${If} $OTPMismatchLabelCreated == \"true\"\n ShowWindow $OTPMismatchLabel ${SW_HIDE}\n ${EndIf}\n\n ${If} $DownloadOTPLinkCreated == \"true\"\n ShowWindow $DownloadOTPLink ${SW_HIDE}\n ${Else}\n StrCpy $DownloadOTPLinkCreated \"true\"\n ${NSD_CreateLink} 0 60u 100% 20u \"Download Erlang/OTP ${OTP_RELEASE}\"\n Pop $DownloadOTPLink\n ${NSD_OnClick} $DownloadOTPLink OpenOTPDownloads\n ShowWindow $DownloadOTPLink ${SW_HIDE}\n ${EndIf}\n\n ${If} $VerifyOTPButtonCreated == \"true\"\n ShowWindow $VerifyOTPButton ${SW_HIDE}\n ${Else}\n StrCpy $VerifyOTPButtonCreated \"true\"\n ${NSD_CreateButton} 0 80u 25% 12u \"Verify Erlang/OTP\"\n Pop $VerifyOTPButton\n ${NSD_OnClick} $VerifyOTPButton VerifyOTP\n ShowWindow $VerifyOTPButton ${SW_HIDE}\n ${EndIf}\n\n StrCpy $0 0\n loop:\n EnumRegKey $1 HKLM \"SOFTWARE\\WOW6432NODE\\Ericsson\\Erlang\" $0\n StrCmp $1 \"\" done\n ReadRegStr $1 HKLM \"SOFTWARE\\WOW6432NODE\\Ericsson\\Erlang\\$1\" \"\"\n StrCpy $OTPPath $1\n IntOp $0 $0 + 1\n goto loop\n done:\n\n ${If} $OTPPath == \"\"\n ${If} $NoOTPLabelCreated != \"true\"\n StrCpy $NoOTPLabelCreated \"true\"\n ${NSD_CreateLabel} 0 0 100% 20u \"Couldn't find existing Erlang/OTP installation. Click the link below to download and install it before proceeding.\"\n Pop $NoOTPLabel\n ${EndIf}\n\n ShowWindow $NoOTPLabel ${SW_SHOW}\n ShowWindow $DownloadOTPLink ${SW_SHOW}\n ShowWindow $VerifyOTPButton ${SW_SHOW}\n\n ${Else}\n nsExec::ExecToStack `$OTPPath\\bin\\erl.exe -noinput -eval \"\\\n io:put_chars(erlang:system_info(otp_release)),\\\n halt().\"`\n Pop $0\n Pop $1\n\n ${If} $0 == 0\n StrCpy $InstalledOTPRelease $1\n ${If} $InstalledOTPRelease == ${OTP_RELEASE}\n ${NSD_CreateLabel} 0 0 100% 60u \"Found existing Erlang/OTP $InstalledOTPRelease installation at $OTPPath. Please proceed.\"\n\n ${Else}\n ${If} $OTPMismatchLabelCreated != \"true\"\n StrCpy $OTPMismatchLabelCreated \"true\"\n ${NSD_CreateLabel} 0 0 100% 60u \"Found existing Erlang/OTP $InstalledOTPRelease installation at $OTPPath but this Elixir installer was precompiled for Erlang/OTP ${OTP_RELEASE}. \\\n $\\r$\\n$\\r$\\nYou can either search for another Elixir installer precompiled for Erlang/OTP $InstalledOTPRelease or download Erlang/OTP ${OTP_RELEASE} and install before proceeding.\"\n Pop $OTPMismatchLabel\n ${EndIf}\n\n ShowWindow $OTPMismatchLabel ${SW_SHOW}\n ShowWindow $DownloadOTPLink ${SW_SHOW}\n ShowWindow $VerifyOTPButton ${SW_SHOW}\n ${EndIf}\n ${Else}\n SetErrorlevel 5\n MessageBox MB_ICONSTOP \"Found existing Erlang/OTP installation at $OTPPath but checking it exited with $0: $1\"\n ${EndIf}\n ${EndIf}\nFunctionEnd\n\nFunction OpenOTPDownloads\n ExecShell \"open\" \"https://www.erlang.org/downloads/${OTP_RELEASE}\"\nFunctionEnd\n\nFunction CheckOTPPageLeave\nFunctionEnd\n\n; Install Page: Files\n\n!insertmacro MUI_PAGE_DIRECTORY\n!insertmacro MUI_PAGE_INSTFILES\n\n; Install Page: Finish\n\nPage custom FinishPageShow FinishPageLeave\n\nvar AddOTPToPathCheckbox\nvar AddElixirToPathCheckbox\nFunction FinishPageShow\n !insertmacro MUI_HEADER_TEXT \"Finish Setup\" \"\"\n\n nsDialogs::Create 1018\n Pop $Dialog\n\n ${If} $Dialog == error\n Abort\n ${EndIf}\n\n ; we add to PATH using erlang, so there must be an OTP installed to do so.\n ${If} \"$OTPPath\" != \"\"\n ${NSD_CreateCheckbox} 0 0 195u 10u \"&Add $INSTDIR\\bin to %PATH%\"\n Pop $AddElixirToPathCheckbox\n SendMessage $AddElixirToPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0\n\n ${NSD_CreateCheckbox} 0 20u 195u 10u \"&Add $OTPPath\\bin to %PATH%\"\n Pop $AddOTPToPathCheckbox\n SendMessage $AddOTPToPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0\n\n ${NSD_CreateLabel} 0 40u 100% 20u \"Note: you need to restart your shell for the environment variable changes to take effect.\"\n ${EndIf}\n\n nsDialogs::Show\nFunctionEnd\n\nvar PathsToAdd\nFunction FinishPageLeave\n ${NSD_GetState} $AddOTPToPathCheckbox $0\n ${If} $0 <> ${BST_UNCHECKED}\n StrCpy $PathsToAdd \";$OTPPath\\bin\"\n ${EndIf}\n\n ${NSD_GetState} $AddElixirToPathCheckbox $0\n ${If} $0 <> ${BST_UNCHECKED}\n StrCpy $PathsToAdd \"$PathsToAdd;$INSTDIR\\bin\"\n ${EndIf}\n\n ${If} \"$PathsToAdd\" != \"\"\n nsExec::ExecToStack `\"$OTPPath\\bin\\escript.exe\" \"$INSTDIR\\update_system_path.erl\" add \"$PathsToAdd\"`\n Pop $0\n Pop $1\n ${If} $0 != 0\n SetErrorlevel 5\n MessageBox MB_ICONSTOP \"adding paths failed with $0: $1\"\n Quit\n ${EndIf}\n ${EndIf}\nFunctionEnd\n\nSection \"Install Elixir\" SectionElixir\n SetOutPath \"$INSTDIR\"\n File /r \"${ELIXIR_DIR}\\\"\n File \"assets\\Elixir.ico\"\n File \"update_system_path.erl\"\n WriteRegStr HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\" \"DisplayName\" \"Elixir\"\n WriteRegStr HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\" \"DisplayVersion\" \"${ELIXIR_VERSION}\"\n WriteRegStr HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\" \"DisplayIcon\" \"$INSTDIR\\Elixir.ico\"\n WriteRegStr HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\" \"Publisher\" \"The Elixir Team\"\n WriteRegStr HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\" \"UninstallString\" '\"$INSTDIR\\Uninstall.exe\"'\n WriteRegDWORD HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\" \"NoModify\" 1\n WriteRegDWORD HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\" \"NoRepair\" 1\n\n WriteRegStr HKLM \"Software\\Elixir\\Elixir\" \"InstallRoot\" \"$INSTDIR\"\n\n WriteUninstaller \"Uninstall.exe\"\nSectionEnd\n\n; Uninstall Page: Remove from %PATH%\n\nvar RemoveOTPFromPathCheckbox\nvar RemoveElixirFromPathCheckbox\nFunction un.FinishPageShow\n !insertmacro MUI_HEADER_TEXT \"Remove from %PATH%\" \"\"\n\n StrCpy $0 0\n loop:\n EnumRegKey $1 HKLM \"SOFTWARE\\WOW6432NODE\\Ericsson\\Erlang\" $0\n StrCmp $1 \"\" done\n ReadRegStr $1 HKLM \"SOFTWARE\\WOW6432NODE\\Ericsson\\Erlang\\$1\" \"\"\n StrCpy $OTPPath $1\n IntOp $0 $0 + 1\n goto loop\n done:\n\n nsDialogs::Create 1018\n Pop $Dialog\n\n ${If} $Dialog == error\n Abort\n ${EndIf}\n\n ReadRegStr $0 HKCU \"Environment\" \"Path\"\n\n ${UnStrStr} $1 \"$0\" \"$INSTDIR\\bin\"\n ${If} $1 != \"\"\n ${NSD_CreateCheckbox} 0 0 195u 10u \"&Remove $INSTDIR\\bin from %PATH%\"\n Pop $RemoveElixirFromPathCheckbox\n SendMessage $RemoveElixirFromPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0\n ${EndIf}\n\n ${UnStrStr} $1 \"$0\" \"$OTPPath\\bin\"\n ${If} $1 != \"\"\n ${NSD_CreateCheckbox} 0 20u 195u 10u \"&Remove $OTPPath\\bin from %PATH%\"\n Pop $RemoveOTPFromPathCheckbox\n SendMessage $RemoveOTPFromPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0\n ${EndIf}\n\n nsDialogs::Show\nFunctionEnd\n\nvar PathsToRemove\nFunction un.FinishPageLeave\n ${NSD_GetState} $RemoveOTPFromPathCheckbox $1\n ${If} $1 <> ${BST_UNCHECKED}\n StrCpy $PathsToRemove \";$OTPPath\\bin\"\n ${EndIf}\n\n ${NSD_GetState} $RemoveElixirFromPathCheckbox $1\n ${If} $1 <> ${BST_UNCHECKED}\n StrCpy $PathsToRemove \"$PathsToRemove;$INSTDIR\\bin\"\n ${EndIf}\n\n ${If} \"$PathsToRemove\" != \"\"\n nsExec::ExecToStack `\"$OTPPath\\bin\\escript.exe\" \"$INSTDIR\\update_system_path.erl\" remove \"$PathsToRemove\"`\n Pop $0\n Pop $1\n ${If} $0 != 0\n SetErrorlevel 5\n MessageBox MB_ICONSTOP \"removing paths failed with $0: $1\"\n Quit\n ${EndIf}\n ${EndIf}\nFunctionEnd\n\nUninstPage custom un.FinishPageShow un.FinishPageLeave\n\n!insertmacro MUI_UNPAGE_DIRECTORY\n!insertmacro MUI_UNPAGE_INSTFILES\n\nSection \"Uninstall\"\n RMDir /r \"$INSTDIR\"\n DeleteRegKey HKLM \"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Elixir\"\n DeleteRegKey HKLM \"Software\\Elixir\\Elixir\"\n DeleteRegKey /ifempty HKLM \"Software\\Elixir\"\nSectionEnd\n\n!insertmacro MUI_LANGUAGE \"English\"\n" }, { "path": "lib/elixir/scripts/windows_installer/update_system_path.erl", "content": "#!/usr/bin/env escript\n%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n\n%%! -noinput\n\n%% This file is used by the Elixir installer and uninstaller.\nmain([\"add\", \";\" ++ PathsToAdd]) ->\n {ok, Reg} = win32reg:open([read, write]),\n ok = win32reg:change_key(Reg, \"\\\\hkey_current_user\\\\environment\"),\n {ok, SystemPath} = win32reg:value(Reg, \"path\"),\n\n NewSystemPath =\n lists:foldl(\n fun(Elem, Acc) ->\n Elem ++ \";\" ++\n binary_to_list(\n iolist_to_binary(\n string:replace(Acc, Elem ++ \";\", \"\", all)))\n end,\n SystemPath,\n string:split(PathsToAdd, \";\", all)\n ),\n\n ok = win32reg:set_value(Reg, \"Path\", NewSystemPath),\n ok;\n\nmain([\"remove\", \";\" ++ PathsToRemove]) ->\n {ok, Reg} = win32reg:open([read, write]),\n ok = win32reg:change_key(Reg, \"\\\\hkey_current_user\\\\environment\"),\n {ok, SystemPath} = win32reg:value(Reg, \"path\"),\n\n NewSystemPath =\n lists:foldl(\n fun(Elem, Acc) ->\n binary_to_list(\n iolist_to_binary(\n string:replace(Acc, Elem ++ \";\", \"\", all)))\n end,\n SystemPath,\n string:split(PathsToRemove, \";\", all)\n ),\n\n ok = win32reg:set_value(Reg, \"Path\", NewSystemPath),\n ok.\n" }, { "path": "lib/elixir/src/elixir.app.src", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n{application, elixir,\n[{description, \"elixir\"},\n {vsn, '$will-be-replaced'},\n {modules, '$will-be-replaced'},\n {registered, [elixir_sup, elixir_config, elixir_code_server]},\n {applications, [kernel,stdlib,compiler]},\n {mod, {elixir,[]}},\n {env, [\n {ansi_syntax_colors, [\n {atom, cyan},\n {binary, default_color},\n {boolean, magenta},\n {charlist, yellow},\n {list, default_color},\n {map, default_color},\n {nil, magenta},\n {number, yellow},\n {string, green},\n {tuple, default_color},\n {variable, light_cyan},\n {call, default_color},\n {operator, default_color}\n ]},\n {check_endianness, true},\n {dbg_callback, {'Elixir.Macro', dbg, []}},\n {time_zone_database, 'Elixir.Calendar.UTCOnlyTimeZoneDatabase'}\n ]}\n]}.\n" }, { "path": "lib/elixir/src/elixir.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Main entry point for Elixir functions. All of those functions are\n%% private to the Elixir compiler and reserved to be used by Elixir only.\n-module(elixir).\n-behaviour(application).\n-export([start_cli/0, start/0]).\n-export([start/2, stop/1, config_change/3]).\n-export([\n string_to_tokens/5, tokens_to_quoted/3, string_to_quoted/5, 'string_to_quoted!'/5,\n env_for_eval/1, quoted_to_erl/2, eval_forms/3, eval_forms/4, eval_quoted/3, eval_quoted/4,\n erl_eval/3, eval_local_handler/2, eval_external_handler/3, emit_warnings/3\n]).\n-include(\"elixir.hrl\").\n-define(system, 'Elixir.System').\n-define(elixir_eval_env, {elixir, eval_env}).\n\n%% Top level types\n%% TODO: Remove char_list type on v2.0\n-export_type([charlist/0, char_list/0, nonempty_charlist/0, struct/0, as_boolean/1, keyword/0, keyword/1]).\n-type charlist() :: string().\n-type char_list() :: string().\n-type nonempty_charlist() :: nonempty_string().\n-type as_boolean(T) :: T.\n-type keyword() :: [{atom(), any()}].\n-type keyword(T) :: [{atom(), T}].\n-type struct() :: #{'__struct__' := atom(), atom() => any()}.\n\n%% OTP Application API\n\nstart(_Type, _Args) ->\n _OTP = parse_otp_release(),\n preload_common_modules(),\n ok = io:setopts(standard_io, [binary]),\n check_file_encoding(file:native_name_encoding()),\n\n case init:get_argument(elixir_root) of\n {ok, [[Root]]} ->\n code:add_pathsa([\n Root ++ \"/eex/ebin\",\n Root ++ \"/ex_unit/ebin\",\n Root ++ \"/iex/ebin\",\n Root ++ \"/logger/ebin\",\n Root ++ \"/mix/ebin\",\n Root ++ \"/elixir/ebin\"\n ], cache);\n _ ->\n ok\n end,\n\n case application:get_env(elixir, check_endianness, true) of\n true -> check_endianness();\n false -> ok\n end,\n\n case application:get_env(elixir, ansi_enabled) of\n {ok, _} ->\n ok;\n\n undefined ->\n application:set_env(elixir, ansi_enabled, prim_tty:isatty(stdout) == true)\n end,\n\n Tokenizer = case code:ensure_loaded('Elixir.String.Tokenizer') of\n {module, Mod} -> Mod;\n _ -> elixir_tokenizer\n end,\n\n URIConfig = [\n {{uri, <<\"ftp\">>}, 21},\n {{uri, <<\"sftp\">>}, 22},\n {{uri, <<\"tftp\">>}, 69},\n {{uri, <<\"http\">>}, 80},\n {{uri, <<\"https\">>}, 443},\n {{uri, <<\"ldap\">>}, 389},\n {{uri, <<\"ws\">>}, 80},\n {{uri, <<\"wss\">>}, 443}\n ],\n\n Config = [\n %% ARGV options\n {at_exit, []},\n {argv, []},\n {no_halt, false},\n\n %% Compiler options\n {debug_info, true},\n {docs, true},\n {ignore_already_consolidated, false},\n {ignore_module_conflict, false},\n {infer_signatures, [elixir]},\n {module_definition, compiled},\n {no_warn_undefined, []},\n {on_undefined_variable, raise},\n {parser_options, [{columns, true}]},\n {relative_paths, true},\n {tracers, []}\n | URIConfig\n ],\n\n elixir_config:static(#{bootstrap => false, identifier_tokenizer => Tokenizer}),\n Tab = elixir_config:new(Config),\n\n case elixir_sup:start_link() of\n {ok, Sup} ->\n {ok, Sup, Tab};\n {error, _Reason} = Error ->\n elixir_config:delete(Tab),\n Error\n end.\n\nstop(Tab) ->\n elixir_config:delete(Tab).\n\nconfig_change(_Changed, _New, _Remove) ->\n ok.\n\npreload_common_modules() ->\n %% We attempt to load those modules here so throughout\n %% the codebase we can avoid code:ensure_loaded/1 checks.\n _ = code:ensure_loaded('Elixir.Kernel'),\n _ = code:ensure_loaded('Elixir.Macro.Env'),\n ok.\n\nparse_otp_release() ->\n %% Whenever we change this check, we should also change Makefile.\n case string:to_integer(erlang:system_info(otp_release)) of\n {Num, _} when Num >= 27 ->\n case Num == 28 andalso (code:ensure_loaded(re) == {module, re}) andalso not erlang:function_exported(re, import, 1) of\n true ->\n io:format(standard_error,\n \"warning! Erlang/OTP 28.0 detected.~n\"\n \"Regexes will be re-compiled from source at runtime, which will cause degraded performance.~n\"\n \"This can be fixed by using Erlang OTP 28.1+ or 27.~n\"\n , []);\n false ->\n ok\n end,\n Num;\n _ ->\n io:format(standard_error, \"ERROR! Unsupported Erlang/OTP version, expected Erlang/OTP 27+~n\", []),\n erlang:halt(1)\n end.\n\ncheck_endianness() ->\n case code:ensure_loaded(?system) of\n {module, ?system} ->\n Endianness = ?system:endianness(),\n case ?system:compiled_endianness() of\n Endianness ->\n ok;\n _ ->\n io:format(standard_error,\n \"warning: Elixir is running in a system with a different endianness than the one its \"\n \"source code was compiled in. Please make sure Elixir and all source files were compiled \"\n \"in a machine with the same endianness as the current one: ~ts~n\", [Endianness])\n end;\n {error, _} ->\n ok\n end.\n\ncheck_file_encoding(Encoding) ->\n case Encoding of\n latin1 ->\n io:format(standard_error,\n \"warning: the VM is running with native name encoding of latin1 which may cause \"\n \"Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 \"\n \"(which can be verified by running \\\"locale\\\" in your shell) or set the \"\n \"ELIXIR_ERL_OPTIONS=\\\"+fnu\\\" environment variable~n\", []);\n _ ->\n ok\n end.\n\n%% Boot and process given options. Invoked by Elixir's script.\n\nstart() ->\n user_drv:start(#{initial_shell => iex:shell()}).\n\nstart_cli() ->\n {ok, _} = application:ensure_all_started(elixir),\n\n %% We start the Logger so tools that depend on Elixir\n %% always have the Logger directly accessible. However\n %% Logger is not a dependency of the Elixir application,\n %% which means releases that want to use Logger must\n %% always list it as part of its applications.\n _ = case code:ensure_loaded('Elixir.Logger') of\n {module, _} -> application:start(logger);\n {error, _} -> ok\n end,\n\n 'Elixir.Kernel.CLI':main(init:get_plain_arguments()).\n\n%% EVAL HOOKS\n\nenv_for_eval(#{'__struct__' := 'Elixir.Macro.Env', lexical_tracker := Pid} = Env) when map_size(Env) == 15 ->\n NewEnv = Env#{\n context := nil,\n macro_aliases := [],\n versioned_vars := #{}\n },\n\n case is_pid(Pid) of\n true ->\n case is_process_alive(Pid) of\n true ->\n NewEnv;\n false ->\n 'Elixir.IO':warn(\n <<\"an __ENV__ with outdated compilation information was given to eval, \"\n \"call Macro.Env.prune_compile_info/1 to prune it\">>\n ),\n NewEnv#{lexical_tracker := nil, tracers := []}\n end;\n false ->\n NewEnv#{tracers := []}\n end;\nenv_for_eval(Opts) when is_list(Opts) ->\n Env = elixir_env:new(),\n Line = elixir_utils:get_line(Opts, Env),\n File = elixir_utils:get_file(Opts, Env),\n\n Module = case lists:keyfind(module, 1, Opts) of\n {module, ModuleOpt} when is_atom(ModuleOpt) -> ModuleOpt;\n false -> nil\n end,\n\n FA = case lists:keyfind(function, 1, Opts) of\n {function, {Function, Arity}} when is_atom(Function), is_integer(Arity) -> {Function, Arity};\n {function, nil} -> nil;\n false -> nil\n end,\n\n TempTracers = case lists:keyfind(tracers, 1, Opts) of\n {tracers, TracersOpt} when is_list(TracersOpt) -> TracersOpt;\n false -> []\n end,\n\n %% TODO: Remove the following deprecations in future releases\n Aliases = case lists:keyfind(aliases, 1, Opts) of\n {aliases, AliasesOpt} when is_list(AliasesOpt) ->\n 'Elixir.IO':warn(<<\":aliases option in eval is deprecated\">>),\n AliasesOpt;\n false ->\n ?key(Env, aliases)\n end,\n\n Requires = case lists:keyfind(requires, 1, Opts) of\n {requires, RequiresOpt} when is_list(RequiresOpt) ->\n 'Elixir.IO':warn(<<\":requires option in eval is deprecated\">>),\n ordsets:from_list(RequiresOpt);\n false ->\n ?key(Env, requires)\n end,\n\n Functions = case lists:keyfind(functions, 1, Opts) of\n {functions, FunctionsOpt} when is_list(FunctionsOpt) ->\n 'Elixir.IO':warn(<<\":functions option in eval is deprecated\">>),\n FunctionsOpt;\n false ->\n ?key(Env, functions)\n end,\n\n Macros = case lists:keyfind(macros, 1, Opts) of\n {macros, MacrosOpt} when is_list(MacrosOpt) ->\n 'Elixir.IO':warn(<<\":macros option in eval is deprecated\">>),\n MacrosOpt;\n false ->\n ?key(Env, macros)\n end,\n\n %% If there is a dead PID or lexical tracker is nil,\n %% we assume the tracers also cannot be (re)used.\n {LexicalTracker, Tracers} = case lists:keyfind(lexical_tracker, 1, Opts) of\n {lexical_tracker, Pid} when is_pid(Pid) ->\n 'Elixir.IO':warn(<<\":lexical_tracker option in eval is deprecated\">>),\n case is_process_alive(Pid) of\n true -> {Pid, TempTracers};\n false -> {nil, []}\n end;\n {lexical_tracker, nil} ->\n 'Elixir.IO':warn(<<\":lexical_tracker option in eval is deprecated\">>),\n {nil, []};\n false ->\n {nil, TempTracers}\n end,\n\n Env#{\n file := File, module := Module, function := FA, tracers := Tracers,\n macros := Macros, functions := Functions, lexical_tracker := LexicalTracker,\n requires := Requires, aliases := Aliases, line := Line\n }.\n\n%% Quoted evaluation\n\neval_quoted(Tree, Binding, E) ->\n eval_quoted(Tree, Binding, E, []).\neval_quoted(Tree, Binding, #{line := Line} = E, Opts) ->\n eval_forms(elixir_quote:linify(Line, line, Tree), Binding, E, Opts).\n\neval_forms(Tree, Binding, OrigE) ->\n eval_forms(Tree, Binding, OrigE, []).\neval_forms(Tree, Binding, OrigE, Opts) ->\n Prune = proplists:get_value(prune_binding, Opts, false),\n case proplists:get_value(dbg_callback, Opts) of\n undefined -> ok;\n DbgCallback -> erlang:put({elixir, dbg_callback}, DbgCallback)\n end,\n try\n {ExVars, ErlVars, ErlBinding} = elixir_erl_var:load_binding(Binding, Prune),\n E = elixir_env:with_vars(OrigE, ExVars),\n ExS = elixir_env:env_to_ex(E),\n ErlS = elixir_erl_var:from_env(E, ErlVars),\n {Erl, NewErlS, NewExS, NewE} = quoted_to_erl(Tree, ErlS, ExS, E),\n\n case Erl of\n {Literal, _, Value} when Literal == atom; Literal == float; Literal == integer ->\n if\n Prune -> {Value, [], NewE#{versioned_vars := #{}}};\n true -> {Value, Binding, NewE}\n end;\n\n _ ->\n {value, Value, NewBinding} = erl_eval(Erl, ErlBinding, NewE),\n PruneBefore = if Prune -> length(Binding); true -> -1 end,\n\n {DumpedBinding, DumpedVars} =\n elixir_erl_var:dump_binding(NewBinding, NewErlS, NewExS, PruneBefore),\n\n {Value, DumpedBinding, NewE#{versioned_vars := DumpedVars}}\n end\n after\n erlang:erase({elixir, dbg_callback})\n end.\n\n%% Evaluate Erlang code with careful handling of local and external functions\nerl_eval(Expr, Binding, Env) ->\n %% We use remote names so eval works across Elixir versions\n LocalHandler = {value, fun ?MODULE:eval_local_handler/2},\n ExternalHandler = {value, fun ?MODULE:eval_external_handler/3},\n\n try\n %% ?elixir_eval_env is used by the external handler.\n %%\n %% The reason why we use the process dictionary to pass the environment\n %% is because we want to avoid passing closures to erl_eval, as that\n %% would effectively tie the eval code to the Elixir version and it is\n %% best if it depends solely on Erlang/OTP.\n %%\n %% The downside is that functions that escape the eval context will no\n %% longer have the original environment they came from.\n erlang:put(?elixir_eval_env, Env),\n erl_eval:expr(Expr, Binding, LocalHandler, ExternalHandler)\n after\n erlang:erase(?elixir_eval_env)\n end.\n\neval_local_handler(FunName, Args) ->\n {current_stacktrace, Stack} = erlang:process_info(self(), current_stacktrace),\n Opts = [{module, nil}, {function, FunName}, {arity, length(Args)}, {reason, 'undefined local'}],\n Exception = 'Elixir.UndefinedFunctionError':exception(Opts),\n erlang:raise(error, Exception, Stack).\n\neval_external_handler(Ann, FunOrModFun, Args) ->\n try\n case FunOrModFun of\n {Mod, Fun} -> apply(Mod, Fun, Args);\n Fun -> apply(Fun, Args)\n end\n catch\n Kind:Reason:Stacktrace ->\n %% Take everything up to the Elixir module\n Pruned =\n lists:takewhile(fun\n ({elixir,_,_,_}) -> false;\n (_) -> true\n end, Stacktrace),\n\n Caller =\n lists:dropwhile(fun\n ({elixir,_,_,_}) -> false;\n (_) -> true\n end, Stacktrace),\n\n %% Now we prune any shared code path from erl_eval\n {current_stacktrace, Current} =\n erlang:process_info(self(), current_stacktrace),\n\n %% We need to make sure that we don't generate more\n %% frames than supported. So we do our best to drop\n %% from the Caller, but if the caller has no frames,\n %% we need to drop from Pruned.\n {DroppedCaller, ToDrop} =\n case Caller of\n [] -> {[], true};\n _ -> {lists:droplast(Caller), false}\n end,\n\n Reversed = drop_common(lists:reverse(Current), lists:reverse(Pruned), ToDrop),\n\n %% Add file+line information at the bottom\n Bottom =\n case erlang:get(?elixir_eval_env) of\n #{'__struct__' := 'Elixir.Macro.Env'} = E ->\n 'Elixir.Macro.Env':stacktrace(E#{line := erl_anno:line(Ann)});\n _ ->\n []\n end,\n\n Custom = lists:reverse(Bottom ++ Reversed, DroppedCaller),\n erlang:raise(Kind, Reason, Custom)\n end.\n\n%% We need to check if we have dropped any frames.\n%% If we have not dropped frames, then we need to drop one\n%% at the end so we can put the elixir_eval frame in. If\n%% we have more traces then depth, Erlang would discard\n%% the whole stacktrace.\ndrop_common([H | T1], [H | T2], _ToDrop) -> drop_common(T1, T2, false);\ndrop_common([_ | T1], T2, ToDrop) -> drop_common(T1, T2, ToDrop);\ndrop_common([], [{?MODULE, _, _, _} | T2], _ToDrop) -> T2;\ndrop_common([], [_ | T2], true) -> T2;\ndrop_common([], T2, _) -> T2.\n\n%% Converts a quoted expression to Erlang abstract format\n\nquoted_to_erl(Quoted, E) ->\n {_, ErlS} = elixir_erl_var:from_env(E),\n ExS = elixir_env:env_to_ex(E),\n quoted_to_erl(Quoted, ErlS, ExS, E).\n\nquoted_to_erl(Quoted, ErlS, ExS, Env) ->\n {Expanded, NewExS, NewEnv} =\n elixir_expand:expand(Quoted, ExS, Env),\n {Erl, NewErlS} = elixir_erl_pass:translate(Expanded, erl_anno:new(?key(Env, line)), ErlS),\n {Erl, NewErlS, NewExS, NewEnv}.\n\n%% Converts a given string (charlist) into quote expression\n\nstring_to_tokens(String, StartLine, StartColumn, File, Opts) when is_integer(StartLine), is_binary(File) ->\n case elixir_tokenizer:tokenize(String, StartLine, StartColumn, Opts) of\n {ok, _Line, _Column, Warnings, Tokens, Terminators} ->\n {ok, lists:reverse(Tokens, Terminators), Warnings};\n {error, Info, _Rest, _Warnings, _SoFar} ->\n {error, elixir_tokenizer:format_error(Info)}\n end.\n\ntokens_to_quoted(Tokens, _WarningFile, Opts) ->\n put_parsing_state(Opts),\n\n try elixir_parser:parse(Tokens) of\n {ok, Forms} ->\n {ok, Forms, get(elixir_parser_warnings)};\n {error, {Line, _, [{ErrorPrefix, ErrorSuffix}, Token]}} ->\n {error, {parser_location(Line), {to_binary(ErrorPrefix), to_binary(ErrorSuffix)}, to_binary(Token)}};\n {error, {Line, _, [Error, Token]}} ->\n {error, {parser_location(Line), to_binary(Error), to_binary(Token)}}\n after\n erase(elixir_parser_warnings),\n erase(elixir_parser_columns),\n erase(elixir_token_metadata),\n erase(elixir_literal_encoder)\n end.\n\nemit_warnings(Warnings, File, Opts) ->\n (Warnings /= []) andalso\n (lists:keyfind(emit_warnings, 1, Opts) /= {emit_warnings, false}) andalso\n [elixir_errors:erl_warn(L, File, M) || {L, M} <- lists:reverse(Warnings)].\n\nparser_location({Line, Column, _}) ->\n [{line, Line}, {column, Column}];\nparser_location(Meta) ->\n Line =\n case lists:keyfind(line, 1, Meta) of\n {line, L} -> L;\n false -> 0\n end,\n\n case lists:keyfind(column, 1, Meta) of\n {column, C} -> [{line, Line}, {column, C}];\n false -> [{line, Line}]\n end.\n\nstring_to_quoted(String, StartLine, StartColumn, File, Opts) ->\n case string_to_tokens(String, StartLine, StartColumn, File, Opts) of\n {ok, Tokens, Warnings1} ->\n emit_warnings(Warnings1, File, Opts),\n\n case tokens_to_quoted(Tokens, File, Opts) of\n {ok, Forms, Warnings2} ->\n emit_warnings(Warnings2, File, Opts),\n {ok, Forms};\n\n {error, Error} ->\n {error, Error}\n end;\n\n {error, Error} ->\n {error, Error}\n end.\n\n'string_to_quoted!'(String, StartLine, StartColumn, File, Opts) ->\n case string_to_quoted(String, StartLine, StartColumn, File, Opts) of\n {ok, Forms} ->\n Forms;\n {error, {Meta, Error, Token}} ->\n Indentation = proplists:get_value(indentation, Opts, 0),\n Input = {String, StartLine, StartColumn, Indentation},\n elixir_errors:parse_error(Meta, File, Error, Token, Input)\n end.\n\nto_binary(List) when is_list(List) -> elixir_utils:characters_to_binary(List);\nto_binary(Atom) when is_atom(Atom) -> atom_to_binary(Atom).\n\nput_parsing_state(Opts) ->\n LiteralEncoder =\n case lists:keyfind(literal_encoder, 1, Opts) of\n {literal_encoder, Fun} -> Fun;\n false -> false\n end,\n TokenMetadata = lists:keyfind(token_metadata, 1, Opts) == {token_metadata, true},\n Columns = lists:keyfind(columns, 1, Opts) == {columns, true},\n put(elixir_parser_warnings, []),\n put(elixir_parser_columns, Columns),\n put(elixir_token_metadata, TokenMetadata),\n put(elixir_literal_encoder, LiteralEncoder).\n" }, { "path": "lib/elixir/src/elixir.hrl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-define(key(M, K), map_get(K, M)).\n-define(ann(Meta), elixir_erl:get_ann(Meta)).\n-define(line(Meta), elixir_utils:get_line(Meta)).\n-define(generated(Meta), elixir_utils:generated(Meta)).\n-define(var_context, ?MODULE).\n-define(remote(Ann, Module, Function, Args), {call, Ann, {remote, Ann, {atom, Ann, Module}, {atom, Ann, Function}}, Args}).\n-define(tracker, 'Elixir.Kernel.LexicalTracker').\n\n-record(elixir_ex, {\n %% Stores that the function will fail, which can be used\n %% to run more expensive checks upfront\n tainted_function=false,\n %% Stores if __CALLER__ is allowed\n caller=false,\n %% Stores the variables available before a match.\n %% May be one of:\n %%\n %% * {Read, Cycle :: #{}, Meta :: Counter | {bitsize, Original}}\n %% * pin\n %% * none.\n %%\n %% The cycle is used to detect cyclic dependencies between\n %% variables in a match.\n %%\n %% The bitsize is used when dealing with bitstring modifiers,\n %% as they allow guards but also support the pin operator.\n prematch=none,\n %% Stores if __STACKTRACE__ is allowed\n stacktrace=false,\n %% A map of unused vars and a version counter for vars\n unused={#{}, 0},\n %% A list of modules defined in functions (runtime)\n runtime_modules=[],\n %% A tuple with maps of read and optional write current vars.\n %% Read variables is all defined variables. Write variables\n %% stores the variables that have been made available (written\n %% to) but cannot be currently read. This is used in two occasions:\n %%\n %% * To store variables graphs inside = in patterns\n %%\n %% * To store variables defined inside calls. For example,\n %% if you write foo(a = 123), the value of `a` cannot be\n %% read in the following argument, only after the call\n %%\n vars={#{}, false}\n}).\n\n-record(elixir_erl, {\n %% Can be match, guards or nil\n context=nil,\n %% Extra information about the context, like pin_guard and map_key\n extra=nil,\n %% When true, it means caller was invoked\n caller=false,\n %% Maps of defined variables and their alias\n var_names=#{},\n %% Extra guards from args expansion\n extra_guards=[],\n %% A map counting the variables defined\n counter=#{},\n %% A boolean to control if captures should be expanded\n expand_captures=false,\n %% Holds information about the stacktrace variable\n stacktrace=nil\n}).\n\n-record(elixir_tokenizer, {\n terminators=[],\n unescape=true,\n cursor_completion=false,\n existing_atoms_only=false,\n static_atoms_encoder=nil,\n preserve_comments=nil,\n identifier_tokenizer=elixir_tokenizer,\n ascii_identifiers_only=true,\n indentation=0,\n column=1,\n mismatch_hints=[],\n warnings=[]\n}).\n" }, { "path": "lib/elixir/src/elixir_aliases.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_aliases).\n-export([inspect/1, concat/1, safe_concat/1, format_error/1,\n ensure_loaded/3, expand/4, expand_or_concat/4, alias/6, require/5]).\n-include(\"elixir.hrl\").\n\ninspect(Atom) when is_atom(Atom) ->\n case elixir_config:is_bootstrap() of\n true -> atom_to_binary(Atom);\n false -> 'Elixir.Macro':inspect_atom(literal, Atom)\n end.\n\nrequire(Meta, Ref, Opts, E, Trace) ->\n Trace andalso elixir_env:trace({require, Meta, Ref, Opts}, E),\n E#{requires := ordsets:add_element(Ref, ?key(E, requires))}.\n\nalias(Meta, Ref, IncludeByDefault, Opts, E, Trace) ->\n #{aliases := Aliases, macro_aliases := MacroAliases} = E,\n\n case expand_as(lists:keyfind(as, 1, Opts), IncludeByDefault, Ref) of\n {ok, Ref} ->\n {ok, false,\n E#{aliases := remove_alias(Ref, Aliases),\n macro_aliases := remove_macro_alias(Meta, Ref, MacroAliases)}};\n\n {ok, New} ->\n Trace andalso elixir_env:trace({alias, Meta, Ref, New, Opts}, E),\n {ok, New,\n E#{aliases := store_alias(New, Ref, Aliases),\n macro_aliases := store_macro_alias(Meta, New, Ref, MacroAliases)}};\n\n none ->\n {ok, false, E};\n\n {error, Reason} ->\n {error, Reason}\n end.\n\nexpand_as({as, Atom}, _IncludeByDefault, _Ref) when is_atom(Atom), not is_boolean(Atom) ->\n case atom_to_list(Atom) of\n \"Elixir.\" ++ ([FirstLetter | _] = Rest) when FirstLetter >= $A, FirstLetter =< $Z ->\n case string:tokens(Rest, \".\") of\n [_] ->\n {ok, Atom};\n _ ->\n {error, {invalid_alias_for_as, nested_alias, Atom}}\n end;\n _ ->\n {error, {invalid_alias_for_as, not_alias, Atom}}\n end;\nexpand_as({as, Other}, _IncludeByDefault, _Ref) ->\n {error, {invalid_alias_for_as, not_alias, Other}};\nexpand_as(false, true, Ref) ->\n case atom_to_list(Ref) of\n (\"Elixir.\" ++ [FirstLetter | _]) = List when FirstLetter >= $A, FirstLetter =< $Z ->\n Last = last(lists:reverse(List), []),\n {ok, list_to_atom(\"Elixir.\" ++ Last)};\n _ ->\n {error, {invalid_alias_module, Ref}}\n end;\nexpand_as(false, false, _Ref) ->\n none.\n\nlast([$. | _], Acc) -> Acc;\nlast([H | T], Acc) -> last(T, [H | Acc]);\nlast([], Acc) -> Acc.\n\nstore_alias(New, Old, Aliases) ->\n lists:keystore(New, 1, Aliases, {New, Old}).\n\nstore_macro_alias(Meta, New, Old, Aliases) ->\n case lists:keyfind(counter, 1, Meta) of\n {counter, Counter} ->\n lists:keystore(New, 1, Aliases, {New, {Counter, Old}});\n false ->\n Aliases\n end.\n\nremove_alias(Atom, Aliases) ->\n lists:keydelete(Atom, 1, Aliases).\n\nremove_macro_alias(Meta, Atom, Aliases) ->\n case lists:keyfind(counter, 1, Meta) of\n {counter, _Counter} ->\n lists:keydelete(Atom, 1, Aliases);\n false ->\n Aliases\n end.\n\n%% Expand an alias. It returns an atom (meaning that there\n%% was an expansion) or a list of atoms.\n\nexpand(_Meta, ['Elixir' | _] = List, _E, _Trace) ->\n List;\n\nexpand(_Meta, [H | _] = List, _E, _Trace) when not is_atom(H) ->\n List;\n\nexpand(Meta, List, #{aliases := Aliases, macro_aliases := MacroAliases} = E, Trace) ->\n case lists:keyfind(alias, 1, Meta) of\n {alias, false} ->\n expand(Meta, List, MacroAliases, E, Trace);\n {alias, Atom} when is_atom(Atom) ->\n Atom;\n false ->\n expand(Meta, List, Aliases, E, Trace)\n end.\n\nexpand(Meta, [H | T], Aliases, E, Trace) ->\n Lookup = list_to_atom(\"Elixir.\" ++ atom_to_list(H)),\n\n Counter = case lists:keyfind(counter, 1, Meta) of\n {counter, C} -> C;\n _ -> nil\n end,\n\n case lookup(Lookup, Aliases, Counter) of\n Lookup -> [H | T];\n Atom ->\n Trace andalso elixir_env:trace({alias_expansion, Meta, Lookup, Atom}, E),\n case T of\n [] -> Atom;\n _ -> concat([Atom | T])\n end\n end.\n\n%% Expands or concat if possible.\n\nexpand_or_concat(Meta, List, E, Trace) ->\n case expand(Meta, List, E, Trace) of\n [H | T] when is_atom(H) -> concat([H | T]);\n AtomOrList -> AtomOrList\n end.\n\n%% Ensure a module is loaded before its usage.\n\n%% Skip Kernel verification for bootstrap purposes.\nensure_loaded(_Meta, 'Elixir.Kernel', _E) ->\n ok;\nensure_loaded(Meta, Module, #{module := Module} = E) ->\n elixir_errors:file_error(Meta, E, ?MODULE, {circular_module, Module});\nensure_loaded(Meta, Module, E) ->\n case code:ensure_loaded(Module) of\n {module, Module} ->\n ok;\n\n _ ->\n case wait_for_module(Module, Meta, E) of\n found ->\n ok;\n\n Wait ->\n Kind = case lists:member(Module, ?key(E, context_modules)) of\n true -> scheduled_module;\n false when Wait == deadlock -> deadlock_module;\n false -> unloaded_module\n end,\n\n elixir_errors:file_error(Meta, E, ?MODULE, {Kind, Module})\n end\n end.\n\nwait_for_module(Module, Meta, E) ->\n case erlang:get(elixir_compiler_info) of\n undefined -> not_found;\n _ -> 'Elixir.Kernel.ErrorHandler':ensure_compiled(Module, module, hard, elixir_utils:get_line(Meta, E))\n end.\n\n%% Receives a list of atoms, binaries or lists\n%% representing modules and concatenates them.\n\nconcat(Args) -> binary_to_atom(do_concat(Args), utf8).\nsafe_concat(Args) -> binary_to_existing_atom(do_concat(Args), utf8).\n\ndo_concat([H | T]) when is_atom(H), H /= nil ->\n do_concat([atom_to_binary(H) | T]);\ndo_concat([<<\"Elixir.\", _/binary>>=H | T]) ->\n do_concat(T, H);\ndo_concat([<<\"Elixir\">>=H | T]) ->\n do_concat(T, H);\ndo_concat(T) ->\n do_concat(T, <<\"Elixir\">>).\n\ndo_concat([nil | T], Acc) ->\n do_concat(T, Acc);\ndo_concat([H | T], Acc) when is_atom(H) ->\n do_concat(T, <>);\ndo_concat([H | T], Acc) when is_binary(H) ->\n do_concat(T, <>);\ndo_concat([], Acc) ->\n Acc.\n\nto_partial(<<\"Elixir.\", Arg/binary>>) -> Arg;\nto_partial(<<\".\", Arg/binary>>) -> Arg;\nto_partial(Arg) when is_binary(Arg) -> Arg.\n\n%% Lookup an alias in the current scope.\n\nlookup(Else, List, Counter) ->\n case lists:keyfind(Else, 1, List) of\n {Else, {Counter, Value}} -> Value;\n {Else, Value} when is_atom(Value) -> Value;\n _ -> Else\n end.\n\n%% Errors\n\nformat_error({invalid_alias_module, Ref}) ->\n io_lib:format(\"alias cannot be inferred automatically for module: ~ts, please use the :as option. Implicit aliasing is only supported with Elixir modules\",\n ['Elixir.Macro':to_string(Ref)]);\n\nformat_error({invalid_alias_for_as, Reason, Value}) ->\n ExpectedGot =\n case Reason of\n not_alias -> \"expected an alias, got\";\n nested_alias -> \"expected a simple alias, got nested alias\"\n end,\n io_lib:format(\"invalid value for option :as, ~ts: ~ts\",\n [ExpectedGot, 'Elixir.Macro':to_string(Value)]);\n\nformat_error({unloaded_module, Module}) ->\n io_lib:format(\"module ~ts is not loaded and could not be found\", [inspect(Module)]);\n\nformat_error({deadlock_module, Module}) ->\n io_lib:format(\"module ~ts is not loaded and could not be found. \"\n \"This may be happening because the module you are trying to load \"\n \"directly or indirectly depends on the current module\",\n [inspect(Module)]);\n\nformat_error({scheduled_module, Module}) ->\n io_lib:format(\n \"module ~ts is not loaded but was defined. This happens when you depend on \"\n \"a module in the same context in which it is defined. For example:\\n\"\n \"\\n\"\n \" defmodule MyApp do\\n\"\n \" defmodule Mod do\\n\"\n \" end\\n\"\n \"\\n\"\n \" use Mod\\n\"\n \" end\\n\"\n \"\\n\"\n \"Try defining the module outside the context that uses it:\\n\"\n \"\\n\"\n \" defmodule MyApp.Mod do\\n\"\n \" end\\n\"\n \"\\n\"\n \" defmodule MyApp do\\n\"\n \" use MyApp.Mod\\n\"\n \" end\\n\"\n \"\\n\"\n \"If the module is defined at the top-level and you are trying to \"\n \"use it at the top-level, this is not supported by Elixir\",\n [inspect(Module)]);\n\nformat_error({circular_module, Module}) ->\n io_lib:format(\n \"you are trying to use/import/require the module ~ts which is currently being defined.\\n\"\n \"\\n\"\n \"This may happen if you accidentally override the module you want to use. For example:\\n\"\n \"\\n\"\n \" defmodule MyApp do\\n\"\n \" defmodule Supervisor do\\n\"\n \" use Supervisor\\n\"\n \" end\\n\"\n \" end\\n\"\n \"\\n\"\n \"In the example above, the new Supervisor conflicts with Elixir's Supervisor. \"\n \"This may be fixed by using the fully qualified name in the definition:\\n\"\n \"\\n\"\n \" defmodule MyApp.Supervisor do\\n\"\n \" use Supervisor\\n\"\n \" end\\n\",\n [inspect(Module)]).\n" }, { "path": "lib/elixir/src/elixir_bitstring.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_bitstring).\n-export([expand/5, format_error/1, validate_spec/2]).\n-import(elixir_errors, [function_error/4]).\n-include(\"elixir.hrl\").\n\nexpand_match(Expr, {S, OriginalS}, E) ->\n {EExpr, SE, EE} = elixir_expand:expand(Expr, S, E),\n {EExpr, {SE, OriginalS}, EE}.\n\nexpand(Meta, Args, S, E, RequireSize) ->\n case ?key(E, context) of\n match ->\n {EArgs, Alignment, {SA, _}, EA} =\n expand(Meta, fun expand_match/3, Args, [], {S, S}, E, 0, RequireSize),\n\n {{'<<>>', [{alignment, Alignment} | Meta], EArgs}, SA, EA};\n _ ->\n PairS = {elixir_env:prepare_write(S), S},\n\n {EArgs, Alignment, {SA, _}, EA} =\n expand(Meta, fun elixir_expand:expand_arg/3, Args, [], PairS, E, 0, RequireSize),\n\n {{'<<>>', [{alignment, Alignment} | Meta], EArgs}, elixir_env:close_write(SA, S), EA}\n end.\n\nexpand(_BitstrMeta, _Fun, [], Acc, S, E, Alignment, _RequireSize) ->\n {lists:reverse(Acc), Alignment, S, E};\nexpand(BitstrMeta, Fun, [{'::', Meta, [Left, Right]} | T], Acc, S, E, Alignment, RequireSize) ->\n % We don't want to consider variables added in the Left pattern inside the Right specs\n {#elixir_ex{vars=BeforeVars}, _} = S,\n\n {ELeft, {#elixir_ex{vars=AfterVars} = SL, OriginalS}, EL} = expand_expr(Left, Fun, S, E),\n validate_expr(ELeft, Meta, E),\n\n MatchOrRequireSize = RequireSize or is_match_size(T, EL),\n EType = expr_type(ELeft),\n ExpectSize = case ELeft of\n _ when not MatchOrRequireSize -> optional;\n {'^', _, [{_, _, _}]} -> {infer, ELeft};\n _ -> required\n end,\n\n {ERight, EAlignment, SS, ES} =\n expand_specs(EType, Meta, Right, SL#elixir_ex{vars=BeforeVars}, OriginalS, EL, ExpectSize),\n\n EAcc = concat_or_prepend_bitstring(Meta, ELeft, ERight, Acc, ES, MatchOrRequireSize),\n PairS = {SS#elixir_ex{vars=AfterVars}, OriginalS},\n expand(BitstrMeta, Fun, T, EAcc, PairS, ES, alignment(Alignment, EAlignment), RequireSize);\nexpand(BitstrMeta, Fun, [H | T], Acc, S, E, Alignment, RequireSize) ->\n Meta = extract_meta(H, BitstrMeta),\n {ELeft, {SS, OriginalS}, ES} = expand_expr(H, Fun, S, E),\n validate_expr(ELeft, Meta, E),\n\n MatchOrRequireSize = RequireSize or is_match_size(T, ES),\n EType = expr_type(ELeft),\n ERight = infer_spec(EType, Meta),\n\n InferredMeta = [{inferred_bitstring_spec, true} | Meta],\n EAcc = concat_or_prepend_bitstring(InferredMeta, ELeft, ERight, Acc, ES, MatchOrRequireSize),\n expand(Meta, Fun, T, EAcc, {SS, OriginalS}, ES, Alignment, RequireSize).\n\nextract_meta({_, Meta, _}, _) -> Meta;\nextract_meta(_, Meta) -> Meta.\n\n%% Variables defined outside the binary can be accounted\n%% on subparts; however, we can't assign new variables.\nis_match_size([_ | _], #{context := match}) -> true;\nis_match_size(_, _) -> false.\n\nexpr_type(Integer) when is_integer(Integer) -> integer;\nexpr_type(Float) when is_float(Float) -> float;\nexpr_type(Binary) when is_binary(Binary) -> binary;\nexpr_type({'<<>>', _, _}) -> bitstring;\nexpr_type(_) -> default.\n\ninfer_spec(bitstring, Meta) -> {bitstring, Meta, nil};\ninfer_spec(binary, Meta) -> {binary, Meta, nil};\ninfer_spec(float, Meta) -> {float, Meta, nil};\ninfer_spec(integer, Meta) -> {integer, Meta, nil};\ninfer_spec(default, Meta) -> {integer, Meta, nil}.\n\nconcat_or_prepend_bitstring(_Meta, {'<<>>', _, []}, _ERight, Acc, _E, _RequireSize) ->\n Acc;\nconcat_or_prepend_bitstring(Meta, {'<<>>', PartsMeta, Parts} = ELeft, ERight, Acc, E, RequireSize) ->\n case E of\n #{context := match} when RequireSize ->\n case lists:last(Parts) of\n {'::', SpecMeta, [Bin, {binary, _, nil}]} when not is_binary(Bin) ->\n function_error(SpecMeta, E, ?MODULE, unsized_binary);\n\n {'::', SpecMeta, [_, {bitstring, _, nil}]} ->\n function_error(SpecMeta, E, ?MODULE, unsized_binary);\n\n _ ->\n ok\n end;\n _ ->\n ok\n end,\n\n case ERight of\n {binary, _, nil} ->\n {alignment, Alignment} = lists:keyfind(alignment, 1, PartsMeta),\n\n if\n is_integer(Alignment) ->\n (Alignment /= 0) andalso function_error(Meta, E, ?MODULE, {unaligned_binary, ELeft}),\n lists:reverse(Parts, Acc);\n\n true ->\n [{'::', Meta, [ELeft, ERight]} | Acc]\n end;\n {bitstring, _, nil} ->\n lists:reverse(Parts, Acc)\n end;\nconcat_or_prepend_bitstring(Meta, ELeft, ERight, Acc, _E, _RequireSize) ->\n [{'::', Meta, [ELeft, ERight]} | Acc].\n\n%% Handling of alignment\n\nalignment(Left, Right) when is_integer(Left), is_integer(Right) -> (Left + Right) rem 8;\nalignment(_, _) -> unknown.\n\ncompute_alignment(_, Size, Unit) when is_integer(Size), is_integer(Unit) -> (Size * Unit);\ncompute_alignment(default, Size, Unit) -> compute_alignment(integer, Size, Unit);\ncompute_alignment(integer, default, Unit) -> compute_alignment(integer, 8, Unit);\ncompute_alignment(integer, Size, default) -> compute_alignment(integer, Size, 1);\ncompute_alignment(bitstring, Size, default) -> compute_alignment(bitstring, Size, 1);\ncompute_alignment(binary, _, _) -> 0;\ncompute_alignment(float, _, _) -> 0;\ncompute_alignment(utf32, _, _) -> 0;\ncompute_alignment(utf16, _, _) -> 0;\ncompute_alignment(utf8, _, _) -> 0;\ncompute_alignment(_, _, _) -> unknown.\n\n%% Expands the expression of a bitstring, that is, the LHS of :: or\n%% an argument of the bitstring (such as \"foo\" in \"<>\").\n%% If we are inside a match/guard, we inline interpolations explicitly,\n%% otherwise they are inlined by elixir_rewrite.erl.\n\nexpand_expr({{'.', _, [Mod, to_string]}, _, [Arg]} = AST, Fun, S, #{context := Context} = E)\n when Context /= nil, (Mod == 'Elixir.Kernel') orelse (Mod == 'Elixir.String.Chars') ->\n case Fun(Arg, S, E) of\n {EBin, SE, EE} when is_binary(EBin) -> {EBin, SE, EE};\n _ -> Fun(AST, S, E) % Let it raise\n end;\nexpand_expr(Component, Fun, S, E) ->\n Fun(Component, S, E).\n\nvalidate_expr(Expr, Meta, #{context := match} = E) ->\n case Expr of\n {Var, _Meta, Ctx} when is_atom(Var), is_atom(Ctx) -> ok;\n {'<<>>', _, _} -> ok;\n {'^', _, _} -> ok;\n _ when is_number(Expr); is_binary(Expr) -> ok;\n _ -> function_error(extract_meta(Expr, Meta), E, ?MODULE, {unknown_match, Expr})\n end;\nvalidate_expr(_Expr, _Meta, _E) ->\n ok.\n\n%% Expands and normalizes types of a bitstring.\n\nexpand_specs(ExprType, Meta, Info, S, OriginalS, E, ExpectSize) ->\n Default =\n #{size => default,\n unit => default,\n sign => default,\n type => default,\n endianness => default},\n {#{size := Size, unit := Unit, type := Type, endianness := Endianness, sign := Sign}, SS, ES} =\n expand_each_spec(Meta, unpack_specs(Info, []), Default, S, OriginalS, E),\n\n MergedType = type(Meta, ExprType, Type, E),\n validate_size_required(Meta, ExpectSize, ExprType, MergedType, Size, ES),\n SizeAndUnit = size_and_unit(Meta, ExprType, Size, Unit, ES),\n Alignment = compute_alignment(MergedType, Size, Unit),\n\n MaybeInferredSize = case {ExpectSize, MergedType, SizeAndUnit} of\n {{infer, PinnedVar}, binary, []} -> [{size, Meta, [{{'.', Meta, [erlang, byte_size]}, Meta, [PinnedVar]}]}];\n {{infer, PinnedVar}, bitstring, []} -> [{size, Meta, [{{'.', Meta, [erlang, bit_size]}, Meta, [PinnedVar]}]}];\n _ -> SizeAndUnit\n end,\n\n [H | T] = build_spec(Meta, Size, Unit, MergedType, Endianness, Sign, MaybeInferredSize, ES),\n {lists:foldl(fun(I, Acc) -> {'-', Meta, [Acc, I]} end, H, T), Alignment, SS, ES}.\n\ntype(_, default, default, _) ->\n integer;\ntype(_, ExprType, default, _) ->\n ExprType;\ntype(_, binary, Type, _) when Type == binary; Type == bitstring; Type == utf8; Type == utf16; Type == utf32 ->\n Type;\ntype(_, bitstring, Type, _) when Type == binary; Type == bitstring ->\n Type;\ntype(_, integer, Type, _) when Type == integer; Type == float; Type == utf8; Type == utf16; Type == utf32 ->\n Type;\ntype(_, float, Type, _) when Type == float ->\n Type;\ntype(_, default, Type, _) ->\n Type;\ntype(Meta, Other, Type, E) ->\n function_error(Meta, E, ?MODULE, {bittype_mismatch, Type, Other, type}),\n Type.\n\nexpand_each_spec(Meta, [{Expr, MetaE, Args} = H | T], Map, S, OriginalS, E) when is_atom(Expr) ->\n case validate_spec(Expr, Args) of\n {Key, Arg} ->\n case Args of\n [] ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {parens_bittype, Expr});\n _ -> ok\n end,\n {Value, SE, EE} = expand_spec_arg(Arg, S, OriginalS, E),\n validate_spec_arg(Meta, Key, Value, SE, OriginalS, EE),\n\n case maps:get(Key, Map) of\n default -> ok;\n Value -> ok;\n Other -> function_error(Meta, E, ?MODULE, {bittype_mismatch, Value, Other, Key})\n end,\n\n expand_each_spec(Meta, T, maps:put(Key, Value, Map), SE, OriginalS, EE);\n\n none ->\n HA = case Args of\n nil ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {unknown_bittype, Expr}),\n {Expr, MetaE, []};\n _ -> H\n end,\n\n case 'Elixir.Macro':expand(HA, E#{line := ?line(Meta)}) of\n HA ->\n function_error(Meta, E, ?MODULE, {undefined_bittype, H}),\n expand_each_spec(Meta, T, Map, S, OriginalS, E);\n\n NewTypes ->\n expand_each_spec(Meta, unpack_specs(NewTypes, []) ++ T, Map, S, OriginalS, E)\n end\n end;\nexpand_each_spec(Meta, [Expr | Tail], Map, S, OriginalS, E) ->\n function_error(Meta, E, ?MODULE, {undefined_bittype, Expr}),\n expand_each_spec(Meta, Tail, Map, S, OriginalS, E);\nexpand_each_spec(_Meta, [], Map, S, _OriginalS, E) ->\n {Map, S, E}.\n\nunpack_specs({'-', _, [H, T]}, Acc) ->\n unpack_specs(H, unpack_specs(T, Acc));\nunpack_specs({'*', _, [{'_', _, Atom}, Unit]}, Acc) when is_atom(Atom) ->\n [{unit, [], [Unit]} | Acc];\nunpack_specs({'*', _, [Size, Unit]}, Acc) ->\n [{size, [], [Size]}, {unit, [], [Unit]} | Acc];\nunpack_specs(Size, Acc) when is_integer(Size) ->\n [{size, [], [Size]} | Acc];\nunpack_specs({Expr, Meta, Args}, Acc) when is_atom(Expr) ->\n ListArgs = if is_atom(Args) -> nil; is_list(Args) -> Args end,\n [{Expr, Meta, ListArgs} | Acc];\nunpack_specs(Other, Acc) ->\n [Other | Acc].\n\nvalidate_spec(Spec, []) -> validate_spec(Spec, nil);\nvalidate_spec(big, nil) -> {endianness, big};\nvalidate_spec(little, nil) -> {endianness, little};\nvalidate_spec(native, nil) -> {endianness, native};\nvalidate_spec(size, [Size]) -> {size, Size};\nvalidate_spec(unit, [Unit]) -> {unit, Unit};\nvalidate_spec(integer, nil) -> {type, integer};\nvalidate_spec(float, nil) -> {type, float};\nvalidate_spec(binary, nil) -> {type, binary};\nvalidate_spec(bytes, nil) -> {type, binary};\nvalidate_spec(bitstring, nil) -> {type, bitstring};\nvalidate_spec(bits, nil) -> {type, bitstring};\nvalidate_spec(utf8, nil) -> {type, utf8};\nvalidate_spec(utf16, nil) -> {type, utf16};\nvalidate_spec(utf32, nil) -> {type, utf32};\nvalidate_spec(signed, nil) -> {sign, signed};\nvalidate_spec(unsigned, nil) -> {sign, unsigned};\nvalidate_spec(_, _) -> none.\n\nexpand_spec_arg(Expr, S, _OriginalS, E) when is_atom(Expr); is_integer(Expr) ->\n {Expr, S, E};\nexpand_spec_arg(Expr, S, OriginalS, #{context := match} = E) ->\n %% We can only access variables that are either on prematch or not in original\n #elixir_ex{prematch={PreRead, PreCycle, _} = OldPre} = S,\n #elixir_ex{vars={OriginalRead, _}} = OriginalS,\n NewPre = {PreRead, PreCycle, {bitsize, OriginalRead}},\n {EExpr, SE, EE} = elixir_expand:expand(Expr, S#elixir_ex{prematch=NewPre}, E#{context := guard}),\n {EExpr, SE#elixir_ex{prematch=OldPre}, EE#{context := match}};\nexpand_spec_arg(Expr, S, OriginalS, E) ->\n elixir_expand:expand(Expr, elixir_env:reset_read(S, OriginalS), E).\n\nvalidate_spec_arg(Meta, unit, Value, _S, _OriginalS, E) when not is_integer(Value) ->\n function_error(Meta, E, ?MODULE, {bad_unit_argument, Value}),\n ok;\nvalidate_spec_arg(_Meta, _Key, _Value, _S, _OriginalS, _E) ->\n ok.\n\nvalidate_size_required(Meta, required, default, Type, default, E) when Type == binary; Type == bitstring ->\n function_error(Meta, E, ?MODULE, unsized_binary),\n ok;\nvalidate_size_required(_, _, _, _, _, _) ->\n ok.\n\nsize_and_unit(Meta, bitstring, Size, Unit, E) when Size /= default; Unit /= default ->\n function_error(Meta, E, ?MODULE, bittype_literal_bitstring),\n [];\nsize_and_unit(Meta, binary, Size, Unit, E) when Size /= default; Unit /= default ->\n function_error(Meta, E, ?MODULE, bittype_literal_string),\n [];\nsize_and_unit(_Meta, _ExprType, Size, Unit, _E) ->\n add_arg(unit, Unit, add_arg(size, Size, [])).\n\nadd_arg(_Key, default, Spec) -> Spec;\nadd_arg(Key, Arg, Spec) -> [{Key, [], [Arg]} | Spec].\n\nbuild_spec(Meta, Size, Unit, Type, Endianness, Sign, Spec, E) when Type == utf8; Type == utf16; Type == utf32 ->\n if\n Size /= default; Unit /= default ->\n function_error(Meta, E, ?MODULE, bittype_utf);\n Sign /= default ->\n function_error(Meta, E, ?MODULE, bittype_signed);\n true ->\n ok\n end,\n add_spec(Type, add_spec(Endianness, Spec));\n\nbuild_spec(Meta, _Size, Unit, Type, _Endianness, Sign, Spec, E) when Type == binary; Type == bitstring ->\n if\n Type == bitstring, Unit /= default, Unit /= 1 ->\n function_error(Meta, E, ?MODULE, {bittype_mismatch, Unit, 1, unit});\n Sign /= default ->\n function_error(Meta, E, ?MODULE, bittype_signed);\n true ->\n %% Endianness is supported but has no effect, so we just ignore it.\n ok\n end,\n add_spec(Type, Spec);\n\nbuild_spec(Meta, Size, Unit, Type, Endianness, Sign, Spec, E) when Type == integer; Type == float ->\n NumberSize = number_size(Size, Unit),\n if\n Type == float, is_integer(NumberSize) ->\n case valid_float_size(NumberSize) of\n true ->\n add_spec(Type, add_spec(Endianness, add_spec(Sign, Spec)));\n false ->\n function_error(Meta, E, ?MODULE, {bittype_float_size, NumberSize}),\n []\n end;\n Size == default, Unit /= default ->\n function_error(Meta, E, ?MODULE, bittype_unit),\n [];\n true ->\n add_spec(Type, add_spec(Endianness, add_spec(Sign, Spec)))\n end.\n\nnumber_size(Size, default) when is_integer(Size) -> Size;\nnumber_size(Size, Unit) when is_integer(Size) -> Size * Unit;\nnumber_size(Size, _) -> Size.\n\nvalid_float_size(16) -> true;\nvalid_float_size(32) -> true;\nvalid_float_size(64) -> true;\nvalid_float_size(_) -> false.\n\nadd_spec(default, Spec) -> Spec;\nadd_spec(Key, Spec) -> [{Key, [], nil} | Spec].\n\nformat_error({unaligned_binary, Expr}) ->\n Message = \"expected ~ts to be a binary but its number of bits is not divisible by 8\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);\nformat_error(unsized_binary) ->\n \"a binary field without size is only allowed at the end of a binary pattern, \"\n \"at the right side of binary concatenation and never allowed in binary generators. \"\n \"The following examples are invalid:\\n\\n\"\n \" rest <> \\\"foo\\\"\\n\"\n \" <>\\n\\n\"\n \"They are invalid because there is a bits/bitstring component not at the end. \"\n \"However, the \\\"reverse\\\" would work:\\n\\n\"\n \" \\\"foo\\\" <> rest\\n\"\n \" <<\\\"foo\\\", rest::binary>>\\n\\n\";\nformat_error(bittype_literal_bitstring) ->\n \"literal <<>> in bitstring supports only type specifiers, which must be one of: \"\n \"binary or bitstring\";\nformat_error(bittype_literal_string) ->\n \"literal string in bitstring supports only endianness and type specifiers, which must be one of: \"\n \"little, big, native, utf8, utf16, utf32, bits, bytes, binary or bitstring\";\nformat_error(bittype_utf) ->\n \"size and unit are not supported on utf types\";\nformat_error(bittype_signed) ->\n \"signed and unsigned specifiers are supported only on integer and float types\";\nformat_error(bittype_unit) ->\n \"integer and float types require a size specifier if the unit specifier is given\";\nformat_error({bittype_float_size, Other}) ->\n io_lib:format(\"float requires size*unit to be 16, 32, or 64 (default), got: ~p\", [Other]);\nformat_error({undefined_bittype, Expr}) ->\n io_lib:format(\"unknown bitstring specifier: ~ts\", ['Elixir.Macro':to_string(Expr)]);\nformat_error({unknown_bittype, Name}) ->\n io_lib:format(\"bitstring specifier \\\"~ts\\\" does not exist and is being expanded to \\\"~ts()\\\",\"\n \" please use parentheses to remove the ambiguity.\\n\"\n \"You may run \\\"mix format --migrate\\\" to fix this warning automatically.\", [Name, Name]);\nformat_error({parens_bittype, Name}) ->\n io_lib:format(\"extra parentheses on a bitstring specifier \\\"~ts()\\\" have been deprecated. \"\n \"Please remove the parentheses: \\\"~ts\\\".\\n\"\n \"You may run \\\"mix format --migrate\\\" to fix this warning automatically.\"\n ,\n [Name, Name]);\nformat_error({bittype_mismatch, Val1, Val2, Where}) ->\n io_lib:format(\"conflicting ~ts specification for bit field: \\\"~p\\\" and \\\"~p\\\"\", [Where, Val1, Val2]);\nformat_error({bad_unit_argument, Unit}) ->\n io_lib:format(\"unit in bitstring expects an integer as argument, got: ~ts\",\n ['Elixir.Macro':to_string(Unit)]);\nformat_error({unknown_match, Expr}) ->\n Message =\n \"a bitstring only accepts binaries, numbers, and variables inside a match, got: ~ts\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);\nformat_error({undefined_var_in_spec, Var}) ->\n Message =\n \"undefined variable \\\"~ts\\\" in bitstring segment. If the size of the binary is a \"\n \"variable, the variable must be defined prior to its use in the binary/bitstring match \"\n \"itself, or outside the pattern match\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Var)]).\n" }, { "path": "lib/elixir/src/elixir_bootstrap.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% An Erlang module that behaves like an Elixir module\n%% used for bootstrapping.\n-module(elixir_bootstrap).\n-export(['MACRO-def'/2, 'MACRO-def'/3, 'MACRO-defp'/3, 'MACRO-defmodule'/3,\n 'MACRO-defmacro'/2, 'MACRO-defmacro'/3, 'MACRO-defmacrop'/3,\n 'MACRO-@'/2, '__info__'/1]).\n-define(kernel, 'Elixir.Kernel').\n\n%% Mock out @ to be a no-op unless Kernel is defined.\n'MACRO-@'(Caller, Tree) ->\n unless_loaded('MACRO-@', [Caller, Tree], fun() -> nil end).\n\n'MACRO-def'(Caller, Call) -> 'MACRO-def'(Caller, Call, nil).\n'MACRO-def'(Caller, Call, Expr) -> define(Caller, def, Call, Expr).\n'MACRO-defp'(Caller, Call, Expr) -> define(Caller, defp, Call, Expr).\n\n'MACRO-defmacro'(Caller, Call) -> 'MACRO-defmacro'(Caller, Call, nil).\n'MACRO-defmacro'(Caller, Call, Expr) -> define(Caller, defmacro, Call, Expr).\n'MACRO-defmacrop'(Caller, Call, Expr) -> define(Caller, defmacrop, Call, Expr).\n\n'MACRO-defmodule'({Line, _S, _E} = _Caller, Alias, [{do, Block}]) ->\n Escaped = elixir_quote:escape(Block, escape, false),\n Args = [[{line, Line}], Alias, Escaped, [], false, env()],\n {{'.', [], [elixir_module, compile]}, [], Args}.\n\n'__info__'(functions) ->\n [];\n'__info__'(macros) ->\n [{'@', 1},\n {def, 1},\n {def, 2},\n {defmacro, 1},\n {defmacro, 2},\n {defmacrop, 2},\n {defmodule, 2},\n {defp, 2}].\n\ndefine({Line, _S, #{module := Module} = E}, Kind, Call, Expr) ->\n UC = elixir_quote:has_unquotes(Call),\n UE = elixir_quote:has_unquotes(Expr),\n\n Store =\n case UC or UE of\n true ->\n elixir_quote:escape({Call, Expr}, escape, true);\n\n false ->\n Key = erlang:unique_integer(),\n elixir_module:write_cache(Module, Key, {Call, Expr}),\n Key\n end,\n\n Args = [Kind, Store, elixir_module:cache_env(E#{line := Line})],\n {{'.', [], [elixir_def, store_definition]}, [], Args}.\n\nunless_loaded(Fun, Args, Callback) ->\n case erlang:module_loaded(?kernel) of\n true -> apply(?kernel, Fun, Args);\n false -> Callback()\n end.\n\nenv() ->\n {'__ENV__', [], nil}.\n" }, { "path": "lib/elixir/src/elixir_clauses.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Handle code related to args, guard and -> matching for case,\n%% fn, receive and friends. try is handled in elixir_try.\n-module(elixir_clauses).\n-export([parallel_match/4, match/6, clause/6, def/3, head/4,\n 'case'/4, 'receive'/4, 'try'/4, 'cond'/4, with/4,\n format_error/1]).\n-import(elixir_errors, [file_error/4, file_warn/4]).\n-include(\"elixir.hrl\").\n\n%% Deal with parallel matches and loops in variables\n\nparallel_match(Meta, Expr, S, #{context := match} = E) ->\n #elixir_ex{vars={_Read, Write}} = S,\n Matches = unpack_match(Expr, Meta, [], E),\n\n {[{_, EHead} | ETail], EWrites, SM, EM} =\n lists:foldl(fun({EMeta, Match}, {AccMatches, AccWrites, SI, EI}) ->\n #elixir_ex{vars={Read, _Write}} = SI,\n {EMatch, SM, EM} = elixir_expand:expand(Match, SI#elixir_ex{vars={Read, #{}}}, EI),\n #elixir_ex{vars={_, EWrite}} = SM,\n {[{EMeta, EMatch} | AccMatches], [EWrite | AccWrites], SM, EM}\n end, {[], [], S, E}, Matches),\n\n EMatch =\n lists:foldl(fun({EMeta, EMatch}, Acc) ->\n {'=', EMeta, [EMatch, Acc]}\n end, EHead, ETail),\n\n #elixir_ex{vars={VRead, _}, prematch={PRead, Cycles, PInfo}} = SM,\n {PCycles, PWrites} = store_cycles(EWrites, Cycles, #{}),\n VWrite = (Write /= false) andalso elixir_env:merge_vars(Write, PWrites),\n {EMatch, SM#elixir_ex{vars={VRead, VWrite}, prematch={PRead, PCycles, PInfo}}, EM}.\n\nunpack_match({'=', Meta, [{_, VarMeta, _} = Node, Node]}, _Meta, Acc, E) ->\n %% TODO: remove this clause on Elixir v1.23\n file_warn(VarMeta, ?key(E, file), ?MODULE, {duplicate_match, Node}),\n unpack_match(Node, Meta, Acc, E);\nunpack_match({'=', Meta, [Left, Right]}, _Meta, Acc, E) ->\n unpack_match(Left, Meta, unpack_match(Right, Meta, Acc, E), E);\nunpack_match(Node, Meta, Acc, _E) ->\n [{Meta, Node} | Acc].\n\nstore_cycles([Write | Writes], {Cycles, SkipList}, Acc) ->\n %% Compute the variables this parallel pattern depends on\n DependsOn = lists:foldl(fun maps:merge/2, Acc, Writes),\n\n %% For each variable on a sibling, we store it inside the graph (Cycles).\n %% The graph will by definition have at least one degree cycles. We need\n %% to find variables which depend on each other more than once (tagged as\n %% error below) and also all second-degree (or later) cycles. In other\n %% words, take this code:\n %%\n %% {x = y, x = {:ok, y}} = expr()\n %%\n %% The first parallel match will say we store the following cycle:\n %%\n %% #{{x,nil} => #{{y,nil} => 1}, {y,nil} => #{{x,nil} => 0}}\n %%\n %% That's why one degree cycles are allowed. However, once we go\n %% over the next parallel pattern, we will have:\n %%\n %% #{{x,nil} => #{{y,nil} => error}, {y,nil} => #{{x,nil} => error}}\n %%\n AccCycles =\n maps:fold(fun(Pair, _, AccCycles) ->\n maps:update_with(Pair, fun(Current) ->\n maps:merge_with(fun(_, _, _) -> error end, Current, DependsOn)\n end, DependsOn, AccCycles)\n end, Cycles, Write),\n\n %% The SkipList keeps variables that are seen as defined together by other\n %% nodes. Those must be skipped on the graph traversal, as they will always\n %% contain cycles between them. For example:\n %%\n %% {{a} = b} = c = expr()\n %%\n %% In the example above, c sees \"a\" and \"b\" as defined together and therefore\n %% one should not point to the other when looking for cycles.\n AccSkipList =\n case map_size(DependsOn) > 1 of\n true -> [DependsOn | SkipList];\n false -> SkipList\n end,\n\n store_cycles(Writes, {AccCycles, AccSkipList}, maps:merge(Acc, Write));\nstore_cycles([], Cycles, Acc) ->\n {Cycles, Acc}.\n\nvalidate_cycles({Cycles, SkipList}, Meta, Expr, E) ->\n maps:fold(fun(Current, _DependsOn, Seen) ->\n recur_cycles(Cycles, Current, root, Seen, SkipList, Meta, Expr, E)\n end, #{}, Cycles).\n\nrecur_cycles(Cycles, Current, Source, Seen, SkipList, Meta, Expr, E) ->\n case is_map_key(Current, Seen) of\n true ->\n Seen;\n\n false ->\n case maps:get(Current, Cycles) of\n #{Current := _} ->\n file_error(Meta, E, ?MODULE, {recursive, [Current], Expr});\n\n DependsOn ->\n %% We traverse over the skip list. For each entry that contains ourselves,\n %% we will split the remaining variables in two groups: one which we have\n %% direct dependencies and skip once and ones that we always skip.\n %%\n %% For example, take `foo = {bar = {baz, bat}}`. `baz` and `bat` never depend\n %% on each other, so we always skip `baz` and `bat` whenever any of them are\n %% seen. However, while `bar` is in the same group as `baz` and `bat` (from the\n %% point of view of `foo`), it depends on them, so it only skips once.\n {OnceKeys, AlwaysKeys} =\n lists:foldl(fun\n (#{Current := _} = Skip, Acc) ->\n maps:fold(fun(K, _, {AccOnce, AccAlways}) ->\n case DependsOn of\n #{K := _} -> {[K | AccOnce], AccAlways};\n #{} -> {AccOnce, [K | AccAlways]}\n end\n end, Acc, Skip);\n (_Skip, Acc) ->\n Acc\n end, {[], []}, SkipList),\n\n NewSeen = maps:merge(maps:from_keys(AlwaysKeys, false), maps:put(Current, true, Seen)),\n\n maps:fold(fun\n (Key, error, _See) ->\n file_error(Meta, E, ?MODULE, {recursive, [Current, Key], Expr});\n\n %% Never go back to the node that we came from (as we can always one hop).\n (Key, _, AccSeen) when Key =:= Source ->\n AccSeen;\n\n (Key, _, AccSeen) ->\n case lists:member(Key, OnceKeys) of\n true ->\n AccSeen;\n\n false when map_get(Key, Seen) ->\n file_error(Meta, E, ?MODULE, {recursive, [Current | maps:keys(Seen)], Expr});\n\n false ->\n recur_cycles(Cycles, Key, Current, AccSeen, SkipList, Meta, Expr, E)\n end\n end, NewSeen, DependsOn)\n end\n end.\n\n%% Match\n\nmatch(Fun, Meta, Expr, AfterS, BeforeS, #{context := nil} = E) ->\n #elixir_ex{vars=Current, unused={_, Counter} = Unused} = AfterS,\n #elixir_ex{vars={Read, _}, prematch=Prematch} = BeforeS,\n\n CallS = BeforeS#elixir_ex{\n prematch={Read, {#{}, []}, Counter},\n unused=Unused,\n vars=Current\n },\n\n CallE = E#{context := match},\n {EExpr, SE, EE} = Fun(Expr, CallS, CallE),\n\n #elixir_ex{\n vars=NewCurrent,\n unused=NewUnused,\n prematch={_, Cycles, _}\n } = SE,\n\n validate_cycles(Cycles, Meta, {match, Expr}, E),\n\n EndS = AfterS#elixir_ex{\n prematch=Prematch,\n unused=NewUnused,\n vars=NewCurrent\n },\n\n EndE = EE#{context := ?key(E, context)},\n {EExpr, EndS, EndE}.\n\ndef({Meta, Args, Guards, Body}, S, E) ->\n {EArgs, SA, EA} = elixir_expand:expand_args(Args, S#elixir_ex{prematch={#{}, {#{}, []}, 0}}, E#{context := match}),\n #elixir_ex{prematch={_, Cycles, _}} = SA,\n validate_cycles(Cycles, Meta, {?key(E, function), Args}, E),\n {EGuards, SG, EG} = guard(Guards, SA#elixir_ex{prematch=none}, EA#{context := guard}),\n {EBody, SB, EB} = elixir_expand:expand(Body, SG, EG#{context := nil}),\n elixir_env:check_unused_vars(SB, EB),\n {Meta, EArgs, EGuards, EBody}.\n\nclause(_Meta, _Kind, Fun, {'->', Meta, [Left, Right]}, S, E) ->\n {ELeft, SL, EL} = case is_function(Fun, 4) of\n true -> Fun(Meta, Left, S, E);\n false -> Fun(Left, S, E)\n end,\n {ERight, SR, ER} = elixir_expand:expand(Right, SL, EL),\n {{'->', Meta, [ELeft, ERight]}, SR, ER};\nclause(Meta, Kind, _Fun, _, _, E) ->\n file_error(Meta, E, ?MODULE, {bad_or_missing_clauses, Kind}).\n\nhead(Meta, [{'when', WhenMeta, [_ | _] = All}], S, E) ->\n {Args, Guard} = elixir_utils:split_last(All),\n guarded_head(Meta, WhenMeta, Args, Guard, S, E);\nhead(Meta, Args, S, E) ->\n match(fun elixir_expand:expand_args/3, Meta, Args, S, S, E).\n\nguarded_head(Meta, WhenMeta, Args, Guard, S, E) ->\n {EArgs, SA, EA} = match(fun elixir_expand:expand_args/3, Meta, Args, S, S, E),\n {EGuard, SG, EG} = guard(Guard, SA, EA#{context := guard}),\n {[{'when', WhenMeta, EArgs ++ [EGuard]}], SG, EG#{context := nil}}.\n\nguard({'when', Meta, [Left, Right]}, S, E) ->\n {ELeft, SL, EL} = guard(Left, S, E),\n {ERight, SR, ER} = guard(Right, SL, EL),\n {{'when', Meta, [ELeft, ERight]}, SR, ER};\nguard(Guard, S, E) ->\n {EGuard, SG, EG} = elixir_expand:expand(Guard, S, E),\n warn_zero_length_guard(EGuard, EG),\n {EGuard, SG, EG}.\n\nwarn_zero_length_guard({{'.', _, [erlang, Op]}, Meta,\n [{{'.', _, [erlang, length]}, _, [Arg]}, 0]}, E) when Op == '=='; Op == '>' ->\n Warn =\n case Op of\n '==' -> {zero_list_length_in_guard, Arg};\n '>' -> {positive_list_length_in_guard, Arg}\n end,\n file_warn(Meta, ?key(E, file), ?MODULE, Warn);\nwarn_zero_length_guard({Op, _, [L, R]}, E) when Op == 'or'; Op == 'and' ->\n warn_zero_length_guard(L, E),\n warn_zero_length_guard(R, E);\nwarn_zero_length_guard(_, _) ->\n ok.\n\n%% Case\n\n'case'(Meta, [], _S, E) ->\n file_error(Meta, E, elixir_expand, {missing_option, 'case', [do]});\n'case'(Meta, Opts, _S, E) when not is_list(Opts) ->\n file_error(Meta, E, elixir_expand, {invalid_args, 'case'});\n'case'(Meta, Opts, S, E) ->\n ok = assert_at_most_once('do', Opts, 0, fun(Key) ->\n file_error(Meta, E, ?MODULE, {duplicated_clauses, 'case', Key})\n end),\n {Case, SA} = lists:mapfoldl(fun(X, SA) -> expand_case(Meta, X, SA, E) end, S, Opts),\n {Case, SA, E}.\n\nexpand_case(Meta, {'do', _} = Do, S, E) ->\n Fun = expand_head('case', 'do'),\n expand_clauses(Meta, 'case', Fun, Do, S, E);\nexpand_case(Meta, {Key, _}, _S, E) ->\n file_error(Meta, E, ?MODULE, {unexpected_option, 'case', Key}).\n\n%% Cond\n\n'cond'(Meta, [], _S, E) ->\n file_error(Meta, E, elixir_expand, {missing_option, 'cond', [do]});\n'cond'(Meta, Opts, _S, E) when not is_list(Opts) ->\n file_error(Meta, E, elixir_expand, {invalid_args, 'cond'});\n'cond'(Meta, Opts, S, E) ->\n ok = assert_at_most_once('do', Opts, 0, fun(Key) ->\n file_error(Meta, E, ?MODULE, {duplicated_clauses, 'cond', Key})\n end),\n {Cond, SA} = lists:mapfoldl(fun(X, SA) -> expand_cond(Meta, X, SA, E) end, S, Opts),\n {Cond, SA, E}.\n\nexpand_cond(Meta, {'do', _} = Do, S, E) ->\n Fun = expand_one(Meta, 'cond', 'do', fun elixir_expand:expand_args/3),\n expand_clauses(Meta, 'cond', Fun, Do, S, E);\nexpand_cond(Meta, {Key, _}, _S, E) ->\n file_error(Meta, E, ?MODULE, {unexpected_option, 'cond', Key}).\n\n%% Receive\n\n'receive'(Meta, [], _S, E) ->\n file_error(Meta, E, elixir_expand, {missing_option, 'receive', [do, 'after']});\n'receive'(Meta, Opts, _S, E) when not is_list(Opts) ->\n file_error(Meta, E, elixir_expand, {invalid_args, 'receive'});\n'receive'(Meta, Opts, S, E) ->\n RaiseError = fun(Key) ->\n file_error(Meta, E, ?MODULE, {duplicated_clauses, 'receive', Key})\n end,\n ok = assert_at_most_once('do', Opts, 0, RaiseError),\n ok = assert_at_most_once('after', Opts, 0, RaiseError),\n {Receive, SA} = lists:mapfoldl(fun(X, SA) -> expand_receive(Meta, X, SA, E) end, S, Opts),\n {Receive, SA, E}.\n\nexpand_receive(_Meta, {'do', {'__block__', _, []}} = Do, S, _E) ->\n {Do, S};\nexpand_receive(Meta, {'do', _} = Do, S, E) ->\n Fun = expand_head('receive', 'do'),\n expand_clauses(Meta, 'receive', Fun, Do, S, E);\nexpand_receive(Meta, {'after', [_]} = After, S, E) ->\n Fun = expand_one(Meta, 'receive', 'after', fun elixir_expand:expand_args/3),\n expand_clauses(Meta, 'receive', Fun, After, S, E);\nexpand_receive(Meta, {'after', _}, _S, E) ->\n file_error(Meta, E, ?MODULE, multiple_after_clauses_in_receive);\nexpand_receive(Meta, {Key, _}, _S, E) ->\n file_error(Meta, E, ?MODULE, {unexpected_option, 'receive', Key}).\n\n%% With\n\nwith(Meta, Args, S, E) ->\n {Exprs, Opts0} = elixir_utils:split_opts(Args),\n S0 = elixir_env:reset_unused_vars(S),\n {EExprs, {S1, E1, HasMatch}} = lists:mapfoldl(fun expand_with/2, {S0, E, false}, Exprs),\n {EDo, Opts1, S2} = expand_with_do(Meta, Opts0, S, S1, E1),\n {EOpts, Opts2, S3} = expand_with_else(Meta, Opts1, S2, E, HasMatch),\n\n case Opts2 of\n [{Key, _} | _] ->\n file_error(Meta, E, elixir_clauses, {unexpected_option, with, Key});\n [] ->\n ok\n end,\n\n {{with, Meta, EExprs ++ [[{do, EDo} | EOpts]]}, S3, E}.\n\nexpand_with({'<-', Meta, [Left, Right]}, {S, E, HasMatch}) ->\n {ERight, SR, ER} = elixir_expand:expand(Right, S, E),\n SM = elixir_env:reset_read(SR, S),\n {[ELeft], SL, EL} = head(Meta, [Left], SM, ER),\n NewHasMatch =\n case ELeft of\n {Var, _, Ctx} when is_atom(Var), is_atom(Ctx) -> HasMatch;\n _ -> true\n end,\n {{'<-', Meta, [ELeft, ERight]}, {SL, EL, NewHasMatch}};\nexpand_with(Expr, {S, E, HasMatch}) ->\n {EExpr, SE, EE} = elixir_expand:expand(Expr, S, E),\n {EExpr, {SE, EE, HasMatch}}.\n\nexpand_with_do(Meta, Opts, S, Acc, E) ->\n case lists:keytake(do, 1, Opts) of\n {value, {do, Expr}, RestOpts} ->\n {EExpr, SAcc, EAcc} = elixir_expand:expand(Expr, Acc, E),\n {EExpr, RestOpts, elixir_env:merge_and_check_unused_vars(SAcc, S, EAcc)};\n false ->\n file_error(Meta, E, elixir_expand, {missing_option, 'with', [do]})\n end.\n\nexpand_with_else(Meta, Opts, S, E, HasMatch) ->\n case lists:keytake('else', 1, Opts) of\n {value, Pair, RestOpts} ->\n if\n HasMatch -> ok;\n true -> file_warn(Meta, ?key(E, file), ?MODULE, unmatchable_else_in_with)\n end,\n Fun = expand_head('with', 'else'),\n {EPair, SE} = expand_clauses(Meta, 'with', Fun, Pair, S, E),\n {[EPair], RestOpts, SE};\n false ->\n {[], Opts, S}\n end.\n\n%% Try\n\n'try'(Meta, [], _S, E) ->\n file_error(Meta, E, elixir_expand, {missing_option, 'try', [do]});\n'try'(Meta, [{do, _}], _S, E) ->\n file_error(Meta, E, elixir_expand, {missing_option, 'try', ['catch', 'rescue', 'after']});\n'try'(Meta, Opts, _S, E) when not is_list(Opts) ->\n file_error(Meta, E, elixir_expand, {invalid_args, 'try'});\n'try'(Meta, Opts, S, E) ->\n % TODO: Make this an error on v2.0\n case Opts of\n [{do, _}, {'else', _}] ->\n file_warn(Meta, ?key(E, file), ?MODULE, {try_with_only_else_clause, origin(Meta, 'try')});\n _ ->\n ok\n end,\n RaiseError = fun(Key) ->\n file_error(Meta, E, ?MODULE, {duplicated_clauses, 'try', Key})\n end,\n ok = assert_at_most_once('do', Opts, 0, RaiseError),\n ok = assert_at_most_once('rescue', Opts, 0, RaiseError),\n ok = assert_at_most_once('catch', Opts, 0, RaiseError),\n ok = assert_at_most_once('else', Opts, 0, RaiseError),\n ok = assert_at_most_once('after', Opts, 0, RaiseError),\n ok = warn_catch_before_rescue(Opts, Meta, E, false),\n {Try, SA} = lists:mapfoldl(fun(X, SA) -> expand_try(Meta, X, SA, E) end, S, Opts),\n {Try, SA, E}.\n\nexpand_try(_Meta, {'do', Expr}, S, E) ->\n {EExpr, SE, EE} = elixir_expand:expand(Expr, elixir_env:reset_unused_vars(S), E),\n {{'do', EExpr}, elixir_env:merge_and_check_unused_vars(SE, S, EE)};\nexpand_try(_Meta, {'after', Expr}, S, E) ->\n {EExpr, SE, EE} = elixir_expand:expand(Expr, elixir_env:reset_unused_vars(S), E),\n {{'after', EExpr}, elixir_env:merge_and_check_unused_vars(SE, S, EE)};\nexpand_try(Meta, {'else', _} = Else, S, E) ->\n Fun = expand_head('try', 'else'),\n expand_clauses(Meta, 'try', Fun, Else, S, E);\nexpand_try(Meta, {'catch', _} = Catch, S, E) ->\n expand_clauses_with_stacktrace(Meta, fun expand_catch/4, Catch, S, E);\nexpand_try(Meta, {'rescue', _} = Rescue, S, E) ->\n expand_clauses_with_stacktrace(Meta, fun expand_rescue/4, Rescue, S, E);\nexpand_try(Meta, {Key, _}, _S, E) ->\n file_error(Meta, E, ?MODULE, {unexpected_option, 'try', Key}).\n\nexpand_clauses_with_stacktrace(Meta, Fun, Clauses, S, E) ->\n OldStacktrace = S#elixir_ex.stacktrace,\n SS = S#elixir_ex{stacktrace=true},\n {Ret, SE} = expand_clauses(Meta, 'try', Fun, Clauses, SS, E),\n {Ret, SE#elixir_ex{stacktrace=OldStacktrace}}.\n\nexpand_catch(Meta, [{'when', _, [_, _, _, _ | _]}], _, E) ->\n Error = {wrong_number_of_args_for_clause, \"one or two args\", origin(Meta, 'try'), 'catch'},\n file_error(Meta, E, ?MODULE, Error);\nexpand_catch(Meta, [{'when', WhenMeta, [Arg1, Arg2, Guard]}], S, E) ->\n guarded_head(Meta, WhenMeta, [Arg1, Arg2], Guard, S, E);\nexpand_catch(Meta, [{'when', WhenMeta, [Arg1, Guard]}], S, E) ->\n guarded_head(Meta, WhenMeta, [throw, Arg1], Guard, S, E);\nexpand_catch(Meta, [Arg], S, E) ->\n head(Meta, [throw, Arg], S, E);\nexpand_catch(Meta, [_, _] = Args, S, E) ->\n head(Meta, Args, S, E);\nexpand_catch(Meta, _, _, E) ->\n Error = {wrong_number_of_args_for_clause, \"one or two args\", origin(Meta, 'try'), 'catch'},\n file_error(Meta, E, ?MODULE, Error).\n\nexpand_rescue(Meta, [Arg], S, E) ->\n case expand_rescue(Arg, S, E) of\n {EArg, SA, EA} ->\n {[EArg], SA, EA};\n false ->\n file_error(Meta, E, ?MODULE, {invalid_rescue_clause, Arg})\n end;\nexpand_rescue(Meta, _, _, E) ->\n Error = {wrong_number_of_args_for_clause, \"one argument\", origin(Meta, 'try'), 'rescue'},\n file_error(Meta, E, ?MODULE, Error).\n\n%% rescue var\nexpand_rescue({Name, Meta, Atom} = Var, S, E) when is_atom(Name), is_atom(Atom) ->\n match(fun elixir_expand:expand/3, Meta, Var, S, S, E);\n\n%% rescue Alias => _ in [Alias]\nexpand_rescue({'__aliases__', _, [_ | _]} = Alias, S, E) ->\n expand_rescue({in, [], [{'_', [], ?key(E, module)}, Alias]}, S, E);\n\n%% rescue var in _\nexpand_rescue({in, _, [{Name, Meta, VarContext} = Var, {'_', _, UnderscoreContext}]}, S, E)\n when is_atom(Name), is_atom(VarContext), is_atom(UnderscoreContext) ->\n match(fun elixir_expand:expand/3, Meta, Var, S, S, E);\n\n%% rescue var in (list() or atom())\nexpand_rescue({in, Meta, [Left, Right]}, S, E) ->\n {ELeft, SL, EL} = match(fun elixir_expand:expand/3, Meta, Left, S, S, E),\n {ERight, SR, ER} = elixir_expand:expand(Right, SL, EL),\n\n case ELeft of\n {Name, _, Atom} when is_atom(Name), is_atom(Atom) ->\n case normalize_rescue(ERight) of\n false -> false;\n Other -> {{in, Meta, [ELeft, Other]}, SR, ER}\n end;\n _ ->\n false\n end;\n\n%% rescue expr() => rescue expanded_expr()\nexpand_rescue({_, Meta, _} = Arg, S, E) ->\n case 'Elixir.Macro':expand_once(Arg, E#{line := ?line(Meta)}) of\n Arg -> false;\n NewArg -> expand_rescue(NewArg, S, E)\n end;\n\n%% rescue list() or atom() => _ in (list() or atom())\nexpand_rescue(Arg, S, E) ->\n expand_rescue({in, [], [{'_', [], ?key(E, module)}, Arg]}, S, E).\n\nnormalize_rescue(Atom) when is_atom(Atom) ->\n [Atom];\nnormalize_rescue(Other) ->\n is_list(Other) andalso lists:all(fun is_atom/1, Other) andalso Other.\n\n%% Expansion helpers\n\nexpand_head(Kind, Key) ->\n fun\n (Meta, [{'when', _, [_, _, _ | _]}], _, E) ->\n file_error(Meta, E, ?MODULE, {wrong_number_of_args_for_clause, \"one argument\", Kind, Key});\n (Meta, [_] = Args, S, E) ->\n head(Meta, Args, S, E);\n (Meta, _, _, E) ->\n file_error(Meta, E, ?MODULE, {wrong_number_of_args_for_clause, \"one argument\", Kind, Key})\n end.\n\n%% Returns a function that expands arguments\n%% considering we have at maximum one entry.\nexpand_one(Meta, Kind, Key, Fun) ->\n fun\n ([_] = Args, S, E) ->\n Fun(Args, S, E);\n (_, _, E) ->\n file_error(Meta, E, ?MODULE, {wrong_number_of_args_for_clause, \"one argument\", Kind, Key})\n end.\n\n%% Expands all -> pairs in a given key but do not keep the overall vars.\nexpand_clauses(Meta, Kind, Fun, Clauses, S, E) ->\n NewKind = origin(Meta, Kind),\n expand_clauses_origin(Meta, NewKind, Fun, Clauses, S, E).\n\nexpand_clauses_origin(Meta, Kind, Fun, {Key, [_ | _] = Clauses}, S, E) ->\n Transformer = fun(Clause, SA) ->\n {EClause, SAcc, EAcc} =\n clause(Meta, {Kind, Key}, Fun, Clause, elixir_env:reset_unused_vars(SA), E),\n\n {EClause, elixir_env:merge_and_check_unused_vars(SAcc, SA, EAcc)}\n end,\n {Values, SE} = lists:mapfoldl(Transformer, S, Clauses),\n {{Key, Values}, SE};\nexpand_clauses_origin(Meta, Kind, _Fun, {Key, _}, _, E) ->\n file_error(Meta, E, ?MODULE, {bad_or_missing_clauses, {Kind, Key}}).\n\nassert_at_most_once(_Kind, [], _Count, _Fun) -> ok;\nassert_at_most_once(Kind, [{Kind, _} | _], 1, ErrorFun) ->\n ErrorFun(Kind);\nassert_at_most_once(Kind, [{Kind, _} | Rest], Count, Fun) ->\n assert_at_most_once(Kind, Rest, Count + 1, Fun);\nassert_at_most_once(Kind, [_ | Rest], Count, Fun) ->\n assert_at_most_once(Kind, Rest, Count, Fun).\n\nwarn_catch_before_rescue([], _, _, _) ->\n ok;\nwarn_catch_before_rescue([{'rescue', _} | _], Meta, E, true) ->\n file_warn(Meta, ?key(E, file), ?MODULE, {catch_before_rescue, origin(Meta, 'try')});\nwarn_catch_before_rescue([{'catch', _} | Rest], Meta, E, _) ->\n warn_catch_before_rescue(Rest, Meta, E, true);\nwarn_catch_before_rescue([_ | Rest], Meta, E, Found) ->\n warn_catch_before_rescue(Rest, Meta, E, Found).\n\norigin(Meta, Default) ->\n case lists:keyfind(origin, 1, Meta) of\n {origin, Origin} -> Origin;\n false -> Default\n end.\n\nformat_error({duplicate_match, Expr}) ->\n String = 'Elixir.Macro':to_string(Expr),\n io_lib:format(\n \"this pattern is matched against itself inside a match: ~ts = ~ts\",\n [String, String]\n );\n\nformat_error({recursive, Vars, TypeExpr}) ->\n Code =\n case TypeExpr of\n {match, Expr} -> 'Elixir.Macro':to_string(Expr);\n {{Name, _Arity}, Args} -> 'Elixir.Macro':to_string({Name, [], Args})\n end,\n\n Message =\n case lists:map(fun({Name, Context}) -> elixir_utils:var_info(Name, Context) end, lists:sort(Vars)) of\n [Var] ->\n io_lib:format(\"the variable ~ts is defined in function of itself\", [Var]);\n [Var1, Var2] ->\n io_lib:format(\"the variable ~ts is defined recursively in function of ~ts\", [Var1, Var2]);\n [Head | Tail] ->\n List = lists:foldl(fun(X, Acc) -> [Acc, $,, $\\s, X] end, Head, Tail),\n io_lib:format(\"the following variables form a cycle: ~ts\", [List])\n end,\n\n io_lib:format(\n \"recursive variable definition in patterns:~n~n~ts~n~n~ts\",\n [Code, Message]\n );\n\nformat_error({bad_or_missing_clauses, {Kind, Key}}) ->\n io_lib:format(\"invalid \\\"~ts\\\" block in \\\"~ts\\\", it expects \\\"pattern -> expr\\\" clauses\", [Key, Kind]);\n\nformat_error({duplicated_clauses, Kind, Key}) ->\n io_lib:format(\"duplicate \\\"~ts\\\" clauses given for \\\"~ts\\\"\", [Key, Kind]);\n\nformat_error({unexpected_option, Kind, Option}) ->\n io_lib:format(\"unexpected option ~ts in \\\"~ts\\\"\", ['Elixir.Macro':to_string(Option), Kind]);\n\nformat_error({wrong_number_of_args_for_clause, Expected, Kind, Key}) ->\n io_lib:format(\"expected ~ts for \\\"~ts\\\" clauses (->) in \\\"~ts\\\"\", [Expected, Key, Kind]);\n\nformat_error(multiple_after_clauses_in_receive) ->\n \"expected a single -> clause for :after in \\\"receive\\\"\";\n\nformat_error({invalid_rescue_clause, Arg}) ->\n io_lib:format(\n \"invalid \\\"rescue\\\" clause. The clause should match on an alias, a variable \"\n \"or be in the \\\"var in [alias]\\\" format. Got: ~ts\",\n ['Elixir.Macro':to_string(Arg)]\n );\n\nformat_error({catch_before_rescue, Origin}) ->\n io_lib:format(\"\\\"catch\\\" should always come after \\\"rescue\\\" in ~ts\", [Origin]);\n\nformat_error({try_with_only_else_clause, Origin}) ->\n io_lib:format(\"\\\"else\\\" shouldn't be used as the only clause in \\\"~ts\\\", use \\\"case\\\" instead\",\n [Origin]);\n\nformat_error(unmatchable_else_in_with) ->\n \"\\\"else\\\" clauses will never match because all patterns in \\\"with\\\" will always match\";\n\nformat_error({zero_list_length_in_guard, ListArg}) ->\n Arg = 'Elixir.Macro':to_string(ListArg),\n io_lib:format(\"do not use \\\"length(~ts) == 0\\\" to check if a list is empty since length \"\n \"always traverses the whole list. Prefer to pattern match on an empty list or \"\n \"use \\\"~ts == []\\\" as a guard\", [Arg, Arg]);\n\nformat_error({positive_list_length_in_guard, ListArg}) ->\n Arg = 'Elixir.Macro':to_string(ListArg),\n io_lib:format(\"do not use \\\"length(~ts) > 0\\\" to check if a list is not empty since length \"\n \"always traverses the whole list. Prefer to pattern match on a non-empty list, \"\n \"such as [_ | _], or use \\\"~ts != []\\\" as a guard\", [Arg, Arg]).\n" }, { "path": "lib/elixir/src/elixir_code_server.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_code_server).\n-export([call/1, cast/1]).\n-export([start_link/0, init/1, handle_call/3, handle_cast/2,\n handle_info/2, terminate/2, code_change/3]).\n-behaviour(gen_server).\n\n-define(timeout, infinity).\n-record(elixir_code_server, {\n required=#{},\n mod_pool={[], [], 0},\n mod_ets=#{}\n}).\n\ncall(Args) ->\n gen_server:call(?MODULE, Args, ?timeout).\n\ncast(Args) ->\n gen_server:cast(?MODULE, Args).\n\n%% Callbacks\n\nstart_link() ->\n gen_server:start_link({local, ?MODULE}, ?MODULE, ok, []).\n\ninit(ok) ->\n %% The table where we store module definitions\n _ = ets:new(elixir_modules, [set, public, named_table, {read_concurrency, true}]),\n {ok, #elixir_code_server{}}.\n\nhandle_call({defmodule, Module, Pid, Tuple}, _From, Config) ->\n case ets:lookup(elixir_modules, Module) of\n [] ->\n {Ref, NewConfig} = defmodule(Pid, Tuple, Config),\n {reply, {ok, Ref}, NewConfig};\n [CurrentTuple] ->\n {reply, {error, CurrentTuple}, Config}\n end;\n\nhandle_call({undefmodule, Ref}, _From, Config) ->\n {reply, ok, undefmodule(Ref, Config)};\n\nhandle_call({acquire, Path}, From, Config) ->\n Current = Config#elixir_code_server.required,\n case maps:find(Path, Current) of\n {ok, true} ->\n {reply, required, Config};\n {ok, Queued} when is_list(Queued) ->\n Required = maps:put(Path, [From | Queued], Current),\n {noreply, Config#elixir_code_server{required=Required}};\n error ->\n Required = maps:put(Path, [], Current),\n {reply, proceed, Config#elixir_code_server{required=Required}}\n end;\n\nhandle_call(required, _From, Config) ->\n {reply, [F || {F, true} <- maps:to_list(Config#elixir_code_server.required)], Config};\n\nhandle_call(retrieve_compiler_module, _From, Config) ->\n case Config#elixir_code_server.mod_pool of\n {Used, [Mod | Unused], Counter} ->\n {reply, Mod, Config#elixir_code_server{mod_pool={Used, Unused, Counter}}};\n {Used, [], Counter} ->\n {reply, compiler_module(Counter), Config#elixir_code_server{mod_pool={Used, [], Counter+1}}}\n end;\n\nhandle_call(purge_compiler_modules, _From, Config) ->\n {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,\n purge_used(Used),\n Mods = [Mod || {Mod, Purgeable} <- Used, Purgeable],\n ModPool = {[], Mods ++ Unused, Counter},\n {reply, {ok, length(Used)}, Config#elixir_code_server{mod_pool=ModPool}};\n\nhandle_call(Request, _From, Config) ->\n {stop, {badcall, Request}, Config}.\n\nhandle_cast({required, Path}, Config) ->\n Current = Config#elixir_code_server.required,\n case maps:find(Path, Current) of\n {ok, true} ->\n {noreply, Config};\n {ok, Queued} ->\n _ = [gen_server:reply(From, required) || From <- lists:reverse(Queued)],\n Done = maps:put(Path, true, Current),\n {noreply, Config#elixir_code_server{required=Done}};\n error ->\n Done = maps:put(Path, true, Current),\n {noreply, Config#elixir_code_server{required=Done}}\n end;\n\nhandle_cast({unrequire_files, Files}, Config) ->\n Current = Config#elixir_code_server.required,\n Unrequired = maps:without(Files, Current),\n {noreply, Config#elixir_code_server{required=Unrequired}};\n\nhandle_cast({return_compiler_module, Module, Purgeable}, Config) ->\n {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,\n ModPool = {[{Module, Purgeable} | Used], Unused, Counter},\n {noreply, Config#elixir_code_server{mod_pool=ModPool}};\n\nhandle_cast(purge_compiler_modules, Config) ->\n {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,\n\n case Used of\n [] -> ok;\n _ ->\n %% Purging modules became more expensive in Erlang/OTP 27+,\n %% so we accumulate them all during compilation and then\n %% purge them asynchronously, especially because they can\n %% block the code server. Ideally we would purge them in\n %% batches, but that's not supported at the moment.\n Mods = [Mod || {Mod, Purgeable} <- Used, Purgeable],\n Opts = [{monitor, [{tag, {purged, Mods}}]}],\n erlang:spawn_opt(fun() -> purge_used(Used) end, Opts)\n end,\n\n ModPool = {[], Unused, Counter},\n {noreply, Config#elixir_code_server{mod_pool=ModPool}};\n\nhandle_cast(Request, Config) ->\n {stop, {badcast, Request}, Config}.\n\nhandle_info({{purged, Purged}, _Ref, process, _Pid, _Reason}, Config) ->\n {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,\n ModPool = {Used, Purged ++ Unused, Counter},\n {noreply, Config#elixir_code_server{mod_pool=ModPool}};\n\nhandle_info({'DOWN', Ref, process, _Pid, _Reason}, Config) ->\n {noreply, undefmodule(Ref, Config)};\n\nhandle_info(_Msg, Config) ->\n {noreply, Config}.\n\nterminate(_Reason, _Config) ->\n ok.\n\ncode_change(_Old, Config, _Extra) ->\n {ok, Config}.\n\ncompiler_module(I) ->\n list_to_atom(\"elixir_compiler_\" ++ integer_to_list(I)).\n\npurge_used(Used) ->\n [begin\n code:delete(Module),\n Purgeable andalso code:purge(Module)\n end || {Module, Purgeable} <- Used],\n ok.\n\ndefmodule(Pid, Tuple, #elixir_code_server{mod_ets=ModEts} = Config) ->\n ets:insert(elixir_modules, Tuple),\n Ref = erlang:monitor(process, Pid),\n Mod = erlang:element(1, Tuple),\n {Ref, Config#elixir_code_server{mod_ets=maps:put(Ref, Mod, ModEts)}}.\n\nundefmodule(Ref, #elixir_code_server{mod_ets=ModEts} = Config) ->\n case maps:find(Ref, ModEts) of\n {ok, Mod} ->\n ets:delete(elixir_modules, Mod),\n Config#elixir_code_server{mod_ets=maps:remove(Ref, ModEts)};\n error ->\n Config\n end.\n" }, { "path": "lib/elixir/src/elixir_compiler.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Elixir compiler front-end to the Erlang backend.\n-module(elixir_compiler).\n-export([string/3, quoted/3, bootstrap/0, file/2, compile/4, interpret/3]).\n-include(\"elixir.hrl\").\n\nstring(Contents, File, Callback) ->\n Forms = elixir:'string_to_quoted!'(Contents, 1, 1, File, elixir_config:get(parser_options)),\n quoted(Forms, File, Callback).\n\nquoted(Forms, File, Callback) ->\n Previous = get(elixir_module_binaries),\n\n try\n put(elixir_module_binaries, []),\n Env = (elixir_env:new())#{line := 1, file := File, tracers := elixir_config:get(tracers)},\n\n elixir_lexical:run(\n Env,\n fun (LexicalEnv) -> optimize_defmodule(Forms, LexicalEnv) end,\n fun (#{lexical_tracker := Pid}) -> Callback(File, Pid) end\n ),\n\n lists:reverse(get(elixir_module_binaries))\n after\n put(elixir_module_binaries, Previous)\n end.\n\nfile(File, Callback) ->\n {ok, Bin} = file:read_file(File),\n string(elixir_utils:characters_to_list(Bin), File, Callback).\n\n%% In case the forms only holds defmodules, we optimize\n%% it by expanding them directly.\noptimize_defmodule(Forms, E) ->\n case (?key(E, module) == nil) andalso only_defmodule(Forms) andalso\n (not elixir_config:is_bootstrap()) of\n true -> expand_defmodule(Forms, E);\n false -> compile(Forms, [], [], E)\n end,\n ok.\n\n%% A version of compilation that uses eval (interpreted)\ninterpret(Quoted, ArgsList, #{line := Line} = E) ->\n {Expanded, SE, EE} = elixir_expand:expand(Quoted, elixir_env:env_to_ex(E), E),\n elixir_env:check_unused_vars(SE, EE),\n\n {Vars, TS} = elixir_erl_var:from_env(E),\n {ErlExprs, _} = elixir_erl_pass:translate(Expanded, erl_anno:new(Line), TS),\n\n ListBinding = lists:zipwith(fun({_, Var}, Arg) -> {Var, Arg} end, Vars, ArgsList),\n Binding = maps:from_list(ListBinding),\n\n {value, Result, _} =\n try\n elixir:erl_eval(ErlExprs, Binding, E)\n catch\n Kind:Reason:Stacktrace ->\n erlang:raise(Kind, Reason, Stacktrace ++ 'Elixir.Macro.Env':stacktrace(E))\n end,\n\n {Result, SE, EE}.\n\ncompile(Quoted, ArgsList, CompilerOpts, #{line := Line} = E) ->\n Block = no_tail_optimize([{line, Line}], Quoted),\n {Expanded, SE, EE} = elixir_expand:expand(Block, elixir_env:env_to_ex(E), E),\n elixir_env:check_unused_vars(SE, EE),\n\n {Module, Fun, LabelledLocals} =\n elixir_erl_compiler:spawn(fun() -> spawned_compile(Expanded, CompilerOpts, E) end),\n\n Args = list_to_tuple(ArgsList),\n {dispatch(Module, Fun, Args, LabelledLocals), SE, EE}.\n\nspawned_compile(ExExprs, CompilerOpts, #{line := Line, file := File} = E) ->\n {Vars, S} = elixir_erl_var:from_env(E),\n {ErlExprs, _} = elixir_erl_pass:translate(ExExprs, erl_anno:new(Line), S),\n\n Module = retrieve_compiler_module(),\n Fun = code_fun(?key(E, module)),\n Forms = code_mod(Fun, ErlExprs, Line, File, Module, Vars),\n\n {Module, Binary} = elixir_erl_compiler:noenv_forms(Forms, File, [nowarn_nomatch | CompilerOpts]),\n code:load_binary(Module, \"\", Binary),\n {Module, Fun, is_purgeable(Binary)}.\n\nis_purgeable(<<\"FOR1\", _Size:32, \"BEAM\", Rest/binary>>) ->\n do_is_purgeable(Rest).\n\ndo_is_purgeable(<<>>) -> true;\ndo_is_purgeable(<<\"LocT\", 4:32, 0:32, _/binary>>) -> true;\ndo_is_purgeable(<<\"LocT\", _:32, _/binary>>) -> false;\ndo_is_purgeable(<<_:4/binary, Size:32, Beam/binary>>) ->\n <<_:(4 * trunc((Size+3) / 4))/binary, Rest/binary>> = Beam,\n do_is_purgeable(Rest).\n\ndispatch(Module, Fun, Args, Purgeable) ->\n Res = Module:Fun(Args),\n return_compiler_module(Module, Purgeable),\n Res.\n\ncode_fun(nil) -> '__FILE__';\ncode_fun(_) -> '__MODULE__'.\n\ncode_mod(Fun, Expr, Line, File, Module, Vars) when is_binary(File), is_integer(Line) ->\n Ann = erl_anno:new(Line),\n Tuple = {tuple, Ann, [{var, Ann, Var} || {_, Var} <- Vars]},\n Relative = elixir_utils:relative_to_cwd(File),\n\n [{attribute, Ann, file, {elixir_utils:characters_to_list(Relative), 1}},\n {attribute, Ann, module, Module},\n {attribute, Ann, compile, no_auto_import},\n {attribute, Ann, export, [{Fun, 1}, {'__RELATIVE__', 0}]},\n {function, Ann, Fun, 1, [\n {clause, Ann, [Tuple], [], [Expr]}\n ]},\n {function, Ann, '__RELATIVE__', 0, [\n {clause, Ann, [], [], [elixir_erl:elixir_to_erl(Relative)]}\n ]}].\n\nretrieve_compiler_module() ->\n elixir_code_server:call(retrieve_compiler_module).\n\nreturn_compiler_module(Module, Purgeable) ->\n elixir_code_server:cast({return_compiler_module, Module, Purgeable}).\n\nonly_defmodule({'__block__', _, Exprs}) ->\n lists:all(fun only_defmodule/1, Exprs);\n only_defmodule({defmodule, _, [_, [{do, _}]]}) ->\n true;\nonly_defmodule(_) ->\n false.\n\nexpand_defmodule({'__block__', _, Exprs}, E) ->\n lists:foldl(fun(Expr, _) -> expand_defmodule(Expr, E) end, nil, Exprs);\nexpand_defmodule({defmodule, Meta, [Mod, [{do, Block}]]}, NoLineE) ->\n E = NoLineE#{line := ?line(Meta)},\n\n Expanded = case Mod of\n {'__aliases__', AliasMeta, List} ->\n case elixir_aliases:expand_or_concat(AliasMeta, List, E, true) of\n Receiver when is_atom(Receiver) -> Receiver;\n _ -> 'Elixir.Macro':expand(Mod, E)\n end;\n\n _ ->\n 'Elixir.Macro':expand(Mod, E)\n end,\n\n ContextModules = [Expanded | ?key(E, context_modules)],\n elixir_module:compile(Meta, Expanded, Block, [], false, E#{context_modules := ContextModules}).\n\nno_tail_optimize(Meta, Block) ->\n {'__block__', Meta, [\n {'=', Meta, [{result, Meta, ?MODULE}, Block]},\n {{'.', Meta, [elixir_utils, noop]}, Meta, []},\n {result, Meta, ?MODULE}\n ]}.\n\n%% Bootstrapper\n\nbootstrap() ->\n {ok, _} = application:ensure_all_started(elixir),\n elixir_config:static(#{bootstrap => true}),\n elixir_config:put(docs, false),\n elixir_config:put(ignore_module_conflict, true),\n elixir_config:put(on_undefined_variable, raise),\n elixir_config:put(parser_options, []),\n elixir_config:put(relative_paths, false),\n elixir_config:put(tracers, []),\n elixir_config:put(infer_signatures, []),\n {Init, Main} = bootstrap_files(),\n {ok, Cwd} = file:get_cwd(),\n Lib = filename:join(Cwd, \"lib/elixir/lib\"),\n [bootstrap_file(Lib, File) || File <- [<<\"kernel.ex\">> | Init]],\n [bootstrap_file(Lib, File) || File <- [<<\"kernel.ex\">> | Main]].\n\nbootstrap_file(Lib, Suffix) ->\n try\n File = filename:join(Lib, Suffix),\n Mods = file(File, fun(_, _) -> ok end),\n _ = [binary_to_path(X, \"lib/elixir/ebin\") || X <- Mods],\n io:format(\"Compiled ~ts~n\", [Suffix])\n catch\n Kind:Reason:Stacktrace ->\n io:format(\"~p: ~p~nstacktrace: ~p~n\", [Kind, Reason, Stacktrace]),\n erlang:halt(1)\n end.\n\nbootstrap_files() ->\n {\n [\n <<\"kernel/utils.ex\">>,\n <<\"macro/env.ex\">>,\n <<\"range.ex\">>,\n <<\"keyword.ex\">>,\n <<\"module.ex\">>,\n <<\"list.ex\">>,\n <<\"macro.ex\">>,\n <<\"kernel/typespec.ex\">>,\n <<\"code.ex\">>,\n <<\"code/identifier.ex\">>,\n <<\"protocol.ex\">>,\n <<\"stream/reducers.ex\">>,\n <<\"enum.ex\">>,\n <<\"regex.ex\">>,\n <<\"inspect/algebra.ex\">>,\n <<\"inspect.ex\">>,\n <<\"string.ex\">>,\n <<\"string/chars.ex\">>\n ],\n [\n <<\"list/chars.ex\">>,\n <<\"bitwise.ex\">>,\n <<\"map.ex\">>,\n <<\"module/parallel_checker.ex\">>,\n <<\"module/behaviour.ex\">>,\n <<\"module/types/helpers.ex\">>,\n <<\"module/types/descr.ex\">>,\n <<\"module/types/of.ex\">>,\n <<\"module/types/pattern.ex\">>,\n <<\"module/types/apply.ex\">>,\n <<\"module/types/expr.ex\">>,\n <<\"module/types/traverse.ex\">>,\n <<\"module/types.ex\">>,\n <<\"exception.ex\">>,\n <<\"path.ex\">>,\n <<\"file.ex\">>,\n <<\"access.ex\">>,\n <<\"io.ex\">>,\n <<\"system.ex\">>,\n <<\"code/formatter.ex\">>,\n <<\"code/normalizer.ex\">>,\n <<\"kernel/cli.ex\">>,\n <<\"kernel/error_handler.ex\">>,\n <<\"kernel/parallel_compiler.ex\">>,\n <<\"kernel/lexical_tracker.ex\">>\n ]\n }.\n\nbinary_to_path({ModuleName, Binary}, CompilePath) ->\n Path = filename:join(CompilePath, atom_to_list(ModuleName) ++ \".beam\"),\n case file:write_file(Path, Binary) of\n ok -> Path;\n {error, Reason} -> error('Elixir.File.Error':exception([{action, \"write to\"}, {path, Path}, {reason, Reason}]))\n end.\n" }, { "path": "lib/elixir/src/elixir_config.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_config).\n-compile({no_auto_import, [get/1]}).\n-export([new/1, warn/2, serial/1]).\n-export([static/1, is_bootstrap/0, identifier_tokenizer/0]).\n-export([delete/1, put/2, get/1, get/2, update/2, get_and_put/2]).\n-export([start_link/0, init/1, handle_call/3, handle_cast/2]).\n-behaviour(gen_server).\n\n%% Persistent term\n\nstatic(Map) when is_map(Map) ->\n persistent_term:put(?MODULE, maps:merge(persistent_term:get(?MODULE, #{}), Map)).\nis_bootstrap() ->\n maps:get(bootstrap, persistent_term:get(?MODULE, #{}), false).\nidentifier_tokenizer() ->\n maps:get(identifier_tokenizer, persistent_term:get(?MODULE, #{}), 'Elixir.String.Tokenizer').\n\n%% Key-value store (concurrent reads, serial writes)\n\nget(Key) ->\n [{_, Value}] = ets:lookup(?MODULE, Key),\n Value.\n\nget(Key, Default) ->\n try ets:lookup(?MODULE, Key) of\n [{_, Value}] -> Value;\n [] -> Default\n catch\n _:_ -> Default\n end.\n\nput(Key, Value) ->\n gen_server:call(?MODULE, {put, Key, Value}, infinity).\n\nget_and_put(Key, Value) ->\n gen_server:call(?MODULE, {get_and_put, Key, Value}, infinity).\n\nupdate(Key, Fun) ->\n gen_server:call(?MODULE, {update, Key, Fun}, infinity).\n\nnew(Opts) ->\n Tab = ets:new(?MODULE, [named_table, public, {read_concurrency, true}]),\n true = ets:insert_new(?MODULE, Opts),\n Tab.\n\ndelete(?MODULE) ->\n ets:delete(?MODULE).\n\n%% MISC\n\nserial(Fun) ->\n gen_server:call(?MODULE, {serial, Fun}, infinity).\n\n%% Used to guarantee warnings are emitted only once per caller.\nwarn(Key, [{Mod, Fun, ArgsOrArity, _} | _]) ->\n EtsKey = {warn, Key, Mod, Fun, to_arity(ArgsOrArity)},\n ets:update_counter(?MODULE, EtsKey, {2, 1, 1, 1}, {EtsKey, -1}) =:= 0;\n\nwarn(_, _) ->\n true.\n\nto_arity(Args) when is_list(Args) -> length(Args);\nto_arity(Arity) -> Arity.\n\n%% gen_server api\n\nstart_link() ->\n gen_server:start_link({local, ?MODULE}, ?MODULE, ?MODULE, []).\n\ninit(?MODULE) ->\n {ok, []}.\n\nhandle_call({serial, Fun}, _From, State) ->\n {reply, Fun(), State};\n handle_call({put, Key, Value}, _From, State) ->\n ets:insert(?MODULE, {Key, Value}),\n {reply, ok, State};\nhandle_call({update, Key, Fun}, _From, State) ->\n Value = Fun(get(Key)),\n ets:insert(?MODULE, {Key, Value}),\n {reply, Value, State};\nhandle_call({get_and_put, Key, Value}, _From, State) ->\n OldValue = get(Key),\n ets:insert(?MODULE, {Key, Value}),\n {reply, OldValue, State}.\n\nhandle_cast(Cast, Tab) ->\n {stop, {bad_cast, Cast}, Tab}.\n" }, { "path": "lib/elixir/src/elixir_def.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n% Holds the logic responsible for function definitions (def(p) and defmacro(p)).\n-module(elixir_def).\n-export([setup/1, reset_last/1, local_for/5, external_for/5,\n take_definition/2, store_definition/3, store_definition/9,\n fetch_definitions/2, format_error/1]).\n-include(\"elixir.hrl\").\n-define(last_def, {elixir, last_def}).\n\nsetup(DataTables) ->\n reset_last(DataTables),\n ok.\n\nreset_last({DataSet, _DataBag}) ->\n ets:insert(DataSet, {?last_def, none});\n\nreset_last(Module) when is_atom(Module) ->\n reset_last(elixir_module:data_tables(Module)).\n\n%% Finds the local definition for the current module.\nlocal_for(Meta, Name, Arity, Kinds, E) ->\n External = fun({Mod, Fun}, Args) ->\n invoke_external([{from_macro, true} | Meta], Mod, Fun, Args, E)\n end,\n fun_for(Meta, ?key(E, module), Name, Arity, Kinds, {value, External}).\n\n%% Finds the local definition for an external module.\nexternal_for(Meta, Module, Name, Arity, Kinds) ->\n fun_for(Meta, Module, Name, Arity, Kinds, none).\n\nfun_for(Meta, Module, Name, Arity, Kinds, External) ->\n Tuple = {Name, Arity},\n\n try\n {Set, Bag} = elixir_module:data_tables(Module),\n {ets:lookup(Set, {def, Tuple}), ets:lookup(Bag, {clauses, Tuple})}\n of\n {[{_, Kind, LocalMeta, _, _, _}], ClausesPairs} ->\n case (Kinds == all) orelse (lists:member(Kind, Kinds)) of\n true ->\n (Kind == defmacrop) andalso track_defmacrop(Module, Tuple),\n Local = {value, fun(Fun, Args) -> invoke_local(Meta, Module, Fun, Args, External) end},\n Clauses = [Clause || {_, Clause} <- ClausesPairs],\n elixir_erl:definition_to_anonymous(Kind, LocalMeta, Clauses, Local, External);\n false ->\n false\n end;\n {[], _} ->\n false\n catch\n _:_ -> false\n end.\n\ninvoke_local(Meta, Module, ErlName, Args, External) ->\n {Name, Arity} = elixir_utils:erl_fa_to_elixir_fa(ErlName, length(Args)),\n\n case fun_for(Meta, Module, Name, Arity, all, External) of\n false ->\n {current_stacktrace, [_ | T]} = erlang:process_info(self(), current_stacktrace),\n erlang:raise(error, undef, [{Module, Name, Arity, []} | T]);\n Fun ->\n apply(Fun, Args)\n end.\n\ntrack_defmacrop(Module, FunArity) ->\n {_, Bag} = elixir_module:data_tables(Module),\n ets:insert(Bag, {used_private, FunArity}).\n\ninvoke_external(Meta, Mod, Name, Args, E) ->\n is_map(E) andalso elixir_env:trace({require, Meta, Mod, []}, E),\n apply(Mod, Name, Args).\n\n%% Take a definition out of the table\n\ntake_definition(Module, {Name, Arity} = Tuple) ->\n {Set, Bag} = elixir_module:data_tables(Module),\n case ets:take(Set, {def, Tuple}) of\n [{{def, Tuple}, _, _, _, _, {Defaults, _, _}} = Result] ->\n ets:delete_object(Bag, {defs, Tuple}),\n ets:delete_object(Bag, {{default, Name}, Arity, Defaults}),\n {Result, [Clause || {_, Clause} <- ets:take(Bag, {clauses, Tuple})]};\n [] ->\n false\n end.\n\n%% Fetch all available definitions\n\nfetch_definitions(Module, E) ->\n {Set, Bag} = elixir_module:data_tables(Module),\n\n Entries = try\n lists:sort(ets:lookup_element(Bag, defs, 2))\n catch\n error:badarg -> []\n end,\n\n fetch_definition(Entries, E, Module, Set, Bag, []).\n\nfetch_definition([Tuple | T], E, Module, Set, Bag, All) ->\n [{_, Kind, Meta, _, _, {MaxDefaults, _, _}}] = ets:lookup(Set, {def, Tuple}),\n\n try ets:lookup_element(Bag, {clauses, Tuple}, 2) of\n Clauses ->\n NewAll = [{Tuple, Kind, add_defaults_to_meta(MaxDefaults, Meta), Clauses} | All],\n fetch_definition(T, E, Module, Set, Bag, NewAll)\n catch\n error:badarg ->\n elixir_errors:module_error(Meta, E, ?MODULE, {function_head, Kind, Tuple}),\n fetch_definition(T, E, Module, Set, Bag, All)\n end;\n\nfetch_definition([], _E, _Module, _Set, _Bag, All) ->\n All.\n\nadd_defaults_to_meta(0, Meta) -> Meta;\nadd_defaults_to_meta(Defaults, Meta) -> [{defaults, Defaults} | Meta].\n\n%% Section for storing definitions\n\nstore_definition(Kind, {Call, Body}, Pos) ->\n E = elixir_module:get_cached_env(Pos),\n store_definition(Kind, false, Call, Body, E);\nstore_definition(Kind, Key, Pos) ->\n #{module := Module} = E = elixir_module:get_cached_env(Pos),\n {Call, Body} = elixir_module:read_cache(Module, Key),\n store_definition(Kind, true, Call, Body, E).\n\nstore_definition(Kind, HasNoUnquote, Call, Body, #{line := Line} = E) ->\n {NameAndArgs, Guards} = elixir_utils:extract_guards(Call),\n\n {Name, Meta, Args} = case NameAndArgs of\n {N, M, A} when is_atom(N), is_atom(A) -> {N, M, []};\n {N, M, A} when is_atom(N), is_list(A) -> {N, M, A};\n _ -> elixir_errors:file_error([{line, Line}], E, ?MODULE, {invalid_def, Kind, NameAndArgs})\n end,\n\n Context = case lists:keyfind(context, 1, Meta) of\n {context, _} = ContextPair -> [ContextPair];\n _ -> []\n end,\n\n Column = case lists:keyfind(column, 1, Meta) of\n {column, _} = ColumnPair -> [ColumnPair | Context];\n _ -> Context\n end,\n\n Generated = case lists:keyfind(generated, 1, Meta) of\n {generated, true} = GeneratedPair -> [GeneratedPair | Column];\n _ -> Column\n end,\n\n CheckClauses = (Context == []) andalso HasNoUnquote,\n\n %% Check if there is a file information in the definition.\n %% If so, we assume this come from another source and\n %% we need to linify taking into account keep line numbers.\n %%\n %% Line and File will always point to the caller. __ENV__.line\n %% will always point to the quoted one and __ENV__.file will\n %% always point to the one at @file or the quoted one.\n {Location, LinifyArgs, LinifyGuards, LinifyBody} =\n case elixir_utils:meta_keep(Meta) of\n {_, _} = MetaFile ->\n {MetaFile,\n elixir_quote:linify(Line, keep, Args),\n elixir_quote:linify(Line, keep, Guards),\n elixir_quote:linify(Line, keep, Body)};\n nil ->\n {nil, Args, Guards, Body}\n end,\n\n Arity = length(Args),\n\n {File, DefMeta} =\n case retrieve_location(Location, ?key(E, module)) of\n {AF, RF, L} ->\n {AF, [{line, Line}, {file, {RF, L}} | Generated]};\n nil ->\n {nil, [{line, Line} | Generated]}\n end,\n\n run_with_location_change(File, E, fun(EL) ->\n assert_no_aliases_name(DefMeta, Name, Args, EL),\n assert_valid_name(DefMeta, Kind, Name, Args, EL),\n store_definition(DefMeta, Kind, CheckClauses, Name, Arity,\n LinifyArgs, LinifyGuards, LinifyBody, ?key(E, file), EL)\n end).\n\nstore_definition(Meta, Kind, CheckClauses, Name, Arity, DefaultsArgs, Guards, Body, File, ER) ->\n Module = ?key(ER, module),\n Tuple = {Name, Arity},\n {S, E} = env_for_expansion(Kind, Tuple, ER),\n\n {Args, Defaults} = unpack_defaults(Kind, Meta, Name, DefaultsArgs, S, E),\n Clauses = [elixir_clauses:def(Clause, S, E) ||\n Clause <- def_to_clauses(Kind, Meta, Args, Guards, Body, E)],\n\n DefaultsLength = length(Defaults),\n check_previous_defaults(Meta, Module, Name, Arity, Kind, DefaultsLength, E),\n\n store_definition(CheckClauses, Kind, Meta, Name, Arity, File,\n Module, DefaultsLength, Clauses),\n [store_definition(false, Kind, [{context, ?MODULE} | Meta], Name, length(DefaultArgs), File,\n Module, 0, [Default]) || {_, DefaultArgs, _, _} = Default <- Defaults],\n\n run_on_definition_callbacks(Meta, Kind, Module, Name, DefaultsArgs, Guards, Body, E),\n Tuple.\n\nenv_for_expansion(Kind, Tuple, E) when Kind =:= defmacro; Kind =:= defmacrop ->\n S = elixir_env:env_to_ex(E),\n {S#elixir_ex{caller=true}, E#{function := Tuple}};\nenv_for_expansion(_Kind, Tuple, E) ->\n {elixir_env:env_to_ex(E), E#{function := Tuple}}.\n\nretrieve_location(Location, Module) ->\n {Set, _} = elixir_module:data_tables(Module),\n case ets:take(Set, file) of\n [] when is_tuple(Location) ->\n {File, Line} = Location,\n {filename:absname(File), elixir_utils:relative_to_cwd(File), Line};\n [] ->\n nil;\n [{file, File, _, _}] when is_binary(File) ->\n 'Elixir.Module':delete_attribute(Module, file),\n {filename:absname(File), elixir_utils:relative_to_cwd(File), 0};\n [{file, {File, Line}, _, _}] when is_binary(File) andalso is_integer(Line) ->\n 'Elixir.Module':delete_attribute(Module, file),\n {filename:absname(File), elixir_utils:relative_to_cwd(File), Line}\n end.\n\nrun_with_location_change(nil, E, Callback) ->\n Callback(E);\nrun_with_location_change(File, #{file := File} = E, Callback) ->\n Callback(E);\nrun_with_location_change(File, E, Callback) ->\n elixir_lexical:with_file(File, E, Callback).\n\ndef_to_clauses(_Kind, Meta, Args, Guards, nil, E) ->\n check_args_for_function_head(Meta, Args, E),\n (Guards /= []) andalso elixir_errors:module_error(Meta, E, ?MODULE, {invalid_function_head, guards}),\n [];\ndef_to_clauses(_Kind, Meta, Args, Guards, [{do, Body}], _E) ->\n [{Meta, Args, Guards, Body}];\ndef_to_clauses(Kind, Meta, Args, Guards, Body, E) ->\n case is_list(Body) andalso lists:keyfind(do, 1, Body) of\n {do, _} ->\n [{Meta, Args, Guards, {'try', [{origin, Kind} | Meta], [Body]}}];\n false ->\n elixir_errors:file_error(Meta, E, elixir_expand, {missing_option, Kind, [do]})\n end.\n\nrun_on_definition_callbacks(Meta, Kind, Module, Name, Args, Guards, Body, E) ->\n {_, Bag} = elixir_module:data_tables(Module),\n Callbacks = ets:lookup_element(Bag, {accumulate, on_definition}, 2),\n _ = [begin\n elixir_env:trace({remote_function, Meta, Mod, Fun, 6}, E),\n Mod:Fun(E, Kind, Name, Args, Guards, Body)\n end || {Mod, Fun} <- lists:reverse(Callbacks)],\n ok.\n\nstore_definition(CheckClauses, Kind, Meta, Name, Arity, File, Module, Defaults, Clauses)\n when is_boolean(CheckClauses) ->\n {Set, Bag} = elixir_module:data_tables(Module),\n Tuple = {Name, Arity},\n HasBody = Clauses =/= [],\n\n if\n Defaults > 0 ->\n ets:insert(Bag, {{default, Name}, Arity, Defaults});\n true ->\n ok\n end,\n\n {MaxDefaults, FirstMeta} =\n case ets:lookup(Set, {def, Tuple}) of\n [{_, StoredKind, StoredMeta, StoredFile, StoredCheck, {StoredDefaults, LastHasBody, LastDefaults}}] ->\n check_valid_kind(Meta, File, Name, Arity, Kind, StoredKind, StoredFile, StoredMeta),\n check_valid_defaults(Meta, File, Name, Arity, Kind, Defaults, StoredMeta, StoredDefaults, LastDefaults, HasBody, LastHasBody),\n (CheckClauses and StoredCheck) andalso\n check_valid_clause(Meta, File, Name, Arity, Kind, Set, StoredMeta, StoredFile, Clauses),\n\n {max(Defaults, StoredDefaults), StoredMeta};\n [] ->\n ets:insert(Bag, {defs, Tuple}),\n {Defaults, Meta}\n end,\n\n CheckClauses andalso ets:insert(Set, {?last_def, Tuple}),\n ets:insert(Bag, [{{clauses, Tuple}, Clause} || Clause <- Clauses]),\n ets:insert(Set, {{def, Tuple}, Kind, FirstMeta, File, CheckClauses, {MaxDefaults, HasBody, Defaults}}).\n\n%% Handling of defaults\n\nunpack_defaults(Kind, Meta, Name, Args, S, E) ->\n {Expanded, #elixir_ex{unused={_, VersionOffset}}} = expand_defaults(Args, S, E#{context := nil}, []),\n unpack_expanded(Kind, Meta, Name, Expanded, VersionOffset, [], []).\n\nunpack_expanded(Kind, Meta, Name, [{'\\\\\\\\', DefaultMeta, [Expr, _]} | T] = List, VersionOffset, Acc, Clauses) ->\n Base = match_defaults(Acc, length(Acc) + VersionOffset, []),\n {Args, Invoke} = extract_defaults(List, length(Base) + VersionOffset, [], []),\n Clause = {Meta, Base ++ Args, [], {super, [{super, {Kind, Name}}, {default, true} | DefaultMeta], Base ++ Invoke}},\n unpack_expanded(Kind, Meta, Name, T, VersionOffset, [Expr | Acc], [Clause | Clauses]);\nunpack_expanded(Kind, Meta, Name, [H | T], VersionOffset, Acc, Clauses) ->\n unpack_expanded(Kind, Meta, Name, T, VersionOffset, [H | Acc], Clauses);\nunpack_expanded(_Kind, _Meta, _Name, [], _VersionOffset, Acc, Clauses) ->\n {lists:reverse(Acc), lists:reverse(Clauses)}.\n\nexpand_defaults([{'\\\\\\\\', Meta, [Expr, Default]} | Args], S, E, Acc) ->\n {ExpandedDefault, SE, _} = elixir_expand:expand(Default, S, E),\n expand_defaults(Args, SE, E, [{'\\\\\\\\', Meta, [Expr, ExpandedDefault]} | Acc]);\nexpand_defaults([Arg | Args], S, E, Acc) ->\n expand_defaults(Args, S, E, [Arg | Acc]);\nexpand_defaults([], S, _E, Acc) ->\n {lists:reverse(Acc), S}.\n\nextract_defaults([{'\\\\\\\\', _, [_Expr, Default]} | T], Counter, NewArgs, NewInvoke) ->\n extract_defaults(T, Counter, NewArgs, [Default | NewInvoke]);\nextract_defaults([_ | T], Counter, NewArgs, NewInvoke) ->\n H = default_var(Counter),\n extract_defaults(T, Counter + 1, [H | NewArgs], [H | NewInvoke]);\nextract_defaults([], _Counter, NewArgs, NewInvoke) ->\n {lists:reverse(NewArgs), lists:reverse(NewInvoke)}.\n\nmatch_defaults([], _Counter, Acc) ->\n Acc;\nmatch_defaults([_ | T], Counter, Acc) ->\n NewCounter = Counter - 1,\n match_defaults(T, NewCounter, [default_var(NewCounter) | Acc]).\n\ndefault_var(Counter) ->\n {list_to_atom([$x | integer_to_list(Counter)]), [{generated, true}, {version, Counter}], ?var_context}.\n\n%% Validations\n\ncheck_valid_kind(_Meta, _File, _Name, _Arity, Kind, Kind, _StoredFile, _StoredMeta) -> ok;\ncheck_valid_kind(Meta, File, Name, Arity, Kind, StoredKind, StoredFile, StoredMeta) ->\n elixir_errors:file_error(Meta, File, ?MODULE,\n {changed_kind, {Name, Arity, StoredKind, Kind, StoredFile, ?line(StoredMeta)}}).\n\ncheck_valid_clause(Meta, File, Name, Arity, Kind, Set, StoredMeta, StoredFile, Clauses) ->\n case ets:lookup_element(Set, ?last_def, 2) of\n none ->\n ok;\n {Name, Arity} when Clauses == [] ->\n elixir_errors:file_warn(Meta, File, ?MODULE,\n {late_function_head, {Kind, Name, Arity}});\n {Name, Arity} ->\n ok;\n {Name, _} ->\n Relative = elixir_utils:relative_to_cwd(StoredFile),\n elixir_errors:file_warn(Meta, File, ?MODULE,\n {ungrouped_name, {Kind, Name, Arity, ?line(StoredMeta), Relative}});\n _ ->\n Relative = elixir_utils:relative_to_cwd(StoredFile),\n elixir_errors:file_warn(Meta, File, ?MODULE,\n {ungrouped_arity, {Kind, Name, Arity, ?line(StoredMeta), Relative}})\n end.\n\n% Clause with defaults after clause with defaults\ncheck_valid_defaults(Meta, File, Name, Arity, Kind, Defaults, StoredMeta, StoredDefaults, _, _, _)\n when Defaults > 0, StoredDefaults > 0 ->\n elixir_errors:file_error(Meta, File, ?MODULE, {duplicate_defaults, {Kind, Name, Arity, StoredMeta}});\n% Clause with defaults after clause without defaults\ncheck_valid_defaults(Meta, File, Name, Arity, Kind, Defaults, StoredMeta, 0, _, _, _) when Defaults > 0 ->\n elixir_errors:file_warn(Meta, File, ?MODULE, {mixed_defaults, {Kind, Name, Arity, StoredMeta}});\n% Clause without defaults directly after clause with defaults (bodiless does not count)\ncheck_valid_defaults(Meta, File, Name, Arity, Kind, 0, StoredMeta, _, LastDefaults, true, true) when LastDefaults > 0 ->\n elixir_errors:file_warn(Meta, File, ?MODULE, {mixed_defaults, {Kind, Name, Arity, StoredMeta}});\n% Clause without defaults\ncheck_valid_defaults(_Meta, _File, _Name, _Arity, _Kind, 0, _StoredMeta, _StoredDefaults, _LastDefaults, _HasBody, _LastHasBody) ->\n ok.\n\ncheck_args_for_function_head(Meta, Args, E) ->\n [begin\n elixir_errors:module_error(Meta, E, ?MODULE, {invalid_function_head, patterns})\n end || Arg <- Args, invalid_arg(Arg)].\n\ninvalid_arg({Name, _, Kind}) when is_atom(Name), is_atom(Kind) -> false;\ninvalid_arg(_) -> true.\n\ncheck_previous_defaults(Meta, Module, Name, Arity, Kind, Defaults, E) ->\n {_Set, Bag} = elixir_module:data_tables(Module),\n Matches = ets:lookup(Bag, {default, Name}),\n [begin\n elixir_errors:file_error(Meta, E, ?MODULE,\n {defs_with_defaults, Kind, Name, Arity, A})\n end || {_, A, D} <- Matches, A /= Arity, D /= 0, defaults_conflict(A, D, Arity, Defaults)].\n\ndefaults_conflict(A, D, Arity, Defaults) ->\n ((Arity >= (A - D)) andalso (Arity < A)) orelse\n ((A >= (Arity - Defaults)) andalso (A < Arity)).\n\nassert_no_aliases_name(Meta, '__aliases__', [Atom], #{file := File}) when is_atom(Atom) ->\n elixir_errors:file_error(Meta, File, ?MODULE, {no_alias, Atom});\nassert_no_aliases_name(_Meta, _Aliases, _Args, _S) ->\n ok.\n\nassert_valid_name(Meta, Kind, '__info__', [_], #{file := File}) ->\n elixir_errors:file_error(Meta, File, ?MODULE, {'__info__', Kind});\nassert_valid_name(Meta, Kind, 'module_info', [], #{file := File}) ->\n elixir_errors:file_error(Meta, File, ?MODULE, {module_info, Kind, 0});\nassert_valid_name(Meta, Kind, 'module_info', [_], #{file := File}) ->\n elixir_errors:file_error(Meta, File, ?MODULE, {module_info, Kind, 1});\nassert_valid_name(Meta, Kind, is_record, [_, _], #{file := File}) when Kind == defp; Kind == def ->\n elixir_errors:file_error(Meta, File, ?MODULE, {is_record, Kind});\nassert_valid_name(_Meta, _Kind, _Name, _Args, _S) ->\n ok.\n\n%% Format errors\n\nformat_error({function_head, Kind, {Name, Arity}}) ->\n io_lib:format(\"implementation not provided for predefined ~ts ~ts/~B\", [Kind, Name, Arity]);\n\nformat_error({no_module, {Kind, Name, Arity}}) ->\n io_lib:format(\"cannot define function outside module, invalid scope for ~ts ~ts/~B\", [Kind, Name, Arity]);\n\nformat_error({defs_with_defaults, Kind, Name, Arity, A}) when Arity > A ->\n io_lib:format(\"~ts ~ts/~B defaults conflicts with ~ts/~B\",\n [Kind, Name, Arity, Name, A]);\n\nformat_error({defs_with_defaults, Kind, Name, Arity, A}) when Arity < A ->\n io_lib:format(\"~ts ~ts/~B conflicts with defaults from ~ts/~B\",\n [Kind, Name, Arity, Name, A]);\n\nformat_error({duplicate_defaults, {Kind, Name, Arity, StoredMeta}}) ->\n io_lib:format(\n \"~ts ~ts/~B defines defaults multiple times. \"\n \"Elixir allows defaults to be declared once per definition. Instead of:\\n\"\n \"\\n\"\n \" def foo(:first_clause, b \\\\\\\\ :default) do ... end\\n\"\n \" def foo(:second_clause, b \\\\\\\\ :default) do ... end\\n\"\n \"\\n\"\n \"one should write:\\n\"\n \"\\n\"\n \" def foo(a, b \\\\\\\\ :default)\\n\"\n \" def foo(:first_clause, b) do ... end\\n\"\n \" def foo(:second_clause, b) do ... end\\n\"\n \"~ts\",\n [Kind, Name, Arity, maybe_stored_meta_line(StoredMeta)]);\n\nformat_error({mixed_defaults, {Kind, Name, Arity, StoredMeta}}) ->\n io_lib:format(\n \"~ts ~ts/~B has multiple clauses and also declares default values. \"\n \"In such cases, the default values should be defined in a header. Instead of:\\n\"\n \"\\n\"\n \" def foo(:first_clause, b \\\\\\\\ :default) do ... end\\n\"\n \" def foo(:second_clause, b) do ... end\\n\"\n \"\\n\"\n \"one should write:\\n\"\n \"\\n\"\n \" def foo(a, b \\\\\\\\ :default)\\n\"\n \" def foo(:first_clause, b) do ... end\\n\"\n \" def foo(:second_clause, b) do ... end\\n\"\n \"~ts\",\n [Kind, Name, Arity, maybe_stored_meta_line(StoredMeta)]);\n\nformat_error({ungrouped_name, {Kind, Name, Arity, OrigLine, OrigFile}}) ->\n io_lib:format(\"clauses with the same name should be grouped together, \\\"~ts ~ts/~B\\\" was previously defined (~ts:~B)\",\n [Kind, Name, Arity, OrigFile, OrigLine]);\n\nformat_error({ungrouped_arity, {Kind, Name, Arity, OrigLine, OrigFile}}) ->\n io_lib:format(\"clauses with the same name and arity (number of arguments) should be grouped together, \\\"~ts ~ts/~B\\\" was previously defined (~ts:~B)\",\n [Kind, Name, Arity, OrigFile, OrigLine]);\n\nformat_error({late_function_head, {Kind, Name, Arity}}) ->\n io_lib:format(\"function head for ~ts ~ts/~B must come at the top of its direct implementation. Instead of:\\n\"\n \"\\n\"\n \" def add(a, b), do: a + b\\n\"\n \" def add(a, b)\\n\"\n \"\\n\"\n \"one should write:\\n\"\n \"\\n\"\n \" def add(a, b)\\n\"\n \" def add(a, b), do: a + b\\n\",\n [Kind, Name, Arity]);\n\nformat_error({changed_kind, {Name, Arity, Previous, Current, OrigFile, OrigLine}}) ->\n OrigFileRelative = elixir_utils:relative_to_cwd(OrigFile),\n io_lib:format(\"~ts ~ts/~B already defined as ~ts in ~ts:~B\", [Current, Name, Arity, Previous, OrigFileRelative, OrigLine]);\n\nformat_error({no_alias, Atom}) ->\n io_lib:format(\"function names should start with lowercase characters or underscore, invalid name ~ts\", [Atom]);\n\nformat_error({invalid_def, Kind, NameAndArgs}) ->\n io_lib:format(\"invalid syntax in ~ts ~ts\", [Kind, 'Elixir.Macro':to_string(NameAndArgs)]);\n\nformat_error({invalid_function_head, Prefix}) ->\n atom_to_list(Prefix) ++ (\n \" are not allowed in function head, only variables and default arguments (using \\\\\\\\)\\n\"\n \"\\n\"\n \"If you did not intend to define a function head, make sure your function \"\n \"definition has the proper syntax by wrapping the arguments in parentheses \"\n \"and using the do keyword accordingly:\\n\\n\"\n \" def add(a, b), do: a + b\\n\\n\"\n \" def add(a, b) do\\n\"\n \" a + b\\n\"\n \" end\\n\");\n\nformat_error({'__info__', Kind}) ->\n io_lib:format(\"cannot define ~ts __info__/1 as it is automatically defined by Elixir\", [Kind]);\n\nformat_error({module_info, Kind, Arity}) ->\n io_lib:format(\"cannot define ~ts module_info/~B as it is automatically defined by Erlang\", [Kind, Arity]);\n\nformat_error({is_record, Kind}) ->\n io_lib:format(\"cannot define ~ts is_record/2 due to compatibility \"\n \"with the Erlang compiler (it is a known limitation)\", [Kind]).\n\nmaybe_stored_meta_line(StoredMeta) ->\n case lists:keyfind(line, 1, StoredMeta) of\n {line, Line} when Line > 0 ->\n \"\\nthe previous clause is defined on line \" ++ integer_to_list(Line) ++ \"\\n\";\n _ -> \"\"\n end.\n" }, { "path": "lib/elixir/src/elixir_dispatch.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Helpers related to dispatching to imports and references.\n%% This module access the information stored on the scope\n%% by elixir_import and therefore assumes it is normalized (ordsets)\n-module(elixir_dispatch).\n-export([dispatch_import/6, dispatch_require/7,\n require_function/5, import_function/4,\n expand_import/7, expand_require/6, check_deprecated/6,\n default_functions/0, default_macros/0, default_requires/0,\n find_import/4, find_imports/3, format_error/1, stop_generated/1]).\n-include(\"elixir.hrl\").\n-import(ordsets, [is_element/2]).\n-define(kernel, 'Elixir.Kernel').\n-define(application, 'Elixir.Application').\n\ndefault_functions() ->\n [{?kernel, elixir_imported_functions()}].\ndefault_macros() ->\n [{?kernel, elixir_imported_macros()}].\ndefault_requires() ->\n ['Elixir.Application', 'Elixir.Kernel'].\n\n%% This is used by elixir_quote. Note we don't record the\n%% import locally because at that point there is no\n%% ambiguity.\nfind_import(Meta, Name, Arity, E) ->\n Tuple = {Name, Arity},\n\n case find_import_by_name_arity(Meta, Tuple, [], E) of\n {function, Receiver} ->\n elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),\n Receiver;\n {macro, Receiver} ->\n elixir_env:trace({imported_macro, Meta, Receiver, Name, Arity}, E),\n Receiver;\n {ambiguous, _} = Ambiguous ->\n elixir_errors:file_error(Meta, E, ?MODULE, {import, Ambiguous, Name, Arity});\n _ ->\n false\n end.\n\nfind_imports(Meta, Name, E) ->\n Funs = ?key(E, functions),\n Macs = ?key(E, macros),\n\n Acc0 = #{},\n Acc1 = find_imports_by_name(Funs, Acc0, Name, Meta, E),\n Acc2 = find_imports_by_name(Macs, Acc1, Name, Meta, E),\n\n lists:sort(maps:to_list(Acc2)).\n\n%% Function retrieval\n\nimport_function(Meta, Name, Arity, E) ->\n Tuple = {Name, Arity},\n case find_import_by_name_arity(Meta, Tuple, [], E) of\n {function, Receiver} ->\n elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),\n elixir_import:record(Tuple, Receiver, ?key(E, module), ?key(E, function)),\n remote_function(Meta, Receiver, Name, Arity, E);\n {macro, _Receiver} ->\n false;\n {import, Receiver} ->\n require_function(Meta, Receiver, Name, Arity, E);\n {ambiguous, _} = Ambiguous ->\n elixir_errors:file_error(Meta, E, ?MODULE, {import, Ambiguous, Name, Arity});\n false ->\n case elixir_import:special_form(Name, Arity) of\n true ->\n false;\n false ->\n Function = ?key(E, function),\n\n case (Function /= nil) andalso (Function /= Tuple) andalso\n elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E) of\n false ->\n elixir_env:trace({local_function, Meta, Name, Arity}, E),\n {local, Name, Arity};\n _ ->\n false\n end\n end\n end.\n\nrequire_function(Meta, Receiver, Name, Arity, E) ->\n Required = is_element(Receiver, ?key(E, requires)),\n\n case is_macro(Name, Arity, Receiver, Required) of\n true -> false;\n false ->\n elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),\n remote_function(Meta, Receiver, Name, Arity, E)\n end.\n\nremote_function(Meta, Receiver, Name, Arity, E) ->\n check_deprecated(function, Meta, Receiver, Name, Arity, E),\n\n case elixir_rewrite:inline(Receiver, Name, Arity) of\n {AR, AN} -> {remote, AR, AN, Arity};\n false -> {remote, Receiver, Name, Arity}\n end.\n\n%% Dispatches\n\ndispatch_import(Meta, Name, Args, S, E, Callback) ->\n Arity = length(Args),\n\n AllowLocals =\n %% If we are inside a function, we support reading from locals.\n case E of\n #{function := {N, A}} when Name =/= N; Arity =/= A -> true;\n _ -> false\n end,\n\n case expand_import(Meta, Name, Arity, E, [], AllowLocals, true) of\n {macro, Receiver, Expander} ->\n check_deprecated(macro, Meta, Receiver, Name, Arity, E),\n Caller = {?line(Meta), S, E},\n expand_quoted(Meta, Receiver, Name, Arity, Expander(stop_generated(Args), Caller), S, E);\n {function, Receiver, NewName} ->\n case elixir_rewrite:inline(Receiver, NewName, Arity) of\n {AR, AN} ->\n Callback({AR, AN});\n false ->\n check_deprecated(function, Meta, Receiver, Name, Arity, E),\n Callback({Receiver, NewName})\n end;\n not_found ->\n Callback(local);\n Error ->\n elixir_errors:file_error(Meta, E, ?MODULE, {import, Error, Name, Arity})\n end.\n\nstop_generated(Args) ->\n lists:map(fun\n ({Call, Meta, Ctx}) when is_list(Meta) -> {Call, [{stop_generated, true} | Meta], Ctx};\n (Other) -> Other\n end, Args).\n\ndispatch_require(Meta, Receiver, Name, Args, S, E, Callback) when is_atom(Receiver) ->\n Arity = length(Args),\n\n case elixir_rewrite:inline(Receiver, Name, Arity) of\n {AR, AN} ->\n elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),\n Callback(AR, AN);\n false ->\n case expand_require(Meta, Receiver, Name, Arity, E, true) of\n {macro, Receiver, Expander} ->\n check_deprecated(macro, Meta, Receiver, Name, Arity, E),\n Caller = {?line(Meta), S, E},\n expand_quoted(Meta, Receiver, Name, Arity, Expander(Args, Caller), S, E);\n error ->\n check_deprecated(function, Meta, Receiver, Name, Arity, E),\n elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),\n Callback(Receiver, Name)\n end\n end;\n\ndispatch_require(_Meta, Receiver, Name, _Args, _S, _E, Callback) ->\n Callback(Receiver, Name).\n\n%% Macros expansion\n\nexpand_import(Meta, Name, Arity, E, Extra, AllowLocals, Trace) ->\n Tuple = {Name, Arity},\n Module = ?key(E, module),\n Dispatch = find_import_by_name_arity(Meta, Tuple, Extra, E),\n\n case Dispatch of\n {ambiguous, Ambiguous} ->\n {ambiguous, Ambiguous};\n\n {import, _} ->\n do_expand_import(Dispatch, Meta, Name, Arity, Module, E, Trace);\n\n _ ->\n Local = case AllowLocals of\n false -> false;\n true -> elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E);\n Fun when is_function(Fun, 0) -> Fun()\n end,\n\n case Dispatch of\n %% There is a local and an import. This is a conflict unless\n %% the receiver is the same as module (happens on bootstrap).\n {_, Receiver} when Local /= false, Receiver /= Module ->\n {conflict, Receiver};\n\n %% There is no local. Dispatch the import.\n _ when Local == false ->\n do_expand_import(Dispatch, Meta, Name, Arity, Module, E, Trace);\n\n %% Dispatch to the local.\n _ ->\n Trace andalso elixir_env:trace({local_macro, Meta, Name, Arity}, E),\n {macro, Module, expander_macro_fun(Meta, Local, Module, Name, E)}\n end\n end.\n\ndo_expand_import(Result, Meta, Name, Arity, Module, E, Trace) ->\n case Result of\n {function, Receiver} ->\n Trace andalso begin\n elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),\n elixir_import:record({Name, Arity}, Receiver, Module, ?key(E, function))\n end,\n {function, Receiver, Name};\n {macro, Receiver} ->\n Trace andalso begin\n elixir_env:trace({imported_macro, Meta, Receiver, Name, Arity}, E),\n elixir_import:record({Name, Arity}, Receiver, Module, ?key(E, function))\n end,\n {macro, Receiver, expander_macro_named(Meta, Receiver, Name, Arity, E)};\n {import, Receiver} ->\n case expand_require(true, Meta, Receiver, Name, Arity, E, Trace) of\n {macro, _, _} = Response -> Response;\n error ->\n Trace andalso elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),\n {function, Receiver, Name}\n end;\n false when Module == ?kernel ->\n case elixir_rewrite:inline(Module, Name, Arity) of\n {AR, AN} -> {function, AR, AN};\n false -> not_found\n end;\n false ->\n not_found\n end.\n\nexpand_require(Meta, Receiver, Name, Arity, E, Trace) ->\n Required = (Receiver == ?key(E, module))\n orelse (lists:keyfind(required, 1, Meta) == {required, true})\n orelse is_element(Receiver, ?key(E, requires)),\n\n expand_require(Required, Meta, Receiver, Name, Arity, E, Trace).\n\nexpand_require(Required, Meta, Receiver, Name, Arity, E, Trace) ->\n case is_macro(Name, Arity, Receiver, Required) of\n true ->\n Trace andalso elixir_env:trace({remote_macro, Meta, Receiver, Name, Arity}, E),\n {macro, Receiver, expander_macro_named(Meta, Receiver, Name, Arity, E)};\n false ->\n error\n end.\n\n%% Expansion helpers\n\nexpander_macro_fun(Meta, Fun, Receiver, Name, E) ->\n fun(Args, Caller) -> expand_macro_fun(Meta, Fun, Receiver, Name, Args, Caller, E) end.\n\nexpander_macro_named(Meta, Receiver, Name, Arity, E) ->\n ProperName = elixir_utils:macro_name(Name),\n ProperArity = Arity + 1,\n Fun = fun Receiver:ProperName/ProperArity,\n fun(Args, Caller) -> expand_macro_fun(Meta, Fun, Receiver, Name, Args, Caller, E) end.\n\nexpand_macro_fun(Meta, Fun, Receiver, Name, Args, Caller, E) ->\n try\n apply(Fun, [Caller | Args])\n catch\n Kind:Reason:Stacktrace ->\n Arity = length(Args),\n MFA = {Receiver, elixir_utils:macro_name(Name), Arity+1},\n Info = [{Receiver, Name, Arity, [{file, \"expanding macro\"}]}, caller(?line(Meta), E)],\n erlang:raise(Kind, Reason, prune_stacktrace(Stacktrace, MFA, Info, {ok, Caller}))\n end.\n\nexpand_quoted(Meta, Receiver, Name, Arity, Quoted, S, E) ->\n Next = elixir_module:next_counter(?key(E, module)),\n\n try\n ToExpand = elixir_quote:linify_with_context_counter(Meta, {Receiver, Next}, Quoted),\n elixir_expand:expand(ToExpand, S, E)\n catch\n Kind:Reason:Stacktrace ->\n MFA = {Receiver, elixir_utils:macro_name(Name), Arity+1},\n Info = [{Receiver, Name, Arity, [{file, \"expanding macro\"}]}, caller(?line(Meta), E)],\n erlang:raise(Kind, Reason, prune_stacktrace(Stacktrace, MFA, Info, error))\n end.\n\ncaller(Line, E) ->\n elixir_utils:caller(Line, ?key(E, file), ?key(E, module), ?key(E, function)).\n\n%% Helpers\n\nfind_imports_by_name([{Mod, Imports} | ModImports], Acc, Name, Meta, E) ->\n NewAcc = find_imports_by_name(Name, Imports, Acc, Mod, Meta, E),\n find_imports_by_name(ModImports, NewAcc, Name, Meta, E);\nfind_imports_by_name([], Acc, _Name, _Meta, _E) ->\n Acc.\n\nfind_imports_by_name(Name, [{Name, Arity} | Imports], Acc, Mod, Meta, E) ->\n case Acc of\n #{Arity := OtherMod} ->\n Error = {import, {ambiguous, [Mod, OtherMod]}, Name, Arity},\n elixir_errors:file_error(Meta, E, ?MODULE, Error);\n\n #{} ->\n find_imports_by_name(Name, Imports, Acc#{Arity => Mod}, Mod, Meta, E)\n end;\nfind_imports_by_name(Name, [{ImportName, _} | Imports], Acc, Mod, Meta, E) when Name > ImportName ->\n find_imports_by_name(Name, Imports, Acc, Mod, Meta, E);\nfind_imports_by_name(_Name, _Imports, Acc, _Mod, _Meta, _E) ->\n Acc.\n\nfind_import_by_name_arity(Meta, {_Name, Arity} = Tuple, Extra, E) ->\n case is_import(Meta, Arity) of\n {import, _} = Import ->\n Import;\n false ->\n Funs = ?key(E, functions),\n Macs = Extra ++ ?key(E, macros),\n FunMatch = find_import_by_name_arity(Tuple, Funs),\n MacMatch = find_import_by_name_arity(Tuple, Macs),\n\n case {FunMatch, MacMatch} of\n {[], [Receiver]} -> {macro, Receiver};\n {[Receiver], []} -> {function, Receiver};\n {[], []} -> false;\n _ -> {ambiguous, FunMatch ++ MacMatch}\n end\n end.\n\nfind_import_by_name_arity(Tuple, List) ->\n [Receiver || {Receiver, Set} <- List, is_element(Tuple, Set)].\n\nis_import(Meta, Arity) ->\n case lists:keyfind(imports, 1, Meta) of\n {imports, [_ | _] = Imports} ->\n case lists:keyfind(context, 1, Meta) of\n {context, _} ->\n case lists:keyfind(Arity, 1, Imports) of\n {Arity, Receiver} -> {import, Receiver};\n false -> false\n end;\n false -> false\n end;\n _ -> false\n end.\n\n% %% We've reached the macro wrapper fun, skip it with the rest\nprune_stacktrace([{_, _, [Caller | _], _} | _], _MFA, Info, {ok, Caller}) ->\n Info;\n%% We've reached the invoked macro, skip it\nprune_stacktrace([{M, F, A, _} | _], {M, F, A}, Info, _E) ->\n Info;\n%% We've reached the elixir_dispatch internals, skip it with the rest\nprune_stacktrace([{Mod, _, _, _} | _], _MFA, Info, _E) when Mod == elixir_dispatch; Mod == elixir_exp ->\n Info;\nprune_stacktrace([H | T], MFA, Info, E) ->\n [H | prune_stacktrace(T, MFA, Info, E)];\nprune_stacktrace([], _MFA, Info, _E) ->\n Info.\n\n%% ERROR HANDLING\n\nformat_error({import, {conflict, Receiver}, Name, Arity}) ->\n io_lib:format(\"call to local macro ~ts/~B conflicts with imported ~ts.~ts/~B, \"\n \"please rename the local macro or remove the conflicting import\",\n [Name, Arity, elixir_aliases:inspect(Receiver), Name, Arity]);\nformat_error({import, {ambiguous, [Mod1, Mod2 | _]}, Name, Arity}) ->\n io_lib:format(\"function ~ts/~B imported from both ~ts and ~ts, call is ambiguous\",\n [Name, Arity, elixir_aliases:inspect(Mod1), elixir_aliases:inspect(Mod2)]);\nformat_error({compile_env, Name, Arity}) ->\n io_lib:format(\"Application.~s/~B is discouraged in the module body, use Application.compile_env/3 instead\", [Name, Arity]);\nformat_error({deprecated, Mod, '__using__', 1, Message}) ->\n io_lib:format(\"use ~s is deprecated. ~s\", [elixir_aliases:inspect(Mod), Message]);\nformat_error({deprecated, Mod, Fun, Arity, Message}) ->\n io_lib:format(\"~s.~s/~B is deprecated. ~s\",[elixir_aliases:inspect(Mod), Fun, Arity, Message]).\n\n%% INTROSPECTION\n\nis_macro(_Name, _Arity, _Module, false) ->\n false;\nis_macro(Name, Arity, Receiver, true) ->\n try Receiver:'__info__'(macros) of\n Macros -> is_element({Name, Arity}, Macros)\n catch\n error:_ -> false\n end.\n\n%% Deprecations checks only happen at the module body,\n%% so in there we can try to at least load the module.\nget_deprecations(Receiver) ->\n case code:ensure_loaded(Receiver) of\n {module, Receiver} -> get_info(Receiver, deprecated);\n _ -> []\n end.\n\nget_info(Receiver, Key) ->\n case erlang:function_exported(Receiver, '__info__', 1) of\n true ->\n try\n Receiver:'__info__'(Key)\n catch\n error:_ -> []\n end;\n false ->\n []\n end.\n\nelixir_imported_functions() ->\n try\n ?kernel:'__info__'(functions)\n catch\n error:undef -> []\n end.\n\nelixir_imported_macros() ->\n try\n ?kernel:'__info__'(macros)\n catch\n error:undef -> []\n end.\n\ncheck_deprecated(_, _, erlang, _, _, _) -> ok;\ncheck_deprecated(_, _, elixir_def, _, _, _) -> ok;\ncheck_deprecated(_, _, elixir_module, _, _, _) -> ok;\ncheck_deprecated(_, _, ?kernel, _, _, _) -> ok;\ncheck_deprecated(Kind, Meta, ?application, Name, Arity, E) ->\n case E of\n #{module := Module, function := nil}\n when (Module /= nil) or (Kind == macro), (Name == get_env) orelse (Name == fetch_env) orelse (Name == 'fetch_env!') ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {compile_env, Name, Arity});\n\n _ ->\n ok\n end;\ncheck_deprecated(Kind, Meta, Receiver, Name, Arity, E) ->\n %% Any compile time behavior cannot be verified by the runtime group pass.\n case ((?key(E, function) == nil) or (Kind == macro)) andalso get_deprecations(Receiver) of\n [_ | _] = Deprecations ->\n case lists:keyfind({Name, Arity}, 1, Deprecations) of\n {_, Message} ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {deprecated, Receiver, Name, Arity, Message});\n\n false ->\n false\n end;\n\n _ ->\n ok\n end.\n" }, { "path": "lib/elixir/src/elixir_env.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_env).\n-include(\"elixir.hrl\").\n-export([\n new/0, to_caller/1, merge_vars/2, with_vars/2, reset_vars/1, env_to_ex/1,\n reset_unused_vars/1, check_unused_vars/2, merge_and_check_unused_vars/3, calculate_span/2,\n trace/2, format_error/1,\n reset_read/2, prepare_write/1, prepare_write/2, close_write/2\n]).\n\nnew() ->\n #{\n '__struct__' => 'Elixir.Macro.Env',\n module => nil, %% the current module\n file => <<\"nofile\">>, %% the current filename\n line => 1, %% the current line\n function => nil, %% the current function\n context => nil, %% can be match, guard or nil\n aliases => [], %% a list of aliases by new -> old names\n requires => elixir_dispatch:default_requires(), %% a set with modules required\n functions => elixir_dispatch:default_functions(), %% a list with functions imported from module\n macros => elixir_dispatch:default_macros(), %% a list with macros imported from module\n macro_aliases => [], %% keep aliases defined inside a macro\n context_modules => [], %% modules defined in the current context\n versioned_vars => #{}, %% a map of vars with their latest versions\n lexical_tracker => nil, %% lexical tracker PID\n tracers => [] %% available compilation tracers\n }.\n\ntrace(Event, #{tracers := Tracers} = E) ->\n [ok = Tracer:trace(Event, E) || Tracer <- Tracers],\n ok.\n\nto_caller({Line, #elixir_ex{vars={Read, _}}, Env}) ->\n Env#{line := Line, versioned_vars := Read};\nto_caller(#{'__struct__' := 'Elixir.Macro.Env'} = Env) ->\n Env.\n\nwith_vars(Env, Vars) when is_list(Vars) ->\n {ReversedVars, _} =\n lists:foldl(fun(Var, {Acc, I}) -> {[{Var, I} | Acc], I + 1} end, {[], 0}, Vars),\n Env#{versioned_vars := maps:from_list(ReversedVars)};\nwith_vars(Env, #{} = Vars) ->\n Env#{versioned_vars := Vars}.\n\nreset_vars(Env) ->\n Env#{versioned_vars := #{}}.\n\n%% CONVERSIONS\n\nenv_to_ex(#{context := match, versioned_vars := Vars}) ->\n Counter = map_size(Vars),\n #elixir_ex{\n prematch={Vars, {#{}, []}, Counter},\n vars={Vars, false},\n unused={#{}, Counter}\n };\nenv_to_ex(#{versioned_vars := Vars}) ->\n #elixir_ex{\n vars={Vars, false},\n unused={#{}, map_size(Vars)}\n }.\n\n%% VAR HANDLING\n\nreset_read(#elixir_ex{vars={_, Write}} = S, #elixir_ex{vars={Read, _}}) ->\n S#elixir_ex{vars={Read, Write}}.\n\nprepare_write(S, #{context := nil}) ->\n prepare_write(S);\nprepare_write(S, _) ->\n S.\n\nprepare_write(#elixir_ex{vars={Read, _}} = S) ->\n S#elixir_ex{vars={Read, Read}}.\n\nclose_write(#elixir_ex{vars={_Read, Write}} = S, #elixir_ex{vars={_, false}}) ->\n S#elixir_ex{vars={Write, false}};\nclose_write(#elixir_ex{vars={_Read, Write}} = S, #elixir_ex{vars={_, UpperWrite}}) ->\n S#elixir_ex{vars={Write, merge_vars(UpperWrite, Write)}}.\n\nmerge_vars(V, V) ->\n V;\nmerge_vars(V1, V2) ->\n maps:fold(fun(K, M2, Acc) ->\n case Acc of\n #{K := M1} when M1 >= M2 -> Acc;\n _ -> Acc#{K => M2}\n end\n end, V1, V2).\n\n%% UNUSED VARS\n\nreset_unused_vars(#elixir_ex{unused={_Unused, Version}} = S) ->\n S#elixir_ex{unused={#{}, Version}}.\n\ncheck_unused_vars(#elixir_ex{unused={Unused, _Version}}, E) ->\n [elixir_errors:file_warn(calculate_span(Meta, Name), E, ?MODULE, {unused_var, Name, Overridden}) ||\n {{{Name, _Kind}, _Count}, {Meta, Overridden}} <- maps:to_list(Unused), is_unused_var(Name)],\n E.\n\ncalculate_span(Meta, Name) ->\n case lists:keyfind(column, 1, Meta) of\n {column, Column} ->\n [{span, {?line(Meta), Column + string:length(atom_to_binary(Name))}} | Meta];\n\n _ ->\n Meta\n end.\n\nmerge_and_check_unused_vars(S, #elixir_ex{vars={Read, Write}, unused={Unused, _Version}}, E) ->\n #elixir_ex{unused={ClauseUnused, Version}} = S,\n NewUnused = merge_and_check_unused_vars(Read, Unused, ClauseUnused, E),\n S#elixir_ex{unused={NewUnused, Version}, vars={Read, Write}}.\n\nmerge_and_check_unused_vars(Current, Unused, ClauseUnused, E) ->\n maps:fold(fun\n ({Var, Count} = Key, false, Acc) ->\n case Current of\n #{Var := CurrentCount} when Count =< CurrentCount ->\n %% The parent knows it, so we have to propagate it was used up.\n Acc#{Key => false};\n\n #{} ->\n Acc\n end;\n\n ({{Name, _Kind}, _Count}, {Meta, Overridden}, Acc) ->\n case is_unused_var(Name) of\n true ->\n Warn = {unused_var, Name, Overridden},\n elixir_errors:file_warn(Meta, E, ?MODULE, Warn);\n\n false ->\n ok\n end,\n\n Acc\n end, Unused, ClauseUnused).\n\nis_unused_var(Name) ->\n case atom_to_list(Name) of\n \"_\" ++ Rest -> is_compiler_var(Rest);\n _ -> true\n end.\n\nis_compiler_var([$_]) -> true;\nis_compiler_var([Var | Rest]) when Var =:= $_; Var >= $A, Var =< $Z -> is_compiler_var(Rest);\nis_compiler_var(_) -> false.\n\nformat_error({unused_var, Name, Overridden}) ->\n case atom_to_list(Name) of\n \"_\" ++ _ ->\n io_lib:format(\"unknown compiler variable \\\"~ts\\\" (expected one of __MODULE__, __ENV__, __DIR__, __CALLER__, __STACKTRACE__)\", [Name]);\n \"&\" ++ _ ->\n io_lib:format(\"variable \\\"~ts\\\" is unused (this might happen when using a capture argument as a pattern)\", [Name]);\n _ when Overridden ->\n io_lib:format(\"variable \\\"~ts\\\" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)\", [Name]);\n _ ->\n io_lib:format(\"variable \\\"~ts\\\" is unused (if the variable is not meant to be used, prefix it with an underscore)\", [Name])\n end.\n" }, { "path": "lib/elixir/src/elixir_erl.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Compiler backend to Erlang.\n\n-module(elixir_erl).\n-export([elixir_to_erl/1, elixir_to_erl/2, definition_to_anonymous/5, compile/2, consolidate/4,\n get_ann/1, debug_info/4, scope/2, checker_chunk/2, checker_version/0, format_error/1]).\n-include(\"elixir.hrl\").\n-define(typespecs, 'Elixir.Kernel.Typespec').\n\nchecker_version() ->\n elixir_checker_v7.\n\n%% debug_info callback\n\ndebug_info(elixir_v1, _Module, none, _Opts) ->\n {error, missing};\ndebug_info(elixir_v1, _Module, {elixir_v1, Map, _Specs}, _Opts) ->\n {ok, Map};\ndebug_info(erlang_v1, _Module, {elixir_v1, Map, Specs}, _Opts) ->\n {Prefix, Forms, _, _, _} = dynamic_form(Map, nil),\n {ok, Prefix ++ Specs ++ Forms};\ndebug_info(core_v1, _Module, {elixir_v1, Map, Specs}, Opts) ->\n {Prefix, Forms, _, _, _} = dynamic_form(Map, nil),\n #{compile_opts := CompileOpts} = Map,\n AllOpts = CompileOpts ++ Opts,\n\n %% Do not rely on elixir_erl_compiler because we don't warn\n %% warnings nor the other functionality provided there.\n case elixir_erl_compiler:erl_to_core(Prefix ++ Specs ++ Forms, AllOpts) of\n {ok, CoreForms, _} ->\n try compile:noenv_forms(CoreForms, [no_spawn_compiler_process, from_core, to_core, return | AllOpts]) of\n {ok, _, Core, _} -> {ok, Core};\n _What -> {error, failed_conversion}\n catch\n error:_ -> {error, failed_conversion}\n end;\n _ ->\n {error, failed_conversion}\n end;\ndebug_info(_, _, _, _) ->\n {error, unknown_format}.\n\n%% Builds Erlang AST annotation.\n\nget_ann(Opts) when is_list(Opts) ->\n get_ann(Opts, false, 0, undefined).\n\nget_ann([{generated, true} | T], _, Line, Column) -> get_ann(T, true, Line, Column);\nget_ann([{line, Line} | T], Gen, _, Column) when is_integer(Line) -> get_ann(T, Gen, Line, Column);\nget_ann([{column, Column} | T], Gen, Line, _) when is_integer(Column) -> get_ann(T, Gen, Line, Column);\nget_ann([_ | T], Gen, Line, Column) -> get_ann(T, Gen, Line, Column);\nget_ann([], Gen, Line, undefined) -> erl_anno:set_generated(Gen, erl_anno:new(Line));\nget_ann([], Gen, Line, Column) -> erl_anno:set_generated(Gen, erl_anno:new({Line, Column})).\n\n%% Converts an Elixir definition to an anonymous function.\n\ndefinition_to_anonymous(Kind, Meta, Clauses, LocalHandler, ExternalHandler) ->\n ErlClauses = [translate_clause(Kind, 0, Clause, true) || Clause <- Clauses],\n Fun = {'fun', ?ann(Meta), {clauses, ErlClauses}},\n {value, Result, _Binding} = erl_eval:expr(Fun, [], LocalHandler, ExternalHandler),\n Result.\n\n%% Converts Elixir quoted literals to Erlang AST.\nelixir_to_erl(Tree) ->\n elixir_to_erl(Tree, erl_anno:new(0)).\n\nelixir_to_erl(Tree, Ann) when is_tuple(Tree) ->\n {tuple, Ann, [elixir_to_erl(X, Ann) || X <- tuple_to_list(Tree)]};\nelixir_to_erl([], Ann) ->\n {nil, Ann};\nelixir_to_erl(<<>>, Ann) ->\n {bin, Ann, []};\nelixir_to_erl(#{} = Map, Ann) ->\n Assocs = [{map_field_assoc, Ann, elixir_to_erl(K, Ann), elixir_to_erl(V, Ann)}\n || {K, V} <- lists:sort(maps:to_list(Map))],\n {map, Ann, Assocs};\nelixir_to_erl(Tree, Ann) when is_list(Tree) ->\n elixir_to_erl_cons(Tree, Ann);\nelixir_to_erl(Tree, Ann) when is_atom(Tree) ->\n {atom, Ann, Tree};\nelixir_to_erl(Tree, Ann) when is_integer(Tree) ->\n {integer, Ann, Tree};\nelixir_to_erl(Tree, Ann) when is_float(Tree), Tree == 0.0 ->\n % 0.0 needs to be rewritten as the AST for +0.0 in matches\n Op =\n case <> of\n <<1:1,_:63>> -> '-';\n _ -> '+'\n end,\n {op, Ann, Op, {float, Ann, 0.0}};\nelixir_to_erl(Tree, Ann) when is_float(Tree) ->\n {float, Ann, Tree};\nelixir_to_erl(Tree, Ann) when is_binary(Tree) ->\n %% Note that our binaries are UTF-8 encoded and we are converting\n %% to a list using binary_to_list. The reason for this is that Erlang\n %% considers a string in a binary to be encoded in latin1, so the bytes\n %% are not changed in any fashion.\n {bin, Ann, [{bin_element, Ann, {string, Ann, binary_to_list(Tree)}, default, default}]};\nelixir_to_erl(Tree, Ann) when is_bitstring(Tree) ->\n Segments = [elixir_to_erl_bitstring_segment(X, Ann) || X <- bitstring_to_list(Tree)],\n {bin, Ann, Segments};\nelixir_to_erl(Tree, Ann) when is_function(Tree) ->\n case (erlang:fun_info(Tree, type) == {type, external}) andalso\n (erlang:fun_info(Tree, env) == {env, []}) of\n true ->\n {module, Module} = erlang:fun_info(Tree, module),\n {name, Name} = erlang:fun_info(Tree, name),\n {arity, Arity} = erlang:fun_info(Tree, arity),\n {'fun', Ann, {function, {atom, Ann, Module}, {atom, Ann, Name}, {integer, Ann, Arity}}};\n false ->\n error(badarg, [Tree, Ann])\n end;\nelixir_to_erl(Tree, Ann) when is_pid(Tree); is_port(Tree); is_reference(Tree) ->\n ?remote(Ann, erlang, binary_to_term, [elixir_to_erl(term_to_binary(Tree), Ann)]);\nelixir_to_erl(Tree, Ann) ->\n error(badarg, [Tree, Ann]).\n\nelixir_to_erl_cons([H | T], Ann) -> {cons, Ann, elixir_to_erl(H, Ann), elixir_to_erl_cons(T, Ann)};\nelixir_to_erl_cons(T, Ann) -> elixir_to_erl(T, Ann).\n\nelixir_to_erl_bitstring_segment(Int, Ann) when is_integer(Int) ->\n {bin_element, Ann, {integer, Ann, Int}, default, [integer]};\nelixir_to_erl_bitstring_segment(Rest, Ann) when is_bitstring(Rest) ->\n Size = bit_size(Rest),\n <> = Rest,\n {bin_element, Ann, {integer, Ann, Int}, {integer, Ann, Size}, [integer]}.\n\n%% Returns a scope for translation.\n\nscope(_Meta, ExpandCaptures) ->\n #elixir_erl{expand_captures=ExpandCaptures}.\n\n%% Static compilation hook, used in protocol consolidation\n\nconsolidate(Map, Checker, TypeSpecs, DocsChunk) ->\n {Prefix, Forms, _Def, _Defmacro, _Macros} = dynamic_form(Map, nil),\n CheckerChunk = checker_chunk(Checker, chunk_opts(Map)),\n load_form(Map, Prefix, Forms, TypeSpecs, DocsChunk ++ CheckerChunk).\n\n%% Used for updating type checking chunks in Elixir\n\nchecker_chunk(nil, _ChunkOpts) ->\n [];\nchecker_chunk(Contents, ChunkOpts) ->\n [{<<\"ExCk\">>, term_to_binary({checker_version(), Contents}, ChunkOpts)}].\n\n%% Dynamic compilation hook, used in regular compiler\n\ncompile(#{module := Module, anno := Anno} = BaseMap, Signatures) ->\n Map =\n case elixir_erl_compiler:env_compiler_options() of\n [] -> BaseMap;\n EnvOptions -> BaseMap#{compile_opts := ?key(BaseMap, compile_opts) ++ EnvOptions}\n end,\n\n {Set, Bag} = elixir_module:data_tables(Module),\n\n TranslatedTypespecs =\n case elixir_config:is_bootstrap() andalso\n (code:ensure_loaded(?typespecs) /= {module, ?typespecs}) of\n true -> {[], [], [], [], []};\n false -> ?typespecs:translate_typespecs_for_module(Set, Bag)\n end,\n\n MD5 = ets:lookup_element(Set, exports_md5, 2),\n {Prefix, Forms, Def, Defmacro, Macros} = dynamic_form(Map, MD5),\n {Types, Callbacks, TypeSpecs} = typespecs_form(Map, TranslatedTypespecs, Macros),\n\n ChunkOpts = chunk_opts(Map),\n DocsChunk = docs_chunk(Map, Set, Module, Anno, Def, Defmacro, Types, Callbacks, ChunkOpts),\n CheckerChunk = checker_chunk(Map, Def, Signatures, ChunkOpts),\n load_form(Map, Prefix, Forms, TypeSpecs, DocsChunk ++ CheckerChunk).\n\nchunk_opts(Map) ->\n case lists:member(deterministic, ?key(Map, compile_opts)) of\n true -> [deterministic];\n false -> []\n end.\n\ndynamic_form(#{module := Module, relative_file := RelativeFile,\n attributes := Attributes, definitions := Definitions, unreachable := Unreachable,\n deprecated := Deprecated, compile_opts := Opts} = Map, MD5) ->\n %% TODO: Match on anno directly in Elixir v1.22+\n Line = case Map of\n #{anno := AnnoValue} -> erl_anno:line(AnnoValue);\n #{line := LineValue} -> LineValue\n end,\n\n {Def, Defmacro, Macros, Exports, Functions} =\n split_definition(Definitions, Unreachable, Line, [], [], [], [], {[], []}),\n\n FilteredOpts = proplists:delete(debug_info, proplists:delete(no_warn_undefined, Opts)),\n Location = {elixir_utils:characters_to_list(RelativeFile), Line},\n\n Prefix = [{attribute, Line, file, Location},\n {attribute, Line, module, Module},\n {attribute, Line, compile, [no_auto_import | FilteredOpts]}],\n\n Struct = maps:get(struct, Map, nil),\n Forms0 = functions_form(Line, Module, Def, Defmacro, Exports, Functions, Deprecated, Struct, MD5),\n Forms1 = attributes_form(Line, Attributes, Forms0),\n {Prefix, Forms1, Def, Defmacro, Macros}.\n\n% Definitions\n\nsplit_definition([{Tuple, Kind, Meta, Clauses} | T], Unreachable, Line,\n Def, Defmacro, Macros, Exports, Functions) ->\n case lists:member(Tuple, Unreachable) of\n false ->\n split_definition(Tuple, Kind, Meta, Clauses, T, Unreachable, Line,\n Def, Defmacro, Macros, Exports, Functions);\n true ->\n split_definition(T, Unreachable, Line, Def, Defmacro, Macros, Exports, Functions)\n end;\n\nsplit_definition([], _Unreachable, _Line, Def, Defmacro, Macros, Exports, {Head, Tail}) ->\n {lists:sort(Def), lists:sort(Defmacro), Macros, Exports, Head ++ Tail}.\n\nsplit_definition(Tuple, def, Meta, Clauses, T, Unreachable, Line,\n Def, Defmacro, Macros, Exports, Functions) ->\n {_, _, N, A, _} = Entry = translate_definition(def, Line, Meta, Tuple, Clauses),\n split_definition(T, Unreachable, Line, [{Tuple, Meta} | Def], Defmacro, Macros, [{N, A} | Exports],\n add_definition(Meta, Entry, Functions));\n\nsplit_definition(Tuple, defp, Meta, Clauses, T, Unreachable, Line,\n Def, Defmacro, Macros, Exports, Functions) ->\n Entry = translate_definition(defp, Line, Meta, Tuple, Clauses),\n split_definition(T, Unreachable, Line, Def, Defmacro, Macros, Exports,\n add_definition(Meta, Entry, Functions));\n\nsplit_definition(Tuple, defmacro, Meta, Clauses, T, Unreachable, Line,\n Def, Defmacro, Macros, Exports, Functions) ->\n {_, _, N, A, _} = Entry = translate_definition(defmacro, Line, Meta, Tuple, Clauses),\n split_definition(T, Unreachable, Line, Def, [{Tuple, Meta} | Defmacro], [Tuple | Macros], [{N, A} | Exports],\n add_definition(Meta, Entry, Functions));\n\nsplit_definition(Tuple, defmacrop, Meta, Clauses, T, Unreachable, Line,\n Def, Defmacro, Macros, Exports, Functions) ->\n Entry = translate_definition(defmacro, Line, Meta, Tuple, Clauses),\n split_definition(T, Unreachable, Line, Def, Defmacro, [Tuple | Macros], Exports,\n add_definition(Meta, Entry, Functions)).\n\nadd_definition(Meta, Body, {Head, Tail}) ->\n case lists:keyfind(file, 1, Meta) of\n {file, {F, L}} ->\n %% Erlang's epp attempts to perform offsetting when generated is set to true\n %% and that causes cover to fail when processing modules. Therefore we never\n %% pass the generated annotation forward for file attributes. The function\n %% will still be marked as generated though if that's the case.\n FileMeta = erl_anno:set_generated(false, ?ann(Meta)),\n Attr = {attribute, FileMeta, file, {elixir_utils:characters_to_list(F), L}},\n {Head, [Attr, Body | Tail]};\n false ->\n {[Body | Head], Tail}\n end.\n\ntranslate_definition(Kind, Line, Meta, {Name, Arity}, Clauses) ->\n ErlClauses = [translate_clause(Kind, Line, Clause, false) || Clause <- Clauses],\n\n case is_macro(Kind) of\n true -> {function, ?ann(Meta), elixir_utils:macro_name(Name), Arity + 1, ErlClauses};\n false -> {function, ?ann(Meta), Name, Arity, ErlClauses}\n end.\n\ntranslate_clause(Kind, Line, {Meta, Args, Guards, Body}, ExpandCaptures) ->\n S = scope(Meta, ExpandCaptures),\n\n %% If the line matches the module line, then it is most likely an\n %% auto-generated function and we don't want to track its contents.\n Ann =\n case ?line(Meta) of\n Line -> erl_anno:set_generated(true, erl_anno:new(0));\n _ -> ?ann(Meta)\n end,\n\n {TClause, TS} =\n elixir_erl_clauses:clause(Ann, fun elixir_erl_pass:translate_args/3, Args, Body, Guards, S),\n\n case is_macro(Kind) of\n true ->\n FArgs = {var, Ann, '_@CALLER'},\n MClause = setelement(3, TClause, [FArgs | element(3, TClause)]),\n\n case TS#elixir_erl.caller of\n true ->\n FBody = {'match', Ann,\n {'var', Ann, '__CALLER__'},\n ?remote(Ann, elixir_env, to_caller, [{var, Ann, '_@CALLER'}])\n },\n setelement(5, MClause, [FBody | element(5, TClause)]);\n false ->\n MClause\n end;\n false ->\n TClause\n end.\n\nis_macro(defmacro) -> true;\nis_macro(defmacrop) -> true;\nis_macro(_) -> false.\n\n% Functions\n\nfunctions_form(Line, Module, Def, Defmacro, Exports, Body, Deprecated, Struct, MD5) ->\n {Spec, Info} = add_info_function(Line, Module, Def, Defmacro, Deprecated, Struct, MD5),\n [{attribute, Line, export, lists:usort([{'__info__', 1} | Exports])}, Spec, Info | Body].\n\nadd_info_function(Line, Module, Def, Defmacro, Deprecated, Struct, MD5) ->\n DefNA = [NA || {NA, _Meta} <- Def],\n DefmacroNA = [NA || {NA, _Meta} <- Defmacro],\n\n AllowedAttrs = [attributes, compile, functions, macros, md5, exports_md5, module, deprecated, struct],\n AllowedArgs = lists:map(fun(Atom) -> {atom, Line, Atom} end, AllowedAttrs),\n\n Spec =\n {attribute, Line, spec, {{'__info__', 1},\n [{type, Line, 'fun', [\n {type, Line, product, [\n {type, Line, union, AllowedArgs}\n ]},\n {type, Line, any, []}\n ]}]\n }},\n\n Info =\n {function, 0, '__info__', 1, [\n get_module_info(Module),\n functions_info(DefNA),\n macros_info(DefmacroNA),\n struct_info(Struct),\n exports_md5_info(MD5, DefNA, DefmacroNA, Struct),\n get_module_info(Module, attributes),\n get_module_info(Module, compile),\n get_module_info(Module, md5),\n deprecated_info(Deprecated)\n ]},\n\n {Spec, Info}.\n\nget_module_info(Module) ->\n {clause, 0, [{atom, 0, module}], [], [{atom, 0, Module}]}.\n\nexports_md5_info(MD5Attr, Def, Defmacro, Struct) ->\n MD5 = if\n is_binary(MD5Attr) -> MD5Attr;\n MD5Attr =:= nil -> elixir_module:exports_md5(Def, Defmacro, Struct)\n end,\n {clause, 0, [{atom, 0, exports_md5}], [], [elixir_to_erl(MD5)]}.\n\nfunctions_info(Def) ->\n {clause, 0, [{atom, 0, functions}], [], [elixir_to_erl(Def)]}.\n\nmacros_info(Defmacro) ->\n {clause, 0, [{atom, 0, macros}], [], [elixir_to_erl(Defmacro)]}.\n\nstruct_info(nil) ->\n {clause, 0, [{atom, 0, struct}], [], [{atom, 0, nil}]};\nstruct_info(Fields) ->\n {clause, 0, [{atom, 0, struct}], [], [elixir_to_erl(Fields)]}.\n\nget_module_info(Module, Key) ->\n Call = ?remote(0, erlang, get_module_info, [{atom, 0, Module}, {var, 0, 'Key'}]),\n {clause, 0, [{match, 0, {var, 0, 'Key'}, {atom, 0, Key}}], [], [Call]}.\n\ndeprecated_info(Deprecated) ->\n {clause, 0, [{atom, 0, deprecated}], [], [elixir_to_erl(Deprecated)]}.\n\n% Typespecs\n\ntypespecs_form(Map, TranslatedTypespecs, MacroNames) ->\n {Types, Specs, Callbacks, MacroCallbacks, OptionalCallbacks} = TranslatedTypespecs,\n\n AllCallbacks = Callbacks ++ MacroCallbacks,\n MacroCallbackNames = [NameArity || {_, NameArity, _, _} <- MacroCallbacks],\n validate_behaviour_info_and_attributes(Map, AllCallbacks),\n validate_optional_callbacks(Map, AllCallbacks, OptionalCallbacks),\n\n Forms0 = [],\n Forms1 = types_form(Types, Forms0),\n Forms2 = callspecs_form(spec, Specs, [], MacroNames, Forms1, Map),\n Forms3 = callspecs_form(callback, AllCallbacks, OptionalCallbacks, MacroCallbackNames, Forms2, Map),\n\n AllCallbacksWithoutSpecs = usort_callbacks([\n {{Kind, Name, Arity}, Meta} || {Kind, {Name, Arity}, Meta, _Spec} <- AllCallbacks\n ]),\n\n {Types, AllCallbacksWithoutSpecs, Forms3}.\n\nusort_callbacks(Callbacks) ->\n % Sort and deduplicate callbacks. For duplicated callbacks we take\n % the one with earliest line.\n\n LineComparator = fun\n ({Callback1, Meta1}, {Callback1, Meta2}) -> ?line(Meta1) =< ?line(Meta2);\n ({Callback1, _Meta1}, {Callback2, _Meta2}) -> Callback1 =< Callback2\n end,\n\n UniqFun = fun({Callback, _Meta}) -> Callback end,\n\n lists:uniq(UniqFun, lists:sort(LineComparator, Callbacks)).\n\n%% Types\n\ntypes_form(Types, Forms) ->\n Fun = fun\n ({Kind, NameArity, Meta, Expr, true}, Acc) ->\n Line = ?line(Meta),\n [{attribute, Line, export_type, [NameArity]}, {attribute, Line, Kind, Expr} | Acc];\n ({Kind, _NameArity, Meta, Expr, false}, Acc) ->\n Line = ?line(Meta),\n [{attribute, Line, Kind, Expr} | Acc]\n end,\n\n lists:foldl(Fun, Forms, Types).\n\n%% Specs and callbacks\n\nvalidate_behaviour_info_and_attributes(#{definitions := Defs} = Map, AllCallbacks) ->\n case {lists:keyfind({behaviour_info, 1}, 1, Defs), AllCallbacks} of\n {false, _} ->\n ok;\n {_, [{Kind, {Name, Arity}, _, _} | _]} when Kind == callback; Kind == macrocallback ->\n file_error(Map, {callbacks_but_also_behaviour_info, {Kind, Name, Arity}});\n {_, _} ->\n ok\n end.\n\nvalidate_optional_callbacks(Map, AllCallbacks, Optional) ->\n lists:foldl(fun(Callback, Acc) ->\n case Callback of\n {Name, Arity} when is_atom(Name) and is_integer(Arity) -> ok;\n _ -> file_error(Map, {ill_defined_optional_callback, Callback})\n end,\n\n case lists:keyfind(Callback, 2, AllCallbacks) of\n false -> file_error(Map, {unknown_callback, Callback});\n _ -> ok\n end,\n\n case Acc of\n #{Callback := _} -> file_error(Map, {duplicate_optional_callback, Callback});\n _ -> ok\n end,\n\n maps:put(Callback, true, Acc)\n end, #{}, Optional).\n\ncallspecs_form(_Kind, [], _Optional, _Macros, Forms, _ModuleMap) ->\n Forms;\ncallspecs_form(Kind, Entries, Optional, Macros, Forms, ModuleMap) ->\n #{unreachable := Unreachable} = ModuleMap,\n\n {SpecsMap, Signatures} =\n lists:foldl(fun({_, NameArity, Meta, Spec}, {Acc, NA}) ->\n Line = ?line(Meta),\n\n case Kind of\n spec -> validate_spec_for_existing_function(ModuleMap, NameArity, Line);\n _ -> ok\n end,\n\n case lists:member(NameArity, Unreachable) of\n false ->\n case Acc of\n #{NameArity := List} -> {Acc#{NameArity := [{Spec, Line} | List]}, NA};\n #{} -> {Acc#{NameArity => [{Spec, Line}]}, [NameArity | NA]}\n end;\n true ->\n {Acc, NA}\n end\n end, {#{}, []}, Entries),\n\n lists:foldl(fun(NameArity, Acc) ->\n #{NameArity := ExprsLines} = SpecsMap,\n {Exprs, Lines} = lists:unzip(ExprsLines),\n Line = lists:min(Lines),\n\n {Key, Value} =\n case lists:member(NameArity, Macros) of\n true ->\n {Name, Arity} = NameArity,\n {{elixir_utils:macro_name(Name), Arity + 1},\n lists:map(fun spec_for_macro/1, Exprs)};\n false ->\n {NameArity, Exprs}\n end,\n\n case lists:member(NameArity, Optional) of\n true ->\n [{attribute, Line, Kind, {Key, lists:reverse(Value)}},\n {attribute, Line, optional_callbacks, [Key]} | Acc];\n false ->\n [{attribute, Line, Kind, {Key, lists:reverse(Value)}} | Acc]\n end\n end, Forms, lists:usort(Signatures)).\n\nspec_for_macro({type, Line, 'bounded_fun', [H | T]}) ->\n {type, Line, 'bounded_fun', [spec_for_macro(H) | T]};\nspec_for_macro({type, Line, 'fun', [{type, _, product, Args} | T]}) ->\n {type, Line, 'fun', [{type, Line, product, [{type, Line, term, []} | Args]} | T]};\nspec_for_macro(Else) ->\n Else.\n\nvalidate_spec_for_existing_function(ModuleMap, NameAndArity, Line) ->\n #{definitions := Defs, file := File} = ModuleMap,\n\n case lists:keymember(NameAndArity, 1, Defs) of\n true -> ok;\n false -> file_error(#{anno => erl_anno:new(Line), file => File}, {spec_for_undefined_function, NameAndArity})\n end.\n\n% Attributes\n\nattributes_form(Line, Attributes, Forms) ->\n Fun = fun({Key, Value}, Acc) -> [{attribute, Line, Key, Value} | Acc] end,\n lists:foldr(Fun, Forms, Attributes).\n\n% Loading forms\n\nload_form(#{file := File, compile_opts := Opts} = Map, Prefix, Forms, Specs, Chunks) ->\n CompileOpts = extra_chunks_opts(Chunks, debug_opts(Map, Specs, Opts)),\n {_, Binary} = elixir_erl_compiler:noenv_forms(Prefix ++ Specs ++ Forms, File, CompileOpts),\n Binary.\n\ndebug_opts(Map, Specs, Opts) ->\n case take_debug_opts(Opts) of\n {true, Rest} -> [{debug_info, {?MODULE, {elixir_v1, Map, Specs}}} | Rest];\n {false, Rest} -> [{debug_info, {?MODULE, none}} | Rest]\n end.\n\ntake_debug_opts(Opts) ->\n case proplists:get_value(debug_info, Opts) of\n true -> {true, proplists:delete(debug_info, Opts)};\n false -> {false, proplists:delete(debug_info, Opts)};\n undefined -> {elixir_config:get(debug_info), Opts}\n end.\n\nextra_chunks_opts([], Opts) -> Opts;\nextra_chunks_opts(Chunks, Opts) -> [{extra_chunks, Chunks} | Opts].\n\ndocs_chunk(Map, Set, Module, Anno, Def, Defmacro, Types, Callbacks, ChunkOpts) ->\n #{file := File, attributes := Attributes} = Map,\n\n case elixir_config:get(docs) of\n true ->\n {ModuleDocLine, ModuleDoc} = get_moduledoc(erl_anno:line(Anno), Set),\n ModuleDocMeta = get_moduledoc_meta(Set),\n FunctionDocs = get_docs(Set, Module, Def, function),\n MacroDocs = get_docs(Set, Module, Defmacro, macro),\n CallbackDocs = get_callback_docs(Set, Callbacks),\n TypeDocs = get_type_docs(Set, Types),\n\n ModuleMeta = ModuleDocMeta#{\n source_path => elixir_utils:characters_to_list(File),\n source_annos => [Anno],\n behaviours => [Mod || {behaviour, Mod} <- Attributes]\n },\n\n DocsChunkData = term_to_binary({docs_v1,\n erl_anno:new(ModuleDocLine),\n elixir,\n <<\"text/markdown\">>,\n ModuleDoc,\n ModuleMeta,\n FunctionDocs ++ MacroDocs ++ CallbackDocs ++ TypeDocs\n }, [compressed | ChunkOpts]),\n\n [{<<\"Docs\">>, DocsChunkData}];\n\n false ->\n []\n end.\n\ndoc_value(Doc, Name) ->\n case Doc of\n false ->\n hidden;\n nil ->\n case erlang:atom_to_list(Name) of\n [$_ | _] -> hidden;\n _ -> none\n end;\n Doc ->\n #{<<\"en\">> => Doc}\n end.\n\nget_moduledoc(Line, Set) ->\n case ets:lookup_element(Set, moduledoc, 2) of\n nil -> {Line, none};\n {DocLine, false} -> {DocLine, hidden};\n {DocLine, nil} -> {DocLine, none};\n {DocLine, Doc} -> {DocLine, #{<<\"en\">> => Doc}}\n end.\n\nget_moduledoc_meta(Set) ->\n case ets:lookup(Set, {moduledoc, meta}) of\n [] -> #{};\n [{{moduledoc, meta}, Map}] when is_map(Map) -> Map\n end.\n\nget_docs(Set, Module, Definitions, Kind) ->\n [{Key,\n erl_anno:new(Line),\n [signature_to_binary(Module, Name, Signature)],\n doc_value(Doc, Name),\n Meta#{source_annos => [?ann(DefinitionMeta)]}\n } || {{Name, Arity}, DefinitionMeta} <- Definitions,\n {Key, _Ctx, Line, Signature, Doc, Meta} <- ets:lookup(Set, {Kind, Name, Arity})].\n\nget_callback_docs(Set, Callbacks) ->\n [{Key,\n erl_anno:new(Line),\n [],\n doc_value(Doc, Name),\n Meta#{source_annos => [?ann(DefinitionMeta)]}\n } || {{Kind, Name, Arity}, DefinitionMeta} <- Callbacks, {Key, Line, Doc, Meta} <- ets:lookup(Set, {Kind, Name, Arity})].\n\nget_type_docs(Set, Types) ->\n [{Key,\n erl_anno:new(Line),\n [],\n doc_value(Doc, Name),\n Meta#{source_annos => [?ann(DefinitionMeta)]}\n } || {_Kind, {Name, Arity}, DefinitionMeta, _, true} <- Types,\n {Key, Line, Doc, Meta} <- ets:lookup(Set, {type, Name, Arity})].\n\nsignature_to_binary(_Module, Name, _Signature) when Name == '__aliases__'; Name == '__block__' ->\n <<(atom_to_binary(Name))/binary, \"(args)\">>;\n\nsignature_to_binary(_Module, fn, _Signature) ->\n <<\"fn(clauses)\">>;\n\nsignature_to_binary(_Module, Name, _Signature)\n when Name == '__CALLER__'; Name == '__DIR__'; Name == '__ENV__';\n Name == '__MODULE__'; Name == '__STACKTRACE__'; Name == '%{}' ->\n atom_to_binary(Name);\n\nsignature_to_binary(_Module, '%', _) ->\n <<\"%struct{}\">>;\n\nsignature_to_binary(Module, '__struct__', []) ->\n <<\"%\", ('Elixir.Kernel':inspect(Module))/binary, \"{}\">>;\n\nsignature_to_binary(_, Name, Signature) ->\n Quoted = {Name, [{closing, []}], Signature},\n Doc = 'Elixir.Inspect.Algebra':format('Elixir.Code':quoted_to_algebra(Quoted), infinity),\n 'Elixir.IO':iodata_to_binary(Doc).\n\nchecker_chunk(Map, Def, Signatures, ChunkOpts) ->\n #{deprecated := Deprecated, defines_behaviour := DefinesBehaviour, attributes := Attributes} = Map,\n DeprecatedMap = maps:from_list(Deprecated),\n\n Exports =\n [begin\n Signature = maps:get(FA, Signatures, none),\n Info = case DeprecatedMap of\n #{FA := Reason} -> #{deprecated => Reason, sig => Signature};\n #{} -> #{sig => Signature}\n end,\n {FA, Info}\n end || {FA, _Meta} <- prepend_behaviour_info(DefinesBehaviour, Def)],\n\n Contents = #{\n exports => Exports,\n mode => case lists:keymember('__protocol__', 1, Attributes) of\n true -> protocol;\n false -> elixir\n end\n },\n\n checker_chunk(Contents, ChunkOpts).\n\nprepend_behaviour_info(true, Def) -> [{{behaviour_info, 1}, []} | Def];\nprepend_behaviour_info(false, Def) -> Def.\n\n%% Errors\n\nfile_error(#{anno := Anno, file := File}, Error) ->\n Line = erl_anno:line(Anno),\n elixir_errors:file_error([{line, Line}], File, ?MODULE, Error).\n\nformat_error({ill_defined_optional_callback, Callback}) ->\n io_lib:format(\"invalid optional callback ~ts. @optional_callbacks expects a \"\n \"keyword list of callback names and arities\", ['Elixir.Kernel':inspect(Callback)]);\nformat_error({unknown_callback, {Name, Arity}}) ->\n io_lib:format(\"unknown callback ~ts/~B given as optional callback\", [Name, Arity]);\nformat_error({duplicate_optional_callback, {Name, Arity}}) ->\n io_lib:format(\"~ts/~B has been specified as optional callback more than once\", [Name, Arity]);\nformat_error({callbacks_but_also_behaviour_info, {Type, Fun, Arity}}) ->\n io_lib:format(\"cannot define @~ts attribute for ~ts/~B when behaviour_info/1 is defined\",\n [Type, Fun, Arity]);\nformat_error({spec_for_undefined_function, {Name, Arity}}) ->\n io_lib:format(\"spec for undefined function ~ts/~B\", [Name, Arity]).\n" }, { "path": "lib/elixir/src/elixir_erl_clauses.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Handle code related to args, guard and -> matching for case,\n%% fn, receive and friends. try is handled in elixir_erl_try.\n-module(elixir_erl_clauses).\n-export([match/4, clause/6, clauses/2, guards/4, get_clauses/3]).\n-include(\"elixir.hrl\").\n\n%% Get clauses under the given key.\n\nget_clauses(Key, Keyword, As) ->\n case lists:keyfind(Key, 1, Keyword) of\n {Key, Clauses} when is_list(Clauses) ->\n [{As, Meta, Left, Right} || {'->', Meta, [Left, Right]} <- Clauses];\n _ ->\n []\n end.\n\n%% Translate matches\n\nmatch(Ann, Fun, Match, #elixir_erl{context=Context} = S) when Context =/= match ->\n {Result, NewS} = Fun(Match, Ann, S#elixir_erl{context=match}),\n {Result, NewS#elixir_erl{context=Context}};\nmatch(Ann, Fun, Match, S) ->\n Fun(Match, Ann, S).\n\n%% Translate clauses with args, guards and expressions\n\nclause(Ann, Fun, Match, Expr, Guards, S) ->\n {TMatch, SA} = match(Ann, Fun, Match, S),\n SG = SA#elixir_erl{extra_guards=[]},\n TGuards = guards(Ann, Guards, SA#elixir_erl.extra_guards, SG),\n {TExpr, SE} = elixir_erl_pass:translate(Expr, Ann, SG),\n {{clause, Ann, TMatch, TGuards, unblock(TExpr)}, SE}.\n\n% Translate/Extract guards from the given expression.\n\nguards(Ann, Guards, Extra, S) ->\n SG = S#elixir_erl{context=guard},\n case Guards of\n [] -> case Extra of [] -> []; _ -> [Extra] end;\n _ -> [translate_guard(Guard, Ann, SG, Extra) || Guard <- Guards]\n end.\n\ntranslate_guard(Guard, Ann, S, Extra) ->\n [element(1, elixir_erl_pass:translate(Guard, Ann, S)) | Extra].\n\n% Function for translating macros with match style like case and receive.\n\nclauses([], S) ->\n {[], S};\n\nclauses(Clauses, S) ->\n lists:mapfoldl(fun each_clause/2, S, Clauses).\n\neach_clause({match, Meta, [Condition], Expr}, S) ->\n {Arg, Guards} = elixir_utils:extract_guards(Condition),\n clause(?ann(Meta), fun elixir_erl_pass:translate_args/3, [Arg], Expr, Guards, S);\n\neach_clause({expr, Meta, [Condition], Expr}, S) ->\n Ann = ?ann(Meta),\n {TCondition, SC} = elixir_erl_pass:translate(Condition, Ann, S),\n {TExpr, SB} = elixir_erl_pass:translate(Expr, Ann, SC),\n {{clause, Ann, [TCondition], [], unblock(TExpr)}, SB}.\n\nunblock({'block', _, Exprs}) -> Exprs;\nunblock(Exprs) -> [Exprs].\n" }, { "path": "lib/elixir/src/elixir_erl_compiler.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_erl_compiler).\n-export([spawn/1, noenv_forms/3, erl_to_core/2, env_compiler_options/0]).\n-include(\"elixir.hrl\").\n\nspawn(Fun) ->\n CompilerInfo = get(elixir_compiler_info),\n {error_handler, ErrorHandler} = erlang:process_info(self(), error_handler),\n\n CodeDiagnostics =\n case get(elixir_code_diagnostics) of\n undefined -> undefined;\n {_Tail, Log} -> {[], Log}\n end,\n\n {_, Ref} =\n spawn_monitor(fun() ->\n erlang:process_flag(error_handler, ErrorHandler),\n put(elixir_compiler_info, CompilerInfo),\n put(elixir_code_diagnostics, CodeDiagnostics),\n\n try Fun() of\n Result -> exit({ok, Result, get(elixir_code_diagnostics)})\n catch\n Kind:Reason:Stack ->\n exit({Kind, Reason, Stack, get(elixir_code_diagnostics)})\n end\n end),\n\n receive\n {'DOWN', Ref, process, _, {ok, Result, Diagnostics}} ->\n copy_diagnostics(Diagnostics),\n Result;\n {'DOWN', Ref, process, _, {Kind, Reason, Stack, Diagnostics}} ->\n copy_diagnostics(Diagnostics),\n erlang:raise(Kind, Reason, Stack)\n end.\n\ncopy_diagnostics(undefined) ->\n ok;\ncopy_diagnostics({Head, _}) ->\n case get(elixir_code_diagnostics) of\n undefined -> ok;\n {Tail, Log} -> put(elixir_code_diagnostics, {Head ++ Tail, Log})\n end.\n\nenv_compiler_options() ->\n case persistent_term:get(?MODULE, undefined) of\n undefined ->\n Options = compile:env_compiler_options() -- [warnings_as_errors],\n persistent_term:put(?MODULE, Options),\n Options;\n\n Options ->\n Options\n end.\n\nerl_to_core(Forms, Opts) ->\n %% TODO: Remove parse transform handling on Elixir v2.0\n case [M || {parse_transform, M} <- Opts] of\n [] ->\n v3_core:module(Forms, Opts);\n _ ->\n case compile:noenv_forms(Forms, [no_spawn_compiler_process, to_core0, return, no_auto_import | Opts]) of\n {ok, _Module, Core, Warnings} -> {ok, Core, Warnings};\n {error, Errors, Warnings} -> {error, Errors, Warnings}\n end\n end.\n\nnoenv_forms(Forms, File, Opts) when is_list(Forms), is_list(Opts), is_binary(File) ->\n Source = elixir_utils:characters_to_list(File),\n\n case erl_to_core(Forms, Opts) of\n {ok, CoreForms, CoreWarnings} ->\n format_warnings(Opts, CoreWarnings),\n CompileOpts = [no_spawn_compiler_process, from_core, no_core_prepare,\n no_auto_import, return, {source, Source} | Opts],\n\n case compile:noenv_forms(CoreForms, CompileOpts) of\n {ok, Module, Binary, Warnings} when is_binary(Binary) ->\n format_warnings(Opts, Warnings),\n {Module, Binary};\n\n {ok, Module, _, _} ->\n incompatible_options(\"could not compile module ~ts\", [elixir_aliases:inspect(Module)], File);\n\n {ok, Module, _} ->\n incompatible_options(\"could not compile module ~ts\", [elixir_aliases:inspect(Module)], File);\n\n {error, Errors, Warnings} ->\n format_warnings(Opts, Warnings),\n format_errors(Errors);\n\n _ ->\n incompatible_options(\"could not compile module\", [], File)\n end;\n\n {error, CoreErrors, CoreWarnings} ->\n format_warnings(Opts, CoreWarnings),\n format_errors(CoreErrors)\n end.\n\nincompatible_options(Prefix, Args, File) ->\n Message = io_lib:format(\n Prefix ++ \". We expected the compiler to return a .beam binary but \"\n \"got something else. This usually happens because ERL_COMPILER_OPTIONS or @compile \"\n \"was set to change the compilation outcome in a way that is incompatible with Elixir\",\n Args\n ),\n\n elixir_errors:compile_error([], File, Message).\n\nformat_errors([]) ->\n exit({nocompile, \"compilation failed but no error was raised\"});\nformat_errors(Errors) ->\n lists:foreach(fun\n ({File, Each}) when is_list(File) ->\n BinFile = elixir_utils:characters_to_binary(File),\n lists:foreach(fun(Error) -> handle_file_error(BinFile, Error) end, Each);\n ({Mod, Each}) when is_atom(Mod) ->\n lists:foreach(fun(Error) -> handle_file_error(elixir_aliases:inspect(Mod), Error) end, Each)\n end, Errors).\n\nformat_warnings(Opts, Warnings) ->\n NoWarnNoMatch = proplists:get_value(nowarn_nomatch, Opts, false),\n lists:foreach(fun ({File, Each}) ->\n BinFile = elixir_utils:characters_to_binary(File),\n lists:foreach(fun(Warning) ->\n handle_file_warning(NoWarnNoMatch, BinFile, Warning)\n end, Each)\n end, Warnings).\n\n%% Handle warnings from Erlang land\n\n%% Those we implement ourselves\nhandle_file_warning(_, _File, {_Line, v3_core, {map_key_repeated, _}}) -> ok;\nhandle_file_warning(_, _File, {_Line, sys_core_fold, {ignored, useless_building}}) -> ok;\n\n%% We skip all of no_match related to no_clause, clause_type, guard, shadow.\n%% Those have too little information and they overlap with the type system.\n%% We keep the remaining ones because the Erlang compiler performs analyses\n%% on literals (including numbers), which the type system does not do.\nhandle_file_warning(_, _File, {_Line, sys_core_fold, {nomatch, Reason}}) when is_atom(Reason) -> ok;\n\n%% Ignore all linting errors (only come up on parse transforms)\nhandle_file_warning(_, _File, {_Line, erl_lint, _}) -> ok;\n\nhandle_file_warning(_, File, {Line, Module, Desc}) ->\n Message = custom_format(Module, Desc),\n elixir_errors:erl_warn(Line, File, Message).\n\n%% Handle warnings\n\nhandle_file_error(File, {beam_validator, Desc}) ->\n elixir_errors:compile_error([{line, 0}], File, beam_validator:format_error(Desc));\nhandle_file_error(File, {Line, Module, Desc}) ->\n Message = custom_format(Module, Desc),\n elixir_errors:compile_error([{line, Line}], File, Message).\n\n%% Mention the capture operator in make_fun\ncustom_format(sys_core_fold, {ignored, {no_effect, {erlang, make_fun, 3}}}) ->\n \"the result of the capture operator & (Function.capture/3) is never used\";\n\n%% Make no_effect clauses pretty\ncustom_format(sys_core_fold, {ignored, {no_effect, {erlang, F, A}}}) ->\n {Fmt, Args} = case erl_internal:comp_op(F, A) of\n true -> {\"use of operator ~ts has no effect\", [elixir_utils:erlang_comparison_op_to_elixir(F)]};\n false ->\n case erl_internal:bif(F, A) of\n false -> {\"the call to :erlang.~ts/~B has no effect\", [F, A]};\n true -> {\"the call to ~ts/~B has no effect\", [F, A]}\n end\n end,\n io_lib:format(Fmt, Args);\n\ncustom_format(sys_core_fold, {nomatch, {shadow, Line, {ErlName, ErlArity}}}) ->\n {Name, Arity} = elixir_utils:erl_fa_to_elixir_fa(ErlName, ErlArity),\n\n io_lib:format(\n \"this clause for ~ts/~B cannot match because a previous clause at line ~B always matches\",\n [Name, Arity, Line]\n );\n\ncustom_format([], Desc) ->\n io_lib:format(\"~p\", [Desc]);\n\ncustom_format(Module, Desc) ->\n Module:format_error(Desc).\n" }, { "path": "lib/elixir/src/elixir_erl_for.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_erl_for).\n-export([translate/3]).\n-include(\"elixir.hrl\").\n\n-define(empty_map_set_pattern, {map, _, [\n {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.MapSet'}},\n {map_field_assoc, _, {atom, _, map}, {map, _, []}}\n ]}).\n\ntranslate(Meta, Args, S) ->\n {Cases, [{do, Expr} | Opts]} = elixir_utils:split_last(Args),\n\n case lists:keyfind(reduce, 1, Opts) of\n {reduce, Reduce} -> translate_reduce(Meta, Cases, Expr, Reduce, S);\n false -> translate_into(Meta, Cases, Expr, Opts, S)\n end.\n\ntranslate_reduce(Meta, Cases, Expr, Reduce, S) ->\n Ann = ?ann(Meta),\n {TReduce, SR} = elixir_erl_pass:translate(Reduce, Ann, S),\n {TCases, SC} = translate_gen(Meta, Cases, [], SR),\n CaseExpr = {'case', Meta, [ok, [{do, Expr}]]},\n {TExpr, SE} = elixir_erl_pass:translate(CaseExpr, Ann, SC),\n\n InnerFun = fun\n ({'case', CaseAnn, _, CaseBlock}, InnerAcc) -> {'case', CaseAnn, InnerAcc, CaseBlock}\n end,\n\n build_reduce(Ann, TCases, InnerFun, TExpr, TReduce, false, SE).\n\ntranslate_into(Meta, Cases, Expr, Opts, S) ->\n Ann = ?ann(Meta),\n\n {TInto, SI} =\n case lists:keyfind(into, 1, Opts) of\n {into, Into} -> elixir_erl_pass:translate(Into, Ann, S);\n false -> {false, S}\n end,\n\n TUniq = lists:keyfind(uniq, 1, Opts) == {uniq, true},\n\n {TCases, SC} = translate_gen(Meta, Cases, [], SI),\n {TExpr, SE} = elixir_erl_pass:translate(wrap_expr_if_unused(Expr, TInto), Ann, SC),\n\n case inline_or_into(TInto) of\n inline -> build_inline(Ann, TCases, TExpr, TInto, TUniq, SE);\n into -> build_into(Ann, TCases, TExpr, TInto, TUniq, SE)\n end.\n\n%% In case we have no return, we wrap the expression\n%% in a block that returns nil.\nwrap_expr_if_unused(Expr, false) -> {'__block__', [], [Expr, nil]};\nwrap_expr_if_unused(Expr, _) -> Expr.\n\ntranslate_gen(ForMeta, [{'<-', Meta, [Left, Right]} | T], Acc, S) ->\n {TLeft, TRight, TFilters, TT, TS} = translate_gen(Meta, Left, Right, T, S),\n TAcc = [{enum, Meta, TLeft, TRight, TFilters} | Acc],\n translate_gen(ForMeta, TT, TAcc, TS);\ntranslate_gen(ForMeta, [{'<<>>', _, [{'<-', Meta, [Left, Right]}]} | T], Acc, S) ->\n {TLeft, TRight, TFilters, TT, TS} = translate_gen(Meta, Left, Right, T, S),\n TAcc = [{bin, Meta, TLeft, TRight, TFilters} | Acc],\n translate_gen(ForMeta, TT, TAcc, TS);\ntranslate_gen(_ForMeta, [], Acc, S) ->\n {lists:reverse(Acc), S}.\n\ntranslate_gen(Meta, Left, Right, T, S) ->\n Ann = ?ann(Meta),\n {TRight, SR} = elixir_erl_pass:translate(Right, Ann, S),\n {LeftArgs, LeftGuards} = elixir_utils:extract_guards(Left),\n {TLeft, SL} = elixir_erl_clauses:match(Ann, fun elixir_erl_pass:translate/3, LeftArgs,\n SR#elixir_erl{extra=pin_guard}),\n\n TLeftGuards = elixir_erl_clauses:guards(Ann, LeftGuards, [], SL),\n ExtraGuards = [{nil, X} || X <- SL#elixir_erl.extra_guards],\n {Filters, TT} = collect_filters(T, []),\n\n {TFilters, TS} =\n lists:mapfoldr(\n fun(F, SF) -> translate_filter(F, Ann, SF) end,\n SL#elixir_erl{extra=S#elixir_erl.extra, extra_guards=[]},\n Filters\n ),\n\n %% The list of guards is kept in reverse order\n Guards = TFilters ++ translate_guards(TLeftGuards) ++ ExtraGuards,\n {TLeft, TRight, Guards, TT, TS}.\n\ntranslate_guards([]) ->\n [];\ntranslate_guards([[Guards]]) ->\n [{nil, Guards}];\ntranslate_guards([[Left], [Right] | Rest]) ->\n translate_guards([[{op, element(2, Left), 'orelse', Left, Right}] | Rest]).\n\ntranslate_filter(Filter, Ann, S) ->\n {TFilter, TS} = elixir_erl_pass:translate(Filter, Ann, S),\n case elixir_utils:returns_boolean(Filter) of\n true ->\n {{nil, TFilter}, TS};\n false ->\n {Name, VS} = elixir_erl_var:build('_', TS),\n {{{var, 0, Name}, TFilter}, VS}\n end.\n\ncollect_filters([{'<-', _, [_, _]} | _] = T, Acc) ->\n {Acc, T};\ncollect_filters([{'<<>>', _, [{'<-', _, [_, _]}]} | _] = T, Acc) ->\n {Acc, T};\ncollect_filters([H | T], Acc) ->\n collect_filters(T, [H | Acc]);\ncollect_filters([], Acc) ->\n {Acc, []}.\n\nbuild_inline(Ann, Clauses, Expr, Into, Uniq, S) ->\n case not Uniq and lists:all(fun(Clause) -> element(1, Clause) == bin end, Clauses) of\n true -> {build_comprehension(Ann, Clauses, Expr, Into), S};\n false -> build_inline_each(Ann, Clauses, Expr, Into, Uniq, S)\n end.\n\nbuild_inline_each(Ann, Clauses, Expr, false, Uniq, S) ->\n InnerFun = fun(InnerExpr, _InnerAcc) -> InnerExpr end,\n build_reduce(Ann, Clauses, InnerFun, Expr, {nil, Ann}, Uniq, S);\nbuild_inline_each(Ann, [{enum, _, Left = {var, _, _}, Right, [] = _Filters}], Expr, {nil, _} = _Into, false, S) ->\n Clauses = [{clause, Ann, [Left], [], [Expr]}],\n Args = [Right, {'fun', Ann, {clauses, Clauses}}],\n {?remote(Ann, 'Elixir.Enum', map, Args), S};\nbuild_inline_each(Ann, [{enum, _, Left = {var, _, _}, Right, [] = _Filters}], Expr, {map, _, []} = _Into, false, S) ->\n Clauses = [{clause, Ann, [Left], [], [Expr]}],\n Args = [Right, {'fun', Ann, {clauses, Clauses}}],\n List = ?remote(Ann, 'Elixir.Enum', map, Args),\n {?remote(Ann, maps, from_list, [List]), S};\nbuild_inline_each(Ann, Clauses, Expr, {nil, _} = Into, Uniq, S) ->\n InnerFun = fun(InnerExpr, InnerAcc) -> {cons, Ann, InnerExpr, InnerAcc} end,\n {ReduceExpr, SR} = build_reduce(Ann, Clauses, InnerFun, Expr, Into, Uniq, S),\n {?remote(Ann, lists, reverse, [ReduceExpr]), SR};\nbuild_inline_each(Ann, Clauses, Expr, {bin, _, []}, Uniq, S) ->\n {InnerValue, SV} = build_var(Ann, S),\n Generated = erl_anno:set_generated(true, Ann),\n\n InnerFun = fun(InnerExpr, InnerAcc) ->\n {'case', Ann, InnerExpr, [\n {clause, Generated,\n [InnerValue],\n [[?remote(Ann, erlang, is_bitstring, [InnerValue]),\n ?remote(Ann, erlang, is_list, [InnerAcc])]],\n [{cons, Generated, InnerAcc, InnerValue}]},\n {clause, Generated,\n [InnerValue],\n [],\n [?remote(Ann, erlang, error, [{tuple, Ann, [{atom, Ann, badarg}, InnerValue]}])]}\n ]}\n end,\n\n {ReduceExpr, SR} = build_reduce(Ann, Clauses, InnerFun, Expr, {nil, Ann}, Uniq, SV),\n {?remote(Ann, erlang, list_to_bitstring, [ReduceExpr]), SR}.\n\nbuild_into(Ann, Clauses, Expr, {map, _, []}, Uniq, S) ->\n {ReduceExpr, SR} = build_inline_each(Ann, Clauses, Expr, {nil, Ann}, Uniq, S),\n {?remote(Ann, maps, from_list, [ReduceExpr]), SR};\nbuild_into(Ann, Clauses, Expr, ?empty_map_set_pattern = _Into, Uniq, S) ->\n InnerFun = fun(InnerExpr, InnerAcc) -> {cons, Ann, InnerExpr, InnerAcc} end,\n {ReduceExpr, SR} = build_reduce(Ann, Clauses, InnerFun, Expr, {nil, Ann}, Uniq, S),\n {?remote(Ann, 'Elixir.MapSet', new, [ReduceExpr]), SR};\nbuild_into(Ann, Clauses, Expr, Into, Uniq, S) ->\n {Fun, SF} = build_var(Ann, S),\n {Acc, SA} = build_var(Ann, SF),\n {Kind, SK} = build_var(Ann, SA),\n {Reason, SR} = build_var(Ann, SK),\n {Stack, ST} = build_var(Ann, SR),\n {Done, SD} = build_var(Ann, ST),\n\n InnerFun = fun(InnerExpr, InnerAcc) ->\n {call, Ann, Fun, [InnerAcc, pair(Ann, cont, InnerExpr)]}\n end,\n\n MatchExpr = {match, Ann,\n {tuple, Ann, [Acc, Fun]},\n ?remote(Ann, 'Elixir.Collectable', into, [Into])\n },\n\n {IntoReduceExpr, SN} = build_reduce(Ann, Clauses, InnerFun, Expr, Acc, Uniq, SD),\n\n TryExpr =\n {'try', Ann,\n [IntoReduceExpr],\n [{clause, Ann,\n [Done],\n [],\n [{call, Ann, Fun, [Done, {atom, Ann, done}]}]}],\n [stacktrace_clause(Ann, Fun, Acc, Kind, Reason, Stack)],\n []},\n\n {{block, Ann, [MatchExpr, TryExpr]}, SN}.\n\nstacktrace_clause(Ann, Fun, Acc, Kind, Reason, Stack) ->\n {clause, Ann,\n [{tuple, Ann, [Kind, Reason, Stack]}],\n [],\n [{call, Ann, Fun, [Acc, {atom, Ann, halt}]},\n ?remote(Ann, erlang, raise, [Kind, Reason, Stack])]}.\n\n%% Helpers\n\nbuild_reduce(Ann, Clauses, InnerFun, Expr, Into, false, S) ->\n {Acc, SA} = build_var(Ann, S),\n {build_reduce_each(Clauses, InnerFun(Expr, Acc), Into, Acc, SA), SA};\nbuild_reduce(Ann, Clauses, InnerFun, Expr, Into, true, S) ->\n %% Those variables are used only inside the anonymous function\n %% so we don't need to worry about returning the scope.\n {Acc, SA} = build_var(Ann, S),\n {Value, SV} = build_var(Ann, SA),\n {IntoAcc, SI} = build_var(Ann, SV),\n {UniqAcc, SU} = build_var(Ann, SI),\n\n NewInto = {tuple, Ann, [Into, {map, Ann, []}]},\n AccTuple = {tuple, Ann, [IntoAcc, UniqAcc]},\n PutUniqExpr = {map, Ann, UniqAcc, [{map_field_assoc, Ann, Value, {atom, Ann, true}}]},\n\n InnerExpr = {block, Ann, [\n {match, Ann, AccTuple, Acc},\n {match, Ann, Value, Expr},\n {'case', Ann, UniqAcc, [\n {clause, Ann, [{map, Ann, [{map_field_exact, Ann, Value, {atom, Ann, true}}]}], [], [AccTuple]},\n {clause, Ann, [{map, Ann, []}], [], [{tuple, Ann, [InnerFun(Value, IntoAcc), PutUniqExpr]}]}\n ]}\n ]},\n\n EnumReduceCall = build_reduce_each(Clauses, InnerExpr, NewInto, Acc, SU),\n {?remote(Ann, erlang, element, [{integer, Ann, 1}, EnumReduceCall]), SU}.\n\nbuild_reduce_each([{enum, Meta, Left, Right, Filters} | T], Expr, Arg, Acc, S) ->\n Ann = ?ann(Meta),\n True = build_reduce_each(T, Expr, Acc, Acc, S),\n False = Acc,\n Generated = erl_anno:set_generated(true, Ann),\n\n Clauses0 =\n case is_var(Left) of\n true -> [];\n false ->\n [{clause, Generated,\n [{var, Ann, '_'}, Acc], [],\n [False]}]\n end,\n\n Clauses1 =\n [{clause, Ann,\n [Left, Acc], [],\n [join_filters(Generated, Filters, True, False)]} | Clauses0],\n\n Args = [Right, Arg, {'fun', Ann, {clauses, Clauses1}}],\n ?remote(Ann, 'Elixir.Enum', reduce, Args);\n\nbuild_reduce_each([{bin, Meta, Left, Right, Filters} | T], Expr, Arg, Acc, S) ->\n Ann = ?ann(Meta),\n Generated = erl_anno:set_generated(true, Ann),\n {Tail, ST} = build_var(Ann, S),\n {Fun, SF} = build_var(Ann, ST),\n\n True = build_reduce_each(T, Expr, Acc, Acc, SF),\n False = Acc,\n {bin, _, Elements} = Left,\n TailElement = {bin_element, Ann, Tail, default, [bitstring]},\n\n Clauses =\n [{clause, Generated,\n [{bin, Ann, [TailElement]}, Acc], [],\n [Acc]},\n {clause, Generated,\n [Tail, {var, Ann, '_'}], [],\n [?remote(Ann, erlang, error, [pair(Ann, badarg, Tail)])]}],\n\n NoVarClauses =\n case no_var(Generated, Elements) of\n error ->\n Clauses;\n\n NoVarElements ->\n NoVarMatch = {bin, Ann, NoVarElements ++ [TailElement]},\n [{clause, Generated, [NoVarMatch, Acc], [], [{call, Ann, Fun, [Tail, False]}]} | Clauses]\n end,\n\n BinMatch = {bin, Ann, Elements ++ [TailElement]},\n VarClauses =\n [{clause, Ann,\n [BinMatch, Acc], [],\n [{call, Ann, Fun, [Tail, join_filters(Generated, Filters, True, False)]}]} | NoVarClauses],\n\n {call, Ann,\n {named_fun, Ann, element(3, Fun), VarClauses},\n [Right, Arg]};\n\nbuild_reduce_each([], Expr, _Arg, _Acc, _S) ->\n Expr.\n\nis_var({var, _, _}) -> true;\nis_var(_) -> false.\n\npair(Ann, Atom, Arg) ->\n {tuple, Ann, [{atom, Ann, Atom}, Arg]}.\n\nbuild_var(Ann, S) ->\n {Name, ST} = elixir_erl_var:build('_', S),\n {{var, Ann, Name}, ST}.\n\nno_var(ParentAnn, Elements) ->\n try\n [{bin_element, Ann, NoVarExpr, no_var_size(Size), Types} ||\n {bin_element, Ann, Expr, Size, Types} <- Elements,\n NoVarExpr <- no_var_expr(ParentAnn, Expr)]\n catch\n unbound_size -> error\n end.\n\nno_var_expr(Ann, {string, _, String}) -> [{var, Ann, '_'} || _ <- String];\nno_var_expr(Ann, _) -> [{var, Ann, '_'}].\nno_var_size({var, _, _}) -> throw(unbound_size);\nno_var_size(Size) -> Size.\n\nbuild_comprehension(Ann, Clauses, Expr, Into) ->\n {comprehension_kind(Into), Ann, Expr, comprehension_clause(Clauses)}.\n\ncomprehension_clause([{bin, Meta, Left, Right, Filters} | T]) ->\n Ann = ?ann(Meta),\n [{b_generate, Ann, Left, Right}] ++\n comprehension_filter(Ann, Filters) ++\n comprehension_clause(T);\ncomprehension_clause([]) ->\n [].\n\ncomprehension_kind(false) -> lc;\ncomprehension_kind({nil, _}) -> lc;\ncomprehension_kind({bin, _, []}) -> bc.\n\ninline_or_into({bin, _, []}) -> inline;\ninline_or_into({nil, _}) -> inline;\ninline_or_into(false) -> inline;\ninline_or_into(_) -> into.\n\ncomprehension_filter(Ann, Filters) ->\n [join_filter(Ann, Filter, {atom, Ann, true}, {atom, Ann, false}) ||\n Filter <- lists:reverse(Filters)].\n\njoin_filters(_Ann, [], True, _False) ->\n True;\njoin_filters(Ann, [H | T], True, False) ->\n lists:foldl(fun(Filter, Acc) ->\n join_filter(Ann, Filter, Acc, False)\n end, join_filter(Ann, H, True, False), T).\n\njoin_filter(Ann, {nil, Filter}, True, False) ->\n {'case', Ann, Filter, [\n {clause, Ann, [{atom, Ann, true}], [], [True]},\n {clause, Ann, [{atom, Ann, false}], [], [False]}\n ]};\njoin_filter(Ann, {Var, Filter}, True, False) ->\n Guards = [[{op, Ann, 'orelse',\n {op, Ann, '==', Var, {atom, Ann, false}},\n {op, Ann, '==', Var, {atom, Ann, nil}}\n }]],\n\n {'case', Ann, Filter, [\n {clause, Ann, [Var], Guards, [False]},\n {clause, Ann, [{var, Ann, '_'}], [], [True]}\n ]}.\n" }, { "path": "lib/elixir/src/elixir_erl_pass.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Translate Elixir quoted expressions to Erlang Abstract Format.\n-module(elixir_erl_pass).\n-export([translate/3, translate_args/3, no_parens_error/2]).\n%% TODO: Remove me on Elixir v2.0.\n-export([parens_map_field/2, no_parens_remote/2]).\n-include(\"elixir.hrl\").\n\n%% =\n\ntranslate({'=', Meta, [{'_', _, Atom}, Right]}, _Ann, S) when is_atom(Atom) ->\n Ann = ?ann(Meta),\n {TRight, SR} = translate(Right, Ann, S),\n {{match, Ann, {var, Ann, '_'}, TRight}, SR};\n\ntranslate({'=', Meta, [Left, Right]}, _Ann, S) ->\n Ann = ?ann(Meta),\n {TRight, SR} = translate(Right, Ann, S),\n case elixir_erl_clauses:match(Ann, fun translate/3, Left, SR) of\n {TLeft, #elixir_erl{extra_guards=ExtraGuards, context=Context} = SL0}\n when ExtraGuards =/= [], Context =/= match ->\n SL1 = SL0#elixir_erl{extra_guards=[]},\n {ResultVarName, SL2} = elixir_erl_var:build('_', SL1),\n Match = {match, Ann, TLeft, TRight},\n Generated = erl_anno:set_generated(true, Ann),\n ResultVar = {var, Generated, ResultVarName},\n ResultMatch = {match, Generated, ResultVar, Match},\n True = {atom, Generated, true},\n Reason = {tuple, Generated, [{atom, Generated, badmatch}, ResultVar]},\n RaiseExpr = ?remote(Generated, erlang, error, [Reason]),\n GuardsExp = {'if', Generated, [\n {clause, Generated, [], [ExtraGuards], [ResultVar]},\n {clause, Generated, [], [[True]], [RaiseExpr]}\n ]},\n {{block, Generated, [ResultMatch, GuardsExp]}, SL2};\n\n {TLeft, SL} ->\n {{match, Ann, TLeft, TRight}, SL}\n end;\n\n%% Containers\n\ntranslate({'{}', Meta, Args}, _Ann, S) when is_list(Args) ->\n Ann = ?ann(Meta),\n {TArgs, SE} = translate_args(Args, Ann, S),\n {{tuple, Ann, TArgs}, SE};\n\ntranslate({'%{}', Meta, Args}, _Ann, S) when is_list(Args) ->\n translate_map(?ann(Meta), Args, S);\n\ntranslate({'%', Meta, [{'^', _, [{Name, _, Context}]} = Left, Right]}, _Ann, S) when is_atom(Name), is_atom(Context) ->\n translate_struct_var_name(?ann(Meta), Left, Right, S);\n\ntranslate({'%', Meta, [{Name, _, Context} = Left, Right]}, _Ann, S) when is_atom(Name), is_atom(Context) ->\n translate_struct_var_name(?ann(Meta), Left, Right, S);\n\ntranslate({'%', Meta, [Left, Right]}, _Ann, S) ->\n translate_struct(?ann(Meta), Left, Right, S);\n\ntranslate({'<<>>', Meta, Args}, _Ann, S) when is_list(Args) ->\n translate_bitstring(Meta, Args, S);\n\n%% Blocks\n\ntranslate({'__block__', Meta, Args}, _Ann, S) when is_list(Args) ->\n Ann = ?ann(Meta),\n {TArgs, SA} = translate_block(Args, Ann, [], S),\n {{block, Ann, lists:reverse(TArgs)}, SA};\n\n%% Compilation environment macros\n\ntranslate({'__CALLER__', Meta, Atom}, _Ann, S) when is_atom(Atom) ->\n {{var, ?ann(Meta), '__CALLER__'}, S#elixir_erl{caller=true}};\n\ntranslate({'__STACKTRACE__', Meta, Atom}, _Ann, S = #elixir_erl{stacktrace=Var}) when is_atom(Atom) ->\n {{var, ?ann(Meta), Var}, S};\n\ntranslate({'super', Meta, Args}, _Ann, S) when is_list(Args) ->\n Ann = ?ann(Meta),\n\n %% In the expanded AST, super is used to invoke a function\n %% in the current module originated from a default clause\n %% or a super call.\n {TArgs, SA} = translate_args(Args, Ann, S),\n {super, {Kind, Name}} = lists:keyfind(super, 1, Meta),\n\n if\n Kind == defmacro; Kind == defmacrop ->\n MacroName = elixir_utils:macro_name(Name),\n {{call, Ann, {atom, Ann, MacroName}, [{var, Ann, '__CALLER__'} | TArgs]}, SA#elixir_erl{caller=true}};\n Kind == def; Kind == defp ->\n {{call, Ann, {atom, Ann, Name}, TArgs}, SA}\n end;\n\n%% Functions\n\ntranslate({'&', Meta, [{'/', _, [{{'.', _, [Remote, Fun]}, _, []}, Arity]}]}, _Ann, S)\n when is_atom(Fun), is_integer(Arity) ->\n Ann = ?ann(Meta),\n {TRemote, SR} = translate(Remote, Ann, S),\n TFun = {atom, Ann, Fun},\n TArity = {integer, Ann, Arity},\n {{'fun', Ann, {function, TRemote, TFun, TArity}}, SR};\ntranslate({'&', Meta, [{'/', _, [{Fun, _, Atom}, Arity]}]}, Ann, S)\n when is_atom(Fun), is_atom(Atom), is_integer(Arity) ->\n case S of\n #elixir_erl{expand_captures=true} ->\n {Vars, SV} = lists:mapfoldl(fun(_, Acc) ->\n {Var, _, AccS} = elixir_erl_var:assign(Meta, Acc),\n {Var, AccS}\n end, S, tl(lists:seq(0, Arity))),\n translate({'fn', Meta, [{'->', Meta, [Vars, {Fun, Meta, Vars}]}]}, Ann, SV);\n\n #elixir_erl{expand_captures=false} ->\n {{'fun', ?ann(Meta), {function, Fun, Arity}}, S}\n end;\n\ntranslate({fn, Meta, Clauses}, _Ann, S) ->\n Transformer = fun({'->', CMeta, [ArgsWithGuards, Expr]}, Acc) ->\n {Args, Guards} = elixir_utils:extract_splat_guards(ArgsWithGuards),\n elixir_erl_clauses:clause(?ann(CMeta), fun translate_fn_match/3, Args, Expr, Guards, Acc)\n end,\n {TClauses, NS} = lists:mapfoldl(Transformer, S, Clauses),\n {{'fun', ?ann(Meta), {clauses, TClauses}}, NS};\n\n%% Cond\n\ntranslate({'cond', CondMeta, [[{do, Clauses}]]}, Ann, S) ->\n [{'->', Meta, [[Condition], _]} = H | T] = lists:reverse(Clauses),\n\n FirstMeta =\n if\n is_atom(Condition), Condition /= false, Condition /= nil -> ?generated(Meta);\n true -> Meta\n end,\n\n Error = {{'.', Meta, [erlang, error]}, Meta, [cond_clause]},\n {Case, SC} = build_cond_clauses([H | T], Error, FirstMeta, S),\n translate(replace_case_meta(CondMeta, Case), Ann, SC);\n\n%% Case\n\ntranslate({'case', Meta, [Expr, Opts]}, _Ann, S) ->\n translate_case(Meta, Expr, Opts, S);\n\n%% Try\n\ntranslate({'try', Meta, [Opts]}, _Ann, S) ->\n Ann = ?ann(Meta),\n Do = proplists:get_value('do', Opts, nil),\n {TDo, SB} = translate(Do, Ann, S),\n\n Catch = [Tuple || {X, _} = Tuple <- Opts, X == 'rescue' orelse X == 'catch'],\n {TCatch, SC} = elixir_erl_try:clauses(Ann, Catch, SB),\n\n {TAfter, SA} = case lists:keyfind('after', 1, Opts) of\n {'after', After} ->\n {TBlock, SAExtracted} = translate(After, Ann, SC),\n {unblock(TBlock), SAExtracted};\n false ->\n {[], SC}\n end,\n\n Else = elixir_erl_clauses:get_clauses('else', Opts, match),\n {TElse, SE} = elixir_erl_clauses:clauses(Else, SA),\n {{'try', ?ann(Meta), unblock(TDo), TElse, TCatch, TAfter}, SE};\n\n%% Receive\n\ntranslate({'receive', Meta, [Opts]}, _Ann, S) ->\n Do = elixir_erl_clauses:get_clauses(do, Opts, match),\n\n case lists:keyfind('after', 1, Opts) of\n false ->\n {TClauses, SC} = elixir_erl_clauses:clauses(Do, S),\n {{'receive', ?ann(Meta), TClauses}, SC};\n _ ->\n After = elixir_erl_clauses:get_clauses('after', Opts, expr),\n {TClauses, SC} = elixir_erl_clauses:clauses(Do ++ After, S),\n {FClauses, TAfter} = elixir_utils:split_last(TClauses),\n {_, _, [FExpr], _, FAfter} = TAfter,\n {{'receive', ?ann(Meta), FClauses, FExpr, FAfter}, SC}\n end;\n\n%% Comprehensions and with\n\ntranslate({for, Meta, [_ | _] = Args}, _Ann, S) ->\n elixir_erl_for:translate(Meta, Args, S);\n\ntranslate({with, Meta, [_ | _] = Args}, _Ann, S) ->\n Ann = ?ann(Meta),\n {Exprs, [{do, Do} | Opts]} = elixir_utils:split_last(Args),\n {ElseClause, MaybeFun, SE} = translate_with_else(Meta, Opts, S),\n {Case, SD} = translate_with_do(Exprs, Ann, Do, ElseClause, SE),\n\n case MaybeFun of\n nil -> {Case, SD};\n FunAssign -> {{block, Ann, [FunAssign, Case]}, SD}\n end;\n\n%% Variables\n\ntranslate({'^', _, [{Name, VarMeta, Kind}]}, _Ann, S) when is_atom(Name), is_atom(Kind) ->\n {Var, VS} = elixir_erl_var:translate(VarMeta, Name, Kind, S),\n\n case S#elixir_erl.extra of\n pin_guard ->\n {PinVarName, PS} = elixir_erl_var:build('_', VS),\n Ann = ?ann(?generated(VarMeta)),\n PinVar = {var, Ann, PinVarName},\n Guard = {op, Ann, '=:=', Var, PinVar},\n {PinVar, PS#elixir_erl{extra_guards=[Guard | PS#elixir_erl.extra_guards]}};\n _ ->\n {Var, VS}\n end;\n\ntranslate({Name, Meta, Kind}, _Ann, S) when is_atom(Name), is_atom(Kind) ->\n elixir_erl_var:translate(Meta, Name, Kind, S);\n\n%% Local calls\n\ntranslate({Name, Meta, Args}, _Ann, S) when is_atom(Name), is_list(Meta), is_list(Args) ->\n Ann = ?ann(Meta),\n {TArgs, NS} = translate_args(Args, Ann, S),\n {{call, Ann, {atom, Ann, Name}, TArgs}, NS};\n\n%% Remote calls\n\ntranslate({{'.', _, [Left, Right]}, Meta, []}, _Ann, #elixir_erl{context=guard} = S)\n when is_tuple(Left), is_atom(Right), is_list(Meta) ->\n Ann = ?ann(Meta),\n {TLeft, SL} = translate(Left, Ann, S),\n TRight = {atom, Ann, Right},\n {?remote(Ann, erlang, map_get, [TRight, TLeft]), SL};\n\ntranslate({{'.', _, [Left, Right]}, Meta, []}, _Ann, S)\n when is_tuple(Left) orelse Left =:= nil orelse is_boolean(Left), is_atom(Right), is_list(Meta) ->\n Ann = ?ann(Meta),\n {TLeft, SL} = translate(Left, Ann, S),\n TRight = {atom, Ann, Right},\n Generated = erl_anno:set_generated(true, Ann),\n\n case proplists:get_value(no_parens, Meta, false) of\n true ->\n {Var, SV} = elixir_erl_var:build('_', SL),\n TVar = {var, Generated, Var},\n\n {{'case', Generated, TLeft, [\n {clause, Generated,\n [{map, Ann, [{map_field_exact, Ann, TRight, TVar}]}],\n [],\n [TVar]},\n {clause, Generated,\n [TVar],\n [],\n [?remote(Ann, erlang, error, [\n ?remote(Generated, elixir_erl_pass, no_parens_error, [TVar, TRight])\n ])]}\n ]}, SV};\n\n false ->\n {{call, Generated, {remote, Generated, TLeft, TRight}, []}, SL}\n end;\n\ntranslate({{'.', _, [Left, Right]}, Meta, Args}, _Ann, S)\n when (is_tuple(Left) orelse is_atom(Left)), is_atom(Right), is_list(Meta), is_list(Args) ->\n translate_remote(Left, Right, Meta, Args, S);\n\n%% Anonymous function calls\n\ntranslate({{'.', _, [Expr]}, Meta, Args}, _Ann, S) when is_list(Args) ->\n Ann = ?ann(Meta),\n {TExpr, SE} = translate(Expr, Ann, S),\n {TArgs, SA} = translate_args(Args, Ann, SE),\n {{call, Ann, TExpr, TArgs}, SA};\n\n%% Literals\n\ntranslate({Left, Right}, Ann, S) ->\n {TLeft, SL} = translate(Left, Ann, S),\n {TRight, SR} = translate(Right, Ann, SL),\n {{tuple, Ann, [TLeft, TRight]}, SR};\n\ntranslate(List, Ann, S) when is_list(List) ->\n translate_list(List, Ann, [], S);\n\ntranslate(Other, Ann, S) ->\n {elixir_erl:elixir_to_erl(Other, Ann), S}.\n\n%% Helpers\n\ntranslate_case(Meta, Expr, Opts, S) ->\n Ann = ?ann(Meta),\n {TExpr, SE} = translate(Expr, Ann, S),\n Clauses = elixir_erl_clauses:get_clauses(do, Opts, match),\n RClauses =\n %% For constructs that optimize booleans, we mark them as generated\n %% to avoid reports from the Erlang compiler but specially Dialyzer.\n case lists:member({optimize_boolean, true}, Meta) of\n true -> [{N, ?generated(M), H, B} || {N, M, H, B} <- Clauses];\n false -> Clauses\n end,\n {TClauses, SC} = elixir_erl_clauses:clauses(RClauses, SE),\n {{'case', Ann, TExpr, TClauses}, SC}.\n\ntranslate_list([{'|', _, [Left, Right]}], Ann, List, Acc) ->\n {TLeft, LAcc} = translate(Left, Ann, Acc),\n {TRight, TAcc} = translate(Right, Ann, LAcc),\n {build_list([TLeft | List], TRight, Ann), TAcc};\ntranslate_list([H | T], Ann, List, Acc) ->\n {TH, TAcc} = translate(H, Ann, Acc),\n translate_list(T, Ann, [TH | List], TAcc);\ntranslate_list([], Ann, List, Acc) ->\n {build_list(List, {nil, Ann}, Ann), Acc}.\n\nbuild_list([H | T], Acc, Ann) ->\n build_list(T, {cons, Ann, H, Acc}, Ann);\nbuild_list([], Acc, _Ann) ->\n Acc.\n\n%% Pack a list of expressions from a block.\nunblock({'block', _, Exprs}) -> Exprs;\nunblock(Expr) -> [Expr].\n\ntranslate_fn_match(Arg, Ann, S) ->\n {TArg, TS} = translate_args(Arg, Ann, S#elixir_erl{extra=pin_guard}),\n {TArg, TS#elixir_erl{extra=S#elixir_erl.extra}}.\n\n%% Translate args\n\ntranslate_args(Args, Ann, S) ->\n lists:mapfoldl(fun\n (Arg, SA) when is_list(Arg) ->\n translate_list(Arg, Ann, [], SA);\n (Arg, SA) when is_tuple(Arg) ->\n translate(Arg, Ann, SA);\n (Arg, SA) ->\n {elixir_erl:elixir_to_erl(Arg, Ann), SA}\n end, S, Args).\n\n%% Translate blocks\n\ntranslate_block([], _Ann, Acc, S) ->\n {Acc, S};\ntranslate_block([H], Ann, Acc, S) ->\n {TH, TS} = translate(H, Ann, S),\n translate_block([], Ann, [TH | Acc], TS);\ntranslate_block([{'__block__', Meta, Args} | T], Ann, Acc, S) when is_list(Args) ->\n {TAcc, SA} = translate_block(Args, ?ann(Meta), Acc, S),\n translate_block(T, Ann, TAcc, SA);\ntranslate_block([H | T], Ann, Acc, S) ->\n {TH, TS} = translate(H, Ann, S),\n translate_block(T, Ann, [TH | Acc], TS).\n\n%% Cond\n\nbuild_cond_clauses([{'->', NewMeta, [[Condition], Body]} | T], Acc, OldMeta, S) ->\n {NewCondition, Truthy, Other, ST} = build_truthy_clause(NewMeta, Condition, Body, S),\n Falsy = {'->', OldMeta, [[Other], Acc]},\n Case = {'case', NewMeta, [NewCondition, [{do, [Truthy, Falsy]}]]},\n build_cond_clauses(T, Case, NewMeta, ST);\nbuild_cond_clauses([], Acc, _, S) ->\n {Acc, S}.\n\nreplace_case_meta(Meta, {'case', _, Args}) ->\n {'case', Meta, Args};\nreplace_case_meta(_Meta, Other) ->\n Other.\n\nbuild_truthy_clause(Meta, Condition, Body, S) ->\n case returns_boolean(Condition, Body) of\n {NewCondition, NewBody} ->\n {NewCondition, {'->', Meta, [[true], NewBody]}, false, S};\n false ->\n {Var, _, SV} = elixir_erl_var:assign(Meta, S),\n Head = {'when', [], [Var,\n {{'.', [], [erlang, 'andalso']}, [], [\n {{'.', [], [erlang, '/=']}, [], [Var, nil]},\n {{'.', [], [erlang, '/=']}, [], [Var, false]}\n ]}\n ]},\n {Condition, {'->', Meta, [[Head], Body]}, {'_', [], nil}, SV}\n end.\n\n%% In case a variable is defined to match in a condition\n%% but a condition returns boolean, we can replace the\n%% variable directly by the boolean result.\nreturns_boolean({'=', _, [{Var, _, Ctx}, Condition]}, {Var, _, Ctx}) when is_atom(Var), is_atom(Ctx) ->\n case elixir_utils:returns_boolean(Condition) of\n true -> {Condition, true};\n false -> false\n end;\n\n%% For all other cases, we check the condition but\n%% return both condition and body untouched.\nreturns_boolean(Condition, Body) ->\n case elixir_utils:returns_boolean(Condition) of\n true -> {Condition, Body};\n false -> false\n end.\n\n%% with\n\ntranslate_with_else(Meta, [], S) ->\n Ann = ?ann(Meta),\n {VarName, SC} = elixir_erl_var:build('_', S),\n Var = {var, Ann, VarName},\n Generated = erl_anno:set_generated(true, Ann),\n {{clause, Generated, [Var], [], [Var]}, nil, SC};\ntranslate_with_else(Meta, [{'else', [{'->', _, [[{Var, VarMeta, Kind}], Clause]}]}], S) when is_atom(Var), is_atom(Kind) ->\n Ann = ?ann(Meta),\n {ElseVarErl, SV} = elixir_erl_var:translate(VarMeta, Var, Kind, S#elixir_erl{context=match}),\n {TranslatedClause, SC} = translate(Clause, Ann, SV#elixir_erl{context=nil}),\n Clauses = [{clause, Ann, [ElseVarErl], [], [TranslatedClause]}],\n with_else_closure(Meta, Clauses, SC);\ntranslate_with_else(Meta, [{'else', Else}], S) ->\n Generated = ?generated(Meta),\n {RaiseVar, _, SV} = elixir_erl_var:assign(Generated, S),\n\n RaiseExpr = {{'.', Generated, [erlang, error]}, Generated, [{else_clause, RaiseVar}]},\n RaiseClause = {'->', Generated, [[RaiseVar], RaiseExpr]},\n\n Clauses = elixir_erl_clauses:get_clauses('else', [{'else', Else ++ [RaiseClause]}], match),\n {TranslatedClauses, SC} = elixir_erl_clauses:clauses(Clauses, SV#elixir_erl{extra=pin_guard}),\n with_else_closure(Generated, TranslatedClauses, SC#elixir_erl{extra=SV#elixir_erl.extra}).\n\nwith_else_closure(Meta, TranslatedClauses, S) ->\n Ann = ?ann(Meta),\n {_, FunErlVar, SC} = elixir_erl_var:assign(Meta, S),\n {_, ArgErlVar, SA} = elixir_erl_var:assign(Meta, SC),\n Generated = erl_anno:set_generated(true, Ann),\n FunAssign = {match, Ann, FunErlVar, {'fun', Generated, {clauses, TranslatedClauses}}},\n FunCall = {call, Ann, FunErlVar, [ArgErlVar]},\n {{clause, Generated, [ArgErlVar], [], [FunCall]}, FunAssign, SA}.\n\ntranslate_with_do([{'<-', Meta, [{Var, _, Ctx} = Left, Expr]} | Rest], Ann, Do, Else, S) when is_atom(Var), is_atom(Ctx) ->\n translate_with_do([{'=', Meta, [Left, Expr]} | Rest], Ann, Do, Else, S);\ntranslate_with_do([{'<-', Meta, [Left, Expr]} | Rest], _Ann, Do, Else, S) ->\n Ann = ?ann(Meta),\n {Args, Guards} = elixir_utils:extract_guards(Left),\n {TExpr, SR} = translate(Expr, Ann, S),\n {TArgs, SA} = elixir_erl_clauses:match(Ann, fun translate/3, Args, SR),\n TGuards = elixir_erl_clauses:guards(Ann, Guards, SA#elixir_erl.extra_guards, SA),\n {TBody, SB} = translate_with_do(Rest, Ann, Do, Else, SA#elixir_erl{extra_guards=[]}),\n Clause = {clause, Ann, [TArgs], TGuards, unblock(TBody)},\n {{'case', Ann, TExpr, [Clause, Else]}, SB};\ntranslate_with_do([Expr | Rest], Ann, Do, Else, S) ->\n {TExpr, TS} = translate(Expr, Ann, S),\n {TRest, RS} = translate_with_do(Rest, Ann, Do, Else, TS),\n {{block, Ann, [TExpr | unblock(TRest)]}, RS};\ntranslate_with_do([], Ann, Do, _Else, S) ->\n translate(Do, Ann, S).\n\n%% Maps and structs\n\ntranslate_struct_var_name(Ann, Name, Args, S0) ->\n {{map, MapAnn, TArgs0}, S1} = translate_struct(Ann, Name, Args, S0),\n {TArgs1, S2} = generate_struct_name_guard(TArgs0, [], S1),\n {{map, MapAnn, TArgs1}, S2}.\n\ntranslate_struct(Ann, _Name, {'%{}', _, [{'|', Meta, [Update, Assocs]}]}, S) ->\n {TUpdate, SU} = translate(Update, Ann, S),\n translate_map(?ann(Meta), Assocs, {ok, TUpdate}, SU);\ntranslate_struct(Ann, Name, {'%{}', _, Assocs}, S) ->\n translate_map(Ann, [{'__struct__', Name}] ++ Assocs, none, S).\n\ntranslate_map(Ann, [{'|', Meta, [Update, Assocs]}], S) ->\n {TUpdate, SU} = translate(Update, Ann, S),\n translate_map(?ann(Meta), Assocs, {ok, TUpdate}, SU);\ntranslate_map(Ann, Assocs, S) ->\n translate_map(Ann, Assocs, none, S).\n\ntranslate_map(Ann, Assocs, TUpdate, #elixir_erl{extra=Extra} = S) ->\n Op = translate_key_val_op(TUpdate, S),\n\n {TArgs, SA} = lists:mapfoldl(fun({Key, Value}, Acc0) ->\n {TKey, Acc1} = translate(Key, Ann, Acc0#elixir_erl{extra=map_key}),\n {TValue, Acc2} = translate(Value, Ann, Acc1#elixir_erl{extra=Extra}),\n {{Op, Ann, TKey, TValue}, Acc2}\n end, S, Assocs),\n\n build_map(Ann, TUpdate, TArgs, SA).\n\ntranslate_key_val_op(_TUpdate, #elixir_erl{extra=map_key}) -> map_field_assoc;\ntranslate_key_val_op(_TUpdate, #elixir_erl{context=match}) -> map_field_exact;\ntranslate_key_val_op(none, _) -> map_field_assoc;\ntranslate_key_val_op(_, _) -> map_field_exact.\n\nbuild_map(Ann, {ok, TUpdate}, TArgs, SA) -> {{map, Ann, TUpdate, TArgs}, SA};\nbuild_map(Ann, none, TArgs, SA) -> {{map, Ann, TArgs}, SA}.\n\n%% Translate bitstrings\n\ntranslate_bitstring(Meta, Args, S) ->\n build_bitstr(Args, ?ann(Meta), S, []).\n\nbuild_bitstr([{'::', Meta, [H, V]} | T], Ann, S, Acc) ->\n {Size, Types} = extract_bit_info(V, Meta, S#elixir_erl{context=nil, extra=nil}),\n build_bitstr(T, Ann, S, Acc, H, Size, Types);\nbuild_bitstr([], Ann, S, Acc) ->\n {{bin, Ann, lists:reverse(Acc)}, S}.\n\nbuild_bitstr(T, Ann, S, Acc, H, default, Types) when is_binary(H) ->\n Element =\n case requires_utf_conversion(Types) of\n false ->\n %% See explanation in elixir_erl:elixir_to_erl/1 to\n %% know why we can simply convert the binary to a list.\n {bin_element, Ann, {string, 0, binary_to_list(H)}, default, default};\n true ->\n %% UTF types require conversion.\n {bin_element, Ann, {string, 0, elixir_utils:characters_to_list(H)}, default, Types}\n end,\n build_bitstr(T, Ann, S, [Element | Acc]);\n\nbuild_bitstr(T, Ann, S, Acc, H, Size, Types) ->\n {Expr, NS} = translate(H, Ann, S),\n build_bitstr(T, Ann, NS, [{bin_element, Ann, Expr, Size, Types} | Acc]).\n\nrequires_utf_conversion([bitstring | _]) -> false;\nrequires_utf_conversion([binary | _]) -> false;\nrequires_utf_conversion(_) -> true.\n\nextract_bit_info({'-', _, [L, {size, _, [Size]}]}, Meta, S) ->\n {extract_bit_size(Size, Meta, S), extract_bit_type(L, [])};\nextract_bit_info({size, _, [Size]}, Meta, S) ->\n {extract_bit_size(Size, Meta, S), []};\nextract_bit_info(L, _Meta, _S) ->\n {default, extract_bit_type(L, [])}.\n\nextract_bit_size(Size, Meta, S) ->\n {TSize, _} = translate(Size, ?ann(Meta), S#elixir_erl{context=guard}),\n TSize.\n\nextract_bit_type({'-', _, [L, R]}, Acc) ->\n extract_bit_type(L, extract_bit_type(R, Acc));\nextract_bit_type({unit, _, [Arg]}, Acc) ->\n [{unit, Arg} | Acc];\nextract_bit_type({Other, _, nil}, Acc) ->\n [Other | Acc];\n%% TODO: Remove me on Elixir v2.0.\n%% Elixir v1.14 and earlier emitted an empty list\n%% and may still be processed via debug_info.\nextract_bit_type({Other, _, []}, Acc) ->\n [Other | Acc].\n\n%% Optimizations that are specific to Erlang and change\n%% the format of the AST.\n\ntranslate_remote('Elixir.String.Chars', to_string, Meta, [Arg], S) ->\n Ann = ?ann(Meta),\n {TArg, TS} = translate(Arg, Ann, S),\n {VarName, VS} = elixir_erl_var:build('_', TS),\n\n Generated = erl_anno:set_generated(true, Ann),\n Var = {var, Generated, VarName},\n Guard = ?remote(Generated, erlang, is_binary, [Var]),\n Slow = ?remote(Generated, 'Elixir.String.Chars', to_string, [Var]),\n Fast = Var,\n\n {{'case', Generated, TArg, [\n {clause, Generated, [Var], [[Guard]], [Fast]},\n {clause, Generated, [Var], [], [Slow]}\n ]}, VS};\ntranslate_remote(maps, put, Meta, [Key, Value, Map], S) ->\n Ann = ?ann(Meta),\n\n case translate_args([Key, Value, Map], Ann, S) of\n {[TKey, TValue, {map, _, InnerMap, Pairs}], TS} ->\n {{map, Ann, InnerMap, Pairs ++ [{map_field_assoc, Ann, TKey, TValue}]}, TS};\n\n {[TKey, TValue, {map, _, Pairs}], TS} ->\n {{map, Ann, Pairs ++ [{map_field_assoc, Ann, TKey, TValue}]}, TS};\n\n {[TKey, TValue, TMap], TS} ->\n {{map, Ann, TMap, [{map_field_assoc, Ann, TKey, TValue}]}, TS}\n end;\ntranslate_remote(lists, member, Meta, [Expr, [Head | Tail] = List], S) ->\n Ann = ?ann(Meta),\n\n case optimize_list_membership(List, 0) of\n true ->\n {TExpr, S1} = translate(Expr, Ann, S),\n\n {TVar, TFun, S3} =\n case TExpr of\n {var, _, _} ->\n {TExpr, fun(Orelse) -> Orelse end, S1};\n\n _ ->\n {VarName, S2} = elixir_erl_var:build('_', S1),\n Generated = erl_anno:set_generated(true, Ann),\n Var = {var, Generated, VarName},\n Fun = fun(Orelse) -> {block, Generated, [{match, Generated, Var, TExpr}, Orelse]} end,\n {Var, Fun, S2}\n end,\n\n {THead, _} = translate(Head, Ann, S),\n\n TOrelse =\n lists:foldl(\n fun(X, Acc) ->\n {TX, _} = translate(X, Ann, S),\n {op, Ann, 'orelse', Acc, {op, Ann, '=:=', TVar, TX}}\n end,\n {op, Ann, '=:=', TVar, THead},\n Tail\n ),\n\n {TFun(TOrelse), S3};\n\n false ->\n {TArgs, SA} = translate_args([Expr, List], Ann, S),\n {{call, Ann, {remote, Ann, {atom, Ann, lists}, {atom, Ann, member}}, TArgs}, SA}\n end;\ntranslate_remote(maps, merge, Meta, [Map1, Map2], S) ->\n Ann = ?ann(Meta),\n\n case translate_args([Map1, Map2], Ann, S) of\n {[{map, _, Pairs1}, {map, _, Pairs2}], TS} ->\n {{map, Ann, Pairs1 ++ Pairs2}, TS};\n\n {[{map, _, InnerMap1, Pairs1}, {map, _, Pairs2}], TS} ->\n {{map, Ann, InnerMap1, Pairs1 ++ Pairs2}, TS};\n\n {[TMap1, {map, _, Pairs2}], TS} ->\n {{map, Ann, TMap1, Pairs2}, TS};\n\n {[TMap1, TMap2], TS} ->\n {{call, Ann, {remote, Ann, {atom, Ann, maps}, {atom, Ann, merge}}, [TMap1, TMap2]}, TS}\n end;\ntranslate_remote(Left, Right, Meta, Args, S) ->\n Ann = ?ann(Meta),\n\n case rewrite_strategy(Left, Right, Args) of\n guard_op ->\n {TArgs, SA} = translate_args(Args, Ann, S),\n %% Rewrite Erlang function calls as operators so they\n %% work in guards, matches and so on.\n case TArgs of\n [TOne] -> {{op, Ann, Right, TOne}, SA};\n [TOne, TTwo] -> {{op, Ann, Right, TOne, TTwo}, SA}\n end;\n {inline_pure, Result} ->\n Generated = erl_anno:set_generated(true, Ann),\n translate(Result, Generated, S);\n {inline_args, NewArgs} ->\n {TLeft, SL} = translate(Left, Ann, S),\n {TArgs, SA} = translate_args(NewArgs, Ann, SL),\n TRight = {atom, Ann, Right},\n {{call, Ann, {remote, Ann, TLeft, TRight}, TArgs}, SA};\n none ->\n {TLeft, SL} = translate(Left, Ann, S),\n {TArgs, SA} = translate_args(Args, Ann, SL),\n TRight = {atom, Ann, Right},\n {{call, Ann, {remote, Ann, TLeft, TRight}, TArgs}, SA}\n end.\n\noptimize_list_membership([Head | Tail], Count)\n when Count =< 32, is_number(Head) orelse is_atom(Head) orelse is_binary(Head) ->\n optimize_list_membership(Tail, Count + 1);\noptimize_list_membership([], _Count) ->\n true;\noptimize_list_membership(_, _Count) ->\n false.\n\nrewrite_strategy(erlang, Right, Args) ->\n Arity = length(Args),\n case elixir_utils:guard_op(Right, Arity) of\n true -> guard_op;\n false -> none\n end;\nrewrite_strategy(Left, shift, [Struct, Opts | RestArgs]) when\n Left == 'Elixir.Date';\n Left == 'Elixir.DateTime';\n Left == 'Elixir.NaiveDateTime';\n Left == 'Elixir.Time'\n->\n case basic_type_arg(Opts) of\n true ->\n try\n {inline_args, [Struct, Left:'__duration__!'(Opts) | RestArgs]}\n catch _:_ ->\n % fail silently, will fail at runtime\n none\n end;\n false ->\n none\n end;\nrewrite_strategy(Left, Right, Args) ->\n case inline_pure_function(Left, Right) andalso basic_type_arg(Args) of\n true ->\n try\n {inline_pure, apply(Left, Right, Args)}\n catch _:_ ->\n % fail silently, will fail at runtime\n none\n end;\n false ->\n none\n end.\n\ninline_pure_function('Elixir.Duration', 'new!') -> true;\ninline_pure_function('Elixir.MapSet', new) -> true;\ninline_pure_function('Elixir.String', length) -> true;\ninline_pure_function('Elixir.String', graphemes) -> true;\ninline_pure_function('Elixir.String', codepoints) -> true;\ninline_pure_function('Elixir.String', split) -> true;\ninline_pure_function('Elixir.Kernel', to_timeout) -> true;\ninline_pure_function('Elixir.URI', new) -> true;\ninline_pure_function('Elixir.URI', 'new!') -> true;\ninline_pure_function('Elixir.URI', parse) -> true;\ninline_pure_function('Elixir.URI', encode_query) -> true;\ninline_pure_function('Elixir.URI', encode_www_form) -> true;\ninline_pure_function('Elixir.URI', decode) -> true;\ninline_pure_function('Elixir.URI', decode_www_form) -> true;\ninline_pure_function('Elixir.Version', parse) -> true;\ninline_pure_function('Elixir.Version', 'parse!') -> true;\ninline_pure_function('Elixir.Version', parse_requirement) -> true;\ninline_pure_function('Elixir.Version', 'parse_requirement!') -> true;\ninline_pure_function(_Left, _Right) -> false.\n\n% we do not want to try and inline calls which might depend on protocols that might be overridden later\nbasic_type_arg(Term) when is_number(Term); is_atom(Term); is_binary(Term) -> true;\nbasic_type_arg(List) when is_list(List) -> lists:all(fun basic_type_arg/1, List);\nbasic_type_arg({Left, Right}) -> basic_type_arg(Left) and basic_type_arg(Right);\nbasic_type_arg(_) -> false.\n\ngenerate_struct_name_guard([{map_field_exact, Ann, {atom, _, '__struct__'} = Key, Var} | Rest], Acc, S0) ->\n {ModuleVarName, S1} = elixir_erl_var:build('_', S0),\n Generated = erl_anno:set_generated(true, Ann),\n ModuleVar = {var, Generated, ModuleVarName},\n Match = {match, Generated, ModuleVar, Var},\n Guard = ?remote(Generated, erlang, is_atom, [ModuleVar]),\n S2 = S1#elixir_erl{extra_guards=[Guard | S1#elixir_erl.extra_guards]},\n {lists:reverse(Acc, [{map_field_exact, Ann, Key, Match} | Rest]), S2};\ngenerate_struct_name_guard([Field | Rest], Acc, S) ->\n generate_struct_name_guard(Rest, [Field | Acc], S).\n\nno_parens_error(#{} = Map, Key) ->\n {badkey, Key, Map};\nno_parens_error(Other, _Key) ->\n {badmap, Other}.\n\n%% TODO: Previous Elixir code was compiled with these functions,\n%% so we have to keep them.\nno_parens_remote(nil, _Key) -> {error, {badmap, nil}};\nno_parens_remote(false, _Key) -> {error, {badmap, false}};\nno_parens_remote(true, _Key) -> {error, {badmap, true}};\nno_parens_remote(Atom, Fun) when is_atom(Atom) ->\n Message = fun() ->\n io_lib:format(\n \"using map.field notation (without parentheses) to invoke function ~ts.~ts() is deprecated, \"\n \"you must add parentheses instead: remote.function()\",\n [elixir_aliases:inspect(Atom), Fun]\n )\n end,\n 'Elixir.IO':warn_once(?MODULE, Message, 3),\n {ok, apply(Atom, Fun, [])};\nno_parens_remote(#{} = Map, Key) ->\n {error, {badkey, Key, Map}};\nno_parens_remote(Other, _Key) ->\n {error, {badmap, Other}}.\n\nparens_map_field(Key, Value) ->\n Message = fun() ->\n io_lib:format(\n \"using module.function() notation (with parentheses) to fetch map field ~ts is deprecated, \"\n \"you must remove the parentheses: map.field\",\n [elixir_aliases:inspect(Key)]\n )\n end,\n 'Elixir.IO':warn_once(?MODULE, Message, 3),\n Value.\n" }, { "path": "lib/elixir/src/elixir_erl_try.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_erl_try).\n-export([clauses/3]).\n-include(\"elixir.hrl\").\n-define(REQUIRES_STACKTRACE,\n ['Elixir.FunctionClauseError', 'Elixir.UndefinedFunctionError',\n 'Elixir.KeyError', 'Elixir.ArgumentError', 'Elixir.SystemLimitError']).\n\nclauses(_Ann, Args, S) ->\n Catch = elixir_erl_clauses:get_clauses('catch', Args, 'catch'),\n Rescue = elixir_erl_clauses:get_clauses(rescue, Args, rescue),\n {StackName, SV} = elixir_erl_var:build('__STACKTRACE__', S),\n OldStack = SV#elixir_erl.stacktrace,\n SS = SV#elixir_erl{stacktrace=StackName},\n reduce_clauses(Rescue ++ Catch, [], OldStack, SS, SS).\n\nreduce_clauses([H | T], Acc, OldStack, SAcc, S) ->\n {TH, TS} = each_clause(H, SAcc),\n reduce_clauses(T, [TH | Acc], OldStack, TS, S);\nreduce_clauses([], Acc, OldStack, SAcc, _S) ->\n {lists:reverse(Acc), SAcc#elixir_erl{stacktrace=OldStack}}.\n\neach_clause({'catch', Meta, Raw, Expr}, S) ->\n {Args, Guards} = elixir_utils:extract_splat_guards(Raw),\n\n Match =\n %% TODO: Remove me on Elixir v2.0.\n %% Elixir v1.17 and earlier emitted single argument\n %% and may still be processed via debug_info.\n case Args of\n [X] -> [throw, X];\n [X, Y] -> [X, Y]\n end,\n\n {{clause, Line, [TKind, TMatches], TGuards, TBody}, TS} =\n elixir_erl_clauses:clause(?ann(Meta), fun elixir_erl_pass:translate_args/3, Match, Expr, Guards, S),\n\n build_clause(Line, TKind, TMatches, TGuards, TBody, TS);\n\neach_clause({rescue, Meta, [{in, _, [Left, Right]}], Expr}, S) ->\n {TempVar, _, CS} = elixir_erl_var:assign(Meta, S),\n {Guards, ErlangAliases} = rescue_guards(Meta, TempVar, Right),\n Body = normalize_rescue(Meta, TempVar, Left, Expr, ErlangAliases),\n build_rescue(Meta, TempVar, Guards, Body, CS);\n\neach_clause({rescue, Meta, [{VarName, _, Context} = Left], Expr}, S) when is_atom(VarName), is_atom(Context) ->\n {TempVar, _, CS} = elixir_erl_var:assign(Meta, S),\n Body = normalize_rescue(Meta, TempVar, Left, Expr, ['Elixir.ErlangError']),\n build_rescue(Meta, TempVar, [], Body, CS).\n\nnormalize_rescue(_Meta, _Var, {'_', _, Atom}, Expr, _) when is_atom(Atom) ->\n Expr;\nnormalize_rescue(Meta, Var, Pattern, Expr, []) ->\n prepend_to_block(Meta, {'=', Meta, [Pattern, Var]}, Expr);\nnormalize_rescue(Meta, Var, Pattern, Expr, ErlangAliases) ->\n Stacktrace =\n case lists:member('Elixir.ErlangError', ErlangAliases) of\n true ->\n dynamic_normalize(Meta, Var, ?REQUIRES_STACKTRACE);\n\n false ->\n case lists:partition(fun is_normalized_with_stacktrace/1, ErlangAliases) of\n {[], _} -> [];\n {_, []} -> {'__STACKTRACE__', Meta, nil};\n {Some, _} -> dynamic_normalize(Meta, Var, Some)\n end\n end,\n\n Normalized = {{'.', Meta, ['Elixir.Exception', normalize]}, Meta, [error, Var, Stacktrace]},\n prepend_to_block(Meta, {'=', Meta, [Pattern, Normalized]}, Expr).\n\ndynamic_normalize(Meta, Var, [H | T]) ->\n Generated = ?generated(Meta),\n\n Guards =\n lists:foldl(fun(Alias, Acc) ->\n {'when', Generated, [erl_rescue_stacktrace_for(Generated, Var, Alias), Acc]}\n end, erl_rescue_stacktrace_for(Generated, Var, H), T),\n\n {'case', Generated, [\n Var,\n [{do, [\n {'->', Generated, [[{'when', Generated, [{'_', Generated, nil}, Guards]}], {'__STACKTRACE__', Generated, nil}]},\n {'->', Generated, [[{'_', Generated, nil}], []]}\n ]}]\n ]}.\n\nerl_rescue_stacktrace_for(_Meta, _Var, 'Elixir.ErlangError') ->\n %% ErlangError is a \"meta\" exception, we should never expand it here.\n error(badarg);\nerl_rescue_stacktrace_for(Meta, Var, 'Elixir.KeyError') ->\n %% Only the two-element tuple requires stacktrace.\n erl_and(Meta, erl_tuple_size(Meta, Var, 2), erl_record_compare(Meta, Var, badkey));\nerl_rescue_stacktrace_for(Meta, Var, Module) ->\n erl_rescue_guard_for(Meta, Var, Module).\n\nis_normalized_with_stacktrace(Module) ->\n lists:member(Module, ?REQUIRES_STACKTRACE).\n\n%% Helpers\n\nbuild_rescue(Meta, Var, Guards, Body, S) ->\n {{clause, Line, [TMatch], TGuards, TBody}, TS} =\n elixir_erl_clauses:clause(?ann(Meta), fun elixir_erl_pass:translate_args/3, [Var], Body, Guards, S),\n\n build_clause(Line, {atom, Line, error}, TMatch, TGuards, TBody, TS).\n\n%% Convert rescue clauses (\"var in [alias1, alias2]\") into guards.\nrescue_guards(_Meta, _Var, []) ->\n {[], []};\nrescue_guards(Meta, Var, Aliases) ->\n {ErlangGuards, ErlangAliases} = erl_rescue(Meta, Var, Aliases, [], []),\n\n ElixirGuards =\n [erl_and(Meta,\n {erl(Meta, '=='), Meta, [{erl(Meta, map_get), Meta, ['__struct__', Var]}, Alias]},\n {erl(Meta, map_get), Meta, ['__exception__', Var]}\n ) || Alias <- Aliases],\n\n {ElixirGuards ++ ErlangGuards, ErlangAliases}.\n\nbuild_clause(Line, Kind, Expr, Guards, Body, #elixir_erl{stacktrace=Var} = TS) ->\n Match = {tuple, Line, [Kind, Expr, {var, Line, Var}]},\n {{clause, Line, [Match], Guards, Body}, TS}.\n\n%% Rescue each atom name considering their Erlang or Elixir matches.\n%% Matching of variables is done with Erlang exceptions is done in\n%% function for optimization.\n\nerl_rescue(Meta, Var, [H | T], Guards, Aliases) when is_atom(H) ->\n case erl_rescue_guard_for(Meta, Var, H) of\n false -> erl_rescue(Meta, Var, T, Guards, Aliases);\n Expr -> erl_rescue(Meta, Var, T, [Expr | Guards], [H | Aliases])\n end;\nerl_rescue(_, _, [], Guards, Aliases) ->\n {Guards, Aliases}.\n\n%% Handle Erlang rescue matches.\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.UndefinedFunctionError') ->\n {erl(Meta, '=='), Meta, [Var, undef]};\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.FunctionClauseError') ->\n {erl(Meta, '=='), Meta, [Var, function_clause]};\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.SystemLimitError') ->\n {erl(Meta, '=='), Meta, [Var, system_limit]};\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.ArithmeticError') ->\n {erl(Meta, '=='), Meta, [Var, badarith]};\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.CondClauseError') ->\n {erl(Meta, '=='), Meta, [Var, cond_clause]};\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.BadArityError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, badarity));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.BadFunctionError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, badfun));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.MatchError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, badmatch));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.CaseClauseError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, case_clause));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.WithClauseError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, else_clause));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.TryClauseError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, try_clause));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.BadMapError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, badmap));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.BadBooleanError') ->\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 3),\n erl_record_compare(Meta, Var, badbool));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.KeyError') ->\n erl_and(Meta,\n erl_or(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_tuple_size(Meta, Var, 3)),\n erl_record_compare(Meta, Var, badkey));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.ArgumentError') ->\n erl_or(Meta,\n {erl(Meta, '=='), Meta, [Var, badarg]},\n erl_and(Meta,\n erl_tuple_size(Meta, Var, 2),\n erl_record_compare(Meta, Var, badarg)));\n\nerl_rescue_guard_for(Meta, Var, 'Elixir.ErlangError') ->\n Condition =\n erl_and(\n Meta,\n {erl(Meta, is_map), Meta, [Var]},\n {erl(Meta, is_map_key), Meta, ['__exception__', Var]}\n ),\n {erl(Meta, 'not'), Meta, [Condition]};\n\nerl_rescue_guard_for(_, _, _) ->\n false.\n\n%% Helpers\n\nerl_tuple_size(Meta, Var, Size) ->\n {erl(Meta, '=='), Meta, [{erl(Meta, tuple_size), Meta, [Var]}, Size]}.\n\nerl_record_compare(Meta, Var, Expr) ->\n {erl(Meta, '=='), Meta, [\n {erl(Meta, element), Meta, [1, Var]},\n Expr\n ]}.\n\nprepend_to_block(_Meta, Expr, {'__block__', Meta, Args}) ->\n {'__block__', Meta, [Expr | Args]};\n\nprepend_to_block(Meta, Expr, Args) ->\n {'__block__', Meta, [Expr, Args]}.\n\nerl(Meta, Op) -> {'.', Meta, [erlang, Op]}.\nerl_or(Meta, Left, Right) -> {erl(Meta, 'orelse'), Meta, [Left, Right]}.\nerl_and(Meta, Left, Right) -> {erl(Meta, 'andalso'), Meta, [Left, Right]}.\n" }, { "path": "lib/elixir/src/elixir_erl_var.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Convenience functions used to manipulate scope and its variables.\n-module(elixir_erl_var).\n-export([\n translate/4, assign/2, build/2,\n load_binding/2, dump_binding/4,\n from_env/1, from_env/2\n]).\n-include(\"elixir.hrl\").\n\n%% VAR HANDLING\n\ntranslate(Meta, '_', _Kind, S) ->\n {{var, ?ann(Meta), '_'}, S};\n\ntranslate(Meta, Name, Kind, #elixir_erl{var_names=VarNames} = S) ->\n {version, Version} = lists:keyfind(version, 1, Meta),\n\n case VarNames of\n #{Version := ErlName} -> {{var, ?ann(Meta), ErlName}, S};\n #{} when Kind /= nil -> assign(Meta, '_', Version, S);\n #{} -> assign(Meta, Name, Version, S)\n end.\n\nassign(Meta, #elixir_erl{var_names=VarNames} = S) ->\n Version = -(map_size(VarNames)+1),\n ExVar = {var, [{version, Version} | Meta], ?var_context},\n {ErlVar, SV} = assign(Meta, '_', Version, S),\n {ExVar, ErlVar, SV}.\n\nassign(Meta, Name, Version, #elixir_erl{var_names=VarNames} = S) ->\n {NewVar, NS} = build(Name, S),\n NewVarNames = VarNames#{Version => NewVar},\n {{var, ?ann(Meta), NewVar}, NS#elixir_erl{var_names=NewVarNames}}.\n\nbuild(Key, #elixir_erl{counter=Counter} = S) ->\n Count =\n case Counter of\n #{Key := Val} -> Val + 1;\n _ -> 1\n end,\n {build_name(Key, Count),\n S#elixir_erl{counter=Counter#{Key => Count}}}.\n\nbuild_name('_', Count) -> list_to_atom(\"_@\" ++ integer_to_list(Count));\nbuild_name(Name, Count) -> list_to_atom(\"_\" ++ atom_to_list(Name) ++ \"@\" ++ integer_to_list(Count)).\n\n%% BINDINGS\n\nfrom_env(#{versioned_vars := Read} = Env) ->\n VarsList = to_erl_vars(maps:values(Read), 0),\n {VarsList, from_env(Env, maps:from_list(VarsList))}.\n\nfrom_env(#{context := Context}, VarsMap) ->\n #elixir_erl{\n context=Context,\n var_names=VarsMap,\n counter=#{'_' => map_size(VarsMap)}\n }.\n\nto_erl_vars([Version | Versions], Counter) ->\n [{Version, to_erl_var(Counter)} | to_erl_vars(Versions, Counter + 1)];\nto_erl_vars([], _Counter) ->\n [].\n\nto_erl_var(Counter) ->\n list_to_atom(\"_@\" ++ integer_to_list(Counter)).\n\nload_binding(Binding, Prune) ->\n load_binding(Binding, #{}, [], [], 0, Prune).\n\nload_binding([Binding | NextBindings], ExVars, ErlVars, Normalized, Counter, Prune) ->\n {Pair, Value} = load_pair(Binding),\n\n case ExVars of\n #{Pair := VarCounter} ->\n ErlVar = to_erl_var(VarCounter),\n load_binding(NextBindings, ExVars, ErlVars, [{ErlVar, Value} | Normalized], Counter, Prune);\n\n #{} ->\n ErlVar = to_erl_var(Counter),\n\n load_binding(\n NextBindings,\n ExVars#{Pair => Counter},\n [{Counter, ErlVar} | ErlVars],\n [{ErlVar, Value} | Normalized],\n Counter + 1,\n Prune\n )\n end;\nload_binding([], ExVars, ErlVars, Normalized, Counter, true) ->\n load_binding([{{elixir, prune_binding}, true}], ExVars, ErlVars, Normalized, Counter, false);\nload_binding([], ExVars, ErlVars, Normalized, _Counter, false) ->\n {ExVars, maps:from_list(ErlVars), maps:from_list(lists:reverse(Normalized))}.\n\nload_pair({Key, Value}) when is_atom(Key) -> {{Key, nil}, Value};\nload_pair({Pair, Value}) -> {Pair, Value}.\n\ndump_binding(Binding, ErlS, ExS, PruneBefore) ->\n #elixir_erl{var_names=ErlVars} = ErlS,\n #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,\n\n maps:fold(fun\n ({Var, Kind} = Pair, Version, {B, V})\n when is_atom(Kind),\n %% If the variable is part of the pruning (usually the input binding)\n %% and is unused, we removed it from vars.\n Version > PruneBefore orelse is_map_key({Pair, Version}, Unused) ->\n Key = case Kind of\n nil -> Var;\n _ -> Pair\n end,\n\n ErlName = maps:get(Version, ErlVars),\n Value = maps:get(ErlName, Binding, nil),\n {[{Key, Value} | B], V};\n\n (Pair, _, {B, V}) when PruneBefore >= 0 ->\n {B, maps:remove(Pair, V)};\n\n (_, _, Acc) ->\n Acc\n end, {[], ExVars}, ExVars).\n" }, { "path": "lib/elixir/src/elixir_errors.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% A bunch of helpers to help to deal with errors in Elixir source code.\n%% This is not exposed in the Elixir language.\n%%\n%% Note that this is also called by the Erlang backend, so we also support\n%% the line number to be none (as it may happen in some erlang errors).\n-module(elixir_errors).\n-export([compile_error/1, compile_error/3, parse_error/5]).\n-export([function_error/4, module_error/4, file_error/4]).\n-export([format_snippet/6]).\n-export([erl_warn/3, file_warn/4]).\n-export([prefix/1]).\n-export([print_diagnostics/1, print_diagnostic/2, emit_diagnostic/6]).\n-export([print_warning/3]).\n-include(\"elixir.hrl\").\n-type location() :: non_neg_integer() | {non_neg_integer(), non_neg_integer()}.\n\n%% Diagnostic API\n\n%% TODO: Remove me on Elixir v2.0.\n%% Called by deprecated Kernel.ParallelCompiler.print_warning.\nprint_warning(Position, File, Message) ->\n Output = format_snippet(warning, Position, File, Message, nil, #{}),\n io:put_chars(standard_error, [Output, $\\n, $\\n]).\n\n%% Used by Module.ParallelChecker.\nprint_diagnostics([Diagnostic | Others]) ->\n #{file := File, position := Position, message := Message} = Diagnostic,\n Snippet = read_snippet(File, Position),\n Formatted = format_snippet(warning, Position, File, Message, Snippet, Diagnostic),\n LineNumber = extract_line(Position),\n LineDigits = get_line_number_digits(LineNumber, 1),\n Padding = case Snippet of\n nil -> 0;\n _ -> max(4, LineDigits + 2)\n end,\n Locations = [[\"\\n\", n_spaces(Padding), \"└─ \", 'Elixir.Exception':format_stacktrace_entry(ES)] || #{stacktrace := [ES]} <- Others],\n io:put_chars(standard_error, [Formatted, Locations, $\\n, $\\n]).\n\nprint_diagnostic(#{severity := S, message := M, position := P, file := F} = Diagnostic, ReadSnippet) ->\n Snippet =\n case ReadSnippet of\n true -> read_snippet(F, P);\n false -> nil\n end,\n\n Output = format_snippet(S, P, F, M, Snippet, Diagnostic),\n\n MaybeStack =\n case (F /= nil) orelse elixir_config:is_bootstrap() of\n true -> [];\n false -> [[\"\\n \", 'Elixir.Exception':format_stacktrace_entry(E)] || E <- ?key(Diagnostic, stacktrace)]\n end,\n\n io:put_chars(standard_error, [Output, MaybeStack, $\\n, $\\n]),\n Diagnostic.\n\nemit_diagnostic(Severity, Position, File, Message, Stacktrace, Options) ->\n ReadSnippet = proplists:get_value(read_snippet, Options, false),\n\n Span = case lists:keyfind(span, 1, Options) of\n {span, {EndLine, EndCol}} -> {EndLine, EndCol};\n _ -> nil\n end,\n\n Diagnostic = #{\n severity => Severity,\n source => case get(elixir_compiler_file) of\n undefined -> File;\n CompilerFile -> CompilerFile\n end,\n file => File,\n position => Position,\n message => unicode:characters_to_binary(Message),\n stacktrace => Stacktrace,\n span => Span\n },\n\n case get(elixir_code_diagnostics) of\n undefined ->\n case get(elixir_compiler_info) of\n undefined -> print_diagnostic(Diagnostic, ReadSnippet);\n {CompilerPid, _} -> CompilerPid ! {diagnostic, Diagnostic, ReadSnippet}\n end;\n\n {Tail, true} ->\n put(elixir_code_diagnostics, {[print_diagnostic(Diagnostic, ReadSnippet) | Tail], true});\n\n {Tail, false} ->\n put(elixir_code_diagnostics, {[Diagnostic | Tail], false})\n end,\n\n ok.\n\nextract_line({L, _}) -> L;\nextract_line(L) -> L.\n\nextract_column({_, C}) -> C;\nextract_column(_) -> nil.\n\n%% Format snippets\n%% \"Snippet\" here refers to the source code line where the diagnostic/error occurred\n\nformat_snippet(Severity, _Position, nil, Message, nil, _Diagnostic) ->\n Formatted = [prefix(Severity), \" \", Message],\n unicode:characters_to_binary(Formatted);\n\nformat_snippet(Severity, Position, File, Message, nil, Diagnostic) ->\n Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])),\n\n Formatted = io_lib:format(\n \"~ts ~ts\\n\"\n \"└─ ~ts\",\n [prefix(Severity), Message, Location]\n ),\n\n unicode:characters_to_binary(Formatted);\n\nformat_snippet(Severity, Position, File, Message, Snippet, Diagnostic) ->\n Column = extract_column(Position),\n LineNumber = extract_line(Position),\n LineDigits = get_line_number_digits(LineNumber, 1),\n Spacing = n_spaces(max(2, LineDigits) + 1),\n LineNumberSpacing = if LineDigits =:= 1 -> 1; true -> 0 end,\n {FormattedLine, ColumnsTrimmed} = format_line(Snippet),\n Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])),\n MessageDetail = format_detail(Diagnostic, Message),\n\n Highlight =\n case Column of\n nil ->\n highlight_below_line(FormattedLine, Severity);\n _ ->\n Length = calculate_span_length({LineNumber, Column}, Diagnostic),\n highlight_at_position(Column - ColumnsTrimmed, Severity, Length)\n end,\n\n Formatted = io_lib:format(\n \" ~ts~ts ~ts\\n\"\n \" ~ts│\\n\"\n \" ~ts~p │ ~ts\\n\"\n \" ~ts│ ~ts\\n\"\n \" ~ts│\\n\"\n \" ~ts└─ ~ts\",\n [\n Spacing, prefix(Severity), format_message(MessageDetail, LineDigits, 2 + LineNumberSpacing),\n Spacing,\n n_spaces(LineNumberSpacing), LineNumber, FormattedLine,\n Spacing, Highlight,\n Spacing,\n Spacing, Location\n ]),\n\n unicode:characters_to_binary(Formatted).\n\nformat_detail(#{details := #{typing_traces := _}}, Message) -> [Message | \"\\ntype warning found at:\"];\nformat_detail(_, Message) -> Message.\n\ncalculate_span_length({StartLine, StartCol}, #{span := {StartLine, EndCol}}) -> EndCol - StartCol;\ncalculate_span_length({StartLine, _}, #{span := {EndLine, _}}) when EndLine > StartLine -> 1;\ncalculate_span_length({_, _}, #{}) -> 1.\n\nformat_line(Line) ->\n case trim_line(Line, 0) of\n {Trimmed, SpacesMatched} when SpacesMatched >= 27 ->\n ColumnsTrimmed = SpacesMatched - 22,\n {[\"...\", n_spaces(19), Trimmed], ColumnsTrimmed};\n\n {_, _} ->\n {Line, 0}\n end.\n\ntrim_line(<<$\\s, Rest/binary>>, Count) -> trim_line(Rest, Count + 1);\ntrim_line(<<$\\t, Rest/binary>>, Count) -> trim_line(Rest, Count + 8);\ntrim_line(Rest, Count) -> {Rest, Count}.\n\nformat_message(Message, NDigits, PaddingSize) ->\n Padding = list_to_binary([$\\n, n_spaces(NDigits + PaddingSize)]),\n Bin = unicode:characters_to_binary(Message),\n pad_line(binary:split(Bin, <<\"\\n\">>, [global]), Padding).\n\npad_line([Last], _Padding) -> [Last];\npad_line([First, <<\"\">> | Rest], Padding) -> [First, \"\\n\" | pad_line([<<\"\">> | Rest], Padding)];\npad_line([First | Rest], Padding) -> [First, Padding | pad_line(Rest, Padding)].\n\nhighlight_at_position(Column, Severity, Length) ->\n Spacing = n_spaces(max(Column - 1, 0)),\n case Severity of\n warning -> highlight([Spacing, lists:duplicate(Length, $~)], warning);\n error -> highlight([Spacing, lists:duplicate(Length, $^)], error)\n end.\n\nhighlight_below_line(Line, Severity) ->\n % Don't highlight leading whitespaces in line\n {Rest, SpacesMatched} = trim_line(Line, 0),\n\n Length = string:length(Rest),\n Highlight = case Severity of\n warning -> highlight(lists:duplicate(Length, $~), warning);\n error -> highlight(lists:duplicate(Length, $^), error)\n end,\n\n [n_spaces(SpacesMatched), Highlight].\n\nget_line_number_digits(Number, Acc) when Number < 10 -> Acc;\nget_line_number_digits(Number, Acc) ->\n get_line_number_digits(Number div 10, Acc + 1).\n\nn_spaces(N) -> lists:duplicate(N, \" \").\n\nread_snippet(nil, _Position) ->\n nil;\nread_snippet(<<\"nofile\">>, _Position) ->\n nil;\nread_snippet(File, Position) ->\n LineNumber = extract_line(Position),\n get_file_line(File, LineNumber).\n\nget_file_line(File, LineNumber) when is_integer(LineNumber), LineNumber > 0 ->\n case file:open(File, [read, binary]) of\n {ok, IoDevice} ->\n Line = traverse_file_line(IoDevice, LineNumber),\n ok = file:close(IoDevice),\n Line;\n {error, _} ->\n nil\n end;\nget_file_line(_, _) -> nil.\n\ntraverse_file_line(IoDevice, 1) ->\n case file:read_line(IoDevice) of\n {ok, Line} -> binary:replace(Line, <<\"\\n\">>, <<>>);\n _ -> nil\n end;\ntraverse_file_line(IoDevice, N) ->\n file:read_line(IoDevice),\n traverse_file_line(IoDevice, N - 1).\n\n%% Compilation error/warn handling.\n\n%% Low-level warning, should be used only from Erlang passes.\n-spec erl_warn(location() | none, unicode:chardata(), unicode:chardata()) -> ok.\nerl_warn(none, File, Warning) ->\n erl_warn(0, File, Warning);\nerl_warn(Location, File, Warning) when is_binary(File) ->\n emit_diagnostic(warning, Location, File, Warning, [], [{read_snippet, true}]).\n\n-spec file_warn(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> ok.\nfile_warn(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) ->\n file_warn(Meta, #{file => File}, Module, Desc);\nfile_warn(Meta, E, Module, Desc) when is_list(Meta) ->\n % Skip warnings during bootstrap, they will be reported during recompilation\n case elixir_config:is_bootstrap() of\n true -> ok;\n false ->\n {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, E),\n Message = Module:format_error(Desc),\n emit_diagnostic(warning, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta])\n end.\n\n-spec file_error(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> no_return().\nfile_error(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) ->\n file_error(Meta, #{file => File}, Module, Desc);\nfile_error(Meta, Env, Module, Desc) when is_list(Meta) ->\n print_error(Meta, Env, Module, Desc),\n compile_error(Env).\n\n%% A module error is one where it can continue if there is a module\n%% being compiled. If there is no module, it is a regular file_error.\n-spec module_error(list(), #{file := binary(), module => module() | nil, _ => _}, module(), any()) -> ok.\nmodule_error(Meta, #{module := EnvModule} = Env, Module, Desc) when EnvModule /= nil ->\n print_error(Meta, Env, Module, Desc),\n case elixir_module:taint(EnvModule) of\n true -> ok;\n false -> compile_error(Env)\n end;\nmodule_error(Meta, Env, Module, Desc) ->\n file_error(Meta, Env, Module, Desc).\n\n%% A function error is one where it can continue if there is a function\n%% being compiled. If there is no function, it is falls back to file_error.\n-spec function_error(list(), #{file := binary(), function => {term(), term()} | nil, _ => _}, module(), any()) -> ok.\nfunction_error(Meta, #{function := {_, _}} = Env, Module, Desc) ->\n module_error(Meta, Env, Module, Desc);\nfunction_error(Meta, Env, Module, Desc) ->\n file_error(Meta, Env, Module, Desc).\n\nprint_error(Meta, Env, Module, Desc) ->\n {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, Env),\n Message = Module:format_error(Desc),\n emit_diagnostic(error, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta]),\n ok.\n\n%% Compilation error.\n\n-spec compile_error(#{file := binary(), _ => _}) -> no_return().\n%% We check for the lexical tracker because pry() inside a module\n%% will have the environment but not a tracker.\ncompile_error(#{module := Module, file := File, lexical_tracker := LT}) when Module /= nil, LT /= nil ->\n Inspected = elixir_aliases:inspect(Module),\n Message = io_lib:format(\"cannot compile module ~ts (errors have been logged)\", [Inspected]),\n compile_error([], File, Message);\ncompile_error(#{file := File}) ->\n compile_error([], File, \"cannot compile file (errors have been logged)\").\n\n-spec compile_error(list(), binary(), binary() | unicode:charlist()) -> no_return().\ncompile_error(Meta, File, Message) when is_binary(Message) ->\n {File, Position} = meta_location(Meta, File),\n raise('Elixir.CompileError', Message, [{file, File} | Position]);\ncompile_error(Meta, File, Message) when is_list(Message) ->\n {File, Position} = meta_location(Meta, File),\n raise('Elixir.CompileError', elixir_utils:characters_to_binary(Message), [{file, File} | Position]).\n\n%% Tokenization parsing/errors.\n\n-spec parse_error(elixir:keyword(), binary() | {binary(), binary()},\n binary(), binary(), {unicode:charlist(), integer(), integer()}) -> no_return().\nparse_error(Location, File, Error, <<>>, Input) ->\n Message = case Error of\n <<\"syntax error before: \">> -> <<\"syntax error: expression is incomplete\">>;\n _ -> <>\n end,\n\n raise_snippet(Location, File, Input, 'Elixir.TokenMissingError', Message);\n\n%% Show a nicer message for end of line\nparse_error(Location, File, <<\"syntax error before: \">>, <<\"eol\">>, Input) ->\n raise_snippet(Location, File, Input, 'Elixir.SyntaxError',\n <<\"unexpectedly reached end of line. The current expression is invalid or incomplete\">>);\n\n%% Show a nicer message for keywords pt1 (Erlang keywords show up wrapped in single quotes)\nparse_error(Location, File, <<\"syntax error before: \">>, Keyword, Input)\n when Keyword == <<\"'not'\">>;\n Keyword == <<\"'and'\">>;\n Keyword == <<\"'or'\">>;\n Keyword == <<\"'when'\">>;\n Keyword == <<\"'after'\">>;\n Keyword == <<\"'catch'\">>;\n Keyword == <<\"'end'\">> ->\n raise_reserved(Location, File, Input, binary_part(Keyword, 1, byte_size(Keyword) - 2));\n\n%% Show a nicer message for keywords pt2 (Elixir keywords show up as is)\nparse_error(Location, File, <<\"syntax error before: \">>, Keyword, Input)\n when Keyword == <<\"fn\">>;\n Keyword == <<\"else\">>;\n Keyword == <<\"rescue\">>;\n Keyword == <<\"true\">>;\n Keyword == <<\"false\">>;\n Keyword == <<\"nil\">>;\n Keyword == <<\"in\">> ->\n raise_reserved(Location, File, Input, Keyword);\n\n%% Produce a human-readable message for errors before a sigil\nparse_error(Location, File, <<\"syntax error before: \">>, <<\"{sigil,\", _Rest/binary>> = Full, Input) ->\n {ok, {sigil, _, Atom, [Content | _], _, _, _}} = parse_erl_term(Full),\n Content2 = case is_binary(Content) of\n true -> Content;\n false -> <<>>\n end,\n\n % :static_atoms_encoder might encode :sigil_ atoms as arbitrary terms\n MaybeSigil = case is_atom(Atom) of\n true -> case atom_to_binary(Atom) of\n <<\"sigil_\", Chars/binary>> -> <<\"\\~\", Chars/binary, \" \">>;\n _ -> <<>>\n end;\n false -> <<>>\n end,\n\n Message = <<\"syntax error before: sigil \", MaybeSigil/binary, \"starting with content '\", Content2/binary, \"'\">>,\n raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message);\n\n%% Binaries (and interpolation) are wrapped in [<<...>>]\nparse_error(Location, File, Error, <<\"[\", _/binary>> = Full, Input) when is_binary(Error) ->\n Term = case parse_erl_term(Full) of\n {ok, [H | _]} when is_binary(H) -> <<$\", H/binary, $\">>;\n _ -> <<$\">>\n end,\n raise_snippet(Location, File, Input, 'Elixir.SyntaxError', <>);\n\n%% Given a string prefix and suffix to insert the token inside the error message rather than append it\nparse_error(Location, File, {ErrorPrefix, ErrorSuffix}, Token, Input) when is_binary(ErrorPrefix), is_binary(ErrorSuffix), is_binary(Token) ->\n Message = <>,\n raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message);\n\n%% Misplaced char tokens (for example, {char, _, 97}) are translated by Erlang into\n%% the char literal (i.e., the token in the previous example becomes $a),\n%% because {char, _, _} is a valid Erlang token for an Erlang char literal. We\n%% want to represent that token as ?a in the error, according to the Elixir\n%% syntax.\nparse_error(Location, File, <<\"syntax error before: \">>, <<$$, Char/binary>>, Input) ->\n Message = <<\"syntax error before: ?\", Char/binary>>,\n raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message);\n\n%% Everything else is fine as is\nparse_error(Location, File, Error, Token, Input) when is_binary(Error), is_binary(Token) ->\n Message = <>,\n case lists:keytake(error_type, 1, Location) of\n {value, {error_type, mismatched_delimiter}, Loc} ->\n raise_snippet(Loc, File, Input, 'Elixir.MismatchedDelimiterError', Message);\n _ ->\n raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message)\n end.\n\nparse_erl_term(Term) ->\n case erl_scan:string(binary_to_list(Term)) of\n {ok, Tokens, _} ->\n case erl_parse:parse_term(Tokens ++ [{dot, 1}]) of\n {ok, Parsed} -> {ok, Parsed};\n _ -> error\n end;\n _ -> error\n end.\n\nraise_reserved(Location, File, Input, Keyword) ->\n raise_snippet(Location, File, Input, 'Elixir.SyntaxError',\n <<\"syntax error before: \", Keyword/binary, \". \\\"\", Keyword/binary, \"\\\" is a \"\n \"reserved word in Elixir and therefore its usage is limited. For instance, \"\n \"it can't be used as a variable or be defined nor invoked as a regular function\">>).\n\nraise_snippet(Location, File, Input, Kind, Message) when is_binary(File) ->\n Snippet = cut_snippet(Location, Input),\n raise(Kind, Message, [{file, File}, {snippet, Snippet} | Location]).\n\ncut_snippet(Location, Input) ->\n case lists:keyfind(column, 1, Location) of\n {column, _} ->\n {line, Line} = lists:keyfind(line, 1, Location),\n\n case lists:keyfind(end_line, 1, Location) of\n {end_line, EndLine} ->\n cut_snippet(Input, Line, EndLine - Line + 1);\n\n false ->\n Snippet = cut_snippet(Input, Line, 1),\n case string:trim(Snippet, leading) of\n <<>> -> nil;\n _ -> Snippet\n end\n end;\n\n false ->\n nil\n end.\n\ncut_snippet({InputString, StartLine, StartColumn, Indentation}, Line, Span) ->\n %% In case the code is indented, we need to add the indentation back\n %% for the snippets to match the reported columns.\n Prelude = lists:duplicate(max(StartColumn - Indentation - 1, 0), \" \"),\n Lines = string:split(Prelude ++ InputString, \"\\n\", all),\n Indent = binary:copy(<<\" \">>, Indentation),\n [Head | Tail] = lists:nthtail(Line - StartLine, Lines),\n IndentedTail = indent_n(Tail, Span - 1, <<\"\\n\", Indent/binary>>),\n elixir_utils:characters_to_binary([Indent, Head, IndentedTail]).\n\nindent_n([], _Count, _Indent) -> [];\nindent_n(_Lines, 0, _Indent) -> [];\nindent_n([H | T], Count, Indent) -> [Indent, H | indent_n(T, Count - 1, Indent)].\n\n%% Helpers\n\nprefix(warning) -> highlight(<<\"warning:\">>, warning);\nprefix(error) -> highlight(<<\"error:\">>, error);\nprefix(hint) -> <<\"hint:\">>.\n\nhighlight(Message, Severity) ->\n case {Severity, application:get_env(elixir, ansi_enabled, false)} of\n {warning, true} -> yellow(Message);\n {error, true} -> red(Message);\n _ -> Message\n end.\n\nyellow(Msg) -> [\"\\e[33m\", Msg, \"\\e[0m\"].\nred(Msg) -> [\"\\e[31m\", Msg, \"\\e[0m\"].\n\nenv_format(Meta, #{file := EnvFile} = E) ->\n {File, Position} = meta_location(Meta, EnvFile),\n Line = ?line(Position),\n\n Stacktrace =\n case E of\n #{function := {Name, Arity}, module := Module} ->\n [{Module, Name, Arity, [{file, elixir_utils:relative_to_cwd(File)} | Position ]}];\n #{module := Module} when Module /= nil ->\n [{Module, '__MODULE__', 0, [{file, elixir_utils:relative_to_cwd(File)} | Position]}];\n #{} ->\n []\n end,\n\n case lists:keyfind(column, 1, Position) of\n {column, Column} -> {{Line, Column}, File, Stacktrace};\n _ -> {Line, File, Stacktrace}\n end.\n\n%% We prefer the stacktrace, if available, as it also contains module/function.\nlocation_format(_Position, _File, [E | _]) ->\n 'Elixir.Exception':format_stacktrace_entry(E);\nlocation_format(Position, File, []) ->\n file_format(Position, File).\n\nfile_format({0, _Column}, File) ->\n elixir_utils:relative_to_cwd(File);\nfile_format({Line, nil}, File) ->\n file_format(Line, File);\nfile_format({Line, Column}, File) ->\n io_lib:format(\"~ts:~w:~w\", [elixir_utils:relative_to_cwd(File), Line, Column]);\nfile_format(0, File) ->\n elixir_utils:relative_to_cwd(File);\nfile_format(Line, File) ->\n io_lib:format(\"~ts:~w\", [elixir_utils:relative_to_cwd(File), Line]).\n\nmeta_location(Meta, File) ->\n case elixir_utils:meta_keep(Meta) of\n {F, L} -> {F, [{line, L}]};\n nil -> {File, maybe_add_col([{line, ?line(Meta)}], Meta)}\n end.\n\nmaybe_add_col(Position, Meta) ->\n case lists:keyfind(column, 1, Meta) of\n {column, Col} when is_integer(Col) -> [{column, Col} | Position];\n false -> Position\n end.\n\nraise(Kind, Message, Opts) when is_binary(Message) ->\n Stacktrace = try throw(ok) catch _:_:Stack -> Stack end,\n Exception = Kind:exception([{description, Message} | Opts]),\n erlang:raise(error, Exception, tl(Stacktrace)).\n" }, { "path": "lib/elixir/src/elixir_expand.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_expand).\n-export([expand/3, expand_args/3, expand_arg/3, format_error/1]).\n-import(elixir_errors, [file_error/4, module_error/4, function_error/4]).\n-include(\"elixir.hrl\").\n-define(kernel, 'Elixir.Kernel').\n\n%% =\n\nexpand({'=', Meta, [_, _]} = Expr, S, #{context := match} = E) ->\n elixir_clauses:parallel_match(Meta, Expr, S, E);\n\nexpand({'=', Meta, [Left, Right]}, S, E) ->\n assert_no_guard_scope(Meta, \"=\", S, E),\n {ERight, SR, ER} = expand(Right, S, E),\n {ELeft, SL, EL} = elixir_clauses:match(fun expand/3, Meta, Left, SR, S, ER),\n {{'=', Meta, [ELeft, ERight]}, SL, EL};\n\n%% Literal operators\n\nexpand({'{}', Meta, Args}, S, E) ->\n {EArgs, SA, EA} = expand_args(Args, S, E),\n {{'{}', Meta, EArgs}, SA, EA};\n\nexpand({'%{}', Meta, Args}, S, E) ->\n elixir_map:expand_map(Meta, Args, S, E);\n\nexpand({'%', Meta, [Left, Right]}, S, E) ->\n elixir_map:expand_struct(Meta, Left, Right, S, E);\n\nexpand({'<<>>', Meta, Args}, S, E) ->\n elixir_bitstring:expand(Meta, Args, S, E, false);\n\nexpand({'->', Meta, [_, _]}, _S, E) ->\n file_error(Meta, E, ?MODULE, unhandled_arrow_op);\n\nexpand({'::', Meta, [_, _]}, _S, E) ->\n file_error(Meta, E, ?MODULE, unhandled_type_op);\n\nexpand({'|', Meta, [_, _]}, _S, E) ->\n file_error(Meta, E, ?MODULE, unhandled_cons_op);\n\n%% __block__\n\nexpand({'__block__', _Meta, []}, S, E) ->\n {nil, S, E};\nexpand({'__block__', _Meta, [Arg]}, S, E) ->\n expand(Arg, S, E);\nexpand({'__block__', Meta, Args}, S, E) when is_list(Args) ->\n {EArgs, SA, EA} = expand_block(Args, [], Meta, S, E),\n {{'__block__', Meta, EArgs}, SA, EA};\n\n%% __aliases__\n\nexpand({'__aliases__', _, _} = Alias, S, E) ->\n expand_aliases(Alias, S, E, true);\n\n%% alias\n\nexpand({Kind, Meta, [{{'.', _, [Base, '{}']}, _, Refs} | Rest]}, S, E)\n when Kind == alias; Kind == require; Kind == import ->\n case Rest of\n [] ->\n expand_multi_alias_call(Kind, Meta, Base, Refs, [], S, E);\n [Opts] ->\n lists:keymember(as, 1, Opts) andalso file_error(Meta, E, ?MODULE, as_in_multi_alias_call),\n expand_multi_alias_call(Kind, Meta, Base, Refs, Opts, S, E)\n end;\nexpand({alias, Meta, [Ref]}, S, E) ->\n expand({alias, Meta, [Ref, []]}, S, E);\nexpand({alias, Meta, [Ref, Opts]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"alias\", S, E),\n {ERef, SR, ER} = expand_without_aliases_report(Ref, S, E),\n {EOpts, ST, ET} = expand_opts(Meta, alias, [as, warn], no_alias_opts(Opts), SR, ER),\n\n is_atom(ERef) orelse\n file_error(Meta, E, ?MODULE, {expected_compile_time_module, alias, Ref}),\n\n {ok, New, EQ} = alias(Meta, ERef, true, EOpts, ET),\n\n Quoted =\n case (New /= false) andalso should_warn(Meta, EOpts, EQ) of\n false ->\n ERef;\n\n Pid when ?key(EQ, function) /= nil ->\n ?tracker:warn_alias(Pid, Meta, New, ERef);\n\n Pid ->\n {{'.', Meta, [?tracker, warn_alias]}, Meta, [Pid, Meta, New, ERef]}\n end,\n\n {Quoted, ST, EQ};\n\nexpand({require, Meta, [Ref]}, S, E) ->\n expand({require, Meta, [Ref, []]}, S, E);\nexpand({require, Meta, [Ref, Opts]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"require\", S, E),\n\n {ERef, SR, ER} = expand_without_aliases_report(Ref, S, E),\n {EOpts, ST, ET} = expand_opts(Meta, require, [as, warn], no_alias_opts(Opts), SR, ER),\n\n %% Add the alias to context_modules if defined is set.\n %% This is used by defmodule in order to store the defined\n %% module in context modules.\n case lists:keyfind(defined, 1, Meta) of\n {defined, Mod} when is_atom(Mod) ->\n Mods = [Mod | ?key(ET, context_modules)],\n {ok, _, EU} = alias(Meta, ERef, false, EOpts, ET#{context_modules := Mods}),\n\n SU = case E of\n #{function := nil} -> ST;\n _ -> ST#elixir_ex{runtime_modules=[Mod | ST#elixir_ex.runtime_modules]}\n end,\n\n {ERef, SU, EU};\n\n false when is_atom(ERef) ->\n elixir_aliases:ensure_loaded(Meta, ERef, ET),\n RE = elixir_aliases:require(Meta, ERef, EOpts, ET, true),\n {ok, Alias, EU} = alias(Meta, ERef, false, EOpts, RE),\n\n Quoted =\n case should_warn(Meta, EOpts, EU) of\n false ->\n ERef;\n\n Pid when ?key(EU, function) /= nil ->\n ?tracker:warn_require(Pid, Meta, ERef, Alias);\n\n Pid ->\n {{'.', Meta, [?tracker, warn_require]}, Meta, [Pid, Meta, ERef, Alias]}\n end,\n\n {Quoted, ST, EU};\n\n false ->\n file_error(Meta, E, ?MODULE, {expected_compile_time_module, require, Ref})\n end;\n\nexpand({import, Meta, [Left]}, S, E) ->\n expand({import, Meta, [Left, []]}, S, E);\n\nexpand({import, Meta, [Ref, Opts]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"import\", S, E),\n {ERef, SR, ER} = expand_without_aliases_report(Ref, S, E),\n {EOpts, ST, ET} = expand_opts(Meta, import, [only, except, warn], Opts, SR, ER),\n\n is_atom(ERef) orelse\n file_error(Meta, E, ?MODULE, {expected_compile_time_module, import, Ref}),\n\n elixir_aliases:ensure_loaded(Meta, ERef, ET),\n\n case elixir_import:import(Meta, ERef, EOpts, ET, true, true) of\n {ok, Imported, EI} ->\n Quoted =\n case Imported andalso should_warn(Meta, EOpts, ET) of\n false ->\n ERef;\n\n Pid ->\n Only =\n case lists:keyfind(only, 1, EOpts) of\n {only, List} when is_list(List) -> List;\n _ -> []\n end,\n\n %% If we are outside a function, we turn on the warnings at execution time.\n case ET of\n #{function := nil} ->\n ?tracker:add_import(Pid, ERef, Only, Meta, false),\n {{'.', Meta, [?tracker, warn_import]}, Meta, [Pid, ERef]};\n\n #{} ->\n ?tracker:add_import(Pid, ERef, Only, Meta, true),\n ERef\n end\n end,\n\n {Quoted, ST, EI};\n\n {error, Reason} ->\n elixir_errors:file_error(Meta, E, elixir_import, Reason)\n end;\n\n%% Compilation environment macros\n\nexpand({'__MODULE__', _, Atom}, S, E) when is_atom(Atom) ->\n {?key(E, module), S, E};\nexpand({'__DIR__', _, Atom}, S, E) when is_atom(Atom) ->\n {filename:dirname(?key(E, file)), S, E};\nexpand({'__CALLER__', Meta, Atom} = Caller, S, E) when is_atom(Atom) ->\n assert_no_match_scope(Meta, \"__CALLER__\", E),\n (not S#elixir_ex.caller) andalso function_error(Meta, E, ?MODULE, caller_not_allowed),\n {Caller, S, E};\nexpand({'__STACKTRACE__', Meta, Atom} = Stacktrace, S, E) when is_atom(Atom) ->\n assert_no_match_scope(Meta, \"__STACKTRACE__\", E),\n (not S#elixir_ex.stacktrace) andalso function_error(Meta, E, ?MODULE, stacktrace_not_allowed),\n {Stacktrace, S, E};\nexpand({'__ENV__', Meta, Atom}, S, E) when is_atom(Atom) ->\n assert_no_match_scope(Meta, \"__ENV__\", E),\n {escape_map(escape_env_entries(Meta, S, E)), S, E};\nexpand({{'.', DotMeta, [{'__ENV__', Meta, Atom}, Field]}, CallMeta, []}, S, E)\n when is_atom(Atom), is_atom(Field) ->\n assert_no_match_scope(Meta, \"__ENV__\", E),\n Env = escape_env_entries(Meta, S, E),\n case maps:is_key(Field, Env) of\n true -> {maps:get(Field, Env), S, E};\n false -> {{{'.', DotMeta, [escape_map(Env), Field]}, CallMeta, []}, S, E}\n end;\nexpand({'__cursor__', Meta, Args}, _S, E) when is_list(Args) ->\n file_error(Meta, E, ?MODULE, '__cursor__');\n\n%% Quote\n\nexpand({Unquote, Meta, [_]}, _S, E) when Unquote == unquote; Unquote == unquote_splicing ->\n file_error(Meta, E, ?MODULE, {unquote_outside_quote, Unquote});\n\nexpand({quote, Meta, [Opts]}, S, E) when is_list(Opts) ->\n case lists:keytake(do, 1, Opts) of\n {value, {do, Do}, DoOpts} ->\n expand({quote, Meta, [DoOpts, [{do, Do}]]}, S, E);\n false ->\n file_error(Meta, E, ?MODULE, {missing_option, 'quote', [do]})\n end;\n\nexpand({quote, Meta, [_]}, _S, E) ->\n file_error(Meta, E, ?MODULE, {invalid_args, 'quote'});\n\nexpand({quote, Meta, [Opts, Do]}, S, E) when is_list(Do) ->\n Exprs =\n case lists:keyfind(do, 1, Do) of\n {do, Expr} -> Expr;\n false -> file_error(Meta, E, ?MODULE, {missing_option, 'quote', [do]})\n end,\n\n ValidOpts = [context, location, line, file, unquote, bind_quoted, generated],\n {EOpts, ST, ET} = expand_opts(Meta, quote, ValidOpts, Opts, S, E),\n\n Context = proplists:get_value(context, EOpts, case ?key(E, module) of\n nil -> 'Elixir';\n Mod -> Mod\n end),\n\n {File, Line} = case lists:keyfind(location, 1, EOpts) of\n {location, keep} ->\n {?key(E, file), true};\n false ->\n {proplists:get_value(file, EOpts, nil), proplists:get_value(line, EOpts, false)}\n end,\n\n {Binding, DefaultUnquote} = case lists:keyfind(bind_quoted, 1, EOpts) of\n {bind_quoted, BQ} ->\n case is_list(BQ) andalso\n lists:all(fun({Key, _}) when is_atom(Key) -> true; (_) -> false end, BQ) of\n true -> {BQ, false};\n false -> file_error(Meta, E, ?MODULE, {invalid_bind_quoted_for_quote, BQ})\n end;\n false ->\n {[], true}\n end,\n\n Unquote = proplists:get_value(unquote, EOpts, DefaultUnquote),\n Generated = proplists:get_value(generated, EOpts, false),\n\n {Q, QContext, QPrelude} = elixir_quote:build(Meta, Line, File, Context, Unquote, Generated, ET),\n {EPrelude, SP, EP} = expand(QPrelude, ST, ET),\n {EContext, SC, EC} = expand(QContext, SP, EP),\n Quoted = elixir_quote:quote(Exprs, Q),\n {EQuoted, ES, EQ} = expand(Quoted, SC, EC),\n BindingMeta = lists:keydelete(column, 1, Meta),\n\n EBinding =\n [{'{}', [],\n ['=', [], [\n {'{}', [], [K, BindingMeta, EContext]},\n V\n ]\n ]} || {K, V} <- Binding],\n\n EBindingQuoted =\n case EBinding of\n [] -> EQuoted;\n _ -> {'{}', [], ['__block__', [], EBinding ++ [EQuoted]]}\n end,\n\n case EPrelude of\n [] -> {EBindingQuoted, ES, EQ};\n _ -> {{'__block__', [], EPrelude ++ [EBindingQuoted]}, ES, EQ}\n end;\n\nexpand({quote, Meta, [_, _]}, _S, E) ->\n file_error(Meta, E, ?MODULE, {invalid_args, 'quote'});\n\n%% Functions\n\nexpand({'&', Meta, [{super, SuperMeta, Args} = Expr]}, S, E) when is_list(Args) ->\n assert_no_match_or_guard_scope(Meta, \"&\", S, E),\n\n case resolve_super(Meta, length(Args), E) of\n {Kind, Name, _} when Kind == def; Kind == defp ->\n expand_fn_capture(Meta, {Name, SuperMeta, Args}, S, E);\n _ ->\n expand_fn_capture(Meta, Expr, S, E)\n end;\n\nexpand({'&', Meta, [{'/', ArityMeta, [{super, SuperMeta, Context}, Arity]} = Expr]}, S, E) when is_atom(Context), is_integer(Arity) ->\n assert_no_match_or_guard_scope(Meta, \"&\", S, E),\n\n case resolve_super(Meta, Arity, E) of\n {Kind, Name, _} when Kind == def; Kind == defp ->\n expand({'&', Meta, [{'/', ArityMeta, [{Name, SuperMeta, Context}, Arity]}]}, S, E);\n _ ->\n expand_fn_capture(Meta, Expr, S, E)\n end;\n\nexpand({'&', Meta, [Arg]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"&\", S, E),\n expand_fn_capture(Meta, Arg, S, E);\n\nexpand({fn, Meta, Pairs}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"fn\", S, E),\n elixir_fn:expand(Meta, Pairs, S, E);\n\n%% Case/Receive/Try\n\nexpand({'cond', Meta, [Opts]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"cond\", S, E),\n assert_no_underscore_clause_in_cond(Opts, E),\n {EClauses, SC, EC} = elixir_clauses:'cond'(Meta, Opts, S, E),\n {{'cond', Meta, [EClauses]}, SC, EC};\n\nexpand({'case', Meta, [Expr, Options]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"case\", S, E),\n expand_case(Meta, Expr, Options, S, E);\n\nexpand({'receive', Meta, [Opts]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"receive\", S, E),\n {EClauses, SC, EC} = elixir_clauses:'receive'(Meta, Opts, S, E),\n {{'receive', Meta, [EClauses]}, SC, EC};\n\nexpand({'try', Meta, [Opts]}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"try\", S, E),\n {EClauses, SC, EC} = elixir_clauses:'try'(Meta, Opts, S, E),\n {{'try', Meta, [EClauses]}, SC, EC};\n\n%% Comprehensions\n\nexpand({for, _, [_ | _] } = Expr, S, E) ->\n expand_for(Expr, S, E, true);\n\n%% With\n\nexpand({with, Meta, [_ | _] = Args}, S, E) ->\n assert_no_match_or_guard_scope(Meta, \"with\", S, E),\n elixir_clauses:with(Meta, Args, S, E);\n\n%% Super\n\nexpand({super, Meta, Args}, S, E) when is_list(Args) ->\n assert_no_match_or_guard_scope(Meta, \"super\", S, E),\n Arity = length(Args),\n {Kind, Name, _} = resolve_super(Meta, Arity, E),\n elixir_env:trace({local_function, Meta, Name, Arity}, E),\n {EArgs, SA, EA} = expand_args(Args, S, E),\n {{super, [{super, {Kind, Name}} | Meta], EArgs}, SA, EA};\n\n%% Vars\n\nexpand({'^', Meta, [Arg]}, #elixir_ex{prematch={Prematch, _, _}, vars={_, Write}} = S, E) ->\n NoMatchS = S#elixir_ex{prematch=pin, vars={Prematch, Write}},\n\n case expand(Arg, NoMatchS, E#{context := nil}) of\n {{Name, _, Kind} = Var, #elixir_ex{unused=Unused}, _} when is_atom(Name), is_atom(Kind) ->\n {{'^', Meta, [Var]}, S#elixir_ex{unused=Unused}, E};\n\n _ ->\n function_error(Meta, E, ?MODULE, {invalid_arg_for_pin, Arg}),\n {{'^', Meta, [Arg]}, S#elixir_ex{tainted_function=true}, E}\n end;\nexpand({'^', Meta, [Arg]}, S, E) ->\n function_error(Meta, E, ?MODULE, {pin_outside_of_match, Arg}),\n {{'^', Meta, [Arg]}, S#elixir_ex{tainted_function=true}, E};\n\nexpand({'_', Meta, Kind} = Var, S, #{context := Context} = E) when is_atom(Kind) ->\n case Context of\n match ->\n {Var, S, E};\n _ ->\n function_error(Meta, E, ?MODULE, unbound_underscore),\n {Var, S#elixir_ex{tainted_function=true}, E}\n end;\n\nexpand({Name, Meta, Kind}, S, #{context := match} = E) when is_atom(Name), is_atom(Kind) ->\n #elixir_ex{\n prematch={_, _, PrematchVersion},\n unused={Unused, Version},\n vars={Read, Write}\n } = S,\n\n Pair = {Name, elixir_utils:var_context(Meta, Kind)},\n\n case Read of\n %% Variable was already overridden\n #{Pair := VarVersion} when VarVersion >= PrematchVersion ->\n maybe_warn_underscored_var_repeat(Meta, Name, Kind, E),\n NewUnused = var_used(Pair, Meta, VarVersion, Unused),\n NewWrite = (Write /= false) andalso Write#{Pair => Version},\n Var = {Name, [{version, VarVersion} | Meta], Kind},\n {Var, S#elixir_ex{vars={Read, NewWrite}, unused={NewUnused, Version}}, E};\n\n %% Variable is being overridden now\n #{Pair := _} ->\n NewUnused = var_unused(Pair, Meta, Version, Unused, true),\n NewRead = Read#{Pair => Version},\n NewWrite = (Write /= false) andalso Write#{Pair => Version},\n Var = {Name, [{version, Version} | Meta], Kind},\n {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused={NewUnused, Version + 1}}, E};\n\n %% Variable defined for the first time\n _ ->\n NewUnused = var_unused(Pair, Meta, Version, Unused, false),\n NewRead = Read#{Pair => Version},\n NewWrite = (Write /= false) andalso Write#{Pair => Version},\n Var = {Name, [{version, Version} | Meta], Kind},\n {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused={NewUnused, Version + 1}}, E}\n end;\n\nexpand({Name, Meta, Kind}, S, E) when is_atom(Name), is_atom(Kind) ->\n #elixir_ex{vars={Read, _Write}, unused={Unused, Version}, prematch=Prematch} = S,\n Pair = {Name, elixir_utils:var_context(Meta, Kind)},\n\n Result =\n case Read of\n #{Pair := CurrentVersion} ->\n case Prematch of\n {Pre, _Cycle, {bitsize, Original}} ->\n if\n map_get(Pair, Pre) /= CurrentVersion ->\n {ok, CurrentVersion};\n\n is_map_key(Pair, Pre) ->\n %% TODO: Remove me on Elixir 2.0\n elixir_errors:file_warn(Meta, E, ?MODULE, {unpinned_bitsize_var, Name, Kind}),\n {ok, CurrentVersion};\n\n not is_map_key(Pair, Original) ->\n {ok, CurrentVersion};\n\n true ->\n raise\n end;\n\n _ ->\n {ok, CurrentVersion}\n end;\n\n _ ->\n case E of\n #{context := guard} -> raise;\n #{} when S#elixir_ex.prematch =:= pin -> pin;\n %% TODO: Remove fallback on on_undefined_variable\n _ -> elixir_config:get(on_undefined_variable)\n end\n end,\n\n case Result of\n {ok, PairVersion} ->\n maybe_warn_underscored_var_access(Meta, Name, Kind, E),\n Var = {Name, [{version, PairVersion} | Meta], Kind},\n {Var, S#elixir_ex{unused={var_used(Pair, Meta, PairVersion, Unused), Version}}, E};\n\n Error ->\n case lists:keyfind(if_undefined, 1, Meta) of\n {if_undefined, apply} ->\n expand({Name, Meta, []}, S, E);\n\n %% TODO: Remove this clause on v2.0 as we will raise by default\n {if_undefined, raise} ->\n function_error(Meta, E, ?MODULE, {undefined_var, Name, Kind}),\n {{Name, Meta, Kind}, S#elixir_ex{tainted_function=true}, E};\n\n %% TODO: Remove this clause on v2.0 as we will no longer support warn\n _ when Error == warn ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {undefined_var_to_call, Name}),\n expand({Name, [{if_undefined, warn} | Meta], []}, S, E);\n\n _ when Error == pin ->\n function_error(Meta, E, ?MODULE, {undefined_var_pin, Name, Kind}),\n {{Name, Meta, Kind}, S#elixir_ex{tainted_function=true}, E};\n\n _ when Error == raise ->\n SpanMeta = elixir_env:calculate_span(Meta, Name),\n function_error(SpanMeta, E, ?MODULE, {undefined_var, Name, Kind}),\n {{Name, SpanMeta, Kind}, S#elixir_ex{tainted_function=true}, E}\n end\n end;\n\n%% Local calls\n\nexpand({Atom, Meta, Args}, S, E) when is_atom(Atom), is_list(Meta), is_list(Args) ->\n assert_no_ambiguous_op(Atom, Meta, Args, S, E),\n\n elixir_dispatch:dispatch_import(Meta, Atom, Args, S, E, fun\n ({AR, AF}) ->\n expand_remote(AR, Meta, AF, Meta, Args, S, elixir_env:prepare_write(S, E), E);\n\n (local) ->\n expand_local(Meta, Atom, Args, S, E)\n end);\n\n%% Remote calls\n\nexpand({{'.', DotMeta, [Left, Right]}, Meta, Args}, S, E)\n when (is_tuple(Left) orelse is_atom(Left)), is_atom(Right), is_list(Meta), is_list(Args) ->\n {ELeft, SL, EL} = expand(Left, elixir_env:prepare_write(S, E), E),\n\n elixir_dispatch:dispatch_require(Meta, ELeft, Right, Args, S, EL, fun(AR, AF) ->\n expand_remote(AR, DotMeta, AF, Meta, Args, S, SL, EL)\n end);\n\n%% Anonymous calls\n\nexpand({{'.', DotMeta, [Expr]}, Meta, Args}, S, E) when is_list(Args) ->\n assert_no_match_or_guard_scope(Meta, \"anonymous call\", S, E),\n {[EExpr | EArgs], SA, EA} = expand_args([Expr | Args], S, E),\n {{{'.', DotMeta, [EExpr]}, Meta, EArgs}, SA, EA};\n\n%% Invalid calls\n\nexpand({_, Meta, Args} = Invalid, _S, E) when is_list(Meta) and is_list(Args) ->\n file_error(Meta, E, ?MODULE, {invalid_call, Invalid});\n\n%% Literals\n\nexpand({Left, Right}, S, E) ->\n {[ELeft, ERight], SE, EE} = expand_args([Left, Right], S, E),\n {{ELeft, ERight}, SE, EE};\n\nexpand(List, S, #{context := match} = E) when is_list(List) ->\n expand_list(List, fun expand/3, S, E, []);\n\nexpand(List, S, E) when is_list(List) ->\n {EArgs, {SE, _}, EE} =\n expand_list(List, fun expand_arg/3, {elixir_env:prepare_write(S), S}, E, []),\n\n {EArgs, elixir_env:close_write(SE, S), EE};\n\nexpand(Zero, S, #{context := match} = E) when is_float(Zero), Zero == 0.0 ->\n elixir_errors:file_warn([], E, ?MODULE, invalid_match_on_zero_float),\n {Zero, S, E};\n\nexpand(Other, S, E) when is_number(Other); is_atom(Other); is_binary(Other) ->\n {Other, S, E};\n\nexpand(Function, S, E) when is_function(Function) ->\n case (erlang:fun_info(Function, type) == {type, external}) andalso\n (erlang:fun_info(Function, env) == {env, []}) of\n true ->\n {elixir_quote:fun_to_quoted(Function), S, E};\n false ->\n file_error([{line, 0}], ?key(E, file), ?MODULE, {invalid_quoted_expr, Function})\n end;\n\nexpand(Pid, S, E) when is_pid(Pid) ->\n case ?key(E, function) of\n nil ->\n {Pid, S, E};\n Function ->\n %% TODO: Make me an error on v2.0\n elixir_errors:file_warn([], E, ?MODULE, {invalid_pid_in_function, Pid, Function}),\n {Pid, S, E}\n end;\n\nexpand(Other, _S, E) ->\n file_error([{line, 0}], ?key(E, file), ?MODULE, {invalid_quoted_expr, Other}).\n\n%% Helpers\n\nescape_env_entries(Meta, #elixir_ex{vars={Read, _}}, Env0) ->\n Env1 = case Env0 of\n #{function := nil} -> Env0;\n _ -> Env0#{lexical_tracker := nil, tracers := []}\n end,\n\n Env1#{versioned_vars := escape_map(Read), line := ?line(Meta)}.\n\nescape_map(Map) -> {'%{}', [], lists:sort(maps:to_list(Map))}.\n\nexpand_multi_alias_call(Kind, Meta, Base, Refs, Opts, S, E) ->\n {BaseRef, SB, EB} = expand_without_aliases_report(Base, S, E),\n\n case is_atom(BaseRef) of\n true ->\n Fun = fun\n ({'__aliases__', _, Ref}, SR, ER) ->\n expand({Kind, Meta, [elixir_aliases:concat([BaseRef | Ref]), Opts]}, SR, ER);\n\n (Ref, SR, ER) when is_atom(Ref) ->\n expand({Kind, Meta, [elixir_aliases:concat([BaseRef, Ref]), Opts]}, SR, ER);\n\n (Other, _SR, _ER) ->\n file_error(Meta, E, ?MODULE, {expected_compile_time_module, Kind, Other})\n end,\n\n mapfold(Fun, SB, EB, Refs);\n\n false ->\n file_error(Meta, E, ?MODULE, {invalid_alias, Base})\n end.\n\nresolve_super(Meta, Arity, E) ->\n Module = assert_module_scope(Meta, super, E),\n Function = assert_function_scope(Meta, super, E),\n\n case Function of\n {_, Arity} ->\n {Kind, Name, SuperMeta} = elixir_overridable:super(Meta, Module, Function, E),\n maybe_warn_deprecated_super_in_gen_server_callback(Meta, Function, SuperMeta, E),\n {Kind, Name, SuperMeta};\n\n _ ->\n file_error(Meta, E, ?MODULE, wrong_number_of_args_for_super)\n end.\n\nexpand_fn_capture(Meta, Arg, S, E) ->\n case elixir_fn:capture(Meta, Arg, S, E) of\n {{remote, Remote, Fun, Arity}, RequireMeta, DotMeta, SE, EE} ->\n AttachedMeta = attach_runtime_module(Remote, RequireMeta, S, E),\n {{'&', Meta, [{'/', [], [{{'.', DotMeta, [Remote, Fun]}, AttachedMeta, []}, Arity]}]}, SE, EE};\n {{local, Fun, Arity}, _, _, _SE, #{function := nil}} ->\n file_error(Meta, E, ?MODULE, {undefined_local_capture, Fun, Arity});\n {{local, Fun, Arity}, LocalMeta, _, SE, EE} ->\n {{'&', Meta, [{'/', [], [{Fun, LocalMeta, nil}, Arity]}]}, SE, EE};\n {expand, Expr, SE, EE} ->\n expand(Expr, SE, EE)\n end.\n\nexpand_list([{'|', Meta, [_, _] = Args}], Fun, S, E, List) ->\n {EArgs, SAcc, EAcc} = mapfold(Fun, S, E, Args),\n expand_list([], Fun, SAcc, EAcc, [{'|', Meta, EArgs} | List]);\nexpand_list([H | T], Fun, S, E, List) ->\n {EArg, SAcc, EAcc} = Fun(H, S, E),\n expand_list(T, Fun, SAcc, EAcc, [EArg | List]);\nexpand_list([], _Fun, S, E, List) ->\n {lists:reverse(List), S, E}.\n\nexpand_block([], Acc, _Meta, S, E) ->\n {lists:reverse(Acc), S, E};\nexpand_block([H], Acc, Meta, S, E) ->\n {EH, SE, EE} = expand(H, S, E),\n expand_block([], [EH | Acc], Meta, SE, EE);\nexpand_block([{for, _, [_ | _]} = H | T], Acc, Meta, S, E) ->\n {EH, SE, EE} = expand_for(H, S, E, false),\n expand_block(T, [EH | Acc], Meta, SE, EE);\nexpand_block([{'=', _, [{'_', _, Ctx}, {for, _, [_ | _]} = H]} | T], Acc, Meta, S, E) when is_atom(Ctx) ->\n {EH, SE, EE} = expand_for(H, S, E, false),\n expand_block(T, [EH | Acc], Meta, SE, EE);\nexpand_block([H | T], Acc, Meta, S, E) ->\n {EH, SE, EE} = expand(H, S, E),\n\n %% Note that checks rely on the code BEFORE expansion\n %% instead of relying on Erlang checks.\n %%\n %% That's because expansion may generate useless\n %% terms on their own (think compile time removed\n %% logger calls) and we don't want to catch those.\n %%\n %% Or, similarly, the work is all in the expansion\n %% (for example, to register something) and it is\n %% simply returning something as replacement.\n case is_useless_building(H, EH, Meta) of\n {UselessMeta, UselessTerm} ->\n elixir_errors:file_warn(UselessMeta, E, ?MODULE, UselessTerm);\n\n false ->\n ok\n end,\n\n expand_block(T, [EH | Acc], Meta, SE, EE).\n\n%% Note that we don't handle atoms on purpose. They are common\n%% when unquoting AST and it is unlikely that we would catch\n%% bugs as we don't do binary operations on them like in\n%% strings or numbers.\nis_useless_building(H, _, Meta) when is_binary(H); is_number(H) ->\n {Meta, {useless_literal, H}};\nis_useless_building({'@', Meta, [{Var, _, Ctx}]}, _, _) when is_atom(Ctx); Ctx == [] ->\n {Meta, {useless_attr, Var}};\nis_useless_building({Var, Meta, Ctx}, {Var, _, Ctx}, _) when is_atom(Ctx) ->\n {Meta, {useless_var, Var}};\nis_useless_building(_, _, _) ->\n false.\n\n%% Variables in arguments are not propagated from one\n%% argument to the other. For instance:\n%%\n%% x = 1\n%% foo(x = x + 2, x)\n%% x\n%%\n%% Should be the same as:\n%%\n%% foo(3, 1)\n%% 3\n%%\n%% However, lexical information is.\nexpand_arg(Arg, Acc, E) when is_number(Arg); is_atom(Arg); is_binary(Arg); is_pid(Arg) ->\n {Arg, Acc, E};\nexpand_arg(Arg, {Acc, S}, E) ->\n {EArg, SAcc, EAcc} = expand(Arg, elixir_env:reset_read(Acc, S), E),\n {EArg, {SAcc, S}, EAcc}.\n\nexpand_args([Arg], S, E) ->\n {EArg, SE, EE} = expand(Arg, S, E),\n {[EArg], SE, EE};\nexpand_args(Args, S, #{context := match} = E) ->\n mapfold(fun expand/3, S, E, Args);\nexpand_args(Args, S, E) ->\n {EArgs, {SA, _}, EA} = mapfold(fun expand_arg/3, {elixir_env:prepare_write(S), S}, E, Args),\n {EArgs, elixir_env:close_write(SA, S), EA}.\n\nmapfold(Fun, S, E, List) ->\n mapfold(Fun, S, E, List, []).\n\nmapfold(Fun, S, E, [H | T], Acc) ->\n {RH, RS, RE} = Fun(H, S, E),\n mapfold(Fun, RS, RE, T, [RH | Acc]);\nmapfold(_Fun, S, E, [], Acc) ->\n {lists:reverse(Acc), S, E}.\n\n%% Match/var helpers\n\nvar_unused({_, Kind} = Pair, Meta, Version, Unused, Override) ->\n case (Kind == nil) andalso should_warn(Meta) of\n true -> Unused#{{Pair, Version} => {Meta, Override}};\n false -> Unused\n end.\n\nvar_used({_, Kind} = Pair, Meta, Version, Unused) ->\n KeepUnused = lists:keymember(keep_unused, 1, Meta),\n\n if\n KeepUnused -> Unused;\n is_atom(Kind) -> Unused#{{Pair, Version} => false};\n true -> Unused\n end.\n\nmaybe_warn_underscored_var_repeat(Meta, Name, Kind, E) ->\n case should_warn(Meta) andalso atom_to_list(Name) of\n \"_\" ++ _ ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {underscored_var_repeat, Name, Kind});\n _ ->\n ok\n end.\n\nmaybe_warn_underscored_var_access(Meta, Name, Kind, E) ->\n case (Kind == nil) andalso should_warn(Meta) andalso atom_to_list(Name) of\n \"_\" ++ _ ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {underscored_var_access, Name});\n _ ->\n ok\n end.\n\n%% TODO: Remove this on Elixir v2.0 and make all GenServer callbacks optional\nmaybe_warn_deprecated_super_in_gen_server_callback(Meta, Function, SuperMeta, E) ->\n case lists:keyfind(context, 1, SuperMeta) of\n {context, 'Elixir.GenServer'} ->\n case Function of\n {child_spec, 1} ->\n ok;\n\n _ ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {super_in_genserver, Function})\n end;\n\n _ ->\n ok\n end.\n\nshould_warn(Meta) ->\n lists:keyfind(generated, 1, Meta) /= {generated, true}.\n\n%% Case\n\nexpand_case(Meta, Expr, Opts, S, E) ->\n {EExpr, SE, EE} = expand(Expr, S, E),\n\n ROpts =\n case lists:member({optimize_boolean, true}, Meta) andalso elixir_utils:returns_boolean(EExpr) of\n true -> rewrite_case_clauses(Opts);\n false -> Opts\n end,\n\n {EOpts, SO, EO} = elixir_clauses:'case'(Meta, ROpts, SE, EE),\n {{'case', Meta, [EExpr, EOpts]}, SO, EO}.\n\nrewrite_case_clauses([{do, [\n {'->', FalseMeta, [\n [{'when', _, [{Var, _, ?kernel}, {{'.', _, ['erlang', 'orelse']}, _, [\n {{'.', _, ['erlang', '=:=']}, _, [{Var, _, ?kernel}, false]},\n {{'.', _, ['erlang', '=:=']}, _, [{Var, _, ?kernel}, nil]}\n ]}]}],\n FalseExpr\n ]},\n {'->', TrueMeta, [\n [{'_', _, _}],\n TrueExpr\n ]}\n]}]) ->\n rewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr);\n\nrewrite_case_clauses([{do, [\n {'->', FalseMeta, [[false], FalseExpr]},\n {'->', TrueMeta, [[true], TrueExpr]} | _\n]}]) ->\n rewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr);\n\nrewrite_case_clauses(Opts) ->\n Opts.\n\nrewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr) ->\n [{do, [\n {'->', FalseMeta, [[false], FalseExpr]},\n {'->', TrueMeta, [[true], TrueExpr]}\n ]}].\n\n%% Comprehensions\n\nexpand_for({for, Meta, [_ | _] = Args}, S, E, Return) ->\n assert_no_match_or_guard_scope(Meta, \"for\", S, E),\n {Cases, Block} = elixir_utils:split_opts(Args),\n validate_opts(Meta, for, [do, into, uniq, reduce], Block, E),\n\n {Expr, Opts} =\n case lists:keytake(do, 1, Block) of\n {value, {do, Do}, DoOpts} ->\n {Do, DoOpts};\n false ->\n file_error(Meta, E, ?MODULE, {missing_option, for, [do]})\n end,\n\n {EOpts, SO, EO} = expand(Opts, elixir_env:reset_unused_vars(S), E),\n {ECases, SC, EC} = mapfold(fun expand_for_generator/3, SO, EO, Cases),\n assert_generator_start(Meta, ECases, E),\n\n {{EExpr, SE, EE}, NormalizedOpts} =\n case validate_for_options(EOpts, false, false, false, Return, Meta, E, []) of\n {ok, MaybeReduce, NOpts} -> {expand_for_do_block(Meta, Expr, SC, EC, MaybeReduce), NOpts};\n {error, Error} -> {file_error(Meta, E, ?MODULE, Error), EOpts}\n end,\n\n {{for, Meta, ECases ++ [[{do, EExpr} | NormalizedOpts]]},\n elixir_env:merge_and_check_unused_vars(SE, S, EE),\n E}.\n\nvalidate_for_options([{into, _} = Pair | Opts], _Into, Uniq, Reduce, Return, Meta, E, Acc) ->\n validate_for_options(Opts, Pair, Uniq, Reduce, Return, Meta, E, [Pair | Acc]);\nvalidate_for_options([{uniq, Boolean} = Pair | Opts], Into, _Uniq, Reduce, Return, Meta, E, Acc) when is_boolean(Boolean) ->\n validate_for_options(Opts, Into, Pair, Reduce, Return, Meta, E, [Pair | Acc]);\nvalidate_for_options([{uniq, Value} | _], _, _, _, _, _, _, _) ->\n {error, {for_invalid_uniq, Value}};\nvalidate_for_options([{reduce, _} = Pair | Opts], Into, Uniq, _Reduce, Return, Meta, E, Acc) ->\n validate_for_options(Opts, Into, Uniq, Pair, Return, Meta, E, [Pair | Acc]);\nvalidate_for_options([], Into, Uniq, {reduce, _}, _Return, _Meta, _E, _Acc) when Into /= false; Uniq /= false ->\n {error, for_conflicting_reduce_into_uniq};\nvalidate_for_options([], _Into = false, Uniq, Reduce = false, Return = true, Meta, E, Acc) ->\n Pair = {into, []},\n validate_for_options([Pair], Pair, Uniq, Reduce, Return, Meta, E, Acc);\nvalidate_for_options([], Into = false, {uniq, true}, Reduce = false, Return = false, Meta, E, Acc) ->\n elixir_errors:file_warn(Meta, E, ?MODULE, for_with_unused_uniq),\n AccWithoutUniq = lists:keydelete(uniq, 1, Acc),\n validate_for_options([], Into, false, Reduce, Return, Meta, E, AccWithoutUniq);\nvalidate_for_options([], _Into, _Uniq, Reduce, _Return, _Meta, _E, Acc) ->\n {ok, Reduce, lists:reverse(Acc)}.\n\nexpand_for_do_block(Meta, [{'->', _, _} | _], _S, E, false) ->\n file_error(Meta, E, ?MODULE, for_without_reduce_bad_block);\nexpand_for_do_block(_Meta, Expr, S, E, false) ->\n expand(Expr, S, E);\nexpand_for_do_block(Meta, [{'->', _, _} | _] = Clauses, S, E, {reduce, _}) ->\n Transformer = fun\n ({_, _, [[{'when', _, [_, _, _ | _]}], _]}, _) ->\n file_error(Meta, E, ?MODULE, for_with_reduce_bad_block);\n\n ({_, _, [[_], _]} = Clause, SA) ->\n SReset = elixir_env:reset_unused_vars(SA),\n\n {EClause, SAcc, EAcc} =\n elixir_clauses:clause(Meta, fn, fun elixir_clauses:head/4, Clause, SReset, E),\n\n {EClause, elixir_env:merge_and_check_unused_vars(SAcc, SA, EAcc)};\n\n (_, _) ->\n file_error(Meta, E, ?MODULE, for_with_reduce_bad_block)\n end,\n\n {Do, SA} = lists:mapfoldl(Transformer, S, Clauses),\n {Do, SA, E};\nexpand_for_do_block(Meta, _Expr, _S, E, {reduce, _}) ->\n file_error(Meta, E, ?MODULE, for_with_reduce_bad_block).\n\n%% Locals\n\nassert_no_ambiguous_op(Name, Meta, [Arg], S, E) ->\n case lists:keyfind(ambiguous_op, 1, Meta) of\n {ambiguous_op, Kind} ->\n Pair = {Name, Kind},\n case S#elixir_ex.vars of\n {#{Pair := _}, _} ->\n file_error(Meta, E, ?MODULE, {op_ambiguity, Name, Arg});\n _ ->\n ok\n end;\n _ ->\n ok\n end;\nassert_no_ambiguous_op(_Atom, _Meta, _Args, _S, _E) ->\n ok.\n\nexpand_local(Meta, Name, Args, S, #{function := Function, context := Context} = E)\n when Function /= nil ->\n %% In case we have the wrong context, we log a module error\n %% so we can print multiple entries at the same time.\n case Context of\n match ->\n module_error(Meta, E, ?MODULE, {invalid_local_invocation, \"match\", {Name, Meta, Args}});\n\n guard ->\n module_error(Meta, E, ?MODULE, {invalid_local_invocation, elixir_utils:guard_info(S), {Name, Meta, Args}});\n\n nil ->\n elixir_env:trace({local_function, Meta, Name, length(Args)}, E)\n end,\n\n {EArgs, SA, EA} = expand_args(Args, S, E),\n {{Name, Meta, EArgs}, SA, EA};\nexpand_local(Meta, Name, Args, _S, #{function := nil} = E) ->\n file_error(Meta, E, ?MODULE, {undefined_function, Name, Args}).\n\n%% Remote\n\nexpand_remote(Receiver, DotMeta, Right, Meta, Args, S, SL, #{context := Context} = E)\n when is_atom(Receiver) or is_tuple(Receiver) ->\n if\n Context =:= guard, is_tuple(Receiver) ->\n (lists:keyfind(no_parens, 1, Meta) /= {no_parens, true}) andalso\n function_error(Meta, E, ?MODULE, {parens_map_lookup, Receiver, Right, elixir_utils:guard_info(S)}),\n\n {{{'.', DotMeta, [Receiver, Right]}, Meta, []}, SL, E};\n\n Context =:= nil ->\n AttachedMeta = attach_runtime_module(Receiver, Meta, S, E),\n {EArgs, {SA, _}, EA} = mapfold(fun expand_arg/3, {SL, S}, E, Args),\n\n SA#elixir_ex.tainted_function andalso is_atom(Receiver) andalso\n (not is_loaded_and_exported(Receiver, Right, Args)) andalso\n elixir_errors:file_warn(Meta, E, ?MODULE, {undefined_function, Receiver, Right, length(Args)}),\n\n Rewritten = elixir_rewrite:rewrite(Receiver, DotMeta, Right, AttachedMeta, EArgs),\n {Rewritten, elixir_env:close_write(SA, S), EA};\n\n true ->\n case {Receiver, Right, Args} of\n {erlang, '+', [Arg]} when is_number(Arg) -> {+Arg, SL, E};\n {erlang, '-', [Arg]} when is_number(Arg) -> {-Arg, SL, E};\n _ ->\n {EArgs, SA, EA} = mapfold(fun expand/3, SL, E, Args),\n\n case elixir_rewrite:Context(Receiver, DotMeta, Right, Meta, EArgs, S) of\n {ok, Rewritten} -> {Rewritten, SA, EA};\n {error, Error} -> file_error(Meta, E, elixir_rewrite, Error)\n end\n end\n end;\nexpand_remote(Receiver, DotMeta, Right, Meta, Args, _, _, E) ->\n Call = {{'.', DotMeta, [Receiver, Right]}, Meta, Args},\n file_error(Meta, E, ?MODULE, {invalid_call, Call}).\n\nis_loaded_and_exported(Receiver, Fun, Args) ->\n (code:ensure_loaded(Receiver) =:= {module, Receiver}) andalso\n erlang:function_exported(Receiver, Fun, length(Args)).\n\nattach_runtime_module(Receiver, Meta, S, _E) ->\n case lists:member(Receiver, S#elixir_ex.runtime_modules) of\n true -> [{runtime_module, true} | Meta];\n false -> Meta\n end.\n\n%% Lexical helpers\n\nexpand_opts(Meta, Kind, Allowed, Opts, S, E) ->\n {EOpts, SE, EE} = expand(Opts, S, E),\n validate_opts(Meta, Kind, Allowed, EOpts, EE),\n {EOpts, SE, EE}.\n\nvalidate_opts(Meta, Kind, Allowed, Opts, E) when is_list(Opts) ->\n [begin\n file_error(Meta, E, ?MODULE, {unsupported_option, Kind, Key})\n end || {Key, _} <- Opts, not lists:member(Key, Allowed)];\n\nvalidate_opts(Meta, Kind, _Allowed, Opts, E) ->\n file_error(Meta, E, ?MODULE, {options_are_not_keyword, Kind, Opts}).\n\nno_alias_opts(Opts) when is_list(Opts) ->\n case lists:keyfind(as, 1, Opts) of\n {as, As} -> lists:keystore(as, 1, Opts, {as, no_alias_expansion(As)});\n false -> Opts\n end;\nno_alias_opts(Opts) -> Opts.\n\nno_alias_expansion({'__aliases__', _, [H | T]}) when is_atom(H) ->\n elixir_aliases:concat([H | T]);\nno_alias_expansion(Other) ->\n Other.\n\nshould_warn(_Meta, _Opts, #{lexical_tracker := nil}) ->\n false;\nshould_warn(Meta, Opts, #{lexical_tracker := Pid}) ->\n case lists:keyfind(warn, 1, Opts) of\n {warn, false} -> false;\n {warn, true} -> Pid;\n false ->\n case lists:keymember(context, 1, Meta) of\n true -> false;\n false -> Pid\n end\n end.\n\n%% Aliases\n\nalias(Meta, Ref, IncludeByDefault, Opts, E) ->\n case elixir_aliases:alias(Meta, Ref, IncludeByDefault, Opts, E, true) of\n {ok, New, EA} -> {ok, New, EA};\n {error, Reason} -> elixir_errors:file_error(Meta, E, elixir_aliases, Reason)\n end.\n\nexpand_without_aliases_report({'__aliases__', _, _} = Alias, S, E) ->\n expand_aliases(Alias, S, E, false);\nexpand_without_aliases_report(Other, S, E) ->\n expand(Other, S, E).\n\nexpand_aliases({'__aliases__', Meta, List} = Alias, S, E, Report) ->\n case elixir_aliases:expand_or_concat(Meta, List, E, true) of\n Receiver when is_atom(Receiver) ->\n if\n Receiver =:= 'Elixir.True'; Receiver =:= 'Elixir.False'; Receiver =:= 'Elixir.Nil' ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {commonly_mistaken_alias, Receiver});\n true ->\n ok\n end,\n Report andalso elixir_env:trace({alias_reference, Meta, Receiver}, E),\n {Receiver, S, E};\n\n [Head | Tail] ->\n {EHead, SA, EA} = expand(Head, S, E),\n\n case is_atom(EHead) of\n true ->\n Receiver = elixir_aliases:concat([EHead | Tail]),\n Report andalso elixir_env:trace({alias_reference, Meta, Receiver}, E),\n {Receiver, SA, EA};\n\n false ->\n file_error(Meta, E, ?MODULE, {invalid_alias, Alias})\n end\n end.\n\n%% Comprehensions\n\nexpand_for_generator({'<-', Meta, [Left, Right]}, S, E) ->\n {ERight, SR, ER} = expand(Right, S, E),\n SM = elixir_env:reset_read(SR, S),\n {[ELeft], SL, EL} = elixir_clauses:head(Meta, [Left], SM, ER),\n {{'<-', Meta, [ELeft, ERight]}, SL, EL};\nexpand_for_generator({'<<>>', Meta, Args} = X, S, E) when is_list(Args) ->\n case elixir_utils:split_last(Args) of\n {LeftStart, {'<-', OpMeta, [LeftEnd, Right]}} ->\n {ERight, SR, ER} = expand(Right, S, E),\n SM = elixir_env:reset_read(SR, S),\n {ELeft, SL, EL} = elixir_clauses:match(fun(BArg, BS, BE) ->\n elixir_bitstring:expand(Meta, BArg, BS, BE, true)\n end, Meta, LeftStart ++ [LeftEnd], SM, SM, ER),\n {{'<<>>', Meta, [{'<-', OpMeta, [ELeft, ERight]}]}, SL, EL};\n _ ->\n expand(X, S, E)\n end;\nexpand_for_generator(X, S, E) ->\n expand(X, S, E).\n\nassert_generator_start(_, [{'<-', _, [_, _]} | _], _) ->\n ok;\nassert_generator_start(_, [{'<<>>', _, [{'<-', _, [_, _]}]} | _], _) ->\n ok;\nassert_generator_start(Meta, _, E) ->\n elixir_errors:file_error(Meta, E, ?MODULE, for_generator_start).\n\n%% Assertions\n\nassert_module_scope(Meta, Kind, #{module := nil, file := File}) ->\n file_error(Meta, File, ?MODULE, {invalid_expr_in_scope, \"module\", Kind});\nassert_module_scope(_Meta, _Kind, #{module:=Module}) -> Module.\n\nassert_function_scope(Meta, Kind, #{function := nil, file := File}) ->\n file_error(Meta, File, ?MODULE, {invalid_expr_in_scope, \"function\", Kind});\nassert_function_scope(_Meta, _Kind, #{function := Function}) -> Function.\n\nassert_no_match_or_guard_scope(Meta, Kind, S, E) ->\n assert_no_match_scope(Meta, Kind, E),\n assert_no_guard_scope(Meta, Kind, S, E).\nassert_no_match_scope(Meta, Kind, #{context := match, file := File}) ->\n file_error(Meta, File, ?MODULE, {invalid_pattern_in_match, Kind});\nassert_no_match_scope(_Meta, _Kind, _E) -> ok.\nassert_no_guard_scope(Meta, Kind, S, #{context := guard, file := File}) ->\n Key =\n case S of\n #elixir_ex{prematch={_, _, {bitsize, _}}} -> invalid_expr_in_bitsize;\n _ -> invalid_expr_in_guard\n end,\n file_error(Meta, File, ?MODULE, {Key, Kind});\nassert_no_guard_scope(_Meta, _Kind, _S, _E) -> ok.\n\n%% Here we look into the Clauses \"optimistically\", that is, we don't check for\n%% multiple \"do\"s and similar stuff. After all, the error we're gonna give here\n%% is just a friendlier version of the \"undefined variable _\" error that we\n%% would raise if we found a \"_ -> ...\" clause in a \"cond\". For this reason, if\n%% Clauses has a bad shape, we just do nothing and let future functions catch\n%% this.\nassert_no_underscore_clause_in_cond([{do, Clauses}], E) when is_list(Clauses) ->\n case lists:last(Clauses) of\n {'->', Meta, [[{'_', _, Atom}], _]} when is_atom(Atom) ->\n file_error(Meta, E, ?MODULE, underscore_in_cond);\n _Other ->\n ok\n end;\nassert_no_underscore_clause_in_cond(_Other, _E) ->\n ok.\n\n%% Errors\n\nformat_error({undefined_function, Module, Fun, Arity}) ->\n Opts = [{module, Module}, {function, Fun}, {arity, Arity}],\n Exception = 'Elixir.UndefinedFunctionError':exception(Opts),\n {BlamedException, _} = 'Elixir.UndefinedFunctionError':blame(Exception, []),\n 'Elixir.UndefinedFunctionError':message(BlamedException);\nformat_error(invalid_match_on_zero_float) ->\n \"pattern matching on 0.0 is equivalent to matching only on +0.0. Instead you must match on +0.0 or -0.0\";\nformat_error({useless_literal, Term}) ->\n io_lib:format(\"code block contains unused literal ~ts \"\n \"(remove the literal or assign it to _ to avoid warnings)\",\n ['Elixir.Macro':to_string(Term)]);\nformat_error({useless_var, Var}) ->\n io_lib:format(\"variable ~ts in code block has no effect as it is never returned \"\n \"(remove the variable or assign it to _ to avoid warnings)\",\n [Var]);\nformat_error({useless_attr, Attr}) ->\n io_lib:format(\"module attribute @~ts in code block has no effect as it is never returned \"\n \"(remove the attribute or assign it to _ to avoid warnings)\",\n [Attr]);\nformat_error({missing_option, Construct, Opts}) when is_list(Opts) ->\n StringOpts = lists:map(fun(Opt) -> [$: | atom_to_list(Opt)] end, Opts),\n io_lib:format(\"missing ~ts option in \\\"~ts\\\"\", [string:join(StringOpts, \"/\"), Construct]);\nformat_error({invalid_args, Construct}) ->\n io_lib:format(\"invalid arguments for \\\"~ts\\\"\", [Construct]);\nformat_error({for_invalid_uniq, Value}) ->\n io_lib:format(\":uniq option for comprehensions only accepts a boolean, got: ~ts\", ['Elixir.Macro':to_string(Value)]);\nformat_error(for_conflicting_reduce_into_uniq) ->\n \"cannot use :reduce alongside :into/:uniq in comprehension\";\nformat_error(for_with_reduce_bad_block) ->\n \"when using :reduce with comprehensions, the do block must be written using acc -> expr clauses, where each clause expects the accumulator as a single argument\";\nformat_error(for_without_reduce_bad_block) ->\n \"the do block was written using acc -> expr clauses but the :reduce option was not given\";\nformat_error(for_generator_start) ->\n \"for comprehensions must start with a generator\";\nformat_error(for_with_unused_uniq) ->\n \"the :uniq option has no effect since the result of the for comprehension is not used\";\nformat_error(unhandled_arrow_op) ->\n \"misplaced operator ->\\n\\n\"\n \"This typically means invalid syntax or a macro is not available in scope\";\nformat_error(unhandled_cons_op) ->\n \"misplaced operator |/2\\n\\n\"\n \"The | operator is typically used between brackets to mark the tail of a list:\\n\\n\"\n \" [head | tail]\\n\"\n \" [head, middle, ... | tail]\\n\\n\"\n \"It is also used to update maps and structs, via the %{map | key: value} notation, \"\n \"and in typespecs, such as @type and @spec, to express the union of two types\";\nformat_error(unhandled_type_op) ->\n \"misplaced operator ::/2\\n\\n\"\n \"The :: operator is typically used in bitstrings to specify types and sizes of segments:\\n\\n\"\n \" <>\\n\\n\"\n \"It is also used in typespecs, such as @type and @spec, to describe inputs and outputs\";\nformat_error(as_in_multi_alias_call) ->\n \":as option is not supported by multi-alias call\";\nformat_error({commonly_mistaken_alias, Ref}) ->\n Module = 'Elixir.Macro':to_string(Ref),\n io_lib:format(\"reserved alias \\\"~ts\\\" expands to the atom :\\\"Elixir.~ts\\\". Perhaps you meant to write \\\"~ts\\\" instead?\", [Module, Module, string:casefold(Module)]);\nformat_error({expected_compile_time_module, Kind, GivenTerm}) ->\n io_lib:format(\"invalid argument for ~ts, expected a compile time atom or alias, got: ~ts\",\n [Kind, 'Elixir.Macro':to_string(GivenTerm)]);\nformat_error({unquote_outside_quote, Unquote}) ->\n %% Unquote can be \"unquote\" or \"unquote_splicing\".\n io_lib:format(\"~p called outside quote\", [Unquote]);\nformat_error({invalid_bind_quoted_for_quote, BQ}) ->\n io_lib:format(\"invalid :bind_quoted for quote, expected a keyword list of variable names, got: ~ts\",\n ['Elixir.Macro':to_string(BQ)]);\nformat_error(wrong_number_of_args_for_super) ->\n \"super must be called with the same number of arguments as the current definition\";\nformat_error({invalid_arg_for_pin, Arg}) ->\n io_lib:format(\"invalid argument for unary operator ^, expected an existing variable, got: ^~ts\",\n ['Elixir.Macro':to_string(Arg)]);\nformat_error({pin_outside_of_match, Arg}) ->\n io_lib:format(\n \"misplaced operator ^~ts\\n\\n\"\n \"The pin operator ^ is supported only inside matches or inside custom macros. \"\n \"Make sure you are inside a match or all necessary macros have been required\",\n ['Elixir.Macro':to_string(Arg)]\n );\nformat_error(unbound_underscore) ->\n \"invalid use of _. _ can only be used inside patterns to ignore values and cannot be used in expressions. Make sure you are inside a pattern or change it accordingly\";\nformat_error({undefined_var, Name, Kind}) ->\n io_lib:format(\"undefined variable ~ts\", [elixir_utils:var_info(Name, Kind)]);\nformat_error({undefined_var_pin, Name, Kind}) ->\n Message = \"undefined variable ^~ts. No variable ~ts has been defined before the current pattern\",\n io_lib:format(Message, [Name, elixir_utils:var_info(Name, Kind)]);\nformat_error(underscore_in_cond) ->\n \"invalid use of _ inside \\\"cond\\\". If you want the last clause to always match, \"\n \"you probably meant to use: true ->\";\nformat_error({invalid_pattern_in_match, Kind}) ->\n io_lib:format(\"invalid pattern in match, ~ts is not allowed in matches\", [Kind]);\nformat_error({invalid_expr_in_scope, Scope, Kind}) ->\n io_lib:format(\"cannot invoke ~ts outside ~ts\", [Kind, Scope]);\nformat_error({invalid_expr_in_guard, Kind}) ->\n Message =\n \"invalid expression in guards, ~ts is not allowed in guards. To learn more about \"\n \"guards, visit: https://hexdocs.pm/elixir/patterns-and-guards.html#guards\",\n io_lib:format(Message, [Kind]);\nformat_error({invalid_expr_in_bitsize, Kind}) ->\n Message =\n \"~ts is not allowed inside a bitstring size specifier. The size specifier in matches works like guards. \"\n \"To learn more about guards, visit: https://hexdocs.pm/elixir/patterns-and-guards.html#guards\",\n io_lib:format(Message, [Kind]);\nformat_error({invalid_alias, Expr}) ->\n Message =\n \"invalid alias: \\\"~ts\\\". If you wanted to define an alias, an alias must expand \"\n \"to an atom at compile time but it did not, you may use Module.concat/2 to build \"\n \"it at runtime. If instead you wanted to invoke a function or access a field, \"\n \"wrap the function or field name in double quotes\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);\nformat_error({op_ambiguity, Name, Arg}) ->\n NameString = atom_to_binary(Name),\n ArgString = 'Elixir.Macro':to_string(Arg),\n\n Message =\n \"\\\"~ts ~ts\\\" looks like a function call but there is a variable named \\\"~ts\\\". \"\n \"If you want to perform a function call, use parentheses:\\n\"\n \"\\n\"\n \" ~ts(~ts)\\n\"\n \"\\n\"\n \"If you want to perform an operation on the variable ~ts, use spaces \"\n \"around the unary operator\",\n io_lib:format(Message, [NameString, ArgString, NameString, NameString, ArgString, NameString]);\nformat_error({invalid_clauses, Name}) ->\n Message =\n \"the function \\\"~ts\\\" cannot handle clauses with the -> operator because it is not a macro. \"\n \"Please make sure you are invoking the proper name and that it is a macro\",\n io_lib:format(Message, [Name]);\nformat_error({invalid_call, Call}) ->\n io_lib:format(\"invalid call ~ts\", ['Elixir.Macro':to_string(Call)]);\nformat_error({invalid_quoted_expr, Expr}) ->\n Message =\n \"invalid quoted expression: ~ts\\n\\n\"\n \"Please make sure your quoted expressions are made of valid AST nodes. \"\n \"If you would like to introduce a value into the AST, such as a four-element \"\n \"tuple or a map, make sure to call Macro.escape/1 before\",\n io_lib:format(Message, ['Elixir.Kernel':inspect(Expr, [])]);\nformat_error({invalid_local_invocation, Context, {Name, _, Args} = Call}) ->\n Message =\n \"cannot find or invoke local ~ts/~B inside a ~ts. \"\n \"Only macros can be invoked inside a ~ts and they must be defined before their invocation. Called as: ~ts\",\n io_lib:format(Message, [Name, length(Args), Context, Context, 'Elixir.Macro':to_string(Call)]);\nformat_error({invalid_pid_in_function, Pid, {Name, Arity}}) ->\n io_lib:format(\"cannot compile PID ~ts inside quoted expression for function ~ts/~B\",\n ['Elixir.Kernel':inspect(Pid, []), Name, Arity]);\nformat_error({unsupported_option, Kind, Key}) ->\n io_lib:format(\"unsupported option ~ts given to ~s\",\n ['Elixir.Macro':to_string(Key), Kind]);\nformat_error({options_are_not_keyword, Kind, Opts}) ->\n io_lib:format(\"invalid options for ~s, expected a keyword list, got: ~ts\",\n [Kind, 'Elixir.Macro':to_string(Opts)]);\nformat_error({undefined_function, Name, Args}) ->\n io_lib:format(\"undefined function ~ts/~B (there is no such import)\", [Name, length(Args)]);\nformat_error({unpinned_bitsize_var, Name, Kind}) ->\n io_lib:format(\"the variable ~ts is accessed inside size(...) of a bitstring \"\n \"but it was defined outside of the match. You must precede it with the \"\n \"pin operator\", [elixir_utils:var_info(Name, Kind)]);\nformat_error({underscored_var_repeat, Name, Kind}) ->\n io_lib:format(\"the underscored variable ~ts appears more than once in a \"\n \"match. This means the pattern will only match if all \\\"~ts\\\" bind \"\n \"to the same value. If this is the intended behaviour, please \"\n \"remove the leading underscore from the variable name, otherwise \"\n \"give the variables different names\", [elixir_utils:var_info(Name, Kind), Name]);\nformat_error({underscored_var_access, Name}) ->\n io_lib:format(\"the underscored variable \\\"~ts\\\" is used after being set. \"\n \"A leading underscore indicates that the value of the variable \"\n \"should be ignored. If this is intended please rename the \"\n \"variable to remove the underscore\", [Name]);\nformat_error({nested_comparison, CompExpr}) ->\n String = 'Elixir.Macro':to_string(CompExpr),\n io_lib:format(\"Elixir does not support nested comparisons. Something like\\n\\n\"\n \" x < y < z\\n\\n\"\n \"is equivalent to\\n\\n\"\n \" (x < y) < z\\n\\n\"\n \"which ultimately compares z with the boolean result of (x < y). \"\n \"Instead, consider joining together each comparison segment with an \\\"and\\\", for example,\\n\\n\"\n \" x < y and y < z\\n\\n\"\n \"You wrote: ~ts\", [String]);\nformat_error({undefined_local_capture, Fun, Arity}) ->\n io_lib:format(\"undefined function ~ts/~B (there is no such import)\", [Fun, Arity]);\nformat_error(caller_not_allowed) ->\n \"__CALLER__ is available only inside defmacro and defmacrop\";\nformat_error(stacktrace_not_allowed) ->\n \"__STACKTRACE__ is available only inside catch and rescue clauses of try expressions\";\nformat_error({undefined_var_to_call, Name}) ->\n io_lib:format(\"variable \\\"~ts\\\" does not exist and is being expanded to \\\"~ts()\\\",\"\n \" please use parentheses to remove the ambiguity or change the variable name\", [Name, Name]);\nformat_error({parens_map_lookup, Map, Field, Context}) ->\n io_lib:format(\"cannot invoke remote function inside a ~ts. \"\n \"If you want to do a map lookup instead, please remove parens from ~ts.~ts()\",\n [Context, 'Elixir.Macro':to_string(Map), Field]);\nformat_error({super_in_genserver, {Name, Arity}}) ->\n io_lib:format(\"calling super for GenServer callback ~ts/~B is deprecated\", [Name, Arity]);\nformat_error('__cursor__') ->\n \"reserved special form __cursor__ cannot be expanded, it is used exclusively to annotate ASTs\"." }, { "path": "lib/elixir/src/elixir_fn.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_fn).\n-export([capture/4, expand/4, format_error/1]).\n-import(elixir_errors, [file_error/4]).\n-include(\"elixir.hrl\").\n\n%% Anonymous functions\n\nexpand(Meta, Clauses, S, E) when is_list(Clauses) ->\n Transformer = fun({_, _, [Left, _Right]} = Clause, SA) ->\n case lists:any(fun is_invalid_arg/1, Left) of\n true ->\n file_error(Meta, E, ?MODULE, defaults_in_args);\n false ->\n SReset = elixir_env:reset_unused_vars(SA),\n\n {EClause, SAcc, EAcc} =\n elixir_clauses:clause(Meta, fn, fun elixir_clauses:head/4, Clause, SReset, E),\n\n {EClause, elixir_env:merge_and_check_unused_vars(SAcc, SA, EAcc)}\n end\n end,\n\n {EClauses, SE} = lists:mapfoldl(Transformer, S, Clauses),\n EArities = [fn_arity(Args) || {'->', _, [Args, _]} <- EClauses],\n\n case lists:usort(EArities) of\n [_] ->\n {{fn, Meta, EClauses}, SE, E};\n _ ->\n file_error(Meta, E, ?MODULE, clauses_with_different_arities)\n end.\n\nis_invalid_arg({'\\\\\\\\', _, _}) -> true;\nis_invalid_arg(_) -> false.\n\nfn_arity([{'when', _, Args}]) -> length(Args) - 1;\nfn_arity(Args) -> length(Args).\n\n%% Capture\n\ncapture(Meta, {'/', _, [{{'.', _, [M, F]} = Dot, RequireMeta, []}, A]}, S, E) when is_atom(F), is_integer(A) ->\n Args = args_from_arity(Meta, A, E),\n handle_capture_possible_warning(Meta, RequireMeta, M, F, A, E),\n capture_require({Dot, RequireMeta, Args}, S, E, arity);\n\ncapture(Meta, {'/', _, [{F, ImportMeta, C}, A]}, S, E) when is_atom(F), is_integer(A), is_atom(C) ->\n Args = args_from_arity(Meta, A, E),\n capture_import({F, ImportMeta, Args}, S, E, arity);\n\ncapture(_Meta, {{'.', _, [_, Fun]}, _, Args} = Expr, S, E) when is_atom(Fun), is_list(Args) ->\n capture_require(Expr, S, E, check_sequential_and_not_empty(Args));\n\ncapture(Meta, {{'.', _, [_]}, _, Args} = Expr, S, E) when is_list(Args) ->\n capture_expr(Meta, Expr, S, E, non_sequential);\n\ncapture(Meta, {'__block__', _, [Expr]}, S, E) ->\n capture(Meta, Expr, S, E);\n\ncapture(Meta, {'__block__', _, _} = Expr, _S, E) ->\n file_error(Meta, E, ?MODULE, {block_expr_in_capture, Expr});\n\ncapture(_Meta, {Atom, _, Args} = Expr, S, E) when is_atom(Atom), is_list(Args) ->\n capture_import(Expr, S, E, check_sequential_and_not_empty(Args));\n\ncapture(Meta, {Left, Right}, S, E) ->\n capture(Meta, {'{}', Meta, [Left, Right]}, S, E);\n\ncapture(Meta, List, S, E) when is_list(List) ->\n capture_expr(Meta, List, S, E, check_sequential_and_not_empty(List));\n\ncapture(Meta, Integer, _S, E) when is_integer(Integer) ->\n file_error(Meta, E, ?MODULE, {capture_arg_outside_of_capture, Integer});\n\ncapture(Meta, Arg, _S, E) ->\n invalid_capture(Meta, Arg, E).\n\ncapture_import({Atom, ImportMeta, Args} = Expr, S, E, ArgsType) ->\n Res = ArgsType /= non_sequential andalso\n elixir_dispatch:import_function(ImportMeta, Atom, length(Args), E),\n handle_capture(Res, ImportMeta, ImportMeta, Expr, S, E, ArgsType).\n\ncapture_require({{'.', DotMeta, [Left, Right]}, RequireMeta, Args}, S, E, ArgsType) ->\n case escape(Left, E, []) of\n {EscLeft, []} ->\n {ELeft, SE, EE} = elixir_expand:expand(EscLeft, S, E),\n\n case ELeft of\n _ when ArgsType /= arity -> ok;\n Atom when is_atom(Atom) -> ok;\n {Var, _, Ctx} when is_atom(Var), is_atom(Ctx) -> ok;\n %% TODO: Raise on Elixir v2.0\n _ -> elixir_errors:file_warn(RequireMeta, E, ?MODULE, {complex_module_capture, Left})\n end,\n\n Res = ArgsType /= non_sequential andalso case ELeft of\n {Name, _, Context} when is_atom(Name), is_atom(Context) ->\n {remote, ELeft, Right, length(Args)};\n _ when is_atom(ELeft) ->\n elixir_dispatch:require_function(RequireMeta, ELeft, Right, length(Args), EE);\n _ ->\n false\n end,\n\n Dot = {{'.', DotMeta, [ELeft, Right]}, RequireMeta, Args},\n handle_capture(Res, RequireMeta, DotMeta, Dot, SE, EE, ArgsType);\n\n {EscLeft, Escaped} ->\n Dot = {{'.', DotMeta, [EscLeft, Right]}, RequireMeta, Args},\n capture_expr(RequireMeta, Dot, S, E, Escaped, ArgsType)\n end.\n\nhandle_capture(false, Meta, _DotMeta, Expr, S, E, ArgsType) ->\n capture_expr(Meta, Expr, S, E, ArgsType);\nhandle_capture(LocalOrRemote, Meta, DotMeta, _Expr, S, E, _ArgsType) ->\n {LocalOrRemote, Meta, DotMeta, S, E}.\n\ncapture_expr(Meta, Expr, S, E, ArgsType) ->\n capture_expr(Meta, Expr, S, E, [], ArgsType).\ncapture_expr(Meta, Expr, S, E, Escaped, ArgsType) ->\n case escape(Expr, E, Escaped) of\n {_, []} when ArgsType == non_sequential ->\n invalid_capture(Meta, Expr, E);\n %% TODO: Remove this clause once we raise on complex module captures like &get_mod().fun/0\n {{{'.', _, [_, _]} = Dot, _, Args}, []} ->\n Meta2 = lists:keydelete(no_parens, 1, Meta),\n Fn = {fn, Meta2, [{'->', Meta2, [[], {Dot, Meta2, Args}]}]},\n {expand, Fn, S, E};\n {EExpr, EDict} ->\n EVars = validate(Meta, EDict, 1, E),\n Fn = {fn, [{capture, true} | Meta], [{'->', Meta, [EVars, EExpr]}]},\n {expand, Fn, S, E}\n end.\n\ninvalid_capture(Meta, Arg, E) ->\n file_error(Meta, E, ?MODULE, {invalid_args_for_capture, Arg}).\n\nvalidate(Meta, [{Pos, Var} | T], Pos, E) ->\n [Var | validate(Meta, T, Pos + 1, E)];\nvalidate(Meta, [{Pos, _} | _], Expected, E) ->\n file_error(Meta, E, ?MODULE, {capture_arg_without_predecessor, Pos, Expected});\nvalidate(_Meta, [], _Pos, _E) ->\n [].\n\nescape({'&', Meta, [Pos]}, E, Dict) when is_integer(Pos), Pos > 0 ->\n % Using a nil context here to emit warnings when variable is unused.\n % This might pollute user space but is unlikely because variables\n % named :\"&1\" are not valid syntax.\n case orddict:find(Pos, Dict) of\n {ok, Var} ->\n {Var, Dict};\n error ->\n Next = elixir_module:next_counter(?key(E, module)),\n Var = {capture, [{counter, Next}, {capture, Pos} | Meta], nil},\n {Var, orddict:store(Pos, Var, Dict)}\n end;\nescape({'&', Meta, [Pos]}, E, _Dict) when is_integer(Pos) ->\n file_error(Meta, E, ?MODULE, {invalid_arity_for_capture, Pos});\nescape({'&', Meta, _} = Arg, E, _Dict) ->\n file_error(Meta, E, ?MODULE, {nested_capture, Arg});\nescape({Left, Meta, Right}, E, Dict0) ->\n {TLeft, Dict1} = escape(Left, E, Dict0),\n {TRight, Dict2} = escape(Right, E, Dict1),\n {{TLeft, Meta, TRight}, Dict2};\nescape({Left, Right}, E, Dict0) ->\n {TLeft, Dict1} = escape(Left, E, Dict0),\n {TRight, Dict2} = escape(Right, E, Dict1),\n {{TLeft, TRight}, Dict2};\nescape(List, E, Dict) when is_list(List) ->\n lists:mapfoldl(fun(X, Acc) -> escape(X, E, Acc) end, Dict, List);\nescape(Other, _E, Dict) ->\n {Other, Dict}.\n\nargs_from_arity(_Meta, A, _E) when is_integer(A), A >= 0, A =< 255 ->\n [{'&', [], [X]} || X <- lists:seq(1, A)];\nargs_from_arity(Meta, A, E) ->\n file_error(Meta, E, ?MODULE, {invalid_arity_for_capture, A}).\n\ncheck_sequential_and_not_empty([]) -> non_sequential;\ncheck_sequential_and_not_empty(List) -> check_sequential(List, 1).\n\ncheck_sequential([{'&', _, [Int]} | T], Int) -> check_sequential(T, Int + 1);\ncheck_sequential([], _Int) -> sequential;\ncheck_sequential(_, _Int) -> non_sequential.\n\nhandle_capture_possible_warning(Meta, DotMeta, Mod, Fun, Arity, E) ->\n case (Arity =:= 0) andalso (lists:keyfind(no_parens, 1, DotMeta) /= {no_parens, true}) of\n true ->\n elixir_errors:file_warn(Meta, E, ?MODULE, {parens_remote_capture, Mod, Fun});\n\n false -> ok\n end.\n\n%% TODO: Raise on Elixir v2.0\nformat_error({parens_remote_capture, Mod, Fun}) ->\n io_lib:format(\"extra parentheses on a remote function capture &~ts.~ts()/0 have been \"\n \"deprecated. Please remove the parentheses: &~ts.~ts/0\",\n ['Elixir.Macro':to_string(Mod), Fun, 'Elixir.Macro':to_string(Mod), Fun]);\nformat_error({complex_module_capture, Mod}) ->\n io_lib:format(\"expected the module in &module.fun/arity to expand to a variable or an atom, got: ~ts\\n\"\n \"You can either compute the module name outside of & or convert it to a regular anonymous function.\",\n ['Elixir.Macro':to_string(Mod)]);\nformat_error(clauses_with_different_arities) ->\n \"cannot mix clauses with different arities in anonymous functions\";\nformat_error(defaults_in_args) ->\n \"anonymous functions cannot have optional arguments\";\nformat_error({block_expr_in_capture, Expr}) ->\n io_lib:format(\"block expressions are not allowed inside the capture operator &, got: ~ts\",\n ['Elixir.Macro':to_string(Expr)]);\nformat_error({nested_capture, Arg}) ->\n io_lib:format(\"nested captures are not allowed. You cannot define a function using \"\n \"the capture operator & inside another function defined via &. Got invalid nested \"\n \"capture: ~ts\", ['Elixir.Macro':to_string(Arg)]);\nformat_error({invalid_arity_for_capture, Arity}) ->\n io_lib:format(\"capture argument &~B must be numbered between 1 and 255\", [Arity]);\nformat_error({capture_arg_outside_of_capture, Integer}) ->\n io_lib:format(\"capture argument &~B must be used within the capture operator &\", [Integer]);\nformat_error({capture_arg_without_predecessor, Pos, Expected}) ->\n io_lib:format(\"capture argument &~B cannot be defined without &~B \"\n \"(you cannot skip arguments, all arguments must be numbered)\", [Pos, Expected]);\nformat_error({invalid_args_for_capture, Arg}) ->\n Message =\n \"invalid args for &, expected one of:\\n\\n\"\n \" * &Mod.fun/arity to capture a remote function, such as &Enum.map/2\\n\"\n \" * &fun/arity to capture a local or imported function, such as &is_atom/1\\n\"\n \" * &some_code(&1, ...) containing at least one argument as &1, such as &List.flatten(&1)\\n\\n\"\n \"Got: ~ts\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Arg)]).\n" }, { "path": "lib/elixir/src/elixir_import.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Module responsible for handling imports and conflicts\n%% between local functions and imports.\n%% For imports dispatch, please check elixir_dispatch.\n-module(elixir_import).\n-export([import/6, import/7, special_form/2,\n record/4, ensure_no_local_conflict/3,\n format_error/1]).\n-compile(inline_list_funcs).\n-include(\"elixir.hrl\").\n\nimport(Meta, Ref, Opts, E, Warn, Trace) ->\n import(Meta, Ref, Opts, E, Warn, Trace, fun Ref:'__info__'/1).\n\nimport(Meta, Ref, Opts, E, Warn, Trace, InfoCallback) ->\n case import_only_except(Meta, Ref, Opts, E, Warn, InfoCallback) of\n {Functions, Macros, Added} ->\n Trace andalso elixir_env:trace({import, Meta, Ref, Opts}, E),\n EI = E#{functions := Functions, macros := Macros},\n {ok, Added, elixir_aliases:require(Meta, Ref, [{warn, false} | Opts], EI, Trace)};\n\n {error, Reason} ->\n {error, Reason}\n end.\n\nimport_only_except(Meta, Ref, Opts, E, Warn, InfoCallback) ->\n MaybeOnly = lists:keyfind(only, 1, Opts),\n\n case lists:keyfind(except, 1, Opts) of\n false ->\n import_only_except(Meta, Ref, MaybeOnly, false, E, Warn, InfoCallback);\n\n {except, DupExcept} when is_list(DupExcept) ->\n case ensure_keyword_list(DupExcept) of\n ok ->\n Except = ensure_no_duplicates(DupExcept, except, Meta, E, Warn),\n import_only_except(Meta, Ref, MaybeOnly, Except, E, Warn, InfoCallback);\n\n error ->\n {error, {invalid_option, except, DupExcept}}\n end;\n\n {except, Other} ->\n {error, {invalid_option, except, Other}}\n end.\n\nimport_only_except(Meta, Ref, MaybeOnly, Except, E, Warn, InfoCallback) ->\n case MaybeOnly of\n {only, functions} ->\n {Added1, _Used1, Funs} = import_functions(Meta, Ref, Except, E, Warn, InfoCallback),\n {Funs, keydelete(Ref, ?key(E, macros)), Added1};\n\n {only, macros} ->\n {Added2, _Used2, Macs} = import_macros(Meta, Ref, Except, E, Warn, InfoCallback),\n {keydelete(Ref, ?key(E, functions)), Macs, Added2};\n\n {only, sigils} ->\n {Added1, _Used1, Funs} = import_sigil_functions(Meta, Ref, Except, E, Warn, InfoCallback),\n {Added2, _Used2, Macs} = import_sigil_macros(Meta, Ref, Except, E, Warn, InfoCallback),\n {Funs, Macs, Added1 or Added2};\n\n {only, DupOnly} when is_list(DupOnly) ->\n case ensure_keyword_list(DupOnly) of\n ok when Except =:= false ->\n Only = ensure_no_duplicates(DupOnly, only, Meta, E, Warn),\n {Added1, Used1, Funs} = import_listed_functions(Meta, Ref, Only, E, Warn, InfoCallback),\n {Added2, Used2, Macs} = import_listed_macros(Meta, Ref, Only, E, Warn, InfoCallback),\n [Warn andalso elixir_errors:file_warn(Meta, E, ?MODULE, {invalid_import, {Ref, Name, Arity}}) ||\n {Name, Arity} <- (Only -- Used1) -- Used2],\n {Funs, Macs, Added1 or Added2};\n\n ok ->\n {error, only_and_except_given};\n\n error ->\n {error, {invalid_option, only, DupOnly}}\n end;\n\n {only, Other} ->\n {error, {invalid_option, only, Other}};\n\n false ->\n {Added1, _Used1, Funs} = import_functions(Meta, Ref, Except, E, Warn, InfoCallback),\n {Added2, _Used2, Macs} = import_macros(Meta, Ref, Except, E, Warn, InfoCallback),\n {Funs, Macs, Added1 or Added2}\n end.\n\nimport_listed_functions(Meta, Ref, Only, E, Warn, InfoCallback) ->\n New = intersection(Only, get_functions(Ref, InfoCallback)),\n calculate_key(Meta, Ref, ?key(E, functions), New, E, Warn).\n\nimport_listed_macros(Meta, Ref, Only, E, Warn, InfoCallback) ->\n New = intersection(Only, get_macros(InfoCallback)),\n calculate_key(Meta, Ref, ?key(E, macros), New, E, Warn).\n\nimport_functions(Meta, Ref, Except, E, Warn, InfoCallback) ->\n calculate_except(Meta, Ref, Except, ?key(E, functions), E, Warn, fun() ->\n get_functions(Ref, InfoCallback)\n end).\n\nimport_macros(Meta, Ref, Except, E, Warn, InfoCallback) ->\n calculate_except(Meta, Ref, Except, ?key(E, macros), E, Warn, fun() ->\n get_macros(InfoCallback)\n end).\n\nimport_sigil_functions(Meta, Ref, Except, E, Warn, InfoCallback) ->\n calculate_except(Meta, Ref, Except, ?key(E, functions), E, Warn, fun() ->\n filter_sigils(InfoCallback(functions))\n end).\n\nimport_sigil_macros(Meta, Ref, Except, E, Warn, InfoCallback) ->\n calculate_except(Meta, Ref, Except, ?key(E, macros), E, Warn, fun() ->\n filter_sigils(InfoCallback(macros))\n end).\n\ncalculate_except(Meta, Key, false, Old, E, Warn, Existing) ->\n New = remove_underscored(Existing()),\n calculate_key(Meta, Key, Old, New, E, Warn);\n\ncalculate_except(Meta, Key, Except, Old, E, Warn, Existing) ->\n %% We are not checking existence of exports listed in :except\n %% option on purpose: to support backwards compatible code.\n %% For example, \"import String, except: [trim: 1]\"\n %% should work across all Elixir versions.\n New =\n case lists:keyfind(Key, 1, Old) of\n false -> remove_underscored(Existing()) -- Except;\n {Key, OldImports} -> OldImports -- Except\n end,\n calculate_key(Meta, Key, Old, New, E, Warn).\n\ncalculate_key(Meta, Key, Old, New, E, Warn) ->\n case ordsets:from_list(New) of\n [] ->\n {false, [], keydelete(Key, Old)};\n Set ->\n FinalSet = ensure_no_special_form_conflict(Set, Key, Meta, E, Warn),\n {true, FinalSet, [{Key, FinalSet} | keydelete(Key, Old)]}\n end.\n\n%% Record function calls for local conflicts\n\nrecord(_Tuple, Receiver, Module, Function)\n when Function == nil; Module == Receiver -> false;\nrecord(Tuple, Receiver, Module, _Function) ->\n try\n {Set, _Bag} = elixir_module:data_tables(Module),\n ets:insert(Set, {{import, Tuple}, Receiver}),\n true\n catch\n error:badarg -> false\n end.\n\nensure_no_local_conflict('Elixir.Kernel', _All, _E) ->\n ok;\nensure_no_local_conflict(Module, AllDefinitions, E) ->\n {Set, _} = elixir_module:data_tables(Module),\n\n [try\n Receiver = ets:lookup_element(Set, {import, Pair}, 2),\n elixir_errors:module_error(Meta, E, ?MODULE, {import_conflict, Receiver, Pair})\n catch\n error:badarg -> false\n end || {Pair, _, Meta, _} <- AllDefinitions].\n\n%% Retrieve functions and macros from modules\n\nget_functions(Module, InfoCallback) ->\n try\n InfoCallback(functions)\n catch\n error:undef -> remove_internals(Module:module_info(exports))\n end.\n\nget_macros(InfoCallback) ->\n try\n InfoCallback(macros)\n catch\n error:undef -> []\n end.\n\nfilter_sigils(Funs) ->\n lists:filter(fun is_sigil/1, Funs).\n\nis_sigil({Name, 2}) ->\n case atom_to_list(Name) of\n \"sigil_\" ++ Letters ->\n case Letters of\n [L] when L >= $a, L =< $z -> true;\n [] -> false;\n [H|T] when H >= $A, H =< $Z ->\n lists:all(fun(L) -> (L >= $0 andalso L =< $9)\n orelse (L>= $A andalso L =< $Z)\n end, T)\n end;\n _ ->\n false\n end;\nis_sigil(_) ->\n false.\n\n%% VALIDATION HELPERS\\\n\nensure_keyword_list([]) ->\n ok;\nensure_keyword_list([{Key, Value} | Rest]) when is_atom(Key), is_integer(Value) ->\n ensure_keyword_list(Rest);\nensure_keyword_list(_Other) ->\n error.\n\nensure_no_special_form_conflict(Set, Key, Meta, E, Warn) ->\n lists:filter(fun({Name, Arity}) ->\n case special_form(Name, Arity) of\n true ->\n Warn andalso elixir_errors:file_warn(Meta, E, ?MODULE, {special_form_conflict, {Key, Name, Arity}}),\n false;\n false ->\n true\n end\n end, Set).\n\nensure_no_duplicates(Option, Kind, Meta, E, Warn) ->\n lists:foldl(fun({Name, Arity}, Acc) ->\n case lists:member({Name, Arity}, Acc) of\n true ->\n Warn andalso elixir_errors:file_warn(Meta, E, ?MODULE, {duplicated_import, {Kind, Name, Arity}}),\n Acc;\n false ->\n [{Name, Arity} | Acc]\n end\n end, [], Option).\n\n%% ERROR HANDLING\n\nformat_error(only_and_except_given) ->\n \":only and :except can only be given together to import \"\n \"when :only is :functions, :macros, or :sigils\";\n\nformat_error({duplicated_import, {Option, Name, Arity}}) ->\n io_lib:format(\"invalid :~s option for import, ~ts/~B is duplicated\", [Option, Name, Arity]);\n\nformat_error({invalid_import, {Receiver, Name, Arity}}) ->\n io_lib:format(\"cannot import ~ts.~ts/~B because it is undefined or private\",\n [elixir_aliases:inspect(Receiver), Name, Arity]);\n\nformat_error({invalid_option, only, Value}) ->\n Message = \"invalid :only option for import, expected value to be an atom :functions, :macros\"\n \", or a literal keyword list of function names with arity as values, got: ~s\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Value)]);\n\nformat_error({invalid_option, except, Value}) ->\n Message = \"invalid :except option for import, expected value to be a literal keyword list of function names with arity as values, got: ~s\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Value)]);\n\nformat_error({special_form_conflict, {Receiver, Name, Arity}}) ->\n io_lib:format(\"cannot import ~ts.~ts/~B because it conflicts with Elixir special forms, the import has been discarded\",\n [elixir_aliases:inspect(Receiver), Name, Arity]);\n\nformat_error({no_macros, Module}) ->\n io_lib:format(\"could not load macros from module ~ts\", [elixir_aliases:inspect(Module)]);\n\nformat_error({import_conflict, Receiver, {Name, Arity}}) ->\n io_lib:format(\"imported ~ts.~ts/~B conflicts with local function\",\n [elixir_aliases:inspect(Receiver), Name, Arity]).\n\n%% LIST HELPERS\n\nkeydelete(Key, List) ->\n lists:keydelete(Key, 1, List).\n\nintersection([H | T], All) ->\n case lists:member(H, All) of\n true -> [H | intersection(T, All)];\n false -> intersection(T, All)\n end;\n\nintersection([], _All) -> [].\n\n%% Internal funs that are never imported, and the like\n\nremove_underscored(List) ->\n lists:filter(fun({Name, _}) ->\n case atom_to_list(Name) of\n \"_\" ++ _ -> false;\n _ -> true\n end\n end, List).\n\nremove_internals(Set) ->\n Set -- [{behaviour_info, 1}, {module_info, 1}, {module_info, 0}].\n\n%% Special forms\n\nspecial_form('&', 1) -> true;\nspecial_form('^', 1) -> true;\nspecial_form('=', 2) -> true;\nspecial_form('%', 2) -> true;\nspecial_form('|', 2) -> true;\nspecial_form('.', 2) -> true;\nspecial_form('::', 2) -> true;\nspecial_form('__aliases__', _) -> true;\nspecial_form('__block__', _) -> true;\nspecial_form('__cursor__', _) -> true;\nspecial_form('->', _) -> true;\nspecial_form('<<>>', _) -> true;\nspecial_form('{}', _) -> true;\nspecial_form('%{}', _) -> true;\nspecial_form('alias', 1) -> true;\nspecial_form('alias', 2) -> true;\nspecial_form('require', 1) -> true;\nspecial_form('require', 2) -> true;\nspecial_form('import', 1) -> true;\nspecial_form('import', 2) -> true;\nspecial_form('__ENV__', 0) -> true;\nspecial_form('__CALLER__', 0) -> true;\nspecial_form('__STACKTRACE__', 0) -> true;\nspecial_form('__MODULE__', 0) -> true;\nspecial_form('__DIR__', 0) -> true;\nspecial_form('quote', 1) -> true;\nspecial_form('quote', 2) -> true;\nspecial_form('unquote', 1) -> true;\nspecial_form('unquote_splicing', 1) -> true;\nspecial_form('fn', _) -> true;\nspecial_form('super', _) -> true;\nspecial_form('for', _) -> true;\nspecial_form('with', _) -> true;\nspecial_form('cond', 1) -> true;\nspecial_form('case', 2) -> true;\nspecial_form('try', 1) -> true;\nspecial_form('receive', 1) -> true;\nspecial_form(_, _) -> false.\n" }, { "path": "lib/elixir/src/elixir_interpolation.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n% Handle string and string-like interpolations.\n-module(elixir_interpolation).\n-export([extract/6, unescape_string/1, unescape_string/2,\nunescape_tokens/1, unescape_map/1]).\n-include(\"elixir.hrl\").\n-include(\"elixir_tokenizer.hrl\").\n\n%% Extract string interpolations\n\nextract(Line, Column, Scope, Interpol, String, Last) ->\n extract(String, [], [], Line, Column, Scope, Interpol, Last).\n\n%% Terminators\n\nextract([], _Buffer, _Output, Line, Column, #elixir_tokenizer{cursor_completion=false}, _Interpol, Last) ->\n {error, {string, Line, Column, io_lib:format(\"missing terminator: ~ts\", [[Last]]), []}};\n\nextract([], Buffer, Output, Line, Column, Scope, _Interpol, _Last) ->\n finish_extraction([], false, Buffer, Output, Line, Column, Scope);\n\nextract([Last | Rest], Buffer, Output, Line, Column, Scope, _Interpol, Last) ->\n finish_extraction(Rest, true, Buffer, Output, Line, Column + 1, Scope);\n\n%% Going through the string\n\nextract([$\\\\, $\\r, $\\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) ->\n extract_nl(Rest, [$\\n, $\\r, $\\\\ | Buffer], Output, Line, Scope, Interpol, Last);\n\nextract([$\\\\, $\\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) ->\n extract_nl(Rest, [$\\n, $\\\\ | Buffer], Output, Line, Scope, Interpol, Last);\n\nextract([$\\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) ->\n extract_nl(Rest, [$\\n | Buffer], Output, Line, Scope, Interpol, Last);\n\nextract([$\\\\, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) ->\n NewScope =\n %% TODO: Remove this on Elixir v2.0\n case Interpol of\n true ->\n Scope;\n false ->\n Msg = \"using \\\\~ts to escape the closing of an uppercase sigil is deprecated, please use another delimiter or a lowercase sigil instead\",\n prepend_warning(Line, Column, io_lib:format(Msg, [[Last]]), Scope)\n end,\n\n extract(Rest, [Last | Buffer], Output, Line, Column+2, NewScope, Interpol, Last);\n\nextract([$\\\\, Last, Last, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, [Last, Last, Last] = All) ->\n extract(Rest, [Last, Last, Last | Buffer], Output, Line, Column+4, Scope, Interpol, All);\n\nextract([$\\\\, $#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) ->\n extract(Rest, [${, $#, $\\\\ | Buffer], Output, Line, Column+3, Scope, true, Last);\n\nextract([$#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) ->\n Output1 = build_string(Buffer, Output),\n case elixir_tokenizer:tokenize(Rest, Line, Column + 2, Scope#elixir_tokenizer{terminators=[]}) of\n {error, {Location, _, \"}\"}, [$} | NewRest], Warnings, Tokens} ->\n NewScope = Scope#elixir_tokenizer{warnings=Warnings},\n {line, EndLine} = lists:keyfind(line, 1, Location),\n {column, EndColumn} = lists:keyfind(column, 1, Location),\n Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens), Output1),\n extract(NewRest, [], Output2, EndLine, EndColumn + 1, NewScope, true, Last);\n {error, Reason, _, _, _} ->\n {error, Reason};\n {ok, EndLine, EndColumn, Warnings, Tokens, Terminators} when Scope#elixir_tokenizer.cursor_completion /= false ->\n NewScope = Scope#elixir_tokenizer{warnings=Warnings, cursor_completion=noprune},\n {CursorTerminators, _} = cursor_complete(EndLine, EndColumn, Terminators),\n Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens, CursorTerminators), Output1),\n extract([], [], Output2, EndLine, EndColumn, NewScope, true, Last);\n {ok, _, _, _, _, _} ->\n {error, {string, Line, Column, \"missing interpolation terminator: \\\"}\\\"\", []}}\n end;\n\nextract([$\\\\ | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) ->\n extract_char(Rest, [$\\\\ | Buffer], Output, Line, Column + 1, Scope, Interpol, Last);\n\n%% Catch all clause\n\nextract([Char1, Char2 | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last)\n when Char1 =< 255, Char2 =< 255 ->\n extract([Char2 | Rest], [Char1 | Buffer], Output, Line, Column + 1, Scope, Interpol, Last);\n\nextract(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) ->\n extract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last).\n\nextract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) ->\n case unicode_util:gc(Rest) of\n [Char | _] when ?bidi(Char); ?break(Char) ->\n Token = io_lib:format(\"\\\\u~4.16.0B\", [Char]),\n Pre = if\n ?bidi(Char) -> \"invalid bidirectional formatting character in string: \";\n true -> \"invalid line break character in string: \"\n end,\n Pos = io_lib:format(\". If you want to use such character, use it in its escaped ~ts form instead\", [Token]),\n {error, {?LOC(Line, Column), {Pre, Pos}, Token}};\n\n [Char | NewRest] when is_list(Char) ->\n extract(NewRest, lists:reverse(Char, Buffer), Output, Line, Column + 1, Scope, Interpol, Last);\n\n [Char | NewRest] when is_integer(Char) ->\n extract(NewRest, [Char | Buffer], Output, Line, Column + 1, Scope, Interpol, Last);\n\n [] ->\n extract([], Buffer, Output, Line, Column, Scope, Interpol, Last)\n end.\n\n%% Handle newlines. Heredocs require special attention\n\nextract_nl(Rest, Buffer, Output, Line, Scope, Interpol, [H,H,H] = Last) ->\n case strip_horizontal_space(Rest, Buffer, 1) of\n {[H,H,H|NewRest], _NewBuffer, Column} ->\n finish_extraction(NewRest, true, Buffer, Output, Line + 1, Column + 3, Scope);\n {NewRest, NewBuffer, Column} ->\n extract(NewRest, NewBuffer, Output, Line + 1, Column, Scope, Interpol, Last)\n end;\nextract_nl(Rest, Buffer, Output, Line, Scope, Interpol, Last) ->\n extract(Rest, Buffer, Output, Line + 1, Scope#elixir_tokenizer.column, Scope, Interpol, Last).\n\nstrip_horizontal_space([H | T], Buffer, Counter) when H =:= $\\s; H =:= $\\t ->\n strip_horizontal_space(T, [H | Buffer], Counter + 1);\nstrip_horizontal_space(T, Buffer, Counter) ->\n {T, Buffer, Counter}.\n\ncursor_complete(Line, Column, Terminators) ->\n lists:mapfoldl(\n fun({Start, _, _}, AccColumn) ->\n End = elixir_tokenizer:terminator(Start),\n {{End, {Line, AccColumn, nil}}, AccColumn + length(erlang:atom_to_list(End))}\n end,\n Column,\n Terminators\n ).\n\n%% Unescape a series of tokens as returned by extract.\n\nunescape_tokens(Tokens) ->\n try [unescape_token(Token, fun unescape_map/1) || Token <- Tokens] of\n Unescaped -> {ok, Unescaped}\n catch\n {error, _Reason, _Token} = Error -> Error\n end.\n\nunescape_token(Token, Map) when is_list(Token) ->\n unescape_chars(elixir_utils:characters_to_binary(Token), Map);\nunescape_token(Token, Map) when is_binary(Token) ->\n unescape_chars(Token, Map);\nunescape_token(Other, _Map) ->\n Other.\n\n% Unescape string. This is called by Elixir. Wrapped by convenience.\n\nunescape_string(String) ->\n unescape_string(String, fun unescape_map/1).\n\nunescape_string(String, Map) ->\n try\n unescape_chars(String, Map)\n catch\n {error, Reason, _} ->\n Message = elixir_utils:characters_to_binary(Reason),\n error('Elixir.ArgumentError':exception([{message, Message}]))\n end.\n\n% Unescape chars. For instance, \"\\\" \"n\" (two chars) needs to be converted to \"\\n\" (one char).\n\nunescape_chars(String, Map) ->\n unescape_chars(String, Map, <<>>).\n\nunescape_chars(<<$\\\\, $x, Rest/binary>>, Map, Acc) ->\n case Map(hex) of\n true -> unescape_hex(Rest, Map, Acc);\n false -> unescape_chars(Rest, Map, <>)\n end;\n\nunescape_chars(<<$\\\\, $u, Rest/binary>>, Map, Acc) ->\n case Map(unicode) of\n true -> unescape_unicode(Rest, Map, Acc);\n false -> unescape_chars(Rest, Map, <>)\n end;\n\nunescape_chars(<<$\\\\, $\\n, Rest/binary>>, Map, Acc) ->\n case Map(newline) of\n true -> unescape_chars(Rest, Map, Acc);\n false -> unescape_chars(Rest, Map, <>)\n end;\n\nunescape_chars(<<$\\\\, $\\r, $\\n, Rest/binary>>, Map, Acc) ->\n case Map(newline) of\n true -> unescape_chars(Rest, Map, Acc);\n false -> unescape_chars(Rest, Map, <>)\n end;\n\nunescape_chars(<<$\\\\, Escaped, Rest/binary>>, Map, Acc) ->\n case Map(Escaped) of\n false -> unescape_chars(Rest, Map, <>);\n Other -> unescape_chars(Rest, Map, <>)\n end;\n\nunescape_chars(<>, Map, Acc) ->\n unescape_chars(Rest, Map, <>);\n\nunescape_chars(<<>>, _Map, Acc) -> Acc.\n\n% Unescape Helpers\n\nunescape_hex(<>, Map, Acc) when ?is_hex(A), ?is_hex(B) ->\n Bytes = list_to_integer([A, B], 16),\n unescape_chars(Rest, Map, <>);\n\nunescape_hex(<<_/binary>>, _Map, _Acc) ->\n throw({error, \"invalid hex escape character, expected \\\\xHH where H is a hexadecimal digit\", \"\\\\x\"}).\n\n%% Finish deprecated sequences\n\nunescape_unicode(<>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->\n append_codepoint(Rest, Map, [A, B, C, D], Acc, 16);\n\nunescape_unicode(<<${, A, $}, Rest/binary>>, Map, Acc) when ?is_hex(A) ->\n append_codepoint(Rest, Map, [A], Acc, 16);\n\nunescape_unicode(<<${, A, B, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B) ->\n append_codepoint(Rest, Map, [A, B], Acc, 16);\n\nunescape_unicode(<<${, A, B, C, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) ->\n append_codepoint(Rest, Map, [A, B, C], Acc, 16);\n\nunescape_unicode(<<${, A, B, C, D, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->\n append_codepoint(Rest, Map, [A, B, C, D], Acc, 16);\n\nunescape_unicode(<<${, A, B, C, D, E, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) ->\n append_codepoint(Rest, Map, [A, B, C, D, E], Acc, 16);\n\nunescape_unicode(<<${, A, B, C, D, E, F, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) ->\n append_codepoint(Rest, Map, [A, B, C, D, E, F], Acc, 16);\n\nunescape_unicode(<<_/binary>>, _Map, _Acc) ->\n throw({error, \"invalid Unicode escape character, expected \\\\uHHHH or \\\\u{H*} where H is a hexadecimal digit\", \"\\\\u\"}).\n\nappend_codepoint(Rest, Map, List, Acc, Base) ->\n Codepoint = list_to_integer(List, Base),\n try <> of\n Binary -> unescape_chars(Rest, Map, Binary)\n catch\n error:badarg ->\n throw({error, \"invalid or reserved Unicode code point \\\\u{\" ++ List ++ \"}\", \"\\\\u\"})\n end.\n\nunescape_map(newline) -> true;\nunescape_map(unicode) -> true;\nunescape_map(hex) -> true;\nunescape_map($0) -> 0;\nunescape_map($a) -> 7;\nunescape_map($b) -> $\\b;\nunescape_map($d) -> $\\d;\nunescape_map($e) -> $\\e;\nunescape_map($f) -> $\\f;\nunescape_map($n) -> $\\n;\nunescape_map($r) -> $\\r;\nunescape_map($s) -> $\\s;\nunescape_map($t) -> $\\t;\nunescape_map($v) -> $\\v;\nunescape_map(E) -> E.\n\n% Extract Helpers\n\nfinish_extraction(Remaining, Done, Buffer, Output, Line, Column, Scope) ->\n Final = case build_string(Buffer, Output) of\n [] -> [[]];\n F -> F\n end,\n\n {Line, Column, lists:reverse(Final), Remaining, Done, Scope}.\n\nbuild_string([], Output) -> Output;\nbuild_string(Buffer, Output) -> [lists:reverse(Buffer) | Output].\n\nbuild_interpol(Line, Column, EndLine, EndColumn, Buffer, Output) ->\n [{{Line, Column, nil}, {EndLine, EndColumn, nil}, Buffer} | Output].\n\nprepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) ->\n Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}.\n" }, { "path": "lib/elixir/src/elixir_lexical.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Module responsible for tracking lexical information.\n-module(elixir_lexical).\n-feature(maybe_expr, enable).\n-export([run/3, with_file/3, trace/2, format_error/1]).\n-include(\"elixir.hrl\").\n\nrun(#{tracers := Tracers} = E, ExecutionCallback, AfterExecutionCallback) ->\n case elixir_config:is_bootstrap() of\n false ->\n {ok, Pid} = ?tracker:start_link(),\n LexEnv = E#{lexical_tracker := Pid, tracers := [?MODULE | Tracers]},\n elixir_env:trace(start, LexEnv),\n\n try ExecutionCallback(LexEnv) of\n Res ->\n warn_unused_aliases(Pid, LexEnv),\n warn_unused_imports(Pid, LexEnv),\n warn_unused_requires(Pid, LexEnv),\n AfterExecutionCallback(LexEnv),\n Res\n after\n elixir_env:trace(stop, LexEnv),\n unlink(Pid),\n ?tracker:stop(Pid)\n end;\n\n true ->\n ExecutionCallback(E),\n AfterExecutionCallback(E)\n end.\ntrace({alias_expansion, _Meta, Lookup, _Result}, #{lexical_tracker := Pid}) ->\n ?tracker:alias_dispatch(Pid, Lookup),\n ok;\ntrace({require, Meta, Module, _Opts}, #{lexical_tracker := Pid}) ->\n case lists:keyfind(from_macro, 1, Meta) of\n {from_macro, true} -> ?tracker:remote_dispatch(Pid, Module, compile);\n _ -> ?tracker:add_export(Pid, Module)\n end,\n ok;\ntrace({struct_expansion, Meta, Module, _Keys}, #{lexical_tracker := Pid} = E) ->\n maybe\n #{function := {_, _}} ?= E,\n Operation = proplists:get_value(operation, Meta, unknown),\n true ?= (Operation =:= match) orelse (Operation =:= update),\n ?tracker:remote_dispatch(Pid, Module, runtime)\n else\n _ -> ?tracker:add_export(Pid, Module)\n end,\n ok;\ntrace({alias_reference, _Meta, Module}, #{lexical_tracker := Pid} = E) ->\n case E of\n %% Alias references inside patterns and guards in functions are not\n %% compile time dependencies.\n #{function := nil} -> ?tracker:remote_dispatch(Pid, Module, compile);\n #{context := nil} -> ?tracker:remote_dispatch(Pid, Module, runtime);\n #{} -> ok\n end,\n ok;\ntrace({remote_function, _Meta, Module, _Function, _Arity}, #{lexical_tracker := Pid} = E) ->\n ?tracker:remote_dispatch(Pid, Module, mode(E)),\n ok;\ntrace({remote_macro, _Meta, Module, _Function, _Arity}, #{lexical_tracker := Pid}) ->\n ?tracker:remote_dispatch(Pid, Module, compile),\n ok;\ntrace({imported_function, _Meta, Module, Function, Arity}, #{lexical_tracker := Pid} = E) ->\n ?tracker:import_dispatch(Pid, Module, {Function, Arity}, mode(E)),\n ok;\ntrace({imported_macro, _Meta, Module, Function, Arity}, #{lexical_tracker := Pid}) ->\n ?tracker:import_dispatch(Pid, Module, {Function, Arity}, compile),\n ok;\ntrace({imported_quoted, _Meta, Module, Function, Arities}, #{lexical_tracker := Pid}) ->\n ?tracker:import_quoted(Pid, Module, Function, Arities),\n ok;\ntrace({compile_env, App, Path, Return}, #{lexical_tracker := Pid}) ->\n ?tracker:add_compile_env(Pid, App, Path, Return),\n ok;\ntrace(_, _) ->\n ok.\n\nmode(#{function := nil}) -> compile;\nmode(#{}) -> runtime.\n\n%% EXTERNAL SOURCES\n\nwith_file(File, #{lexical_tracker := nil} = E, Callback) ->\n Callback(E#{file := File});\nwith_file(File, #{lexical_tracker := Pid} = E, Callback) ->\n try\n ?tracker:set_file(Pid, File),\n Callback(E#{file := File})\n after\n ?tracker:reset_file(Pid)\n end.\n\n%% ERROR HANDLING\n\nwarn_unused_imports(Pid, E) ->\n [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_import, ModOrMFA})\n || {Module, Imports} <- ?tracker:collect_unused_imports(Pid),\n {ModOrMFA, Meta} <- unused_imports_for_module(Module, Imports)],\n ok.\n\nwarn_unused_requires(Pid, E) ->\n [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_require, Module, Alias, AliasUsed})\n || {Module, Meta, Alias, AliasUsed} <- ?tracker:collect_unused_requires(Pid)],\n ok.\n\nunused_imports_for_module(Module, Imports) ->\n case Imports of\n #{Module := Meta} -> [{Module, Meta}];\n #{} -> [{{Module, Fun, Arity}, Meta} || {{Fun, Arity}, Meta} <- maps:to_list(Imports)]\n end.\n\nwarn_unused_aliases(Pid, E) ->\n [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_alias, Module})\n || {Module, Meta} <- ?tracker:collect_unused_aliases(Pid)],\n ok.\n\nformat_error({unused_alias, Module}) ->\n io_lib:format(\"unused alias ~ts\", [elixir_aliases:inspect(Module)]);\nformat_error({unused_import, {Module, Function, Arity}}) ->\n io_lib:format(\"unused import ~ts.~ts/~w\", [elixir_aliases:inspect(Module), Function, Arity]);\nformat_error({unused_import, Module}) ->\n io_lib:format(\"unused import ~ts\", [elixir_aliases:inspect(Module)]);\nformat_error({unused_require, Module, Alias, AliasUsed}) ->\n Message = if\n Alias == false -> \"unused require ~ts\";\n AliasUsed -> \"unused require ~ts (convert it to an alias instead)\";\n true -> \"unused require ~ts (the alias is also unused)\"\n end,\n io_lib:format(Message, [elixir_aliases:inspect(Module)]).\n" }, { "path": "lib/elixir/src/elixir_map.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_map).\n-export([expand_map/4, expand_struct/5, format_error/1, maybe_load_struct_info/3]).\n-import(elixir_errors, [function_error/4, file_error/4, file_warn/4]).\n-include(\"elixir.hrl\").\n\nexpand_map(Meta, [{'|', UpdateMeta, [Left, Right]}], S, #{context := nil} = E) ->\n {[ELeft | ERight], SE, EE} = elixir_expand:expand_args([Left | Right], S, E),\n validate_kv(Meta, ERight, Right, E),\n {{'%{}', Meta, [{'|', UpdateMeta, [ELeft, ERight]}]}, SE, EE};\nexpand_map(Meta, [{'|', _, [_, _]}] = Args, _S, #{context := Context, file := File}) ->\n file_error(Meta, File, ?MODULE, {update_syntax_in_wrong_context, Context, {'%{}', Meta, Args}});\nexpand_map(Meta, Args, S, E) ->\n {EArgs, SE, EE} = elixir_expand:expand_args(Args, S, E),\n validate_kv(Meta, EArgs, Args, E),\n {{'%{}', Meta, EArgs}, SE, EE}.\n\nexpand_struct(Meta, Left, {'%{}', MapMeta, MapArgs}, S, #{context := Context} = E) ->\n CleanMapArgs = delete_struct_key(Meta, MapArgs, E),\n {[ELeft, ERight], SE, EE} = elixir_expand:expand_args([Left, {'%{}', MapMeta, CleanMapArgs}], S, E),\n\n case validate_struct(ELeft, Context) of\n true when is_atom(ELeft) ->\n case ERight of\n {'%{}', MapMeta, [{'|', _, [_, Assocs]}]} ->\n assert_and_trace_struct_assocs([{operation, update} | Meta], ELeft, Assocs, E),\n assert_struct_info_if_not_function(Meta, ELeft, Assocs, EE),\n {{'%', Meta, [ELeft, ERight]}, SE, EE};\n\n {'%{}', MapMeta, Assocs} when Context /= match ->\n AssocKeys = assert_and_trace_struct_assocs(Meta, ELeft, Assocs, EE),\n Struct = load_struct(Meta, ELeft, Assocs, EE),\n Keys = ['__struct__'] ++ AssocKeys,\n WithoutKeys = lists:sort(maps:to_list(maps:without(Keys, Struct))),\n StructAssocs = elixir_quote:escape(WithoutKeys, escape, false),\n {{'%', Meta, [ELeft, {'%{}', MapMeta, StructAssocs ++ Assocs}]}, SE, EE};\n\n {'%{}', MapMeta, Assocs} ->\n assert_and_trace_struct_assocs([{operation, match} | Meta], ELeft, Assocs, E),\n assert_struct_info_if_not_function(Meta, ELeft, Assocs, EE),\n {{'%', Meta, [ELeft, ERight]}, SE, EE}\n end;\n\n true ->\n {{'%', Meta, [ELeft, ERight]}, SE, EE};\n\n false when Context == match ->\n file_error(Meta, E, ?MODULE, {invalid_struct_name_in_match, ELeft});\n\n false ->\n file_error(Meta, E, ?MODULE, {invalid_struct_name, ELeft})\n end;\nexpand_struct(Meta, _Left, Right, _S, E) ->\n file_error(Meta, E, ?MODULE, {non_map_after_struct, Right}).\n\ndelete_struct_key(Meta, [{'|', PipeMeta, [Left, MapAssocs]}], E) ->\n [{'|', PipeMeta, [Left, delete_struct_key_assoc(Meta, MapAssocs, E)]}];\ndelete_struct_key(Meta, MapAssocs, E) ->\n delete_struct_key_assoc(Meta, MapAssocs, E).\n\ndelete_struct_key_assoc(Meta, Assocs, E) ->\n case lists:keytake('__struct__', 1, Assocs) of\n {value, _, CleanAssocs} ->\n file_warn(Meta, ?key(E, file), ?MODULE, ignored_struct_key_in_struct),\n CleanAssocs;\n false ->\n Assocs\n end.\n\nvalidate_match_key(Meta, {Name, _, Context}, E) when is_atom(Name), is_atom(Context) ->\n file_error(Meta, E, ?MODULE, {invalid_variable_in_map_key_match, Name});\nvalidate_match_key(Meta, {'::', _, [Left, _]}, E) ->\n validate_match_key(Meta, Left, E);\nvalidate_match_key(_, {'^', _, [{Name, _, Context}]}, _) when is_atom(Name), is_atom(Context) ->\n ok;\nvalidate_match_key(_, {'%{}', _, [_ | _]}, _) ->\n ok;\nvalidate_match_key(Meta, {Left, _, Right}, E) ->\n validate_match_key(Meta, Left, E),\n validate_match_key(Meta, Right, E);\nvalidate_match_key(Meta, {Left, Right}, E) ->\n validate_match_key(Meta, Left, E),\n validate_match_key(Meta, Right, E);\nvalidate_match_key(Meta, List, E) when is_list(List) ->\n [validate_match_key(Meta, Each, E) || Each <- List];\nvalidate_match_key(_, _, _) ->\n ok.\n\nvalidate_not_repeated(Meta, Key, Used, E) ->\n case is_literal(Key) andalso Used of\n #{Key := true} ->\n case E of\n #{context := match} -> function_error(Meta, ?key(E, file), ?MODULE, {repeated_key, Key});\n _ -> file_warn(Meta, ?key(E, file), ?MODULE, {repeated_key, Key})\n end,\n Used;\n\n #{} ->\n Used#{Key => true};\n\n false ->\n Used\n end.\n\nis_literal({_, _, _}) -> false;\nis_literal({Left, Right}) -> is_literal(Left) andalso is_literal(Right);\nis_literal([_ | _] = List) -> lists:all(fun is_literal/1, List);\nis_literal(_) -> true.\n\nvalidate_kv(Meta, KV, Original, #{context := Context} = E) ->\n lists:foldl(fun\n ({K, _V}, {Index, Used}) ->\n (Context == match) andalso validate_match_key(Meta, K, E),\n NewUsed = validate_not_repeated(Meta, K, Used, E),\n {Index + 1, NewUsed};\n (_, {Index, _Used}) ->\n file_error(Meta, E, ?MODULE, {not_kv_pair, lists:nth(Index, Original)})\n end, {1, #{}}, KV).\n\nvalidate_struct({'^', _, [{Var, _, Ctx}]}, match) when is_atom(Var), is_atom(Ctx) -> true;\nvalidate_struct({Var, _Meta, Ctx}, match) when is_atom(Var), is_atom(Ctx) -> true;\nvalidate_struct(Atom, _) when is_atom(Atom) -> true;\nvalidate_struct(_, _) -> false.\n\nassert_struct_info_if_not_function(Meta, Name, Assocs, #{function := nil} = E) ->\n case maybe_load_struct_info(Meta, Name, E) of\n {ok, Info} ->\n [lists:any(fun(Field) -> ?key(Field, field) =:= Key end, Info) orelse\n function_error(Meta, E, ?MODULE, {unknown_key_for_struct, Name, Key})\n || {Key, _} <- Assocs],\n ok;\n\n {error, Desc} ->\n file_error(Meta, E, ?MODULE, Desc)\n end;\nassert_struct_info_if_not_function(_Meta, _Name, _Assocs, _E) ->\n ok.\n\nmaybe_load_struct_info(Meta, Name, E) ->\n try\n case is_open(Name, Meta, E) andalso lookup_struct_info_from_data_tables(Name) of\n %% If I am accessing myself and there is no attribute,\n %% don't invoke the fallback to avoid calling loaded code.\n false when ?key(E, module) =:= Name -> nil;\n false -> Name:'__info__'(struct);\n InfoList -> InfoList\n end\n of\n nil -> {error, struct_undef(Name, E)};\n Info -> {ok, Info}\n catch\n error:undef -> {error, struct_undef(Name, E)}\n end.\n\nlookup_struct_info_from_data_tables(Module) ->\n try\n {Set, _} = elixir_module:data_tables(Module),\n ets:lookup_element(Set, {elixir, struct}, 2)\n catch\n _:_ -> false\n end.\n\nload_struct(Meta, Name, Assocs, E) ->\n try\n maybe_load_struct(Meta, Name, Assocs, E)\n of\n {ok, Struct} -> Struct;\n {error, Desc} -> file_error(Meta, E, ?MODULE, Desc)\n catch\n Kind:Reason ->\n Info = [{Name, '__struct__', 1, [{file, \"expanding struct\"}]},\n elixir_utils:caller(?line(Meta), ?key(E, file), ?key(E, module), ?key(E, function))],\n erlang:raise(Kind, Reason, Info)\n end.\n\nmaybe_load_struct(Meta, Name, Assocs, E) ->\n try\n case is_open(Name, Meta, E) andalso elixir_def:external_for(Meta, Name, '__struct__', 1, [def]) of\n %% If I am accessing myself and there is no __struct__ function,\n %% don't invoke the fallback to avoid calling loaded code.\n false when ?key(E, module) =:= Name ->\n error(undef);\n\n false ->\n Name:'__struct__'(Assocs);\n\n ExternalFun ->\n %% There is an inherent race condition when using external_for.\n %% By the time we got to execute the function, the ETS table\n %% with temporary definitions for the given module may no longer\n %% be available, so any function invocation happening inside the\n %% local function will fail. In this case, we need to fall back to\n %% the regular dispatching since the module will be available if\n %% the table has not been deleted (unless compilation of that\n %% module failed which should then cause this call to fail too).\n try\n ExternalFun(Assocs)\n catch\n error:undef -> Name:'__struct__'(Assocs)\n end\n end\n of\n #{'__struct__' := Name} = Struct ->\n [maps:is_key(Key, Struct) orelse\n function_error(Meta, E, ?MODULE, {unknown_key_for_struct, Name, Key})\n || {Key, _} <- Assocs],\n {ok, Struct};\n\n #{'__struct__' := StructName} when is_atom(StructName) ->\n {error, {struct_name_mismatch, Name, StructName}};\n\n Other ->\n {error, {invalid_struct_return_value, Name, Other}}\n catch\n error:undef -> {error, struct_undef(Name, E)}\n end.\n\nassert_and_trace_struct_assocs(Meta, Name, Assocs, E) ->\n Keys = [begin\n is_atom(K) orelse function_error(Meta, E, ?MODULE, {invalid_key_for_struct, K}),\n K\n end || {K, _} <- Assocs],\n elixir_env:trace({struct_expansion, Meta, Name, Keys}, E),\n Keys.\n\nis_open(Name, Meta, E) ->\n in_context(Name, E) orelse ((code:ensure_loaded(Name) /= {module, Name}) andalso wait_for_struct(Name, Meta, E)).\n\nin_context(Name, E) ->\n %% We also include the current module because it won't be present\n %% in context module in case the module name is defined dynamically.\n lists:member(Name, [?key(E, module) | ?key(E, context_modules)]).\n\nwait_for_struct(Module, Meta, E) ->\n (erlang:get(elixir_compiler_info) /= undefined) andalso\n ('Elixir.Kernel.ErrorHandler':ensure_compiled(Module, struct, hard, elixir_utils:get_line(Meta, E)) =:= found).\n\nstruct_undef(Name, E) ->\n case in_context(Name, E) andalso (?key(E, function) == nil) of\n true -> {inaccessible_struct, Name};\n false -> {undefined_struct, Name}\n end.\n\nformat_error({update_syntax_in_wrong_context, Context, Expr}) ->\n io_lib:format(\"cannot use map/struct update syntax in ~ts, got: ~ts\",\n [Context, 'Elixir.Macro':to_string(Expr)]);\nformat_error({invalid_struct_name_in_match, Expr}) ->\n Message =\n \"expected struct name in a match to be a compile time atom, alias or a \"\n \"variable, got: ~ts\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);\nformat_error({invalid_struct_name, Expr}) ->\n Message = \"expected struct name to be a compile time atom or alias, got: ~ts\",\n io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);\nformat_error({invalid_variable_in_map_key_match, Name}) ->\n Message =\n \"cannot use variable ~ts as map key inside a pattern. Map keys in patterns can only be literals \"\n \"(such as atoms, strings, tuples, and the like) or an existing variable matched with the pin operator \"\n \"(such as ^some_var)\",\n io_lib:format(Message, [Name]);\nformat_error({repeated_key, Key}) ->\n io_lib:format(\"key ~ts will be overridden in map\", ['Elixir.Macro':to_string(Key)]);\nformat_error({not_kv_pair, Expr}) ->\n io_lib:format(\"expected key-value pairs in a map, got: ~ts\",\n ['Elixir.Macro':to_string(Expr)]);\nformat_error({non_map_after_struct, Expr}) ->\n io_lib:format(\"expected struct to be followed by a map, got: ~ts\",\n ['Elixir.Macro':to_string(Expr)]);\nformat_error({struct_name_mismatch, Module, StructName}) ->\n Name = elixir_aliases:inspect(Module),\n Message = \"expected struct name returned by ~ts.__struct__/1 to be ~ts, got: ~ts\",\n io_lib:format(Message, [Name, Name, elixir_aliases:inspect(StructName)]);\nformat_error({invalid_struct_return_value, Module, Value}) ->\n Message =\n \"expected ~ts.__struct__/1 to return a map with a :__struct__ key that holds the \"\n \"name of the struct (atom), got: ~ts\",\n io_lib:format(Message, [elixir_aliases:inspect(Module), 'Elixir.Kernel':inspect(Value)]);\nformat_error({inaccessible_struct, Module}) ->\n Message =\n \"cannot access struct ~ts, the struct was not yet defined or the struct is \"\n \"being accessed in the same context that defines it\",\n io_lib:format(Message, [elixir_aliases:inspect(Module)]);\nformat_error({undefined_struct, Module}) ->\n Name = elixir_aliases:inspect(Module),\n io_lib:format(\n \"~ts.__struct__/1 is undefined, cannot expand struct ~ts. \"\n \"Make sure the struct name is correct. If the struct name exists and is correct \"\n \"but it still cannot be found, you likely have cyclic module usage in your code\",\n [Name, Name]);\nformat_error({unknown_key_for_struct, Module, Key}) ->\n io_lib:format(\"unknown key ~ts for struct ~ts\",\n ['Elixir.Macro':to_string(Key), elixir_aliases:inspect(Module)]);\nformat_error({invalid_key_for_struct, Key}) ->\n io_lib:format(\"invalid key ~ts for struct, struct keys must be atoms, got: \",\n ['Elixir.Macro':to_string(Key)]);\nformat_error(ignored_struct_key_in_struct) ->\n \"key :__struct__ is ignored when using structs\"." }, { "path": "lib/elixir/src/elixir_module.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_module).\n-export([file/1, data_tables/1, is_open/1, mode/1, delete_definition_attributes/6,\n compile/6, expand_callback/6, format_error/1, compiler_modules/0, exports_md5/3,\n write_cache/3, read_cache/2, next_counter/1, taint/1, cache_env/1, get_cached_env/1]).\n-include(\"elixir.hrl\").\n-define(counter_attr, {elixir, counter}).\n-define(cache_key, {elixir, cache_env}).\n\n%% Stores modules currently being defined by the compiler\n\ncompiler_modules() ->\n case erlang:get(elixir_compiler_modules) of\n undefined -> [];\n M when is_list(M) -> M\n end.\n\nput_compiler_modules([]) ->\n erlang:erase(elixir_compiler_modules);\nput_compiler_modules(M) when is_list(M) ->\n erlang:put(elixir_compiler_modules, M).\n\nexports_md5(Def, Defmacro, Struct) ->\n erlang:md5(term_to_binary({lists:sort(Def), lists:sort(Defmacro), Struct}, [deterministic])).\n\n%% Table functions\n\nfile(Module) ->\n ets:lookup_element(elixir_modules, Module, 4).\n\ndata_tables(Module) ->\n ets:lookup_element(elixir_modules, Module, 2).\n\nis_open(Module) ->\n ets:member(elixir_modules, Module).\n\nmode(Module) ->\n try ets:lookup_element(elixir_modules, Module, 5) of\n Mode -> Mode\n catch\n _:badarg -> closed\n end.\n\nmake_readonly(Module) ->\n ets:update_element(elixir_modules, Module, {5, readonly}).\n\ndelete_definition_attributes(#{module := Module}, _, _, _, _, _) ->\n {DataSet, _} = data_tables(Module),\n ets:delete(DataSet, doc),\n ets:delete(DataSet, deprecated),\n ets:delete(DataSet, impl).\n\nwrite_cache(Module, Key, Value) ->\n {DataSet, _} = data_tables(Module),\n ets:insert(DataSet, {{cache, Key}, Value}).\n\nread_cache(Module, Key) ->\n {DataSet, _} = data_tables(Module),\n ets:lookup_element(DataSet, {cache, Key}, 2).\n\nnext_counter(nil) -> erlang:unique_integer();\nnext_counter(Module) ->\n try\n {DataSet, _} = data_tables(Module),\n {Module, ets:update_counter(DataSet, ?counter_attr, 1)}\n catch\n _:_ -> erlang:unique_integer()\n end.\n\ntaint(Module) ->\n try\n {DataSet, _} = data_tables(Module),\n ets:insert(DataSet, [{{elixir, taint}}]),\n true\n catch\n _:_ -> false\n end.\n\ncache_env(#{line := Line, module := Module} = E) ->\n {Set, _} = data_tables(Module),\n Cache = elixir_env:reset_vars(E#{line := nil}),\n PrevKey = ets:lookup_element(Set, ?cache_key, 2),\n\n Pos =\n case ets:lookup(Set, {cache_env, PrevKey}) of\n [{_, Cache}] ->\n PrevKey;\n _ ->\n NewKey = PrevKey + 1,\n ets:insert(Set, [{{cache_env, NewKey}, Cache}, {?cache_key, NewKey}]),\n NewKey\n end,\n\n {Module, {Line, Pos}}.\n\nget_cached_env({Module, {Line, Pos}}) ->\n {Set, _} = data_tables(Module),\n (ets:lookup_element(Set, {cache_env, Pos}, 2))#{line := Line};\nget_cached_env(Env) ->\n Env.\n\n%% Compilation hook\n\ncompile(Meta, Module, Block, Vars, Prune, Env) ->\n ModuleAsCharlist = validate_module_name(Module),\n #{function := Function, versioned_vars := OldVerVars} = Env,\n\n {VerVars, _} =\n lists:mapfoldl(fun({Var, _}, I) -> {{Var, I}, I + 1} end, 0, maps:to_list(OldVerVars)),\n\n BaseEnv = Env#{module := Module, versioned_vars := maps:from_list(VerVars)},\n\n MaybeLexEnv =\n case Function of\n nil -> BaseEnv;\n _ -> BaseEnv#{lexical_tracker := nil, tracers := [], function := nil}\n end,\n\n case MaybeLexEnv of\n #{lexical_tracker := nil} ->\n elixir_lexical:run(\n MaybeLexEnv,\n fun(LexEnv) -> compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, LexEnv) end,\n fun(_LexEnv) -> ok end\n );\n _ ->\n compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, MaybeLexEnv)\n end.\n\nvalidate_module_name(Module) when Module == nil; is_boolean(Module); not is_atom(Module) ->\n invalid_module_name(Module);\nvalidate_module_name(Module) ->\n Charlist = atom_to_list(Module),\n case lists:any(fun(Char) -> (Char =:= $/) or (Char =:= $\\\\) end, Charlist) of\n true -> invalid_module_name(Module);\n false -> Charlist\n end.\n\ninvalid_module_name(Module) ->\n %% We raise an argument error to keep it close to Elixir errors before it starts.\n erlang:error('Elixir.ArgumentError':exception(\n <<\"invalid module name: \",\n ('Elixir.Kernel':inspect(Module))/binary>>\n )).\n\ncompile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->\n Anno = ?ann(Meta),\n Line = erl_anno:line(Anno),\n\n File = ?key(E, file),\n check_module_availability(Module, Line, E),\n elixir_env:trace(defmodule, E),\n\n CompilerModules = compiler_modules(),\n {Tables, Ref} = build(Module, Line, File, E),\n {DataSet, DataBag} = Tables,\n\n try\n put_compiler_modules([Module | CompilerModules]),\n {Result, ModuleE, CallbackE} = eval_form(Line, Module, DataBag, Block, Vars, Prune, E),\n CheckerInfo = checker_info(),\n {BeamLocation, Forceload} = beam_location(ModuleAsCharlist),\n\n {Binary, PersistedAttributes, Autoload} =\n elixir_erl_compiler:spawn(fun() ->\n PersistedAttributes = ets:lookup_element(DataBag, persisted_attributes, 2),\n Attributes = attributes(DataSet, DataBag, PersistedAttributes),\n AllDefinitions = elixir_def:fetch_definitions(Module, E),\n\n OnLoadAttribute = lists:keyfind(on_load, 1, Attributes),\n validate_on_load_attribute(OnLoadAttribute, AllDefinitions, DataBag, Line, E),\n\n DialyzerAttribute = lists:keyfind(dialyzer, 1, Attributes),\n validate_dialyzer_attribute(DialyzerAttribute, AllDefinitions, Line, E),\n\n NifsAttribute = lists:keyfind(nifs, 1, Attributes),\n validate_nifs_attribute(NifsAttribute, AllDefinitions, Line, E),\n elixir_import:ensure_no_local_conflict(Module, AllDefinitions, E),\n make_readonly(Module),\n\n (not elixir_config:is_bootstrap()) andalso\n 'Elixir.Module':'__check_attributes__'(E, DataSet, DataBag),\n\n AfterVerify = bag_lookup_element(DataBag, {accumulate, after_verify}, 2),\n [elixir_env:trace({remote_function, [{line, Line}], VerifyMod, VerifyFun, 1}, CallbackE) ||\n {VerifyMod, VerifyFun} <- AfterVerify],\n\n %% Ensure there are no errors before we infer types\n compile_error_if_tainted(DataSet, E),\n\n {Signatures, Unreachable} =\n case elixir_config:is_bootstrap() of\n true -> {#{}, []};\n false ->\n UsedPrivate = bag_lookup_element(DataBag, used_private, 2),\n 'Elixir.Module.Types':infer(Module, File, Attributes, AllDefinitions, UsedPrivate, E, CheckerInfo)\n end,\n\n RawCompileOpts = bag_lookup_element(DataBag, {accumulate, compile}, 2),\n CompileOpts = validate_compile_opts(RawCompileOpts, AllDefinitions, Unreachable, Line, E),\n Impls = bag_lookup_element(DataBag, impls, 2),\n\n Struct = get_struct(DataSet),\n set_exports_md5(DataSet, AllDefinitions, Struct),\n\n ModuleMap = #{\n struct => Struct,\n module => Module,\n anno => Anno,\n file => File,\n relative_file => elixir_utils:relative_to_cwd(File),\n attributes => Attributes,\n definitions => AllDefinitions,\n after_verify => AfterVerify,\n compile_opts => CompileOpts,\n deprecated => get_deprecated(DataBag),\n defines_behaviour => defines_behaviour(DataBag),\n impls => Impls,\n unreachable => Unreachable\n },\n\n compile_error_if_tainted(DataSet, E),\n Binary = elixir_erl:compile(ModuleMap, Signatures),\n Autoload = Forceload or proplists:get_value(autoload, CompileOpts, false),\n spawn_parallel_checker(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation),\n {Binary, PersistedAttributes, Autoload}\n end),\n\n Autoload andalso code:load_binary(Module, BeamLocation, Binary),\n make_module_available(Module, Binary, Autoload),\n put_compiler_modules(CompilerModules),\n eval_callbacks(Line, DataBag, after_compile, [CallbackE, Binary], CallbackE),\n elixir_env:trace({on_module, Binary, none}, ModuleE),\n warn_unused_attributes(DataSet, DataBag, PersistedAttributes, E),\n (element(2, CheckerInfo) == nil) andalso\n [VerifyMod:VerifyFun(Module) ||\n {VerifyMod, VerifyFun} <- bag_lookup_element(DataBag, {accumulate, after_verify}, 2)],\n {module, Module, Binary, Result}\n catch\n error:undef:Stacktrace ->\n case Stacktrace of\n [{Module, Fun, Args, _Info} | _] = Stack when is_list(Args) ->\n compile_undef(Module, Fun, length(Args), Stack);\n [{Module, Fun, Arity, _Info} | _] = Stack ->\n compile_undef(Module, Fun, Arity, Stack);\n Stack ->\n erlang:raise(error, undef, Stack)\n end\n after\n put_compiler_modules(CompilerModules),\n ets:delete(DataSet),\n ets:delete(DataBag),\n elixir_code_server:call({undefmodule, Ref})\n end.\n\ncompile_error_if_tainted(DataSet, E) ->\n case ets:member(DataSet, {elixir, taint}) of\n true -> elixir_errors:compile_error(E);\n false -> ok\n end.\n\nset_exports_md5(DataSet, AllDefinitions, Struct) ->\n {Funs, Macros} =\n lists:foldl(fun\n ({Tuple, def, _Meta, _Clauses}, {Funs, Macros}) -> {[Tuple | Funs], Macros};\n ({Tuple, defmacro, _Meta, _Clauses}, {Funs, Macros}) -> {Funs, [Tuple | Macros]};\n ({_Tuple, _Kind, _Meta, _Clauses}, {Funs, Macros}) -> {Funs, Macros}\n end, {[], []}, AllDefinitions),\n MD5 = exports_md5(Funs, Macros, Struct),\n ets:insert(DataSet, {exports_md5, MD5, nil, []}).\n\nvalidate_compile_opts(Opts, Defs, Unreachable, Line, E) ->\n lists:flatmap(fun (Opt) -> validate_compile_opt(Opt, Defs, Unreachable, Line, E) end, Opts).\n\n%% TODO: Make this an error on v2.0\nvalidate_compile_opt({parse_transform, Module} = Opt, _Defs, _Unreachable, Line, E) ->\n elixir_errors:file_warn([{line, Line}], E, ?MODULE, {parse_transform, Module}),\n [Opt];\nvalidate_compile_opt({inline, Inlines}, Defs, Unreachable, Line, E) ->\n case validate_inlines(Inlines, Defs, Unreachable, []) of\n {ok, []} ->\n [];\n {ok, FilteredInlines} ->\n [{inline, FilteredInlines}];\n {error, Reason} ->\n elixir_errors:module_error([{line, Line}], E, ?MODULE, Reason),\n []\n end;\nvalidate_compile_opt(Opt, Defs, Unreachable, Line, E) when is_list(Opt) ->\n validate_compile_opts(Opt, Defs, Unreachable, Line, E);\nvalidate_compile_opt(Opt, _Defs, _Unreachable, _Line, _E) ->\n [Opt].\n\nvalidate_inlines([Inline | Inlines], Defs, Unreachable, Acc) ->\n case lists:keyfind(Inline, 1, Defs) of\n false ->\n {error, {undefined_function, {compile, inline}, Inline}};\n {_Def, Kind, _Meta, _Clauses} when Kind == defmacro; Kind == defmacrop ->\n {error, {bad_macro, {compile, inline}, Inline}};\n _ ->\n case lists:member(Inline, Unreachable) of\n true -> validate_inlines(Inlines, Defs, Unreachable, Acc);\n false -> validate_inlines(Inlines, Defs, Unreachable, [Inline | Acc])\n end\n end;\nvalidate_inlines([], _Defs, _Unreachable, Acc) -> {ok, Acc}.\n\nvalidate_on_load_attribute({on_load, Def}, Defs, Bag, Line, E) ->\n case lists:keyfind(Def, 1, Defs) of\n false ->\n elixir_errors:module_error([{line, Line}], E, ?MODULE, {undefined_function, on_load, Def});\n {_Def, Kind, _Meta, _Clauses} when Kind == defmacro; Kind == defmacrop ->\n elixir_errors:module_error([{line, Line}], E, ?MODULE, {bad_macro, on_load, Def});\n {{Name, Arity}, Kind, _Meta, _Clauses} ->\n elixir_env:trace({local_function, [{line, Line}], Name, Arity}, E),\n (Kind == defp) andalso ets:insert(Bag, {used_private, Def})\n end;\nvalidate_on_load_attribute(false, _Defs, _Bag, _Line, _E) -> ok.\n\nvalidate_dialyzer_attribute({dialyzer, Dialyzer}, Defs, Line, E) ->\n [validate_definition({dialyzer, Key}, Fun, Defs, Line, E)\n || {Key, Funs} <- lists:flatten([Dialyzer]), Fun <- lists:flatten([Funs])];\nvalidate_dialyzer_attribute(false, _Defs, _Line, _E) ->\n ok.\n\nvalidate_nifs_attribute({nifs, Funs}, Defs, Line, E) ->\n [validate_definition(nifs, Fun, Defs, Line, E) || Fun <- lists:flatten([Funs])];\nvalidate_nifs_attribute(false, _Defs, _Line, _E) ->\n ok.\n\nvalidate_definition(Key, Fun, Defs, Line, E) ->\n case lists:keyfind(Fun, 1, Defs) of\n false ->\n elixir_errors:module_error([{line, Line}], E, ?MODULE, {undefined_function, Key, Fun});\n {Fun, Type, _Meta, _Clauses} when Type == defmacro; Type == defmacrop ->\n elixir_errors:module_error([{line, Line}], E, ?MODULE, {bad_macro, Key, Fun});\n _ ->\n ok\n end.\n\ndefines_behaviour(DataBag) ->\n ets:member(DataBag, {accumulate, callback}) orelse ets:member(DataBag, {accumulate, macrocallback}).\n\n%% An undef error for a function in the module being compiled might result in an\n%% exception message suggesting the current module is not loaded. This is\n%% misleading so use a custom reason.\ncompile_undef(Module, Fun, Arity, Stack) ->\n case elixir_config:is_bootstrap() of\n false ->\n Opts = [{module, Module}, {function, Fun}, {arity, Arity},\n {reason, 'function not available'}],\n Exception = 'Elixir.UndefinedFunctionError':exception(Opts),\n erlang:raise(error, Exception, Stack);\n true ->\n erlang:raise(error, undef, Stack)\n end.\n\n%% Handle reserved modules and duplicates.\n\ncheck_module_availability(Module, Line, E) ->\n Reserved = ['Elixir.True', 'Elixir.False', 'Elixir.Nil',\n 'Elixir.Any', 'Elixir.BitString', 'Elixir.PID',\n 'Elixir.Reference', 'Elixir.Elixir', 'Elixir'],\n\n case lists:member(Module, Reserved) of\n true -> elixir_errors:file_error([{line, Line}], E, ?MODULE, {module_reserved, Module});\n false -> ok\n end,\n\n case elixir_config:get(ignore_module_conflict) of\n false ->\n case code:ensure_loaded(Module) of\n {module, _} ->\n elixir_errors:file_warn([{line, Line}], E, ?MODULE, {module_defined, Module});\n {error, _} ->\n ok\n end;\n true ->\n ok\n end.\n\n%% Hook that builds both attribute and functions and set up common hooks.\n\nbuild(Module, Line, File, E) ->\n %% In the set table we store:\n %%\n %% * {Attribute, Value, AccumulateOrUnsetOrReadOrUnreadline, TraceLineOrNil}\n %% * {{elixir, ...}, ...}\n %% * {{cache, ...}, ...}\n %% * {{function, Tuple}, ...}, {{macro, Tuple}, ...}\n %% * {{type, Tuple}, ...}, {{opaque, Tuple}, ...}\n %% * {{callback, Tuple}, ...}, {{macrocallback, Tuple}, ...}\n %% * {{def, Tuple}, ...} (from elixir_def)\n %% * {{overridable, Tuple}, ...} (from elixir_overridable)\n %%\n DataSet = ets:new(Module, [set, public]),\n\n %% In the bag table we store:\n %%\n %% * {{accumulate, Attribute}, ...} (includes typespecs)\n %% * {warn_attributes, ...}\n %% * {impls, ...}\n %% * {deprecated, ...}\n %% * {persisted_attributes, ...}\n %% * {defs, ...} (from elixir_def)\n %% * {overridables, ...} (from elixir_overridable)\n %% * {{default, Name}, ...} (from elixir_def)\n %% * {{clauses, Tuple}, ...} (from elixir_def)\n %%\n DataBag = ets:new(Module, [duplicate_bag, public]),\n\n ets:insert(DataSet, [\n % {Key, Value, ReadOrUnreadLine, TraceLine}\n {moduledoc, nil, nil, []},\n\n % {Key, Value, accumulate, TraceLine}\n {after_compile, [], accumulate, []},\n {after_verify, [], accumulate, []},\n {before_compile, [], accumulate, []},\n {behaviour, [], accumulate, []},\n {compile, [], accumulate, []},\n {derive, [], accumulate, []},\n {dialyzer, [], accumulate, []},\n {external_resource, [], accumulate, []},\n {nifs, [], accumulate, []},\n {on_definition, [], accumulate, []},\n {opaque, [], accumulate, []},\n {type, [], accumulate, []},\n {typep, [], accumulate, []},\n {spec, [], accumulate, []},\n {callback, [], accumulate, []},\n {macrocallback, [], accumulate, []},\n {optional_callbacks, [], accumulate, []},\n\n % Others\n {?cache_key, 0},\n {?counter_attr, 0}\n ]),\n\n Persisted = [behaviour, dialyzer, external_resource, nifs, on_load, vsn],\n ets:insert(DataBag, [{persisted_attributes, Attr} || Attr <- Persisted]),\n\n OnDefinition =\n case elixir_config:is_bootstrap() of\n false -> {'Elixir.Module', compile_definition_attributes};\n _ -> {elixir_module, delete_definition_attributes}\n end,\n ets:insert(DataBag, {{accumulate, on_definition}, OnDefinition}),\n\n %% Setup definition related modules\n Tables = {DataSet, DataBag},\n elixir_def:setup(Tables),\n Tuple = {Module, Tables, Line, File, all},\n\n Ref =\n case elixir_code_server:call({defmodule, Module, self(), Tuple}) of\n {ok, ModuleRef} ->\n ModuleRef;\n {error, {Module, _, OldLine, OldFile, _}} ->\n ets:delete(DataSet),\n ets:delete(DataBag),\n Error = {module_in_definition, Module, OldFile, OldLine},\n elixir_errors:file_error([{line, Line}], E, ?MODULE, Error)\n end,\n\n {Tables, Ref}.\n\n%% Handles module and callback evaluations.\n\neval_form(Line, Module, DataBag, Block, Vars, Prune, E) ->\n %% Given Elixir modules can get very long to compile due to metaprogramming,\n %% we disable expansions that have linear time to code size.\n {Value, ExS, EE} =\n case elixir_config:get(module_definition) of\n interpreted -> elixir_compiler:interpret(Block, Vars, E);\n compiled -> elixir_compiler:compile(Block, Vars, [no_bool_opt, no_ssa_opt], E)\n end,\n elixir_overridable:store_not_overridden(Module),\n EV = (elixir_env:reset_vars(EE))#{line := Line},\n EC = eval_callbacks(Line, DataBag, before_compile, [EV], EV),\n elixir_overridable:store_not_overridden(Module),\n {Value, maybe_prune_versioned_vars(Prune, Vars, ExS, E), EC}.\n\nmaybe_prune_versioned_vars(false, _Vars, _Exs, E) ->\n E;\nmaybe_prune_versioned_vars(true, Vars, ExS, E) ->\n PruneBefore = length(Vars),\n #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,\n\n VersionedVars =\n maps:filter(fun\n (Pair, Version) when Version < PruneBefore, not is_map_key({Pair, Version}, Unused) -> false;\n (_, _) -> true\n end, ExVars),\n\n E#{versioned_vars := VersionedVars}.\n\neval_callbacks(Line, DataBag, Name, Args, E) ->\n Callbacks = bag_lookup_element(DataBag, {accumulate, Name}, 2),\n lists:foldl(fun({M, F}, Acc) ->\n expand_callback(Line, M, F, Args, Acc, fun(AM, AF, AA) -> apply(AM, AF, AA) end)\n end, E, Callbacks).\n\nexpand_callback(Line, M, F, Args, Acc, Fun) ->\n E = elixir_env:reset_vars(Acc),\n S = elixir_env:env_to_ex(E),\n Meta = [{line, Line}, {required, true}],\n\n {EE, _S, ET} =\n elixir_dispatch:dispatch_require(Meta, M, F, Args, S, E, fun(AM, AF) ->\n Fun(AM, AF, Args),\n {ok, S, E}\n end),\n\n if\n is_atom(EE) ->\n ET;\n true ->\n try\n {_Value, _Binding, EF} = elixir:eval_forms(EE, [], ET),\n EF\n catch\n Kind:Reason:Stacktrace ->\n Info = {M, F, length(Args), location(Line, E)},\n erlang:raise(Kind, Reason, prune_stacktrace(Info, Stacktrace))\n end\n end.\n\n%% Add attributes handling to the form\n\nattributes(DataSet, DataBag, PersistedAttributes) ->\n [{Key, Value} || Key <- PersistedAttributes, Value <- lookup_attribute(DataSet, DataBag, Key)].\n\nlookup_attribute(DataSet, DataBag, Key) when is_atom(Key) ->\n case ets:lookup(DataSet, Key) of\n [{_, _, accumulate, _}] -> bag_lookup_element(DataBag, {accumulate, Key}, 2);\n [{_, _, unset, _}] -> [];\n [{_, Value, _, _}] -> [Value];\n [] -> []\n end.\n\nwarn_unused_attributes(DataSet, DataBag, PersistedAttrs, E) ->\n StoredAttrs = bag_lookup_element(DataBag, warn_attributes, 2),\n %% This is the same list as in Module.put_attribute\n %% without moduledoc which are never warned on.\n Attrs = [doc, typedoc, impl, deprecated | StoredAttrs -- PersistedAttrs],\n Query = [{{Attr, '_', '$1', '_'}, [{is_integer, '$1'}], [[Attr, '$1']]} || Attr <- Attrs],\n [elixir_errors:file_warn([{line, Line}], E, ?MODULE, {unused_attribute, Key})\n || [Key, Line] <- ets:select(DataSet, Query)].\n\nget_struct(Set) ->\n case ets:lookup(Set, {elixir, struct}) of\n [] -> nil;\n [{_, Fields}] -> Fields\n end.\n\nget_deprecated(Bag) ->\n lists:usort(bag_lookup_element(Bag, deprecated, 2)).\n\nbag_lookup_element(Table, Name, Pos) ->\n try\n ets:lookup_element(Table, Name, Pos)\n catch\n error:badarg -> []\n end.\n\nbeam_location(ModuleAsCharlist) ->\n case get(elixir_compiler_dest) of\n {Dest, Forceload} when is_binary(Dest) ->\n {filename:join(elixir_utils:characters_to_list(Dest), ModuleAsCharlist ++ \".beam\"),\n Forceload};\n _ ->\n {\"\", true}\n end.\n\n%% Integration with elixir_compiler that makes the module available\n\nchecker_info() ->\n case get(elixir_checker_info) of\n undefined -> {self(), nil};\n _ -> 'Elixir.Module.ParallelChecker':get()\n end.\n\nspawn_parallel_checker({_, nil}, _Module, _ModuleMap, _Signatures, _BeamLocation) ->\n ok;\nspawn_parallel_checker(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation) ->\n Log =\n case erlang:get(elixir_code_diagnostics) of\n {_, false} -> false;\n _ -> true\n end,\n 'Elixir.Module.ParallelChecker':spawn(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation, Log).\n\nmake_module_available(Module, Binary, Loaded) ->\n case get(elixir_module_binaries) of\n Current when is_list(Current) ->\n put(elixir_module_binaries, [{Module, Binary} | Current]);\n _ ->\n ok\n end,\n\n case get(elixir_compiler_info) of\n undefined ->\n ok;\n {PID, _} ->\n Ref = make_ref(),\n PID ! {module_available, self(), Ref, get(elixir_compiler_file), Module, Binary, Loaded},\n receive {Ref, ack} -> ok end\n end.\n\n%% Error handling and helpers.\n\n%% We've reached the elixir_module or eval internals, skip it with the rest\nprune_stacktrace(Info, [{elixir, eval_forms, _, _} | _]) ->\n [Info];\nprune_stacktrace(Info, [{elixir_module, _, _, _} | _]) ->\n [Info];\nprune_stacktrace(Info, [H | T]) ->\n [H | prune_stacktrace(Info, T)];\nprune_stacktrace(Info, []) ->\n [Info].\n\nlocation(Line, E) ->\n [{file, elixir_utils:characters_to_list(?key(E, file))}, {line, Line}].\n\nformat_error({unused_attribute, typedoc}) ->\n \"module attribute @typedoc was set but no type follows it\";\nformat_error({unused_attribute, doc}) ->\n \"module attribute @doc was set but no definition follows it\";\nformat_error({unused_attribute, impl}) ->\n \"module attribute @impl was set but no definition follows it\";\nformat_error({unused_attribute, deprecated}) ->\n \"module attribute @deprecated was set but no definition follows it\";\nformat_error({unused_attribute, Attr}) ->\n io_lib:format(\"module attribute @~ts was set but never used\", [Attr]);\nformat_error({module_defined, Module}) ->\n Extra =\n case code:which(Module) of\n \"\" ->\n \" (current version defined in memory)\";\n Path when is_list(Path) ->\n io_lib:format(\" (current version loaded from ~ts)\", [elixir_utils:relative_to_cwd(Path)]);\n _ ->\n \"\"\n end,\n io_lib:format(\"redefining module ~ts~ts\", [elixir_aliases:inspect(Module), Extra]);\nformat_error({module_reserved, Module}) ->\n io_lib:format(\"module ~ts is reserved and cannot be defined\", [elixir_aliases:inspect(Module)]);\nformat_error({module_in_definition, Module, File, Line}) ->\n io_lib:format(\"cannot define module ~ts because it is currently being defined in ~ts:~B\",\n [elixir_aliases:inspect(Module), elixir_utils:relative_to_cwd(File), Line]);\nformat_error({undefined_function, {Attr, Key}, {Name, Arity}}) ->\n io_lib:format(\"undefined function ~ts/~B given to @~ts :~ts\", [Name, Arity, Attr, Key]);\nformat_error({undefined_function, Attr, {Name, Arity}}) ->\n io_lib:format(\"undefined function ~ts/~B given to @~ts\", [Name, Arity, Attr]);\nformat_error({bad_macro, {Attr, Key}, {Name, Arity}}) ->\n io_lib:format(\"macro ~ts/~B given to @~ts :~ts (only functions are supported)\", [Name, Arity, Attr, Key]);\nformat_error({bad_macro, Attr, {Name, Arity}}) ->\n io_lib:format(\"macro ~ts/~B given to @~ts (only functions are supported)\", [Name, Arity, Attr]);\nformat_error({parse_transform, Module}) ->\n io_lib:format(\"@compile {:parse_transform, ~ts} is deprecated. Elixir will no longer support \"\n \"Erlang-based transforms in future versions\", [elixir_aliases:inspect(Module)]).\n" }, { "path": "lib/elixir/src/elixir_overridable.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n% Holds the logic responsible for defining overridable functions and handling super.\n-module(elixir_overridable).\n-export([overridables_for/1, overridable_for/2,\n record_overridable/3, super/4,\n store_not_overridden/1, format_error/1]).\n-include(\"elixir.hrl\").\n-define(overridden_pos, 4).\n\noverridables_for(Module) ->\n {_, Bag} = elixir_module:data_tables(Module),\n try\n ets:lookup_element(Bag, overridables, 2)\n catch\n _:_ -> []\n end.\n\noverridable_for(Module, Tuple) ->\n {Set, _} = elixir_module:data_tables(Module),\n\n case ets:lookup(Set, {overridable, Tuple}) of\n [Overridable] -> Overridable;\n [] -> not_overridable\n end.\n\nrecord_overridable(Module, Tuple, Def) ->\n {Set, Bag} = elixir_module:data_tables(Module),\n\n case ets:insert_new(Set, {{overridable, Tuple}, 1, Def, false}) of\n true ->\n ets:insert(Bag, {overridables, Tuple});\n false ->\n [{_, Count, PreviousDef, _}] = ets:lookup(Set, {overridable, Tuple}),\n {{_, Kind, Meta, File, _, _}, _} = Def,\n {{_, PreviousKind, _, _, _, _}, _} = PreviousDef,\n\n case is_valid_kind(Kind, PreviousKind) of\n true ->\n ets:insert(Set, {{overridable, Tuple}, Count + 1, Def, false});\n false ->\n elixir_errors:file_error(Meta, File, ?MODULE, {bad_kind, Module, Tuple, Kind})\n end\n end,\n\n ok.\n\nsuper(Meta, Module, Tuple, E) ->\n {Set, _} = elixir_module:data_tables(Module),\n\n case ets:lookup(Set, {overridable, Tuple}) of\n [Overridable] ->\n store(Set, Module, Tuple, Overridable, true);\n [] ->\n elixir_errors:file_error(Meta, E, ?MODULE, {no_super, Module, Tuple})\n end.\n\nstore_not_overridden(Module) ->\n {Set, Bag} = elixir_module:data_tables(Module),\n\n lists:foreach(fun({_, Tuple}) ->\n [Overridable] = ets:lookup(Set, {overridable, Tuple}),\n\n case ets:lookup(Set, {def, Tuple}) of\n [] ->\n store(Set, Module, Tuple, Overridable, false);\n [{_, Kind, Meta, File, _, _}] ->\n {{_, OverridableKind, _, _, _, _}, _} = element(3, Overridable),\n\n case is_valid_kind(Kind, OverridableKind) of\n true -> ok;\n false -> elixir_errors:file_error(Meta, File, ?MODULE, {bad_kind, Module, Tuple, Kind})\n end\n end\n end, ets:lookup(Bag, overridables)).\n\n%% Private\n\nstore(Set, Module, Tuple, {_, Count, Def, Overridden}, Hidden) ->\n {{{def, {Name, Arity}}, Kind, BaseMeta, File, _Check,\n {Defaults, _HasBody, _LastDefaults}}, Clauses} = Def,\n Meta = [{from_super, Hidden} | BaseMeta],\n\n {FinalKind, FinalName, FinalArity, FinalClauses} =\n case Hidden of\n false ->\n {Kind, Name, Arity, Clauses};\n true when Kind == defmacro; Kind == defmacrop ->\n {defmacrop, name(Name, Count), Arity, Clauses};\n true ->\n {defp, name(Name, Count), Arity, Clauses}\n end,\n\n case Overridden of\n false ->\n ets:update_element(Set, {overridable, Tuple}, {?overridden_pos, true}),\n elixir_def:store_definition(false, FinalKind, Meta, FinalName, FinalArity,\n File, Module, Defaults, FinalClauses);\n true ->\n ok\n end,\n\n {FinalKind, FinalName, Meta}.\n\nname(Name, Count) when is_integer(Count) ->\n list_to_atom(atom_to_list(Name) ++ \" (overridable \" ++ integer_to_list(Count) ++ \")\").\n\nis_valid_kind(NewKind, PreviousKind) ->\n is_macro(NewKind) =:= is_macro(PreviousKind).\n\nis_macro(defmacro) -> true;\nis_macro(defmacrop) -> true;\nis_macro(_) -> false.\n\n%% Error handling\nformat_error({bad_kind, Module, {Name, Arity}, Kind}) ->\n case is_macro(Kind) of\n true ->\n io_lib:format(\"cannot override function (def, defp) ~ts/~B in module ~ts as a macro (defmacro, defmacrop)\",\n [Name, Arity, elixir_aliases:inspect(Module)]);\n false ->\n io_lib:format(\"cannot override macro (defmacro, defmacrop) ~ts/~B in module ~ts as a function (def, defp)\",\n [Name, Arity, elixir_aliases:inspect(Module)])\n end;\n\nformat_error({no_super, Module, {Name, Arity}}) ->\n Bins = [format_fa(Tuple) || Tuple <- overridables_for(Module)],\n Joined = 'Elixir.Enum':join(Bins, <<\", \">>),\n io_lib:format(\"no super defined for ~ts/~B in module ~ts. Overridable functions available are: ~ts\",\n [Name, Arity, elixir_aliases:inspect(Module), Joined]).\n\nformat_fa({Name, Arity}) ->\n A = 'Elixir.Macro':inspect_atom(remote_call, Name),\n B = integer_to_binary(Arity),\n <>.\n" }, { "path": "lib/elixir/src/elixir_parser.yrl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% REUSE-IgnoreStart\nHeader \"%% SPDX-License-Identifier: Apache-2.0\"\n\"%% SPDX-FileCopyrightText: 2021 The Elixir Team\"\n\"%% SPDX-FileCopyrightText: 2012 Plataformatec\".\n%% REUSE-IgnoreEnd\n\nNonterminals\n grammar expr_list\n expr container_expr block_expr access_expr\n no_parens_expr no_parens_zero_expr no_parens_one_expr no_parens_one_ambig_expr\n bracket_expr bracket_at_expr bracket_arg matched_expr unmatched_expr sub_matched_expr\n unmatched_op_expr matched_op_expr no_parens_op_expr no_parens_many_expr\n comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol capture_op_eol\n dual_op_eol mult_op_eol power_op_eol concat_op_eol xor_op_eol pipe_op_eol\n stab_op_eol arrow_op_eol match_op_eol when_op_eol in_op_eol in_match_op_eol\n type_op_eol rel_op_eol range_op_eol ternary_op_eol\n open_paren close_paren empty_paren eoe\n list list_args open_bracket close_bracket\n tuple open_curly close_curly\n bitstring open_bit close_bit\n map map_op map_base_expr map_close map_args\n assoc_op_eol assoc_expr assoc_base assoc assoc_update assoc_update_kw\n container_args_base container_args\n call_args_parens_expr call_args_parens_base call_args_parens parens_call\n call_args_no_parens_one call_args_no_parens_ambig call_args_no_parens_expr\n call_args_no_parens_comma_expr call_args_no_parens_all call_args_no_parens_many\n call_args_no_parens_many_strict\n stab stab_eoe stab_expr stab_op_eol_and_expr stab_parens_many\n kw_eol kw_base kw_data kw_call call_args_no_parens_kw_expr call_args_no_parens_kw\n dot_op dot_alias dot_bracket_identifier dot_call_identifier\n dot_identifier dot_op_identifier dot_do_identifier dot_paren_identifier\n do_block fn_eoe do_eoe block_eoe block_item block_list\n .\n\nTerminals\n identifier kw_identifier kw_identifier_safe kw_identifier_unsafe bracket_identifier\n paren_identifier do_identifier block_identifier op_identifier\n fn 'end' alias\n atom atom_quoted atom_safe atom_unsafe bin_string list_string sigil\n bin_heredoc list_heredoc\n comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op ellipsis_op\n type_op dual_op mult_op power_op concat_op range_op xor_op pipe_op stab_op when_op\n capture_int capture_op assoc_op rel_op ternary_op dot_call_op\n 'true' 'false' 'nil' 'do' eol ';' ',' '.'\n '(' ')' '[' ']' '{' '}' '<<' '>>' '%{}' '%'\n int flt char\n .\n\nRootsymbol grammar.\n\n%% Two shift/reduce conflicts coming from call_args_parens and\n%% one coming from empty_paren on stab.\nExpect 3.\n\n%% Changes in ops and precedence should be reflected on:\n%%\n%% 1. lib/elixir/lib/code/identifier.ex\n%% 2. lib/elixir/pages/operators.md\n%% 3. lib/iex/lib/iex/evaluator.ex\n%%\n%% Note though the operator => in practice has lower precedence\n%% than all others, its entry in the table is only to support the\n%% %{user | foo => bar} syntax.\n\nLeft 5 do.\nRight 10 stab_op_eol. %% ->\nLeft 20 ','.\nLeft 40 in_match_op_eol. %% <-, \\\\ (allowed in matches along =)\nRight 50 when_op_eol. %% when\nRight 60 type_op_eol. %% ::\nRight 70 pipe_op_eol. %% |\nRight 80 assoc_op_eol. %% =>\nNonassoc 90 capture_op_eol. %% &\nNonassoc 90 ellipsis_op. %% ...\nRight 100 match_op_eol. %% =\nLeft 120 or_op_eol. %% ||, |||, or\nLeft 130 and_op_eol. %% &&, &&&, and\nLeft 140 comp_op_eol. %% ==, !=, =~, ===, !==\nLeft 150 rel_op_eol. %% <, >, <=, >=\nLeft 160 arrow_op_eol. %% <<<, >>>, |>, <<~, ~>>, <~, ~>, <~>, <|>\nLeft 170 in_op_eol. %% in, not in\nLeft 180 xor_op_eol. %% ^^^\nRight 190 ternary_op_eol. %% //\nRight 200 concat_op_eol. %% ++, --, +++, ---, <>\nRight 200 range_op_eol. %% ..\nLeft 210 dual_op_eol. %% +, -\nLeft 220 mult_op_eol. %% *, /\nLeft 230 power_op_eol. %% **\nNonassoc 300 unary_op_eol. %% +, -, !, ^, not, ~~~\nLeft 310 dot_call_op.\nLeft 310 dot_op. %% .\nNonassoc 320 at_op_eol. %% @\nNonassoc 330 dot_identifier.\n\n%%% MAIN FLOW OF EXPRESSIONS\n\ngrammar -> eoe : {'__block__', meta_from_location({1, 1, nil}), []}.\ngrammar -> expr_list : build_block(reverse('$1')).\ngrammar -> eoe expr_list : build_block(reverse('$2')).\ngrammar -> expr_list eoe : build_block(reverse(annotate_eoe('$2', '$1'))).\ngrammar -> eoe expr_list eoe : build_block(reverse(annotate_eoe('$3', '$2'))).\ngrammar -> '$empty' : {'__block__', meta_from_location({1, 1, nil}), []}.\n\n% Note expressions are on reverse order\nexpr_list -> expr : ['$1'].\nexpr_list -> expr_list eoe expr : ['$3' | annotate_eoe('$2', '$1')].\n\nexpr -> matched_expr : '$1'.\nexpr -> no_parens_expr : '$1'.\nexpr -> unmatched_expr : '$1'.\n\n%% In Elixir we have three main call syntaxes: with parentheses,\n%% without parentheses and with do blocks. They are represented\n%% in the AST as matched, no_parens and unmatched.\n%%\n%% Calls without parentheses are further divided according to how\n%% problematic they are:\n%%\n%% (a) no_parens_one: a call with one unproblematic argument\n%% (for example, `f a` or `f g a` and similar) (includes unary operators)\n%%\n%% (b) no_parens_many: a call with several arguments (for example, `f a, b`)\n%%\n%% (c) no_parens_one_ambig: a call with one argument which is\n%% itself a no_parens_many or no_parens_one_ambig (for example, `f g a, b`,\n%% `f g h a, b` and similar)\n%%\n%% Note, in particular, that no_parens_one_ambig expressions are\n%% ambiguous and are interpreted such that the outer function has\n%% arity 1. For instance, `f g a, b` is interpreted as `f(g(a, b))` rather\n%% than `f(g(a), b)`. Hence the name, no_parens_one_ambig.\n%%\n%% The distinction is required because we can't, for example, have\n%% a function call with a do block as argument inside another do\n%% block call, unless there are parentheses:\n%%\n%% if if true do true else false end do #=> invalid\n%% if(if true do true else false end) do #=> valid\n%%\n%% Similarly, it is not possible to nest calls without parentheses\n%% if their arity is more than 1:\n%%\n%% foo a, bar b, c #=> invalid\n%% foo(a, bar b, c) #=> invalid\n%% foo bar a, b #=> valid\n%% foo a, bar(b, c) #=> valid\n%%\n%% So the different grammar rules need to take into account\n%% if calls without parentheses are do blocks in particular\n%% segments and act accordingly.\nmatched_expr -> matched_expr matched_op_expr : build_op('$1', '$2').\nmatched_expr -> unary_op_eol matched_expr : build_unary_op('$1', '$2').\nmatched_expr -> at_op_eol matched_expr : build_unary_op('$1', '$2').\nmatched_expr -> capture_op_eol matched_expr : build_unary_op('$1', '$2').\nmatched_expr -> ellipsis_op matched_expr : build_unary_op('$1', '$2').\nmatched_expr -> no_parens_one_expr : '$1'.\nmatched_expr -> sub_matched_expr : '$1'.\n\nunmatched_expr -> matched_expr unmatched_op_expr : build_op('$1', '$2').\nunmatched_expr -> unmatched_expr matched_op_expr : build_op('$1', '$2').\nunmatched_expr -> unmatched_expr unmatched_op_expr : build_op('$1', '$2').\nunmatched_expr -> unmatched_expr no_parens_op_expr : warn_no_parens_after_do_op('$2'), build_op('$1', '$2').\nunmatched_expr -> unary_op_eol expr : build_unary_op('$1', '$2').\nunmatched_expr -> at_op_eol expr : build_unary_op('$1', '$2').\nunmatched_expr -> capture_op_eol expr : build_unary_op('$1', '$2').\nunmatched_expr -> ellipsis_op expr : build_unary_op('$1', '$2').\nunmatched_expr -> block_expr : '$1'.\n\nno_parens_expr -> matched_expr no_parens_op_expr : build_op('$1', '$2').\nno_parens_expr -> unary_op_eol no_parens_expr : build_unary_op('$1', '$2').\nno_parens_expr -> at_op_eol no_parens_expr : build_unary_op('$1', '$2').\nno_parens_expr -> capture_op_eol no_parens_expr : build_unary_op('$1', '$2').\nno_parens_expr -> ellipsis_op no_parens_expr : build_unary_op('$1', '$2').\nno_parens_expr -> no_parens_one_ambig_expr : '$1'.\nno_parens_expr -> no_parens_many_expr : '$1'.\n\nblock_expr -> dot_call_identifier call_args_parens do_block : build_parens('$1', '$2', '$3').\nblock_expr -> dot_call_identifier call_args_parens call_args_parens do_block : build_nested_parens('$1', '$2', '$3', '$4').\nblock_expr -> dot_do_identifier do_block : build_no_parens_do_block('$1', [], '$2').\nblock_expr -> dot_op_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3').\nblock_expr -> dot_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3').\n\nmatched_op_expr -> match_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> dual_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> mult_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> power_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> concat_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> range_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> ternary_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> xor_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> and_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> or_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> in_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> in_match_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> type_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> when_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> pipe_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> comp_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> rel_op_eol matched_expr : {'$1', '$2'}.\nmatched_op_expr -> arrow_op_eol matched_expr : {'$1', '$2'}.\n\n%% We warn exclusively of |> and friends because they are used\n%% in other languages with lower precedence than function application,\n%% which can be the source of confusion.\nmatched_op_expr -> arrow_op_eol no_parens_one_expr : warn_pipe('$1', '$2'), {'$1', '$2'}.\n\nunmatched_op_expr -> match_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> dual_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> mult_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> power_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> concat_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> range_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> ternary_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> xor_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> and_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> or_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> in_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> in_match_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> type_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> when_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> pipe_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> comp_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> rel_op_eol unmatched_expr : {'$1', '$2'}.\nunmatched_op_expr -> arrow_op_eol unmatched_expr : {'$1', '$2'}.\n\nno_parens_op_expr -> match_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> dual_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> mult_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> power_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> concat_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> range_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> ternary_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> xor_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> and_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> or_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> in_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> in_match_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> type_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> when_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> pipe_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> comp_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> rel_op_eol no_parens_expr : {'$1', '$2'}.\nno_parens_op_expr -> arrow_op_eol no_parens_expr : warn_pipe('$1', '$2'), {'$1', '$2'}.\n\n%% Allow when (and only when) with keywords\nno_parens_op_expr -> when_op_eol call_args_no_parens_kw : {'$1', '$2'}.\n\nno_parens_one_ambig_expr -> dot_op_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2').\nno_parens_one_ambig_expr -> dot_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2').\n\nno_parens_many_expr -> dot_op_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2').\nno_parens_many_expr -> dot_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2').\n\nno_parens_one_expr -> dot_op_identifier call_args_no_parens_one : build_no_parens('$1', '$2').\nno_parens_one_expr -> dot_identifier call_args_no_parens_one : build_no_parens('$1', '$2').\nno_parens_zero_expr -> dot_do_identifier : build_identifier('$1').\nno_parens_zero_expr -> dot_identifier : build_identifier('$1').\n\nsub_matched_expr -> no_parens_zero_expr : '$1'.\nsub_matched_expr -> range_op : build_nullary_op('$1').\nsub_matched_expr -> ellipsis_op : build_nullary_op('$1').\nsub_matched_expr -> access_expr : '$1'.\nsub_matched_expr -> access_expr kw_identifier : error_invalid_kw_identifier('$2').\n\n%% From this point on, we just have constructs that can be\n%% used with the access syntax. Note that (dot_)identifier\n%% is not included in this list simply because the tokenizer\n%% marks identifiers followed by brackets as bracket_identifier.\naccess_expr -> bracket_at_expr : '$1'.\naccess_expr -> bracket_expr : '$1'.\naccess_expr -> capture_int int : build_unary_op('$1', number_value('$2')).\naccess_expr -> fn_eoe stab_eoe 'end' : build_fn('$1', '$2', '$3').\naccess_expr -> open_paren stab_eoe ')' : build_paren_stab('$1', '$2', '$3').\naccess_expr -> open_paren ';' stab_eoe ')' : build_paren_stab('$1', '$3', '$4').\naccess_expr -> open_paren ';' close_paren : build_paren_stab('$1', [], '$3').\naccess_expr -> empty_paren : warn_empty_paren('$1'), {'__block__', parens_meta('$1'), []}.\naccess_expr -> int : handle_number(number_value('$1'), '$1', ?exprs('$1')).\naccess_expr -> flt : handle_number(number_value('$1'), '$1', ?exprs('$1')).\naccess_expr -> char : handle_number(?exprs('$1'), '$1', number_value('$1')).\naccess_expr -> list : element(1, '$1').\naccess_expr -> map : '$1'.\naccess_expr -> tuple : '$1'.\naccess_expr -> 'true' : handle_literal(?id('$1'), '$1').\naccess_expr -> 'false' : handle_literal(?id('$1'), '$1').\naccess_expr -> 'nil' : handle_literal(?id('$1'), '$1').\naccess_expr -> bin_string : build_bin_string('$1', delimiter(<<$\">>)).\naccess_expr -> list_string : build_list_string('$1', delimiter(<<$'>>)).\naccess_expr -> bin_heredoc : build_bin_heredoc('$1').\naccess_expr -> list_heredoc : build_list_heredoc('$1').\naccess_expr -> bitstring : '$1'.\naccess_expr -> sigil : build_sigil('$1').\naccess_expr -> atom : handle_literal(?exprs('$1'), '$1', atom_colon_meta('$1')).\naccess_expr -> atom_quoted : handle_literal(?exprs('$1'), '$1', atom_delimiter_meta('$1')).\naccess_expr -> atom_safe : build_quoted_atom('$1', true, atom_delimiter_meta('$1')).\naccess_expr -> atom_unsafe : build_quoted_atom('$1', false, atom_delimiter_meta('$1')).\naccess_expr -> dot_alias : '$1'.\naccess_expr -> parens_call : '$1'.\n\n%% Also used by maps and structs\nparens_call -> dot_call_identifier call_args_parens : build_parens('$1', '$2', {[], []}).\nparens_call -> dot_call_identifier call_args_parens call_args_parens : build_nested_parens('$1', '$2', '$3', {[], []}).\n\nbracket_arg -> open_bracket kw_data close_bracket : build_access_arg('$1', '$2', '$3').\nbracket_arg -> open_bracket container_expr close_bracket : build_access_arg('$1', '$2', '$3').\nbracket_arg -> open_bracket container_expr ',' close_bracket : build_access_arg('$1', '$2', '$4').\nbracket_arg -> open_bracket container_expr ',' container_args close_bracket : error_too_many_access_syntax('$3').\n\nbracket_expr -> dot_bracket_identifier bracket_arg : build_access(build_identifier('$1'), meta_with_from_brackets('$2')).\nbracket_expr -> access_expr bracket_arg : build_access('$1', meta_with_from_brackets('$2')).\n\nbracket_at_expr -> at_op_eol dot_bracket_identifier bracket_arg :\n build_access(build_unary_op('$1', build_identifier('$2')), meta_with_from_brackets('$3')).\nbracket_at_expr -> at_op_eol access_expr bracket_arg :\n build_access(build_unary_op('$1', '$2'), meta_with_from_brackets('$3')).\n\n%% Blocks\n\ndo_block -> do_eoe 'end' :\n {do_end_meta('$1', '$2'), [[{handle_literal(do, '$1'), {'__block__', meta_from_token('$1'), []}}]]}.\ndo_block -> do_eoe stab_eoe 'end' :\n {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), build_stab('$2', meta_from_token('$1'))}]]}.\ndo_block -> do_eoe block_list 'end' :\n {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), {'__block__', meta_from_token('$1'), []}} | '$2']]}.\ndo_block -> do_eoe stab_eoe block_list 'end' :\n {do_end_meta('$1', '$4'), [[{handle_literal(do, '$1'), build_stab('$2', meta_from_token('$1'))} | '$3']]}.\n\neoe -> eol : '$1'.\neoe -> ';' : '$1'.\neoe -> eol ';' : '$1'.\n\nfn_eoe -> 'fn' : '$1'.\nfn_eoe -> 'fn' eoe : next_is_eol('$1', '$2').\n\ndo_eoe -> 'do' : '$1'.\ndo_eoe -> 'do' eoe : '$1'.\n\nblock_eoe -> block_identifier : '$1'.\nblock_eoe -> block_identifier eoe : '$1'.\n\nstab -> stab_expr : ['$1'].\nstab -> stab eoe stab_expr : ['$3' | annotate_eoe('$2', '$1')].\n\nstab_eoe -> stab : '$1'.\nstab_eoe -> stab eoe : annotate_eoe('$2', '$1').\n\nstab_expr -> expr :\n '$1'.\nstab_expr -> stab_op_eol_and_expr :\n build_op([], '$1').\nstab_expr -> empty_paren stab_op_eol_and_expr :\n build_op_with_meta([], '$2', parens_meta('$1')).\nstab_expr -> empty_paren when_op expr stab_op_eol_and_expr :\n build_op_with_meta([{'when', meta_from_token('$2'), ['$3']}], '$4', parens_meta('$1')).\nstab_expr -> call_args_no_parens_all stab_op_eol_and_expr :\n build_op(unwrap_when(unwrap_splice('$1')), '$2').\nstab_expr -> stab_parens_many stab_op_eol_and_expr :\n build_op_with_meta(unwrap_splice(element(2, '$1')), '$2', parens_meta('$1')).\nstab_expr -> stab_parens_many when_op expr stab_op_eol_and_expr :\n build_op_with_meta([{'when', meta_from_token('$2'), unwrap_splice(element(2, '$1')) ++ ['$3']}], '$4', parens_meta('$1')).\n\nstab_op_eol_and_expr -> stab_op_eol expr : {'$1', '$2'}.\nstab_op_eol_and_expr -> stab_op_eol : warn_empty_stab_clause('$1'), {'$1', handle_literal(nil, '$1')}.\n\nblock_item -> block_eoe stab_eoe :\n {handle_literal(?exprs('$1'), '$1'), build_stab('$2', [])}.\nblock_item -> block_eoe :\n {handle_literal(?exprs('$1'), '$1'), {'__block__', [], []}}.\n\nblock_list -> block_item : ['$1'].\nblock_list -> block_item block_list : ['$1' | '$2'].\n\n%% Helpers\n\nopen_paren -> '(' : '$1'.\nopen_paren -> '(' eol : next_is_eol('$1', '$2').\nclose_paren -> ')' : '$1'.\nclose_paren -> eol ')' : '$2'.\n\nempty_paren -> open_paren ')' : {'$1', '$2'}.\n\nopen_bracket -> '[' : '$1'.\nopen_bracket -> '[' eol : next_is_eol('$1', '$2').\nclose_bracket -> ']' : '$1'.\nclose_bracket -> eol ']' : '$2'.\n\nopen_bit -> '<<' : '$1'.\nopen_bit -> '<<' eol : next_is_eol('$1', '$2').\nclose_bit -> '>>' : '$1'.\nclose_bit -> eol '>>' : '$2'.\n\nopen_curly -> '{' : '$1'.\nopen_curly -> '{' eol : next_is_eol('$1', '$2').\nclose_curly -> '}' : '$1'.\nclose_curly -> eol '}' : '$2'.\n\n% Operators\n\nunary_op_eol -> unary_op : '$1'.\nunary_op_eol -> unary_op eol : '$1'.\nunary_op_eol -> dual_op : '$1'.\nunary_op_eol -> dual_op eol : '$1'.\nunary_op_eol -> ternary_op : '$1'.\nunary_op_eol -> ternary_op eol : '$1'.\n\ncapture_op_eol -> capture_op : '$1'.\ncapture_op_eol -> capture_op eol : '$1'.\n\nat_op_eol -> at_op : '$1'.\nat_op_eol -> at_op eol : '$1'.\n\nmatch_op_eol -> match_op : '$1'.\nmatch_op_eol -> match_op eol : next_is_eol('$1', '$2').\n\ndual_op_eol -> dual_op : '$1'.\ndual_op_eol -> dual_op eol : next_is_eol('$1', '$2').\n\nmult_op_eol -> mult_op : '$1'.\nmult_op_eol -> mult_op eol : next_is_eol('$1', '$2').\n\npower_op_eol -> power_op : '$1'.\npower_op_eol -> power_op eol : next_is_eol('$1', '$2').\n\nconcat_op_eol -> concat_op : '$1'.\nconcat_op_eol -> concat_op eol : next_is_eol('$1', '$2').\n\nrange_op_eol -> range_op : '$1'.\nrange_op_eol -> range_op eol : next_is_eol('$1', '$2').\n\nternary_op_eol -> ternary_op : '$1'.\nternary_op_eol -> ternary_op eol : next_is_eol('$1', '$2').\n\nxor_op_eol -> xor_op : '$1'.\nxor_op_eol -> xor_op eol : next_is_eol('$1', '$2').\n\npipe_op_eol -> pipe_op : '$1'.\npipe_op_eol -> pipe_op eol : next_is_eol('$1', '$2').\n\nand_op_eol -> and_op : '$1'.\nand_op_eol -> and_op eol : next_is_eol('$1', '$2').\n\nor_op_eol -> or_op : '$1'.\nor_op_eol -> or_op eol : next_is_eol('$1', '$2').\n\nin_op_eol -> in_op : '$1'.\nin_op_eol -> in_op eol : next_is_eol('$1', '$2').\n\nin_match_op_eol -> in_match_op : '$1'.\nin_match_op_eol -> in_match_op eol : next_is_eol('$1', '$2').\n\ntype_op_eol -> type_op : '$1'.\ntype_op_eol -> type_op eol : next_is_eol('$1', '$2').\n\nwhen_op_eol -> when_op : '$1'.\nwhen_op_eol -> when_op eol : next_is_eol('$1', '$2').\n\nstab_op_eol -> stab_op : '$1'.\nstab_op_eol -> stab_op eol : next_is_eol('$1', '$2').\n\ncomp_op_eol -> comp_op : '$1'.\ncomp_op_eol -> comp_op eol : next_is_eol('$1', '$2').\n\nrel_op_eol -> rel_op : '$1'.\nrel_op_eol -> rel_op eol : next_is_eol('$1', '$2').\n\narrow_op_eol -> arrow_op : '$1'.\narrow_op_eol -> arrow_op eol : next_is_eol('$1', '$2').\n\n% Dot operator\n\ndot_op -> '.' : '$1'.\ndot_op -> '.' eol : '$1'.\n\ndot_identifier -> identifier : '$1'.\ndot_identifier -> matched_expr dot_op identifier : build_dot('$2', '$1', '$3').\n\ndot_alias -> alias : build_alias('$1').\ndot_alias -> matched_expr dot_op alias : build_dot_alias('$2', '$1', '$3').\ndot_alias -> matched_expr dot_op open_curly '}' : build_dot_container('$2', '$1', [], newlines_pair('$3', '$4')).\ndot_alias -> matched_expr dot_op open_curly container_args close_curly : build_dot_container('$2', '$1', '$4', newlines_pair('$3', '$5')).\n\ndot_op_identifier -> op_identifier : '$1'.\ndot_op_identifier -> matched_expr dot_op op_identifier : build_dot('$2', '$1', '$3').\n\ndot_do_identifier -> do_identifier : '$1'.\ndot_do_identifier -> matched_expr dot_op do_identifier : build_dot('$2', '$1', '$3').\n\ndot_bracket_identifier -> bracket_identifier : '$1'.\ndot_bracket_identifier -> matched_expr dot_op bracket_identifier : build_dot('$2', '$1', '$3').\n\ndot_paren_identifier -> paren_identifier : '$1'.\ndot_paren_identifier -> matched_expr dot_op paren_identifier : build_dot('$2', '$1', '$3').\n\ndot_call_identifier -> dot_paren_identifier : '$1'.\ndot_call_identifier -> matched_expr dot_call_op : {'.', meta_from_token('$2'), ['$1']}. % Fun/local calls\n\n% Function calls with no parentheses\n\ncall_args_no_parens_expr -> matched_expr : '$1'.\ncall_args_no_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1').\n\ncall_args_no_parens_comma_expr -> matched_expr ',' call_args_no_parens_expr : ['$3', '$1'].\ncall_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ',' call_args_no_parens_expr : ['$3' | '$1'].\n\ncall_args_no_parens_all -> call_args_no_parens_one : '$1'.\ncall_args_no_parens_all -> call_args_no_parens_ambig : '$1'.\ncall_args_no_parens_all -> call_args_no_parens_many : '$1'.\n\ncall_args_no_parens_one -> call_args_no_parens_kw : ['$1'].\ncall_args_no_parens_one -> matched_expr : ['$1'].\n\n%% This is the only no parens ambiguity where we don't\n%% raise nor warn: \"parent_call nested_call 1, 2, 3\"\n%% always assumes that all arguments are nested.\ncall_args_no_parens_ambig -> no_parens_expr : ['$1'].\n\ncall_args_no_parens_many -> matched_expr ',' call_args_no_parens_kw : ['$1', '$3'].\ncall_args_no_parens_many -> call_args_no_parens_comma_expr : reverse('$1').\ncall_args_no_parens_many -> call_args_no_parens_comma_expr ',' call_args_no_parens_kw : reverse(['$3' | '$1']).\n\ncall_args_no_parens_many_strict -> call_args_no_parens_many : '$1'.\ncall_args_no_parens_many_strict -> open_paren call_args_no_parens_kw close_paren : error_no_parens_strict('$1').\ncall_args_no_parens_many_strict -> open_paren call_args_no_parens_many close_paren : error_no_parens_strict('$1').\n\nstab_parens_many -> open_paren call_args_no_parens_kw close_paren : {'$1', ['$2'], '$3'}.\nstab_parens_many -> open_paren call_args_no_parens_many close_paren : {'$1', '$2', '$3'}.\n\n% Containers\n\ncontainer_expr -> matched_expr : '$1'.\ncontainer_expr -> unmatched_expr : '$1'.\ncontainer_expr -> no_parens_expr : error_no_parens_container_strict('$1').\n\ncontainer_args_base -> container_expr : ['$1'].\ncontainer_args_base -> container_args_base ',' container_expr : ['$3' | '$1'].\n\ncontainer_args -> container_args_base : reverse('$1').\ncontainer_args -> container_args_base ',' : reverse('$1').\ncontainer_args -> container_args_base ',' kw_data : reverse(['$3' | '$1']).\n\n% Function calls with parentheses\n\ncall_args_parens_expr -> matched_expr : '$1'.\ncall_args_parens_expr -> unmatched_expr : '$1'.\ncall_args_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1').\n\ncall_args_parens_base -> call_args_parens_expr : ['$1'].\ncall_args_parens_base -> call_args_parens_base ',' call_args_parens_expr : ['$3' | '$1'].\n\ncall_args_parens -> open_paren ')' :\n {newlines_pair('$1', '$2'), []}.\ncall_args_parens -> open_paren no_parens_expr close_paren :\n {newlines_pair('$1', '$3'), ['$2']}.\ncall_args_parens -> open_paren kw_call close_paren :\n {newlines_pair('$1', '$3'), ['$2']}.\ncall_args_parens -> open_paren call_args_parens_base close_paren :\n {newlines_pair('$1', '$3'), reverse('$2')}.\ncall_args_parens -> open_paren call_args_parens_base ',' kw_call close_paren :\n {newlines_pair('$1', '$5'), reverse(['$4' | '$2'])}.\n\n% KV\n\nkw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1', kw_identifier_meta('$1')).\nkw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1', kw_identifier_meta('$1')).\nkw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, kw_identifier_meta('$1')).\nkw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, kw_identifier_meta('$1')).\nkw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, kw_identifier_meta('$1')).\nkw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, kw_identifier_meta('$1')).\n\nkw_base -> kw_eol container_expr : [{'$1', '$2'}].\nkw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'} | '$1'].\n\nkw_call -> kw_base : reverse('$1').\nkw_call -> kw_base ',' : warn_trailing_comma('$2'), reverse('$1').\nkw_call -> kw_base ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', '$1', '$3').\n\nkw_data -> kw_base : reverse('$1').\nkw_data -> kw_base ',' : reverse('$1').\nkw_data -> kw_base ',' matched_expr : maybe_bad_keyword_data_follow_up('$2', '$1', '$3').\n\ncall_args_no_parens_kw_expr -> kw_eol matched_expr : {'$1', '$2'}.\ncall_args_no_parens_kw_expr -> kw_eol no_parens_expr : warn_nested_no_parens_keyword('$1', '$2'), {'$1', '$2'}.\n\ncall_args_no_parens_kw -> call_args_no_parens_kw_expr : ['$1'].\ncall_args_no_parens_kw -> call_args_no_parens_kw_expr ',' call_args_no_parens_kw : ['$1' | '$3'].\ncall_args_no_parens_kw -> call_args_no_parens_kw_expr ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', ['$1'], '$3').\n\n% Lists\n\nlist_args -> kw_data : '$1'.\nlist_args -> container_args_base : reverse('$1').\nlist_args -> container_args_base ',' : reverse('$1').\nlist_args -> container_args_base ',' kw_data : reverse('$1', '$3').\n\nlist -> open_bracket ']' : build_list('$1', [], '$2').\nlist -> open_bracket list_args close_bracket : build_list('$1', '$2', '$3').\n\n% Tuple\n\ntuple -> open_curly '}' : build_tuple('$1', [], '$2').\ntuple -> open_curly kw_data '}' : bad_keyword('$1', tuple, \"'{'\").\ntuple -> open_curly container_args close_curly : build_tuple('$1', '$2', '$3').\n\n% Bitstrings\n\nbitstring -> open_bit '>>' : build_bit('$1', [], '$2').\nbitstring -> open_bit kw_data '>>' : bad_keyword('$1', bitstring, \"'<<'\").\nbitstring -> open_bit container_args close_bit : build_bit('$1', '$2', '$3').\n\n% Map and structs\n\nmap_base_expr -> sub_matched_expr : '$1'.\nmap_base_expr -> at_op_eol map_base_expr : build_unary_op('$1', '$2').\nmap_base_expr -> unary_op_eol map_base_expr : build_unary_op('$1', '$2').\nmap_base_expr -> ellipsis_op map_base_expr : build_unary_op('$1', '$2').\n\nassoc_op_eol -> assoc_op : '$1'.\nassoc_op_eol -> assoc_op eol : '$1'.\n\nassoc_expr -> matched_expr assoc_op_eol matched_expr : {with_assoc_meta('$1', '$2'), '$3'}.\nassoc_expr -> unmatched_expr assoc_op_eol unmatched_expr : {with_assoc_meta('$1', '$2'), '$3'}.\nassoc_expr -> matched_expr assoc_op_eol unmatched_expr : {with_assoc_meta('$1', '$2'), '$3'}.\nassoc_expr -> unmatched_expr assoc_op_eol matched_expr : {with_assoc_meta('$1', '$2'), '$3'}.\nassoc_expr -> map_base_expr : '$1'.\n\nassoc_update -> matched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}.\nassoc_update -> unmatched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}.\n\nassoc_update_kw -> matched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}.\nassoc_update_kw -> unmatched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}.\n\nassoc_base -> assoc_expr : ['$1'].\nassoc_base -> assoc_base ',' assoc_expr : ['$3' | '$1'].\n\nassoc -> assoc_base : reverse('$1').\nassoc -> assoc_base ',' : reverse('$1').\n\nmap_op -> '%{}' : '$1'.\nmap_op -> '%{}' eol : '$1'.\n\nmap_close -> kw_data close_curly : {'$1', '$2'}.\nmap_close -> assoc close_curly : {'$1', '$2'}.\nmap_close -> assoc_base ',' kw_data close_curly : {reverse('$1', '$3'), '$4'}.\n\nmap_args -> open_curly '}' : build_map('$1', [], '$2').\nmap_args -> open_curly map_close : build_map('$1', element(1, '$2'), element(2, '$2')).\nmap_args -> open_curly assoc_update close_curly : build_map_update('$1', '$2', '$3', []).\nmap_args -> open_curly assoc_update ',' close_curly : build_map_update('$1', '$2', '$4', []).\nmap_args -> open_curly assoc_update ',' map_close : build_map_update('$1', '$2', element(2, '$4'), element(1, '$4')).\nmap_args -> open_curly assoc_update_kw close_curly : build_map_update('$1', '$2', '$3', []).\n\nmap -> map_op map_args : '$2'.\nmap -> '%' map_base_expr map_args : {'%', meta_from_token('$1'), ['$2', '$3']}.\nmap -> '%' map_base_expr eol map_args : {'%', meta_from_token('$1'), ['$2', '$4']}.\n\nErlang code.\n\n-define(columns(), get(elixir_parser_columns)).\n-define(token_metadata(), get(elixir_token_metadata)).\n\n-define(id(Token), element(1, Token)).\n-define(location(Token), element(2, Token)).\n-define(op(Token), element(3, Token)).\n-define(meta(Node), element(2, Node)).\n-define(exprs(Node), element(3, Node)).\n-define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')).\n\n-compile({inline, meta_from_token/1, meta_from_location/1, is_eol/1}).\n-import(lists, [reverse/1, reverse/2]).\n\nmeta_from_token(Token) ->\n meta_from_location(?location(Token)).\n\nmeta_from_location({Line, Column, _}) ->\n case ?columns() of\n true -> [{line, Line}, {column, Column}];\n false -> [{line, Line}]\n end.\n\ndo_end_meta(Do, End) ->\n case ?token_metadata() of\n true ->\n [{do, meta_from_token(Do)}, {'end', meta_from_token(End)}];\n false ->\n []\n end.\n\nmeta_from_token_with_closing(Begin, End) ->\n case ?token_metadata() of\n true ->\n [{closing, meta_from_token(End)} | meta_from_token(Begin)];\n false ->\n meta_from_token(Begin)\n end.\n\nappend_non_empty(Left, []) -> Left;\nappend_non_empty(Left, Right) -> Left ++ Right.\n\n%% Handle metadata in literals\n\nhandle_literal(Literal, Token) ->\n handle_literal(Literal, Token, []).\n\nhandle_literal(Literal, Token, ExtraMeta) ->\n case get(elixir_literal_encoder) of\n false ->\n Literal;\n\n Fun ->\n Meta = ExtraMeta ++ meta_from_token(Token),\n case Fun(Literal, Meta) of\n {ok, EncodedLiteral} ->\n EncodedLiteral;\n {error, Reason} ->\n return_error(?location(Token), elixir_utils:characters_to_list(Reason) ++ [\": \"], \"literal\")\n end\n end.\n\nhandle_number(Number, Token, Original) ->\n case ?token_metadata() of\n true -> handle_literal(Number, Token, [{token, elixir_utils:characters_to_binary(Original)}]);\n false -> handle_literal(Number, Token, [])\n end.\n\nnumber_value({_, {_, _, Value}, _}) ->\n Value.\n\n%% Operators\n\nbuild_op_with_meta(Left, {Op, Right}, Meta) ->\n {Op1, OpMeta, Args} = build_op(Left, Op, Right),\n {Op1, Meta ++ OpMeta, Args}.\n\nbuild_op(Left, {Op, Right}) ->\n build_op(Left, Op, Right).\n\nbuild_op(AST, {_Kind, Location, '//'}, Right) ->\n case AST of\n {'..', Meta, [Left, Middle]} ->\n {'..//', Meta, [Left, Middle, Right]};\n\n _ ->\n return_error(Location, \"the range step operator (//) must immediately follow the range definition operator (..), for example: 1..9//2. If you wanted to define a default argument, use (\\\\\\\\) instead. Syntax error before: \", \"'//'\")\n end;\n\nbuild_op({UOp, UMeta, [Left]}, {_Kind, {Line, Column, _} = Location, 'in'}, Right) when ?rearrange_uop(UOp) ->\n %% TODO: Remove \"not left in right\" rearrangement on v2.0\n warn({Line, Column}, case UOp of\n '!' -> \"\\\"!expr1 in expr2\\\" is deprecated, use \\\"expr1 not in expr2\\\" instead\";\n 'not' -> \"\\\"not expr1 in expr2\\\" is deprecated, use \\\"expr1 not in expr2\\\" instead\"\n end),\n Meta = meta_from_location(Location),\n {UOp, UMeta, [{'in', Meta, [Left, Right]}]};\n\nbuild_op(Left, {in_op, NotLocation, 'not in', InLocation}, Right) ->\n NotMeta = newlines_op(NotLocation) ++ meta_from_location(NotLocation),\n InMeta = meta_from_location(InLocation),\n {'not', NotMeta, [{'in', InMeta, [Left, Right]}]};\n\nbuild_op(Left, {_Kind, Location, Op}, Right) ->\n {Op, newlines_op(Location) ++ meta_from_location(Location), [Left, Right]}.\n\nbuild_unary_op({_Kind, {Line, Column, _}, '//'}, Expr) ->\n {Outer, Inner} =\n case ?columns() of\n true -> {[{column, Column+1}], [{column, Column}]};\n false -> {[], []}\n end,\n {'/', [{line, Line} | Outer], [{'/', [{line, Line} | Inner], nil}, Expr]};\n\nbuild_unary_op({_Kind, Location, Op}, Expr) ->\n {Op, meta_from_location(Location), [Expr]}.\n\nbuild_nullary_op({_Kind, Location, Op}) ->\n {Op, meta_from_location(Location), []}.\n\nbuild_list(Left, Args, Right) ->\n {handle_literal(Args, Left, newlines_pair(Left, Right)), ?location(Left)}.\n\nbuild_tuple(Left, [Arg1, Arg2], Right) ->\n handle_literal({Arg1, Arg2}, Left, newlines_pair(Left, Right));\nbuild_tuple(Left, Args, Right) ->\n {'{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}.\n\nbuild_bit(Left, Args, Right) ->\n {'<<>>', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}.\n\nbuild_map(Left, Args, Right) ->\n {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}.\n\nbuild_map_update(Left, {Pipe, Struct, Map}, Right, Extra) ->\n Op = build_op(Struct, Pipe, append_non_empty(Map, Extra)),\n {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), [Op]}.\n\n%% Blocks\n\nbuild_block(Exprs) -> build_block(Exprs, []).\n\nbuild_block([{unquote_splicing, _, [_]}]=Exprs, Meta) ->\n {'__block__', Meta, Exprs};\nbuild_block([{Op, ExprMeta, Args}], Meta) ->\n ExprMetaWithExtra =\n case ?token_metadata() of\n true when Meta /= [] -> [{parens, Meta} | ExprMeta];\n _ -> ExprMeta\n end,\n {Op, ExprMetaWithExtra, Args};\nbuild_block([Expr], _Meta) ->\n Expr;\nbuild_block(Exprs, Meta) ->\n {'__block__', Meta, Exprs}.\n\n%% Newlines\n\nnewlines_pair(Left, Right) ->\n case ?token_metadata() of\n true ->\n newlines(?location(Left), [{closing, meta_from_token(Right)}]);\n false ->\n []\n end.\n\nnewlines_op(Location) ->\n case ?token_metadata() of\n true -> newlines(Location, []);\n false -> []\n end.\n\nnext_is_eol(Token, {_, {_, _, Count}}) ->\n {Line, Column, _} = ?location(Token),\n setelement(2, Token, {Line, Column, Count}).\n\nnewlines({_, _, Count}, Meta) when is_integer(Count) and (Count > 0) ->\n [{newlines, Count} | Meta];\nnewlines(_, Meta) ->\n Meta.\n\nannotate_eoe(Token, Stack) ->\n case ?token_metadata() of\n true ->\n case {Token, Stack} of\n {{_, Location}, [{'->', StabMeta, [StabArgs, {Left, Meta, Right}]} | Rest]} when is_list(Meta) ->\n [{'->', StabMeta, [StabArgs, {Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right}]} | Rest];\n\n {{_, Location}, [{Left, Meta, Right} | Rest]} when is_list(Meta), Left =/= '->' ->\n [{Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right} | Rest];\n\n _ ->\n Stack\n end;\n false ->\n Stack\n end.\n\nend_of_expression({_, _, Count} = Location) when is_integer(Count) ->\n [{newlines, Count} | meta_from_location(Location)];\nend_of_expression(Location) ->\n meta_from_location(Location).\n\n%% Dots\n\nbuild_alias({'alias', Location, Alias}) ->\n Meta = meta_from_location(Location),\n MetaWithExtra =\n case ?token_metadata() of\n true -> [{last, meta_from_location(Location)} | Meta];\n false -> Meta\n end,\n {'__aliases__', MetaWithExtra, [Alias]}.\n\nbuild_dot_alias(_Dot, {'__aliases__', Meta, Left}, {'alias', SegmentLocation, Right}) ->\n MetaWithExtra =\n case ?token_metadata() of\n true -> lists:keystore(last, 1, Meta, {last, meta_from_location(SegmentLocation)});\n false -> Meta\n end,\n {'__aliases__', MetaWithExtra, Left ++ [Right]};\nbuild_dot_alias(_Dot, Atom, Right) when is_atom(Atom) ->\n error_bad_atom(Right);\nbuild_dot_alias(Dot, Expr, {'alias', SegmentLocation, Right}) ->\n Meta = meta_from_token(Dot),\n MetaWithExtra =\n case ?token_metadata() of\n true -> [{last, meta_from_location(SegmentLocation)} | Meta];\n false -> Meta\n end,\n {'__aliases__', MetaWithExtra, [Expr, Right]}.\n\nbuild_dot_container(Dot, Left, Right, Extra) ->\n Meta = meta_from_token(Dot),\n {{'.', Meta, [Left, '{}']}, Extra ++ Meta, Right}.\n\nbuild_dot(Dot, Left, {_, Location, _} = Right) ->\n Meta = meta_from_token(Dot),\n IdentifierMeta0 = meta_from_location(Location),\n IdentifierMeta1 =\n case Location of\n {_Line, _Column, Delimiter} when is_integer(Delimiter) ->\n delimiter(<>) ++ IdentifierMeta0;\n _ ->\n IdentifierMeta0\n end,\n {'.', Meta, IdentifierMeta1, [Left, extract_identifier(Right)]}.\n\nextract_identifier({Kind, _, Identifier}) when\n Kind == identifier; Kind == bracket_identifier; Kind == paren_identifier;\n Kind == do_identifier; Kind == op_identifier ->\n Identifier.\n\n%% Identifiers\n\nbuild_nested_parens(Dot, Args1, {Args2Meta, Args2}, {BlockMeta, Block}) ->\n Identifier = build_parens(Dot, Args1, {[], []}),\n %% Take line and column meta from the call target node\n LocationMeta = lists:filter(fun({Key, _}) -> Key == line orelse Key == column end, ?meta(Identifier)),\n Meta = BlockMeta ++ Args2Meta ++ LocationMeta,\n {Identifier, Meta, append_non_empty(Args2, Block)}.\n\nbuild_parens(Expr, {ArgsMeta, Args}, {BlockMeta, Block}) ->\n {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, append_non_empty(Args, Block)),\n {BuiltExpr, BlockMeta ++ ArgsMeta ++ BuiltMeta, BuiltArgs}.\n\nbuild_no_parens_do_block(Expr, Args, {BlockMeta, Block}) ->\n {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, Args ++ Block),\n {BuiltExpr, BlockMeta ++ BuiltMeta, BuiltArgs}.\n\nbuild_no_parens(Expr, Args) ->\n build_call(Expr, Args).\n\nbuild_identifier({'.', Meta, IdentifierMeta, DotArgs}) ->\n {{'.', Meta, DotArgs}, [{no_parens, true} | IdentifierMeta], []};\n\nbuild_identifier({'.', Meta, _} = Dot) ->\n {Dot, [{no_parens, true} | Meta], []};\n\nbuild_identifier({_, Location, Identifier}) ->\n {Identifier, meta_from_location(Location), nil}.\n\nbuild_call({'.', Meta, IdentifierMeta, DotArgs}, Args) ->\n {{'.', Meta, DotArgs}, IdentifierMeta, Args};\n\nbuild_call({'.', Meta, _} = Dot, Args) ->\n {Dot, Meta, Args};\n\nbuild_call({op_identifier, Location, Identifier}, [Arg]) ->\n {Identifier, [{ambiguous_op, nil} | meta_from_location(Location)], [Arg]};\n\nbuild_call({_, Location, Identifier}, Args) ->\n {Identifier, meta_from_location(Location), Args}.\n\n%% Fn\n\nbuild_fn(Fn, Stab, End) ->\n case check_stab(Stab, none) of\n stab ->\n Meta = newlines_op(?location(Fn)) ++ meta_from_token_with_closing(Fn, End),\n {fn, Meta, collect_stab(Stab, [], [])};\n block ->\n return_error(?location(Fn), \"expected anonymous functions to be defined with -> inside: \", \"'fn'\")\n end.\n\n%% Access\n\nbuild_access_arg(Left, Args, Right) ->\n {Args, newlines_pair(Left, Right) ++ meta_from_token(Left)}.\n\nbuild_access(Expr, {List, Meta}) ->\n {{'.', Meta, ['Elixir.Access', get]}, Meta, [Expr, List]}.\n\n%% Interpolation aware\n\nbuild_sigil({sigil, Location, Atom, Parts, Modifiers, Indentation, Delimiter}) ->\n Meta = meta_from_location(Location),\n MetaWithDelimiter = [{delimiter, Delimiter} | Meta],\n MetaWithIndentation = meta_with_indentation(Meta, Indentation),\n {Atom,\n MetaWithDelimiter,\n [{'<<>>', MetaWithIndentation, string_parts(Parts)}, Modifiers]}.\n\nmeta_with_indentation(Meta, nil) ->\n Meta;\nmeta_with_indentation(Meta, Indentation) ->\n [{indentation, Indentation} | Meta].\n\nmeta_with_from_brackets({List, Meta}) ->\n {List, [{from_brackets, true} | Meta]}.\n\nbuild_bin_heredoc({bin_heredoc, Location, Indentation, Args}) ->\n ExtraMeta =\n case ?token_metadata() of\n true -> [{delimiter, <<$\", $\", $\">>}, {indentation, Indentation}];\n false -> []\n end,\n build_bin_string({bin_string, Location, Args}, ExtraMeta).\n\nbuild_list_heredoc({list_heredoc, Location, Indentation, Args}) ->\n ExtraMeta =\n case ?token_metadata() of\n true -> [{delimiter, <<$', $', $'>>}, {indentation, Indentation}];\n false -> []\n end,\n build_list_string({list_string, Location, Args}, ExtraMeta).\n\nbuild_bin_string({bin_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) ->\n handle_literal(H, Token, ExtraMeta);\nbuild_bin_string({bin_string, Location, Args}, ExtraMeta) ->\n Meta =\n case ?token_metadata() of\n true -> ExtraMeta ++ meta_from_location(Location);\n false -> meta_from_location(Location)\n end,\n {'<<>>', Meta, string_parts(Args)}.\n\nbuild_list_string({list_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) ->\n try\n List = elixir_utils:characters_to_list(H),\n handle_literal(List, Token, ExtraMeta)\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n return_error(?location(Token), elixir_utils:characters_to_list(Message), \"'\")\n end;\nbuild_list_string({list_string, Location, Args}, ExtraMeta) ->\n Meta = meta_from_location(Location),\n MetaWithExtra =\n case ?token_metadata() of\n true -> ExtraMeta ++ Meta;\n false -> Meta\n end,\n {{'.', Meta, ['Elixir.List', to_charlist]}, MetaWithExtra, [charlist_parts(Args)]}.\n\nbuild_quoted_atom({_, _Location, [H]} = Token, Safe, ExtraMeta) when is_binary(H) ->\n Op = binary_to_atom_op(Safe),\n handle_literal(erlang:Op(H, utf8), Token, ExtraMeta);\nbuild_quoted_atom({_, Location, Args}, Safe, ExtraMeta) ->\n Meta = meta_from_location(Location),\n MetaWithExtra =\n case ?token_metadata() of\n true -> ExtraMeta ++ Meta;\n false -> Meta\n end,\n {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, MetaWithExtra, [{'<<>>', Meta, string_parts(Args)}, utf8]}.\n\nbinary_to_atom_op(true) -> binary_to_existing_atom;\nbinary_to_atom_op(false) -> binary_to_atom.\n\natom_colon_meta({atom, _Location, Atom}) when Atom =:= true orelse Atom =:= false orelse Atom =:= nil ->\n [{format, atom}];\natom_colon_meta(_) ->\n [].\n\natom_delimiter_meta({_Kind, {_Line, _Column, Delimiter}, _Args}) ->\n case ?token_metadata() of\n true -> [{delimiter, <>}];\n false -> []\n end.\n\nkw_identifier_meta({_Kind, {_Line, _Column, Delimiter}, _Args}) ->\n Meta = [{format, keyword}],\n case ?token_metadata() of\n true when is_integer(Delimiter) -> [{delimiter, <>} | Meta];\n _ -> Meta\n end.\n\ncharlist_parts(Parts) ->\n [charlist_part(Part) || Part <- Parts].\ncharlist_part(Binary) when is_binary(Binary) ->\n Binary;\ncharlist_part({Begin, End, Tokens}) ->\n Form = string_tokens_parse(Tokens),\n Meta = meta_from_location(Begin),\n MetaWithExtra =\n case ?token_metadata() of\n true -> [{closing, meta_from_location(End)} | Meta];\n false -> Meta\n end,\n {{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}.\n\nstring_parts(Parts) ->\n [string_part(Part) || Part <- Parts].\nstring_part(Binary) when is_binary(Binary) ->\n Binary;\nstring_part({Begin, End, Tokens}) ->\n Form = string_tokens_parse(Tokens),\n Meta = meta_from_location(Begin),\n MetaWithExtra =\n case ?token_metadata() of\n true -> [{closing, meta_from_location(End)} | Meta];\n false -> Meta\n end,\n {'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}, {binary, Meta, nil}]}.\n\nstring_tokens_parse(Tokens) ->\n case parse(Tokens) of\n {ok, Forms} -> Forms;\n {error, _} = Error -> throw(Error)\n end.\n\ndelimiter(Delimiter) ->\n case ?token_metadata() of\n true -> [{delimiter, Delimiter}];\n false -> []\n end.\n\n%% Keywords\n\ncheck_stab([{'->', _, [_, _]}], _) -> stab;\ncheck_stab([], none) -> block;\ncheck_stab([_], none) -> block;\ncheck_stab([_], Meta) -> error_invalid_stab(Meta);\ncheck_stab([{'->', Meta, [_, _]} | T], _) -> check_stab(T, Meta);\ncheck_stab([_ | T], MaybeMeta) -> check_stab(T, MaybeMeta).\n\nbuild_stab(Stab, BlockMeta) ->\n case check_stab(Stab, none) of\n block -> build_block(reverse(Stab), BlockMeta);\n stab -> collect_stab(Stab, [], [])\n end.\n\nbuild_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op) ->\n {'__block__', [], Exprs};\nbuild_paren_stab(Before, Stab, After) ->\n case check_stab(Stab, none) of\n block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After));\n stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After))\n end.\n\ncollect_stab([{'->', Meta, [Left, Right]} | T], Exprs, Stabs) ->\n Stab = {'->', Meta, [Left, build_block([Right | Exprs])]},\n collect_stab(T, [], [Stab | Stabs]);\n\ncollect_stab([H | T], Exprs, Stabs) ->\n collect_stab(T, [H | Exprs], Stabs);\n\ncollect_stab([], [], Stabs) ->\n Stabs.\n\n%% Every time the parser sees a (unquote_splicing())\n%% it assumes that a block is being spliced, wrapping\n%% the splicing in a __block__. But in the stab clause,\n%% we can have (unquote_splicing(1, 2, 3)) -> :ok, in such\n%% case, we don't actually want the block, since it is\n%% an arg style call. unwrap_splice unwraps the splice\n%% from such blocks.\nunwrap_splice([{'__block__', _, [{unquote_splicing, _, _}] = Splice}]) ->\n Splice;\nunwrap_splice(Other) ->\n Other.\n\nunwrap_when(Args) ->\n case elixir_utils:split_last(Args) of\n {Start, {'when', Meta, [_, _] = End}} ->\n [{'when', Meta, Start ++ End}];\n {_, _} ->\n Args\n end.\n\nparens_meta({Open, Close}) ->\n case ?token_metadata() of\n true ->\n ParensEntry = [{closing, meta_from_token(Close)} | meta_from_token(Open)],\n [{parens, ParensEntry}];\n false ->\n []\n end;\nparens_meta({Open, _Args, Close}) ->\n parens_meta({Open, Close}).\n\nwith_assoc_meta({Target, Meta, Args}, AssocToken) ->\n case ?token_metadata() of\n true ->\n {Target, [{assoc, meta_from_token(AssocToken)} | Meta], Args};\n false ->\n {Target, Meta, Args}\n end;\n\nwith_assoc_meta(Left, _AssocToken) -> Left.\n\n%% Warnings and errors\n\nreturn_error({Line, Column, _}, ErrorMessage, ErrorToken) ->\n return_error([{line, Line}, {column, Column}], [ErrorMessage, ErrorToken]).\n\n%% We should prefer to use return_error as it includes\n%% Line and Column but that's not always possible.\nreturn_error_with_meta(Meta, ErrorMessage, ErrorToken) ->\n return_error(Meta, [ErrorMessage, ErrorToken]).\n\nerror_invalid_stab(MetaStab) ->\n return_error_with_meta(MetaStab,\n \"unexpected operator ->. If you want to define multiple clauses, the first expression must use ->. \"\n \"Syntax error before: \", \"'->'\").\n\nerror_bad_atom(Token) ->\n return_error(?location(Token), \"atom cannot be followed by an alias. \"\n \"If the '.' was meant to be part of the atom's name, \"\n \"the atom name must be quoted. Syntax error before: \", \"'.'\").\n\nbad_keyword(Token, Context, StartString) ->\n return_error(?location(Token),\n \"unexpected keyword list inside \" ++ atom_to_list(Context) ++ \". \"\n \"Did you mean to write a map (using %{...}) or a list (using [...]) instead? \"\n \"Syntax error after: \", StartString).\n\nmaybe_bad_keyword_call_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) ->\n reverse([Expr | KW]);\nmaybe_bad_keyword_call_follow_up(Token, _KW, _Expr) ->\n return_error(?location(Token),\n \"unexpected expression after keyword list. Keyword lists must always come as the last argument. Therefore, this is not allowed:\\n\\n\"\n \" function_call(1, some: :option, 2)\\n\\n\"\n \"Instead, wrap the keyword in brackets:\\n\\n\"\n \" function_call(1, [some: :option], 2)\\n\\n\"\n \"Syntax error after: \", \"','\").\n\nmaybe_bad_keyword_data_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) ->\n reverse([Expr | KW]);\nmaybe_bad_keyword_data_follow_up(Token, _KW, _Expr) ->\n return_error(?location(Token),\n \"unexpected expression after keyword list. Keyword lists must always come last in lists and maps. Therefore, this is not allowed:\\n\\n\"\n \" [some: :value, :another]\\n\"\n \" %{some: :value, another => value}\\n\\n\"\n \"Instead, reorder it to be the last entry:\\n\\n\"\n \" [:another, some: :value]\\n\"\n \" %{another => value, some: :value}\\n\\n\"\n \"Syntax error after: \", \"','\").\n\nerror_no_parens_strict(Token) ->\n return_error(?location(Token), \"unexpected parentheses. If you are making a \"\n \"function call, do not insert spaces between the function name and the \"\n \"opening parentheses. Syntax error before: \", \"'('\").\n\nerror_no_parens_many_strict(Node) ->\n return_error_with_meta(?meta(Node),\n \"unexpected comma. Parentheses are required to solve ambiguity in nested calls.\\n\\n\"\n \"This error happens when you have nested function calls without parentheses. \"\n \"For example:\\n\\n\"\n \" parent_call a, nested_call b, c, d\\n\\n\"\n \"In the example above, we don't know if the parameters \\\"c\\\" and \\\"d\\\" apply \"\n \"to the function \\\"parent_call\\\" or \\\"nested_call\\\". You can solve this by \"\n \"explicitly adding parentheses:\\n\\n\"\n \" parent_call a, nested_call(b, c, d)\\n\\n\"\n \"Or by adding commas (in case a nested call is not intended):\\n\\n\"\n \" parent_call a, nested_call, b, c, d\\n\\n\"\n \"Elixir cannot compile otherwise. Syntax error before: \", \"','\").\n\nerror_no_parens_container_strict(Node) ->\n return_error_with_meta(?meta(Node),\n \"unexpected comma. Parentheses are required to solve ambiguity inside containers.\\n\\n\"\n \"This error may happen when you forget a comma in a list or other container:\\n\\n\"\n \" [a, b c, d]\\n\\n\"\n \"Or when you have ambiguous calls:\\n\\n\"\n \" [function a, b, c]\\n\\n\"\n \"In the example above, we don't know if the values \\\"b\\\" and \\\"c\\\" \"\n \"belongs to the list or the function \\\"function\\\". You can solve this by explicitly \"\n \"adding parentheses:\\n\\n\"\n \" [one, function(a, b, c)]\\n\\n\"\n \"Elixir cannot compile otherwise. Syntax error before: \", \"','\").\n\nerror_too_many_access_syntax(Comma) ->\n return_error(?location(Comma), \"too many arguments when accessing a value. \"\n \"The value[key] notation in Elixir expects either a single argument or a keyword list. \"\n \"The following examples are allowed:\\n\\n\"\n \" value[one]\\n\"\n \" value[one: 1, two: 2]\\n\"\n \" value[[one, two, three]]\\n\\n\"\n \"These are invalid:\\n\\n\"\n \" value[1, 2, 3]\\n\"\n \" value[one, two, three]\\n\\n\"\n \"Syntax error after: \", \"','\").\n\nerror_invalid_kw_identifier({_, Location, do}) ->\n return_error(Location, elixir_tokenizer:invalid_do_error(\"unexpected keyword: \"), \"do:\");\nerror_invalid_kw_identifier({_, Location, KW}) ->\n return_error(Location, \"syntax error before: \", \"'\" ++ atom_to_list(KW) ++ \":'\").\n\n%% TODO: Make this an error on v2.0\nwarn_trailing_comma({',', {Line, Column, _}}) ->\n warn({Line, Column}, \"trailing commas are not allowed inside function/macro call arguments\").\n\n%% TODO: Make this an error on v2.0\nwarn_pipe({arrow_op, {Line, Column, _}, Op}, {_, [_ | _], [_ | _]}) ->\n warn(\n {Line, Column},\n io_lib:format(\n \"parentheses are required when piping into a function call. For example:\\n\\n\"\n \" foo 1 ~ts bar 2 ~ts baz 3\\n\\n\"\n \"is ambiguous and should be written as\\n\\n\"\n \" foo(1) ~ts bar(2) ~ts baz(3)\\n\\n\"\n \"Ambiguous pipe found at:\",\n [Op, Op, Op, Op]\n )\n );\nwarn_pipe(_Token, _) ->\n ok.\n\n%% TODO: Make this an error on v2.0\nwarn_no_parens_after_do_op({Token, _}) ->\n {Line, _, _} = ?location(Token),\n\n warn(\n Line,\n \"missing parentheses on expression following operator \\\"\" ++ atom_to_list(?op(Token)) ++ \"\\\", \"\n \"you must add parentheses to avoid ambiguities\"\n ).\n\n%% TODO: Make this an error on v2.0\nwarn_nested_no_parens_keyword(Key, Value) when is_atom(Key) ->\n {line, Line} = lists:keyfind(line, 1, ?meta(Value)),\n warn(\n Line,\n \"missing parentheses for expression following \\\"\" ++ atom_to_list(Key) ++ \":\\\" keyword. \"\n \"Parentheses are required to solve ambiguity inside keywords.\\n\\n\"\n \"This error happens when you have function calls without parentheses inside keywords. \"\n \"For example:\\n\\n\"\n \" function(arg, one: nested_call a, b, c)\\n\"\n \" function(arg, one: if expr, do: :this, else: :that)\\n\\n\"\n \"In the examples above, we don't know if the arguments \\\"b\\\" and \\\"c\\\" apply \"\n \"to the function \\\"function\\\" or \\\"nested_call\\\". Or if the keywords \\\"do\\\" and \"\n \"\\\"else\\\" apply to the function \\\"function\\\" or \\\"if\\\". You can solve this by \"\n \"explicitly adding parentheses:\\n\\n\"\n \" function(arg, one: if(expr, do: :this, else: :that))\\n\"\n \" function(arg, one: nested_call(a, b, c))\\n\\n\"\n \"Ambiguity found at:\"\n );\n\n% Key might not be an atom when using literal_encoder, we just skip the warning\nwarn_nested_no_parens_keyword(_Key, _Value) ->\n ok.\n\nwarn_empty_paren({{_, {Line, Column, _}}, _}) ->\n warn(\n {Line, Column},\n \"invalid expression (). \"\n \"If you want to invoke or define a function, make sure there are \"\n \"no spaces between the function name and its arguments. If you wanted \"\n \"to pass an empty block or code, pass a value instead, such as a nil or an atom\"\n ).\n\nwarn_empty_stab_clause({stab_op, {Line, Column, _}, '->'}) ->\n warn(\n {Line, Column},\n \"an expression is always required on the right side of ->. \"\n \"Please provide a value after ->\"\n ).\n\nwarn(LineColumn, Message) ->\n put(elixir_parser_warnings, [{LineColumn, Message} | get(elixir_parser_warnings)]).\n" }, { "path": "lib/elixir/src/elixir_quote.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_quote).\n\n-feature(maybe_expr, enable).\n\n-export([escape/3, linify/3, linify_with_context_counter/3, build/7, quote/2, has_unquotes/1, fun_to_quoted/1]).\n-export([dot/5, tail_list/3, list/2, validate_runtime/2, shallow_validate_ast/1]). %% Quote callbacks\n\n-include(\"elixir.hrl\").\n-define(defs(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop; Kind == '@').\n-define(lexical(Kind), Kind == import; Kind == alias; Kind == require).\n-compile({inline, [keyfind/2, keystore/3, keydelete/2, keynew/3, do_tuple_linify/6]}).\n\n-record(elixir_quote, {\n line=false,\n file=nil,\n context=nil,\n op=escape, % escape | escape_and_prune | {struct, Module} | quote\n aliases_hygiene=nil,\n imports_hygiene=nil,\n unquote=true,\n generated=false,\n shallow_validate=false\n}).\n\n%% fun_to_quoted\n\nfun_to_quoted(Function) ->\n Meta = [],\n {module, Module} = erlang:fun_info(Function, module),\n {name, Name} = erlang:fun_info(Function, name),\n {arity, Arity} = erlang:fun_info(Function, arity),\n {'&', Meta, [{'/', Meta, [{{'.', Meta, [Module, Name]}, [{no_parens, true} | Meta], []}, Arity]}]}.\n\n%% has_unquotes\n\nhas_unquotes(Ast) -> has_unquotes(Ast, 0).\n\nhas_unquotes({quote, _, [Child]}, QuoteLevel) ->\n has_unquotes(Child, QuoteLevel + 1);\nhas_unquotes({quote, _, [QuoteOpts, Child]}, QuoteLevel) ->\n case disables_unquote(QuoteOpts) of\n true -> false;\n _ -> has_unquotes(Child, QuoteLevel + 1)\n end;\nhas_unquotes({Unquote, _, [Child]}, QuoteLevel)\n when Unquote == unquote; Unquote == unquote_splicing ->\n case QuoteLevel of\n 0 -> true;\n _ -> has_unquotes(Child, QuoteLevel - 1)\nend;\nhas_unquotes({{'.', _, [_, unquote]}, _, [_]}, _) -> true;\nhas_unquotes({Var, _, Ctx}, _) when is_atom(Var), is_atom(Ctx) -> false;\nhas_unquotes({Name, _, Args}, QuoteLevel) when is_list(Args) ->\n has_unquotes(Name) orelse lists:any(fun(Child) -> has_unquotes(Child, QuoteLevel) end, Args);\nhas_unquotes({Left, Right}, QuoteLevel) ->\n has_unquotes(Left, QuoteLevel) orelse has_unquotes(Right, QuoteLevel);\nhas_unquotes(List, QuoteLevel) when is_list(List) ->\n lists:any(fun(Child) -> has_unquotes(Child, QuoteLevel) end, List);\nhas_unquotes(_Other, _) -> false.\n\ndisables_unquote([{unquote, false} | _]) -> true;\ndisables_unquote([{bind_quoted, _} | _]) -> true;\ndisables_unquote([_H | T]) -> disables_unquote(T);\ndisables_unquote(_) -> false.\n\n%% Apply the line from site call on quoted contents.\n%% Receives a Key to look for the default line as argument.\nlinify(0, _Key, Exprs) ->\n Exprs;\nlinify(Line, Key, Exprs) when is_integer(Line) ->\n Fun =\n case Key of\n line ->\n fun(Meta) -> keynew(line, Meta, Line) end;\n keep ->\n fun(Meta) ->\n case lists:keytake(keep, 1, Meta) of\n {value, {keep, {_, Int}}, MetaNoFile} ->\n [{line, Int} | keydelete(line, MetaNoFile)];\n _ ->\n keynew(line, Meta, Line)\n end\n end\n end,\n\n do_linify(Fun, Exprs, nil, false).\n\n%% Same as linify but also considers the context counter and generated.\nlinify_with_context_counter(ContextMeta, Var, Exprs) when is_list(ContextMeta) ->\n Line = ?line(ContextMeta),\n\n Generated = keyfind(generated, ContextMeta) == {generated, true},\n\n Fun = if\n Line =:= 0 -> fun(Meta) -> Meta end;\n true -> fun(Meta) -> keynew(line, Meta, Line) end\n end,\n\n do_linify(Fun, Exprs, Var, Generated).\n\ndo_linify(Fun, {quote, Meta, [_ | _] = Args}, {Receiver, Counter} = Var, Gen)\n when is_list(Meta) ->\n NewMeta =\n case keyfind(context, Meta) == {context, Receiver} of\n true -> keynew(counter, Meta, Counter);\n false -> Meta\n end,\n do_tuple_linify(Fun, NewMeta, quote, Args, Var, Gen);\n\ndo_linify(Fun, {Left, Meta, Receiver}, {Receiver, Counter} = Var, Gen)\n when is_atom(Left), is_list(Meta), Left /= '_' ->\n do_tuple_linify(Fun, keynew(counter, Meta, Counter), Left, Receiver, Var, Gen);\n\ndo_linify(Fun, {Lexical, Meta, [_ | _] = Args}, {_, Counter} = Var, Gen)\n when ?lexical(Lexical); Lexical == '__aliases__' ->\n do_tuple_linify(Fun, keynew(counter, Meta, Counter), Lexical, Args, Var, Gen);\n\ndo_linify(Fun, {Left, Meta, Right}, Var, Gen) when is_list(Meta) ->\n do_tuple_linify(Fun, Meta, Left, Right, Var, Gen);\n\ndo_linify(Fun, {Left, Right}, Var, Gen) ->\n {do_linify(Fun, Left, Var, Gen), do_linify(Fun, Right, Var, Gen)};\n\ndo_linify(Fun, List, Var, Gen) when is_list(List) ->\n [do_linify(Fun, X, Var, Gen) || X <- List];\n\ndo_linify(_, Else, _, _Gen) -> Else.\n\ndo_tuple_linify(Fun, Meta, Left, Right, Var, Gen) ->\n {NewMeta, NewGen} =\n case keyfind(stop_generated, Meta) of\n {stop_generated, true} -> {keydelete(stop_generated, Meta), false};\n _ when Gen -> {elixir_utils:generated(Meta), Gen};\n _ -> {Meta, Gen}\n end,\n\n {do_linify(Fun, Left, Var, NewGen), Fun(NewMeta), do_linify(Fun, Right, Var, NewGen)}.\n\n%% Escaping\n\n%% Escapes the given expression. It is similar to quote, but\n%% lines are kept and hygiene mechanisms are disabled.\nescape(Expr, Op, Unquote) ->\n try\n do_quote(Expr, #elixir_quote{\n line=true,\n file=nil,\n op=Op,\n unquote=Unquote\n })\n catch\n Kind:Reason:Stacktrace ->\n Pruned = lists:dropwhile(fun\n ({?MODULE, _, _, _}) -> true;\n (_) -> false\n end, Stacktrace),\n erlang:raise(Kind, Reason, Pruned)\n end.\n\ndo_escape({Left, Meta, Right}, #elixir_quote{op=escape_and_prune} = Q) when is_list(Meta) ->\n TM = [{K, V} || {K, V} <- Meta, (K == no_parens) orelse (K == line) orelse (K == delimiter)],\n TL = do_quote(Left, Q),\n TR = do_quote(Right, Q),\n {'{}', [], [TL, TM, TR]};\n\ndo_escape({Left, Right}, Q) ->\n {do_quote(Left, Q), do_quote(Right, Q)};\n\ndo_escape(Tuple, Q) when is_tuple(Tuple) ->\n TT = do_quote(tuple_to_list(Tuple), Q),\n {'{}', [], TT};\n\ndo_escape(BitString, _) when is_bitstring(BitString) ->\n case bit_size(BitString) rem 8 of\n 0 ->\n BitString;\n Size ->\n <> = BitString,\n {'<<>>', [], [{'::', [], [Bits, {size, [], [Size]}]}, {'::', [], [Bytes, {binary, [], nil}]}]}\n end;\n\ndo_escape(Map, Q) when is_map(Map) ->\n maybe\n #{'__struct__' := Module} ?= Map,\n true ?= is_atom(Module),\n % We never escape ourselves (it can only happen during Elixir bootstrapping)\n true ?= (Q#elixir_quote.op /= {struct, Module}),\n {module, Module} ?= code:ensure_loaded(Module),\n true ?= erlang:function_exported(Module, '__escape__', 1),\n case Q#elixir_quote.op of\n {struct, _Module} ->\n argument_error(<<('Elixir.Kernel':inspect(Module))/binary,\n \" defines custom escaping rules which are not supported in struct defaults\",\n (bad_escape_hint())/binary>>);\n\n _ ->\n Expr = Module:'__escape__'(Map),\n case shallow_valid_ast(Expr) of\n true -> Expr;\n false -> argument_error(\n <<('Elixir.Kernel':inspect(Module))/binary, \".__escape__/1 returned invalid AST: \", ('Elixir.Kernel':inspect(Expr))/binary>>\n )\n end\n end\n else\n _ ->\n TT = [\n {do_quote(K, Q), do_quote(V, Q)}\n || {K, V} <- lists:sort(maps:to_list(Map))\n ],\n {'%{}', [], TT}\n end;\n\ndo_escape([], _) ->\n [];\n\ndo_escape([H | T], #elixir_quote{unquote=false} = Q) ->\n do_quote_simple_list(T, do_escape(H, Q), Q);\n\ndo_escape([H | T], Q) ->\n %% The improper case is inefficient, but improper lists are rare.\n try lists:reverse(T, [H]) of\n L -> do_quote_tail(L, Q)\n catch\n _:_ ->\n {L, R} = reverse_improper(T, [H]),\n TL = do_quote_splice(L, Q, [], []),\n TR = do_quote(R, Q),\n update_last(TL, fun(X) -> {'|', [], [X, TR]} end)\n end;\n\ndo_escape(Other, _) when is_number(Other); is_atom(Other); is_pid(Other) ->\n Other;\n\ndo_escape(Fun, _) when is_function(Fun) ->\n case (erlang:fun_info(Fun, env) == {env, []}) andalso\n (erlang:fun_info(Fun, type) == {type, external}) of\n true -> fun_to_quoted(Fun);\n false -> bad_escape(Fun)\n end;\n\ndo_escape(Other, _) ->\n bad_escape(Other).\n\nbad_escape(Arg) ->\n argument_error(<<\"cannot escape \", ('Elixir.Kernel':inspect(Arg, []))/binary,\n (bad_escape_hint())/binary>>).\n\nbad_escape_hint() ->\n <<\". The supported values are: lists, tuples, maps, atoms, numbers, bitstrings, \",\n \"PIDs and remote functions in the format &Mod.fun/arity\">>.\n\n%% Quote entry points\n\nbuild(Meta, Line, File, Context, Unquote, Generated, E) ->\n Acc0 = [],\n {VLine, Acc1} = validate_compile(Meta, line, Line, Acc0),\n {VFile, Acc2} = validate_compile(Meta, file, File, Acc1),\n {VContext, Acc3} = validate_compile(Meta, context, Context, Acc2),\n validate_runtime(unquote, Unquote),\n validate_runtime(generated, Generated),\n\n Q = #elixir_quote{\n op=quote,\n aliases_hygiene=E,\n imports_hygiene=E,\n line=VLine,\n file=VFile,\n unquote=Unquote,\n context=VContext,\n generated=Generated,\n shallow_validate=true\n },\n\n {Q, VContext, Acc3}.\n\nvalidate_compile(_Meta, line, Value, Acc) when is_boolean(Value) ->\n {Value, Acc};\nvalidate_compile(_Meta, file, nil, Acc) ->\n {nil, Acc};\nvalidate_compile(Meta, Key, Value, Acc) ->\n case is_valid(Key, Value) of\n true ->\n {Value, Acc};\n false ->\n Var = {Key, Meta, ?MODULE},\n Call = {{'.', Meta, [?MODULE, validate_runtime]}, Meta, [Key, Value]},\n {Var, [{'=', Meta, [Var, Call]} | Acc]}\n end.\n\nvalidate_runtime(Key, Value) ->\n case is_valid(Key, Value) of\n true ->\n Value;\n\n false ->\n erlang:error(\n 'Elixir.ArgumentError':exception(\n <<\"invalid runtime value for option :\", (erlang:atom_to_binary(Key))/binary,\n \" in quote, got: \", ('Elixir.Kernel':inspect(Value))/binary>>\n )\n )\n end.\n\nis_valid(line, Line) -> is_integer(Line);\nis_valid(file, File) -> is_binary(File);\nis_valid(context, Context) -> is_atom(Context) andalso (Context /= nil);\nis_valid(generated, Generated) -> is_boolean(Generated);\nis_valid(unquote, Unquote) -> is_boolean(Unquote).\n\nshallow_validate_ast(Expr) ->\n case shallow_valid_ast(Expr) of\n true -> Expr;\n false -> argument_error(\n <<\"tried to unquote invalid AST: \", ('Elixir.Kernel':inspect(Expr))/binary,\n \"\\nDid you forget to escape term using Macro.escape/1?\">>)\n end.\n\nshallow_valid_ast(Expr) when is_list(Expr) -> valid_ast_list(Expr);\nshallow_valid_ast(Expr) -> valid_ast_elem(Expr).\n\nvalid_ast_list([]) -> true;\nvalid_ast_list([Head | Tail]) -> valid_ast_elem(Head) andalso valid_ast_list(Tail);\nvalid_ast_list(_Improper) -> false.\n\nvalid_ast_elem(Expr) when is_list(Expr); is_atom(Expr); is_binary(Expr); is_number(Expr); is_pid(Expr); is_function(Expr) -> true;\nvalid_ast_elem({Left, Right}) -> valid_ast_elem(Left) andalso valid_ast_elem(Right);\nvalid_ast_elem({Atom, Meta, Args}) when is_atom(Atom), is_list(Meta), is_atom(Args) orelse is_list(Args) -> true;\nvalid_ast_elem({Call, Meta, Args}) when is_list(Meta), is_list(Args) -> shallow_valid_ast(Call);\nvalid_ast_elem(_Term) -> false.\n\nquote({unquote_splicing, _, [_]}, #elixir_quote{unquote=true}) ->\n argument_error(<<\"unquote_splicing only works inside arguments and block contexts, \"\n \"wrap it in parens if you want it to work with one-liners\">>);\nquote(Expr, Q) ->\n do_quote(Expr, Q).\n\n%% quote/unquote\n\ndo_quote({quote, Meta, [Arg]}, Q) when is_list(Meta) ->\n TArg = do_quote(Arg, Q#elixir_quote{unquote=false}),\n\n NewMeta = case Q of\n #elixir_quote{op=quote, context=Context} -> keystore(context, Meta, Context);\n _ -> Meta\n end,\n\n {'{}', [], [quote, meta(NewMeta, Q), [TArg]]};\n\ndo_quote({quote, Meta, [Opts, Arg]}, Q) when is_list(Meta) ->\n TOpts = do_quote(Opts, Q),\n TArg = do_quote(Arg, Q#elixir_quote{unquote=false}),\n\n NewMeta = case Q of\n #elixir_quote{op=quote, context=Context} -> keystore(context, Meta, Context);\n _ -> Meta\n end,\n\n {'{}', [], [quote, meta(NewMeta, Q), [TOpts, TArg]]};\n\ndo_quote({unquote, Meta, [Expr]}, #elixir_quote{unquote=true, shallow_validate=Validate}) when is_list(Meta) ->\n case Validate of\n true -> {{'.', Meta, [?MODULE, shallow_validate_ast]}, Meta, [Expr]};\n false -> Expr\n end;\n\n%% Aliases\n\ndo_quote({'__aliases__', Meta, [H | T]}, #elixir_quote{aliases_hygiene=(#{}=E)} = Q)\n when is_list(Meta), is_atom(H), H /= 'Elixir' ->\n Annotation =\n case elixir_aliases:expand(Meta, [H | T], E, true) of\n Atom when is_atom(Atom) -> Atom;\n Aliases when is_list(Aliases) -> false\n end,\n AliasMeta = keystore(alias, keydelete(counter, Meta), Annotation),\n do_quote_tuple('__aliases__', AliasMeta, [H | T], Q);\n\n%% Vars\n\ndo_quote({Name, Meta, nil}, #elixir_quote{op=quote} = Q)\n when is_atom(Name), is_list(Meta) ->\n ImportMeta = case Q#elixir_quote.imports_hygiene of\n nil -> Meta;\n E -> import_meta(Meta, Name, 0, Q, E)\n end,\n\n {'{}', [], [Name, meta(ImportMeta, Q), Q#elixir_quote.context]};\n\n%% Unquote\n\ndo_quote({{{'.', Meta, [Left, unquote]}, _, [Expr]}, _, Args}, #elixir_quote{unquote=true} = Q) when is_list(Meta) ->\n do_quote_call(Left, Meta, Expr, Args, Q);\n\ndo_quote({{'.', Meta, [Left, unquote]}, _, [Expr]}, #elixir_quote{unquote=true} = Q) when is_list(Meta) ->\n do_quote_call(Left, Meta, Expr, nil, Q);\n\n%% Imports\n\ndo_quote({'&', Meta, [{'/', _, [{F, _, C}, A]}] = Args},\n #elixir_quote{imports_hygiene=(#{}=E)} = Q) when is_atom(F), is_integer(A), is_atom(C), is_list(Meta) ->\n NewMeta =\n case elixir_dispatch:find_import(Meta, F, A, E) of\n false ->\n Meta;\n\n Receiver ->\n keystore(context, keystore(imports, Meta, [{A, Receiver}]), Q#elixir_quote.context)\n end,\n do_quote_tuple('&', NewMeta, Args, Q);\n\ndo_quote({Name, Meta, ArgsOrContext}, #elixir_quote{imports_hygiene=(#{}=E)} = Q)\n when is_atom(Name), is_list(Meta), is_list(ArgsOrContext) or is_atom(ArgsOrContext) ->\n Arity = if\n is_atom(ArgsOrContext) -> 0;\n true -> length(ArgsOrContext)\n end,\n\n ImportMeta = import_meta(Meta, Name, Arity, Q, E),\n Annotated = annotate({Name, ImportMeta, ArgsOrContext}, Q#elixir_quote.context),\n do_quote_tuple(Annotated, Q);\n\n%% Two-element tuples\n\ndo_quote({Left, Right}, #elixir_quote{unquote=true} = Q) when\n is_tuple(Left) andalso (element(1, Left) == unquote_splicing);\n is_tuple(Right) andalso (element(1, Right) == unquote_splicing) ->\n do_quote({'{}', [], [Left, Right]}, Q);\n\ndo_quote({Left, Right}, Q) ->\n TLeft = do_quote(Left, Q),\n TRight = do_quote(Right, Q),\n {TLeft, TRight};\n\n%% Everything else\n\ndo_quote(Other, #elixir_quote{op=Op} = Q) when Op =/= quote ->\n do_escape(Other, Q);\n\ndo_quote({_, _, _} = Tuple, Q) ->\n Annotated = annotate(Tuple, Q#elixir_quote.context),\n do_quote_tuple(Annotated, Q);\n\ndo_quote([], _) ->\n [];\n\ndo_quote([H | T], #elixir_quote{unquote=false} = Q) ->\n do_quote_simple_list(T, do_quote(H, Q), Q);\n\ndo_quote([H | T], Q) ->\n do_quote_tail(lists:reverse(T, [H]), Q);\n\ndo_quote(Other, _) ->\n Other.\n\nimport_meta(Meta, Name, Arity, Q, E) ->\n case (keyfind(imports, Meta) == false) andalso\n elixir_dispatch:find_imports(Meta, Name, E) of\n [_ | _] = Imports ->\n trace_import_quoted(Imports, Meta, Name, E),\n keystore(imports, keystore(context, Meta, Q#elixir_quote.context), Imports);\n\n _ ->\n case (Arity == 1) andalso keyfind(ambiguous_op, Meta) of\n {ambiguous_op, nil} -> keystore(ambiguous_op, Meta, Q#elixir_quote.context);\n _ -> Meta\n end\n end.\n\ntrace_import_quoted([{Arity, Mod} | Imports], Meta, Name, E) ->\n {Rest, Arities} = collect_trace_import_quoted(Imports, Mod, [], [Arity]),\n elixir_env:trace({imported_quoted, Meta, Mod, Name, Arities}, E),\n trace_import_quoted(Rest, Meta, Name, E);\ntrace_import_quoted([], _Meta, _Name, _E) ->\n ok.\n\ncollect_trace_import_quoted([{Arity, Mod} | Imports], Mod, Acc, Arities) ->\n collect_trace_import_quoted(Imports, Mod, Acc, [Arity | Arities]);\ncollect_trace_import_quoted([Import | Imports], Mod, Acc, Arities) ->\n collect_trace_import_quoted(Imports, Mod, [Import | Acc], Arities);\ncollect_trace_import_quoted([], _Mod, Acc, Arities) ->\n {lists:reverse(Acc), lists:reverse(Arities)}.\n\n%% do_quote_*\n\ndo_quote_call(Left, Meta, Expr, Args, Q) ->\n All = [Left, {unquote, Meta, [Expr]}, Args, Q#elixir_quote.context],\n TAll = [do_quote(X, Q) || X <- All],\n {{'.', Meta, [elixir_quote, dot]}, Meta, [meta(Meta, Q) | TAll]}.\n\ndo_quote_tuple({Left, Meta, Right}, Q) ->\n do_quote_tuple(Left, Meta, Right, Q).\n\ndo_quote_tuple(Left, Meta, Right, Q) ->\n TLeft = do_quote(Left, Q),\n TRight = do_quote(Right, Q),\n {'{}', [], [TLeft, meta(Meta, Q), TRight]}.\n\ndo_quote_simple_list([], Prev, _) -> [Prev];\ndo_quote_simple_list([H | T], Prev, Q) ->\n [Prev | do_quote_simple_list(T, do_quote(H, Q), Q)];\ndo_quote_simple_list(Other, Prev, Q) ->\n [{'|', [], [Prev, do_quote(Other, Q)]}].\n\ndo_quote_tail([{'|', Meta, [{unquote_splicing, _, [Left]}, Right]} | T], #elixir_quote{unquote=true} = Q) ->\n %% Process the remaining entries on the list.\n %% For [1, 2, 3, unquote_splicing(arg) | tail], this will quote\n %% 1, 2 and 3, which could even be unquotes.\n TT = do_quote_splice(T, Q, [], []),\n TR = do_quote(Right, Q),\n do_runtime_list(Meta, tail_list, [Left, TR, TT]);\n\ndo_quote_tail(List, Q) ->\n do_quote_splice(List, Q, [], []).\n\ndo_quote_splice([{unquote_splicing, Meta, [Expr]} | T], #elixir_quote{unquote=true} = Q, Buffer, Acc) ->\n Runtime = do_runtime_list(Meta, list, [Expr, do_list_concat(Buffer, Acc)]),\n do_quote_splice(T, Q, [], Runtime);\n\ndo_quote_splice([H | T], Q, Buffer, Acc) ->\n TH = do_quote(H, Q),\n do_quote_splice(T, Q, [TH | Buffer], Acc);\n\ndo_quote_splice([], _Q, Buffer, Acc) ->\n do_list_concat(Buffer, Acc).\n\ndo_list_concat(Left, []) -> Left;\ndo_list_concat([], Right) -> Right;\ndo_list_concat(Left, Right) -> {{'.', [], [erlang, '++']}, [], [Left, Right]}.\n\ndo_runtime_list(Meta, Fun, Args) ->\n {{'.', Meta, [elixir_quote, Fun]}, Meta, Args}.\n\n%% Callbacks\n\n%% Some expressions cannot be unquoted at compilation time.\n%% This function is responsible for doing runtime unquoting.\ndot(Meta, Left, Right, Args, Context) ->\n annotate(dot(Meta, Left, Right, Args), Context).\n\ndot(Meta, Left, {'__aliases__', _, Args}, nil) ->\n {'__aliases__', Meta, [Left | Args]};\n\ndot(Meta, Left, Right, nil) when is_atom(Right) ->\n case atom_to_list(Right) of\n \"Elixir.\" ++ _ ->\n {'__aliases__', Meta, [Left, Right]};\n _ ->\n {{'.', Meta, [Left, Right]}, [{no_parens, true} | Meta], []}\n end;\n\ndot(Meta, Left, {Right, _, Context}, nil) when is_atom(Right), is_atom(Context) ->\n {{'.', Meta, [Left, Right]}, [{no_parens, true} | Meta], []};\n\ndot(Meta, Left, {Right, _, Args}, nil) when is_atom(Right) ->\n {{'.', Meta, [Left, Right]}, Meta, Args};\n\ndot(_Meta, _Left, Right, nil) ->\n argument_error(<<\"expected unquote after dot to return an atom, an alias or a quoted call, got: \",\n ('Elixir.Macro':to_string(Right))/binary>>);\n\ndot(Meta, Left, Right, Args) when is_atom(Right) ->\n {{'.', Meta, [Left, Right]}, Meta, Args};\n\ndot(Meta, Left, {Right, _, Context}, Args) when is_atom(Right), is_atom(Context) ->\n {{'.', Meta, [Left, Right]}, Meta, Args};\n\ndot(_Meta, _Left, Right, _Args) ->\n argument_error(<<\"expected unquote after dot with args to return an atom or a quoted call, got: \",\n ('Elixir.Macro':to_string(Right))/binary>>).\n\nlist(Left, Right) when is_list(Right) ->\n validate_list(Left),\n Left ++ Right.\n\ntail_list(Left, Right, Tail) when is_list(Right), is_list(Tail) ->\n validate_list(Left),\n Tail ++ Left ++ Right;\n\ntail_list(Left, Right, Tail) when is_list(Left) ->\n validate_list(Left),\n [H | T] = lists:reverse(Tail ++ Left),\n lists:reverse([{'|', [], [H, Right]} | T]).\n\nvalidate_list(List) ->\n case valid_ast_list(List) of\n true -> ok;\n false -> argument_error(<<\"expected a list with quoted expressions in unquote_splicing/1, got: \",\n ('Elixir.Kernel':inspect(List))/binary>>)\n end.\n\nargument_error(Message) ->\n error('Elixir.ArgumentError':exception([{message, Message}])).\n\n%% Helpers\n\nmeta(Meta, #elixir_quote{op=quote} = Q) ->\n generated(keep(keydelete(column, Meta), Q), Q);\nmeta(Meta, Q) ->\n do_quote(Meta, Q).\n\ngenerated(Meta, #elixir_quote{generated=true}) -> [{generated, true} | Meta];\ngenerated(Meta, #elixir_quote{generated=false}) -> Meta.\n\nkeep(Meta, #elixir_quote{file=nil, line=Line}) ->\n line(Meta, Line);\nkeep(Meta, #elixir_quote{file=File, line=true}) ->\n case lists:keytake(line, 1, Meta) of\n {value, {line, Line}, MetaNoLine} ->\n [{keep, {File, Line}} | MetaNoLine];\n false ->\n [{keep, {File, 0}} | Meta]\n end;\nkeep(Meta, #elixir_quote{file=File, line=false}) ->\n [{keep, {File, 0}} | keydelete(line, Meta)];\nkeep(Meta, #elixir_quote{file=File, line=Line}) ->\n [{keep, {File, Line}} | keydelete(line, Meta)].\n\nline(Meta, true) ->\n Meta;\nline(Meta, false) ->\n keydelete(line, Meta);\nline(Meta, Line) ->\n keystore(line, Meta, Line).\n\nreverse_improper([H | T], Acc) -> reverse_improper(T, [H | Acc]);\nreverse_improper([], Acc) -> Acc;\nreverse_improper(T, Acc) -> {Acc, T}.\n\nupdate_last([], _) -> [];\nupdate_last([H], F) -> [F(H)];\nupdate_last([H | T], F) -> [H | update_last(T, F)].\n\nkeyfind(Key, Meta) ->\n lists:keyfind(Key, 1, Meta).\nkeydelete(Key, Meta) ->\n lists:keydelete(Key, 1, Meta).\nkeystore(_Key, Meta, nil) ->\n Meta;\nkeystore(Key, Meta, Value) ->\n lists:keystore(Key, 1, Meta, {Key, Value}).\nkeynew(Key, Meta, Value) ->\n case lists:keymember(Key, 1, Meta) of\n true -> Meta;\n false -> [{Key, Value} | Meta]\n end.\n\n%% Annotates the AST with context and other info.\n%%\n%% Note we need to delete the counter because linify\n%% adds the counter recursively, even inside quoted\n%% expressions, so we need to clean up the forms to\n%% allow them to get a new counter on the next expansion.\n\nannotate({Def, Meta, [H | T]}, Context) when ?defs(Def) ->\n {Def, Meta, [annotate_def(H, Context) | T]};\nannotate({{'.', _, [_, Def]} = Target, Meta, [H | T]}, Context) when ?defs(Def) ->\n {Target, Meta, [annotate_def(H, Context) | T]};\nannotate({Lexical, Meta, [_ | _] = Args}, Context) when ?lexical(Lexical) ->\n NewMeta = keystore(context, keydelete(counter, Meta), Context),\n {Lexical, NewMeta, Args};\nannotate(Tree, _Context) -> Tree.\n\nannotate_def({'when', Meta, [Left, Right]}, Context) ->\n {'when', Meta, [annotate_def(Left, Context), Right]};\nannotate_def({Fun, Meta, Args}, Context) ->\n {Fun, keystore(context, Meta, Context), Args};\nannotate_def(Other, _Context) ->\n Other.\n" }, { "path": "lib/elixir/src/elixir_rewrite.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_rewrite).\n-compile({inline, [inner_inline/4, inner_rewrite/5]}).\n-compile(nowarn_shadow_vars).\n-export([erl_to_ex/3, inline/3, rewrite/5, match/6, guard/6, format_error/1]).\n-include(\"elixir.hrl\").\n\n%% Convenience variables\n\n-define(atom, 'Elixir.Atom').\n-define(bitwise, 'Elixir.Bitwise').\n-define(enum, 'Elixir.Enum').\n-define(float, 'Elixir.Float').\n-define(function, 'Elixir.Function').\n-define(integer, 'Elixir.Integer').\n-define(io, 'Elixir.IO').\n-define(kernel, 'Elixir.Kernel').\n-define(list, 'Elixir.List').\n-define(map, 'Elixir.Map').\n-define(node, 'Elixir.Node').\n-define(port, 'Elixir.Port').\n-define(process, 'Elixir.Process').\n-define(string, 'Elixir.String').\n-define(string_chars, 'Elixir.String.Chars').\n-define(system, 'Elixir.System').\n-define(tuple, 'Elixir.Tuple').\n\n% Macros used to define inline and rewrite rules.\n% Defines the rules from Elixir function to Erlang function\n% and the reverse, rewrites that are not reversible or have\n% complex rules are defined without the macros.\n-define(\n inline(ExMod, ExFun, Arity, ErlMod, ErlFun),\n inner_inline(ex_to_erl, ExMod, ExFun, Arity) -> {ErlMod, ErlFun};\n inner_inline(erl_to_ex, ErlMod, ErlFun, Arity) -> {ExMod, ExFun}\n).\n\n-define(\n rewrite(ExMod, ExFun, ExArgs, ErlMod, ErlFun, ErlArgs),\n inner_rewrite(ex_to_erl, _Meta, ExMod, ExFun, ExArgs) -> {ErlMod, ErlFun, ErlArgs};\n inner_rewrite(erl_to_ex, _Meta, ErlMod, ErlFun, ErlArgs) -> {ExMod, ExFun, ExArgs, fun(ErlArgs) -> ExArgs end}\n).\n\nerl_to_ex(Mod, Fun, Args) when is_list(Args) ->\n case inner_inline(erl_to_ex, Mod, Fun, length(Args)) of\n false -> inner_rewrite(erl_to_ex, [], Mod, Fun, Args);\n {ExMod, ExFun} -> {ExMod, ExFun, Args, fun identity/1}\n end;\n\nerl_to_ex(Mod, Fun, Arity) when is_integer(Arity) ->\n inner_inline(erl_to_ex, Mod, Fun, Arity).\n\n%% Inline rules\n%%\n%% Inline rules are straightforward, they keep the same\n%% number and order of arguments and show up on captures.\ninline(Mod, Fun, Arity) -> inner_inline(ex_to_erl, Mod, Fun, Arity).\n\n?inline(?atom, to_charlist, 1, erlang, atom_to_list);\n?inline(?atom, to_string, 1, erlang, atom_to_binary);\n\n?inline(?bitwise, 'bnot', 1, erlang, 'bnot');\n?inline(?bitwise, 'band', 2, erlang, 'band');\n?inline(?bitwise, 'bor', 2, erlang, 'bor');\n?inline(?bitwise, 'bxor', 2, erlang, 'bxor');\n?inline(?bitwise, 'bsl', 2, erlang, 'bsl');\n?inline(?bitwise, 'bsr', 2, erlang, 'bsr');\n\n?inline(?function, capture, 3, erlang, make_fun);\n?inline(?function, info, 1, erlang, fun_info);\n?inline(?function, info, 2, erlang, fun_info);\n\n?inline(?integer, to_charlist, 1, erlang, integer_to_list);\n?inline(?integer, to_charlist, 2, erlang, integer_to_list);\n?inline(?integer, to_string, 1, erlang, integer_to_binary);\n?inline(?integer, to_string, 2, erlang, integer_to_binary);\n\n?inline(?io, iodata_length, 1, erlang, iolist_size);\n?inline(?io, iodata_to_binary, 1, erlang, iolist_to_binary);\n\n?inline(?kernel, '!=', 2, erlang, '/=');\n?inline(?kernel, '!==', 2, erlang, '=/=');\n?inline(?kernel, '*', 2, erlang, '*');\n?inline(?kernel, '+', 1, erlang, '+');\n?inline(?kernel, '+', 2, erlang, '+');\n?inline(?kernel, '++', 2, erlang, '++');\n?inline(?kernel, '-', 1, erlang, '-');\n?inline(?kernel, '-', 2, erlang, '-');\n?inline(?kernel, '--', 2, erlang, '--');\n?inline(?kernel, '/', 2, erlang, '/');\n?inline(?kernel, '<', 2, erlang, '<');\n?inline(?kernel, '<=', 2, erlang, '=<');\n?inline(?kernel, '==', 2, erlang, '==');\n?inline(?kernel, '===', 2, erlang, '=:=');\n?inline(?kernel, '>', 2, erlang, '>');\n?inline(?kernel, '>=', 2, erlang, '>=');\n?inline(?kernel, abs, 1, erlang, abs);\n?inline(?kernel, apply, 2, erlang, apply);\n?inline(?kernel, apply, 3, erlang, apply);\n?inline(?kernel, binary_part, 3, erlang, binary_part);\n?inline(?kernel, bit_size, 1, erlang, bit_size);\n?inline(?kernel, byte_size, 1, erlang, byte_size);\n?inline(?kernel, ceil, 1, erlang, ceil);\n?inline(?kernel, 'div', 2, erlang, 'div');\n?inline(?kernel, exit, 1, erlang, exit);\n?inline(?kernel, floor, 1, erlang, floor);\n?inline(?kernel, 'function_exported?', 3, erlang, function_exported);\n?inline(?kernel, hd, 1, erlang, hd);\n?inline(?kernel, is_atom, 1, erlang, is_atom);\n?inline(?kernel, is_binary, 1, erlang, is_binary);\n?inline(?kernel, is_bitstring, 1, erlang, is_bitstring);\n?inline(?kernel, is_boolean, 1, erlang, is_boolean);\n?inline(?kernel, is_float, 1, erlang, is_float);\n?inline(?kernel, is_function, 1, erlang, is_function);\n?inline(?kernel, is_function, 2, erlang, is_function);\n?inline(?kernel, is_integer, 1, erlang, is_integer);\n?inline(?kernel, is_list, 1, erlang, is_list);\n?inline(?kernel, is_map, 1, erlang, is_map);\n?inline(?kernel, is_number, 1, erlang, is_number);\n?inline(?kernel, is_pid, 1, erlang, is_pid);\n?inline(?kernel, is_port, 1, erlang, is_port);\n?inline(?kernel, is_reference, 1, erlang, is_reference);\n?inline(?kernel, is_tuple, 1, erlang, is_tuple);\n?inline(?kernel, length, 1, erlang, length);\n?inline(?kernel, make_ref, 0, erlang, make_ref);\n?inline(?kernel, map_size, 1, erlang, map_size);\n?inline(?kernel, max, 2, erlang, max);\n?inline(?kernel, min, 2, erlang, min);\n?inline(?kernel, node, 0, erlang, node);\n?inline(?kernel, node, 1, erlang, node);\n?inline(?kernel, 'not', 1, erlang, 'not');\n?inline(?kernel, 'rem', 2, erlang, 'rem');\n?inline(?kernel, round, 1, erlang, round);\n?inline(?kernel, self, 0, erlang, self);\n?inline(?kernel, send, 2, erlang, send);\n?inline(?kernel, spawn, 1, erlang, spawn);\n?inline(?kernel, spawn, 3, erlang, spawn);\n?inline(?kernel, spawn_link, 1, erlang, spawn_link);\n?inline(?kernel, spawn_link, 3, erlang, spawn_link);\n?inline(?kernel, spawn_monitor, 1, erlang, spawn_monitor);\n?inline(?kernel, spawn_monitor, 3, erlang, spawn_monitor);\n?inline(?kernel, throw, 1, erlang, throw);\n?inline(?kernel, tl, 1, erlang, tl);\n?inline(?kernel, trunc, 1, erlang, trunc);\n?inline(?kernel, tuple_size, 1, erlang, tuple_size);\n\n?inline(?list, to_atom, 1, erlang, list_to_atom);\n?inline(?list, to_existing_atom, 1, erlang, list_to_existing_atom);\n?inline(?list, to_float, 1, erlang, list_to_float);\n?inline(?list, to_integer, 1, erlang, list_to_integer);\n?inline(?list, to_integer, 2, erlang, list_to_integer);\n?inline(?list, to_tuple, 1, erlang, list_to_tuple);\n\n?inline(?map, from_keys, 2, maps, from_keys);\n?inline(?map, intersect, 2, maps, intersect);\n?inline(?map, keys, 1, maps, keys);\n?inline(?map, merge, 2, maps, merge);\n?inline(?map, to_list, 1, maps, to_list);\n?inline(?map, values, 1, maps, values);\n\n?inline(?node, list, 0, erlang, nodes);\n?inline(?node, list, 1, erlang, nodes);\n?inline(?node, spawn, 2, erlang, spawn);\n?inline(?node, spawn, 3, erlang, spawn_opt);\n?inline(?node, spawn, 4, erlang, spawn);\n?inline(?node, spawn, 5, erlang, spawn_opt);\n?inline(?node, spawn_link, 2, erlang, spawn_link);\n?inline(?node, spawn_link, 4, erlang, spawn_link);\n?inline(?node, spawn_monitor, 2, erlang, spawn_monitor);\n?inline(?node, spawn_monitor, 4, erlang, spawn_monitor);\n\n?inline(?port, close, 1, erlang, port_close);\n?inline(?port, command, 2, erlang, port_command);\n?inline(?port, command, 3, erlang, port_command);\n?inline(?port, connect, 2, erlang, port_connect);\n?inline(?port, list, 0, erlang, ports);\n?inline(?port, open, 2, erlang, open_port);\n\n?inline(?process, alias, 0, erlang, alias);\n?inline(?process, alias, 1, erlang, alias);\n?inline(?process, 'alive?', 1, erlang, is_process_alive);\n?inline(?process, cancel_timer, 1, erlang, cancel_timer);\n?inline(?process, cancel_timer, 2, erlang, cancel_timer);\n?inline(?process, demonitor, 1, erlang, demonitor);\n?inline(?process, demonitor, 2, erlang, demonitor);\n?inline(?process, exit, 2, erlang, exit);\n?inline(?process, flag, 2, erlang, process_flag);\n?inline(?process, flag, 3, erlang, process_flag);\n?inline(?process, get, 0, erlang, get);\n?inline(?process, get_keys, 0, erlang, get_keys);\n?inline(?process, get_keys, 1, erlang, get_keys);\n?inline(?process, group_leader, 0, erlang, group_leader);\n?inline(?process, hibernate, 3, erlang, hibernate);\n?inline(?process, link, 1, erlang, link);\n?inline(?process, list, 0, erlang, processes);\n?inline(?process, read_timer, 1, erlang, read_timer);\n?inline(?process, registered, 0, erlang, registered);\n?inline(?process, send, 3, erlang, send);\n?inline(?process, spawn, 2, erlang, spawn_opt);\n?inline(?process, spawn, 4, erlang, spawn_opt);\n?inline(?process, unalias, 1, erlang, unalias);\n?inline(?process, unlink, 1, erlang, unlink);\n?inline(?process, unregister, 1, erlang, unregister);\n\n?inline(?string, duplicate, 2, binary, copy);\n?inline(?string, to_atom, 1, erlang, binary_to_atom);\n?inline(?string, to_existing_atom, 1, erlang, binary_to_existing_atom);\n?inline(?string, to_float, 1, erlang, binary_to_float);\n?inline(?string, to_integer, 1, erlang, binary_to_integer);\n?inline(?string, to_integer, 2, erlang, binary_to_integer);\n\n?inline(?system, monotonic_time, 0, erlang, monotonic_time);\n?inline(?system, os_time, 0, os, system_time);\n?inline(?system, system_time, 0, erlang, system_time);\n?inline(?system, time_offset, 0, erlang, time_offset);\n?inline(?system, unique_integer, 0, erlang, unique_integer);\n?inline(?system, unique_integer, 1, erlang, unique_integer);\n?inline(?tuple, to_list, 1, erlang, tuple_to_list);\n\n% Defined without macro to avoid conflict with Bitwise named operators\ninner_inline(ex_to_erl, ?bitwise, '~~~', 1) -> {erlang, 'bnot'};\ninner_inline(ex_to_erl, ?bitwise, '&&&', 2) -> {erlang, 'band'};\ninner_inline(ex_to_erl, ?bitwise, '|||', 2) -> {erlang, 'bor'};\ninner_inline(ex_to_erl, ?bitwise, '^^^', 2) -> {erlang, 'bxor'};\ninner_inline(ex_to_erl, ?bitwise, '<<<', 2) -> {erlang, 'bsl'};\ninner_inline(ex_to_erl, ?bitwise, '>>>', 2) -> {erlang, 'bsr'};\n\n% Defined without macro to avoid conflict with Process.demonitor\ninner_inline(ex_to_erl, ?port, demonitor, 1) -> {erlang, demonitor};\ninner_inline(ex_to_erl, ?port, demonitor, 2) -> {erlang, demonitor};\n\ninner_inline(_, _, _, _) -> false.\n\n%% Rewrite rules\n%%\n%% Rewrite rules are more complex than regular inlining code\n%% as they may change the number of arguments. However, they\n%% don't add new code (such as case expressions), at best they\n%% perform dead code removal.\nrewrite(?string_chars, DotMeta, to_string, Meta, [Arg]) ->\n case is_always_string(Arg) of\n true -> Arg;\n false -> {{'.', DotMeta, [?string_chars, to_string]}, Meta, [Arg]}\n end;\nrewrite(erlang, _, '+', _, [Arg]) when is_number(Arg) -> +Arg;\nrewrite(erlang, _, '-', _, [Arg]) when is_number(Arg) -> -Arg;\nrewrite(Receiver, DotMeta, Right, Meta, Args) ->\n {EReceiver, ERight, EArgs} = inner_rewrite(ex_to_erl, DotMeta, Receiver, Right, Args),\n {{'.', DotMeta, [EReceiver, ERight]}, Meta, EArgs}.\n\n?rewrite(?float, to_charlist, [Arg], erlang, float_to_list, [Arg, [short]]);\n?rewrite(?float, to_string, [Arg], erlang, float_to_binary, [Arg, [short]]);\n?rewrite(?kernel, is_map_key, [Map, Key], erlang, is_map_key, [Key, Map]);\n?rewrite(?map, delete, [Map, Key], maps, remove, [Key, Map]);\n?rewrite(?map, fetch, [Map, Key], maps, find, [Key, Map]);\n?rewrite(?map, 'fetch!', [Map, Key], maps, get, [Key, Map]);\n?rewrite(?map, 'has_key?', [Map, Key], maps, is_key, [Key, Map]);\n?rewrite(?map, put, [Map, Key, Value], maps, put, [Key, Value, Map]);\n?rewrite(?map, 'replace!', [Map, Key, Value], maps, update, [Key, Value, Map]);\n?rewrite(?port, monitor, [Arg], erlang, monitor, [port, Arg]);\n?rewrite(?process, group_leader, [Pid, Leader], erlang, group_leader, [Leader, Pid]);\n?rewrite(?process, monitor, [Arg], erlang, monitor, [process, Arg]);\n?rewrite(?process, monitor, [Arg, Opts], erlang, monitor, [process, Arg, Opts]);\n?rewrite(?process, send_after, [Dest, Msg, Time], erlang, send_after, [Time, Dest, Msg]);\n?rewrite(?process, send_after, [Dest, Msg, Time, Opts], erlang, send_after, [Time, Dest, Msg, Opts]);\n?rewrite(?tuple, duplicate, [Data, Size], erlang, make_tuple, [Size, Data]);\n\ninner_rewrite(ex_to_erl, Meta, ?tuple, delete_at, [Tuple, Index]) ->\n {erlang, delete_element, [increment(Meta, Index), Tuple]};\ninner_rewrite(ex_to_erl, Meta, ?tuple, insert_at, [Tuple, Index, Term]) ->\n {erlang, insert_element, [increment(Meta, Index), Tuple, Term]};\ninner_rewrite(ex_to_erl, Meta, ?kernel, elem, [Tuple, Index]) ->\n {erlang, element, [increment(Meta, Index), Tuple]};\ninner_rewrite(ex_to_erl, Meta, ?kernel, put_elem, [Tuple, Index, Value]) ->\n {erlang, setelement, [increment(Meta, Index), Tuple, Value]};\n\ninner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [Index, Tuple]) when is_number(Index) ->\n {?tuple, delete_at, [Tuple, Index - 1], fun([Index, Tuple]) -> [Tuple, Index] end};\ninner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [Index, Tuple, Term]) when is_number(Index) ->\n {?tuple, insert_at, [Tuple, Index - 1, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};\ninner_rewrite(erl_to_ex, _Meta, erlang, element, [Index, Tuple]) when is_number(Index) ->\n {?kernel, elem, [Tuple, Index - 1], fun([Index, Tuple]) -> [Tuple, Index] end};\ninner_rewrite(erl_to_ex, _Meta, erlang, setelement, [Index, Tuple, Term]) when is_number(Index) ->\n {?kernel, put_elem, [Tuple, Index - 1, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};\n\ninner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->\n {?tuple, delete_at, [Tuple, Index], fun([Index, Tuple]) -> [Tuple, Index] end};\ninner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->\n {?tuple, insert_at, [Tuple, Index, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};\ninner_rewrite(erl_to_ex, _Meta, erlang, element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->\n {?kernel, elem, [Tuple, Index], fun([Index, Tuple]) -> [Tuple, Index] end};\ninner_rewrite(erl_to_ex, _Meta, erlang, setelement, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->\n {?kernel, put_elem, [Tuple, Index, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};\n\ninner_rewrite(erl_to_ex, _Meta, erlang, 'orelse', [_, _] = Args) ->\n {?kernel, 'or', Args, fun identity/1};\ninner_rewrite(erl_to_ex, _Meta, erlang, 'andalso', [_, _] = Args) ->\n {?kernel, 'and', Args, fun identity/1};\n\ninner_rewrite(ex_to_erl, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args};\ninner_rewrite(erl_to_ex, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args, fun identity/1}.\n\nidentity(Arg) -> Arg.\n\nincrement(_Meta, Number) when is_number(Number) ->\n Number + 1;\nincrement(Meta, Other) ->\n {{'.', Meta, [erlang, '+']}, Meta, [Other, 1]}.\n\n%% Match rewrite\n%%\n%% Match rewrite is similar to regular rewrite, except\n%% it also verifies the rewrite rule applies in a match context.\n%% The allowed operations are very limited.\n%% The Kernel operators are already inlined by now, we only need to\n%% care about Erlang ones.\nmatch(erlang, _, '++', Meta, [Left, Right], _S) ->\n try {ok, static_append(Left, Right, Meta)}\n catch impossible -> {error, {invalid_match_append, Left}}\n end;\nmatch(Receiver, _, Right, _, Args, _S) ->\n {error, {invalid_match, Receiver, Right, length(Args)}}.\n\nstatic_append([], Right, _Meta) -> Right;\nstatic_append([{'|', InnerMeta, [Head, Tail]}], Right, Meta) when is_list(Tail) ->\n [{'|', InnerMeta, [Head, static_append(Tail, Right, Meta)]}];\nstatic_append([{'|', _, [_, _]}], _, _) -> throw(impossible);\nstatic_append([Last], Right, Meta) -> [{'|', Meta, [Last, Right]}];\nstatic_append([Head | Tail], Right, Meta) -> [Head | static_append(Tail, Right, Meta)];\nstatic_append(_, _, _) -> throw(impossible).\n\n%% Guard rewrite\n%%\n%% Guard rewrite is similar to regular rewrite, except\n%% it also verifies the resulting function is supported in\n%% guard context - only certain BIFs and operators are.\nguard(Receiver, DotMeta, Right, Meta, Args, S) ->\n case inner_rewrite(ex_to_erl, DotMeta, Receiver, Right, Args) of\n {erlang, RRight, RArgs} ->\n case allowed_guard(RRight, length(RArgs)) of\n true -> {ok, {{'.', DotMeta, [erlang, RRight]}, Meta, RArgs}};\n false -> {error, {invalid_guard, Receiver, Right, length(Args), elixir_utils:guard_info(S)}}\n end;\n _ -> {error, {invalid_guard, Receiver, Right, length(Args), elixir_utils:guard_info(S)}}\n end.\n\n%% erlang:is_record/2-3 are compiler guards in Erlang which we\n%% need to explicitly forbid as they are allowed in erl_internal.\nallowed_guard(is_record, 2) -> false;\nallowed_guard(is_record, 3) -> false;\nallowed_guard(Right, Arity) ->\n erl_internal:guard_bif(Right, Arity) orelse elixir_utils:guard_op(Right, Arity).\n\nformat_error({invalid_guard, Receiver, Right, Arity, Context}) ->\n io_lib:format(cannot_invoke_or_maybe_require(Receiver, Right, Arity) ++ \" ~ts.~ts/~B inside a ~ts\",\n ['Elixir.Macro':to_string(Receiver), Right, Arity, Context]);\nformat_error({invalid_match, Receiver, Right, Arity}) ->\n io_lib:format(cannot_invoke_or_maybe_require(Receiver, Right, Arity) ++ \" ~ts.~ts/~B inside a match\",\n ['Elixir.Macro':to_string(Receiver), Right, Arity]);\nformat_error({invalid_match_append, Arg}) ->\n io_lib:format(\"invalid argument for ++ operator inside a match, expected a literal proper list, got: ~ts\",\n ['Elixir.Macro':to_string(Arg)]).\n\ncannot_invoke_or_maybe_require(Receiver, Fun, Arity) ->\n try\n true = lists:member({Fun, Arity}, Receiver:'__info__'(macros)),\n [\"you must require the module \", 'Elixir.Macro':to_string(Receiver), \" before invoking macro\"]\n catch\n _:_ -> \"cannot invoke remote function\"\n end.\n\nis_always_string({{'.', _, [Module, Function]}, _, Args}) ->\n is_always_string(Module, Function, length(Args));\nis_always_string(Ast) ->\n is_binary(Ast).\n\nis_always_string('Elixir.Enum', join, _) -> true;\nis_always_string('Elixir.Enum', map_join, _) -> true;\nis_always_string('Elixir.Kernel', inspect, _) -> true;\nis_always_string('Elixir.Macro', to_string, _) -> true;\nis_always_string('Elixir.String.Chars', to_string, _) -> true;\nis_always_string('Elixir.Path', join, _) -> true;\nis_always_string(_Module, _Function, _Args) -> false.\n" }, { "path": "lib/elixir/src/elixir_sup.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_sup).\n-behaviour(supervisor).\n-export([init/1, start_link/0]).\n\nstart_link() ->\n supervisor:start_link({local, ?MODULE}, ?MODULE, ok).\n\ninit(ok) ->\n Workers = [\n {\n elixir_config,\n {elixir_config, start_link, []},\n\n permanent, % Restart = permanent | transient | temporary\n 2000, % Shutdown = brutal_kill | int() >= 0 | infinity\n worker, % Type = worker | supervisor\n [elixir_config] % Modules = [Module] | dynamic\n },\n\n {\n elixir_code_server,\n {elixir_code_server, start_link, []},\n\n permanent, % Restart = permanent | transient | temporary\n 2000, % Shutdown = brutal_kill | int() >= 0 | infinity\n worker, % Type = worker | supervisor\n [elixir_code_server] % Modules = [Module] | dynamic\n }\n ],\n\n {ok, {{one_for_one, 3, 10}, Workers}}.\n" }, { "path": "lib/elixir/src/elixir_tokenizer.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(elixir_tokenizer).\n-include(\"elixir.hrl\").\n-include(\"elixir_tokenizer.hrl\").\n-export([tokenize/1, tokenize/3, tokenize/4, invalid_do_error/1,\n format_error/1, terminator/1]).\n\n-define(at_op(T),\n T =:= $@).\n\n-define(capture_op(T),\n T =:= $&).\n\n-define(unary_op(T),\n T =:= $!;\n T =:= $^).\n\n-define(range_op(T1, T2),\n T1 =:= $., T2 =:= $.).\n\n-define(concat_op(T1, T2),\n T1 =:= $+, T2 =:= $+;\n T1 =:= $-, T2 =:= $-;\n T1 =:= $<, T2 =:= $>).\n\n-define(concat_op3(T1, T2, T3),\n T1 =:= $+, T2 =:= $+, T3 =:= $+;\n T1 =:= $-, T2 =:= $-, T3 =:= $-).\n\n-define(power_op(T1, T2),\n T1 =:= $*, T2 =:= $*).\n\n-define(mult_op(T),\n T =:= $* orelse T =:= $/).\n\n-define(dual_op(T),\n T =:= $+ orelse T =:= $-).\n\n-define(arrow_op3(T1, T2, T3),\n T1 =:= $<, T2 =:= $<, T3 =:= $<;\n T1 =:= $>, T2 =:= $>, T3 =:= $>;\n T1 =:= $~, T2 =:= $>, T3 =:= $>;\n T1 =:= $<, T2 =:= $<, T3 =:= $~;\n T1 =:= $<, T2 =:= $~, T3 =:= $>;\n T1 =:= $<, T2 =:= $|, T3 =:= $>).\n\n-define(arrow_op(T1, T2),\n T1 =:= $|, T2 =:= $>;\n T1 =:= $~, T2 =:= $>;\n T1 =:= $<, T2 =:= $~).\n\n-define(rel_op(T),\n T =:= $<;\n T =:= $>).\n\n-define(rel_op2(T1, T2),\n T1 =:= $<, T2 =:= $=;\n T1 =:= $>, T2 =:= $=).\n\n-define(comp_op2(T1, T2),\n T1 =:= $=, T2 =:= $=;\n T1 =:= $=, T2 =:= $~;\n T1 =:= $!, T2 =:= $=).\n\n-define(comp_op3(T1, T2, T3),\n T1 =:= $=, T2 =:= $=, T3 =:= $=;\n T1 =:= $!, T2 =:= $=, T3 =:= $=).\n\n-define(ternary_op(T1, T2),\n T1 =:= $/, T2 =:= $/).\n\n-define(and_op(T1, T2),\n T1 =:= $&, T2 =:= $&).\n\n-define(or_op(T1, T2),\n T1 =:= $|, T2 =:= $|).\n\n-define(and_op3(T1, T2, T3),\n T1 =:= $&, T2 =:= $&, T3 =:= $&).\n\n-define(or_op3(T1, T2, T3),\n T1 =:= $|, T2 =:= $|, T3 =:= $|).\n\n-define(match_op(T),\n T =:= $=).\n\n-define(in_match_op(T1, T2),\n T1 =:= $<, T2 =:= $-;\n T1 =:= $\\\\, T2 =:= $\\\\).\n\n-define(stab_op(T1, T2),\n T1 =:= $-, T2 =:= $>).\n\n-define(type_op(T1, T2),\n T1 =:= $:, T2 =:= $:).\n\n-define(pipe_op(T),\n T =:= $|).\n\n-define(ellipsis_op3(T1, T2, T3),\n T1 =:= $., T2 =:= $., T3 =:= $.).\n\n%% Deprecated operators\n\n-define(unary_op3(T1, T2, T3),\n T1 =:= $~, T2 =:= $~, T3 =:= $~).\n\n-define(xor_op3(T1, T2, T3),\n T1 =:= $^, T2 =:= $^, T3 =:= $^).\n\ntokenize(String, Line, Column, #elixir_tokenizer{} = Scope) ->\n tokenize(String, Line, Column, Scope, []);\n\ntokenize(String, Line, Column, Opts) ->\n IdentifierTokenizer = elixir_config:identifier_tokenizer(),\n\n Scope =\n lists:foldl(fun\n ({check_terminators, false}, Acc) ->\n Acc#elixir_tokenizer{cursor_completion=false, terminators=none};\n ({check_terminators, {cursor, Sigils, Terminators}}, Acc) ->\n Acc#elixir_tokenizer{cursor_completion={prune_and_cursor, Sigils}, terminators=Terminators};\n ({existing_atoms_only, ExistingAtomsOnly}, Acc) when is_boolean(ExistingAtomsOnly) ->\n Acc#elixir_tokenizer{existing_atoms_only=ExistingAtomsOnly};\n ({static_atoms_encoder, StaticAtomsEncoder}, Acc) when is_function(StaticAtomsEncoder) ->\n Acc#elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder};\n ({preserve_comments, PreserveComments}, Acc) when is_function(PreserveComments) ->\n Acc#elixir_tokenizer{preserve_comments=PreserveComments};\n ({unescape, Unescape}, Acc) when is_boolean(Unescape) ->\n Acc#elixir_tokenizer{unescape=Unescape};\n ({indentation, Indentation}, Acc) when Indentation >= 0 ->\n Acc#elixir_tokenizer{column=Indentation+1};\n (_, Acc) ->\n Acc\n end, #elixir_tokenizer{identifier_tokenizer=IdentifierTokenizer}, Opts),\n\n tokenize(String, Line, Column, Scope, []).\n\ntokenize(String, Line, Opts) ->\n tokenize(String, Line, 1, Opts).\n\ntokenize([], Line, Column, #elixir_tokenizer{cursor_completion=Cursor} = Scope, Tokens) when Cursor /= false ->\n #elixir_tokenizer{ascii_identifiers_only=Ascii, terminators=Terminators, warnings=Warnings} = Scope,\n {CursorColumn, AccTokens} = add_cursor(Line, Column, Cursor, Tokens),\n AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings),\n {ok, Line, CursorColumn, AllWarnings, AccTokens, Terminators};\n\ntokenize([], EndLine, EndColumn, #elixir_tokenizer{terminators=[{Start, {StartLine, StartColumn, _}, _} | _]} = Scope, Tokens) ->\n End = terminator(Start),\n Hint = missing_terminator_hint(Start, End, Scope),\n Message = \"missing terminator: ~ts\",\n Formatted = io_lib:format(Message, [End]),\n Meta = [\n {opening_delimiter, Start},\n {expected_delimiter, End},\n {line, StartLine},\n {column, StartColumn},\n {end_line, EndLine},\n {end_column, EndColumn}\n ],\n error({Meta, [Formatted, Hint], []}, [], Scope, Tokens);\n\ntokenize([], Line, Column, #elixir_tokenizer{} = Scope, Tokens) ->\n #elixir_tokenizer{ascii_identifiers_only=Ascii, warnings=Warnings} = Scope,\n AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings),\n {ok, Line, Column, AllWarnings, Tokens, []};\n\n% VC merge conflict\n\ntokenize((\"<<<<<<<\" ++ _) = Original, Line, 1, Scope, Tokens) ->\n FirstLine = lists:takewhile(fun(C) -> C =/= $\\n andalso C =/= $\\r end, Original),\n Reason = {?LOC(Line, 1), \"found an unexpected version control marker, please resolve the conflicts: \", FirstLine},\n error(Reason, Original, Scope, Tokens);\n\n% Base integers\n\ntokenize([$0, $x, H | T], Line, Column, Scope, Tokens) when ?is_hex(H) ->\n {Rest, Number, OriginalRepresentation, Length} = tokenize_hex(T, [H], 1),\n Token = {int, {Line, Column, Number}, OriginalRepresentation},\n tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]);\n\ntokenize([$0, $b, H | T], Line, Column, Scope, Tokens) when ?is_bin(H) ->\n {Rest, Number, OriginalRepresentation, Length} = tokenize_bin(T, [H], 1),\n Token = {int, {Line, Column, Number}, OriginalRepresentation},\n tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]);\n\ntokenize([$0, $o, H | T], Line, Column, Scope, Tokens) when ?is_octal(H) ->\n {Rest, Number, OriginalRepresentation, Length} = tokenize_octal(T, [H], 1),\n Token = {int, {Line, Column, Number}, OriginalRepresentation},\n tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]);\n\n% Comments\n\ntokenize([$# | String], Line, Column, Scope, Tokens) ->\n case tokenize_comment(String, [$#]) of\n {error, Char, Reason} ->\n error_comment(Char, Reason, [$# | String], Line, Column, Scope, Tokens);\n {Rest, Comment} ->\n preserve_comments(Line, Column, Tokens, Comment, Rest, Scope),\n tokenize(Rest, Line, Column, Scope, reset_eol(Tokens))\n end;\n\n% Sigils\n\ntokenize([$~, H | _T] = Original, Line, Column, Scope, Tokens) when ?is_upcase(H) orelse ?is_downcase(H) ->\n tokenize_sigil(Original, Line, Column, Scope, Tokens);\n\n% Char tokens\n\n% We tokenize char literals (?a) as {char, _, CharInt} instead of {number, _,\n% CharInt}. This is exactly what Erlang does with Erlang char literals\n% ($a). This means we'll have to adjust the error message for char literals in\n% elixir_errors.erl as by default {char, _, _} tokens are \"hijacked\" by Erlang\n% and printed with Erlang syntax ($a) in the parser's error messages.\n\ntokenize([$?, $\\\\, H | T], Line, Column, Scope, Tokens) ->\n Char = elixir_interpolation:unescape_map(H),\n\n NewScope = if\n H =:= Char, H =/= $\\\\ ->\n case handle_char(Char) of\n {Escape, Name} ->\n Msg = io_lib:format(\"found ?\\\\ followed by code point 0x~.16B (~ts), please use ?~ts instead\",\n [Char, Name, Escape]),\n prepend_warning(Line, Column, Msg, Scope);\n\n false when ?is_downcase(H); ?is_upcase(H) ->\n Msg = io_lib:format(\"unknown escape sequence ?\\\\~tc, use ?~tc instead\", [H, H]),\n prepend_warning(Line, Column, Msg, Scope);\n\n false ->\n Scope\n end;\n true ->\n Scope\n end,\n\n Token = {char, {Line, Column, [$?, $\\\\, H]}, Char},\n case H of\n $\\n ->\n %% If original char is a literal line feed, we already emit a warning,\n %% but we need to bump the line without emitting an EOL token.\n tokenize_eol(T, Line, NewScope, [Token | Tokens]);\n _ ->\n tokenize(T, Line, Column + 3, NewScope, [Token | Tokens])\n end;\n\ntokenize([$?, Char | T], Line, Column, Scope, Tokens) ->\n NewScope = case handle_char(Char) of\n {Escape, Name} ->\n Msg = io_lib:format(\"found ? followed by code point 0x~.16B (~ts), please use ?~ts instead\",\n [Char, Name, Escape]),\n prepend_warning(Line, Column, Msg, Scope);\n false ->\n Scope\n end,\n Token = {char, {Line, Column, [$?, Char]}, Char},\n case Char of\n $\\n ->\n %% If original char is a literal line feed, we already emit a warning,\n %% but we need to bump the line without emitting an EOL token.\n tokenize_eol(T, Line, NewScope, [Token | Tokens]);\n _ ->\n tokenize(T, Line, Column + 2, NewScope, [Token | Tokens])\n end;\n\n% Heredocs\n\ntokenize(\"\\\"\\\"\\\"\" ++ T, Line, Column, Scope, Tokens) ->\n handle_heredocs(T, Line, Column, $\", Scope, Tokens);\n\n%% TODO: Remove me in Elixir v2.0\ntokenize(\"'''\" ++ T, Line, Column, Scope, Tokens) ->\n NewScope = prepend_warning(Line, Column, \"single-quoted string represent charlists. Use ~c''' if you indeed want a charlist or use \\\"\\\"\\\" instead\", Scope),\n handle_heredocs(T, Line, Column, $', NewScope, Tokens);\n\n% Strings\n\ntokenize([$\" | T], Line, Column, Scope, Tokens) ->\n handle_strings(T, Line, Column + 1, $\", Scope, Tokens);\n\n%% TODO: Remove me in Elixir v2.0\ntokenize([$' | T], Line, Column, Scope, Tokens) ->\n handle_strings(T, Line, Column + 1, $', Scope, Tokens);\n\n% Operator atoms\n\ntokenize(\".:\" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->\n tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '.'} | Tokens]);\n\ntokenize(\"<<>>:\" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->\n tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '<<>>'} | Tokens]);\ntokenize(\"%{}:\" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->\n tokenize(Rest, Line, Column + 4, Scope, [{kw_identifier, {Line, Column, nil}, '%{}'} | Tokens]);\ntokenize(\"%:\" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->\n tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '%'} | Tokens]);\ntokenize(\"&:\" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->\n tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '&'} | Tokens]);\ntokenize(\"{}:\" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->\n tokenize(Rest, Line, Column + 3, Scope, [{kw_identifier, {Line, Column, nil}, '{}'} | Tokens]);\ntokenize(\"..//:\" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->\n tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '..//'} | Tokens]);\n\ntokenize(\":<<>>\" ++ Rest, Line, Column, Scope, Tokens) ->\n tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '<<>>'} | Tokens]);\ntokenize(\":%{}\" ++ Rest, Line, Column, Scope, Tokens) ->\n tokenize(Rest, Line, Column + 4, Scope, [{atom, {Line, Column, nil}, '%{}'} | Tokens]);\ntokenize(\":%\" ++ Rest, Line, Column, Scope, Tokens) ->\n tokenize(Rest, Line, Column + 2, Scope, [{atom, {Line, Column, nil}, '%'} | Tokens]);\ntokenize(\":{}\" ++ Rest, Line, Column, Scope, Tokens) ->\n tokenize(Rest, Line, Column + 3, Scope, [{atom, {Line, Column, nil}, '{}'} | Tokens]);\ntokenize(\":..//\" ++ Rest, Line, Column, Scope, Tokens) ->\n tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '..//'} | Tokens]);\n\n% ## Three Token Operators\ntokenize([$:, T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when\n ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3);\n ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3); ?ellipsis_op3(T1, T2, T3) ->\n Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2, T3])},\n tokenize(Rest, Line, Column + 4, Scope, [Token | Tokens]);\n\n% ## Two Token Operators\n\ntokenize([$:, $:, $: | Rest], Line, Column, Scope, Tokens) ->\n Message = \"atom ::: must be written between quotes, as in :\\\"::\\\", to avoid ambiguity\",\n NewScope = prepend_warning(Line, Column, Message, Scope),\n Token = {atom, {Line, Column, nil}, '::'},\n tokenize(Rest, Line, Column + 3, NewScope, [Token | Tokens]);\n\ntokenize([$:, T1, T2 | Rest], Line, Column, Scope, Tokens) when\n ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2);\n ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2);\n ?stab_op(T1, T2); ?range_op(T1, T2) ->\n Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2])},\n tokenize(Rest, Line, Column + 3, Scope, [Token | Tokens]);\n\n% ## Single Token Operators\ntokenize([$:, T | Rest], Line, Column, Scope, Tokens) when\n ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T);\n ?rel_op(T); ?match_op(T); ?pipe_op(T); T =:= $. ->\n Token = {atom, {Line, Column, nil}, list_to_atom([T])},\n tokenize(Rest, Line, Column + 2, Scope, [Token | Tokens]);\n\n% ## Stand-alone tokens\n\ntokenize(\"=>\" ++ Rest, Line, Column, Scope, Tokens) ->\n Token = {assoc_op, {Line, Column, previous_was_eol(Tokens)}, '=>'},\n tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens));\n\ntokenize(\"..//\" ++ Rest = String, Line, Column, Scope, Tokens) ->\n case strip_horizontal_space(Rest, Line, Column + 4, Scope) of\n {[$/ | _] = Remaining, NewLine, NewColumn} ->\n Token = {identifier, {Line, Column, nil}, '..//'},\n tokenize(Remaining, NewLine, NewColumn, Scope, [Token | Tokens]);\n {_, _, _} ->\n unexpected_token(String, Line, Column, Scope, Tokens)\n end;\n\n% ## Ternary operator\n\n% ## Three token operators\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?unary_op3(T1, T2, T3) ->\n handle_unary_op(Rest, Line, Column, unary_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);\n\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?ellipsis_op3(T1, T2, T3) ->\n handle_unary_op(Rest, Line, Column, ellipsis_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);\n\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?comp_op3(T1, T2, T3) ->\n handle_op(Rest, Line, Column, comp_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);\n\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?and_op3(T1, T2, T3) ->\n NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),\n handle_op(Rest, Line, Column, and_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);\n\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?or_op3(T1, T2, T3) ->\n NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),\n handle_op(Rest, Line, Column, or_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);\n\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?xor_op3(T1, T2, T3) ->\n NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),\n handle_op(Rest, Line, Column, xor_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);\n\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?concat_op3(T1, T2, T3) ->\n NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),\n handle_op(Rest, Line, Column, concat_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);\n\ntokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?arrow_op3(T1, T2, T3) ->\n handle_op(Rest, Line, Column, arrow_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);\n\n% ## Containers + punctuation tokens\ntokenize([$, | Rest], Line, Column, Scope, Tokens) ->\n Token = {',', {Line, Column, 0}},\n tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]);\n\ntokenize([$<, $< | Rest], Line, Column, Scope, Tokens) ->\n Token = {'<<', {Line, Column, nil}},\n handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens);\n\ntokenize([$>, $> | Rest], Line, Column, Scope, Tokens) ->\n Token = {'>>', {Line, Column, previous_was_eol(Tokens)}},\n handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens);\n\ntokenize([${ | Rest], Line, Column, Scope, [{'%', _} | _] = Tokens) ->\n Message =\n \"unexpected space between % and {\\n\\n\"\n \"If you want to define a map, write %{...}, with no spaces.\\n\"\n \"If you want to define a struct, write %StructName{...}.\\n\\n\"\n \"Syntax error before: \",\n error({?LOC(Line, Column), Message, [${]}, Rest, Scope, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $(; T =:= ${; T =:= $[ ->\n Token = {list_to_atom([T]), {Line, Column, nil}},\n handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $); T =:= $}; T =:= $] ->\n Token = {list_to_atom([T]), {Line, Column, previous_was_eol(Tokens)}},\n handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens);\n\n% ## Two Token Operators\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?ternary_op(T1, T2) ->\n Op = list_to_atom([T1, T2]),\n Token = {ternary_op, {Line, Column, previous_was_eol(Tokens)}, Op},\n tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens));\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?power_op(T1, T2) ->\n handle_op(Rest, Line, Column, power_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?range_op(T1, T2) ->\n handle_op(Rest, Line, Column, range_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?concat_op(T1, T2) ->\n handle_op(Rest, Line, Column, concat_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?arrow_op(T1, T2) ->\n handle_op(Rest, Line, Column, arrow_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?comp_op2(T1, T2) ->\n handle_op(Rest, Line, Column, comp_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?rel_op2(T1, T2) ->\n handle_op(Rest, Line, Column, rel_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?and_op(T1, T2) ->\n handle_op(Rest, Line, Column, and_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?or_op(T1, T2) ->\n handle_op(Rest, Line, Column, or_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?in_match_op(T1, T2) ->\n handle_op(Rest, Line, Column, in_match_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?type_op(T1, T2) ->\n handle_op(Rest, Line, Column, type_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\ntokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?stab_op(T1, T2) ->\n handle_op(Rest, Line, Column, stab_op, 2, list_to_atom([T1, T2]), Scope, Tokens);\n\n% ## Single Token Operators\n\ntokenize([$& | Rest], Line, Column, Scope, Tokens) ->\n Kind =\n case strip_horizontal_space(Rest, Line, 0, Scope) of\n {[Int | _], Line, 0} when ?is_digit(Int) ->\n capture_int;\n\n {[$/ | NewRest], _, _} ->\n case strip_horizontal_space(NewRest, Line, 0, Scope) of\n {[$/ | _], _, _} -> capture_op;\n {_, _, _} -> identifier\n end;\n\n {_, _, _} ->\n capture_op\n end,\n\n Token = {Kind, {Line, Column, nil}, '&'},\n tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?at_op(T) ->\n handle_unary_op(Rest, Line, Column, at_op, 1, list_to_atom([T]), Scope, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?unary_op(T) ->\n handle_unary_op(Rest, Line, Column, unary_op, 1, list_to_atom([T]), Scope, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?rel_op(T) ->\n handle_op(Rest, Line, Column, rel_op, 1, list_to_atom([T]), Scope, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?dual_op(T) ->\n handle_unary_op(Rest, Line, Column, dual_op, 1, list_to_atom([T]), Scope, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?mult_op(T) ->\n handle_op(Rest, Line, Column, mult_op, 1, list_to_atom([T]), Scope, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?match_op(T) ->\n handle_op(Rest, Line, Column, match_op, 1, list_to_atom([T]), Scope, Tokens);\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?pipe_op(T) ->\n handle_op(Rest, Line, Column, pipe_op, 1, list_to_atom([T]), Scope, Tokens);\n\n% Non-operator Atoms\n\ntokenize([$:, H | T] = Original, Line, Column, BaseScope, Tokens) when ?is_quote(H) ->\n Scope = case H == $' of\n true ->\n prepend_warning(Line, Column, \"single quotes around atoms are deprecated. Use double quotes instead\", BaseScope);\n\n false ->\n BaseScope\n end,\n\n case elixir_interpolation:extract(Line, Column + 2, Scope, true, T, H) of\n {NewLine, NewColumn, Parts, Rest, _Done, InterScope} ->\n NewScope = case is_unnecessary_quote(Parts, InterScope) of\n true ->\n WarnMsg = io_lib:format(\n \"found quoted atom \\\"~ts\\\" but the quotes are not required. \"\n \"Atoms made exclusively of ASCII letters, numbers, underscores, \"\n \"beginning with a letter or underscore, and optionally ending with ! or ? \"\n \"do not require quotes\",\n [hd(Parts)]\n ),\n prepend_warning(Line, Column, WarnMsg, InterScope);\n\n false ->\n InterScope\n end,\n\n case unescape_tokens(Parts, Line, Column, NewScope) of\n {ok, [Part]} when is_binary(Part) ->\n case unsafe_to_atom(Part, Line, Column, Scope) of\n {ok, Atom} ->\n Token = {atom_quoted, {Line, Column, H}, Atom},\n tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);\n\n {error, Reason} ->\n error(Reason, Rest, NewScope, Tokens)\n end;\n\n {ok, Unescaped} ->\n Key = case Scope#elixir_tokenizer.existing_atoms_only of\n true -> atom_safe;\n false -> atom_unsafe\n end,\n Token = {Key, {Line, Column, H}, Unescaped},\n tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);\n\n {error, Reason} ->\n error(Reason, Rest, NewScope, Tokens)\n end;\n\n {error, Reason} ->\n Message = \" (for atom starting at line ~B)\",\n interpolation_error(Reason, Original, Scope, Tokens, Message, [Line], Line, Column + 1, [H], [H])\n end;\n\ntokenize([$: | String] = Original, Line, Column, Scope, Tokens) ->\n case tokenize_identifier(String, Line, Column, Scope, false) of\n {_Kind, Unencoded, Atom, Rest, Length, Ascii, _Special} ->\n NewScope = maybe_warn_for_ambiguous_bang_before_equals(atom, Unencoded, Rest, Line, Column, Scope),\n TrackedScope = track_ascii(Ascii, NewScope),\n Token = {atom, {Line, Column, Unencoded}, Atom},\n tokenize(Rest, Line, Column + 1 + Length, TrackedScope, [Token | Tokens]);\n empty when Scope#elixir_tokenizer.cursor_completion == false ->\n unexpected_token(Original, Line, Column, Scope, Tokens);\n empty ->\n tokenize([], Line, Column, Scope, Tokens);\n {unexpected_token, Length} ->\n unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, Scope, Tokens);\n {error, Reason} ->\n error(Reason, Original, Scope, Tokens)\n end;\n\n% Integers and floats\n% We use int and flt otherwise elixir_parser won't format them\n% properly in case of errors.\n\ntokenize([H | T], Line, Column, Scope, Tokens) when ?is_digit(H) ->\n case tokenize_number(T, [H], 1, false) of\n {error, Reason, Original} ->\n error({?LOC(Line, Column), Reason, Original}, T, Scope, Tokens);\n {[I | Rest], Number, Original, _Length} when ?is_upcase(I); ?is_downcase(I); I == $_ ->\n if\n Number == 0, (I =:= $x) orelse (I =:= $o) orelse (I =:= $b), Rest == [],\n Scope#elixir_tokenizer.cursor_completion /= false ->\n tokenize([], Line, Column, Scope, Tokens);\n\n true ->\n Msg =\n io_lib:format(\n \"invalid character \\\"~ts\\\" after number ~ts. If you intended to write a number, \"\n \"make sure to separate the number from the character (using comma, space, etc). \"\n \"If you meant to write a function name or a variable, note that identifiers in \"\n \"Elixir cannot start with numbers. Unexpected token: \",\n [[I], Original]\n ),\n\n error({?LOC(Line, Column), Msg, [I]}, T, Scope, Tokens)\n end;\n {Rest, Number, Original, Length} when is_integer(Number) ->\n Token = {int, {Line, Column, Number}, Original},\n tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]);\n {Rest, Number, Original, Length} ->\n Token = {flt, {Line, Column, Number}, Original},\n tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens])\n end;\n\n% Spaces\n\ntokenize([T | Rest], Line, Column, Scope, Tokens) when ?is_horizontal_space(T) ->\n {Remaining, NewLine, NewColumn} = strip_horizontal_space(Rest, Line, Column + 1, Scope),\n handle_space_sensitive_tokens(Remaining, NewLine, NewColumn, Scope, Tokens);\n\n% End of line\n\ntokenize(\";\" ++ Rest, Line, Column, Scope, []) ->\n tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}}]);\n\ntokenize(\";\" ++ Rest, Line, Column, Scope, [Top | _] = Tokens) when element(1, Top) /= ';' ->\n tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}} | Tokens]);\n\ntokenize(\"\\\\\" = Original, Line, Column, Scope, Tokens) ->\n error({?LOC(Line, Column), \"invalid escape \\\\ at end of file\", []}, Original, Scope, Tokens);\n\ntokenize(\"\\\\\\n\" = Original, Line, Column, Scope, Tokens) ->\n error({?LOC(Line, Column), \"invalid escape \\\\ at end of file\", []}, Original, Scope, Tokens);\n\ntokenize(\"\\\\\\r\\n\" = Original, Line, Column, Scope, Tokens) ->\n error({?LOC(Line, Column), \"invalid escape \\\\ at end of file\", []}, Original, Scope, Tokens);\n\ntokenize(\"\\\\\\n\" ++ Rest, Line, _Column, Scope, Tokens) ->\n tokenize_eol(Rest, Line, Scope, Tokens);\n\ntokenize(\"\\\\\\r\\n\" ++ Rest, Line, _Column, Scope, Tokens) ->\n tokenize_eol(Rest, Line, Scope, Tokens);\n\ntokenize(\"\\n\" ++ Rest, Line, Column, Scope, Tokens) ->\n tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens));\n\ntokenize(\"\\r\\n\" ++ Rest, Line, Column, Scope, Tokens) ->\n tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens));\n\n% Others\n\ntokenize([$%, $( | Rest], Line, Column, Scope, Tokens) ->\n Reason = {?LOC(Line, Column), \"expected %{ to define a map, got: \", [$%, $(]},\n error(Reason, Rest, Scope, Tokens);\n\ntokenize([$%, $[ | Rest], Line, Column, Scope, Tokens) ->\n Reason = {?LOC(Line, Column), \"expected %{ to define a map, got: \", [$%, $[]},\n error(Reason, Rest, Scope, Tokens);\n\ntokenize([$%, ${ | T], Line, Column, Scope, Tokens) ->\n Token = {'{', {Line, Column, nil}},\n handle_terminator(T, Line, Column + 2, Scope, Token, [{'%{}', {Line, Column, nil}} | Tokens]);\n\ntokenize([$% | T], Line, Column, Scope, Tokens) ->\n tokenize(T, Line, Column + 1, Scope, [{'%', {Line, Column, nil}} | Tokens]);\n\ntokenize([$. | T], Line, Column, Scope, Tokens) ->\n tokenize_dot(T, Line, Column + 1, {Line, Column, nil}, Scope, Tokens);\n\n% Identifiers\n\ntokenize(String, Line, Column, OriginalScope, Tokens) ->\n case tokenize_identifier(String, Line, Column, OriginalScope, not previous_was_dot(Tokens)) of\n {Kind, Unencoded, Atom, Rest, Length, Ascii, Special} ->\n HasAt = lists:member(at, Special),\n Scope = track_ascii(Ascii, OriginalScope),\n\n case Rest of\n [$: | T] when ?is_space(hd(T)) ->\n Token = {kw_identifier, {Line, Column, Unencoded}, Atom},\n tokenize(T, Line, Column + Length + 1, Scope, [Token | Tokens]);\n\n [$: | T] when hd(T) =/= $: ->\n AtomName = atom_to_list(Atom) ++ [$:],\n Reason = {?LOC(Line, Column), \"keyword argument must be followed by space after: \", AtomName},\n error(Reason, String, Scope, Tokens);\n\n _ when HasAt ->\n Reason = {?LOC(Line, Column), invalid_character_error(Kind, $@), atom_to_list(Atom)},\n error(Reason, String, Scope, Tokens);\n\n _ when Atom == '__aliases__'; Atom == '__block__' ->\n error({?LOC(Line, Column), \"reserved token: \", atom_to_list(Atom)}, Rest, Scope, Tokens);\n\n _ when Kind == alias ->\n tokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens);\n\n _ when Kind == identifier ->\n NewScope = maybe_warn_for_ambiguous_bang_before_equals(identifier, Unencoded, Rest, Line, Column, Scope),\n Token = check_call_identifier(Line, Column, Unencoded, Atom, Rest),\n tokenize(Rest, Line, Column + Length, NewScope, [Token | Tokens]);\n\n _ ->\n unexpected_token(String, Line, Column, Scope, Tokens)\n end;\n\n {keyword, Atom, Type, Rest, Length} ->\n tokenize_keyword(Type, Rest, Line, Column, Atom, Length, OriginalScope, Tokens);\n\n empty when OriginalScope#elixir_tokenizer.cursor_completion == false ->\n unexpected_token(String, Line, Column, OriginalScope, Tokens);\n\n empty ->\n case String of\n [$~, L] when ?is_upcase(L); ?is_downcase(L) -> tokenize([], Line, Column, OriginalScope, Tokens);\n [$~] -> tokenize([], Line, Column, OriginalScope, Tokens);\n _ -> unexpected_token(String, Line, Column, OriginalScope, Tokens)\n end;\n\n {unexpected_token, Length} ->\n unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, OriginalScope, Tokens);\n\n {error, Reason} ->\n error(Reason, String, OriginalScope, Tokens)\n end.\n\nprevious_was_dot([{'.', _} | _]) -> true;\nprevious_was_dot(_) -> false.\n\nunexpected_token([T | Rest], Line, Column, Scope, Tokens) ->\n Message =\n case handle_char(T) of\n {_Escaped, Explanation} ->\n io_lib:format(\"~ts (column ~p, code point U+~4.16.0B)\", [Explanation, Column, T]);\n false ->\n io_lib:format(\"\\\"~ts\\\" (column ~p, code point U+~4.16.0B)\", [[T], Column, T])\n end,\n error({?LOC(Line, Column), \"unexpected token: \", Message}, Rest, Scope, Tokens).\n\ntokenize_eol(Rest, Line, Scope, Tokens) ->\n {StrippedRest, NewLine, NewColumn} =\n strip_horizontal_space(Rest, Line + 1, Scope#elixir_tokenizer.column, Scope),\n IndentedScope = Scope#elixir_tokenizer{indentation=NewColumn-1},\n tokenize(StrippedRest, NewLine, NewColumn, IndentedScope, Tokens).\n\nstrip_horizontal_space([H | T], Line, Counter, Scope) when ?is_horizontal_space(H) ->\n strip_horizontal_space(T, Line, Counter + 1, Scope);\n%% \\\\ at the end of lines is treated as horizontal whitespace\n%% except at the very end of the buffer, which we treat as incomplete\nstrip_horizontal_space(\"\\\\\\n\" ++ T, Line, _Counter, Scope) when T /= [] ->\n strip_horizontal_space(T, Line+1, Scope#elixir_tokenizer.column, Scope);\nstrip_horizontal_space(\"\\\\\\r\\n\" ++ T, Line, _Counter, Scope) when T /= [] ->\n strip_horizontal_space(T, Line+1, Scope#elixir_tokenizer.column, Scope);\nstrip_horizontal_space(T, Line, Counter, _Scope) ->\n {T, Line, Counter}.\n\ntokenize_dot(T, Line, Column, DotInfo, Scope, Tokens) ->\n case strip_horizontal_space(T, Line, Column, Scope) of\n {[$# | R], NewLine, NewColumn} ->\n case tokenize_comment(R, [$#]) of\n {error, Char, Reason} ->\n error_comment(Char, Reason, [$# | R], NewLine, NewColumn, Scope, Tokens);\n\n {Rest, Comment} ->\n preserve_comments(NewLine, NewColumn, Tokens, Comment, Rest, Scope),\n tokenize_dot(Rest, NewLine, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens)\n end;\n {\"\\r\\n\" ++ Rest, NewLine, _NewColumn} ->\n tokenize_dot(Rest, NewLine + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens);\n {\"\\n\" ++ Rest, NewLine, _NewColumn} ->\n tokenize_dot(Rest, NewLine + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens);\n {Rest, NewLine, NewColumn} ->\n handle_dot([$. | Rest], NewLine, NewColumn, DotInfo, Scope, Tokens)\n end.\n\nhandle_char(0) -> {\"\\\\0\", \"null byte\"};\nhandle_char(7) -> {\"\\\\a\", \"alert\"};\nhandle_char($\\b) -> {\"\\\\b\", \"backspace\"};\nhandle_char($\\d) -> {\"\\\\d\", \"delete\"};\nhandle_char($\\e) -> {\"\\\\e\", \"escape\"};\nhandle_char($\\f) -> {\"\\\\f\", \"form feed\"};\nhandle_char($\\n) -> {\"\\\\n\", \"newline\"};\nhandle_char($\\r) -> {\"\\\\r\", \"carriage return\"};\nhandle_char($\\s) -> {\"\\\\s\", \"space\"};\nhandle_char($\\t) -> {\"\\\\t\", \"tab\"};\nhandle_char($\\v) -> {\"\\\\v\", \"vertical tab\"};\nhandle_char(_) -> false.\n\n%% Handlers\n\nhandle_heredocs(T, Line, Column, H, Scope, Tokens) ->\n case extract_heredoc_with_interpolation(Line, Column, Scope, true, T, H) of\n {ok, NewLine, NewColumn, Parts, Rest, _Done, NewScope} ->\n case unescape_tokens(Parts, Line, Column, NewScope) of\n {ok, Unescaped} ->\n Token = {heredoc_type(H), {Line, Column, nil}, NewColumn - 4, Unescaped},\n tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);\n\n {error, Reason} ->\n error(Reason, Rest, Scope, Tokens)\n end;\n\n {error, Reason} ->\n error(Reason, [H, H, H] ++ T, Scope, Tokens)\n end.\n\nhandle_strings(T, Line, Column, H, Scope, Tokens) ->\n case elixir_interpolation:extract(Line, Column, Scope, true, T, H) of\n {error, Reason} ->\n interpolation_error(Reason, [H | T], Scope, Tokens, \" (for string starting at line ~B)\", [Line], Line, Column-1, [H], [H]);\n\n {NewLine, NewColumn, Parts, [$: | Rest], _Done, InterScope} when ?is_space(hd(Rest)) ->\n NewScope = case is_unnecessary_quote(Parts, InterScope) of\n true ->\n WarnMsg = io_lib:format(\n \"found quoted keyword \\\"~ts\\\" but the quotes are not required. \"\n \"Note that keywords are always atoms, even when quoted. \"\n \"Similar to atoms, keywords made exclusively of ASCII \"\n \"letters, numbers, and underscores and not beginning with a \"\n \"number do not require quotes\",\n [hd(Parts)]\n ),\n prepend_warning(Line, Column-1, WarnMsg, InterScope);\n\n false when H =:= $' ->\n WarnMsg = \"single quotes around keywords are deprecated. Use double quotes instead\",\n prepend_warning(Line, Column-1, WarnMsg, InterScope);\n\n false ->\n InterScope\n end,\n\n case unescape_tokens(Parts, Line, Column, NewScope) of\n {ok, [Part]} when is_binary(Part) ->\n case unsafe_to_atom(Part, Line, Column - 1, Scope) of\n {ok, Atom} ->\n Token = {kw_identifier, {Line, Column - 1, H}, Atom},\n tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]);\n {error, Reason} ->\n error(Reason, Rest, NewScope, Tokens)\n end;\n\n {ok, Unescaped} ->\n Key = case Scope#elixir_tokenizer.existing_atoms_only of\n true -> kw_identifier_safe;\n false -> kw_identifier_unsafe\n end,\n Token = {Key, {Line, Column - 1, H}, Unescaped},\n tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]);\n\n {error, Reason} ->\n error(Reason, Rest, NewScope, Tokens)\n end;\n\n {NewLine, NewColumn, Parts, Rest, _Done, InterScope} ->\n NewScope =\n case H of\n $' ->\n Message = \"using single-quoted strings to represent charlists is deprecated.\\n\"\n \"Use ~c\\\"\\\" if you indeed want a charlist or use \\\"\\\" instead.\\n\"\n \"You may run \\\"mix format --migrate\\\" to change all single-quoted\\n\"\n \"strings to use the ~c sigil and fix this warning.\",\n prepend_warning(Line, Column-1, Message, InterScope);\n\n _ ->\n InterScope\n end,\n\n case unescape_tokens(Parts, Line, Column, NewScope) of\n {ok, Unescaped} ->\n Token = {string_type(H), {Line, Column - 1, nil}, Unescaped},\n tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);\n\n {error, Reason} ->\n error(Reason, Rest, NewScope, Tokens)\n end\n end.\n\nhandle_unary_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) ->\n Token = {kw_identifier, {Line, Column, nil}, Op},\n tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]);\n\nhandle_unary_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) ->\n case strip_horizontal_space(Rest, Line, Column + Length, Scope) of\n {[$/ | _] = Remaining, NewLine, NewColumn} ->\n Token = {identifier, {Line, Column, nil}, Op},\n tokenize(Remaining, NewLine, NewColumn, Scope, [Token | Tokens]);\n {Remaining, NewLine, NewColumn} ->\n NewScope =\n %% TODO: Remove these deprecations on Elixir v2.0\n case Op of\n '~~~' ->\n Msg = \"~~~ is deprecated. Use Bitwise.bnot/1 instead for clarity\",\n prepend_warning(Line, Column, Msg, Scope);\n _ ->\n Scope\n end,\n\n Token = {Kind, {Line, Column, nil}, Op},\n tokenize(Remaining, NewLine, NewColumn, NewScope, [Token | Tokens])\n end.\n\nhandle_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) ->\n Token = {kw_identifier, {Line, Column, nil}, Op},\n tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]);\n\nhandle_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) ->\n case strip_horizontal_space(Rest, Line, Column + Length, Scope) of\n {[$/ | _] = Remaining, NewLine, NewColumn} ->\n Token = {identifier, {Line, Column, nil}, Op},\n tokenize(Remaining, NewLine, NewColumn, Scope, [Token | Tokens]);\n {Remaining, NewLine, NewColumn} ->\n NewScope =\n %% TODO: Remove these deprecations on Elixir v2.0\n case Op of\n '^^^' ->\n Msg = \"^^^ is deprecated. It is typically used as xor but it has the wrong precedence, use Bitwise.bxor/2 instead\",\n prepend_warning(Line, Column, Msg, Scope);\n\n '<|>' ->\n Msg = \"<|> is deprecated. Use another pipe-like operator\",\n prepend_warning(Line, Column, Msg, Scope);\n\n _ ->\n Scope\n end,\n\n Token = {Kind, {Line, Column, previous_was_eol(Tokens)}, Op},\n tokenize(Remaining, NewLine, NewColumn, NewScope, add_token_with_eol(Token, Tokens))\n end.\n\n% ## Three Token Operators\nhandle_dot([$., T1, T2, T3 | Rest], Line, Column, DotInfo, Scope, Tokens) when\n ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3);\n ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3) ->\n handle_call_identifier(Rest, Line, Column, DotInfo, 3, [T1, T2, T3], Scope, Tokens);\n\n% ## Two Token Operators\nhandle_dot([$., T1, T2 | Rest], Line, Column, DotInfo, Scope, Tokens) when\n ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2);\n ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2);\n ?type_op(T1, T2) ->\n handle_call_identifier(Rest, Line, Column, DotInfo, 2, [T1, T2], Scope, Tokens);\n\n% ## Single Token Operators\nhandle_dot([$., T | Rest], Line, Column, DotInfo, Scope, Tokens) when\n ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T);\n ?rel_op(T); ?match_op(T); ?pipe_op(T) ->\n handle_call_identifier(Rest, Line, Column, DotInfo, 1, [T], Scope, Tokens);\n\n% ## Exception for .( as it needs to be treated specially in the parser\nhandle_dot([$., $( | Rest], Line, Column, DotInfo, Scope, Tokens) ->\n TokensSoFar = add_token_with_eol({dot_call_op, DotInfo, '.'}, Tokens),\n tokenize([$( | Rest], Line, Column, Scope, TokensSoFar);\n\nhandle_dot([$., H | T] = Original, Line, Column, DotInfo, BaseScope, Tokens) when ?is_quote(H) ->\n Scope = case H == $' of\n true ->\n prepend_warning(Line, Column, \"single quotes around calls are deprecated. Use double quotes instead\", BaseScope);\n\n false ->\n BaseScope\n end,\n\n case elixir_interpolation:extract(Line, Column + 1, Scope, true, T, H) of\n {NewLine, NewColumn, [Part], Rest, _Done, InterScope} when is_list(Part) ->\n NewScope = case is_unnecessary_quote([Part], InterScope) of\n true ->\n WarnMsg = io_lib:format(\n \"found quoted call \\\"~ts\\\" but the quotes are not required. \"\n \"Calls made exclusively of Unicode letters, numbers, and underscores \"\n \"and not beginning with a number do not require quotes\",\n [Part]\n ),\n prepend_warning(Line, Column, WarnMsg, InterScope);\n\n false ->\n InterScope\n end,\n\n case unescape_tokens([Part], Line, Column, NewScope) of\n {ok, [UnescapedPart]} ->\n case unsafe_to_atom(UnescapedPart, Line, Column, NewScope) of\n {ok, Atom} ->\n Token = check_call_identifier(Line, Column, H, Atom, Rest),\n TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens),\n tokenize(Rest, NewLine, NewColumn, NewScope, [Token | TokensSoFar]);\n\n {error, Reason} ->\n error(Reason, Original, NewScope, Tokens)\n end;\n\n {error, Reason} ->\n error(Reason, Original, NewScope, Tokens)\n end;\n\n {_NewLine, _NewColumn, _Parts, Rest, _Done, NewScope} ->\n Message = \"interpolation is not allowed when calling function/macro. Found interpolation in a call starting with: \",\n error({?LOC(Line, Column), Message, [H]}, Rest, NewScope, Tokens);\n {error, Reason} ->\n interpolation_error(Reason, Original, Scope, Tokens, \" (for function name starting at line ~B)\", [Line], Line, Column, [H], [H])\n end;\n\nhandle_dot([$. | Rest], Line, Column, DotInfo, Scope, Tokens) ->\n TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens),\n tokenize(Rest, Line, Column, Scope, TokensSoFar).\n\nhandle_call_identifier(Rest, Line, Column, DotInfo, Length, UnencodedOp, Scope, Tokens) ->\n Token = check_call_identifier(Line, Column, UnencodedOp, list_to_atom(UnencodedOp), Rest),\n TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens),\n tokenize(Rest, Line, Column + Length, Scope, [Token | TokensSoFar]).\n\n% ## Ambiguous unary/binary operators tokens\n% Keywords are not ambiguous operators\nhandle_space_sensitive_tokens([Sign, $:, Space | _] = String, Line, Column, Scope, Tokens) when\n ?dual_op(Sign), ?is_space(Space) ->\n tokenize(String, Line, Column, Scope, Tokens);\n\n% But everything else, except other operators, are\nhandle_space_sensitive_tokens([Sign, NotMarker | T], Line, Column, Scope, [{identifier, _, _} = H | Tokens]) when\n ?dual_op(Sign), not(?is_space(NotMarker)),\n %% Do not match ++ or --\n NotMarker =/= Sign,\n %% Do not match +/2 or -/2\n NotMarker =/= $/,\n %% Do not match ->\n NotMarker =/= $>,\n %% Do not match +\\\\n or -\\\\n (it should be treated as if a space is there)\n NotMarker =/= $\\\\ ->\n Rest = [NotMarker | T],\n DualOpToken = {dual_op, {Line, Column, nil}, list_to_atom([Sign])},\n tokenize(Rest, Line, Column + 1, Scope, [DualOpToken, setelement(1, H, op_identifier) | Tokens]);\n\n% Handle cursor completion\nhandle_space_sensitive_tokens([], Line, Column,\n #elixir_tokenizer{cursor_completion=Cursor} = Scope,\n [{identifier, Info, Identifier} | Tokens]) when Cursor /= false ->\n tokenize([$(], Line, Column+1, Scope, [{paren_identifier, Info, Identifier} | Tokens]);\n\nhandle_space_sensitive_tokens(String, Line, Column, Scope, Tokens) ->\n tokenize(String, Line, Column, Scope, Tokens).\n\n%% Helpers\n\neol(_Line, _Column, [{',', {Line, Column, Count}} | Tokens]) ->\n [{',', {Line, Column, Count + 1}} | Tokens];\neol(_Line, _Column, [{';', {Line, Column, Count}} | Tokens]) ->\n [{';', {Line, Column, Count + 1}} | Tokens];\neol(_Line, _Column, [{eol, {Line, Column, Count}} | Tokens]) ->\n [{eol, {Line, Column, Count + 1}} | Tokens];\neol(Line, Column, Tokens) ->\n [{eol, {Line, Column, 1}} | Tokens].\n\nis_unnecessary_quote([Part], Scope) when is_list(Part) ->\n case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(Part) of\n {identifier, _, [], _, true, Special} -> not lists:member(at, Special);\n _ -> false\n end;\nis_unnecessary_quote(_Parts, _Scope) ->\n false.\n\nunsafe_to_atom(Part, Line, Column, #elixir_tokenizer{}) when\n is_binary(Part) andalso byte_size(Part) > 255;\n is_list(Part) andalso length(Part) > 255 ->\n try\n PartList = elixir_utils:characters_to_list(Part),\n {error, {?LOC(Line, Column), \"atom length must be less than system limit: \", PartList}}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, {?LOC(Line, Column), \"invalid encoding in atom: \", elixir_utils:characters_to_list(Message)}}\n end;\nunsafe_to_atom(Part, Line, Column, #elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder}) when\n is_function(StaticAtomsEncoder) ->\n EncodeResult = try\n ValueEncBin = elixir_utils:characters_to_binary(Part),\n ValueEncList = elixir_utils:characters_to_list(Part),\n {ok, ValueEncBin, ValueEncList}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, {?LOC(Line, Column), \"invalid encoding in atom: \", elixir_utils:characters_to_list(Message)}}\n end,\n\n case EncodeResult of\n {ok, Value, ValueList} ->\n case StaticAtomsEncoder(Value, [{line, Line}, {column, Column}]) of\n {ok, Term} ->\n {ok, Term};\n {error, Reason} when is_binary(Reason) ->\n {error, {?LOC(Line, Column), elixir_utils:characters_to_list(Reason) ++ \": \", ValueList}}\n end;\n EncError -> EncError\n end;\nunsafe_to_atom(Binary, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_binary(Binary) ->\n try\n {ok, binary_to_existing_atom(Binary, utf8)}\n catch\n error:badarg ->\n % Check if it's a UTF-8 issue by trying to convert to list\n try\n List = elixir_utils:characters_to_list(Binary),\n % If we get here, it's not a UTF-8 issue\n {error, {?LOC(Line, Column), \"unsafe atom does not exist: \", List}}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, {?LOC(Line, Column), \"invalid encoding in atom: \", elixir_utils:characters_to_list(Message)}}\n end\n end;\nunsafe_to_atom(Binary, Line, Column, #elixir_tokenizer{}) when is_binary(Binary) ->\n try\n {ok, binary_to_atom(Binary, utf8)}\n catch\n error:badarg ->\n % Try to convert using elixir_utils to get proper UnicodeConversionError\n try\n List = elixir_utils:characters_to_list(Binary),\n % If we get here, it's not a UTF-8 issue, so it's some other badarg\n {error, {?LOC(Line, Column), \"invalid atom: \", List}}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, {?LOC(Line, Column), \"invalid encoding in atom: \", elixir_utils:characters_to_list(Message)}}\n end\n end;\nunsafe_to_atom(List, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_list(List) ->\n try\n {ok, list_to_existing_atom(List)}\n catch\n error:badarg ->\n % Try to convert using elixir_utils to get proper UnicodeConversionError\n try\n elixir_utils:characters_to_binary(List),\n % If we get here, it's not a UTF-8 issue\n {error, {?LOC(Line, Column), \"unsafe atom does not exist: \", List}}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, {?LOC(Line, Column), \"invalid encoding in atom: \", elixir_utils:characters_to_list(Message)}}\n end\n end;\nunsafe_to_atom(List, Line, Column, #elixir_tokenizer{}) when is_list(List) ->\n try\n {ok, list_to_atom(List)}\n catch\n error:badarg ->\n % Try to convert using elixir_utils to get proper UnicodeConversionError\n try\n elixir_utils:characters_to_binary(List),\n % If we get here, it's not a UTF-8 issue, so it's some other badarg\n {error, {?LOC(Line, Column), \"invalid atom: \", List}}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, {?LOC(Line, Column), \"invalid encoding in atom: \", elixir_utils:characters_to_list(Message)}}\n end\n end.\n\ncollect_modifiers([H | T], Column, Buffer) when ?is_downcase(H) or ?is_upcase(H) or ?is_digit(H) ->\n collect_modifiers(T, Column + 1, [H | Buffer]);\n\ncollect_modifiers(Rest, Column, Buffer) ->\n {Rest, Column, lists:reverse(Buffer)}.\n\n%% Heredocs\n\nextract_heredoc_with_interpolation(Line, Column, Scope, Interpol, T, H) ->\n case extract_heredoc_header(T) of\n {ok, Headerless} ->\n %% We prepend a new line so we can transparently remove\n %% spaces later. This new line is removed by calling \"tl\"\n %% in the final heredoc body three lines below.\n case elixir_interpolation:extract(Line, Column, Scope, Interpol, [$\\n|Headerless], [H,H,H]) of\n {NewLine, NewColumn, Parts0, Rest, Done, InterScope} ->\n Indent = NewColumn - 4,\n Fun = fun(Part, Acc) -> extract_heredoc_indent(Part, Acc, Indent) end,\n {Parts1, {ShouldWarn, _}} = lists:mapfoldl(Fun, {false, Line}, Parts0),\n Parts2 = extract_heredoc_head(Parts1),\n NewScope = maybe_heredoc_warn(ShouldWarn, Column, InterScope, H),\n try\n {ok, NewLine, NewColumn, tokens_to_binary(Parts2), Rest, Done, NewScope}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, interpolation_format(Message, \" (for heredoc starting at line ~B)\", [Line], Line, Column, [H, H, H], [H, H, H])}\n end;\n\n {error, Reason} ->\n {error, interpolation_format(Reason, \" (for heredoc starting at line ~B)\", [Line], Line, Column, [H, H, H], [H, H, H])}\n end;\n\n error ->\n Message = \"heredoc allows only whitespace characters followed by a new line after opening \",\n {error, {?LOC(Line, Column + 3), io_lib:format(Message, []), [H, H, H]}}\n end.\n\nextract_heredoc_header(\"\\r\\n\" ++ Rest) ->\n {ok, Rest};\nextract_heredoc_header(\"\\n\" ++ Rest) ->\n {ok, Rest};\nextract_heredoc_header([H | T]) when ?is_horizontal_space(H) ->\n extract_heredoc_header(T);\nextract_heredoc_header(_) ->\n error.\n\nextract_heredoc_indent(Part, {Warned, Line}, Indent) when is_list(Part) ->\n extract_heredoc_indent(Part, [], Warned, Line, Indent);\nextract_heredoc_indent({_, {EndLine, _, _}, _} = Part, {Warned, _Line}, _Indent) ->\n {Part, {Warned, EndLine}}.\n\nextract_heredoc_indent([$\\n | Rest], Acc, Warned, Line, Indent) ->\n {Trimmed, ShouldWarn} = trim_space(Rest, Indent),\n Warn = if ShouldWarn, not Warned -> Line + 1; true -> Warned end,\n extract_heredoc_indent(Trimmed, [$\\n | Acc], Warn, Line + 1, Indent);\nextract_heredoc_indent([Head | Rest], Acc, Warned, Line, Indent) ->\n extract_heredoc_indent(Rest, [Head | Acc], Warned, Line, Indent);\nextract_heredoc_indent([], Acc, Warned, Line, _Indent) ->\n {lists:reverse(Acc), {Warned, Line}}.\n\ntrim_space(Rest, 0) -> {Rest, false};\ntrim_space([$\\r, $\\n | _] = Rest, _) -> {Rest, false};\ntrim_space([$\\n | _] = Rest, _) -> {Rest, false};\ntrim_space([H | T], Spaces) when ?is_horizontal_space(H) -> trim_space(T, Spaces - 1);\ntrim_space([], _Spaces) -> {[], false};\ntrim_space(Rest, _Spaces) -> {Rest, true}.\n\nmaybe_heredoc_warn(false, _Column, Scope, _Marker) ->\n Scope;\nmaybe_heredoc_warn(Line, Column, Scope, Marker) ->\n Msg = io_lib:format(\"outdented heredoc line. The contents inside the heredoc should be indented \"\n \"at the same level as the closing ~ts. The following is forbidden:~n~n\"\n \" def text do~n\"\n \" \\\"\\\"\\\"~n\"\n \" contents~n\"\n \" \\\"\\\"\\\"~n\"\n \" end~n~n\"\n \"Instead make sure the contents are indented as much as the heredoc closing:~n~n\"\n \" def text do~n\"\n \" \\\"\\\"\\\"~n\"\n \" contents~n\"\n \" \\\"\\\"\\\"~n\"\n \" end~n~n\"\n \"The current heredoc line is indented too little\", [[Marker, Marker, Marker]]),\n\n prepend_warning(Line, Column, Msg, Scope).\n\nextract_heredoc_head([[$\\n|H]|T]) -> [H|T].\n\nunescape_tokens(Tokens, Line, Column, #elixir_tokenizer{unescape=true}) ->\n case elixir_interpolation:unescape_tokens(Tokens) of\n {ok, Result} ->\n {ok, Result};\n\n {error, Message, Token} ->\n {error, {?LOC(Line, Column), Message ++ \". Syntax error after: \", Token}}\n end;\nunescape_tokens(Tokens, Line, Column, #elixir_tokenizer{unescape=false}) ->\n try\n {ok, tokens_to_binary(Tokens)}\n catch\n error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->\n {error, {?LOC(Line, Column), \"invalid encoding in tokens: \", elixir_utils:characters_to_list(Message)}}\n end.\n\ntokens_to_binary(Tokens) ->\n [if is_list(Token) -> elixir_utils:characters_to_binary(Token); true -> Token end\n || Token <- Tokens].\n\n%% Integers and floats\n%% At this point, we are at least sure the first digit is a number.\n\n%% Check if we have a point followed by a number;\ntokenize_number([$., H | T], Acc, Length, false) when ?is_digit(H) ->\n tokenize_number(T, [H, $. | Acc], Length + 2, true);\n\n%% Check if we have an underscore followed by a number;\ntokenize_number([$_, H | T], Acc, Length, Bool) when ?is_digit(H) ->\n tokenize_number(T, [H, $_ | Acc], Length + 2, Bool);\n\n%% Check if we have e- followed by numbers (valid only for floats);\ntokenize_number([E, S, H | T], Acc, Length, true)\n when (E =:= $E) or (E =:= $e), ?is_digit(H), S =:= $+ orelse S =:= $- ->\n tokenize_number(T, [H, S, E | Acc], Length + 3, true);\n\n%% Check if we have e followed by numbers (valid only for floats);\ntokenize_number([E, H | T], Acc, Length, true)\n when (E =:= $E) or (E =:= $e), ?is_digit(H) ->\n tokenize_number(T, [H, E | Acc], Length + 2, true);\n\n%% Finally just numbers.\ntokenize_number([H | T], Acc, Length, Bool) when ?is_digit(H) ->\n tokenize_number(T, [H | Acc], Length + 1, Bool);\n\n%% Cast to float...\ntokenize_number(Rest, Acc, Length, true) ->\n try\n {Number, Original} = reverse_number(Acc, [], []),\n {Rest, list_to_float(Number), Original, Length}\n catch\n error:badarg -> {error, \"invalid float number \", lists:reverse(Acc)}\n end;\n\n%% Or integer.\ntokenize_number(Rest, Acc, Length, false) ->\n {Number, Original} = reverse_number(Acc, [], []),\n {Rest, list_to_integer(Number), Original, Length}.\n\ntokenize_hex([H | T], Acc, Length) when ?is_hex(H) ->\n tokenize_hex(T, [H | Acc], Length + 1);\ntokenize_hex([$_, H | T], Acc, Length) when ?is_hex(H) ->\n tokenize_hex(T, [H, $_ | Acc], Length + 2);\ntokenize_hex(Rest, Acc, Length) ->\n {Number, Original} = reverse_number(Acc, [], []),\n {Rest, list_to_integer(Number, 16), [$0, $x | Original], Length}.\n\ntokenize_octal([H | T], Acc, Length) when ?is_octal(H) ->\n tokenize_octal(T, [H | Acc], Length + 1);\ntokenize_octal([$_, H | T], Acc, Length) when ?is_octal(H) ->\n tokenize_octal(T, [H, $_ | Acc], Length + 2);\ntokenize_octal(Rest, Acc, Length) ->\n {Number, Original} = reverse_number(Acc, [], []),\n {Rest, list_to_integer(Number, 8), [$0, $o | Original], Length}.\n\ntokenize_bin([H | T], Acc, Length) when ?is_bin(H) ->\n tokenize_bin(T, [H | Acc], Length + 1);\ntokenize_bin([$_, H | T], Acc, Length) when ?is_bin(H) ->\n tokenize_bin(T, [H, $_ | Acc], Length + 2);\ntokenize_bin(Rest, Acc, Length) ->\n {Number, Original} = reverse_number(Acc, [], []),\n {Rest, list_to_integer(Number, 2), [$0, $b | Original], Length}.\n\nreverse_number([$_ | T], Number, Original) ->\n reverse_number(T, Number, [$_ | Original]);\nreverse_number([H | T], Number, Original) ->\n reverse_number(T, [H | Number], [H | Original]);\nreverse_number([], Number, Original) ->\n {Number, Original}.\n\n%% Comments\n\nreset_eol([{eol, {Line, Column, _}} | Rest]) -> [{eol, {Line, Column, 0}} | Rest];\nreset_eol(Rest) -> Rest.\n\ntokenize_comment(\"\\r\\n\" ++ _ = Rest, Acc) ->\n {Rest, lists:reverse(Acc)};\ntokenize_comment(\"\\n\" ++ _ = Rest, Acc) ->\n {Rest, lists:reverse(Acc)};\ntokenize_comment([H | _Rest], _) when ?bidi(H) ->\n {error, H, \"invalid bidirectional formatting character in comment: \"};\ntokenize_comment([H | _Rest], _) when ?break(H) ->\n {error, H, \"invalid line break character in comment: \"};\ntokenize_comment([H | Rest], Acc) ->\n tokenize_comment(Rest, [H | Acc]);\ntokenize_comment([], Acc) ->\n {[], lists:reverse(Acc)}.\n\nerror_comment(Char, Reason, Comment, Line, Column, Scope, Tokens) ->\n Token = io_lib:format(\"\\\\u~4.16.0B\", [Char]),\n error({?LOC(Line, Column), Reason, Token}, Comment, Scope, Tokens).\n\npreserve_comments(Line, Column, Tokens, Comment, Rest, Scope) ->\n case Scope#elixir_tokenizer.preserve_comments of\n Fun when is_function(Fun) ->\n Fun(Line, Column, Tokens, Comment, Rest);\n nil ->\n ok\n end.\n\n%% Identifiers\n\ntokenize([H | T]) when ?is_upcase(H) ->\n {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []),\n {alias, lists:reverse(Acc), Rest, Length, true, Special};\ntokenize([H | T]) when ?is_downcase(H); H =:= $_ ->\n {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []),\n {identifier, lists:reverse(Acc), Rest, Length, true, Special};\ntokenize(_List) ->\n {error, empty}.\n\ntokenize_continue([$@ | T], Acc, Length, Special) ->\n tokenize_continue(T, [$@ | Acc], Length + 1, [at | lists:delete(at, Special)]);\ntokenize_continue([$! | T], Acc, Length, Special) ->\n {[$! | Acc], T, Length + 1, [punctuation | Special]};\ntokenize_continue([$? | T], Acc, Length, Special) ->\n {[$? | Acc], T, Length + 1, [punctuation | Special]};\ntokenize_continue([H | T], Acc, Length, Special) when ?is_upcase(H); ?is_downcase(H); ?is_digit(H); H =:= $_ ->\n tokenize_continue(T, [H | Acc], Length + 1, Special);\ntokenize_continue(Rest, Acc, Length, Special) ->\n {Acc, Rest, Length, Special}.\n\ntokenize_identifier(String, Line, Column, Scope, MaybeKeyword) ->\n case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(String) of\n {Kind, Acc, Rest, Length, Ascii, Special} ->\n Keyword = MaybeKeyword andalso maybe_keyword(Rest),\n\n case keyword_or_unsafe_to_atom(Keyword, Acc, Line, Column, Scope) of\n {keyword, Atom, Type} ->\n {keyword, Atom, Type, Rest, Length};\n {ok, Atom} ->\n {Kind, Acc, Atom, Rest, Length, Ascii, Special};\n {error, _Reason} = Error ->\n Error\n end;\n\n {error, {mixed_script, Wrong, {Prefix, Suffix}}} ->\n WrongColumn = Column + length(Wrong) - 1,\n case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of\n no_suggestion ->\n %% we append a pointer to more info if we aren't appending a suggestion\n MoreInfo = \"\\nSee https://hexdocs.pm/elixir/unicode-syntax.html for more information.\",\n {error, {?LOC(Line, Column), {Prefix, Suffix ++ MoreInfo}, Wrong}};\n\n {_, {Location, _, SuggestionMessage}} = _SuggestionError ->\n {error, {Location, {Prefix, Suffix ++ SuggestionMessage}, Wrong}}\n end;\n\n {error, {unexpected_token, Wrong}} ->\n WrongColumn = Column + length(Wrong) - 1,\n case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of\n no_suggestion ->\n [T | _] = lists:reverse(Wrong),\n case suggest_simpler_unexpected_token_in_error([T], Line, WrongColumn, Scope) of\n no_suggestion -> {unexpected_token, length(Wrong)};\n SuggestionError -> SuggestionError\n end;\n\n SuggestionError ->\n SuggestionError\n end;\n\n {error, empty} ->\n empty\n end.\n\n%% heuristic: try nfkc; try confusability skeleton; try calling this again w/just failed codepoint\nsuggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) ->\n NFKC = unicode:characters_to_nfkc_list(Wrong),\n case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(NFKC) of\n {error, _Reason} ->\n ConfusableSkeleton = 'Elixir.String.Tokenizer.Security':confusable_skeleton(Wrong),\n case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(ConfusableSkeleton) of\n {_, Simpler, _, _, _, _} ->\n Message = suggest_change(\"Codepoint failed identifier tokenization, but a simpler form was found.\",\n Wrong,\n \"You could write the above in a similar way that is accepted by Elixir:\",\n Simpler,\n \"See https://hexdocs.pm/elixir/unicode-syntax.html for more information.\"),\n {error, {?LOC(Line, WrongColumn), \"unexpected token: \", Message}};\n _other ->\n no_suggestion\n end;\n {_, _NFKC, _, _, _, _} ->\n Message = suggest_change(\"Elixir expects unquoted Unicode atoms, variables, and calls to use allowed codepoints and to be in NFC form.\",\n Wrong,\n \"You could write the above in a compatible format that is accepted by Elixir:\",\n NFKC,\n \"See https://hexdocs.pm/elixir/unicode-syntax.html for more information.\"),\n {error, {?LOC(Line, WrongColumn), \"unexpected token: \", Message}}\n end.\n\nsuggest_change(Intro, WrongForm, Hint, HintedForm, Ending) ->\n WrongCodepoints = list_to_codepoint_hex(WrongForm),\n HintedCodepoints = list_to_codepoint_hex(HintedForm),\n io_lib:format(\"~ts\\n\\nGot:\\n\\n \\\"~ts\\\" (code points~ts)\\n\\n\"\n \"Hint: ~ts\\n\\n \\\"~ts\\\" (code points~ts)\\n\\n~ts\",\n [Intro, WrongForm, WrongCodepoints, Hint, HintedForm, HintedCodepoints, Ending]).\n\nmaybe_keyword([]) -> true;\nmaybe_keyword([$:, $: | _]) -> true;\nmaybe_keyword([$: | _]) -> false;\nmaybe_keyword(_) -> true.\n\nlist_to_codepoint_hex(List) ->\n [io_lib:format(\" 0x~5.16.0B\", [Codepoint]) || Codepoint <- List].\n\ntokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens) ->\n if\n not Ascii or (Special /= []) ->\n Invalid = hd([C || C <- Unencoded, (C < $A) or (C > 127)]),\n Reason = {?LOC(Line, Column), invalid_character_error(\"alias (only ASCII characters, without punctuation, are allowed)\", Invalid), Unencoded},\n error(Reason, Unencoded ++ Rest, Scope, Tokens);\n\n true ->\n AliasesToken = {alias, {Line, Column, Unencoded}, Atom},\n tokenize(Rest, Line, Column + Length, Scope, [AliasesToken | Tokens])\n end.\n\n%% Check if it is a call identifier (paren | bracket | do)\n\ncheck_call_identifier(Line, Column, Info, Atom, [$( | _]) ->\n {paren_identifier, {Line, Column, Info}, Atom};\ncheck_call_identifier(Line, Column, Info, Atom, [$[ | _]) ->\n {bracket_identifier, {Line, Column, Info}, Atom};\ncheck_call_identifier(Line, Column, Info, Atom, _Rest) ->\n {identifier, {Line, Column, Info}, Atom}.\n\nadd_token_with_eol({unary_op, _, _} = Left, T) -> [Left | T];\nadd_token_with_eol(Left, [{eol, _} | T]) -> [Left | T];\nadd_token_with_eol(Left, T) -> [Left | T].\n\nprevious_was_eol([{',', {_, _, Count}} | _]) when Count > 0 -> Count;\nprevious_was_eol([{';', {_, _, Count}} | _]) when Count > 0 -> Count;\nprevious_was_eol([{eol, {_, _, Count}} | _]) when Count > 0 -> Count;\nprevious_was_eol(_) -> nil.\n\n%% Error handling\n\ninterpolation_error(Reason, Rest, Scope, Tokens, Extension, Args, Line, Column, Opening, Closing) ->\n error(interpolation_format(Reason, Extension, Args, Line, Column, Opening, Closing), Rest, Scope, Tokens).\n\ninterpolation_format({string, EndLine, EndColumn, Message, Token}, Extension, Args, Line, Column, Opening, Closing) ->\n Meta = [\n {opening_delimiter, list_to_atom(Opening)},\n {expected_delimiter, list_to_atom(Closing)},\n {line, Line},\n {column, Column},\n {end_line, EndLine},\n {end_column, EndColumn}\n ],\n {Meta, [Message, io_lib:format(Extension, Args)], Token};\ninterpolation_format({_, _, _} = Reason, _Extension, _Args, _Line, _Column, _Opening, _Closing) ->\n Reason.\n\n%% Terminators\n\nhandle_terminator(Rest, _, _, Scope, {'(', {Line, Column, _}}, [{alias, _, Alias} | Tokens]) when is_atom(Alias) ->\n Reason =\n io_lib:format(\n \"unexpected ( after alias ~ts. Function names and identifiers in Elixir \"\n \"start with lowercase characters or underscore. For example:\\n\\n\"\n \" hello_world()\\n\"\n \" _starting_with_underscore()\\n\"\n \" numb3rs_are_allowed()\\n\"\n \" may_finish_with_question_mark?()\\n\"\n \" may_finish_with_exclamation_mark!()\\n\\n\"\n \"Unexpected token: \",\n [Alias]\n ),\n\n error({?LOC(Line, Column), Reason, [\"(\"]}, atom_to_list(Alias) ++ [$( | Rest], Scope, Tokens);\nhandle_terminator(Rest, Line, Column, #elixir_tokenizer{terminators=none} = Scope, Token, Tokens) ->\n tokenize(Rest, Line, Column, Scope, [Token | Tokens]);\nhandle_terminator(Rest, Line, Column, Scope, Token, Tokens) ->\n #elixir_tokenizer{terminators=Terminators} = Scope,\n\n case check_terminator(Token, Terminators, Scope) of\n {error, Reason} ->\n error(Reason, atom_to_list(element(1, Token)) ++ Rest, Scope, Tokens);\n {ok, New} ->\n tokenize(Rest, Line, Column, New, [Token | Tokens])\n end.\n\ncheck_terminator({Start, Meta}, Terminators, Scope)\n when Start == '('; Start == '['; Start == '{'; Start == '<<' ->\n Indentation = Scope#elixir_tokenizer.indentation,\n {ok, Scope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}};\n\ncheck_terminator({Start, Meta}, Terminators, Scope) when Start == 'fn'; Start == 'do' ->\n Indentation = Scope#elixir_tokenizer.indentation,\n\n NewScope =\n case Terminators of\n %% If the do is indented equally or less than the previous do, it may be a missing end error!\n [{Start, _, PreviousIndentation} = Previous | _] when Indentation =< PreviousIndentation ->\n Scope#elixir_tokenizer{mismatch_hints=[Previous | Scope#elixir_tokenizer.mismatch_hints]};\n\n _ ->\n Scope\n end,\n\n {ok, NewScope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}};\n\ncheck_terminator({'end', {EndLine, _, _}}, [{'do', _, Indentation} | Terminators], Scope) ->\n NewScope =\n %% If the end is more indented than the do, it may be a missing do error!\n case Scope#elixir_tokenizer.indentation > Indentation of\n true ->\n Hint = {'end', EndLine, Scope#elixir_tokenizer.indentation},\n Scope#elixir_tokenizer{mismatch_hints=[Hint | Scope#elixir_tokenizer.mismatch_hints]};\n\n false ->\n Scope\n end,\n\n {ok, NewScope#elixir_tokenizer{terminators=Terminators}};\n\ncheck_terminator({End, {EndLine, EndColumn, _}}, [{Start, {StartLine, StartColumn, _}, _} | Terminators], Scope)\n when End == 'end'; End == ')'; End == ']'; End == '}'; End == '>>' ->\n case terminator(Start) of\n End ->\n {ok, Scope#elixir_tokenizer{terminators=Terminators}};\n\n ExpectedEnd ->\n Meta = [\n {line, StartLine},\n {column, StartColumn},\n {end_line, EndLine},\n {end_column, EndColumn},\n {error_type, mismatched_delimiter},\n {opening_delimiter, Start},\n {closing_delimiter, End},\n {expected_delimiter, ExpectedEnd}\n ],\n {error, {Meta, unexpected_token_or_reserved(End), [atom_to_list(End)]}}\n end;\n\ncheck_terminator({'end', {Line, Column, _}}, [], #elixir_tokenizer{mismatch_hints=Hints}) ->\n Suffix =\n case lists:keyfind('end', 1, Hints) of\n {'end', HintLine, _Indentation} ->\n io_lib:format(\"\\n~ts the \\\"end\\\" on line ~B may not have a matching \\\"do\\\" \"\n \"defined before it (based on indentation)\", [elixir_errors:prefix(hint), HintLine]);\n false ->\n \"\"\n end,\n\n {error, {?LOC(Line, Column), {\"unexpected reserved word: \", Suffix}, \"end\"}};\n\ncheck_terminator({End, {Line, Column, _}}, [], _Scope)\n when End == ')'; End == ']'; End == '}'; End == '>>' ->\n {error, {?LOC(Line, Column), \"unexpected token: \", atom_to_list(End)}};\n\ncheck_terminator(_, _, Scope) ->\n {ok, Scope}.\n\nunexpected_token_or_reserved('end') -> \"unexpected reserved word: \";\nunexpected_token_or_reserved(_) -> \"unexpected token: \".\n\nmissing_terminator_hint(Start, End, #elixir_tokenizer{mismatch_hints=Hints}) ->\n case lists:keyfind(Start, 1, Hints) of\n {Start, {HintLine, _, _}, _} ->\n io_lib:format(\"\\n~ts it looks like the \\\"~ts\\\" on line ~B does not have a matching \\\"~ts\\\"\",\n [elixir_errors:prefix(hint), Start, HintLine, End]);\n false ->\n \"\"\n end.\n\nstring_type($\") -> bin_string;\nstring_type($') -> list_string.\n\nheredoc_type($\") -> bin_heredoc;\nheredoc_type($') -> list_heredoc.\n\nsigil_terminator($() -> $);\nsigil_terminator($[) -> $];\nsigil_terminator(${) -> $};\nsigil_terminator($<) -> $>;\nsigil_terminator(O) -> O.\n\nterminator('fn') -> 'end';\nterminator('do') -> 'end';\nterminator('(') -> ')';\nterminator('[') -> ']';\nterminator('{') -> '}';\nterminator('<<') -> '>>'.\n\n%% Keywords checking\n\nkeyword_or_unsafe_to_atom(true, \"fn\", _Line, _Column, _Scope) -> {keyword, 'fn', terminator};\nkeyword_or_unsafe_to_atom(true, \"do\", _Line, _Column, _Scope) -> {keyword, 'do', terminator};\nkeyword_or_unsafe_to_atom(true, \"end\", _Line, _Column, _Scope) -> {keyword, 'end', terminator};\nkeyword_or_unsafe_to_atom(true, \"true\", _Line, _Column, _Scope) -> {keyword, 'true', token};\nkeyword_or_unsafe_to_atom(true, \"false\", _Line, _Column, _Scope) -> {keyword, 'false', token};\nkeyword_or_unsafe_to_atom(true, \"nil\", _Line, _Column, _Scope) -> {keyword, 'nil', token};\n\nkeyword_or_unsafe_to_atom(true, \"not\", _Line, _Column, _Scope) -> {keyword, 'not', unary_op};\nkeyword_or_unsafe_to_atom(true, \"and\", _Line, _Column, _Scope) -> {keyword, 'and', and_op};\nkeyword_or_unsafe_to_atom(true, \"or\", _Line, _Column, _Scope) -> {keyword, 'or', or_op};\nkeyword_or_unsafe_to_atom(true, \"when\", _Line, _Column, _Scope) -> {keyword, 'when', when_op};\nkeyword_or_unsafe_to_atom(true, \"in\", _Line, _Column, _Scope) -> {keyword, 'in', in_op};\n\nkeyword_or_unsafe_to_atom(true, \"after\", _Line, _Column, _Scope) -> {keyword, 'after', block};\nkeyword_or_unsafe_to_atom(true, \"else\", _Line, _Column, _Scope) -> {keyword, 'else', block};\nkeyword_or_unsafe_to_atom(true, \"catch\", _Line, _Column, _Scope) -> {keyword, 'catch', block};\nkeyword_or_unsafe_to_atom(true, \"rescue\", _Line, _Column, _Scope) -> {keyword, 'rescue', block};\n\nkeyword_or_unsafe_to_atom(_, Part, Line, Column, Scope) ->\n unsafe_to_atom(Part, Line, Column, Scope).\n\ntokenize_keyword(terminator, Rest, Line, Column, Atom, Length, Scope, Tokens) ->\n case tokenize_keyword_terminator(Line, Column, Atom, Tokens) of\n {ok, [Check | T]} ->\n handle_terminator(Rest, Line, Column + Length, Scope, Check, T);\n {error, Message, Token} ->\n error({?LOC(Line, Column), Message, Token}, Token ++ Rest, Scope, Tokens)\n end;\n\ntokenize_keyword(token, Rest, Line, Column, Atom, Length, Scope, Tokens) ->\n Token = {Atom, {Line, Column, nil}},\n tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]);\n\ntokenize_keyword(block, Rest, Line, Column, Atom, Length, Scope, Tokens) ->\n Token = {block_identifier, {Line, Column, nil}, Atom},\n tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]);\n\ntokenize_keyword(Kind, Rest, Line, Column, Atom, Length, Scope, Tokens) ->\n NewTokens =\n case strip_horizontal_space(Rest, Line, Column, Scope) of\n {[$/ | _], _, _} ->\n [{identifier, {Line, Column, nil}, Atom} | Tokens];\n\n _ ->\n Info = {Line, Column, previous_was_eol(Tokens)},\n\n case {Kind, Tokens} of\n {in_op, [{unary_op, NotInfo, 'not'} | T]} ->\n add_token_with_eol({in_op, NotInfo, 'not in', Info}, T);\n\n {_, _} ->\n add_token_with_eol({Kind, Info, Atom}, Tokens)\n end\n end,\n\n tokenize(Rest, Line, Column + Length, Scope, NewTokens).\n\ntokenize_sigil([$~ | T], Line, Column, Scope, Tokens) ->\n case tokenize_sigil_name(T, [], Line, Column + 1, Scope, Tokens) of\n {ok, Name, Rest, NewLine, NewColumn, NewScope, NewTokens} ->\n tokenize_sigil_contents(Rest, Name, NewLine, NewColumn, NewScope, NewTokens);\n\n {error, Message, Token} ->\n Reason = {?LOC(Line, Column), Message, Token},\n error(Reason, T, Scope, Tokens)\n end.\n\n% A one-letter sigil is ok both as upcase as well as downcase.\ntokenize_sigil_name([S | T], [], Line, Column, Scope, Tokens) when ?is_downcase(S) ->\n tokenize_lower_sigil_name(T, [S], Line, Column + 1, Scope, Tokens);\ntokenize_sigil_name([S | T], [], Line, Column, Scope, Tokens) when ?is_upcase(S) ->\n tokenize_upper_sigil_name(T, [S], Line, Column + 1, Scope, Tokens).\n\ntokenize_lower_sigil_name([S | _T] = Original, [_ | _] = NameAcc, _Line, _Column, _Scope, _Tokens) when ?is_downcase(S) ->\n SigilName = lists:reverse(NameAcc) ++ Original,\n {error, sigil_name_error(), [$~] ++ SigilName};\ntokenize_lower_sigil_name(T, NameAcc, Line, Column, Scope, Tokens) ->\n {ok, lists:reverse(NameAcc), T, Line, Column, Scope, Tokens}.\n\n% If we have an uppercase letter, we keep tokenizing the name.\n% A digit is allowed but an uppercase letter or digit must proceed it.\ntokenize_upper_sigil_name([S | T], NameAcc, Line, Column, Scope, Tokens) when ?is_upcase(S); ?is_digit(S) ->\n tokenize_upper_sigil_name(T, [S | NameAcc], Line, Column + 1, Scope, Tokens);\n% With a lowercase letter and a non-empty NameAcc we return an error.\ntokenize_upper_sigil_name([S | _T] = Original, [_ | _] = NameAcc, _Line, _Column, _Scope, _Tokens) when ?is_downcase(S) ->\n SigilName = lists:reverse(NameAcc) ++ Original,\n {error, sigil_name_error(), [$~] ++ SigilName};\n% We finished the letters, so the name is over.\ntokenize_upper_sigil_name(T, NameAcc, Line, Column, Scope, Tokens) ->\n {ok, lists:reverse(NameAcc), T, Line, Column, Scope, Tokens}.\n\nsigil_name_error() ->\n \"invalid sigil name, it should be either a one-letter lowercase letter or an \" ++\n \"uppercase letter optionally followed by uppercase letters and digits, got: \".\n\ntokenize_sigil_contents([H, H, H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens)\n when ?is_quote(H) ->\n case extract_heredoc_with_interpolation(Line, Column, Scope, ?is_downcase(S), T, H) of\n {ok, NewLine, NewColumn, Parts, Rest, Done, NewScope} ->\n Indentation = NewColumn - 4,\n add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, Done, NewScope, Tokens, Indentation, <>);\n\n {error, Reason} ->\n error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens)\n end;\n\ntokenize_sigil_contents([H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens)\n when ?is_sigil(H) ->\n case elixir_interpolation:extract(Line, Column + 1, Scope, ?is_downcase(S), T, sigil_terminator(H)) of\n {NewLine, NewColumn, Parts, Rest, Done, NewScope} ->\n Indentation = nil,\n add_sigil_token(SigilName, Line, Column, NewLine, NewColumn,\n tokens_to_binary(Parts), Rest, Done, NewScope, Tokens, Indentation, <>);\n\n {error, Reason} ->\n Sigil = [$~, S, H],\n Message = \" (for sigil ~ts starting at line ~B)\",\n interpolation_error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens, Message, [Sigil, Line], Line, Column, [H], [sigil_terminator(H)])\n end;\n\ntokenize_sigil_contents([H | _] = Original, SigilName, Line, Column, Scope, Tokens) ->\n MessageString =\n \"\\\"~ts\\\" (column ~p, code point U+~4.16.0B). The available delimiters are: \"\n \"//, ||, \\\"\\\", '', (), [], {}, <>\",\n Message = io_lib:format(MessageString, [[H], Column, H]),\n ErrorColumn = Column - 1 - length(SigilName),\n error({?LOC(Line, ErrorColumn), \"invalid sigil delimiter: \", Message}, [$~] ++ SigilName ++ Original, Scope, Tokens);\n\n% Incomplete sigil.\ntokenize_sigil_contents([], _SigilName, Line, Column, Scope, Tokens) ->\n tokenize([], Line, Column, Scope, Tokens).\n\nadd_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, Done, Scope, Tokens, Indentation, Delimiter) ->\n TokenColumn = Column - 1 - length(SigilName),\n MaybeEncoded = case SigilName of\n % Single-letter sigils present no risk of atom exhaustion (limited possibilities)\n [_Char] -> {ok, list_to_atom(\"sigil_\" ++ SigilName)};\n _ -> unsafe_to_atom(\"sigil_\" ++ SigilName, Line, TokenColumn, Scope)\n end,\n case MaybeEncoded of\n {ok, Atom} ->\n {Final, NewColumnWithModifiers, Modifiers} = case Done of\n true -> collect_modifiers(Rest, NewColumn, []);\n false -> {Rest, NewColumn, false}\n end,\n Token = {sigil, {Line, TokenColumn, {NewLine, NewColumnWithModifiers}},\n Atom, Parts, Modifiers, Indentation, Delimiter},\n tokenize(Final, NewLine, NewColumnWithModifiers, Scope, [Token | Tokens]);\n\n {error, Reason} ->\n error(Reason, Rest, Scope, Tokens)\n end.\n\n%% Fail early on invalid do syntax. For example, after\n%% most keywords, after comma and so on.\ntokenize_keyword_terminator(DoLine, DoColumn, do, [{identifier, {Line, Column, Meta}, Atom} | T]) ->\n {ok, add_token_with_eol({do, {DoLine, DoColumn, nil}},\n [{do_identifier, {Line, Column, Meta}, Atom} | T])};\ntokenize_keyword_terminator(_Line, _Column, do, [{'fn', _} | _]) ->\n {error, invalid_do_with_fn_error(\"unexpected reserved word: \"), \"do\"};\ntokenize_keyword_terminator(Line, Column, do, Tokens) ->\n case is_valid_do(Tokens) of\n true -> {ok, add_token_with_eol({do, {Line, Column, nil}}, Tokens)};\n false -> {error, invalid_do_error(\"unexpected reserved word: \"), \"do\"}\n end;\ntokenize_keyword_terminator(Line, Column, Atom, Tokens) ->\n {ok, [{Atom, {Line, Column, nil}} | Tokens]}.\n\nis_valid_do([{Atom, _} | _]) ->\n case Atom of\n ',' -> false;\n ';' -> false;\n 'not' -> false;\n 'and' -> false;\n 'or' -> false;\n 'when' -> false;\n 'in' -> false;\n 'after' -> false;\n 'else' -> false;\n 'catch' -> false;\n 'rescue' -> false;\n _ -> true\n end;\nis_valid_do(_) ->\n true.\n\ninvalid_character_error(What, Char) ->\n io_lib:format(\"invalid character \\\"~ts\\\" (code point U+~4.16.0B) in ~ts: \", [[Char], Char, What]).\n\ninvalid_do_error(Prefix) ->\n {Prefix, \". In case you wanted to write a \\\"do\\\" expression, \"\n \"you must either use do-blocks or separate the keyword argument with comma. \"\n \"For example, you should either write:\\n\\n\"\n \" if some_condition? do\\n\"\n \" :this\\n\"\n \" else\\n\"\n \" :that\\n\"\n \" end\\n\\n\"\n \"or the equivalent construct:\\n\\n\"\n \" if(some_condition?, do: :this, else: :that)\\n\\n\"\n \"where \\\"some_condition?\\\" is the first argument and the second argument is a keyword list.\\n\\n\"\n \"You may see this error if you forget a trailing comma before the \\\"do\\\" in a \\\"do\\\" block\"}.\n\ninvalid_do_with_fn_error(Prefix) ->\n {Prefix, \". Anonymous functions are written as:\\n\\n\"\n \" fn pattern -> expression end\\n\\nPlease remove the \\\"do\\\" keyword\"}.\n\n% TODO: Turn into an error on v2.0\nmaybe_warn_too_many_of_same_char([T | _] = Token, [T | _] = _Rest, Line, Column, Scope) ->\n Message = io_lib:format(\n \"found \\\"~ts\\\" followed by \\\"~ts\\\", please use a space between \\\"~ts\\\" and the next \\\"~ts\\\"\",\n [Token, [T], Token, [T]]\n ),\n prepend_warning(Line, Column, Message, Scope);\nmaybe_warn_too_many_of_same_char(_Token, _Rest, _Line, _Column, Scope) ->\n Scope.\n\n%% TODO: Turn into an error on v2.0\nmaybe_warn_for_ambiguous_bang_before_equals(Kind, Unencoded, [$= | _], Line, Column, Scope) ->\n {What, Identifier} =\n case Kind of\n atom -> {\"atom\", [$: | Unencoded]};\n identifier -> {\"identifier\", Unencoded}\n end,\n\n case lists:last(Identifier) of\n Last when Last =:= $!; Last =:= $? ->\n Msg = io_lib:format(\"found ~ts \\\"~ts\\\", ending with \\\"~ts\\\", followed by =. \"\n \"It is unclear if you mean \\\"~ts ~ts=\\\" or \\\"~ts =\\\". Please add \"\n \"a space before or after ~ts to remove the ambiguity\",\n [What, Identifier, [Last], lists:droplast(Identifier), [Last], Identifier, [Last]]),\n prepend_warning(Line, Column, Msg, Scope);\n _ ->\n Scope\n end;\nmaybe_warn_for_ambiguous_bang_before_equals(_Kind, _Atom, _Rest, _Line, _Column, Scope) ->\n Scope.\n\nprepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) ->\n Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}.\n\ntrack_ascii(true, Scope) -> Scope;\ntrack_ascii(false, Scope) -> Scope#elixir_tokenizer{ascii_identifiers_only=false}.\n\nmaybe_unicode_lint_warnings(_Ascii=false, Tokens, Warnings) ->\n 'Elixir.String.Tokenizer.Security':unicode_lint_warnings(lists:reverse(Tokens)) ++ Warnings;\nmaybe_unicode_lint_warnings(_Ascii=true, _Tokens, Warnings) ->\n Warnings.\n\nerror(Reason, Rest, #elixir_tokenizer{warnings=Warnings}, Tokens) ->\n {error, Reason, Rest, Warnings, Tokens}.\n\nformat_error({Location, {ErrorPrefix, ErrorSuffix}, Token}) ->\n {Location, {elixir_utils:characters_to_binary(ErrorPrefix), elixir_utils:characters_to_binary(ErrorSuffix)}, elixir_utils:characters_to_binary(Token)};\nformat_error({Location, Error, Token}) ->\n {Location, elixir_utils:characters_to_binary(Error), elixir_utils:characters_to_binary(Token)}.\n\n%% Cursor handling\n\nadd_cursor(_Line, Column, noprune, Tokens) ->\n {Column, Tokens};\n\nadd_cursor(Line, Column, {prune_and_cursor, true},\n [{sigil, {_, _, {Line, Column}} = Location, Name, Parts, Modifier, Identation, Delimiter} | Rest]) ->\n Cursor = {'__cursor__', [{line, Line}, {column, Column}], []},\n CursorModifier = case Modifier of\n false -> Cursor;\n List -> List ++ [Cursor]\n end,\n {Column + 12, [{sigil, Location, Name, Parts, CursorModifier, Identation, Delimiter} | Rest]};\n\nadd_cursor(Line, Column, {prune_and_cursor, _}, Tokens) ->\n PrePrunedTokens = prune_identifier(Tokens),\n PrunedTokens = prune_tokens(PrePrunedTokens, []),\n CursorTokens = [\n {')', {Line, Column + 11, nil}},\n {'(', {Line, Column + 10, nil}},\n {paren_identifier, {Line, Column, nil}, '__cursor__'}\n | PrunedTokens\n ],\n {Column + 12, CursorTokens}.\n\nprune_identifier([{identifier, _, _} | Tokens]) -> Tokens;\nprune_identifier(Tokens) -> Tokens.\n\n%%% Any terminator needs to be closed\nprune_tokens([{'end', _} | Tokens], Opener) ->\n prune_tokens(Tokens, ['end' | Opener]);\nprune_tokens([{')', _} | Tokens], Opener) ->\n prune_tokens(Tokens, [')' | Opener]);\nprune_tokens([{']', _} | Tokens], Opener) ->\n prune_tokens(Tokens, [']' | Opener]);\nprune_tokens([{'}', _} | Tokens], Opener) ->\n prune_tokens(Tokens, ['}' | Opener]);\nprune_tokens([{'>>', _} | Tokens], Opener) ->\n prune_tokens(Tokens, ['>>' | Opener]);\n%%% Close opened terminators\nprune_tokens([{'fn', _} | Tokens], ['end' | Opener]) ->\n prune_tokens(Tokens, Opener);\nprune_tokens([{'do', _} | Tokens], ['end' | Opener]) ->\n prune_tokens(Tokens, Opener);\nprune_tokens([{'(', _} | Tokens], [')' | Opener]) ->\n prune_tokens(Tokens, Opener);\nprune_tokens([{'[', _} | Tokens], [']' | Opener]) ->\n prune_tokens(Tokens, Opener);\nprune_tokens([{'{', _} | Tokens], ['}' | Opener]) ->\n prune_tokens(Tokens, Opener);\nprune_tokens([{'<<', _} | Tokens], ['>>' | Opener]) ->\n prune_tokens(Tokens, Opener);\n%%% or it is time to stop...\nprune_tokens([{';', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{'eol', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{',', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{'fn', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{'do', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{'(', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{'[', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{'{', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{'<<', _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{identifier, _, _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{block_identifier, _, _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{kw_identifier, _, _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{kw_identifier_safe, _, _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{kw_identifier_unsafe, _, _} | _] = Tokens, []) ->\n Tokens;\nprune_tokens([{OpType, _, _} | _] = Tokens, [])\n when OpType =:= comp_op; OpType =:= at_op; OpType =:= unary_op; OpType =:= and_op;\n OpType =:= or_op; OpType =:= arrow_op; OpType =:= match_op; OpType =:= in_op;\n OpType =:= in_match_op; OpType =:= type_op; OpType =:= dual_op; OpType =:= mult_op;\n OpType =:= power_op; OpType =:= concat_op; OpType =:= range_op; OpType =:= xor_op;\n OpType =:= pipe_op; OpType =:= stab_op; OpType =:= when_op; OpType =:= assoc_op;\n OpType =:= rel_op; OpType =:= ternary_op; OpType =:= capture_op; OpType =:= ellipsis_op ->\n Tokens;\n%%% or we traverse until the end.\nprune_tokens([_ | Tokens], Opener) ->\n prune_tokens(Tokens, Opener);\nprune_tokens([], _Opener) ->\n [].\n" }, { "path": "lib/elixir/src/elixir_tokenizer.hrl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n\n%% Numbers\n-define(is_hex(S), (?is_digit(S) orelse (S >= $A andalso S =< $F) orelse (S >= $a andalso S =< $f))).\n-define(is_bin(S), (S >= $0 andalso S =< $1)).\n-define(is_octal(S), (S >= $0 andalso S =< $7)).\n\n%% Digits and letters\n-define(is_digit(S), (S >= $0 andalso S =< $9)).\n-define(is_upcase(S), (S >= $A andalso S =< $Z)).\n-define(is_downcase(S), (S >= $a andalso S =< $z)).\n\n%% Others\n-define(is_quote(S), (S =:= $\" orelse S =:= $')).\n-define(is_sigil(S), (S =:= $/ orelse S =:= $< orelse S =:= $\" orelse S =:= $' orelse\n S =:= $[ orelse S =:= $( orelse S =:= ${ orelse S =:= $|)).\n-define(LOC(Line, Column), [{line, Line}, {column, Column}]).\n\n%% Spaces\n-define(is_horizontal_space(S), (S =:= $\\s orelse S =:= $\\t)).\n-define(is_vertical_space(S), (S =:= $\\r orelse S =:= $\\n)).\n-define(is_space(S), (?is_horizontal_space(S) orelse ?is_vertical_space(S))).\n\n%% Bidirectional control\n%% Retrieved from https://trojansource.codes/trojan-source.pdf\n-define(bidi(C), C =:= 16#202A;\n C =:= 16#202B;\n C =:= 16#202D;\n C =:= 16#202E;\n C =:= 16#2066;\n C =:= 16#2067;\n C =:= 16#2068;\n C =:= 16#202C;\n C =:= 16#2069).\n\n%% Unsupported newlines\n%% https://www.unicode.org/reports/tr55/\n-define(break(C), C =:= 16#000B;\n C =:= 16#000C;\n C =:= 16#0085;\n C =:= 16#2028;\n C =:= 16#2029)." }, { "path": "lib/elixir/src/elixir_utils.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n%% Convenience functions used throughout elixir source code\n%% for ast manipulation and querying.\n-module(elixir_utils).\n-export([get_line/1, get_line/2, get_file/2, generated/1,\n split_last/1, split_opts/1, noop/0, var_context/2,\n characters_to_list/1, characters_to_binary/1, relative_to_cwd/1,\n macro_name/1, returns_boolean/1, caller/4, meta_keep/1,\n read_file_type/1, read_file_type/2, read_link_type/1, read_posix_mtime_and_size/1,\n change_posix_time/2, change_universal_time/2, var_info/2,\n guard_op/2, guard_info/1, extract_splat_guards/1, extract_guards/1,\n erlang_comparison_op_to_elixir/1, erl_fa_to_elixir_fa/2]).\n-include(\"elixir.hrl\").\n-include_lib(\"kernel/include/file.hrl\").\n\nvar_info(Name, Kind) when Kind == nil; is_integer(Kind) ->\n io_lib:format(\"\\\"~ts\\\"\", [Name]);\nvar_info(Name, Kind) ->\n io_lib:format(\"\\\"~ts\\\" (context ~ts)\", [Name, elixir_aliases:inspect(Kind)]).\n\nguard_info(#elixir_ex{prematch={_, _, {bitsize, _}}}) -> \"bitstring size specifier\";\nguard_info(_) -> \"guard\".\n\nmacro_name(Macro) ->\n list_to_atom(\"MACRO-\" ++ atom_to_list(Macro)).\n\nerl_fa_to_elixir_fa(Name, Arity) ->\n case atom_to_list(Name) of\n \"MACRO-\" ++ Rest -> {list_to_atom(Rest), Arity - 1};\n _ -> {Name, Arity}\n end.\n\nguard_op('andalso', 2) ->\n true;\nguard_op('orelse', 2) ->\n true;\nguard_op(Op, Arity) ->\n try erl_internal:op_type(Op, Arity) of\n arith -> true;\n comp -> true;\n bool -> true;\n list -> false;\n send -> false\n catch\n _:_ -> false\n end.\n\nerlang_comparison_op_to_elixir('/=') -> '!=';\nerlang_comparison_op_to_elixir('=<') -> '<=';\nerlang_comparison_op_to_elixir('=:=') -> '===';\nerlang_comparison_op_to_elixir('=/=') -> '!==';\nerlang_comparison_op_to_elixir(Other) -> Other.\n\nvar_context(Meta, Kind) ->\n case lists:keyfind(counter, 1, Meta) of\n {counter, Counter} -> Counter;\n false -> Kind\n end.\n\n% Extract guards\n\nextract_guards({'when', _, [Left, Right]}) -> {Left, extract_or_guards(Right)};\nextract_guards(Else) -> {Else, []}.\n\nextract_or_guards({'when', _, [Left, Right]}) -> [Left | extract_or_guards(Right)];\nextract_or_guards(Term) -> [Term].\n\n% Extract guards when multiple left side args are allowed.\n\nextract_splat_guards([{'when', _, [_ | _] = Args}]) ->\n {Left, Right} = split_last(Args),\n {Left, extract_or_guards(Right)};\nextract_splat_guards(Else) ->\n {Else, []}.\n\n%% No-op function that can be used for stuff like preventing tail-call\n%% optimization to kick in.\nnoop() ->\n ok.\n\nsplit_last([]) -> {[], []};\nsplit_last(List) -> split_last(List, []).\nsplit_last([H], Acc) -> {lists:reverse(Acc), H};\nsplit_last([H | T], Acc) -> split_last(T, [H | Acc]).\n\n%% Useful to handle options similarly in `opts, do ... end` and `opts, do: ...`.\nsplit_opts(Args) ->\n case elixir_utils:split_last(Args) of\n {OuterCases, OuterOpts} when is_list(OuterOpts) ->\n case elixir_utils:split_last(OuterCases) of\n {InnerCases, InnerOpts} when is_list(InnerOpts) ->\n {InnerCases, InnerOpts ++ OuterOpts};\n _ ->\n {OuterCases, OuterOpts}\n end;\n _ ->\n {Args, []}\n end.\n\nread_file_type(File) ->\n read_file_type(File, []).\n\nread_file_type(File, Opts) ->\n case file:read_file_info(File, [{time, posix} | Opts]) of\n {ok, #file_info{type=Type}} -> {ok, Type};\n {error, _} = Error -> Error\n end.\n\nread_link_type(File) ->\n case file:read_link_info(File) of\n {ok, #file_info{type=Type}} -> {ok, Type};\n {error, _} = Error -> Error\n end.\n\nread_posix_mtime_and_size(File) ->\n case file:read_file_info(File, [raw, {time, posix}]) of\n {ok, #file_info{mtime=Mtime, size=Size}} -> {ok, Mtime, Size};\n {error, _} = Error -> Error\n end.\n\nchange_posix_time(Name, Time) when is_integer(Time) ->\n file:write_file_info(Name, #file_info{mtime=Time}, [raw, {time, posix}]).\n\nchange_universal_time(Name, {{Y, M, D}, {H, Min, Sec}}=Time)\n when is_integer(Y), is_integer(M), is_integer(D),\n is_integer(H), is_integer(Min), is_integer(Sec) ->\n file:write_file_info(Name, #file_info{mtime=Time}, [raw, {time, universal}]).\n\nrelative_to_cwd(Path) ->\n try elixir_config:get(relative_paths) of\n true -> 'Elixir.Path':relative_to_cwd(Path);\n false -> Path\n catch\n _:_ -> Path\n end.\n\ncharacters_to_list(Data) when is_list(Data) ->\n Data;\ncharacters_to_list(Data) ->\n case unicode:characters_to_list(Data) of\n Result when is_list(Result) -> Result;\n {error, Encoded, Rest} -> conversion_error(invalid, Encoded, Rest);\n {incomplete, Encoded, Rest} -> conversion_error(incomplete, Encoded, Rest)\n end.\n\ncharacters_to_binary(Data) when is_binary(Data) ->\n Data;\ncharacters_to_binary(Data) ->\n case unicode:characters_to_binary(Data) of\n Result when is_binary(Result) -> Result;\n {error, Encoded, Rest} -> conversion_error(invalid, Encoded, Rest);\n {incomplete, Encoded, Rest} -> conversion_error(incomplete, Encoded, Rest)\n end.\n\nconversion_error(Kind, Encoded, Rest) ->\n error('Elixir.UnicodeConversionError':exception([{encoded, Encoded}, {rest, Rest}, {kind, Kind}])).\n\n%% Returns the caller as a stacktrace entry.\ncaller(Line, File, nil, _) ->\n {elixir_compiler_0, '__FILE__', 1, stack_location(Line, File)};\ncaller(Line, File, Module, nil) ->\n {Module, '__MODULE__', 0, stack_location(Line, File)};\ncaller(Line, File, Module, {Name, Arity}) ->\n {Module, Name, Arity, stack_location(Line, File)}.\n\nstack_location(Line, File) ->\n [{file, elixir_utils:characters_to_list(elixir_utils:relative_to_cwd(File))},\n {line, Line}].\n\nget_line(Opts) when is_list(Opts) ->\n case lists:keyfind(line, 1, Opts) of\n {line, Line} when is_integer(Line) -> Line;\n _ -> 0\n end.\n\nget_line(Meta, Env) when is_list(Meta) ->\n case lists:keyfind(line, 1, Meta) of\n {line, LineOpt} when is_integer(LineOpt) -> LineOpt;\n false -> ?key(Env, line)\n end.\n\nget_file(Meta, Env) when is_list(Meta) ->\n case lists:keyfind(file, 1, Meta) of\n {file, FileOpt} when is_binary(FileOpt) -> FileOpt;\n false -> ?key(Env, file)\n end.\n\ngenerated([{generated, true} | _] = Meta) -> Meta;\ngenerated(Meta) -> [{generated, true} | Meta].\n\n%% Meta location.\n%%\n%% Macros add a file pair on location keep which we\n%% should take into account for error reporting.\n%%\n%% Returns {binary, integer} on location keep or nil.\n\nmeta_keep(Meta) ->\n case lists:keyfind(keep, 1, Meta) of\n {keep, {File, Line} = Pair} when is_binary(File), is_integer(Line) ->\n Pair;\n _ ->\n nil\n end.\n\n%% Boolean checks\n\nreturns_boolean(Bool) when is_boolean(Bool) -> true;\n\nreturns_boolean({{'.', _, [erlang, Op]}, _, [_]}) when Op == 'not' -> true;\n\nreturns_boolean({{'.', _, [erlang, Op]}, _, [_, _]}) when\n Op == 'and'; Op == 'or'; Op == 'xor';\n Op == '=='; Op == '/='; Op == '=<'; Op == '>=';\n Op == '<'; Op == '>'; Op == '=:='; Op == '=/=' -> true;\n\nreturns_boolean({{'.', _, [erlang, Op]}, _, [_, Right]}) when\n Op == 'andalso'; Op == 'orelse' ->\n returns_boolean(Right);\n\nreturns_boolean({{'.', _, [erlang, Fun]}, _, [_]}) when\n Fun == is_atom; Fun == is_binary; Fun == is_bitstring; Fun == is_boolean;\n Fun == is_float; Fun == is_function; Fun == is_integer; Fun == is_list;\n Fun == is_number; Fun == is_pid; Fun == is_port; Fun == is_reference;\n Fun == is_tuple; Fun == is_map; Fun == is_process_alive -> true;\n\nreturns_boolean({{'.', _, [erlang, Fun]}, _, [_, _]}) when\n Fun == is_map_key; Fun == is_function; Fun == is_record -> true;\n\nreturns_boolean({{'.', _, [erlang, Fun]}, _, [_, _, _]}) when\n Fun == function_exported; Fun == is_record -> true;\n\nreturns_boolean({'case', _, [_, [{do, Clauses}]]}) ->\n lists:all(fun\n ({'->', _, [_, Expr]}) -> returns_boolean(Expr)\n end, Clauses);\n\nreturns_boolean({'cond', _, [[{do, Clauses}]]}) ->\n lists:all(fun\n ({'->', _, [_, Expr]}) -> returns_boolean(Expr)\n end, Clauses);\n\nreturns_boolean({'__block__', _, Exprs}) ->\n returns_boolean(lists:last(Exprs));\n\nreturns_boolean(_) -> false.\n" }, { "path": "lib/elixir/src/iex.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n\n-module(iex).\n-export([start/0, start/2, shell/0, sync_remote/2]).\n\n%% Manual tests for changing the CLI boot.\n%%\n%% 1. In some situations, we cannot read inputs as IEx boots:\n%%\n%% $ iex -e \":io.get_line(:foo)\"\n%%\n%% 2. In some situations, connecting to a remote node via --remsh\n%% is not possible. This can be tested by starting two IEx nodes:\n%%\n%% $ iex --sname foo\n%% $ iex --sname bar --remsh foo\n%%\n%% 3. When still using --remsh, we need to guarantee the arguments\n%% are processed on the local node and not the remote one. For such,\n%% one can replace the last line above by:\n%%\n%% $ iex --sname bar --remsh foo -e 'IO.inspect node()'\n%%\n%% And verify that the local node name is printed.\n%%\n%% 4. Finally, in some other circumstances, printing messages may become\n%% borked. This can be verified with:\n%%\n%% $ iex -e \":logger.info(~c'foo~nbar', [])\"\n%%\n%% By the time those instructions have been written, all tests above pass.\n\nstart() ->\n start([], {elixir_utils, noop, []}).\n\nstart(Opts, MFA) ->\n {ok, _} = application:ensure_all_started(elixir),\n {ok, _} = application:ensure_all_started(iex),\n\n spawn(fun() ->\n case init:notify_when_started(self()) of\n started -> ok;\n _ -> init:wait_until_started()\n end,\n\n ok = io:setopts([{binary, true}, {encoding, unicode}]),\n 'Elixir.IEx.Server':run_from_shell(Opts, MFA)\n end).\n\nshell() ->\n Args = init:get_plain_arguments(),\n\n case get_remsh(Args) of\n nil ->\n start_mfa(Args, {elixir, start_cli, []});\n\n Remote ->\n Ref = make_ref(),\n\n Parent =\n spawn_link(fun() ->\n receive\n {'begin', Ref, Other} ->\n elixir:start_cli(),\n Other ! {done, Ref}\n end\n end),\n\n {remote, Remote, start_mfa(Args, {?MODULE, sync_remote, [Parent, Ref]})}\n end.\n\nsync_remote(Parent, Ref) ->\n Parent ! {'begin', Ref, self()},\n receive {done, Ref} -> ok end.\n\nstart_mfa(Args, MFA) ->\n Opts = [{dot_iex, get_dot_iex(Args)}, {on_eof, halt}],\n {?MODULE, start, [Opts, MFA]}.\n\nget_dot_iex([\"--dot-iex\", H | _]) -> elixir_utils:characters_to_binary(H);\nget_dot_iex([_ | T]) -> get_dot_iex(T);\nget_dot_iex([]) -> nil.\n\nget_remsh([\"--remsh\", H | _]) -> H;\nget_remsh([_ | T]) -> get_remsh(T);\nget_remsh([]) -> nil.\n" }, { "path": "lib/elixir/test/elixir/access_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule AccessTest do\n use ExUnit.Case, async: true\n\n doctest Access\n\n # Test nil at compilation time does not fail\n # and that @config[:foo] has proper precedence.\n @config nil\n nil = @config[:foo]\n\n @config [foo: :bar]\n :bar = @config[:foo]\n\n @mod :lists\n [1, 2, 3] = @mod.flatten([1, [2], 3])\n\n @mod -13\n -13 = @mod\n\n test \"for nil\" do\n assert nil[:foo] == nil\n assert Access.fetch(nil, :foo) == :error\n assert Access.get(nil, :foo) == nil\n\n assert_raise ArgumentError, \"could not put/update key :foo on a nil value\", fn ->\n Access.get_and_update(nil, :foo, fn nil -> {:ok, :bar} end)\n end\n end\n\n test \"for keywords\" do\n assert [foo: :bar][:foo] == :bar\n assert [foo: [bar: :baz]][:foo][:bar] == :baz\n assert [foo: [bar: :baz]][:fuu][:bar] == nil\n\n assert Access.fetch([foo: :bar], :foo) == {:ok, :bar}\n assert Access.fetch([foo: :bar], :bar) == :error\n\n msg = ~r/the Access calls for keywords expect the key to be an atom/\n\n assert_raise ArgumentError, msg, fn ->\n Access.fetch([], \"foo\")\n end\n\n assert Access.get([foo: :bar], :foo) == :bar\n assert Access.get_and_update([], :foo, fn nil -> {:ok, :baz} end) == {:ok, [foo: :baz]}\n\n assert Access.get_and_update([foo: :bar], :foo, fn :bar -> {:ok, :baz} end) ==\n {:ok, [foo: :baz]}\n\n assert Access.pop([foo: :bar], :foo) == {:bar, []}\n assert Access.pop([], :foo) == {nil, []}\n end\n\n test \"for maps\" do\n assert %{foo: :bar}[:foo] == :bar\n assert %{1 => 1}[1] == 1\n assert %{1.0 => 1.0}[1.0] == 1.0\n assert %{1 => 1}[1.0] == nil\n\n assert Access.fetch(%{foo: :bar}, :foo) == {:ok, :bar}\n assert Access.fetch(%{foo: :bar}, :bar) == :error\n\n assert Access.get(%{foo: :bar}, :foo) == :bar\n assert Access.get_and_update(%{}, :foo, fn nil -> {:ok, :baz} end) == {:ok, %{foo: :baz}}\n\n assert Access.get_and_update(%{foo: :bar}, :foo, fn :bar -> {:ok, :baz} end) ==\n {:ok, %{foo: :baz}}\n\n assert Access.pop(%{foo: :bar}, :foo) == {:bar, %{}}\n assert Access.pop(%{}, :foo) == {nil, %{}}\n end\n\n test \"for struct\" do\n defmodule Sample do\n defstruct [:name]\n end\n\n message =\n ~r\"function AccessTest.Sample.fetch/2 is undefined \\(AccessTest.Sample does not implement the Access behaviour\"\n\n assert_raise UndefinedFunctionError, message, fn ->\n Access.fetch(struct(Sample, []), :name)\n end\n\n message =\n ~r\"function AccessTest.Sample.get_and_update/3 is undefined \\(AccessTest.Sample does not implement the Access behaviour\"\n\n assert_raise UndefinedFunctionError, message, fn ->\n Access.get_and_update(struct(Sample, []), :name, fn nil -> {:ok, :baz} end)\n end\n\n message =\n ~r\"function AccessTest.Sample.pop/2 is undefined \\(AccessTest.Sample does not implement the Access behaviour\"\n\n assert_raise UndefinedFunctionError, message, fn ->\n Access.pop(struct(Sample, []), :name)\n end\n end\n\n describe \"fetch!/2\" do\n assert Access.fetch!(%{foo: :bar}, :foo) == :bar\n\n assert_raise ArgumentError,\n ~r/the Access calls for keywords expect the key to be an atom/,\n fn -> Access.fetch!([], \"foo\") end\n\n assert_raise KeyError,\n ~r/key \\\"foo\\\" not found/,\n fn -> Access.fetch!(nil, \"foo\") end\n end\n\n describe \"filter/1\" do\n @test_list [1, 2, 3, 4, 5, 6]\n\n test \"filters in get_in\" do\n assert get_in(@test_list, [Access.filter(&(&1 > 3))]) == [4, 5, 6]\n end\n\n test \"retains order in get_and_update_in\" do\n assert get_and_update_in(@test_list, [Access.filter(&(&1 == 3 || &1 == 2))], &{&1 * 2, &1}) ==\n {[4, 6], [1, 2, 3, 4, 5, 6]}\n end\n\n test \"retains order in pop_in\" do\n assert pop_in(@test_list, [Access.filter(&(&1 == 3 || &1 == 2))]) == {[2, 3], [1, 4, 5, 6]}\n end\n\n test \"chains with other access functions\" do\n mixed_map_and_list = %{foo: Enum.map(@test_list, &%{value: &1})}\n\n assert get_in(mixed_map_and_list, [:foo, Access.filter(&(&1.value <= 3)), :value]) ==\n [1, 2, 3]\n end\n end\n\n describe \"slice/1\" do\n @test_list [1, 2, 3, 4, 5, 6, 7]\n\n test \"retrieves a range from the start of the list\" do\n assert [2, 3] == get_in(@test_list, [Access.slice(1..2)])\n end\n\n test \"retrieves a range from the end of the list\" do\n assert [6, 7] == get_in(@test_list, [Access.slice(-2..-1)])\n end\n\n test \"retrieves a range from positive first and negative last\" do\n assert [2, 3, 4, 5, 6] == get_in(@test_list, [Access.slice(1..-2//1)])\n end\n\n test \"retrieves a range from negative first and positive last\" do\n assert [6, 7] == get_in(@test_list, [Access.slice(-2..7//1)])\n end\n\n test \"retrieves a range with steps\" do\n assert [1, 3] == get_in(@test_list, [Access.slice(0..2//2)])\n assert [2, 5] == get_in(@test_list, [Access.slice(1..4//3)])\n assert [2] == get_in(@test_list, [Access.slice(1..2//3)])\n assert [1, 3, 5, 7] == get_in(@test_list, [Access.slice(0..6//2)])\n end\n\n test \"pops a range from the start of the list\" do\n assert {[2, 3], [1, 4, 5, 6, 7]} == pop_in(@test_list, [Access.slice(1..2)])\n end\n\n test \"pops a range from the end of the list\" do\n assert {[6, 7], [1, 2, 3, 4, 5]} == pop_in(@test_list, [Access.slice(-2..-1)])\n end\n\n test \"pops a range from positive first and negative last\" do\n assert {[2, 3, 4, 5, 6], [1, 7]} == pop_in(@test_list, [Access.slice(1..-2//1)])\n end\n\n test \"pops a range from negative first and positive last\" do\n assert {[6, 7], [1, 2, 3, 4, 5]} == pop_in(@test_list, [Access.slice(-2..7//1)])\n end\n\n test \"pops a range with steps\" do\n assert {[1, 3, 5], [2, 4, 6, 7]} == pop_in(@test_list, [Access.slice(0..4//2)])\n assert {[2], [1, 3, 4, 5, 6, 7]} == pop_in(@test_list, [Access.slice(1..2//2)])\n assert {[1, 4], [1, 2, 5, 6, 7]} == pop_in([1, 2, 1, 4, 5, 6, 7], [Access.slice(2..3)])\n end\n\n test \"updates range from the start of the list\" do\n assert [-1, 2, 3, 4, 5, 6, 7] == update_in(@test_list, [Access.slice(0..0)], &(&1 * -1))\n\n assert [1, -2, -3, 4, 5, 6, 7] == update_in(@test_list, [Access.slice(1..2)], &(&1 * -1))\n end\n\n test \"updates range from the end of the list\" do\n assert [1, 2, 3, 4, 5, -6, -7] == update_in(@test_list, [Access.slice(-2..-1)], &(&1 * -1))\n\n assert [-1, -2, 3, 4, 5, 6, 7] == update_in(@test_list, [Access.slice(-7..-6)], &(&1 * -1))\n end\n\n test \"updates a range from positive first and negative last\" do\n assert [1, -2, -3, -4, -5, -6, 7] ==\n update_in(@test_list, [Access.slice(1..-2//1)], &(&1 * -1))\n end\n\n test \"updates a range from negative first and positive last\" do\n assert [1, 2, 3, 4, 5, -6, -7] ==\n update_in(@test_list, [Access.slice(-2..7//1)], &(&1 * -1))\n end\n\n test \"updates a range with steps\" do\n assert [-1, 2, -3, 4, -5, 6, 7] ==\n update_in(@test_list, [Access.slice(0..4//2)], &(&1 * -1))\n end\n\n test \"returns empty when the start of the range is greater than the end\" do\n assert [] == get_in(@test_list, [Access.slice(2..1//1)])\n end\n end\n\n describe \"at/1\" do\n @test_list [1, 2, 3, 4, 5, 6]\n\n test \"returns element from the end if index is negative\" do\n assert get_in(@test_list, [Access.at(-2)]) == 5\n end\n\n test \"returns nil if index is out of bounds counting from the end\" do\n assert get_in(@test_list, [Access.at(-10)]) == nil\n end\n\n test \"updates the element counting from the end if index is negative\" do\n assert get_and_update_in(@test_list, [Access.at(-2)], fn prev ->\n {prev, :foo}\n end) == {5, [1, 2, 3, 4, :foo, 6]}\n end\n\n test \"returns nil and does not update if index is out of bounds\" do\n assert get_and_update_in(@test_list, [Access.at(-10)], fn prev ->\n {prev, :foo}\n end) == {nil, [1, 2, 3, 4, 5, 6]}\n end\n end\n\n describe \"at!/1\" do\n @test_list [1, 2, 3, 4, 5, 6]\n\n test \"returns a list element when the index is within bounds, with get_in\" do\n assert get_in(@test_list, [Access.at!(5)]) == 6\n assert get_in(@test_list, [Access.at!(-6)]) == 1\n end\n\n test \"updates a list element when the index is within bounds, with get_and_update_in\" do\n assert get_and_update_in(@test_list, [Access.at!(5)], fn prev ->\n {prev, :foo}\n end) == {6, [1, 2, 3, 4, 5, :foo]}\n\n assert get_and_update_in(@test_list, [Access.at!(-6)], fn prev ->\n {prev, :foo}\n end) == {1, [:foo, 2, 3, 4, 5, 6]}\n end\n\n test \"raises OutOfBoundsError when out of bounds, with get_in\" do\n assert_raise Enum.OutOfBoundsError, fn ->\n get_in(@test_list, [Access.at!(6)])\n end\n\n assert_raise Enum.OutOfBoundsError, fn ->\n get_in(@test_list, [Access.at!(-7)])\n end\n end\n\n test \"raises OutOfBoundsError when out of bounds, with get_and_update_in\" do\n assert_raise Enum.OutOfBoundsError, fn ->\n get_and_update_in(@test_list, [Access.at!(6)], fn prev -> {prev, :foo} end)\n end\n\n assert_raise Enum.OutOfBoundsError, fn ->\n get_and_update_in(@test_list, [Access.at!(-7)], fn prev -> {prev, :foo} end)\n end\n end\n\n test \"raises when not given a list\" do\n assert_raise RuntimeError, \"Access.at!/1 expected a list, got: %{}\", fn ->\n get_in(%{}, [Access.at!(0)])\n end\n end\n\n test \"chains\" do\n input = %{list: [%{greeting: \"hi\"}]}\n assert get_in(input, [:list, Access.at!(0), :greeting]) == \"hi\"\n end\n end\n\n describe \"values/0\" do\n @test_map %{a: 1, b: 2, c: 3, d: 4}\n @test_list [a: 1, b: 2, c: 3, d: 4]\n\n test \"retrieves values in a map\" do\n assert [1, 2, 3, 4] = get_in(@test_map, [Access.values()]) |> Enum.sort()\n end\n\n test \"retrieves values in a keyword list\" do\n assert [1, 2, 3, 4] = get_in(@test_list, [Access.values()])\n end\n\n test \"gets and updates values in a map\" do\n assert {gets, %{a: 3, b: 4, c: 5, d: 6}} =\n get_and_update_in(@test_map, [Access.values()], fn n -> {n + 1, n + 2} end)\n\n assert [2, 3, 4, 5] = Enum.sort(gets)\n end\n\n test \"gets and updates values in a keyword list\" do\n assert {[2, 3, 4, 5], [a: 3, b: 4, c: 5, d: 6]} =\n get_and_update_in(@test_list, [Access.values()], fn n -> {n + 1, n + 2} end)\n end\n\n test \"pops values from a map\" do\n assert {gets, %{c: 4, d: 5}} =\n get_and_update_in(@test_map, [Access.values()], fn n ->\n if(n > 2, do: {-n, n + 1}, else: :pop)\n end)\n\n assert [-4, -3, 1, 2] = Enum.sort(gets)\n end\n\n test \"pops values from a keyword list\" do\n assert {[1, 2, -3, -4], [c: 4, d: 5]} =\n get_and_update_in(@test_list, [Access.values()], fn n ->\n if(n > 2, do: {-n, n + 1}, else: :pop)\n end)\n end\n\n test \"raises when not given a map or a keyword list\" do\n message = ~r[^Access.values/0 expected a map or a keyword list, got: .*]\n\n assert_raise RuntimeError, message, fn ->\n get_in(123, [Access.values()])\n end\n\n assert_raise RuntimeError, message, fn ->\n get_and_update_in(:some_atom, [Access.values()], fn x -> {x, x} end)\n end\n\n assert_raise RuntimeError, message, fn ->\n get_in([:a, :b, :c], [Access.values()])\n end\n\n assert_raise RuntimeError, message, fn ->\n get_in([{:a, :b, :c}, {:d, :e, :f}], [Access.values()])\n end\n\n assert_raise RuntimeError, message, fn ->\n get_in([{1, 2}, {3, 4}], [Access.values()])\n end\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/agent_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule AgentTest do\n use ExUnit.Case, async: true\n\n doctest Agent\n\n def identity(state) do\n state\n end\n\n test \"can be supervised directly\" do\n assert {:ok, _} = Supervisor.start_link([{Agent, fn -> :ok end}], strategy: :one_for_one)\n end\n\n test \"generates child_spec/1\" do\n defmodule MyAgent do\n use Agent\n end\n\n assert MyAgent.child_spec([:hello]) == %{\n id: MyAgent,\n start: {MyAgent, :start_link, [[:hello]]}\n }\n\n defmodule CustomAgent do\n use Agent, id: :id, restart: :temporary, shutdown: :infinity, start: {:foo, :bar, []}\n end\n\n assert CustomAgent.child_spec([:hello]) == %{\n id: :id,\n restart: :temporary,\n shutdown: :infinity,\n start: {:foo, :bar, []}\n }\n end\n\n test \"start_link/2 workflow with unregistered name and anonymous functions\" do\n {:ok, pid} = Agent.start_link(&Map.new/0)\n\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n assert :proc_lib.translate_initial_call(pid) == {Map, :new, 0}\n\n assert Agent.update(pid, &Map.put(&1, :hello, :world)) == :ok\n assert Agent.get(pid, &Map.get(&1, :hello), 3000) == :world\n assert Agent.get_and_update(pid, &Map.pop(&1, :hello), 3000) == :world\n assert Agent.get(pid, & &1) == %{}\n assert Agent.stop(pid) == :ok\n wait_until_dead(pid)\n end\n\n test \"start_link/2 with spawn_opt\" do\n {:ok, pid} = Agent.start_link(fn -> 0 end, spawn_opt: [priority: :high])\n assert Process.info(pid, :priority) == {:priority, :high}\n end\n\n test \"start/2 workflow with registered name and module functions\" do\n {:ok, pid} = Agent.start(Map, :new, [], name: :agent)\n assert Process.info(pid, :registered_name) == {:registered_name, :agent}\n assert :proc_lib.translate_initial_call(pid) == {Map, :new, 0}\n assert Agent.cast(:agent, Map, :put, [:hello, :world]) == :ok\n assert Agent.get(:agent, Map, :get, [:hello]) == :world\n assert Agent.get_and_update(:agent, Map, :pop, [:hello]) == :world\n assert Agent.get(:agent, AgentTest, :identity, []) == %{}\n assert Agent.stop(:agent) == :ok\n assert Process.info(pid, :registered_name) == nil\n end\n\n test \":sys.change_code/4 with mfa\" do\n {:ok, pid} = Agent.start_link(fn -> %{} end)\n :ok = :sys.suspend(pid)\n mfa = {Map, :put, [:hello, :world]}\n assert :sys.change_code(pid, __MODULE__, \"vsn\", mfa) == :ok\n :ok = :sys.resume(pid)\n assert Agent.get(pid, &Map.get(&1, :hello)) == :world\n assert Agent.stop(pid) == :ok\n end\n\n test \":sys.change_code/4 with raising mfa\" do\n {:ok, pid} = Agent.start_link(fn -> %{} end)\n :ok = :sys.suspend(pid)\n mfa = {:erlang, :error, []}\n assert match?({:error, _}, :sys.change_code(pid, __MODULE__, \"vsn\", mfa))\n :ok = :sys.resume(pid)\n assert Agent.get(pid, & &1) == %{}\n assert Agent.stop(pid) == :ok\n end\n\n defp wait_until_dead(pid) do\n if Process.alive?(pid) do\n wait_until_dead(pid)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/application_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule ApplicationTest do\n use ExUnit.Case, async: true\n\n import PathHelpers\n import ExUnit.CaptureIO\n\n @app :elixir\n\n test \"application environment\" do\n assert_raise ArgumentError, ~r/because the application was not loaded nor configured/, fn ->\n Application.fetch_env!(:unknown, :unknown)\n end\n\n assert_raise ArgumentError, ~r/because configuration at :unknown was not set/, fn ->\n Application.fetch_env!(:elixir, :unknown)\n end\n\n assert Application.get_env(:elixir, :unknown) == nil\n assert Application.get_env(:elixir, :unknown, :default) == :default\n assert Application.fetch_env(:elixir, :unknown) == :error\n\n assert Application.put_env(:elixir, :unknown, :known) == :ok\n assert Application.fetch_env(:elixir, :unknown) == {:ok, :known}\n assert Application.fetch_env!(:elixir, :unknown) == :known\n assert Application.get_env(:elixir, :unknown, :default) == :known\n assert {:unknown, :known} in Application.get_all_env(:elixir)\n\n assert Application.delete_env(:elixir, :unknown) == :ok\n assert Application.get_env(:elixir, :unknown, :default) == :default\n after\n Application.delete_env(:elixir, :unknown)\n end\n\n test \"deprecated non-atom keys\" do\n assert_deprecated(fn ->\n Application.put_env(:elixir, [:a, :b], :c)\n end)\n\n assert_deprecated(fn ->\n assert Application.get_env(:elixir, [:a, :b]) == :c\n end)\n\n assert_deprecated(fn ->\n assert Application.fetch_env!(:elixir, [:a, :b]) == :c\n end)\n after\n assert_deprecated(fn ->\n Application.delete_env(:elixir, [:a, :b])\n end)\n end\n\n defp assert_deprecated(fun) do\n assert capture_io(:stderr, fun) =~ ~r/passing non-atom as application env key is deprecated/\n end\n\n describe \"compile environment\" do\n test \"invoked at compile time\" do\n assert_raise ArgumentError, ~r/because the application was not loaded nor configured/, fn ->\n compile_env!(:unknown, :unknown)\n end\n\n assert_received {:compile_env, :unknown, [:unknown], :error}\n\n assert_raise ArgumentError, ~r/because configuration at :unknown was not set/, fn ->\n compile_env!(:elixir, :unknown)\n end\n\n assert_received {:compile_env, :elixir, [:unknown], :error}\n\n assert compile_env(:elixir, :unknown) == nil\n assert_received {:compile_env, :elixir, [:unknown], :error}\n\n assert compile_env(:elixir, :unknown, :default) == :default\n assert_received {:compile_env, :elixir, [:unknown], :error}\n\n assert Application.put_env(:elixir, :unknown, nested: [key: :value]) == :ok\n\n assert compile_env(@app, :unknown, :default) == [nested: [key: :value]]\n assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}\n assert compile_env(:elixir, :unknown, :default) == [nested: [key: :value]]\n assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}\n\n assert compile_env(:elixir, :unknown) == [nested: [key: :value]]\n assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}\n\n assert compile_env!(@app, :unknown) == [nested: [key: :value]]\n assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}\n assert compile_env!(:elixir, :unknown) == [nested: [key: :value]]\n assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}\n\n assert compile_env(:elixir, [:unknown, :nested]) == [key: :value]\n assert_received {:compile_env, :elixir, [:unknown, :nested], {:ok, [key: :value]}}\n\n assert compile_env!(:elixir, [:unknown, :nested]) == [key: :value]\n assert_received {:compile_env, :elixir, [:unknown, :nested], {:ok, [key: :value]}}\n\n assert compile_env(:elixir, [:unknown, :nested, :key]) == :value\n assert_received {:compile_env, :elixir, [:unknown, :nested, :key], {:ok, :value}}\n\n assert compile_env!(:elixir, [:unknown, :nested, :key]) == :value\n assert_received {:compile_env, :elixir, [:unknown, :nested, :key], {:ok, :value}}\n\n assert compile_env(:elixir, [:unknown, :unknown, :key], :default) == :default\n assert_received {:compile_env, :elixir, [:unknown, :unknown, :key], :error}\n\n assert compile_env(:elixir, [:unknown, :nested, :unknown], :default) == :default\n assert_received {:compile_env, :elixir, [:unknown, :nested, :unknown], :error}\n after\n Application.delete_env(:elixir, :unknown)\n end\n\n def trace({:compile_env, _, _, _} = msg, %Macro.Env{}) do\n send(self(), msg)\n :ok\n end\n\n def trace(_, _), do: :ok\n\n defp compile_env(app, key, default \\\\ nil) do\n code =\n quote do\n require Application\n Application.compile_env(unquote(app), unquote(key), unquote(default))\n end\n\n {result, _binding} = Code.eval_quoted(code, [], tracers: [__MODULE__])\n result\n end\n\n defp compile_env!(app, key) do\n code =\n quote do\n require Application\n Application.compile_env!(unquote(app), unquote(key))\n end\n\n {result, _binding} = Code.eval_quoted(code, [], tracers: [__MODULE__])\n result\n end\n end\n\n test \"loaded and started applications\" do\n started = Application.started_applications()\n assert is_list(started)\n assert {:elixir, ~c\"elixir\", _} = List.keyfind(started, :elixir, 0)\n\n started_timeout = Application.started_applications(7000)\n assert is_list(started_timeout)\n assert {:elixir, ~c\"elixir\", _} = List.keyfind(started_timeout, :elixir, 0)\n\n loaded = Application.loaded_applications()\n assert is_list(loaded)\n assert {:elixir, ~c\"elixir\", _} = List.keyfind(loaded, :elixir, 0)\n end\n\n test \"application specification\" do\n assert is_list(Application.spec(:elixir))\n assert Application.spec(:unknown) == nil\n assert Application.spec(:unknown, :description) == nil\n assert Application.spec(:elixir, :description) == ~c\"elixir\"\n\n assert_raise FunctionClauseError, fn ->\n Application.spec(:elixir, Process.get(:unknown, :unknown))\n end\n end\n\n test \"application module\" do\n assert Application.get_application(String) == :elixir\n assert Application.get_application(__MODULE__) == nil\n assert Application.get_application(__MODULE__.Unknown) == nil\n end\n\n test \"application directory\" do\n root = Path.expand(\"../../../..\", __DIR__)\n\n assert normalize_app_dir(Application.app_dir(:elixir)) ==\n normalize_app_dir(Path.join(root, \"bin/../lib/elixir\"))\n\n assert normalize_app_dir(Application.app_dir(:elixir, \"priv\")) ==\n normalize_app_dir(Path.join(root, \"bin/../lib/elixir/priv\"))\n\n assert normalize_app_dir(Application.app_dir(:elixir, [\"priv\", \"foo\"])) ==\n normalize_app_dir(Path.join(root, \"bin/../lib/elixir/priv/foo\"))\n\n assert_raise ArgumentError, fn ->\n Application.app_dir(:unknown)\n end\n end\n\n if windows?() do\n defp normalize_app_dir(path) do\n path |> String.downcase() |> Path.expand()\n end\n else\n defp normalize_app_dir(path) do\n path |> String.downcase()\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/atom_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule AtomTest do\n use ExUnit.Case, async: true\n\n doctest Atom, except: [:moduledoc]\n\n test \"to_string/1\" do\n assert \"héllo\" |> String.to_atom() |> Atom.to_string() == \"héllo\"\n end\n\n test \"to_charlist/1\" do\n assert \"héllo\" |> String.to_atom() |> Atom.to_charlist() == ~c\"héllo\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/base_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule BaseTest do\n use ExUnit.Case, async: true\n\n doctest Base\n import Base\n\n test \"encode16/1\" do\n assert \"\" == encode16(\"\")\n assert \"66\" == encode16(\"f\")\n assert \"666F\" == encode16(\"fo\")\n assert \"666F6F\" == encode16(\"foo\")\n assert \"666F6F62\" == encode16(\"foob\")\n assert \"666F6F6261\" == encode16(\"fooba\")\n assert \"666F6F626172\" == encode16(\"foobar\")\n assert \"A1B2C3D4E5F67891\" == encode16(<<161, 178, 195, 212, 229, 246, 120, 145>>)\n\n assert \"a1b2c3d4e5f67891\" ==\n encode16(<<161, 178, 195, 212, 229, 246, 120, 145>>, case: :lower)\n end\n\n test \"decode16/1\" do\n assert {:ok, \"\"} == decode16(\"\")\n assert {:ok, \"f\"} == decode16(\"66\")\n assert {:ok, \"fo\"} == decode16(\"666F\")\n assert {:ok, \"foo\"} == decode16(\"666F6F\")\n assert {:ok, \"foob\"} == decode16(\"666F6F62\")\n assert {:ok, \"fooba\"} == decode16(\"666F6F6261\")\n assert {:ok, \"foobar\"} == decode16(\"666F6F626172\")\n assert {:ok, <<161, 178, 195, 212, 229, 246, 120, 145>>} == decode16(\"A1B2C3D4E5F67891\")\n\n assert {:ok, <<161, 178, 195, 212, 229, 246, 120, 145>>} ==\n decode16(\"a1b2c3d4e5f67891\", case: :lower)\n\n assert {:ok, <<161, 178, 195, 212, 229, 246, 120, 145>>} ==\n decode16(\"a1B2c3D4e5F67891\", case: :mixed)\n end\n\n test \"decode16!/1\" do\n assert \"\" == decode16!(\"\")\n assert \"f\" == decode16!(\"66\")\n assert \"fo\" == decode16!(\"666F\")\n assert \"foo\" == decode16!(\"666F6F\")\n assert \"foob\" == decode16!(\"666F6F62\")\n assert \"fooba\" == decode16!(\"666F6F6261\")\n assert \"foobar\" == decode16!(\"666F6F626172\")\n assert <<161, 178, 195, 212, 229, 246, 120, 145>> == decode16!(\"A1B2C3D4E5F67891\")\n\n assert <<161, 178, 195, 212, 229, 246, 120, 145>> ==\n decode16!(\"a1b2c3d4e5f67891\", case: :lower)\n\n assert <<161, 178, 195, 212, 229, 246, 120, 145>> ==\n decode16!(\"a1B2c3D4e5F67891\", case: :mixed)\n end\n\n test \"decode16/1 errors on non-alphabet character\" do\n assert :error == decode16(\"66KF\")\n assert :error == decode16(\"66ff\")\n assert :error == decode16(\"66FF\", case: :lower)\n end\n\n test \"decode16!/1 errors on non-alphabet character\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\"K\\\" (byte 75)\", fn ->\n decode16!(\"66KF\")\n end\n\n assert_raise ArgumentError, \"non-alphabet character found: \\\"f\\\" (byte 102)\", fn ->\n decode16!(\"66ff\")\n end\n\n assert_raise ArgumentError, \"non-alphabet character found: \\\"F\\\" (byte 70)\", fn ->\n decode16!(\"66FF\", case: :lower)\n end\n end\n\n test \"decode16/1 errors on odd-length string\" do\n assert :error == decode16(\"666\")\n end\n\n test \"decode16!/1 errors odd-length string\" do\n assert_raise ArgumentError, ~r/string given to decode has wrong length/, fn ->\n decode16!(\"666\")\n end\n end\n\n test \"valid16?/1\" do\n assert valid16?(\"\")\n assert valid16?(\"66\")\n assert valid16?(\"666F\")\n assert valid16?(\"666F6F\")\n assert valid16?(\"666F6F62\")\n assert valid16?(\"666F6F6261\")\n assert valid16?(\"666F6F626172\")\n assert valid16?(\"A1B2C3D4E5F67891\")\n assert valid16?(\"a1b2c3d4e5f67891\", case: :lower)\n assert valid16?(\"a1B2c3D4e5F67891\", case: :mixed)\n end\n\n test \"valid16?/1 returns false on non-alphabet character\" do\n refute valid16?(\"66KF\")\n refute valid16?(\"66ff\")\n refute valid16?(\"66FF\", case: :lower)\n refute valid16?(\"66fg\", case: :mixed)\n end\n\n test \"valid16?/1 errors on odd-length string\" do\n refute valid16?(\"666\")\n end\n\n test \"encode64/1 can deal with empty strings\" do\n assert \"\" == encode64(\"\")\n end\n\n test \"encode64/1 with two pads\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\" == encode64(\"Aladdin:open sesame\")\n end\n\n test \"encode64/1 with one pad\" do\n assert \"SGVsbG8gV29ybGQ=\" == encode64(\"Hello World\")\n end\n\n test \"encode64/1 with no pad\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2Ft\" == encode64(\"Aladdin:open sesam\")\n\n assert \"MDEyMzQ1Njc4OSFAIzBeJiooKTs6PD4sLiBbXXt9\" ==\n encode64(<<\"0123456789!@#0^&*();:<>,. []{}\">>)\n end\n\n test \"encode64/1 with one pad and ignoring padding\" do\n assert \"SGVsbG8gV29ybGQ\" == encode64(\"Hello World\", padding: false)\n end\n\n test \"encode64/1 with two pads and ignoring padding\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2FtZQ\" == encode64(\"Aladdin:open sesame\", padding: false)\n end\n\n test \"encode64/1 with no pads and ignoring padding\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2Ft\" == encode64(\"Aladdin:open sesam\", padding: false)\n end\n\n test \"decode64/1 can deal with empty strings\" do\n assert {:ok, \"\"} == decode64(\"\")\n end\n\n test \"decode64!/1 can deal with empty strings\" do\n assert \"\" == decode64!(\"\")\n end\n\n test \"decode64/1 with two pads\" do\n assert {:ok, \"Aladdin:open sesame\"} == decode64(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\")\n end\n\n test \"decode64!/1 with two pads\" do\n assert \"Aladdin:open sesame\" == decode64!(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\")\n end\n\n test \"decode64/1 with one pad\" do\n assert {:ok, \"Hello World\"} == decode64(\"SGVsbG8gV29ybGQ=\")\n end\n\n test \"decode64!/1 with one pad\" do\n assert \"Hello World\" == decode64!(\"SGVsbG8gV29ybGQ=\")\n end\n\n test \"decode64/1 with no pad\" do\n assert {:ok, \"Aladdin:open sesam\"} == decode64(\"QWxhZGRpbjpvcGVuIHNlc2Ft\")\n end\n\n test \"decode64!/1 with no pad\" do\n assert \"Aladdin:open sesam\" == decode64!(\"QWxhZGRpbjpvcGVuIHNlc2Ft\")\n end\n\n test \"decode64/1 errors on non-alphabet character\" do\n assert :error == decode64(\"Zm9)\")\n end\n\n test \"decode64!/1 errors on non-alphabet character\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\")\\\" (byte 41)\", fn ->\n decode64!(\"Zm9)\")\n end\n end\n\n test \"decode64/1 errors on whitespace unless there's ignore: :whitespace\" do\n assert :error == decode64(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\")\n\n assert {:ok, \"Aladdin:open sesam\"} ==\n decode64(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\", ignore: :whitespace)\n end\n\n test \"decode64!/1 errors on whitespace unless there's ignore: :whitespace\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\"\\\\n\\\" (byte 10)\", fn ->\n decode64!(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\")\n end\n\n assert \"Aladdin:open sesam\" ==\n decode64!(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\", ignore: :whitespace)\n end\n\n test \"decode64/1 errors on incorrect padding\" do\n assert :error == decode64(\"SGVsbG8gV29ybGQ\")\n end\n\n test \"decode64!/1 errors on incorrect padding\" do\n assert_raise ArgumentError, \"incorrect padding\", fn ->\n decode64!(\"SGVsbG8gV29ybGQ\")\n end\n end\n\n test \"decode64/2 with two pads and ignoring padding\" do\n assert {:ok, \"Aladdin:open sesame\"} == decode64(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ\", padding: false)\n end\n\n test \"decode64!/2 with two pads and ignoring padding\" do\n assert \"Aladdin:open sesame\" == decode64!(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ\", padding: false)\n end\n\n test \"decode64/2 with one pad and ignoring padding\" do\n assert {:ok, \"Hello World\"} == decode64(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"decode64!/2 with one pad and ignoring padding\" do\n assert \"Hello World\" == decode64!(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"decode64/2 with no pad and ignoring padding\" do\n assert {:ok, \"Aladdin:open sesam\"} == decode64(\"QWxhZGRpbjpvcGVuIHNlc2Ft\", padding: false)\n end\n\n test \"decode64!/2 with no pad and ignoring padding\" do\n assert \"Aladdin:open sesam\" == decode64!(\"QWxhZGRpbjpvcGVuIHNlc2Ft\", padding: false)\n end\n\n test \"decode64/2 with incorrect padding and ignoring padding\" do\n assert {:ok, \"Hello World\"} == decode64(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"decode64!/2 with incorrect padding and ignoring padding\" do\n assert \"Hello World\" == decode64!(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"valid64?/1 can deal with empty strings\" do\n assert valid64?(\"\")\n end\n\n test \"valid64?/1 with two pads\" do\n assert valid64?(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\")\n end\n\n test \"valid64?/1 with one pad\" do\n assert valid64?(\"SGVsbG8gV29ybGQ=\")\n end\n\n test \"valid64?/1 with no pad\" do\n assert valid64?(\"QWxhZGRpbjpvcGVuIHNlc2Ft\")\n end\n\n test \"valid64?/1 returns false on non-alphabet character\" do\n refute valid64?(\"Zm9)\")\n end\n\n test \"valid64?/1 returns false on whitespace unless there's ignore: :whitespace\" do\n refute valid64?(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\")\n\n assert valid64?(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\", ignore: :whitespace)\n end\n\n test \"valid64?/1 returns false on incorrect padding\" do\n refute valid64?(\"SGVsbG8gV29ybGQ\")\n end\n\n test \"valid64?/2 with two pads and ignoring padding\" do\n assert valid64?(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ\", padding: false)\n end\n\n test \"valid64?/2 with one pad and ignoring padding\" do\n assert valid64?(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"valid64?/2 with no pad and ignoring padding\" do\n assert valid64?(\"QWxhZGRpbjpvcGVuIHNlc2Ft\", padding: false)\n end\n\n test \"valid64?/2 with incorrect padding and ignoring padding\" do\n assert valid64?(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"url_encode64/1 can deal with empty strings\" do\n assert \"\" == url_encode64(\"\")\n end\n\n test \"url_encode64/1 with two pads\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\" == url_encode64(\"Aladdin:open sesame\")\n end\n\n test \"url_encode64/1 with one pad\" do\n assert \"SGVsbG8gV29ybGQ=\" == url_encode64(\"Hello World\")\n end\n\n test \"url_encode64/1 with no pad\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2Ft\" == url_encode64(\"Aladdin:open sesam\")\n\n assert \"MDEyMzQ1Njc4OSFAIzBeJiooKTs6PD4sLiBbXXt9\" ==\n url_encode64(<<\"0123456789!@#0^&*();:<>,. []{}\">>)\n end\n\n test \"url_encode64/2 with two pads and ignoring padding\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2FtZQ\" == url_encode64(\"Aladdin:open sesame\", padding: false)\n end\n\n test \"url_encode64/2 with one pad and ignoring padding\" do\n assert \"SGVsbG8gV29ybGQ\" == url_encode64(\"Hello World\", padding: false)\n end\n\n test \"url_encode64/2 with no pad and ignoring padding\" do\n assert \"QWxhZGRpbjpvcGVuIHNlc2Ft\" == url_encode64(\"Aladdin:open sesam\", padding: false)\n end\n\n test \"url_encode64/1 doesn't produce URL-unsafe characters\" do\n refute \"/3/+/A==\" == url_encode64(<<255, 127, 254, 252>>)\n assert \"_3_-_A==\" == url_encode64(<<255, 127, 254, 252>>)\n end\n\n test \"url_decode64/1 can deal with empty strings\" do\n assert {:ok, \"\"} == url_decode64(\"\")\n end\n\n test \"url_decode64!/1 can deal with empty strings\" do\n assert \"\" == url_decode64!(\"\")\n end\n\n test \"url_decode64/1 with two pads\" do\n assert {:ok, \"Aladdin:open sesame\"} == url_decode64(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\")\n end\n\n test \"url_decode64!/1 with two pads\" do\n assert \"Aladdin:open sesame\" == url_decode64!(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\")\n end\n\n test \"url_decode64/1 with one pad\" do\n assert {:ok, \"Hello World\"} == url_decode64(\"SGVsbG8gV29ybGQ=\")\n end\n\n test \"url_decode64!/1 with one pad\" do\n assert \"Hello World\" == url_decode64!(\"SGVsbG8gV29ybGQ=\")\n end\n\n test \"url_decode64/1 with no pad\" do\n assert {:ok, \"Aladdin:open sesam\"} == url_decode64(\"QWxhZGRpbjpvcGVuIHNlc2Ft\")\n end\n\n test \"url_decode64!/1 with no pad\" do\n assert \"Aladdin:open sesam\" == url_decode64!(\"QWxhZGRpbjpvcGVuIHNlc2Ft\")\n end\n\n test \"url_decode64/1,2 error on whitespace unless there's ignore: :whitespace\" do\n assert :error == url_decode64(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\")\n\n assert {:ok, \"Aladdin:open sesam\"} ==\n url_decode64(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\", ignore: :whitespace)\n end\n\n test \"url_decode64!/1,2 error on whitespace unless there's ignore: :whitespace\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\"\\\\n\\\" (byte 10)\", fn ->\n url_decode64!(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\")\n end\n\n assert \"Aladdin:open sesam\" ==\n url_decode64!(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\", ignore: :whitespace)\n end\n\n test \"url_decode64/1 errors on non-alphabet character\" do\n assert :error == url_decode64(\"Zm9)\")\n end\n\n test \"url_decode64!/1 errors on non-alphabet character\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\")\\\" (byte 41)\", fn ->\n url_decode64!(\"Zm9)\")\n end\n end\n\n test \"url_decode64/1 errors on incorrect padding\" do\n assert :error == url_decode64(\"SGVsbG8gV29ybGQ\")\n end\n\n test \"url_decode64!/1 errors on incorrect padding\" do\n assert_raise ArgumentError, \"incorrect padding\", fn ->\n url_decode64!(\"SGVsbG8gV29ybGQ\")\n end\n end\n\n test \"url_decode64/2 with two pads and ignoring padding\" do\n assert {:ok, \"Aladdin:open sesame\"} ==\n url_decode64(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ\", padding: false)\n end\n\n test \"url_decode64!/2 with two pads and ignoring padding\" do\n assert \"Aladdin:open sesame\" == url_decode64!(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ\", padding: false)\n end\n\n test \"url_decode64/2 with one pad and ignoring padding\" do\n assert {:ok, \"Hello World\"} == url_decode64(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"url_decode64!/2 with one pad and ignoring padding\" do\n assert \"Hello World\" == url_decode64!(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"url_decode64/2 with no pad and ignoring padding\" do\n assert {:ok, \"Aladdin:open sesam\"} == url_decode64(\"QWxhZGRpbjpvcGVuIHNlc2Ft\", padding: false)\n end\n\n test \"url_decode64!/2 with no pad and ignoring padding\" do\n assert \"Aladdin:open sesam\" == url_decode64!(\"QWxhZGRpbjpvcGVuIHNlc2Ft\", padding: false)\n end\n\n test \"url_decode64/2 ignores incorrect padding when :padding is false\" do\n assert {:ok, \"Hello World\"} == url_decode64(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"url_decode64!/2 ignores incorrect padding when :padding is false\" do\n assert \"Hello World\" == url_decode64!(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"url_valid64?/1 can deal with empty strings\" do\n assert url_valid64?(\"\")\n end\n\n test \"url_valid64?/1 with two pads\" do\n assert url_valid64?(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ==\")\n end\n\n test \"url_valid64?/1 with one pad\" do\n assert url_valid64?(\"SGVsbG8gV29ybGQ=\")\n end\n\n test \"url_valid64?/1 with no pad\" do\n assert url_valid64?(\"QWxhZGRpbjpvcGVuIHNlc2Ft\")\n end\n\n test \"url_valid64?/1 returns false on non-alphabet character\" do\n refute url_valid64?(\"Zm9)\")\n end\n\n test \"url_valid64?/1 returns false on whitespace unless there's ignore: :whitespace\" do\n refute url_valid64?(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\")\n\n assert url_valid64?(\"\\nQWxhZGRp bjpvcGVu\\sIHNlc2Ft\\t\", ignore: :whitespace)\n end\n\n test \"url_valid64?/1 returns false on incorrect padding\" do\n refute url_valid64?(\"SGVsbG8gV29ybGQ\")\n end\n\n test \"url_valid64?/2 with two pads and ignoring padding\" do\n assert url_valid64?(\"QWxhZGRpbjpvcGVuIHNlc2FtZQ\", padding: false)\n end\n\n test \"url_valid64?/2 with one pad and ignoring padding\" do\n assert url_valid64?(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"url_valid64?/2 with no pad and ignoring padding\" do\n assert url_valid64?(\"QWxhZGRpbjpvcGVuIHNlc2Ft\", padding: false)\n end\n\n test \"url_valid64?/2 errors on incorrect padding\" do\n refute url_valid64?(\"SGVsbG8gV29ybGQ\")\n end\n\n test \"url_valid64?/2 ignores incorrect padding when :padding is false\" do\n assert url_valid64?(\"SGVsbG8gV29ybGQ\", padding: false)\n end\n\n test \"encode32/1 can deal with empty strings\" do\n assert \"\" == encode32(\"\")\n end\n\n test \"encode32/1 with one pad\" do\n assert \"MZXW6YQ=\" == encode32(\"foob\")\n end\n\n test \"encode32/1 with three pads\" do\n assert \"MZXW6===\" == encode32(\"foo\")\n end\n\n test \"encode32/1 with four pads\" do\n assert \"MZXQ====\" == encode32(\"fo\")\n end\n\n test \"encode32/1 with six pads\" do\n assert \"MZXW6YTBOI======\" == encode32(\"foobar\")\n assert \"MY======\" == encode32(\"f\")\n end\n\n test \"encode32/1 with no pads\" do\n assert \"MZXW6YTB\" == encode32(\"fooba\")\n end\n\n test \"encode32/2 with one pad and ignoring padding\" do\n assert \"MZXW6YQ\" == encode32(\"foob\", padding: false)\n end\n\n test \"encode32/2 with three pads and ignoring padding\" do\n assert \"MZXW6\" == encode32(\"foo\", padding: false)\n end\n\n test \"encode32/2 with four pads and ignoring padding\" do\n assert \"MZXQ\" == encode32(\"fo\", padding: false)\n end\n\n test \"encode32/2 with six pads and ignoring padding\" do\n assert \"MZXW6YTBOI\" == encode32(\"foobar\", padding: false)\n end\n\n test \"encode32/2 with no pads and ignoring padding\" do\n assert \"MZXW6YTB\" == encode32(\"fooba\", padding: false)\n end\n\n test \"encode32/2 with lowercase\" do\n assert \"mzxw6ytb\" == encode32(\"fooba\", case: :lower)\n end\n\n test \"decode32/1 can deal with empty strings\" do\n assert {:ok, \"\"} == decode32(\"\")\n end\n\n test \"decode32!/2 can deal with empty strings\" do\n assert \"\" == decode32!(\"\")\n end\n\n test \"decode32/1 with one pad\" do\n assert {:ok, \"foob\"} == decode32(\"MZXW6YQ=\")\n end\n\n test \"decode32!/1 with one pad\" do\n assert \"foob\" == decode32!(\"MZXW6YQ=\")\n end\n\n test \"decode32/1 with three pads\" do\n assert {:ok, \"foo\"} == decode32(\"MZXW6===\")\n end\n\n test \"decode32!/1 with three pads\" do\n assert \"foo\" == decode32!(\"MZXW6===\")\n end\n\n test \"decode32/1 with four pads\" do\n assert {:ok, \"fo\"} == decode32(\"MZXQ====\")\n end\n\n test \"decode32!/1 with four pads\" do\n assert \"fo\" == decode32!(\"MZXQ====\")\n end\n\n test \"decode32/2 with lowercase\" do\n assert {:ok, \"fo\"} == decode32(\"mzxq====\", case: :lower)\n end\n\n test \"decode32!/2 with lowercase\" do\n assert \"fo\" == decode32!(\"mzxq====\", case: :lower)\n end\n\n test \"decode32/2 with mixed case\" do\n assert {:ok, \"fo\"} == decode32(\"mZXq====\", case: :mixed)\n end\n\n test \"decode32!/2 with mixed case\" do\n assert \"fo\" == decode32!(\"mZXq====\", case: :mixed)\n end\n\n test \"decode32/1 with six pads\" do\n assert {:ok, \"foobar\"} == decode32(\"MZXW6YTBOI======\")\n assert {:ok, \"f\"} == decode32(\"MY======\")\n end\n\n test \"decode32!/1 with six pads\" do\n assert \"foobar\" == decode32!(\"MZXW6YTBOI======\")\n assert \"f\" == decode32!(\"MY======\")\n end\n\n test \"decode32/1 with no pads\" do\n assert {:ok, \"fooba\"} == decode32(\"MZXW6YTB\")\n end\n\n test \"decode32!/1 with no pads\" do\n assert \"fooba\" == decode32!(\"MZXW6YTB\")\n end\n\n test \"decode32/1,2 error on non-alphabet character\" do\n assert :error == decode32(\"MZX)6YTB\")\n assert :error == decode32(\"66ff\")\n assert :error == decode32(\"66FF\", case: :lower)\n end\n\n test \"decode32!/1,2 argument error on non-alphabet character\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\")\\\" (byte 41)\", fn ->\n decode32!(\"MZX)6YTB\")\n end\n\n assert_raise ArgumentError, \"non-alphabet character found: \\\"m\\\" (byte 109)\", fn ->\n decode32!(\"mzxw6ytboi======\")\n end\n\n assert_raise ArgumentError, \"non-alphabet character found: \\\"M\\\" (byte 77)\", fn ->\n decode32!(\"MZXW6YTBOI======\", case: :lower)\n end\n\n assert_raise ArgumentError, \"non-alphabet character found: \\\"0\\\" (byte 48)\", fn ->\n decode32!(\"0ZXW6YTB0I======\", case: :mixed)\n end\n end\n\n test \"decode32/1 errors on incorrect padding\" do\n assert :error == decode32(\"MZXW6YQ\")\n end\n\n test \"decode32!/1 errors on incorrect padding\" do\n assert_raise ArgumentError, \"incorrect padding\", fn ->\n decode32!(\"MZXW6YQ\")\n end\n end\n\n test \"decode32/2 with one pad and :padding to false\" do\n assert {:ok, \"foob\"} == decode32(\"MZXW6YQ\", padding: false)\n end\n\n test \"decode32!/2 with one pad and :padding to false\" do\n assert \"foob\" == decode32!(\"MZXW6YQ\", padding: false)\n end\n\n test \"decode32/2 with three pads and ignoring padding\" do\n assert {:ok, \"foo\"} == decode32(\"MZXW6\", padding: false)\n end\n\n test \"decode32!/2 with three pads and ignoring padding\" do\n assert \"foo\" == decode32!(\"MZXW6\", padding: false)\n end\n\n test \"decode32/2 with four pads and ignoring padding\" do\n assert {:ok, \"fo\"} == decode32(\"MZXQ\", padding: false)\n end\n\n test \"decode32!/2 with four pads and ignoring padding\" do\n assert \"fo\" == decode32!(\"MZXQ\", padding: false)\n end\n\n test \"decode32/2 with :lower case and ignoring padding\" do\n assert {:ok, \"fo\"} == decode32(\"mzxq\", case: :lower, padding: false)\n end\n\n test \"decode32!/2 with :lower case and ignoring padding\" do\n assert \"fo\" == decode32!(\"mzxq\", case: :lower, padding: false)\n end\n\n test \"decode32/2 with :mixed case and ignoring padding\" do\n assert {:ok, \"fo\"} == decode32(\"mZXq\", case: :mixed, padding: false)\n end\n\n test \"decode32!/2 with :mixed case and ignoring padding\" do\n assert \"fo\" == decode32!(\"mZXq\", case: :mixed, padding: false)\n end\n\n test \"decode32/2 with six pads and ignoring padding\" do\n assert {:ok, \"foobar\"} == decode32(\"MZXW6YTBOI\", padding: false)\n end\n\n test \"decode32!/2 with six pads and ignoring padding\" do\n assert \"foobar\" == decode32!(\"MZXW6YTBOI\", padding: false)\n end\n\n test \"decode32/2 with no pads and ignoring padding\" do\n assert {:ok, \"fooba\"} == decode32(\"MZXW6YTB\", padding: false)\n end\n\n test \"decode32!/2 with no pads and ignoring padding\" do\n assert \"fooba\" == decode32!(\"MZXW6YTB\", padding: false)\n end\n\n test \"decode32/2 ignores incorrect padding when :padding is false\" do\n assert {:ok, \"foob\"} == decode32(\"MZXW6YQ\", padding: false)\n end\n\n test \"decode32!/2 ignores incorrect padding when :padding is false\" do\n \"foob\" = decode32!(\"MZXW6YQ\", padding: false)\n end\n\n test \"valid32?/1 can deal with empty strings\" do\n assert valid32?(\"\")\n end\n\n test \"valid32?/1 with one pad\" do\n assert valid32?(\"MZXW6YQ=\")\n end\n\n test \"valid32?/1 with three pads\" do\n assert valid32?(\"MZXW6===\")\n end\n\n test \"valid32?/1 with four pads\" do\n assert valid32?(\"MZXQ====\")\n end\n\n test \"valid32?/1 with lowercase\" do\n assert valid32?(\"mzxq====\", case: :lower)\n end\n\n test \"valid32?/1 with mixed case\" do\n assert valid32?(\"mZXq====\", case: :mixed)\n end\n\n test \"valid32?/1 with six pads\" do\n assert valid32?(\"MZXW6YTBOI======\")\n end\n\n test \"valid32?/1 with no pads\" do\n assert valid32?(\"MZXW6YTB\")\n end\n\n test \"valid32?/1,2 returns false on non-alphabet character\" do\n refute valid32?(\"MZX)6YTB\")\n refute valid32?(\"66ff\")\n refute valid32?(\"66FF\", case: :lower)\n refute valid32?(\"0ZXW6YTB0I======\", case: :mixed)\n end\n\n test \"valid32?/1 returns false on incorrect padding\" do\n refute valid32?(\"MZXW6YQ\")\n end\n\n test \"valid32?/2 with one pad and :padding to false\" do\n assert valid32?(\"MZXW6YQ\", padding: false)\n end\n\n test \"valid32?/2 with three pads and ignoring padding\" do\n assert valid32?(\"MZXW6\", padding: false)\n end\n\n test \"valid32?/2 with four pads and ignoring padding\" do\n assert valid32?(\"MZXQ\", padding: false)\n end\n\n test \"valid32?/2 with :lower case and ignoring padding\" do\n assert valid32?(\"mzxq\", case: :lower, padding: false)\n end\n\n test \"valid32?/2 with :mixed case and ignoring padding\" do\n assert valid32?(\"mZXq\", case: :mixed, padding: false)\n end\n\n test \"valid32?/2 with six pads and ignoring padding\" do\n assert valid32?(\"MZXW6YTBOI\", padding: false)\n end\n\n test \"valid32?/2 with no pads and ignoring padding\" do\n assert valid32?(\"MZXW6YTB\", padding: false)\n end\n\n test \"valid32?/2 ignores incorrect padding when :padding is false\" do\n assert valid32?(\"MZXW6YQ\", padding: false)\n end\n\n test \"hex_encode32/1 can deal with empty strings\" do\n assert \"\" == hex_encode32(\"\")\n end\n\n test \"hex_encode32/1 with one pad\" do\n assert \"CPNMUOG=\" == hex_encode32(\"foob\")\n end\n\n test \"hex_encode32/1 with three pads\" do\n assert \"CPNMU===\" == hex_encode32(\"foo\")\n end\n\n test \"hex_encode32/1 with four pads\" do\n assert \"CPNG====\" == hex_encode32(\"fo\")\n end\n\n test \"hex_encode32/1 with six pads\" do\n assert \"CPNMUOJ1E8======\" == hex_encode32(\"foobar\")\n assert \"CO======\" == hex_encode32(\"f\")\n end\n\n test \"hex_encode32/1 with no pads\" do\n assert \"CPNMUOJ1\" == hex_encode32(\"fooba\")\n end\n\n test \"hex_encode32/2 with one pad and ignoring padding\" do\n assert \"CPNMUOG\" == hex_encode32(\"foob\", padding: false)\n end\n\n test \"hex_encode32/2 with three pads and ignoring padding\" do\n assert \"CPNMU\" == hex_encode32(\"foo\", padding: false)\n end\n\n test \"hex_encode32/2 with four pads and ignoring padding\" do\n assert \"CPNG\" == hex_encode32(\"fo\", padding: false)\n end\n\n test \"hex_encode32/2 with six pads and ignoring padding\" do\n assert \"CPNMUOJ1E8\" == hex_encode32(\"foobar\", padding: false)\n end\n\n test \"hex_encode32/2 with no pads and ignoring padding\" do\n assert \"CPNMUOJ1\" == hex_encode32(\"fooba\", padding: false)\n end\n\n test \"hex_encode32/2 with lowercase\" do\n assert \"cpnmuoj1\" == hex_encode32(\"fooba\", case: :lower)\n end\n\n test \"hex_decode32/1 can deal with empty strings\" do\n assert {:ok, \"\"} == hex_decode32(\"\")\n end\n\n test \"hex_decode32!/1 can deal with empty strings\" do\n assert \"\" == hex_decode32!(\"\")\n end\n\n test \"hex_decode32/1 with one pad\" do\n assert {:ok, \"foob\"} == hex_decode32(\"CPNMUOG=\")\n end\n\n test \"hex_decode32!/1 with one pad\" do\n assert \"foob\" == hex_decode32!(\"CPNMUOG=\")\n end\n\n test \"hex_decode32/1 with three pads\" do\n assert {:ok, \"foo\"} == hex_decode32(\"CPNMU===\")\n end\n\n test \"hex_decode32!/1 with three pads\" do\n assert \"foo\" == hex_decode32!(\"CPNMU===\")\n end\n\n test \"hex_decode32/1 with four pads\" do\n assert {:ok, \"fo\"} == hex_decode32(\"CPNG====\")\n end\n\n test \"hex_decode32!/1 with four pads\" do\n assert \"fo\" == hex_decode32!(\"CPNG====\")\n end\n\n test \"hex_decode32/1 with six pads\" do\n assert {:ok, \"foobar\"} == hex_decode32(\"CPNMUOJ1E8======\")\n assert {:ok, \"f\"} == hex_decode32(\"CO======\")\n end\n\n test \"hex_decode32!/1 with six pads\" do\n assert \"foobar\" == hex_decode32!(\"CPNMUOJ1E8======\")\n assert \"f\" == hex_decode32!(\"CO======\")\n end\n\n test \"hex_decode32/1 with no pads\" do\n assert {:ok, \"fooba\"} == hex_decode32(\"CPNMUOJ1\")\n end\n\n test \"hex_decode32!/1 with no pads\" do\n assert \"fooba\" == hex_decode32!(\"CPNMUOJ1\")\n end\n\n test \"hex_decode32/1,2 error on non-alphabet character\" do\n assert :error == hex_decode32(\"CPN)UOJ1\")\n assert :error == hex_decode32(\"66f\")\n assert :error == hex_decode32(\"66F\", case: :lower)\n end\n\n test \"hex_decode32!/1,2 error non-alphabet character\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\")\\\" (byte 41)\", fn ->\n hex_decode32!(\"CPN)UOJ1\")\n end\n\n assert_raise ArgumentError, \"non-alphabet character found: \\\"c\\\" (byte 99)\", fn ->\n hex_decode32!(\"cpnmuoj1e8======\")\n end\n\n assert_raise ArgumentError, \"non-alphabet character found: \\\"C\\\" (byte 67)\", fn ->\n hex_decode32!(\"CPNMUOJ1E8======\", case: :lower)\n end\n end\n\n test \"hex_decode32/1 errors on incorrect padding\" do\n assert :error == hex_decode32(\"CPNMUOG\")\n end\n\n test \"hex_decode32!/1 errors on incorrect padding\" do\n assert_raise ArgumentError, \"incorrect padding\", fn ->\n hex_decode32!(\"CPNMUOG\")\n end\n end\n\n test \"hex_decode32/2 with lowercase\" do\n assert {:ok, \"fo\"} == hex_decode32(\"cpng====\", case: :lower)\n end\n\n test \"hex_decode32!/2 with lowercase\" do\n assert \"fo\" == hex_decode32!(\"cpng====\", case: :lower)\n end\n\n test \"hex_decode32/2 with mixed case\" do\n assert {:ok, \"fo\"} == hex_decode32(\"cPNg====\", case: :mixed)\n end\n\n test \"hex_decode32!/2 with mixed case\" do\n assert \"fo\" == hex_decode32!(\"cPNg====\", case: :mixed)\n end\n\n test \"decode16!/1 errors on non-UTF-8 char\" do\n assert_raise ArgumentError, \"non-alphabet character found: \\\"\\\\0\\\" (byte 0)\", fn ->\n decode16!(\"012\" <> <<0>>)\n end\n end\n\n test \"hex_decode32/2 with one pad and ignoring padding\" do\n assert {:ok, \"foob\"} == hex_decode32(\"CPNMUOG\", padding: false)\n end\n\n test \"hex_decode32!/2 with one pad and ignoring padding\" do\n assert \"foob\" == hex_decode32!(\"CPNMUOG\", padding: false)\n end\n\n test \"hex_decode32/2 with three pads and ignoring padding\" do\n assert {:ok, \"foo\"} == hex_decode32(\"CPNMU\", padding: false)\n end\n\n test \"hex_decode32!/2 with three pads and ignoring padding\" do\n assert \"foo\" == hex_decode32!(\"CPNMU\", padding: false)\n end\n\n test \"hex_decode32/2 with four pads and ignoring padding\" do\n assert {:ok, \"fo\"} == hex_decode32(\"CPNG\", padding: false)\n end\n\n test \"hex_decode32!/2 with four pads and ignoring padding\" do\n assert \"fo\" == hex_decode32!(\"CPNG\", padding: false)\n end\n\n test \"hex_decode32/2 with six pads and ignoring padding\" do\n assert {:ok, \"foobar\"} == hex_decode32(\"CPNMUOJ1E8\", padding: false)\n end\n\n test \"hex_decode32!/2 with six pads and ignoring padding\" do\n assert \"foobar\" == hex_decode32!(\"CPNMUOJ1E8\", padding: false)\n end\n\n test \"hex_decode32/2 with no pads and ignoring padding\" do\n assert {:ok, \"fooba\"} == hex_decode32(\"CPNMUOJ1\", padding: false)\n end\n\n test \"hex_decode32!/2 with no pads and ignoring padding\" do\n assert \"fooba\" == hex_decode32!(\"CPNMUOJ1\", padding: false)\n end\n\n test \"hex_decode32/2 ignores incorrect padding when :padding is false\" do\n assert {:ok, \"foob\"} == hex_decode32(\"CPNMUOG\", padding: false)\n end\n\n test \"hex_decode32!/2 ignores incorrect padding when :padding is false\" do\n \"foob\" = hex_decode32!(\"CPNMUOG\", padding: false)\n end\n\n test \"hex_decode32/2 with :lower case and ignoring padding\" do\n assert {:ok, \"fo\"} == hex_decode32(\"cpng\", case: :lower, padding: false)\n end\n\n test \"hex_decode32!/2 with :lower case and ignoring padding\" do\n assert \"fo\" == hex_decode32!(\"cpng\", case: :lower, padding: false)\n end\n\n test \"hex_decode32/2 with :mixed case and ignoring padding\" do\n assert {:ok, \"fo\"} == hex_decode32(\"cPNg====\", case: :mixed, padding: false)\n end\n\n test \"hex_decode32!/2 with :mixed case and ignoring padding\" do\n assert \"fo\" == hex_decode32!(\"cPNg\", case: :mixed, padding: false)\n end\n\n test \"hex_valid32?/1 can deal with empty strings\" do\n assert hex_valid32?(\"\")\n end\n\n test \"hex_valid32?/1 with one pad\" do\n assert hex_valid32?(\"CPNMUOG=\")\n end\n\n test \"hex_valid32?/1 with three pads\" do\n assert hex_valid32?(\"CPNMU===\")\n end\n\n test \"hex_valid32?/1 with four pads\" do\n assert hex_valid32?(\"CPNG====\")\n end\n\n test \"hex_valid32?/1 with six pads\" do\n assert hex_valid32?(\"CPNMUOJ1E8======\")\n assert hex_valid32?(\"CO======\")\n end\n\n test \"hex_valid32?/1 with no pads\" do\n assert hex_valid32?(\"CPNMUOJ1\")\n end\n\n test \"hex_valid32?/1,2 returns false on non-alphabet character\" do\n refute hex_valid32?(\"CPN)UOJ1\")\n refute hex_valid32?(\"66f\")\n refute hex_valid32?(\"66F\", case: :lower)\n end\n\n test \"hex_valid32?/1 returns false on incorrect padding\" do\n refute hex_valid32?(\"CPNMUOG\")\n end\n\n test \"hex_valid32?/2 with lowercase\" do\n assert hex_valid32?(\"cpng====\", case: :lower)\n end\n\n test \"hex_valid32?/2 with mixed case\" do\n assert hex_valid32?(\"cPNg====\", case: :mixed)\n end\n\n test \"hex_valid32?/2 with one pad and ignoring padding\" do\n assert hex_valid32?(\"CPNMUOG\", padding: false)\n end\n\n test \"hex_valid32?/2 with three pads and ignoring padding\" do\n assert hex_valid32?(\"CPNMU\", padding: false)\n end\n\n test \"hex_valid32?/2 with four pads and ignoring padding\" do\n assert hex_valid32?(\"CPNG\", padding: false)\n end\n\n test \"hex_valid32?/2 with six pads and ignoring padding\" do\n assert hex_valid32?(\"CPNMUOJ1E8\", padding: false)\n end\n\n test \"hex_valid32?/2 with no pads and ignoring padding\" do\n assert hex_valid32?(\"CPNMUOJ1\", padding: false)\n end\n\n test \"hex_valid32?/2 ignores incorrect padding when :padding is false\" do\n assert hex_valid32?(\"CPNMUOG\", padding: false)\n end\n\n test \"hex_valid32?/2 with :lower case and ignoring padding\" do\n assert hex_valid32?(\"cpng\", case: :lower, padding: false)\n end\n\n test \"hex_valid32?/2 with :mixed case and ignoring padding\" do\n assert hex_valid32?(\"cPNg====\", case: :mixed, padding: false)\n end\n\n # TODO: add valid? tests\n test \"encode then decode is identity\" do\n for {encode, decode, valid?} <- [\n {&encode16/2, &decode16!/2, &valid16?/2},\n {&encode32/2, &decode32!/2, &valid32?/2},\n {&hex_encode32/2, &hex_decode32!/2, &hex_valid32?/2},\n {&encode64/2, &decode64!/2, &valid64?/2},\n {&url_encode64/2, &url_decode64!/2, &url_valid64?/2}\n ],\n encode_case <- [:upper, :lower],\n decode_case <- [:upper, :lower, :mixed],\n encode_case == decode_case or decode_case == :mixed,\n pad? <- [true, false],\n len <- 0..256 do\n data =\n 0\n |> :lists.seq(len - 1)\n |> Enum.shuffle()\n |> IO.iodata_to_binary()\n\n allowed_opts =\n encode\n |> Function.info()\n |> Keyword.fetch!(:name)\n |> case do\n :encode16 -> [:case]\n :encode64 -> [:padding]\n :url_encode64 -> [:padding]\n _ -> [:case, :padding]\n end\n\n encoded = encode.(data, Keyword.take([case: encode_case, padding: pad?], allowed_opts))\n\n decode_opts = Keyword.take([case: decode_case, padding: pad?], allowed_opts)\n assert valid?.(encoded, decode_opts)\n expected = decode.(encoded, decode_opts)\n\n assert data == expected,\n \"identity did not match for #{inspect(data)} when #{inspect(encode)} (#{encode_case})\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/bitwise_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule BitwiseTest do\n use ExUnit.Case, async: true\n\n import Bitwise\n doctest Bitwise\n\n test \"bnot/1\" do\n assert bnot(1) == -2\n end\n\n test \"band/2\" do\n assert band(1, 1) == 1\n end\n\n test \"bor/2\" do\n assert bor(0, 1) == 1\n end\n\n test \"bxor/2\" do\n assert bxor(1, 1) == 0\n end\n\n test \"bsl/2\" do\n assert bsl(1, 1) == 2\n end\n\n test \"bsr/2\" do\n assert bsr(1, 1) == 0\n end\n\n test \"band (&&&)\" do\n assert (1 &&& 1) == 1\n end\n\n test \"bor (|||)\" do\n assert (0 ||| 1) == 1\n end\n\n test \"bsl (<<<)\" do\n assert 1 <<< 1 == 2\n end\n\n test \"bsr (>>>)\" do\n assert 1 >>> 1 == 0\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/date_range_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\nCode.require_file(\"holocene.exs\", __DIR__)\n\ndefmodule Date.RangeTest do\n use ExUnit.Case, async: true\n\n @asc_range Date.range(~D[2000-01-01], ~D[2001-01-01])\n @asc_range_2 Date.range(~D[2000-01-01], ~D[2001-01-01], 2)\n @desc_range Date.range(~D[2001-01-01], ~D[2000-01-01], -1)\n @desc_range_2 Date.range(~D[2001-01-01], ~D[2000-01-01], -2)\n @empty_range Date.range(~D[2001-01-01], ~D[2000-01-01], 1)\n\n describe \"Enum.member?/2\" do\n test \"for ascending range\" do\n assert Enum.member?(@asc_range, ~D[2000-02-22])\n assert Enum.member?(@asc_range, ~D[2000-01-01])\n assert Enum.member?(@asc_range, ~D[2001-01-01])\n refute Enum.member?(@asc_range, ~D[2002-01-01])\n refute Enum.member?(@asc_range, Calendar.Holocene.date(12000, 1, 1))\n\n assert Enum.member?(@asc_range_2, ~D[2000-01-03])\n refute Enum.member?(@asc_range_2, ~D[2000-01-02])\n end\n\n test \"for descending range\" do\n assert Enum.member?(@desc_range, ~D[2000-02-22])\n assert Enum.member?(@desc_range, ~D[2000-01-01])\n assert Enum.member?(@desc_range, ~D[2001-01-01])\n refute Enum.member?(@desc_range, ~D[1999-01-01])\n refute Enum.member?(@desc_range, Calendar.Holocene.date(12000, 1, 1))\n\n assert Enum.member?(@desc_range_2, ~D[2000-12-30])\n refute Enum.member?(@desc_range_2, ~D[2000-12-29])\n end\n\n test \"empty range\" do\n refute Enum.member?(@empty_range, @empty_range.first)\n end\n end\n\n describe \"Enum.count/1\" do\n test \"for ascending range\" do\n assert Enum.count(@asc_range) == 367\n assert Enum.count(@asc_range_2) == 184\n end\n\n test \"for descending range\" do\n assert Enum.count(@desc_range) == 367\n assert Enum.count(@desc_range_2) == 184\n end\n\n test \"for empty range\" do\n assert Enum.count(@empty_range) == 0\n end\n end\n\n describe \"Enum.slice/3\" do\n test \"for ascending range\" do\n assert Enum.slice(@asc_range, 3, 3) == [~D[2000-01-04], ~D[2000-01-05], ~D[2000-01-06]]\n assert Enum.slice(@asc_range, -3, 3) == [~D[2000-12-30], ~D[2000-12-31], ~D[2001-01-01]]\n\n assert Enum.slice(@asc_range_2, 3, 3) == [~D[2000-01-07], ~D[2000-01-09], ~D[2000-01-11]]\n assert Enum.slice(@asc_range_2, -3, 3) == [~D[2000-12-28], ~D[2000-12-30], ~D[2001-01-01]]\n end\n\n test \"for descending range\" do\n assert Enum.slice(@desc_range, 3, 3) == [~D[2000-12-29], ~D[2000-12-28], ~D[2000-12-27]]\n assert Enum.slice(@desc_range, -3, 3) == [~D[2000-01-03], ~D[2000-01-02], ~D[2000-01-01]]\n\n assert Enum.slice(@desc_range_2, 3, 3) == [~D[2000-12-26], ~D[2000-12-24], ~D[2000-12-22]]\n assert Enum.slice(@desc_range_2, -3, 3) == [~D[2000-01-05], ~D[2000-01-03], ~D[2000-01-01]]\n end\n\n test \"for empty range\" do\n assert Enum.slice(@empty_range, 1, 3) == []\n assert Enum.slice(@empty_range, 3, 3) == []\n assert Enum.slice(@empty_range, -1, 3) == []\n assert Enum.slice(@empty_range, -3, 3) == []\n end\n end\n\n describe \"Enum.reduce/3\" do\n test \"for ascending range\" do\n assert Enum.take(@asc_range, 3) == [~D[2000-01-01], ~D[2000-01-02], ~D[2000-01-03]]\n\n assert Enum.take(@asc_range_2, 3) == [~D[2000-01-01], ~D[2000-01-03], ~D[2000-01-05]]\n end\n\n test \"for descending range\" do\n assert Enum.take(@desc_range, 3) == [~D[2001-01-01], ~D[2000-12-31], ~D[2000-12-30]]\n\n assert Enum.take(@desc_range_2, 3) == [~D[2001-01-01], ~D[2000-12-30], ~D[2000-12-28]]\n end\n\n test \"for empty range\" do\n assert Enum.take(@empty_range, 3) == []\n end\n end\n\n test \"Enum.take/1 for empty range with negative step\" do\n assert Enum.take(@empty_range, -1) == []\n end\n\n test \"works with date-like structs\" do\n range = Date.range(~N[2000-01-01 09:00:00], ~U[2000-01-02 09:00:00Z])\n assert range.first == ~D[2000-01-01]\n assert range.last == ~D[2000-01-02]\n assert Enum.to_list(range) == [~D[2000-01-01], ~D[2000-01-02]]\n\n range = Date.range(~N[2000-01-01 09:00:00], ~U[2000-01-03 09:00:00Z], 2)\n assert range.first == ~D[2000-01-01]\n assert range.last == ~D[2000-01-03]\n assert Enum.to_list(range) == [~D[2000-01-01], ~D[2000-01-03]]\n end\n\n test \"both dates must have matching calendars\" do\n first = ~D[2000-01-01]\n last = Calendar.Holocene.date(12001, 1, 1)\n\n assert_raise ArgumentError, \"both dates must have matching calendars\", fn ->\n Date.range(first, last)\n end\n end\n\n test \"accepts equal but non Calendar.ISO calendars\" do\n first = Calendar.Holocene.date(12000, 1, 1)\n last = Calendar.Holocene.date(12001, 1, 1)\n range = Date.range(first, last)\n assert range\n assert first in range\n assert last in range\n assert Enum.count(range) == 367\n end\n\n test \"step is a non-zero integer\" do\n step = 1.0\n message = ~r\"the step must be a non-zero integer\"\n\n assert_raise ArgumentError, message, fn ->\n Date.range(~D[2000-01-01], ~D[2000-01-31], step)\n end\n\n step = 0\n message = ~r\"the step must be a non-zero integer\"\n\n assert_raise ArgumentError, message, fn ->\n Date.range(~D[2000-01-01], ~D[2000-01-31], step)\n end\n end\n\n describe \"old date ranges\" do\n test \"enumerable\" do\n asc = %{\n __struct__: Date.Range,\n first: ~D[2021-07-14],\n first_in_iso_days: 738_350,\n last: ~D[2021-07-17],\n last_in_iso_days: 738_353\n }\n\n desc = %{\n __struct__: Date.Range,\n first: ~D[2021-07-17],\n first_in_iso_days: 738_353,\n last: ~D[2021-07-14],\n last_in_iso_days: 738_350\n }\n\n # member? implementations tests also empty?\n assert Enumerable.member?(asc, ~D[2021-07-15])\n assert {:ok, 4, _} = Enumerable.slice(asc)\n\n assert Enum.reduce(asc, [], fn x, acc -> [x | acc] end) == [\n ~D[2021-07-17],\n ~D[2021-07-16],\n ~D[2021-07-15],\n ~D[2021-07-14]\n ]\n\n assert Enum.count(asc) == 4\n\n # member? implementations tests also empty?\n assert Enumerable.member?(desc, ~D[2021-07-15])\n assert {:ok, 4, _} = Enumerable.slice(desc)\n\n assert Enum.reduce(desc, [], fn x, acc -> [x | acc] end) == [\n ~D[2021-07-14],\n ~D[2021-07-15],\n ~D[2021-07-16],\n ~D[2021-07-17]\n ]\n\n assert Enum.count(desc) == 4\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/date_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\nCode.require_file(\"holocene.exs\", __DIR__)\nCode.require_file(\"fakes.exs\", __DIR__)\n\ndefmodule DateTest do\n use ExUnit.Case, async: true\n doctest Date\n\n test \"sigil_D\" do\n assert ~D[2000-01-01] ==\n %Date{calendar: Calendar.ISO, year: 2000, month: 1, day: 1}\n\n assert ~D[20001-01-01 Calendar.Holocene] ==\n %Date{calendar: Calendar.Holocene, year: 20001, month: 1, day: 1}\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2000-50-50\" as Date for Calendar.ISO, reason: :invalid_date/,\n fn -> Code.eval_string(\"~D[2000-50-50]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2000-04-15 notalias\" as Date for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(\"~D[2000-04-15 notalias]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"20010415\" as Date for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(~s{~D[20010415]}) end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"20001-50-50\" as Date for Calendar.Holocene, reason: :invalid_date/,\n fn -> Code.eval_string(\"~D[20001-50-50 Calendar.Holocene]\") end\n\n assert_raise UndefinedFunctionError, fn ->\n Code.eval_string(\"~D[2000-01-01 UnknownCalendar]\")\n end\n end\n\n test \"to_string/1\" do\n date = ~D[2000-01-01]\n assert to_string(date) == \"2000-01-01\"\n assert Date.to_string(date) == \"2000-01-01\"\n assert Date.to_string(Map.from_struct(date)) == \"2000-01-01\"\n\n assert to_string(%{date | calendar: FakeCalendar}) == \"1/1/2000\"\n assert Date.to_string(%{date | calendar: FakeCalendar}) == \"1/1/2000\"\n\n date2 = Date.new!(5_874_897, 12, 31)\n assert to_string(date2) == \"5874897-12-31\"\n assert Date.to_string(date2) == \"5874897-12-31\"\n assert Date.to_string(Map.from_struct(date2)) == \"5874897-12-31\"\n\n assert to_string(%{date2 | calendar: FakeCalendar}) == \"31/12/5874897\"\n assert Date.to_string(%{date2 | calendar: FakeCalendar}) == \"31/12/5874897\"\n end\n\n test \"inspect/1\" do\n assert inspect(~D[2000-01-01]) == \"~D[2000-01-01]\"\n assert inspect(~D[-0100-12-31]) == \"~D[-0100-12-31]\"\n\n date = %{~D[2000-01-01] | calendar: FakeCalendar}\n assert inspect(date) == \"~D[1/1/2000 FakeCalendar]\"\n\n assert inspect(Date.new!(99999, 12, 31)) == \"Date.new!(99999, 12, 31)\"\n assert inspect(Date.new!(-99999, 1, 1)) == \"Date.new!(-99999, 1, 1)\"\n\n date2 = %{Date.new!(99999, 12, 31) | calendar: FakeCalendar}\n\n assert inspect(%{date2 | calendar: FakeCalendar}) ==\n \"~D[31/12/99999 FakeCalendar]\"\n end\n\n test \"compare/2\" do\n date1 = ~D[-0001-12-30]\n date2 = ~D[-0001-12-31]\n date3 = ~D[0001-01-01]\n date4 = Date.new!(5_874_897, 12, 31)\n date5 = Date.new!(-4713, 1, 1)\n\n assert Date.compare(date1, date1) == :eq\n assert Date.compare(date1, date2) == :lt\n assert Date.compare(date2, date1) == :gt\n assert Date.compare(date3, date3) == :eq\n assert Date.compare(date2, date3) == :lt\n assert Date.compare(date3, date2) == :gt\n assert Date.compare(date4, date1) == :gt\n assert Date.compare(date1, date4) == :lt\n assert Date.compare(date4, date4) == :eq\n assert Date.compare(date4, date5) == :gt\n assert Date.compare(date5, date4) == :lt\n assert Date.compare(date5, date5) == :eq\n\n assert_raise ArgumentError,\n ~r/cannot compare .*\\n\\n.* their calendars have incompatible day rollover moments/,\n fn -> Date.compare(date1, %{date2 | calendar: FakeCalendar}) end\n end\n\n test \"before?/2 and after?/2\" do\n date1 = ~D[2022-11-01]\n date2 = ~D[2022-11-02]\n date3 = Date.new!(5_874_897, 12, 31)\n date4 = Date.new!(-4713, 1, 1)\n\n assert Date.before?(date1, date2)\n assert Date.before?(date1, date3)\n assert Date.before?(date4, date1)\n assert not Date.before?(date2, date1)\n assert not Date.before?(date3, date1)\n assert not Date.before?(date1, date4)\n\n assert Date.after?(date2, date1)\n assert Date.after?(date3, date2)\n assert Date.after?(date2, date4)\n assert not Date.after?(date1, date2)\n assert not Date.after?(date2, date3)\n assert not Date.after?(date4, date2)\n end\n\n test \"compare/2 across calendars\" do\n date1 = ~D[2000-01-01]\n date2 = Calendar.Holocene.date(12000, 01, 01)\n assert Date.compare(date1, date2) == :eq\n\n date2 = Calendar.Holocene.date(12001, 01, 01)\n assert Date.compare(date1, date2) == :lt\n assert Date.compare(date2, date1) == :gt\n end\n\n test \"day_of_week/1\" do\n assert Date.day_of_week(Calendar.Holocene.date(2016, 10, 31)) == 1\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 01)) == 2\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 02)) == 3\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 03)) == 4\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 04)) == 5\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 05)) == 6\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 06)) == 7\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 07)) == 1\n\n assert Date.day_of_week(Calendar.Holocene.date(2016, 10, 30), :sunday) == 1\n assert Date.day_of_week(Calendar.Holocene.date(2016, 10, 31), :sunday) == 2\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 01), :sunday) == 3\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 02), :sunday) == 4\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 03), :sunday) == 5\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 04), :sunday) == 6\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 05), :sunday) == 7\n assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 06), :sunday) == 1\n end\n\n test \"beginning_of_week\" do\n assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 11)) ==\n Calendar.Holocene.date(2020, 07, 06)\n\n assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 06)) ==\n Calendar.Holocene.date(2020, 07, 06)\n\n assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 11), :sunday) ==\n Calendar.Holocene.date(2020, 07, 05)\n\n assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 11), :saturday) ==\n Calendar.Holocene.date(2020, 07, 11)\n end\n\n test \"end_of_week\" do\n assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 11)) ==\n Calendar.Holocene.date(2020, 07, 12)\n\n assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 05)) ==\n Calendar.Holocene.date(2020, 07, 05)\n\n assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 05), :sunday) ==\n Calendar.Holocene.date(2020, 07, 11)\n\n assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 05), :saturday) ==\n Calendar.Holocene.date(2020, 07, 10)\n end\n\n test \"convert/2\" do\n assert Date.convert(~D[2000-01-01], Calendar.Holocene) ==\n {:ok, Calendar.Holocene.date(12000, 01, 01)}\n\n assert ~D[2000-01-01]\n |> Date.convert!(Calendar.Holocene)\n |> Date.convert!(Calendar.ISO) == ~D[2000-01-01]\n\n assert Date.convert(~N[2000-01-01 00:00:00], Calendar.Holocene) ==\n {:ok, Calendar.Holocene.date(12000, 01, 01)}\n\n assert Date.convert(~D[2016-02-03], FakeCalendar) == {:error, :incompatible_calendars}\n\n assert_raise ArgumentError,\n \"cannot convert ~D[2016-02-03] to target calendar FakeCalendar, reason: :incompatible_calendars\",\n fn -> Date.convert!(~D[2016-02-03], FakeCalendar) end\n end\n\n test \"add/2\" do\n assert Date.add(~D[0000-01-01], 3_652_424) == ~D[9999-12-31]\n assert Date.add(~D[0000-01-01], 3_652_425) == Date.new!(10000, 1, 1)\n assert Date.add(~D[0000-01-01], -1) == ~D[-0001-12-31]\n assert Date.add(~D[0000-01-01], -365) == ~D[-0001-01-01]\n assert Date.add(~D[0000-01-01], -366) == ~D[-0002-12-31]\n assert Date.add(~D[0000-01-01], -(365 * 4)) == ~D[-0004-01-02]\n assert Date.add(~D[0000-01-01], -(365 * 5)) == ~D[-0005-01-02]\n assert Date.add(~D[0000-01-01], -(365 * 100)) == ~D[-0100-01-25]\n assert Date.add(~D[0000-01-01], -3_652_059) == ~D[-9999-01-01]\n assert Date.add(~D[0000-01-01], -3_652_060) == Date.new!(-10000, 12, 31)\n assert Date.add(Date.new!(5_874_897, 12, 31), 1) == Date.new!(5_874_898, 1, 1)\n end\n\n test \"diff/2\" do\n assert Date.diff(~D[2000-01-31], ~D[2000-01-01]) == 30\n assert Date.diff(~D[2000-01-01], ~D[2000-01-31]) == -30\n\n assert Date.diff(~D[0000-01-01], ~D[-0001-01-01]) == 365\n assert Date.diff(~D[-0003-01-01], ~D[-0004-01-01]) == 366\n\n assert Date.diff(Date.new!(5_874_898, 1, 1), Date.new!(5_874_897, 1, 1)) == 365\n assert Date.diff(Date.new!(5_874_905, 1, 1), Date.new!(5_874_904, 1, 1)) == 366\n\n date1 = ~D[2000-01-01]\n date2 = Calendar.Holocene.date(12000, 01, 14)\n assert Date.diff(date1, date2) == -13\n assert Date.diff(date2, date1) == 13\n\n assert_raise ArgumentError,\n ~r/cannot calculate the difference between .* because their calendars are not compatible/,\n fn -> Date.diff(date1, %{date2 | calendar: FakeCalendar}) end\n end\n\n test \"shift/2\" do\n assert Date.shift(~D[2012-02-29], day: -1) == ~D[2012-02-28]\n assert Date.shift(~D[2012-02-29], month: -1) == ~D[2012-01-29]\n assert Date.shift(~D[2012-02-29], week: -9) == ~D[2011-12-28]\n assert Date.shift(~D[2012-02-29], month: 1) == ~D[2012-03-29]\n assert Date.shift(~D[2012-02-29], year: -1) == ~D[2011-02-28]\n assert Date.shift(~D[2012-02-29], year: 4) == ~D[2016-02-29]\n assert Date.shift(~D[0000-01-01], day: -1) == ~D[-0001-12-31]\n assert Date.shift(~D[0000-01-01], month: -1) == ~D[-0001-12-01]\n assert Date.shift(~D[0000-01-01], year: -1) == ~D[-0001-01-01]\n assert Date.shift(~D[0000-01-01], year: -1) == ~D[-0001-01-01]\n assert Date.shift(~D[2000-01-01], month: 12) == ~D[2001-01-01]\n assert Date.shift(~D[0000-01-01], day: 2, year: 1, month: 37) == ~D[0004-02-03]\n\n assert Date.shift(Date.new!(5_874_904, 2, 29), day: -1) == Date.new!(5_874_904, 2, 28)\n assert Date.shift(Date.new!(5_874_904, 2, 29), month: -2) == Date.new!(5_874_903, 12, 29)\n assert Date.shift(Date.new!(5_874_904, 2, 29), week: -9) == Date.new!(5_874_903, 12, 28)\n assert Date.shift(Date.new!(5_874_904, 2, 29), month: 1) == Date.new!(5_874_904, 3, 29)\n assert Date.shift(Date.new!(5_874_904, 2, 29), year: -1) == Date.new!(5_874_903, 2, 28)\n assert Date.shift(Date.new!(5_874_904, 2, 29), year: -4) == Date.new!(5_874_900, 2, 28)\n assert Date.shift(Date.new!(5_874_904, 2, 29), year: 4) == Date.new!(5_874_908, 2, 29)\n\n assert Date.shift(Date.new!(5_874_904, 2, 29), day: 1, year: 4, month: 2) ==\n Date.new!(5_874_908, 4, 30)\n\n assert_raise ArgumentError,\n \"unsupported unit :second. Expected :year, :month, :week, :day\",\n fn -> Date.shift(~D[2012-02-29], second: 86400) end\n\n assert_raise ArgumentError,\n \"unknown unit :months. Expected :year, :month, :week, :day\",\n fn -> Date.shift(~D[2012-01-01], months: 12) end\n\n assert_raise ArgumentError,\n \"unsupported value nil for :day. Expected an integer\",\n fn -> Date.shift(~D[2012-02-29], year: 1, day: nil) end\n\n assert_raise ArgumentError,\n \"cannot shift date by time scale unit. Expected :year, :month, :week, :day\",\n fn -> Date.shift(~D[2012-02-29], %Duration{second: 86400}) end\n\n # Microsecond precision is ignored\n assert Date.shift(~D[2012-02-29], Duration.new!(microsecond: {0, 6})) == ~D[2012-02-29]\n\n assert_raise ArgumentError,\n \"cannot shift date by time scale unit. Expected :year, :month, :week, :day\",\n fn -> Date.shift(~D[2012-02-29], %Duration{microsecond: {100, 6}}) end\n\n # Implements calendar callback\n assert_raise RuntimeError, \"shift_date/4 not implemented\", fn ->\n date = Calendar.Holocene.date(10000, 01, 01)\n Date.shift(date, month: 1)\n end\n end\n\n test \"utc_today/1\" do\n date = Date.utc_today()\n assert date.year > 2020\n assert date.calendar == Calendar.ISO\n\n date = Date.utc_today(Calendar.ISO)\n assert date.year > 2020\n assert date.calendar == Calendar.ISO\n\n date = Date.utc_today(Calendar.Holocene)\n assert date.year > 12020\n assert date.calendar == Calendar.Holocene\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/datetime_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\nCode.require_file(\"holocene.exs\", __DIR__)\nCode.require_file(\"fakes.exs\", __DIR__)\n\ndefmodule DateTimeTest do\n use ExUnit.Case\n doctest DateTime\n\n test \"sigil_U\" do\n assert ~U[2000-01-01T12:34:56Z] ==\n %DateTime{\n calendar: Calendar.ISO,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56,\n std_offset: 0,\n utc_offset: 0,\n time_zone: \"Etc/UTC\",\n zone_abbr: \"UTC\"\n }\n\n assert ~U[2000-01-01T12:34:56+00:00 Calendar.Holocene] ==\n %DateTime{\n calendar: Calendar.Holocene,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56,\n std_offset: 0,\n utc_offset: 0,\n time_zone: \"Etc/UTC\",\n zone_abbr: \"UTC\"\n }\n\n assert ~U[2000-01-01 12:34:56+00:00] ==\n %DateTime{\n calendar: Calendar.ISO,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56,\n std_offset: 0,\n utc_offset: 0,\n time_zone: \"Etc/UTC\",\n zone_abbr: \"UTC\"\n }\n\n assert ~U[2000-01-01 12:34:56Z Calendar.Holocene] ==\n %DateTime{\n calendar: Calendar.Holocene,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56,\n std_offset: 0,\n utc_offset: 0,\n time_zone: \"Etc/UTC\",\n zone_abbr: \"UTC\"\n }\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-50-50T12:34:56Z\" as UTC DateTime for Calendar.ISO, reason: :invalid_date/,\n fn -> Code.eval_string(\"~U[2001-50-50T12:34:56Z]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:65Z\" as UTC DateTime for Calendar.ISO, reason: :invalid_time/,\n fn -> Code.eval_string(\"~U[2001-01-01T12:34:65Z]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:56\\+01:00\" as UTC DateTime for Calendar.ISO, reason: :non_utc_offset/,\n fn -> Code.eval_string(\"~U[2001-01-01T12:34:56+01:00]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01 12:34:56Z notalias\" as UTC DateTime for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(\"~U[2001-01-01 12:34:56Z notalias]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:56Z notalias\" as UTC DateTime for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(\"~U[2001-01-01T12:34:56Z notalias]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-50-50T12:34:56Z\" as UTC DateTime for Calendar.Holocene, reason: :invalid_date/,\n fn -> Code.eval_string(\"~U[2001-50-50T12:34:56Z Calendar.Holocene]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:65Z\" as UTC DateTime for Calendar.Holocene, reason: :invalid_time/,\n fn -> Code.eval_string(\"~U[2001-01-01T12:34:65Z Calendar.Holocene]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:56+01:00 Calendar.Holocene\" as UTC DateTime for Calendar.Holocene, reason: :non_utc_offset/,\n fn -> Code.eval_string(\"~U[2001-01-01T12:34:56+01:00 Calendar.Holocene]\") end\n\n assert_raise UndefinedFunctionError, fn ->\n Code.eval_string(\"~U[2001-01-01 12:34:56 UnknownCalendar]\")\n end\n\n assert_raise UndefinedFunctionError, fn ->\n Code.eval_string(\"~U[2001-01-01T12:34:56 UnknownCalendar]\")\n end\n end\n\n test \"to_string/1\" do\n datetime = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"BRM\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: -12600,\n std_offset: 3600,\n time_zone: \"Brazil/Manaus\"\n }\n\n assert to_string(datetime) == \"2000-02-29 23:00:07-02:30 BRM Brazil/Manaus\"\n assert DateTime.to_string(datetime) == \"2000-02-29 23:00:07-02:30 BRM Brazil/Manaus\"\n\n assert DateTime.to_string(Map.from_struct(datetime)) ==\n \"2000-02-29 23:00:07-02:30 BRM Brazil/Manaus\"\n\n assert to_string(%{datetime | calendar: FakeCalendar}) ==\n \"29/2/2000F23::0::7 Brazil/Manaus BRM -12600 3600\"\n\n assert DateTime.to_string(%{datetime | calendar: FakeCalendar}) ==\n \"29/2/2000F23::0::7 Brazil/Manaus BRM -12600 3600\"\n end\n\n test \"inspect/1\" do\n utc_datetime = ~U[2000-01-01 23:00:07.005Z]\n assert inspect(utc_datetime) == \"~U[2000-01-01 23:00:07.005Z]\"\n\n assert inspect(%{utc_datetime | year: 99999}) == \"#DateTime<99999-01-01 23:00:07.005Z>\"\n\n assert inspect(%{utc_datetime | calendar: FakeCalendar}) ==\n \"~U[1/1/2000F23::0::7 Etc/UTC UTC 0 0 FakeCalendar]\"\n\n datetime = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"BRM\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: -12600,\n std_offset: 3600,\n time_zone: \"Brazil/Manaus\"\n }\n\n assert inspect(datetime) == \"#DateTime<2000-02-29 23:00:07-02:30 BRM Brazil/Manaus>\"\n\n assert inspect(%{datetime | calendar: FakeCalendar}) ==\n \"#DateTime<29/2/2000F23::0::7 Brazil/Manaus BRM -12600 3600 FakeCalendar>\"\n end\n\n test \"from_iso8601/1 handles positive and negative offsets\" do\n assert DateTime.from_iso8601(\"2015-01-24T09:50:07-10:00\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 1,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 2015,\n zone_abbr: \"UTC\",\n day: 24,\n hour: 19,\n minute: 50,\n second: 7\n }\n\n assert DateTime.from_iso8601(\"2015-01-24T09:50:07+10:00\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 1,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 2015,\n zone_abbr: \"UTC\",\n day: 23,\n hour: 23,\n minute: 50,\n second: 7\n }\n\n assert DateTime.from_iso8601(\"0000-01-01T01:22:07+10:30\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 12,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: -1,\n zone_abbr: \"UTC\",\n day: 31,\n hour: 14,\n minute: 52,\n second: 7\n }\n end\n\n test \"from_iso8601/1 handles negative dates\" do\n assert DateTime.from_iso8601(\"-2015-01-24T09:50:07-10:00\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 1,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: -2015,\n zone_abbr: \"UTC\",\n day: 24,\n hour: 19,\n minute: 50,\n second: 7\n }\n\n assert DateTime.from_iso8601(\"-2015-01-24T09:50:07+10:00\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 1,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: -2015,\n zone_abbr: \"UTC\",\n day: 23,\n hour: 23,\n minute: 50,\n second: 7\n }\n\n assert DateTime.from_iso8601(\"-0001-01-01T01:22:07+10:30\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 12,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: -2,\n zone_abbr: \"UTC\",\n day: 31,\n hour: 14,\n minute: 52,\n second: 7\n }\n\n assert DateTime.from_iso8601(\"-0001-01-01T01:22:07-10:30\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 1,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: -1,\n zone_abbr: \"UTC\",\n day: 1,\n hour: 11,\n minute: 52,\n second: 7\n }\n\n assert DateTime.from_iso8601(\"-0001-12-31T23:22:07-10:30\") |> elem(1) ==\n %DateTime{\n microsecond: {0, 0},\n month: 1,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 0,\n zone_abbr: \"UTC\",\n day: 1,\n hour: 9,\n minute: 52,\n second: 7\n }\n end\n\n test \"from_iso8601/3 with basic format handles positive and negative offsets\" do\n assert DateTime.from_iso8601(\"20150124T095007-1000\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"2015-01-24T09:50:07-10:00\", Calendar.ISO)\n\n assert DateTime.from_iso8601(\"20150124T095007+1000\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"2015-01-24T09:50:07+10:00\", Calendar.ISO)\n\n assert DateTime.from_iso8601(\"00000101T012207+1030\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"0000-01-01T01:22:07+10:30\", Calendar.ISO)\n end\n\n test \"from_iso8601/3 with basic format handles negative dates\" do\n assert DateTime.from_iso8601(\"-20150124T095007-1000\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"-2015-01-24T09:50:07-10:00\", Calendar.ISO)\n\n assert DateTime.from_iso8601(\"-20150124T095007+1000\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"-2015-01-24T09:50:07+10:00\", Calendar.ISO)\n\n assert DateTime.from_iso8601(\"-00010101T012207+1030\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"-0001-01-01T01:22:07+10:30\", Calendar.ISO)\n\n assert DateTime.from_iso8601(\"-00010101T012207-1030\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"-0001-01-01T01:22:07-10:30\", Calendar.ISO)\n\n assert DateTime.from_iso8601(\"-00011231T232207-1030\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"-0001-12-31T23:22:07-10:30\", Calendar.ISO)\n end\n\n test \"from_iso8601/2 handles either a calendar or a format as the second parameter\" do\n assert DateTime.from_iso8601(\"20150124T095007-1000\", :basic) ==\n DateTime.from_iso8601(\"2015-01-24T09:50:07-10:00\", Calendar.ISO)\n end\n\n test \"from_iso8601 handles invalid date, time, formats correctly\" do\n assert DateTime.from_iso8601(\"2015-01-23T23:50:07\") == {:error, :missing_offset}\n assert DateTime.from_iso8601(\"2015-01-23 23:50:61\") == {:error, :invalid_time}\n assert DateTime.from_iso8601(\"2015-01-32 23:50:07\") == {:error, :invalid_date}\n assert DateTime.from_iso8601(\"2015-01-23 23:50:07A\") == {:error, :invalid_format}\n assert DateTime.from_iso8601(\"2015-01-23T23:50:07.123-00:60\") == {:error, :invalid_format}\n\n assert DateTime.from_iso8601(\"20150123T235007\", Calendar.ISO, :basic) ==\n {:error, :missing_offset}\n\n assert DateTime.from_iso8601(\"20150123 235061\", Calendar.ISO, :basic) ==\n {:error, :invalid_time}\n\n assert DateTime.from_iso8601(\"20150132 235007\", Calendar.ISO, :basic) ==\n {:error, :invalid_date}\n\n assert DateTime.from_iso8601(\"20150123 235007A\", Calendar.ISO, :basic) ==\n {:error, :invalid_format}\n\n assert DateTime.from_iso8601(\"2015-01-24T09:50:07-10:00\", Calendar.ISO, :basic) ==\n {:error, :invalid_format}\n\n assert DateTime.from_iso8601(\"20150123T235007.123-0060\", Calendar.ISO, :basic) ==\n {:error, :invalid_format}\n end\n\n test \"from_unix/2\" do\n min_datetime = %DateTime{\n calendar: Calendar.ISO,\n day: 1,\n hour: 0,\n microsecond: {0, 0},\n minute: 0,\n month: 1,\n second: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: -9999,\n zone_abbr: \"UTC\"\n }\n\n assert DateTime.from_unix(-377_705_116_800) == {:ok, min_datetime}\n\n assert DateTime.from_unix(-377_705_116_800_000_001, :microsecond) ==\n {:error, :invalid_unix_time}\n\n assert DateTime.from_unix(143_256_036_886_856, 1024) ==\n {:ok,\n %DateTime{\n calendar: Calendar.ISO,\n day: 17,\n hour: 7,\n microsecond: {320_312, 6},\n minute: 5,\n month: 3,\n second: 22,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 6403,\n zone_abbr: \"UTC\"\n }}\n\n max_datetime = %DateTime{\n calendar: Calendar.ISO,\n day: 31,\n hour: 23,\n microsecond: {999_999, 6},\n minute: 59,\n month: 12,\n second: 59,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 9999,\n zone_abbr: \"UTC\"\n }\n\n assert DateTime.from_unix(253_402_300_799_999_999, :microsecond) == {:ok, max_datetime}\n\n assert DateTime.from_unix(253_402_300_800) == {:error, :invalid_unix_time}\n\n minus_datetime = %DateTime{\n calendar: Calendar.ISO,\n day: 31,\n hour: 23,\n microsecond: {999_999, 6},\n minute: 59,\n month: 12,\n second: 59,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 1969,\n zone_abbr: \"UTC\"\n }\n\n assert DateTime.from_unix(-1, :microsecond) == {:ok, minus_datetime}\n\n assert_raise ArgumentError, fn ->\n DateTime.from_unix(0, :unknown_atom)\n end\n\n assert_raise ArgumentError, fn ->\n DateTime.from_unix(0, \"invalid type\")\n end\n end\n\n test \"from_unix!/2\" do\n # with Unix times back to 0 Gregorian seconds\n datetime = %DateTime{\n calendar: Calendar.ISO,\n day: 1,\n hour: 0,\n microsecond: {0, 0},\n minute: 0,\n month: 1,\n second: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 0,\n zone_abbr: \"UTC\"\n }\n\n assert DateTime.from_unix!(-62_167_219_200) == datetime\n\n assert_raise ArgumentError, fn ->\n DateTime.from_unix!(-377_705_116_801)\n end\n\n assert_raise ArgumentError, fn ->\n DateTime.from_unix!(0, :unknown_atom)\n end\n\n assert_raise ArgumentError, fn ->\n DateTime.from_unix!(0, \"invalid type\")\n end\n end\n\n test \"to_unix/2 works with Unix times back to 0 Gregorian seconds\" do\n # with Unix times back to 0 Gregorian seconds\n gregorian_0 = %DateTime{\n calendar: Calendar.ISO,\n day: 1,\n hour: 0,\n microsecond: {0, 0},\n minute: 0,\n month: 1,\n second: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 0,\n zone_abbr: \"UTC\"\n }\n\n assert DateTime.to_unix(gregorian_0) == -62_167_219_200\n assert DateTime.to_unix(Map.from_struct(gregorian_0)) == -62_167_219_200\n\n min_datetime = %{gregorian_0 | year: -9999}\n assert DateTime.to_unix(min_datetime) == -377_705_116_800\n end\n\n test \"compare/2\" do\n datetime1 = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n datetime2 = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"AMT\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: -14400,\n std_offset: 0,\n time_zone: \"America/Manaus\"\n }\n\n datetime3 = %DateTime{\n year: -99,\n month: 2,\n day: 28,\n zone_abbr: \"AMT\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: -14400,\n std_offset: 0,\n time_zone: \"America/Manaus\"\n }\n\n assert DateTime.compare(datetime1, datetime1) == :eq\n assert DateTime.compare(datetime1, datetime2) == :lt\n assert DateTime.compare(datetime2, datetime1) == :gt\n assert DateTime.compare(datetime3, datetime3) == :eq\n assert DateTime.compare(datetime2, datetime3) == :gt\n assert DateTime.compare(datetime3, datetime1) == :lt\n assert DateTime.compare(Map.from_struct(datetime3), Map.from_struct(datetime1)) == :lt\n end\n\n test \"before?/2 and after?/2\" do\n datetime1 = ~U[2015-01-02T12:34:56Z]\n datetime2 = ~U[2015-01-02T12:55:55Z]\n\n assert DateTime.before?(datetime1, datetime2)\n assert not DateTime.before?(datetime2, datetime1)\n\n assert DateTime.after?(datetime2, datetime1)\n assert not DateTime.after?(datetime1, datetime2)\n end\n\n test \"convert/2\" do\n datetime_iso = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n datetime_hol = %DateTime{\n year: 12000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\",\n calendar: Calendar.Holocene\n }\n\n assert DateTime.convert(datetime_iso, Calendar.Holocene) == {:ok, datetime_hol}\n\n assert datetime_iso\n |> DateTime.convert!(Calendar.Holocene)\n |> DateTime.convert!(Calendar.ISO) == datetime_iso\n\n assert %{datetime_iso | microsecond: {123, 6}}\n |> DateTime.convert!(Calendar.Holocene)\n |> DateTime.convert!(Calendar.ISO) == %{datetime_iso | microsecond: {123, 6}}\n\n assert DateTime.convert(datetime_iso, FakeCalendar) == {:error, :incompatible_calendars}\n\n # Test passing non-struct map when converting to different calendar returns DateTime struct\n assert DateTime.convert(Map.from_struct(datetime_iso), Calendar.Holocene) ==\n {:ok, datetime_hol}\n\n # Test passing non-struct map when converting to same calendar returns DateTime struct\n assert DateTime.convert(Map.from_struct(datetime_iso), Calendar.ISO) ==\n {:ok, datetime_iso}\n end\n\n test \"from_iso8601/1 with tz offsets\" do\n assert DateTime.from_iso8601(\"2017-06-02T14:00:00+01:00\")\n |> elem(1) ==\n %DateTime{\n year: 2017,\n month: 6,\n day: 2,\n zone_abbr: \"UTC\",\n hour: 13,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n utc_offset: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\"\n }\n\n assert DateTime.from_iso8601(\"2017-06-02T14:00:00-04:00\")\n |> elem(1) ==\n %DateTime{\n year: 2017,\n month: 6,\n day: 2,\n zone_abbr: \"UTC\",\n hour: 18,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n utc_offset: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\"\n }\n\n assert DateTime.from_iso8601(\"2017-06-02T14:00:00+0100\")\n |> elem(1) ==\n %DateTime{\n year: 2017,\n month: 6,\n day: 2,\n zone_abbr: \"UTC\",\n hour: 13,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n utc_offset: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\"\n }\n\n assert DateTime.from_iso8601(\"2017-06-02T14:00:00-0400\")\n |> elem(1) ==\n %DateTime{\n year: 2017,\n month: 6,\n day: 2,\n zone_abbr: \"UTC\",\n hour: 18,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n utc_offset: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\"\n }\n\n assert DateTime.from_iso8601(\"2017-06-02T14:00:00+01\")\n |> elem(1) ==\n %DateTime{\n year: 2017,\n month: 6,\n day: 2,\n zone_abbr: \"UTC\",\n hour: 13,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n utc_offset: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\"\n }\n\n assert DateTime.from_iso8601(\"2017-06-02T14:00:00-04\")\n |> elem(1) ==\n %DateTime{\n year: 2017,\n month: 6,\n day: 2,\n zone_abbr: \"UTC\",\n hour: 18,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n utc_offset: 0,\n std_offset: 0,\n time_zone: \"Etc/UTC\"\n }\n end\n\n test \"from_iso8601/3 with basic format with tz offsets\" do\n assert DateTime.from_iso8601(\"20170602T140000+0100\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"2017-06-02T14:00:00+01:00\", Calendar.ISO)\n\n assert DateTime.from_iso8601(\"20170602T140000-0400\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"2017-06-02T14:00:00-04:00\")\n\n assert DateTime.from_iso8601(\"20170602T140000+01\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"2017-06-02T14:00:00+01\")\n\n assert DateTime.from_iso8601(\"20170602T140000-04\", Calendar.ISO, :basic) ==\n DateTime.from_iso8601(\"2017-06-02T14:00:00-04\")\n end\n\n test \"truncate/2\" do\n datetime = %DateTime{\n year: 2017,\n month: 11,\n day: 6,\n zone_abbr: \"CET\",\n hour: 0,\n minute: 6,\n second: 23,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Paris\"\n }\n\n datetime_map = Map.from_struct(datetime)\n\n assert DateTime.truncate(%{datetime | microsecond: {123_456, 6}}, :microsecond) ==\n %{datetime | microsecond: {123_456, 6}}\n\n # A struct should be returned when passing a map.\n assert DateTime.truncate(%{datetime_map | microsecond: {123_456, 6}}, :microsecond) ==\n %{datetime | microsecond: {123_456, 6}}\n\n assert DateTime.truncate(%{datetime | microsecond: {0, 0}}, :millisecond) ==\n %{datetime | microsecond: {0, 0}}\n\n assert DateTime.truncate(%{datetime | microsecond: {000_100, 6}}, :millisecond) ==\n %{datetime | microsecond: {0, 3}}\n\n assert DateTime.truncate(%{datetime | microsecond: {000_999, 6}}, :millisecond) ==\n %{datetime | microsecond: {0, 3}}\n\n assert DateTime.truncate(%{datetime | microsecond: {001_000, 6}}, :millisecond) ==\n %{datetime | microsecond: {1000, 3}}\n\n assert DateTime.truncate(%{datetime | microsecond: {001_200, 6}}, :millisecond) ==\n %{datetime | microsecond: {1000, 3}}\n\n assert DateTime.truncate(%{datetime | microsecond: {123_456, 6}}, :millisecond) ==\n %{datetime | microsecond: {123_000, 3}}\n\n assert DateTime.truncate(%{datetime | microsecond: {123_456, 6}}, :second) ==\n %{datetime | microsecond: {0, 0}}\n end\n\n describe \"diff\" do\n test \"with invalid time unit\" do\n dt = DateTime.utc_now()\n\n message =\n ~r/unsupported time unit\\. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got \"day\"/\n\n assert_raise ArgumentError, message, fn -> DateTime.diff(dt, dt, \"day\") end\n end\n\n test \"with valid time unit\" do\n dt1 = %DateTime{\n year: 100,\n month: 2,\n day: 28,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n dt2 = %DateTime{\n year: -0004,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n assert DateTime.diff(dt1, dt2) == 3_281_904_000\n\n # Test with a non-struct map conforming to Calendar.datetime\n assert DateTime.diff(Map.from_struct(dt1), Map.from_struct(dt2)) == 3_281_904_000\n end\n\n test \"with microseconds\" do\n datetime = ~U[2023-02-01 10:30:10.123456Z]\n\n in_almost_7_days =\n datetime\n |> DateTime.add(7, :day)\n |> DateTime.add(-1, :microsecond)\n\n assert DateTime.diff(in_almost_7_days, datetime, :day) == 6\n end\n\n test \"in microseconds\" do\n datetime1 = ~U[2023-02-01 10:30:10.000000Z]\n datetime2 = DateTime.add(datetime1, 1234, :microsecond)\n\n assert DateTime.diff(datetime1, datetime2, :microsecond) == -1234\n end\n end\n\n describe \"from_naive\" do\n test \"uses default time zone database from config\" do\n Calendar.put_time_zone_database(FakeTimeZoneDatabase)\n\n assert DateTime.from_naive(\n ~N[2018-07-01 12:34:25.123456],\n \"Europe/Copenhagen\",\n FakeTimeZoneDatabase\n ) ==\n {:ok,\n %DateTime{\n day: 1,\n hour: 12,\n microsecond: {123_456, 6},\n minute: 34,\n month: 7,\n second: 25,\n std_offset: 3600,\n time_zone: \"Europe/Copenhagen\",\n utc_offset: 3600,\n year: 2018,\n zone_abbr: \"CEST\"\n }}\n after\n Calendar.put_time_zone_database(Calendar.UTCOnlyTimeZoneDatabase)\n end\n\n test \"with compatible calendar on unambiguous wall clock\" do\n holocene_ndt = %NaiveDateTime{\n calendar: Calendar.Holocene,\n year: 12018,\n month: 7,\n day: 1,\n hour: 12,\n minute: 34,\n second: 25,\n microsecond: {123_456, 6}\n }\n\n assert DateTime.from_naive(holocene_ndt, \"Europe/Copenhagen\", FakeTimeZoneDatabase) ==\n {:ok,\n %DateTime{\n calendar: Calendar.Holocene,\n day: 1,\n hour: 12,\n microsecond: {123_456, 6},\n minute: 34,\n month: 7,\n second: 25,\n std_offset: 3600,\n time_zone: \"Europe/Copenhagen\",\n utc_offset: 3600,\n year: 12018,\n zone_abbr: \"CEST\"\n }}\n end\n\n test \"with compatible calendar on ambiguous wall clock\" do\n holocene_ndt = %NaiveDateTime{\n calendar: Calendar.Holocene,\n year: 12018,\n month: 10,\n day: 28,\n hour: 02,\n minute: 30,\n second: 00,\n microsecond: {123_456, 6}\n }\n\n assert {:ambiguous, first_dt, second_dt} =\n DateTime.from_naive(holocene_ndt, \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n\n assert %DateTime{calendar: Calendar.Holocene, zone_abbr: \"CEST\"} = first_dt\n assert %DateTime{calendar: Calendar.Holocene, zone_abbr: \"CET\"} = second_dt\n end\n\n test \"with compatible calendar on gap\" do\n holocene_ndt = %NaiveDateTime{\n calendar: Calendar.Holocene,\n year: 12019,\n month: 03,\n day: 31,\n hour: 02,\n minute: 30,\n second: 00,\n microsecond: {123_456, 6}\n }\n\n assert {:gap, first_dt, second_dt} =\n DateTime.from_naive(holocene_ndt, \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n\n assert %DateTime{calendar: Calendar.Holocene, zone_abbr: \"CET\"} = first_dt\n assert %DateTime{calendar: Calendar.Holocene, zone_abbr: \"CEST\"} = second_dt\n end\n\n test \"with incompatible calendar\" do\n ndt = %{~N[2018-07-20 00:00:00] | calendar: FakeCalendar}\n\n assert DateTime.from_naive(ndt, \"Europe/Copenhagen\", FakeTimeZoneDatabase) ==\n {:error, :incompatible_calendars}\n end\n end\n\n describe \"from_naive!\" do\n test \"raises on ambiguous wall clock\" do\n assert_raise ArgumentError, ~r\"ambiguous\", fn ->\n DateTime.from_naive!(~N[2018-10-28 02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n end\n end\n\n test \"raises on gap\" do\n assert_raise ArgumentError, ~r\"gap\", fn ->\n DateTime.from_naive!(~N[2019-03-31 02:30:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n end\n end\n end\n\n describe \"shift_zone\" do\n test \"with compatible calendar\" do\n holocene_ndt = %NaiveDateTime{\n calendar: Calendar.Holocene,\n year: 12018,\n month: 7,\n day: 1,\n hour: 12,\n minute: 34,\n second: 25,\n microsecond: {123_456, 6}\n }\n\n {:ok, holocene_dt} =\n DateTime.from_naive(holocene_ndt, \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n\n {:ok, dt} = DateTime.shift_zone(holocene_dt, \"America/Los_Angeles\", FakeTimeZoneDatabase)\n\n assert dt == %DateTime{\n calendar: Calendar.Holocene,\n day: 1,\n hour: 3,\n microsecond: {123_456, 6},\n minute: 34,\n month: 7,\n second: 25,\n std_offset: 3600,\n time_zone: \"America/Los_Angeles\",\n utc_offset: -28800,\n year: 12018,\n zone_abbr: \"PDT\"\n }\n end\n\n test \"uses default time zone database from config\" do\n Calendar.put_time_zone_database(FakeTimeZoneDatabase)\n\n {:ok, dt} = DateTime.from_naive(~N[2018-07-01 12:34:25.123456], \"Europe/Copenhagen\")\n {:ok, dt} = DateTime.shift_zone(dt, \"America/Los_Angeles\")\n\n assert dt == %DateTime{\n day: 1,\n hour: 3,\n microsecond: {123_456, 6},\n minute: 34,\n month: 7,\n second: 25,\n std_offset: 3600,\n time_zone: \"America/Los_Angeles\",\n utc_offset: -28800,\n year: 2018,\n zone_abbr: \"PDT\"\n }\n after\n Calendar.put_time_zone_database(Calendar.UTCOnlyTimeZoneDatabase)\n end\n end\n\n describe \"add\" do\n test \"with non-struct map that conforms to Calendar.datetime\" do\n dt_map = DateTime.from_naive!(~N[2018-08-28 00:00:00], \"Etc/UTC\") |> Map.from_struct()\n\n assert DateTime.add(dt_map, 1, :second) == %DateTime{\n calendar: Calendar.ISO,\n year: 2018,\n month: 8,\n day: 28,\n hour: 0,\n minute: 0,\n second: 1,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n zone_abbr: \"UTC\",\n utc_offset: 0,\n microsecond: {0, 0}\n }\n end\n\n test \"with UTC only database and non UTC datetime emits error\" do\n dt =\n DateTime.from_naive!(~N[2018-08-28 00:00:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n\n assert_raise ArgumentError, fn ->\n DateTime.add(dt, 1, :second)\n end\n end\n\n test \"with other calendars\" do\n assert ~N[2000-01-01 12:34:15.123456]\n |> NaiveDateTime.convert!(Calendar.Holocene)\n |> DateTime.from_naive!(\"Etc/UTC\")\n |> DateTime.add(10, :second) ==\n %DateTime{\n calendar: Calendar.Holocene,\n year: 12000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 25,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n zone_abbr: \"UTC\",\n utc_offset: 0,\n microsecond: {123_456, 6}\n }\n end\n end\n\n describe \"to_iso8601\" do\n test \"to_iso8601/2 with a normal DateTime struct\" do\n datetime = DateTime.from_naive!(~N[2018-07-01 12:34:25.123456], \"Etc/UTC\")\n\n assert DateTime.to_iso8601(datetime) == \"2018-07-01T12:34:25.123456Z\"\n end\n\n test \"to_iso8601/2 with a non-struct map conforming to the Calendar.datetime type\" do\n datetime_map =\n DateTime.from_naive!(~N[2018-07-01 12:34:25.123456], \"Etc/UTC\") |> Map.from_struct()\n\n assert DateTime.to_iso8601(datetime_map) == \"2018-07-01T12:34:25.123456Z\"\n end\n end\n\n describe \"to_date/1\" do\n test \"upcasting\" do\n assert catch_error(DateTime.to_date(~N[2000-02-29 12:23:34]))\n end\n end\n\n describe \"to_time/1\" do\n test \"upcasting\" do\n assert catch_error(DateTime.to_time(~N[2000-02-29 12:23:34]))\n end\n end\n\n describe \"to_naive/1\" do\n test \"upcasting\" do\n assert catch_error(DateTime.to_naive(~N[2000-02-29 12:23:34]))\n end\n end\n\n test \"shift/2\" do\n assert DateTime.shift(~U[2000-01-01 00:00:00Z], year: 1) == ~U[2001-01-01 00:00:00Z]\n assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 1) == ~U[2000-02-01 00:00:00Z]\n assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 1, day: 28) == ~U[2000-02-29 00:00:00Z]\n assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 1, day: 30) == ~U[2000-03-02 00:00:00Z]\n assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 2, day: 29) == ~U[2000-03-30 00:00:00Z]\n\n assert DateTime.shift(~U[2000-01-01 00:00:00Z], microsecond: {4000, 4}) ==\n ~U[2000-01-01 00:00:00.0040Z]\n\n assert DateTime.shift(~U[2000-02-29 00:00:00Z], year: -1) == ~U[1999-02-28 00:00:00Z]\n assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1) == ~U[2000-01-29 00:00:00Z]\n\n assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1, day: -28) ==\n ~U[2000-01-01 00:00:00Z]\n\n assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1, day: -30) ==\n ~U[1999-12-30 00:00:00Z]\n\n assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1, day: -29) ==\n ~U[1999-12-31 00:00:00Z]\n\n datetime =\n DateTime.new!(~D[2018-11-04], ~T[03:00:00], \"America/Los_Angeles\", FakeTimeZoneDatabase)\n\n assert DateTime.shift(datetime, [month: -1], FakeTimeZoneDatabase) ==\n %DateTime{\n calendar: Calendar.ISO,\n year: 2018,\n month: 10,\n day: 4,\n hour: 4,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n time_zone: \"America/Los_Angeles\",\n std_offset: 3600,\n utc_offset: -28800,\n zone_abbr: \"PDT\"\n }\n\n datetime =\n DateTime.new!(~D[2018-11-04], ~T[00:00:00], \"America/Los_Angeles\", FakeTimeZoneDatabase)\n\n assert DateTime.shift(datetime, [hour: 2], FakeTimeZoneDatabase) ==\n %DateTime{\n calendar: Calendar.ISO,\n year: 2018,\n month: 11,\n day: 4,\n hour: 1,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n time_zone: \"America/Los_Angeles\",\n std_offset: 0,\n utc_offset: -28800,\n zone_abbr: \"PST\"\n }\n\n datetime =\n DateTime.new!(~D[2019-03-31], ~T[01:00:00], \"Europe/Copenhagen\", FakeTimeZoneDatabase)\n\n assert DateTime.shift(datetime, [hour: 1], FakeTimeZoneDatabase) ==\n %DateTime{\n calendar: Calendar.ISO,\n year: 2019,\n month: 03,\n day: 31,\n hour: 3,\n minute: 0,\n second: 0,\n microsecond: {0, 0},\n time_zone: \"Europe/Copenhagen\",\n std_offset: 3600,\n utc_offset: 3600,\n zone_abbr: \"CEST\"\n }\n\n assert_raise ArgumentError,\n \"unknown unit :months. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond\",\n fn -> DateTime.shift(~U[2012-01-01 00:00:00Z], months: 12) end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/duration_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule DurationTest do\n use ExUnit.Case, async: true\n doctest Duration\n\n test \"new!/1\" do\n assert Duration.new!(year: 2, month: 1, week: 3) == %Duration{year: 2, month: 1, week: 3}\n assert Duration.new!(microsecond: {20000, 2}) == %Duration{microsecond: {20000, 2}}\n\n duration = %Duration{year: 1}\n assert ^duration = Duration.new!(duration)\n\n assert_raise ArgumentError,\n \"unsupported value nil for :month. Expected an integer\",\n fn -> Duration.new!(month: nil) end\n\n assert_raise ArgumentError,\n \"unknown unit :years. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond\",\n fn -> Duration.new!(years: 1) end\n\n assert_raise ArgumentError,\n \"unsupported value {1, 2, 3} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6\",\n fn -> Duration.new!(microsecond: {1, 2, 3}) end\n\n assert_raise ArgumentError,\n \"unsupported value {100, 7} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6\",\n fn -> Duration.new!(microsecond: {100, 7}) end\n end\n\n test \"add/2\" do\n d1 = %Duration{\n year: 1,\n month: 2,\n week: 3,\n day: 4,\n hour: 5,\n minute: 6,\n second: 7,\n microsecond: {8, 6}\n }\n\n d2 = %Duration{\n year: 8,\n month: 7,\n week: 6,\n day: 5,\n hour: 4,\n minute: 3,\n second: 2,\n microsecond: {1, 6}\n }\n\n assert Duration.add(d1, d2) == %Duration{\n year: 9,\n month: 9,\n week: 9,\n day: 9,\n hour: 9,\n minute: 9,\n second: 9,\n microsecond: {9, 6}\n }\n\n assert Duration.add(d1, d2) == Duration.add(d2, d1)\n\n d1 = %Duration{month: 2, week: 3, day: 4}\n d2 = %Duration{year: 8, day: 2, second: 2}\n\n assert Duration.add(d1, d2) == %Duration{\n year: 8,\n month: 2,\n week: 3,\n day: 6,\n hour: 0,\n minute: 0,\n second: 2,\n microsecond: {0, 0}\n }\n\n d1 = %Duration{microsecond: {1000, 4}}\n d2 = %Duration{microsecond: {5, 6}}\n assert Duration.add(d1, d2) == %Duration{microsecond: {1005, 6}}\n end\n\n test \"subtract/2\" do\n d1 = %Duration{\n year: 1,\n month: 2,\n week: 3,\n day: 4,\n hour: 5,\n minute: 6,\n second: 7,\n microsecond: {8, 6}\n }\n\n d2 = %Duration{\n year: 8,\n month: 7,\n week: 6,\n day: 5,\n hour: 4,\n minute: 3,\n second: 2,\n microsecond: {1, 6}\n }\n\n assert Duration.subtract(d1, d2) == %Duration{\n year: -7,\n month: -5,\n week: -3,\n day: -1,\n hour: 1,\n minute: 3,\n second: 5,\n microsecond: {7, 6}\n }\n\n assert Duration.subtract(d2, d1) == %Duration{\n year: 7,\n month: 5,\n week: 3,\n day: 1,\n hour: -1,\n minute: -3,\n second: -5,\n microsecond: {-7, 6}\n }\n\n assert Duration.subtract(d1, d2) != Duration.subtract(d2, d1)\n\n d1 = %Duration{year: 10, month: 2, week: 3, day: 4}\n d2 = %Duration{year: 8, day: 2, second: 2}\n\n assert Duration.subtract(d1, d2) == %Duration{\n year: 2,\n month: 2,\n week: 3,\n day: 2,\n hour: 0,\n minute: 0,\n second: -2,\n microsecond: {0, 0}\n }\n\n d1 = %Duration{microsecond: {1000, 4}}\n d2 = %Duration{microsecond: {5, 6}}\n assert Duration.subtract(d1, d2) == %Duration{microsecond: {995, 6}}\n end\n\n test \"multiply/2\" do\n duration = %Duration{\n year: 1,\n month: 2,\n week: 3,\n day: 4,\n hour: 5,\n minute: 6,\n second: 7,\n microsecond: {8, 6}\n }\n\n assert Duration.multiply(duration, 3) == %Duration{\n year: 3,\n month: 6,\n week: 9,\n day: 12,\n hour: 15,\n minute: 18,\n second: 21,\n microsecond: {24, 6}\n }\n\n assert Duration.multiply(%Duration{year: 2, day: 4, minute: 5}, 4) ==\n %Duration{\n year: 8,\n month: 0,\n week: 0,\n day: 16,\n hour: 0,\n minute: 20,\n second: 0,\n microsecond: {0, 0}\n }\n end\n\n test \"negate/1\" do\n duration = %Duration{\n year: 1,\n month: 2,\n week: 3,\n day: 4,\n hour: 5,\n minute: 6,\n second: 7,\n microsecond: {8, 6}\n }\n\n assert Duration.negate(duration) == %Duration{\n year: -1,\n month: -2,\n week: -3,\n day: -4,\n hour: -5,\n minute: -6,\n second: -7,\n microsecond: {-8, 6}\n }\n\n assert Duration.negate(%Duration{year: 2, day: 4, minute: 5}) ==\n %Duration{\n year: -2,\n month: 0,\n week: 0,\n day: -4,\n hour: 0,\n minute: -5,\n second: 0,\n microsecond: {0, 0}\n }\n end\n\n test \"from_iso8601/1\" do\n assert Duration.from_iso8601(\"P1Y2M3DT4H5M6S\") ==\n {:ok, %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}}\n\n assert Duration.from_iso8601(\"P3WT5H3M\") == {:ok, %Duration{week: 3, hour: 5, minute: 3}}\n assert Duration.from_iso8601(\"PT5H3M\") == {:ok, %Duration{hour: 5, minute: 3}}\n assert Duration.from_iso8601(\"P1Y2M3D\") == {:ok, %Duration{year: 1, month: 2, day: 3}}\n assert Duration.from_iso8601(\"PT4H5M6S\") == {:ok, %Duration{hour: 4, minute: 5, second: 6}}\n assert Duration.from_iso8601(\"P1Y2M\") == {:ok, %Duration{year: 1, month: 2}}\n assert Duration.from_iso8601(\"P3D\") == {:ok, %Duration{day: 3}}\n assert Duration.from_iso8601(\"PT4H5M\") == {:ok, %Duration{hour: 4, minute: 5}}\n assert Duration.from_iso8601(\"PT6S\") == {:ok, %Duration{second: 6}}\n assert Duration.from_iso8601(\"P2M4Y\") == {:error, :invalid_date_component}\n assert Duration.from_iso8601(\"P4Y2W3Y\") == {:error, :invalid_date_component}\n assert Duration.from_iso8601(\"P5HT4MT3S\") == {:error, :invalid_date_component}\n assert Duration.from_iso8601(\"P5H3HT4M\") == {:error, :invalid_date_component}\n assert Duration.from_iso8601(\"P0.5Y\") == {:error, :invalid_date_component}\n assert Duration.from_iso8601(\"PT1D\") == {:error, :invalid_time_component}\n assert Duration.from_iso8601(\"PT.6S\") == {:error, :invalid_time_component}\n assert Duration.from_iso8601(\"PT0.5H\") == {:error, :invalid_time_component}\n assert Duration.from_iso8601(\"invalid\") == {:error, :invalid_duration}\n end\n\n test \"from_iso8601!/1\" do\n assert Duration.from_iso8601!(\"P1Y2M3DT4H5M6S\") == %Duration{\n year: 1,\n month: 2,\n day: 3,\n hour: 4,\n minute: 5,\n second: 6\n }\n\n assert Duration.from_iso8601!(\"P3WT5H3M\") == %Duration{week: 3, hour: 5, minute: 3}\n assert Duration.from_iso8601!(\"PT5H3M\") == %Duration{hour: 5, minute: 3}\n assert Duration.from_iso8601!(\"P1Y2M3D\") == %Duration{year: 1, month: 2, day: 3}\n assert Duration.from_iso8601!(\"PT4H5M6S\") == %Duration{hour: 4, minute: 5, second: 6}\n assert Duration.from_iso8601!(\"P1Y2M\") == %Duration{year: 1, month: 2}\n assert Duration.from_iso8601!(\"P3D\") == %Duration{day: 3}\n assert Duration.from_iso8601!(\"PT4H5M\") == %Duration{hour: 4, minute: 5}\n assert Duration.from_iso8601!(\"PT6S\") == %Duration{second: 6}\n assert Duration.from_iso8601!(\"PT1,6S\") == %Duration{second: 1, microsecond: {600_000, 1}}\n assert Duration.from_iso8601!(\"PT-1.6S\") == %Duration{second: -1, microsecond: {-600_000, 1}}\n assert Duration.from_iso8601!(\"PT0,6S\") == %Duration{second: 0, microsecond: {600_000, 1}}\n assert Duration.from_iso8601!(\"PT-0,6S\") == %Duration{second: 0, microsecond: {-600_000, 1}}\n assert Duration.from_iso8601!(\"-PT-0,6S\") == %Duration{second: 0, microsecond: {600_000, 1}}\n assert Duration.from_iso8601!(\"-P10DT4H\") == %Duration{day: -10, hour: -4}\n assert Duration.from_iso8601!(\"-P10DT-4H\") == %Duration{day: -10, hour: 4}\n assert Duration.from_iso8601!(\"P-10D\") == %Duration{day: -10}\n assert Duration.from_iso8601!(\"+P10DT-4H\") == %Duration{day: 10, hour: -4}\n assert Duration.from_iso8601!(\"P+10D\") == %Duration{day: 10}\n assert Duration.from_iso8601!(\"-P+10D\") == %Duration{day: -10}\n\n assert Duration.from_iso8601!(\"PT-1.234567S\") == %Duration{\n second: -1,\n microsecond: {-234_567, 6}\n }\n\n assert Duration.from_iso8601!(\"PT1.12345678S\") == %Duration{\n second: 1,\n microsecond: {123_456, 6}\n }\n\n assert Duration.from_iso8601!(\"P3Y4W-3DT-6S\") == %Duration{\n year: 3,\n week: 4,\n day: -3,\n second: -6\n }\n\n assert Duration.from_iso8601!(\"PT-4.23S\") == %Duration{second: -4, microsecond: {-230_000, 2}}\n\n assert_raise ArgumentError,\n ~s/failed to parse duration \"P5H3HT4M\". reason: :invalid_date_component/,\n fn ->\n Duration.from_iso8601!(\"P5H3HT4M\")\n end\n\n assert_raise ArgumentError,\n ~s/failed to parse duration \"P4Y2W3Y\". reason: :invalid_date_component/,\n fn ->\n Duration.from_iso8601!(\"P4Y2W3Y\")\n end\n\n assert_raise ArgumentError,\n ~s/failed to parse duration \"invalid\". reason: :invalid_duration/,\n fn ->\n Duration.from_iso8601!(\"invalid\")\n end\n\n assert_raise ArgumentError,\n ~s/failed to parse duration \"P4.5YT6S\". reason: :invalid_date_component/,\n fn ->\n Duration.from_iso8601!(\"P4.5YT6S\")\n end\n end\n\n test \"to_iso8601/1\" do\n assert %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}\n |> Duration.to_iso8601() == \"P1Y2M3DT4H5M6S\"\n\n assert %Duration{week: 3, hour: 5, minute: 3} |> Duration.to_iso8601() == \"P3WT5H3M\"\n assert %Duration{hour: 5, minute: 3} |> Duration.to_iso8601() == \"PT5H3M\"\n assert %Duration{year: 1, month: 2, day: 3} |> Duration.to_iso8601() == \"P1Y2M3D\"\n assert %Duration{hour: 4, minute: 5, second: 6} |> Duration.to_iso8601() == \"PT4H5M6S\"\n assert %Duration{year: 1, month: 2} |> Duration.to_iso8601() == \"P1Y2M\"\n assert %Duration{day: 3} |> Duration.to_iso8601() == \"P3D\"\n assert %Duration{hour: 4, minute: 5} |> Duration.to_iso8601() == \"PT4H5M\"\n assert %Duration{second: 6} |> Duration.to_iso8601() == \"PT6S\"\n assert %Duration{second: 1, microsecond: {600_000, 1}} |> Duration.to_iso8601() == \"PT1.6S\"\n assert %Duration{second: -1, microsecond: {-600_000, 1}} |> Duration.to_iso8601() == \"PT-1.6S\"\n\n assert %Duration{second: -1, microsecond: {-234_567, 6}} |> Duration.to_iso8601() ==\n \"PT-1.234567S\"\n\n assert %Duration{second: 1, microsecond: {123_456, 6}} |> Duration.to_iso8601() ==\n \"PT1.123456S\"\n\n assert %Duration{year: 3, week: 4, day: -3, second: -6} |> Duration.to_iso8601() ==\n \"P3Y4W-3DT-6S\"\n\n assert %Duration{second: -4, microsecond: {-230_000, 2}} |> Duration.to_iso8601() ==\n \"PT-4.23S\"\n\n assert %Duration{second: -4, microsecond: {230_000, 2}} |> Duration.to_iso8601() ==\n \"PT-3.77S\"\n\n assert %Duration{second: 2, microsecond: {-1_200_000, 4}} |> Duration.to_iso8601() ==\n \"PT0.8000S\"\n\n assert %Duration{second: 1, microsecond: {-1_200_000, 3}} |> Duration.to_iso8601() ==\n \"PT-0.200S\"\n\n assert %Duration{microsecond: {-800_000, 2}} |> Duration.to_iso8601() == \"PT-0.80S\"\n assert %Duration{microsecond: {-800_000, 0}} |> Duration.to_iso8601() == \"PT0S\"\n assert %Duration{microsecond: {-1_200_000, 2}} |> Duration.to_iso8601() == \"PT-1.20S\"\n end\n\n test \"to_string/1\" do\n assert Duration.to_string(%Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}) ==\n \"1a 2mo 3d 4h 5min 6s\"\n\n assert Duration.to_string(%Duration{week: 3, hour: 5, minute: 3}) ==\n \"3wk 5h 3min\"\n\n assert Duration.to_string(%Duration{hour: 5, minute: 3}) ==\n \"5h 3min\"\n\n assert Duration.to_string(%Duration{year: 1, month: 2, day: 3}) ==\n \"1a 2mo 3d\"\n\n assert Duration.to_string(%Duration{hour: 4, minute: 5, second: 6}) ==\n \"4h 5min 6s\"\n\n assert Duration.to_string(%Duration{year: 1, month: 2}) ==\n \"1a 2mo\"\n\n assert Duration.to_string(%Duration{day: 3}) ==\n \"3d\"\n\n assert Duration.to_string(%Duration{hour: 4, minute: 5}) ==\n \"4h 5min\"\n\n assert Duration.to_string(%Duration{second: 6}) ==\n \"6s\"\n\n assert Duration.to_string(%Duration{second: 1, microsecond: {600_000, 1}}) ==\n \"1.6s\"\n\n assert Duration.to_string(%Duration{second: -1, microsecond: {-600_000, 1}}) ==\n \"-1.6s\"\n\n assert Duration.to_string(%Duration{second: -1, microsecond: {-234_567, 6}}) ==\n \"-1.234567s\"\n\n assert Duration.to_string(%Duration{second: 1, microsecond: {123_456, 6}}) ==\n \"1.123456s\"\n\n assert Duration.to_string(%Duration{year: 3, week: 4, day: -3, second: -6}) ==\n \"3a 4wk -3d -6s\"\n\n assert Duration.to_string(%Duration{second: -4, microsecond: {-230_000, 2}}) ==\n \"-4.23s\"\n\n assert Duration.to_string(%Duration{second: -4, microsecond: {230_000, 2}}) ==\n \"-3.77s\"\n\n assert Duration.to_string(%Duration{second: 2, microsecond: {-1_200_000, 4}}) ==\n \"0.8000s\"\n\n assert Duration.to_string(%Duration{second: 1, microsecond: {-1_200_000, 3}}) ==\n \"-0.200s\"\n\n assert Duration.to_string(%Duration{microsecond: {-800_000, 2}}) ==\n \"-0.80s\"\n\n assert Duration.to_string(%Duration{microsecond: {-800_000, 0}}) ==\n \"0s\"\n\n assert Duration.to_string(%Duration{microsecond: {-1_200_000, 2}}) ==\n \"-1.20s\"\n\n assert Duration.to_string(%Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6},\n units: [year: \"year\", month: \"month\", day: \"day\"],\n separator: \"-\"\n ) ==\n \"1year-2month-3day-4h-5min-6s\"\n end\n\n test \"inspect/1\" do\n assert inspect(%Duration{hour: 5, minute: 3}) == \"%Duration{hour: 5, minute: 3}\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/fakes.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule FakeCalendar do\n def time_to_string(hour, minute, second, _), do: \"#{hour}::#{minute}::#{second}\"\n def date_to_string(year, month, day), do: \"#{day}/#{month}/#{year}\"\n\n def naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) do\n date_to_string(year, month, day) <> \"F\" <> time_to_string(hour, minute, second, microsecond)\n end\n\n def datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n time_zone,\n abbr,\n utc_offset,\n std_offset\n ) do\n naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) <>\n \" #{time_zone} #{abbr} #{utc_offset} #{std_offset}\"\n end\n\n def day_rollover_relative_to_midnight_utc, do: {123_456, 123_457}\nend\n\ndefmodule FakeTimeZoneDatabase do\n @behaviour Calendar.TimeZoneDatabase\n\n @time_zone_period_cph_summer_2018 %{\n std_offset: 3600,\n utc_offset: 3600,\n zone_abbr: \"CEST\",\n from_wall: ~N[2018-03-25 03:00:00],\n until_wall: ~N[2018-10-28 03:00:00]\n }\n\n @time_zone_period_cph_winter_2018_2019 %{\n std_offset: 0,\n utc_offset: 3600,\n zone_abbr: \"CET\",\n from_wall: ~N[2018-10-28 02:00:00],\n until_wall: ~N[2019-03-31 02:00:00]\n }\n\n @time_zone_period_cph_summer_2019 %{\n std_offset: 3600,\n utc_offset: 3600,\n zone_abbr: \"CEST\",\n from_wall: ~N[2019-03-31 03:00:00],\n until_wall: ~N[2019-10-27 03:00:00]\n }\n\n @time_zone_period_usla_summer_2018 %{\n std_offset: 3600,\n utc_offset: -28800,\n zone_abbr: \"PDT\",\n from_wall: ~N[2018-03-11 02:00:00],\n until_wall: ~N[2018-11-04 02:00:00]\n }\n\n @time_zone_period_usla_winter_2018_2019 %{\n std_offset: 0,\n utc_offset: -28800,\n zone_abbr: \"PST\",\n from_wall: ~N[2018-11-04 02:00:00],\n until_wall: ~N[2019-03-10 03:00:00]\n }\n\n @spec time_zone_period_from_utc_iso_days(Calendar.iso_days(), Calendar.time_zone()) ::\n {:ok, TimeZoneDatabase.time_zone_period()} | {:error, :time_zone_not_found}\n @impl true\n def time_zone_period_from_utc_iso_days(iso_days, time_zone) do\n {:ok, ndt} = naive_datetime_from_iso_days(iso_days)\n time_zone_periods_from_utc(time_zone, NaiveDateTime.to_erl(ndt))\n end\n\n @spec time_zone_periods_from_wall_datetime(Calendar.naive_datetime(), Calendar.time_zone()) ::\n {:ok, TimeZoneDatabase.time_zone_period()}\n | {:ambiguous, TimeZoneDatabase.time_zone_period(), TimeZoneDatabase.time_zone_period()}\n | {:gap,\n {TimeZoneDatabase.time_zone_period(), TimeZoneDatabase.time_zone_period_limit()},\n {TimeZoneDatabase.time_zone_period(), TimeZoneDatabase.time_zone_period_limit()}}\n | {:error, :time_zone_not_found}\n @impl true\n def time_zone_periods_from_wall_datetime(naive_datetime, time_zone) do\n time_zone_periods_from_wall(time_zone, NaiveDateTime.to_erl(naive_datetime))\n end\n\n defp time_zone_periods_from_utc(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2018, 3, 25}, {1, 0, 0}} and\n erl_datetime < {{2018, 10, 28}, {3, 0, 0}} do\n {:ok, @time_zone_period_cph_summer_2018}\n end\n\n defp time_zone_periods_from_utc(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2018, 10, 28}, {2, 0, 0}} and\n erl_datetime < {{2019, 3, 31}, {1, 0, 0}} do\n {:ok, @time_zone_period_cph_winter_2018_2019}\n end\n\n defp time_zone_periods_from_utc(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2019, 3, 31}, {1, 0, 0}} and\n erl_datetime < {{2019, 10, 28}, {3, 0, 0}} do\n {:ok, @time_zone_period_cph_summer_2019}\n end\n\n defp time_zone_periods_from_utc(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2015, 3, 29}, {1, 0, 0}} and\n erl_datetime < {{2015, 10, 25}, {1, 0, 0}} do\n {:ok,\n %{\n std_offset: 3600,\n utc_offset: 3600,\n zone_abbr: \"CEST\"\n }}\n end\n\n defp time_zone_periods_from_utc(\"America/Los_Angeles\", erl_datetime)\n when erl_datetime >= {{2018, 3, 11}, {2, 0, 0}} and\n erl_datetime < {{2018, 11, 4}, {2, 0, 0}} do\n {:ok, @time_zone_period_usla_summer_2018}\n end\n\n defp time_zone_periods_from_utc(\"America/Los_Angeles\", erl_datetime)\n when erl_datetime >= {{2018, 11, 4}, {2, 0, 0}} and\n erl_datetime < {{2019, 3, 10}, {3, 0, 0}} do\n {:ok, @time_zone_period_usla_winter_2018_2019}\n end\n\n defp time_zone_periods_from_utc(\"Etc/UTC\", _erl_datetime) do\n {:ok,\n %{\n std_offset: 0,\n utc_offset: 0,\n zone_abbr: \"UTC\"\n }}\n end\n\n defp time_zone_periods_from_utc(time_zone, _) when time_zone != \"Europe/Copenhagen\" do\n {:error, :time_zone_not_found}\n end\n\n defp time_zone_periods_from_wall(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2019, 3, 31}, {2, 0, 0}} and\n erl_datetime < {{2019, 3, 31}, {3, 0, 0}} do\n {:gap,\n {@time_zone_period_cph_winter_2018_2019, @time_zone_period_cph_winter_2018_2019.until_wall},\n {@time_zone_period_cph_summer_2019, @time_zone_period_cph_summer_2019.from_wall}}\n end\n\n defp time_zone_periods_from_wall(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime < {{2018, 10, 28}, {3, 0, 0}} and\n erl_datetime >= {{2018, 10, 28}, {2, 0, 0}} do\n {:ambiguous, @time_zone_period_cph_summer_2018, @time_zone_period_cph_winter_2018_2019}\n end\n\n defp time_zone_periods_from_wall(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2018, 3, 25}, {3, 0, 0}} and\n erl_datetime < {{2018, 10, 28}, {3, 0, 0}} do\n {:ok, @time_zone_period_cph_summer_2018}\n end\n\n defp time_zone_periods_from_wall(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2018, 10, 28}, {2, 0, 0}} and\n erl_datetime < {{2019, 3, 31}, {2, 0, 0}} do\n {:ok, @time_zone_period_cph_winter_2018_2019}\n end\n\n defp time_zone_periods_from_wall(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2019, 3, 31}, {3, 0, 0}} and\n erl_datetime < {{2019, 10, 27}, {3, 0, 0}} do\n {:ok, @time_zone_period_cph_summer_2019}\n end\n\n defp time_zone_periods_from_wall(\"America/Los_Angeles\", erl_datetime)\n when erl_datetime >= {{2018, 3, 11}, {2, 0, 0}} and\n erl_datetime < {{2018, 11, 4}, {2, 0, 0}} do\n {:ok, @time_zone_period_usla_summer_2018}\n end\n\n defp time_zone_periods_from_wall(\"America/Los_Angeles\", erl_datetime)\n when erl_datetime >= {{2018, 11, 4}, {3, 0, 0}} and\n erl_datetime < {{2019, 3, 10}, {3, 0, 0}} do\n {:ok, @time_zone_period_usla_winter_2018_2019}\n end\n\n defp time_zone_periods_from_wall(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2015, 3, 29}, {3, 0, 0}} and\n erl_datetime < {{2015, 10, 25}, {3, 0, 0}} do\n {:ok,\n %{\n std_offset: 3600,\n utc_offset: 3600,\n zone_abbr: \"CEST\"\n }}\n end\n\n defp time_zone_periods_from_wall(\"Europe/Copenhagen\", erl_datetime)\n when erl_datetime >= {{2090, 3, 26}, {3, 0, 0}} and\n erl_datetime < {{2090, 10, 29}, {3, 0, 0}} do\n {:ok,\n %{\n std_offset: 3600,\n utc_offset: 3600,\n zone_abbr: \"CEST\"\n }}\n end\n\n defp time_zone_periods_from_wall(\"Etc/UTC\", _erl_datetime) do\n {:ok,\n %{\n std_offset: 0,\n utc_offset: 0,\n zone_abbr: \"UTC\"\n }}\n end\n\n defp time_zone_periods_from_wall(time_zone, _) when time_zone != \"Europe/Copenhagen\" do\n {:error, :time_zone_not_found}\n end\n\n defp naive_datetime_from_iso_days(iso_days) do\n {year, month, day, hour, minute, second, microsecond} =\n Calendar.ISO.naive_datetime_from_iso_days(iso_days)\n\n NaiveDateTime.new(year, month, day, hour, minute, second, microsecond)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/holocene.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\ndefmodule Calendar.Holocene do\n # This calendar is used to test conversions between calendars.\n # It implements the Holocene calendar, which is based on the\n # Proleptic Gregorian calendar with every year + 10000.\n\n @behaviour Calendar\n\n def date(year, month, day) do\n %Date{year: year, month: month, day: day, calendar: __MODULE__}\n end\n\n def naive_datetime(year, month, day, hour, minute, second, microsecond \\\\ {0, 0}) do\n %NaiveDateTime{\n year: year,\n month: month,\n day: day,\n hour: hour,\n minute: minute,\n second: second,\n microsecond: microsecond,\n calendar: __MODULE__\n }\n end\n\n @impl true\n def date_to_string(year, month, day) do\n \"#{year}-#{zero_pad(month, 2)}-#{zero_pad(day, 2)}\"\n end\n\n @impl true\n def naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) do\n \"#{year}-#{zero_pad(month, 2)}-#{zero_pad(day, 2)}\" <>\n Calendar.ISO.time_to_string(hour, minute, second, microsecond)\n end\n\n @impl true\n def datetime_to_string(\n year,\n month,\n day,\n hour,\n minute,\n second,\n microsecond,\n _time_zone,\n zone_abbr,\n _utc_offset,\n _std_offset\n ) do\n \"#{year}-#{zero_pad(month, 2)}-#{zero_pad(day, 2)}\" <>\n Calendar.ISO.time_to_string(hour, minute, second, microsecond) <>\n \" #{zone_abbr}\"\n end\n\n @impl true\n defdelegate time_to_string(hour, minute, second, microsecond), to: Calendar.ISO\n\n @impl true\n def day_rollover_relative_to_midnight_utc(), do: {0, 1}\n\n @impl true\n def naive_datetime_from_iso_days(entry) do\n {year, month, day, hour, minute, second, microsecond} =\n Calendar.ISO.naive_datetime_from_iso_days(entry)\n\n {year + 10000, month, day, hour, minute, second, microsecond}\n end\n\n @impl true\n def naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) do\n Calendar.ISO.naive_datetime_to_iso_days(\n year - 10000,\n month,\n day,\n hour,\n minute,\n second,\n microsecond\n )\n end\n\n defp zero_pad(val, count) when val >= 0 do\n String.pad_leading(\"#{val}\", count, [\"0\"])\n end\n\n defp zero_pad(val, count) do\n \"-\" <> zero_pad(-val, count)\n end\n\n @impl true\n def parse_date(string) do\n {year, month, day} =\n string\n |> String.split(\"-\")\n |> Enum.map(&String.to_integer/1)\n |> List.to_tuple()\n\n if valid_date?(year, month, day) do\n {:ok, {year, month, day}}\n else\n {:error, :invalid_date}\n end\n end\n\n @impl true\n def valid_date?(year, month, day) do\n :calendar.valid_date(year, month, day)\n end\n\n @impl true\n defdelegate parse_time(string), to: Calendar.ISO\n\n @impl true\n defdelegate parse_naive_datetime(string), to: Calendar.ISO\n\n @impl true\n defdelegate parse_utc_datetime(string), to: Calendar.ISO\n\n @impl true\n defdelegate time_from_day_fraction(day_fraction), to: Calendar.ISO\n\n @impl true\n defdelegate time_to_day_fraction(hour, minute, second, microsecond), to: Calendar.ISO\n\n @impl true\n defdelegate leap_year?(year), to: Calendar.ISO\n\n @impl true\n defdelegate days_in_month(year, month), to: Calendar.ISO\n\n @impl true\n defdelegate months_in_year(year), to: Calendar.ISO\n\n @impl true\n defdelegate day_of_week(year, month, day, starting_on), to: Calendar.ISO\n\n @impl true\n defdelegate day_of_year(year, month, day), to: Calendar.ISO\n\n @impl true\n defdelegate quarter_of_year(year, month, day), to: Calendar.ISO\n\n @impl true\n defdelegate year_of_era(year, month, day), to: Calendar.ISO\n\n @impl true\n defdelegate day_of_era(year, month, day), to: Calendar.ISO\n\n @impl true\n defdelegate valid_time?(hour, minute, second, microsecond), to: Calendar.ISO\n\n @impl true\n defdelegate iso_days_to_beginning_of_day(iso_days), to: Calendar.ISO\n\n @impl true\n defdelegate iso_days_to_end_of_day(iso_days), to: Calendar.ISO\n\n # The Holocene calendar extends most year and day count guards implemented in the ISO calendars.\n @impl true\n def shift_date(_year, _month, _day, _duration) do\n raise \"shift_date/4 not implemented\"\n end\n\n @impl true\n def shift_naive_datetime(_year, _month, _day, _hour, _minute, _second, _microsecond, _duration) do\n raise \"shift_naive_datetime/8 not implemented\"\n end\n\n @impl true\n def shift_time(_hour, _minute, _second, _microsecond, _duration) do\n raise \"shift_time/5 not implemented\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/iso_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Calendar.ISOTest do\n use ExUnit.Case, async: true\n doctest Calendar.ISO\n\n describe \"date_from_iso_days\" do\n test \"with positive dates\" do\n assert {0, 1, 1} == iso_day_roundtrip(0, 1, 1)\n assert {0, 12, 31} == iso_day_roundtrip(0, 12, 31)\n assert {1, 12, 31} == iso_day_roundtrip(1, 12, 31)\n assert {4, 1, 1} == iso_day_roundtrip(4, 1, 1)\n assert {4, 12, 31} == iso_day_roundtrip(4, 12, 31)\n assert {9999, 12, 31} == iso_day_roundtrip(9999, 12, 31)\n assert {9999, 1, 1} == iso_day_roundtrip(9999, 1, 1)\n assert {9996, 12, 31} == iso_day_roundtrip(9996, 12, 31)\n assert {9996, 1, 1} == iso_day_roundtrip(9996, 1, 1)\n end\n\n test \"with negative dates\" do\n assert {-1, 1, 1} == iso_day_roundtrip(-1, 1, 1)\n assert {-1, 12, 31} == iso_day_roundtrip(-1, 12, 31)\n assert {-1, 12, 31} == iso_day_roundtrip(-1, 12, 31)\n assert {-2, 1, 1} == iso_day_roundtrip(-2, 1, 1)\n assert {-5, 12, 31} == iso_day_roundtrip(-5, 12, 31)\n\n assert {-4, 1, 1} == iso_day_roundtrip(-4, 1, 1)\n assert {-4, 12, 31} == iso_day_roundtrip(-4, 12, 31)\n\n assert {-9999, 12, 31} == iso_day_roundtrip(-9999, 12, 31)\n assert {-9996, 12, 31} == iso_day_roundtrip(-9996, 12, 31)\n\n assert {-9996, 12, 31} == iso_day_roundtrip(-9996, 12, 31)\n assert {-9996, 1, 1} == iso_day_roundtrip(-9996, 1, 1)\n end\n end\n\n describe \"date_to_string/4\" do\n test \"regular use\" do\n assert Calendar.ISO.date_to_string(1000, 1, 1, :basic) == \"10000101\"\n assert Calendar.ISO.date_to_string(1000, 1, 1, :extended) == \"1000-01-01\"\n\n assert Calendar.ISO.date_to_string(-123, 1, 1, :basic) == \"-01230101\"\n assert Calendar.ISO.date_to_string(-123, 1, 1, :extended) == \"-0123-01-01\"\n end\n\n test \"handles years > 9999\" do\n assert Calendar.ISO.date_to_string(10000, 1, 1, :basic) == \"100000101\"\n assert Calendar.ISO.date_to_string(10000, 1, 1, :extended) == \"10000-01-01\"\n end\n end\n\n describe \"naive_datetime_to_iso_days/7\" do\n test \"raises with invalid dates\" do\n assert_raise ArgumentError, \"invalid date: 2018-02-30\", fn ->\n Calendar.ISO.naive_datetime_to_iso_days(2018, 2, 30, 0, 0, 0, {0, 0})\n end\n\n assert_raise ArgumentError, \"invalid date: 2017-11--03\", fn ->\n Calendar.ISO.naive_datetime_to_iso_days(2017, 11, -3, 0, 0, 0, {0, 0})\n end\n end\n end\n\n describe \"day_of_week/4\" do\n test \"raises with invalid dates\" do\n assert_raise ArgumentError, \"invalid date: 2018-02-30\", fn ->\n Calendar.ISO.day_of_week(2018, 2, 30, :default)\n end\n\n assert_raise ArgumentError, \"invalid date: 2017-11-00\", fn ->\n Calendar.ISO.day_of_week(2017, 11, 0, :default)\n end\n end\n end\n\n describe \"day_of_era/3\" do\n test \"raises with invalid dates\" do\n assert_raise ArgumentError, \"invalid date: 2018-02-30\", fn ->\n Calendar.ISO.day_of_era(2018, 2, 30)\n end\n\n assert_raise ArgumentError, \"invalid date: 2017-11-00\", fn ->\n Calendar.ISO.day_of_era(2017, 11, 0)\n end\n end\n end\n\n describe \"day_of_year/3\" do\n test \"raises with invalid dates\" do\n assert_raise ArgumentError, \"invalid date: 2018-02-30\", fn ->\n Calendar.ISO.day_of_year(2018, 2, 30)\n end\n\n assert_raise ArgumentError, \"invalid date: 2017-11-00\", fn ->\n Calendar.ISO.day_of_year(2017, 11, 0)\n end\n end\n end\n\n test \"year_of_era/3\" do\n # Compatibility tests for year_of_era/1\n assert Calendar.ISO.year_of_era(-9999) == {10000, 0}\n assert Calendar.ISO.year_of_era(-1) == {2, 0}\n assert Calendar.ISO.year_of_era(0) == {1, 0}\n assert Calendar.ISO.year_of_era(1) == {1, 1}\n assert Calendar.ISO.year_of_era(1984) == {1984, 1}\n\n assert Calendar.ISO.year_of_era(-9999, 1, 1) == {10000, 0}\n assert Calendar.ISO.year_of_era(-1, 1, 1) == {2, 0}\n assert Calendar.ISO.year_of_era(0, 12, 1) == {1, 0}\n assert Calendar.ISO.year_of_era(1, 12, 1) == {1, 1}\n assert Calendar.ISO.year_of_era(1984, 12, 1) == {1984, 1}\n\n random_positive_year = Enum.random(1..9999)\n assert Calendar.ISO.year_of_era(random_positive_year, 1, 1) == {random_positive_year, 1}\n end\n\n defp iso_day_roundtrip(year, month, day) do\n iso_days = Calendar.ISO.date_to_iso_days(year, month, day)\n Calendar.ISO.date_from_iso_days(iso_days)\n end\n\n describe \"parse_date/1\" do\n test \"supports both only extended format by default\" do\n assert Calendar.ISO.parse_date(\"20150123\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_date(\"2015-01-23\") == {:ok, {2015, 1, 23}}\n end\n end\n\n describe \"parse_date/2\" do\n test \"allows enforcing basic formats\" do\n assert Calendar.ISO.parse_date(\"20150123\", :basic) == {:ok, {2015, 1, 23}}\n assert Calendar.ISO.parse_date(\"2015-01-23\", :basic) == {:error, :invalid_format}\n end\n\n test \"allows enforcing extended formats\" do\n assert Calendar.ISO.parse_date(\"20150123\", :extended) == {:error, :invalid_format}\n assert Calendar.ISO.parse_date(\"2015-01-23\", :extended) == {:ok, {2015, 1, 23}}\n end\n end\n\n describe \"parse_time/1\" do\n test \"supports only extended format by default\" do\n assert Calendar.ISO.parse_time(\"235007\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"23:50:07\") == {:ok, {23, 50, 7, {0, 0}}}\n end\n\n test \"ignores offset data but requires valid ones\" do\n assert Calendar.ISO.parse_time(\"23:50:07Z\") == {:ok, {23, 50, 7, {0, 0}}}\n assert Calendar.ISO.parse_time(\"23:50:07+01:00\") == {:ok, {23, 50, 7, {0, 0}}}\n\n assert Calendar.ISO.parse_time(\"2015-01-23 23:50-00:00\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"2015-01-23 23:50-00:60\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"2015-01-23 23:50-24:00\") == {:error, :invalid_format}\n end\n\n test \"supports either comma or period millisecond delimiters\" do\n assert Calendar.ISO.parse_time(\"23:50:07,012345\") == {:ok, {23, 50, 7, {12345, 6}}}\n assert Calendar.ISO.parse_time(\"23:50:07.012345\") == {:ok, {23, 50, 7, {12345, 6}}}\n end\n\n test \"only supports reduced precision for milliseconds\" do\n assert Calendar.ISO.parse_time(\"23:50:07.012345\") == {:ok, {23, 50, 7, {12345, 6}}}\n assert Calendar.ISO.parse_time(\"23:50:07\") == {:ok, {23, 50, 7, {0, 0}}}\n assert Calendar.ISO.parse_time(\"23:50\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"23\") == {:error, :invalid_format}\n end\n\n test \"supports various millisecond precisions\" do\n assert Calendar.ISO.parse_time(\"23:50:07.012345\") == {:ok, {23, 50, 7, {12345, 6}}}\n assert Calendar.ISO.parse_time(\"23:50:07.0123\") == {:ok, {23, 50, 7, {12300, 4}}}\n assert Calendar.ISO.parse_time(\"23:50:07.01\") == {:ok, {23, 50, 7, {10000, 2}}}\n assert Calendar.ISO.parse_time(\"23:50:07.0\") == {:ok, {23, 50, 7, {0, 1}}}\n assert Calendar.ISO.parse_time(\"23:50:07\") == {:ok, {23, 50, 7, {0, 0}}}\n end\n\n test \"truncates extra millisecond precision\" do\n assert Calendar.ISO.parse_time(\"23:50:07.012345\") == {:ok, {23, 50, 7, {12345, 6}}}\n assert Calendar.ISO.parse_time(\"23:50:07.0123456\") == {:ok, {23, 50, 7, {12345, 6}}}\n end\n\n test \"rejects strings with formatting errors\" do\n assert Calendar.ISO.parse_time(\"23:50:07A\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"23:50:07.\") == {:error, :invalid_format}\n end\n\n test \"refuses to parse the wrong thing\" do\n assert Calendar.ISO.parse_time(\"2015:01:23 23-50-07\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"2015-01-23 23:50:07\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"2015:01:23T23-50-07\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"2015-01-23T23:50:07\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"2015:01:23\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"2015-01-23\") == {:error, :invalid_format}\n end\n\n test \"recognizes invalid times\" do\n assert Calendar.ISO.parse_time(\"23:59:61\") == {:error, :invalid_time}\n assert Calendar.ISO.parse_time(\"23:61:59\") == {:error, :invalid_time}\n assert Calendar.ISO.parse_time(\"25:59:59\") == {:error, :invalid_time}\n end\n end\n\n describe \"parse_time/2\" do\n test \"allows enforcing basic formats\" do\n assert Calendar.ISO.parse_time(\"235007\", :basic) == {:ok, {23, 50, 7, {0, 0}}}\n assert Calendar.ISO.parse_time(\"23:50:07\", :basic) == {:error, :invalid_format}\n end\n\n test \"allows enforcing extended formats\" do\n assert Calendar.ISO.parse_time(\"235007\", :extended) == {:error, :invalid_format}\n assert Calendar.ISO.parse_time(\"23:50:07\", :extended) == {:ok, {23, 50, 7, {0, 0}}}\n end\n end\n\n describe \"parse_naive_datetime/1\" do\n test \"rejects strings with formatting errors\" do\n assert Calendar.ISO.parse_naive_datetime(\"2015:01:23 23-50-07\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23P23:50:07\") == {:error, :invalid_format}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07A\") ==\n {:error, :invalid_format}\n end\n\n test \"recognizes invalid dates and times\" do\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:61\") == {:error, :invalid_time}\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-32 23:50:07\") == {:error, :invalid_date}\n end\n\n test \"ignores offset data but requires valid ones\" do\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07.123+02:30\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07.123+00:00\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07.123-02:30\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07.123-00:00\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07.123-00:60\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07.123-24:00\") ==\n {:error, :invalid_format}\n end\n\n test \"supports both spaces and 'T' as datetime separators\" do\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23T23:50:07\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}\n end\n\n test \"supports only extended format by default\" do\n assert Calendar.ISO.parse_naive_datetime(\"20150123 235007.123\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07.123\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}\n end\n\n test \"errors on mixed basic and extended formats\" do\n assert Calendar.ISO.parse_naive_datetime(\"20150123 23:50:07.123\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23 235007.123\") ==\n {:error, :invalid_format}\n end\n end\n\n describe \"parse_naive_datetime/2\" do\n test \"allows enforcing basic formats\" do\n assert Calendar.ISO.parse_naive_datetime(\"20150123 235007.123\", :basic) ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07.123\", :basic) ==\n {:error, :invalid_format}\n end\n\n test \"allows enforcing extended formats\" do\n assert Calendar.ISO.parse_naive_datetime(\"20150123 235007.123\", :extended) ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_naive_datetime(\"2015-01-23 23:50:07.123\", :extended) ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}\n end\n end\n\n describe \"parse_utc_datetime/1\" do\n test \"rejects strings with formatting errors\" do\n assert Calendar.ISO.parse_utc_datetime(\"2015:01:23 23-50-07Z\") == {:error, :invalid_format}\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23P23:50:07Z\") == {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07A\") == {:error, :invalid_format}\n end\n\n test \"recognizes invalid dates, times, and offsets\" do\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07\") == {:error, :missing_offset}\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:61Z\") == {:error, :invalid_time}\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-32 23:50:07Z\") == {:error, :invalid_date}\n end\n\n test \"interprets offset data\" do\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07.123+02:30\") ==\n {:ok, {2015, 1, 23, 21, 20, 7, {123_000, 3}}, 9000}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07.123+00:00\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07.123-02:30\") ==\n {:ok, {2015, 1, 24, 2, 20, 7, {123_000, 3}}, -9000}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07.123-00:00\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07.123-00:60\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07.123-24:00\") ==\n {:error, :invalid_format}\n end\n\n test \"supports both spaces and 'T' as datetime separators\" do\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07Z\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23T23:50:07Z\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}\n end\n\n test \"supports only extended format by default\" do\n assert Calendar.ISO.parse_utc_datetime(\"20150123 235007.123Z\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07.123Z\") ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}\n end\n\n test \"errors on mixed basic and extended formats\" do\n assert Calendar.ISO.parse_utc_datetime(\"20150123 23:50:07.123Z\") ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 235007.123Z\") ==\n {:error, :invalid_format}\n end\n end\n\n describe \"parse_utc_datetime/2\" do\n test \"allows enforcing basic formats\" do\n assert Calendar.ISO.parse_utc_datetime(\"20150123 235007.123Z\", :basic) ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07.123Z\", :basic) ==\n {:error, :invalid_format}\n end\n\n test \"allows enforcing extended formats\" do\n assert Calendar.ISO.parse_utc_datetime(\"20150123 235007.123Z\", :extended) ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 23:50:07.123Z\", :extended) ==\n {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}\n end\n\n test \"errors on mixed basic and extended formats\" do\n assert Calendar.ISO.parse_utc_datetime(\"20150123 23:50:07.123Z\", :basic) ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"20150123 23:50:07.123Z\", :extended) ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 235007.123Z\", :basic) ==\n {:error, :invalid_format}\n\n assert Calendar.ISO.parse_utc_datetime(\"2015-01-23 235007.123Z\", :extended) ==\n {:error, :invalid_format}\n end\n end\n\n test \"shift_date/2\" do\n assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!([])) == {2024, 3, 2}\n assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(year: 1)) == {2025, 3, 2}\n assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(month: 2)) == {2024, 5, 2}\n assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(week: 3)) == {2024, 3, 23}\n assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(day: 5)) == {2024, 3, 7}\n\n assert Calendar.ISO.shift_date(0, 1, 1, Duration.new!(month: 1)) == {0, 2, 1}\n assert Calendar.ISO.shift_date(0, 1, 1, Duration.new!(year: 1)) == {1, 1, 1}\n assert Calendar.ISO.shift_date(0, 1, 1, Duration.new!(year: -2, month: 2)) == {-2, 3, 1}\n assert Calendar.ISO.shift_date(-4, 1, 1, Duration.new!(year: -1)) == {-5, 1, 1}\n\n assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(year: 1, month: 2, week: 3, day: 5)) ==\n {2025, 5, 28}\n\n assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(year: -1, month: -2, week: -3)) ==\n {2022, 12, 12}\n\n assert Calendar.ISO.shift_date(2020, 2, 28, Duration.new!(day: 1)) == {2020, 2, 29}\n assert Calendar.ISO.shift_date(2020, 2, 29, Duration.new!(year: 1)) == {2021, 2, 28}\n assert Calendar.ISO.shift_date(2024, 3, 31, Duration.new!(month: -1)) == {2024, 2, 29}\n assert Calendar.ISO.shift_date(2024, 3, 31, Duration.new!(month: -2)) == {2024, 1, 31}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 1)) == {2024, 2, 29}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 2)) == {2024, 3, 31}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 3)) == {2024, 4, 30}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 4)) == {2024, 5, 31}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 5)) == {2024, 6, 30}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 6)) == {2024, 7, 31}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 7)) == {2024, 8, 31}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 8)) == {2024, 9, 30}\n assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 9)) == {2024, 10, 31}\n end\n\n test \"shift_naive_datetime/2\" do\n assert Calendar.ISO.shift_naive_datetime(\n 2024,\n 3,\n 2,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!([])\n ) == {2024, 3, 2, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 1,\n 1,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(year: 1)\n ) == {2001, 1, 1, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 1,\n 1,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: 1)\n ) == {2000, 2, 1, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 1,\n 1,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: 1, day: 28)\n ) == {2000, 2, 29, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 1,\n 1,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: 1, day: 30)\n ) == {2000, 3, 2, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 1,\n 1,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: 2, day: 29)\n ) == {2000, 3, 30, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 2,\n 29,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(year: -1)\n ) == {1999, 2, 28, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 2,\n 29,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: -1)\n ) == {2000, 1, 29, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 2,\n 29,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: -1, day: -28)\n ) == {2000, 1, 1, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 2,\n 29,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: -1, day: -30)\n ) == {1999, 12, 30, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 2,\n 29,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(month: -1, day: -29)\n ) == {1999, 12, 31, 0, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 1,\n 1,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(hour: 12)\n ) == {2000, 1, 1, 12, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_naive_datetime(\n 2000,\n 1,\n 1,\n 0,\n 0,\n 0,\n {0, 0},\n Duration.new!(minute: -65)\n ) == {1999, 12, 31, 22, 55, 0, {0, 0}}\n end\n\n test \"shift_time/2\" do\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(hour: 1)) == {1, 0, 0, {0, 0}}\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(hour: -1)) == {23, 0, 0, {0, 0}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(minute: 30)) ==\n {0, 30, 0, {0, 0}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(minute: -30)) ==\n {23, 30, 0, {0, 0}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(second: 30)) ==\n {0, 0, 30, {0, 0}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(second: -30)) ==\n {23, 59, 30, {0, 0}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {100, 6})) ==\n {0, 0, 0, {100, 6}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {-100, 6})) ==\n {23, 59, 59, {999_900, 6}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {2000, 4})) ==\n {0, 0, 0, {2000, 4}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {-2000, 4})) ==\n {23, 59, 59, {998_000, 4}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {3500, 6}, Duration.new!(microsecond: {-2000, 4})) ==\n {0, 0, 0, {1500, 4}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {3500, 4}, Duration.new!(minute: 5)) ==\n {0, 5, 0, {3500, 4}}\n\n assert Calendar.ISO.shift_time(0, 0, 0, {3500, 6}, Duration.new!(hour: 4)) ==\n {4, 0, 0, {3500, 6}}\n\n assert Calendar.ISO.shift_time(\n 23,\n 59,\n 59,\n {999_900, 6},\n Duration.new!(hour: 4, microsecond: {100, 6})\n ) == {4, 0, 0, {0, 6}}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/naive_datetime_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\nCode.require_file(\"holocene.exs\", __DIR__)\nCode.require_file(\"fakes.exs\", __DIR__)\n\ndefmodule NaiveDateTimeTest do\n use ExUnit.Case, async: true\n doctest NaiveDateTime\n\n test \"sigil_N\" do\n assert ~N[2000-01-01T12:34:56] ==\n %NaiveDateTime{\n calendar: Calendar.ISO,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56\n }\n\n assert ~N[2000-01-01T12:34:56 Calendar.Holocene] ==\n %NaiveDateTime{\n calendar: Calendar.Holocene,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56\n }\n\n assert ~N[2000-01-01 12:34:56] ==\n %NaiveDateTime{\n calendar: Calendar.ISO,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56\n }\n\n assert ~N[2000-01-01 12:34:56 Calendar.Holocene] ==\n %NaiveDateTime{\n calendar: Calendar.Holocene,\n year: 2000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 56\n }\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-50-50T12:34:56\" as NaiveDateTime for Calendar.ISO, reason: :invalid_date/,\n fn -> Code.eval_string(\"~N[2001-50-50T12:34:56]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:65\" as NaiveDateTime for Calendar.ISO, reason: :invalid_time/,\n fn -> Code.eval_string(\"~N[2001-01-01T12:34:65]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"20010101 123456\" as NaiveDateTime for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(~s{~N[20010101 123456]}) end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01 12:34:56 notalias\" as NaiveDateTime for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(\"~N[2001-01-01 12:34:56 notalias]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:56 notalias\" as NaiveDateTime for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(\"~N[2001-01-01T12:34:56 notalias]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-50-50T12:34:56\" as NaiveDateTime for Calendar.Holocene, reason: :invalid_date/,\n fn -> Code.eval_string(\"~N[2001-50-50T12:34:56 Calendar.Holocene]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"2001-01-01T12:34:65\" as NaiveDateTime for Calendar.Holocene, reason: :invalid_time/,\n fn -> Code.eval_string(\"~N[2001-01-01T12:34:65 Calendar.Holocene]\") end\n\n assert_raise UndefinedFunctionError, fn ->\n Code.eval_string(\"~N[2001-01-01 12:34:56 UnknownCalendar]\")\n end\n\n assert_raise UndefinedFunctionError, fn ->\n Code.eval_string(\"~N[2001-01-01T12:34:56 UnknownCalendar]\")\n end\n end\n\n test \"to_string/1\" do\n assert to_string(~N[2000-01-01 23:00:07.005]) == \"2000-01-01 23:00:07.005\"\n assert NaiveDateTime.to_string(~N[2000-01-01 23:00:07.005]) == \"2000-01-01 23:00:07.005\"\n\n ndt = %{~N[2000-01-01 23:00:07.005] | calendar: FakeCalendar}\n assert to_string(ndt) == \"1/1/2000F23::0::7\"\n end\n\n test \"inspect/1\" do\n assert inspect(~N[2000-01-01 23:00:07.005]) == \"~N[2000-01-01 23:00:07.005]\"\n assert inspect(~N[-0100-12-31 23:00:07.005]) == \"~N[-0100-12-31 23:00:07.005]\"\n\n assert inspect(%{~N[2000-01-01 23:00:07.005] | year: 99999}) ==\n \"NaiveDateTime.new!(99999, 1, 1, 23, 0, 7, {5000, 3})\"\n\n ndt = %{~N[2000-01-01 23:00:07.005] | calendar: FakeCalendar}\n assert inspect(ndt) == \"~N[1/1/2000F23::0::7 FakeCalendar]\"\n end\n\n test \"compare/2\" do\n ndt1 = ~N[2000-04-16 13:30:15.0049]\n ndt2 = ~N[2000-04-16 13:30:15.0050]\n ndt3 = ~N[2001-04-16 13:30:15.0050]\n ndt4 = ~N[-0001-04-16 13:30:15.004]\n assert NaiveDateTime.compare(ndt1, ndt1) == :eq\n assert NaiveDateTime.compare(ndt1, ndt2) == :lt\n assert NaiveDateTime.compare(ndt2, ndt1) == :gt\n assert NaiveDateTime.compare(ndt3, ndt1) == :gt\n assert NaiveDateTime.compare(ndt3, ndt2) == :gt\n assert NaiveDateTime.compare(ndt4, ndt4) == :eq\n assert NaiveDateTime.compare(ndt1, ndt4) == :gt\n assert NaiveDateTime.compare(ndt4, ndt3) == :lt\n end\n\n test \"before?/2 and after?/2\" do\n ndt1 = ~N[2022-01-12 10:10:11.0019]\n ndt2 = ~N[2022-02-16 13:20:15.0019]\n\n assert NaiveDateTime.before?(ndt1, ndt2)\n assert not NaiveDateTime.before?(ndt2, ndt1)\n\n assert NaiveDateTime.after?(ndt2, ndt1)\n assert not NaiveDateTime.after?(ndt1, ndt2)\n end\n\n test \"to_iso8601/1\" do\n ndt = ~N[2000-04-16 12:34:15.1234]\n ndt = put_in(ndt.calendar, FakeCalendar)\n\n message =\n \"cannot convert #{inspect(ndt)} to target calendar Calendar.ISO, \" <>\n \"reason: #{inspect(ndt.calendar)} and Calendar.ISO have different day rollover moments, \" <>\n \"making this conversion ambiguous\"\n\n assert_raise ArgumentError, message, fn ->\n NaiveDateTime.to_iso8601(ndt)\n end\n end\n\n describe \"add\" do\n test \"with other calendars\" do\n assert ~N[2000-01-01 12:34:15.123456]\n |> NaiveDateTime.convert!(Calendar.Holocene)\n |> NaiveDateTime.add(10, :second) ==\n %NaiveDateTime{\n calendar: Calendar.Holocene,\n year: 12000,\n month: 1,\n day: 1,\n hour: 12,\n minute: 34,\n second: 25,\n microsecond: {123_456, 6}\n }\n end\n\n test \"with datetime\" do\n dt = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n assert NaiveDateTime.add(dt, 21, :second) == ~N[2000-02-29 23:00:28]\n end\n end\n\n describe \"diff\" do\n test \"with invalid time unit\" do\n dt = NaiveDateTime.utc_now()\n\n message =\n ~r/unsupported time unit\\. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got \"day\"/\n\n assert_raise ArgumentError, message, fn -> NaiveDateTime.diff(dt, dt, \"day\") end\n end\n\n test \"with other calendars\" do\n assert ~N[2000-01-01 12:34:15.123456]\n |> NaiveDateTime.convert!(Calendar.Holocene)\n |> NaiveDateTime.add(10, :second)\n |> NaiveDateTime.diff(~N[2000-01-01 12:34:15.123456]) == 10\n end\n\n test \"with datetime\" do\n dt = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {0, 0},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n assert NaiveDateTime.diff(%{dt | second: 57}, dt, :second) == 50\n end\n end\n\n test \"convert/2\" do\n assert NaiveDateTime.convert(~N[2000-01-01 12:34:15.123400], Calendar.Holocene) ==\n {:ok, Calendar.Holocene.naive_datetime(12000, 1, 1, 12, 34, 15, {123_400, 6})}\n\n assert ~N[2000-01-01 12:34:15]\n |> NaiveDateTime.convert!(Calendar.Holocene)\n |> NaiveDateTime.convert!(Calendar.ISO) == ~N[2000-01-01 12:34:15]\n\n assert ~N[2000-01-01 12:34:15.123456]\n |> NaiveDateTime.convert!(Calendar.Holocene)\n |> NaiveDateTime.convert!(Calendar.ISO) == ~N[2000-01-01 12:34:15.123456]\n\n assert NaiveDateTime.convert(~N[2016-02-03 00:00:01], FakeCalendar) ==\n {:error, :incompatible_calendars}\n\n assert NaiveDateTime.convert(~N[1970-01-01 00:00:00], Calendar.Holocene) ==\n {:ok, Calendar.Holocene.naive_datetime(11970, 1, 1, 0, 0, 0, {0, 0})}\n\n assert NaiveDateTime.convert(DateTime.from_unix!(0, :second), Calendar.Holocene) ==\n {:ok, Calendar.Holocene.naive_datetime(11970, 1, 1, 0, 0, 0, {0, 0})}\n end\n\n test \"truncate/2\" do\n assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond) ==\n ~N[2017-11-06 00:23:51.123456]\n\n assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.0], :millisecond) ==\n ~N[2017-11-06 00:23:51.0]\n\n assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.999], :millisecond) ==\n ~N[2017-11-06 00:23:51.999]\n\n assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.1009], :millisecond) ==\n ~N[2017-11-06 00:23:51.100]\n\n assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond) ==\n ~N[2017-11-06 00:23:51.123]\n\n assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.000456], :millisecond) ==\n ~N[2017-11-06 00:23:51.000]\n\n assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second) ==\n ~N[2017-11-06 00:23:51]\n end\n\n test \"truncate/2 with datetime\" do\n dt = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {3000, 6},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n assert NaiveDateTime.truncate(dt, :millisecond) == ~N[2000-02-29 23:00:07.003]\n assert catch_error(NaiveDateTime.truncate(~T[00:00:00.000000], :millisecond))\n end\n\n describe \"utc_now/1\" do\n test \"utc_now/1 with default calendar (ISO)\" do\n naive_datetime = NaiveDateTime.utc_now()\n assert naive_datetime.year >= 2019\n end\n\n test \"utc_now/1 with alternative calendar\" do\n naive_datetime = NaiveDateTime.utc_now(Calendar.Holocene)\n assert naive_datetime.calendar == Calendar.Holocene\n assert naive_datetime.year >= 12019\n end\n end\n\n describe \"local_now/1\" do\n test \"local_now/1 with default calendar (ISO)\" do\n naive_datetime = NaiveDateTime.local_now()\n assert naive_datetime.year >= 2018\n end\n\n test \"local_now/1 alternative calendar\" do\n naive_datetime = NaiveDateTime.local_now(Calendar.Holocene)\n assert naive_datetime.calendar == Calendar.Holocene\n assert naive_datetime.year >= 12018\n end\n\n test \"local_now/1 incompatible calendar\" do\n assert_raise ArgumentError,\n ~s(cannot get \"local now\" in target calendar FakeCalendar, reason: cannot convert from Calendar.ISO to FakeCalendar.),\n fn ->\n NaiveDateTime.local_now(FakeCalendar)\n end\n end\n end\n\n describe \"to_date/2\" do\n test \"downcasting\" do\n dt = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {3000, 6},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n assert NaiveDateTime.to_date(dt) == ~D[2000-02-29]\n end\n\n test \"upcasting\" do\n assert catch_error(NaiveDateTime.to_date(~D[2000-02-29]))\n end\n end\n\n describe \"to_time/2\" do\n test \"downcasting\" do\n dt = %DateTime{\n year: 2000,\n month: 2,\n day: 29,\n zone_abbr: \"CET\",\n hour: 23,\n minute: 0,\n second: 7,\n microsecond: {3000, 6},\n utc_offset: 3600,\n std_offset: 0,\n time_zone: \"Europe/Warsaw\"\n }\n\n assert NaiveDateTime.to_time(dt) == ~T[23:00:07.003000]\n end\n\n test \"upcasting\" do\n assert catch_error(NaiveDateTime.to_time(~T[00:00:00.000000]))\n end\n end\n\n describe \"beginning_of_day/1\" do\n test \"precision\" do\n assert NaiveDateTime.beginning_of_day(~N[2000-01-01 23:00:07.123]) ==\n ~N[2000-01-01 00:00:00.000]\n\n assert NaiveDateTime.beginning_of_day(~N[2000-01-01 23:00:07]) == ~N[2000-01-01 00:00:00]\n end\n end\n\n describe \"end_of_day/1\" do\n test \"precision\" do\n assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.1]) == ~N[2000-01-01 23:59:59.9]\n assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.123]) == ~N[2000-01-01 23:59:59.999]\n\n assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.12345]) ==\n ~N[2000-01-01 23:59:59.99999]\n\n assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07]) == ~N[2000-01-01 23:59:59]\n end\n end\n\n test \"shift/2\" do\n naive_datetime = ~N[2000-01-01 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, year: 1) == ~N[2001-01-01 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, month: 1) == ~N[2000-02-01 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, week: 3) == ~N[2000-01-22 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, day: 2) == ~N[2000-01-03 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, hour: 6) == ~N[2000-01-01 06:00:00]\n assert NaiveDateTime.shift(naive_datetime, minute: 30) == ~N[2000-01-01 00:30:00]\n assert NaiveDateTime.shift(naive_datetime, second: 45) == ~N[2000-01-01 00:00:45]\n assert NaiveDateTime.shift(naive_datetime, year: -1) == ~N[1999-01-01 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, month: -1) == ~N[1999-12-01 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, week: -1) == ~N[1999-12-25 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, day: -1) == ~N[1999-12-31 00:00:00]\n assert NaiveDateTime.shift(naive_datetime, hour: -12) == ~N[1999-12-31 12:00:00]\n assert NaiveDateTime.shift(naive_datetime, minute: -45) == ~N[1999-12-31 23:15:00]\n assert NaiveDateTime.shift(naive_datetime, second: -30) == ~N[1999-12-31 23:59:30]\n assert NaiveDateTime.shift(naive_datetime, year: 1, month: 2) == ~N[2001-03-01 00:00:00]\n\n assert NaiveDateTime.shift(naive_datetime, microsecond: {-500, 6}) ==\n ~N[1999-12-31 23:59:59.999500]\n\n assert NaiveDateTime.shift(naive_datetime, microsecond: {500, 6}) ==\n ~N[2000-01-01 00:00:00.000500]\n\n assert NaiveDateTime.shift(naive_datetime, microsecond: {100, 6}) ==\n ~N[2000-01-01 00:00:00.000100]\n\n assert NaiveDateTime.shift(naive_datetime, microsecond: {100, 4}) ==\n ~N[2000-01-01 00:00:00.0001]\n\n assert NaiveDateTime.shift(naive_datetime, month: 2, day: 3, hour: 6, minute: 15) ==\n ~N[2000-03-04 06:15:00]\n\n assert NaiveDateTime.shift(naive_datetime,\n year: 1,\n month: 2,\n week: 3,\n day: 4,\n hour: 5,\n minute: 6,\n second: 7,\n microsecond: {8, 6}\n ) == ~N[2001-03-26 05:06:07.000008]\n\n assert NaiveDateTime.shift(naive_datetime,\n year: -1,\n month: -2,\n week: -3,\n day: -4,\n hour: -5,\n minute: -6,\n second: -7,\n microsecond: {-8, 6}\n ) == ~N[1998-10-06 18:53:52.999992]\n\n assert_raise ArgumentError,\n \"unknown unit :months. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond\",\n fn -> NaiveDateTime.shift(~N[2000-01-01 00:00:00], months: 12) end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar/time_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\nCode.require_file(\"holocene.exs\", __DIR__)\nCode.require_file(\"fakes.exs\", __DIR__)\n\ndefmodule TimeTest do\n use ExUnit.Case, async: true\n doctest Time\n\n test \"sigil_T\" do\n assert ~T[12:34:56] ==\n %Time{calendar: Calendar.ISO, hour: 12, minute: 34, second: 56}\n\n assert ~T[12:34:56 Calendar.Holocene] ==\n %Time{calendar: Calendar.Holocene, hour: 12, minute: 34, second: 56}\n\n assert_raise ArgumentError,\n ~s/cannot parse \"12:34:65\" as Time for Calendar.ISO, reason: :invalid_time/,\n fn -> Code.eval_string(\"~T[12:34:65]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"123456\" as Time for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(\"~T[123456]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"12:34:56 notalias\" as Time for Calendar.ISO, reason: :invalid_format/,\n fn -> Code.eval_string(\"~T[12:34:56 notalias]\") end\n\n assert_raise ArgumentError,\n ~s/cannot parse \"12:34:65\" as Time for Calendar.Holocene, reason: :invalid_time/,\n fn -> Code.eval_string(\"~T[12:34:65 Calendar.Holocene]\") end\n\n assert_raise UndefinedFunctionError, fn ->\n Code.eval_string(\"~T[12:34:56 UnknownCalendar]\")\n end\n end\n\n test \"to_iso8601/2\" do\n time1 = ~T[23:00:07.005]\n assert Time.to_iso8601(time1) == \"23:00:07.005\"\n assert Time.to_iso8601(Map.from_struct(time1)) == \"23:00:07.005\"\n assert Time.to_iso8601(time1, :basic) == \"230007.005\"\n\n time2 = ~T[23:00:07.005 Calendar.Holocene]\n assert Time.to_iso8601(time2) == \"23:00:07.005\"\n assert Time.to_iso8601(Map.from_struct(time2)) == \"23:00:07.005\"\n assert Time.to_iso8601(time2, :basic) == \"230007.005\"\n end\n\n test \"to_string/1\" do\n time = ~T[23:00:07.005]\n assert to_string(time) == \"23:00:07.005\"\n assert Time.to_string(time) == \"23:00:07.005\"\n assert Time.to_string(Map.from_struct(time)) == \"23:00:07.005\"\n\n assert to_string(%{time | calendar: FakeCalendar}) == \"23::0::7\"\n assert Time.to_string(%{time | calendar: FakeCalendar}) == \"23::0::7\"\n end\n\n test \"inspect/1\" do\n assert inspect(~T[23:00:07.005]) == \"~T[23:00:07.005]\"\n\n time = %{~T[23:00:07.005] | calendar: FakeCalendar}\n assert inspect(time) == \"~T[23::0::7 FakeCalendar]\"\n end\n\n test \"compare/2\" do\n time0 = ~T[01:01:01.0]\n time1 = ~T[01:01:01.005]\n time2 = ~T[01:01:01.0050]\n time3 = ~T[23:01:01.0050]\n assert Time.compare(time0, time1) == :lt\n assert Time.compare(time1, time1) == :eq\n assert Time.compare(time1, time2) == :eq\n assert Time.compare(time1, time3) == :lt\n assert Time.compare(time3, time2) == :gt\n\n time1_holocene = ~T[01:01:01.005 Calendar.Holocene]\n assert Time.compare(time1_holocene, time1) == :eq\n assert Time.compare(time1_holocene, time2) == :eq\n assert Time.compare(time1_holocene, time3) == :lt\n end\n\n test \"before?/2 and after?/2\" do\n time1 = ~T[05:02:01.234]\n time2 = ~T[10:00:04.123]\n\n assert Time.before?(time1, time2)\n assert not Time.before?(time2, time1)\n\n assert Time.after?(time2, time1)\n assert not Time.after?(time1, time2)\n end\n\n test \"diff/3\" do\n time1 = ~T[05:02:01.234]\n time2 = ~T[10:00:04.123]\n time1_holocene = ~T[05:02:01.234 Calendar.Holocene]\n\n assert Time.diff(time1, time2) == -17883\n assert Time.diff(time1, time2, :hour) == -4\n assert Time.diff(time1, time2, :minute) == -298\n assert Time.diff(time1, time2, :second) == -17883\n assert Time.diff(time1, time2, :millisecond) == -17_882_889\n assert Time.diff(time1, time2, :microsecond) == -17_882_889_000\n\n assert Time.diff(time1_holocene, time2) == -17883\n assert Time.diff(time1_holocene, time2, :hour) == -4\n assert Time.diff(time1_holocene, time2, :minute) == -298\n assert Time.diff(time1_holocene, time2, :second) == -17883\n assert Time.diff(time1_holocene, time2, :millisecond) == -17_882_889\n assert Time.diff(time1_holocene, time2, :microsecond) == -17_882_889_000\n end\n\n test \"truncate/2\" do\n assert Time.truncate(~T[01:01:01.123456], :microsecond) == ~T[01:01:01.123456]\n\n assert Time.truncate(~T[01:01:01.0], :millisecond) == ~T[01:01:01.0]\n assert Time.truncate(~T[01:01:01.00], :millisecond) == ~T[01:01:01.00]\n assert Time.truncate(~T[01:01:01.1], :millisecond) == ~T[01:01:01.1]\n assert Time.truncate(~T[01:01:01.100], :millisecond) == ~T[01:01:01.100]\n assert Time.truncate(~T[01:01:01.999], :millisecond) == ~T[01:01:01.999]\n assert Time.truncate(~T[01:01:01.1000], :millisecond) == ~T[01:01:01.100]\n assert Time.truncate(~T[01:01:01.1001], :millisecond) == ~T[01:01:01.100]\n assert Time.truncate(~T[01:01:01.123456], :millisecond) == ~T[01:01:01.123]\n assert Time.truncate(~T[01:01:01.000123], :millisecond) == ~T[01:01:01.000]\n assert Time.truncate(~T[01:01:01.00012], :millisecond) == ~T[01:01:01.000]\n\n assert Time.truncate(~T[01:01:01.123456], :second) == ~T[01:01:01]\n end\n\n test \"add/3\" do\n time = ~T[00:00:00.0]\n\n assert Time.add(time, 1, :hour) == ~T[01:00:00.0]\n\n assert Time.add(time, 1, 10) == ~T[00:00:00.100000]\n\n assert_raise ArgumentError, ~r/Expected :hour, :minute, :second/, fn ->\n Time.add(time, 1, 0)\n end\n end\n\n test \"shift/2\" do\n time = ~T[00:00:00.0]\n assert Time.shift(time, hour: 1) == ~T[01:00:00.0]\n assert Time.shift(time, hour: 25) == ~T[01:00:00.0]\n assert Time.shift(time, minute: 25) == ~T[00:25:00.0]\n assert Time.shift(time, second: 50) == ~T[00:00:50.0]\n assert Time.shift(time, microsecond: {150, 6}) == ~T[00:00:00.000150]\n assert Time.shift(time, microsecond: {1000, 4}) == ~T[00:00:00.0010]\n assert Time.shift(time, hour: 2, minute: 65, second: 5) == ~T[03:05:05.0]\n\n assert_raise ArgumentError,\n \"unsupported unit :day. Expected :hour, :minute, :second, :microsecond\",\n fn -> Time.shift(time, day: 1) end\n\n assert_raise ArgumentError,\n \"unknown unit :hours. Expected :hour, :minute, :second, :microsecond\",\n fn -> Time.shift(time, hours: 12) end\n\n assert_raise ArgumentError,\n \"cannot shift time by date scale unit. Expected :hour, :minute, :second, :microsecond\",\n fn -> Time.shift(time, %Duration{day: 1}) end\n\n assert_raise ArgumentError,\n \"unsupported value nil for :minute. Expected an integer\",\n fn -> Time.shift(time, minute: nil) end\n\n assert_raise ArgumentError,\n ~r/unsupported value 1 for :microsecond. Expected a tuple \\{ms, precision\\}/,\n fn -> Time.shift(time, microsecond: 1) end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/calendar_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule CalendarTest do\n use ExUnit.Case, async: true\n doctest Calendar\n\n describe \"strftime/3\" do\n test \"returns received string if there is no datetime formatting to be found in it\" do\n assert Calendar.strftime(~N[2019-08-20 15:47:34.001], \"same string\") == \"same string\"\n end\n\n test \"formats all time zones blank when receiving a NaiveDateTime\" do\n assert Calendar.strftime(~N[2019-08-15 17:07:57.001], \"%z%Z\") == \"\"\n end\n\n test \"raises error when trying to format a date with a map that has no date fields\" do\n time_without_date = %{hour: 15, minute: 47, second: 34, microsecond: {0, 0}}\n\n assert_raise KeyError, fn -> Calendar.strftime(time_without_date, \"%x\") end\n end\n\n test \"raises error when trying to format a time with a map that has no time fields\" do\n date_without_time = %{year: 2019, month: 8, day: 20}\n\n assert_raise KeyError, fn -> Calendar.strftime(date_without_time, \"%X\") end\n end\n\n test \"raises error when the format is invalid\" do\n assert_raise ArgumentError, \"invalid strftime format: %-\", fn ->\n Calendar.strftime(~N[2019-08-20 15:47:34.001], \"%-2-ç\")\n end\n\n assert_raise ArgumentError, \"invalid strftime format: %\", fn ->\n Calendar.strftime(~N[2019-08-20 15:47:34.001], \"%\")\n end\n end\n\n test \"raises error when the preferred_datetime calls itself\" do\n assert_raise ArgumentError, fn ->\n Calendar.strftime(~N[2019-08-20 15:47:34.001], \"%c\", preferred_datetime: \"%c\")\n end\n end\n\n test \"raises error when the preferred_date calls itself\" do\n assert_raise ArgumentError, fn ->\n Calendar.strftime(~N[2019-08-20 15:47:34.001], \"%x\", preferred_date: \"%x\")\n end\n end\n\n test \"raises error when the preferred_time calls itself\" do\n assert_raise ArgumentError, fn ->\n Calendar.strftime(~N[2019-08-20 15:47:34.001], \"%X\", preferred_time: \"%X\")\n end\n end\n\n test \"raises error when the preferred formats creates a circular chain\" do\n assert_raise ArgumentError, fn ->\n Calendar.strftime(~N[2019-08-20 15:47:34.001], \"%c\",\n preferred_datetime: \"%x\",\n preferred_date: \"%X\",\n preferred_time: \"%c\"\n )\n end\n end\n\n test \"with preferred formats are included multiple times on the same string\" do\n assert Calendar.strftime(~N[2019-08-15 17:07:57.001], \"%c %c %x %x %X %X\") ==\n \"2019-08-15 17:07:57 2019-08-15 17:07:57 2019-08-15 2019-08-15 17:07:57 17:07:57\"\n end\n\n test \"`-` removes padding\" do\n assert Calendar.strftime(~D[2019-01-01], \"%-j\") == \"1\"\n assert Calendar.strftime(~T[17:07:57.001], \"%-999M\") == \"7\"\n end\n\n test \"formats time zones correctly when receiving a DateTime\" do\n datetime_with_zone = %DateTime{\n year: 2019,\n month: 8,\n day: 15,\n zone_abbr: \"EEST\",\n hour: 17,\n minute: 7,\n second: 57,\n microsecond: {0, 0},\n utc_offset: 7200,\n std_offset: 3600,\n time_zone: \"UK\"\n }\n\n assert Calendar.strftime(datetime_with_zone, \"%z %Z\") == \"+0300 EEST\"\n end\n\n test \"formats AM and PM correctly on the %P and %p options\" do\n am_time_almost_pm = ~U[2019-08-26 11:59:59.001Z]\n pm_time = ~U[2019-08-26 12:00:57.001Z]\n pm_time_almost_am = ~U[2019-08-26 23:59:57.001Z]\n am_time = ~U[2019-08-26 00:00:01.001Z]\n\n assert Calendar.strftime(am_time_almost_pm, \"%P %p\") == \"am AM\"\n assert Calendar.strftime(pm_time, \"%P %p\") == \"pm PM\"\n assert Calendar.strftime(pm_time_almost_am, \"%P %p\") == \"pm PM\"\n assert Calendar.strftime(am_time, \"%P %p\") == \"am AM\"\n end\n\n test \"formats all weekdays correctly with %A and %a formats\" do\n sunday = ~U[2019-08-25 11:59:59.001Z]\n monday = ~U[2019-08-26 11:59:59.001Z]\n tuesday = ~U[2019-08-27 11:59:59.001Z]\n wednesday = ~U[2019-08-28 11:59:59.001Z]\n thursday = ~U[2019-08-29 11:59:59.001Z]\n friday = ~U[2019-08-30 11:59:59.001Z]\n saturday = ~U[2019-08-31 11:59:59.001Z]\n\n assert Calendar.strftime(sunday, \"%A %a\") == \"Sunday Sun\"\n assert Calendar.strftime(monday, \"%A %a\") == \"Monday Mon\"\n assert Calendar.strftime(tuesday, \"%A %a\") == \"Tuesday Tue\"\n assert Calendar.strftime(wednesday, \"%A %a\") == \"Wednesday Wed\"\n assert Calendar.strftime(thursday, \"%A %a\") == \"Thursday Thu\"\n assert Calendar.strftime(friday, \"%A %a\") == \"Friday Fri\"\n assert Calendar.strftime(saturday, \"%A %a\") == \"Saturday Sat\"\n end\n\n test \"formats all months correctly with the %B and %b formats\" do\n assert Calendar.strftime(%{month: 1}, \"%B %b\") == \"January Jan\"\n assert Calendar.strftime(%{month: 2}, \"%B %b\") == \"February Feb\"\n assert Calendar.strftime(%{month: 3}, \"%B %b\") == \"March Mar\"\n assert Calendar.strftime(%{month: 4}, \"%B %b\") == \"April Apr\"\n assert Calendar.strftime(%{month: 5}, \"%B %b\") == \"May May\"\n assert Calendar.strftime(%{month: 6}, \"%B %b\") == \"June Jun\"\n assert Calendar.strftime(%{month: 7}, \"%B %b\") == \"July Jul\"\n assert Calendar.strftime(%{month: 8}, \"%B %b\") == \"August Aug\"\n assert Calendar.strftime(%{month: 9}, \"%B %b\") == \"September Sep\"\n assert Calendar.strftime(%{month: 10}, \"%B %b\") == \"October Oct\"\n assert Calendar.strftime(%{month: 11}, \"%B %b\") == \"November Nov\"\n assert Calendar.strftime(%{month: 12}, \"%B %b\") == \"December Dec\"\n end\n\n test \"formats all weekdays correctly on %A with day_of_week_names option\" do\n sunday = ~U[2019-08-25 11:59:59.001Z]\n monday = ~U[2019-08-26 11:59:59.001Z]\n tuesday = ~U[2019-08-27 11:59:59.001Z]\n wednesday = ~U[2019-08-28 11:59:59.001Z]\n thursday = ~U[2019-08-29 11:59:59.001Z]\n friday = ~U[2019-08-30 11:59:59.001Z]\n saturday = ~U[2019-08-31 11:59:59.001Z]\n\n day_of_week_names = fn day_of_week ->\n {\"segunda-feira\", \"terça-feira\", \"quarta-feira\", \"quinta-feira\", \"sexta-feira\", \"sábado\",\n \"domingo\"}\n |> elem(day_of_week - 1)\n end\n\n assert Calendar.strftime(sunday, \"%A\", day_of_week_names: day_of_week_names) ==\n \"domingo\"\n\n assert Calendar.strftime(monday, \"%A\", day_of_week_names: day_of_week_names) ==\n \"segunda-feira\"\n\n assert Calendar.strftime(tuesday, \"%A\", day_of_week_names: day_of_week_names) ==\n \"terça-feira\"\n\n assert Calendar.strftime(wednesday, \"%A\", day_of_week_names: day_of_week_names) ==\n \"quarta-feira\"\n\n assert Calendar.strftime(thursday, \"%A\", day_of_week_names: day_of_week_names) ==\n \"quinta-feira\"\n\n assert Calendar.strftime(friday, \"%A\", day_of_week_names: day_of_week_names) ==\n \"sexta-feira\"\n\n assert Calendar.strftime(saturday, \"%A\", day_of_week_names: day_of_week_names) ==\n \"sábado\"\n end\n\n test \"formats all months correctly on the %B with month_names option\" do\n month_names = fn month ->\n {\"январь\", \"февраль\", \"март\", \"апрель\", \"май\", \"июнь\", \"июль\", \"август\", \"сентябрь\",\n \"октябрь\", \"ноябрь\", \"декабрь\"}\n |> elem(month - 1)\n end\n\n assert Calendar.strftime(%{month: 1}, \"%B\", month_names: month_names) == \"январь\"\n assert Calendar.strftime(%{month: 2}, \"%B\", month_names: month_names) == \"февраль\"\n assert Calendar.strftime(%{month: 3}, \"%B\", month_names: month_names) == \"март\"\n assert Calendar.strftime(%{month: 4}, \"%B\", month_names: month_names) == \"апрель\"\n assert Calendar.strftime(%{month: 5}, \"%B\", month_names: month_names) == \"май\"\n assert Calendar.strftime(%{month: 6}, \"%B\", month_names: month_names) == \"июнь\"\n assert Calendar.strftime(%{month: 7}, \"%B\", month_names: month_names) == \"июль\"\n assert Calendar.strftime(%{month: 8}, \"%B\", month_names: month_names) == \"август\"\n assert Calendar.strftime(%{month: 9}, \"%B\", month_names: month_names) == \"сентябрь\"\n assert Calendar.strftime(%{month: 10}, \"%B\", month_names: month_names) == \"октябрь\"\n assert Calendar.strftime(%{month: 11}, \"%B\", month_names: month_names) == \"ноябрь\"\n assert Calendar.strftime(%{month: 12}, \"%B\", month_names: month_names) == \"декабрь\"\n end\n\n test \"formats all weekdays correctly on the %a format with abbreviated_day_of_week_names option\" do\n sunday = ~U[2019-08-25 11:59:59.001Z]\n monday = ~U[2019-08-26 11:59:59.001Z]\n tuesday = ~U[2019-08-27 11:59:59.001Z]\n wednesday = ~U[2019-08-28 11:59:59.001Z]\n thursday = ~U[2019-08-29 11:59:59.001Z]\n friday = ~U[2019-08-30 11:59:59.001Z]\n saturday = ~U[2019-08-31 11:59:59.001Z]\n\n abbreviated_day_of_week_names = fn day_of_week ->\n {\"seg\", \"ter\", \"qua\", \"qui\", \"sex\", \"sáb\", \"dom\"}\n |> elem(day_of_week - 1)\n end\n\n assert Calendar.strftime(sunday, \"%a\",\n abbreviated_day_of_week_names: abbreviated_day_of_week_names\n ) == \"dom\"\n\n assert Calendar.strftime(monday, \"%a\",\n abbreviated_day_of_week_names: abbreviated_day_of_week_names\n ) == \"seg\"\n\n assert Calendar.strftime(tuesday, \"%a\",\n abbreviated_day_of_week_names: abbreviated_day_of_week_names\n ) == \"ter\"\n\n assert Calendar.strftime(wednesday, \"%a\",\n abbreviated_day_of_week_names: abbreviated_day_of_week_names\n ) == \"qua\"\n\n assert Calendar.strftime(thursday, \"%a\",\n abbreviated_day_of_week_names: abbreviated_day_of_week_names\n ) == \"qui\"\n\n assert Calendar.strftime(friday, \"%a\",\n abbreviated_day_of_week_names: abbreviated_day_of_week_names\n ) == \"sex\"\n\n assert Calendar.strftime(saturday, \"%a\",\n abbreviated_day_of_week_names: abbreviated_day_of_week_names\n ) == \"sáb\"\n end\n\n test \"formats all months correctly on the %b format with abbreviated_month_names option\" do\n abbreviated_month_names = fn month ->\n {\"янв\", \"февр\", \"март\", \"апр\", \"май\", \"июнь\", \"июль\", \"авг\", \"сент\", \"окт\", \"нояб\", \"дек\"}\n |> elem(month - 1)\n end\n\n assert Calendar.strftime(%{month: 1}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"янв\"\n\n assert Calendar.strftime(%{month: 2}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"февр\"\n\n assert Calendar.strftime(%{month: 3}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"март\"\n\n assert Calendar.strftime(%{month: 4}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"апр\"\n\n assert Calendar.strftime(%{month: 5}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"май\"\n\n assert Calendar.strftime(%{month: 6}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"июнь\"\n\n assert Calendar.strftime(%{month: 7}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"июль\"\n\n assert Calendar.strftime(%{month: 8}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"авг\"\n\n assert Calendar.strftime(%{month: 9}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) ==\n \"сент\"\n\n assert Calendar.strftime(%{month: 10}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) == \"окт\"\n\n assert Calendar.strftime(%{month: 11}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) == \"нояб\"\n\n assert Calendar.strftime(%{month: 12}, \"%b\",\n abbreviated_month_names: abbreviated_month_names\n ) == \"дек\"\n end\n\n test \"formats ignores padding and width options on microseconds\" do\n datetime = ~U[2019-08-15 17:07:57.001234Z]\n assert Calendar.strftime(datetime, \"%f\") == \"001234\"\n assert Calendar.strftime(datetime, \"%f\") == Calendar.strftime(datetime, \"%_20f\")\n assert Calendar.strftime(datetime, \"%f\") == Calendar.strftime(datetime, \"%020f\")\n assert Calendar.strftime(datetime, \"%f\") == Calendar.strftime(datetime, \"%-f\")\n end\n\n test \"formats properly dates with different microsecond precisions\" do\n assert Calendar.strftime(~U[2019-08-15 17:07:57.5Z], \"%f\") == \"5\"\n assert Calendar.strftime(~U[2019-08-15 17:07:57.45Z], \"%f\") == \"45\"\n assert Calendar.strftime(~U[2019-08-15 17:07:57.345Z], \"%f\") == \"345\"\n assert Calendar.strftime(~U[2019-08-15 17:07:57.2345Z], \"%f\") == \"2345\"\n assert Calendar.strftime(~U[2019-08-15 17:07:57.12345Z], \"%f\") == \"12345\"\n assert Calendar.strftime(~U[2019-08-15 17:07:57.012345Z], \"%f\") == \"012345\"\n end\n\n test \"formats properly different microsecond precisions of zero\" do\n assert Calendar.strftime(~N[2019-08-15 17:07:57.0], \"%f\") == \"0\"\n assert Calendar.strftime(~N[2019-08-15 17:07:57.00], \"%f\") == \"00\"\n assert Calendar.strftime(~N[2019-08-15 17:07:57.000], \"%f\") == \"000\"\n assert Calendar.strftime(~N[2019-08-15 17:07:57.0000], \"%f\") == \"0000\"\n assert Calendar.strftime(~N[2019-08-15 17:07:57.00000], \"%f\") == \"00000\"\n assert Calendar.strftime(~N[2019-08-15 17:07:57.000000], \"%f\") == \"000000\"\n end\n\n test \"returns a single zero if there's no microseconds precision\" do\n assert Calendar.strftime(~N[2019-08-15 17:07:57], \"%f\") == \"0\"\n end\n\n test \"handles `0` both as padding and as part of a width\" do\n assert Calendar.strftime(~N[2019-08-15 17:07:57], \"%10A\") == \" Thursday\"\n assert Calendar.strftime(~N[2019-08-15 17:07:57], \"%010A\") == \"00Thursday\"\n end\n\n test \"formats Epoch time with %s\" do\n assert Calendar.strftime(~N[2019-08-15 17:07:57], \"%s\") == \"1565888877\"\n\n datetime = %DateTime{\n year: 2019,\n month: 8,\n day: 15,\n hour: 17,\n minute: 7,\n second: 57,\n microsecond: {0, 0},\n time_zone: \"Europe/Berlin\",\n zone_abbr: \"CET\",\n utc_offset: 3600,\n std_offset: 0\n }\n\n assert Calendar.strftime(datetime, \"%s\") == \"1565885277\"\n end\n\n test \"formats datetime with all options and modifiers\" do\n assert Calendar.strftime(\n ~U[2019-08-15 17:07:57.001Z],\n \"%04% %a %A %b %B %-3c %d %f %H %I %j %m %_5M %p %P %q %S %u %x %X %y %Y %z %Z\"\n ) ==\n \"000% Thu Thursday Aug August 2019-08-15 17:07:57 15 001 17 05 227 08 7 PM pm 3 57 4 2019-08-15 17:07:57 19 2019 +0000 UTC\"\n end\n\n test \"formats according to custom configs\" do\n assert Calendar.strftime(\n ~U[2019-08-15 17:07:57.001Z],\n \"%A %a %p %B %b %c %x %X\",\n am_pm_names: fn\n :am -> \"a\"\n :pm -> \"p\"\n end,\n month_names: fn month ->\n {\"Janeiro\", \"Fevereiro\", \"Março\", \"Abril\", \"Maio\", \"Junho\", \"Julho\", \"Agosto\",\n \"Setembro\", \"Outubro\", \"Novembro\", \"Dezembro\"}\n |> elem(month - 1)\n end,\n day_of_week_names: fn day_of_week ->\n {\"понедельник\", \"вторник\", \"среда\", \"четверг\", \"пятница\", \"суббота\",\n \"воскресенье\"}\n |> elem(day_of_week - 1)\n end,\n abbreviated_month_names: fn month ->\n {\"Jan\", \"Fev\", \"Mar\", \"Abr\", \"Mai\", \"Jun\", \"Jul\", \"Ago\", \"Set\", \"Out\", \"Nov\",\n \"Dez\"}\n |> elem(month - 1)\n end,\n abbreviated_day_of_week_names: fn day_of_week ->\n {\"ПНД\", \"ВТР\", \"СРД\", \"ЧТВ\", \"ПТН\", \"СБТ\", \"ВСК\"}\n |> elem(day_of_week - 1)\n end,\n preferred_date: \"%05Y-%m-%d\",\n preferred_time: \"%M:%_3H%S\",\n preferred_datetime: \"%%\"\n ) == \"четверг ЧТВ P Agosto Ago % 02019-08-15 07: 1757\"\n end\n\n test \"formats according to custom configs with 2-arity functions\" do\n assert Calendar.strftime(\n ~U[2019-08-15 17:07:57.001Z],\n \"%A %a %p %B %b %c %x %X\",\n am_pm_names: fn\n :am, ~U[2019-08-15 17:07:57.001Z] -> \"a\"\n :pm, ~U[2019-08-15 17:07:57.001Z] -> \"p\"\n end,\n month_names: fn month, ~U[2019-08-15 17:07:57.001Z] ->\n {\"Janeiro\", \"Fevereiro\", \"Março\", \"Abril\", \"Maio\", \"Junho\", \"Julho\", \"Agosto\",\n \"Setembro\", \"Outubro\", \"Novembro\", \"Dezembro\"}\n |> elem(month - 1)\n end,\n day_of_week_names: fn day_of_week, ~U[2019-08-15 17:07:57.001Z] ->\n {\"понедельник\", \"вторник\", \"среда\", \"четверг\", \"пятница\", \"суббота\",\n \"воскресенье\"}\n |> elem(day_of_week - 1)\n end,\n abbreviated_month_names: fn month, ~U[2019-08-15 17:07:57.001Z] ->\n {\"Jan\", \"Fev\", \"Mar\", \"Abr\", \"Mai\", \"Jun\", \"Jul\", \"Ago\", \"Set\", \"Out\", \"Nov\",\n \"Dez\"}\n |> elem(month - 1)\n end,\n abbreviated_day_of_week_names: fn day_of_week, ~U[2019-08-15 17:07:57.001Z] ->\n {\"ПНД\", \"ВТР\", \"СРД\", \"ЧТВ\", \"ПТН\", \"СБТ\", \"ВСК\"}\n |> elem(day_of_week - 1)\n end,\n preferred_date: \"%05Y-%m-%d\",\n preferred_time: \"%M:%_3H%S\",\n preferred_datetime: \"%%\"\n ) == \"четверг ЧТВ P Agosto Ago % 02019-08-15 07: 1757\"\n end\n\n test \"raises on unknown option according to custom configs\" do\n assert_raise ArgumentError, \"unknown option :unknown given to Calendar.strftime/3\", fn ->\n Calendar.strftime(~D[2019-08-15], \"%D\", unknown: \"option\")\n end\n end\n\n test \"zero padding for negative year\" do\n assert Calendar.strftime(Date.new!(-1, 1, 1), \"%Y\") == \"-0001\"\n assert Calendar.strftime(Date.new!(-11, 1, 1), \"%Y\") == \"-0011\"\n assert Calendar.strftime(Date.new!(-111, 1, 1), \"%Y\") == \"-0111\"\n assert Calendar.strftime(Date.new!(-1111, 1, 1), \"%Y\") == \"-1111\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/changelog_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nExUnit.start()\n\ndefmodule ChangelogTest do\n use ExUnit.Case, async: true\n doctest_file(Path.expand(\"../../../../CHANGELOG.md\", __DIR__))\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/calls_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.CallsTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n @short_length [line_length: 10]\n @medium_length [line_length: 20]\n\n describe \"next break fits\" do\n test \"does not apply to function calls\" do\n bad = \"foo(very_long_call(bar))\"\n\n good = \"\"\"\n foo(\n very_long_call(\n bar\n )\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"does not apply to strings\" do\n bad = \"foo(\\\"very long string\\\")\"\n\n good = \"\"\"\n foo(\n \"very long string\"\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"for functions\" do\n assert_same \"\"\"\n foo(fn x -> y end)\n \"\"\"\n\n assert_same \"\"\"\n foo(fn\n a1 -> :ok\n b2 -> :error\n end)\n \"\"\"\n\n assert_same \"\"\"\n foo(bar, fn\n a1 -> :ok\n b2 -> :error\n end)\n \"\"\"\n\n assert_same \"\"\"\n foo(fn x ->\n :really_long_atom\n end)\n \"\"\",\n @medium_length\n\n assert_same \"\"\"\n foo(bar, fn\n a1 ->\n :ok\n\n b2 ->\n :really_long_error\n end)\n \"\"\",\n @medium_length\n end\n\n test \"for heredocs\" do\n assert_same \"\"\"\n foo(~c'''\n bar\n ''')\n \"\"\"\n\n assert_same ~S'''\n foo(\"\"\"\n bar\n \"\"\")\n '''\n\n assert_same \"\"\"\n foo(~S'''\n bar\n ''')\n \"\"\"\n\n assert_same \"\"\"\n foo(~S'''\n very long line does trigger another break\n ''')\n \"\"\",\n @short_length\n end\n\n test \"for lists\" do\n bad = \"foo([1, 2, 3, 4])\"\n\n good = \"\"\"\n foo([\n 1,\n 2,\n 3,\n 4\n ])\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"for {} calls\" do\n bad = \"\"\"\n alias Foo.{\n Bar, Baz\n }\n \"\"\"\n\n good = \"\"\"\n alias Foo.{\n Bar,\n Baz\n }\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"for binaries only on eol\" do\n bad = \"foo(<<1, 2, 3, 4>>)\"\n\n good = \"\"\"\n foo(\n <<1, 2,\n 3, 4>>\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n foo(<<\n # foo\n 1,\n 2,\n 3,\n 4>>)\n \"\"\"\n\n good = \"\"\"\n foo(<<\n # foo\n 1,\n 2,\n 3,\n 4\n >>)\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"for maps\" do\n assert_same \"a(%{x: 1})\", @short_length\n assert_format \"ab(%{x: 1})\", \"ab(%{\\n x: 1\\n})\", @short_length\n end\n end\n\n describe \"local calls\" do\n test \"without arguments\" do\n assert_format \"foo( )\", \"foo()\"\n end\n\n test \"without arguments doesn't split on line limit\" do\n assert_same \"very_long_function_name()\", @short_length\n end\n\n test \"removes outer parens except for unquote_splicing/1\" do\n assert_format \"(foo())\", \"foo()\"\n assert_same \"(unquote_splicing(123))\"\n end\n\n test \"with arguments\" do\n assert_format \"foo( :one ,:two,\\n :three)\", \"foo(:one, :two, :three)\"\n end\n\n test \"with arguments splits on line limit\" do\n bad = \"\"\"\n fun(x, y, z)\n \"\"\"\n\n good = \"\"\"\n fun(\n x,\n y,\n z\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with arguments on comma limit\" do\n bad = \"\"\"\n import(foo(abc, cde), :next)\n \"\"\"\n\n good = \"\"\"\n import(\n foo(abc, cde),\n :next\n )\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"with keyword lists\" do\n assert_same \"foo(foo: 1, bar: 2)\"\n assert_same \"foo(:hello, foo: 1, bar: 2)\"\n\n bad = \"\"\"\n foo(:hello, foo: 1, bar: 2)\n \"\"\"\n\n good = \"\"\"\n foo(\n :hello,\n foo: 1,\n bar: 2\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n foo(:hello, foo: 1,\n bar: 2, baz: 3)\n \"\"\"\n\n assert_format bad, \"\"\"\n foo(:hello, foo: 1, bar: 2, baz: 3)\n \"\"\"\n end\n\n test \"with lists maybe rewritten as keyword lists\" do\n assert_format \"foo([foo: 1, bar: 2])\", \"foo(foo: 1, bar: 2)\"\n assert_format \"foo(:arg, [foo: 1, bar: 2])\", \"foo(:arg, foo: 1, bar: 2)\"\n assert_same \"foo(:arg, [:elem, foo: 1, bar: 2])\"\n end\n\n test \"without parens\" do\n assert_same \"import :foo, :bar\"\n assert_same \"bar = if foo, do: bar, else: baz\"\n\n assert_same \"\"\"\n for :one,\n :two,\n :three,\n fn ->\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n for :one, fn ->\n :ok\n end\n \"\"\"\n end\n\n test \"without parens on line limit\" do\n bad = \"import :long_atom, :other_arg\"\n\n good = \"\"\"\n import :long_atom,\n :other_arg\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"without parens on comma limit\" do\n bad = \"\"\"\n import foo(abc, cde), :next\n \"\"\"\n\n good = \"\"\"\n import foo(\n abc,\n cde\n ),\n :next\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"without parens and with keyword lists preserves multiline\" do\n assert_same \"\"\"\n defstruct foo: 1,\n bar: 2\n \"\"\"\n\n assert_same \"\"\"\n config :app,\n foo: 1\n \"\"\"\n\n assert_same \"\"\"\n config :app,\n foo: 1,\n bar: 2\n \"\"\"\n\n assert_same \"\"\"\n config :app, :key,\n foo: 1,\n bar: 2\n \"\"\"\n\n assert_same \"\"\"\n config :app,\n :key,\n foo: 1,\n bar: 2\n \"\"\"\n\n bad = \"\"\"\n config :app, foo: 1,\n bar: 2\n \"\"\"\n\n assert_format bad, \"\"\"\n config :app,\n foo: 1,\n bar: 2\n \"\"\"\n end\n\n test \"without parens and with keyword lists on comma limit\" do\n bad = \"\"\"\n import foo(abc, cde), opts: :next\n \"\"\"\n\n good = \"\"\"\n import foo(\n abc,\n cde\n ),\n opts: :next\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"without parens and with keyword lists on line limit\" do\n assert_same \"import :atom, opts: [foo: :bar]\"\n\n bad = \"import :atom, opts: [foo: :bar]\"\n\n good = \"\"\"\n import :atom,\n opts: [foo: :bar]\n \"\"\"\n\n assert_format bad, good, @medium_length\n\n bad = \"import :atom, really_long_key: [foo: :bar]\"\n\n good = \"\"\"\n import :atom,\n really_long_key: [\n foo: :bar\n ]\n \"\"\"\n\n assert_format bad, good, @medium_length\n\n assert_same \"\"\"\n import :foo,\n one: two,\n three: four,\n five: [6, 7, 8, 9]\n \"\"\",\n @medium_length\n\n assert_same \"\"\"\n import :really_long_atom_but_no_breaks,\n one: two,\n three: four\n \"\"\",\n @medium_length\n\n bad = \"with :really_long_atom1, :really_long_atom2, opts: [foo: :bar]\"\n\n good = \"\"\"\n with :really_long_atom1,\n :really_long_atom2,\n opts: [\n foo: :bar\n ]\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"without parens from option\" do\n assert_format \"foo bar\", \"foo(bar)\"\n assert_same \"foo bar\", locals_without_parens: [foo: 1]\n assert_same \"foo(bar)\", locals_without_parens: [foo: 1]\n assert_same \"foo bar\", locals_without_parens: [foo: :*]\n assert_same \"foo(bar)\", locals_without_parens: [foo: :*]\n end\n\n test \"without parens on unique argument\" do\n assert_same \"foo(for 1, 2, 3)\"\n assert_same \"foo(bar, for(1, 2, 3))\"\n assert_same \"assert for 1, 2, 3\"\n assert_same \"assert foo, for(1, 2, 3)\"\n\n assert_same \"\"\"\n assert for 1, 2, 3 do\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n assert foo, for(1, 2, 3) do\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n assert for(1, 2, 3) do\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n assert (for 1, 2, 3 do\n :ok\n end)\n \"\"\"\n end\n\n test \"call on call\" do\n assert_same \"unquote(call)()\"\n assert_same \"unquote(call)(one, two)\"\n\n assert_same \"\"\"\n unquote(call)() do\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n unquote(call)(one, two) do\n :ok\n end\n \"\"\"\n end\n\n test \"call on call on line limit\" do\n bad = \"foo(bar)(one, two, three)\"\n\n good = \"\"\"\n foo(bar)(\n one,\n two,\n three\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with generators\" do\n assert_same \"foo(bar <- baz, is_bat(bar))\"\n assert_same \"for bar <- baz, is_bat(bar)\"\n\n assert_same \"\"\"\n foo(\n bar <- baz,\n is_bat(bar),\n bat <- bar\n )\n \"\"\"\n\n assert_same \"\"\"\n for bar <- baz,\n is_bat(bar),\n bat <- bar\n \"\"\"\n\n assert_same \"\"\"\n for bar <- baz,\n is_bat(bar),\n bat <- bar do\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n for bar <- baz,\n is_bat(bar),\n bat <- bar,\n into: %{}\n \"\"\"\n end\n\n test \"preserves user choice on parens even when it fits\" do\n assert_same \"\"\"\n call(\n :hello,\n :foo,\n :bar\n )\n \"\"\"\n\n assert_same \"\"\"\n call(\n :hello,\n :foo,\n :bar\n ) do\n 1 + 2\n end\n \"\"\"\n\n # Doesn't preserve this because only the ending has a newline\n assert_format \"call(foo, bar, baz\\n)\", \"call(foo, bar, baz)\"\n\n # Doesn't preserve because there are no args\n bad = \"\"\"\n call() do\n 1 + 2\n end\n \"\"\"\n\n assert_format bad, \"\"\"\n call do\n 1 + 2\n end\n \"\"\"\n\n # Doesn't preserve because we have a single argument with next break fits\n bad = \"\"\"\n call(\n %{\n key: :value\n }\n )\n \"\"\"\n\n assert_format bad, \"\"\"\n call(%{\n key: :value\n })\n \"\"\"\n end\n end\n\n describe \"remote calls\" do\n test \"with no arguments\" do\n assert_format \"Foo . Bar . baz\", \"Foo.Bar.baz()\"\n assert_format \":erlang.\\nget_stacktrace\", \":erlang.get_stacktrace()\"\n assert_format \"@foo.bar\", \"@foo.bar\"\n assert_format \"@foo.bar()\", \"@foo.bar()\"\n assert_format \"(@foo).bar()\", \"@foo.bar()\"\n assert_format \"__MODULE__.start_link\", \"__MODULE__.start_link()\"\n assert_format \"Foo.bar.baz.bong\", \"Foo.bar().baz.bong\"\n assert_format \"(1 + 2).foo\", \"(1 + 2).foo\"\n assert_format \"(1 + 2).foo()\", \"(1 + 2).foo()\"\n end\n\n test \"with arguments\" do\n assert_format \"Foo . Bar. baz(1, 2, 3)\", \"Foo.Bar.baz(1, 2, 3)\"\n assert_format \":erlang.\\nget(\\n:some_key)\", \":erlang.get(:some_key)\"\n assert_format \":erlang.\\nget(:some_key\\n)\", \":erlang.get(:some_key)\"\n assert_same \"@foo.bar(1, 2, 3)\"\n assert_same \"__MODULE__.start_link(1, 2, 3)\"\n assert_same \"foo.bar(1).baz(2, 3)\"\n end\n\n test \"inspects function names correctly\" do\n assert_same ~S[MyModule.\"my function\"(1, 2)]\n assert_same ~S[MyModule.\"Foo.Bar\"(1, 2)]\n assert_same ~S[Kernel.+(1, 2)]\n assert_same ~S[:erlang.+(1, 2)]\n assert_same ~S[foo.\"bar baz\"(1, 2)]\n assert_same ~S[foo.\"bar\\nbaz\"(1, 2)]\n end\n\n test \"splits on arguments and dot on line limit\" do\n bad = \"\"\"\n MyModule.Foo.bar(:one, :two, :three)\n \"\"\"\n\n good = \"\"\"\n MyModule.Foo.bar(\n :one,\n :two,\n :three\n )\n \"\"\"\n\n assert_format bad, good, @medium_length\n\n bad = \"\"\"\n My_function.foo().bar(2, 3).baz(4, 5)\n \"\"\"\n\n good = \"\"\"\n My_function.foo().bar(\n 2,\n 3\n ).baz(4, 5)\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"doesn't split on parens on empty arguments\" do\n assert_same \"Mod.func()\", @short_length\n end\n\n test \"with keyword lists\" do\n assert_same \"mod.foo(foo: 1, bar: 2)\"\n\n assert_same \"mod.foo(:hello, foo: 1, bar: 2)\"\n\n assert_same \"\"\"\n mod.really_long_function_name(\n :hello,\n foo: 1,\n bar: 2\n )\n \"\"\",\n @short_length\n\n assert_same \"\"\"\n really_long_module_name.foo(\n :hello,\n foo: 1,\n bar: 2\n )\n \"\"\",\n @short_length\n end\n\n test \"wraps left side in parens if it is an anonymous function\" do\n assert_same \"(fn -> :ok end).foo\"\n end\n\n test \"wraps left side in parens if it is a do-end block\" do\n assert_same \"\"\"\n (if true do\n :ok\n end).foo\n \"\"\"\n end\n\n test \"wraps left side in parens if it is a do-end block as an argument\" do\n assert_same \"\"\"\n import (if true do\n :ok\n end).foo\n \"\"\"\n end\n\n test \"call on call\" do\n assert_same \"foo.bar(call)()\"\n assert_same \"foo.bar(call)(one, two)\"\n\n assert_same \"\"\"\n foo.bar(call)() do\n end\n \"\"\"\n\n assert_same \"\"\"\n foo.bar(call)(one, two) do\n :ok\n end\n \"\"\"\n end\n\n test \"call on call on line limit\" do\n bad = \"a.b(foo)(one, two, three)\"\n\n good = \"\"\"\n a.b(foo)(\n one,\n two,\n three\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"on vars\" do\n assert_same \"foo.bar\"\n assert_same \"foo.bar()\"\n end\n\n test \"on vars before blocks\" do\n assert_same \"\"\"\n if var.field do\n raise \"oops\"\n end\n \"\"\"\n end\n\n test \"on vars before brackets\" do\n assert_same \"\"\"\n exception.opts[:foo]\n \"\"\"\n end\n\n test \"preserves user choice on parens even when it fits\" do\n assert_same \"\"\"\n Remote.call(\n :hello,\n :foo,\n :bar\n )\n \"\"\"\n\n # Doesn't preserve this because only the ending has a newline\n assert_format \"Remote.call(foo, bar, baz\\n)\", \"Remote.call(foo, bar, baz)\"\n\n assert_same \"\"\"\n Remote.call(\n :hello,\n :foo,\n fn -> :bar end\n )\n \"\"\"\n end\n end\n\n describe \"anonymous function calls\" do\n test \"without arguments\" do\n assert_format \"foo . ()\", \"foo.()\"\n assert_format \"(foo.()).().()\", \"foo.().().()\"\n assert_same \"@foo.()\"\n assert_same \"(1 + 1).()\"\n assert_same \":foo.()\"\n end\n\n test \"with arguments\" do\n assert_format \"foo . (1, 2 , 3 )\", \"foo.(1, 2, 3)\"\n assert_format \"foo . (1, 2 ).(3,4)\", \"foo.(1, 2).(3, 4)\"\n assert_same \"@foo.(:one, :two)\"\n assert_same \"foo.(1 + 1).(hello)\"\n end\n\n test \"does not split on dot on line limit\" do\n assert_same \"my_function.()\", @short_length\n end\n\n test \"splits on arguments on line limit\" do\n bad = \"\"\"\n my_function.(1, 2, 3)\n \"\"\"\n\n good = \"\"\"\n my_function.(\n 1,\n 2,\n 3\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n my_function.(1, 2).f(3, 4).(5, 6)\n \"\"\"\n\n good = \"\"\"\n my_function.(\n 1,\n 2\n ).f(3, 4).(\n 5,\n 6\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with keyword lists\" do\n assert_same \"foo.(foo: 1, bar: 2)\"\n\n assert_same \"foo.(:hello, foo: 1, bar: 2)\"\n\n assert_same \"\"\"\n foo.(\n :hello,\n foo: 1,\n bar: 2\n )\n \"\"\",\n @short_length\n end\n\n test \"wraps left side in parens if it is an anonymous function\" do\n assert_same \"(fn -> :ok end).()\"\n end\n\n test \"wraps left side in parens if it is a do-end block\" do\n assert_same \"\"\"\n (if true do\n :ok\n end).()\n \"\"\"\n end\n\n test \"wraps left side in parens if it is a do-end block as an argument\" do\n assert_same \"\"\"\n import (if true do\n :ok\n end).()\n \"\"\"\n end\n\n test \"preserves user choice on parens even when it fits\" do\n assert_same \"\"\"\n call.(\n :hello,\n :foo,\n :bar\n )\n \"\"\"\n\n # Doesn't preserve this because only the ending has a newline\n assert_format \"call.(foo, bar, baz\\n)\", \"call.(foo, bar, baz)\"\n end\n end\n\n describe \"do-end blocks\" do\n test \"with non-block keywords\" do\n assert_same \"foo(do: nil)\"\n end\n\n test \"with forced block keywords\" do\n good = \"\"\"\n foo do\n nil\n end\n \"\"\"\n\n assert_format \"foo(do: nil)\", good, force_do_end_blocks: true\n\n # Avoid false positives\n assert_same \"foo(do: 1, do: 2)\", force_do_end_blocks: true\n assert_same \"foo(do: 1, another: 2)\", force_do_end_blocks: true\n end\n\n test \"with multiple keywords\" do\n assert_same \"\"\"\n foo do\n :do\n rescue\n :rescue\n catch\n :catch\n else\n :else\n after\n :after\n end\n \"\"\"\n end\n\n test \"with multiple keywords and arrows\" do\n assert_same \"\"\"\n foo do\n a1 -> a2\n b1 -> b2\n rescue\n a1 -> a2\n b1 -> b2\n catch\n a1 -> a2\n b1 -> b2\n else\n a1 -> a2\n b1 -> b2\n after\n a1 -> a2\n b1 -> b2\n end\n \"\"\"\n end\n\n test \"with no extra arguments\" do\n assert_same \"\"\"\n foo do\n :ok\n end\n \"\"\"\n end\n\n test \"with no extra arguments and line breaks\" do\n assert_same \"\"\"\n foo do\n a1 ->\n really_long_line\n\n b1 ->\n b2\n rescue\n c1\n catch\n d1 -> d1\n e1 -> e1\n else\n f2\n after\n g1 ->\n really_long_line\n\n h1 ->\n h2\n end\n \"\"\",\n @medium_length\n end\n\n test \"with extra arguments\" do\n assert_same \"\"\"\n foo bar, baz do\n :ok\n end\n \"\"\"\n end\n\n test \"with extra arguments and line breaks\" do\n assert_same \"\"\"\n foo bar do\n a1 ->\n really_long_line\n\n b1 ->\n b2\n rescue\n c1\n catch\n d1 -> d1\n e1 -> e1\n else\n f2\n after\n g1 ->\n really_long_line\n\n h1 ->\n h2\n end\n \"\"\",\n @medium_length\n\n assert_same \"\"\"\n foo really,\n long,\n list,\n of,\n arguments do\n a1 ->\n really_long_line\n\n b1 ->\n b2\n rescue\n c1\n catch\n d1 -> d1\n e1 -> e1\n else\n f2\n after\n g1 ->\n really_long_line\n\n h1 ->\n h2\n end\n \"\"\",\n @medium_length\n end\n\n test \"when empty\" do\n assert_same \"\"\"\n foo do\n end\n \"\"\"\n\n assert_same \"\"\"\n foo do\n rescue\n catch\n else\n after\n end\n \"\"\"\n end\n\n test \"inside call\" do\n bad = \"foo (bar do :ok end)\"\n\n good = \"\"\"\n foo(\n bar do\n :ok\n end\n )\n \"\"\"\n\n assert_format bad, good\n\n bad = \"import (bar do :ok end)\"\n\n good = \"\"\"\n import (bar do\n :ok\n end)\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"inside operator\" do\n bad = \"foo + bar do :ok end\"\n\n good = \"\"\"\n foo +\n bar do\n :ok\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"inside operator inside argument\" do\n bad = \"fun foo + (bar do :ok end)\"\n\n good = \"\"\"\n fun(\n foo +\n bar do\n :ok\n end\n )\n \"\"\"\n\n assert_format bad, good\n\n bad = \"if foo + (bar do :ok end) do :ok end\"\n\n good = \"\"\"\n if foo +\n (bar do\n :ok\n end) do\n :ok\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"inside operator inside argument with remote call\" do\n bad = \"if foo + (Bar.baz do :ok end) do :ok end\"\n\n good = \"\"\"\n if foo +\n (Bar.baz do\n :ok\n end) do\n :ok\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"keeps repeated keys\" do\n assert_same \"\"\"\n receive do\n :ok\n after\n 0 -> 1\n after\n 2 -> 3\n end\n \"\"\"\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n case do\n 1 ->\n :ok\n\n 2 ->\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n case do\n 1 ->\n :ok\n\n 2 ->\n :ok\n\n 3 ->\n :ok\n end\n \"\"\"\n end\n end\n\n describe \"tuple calls\" do\n test \"without arguments\" do\n assert_format \"foo . {}\", \"foo.{}\"\n end\n\n test \"with arguments\" do\n assert_format \"foo.{bar,baz,bat,}\", \"foo.{bar, baz, bat}\"\n end\n\n test \"with arguments on line limit\" do\n bad = \"foo.{bar,baz,bat,}\"\n\n good = \"\"\"\n foo.{\n bar,\n baz,\n bat\n }\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"really_long_expression.{bar,baz,bat,}\"\n\n good = \"\"\"\n really_long_expression.{\n bar,\n baz,\n bat\n }\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with keywords\" do\n assert_same \"expr.{:hello, foo: bar, baz: bat}\"\n end\n\n test \"preserves user choice on parens even when it fits\" do\n assert_same \"\"\"\n call.{\n :hello,\n :foo,\n :bar\n }\n \"\"\"\n\n assert_format \"call.{foo, bar, baz\\n}\", \"call.{foo, bar, baz}\"\n end\n end\n\n describe \"access\" do\n test \"with one argument\" do\n assert_format \"foo[ bar ]\", \"foo[bar]\"\n end\n\n test \"with arguments on line limit\" do\n bad = \"foo[really_long_argument()]\"\n\n good = \"\"\"\n foo[\n really_long_argument()\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"really_long_expression[really_long_argument()]\"\n\n good = \"\"\"\n really_long_expression[\n really_long_argument()\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with do-end blocks\" do\n assert_same \"\"\"\n (if true do\n false\n end)[key]\n \"\"\"\n end\n\n test \"with keywords\" do\n assert_format \"expr[[]]\", \"expr[[]]\"\n assert_format \"expr[foo: bar, baz: bat]\", \"expr[foo: bar, baz: bat]\"\n assert_format \"expr[[foo: bar, baz: bat]]\", \"expr[[foo: bar, baz: bat]]\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/comments_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.CommentsTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n @short_length [line_length: 10]\n\n describe \"at the root\" do\n test \"for empty documents\" do\n assert_same \"# hello world\"\n end\n\n test \"are reformatted\" do\n assert_format \"#oops\", \"# oops\"\n assert_format \"##oops\", \"## oops\"\n assert_same \"# ## oops\"\n end\n\n test \"recognizes hashbangs\" do\n assert_format \"#! /usr/bin/env elixir\", \"#! /usr/bin/env elixir\"\n assert_format \"#!/usr/bin/env elixir\", \"#!/usr/bin/env elixir\"\n assert_same \"#!\"\n end\n\n test \"before and after expressions\" do\n assert_same \"\"\"\n # before comment\n :hello\n \"\"\"\n\n assert_same \"\"\"\n :hello\n # after comment\n \"\"\"\n\n assert_same \"\"\"\n # before comment\n :hello\n # after comment\n \"\"\"\n end\n\n test \"on expressions\" do\n bad = \"\"\"\n :hello # this is hello\n :world # this is world\n \"\"\"\n\n good = \"\"\"\n # this is hello\n :hello\n # this is world\n :world\n \"\"\"\n\n assert_format bad, good\n\n bad = \"\"\"\n foo # this is foo\n ++ bar # this is bar\n ++ baz # this is baz\n \"\"\"\n\n good = \"\"\"\n # this is foo\n # this is bar\n # this is baz\n foo ++\n bar ++\n baz\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"empty comment\" do\n assert_same \"\"\"\n #\n :foo\n \"\"\"\n end\n\n test \"before and after expressions with newlines\" do\n assert_same \"\"\"\n # before comment\n # second line\n\n :hello\n\n # middle comment 1\n\n #\n\n # middle comment 2\n\n :world\n\n # after comment\n # second line\n \"\"\"\n end\n end\n\n describe \"modules attributes\" do\n test \"with comments around\" do\n assert_same \"\"\"\n defmodule Sample do\n # Comment 0\n @moduledoc false\n # Comment 1\n\n # Comment 2\n @attr1 1\n # Comment 3\n\n # Comment 4\n @doc \"Doc\"\n # Comment 5\n @attr2 2\n # Comment 6\n def sample, do: :sample\n end\n \"\"\"\n end\n\n test \"with comments only after\" do\n assert_same \"\"\"\n @moduledoc false\n # Comment 1\n\n @attr 1\n \"\"\"\n end\n\n test \"with too many new lines\" do\n bad = \"\"\"\n defmodule Sample do\n\n # Comment 0\n\n\n @moduledoc false\n\n\n # Comment 1\n\n\n # Comment 2\n\n\n @attr1 1\n\n\n # Comment 3\n\n\n # Comment 4\n\n\n @doc \"Doc\"\n\n\n # Comment 5\n\n\n @attr2 2\n\n\n # Comment 6\n\n\n def sample, do: :sample\n end\n \"\"\"\n\n assert_format bad, \"\"\"\n defmodule Sample do\n # Comment 0\n\n @moduledoc false\n\n # Comment 1\n\n # Comment 2\n\n @attr1 1\n\n # Comment 3\n\n # Comment 4\n\n @doc \"Doc\"\n\n # Comment 5\n\n @attr2 2\n\n # Comment 6\n\n def sample, do: :sample\n end\n \"\"\"\n end\n end\n\n describe \"interpolation\" do\n test \"with comment outside before, during and after\" do\n assert_same ~S\"\"\"\n # comment\n IO.puts(\"Hello #{world}\")\n \"\"\"\n\n assert_same ~S\"\"\"\n IO.puts(\"Hello #{world}\")\n # comment\n \"\"\"\n end\n\n test \"with trailing comments\" do\n # This is trailing so we move the comment out\n trailing = ~S\"\"\"\n IO.puts(\"Hello #{world}\") # comment\n \"\"\"\n\n assert_format trailing, ~S\"\"\"\n # comment\n IO.puts(\"Hello #{world}\")\n \"\"\"\n\n # This is ambiguous so we move the comment out\n ambiguous = ~S\"\"\"\n IO.puts(\"Hello #{world # comment\n }\")\n \"\"\"\n\n assert_format ambiguous, ~S\"\"\"\n # comment\n IO.puts(\"Hello #{world}\")\n \"\"\"\n end\n\n test \"with comment inside before and after\" do\n bad = ~S\"\"\"\n IO.puts(\n \"Hello #{\n # comment\n world\n }\"\n )\n \"\"\"\n\n good = ~S\"\"\"\n IO.puts(\n # comment\n \"Hello #{world}\"\n )\n \"\"\"\n\n assert_format bad, good\n\n bad = ~S\"\"\"\n IO.puts(\n \"Hello #{\n world\n # comment\n }\"\n )\n \"\"\"\n\n good = ~S\"\"\"\n IO.puts(\n \"Hello #{world}\"\n # comment\n )\n \"\"\"\n\n assert_format bad, good\n\n bad = ~S\"\"\"\n IO.puts(\"Hello #{hello\n world}\")\n \"\"\"\n\n good = ~S\"\"\"\n IO.puts(\n \"Hello #{hello\n world}\"\n )\n \"\"\"\n\n assert_format bad, good\n end\n end\n\n describe \"parens blocks\" do\n test \"with comment outside before and after\" do\n assert_same ~S\"\"\"\n # comment\n assert (\n hello\n world\n )\n \"\"\"\n\n assert_same ~S\"\"\"\n assert (\n hello\n world\n )\n\n # comment\n \"\"\"\n end\n\n test \"with trailing comments\" do\n # This is ambiguous so we move the comment out\n ambiguous = ~S\"\"\"\n assert ( # comment\n hello\n world\n )\n \"\"\"\n\n assert_format ambiguous, ~S\"\"\"\n # comment\n assert (\n hello\n world\n )\n \"\"\"\n\n # This is ambiguous so we move the comment out\n ambiguous = ~S\"\"\"\n assert (\n hello\n world\n ) # comment\n \"\"\"\n\n assert_format ambiguous, ~S\"\"\"\n assert (\n hello\n world\n )\n\n # comment\n \"\"\"\n end\n\n test \"with comment inside before and after\" do\n assert_same ~S\"\"\"\n assert (\n # comment\n hello\n world\n )\n \"\"\"\n\n assert_same ~S\"\"\"\n assert (\n hello\n world\n # comment\n )\n \"\"\"\n end\n end\n\n describe \"access\" do\n test \"before and after single arg\" do\n assert_same ~S\"\"\"\n foo[\n # bar\n baz\n # bat\n ]\n \"\"\"\n end\n\n test \"before and after keywords\" do\n assert_same ~S\"\"\"\n foo[\n # bar\n one: :two,\n # baz\n three: :four\n # bat\n ]\n \"\"\"\n end\n end\n\n describe \"calls\" do\n test \"local with parens inside before and after\" do\n assert_same ~S\"\"\"\n call(\n # before\n hello,\n # middle\n world\n # after\n )\n \"\"\"\n\n assert_same ~S\"\"\"\n call(\n # command\n )\n \"\"\"\n end\n\n test \"remote with parens inside before and after\" do\n assert_same ~S\"\"\"\n Remote.call(\n # before\n hello,\n # middle\n world\n # after\n )\n \"\"\"\n\n assert_same ~S\"\"\"\n Remote.call(\n # command\n )\n \"\"\"\n end\n\n test \"local with parens and keywords inside before and after\" do\n assert_same ~S\"\"\"\n call(\n # before\n hello,\n # middle\n world,\n # key before\n key: hello,\n # key middle\n key: world\n # key after\n )\n \"\"\"\n end\n\n test \"remote with parens and keywords inside before and after\" do\n assert_same ~S\"\"\"\n call(\n # before\n hello,\n # middle\n world,\n # key before\n key: hello,\n # key middle\n key: world\n # key after\n )\n \"\"\"\n end\n\n test \"local with no parens inside before and after\" do\n bad = ~S\"\"\"\n # before\n assert hello,\n # middle\n world\n # after\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # before\n assert hello,\n # middle\n world\n\n # after\n \"\"\"\n end\n\n test \"local with no parens and keywords inside before and after\" do\n bad = ~S\"\"\"\n config hello, world,\n # key before\n key: hello,\n # key middle\n key: world\n # key after\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n config hello, world,\n # key before\n key: hello,\n # key middle\n key: world\n\n # key after\n \"\"\"\n\n bad = ~S\"\"\"\n # before\n config hello,\n # middle\n world,\n # key before\n key: hello,\n # key middle\n key: world\n # key after\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # before\n config hello,\n # middle\n world,\n # key before\n key: hello,\n # key middle\n key: world\n\n # key after\n \"\"\"\n end\n end\n\n describe \"anonymous functions\" do\n test \"with one clause and no args\" do\n assert_same ~S\"\"\"\n fn ->\n # comment\n hello\n world\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n fn ->\n hello\n world\n # comment\n end\n \"\"\"\n end\n\n test \"with one clause and no args and trailing comments\" do\n bad = ~S\"\"\"\n fn # comment\n ->\n hello\n world\n end\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # comment\n fn ->\n hello\n world\n end\n \"\"\"\n\n bad = ~S\"\"\"\n fn\n # comment\n ->\n hello\n world\n end\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # comment\n fn ->\n hello\n world\n end\n \"\"\"\n end\n\n test \"with one clause and args\" do\n assert_same ~S\"\"\"\n fn hello ->\n # before\n hello\n # middle\n world\n # after\n end\n \"\"\"\n end\n\n test \"with one clause and args and trailing comments\" do\n bad = ~S\"\"\"\n fn # fn\n # before head\n hello # middle head\n # after head\n ->\n # before body\n world # middle body\n # after body\n end\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # fn\n fn\n # before head\n # middle head\n hello ->\n # after head\n # before body\n # middle body\n world\n # after body\n end\n \"\"\"\n end\n\n test \"with multiple clauses and args\" do\n bad = ~S\"\"\"\n fn # fn\n # before one\n one, # middle one\n # after one / before two\n two # middle two\n # after two\n ->\n # before hello\n hello # middle hello\n # after hello\n\n # before three\n three # middle three\n # after three\n ->\n # before world\n world # middle world\n # after world\n end\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # fn\n fn\n # before one\n # middle one\n # after one / before two\n # middle two\n one, two ->\n # after two\n # before hello\n # middle hello\n hello\n\n # after hello\n\n # before three\n # middle three\n three ->\n # after three\n # before world\n # middle world\n world\n # after world\n end\n \"\"\"\n end\n\n test \"with commented out clause\" do\n assert_same \"\"\"\n fn\n arg1 ->\n body1\n\n # arg2 ->\n # body 2\n\n arg3 ->\n body3\n end\n \"\"\"\n end\n end\n\n describe \"do-end blocks\" do\n test \"with comment outside before and after\" do\n assert_same ~S\"\"\"\n # comment\n assert do\n hello\n world\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n assert do\n hello\n world\n end\n\n # comment\n \"\"\"\n end\n\n test \"with trailing comments\" do\n # This is ambiguous so we move the comment out\n ambiguous = ~S\"\"\"\n assert do # comment\n hello\n world\n end\n \"\"\"\n\n assert_format ambiguous, ~S\"\"\"\n # comment\n assert do\n hello\n world\n end\n \"\"\"\n\n # This is ambiguous so we move the comment out\n ambiguous = ~S\"\"\"\n assert do\n hello\n world\n end # comment\n \"\"\"\n\n assert_format ambiguous, ~S\"\"\"\n assert do\n hello\n world\n end\n\n # comment\n \"\"\"\n end\n\n test \"with comment inside before and after\" do\n assert_same ~S\"\"\"\n assert do\n # comment\n hello\n world\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n assert do\n hello\n world\n # comment\n end\n \"\"\"\n end\n\n test \"with comment inside before and after and multiple keywords\" do\n assert_same ~S\"\"\"\n assert do\n # before\n hello\n world\n # after\n rescue\n # before\n hello\n world\n # after\n after\n # before\n hello\n world\n # after\n catch\n # before\n hello\n world\n # after\n else\n # before\n hello\n world\n # after\n end\n \"\"\"\n end\n\n test \"when empty\" do\n assert_same ~S\"\"\"\n assert do\n # comment\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n assert do\n # comment\n rescue\n # comment\n after\n # comment\n catch\n # comment\n else\n # comment\n end\n \"\"\"\n end\n\n test \"with one-line clauses\" do\n bad = ~S\"\"\"\n assert do # do\n # before\n one -> two\n end\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # do\n assert do\n # before\n one -> two\n end\n \"\"\"\n\n bad = ~S\"\"\"\n assert do # do\n # before\n one -> two\n # after\n three -> four\n end\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # do\n assert do\n # before\n one -> two\n # after\n three -> four\n end\n \"\"\"\n end\n\n test \"with multiple clauses and args\" do\n bad = ~S\"\"\"\n assert do # do\n # before one\n one, # middle one\n # after one / before two\n two # middle two\n # after two\n ->\n # before hello\n hello # middle hello\n # after hello\n\n # before three\n three # middle three\n # after three\n ->\n # before world\n world # middle world\n # after world\n end\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n # do\n assert do\n # before one\n # middle one\n # after one / before two\n # middle two\n one, two ->\n # after two\n # before hello\n # middle hello\n hello\n\n # after hello\n\n # before three\n # middle three\n three ->\n # after three\n # before world\n # middle world\n world\n # after world\n end\n \"\"\"\n end\n end\n\n describe \"operators\" do\n test \"with comment before, during and after uniform pipelines\" do\n assert_same \"\"\"\n foo\n # |> bar\n # |> baz\n |> bat\n \"\"\"\n\n bad = \"\"\"\n # before\n foo # this is foo\n |> bar # this is bar\n |> baz # this is baz\n # after\n \"\"\"\n\n good = \"\"\"\n # before\n # this is foo\n foo\n # this is bar\n |> bar\n # this is baz\n |> baz\n\n # after\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with comment before, during and after mixed pipelines\" do\n assert_same \"\"\"\n foo\n # |> bar\n # |> baz\n ~> bat\n \"\"\"\n\n bad = \"\"\"\n # before\n foo # this is foo\n ~> bar # this is bar\n <~> baz # this is baz\n # after\n \"\"\"\n\n good = \"\"\"\n # before\n # this is foo\n foo\n # this is bar\n ~> bar\n # this is baz\n <~> baz\n\n # after\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with comment before, during and after uniform right\" do\n assert_same \"\"\"\n foo\n # | bar\n # | baz\n | bat\n \"\"\"\n\n bad = \"\"\"\n # before\n foo # this is foo\n | bar # this is bar\n | baz # this is baz\n # after\n \"\"\"\n\n good = \"\"\"\n # before\n # this is foo\n foo\n # this is bar\n | bar\n # this is baz\n | baz\n\n # after\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with comment before, during and after mixed right\" do\n assert_same \"\"\"\n one\n # when two\n # when three\n when four\n # | five\n | six\n \"\"\"\n end\n\n test \"handles nodes without meta info\" do\n assert_same \"(a -> b) |> (c -> d)\"\n assert_same \"(a -> b) when c: d\"\n assert_same \"(a -> b) when (c -> d)\"\n end\n end\n\n describe \"containers\" do\n test \"with comment outside before, during and after\" do\n assert_same ~S\"\"\"\n # comment\n [one, two, three]\n \"\"\"\n\n assert_same ~S\"\"\"\n [one, two, three]\n # comment\n \"\"\"\n end\n\n test \"with trailing comments\" do\n # This is trailing so we move the comment out\n trailing = ~S\"\"\"\n [one, two, three] # comment\n \"\"\"\n\n assert_format trailing, ~S\"\"\"\n # comment\n [one, two, three]\n \"\"\"\n\n # This is ambiguous so we move the comment out\n ambiguous = ~S\"\"\"\n [# comment\n one, two, three]\n \"\"\"\n\n assert_format ambiguous, ~S\"\"\"\n # comment\n [\n one,\n two,\n three\n ]\n \"\"\"\n end\n\n test \"when empty\" do\n assert_same ~S\"\"\"\n [\n # comment\n ]\n \"\"\"\n end\n\n test \"with block\" do\n assert_same ~S\"\"\"\n [\n (\n # before\n multi\n line\n # after\n )\n ]\n \"\"\"\n end\n\n test \"with comments inside lists before and after\" do\n bad = ~S\"\"\"\n [\n # 1. one\n\n # 1. two\n # 1. three\n one,\n after_one,\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n three # final\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n ]\n \"\"\"\n\n good = ~S\"\"\"\n [\n # 1. one\n\n # 1. two\n # 1. three\n one,\n after_one,\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n # final\n three\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n ]\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with comments inside tuples before and after\" do\n bad = ~S\"\"\"\n {\n # 1. one\n\n # 1. two\n # 1. three\n one,\n after_one,\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n three # final\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n }\n \"\"\"\n\n good = ~S\"\"\"\n {\n # 1. one\n\n # 1. two\n # 1. three\n one,\n after_one,\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n # final\n three\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n }\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with comments inside bitstrings before and after\" do\n bad = ~S\"\"\"\n <<\n # 1. one\n\n # 1. two\n # 1. three\n one,\n after_one,\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n three # final\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n >>\n \"\"\"\n\n good = ~S\"\"\"\n <<\n # 1. one\n\n # 1. two\n # 1. three\n one,\n after_one,\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n # final\n three\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n >>\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with comments inside maps before and after\" do\n bad = ~S\"\"\"\n %{\n # 1. one\n\n # 1. two\n # 1. three\n one: one,\n one: after_one,\n one: after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n three: three # final\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n }\n \"\"\"\n\n good = ~S\"\"\"\n %{\n # 1. one\n\n # 1. two\n # 1. three\n one: one,\n one: after_one,\n one:\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n # final\n three: three\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n }\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with comments inside structs before and after\" do\n bad = ~S\"\"\"\n %Foo{bar |\n # 1. one\n\n # 1. two\n # 1. three\n one: one,\n one: after_one,\n one: after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n three: three # final\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n }\n \"\"\"\n\n good = ~S\"\"\"\n %Foo{\n bar\n | # 1. one\n\n # 1. two\n # 1. three\n one: one,\n one: after_one,\n one:\n after_one do\n :ok\n end,\n\n # 2. one\n\n # 2. two\n # 2. three\n # two,\n\n # 3. one\n\n # 3. two\n # 3. three\n # final\n three: three\n\n # 4. one\n\n # 4. two\n # 4. three\n # four\n }\n \"\"\"\n\n assert_format bad, good\n end\n end\n\n describe \"defstruct\" do\n test \"with first field comments\" do\n bad = ~S\"\"\"\n defmodule Foo do\n # defstruct\n defstruct [ # foo\n # 1. one\n one: 1, # 2. one\n # 1. two\n # 2. two\n two: 2\n ]\n end\n \"\"\"\n\n good = ~S\"\"\"\n defmodule Foo do\n # defstruct\n # foo\n defstruct [\n # 1. one\n # 2. one\n one: 1,\n # 1. two\n # 2. two\n two: 2\n ]\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with first field comments and defstruct has the parens\" do\n bad = ~S\"\"\"\n defmodule Foo do\n # defstruct\n defstruct([ # foo\n # 1. one\n one: 1, # 2. one\n # 1. two\n # 2. two\n two: 2\n ])\n end\n \"\"\"\n\n good = ~S\"\"\"\n defmodule Foo do\n # defstruct\n # foo\n defstruct(\n # 1. one\n # 2. one\n one: 1,\n # 1. two\n # 2. two\n two: 2\n )\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"without first field comments\" do\n bad = ~S\"\"\"\n defmodule Foo do\n # defstruct\n defstruct [\n one: 1,\n # 1. two\n two: 2 # 2. two\n ]\n end\n \"\"\"\n\n good = ~S\"\"\"\n defmodule Foo do\n # defstruct\n defstruct one: 1,\n # 1. two\n # 2. two\n two: 2\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"without field comments\" do\n bad = ~S\"\"\"\n defmodule Foo do\n # defstruct\n defstruct [\n one: 1,\n two: 2\n ]\n end\n \"\"\"\n\n good = ~S\"\"\"\n defmodule Foo do\n # defstruct\n defstruct one: 1,\n two: 2\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"without square brackets\" do\n assert_same ~S\"\"\"\n defmodule Foo do\n # defstruct\n defstruct one: 1,\n # 1. two\n # 2. two\n two: 2\n end\n \"\"\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/containers_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.ContainersTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n @short_length [line_length: 10]\n @medium_length [line_length: 20]\n\n describe \"tuples\" do\n test \"without arguments\" do\n assert_format \"{ }\", \"{}\"\n end\n\n test \"with arguments\" do\n assert_format \"{1,2}\", \"{1, 2}\"\n assert_format \"{1,2,3}\", \"{1, 2, 3}\"\n end\n\n test \"is flex on line limits\" do\n bad = \"{1, 2, 3, 4}\"\n\n good = \"\"\"\n {1, 2, 3,\n 4}\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"removes trailing comma\" do\n assert_format \"{1,}\", \"{1}\"\n assert_format \"{1, 2, 3,}\", \"{1, 2, 3}\"\n end\n\n test \"with keyword lists\" do\n # The one below is not valid syntax\n # assert_same \"{foo: 1, bar: 2}\"\n assert_same \"{:hello, foo: 1, bar: 2}\"\n\n tuple = \"\"\"\n {\n :hello,\n foo: 1,\n bar: 2\n }\n \"\"\"\n\n assert_same tuple, @short_length\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n {\n :hello,\n :foo,\n :bar\n }\n \"\"\"\n\n # Doesn't preserve this because only the ending has a newline\n assert_format \"{foo, bar, baz\\n}\", \"{foo, bar, baz}\"\n end\n\n test \"preserves user choice even when it fits with trailing comma\" do\n bad = \"\"\"\n {\n :hello,\n :foo,\n :bar,\n }\n \"\"\"\n\n assert_format bad, \"\"\"\n {\n :hello,\n :foo,\n :bar\n }\n \"\"\"\n end\n end\n\n describe \"lists\" do\n test \"empty\" do\n assert_format \"[ ]\", \"[]\"\n assert_format \"[\\n]\", \"[]\"\n end\n\n test \"with elements\" do\n assert_format \"[ 1 , 2,3, 4 ]\", \"[1, 2, 3, 4]\"\n end\n\n test \"with tail\" do\n assert_format \"[1,2,3|4]\", \"[1, 2, 3 | 4]\"\n end\n\n test \"are strict on line limit\" do\n bad = \"\"\"\n [11, 22, 33, 44]\n \"\"\"\n\n good = \"\"\"\n [\n 11,\n 22,\n 33,\n 44\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n [11, 22, 33 | 44]\n \"\"\"\n\n good = \"\"\"\n [\n 11,\n 22,\n 33 | 44\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n [1, 2, 3 | 4]\n \"\"\"\n\n good = \"\"\"\n [\n 1,\n 2,\n 3 | 4\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n [1, 2, 3 | really_long_expression()]\n \"\"\"\n\n good = \"\"\"\n [\n 1,\n 2,\n 3\n | really_long_expression()\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"removes trailing comma\" do\n assert_format \"[1,]\", \"[1]\"\n assert_format \"[1, 2, 3,]\", \"[1, 2, 3]\"\n end\n\n test \"with keyword lists\" do\n assert_same \"[foo: 1, bar: 2]\"\n assert_same \"[:hello, foo: 1, bar: 2]\"\n\n # Pseudo keyword lists are kept as is\n assert_same \"[{:foo, 1}, {:bar, 2}]\"\n\n keyword = \"\"\"\n [\n foo: 1,\n bar: 2\n ]\n \"\"\"\n\n assert_same keyword, @short_length\n end\n\n test \"with keyword lists on comma line limit\" do\n bad = \"\"\"\n [\n foooo: 1,\n barrr: 2\n ]\n \"\"\"\n\n good = \"\"\"\n [\n foooo:\n 1,\n barrr: 2\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with quoted keyword lists\" do\n assert_same ~S([\"with spaces\": 1])\n assert_same ~S([\"one #{two} three\": 1])\n assert_same ~S([\"\\w\": 1, \"\\\\w\": 2])\n assert_same ~S([\"Elixir.Foo\": 1, \"Elixir.Bar\": 2])\n assert_format ~S([\"Foo\": 1, \"Bar\": 2]), ~S([Foo: 1, Bar: 2])\n assert_same ~S([\"with \\\"scare quotes\\\"\": 1])\n end\n\n test \"with operators keyword lists\" do\n assert_same ~S([.: :.])\n assert_same ~S([..: :..])\n assert_same ~S([...: :...])\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n [\n :hello,\n :foo,\n :bar\n ]\n \"\"\"\n\n # Doesn't preserve this because only the ending has a newline\n assert_format \"[foo, bar, baz\\n]\", \"[foo, bar, baz]\"\n end\n\n test \"preserves user choice even when it fits with trailing comma\" do\n bad = \"\"\"\n [\n :hello,\n :foo,\n :bar,\n ]\n \"\"\"\n\n assert_format bad, \"\"\"\n [\n :hello,\n :foo,\n :bar\n ]\n \"\"\"\n end\n end\n\n describe \"bitstrings\" do\n test \"without arguments\" do\n assert_format \"<< >>\", \"<<>>\"\n assert_format \"<<\\n>>\", \"<<>>\"\n end\n\n test \"with arguments\" do\n assert_format \"<<1,2,3>>\", \"<<1, 2, 3>>\"\n end\n\n test \"add parens on first and last in case of binary ambiguity\" do\n assert_format \"<< <<>> >>\", \"<<(<<>>)>>\"\n assert_format \"<< <<>> + <<>> >>\", \"<<(<<>> + <<>>)>>\"\n assert_format \"<< 1 + <<>> >>\", \"<<(1 + <<>>)>>\"\n assert_format \"<< <<>> + 1 >>\", \"<<(<<>> + 1)>>\"\n assert_format \"<< <<>>, <<>>, <<>> >>\", \"<<(<<>>), <<>>, (<<>>)>>\"\n assert_format \"<< <<>>::1, <<>>::2, <<>>::3 >>\", \"<<(<<>>)::1, <<>>::2, <<>>::3>>\"\n assert_format \"<< <<>>::<<>> >>\", \"<<(<<>>)::(<<>>)>>\"\n end\n\n test \"add parens on first in case of operator ambiguity\" do\n assert_format \"<< ~~~1::8 >>\", \"<<(~~~1)::8>>\"\n assert_format \"<< ~s[foo]::binary >>\", \"<<(~s[foo])::binary>>\"\n end\n\n test \"with modifiers\" do\n assert_format \"<< 1 :: 1 >>\", \"<<1::1>>\"\n assert_format \"<< 1 :: 2 + 3 >>\", \"<<1::(2 + 3)>>\"\n assert_format \"<< 1 :: 2 - integer >>\", \"<<1::2-integer>>\"\n assert_format \"<< 1 :: 2 - unit(3) >>\", \"<<1::2-unit(3)>>\"\n assert_format \"<< 1 :: 2 * 3 - unit(4) >>\", \"<<1::2*3-unit(4)>>\"\n assert_format \"<< 1 :: 2 - unit(3) - 4 / 5 >>\", \"<<1::2-unit(3)-(4 / 5)>>\"\n assert_format \"<<0 :: ( x - 1 ) * 5>>\", \"<<0::(x-1)*5>>\"\n assert_format \"<<0 :: 2 * 3 * 4>>\", \"<<0::(2*3)*4>>\"\n end\n\n test \"in comprehensions\" do\n assert_format \"<< 0, 1 :: 1 <- x >>\", \"<<0, 1::1 <- x>>\"\n assert_format \"<< 0, 1 :: 2 + 3 <- x >>\", \"<<0, 1::(2 + 3) <- x>>\"\n assert_format \"<< 0, 1 :: 2 - integer <- x >>\", \"<<0, 1::2-integer <- x>>\"\n assert_format \"<< 0, 1 :: 2 - unit(3) <- x >>\", \"<<0, 1::2-unit(3) <- x>>\"\n assert_format \"<< 0, 1 :: 2 * 3 - unit(4) <- x >>\", \"<<0, 1::2*3-unit(4) <- x>>\"\n assert_format \"<< 0, 1 :: 2 - unit(3) - 4 / 5 <- x >>\", \"<<0, 1::2-unit(3)-(4 / 5) <- x>>\"\n\n assert_same \"<<(<> <- <>)>>\"\n assert_same \"<<(y <- <>)>>\"\n assert_same \"<<(<> <- x)>>\"\n end\n\n test \"keeps parentheses by default\" do\n assert_same \"<>\"\n assert_same \"<>\"\n\n assert_same \"<>\"\n assert_same \"<>\"\n\n assert_same \"<>\"\n assert_same \"<<0, 1::2-integer() <- x>>\"\n end\n\n test \"is flex on line limits\" do\n bad = \"<<1, 2, 3, 4>>\"\n\n good = \"\"\"\n <<1, 2, 3,\n 4>>\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n <<\n :hello,\n :foo,\n :bar\n >>\n \"\"\"\n\n # Doesn't preserve this because only the ending has a newline\n assert_format \"<>\", \"<>\"\n end\n\n test \"preserves user choice even when it fits with trailing comma\" do\n bad = \"\"\"\n <<\n :hello,\n :foo,\n :bar,\n >>\n \"\"\"\n\n assert_format bad, \"\"\"\n <<\n :hello,\n :foo,\n :bar\n >>\n \"\"\"\n end\n end\n\n describe \"maps\" do\n test \"without arguments\" do\n assert_format \"%{ }\", \"%{}\"\n end\n\n test \"with arguments\" do\n assert_format \"%{1 => 2,3 => 4}\", \"%{1 => 2, 3 => 4}\"\n end\n\n test \"is strict on line limits\" do\n bad = \"%{1 => 2, 3 => 4}\"\n\n good = \"\"\"\n %{\n 1 => 2,\n 3 => 4\n }\n \"\"\"\n\n assert_format bad, good, @short_length\n\n map = \"\"\"\n %{\n a(1, 2) => b,\n c(3, 4) => d\n }\n \"\"\"\n\n assert_same map, @medium_length\n\n map = \"\"\"\n %{\n a => fn x ->\n y\n end,\n b => fn y ->\n z\n end\n }\n \"\"\"\n\n assert_same map, @medium_length\n\n map = \"\"\"\n %{\n a =>\n for(\n y <- x,\n z <- y,\n do: 123\n )\n }\n \"\"\"\n\n assert_same map, @medium_length\n\n map = \"\"\"\n %{\n a =>\n for do\n :ok\n end\n }\n \"\"\"\n\n assert_same map, @short_length\n end\n\n test \"removes trailing comma\" do\n assert_format \"%{1 => 2,}\", \"%{1 => 2}\"\n end\n\n test \"with keyword lists\" do\n assert_same \"%{:foo => :bar, baz: :bat}\"\n\n map = \"\"\"\n %{\n :foo => :bar,\n baz: :bat\n }\n \"\"\"\n\n assert_same map, @medium_length\n end\n\n test \"preserves user choice in regards to =>\" do\n assert_same \"%{:hello => 1, :world => 2}\"\n assert_format \"%{:true => 1, :false => 2}\", \"%{true => 1, false => 2}\"\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n %{\n :hello => 1,\n :foo => 2,\n :bar => 3\n }\n \"\"\"\n\n # Doesn't preserve this because only the ending has a newline\n assert_format \"%{foo: 1, bar: 2\\n}\", \"%{foo: 1, bar: 2}\"\n end\n\n test \"preserves user choice even when it fits with trailing comma\" do\n bad = \"\"\"\n %{\n hello,\n foo,\n bar,\n }\n \"\"\"\n\n assert_format bad, \"\"\"\n %{\n hello,\n foo,\n bar\n }\n \"\"\"\n end\n\n test \"preserves user choice when a newline is used after keyword\" do\n good = \"\"\"\n %{\n hello:\n {:ok, :world}\n }\n \"\"\"\n\n assert_same good, @medium_length\n end\n\n test \"preserves user choice when a newline is used after assoc\" do\n good = \"\"\"\n %{\n hello =>\n {:ok, :world}\n }\n \"\"\"\n\n assert_same good, @medium_length\n end\n end\n\n describe \"maps with update\" do\n test \"with arguments\" do\n assert_format \"%{foo | 1 => 2,3 => 4}\", \"%{foo | 1 => 2, 3 => 4}\"\n end\n\n test \"is strict on line limits\" do\n bad = \"%{foo | 1 => 2, 3 => 4}\"\n\n good = \"\"\"\n %{\n foo\n | 1 => 2,\n 3 => 4\n }\n \"\"\"\n\n assert_format bad, good, line_length: 11\n end\n\n test \"removes trailing comma\" do\n assert_format \"%{foo | 1 => 2,}\", \"%{foo | 1 => 2}\"\n end\n\n test \"with keyword lists\" do\n assert_same \"%{foo | :foo => :bar, baz: :bat}\"\n\n map = \"\"\"\n %{\n foo\n | :foo => :bar,\n baz: :bat\n }\n \"\"\"\n\n assert_same map, @medium_length\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n %{\n foo\n | :hello => 1,\n :foo => 2,\n :bar => 3\n }\n \"\"\"\n end\n\n test \"wraps operators in parens\" do\n assert_format \"%{foo && bar | baz: :bat}\", \"%{(foo && bar) | baz: :bat}\"\n assert_same \"%{@foo | baz: :bat}\"\n end\n end\n\n describe \"structs\" do\n test \"without arguments\" do\n assert_format \"%struct{ }\", \"%struct{}\"\n end\n\n test \"with arguments\" do\n assert_format \"%struct{1 => 2,3 => 4}\", \"%struct{1 => 2, 3 => 4}\"\n end\n\n test \"is strict on line limits\" do\n bad = \"%struct{1 => 2, 3 => 4}\"\n\n good = \"\"\"\n %struct{\n 1 => 2,\n 3 => 4\n }\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"removes trailing comma\" do\n assert_format \"%struct{1 => 2,}\", \"%struct{1 => 2}\"\n end\n\n test \"with keyword lists\" do\n assert_same \"%struct{:foo => :bar, baz: :bat}\"\n\n struct = \"\"\"\n %struct{\n :foo => :bar,\n baz: :bat\n }\n \"\"\"\n\n assert_same struct, @medium_length\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n %Foo{\n :hello => 1,\n :foo => 2,\n :bar => 3\n }\n \"\"\"\n end\n end\n\n describe \"struct with update\" do\n test \"with arguments\" do\n assert_format \"%struct{foo | 1 => 2,3 => 4}\", \"%struct{foo | 1 => 2, 3 => 4}\"\n end\n\n test \"is strict on line limits\" do\n bad = \"%struct{foo | 1 => 2, 3 => 4}\"\n\n good = \"\"\"\n %struct{\n foo\n | 1 => 2,\n 3 => 4\n }\n \"\"\"\n\n assert_format bad, good, line_length: 11\n end\n\n test \"removes trailing comma\" do\n assert_format \"%struct{foo | 1 => 2,}\", \"%struct{foo | 1 => 2}\"\n end\n\n test \"with keyword lists\" do\n assert_same \"%struct{foo | :foo => :bar, baz: :bat}\"\n\n struct = \"\"\"\n %struct{\n foo\n | :foo => :bar,\n baz: :bat\n }\n \"\"\"\n\n assert_same struct, @medium_length\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n %Foo{\n foo\n | :hello => 1,\n :foo => 2,\n :bar => 3\n }\n \"\"\"\n end\n\n test \"converges\" do\n bad = \"hello_world(%struct{foo | 1 => 2, 3 => 4})\"\n\n good = \"\"\"\n hello_world(%struct{\n foo\n | 1 => 2,\n 3 => 4\n })\n \"\"\"\n\n assert_format bad, good, line_length: 30\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/general_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.GeneralTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n @short_length [line_length: 10]\n\n test \"does not emit warnings\" do\n assert_format \"fn -> end\", \"fn -> nil end\"\n end\n\n describe \"unicode normalization\" do\n test \"with nfc normalizations\" do\n assert_format \"ç\", \"ç\"\n end\n\n test \"with custom normalizations\" do\n assert_format \"µs\", \"μs\"\n end\n end\n\n describe \"aliases\" do\n test \"with atom-only parts\" do\n assert_same \"Elixir\"\n assert_same \"Elixir.Foo\"\n assert_same \"Foo.Bar.Baz\"\n end\n\n test \"removes spaces between aliases\" do\n assert_format \"Foo . Bar . Baz\", \"Foo.Bar.Baz\"\n end\n\n test \"starting with expression\" do\n assert_same \"__MODULE__.Foo.Bar\"\n # Syntactically valid, semantically invalid\n assert_same ~S[~c\"Foo\".Bar.Baz]\n end\n\n test \"wraps the head in parens if it has an operator\" do\n assert_format \"+(Foo . Bar . Baz)\", \"+Foo.Bar.Baz\"\n assert_format \"(+Foo) . Bar . Baz\", \"(+Foo).Bar.Baz\"\n end\n end\n\n describe \"sigils\" do\n test \"without interpolation\" do\n assert_same ~S[~s(foo)]\n assert_same ~S[~s{foo bar}]\n assert_same ~S[~r/Bar Baz/]\n assert_same ~S[~w<>]\n assert_same ~S[~W()]\n assert_same ~S[~MAT()]\n assert_same ~S[~MAT{1,2,3}]\n end\n\n test \"with escapes\" do\n assert_same ~S[~s(foo \\) bar)]\n assert_same ~S[~s(f\\a\\b\\ro)]\n\n assert_same ~S\"\"\"\n ~S(foo\\\n bar)\n \"\"\"\n end\n\n test \"with nested new lines\" do\n assert_same ~S\"\"\"\n foo do\n ~S(foo\\\n bar)\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n foo do\n ~s(#{bar}\n )\n end\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S[~s(one #{2} three)]\n end\n\n test \"with modifiers\" do\n assert_same ~S[~w(one two three)a]\n assert_same ~S[~z(one two three)foo]\n end\n\n test \"with interpolation on line limit\" do\n assert_same ~S\"\"\"\n ~s(one #{\"two\"} three)\n \"\"\",\n @short_length\n end\n\n test \"with heredoc syntax\" do\n assert_same ~S\"\"\"\n ~s'''\n one\\a\n #{:two}\\r\n three\\0\n '''\n \"\"\"\n\n assert_same ~S'''\n ~s\"\"\"\n one\\a\n #{:two}\\r\n three\\0\n \"\"\"\n '''\n end\n\n test \"with heredoc syntax and modifier\" do\n assert_same ~S\"\"\"\n ~s'''\n foo\n '''rsa\n \"\"\"\n end\n\n test \"with heredoc syntax and interpolation on line limit\" do\n assert_same ~S\"\"\"\n ~s'''\n one #{\"two two\"} three\n '''\n \"\"\",\n @short_length\n end\n\n test \"with custom formatting\" do\n bad = \"\"\"\n ~W/foo bar baz/\n \"\"\"\n\n good = \"\"\"\n ~W/foo bar baz/\n \"\"\"\n\n formatter = fn content, opts ->\n assert opts == [file: nil, line: 1, sigil: :W, modifiers: [], opening_delimiter: \"/\"]\n content |> String.split(~r/ +/) |> Enum.join(\" \")\n end\n\n assert_format bad, good, sigils: [W: formatter]\n\n bad = \"\"\"\n var = ~Wabc\n \"\"\"\n\n good = \"\"\"\n var = ~Wabc\n \"\"\"\n\n formatter = fn content, opts ->\n assert opts == [file: nil, line: 1, sigil: :W, modifiers: ~c\"abc\", opening_delimiter: \"<\"]\n content |> String.split(~r/ +/) |> Enum.intersperse(\" \")\n end\n\n assert_format bad, good, sigils: [W: formatter]\n\n bad = \"\"\"\n var = ~MAT{foo bar baz}abc\n \"\"\"\n\n good = \"\"\"\n var = ~MAT{foo bar baz}abc\n \"\"\"\n\n formatter = fn content, opts ->\n assert opts == [\n file: nil,\n line: 1,\n sigil: :MAT,\n modifiers: ~c\"abc\",\n opening_delimiter: \"{\"\n ]\n\n content |> String.split(~r/ +/) |> Enum.intersperse(\" \")\n end\n\n assert_format bad, good, sigils: [MAT: formatter]\n end\n\n test \"with custom formatting on heredocs\" do\n bad = \"\"\"\n ~W'''\n foo bar baz\n '''\n \"\"\"\n\n good = \"\"\"\n ~W'''\n foo bar baz\n '''\n \"\"\"\n\n formatter = fn content, opts ->\n assert opts == [file: nil, line: 1, sigil: :W, modifiers: [], opening_delimiter: \"'''\"]\n content |> String.split(~r/ +/) |> Enum.join(\" \")\n end\n\n assert_format bad, good, sigils: [W: formatter]\n\n bad = ~S'''\n if true do\n ~W\"\"\"\n foo\n bar\n baz\n \"\"\"abc\n end\n '''\n\n good = ~S'''\n if true do\n ~W\"\"\"\n foo\n bar\n baz\n \"\"\"abc\n end\n '''\n\n formatter = fn content, opts ->\n assert opts == [\n file: nil,\n line: 2,\n sigil: :W,\n modifiers: ~c\"abc\",\n opening_delimiter: ~S/\"\"\"/\n ]\n\n content |> String.split(~r/ +/) |> Enum.join(\"\\n\")\n end\n\n assert_format bad, good, sigils: [W: formatter]\n end\n end\n\n describe \"anonymous functions\" do\n test \"with a single clause and no arguments\" do\n assert_format \"fn ->:ok end\", \"fn -> :ok end\"\n\n bad = \"fn -> :foo end\"\n\n good = \"\"\"\n fn ->\n :foo\n end\n \"\"\"\n\n assert_format bad, good, @short_length\n\n assert_same \"fn () when node() == :nonode@nohost -> true end\"\n end\n\n test \"with a single clause and arguments\" do\n assert_format \"fn x ,y-> x + y end\", \"fn x, y -> x + y end\"\n\n bad = \"fn x -> foo(x) end\"\n\n good = \"\"\"\n fn x ->\n foo(x)\n end\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"fn one, two, three -> foo(x) end\"\n\n good = \"\"\"\n fn one,\n two,\n three ->\n foo(x)\n end\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with a single clause and when\" do\n code = \"\"\"\n fn arg\n when guard ->\n :ok\n end\n \"\"\"\n\n assert_same code, @short_length\n end\n\n test \"keeps parens if argument includes keyword list\" do\n assert_same \"\"\"\n fn [] when is_integer(x) ->\n x + 42\n end\n \"\"\"\n\n bad = \"\"\"\n fn (input: x) when is_integer(x) ->\n x + 42\n end\n \"\"\"\n\n good = \"\"\"\n fn [input: x] when is_integer(x) ->\n x + 42\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with a single clause, followed by a newline, and can fit in one line\" do\n assert_same \"\"\"\n fn\n hello -> world\n end\n \"\"\"\n end\n\n test \"with a single clause, followed by a newline, and can not fit in one line\" do\n assert_same \"\"\"\n SomeModule.long_function_name_that_approaches_max_columns(argument, acc, fn\n %SomeStruct{key: key}, acc -> more_code(key, acc)\n end)\n \"\"\"\n end\n\n test \"with multiple clauses\" do\n code = \"\"\"\n fn\n 1 -> :ok\n 2 -> :ok\n end\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n fn\n 1 ->\n :ok\n\n 2 ->\n :error\n end\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n fn\n arg11,\n arg12 ->\n body1\n\n arg21,\n arg22 ->\n body2\n end\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n fn\n arg11,\n arg12 ->\n body1\n\n arg21,\n arg22 ->\n body2\n\n arg31,\n arg32 ->\n body3\n end\n \"\"\"\n\n assert_same code, @short_length\n end\n\n test \"with heredocs\" do\n assert_same ~S'''\n fn\n arg1 ->\n \"\"\"\n foo\n \"\"\"\n\n arg2 ->\n \"\"\"\n bar\n \"\"\"\n end\n '''\n end\n\n test \"with multiple empty clauses\" do\n assert_same \"\"\"\n fn\n () -> :ok1\n () -> :ok2\n end\n \"\"\"\n end\n\n test \"with when in clauses\" do\n assert_same \"\"\"\n fn\n a1 when a + b -> :ok\n b1 when c + d -> :ok\n end\n \"\"\"\n\n long = \"\"\"\n fn\n a1, a2 when a + b -> :ok\n b1, b2 when c + d -> :ok\n end\n \"\"\"\n\n assert_same long\n\n good = \"\"\"\n fn\n a1, a2\n when a +\n b ->\n :ok\n\n b1, b2\n when c +\n d ->\n :ok\n end\n \"\"\"\n\n assert_format long, good, @short_length\n end\n\n test \"uses block context for the body of each clause\" do\n assert_same \"fn -> @foo bar end\"\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n fn\n 1 ->\n :ok\n\n 2 ->\n :ok\n end\n \"\"\"\n\n assert_same \"\"\"\n fn\n 1 ->\n :ok\n\n 2 ->\n :ok\n\n 3 ->\n :ok\n end\n \"\"\"\n end\n\n test \"with -> on line limit\" do\n bad = \"\"\"\n fn ab, cd ->\n ab + cd\n end\n \"\"\"\n\n good = \"\"\"\n fn ab,\n cd ->\n ab + cd\n end\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n fn\n ab, cd ->\n 1\n xy, zw ->\n 2\n end\n \"\"\"\n\n good = \"\"\"\n fn\n ab,\n cd ->\n 1\n\n xy,\n zw ->\n 2\n end\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n end\n\n describe \"anonymous functions types\" do\n test \"with a single clause and no arguments\" do\n assert_same \"(-> :ok)\"\n assert_format \"(->:ok)\", \"(-> :ok)\"\n assert_format \"( -> :ok)\", \"(-> :ok)\"\n assert_format \"(() -> :really_long_atom)\", \"(-> :really_long_atom)\", @short_length\n assert_same \"(() when node() == :nonode@nohost -> true)\"\n end\n\n test \"with a single clause and arguments\" do\n assert_format \"( x ,y-> x + y )\", \"(x, y -> x + y)\"\n\n bad = \"(x -> :really_long_atom)\"\n\n good = \"\"\"\n (x ->\n :really_long_atom)\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"(one, two, three -> foo(x))\"\n\n good = \"\"\"\n (one,\n two,\n three ->\n foo(x))\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with multiple clauses\" do\n code = \"\"\"\n (\n 1 -> :ok\n 2 -> :ok\n )\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n (\n 1 ->\n :ok\n\n 2 ->\n :error\n )\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n (\n arg11,\n arg12 ->\n body1\n\n arg21,\n arg22 ->\n body2\n )\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n (\n arg11,\n arg12 ->\n body1\n\n arg21,\n arg22 ->\n body2\n\n arg31,\n arg32 ->\n body2\n )\n \"\"\"\n\n assert_same code, @short_length\n end\n\n test \"with heredocs\" do\n assert_same ~S'''\n (\n arg1 ->\n \"\"\"\n foo\n \"\"\"\n\n arg2 ->\n \"\"\"\n bar\n \"\"\"\n )\n '''\n end\n\n test \"with multiple empty clauses\" do\n assert_same \"\"\"\n (\n () -> :ok1\n () -> :ok2\n )\n \"\"\"\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n (\n 1 ->\n :ok\n\n 2 ->\n :ok\n )\n \"\"\"\n\n assert_same \"\"\"\n (\n 1 ->\n :ok\n\n 2 ->\n :ok\n\n 3 ->\n :ok\n )\n \"\"\"\n end\n end\n\n describe \"blocks\" do\n test \"empty\" do\n assert_format \"(;)\", \"\"\n assert_format \"quote do: (;)\", \"quote do: nil\"\n assert_format \"quote do end\", \"quote do\\nend\"\n assert_format \"quote do ; end\", \"quote do\\nend\"\n end\n\n test \"with multiple lines\" do\n assert_same \"\"\"\n foo = bar\n baz = bat\n \"\"\"\n end\n\n test \"with multiple lines with line limit\" do\n code = \"\"\"\n foo =\n bar(one)\n\n baz =\n bat(two)\n\n a(b)\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n foo =\n bar(one)\n\n a(b)\n\n baz =\n bat(two)\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n a(b)\n\n foo =\n bar(one)\n\n baz =\n bat(two)\n \"\"\"\n\n assert_same code, @short_length\n\n code = \"\"\"\n foo =\n bar(one)\n\n one =\n two(ghi)\n\n baz =\n bat(two)\n \"\"\"\n\n assert_same code, @short_length\n end\n\n test \"with multiple lines with line limit inside block\" do\n code = \"\"\"\n block do\n a =\n b(foo)\n\n c =\n d(bar)\n\n e =\n f(baz)\n end\n \"\"\"\n\n assert_same code, @short_length\n end\n\n test \"with multiple lines with cancel expressions\" do\n code = \"\"\"\n foo(%{\n key: 1\n })\n\n bar(%{\n key: 1\n })\n\n baz(%{\n key: 1\n })\n \"\"\"\n\n assert_same code, @short_length\n end\n\n test \"with heredoc\" do\n assert_same ~S'''\n block do\n \"\"\"\n a\n\n b\n\n c\n \"\"\"\n end\n '''\n end\n\n test \"keeps user newlines\" do\n assert_same \"\"\"\n defmodule Mod do\n field(:foo)\n field(:bar)\n field(:baz)\n belongs_to(:one)\n belongs_to(:two)\n timestamp()\n lock()\n has_many(:three)\n has_many(:four)\n :ok\n has_one(:five)\n has_one(:six)\n foo = 1\n bar = 2\n :before\n baz = 3\n :after\n end\n \"\"\"\n\n bad = \"\"\"\n defmodule Mod do\n field(:foo)\n\n field(:bar)\n\n field(:baz)\n\n\n belongs_to(:one)\n belongs_to(:two)\n\n\n timestamp()\n\n lock()\n\n\n has_many(:three)\n has_many(:four)\n\n\n :ok\n\n\n has_one(:five)\n has_one(:six)\n\n\n foo = 1\n bar = 2\n\n\n :before\n baz = 3\n :after\n end\n \"\"\"\n\n good = \"\"\"\n defmodule Mod do\n field(:foo)\n\n field(:bar)\n\n field(:baz)\n\n belongs_to(:one)\n belongs_to(:two)\n\n timestamp()\n\n lock()\n\n has_many(:three)\n has_many(:four)\n\n :ok\n\n has_one(:five)\n has_one(:six)\n\n foo = 1\n bar = 2\n\n :before\n baz = 3\n :after\n end\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with multiple defs\" do\n assert_same \"\"\"\n def foo(:one), do: 1\n def foo(:two), do: 2\n def foo(:three), do: 3\n \"\"\"\n end\n\n test \"with module attributes\" do\n assert_same ~S'''\n defmodule Foo do\n @constant 1\n @constant 2\n\n @doc \"\"\"\n foo\n \"\"\"\n def foo do\n :ok\n end\n\n @spec bar :: 1\n @spec bar :: 2\n def bar do\n :ok\n end\n\n @other_constant 3\n\n @spec baz :: 4\n @doc \"\"\"\n baz\n \"\"\"\n def baz do\n :ok\n end\n\n @another_constant 5\n @another_constant 5\n\n @doc \"\"\"\n baz\n \"\"\"\n @spec baz :: 6\n def baz do\n :ok\n end\n end\n '''\n end\n\n test \"as function arguments\" do\n assert_same \"\"\"\n fun(\n (\n foo\n bar\n )\n )\n \"\"\"\n\n assert_same \"\"\"\n assert true,\n do:\n (\n foo\n bar\n )\n \"\"\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/integration_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.IntegrationTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n test \"empty documents\" do\n assert_format \" \", \"\"\n assert_format \"\\n\", \"\"\n assert_format \";\", \"\"\n end\n\n test \"function with multiple calls and case\" do\n assert_same \"\"\"\n def equivalent(string1, string2) when is_binary(string1) and is_binary(string2) do\n quoted1 = Code.string_to_quoted!(string1)\n quoted2 = Code.string_to_quoted!(string2)\n\n case not_equivalent(quoted1, quoted2) do\n {left, right} -> {:error, left, right}\n nil -> :ok\n end\n end\n \"\"\"\n end\n\n test \"function with long pipeline\" do\n assert_same ~S\"\"\"\n def to_algebra!(string, opts \\\\ []) when is_binary(string) and is_list(opts) do\n string\n |> Code.string_to_quoted!(wrap_literals_in_blocks: true, unescape: false)\n |> block_to_algebra(state(opts))\n |> elem(0)\n end\n \"\"\"\n end\n\n test \"case with multiple multi-line arrows\" do\n assert_same ~S\"\"\"\n case meta[:format] do\n :list_heredoc ->\n string = list |> List.to_string() |> escape_string(:heredoc)\n {@single_heredoc |> line(string) |> concat(@single_heredoc) |> force_unfit(), state}\n\n :charlist ->\n string = list |> List.to_string() |> escape_string(@single_quote)\n {@single_quote |> concat(string) |> concat(@single_quote), state}\n\n _other ->\n list_to_algebra(list, state)\n end\n \"\"\"\n end\n\n test \"function with long guards\" do\n assert_same \"\"\"\n defp module_attribute_read?({:@, _, [{var, _, var_context}]})\n when is_atom(var) and is_atom(var_context) do\n Macro.classify_atom(var) == :identifier\n end\n \"\"\"\n end\n\n test \"anonymous function with single clause and blocks\" do\n assert_same \"\"\"\n {args_doc, state} =\n Enum.reduce(args, {[], state}, fn quoted, {acc, state} ->\n {doc, state} = quoted_to_algebra(quoted, :block, state)\n doc = doc |> concat(nest(break(\"\"), :reset)) |> group()\n {[doc | acc], state}\n end)\n \"\"\"\n end\n\n test \"anonymous function with long single clause and blocks\" do\n assert_same \"\"\"\n {function_count, call_count, total_time} =\n Enum.reduce(call_results, {0, 0, 0}, fn {_, {count, time}},\n {function_count, call_count, total_time} ->\n {function_count + 1, call_count + count, total_time + time}\n end)\n \"\"\"\n end\n\n test \"cond with long clause args\" do\n assert_same \"\"\"\n cond do\n parent_prec == prec and parent_assoc == side ->\n binary_op_to_algebra(op, op_string, left, right, context, state, op_info, nesting)\n\n parent_op in @required_parens_on_binary_operands or parent_prec > prec or\n (parent_prec == prec and parent_assoc != side) ->\n {operand, state} =\n binary_op_to_algebra(op, op_string, left, right, context, state, op_info, 2)\n\n {concat(concat(\"(\", nest(operand, 1)), \")\"), state}\n\n true ->\n binary_op_to_algebra(op, op_string, left, right, context, state, op_info, 2)\n end\n \"\"\"\n end\n\n test \"type with multiple |\" do\n assert_same \"\"\"\n @type t ::\n binary\n | :doc_nil\n | :doc_line\n | doc_string\n | doc_cons\n | doc_nest\n | doc_break\n | doc_group\n | doc_color\n | doc_force\n | doc_cancel\n \"\"\"\n end\n\n test \"spec with when keywords and |\" do\n assert_same \"\"\"\n @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend\n when dest: pid | port | atom | {atom, node},\n msg: any,\n option: :noconnect | :nosuspend\n \"\"\"\n\n assert_same \"\"\"\n @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend\n when dest:\n pid\n | port\n | atom\n | {atom, node}\n | and_a_really_long_type_to_force_a_line_break\n | followed_by_another_really_long_type\n \"\"\"\n\n assert_same \"\"\"\n @callback get_and_update(data, key, (value -> {get_value, value} | :pop)) :: {get_value, data}\n when get_value: var, data: container\n \"\"\"\n end\n\n test \"spec with multiple keys on type\" do\n assert_same \"\"\"\n @spec foo(%{(String.t() | atom) => any}) :: any\n \"\"\"\n end\n\n test \"multiple whens with new lines\" do\n assert_same \"\"\"\n def sleep(timeout)\n when is_integer(timeout) and timeout >= 0\n when timeout == :infinity do\n receive after: (timeout -> :ok)\n end\n \"\"\"\n end\n\n test \"function with operator and pipeline\" do\n assert_same \"\"\"\n defp apply_next_break_fits?({fun, meta, args}) when is_atom(fun) and is_list(args) do\n meta[:terminator] in [@double_heredoc, @single_heredoc] and\n fun |> Atom.to_string() |> String.starts_with?(\"sigil_\")\n end\n \"\"\"\n end\n\n test \"mixed parens and no parens calls with anonymous function\" do\n assert_same ~S\"\"\"\n node interface do\n resolve_type(fn\n %{__struct__: str}, _ ->\n str |> Model.Node.model_to_node_type()\n\n value, _ ->\n Logger.warning(\"Could not extract node type from value: #{inspect(value)}\")\n nil\n end)\n end\n \"\"\"\n end\n\n test \"long defstruct definition\" do\n assert_same \"\"\"\n defstruct name: nil,\n module: nil,\n schema: nil,\n alias: nil,\n base_module: nil,\n web_module: nil,\n basename: nil,\n file: nil,\n test_file: nil\n \"\"\"\n end\n\n test \"mix of operators and arguments\" do\n assert_same \"\"\"\n def count(%{path: path, line_or_bytes: bytes}) do\n case File.stat(path) do\n {:ok, %{size: 0}} -> {:error, __MODULE__}\n {:ok, %{size: size}} -> {:ok, div(size, bytes) + if(rem(size, bytes) == 0, do: 0, else: 1)}\n {:error, reason} -> raise File.Error, reason: reason, action: \"stream\", path: path\n end\n end\n \"\"\"\n end\n\n test \"mix of left and right operands\" do\n assert_same \"\"\"\n defp server_get_modules(handlers) do\n for(handler(module: module) <- handlers, do: module)\n |> :ordsets.from_list()\n |> :ordsets.to_list()\n end\n \"\"\"\n\n assert_same \"\"\"\n neighbours = for({_, _} = t <- neighbours, do: t) |> :sets.from_list()\n \"\"\"\n end\n\n test \"long expression with single line anonymous function\" do\n assert_same \"\"\"\n for_many(uniq_list_of(integer(1..10000)), fn list ->\n assert Enum.uniq(list) == list\n end)\n \"\"\"\n end\n\n test \"long comprehension\" do\n assert_same \"\"\"\n for %{app: app, opts: opts, top_level: true} <- Mix.Dep.cached(),\n Keyword.get(opts, :app, true),\n Keyword.get(opts, :runtime, true),\n not Keyword.get(opts, :optional, false),\n app not in included_applications,\n app not in included_applications,\n do: app\n \"\"\"\n end\n\n test \"short comprehensions\" do\n assert_same \"\"\"\n for {protocol, :protocol, _beam} <- removed_metadata,\n remove_consolidated(protocol, output),\n do: {protocol, true},\n into: %{}\n \"\"\"\n end\n\n test \"comprehensions with when\" do\n assert_same \"\"\"\n for {key, value} when is_atom(key) <- Map.to_list(map),\n key = Atom.to_string(key),\n String.starts_with?(key, hint) do\n %{kind: :map_key, name: key, value_is_map: is_map(value)}\n end\n \"\"\"\n\n assert_same \"\"\"\n with {_, doc} when unquote(doc_attr?) <-\n Module.get_attribute(__MODULE__, unquote(name), unquote(escaped)),\n do: doc\n \"\"\"\n end\n\n test \"next break fits followed by inline tuple\" do\n assert_same \"\"\"\n assert ExUnit.Filters.eval([line: \"1\"], [:line], %{line: 3, describe_line: 2}, tests) ==\n {:error, \"due to line filter\"}\n \"\"\"\n end\n\n test \"try/catch with clause comment\" do\n assert_same \"\"\"\n def format_error(reason) do\n try do\n do_format_error(reason)\n catch\n # A user could create an error that looks like a built-in one\n # causing an error.\n :error, _ ->\n inspect(reason)\n end\n end\n \"\"\"\n end\n\n test \"case with when and clause comment\" do\n assert_same \"\"\"\n case decomposition do\n # Decomposition\n <> when h != ?< ->\n decomposition =\n decomposition\n |> :binary.split(\" \", [:global])\n |> Enum.map(&String.to_integer(&1, 16))\n\n Map.put(dacc, String.to_integer(codepoint, 16), decomposition)\n\n _ ->\n dacc\n end\n \"\"\"\n end\n\n test \"do-end inside binary\" do\n assert_same \"\"\"\n <>\n \"\"\"\n end\n\n test \"anonymous function with parens around integer argument\" do\n bad = \"\"\"\n fn (1) -> \"hello\" end\n \"\"\"\n\n assert_format bad, \"\"\"\n fn 1 -> \"hello\" end\n \"\"\"\n end\n\n test \"no parens keywords at the end of the line\" do\n bad = \"\"\"\n defmodule Mod do\n def token_list_downcase(<>, acc) when is_whitespace(char) or is_comma(char), do: token_list_downcase(rest, acc)\n def token_list_downcase(some_really_long_arg11, some_really_long_arg22, some_really_long_arg33), do: token_list_downcase(rest, acc)\n end\n \"\"\"\n\n assert_format bad, \"\"\"\n defmodule Mod do\n def token_list_downcase(<>, acc) when is_whitespace(char) or is_comma(char),\n do: token_list_downcase(rest, acc)\n\n def token_list_downcase(some_really_long_arg11, some_really_long_arg22, some_really_long_arg33),\n do: token_list_downcase(rest, acc)\n end\n \"\"\"\n end\n\n test \"do at the end of the line\" do\n bad = \"\"\"\n foo bar, baz, quux do\n :ok\n end\n \"\"\"\n\n good = \"\"\"\n foo bar,\n baz,\n quux do\n :ok\n end\n \"\"\"\n\n assert_format bad, good, line_length: 18\n end\n\n test \"keyword lists in last line\" do\n assert_same \"\"\"\n content =\n config(VeryLongModuleNameThatWillCauseBreak, \"new.html\",\n conn: conn,\n changeset: changeset,\n categories: categories\n )\n \"\"\"\n\n assert_same \"\"\"\n content =\n config VeryLongModuleNameThatWillCauseBreak, \"new.html\",\n conn: conn,\n changeset: changeset,\n categories: categories\n \"\"\"\n end\n\n test \"keyword list at line limit\" do\n bad = \"\"\"\n pre()\n config(arg, foo: bar)\n post()\n \"\"\"\n\n good = \"\"\"\n pre()\n\n config(arg,\n foo: bar\n )\n\n post()\n \"\"\"\n\n assert_format bad, good, line_length: 20\n end\n\n test \"do at the end of the line with single argument\" do\n bad = \"\"\"\n defmodule Location do\n def new(line, column) when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do\n %{column: column, line: line}\n end\n end\n \"\"\"\n\n assert_format bad, \"\"\"\n defmodule Location do\n def new(line, column)\n when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do\n %{column: column, line: line}\n end\n end\n \"\"\"\n end\n\n test \"tuples as trees\" do\n bad = \"\"\"\n @document Parser.parse(\n {\"html\", [], [\n {\"head\", [], []},\n {\"body\", [], [\n {\"div\", [], [\n {\"p\", [], [\"1\"]},\n {\"p\", [], [\"2\"]},\n {\"div\", [], [\n {\"p\", [], [\"3\"]},\n {\"p\", [], [\"4\"]}]},\n {\"p\", [], [\"5\"]}]}]}]})\n \"\"\"\n\n assert_format bad, \"\"\"\n @document Parser.parse(\n {\"html\", [],\n [\n {\"head\", [], []},\n {\"body\", [],\n [\n {\"div\", [],\n [\n {\"p\", [], [\"1\"]},\n {\"p\", [], [\"2\"]},\n {\"div\", [],\n [\n {\"p\", [], [\"3\"]},\n {\"p\", [], [\"4\"]}\n ]},\n {\"p\", [], [\"5\"]}\n ]}\n ]}\n ]}\n )\n \"\"\"\n end\n\n test \"nested tuples as lines\" do\n assert_same \"\"\"\n {:ok,\n {1, 2, 3,\n 4, 5}} =\n call()\n \"\"\",\n line_length: 10\n end\n\n test \"first argument in a call without parens with comments\" do\n assert_same \"\"\"\n with bar ::\n :ok\n | :invalid\n # | :unknown\n | :other\n \"\"\"\n\n assert_same \"\"\"\n @spec bar ::\n :ok\n | :invalid\n # | :unknown\n | :other\n \"\"\"\n end\n\n test \"when with keywords inside call\" do\n assert_same \"\"\"\n quote((bar(foo(1)) when bat: foo(1)), [])\n \"\"\"\n\n assert_same \"\"\"\n quote(do: (bar(foo(1)) when bat: foo(1)), line: 1)\n \"\"\"\n\n assert_same \"\"\"\n typespec(quote(do: (bar(foo(1)) when bat: foo(1))), [foo: 1], [])\n \"\"\"\n end\n\n test \"false positive sigil\" do\n assert_same \"\"\"\n def sigil_d(<>, calendar) do\n ymd(year, month, day, calendar)\n end\n \"\"\"\n end\n\n test \"newline after stab\" do\n assert_same \"\"\"\n capture_io(\":erl. mof*,,l\", fn ->\n assert :io.scan_erl_form(~c\">\") == {:ok, [{:\":\", 1}, {:atom, 1, :erl}, {:dot, 1}], 1}\n\n expected_tokens = [{:atom, 1, :mof}, {:*, 1}, {:\",\", 1}, {:\",\", 1}, {:atom, 1, :l}]\n assert :io.scan_erl_form(~c\">\") == {:ok, expected_tokens, 1}\n\n assert :io.scan_erl_form(~c\">\") == {:eof, 1}\n end)\n \"\"\"\n end\n\n test \"capture with operators\" do\n assert_same \"\"\"\n \"this works\" |> (&String.upcase/1) |> (&String.downcase/1)\n \"\"\"\n\n assert_same \"\"\"\n \"this works\" || (&String.upcase/1) || (&String.downcase/1)\n \"\"\"\n\n assert_same \"\"\"\n \"this works\" == (&String.upcase/1) == (&String.downcase/1)\n \"\"\"\n\n bad = \"\"\"\n \"this works\" = (&String.upcase/1) = (&String.downcase/1)\n \"\"\"\n\n assert_format bad, \"\"\"\n \"this works\" = (&String.upcase/1) = &String.downcase/1\n \"\"\"\n\n bad = \"\"\"\n \"this works\" ++ (&String.upcase/1) ++ (&String.downcase/1)\n \"\"\"\n\n assert_format bad, \"\"\"\n \"this works\" ++ (&String.upcase/1) ++ &String.downcase/1\n \"\"\"\n\n bad = \"\"\"\n \"this works\" +++ (&String.upcase/1) +++ (&String.downcase/1)\n \"\"\"\n\n assert_format bad, \"\"\"\n \"this works\" +++ (&String.upcase/1) +++ &String.downcase/1\n \"\"\"\n\n bad = \"\"\"\n \"this works\" | (&String.upcase/1) | (&String.downcase/1)\n \"\"\"\n\n assert_format bad, \"\"\"\n \"this works\" | (&String.upcase/1) | &String.downcase/1\n \"\"\"\n\n bad = ~S\"\"\"\n \"this works\" \\\\ (&String.upcase/1) \\\\ (&String.downcase/1)\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n \"this works\" \\\\ &String.upcase/1 \\\\ &String.downcase/1\n \"\"\"\n end\n\n test \"multiline expression inside interpolation\" do\n bad = ~S\"\"\"\n Logger.info(\"Example: #{\n inspect(%{\n a: 1,\n b: 2\n })\n }\")\n \"\"\"\n\n assert_format bad, ~S\"\"\"\n Logger.info(\"Example: #{inspect(%{a: 1, b: 2})}\")\n \"\"\"\n end\n\n test \"comment inside operator with when\" do\n bad = \"\"\"\n raise function(x) ::\n # Comment\n any\n \"\"\"\n\n assert_format bad, \"\"\"\n # Comment\n raise function(x) ::\n any\n \"\"\"\n\n bad = \"\"\"\n raise function(x) ::\n # Comment\n any\n when x: any\n \"\"\"\n\n assert_format bad, \"\"\"\n raise function(x) ::\n any\n # Comment\n when x: any\n \"\"\"\n\n bad = \"\"\"\n @spec function(x) ::\n # Comment\n any\n when x: any\n \"\"\"\n\n assert_format bad, \"\"\"\n @spec function(x) ::\n any\n # Comment\n when x: any\n \"\"\"\n\n bad = \"\"\"\n @spec function(x) ::\n # Comment\n any\n when x\n when y\n \"\"\"\n\n assert_format bad, \"\"\"\n @spec function(x) ::\n any\n # Comment\n when x\n when y\n \"\"\"\n end\n\n test \"nested heredocs with multi-line string in interpolation\" do\n bad = ~S'''\n def foo do\n \"\"\"\n #{(feature_flag(:feature_x) && \"\n new_field\n \" || \"\")}\n \"\"\"\n end\n '''\n\n good = ~S'''\n def foo do\n \"\"\"\n #{(feature_flag(:feature_x) && \"\n new_field\n \") || \"\"}\n \"\"\"\n end\n '''\n\n assert_format bad, good\n end\n\n test \"functions with infinity line length\" do\n assert_same ~S\"\"\"\n x = fn ->\n {:ok, pid} = Repl.start_link({self(), opts})\n assert Exception.message(error) =~ msg\n end\n \"\"\",\n line_length: :infinity\n\n assert_same ~S\"\"\"\n capture_log(fn x ->\n {:ok, pid} = Repl.start_link({self(), opts})\n assert Exception.message(error) =~ msg\n end) =~ msg\n \"\"\",\n line_length: :infinity\n\n assert_same ~S\"\"\"\n capture_log(fn ->\n {:ok, pid} = Repl.start_link({self(), opts})\n assert Exception.message(error) =~ msg\n end) =~ msg\n \"\"\",\n line_length: :infinity\n\n assert_same ~S\"\"\"\n capture_log(fn x ->\n {:ok, pid} = Repl.start_link({self(), opts})\n assert Exception.message(error) =~ msg\n end) =~ msg\n \"\"\",\n line_length: :infinity\n end\n\n test \"functions without parentheses within do: keyword\" do\n assert_format ~S\"defmodule Foo, do: foo bar, baz\",\n ~S\"defmodule Foo, do: foo(bar, baz)\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/literals_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.LiteralsTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n @short_length [line_length: 10]\n\n describe \"integers\" do\n test \"in decimal base\" do\n assert_same \"0\"\n assert_same \"100\"\n assert_same \"007\"\n assert_same \"10000\"\n assert_same \"100_00\"\n assert_format \"100000\", \"100_000\"\n assert_format \"1000000\", \"1_000_000\"\n end\n\n test \"in binary base\" do\n assert_same \"0b0\"\n assert_same \"0b1\"\n assert_same \"0b101\"\n assert_same \"0b01\"\n assert_same \"0b111_111\"\n end\n\n test \"in octal base\" do\n assert_same \"0o77\"\n assert_same \"0o0\"\n assert_same \"0o01\"\n assert_same \"0o777_777\"\n end\n\n test \"in hex base\" do\n assert_same \"0x1\"\n assert_format \"0xabcdef\", \"0xABCDEF\"\n assert_same \"0x01\"\n assert_format \"0xfff_fff\", \"0xFFF_FFF\"\n end\n\n test \"as chars\" do\n assert_same \"?a\"\n assert_same \"?1\"\n assert_same \"?è\"\n assert_same \"??\"\n assert_same \"?\\\\\\\\\"\n assert_same \"?\\\\s\"\n assert_same \"?🎾\"\n end\n end\n\n describe \"floats\" do\n test \"with normal notation\" do\n assert_same \"0.0\"\n assert_same \"1.0\"\n assert_same \"123.456\"\n assert_same \"0.0000001\"\n assert_same \"001.100\"\n assert_same \"0_10000_0.000_000\"\n assert_format \"0100000.000000\", \"0_100_000.000000\"\n end\n\n test \"with scientific notation\" do\n assert_same \"1.0e1\"\n assert_same \"1.0e-1\"\n assert_same \"1.0e01\"\n assert_same \"1.0e-01\"\n assert_same \"001.100e-010\"\n assert_same \"0_100_0000.100e-010\"\n assert_format \"0100000.0e-5\", \"0_100_000.0e-5\"\n\n assert_format \"1.0E01\", \"1.0e01\"\n assert_format \"1.0E-01\", \"1.0e-01\"\n end\n end\n\n describe \"atoms\" do\n test \"true, false, nil\" do\n assert_same \"nil\"\n assert_same \"true\"\n assert_same \"false\"\n end\n\n test \"without escapes\" do\n assert_same ~S[:foo]\n assert_same ~S[:\\\\]\n end\n\n test \"with escapes\" do\n assert_same ~S[:\"f\\a\\b\\ro\"]\n assert_format ~S[:'f\\a\\b\\ro'], ~S[:\"f\\a\\b\\ro\"]\n assert_format ~S[:'single \\' quote'], ~S[:\"single ' quote\"]\n assert_format ~S[:\"double \\\" quote\"], ~S[:\"double \\\" quote\"]\n assert_same ~S[:\"\\\\\"]\n end\n\n test \"with unicode\" do\n assert_same ~S[:ólá]\n end\n\n test \"does not reformat aliases\" do\n assert_same ~S[:\"Elixir.String\"]\n end\n\n test \"removes quotes when they are not necessary\" do\n assert_format ~S[:\"foo\"], ~S[:foo]\n assert_format ~S[:\"++\"], ~S[:++]\n end\n\n test \"quoted operators\" do\n assert_same ~S[:\"::\"]\n end\n\n test \"uses double quotes even when single quotes are used\" do\n assert_format ~S[:'foo bar'], ~S[:\"foo bar\"]\n end\n\n test \"with interpolation\" do\n assert_same ~S[:\"one #{2} three\"]\n end\n\n test \"with escapes and interpolation\" do\n assert_same ~S[:\"one\\n\\\"#{2}\\\"\\nthree\"]\n end\n\n test \"with interpolation on line limit\" do\n assert_same ~S\"\"\"\n :\"one #{\"two\"} three\"\n \"\"\",\n @short_length\n end\n end\n\n describe \"strings\" do\n test \"without escapes\" do\n assert_same ~S[\"foo\"]\n end\n\n test \"with escapes\" do\n assert_same ~S[\"f\\a\\b\\ro\"]\n assert_same ~S[\"double \\\" quote\"]\n end\n\n test \"keeps literal new lines\" do\n assert_same \"\"\"\n \"fo\n o\"\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S[\"one #{} three\"]\n assert_same ~S[\"one #{2} three\"]\n end\n\n test \"with interpolation uses block content\" do\n assert_format ~S[\"one #{@two(three)}\"], ~S[\"one #{@two three}\"]\n end\n\n test \"with interpolation on line limit\" do\n assert_same ~S\"\"\"\n \"one #{\"two\"} three\"\n \"\"\",\n @short_length\n end\n\n test \"with escaped interpolation\" do\n assert_same ~S[\"one\\#{two}three\"]\n end\n\n test \"with escapes and interpolation\" do\n assert_same ~S[\"one\\n\\\"#{2}\\\"\\nthree\"]\n end\n\n test \"is measured in graphemes\" do\n assert_same ~S\"\"\"\n \"áá#{0}áá\"\n \"\"\",\n @short_length\n end\n\n test \"literal new lines don't count towards line limit\" do\n assert_same ~S\"\"\"\n \"one\n #{\"two\"}\n three\"\n \"\"\",\n @short_length\n end\n end\n\n describe \"charlists\" do\n test \"without escapes\" do\n assert_same ~S['']\n assert_same ~S[' ']\n assert_same ~S['foo']\n end\n\n test \"with escapes\" do\n assert_same ~S['f\\a\\b\\ro']\n assert_same ~S['single \\' quote']\n assert_same ~S['double \" quote']\n assert_same ~S['escaped \\\" quote']\n assert_same ~S['\\\\\"']\n end\n\n test \"keeps literal new lines\" do\n assert_same \"\"\"\n 'fo\n o'\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S['one #{2} three']\n assert_same ~S['#{1}\\n \\\\ \" \\\"']\n end\n\n test \"with escape and interpolation\" do\n assert_same ~S['one\\n\\'#{2}\\'\\nthree']\n end\n\n test \"with interpolation on line limit\" do\n assert_same ~S\"\"\"\n 'one #{\"two\"} three'\n \"\"\",\n @short_length\n end\n\n test \"literal new lines don't count towards line limit\" do\n assert_same ~S\"\"\"\n 'one\n #{\"two\"}\n three'\n \"\"\",\n @short_length\n end\n end\n\n describe \"string heredocs\" do\n test \"without escapes\" do\n assert_same ~S'''\n \"\"\"\n hello\n \"\"\"\n '''\n end\n\n test \"with escapes\" do\n assert_same ~S'''\n \"\"\"\n f\\a\\b\\ro\n \"\"\"\n '''\n\n assert_same ~S'''\n \"\"\"\n multiple \"\\\"\" quotes\n \"\"\"\n '''\n end\n\n test \"with interpolation\" do\n assert_same ~S'''\n \"\"\"\n one\n #{2}\n three\n \"\"\"\n '''\n\n assert_same ~S'''\n \"\"\"\n one\n \"\n #{2}\n \"\n three\n \"\"\"\n '''\n end\n\n test \"with interpolation on line limit\" do\n assert_same ~S'''\n \"\"\"\n one #{\"two two\"} three\n \"\"\"\n ''',\n @short_length\n end\n\n test \"nested with empty lines\" do\n assert_same ~S'''\n nested do\n \"\"\"\n\n foo\n\n\n bar\n\n \"\"\"\n end\n '''\n end\n\n test \"nested with empty lines and interpolation\" do\n assert_same ~S'''\n nested do\n \"\"\"\n\n #{foo}\n\n\n #{bar}\n\n \"\"\"\n end\n '''\n\n assert_same ~S'''\n nested do\n \"\"\"\n #{foo}\n\n\n #{bar}\n \"\"\"\n end\n '''\n end\n\n test \"literal new lines don't count towards line limit\" do\n assert_same ~S'''\n \"\"\"\n one\n #{\"two\"}\n three\n \"\"\"\n ''',\n @short_length\n end\n\n test \"with escaped new lines\" do\n assert_same ~S'''\n \"\"\"\n one\\\n #{\"two\"}\\\n three\\\n \"\"\"\n '''\n end\n\n test \"with new lines\" do\n assert_format ~s|foo do\\n \"\"\"\\n foo\\n \\n bar\\n \"\"\"\\nend|,\n ~s|foo do\\n \"\"\"\\n foo\\n\\n bar\\n \"\"\"\\nend|\n\n assert_format ~s|foo do\\r\\n \"\"\"\\r\\n foo\\r\\n \\r\\n bar\\r\\n \"\"\"\\r\\nend|,\n ~s|foo do\\n \"\"\"\\n foo\\r\\n\\r\\n bar\\r\\n \"\"\"\\nend|\n end\n end\n\n describe \"charlist heredocs\" do\n test \"without escapes\" do\n assert_same ~S\"\"\"\n '''\n hello\n '''\n \"\"\"\n end\n\n test \"with escapes\" do\n assert_same ~S\"\"\"\n '''\n f\\a\\b\\ro\n '''\n \"\"\"\n\n assert_same ~S\"\"\"\n '''\n multiple \"\\\"\" quotes\n '''\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S\"\"\"\n '''\n one\n #{2}\n three\n '''\n \"\"\"\n\n assert_same ~S\"\"\"\n '''\n one\n \"\n #{2}\n \"\n three\n '''\n \"\"\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/migration_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.MigrationTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n @short_length [line_length: 10]\n\n describe \"migrate_bitstring_modifiers: true\" do\n @opts [migrate_bitstring_modifiers: true]\n\n test \"normalizes bitstring modifiers\" do\n assert_format \"<>\", \"<>\", @opts\n assert_same \"<>\", @opts\n\n assert_format \"<>\", \"<>\", @opts\n assert_same \"<>\", @opts\n\n assert_format \"<>\", \"<>\", @opts\n assert_same \"<>\", @opts\n assert_same \"<<0::size*unit, bytes::binary>>\", @opts\n assert_format \"<<0::size*unit, bytes::custom>>\", \"<<0::size*unit, bytes::custom()>>\", @opts\n\n assert_format \"<<0, 1::2-integer() <- x>>\", \"<<0, 1::2-integer <- x>>\", @opts\n assert_same \"<<0, 1::2-integer <- x>>\", @opts\n end\n end\n\n describe \"migrate_call_parens_on_pipe: true\" do\n @opts [migrate_call_parens_on_pipe: true]\n\n test \"adds parentheses on the right operand\" do\n assert_format \"x |> y\", \"x |> y()\", @opts\n assert_format \"x |> y |> z\", \"x |> y() |> z()\", @opts\n assert_format \"x |> y.z\", \"x |> y.z()\", @opts\n assert_format \"x |> y.z.t\", \"x |> y.z.t()\", @opts\n end\n\n test \"does nothing within defmacro\" do\n assert_same \"defmacro left |> right, do: ...\", @opts\n end\n\n test \"does nothing without the migrate_unless option\" do\n assert_same \"x |> y\"\n assert_same \"x |> y |> z\"\n assert_same \"x |> y.z\"\n end\n end\n\n describe \"migrate_charlists_as_sigils: true\" do\n @opts [migrate_charlists_as_sigils: true]\n\n test \"without escapes\" do\n assert_format ~S[''], ~S[~c\"\"], @opts\n assert_format ~S[' '], ~S[~c\" \"], @opts\n assert_format ~S['foo'], ~S[~c\"foo\"], @opts\n end\n\n test \"with escapes\" do\n assert_format ~S['f\\a\\b\\ro'], ~S[~c\"f\\a\\b\\ro\"], @opts\n assert_format ~S['single \\' quote'], ~S[~c\"single ' quote\"], @opts\n assert_format ~S['double \" quote'], ~S[~c'double \" quote'], @opts\n assert_format ~S['escaped \\\" quote'], ~S[~c'escaped \\\" quote'], @opts\n assert_format ~S['\\\\\"'], ~S[~c'\\\\\"'], @opts\n end\n\n test \"keeps literal new lines\" do\n assert_format \"\"\"\n 'fo\n o'\n \"\"\",\n \"\"\"\n ~c\"fo\n o\"\n \"\"\",\n @opts\n end\n\n test \"with interpolation\" do\n assert_format ~S['one #{2} three'], ~S[~c\"one #{2} three\"], @opts\n assert_format ~S['#{1}\\n \\\\ \" \\\"'], ~S[~c'#{1}\\n \\\\ \" \\\"'], @opts\n end\n\n test \"with escape and interpolation\" do\n assert_format ~S['one\\n\\'#{2}\\'\\nthree'], ~S[~c\"one\\n'#{2}'\\nthree\"], @opts\n assert_format ~S['one\\n\"#{2}\"\\nthree'], ~S[~c'one\\n\"#{2}\"\\nthree'], @opts\n end\n\n test \"with interpolation on line limit\" do\n assert_format ~S\"\"\"\n 'one #{\"two\"} three'\n \"\"\",\n ~S\"\"\"\n ~c\"one #{\"two\"} three\"\n \"\"\",\n @short_length ++ @opts\n end\n\n test \"literal new lines don't count towards line limit\" do\n assert_format ~S\"\"\"\n 'one\n #{\"two\"}\n three'\n \"\"\",\n ~S\"\"\"\n ~c\"one\n #{\"two\"}\n three\"\n \"\"\",\n @short_length ++ @opts\n end\n\n test \"heredocs without escapes\" do\n assert_format ~S\"\"\"\n '''\n hello\n '''\n \"\"\",\n ~S'''\n ~c\"\"\"\n hello\n \"\"\"\n ''',\n @opts\n end\n\n test \"heredocs with escapes\" do\n assert_format ~S\"\"\"\n '''\n f\\a\\b\\ro\n '''\n \"\"\",\n ~S'''\n ~c\"\"\"\n f\\a\\b\\ro\n \"\"\"\n ''',\n @opts\n\n assert_format ~S\"\"\"\n '''\n multiple \"\\\"\" quotes\n '''\n \"\"\",\n ~S'''\n ~c\"\"\"\n multiple \"\\\"\" quotes\n \"\"\"\n ''',\n @opts\n end\n\n test \"heredocs with interpolation\" do\n assert_format ~S\"\"\"\n '''\n one\n #{2}\n three\n '''\n \"\"\",\n ~S'''\n ~c\"\"\"\n one\n #{2}\n three\n \"\"\"\n ''',\n @opts\n\n assert_format ~S\"\"\"\n '''\n one\n \"\n #{2}\n \"\n three\n '''\n \"\"\",\n ~S'''\n ~c\"\"\"\n one\n \"\n #{2}\n \"\n three\n \"\"\"\n ''',\n @opts\n end\n\n test \"heredocs with interpolation on line limit\" do\n assert_format ~S\"\"\"\n '''\n one #{\"two two\"} three\n '''\n \"\"\",\n ~S'''\n ~c\"\"\"\n one #{\"two two\"} three\n \"\"\"\n ''',\n @short_length ++ @opts\n end\n\n test \"heredocs literal new lines don't count towards line limit\" do\n assert_format ~S\"\"\"\n '''\n one\n #{\"two\"}\n three\n '''\n \"\"\",\n ~S'''\n ~c\"\"\"\n one\n #{\"two\"}\n three\n \"\"\"\n ''',\n @short_length ++ @opts\n end\n end\n\n describe \"migrate_unless: true\" do\n @opts [migrate_unless: true]\n\n test \"rewrites unless as an if with negated condition\" do\n bad = \"unless x, do: y\"\n\n good = \"if !x, do: y\"\n\n assert_format bad, good, @opts\n\n bad = \"\"\"\n unless x do\n y\n else\n z\n end\n \"\"\"\n\n good = \"\"\"\n if !x do\n y\n else\n z\n end\n \"\"\"\n\n assert_format bad, good, @opts\n end\n\n test \"rewrites pipelines with negated condition\" do\n bad = \"x |> unless(do: y)\"\n\n good = \"!x |> if(do: y)\"\n\n assert_format bad, good, @opts\n\n bad = \"x |> foo() |> unless(do: y)\"\n\n good = \"x |> foo() |> Kernel.!() |> if(do: y)\"\n\n assert_format bad, good, @opts\n\n bad = \"unless x |> foo(), do: y\"\n good = \"if !(x |> foo()), do: y\"\n\n assert_format bad, good, @opts\n end\n\n test \"rewrites in as not in\" do\n assert_format \"unless x in y, do: 1\", \"if x not in y, do: 1\", @opts\n end\n\n test \"rewrites equality operators\" do\n assert_format \"unless x == y, do: 1\", \"if x != y, do: 1\", @opts\n assert_format \"unless x === y, do: 1\", \"if x !== y, do: 1\", @opts\n assert_format \"unless x != y, do: 1\", \"if x == y, do: 1\", @opts\n assert_format \"unless x !== y, do: 1\", \"if x === y, do: 1\", @opts\n end\n\n test \"rewrites boolean or is_* conditions with not\" do\n assert_format \"unless x > 0, do: 1\", \"if not (x > 0), do: 1\", @opts\n assert_format \"unless is_atom(x), do: 1\", \"if not is_atom(x), do: 1\", @opts\n end\n\n test \"removes ! or not in condition\" do\n assert_format \"unless not x, do: 1\", \"if x, do: 1\", @opts\n assert_format \"unless !x, do: 1\", \"if x, do: 1\", @opts\n end\n\n test \"does nothing without the migrate_unless option\" do\n assert_same \"unless x, do: y\"\n assert_same \"unless x, do: y, else: z\"\n end\n end\n\n describe \"migrate: true\" do\n test \"enables :migrate_bitstring_modifiers\" do\n assert_format \"<>\", \"<>\", migrate: true\n end\n\n test \"enables :migrate_call_parens_on_pipe\" do\n bad = \"x |> y\"\n\n good = \"x |> y()\"\n\n assert_format bad, good, migrate: true\n end\n\n test \"enables :migrate_charlists_as_sigils\" do\n assert_format ~S['abc'], ~S[~c\"abc\"], migrate: true\n end\n\n test \"enables :migrate_unless\" do\n bad = \"unless x, do: y\"\n\n good = \"if !x, do: y\"\n\n assert_format bad, good, migrate: true\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_formatter/operators_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Formatter.OperatorsTest do\n use ExUnit.Case, async: true\n\n import CodeFormatterHelpers\n\n @short_length [line_length: 10]\n @medium_length [line_length: 20]\n\n describe \"nullary\" do\n test \"formats symbol operators\" do\n assert_same \"..\"\n end\n\n test \"combines with unary and binary operators\" do\n assert_same \"not ..\"\n assert_same \"left = ..\"\n assert_same \".. = right\"\n end\n\n test \"is wrapped in parentheses on ambiguous calls\" do\n assert_same \"require (..)\"\n assert_same \"require foo, (..)\"\n assert_same \"require (..), bar\"\n assert_same \"require(..)\"\n assert_same \"require(foo, ..)\"\n assert_same \"require(.., bar)\"\n\n assert_same \"assert [.., :ok]\"\n assert_same \"assert {.., :ok}\"\n assert_same \"assert (..) == 0..-1//1\"\n assert_same \"assert 0..-1//1 == (..)\"\n\n assert_same \"\"\"\n defmacro (..) do\n :ok\n end\\\n \"\"\"\n\n assert_format \"Range.range? (..)\", \"Range.range?(..)\"\n end\n end\n\n describe \"unary\" do\n test \"formats symbol operators without spaces\" do\n assert_format \"+ 1\", \"+1\"\n assert_format \"- 1\", \"-1\"\n assert_format \"! 1\", \"!1\"\n assert_format \"^ 1\", \"^1\"\n end\n\n test \"formats word operators with spaces\" do\n assert_same \"not 1\"\n assert_same \"not true\"\n end\n\n test \"wraps operand if it is a unary or binary operator\" do\n assert_format \"!+1\", \"!(+1)\"\n assert_format \"+ +1\", \"+(+1)\"\n assert_format \"not +1\", \"not (+1)\"\n assert_format \"!not 1\", \"!(not 1)\"\n assert_format \"not !1\", \"not (!1)\"\n assert_format \"not(!1)\", \"not (!1)\"\n assert_format \"not(1 + 1)\", \"not (1 + 1)\"\n assert_format \"-(2**2)\", \"-(2 ** 2)\"\n end\n\n test \"wraps operand in ambiguous calls\" do\n assert_same \"def -(2 ** 2)\"\n assert_same \"def -var\"\n assert_format \"def (-(2 ** 2))\", \"def -(2 ** 2)\"\n assert_format \"def --var\", \"def -- var\"\n assert_format \"def -+var\", \"def -(+var)\"\n end\n\n test \"does not wrap operand if it is a nestable operator\" do\n assert_format \"! ! var\", \"!!var\"\n assert_same \"not not var\"\n end\n\n test \"nests operand\" do\n bad = \"+foo(bar, baz, bat)\"\n\n good = \"\"\"\n +foo(\n bar,\n baz,\n bat\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n operator = \"\"\"\n +assert foo,\n bar\n \"\"\"\n\n assert_same operator, @short_length\n end\n\n test \"does not nest operand\" do\n bad = \"not foo(bar, baz, bat)\"\n\n good = \"\"\"\n not foo(\n bar,\n baz,\n bat\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n operator = \"\"\"\n not assert foo,\n bar\n \"\"\"\n\n assert_same operator, @short_length\n end\n\n test \"inside do-end block\" do\n assert_same \"\"\"\n if +value do\n true\n end\n \"\"\"\n end\n end\n\n describe \"binary without space\" do\n test \"formats without spaces\" do\n assert_format \"1 .. 2\", \"1..2\"\n end\n\n test \"never breaks\" do\n assert_same \"123_456_789..987_654_321\", @short_length\n end\n end\n\n describe \"ternary without space\" do\n test \"formats without spaces\" do\n assert_format \"1 .. 2 // 3\", \"1..2//3\"\n assert_same \"(1..2//3).step\"\n end\n\n test \"never breaks\" do\n assert_same \"123_456_789..987_654_321//147_268_369\", @short_length\n end\n end\n\n describe \"binary without newline\" do\n test \"formats without spaces\" do\n assert_same \"1 in 2\"\n assert_format \"1\\\\\\\\2\", \"1 \\\\\\\\ 2\"\n end\n\n test \"never breaks\" do\n assert_same \"123_456_789 in 987_654_321\", @short_length\n end\n\n test \"not in\" do\n assert_format \"not(foo in bar)\", \"foo not in bar\"\n\n assert_same \"foo not in bar\"\n assert_same \"(not foo) in bar\"\n assert_same \"(!foo) in bar\"\n end\n\n test \"bitwise precedence\" do\n assert_format \"(crc >>> 8) ||| byte\", \"crc >>> 8 ||| byte\"\n assert_same \"crc >>> (8 ||| byte)\"\n end\n end\n\n describe \"binary operators with preceding new line\" do\n test \"formats with spaces\" do\n assert_format \"1|>2\", \"1 |> 2\"\n end\n\n test \"breaks into new line\" do\n bad = \"123_456_789 |> 987_654_321\"\n\n good = \"\"\"\n 123_456_789\n |> 987_654_321\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"123 |> foo(bar, baz)\"\n\n good = \"\"\"\n 123\n |> foo(\n bar,\n baz\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"123 |> foo(bar) |> bar(bat)\"\n\n good = \"\"\"\n 123\n |> foo(\n bar\n )\n |> bar(\n bat\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"foo(bar, 123 |> bar(baz))\"\n\n good = \"\"\"\n foo(\n bar,\n 123\n |> bar(\n baz\n )\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"foo(bar, baz) |> 123\"\n\n good = \"\"\"\n foo(\n bar,\n baz\n )\n |> 123\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"foo(bar, baz) |> 123 |> 456\"\n\n good = \"\"\"\n foo(\n bar,\n baz\n )\n |> 123\n |> 456\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"123 |> foo(bar, baz) |> 456\"\n\n good = \"\"\"\n 123\n |> foo(\n bar,\n baz\n )\n |> 456\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with multiple of the different entry and same precedence\" do\n assert_same \"foo <~> bar ~> baz\"\n\n bad = \"foo <~> bar ~> baz\"\n\n good = \"\"\"\n foo\n <~> bar\n ~> baz\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with multiple of the different entry, same precedence and right associative\" do\n assert_format \"foo ++ bar ++ baz -- bat\", \"foo ++ bar ++ (baz -- bat)\"\n\n assert_format \"foo +++ bar +++ baz --- bat\", \"foo +++ bar +++ (baz --- bat)\"\n end\n\n test \"preserves user choice even when it fits\" do\n assert_same \"\"\"\n foo\n |> bar\n \"\"\"\n\n assert_same \"\"\"\n foo =\n one\n |> two()\n |> three()\n \"\"\"\n\n bad = \"\"\"\n foo |>\n bar\n \"\"\"\n\n good = \"\"\"\n foo\n |> bar\n \"\"\"\n\n assert_format bad, good\n end\n end\n\n describe \"binary with following new line\" do\n test \"formats with spaces\" do\n assert_format \"1++2\", \"1 ++ 2\"\n\n assert_format \"1+++2\", \"1 +++ 2\"\n end\n\n test \"breaks into new line\" do\n bad = \"123_456_789 ++ 987_654_321\"\n\n good = \"\"\"\n 123_456_789 ++\n 987_654_321\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"123 ++ foo(bar)\"\n\n good = \"\"\"\n 123 ++\n foo(bar)\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"123 ++ foo(bar, baz)\"\n\n good = \"\"\"\n 123 ++\n foo(\n bar,\n baz\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"foo(bar, 123 ++ bar(baz))\"\n\n good = \"\"\"\n foo(\n bar,\n 123 ++\n bar(\n baz\n )\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"foo(bar, baz) ++ 123\"\n\n good = \"\"\"\n foo(\n bar,\n baz\n ) ++ 123\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with multiple of the same entry and left associative\" do\n assert_same \"foo == bar == baz\"\n\n bad = \"a == b == c\"\n\n good = \"\"\"\n a == b ==\n c\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"(a == (b == c))\"\n\n good = \"\"\"\n a ==\n (b == c)\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"foo == bar == baz\"\n\n good = \"\"\"\n foo == bar ==\n baz\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"(foo == (bar == baz))\"\n\n good = \"\"\"\n foo ==\n (bar ==\n baz)\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with multiple of the same entry and right associative\" do\n assert_same \"foo ++ bar ++ baz\"\n assert_format \"foo -- bar -- baz\", \"foo -- (bar -- baz)\"\n assert_same \"foo +++ bar +++ baz\"\n assert_format \"foo --- bar --- baz\", \"foo --- (bar --- baz)\"\n\n bad = \"a ++ b ++ c\"\n\n good = \"\"\"\n a ++\n b ++ c\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"((a ++ b) ++ c)\"\n\n good = \"\"\"\n (a ++ b) ++\n c\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"foo ++ bar ++ baz\"\n\n good = \"\"\"\n foo ++\n bar ++\n baz\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"((foo ++ bar) ++ baz)\"\n\n good = \"\"\"\n (foo ++\n bar) ++\n baz\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with precedence\" do\n assert_format \"(a + b) == (c + d)\", \"a + b == c + d\"\n assert_format \"a + (b == c) + d\", \"a + (b == c) + d\"\n\n bad = \"(a + b) == (c + d)\"\n\n good = \"\"\"\n a + b ==\n c + d\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"a * (b + c) * d\"\n\n good = \"\"\"\n a *\n (b + c) *\n d\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"(one + two) == (three + four)\"\n\n good = \"\"\"\n one + two ==\n three + four\n \"\"\"\n\n assert_format bad, good, @medium_length\n\n bad = \"one * (two + three) * four\"\n\n good = \"\"\"\n one * (two + three) *\n four\n \"\"\"\n\n assert_format bad, good, @medium_length\n\n bad = \"one * (two + three + four) * five\"\n\n good = \"\"\"\n one *\n (two + three +\n four) * five\n \"\"\"\n\n assert_format bad, good, @medium_length\n\n bad = \"var = one * (two + three + four) * five\"\n\n good = \"\"\"\n var =\n one *\n (two + three +\n four) * five\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"with required parens\" do\n assert_same \"(a |> b) ++ (c |> d)\"\n assert_format \"a + b |> c + d\", \"(a + b) |> (c + d)\"\n assert_format \"a ++ b |> c ++ d\", \"(a ++ b) |> (c ++ d)\"\n assert_format \"a |> b ++ c |> d\", \"a |> (b ++ c) |> d\"\n end\n\n test \"with required parens skips on no parens\" do\n assert_same \"1..2 |> 3..4\"\n end\n\n test \"with logical operators\" do\n assert_same \"a or b or c\"\n assert_format \"a or b and c\", \"a or (b and c)\"\n assert_format \"a and b or c\", \"(a and b) or c\"\n end\n\n test \"mixed before and after lines\" do\n bad = \"var :: a | b and c | d\"\n\n good = \"\"\"\n var ::\n a\n | b and\n c\n | d\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"var :: a | b and c + d + e + f | g\"\n\n good = \"\"\"\n var ::\n a\n | b and\n c + d + e + f\n | g\n \"\"\"\n\n assert_format bad, good, @medium_length\n\n assert_same \"\"\"\n var ::\n {\n :one,\n :two\n }\n | :three\n \"\"\"\n end\n\n test \"preserves user choice even when it fits and left associative\" do\n assert_same \"\"\"\n foo + bar +\n baz + bat\n \"\"\"\n\n assert_same \"\"\"\n foo +\n bar +\n baz +\n bat\n \"\"\"\n end\n\n test \"preserves user choice even when it fits and right associative\" do\n bad = \"\"\"\n foo ++ bar ++\n baz ++ bat\n \"\"\"\n\n assert_format bad, \"\"\"\n foo ++\n bar ++\n baz ++ bat\n \"\"\"\n\n assert_same \"\"\"\n foo ++\n bar ++\n baz ++\n bat\n \"\"\"\n end\n end\n\n # Theoretically it fits under binary operators\n # but the goal of this section is to test common idioms.\n describe \"match\" do\n test \"with calls\" do\n bad = \"var = fun(one, two, three)\"\n\n good = \"\"\"\n var =\n fun(\n one,\n two,\n three\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"fun(one, two, three) = var\"\n\n good = \"\"\"\n fun(\n one,\n two,\n three\n ) = var\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"fun(foo, bar) = fun(baz, bat)\"\n\n good = \"\"\"\n fun(\n foo,\n bar\n ) =\n fun(\n baz,\n bat\n )\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"fun(foo, bar) = fun(baz, bat)\"\n\n good = \"\"\"\n fun(foo, bar) =\n fun(baz, bat)\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"with containers\" do\n bad = \"var = [one, two, three]\"\n\n good = \"\"\"\n var = [\n one,\n two,\n three\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"\"\"\n var =\n [one, two, three]\n \"\"\"\n\n good = \"\"\"\n var =\n [\n one,\n two,\n three\n ]\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"[one, two, three] = var\"\n\n good = \"\"\"\n [\n one,\n two,\n three\n ] = var\n \"\"\"\n\n assert_format bad, good, @short_length\n\n bad = \"[one, two, three] = foo(bar, baz)\"\n\n good = \"\"\"\n [one, two, three] =\n foo(bar, baz)\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"with heredoc\" do\n heredoc = ~S'''\n var = \"\"\"\n one\n \"\"\"\n '''\n\n assert_same heredoc, @short_length\n\n heredoc = ~S'''\n var = \"\"\"\n #{one}\n \"\"\"\n '''\n\n assert_same heredoc, @short_length\n end\n\n test \"with anonymous functions\" do\n bad = \"var = fn arg1 -> body1; arg2 -> body2 end\"\n\n good = \"\"\"\n var = fn\n arg1 ->\n body1\n\n arg2 ->\n body2\n end\n \"\"\"\n\n assert_format bad, good, @short_length\n\n good = \"\"\"\n var = fn\n arg1 -> body1\n arg2 -> body2\n end\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n\n test \"with do-end blocks\" do\n assert_same \"\"\"\n var =\n case true do\n foo -> bar\n baz -> bat\n end\n \"\"\"\n end\n end\n\n describe \"module attributes\" do\n test \"when reading\" do\n assert_format \"@ my_attribute\", \"@my_attribute\"\n end\n\n test \"when setting\" do\n assert_format \"@ my_attribute(:some_value)\", \"@my_attribute :some_value\"\n end\n\n test \"doesn't split when reading on line limit\" do\n assert_same \"@my_long_attribute\", @short_length\n end\n\n test \"doesn't split when setting on line limit\" do\n assert_same \"@my_long_attribute :some_value\", @short_length\n end\n\n test \"with do-end block\" do\n assert_same \"\"\"\n @attr (for x <- y do\n z\n end)\n \"\"\"\n end\n\n test \"is parenthesized when setting inside a call\" do\n assert_same \"my_fun(@foo(bar), baz)\"\n end\n\n test \"fall back to @ as an operator when needed\" do\n assert_same \"@(1 + 1)\"\n assert_same \"@:foo\"\n assert_same \"+@foo\"\n assert_same \"@@foo\"\n assert_same \"@(+foo)\"\n assert_same \"!(@(1 + 1))\"\n assert_same \"(@Foo).Baz\"\n assert_same \"@bar(1, 2)\"\n\n assert_format \"@+1\", \"@(+1)\"\n assert_format \"@Foo.Baz\", \"(@Foo).Baz\"\n assert_format \"@(Foo.Bar).Baz\", \"(@(Foo.Bar)).Baz\"\n end\n\n test \"with next break fits\" do\n attribute = ~S'''\n @doc \"\"\"\n foo\n \"\"\"\n '''\n\n assert_same attribute\n\n attribute = ~S'''\n @doc foo: \"\"\"\n bar\n \"\"\"\n '''\n\n assert_same attribute\n end\n\n test \"without next break fits\" do\n bad = \"@really_long_expr foo + bar\"\n\n good = \"\"\"\n @really_long_expr foo +\n bar\n \"\"\"\n\n assert_format bad, good, @short_length\n end\n\n test \"with do-end blocks\" do\n attribute = \"\"\"\n @doc do\n :ok\n end\n \"\"\"\n\n assert_same attribute, @short_length\n\n attribute = \"\"\"\n use (@doc do\n :end\n end)\n \"\"\"\n\n assert_same attribute, @short_length\n end\n\n test \"do not rewrite lists to keyword lists\" do\n assert_same \"\"\"\n @foo [\n bar: baz\n ]\n \"\"\"\n end\n end\n\n describe \"capture\" do\n test \"with integers\" do\n assert_same \"&1\"\n assert_format \"&(&1)\", \"& &1\"\n assert_format \"&(&1.foo)\", \"& &1.foo\"\n end\n\n test \"with operators inside\" do\n assert_format \"& +1\", \"&(+1)\"\n assert_format \"& 1[:foo]\", \"& 1[:foo]\"\n assert_format \"& not &1\", \"&(not &1)\"\n assert_format \"& a ++ b\", \"&(a ++ b)\"\n assert_format \"& &1 && &2\", \"&(&1 && &2)\"\n assert_same \"&(&1 | &2)\"\n end\n\n test \"with operators outside\" do\n assert_same \"(& &1) == (& &2)\"\n assert_same \"(& &1) and (& &2)\"\n assert_same \"(&foo/1) and (&bar/1)\"\n assert_same \"[(&IO.puts/1) | &IO.puts/2]\"\n end\n\n test \"with call expressions\" do\n assert_format \"& local(&1, &2)\", \"&local(&1, &2)\"\n assert_format \"&-local(&1, &2)\", \"&(-local(&1, &2))\"\n end\n\n test \"with blocks\" do\n bad = \"&(1; 2)\"\n\n good = \"\"\"\n &(\n 1\n 2\n )\n \"\"\"\n\n assert_format bad, good\n end\n\n test \"with no parens\" do\n capture = \"\"\"\n &assert foo,\n bar\n \"\"\"\n\n assert_same capture, @short_length\n end\n\n test \"precedence when combined with calls\" do\n assert_same \"(&Foo).Bar\"\n assert_format \"&(Foo).Bar\", \"&Foo.Bar\"\n assert_format \"&(Foo.Bar).Baz\", \"&Foo.Bar.Baz\"\n end\n\n test \"local/arity\" do\n assert_format \"&(foo/1)\", \"&foo/1\"\n assert_format \"&(foo/bar)\", \"&(foo / bar)\"\n end\n\n test \"operator/arity\" do\n assert_same \"&+/2\"\n assert_same \"&and/2\"\n assert_same \"& &&/2\"\n assert_same \"& &/1\"\n assert_same \"&//2\"\n end\n\n test \"Module.remote/arity\" do\n assert_format \"&(Mod.foo/1)\", \"&Mod.foo/1\"\n assert_format \"&(Mod.++/1)\", \"&Mod.++/1\"\n assert_format ~s[&(Mod.\"foo bar\"/1)], ~s[&Mod.\"foo bar\"/1]\n assert_format ~S[&(Mod.\"foo\\nbar\"/1)], ~S[&Mod.\"foo\\nbar\"/1]\n\n # Invalid\n assert_format \"& Mod.foo/bar\", \"&(Mod.foo() / bar)\"\n\n # This is \"invalid\" as a special form but we don't\n # have enough knowledge to know that, so let's just\n # make sure we format it properly with proper wrapping.\n assert_same \"&(1 + 2).foo/1\"\n\n assert_same \"&my_function.foo.bar/3\", @short_length\n end\n end\n\n describe \"when\" do\n test \"with keywords\" do\n assert_same \"foo when bar: :baz\"\n end\n\n test \"with keywords on line breaks\" do\n bad = \"foo when one: :two, three: :four\"\n\n good = \"\"\"\n foo\n when one: :two,\n three: :four\n \"\"\"\n\n assert_format bad, good, @medium_length\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_fragment_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule CodeFragmentTest do\n use ExUnit.Case, async: true\n\n doctest Code.Fragment\n alias Code.Fragment, as: CF\n\n describe \"cursor_context/2\" do\n test \"expressions\" do\n assert CF.cursor_context([]) == :expr\n assert CF.cursor_context(\",\") == :expr\n assert CF.cursor_context(\"[\") == :expr\n assert CF.cursor_context(\"<<\") == :expr\n assert CF.cursor_context(\"=>\") == :expr\n assert CF.cursor_context(\"->\") == :expr\n assert CF.cursor_context(\"foo(<<\") == :expr\n assert CF.cursor_context(\"hello: \") == :expr\n assert CF.cursor_context(\"\\n\") == :expr\n assert CF.cursor_context(~c\"\\n\") == :expr\n assert CF.cursor_context(\"\\n\\n\") == :expr\n assert CF.cursor_context(~c\"\\n\\n\") == :expr\n assert CF.cursor_context(\"\\r\\n\") == :expr\n assert CF.cursor_context(~c\"\\r\\n\") == :expr\n assert CF.cursor_context(\"\\r\\n\\r\\n\") == :expr\n assert CF.cursor_context(~c\"\\r\\n\\r\\n\") == :expr\n end\n\n test \"local_or_var\" do\n assert CF.cursor_context(\"hello_wo\") == {:local_or_var, ~c\"hello_wo\"}\n assert CF.cursor_context(\"hello_world?\") == {:local_or_var, ~c\"hello_world?\"}\n assert CF.cursor_context(\"hello_world!\") == {:local_or_var, ~c\"hello_world!\"}\n assert CF.cursor_context(\"hello/wor\") == {:local_or_var, ~c\"wor\"}\n assert CF.cursor_context(\"hello..wor\") == {:local_or_var, ~c\"wor\"}\n assert CF.cursor_context(\"hello::wor\") == {:local_or_var, ~c\"wor\"}\n assert CF.cursor_context(\"[hello_wo\") == {:local_or_var, ~c\"hello_wo\"}\n assert CF.cursor_context(\"'hello_wo\") == {:local_or_var, ~c\"hello_wo\"}\n assert CF.cursor_context(\"hellò_wó\") == {:local_or_var, ~c\"hellò_wó\"}\n assert CF.cursor_context(\"hello? world\") == {:local_or_var, ~c\"world\"}\n assert CF.cursor_context(\"hello! world\") == {:local_or_var, ~c\"world\"}\n assert CF.cursor_context(\"hello: world\") == {:local_or_var, ~c\"world\"}\n assert CF.cursor_context(\"__MODULE__\") == {:local_or_var, ~c\"__MODULE__\"}\n end\n\n test \"dot\" do\n assert CF.cursor_context(\"hello.\") == {:dot, {:var, ~c\"hello\"}, ~c\"\"}\n assert CF.cursor_context(\":hello.\") == {:dot, {:unquoted_atom, ~c\"hello\"}, ~c\"\"}\n assert CF.cursor_context(\"nested.map.\") == {:dot, {:dot, {:var, ~c\"nested\"}, ~c\"map\"}, ~c\"\"}\n\n assert CF.cursor_context(\"Hello.\") == {:dot, {:alias, ~c\"Hello\"}, ~c\"\"}\n assert CF.cursor_context(\"Hello.World.\") == {:dot, {:alias, ~c\"Hello.World\"}, ~c\"\"}\n assert CF.cursor_context(\"Hello.wor\") == {:dot, {:alias, ~c\"Hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"hello.wor\") == {:dot, {:var, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"Hello.++\") == {:dot, {:alias, ~c\"Hello\"}, ~c\"++\"}\n assert CF.cursor_context(\":hello.wor\") == {:dot, {:unquoted_atom, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\":hell@o.wor\") == {:dot, {:unquoted_atom, ~c\"hell@o\"}, ~c\"wor\"}\n assert CF.cursor_context(\":he@ll@o.wor\") == {:dot, {:unquoted_atom, ~c\"he@ll@o\"}, ~c\"wor\"}\n assert CF.cursor_context(\":hell@@o.wor\") == {:dot, {:unquoted_atom, ~c\"hell@@o\"}, ~c\"wor\"}\n assert CF.cursor_context(\"@hello.wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"@hello. wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"@hello .wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"@hello . wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"@hello.\\nwor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"@hello. \\nwor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"@hello.\\n wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"@hello.\\r\\nwor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"@hello\\n.wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"@hello \\n.wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n assert CF.cursor_context(\"@hello\\n .wor\") == {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"@hello. # some comment\\nwor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"@hello. # some comment\\n\\nwor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"@hello. # some comment\\nsub\\n.wor\") ==\n {:dot, {:dot, {:module_attribute, ~c\"hello\"}, ~c\"sub\"}, ~c\"wor\"}\n\n assert CF.cursor_context(~c\"@hello.\\nwor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(~c\"@hello.\\r\\nwor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(~c\"@hello\\n.wor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(~c\"@hello. # some comment\\nwor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(~c\"@hello. # some comment\\n\\nwor\") ==\n {:dot, {:module_attribute, ~c\"hello\"}, ~c\"wor\"}\n\n assert CF.cursor_context(~c\"@hello. # some comment\\nsub\\n.wor\") ==\n {:dot, {:dot, {:module_attribute, ~c\"hello\"}, ~c\"sub\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"nested.map.wor\") ==\n {:dot, {:dot, {:var, ~c\"nested\"}, ~c\"map\"}, ~c\"wor\"}\n\n assert CF.cursor_context(\"__MODULE__.\") == {:dot, {:var, ~c\"__MODULE__\"}, ~c\"\"}\n\n assert CF.cursor_context(\"__MODULE__.Sub.\") ==\n {:dot, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Sub\"}, ~c\"\"}\n\n assert CF.cursor_context(\"@hello.Sub.wor\") ==\n {:dot, {:alias, {:module_attribute, ~c\"hello\"}, ~c\"Sub\"}, ~c\"wor\"}\n end\n\n test \"local_arity\" do\n assert CF.cursor_context(\"hello/\") == {:local_arity, ~c\"hello\"}\n end\n\n test \"local_call\" do\n assert CF.cursor_context(\"hello\\s\") == {:local_call, ~c\"hello\"}\n assert CF.cursor_context(\"hello\\t\") == {:local_call, ~c\"hello\"}\n assert CF.cursor_context(\"hello(\") == {:local_call, ~c\"hello\"}\n assert CF.cursor_context(\"hello(\\s\") == {:local_call, ~c\"hello\"}\n assert CF.cursor_context(\"hello(\\t\") == {:local_call, ~c\"hello\"}\n assert CF.cursor_context(\"hello(\\n\") == {:local_call, ~c\"hello\"}\n assert CF.cursor_context(\"hello(\\r\\n\") == {:local_call, ~c\"hello\"}\n end\n\n test \"dot_arity\" do\n assert CF.cursor_context(\"Foo.hello/\") == {:dot_arity, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo.+/\") == {:dot_arity, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo . hello /\") == {:dot_arity, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo . + /\") == {:dot_arity, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"foo.hello/\") == {:dot_arity, {:var, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\":foo.hello/\") ==\n {:dot_arity, {:unquoted_atom, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\"@f.hello/\") == {:dot_arity, {:module_attribute, ~c\"f\"}, ~c\"hello\"}\n end\n\n test \"dot_call\" do\n assert CF.cursor_context(\"Foo.hello\\s\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo.hello\\t\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo.hello(\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo.hello(\\s\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo.hello(\\t\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo . hello (\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo . hello (\\s\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"Foo . hello (\\t\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\":foo.hello\\s\") ==\n {:dot_call, {:unquoted_atom, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\":foo.hello\\t\") ==\n {:dot_call, {:unquoted_atom, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\":foo.hello(\") == {:dot_call, {:unquoted_atom, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\":foo.hello(\\s\") ==\n {:dot_call, {:unquoted_atom, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\":foo.hello(\\t\") ==\n {:dot_call, {:unquoted_atom, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\":foo.hello\\s\") ==\n {:dot_call, {:unquoted_atom, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\"foo.hello\\s\") == {:dot_call, {:var, ~c\"foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"foo.hello\\t\") == {:dot_call, {:var, ~c\"foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"foo.hello(\") == {:dot_call, {:var, ~c\"foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"foo.hello(\\s\") == {:dot_call, {:var, ~c\"foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"foo.hello(\\t\") == {:dot_call, {:var, ~c\"foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"foo.hello(\\n\") == {:dot_call, {:var, ~c\"foo\"}, ~c\"hello\"}\n assert CF.cursor_context(\"foo.hello(\\r\\n\") == {:dot_call, {:var, ~c\"foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\"@f.hello\\s\") == {:dot_call, {:module_attribute, ~c\"f\"}, ~c\"hello\"}\n assert CF.cursor_context(\"@f.hello\\t\") == {:dot_call, {:module_attribute, ~c\"f\"}, ~c\"hello\"}\n assert CF.cursor_context(\"@f.hello(\") == {:dot_call, {:module_attribute, ~c\"f\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\"@f.hello(\\s\") ==\n {:dot_call, {:module_attribute, ~c\"f\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\"@f.hello(\\t\") ==\n {:dot_call, {:module_attribute, ~c\"f\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\"Foo.+\\s\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo.+\\t\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo.+(\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo.+(\\s\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo.+(\\t\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo . + (\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo . + (\\s\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n assert CF.cursor_context(\"Foo . + (\\t\") == {:dot_call, {:alias, ~c\"Foo\"}, ~c\"+\"}\n\n assert CF.cursor_context(\"__MODULE__.Foo.hello(\") ==\n {:dot_call, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Foo\"}, ~c\"hello\"}\n\n assert CF.cursor_context(\"@foo.Foo.hello(\") ==\n {:dot_call, {:alias, {:module_attribute, ~c\"foo\"}, ~c\"Foo\"}, ~c\"hello\"}\n end\n\n test \"anonymous_call\" do\n assert CF.cursor_context(\"hello.(\") == {:anonymous_call, {:var, ~c\"hello\"}}\n assert CF.cursor_context(\"hello.(\\s\") == {:anonymous_call, {:var, ~c\"hello\"}}\n assert CF.cursor_context(\"hello.(\\t\") == {:anonymous_call, {:var, ~c\"hello\"}}\n assert CF.cursor_context(\"hello.(\\n\") == {:anonymous_call, {:var, ~c\"hello\"}}\n assert CF.cursor_context(\"hello.(\\r\\n\") == {:anonymous_call, {:var, ~c\"hello\"}}\n\n assert CF.cursor_context(\"hello . (\") == {:anonymous_call, {:var, ~c\"hello\"}}\n\n assert CF.cursor_context(\"@hello.(\") == {:anonymous_call, {:module_attribute, ~c\"hello\"}}\n assert CF.cursor_context(\"@hello . (\") == {:anonymous_call, {:module_attribute, ~c\"hello\"}}\n end\n\n test \"nested expressions\" do\n assert CF.cursor_context(\"Hello.world()\") == :none\n assert CF.cursor_context(\"hello().\") == {:dot, :expr, ~c\"\"}\n assert CF.cursor_context(\"Foo.hello ('(').\") == {:dot, :expr, ~c\"\"}\n assert CF.cursor_context(\"Foo.hello('(', ?), ?().bar\") == {:dot, :expr, ~c\"bar\"}\n assert CF.cursor_context(\"Hello.bar(World.call(42), ?), ?().foo\") == {:dot, :expr, ~c\"foo\"}\n assert CF.cursor_context(\"Foo.hello( ).world\") == {:dot, :expr, ~c\"world\"}\n assert CF.cursor_context(\"hello.dyn_impl().call(42).bar\") == {:dot, :expr, ~c\"bar\"}\n\n assert CF.cursor_context(\"Foo.dyn_impl().call(\") == {:dot_call, :expr, ~c\"call\"}\n assert CF.cursor_context(\"hello().call(\") == {:dot_call, :expr, ~c\"call\"}\n end\n\n test \"alias\" do\n assert CF.cursor_context(\"HelloWor\") == {:alias, ~c\"HelloWor\"}\n assert CF.cursor_context(\"Hello.Wor\") == {:alias, ~c\"Hello.Wor\"}\n assert CF.cursor_context(\"Hello.\\nWor\") == {:alias, ~c\"Hello.Wor\"}\n assert CF.cursor_context(\"Hello.\\r\\nWor\") == {:alias, ~c\"Hello.Wor\"}\n assert CF.cursor_context(\"Hello . Wor\") == {:alias, ~c\"Hello.Wor\"}\n assert CF.cursor_context(\"Hello::Wor\") == {:alias, ~c\"Wor\"}\n assert CF.cursor_context(\"Hello..Wor\") == {:alias, ~c\"Wor\"}\n\n assert CF.cursor_context(\"hello.World\") ==\n {:alias, {:local_or_var, ~c\"hello\"}, ~c\"World\"}\n\n assert CF.cursor_context(\"__MODULE__.Wor\") ==\n {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Wor\"}\n\n assert CF.cursor_context(\"@foo.Wor\") == {:alias, {:module_attribute, ~c\"foo\"}, ~c\"Wor\"}\n end\n\n test \"structs\" do\n assert CF.cursor_context(\"%\") == {:struct, ~c\"\"}\n assert CF.cursor_context(\":%\") == {:unquoted_atom, ~c\"%\"}\n assert CF.cursor_context(\"::%\") == {:struct, ~c\"\"}\n\n assert CF.cursor_context(\"%HelloWor\") == {:struct, ~c\"HelloWor\"}\n\n assert CF.cursor_context(\"%Hello.\") == {:struct, {:dot, {:alias, ~c\"Hello\"}, ~c\"\"}}\n assert CF.cursor_context(\"%Hello.nam\") == {:struct, {:dot, {:alias, ~c\"Hello\"}, ~c\"nam\"}}\n assert CF.cursor_context(\"%Hello.Wor\") == {:struct, ~c\"Hello.Wor\"}\n assert CF.cursor_context(\"% Hello . Wor\") == {:struct, ~c\"Hello.Wor\"}\n\n assert CF.cursor_context(\"%__MODULE_\") == {:struct, {:local_or_var, ~c\"__MODULE_\"}}\n assert CF.cursor_context(\"%__MODULE__\") == {:struct, {:local_or_var, ~c\"__MODULE__\"}}\n\n assert CF.cursor_context(\"%__MODULE__.\") ==\n {:struct, {:dot, {:local_or_var, ~c\"__MODULE__\"}, ~c\"\"}}\n\n assert CF.cursor_context(\"%__MODULE__.Sub.\") ==\n {:struct, {:dot, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Sub\"}, ~c\"\"}}\n\n assert CF.cursor_context(\"%__MODULE__.Wor\") ==\n {:struct, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Wor\"}}\n\n assert CF.cursor_context(\"%@foo\") ==\n {:struct, {:module_attribute, ~c\"foo\"}}\n\n assert CF.cursor_context(\"%@foo.\") ==\n {:struct, {:dot, {:module_attribute, ~c\"foo\"}, ~c\"\"}}\n\n assert CF.cursor_context(\"%@foo.Wor\") ==\n {:struct, {:alias, {:module_attribute, ~c\"foo\"}, ~c\"Wor\"}}\n end\n\n test \"unquoted atom\" do\n assert CF.cursor_context(\":\") == {:unquoted_atom, ~c\"\"}\n assert CF.cursor_context(\":HelloWor\") == {:unquoted_atom, ~c\"HelloWor\"}\n assert CF.cursor_context(\":HelloWór\") == {:unquoted_atom, ~c\"HelloWór\"}\n assert CF.cursor_context(\":hello_wor\") == {:unquoted_atom, ~c\"hello_wor\"}\n assert CF.cursor_context(\":Óla_mundo\") == {:unquoted_atom, ~c\"Óla_mundo\"}\n assert CF.cursor_context(\":Ol@_mundo\") == {:unquoted_atom, ~c\"Ol@_mundo\"}\n assert CF.cursor_context(\":Ol@\") == {:unquoted_atom, ~c\"Ol@\"}\n assert CF.cursor_context(\"foo:hello_wor\") == {:unquoted_atom, ~c\"hello_wor\"}\n\n # Operators from atoms\n assert CF.cursor_context(\":+\") == {:unquoted_atom, ~c\"+\"}\n assert CF.cursor_context(\":or\") == {:unquoted_atom, ~c\"or\"}\n assert CF.cursor_context(\":<\") == {:unquoted_atom, ~c\"<\"}\n assert CF.cursor_context(\":.\") == {:unquoted_atom, ~c\".\"}\n assert CF.cursor_context(\":..\") == {:unquoted_atom, ~c\"..\"}\n assert CF.cursor_context(\":->\") == {:unquoted_atom, ~c\"->\"}\n assert CF.cursor_context(\":%\") == {:unquoted_atom, ~c\"%\"}\n end\n\n test \"operators\" do\n assert CF.cursor_context(\"/\") == {:operator, ~c\"/\"}\n assert CF.cursor_context(\"+\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"++\") == {:operator, ~c\"++\"}\n assert CF.cursor_context(\"!\") == {:operator, ~c\"!\"}\n assert CF.cursor_context(\"<\") == {:operator, ~c\"<\"}\n assert CF.cursor_context(\"<<<\") == {:operator, ~c\"<<<\"}\n assert CF.cursor_context(\"..\") == {:operator, ~c\"..\"}\n assert CF.cursor_context(\"<~\") == {:operator, ~c\"<~\"}\n assert CF.cursor_context(\"=~\") == {:operator, ~c\"=~\"}\n assert CF.cursor_context(\"<~>\") == {:operator, ~c\"<~>\"}\n assert CF.cursor_context(\"::\") == {:operator, ~c\"::\"}\n\n assert CF.cursor_context(\"+ \") == {:operator_call, ~c\"+\"}\n assert CF.cursor_context(\"++ \") == {:operator_call, ~c\"++\"}\n assert CF.cursor_context(\"! \") == {:operator_call, ~c\"!\"}\n assert CF.cursor_context(\"< \") == {:operator_call, ~c\"<\"}\n assert CF.cursor_context(\"<<< \") == {:operator_call, ~c\"<<<\"}\n assert CF.cursor_context(\".. \") == {:operator_call, ~c\"..\"}\n assert CF.cursor_context(\"<~ \") == {:operator_call, ~c\"<~\"}\n assert CF.cursor_context(\"=~ \") == {:operator_call, ~c\"=~\"}\n assert CF.cursor_context(\"<~> \") == {:operator_call, ~c\"<~>\"}\n assert CF.cursor_context(\":: \") == {:operator_call, ~c\"::\"}\n\n assert CF.cursor_context(\"...(\") == {:operator_call, ~c\"...\"}\n assert CF.cursor_context(\"...(\\s\") == {:operator_call, ~c\"...\"}\n assert CF.cursor_context(\"+(\") == {:operator_call, ~c\"+\"}\n assert CF.cursor_context(\"++(\\s\") == {:operator_call, ~c\"++\"}\n\n assert CF.cursor_context(\"+/\") == {:operator_arity, ~c\"+\"}\n assert CF.cursor_context(\"++/\") == {:operator_arity, ~c\"++\"}\n assert CF.cursor_context(\"!/\") == {:operator_arity, ~c\"!\"}\n assert CF.cursor_context(\"/\") == {:operator_arity, ~c\"<~>\"}\n assert CF.cursor_context(\"::/\") == {:operator_arity, ~c\"::\"}\n\n # Unknown operators altogether\n assert CF.cursor_context(\"***\") == :none\n\n # Textual operators are shown as local_or_var UNLESS there is space\n assert CF.cursor_context(\"when\") == {:local_or_var, ~c\"when\"}\n assert CF.cursor_context(\"when \") == {:operator_call, ~c\"when\"}\n assert CF.cursor_context(\"when.\") == :none\n\n assert CF.cursor_context(\"not\") == {:local_or_var, ~c\"not\"}\n assert CF.cursor_context(\"not \") == {:operator_call, ~c\"not\"}\n assert CF.cursor_context(\"not.\") == :none\n end\n\n test \"sigil\" do\n assert CF.cursor_context(\"~\") == {:sigil, ~c\"\"}\n assert CF.cursor_context(\"~ \") == :none\n\n assert CF.cursor_context(\"~r\") == {:sigil, ~c\"r\"}\n assert CF.cursor_context(\"~r/\") == :none\n assert CF.cursor_context(\"~r<\") == :none\n\n assert CF.cursor_context(\"~r''\") == :none\n assert CF.cursor_context(\"~r' '\") == :none\n assert CF.cursor_context(\"~r'foo'\") == :none\n\n # The slash is used in sigils, arities, and operators, so there is ambiguity\n assert CF.cursor_context(\"~r//\") == {:operator, ~c\"/\"}\n assert CF.cursor_context(\"~r/ /\") == {:operator, ~c\"/\"}\n assert CF.cursor_context(\"~r/foo/\") == {:local_arity, ~c\"foo\"}\n\n assert CF.cursor_context(\"~R\") == {:sigil, ~c\"R\"}\n assert CF.cursor_context(\"~R/\") == :none\n assert CF.cursor_context(\"~R<\") == :none\n\n assert CF.cursor_context(\"Foo.~\") == :none\n assert CF.cursor_context(\"Foo.~ \") == :none\n end\n\n test \"module attribute\" do\n assert CF.cursor_context(\"@\") == {:module_attribute, ~c\"\"}\n assert CF.cursor_context(\"@hello_wo\") == {:module_attribute, ~c\"hello_wo\"}\n end\n\n test \"keyword or binary operator\" do\n # Literals\n assert CF.cursor_context(\"Foo.Bar \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"Foo \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\":foo \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"123 \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"nil \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"true \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"false \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"\\\"foo\\\" \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"'foo' \") == {:block_keyword_or_binary_operator, ~c\"\"}\n\n # Containers\n assert CF.cursor_context(\"(foo) \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"[foo] \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"{foo} \") == {:block_keyword_or_binary_operator, ~c\"\"}\n assert CF.cursor_context(\"<> \") == {:block_keyword_or_binary_operator, ~c\"\"}\n\n # False positives\n assert CF.cursor_context(\"foo ~>> \") == {:operator_call, ~c\"~>>\"}\n assert CF.cursor_context(\"foo >>> \") == {:operator_call, ~c\">>>\"}\n end\n\n test \"keyword from keyword or binary operator\" do\n # Literals\n assert CF.cursor_context(\"Foo.Bar do\") == {:block_keyword_or_binary_operator, ~c\"do\"}\n assert CF.cursor_context(\"Foo.Bar d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"Foo d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\":foo d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"123 d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"nil d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"true d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"false d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"\\\"foo\\\" d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"'foo' d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n\n # Containers\n assert CF.cursor_context(\"(foo) d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"[foo] d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"{foo} d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n assert CF.cursor_context(\"<> d\") == {:block_keyword_or_binary_operator, ~c\"d\"}\n\n # False positives\n assert CF.cursor_context(\"foo ~>> d\") == {:local_or_var, ~c\"d\"}\n assert CF.cursor_context(\"foo >>> d\") == {:local_or_var, ~c\"d\"}\n end\n\n test \"operator from keyword or binary operator\" do\n # Literals\n assert CF.cursor_context(\"Foo.Bar +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"Foo +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\":foo +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"123 +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"nil +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"true +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"false +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"\\\"foo\\\" +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"'foo' +\") == {:operator, ~c\"+\"}\n\n # Containers\n assert CF.cursor_context(\"(foo) +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"[foo] +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"{foo} +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"<> +\") == {:operator, ~c\"+\"}\n\n # False positives\n assert CF.cursor_context(\"foo ~>> +\") == {:operator, ~c\"+\"}\n assert CF.cursor_context(\"foo >>> +\") == {:operator, ~c\"+\"}\n end\n\n test \"none\" do\n # Punctuation\n assert CF.cursor_context(\")\") == :none\n assert CF.cursor_context(\"}\") == :none\n assert CF.cursor_context(\">>\") == :none\n assert CF.cursor_context(\"'\") == :none\n assert CF.cursor_context(\"\\\"\") == :none\n\n # Numbers\n assert CF.cursor_context(\"123\") == :none\n assert CF.cursor_context(\"123?\") == :none\n assert CF.cursor_context(\"123!\") == :none\n assert CF.cursor_context(\"123var?\") == :none\n assert CF.cursor_context(\"0x\") == :none\n\n # Codepoints\n assert CF.cursor_context(\"?\") == :none\n assert CF.cursor_context(\"?a\") == :none\n assert CF.cursor_context(\"?foo\") == :none\n\n # Dots\n assert CF.cursor_context(\".\") == :none\n assert CF.cursor_context(\"Mundo.Óla\") == :none\n assert CF.cursor_context(\":hello.World\") == :none\n\n # Aliases\n assert CF.cursor_context(\"Hello::Wór\") == :none\n assert CF.cursor_context(\"ÓlaMundo\") == :none\n assert CF.cursor_context(\"HelloWór\") == :none\n assert CF.cursor_context(\"@Hello\") == :none\n assert CF.cursor_context(\"Hello(\") == :none\n\n # Identifier\n assert CF.cursor_context(\"foo@bar\") == :none\n assert CF.cursor_context(\"@foo@bar\") == :none\n end\n\n test \"newlines\" do\n assert CF.cursor_context(\"this+does-not*matter\\nHello.\") ==\n {:dot, {:alias, ~c\"Hello\"}, ~c\"\"}\n\n assert CF.cursor_context(~c\"this+does-not*matter\\nHello.\") ==\n {:dot, {:alias, ~c\"Hello\"}, ~c\"\"}\n\n assert CF.cursor_context(\"this+does-not*matter\\r\\nHello.\") ==\n {:dot, {:alias, ~c\"Hello\"}, ~c\"\"}\n\n assert CF.cursor_context(~c\"this+does-not*matter\\r\\nHello.\") ==\n {:dot, {:alias, ~c\"Hello\"}, ~c\"\"}\n end\n end\n\n describe \"surround_context/2\" do\n test \"newlines\" do\n for i <- 1..8 do\n assert CF.surround_context(\"\\n\\nhello_wo\\n\", {3, i}) == %{\n context: {:local_or_var, ~c\"hello_wo\"},\n begin: {3, 1},\n end: {3, 9}\n }\n\n assert CF.surround_context(\"\\r\\n\\r\\nhello_wo\\r\\n\", {3, i}) == %{\n context: {:local_or_var, ~c\"hello_wo\"},\n begin: {3, 1},\n end: {3, 9}\n }\n\n assert CF.surround_context(~c\"\\r\\n\\r\\nhello_wo\\r\\n\", {3, i}) == %{\n context: {:local_or_var, ~c\"hello_wo\"},\n begin: {3, 1},\n end: {3, 9}\n }\n end\n end\n\n test \"column out of range\" do\n assert CF.surround_context(\"hello\", {1, 20}) == :none\n end\n\n test \"local_or_var\" do\n for i <- 1..8 do\n assert CF.surround_context(\"hello_wo\", {1, i}) == %{\n context: {:local_or_var, ~c\"hello_wo\"},\n begin: {1, 1},\n end: {1, 9}\n }\n end\n\n assert CF.surround_context(\"hello_wo\", {1, 9}) == :none\n\n for i <- 2..9 do\n assert CF.surround_context(\" hello_wo\", {1, i}) == %{\n context: {:local_or_var, ~c\"hello_wo\"},\n begin: {1, 2},\n end: {1, 10}\n }\n end\n\n assert CF.surround_context(\" hello_wo\", {1, 10}) == :none\n\n for i <- 1..6 do\n assert CF.surround_context(\"hello!\", {1, i}) == %{\n context: {:local_or_var, ~c\"hello!\"},\n begin: {1, 1},\n end: {1, 7}\n }\n end\n\n assert CF.surround_context(\"hello!\", {1, 7}) == :none\n\n for i <- 1..5 do\n assert CF.surround_context(\"안녕_세상\", {1, i}) == %{\n context: {:local_or_var, ~c\"안녕_세상\"},\n begin: {1, 1},\n end: {1, 6}\n }\n end\n\n assert CF.surround_context(\"안녕_세상\", {1, 6}) == :none\n\n # Keywords are not local or var\n for keyword <- ~w(do end after catch else rescue fn true false nil)c,\n length = length(keyword),\n i <- 1..length do\n assert CF.surround_context(keyword, {1, i}) == %{\n context: {:keyword, keyword},\n begin: {1, 1},\n end: {1, length + 1}\n }\n\n assert CF.surround_context(~c\"Foo \" ++ keyword, {1, 4 + i}) == %{\n context: {:keyword, keyword},\n begin: {1, 5},\n end: {1, length + 5}\n }\n end\n end\n\n test \"local call\" do\n for i <- 1..8 do\n assert CF.surround_context(\"hello_wo(\", {1, i}) == %{\n context: {:local_call, ~c\"hello_wo\"},\n begin: {1, 1},\n end: {1, 9}\n }\n end\n\n assert CF.surround_context(\"hello_wo(\", {1, 9}) == :none\n\n for i <- 1..8 do\n assert CF.surround_context(\"hello_wo (\", {1, i}) == %{\n context: {:local_call, ~c\"hello_wo\"},\n begin: {1, 1},\n end: {1, 9}\n }\n end\n\n assert CF.surround_context(\"hello_wo (\", {1, 9}) == :none\n\n for i <- 1..6 do\n assert CF.surround_context(\"hello!(\", {1, i}) == %{\n context: {:local_call, ~c\"hello!\"},\n begin: {1, 1},\n end: {1, 7}\n }\n end\n\n assert CF.surround_context(\"hello!(\", {1, 7}) == :none\n\n for i <- 1..5 do\n assert CF.surround_context(\"안녕_세상(\", {1, i}) == %{\n context: {:local_call, ~c\"안녕_세상\"},\n begin: {1, 1},\n end: {1, 6}\n }\n end\n\n assert CF.surround_context(\"안녕_세상(\", {1, 6}) == :none\n end\n\n test \"local arity\" do\n for i <- 1..8 do\n assert CF.surround_context(\"hello_wo/\", {1, i}) == %{\n context: {:local_arity, ~c\"hello_wo\"},\n begin: {1, 1},\n end: {1, 9}\n }\n end\n\n assert CF.surround_context(\"hello_wo/\", {1, 9}) == :none\n\n for i <- 1..8 do\n assert CF.surround_context(\"hello_wo /\", {1, i}) == %{\n context: {:local_arity, ~c\"hello_wo\"},\n begin: {1, 1},\n end: {1, 9}\n }\n end\n\n assert CF.surround_context(\"hello_wo /\", {1, 9}) == :none\n\n for i <- 1..6 do\n assert CF.surround_context(\"hello!/\", {1, i}) == %{\n context: {:local_arity, ~c\"hello!\"},\n begin: {1, 1},\n end: {1, 7}\n }\n end\n\n assert CF.surround_context(\"hello!/\", {1, 7}) == :none\n\n for i <- 1..5 do\n assert CF.surround_context(\"안녕_세상/\", {1, i}) == %{\n context: {:local_arity, ~c\"안녕_세상\"},\n begin: {1, 1},\n end: {1, 6}\n }\n end\n\n assert CF.surround_context(\"안녕_세상/\", {1, 6}) == :none\n end\n\n test \"textual operators\" do\n for op <- ~w(when not or and in), i <- 1..byte_size(op) do\n assert CF.surround_context(\"#{op}\", {1, i}) == %{\n context: {:operator, String.to_charlist(op)},\n begin: {1, 1},\n end: {1, byte_size(op) + 1}\n }\n\n assert CF.surround_context(\"Foo #{op}\", {1, 4 + i}) == %{\n context: {:operator, String.to_charlist(op)},\n begin: {1, 5},\n end: {1, byte_size(op) + 5}\n }\n end\n end\n\n test \"dot\" do\n for i <- 1..5 do\n assert CF.surround_context(\"Hello.wor\", {1, i}) == %{\n context: {:alias, ~c\"Hello\"},\n begin: {1, 1},\n end: {1, 6}\n }\n end\n\n for i <- 6..9 do\n assert CF.surround_context(\"Hello.wor\", {1, i}) == %{\n context: {:dot, {:alias, ~c\"Hello\"}, ~c\"wor\"},\n begin: {1, 1},\n end: {1, 10}\n }\n end\n\n assert CF.surround_context(\"Hello.\", {1, 6}) == :none\n\n for i <- 1..5 do\n assert CF.surround_context(\"Hello . wor\", {1, i}) == %{\n context: {:alias, ~c\"Hello\"},\n begin: {1, 1},\n end: {1, 6}\n }\n end\n\n for i <- 6..11 do\n assert CF.surround_context(\"Hello . wor\", {1, i}) == %{\n context: {:dot, {:alias, ~c\"Hello\"}, ~c\"wor\"},\n begin: {1, 1},\n end: {1, 12}\n }\n end\n\n assert CF.surround_context(\"Hello .\", {1, 6}) == :none\n\n for i <- 1..5 do\n assert CF.surround_context(\"hello.wor\", {1, i}) == %{\n context: {:local_or_var, ~c\"hello\"},\n begin: {1, 1},\n end: {1, 6}\n }\n end\n\n for i <- 6..9 do\n assert CF.surround_context(\"hello.wor\", {1, i}) == %{\n context: {:dot, {:var, ~c\"hello\"}, ~c\"wor\"},\n begin: {1, 1},\n end: {1, 10}\n }\n end\n\n assert CF.surround_context(\"hello # comment\\n .wor\", {2, 4}) == %{\n context: {:dot, {:var, ~c\"hello\"}, ~c\"wor\"},\n begin: {1, 1},\n end: {2, 7}\n }\n\n assert CF.surround_context(\"123 + hello. # comment\\n\\n wor\", {3, 4}) == %{\n context: {:dot, {:var, ~c\"hello\"}, ~c\"wor\"},\n begin: {1, 7},\n end: {3, 6}\n }\n\n assert CF.surround_context(\"hello. # comment\\n\\n # wor\", {3, 5}) == %{\n context: {:local_or_var, ~c\"wor\"},\n begin: {3, 4},\n end: {3, 7}\n }\n end\n\n test \"alias\" do\n for i <- 1..8 do\n assert CF.surround_context(\"HelloWor\", {1, i}) == %{\n context: {:alias, ~c\"HelloWor\"},\n begin: {1, 1},\n end: {1, 9}\n }\n end\n\n assert CF.surround_context(\"HelloWor\", {1, 9}) == :none\n\n for i <- 2..9 do\n assert CF.surround_context(\" HelloWor\", {1, i}) == %{\n context: {:alias, ~c\"HelloWor\"},\n begin: {1, 2},\n end: {1, 10}\n }\n end\n\n assert CF.surround_context(\" HelloWor\", {1, 10}) == :none\n\n for i <- 1..9 do\n assert CF.surround_context(\"Hello.Wor\", {1, i}) == %{\n context: {:alias, ~c\"Hello.Wor\"},\n begin: {1, 1},\n end: {1, 10}\n }\n end\n\n assert CF.surround_context(\"Hello.Wor\", {1, 10}) == :none\n\n for i <- 1..11 do\n assert CF.surround_context(\"Hello . Wor\", {1, i}) == %{\n context: {:alias, ~c\"Hello.Wor\"},\n begin: {1, 1},\n end: {1, 12}\n }\n end\n\n assert CF.surround_context(\"Hello . Wor\", {1, 12}) == :none\n\n for i <- 1..15 do\n assert CF.surround_context(\"Foo . Bar . Baz\", {1, i}) == %{\n context: {:alias, ~c\"Foo.Bar.Baz\"},\n begin: {1, 1},\n end: {1, 16}\n }\n end\n\n for i <- 1..3 do\n assert CF.surround_context(\"Foo # dc\\n. Bar .\\n Baz\", {i, 1}) == %{\n context: {:alias, ~c\"Foo.Bar.Baz\"},\n begin: {1, 1},\n end: {3, 5}\n }\n end\n\n for i <- 1..11 do\n assert CF.surround_context(\"Foo.Bar.Baz.foo(bar)\", {1, i}) == %{\n context: {:alias, ~c\"Foo.Bar.Baz\"},\n begin: {1, 1},\n end: {1, 12}\n }\n end\n end\n\n test \"underscored special forms\" do\n assert CF.surround_context(\"__MODULE__\", {1, 1}) == %{\n context: {:local_or_var, ~c\"__MODULE__\"},\n begin: {1, 1},\n end: {1, 11}\n }\n\n for i <- 1..14 do\n assert CF.surround_context(\"__MODULE__.Foo\", {1, i}) == %{\n context: {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Foo\"},\n begin: {1, 1},\n end: {1, 15}\n }\n end\n\n for i <- 1..18 do\n assert CF.surround_context(\"__MODULE__.Foo.Sub\", {1, i}) == %{\n context: {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Foo.Sub\"},\n begin: {1, 1},\n end: {1, 19}\n }\n end\n\n assert CF.surround_context(\"%__MODULE__{}\", {1, 5}) == %{\n context: {:struct, {:local_or_var, ~c\"__MODULE__\"}},\n begin: {1, 1},\n end: {1, 12}\n }\n\n assert CF.surround_context(\"%__MODULE__.Foo{}\", {1, 13}) == %{\n context: {:struct, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Foo\"}},\n begin: {1, 1},\n end: {1, 16}\n }\n\n assert CF.surround_context(\"%__MODULE__.Foo.Sub{}\", {1, 17}) == %{\n context: {:struct, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Foo.Sub\"}},\n begin: {1, 1},\n end: {1, 20}\n }\n\n assert CF.surround_context(\"__MODULE__.call()\", {1, 13}) == %{\n context: {:dot, {:var, ~c\"__MODULE__\"}, ~c\"call\"},\n begin: {1, 1},\n end: {1, 16}\n }\n\n assert CF.surround_context(\"__MODULE__.Foo.call()\", {1, 17}) == %{\n context: {:dot, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Foo\"}, ~c\"call\"},\n begin: {1, 1},\n end: {1, 20}\n }\n\n assert CF.surround_context(\"__MODULE__.Foo.Sub.call()\", {1, 21}) == %{\n context: {:dot, {:alias, {:local_or_var, ~c\"__MODULE__\"}, ~c\"Foo.Sub\"}, ~c\"call\"},\n begin: {1, 1},\n end: {1, 24}\n }\n\n assert CF.surround_context(\"__ENV__.module.call()\", {1, 17}) == %{\n context: {:dot, {:dot, {:var, ~c\"__ENV__\"}, ~c\"module\"}, ~c\"call\"},\n begin: {1, 1},\n end: {1, 20}\n }\n end\n\n test \"attribute submodules\" do\n for i <- 1..9 do\n assert CF.surround_context(\"@some.Foo\", {1, i}) == %{\n context: {:alias, {:module_attribute, ~c\"some\"}, ~c\"Foo\"},\n begin: {1, 1},\n end: {1, 10}\n }\n end\n\n for i <- 1..13 do\n assert CF.surround_context(\"@some.Foo.Sub\", {1, i}) == %{\n context: {:alias, {:module_attribute, ~c\"some\"}, ~c\"Foo.Sub\"},\n begin: {1, 1},\n end: {1, 14}\n }\n end\n\n assert CF.surround_context(\"%@some{}\", {1, 5}) == %{\n context: {:struct, {:module_attribute, ~c\"some\"}},\n begin: {1, 1},\n end: {1, 7}\n }\n\n assert CF.surround_context(\"%@some.Foo{}\", {1, 10}) == %{\n context: {:struct, {:alias, {:module_attribute, ~c\"some\"}, ~c\"Foo\"}},\n begin: {1, 1},\n end: {1, 11}\n }\n\n assert CF.surround_context(\"%@some.Foo.Sub{}\", {1, 14}) == %{\n context: {:struct, {:alias, {:module_attribute, ~c\"some\"}, ~c\"Foo.Sub\"}},\n begin: {1, 1},\n end: {1, 15}\n }\n\n assert CF.surround_context(\"@some.call()\", {1, 8}) == %{\n context: {:dot, {:module_attribute, ~c\"some\"}, ~c\"call\"},\n begin: {1, 1},\n end: {1, 11}\n }\n\n assert CF.surround_context(\"@some.Foo.call()\", {1, 12}) == %{\n context: {:dot, {:alias, {:module_attribute, ~c\"some\"}, ~c\"Foo\"}, ~c\"call\"},\n begin: {1, 1},\n end: {1, 15}\n }\n\n assert CF.surround_context(\"@some.Foo.Sub.call()\", {1, 16}) == %{\n context: {:dot, {:alias, {:module_attribute, ~c\"some\"}, ~c\"Foo.Sub\"}, ~c\"call\"},\n begin: {1, 1},\n end: {1, 19}\n }\n end\n\n test \"struct\" do\n assert CF.surround_context(\"%\", {1, 1}) == :none\n assert CF.surround_context(\"::%\", {1, 1}) == :none\n assert CF.surround_context(\"::%\", {1, 2}) == :none\n assert CF.surround_context(\"::%Hello\", {1, 1}) == :none\n assert CF.surround_context(\"::%Hello\", {1, 2}) == :none\n\n assert CF.surround_context(\"::%Hello\", {1, 3}) == %{\n context: {:struct, ~c\"Hello\"},\n begin: {1, 3},\n end: {1, 9}\n }\n\n assert CF.surround_context(\"::% Hello\", {1, 3}) == %{\n context: {:struct, ~c\"Hello\"},\n begin: {1, 3},\n end: {1, 10}\n }\n\n assert CF.surround_context(\"::% Hello\", {1, 4}) == %{\n context: {:struct, ~c\"Hello\"},\n begin: {1, 3},\n end: {1, 10}\n }\n\n # Alias\n assert CF.surround_context(\"%HelloWor\", {1, 1}) == %{\n context: {:struct, ~c\"HelloWor\"},\n begin: {1, 1},\n end: {1, 10}\n }\n\n assert CF.surround_context(\"%HelloWor.some\", {1, 12}) == %{\n context: {:struct, {:dot, {:alias, ~c\"HelloWor\"}, ~c\"some\"}},\n begin: {1, 1},\n end: {1, 15}\n }\n\n for i <- 2..9 do\n assert CF.surround_context(\"%HelloWor\", {1, i}) == %{\n context: {:struct, ~c\"HelloWor\"},\n begin: {1, 1},\n end: {1, 10}\n }\n end\n\n assert CF.surround_context(\"%HelloWor\", {1, 10}) == :none\n\n # With dot\n assert CF.surround_context(\"%Hello.Wor\", {1, 1}) == %{\n context: {:struct, ~c\"Hello.Wor\"},\n begin: {1, 1},\n end: {1, 11}\n }\n\n for i <- 2..10 do\n assert CF.surround_context(\"%Hello.Wor\", {1, i}) == %{\n context: {:struct, ~c\"Hello.Wor\"},\n begin: {1, 1},\n end: {1, 11}\n }\n end\n\n assert CF.surround_context(\"%Hello.Wor\", {1, 11}) == :none\n\n # With spaces\n assert CF.surround_context(\"% Hello . Wor\", {1, 1}) == %{\n context: {:struct, ~c\"Hello.Wor\"},\n begin: {1, 1},\n end: {1, 14}\n }\n\n for i <- 2..13 do\n assert CF.surround_context(\"% Hello . Wor\", {1, i}) == %{\n context: {:struct, ~c\"Hello.Wor\"},\n begin: {1, 1},\n end: {1, 14}\n }\n end\n\n assert CF.surround_context(\"% Hello . Wor\", {1, 14}) == :none\n end\n\n test \"module attributes\" do\n for i <- 1..10 do\n assert CF.surround_context(\"@hello_wor\", {1, i}) == %{\n context: {:module_attribute, ~c\"hello_wor\"},\n begin: {1, 1},\n end: {1, 11}\n }\n end\n\n assert CF.surround_context(\"@Hello\", {1, 1}) == :none\n end\n\n test \"operators\" do\n for i <- 2..4 do\n assert CF.surround_context(\"1<<<3\", {1, i}) == %{\n context: {:operator, ~c\"<<<\"},\n begin: {1, 2},\n end: {1, 5}\n }\n end\n\n for i <- 3..5 do\n assert CF.surround_context(\"1 <<< 3\", {1, i}) == %{\n context: {:operator, ~c\"<<<\"},\n begin: {1, 3},\n end: {1, 6}\n }\n end\n\n for i <- 2..3 do\n assert CF.surround_context(\"1::3\", {1, i}) == %{\n context: {:operator, ~c\"::\"},\n begin: {1, 2},\n end: {1, 4}\n }\n end\n\n for i <- 3..4 do\n assert CF.surround_context(\"1 :: 3\", {1, i}) == %{\n context: {:operator, ~c\"::\"},\n begin: {1, 3},\n end: {1, 5}\n }\n end\n\n for i <- 2..3 do\n assert CF.surround_context(\"x..y\", {1, i}) == %{\n context: {:operator, ~c\"..\"},\n begin: {1, 2},\n end: {1, 4}\n }\n end\n\n for i <- 3..4 do\n assert CF.surround_context(\"x .. y\", {1, i}) == %{\n context: {:operator, ~c\"..\"},\n begin: {1, 3},\n end: {1, 5}\n }\n end\n\n assert CF.surround_context(\"@\", {1, 1}) == %{\n context: {:operator, ~c\"@\"},\n begin: {1, 1},\n end: {1, 2}\n }\n\n assert CF.surround_context(\"!\", {1, 1}) == %{\n context: {:operator, ~c\"!\"},\n begin: {1, 1},\n end: {1, 2}\n }\n\n assert CF.surround_context(\"!foo\", {1, 1}) == %{\n context: {:operator, ~c\"!\"},\n begin: {1, 1},\n end: {1, 2}\n }\n\n assert CF.surround_context(\"foo !bar\", {1, 5}) == %{\n context: {:operator, ~c\"!\"},\n begin: {1, 5},\n end: {1, 6}\n }\n\n # invalid\n assert CF.surround_context(\"->\", {1, 2}) == :none\n end\n\n test \"sigil\" do\n assert CF.surround_context(\"~\", {1, 1}) == :none\n assert CF.surround_context(\"~~r\", {1, 1}) == :none\n assert CF.surround_context(\"~~r\", {1, 2}) == :none\n\n assert CF.surround_context(\"~r/foo/\", {1, 1}) == %{\n begin: {1, 1},\n context: {:sigil, ~c\"r\"},\n end: {1, 3}\n }\n\n assert CF.surround_context(\"~r/foo/\", {1, 2}) == %{\n begin: {1, 1},\n context: {:sigil, ~c\"r\"},\n end: {1, 3}\n }\n\n assert CF.surround_context(\"~r/foo/\", {1, 3}) == :none\n\n assert CF.surround_context(\"~R\", {1, 1}) == %{\n begin: {1, 1},\n context: {:sigil, ~c\"R\"},\n end: {1, 3}\n }\n\n assert CF.surround_context(\"~R\", {1, 2}) == %{\n begin: {1, 1},\n context: {:sigil, ~c\"R\"},\n end: {1, 3}\n }\n\n assert CF.surround_context(\"~R\", {1, 3}) == :none\n end\n\n test \"dot operator\" do\n for i <- 4..7 do\n assert CF.surround_context(\"Foo.<<<\", {1, i}) == %{\n context: {:dot, {:alias, ~c\"Foo\"}, ~c\"<<<\"},\n begin: {1, 1},\n end: {1, 8}\n }\n end\n\n for i <- 4..9 do\n assert CF.surround_context(\"Foo . <<<\", {1, i}) == %{\n context: {:dot, {:alias, ~c\"Foo\"}, ~c\"<<<\"},\n begin: {1, 1},\n end: {1, 10}\n }\n end\n\n for i <- 4..6 do\n assert CF.surround_context(\"Foo.::\", {1, i}) == %{\n context: {:dot, {:alias, ~c\"Foo\"}, ~c\"::\"},\n begin: {1, 1},\n end: {1, 7}\n }\n end\n\n for i <- 4..8 do\n assert CF.surround_context(\"Foo . ::\", {1, i}) == %{\n context: {:dot, {:alias, ~c\"Foo\"}, ~c\"::\"},\n begin: {1, 1},\n end: {1, 9}\n }\n end\n end\n\n test \"capture operator\" do\n assert CF.surround_context(\"& &123 + 1\", {1, 1}) == %{\n context: {:operator, ~c\"&\"},\n begin: {1, 1},\n end: {1, 2}\n }\n\n for i <- 3..6 do\n assert CF.surround_context(\"& &123 + 1\", {1, i}) == %{\n context: {:capture_arg, ~c\"&123\"},\n begin: {1, 3},\n end: {1, 7}\n }\n end\n end\n\n test \"capture operator false positive\" do\n assert CF.surround_context(\"1&&2\", {1, 3}) == %{\n context: {:operator, ~c\"&&\"},\n begin: {1, 2},\n end: {1, 4}\n }\n\n assert CF.surround_context(\"1&&2\", {1, 4}) == :none\n\n assert CF.surround_context(\"&a\", {1, 2}) == %{\n context: {:local_or_var, ~c\"a\"},\n begin: {1, 2},\n end: {1, 3}\n }\n end\n\n test \"unquoted atom\" do\n for i <- 1..10 do\n assert CF.surround_context(\":hello_wor\", {1, i}) == %{\n context: {:unquoted_atom, ~c\"hello_wor\"},\n begin: {1, 1},\n end: {1, 11}\n }\n end\n\n for i <- 1..10 do\n assert CF.surround_context(\":Hello@Wor\", {1, i}) == %{\n context: {:unquoted_atom, ~c\"Hello@Wor\"},\n begin: {1, 1},\n end: {1, 11}\n }\n end\n\n assert CF.surround_context(\":\", {1, 1}) == :none\n end\n\n test \"keyword keys\" do\n for i <- 2..4 do\n assert CF.surround_context(\"[foo:\", {1, i}) == %{\n context: {:key, ~c\"foo\"},\n begin: {1, 2},\n end: {1, 5}\n }\n end\n\n for i <- 10..12 do\n assert CF.surround_context(\"[foo: 1, bar: 2]\", {1, i}) == %{\n context: {:key, ~c\"bar\"},\n begin: {1, 10},\n end: {1, 13}\n }\n end\n\n assert CF.surround_context(\"if foo?, do: bar()\", {1, 10}) == %{\n context: {:key, ~c\"do\"},\n begin: {1, 10},\n end: {1, 12}\n }\n end\n\n test \"keyword false positives\" do\n assert CF.surround_context(\"<>\")\n assert cc2q!(\"foo do\") == s2q!(\"foo do __cursor__() end\")\n assert cc2q!(\"foo do true else\") == s2q!(\"foo do true else __cursor__() end\")\n end\n\n test \"inside interpolation\" do\n assert cc2q!(~S|\"foo #{(|) == s2q!(~S|\"foo #{(__cursor__())}\"|)\n assert cc2q!(~S|\"foo #{\"bar #{{|) == s2q!(~S|\"foo #{\"bar #{{__cursor__()}}\"}\"|)\n end\n\n test \"keeps operators\" do\n assert cc2q!(\"1 + 2\") == s2q!(\"1 + __cursor__()\")\n assert cc2q!(\"&foo\") == s2q!(\"&__cursor__()\")\n assert cc2q!(\"&foo/\") == s2q!(\"&foo/__cursor__()\")\n end\n\n test \"keeps function calls without parens\" do\n assert cc2q!(\"alias\") == s2q!(\"__cursor__()\")\n assert cc2q!(\"alias \") == s2q!(\"alias __cursor__()\")\n assert cc2q!(\"alias foo\") == s2q!(\"alias __cursor__()\")\n assert cc2q!(\"alias Foo.Bar\") == s2q!(\"alias __cursor__()\")\n assert cc2q!(\"alias Foo.Bar,\") == s2q!(\"alias Foo.Bar, __cursor__()\")\n assert cc2q!(\"alias Foo.Bar, as: \") == s2q!(\"alias Foo.Bar, as: __cursor__()\")\n end\n\n test \"do-end blocks\" do\n assert cc2q!(\"foo do baz\") == s2q!(\"foo do __cursor__() end\")\n assert cc2q!(\"foo do bar; baz\") == s2q!(\"foo do bar; __cursor__() end\")\n assert cc2q!(\"foo do bar\\nbaz\") == s2q!(\"foo do bar\\n__cursor__() end\")\n\n assert cc2q!(\"foo(bar do baz\") == s2q!(\"foo(bar do __cursor__() end)\")\n assert cc2q!(\"foo(bar do baz \") == s2q!(\"foo(bar do baz(__cursor__()) end)\")\n assert cc2q!(\"foo(bar do baz(\") == s2q!(\"foo(bar do baz(__cursor__()) end)\")\n assert cc2q!(\"foo(bar do baz bat,\") == s2q!(\"foo(bar do baz(bat, __cursor__()) end)\")\n\n assert cc2q!(\"foo(bar do baz, bat\", trailing_fragment: \" -> :ok end\") ==\n s2q!(\"foo(bar do baz, __cursor__() -> :ok end)\")\n end\n\n test \"keyword lists\" do\n assert cc2q!(\"[bar: \") == s2q!(\"[bar: __cursor__()]\")\n assert cc2q!(\"[bar: baz,\") == s2q!(\"[bar: baz, __cursor__()]\")\n assert cc2q!(\"[arg, bar: baz,\") == s2q!(\"[arg, bar: baz, __cursor__()]\")\n assert cc2q!(\"[arg: val, bar: baz,\") == s2q!(\"[arg: val, bar: baz, __cursor__()]\")\n\n assert cc2q!(\"{arg, bar: \") == s2q!(\"{arg, bar: __cursor__()}\")\n assert cc2q!(\"{arg, bar: baz,\") == s2q!(\"{arg, bar: baz, __cursor__()}\")\n\n assert cc2q!(\"foo(bar: \") == s2q!(\"foo(bar: __cursor__())\")\n assert cc2q!(\"foo(bar: baz,\") == s2q!(\"foo([bar: baz, __cursor__()])\")\n assert cc2q!(\"foo(arg, bar: \") == s2q!(\"foo(arg, bar: __cursor__())\")\n assert cc2q!(\"foo(arg, bar: baz,\") == s2q!(\"foo(arg, [bar: baz, __cursor__()])\")\n assert cc2q!(\"foo(arg: val, bar: \") == s2q!(\"foo(arg: val, bar: __cursor__())\")\n assert cc2q!(\"foo(arg: val, bar: baz,\") == s2q!(\"foo([arg: val, bar: baz, __cursor__()])\")\n\n assert cc2q!(\"foo bar: \") == s2q!(\"foo(bar: __cursor__())\")\n assert cc2q!(\"foo bar: baz,\") == s2q!(\"foo([bar: baz, __cursor__()])\")\n assert cc2q!(\"foo arg, bar: \") == s2q!(\"foo(arg, bar: __cursor__())\")\n assert cc2q!(\"foo arg, bar: baz,\") == s2q!(\"foo(arg, [bar: baz, __cursor__()])\")\n assert cc2q!(\"foo arg: val, bar: \") == s2q!(\"foo(arg: val, bar: __cursor__())\")\n assert cc2q!(\"foo arg: val, bar: baz,\") == s2q!(\"foo([arg: val, bar: baz, __cursor__()])\")\n end\n\n test \"maps and structs\" do\n assert cc2q!(\"%\") == s2q!(\"__cursor__()\")\n assert cc2q!(\"%{\") == s2q!(\"%{__cursor__()}\")\n assert cc2q!(\"%{bar:\") == s2q!(\"%{__cursor__()}\")\n assert cc2q!(\"%{bar: \") == s2q!(\"%{bar: __cursor__()}\")\n assert cc2q!(\"%{bar: baz,\") == s2q!(\"%{bar: baz, __cursor__()}\")\n assert cc2q!(\"%{foo | \") == s2q!(\"%{foo | __cursor__()}\")\n assert cc2q!(\"%{foo | bar:\") == s2q!(\"%{foo | __cursor__()}\")\n assert cc2q!(\"%{foo | bar: \") == s2q!(\"%{foo | bar: __cursor__()}\")\n assert cc2q!(\"%{foo | bar: baz,\") == s2q!(\"%{foo | bar: baz, __cursor__()}\")\n\n assert cc2q!(\"%Foo\") == s2q!(\"__cursor__()\")\n assert cc2q!(\"%Foo{\") == s2q!(\"%Foo{__cursor__()}\")\n assert cc2q!(\"%Foo{bar: \") == s2q!(\"%Foo{bar: __cursor__()}\")\n assert cc2q!(\"%Foo{bar: baz,\") == s2q!(\"%Foo{bar: baz, __cursor__()}\")\n assert cc2q!(\"%Foo{foo | \") == s2q!(\"%Foo{foo | __cursor__()}\")\n assert cc2q!(\"%Foo{foo | bar:\") == s2q!(\"%Foo{foo | __cursor__()}\")\n assert cc2q!(\"%Foo{foo | bar: \") == s2q!(\"%Foo{foo | bar: __cursor__()}\")\n assert cc2q!(\"%Foo{foo | bar: baz,\") == s2q!(\"%Foo{foo | bar: baz, __cursor__()}\")\n end\n\n test \"binaries\" do\n assert cc2q!(\"<<\") == s2q!(\"<<__cursor__()>>\")\n assert cc2q!(\"<>\")\n assert cc2q!(\"<>\")\n assert cc2q!(\"<>\")\n end\n\n test \"anonymous functions\" do\n assert cc2q!(\"(fn\", trailing_fragment: \"-> end)\") == s2q!(\"(fn __cursor__() -> nil end)\")\n\n assert cc2q!(\"(fn\", trailing_fragment: \"-> 1 + 2 end)\") ==\n s2q!(\"(fn __cursor__() -> 1 + 2 end)\")\n\n assert cc2q!(\"(fn x\", trailing_fragment: \"-> :ok end)\") ==\n s2q!(\"(fn __cursor__() -> :ok end)\")\n\n assert cc2q!(\"(fn x\", trailing_fragment: \", y -> :ok end)\") ==\n s2q!(\"(fn __cursor__(), y -> :ok end)\")\n\n assert cc2q!(\"(fn x,\", trailing_fragment: \"y -> :ok end)\") ==\n s2q!(\"(fn x, __cursor__() -> :ok end)\")\n\n assert cc2q!(\"(fn x,\", trailing_fragment: \"\\ny -> :ok end)\") ==\n s2q!(\"(fn x, __cursor__()\\n -> :ok end)\")\n\n assert cc2q!(\"(fn x, {\", trailing_fragment: \"y, z} -> :ok end)\") ==\n s2q!(\"(fn x, {__cursor__(), z} -> :ok end)\")\n\n assert cc2q!(\"(fn x, {y\", trailing_fragment: \", z} -> :ok end)\") ==\n s2q!(\"(fn x, {__cursor__(), z} -> :ok end)\")\n\n assert cc2q!(\"(fn x, {y, \", trailing_fragment: \"z} -> :ok end)\") ==\n s2q!(\"(fn x, {y, __cursor__()} -> :ok end)\")\n\n assert cc2q!(\"(fn x ->\", trailing_fragment: \":ok end)\") ==\n s2q!(\"(fn x -> __cursor__() end)\")\n\n assert cc2q!(\"(fn x ->\", trailing_fragment: \"\\n:ok end)\") ==\n s2q!(\"(fn x -> __cursor__() end)\")\n\n assert cc2q!(\"(fn x when \", trailing_fragment: \"-> :ok end)\") ==\n s2q!(\"(fn x when __cursor__() -> :ok end)\")\n\n assert cc2q!(\"(fn x when \", trailing_fragment: \"->\\n:ok end)\") ==\n s2q!(\"(fn x when __cursor__() -> :ok end)\")\n\n assert cc2q!(\"(fn\") == s2q!(\"(__cursor__())\")\n assert cc2q!(\"(fn x\") == s2q!(\"(__cursor__())\")\n assert cc2q!(\"(fn x,\") == s2q!(\"(__cursor__())\")\n assert cc2q!(\"(fn x ->\") == s2q!(\"(fn x -> __cursor__() end)\")\n assert cc2q!(\"(fn x -> x\") == s2q!(\"(fn x -> __cursor__() end)\")\n assert cc2q!(\"(fn x, y -> x + y\") == s2q!(\"(fn x, y -> x + __cursor__() end)\")\n assert cc2q!(\"(fn x, y -> x + y end\") == s2q!(\"(__cursor__())\")\n end\n\n test \"do -> end\" do\n assert cc2q!(\"if do\\nx ->\\n\", trailing_fragment: \"y\\nz ->\\nw\\nend\") ==\n s2q!(\"if do\\nx ->\\n__cursor__()\\nz -> \\nw\\nend\")\n\n assert cc2q!(\"if do\\nx ->\\ny\", trailing_fragment: \"\\nz ->\\nw\\nend\") ==\n s2q!(\"if do\\nx ->\\n__cursor__()\\nz -> \\nw\\nend\")\n\n assert cc2q!(\"if do\\nx ->\\ny\\n\", trailing_fragment: \"\\nz ->\\nw\\nend\") ==\n s2q!(\"if do\\nx ->\\ny\\n__cursor__()\\nz -> \\nw\\nend\")\n\n assert cc2q!(\"for x <- [], reduce: %{} do\\ny, \", trailing_fragment: \"-> :ok\\nend\") ==\n s2q!(\"for x <- [], reduce: %{} do\\ny, __cursor__() -> :ok\\nend\")\n\n assert cc2q!(\"for x <- [], reduce: %{} do\\ny, z when \", trailing_fragment: \"-> :ok\\nend\") ==\n s2q!(\"for x <- [], reduce: %{} do\\ny, z when __cursor__() -> :ok\\nend\")\n\n assert cc2q!(\"case do\\na -> a\\nb = \", trailing_fragment: \"c -> c\\nend\") ==\n s2q!(\"case do\\na -> a\\nb = __cursor__() -> c\\nend\")\n end\n\n test \"removes tokens until opening\" do\n assert cc2q!(\"(123\") == s2q!(\"(__cursor__())\")\n assert cc2q!(\"[foo\") == s2q!(\"[__cursor__()]\")\n assert cc2q!(\"{'foo'\") == s2q!(\"{__cursor__()}\")\n assert cc2q!(\"foo do :atom\") == s2q!(\"foo do __cursor__() end\")\n assert cc2q!(\"foo(:atom\") == s2q!(\"foo(__cursor__())\")\n end\n\n test \"removes tokens until comma\" do\n assert cc2q!(\"[bar, 123\") == s2q!(\"[bar, __cursor__()]\")\n assert cc2q!(\"{bar, 'foo'\") == s2q!(\"{bar, __cursor__()}\")\n assert cc2q!(\"<>\")\n assert cc2q!(\"foo(bar, :atom\") == s2q!(\"foo(bar, __cursor__())\")\n assert cc2q!(\"foo bar, :atom\") == s2q!(\"foo(bar, __cursor__())\")\n end\n\n test \"removes closed terminators\" do\n assert cc2q!(\"foo([1, 2, 3]\") == s2q!(\"foo(__cursor__())\")\n assert cc2q!(\"foo({1, 2, 3}\") == s2q!(\"foo(__cursor__())\")\n assert cc2q!(\"foo((1, 2, 3)\") == s2q!(\"foo(__cursor__())\")\n assert cc2q!(\"foo(<<1, 2, 3>>\") == s2q!(\"foo(__cursor__())\")\n assert cc2q!(\"foo(bar do :done end\") == s2q!(\"foo(__cursor__())\")\n end\n\n test \"incomplete expressions\" do\n assert cc2q!(\"foo(123, :\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, %\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, 0x\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r/\") == s2q!(\"foo(123, __cursor__())\")\n end\n\n test \"sigils\" do\n assert cc2q!(\"foo(123, ~\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r/\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r/foo\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r//\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r//i\") == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r//i \") == s2q!(\"foo(123, __cursor__())\")\n\n drop_metadata = fn ast ->\n Macro.prewalk(ast, fn node ->\n Macro.update_meta(node, &Keyword.drop(&1, [:delimiter, :column]))\n end)\n end\n\n assert cc2q!(\"foo(123, ~\", preserve_sigils: true) == s2q!(\"foo(123, __cursor__())\")\n assert cc2q!(\"foo(123, ~r\", preserve_sigils: true) == s2q!(\"foo(123, __cursor__())\")\n\n assert cc2q!(\"foo(123, ~r/\", preserve_sigils: true) |> drop_metadata.() ==\n s2q!(\"foo(123, sigil_r(<<\\\"\\\">>, __cursor__()))\")\n\n assert cc2q!(\"foo(123, ~r/foo\", preserve_sigils: true) |> drop_metadata.() ==\n s2q!(\"foo(123, sigil_r(<<\\\"foo\\\">>, __cursor__()))\")\n\n assert cc2q!(\"foo(123, ~r//\", preserve_sigils: true) |> drop_metadata.() ==\n s2q!(\"foo(123, sigil_r(<<\\\"\\\">>, [__cursor__()]))\")\n\n assert cc2q!(\"foo(123, ~r//i\", preserve_sigils: true) |> drop_metadata.() ==\n s2q!(\"foo(123, sigil_r(<<\\\"\\\">>, [?i, __cursor__()]))\")\n\n assert cc2q!(\"foo(123, ~r//i \", preserve_sigils: true) |> drop_metadata.() ==\n s2q!(\"foo(123, __cursor__())\")\n end\n\n test \"no warnings\" do\n assert cc2q!(~s\"?\\\\ \") == s2q!(\"__cursor__()\")\n assert cc2q!(~s\"{fn -> end, \") == s2q!(\"{fn -> nil end, __cursor__()}\")\n end\n\n test \"options\" do\n opts = [columns: true]\n assert cc2q!(\"foo(\", opts) == s2q!(\"foo(__cursor__())\", opts)\n assert cc2q!(\"foo(123,\", opts) == s2q!(\"foo(123,__cursor__())\", opts)\n\n opts = [token_metadata: true]\n assert cc2q!(\"foo(\", opts) == s2q!(\"foo(__cursor__())\", opts)\n assert cc2q!(\"foo(123,\", opts) == s2q!(\"foo(123,__cursor__())\", opts)\n\n opts = [literal_encoder: fn ast, _ -> {:ok, {:literal, ast}} end]\n assert cc2q!(\"foo(\", opts) == s2q!(\"foo(__cursor__())\", opts)\n assert cc2q!(\"foo(123,\", opts) == s2q!(\"foo({:literal, 123},__cursor__())\", [])\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_identifier_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule Code.IdentifierTest do\n use ExUnit.Case, async: true\n doctest Code.Identifier\nend\n" }, { "path": "lib/elixir/test/elixir/code_normalizer/formatted_ast_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Normalizer.FormatterASTTest do\n use ExUnit.Case, async: true\n\n defmacro assert_same(good, opts \\\\ []) do\n quote bind_quoted: [good: good, opts: opts], location: :keep do\n assert IO.iodata_to_binary(Code.format_string!(good, opts)) ==\n string_to_string(good, opts)\n end\n end\n\n def string_to_string(good, opts) do\n line_length = Keyword.get(opts, :line_length, 98)\n good = String.trim(good)\n\n to_quoted_opts =\n Keyword.merge(\n [\n literal_encoder: &{:ok, {:__block__, &2, [&1]}},\n token_metadata: true,\n unescape: false\n ],\n opts\n )\n\n {quoted, comments} = Code.string_to_quoted_with_comments!(good, to_quoted_opts)\n\n to_algebra_opts = [comments: comments, escape: false] ++ opts\n\n quoted\n |> Code.quoted_to_algebra(to_algebra_opts)\n |> Inspect.Algebra.format(line_length)\n |> IO.iodata_to_binary()\n end\n\n describe \"integers\" do\n test \"in decimal base\" do\n assert_same \"0\"\n assert_same \"100\"\n assert_same \"007\"\n assert_same \"10000\"\n assert_same \"100_00\"\n end\n\n test \"in binary base\" do\n assert_same \"0b0\"\n assert_same \"0b1\"\n assert_same \"0b101\"\n assert_same \"0b01\"\n assert_same \"0b111_111\"\n end\n\n test \"in octal base\" do\n assert_same \"0o77\"\n assert_same \"0o0\"\n assert_same \"0o01\"\n assert_same \"0o777_777\"\n end\n\n test \"in hex base\" do\n assert_same \"0x1\"\n assert_same \"0x01\"\n end\n\n test \"as chars\" do\n assert_same \"?a\"\n assert_same \"?1\"\n assert_same \"?è\"\n assert_same \"??\"\n assert_same \"?\\\\\\\\\"\n assert_same \"?\\\\s\"\n assert_same \"?🎾\"\n end\n end\n\n describe \"floats\" do\n test \"with normal notation\" do\n assert_same \"0.0\"\n assert_same \"1.0\"\n assert_same \"123.456\"\n assert_same \"0.0000001\"\n assert_same \"001.100\"\n assert_same \"0_10000_0.000_000\"\n end\n\n test \"with scientific notation\" do\n assert_same \"1.0e1\"\n assert_same \"1.0e-1\"\n assert_same \"1.0e01\"\n assert_same \"1.0e-01\"\n assert_same \"001.100e-010\"\n assert_same \"0_100_0000.100e-010\"\n end\n end\n\n describe \"atoms\" do\n test \"true, false, nil\" do\n assert_same \"nil\"\n assert_same \"true\"\n assert_same \"false\"\n end\n\n test \"without escapes\" do\n assert_same ~S[:foo]\n end\n\n test \"with escapes\" do\n assert_same ~S[:\"f\\a\\b\\ro\"]\n end\n\n test \"with unicode\" do\n assert_same ~S[:ólá]\n end\n\n test \"does not reformat aliases\" do\n assert_same ~S[:\"Elixir.String\"]\n assert_same ~S[:\"Elixir\"]\n end\n\n test \"quoted operators\" do\n assert_same ~S[:\"::\"]\n assert_same ~S[:\"..//\"]\n assert_same ~S{[\"..//\": 1]}\n end\n\n test \"with interpolation\" do\n assert_same ~S[:\"one #{2} three\"]\n end\n\n test \"with escapes and interpolation\" do\n assert_same ~S[:\"one\\n\\\"#{2}\\\"\\nthree\"]\n end\n end\n\n describe \"strings\" do\n test \"without escapes\" do\n assert_same ~S[\"foo\"]\n end\n\n test \"with escapes\" do\n assert_same ~S[\"\\x0A\"]\n assert_same ~S[\"f\\a\\b\\ro\"]\n assert_same ~S[\"double \\\" quote\"]\n end\n\n test \"keeps literal new lines\" do\n assert_same \"\"\"\n \"fo\n o\"\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S[\"one #{} three\"]\n assert_same ~S[\"one #{2} three\"]\n end\n\n test \"with escaped interpolation\" do\n assert_same ~S[\"one\\#{two}three\"]\n end\n\n test \"with escapes and interpolation\" do\n assert_same ~S[\"one\\n\\\"#{2}\\\"\\nthree\"]\n end\n end\n\n describe \"lists\" do\n test \"on module attribute\" do\n assert_same ~S\"@foo [1]\"\n end\n end\n\n describe \"charlists\" do\n test \"without escapes\" do\n assert_same ~S[~c\"\"]\n assert_same ~S[~c\" \"]\n assert_same ~S[~c\"foo\"]\n end\n\n test \"with escapes\" do\n assert_same ~S[~c\"f\\a\\b\\ro\"]\n assert_same ~S[~c'single \\' quote']\n assert_same ~S[~c\"double \\\" quote\"]\n end\n\n test \"keeps literal new lines\" do\n assert_same \"\"\"\n ~c\"fo\n o\"\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S[~c\"one #{2} three\"]\n end\n\n test \"with escape and interpolation\" do\n assert_same ~S[~c'one\\n\\'#{2}\\'\\nthree']\n end\n end\n\n describe \"string heredocs\" do\n test \"without escapes\" do\n assert_same ~S'''\n \"\"\"\n hello\n \"\"\"\n '''\n end\n\n test \"with escapes\" do\n assert_same ~S'''\n \"\"\"\n f\\a\\b\\ro\n \"\"\"\n '''\n\n assert_same ~S'''\n \"\"\"\n multiple \"\\\"\" quotes\n \"\"\"\n '''\n end\n\n test \"with interpolation\" do\n assert_same ~S'''\n \"\"\"\n one\n #{2}\n three\n \"\"\"\n '''\n\n assert_same ~S'''\n \"\"\"\n one\n \"\n #{2}\n \"\n three\n \"\"\"\n '''\n end\n\n test \"nested with empty lines\" do\n assert_same ~S'''\n nested do\n \"\"\"\n\n foo\n\n\n bar\n\n \"\"\"\n end\n '''\n end\n\n test \"nested with empty lines and interpolation\" do\n assert_same ~S'''\n nested do\n \"\"\"\n\n #{foo}\n\n\n #{bar}\n\n \"\"\"\n end\n '''\n\n assert_same ~S'''\n nested do\n \"\"\"\n #{foo}\n\n\n #{bar}\n \"\"\"\n end\n '''\n end\n\n test \"with escaped new lines\" do\n assert_same ~S'''\n \"\"\"\n one\\\n #{\"two\"}\\\n three\\\n \"\"\"\n '''\n end\n end\n\n describe \"charlist heredocs\" do\n test \"without escapes\" do\n assert_same ~S\"\"\"\n ~c'''\n hello\n '''\n \"\"\"\n end\n\n test \"with escapes\" do\n assert_same ~S\"\"\"\n ~c'''\n f\\a\\b\\ro\n '''\n \"\"\"\n\n assert_same ~S\"\"\"\n ~c'''\n multiple \"\\\"\" quotes\n '''\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S\"\"\"\n ~c'''\n one\n #{2}\n three\n '''\n \"\"\"\n\n assert_same ~S\"\"\"\n ~c'''\n one\n \"\n #{2}\n \"\n three\n '''\n \"\"\"\n end\n end\n\n describe \"keyword list\" do\n test \"blocks\" do\n assert_same ~S\"\"\"\n defmodule Example do\n def sample, do: :ok\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n with true, do: :ok, else: (_ -> :ok)\n \"\"\"\n end\n\n test \"omitting brackets\" do\n assert_same ~S\"\"\"\n @type foo :: a when b: :c\n \"\"\"\n end\n\n test \"last tuple element as keyword list keeps its format\" do\n assert_same ~S\"{:wrapped, [opt1: true, opt2: false]}\"\n assert_same ~S\"{:unwrapped, opt1: true, opt2: false}\"\n assert_same ~S\"{:wrapped, 1, [opt1: true, opt2: false]}\"\n assert_same ~S\"{:unwrapped, 1, opt1: true, opt2: false}\"\n end\n\n test \"on module attribute\" do\n assert_same ~S\"\"\"\n @foo a: b,\n c: d\n \"\"\"\n\n assert_same ~S\"@foo [\n a: b,\n c: d\n ]\"\n end\n end\n\n describe \"preserves user choice on parenthesis\" do\n test \"in functions with do blocks\" do\n assert_same(~S\"\"\"\n foo Bar do\n :ok\n end\n \"\"\")\n\n assert_same(~S\"\"\"\n foo(Bar) do\n :ok\n end\n \"\"\")\n end\n end\n\n describe \"preserves formatting for sigils\" do\n test \"without interpolation\" do\n assert_same ~S[~s(foo)]\n assert_same ~S[~s{foo bar}]\n assert_same ~S[~r/Bar Baz/]\n assert_same ~S[~w<>]\n assert_same ~S[~W()]\n end\n\n test \"with escapes\" do\n assert_same ~S[~s(foo \\) bar)]\n assert_same ~S[~s(f\\a\\b\\ro)]\n\n assert_same ~S\"\"\"\n ~S(foo\\\n bar)\n \"\"\"\n end\n\n test \"with nested new lines\" do\n assert_same ~S\"\"\"\n foo do\n ~S(foo\\\n bar)\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n foo do\n ~s(#{bar}\n )\n end\n \"\"\"\n end\n\n test \"with interpolation\" do\n assert_same ~S[~s(one #{2} three)]\n end\n\n test \"with modifiers\" do\n assert_same ~S[~w(one two three)a]\n assert_same ~S[~z(one two three)foo]\n end\n\n test \"with heredoc syntax\" do\n assert_same ~S\"\"\"\n ~s'''\n one\\a\n #{:two}\\r\n three\\0\n '''\n \"\"\"\n\n assert_same ~S'''\n ~s\"\"\"\n one\\a\n #{:two}\\r\n three\\0\n \"\"\"\n '''\n end\n\n test \"with heredoc syntax and modifier\" do\n assert_same ~S\"\"\"\n ~s'''\n foo\n '''rsa\n \"\"\"\n end\n end\n\n describe \"preserves comments formatting\" do\n test \"before and after expressions\" do\n assert_same \"\"\"\n # before comment\n :hello\n \"\"\"\n\n assert_same \"\"\"\n :hello\n # after comment\n \"\"\"\n\n assert_same \"\"\"\n # before comment\n :hello\n # after comment\n \"\"\"\n end\n\n test \"empty comment\" do\n assert_same \"\"\"\n #\n :foo\n \"\"\"\n end\n\n test \"handles comments with unescaped literal\" do\n assert_same \"\"\"\n # before\n Mix.install([:foo])\n # after\n \"\"\",\n literal_encoder: fn literal, _ -> {:ok, literal} end\n\n assert_same \"\"\"\n # before\n Mix.install([1 + 2, :foo])\n # after\n \"\"\",\n literal_encoder: fn literal, _ -> {:ok, literal} end\n\n assert_same \"\"\"\n # before\n Mix.install([:foo, 1 + 2])\n # after\n \"\"\",\n literal_encoder: fn literal, _ -> {:ok, literal} end\n\n assert_same \"\"\"\n block do\n # before 1\n 1 + 1\n\n # before 2\n 2 + 2\n end\n \"\"\",\n literal_encoder: fn literal, _ -> {:ok, literal} end\n\n assert_same \"\"\"\n block do\n # before 1\n Mix.install([1 + 1])\n\n # before 2\n Mix.install([2 + 2])\n end\n \"\"\",\n literal_encoder: fn literal, _ -> {:ok, literal} end\n end\n\n test \"before and after expressions with newlines\" do\n assert_same \"\"\"\n # before comment\n # second line\n\n :hello\n\n # middle comment 1\n\n #\n\n # middle comment 2\n\n :world\n\n # after comment\n # second line\n \"\"\"\n end\n\n test \"interpolation with comment outside before and after\" do\n assert_same ~S\"\"\"\n # comment\n IO.puts(\"Hello #{world}\")\n \"\"\"\n\n assert_same ~S\"\"\"\n IO.puts(\"Hello #{world}\")\n # comment\n \"\"\"\n end\n\n test \"blocks with keyword list\" do\n assert_same ~S\"\"\"\n defp sample do\n [\n # comment\n {:a, \"~> 1.2\"}\n ]\n end\n \"\"\"\n\n assert_same ~S\"\"\"\n defp sample do\n [\n # comment\n {:a, \"~> 1.2\"},\n {:b, \"~> 1.2\"}\n ]\n end\n \"\"\"\n end\n\n test \"keyword literals with variable values\" do\n assert_same(~S\"\"\"\n foo = foo()\n [foo: foo]\n \"\"\")\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_normalizer/quoted_ast_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Code.Normalizer.QuotedASTTest do\n use ExUnit.Case, async: true\n\n describe \"quoted_to_algebra/2\" do\n test \"variable\" do\n assert quoted_to_string(quote(do: foo)) == \"foo\"\n assert quoted_to_string({:{}, [], nil}) == \"{}\"\n end\n\n test \"variable with colors\" do\n opts = [syntax_colors: [variable: :blue]]\n assert quoted_to_string(quote(do: foo), opts) == \"\\e[34mfoo\\e[0m\"\n end\n\n test \"local call\" do\n assert quoted_to_string(quote(do: foo(1, 2, 3))) == \"foo(1, 2, 3)\"\n assert quoted_to_string(quote(do: foo([1, 2, 3]))) == \"foo([1, 2, 3])\"\n\n assert quoted_to_string(quote(do: foo(1, 2, 3)), locals_without_parens: [foo: 3]) ==\n \"foo 1, 2, 3\"\n\n # Mixing literals and non-literals\n assert quoted_to_string(quote(do: foo(a, 2))) == \"foo(a, 2)\"\n assert quoted_to_string(quote(do: foo(1, b))) == \"foo(1, b)\"\n\n # Mixing literals and non-literals with line\n assert quoted_to_string(quote(line: __ENV__.line, do: foo(a, 2))) == \"foo(a, 2)\"\n assert quoted_to_string(quote(line: __ENV__.line, do: foo(1, b))) == \"foo(1, b)\"\n end\n\n test \"local call with colors\" do\n opts = [syntax_colors: [call: :blue, number: :yellow, variable: :red]]\n\n assert quoted_to_string(quote(do: foo(1, a)), opts) ==\n \"\\e[34mfoo\\e[0m(\\e[33m1\\e[0m, \\e[31ma\\e[0m)\"\n end\n\n test \"local call no parens\" do\n assert quoted_to_string({:def, [], [1, 2]}) == \"def 1, 2\"\n assert quoted_to_string({:def, [closing: []], [1, 2]}) == \"def(1, 2)\"\n end\n\n test \"remote call\" do\n assert quoted_to_string(quote(do: foo.bar(1, 2, 3))) == \"foo.bar(1, 2, 3)\"\n assert quoted_to_string(quote(do: foo.bar([1, 2, 3]))) == \"foo.bar([1, 2, 3])\"\n\n quoted =\n quote do\n (foo do\n :ok\n end).bar([1, 2, 3])\n end\n\n assert quoted_to_string(quoted) == \"(foo do\\n :ok\\n end).bar([1, 2, 3])\"\n end\n\n test \"nullary remote call\" do\n assert quoted_to_string(quote do: foo.bar) == \"foo.bar\"\n assert quoted_to_string(quote do: foo.bar()) == \"foo.bar()\"\n end\n\n test \"atom remote call\" do\n assert quoted_to_string(quote(do: :foo.bar(1, 2, 3))) == \":foo.bar(1, 2, 3)\"\n end\n\n test \"remote and fun call\" do\n assert quoted_to_string(quote(do: foo.bar().(1, 2, 3))) == \"foo.bar().(1, 2, 3)\"\n assert quoted_to_string(quote(do: foo.bar().([1, 2, 3]))) == \"foo.bar().([1, 2, 3])\"\n end\n\n test \"unusual remote atom fun call\" do\n assert quoted_to_string(quote(do: Foo.\"42\"())) == ~s/Foo.\"42\"()/\n assert quoted_to_string(quote(do: Foo.\"Bar\"())) == ~s/Foo.\"Bar\"()/\n assert quoted_to_string(quote(do: Foo.\"bar baz\"().\"\"())) == ~s/Foo.\"bar baz\"().\"\"()/\n assert quoted_to_string(quote(do: Foo.\"%{}\"())) == ~s/Foo.\"%{}\"()/\n assert quoted_to_string(quote(do: Foo.\"...\"())) == ~s/Foo.\"...\"()/\n end\n\n test \"atom fun call\" do\n assert quoted_to_string(quote(do: :foo.(1, 2, 3))) == \":foo.(1, 2, 3)\"\n end\n\n test \"aliases call\" do\n assert quoted_to_string(quote(do: Foo.Bar.baz(1, 2, 3))) == \"Foo.Bar.baz(1, 2, 3)\"\n assert quoted_to_string(quote(do: Foo.Bar.baz([1, 2, 3]))) == \"Foo.Bar.baz([1, 2, 3])\"\n assert quoted_to_string(quote(do: ?0.Bar.baz([1, 2, 3]))) == \"48.Bar.baz([1, 2, 3])\"\n assert quoted_to_string(quote(do: Foo.bar(<<>>, []))) == \"Foo.bar(<<>>, [])\"\n end\n\n test \"remote call with colors\" do\n opts = [syntax_colors: [call: :blue, number: :yellow, variable: :red, atom: :green]]\n\n assert quoted_to_string(quote(do: foo.bar(1, 2)), opts) ==\n \"\\e[31mfoo\\e[0m.\\e[34mbar\\e[0m(\\e[33m1\\e[0m, \\e[33m2\\e[0m)\"\n\n assert quoted_to_string(quote(do: :foo.bar(1, 2)), opts) ==\n \"\\e[32m:foo\\e[0m.\\e[34mbar\\e[0m(\\e[33m1\\e[0m, \\e[33m2\\e[0m)\"\n\n assert quoted_to_string(quote(do: Foo.Bar.bar(1, 2)), opts) ==\n \"\\e[32mFoo.Bar\\e[0m.\\e[34mbar\\e[0m(\\e[33m1\\e[0m, \\e[33m2\\e[0m)\"\n end\n\n test \"keyword call\" do\n assert quoted_to_string(quote(do: Foo.bar(foo: :bar))) == \"Foo.bar(foo: :bar)\"\n assert quoted_to_string(quote(do: Foo.bar(\"Elixir.Foo\": :bar))) == \"Foo.bar([{Foo, :bar}])\"\n end\n\n test \"sigil call\" do\n assert quoted_to_string(quote(do: ~r\"123\")) == ~S/~r\"123\"/\n assert quoted_to_string(quote(do: ~r\"\\n123\")) == ~S/~r\"\\n123\"/\n assert quoted_to_string(quote(do: ~r\"12\\\"3\")) == ~S/~r\"12\\\"3\"/\n assert quoted_to_string(quote(do: ~r/12\\/3/u)) == ~S\"~r/12\\/3/u\"\n assert quoted_to_string(quote(do: ~r{\\n123})) == ~S/~r{\\n123}/\n assert quoted_to_string(quote(do: ~r((1\\)(2\\)3))) == ~S/~r((1\\)(2\\)3)/\n assert quoted_to_string(quote(do: ~r{\\n1{1\\}23})) == ~S/~r{\\n1{1\\}23}/\n assert quoted_to_string(quote(do: ~r|12\\|3|)) == ~S\"~r|12\\|3|\"\n\n assert quoted_to_string(quote(do: ~r[1#{two}3])) == ~S/~r[1#{two}3]/\n assert quoted_to_string(quote(do: ~r|1[#{two}]3|)) == ~S/~r|1[#{two}]3|/\n assert quoted_to_string(quote(do: ~r'1#{two}3'u)) == ~S/~r'1#{two}3'u/\n\n assert quoted_to_string(quote(do: ~R\"123\")) == ~S/~R\"123\"/\n assert quoted_to_string(quote(do: ~R\"123\"u)) == ~S/~R\"123\"u/\n assert quoted_to_string(quote(do: ~R\"\\n123\")) == ~S/~R\"\\n123\"/\n\n assert quoted_to_string(quote(do: ~S[\"'(123)'\"])) == ~S/~S[\"'(123)'\"]/\n assert quoted_to_string(quote(do: ~s\"#{\"foo\"}\")) == ~S/~s\"#{\"foo\"}\"/\n\n assert quoted_to_string(quote(do: ~S[\"'(123)'\"]) |> strip_metadata()) == ~S/~S\"\\\"'(123)'\\\"\"/\n assert quoted_to_string(quote(do: ~s\"#{\"foo\"}\") |> strip_metadata()) == ~S/~s\"#{\"foo\"}\"/\n\n assert quoted_to_string(\n quote do\n ~s\"\"\"\n \"\\\"\"foo\"\\\"\"\n \"\"\"\n end\n ) == ~s[~s\"\"\"\\n\"\\\\\"\"foo\"\\\\\"\"\\n\"\"\"]\n\n assert quoted_to_string(\n quote do\n ~s'''\n '\\''foo'\\''\n '''\n end\n ) == ~s[~s'''\\n'\\\\''foo'\\\\''\\n''']\n\n assert quoted_to_string(\n quote do\n ~s\"\"\"\n \"\\\"foo\\\"\"\n \"\"\"\n end\n ) == ~s[~s\"\"\"\\n\"\\\\\"foo\\\\\"\"\\n\"\"\"]\n\n assert quoted_to_string(\n quote do\n ~s'''\n '\\\"foo\\\"'\n '''\n end\n ) == ~s[~s'''\\n'\\\\\"foo\\\\\"'\\n''']\n\n assert quoted_to_string(\n quote do\n ~S\"\"\"\n \"123\"\n \"\"\"\n end\n ) == ~s[~S\"\"\"\\n\"123\"\\n\"\"\"]\n end\n\n test \"regression: invalid sigil calls\" do\n assert quoted_to_string(quote do: sigil_r(<<\"foo\", 123>>, [])) ==\n \"sigil_r(<<\\\"foo\\\", 123>>, [])\"\n\n assert quoted_to_string(quote do: sigil_r(<<\"foo\">>, :invalid_modifiers)) ==\n \"sigil_r(\\\"foo\\\", :invalid_modifiers)\"\n\n assert quoted_to_string(quote do: sigil_r(<<\"foo\">>, [:invalid_modifier])) ==\n \"sigil_r(\\\"foo\\\", [:invalid_modifier])\"\n\n assert quoted_to_string(quote do: sigil_r(<<\"foo\">>, [])) == \"~r\\\"foo\\\"\"\n assert quoted_to_string(quote do: sigil_r(<<\"foo\">>, [?a, ?b, ?c])) == \"~r\\\"foo\\\"abc\"\n end\n\n test \"tuple\" do\n assert quoted_to_string(quote do: {1, 2}) == \"{1, 2}\"\n assert quoted_to_string(quote do: {1}) == \"{1}\"\n assert quoted_to_string(quote do: {1, 2, 3}) == \"{1, 2, 3}\"\n assert quoted_to_string(quote do: {1, 2, 3, foo: :bar}) == \"{1, 2, 3, foo: :bar}\"\n end\n\n test \"tuple with colors\" do\n opts = [syntax_colors: [tuple: :blue, number: :yellow]]\n\n assert quoted_to_string(quote(do: {1, 2, 3}), opts) ==\n \"\\e[34m{\\e[0m\\e[33m1\\e[0m, \\e[33m2\\e[0m, \\e[33m3\\e[0m\\e[34m}\\e[0m\"\n end\n\n test \"tuple call\" do\n assert quoted_to_string(quote(do: alias(Foo.{Bar, Baz, Bong}))) ==\n \"alias Foo.{Bar, Baz, Bong}\"\n\n assert quoted_to_string(quote(do: foo(Foo.{}))) == \"foo(Foo.{})\"\n end\n\n test \"arrow\" do\n assert quoted_to_string(quote(do: foo(1, (2 -> 3)))) == \"foo(1, (2 -> 3))\"\n end\n\n test \"block\" do\n quoted =\n quote do\n 1\n 2\n\n (\n :foo\n :bar\n )\n\n 3\n end\n\n expected = \"\"\"\n 1\n 2\n\n (\n :foo\n :bar\n )\n\n 3\n \"\"\"\n\n assert quoted_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"not in\" do\n assert quoted_to_string(quote(do: false not in [])) == \"false not in []\"\n end\n\n test \"if else\" do\n expected = \"\"\"\n if foo do\n bar\n else\n baz\n end\n \"\"\"\n\n assert quoted_to_string(quote(do: if(foo, do: bar, else: baz))) <> \"\\n\" == expected\n end\n\n test \"case\" do\n quoted =\n quote do\n case foo do\n true ->\n 0\n\n false ->\n 1\n 2\n end\n end\n\n expected = \"\"\"\n case foo do\n true ->\n 0\n\n false ->\n 1\n 2\n end\n \"\"\"\n\n assert quoted_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"case if else\" do\n expected = \"\"\"\n case (if foo do\n bar\n else\n baz\n end) do\n end\n \"\"\"\n\n assert quoted_to_string(\n quote(\n do:\n case if(foo, do: bar, else: baz) do\n end\n )\n ) <> \"\\n\" == expected\n end\n\n test \"try\" do\n quoted =\n quote do\n try do\n foo\n catch\n _, _ ->\n 2\n rescue\n ArgumentError ->\n 1\n after\n 4\n else\n _ ->\n 3\n end\n end\n\n expected = \"\"\"\n try do\n foo\n catch\n _, _ -> 2\n rescue\n ArgumentError -> 1\n after\n 4\n else\n _ -> 3\n end\n \"\"\"\n\n assert quoted_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"fn\" do\n assert quoted_to_string(quote(do: fn -> 1 + 2 end)) == \"fn -> 1 + 2 end\"\n assert quoted_to_string(quote(do: fn x -> x + 1 end)) == \"fn x -> x + 1 end\"\n\n quoted =\n quote do\n fn x ->\n y = x + 1\n y\n end\n end\n\n expected = \"\"\"\n fn x ->\n y = x + 1\n y\n end\n \"\"\"\n\n assert quoted_to_string(quoted) <> \"\\n\" == expected\n\n quoted =\n quote do\n fn\n x ->\n y = x + 1\n y\n\n z ->\n z\n end\n end\n\n expected = \"\"\"\n fn\n x ->\n y = x + 1\n y\n\n z ->\n z\n end\n \"\"\"\n\n assert quoted_to_string(quoted) <> \"\\n\" == expected\n\n assert quoted_to_string(quote(do: (fn x -> x end).(1))) == \"(fn x -> x end).(1)\"\n\n quoted =\n quote do\n (fn\n %{} -> :map\n _ -> :other\n end).(1)\n end\n\n expected = \"\"\"\n (fn\n %{} -> :map\n _ -> :other\n end).(1)\n \"\"\"\n\n assert quoted_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"range\" do\n assert quoted_to_string(quote(do: -1..+2)) == \"-1..+2\"\n assert quoted_to_string(quote(do: Foo.integer()..3)) == \"Foo.integer()..3\"\n assert quoted_to_string(quote(do: -1..+2//-3)) == \"-1..+2//-3\"\n\n assert quoted_to_string(quote(do: Foo.integer()..3//Bar.bat())) ==\n \"Foo.integer()..3//Bar.bat()\"\n\n # invalid AST\n assert quoted_to_string(-1..+2) == \"-1..2\"\n assert quoted_to_string(-1..+2//-3) == \"-1..2//-3\"\n end\n\n test \"when\" do\n assert quoted_to_string(quote(do: (-> x))) == \"(-> x)\"\n assert quoted_to_string(quote(do: (x when y -> z))) == \"(x when y -> z)\"\n assert quoted_to_string(quote(do: (x, y when z -> w))) == \"(x, y when z -> w)\"\n assert quoted_to_string(quote(do: (x, y when z -> w))) == \"(x, y when z -> w)\"\n assert quoted_to_string(quote(do: (x, y when z -> w))) == \"(x, y when z -> w)\"\n assert quoted_to_string(quote(do: (x when y: z))) == \"x when y: z\"\n assert quoted_to_string(quote(do: (x when y: z, z: w))) == \"x when y: z, z: w\"\n end\n\n test \"nested\" do\n quoted =\n quote do\n defmodule Foo do\n def foo do\n 1 + 1\n end\n end\n end\n\n expected = \"\"\"\n defmodule Foo do\n def foo do\n 1 + 1\n end\n end\n \"\"\"\n\n assert quoted_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"operator precedence\" do\n assert quoted_to_string(quote(do: (1 + 2) * (3 - 4))) == \"(1 + 2) * (3 - 4)\"\n assert quoted_to_string(quote(do: (1 + 2) * 3 - 4)) == \"(1 + 2) * 3 - 4\"\n assert quoted_to_string(quote(do: 1 + 2 + 3)) == \"1 + 2 + 3\"\n assert quoted_to_string(quote(do: 1 + 2 - 3)) == \"1 + 2 - 3\"\n end\n\n test \"capture operator\" do\n assert quoted_to_string(quote(do: &foo/0)) == \"&foo/0\"\n assert quoted_to_string(quote(do: &Foo.foo/0)) == \"&Foo.foo/0\"\n assert quoted_to_string(quote(do: &(&1 + &2))) == \"&(&1 + &2)\"\n assert quoted_to_string(quote(do: & &1)) == \"& &1\"\n assert quoted_to_string(quote(do: & &1.(:x))) == \"& &1.(:x)\"\n assert quoted_to_string(quote(do: (& &1).(:x))) == \"(& &1).(:x)\"\n end\n\n test \"operators\" do\n assert quoted_to_string(quote(do: foo |> {1, 2})) == \"foo |> {1, 2}\"\n assert quoted_to_string(quote(do: foo |> {:map, arg})) == \"foo |> {:map, arg}\"\n end\n\n test \"containers\" do\n assert quoted_to_string(quote(do: {})) == \"{}\"\n assert quoted_to_string(quote(do: [])) == \"[]\"\n assert quoted_to_string(quote(do: {1, 2, 3})) == \"{1, 2, 3}\"\n assert quoted_to_string(quote(do: [1, 2, 3])) == \"[1, 2, 3]\"\n assert quoted_to_string(quote(do: [\"Elixir.Foo\": :bar])) == \"[{Foo, :bar}]\"\n assert quoted_to_string(quote(do: %{})) == \"%{}\"\n assert quoted_to_string(quote(do: %{:foo => :bar})) == \"%{foo: :bar}\"\n assert quoted_to_string(quote(do: %{:\"Elixir.Foo\" => :bar})) == \"%{Foo => :bar}\"\n assert quoted_to_string(quote(do: %{{1, 2} => [1, 2, 3]})) == \"%{{1, 2} => [1, 2, 3]}\"\n assert quoted_to_string(quote(do: %{map | \"a\" => \"b\"})) == \"%{map | \\\"a\\\" => \\\"b\\\"}\"\n assert quoted_to_string(quote(do: [1, 2, 3])) == \"[1, 2, 3]\"\n end\n\n test \"false positive containers\" do\n assert quoted_to_string({:%{}, [], nil}) == \"%{}\"\n end\n\n test \"struct\" do\n assert quoted_to_string(quote(do: %Test{})) == \"%Test{}\"\n assert quoted_to_string(quote(do: %Test{foo: 1, bar: 1})) == \"%Test{foo: 1, bar: 1}\"\n assert quoted_to_string(quote(do: %Test{struct | foo: 2})) == \"%Test{struct | foo: 2}\"\n assert quoted_to_string(quote(do: %Test{} + 1)) == \"%Test{} + 1\"\n assert quoted_to_string(quote(do: %Test{foo(1)} + 2)) == \"%Test{foo(1)} + 2\"\n end\n\n test \"binary operators\" do\n assert quoted_to_string(quote(do: 1 + 2)) == \"1 + 2\"\n assert quoted_to_string(quote(do: [1, 2 | 3])) == \"[1, 2 | 3]\"\n assert quoted_to_string(quote(do: [h | t] = [1, 2, 3])) == \"[h | t] = [1, 2, 3]\"\n assert quoted_to_string(quote(do: (x ++ y) ++ z)) == \"(x ++ y) ++ z\"\n assert quoted_to_string(quote(do: (x +++ y) +++ z)) == \"(x +++ y) +++ z\"\n end\n\n test \"unary operators\" do\n assert quoted_to_string(quote(do: not 1)) == \"not 1\"\n assert quoted_to_string(quote(do: not foo)) == \"not foo\"\n assert quoted_to_string(quote(do: -1)) == \"-1\"\n assert quoted_to_string(quote(do: +(+1))) == \"+(+1)\"\n assert quoted_to_string(quote(do: !(foo > bar))) == \"!(foo > bar)\"\n assert quoted_to_string(quote(do: @foo(bar))) == \"@foo bar\"\n assert quoted_to_string(quote(do: identity(&1))) == \"identity(&1)\"\n end\n\n test \"operators with colors\" do\n opts = [syntax_colors: [operator: :blue, number: :yellow]]\n assert quoted_to_string(quote(do: !!1), opts) == \"\\e[34m!\\e[0m\\e[34m!\\e[0m\\e[33m1\\e[0m\"\n assert quoted_to_string(quote(do: 1 + 2), opts) == \"\\e[33m1\\e[0m\\e[34m +\\e[0m \\e[33m2\\e[0m\"\n end\n\n test \"access\" do\n assert quoted_to_string(quote(do: a[b])) == \"a[b]\"\n assert quoted_to_string(quote(do: a[1 + 2])) == \"a[1 + 2]\"\n assert quoted_to_string(quote(do: (a || [a: 1])[:a])) == \"(a || [a: 1])[:a]\"\n assert quoted_to_string(quote(do: Map.put(%{}, :a, 1)[:a])) == \"Map.put(%{}, :a, 1)[:a]\"\n end\n\n test \"keyword list\" do\n assert quoted_to_string(quote(do: [a: a, b: b])) == \"[a: a, b: b]\"\n assert quoted_to_string(quote(do: [a: 1, b: 1 + 2])) == \"[a: 1, b: 1 + 2]\"\n assert quoted_to_string(quote(do: [\"a.b\": 1, c: 1 + 2])) == \"[\\\"a.b\\\": 1, c: 1 + 2]\"\n\n tuple = {{:__block__, [format: :keyword], [:a]}, {:b, [], nil}}\n assert quoted_to_string([tuple, :foo, tuple]) == \"[{:a, b}, :foo, a: b]\"\n assert quoted_to_string([tuple, :foo, {:c, :d}, tuple]) == \"[{:a, b}, :foo, c: :d, a: b]\"\n\n # Not keyword lists\n assert quoted_to_string(quote(do: [{binary(), integer()}])) == \"[{binary(), integer()}]\"\n end\n\n test \"keyword list with colors\" do\n opts = [syntax_colors: [list: :blue, atom: :green, number: :yellow]]\n\n assert quoted_to_string(quote(do: [a: 1, b: 2]), opts) ==\n \"\\e[34m[\\e[0m\\e[32ma:\\e[0m \\e[33m1\\e[0m, \\e[32mb:\\e[0m \\e[33m2\\e[0m\\e[34m]\\e[0m\"\n end\n\n test \"keyword list with :do as operand\" do\n assert quoted_to_string(quote(do: a = [do: 1])) == \"a = [do: 1]\"\n end\n\n test \"interpolation\" do\n assert quoted_to_string(quote(do: \"foo#{bar}baz\")) == ~S[\"foo#{bar}baz\"]\n end\n\n test \"bit syntax\" do\n ast = quote(do: <<1::8*4>>)\n assert quoted_to_string(ast) == \"<<1::8*4>>\"\n\n ast = quote(do: @type(foo :: <<_::8, _::_*4>>))\n assert quoted_to_string(ast) == \"@type foo :: <<_::8, _::_*4>>\"\n\n ast = quote(do: <<69 - 4::bits-size(8 - 4)-unit(1), 65>>)\n assert quoted_to_string(ast) == \"<<69 - 4::bits-size(8 - 4)-unit(1), 65>>\"\n\n ast = quote(do: <<(<<65>>), 65>>)\n assert quoted_to_string(ast) == \"<<(<<65>>), 65>>\"\n\n ast = quote(do: <<65, (<<65>>)>>)\n assert quoted_to_string(ast) == \"<<65, (<<65>>)>>\"\n\n ast = quote(do: for(<<(a::4 <- <<1, 2>>)>>, do: a))\n assert quoted_to_string(ast) == \"for <<(a::4 <- <<1, 2>>)>> do\\n a\\nend\"\n end\n\n test \"integer/float\" do\n assert quoted_to_string(1) == \"1\"\n assert quoted_to_string({:__block__, [], [1]}) == \"1\"\n assert quoted_to_string(1.23) == \"1.23\"\n end\n\n test \"integer/float with colors\" do\n opts = [syntax_colors: [number: :yellow]]\n assert quoted_to_string(1, opts) == \"\\e[33m1\\e[0m\"\n assert quoted_to_string(1.23, opts) == \"\\e[33m1.23\\e[0m\"\n end\n\n test \"charlist\" do\n assert quoted_to_string(quote(do: [])) == \"[]\"\n assert quoted_to_string(quote(do: ~c\"abc\")) == ~S/~c\"abc\"/\n\n # False positive\n assert quoted_to_string(\n quote do\n :\"Elixir.List\".to_charlist([\n case var do\n var -> var\n end\n ])\n end\n ) =~ \"List.to_charlist([\\n case var do\\n var -> var\\n end\\n])\"\n end\n\n test \"string\" do\n assert quoted_to_string(quote(do: \"\")) == ~S/\"\"/\n assert quoted_to_string(quote(do: \"abc\")) == ~S/\"abc\"/\n assert quoted_to_string(quote(do: \"#{\"abc\"}\")) == ~S/\"#{\"abc\"}\"/\n end\n\n test \"string with colors\" do\n opts = [syntax_colors: [string: :green]]\n assert quoted_to_string(quote(do: \"abc\"), opts) == \"\\e[32m\\\"abc\\\"\\e[0m\"\n end\n\n test \"catch-all\" do\n assert quoted_to_string(quote do: {unquote(self())}) == \"{#{inspect(self())}}\"\n assert quoted_to_string(quote do: foo(unquote(self()))) == \"foo(#{inspect(self())})\"\n end\n\n test \"last arg keyword list\" do\n assert quoted_to_string(quote(do: foo([]))) == \"foo([])\"\n assert quoted_to_string(quote(do: foo(x: y))) == \"foo(x: y)\"\n assert quoted_to_string(quote(do: foo(x: 1 + 2))) == \"foo(x: 1 + 2)\"\n assert quoted_to_string(quote(do: foo(x: y, p: q))) == \"foo(x: y, p: q)\"\n assert quoted_to_string(quote(do: foo(a, x: y, p: q))) == \"foo(a, x: y, p: q)\"\n\n assert quoted_to_string(quote(do: {[]})) == \"{[]}\"\n assert quoted_to_string(quote(do: {[a: b]})) == \"{[a: b]}\"\n assert quoted_to_string(quote(do: {x, a: b})) == \"{x, a: b}\"\n assert quoted_to_string(quote(do: foo(else: a))) == \"foo(else: a)\"\n assert quoted_to_string(quote(do: foo(catch: a))) == \"foo(catch: a)\"\n assert quoted_to_string(quote(do: foo |> [bar: :baz])) == \"foo |> [bar: :baz]\"\n end\n\n test \"keyword arg with cursor\" do\n input = \"def foo, do: :bar, __cursor__()\"\n expected = \"def foo, [{:do, :bar}, __cursor__()]\"\n\n ast = Code.string_to_quoted!(input)\n assert quoted_to_string(ast) == expected\n\n encoder = &{:ok, {:__block__, &2, [&1]}}\n ast = Code.string_to_quoted!(input, literal_encoder: encoder)\n assert quoted_to_string(ast) == expected\n\n ast = Code.string_to_quoted!(input, token_metadata: true)\n assert quoted_to_string(ast) == expected\n\n ast = Code.string_to_quoted!(input, literal_encoder: encoder, token_metadata: true)\n assert quoted_to_string(ast) == expected\n end\n\n test \"keyword arg with literal encoder and no metadata\" do\n input = \"\"\"\n foo(Bar) do\n :ok\n end\n \"\"\"\n\n encoder = &{:ok, {:__block__, &2, [&1]}}\n ast = Code.string_to_quoted!(input, literal_encoder: encoder)\n assert quoted_to_string(ast) == \"foo(Bar, do: :ok)\"\n end\n\n test \"list in module attribute\" do\n assert quoted_to_string(\n quote do\n @foo []\n end\n ) == \"@foo []\"\n\n assert quoted_to_string(\n quote do\n @foo [1]\n end\n ) == \"@foo [1]\"\n\n assert quoted_to_string(\n quote do\n @foo [foo: :bar]\n end\n ) == \"@foo foo: :bar\"\n\n assert quoted_to_string(\n quote do\n @foo [1, foo: :bar]\n end\n ) == \"@foo [1, foo: :bar]\"\n end\n end\n\n describe \"quoted_to_algebra/2 escapes\" do\n test \"strings with slash escapes\" do\n assert quoted_to_string(quote(do: \"\\a\\b\\d\\e\\f\\n\\r\\t\\v\"), escape: false) ==\n ~s/\"\\a\\b\\d\\e\\f\\n\\r\\t\\v\"/\n\n assert quoted_to_string(quote(do: \"\\a\\b\\d\\e\\f\\n\\r\\t\\v\")) ==\n ~s/\"\\\\a\\\\b\\\\d\\\\e\\\\f\\\\n\\\\r\\\\t\\\\v\"/\n\n assert quoted_to_string({:__block__, [], [\"\\a\\b\\d\\e\\f\\n\\r\\t\\v\"]}, escape: false) ==\n ~s/\"\\a\\b\\d\\e\\f\\n\\r\\t\\v\"/\n\n assert quoted_to_string({:__block__, [], [\"\\a\\b\\d\\e\\f\\n\\r\\t\\v\"]}) ==\n ~s/\"\\\\a\\\\b\\\\d\\\\e\\\\f\\\\n\\\\r\\\\t\\\\v\"/\n end\n\n test \"strings with non printable characters\" do\n assert quoted_to_string(quote(do: \"\\x00\\x01\\x10\"), escape: false) == ~s/\"\\x00\\x01\\x10\"/\n assert quoted_to_string(quote(do: \"\\x00\\x01\\x10\")) == ~S/\"\\0\\x01\\x10\"/\n end\n\n test \"charlists with slash escapes\" do\n assert quoted_to_string(~c\"\\a\\b\\e\\n\\r\\t\\v\", escape: false) ==\n ~s/~c\"\\a\\b\\e\\n\\r\\t\\v\"/\n\n assert quoted_to_string(~c\"\\a\\b\\e\\n\\r\\t\\v\") ==\n ~s/~c\"\\\\a\\\\b\\\\e\\\\n\\\\r\\\\t\\\\v\"/\n\n assert quoted_to_string({:__block__, [], [~c\"\\a\\b\\e\\n\\r\\t\\v\"]}, escape: false) ==\n ~s/~c\"\\a\\b\\e\\n\\r\\t\\v\"/\n\n assert quoted_to_string({:__block__, [], [~c\"\\a\\b\\e\\n\\r\\t\\v\"]}) ==\n ~s/~c\"\\\\a\\\\b\\\\e\\\\n\\\\r\\\\t\\\\v\"/\n end\n\n test \"charlists with non printable characters\" do\n assert quoted_to_string(~c\"\\x00\\x01\\x10\", escape: false) == ~S/[0, 1, 16]/\n assert quoted_to_string(~c\"\\x00\\x01\\x10\") == ~S/[0, 1, 16]/\n end\n\n test \"atoms\" do\n assert quoted_to_string(quote(do: :\"a\\nb\\tc\"), escape: false) == ~s/:\"a\\nb\\tc\"/\n assert quoted_to_string(quote(do: :\"a\\nb\\tc\")) == ~S/:\"a\\nb\\tc\"/\n\n assert quoted_to_string({:__block__, [], [:\"a\\nb\\tc\"]}, escape: false) == ~s/:\"a\\nb\\tc\"/\n assert quoted_to_string({:__block__, [], [:\"a\\nb\\tc\"]}) == ~S/:\"a\\nb\\tc\"/\n\n assert quoted_to_string(quote(do: :\"Elixir\")) == \"Elixir\"\n assert quoted_to_string(quote(do: :\"Elixir.Foo\")) == \"Foo\"\n assert quoted_to_string(quote(do: :\"Elixir.Foo.Bar\")) == \"Foo.Bar\"\n assert quoted_to_string(quote(do: :\"Elixir.foobar\")) == ~S/:\"Elixir.foobar\"/\n end\n\n test \"atoms with non printable characters\" do\n assert quoted_to_string(quote(do: :\"\\x00\\x01\\x10\"), escape: false) == ~s/:\"\\0\\x01\\x10\"/\n assert quoted_to_string(quote(do: :\"\\x00\\x01\\x10\")) == ~S/:\"\\0\\x01\\x10\"/\n end\n\n test \"atoms with interpolations\" do\n assert quoted_to_string(quote(do: :\"foo\\n#{bar}\\tbaz\"), escape: false) ==\n ~s[:\"foo\\n\\#{bar}\\tbaz\"]\n\n assert quoted_to_string(quote(do: :\"foo\\n#{bar}\\tbaz\")) == ~S[:\"foo\\n#{bar}\\tbaz\"]\n\n assert quoted_to_string(quote(do: :\"foo\\\"bar\"), escape: false) == ~S[:\"foo\\\"bar\"]\n assert quoted_to_string(quote(do: :\"foo\\\"bar\")) == ~S[:\"foo\\\"bar\"]\n\n assert quoted_to_string(quote(do: :\"foo#{~s/\\n/}bar\"), escape: false) ==\n ~S[:\"foo#{~s/\\n/}bar\"]\n\n assert quoted_to_string(quote(do: :\"foo#{~s/\\n/}bar\")) == ~S[:\"foo#{~s/\\n/}bar\"]\n\n assert quoted_to_string(quote(do: :\"one\\n\\\"#{2}\\\"\\nthree\"), escape: false) ==\n ~s[:\"one\\n\\\\\"\\#{2}\\\\\"\\nthree\"]\n\n assert quoted_to_string(quote(do: :\"one\\n\\\"#{2}\\\"\\nthree\")) == ~S[:\"one\\n\\\"#{2}\\\"\\nthree\"]\n end\n\n test \":erlang.binary_to_atom/2 edge cases\" do\n assert quoted_to_string(quote(do: :erlang.binary_to_atom(<<>>, :utf8))) == ~S[:\"\"]\n\n assert quoted_to_string(quote(do: :erlang.binary_to_atom(<<1>>, :utf8))) ==\n ~S\":erlang.binary_to_atom(<<1>>, :utf8)\"\n end\n end\n\n describe \"quoted_to_algebra/2 with invalid\" do\n test \"block\" do\n assert quoted_to_string({:__block__, [], {:bar, [], []}}) ==\n \"{:__block__, [], {:bar, [], []}}\"\n\n assert quoted_to_string({:foo, [], [{:do, :ok}, :not_keyword]}) ==\n \"foo({:do, :ok}, :not_keyword)\"\n\n assert quoted_to_string({:foo, [], [[{:do, :ok}, :not_keyword]]}) ==\n \"foo([{:do, :ok}, :not_keyword])\"\n end\n\n test \"ode\" do\n assert quoted_to_string(1..3) == \"1..3\"\n end\n end\n\n describe \"quoted_to_algebra/2 does not escape\" do\n test \"sigils\" do\n assert quoted_to_string(quote(do: ~s/a\\nb\\tc/), escape: false) == ~S\"~s/a\\nb\\tc/\"\n assert quoted_to_string(quote(do: ~s/a\\nb\\tc/)) == ~S\"~s/a\\nb\\tc/\"\n\n assert quoted_to_string(quote(do: ~s/\\a\\b\\d\\e\\f\\n\\r\\t\\v/), escape: false) ==\n ~S\"~s/\\a\\b\\d\\e\\f\\n\\r\\t\\v/\"\n\n assert quoted_to_string(quote(do: ~s/\\a\\b\\d\\e\\f\\n\\r\\t\\v/)) == ~S\"~s/\\a\\b\\d\\e\\f\\n\\r\\t\\v/\"\n\n assert quoted_to_string(quote(do: ~s/\\x00\\x01\\x10/), escape: false) == ~S\"~s/\\x00\\x01\\x10/\"\n assert quoted_to_string(quote(do: ~s/\\x00\\x01\\x10/)) == ~S\"~s/\\x00\\x01\\x10/\"\n end\n end\n\n defp strip_metadata(ast) do\n Macro.prewalk(ast, &Macro.update_meta(&1, fn _ -> [] end))\n end\n\n defp quoted_to_string(quoted, opts \\\\ []) do\n doc = Code.quoted_to_algebra(quoted, opts)\n\n Inspect.Algebra.format(doc, 98)\n |> IO.iodata_to_binary()\n end\nend\n" }, { "path": "lib/elixir/test/elixir/code_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule CodeTest do\n use ExUnit.Case, async: true\n\n doctest Code\n import PathHelpers\n\n def genmodule(name) do\n defmodule name do\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end\n end\n\n contents =\n quote do\n defmodule CodeTest.Sample do\n def eval_quoted_info, do: {__MODULE__, __ENV__.file, __ENV__.line}\n end\n end\n\n Code.eval_quoted(contents, [], file: \"sample.ex\", line: 13)\n\n describe \"with_diagnostics/2\" do\n test \"captures warnings\" do\n assert {:warn, [%{message: \"hello\"}]} =\n Code.with_diagnostics(fn ->\n IO.warn(\"hello\")\n :warn\n end)\n end\n\n test \"captures and logs warnings\" do\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert {:warn, [%{message: \"hello\"}]} =\n Code.with_diagnostics([log: true], fn ->\n IO.warn(\"hello\")\n :warn\n end)\n end) =~ \"hello\"\n end\n\n test \"can be nested\" do\n assert {:warn, [%{message: \"hello\"}]} =\n Code.with_diagnostics(fn ->\n IO.warn(\"hello\")\n\n assert {:nested, [%{message: \"world\"}]} =\n Code.with_diagnostics(fn ->\n IO.warn(\"world\")\n :nested\n end)\n\n :warn\n end)\n end\n\n test \"includes column information on unused variables\" do\n assert {_, [%{position: {1, 12}}]} =\n Code.with_diagnostics(fn ->\n quoted = Code.string_to_quoted!(\"if true do var = :foo end\", columns: true)\n Code.eval_quoted(quoted, [])\n end)\n end\n\n test \"includes column information on unused aliases\" do\n sample = \"\"\"\n defmodule CodeTest.UnusedAlias do\n alias String.Chars\n end\n \"\"\"\n\n assert {_, [%{position: {2, 3}}]} =\n Code.with_diagnostics(fn ->\n quoted = Code.string_to_quoted!(sample, columns: true)\n Code.eval_quoted(quoted, [])\n end)\n end\n\n test \"includes column information on unused imports\" do\n sample = \"\"\"\n defmodule CodeTest.UnusedImport do\n import URI\n end\n \"\"\"\n\n assert {_, [%{position: {2, 3}}]} =\n Code.with_diagnostics(fn ->\n quoted = Code.string_to_quoted!(sample, columns: true)\n Code.eval_quoted(quoted, [])\n end)\n end\n\n test \"includes column information on unknown remote function calls\" do\n sample = \"\"\"\n defmodule CodeTest.UnknownRemoteCall do\n def perform do\n UnknownModule.foo()\n end\n end\n \"\"\"\n\n assert {_, [%{position: {3, 19}}]} =\n Code.with_diagnostics(fn ->\n quoted = Code.string_to_quoted!(sample, columns: true)\n Code.eval_quoted(quoted, [])\n end)\n end\n\n test \"captures unknown local calls\" do\n sample = \"\"\"\n defmodule CodeTest.UnknownLocalCall do\n def perform do\n foo()\n end\n end\n \"\"\"\n\n assert {:rescued, [%{message: message}]} =\n Code.with_diagnostics(fn ->\n try do\n quoted = Code.string_to_quoted!(sample, columns: true)\n Code.eval_quoted(quoted, [])\n rescue\n _ -> :rescued\n end\n end)\n\n assert message =~ \"undefined function foo/0\"\n end\n end\n\n describe \"eval_string/1,2,3\" do\n test \"correctly evaluates a string of code\" do\n assert Code.eval_string(\"1 + 2\") == {3, []}\n assert Code.eval_string(\"two = 1 + 1\") == {2, [two: 2]}\n end\n\n test \"keeps bindings on optimized evals\" do\n assert Code.eval_string(\"import Enum\", x: 1) == {Enum, [x: 1]}\n end\n\n test \"supports a %Macro.Env{} struct as the third argument\" do\n assert {3, _} = Code.eval_string(\"a + b\", [a: 1, b: 2], __ENV__)\n end\n\n test \"supports unnamed scopes\" do\n assert {%RuntimeError{}, [a: %RuntimeError{}]} =\n Code.eval_string(\"a = (try do (raise \\\"hello\\\") rescue e -> e end)\")\n end\n\n test \"returns bindings from a different context\" do\n assert Code.eval_string(\"var!(a, Sample) = 1\") == {1, [{{:a, Sample}, 1}]}\n end\n\n defmacro hygiene_var do\n quote do\n a = 1\n end\n end\n\n test \"does not return bindings from macro hygiene\" do\n assert Code.eval_string(\"require CodeTest; CodeTest.hygiene_var()\") == {1, []}\n end\n\n test \"does not raise on duplicate bindings\" do\n # The order of which values win is not guaranteed, but it should evaluate successfully.\n assert Code.eval_string(\"b = String.Chars.to_string(a)\", a: 0, a: 1) ==\n {\"1\", [{:b, \"1\"}, {:a, 1}]}\n\n assert Code.eval_string(\"b = String.Chars.to_string(a)\", a: 0, a: 1, c: 2) ==\n {\"1\", [{:c, 2}, {:b, \"1\"}, {:a, 1}]}\n end\n\n test \"raises on invalid binding type\" do\n assert_raise ArgumentError, \"binding must be a list, got: :not_a_list\", fn ->\n Code.eval_string(\"1 + 1\", :not_a_list)\n end\n\n assert_raise ArgumentError, \"binding must be a list, got: %{}\", fn ->\n Code.eval_string(\"1 + 1\", %{}, __ENV__)\n end\n end\n\n test \"keeps caller in stacktrace\" do\n try do\n Code.eval_string(\"<>\", [a: :a, b: :b], file: \"myfile\")\n rescue\n _ ->\n assert Enum.any?(__STACKTRACE__, &(elem(&1, 0) == __MODULE__))\n end\n end\n\n test \"includes eval file in stacktrace\" do\n try do\n Code.eval_string(\"<>\", [a: :a, b: :b], file: \"myfile\")\n rescue\n _ ->\n assert Exception.format_stacktrace(__STACKTRACE__) =~ \"myfile:1\"\n end\n\n try do\n Code.eval_string(\n \"Enum.map([a: :a, b: :b], fn {a, b} -> <> end)\",\n [],\n file: \"myfile\"\n )\n rescue\n _ ->\n assert Exception.format_stacktrace(__STACKTRACE__) =~ \"myfile:1\"\n end\n end\n\n test \"warns when lexical tracker process is dead\" do\n {pid, ref} = spawn_monitor(fn -> :ok end)\n assert_receive {:DOWN, ^ref, _, _, _}\n env = %{__ENV__ | lexical_tracker: pid}\n\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert Code.eval_string(\"1 + 2\", [], env) == {3, []}\n end) =~ \"an __ENV__ with outdated compilation information was given to eval\"\n end\n\n test \"formats diagnostic file paths as relatives\" do\n {_, diagnostics} =\n Code.with_diagnostics(fn ->\n try do\n Code.eval_string(\"x\", [])\n rescue\n e -> e\n end\n end)\n\n assert [\n %{\n message: \"undefined variable \\\"x\\\"\",\n position: 1,\n file: \"nofile\",\n source: \"nofile\",\n stacktrace: [],\n severity: :error\n }\n ] = diagnostics\n end\n\n test \"with :prune_binding\" do\n opts = [prune_binding: true]\n assert {2, [x: 1]} = Code.eval_string(\"x + 1\", [x: 1, y: 2], opts)\n end\n\n test \"with :debug_callback\" do\n opts = [dbg_callback: {__MODULE__, :dbg_callback_add_one, []}]\n assert {2, _binding} = Code.eval_string(\"dbg(1)\", [], opts)\n\n # Maintains the default behaviour when called again without the option.\n ExUnit.CaptureIO.capture_io(fn ->\n assert {1, _binding} = Code.eval_string(\"dbg(1)\", [])\n end)\n end\n end\n\n describe \"eval_quoted/1\" do\n test \"evaluates expression\" do\n assert Code.eval_quoted(quote(do: 1 + 2)) == {3, []}\n assert CodeTest.Sample.eval_quoted_info() == {CodeTest.Sample, \"sample.ex\", 13}\n end\n\n test \"with %Macro.Env{} at runtime\" do\n alias :lists, as: MyList\n quoted = quote(do: MyList.flatten([[1, 2, 3]]))\n\n assert Code.eval_quoted(quoted, [], __ENV__) == {[1, 2, 3], []}\n\n # Let's check it discards tracers since the lexical tracker is explicitly nil\n assert Code.eval_quoted(quoted, [], %{__ENV__ | tracers: [:bad]}) == {[1, 2, 3], []}\n end\n\n test \"with %Macro.Env{} at compile time\" do\n defmodule CompileTimeEnv do\n alias String.Chars\n {\"foo\", []} = Code.eval_string(\"Chars.to_string(:foo)\", [], __ENV__)\n end\n end\n\n test \"with :prune_binding\" do\n quoted = quote(do: var!(x) + 1)\n opts = [prune_binding: true]\n assert {2, [x: 1]} = Code.eval_quoted(quoted, [x: 1, y: 2], opts)\n end\n\n test \"with :dbg_callback\" do\n quoted = quote(do: dbg(1))\n opts = [dbg_callback: {__MODULE__, :dbg_callback_add_one, []}]\n assert {2, _binding} = Code.eval_quoted(quoted, [], opts)\n\n # Maintains the default behaviour when called again without the option.\n ExUnit.CaptureIO.capture_io(fn ->\n assert {1, _binding} = Code.eval_quoted(quoted, [])\n end)\n end\n end\n\n test \"eval_file/1\" do\n assert Code.eval_file(fixture_path(\"code_sample.exs\")) == {3, [var: 3]}\n\n assert_raise Code.LoadError, fn ->\n Code.eval_file(\"non_existent.exs\")\n end\n end\n\n describe \"eval_quoted_with_env/3\" do\n test \"returns results, bindings, and env\" do\n alias :lists, as: MyList\n quoted = quote(do: MyList.flatten([[1, 2, 3]]))\n env = Code.env_for_eval(__ENV__)\n assert Code.eval_quoted_with_env(quoted, [], env) == {[1, 2, 3], [], env}\n\n quoted = quote(do: alias(:dict, as: MyDict))\n {:dict, [], env} = Code.eval_quoted_with_env(quoted, [], env)\n assert Keyword.fetch(env.aliases, Elixir.MyDict) == {:ok, :dict}\n end\n\n test \"manages env vars\" do\n env = Code.env_for_eval(__ENV__)\n {1, [x: 1], env} = Code.eval_quoted_with_env(quote(do: var!(x) = 1), [], env)\n assert Macro.Env.vars(env) == [{:x, nil}]\n end\n\n test \"prunes vars\" do\n env = Code.env_for_eval(__ENV__)\n\n fun = fn quoted, binding ->\n {_, binding, env} = Code.eval_quoted_with_env(quoted, binding, env, prune_binding: true)\n {binding, Macro.Env.vars(env)}\n end\n\n assert fun.(quote(do: 123), []) == {[], []}\n assert fun.(quote(do: 123), x: 2, y: 3) == {[], []}\n\n assert fun.(quote(do: var!(x) = 1), []) == {[x: 1], [x: nil]}\n assert fun.(quote(do: var!(x) = 1), x: 2, y: 3) == {[x: 1], [x: nil]}\n\n assert fun.(quote(do: var!(x, :foo) = 1), []) == {[{{:x, :foo}, 1}], [x: :foo]}\n assert fun.(quote(do: var!(x, :foo) = 1), x: 2, y: 3) == {[{{:x, :foo}, 1}], [x: :foo]}\n\n assert fun.(quote(do: var!(x, :foo) = 1), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==\n {[{{:x, :foo}, 1}], [x: :foo]}\n\n assert fun.(quote(do: fn -> var!(x, :foo) = 1 end), []) == {[], []}\n assert fun.(quote(do: fn -> var!(x, :foo) = 1 end), x: 1, y: 2) == {[], []}\n\n assert fun.(quote(do: fn -> var!(x) end), x: 2, y: 3) == {[x: 2], [x: nil]}\n\n assert fun.(quote(do: fn -> var!(x, :foo) end), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==\n {[{{:x, :foo}, 2}], [x: :foo]}\n end\n\n test \"undefined function\" do\n env = Code.env_for_eval(__ENV__)\n quoted = quote do: foo()\n\n assert_exception(\n UndefinedFunctionError,\n [\"** (UndefinedFunctionError) function foo/0 is undefined (there is no such import)\"],\n fn ->\n Code.eval_quoted_with_env(quoted, [], env)\n end\n )\n end\n\n defmodule Tracer do\n def trace(event, env) do\n send(self(), {:trace, event, env})\n :ok\n end\n end\n\n test \"with tracing and pruning\" do\n env = %{Code.env_for_eval(__ENV__) | tracers: [Tracer], function: nil}\n binding = [x: 1, y: 2, z: 3]\n\n quoted =\n quote do\n defmodule Elixir.CodeTest.TracingPruning do\n var!(y) = :updated\n var!(y)\n var!(x)\n end\n end\n\n {_, binding, env} = Code.eval_quoted_with_env(quoted, binding, env, prune_binding: true)\n assert Enum.sort(binding) == []\n assert env.versioned_vars == %{}\n\n assert_receive {:trace, {:on_module, _, _}, %{module: CodeTest.TracingPruning} = trace_env}\n\n assert trace_env.versioned_vars == %{\n {:result, :elixir_compiler} => 5,\n {:x, nil} => 1,\n {:y, nil} => 4\n }\n end\n\n test \"with defguard\" do\n require Integer, warn: false\n env = Code.env_for_eval(__ENV__)\n quoted = quote do: Integer.is_even(1)\n {false, binding, env} = Code.eval_quoted_with_env(quoted, [], env, prune_binding: true)\n assert binding == []\n assert Macro.Env.vars(env) == []\n end\n\n test \"with :dbg_callback\" do\n quoted = quote(do: dbg(1))\n env = Code.env_for_eval(__ENV__)\n opts = [dbg_callback: {__MODULE__, :dbg_callback_add_one, []}]\n assert {2, _binding, _env} = Code.eval_quoted_with_env(quoted, [], env, opts)\n\n # Maintains the default behaviour when called again without the option.\n ExUnit.CaptureIO.capture_io(fn ->\n assert {1, _binding, _env} = Code.eval_quoted_with_env(quoted, [], env, [])\n end)\n end\n end\n\n def dbg_callback_add_one(code, _options, _caller) do\n quote do\n unquote(code) + 1\n end\n end\n\n describe \"compile_file/1\" do\n test \"compiles the given path\" do\n assert Code.compile_file(fixture_path(\"code_sample.exs\")) == []\n refute fixture_path(\"code_sample.exs\") in Code.required_files()\n end\n end\n\n test \"require_file/1\" do\n assert Code.require_file(fixture_path(\"code_sample.exs\")) == []\n assert fixture_path(\"code_sample.exs\") in Code.required_files()\n assert Code.require_file(fixture_path(\"code_sample.exs\")) == nil\n\n Code.unrequire_files([fixture_path(\"code_sample.exs\")])\n refute fixture_path(\"code_sample.exs\") in Code.required_files()\n assert Code.require_file(fixture_path(\"code_sample.exs\")) != nil\n after\n Code.unrequire_files([fixture_path(\"code_sample.exs\")])\n end\n\n test \"string_to_quoted!/2 errors take lines/columns/indentation into account\" do\n assert_exception(\n SyntaxError,\n [\"nofile:1:5:\", \"syntax error before:\", \"1 + * 3\", \"^\"],\n fn ->\n Code.string_to_quoted!(\"1 + * 3\")\n end\n )\n\n assert_exception(\n SyntaxError,\n [\"nofile:10:5:\", \"syntax error before:\", \"1 + * 3\", \"^\"],\n fn ->\n Code.string_to_quoted!(\"1 + * 3\", line: 10)\n end\n )\n\n assert_exception(\n SyntaxError,\n [\"nofile:10:7:\", \"syntax error before:\", \"1 + * 3\", \"^\"],\n fn ->\n Code.string_to_quoted!(\"1 + * 3\", line: 10, column: 3)\n end\n )\n\n assert_exception(\n SyntaxError,\n [\"nofile:11:15:\", \"syntax error before:\", \"1 + * 3\", \"^\"],\n fn ->\n Code.string_to_quoted!(\":ok\\n1 + * 3\", line: 10, column: 3, indentation: 10)\n end\n )\n end\n\n test \"string_to_quoted only requires the List.Chars protocol implementation to work\" do\n assert {:ok, 1.23} = Code.string_to_quoted(1.23)\n assert 1.23 = Code.string_to_quoted!(1.23)\n assert {:ok, 1.23, []} = Code.string_to_quoted_with_comments(1.23)\n assert {1.23, []} = Code.string_to_quoted_with_comments!(1.23)\n end\n\n test \"string_to_quoted returns error on incomplete escaped string\" do\n assert {:error, {meta, \"missing terminator: \\\" (for string starting at line 1)\", \"\"}} =\n Code.string_to_quoted(\"\\\"\\\\\")\n\n assert meta[:line] == 1\n assert meta[:column] == 1\n assert meta[:end_line] == 1\n assert meta[:end_column] == 3\n end\n\n test \"string_to_quoted with comments\" do\n assert Code.string_to_quoted_with_comments(\"\"\"\n # top\n [\n # before\n\n # right-before\n expr, # middle\n # right-after\n\n # after\n ]\n # bottom\n \"\"\") ==\n {\n :ok,\n [{:expr, [line: 6], nil}],\n [\n %{\n column: 1,\n line: 1,\n next_eol_count: 1,\n previous_eol_count: 1,\n text: \"# top\"\n },\n %{\n column: 3,\n line: 3,\n next_eol_count: 2,\n previous_eol_count: 1,\n text: \"# before\"\n },\n %{\n column: 3,\n line: 5,\n next_eol_count: 1,\n previous_eol_count: 2,\n text: \"# right-before\"\n },\n %{\n column: 9,\n line: 6,\n next_eol_count: 1,\n previous_eol_count: 0,\n text: \"# middle\"\n },\n %{\n column: 3,\n line: 7,\n next_eol_count: 2,\n previous_eol_count: 1,\n text: \"# right-after\"\n },\n %{\n column: 3,\n line: 9,\n next_eol_count: 1,\n previous_eol_count: 2,\n text: \"# after\"\n },\n %{\n column: 1,\n line: 11,\n next_eol_count: 1,\n previous_eol_count: 1,\n text: \"# bottom\"\n }\n ]\n }\n end\n\n test \"string_to_quoted handles unescape errors properly\" do\n # Test invalid hex escape character\n assert {:error, {meta, message, token}} = Code.string_to_quoted(\"a.'\\\\xg'\")\n\n assert meta[:line] == 1\n assert meta[:column] == 3\n\n assert message ==\n \"invalid hex escape character, expected \\\\xHH where H is a hexadecimal digit. Syntax error after: \"\n\n assert token == \"\\\\x\"\n\n # Test invalid Unicode escape character\n assert {:error, {meta2, message2, token2}} = Code.string_to_quoted(\"a.'\\\\ug'\")\n\n assert meta2[:line] == 1\n assert meta2[:column] == 3\n\n assert message2 ==\n \"invalid Unicode escape character, expected \\\\uHHHH or \\\\u{H*} where H is a hexadecimal digit. Syntax error after: \"\n\n assert token2 == \"\\\\u\"\n\n # Test invalid Unicode code point (surrogate pair)\n assert {:error, {meta3, message3, token3}} = Code.string_to_quoted(\"a.'\\\\u{D800}'\")\n\n assert meta3[:line] == 1\n assert meta3[:column] == 3\n\n assert message3 == \"invalid or reserved Unicode code point \\\\u{D800}. Syntax error after: \"\n assert token3 == \"\\\\u\"\n\n # Test Unicode code point beyond valid range\n assert {:error, {meta4, message4, token4}} = Code.string_to_quoted(\"a.'\\\\u{110000}'\")\n\n assert meta4[:line] == 1\n assert meta4[:column] == 3\n\n assert message4 == \"invalid or reserved Unicode code point \\\\u{110000}. Syntax error after: \"\n assert token4 == \"\\\\u\"\n end\n\n test \"string_to_quoted returns error for invalid UTF-8 in strings\" do\n invalid_utf8_cases = [\n # charlist\n \"'\\\\xFF'\",\n # charlist heredoc\n \"'''\\n\\\\xFF\\\\\\n'''\"\n ]\n\n for code <- invalid_utf8_cases do\n assert {:error, {_, message, _}} = Code.string_to_quoted(code)\n assert message =~ \"invalid encoding starting at <<255>>\"\n end\n end\n\n test \"string_to_quoted returns error for invalid UTF-8 in quoted atoms and function calls\" do\n invalid_utf8_cases = [\n # charlist\n # ~S{'\\xFF'},\n # charlist heredoc\n # ~s{'''\\n\\xFF\\n'''},\n # Quoted atom\n ~S{:\"\\xFF\"},\n ~S{:'\\xFF'},\n # Quoted keyword identifier\n ~S{[\"\\xFF\": 1]},\n ~S{['\\xFF': 1]},\n # Quoted function call\n ~S{foo.\"\\xFF\"()},\n ~S{foo.'\\xFF'()}\n ]\n\n for code <- invalid_utf8_cases do\n assert {:error, {_, message, detail}} = Code.string_to_quoted(code)\n assert message =~ \"invalid encoding in atom: \"\n assert detail =~ \"invalid encoding starting at <<255>>\"\n\n assert {:error, {_, message, detail}} =\n Code.string_to_quoted(code, existing_atoms_only: true)\n\n assert message =~ \"invalid encoding in atom: \"\n assert detail =~ \"invalid encoding starting at <<255>>\"\n end\n end\n\n @tag :requires_source\n test \"compile source\" do\n assert __MODULE__.__info__(:compile)[:source] == String.to_charlist(__ENV__.file)\n end\n\n describe \"compile_string/1\" do\n test \"compiles the given string\" do\n assert [{CompileStringSample, _}] =\n Code.compile_string(\"defmodule CompileStringSample, do: :ok\")\n after\n :code.purge(CompileSimpleSample)\n :code.delete(CompileSimpleSample)\n end\n\n test \"works across lexical scopes\" do\n assert [{CompileCrossSample, _}] =\n Code.compile_string(\"CodeTest.genmodule CompileCrossSample\")\n after\n :code.purge(CompileCrossSample)\n :code.delete(CompileCrossSample)\n end\n\n test \"disables tail call optimization at the root\" do\n try do\n Code.compile_string(\"List.flatten(123)\")\n rescue\n _ -> assert Enum.any?(__STACKTRACE__, &match?({_, :__FILE__, 1, _}, &1))\n end\n end\n end\n\n test \"format_string/2 returns empty iodata for empty string\" do\n assert Code.format_string!(\"\") == \"\"\n end\n\n test \"ensure_loaded?/1\" do\n assert Code.ensure_loaded?(__MODULE__)\n refute Code.ensure_loaded?(Code.NoFile)\n end\n\n test \"ensure_loaded!/1\" do\n assert Code.ensure_loaded!(__MODULE__) == __MODULE__\n\n assert_raise ArgumentError, \"could not load module Code.NoFile due to reason :nofile\", fn ->\n Code.ensure_loaded!(Code.NoFile)\n end\n end\n\n test \"ensure_all_loaded/1\" do\n assert Code.ensure_all_loaded([__MODULE__]) == :ok\n assert Code.ensure_all_loaded([__MODULE__, Kernel]) == :ok\n\n assert {:error, [error]} = Code.ensure_all_loaded([__MODULE__, Code.NoFile, __MODULE__])\n assert error == {Code.NoFile, :nofile}\n end\n\n test \"ensure_all_loaded!/1\" do\n assert Code.ensure_all_loaded!([__MODULE__]) == :ok\n assert Code.ensure_all_loaded!([__MODULE__, Kernel]) == :ok\n\n message = \"\"\"\n could not load the following modules:\n\n * Code.NoFile due to reason :nofile\n * Code.OtherNoFile due to reason :nofile\\\n \"\"\"\n\n assert_raise ArgumentError, message, fn ->\n Code.ensure_all_loaded!([__MODULE__, Code.NoFile, Code.OtherNoFile])\n end\n end\n\n test \"ensure_compiled/1\" do\n assert Code.ensure_compiled(__MODULE__) == {:module, __MODULE__}\n assert Code.ensure_compiled(Code.NoFile) == {:error, :nofile}\n end\n\n test \"ensure_compiled!/1\" do\n assert Code.ensure_compiled!(__MODULE__) == __MODULE__\n\n assert_raise ArgumentError, \"could not load module Code.NoFile due to reason :nofile\", fn ->\n Code.ensure_compiled!(Code.NoFile)\n end\n end\n\n test \"put_compiler_option/2 validates options\" do\n message = \"unknown compiler option: :not_a_valid_option\"\n\n assert_raise RuntimeError, message, fn ->\n Code.put_compiler_option(:not_a_valid_option, :foo)\n end\n\n message = \"compiler option :debug_info should be a boolean, got: :not_a_boolean\"\n\n assert_raise RuntimeError, message, fn ->\n Code.put_compiler_option(:debug_info, :not_a_boolean)\n end\n end\n\n describe \"fetch_docs/1\" do\n test \"is case sensitive\" do\n assert {:docs_v1, _, :elixir, _, %{\"en\" => module_doc}, _, _} = Code.fetch_docs(IO)\n\n assert \"Functions handling input/output (IO).\" =\n module_doc |> String.split(\"\\n\") |> Enum.at(0)\n\n assert Code.fetch_docs(Io) == {:error, :module_not_found}\n end\n end\n\n defp assert_exception(ex, messages, callback) do\n e =\n assert_raise ex, fn ->\n callback.()\n end\n\n error_msg = Exception.format(:error, e, [])\n\n for msg <- messages do\n assert error_msg =~ msg\n end\n end\nend\n\ndefmodule Code.SyncTest do\n use ExUnit.Case\n\n import PathHelpers\n\n defp assert_cached(path) do\n assert find_path(path) != :nocache\n end\n\n defp refute_cached(path) do\n assert find_path(path) == :nocache\n end\n\n defp find_path(path) do\n {:status, _, {:module, :code_server}, [_, :running, _, _, state]} =\n :sys.get_status(:code_server)\n\n [:state, _, _otp_root, paths | _] = Tuple.to_list(state)\n {_, value} = List.keyfind(paths, to_charlist(path), 0)\n value\n end\n\n test \"evaluates module definitions\" do\n Code.put_compiler_option(:module_definition, :interpreted)\n\n defmodule CodeTest.EvalModule do\n {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)\n assert Enum.find(stacktrace, &(elem(&1, 0) == :erl_eval))\n end\n after\n Code.put_compiler_option(:module_definition, :compiled)\n end\n\n test \"evaluates module definitions with stacktraces\" do\n Code.put_compiler_option(:module_definition, :interpreted)\n\n try do\n defmodule CodeTest.EvalModuleRaise do\n Enum.map(1..10, fn x -> x <> \"example\" end)\n end\n rescue\n e ->\n assert e.__struct__ == ArgumentError\n assert Enum.find(__STACKTRACE__, &(elem(&1, 0) == Code.SyncTest.CodeTest.EvalModuleRaise))\n assert Enum.find(__STACKTRACE__, &(elem(&1, 0) == :erl_eval))\n else\n _ -> flunk(\"defmodule should have failed\")\n end\n after\n Code.put_compiler_option(:module_definition, :compiled)\n end\n\n test \"prepend_path\" do\n path = Path.join(__DIR__, \"fixtures\")\n true = Code.prepend_path(path)\n assert to_charlist(path) in :code.get_path()\n refute_cached(path)\n\n true = Code.prepend_path(path, cache: true)\n assert_cached(path)\n\n Code.delete_path(path)\n refute to_charlist(path) in :code.get_path()\n end\n\n test \"append_path\" do\n path = Path.join(__DIR__, \"fixtures\")\n true = Code.append_path(path)\n assert to_charlist(path) in :code.get_path()\n refute_cached(path)\n\n true = Code.append_path(path, cache: true)\n assert_cached(path)\n\n Code.delete_path(path)\n refute to_charlist(path) in :code.get_path()\n end\n\n test \"prepend_paths\" do\n path = Path.join(__DIR__, \"fixtures\")\n :ok = Code.prepend_paths([path])\n assert to_charlist(path) in :code.get_path()\n refute_cached(path)\n\n :ok = Code.prepend_paths([path], cache: true)\n assert_cached(path)\n\n Code.delete_paths([path])\n refute to_charlist(path) in :code.get_path()\n end\n\n test \"append_paths\" do\n path = Path.join(__DIR__, \"fixtures\")\n :ok = Code.append_paths([path])\n assert to_charlist(path) in :code.get_path()\n refute_cached(path)\n\n :ok = Code.append_paths([path], cache: true)\n assert_cached(path)\n\n Code.delete_paths([path])\n refute to_charlist(path) in :code.get_path()\n end\n\n test \"returns previous options when setting compiler options\" do\n Code.compiler_options(debug_info: false)\n assert Code.compiler_options(debug_info: true) == %{debug_info: false}\n after\n Code.compiler_options(debug_info: true)\n end\n\n test \"compile_file/1 return value\" do\n assert [{CompileSample, binary}] = Code.compile_file(fixture_path(\"compile_sample.ex\"))\n assert is_binary(binary)\n after\n :code.purge(CompileSample)\n :code.delete(CompileSample)\n end\n\n test \"require_file/1 return value\" do\n assert [{CompileSample, binary}] = Code.require_file(fixture_path(\"compile_sample.ex\"))\n assert is_binary(binary)\n after\n Code.unrequire_files([fixture_path(\"compile_sample.ex\")])\n :code.purge(CompileSample)\n :code.delete(CompileSample)\n end\n\n test \"purges compiler modules\" do\n quoted = quote(do: :ok)\n Code.compile_quoted(quoted)\n\n {:ok, claimed} = Code.purge_compiler_modules()\n assert claimed > 0\n\n {:ok, claimed} = Code.purge_compiler_modules()\n assert claimed == 0\n end\nend\n" }, { "path": "lib/elixir/test/elixir/collectable_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule CollectableTest do\n use ExUnit.Case, async: true\n\n doctest Collectable\nend\n" }, { "path": "lib/elixir/test/elixir/config/provider_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Config.ProviderTest do\n use ExUnit.Case\n\n doctest Config.Provider\n alias Config.Provider\n import PathHelpers\n import ExUnit.CaptureIO\n\n @tmp_path tmp_path(\"config_provider\")\n @env_var \"ELIXIR_CONFIG_PROVIDER_BOOTED\"\n @sys_config Path.join(@tmp_path, \"sys.config\")\n\n setup context do\n File.rm_rf(@tmp_path)\n File.mkdir_p!(@tmp_path)\n write_sys_config!(context[:sys_config] || [])\n\n on_exit(fn ->\n Application.delete_env(:elixir, :config_provider_init)\n Application.delete_env(:elixir, :config_provider_booted)\n System.delete_env(@env_var)\n end)\n end\n\n test \"validate_compile_env\" do\n assert Config.Provider.validate_compile_env([{:elixir, [:unknown], :error}]) == :ok\n\n Application.put_env(:elixir, :unknown, nested: [key: :value])\n\n assert Config.Provider.validate_compile_env([\n {:elixir, [:unknown], {:ok, [nested: [key: :value]]}}\n ]) == :ok\n\n assert Config.Provider.validate_compile_env([\n {:elixir, [:unknown, :nested], {:ok, [key: :value]}}\n ]) == :ok\n\n assert Config.Provider.validate_compile_env([\n {:elixir, [:unknown, :nested, :key], {:ok, :value}}\n ]) == :ok\n\n assert Config.Provider.validate_compile_env([\n {:elixir, [:unknown, :nested, :unknown], :error}\n ]) == :ok\n\n assert {:error, msg} =\n Config.Provider.validate_compile_env([{:elixir, [:unknown, :nested], :error}])\n\n assert msg =~ \"Compile time value was not set\"\n\n assert {:error, msg} =\n Config.Provider.validate_compile_env([\n {:elixir, [:unknown, :nested], {:ok, :another}}\n ])\n\n assert msg =~ \"Compile time value was set to: :another\"\n\n keys = [:unknown, :nested, :key, :too_deep]\n\n assert {:error, msg} =\n Config.Provider.validate_compile_env([{:elixir, keys, :error}])\n\n assert msg =~\n \"application :elixir failed reading its compile environment for path [:nested, :key, :too_deep] inside key :unknown\"\n after\n Application.delete_env(:elixir, :unknown)\n end\n\n describe \"config_path\" do\n test \"validate!\" do\n assert Provider.validate_config_path!(\"/foo\") == :ok\n assert Provider.validate_config_path!({:system, \"foo\", \"bar\"}) == :ok\n\n assert_raise ArgumentError, fn -> Provider.validate_config_path!({:system, 1, 2}) end\n assert_raise ArgumentError, fn -> Provider.validate_config_path!(~c\"baz\") end\n end\n\n test \"resolve!\" do\n env_var = \"ELIXIR_CONFIG_PROVIDER_PATH\"\n\n try do\n System.put_env(env_var, @tmp_path)\n assert Provider.resolve_config_path!(\"/foo\") == \"/foo\"\n assert Provider.resolve_config_path!({:system, env_var, \"/bar\"}) == @tmp_path <> \"/bar\"\n after\n System.delete_env(env_var)\n end\n end\n end\n\n describe \"boot\" do\n test \"runs providers\" do\n init_and_assert_boot()\n config = consult(@sys_config)\n assert config[:my_app] == [key: :value]\n assert config[:elixir] == [config_provider_booted: {:booted, nil}]\n end\n\n @tag sys_config: [my_app: [encoding: {:_μ, :\"£\", \"£\", ~c\"£\"}]]\n test \"writes sys_config with encoding\" do\n init_and_assert_boot()\n config = consult(@sys_config)\n assert config[:my_app][:encoding] == {:_μ, :\"£\", \"£\", ~c\"£\"}\n end\n\n @tag sys_config: [my_app: [key: :old_value, sys_key: :sys_value, extra_config: :old_value]]\n test \"writes extra config with overrides\" do\n init_and_assert_boot(extra_config: [my_app: [key: :old_extra_value, extra_config: :value]])\n\n assert consult(@sys_config)[:my_app] ==\n [sys_key: :sys_value, extra_config: :value, key: :value]\n end\n\n test \"returns :booted if already booted and keeps config file\" do\n init_and_assert_boot()\n Application.put_all_env(Keyword.take(consult(@sys_config), [:elixir]))\n assert boot() == :booted\n refute_received :restart\n assert File.exists?(@sys_config)\n end\n\n test \"returns :booted if already booted and prunes config file\" do\n init_and_assert_boot(prune_runtime_sys_config_after_boot: true)\n Application.put_all_env(Keyword.take(consult(@sys_config), [:elixir]))\n assert boot() == :booted\n refute_received :restart\n refute File.exists?(@sys_config)\n end\n\n test \"returns :booted if already booted and runs validate_compile_env\" do\n init_and_assert_boot(\n prune_runtime_sys_config_after_boot: true,\n validate_compile_env: [{:elixir, [:unknown], {:ok, :value}}]\n )\n\n Application.put_all_env(Keyword.take(consult(@sys_config), [:elixir]))\n\n assert capture_abort(fn -> boot() end) =~\n \"the application :elixir has a different value set for key :unknown\"\n end\n\n test \"returns without rebooting\" do\n reader = {Config.Reader, fixture_path(\"configs/kernel.exs\")}\n init = Config.Provider.init([reader], @sys_config, reboot_system_after_config: false)\n Application.put_all_env(init)\n\n assert capture_abort(fn ->\n Provider.boot(fn ->\n raise \"should not be called\"\n end)\n end) =~\n \"Cannot configure :kernel because :reboot_system_after_config has been set to false\"\n\n # Make sure values before and after match\n write_sys_config!(kernel: [elixir_reboot: true])\n Application.put_all_env(init)\n System.delete_env(@env_var)\n\n Provider.boot(fn -> raise \"should not be called\" end)\n assert Application.get_env(:kernel, :elixir_reboot) == true\n assert Application.get_env(:elixir_reboot, :key) == :value\n end\n end\n\n defp init(opts) do\n reader = {Config.Reader, fixture_path(\"configs/good_config.exs\")}\n init = Config.Provider.init([reader], Keyword.get(opts, :path, @sys_config), opts)\n Application.put_all_env(init)\n init\n end\n\n defp boot do\n Provider.boot(fn -> send(self(), :restart) end)\n end\n\n defp init_and_assert_boot(opts \\\\ []) do\n init(opts ++ [reboot_system_after_config: true])\n boot()\n assert_received :restart\n end\n\n defp consult(file) do\n {:ok, [config]} = :file.consult(file)\n config\n end\n\n defp capture_abort(fun) do\n capture_io(fn ->\n assert_raise ErlangError, fun\n end)\n end\n\n defp write_sys_config!(data) do\n File.write!(@sys_config, IO.chardata_to_string(:io_lib.format(\"~tw.~n\", [data])))\n end\nend\n" }, { "path": "lib/elixir/test/elixir/config/reader_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Config.ReaderTest do\n use ExUnit.Case, async: true\n\n doctest Config.Reader\n import PathHelpers\n\n test \"read_imports!/2\" do\n assert Config.Reader.read_imports!(fixture_path(\"configs/good_kw.exs\")) ==\n {[my_app: [key: :value]], [fixture_path(\"configs/good_kw.exs\")]}\n\n assert Config.Reader.read_imports!(fixture_path(\"configs/good_config.exs\")) ==\n {[my_app: [key: :value]], [fixture_path(\"configs/good_config.exs\")]}\n\n assert Config.Reader.read_imports!(fixture_path(\"configs/good_import.exs\")) ==\n {[my_app: [key: :value]],\n [fixture_path(\"configs/good_config.exs\"), fixture_path(\"configs/good_import.exs\")]}\n\n assert_raise ArgumentError,\n \":imports must be a list of paths\",\n fn -> Config.Reader.read_imports!(\"config\", imports: :disabled) end\n\n assert_raise File.Error,\n fn -> Config.Reader.read_imports!(fixture_path(\"configs/bad_root.exs\")) end\n\n assert_raise File.Error,\n fn -> Config.Reader.read_imports!(fixture_path(\"configs/bad_import.exs\")) end\n end\n\n test \"read!/2\" do\n assert Config.Reader.read!(fixture_path(\"configs/good_kw.exs\")) ==\n [my_app: [key: :value]]\n\n assert Config.Reader.read!(fixture_path(\"configs/good_config.exs\")) ==\n [my_app: [key: :value]]\n\n assert Config.Reader.read!(fixture_path(\"configs/good_import.exs\")) ==\n [my_app: [key: :value]]\n\n assert Config.Reader.read!(fixture_path(\"configs/env.exs\"), env: :dev, target: :host) ==\n [my_app: [env: :dev, target: :host]]\n\n assert Config.Reader.read!(fixture_path(\"configs/env.exs\"), env: :prod, target: :embedded) ==\n [my_app: [env: :prod, target: :embedded]]\n\n assert_raise ArgumentError,\n ~r\"expected config for app :sample in .*/bad_app.exs to return keyword list\",\n fn -> Config.Reader.read!(fixture_path(\"configs/bad_app.exs\")) end\n\n assert_raise RuntimeError, \"no :env key was given to this configuration file\", fn ->\n Config.Reader.read!(fixture_path(\"configs/env.exs\"))\n end\n\n assert_raise RuntimeError, \"no :target key was given to this configuration file\", fn ->\n Config.Reader.read!(fixture_path(\"configs/env.exs\"), env: :prod)\n end\n\n assert_raise RuntimeError,\n ~r\"import_config/1 is not enabled for this configuration file\",\n fn ->\n Config.Reader.read!(fixture_path(\"configs/good_import.exs\"),\n imports: :disabled\n )\n end\n end\n\n test \"eval!/3\" do\n files = [\"configs/good_kw.exs\", \"configs/good_config.exs\", \"configs/good_import.exs\"]\n\n for file <- files do\n file = fixture_path(file)\n assert Config.Reader.read!(file) == Config.Reader.eval!(file, File.read!(file))\n end\n\n file = fixture_path(\"configs/env.exs\")\n\n assert Config.Reader.read!(file, env: :dev, target: :host) ==\n Config.Reader.eval!(file, File.read!(file), env: :dev, target: :host)\n end\n\n test \"as a provider\" do\n state = Config.Reader.init(fixture_path(\"configs/good_config.exs\"))\n assert Config.Reader.load([my_app: [key: :old_value]], state) == [my_app: [key: :value]]\n\n state = Config.Reader.init(path: fixture_path(\"configs/env.exs\"), env: :prod, target: :host)\n\n assert Config.Reader.load([my_app: [env: :dev]], state) ==\n [my_app: [env: :prod, target: :host]]\n end\nend\n" }, { "path": "lib/elixir/test/elixir/config_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule ConfigTest do\n use ExUnit.Case, async: true\n\n doctest Config\n import Config\n import PathHelpers\n\n setup config do\n Process.put({Config, :opts}, {config[:env], config[:target]})\n Process.put({Config, :config}, [])\n Process.put({Config, :imports}, config[:imports] || [])\n :ok\n end\n\n defp config do\n Process.get({Config, :config})\n end\n\n defp files do\n Process.get({Config, :imports})\n end\n\n test \"config/2\" do\n assert config() == []\n\n config :lager, key: :value\n assert config() == [lager: [key: :value]]\n\n config :lager, other: :value\n assert config() == [lager: [key: :value, other: :value]]\n\n config :lager, key: :other\n assert config() == [lager: [other: :value, key: :other]]\n\n # Works inside functions too...\n f = fn -> config(:lager, key: :fn) end\n f.()\n assert config() == [lager: [other: :value, key: :fn]]\n\n # ...and in for comprehensions.\n for _ <- 0..0, do: config(:lager, key: :for)\n assert config() == [lager: [other: :value, key: :for]]\n end\n\n test \"config/3\" do\n config :app, Repo, key: :value\n assert config() == [app: [{Repo, key: :value}]]\n\n config :app, Repo, other: :value\n assert config() == [app: [{Repo, key: :value, other: :value}]]\n\n config :app, Repo, key: :other\n assert config() == [app: [{Repo, other: :value, key: :other}]]\n\n config :app, Repo, key: [nested: false]\n assert config() == [app: [{Repo, other: :value, key: [nested: false]}]]\n\n config :app, Repo, key: [nested: true]\n assert config() == [app: [{Repo, other: :value, key: [nested: true]}]]\n\n config :app, Repo, key: :other\n assert config() == [app: [{Repo, other: :value, key: :other}]]\n end\n\n test \"read_config/1\" do\n assert read_config(:lager) == nil\n\n config :lager, key: :value\n assert read_config(:lager) == [key: :value]\n\n config :lager, other: :value\n assert read_config(:lager) == [key: :value, other: :value]\n end\n\n @tag env: :dev\n test \"config_env/0\" do\n assert config_env() == :dev\n end\n\n test \"config_env/0 raises if no env is set\" do\n assert_raise RuntimeError, \"no :env key was given to this configuration file\", fn ->\n config_env()\n end\n end\n\n @tag target: :host\n test \"config_target/0\" do\n assert config_target() == :host\n end\n\n test \"config_target/0 raises if no env is set\" do\n assert_raise RuntimeError, \"no :target key was given to this configuration file\", fn ->\n config_target()\n end\n end\n\n test \"import_config/1\" do\n import_config fixture_path(\"configs/good_config.exs\")\n assert config() == [my_app: [key: :value]]\n assert files() == [fixture_path(\"configs/good_config.exs\")]\n end\n\n @tag imports: :disabled\n test \"import_config/1 raises when disabled\" do\n assert_raise RuntimeError,\n ~r\"import_config/1 is not enabled for this configuration file\",\n fn -> import_config fixture_path(\"configs/good_config.exs\") end\n end\n\n test \"import_config/1 raises for recursive import\" do\n assert_raise ArgumentError,\n ~r\"attempting to load configuration .*/imports_recursive.exs recursively\",\n fn -> import_config fixture_path(\"configs/imports_recursive.exs\") end\n end\n\n test \"import_config/1 with nested\" do\n config :app, Repo, key: [nested: false, other: true]\n import_config fixture_path(\"configs/nested.exs\")\n assert config() == [app: [{Repo, key: [other: true, nested: true]}]]\n end\n\n test \"import_config/1 with bad path\" do\n assert_raise File.Error, ~r\"could not read file .*/configs/unknown.exs\", fn ->\n import_config fixture_path(\"configs/unknown.exs\")\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/dynamic_supervisor_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule DynamicSupervisorTest do\n use ExUnit.Case, async: true\n\n defmodule Simple do\n use DynamicSupervisor\n\n def init(args), do: args\n end\n\n test \"can be supervised directly\" do\n children = [{DynamicSupervisor, name: :dyn_sup_spec_test}]\n assert {:ok, _} = Supervisor.start_link(children, strategy: :one_for_one)\n assert DynamicSupervisor.which_children(:dyn_sup_spec_test) == []\n end\n\n test \"multiple supervisors can be supervised and identified with simple child spec\" do\n {:ok, _} = Registry.start_link(keys: :unique, name: DynSup.Registry)\n\n children = [\n {DynamicSupervisor, name: :simple_name},\n {DynamicSupervisor, name: {:global, :global_name}},\n {DynamicSupervisor, name: {:via, Registry, {DynSup.Registry, \"via_name\"}}}\n ]\n\n assert {:ok, supsup} = Supervisor.start_link(children, strategy: :one_for_one)\n\n assert {:ok, no_name_dynsup} =\n Supervisor.start_child(supsup, {DynamicSupervisor, strategy: :one_for_one})\n\n assert DynamicSupervisor.which_children(:simple_name) == []\n assert DynamicSupervisor.which_children({:global, :global_name}) == []\n assert DynamicSupervisor.which_children({:via, Registry, {DynSup.Registry, \"via_name\"}}) == []\n assert DynamicSupervisor.which_children(no_name_dynsup) == []\n\n assert Supervisor.start_child(supsup, {DynamicSupervisor, strategy: :one_for_one}) ==\n {:error, {:already_started, no_name_dynsup}}\n end\n\n describe \"use/2\" do\n test \"generates child_spec/1\" do\n assert Simple.child_spec([:hello]) == %{\n id: Simple,\n start: {Simple, :start_link, [[:hello]]},\n type: :supervisor\n }\n\n defmodule Custom do\n use DynamicSupervisor,\n id: :id,\n restart: :temporary,\n shutdown: :infinity,\n start: {:foo, :bar, []}\n\n def init(arg), do: {:producer, arg}\n end\n\n assert Custom.child_spec([:hello]) == %{\n id: :id,\n restart: :temporary,\n shutdown: :infinity,\n start: {:foo, :bar, []},\n type: :supervisor\n }\n end\n end\n\n describe \"init/1\" do\n test \"set default options\" do\n assert DynamicSupervisor.init([]) ==\n {:ok,\n %{\n strategy: :one_for_one,\n intensity: 3,\n period: 5,\n max_children: :infinity,\n extra_arguments: []\n }}\n end\n end\n\n describe \"start_link/3\" do\n test \"with non-ok init\" do\n Process.flag(:trap_exit, true)\n\n assert DynamicSupervisor.start_link(Simple, {:ok, %{strategy: :unknown}}) ==\n {:error, {:supervisor_data, {:invalid_strategy, :unknown}}}\n\n assert DynamicSupervisor.start_link(Simple, {:ok, %{intensity: -1}}) ==\n {:error, {:supervisor_data, {:invalid_intensity, -1}}}\n\n assert DynamicSupervisor.start_link(Simple, {:ok, %{period: 0}}) ==\n {:error, {:supervisor_data, {:invalid_period, 0}}}\n\n assert DynamicSupervisor.start_link(Simple, {:ok, %{max_children: -1}}) ==\n {:error, {:supervisor_data, {:invalid_max_children, -1}}}\n\n assert DynamicSupervisor.start_link(Simple, {:ok, %{extra_arguments: -1}}) ==\n {:error, {:supervisor_data, {:invalid_extra_arguments, -1}}}\n\n assert DynamicSupervisor.start_link(Simple, {:ok, %{auto_shutdown: :any_significant}}) ==\n {:error, {:supervisor_data, {:invalid_auto_shutdown, :any_significant}}}\n\n assert DynamicSupervisor.start_link(Simple, :unknown) ==\n {:error, {:bad_return, {Simple, :init, :unknown}}}\n\n assert DynamicSupervisor.start_link(Simple, :ignore) == :ignore\n end\n\n test \"with registered process\" do\n {:ok, pid} = DynamicSupervisor.start_link(Simple, {:ok, %{}}, name: __MODULE__)\n\n # Sets up a link\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n # A name\n assert Process.whereis(__MODULE__) == pid\n\n # And the initial call\n assert {:supervisor, DynamicSupervisorTest.Simple, 1} =\n :proc_lib.translate_initial_call(pid)\n\n # And shuts down\n assert DynamicSupervisor.stop(__MODULE__) == :ok\n end\n\n test \"with spawn_opt\" do\n {:ok, pid} =\n DynamicSupervisor.start_link(strategy: :one_for_one, spawn_opt: [priority: :high])\n\n assert Process.info(pid, :priority) == {:priority, :high}\n end\n\n test \"sets initial call to the same as a regular supervisor\" do\n {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)\n assert :proc_lib.initial_call(pid) == {:supervisor, Supervisor.Default, [:Argument__1]}\n\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n assert :proc_lib.initial_call(pid) == {:supervisor, Supervisor.Default, [:Argument__1]}\n end\n end\n\n ## Code change\n\n describe \"code_change/3\" do\n test \"with non-ok init\" do\n {:ok, pid} = DynamicSupervisor.start_link(Simple, {:ok, %{}})\n\n assert fake_upgrade(pid, {:ok, %{strategy: :unknown}}) ==\n {:error, {:error, {:supervisor_data, {:invalid_strategy, :unknown}}}}\n\n assert fake_upgrade(pid, {:ok, %{intensity: -1}}) ==\n {:error, {:error, {:supervisor_data, {:invalid_intensity, -1}}}}\n\n assert fake_upgrade(pid, {:ok, %{period: 0}}) ==\n {:error, {:error, {:supervisor_data, {:invalid_period, 0}}}}\n\n assert fake_upgrade(pid, {:ok, %{max_children: -1}}) ==\n {:error, {:error, {:supervisor_data, {:invalid_max_children, -1}}}}\n\n assert fake_upgrade(pid, :unknown) == {:error, :unknown}\n assert fake_upgrade(pid, :ignore) == :ok\n end\n\n test \"with ok init\" do\n {:ok, pid} = DynamicSupervisor.start_link(Simple, {:ok, %{}})\n {:ok, _} = DynamicSupervisor.start_child(pid, sleepy_worker())\n assert %{active: 1} = DynamicSupervisor.count_children(pid)\n\n assert fake_upgrade(pid, {:ok, %{max_children: 1}}) == :ok\n assert %{active: 1} = DynamicSupervisor.count_children(pid)\n assert DynamicSupervisor.start_child(pid, {Task, fn -> :ok end}) == {:error, :max_children}\n end\n\n defp fake_upgrade(pid, init_arg) do\n :ok = :sys.suspend(pid)\n :sys.replace_state(pid, fn state -> %{state | args: init_arg} end)\n res = :sys.change_code(pid, :gen_server, 123, :extra)\n :ok = :sys.resume(pid)\n res\n end\n end\n\n describe \"start_child/2\" do\n test \"supports old child spec\" do\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n child = {Task, {Task, :start_link, [fn -> :ok end]}, :temporary, 5000, :worker, [Task]}\n assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)\n assert is_pid(pid)\n end\n\n test \"supports new child spec as tuple\" do\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n child = %{id: Task, restart: :temporary, start: {Task, :start_link, [fn -> :ok end]}}\n assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)\n assert is_pid(pid)\n end\n\n test \"supports new child spec\" do\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n child = {Task, fn -> Process.sleep(:infinity) end}\n assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)\n assert is_pid(pid)\n end\n\n test \"supports extra arguments\" do\n parent = self()\n fun = fn -> send(parent, :from_child) end\n\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, extra_arguments: [fun])\n child = %{id: Task, restart: :temporary, start: {Task, :start_link, []}}\n assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)\n assert is_pid(pid)\n assert_receive :from_child\n end\n\n test \"with invalid child spec\" do\n assert DynamicSupervisor.start_child(:not_used, %{}) == {:error, {:invalid_child_spec, %{}}}\n\n assert DynamicSupervisor.start_child(:not_used, {1, 2, 3, 4, 5, 6}) ==\n {:error, {:invalid_mfa, 2}}\n\n assert DynamicSupervisor.start_child(:not_used, %{id: 1, start: {Task, :foo, :bar}}) ==\n {:error, {:invalid_mfa, {Task, :foo, :bar}}}\n\n assert DynamicSupervisor.start_child(:not_used, %{\n id: 1,\n start: {Task, :foo, [:bar]},\n shutdown: -1\n }) ==\n {:error, {:invalid_shutdown, -1}}\n\n assert DynamicSupervisor.start_child(:not_used, %{\n id: 1,\n start: {Task, :foo, [:bar]},\n significant: true\n }) ==\n {:error, {:invalid_significant, true}}\n end\n\n test \"with different returns\" do\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n assert {:ok, _, :extra} = DynamicSupervisor.start_child(pid, current_module_worker([:ok3]))\n assert {:ok, _} = DynamicSupervisor.start_child(pid, current_module_worker([:ok2]))\n assert :ignore = DynamicSupervisor.start_child(pid, current_module_worker([:ignore]))\n\n assert {:error, :found} =\n DynamicSupervisor.start_child(pid, current_module_worker([:error]))\n\n assert {:error, :unknown} =\n DynamicSupervisor.start_child(pid, current_module_worker([:unknown]))\n end\n\n test \"with throw/error/exit\" do\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n assert {:error, {{:nocatch, :oops}, [_ | _]}} =\n DynamicSupervisor.start_child(pid, current_module_worker([:non_local, :throw]))\n\n assert {:error, {%RuntimeError{}, [_ | _]}} =\n DynamicSupervisor.start_child(pid, current_module_worker([:non_local, :error]))\n\n assert {:error, :oops} =\n DynamicSupervisor.start_child(pid, current_module_worker([:non_local, :exit]))\n end\n\n test \"with max_children\" do\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_children: 0)\n\n assert {:error, :max_children} =\n DynamicSupervisor.start_child(pid, current_module_worker([:ok2]))\n end\n\n test \"temporary child is not restarted regardless of reason\" do\n child = current_module_worker([:ok2], restart: :temporary)\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :shutdown)\n assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :whatever)\n assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)\n end\n\n test \"transient child is restarted unless normal/shutdown/{shutdown, _}\" do\n child = current_module_worker([:ok2], restart: :transient)\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :shutdown)\n assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, {:shutdown, :signal})\n assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :whatever)\n assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)\n end\n\n test \"permanent child is restarted regardless of reason\" do\n child = current_module_worker([:ok2], restart: :permanent)\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 100_000)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :shutdown)\n assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, {:shutdown, :signal})\n assert %{workers: 2, active: 2} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :whatever)\n assert %{workers: 3, active: 3} = DynamicSupervisor.count_children(pid)\n end\n\n test \"child is restarted with different values\" do\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 100_000)\n\n assert {:ok, child1} =\n DynamicSupervisor.start_child(pid, current_module_worker([:restart, :ok2]))\n\n assert [{:undefined, ^child1, :worker, [DynamicSupervisorTest]}] =\n DynamicSupervisor.which_children(pid)\n\n assert_kill(child1, :shutdown)\n assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child2} =\n DynamicSupervisor.start_child(pid, current_module_worker([:restart, :ok3]))\n\n assert [\n {:undefined, _, :worker, [DynamicSupervisorTest]},\n {:undefined, ^child2, :worker, [DynamicSupervisorTest]}\n ] = DynamicSupervisor.which_children(pid)\n\n assert_kill(child2, :shutdown)\n assert %{workers: 2, active: 2} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child3} =\n DynamicSupervisor.start_child(pid, current_module_worker([:restart, :ignore]))\n\n assert [\n {:undefined, _, :worker, [DynamicSupervisorTest]},\n {:undefined, _, :worker, [DynamicSupervisorTest]},\n {:undefined, _, :worker, [DynamicSupervisorTest]}\n ] = DynamicSupervisor.which_children(pid)\n\n assert_kill(child3, :shutdown)\n assert %{workers: 2, active: 2} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child4} =\n DynamicSupervisor.start_child(pid, current_module_worker([:restart, :error]))\n\n assert [\n {:undefined, _, :worker, [DynamicSupervisorTest]},\n {:undefined, _, :worker, [DynamicSupervisorTest]},\n {:undefined, _, :worker, [DynamicSupervisorTest]}\n ] = DynamicSupervisor.which_children(pid)\n\n assert_kill(child4, :shutdown)\n assert %{workers: 3, active: 2} = DynamicSupervisor.count_children(pid)\n\n assert {:ok, child5} =\n DynamicSupervisor.start_child(pid, current_module_worker([:restart, :unknown]))\n\n assert [\n {:undefined, _, :worker, [DynamicSupervisorTest]},\n {:undefined, _, :worker, [DynamicSupervisorTest]},\n {:undefined, :restarting, :worker, [DynamicSupervisorTest]},\n {:undefined, _, :worker, [DynamicSupervisorTest]}\n ] = DynamicSupervisor.which_children(pid)\n\n assert_kill(child5, :shutdown)\n assert %{workers: 4, active: 2} = DynamicSupervisor.count_children(pid)\n end\n\n test \"restarting on init children counted in max_children\" do\n child = current_module_worker([:restart, :error], restart: :permanent)\n opts = [strategy: :one_for_one, max_children: 1, max_restarts: 100_000]\n {:ok, pid} = DynamicSupervisor.start_link(opts)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :shutdown)\n assert %{workers: 1, active: 0} = DynamicSupervisor.count_children(pid)\n\n child = current_module_worker([:restart, :ok2], restart: :permanent)\n assert {:error, :max_children} = DynamicSupervisor.start_child(pid, child)\n end\n\n test \"restarting on exit children counted in max_children\" do\n child = current_module_worker([:ok2], restart: :permanent)\n opts = [strategy: :one_for_one, max_children: 1, max_restarts: 100_000]\n {:ok, pid} = DynamicSupervisor.start_link(opts)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :shutdown)\n assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)\n\n child = current_module_worker([:ok2], restart: :permanent)\n assert {:error, :max_children} = DynamicSupervisor.start_child(pid, child)\n end\n\n test \"restarting a child with extra_arguments successfully restarts child\" do\n parent = self()\n\n fun = fn ->\n send(parent, :from_child)\n Process.sleep(:infinity)\n end\n\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one, extra_arguments: [fun])\n child = %{id: Task, restart: :transient, start: {Task, :start_link, []}}\n\n assert {:ok, child} = DynamicSupervisor.start_child(sup, child)\n assert is_pid(child)\n assert_receive :from_child\n assert %{active: 1, workers: 1} = DynamicSupervisor.count_children(sup)\n assert_kill(child, :oops)\n assert_receive :from_child\n assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(sup)\n end\n\n test \"child is restarted when trying again\" do\n child = current_module_worker([:try_again, self()], restart: :permanent)\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 2)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_received {:try_again, true}\n assert_kill(child_pid, :shutdown)\n assert_receive {:try_again, false}\n assert_receive {:try_again, true}\n assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)\n end\n\n test \"child triggers maximum restarts\" do\n Process.flag(:trap_exit, true)\n child = current_module_worker([:restart, :error], restart: :permanent)\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 1)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :shutdown)\n assert_receive {:EXIT, ^pid, :shutdown}\n end\n\n test \"child triggers maximum intensity when trying again\" do\n Process.flag(:trap_exit, true)\n child = current_module_worker([:restart, :error], restart: :permanent)\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 10)\n\n assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)\n assert_kill(child_pid, :shutdown)\n assert_receive {:EXIT, ^pid, :shutdown}\n end\n\n test \"with valid shutdown\" do\n Process.flag(:trap_exit, true)\n\n {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n for n <- 0..1 do\n assert {:ok, child_pid} =\n DynamicSupervisor.start_child(pid, %{\n id: n,\n start: {Task, :start_link, [fn -> Process.sleep(:infinity) end]},\n shutdown: n\n })\n\n assert_kill(child_pid, :shutdown)\n end\n end\n\n test \"with invalid valid shutdown\" do\n assert DynamicSupervisor.start_child(:not_used, %{\n id: 1,\n start: {Task, :start_link, [fn -> :ok end]},\n shutdown: -1\n }) == {:error, {:invalid_shutdown, -1}}\n end\n\n def start_link(:ok3), do: {:ok, spawn_link(fn -> Process.sleep(:infinity) end), :extra}\n def start_link(:ok2), do: {:ok, spawn_link(fn -> Process.sleep(:infinity) end)}\n def start_link(:error), do: {:error, :found}\n def start_link(:ignore), do: :ignore\n def start_link(:unknown), do: :unknown\n\n def start_link(:non_local, :throw), do: throw(:oops)\n def start_link(:non_local, :error), do: raise(\"oops\")\n def start_link(:non_local, :exit), do: exit(:oops)\n\n def start_link(:try_again, notify) do\n if Process.get(:try_again) do\n Process.put(:try_again, false)\n send(notify, {:try_again, false})\n {:error, :try_again}\n else\n Process.put(:try_again, true)\n send(notify, {:try_again, true})\n start_link(:ok2)\n end\n end\n\n def start_link(:restart, value) do\n if Process.get({:restart, value}) do\n start_link(value)\n else\n Process.put({:restart, value}, true)\n start_link(:ok2)\n end\n end\n end\n\n describe \"terminate/2\" do\n test \"terminates children with brutal kill\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n child = sleepy_worker(shutdown: :brutal_kill)\n assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)\n\n Process.monitor(child1)\n Process.monitor(child2)\n Process.monitor(child3)\n assert_kill(sup, :shutdown)\n assert_receive {:DOWN, _, :process, ^child1, :killed}\n assert_receive {:DOWN, _, :process, ^child2, :killed}\n assert_receive {:DOWN, _, :process, ^child3, :killed}\n end\n\n test \"terminates children with infinity shutdown\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n child = sleepy_worker(shutdown: :infinity)\n assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)\n\n Process.monitor(child1)\n Process.monitor(child2)\n Process.monitor(child3)\n assert_kill(sup, :shutdown)\n assert_receive {:DOWN, _, :process, ^child1, :shutdown}\n assert_receive {:DOWN, _, :process, ^child2, :shutdown}\n assert_receive {:DOWN, _, :process, ^child3, :shutdown}\n end\n\n test \"terminates children with infinity shutdown and abnormal reason\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n parent = self()\n\n fun = fn ->\n Process.flag(:trap_exit, true)\n send(parent, :ready)\n receive(do: (_ -> exit({:shutdown, :oops})))\n end\n\n child = Supervisor.child_spec({Task, fun}, shutdown: :infinity)\n assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)\n\n assert_receive :ready\n assert_receive :ready\n assert_receive :ready\n\n Process.monitor(child1)\n Process.monitor(child2)\n Process.monitor(child3)\n assert_kill(sup, :shutdown)\n\n assert_receive {:DOWN, _, :process, ^child1, {:shutdown, :oops}}\n assert_receive {:DOWN, _, :process, ^child2, {:shutdown, :oops}}\n assert_receive {:DOWN, _, :process, ^child3, {:shutdown, :oops}}\n end\n\n test \"terminates children with integer shutdown\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n child = sleepy_worker(shutdown: 1000)\n assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)\n\n Process.monitor(child1)\n Process.monitor(child2)\n Process.monitor(child3)\n assert_kill(sup, :shutdown)\n assert_receive {:DOWN, _, :process, ^child1, :shutdown}\n assert_receive {:DOWN, _, :process, ^child2, :shutdown}\n assert_receive {:DOWN, _, :process, ^child3, :shutdown}\n end\n\n test \"terminates children with integer shutdown and abnormal reason\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n parent = self()\n\n fun = fn ->\n Process.flag(:trap_exit, true)\n send(parent, :ready)\n receive(do: (_ -> exit({:shutdown, :oops})))\n end\n\n child = Supervisor.child_spec({Task, fun}, shutdown: 1000)\n assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)\n\n assert_receive :ready\n assert_receive :ready\n assert_receive :ready\n\n Process.monitor(child1)\n Process.monitor(child2)\n Process.monitor(child3)\n assert_kill(sup, :shutdown)\n\n assert_receive {:DOWN, _, :process, ^child1, {:shutdown, :oops}}\n assert_receive {:DOWN, _, :process, ^child2, {:shutdown, :oops}}\n assert_receive {:DOWN, _, :process, ^child3, {:shutdown, :oops}}\n end\n\n test \"terminates children with expired integer shutdown\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n parent = self()\n\n fun = fn ->\n Process.sleep(:infinity)\n end\n\n tmt = fn ->\n Process.flag(:trap_exit, true)\n send(parent, :ready)\n Process.sleep(:infinity)\n end\n\n child_fun = Supervisor.child_spec({Task, fun}, shutdown: 1)\n child_tmt = Supervisor.child_spec({Task, tmt}, shutdown: 1)\n assert {:ok, child1} = DynamicSupervisor.start_child(sup, child_fun)\n assert {:ok, child2} = DynamicSupervisor.start_child(sup, child_tmt)\n assert {:ok, child3} = DynamicSupervisor.start_child(sup, child_fun)\n\n assert_receive :ready\n Process.monitor(child1)\n Process.monitor(child2)\n Process.monitor(child3)\n assert_kill(sup, :shutdown)\n\n assert_receive {:DOWN, _, :process, ^child1, :shutdown}\n assert_receive {:DOWN, _, :process, ^child2, :killed}\n assert_receive {:DOWN, _, :process, ^child3, :shutdown}\n end\n\n test \"terminates children with permanent restart and normal reason\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n parent = self()\n\n fun = fn ->\n Process.flag(:trap_exit, true)\n send(parent, :ready)\n receive(do: (_ -> exit(:normal)))\n end\n\n child = Supervisor.child_spec({Task, fun}, shutdown: :infinity, restart: :permanent)\n assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)\n assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)\n\n assert_receive :ready\n assert_receive :ready\n assert_receive :ready\n\n Process.monitor(child1)\n Process.monitor(child2)\n Process.monitor(child3)\n assert_kill(sup, :shutdown)\n assert_receive {:DOWN, _, :process, ^child1, :normal}\n assert_receive {:DOWN, _, :process, ^child2, :normal}\n assert_receive {:DOWN, _, :process, ^child3, :normal}\n end\n\n test \"terminates with mixed children\" do\n Process.flag(:trap_exit, true)\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n assert {:ok, child1} =\n DynamicSupervisor.start_child(sup, sleepy_worker(shutdown: :infinity))\n\n assert {:ok, child2} =\n DynamicSupervisor.start_child(sup, sleepy_worker(shutdown: :brutal_kill))\n\n Process.monitor(child1)\n Process.monitor(child2)\n assert_kill(sup, :shutdown)\n assert_receive {:DOWN, _, :process, ^child1, :shutdown}\n assert_receive {:DOWN, _, :process, ^child2, :killed}\n end\n end\n\n describe \"terminate_child/2\" do\n test \"terminates child with brutal kill\" do\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n child = sleepy_worker(shutdown: :brutal_kill)\n assert {:ok, child_pid} = DynamicSupervisor.start_child(sup, child)\n\n Process.monitor(child_pid)\n assert :ok = DynamicSupervisor.terminate_child(sup, child_pid)\n assert_receive {:DOWN, _, :process, ^child_pid, :killed}\n\n assert {:error, :not_found} = DynamicSupervisor.terminate_child(sup, child_pid)\n assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(sup)\n end\n\n test \"terminates child with integer shutdown\" do\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)\n\n child = sleepy_worker(shutdown: 1000)\n assert {:ok, child_pid} = DynamicSupervisor.start_child(sup, child)\n\n Process.monitor(child_pid)\n assert :ok = DynamicSupervisor.terminate_child(sup, child_pid)\n assert_receive {:DOWN, _, :process, ^child_pid, :shutdown}\n\n assert {:error, :not_found} = DynamicSupervisor.terminate_child(sup, child_pid)\n assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(sup)\n end\n\n test \"terminates restarting child\" do\n {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 100_000)\n\n child = current_module_worker([:restart, :error], restart: :permanent)\n assert {:ok, child_pid} = DynamicSupervisor.start_child(sup, child)\n assert_kill(child_pid, :shutdown)\n assert :ok = DynamicSupervisor.terminate_child(sup, child_pid)\n\n assert {:error, :not_found} = DynamicSupervisor.terminate_child(sup, child_pid)\n assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(sup)\n end\n end\n\n defp sleepy_worker(opts \\\\ []) do\n mfa = {Task, :start_link, [Process, :sleep, [:infinity]]}\n Supervisor.child_spec(%{id: Task, start: mfa}, opts)\n end\n\n defp current_module_worker(args, opts \\\\ []) do\n Supervisor.child_spec(%{id: __MODULE__, start: {__MODULE__, :start_link, args}}, opts)\n end\n\n defp assert_kill(pid, reason) do\n ref = Process.monitor(pid)\n Process.exit(pid, reason)\n assert_receive {:DOWN, ^ref, _, _, _}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/enum_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule EnumTest do\n use ExUnit.Case, async: true\n doctest Enum\n\n defp assert_runs_enumeration_only_once(enum_fun) do\n enumerator =\n Stream.map([:element], fn element ->\n send(self(), element)\n element\n end)\n\n enum_fun.(enumerator)\n assert_received :element\n refute_received :element\n end\n\n describe \"zip_reduce/4\" do\n test \"two non lists\" do\n left = %{a: 1}\n right = %{b: 2}\n reducer = fn {_, x}, {_, y}, acc -> [x + y | acc] end\n assert Enum.zip_reduce(left, right, [], reducer) == [3]\n\n # Empty Left\n assert Enum.zip_reduce(%{}, right, [], reducer) == []\n\n # Empty Right\n assert Enum.zip_reduce(left, %{}, [], reducer) == []\n end\n\n test \"lists\" do\n assert Enum.zip_reduce([1, 2], [3, 4], 0, fn x, y, acc -> x + y + acc end) == 10\n assert Enum.zip_reduce([1, 2], [3, 4], [], fn x, y, acc -> [x + y | acc] end) == [6, 4]\n end\n\n test \"when left empty\" do\n assert Enum.zip_reduce([], [1, 2], 0, fn x, y, acc -> x + y + acc end) == 0\n end\n\n test \"when right empty\" do\n assert Enum.zip_reduce([1, 2], [], 0, fn x, y, acc -> x + y + acc end) == 0\n end\n end\n\n describe \"zip_reduce/3\" do\n test \"when enums empty\" do\n assert Enum.zip_reduce([], 0, fn _, acc -> acc end) == 0\n end\n\n test \"lists work\" do\n enums = [[1, 1], [2, 2], [3, 3]]\n result = Enum.zip_reduce(enums, [], fn elements, acc -> [List.to_tuple(elements) | acc] end)\n assert result == [{1, 2, 3}, {1, 2, 3}]\n end\n\n test \"mix and match\" do\n enums = [[1, 2], 3..4, [5, 6]]\n result = Enum.zip_reduce(enums, [], fn elements, acc -> [List.to_tuple(elements) | acc] end)\n assert result == [{2, 4, 6}, {1, 3, 5}]\n end\n end\n\n test \"all?/2\" do\n assert Enum.all?([2, 4, 6])\n refute Enum.all?([2, nil, 4])\n assert Enum.all?([])\n\n assert Enum.all?([2, 4, 6], fn x -> rem(x, 2) == 0 end)\n refute Enum.all?([2, 3, 4], fn x -> rem(x, 2) == 0 end)\n end\n\n test \"any?/2\" do\n refute Enum.any?([2, 4, 6], fn x -> rem(x, 2) == 1 end)\n assert Enum.any?([2, 3, 4], fn x -> rem(x, 2) == 1 end)\n\n refute Enum.any?([false, false, false])\n assert Enum.any?([false, true, false])\n\n assert Enum.any?([:foo, false, false])\n refute Enum.any?([false, nil, false])\n\n refute Enum.any?([])\n end\n\n test \"at/3\" do\n assert Enum.at([2, 4, 6], 0) == 2\n assert Enum.at([2, 4, 6], 2) == 6\n assert Enum.at([2, 4, 6], 4) == nil\n assert Enum.at([2, 4, 6], 4, :none) == :none\n assert Enum.at([2, 4, 6], -2) == 4\n assert Enum.at([2, 4, 6], -4) == nil\n end\n\n test \"chunk/3\" do\n enum = String.to_atom(\"Elixir.Enum\")\n assert enum.chunk(1..5, 2, 1) == Enum.chunk_every(1..5, 2, 1, :discard)\n end\n\n test \"chunk/4\" do\n enum = String.to_atom(\"Elixir.Enum\")\n assert enum.chunk(1..5, 2, 1, nil) == Enum.chunk_every(1..5, 2, 1, :discard)\n end\n\n test \"chunk_every/2\" do\n assert Enum.chunk_every([1, 2, 3, 4, 5], 2) == [[1, 2], [3, 4], [5]]\n end\n\n test \"chunk_every/4\" do\n assert Enum.chunk_every([1, 2, 3, 4, 5], 2, 2, [6]) == [[1, 2], [3, 4], [5, 6]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) == [[1, 2, 3], [3, 4, 5]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 2, 3, :discard) == [[1, 2], [4, 5]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, []) == [[1, 2, 3], [3, 4, 5], [5, 6]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 3, []) == [[1, 2, 3], [4, 5, 6]]\n assert Enum.chunk_every([1, 2, 3, 4, 5], 4, 4, 6..10) == [[1, 2, 3, 4], [5, 6, 7, 8]]\n assert Enum.chunk_every([1, 2, 3, 4, 5], 2, 3, []) == [[1, 2], [4, 5]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 2, 3, []) == [[1, 2], [4, 5]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6, 7], 2, 3, []) == [[1, 2], [4, 5], [7]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6, 7], 2, 3, [8]) == [[1, 2], [4, 5], [7, 8]]\n assert Enum.chunk_every([1, 2, 3, 4, 5, 6, 7], 2, 4, []) == [[1, 2], [5, 6]]\n end\n\n test \"chunk_by/2\" do\n assert Enum.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1)) ==\n [[1], [2, 2], [3], [4, 4, 6], [7, 7]]\n\n assert Enum.chunk_by([1, 2, 3, 4], fn _ -> true end) == [[1, 2, 3, 4]]\n assert Enum.chunk_by([], fn _ -> true end) == []\n assert Enum.chunk_by([1], fn _ -> true end) == [[1]]\n end\n\n test \"chunk_while/4\" do\n chunk_fun = fn i, acc ->\n cond do\n i > 10 ->\n {:halt, acc}\n\n rem(i, 2) == 0 ->\n {:cont, Enum.reverse([i | acc]), []}\n\n true ->\n {:cont, [i | acc]}\n end\n end\n\n after_fun = fn\n [] -> {:cont, []}\n acc -> {:cont, Enum.reverse(acc), []}\n end\n\n assert Enum.chunk_while([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [], chunk_fun, after_fun) ==\n [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]\n\n assert Enum.chunk_while(0..9, [], chunk_fun, after_fun) ==\n [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9]]\n\n assert Enum.chunk_while(0..10, [], chunk_fun, after_fun) ==\n [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]\n\n assert Enum.chunk_while(0..11, [], chunk_fun, after_fun) ==\n [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]\n\n assert Enum.chunk_while([5, 7, 9, 11], [], chunk_fun, after_fun) == [[5, 7, 9]]\n\n assert Enum.chunk_while([1, 2, 3, 5, 7], [], chunk_fun, after_fun) == [[1, 2], [3, 5, 7]]\n\n chunk_fn2 = fn\n -1, acc -> {:cont, acc, 0}\n i, acc -> {:cont, acc + i}\n end\n\n after_fn2 = fn acc -> {:cont, acc, 0} end\n\n assert Enum.chunk_while([1, -1, 2, 3, -1, 4, 5, 6], 0, chunk_fn2, after_fn2) == [1, 5, 15]\n end\n\n test \"concat/1\" do\n assert Enum.concat([[1, [2], 3], [4], [5, 6]]) == [1, [2], 3, 4, 5, 6]\n\n assert Enum.concat([[], []]) == []\n assert Enum.concat([[]]) == []\n assert Enum.concat([]) == []\n end\n\n test \"concat/2\" do\n assert Enum.concat([], [1]) == [1]\n assert Enum.concat([1, [2], 3], [4, 5]) == [1, [2], 3, 4, 5]\n\n assert Enum.concat([1, 2], 3..5) == [1, 2, 3, 4, 5]\n\n assert Enum.concat([], []) == []\n assert Enum.concat([], 1..3) == [1, 2, 3]\n\n assert Enum.concat(fn acc, _ -> acc end, [1]) == [1]\n end\n\n test \"count/1\" do\n assert Enum.count([1, 2, 3]) == 3\n assert Enum.count([]) == 0\n assert Enum.count([1, true, false, nil]) == 4\n end\n\n test \"count/2\" do\n assert Enum.count([1, 2, 3], fn x -> rem(x, 2) == 0 end) == 1\n assert Enum.count([], fn x -> rem(x, 2) == 0 end) == 0\n assert Enum.count([1, true, false, nil], & &1) == 2\n end\n\n test \"count_until/2\" do\n assert Enum.count_until([1, 2, 3], 2) == 2\n assert Enum.count_until([], 2) == 0\n assert Enum.count_until([1, 2], 2) == 2\n end\n\n test \"count_until/2 with streams\" do\n count_until_stream = fn list, limit -> list |> Stream.map(& &1) |> Enum.count_until(limit) end\n\n assert count_until_stream.([1, 2, 3], 2) == 2\n assert count_until_stream.([], 2) == 0\n assert count_until_stream.([1, 2], 2) == 2\n end\n\n test \"count_until/2 with invalid limit\" do\n assert_raise ArgumentError, \"expected limit to be greater than 0, got: 0\", fn ->\n Enum.count_until([1, 2, 3], 0)\n end\n\n assert_raise ArgumentError, \"expected limit to be greater than 0, got: -22\", fn ->\n Enum.count_until([1, 2, 3], -22)\n end\n end\n\n test \"count_until/3\" do\n assert Enum.count_until([1, 2, 3, 4, 5, 6], fn x -> rem(x, 2) == 0 end, 2) == 2\n assert Enum.count_until([1, 2], fn x -> rem(x, 2) == 0 end, 2) == 1\n assert Enum.count_until([1, 2, 3, 4], fn x -> rem(x, 2) == 0 end, 2) == 2\n assert Enum.count_until([], fn x -> rem(x, 2) == 0 end, 2) == 0\n end\n\n test \"count_until/3 with streams\" do\n count_until_stream = fn list, fun, limit ->\n list |> Stream.map(& &1) |> Enum.count_until(fun, limit)\n end\n\n assert count_until_stream.([1, 2, 3, 4, 5, 6], fn x -> rem(x, 2) == 0 end, 2) == 2\n assert count_until_stream.([1, 2], fn x -> rem(x, 2) == 0 end, 2) == 1\n assert count_until_stream.([1, 2, 3, 4], fn x -> rem(x, 2) == 0 end, 2) == 2\n assert count_until_stream.([], fn x -> rem(x, 2) == 0 end, 2) == 0\n end\n\n test \"count_until/3 with invalid limit\" do\n assert_raise ArgumentError, \"expected limit to be greater than 0, got: 0\", fn ->\n Enum.count_until([1, 2, 3], fn x -> rem(x, 2) == 0 end, 0)\n end\n\n assert_raise ArgumentError, \"expected limit to be greater than 0, got: -22\", fn ->\n Enum.count_until([1, 2, 3], fn x -> rem(x, 2) == 0 end, -22)\n end\n end\n\n test \"dedup/1\" do\n assert Enum.dedup([1, 1, 2, 1, 1, 2, 1]) == [1, 2, 1, 2, 1]\n assert Enum.dedup([2, 1, 1, 2, 1]) == [2, 1, 2, 1]\n assert Enum.dedup([1, 2, 3, 4]) == [1, 2, 3, 4]\n assert Enum.dedup([1, 1.0, 2.0, 2]) == [1, 1.0, 2.0, 2]\n assert Enum.dedup([]) == []\n assert Enum.dedup([nil, nil, true, {:value, true}]) == [nil, true, {:value, true}]\n assert Enum.dedup([nil]) == [nil]\n end\n\n test \"dedup/1 with streams\" do\n dedup_stream = fn list -> list |> Stream.map(& &1) |> Enum.dedup() end\n\n assert dedup_stream.([1, 1, 2, 1, 1, 2, 1]) == [1, 2, 1, 2, 1]\n assert dedup_stream.([2, 1, 1, 2, 1]) == [2, 1, 2, 1]\n assert dedup_stream.([1, 2, 3, 4]) == [1, 2, 3, 4]\n assert dedup_stream.([1, 1.0, 2.0, 2]) == [1, 1.0, 2.0, 2]\n assert dedup_stream.([]) == []\n assert dedup_stream.([nil, nil, true, {:value, true}]) == [nil, true, {:value, true}]\n assert dedup_stream.([nil]) == [nil]\n end\n\n test \"dedup_by/2\" do\n assert Enum.dedup_by([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end) ==\n [{1, :x}, {2, :y}, {1, :x}]\n\n assert Enum.dedup_by([5, 1, 2, 3, 2, 1], fn x -> x > 2 end) == [5, 1, 3, 2]\n end\n\n test \"drop/2\" do\n assert Enum.drop([1, 2, 3], 0) == [1, 2, 3]\n assert Enum.drop([1, 2, 3], 1) == [2, 3]\n assert Enum.drop([1, 2, 3], 2) == [3]\n assert Enum.drop([1, 2, 3], 3) == []\n assert Enum.drop([1, 2, 3], 4) == []\n assert Enum.drop([1, 2, 3], -1) == [1, 2]\n assert Enum.drop([1, 2, 3], -2) == [1]\n assert Enum.drop([1, 2, 3], -4) == []\n assert Enum.drop([], 3) == []\n end\n\n test \"drop/2 with streams\" do\n drop_stream = fn list, count -> list |> Stream.map(& &1) |> Enum.drop(count) end\n\n assert drop_stream.([1, 2, 3], 0) == [1, 2, 3]\n assert drop_stream.([1, 2, 3], 1) == [2, 3]\n assert drop_stream.([1, 2, 3], 2) == [3]\n assert drop_stream.([1, 2, 3], 3) == []\n assert drop_stream.([1, 2, 3], 4) == []\n assert drop_stream.([1, 2, 3], -1) == [1, 2]\n assert drop_stream.([1, 2, 3], -2) == [1]\n assert drop_stream.([1, 2, 3], -4) == []\n assert drop_stream.([], 3) == []\n end\n\n test \"drop_every/2\" do\n assert Enum.drop_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2) == [2, 4, 6, 8, 10]\n assert Enum.drop_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3) == [2, 3, 5, 6, 8, 9]\n assert Enum.drop_every([], 2) == []\n assert Enum.drop_every([1, 2], 2) == [2]\n assert Enum.drop_every([1, 2, 3], 0) == [1, 2, 3]\n\n assert_raise FunctionClauseError, fn ->\n Enum.drop_every([1, 2, 3], -1)\n end\n end\n\n test \"drop_while/2\" do\n assert Enum.drop_while([1, 2, 3, 4, 3, 2, 1], fn x -> x <= 3 end) == [4, 3, 2, 1]\n assert Enum.drop_while([1, 2, 3], fn _ -> false end) == [1, 2, 3]\n assert Enum.drop_while([1, 2, 3], fn x -> x <= 3 end) == []\n assert Enum.drop_while([], fn _ -> false end) == []\n end\n\n test \"each/2\" do\n try do\n assert Enum.each([], fn x -> x end) == :ok\n assert Enum.each([1, 2, 3], fn x -> Process.put(:enum_test_each, x * 2) end) == :ok\n assert Process.get(:enum_test_each) == 6\n after\n Process.delete(:enum_test_each)\n end\n end\n\n test \"empty?/1\" do\n assert Enum.empty?([])\n assert Enum.empty?(%{})\n refute Enum.empty?([1, 2, 3])\n refute Enum.empty?(%{one: 1})\n refute Enum.empty?(1..3)\n\n assert Stream.take([1], 0) |> Enum.empty?()\n refute Stream.take([1], 1) |> Enum.empty?()\n end\n\n test \"fetch/2\" do\n assert Enum.fetch([66], 0) == {:ok, 66}\n assert Enum.fetch([66], -1) == {:ok, 66}\n assert Enum.fetch([66], 1) == :error\n assert Enum.fetch([66], -2) == :error\n\n assert Enum.fetch([2, 4, 6], 0) == {:ok, 2}\n assert Enum.fetch([2, 4, 6], -1) == {:ok, 6}\n assert Enum.fetch([2, 4, 6], 2) == {:ok, 6}\n assert Enum.fetch([2, 4, 6], 4) == :error\n assert Enum.fetch([2, 4, 6], -2) == {:ok, 4}\n assert Enum.fetch([2, 4, 6], -4) == :error\n\n assert Enum.fetch([], 0) == :error\n assert Enum.fetch([], 1) == :error\n end\n\n test \"fetch!/2\" do\n assert Enum.fetch!([2, 4, 6], 0) == 2\n assert Enum.fetch!([2, 4, 6], 2) == 6\n assert Enum.fetch!([2, 4, 6], -2) == 4\n\n assert_raise Enum.OutOfBoundsError, fn ->\n Enum.fetch!([2, 4, 6], 4)\n end\n\n assert_raise Enum.OutOfBoundsError, fn ->\n Enum.fetch!([2, 4, 6], -4)\n end\n end\n\n test \"filter/2\" do\n assert Enum.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end) == [2]\n assert Enum.filter([2, 4, 6], fn x -> rem(x, 2) == 0 end) == [2, 4, 6]\n\n assert Enum.filter([1, 2, false, 3, nil], & &1) == [1, 2, 3]\n assert Enum.filter([1, 2, 3], &match?(1, &1)) == [1]\n assert Enum.filter([1, 2, 3], &match?(x when x < 3, &1)) == [1, 2]\n assert Enum.filter([1, 2, 3], fn _ -> true end) == [1, 2, 3]\n end\n\n test \"find/3\" do\n assert Enum.find([2, 4, 6], fn x -> rem(x, 2) == 1 end) == nil\n assert Enum.find([2, 4, 6], 0, fn x -> rem(x, 2) == 1 end) == 0\n assert Enum.find([2, 3, 4], fn x -> rem(x, 2) == 1 end) == 3\n end\n\n test \"find_index/2\" do\n assert Enum.find_index([2, 4, 6], fn x -> rem(x, 2) == 1 end) == nil\n assert Enum.find_index([2, 3, 4], fn x -> rem(x, 2) == 1 end) == 1\n assert Stream.take(1..3, 3) |> Enum.find_index(fn _ -> false end) == nil\n assert Stream.take(1..6, 6) |> Enum.find_index(fn x -> x == 5 end) == 4\n end\n\n test \"find_value/2\" do\n assert Enum.find_value([2, 4, 6], fn x -> rem(x, 2) == 1 end) == nil\n assert Enum.find_value([2, 4, 6], 0, fn x -> rem(x, 2) == 1 end) == 0\n assert Enum.find_value([2, 3, 4], fn x -> rem(x, 2) == 1 end)\n end\n\n test \"flat_map/2\" do\n assert Enum.flat_map([], fn x -> [x, x] end) == []\n assert Enum.flat_map([1, 2, 3], fn x -> [x, x] end) == [1, 1, 2, 2, 3, 3]\n assert Enum.flat_map([1, 2, 3], fn x -> x..(x + 1) end) == [1, 2, 2, 3, 3, 4]\n assert Enum.flat_map([1, 2, 3], fn x -> Stream.duplicate(x, 2) end) == [1, 1, 2, 2, 3, 3]\n end\n\n test \"flat_map/2 with streams\" do\n flat_map_stream = fn list, fun -> list |> Stream.map(& &1) |> Enum.flat_map(fun) end\n\n assert flat_map_stream.([], fn x -> [x, x] end) == []\n assert flat_map_stream.([1, 2, 3], fn x -> [x, x] end) == [1, 1, 2, 2, 3, 3]\n assert flat_map_stream.([1, 2, 3], fn x -> x..(x + 1) end) == [1, 2, 2, 3, 3, 4]\n assert flat_map_stream.([1, 2, 3], fn x -> Stream.duplicate(x, 2) end) == [1, 1, 2, 2, 3, 3]\n end\n\n test \"flat_map_reduce/3\" do\n assert Enum.flat_map_reduce([1, 2, 3], 0, &{[&1, &2], &1 + &2}) == {[1, 0, 2, 1, 3, 3], 6}\n end\n\n test \"frequencies/1\" do\n assert Enum.frequencies([]) == %{}\n assert Enum.frequencies(~w{a c a a c b}) == %{\"a\" => 3, \"b\" => 1, \"c\" => 2}\n end\n\n test \"frequencies_by/2\" do\n assert Enum.frequencies_by([], fn _ -> raise \"oops\" end) == %{}\n assert Enum.frequencies_by([12, 7, 6, 5, 1], &Integer.mod(&1, 2)) == %{0 => 2, 1 => 3}\n end\n\n test \"group_by/3\" do\n assert Enum.group_by([], fn _ -> raise \"oops\" end) == %{}\n assert Enum.group_by([1, 2, 3], &rem(&1, 2)) == %{0 => [2], 1 => [1, 3]}\n end\n\n test \"intersperse/2\" do\n assert Enum.intersperse([], true) == []\n assert Enum.intersperse([1], true) == [1]\n assert Enum.intersperse([1, 2, 3], true) == [1, true, 2, true, 3]\n\n assert Enum.intersperse(.., true) == []\n assert Enum.intersperse(1..1, true) == [1]\n assert Enum.intersperse(1..3, true) == [1, true, 2, true, 3]\n end\n\n test \"into/2\" do\n assert Enum.into([a: 1, b: 2], %{}) == %{a: 1, b: 2}\n assert Enum.into([a: 1, b: 2], %{c: 3}) == %{a: 1, b: 2, c: 3}\n assert Enum.into(MapSet.new(a: 1, b: 2), %{}) == %{a: 1, b: 2}\n assert Enum.into(MapSet.new(a: 1, b: 2), %{c: 3}) == %{a: 1, b: 2, c: 3}\n assert Enum.into(%{a: 1, b: 2}, []) |> Enum.sort() == [a: 1, b: 2]\n assert Enum.into(1..3, []) == [1, 2, 3]\n assert Enum.into([\"H\", \"i\"], \"\") == \"Hi\"\n\n assert Enum.into([a: 1, b: 2], MapSet.new()) == MapSet.new(a: 1, b: 2)\n assert Enum.into(%{a: 1, b: 2}, MapSet.new()) == MapSet.new(a: 1, b: 2)\n assert Enum.into([a: 1, b: 2], MapSet.new(a: 1, c: 3)) == MapSet.new(a: 1, b: 2, c: 3)\n end\n\n test \"into/2 exceptions\" do\n assert_raise ArgumentError,\n \"collecting into a map requires {key, value} tuples, got: 1\",\n fn -> Enum.into(1..10, %{}) end\n\n assert_raise ArgumentError, \"collecting into a binary requires a bitstring, got: 1\", fn ->\n Enum.into(1..10, <<>>)\n end\n\n assert_raise ArgumentError, \"collecting into a bitstring requires a bitstring, got: 1\", fn ->\n Enum.into(1..10, <<1::1>>)\n end\n end\n\n test \"into/3\" do\n assert Enum.into([1, 2, 3], [], fn x -> x * 2 end) == [2, 4, 6]\n assert Enum.into([1, 2, 3], \"numbers: \", &to_string/1) == \"numbers: 123\"\n\n assert Enum.into([1, 2, 3], MapSet.new(), &(&1 * 2)) == MapSet.new([2, 4, 6])\n assert Enum.into([1, 2, 3], MapSet.new([0, 2]), &(&1 * 2)) == MapSet.new([0, 2, 4, 6])\n\n assert_raise MatchError, fn ->\n Enum.into([2, 3], %{a: 1}, & &1)\n end\n end\n\n test \"join/2\" do\n assert Enum.join([], \" = \") == \"\"\n assert Enum.join([1, 2, 3], \" = \") == \"1 = 2 = 3\"\n assert Enum.join([1, \"2\", 3], \" = \") == \"1 = 2 = 3\"\n assert Enum.join([1, 2, 3]) == \"123\"\n assert Enum.join([\"\", \"\", 1, 2, \"\", 3, \"\", \"\\n\"], \";\") == \";;1;2;;3;;\\n\"\n assert Enum.join([\"\"]) == \"\"\n\n assert Enum.join(fn acc, _ -> acc end, \".\") == \"\"\n end\n\n test \"map/2\" do\n assert Enum.map([], fn x -> x * 2 end) == []\n assert Enum.map([1, 2, 3], fn x -> x * 2 end) == [2, 4, 6]\n end\n\n test \"map_every/3\" do\n assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2, fn x -> x * 2 end) ==\n [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]\n\n assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3, fn x -> x * 2 end) ==\n [2, 2, 3, 8, 5, 6, 14, 8, 9, 20]\n\n assert Enum.map_every([], 2, fn x -> x * 2 end) == []\n assert Enum.map_every([1, 2], 2, fn x -> x * 2 end) == [2, 2]\n\n assert Enum.map_every([1, 2, 3], 0, fn _x -> raise \"should not be invoked\" end) ==\n [1, 2, 3]\n\n assert Enum.map_every(1..3, 1, fn x -> x * 2 end) == [2, 4, 6]\n\n assert_raise FunctionClauseError, fn ->\n Enum.map_every([1, 2, 3], -1, fn x -> x * 2 end)\n end\n\n assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 9, fn x -> x + 1000 end) ==\n [1001, 2, 3, 4, 5, 6, 7, 8, 9, 1010]\n\n assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10, fn x -> x + 1000 end) ==\n [1001, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\n assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 100, fn x -> x + 1000 end) ==\n [1001, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n end\n\n test \"map_intersperse/3\" do\n assert Enum.map_intersperse([], :a, &(&1 * 2)) == []\n assert Enum.map_intersperse([1], :a, &(&1 * 2)) == [2]\n assert Enum.map_intersperse([1, 2, 3], :a, &(&1 * 2)) == [2, :a, 4, :a, 6]\n end\n\n test \"map_join/3\" do\n assert Enum.map_join([], \" = \", &(&1 * 2)) == \"\"\n assert Enum.map_join([1, 2, 3], \" = \", &(&1 * 2)) == \"2 = 4 = 6\"\n assert Enum.map_join([1, 2, 3], &(&1 * 2)) == \"246\"\n assert Enum.map_join([\"\", \"\", 1, 2, \"\", 3, \"\", \"\\n\"], \";\", & &1) == \";;1;2;;3;;\\n\"\n assert Enum.map_join([\"\"], \"\", & &1) == \"\"\n assert Enum.map_join(fn acc, _ -> acc end, \".\", &(&1 + 0)) == \"\"\n end\n\n test \"map_reduce/3\" do\n assert Enum.map_reduce([], 1, fn x, acc -> {x * 2, x + acc} end) == {[], 1}\n assert Enum.map_reduce([1, 2, 3], 1, fn x, acc -> {x * 2, x + acc} end) == {[2, 4, 6], 7}\n end\n\n test \"max/1\" do\n assert Enum.max([1]) == 1\n assert Enum.max([1, 2, 3]) == 3\n assert Enum.max([1, [], :a, {}]) == []\n\n assert Enum.max([1, 1.0]) === 1\n assert Enum.max([1.0, 1]) === 1.0\n\n assert_raise Enum.EmptyError, fn ->\n Enum.max([])\n end\n end\n\n test \"max/2 with empty fallback\" do\n assert Enum.max([], fn -> 0 end) === 0\n assert Enum.max([1, 2], fn -> 0 end) === 2\n end\n\n test \"max/2 with stable sorting\" do\n assert Enum.max([1, 1.0], &>=/2) === 1\n assert Enum.max([1.0, 1], &>=/2) === 1.0\n assert Enum.max([1, 1.0], &>/2) === 1.0\n assert Enum.max([1.0, 1], &>/2) === 1\n end\n\n test \"max/2 with module\" do\n assert Enum.max([~D[2019-01-01], ~D[2020-01-01]], Date) === ~D[2020-01-01]\n end\n\n test \"max/3\" do\n assert Enum.max([1], &>=/2, fn -> nil end) == 1\n assert Enum.max([1, 2, 3], &>=/2, fn -> nil end) == 3\n assert Enum.max([1, [], :a, {}], &>=/2, fn -> nil end) == []\n assert Enum.max([], &>=/2, fn -> :empty_value end) == :empty_value\n assert Enum.max(%{}, &>=/2, fn -> :empty_value end) == :empty_value\n assert_runs_enumeration_only_once(&Enum.max(&1, fn a, b -> a >= b end, fn -> nil end))\n end\n\n test \"max_by/2\" do\n assert Enum.max_by([\"a\", \"aa\", \"aaa\"], fn x -> String.length(x) end) == \"aaa\"\n\n assert Enum.max_by([1, 1.0], & &1) === 1\n assert Enum.max_by([1.0, 1], & &1) === 1.0\n\n assert_raise Enum.EmptyError, fn ->\n Enum.max_by([], fn x -> String.length(x) end)\n end\n\n assert_raise Enum.EmptyError, fn ->\n Enum.max_by(%{}, & &1)\n end\n end\n\n test \"max_by/3 with stable sorting\" do\n assert Enum.max_by([1, 1.0], & &1, &>=/2) === 1\n assert Enum.max_by([1.0, 1], & &1, &>=/2) === 1.0\n assert Enum.max_by([1, 1.0], & &1, &>/2) === 1.0\n assert Enum.max_by([1.0, 1], & &1, &>/2) === 1\n end\n\n test \"max_by/3 with module\" do\n users = [%{id: 1, date: ~D[2019-01-01]}, %{id: 2, date: ~D[2020-01-01]}]\n assert Enum.max_by(users, & &1.date, Date).id == 2\n\n users = [%{id: 1, date: ~D[2020-01-01]}, %{id: 2, date: ~D[2020-01-01]}]\n assert Enum.max_by(users, & &1.date, Date).id == 1\n end\n\n test \"max_by/4\" do\n assert Enum.max_by([\"a\", \"aa\", \"aaa\"], fn x -> String.length(x) end, &>=/2, fn -> nil end) ==\n \"aaa\"\n\n assert Enum.max_by([], fn x -> String.length(x) end, &>=/2, fn -> :empty_value end) ==\n :empty_value\n\n assert Enum.max_by(%{}, & &1, &>=/2, fn -> :empty_value end) == :empty_value\n assert Enum.max_by(%{}, & &1, &>=/2, fn -> {:a, :tuple} end) == {:a, :tuple}\n\n assert_runs_enumeration_only_once(\n &Enum.max_by(&1, fn e -> e end, fn a, b -> a >= b end, fn -> nil end)\n )\n end\n\n test \"member?/2\" do\n assert Enum.member?([1, 2, 3], 2)\n refute Enum.member?([], 0)\n refute Enum.member?([1, 2, 3], 0)\n end\n\n test \"min/1\" do\n assert Enum.min([1]) == 1\n assert Enum.min([1, 2, 3]) == 1\n assert Enum.min([[], :a, {}]) == :a\n\n assert Enum.min([1, 1.0]) === 1\n assert Enum.min([1.0, 1]) === 1.0\n\n assert_raise Enum.EmptyError, fn ->\n Enum.min([])\n end\n end\n\n test \"min/2 with empty fallback\" do\n assert Enum.min([], fn -> 0 end) === 0\n assert Enum.min([1, 2], fn -> 0 end) === 1\n end\n\n test \"min/2 with stable sorting\" do\n assert Enum.min([1, 1.0], &<=/2) === 1\n assert Enum.min([1.0, 1], &<=/2) === 1.0\n assert Enum.min([1, 1.0], & nil end) == 1\n assert Enum.min([1, 2, 3], &<=/2, fn -> nil end) == 1\n assert Enum.min([[], :a, {}], &<=/2, fn -> nil end) == :a\n assert Enum.min([], &<=/2, fn -> :empty_value end) == :empty_value\n assert Enum.min(%{}, &<=/2, fn -> :empty_value end) == :empty_value\n assert_runs_enumeration_only_once(&Enum.min(&1, fn a, b -> a <= b end, fn -> nil end))\n end\n\n test \"min_by/2\" do\n assert Enum.min_by([\"a\", \"aa\", \"aaa\"], fn x -> String.length(x) end) == \"a\"\n\n assert Enum.min_by([1, 1.0], & &1) === 1\n assert Enum.min_by([1.0, 1], & &1) === 1.0\n\n assert_raise Enum.EmptyError, fn ->\n Enum.min_by([], fn x -> String.length(x) end)\n end\n\n assert_raise Enum.EmptyError, fn ->\n Enum.min_by(%{}, & &1)\n end\n end\n\n test \"min_by/3 with stable sorting\" do\n assert Enum.min_by([1, 1.0], & &1, &<=/2) === 1\n assert Enum.min_by([1.0, 1], & &1, &<=/2) === 1.0\n assert Enum.min_by([1, 1.0], & &1, & String.length(x) end, &<=/2, fn -> nil end) ==\n \"a\"\n\n assert Enum.min_by([], fn x -> String.length(x) end, &<=/2, fn -> :empty_value end) ==\n :empty_value\n\n assert Enum.min_by(%{}, & &1, &<=/2, fn -> :empty_value end) == :empty_value\n assert Enum.min_by(%{}, & &1, &<=/2, fn -> {:a, :tuple} end) == {:a, :tuple}\n\n assert_runs_enumeration_only_once(\n &Enum.min_by(&1, fn e -> e end, fn a, b -> a <= b end, fn -> nil end)\n )\n end\n\n test \"min_max/1\" do\n assert Enum.min_max([1]) == {1, 1}\n assert Enum.min_max([2, 3, 1]) == {1, 3}\n assert Enum.min_max([[], :a, {}]) == {:a, []}\n\n assert Enum.min_max([1, 1.0]) === {1, 1}\n assert Enum.min_max([1.0, 1]) === {1.0, 1.0}\n\n assert_raise Enum.EmptyError, fn ->\n Enum.min_max([])\n end\n end\n\n test \"min_max/2\" do\n assert Enum.min_max([1], fn -> nil end) == {1, 1}\n assert Enum.min_max([2, 3, 1], fn -> nil end) == {1, 3}\n assert Enum.min_max([[], :a, {}], fn -> nil end) == {:a, []}\n assert Enum.min_max([], fn -> {:empty_min, :empty_max} end) == {:empty_min, :empty_max}\n assert Enum.min_max(%{}, fn -> {:empty_min, :empty_max} end) == {:empty_min, :empty_max}\n assert_runs_enumeration_only_once(&Enum.min_max(&1, fn -> nil end))\n end\n\n test \"min_max/3\" do\n dates = [~D[2020-01-01], ~D[2019-01-01]]\n\n assert Enum.min_max(dates, Date) ==\n {~D[2019-01-01], ~D[2020-01-01]}\n\n assert Enum.min_max([~D[2000-01-01]], Date) ==\n {~D[2000-01-01], ~D[2000-01-01]}\n\n assert Enum.min_max([3, 1, 2], &>/2, fn -> nil end) ==\n {3, 1}\n\n assert Enum.min_max([], &>/2, fn -> {:no_min, :no_max} end) ==\n {:no_min, :no_max}\n\n assert Enum.min_max(%{}, &>/2, fn -> {:no_min, :no_max} end) ==\n {:no_min, :no_max}\n\n assert Enum.min_max(1..5, &>/2, fn -> {:no_min, :no_max} end) ==\n {5, 1}\n\n assert_runs_enumeration_only_once(&Enum.min_max(&1, fn a, b -> a > b end, fn -> nil end))\n end\n\n test \"min_max_by/2\" do\n assert Enum.min_max_by([\"aaa\", \"a\", \"aa\"], fn x -> String.length(x) end) == {\"a\", \"aaa\"}\n\n assert Enum.min_max_by([1, 1.0], & &1) === {1, 1}\n assert Enum.min_max_by([1.0, 1], & &1) === {1.0, 1.0}\n\n assert_raise Enum.EmptyError, fn ->\n Enum.min_max_by([], fn x -> String.length(x) end)\n end\n end\n\n test \"min_max_by/3\" do\n assert Enum.min_max_by([\"aaa\", \"a\", \"aa\"], fn x -> String.length(x) end, fn -> nil end) ==\n {\"a\", \"aaa\"}\n\n assert Enum.min_max_by([], fn x -> String.length(x) end, fn -> {:no_min, :no_max} end) ==\n {:no_min, :no_max}\n\n assert Enum.min_max_by(%{}, fn x -> String.length(x) end, fn -> {:no_min, :no_max} end) ==\n {:no_min, :no_max}\n\n assert Enum.min_max_by([\"aaa\", \"a\", \"aa\"], fn x -> String.length(x) end, &>/2) == {\"aaa\", \"a\"}\n\n assert_runs_enumeration_only_once(&Enum.min_max_by(&1, fn x -> x end, fn -> nil end))\n end\n\n test \"min_max_by/4\" do\n users = [%{id: 1, date: ~D[2019-01-01]}, %{id: 2, date: ~D[2020-01-01]}]\n\n assert Enum.min_max_by(users, & &1.date, Date) ==\n {%{id: 1, date: ~D[2019-01-01]}, %{id: 2, date: ~D[2020-01-01]}}\n\n assert Enum.min_max_by([\"aaa\", \"a\", \"aa\"], fn x -> String.length(x) end, &>/2, fn -> nil end) ==\n {\"aaa\", \"a\"}\n\n assert Enum.min_max_by([], fn x -> String.length(x) end, &>/2, fn -> {:no_min, :no_max} end) ==\n {:no_min, :no_max}\n\n assert Enum.min_max_by(%{}, fn x -> String.length(x) end, &>/2, fn -> {:no_min, :no_max} end) ==\n {:no_min, :no_max}\n\n assert_runs_enumeration_only_once(\n &Enum.min_max_by(&1, fn x -> x end, fn a, b -> a > b end, fn -> nil end)\n )\n end\n\n test \"split_with/2\" do\n assert Enum.split_with([], fn x -> rem(x, 2) == 0 end) == {[], []}\n assert Enum.split_with([1, 2, 3], fn x -> rem(x, 2) == 0 end) == {[2], [1, 3]}\n assert Enum.split_with([2, 4, 6], fn x -> rem(x, 2) == 0 end) == {[2, 4, 6], []}\n\n assert Enum.split_with(1..5, fn x -> rem(x, 2) == 0 end) == {[2, 4], [1, 3, 5]}\n assert Enum.split_with(-3..0, fn x -> x > 0 end) == {[], [-3, -2, -1, 0]}\n\n assert Enum.split_with(%{}, fn x -> rem(x, 2) == 0 end) == {[], []}\n\n assert Enum.split_with(%{a: 1, b: 2}, fn {_k, v} -> rem(v, 2) == 0 end) ==\n {[b: 2], [a: 1]}\n\n assert Enum.split_with(%{b: 2, d: 4, f: 6}, fn {_k, v} -> rem(v, 2) == 0 end) ==\n {Map.to_list(%{b: 2, d: 4, f: 6}), []}\n end\n\n test \"random/1\" do\n # corner cases, independent of the seed\n assert_raise Enum.EmptyError, fn -> Enum.random([]) end\n assert Enum.random([1]) == 1\n\n # set a fixed seed so the test can be deterministic\n # please note the order of following assertions is important\n seed1 = {1406, 407_414, 139_258}\n seed2 = {1306, 421_106, 567_597}\n :rand.seed(:exsss, seed1)\n assert Enum.random([1, 2]) == 1\n assert Enum.random([1, 2]) == 2\n :rand.seed(:exsss, seed1)\n assert Enum.random([1, 2]) == 1\n assert Enum.random([1, 2, 3]) == 1\n assert Enum.random([1, 2, 3, 4]) == 2\n assert Enum.random([1, 2, 3, 4, 5]) == 3\n :rand.seed(:exsss, seed2)\n assert Enum.random([1, 2]) == 1\n assert Enum.random([1, 2, 3]) == 2\n assert Enum.random([1, 2, 3, 4]) == 4\n assert Enum.random([1, 2, 3, 4, 5]) == 3\n end\n\n test \"random/1 with streams\" do\n random_stream = fn list -> list |> Stream.map(& &1) |> Enum.random() end\n\n assert_raise Enum.EmptyError, fn -> random_stream.([]) end\n assert random_stream.([1]) == 1\n\n seed = {1406, 407_414, 139_258}\n :rand.seed(:exsss, seed)\n\n assert random_stream.([1, 2]) == 2\n assert random_stream.([1, 2, 3]) == 3\n assert random_stream.([1, 2, 3, 4]) == 1\n assert random_stream.([1, 2, 3, 4, 5]) == 3\n end\n\n test \"reduce/2\" do\n assert Enum.reduce([1, 2, 3], fn x, acc -> x + acc end) == 6\n\n assert_raise Enum.EmptyError, fn ->\n Enum.reduce([], fn x, acc -> x + acc end)\n end\n\n assert_raise Enum.EmptyError, fn ->\n Enum.reduce(%{}, fn _, acc -> acc end)\n end\n end\n\n test \"reduce/3\" do\n assert Enum.reduce([], 1, fn x, acc -> x + acc end) == 1\n assert Enum.reduce([1, 2, 3], 1, fn x, acc -> x + acc end) == 7\n end\n\n test \"reduce/3 with streams\" do\n reduce_stream = fn list, acc, fun -> list |> Stream.map(& &1) |> Enum.reduce(acc, fun) end\n\n assert reduce_stream.([], 1, fn x, acc -> x + acc end) == 1\n assert reduce_stream.([1, 2, 3], 1, fn x, acc -> x + acc end) == 7\n end\n\n test \"reduce_while/3\" do\n assert Enum.reduce_while([1, 2, 3], 1, fn i, acc -> {:cont, acc + i} end) == 7\n assert Enum.reduce_while([1, 2, 3], 1, fn _i, acc -> {:halt, acc} end) == 1\n assert Enum.reduce_while([], 0, fn _i, acc -> {:cont, acc} end) == 0\n end\n\n test \"reject/2\" do\n assert Enum.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end) == [1, 3]\n assert Enum.reject([2, 4, 6], fn x -> rem(x, 2) == 0 end) == []\n assert Enum.reject([1, true, nil, false, 2], & &1) == [nil, false]\n end\n\n test \"reverse/1\" do\n assert Enum.reverse([]) == []\n assert Enum.reverse([1, 2, 3]) == [3, 2, 1]\n assert Enum.reverse([5..5]) == [5..5]\n end\n\n test \"reverse/2\" do\n assert Enum.reverse([1, 2, 3], [4, 5, 6]) == [3, 2, 1, 4, 5, 6]\n assert Enum.reverse([1, 2, 3], []) == [3, 2, 1]\n assert Enum.reverse([5..5], [5]) == [5..5, 5]\n end\n\n test \"reverse_slice/3\" do\n assert Enum.reverse_slice([], 1, 2) == []\n assert Enum.reverse_slice([1, 2, 3], 0, 0) == [1, 2, 3]\n assert Enum.reverse_slice([1, 2, 3], 0, 1) == [1, 2, 3]\n assert Enum.reverse_slice([1, 2, 3], 0, 2) == [2, 1, 3]\n assert Enum.reverse_slice([1, 2, 3], 0, 20_000_000) == [3, 2, 1]\n assert Enum.reverse_slice([1, 2, 3], 100, 2) == [1, 2, 3]\n assert Enum.reverse_slice([1, 2, 3], 10, 10) == [1, 2, 3]\n end\n\n describe \"slide/3\" do\n test \"on an empty enum produces an empty list\" do\n for enum <- [[], %{}, 0..-1//1, MapSet.new()] do\n assert Enum.slide(enum, 0..0, 0) == []\n assert Enum.slide(enum, 1..1, 2) == []\n end\n end\n\n test \"on a single-element enumerable is the same as transforming to list\" do\n for enum <- [[\"foo\"], [1], [%{foo: \"bar\"}], %{foo: :bar}, MapSet.new([\"foo\"]), 1..1] do\n assert Enum.slide(enum, 0..0, 0) == Enum.to_list(enum)\n end\n end\n\n test \"moves a single element\" do\n for zero_to_20 <- [0..20, Enum.to_list(0..20)] do\n expected_numbers = Enum.flat_map([0..7, [14], 8..13, 15..20], &Enum.to_list/1)\n assert Enum.slide(zero_to_20, 14..14, 8) == expected_numbers\n end\n\n assert Enum.slide([:a, :b, :c, :d, :e, :f], 3..3, 2) == [:a, :b, :d, :c, :e, :f]\n assert Enum.slide([:a, :b, :c, :d, :e, :f], 3, 3) == [:a, :b, :c, :d, :e, :f]\n end\n\n test \"on a subsection of a list reorders the range correctly\" do\n for zero_to_20 <- [0..20, Enum.to_list(0..20)] do\n expected_numbers = Enum.flat_map([0..7, 14..18, 8..13, 19..20], &Enum.to_list/1)\n assert Enum.slide(zero_to_20, 14..18, 8) == expected_numbers\n end\n\n assert Enum.slide([:a, :b, :c, :d, :e, :f], 3..4, 2) == [:a, :b, :d, :e, :c, :f]\n end\n\n test \"handles negative indices\" do\n make_negative_range = fn first..last//1, length ->\n (first - length)..(last - length)//1\n end\n\n test_specs = [\n {[], 0..0, 0},\n {[1], 0..0, 0},\n {[-2, 1], 1..1, 1},\n {[4, -3, 2, -1], 3..3, 2},\n {[-5, -3, 4, 4, 5], 0..2, 3},\n {[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 4..7, 9},\n {[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 4..7, 0}\n ]\n\n for {list, range, insertion_point} <- test_specs do\n negative_range = make_negative_range.(range, length(list))\n\n assert Enum.slide(list, negative_range, insertion_point) ==\n Enum.slide(list, range, insertion_point)\n end\n end\n\n test \"handles mixed positive and negative indices\" do\n for zero_to_20 <- [0..20, Enum.to_list(0..20)] do\n assert Enum.slide(zero_to_20, -6..-1, 8) ==\n Enum.slide(zero_to_20, 15..20, 8)\n\n assert Enum.slide(zero_to_20, 15..-1//1, 8) ==\n Enum.slide(zero_to_20, 15..20, 8)\n\n assert Enum.slide(zero_to_20, -6..20, 8) ==\n Enum.slide(zero_to_20, 15..20, 8)\n\n assert Enum.slide(zero_to_20, -100..5, 8) ==\n Enum.slide(zero_to_20, 0..5, 8)\n end\n end\n\n test \"raises an error when the step is not exactly 1\" do\n slide_ranges_that_should_fail = [2..10//2, 8..-1//-1, 10..2//-1, 10..4//-2, -1..-8//-1]\n\n for zero_to_20 <- [0..20, Enum.to_list(0..20)],\n range_that_should_fail <- slide_ranges_that_should_fail do\n assert_raise(ArgumentError, fn ->\n Enum.slide(zero_to_20, range_that_should_fail, 1)\n end)\n end\n end\n\n test \"doesn't change the order when the first and middle indices match\" do\n for zero_to_20 <- [0..20, Enum.to_list(0..20)] do\n assert Enum.slide(zero_to_20, 8..18, 8) == Enum.to_list(0..20)\n end\n\n assert Enum.slide([:a, :b, :c, :d, :e, :f], 1..3, 1) == [:a, :b, :c, :d, :e, :f]\n end\n\n test \"on the whole of an enumerable reorders it correctly\" do\n for zero_to_20 <- [0..20, Enum.to_list(0..20)] do\n expected_numbers = Enum.flat_map([10..20, 0..9], &Enum.to_list/1)\n assert Enum.slide(zero_to_20, 10..20, 0) == expected_numbers\n end\n\n assert Enum.slide([:a, :b, :c, :d, :e, :f], 4..5, 0) == [:e, :f, :a, :b, :c, :d]\n end\n\n test \"raises when the insertion point is inside the range\" do\n for zero_to_20 <- [0..20, Enum.to_list(0..20)] do\n assert_raise ArgumentError, fn ->\n Enum.slide(zero_to_20, 10..18, 14)\n end\n end\n end\n\n test \"accepts range starts that are off the end of the enum, returning the input list\" do\n assert Enum.slide([], 1..5, 0) == []\n\n for zero_to_20 <- [0..20, Enum.to_list(0..20)] do\n assert Enum.slide(zero_to_20, 21..25, 3) == Enum.to_list(0..20)\n end\n end\n\n test \"accepts range ends that are off the end of the enum, truncating the moved range\" do\n for zero_to_10 <- [0..10, Enum.to_list(0..10)] do\n assert Enum.slide(zero_to_10, 8..15, 4) == Enum.slide(zero_to_10, 8..10, 4)\n end\n end\n\n test \"matches behavior for lists vs. ranges\" do\n range = 0..20\n list = Enum.to_list(range)\n # Below 32 elements, the map implementation currently sticks values in order.\n # If ever the MapSet implementation changes, this will fail (not affecting the correctness\n # of slide). I figured it'd be worth testing this for the time being just to have\n # another enumerable (aside from range) testing the generic implementation.\n set = MapSet.new(list)\n\n test_specs = [\n {0..0, 0},\n {0..0, 20},\n {11..11, 14},\n {11..11, 3},\n {4..8, 19},\n {4..8, 0},\n {4..8, 2},\n {10..20, 0},\n {2..1//1, -20}\n ]\n\n for {slide_range, insertion_point} <- test_specs do\n slide = &Enum.slide(&1, slide_range, insertion_point)\n assert slide.(list) == slide.(set)\n assert slide.(list) == slide.(range)\n end\n end\n\n test \"inserts at negative indices\" do\n for zero_to_5 <- [0..5, Enum.to_list(0..5)] do\n assert Enum.slide(zero_to_5, 0, -1) == [1, 2, 3, 4, 5, 0]\n assert Enum.slide(zero_to_5, 1, -1) == [0, 2, 3, 4, 5, 1]\n assert Enum.slide(zero_to_5, 1..2, -2) == [0, 3, 4, 1, 2, 5]\n assert Enum.slide(zero_to_5, -5..-4//1, -2) == [0, 3, 4, 1, 2, 5]\n end\n\n assert Enum.slide([:a, :b, :c, :d, :e, :f], -5..-3//1, -2) ==\n Enum.slide([:a, :b, :c, :d, :e, :f], 1..3, 4)\n end\n\n test \"raises when insertion index would fall inside the range\" do\n for zero_to_5 <- [0..5, Enum.to_list(0..5)] do\n assert_raise ArgumentError, fn ->\n Enum.slide(zero_to_5, 2..3, -3)\n end\n end\n\n for zero_to_10 <- [0..10, Enum.to_list(0..10)],\n insertion_idx <- 3..5 do\n assert_raise ArgumentError, fn ->\n assert Enum.slide(zero_to_10, 2..5, insertion_idx)\n end\n end\n end\n end\n\n test \"scan/2\" do\n assert Enum.scan([1, 2, 3, 4, 5], &(&1 + &2)) == [1, 3, 6, 10, 15]\n assert Enum.scan([], &(&1 + &2)) == []\n end\n\n test \"scan/3\" do\n assert Enum.scan([1, 2, 3, 4, 5], 0, &(&1 + &2)) == [1, 3, 6, 10, 15]\n assert Enum.scan([], 0, &(&1 + &2)) == []\n end\n\n test \"shuffle/1\" do\n # set a fixed seed so the test can be deterministic\n :rand.seed(:exsss, {1374, 347_975, 449_264})\n assert Enum.shuffle([1, 2, 3, 4, 5]) == [2, 5, 4, 3, 1]\n end\n\n test \"slice/2\" do\n list = [1, 2, 3, 4, 5]\n assert Enum.slice(list, 0..0) == [1]\n assert Enum.slice(list, 0..1) == [1, 2]\n assert Enum.slice(list, 0..2) == [1, 2, 3]\n\n assert Enum.slice(list, 0..10//2) == [1, 3, 5]\n assert Enum.slice(list, 0..10//3) == [1, 4]\n assert Enum.slice(list, 0..10//4) == [1, 5]\n assert Enum.slice(list, 0..10//5) == [1]\n assert Enum.slice(list, 0..10//6) == [1]\n\n assert Enum.slice(list, 0..2//2) == [1, 3]\n assert Enum.slice(list, 0..2//3) == [1]\n\n assert Enum.slice(list, 0..-1//2) == [1, 3, 5]\n assert Enum.slice(list, 0..-1//3) == [1, 4]\n assert Enum.slice(list, 0..-1//4) == [1, 5]\n assert Enum.slice(list, 0..-1//5) == [1]\n assert Enum.slice(list, 0..-1//6) == [1]\n\n assert Enum.slice(list, 1..-1//2) == [2, 4]\n assert Enum.slice(list, 1..-1//3) == [2, 5]\n assert Enum.slice(list, 1..-1//4) == [2]\n assert Enum.slice(list, 1..-1//5) == [2]\n\n assert Enum.slice(list, -4..-1//2) == [2, 4]\n assert Enum.slice(list, -4..-1//3) == [2, 5]\n assert Enum.slice(list, -4..-1//4) == [2]\n assert Enum.slice(list, -4..-1//5) == [2]\n end\n\n test \"slice/3\" do\n list = [1, 2, 3, 4, 5]\n assert Enum.slice(list, 0, 0) == []\n assert Enum.slice(list, 0, 1) == [1]\n assert Enum.slice(list, 0, 2) == [1, 2]\n assert Enum.slice(list, 1, 2) == [2, 3]\n assert Enum.slice(list, 1, 0) == []\n assert Enum.slice(list, 2, 5) == [3, 4, 5]\n assert Enum.slice(list, 2, 6) == [3, 4, 5]\n assert Enum.slice(list, 5, 5) == []\n assert Enum.slice(list, 6, 5) == []\n assert Enum.slice(list, 6, 0) == []\n assert Enum.slice(list, -6, 0) == []\n assert Enum.slice(list, -6, 5) == [1, 2, 3, 4, 5]\n assert Enum.slice(list, -2, 5) == [4, 5]\n assert Enum.slice(list, -3, 1) == [3]\n\n assert_raise FunctionClauseError, fn ->\n Enum.slice(list, 0, -1)\n end\n end\n\n test \"slice on infinite streams\" do\n assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0, 2) == [1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0, 5) == [1, 2, 3, 1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..1) == [1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..4) == [1, 2, 3, 1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..4//2) == [1, 3, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..5//2) == [1, 3, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(1..6//2) == [2, 1, 3]\n end\n\n test \"slice on pruned infinite streams\" do\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0, 2) == [1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0, 5) == [1, 2, 3, 1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0..1) == [1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0..4) == [1, 2, 3, 1, 2]\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0..4//2) == [1, 3, 2]\n\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-10..-9//1) ==\n [1, 2]\n\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-10..-6//1) ==\n [1, 2, 3, 1, 2]\n\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-10..-6//2) ==\n [1, 3, 2]\n\n assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-9..-5//2) ==\n [2, 1, 3]\n end\n\n test \"slice on MapSets\" do\n assert MapSet.new(1..10) |> Enum.slice(0, 2) |> Enum.count() == 2\n assert MapSet.new(1..3) |> Enum.slice(0, 10) |> Enum.count() == 3\n assert MapSet.new(1..10) |> Enum.slice(0..1) |> Enum.count() == 2\n assert MapSet.new(1..3) |> Enum.slice(0..10) |> Enum.count() == 3\n\n assert MapSet.new(1..10) |> Enum.slice(0..4//2) |> Enum.count() == 3\n assert MapSet.new(1..10) |> Enum.slice(0..5//2) |> Enum.count() == 3\n end\n\n test \"sort/1\" do\n assert Enum.sort([5, 3, 2, 4, 1]) == [1, 2, 3, 4, 5]\n end\n\n test \"sort/2\" do\n assert Enum.sort([5, 3, 2, 4, 1], &(&1 >= &2)) == [5, 4, 3, 2, 1]\n assert Enum.sort([5, 3, 2, 4, 1], :asc) == [1, 2, 3, 4, 5]\n assert Enum.sort([5, 3, 2, 4, 1], :desc) == [5, 4, 3, 2, 1]\n\n assert Enum.sort([3, 2, 1, 3, 2, 3], :asc) == [1, 2, 2, 3, 3, 3]\n assert Enum.sort([3, 2, 1, 3, 2, 3], :desc) == [3, 3, 3, 2, 2, 1]\n\n shuffled = Enum.shuffle(1..100)\n assert Enum.sort(shuffled, :asc) == Enum.to_list(1..100)\n assert Enum.sort(shuffled, :desc) == Enum.reverse(1..100)\n end\n\n test \"sort/2 with module\" do\n assert Enum.sort([~D[2020-01-01], ~D[2018-01-01], ~D[2019-01-01]], Date) ==\n [~D[2018-01-01], ~D[2019-01-01], ~D[2020-01-01]]\n\n assert Enum.sort([~D[2020-01-01], ~D[2018-01-01], ~D[2019-01-01]], {:asc, Date}) ==\n [~D[2018-01-01], ~D[2019-01-01], ~D[2020-01-01]]\n\n assert Enum.sort([~D[2020-01-01], ~D[2018-01-01], ~D[2019-01-01]], {:desc, Date}) ==\n [~D[2020-01-01], ~D[2019-01-01], ~D[2018-01-01]]\n end\n\n test \"sort/2 with streams\" do\n sort_stream = fn list, sorter -> list |> Stream.map(& &1) |> Enum.sort(sorter) end\n\n assert sort_stream.([5, 3, 2, 4, 1], &(&1 >= &2)) == [5, 4, 3, 2, 1]\n assert sort_stream.([5, 3, 2, 4, 1], :asc) == [1, 2, 3, 4, 5]\n assert sort_stream.([5, 3, 2, 4, 1], :desc) == [5, 4, 3, 2, 1]\n\n assert sort_stream.([3, 2, 1, 3, 2, 3], :asc) == [1, 2, 2, 3, 3, 3]\n assert sort_stream.([3, 2, 1, 3, 2, 3], :desc) == [3, 3, 3, 2, 2, 1]\n\n shuffled = Enum.shuffle(1..100)\n assert sort_stream.(shuffled, :asc) == Enum.to_list(1..100)\n assert sort_stream.(shuffled, :desc) == Enum.reverse(1..100)\n end\n\n test \"sort_by/3\" do\n collection = [\n [sorted_data: 4],\n [sorted_data: 5],\n [sorted_data: 2],\n [sorted_data: 1],\n [sorted_data: 3]\n ]\n\n asc = [\n [sorted_data: 1],\n [sorted_data: 2],\n [sorted_data: 3],\n [sorted_data: 4],\n [sorted_data: 5]\n ]\n\n desc = [\n [sorted_data: 5],\n [sorted_data: 4],\n [sorted_data: 3],\n [sorted_data: 2],\n [sorted_data: 1]\n ]\n\n assert Enum.sort_by(collection, & &1[:sorted_data]) == asc\n assert Enum.sort_by(collection, & &1[:sorted_data], :asc) == asc\n assert Enum.sort_by(collection, & &1[:sorted_data], &>=/2) == desc\n assert Enum.sort_by(collection, & &1[:sorted_data], :desc) == desc\n end\n\n test \"sort_by/3 with stable sorting\" do\n collection = [\n [other_data: 2, sorted_data: 4],\n [other_data: 1, sorted_data: 5],\n [other_data: 2, sorted_data: 2],\n [other_data: 3, sorted_data: 1],\n [other_data: 4, sorted_data: 3]\n ]\n\n # Stable sorting\n assert Enum.sort_by(collection, & &1[:other_data]) == [\n [other_data: 1, sorted_data: 5],\n [other_data: 2, sorted_data: 4],\n [other_data: 2, sorted_data: 2],\n [other_data: 3, sorted_data: 1],\n [other_data: 4, sorted_data: 3]\n ]\n\n assert Enum.sort_by(collection, & &1[:other_data]) ==\n Enum.sort_by(collection, & &1[:other_data], :asc)\n\n assert Enum.sort_by(collection, & &1[:other_data], & false end) == {[], [1, 2, 3]}\n assert Enum.split_while([1, 2, 3], fn _ -> true end) == {[1, 2, 3], []}\n assert Enum.split_while([1, 2, 3], fn x -> x > 2 end) == {[], [1, 2, 3]}\n assert Enum.split_while([1, 2, 3], fn x -> x > 3 end) == {[], [1, 2, 3]}\n assert Enum.split_while([1, 2, 3], fn x -> x < 3 end) == {[1, 2], [3]}\n assert Enum.split_while([], fn _ -> true end) == {[], []}\n end\n\n test \"sum/1\" do\n assert Enum.sum([]) == 0\n assert Enum.sum([1]) == 1\n assert Enum.sum([1, 2, 3]) == 6\n assert Enum.sum([1.1, 2.2, 3.3]) == 6.6\n assert Enum.sum([-3, -2, -1, 0, 1, 2, 3]) == 0\n assert Enum.sum(42..42) == 42\n assert Enum.sum(11..17) == 98\n assert Enum.sum(17..11//-1) == 98\n assert Enum.sum(11..-17//-1) == Enum.sum(-17..11)\n\n assert_raise ArithmeticError, fn ->\n Enum.sum([{}])\n end\n\n assert_raise ArithmeticError, fn ->\n Enum.sum([1, {}])\n end\n end\n\n test \"sum_by/2\" do\n assert Enum.sum_by([], &hd/1) == 0\n assert Enum.sum_by([[1]], &hd/1) == 1\n assert Enum.sum_by([[1], [2], [3]], &hd/1) == 6\n assert Enum.sum_by([[1.1], [2.2], [3.3]], &hd/1) == 6.6\n assert Enum.sum_by([[-3], [-2], [-1], [0], [1], [2], [3]], &hd/1) == 0\n\n assert Enum.sum_by(1..3, &(&1 ** 2)) == 14\n\n assert_raise ArithmeticError, fn ->\n Enum.sum_by([[{}]], &hd/1)\n end\n\n assert_raise ArithmeticError, fn ->\n Enum.sum_by([[1], [{}]], &hd/1)\n end\n end\n\n test \"product/1\" do\n assert Enum.product([]) == 1\n assert Enum.product([1]) == 1\n assert Enum.product([1, 2, 3, 4, 5]) == 120\n assert Enum.product([1, -2, 3, 4, 5]) == -120\n assert Enum.product(1..5) == 120\n assert Enum.product(11..-17//-1) == Enum.product(-17..11)\n\n assert_raise ArithmeticError, fn ->\n Enum.product([{}])\n end\n\n assert_raise ArithmeticError, fn ->\n Enum.product([1, {}])\n end\n\n assert_raise ArithmeticError, fn ->\n Enum.product(%{a: 1, b: 2})\n end\n end\n\n test \"product_by/2\" do\n assert Enum.product_by([], &hd/1) == 1\n assert Enum.product_by([[1]], &hd/1) == 1\n assert Enum.product_by([[1], [2], [3], [4], [5]], &hd/1) == 120\n assert Enum.product_by([[1], [-2], [3], [4], [5]], &hd/1) == -120\n assert Enum.product_by(1..5, & &1) == 120\n assert Enum.product_by(11..-17//-1, & &1) == 0\n\n assert_raise ArithmeticError, fn ->\n Enum.product_by([[{}]], &hd/1)\n end\n\n assert_raise ArithmeticError, fn ->\n Enum.product_by([[1], [{}]], &hd/1)\n end\n\n assert_raise ArithmeticError, fn ->\n Enum.product_by(%{a: 1, b: 2}, & &1)\n end\n end\n\n test \"take/2\" do\n assert Enum.take([1, 2, 3], 0) == []\n assert Enum.take([1, 2, 3], 1) == [1]\n assert Enum.take([1, 2, 3], 2) == [1, 2]\n assert Enum.take([1, 2, 3], 3) == [1, 2, 3]\n assert Enum.take([1, 2, 3], 4) == [1, 2, 3]\n assert Enum.take([1, 2, 3], -1) == [3]\n assert Enum.take([1, 2, 3], -2) == [2, 3]\n assert Enum.take([1, 2, 3], -4) == [1, 2, 3]\n assert Enum.take([], 3) == []\n end\n\n test \"take_every/2\" do\n assert Enum.take_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2) == [1, 3, 5, 7, 9]\n assert Enum.take_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3) == [1, 4, 7, 10]\n assert Enum.take_every([], 2) == []\n assert Enum.take_every([1, 2], 2) == [1]\n assert Enum.take_every([1, 2, 3], 0) == []\n assert Enum.take_every(1..3, 1) == [1, 2, 3]\n\n assert_raise FunctionClauseError, fn ->\n Enum.take_every([1, 2, 3], -1)\n end\n end\n\n test \"take_random/2\" do\n assert Enum.take_random(-42..-42, 1) == [-42]\n\n # corner cases, independent of the seed\n assert_raise FunctionClauseError, fn -> Enum.take_random([1, 2], -1) end\n assert Enum.take_random([], 0) == []\n assert Enum.take_random([], 3) == []\n assert Enum.take_random([1], 0) == []\n assert Enum.take_random([1], 2) == [1]\n assert Enum.take_random([1, 2], 0) == []\n\n # set a fixed seed so the test can be deterministic\n # please note the order of following assertions is important\n seed1 = {1406, 407_414, 139_258}\n seed2 = {1406, 421_106, 567_597}\n :rand.seed(:exsss, seed1)\n assert Enum.take_random([1, 2, 3], 1) == [2]\n assert Enum.take_random([1, 2, 3], 2) == [2, 3]\n assert Enum.take_random([1, 2, 3], 3) == [3, 1, 2]\n assert Enum.take_random([1, 2, 3], 4) == [2, 3, 1]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random([1, 2, 3], 1) == [1]\n assert Enum.take_random([1, 2, 3], 2) == [3, 1]\n assert Enum.take_random([1, 2, 3], 3) == [2, 3, 1]\n assert Enum.take_random([1, 2, 3], 4) == [3, 2, 1]\n assert Enum.take_random([1, 2, 3], 129) == [2, 1, 3]\n\n # assert that every item in the sample comes from the input list\n list = for _ <- 1..100, do: make_ref()\n\n for x <- Enum.take_random(list, 50) do\n assert x in list\n end\n\n assert_raise FunctionClauseError, fn ->\n Enum.take_random(1..10, -1)\n end\n end\n\n test \"take_while/2\" do\n assert Enum.take_while([1, 2, 3], fn x -> x > 3 end) == []\n assert Enum.take_while([1, 2, 3], fn x -> x <= 1 end) == [1]\n assert Enum.take_while([1, 2, 3], fn x -> x <= 3 end) == [1, 2, 3]\n assert Enum.take_while([], fn _ -> true end) == []\n end\n\n test \"to_list/1\" do\n assert Enum.to_list([]) == []\n end\n\n test \"uniq/1\" do\n assert Enum.uniq([5, 1, 2, 3, 2, 1]) == [5, 1, 2, 3]\n end\n\n test \"uniq_by/2\" do\n assert Enum.uniq_by([1, 2, 3, 2, 1], fn x -> x end) == [1, 2, 3]\n end\n\n test \"unzip/1\" do\n assert Enum.unzip([{:a, 1}, {:b, 2}, {:c, 3}]) == {[:a, :b, :c], [1, 2, 3]}\n assert Enum.unzip([]) == {[], []}\n assert Enum.unzip(%{a: 1}) == {[:a], [1]}\n assert Enum.unzip(foo: \"a\", bar: \"b\") == {[:foo, :bar], [\"a\", \"b\"]}\n\n assert_raise FunctionClauseError, fn -> Enum.unzip([{:a, 1}, {:b, 2, \"foo\"}]) end\n assert_raise FunctionClauseError, fn -> Enum.unzip([{1, 2, {3, {4, 5}}}]) end\n assert_raise FunctionClauseError, fn -> Enum.unzip([1, 2, 3]) end\n end\n\n test \"with_index/2\" do\n assert Enum.with_index([]) == []\n assert Enum.with_index([1, 2, 3]) == [{1, 0}, {2, 1}, {3, 2}]\n assert Enum.with_index([1, 2, 3], 10) == [{1, 10}, {2, 11}, {3, 12}]\n\n assert Enum.with_index([1, 2, 3], fn element, index -> {index, element} end) ==\n [{0, 1}, {1, 2}, {2, 3}]\n\n assert Enum.with_index(1..0//1) == []\n assert Enum.with_index(1..3) == [{1, 0}, {2, 1}, {3, 2}]\n assert Enum.with_index(1..3, 10) == [{1, 10}, {2, 11}, {3, 12}]\n\n assert Enum.with_index(1..3, fn element, index -> {index, element} end) ==\n [{0, 1}, {1, 2}, {2, 3}]\n end\n\n test \"zip/2\" do\n assert Enum.zip([:a, :b], [1, 2]) == [{:a, 1}, {:b, 2}]\n assert Enum.zip([:a, :b], [1, 2, 3, 4]) == [{:a, 1}, {:b, 2}]\n assert Enum.zip([:a, :b, :c, :d], [1, 2]) == [{:a, 1}, {:b, 2}]\n\n assert Enum.zip([], [1]) == []\n assert Enum.zip([1], []) == []\n assert Enum.zip([], []) == []\n end\n\n test \"zip/2 with infinite streams\" do\n assert Enum.zip([], Stream.cycle([1, 2])) == []\n assert Enum.zip([], Stream.cycle(1..2)) == []\n assert Enum.zip(.., Stream.cycle([1, 2])) == []\n assert Enum.zip(.., Stream.cycle(1..2)) == []\n\n assert Enum.zip(Stream.cycle([1, 2]), ..) == []\n assert Enum.zip(Stream.cycle(1..2), ..) == []\n assert Enum.zip(Stream.cycle([1, 2]), ..) == []\n assert Enum.zip(Stream.cycle(1..2), ..) == []\n end\n\n test \"zip/1\" do\n assert Enum.zip([[:a, :b], [1, 2], [\"foo\", \"bar\"]]) == [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n assert Enum.zip([[:a, :b], [1, 2, 3, 4], [\"foo\", \"bar\", \"baz\", \"qux\"]]) ==\n [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n assert Enum.zip([[:a, :b, :c, :d], [1, 2], [\"foo\", \"bar\", \"baz\", \"qux\"]]) ==\n [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n assert Enum.zip([[:a, :b, :c, :d], [1, 2, 3, 4], [\"foo\", \"bar\"]]) ==\n [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n assert Enum.zip([1..10, [\"foo\", \"bar\"]]) == [{1, \"foo\"}, {2, \"bar\"}]\n\n assert Enum.zip([]) == []\n assert Enum.zip([[]]) == []\n assert Enum.zip([[1]]) == [{1}]\n\n assert Enum.zip([[], [], [], []]) == []\n assert Enum.zip(%{}) == []\n end\n\n test \"zip_with/3\" do\n assert Enum.zip_with([1, 2], [3, 4], fn a, b -> a * b end) == [3, 8]\n assert Enum.zip_with([:a, :b], [1, 2], &{&1, &2}) == [{:a, 1}, {:b, 2}]\n assert Enum.zip_with([:a, :b], [1, 2, 3, 4], &{&1, &2}) == [{:a, 1}, {:b, 2}]\n assert Enum.zip_with([:a, :b, :c, :d], [1, 2], &{&1, &2}) == [{:a, 1}, {:b, 2}]\n assert Enum.zip_with([], [1], &{&1, &2}) == []\n assert Enum.zip_with([1], [], &{&1, &2}) == []\n assert Enum.zip_with([], [], &{&1, &2}) == []\n\n # Ranges\n assert Enum.zip_with(1..6, 3..4, fn a, b -> a + b end) == [4, 6]\n assert Enum.zip_with([1, 2, 5, 6], 3..4, fn a, b -> a + b end) == [4, 6]\n assert Enum.zip_with(fn _, _ -> {:cont, [1, 2]} end, 3..4, fn a, b -> a + b end) == [4, 6]\n assert Enum.zip_with(1..1, 0..0, fn a, b -> a + b end) == [1]\n\n # Date.range\n week_1 = Date.range(~D[2020-10-12], ~D[2020-10-16])\n week_2 = Date.range(~D[2020-10-19], ~D[2020-10-23])\n\n result =\n Enum.zip_with(week_1, week_2, fn a, b ->\n Date.day_of_week(a) + Date.day_of_week(b)\n end)\n\n assert result == [2, 4, 6, 8, 10]\n\n # Maps\n result = Enum.zip_with(%{a: 7}, 3..4, fn {key, value}, b -> {key, value + b} end)\n assert result == [a: 10]\n\n result = Enum.zip_with(3..4, %{a: 7}, fn a, {key, value} -> {key, value + a} end)\n assert result == [a: 10]\n end\n\n test \"zip_with/2\" do\n zip_fun = fn items -> List.to_tuple(items) end\n result = Enum.zip_with([[:a, :b], [1, 2], [\"foo\", \"bar\"]], zip_fun)\n assert result == [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n map = %{a: :b, c: :d}\n [x1, x2] = Map.to_list(map)\n lots = Enum.zip_with([[:a, :b], [1, 2], [\"foo\", \"bar\"], map], zip_fun)\n assert lots == [{:a, 1, \"foo\", x1}, {:b, 2, \"bar\", x2}]\n\n assert Enum.zip_with([[:a, :b], [1, 2, 3, 4], [\"foo\", \"bar\", \"baz\", \"qux\"]], zip_fun) ==\n [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n assert Enum.zip_with([[:a, :b, :c, :d], [1, 2], [\"foo\", \"bar\", \"baz\", \"qux\"]], zip_fun) ==\n [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n assert Enum.zip_with([[:a, :b, :c, :d], [1, 2, 3, 4], [\"foo\", \"bar\"]], zip_fun) ==\n [{:a, 1, \"foo\"}, {:b, 2, \"bar\"}]\n\n assert Enum.zip_with([1..10, [\"foo\", \"bar\"]], zip_fun) == [{1, \"foo\"}, {2, \"bar\"}]\n assert Enum.zip_with([], zip_fun) == []\n assert Enum.zip_with([[]], zip_fun) == []\n assert Enum.zip_with([[1]], zip_fun) == [{1}]\n assert Enum.zip_with([[], [], [], []], zip_fun) == []\n assert Enum.zip_with(%{}, zip_fun) == []\n assert Enum.zip_with([[1, 2, 5, 6], 3..4], fn [x, y] -> x + y end) == [4, 6]\n\n # Ranges\n assert Enum.zip_with([1..6, 3..4], fn [a, b] -> a + b end) == [4, 6]\n assert Enum.zip_with([[1, 2, 5, 6], 3..4], fn [a, b] -> a + b end) == [4, 6]\n assert Enum.zip_with([fn _, _ -> {:cont, [1, 2]} end, 3..4], fn [a, b] -> a + b end) == [4, 6]\n assert Enum.zip_with([1..1, 0..0], fn [a, b] -> a + b end) == [1]\n\n # Date.range\n week_1 = Date.range(~D[2020-10-12], ~D[2020-10-16])\n week_2 = Date.range(~D[2020-10-19], ~D[2020-10-23])\n\n result =\n Enum.zip_with([week_1, week_2], fn [a, b] ->\n Date.day_of_week(a) + Date.day_of_week(b)\n end)\n\n assert result == [2, 4, 6, 8, 10]\n\n # Maps\n result = Enum.zip_with([%{a: 7}, 3..4], fn [{key, value}, b] -> {key, value + b} end)\n assert result == [a: 10]\n\n result = Enum.zip_with([%{a: 7}, 3..4], fn [{key, value}, b] -> {key, value + b} end)\n assert result == [a: 10]\n end\nend\n\ndefmodule EnumTest.Range do\n # Ranges use custom callbacks for protocols in many operations.\n use ExUnit.Case, async: true\n\n test \"all?/2\" do\n assert Enum.all?(0..1)\n assert Enum.all?(1..0//-1)\n refute Enum.all?(0..5, fn x -> rem(x, 2) == 0 end)\n assert Enum.all?(0..1, fn x -> x < 2 end)\n\n assert Enum.all?(0..1//-1)\n assert Enum.all?(0..5//2, fn x -> rem(x, 2) == 0 end)\n refute Enum.all?(1..5//2, fn x -> rem(x, 2) == 0 end)\n end\n\n test \"any?/2\" do\n assert Enum.any?(1..0//-1)\n refute Enum.any?(0..5, &(&1 > 10))\n assert Enum.any?(0..5, &(&1 > 3))\n\n refute Enum.any?(0..1//-1)\n assert Enum.any?(0..5//2, fn x -> rem(x, 2) == 0 end)\n refute Enum.any?(1..5//2, fn x -> rem(x, 2) == 0 end)\n end\n\n test \"at/3\" do\n assert Enum.at(2..6, 0) == 2\n assert Enum.at(2..6, 4) == 6\n assert Enum.at(2..6, 6) == nil\n assert Enum.at(2..6, 6, :none) == :none\n assert Enum.at(2..6, -2) == 5\n assert Enum.at(2..6, -8) == nil\n\n assert Enum.at(0..1//-1, 0) == nil\n assert Enum.at(1..1//5, 0) == 1\n assert Enum.at(1..3//2, 0) == 1\n assert Enum.at(1..3//2, 1) == 3\n assert Enum.at(1..3//2, 2) == nil\n assert Enum.at(1..3//2, -1) == 3\n assert Enum.at(1..3//2, -2) == 1\n assert Enum.at(1..3//2, -3) == nil\n end\n\n test \"chunk_every/2\" do\n assert Enum.chunk_every(1..5, 2) == [[1, 2], [3, 4], [5]]\n assert Enum.chunk_every(1..10//2, 2) == [[1, 3], [5, 7], [9]]\n end\n\n test \"chunk_every/4\" do\n assert Enum.chunk_every(1..5, 2, 2) == [[1, 2], [3, 4], [5]]\n assert Enum.chunk_every(1..6, 3, 2, :discard) == [[1, 2, 3], [3, 4, 5]]\n assert Enum.chunk_every(1..6, 2, 3, :discard) == [[1, 2], [4, 5]]\n assert Enum.chunk_every(1..6, 3, 2, []) == [[1, 2, 3], [3, 4, 5], [5, 6]]\n assert Enum.chunk_every(1..5, 4, 4, 6..10) == [[1, 2, 3, 4], [5, 6, 7, 8]]\n assert Enum.chunk_every(1..10//2, 4, 4, 11..20) == [[1, 3, 5, 7], [9, 11, 12, 13]]\n end\n\n test \"chunk_by/2\" do\n assert Enum.chunk_by(1..4, fn _ -> true end) == [[1, 2, 3, 4]]\n assert Enum.chunk_by(1..4, &(rem(&1, 2) == 1)) == [[1], [2], [3], [4]]\n assert Enum.chunk_by(1..20//3, &(rem(&1, 2) == 1)) == [[1], [4], [7], [10], [13], [16], [19]]\n end\n\n test \"concat/1\" do\n assert Enum.concat([1..2, 4..6]) == [1, 2, 4, 5, 6]\n assert Enum.concat([1..5, fn acc, _ -> acc end, [1]]) == [1, 2, 3, 4, 5, 1]\n assert Enum.concat([1..5, 6..10//2]) == [1, 2, 3, 4, 5, 6, 8, 10]\n end\n\n test \"concat/2\" do\n assert Enum.concat(1..3, 4..5) == [1, 2, 3, 4, 5]\n assert Enum.concat(1..3, [4, 5]) == [1, 2, 3, 4, 5]\n assert Enum.concat(1..3, []) == [1, 2, 3]\n assert Enum.concat(1..3, 0..0) == [1, 2, 3, 0]\n assert Enum.concat(1..5, 6..10//2) == [1, 2, 3, 4, 5, 6, 8, 10]\n assert Enum.concat(1..5, 0..1//-1) == [1, 2, 3, 4, 5]\n assert Enum.concat(1..5, 1..0//1) == [1, 2, 3, 4, 5]\n end\n\n test \"count/1\" do\n assert Enum.count(1..5) == 5\n assert Enum.count(1..1) == 1\n assert Enum.count(1..9//2) == 5\n assert Enum.count(1..10//2) == 5\n assert Enum.count(1..11//2) == 6\n assert Enum.count(1..11//-2) == 0\n assert Enum.count(11..1//-2) == 6\n assert Enum.count(10..1//-2) == 5\n assert Enum.count(9..1//-2) == 5\n assert Enum.count(9..1//2) == 0\n end\n\n test \"count/2\" do\n assert Enum.count(1..5, fn x -> rem(x, 2) == 0 end) == 2\n assert Enum.count(1..1, fn x -> rem(x, 2) == 0 end) == 0\n assert Enum.count(0..5//2, fn x -> rem(x, 2) == 0 end) == 3\n assert Enum.count(1..5//2, fn x -> rem(x, 2) == 0 end) == 0\n end\n\n test \"dedup/1\" do\n assert Enum.dedup(1..3) == [1, 2, 3]\n assert Enum.dedup(1..3//2) == [1, 3]\n end\n\n test \"dedup_by/2\" do\n assert Enum.dedup_by(1..3, fn _ -> 1 end) == [1]\n assert Enum.dedup_by(1..3//2, fn _ -> 1 end) == [1]\n end\n\n test \"drop/2\" do\n assert Enum.drop(1..3, 0) == [1, 2, 3]\n assert Enum.drop(1..3, 1) == [2, 3]\n assert Enum.drop(1..3, 2) == [3]\n assert Enum.drop(1..3, 3) == []\n assert Enum.drop(1..3, 4) == []\n assert Enum.drop(1..3, -1) == [1, 2]\n assert Enum.drop(1..3, -2) == [1]\n assert Enum.drop(1..3, -4) == []\n assert Enum.drop(1..0//-1, 3) == []\n\n assert Enum.drop(1..9//2, 2) == [5, 7, 9]\n assert Enum.drop(1..9//2, -2) == [1, 3, 5]\n assert Enum.drop(9..1//-2, 2) == [5, 3, 1]\n assert Enum.drop(9..1//-2, -2) == [9, 7, 5]\n end\n\n test \"drop_every/2\" do\n assert Enum.drop_every(1..10, 2) == [2, 4, 6, 8, 10]\n assert Enum.drop_every(1..10, 3) == [2, 3, 5, 6, 8, 9]\n assert Enum.drop_every(0..0, 2) == []\n assert Enum.drop_every(1..2, 2) == [2]\n assert Enum.drop_every(1..3, 0) == [1, 2, 3]\n assert Enum.drop_every(1..3, 1) == []\n\n assert Enum.drop_every(1..5//2, 0) == [1, 3, 5]\n assert Enum.drop_every(1..5//2, 1) == []\n assert Enum.drop_every(1..5//2, 2) == [3]\n end\n\n test \"drop_while/2\" do\n assert Enum.drop_while(0..6, fn x -> x <= 3 end) == [4, 5, 6]\n assert Enum.drop_while(0..6, fn _ -> false end) == [0, 1, 2, 3, 4, 5, 6]\n assert Enum.drop_while(0..3, fn x -> x <= 3 end) == []\n assert Enum.drop_while(1..0//-1, fn _ -> nil end) == [1, 0]\n end\n\n test \"each/2\" do\n try do\n assert Enum.each(1..0//-1, fn x -> x end) == :ok\n assert Enum.each(1..3, fn x -> Process.put(:enum_test_each, x * 2) end) == :ok\n assert Process.get(:enum_test_each) == 6\n after\n Process.delete(:enum_test_each)\n end\n\n try do\n assert Enum.each(-1..-3//-1, fn x -> Process.put(:enum_test_each, x * 2) end) == :ok\n assert Process.get(:enum_test_each) == -6\n after\n Process.delete(:enum_test_each)\n end\n end\n\n test \"empty?/1\" do\n refute Enum.empty?(1..0//-1)\n refute Enum.empty?(1..2)\n refute Enum.empty?(1..2//2)\n assert Enum.empty?(1..2//-2)\n end\n\n test \"fetch/2\" do\n # ascending order\n assert Enum.fetch(-10..20, 4) == {:ok, -6}\n assert Enum.fetch(-10..20, -4) == {:ok, 17}\n # ascending order, first\n assert Enum.fetch(-10..20, 0) == {:ok, -10}\n assert Enum.fetch(-10..20, -31) == {:ok, -10}\n # ascending order, last\n assert Enum.fetch(-10..20, -1) == {:ok, 20}\n assert Enum.fetch(-10..20, 30) == {:ok, 20}\n # ascending order, out of bound\n assert Enum.fetch(-10..20, 31) == :error\n assert Enum.fetch(-10..20, -32) == :error\n\n # descending order\n assert Enum.fetch(20..-10//-1, 4) == {:ok, 16}\n assert Enum.fetch(20..-10//-1, -4) == {:ok, -7}\n # descending order, first\n assert Enum.fetch(20..-10//-1, 0) == {:ok, 20}\n assert Enum.fetch(20..-10//-1, -31) == {:ok, 20}\n # descending order, last\n assert Enum.fetch(20..-10//-1, -1) == {:ok, -10}\n assert Enum.fetch(20..-10//-1, 30) == {:ok, -10}\n # descending order, out of bound\n assert Enum.fetch(20..-10//-1, 31) == :error\n assert Enum.fetch(20..-10//-1, -32) == :error\n\n # edge cases\n assert Enum.fetch(42..42, 0) == {:ok, 42}\n assert Enum.fetch(42..42, -1) == {:ok, 42}\n assert Enum.fetch(42..42, 2) == :error\n assert Enum.fetch(42..42, -2) == :error\n\n assert Enum.fetch(42..42//2, 0) == {:ok, 42}\n assert Enum.fetch(42..42//2, -1) == {:ok, 42}\n assert Enum.fetch(42..42//2, 2) == :error\n assert Enum.fetch(42..42//2, -2) == :error\n end\n\n test \"fetch!/2\" do\n assert Enum.fetch!(2..6, 0) == 2\n assert Enum.fetch!(2..6, 4) == 6\n assert Enum.fetch!(2..6, -1) == 6\n assert Enum.fetch!(2..6, -2) == 5\n assert Enum.fetch!(-2..-6//-1, 0) == -2\n assert Enum.fetch!(-2..-6//-1, 4) == -6\n\n assert_raise Enum.OutOfBoundsError, fn ->\n Enum.fetch!(2..6, 8)\n end\n\n assert_raise Enum.OutOfBoundsError, fn ->\n Enum.fetch!(-2..-6//-1, 8)\n end\n\n assert_raise Enum.OutOfBoundsError, fn ->\n Enum.fetch!(2..6, -8)\n end\n end\n\n test \"filter/2\" do\n assert Enum.filter(1..3, fn x -> rem(x, 2) == 0 end) == [2]\n assert Enum.filter(1..6, fn x -> rem(x, 2) == 0 end) == [2, 4, 6]\n\n assert Enum.filter(1..3, &match?(1, &1)) == [1]\n assert Enum.filter(1..3, &match?(x when x < 3, &1)) == [1, 2]\n assert Enum.filter(1..3, fn _ -> true end) == [1, 2, 3]\n end\n\n test \"find/3\" do\n assert Enum.find(2..6, fn x -> rem(x, 2) == 0 end) == 2\n assert Enum.find(2..6, fn x -> rem(x, 2) == 1 end) == 3\n assert Enum.find(2..6, fn _ -> false end) == nil\n assert Enum.find(2..6, 0, fn _ -> false end) == 0\n end\n\n test \"find_index/2\" do\n assert Enum.find_index(2..6, fn x -> rem(x, 2) == 1 end) == 1\n end\n\n test \"find_value/3\" do\n assert Enum.find_value(2..6, fn x -> rem(x, 2) == 1 end)\n end\n\n test \"flat_map/2\" do\n assert Enum.flat_map(1..3, fn x -> [x, x] end) == [1, 1, 2, 2, 3, 3]\n end\n\n test \"flat_map_reduce/3\" do\n assert Enum.flat_map_reduce(1..100, 0, fn i, acc ->\n if acc < 3, do: {[i], acc + 1}, else: {:halt, acc}\n end) == {[1, 2, 3], 3}\n end\n\n test \"group_by/3\" do\n assert Enum.group_by(1..6, &rem(&1, 3)) == %{0 => [3, 6], 1 => [1, 4], 2 => [2, 5]}\n\n assert Enum.group_by(1..6, &rem(&1, 3), &(&1 * 2)) ==\n %{0 => [6, 12], 1 => [2, 8], 2 => [4, 10]}\n end\n\n test \"intersperse/2\" do\n assert Enum.intersperse(1..0//-1, true) == [1, true, 0]\n assert Enum.intersperse(1..3, false) == [1, false, 2, false, 3]\n end\n\n test \"into/2\" do\n assert Enum.into(1..5, []) == [1, 2, 3, 4, 5]\n assert Enum.into(1..5, MapSet.new()) == MapSet.new([1, 2, 3, 4, 5])\n end\n\n test \"into/3\" do\n assert Enum.into(1..5, [], fn x -> x * 2 end) == [2, 4, 6, 8, 10]\n assert Enum.into(1..3, \"numbers: \", &to_string/1) == \"numbers: 123\"\n assert Enum.into(1..3, MapSet.new(), &(&1 * 2)) == MapSet.new([2, 4, 6])\n end\n\n test \"join/2\" do\n assert Enum.join(1..0//-1, \" = \") == \"1 = 0\"\n assert Enum.join(1..3, \" = \") == \"1 = 2 = 3\"\n assert Enum.join(1..3) == \"123\"\n end\n\n test \"map/2\" do\n assert Enum.map(1..3, fn x -> x * 2 end) == [2, 4, 6]\n assert Enum.map(-1..-3//-1, fn x -> x * 2 end) == [-2, -4, -6]\n assert Enum.map(1..10//2, fn x -> x * 2 end) == [2, 6, 10, 14, 18]\n assert Enum.map(3..1//-2, fn x -> x * 2 end) == [6, 2]\n assert Enum.map(0..1//-1, fn x -> x * 2 end) == []\n end\n\n test \"map_every/3\" do\n assert Enum.map_every(1..10, 2, fn x -> x * 2 end) == [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]\n\n assert Enum.map_every(-1..-10//-1, 2, fn x -> x * 2 end) ==\n [-2, -2, -6, -4, -10, -6, -14, -8, -18, -10]\n\n assert Enum.map_every(1..2, 2, fn x -> x * 2 end) == [2, 2]\n assert Enum.map_every(1..3, 0, fn x -> x * 2 end) == [1, 2, 3]\n\n assert_raise FunctionClauseError, fn ->\n Enum.map_every(1..3, -1, fn x -> x * 2 end)\n end\n end\n\n test \"map_intersperse/3\" do\n assert Enum.map_intersperse(1..1, :a, &(&1 * 2)) == [2]\n assert Enum.map_intersperse(1..3, :a, &(&1 * 2)) == [2, :a, 4, :a, 6]\n end\n\n test \"map_join/3\" do\n assert Enum.map_join(1..0//-1, \" = \", &(&1 * 2)) == \"2 = 0\"\n assert Enum.map_join(1..3, \" = \", &(&1 * 2)) == \"2 = 4 = 6\"\n assert Enum.map_join(1..3, &(&1 * 2)) == \"246\"\n end\n\n test \"map_reduce/3\" do\n assert Enum.map_reduce(1..0//-1, 1, fn x, acc -> {x * 2, x + acc} end) == {[2, 0], 2}\n assert Enum.map_reduce(1..3, 1, fn x, acc -> {x * 2, x + acc} end) == {[2, 4, 6], 7}\n end\n\n test \"max/1\" do\n assert Enum.max(1..1) == 1\n assert Enum.max(1..3) == 3\n assert Enum.max(3..1//-1) == 3\n\n assert Enum.max(1..9//2) == 9\n assert Enum.max(1..10//2) == 9\n assert Enum.max(-1..-9//-2) == -1\n\n assert_raise Enum.EmptyError, fn -> Enum.max(1..0//1) end\n end\n\n test \"max/2 with empty fallback\" do\n assert Enum.max(.., fn -> 0 end) === 0\n assert Enum.max(1..2, fn -> 0 end) === 2\n end\n\n test \"max_by/2\" do\n assert Enum.max_by(1..1, fn x -> :math.pow(-2, x) end) == 1\n assert Enum.max_by(1..3, fn x -> :math.pow(-2, x) end) == 2\n\n assert Enum.max_by(1..8//3, fn x -> :math.pow(-2, x) end) == 4\n assert_raise Enum.EmptyError, fn -> Enum.max_by(1..0//1, & &1) end\n end\n\n test \"member?/2\" do\n assert Enum.member?(1..3, 2)\n refute Enum.member?(1..3, 0)\n\n assert Enum.member?(1..9//2, 1)\n assert Enum.member?(1..9//2, 9)\n refute Enum.member?(1..9//2, 10)\n refute Enum.member?(1..10//2, 10)\n assert Enum.member?(1..2//2, 1)\n refute Enum.member?(1..2//2, 2)\n\n assert Enum.member?(-1..-9//-2, -1)\n assert Enum.member?(-1..-9//-2, -9)\n refute Enum.member?(-1..-9//-2, -8)\n\n refute Enum.member?(1..0//1, 1)\n refute Enum.member?(0..1//-1, 1)\n end\n\n test \"min/1\" do\n assert Enum.min(1..1) == 1\n assert Enum.min(1..3) == 1\n\n assert Enum.min(1..9//2) == 1\n assert Enum.min(1..10//2) == 1\n assert Enum.min(-1..-9//-2) == -9\n\n assert_raise Enum.EmptyError, fn -> Enum.min(1..0//1) end\n end\n\n test \"min/2 with empty fallback\" do\n assert Enum.min(.., fn -> 0 end) === 0\n assert Enum.min(1..2, fn -> 0 end) === 1\n end\n\n test \"min_by/2\" do\n assert Enum.min_by(1..1, fn x -> :math.pow(-2, x) end) == 1\n assert Enum.min_by(1..3, fn x -> :math.pow(-2, x) end) == 3\n\n assert Enum.min_by(1..8//3, fn x -> :math.pow(-2, x) end) == 7\n assert_raise Enum.EmptyError, fn -> Enum.min_by(1..0//1, & &1) end\n end\n\n test \"min_max/1\" do\n assert Enum.min_max(1..1) == {1, 1}\n assert Enum.min_max(1..3) == {1, 3}\n assert Enum.min_max(3..1//-1) == {1, 3}\n\n assert Enum.min_max(1..9//2) == {1, 9}\n assert Enum.min_max(1..10//2) == {1, 9}\n assert Enum.min_max(-1..-9//-2) == {-9, -1}\n\n assert_raise Enum.EmptyError, fn -> Enum.min_max(1..0//1) end\n end\n\n test \"min_max_by/2\" do\n assert Enum.min_max_by(1..1, fn x -> x end) == {1, 1}\n assert Enum.min_max_by(1..3, fn x -> x end) == {1, 3}\n\n assert Enum.min_max_by(1..8//3, fn x -> :math.pow(-2, x) end) == {7, 4}\n assert_raise Enum.EmptyError, fn -> Enum.min_max_by(1..0//1, & &1) end\n end\n\n test \"split_with/2\" do\n assert Enum.split_with(1..3, fn x -> rem(x, 2) == 0 end) == {[2], [1, 3]}\n end\n\n test \"random/1\" do\n # corner cases, independent of the seed\n assert Enum.random(1..1) == 1\n\n # set a fixed seed so the test can be deterministic\n # please note the order of following assertions is important\n seed1 = {1406, 407_414, 139_258}\n seed2 = {1306, 421_106, 567_597}\n :rand.seed(:exsss, seed1)\n assert Enum.random(1..2) == 1\n assert Enum.random(1..3) == 1\n assert Enum.random(3..1//-1) == 2\n\n :rand.seed(:exsss, seed2)\n assert Enum.random(1..2) == 1\n assert Enum.random(1..3) == 2\n\n assert Enum.random(1..10//2) == 7\n assert Enum.random(1..10//2) == 5\n\n assert_raise Enum.EmptyError, fn -> Enum.random(..) end\n end\n\n test \"reduce/2\" do\n assert Enum.reduce(1..3, fn x, acc -> x + acc end) == 6\n assert Enum.reduce(1..10//2, fn x, acc -> x + acc end) == 25\n assert_raise Enum.EmptyError, fn -> Enum.reduce(0..1//-1, &+/2) end\n end\n\n test \"reduce/3\" do\n assert Enum.reduce(1..0//-1, 1, fn x, acc -> x + acc end) == 2\n assert Enum.reduce(1..3, 1, fn x, acc -> x + acc end) == 7\n assert Enum.reduce(1..10//2, 1, fn x, acc -> x + acc end) == 26\n assert Enum.reduce(0..1//-1, 1, fn x, acc -> x + acc end) == 1\n end\n\n test \"reduce_while/3\" do\n assert Enum.reduce_while(1..100, 0, fn i, acc ->\n if i <= 3, do: {:cont, acc + i}, else: {:halt, acc}\n end) == 6\n end\n\n test \"reject/2\" do\n assert Enum.reject(1..3, fn x -> rem(x, 2) == 0 end) == [1, 3]\n assert Enum.reject(1..6, fn x -> rem(x, 2) == 0 end) == [1, 3, 5]\n end\n\n test \"reverse/1\" do\n assert Enum.reverse(0..0) == [0]\n assert Enum.reverse(1..3) == [3, 2, 1]\n assert Enum.reverse(-3..5) == [5, 4, 3, 2, 1, 0, -1, -2, -3]\n assert Enum.reverse(5..5) == [5]\n\n assert Enum.reverse(0..1//-1) == []\n assert Enum.reverse(1..10//2) == [9, 7, 5, 3, 1]\n end\n\n test \"reverse/2\" do\n assert Enum.reverse(1..3, 4..6) == [3, 2, 1, 4, 5, 6]\n assert Enum.reverse([1, 2, 3], 4..6) == [3, 2, 1, 4, 5, 6]\n assert Enum.reverse(1..3, [4, 5, 6]) == [3, 2, 1, 4, 5, 6]\n assert Enum.reverse(-3..5, MapSet.new([-3, -2])) == [5, 4, 3, 2, 1, 0, -1, -2, -3, -3, -2]\n assert Enum.reverse(5..5, [5]) == [5, 5]\n end\n\n test \"reverse_slice/3\" do\n assert Enum.reverse_slice(1..6, 2, 0) == [1, 2, 3, 4, 5, 6]\n assert Enum.reverse_slice(1..6, 2, 2) == [1, 2, 4, 3, 5, 6]\n assert Enum.reverse_slice(1..6, 2, 4) == [1, 2, 6, 5, 4, 3]\n assert Enum.reverse_slice(1..6, 2, 10_000_000) == [1, 2, 6, 5, 4, 3]\n assert Enum.reverse_slice(1..6, 10_000_000, 4) == [1, 2, 3, 4, 5, 6]\n assert Enum.reverse_slice(1..6, 50, 50) == [1, 2, 3, 4, 5, 6]\n end\n\n test \"scan/2\" do\n assert Enum.scan(1..5, &(&1 + &2)) == [1, 3, 6, 10, 15]\n end\n\n test \"scan/3\" do\n assert Enum.scan(1..5, 0, &(&1 + &2)) == [1, 3, 6, 10, 15]\n end\n\n test \"shuffle/1\" do\n # set a fixed seed so the test can be deterministic\n :rand.seed(:exsss, {1374, 347_975, 449_264})\n assert Enum.shuffle(1..5) == [2, 5, 4, 3, 1]\n assert Enum.shuffle(1..10//2) == [5, 1, 7, 9, 3]\n end\n\n test \"slice/2\" do\n assert Enum.slice(1..5, 0..0) == [1]\n assert Enum.slice(1..5, 0..1) == [1, 2]\n assert Enum.slice(1..5, 0..2) == [1, 2, 3]\n assert Enum.slice(1..5, 1..2) == [2, 3]\n assert Enum.slice(1..5, 1..0//1) == []\n assert Enum.slice(1..5, 2..5) == [3, 4, 5]\n assert Enum.slice(1..5, 2..6) == [3, 4, 5]\n assert Enum.slice(1..5, 4..4) == [5]\n assert Enum.slice(1..5, 5..5) == []\n assert Enum.slice(1..5, 6..5//1) == []\n assert Enum.slice(1..5, 6..0//1) == []\n assert Enum.slice(1..5, -3..0) == []\n assert Enum.slice(1..5, -3..1) == []\n assert Enum.slice(1..5, -6..0) == [1]\n assert Enum.slice(1..5, -6..5) == [1, 2, 3, 4, 5]\n assert Enum.slice(1..5, -6..-1) == [1, 2, 3, 4, 5]\n assert Enum.slice(1..5, -5..-1) == [1, 2, 3, 4, 5]\n assert Enum.slice(1..5, -5..-3) == [1, 2, 3]\n\n assert Enum.slice(1..5, 0..10//2) == [1, 3, 5]\n assert Enum.slice(1..5, 0..10//3) == [1, 4]\n assert Enum.slice(1..5, 0..10//4) == [1, 5]\n assert Enum.slice(1..5, 0..10//5) == [1]\n assert Enum.slice(1..5, 0..10//6) == [1]\n\n assert Enum.slice(1..5, 0..2//2) == [1, 3]\n assert Enum.slice(1..5, 0..2//3) == [1]\n\n assert Enum.slice(1..5, 0..-1//2) == [1, 3, 5]\n assert Enum.slice(1..5, 0..-1//3) == [1, 4]\n assert Enum.slice(1..5, 0..-1//4) == [1, 5]\n assert Enum.slice(1..5, 0..-1//5) == [1]\n assert Enum.slice(1..5, 0..-1//6) == [1]\n\n assert Enum.slice(1..5, 1..-1//2) == [2, 4]\n assert Enum.slice(1..5, 1..-1//3) == [2, 5]\n assert Enum.slice(1..5, 1..-1//4) == [2]\n assert Enum.slice(1..5, 1..-1//5) == [2]\n\n assert Enum.slice(1..5, -4..-1//2) == [2, 4]\n assert Enum.slice(1..5, -4..-1//3) == [2, 5]\n assert Enum.slice(1..5, -4..-1//4) == [2]\n assert Enum.slice(1..5, -4..-1//5) == [2]\n\n assert Enum.slice(5..1//-1, 0..0) == [5]\n assert Enum.slice(5..1//-1, 0..1) == [5, 4]\n assert Enum.slice(5..1//-1, 0..2) == [5, 4, 3]\n assert Enum.slice(5..1//-1, 1..2) == [4, 3]\n assert Enum.slice(5..1//-1, 1..0//1) == []\n assert Enum.slice(5..1//-1, 2..5) == [3, 2, 1]\n assert Enum.slice(5..1//-1, 2..6) == [3, 2, 1]\n assert Enum.slice(5..1//-1, 4..4) == [1]\n assert Enum.slice(5..1//-1, 5..5) == []\n assert Enum.slice(5..1//-1, 6..5//1) == []\n assert Enum.slice(5..1//-1, 6..0//1) == []\n assert Enum.slice(5..1//-1, -6..0) == [5]\n assert Enum.slice(5..1//-1, -6..5) == [5, 4, 3, 2, 1]\n assert Enum.slice(5..1//-1, -6..-1) == [5, 4, 3, 2, 1]\n assert Enum.slice(5..1//-1, -5..-1) == [5, 4, 3, 2, 1]\n assert Enum.slice(5..1//-1, -5..-3) == [5, 4, 3]\n\n assert Enum.slice(1..10//2, 0..0) == [1]\n assert Enum.slice(1..10//2, 0..1) == [1, 3]\n assert Enum.slice(1..10//2, 0..2) == [1, 3, 5]\n assert Enum.slice(1..10//2, 1..2) == [3, 5]\n assert Enum.slice(1..10//2, 1..0//1) == []\n assert Enum.slice(1..10//2, 2..5) == [5, 7, 9]\n assert Enum.slice(1..10//2, 2..6) == [5, 7, 9]\n assert Enum.slice(1..10//2, 4..4) == [9]\n assert Enum.slice(1..10//2, 5..5) == []\n assert Enum.slice(1..10//2, 6..5//1) == []\n assert Enum.slice(1..10//2, 6..0//1) == []\n assert Enum.slice(1..10//2, -3..0) == []\n assert Enum.slice(1..10//2, -3..1) == []\n assert Enum.slice(1..10//2, -6..0) == [1]\n assert Enum.slice(1..10//2, -6..5) == [1, 3, 5, 7, 9]\n assert Enum.slice(1..10//2, -6..-1) == [1, 3, 5, 7, 9]\n assert Enum.slice(1..10//2, -5..-1) == [1, 3, 5, 7, 9]\n assert Enum.slice(1..10//2, -5..-3) == [1, 3, 5]\n\n # Range with step > 1 sliced by a range with step > 1\n assert Enum.slice(1..10//2, 0..4//2) == [1, 5, 9]\n assert Enum.slice(1..10//2, 0..4//3) == [1, 7]\n assert Enum.slice(1..10//2, 1..4//2) == [3, 7]\n assert Enum.slice(0..20//3, 0..6//2) == [0, 6, 12, 18]\n\n # Range with negative step sliced by a range with step > 1\n assert Enum.slice(10..1//-2, 0..4//2) == [10, 6, 2]\n assert Enum.slice(20..0//-3, 0..6//2) == [20, 14, 8, 2]\n\n assert_raise ArgumentError,\n \"Enum.slice/2 does not accept ranges with negative steps, got: 1..3//-2\",\n fn -> Enum.slice(1..5, 1..3//-2) end\n end\n\n test \"slice/3\" do\n assert Enum.slice(1..5, 0, 0) == []\n assert Enum.slice(1..5, 0, 1) == [1]\n assert Enum.slice(1..5, 0, 2) == [1, 2]\n assert Enum.slice(1..5, 1, 2) == [2, 3]\n assert Enum.slice(1..5, 1, 0) == []\n assert Enum.slice(1..5, 2, 3) == [3, 4, 5]\n assert Enum.slice(1..5, 2, 6) == [3, 4, 5]\n assert Enum.slice(1..5, 5, 5) == []\n assert Enum.slice(1..5, 6, 5) == []\n assert Enum.slice(1..5, 6, 0) == []\n assert Enum.slice(1..5, -6, 0) == []\n assert Enum.slice(1..5, -6, 5) == [1, 2, 3, 4, 5]\n assert Enum.slice(1..5, -2, 5) == [4, 5]\n assert Enum.slice(1..5, -3, 1) == [3]\n\n assert_raise FunctionClauseError, fn ->\n Enum.slice(1..5, 0, -1)\n end\n\n assert Enum.slice(5..1//-1, 0, 0) == []\n assert Enum.slice(5..1//-1, 0, 1) == [5]\n assert Enum.slice(5..1//-1, 0, 2) == [5, 4]\n assert Enum.slice(5..1//-1, 1, 2) == [4, 3]\n assert Enum.slice(5..1//-1, 1, 0) == []\n assert Enum.slice(5..1//-1, 2, 3) == [3, 2, 1]\n assert Enum.slice(5..1//-1, 2, 6) == [3, 2, 1]\n assert Enum.slice(5..1//-1, 4, 4) == [1]\n assert Enum.slice(5..1//-1, 5, 5) == []\n assert Enum.slice(5..1//-1, 6, 5) == []\n assert Enum.slice(5..1//-1, 6, 0) == []\n assert Enum.slice(5..1//-1, -6, 0) == []\n assert Enum.slice(5..1//-1, -6, 5) == [5, 4, 3, 2, 1]\n\n assert Enum.slice(1..10//2, 0, 0) == []\n assert Enum.slice(1..10//2, 0, 1) == [1]\n assert Enum.slice(1..10//2, 0, 2) == [1, 3]\n assert Enum.slice(1..10//2, 1, 2) == [3, 5]\n assert Enum.slice(1..10//2, 1, 0) == []\n assert Enum.slice(1..10//2, 2, 3) == [5, 7, 9]\n assert Enum.slice(1..10//2, 2, 6) == [5, 7, 9]\n assert Enum.slice(1..10//2, 5, 5) == []\n assert Enum.slice(1..10//2, 6, 5) == []\n assert Enum.slice(1..10//2, 6, 0) == []\n assert Enum.slice(1..10//2, -6, 0) == []\n assert Enum.slice(1..10//2, -6, 5) == [1, 3, 5, 7, 9]\n assert Enum.slice(1..10//2, -2, 5) == [7, 9]\n assert Enum.slice(1..10//2, -3, 1) == [5]\n end\n\n test \"sort/1\" do\n assert Enum.sort(3..1//-1) == [1, 2, 3]\n assert Enum.sort(2..1//-1) == [1, 2]\n assert Enum.sort(1..1) == [1]\n end\n\n test \"sort/2\" do\n assert Enum.sort(3..1//-1, &(&1 > &2)) == [3, 2, 1]\n assert Enum.sort(2..1//-1, &(&1 > &2)) == [2, 1]\n assert Enum.sort(1..1, &(&1 > &2)) == [1]\n\n assert Enum.sort(3..1//-1, :asc) == [1, 2, 3]\n assert Enum.sort(3..1//-1, :desc) == [3, 2, 1]\n end\n\n test \"sort_by/2\" do\n assert Enum.sort_by(3..1//-1, & &1) == [1, 2, 3]\n assert Enum.sort_by(3..1//-1, & &1, :asc) == [1, 2, 3]\n assert Enum.sort_by(3..1//-1, & &1, :desc) == [3, 2, 1]\n end\n\n test \"split/2\" do\n assert Enum.split(1..3, 0) == {[], [1, 2, 3]}\n assert Enum.split(1..3, 1) == {[1], [2, 3]}\n assert Enum.split(1..3, 2) == {[1, 2], [3]}\n assert Enum.split(1..3, 3) == {[1, 2, 3], []}\n assert Enum.split(1..3, 4) == {[1, 2, 3], []}\n assert Enum.split(1..3, -1) == {[1, 2], [3]}\n assert Enum.split(1..3, -2) == {[1], [2, 3]}\n assert Enum.split(1..3, -3) == {[], [1, 2, 3]}\n assert Enum.split(1..3, -10) == {[], [1, 2, 3]}\n assert Enum.split(1..0//-1, 3) == {[1, 0], []}\n end\n\n test \"split_while/2\" do\n assert Enum.split_while(1..3, fn _ -> false end) == {[], [1, 2, 3]}\n assert Enum.split_while(1..3, fn _ -> nil end) == {[], [1, 2, 3]}\n assert Enum.split_while(1..3, fn _ -> true end) == {[1, 2, 3], []}\n assert Enum.split_while(1..3, fn x -> x > 2 end) == {[], [1, 2, 3]}\n assert Enum.split_while(1..3, fn x -> x > 3 end) == {[], [1, 2, 3]}\n assert Enum.split_while(1..3, fn x -> x < 3 end) == {[1, 2], [3]}\n assert Enum.split_while(1..3, fn x -> x end) == {[1, 2, 3], []}\n assert Enum.split_while(1..0//-1, fn _ -> true end) == {[1, 0], []}\n end\n\n test \"sum/1\" do\n assert Enum.sum(0..0) == 0\n assert Enum.sum(1..1) == 1\n assert Enum.sum(1..3) == 6\n assert Enum.sum(0..100) == 5050\n assert Enum.sum(10..100) == 5005\n assert Enum.sum(100..10//-1) == 5005\n assert Enum.sum(-10..-20//-1) == -165\n assert Enum.sum(-10..2) == -52\n\n assert Enum.sum(0..1//-1) == 0\n assert Enum.sum(1..9//2) == 25\n assert Enum.sum(1..10//2) == 25\n assert Enum.sum(9..1//-2) == 25\n end\n\n test \"take/2\" do\n assert Enum.take(1..3, 0) == []\n assert Enum.take(1..3, 1) == [1]\n assert Enum.take(1..3, 2) == [1, 2]\n assert Enum.take(1..3, 3) == [1, 2, 3]\n assert Enum.take(1..3, 4) == [1, 2, 3]\n assert Enum.take(1..3, -1) == [3]\n assert Enum.take(1..3, -2) == [2, 3]\n assert Enum.take(1..3, -4) == [1, 2, 3]\n assert Enum.take(1..0//-1, 3) == [1, 0]\n assert Enum.take(1..0//1, -3) == []\n end\n\n test \"take_every/2\" do\n assert Enum.take_every(1..10, 2) == [1, 3, 5, 7, 9]\n assert Enum.take_every(1..2, 2) == [1]\n assert Enum.take_every(1..3, 0) == []\n\n assert_raise FunctionClauseError, fn ->\n Enum.take_every(1..3, -1)\n end\n end\n\n test \"take_random/2\" do\n # corner cases, independent of the seed\n assert_raise FunctionClauseError, fn -> Enum.take_random(1..2, -1) end\n assert Enum.take_random(1..1, 0) == []\n assert Enum.take_random(1..1, 1) == [1]\n assert Enum.take_random(1..1, 2) == [1]\n assert Enum.take_random(1..2, 0) == []\n\n # set a fixed seed so the test can be deterministic\n # please note the order of following assertions is important\n seed1 = {1406, 407_414, 139_258}\n seed2 = {1406, 421_106, 567_597}\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(1..3, 1) == [2]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(1..3, 2) == [3, 1]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(1..3, 3) == [3, 1, 2]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(1..3, 4) == [3, 1, 2]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(1..3, 5) == [3, 1, 2]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(3..1//-1, 1) == [2]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(1..3, 1) == [1]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(1..3, 2) == [3, 2]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(1..3, 3) == [1, 3, 2]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(1..3, 4) == [1, 3, 2]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(1..3, 5) == [1, 3, 2]\n end\n\n test \"take_while/2\" do\n assert Enum.take_while(1..3, fn x -> x > 3 end) == []\n assert Enum.take_while(1..3, fn x -> x <= 1 end) == [1]\n assert Enum.take_while(1..3, fn x -> x <= 3 end) == [1, 2, 3]\n assert Enum.take_while(1..3, fn x -> x end) == [1, 2, 3]\n assert Enum.take_while(1..3, fn _ -> nil end) == []\n end\n\n test \"to_list/1\" do\n assert Enum.to_list(1..3) == [1, 2, 3]\n assert Enum.to_list(1..3//2) == [1, 3]\n assert Enum.to_list(3..1//-2) == [3, 1]\n assert Enum.to_list(0..1//-1) == []\n end\n\n test \"uniq/1\" do\n assert Enum.uniq(1..3) == [1, 2, 3]\n end\n\n test \"uniq_by/2\" do\n assert Enum.uniq_by(1..3, fn x -> x end) == [1, 2, 3]\n end\n\n test \"unzip/1\" do\n assert_raise FunctionClauseError, fn -> Enum.unzip(1..3) end\n end\n\n test \"with_index/2\" do\n assert Enum.with_index(1..3) == [{1, 0}, {2, 1}, {3, 2}]\n assert Enum.with_index(1..3, 3) == [{1, 3}, {2, 4}, {3, 5}]\n end\n\n test \"zip/2\" do\n assert Enum.zip([:a, :b], 1..2) == [{:a, 1}, {:b, 2}]\n assert Enum.zip([:a, :b], 1..4) == [{:a, 1}, {:b, 2}]\n assert Enum.zip([:a, :b, :c, :d], 1..2) == [{:a, 1}, {:b, 2}]\n\n assert Enum.zip(1..2, [:a, :b]) == [{1, :a}, {2, :b}]\n assert Enum.zip(1..4, [:a, :b]) == [{1, :a}, {2, :b}]\n assert Enum.zip(1..2, [:a, :b, :c, :d]) == [{1, :a}, {2, :b}]\n\n assert Enum.zip(1..2, 1..2) == [{1, 1}, {2, 2}]\n assert Enum.zip(1..4, 1..2) == [{1, 1}, {2, 2}]\n assert Enum.zip(1..2, 1..4) == [{1, 1}, {2, 2}]\n\n assert Enum.zip(1..10//2, 1..10//3) == [{1, 1}, {3, 4}, {5, 7}, {7, 10}]\n assert Enum.zip(0..1//-1, 1..10//3) == []\n end\nend\n\ndefmodule EnumTest.Map do\n # Maps use different protocols path than lists and ranges in the cases below.\n use ExUnit.Case, async: true\n\n test \"random/1\" do\n map = %{a: 1, b: 2, c: 3}\n [x1, x2, x3] = Map.to_list(map)\n seed1 = {1406, 407_414, 139_258}\n seed2 = {1406, 421_106, 567_597}\n :rand.seed(:exsss, seed1)\n assert Enum.random(map) == x3\n assert Enum.random(map) == x1\n assert Enum.random(map) == x2\n\n :rand.seed(:exsss, seed2)\n assert Enum.random(map) == x3\n assert Enum.random(map) == x2\n end\n\n test \"take_random/2\" do\n # corner cases, independent of the seed\n assert_raise FunctionClauseError, fn -> Enum.take_random(1..2, -1) end\n assert Enum.take_random(%{a: 1}, 0) == []\n assert Enum.take_random(%{a: 1}, 2) == [a: 1]\n assert Enum.take_random(%{a: 1, b: 2}, 0) == []\n\n # set a fixed seed so the test can be deterministic\n # please note the order of following assertions is important\n map = %{a: 1, b: 2, c: 3}\n [x1, x2, x3] = Map.to_list(map)\n seed1 = {1406, 407_414, 139_258}\n seed2 = {1406, 421_106, 567_597}\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(map, 1) == [x2]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(map, 2) == [x3, x1]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(map, 3) == [x3, x1, x2]\n :rand.seed(:exsss, seed1)\n assert Enum.take_random(map, 4) == [x3, x1, x2]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(map, 1) == [x1]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(map, 2) == [x3, x2]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(map, 3) == [x1, x3, x2]\n :rand.seed(:exsss, seed2)\n assert Enum.take_random(map, 4) == [x1, x3, x2]\n end\n\n test \"reverse/1\" do\n assert Enum.reverse(%{}) == []\n assert Enum.reverse(MapSet.new()) == []\n\n map = %{a: 1, b: 2, c: 3}\n assert Enum.reverse(map) == Map.to_list(map) |> Enum.reverse()\n end\n\n test \"reverse/2\" do\n assert Enum.reverse([a: 1, b: 2, c: 3, a: 1], %{x: 1}) == [a: 1, c: 3, b: 2, a: 1, x: 1]\n\n assert Enum.reverse([], %{a: 1}) == [a: 1]\n assert Enum.reverse([], %{}) == []\n assert Enum.reverse(%{a: 1}, []) == [a: 1]\n assert Enum.reverse(MapSet.new(), %{}) == []\n end\n\n test \"fetch/2\" do\n map = %{a: 1, b: 2, c: 3, d: 4, e: 5}\n [x1, _x2, _x3, x4, x5] = Map.to_list(map)\n assert Enum.fetch(map, 0) == {:ok, x1}\n assert Enum.fetch(map, -2) == {:ok, x4}\n assert Enum.fetch(map, -6) == :error\n assert Enum.fetch(map, 5) == :error\n assert Enum.fetch(%{}, 0) == :error\n\n assert Stream.take(map, 3) |> Enum.fetch(3) == :error\n assert Stream.take(map, 5) |> Enum.fetch(4) == {:ok, x5}\n end\n\n test \"map_intersperse/3\" do\n assert Enum.map_intersperse(%{}, :a, & &1) == []\n assert Enum.map_intersperse(%{foo: :bar}, :a, & &1) == [{:foo, :bar}]\n\n map = %{foo: :bar, baz: :bat}\n [x1, x2] = Map.to_list(map)\n\n assert Enum.map_intersperse(map, :a, & &1) == [x1, :a, x2]\n end\n\n test \"slice/2\" do\n map = %{a: 1, b: 2, c: 3, d: 4, e: 5}\n [x1, x2, x3 | _] = Map.to_list(map)\n assert Enum.slice(map, 0..0) == [x1]\n assert Enum.slice(map, 0..1) == [x1, x2]\n assert Enum.slice(map, 0..2) == [x1, x2, x3]\n end\n\n test \"slice/3\" do\n map = %{a: 1, b: 2, c: 3, d: 4, e: 5}\n [x1, x2, x3, x4, x5] = Map.to_list(map)\n assert Enum.slice(map, 1, 2) == [x2, x3]\n assert Enum.slice(map, 1, 0) == []\n assert Enum.slice(map, 2, 5) == [x3, x4, x5]\n assert Enum.slice(map, 2, 6) == [x3, x4, x5]\n assert Enum.slice(map, 5, 5) == []\n assert Enum.slice(map, 6, 5) == []\n assert Enum.slice(map, 6, 0) == []\n assert Enum.slice(map, -6, 0) == []\n assert Enum.slice(map, -6, 5) == [x1, x2, x3, x4, x5]\n assert Enum.slice(map, -2, 5) == [x4, x5]\n assert Enum.slice(map, -3, 1) == [x3]\n\n assert_raise FunctionClauseError, fn ->\n Enum.slice(map, 0, -1)\n end\n\n assert Enum.slice(map, 0, 0) == []\n assert Enum.slice(map, 0, 1) == [x1]\n assert Enum.slice(map, 0, 2) == [x1, x2]\n assert Enum.slice(map, 1, 2) == [x2, x3]\n assert Enum.slice(map, 1, 0) == []\n assert Enum.slice(map, 2, 5) == [x3, x4, x5]\n assert Enum.slice(map, 2, 6) == [x3, x4, x5]\n assert Enum.slice(map, 5, 5) == []\n assert Enum.slice(map, 6, 5) == []\n assert Enum.slice(map, 6, 0) == []\n assert Enum.slice(map, -6, 0) == []\n assert Enum.slice(map, -6, 5) == [x1, x2, x3, x4, x5]\n assert Enum.slice(map, -2, 5) == [x4, x5]\n assert Enum.slice(map, -3, 1) == [x3]\n\n assert_raise FunctionClauseError, fn ->\n Enum.slice(map, 0, -1)\n end\n end\n\n test \"reduce/3\" do\n assert Enum.reduce(%{}, 1, fn x, acc -> x + acc end) == 1\n assert Enum.reduce(%{a: 1, b: 2}, 1, fn {_, x}, acc -> x + acc end) == 4\n end\nend\n\ndefmodule EnumTest.SideEffects do\n use ExUnit.Case, async: true\n\n import ExUnit.CaptureIO\n\n test \"take/2 with side effects\" do\n stream =\n Stream.unfold(1, fn x ->\n IO.puts(x)\n {x, x + 1}\n end)\n\n assert capture_io(fn ->\n Enum.take(stream, 1)\n end) == \"1\\n\"\n end\n\n @tag :tmp_dir\n test \"take/2 does not consume next without a need\", config do\n path = Path.join(config.tmp_dir, \"oneliner.txt\")\n File.mkdir(Path.dirname(path))\n\n try do\n File.write!(path, \"ONE\")\n\n File.open!(path, [], fn file ->\n iterator = IO.stream(file, :line)\n assert Enum.take(iterator, 1) == [\"ONE\"]\n assert Enum.take(iterator, 5) == []\n end)\n after\n File.rm(path)\n end\n end\n\n test \"take/2 with no elements works as no-op\" do\n iterator = File.stream!(PathHelpers.fixture_path(\"unknown.txt\"))\n\n assert Enum.take(iterator, 0) == []\n assert Enum.take(iterator, 0) == []\n assert Enum.take(iterator, 0) == []\n assert Enum.take(iterator, 0) == []\n end\nend\n\ndefmodule EnumTest.Function do\n use ExUnit.Case, async: true\n\n test \"raises Protocol.UndefinedError for funs of wrong arity\" do\n assert_raise Protocol.UndefinedError, fn ->\n Enum.to_list(fn -> nil end)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/exception_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule ExceptionTest do\n use ExUnit.Case, async: true\n\n defp capture_err(fun) do\n ExUnit.CaptureIO.capture_io(:stderr, fun)\n end\n\n doctest Exception\n\n doctest RuntimeError\n doctest SystemLimitError\n doctest MismatchedDelimiterError\n doctest SyntaxError\n doctest TokenMissingError\n doctest BadBooleanError\n doctest UndefinedFunctionError\n doctest FunctionClauseError\n doctest Protocol.UndefinedError\n doctest UnicodeConversionError\n doctest Enum.OutOfBoundsError\n doctest Enum.EmptyError\n doctest File.Error\n doctest File.CopyError\n doctest File.RenameError\n doctest File.LinkError\n doctest ErlangError\n\n test \"message/1\" do\n defmodule BadException do\n def message(exception) do\n if exception.raise do\n raise \"oops\"\n end\n end\n end\n\n assert \"got RuntimeError with message \\\"oops\\\" while retrieving Exception.message/1 for %{\" <>\n inspected =\n Exception.message(%{__struct__: BadException, __exception__: true, raise: true})\n\n assert inspected =~ \"raise: true\"\n assert inspected =~ \"__exception__: true\"\n assert inspected =~ \"__struct__: ExceptionTest.BadException\"\n\n assert \"got nil while retrieving Exception.message/1 for %{\" <> inspected =\n Exception.message(%{__struct__: BadException, __exception__: true, raise: false})\n\n assert inspected =~ \"raise: false\"\n assert inspected =~ \"__exception__: true\"\n assert inspected =~ \"__struct__: ExceptionTest.BadException\"\n end\n\n test \"normalize/2\" do\n assert Exception.normalize(:throw, :badarg, []) == :badarg\n assert Exception.normalize(:exit, :badarg, []) == :badarg\n assert Exception.normalize({:EXIT, self()}, :badarg, []) == :badarg\n assert Exception.normalize(:error, :badarg, []).__struct__ == ArgumentError\n assert Exception.normalize(:error, %ArgumentError{}, []).__struct__ == ArgumentError\n\n assert %ErlangError{original: :no_translation, reason: \": foo\"} =\n Exception.normalize(:error, :no_translation, [\n {:io, :put_chars, [self(), <<222>>],\n [error_info: %{module: __MODULE__, function: :dummy_error_extras}]}\n ])\n\n assert %ErlangError{original: {:failed_load_cacerts, :enoent}, reason: \": this is chardata\"} =\n Exception.normalize(:error, {:failed_load_cacerts, :enoent}, [\n {:pubkey_os_cacerts, :get, 0,\n [error_info: %{module: __MODULE__, function: :dummy_error_chardata}]}\n ])\n end\n\n test \"format/2 without stacktrace\" do\n stacktrace =\n try do\n throw(:stack)\n catch\n :stack -> __STACKTRACE__\n end\n\n assert Exception.format(:error, :badarg, stacktrace) ==\n \"** (ArgumentError) argument error\\n\" <> Exception.format_stacktrace(stacktrace)\n end\n\n test \"format/2 with empty stacktrace\" do\n assert Exception.format(:error, :badarg, []) == \"** (ArgumentError) argument error\"\n end\n\n test \"format/2 with EXIT (has no stacktrace)\" do\n assert Exception.format({:EXIT, self()}, :badarg, []) ==\n \"** (EXIT from #{inspect(self())}) :badarg\"\n end\n\n test \"format_banner/2\" do\n assert Exception.format_banner(:error, :badarg) == \"** (ArgumentError) argument error\"\n assert Exception.format_banner(:throw, :badarg) == \"** (throw) :badarg\"\n assert Exception.format_banner(:exit, :badarg) == \"** (exit) :badarg\"\n\n assert Exception.format_banner({:EXIT, self()}, :badarg) ==\n \"** (EXIT from #{inspect(self())}) :badarg\"\n end\n\n test \"format_stacktrace/1 from file\" do\n try do\n Code.eval_string(\"def foo do end\", [], file: \"my_file\")\n rescue\n ArgumentError ->\n assert Exception.format_stacktrace(__STACKTRACE__) =~ \"my_file:1: (file)\"\n else\n _ -> flunk(\"expected failure\")\n end\n end\n\n test \"format_stacktrace/1 from module\" do\n try do\n Code.eval_string(\n \"defmodule FmtStack do raise ArgumentError, ~s(oops) end\",\n [],\n file: \"my_file\"\n )\n rescue\n ArgumentError ->\n assert Exception.format_stacktrace(__STACKTRACE__) =~ \"my_file:1: (module)\"\n else\n _ -> flunk(\"expected failure\")\n end\n end\n\n test \"format_stacktrace_entry/1 with no file or line\" do\n assert Exception.format_stacktrace_entry({Foo, :bar, [1, 2, 3], []}) == \"Foo.bar(1, 2, 3)\"\n assert Exception.format_stacktrace_entry({Foo, :bar, [], []}) == \"Foo.bar()\"\n assert Exception.format_stacktrace_entry({Foo, :bar, 1, []}) == \"Foo.bar/1\"\n end\n\n test \"format_stacktrace_entry/1 with file and line\" do\n assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: ~c\"file.ex\", line: 10]}) ==\n \"file.ex:10: Foo.bar()\"\n\n assert Exception.format_stacktrace_entry(\n {Foo, :bar, [1, 2, 3], [file: ~c\"file.ex\", line: 10]}\n ) ==\n \"file.ex:10: Foo.bar(1, 2, 3)\"\n\n assert Exception.format_stacktrace_entry({Foo, :bar, 1, [file: ~c\"file.ex\", line: 10]}) ==\n \"file.ex:10: Foo.bar/1\"\n end\n\n test \"format_stacktrace_entry/1 with file no line\" do\n assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: ~c\"file.ex\"]}) ==\n \"file.ex: Foo.bar()\"\n\n assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: ~c\"file.ex\", line: 0]}) ==\n \"file.ex: Foo.bar()\"\n\n assert Exception.format_stacktrace_entry({Foo, :bar, [1, 2, 3], [file: ~c\"file.ex\"]}) ==\n \"file.ex: Foo.bar(1, 2, 3)\"\n\n assert Exception.format_stacktrace_entry({Foo, :bar, 1, [file: ~c\"file.ex\"]}) ==\n \"file.ex: Foo.bar/1\"\n end\n\n test \"format_stacktrace_entry/1 with application\" do\n assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: ~c\"file.ex\"]}) ==\n \"(elixir #{System.version()}) file.ex: Exception.bar()\"\n\n assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: ~c\"file.ex\", line: 10]}) ==\n \"(elixir #{System.version()}) file.ex:10: Exception.bar()\"\n end\n\n test \"format_stacktrace_entry/1 with fun\" do\n assert Exception.format_stacktrace_entry({fn x -> x end, [1], []}) =~ ~r/#Function<.+>\\(1\\)/\n\n assert Exception.format_stacktrace_entry({fn x, y -> {x, y} end, 2, []}) =~\n ~r\"#Function<.+>/2\"\n end\n\n test \"format_mfa/3\" do\n # Let's create this atom so that String.to_existing_atom/1 inside\n # format_mfa/3 doesn't raise.\n _ = :\"some function\"\n\n assert Exception.format_mfa(Foo, nil, 1) == \"Foo.nil/1\"\n assert Exception.format_mfa(Foo, :bar, 1) == \"Foo.bar/1\"\n assert Exception.format_mfa(Foo, :bar, []) == \"Foo.bar()\"\n assert Exception.format_mfa(nil, :bar, []) == \"nil.bar()\"\n assert Exception.format_mfa(:foo, :bar, [1, 2]) == \":foo.bar(1, 2)\"\n assert Exception.format_mfa(Foo, :b@r, 1) == \"Foo.\\\"b@r\\\"/1\"\n assert Exception.format_mfa(Foo, :\"bar baz\", 1) == \"Foo.\\\"bar baz\\\"/1\"\n assert Exception.format_mfa(Foo, :\"-func/2-fun-0-\", 4) == \"anonymous fn/4 in Foo.func/2\"\n\n assert Exception.format_mfa(Foo, :\"-some function/2-fun-0-\", 4) ==\n \"anonymous fn/4 in Foo.\\\"some function\\\"/2\"\n\n assert Exception.format_mfa(Foo, :\"42\", 1) == \"Foo.\\\"42\\\"/1\"\n assert Exception.format_mfa(Foo, :Bar, [1, 2]) == \"Foo.\\\"Bar\\\"(1, 2)\"\n assert Exception.format_mfa(Foo, :%{}, [1, 2]) == \"Foo.\\\"%{}\\\"(1, 2)\"\n assert Exception.format_mfa(Foo, :..., 1) == \"Foo.\\\"...\\\"/1\"\n end\n\n test \"format_mfa/3 with Unicode\" do\n assert Exception.format_mfa(Foo, :olá, [1, 2]) == \"Foo.olá(1, 2)\"\n assert Exception.format_mfa(Foo, :Olá, [1, 2]) == \"Foo.\\\"Olá\\\"(1, 2)\"\n assert Exception.format_mfa(Foo, :Ólá, [1, 2]) == \"Foo.\\\"Ólá\\\"(1, 2)\"\n assert Exception.format_mfa(Foo, :こんにちは世界, [1, 2]) == \"Foo.こんにちは世界(1, 2)\"\n\n nfd = :unicode.characters_to_nfd_binary(\"olá\")\n assert Exception.format_mfa(Foo, String.to_atom(nfd), [1, 2]) == \"Foo.\\\"#{nfd}\\\"(1, 2)\"\n end\n\n test \"format_fa/2\" do\n assert Exception.format_fa(fn -> nil end, 1) =~\n ~r\"#Function<\\d+\\.\\d+/0 in ExceptionTest\\.\\\"test format_fa/2\\\"/1>/1\"\n end\n\n describe \"format_exit/1\" do\n test \"with atom/tuples\" do\n assert Exception.format_exit(:bye) == \":bye\"\n assert Exception.format_exit(:noconnection) == \"no connection\"\n assert Exception.format_exit({:nodedown, :node@host}) == \"no connection to node@host\"\n assert Exception.format_exit(:timeout) == \"time out\"\n assert Exception.format_exit(:noproc) |> String.starts_with?(\"no process:\")\n assert Exception.format_exit(:killed) == \"killed\"\n assert Exception.format_exit(:normal) == \"normal\"\n assert Exception.format_exit(:shutdown) == \"shutdown\"\n assert Exception.format_exit(:calling_self) == \"process attempted to call itself\"\n assert Exception.format_exit({:shutdown, :bye}) == \"shutdown: :bye\"\n\n assert Exception.format_exit({:badarg, [{:not_a_real_module, :function, 0, []}]}) ==\n \"an exception was raised:\\n ** (ArgumentError) argument error\\n :not_a_real_module.function/0\"\n\n assert Exception.format_exit({:bad_call, :request}) == \"bad call: :request\"\n assert Exception.format_exit({:bad_cast, :request}) == \"bad cast: :request\"\n\n assert Exception.format_exit({:start_spec, :unexpected}) ==\n \"bad child specification, got: :unexpected\"\n\n assert Exception.format_exit({:supervisor_data, :unexpected}) ==\n \"bad supervisor configuration, got: :unexpected\"\n end\n\n defmodule Sup do\n def start_link(fun), do: :supervisor.start_link(__MODULE__, fun)\n\n def init(fun), do: fun.()\n end\n\n test \"with supervisor errors\" do\n Process.flag(:trap_exit, true)\n\n {:error, reason} = __MODULE__.Sup.start_link(fn -> :foo end)\n\n assert Exception.format_exit(reason) ==\n \"#{inspect(__MODULE__.Sup)}.init/1 returned a bad value: :foo\"\n\n return = {:ok, {:foo, []}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n assert Exception.format_exit(reason) == \"bad supervisor configuration, invalid type: :foo\"\n\n return = {:ok, {{:foo, 1, 1}, []}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) ==\n \"bad supervisor configuration, invalid strategy: :foo\"\n\n return = {:ok, {{:one_for_one, :foo, 1}, []}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) ==\n \"bad supervisor configuration, invalid max_restarts (intensity): :foo\"\n\n return = {:ok, {{:one_for_one, 1, :foo}, []}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) ==\n \"bad supervisor configuration, invalid max_seconds (period): :foo\"\n\n return = {:ok, {{:simple_one_for_one, 1, 1}, :foo}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n assert Exception.format_exit(reason) == \"bad child specification, invalid children: :foo\"\n\n return = {:ok, {{:one_for_one, 1, 1}, [:foo]}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) ==\n \"bad child specification, invalid child specification: :foo\"\n\n return = {:ok, {{:one_for_one, 1, 1}, [{:child, :foo, :temporary, 1, :worker, []}]}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n assert Exception.format_exit(reason) == \"bad child specification, invalid mfa: :foo\"\n\n return = {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :foo, 1, :worker, []}]}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) =~\n \"bad child specification, invalid restart type: :foo\"\n\n return = {\n :ok,\n {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, :foo, :worker, []}]}\n }\n\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n assert Exception.format_exit(reason) =~ \"bad child specification, invalid shutdown: :foo\"\n\n return = {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :foo, []}]}}\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n assert Exception.format_exit(reason) =~ \"bad child specification, invalid child type: :foo\"\n\n return =\n {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :worker, :foo}]}}\n\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n assert Exception.format_exit(reason) =~ \"bad child specification, invalid modules: :foo\"\n\n return = {\n :ok,\n {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :worker, [{:foo}]}]}\n }\n\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n assert Exception.format_exit(reason) =~ \"bad child specification, invalid module: {:foo}\"\n\n return = {\n :ok,\n {\n {:one_for_one, 1, 1},\n [\n {:child, {:m, :f, []}, :permanent, 1, :worker, []},\n {:child, {:m, :f, []}, :permanent, 1, :worker, []}\n ]\n }\n }\n\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) =~\n \"bad child specification, more than one child specification has the id: :child\"\n\n return = {\n :ok,\n {{:one_for_one, 1, 1}, [{:child, {Kernel, :exit, [:foo]}, :temporary, 1, :worker, []}]}\n }\n\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) ==\n \"shutdown: failed to start child: :child\\n ** (EXIT) :foo\"\n\n return = {\n :ok,\n {\n {:one_for_one, 1, 1},\n [{:child, {Kernel, :apply, [fn -> {:error, :foo} end, []]}, :temporary, 1, :worker, []}]\n }\n }\n\n {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)\n\n assert Exception.format_exit(reason) ==\n \"shutdown: failed to start child: :child\\n ** (EXIT) :foo\"\n end\n\n test \"with call\" do\n reason =\n try do\n :gen_server.call(:does_not_exist, :hello)\n catch\n :exit, reason -> reason\n end\n\n expected_to_start_with =\n \"exited in: :gen_server.call(:does_not_exist, :hello)\\n ** (EXIT) no process:\"\n\n assert Exception.format_exit(reason) |> String.starts_with?(expected_to_start_with)\n end\n\n test \"with nested calls\" do\n Process.flag(:trap_exit, true)\n # Fake reason to prevent error_logger printing to stdout\n exit_fun = fn -> receive do: (_ -> exit(:normal)) end\n\n outer_pid =\n spawn_link(fn ->\n Process.flag(:trap_exit, true)\n\n receive do\n _ ->\n :gen_event.call(spawn_link(exit_fun), :handler, :hello)\n end\n end)\n\n reason =\n try do\n :gen_server.call(outer_pid, :hi)\n catch\n :exit, reason -> reason\n end\n\n formatted = Exception.format_exit(reason)\n assert formatted =~ ~r\"exited in: :gen_server\\.call\\(#PID<\\d+\\.\\d+\\.\\d+>, :hi\\)\\n\"\n\n assert formatted =~\n ~r\"\\s{4}\\*\\* \\(EXIT\\) exited in: :gen_event\\.call\\(#PID<\\d+\\.\\d+\\.\\d+>, :handler, :hello\\)\\n\"\n\n assert formatted =~ ~r\"\\s{8}\\*\\* \\(EXIT\\) normal\"\n end\n\n test \"format_exit/1 with nested calls and exception\" do\n Process.flag(:trap_exit, true)\n # Fake reason to prevent error_logger printing to stdout\n exit_reason = {%ArgumentError{}, [{:not_a_real_module, :function, 0, []}]}\n exit_fun = fn -> receive do: (_ -> exit(exit_reason)) end\n\n outer_pid =\n spawn_link(fn ->\n Process.flag(:trap_exit, true)\n :gen_event.call(spawn_link(exit_fun), :handler, :hello)\n end)\n\n reason =\n try do\n :gen_server.call(outer_pid, :hi)\n catch\n :exit, reason -> reason\n end\n\n formatted = Exception.format_exit(reason)\n assert formatted =~ ~r\"exited in: :gen_server\\.call\\(#PID<\\d+\\.\\d+\\.\\d+>, :hi\\)\\n\"\n\n assert formatted =~\n ~r\"\\s{4}\\*\\* \\(EXIT\\) exited in: :gen_event\\.call\\(#PID<\\d+\\.\\d+\\.\\d+>, :handler, :hello\\)\\n\"\n\n assert formatted =~ ~r\"\\s{8}\\*\\* \\(EXIT\\) an exception was raised:\\n\"\n assert formatted =~ ~r\"\\s{12}\\*\\* \\(ArgumentError\\) argument error\\n\"\n assert formatted =~ ~r\"\\s{16}:not_a_real_module\\.function/0\"\n end\n end\n\n describe \"blaming\" do\n test \"does not annotate throws/exits\" do\n stack = [{Keyword, :pop, [%{}, :key, nil], [line: 13]}]\n assert Exception.blame(:throw, :function_clause, stack) == {:function_clause, stack}\n assert Exception.blame(:exit, :function_clause, stack) == {:function_clause, stack}\n end\n\n test \"handles operators precedence\" do\n import PathHelpers\n\n write_beam(\n defmodule OperatorPrecedence do\n def test!(x, y) when x in [1, 2, 3] and y >= 4, do: :ok\n end\n )\n\n :code.purge(OperatorPrecedence)\n :code.delete(OperatorPrecedence)\n\n assert blame_message(OperatorPrecedence, & &1.test!(1, 2)) =~ \"\"\"\n no function clause matching in ExceptionTest.OperatorPrecedence.test!/2\n\n The following arguments were given to ExceptionTest.OperatorPrecedence.test!/2:\n\n # 1\n 1\n\n # 2\n 2\n\n Attempted function clauses (showing 1 out of 1):\n\n def test!(x, y) when (x === 1 or -x === 2- or -x === 3-) and -y >= 4-\n \"\"\"\n end\n\n test \"reverts is_struct macro on guards for blaming\" do\n import PathHelpers\n\n write_beam(\n defmodule Req do\n def get!(url)\n when is_binary(url) or (is_struct(url) and is_struct(url, URI) and false) do\n url\n end\n\n def get!(url, url_module)\n when is_binary(url) or (is_struct(url) and is_struct(url, url_module) and false) do\n url\n end\n\n def sub_get!(url) when is_struct(url.sub, URI), do: url.sub\n end\n )\n\n :code.purge(Req)\n :code.delete(Req)\n\n assert blame_message(Req, & &1.get!(url: \"https://elixir-lang.org\")) =~ \"\"\"\n no function clause matching in ExceptionTest.Req.get!/1\n\n The following arguments were given to ExceptionTest.Req.get!/1:\n\n # 1\n [url: \"https://elixir-lang.org\"]\n\n Attempted function clauses (showing 1 out of 1):\n\n def get!(url) when -is_binary(url)- or -is_struct(url)- and -is_struct(url, URI)- and -false-\n \"\"\"\n\n elixir_uri = %URI{} = URI.parse(\"https://elixir-lang.org\")\n\n assert blame_message(Req, & &1.get!(elixir_uri, URI)) =~ \"\"\"\n no function clause matching in ExceptionTest.Req.get!/2\n\n The following arguments were given to ExceptionTest.Req.get!/2:\n\n # 1\n %URI{scheme: \\\"https\\\", authority: \\\"elixir-lang.org\\\", userinfo: nil, host: \\\"elixir-lang.org\\\", port: 443, path: nil, query: nil, fragment: nil}\n\n # 2\n URI\n\n Attempted function clauses (showing 1 out of 1):\n\n def get!(url, url_module) when -is_binary(url)- or is_struct(url) and is_struct(url, url_module) and -false-\n \"\"\"\n\n assert blame_message(Req, & &1.get!(elixir_uri)) =~ \"\"\"\n no function clause matching in ExceptionTest.Req.get!/1\n\n The following arguments were given to ExceptionTest.Req.get!/1:\n\n # 1\n %URI{scheme: \\\"https\\\", authority: \\\"elixir-lang.org\\\", userinfo: nil, host: \\\"elixir-lang.org\\\", port: 443, path: nil, query: nil, fragment: nil}\n\n Attempted function clauses (showing 1 out of 1):\n\n def get!(url) when -is_binary(url)- or is_struct(url) and is_struct(url, URI) and -false-\n \"\"\"\n\n assert blame_message(Req, & &1.sub_get!(%{})) =~ \"\"\"\n no function clause matching in ExceptionTest.Req.sub_get!/1\n\n The following arguments were given to ExceptionTest.Req.sub_get!/1:\n\n # 1\n %{}\n\n Attempted function clauses (showing 1 out of 1):\n\n def sub_get!(url) when -is_struct(url.sub, URI)-\n \"\"\"\n end\n\n test \"annotates badarg on apply\" do\n assert blame_message([], & &1.foo()) ==\n \"you attempted to apply a function named :foo on []. If you are using Kernel.apply/3, make sure \" <>\n \"the module is an atom. If you are using the dot syntax, such as \" <>\n \"module.function(), make sure the left-hand side of the dot is an atom representing a module\"\n\n assert blame_message([], &apply(&1, :foo, [])) ==\n \"you attempted to apply a function named :foo on []. If you are using Kernel.apply/3, make sure \" <>\n \"the module is an atom. If you are using the dot syntax, such as \" <>\n \"module.function(), make sure the left-hand side of the dot is an atom representing a module\"\n\n assert blame_message([], &apply(&1, :foo, [1, 2])) ==\n \"you attempted to apply a function on []. Modules (the first argument of apply) must always be an atom\"\n end\n\n test \"annotates function clause errors\" do\n import PathHelpers\n\n write_beam(\n defmodule ExampleModule do\n def fun(arg1, arg2)\n def fun(:one, :one), do: :ok\n def fun(:two, :two), do: :ok\n end\n )\n\n message = blame_message(ExceptionTest.ExampleModule, & &1.fun(:three, :four))\n\n assert message =~ \"\"\"\n no function clause matching in ExceptionTest.ExampleModule.fun/2\n\n The following arguments were given to ExceptionTest.ExampleModule.fun/2:\n\n # 1\n :three\n\n # 2\n :four\n\n Attempted function clauses (showing 2 out of 2):\n\n def fun(-:one-, -:one-)\n def fun(-:two-, -:two-)\n \"\"\"\n end\n\n test \"annotates undefined function error with suggestions\" do\n assert blame_message(Enum, & &1.map(:ok)) == \"\"\"\n function Enum.map/1 is undefined or private. Did you mean:\n\n * map/2\n \"\"\"\n\n assert blame_message(Enum, & &1.man(:ok)) == \"\"\"\n function Enum.man/1 is undefined or private. Did you mean:\n\n * map/2\n * max/1\n * max/2\n * max/3\n * min/1\n \"\"\"\n\n message = blame_message(:erlang, & &1.gt_cookie())\n assert message =~ \"function :erlang.gt_cookie/0 is undefined or private. Did you mean:\"\n assert message =~ \"* get_cookie/0\"\n assert message =~ \"* set_cookie/2\"\n end\n\n test \"annotates undefined function error with module suggestions\" do\n import PathHelpers\n\n modules = [\n Namespace.A.One,\n Namespace.A.Two,\n Namespace.A.Three,\n Namespace.B.One,\n Namespace.B.Two,\n Namespace.B.Three\n ]\n\n for module <- modules do\n write_beam(\n defmodule module do\n def foo, do: :bar\n end\n )\n end\n\n assert blame_message(ENUM, & &1.map(&1, 1)) == \"\"\"\n function ENUM.map/2 is undefined (module ENUM is not available). Did you mean:\n\n * Enum.map/2\n \"\"\"\n\n assert blame_message(ENUM, & &1.not_a_function(&1, 1)) ==\n \"function ENUM.not_a_function/2 is undefined (module ENUM is not available). \" <>\n \"Make sure the module name is correct and has been specified in full (or that an alias has been defined)\"\n\n assert blame_message(One, & &1.foo()) == \"\"\"\n function One.foo/0 is undefined (module One is not available). Did you mean:\n\n * Namespace.A.One.foo/0\n * Namespace.B.One.foo/0\n \"\"\"\n\n for module <- modules do\n :code.purge(module)\n :code.delete(module)\n end\n end\n\n test \"annotates undefined function clause error with macro hints\" do\n assert blame_message(Integer, & &1.is_odd(1)) ==\n \"function Integer.is_odd/1 is undefined or private. However, there is \" <>\n \"a macro with the same name and arity. Be sure to require Integer if \" <>\n \"you intend to invoke this macro\"\n end\n\n test \"annotates undefined function clause error with callback hints\" do\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Behaviour do\n @callback callback() :: :ok\n end\n\n defmodule Implementation do\n @behaviour Behaviour\n end\n \"\"\")\n end)\n\n assert blame_message(Implementation, & &1.callback()) ==\n \"function Implementation.callback/0 is undefined or private\" <>\n \", but the behaviour Behaviour expects it to be present\"\n end\n\n test \"does not annotate undefined function clause error with callback hints when callback is optional\" do\n defmodule BehaviourWithOptional do\n @callback callback() :: :ok\n @callback optional() :: :ok\n @optional_callbacks callback: 0, optional: 0\n end\n\n defmodule ImplementationWithOptional do\n @behaviour BehaviourWithOptional\n def callback(), do: :ok\n end\n\n assert blame_message(ImplementationWithOptional, & &1.optional()) ==\n \"function ExceptionTest.ImplementationWithOptional.optional/0 is undefined or private\"\n end\n\n test \"annotates undefined function clause error with otp obsolete hints\" do\n assert blame_message(:erlang, & &1.hash(1, 2)) ==\n \"function :erlang.hash/2 is undefined or private, use erlang:phash2/2 instead\"\n end\n\n test \"annotates undefined function clause error with nil hints\" do\n assert blame_message(nil, & &1.foo()) ==\n \"function nil.foo/0 is undefined. If you are using the dot syntax, \" <>\n \"such as module.function(), make sure the left-hand side of \" <>\n \"the dot is a module atom\"\n\n assert blame_message(\"nil.foo()\", &Code.eval_string/1) ==\n \"function nil.foo/0 is undefined. If you are using the dot syntax, \" <>\n \"such as module.function(), make sure the left-hand side of \" <>\n \"the dot is a module atom\"\n end\n\n test \"annotates key error with suggestions if keys are atoms\" do\n message = blame_message(%{first: nil, second: nil}, fn map -> map.firts end)\n\n assert message ==\n \"\"\"\n key :firts not found in:\n\n %{first: nil, second: nil}\n\n Did you mean:\n\n * :first\n \"\"\"\n\n message = blame_message(%{\"first\" => nil, \"second\" => nil}, fn map -> map.firts end)\n\n assert message == \"\"\"\n key :firts not found in:\n\n %{\"first\" => nil, \"second\" => nil}\n \"\"\"\n\n message =\n blame_message(%{\"first\" => nil, \"second\" => nil}, fn map -> Map.fetch!(map, \"firts\") end)\n\n assert message ==\n \"\"\"\n key \"firts\" not found in:\n\n %{\"first\" => nil, \"second\" => nil}\n \"\"\"\n\n message =\n blame_message(\n [\n created_at: nil,\n updated_at: nil,\n deleted_at: nil,\n started_at: nil,\n finished_at: nil\n ],\n fn kwlist ->\n Keyword.fetch!(kwlist, :inserted_at)\n end\n )\n\n assert message == \"\"\"\n key :inserted_at not found in:\n\n [\n created_at: nil,\n updated_at: nil,\n deleted_at: nil,\n started_at: nil,\n finished_at: nil\n ]\n\n Did you mean:\n\n * :created_at\n * :finished_at\n * :started_at\n \"\"\"\n end\n\n test \"annotates key error with suggestions for structs\" do\n message = blame_message(%URI{}, fn map -> map.schema end)\n assert message =~ \"key :schema not found in:\\n\\n %URI{\"\n assert message =~ \"Did you mean:\"\n assert message =~ \"* :scheme\"\n end\n\n test \"annotates +/1 arithmetic errors\" do\n assert blame_message(:foo, &(+&1)) == \"bad argument in arithmetic expression: +(:foo)\"\n end\n\n test \"annotates -/1 arithmetic errors\" do\n assert blame_message(:foo, &(-&1)) == \"bad argument in arithmetic expression: -(:foo)\"\n end\n\n test \"annotates div arithmetic errors\" do\n assert blame_message(0, &div(10, &1)) ==\n \"bad argument in arithmetic expression: div(10, 0)\"\n end\n\n test \"annotates rem arithmetic errors\" do\n assert blame_message(0, &rem(10, &1)) ==\n \"bad argument in arithmetic expression: rem(10, 0)\"\n end\n\n test \"annotates band arithmetic errors\" do\n import Bitwise\n\n assert blame_message(:foo, &band(&1, 10)) ==\n \"bad argument in arithmetic expression: Bitwise.band(:foo, 10)\"\n\n assert blame_message(:foo, &(&1 &&& 10)) ==\n \"bad argument in arithmetic expression: Bitwise.band(:foo, 10)\"\n end\n\n test \"annotates bor arithmetic errors\" do\n import Bitwise\n\n assert blame_message(:foo, &bor(&1, 10)) ==\n \"bad argument in arithmetic expression: Bitwise.bor(:foo, 10)\"\n\n assert blame_message(:foo, &(&1 ||| 10)) ==\n \"bad argument in arithmetic expression: Bitwise.bor(:foo, 10)\"\n end\n\n test \"annotates bxor arithmetic errors\" do\n import Bitwise\n\n assert blame_message(:foo, &bxor(&1, 10)) ==\n \"bad argument in arithmetic expression: Bitwise.bxor(:foo, 10)\"\n end\n\n test \"annotates bsl arithmetic errors\" do\n import Bitwise\n\n assert blame_message(:foo, &bsl(10, &1)) ==\n \"bad argument in arithmetic expression: Bitwise.bsl(10, :foo)\"\n\n assert blame_message(:foo, &(10 <<< &1)) ==\n \"bad argument in arithmetic expression: Bitwise.bsl(10, :foo)\"\n end\n\n test \"annotates bsr arithmetic errors\" do\n import Bitwise\n\n assert blame_message(:foo, &bsr(10, &1)) ==\n \"bad argument in arithmetic expression: Bitwise.bsr(10, :foo)\"\n\n assert blame_message(:foo, &(10 >>> &1)) ==\n \"bad argument in arithmetic expression: Bitwise.bsr(10, :foo)\"\n end\n\n test \"annotates bnot arithmetic errors\" do\n import Bitwise\n\n assert blame_message(:foo, &bnot(&1)) ==\n \"bad argument in arithmetic expression: Bitwise.bnot(:foo)\"\n end\n\n defp blame_message(arg, fun) do\n try do\n fun.(arg)\n rescue\n e ->\n Exception.blame(:error, e, __STACKTRACE__) |> elem(0) |> Exception.message()\n end\n end\n end\n\n describe \"blaming unit tests\" do\n test \"annotates clauses errors\" do\n import PathHelpers\n\n write_beam(\n defmodule BlameModule do\n def fun(arg), do: arg\n end\n )\n\n args = [nil]\n\n {exception, stack} =\n Exception.blame(:error, :function_clause, [{BlameModule, :fun, args, [line: 13]}])\n\n assert %FunctionClauseError{kind: :def, args: ^args, clauses: [_]} = exception\n assert stack == [{BlameModule, :fun, 1, [line: 13]}]\n end\n\n @tag :require_ast\n test \"annotates args and clauses from mfa\" do\n import PathHelpers\n\n write_beam(\n defmodule Blaming do\n def with_elem(x, y) when elem(x, 1) == 0 and elem(x, y) == 1 do\n {x, y}\n end\n\n def fetch(%module{} = container, key), do: {module, container, key}\n def fetch(map, key) when is_map(map), do: {map, key}\n def fetch(list, key) when is_list(list) and is_atom(key), do: {list, key}\n def fetch(nil, _key), do: nil\n\n require Integer\n def even_and_odd(foo, bar) when Integer.is_even(foo) and Integer.is_odd(bar), do: :ok\n end\n )\n\n :code.purge(Blaming)\n :code.delete(Blaming)\n\n {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :with_elem, [1, 2])\n\n assert annotated_clauses_to_string(clauses) == [\n \"{[+x+, +y+], [-elem(x, 1) == 0- and -elem(x, y) == 1-]}\"\n ]\n\n {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :fetch, [self(), \"oops\"])\n\n assert annotated_clauses_to_string(clauses) == [\n \"{[-%module{} = container-, +key+], []}\",\n \"{[+map+, +key+], [-is_map(map)-]}\",\n \"{[+list+, +key+], [-is_list(list)- and -is_atom(key)-]}\",\n \"{[-nil-, +_key+], []}\"\n ]\n\n {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :even_and_odd, [1, 1])\n\n assert annotated_clauses_to_string(clauses) == [\n \"{[+foo+, +bar+], [+is_integer(foo)+ and -Bitwise.band(foo, 1) == 0- and +is_integer(bar)+ and +Bitwise.band(bar, 1) == 1+]}\"\n ]\n\n {:ok, :defmacro, clauses} = Exception.blame_mfa(Kernel, :!, [true])\n\n assert annotated_clauses_to_string(clauses) == [\n \"{[-{:!, _, [value]}-], []}\",\n \"{[+value+], []}\"\n ]\n end\n\n defp annotated_clauses_to_string(clauses) do\n Enum.map(clauses, fn {args, clauses} ->\n args = Enum.map_join(args, \", \", &arg_to_string/1)\n clauses = Enum.map_join(clauses, \", \", &clause_to_string/1)\n \"{[#{args}], [#{clauses}]}\"\n end)\n end\n\n defp arg_to_string(%{match?: true, node: node}), do: \"+\" <> Macro.to_string(node) <> \"+\"\n defp arg_to_string(%{match?: false, node: node}), do: \"-\" <> Macro.to_string(node) <> \"-\"\n\n defp clause_to_string({op, _, [left, right]}),\n do: clause_to_string(left) <> \" #{op} \" <> clause_to_string(right)\n\n defp clause_to_string(other),\n do: arg_to_string(other)\n end\n\n describe \"exception messages\" do\n import Exception, only: [message: 1]\n\n test \"RuntimeError\" do\n assert %RuntimeError{} |> message() == \"runtime error\"\n assert %RuntimeError{message: \"unexpected roquefort\"} |> message() == \"unexpected roquefort\"\n end\n\n test \"ArithmeticError\" do\n assert %ArithmeticError{} |> message() == \"bad argument in arithmetic expression\"\n\n assert %ArithmeticError{message: \"unexpected camembert\"}\n |> message() == \"unexpected camembert\"\n end\n\n test \"ArgumentError\" do\n assert %ArgumentError{} |> message() == \"argument error\"\n assert %ArgumentError{message: \"unexpected comté\"} |> message() == \"unexpected comté\"\n end\n\n test \"KeyError\" do\n assert %KeyError{} |> message() == \"key nil not found\"\n assert %KeyError{message: \"key missed\"} |> message() == \"key missed\"\n end\n\n test \"Enum.OutOfBoundsError\" do\n assert %Enum.OutOfBoundsError{} |> message() == \"out of bounds error\"\n\n assert %Enum.OutOfBoundsError{message: \"the brie is not on the table\"}\n |> message() == \"the brie is not on the table\"\n end\n\n test \"Enum.EmptyError\" do\n assert %Enum.EmptyError{} |> message() == \"empty error\"\n\n assert %Enum.EmptyError{message: \"there is no saint-nectaire left!\"}\n |> message() == \"there is no saint-nectaire left!\"\n end\n\n test \"UndefinedFunctionError\" do\n assert %UndefinedFunctionError{} |> message() == \"undefined function\"\n\n assert %UndefinedFunctionError{module: Kernel, function: :bar, arity: 1}\n |> message() == \"function Kernel.bar/1 is undefined or private\"\n\n assert %UndefinedFunctionError{module: Foo, function: :bar, arity: 1}\n |> message() ==\n \"function Foo.bar/1 is undefined (module Foo is not available). \" <>\n \"Make sure the module name is correct and has been specified in full (or that an alias has been defined)\"\n\n assert %UndefinedFunctionError{module: nil, function: :bar, arity: 3}\n |> message() == \"function nil.bar/3 is undefined\"\n\n assert %UndefinedFunctionError{module: nil, function: :bar, arity: 0}\n |> message() == \"function nil.bar/0 is undefined\"\n end\n\n test \"FunctionClauseError\" do\n assert %FunctionClauseError{} |> message() == \"no function clause matches\"\n\n assert %FunctionClauseError{module: Foo, function: :bar, arity: 1}\n |> message() == \"no function clause matching in Foo.bar/1\"\n end\n\n test \"ErlangError\" do\n assert %ErlangError{original: :sample} |> message() == \"Erlang error: :sample\"\n end\n\n test \"MissingApplicationsError\" do\n assert %MissingApplicationsError{\n apps: [{:logger, \"~> 1.18\"}, {:ex_unit, Version.parse_requirement!(\">= 0.0.0\")}],\n description: \"applications are required\"\n }\n |> message() == \"\"\"\n applications are required\n\n To address this, include these applications as your dependencies:\n\n {:logger, \"~> 1.18\"}\n {:ex_unit, \">= 0.0.0\"}\\\n \"\"\"\n end\n end\n\n describe \"error_info\" do\n test \"badarg on erlang\" do\n assert message(:erlang, & &1.element(\"foo\", \"bar\")) == \"\"\"\n errors were found at the given arguments:\n\n * 1st argument: not an integer\n * 2nd argument: not a tuple\n \"\"\"\n end\n\n test \"badarg on ets\" do\n ets = :ets.new(:foo, [])\n :ets.delete(ets)\n\n assert message(:ets, & &1.insert(ets, 1)) == \"\"\"\n errors were found at the given arguments:\n\n * 1st argument: the table identifier does not refer to an existing ETS table\n * 2nd argument: not a tuple\n \"\"\"\n end\n\n test \"system_limit on counters\" do\n assert message(:counters, & &1.new(123_456_789_123_456_789_123_456_789, [])) == \"\"\"\n a system limit has been reached due to errors at the given arguments:\n\n * 1st argument: counters array size reached a system limit\n \"\"\"\n end\n end\n\n describe \"binary constructor error info\" do\n defp concat(a, b), do: a <> b\n\n test \"on binary concatenation\" do\n assert message(123, &concat(&1, \"bar\")) ==\n \"construction of binary failed: segment 1 of type 'binary': expected a binary but got: 123\"\n\n assert message(~D[0001-02-03], &concat(&1, \"bar\")) ==\n \"construction of binary failed: segment 1 of type 'binary': expected a binary but got: ~D[0001-02-03]\"\n end\n end\n\n defp message(arg, fun) do\n try do\n fun.(arg)\n rescue\n e -> Exception.message(e)\n end\n end\n\n def dummy_error_extras(_exception, _stacktrace), do: %{general: \"foo\"}\n\n def dummy_error_chardata(_exception, _stacktrace) do\n %{general: ~c\"this is \" ++ [~c\"chardata\"], reason: ~c\"this \" ++ [~c\"too\"]}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/file/stream_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule File.StreamTest do\n use ExUnit.Case\n import PathHelpers\n\n setup do\n File.mkdir_p!(tmp_path())\n on_exit(fn -> File.rm_rf(tmp_path()) end)\n :ok\n end\n\n defp stream!(node, src, lines_or_bytes_or_modes \\\\ []) do\n :erpc.call(node, File, :stream!, [src, lines_or_bytes_or_modes])\n end\n\n defp stream!(node, src, modes, lines_or_bytes) do\n :erpc.call(node, File, :stream!, [src, modes, lines_or_bytes])\n end\n\n distributed_node = :\"secondary@#{node() |> Atom.to_string() |> :binary.split(\"@\") |> tl()}\"\n\n for {type, node} <- [local: node(), distributed: distributed_node] do\n describe \"#{type} node\" do\n @describetag type\n @node node\n\n test \"returns a struct\" do\n src = fixture_path(\"file.txt\")\n stream = stream!(@node, src)\n assert %File.Stream{} = stream\n assert stream.modes == [:raw, :read_ahead, :binary]\n assert stream.raw\n assert stream.line_or_bytes == :line\n\n stream = stream!(@node, src, read_ahead: false)\n assert %File.Stream{} = stream\n assert stream.modes == [:raw, :binary]\n assert stream.raw\n\n stream = stream!(@node, src, read_ahead: 5000)\n assert %File.Stream{} = stream\n assert stream.modes == [:raw, {:read_ahead, 5000}, :binary]\n assert stream.raw\n\n stream = stream!(@node, src, 10, [:utf8])\n assert %File.Stream{} = stream\n assert stream.modes == [{:encoding, :utf8}, :binary]\n refute stream.raw\n assert stream.line_or_bytes == 10\n end\n\n test \"counts bytes/characters\" do\n src = fixture_path(\"file.txt\")\n stream = stream!(@node, src)\n assert Enum.count(stream) == 1\n\n stream = stream!(@node, src, [:utf8])\n assert Enum.count(stream) == 1\n\n stream = stream!(@node, src, 2)\n assert Enum.count(stream) == 2\n end\n\n test \"counts lines without trailing newline\" do\n no_trailing = tmp_path(\"no_trailing.txt\")\n single_line = tmp_path(\"single_line.txt\")\n empty_file = tmp_path(\"empty.txt\")\n\n try do\n File.write!(no_trailing, \"line1\\nline2\\nline3\")\n File.write!(single_line, \"hello\")\n File.write!(empty_file, \"\")\n\n # 3 lines, no trailing newline\n stream = stream!(@node, no_trailing)\n assert Enum.count(stream) == 3\n\n # 1 line, no newline at all\n stream = stream!(@node, single_line)\n assert Enum.count(stream) == 1\n\n # empty file\n stream = stream!(@node, empty_file)\n assert Enum.count(stream) == 0\n after\n File.rm(no_trailing)\n File.rm(single_line)\n File.rm(empty_file)\n end\n end\n\n test \"reads and writes lines\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n stream = stream!(@node, src)\n\n File.open(dest, [:write], fn target ->\n Enum.each(stream, fn line ->\n IO.write(target, String.replace(line, \"O\", \"A\"))\n end)\n end)\n\n assert File.read(dest) == {:ok, \"FAA\\n\"}\n after\n File.rm(dest)\n end\n end\n\n test \"reads and writes bytes\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n stream = stream!(@node, src, 1)\n\n File.open(dest, [:write], fn target ->\n Enum.each(stream, fn <> ->\n IO.write(target, <>)\n end)\n end)\n\n assert File.read(dest) == {:ok, \"GPP\\v\"}\n after\n File.rm(dest)\n end\n end\n\n test \"is collectable\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n original = stream!(@node, dest)\n\n stream =\n stream!(@node, src)\n |> Stream.map(&String.replace(&1, \"O\", \"A\"))\n |> Enum.into(original)\n\n assert stream == original\n assert File.read(dest) == {:ok, \"FAA\\n\"}\n after\n File.rm(dest)\n end\n end\n\n test \"is collectable with append\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n original = stream!(@node, dest, [:append])\n\n stream!(@node, src, [:append])\n |> Stream.map(&String.replace(&1, \"O\", \"A\"))\n |> Enum.into(original)\n\n stream!(@node, src, [:append])\n |> Enum.into(original)\n\n assert File.read(dest) == {:ok, \"FAA\\nFOO\\n\"}\n after\n File.rm(dest)\n end\n end\n\n test \"supports byte offset\" do\n src = fixture_path(\"file.txt\")\n\n assert @node\n |> stream!(src, read_offset: 0)\n |> Enum.take(1) == [\"FOO\\n\"]\n\n assert @node\n |> stream!(src, read_offset: 1)\n |> Enum.take(1) == [\"OO\\n\"]\n\n assert @node\n |> stream!(src, read_offset: 4)\n |> Enum.take(1) == []\n\n assert @node |> stream!(src, 1, read_offset: 1) |> Enum.count() == 3\n assert @node |> stream!(src, 1, read_offset: 4) |> Enum.count() == 0\n end\n\n test \"applies offset after trimming BOM\" do\n src = fixture_path(\"utf8_bom.txt\")\n\n assert @node\n |> stream!(src, [:trim_bom, read_offset: 4])\n |> Enum.take(1) == [\"сский\\n\"]\n\n assert @node |> stream!(src, 1, [:trim_bom, read_offset: 4]) |> Enum.count() == 15\n end\n\n test \"keeps BOM when raw\" do\n src = fixture_path(\"utf8_bom.txt\")\n\n assert @node\n |> stream!(src, [])\n |> Enum.take(1) == [<<239, 187, 191>> <> \"Русский\\n\"]\n\n assert @node\n |> stream!(src, 1)\n |> Enum.take(5) == [<<239>>, <<187>>, <<191>>, <<208>>, <<160>>]\n\n assert @node |> stream!(src, []) |> Enum.count() == 2\n assert @node |> stream!(src, 1) |> Enum.count() == 22\n end\n\n test \"trims BOM via option when raw\" do\n src = fixture_path(\"utf8_bom.txt\")\n\n assert @node\n |> stream!(src, [:trim_bom])\n |> Enum.take(1) == [\"Русский\\n\"]\n\n assert @node\n |> stream!(src, 1, [:trim_bom])\n |> Enum.take(5) == [<<208>>, <<160>>, <<209>>, <<131>>, <<209>>]\n\n assert @node |> stream!(src, [:trim_bom]) |> Enum.count() == 2\n assert @node |> stream!(src, 1, [:trim_bom]) |> Enum.count() == 19\n assert @node |> stream!(src, 2, [:trim_bom]) |> Enum.count() == 10\n end\n\n test \"keeps BOM with utf8 encoding\" do\n src = fixture_path(\"utf8_bom.txt\")\n\n assert @node\n |> stream!(src, encoding: :utf8)\n |> Enum.take(1) == [<<239, 187, 191>> <> \"Русский\\n\"]\n\n assert @node\n |> stream!(src, 1, encoding: :utf8)\n |> Enum.take(9) == [\"\\uFEFF\", \"Р\", \"у\", \"с\", \"с\", \"к\", \"и\", \"й\", \"\\n\"]\n end\n\n test \"trims BOM via option with utf8 encoding\" do\n src = fixture_path(\"utf8_bom.txt\")\n\n assert @node\n |> stream!(src, [{:encoding, :utf8}, :trim_bom])\n |> Enum.take(1) == [\"Русский\\n\"]\n\n assert @node\n |> stream!(src, 1, [{:encoding, :utf8}, :trim_bom])\n |> Enum.take(8) == [\"Р\", \"у\", \"с\", \"с\", \"к\", \"и\", \"й\", \"\\n\"]\n end\n\n test \"keeps BOM with UTF16 BE\" do\n src = fixture_path(\"utf16_be_bom.txt\")\n\n assert @node\n |> stream!(src, [{:encoding, {:utf16, :big}}])\n |> Enum.take(1) == [\"\\uFEFFРусский\\n\"]\n end\n\n test \"keeps BOM with UTF16 LE\" do\n src = fixture_path(\"utf16_le_bom.txt\")\n\n assert @node\n |> stream!(src, [{:encoding, {:utf16, :little}}])\n |> Enum.take(1) == [\"\\uFEFFРусский\\n\"]\n end\n\n test \"trims BOM via option with utf16 BE encoding\" do\n src = fixture_path(\"utf16_be_bom.txt\")\n\n assert @node\n |> stream!(src, [{:encoding, {:utf16, :big}}, :trim_bom])\n |> Enum.take(1) == [\"Русский\\n\"]\n\n assert @node\n |> stream!(src, 1, [{:encoding, {:utf16, :big}}, :trim_bom])\n |> Enum.take(8) == [\"Р\", \"у\", \"с\", \"с\", \"к\", \"и\", \"й\", \"\\n\"]\n end\n\n test \"trims BOM via option with utf16 LE encoding\" do\n src = fixture_path(\"utf16_le_bom.txt\")\n\n assert @node\n |> stream!(src, [{:encoding, {:utf16, :little}}, :trim_bom])\n |> Enum.take(1) == [\"Русский\\n\"]\n\n assert @node\n |> stream!(src, 1, [{:encoding, {:utf16, :little}}, :trim_bom])\n |> Enum.take(8) == [\"Р\", \"у\", \"с\", \"с\", \"к\", \"и\", \"й\", \"\\n\"]\n end\n\n test \"reads and writes line by line in UTF-8\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n stream = stream!(@node, src)\n\n File.open(dest, [:write, :utf8], fn target ->\n Enum.each(stream, fn line ->\n IO.write(target, String.replace(line, \"O\", \"A\"))\n end)\n end)\n\n assert File.read(dest) == {:ok, \"FAA\\n\"}\n after\n File.rm(dest)\n end\n end\n\n test \"reads and writes character in UTF-8\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n stream = stream!(@node, src, 1, [:utf8])\n\n File.open(dest, [:write], fn target ->\n Enum.each(stream, fn <> ->\n IO.write(target, <>)\n end)\n end)\n\n assert File.read(dest) == {:ok, \"GPP\\v\"}\n after\n File.rm(dest)\n end\n end\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/file_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule FileTest do\n use ExUnit.Case\n import PathHelpers\n\n setup do\n File.mkdir_p!(tmp_path())\n on_exit(fn -> File.rm_rf(tmp_path()) end)\n :ok\n end\n\n describe \"rename\" do\n # Following Erlang's underlying implementation\n #\n # Renaming files\n # :ok -> rename file to existing file default behavior\n # {:error, :eisdir} -> rename file to existing empty dir\n # {:error, :eisdir} -> rename file to existing non-empty dir\n # :ok -> rename file to non-existing location\n # {:error, :eexist} -> rename file to existing file\n # :ok -> rename file to itself\n\n # Renaming dirs\n # {:error, :enotdir} -> rename dir to existing file\n # :ok -> rename dir to non-existing leaf location\n # {:error, ??} -> rename dir to non-existing parent location\n # :ok -> rename dir to itself\n # :ok -> rename dir to existing empty dir default behavior\n # {:error, :eexist} -> rename dir to existing empty dir\n # {:error, :einval} -> rename parent dir to existing sub dir\n # {:error, :einval} -> rename parent dir to non-existing sub dir\n # {:error, :eexist} -> rename dir to existing non-empty dir\n\n # other tests\n # {:error, :enoent} -> rename unknown source\n # :ok -> rename preserves mode\n test \"rename file to existing file default behavior\" do\n src = tmp_fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n File.write!(dest, \"hello\")\n\n try do\n assert File.exists?(dest)\n assert File.rename(src, dest) == :ok\n refute File.exists?(src)\n assert File.read!(dest) == \"FOO\\n\"\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename file to existing empty dir\" do\n src = tmp_fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp\")\n\n try do\n File.mkdir(dest)\n assert File.rename(src, dest) == {:error, :eisdir}\n assert File.exists?(src)\n refute File.exists?(tmp_path(\"tmp/file.txt\"))\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename file to existing non-empty dir\" do\n src = tmp_fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp\")\n\n try do\n File.mkdir_p(Path.join(dest, \"a\"))\n assert File.rename(src, dest) in [{:error, :eisdir}, {:error, :eexist}]\n assert File.exists?(src)\n refute File.exists?(Path.join(dest, \"file.txt\"))\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename file to non-existing location\" do\n src = tmp_fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n try do\n refute File.exists?(dest)\n assert File.rename(src, dest) == :ok\n assert File.exists?(dest)\n refute File.exists?(src)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename file to existing file\" do\n src = tmp_fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n File.write!(dest, \"hello\")\n\n try do\n assert File.exists?(dest)\n assert File.rename(src, dest) == :ok\n refute File.exists?(src)\n assert File.read!(dest) == \"FOO\\n\"\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename file to itself\" do\n src = tmp_fixture_path(\"file.txt\")\n dest = src\n\n try do\n assert File.exists?(src)\n assert File.rename(src, dest) == :ok\n assert File.exists?(src)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename! file to existing file default behavior\" do\n src = tmp_fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n File.write!(dest, \"hello\")\n\n try do\n assert File.exists?(dest)\n assert File.rename!(src, dest) == :ok\n refute File.exists?(src)\n assert File.read!(dest) == \"FOO\\n\"\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename! with invalid file\" do\n src = tmp_fixture_path(\"invalid.txt\")\n dest = tmp_path(\"tmp.file\")\n\n message =\n \"could not rename from #{inspect(src)} to #{inspect(dest)}: no such file or directory\"\n\n assert_raise File.RenameError, message, fn ->\n File.rename!(src, dest)\n end\n end\n\n test \"rename dir to existing file\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp.file\")\n\n try do\n File.touch(dest)\n assert File.rename(src, dest) == {:error, :enotdir}\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename dir to non-existing leaf location\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n try do\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n assert File.rename(src, dest) == :ok\n {:ok, files} = File.ls(dest)\n assert length(files) == 2\n assert \"a\" in files\n\n {:ok, files} = File.ls(tmp_path(\"tmp/a\"))\n assert length(files) == 2\n assert \"1.txt\" in files\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n refute File.exists?(src)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename dir to non-existing parent location\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp/a/b\")\n\n try do\n assert File.rename(src, dest) == {:error, :enoent}\n assert File.exists?(src)\n refute File.exists?(dest)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename dir to itself\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = src\n\n try do\n assert File.exists?(src)\n assert File.rename(src, dest) == :ok\n assert File.exists?(src)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename parent dir to existing sub dir\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"cp_r/a\")\n\n try do\n assert File.exists?(src)\n assert File.rename(src, dest) in [{:error, :einval}, {:error, :eexist}]\n assert File.exists?(src)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename parent dir to non-existing sub dir\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"cp_r/x\")\n\n try do\n assert File.exists?(src)\n assert File.rename(src, dest) == {:error, :einval}\n assert File.exists?(src)\n refute File.exists?(dest)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename dir to existing empty dir default behavior\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir(dest)\n\n try do\n refute File.exists?(tmp_path(\"tmp/a\"))\n\n assert File.rename(src, dest) == :ok\n {:ok, files} = File.ls(dest)\n assert length(files) == 2\n assert \"a\" in files\n\n {:ok, files} = File.ls(tmp_path(\"tmp/a\"))\n assert length(files) == 2\n assert \"1.txt\" in files\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n refute File.exists?(src)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename dir to existing empty dir\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir(dest)\n\n try do\n assert File.exists?(dest)\n assert File.rename(src, dest) == :ok\n refute File.exists?(src)\n assert File.exists?(tmp_path(\"tmp/a\"))\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename dir to existing non-empty dir\" do\n src = tmp_fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir_p(tmp_path(\"tmp/x\"))\n\n try do\n assert File.exists?(tmp_path(\"tmp/x\"))\n assert File.exists?(src)\n refute File.exists?(tmp_path(\"tmp/a\"))\n\n assert File.rename(src, dest) == {:error, :eexist}\n\n assert File.exists?(tmp_path(\"tmp/x\"))\n assert File.exists?(src)\n refute File.exists?(tmp_path(\"tmp/a\"))\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"rename unknown source\" do\n src = fixture_path(\"unknown\")\n dest = tmp_path(\"tmp\")\n\n try do\n assert File.rename(src, dest) == {:error, :enoent}\n after\n File.rm_rf(dest)\n end\n end\n\n test \"rename preserves mode\" do\n File.mkdir_p!(tmp_path(\"tmp\"))\n src = tmp_fixture_path(\"cp_mode\")\n dest = tmp_path(\"tmp/cp_mode\")\n\n try do\n %File.Stat{mode: src_mode} = File.stat!(src)\n File.rename(src, dest)\n %File.Stat{mode: dest_mode} = File.stat!(dest)\n assert src_mode == dest_mode\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n def tmp_fixture_path(extra) do\n src = fixture_path(extra)\n dest = tmp_path(extra)\n File.cp_r(src, dest)\n dest\n end\n end\n\n describe \"cp\" do\n test \"cp with src file and dest file\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"sample.txt\")\n\n File.touch(dest)\n\n try do\n assert File.exists?(dest)\n assert File.cp(src, dest) == :ok\n assert File.exists?(dest)\n after\n File.rm(dest)\n end\n end\n\n test \"cp with src file and dest dir\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir(dest)\n\n try do\n assert File.cp(src, dest) == {:error, :eisdir}\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp with src file and dest unknown\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n try do\n refute File.exists?(dest)\n assert File.cp(src, dest) == :ok\n assert File.exists?(dest)\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp with src dir\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp.file\")\n assert File.cp(src, dest) == {:error, :eisdir}\n end\n\n test \"cp with conflict\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n File.write!(dest, \"hello\")\n\n try do\n assert File.exists?(dest)\n assert File.cp(src, dest) == :ok\n assert File.read!(dest) == \"FOO\\n\"\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp with conflict with function\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n File.write!(dest, \"hello\")\n\n try do\n assert File.exists?(dest)\n\n assert File.cp(src, dest,\n on_conflict: fn src_file, dest_file ->\n assert src_file == src\n assert dest_file == dest\n false\n end\n ) == :ok\n\n assert File.read!(dest) == \"hello\"\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp! with src file and dest file\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"sample.txt\")\n\n File.touch(dest)\n\n try do\n assert File.exists?(dest)\n assert File.cp!(src, dest) == :ok\n assert File.exists?(dest)\n after\n File.rm(dest)\n end\n end\n\n test \"cp! with src dir\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp.file\")\n\n message =\n \"could not copy from #{inspect(src)} to #{inspect(dest)}: illegal operation on a directory\"\n\n assert_raise File.CopyError, message, fn ->\n File.cp!(src, dest)\n end\n end\n\n test \"cp itself\" do\n src = dest = tmp_path(\"tmp.file\")\n\n File.write!(src, \"here\")\n\n try do\n assert File.cp(src, dest) == :ok\n assert File.read!(dest) == \"here\"\n assert File.cp_r(src, dest) == {:ok, []}\n after\n File.rm(dest)\n end\n end\n\n test \"cp_r raises on path with null byte\" do\n assert_raise ArgumentError, ~r/null byte/, fn -> File.cp_r(\"source\", \"foo\\0bar\") end\n assert_raise ArgumentError, ~r/null byte/, fn -> File.cp_r(\"foo\\0bar\", \"dest\") end\n end\n\n test \"cp_r with src file and dest file\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"sample.txt\")\n\n File.touch(dest)\n\n try do\n assert File.exists?(dest)\n assert File.cp_r(src, dest) == {:ok, [dest]}\n assert File.exists?(dest)\n after\n File.rm(dest)\n end\n end\n\n test \"cp_r with src file and dest dir\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir(dest)\n\n try do\n assert io_error?(File.cp_r(src, dest))\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src file and dest unknown\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp.file\")\n\n try do\n refute File.exists?(dest)\n assert File.cp_r(src, dest) == {:ok, [dest]}\n assert File.exists?(dest)\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src dir and dest dir\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir(dest)\n\n try do\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n {:ok, files} = File.cp_r(src, dest)\n assert length(files) == 7\n assert tmp_path(\"tmp/a\") in files\n assert tmp_path(\"tmp/a/1.txt\") in files\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src dir and dest file\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp.file\")\n\n try do\n File.touch!(dest)\n assert File.cp_r(src, dest) |> io_error?()\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src dir and dest unknown\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n try do\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n {:ok, files} = File.cp_r(src, dest)\n assert length(files) == 7\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src unknown\" do\n src = fixture_path(\"unknown\")\n dest = tmp_path(\"tmp\")\n assert File.cp_r(src, dest) == {:error, :enoent, src}\n end\n\n test \"cp_r with absolute symlink\" do\n linked_src = fixture_path(\"cp_r\")\n src = tmp_path(\"tmp/src\")\n dest = tmp_path(\"tmp/dest\")\n\n File.mkdir_p!(src)\n :ok = :file.make_symlink(Path.join(linked_src, \"a\"), Path.join(src, \"sym\"))\n\n try do\n {:ok, files} = File.cp_r(src, dest)\n assert length(files) == 2\n\n assert File.exists?(tmp_path(\"tmp/dest/sym/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/dest/sym/a/2.txt\"))\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with dereference absolute symlink\" do\n linked_src = fixture_path(\"cp_r\")\n src = tmp_path(\"tmp/src\")\n dest = tmp_path(\"tmp/dest\")\n\n File.mkdir_p!(src)\n :ok = :file.make_symlink(Path.join(linked_src, \"a\"), Path.join(src, \"sym\"))\n\n try do\n {:ok, files} = File.cp_r(src, dest, dereference_symlinks: true)\n assert length(files) == 5\n\n assert File.exists?(tmp_path(\"tmp/dest/sym/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/dest/sym/a/2.txt\"))\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n @tag :unix\n test \"cp_r with relative symlink\" do\n doc = tmp_path(\"tmp/doc\")\n src = tmp_path(\"tmp/src\")\n dest = tmp_path(\"tmp/dest\")\n\n File.mkdir_p!(src)\n File.write!(doc, \"hello\")\n :ok = :file.make_symlink(\"../doc\", Path.join(src, \"sym\"))\n\n try do\n {:ok, files} = File.cp_r(src, dest)\n assert length(files) == 2\n assert File.lstat!(tmp_path(\"tmp/dest/sym\")).type == :symlink\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n @tag :unix\n test \"cp_r with dereference relative symlink\" do\n doc = tmp_path(\"tmp/doc\")\n src = tmp_path(\"tmp/src\")\n dest = tmp_path(\"tmp/dest\")\n\n File.mkdir_p!(src)\n File.write!(doc, \"hello\")\n :ok = :file.make_symlink(\"../doc\", Path.join(src, \"sym\"))\n\n try do\n {:ok, files} = File.cp_r(src, dest, dereference_symlinks: true)\n assert length(files) == 2\n assert File.lstat!(tmp_path(\"tmp/dest/sym\")).type == :regular\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n @tag :unix\n test \"cp_r with dereference symlink cycle returns eloop error\" do\n src = tmp_path(\"tmp/src\")\n dest = tmp_path(\"tmp/dest\")\n\n File.mkdir_p!(src)\n :ok = :file.make_symlink(Path.join(src, \"b\"), Path.join(src, \"a\"))\n :ok = :file.make_symlink(Path.join(src, \"a\"), Path.join(src, \"b\"))\n\n try do\n assert {:error, :eloop, _} = File.cp_r(src, dest, dereference_symlinks: true)\n after\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with dir and file conflict\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n try do\n File.mkdir(dest)\n File.write!(Path.join(dest, \"a\"), \"hello\")\n assert io_error?(File.cp_r(src, dest))\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src dir and dest dir using lists\" do\n src = fixture_path(\"cp_r\") |> to_charlist()\n dest = tmp_path(\"tmp\") |> to_charlist()\n\n File.mkdir(dest)\n\n try do\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n {:ok, files} = File.cp_r(src, dest)\n assert length(files) == 7\n assert Enum.all?(files, &is_binary/1)\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src with file conflict\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir_p(tmp_path(\"tmp/a\"))\n File.write!(tmp_path(\"tmp/a/1.txt\"), \"hello\")\n\n try do\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n File.cp_r(src, dest)\n assert File.read!(tmp_path(\"tmp/a/1.txt\")) == \"\"\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r with src with file conflict callback\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir_p(tmp_path(\"tmp/a\"))\n File.write!(tmp_path(\"tmp/a/1.txt\"), \"hello\")\n\n try do\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n\n File.cp_r(src, dest,\n on_conflict: fn src_file, dest_file ->\n assert src_file == fixture_path(\"cp_r/a/1.txt\")\n assert dest_file == tmp_path(\"tmp/a/1.txt\")\n false\n end\n )\n\n assert File.read!(tmp_path(\"tmp/a/1.txt\")) == \"hello\"\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r!\" do\n src = fixture_path(\"cp_r\")\n dest = tmp_path(\"tmp\")\n\n File.mkdir(dest)\n\n try do\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n assert length(File.cp_r!(src, dest)) == 7\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n after\n File.rm_rf(dest)\n end\n end\n\n test \"cp_r! with src unknown\" do\n src = fixture_path(\"unknown\")\n dest = tmp_path(\"tmp\")\n\n message =\n \"could not copy recursively from #{inspect(src)} to #{inspect(dest)}. #{src}: no such file or directory\"\n\n assert_raise File.CopyError, message, fn ->\n File.cp_r!(src, dest)\n end\n end\n\n test \"cp_r! with file src and dest unknown\" do\n src = fixture_path(\"cp_r/a/1.txt\")\n dest = tmp_path(\"tmp/unknown/\")\n\n message =\n \"could not copy recursively from #{inspect(src)} to #{inspect(dest)}. #{dest}: no such file or directory\"\n\n assert_raise File.CopyError, message, fn ->\n File.cp_r!(src, dest)\n end\n end\n\n test \"cp_r with destination inside source returns error\" do\n src = tmp_path(\"tmp/src\")\n dest = tmp_path(\"tmp/src/subdir/dest\")\n\n File.mkdir_p!(src)\n File.write!(Path.join(src, \"file.txt\"), \"hello\")\n\n try do\n assert File.cp_r(src, dest) == {:error, :einval, dest}\n refute File.exists?(dest)\n after\n File.rm_rf(src)\n end\n end\n\n test \"cp_r! with destination inside source raises\" do\n src = tmp_path(\"tmp/src\")\n dest = tmp_path(\"tmp/src/subdir/dest\")\n\n File.mkdir_p!(src)\n File.write!(Path.join(src, \"file.txt\"), \"hello\")\n\n try do\n message =\n \"could not copy recursively from #{inspect(src)} to #{inspect(dest)}. #{dest}: invalid argument\"\n\n assert_raise File.CopyError, message, fn ->\n File.cp_r!(src, dest)\n end\n\n refute File.exists?(dest)\n after\n File.rm_rf(src)\n end\n end\n\n test \"cp preserves mode\" do\n File.mkdir_p!(tmp_path(\"tmp\"))\n src = fixture_path(\"cp_mode\")\n dest = tmp_path(\"tmp/cp_mode\")\n\n File.cp!(src, dest)\n %File.Stat{mode: src_mode} = File.stat!(src)\n %File.Stat{mode: dest_mode} = File.stat!(dest)\n assert src_mode == dest_mode\n\n # On overwrite\n File.cp!(src, dest, on_conflict: fn _, _ -> true end)\n %File.Stat{mode: src_mode} = File.stat!(src)\n %File.Stat{mode: dest_mode} = File.stat!(dest)\n assert src_mode == dest_mode\n end\n\n test \"cp_r preserves directory mode\" do\n src = tmp_path(\"tmp/src_dir\")\n dest = tmp_path(\"tmp/dest_dir\")\n inner = Path.join(src, \"inner\")\n\n File.mkdir_p!(inner)\n File.chmod!(inner, 0o700)\n\n try do\n File.cp_r!(src, dest)\n\n %File.Stat{mode: src_mode} = File.stat!(inner)\n %File.Stat{mode: dest_mode} = File.stat!(Path.join(dest, \"inner\"))\n assert src_mode == dest_mode\n after\n File.rm_rf!(src)\n File.rm_rf!(dest)\n end\n end\n\n @tag :unix\n test \"cp_r skips sockets and other special files\" do\n # We use tmpdir because macOS has a limit on socket paths\n src = Path.join(System.tmp_dir(), \"src_with_socket\")\n dest = tmp_path(\"dest_with_socket\")\n socket_path = Path.join(src, \"test.sock\")\n regular_path = Path.join(src, \"regular.txt\")\n\n File.mkdir_p!(src)\n File.write!(regular_path, \"content\")\n\n {:ok, socket} = :gen_tcp.listen(0, [:local, {:ifaddr, {:local, socket_path}}])\n\n try do\n assert File.exists?(socket_path)\n assert :elixir_utils.read_link_type(socket_path) == {:ok, :other}\n\n {:ok, copied_files} = File.cp_r(src, dest)\n assert Path.join(dest, \"regular.txt\") in copied_files\n\n refute File.exists?(Path.join(dest, \"test.sock\"))\n refute Path.join(dest, \"test.sock\") in copied_files\n after\n :gen_tcp.close(socket)\n File.rm_rf(src)\n File.rm_rf(dest)\n end\n end\n end\n\n defmodule Queries do\n use ExUnit.Case\n\n test \"regular\" do\n assert File.regular?(__ENV__.file)\n assert File.regular?(String.to_charlist(__ENV__.file))\n refute File.regular?(\"#{__ENV__.file}.unknown\")\n end\n\n test \"exists\" do\n assert File.exists?(__ENV__.file)\n assert File.exists?(fixture_path())\n assert File.exists?(fixture_path(\"file.txt\"))\n\n refute File.exists?(fixture_path(\"missing.txt\"))\n refute File.exists?(\"_missing.txt\")\n end\n\n test \"exists with dangling symlink\" do\n invalid_file = tmp_path(\"invalid_file\")\n dest = tmp_path(\"dangling_symlink\")\n File.ln_s(invalid_file, dest)\n\n try do\n refute File.exists?(dest)\n after\n File.rm(dest)\n end\n end\n end\n\n test \"ls\" do\n {:ok, value} = File.ls(fixture_path())\n assert \"code_sample.exs\" in value\n assert \"file.txt\" in value\n\n {:error, :enoent} = File.ls(fixture_path(\"non-existent-subdirectory\"))\n end\n\n test \"ls!\" do\n value = File.ls!(fixture_path())\n assert \"code_sample.exs\" in value\n assert \"file.txt\" in value\n\n assert_raise File.Error, fn ->\n File.ls!(fixture_path(\"non-existent-subdirectory\"))\n end\n end\n\n describe \"open-read-write\" do\n test \"read with binary\" do\n assert {:ok, \"FOO\\n\"} = File.read(fixture_path(\"file.txt\"))\n assert {:error, :enoent} = File.read(fixture_path(\"missing.txt\"))\n end\n\n test \"read with list\" do\n assert {:ok, \"FOO\\n\"} = File.read(Path.expand(~c\"fixtures/file.txt\", __DIR__))\n assert {:error, :enoent} = File.read(Path.expand(~c\"fixtures/missing.txt\", __DIR__))\n end\n\n test \"read with UTF-8\" do\n assert {:ok, \"Русский\\n日\\n\"} = File.read(Path.expand(~c\"fixtures/utf8.txt\", __DIR__))\n end\n\n test \"read with :raw options\" do\n assert {:ok, \"FOO\\n\"} = File.read(fixture_path(\"file.txt\"), [:raw])\n end\n\n test \"read!\" do\n assert File.read!(fixture_path(\"file.txt\")) == \"FOO\\n\"\n expected_message = \"could not read file \\\"fixtures/missing.txt\\\": no such file or directory\"\n\n assert_raise File.Error, expected_message, fn ->\n File.read!(\"fixtures/missing.txt\")\n end\n end\n\n test \"write ASCII content\" do\n fixture = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(fixture)\n assert File.write(fixture, ~c\"test text\") == :ok\n assert File.read(fixture) == {:ok, \"test text\"}\n after\n File.rm(fixture)\n end\n end\n\n test \"write UTF-8\" do\n fixture = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(fixture)\n assert File.write(fixture, \"Русский\\n日\\n\") == :ok\n assert {:ok, \"Русский\\n日\\n\"} == File.read(fixture)\n after\n File.rm(fixture)\n end\n end\n\n test \"write with options\" do\n fixture = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(fixture)\n assert File.write(fixture, \"Русский\\n日\\n\") == :ok\n assert File.write(fixture, \"test text\", [:append]) == :ok\n assert {:ok, \"Русский\\n日\\ntest text\"} == File.read(fixture)\n after\n File.rm(fixture)\n end\n end\n\n test \"open file without modes\" do\n {:ok, file} = File.open(fixture_path(\"file.txt\"))\n assert IO.gets(file, \"\") == \"FOO\\n\"\n assert File.close(file) == :ok\n end\n\n test \"open file with charlist\" do\n {:ok, file} = File.open(fixture_path(\"file.txt\"), [:charlist])\n assert IO.gets(file, \"\") == ~c\"FOO\\n\"\n assert File.close(file) == :ok\n end\n\n test \"open UTF-8 by default\" do\n {:ok, file} = File.open(fixture_path(\"utf8.txt\"), [:utf8])\n assert IO.gets(file, \"\") == \"Русский\\n\"\n assert File.close(file) == :ok\n end\n\n test \"open readonly by default\" do\n {:ok, file} = File.open(fixture_path(\"file.txt\"))\n assert_raise ArgumentError, fn -> IO.write(file, \"foo\") end\n assert File.close(file) == :ok\n end\n\n test \"open with write permission\" do\n fixture = tmp_path(\"tmp_text.txt\")\n\n try do\n {:ok, file} = File.open(fixture, [:write])\n assert IO.write(file, \"foo\") == :ok\n assert File.close(file) == :ok\n assert File.read(fixture) == {:ok, \"foo\"}\n after\n File.rm(fixture)\n end\n end\n\n test \"open with binwrite permission\" do\n fixture = tmp_path(\"tmp_text.txt\")\n\n try do\n {:ok, file} = File.open(fixture, [:write])\n assert IO.binwrite(file, \"Русский\") == :ok\n assert File.close(file) == :ok\n assert_raise ErlangError, fn -> IO.binwrite(file, \"Русский\") end\n assert File.read(fixture) == {:ok, \"Русский\"}\n after\n File.rm(fixture)\n end\n end\n\n test \"open UTF-8 and charlist\" do\n {:ok, file} = File.open(fixture_path(\"utf8.txt\"), [:charlist, :utf8])\n assert IO.gets(file, \"\") == [1056, 1091, 1089, 1089, 1082, 1080, 1081, 10]\n assert File.close(file) == :ok\n end\n\n test \"open respects encoding\" do\n {:ok, file} = File.open(fixture_path(\"utf8.txt\"), [{:encoding, :latin1}])\n\n data =\n <<195, 144, 194, 160, 195, 145, 194, 131, 195, 145, 194, 129, 195, 145>> <>\n <<194, 129, 195, 144, 194, 186, 195, 144, 194, 184, 195, 144, 194, 185, 10>>\n\n assert IO.gets(file, \"\") == data\n assert File.close(file) == :ok\n end\n\n test \"open a missing file\" do\n assert File.open(~c\"missing.txt\") == {:error, :enoent}\n end\n\n test \"open a file with function\" do\n file = fixture_path(\"file.txt\")\n assert File.open(file, &IO.read(&1, :line)) == {:ok, \"FOO\\n\"}\n end\n\n test \"open! a missing file\" do\n message = \"could not open \\\"missing.txt\\\": no such file or directory\"\n\n assert_raise File.Error, message, fn ->\n File.open!(~c\"missing.txt\")\n end\n end\n\n test \"open! a file with function\" do\n file = fixture_path(\"file.txt\")\n assert File.open!(file, &IO.read(&1, :line)) == \"FOO\\n\"\n end\n end\n\n describe \"mkdir\" do\n test \"mkdir with binary\" do\n fixture = tmp_path(\"tmp_test\")\n\n try do\n refute File.exists?(fixture)\n assert File.mkdir(fixture) == :ok\n assert File.exists?(fixture)\n after\n File.rmdir(fixture)\n end\n end\n\n test \"mkdir with list\" do\n fixture = tmp_path(\"tmp_test\") |> to_charlist()\n\n try do\n refute File.exists?(fixture)\n assert File.mkdir(fixture) == :ok\n assert File.exists?(fixture)\n after\n File.rmdir(fixture)\n end\n end\n\n test \"mkdir with invalid path\" do\n fixture = fixture_path(\"file.txt\")\n invalid = Path.join(fixture, \"test\")\n assert File.exists?(fixture)\n assert io_error?(File.mkdir(invalid))\n refute File.exists?(invalid)\n end\n\n test \"mkdir!\" do\n fixture = tmp_path(\"tmp_test\")\n\n try do\n refute File.exists?(fixture)\n assert File.mkdir!(fixture) == :ok\n assert File.exists?(fixture)\n after\n File.rmdir(fixture)\n end\n end\n\n test \"mkdir! with invalid path\" do\n fixture = fixture_path(\"file.txt\")\n invalid = Path.join(fixture, \"test\")\n assert File.exists?(fixture)\n\n message =\n ~r\"\\Acould not make directory #{inspect(invalid)}: (not a directory|no such file or directory)\"\n\n assert_raise File.Error, message, fn ->\n File.mkdir!(invalid)\n end\n end\n\n test \"mkdir_p with one directory\" do\n fixture = tmp_path(\"tmp_test\")\n\n try do\n refute File.exists?(fixture)\n assert File.mkdir_p(fixture) == :ok\n assert File.exists?(fixture)\n after\n File.rm_rf(fixture)\n end\n end\n\n test \"mkdir_p with nested directory and binary\" do\n base = tmp_path(\"tmp_test\")\n fixture = Path.join(base, \"test\")\n refute File.exists?(base)\n\n try do\n assert File.mkdir_p(fixture) == :ok\n assert File.exists?(base)\n assert File.exists?(fixture)\n after\n File.rm_rf(base)\n end\n end\n\n test \"mkdir_p with nested directory and list\" do\n base = tmp_path(\"tmp_test\") |> to_charlist()\n fixture = Path.join(base, \"test\")\n refute File.exists?(base)\n\n try do\n assert File.mkdir_p(fixture) == :ok\n assert File.exists?(base)\n assert File.exists?(fixture)\n after\n File.rm_rf(base)\n end\n end\n\n test \"mkdir_p with nested directory and existing parent\" do\n base = tmp_path(\"tmp_test\")\n fixture = Path.join(base, \"test\")\n\n File.mkdir(base)\n\n try do\n assert File.mkdir_p(fixture) == :ok\n assert File.exists?(base)\n assert File.exists?(fixture)\n after\n File.rm_rf(base)\n end\n end\n\n test \"mkdir_p with invalid path\" do\n assert File.exists?(fixture_path(\"file.txt\"))\n invalid = Path.join(fixture_path(\"file.txt\"), \"test/foo\")\n assert io_error?(File.mkdir(invalid))\n refute File.exists?(invalid)\n end\n\n test \"mkdir_p!\" do\n fixture = tmp_path(\"tmp_test\")\n\n try do\n refute File.exists?(fixture)\n assert File.mkdir_p!(fixture) == :ok\n assert File.exists?(fixture)\n after\n File.rm_rf(fixture)\n end\n end\n\n test \"mkdir_p! with invalid path\" do\n fixture = fixture_path(\"file.txt\")\n invalid = Path.join(fixture, \"test\")\n assert File.exists?(fixture)\n\n message =\n ~r\"\\Acould not make directory \\(with -p\\) #{inspect(invalid)}: (not a directory|no such file or directory)\"\n\n assert_raise File.Error, message, fn ->\n File.mkdir_p!(invalid)\n end\n end\n\n @tag :unix\n test \"mkdir_p with non-accessible parent directory\" do\n fixture = tmp_path(\"tmp_test_parent\")\n\n try do\n refute File.exists?(fixture)\n assert File.mkdir_p!(fixture) == :ok\n %File.Stat{mode: orig_mode} = File.stat!(fixture)\n assert File.chmod!(fixture, 0o000) == :ok\n\n child = Path.join(fixture, \"child\")\n refute File.exists?(child)\n\n assert File.mkdir_p(child) == {:error, :eacces}\n refute File.exists?(child)\n\n assert File.chmod!(fixture, orig_mode) == :ok\n after\n File.rm_rf(fixture)\n end\n end\n end\n\n describe \"rm\" do\n test \"rm file\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.write(fixture, \"test\")\n assert File.exists?(fixture)\n assert File.rm(fixture) == :ok\n refute File.exists?(fixture)\n end\n\n test \"rm read only file\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.write(fixture, \"test\")\n assert File.exists?(fixture)\n File.chmod(fixture, 0o100444)\n assert File.rm(fixture) == :ok\n refute File.exists?(fixture)\n end\n\n test \"rm file with dir\" do\n assert File.rm(fixture_path()) == {:error, :eperm}\n end\n\n test \"rm nonexistent file\" do\n assert File.rm(~c\"missing.txt\") == {:error, :enoent}\n end\n\n test \"rm!\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.write(fixture, \"test\")\n assert File.exists?(fixture)\n assert File.rm!(fixture) == :ok\n refute File.exists?(fixture)\n end\n\n test \"rm! with invalid file\" do\n message = \"could not remove file \\\"missing.file\\\": no such file or directory\"\n\n assert_raise File.Error, message, fn ->\n File.rm!(\"missing.file\")\n end\n end\n\n test \"rmdir\" do\n fixture = tmp_path(\"tmp_test\")\n File.mkdir_p(fixture)\n assert File.dir?(fixture)\n assert File.rmdir(fixture) == :ok\n refute File.exists?(fixture)\n end\n\n test \"rmdir with file\" do\n assert io_error?(File.rmdir(fixture_path(\"file.txt\")))\n end\n\n test \"rmdir!\" do\n fixture = tmp_path(\"tmp_test\")\n File.mkdir_p(fixture)\n assert File.dir?(fixture)\n assert File.rmdir!(fixture) == :ok\n refute File.exists?(fixture)\n end\n\n test \"rmdir! with file\" do\n fixture = fixture_path(\"file.txt\")\n message = ~r\"\\Acould not remove directory #{inspect(fixture)}: (not a directory|I/O error)\"\n\n assert_raise File.Error, message, fn ->\n File.rmdir!(fixture)\n end\n end\n\n test \"rmdir! error messages\" do\n fixture = tmp_path(\"tmp_test\")\n File.mkdir_p(fixture)\n File.touch(fixture <> \"/file\")\n\n # directory is not empty\n dir_not_empty_message =\n \"could not remove directory #{inspect(fixture)}: directory is not empty\"\n\n assert_raise File.Error, dir_not_empty_message, fn ->\n File.rmdir!(fixture)\n end\n\n # directory does not exist\n non_existent_dir = fixture <> \"/non_existent_dir\"\n\n non_existent_dir_message =\n ~r\"\\Acould not remove directory #{inspect(non_existent_dir)}: (not a directory|no such file or directory)\"\n\n assert_raise File.Error, non_existent_dir_message, fn ->\n File.rmdir!(non_existent_dir)\n end\n\n File.rm_rf(fixture)\n end\n\n test \"rm_rf\" do\n fixture = tmp_path(\"tmp\")\n File.mkdir(fixture)\n File.cp_r!(fixture_path(\"cp_r\"), fixture)\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n {:ok, files} = File.rm_rf(fixture)\n assert length(files) == 7\n assert fixture in files\n assert tmp_path(\"tmp/a/1.txt\") in files\n\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n refute File.exists?(fixture)\n end\n\n test \"rm_rf raises on path with null byte\" do\n assert_raise ArgumentError, ~r/null byte/, fn -> File.rm_rf(\"foo\\0bar\") end\n end\n\n test \"rm_rf with symlink\" do\n from = tmp_path(\"tmp/from\")\n to = tmp_path(\"tmp/to\")\n\n File.mkdir_p!(to)\n File.write!(Path.join(to, \"hello\"), \"world\")\n :file.make_symlink(to, from)\n\n if File.exists?(from) or not windows?() do\n assert File.exists?(from)\n\n {:ok, files} = File.rm_rf(from)\n assert length(files) == 1\n\n assert File.exists?(Path.join(to, \"hello\"))\n refute File.exists?(from)\n end\n after\n File.rm(tmp_path(\"tmp/from\"))\n end\n\n test \"rm_rf with charlist\" do\n fixture = tmp_path(\"tmp\") |> to_charlist()\n File.mkdir(fixture)\n File.cp_r!(fixture_path(\"cp_r\"), fixture)\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n {:ok, files} = File.rm_rf(fixture)\n assert length(files) == 7\n assert tmp_path(\"tmp\") in files\n assert Enum.all?(files, &is_binary/1)\n\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n refute File.exists?(fixture)\n end\n\n test \"rm_rf with file\" do\n fixture = tmp_path(\"tmp\")\n File.write(fixture, \"hello\")\n assert File.rm_rf(fixture) == {:ok, [fixture]}\n end\n\n test \"rm_rf with write-only subdir\" do\n dir = tmp_path(\"tmp\")\n subdir = Path.join(dir, \"write-only\")\n File.mkdir_p!(subdir)\n File.chmod!(subdir, 0o222)\n assert File.rm_rf(dir) == {:ok, [dir, subdir]}\n end\n\n test \"rm_rf with unknown\" do\n fixture = tmp_path(\"tmp.unknown\")\n assert File.rm_rf(fixture) == {:ok, []}\n end\n\n test \"rm_rf with invalid\" do\n fixture = fixture_path(\"file.txt/path\")\n assert File.rm_rf(fixture) == {:ok, []}\n end\n\n test \"rm_rf!\" do\n fixture = tmp_path(\"tmp\")\n File.mkdir(fixture)\n File.cp_r!(fixture_path(\"cp_r\"), fixture)\n\n assert File.exists?(tmp_path(\"tmp/a/1.txt\"))\n assert File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n assert File.exists?(tmp_path(\"tmp/b/3.txt\"))\n\n files = File.rm_rf!(fixture)\n assert length(files) == 7\n assert fixture in files\n assert tmp_path(\"tmp/a/1.txt\") in files\n\n refute File.exists?(tmp_path(\"tmp/a/1.txt\"))\n refute File.exists?(tmp_path(\"tmp/a/a/2.txt\"))\n refute File.exists?(tmp_path(\"tmp/b/3.txt\"))\n refute File.exists?(fixture)\n end\n\n test \"rm_rf! with invalid path\" do\n fixture = fixture_path(\"file.txt/path\")\n assert File.rm_rf!(fixture) == []\n end\n end\n\n describe \"stat\" do\n test \"stat\" do\n {:ok, info} = File.stat(__ENV__.file)\n assert info.mtime\n end\n\n test \"stat!\" do\n assert File.stat!(__ENV__.file).mtime\n end\n\n test \"stat with invalid file\" do\n assert {:error, _} = File.stat(\"./invalid_file\")\n end\n\n test \"stat! with invalid_file\" do\n assert_raise File.Error, fn ->\n File.stat!(\"./invalid_file\")\n end\n end\n\n test \"lstat\" do\n {:ok, info} = File.lstat(__ENV__.file)\n assert info.mtime\n end\n\n test \"lstat!\" do\n assert File.lstat!(__ENV__.file).mtime\n end\n\n test \"lstat with invalid file\" do\n invalid_file = tmp_path(\"invalid_file\")\n assert {:error, _} = File.lstat(invalid_file)\n end\n\n test \"lstat! with invalid file\" do\n invalid_file = tmp_path(\"invalid_file\")\n\n assert_raise File.Error, fn ->\n File.lstat!(invalid_file)\n end\n end\n\n test \"lstat with dangling symlink\" do\n invalid_file = tmp_path(\"invalid_file\")\n dest = tmp_path(\"dangling_symlink\")\n File.ln_s(invalid_file, dest)\n\n try do\n assert {:ok, info} = File.lstat(dest)\n assert info.type == :symlink\n after\n File.rm(dest)\n end\n end\n\n test \"lstat! with dangling symlink\" do\n invalid_file = tmp_path(\"invalid_file\")\n dest = tmp_path(\"dangling_symlink\")\n File.ln_s(invalid_file, dest)\n\n try do\n assert File.lstat!(dest).type == :symlink\n after\n File.rm(dest)\n end\n end\n end\n\n describe \"IO stream\" do\n test \"IO stream UTF-8\" do\n src = File.open!(fixture_path(\"file.txt\"), [:utf8])\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n stream = IO.stream(src, :line)\n\n File.open(dest, [:write], fn target ->\n Enum.into(stream, IO.stream(target, :line), &String.replace(&1, \"O\", \"A\"))\n end)\n\n assert File.read(dest) == {:ok, \"FAA\\n\"}\n after\n File.rm(dest)\n end\n end\n\n test \"IO stream\" do\n src = File.open!(fixture_path(\"file.txt\"))\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n stream = IO.binstream(src, :line)\n\n File.open(dest, [:write], fn target ->\n Enum.into(stream, IO.binstream(target, :line), &String.replace(&1, \"O\", \"A\"))\n end)\n\n assert File.read(dest) == {:ok, \"FAA\\n\"}\n after\n File.rm(dest)\n end\n end\n end\n\n describe \"links\" do\n test \"read_link with regular file\" do\n dest = tmp_path(\"symlink\")\n File.touch(dest)\n\n try do\n assert File.read_link(dest) == {:error, :einval}\n after\n File.rm(dest)\n end\n end\n\n test \"read_link with nonexistent file\" do\n dest = tmp_path(\"does_not_exist\")\n assert File.read_link(dest) == {:error, :enoent}\n end\n\n test \"read_link! with nonexistent file\" do\n dest = tmp_path(\"does_not_exist\")\n assert_raise File.Error, fn -> File.read_link!(dest) end\n end\n\n @tag :unix\n test \"read_link with symlink\" do\n target = tmp_path(\"does_not_need_to_exist\")\n dest = tmp_path(\"symlink\")\n File.ln_s(target, dest)\n\n try do\n assert File.read_link(dest) == {:ok, target}\n after\n File.rm(dest)\n end\n end\n\n @tag :unix\n test \"read_link! with symlink\" do\n target = tmp_path(\"does_not_need_to_exist\")\n dest = tmp_path(\"symlink\")\n File.ln_s(target, dest)\n\n try do\n assert File.read_link!(dest) == target\n after\n File.rm(dest)\n end\n end\n\n test \"ln\" do\n existing = fixture_path(\"file.txt\")\n new = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(new)\n assert File.ln(existing, new) == :ok\n assert File.read(new) == {:ok, \"FOO\\n\"}\n after\n File.rm(new)\n end\n end\n\n test \"ln with existing destination\" do\n existing = fixture_path(\"file.txt\")\n assert File.ln(existing, existing) == {:error, :eexist}\n end\n\n test \"ln! with existing destination\" do\n assert_raise File.LinkError, fn ->\n existing = fixture_path(\"file.txt\")\n File.ln!(existing, existing)\n end\n end\n\n test \"ln_s\" do\n existing = fixture_path(\"file.txt\")\n new = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(new)\n assert File.ln_s(existing, new) == :ok\n assert File.read(new) == {:ok, \"FOO\\n\"}\n after\n File.rm(new)\n end\n end\n\n test \"ln_s with existing destination\" do\n existing = fixture_path(\"file.txt\")\n assert File.ln_s(existing, existing) == {:error, :eexist}\n end\n\n test \"ln_s! with existing destination\" do\n existing = fixture_path(\"file.txt\")\n\n assert_raise File.LinkError, fn ->\n File.ln_s!(existing, existing)\n end\n end\n end\n\n describe \"copy\" do\n test \"copy\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n assert File.copy(src, dest) == {:ok, 4}\n assert File.read(dest) == {:ok, \"FOO\\n\"}\n after\n File.rm(dest)\n end\n end\n\n test \"copy with an io_device\" do\n {:ok, src} = File.open(fixture_path(\"file.txt\"))\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n assert File.copy(src, dest) == {:ok, 4}\n assert File.read(dest) == {:ok, \"FOO\\n\"}\n after\n File.close(src)\n File.rm(dest)\n end\n end\n\n test \"copy with raw io_device\" do\n {:ok, src} = File.open(fixture_path(\"file.txt\"), [:raw])\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n assert File.copy(src, dest) == {:ok, 4}\n assert File.read(dest) == {:ok, \"FOO\\n\"}\n after\n File.close(src)\n File.rm(dest)\n end\n end\n\n test \"copy with ram io_device\" do\n {:ok, src} = File.open(\"FOO\\n\", [:ram])\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n assert File.copy(src, dest) == {:ok, 4}\n assert File.read(dest) == {:ok, \"FOO\\n\"}\n after\n File.close(src)\n File.rm(dest)\n end\n end\n\n test \"copy with bytes count\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n assert File.copy(src, dest, 2) == {:ok, 2}\n assert {:ok, \"FO\"} == File.read(dest)\n after\n File.rm(dest)\n end\n end\n\n test \"copy with invalid file\" do\n src = fixture_path(\"invalid.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n assert File.copy(src, dest, 2) == {:error, :enoent}\n end\n\n test \"copy!\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n assert File.copy!(src, dest) == 4\n assert {:ok, \"FOO\\n\"} == File.read(dest)\n after\n File.rm(dest)\n end\n end\n\n test \"copy! with bytes count\" do\n src = fixture_path(\"file.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n try do\n refute File.exists?(dest)\n assert File.copy!(src, dest, 2) == 2\n assert {:ok, \"FO\"} == File.read(dest)\n after\n File.rm(dest)\n end\n end\n\n test \"copy! with invalid file\" do\n src = fixture_path(\"invalid.txt\")\n dest = tmp_path(\"tmp_test.txt\")\n\n message =\n \"could not copy from #{inspect(src)} to #{inspect(dest)}: no such file or directory\"\n\n assert_raise File.CopyError, message, fn ->\n File.copy!(src, dest, 2)\n end\n end\n end\n\n describe \"cwd and cd\" do\n test \"cwd and cd\" do\n {:ok, current} = File.cwd()\n\n try do\n assert File.cd(fixture_path()) == :ok\n assert File.exists?(\"file.txt\")\n after\n File.cd!(current)\n end\n end\n\n if :file.native_name_encoding() == :utf8 do\n test \"cwd and cd with UTF-8\" do\n File.mkdir_p(tmp_path(\"héllò\"))\n\n File.cd!(tmp_path(\"héllò\"), fn ->\n assert Path.basename(File.cwd!()) == \"héllò\"\n end)\n after\n File.rm_rf(tmp_path(\"héllò\"))\n end\n end\n\n test \"invalid cd\" do\n assert io_error?(File.cd(fixture_path(\"file.txt\")))\n end\n\n test \"invalid_cd!\" do\n message =\n ~r\"\\Acould not set current working directory to #{inspect(fixture_path(\"file.txt\"))}: (not a directory|no such file or directory|I/O error)\"\n\n assert_raise File.Error, message, fn ->\n File.cd!(fixture_path(\"file.txt\"))\n end\n end\n\n test \"cd with function\" do\n assert File.cd!(fixture_path(), fn ->\n assert File.exists?(\"file.txt\")\n :cd_result\n end) == :cd_result\n end\n end\n\n describe \"touch\" do\n test \"touch with no file\" do\n fixture = tmp_path(\"tmp_test.txt\")\n time = {{2010, 4, 17}, {14, 0, 0}}\n\n try do\n refute File.exists?(fixture)\n assert File.touch(fixture, time) == :ok\n assert {:ok, \"\"} == File.read(fixture)\n assert File.stat!(fixture).mtime == time\n after\n File.rm(fixture)\n end\n end\n\n test \"touch with Erlang timestamp\" do\n fixture = tmp_path(\"tmp_erlang_touch.txt\")\n\n try do\n assert File.touch!(fixture, :erlang.universaltime()) == :ok\n stat = File.stat!(fixture)\n\n assert File.touch!(fixture, last_year()) == :ok\n assert stat.mtime > File.stat!(fixture).mtime\n after\n File.rm(fixture)\n end\n end\n\n test \"touch with posix timestamp\" do\n fixture = tmp_path(\"tmp_posix_touch.txt\")\n\n try do\n assert File.touch!(fixture, System.os_time(:second)) == :ok\n stat = File.stat!(fixture)\n\n assert File.touch!(fixture, last_year()) == :ok\n assert stat.mtime > File.stat!(fixture).mtime\n after\n File.rm(fixture)\n end\n end\n\n test \"touch with dir\" do\n assert File.touch(fixture_path()) == :ok\n end\n\n test \"touch with failure\" do\n fixture = fixture_path(\"file.txt/bar\")\n assert io_error?(File.touch(fixture))\n end\n\n test \"touch! raises\" do\n fixture = fixture_path(\"file.txt/bar\")\n\n message =\n ~r\"\\Acould not touch #{inspect(fixture)}: (not a directory|no such file or directory)\"\n\n assert_raise File.Error, message, fn ->\n File.touch!(fixture)\n end\n end\n end\n\n describe \"ch*\" do\n test \"chmod with success\" do\n fixture = tmp_path(\"tmp_test.txt\")\n\n File.touch(fixture)\n\n try do\n assert File.chmod(fixture, 0o100666) == :ok\n stat = File.stat!(fixture)\n assert stat.mode == 0o100666\n\n if not windows?() do\n assert File.chmod(fixture, 0o100777) == :ok\n stat = File.stat!(fixture)\n assert stat.mode == 0o100777\n end\n after\n File.rm(fixture)\n end\n end\n\n test \"chmod! with success\" do\n fixture = tmp_path(\"tmp_test.txt\")\n\n File.touch(fixture)\n\n try do\n assert File.chmod!(fixture, 0o100666) == :ok\n stat = File.stat!(fixture)\n assert stat.mode == 0o100666\n\n if not windows?() do\n assert File.chmod!(fixture, 0o100777) == :ok\n stat = File.stat!(fixture)\n assert stat.mode == 0o100777\n end\n after\n File.rm(fixture)\n end\n end\n\n test \"chmod with failure\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.rm(fixture)\n\n assert File.chmod(fixture, 0o100777) == {:error, :enoent}\n end\n\n test \"chmod! with failure\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.rm(fixture)\n\n message = ~r\"could not change mode for #{inspect(fixture)}: no such file or directory\"\n\n assert_raise File.Error, message, fn ->\n File.chmod!(fixture, 0o100777)\n end\n end\n\n test \"chgrp with failure\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.rm(fixture)\n\n assert File.chgrp(fixture, 1) == {:error, :enoent}\n end\n\n test \"chgrp! with failure\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.rm(fixture)\n\n message = ~r\"could not change group for #{inspect(fixture)}: no such file or directory\"\n\n assert_raise File.Error, message, fn ->\n File.chgrp!(fixture, 1)\n end\n end\n\n test \"chown with failure\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.rm(fixture)\n\n assert File.chown(fixture, 1) == {:error, :enoent}\n end\n\n test \"chown! with failure\" do\n fixture = tmp_path(\"tmp_test.txt\")\n File.rm(fixture)\n\n message = ~r\"could not change owner for #{inspect(fixture)}: no such file or directory\"\n\n assert_raise File.Error, message, fn ->\n File.chown!(fixture, 1)\n end\n end\n end\n\n defp last_year do\n System.os_time(:second) - 365 * 24 * 60 * 60\n end\n\n defp io_error?(result) do\n elem(result, 1) in [:enotdir, :eio, :enoent, :eisdir]\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/at_exit.exs", "content": "defmodule AtExit do\n def at_exit(str) do\n System.at_exit(fn _ -> IO.write(str) end)\n end\nend\n\nSystem.at_exit(fn status -> IO.puts(\"cruel world with status #{status}\") end)\nAtExit.at_exit(\"goodbye \")\nexit({:shutdown, 1})\n" }, { "path": "lib/elixir/test/elixir/fixtures/code_sample.exs", "content": "# Some Comments\nvar = 1 + 2\nvar\n" }, { "path": "lib/elixir/test/elixir/fixtures/compile_sample.ex", "content": "defmodule(CompileSample, do: nil)\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/bad_app.exs", "content": "[sample: :oops]\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/bad_import.exs", "content": "import Config\nimport_config \"bad_root.exs\"\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/env.exs", "content": "import Config\nconfig :my_app, env: config_env(), target: config_target()\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/good_config.exs", "content": "import Config\nconfig :my_app, :key, :value\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/good_import.exs", "content": "import Config\nimport_config \"good_config.exs\"\n:done\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/good_kw.exs", "content": "[my_app: [key: :value]]\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/imports_recursive.exs", "content": "import Config\nimport_config \"recursive.exs\"\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/kernel.exs", "content": "import Config\nconfig :kernel, :elixir_reboot, true\nconfig :elixir_reboot, :key, :value\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/nested.exs", "content": "import Config\nconfig :app, Repo, key: [nested: true]\n" }, { "path": "lib/elixir/test/elixir/fixtures/configs/recursive.exs", "content": "import Config\nimport_config \"imports_recursive.exs\"\n" }, { "path": "lib/elixir/test/elixir/fixtures/consolidation/no_impl.ex", "content": "defprotocol Protocol.ConsolidationTest.NoImpl do\n def ok(term)\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/consolidation/sample.ex", "content": "defprotocol Protocol.ConsolidationTest.Sample do\n @type t :: any\n @doc \"Ok\"\n @deprecated \"Reason\"\n @spec ok(t) :: boolean\n def ok(term)\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/consolidation/with_any.ex", "content": "defprotocol Protocol.ConsolidationTest.WithAny do\n @fallback_to_any true\n @doc \"Ok\"\n def ok(term, opts)\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/cp_mode", "content": "" }, { "path": "lib/elixir/test/elixir/fixtures/cp_r/a/1.txt", "content": "" }, { "path": "lib/elixir/test/elixir/fixtures/cp_r/a/a/2.txt", "content": "" }, { "path": "lib/elixir/test/elixir/fixtures/cp_r/b/3.txt", "content": "" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/assertions.ex", "content": "defmodule Dialyzer.Assertions do\n import ExUnit.Assertions\n\n def assert_with_truthy_match do\n assert :ok = known_type_truthy()\n end\n\n def assert_with_truthy_value do\n assert known_type_truthy()\n end\n\n def assert_with_unknown_type do\n assert unknown_type_truthy()\n end\n\n def refute_with_falsy_value do\n refute known_type_falsy()\n end\n\n def refute_with_unknown_type do\n refute unknown_type_falsy()\n end\n\n def refute_with_operator(log) do\n refute log == \"failure\"\n end\n\n defp known_type_truthy, do: :ok\n defp known_type_falsy, do: nil\n\n @spec unknown_type_truthy :: any\n defp unknown_type_truthy, do: Enum.random([1, true, :ok])\n @spec unknown_type_falsy :: any\n defp unknown_type_falsy, do: Enum.random([false, nil])\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/boolean_check.ex", "content": "defmodule Dialyzer.BooleanCheck do\n def and_check(arg) when is_boolean(arg) do\n arg and arg\n end\n\n def or_check(arg) when is_boolean(arg) do\n arg or arg\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/callback.ex", "content": "defmodule Dialyzer.Callback do\n @callback required(atom) :: atom\n @callback required(list) :: list\nend\n\ndefmodule Dialyzer.Callback.ImplAtom do\n @behaviour Dialyzer.Callback\n def required(:ok), do: :ok\nend\n\ndefmodule Dialyzer.Callback.ImplList do\n @behaviour Dialyzer.Callback\n def required([a, b]), do: [b, a]\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/cond.ex", "content": "defmodule Dialyzer.Cond do\n def one_boolean do\n cond do\n true -> :ok\n end\n end\n\n def two_boolean do\n cond do\n List.flatten([]) == [] -> :ok\n true -> :ok\n end\n end\n\n def one_otherwise do\n cond do\n :otherwise -> :ok\n end\n end\n\n def two_otherwise do\n cond do\n List.flatten([]) == [] -> :ok\n :otherwise -> :ok\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/defmacrop.ex", "content": "defmodule Dialyzer.Defmacrop do\n defmacrop good_macro(id) do\n quote do\n {:good, {:good_macro, unquote(id)}}\n end\n end\n\n def run() do\n good_macro(\"Not So Bad\")\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/for_bitstring.ex", "content": "defmodule Dialyzer.ForBitstring do\n def foo() do\n for a <- 1..3, into: \"\", do: <>\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/for_boolean_check.ex", "content": "defmodule Dialyzer.ForBooleanCheck do\n def foo(enum, potential) when is_binary(potential) do\n for element <- enum, string = Atom.to_string(element), string == potential do\n element\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/in_range.ex", "content": "defmodule Dialyzer.InRange do\n def string_to_number_in_range(x) do\n String.to_integer(x) in 1..10\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/is_struct.ex", "content": "defmodule Dialyzer.IsStruct do\n def map_literal_atom_literal() do\n is_struct(%Macro.Env{}, Macro.Env)\n end\n\n def arg_atom_literal(arg) do\n is_struct(arg, Macro.Env)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/macrocallback.ex", "content": "defmodule Dialyzer.Macrocallback do\n @macrocallback required(atom) :: Macro.t()\n @macrocallback optional(atom) :: Macro.t()\n @optional_callbacks [optional: 1]\nend\n\ndefmodule Dialyzer.Macrocallback.Impl do\n @behaviour Dialyzer.Macrocallback\n defmacro required(var), do: Macro.expand(var, __CALLER__)\n defmacro optional(var), do: Macro.expand(var, __CALLER__)\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/opaqueness.ex", "content": "defmodule Dialyzer.Opaqueness do\n @spec bar(MapSet.t()) :: term()\n def bar(set) do\n set\n end\n\n def inlined do\n # inlining of literals should not violate opaqueness check\n bar(MapSet.new([1, 2, 3]))\n end\n\n @my_set MapSet.new([1, 2, 3])\n def module_attr do\n bar(@my_set)\n end\n\n # Task.Supervisor returns a Task.t() containing an opaque Task.ref()\n @spec run_task() :: Task.t()\n def run_task do\n Task.Supervisor.async(SupervisorName, fn -> :ok end)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/raise.ex", "content": "defmodule Dialyzer.Raise do\n defexception [:message]\n\n def exception_var() do\n ex = %Dialyzer.Raise{}\n raise ex\n end\n\n def exception_var(ex = %Dialyzer.Raise{}) do\n raise ex\n end\n\n def string_var() do\n string = \"hello\"\n raise string\n end\n\n def string_var(string) when is_binary(string) do\n raise string\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/regressions.ex", "content": "defmodule Dialyzer.Regressions do\n def io_inspect_opts do\n IO.inspect(123, label: \"foo\", limit: :infinity)\n end\n\n def format_opts do\n Code.format_string!(\"\",\n line_length: 120,\n force_do_end_blocks: true,\n locals_without_parens: true,\n migrate: true\n )\n end\n\n def eex_eval_opts do\n EEx.eval_string(\"foo <%= bar %>\", [bar: \"baz\"], trim: true)\n end\n\n @spec inlined_map_set :: MapSet.t(integer())\n def inlined_map_set, do: MapSet.new([1, 2])\n\n @spec inlined_uri :: URI.t()\n def inlined_uri, do: URI.new!(\"example.com\")\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/remote_call.ex", "content": "defmodule Dialyzer.RemoteCall do\n _ = Application.load(:dialyzer)\n\n case Application.spec(:dialyzer, :vsn) do\n ~c(2.) ++ _ ->\n @dialyzer {:no_fail_call, [map_var: 0]}\n\n three when three < ~c(3.0.2) ->\n # regression introduced in 3.0 for map warnings fixed in 3.0.2\n @dialyzer {:no_match, [map_var: 0, mod_var: 0]}\n\n _ ->\n :ok\n end\n\n def map_var() do\n map = %{key: 1}\n map.key\n end\n\n def map_var(map) when is_map(map) do\n map.key\n end\n\n def mod_var() do\n module = String.to_atom(\"Elixir.Hello\")\n module.fun()\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/rewrite.ex", "content": "defmodule Dialyzer.Rewrite do\n def interpolation do\n \"foo #{:a}\"\n end\n\n def reverse do\n Enum.reverse(1..3)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/try.ex", "content": "defmodule Dialyzer.Try do\n def rescue_error do\n try do\n :erlang.error(:badarg)\n rescue\n e in ErlangError -> {:ok, e}\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/with.ex", "content": "defmodule Dialyzer.With do\n def with_else do\n with :ok <- ok_or_error(),\n :ok <- ok_or_other_error(),\n :ok <- ok_or_tuple_error(),\n :ok <- ok_or_tuple_list_error() do\n :ok\n else\n :error ->\n :error\n\n :other_error ->\n :other_error\n\n {:error, msg} when is_list(msg) when is_tuple(msg) ->\n :error\n\n {:error, _msg} ->\n :error\n end\n end\n\n @spec ok_or_error() :: :ok | :error\n defp ok_or_error do\n Enum.random([:ok, :error])\n end\n\n @spec ok_or_other_error() :: :ok | :other_error\n defp ok_or_other_error do\n Enum.random([:ok, :other_error])\n end\n\n @spec ok_or_tuple_error() :: :ok | {:error, :err}\n defp ok_or_tuple_error do\n Enum.random([:ok, {:error, :err}])\n end\n\n @spec ok_or_tuple_list_error() :: :ok | {:error, [:err]}\n defp ok_or_tuple_list_error do\n Enum.random([:ok, {:error, [:err]}])\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/with_no_return.ex", "content": "defmodule Dialyzer.WithNoReturn do\n def with_no_return(list) do\n no_return = fn -> throw(:no_return) end\n\n with [] <- list do\n :ok\n else\n # note: throwing here directly wouldn't be caught in the first place,\n # calling a no_return function is what could cause an issue.\n _ -> no_return.()\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/dialyzer/with_throwing_else.ex", "content": "defmodule Dialyzer.WithThrowingElse do\n def with_throwing_else(map) do\n with {:ok, foo} <- Map.fetch(map, :foo),\n false <- Enum.empty?(foo) do\n foo\n else\n # several clauses but one is a no_return\n :error -> throw(:empty_map)\n true -> nil\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/fixtures/file.txt", "content": "FOO\n" }, { "path": "lib/elixir/test/elixir/fixtures/multiline_file.txt", "content": "this is the first line\nthis is the second line\n" }, { "path": "lib/elixir/test/elixir/fixtures/utf8.txt", "content": "Русский\n日\n" }, { "path": "lib/elixir/test/elixir/fixtures/utf8_bom.txt", "content": "Русский\n日\n" }, { "path": "lib/elixir/test/elixir/float_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule FloatTest do\n use ExUnit.Case, async: true\n\n doctest Float\n\n test \"parse/1\" do\n assert Float.parse(\"12\") === {12.0, \"\"}\n assert Float.parse(\"-12\") === {-12.0, \"\"}\n assert Float.parse(\"-0.1\") === {-0.1, \"\"}\n assert Float.parse(\"123456789\") === {123_456_789.0, \"\"}\n assert Float.parse(\"12.5\") === {12.5, \"\"}\n assert Float.parse(\"12.524235\") === {12.524235, \"\"}\n assert Float.parse(\"-12.5\") === {-12.5, \"\"}\n assert Float.parse(\"-12.524235\") === {-12.524235, \"\"}\n assert Float.parse(\"0.3534091\") === {0.3534091, \"\"}\n assert Float.parse(\"0.3534091elixir\") === {0.3534091, \"elixir\"}\n assert Float.parse(\"7.5e3\") === {7.5e3, \"\"}\n assert Float.parse(\"7.5e-3\") === {7.5e-3, \"\"}\n assert Float.parse(\"12x\") === {12.0, \"x\"}\n assert Float.parse(\"12.5x\") === {12.5, \"x\"}\n assert Float.parse(\"-12.32453e10\") === {-1.232453e11, \"\"}\n assert Float.parse(\"-12.32453e-10\") === {-1.232453e-9, \"\"}\n assert Float.parse(\"0.32453e-10\") === {3.2453e-11, \"\"}\n assert Float.parse(\"1.32453e-10\") === {1.32453e-10, \"\"}\n assert Float.parse(\"1.7976931348623159e-99999foo\") === {0.0, \"foo\"}\n assert Float.parse(\"1.32.45\") === {1.32, \".45\"}\n assert Float.parse(\"1.o\") === {1.0, \".o\"}\n assert Float.parse(\"+12.3E+4\") === {1.23e5, \"\"}\n assert Float.parse(\"+12.3E-4x\") === {0.00123, \"x\"}\n assert Float.parse(\"-1.23e-0xFF\") === {-1.23, \"xFF\"}\n assert Float.parse(\"-1.e2\") === {-1.0, \".e2\"}\n assert Float.parse(\".12\") === :error\n assert Float.parse(\"--1.2\") === :error\n assert Float.parse(\"++1.2\") === :error\n assert Float.parse(\"pi\") === :error\n assert Float.parse(\"1.7976931348623157e308\") === {1.7976931348623157e308, \"\"}\n assert Float.parse(\"1.7976931348623157e308foo\") === {1.7976931348623157e308, \"foo\"}\n assert Float.parse(\"1.7976931348623157e+308foo\") === {1.7976931348623157e308, \"foo\"}\n assert Float.parse(\"1.7976931348623157e-308foo\") === {1.7976931348623155e-308, \"foo\"}\n assert Float.parse(\"1.7976931348623159e308\") === :error\n assert Float.parse(\"1.7976931348623159e+308\") === :error\n assert Float.parse(\"9e8363\") === :error\n\n # Non-scientific notation overflow\n assert Float.parse(String.duplicate(\"9\", 310) <> \".0\") === :error\n assert Float.parse(\"-\" <> String.duplicate(\"9\", 310) <> \".0\") === :error\n assert Float.parse(String.duplicate(\"9\", 310) <> \".0foo\") === :error\n end\n\n test \"floor/1\" do\n assert Float.floor(12.524235) === 12.0\n assert Float.floor(-12.5) === -13.0\n assert Float.floor(-12.524235) === -13.0\n assert Float.floor(7.5e3) === 7500.0\n assert Float.floor(7.5432e3) === 7543.0\n assert Float.floor(7.5e-3) === 0.0\n assert Float.floor(-12.32453e4) === -123_246.0\n assert Float.floor(-12.32453e-10) === -1.0\n assert Float.floor(0.32453e-10) === 0.0\n assert Float.floor(-0.32453e-10) === -1.0\n assert Float.floor(1.32453e-10) === 0.0\n end\n\n describe \"floor/2\" do\n test \"with 0.0\" do\n for precision <- 0..15 do\n assert Float.floor(0.0, precision) === 0.0\n assert Float.floor(-0.0, precision) === -0.0\n end\n end\n\n test \"floor/2 with precision\" do\n assert Float.floor(12.524235, 0) === 12.0\n assert Float.floor(-12.524235, 0) === -13.0\n\n assert Float.floor(12.52, 2) === 12.51\n assert Float.floor(-12.52, 2) === -12.52\n\n assert Float.floor(12.524235, 2) === 12.52\n assert Float.floor(-12.524235, 3) === -12.525\n\n assert Float.floor(12.32453e-20, 2) === 0.0\n assert Float.floor(-12.32453e-20, 2) === -0.01\n\n assert_raise ArgumentError, \"precision 16 is out of valid range of 0..15\", fn ->\n Float.floor(1.1, 16)\n end\n end\n\n test \"with subnormal floats\" do\n assert Float.floor(-5.0e-324, 0) === -1.0\n assert Float.floor(-5.0e-324, 1) === -0.1\n assert Float.floor(-5.0e-324, 2) === -0.01\n assert Float.floor(-5.0e-324, 15) === -0.000000000000001\n\n for precision <- 0..15 do\n assert Float.floor(5.0e-324, precision) === 0.0\n end\n end\n end\n\n test \"ceil/1\" do\n assert Float.ceil(12.524235) === 13.0\n assert Float.ceil(-12.5) === -12.0\n assert Float.ceil(-12.524235) === -12.0\n assert Float.ceil(7.5e3) === 7500.0\n assert Float.ceil(7.5432e3) === 7544.0\n assert Float.ceil(7.5e-3) === 1.0\n assert Float.ceil(-12.32453e4) === -123_245.0\n assert Float.ceil(-12.32453e-10) === -0.0\n assert Float.ceil(0.32453e-10) === 1.0\n assert Float.ceil(-0.32453e-10) === -0.0\n assert Float.ceil(1.32453e-10) === 1.0\n assert Float.ceil(0.0) === 0.0\n end\n\n describe \"ceil/2\" do\n test \"with 0.0\" do\n for precision <- 0..15 do\n assert Float.ceil(0.0, precision) === 0.0\n assert Float.ceil(-0.0, precision) === -0.0\n end\n end\n\n test \"with regular floats\" do\n assert Float.ceil(12.524235, 0) === 13.0\n assert Float.ceil(-12.524235, 0) === -12.0\n\n assert Float.ceil(12.52, 2) === 12.52\n assert Float.ceil(-12.52, 2) === -12.51\n\n assert Float.ceil(12.524235, 2) === 12.53\n assert Float.ceil(-12.524235, 3) === -12.524\n\n assert Float.ceil(12.32453e-20, 2) === 0.01\n assert Float.ceil(-12.32453e-20, 2) === -0.0\n\n assert Float.ceil(0.0, 2) === 0.0\n\n assert_raise ArgumentError, \"precision 16 is out of valid range of 0..15\", fn ->\n Float.ceil(1.1, 16)\n end\n end\n\n test \"with small floats rounded up to -0.0\" do\n assert Float.ceil(-0.1, 0) === -0.0\n assert Float.ceil(-0.01, 1) === -0.0\n end\n\n test \"with subnormal floats\" do\n assert Float.ceil(5.0e-324, 0) === 1.0\n assert Float.ceil(5.0e-324, 1) === 0.1\n assert Float.ceil(5.0e-324, 2) === 0.01\n assert Float.ceil(5.0e-324, 15) === 0.000000000000001\n\n for precision <- 0..15 do\n assert Float.ceil(-5.0e-324, precision) === -0.0\n end\n end\n end\n\n describe \"round/2\" do\n test \"with 0.0\" do\n for precision <- 0..15 do\n assert Float.round(0.0, precision) === 0.0\n assert Float.round(-0.0, precision) === -0.0\n end\n end\n\n test \"with regular floats\" do\n assert Float.round(5.5675, 3) === 5.567\n assert Float.round(-5.5674, 3) === -5.567\n assert Float.round(5.5, 3) === 5.5\n assert Float.round(5.5e-10, 10) === 5.0e-10\n assert Float.round(5.5e-10, 8) === 0.0\n assert Float.round(5.0, 0) === 5.0\n\n assert_raise ArgumentError, \"precision 16 is out of valid range of 0..15\", fn ->\n Float.round(1.1, 16)\n end\n end\n\n test \"with small floats rounded to +0.0 / -0.0\" do\n assert Float.round(0.01, 0) === 0.0\n assert Float.round(0.01, 1) === 0.0\n\n assert Float.round(-0.01, 0) === -0.0\n assert Float.round(-0.01, 1) === -0.0\n\n assert Float.round(-0.49999, 0) === -0.0\n assert Float.round(-0.049999, 1) === -0.0\n end\n\n test \"with subnormal floats\" do\n for precision <- 0..15 do\n assert Float.round(5.0e-324, precision) === 0.0\n assert Float.round(-5.0e-324, precision) === -0.0\n end\n end\n end\n\n describe \"ratio/1\" do\n test \"with 0.0\" do\n assert Float.ratio(0.0) == {0, 1}\n end\n\n test \"with regular floats\" do\n assert Float.ratio(3.14) == {7_070_651_414_971_679, 2_251_799_813_685_248}\n assert Float.ratio(-3.14) == {-7_070_651_414_971_679, 2_251_799_813_685_248}\n assert Float.ratio(1.5) == {3, 2}\n end\n\n test \"with subnormal floats\" do\n assert Float.ratio(5.0e-324) ==\n {1,\n 202_402_253_307_310_618_352_495_346_718_917_307_049_556_649_764_142_118_356_901_358_027_430_339_567_995_346_891_960_383_701_437_124_495_187_077_864_316_811_911_389_808_737_385_793_476_867_013_399_940_738_509_921_517_424_276_566_361_364_466_907_742_093_216_341_239_767_678_472_745_068_562_007_483_424_692_698_618_103_355_649_159_556_340_810_056_512_358_769_552_333_414_615_230_502_532_186_327_508_646_006_263_307_707_741_093_494_784}\n\n assert Float.ratio(1.0e-323) ==\n {1,\n 101_201_126_653_655_309_176_247_673_359_458_653_524_778_324_882_071_059_178_450_679_013_715_169_783_997_673_445_980_191_850_718_562_247_593_538_932_158_405_955_694_904_368_692_896_738_433_506_699_970_369_254_960_758_712_138_283_180_682_233_453_871_046_608_170_619_883_839_236_372_534_281_003_741_712_346_349_309_051_677_824_579_778_170_405_028_256_179_384_776_166_707_307_615_251_266_093_163_754_323_003_131_653_853_870_546_747_392}\n\n assert Float.ratio(2.225073858507201e-308) ==\n {4_503_599_627_370_495,\n 202_402_253_307_310_618_352_495_346_718_917_307_049_556_649_764_142_118_356_901_358_027_430_339_567_995_346_891_960_383_701_437_124_495_187_077_864_316_811_911_389_808_737_385_793_476_867_013_399_940_738_509_921_517_424_276_566_361_364_466_907_742_093_216_341_239_767_678_472_745_068_562_007_483_424_692_698_618_103_355_649_159_556_340_810_056_512_358_769_552_333_414_615_230_502_532_186_327_508_646_006_263_307_707_741_093_494_784}\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/function_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule DummyFunction do\n def function_with_arity_0 do\n true\n end\n\n def zero?(0), do: true\n def zero?(_), do: false\nend\n\ndefmodule FunctionTest do\n use ExUnit.Case, async: true\n\n doctest Function\n import Function\n\n @information_keys_for_named [:type, :module, :arity, :name, :env]\n @information_keys_for_anonymous @information_keys_for_named ++\n [:pid, :index, :new_index, :new_uniq, :uniq]\n\n describe \"capture/3\" do\n test \"captures module functions with arity 0\" do\n f = capture(DummyFunction, :function_with_arity_0, 0)\n\n assert is_function(f)\n end\n\n test \"captures module functions with any arity\" do\n f = capture(DummyFunction, :zero?, 1)\n\n assert is_function(f)\n assert f.(0)\n end\n end\n\n describe \"info/1\" do\n test \"returns info for named captured functions\" do\n f = &DummyFunction.zero?/1\n expected = [module: DummyFunction, name: :zero?, arity: 1, env: [], type: :external]\n\n result = info(f)\n\n assert expected == result\n end\n\n test \"returns info for anonymous functions\" do\n f = fn x -> x end\n\n result = info(f)\n\n for {key, _value} <- result do\n assert key in @information_keys_for_anonymous\n end\n end\n end\n\n describe \"info/2\" do\n test \"returns info for every possible information key for named functions\" do\n f = &DummyFunction.zero?/1\n\n for x <- @information_keys_for_named do\n assert {^x, _} = info(f, x)\n end\n end\n\n test \"returns info for every possible information key for anonymous functions\" do\n f = &DummyFunction.zero?/1\n\n for x <- @information_keys_for_anonymous do\n assert {^x, _} = info(f, x)\n end\n\n assert {:arity, 1} = info(f, :arity)\n end\n end\n\n describe \"identity/1\" do\n test \"returns whatever it gets passed\" do\n assert :hello = Function.identity(:hello)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/gen_server_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule GenServerTest do\n use ExUnit.Case, async: true\n\n defmodule Stack do\n use GenServer\n\n def init(args) do\n {:ok, args}\n end\n\n def handle_call(:pop, _from, [h | t]) do\n {:reply, h, t}\n end\n\n def handle_call(:noreply, _from, h) do\n {:noreply, h}\n end\n\n def handle_call(:stop_self, _from, state) do\n reason = catch_exit(GenServer.stop(self()))\n {:reply, reason, state}\n end\n\n def handle_cast({:push, element}, state) do\n {:noreply, [element | state]}\n end\n\n def terminate(_reason, _state) do\n # There is a race condition if the agent is\n # restarted too fast and it is registered.\n try do\n self() |> Process.info(:registered_name) |> elem(1) |> Process.unregister()\n rescue\n _ -> :ok\n end\n\n :ok\n end\n end\n\n test \"generates child_spec/1\" do\n assert Stack.child_spec([:hello]) == %{\n id: Stack,\n start: {Stack, :start_link, [[:hello]]}\n }\n\n defmodule CustomStack do\n use GenServer, id: :id, restart: :temporary, shutdown: :infinity, start: {:foo, :bar, []}\n\n def init(args) do\n {:ok, args}\n end\n end\n\n assert CustomStack.child_spec([:hello]) == %{\n id: :id,\n restart: :temporary,\n shutdown: :infinity,\n start: {:foo, :bar, []}\n }\n end\n\n test \"start_link/3\" do\n assert_raise ArgumentError, ~r\"expected :name option to be one of the following:\", fn ->\n GenServer.start_link(Stack, [:hello], name: \"my_gen_server_name\")\n end\n\n assert_raise ArgumentError, ~r\"expected :name option to be one of the following:\", fn ->\n GenServer.start_link(Stack, [:hello], name: {:invalid_tuple, \"my_gen_server_name\"})\n end\n\n assert_raise ArgumentError, ~r\"expected :name option to be one of the following:\", fn ->\n GenServer.start_link(Stack, [:hello], name: {:via, \"Via\", \"my_gen_server_name\"})\n end\n\n assert_raise ArgumentError, ~r/Got: \"my_gen_server_name\"/, fn ->\n GenServer.start_link(Stack, [:hello], name: \"my_gen_server_name\")\n end\n end\n\n test \"start_link/3 with via\" do\n GenServer.start_link(Stack, [:hello], name: {:via, :global, :via_stack})\n assert GenServer.call({:via, :global, :via_stack}, :pop) == :hello\n end\n\n test \"start_link/3 with global\" do\n GenServer.start_link(Stack, [:hello], name: {:global, :global_stack})\n assert GenServer.call({:global, :global_stack}, :pop) == :hello\n end\n\n test \"start_link/3 with local\" do\n GenServer.start_link(Stack, [:hello], name: :stack)\n assert GenServer.call(:stack, :pop) == :hello\n end\n\n test \"start_link/2, call/2 and cast/2\" do\n {:ok, pid} = GenServer.start_link(Stack, [:hello])\n\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n assert GenServer.call(pid, :pop) == :hello\n assert GenServer.cast(pid, {:push, :world}) == :ok\n assert GenServer.call(pid, :pop) == :world\n assert GenServer.stop(pid) == :ok\n\n assert GenServer.cast({:global, :foo}, {:push, :world}) == :ok\n assert GenServer.cast({:via, :foo, :bar}, {:push, :world}) == :ok\n assert GenServer.cast(:foo, {:push, :world}) == :ok\n end\n\n @tag capture_log: true\n test \"call/3 exit messages\" do\n name = :self\n Process.register(self(), name)\n :global.register_name(name, self())\n {:ok, pid} = GenServer.start_link(Stack, [:hello])\n {:ok, stopped_pid} = GenServer.start(Stack, [:hello])\n GenServer.stop(stopped_pid)\n\n assert catch_exit(GenServer.call(name, :pop, 5000)) ==\n {:calling_self, {GenServer, :call, [name, :pop, 5000]}}\n\n assert catch_exit(GenServer.call({:global, name}, :pop, 5000)) ==\n {:calling_self, {GenServer, :call, [{:global, name}, :pop, 5000]}}\n\n assert catch_exit(GenServer.call({:via, :global, name}, :pop, 5000)) ==\n {:calling_self, {GenServer, :call, [{:via, :global, name}, :pop, 5000]}}\n\n assert catch_exit(GenServer.call(self(), :pop, 5000)) ==\n {:calling_self, {GenServer, :call, [self(), :pop, 5000]}}\n\n assert catch_exit(GenServer.call(pid, :noreply, 1)) ==\n {:timeout, {GenServer, :call, [pid, :noreply, 1]}}\n\n assert catch_exit(GenServer.call(nil, :pop, 5000)) ==\n {:noproc, {GenServer, :call, [nil, :pop, 5000]}}\n\n assert catch_exit(GenServer.call(stopped_pid, :pop, 5000)) ==\n {:noproc, {GenServer, :call, [stopped_pid, :pop, 5000]}}\n\n assert catch_exit(GenServer.call({:stack, :bogus_node}, :pop, 5000)) ==\n {{:nodedown, :bogus_node}, {GenServer, :call, [{:stack, :bogus_node}, :pop, 5000]}}\n end\n\n test \"nil name\" do\n {:ok, pid} = GenServer.start_link(Stack, [:hello], name: nil)\n assert Process.info(pid, :registered_name) == {:registered_name, []}\n end\n\n test \"start/2\" do\n {:ok, pid} = GenServer.start(Stack, [:hello])\n {:links, links} = Process.info(self(), :links)\n refute pid in links\n GenServer.stop(pid)\n end\n\n test \"abcast/3\", %{test: name} do\n {:ok, _} = GenServer.start_link(Stack, [], name: name)\n\n assert GenServer.abcast(name, {:push, :hello}) == :abcast\n assert GenServer.call({name, node()}, :pop) == :hello\n\n assert GenServer.abcast([node(), :foo@bar], name, {:push, :world}) == :abcast\n assert GenServer.call(name, :pop) == :world\n end\n\n test \"multi_call/4\", %{test: name} do\n {:ok, _} = GenServer.start_link(Stack, [:hello, :world], name: name)\n node = node()\n\n assert {[{^node, :hello}], _} = GenServer.multi_call(name, :pop)\n assert {[{^node, :world}], [:foo@bar]} = GenServer.multi_call([node(), :foo@bar], name, :pop)\n end\n\n test \"whereis/1\" do\n name = :whereis_server\n\n {:ok, pid} = GenServer.start_link(Stack, [], name: name)\n assert GenServer.whereis(name) == pid\n assert GenServer.whereis({name, node()}) == pid\n assert GenServer.whereis({name, :another_node}) == {name, :another_node}\n assert GenServer.whereis(pid) == pid\n assert GenServer.whereis(:whereis_bad_server) == nil\n\n {:ok, pid} = GenServer.start_link(Stack, [], name: {:global, name})\n assert GenServer.whereis({:global, name}) == pid\n assert GenServer.whereis({:global, :whereis_bad_server}) == nil\n assert GenServer.whereis({:via, :global, name}) == pid\n assert GenServer.whereis({:via, :global, :whereis_bad_server}) == nil\n end\n\n test \"stop/3\", %{test: name} do\n {:ok, pid} = GenServer.start(Stack, [])\n assert GenServer.stop(pid, :normal) == :ok\n\n stopped_pid = pid\n\n assert catch_exit(GenServer.stop(stopped_pid)) ==\n {:noproc, {GenServer, :stop, [stopped_pid, :normal, :infinity]}}\n\n assert catch_exit(GenServer.stop(nil)) ==\n {:noproc, {GenServer, :stop, [nil, :normal, :infinity]}}\n\n {:ok, pid} = GenServer.start(Stack, [])\n\n assert GenServer.call(pid, :stop_self) ==\n {:calling_self, {GenServer, :stop, [pid, :normal, :infinity]}}\n\n {:ok, _} = GenServer.start(Stack, [], name: name)\n assert GenServer.stop(name, :normal) == :ok\n end\nend\n" }, { "path": "lib/elixir/test/elixir/inspect/algebra_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Inspect.OptsTest do\n use ExUnit.Case\n\n test \"new\" do\n opts = Inspect.Opts.new(limit: 13, pretty: true)\n assert opts.limit == 13\n assert opts.pretty\n end\n\n test \"default_inspect_fun\" do\n assert Inspect.Opts.default_inspect_fun() == (&Inspect.inspect/2)\n\n assert Inspect.Opts.default_inspect_fun(fn\n :rewrite_atom, _ -> \"rewritten_atom\"\n value, opts -> Inspect.inspect(value, opts)\n end) == :ok\n\n assert inspect(:rewrite_atom) == \"rewritten_atom\"\n after\n Inspect.Opts.default_inspect_fun(&Inspect.inspect/2)\n end\nend\n\ndefmodule Inspect.AlgebraTest do\n use ExUnit.Case, async: true\n\n doctest Inspect.Algebra\n\n import Inspect.Algebra\n\n defp render(doc, limit) do\n doc |> group() |> format(limit) |> IO.iodata_to_binary()\n end\n\n test \"empty doc\" do\n # Consistent with definitions\n assert empty() == []\n\n # Consistent formatting\n assert render(empty(), 80) == \"\"\n end\n\n test \"strict break doc\" do\n # Consistent with definitions\n assert break(\"break\") == {:doc_break, \"break\", :strict}\n assert break(\"\") == {:doc_break, \"\", :strict}\n\n # Consistent formatting\n assert render(break(\"_\"), 80) == \"_\"\n assert render(glue(\"foo\", \" \", glue(\"bar\", \" \", \"baz\")), 10) == \"foo\\nbar\\nbaz\"\n end\n\n test \"flex break doc\" do\n # Consistent with definitions\n assert flex_break(\"break\") == {:doc_break, \"break\", :flex}\n assert flex_break(\"\") == {:doc_break, \"\", :flex}\n\n # Consistent formatting\n assert render(flex_break(\"_\"), 80) == \"_\"\n assert render(flex_glue(\"foo\", \" \", flex_glue(\"bar\", \" \", \"baz\")), 10) == \"foo bar\\nbaz\"\n end\n\n test \"glue doc\" do\n # Consistent with definitions\n assert glue(\"a\", \"->\", \"b\") == [\"a\", {:doc_break, \"->\", :strict} | \"b\"]\n assert glue(\"a\", \"b\") == glue(\"a\", \" \", \"b\")\n end\n\n test \"flex glue doc\" do\n # Consistent with definitions\n assert flex_glue(\"a\", \"->\", \"b\") ==\n [\"a\", {:doc_break, \"->\", :flex} | \"b\"]\n\n assert flex_glue(\"a\", \"b\") == flex_glue(\"a\", \" \", \"b\")\n end\n\n test \"binary doc\" do\n assert render(\"_\", 80) == \"_\"\n end\n\n test \"string doc\" do\n # Consistent with definitions\n assert string(\"ólá\") == {:doc_string, \"ólá\", 3}\n\n # Counts graphemes\n doc = glue(string(\"olá\"), \" \", string(\"mundo\"))\n assert render(doc, 9) == \"olá mundo\"\n end\n\n test \"space doc\" do\n # Consistent with definitions\n assert space(\"a\", \"b\") == [\"a\", \" \" | \"b\"]\n end\n\n test \"always nest doc\" do\n # Consistent with definitions\n assert nest(empty(), 1) == {:doc_nest, empty(), 1, :always}\n assert nest(empty(), 0) == []\n\n # Consistent formatting\n assert render(nest(\"a\", 1), 80) == \"a\"\n assert render(nest(glue(\"a\", \"b\"), 1), 2) == \"a\\n b\"\n assert render(nest(line(\"a\", \"b\"), 1), 20) == \"a\\n b\"\n end\n\n test \"break nest doc\" do\n # Consistent with definitions\n assert nest(empty(), 1, :break) == {:doc_nest, empty(), 1, :break}\n assert nest(empty(), 0, :break) == []\n\n # Consistent formatting\n assert render(nest(\"a\", 1, :break), 80) == \"a\"\n assert render(nest(glue(\"a\", \"b\"), 1, :break), 2) == \"a\\n b\"\n assert render(nest(line(\"a\", \"b\"), 1, :break), 20) == \"a\\nb\"\n end\n\n test \"cursor nest doc\" do\n # Consistent with definitions\n assert nest(empty(), :cursor) == {:doc_nest, empty(), :cursor, :always}\n\n # Consistent formatting\n assert render(nest(\"a\", :cursor), 80) == \"a\"\n assert render(concat(\"prefix \", nest(glue(\"a\", \"b\"), :cursor)), 2) == \"prefix a\\n b\"\n assert render(concat(\"prefix \", nest(line(\"a\", \"b\"), :cursor)), 2) == \"prefix a\\n b\"\n end\n\n test \"reset nest doc\" do\n # Consistent with definitions\n assert nest(empty(), :reset) == {:doc_nest, empty(), :reset, :always}\n\n # Consistent formatting\n assert render(nest(\"a\", :reset), 80) == \"a\"\n assert render(nest(nest(glue(\"a\", \"b\"), :reset), 10), 2) == \"a\\nb\"\n assert render(nest(nest(line(\"a\", \"b\"), :reset), 10), 2) == \"a\\nb\"\n end\n\n test \"color doc\" do\n # Consistent with definitions\n opts = %Inspect.Opts{}\n assert color_doc(empty(), :atom, opts) == empty()\n\n opts = %Inspect.Opts{syntax_colors: [regex: :red]}\n assert color_doc(empty(), :atom, opts) == empty()\n\n opts = %Inspect.Opts{syntax_colors: [atom: :red]}\n doc1 = {:doc_color, \"Hi\", IO.ANSI.red()}\n doc2 = {:doc_color, empty(), IO.ANSI.reset()}\n assert color_doc(\"Hi\", :atom, opts) == concat(doc1, doc2)\n\n opts = %Inspect.Opts{syntax_colors: [reset: :red]}\n assert color_doc(empty(), :atom, opts) == empty()\n\n opts = %Inspect.Opts{syntax_colors: [number: :cyan, reset: :red]}\n doc1 = {:doc_color, \"123\", IO.ANSI.cyan()}\n doc2 = {:doc_color, empty(), IO.ANSI.red()}\n assert color_doc(\"123\", :number, opts) == concat(doc1, doc2)\n\n # Consistent formatting\n opts = %Inspect.Opts{syntax_colors: [atom: :cyan]}\n assert render(glue(color_doc(\"AA\", :atom, opts), \"BB\"), 5) == \"\\e[36mAA\\e[0m BB\"\n assert render(glue(color_doc(\"AA\", :atom, opts), \"BB\"), 3) == \"\\e[36mAA\\e[0m\\nBB\"\n assert render(glue(\"AA\", color_doc(\"BB\", :atom, opts)), 6) == \"AA \\e[36mBB\\e[0m\"\n end\n\n test \"line doc\" do\n # Consistent with definitions\n assert line(\"a\", \"b\") == [\"a\", :doc_line | \"b\"]\n\n # Consistent formatting\n assert render(line(glue(\"aaa\", \"bbb\"), glue(\"ccc\", \"ddd\")), 10) == \"aaa bbb\\nccc ddd\"\n end\n\n test \"group doc\" do\n # Consistent with definitions\n assert group(\"ab\") == {:doc_group, \"ab\", :normal}\n assert group(empty()) == {:doc_group, empty(), :normal}\n\n # Consistent formatting\n doc = concat(glue(glue(glue(\"hello\", \"a\"), \"b\"), \"c\"), \"d\")\n assert render(group(doc), 5) == \"hello\\na\\nb\\ncd\"\n end\n\n test \"group modes doc\" do\n doc = glue(glue(\"hello\", \"a\"), \"b\")\n assert render(doc, 10) == \"hello a b\"\n\n assert render(doc |> glue(\"c\") |> group(), 10) ==\n \"hello\\na\\nb\\nc\"\n\n assert render(doc |> group() |> glue(\"c\") |> group() |> glue(\"d\"), 10) ==\n \"hello a b\\nc\\nd\"\n\n assert render(doc |> group(:optimistic) |> glue(\"c\") |> group() |> glue(\"d\"), 10) ==\n \"hello\\na\\nb c d\"\n\n assert render(doc |> group(:optimistic) |> glue(\"c\") |> group(:pessimistic) |> glue(\"d\"), 10) ==\n \"hello\\na\\nb c\\nd\"\n end\n\n test \"no limit doc\" do\n doc = no_limit(group(glue(glue(\"hello\", \"a\"), \"b\")))\n assert render(doc, 5) == \"hello a b\"\n assert render(doc, :infinity) == \"hello a b\"\n end\n\n test \"collapse lines\" do\n # Consistent with definitions\n assert collapse_lines(3) == {:doc_collapse, 3}\n\n # Consistent formatting\n doc = concat([collapse_lines(2), line(), line(), line()])\n assert render(doc, 10) == \"\\n\\n\"\n assert render(nest(doc, 2), 10) == \"\\n\\n \"\n\n doc = concat([collapse_lines(2), line(), line()])\n assert render(doc, 10) == \"\\n\\n\"\n assert render(nest(doc, 2), 10) == \"\\n\\n \"\n\n doc = concat([collapse_lines(2), line()])\n assert render(doc, 10) == \"\\n\"\n assert render(nest(doc, 2), 10) == \"\\n \"\n\n doc = concat([collapse_lines(2), line(), \"\", line(), \"\", line()])\n assert render(doc, 10) == \"\\n\\n\"\n assert render(nest(doc, 2), 10) == \"\\n\\n \"\n\n doc = concat([collapse_lines(2), line(), \"foo\", line(), \"bar\", line()])\n assert render(doc, 10) == \"\\nfoo\\nbar\\n\"\n assert render(nest(doc, 2), 10) == \"\\n foo\\n bar\\n \"\n end\n\n test \"force doc and cancel doc\" do\n # Consistent with definitions\n assert force_unfit(\"ab\") == {:doc_force, \"ab\"}\n assert force_unfit(empty()) == {:doc_force, empty()}\n\n # Consistent formatting\n doc = force_unfit(glue(glue(\"hello\", \"a\"), \"b\"))\n assert render(doc, 20) == \"hello\\na\\nb\"\n\n assert render(doc |> glue(\"c\") |> group(), 20) ==\n \"hello\\na\\nb\\nc\"\n\n assert render(doc |> group(:optimistic) |> glue(\"c\") |> group() |> glue(\"d\"), 20) ==\n \"hello\\na\\nb c d\"\n\n assert render(doc |> group(:optimistic) |> glue(\"c\") |> group(:pessimistic) |> glue(\"d\"), 20) ==\n \"hello\\na\\nb c\\nd\"\n end\n\n test \"formatting groups with lines\" do\n doc = line(glue(\"a\", \"b\"), glue(\"hello\", \"world\"))\n assert render(group(doc), 5) == \"a\\nb\\nhello\\nworld\"\n assert render(group(doc), 100) == \"a b\\nhello world\"\n end\n\n test \"formatting with infinity\" do\n str = String.duplicate(\"x\", 50)\n colon = \";\"\n\n doc =\n str\n |> glue(colon, str)\n |> glue(colon, str)\n |> glue(colon, str)\n |> glue(colon, str)\n |> group()\n\n assert render(doc, :infinity) ==\n str <> colon <> str <> colon <> str <> colon <> str <> colon <> str\n end\n\n test \"formatting container_doc with empty\" do\n sm = &container_doc(\"[\", &1, \"]\", %Inspect.Opts{}, fn d, _ -> d end, separator: \",\")\n\n assert sm.([]) |> render(80) == \"[]\"\n assert sm.([empty()]) |> render(80) == \"[]\"\n assert sm.([empty(), empty()]) |> render(80) == \"[]\"\n assert sm.([\"a\"]) |> render(80) == \"[a]\"\n assert sm.([\"a\", empty()]) |> render(80) == \"[a]\"\n assert sm.([empty(), \"a\"]) |> render(80) == \"[a]\"\n assert sm.([\"a\", empty(), \"b\"]) |> render(80) == \"[a, b]\"\n assert sm.([empty(), \"a\", \"b\"]) |> render(80) == \"[a, b]\"\n assert sm.([\"a\", \"b\", empty()]) |> render(80) == \"[a, b]\"\n assert sm.([\"a\", \"b\" | \"c\"]) |> render(80) == \"[a, b | c]\"\n assert sm.([\"a\" | \"b\"]) |> render(80) == \"[a | b]\"\n assert sm.([\"a\" | empty()]) |> render(80) == \"[a]\"\n assert sm.([empty() | \"b\"]) |> render(80) == \"[b]\"\n end\n\n test \"formatting container_doc with empty and limit\" do\n opts = %Inspect.Opts{limit: 2}\n value = [\"a\", empty(), \"b\"]\n\n assert container_doc(\"[\", value, \"]\", opts, fn d, _ -> d end, separator: \",\") |> render(80) ==\n \"[a, b]\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/inspect_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule Inspect.AtomTest do\n use ExUnit.Case, async: true\n\n doctest Inspect\n\n test \"basic\" do\n assert inspect(:foo) == \":foo\"\n end\n\n test \"empty\" do\n assert inspect(:\"\") == \":\\\"\\\"\"\n end\n\n test \"true, false, nil\" do\n assert inspect(false) == \"false\"\n assert inspect(true) == \"true\"\n assert inspect(nil) == \"nil\"\n end\n\n test \"with uppercase letters\" do\n assert inspect(:fOO) == \":fOO\"\n assert inspect(:FOO) == \":FOO\"\n end\n\n test \"aliases\" do\n assert inspect(Foo) == \"Foo\"\n assert inspect(Foo.Bar) == \"Foo.Bar\"\n assert inspect(Elixir) == \"Elixir\"\n assert inspect(Elixir.Foo) == \"Foo\"\n assert inspect(Elixir.Elixir) == \"Elixir.Elixir\"\n assert inspect(Elixir.Elixir.Foo) == \"Elixir.Elixir.Foo\"\n end\n\n test \"with integers\" do\n assert inspect(User1) == \"User1\"\n assert inspect(:user1) == \":user1\"\n end\n\n test \"with trailing ? or !\" do\n assert inspect(:foo?) == \":foo?\"\n assert inspect(:bar!) == \":bar!\"\n assert inspect(:Foo?) == \":Foo?\"\n end\n\n test \"operators\" do\n assert inspect(:+) == \":+\"\n assert inspect(:<~) == \":<~\"\n assert inspect(:~>) == \":~>\"\n assert inspect(:&&&) == \":&&&\"\n assert inspect(:\"~~~\") == \":\\\"~~~\\\"\"\n assert inspect(:<<~) == \":<<~\"\n assert inspect(:~>>) == \":~>>\"\n assert inspect(:<~>) == \":<~>\"\n assert inspect(:+++) == \":+++\"\n assert inspect(:---) == \":---\"\n end\n\n test \"::\" do\n assert inspect(:\"::\") == ~s[:\"::\"]\n end\n\n test \"with @\" do\n assert inspect(:@) == \":@\"\n assert inspect(:foo@bar) == \":foo@bar\"\n assert inspect(:foo@bar@) == \":foo@bar@\"\n assert inspect(:foo@bar@baz) == \":foo@bar@baz\"\n end\n\n test \"others\" do\n assert inspect(:...) == \":...\"\n assert inspect(:<<>>) == \":<<>>\"\n assert inspect(:{}) == \":{}\"\n assert inspect(:%{}) == \":%{}\"\n assert inspect(:%) == \":%\"\n assert inspect(:->) == \":->\"\n end\n\n test \"escaping\" do\n assert inspect(:\"hy-phen\") == ~s(:\"hy-phen\")\n assert inspect(:\"@hello\") == ~s(:\"@hello\")\n assert inspect(:\"Wat!?\") == ~s(:\"Wat!?\")\n assert inspect(:\"'quotes' and \\\"double quotes\\\"\") == ~S(:\"'quotes' and \\\"double quotes\\\"\")\n end\n\n test \"colors\" do\n opts = [syntax_colors: [atom: :red]]\n assert inspect(:hello, opts) == \"\\e[31m:hello\\e[0m\"\n opts = [syntax_colors: [reset: :cyan]]\n assert inspect(:hello, opts) == \":hello\"\n end\n\n test \"Unicode\" do\n assert inspect(:olá) == \":olá\"\n assert inspect(:Olá) == \":Olá\"\n assert inspect(:Ólá) == \":Ólá\"\n assert inspect(:こんにちは世界) == \":こんにちは世界\"\n\n nfd = :unicode.characters_to_nfd_binary(\"olá\")\n assert inspect(String.to_atom(nfd)) == \":\\\"#{nfd}\\\"\"\n end\nend\n\ndefmodule Inspect.BitStringTest do\n use ExUnit.Case, async: true\n\n test \"bitstring\" do\n assert inspect(<<1::12-integer-signed>>) == \"<<0, 1::size(4)>>\"\n\n assert inspect(<<1::12-integer-signed>>, syntax_colors: [number: :blue]) ==\n \"<<\\e[34m0\\e[0m, \\e[34m1\\e[0m::size(4)>>\"\n\n assert inspect(<<1, 2, 3, 4, 5>>, pretty: true, width: 10) == \"<<1, 2, 3,\\n 4, 5>>\"\n end\n\n test \"binary\" do\n assert inspect(\"foo\") == \"\\\"foo\\\"\"\n assert inspect(<>) == \"\\\"abc\\\"\"\n end\n\n test \"escaping\" do\n assert inspect(\"f\\no\") == \"\\\"f\\\\no\\\"\"\n assert inspect(\"f\\\\o\") == \"\\\"f\\\\\\\\o\\\"\"\n assert inspect(\"f\\ao\") == \"\\\"f\\\\ao\\\"\"\n\n assert inspect(\"\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v\") == \"\\\"\\\\a\\\\b\\\\d\\\\e\\\\f\\\\n\\\\r \\\\t\\\\v\\\"\"\n end\n\n test \"UTF-8\" do\n assert inspect(\" ゆんゆん\") == \"\\\" ゆんゆん\\\"\"\n # BOM\n assert inspect(\"\\uFEFFhello world\") == \"\\\"\\\\uFEFFhello world\\\"\"\n # Invisible characters\n assert inspect(\"\\u2063\") == \"\\\"\\\\u2063\\\"\"\n end\n\n test \"infer\" do\n assert inspect(<<\"john\", 193, \"doe\">>, binaries: :infer) ==\n ~s(<<106, 111, 104, 110, 193, 100, 111, 101>>)\n\n assert inspect(<<\"john\">>, binaries: :infer) == ~s(\"john\")\n assert inspect(<<193>>, binaries: :infer) == ~s(<<193>>)\n end\n\n test \"as strings\" do\n assert inspect(<<\"john\", 193, \"doe\">>, binaries: :as_strings) == ~s(\"john\\\\xC1doe\")\n assert inspect(<<\"john\">>, binaries: :as_strings) == ~s(\"john\")\n assert inspect(<<193>>, binaries: :as_strings) == ~s(\"\\\\xC1\")\n assert inspect(<<193>>, base: :hex, binaries: :as_strings) == ~s(\"\\\\xC1\")\n end\n\n test \"as binaries\" do\n assert inspect(<<\"john\", 193, \"doe\">>, binaries: :as_binaries) ==\n \"<<106, 111, 104, 110, 193, 100, 111, 101>>\"\n\n assert inspect(<<\"john\">>, binaries: :as_binaries) == \"<<106, 111, 104, 110>>\"\n assert inspect(<<193>>, binaries: :as_binaries) == \"<<193>>\"\n\n # Any base other than :decimal implies \"binaries: :as_binaries\"\n assert inspect(\"abc\", base: :hex) == \"<<0x61, 0x62, 0x63>>\"\n assert inspect(\"abc\", base: :octal) == \"<<0o141, 0o142, 0o143>>\"\n\n # Size is still represented as decimal\n assert inspect(<<10, 11, 12::4>>, base: :hex) == \"<<0xA, 0xB, 0xC::size(4)>>\"\n end\n\n test \"unprintable with limit\" do\n assert inspect(<<193, 193, 193, 193>>, limit: 3) == \"<<193, 193, 193, ...>>\"\n end\n\n test \"printable limit\" do\n assert inspect(\"hello world\", printable_limit: 4) == ~s(\"hell\" <> ...)\n\n # Non-printable characters after the limit don't matter\n assert inspect(\"hello world\" <> <<0>>, printable_limit: 4) == ~s(\"hell\" <> ...)\n\n # Non printable strings aren't affected by printable limit\n assert inspect(<<0, 1, 2, 3, 4>>, printable_limit: 3) == ~s(<<0, 1, 2, 3, 4>>)\n end\nend\n\ndefmodule Inspect.NumberTest do\n use ExUnit.Case, async: true\n\n test \"integer\" do\n assert inspect(100) == \"100\"\n end\n\n test \"decimal\" do\n assert inspect(100, base: :decimal) == \"100\"\n end\n\n test \"hex\" do\n assert inspect(100, base: :hex) == \"0x64\"\n assert inspect(-100, base: :hex) == \"-0x64\"\n end\n\n test \"octal\" do\n assert inspect(100, base: :octal) == \"0o144\"\n assert inspect(-100, base: :octal) == \"-0o144\"\n end\n\n test \"binary\" do\n assert inspect(86, base: :binary) == \"0b1010110\"\n assert inspect(-86, base: :binary) == \"-0b1010110\"\n end\n\n test \"float\" do\n assert inspect(1.0) == \"1.0\"\n assert inspect(1.0e10) == \"10000000000.0\"\n assert inspect(1.0e-10) == \"1.0e-10\"\n end\n\n test \"integer colors\" do\n opts = [syntax_colors: [number: :red]]\n assert inspect(123, opts) == \"\\e[31m123\\e[0m\"\n opts = [syntax_colors: [reset: :cyan]]\n assert inspect(123, opts) == \"123\"\n end\n\n test \"float colors\" do\n opts = [syntax_colors: [number: :red]]\n assert inspect(1.3, opts) == \"\\e[31m1.3\\e[0m\"\n opts = [syntax_colors: [reset: :cyan]]\n assert inspect(1.3, opts) == \"1.3\"\n end\nend\n\ndefmodule Inspect.TupleTest do\n use ExUnit.Case, async: true\n\n test \"basic\" do\n assert inspect({1, \"b\", 3}) == \"{1, \\\"b\\\", 3}\"\n assert inspect({1, \"b\", 3}, pretty: true, width: 1) == \"{1,\\n \\\"b\\\",\\n 3}\"\n assert inspect({1, \"b\", 3}, pretty: true, width: 10) == \"{1, \\\"b\\\",\\n 3}\"\n end\n\n test \"empty\" do\n assert inspect({}) == \"{}\"\n end\n\n test \"with limit\" do\n assert inspect({1, 2, 3, 4}, limit: 3) == \"{1, 2, 3, ...}\"\n end\n\n test \"colors\" do\n opts = [syntax_colors: []]\n assert inspect({}, opts) == \"{}\"\n\n opts = [syntax_colors: [reset: :cyan]]\n assert inspect({}, opts) == \"{}\"\n assert inspect({:x, :y}, opts) == \"{:x, :y}\"\n\n opts = [syntax_colors: [reset: :cyan, atom: :red]]\n assert inspect({}, opts) == \"{}\"\n assert inspect({:x, :y}, opts) == \"{\\e[31m:x\\e[36m, \\e[31m:y\\e[36m}\"\n\n opts = [syntax_colors: [tuple: :green, reset: :cyan, atom: :red]]\n assert inspect({}, opts) == \"\\e[32m{\\e[36m\\e[32m}\\e[36m\"\n\n assert inspect({:x, :y}, opts) ==\n \"\\e[32m{\\e[36m\\e[31m:x\\e[36m\\e[32m,\\e[36m \\e[31m:y\\e[36m\\e[32m}\\e[36m\"\n end\nend\n\ndefmodule Inspect.ListTest do\n use ExUnit.Case, async: true\n\n test \"basic\" do\n assert inspect([1, \"b\", 3]) == \"[1, \\\"b\\\", 3]\"\n assert inspect([1, \"b\", 3], pretty: true, width: 1) == \"[1,\\n \\\"b\\\",\\n 3]\"\n end\n\n test \"printable\" do\n assert inspect(~c\"abc\") == ~s(~c\"abc\")\n end\n\n test \"printable limit\" do\n assert inspect(~c\"hello world\", printable_limit: 4) == ~s(~c\"hell\" ++ ...)\n # Non printable characters after the limit don't matter\n assert inspect(~c\"hello world\" ++ [0], printable_limit: 4) == ~s(~c\"hell\" ++ ...)\n # Non printable strings aren't affected by printable limit\n assert inspect([0, 1, 2, 3, 4], printable_limit: 3) == ~s([0, 1, 2, 3, 4])\n end\n\n test \"keyword\" do\n assert inspect(a: 1) == \"[a: 1]\"\n assert inspect(a: 1, b: 2) == \"[a: 1, b: 2]\"\n assert inspect(a: 1, a: 2, b: 2) == \"[a: 1, a: 2, b: 2]\"\n assert inspect(\"123\": 1) == ~s([\"123\": 1])\n\n assert inspect([foo: [1, 2, 3], baz: [4, 5, 6]], pretty: true, width: 20) ==\n \"[\\n foo: [1, 2, 3],\\n baz: [4, 5, 6]\\n]\"\n end\n\n test \"keyword operators\" do\n assert inspect(\"::\": 1, +: 2) == ~s([\"::\": 1, +: 2])\n end\n\n test \"opt infer\" do\n assert inspect(~c\"john\" ++ [0] ++ ~c\"doe\", charlists: :infer) ==\n \"[106, 111, 104, 110, 0, 100, 111, 101]\"\n\n assert inspect(~c\"john\", charlists: :infer) == ~s(~c\"john\")\n assert inspect([0], charlists: :infer) == \"[0]\"\n end\n\n test \"opt as strings\" do\n assert inspect(~c\"john\" ++ [0] ++ ~c\"doe\", charlists: :as_charlists) == ~s(~c\"john\\\\0doe\")\n assert inspect(~c\"john\", charlists: :as_charlists) == ~s(~c\"john\")\n assert inspect([0], charlists: :as_charlists) == ~s(~c\"\\\\0\")\n end\n\n test \"opt as lists\" do\n assert inspect(~c\"john\" ++ [0] ++ ~c\"doe\", charlists: :as_lists) ==\n \"[106, 111, 104, 110, 0, 100, 111, 101]\"\n\n assert inspect(~c\"john\", charlists: :as_lists) == \"[106, 111, 104, 110]\"\n assert inspect([0], charlists: :as_lists) == \"[0]\"\n end\n\n test \"non printable\" do\n assert inspect([{:b, 1}, {:a, 1}]) == \"[b: 1, a: 1]\"\n end\n\n test \"improper\" do\n assert inspect([:foo | :bar]) == \"[:foo | :bar]\"\n\n assert inspect([1, 2, 3, 4, 5 | 42], pretty: true, width: 1) ==\n \"[1,\\n 2,\\n 3,\\n 4,\\n 5 |\\n 42]\"\n end\n\n test \"nested\" do\n assert inspect(Enum.reduce(1..5, [0], &[&2, &1]), limit: 5) ==\n \"[[[[[[...], ...], ...], ...], ...], ...]\"\n\n assert inspect(Enum.reduce(1..5, [0], &[&2, &1]), limit: 10) ==\n \"[[[[[[0], 1], 2], 3], 4], ...]\"\n\n assert inspect(Enum.reduce(1..6, [0], &[&2, &1]), limit: 10) ==\n \"[[[[[[[0], 1], 2], 3], ...], ...], ...]\"\n\n assert inspect(Enum.reduce(1..100, [0], &[&2 | &1]), limit: 5) ==\n \"[[[[[[...] | 96] | 97] | 98] | 99] | 100]\"\n end\n\n test \"codepoints\" do\n assert inspect(~c\"é\") == \"[233]\"\n end\n\n test \"empty\" do\n assert inspect([]) == \"[]\"\n end\n\n test \"with limit\" do\n assert inspect([1, 2, 3, 4], limit: 3) == \"[1, 2, 3, ...]\"\n end\n\n test \"colors\" do\n opts = [syntax_colors: []]\n assert inspect([], opts) == \"[]\"\n\n opts = [syntax_colors: [reset: :cyan]]\n assert inspect([], opts) == \"[]\"\n assert inspect([:x, :y], opts) == \"[:x, :y]\"\n\n opts = [syntax_colors: [reset: :cyan, atom: :red]]\n assert inspect([], opts) == \"[]\"\n assert inspect([:x, :y], opts) == \"[\\e[31m:x\\e[36m, \\e[31m:y\\e[36m]\"\n\n opts = [syntax_colors: [reset: :cyan, atom: :red, list: :green]]\n assert inspect([], opts) == \"\\e[32m[]\\e[36m\"\n\n assert inspect([:x, :y], opts) ==\n \"\\e[32m[\\e[36m\\e[31m:x\\e[36m\\e[32m,\\e[36m \\e[31m:y\\e[36m\\e[32m]\\e[36m\"\n end\n\n test \"keyword with colors\" do\n opts = [syntax_colors: [reset: :cyan, list: :green, number: :blue]]\n assert inspect([], opts) == \"\\e[32m[]\\e[36m\"\n\n assert inspect([a: 9999], opts) == \"\\e[32m[\\e[36ma: \\e[34m9999\\e[36m\\e[32m]\\e[36m\"\n\n opts = [syntax_colors: [reset: :cyan, atom: :red, list: :green, number: :blue]]\n assert inspect([], opts) == \"\\e[32m[]\\e[36m\"\n\n assert inspect([a: 9999], opts) == \"\\e[32m[\\e[36m\\e[31ma:\\e[36m \\e[34m9999\\e[36m\\e[32m]\\e[36m\"\n end\n\n test \"limit with colors\" do\n opts = [limit: 1, syntax_colors: [reset: :cyan, list: :green, atom: :red]]\n assert inspect([], opts) == \"\\e[32m[]\\e[36m\"\n\n assert inspect([:x, :y], opts) == \"\\e[32m[\\e[36m\\e[31m:x\\e[36m\\e[32m,\\e[36m ...\\e[32m]\\e[36m\"\n end\nend\n\ndefmodule Inspect.MapTest do\n use ExUnit.Case, async: true\n\n test \"basic\" do\n assert inspect(%{1 => \"b\"}) == \"%{1 => \\\"b\\\"}\"\n\n assert inspect(%{1 => \"b\", 2 => \"c\"},\n pretty: true,\n width: 1,\n custom_options: [sort_maps: true]\n ) ==\n \"%{\\n 1 => \\\"b\\\",\\n 2 => \\\"c\\\"\\n}\"\n end\n\n test \"keyword\" do\n assert inspect(%{a: 1}) == \"%{a: 1}\"\n assert inspect(%{a: 1, b: 2}, custom_options: [sort_maps: true]) == \"%{a: 1, b: 2}\"\n\n assert inspect(%{a: 1, b: 2, c: 3}, custom_options: [sort_maps: true]) ==\n \"%{a: 1, b: 2, c: 3}\"\n end\n\n test \"with limit\" do\n assert inspect(%{1 => 1, 2 => 2, 3 => 3, 4 => 4}, limit: 3) ==\n \"%{1 => 1, 2 => 2, 3 => 3, ...}\"\n end\n\n defmodule Public do\n defstruct key: 0\n end\n\n defmodule Private do\n end\n\n test \"public struct\" do\n assert inspect(%Public{key: 1}) == \"%Inspect.MapTest.Public{key: 1}\"\n end\n\n test \"public modified struct\" do\n public = %Public{key: 1}\n\n assert inspect(Map.put(public, :foo, :bar), custom_options: [sort_maps: true]) ==\n \"%{__struct__: Inspect.MapTest.Public, foo: :bar, key: 1}\"\n end\n\n test \"public modified struct with defimpl\" do\n map_set = MapSet.new([1, 2])\n\n assert inspect(Map.put(map_set, :foo, :bar), custom_options: [sort_maps: true]) ==\n \"%{__struct__: MapSet, foo: :bar, map: %{1 => [], 2 => []}}\"\n end\n\n test \"private struct\" do\n assert inspect(%{__struct__: Private, key: 1}, custom_options: [sort_maps: true]) ==\n \"%{__struct__: Inspect.MapTest.Private, key: 1}\"\n end\n\n defmodule Failing do\n @enforce_keys [:name]\n defstruct @enforce_keys\n\n defimpl Inspect do\n def inspect(%Failing{name: name}, _) do\n Atom.to_string(name)\n end\n end\n end\n\n test \"safely inspect bad implementation\" do\n assert_raise ArgumentError, ~r/argument error/, fn ->\n raise(ArgumentError)\n end\n\n message = ~s'''\n #Inspect.Error<\n got ArgumentError with message:\n\n \"\"\"\n errors were found at the given arguments:\n\n * 1st argument: not an atom\n \"\"\"\n\n while inspecting:\n\n %{__struct__: Inspect.MapTest.Failing, name: \"Foo\"}\n '''\n\n assert inspect(%Failing{name: \"Foo\"}, custom_options: [sort_maps: true]) =~ message\n end\n\n test \"safely inspect bad implementation disables colors\" do\n message = ~s'''\n #Inspect.Error<\n got ArgumentError with message:\n\n \"\"\"\n errors were found at the given arguments:\n\n * 1st argument: not an atom\n \"\"\"\n\n while inspecting:\n\n %{__struct__: Inspect.MapTest.Failing, name: \"Foo\"}\n '''\n\n assert inspect(%Failing{name: \"Foo\"},\n syntax_colors: [atom: [:green]],\n custom_options: [sort_maps: true]\n ) =~ message\n end\n\n test \"unsafely inspect bad implementation\" do\n exception_message = ~s'''\n got ArgumentError with message:\n\n \"\"\"\n errors were found at the given arguments:\n\n * 1st argument: not an atom\n \"\"\"\n\n while inspecting:\n\n %{__struct__: Inspect.MapTest.Failing, name: \"Foo\"}\n '''\n\n try do\n inspect(%Failing{name: \"Foo\"}, safe: false, custom_options: [sort_maps: true])\n rescue\n exception in Inspect.Error ->\n assert Exception.message(exception) =~ exception_message\n assert [{:erlang, :atom_to_binary, [_], [_ | _]} | _] = __STACKTRACE__\n else\n _ -> flunk(\"expected failure\")\n end\n end\n\n test \"raise when trying to inspect with a bad implementation from inside another exception that is being raised\" do\n # Inspect.Error is raised here when we tried to print the error message\n # called by another exception (Protocol.UndefinedError in this case)\n exception_message = ~s'''\n protocol Enumerable not implemented for Inspect.MapTest.Failing (a struct)\n\n Got value:\n\n #Inspect.Error<\n got ArgumentError with message:\n\n \"\"\"\n errors were found at the given arguments:\n\n * 1st argument: not an atom\n \"\"\"\n\n while inspecting:\n\n '''\n\n try do\n Enum.to_list(%Failing{name: \"Foo\"})\n rescue\n exception in Protocol.UndefinedError ->\n message = Exception.message(exception)\n assert message =~ exception_message\n assert message =~ \"__struct__: Inspect.MapTest.Failing\"\n assert message =~ \"name: \\\"Foo\\\"\"\n\n assert [\n {Enumerable, :impl_for!, 1, _} | _\n ] = __STACKTRACE__\n\n # The culprit\n assert Enum.any?(__STACKTRACE__, fn\n {Enum, :to_list, 1, _} -> true\n _ -> false\n end)\n\n # The line calling the culprit\n assert Enum.any?(__STACKTRACE__, fn\n {Inspect.MapTest, _test_name, 1, file: file, line: _line_number} ->\n String.ends_with?(List.to_string(file), \"test/elixir/inspect_test.exs\")\n\n _ ->\n false\n end)\n else\n _ -> flunk(\"expected failure\")\n end\n end\n\n test \"Exception.message/1 with bad implementation\" do\n failing = %Failing{name: \"Foo\"}\n\n message = ~s'''\n #Inspect.Error<\n got ArgumentError with message:\n\n \"\"\"\n errors were found at the given arguments:\n\n * 1st argument: not an atom\n \"\"\"\n\n while inspecting:\n\n %{__struct__: Inspect.MapTest.Failing, name: \"Foo\"}\n '''\n\n {my_argument_error, stacktrace} =\n try do\n atom_to_string(Process.get(:unused, failing.name))\n rescue\n e -> {e, __STACKTRACE__}\n end\n\n inspected =\n inspect(\n Inspect.Error.exception(\n exception: my_argument_error,\n stacktrace: stacktrace,\n inspected_struct: \"%{__struct__: Inspect.MapTest.Failing, name: \\\"Foo\\\"}\"\n )\n )\n\n assert inspect(failing, custom_options: [sort_maps: true]) =~ message\n assert inspected =~ message\n end\n\n defp atom_to_string(atom) do\n Atom.to_string(atom)\n end\n\n test \"exception\" do\n assert inspect(%RuntimeError{message: \"runtime error\"}) ==\n \"%RuntimeError{message: \\\"runtime error\\\"}\"\n end\n\n test \"colors\" do\n opts = [syntax_colors: [reset: :cyan, atom: :red, number: :magenta]]\n assert inspect(%{1 => 2}, opts) == \"%{\\e[35m1\\e[36m => \\e[35m2\\e[36m}\"\n\n assert inspect(%{a: 1}, opts) == \"%{\\e[31ma:\\e[36m \\e[35m1\\e[36m}\"\n\n assert inspect(%Public{key: 1}, opts) ==\n \"%Inspect.MapTest.Public{\\e[31mkey:\\e[36m \\e[35m1\\e[36m}\"\n\n opts = [syntax_colors: [reset: :cyan, atom: :red, map: :green, number: :blue]]\n\n assert inspect(%{a: 9999}, opts) ==\n \"\\e[32m%{\\e[36m\" <> \"\\e[31ma:\\e[36m \" <> \"\\e[34m9999\\e[36m\" <> \"\\e[32m}\\e[36m\"\n end\n\n defmodule StructWithoutOptions do\n @derive Inspect\n defstruct [:a, :b, :c, :d]\n end\n\n test \"struct without options\" do\n struct = %StructWithoutOptions{a: 1, b: 2, c: 3, d: 4}\n assert inspect(struct) == \"%Inspect.MapTest.StructWithoutOptions{a: 1, b: 2, c: 3, d: 4}\"\n\n assert inspect(struct, pretty: true, width: 1) ==\n \"%Inspect.MapTest.StructWithoutOptions{\\n a: 1,\\n b: 2,\\n c: 3,\\n d: 4\\n}\"\n end\n\n defmodule StructWithOnlyOption do\n @derive {Inspect, only: [:b, :c]}\n defstruct [:a, :b, :c, :d]\n end\n\n test \"struct with :only option\" do\n struct = %StructWithOnlyOption{a: 1, b: 2, c: 3, d: 4}\n assert inspect(struct) == \"#Inspect.MapTest.StructWithOnlyOption\"\n\n assert inspect(struct, pretty: true, width: 1) ==\n \"#Inspect.MapTest.StructWithOnlyOption<\\n b: 2,\\n c: 3,\\n ...\\n>\"\n\n struct = %{struct | c: [1, 2, 3, 4]}\n assert inspect(struct) == \"#Inspect.MapTest.StructWithOnlyOption\"\n end\n\n defmodule StructWithEmptyOnlyOption do\n @derive {Inspect, only: []}\n defstruct [:a, :b, :c, :d]\n end\n\n test \"struct with empty :only option\" do\n struct = %StructWithEmptyOnlyOption{a: 1, b: 2, c: 3, d: 4}\n assert inspect(struct) == \"#Inspect.MapTest.StructWithEmptyOnlyOption<...>\"\n end\n\n defmodule StructWithAllFieldsInOnlyOption do\n @derive {Inspect, only: [:a, :b]}\n defstruct [:a, :b]\n end\n\n test \"struct with all fields in the :only option\" do\n struct = %StructWithAllFieldsInOnlyOption{a: 1, b: 2}\n assert inspect(struct) == \"%Inspect.MapTest.StructWithAllFieldsInOnlyOption{a: 1, b: 2}\"\n\n assert inspect(struct, pretty: true, width: 1) ==\n \"%Inspect.MapTest.StructWithAllFieldsInOnlyOption{\\n a: 1,\\n b: 2\\n}\"\n end\n\n test \"struct missing fields in the :only option\" do\n assert_raise ArgumentError,\n \"unknown fields [:c] in :only when deriving the Inspect protocol for Inspect.MapTest.StructMissingFieldsInOnlyOption\",\n fn ->\n defmodule StructMissingFieldsInOnlyOption do\n @derive {Inspect, only: [:c]}\n defstruct [:a, :b]\n end\n end\n end\n\n test \"struct missing fields in the :except option\" do\n assert_raise ArgumentError,\n \"unknown fields [:c, :d] in :except when deriving the Inspect protocol for Inspect.MapTest.StructMissingFieldsInExceptOption\",\n fn ->\n defmodule StructMissingFieldsInExceptOption do\n @derive {Inspect, except: [:c, :d]}\n defstruct [:a, :b]\n end\n end\n end\n\n test \"passing a non-list to the :only option\" do\n assert_raise ArgumentError,\n \"invalid value :not_a_list in :only when deriving the Inspect protocol for Inspect.MapTest.StructInvalidListInOnlyOption (expected a list)\",\n fn ->\n defmodule StructInvalidListInOnlyOption do\n @derive {Inspect, only: :not_a_list}\n defstruct [:a, :b]\n end\n end\n end\n\n defmodule StructWithExceptOption do\n @derive {Inspect, except: [:b, :c]}\n defstruct [:a, :b, :c, :d]\n end\n\n test \"struct with :except option\" do\n struct = %StructWithExceptOption{a: 1, b: 2, c: 3, d: 4}\n assert inspect(struct) == \"#Inspect.MapTest.StructWithExceptOption\"\n\n assert inspect(struct, pretty: true, width: 1) ==\n \"#Inspect.MapTest.StructWithExceptOption<\\n a: 1,\\n d: 4,\\n ...\\n>\"\n end\n\n defmodule StructWithBothOnlyAndExceptOptions do\n @derive {Inspect, only: [:a, :b], except: [:b, :c]}\n defstruct [:a, :b, :c, :d]\n end\n\n test \"struct with both :only and :except options\" do\n struct = %StructWithBothOnlyAndExceptOptions{a: 1, b: 2, c: 3, d: 4}\n assert inspect(struct) == \"#Inspect.MapTest.StructWithBothOnlyAndExceptOptions\"\n\n assert inspect(struct, pretty: true, width: 1) ==\n \"#Inspect.MapTest.StructWithBothOnlyAndExceptOptions<\\n a: 1,\\n ...\\n>\"\n end\n\n defmodule StructWithOptionalAndOrder do\n @derive {Inspect, optional: [:b, :c]}\n defstruct [:c, :d, :a, :b]\n end\n\n test \"struct with both :order and :optional options\" do\n struct = %StructWithOptionalAndOrder{a: 1, b: 2, c: 3, d: 4}\n\n assert inspect(struct) ==\n \"%Inspect.MapTest.StructWithOptionalAndOrder{c: 3, d: 4, a: 1, b: 2}\"\n\n struct = %StructWithOptionalAndOrder{}\n assert inspect(struct) == \"%Inspect.MapTest.StructWithOptionalAndOrder{d: nil, a: nil}\"\n end\n\n defmodule StructWithExceptOptionalAndOrder do\n @derive {Inspect, optional: [:b, :c], except: [:e]}\n defstruct [:c, :d, :e, :a, :b]\n end\n\n test \"struct with :except, :order, and :optional options\" do\n struct = %StructWithExceptOptionalAndOrder{a: 1, b: 2, c: 3, d: 4}\n\n assert inspect(struct) ==\n \"#Inspect.MapTest.StructWithExceptOptionalAndOrder\"\n\n struct = %StructWithExceptOptionalAndOrder{}\n\n assert inspect(struct) ==\n \"#Inspect.MapTest.StructWithExceptOptionalAndOrder\"\n end\n\n defmodule StructWithOptionalAll do\n @derive {Inspect, optional: :all}\n defstruct [:a, :b, :c, :d]\n end\n\n test \"struct with :optional set to :all\" do\n struct = %StructWithOptionalAll{a: 1, b: 2}\n\n assert inspect(struct) == \"%Inspect.MapTest.StructWithOptionalAll{a: 1, b: 2}\"\n\n struct = %StructWithOptionalAll{}\n assert inspect(struct) == \"%Inspect.MapTest.StructWithOptionalAll{}\"\n end\nend\n\ndefmodule Inspect.OthersTest do\n use ExUnit.Case, async: true\n\n def fun() do\n fn -> :ok end\n end\n\n def unquote(:\"weirdly named/fun-\")() do\n fn -> :ok end\n end\n\n test \"external Elixir funs\" do\n bin = inspect(&Enum.map/2)\n assert bin == \"&Enum.map/2\"\n\n assert inspect(&__MODULE__.\"weirdly named/fun-\"/0) ==\n ~s(&Inspect.OthersTest.\"weirdly named/fun-\"/0)\n end\n\n test \"external Erlang funs\" do\n bin = inspect(&:lists.map/2)\n assert bin == \"&:lists.map/2\"\n end\n\n test \"outdated functions\" do\n defmodule V do\n def fun do\n fn -> 1 end\n end\n end\n\n Application.put_env(:elixir, :anony, V.fun())\n Application.put_env(:elixir, :named, &V.fun/0)\n\n :code.purge(V)\n :code.delete(V)\n\n anony = Application.get_env(:elixir, :anony)\n named = Application.get_env(:elixir, :named)\n\n assert inspect(anony) =~ ~r\"#Function<0.\\d+/0\"\n assert inspect(named) =~ ~r\"&Inspect.OthersTest.V.fun/0\"\n after\n Application.delete_env(:elixir, :anony)\n Application.delete_env(:elixir, :named)\n end\n\n test \"other funs\" do\n assert \"#Function<\" <> _ = inspect(fn x -> x + 1 end)\n assert \"#Function<\" <> _ = inspect(fun())\n opts = [syntax_colors: []]\n assert \"#Function<\" <> _ = inspect(fun(), opts)\n opts = [syntax_colors: [reset: :red]]\n assert \"#Function<\" <> rest = inspect(fun(), opts)\n assert String.ends_with?(rest, \">\")\n\n inspected = inspect(__MODULE__.\"weirdly named/fun-\"())\n assert inspected =~ ~r(#Function<\\d+\\.\\d+/0 in Inspect\\.OthersTest\\.\"weirdly named/fun-\"/0>)\n end\n\n test \"map set\" do\n assert \"MapSet.new(\" <> _ = inspect(MapSet.new())\n end\n\n test \"PIDs\" do\n assert \"#PID<\" <> _ = inspect(self())\n opts = [syntax_colors: []]\n assert \"#PID<\" <> _ = inspect(self(), opts)\n opts = [syntax_colors: [reset: :cyan]]\n assert \"#PID<\" <> rest = inspect(self(), opts)\n assert String.ends_with?(rest, \">\")\n end\n\n test \"references\" do\n assert \"#Reference<\" <> _ = inspect(make_ref())\n end\n\n test \"regex\" do\n assert inspect(~r(foo)m) == \"~r/foo/m\"\n assert inspect(~r[\\\\\\#{2,}]iu) == ~S\"~r/\\\\\\#{2,}/iu\"\n\n assert inspect(Regex.compile!(\"a\\\\/b\")) == \"~r/a\\\\/b/\"\n\n assert inspect(Regex.compile!(\"\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v/\")) ==\n \"~r/\\\\a\\\\x08\\\\x7F\\\\x1B\\\\f\\\\n\\\\r \\\\t\\\\v\\\\//\"\n\n assert inspect(~r<\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v/>) == \"~r/\\\\a\\\\b\\\\d\\\\e\\\\f\\\\n\\\\r\\\\s\\\\t\\\\v\\\\//\"\n assert inspect(~r\" \\\\/ \") == \"~r/ \\\\\\\\\\\\/ /\"\n assert inspect(~r/hi/, syntax_colors: [regex: :red]) == \"\\e[31m~r/hi/\\e[0m\"\n\n assert inspect(Regex.compile!(\"foo\", \"i\")) == \"~r/foo/i\"\n assert inspect(Regex.compile!(\"foo\", [:ucp])) == ~S'Regex.compile!(\"foo\", [:ucp])'\n end\n\n @tag :re_import\n test \"exported regex\" do\n assert inspect(~r/foo/E) == \"~r/foo/E\"\n end\n\n test \"inspect_fun\" do\n fun = fn\n integer, _opts when is_integer(integer) ->\n \"<#{integer}>\"\n\n %URI{} = uri, _opts ->\n \"#URI<#{uri}>\"\n\n term, opts ->\n Inspect.inspect(term, opts)\n end\n\n opts = [inspect_fun: fun]\n\n assert inspect(1000, opts) == \"<1000>\"\n assert inspect([1000], opts) == \"[<1000>]\"\n\n uri = URI.parse(\"https://elixir-lang.org\")\n assert inspect(uri, opts) == \"#URI\"\n assert inspect([uri], opts) == \"[#URI]\"\n end\n\n defmodule Nested do\n defstruct nested: nil\n\n defimpl Inspect do\n import Inspect.Algebra\n\n def inspect(%Nested{nested: nested}, opts) do\n indent = Keyword.get(opts.custom_options, :indent, 2)\n level = Keyword.get(opts.custom_options, :level, 1)\n\n nested_str =\n Kernel.inspect(nested, custom_options: [level: level + 1, indent: indent + 2])\n\n concat(\n nest(line(\"#Nested[##{level}/#{indent}]<\", nested_str), indent),\n nest(line(\"\", \">\"), indent - 2)\n )\n end\n end\n end\n\n test \"custom_options\" do\n assert inspect(%Nested{nested: %Nested{nested: 42}}) ==\n \"#Nested[#1/2]<\\n #Nested[#2/4]<\\n 42\\n >\\n>\"\n end\nend\n\ndefmodule Inspect.CustomProtocolTest do\n use ExUnit.Case, async: true\n\n defprotocol CustomInspect do\n def inspect(term, opts)\n end\n\n defmodule MissingImplementation do\n defstruct []\n end\n\n test \"unsafely inspect missing implementation\" do\n msg = ~S'''\n got Protocol.UndefinedError with message:\n\n \"\"\"\n protocol Inspect.CustomProtocolTest.CustomInspect not implemented for Inspect.CustomProtocolTest.MissingImplementation (a struct)\n\n Got value:\n\n %Inspect.CustomProtocolTest.MissingImplementation{}\n \"\"\"\n\n while inspecting:\n\n %{__struct__: Inspect.CustomProtocolTest.MissingImplementation}\n '''\n\n opts = [safe: false, inspect_fun: &CustomInspect.inspect/2]\n\n try do\n inspect(%MissingImplementation{}, opts)\n rescue\n e in Inspect.Error ->\n assert Exception.message(e) =~ msg\n assert [{Inspect.CustomProtocolTest.CustomInspect, :impl_for!, 1, _} | _] = __STACKTRACE__\n else\n _ -> flunk(\"expected failure\")\n end\n end\n\n test \"safely inspect missing implementation\" do\n msg = ~S'''\n #Inspect.Error<\n got Protocol.UndefinedError with message:\n\n \"\"\"\n protocol Inspect.CustomProtocolTest.CustomInspect not implemented for Inspect.CustomProtocolTest.MissingImplementation (a struct)\n\n Got value:\n\n %Inspect.CustomProtocolTest.MissingImplementation{}\n \"\"\"\n\n while inspecting:\n\n %{__struct__: Inspect.CustomProtocolTest.MissingImplementation}\n '''\n\n opts = [inspect_fun: &CustomInspect.inspect/2]\n assert inspect(%MissingImplementation{}, opts) =~ msg\n end\nend\n" }, { "path": "lib/elixir/test/elixir/integer_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule IntegerTest do\n use ExUnit.Case, async: true\n\n doctest Integer\n\n require Integer\n\n def test_is_odd_in_guards(number) when Integer.is_odd(number), do: number\n def test_is_odd_in_guards(_number), do: false\n\n def test_is_even_in_guards(number) when Integer.is_even(number), do: number\n def test_is_even_in_guards(_number), do: false\n\n test \"is_odd/1\" do\n assert Integer.is_odd(0) == false\n assert Integer.is_odd(1) == true\n assert Integer.is_odd(2) == false\n assert Integer.is_odd(3) == true\n assert Integer.is_odd(-1) == true\n assert Integer.is_odd(-2) == false\n assert Integer.is_odd(-3) == true\n assert test_is_odd_in_guards(10) == false\n assert test_is_odd_in_guards(11) == 11\n assert test_is_odd_in_guards(:not_integer) == false\n end\n\n test \"is_even/1\" do\n assert Integer.is_even(0) == true\n assert Integer.is_even(1) == false\n assert Integer.is_even(2) == true\n assert Integer.is_even(3) == false\n assert Integer.is_even(-1) == false\n assert Integer.is_even(-2) == true\n assert Integer.is_even(-3) == false\n assert test_is_even_in_guards(10) == 10\n assert test_is_even_in_guards(11) == false\n assert test_is_even_in_guards(:not_integer) == false\n end\n\n test \"mod/2\" do\n assert Integer.mod(10, -5) == 0\n assert Integer.mod(3, 2) == 1\n assert Integer.mod(0, 10) == 0\n assert Integer.mod(0, -5) == 0\n assert Integer.mod(30000, 2001) == 1986\n assert Integer.mod(30000, -2001) == -15\n assert Integer.mod(-20, 11) == 2\n assert Integer.mod(-55, -22) == -11\n end\n\n test \"mod/2 raises ArithmeticError when divisor is 0\" do\n assert_raise ArithmeticError, fn -> Integer.mod(3, 0) end\n assert_raise ArithmeticError, fn -> Integer.mod(-50, 0) end\n end\n\n test \"floor_div/2\" do\n assert Integer.floor_div(10, -5) == -2\n assert Integer.floor_div(3, 2) == 1\n assert Integer.floor_div(0, 10) == 0\n assert Integer.floor_div(0, -5) == 0\n assert Integer.floor_div(30000, 2001) == 14\n assert Integer.floor_div(30000, -2001) == -15\n assert Integer.floor_div(-20, 11) == -2\n assert Integer.floor_div(-55, -22) == 2\n end\n\n test \"floor_div/2 raises ArithmeticError when divisor is 0\" do\n assert_raise ArithmeticError, fn -> Integer.floor_div(3, 0) end\n assert_raise ArithmeticError, fn -> Integer.floor_div(-50, 0) end\n end\n\n test \"floor_div/2 raises ArithmeticError when non-integers used as arguments\" do\n assert_raise ArithmeticError, fn -> Integer.floor_div(3.0, 2) end\n assert_raise ArithmeticError, fn -> Integer.floor_div(20, 1.2) end\n end\n\n test \"ceil_div/2\" do\n assert Integer.ceil_div(10, -5) == -2\n assert Integer.ceil_div(3, 2) == 2\n assert Integer.ceil_div(0, 10) == 0\n assert Integer.ceil_div(0, -10) == 0\n assert Integer.ceil_div(30000, -2001) == -14\n assert Integer.ceil_div(-20, 11) == -1\n assert Integer.ceil_div(-55, -22) == 3\n end\n\n test \"ceil_div/2 raises ArithmeticError when divisor is 0\" do\n assert_raise ArithmeticError, fn -> Integer.ceil_div(3, 0) end\n assert_raise ArithmeticError, fn -> Integer.ceil_div(-50, 0) end\n end\n\n test \"ceil_div/2 raises ArithmeticError when non-integers used as arguments\" do\n assert_raise ArithmeticError, fn -> Integer.ceil_div(3.0, 2) end\n assert_raise ArithmeticError, fn -> Integer.ceil_div(20, 1.2) end\n end\n\n test \"digits/2\" do\n assert Integer.digits(0) == [0]\n assert Integer.digits(0, 2) == [0]\n assert Integer.digits(1) == [1]\n assert Integer.digits(-1) == [-1]\n assert Integer.digits(123, 123) == [1, 0]\n assert Integer.digits(-123, 123) == [-1, 0]\n assert Integer.digits(456, 1000) == [456]\n assert Integer.digits(-456, 1000) == [-456]\n assert Integer.digits(123) == [1, 2, 3]\n assert Integer.digits(-123) == [-1, -2, -3]\n assert Integer.digits(58127, 2) == [1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]\n assert Integer.digits(-58127, 2) == [-1, -1, -1, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, -1, -1]\n\n for n <- Enum.to_list(-1..1) do\n assert_raise FunctionClauseError, fn ->\n Integer.digits(10, n)\n Integer.digits(-10, n)\n end\n end\n end\n\n test \"undigits/2\" do\n assert Integer.undigits([]) == 0\n assert Integer.undigits([0]) == 0\n assert Integer.undigits([1]) == 1\n assert Integer.undigits([1, 0, 1]) == 101\n assert Integer.undigits([1, 4], 16) == 0x14\n assert Integer.undigits([1, 4], 8) == 0o14\n assert Integer.undigits([1, 1], 2) == 0b11\n assert Integer.undigits([1, 2, 3, 4, 5]) == 12345\n assert Integer.undigits([1, 0, -5]) == 95\n assert Integer.undigits([-1, -1, -5]) == -115\n assert Integer.undigits([0, 0, 0, -1, -1, -5]) == -115\n\n for n <- Enum.to_list(-1..1) do\n assert_raise FunctionClauseError, fn ->\n Integer.undigits([1, 0, 1], n)\n end\n end\n\n assert_raise ArgumentError, \"invalid digit 17 in base 16\", fn ->\n Integer.undigits([1, 2, 17], 16)\n end\n\n assert_raise ArgumentError, \"invalid digit -10 in base 10\", fn ->\n Integer.undigits([-10], 10)\n end\n\n assert_raise ArgumentError, \"invalid digit -17 in base 16\", fn ->\n Integer.undigits([1, 2, -17], 16)\n end\n end\n\n test \"parse/2\" do\n assert Integer.parse(\"12\") === {12, \"\"}\n assert Integer.parse(\"012\") === {12, \"\"}\n assert Integer.parse(\"+12\") === {12, \"\"}\n assert Integer.parse(\"-12\") === {-12, \"\"}\n assert Integer.parse(\"123456789\") === {123_456_789, \"\"}\n assert Integer.parse(\"12.5\") === {12, \".5\"}\n assert Integer.parse(\"7.5e-3\") === {7, \".5e-3\"}\n assert Integer.parse(\"12x\") === {12, \"x\"}\n assert Integer.parse(\"++1\") === :error\n assert Integer.parse(\"--1\") === :error\n assert Integer.parse(\"+-1\") === :error\n assert Integer.parse(\"three\") === :error\n\n assert Integer.parse(\"12\", 10) === {12, \"\"}\n assert Integer.parse(\"-12\", 12) === {-14, \"\"}\n assert Integer.parse(\"12345678\", 9) === {6_053_444, \"\"}\n assert Integer.parse(\"3.14\", 4) === {3, \".14\"}\n assert Integer.parse(\"64eb\", 16) === {25835, \"\"}\n assert Integer.parse(\"64eb\", 10) === {64, \"eb\"}\n assert Integer.parse(\"10\", 2) === {2, \"\"}\n assert Integer.parse(\"++4\", 10) === :error\n\n # Base should be in range 2..36\n assert_raise ArgumentError, \"invalid base 1\", fn -> Integer.parse(\"2\", 1) end\n assert_raise ArgumentError, \"invalid base 37\", fn -> Integer.parse(\"2\", 37) end\n\n # Base should be an integer\n assert_raise ArgumentError, \"invalid base 10.2\", fn -> Integer.parse(\"2\", 10.2) end\n\n assert_raise ArgumentError, \"invalid base nil\", fn -> Integer.parse(\"2\", nil) end\n end\n\n test \"to_string/2\" do\n assert Integer.to_string(42) == \"42\"\n assert Integer.to_string(+42) == \"42\"\n assert Integer.to_string(-42) == \"-42\"\n assert Integer.to_string(-0001) == \"-1\"\n\n for n <- [42.0, :forty_two, ~c\"42\", \"42\"] do\n assert_raise ArgumentError, fn ->\n Integer.to_string(n)\n end\n end\n\n assert Integer.to_string(42, 2) == \"101010\"\n assert Integer.to_string(42, 10) == \"42\"\n assert Integer.to_string(42, 16) == \"2A\"\n assert Integer.to_string(+42, 16) == \"2A\"\n assert Integer.to_string(-42, 16) == \"-2A\"\n assert Integer.to_string(-042, 16) == \"-2A\"\n\n for n <- [42.0, :forty_two, ~c\"42\", \"42\"] do\n assert_raise ArgumentError, fn ->\n Integer.to_string(n, 42)\n end\n end\n\n for n <- [-1, 0, 1, 37] do\n assert_raise ArgumentError, fn ->\n Integer.to_string(42, n)\n end\n\n assert_raise ArgumentError, fn ->\n Integer.to_string(n, n)\n end\n end\n end\n\n test \"to_charlist/2\" do\n module = String.to_atom(\"Elixir.Integer\")\n\n assert Integer.to_charlist(42) == ~c\"42\"\n assert Integer.to_charlist(+42) == ~c\"42\"\n assert Integer.to_charlist(-42) == ~c\"-42\"\n assert Integer.to_charlist(-0001) == ~c\"-1\"\n\n for n <- [42.0, :forty_two, ~c\"42\", \"42\"] do\n assert_raise ArgumentError, fn ->\n Integer.to_charlist(n)\n end\n end\n\n assert module.to_char_list(42) == ~c\"42\"\n assert module.to_char_list(42, 2) == ~c\"101010\"\n\n assert Integer.to_charlist(42, 2) == ~c\"101010\"\n assert Integer.to_charlist(42, 10) == ~c\"42\"\n assert Integer.to_charlist(42, 16) == ~c\"2A\"\n assert Integer.to_charlist(+42, 16) == ~c\"2A\"\n assert Integer.to_charlist(-42, 16) == ~c\"-2A\"\n assert Integer.to_charlist(-042, 16) == ~c\"-2A\"\n\n for n <- [42.0, :forty_two, ~c\"42\", \"42\"] do\n assert_raise ArgumentError, fn ->\n Integer.to_charlist(n, 42)\n end\n end\n\n for n <- [-1, 0, 1, 37] do\n assert_raise ArgumentError, fn ->\n Integer.to_charlist(42, n)\n end\n\n assert_raise ArgumentError, fn ->\n Integer.to_charlist(n, n)\n end\n end\n end\n\n test \"gcd/2\" do\n assert Integer.gcd(1, 5) == 1\n assert Integer.gcd(2, 3) == 1\n assert Integer.gcd(8, 12) == 4\n assert Integer.gcd(-8, 12) == 4\n assert Integer.gcd(8, -12) == 4\n assert Integer.gcd(-8, -12) == 4\n assert Integer.gcd(27, 27) == 27\n assert Integer.gcd(-27, -27) == 27\n assert Integer.gcd(-27, 27) == 27\n assert Integer.gcd(0, 3) == 3\n assert Integer.gcd(0, -3) == 3\n assert Integer.gcd(3, 0) == 3\n assert Integer.gcd(-3, 0) == 3\n assert Integer.gcd(0, 0) == 0\n end\n\n test \"extended_gcd\" do\n # Poor's man property based testing\n for _ <- 1..100 do\n left = :rand.uniform(1000)\n right = :rand.uniform(1000)\n {gcd, m, n} = Integer.extended_gcd(left, right)\n assert Integer.gcd(left, right) == gcd\n assert m * left + n * right == gcd\n end\n\n # zero cases\n for {left, right} <- [{10, 0}, {0, 10}, {0, -10}, {-10, 0}] do\n {gcd, m, n} = Integer.extended_gcd(left, right)\n assert Integer.gcd(left, right) == gcd\n assert m * left + n * right == gcd\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/io/ansi/docs_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../../test_helper.exs\", __DIR__)\n\ndefmodule IO.ANSI.DocsTest do\n use ExUnit.Case, async: true\n import ExUnit.CaptureIO\n\n def format_headings(list) do\n capture_io(fn -> IO.ANSI.Docs.print_headings(list, []) end) |> String.trim_trailing()\n end\n\n def format_metadata(map) do\n capture_io(fn -> IO.ANSI.Docs.print_metadata(map, []) end)\n end\n\n def format_markdown(str, opts \\\\ []) do\n capture_io(fn -> IO.ANSI.Docs.print(str, \"text/markdown\", opts) end)\n |> String.trim_trailing()\n end\n\n describe \"heading\" do\n test \"is formatted\" do\n result = format_headings([\"foo\"])\n assert String.starts_with?(result, \"\\e[0m\\n\\e[7m\\e[33m\")\n assert String.ends_with?(result, \"\\e[0m\\n\\e[0m\")\n assert String.contains?(result, \" foo \")\n end\n\n test \"multiple entries formatted\" do\n result = format_headings([\"foo\", \"bar\"])\n assert :binary.matches(result, \"\\e[0m\\n\\e[7m\\e[33m\") |> length() == 2\n assert String.starts_with?(result, \"\\e[0m\\n\\e[7m\\e[33m\")\n assert String.ends_with?(result, \"\\e[0m\\n\\e[0m\")\n assert String.contains?(result, \" foo \")\n assert String.contains?(result, \" bar \")\n end\n\n test \"is correctly formatted when newline character is present\" do\n result = format_headings([\"foo\\nbar\"])\n assert :binary.matches(result, \"\\e[0m\\n\\e[7m\\e[33m\") |> length() == 2\n assert [\"\\e[0m\", foo_line, bar_line, \"\\e[0m\"] = String.split(result, \"\\n\")\n assert Regex.match?(~r/\\e\\[7m\\e\\[33m +foo +\\e\\[0m/, foo_line)\n assert Regex.match?(~r/\\e\\[7m\\e\\[33m +bar +\\e\\[0m/, bar_line)\n end\n end\n\n describe \"metadata\" do\n test \"is formatted\" do\n result =\n format_metadata(%{\n since: \"1.2.3\",\n deprecated: \"Use that other one\",\n author: \"Alice\",\n delegate_to: {Foo, :bar, 3}\n })\n\n assert result == \"\"\"\n \\e[33mdelegate_to:\\e[0m Foo.bar/3\n \\e[33mdeprecated:\\e[0m Use that other one\n \\e[33msince:\\e[0m 1.2.3\n\n \"\"\"\n\n assert format_metadata(%{author: \"Alice\"}) == \"\"\n end\n end\n\n describe \"markdown\" do\n test \"first level heading is converted\" do\n result = format_markdown(\"# wibble\\n\\ntext\\n\")\n assert result == \"\\e[33m# wibble\\e[0m\\n\\e[0m\\ntext\\n\\e[0m\"\n end\n\n test \"second level heading is converted\" do\n result = format_markdown(\"## wibble\\n\\ntext\\n\")\n assert result == \"\\e[33m## wibble\\e[0m\\n\\e[0m\\ntext\\n\\e[0m\"\n end\n\n test \"third level heading is converted\" do\n result = format_markdown(\"### wibble\\n\\ntext\\n\")\n assert result == \"\\e[33m### wibble\\e[0m\\n\\e[0m\\ntext\\n\\e[0m\"\n end\n\n test \"short single-line quote block is converted into single-line quote\" do\n result =\n format_markdown(\"\"\"\n line\n\n > normal *italics* `code`\n\n line2\n \"\"\")\n\n assert result ==\n \"\"\"\n line\n \\e[0m\n \\e[90m> \\e[0mnormal \\e[4mitalics\\e[0m \\e[36mcode\\e[0m\n \\e[0m\n line2\n \\e[0m\\\n \"\"\"\n end\n\n test \"short multi-line quote block is converted into single-line quote\" do\n result =\n format_markdown(\"\"\"\n line\n\n > normal\n > *italics*\n > `code`\n\n line2\n \"\"\")\n\n assert result ==\n \"\"\"\n line\n \\e[0m\n \\e[90m> \\e[0mnormal \\e[4mitalics\\e[0m \\e[36mcode\\e[0m\n \\e[0m\n line2\n \\e[0m\\\n \"\"\"\n end\n\n test \"long multi-line quote block is converted into wrapped multi-line quote\" do\n result =\n format_markdown(\"\"\"\n line\n\n > normal\n > *italics*\n > `code`\n > some-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line\n\n line2\n \"\"\")\n\n assert result ==\n \"\"\"\n line\n \\e[0m\n \\e[90m> \\e[0mnormal \\e[4mitalics\\e[0m \\e[36mcode\\e[0m\n \\e[90m> \\e[0msome-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line\n \\e[0m\n line2\n \\e[0m\\\n \"\"\"\n end\n\n test \"multi-line quote block containing empty lines is converted into wrapped multi-line quote\" do\n result =\n format_markdown(\"\"\"\n line\n\n > normal\n > *italics*\n >\n > `code`\n > some-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line\n\n line2\n \"\"\")\n\n assert result ==\n \"\"\"\n line\n \\e[0m\n \\e[90m> \\e[0mnormal \\e[4mitalics\\e[0m\n \\e[90m> \\e[0m\n \\e[90m> \\e[0m\\e[36mcode\\e[0m\n \\e[90m> \\e[0msome-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line\n \\e[0m\n line2\n \\e[0m\\\n \"\"\"\n end\n\n test \"code block is converted\" do\n result = format_markdown(\"line\\n\\n code\\n code2\\n\\nline2\\n\")\n assert result == \"line\\n\\e[0m\\n\\e[36m code\\n code2\\e[0m\\n\\e[0m\\nline2\\n\\e[0m\"\n end\n\n test \"fenced code block is converted\" do\n result = format_markdown(\"line\\n```\\ncode\\ncode2\\n```\\nline2\\n\")\n assert result == \"line\\n\\e[0m\\n\\e[36m code\\n code2\\e[0m\\n\\e[0m\\nline2\\n\\e[0m\"\n result = format_markdown(\"line\\n```elixir\\ncode\\ncode2\\n```\\nline2\\n\")\n assert result == \"line\\n\\e[0m\\n\\e[36m code\\n code2\\e[0m\\n\\e[0m\\nline2\\n\\e[0m\"\n end\n\n test \"mermaid fenced code block is discarded\" do\n result = format_markdown(\"line\\n```mermaid\\ncode\\ncode2\\n```\\nline2\\n\")\n assert result == \"line\\n\\e[0m\\nline2\\n\\e[0m\"\n end\n\n test \"* list is converted\" do\n result = format_markdown(\"* one\\n* two\\n* three\\n\")\n assert result == \" • one\\n • two\\n • three\\n\\e[0m\"\n end\n\n test \"* list is converted without ansi\" do\n result = format_markdown(\"* one\\n* two\\n* three\\n\", enabled: false)\n assert result == \" * one\\n * two\\n * three\"\n end\n\n test \"* list surrounded by text is converted\" do\n result = format_markdown(\"Count:\\n\\n* one\\n* two\\n* three\\n\\nDone\")\n assert result == \"Count:\\n\\e[0m\\n • one\\n • two\\n • three\\n\\e[0m\\nDone\\n\\e[0m\"\n end\n\n test \"* list with continuation is converted\" do\n result = format_markdown(\"* one\\ntwo\\n\\n three\\nfour\\n* five\")\n assert result == \" • one two\\n three four\\n\\e[0m\\n • five\\n\\e[0m\"\n end\n\n test \"* nested lists are converted\" do\n result = format_markdown(\"* one\\n * one.one\\n * one.two\\n* two\")\n assert result == \" • one\\n • one.one\\n • one.two\\n\\e[0m\\n • two\\n\\e[0m\"\n end\n\n test \"* deep nested lists are converted\" do\n result =\n format_markdown(\"\"\"\n * level 1\n * level 2a\n * level 2b\n * level 3\n * level 4a\n * level 4b\n * level 5\n * level 6\n \"\"\")\n\n assert result ==\n \" • level 1\\n • level 2a\\n • level 2b\\n • level 3\\n • level 4a\\n • level 4b\\n • level 5\\n • level 6\\n\\e[0m\\n\\e[0m\\n\\e[0m\\n\\e[0m\\n\\e[0m\\n\\e[0m\"\n end\n\n test \"* lists with spaces are converted\" do\n result = format_markdown(\" * one\\n * two\\n * three\")\n assert result == \" • one\\n • two\\n • three\\n\\e[0m\"\n end\n\n test \"* lists with code\" do\n result = format_markdown(\" * one\\n two three\")\n assert result == \" • one\\n\\e[36m two three\\e[0m\\n\\e[0m\\n\\e[0m\"\n end\n\n test \"- list is converted\" do\n result = format_markdown(\"- one\\n- two\\n- three\\n\")\n assert result == \" • one\\n • two\\n • three\\n\\e[0m\"\n end\n\n test \"+ list is converted\" do\n result = format_markdown(\"+ one\\n+ two\\n+ three\\n\")\n assert result == \" • one\\n • two\\n • three\\n\\e[0m\"\n end\n\n test \"+ and - nested lists are converted\" do\n result = format_markdown(\"- one\\n + one.one\\n + one.two\\n- two\")\n assert result == \" • one\\n • one.one\\n • one.two\\n\\e[0m\\n • two\\n\\e[0m\"\n end\n\n test \"paragraphs are split\" do\n result = format_markdown(\"para1\\n\\npara2\")\n assert result == \"para1\\n\\e[0m\\npara2\\n\\e[0m\"\n end\n\n test \"extra whitespace is ignored between paras\" do\n result = format_markdown(\"para1\\n \\npara2\")\n assert result == \"para1\\n\\e[0m\\npara2\\n\\e[0m\"\n end\n\n test \"extra whitespace doesn't mess up a following list\" do\n result = format_markdown(\"para1\\n \\n* one\\n* two\")\n assert result == \"para1\\n\\e[0m\\n • one\\n • two\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick works\" do\n result = format_markdown(\"*world*\")\n assert result == \"\\e[4mworld\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"*world*.\")\n assert result == \"\\e[4mworld\\e[0m.\\n\\e[0m\"\n\n result = format_markdown(\"**world**\")\n assert result == \"\\e[1mworld\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"_world_\")\n assert result == \"\\e[4mworld\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"__world__\")\n assert result == \"\\e[1mworld\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"`world`\")\n assert result == \"\\e[36mworld\\e[0m\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick works across words\" do\n result = format_markdown(\"*hello world*\")\n assert result == \"\\e[4mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"**hello world**\")\n assert result == \"\\e[1mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"_hello world_\")\n assert result == \"\\e[4mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"__hello world__\")\n assert result == \"\\e[1mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"`hello world`\")\n assert result == \"\\e[36mhello world\\e[0m\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick works across words with ansi disabled\" do\n result = format_markdown(\"*hello world*\", enabled: false)\n assert result == \"*hello world*\"\n\n result = format_markdown(\"**hello world**\", enabled: false)\n assert result == \"**hello world**\"\n\n result = format_markdown(\"_hello world_\", enabled: false)\n assert result == \"_hello world_\"\n\n result = format_markdown(\"__hello world__\", enabled: false)\n assert result == \"__hello world__\"\n\n result = format_markdown(\"`hello world`\", enabled: false)\n assert result == \"`hello world`\"\n end\n\n test \"multiple stars/underscores/backticks work\" do\n result = format_markdown(\"*hello world* *hello world*\")\n assert result == \"\\e[4mhello world\\e[0m \\e[4mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"_hello world_ _hello world_\")\n assert result == \"\\e[4mhello world\\e[0m \\e[4mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"`hello world` `hello world`\")\n assert result == \"\\e[36mhello world\\e[0m \\e[36mhello world\\e[0m\\n\\e[0m\"\n end\n\n test \"multiple stars/underscores/backticks work when separated by other words\" do\n result = format_markdown(\"*hello world* unit test *hello world*\")\n assert result == \"\\e[4mhello world\\e[0m unit test \\e[4mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"_hello world_ unit test _hello world_\")\n assert result == \"\\e[4mhello world\\e[0m unit test \\e[4mhello world\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"`hello world` unit test `hello world`\")\n assert result == \"\\e[36mhello world\\e[0m unit test \\e[36mhello world\\e[0m\\n\\e[0m\"\n end\n\n test \"star/underscore preceded by space doesn't get interpreted\" do\n result = format_markdown(\"_unit _size\")\n assert result == \"_unit _size\\n\\e[0m\"\n\n result = format_markdown(\"**unit **size\")\n assert result == \"**unit **size\\n\\e[0m\"\n\n result = format_markdown(\"*unit *size\")\n assert result == \"*unit *size\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick preceded by non-space delimiters gets interpreted\" do\n result = format_markdown(\"(`hello world`)\")\n assert result == \"(\\e[36mhello world\\e[0m)\\n\\e[0m\"\n result = format_markdown(\"<`hello world`>\")\n assert result == \"<\\e[36mhello world\\e[0m>\\n\\e[0m\"\n\n result = format_markdown(\"(*hello world*)\")\n assert result == \"(\\e[4mhello world\\e[0m)\\n\\e[0m\"\n result = format_markdown(\"@*hello world*@\")\n assert result == \"@\\e[4mhello world\\e[0m@\\n\\e[0m\"\n\n result = format_markdown(\"(_hello world_)\")\n assert result == \"(\\e[4mhello world\\e[0m)\\n\\e[0m\"\n result = format_markdown(\"'_hello world_'\")\n assert result == \"'\\e[4mhello world\\e[0m'\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick starts/ends within a word doesn't get interpreted\" do\n result = format_markdown(\"foo_bar, foo_bar_baz!\")\n assert result == \"foo_bar, foo_bar_baz!\\n\\e[0m\"\n\n result = format_markdown(\"_foo_bar\")\n assert result == \"_foo_bar\\n\\e[0m\"\n\n result = format_markdown(\"foo_bar_\")\n assert result == \"foo_bar_\\n\\e[0m\"\n\n result = format_markdown(\"foo*bar, foo*bar*baz!\")\n assert result == \"foo*bar, foo*bar*baz!\\n\\e[0m\"\n\n result = format_markdown(\"*foo*bar\")\n assert result == \"*foo*bar\\n\\e[0m\"\n\n result = format_markdown(\"foo*bar*\")\n assert result == \"foo*bar*\\n\\e[0m\"\n end\n\n test \"backtick preceded by space gets interpreted\" do\n result = format_markdown(\"`unit `size\")\n assert result == \"\\e[36munit \\e[0msize\\n\\e[0m\"\n end\n\n test \"backtick does not escape characters\" do\n result = format_markdown(\"`Ctrl+\\\\ `\")\n assert result == \"\\e[36mCtrl+\\\\ \\e[0m\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick with leading escape\" do\n result = format_markdown(\"\\\\_unit_\")\n assert result == \"_unit_\\n\\e[0m\"\n\n result = format_markdown(\"\\\\*unit*\")\n assert result == \"*unit*\\n\\e[0m\"\n\n result = format_markdown(\"\\\\`unit`\")\n assert result == \"`unit`\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick with closing escape\" do\n result = format_markdown(\"_unit\\\\_\")\n assert result == \"_unit_\\n\\e[0m\"\n\n result = format_markdown(\"*unit\\\\*\")\n assert result == \"*unit*\\n\\e[0m\"\n\n result = format_markdown(\"`unit\\\\`\")\n assert result == \"\\e[36munit\\\\\\e[0m\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick with double escape\" do\n result = format_markdown(\"\\\\\\\\*world*\")\n assert result == \"\\\\\\e[4mworld\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"\\\\\\\\_world_\")\n assert result == \"\\\\\\e[4mworld\\e[0m\\n\\e[0m\"\n\n result = format_markdown(\"\\\\\\\\`world`\")\n assert result == \"\\\\\\e[36mworld\\e[0m\\n\\e[0m\"\n end\n\n test \"star/underscore/backtick when incomplete\" do\n result = format_markdown(\"unit_size\")\n assert result == \"unit_size\\n\\e[0m\"\n\n result = format_markdown(\"unit`size\")\n assert result == \"unit`size\\n\\e[0m\"\n\n result = format_markdown(\"unit*size\")\n assert result == \"unit*size\\n\\e[0m\"\n\n result = format_markdown(\"unit**size\")\n assert result == \"unit**size\\n\\e[0m\"\n end\n\n test \"backtick with escape\" do\n result = format_markdown(\"`\\\\`\")\n assert result == \"\\e[36m\\\\\\e[0m\\n\\e[0m\"\n end\n\n test \"backtick close to underscores gets interpreted as code\" do\n result = format_markdown(\"`__world__`\")\n assert result == \"\\e[36m__world__\\e[0m\\n\\e[0m\"\n end\n\n test \"escaping of underlines within links\" do\n result = format_markdown(\"(https://en.wikipedia.org/wiki/ANSI_escape_code)\")\n assert result == \"(https://en.wikipedia.org/wiki/ANSI_escape_code)\\n\\e[0m\"\n\n result =\n format_markdown(\"[ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code)\")\n\n assert result == \"ANSI escape code (https://en.wikipedia.org/wiki/ANSI_escape_code)\\n\\e[0m\"\n\n result = format_markdown(\"(ftp://example.com/ANSI_escape_code.zip)\")\n assert result == \"(ftp://example.com/ANSI_escape_code.zip)\\n\\e[0m\"\n end\n\n test \"escaping of underlines within links does not escape surrounding text\" do\n result =\n format_markdown(\n \"_emphasis_ (https://en.wikipedia.org/wiki/ANSI_escape_code) more _emphasis_\"\n )\n\n assert result ==\n \"\\e[4memphasis\\e[0m (https://en.wikipedia.org/wiki/ANSI_escape_code) more \\e[4memphasis\\e[0m\\n\\e[0m\"\n end\n\n test \"escaping of underlines within links avoids false positives\" do\n assert format_markdown(\"`https_proxy`\") == \"\\e[36mhttps_proxy\\e[0m\\n\\e[0m\"\n end\n\n test \"escaping of several Markdown links in one line\" do\n assert format_markdown(\"[List](`List`) (`[1, 2, 3]`), [Map](`Map`)\") ==\n \"List (\\e[36mList\\e[0m) (\\e[36m[1, 2, 3]\\e[0m), Map (\\e[36mMap\\e[0m)\\n\\e[0m\"\n end\n\n test \"one reference link label per line\" do\n assert format_markdown(\" [id]: //example.com\\n [Elixir]: https://elixir-lang.org\") ==\n \" [id]: //example.com\\n [Elixir]: https://elixir-lang.org\"\n end\n end\n\n describe \"markdown tables\" do\n test \"lone thing that looks like a table line isn't\" do\n assert format_markdown(\"one\\n2 | 3\\ntwo\\n\") == \"one 2 | 3 two\\n\\e[0m\"\n end\n\n test \"lone table line at end of input isn't\" do\n assert format_markdown(\"one\\n2 | 3\") == \"one 2 | 3\\n\\e[0m\"\n end\n\n test \"two successive table lines are a table\" do\n # note spacing\n assert format_markdown(\"a | b\\none | two\\n\") == \"a | b \\none | two\\n\\e[0m\"\n end\n\n test \"table with heading\" do\n assert format_markdown(\"column 1 | and 2\\n-- | --\\na | b\\none | two\\n\") ==\n \"\\e[7mcolumn 1 | and 2\\e[0m\\na | b \\none | two \\n\\e[0m\"\n end\n\n test \"table with heading alignment\" do\n table = \"\"\"\n column 1 | 2 | and three\n -------: | :------: | :-----\n a | even | c\\none | odd | three\n \"\"\"\n\n expected =\n \"\"\"\n \\e[7mcolumn 1 | 2 | and three\\e[0m\n a | even | c\\s\\s\\s\\s\\s\\s\\s\\s\n one | odd | three\\s\\s\\s\\s\n \\e[0m\n \"\"\"\n |> String.trim_trailing()\n\n assert format_markdown(table) == expected\n end\n\n test \"table with heading alignment and no space around \\\"|\\\"\" do\n table = \"\"\"\n | Value | Encoding | Value | Encoding |\n |------:|:---------|------:|:---------|\n | 0 | A | 17 | R |\n | 1 | B | 18 | S |\n \"\"\"\n\n expected =\n \"\\e[7m\" <>\n \"Value | Encoding | Value | Encoding\\e[0m\\n\" <>\n \" 0 | A | 17 | R \\n\" <>\n \" 1 | B | 18 | S \\n\\e[0m\"\n\n assert format_markdown(table) == expected\n end\n\n test \"table with formatting in cells\" do\n assert format_markdown(\"`a` | _b_\\nc | d\") == \"\\e[36ma\\e[0m | \\e[4mb\\e[0m\\nc | d\\n\\e[0m\"\n\n assert format_markdown(\"`abc` | d \\n`e` | f\") ==\n \"\\e[36mabc\\e[0m | d\\n\\e[36me\\e[0m | f\\n\\e[0m\"\n end\n\n test \"table with variable number of columns\" do\n assert format_markdown(\"a | b | c\\nd | e\") == \"a | b | c\\nd | e | \\n\\e[0m\"\n end\n\n test \"table with escaped \\\"|\\\" inside cell\" do\n table = \"a | smth\\\\|smth_else | c\\nd | e | f\"\n\n expected =\n \"\"\"\n a | smth|smth_else | c\n d | e | f\n \\e[0m\n \"\"\"\n |> String.trim_trailing()\n\n assert format_markdown(table) == expected\n end\n\n test \"table with last two columns empty\" do\n table = \"\"\"\n AAA | | |\n BBB | CCC | |\n GGG | HHH | III |\n JJJ | KKK | LLL | MMM\n \"\"\"\n\n expected =\n \"\"\"\n AAA | | |\\s\\s\\s\\s\n BBB | CCC | |\\s\\s\\s\\s\n GGG | HHH | III |\\s\\s\\s\\s\n JJJ | KKK | LLL | MMM\n \\e[0m\n \"\"\"\n |> String.trim_trailing()\n\n assert format_markdown(table) == expected\n end\n\n test \"HTML comments are ignored\" do\n markdown = \"\"\"\n \n hello\n \"\"\"\n\n assert format_markdown(markdown) == \"hello\\n\\e[0m\"\n\n markdown = \"\"\"\n \n\n hello\n \"\"\"\n\n assert format_markdown(markdown) == \"hello\\n\\e[0m\"\n\n markdown = \"\"\"\n hello\n \n world\n \"\"\"\n\n assert format_markdown(markdown) == \"hello\\n\\e[0m\\nworld\\n\\e[0m\"\n\n markdown = \"\"\"\n hello\n\n \n\n world\n \"\"\"\n\n assert format_markdown(markdown) == \"hello\\n\\e[0m\\nworld\\n\\e[0m\"\n\n markdown = \"\"\"\n hello\n world\n \"\"\"\n\n assert format_markdown(markdown) == \"hello world\\n\\e[0m\"\n\n markdown = \"\"\"\n hello world\n \"\"\"\n\n assert format_markdown(markdown) == \"hello world\\n\\e[0m\"\n end\n end\n\n describe \"invalid format\" do\n test \"prints message\" do\n assert capture_io(fn -> IO.ANSI.Docs.print(\"hello\", \"text/unknown\", []) end) ==\n \"\\nUnknown documentation format \\\"text/unknown\\\"\\n\\n\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/io/ansi_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule IO.ANSITest do\n use ExUnit.Case, async: true\n\n doctest IO.ANSI\n\n test \"format ansicode\" do\n assert IO.chardata_to_string(IO.ANSI.format(:green, true)) ==\n \"#{IO.ANSI.green()}#{IO.ANSI.reset()}\"\n\n assert IO.chardata_to_string(IO.ANSI.format(:green, false)) == \"\"\n end\n\n test \"format binary\" do\n assert IO.chardata_to_string(IO.ANSI.format(\"Hello, world!\", true)) == \"Hello, world!\"\n\n assert IO.chardata_to_string(IO.ANSI.format(\"A map: %{foo: :bar}\", false)) ==\n \"A map: %{foo: :bar}\"\n end\n\n test \"format empty list\" do\n assert IO.chardata_to_string(IO.ANSI.format([], true)) == \"\"\n assert IO.chardata_to_string(IO.ANSI.format([], false)) == \"\"\n end\n\n test \"format ansicode list\" do\n assert IO.chardata_to_string(IO.ANSI.format([:red, :bright], true)) ==\n \"#{IO.ANSI.red()}#{IO.ANSI.bright()}#{IO.ANSI.reset()}\"\n\n assert IO.chardata_to_string(IO.ANSI.format([:red, :bright], false)) == \"\"\n end\n\n test \"format binary list\" do\n assert IO.chardata_to_string(IO.ANSI.format([\"Hello, \", \"world!\"], true)) == \"Hello, world!\"\n assert IO.chardata_to_string(IO.ANSI.format([\"Hello, \", \"world!\"], false)) == \"Hello, world!\"\n end\n\n test \"format charlist\" do\n assert IO.chardata_to_string(IO.ANSI.format(~c\"Hello, world!\", true)) == \"Hello, world!\"\n assert IO.chardata_to_string(IO.ANSI.format(~c\"Hello, world!\", false)) == \"Hello, world!\"\n end\n\n test \"format mixed list\" do\n data = [\"Hello\", ?,, 32, :red, \"world!\"]\n\n assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==\n \"Hello, #{IO.ANSI.red()}world!#{IO.ANSI.reset()}\"\n\n assert IO.chardata_to_string(IO.ANSI.format(data, false)) == \"Hello, world!\"\n end\n\n test \"format nested list\" do\n data = [\"Hello, \", [\"nested\", 32, :red, \"world!\"]]\n\n assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==\n \"Hello, nested #{IO.ANSI.red()}world!#{IO.ANSI.reset()}\"\n\n assert IO.chardata_to_string(IO.ANSI.format(data, false)) == \"Hello, nested world!\"\n end\n\n test \"format improper list\" do\n data = [\"Hello, \", :red, \"world\" | \"!\"]\n\n assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==\n \"Hello, #{IO.ANSI.red()}world!#{IO.ANSI.reset()}\"\n\n assert IO.chardata_to_string(IO.ANSI.format(data, false)) == \"Hello, world!\"\n end\n\n test \"format nested improper list\" do\n data = [[\"Hello, \" | :red], \"world!\" | :green]\n\n assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==\n \"Hello, #{IO.ANSI.red()}world!#{IO.ANSI.green()}#{IO.ANSI.reset()}\"\n\n assert IO.chardata_to_string(IO.ANSI.format(data, false)) == \"Hello, world!\"\n end\n\n test \"format fragment\" do\n assert IO.chardata_to_string(IO.ANSI.format_fragment([:red, \"Hello!\"], true)) ==\n \"#{IO.ANSI.red()}Hello!\"\n end\n\n test \"format invalid sequence\" do\n assert_raise ArgumentError, \"invalid ANSI sequence specification: :brigh\", fn ->\n IO.ANSI.format([:brigh, \"Hello!\"], true)\n end\n\n assert_raise ArgumentError, \"invalid ANSI sequence specification: nil\", fn ->\n IO.ANSI.format([\"Hello!\", nil], true)\n end\n\n assert_raise ArgumentError, \"invalid ANSI sequence specification: :brigh\", fn ->\n IO.ANSI.format([:brigh, \"Hello!\"], false)\n end\n\n assert_raise ArgumentError, \"invalid ANSI sequence specification: nil\", fn ->\n IO.ANSI.format([\"Hello!\", nil], false)\n end\n\n assert_raise ArgumentError, \"invalid ANSI sequence specification: :invalid\", fn ->\n IO.ANSI.format(:invalid, false)\n end\n end\n\n test \"colors\" do\n assert IO.ANSI.red() == \"\\e[31m\"\n assert IO.ANSI.light_red() == \"\\e[91m\"\n\n assert IO.ANSI.red_background() == \"\\e[41m\"\n assert IO.ANSI.light_red_background() == \"\\e[101m\"\n end\n\n test \"color/1\" do\n assert IO.ANSI.color(0) == \"\\e[38;5;0m\"\n assert IO.ANSI.color(42) == \"\\e[38;5;42m\"\n assert IO.ANSI.color(255) == \"\\e[38;5;255m\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color(-1)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color(256)\n end\n end\n\n test \"color/3\" do\n assert IO.ANSI.color(0, 4, 2) == \"\\e[38;5;42m\"\n assert IO.ANSI.color(1, 1, 1) == \"\\e[38;5;59m\"\n assert IO.ANSI.color(5, 5, 5) == \"\\e[38;5;231m\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color(0, 6, 1)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color(5, -1, 1)\n end\n end\n\n test \"color_background/1\" do\n assert IO.ANSI.color_background(0) == \"\\e[48;5;0m\"\n assert IO.ANSI.color_background(42) == \"\\e[48;5;42m\"\n assert IO.ANSI.color_background(255) == \"\\e[48;5;255m\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color_background(-1)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color_background(256)\n end\n end\n\n test \"color_background/3\" do\n assert IO.ANSI.color_background(0, 4, 2) == \"\\e[48;5;42m\"\n assert IO.ANSI.color_background(1, 1, 1) == \"\\e[48;5;59m\"\n assert IO.ANSI.color_background(5, 5, 5) == \"\\e[48;5;231m\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color_background(0, 6, 1)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.color_background(5, -1, 1)\n end\n end\n\n test \"cursor/2\" do\n assert IO.ANSI.cursor(0, 0) == \"\\e[0;0H\"\n assert IO.ANSI.cursor(11, 12) == \"\\e[11;12H\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor(-1, 5)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor(5, -1)\n end\n end\n\n test \"cursor_up/1\" do\n assert IO.ANSI.cursor_up() == \"\\e[1A\"\n assert IO.ANSI.cursor_up(12) == \"\\e[12A\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_up(0)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_up(-1)\n end\n end\n\n test \"cursor_down/1\" do\n assert IO.ANSI.cursor_down() == \"\\e[1B\"\n assert IO.ANSI.cursor_down(2) == \"\\e[2B\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_right(0)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_down(-1)\n end\n end\n\n test \"cursor_left/1\" do\n assert IO.ANSI.cursor_left() == \"\\e[1D\"\n assert IO.ANSI.cursor_left(3) == \"\\e[3D\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_left(0)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_left(-1)\n end\n end\n\n test \"cursor_right/1\" do\n assert IO.ANSI.cursor_right() == \"\\e[1C\"\n assert IO.ANSI.cursor_right(4) == \"\\e[4C\"\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_right(0)\n end\n\n assert_raise FunctionClauseError, fn ->\n IO.ANSI.cursor_right(-1)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/io_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule IOTest do\n use ExUnit.Case, async: true\n\n doctest IO\n\n import ExUnit.CaptureIO\n\n test \"read with count\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.txt\", __DIR__), [:charlist])\n assert ~c\"FOO\" == IO.read(file, 3)\n assert File.close(file) == :ok\n end\n\n test \"read with UTF-8 and binary\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__), [:utf8])\n assert \"Русский\" == IO.read(file, 7)\n assert File.close(file) == :ok\n end\n\n test \"read all charlist\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/multiline_file.txt\", __DIR__), [:charlist])\n assert ~c\"this is the first line\\nthis is the second line\\n\" == IO.read(file, :eof)\n assert File.close(file) == :ok\n end\n\n test \"read empty file\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/cp_mode\", __DIR__), [])\n assert IO.read(file, :eof) == :eof\n assert File.close(file) == :ok\n\n {:ok, file} = File.open(Path.expand(~c\"fixtures/cp_mode\", __DIR__), [:charlist])\n assert IO.read(file, :eof) == :eof\n assert File.close(file) == :ok\n end\n\n test \"binread\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__))\n assert \"Русский\" == IO.binread(file, 14)\n assert File.close(file) == :ok\n end\n\n test \"binread eof\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.bin\", __DIR__))\n assert \"LF\\nCR\\rCRLF\\r\\nLFCR\\n\\r\" == IO.binread(file, :eof)\n assert File.close(file) == :ok\n end\n\n test \"getn\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.txt\", __DIR__))\n assert \"F\" == IO.getn(file, \"\")\n assert \"O\" == IO.getn(file, \"\")\n assert \"O\" == IO.getn(file, \"\")\n assert \"\\n\" == IO.getn(file, \"\")\n assert :eof == IO.getn(file, \"\")\n assert File.close(file) == :ok\n end\n\n test \"getn with count\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.txt\", __DIR__), [:charlist])\n assert ~c\"F\" == IO.getn(file, \"λ\")\n assert ~c\"OO\" == IO.getn(file, \"\", 2)\n assert ~c\"\\n\" == IO.getn(file, \"λ\", 99)\n assert :eof == IO.getn(file, \"λ\", 1)\n assert File.close(file) == :ok\n end\n\n test \"getn with eof\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.txt\", __DIR__), [:charlist])\n assert ~c\"F\" == IO.getn(file, \"λ\")\n assert ~c\"OO\\n\" == IO.getn(file, \"\", :eof)\n assert :eof == IO.getn(file, \"\", :eof)\n assert File.close(file) == :ok\n end\n\n test \"getn with UTF-8 and binary\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__), [:utf8])\n assert \"Русский\" == IO.getn(file, \"\", 7)\n assert \"\\n日\\n\" == IO.getn(file, \"\", :eof)\n assert :eof == IO.getn(file, \"\", :eof)\n assert File.close(file) == :ok\n end\n\n test \"gets\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.txt\", __DIR__), [:charlist])\n assert ~c\"FOO\\n\" == IO.gets(file, \"\")\n assert :eof == IO.gets(file, \"\")\n assert File.close(file) == :ok\n end\n\n test \"gets with UTF-8 and binary\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__), [:utf8])\n assert \"Русский\\n\" == IO.gets(file, \"\")\n assert \"日\\n\" == IO.gets(file, \"\")\n assert File.close(file) == :ok\n end\n\n test \"read with eof\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.txt\", __DIR__))\n assert \"FOO\\n\" == IO.read(file, :eof)\n assert :eof == IO.read(file, :eof)\n assert File.close(file) == :ok\n end\n\n test \"read with eof and UTF-8 and binary\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__), [:utf8])\n assert \"Русский\\n日\\n\" == IO.read(file, :eof)\n assert :eof == IO.read(file, :eof)\n assert File.close(file) == :ok\n end\n\n test \"readline\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/file.txt\", __DIR__))\n assert \"FOO\\n\" == IO.read(file, :line)\n assert :eof == IO.read(file, :line)\n assert File.close(file) == :ok\n end\n\n test \"readline with UTF-8 and binary\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__), [:utf8])\n assert \"Русский\\n\" == IO.read(file, :line)\n assert \"日\\n\" == IO.read(file, :line)\n assert File.close(file) == :ok\n end\n\n test \"binread with eof\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__))\n assert \"Русский\\n日\\n\" == IO.binread(file, :eof)\n assert :eof == IO.binread(file, :eof)\n assert File.close(file) == :ok\n end\n\n test \"binread with line\" do\n {:ok, file} = File.open(Path.expand(~c\"fixtures/utf8.txt\", __DIR__))\n assert \"Русский\\n\" == IO.binread(file, :line)\n assert \"日\\n\" == IO.binread(file, :line)\n assert File.close(file) == :ok\n end\n\n test \"puts with chardata\" do\n assert capture_io(fn -> IO.puts(\"hello\") end) == \"hello\\n\"\n assert capture_io(fn -> IO.puts(~c\"hello\") end) == \"hello\\n\"\n assert capture_io(fn -> IO.puts(:hello) end) == \"hello\\n\"\n assert capture_io(fn -> IO.puts(13) end) == \"13\\n\"\n end\n\n describe \"warn\" do\n test \"with chardata\" do\n capture_io(:stderr, fn -> IO.warn(\"hello\") end)\n |> assert_emits([\"hello\", \"(ex_unit #{System.version()}) lib/ex_unit\"])\n\n capture_io(:stderr, fn -> IO.warn(~c\"hello\") end)\n |> assert_emits([\"hello\", \"(ex_unit #{System.version()}) lib/ex_unit\"])\n\n capture_io(:stderr, fn -> IO.warn(:hello) end)\n |> assert_emits([\"hello\", \"(ex_unit #{System.version()}) lib/ex_unit\"])\n\n capture_io(:stderr, fn -> IO.warn(13) end)\n |> assert_emits([\"13\", \"(ex_unit #{System.version()}) lib/ex_unit\"])\n end\n\n test \"no stacktrace\" do\n assert capture_io(:stderr, fn -> IO.warn(\"hello\", []) end) =~ \"hello\\n\"\n end\n\n test \"with stacktrace\" do\n stacktrace = [{IEx.Evaluator, :eval, 4, [file: ~c\"lib/iex/evaluator.ex\", line: 108]}]\n\n output = capture_io(:stderr, fn -> IO.warn(\"hello\", stacktrace) end)\n\n assert output =~ \"hello\"\n assert output =~ \"lib/iex/evaluator.ex:108: IEx.Evaluator.eval/4\"\n end\n\n test \"with env\" do\n output = capture_io(:stderr, fn -> IO.warn(\"hello\", __ENV__) end)\n\n assert output =~ \"hello\"\n\n assert output =~\n ~r\"(lib/elixir/)?test/elixir/io_test.exs:#{__ENV__.line - 5}: IOTest.\\\"test warn with env\\\"/1\"\n end\n\n test \"with options\" do\n capture_io(:stderr, fn ->\n IO.warn(\"hello\", line: 13, file: \"lib/foo.ex\", module: Foo, function: {:bar, 1})\n end)\n |> assert_emits([\"hello\", \"lib/foo.ex:13: Foo.bar/1\"])\n\n capture_io(:stderr, fn ->\n IO.warn(\"hello\", file: \"lib/foo.ex\", module: Foo, function: {:bar, 1})\n end)\n |> assert_emits([\"hello\", \"lib/foo.ex: Foo.bar/1\"])\n\n capture_io(:stderr, fn -> IO.warn(\"hello\", file: \"lib/foo.ex\", module: Foo) end)\n |> assert_emits([\"hello\", \"lib/foo.ex: Foo (module)\"])\n\n capture_io(:stderr, fn -> IO.warn(\"hello\", file: \"lib/foo.ex\") end)\n |> assert_emits([\"hello\", \"lib/foo.ex: (file)\"])\n\n capture_io(:stderr, fn ->\n IO.warn(\"hello\", file: \"lib/foo.ex\", function: {:bar, 1})\n end)\n |> assert_emits([\"hello\", \"lib/foo.ex: (file)\"])\n\n assert capture_io(:stderr, fn ->\n IO.warn(\"hello\", line: 13, module: Foo, function: {:bar, 1})\n end) =~ \"hello\"\n end\n end\n\n test \"write with chardata\" do\n assert capture_io(fn -> IO.write(\"hello\") end) == \"hello\"\n assert capture_io(fn -> IO.write(~c\"hello\") end) == \"hello\"\n assert capture_io(fn -> IO.write(:hello) end) == \"hello\"\n assert capture_io(fn -> IO.write(13) end) == \"13\"\n end\n\n test \"gets with chardata\" do\n assert capture_io(\"foo\\n\", fn -> IO.gets(\"hello\") end) == \"hello\"\n assert capture_io(\"foo\\n\", fn -> IO.gets(~c\"hello\") end) == \"hello\"\n assert capture_io(\"foo\\n\", fn -> IO.gets(:hello) end) == \"hello\"\n assert capture_io(\"foo\\n\", fn -> IO.gets(13) end) == \"13\"\n end\n\n test \"getn with chardata\" do\n assert capture_io(\"foo\\n\", fn -> IO.getn(\"hello\", 3) end) == \"hello\"\n assert capture_io(\"foo\\n\", fn -> IO.getn(~c\"hello\", 3) end) == \"hello\"\n assert capture_io(\"foo\\n\", fn -> IO.getn(:hello, 3) end) == \"hello\"\n assert capture_io(\"foo\\n\", fn -> IO.getn(13, 3) end) == \"13\"\n end\n\n test \"getn with different arities\" do\n assert capture_io(\"hello\", fn ->\n input = IO.getn(\">\")\n IO.write(input)\n end) == \">h\"\n\n assert capture_io(\"hello\", fn ->\n input = IO.getn(\">\", 3)\n IO.write(input)\n end) == \">hel\"\n\n assert capture_io(\"hello\", fn ->\n input = IO.getn(Process.group_leader(), \">\")\n IO.write(input)\n end) == \">h\"\n\n assert capture_io(\"hello\", fn ->\n input = IO.getn(Process.group_leader(), \">\")\n IO.write(input)\n end) == \">h\"\n\n assert capture_io(\"hello\", fn ->\n input = IO.getn(Process.group_leader(), \">\", 99)\n IO.write(input)\n end) == \">hello\"\n end\n\n test \"inspect\" do\n assert capture_io(fn -> IO.inspect(1) end) == \"1\\n\"\n assert capture_io(fn -> IO.inspect(1, label: \"foo\") end) == \"foo: 1\\n\"\n assert capture_io(fn -> IO.inspect(1, label: :foo) end) == \"foo: 1\\n\"\n end\n\n test \"stream\" do\n assert IO.stream() == IO.stream(:stdio, :line)\n assert IO.binstream() == IO.binstream(:stdio, :line)\n end\n\n test \"iodata_empty?\" do\n assert IO.iodata_empty?([])\n assert IO.iodata_empty?(\"\")\n assert IO.iodata_empty?([[\"\", []] | \"\"])\n\n refute IO.iodata_empty?([1])\n refute IO.iodata_empty?(\"1\")\n refute IO.iodata_empty?([[\"\", []] | \"ok\"])\n end\n\n defp assert_emits(output, messages) do\n for m <- messages do\n assert output =~ m\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/json_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule JSONTest do\n use ExUnit.Case, async: true\n\n defmodule Token do\n defstruct [:value]\n\n defimpl JSON.Encoder do\n def encode(token, encoder) do\n [?[, encoder.(token.value, encoder), ?]]\n end\n end\n end\n\n doctest JSON\n\n describe \"encode\" do\n test \"atoms\" do\n assert JSON.encode!([nil, false, true, :another]) == \"[null,false,true,\\\"another\\\"]\"\n end\n\n test \"binaries\" do\n assert JSON.encode!(\"hello\\0world\\t✂️\") == \"\\\"hello\\\\u0000world\\\\t✂️\\\"\"\n end\n\n test \"integers\" do\n assert JSON.encode!(123_456) == \"123456\"\n end\n\n test \"floats\" do\n assert JSON.encode!(123.456) == \"123.456\"\n end\n\n test \"maps\" do\n assert JSON.encode!(%{1 => 2, 3.0 => 4.0, ~c\"list\" => ~c\"list\", key: :bar}) ==\n \"{\\\"1\\\":2,\\\"3.0\\\":4.0,\\\"key\\\":\\\"bar\\\",\\\"list\\\":[108,105,115,116]}\"\n end\n\n test \"lists\" do\n assert JSON.encode!([1, 1.0, \"one\", %{1 => 2, 3.0 => 4.0, key: :bar}]) ==\n \"[1,1.0,\\\"one\\\",{\\\"1\\\":2,\\\"3.0\\\":4.0,\\\"key\\\":\\\"bar\\\"}]\"\n end\n\n test \"structs\" do\n assert JSON.encode!(%Token{value: :example}) == \"[\\\"example\\\"]\"\n assert JSON.encode!(%Token{value: \"hello\\0world\"}) == \"[\\\"hello\\\\u0000world\\\"]\"\n end\n\n test \"calendar\" do\n assert JSON.encode!(~D[2010-04-17]) == \"\\\"2010-04-17\\\"\"\n assert JSON.encode!(~T[14:00:00.123]) == \"\\\"14:00:00.123\\\"\"\n assert JSON.encode!(~N[2010-04-17 14:00:00.123]) == \"\\\"2010-04-17T14:00:00.123\\\"\"\n assert JSON.encode!(~U[2010-04-17 14:00:00.123Z]) == \"\\\"2010-04-17T14:00:00.123Z\\\"\"\n assert JSON.encode!(Duration.new!(month: 2, hour: 3)) == \"\\\"P2MT3H\\\"\"\n end\n end\n\n describe \"JSON.Encoder\" do\n defp protocol_encode(term) do\n term\n |> JSON.Encoder.encode(&JSON.protocol_encode/2)\n |> IO.iodata_to_binary()\n end\n\n test \"atoms\" do\n assert protocol_encode(:another) == \"\\\"another\\\"\"\n assert protocol_encode([nil, false, true, :another]) == \"[null,false,true,\\\"another\\\"]\"\n end\n\n test \"binaries\" do\n assert protocol_encode(\"hello\\0world\\t✂️\") == \"\\\"hello\\\\u0000world\\\\t✂️\\\"\"\n end\n\n test \"integers\" do\n assert protocol_encode(123_456) == \"123456\"\n end\n\n test \"floats\" do\n assert protocol_encode(123.456) == \"123.456\"\n end\n\n test \"maps\" do\n assert protocol_encode(%{1 => 2, 3.0 => 4.0, ~c\"list\" => ~c\"list\", key: :bar}) ==\n \"{\\\"1\\\":2,\\\"3.0\\\":4.0,\\\"key\\\":\\\"bar\\\",\\\"list\\\":[108,105,115,116]}\"\n end\n\n test \"lists\" do\n assert protocol_encode([1, 1.0, \"one\", %{1 => 2, 3.0 => 4.0, key: :bar}]) ==\n \"[1,1.0,\\\"one\\\",{\\\"1\\\":2,\\\"3.0\\\":4.0,\\\"key\\\":\\\"bar\\\"}]\"\n end\n\n test \"structs\" do\n assert protocol_encode(%Token{value: :example}) == \"[\\\"example\\\"]\"\n assert protocol_encode(%Token{value: \"hello\\0world\"}) == \"[\\\"hello\\\\u0000world\\\"]\"\n end\n end\n\n test \"encode_to_iodata\" do\n list = JSON.encode_to_iodata!([1, 1.0, \"one\", %{1 => 2, 3.0 => 4.0, key: :bar}])\n assert is_list(list)\n assert IO.iodata_to_binary(list) == \"[1,1.0,\\\"one\\\",{\\\"1\\\":2,\\\"3.0\\\":4.0,\\\"key\\\":\\\"bar\\\"}]\"\n\n list =\n JSON.encode_to_iodata!([\n ~T[12:34:56.78],\n ~D[2024-12-31],\n ~N[2010-04-17 14:00:00.123],\n ~U[2010-04-17 14:00:00.123Z],\n Duration.new!(month: 2, hour: 3)\n ])\n\n assert IO.iodata_to_binary(list) ==\n ~s'[\"12:34:56.78\",\"2024-12-31\",\"2010-04-17T14:00:00.123\",\"2010-04-17T14:00:00.123Z\",\"P2MT3H\"]'\n end\n\n test \"deprecated\" do\n assert JSON.encode!([:hello, \"world\"]) == \"[\\\"hello\\\",\\\"world\\\"]\"\n\n list = JSON.encode_to_iodata!([:hello, \"world\"])\n assert is_list(list)\n assert IO.iodata_to_binary(list) == \"[\\\"hello\\\",\\\"world\\\"]\"\n end\n\n describe \"deriving\" do\n defmodule WithOnly do\n @derive {JSON.Encoder, only: [:a, :b, :d]}\n # The encoded order depends on only\n defstruct Enum.shuffle([:a, :b, :c, :d])\n end\n\n test \"with only\" do\n assert [\"{\\\"a\\\":\", _, \",\\\"b\\\":\", _, \",\\\"d\\\":\", _, 125] =\n json = JSON.encode_to_iodata!(%WithOnly{a: :a, b: \"b\", c: make_ref(), d: [?d]})\n\n assert IO.iodata_to_binary(json) == \"{\\\"a\\\":\\\"a\\\",\\\"b\\\":\\\"b\\\",\\\"d\\\":[100]}\"\n end\n\n defmodule WithExcept do\n @derive {JSON.Encoder, except: [:c]}\n defstruct [:a, :b, :c, :d]\n end\n\n test \"with except\" do\n assert [\"{\\\"a\\\":\", _, \",\\\"b\\\":\", _, \",\\\"d\\\":\", _, 125] =\n json = JSON.encode_to_iodata!(%WithExcept{a: :a, b: \"b\", c: make_ref(), d: [?d]})\n\n assert IO.iodata_to_binary(json) == \"{\\\"a\\\":\\\"a\\\",\\\"b\\\":\\\"b\\\",\\\"d\\\":[100]}\"\n end\n\n defmodule WithEmpty do\n @derive {JSON.Encoder, only: []}\n defstruct [:a, :b]\n end\n\n test \"with empty\" do\n assert JSON.encode_to_iodata!(%WithEmpty{}) == \"{}\"\n end\n end\n\n describe \"decode\" do\n test \"succeeds\" do\n assert JSON.decode(\"[null,123,456.7,\\\"string\\\",{\\\"key\\\":\\\"value\\\"}]\") ==\n {:ok, [nil, 123, 456.7, \"string\", %{\"key\" => \"value\"}]}\n\n assert JSON.decode!(\"[null,123,456.7,\\\"string\\\",{\\\"key\\\":\\\"value\\\"}]\") ==\n [nil, 123, 456.7, \"string\", %{\"key\" => \"value\"}]\n end\n\n test \"unexpected end\" do\n assert JSON.decode(\"{\") == {:error, {:unexpected_end, 1}}\n\n assert_raise JSON.DecodeError,\n \"unexpected end of JSON binary at position (byte offset) 1\",\n fn -> JSON.decode!(\"{\") end\n end\n\n test \"invalid byte\" do\n assert JSON.decode(\",\") == {:error, {:invalid_byte, 0, ?,}}\n assert JSON.decode(\"123o\") == {:error, {:invalid_byte, 3, ?o}}\n\n assert_raise JSON.DecodeError,\n \"invalid byte 111 at position (byte offset) 3\",\n fn -> JSON.decode!(\"123o\") end\n end\n\n test \"unexpected sequence\" do\n assert JSON.decode(\"\\\"\\\\ud8aa\\\\udcxx\\\"\") ==\n {:error, {:unexpected_sequence, 1, \"\\\\ud8aa\\\\udcxx\"}}\n\n assert_raise JSON.DecodeError,\n \"unexpected sequence \\\"\\\\\\\\ud8aa\\\\\\\\udcxx\\\" at position (byte offset) 1\",\n fn -> JSON.decode!(\"\\\"\\\\ud8aa\\\\udcxx\\\"\") end\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/alias_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\nalias Kernel.AliasTest.Nested, as: Nested\n\ndefmodule Nested do\n def value, do: 1\nend\n\ndefmodule Kernel.AliasTest do\n use ExUnit.Case, async: true\n\n test \"alias Erlang\" do\n alias :lists, as: MyList\n assert MyList.flatten([1, [2], 3]) == [1, 2, 3]\n assert Elixir.MyList.Bar == :\"Elixir.MyList.Bar\"\n assert MyList.Bar == :\"Elixir.lists.Bar\"\n end\n\n test \"double alias\" do\n alias Kernel.AliasTest.Nested, as: Nested2\n assert Nested.value() == 1\n assert Nested2.value() == 1\n end\n\n test \"overwritten alias\" do\n assert alias(List, as: Nested) == List\n assert Nested.flatten([[13]]) == [13]\n end\n\n test \"non-recursive alias\" do\n alias Billing, as: BillingLib\n alias MyApp.Billing\n assert BillingLib == :\"Elixir.Billing\"\n assert Billing == :\"Elixir.MyApp.Billing\"\n end\n\n test \"lexical\" do\n if Process.get(:unused, true) do\n alias OMG, as: List, warn: false\n else\n alias ABC, as: List, warn: false\n end\n\n assert List.flatten([1, [2], 3]) == [1, 2, 3]\n end\n\n defmodule Elixir do\n def sample, do: 1\n end\n\n test \"nested Elixir alias\" do\n assert Kernel.AliasTest.Elixir.sample() == 1\n end\n\n test \"multi-call\" do\n result = alias unquote(Inspect).{Opts, Algebra}\n assert result == [Inspect.Opts, Inspect.Algebra]\n assert %Opts{} == %Inspect.Opts{}\n assert Algebra.empty() == []\n end\n\n test \"alias removal\" do\n alias __MODULE__.Foo\n assert Foo == __MODULE__.Foo\n alias Elixir.Foo\n assert Foo == Elixir.Foo\n alias Elixir.Bar\n end\nend\n\ndefmodule Kernel.AliasNestingGenerator do\n defmacro create do\n quote do\n defmodule Parent do\n def a, do: :a\n end\n\n defmodule Parent.Child do\n def b, do: Parent.a()\n end\n end\n end\nend\n\ndefmodule Kernel.AliasNestingTest do\n use ExUnit.Case, async: true\n\n test \"aliases nesting\" do\n require Kernel.AliasNestingGenerator\n Kernel.AliasNestingGenerator.create()\n\n assert Parent.a() == :a\n assert Parent.Child.b() == :a\n end\n\n defmodule Nested do\n def value, do: 2\n end\n\n test \"aliases nesting with previous alias\" do\n assert Nested.value() == 2\n end\n\n alias Another.AliasEnv, warn: false\n def aliases_before, do: __ENV__.aliases\n\n defmodule Elixir.AliasEnv do\n def aliases_nested, do: __ENV__.aliases\n end\n\n def aliases_after, do: __ENV__.aliases\n\n test \"keeps env after overriding nested Elixir module of the same name\" do\n assert aliases_before() == [\n {Elixir.Nested, Kernel.AliasNestingTest.Nested},\n {Elixir.AliasEnv, Another.AliasEnv}\n ]\n\n assert Elixir.AliasEnv.aliases_nested() == [\n {Elixir.Nested, Kernel.AliasNestingTest.Nested},\n {Elixir.AliasEnv, Another.AliasEnv}\n ]\n\n assert aliases_after() == [\n {Elixir.Nested, Kernel.AliasNestingTest.Nested},\n {Elixir.AliasEnv, Another.AliasEnv}\n ]\n end\nend\n\n# Test case extracted from using records with aliases\n# and @before_compile. We are basically testing that\n# macro aliases are not leaking from the macro.\n\ndefmodule Macro.AliasTest.Definer do\n defmacro __using__(_options) do\n quote do\n @before_compile unquote(__MODULE__)\n end\n end\n\n defmacro __before_compile__(_env) do\n quote do\n defmodule First do\n defstruct foo: :bar\n end\n\n defmodule Second do\n defstruct baz: %First{}\n end\n end\n end\nend\n\ndefmodule Macro.AliasTest.Aliaser do\n defmacro __using__(_options) do\n quote do\n alias Some.First\n end\n end\nend\n\ndefmodule Macro.AliasTest.User do\n use ExUnit.Case, async: true\n\n use Macro.AliasTest.Definer\n use Macro.AliasTest.Aliaser\n\n test \"has a struct defined from after compile\" do\n assert is_map(struct(Macro.AliasTest.User.First, []))\n assert is_map(struct(Macro.AliasTest.User.Second, []).baz)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/binary_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.BinaryTest do\n use ExUnit.Case, async: true\n\n test \"heredoc\" do\n assert 11 == __ENV__.line\n\n assert \"foo\\nbar\\n\" == \"\"\"\n foo\n bar\n \"\"\"\n\n assert 18 == __ENV__.line\n\n assert \"foo\\nbar \\\"\\\"\\\"\\n\" == \"\"\"\n foo\n bar \\\"\"\"\n \"\"\"\n end\n\n test \"aligned heredoc\" do\n assert \"foo\\nbar\\n\" == \"\"\"\n foo\n bar\n \"\"\"\n end\n\n test \"heredoc with interpolation\" do\n assert \"35\\n\" == \"\"\"\n #{__ENV__.line}\n \"\"\"\n\n assert \"\\n40\\n\" == \"\"\"\n\n #{__ENV__.line}\n \"\"\"\n end\n\n test \"heredoc in call\" do\n assert \"foo\\nbar\" ==\n Kernel.<>(\n \"\"\"\n foo\n \"\"\",\n \"bar\"\n )\n end\n\n test \"heredoc with heredoc inside interpolation\" do\n assert \"\"\"\n 1\n #{\"\"\"\n 2\n \"\"\"}\n \"\"\" == \"1\\n2\\n\\n\"\n end\n\n test \"UTF-8\" do\n assert byte_size(\" ゆんゆん\") == 13\n end\n\n test \"UTF-8 char\" do\n assert ?ゆ == 12422\n end\n\n test \"size outside match\" do\n x = 16\n assert <<0::size(x)>> == <<0, 0>>\n end\n\n test \"string concatenation as match\" do\n \"foo\" <> x = \"foobar\"\n assert x == \"bar\"\n\n <<\"foo\">> <> x = \"foobar\"\n assert x == \"bar\"\n\n <<\"f\", \"oo\">> <> x = \"foobar\"\n assert x == \"bar\"\n\n <> <> _ = \"foobar\"\n assert x == \"foo\"\n\n size = 3\n <> <> _ = \"foobar\"\n assert x == \"foo\"\n\n size = 3\n <> <> _ = <<10, \"foobar\">>\n assert x == \"foo\"\n assert size == 10\n\n <> <> _ = \"foobar\"\n assert x == \"foo\"\n\n <> <> _ = \"foobar\"\n assert x == \"foo\"\n\n <> <> _ = \"foobar\"\n assert x == \"foo\"\n\n <> <> _ = \"foobar\"\n assert x == ?f\n end\n\n test \"string concatenation outside match\" do\n x = \"bar\"\n assert \"foobar\" = \"foo\" <> x\n assert \"barfoo\" = x <> \"foo\"\n end\n\n test \"invalid string concatenation arguments\" do\n assert_raise ArgumentError, ~r\"expected binary argument in <> operator but got: :bar\", fn ->\n Code.eval_string(~s[\"foo\" <> :bar])\n end\n\n assert_raise ArgumentError, ~r\"expected binary argument in <> operator but got: 1\", fn ->\n Code.eval_string(~s[\"foo\" <> 1])\n end\n\n message = ~r\"cannot perform prefix match because the left operand of <> has unknown size.\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(~s[a <> \"b\" = \"ab\"])\n end\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(~s[\"a\" <> b <> \"c\" = \"abc\"])\n end\n end\n\n test \"hex\" do\n assert \"\\x76\" == \"v\"\n assert \"\\u00FF\" == \"ÿ\"\n assert \"\\u{A}\" == \"\\n\"\n assert \"\\u{E9}\" == \"é\"\n assert \"\\u{10F}\" == <<196, 143>>\n assert \"\\u{10FF}\" == <<225, 131, 191>>\n assert \"\\u{10FFF}\" == <<240, 144, 191, 191>>\n assert \"\\u{10FFFF}\" == <<244, 143, 191, 191>>\n end\n\n test \"match\" do\n assert match?(<>, \"ab\")\n refute match?(<>, \"cd\")\n assert match?(<<_::utf8>> <> _, \"éf\")\n end\n\n test \"interpolation\" do\n res = \"hello \\\\abc\"\n assert \"hello #{\"\\\\abc\"}\" == res\n assert \"hello #{\"\\\\abc\" <> \"\"}\" == res\n end\n\n test \"pattern match\" do\n s = 16\n assert <<_a, _b::size(^s)>> = \"foo\"\n end\n\n test \"pattern match with splice\" do\n assert <<1, <<2, 3, 4>>, 5>> = <<1, 2, 3, 4, 5>>\n end\n\n test \"partial application\" do\n assert (&<<&1, 2>>).(1) == <<1, 2>>\n assert (&<<&1, &2>>).(1, 2) == <<1, 2>>\n assert (&<<&2, &1>>).(2, 1) == <<1, 2>>\n end\n\n test \"literal\" do\n assert <<106, 111, 115, 195, 169>> == <<\"josé\">>\n assert <<106, 111, 115, 195, 169>> == <<\"#{:josé}\">>\n assert <<106, 111, 115, 195, 169>> == <<\"josé\"::binary>>\n assert <<106, 111, 115, 195, 169>> == <<\"josé\"::bits>>\n assert <<106, 111, 115, 195, 169>> == <<\"josé\"::bitstring>>\n assert <<106, 111, 115, 195, 169>> == <<\"josé\"::bytes>>\n\n assert <<106, 111, 115, 195, 169>> == <<\"josé\"::utf8>>\n assert <<0, 106, 0, 111, 0, 115, 0, 233>> == <<\"josé\"::utf16>>\n assert <<106, 0, 111, 0, 115, 0, 233, 0>> == <<\"josé\"::little-utf16>>\n assert <<0, 0, 0, 106, 0, 0, 0, 111, 0, 0, 0, 115, 0, 0, 0, 233>> == <<\"josé\"::utf32>>\n end\n\n test \"literal errors\" do\n message = \"conflicting type specification for bit field\"\n\n assert_compile_error(message, fn ->\n Code.eval_string(~s[<<\"foo\"::integer>>])\n end)\n\n assert_compile_error(message, fn ->\n Code.eval_string(~s[<<\"foo\"::float>>])\n end)\n end\n\n @bitstring <<\"foo\", 16::4>>\n\n test \"bitstring attribute\" do\n assert @bitstring == <<\"foo\", 16::4>>\n end\n\n @binary \"new \"\n\n test \"bitsyntax expansion\" do\n assert <<@binary, \"world\">> == \"new world\"\n end\n\n test \"bitsyntax translation\" do\n refb = \"sample\"\n sec_data = \"another\"\n\n <<\n byte_size(refb)::size(1)-big-signed-integer-unit(8),\n refb::binary,\n byte_size(sec_data)::1*16-big-signed-integer,\n sec_data::binary\n >>\n end\n\n test \"bitsyntax size shortcut\" do\n assert <<1::3>> == <<1::size(3)>>\n assert <<1::3*8>> == <<1::size(3)-unit(8)>>\n end\n\n test \"bitsyntax variable size\" do\n x = 8\n assert <<_, _::size(^x)>> = <>\n assert (fn <<_, _::size(^x)>> -> true end).(<>)\n end\n\n test \"bitsyntax size using expressions\" do\n x = 8\n assert <<1::size(x - 5)>>\n\n foo = %{bar: 5}\n assert <<1::size(foo.bar)>>\n assert <<1::size(length(~c\"abcd\"))>>\n assert <<255::size(hd(List.flatten([3])))>>\n end\n\n test \"bitsyntax size using guard expressions in match context\" do\n x = 8\n assert <<1::size(^x - 5)>> = <<1::3>>\n assert <<1::size(^x - 5)-unit(8)>> = <<1::3*8>>\n assert <<1::size(length(~c\"abcd\"))>> = <<1::4>>\n\n foo = %{bar: 5}\n assert <<1::size((^foo).bar)>> = <<1::5>>\n end\n\n test \"bitsyntax size with pinned integer\" do\n a = 1\n b = <<2, 3>>\n assert <<^a, ^b::binary>> = <<1, 2, 3>>\n end\n\n test \"automatic size computation of matched bitsyntax variable\" do\n var = \"foo\"\n <<^var::binary, rest::binary>> = \"foobar\"\n assert rest == \"bar\"\n\n <<^var::bytes, rest::bytes>> = \"foobar\"\n assert rest == \"bar\"\n\n ^var <> rest = \"foobar\"\n assert rest == \"bar\"\n\n var = <<0, 1>>\n <<^var::bitstring, rest::bitstring>> = <<0, 1, 2, 3>>\n assert rest == <<2, 3>>\n\n <<^var::bits, rest::bits>> = <<0, 1, 2, 3>>\n assert rest == <<2, 3>>\n\n ^var <> rest = <<0, 1, 2, 3>>\n assert rest == <<2, 3>>\n end\n\n defmacro signed_16 do\n quote do\n big - signed - integer - unit(16)\n end\n end\n\n defmacro refb_spec do\n quote do\n 1 * 8 - big - signed - integer\n end\n end\n\n test \"bitsyntax macro\" do\n refb = \"sample\"\n sec_data = \"another\"\n\n <<\n byte_size(refb)::refb_spec(),\n refb::binary,\n byte_size(sec_data)::size(1)-signed_16(),\n sec_data::binary\n >>\n end\n\n test \"bitsyntax macro is expanded with a warning\" do\n assert capture_err(fn ->\n Code.eval_string(\"<<1::refb_spec>>\", [], __ENV__)\n end) =~\n \"bitstring specifier \\\"refb_spec\\\" does not exist and is being expanded to \\\"refb_spec()\\\"\"\n\n assert capture_err(fn ->\n Code.eval_string(\"<<1::size(1)-signed_16>>\", [], __ENV__)\n end) =~\n \"bitstring specifier \\\"signed_16\\\" does not exist and is being expanded to \\\"signed_16()\\\"\"\n end\n\n test \"bitsyntax with extra parentheses warns\" do\n assert capture_err(fn ->\n Code.eval_string(\"<<1::big()>>\")\n end) =~ \"extra parentheses on a bitstring specifier \\\"big()\\\" have been deprecated\"\n\n assert capture_err(fn ->\n Code.eval_string(\"<<1::size(8)-integer()>>\")\n end) =~ \"extra parentheses on a bitstring specifier \\\"integer()\\\" have been deprecated\"\n end\n\n defp capture_err(fun) do\n ExUnit.CaptureIO.capture_io(:stderr, fun)\n end\n\n defp assert_compile_error(message, fun) do\n assert capture_err(fn -> assert_raise CompileError, fun end) =~ message\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/charlist_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule CharlistTest do\n use ExUnit.Case, async: true\n\n test \"heredoc\" do\n assert __ENV__.line == 11\n\n assert ~c\"foo\\nbar\\n\" == ~c\"\"\"\n foo\n bar\n \"\"\"\n\n assert __ENV__.line == 18\n\n assert ~c\"foo\\nbar '''\\n\" == ~c\"\"\"\n foo\n bar \\'\\'\\'\n \"\"\"\n end\n\n test \"UTF-8\" do\n assert length(~c\" ゆんゆん\") == 5\n end\n\n test \"hex\" do\n assert ~c\"\\x76\" == ~c\"v\"\n assert ~c\"\\u00fF\" == ~c\"ÿ\"\n assert ~c\"\\u{A}\" == ~c\"\\n\"\n assert ~c\"\\u{e9}\" == ~c\"é\"\n assert ~c\"\\u{10F}\" == [271]\n assert ~c\"\\u{10FF}\" == [4351]\n assert ~c\"\\u{10FFF}\" == [69631]\n assert ~c\"\\u{10FFFF}\" == [1_114_111]\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/cli_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\nimport PathHelpers\n\ndefmodule Retry do\n # Tests that write to stderr fail on Windows due to late writes,\n # so we do a simple retry already them.\n defmacro stderr_test(msg, context \\\\ quote(do: _), do: block) do\n if windows?() do\n quote do\n test unquote(msg), unquote(context) do\n unquote(__MODULE__).retry(fn -> unquote(block) end, 3)\n end\n end\n else\n quote do\n test(unquote(msg), unquote(context), do: unquote(block))\n end\n end\n end\n\n def retry(fun, 1) do\n fun.()\n end\n\n def retry(fun, n) do\n try do\n fun.()\n rescue\n _ -> retry(fun, n - 1)\n end\n end\nend\n\ndefmodule Kernel.CLITest do\n use ExUnit.Case, async: true\n\n import ExUnit.CaptureIO\n\n defp run(argv) do\n {config, argv} = Kernel.CLI.parse_argv(Enum.map(argv, &String.to_charlist/1))\n assert Kernel.CLI.process_commands(config) == []\n Enum.map(argv, &IO.chardata_to_string/1)\n end\n\n test \"argv handling\" do\n assert capture_io(fn ->\n assert run([\"-e\", \"IO.puts :ok\", \"sample.exs\", \"-o\", \"1\", \"2\"]) ==\n [\"sample.exs\", \"-o\", \"1\", \"2\"]\n end) == \"ok\\n\"\n\n assert capture_io(fn ->\n assert run([\"-e\", \"IO.puts :ok\", \"--\", \"sample.exs\", \"-o\", \"1\", \"2\"]) ==\n [\"sample.exs\", \"-o\", \"1\", \"2\"]\n end) == \"ok\\n\"\n\n assert capture_io(fn ->\n assert run([\"-e\", \"\", \"--\", \"sample.exs\", \"-o\", \"1\", \"2\"]) ==\n [\"sample.exs\", \"-o\", \"1\", \"2\"]\n end)\n end\nend\n\ntest_parameters =\n if(PathHelpers.windows?(),\n do: [%{cli_extension: \".bat\"}],\n else: [%{cli_extension: \"\"}]\n )\n\ndefmodule Kernel.CLI.ExecutableTest do\n use ExUnit.Case,\n async: true,\n parameterize: test_parameters\n\n import Retry\n\n @tag :tmp_dir\n test \"file smoke test\", context do\n file = Path.join(context.tmp_dir, \"hello_world!.exs\")\n File.write!(file, \"IO.puts :hello_world123\")\n {output, 0} = System.cmd(elixir_executable(context.cli_extension), [file])\n assert output =~ \"hello_world123\"\n end\n\n test \"--eval smoke test\", context do\n {output, 0} =\n System.cmd(elixir_executable(context.cli_extension), [\"--eval\", \"IO.puts :hello_world123\"])\n\n assert output =~ \"hello_world123\"\n\n # Check for -e and exclamation mark handling on Windows\n assert {_output, 0} =\n System.cmd(elixir_executable(context.cli_extension), [\"-e\", \"Time.new!(0, 0, 0)\"])\n end\n\n @tag :unix\n # This test hangs on Windows but \"iex --version\" works on the command line\n test \"iex smoke test\", %{cli_extension: cli_extension} do\n output = iex(~c\"--version\", cli_extension)\n assert output =~ \"Erlang/OTP #{System.otp_release()}\"\n assert output =~ \"IEx #{System.version()}\"\n end\n\n test \"--version smoke test\", %{cli_extension: cli_extension} do\n output = elixir(~c\"--version\", cli_extension)\n assert output =~ \"Erlang/OTP #{System.otp_release()}\"\n assert output =~ \"Elixir #{System.version()}\"\n\n output = elixir(~c\"--version -e \\\"IO.puts(:test_output)\\\"\", cli_extension)\n assert output =~ \"Erlang/OTP #{System.otp_release()}\"\n assert output =~ \"Elixir #{System.version()}\"\n assert output =~ \"Standalone options can't be combined with other options\"\n end\n\n test \"--short-version smoke test\", %{cli_extension: cli_extension} do\n output = elixir(~c\"--short-version\", cli_extension)\n assert output =~ System.version()\n refute output =~ \"Erlang\"\n end\n\n stderr_test \"--help smoke test\", %{cli_extension: cli_extension} do\n output = elixir(~c\"--help\", cli_extension)\n assert output =~ \"Usage: elixir\"\n end\n\n stderr_test \"combining --help results in error\", %{cli_extension: cli_extension} do\n output = elixir(~c\"-e 1 --help\", cli_extension)\n assert output =~ \"--help : Standalone options can't be combined with other options\"\n\n output = elixir(~c\"--help -e 1\", cli_extension)\n assert output =~ \"--help : Standalone options can't be combined with other options\"\n end\n\n stderr_test \"combining --short-version results in error\", %{cli_extension: cli_extension} do\n output = elixir(~c\"--short-version -e 1\", cli_extension)\n assert output =~ \"--short-version : Standalone options can't be combined with other options\"\n\n output = elixir(~c\"-e 1 --short-version\", cli_extension)\n assert output =~ \"--short-version : Standalone options can't be combined with other options\"\n end\n\n test \"parses paths\", %{cli_extension: cli_extension} do\n root = fixture_path(\"../../..\") |> to_charlist()\n\n args =\n ~c\"-pa \\\"#{root}/*\\\" -pz \\\"#{root}/lib/*\\\" -e \\\"IO.inspect(:code.get_path(), limit: :infinity)\\\"\"\n\n list = elixir(args, cli_extension)\n {path, _} = Code.eval_string(list, [])\n\n # pa\n assert to_charlist(Path.expand(~c\"ebin\", root)) in path\n assert to_charlist(Path.expand(~c\"lib\", root)) in path\n assert to_charlist(Path.expand(~c\"src\", root)) in path\n\n # pz\n assert to_charlist(Path.expand(~c\"lib/list\", root)) in path\n end\n\n stderr_test \"formats errors\", %{cli_extension: cli_extension} do\n assert String.starts_with?(elixir(~c\"-e \\\":erlang.throw 1\\\"\", cli_extension), \"** (throw) 1\")\n\n assert String.starts_with?(\n elixir(~c\"-e \\\":erlang.error 1\\\"\", cli_extension),\n \"** (ErlangError) Erlang error: 1\"\n )\n\n assert String.starts_with?(elixir(~c\"-e \\\"1 +\\\"\", cli_extension), \"** (TokenMissingError)\")\n\n assert elixir(\n ~c\"-e \\\"Task.async(fn -> raise ArgumentError end) |> Task.await\\\"\",\n cli_extension\n ) =~\n \"an exception was raised:\\n ** (ArgumentError) argument error\"\n\n assert elixir(\n ~c\"-e \\\"IO.puts(Process.flag(:trap_exit, false)); exit({:shutdown, 1})\\\"\",\n cli_extension\n ) ==\n \"false\\n\"\n end\n\n stderr_test \"blames exceptions\", %{cli_extension: cli_extension} do\n error = elixir(~c\"-e \\\"Access.fetch :foo, :bar\\\"\", cli_extension)\n assert error =~ \"** (FunctionClauseError) no function clause matching in Access.fetch/2\"\n assert error =~ \"The following arguments were given to Access.fetch/2\"\n assert error =~ \":foo\"\n assert error =~ \"def fetch(-%module{} = container-, +key+)\"\n assert error =~ ~r\"\\(elixir #{System.version()}\\) lib/access\\.ex:\\d+: Access\\.fetch/2\"\n end\n\n test \"invokes at_exit callbacks\" do\n assert elixir(fixture_path(\"at_exit.exs\") |> to_charlist()) ==\n \"goodbye cruel world with status 1\\n\"\n end\nend\n\ndefmodule Kernel.CLI.RPCTest do\n use ExUnit.Case, async: true\n\n import Retry\n\n defp rpc_eval(command) do\n node = \"cli-rpc#{System.unique_integer()}@127.0.0.1\"\n elixir(~c\"--name #{node} --rpc-eval #{node} \\\"#{command}\\\"\")\n end\n\n test \"invokes command on remote node\" do\n assert rpc_eval(\"IO.puts :ok\") == \"ok\\n\"\n end\n\n test \"invokes command on remote node without host and --name after --rpc-eval\" do\n node = \"cli-rpc#{System.unique_integer()}\"\n assert elixir(~c\"--rpc-eval #{node} \\\"IO.puts :ok\\\" --name #{node}@127.0.0.1 \") == \"ok\\n\"\n end\n\n test \"can be invoked multiple times\" do\n node = \"cli-rpc#{System.unique_integer()}\"\n\n assert elixir(\n ~c\"--name #{node}@127.0.0.1 --rpc-eval #{node} \\\"IO.puts :foo\\\" --rpc-eval #{node} \\\"IO.puts :bar\\\"\"\n ) == \"foo\\nbar\\n\"\n end\n\n # Windows does not provide an easy to check for missing args\n @tag :unix\n test \"fails on wrong arguments\" do\n node = \"cli-rpc#{System.unique_integer()}\"\n\n assert elixir(~c\"--name #{node}@127.0.0.1 --rpc-eval\") ==\n \"--rpc-eval : wrong number of arguments\\n\"\n\n assert elixir(~c\"--name #{node}@127.0.0.1 --rpc-eval #{node}\") ==\n \"--rpc-eval : wrong number of arguments\\n\"\n end\n\n stderr_test \"properly formats errors\" do\n assert String.starts_with?(rpc_eval(\":erlang.throw 1\"), \"** (throw) 1\")\n assert String.starts_with?(rpc_eval(\":erlang.error 1\"), \"** (ErlangError) Erlang error: 1\")\n assert String.starts_with?(rpc_eval(\"1 +\"), \"** (TokenMissingError)\")\n\n assert rpc_eval(\"Task.async(fn -> raise ArgumentError end) |> Task.await\") =~\n \"an exception was raised:\\n ** (ArgumentError) argument error\"\n\n assert rpc_eval(\"IO.puts(Process.flag(:trap_exit, false)); exit({:shutdown, 1})\") ==\n \"false\\n\"\n end\nend\n\ndefmodule Kernel.CLI.CompileTest do\n use ExUnit.Case,\n async: true,\n parameterize: test_parameters\n\n import Retry\n @moduletag :tmp_dir\n\n setup context do\n beam_file_path = Path.join([context.tmp_dir, \"Elixir.CompileSample.beam\"])\n fixture = fixture_path(\"compile_sample.ex\")\n {:ok, [beam_file_path: beam_file_path, fixture: fixture]}\n end\n\n test \"compiles code\", context do\n assert elixirc(~c\"#{context.fixture} -o #{context.tmp_dir}\", context.cli_extension) == \"\"\n assert File.regular?(context.beam_file_path)\n\n # Assert that the module is loaded into memory with the proper destination for the BEAM file.\n Code.append_path(context.tmp_dir)\n assert :code.which(CompileSample) |> List.to_string() == Path.expand(context.beam_file_path)\n after\n :code.purge(CompileSample)\n :code.delete(CompileSample)\n Code.delete_path(context.tmp_dir)\n end\n\n @tag :windows\n stderr_test \"compiles code with Windows paths\", context do\n try do\n fixture = String.replace(context.fixture, \"/\", \"\\\\\")\n tmp_dir_path = String.replace(context.tmp_dir, \"/\", \"\\\\\")\n assert elixirc(~c\"#{fixture} -o #{tmp_dir_path}\", context.cli_extension) == \"\"\n assert File.regular?(context[:beam_file_path])\n\n # Assert that the module is loaded into memory with the proper destination for the BEAM file.\n Code.append_path(context.tmp_dir)\n\n assert :code.which(CompileSample) |> List.to_string() ==\n Path.expand(context[:beam_file_path])\n after\n :code.purge(CompileSample)\n :code.delete(CompileSample)\n Code.delete_path(context.tmp_dir)\n end\n end\n\n stderr_test \"fails on missing patterns\", context do\n output =\n elixirc(~c\"#{context.fixture} non_existing.ex -o #{context.tmp_dir}\", context.cli_extension)\n\n assert output =~ \"non_existing.ex\"\n refute output =~ \"compile_sample.ex\"\n refute File.exists?(context.beam_file_path)\n end\n\n stderr_test \"fails on missing write access to .beam file\", context do\n compilation_args = ~c\"#{context.fixture} -o #{context.tmp_dir}\"\n\n assert elixirc(compilation_args, context.cli_extension) == \"\"\n assert File.regular?(context.beam_file_path)\n\n # Set the .beam file to read-only\n File.chmod!(context.beam_file_path, 4)\n {:ok, %{access: access}} = File.stat(context.beam_file_path)\n\n # Can only assert when read-only applies to the user\n if access != :read_write do\n output = elixirc(compilation_args, context.cli_extension)\n\n expected =\n \"(File.Error) could not write to file #{inspect(context.beam_file_path)}: permission denied\"\n\n assert output =~ expected\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/comprehension_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.ComprehensionTest do\n use ExUnit.Case, async: true\n\n import ExUnit.CaptureIO\n require Integer\n\n defmodule Pdict do\n defstruct []\n\n defimpl Collectable do\n def into(struct) do\n fun = fn\n _, {:cont, x} -> Process.put(:into_cont, [x | Process.get(:into_cont)])\n _, :done -> Process.put(:into_done, true)\n _, :halt -> Process.put(:into_halt, true)\n end\n\n {struct, fun}\n end\n end\n end\n\n defp to_bin(x) do\n <>\n end\n\n defp nilly, do: nil\n\n ## Enum comprehensions (the common case)\n\n test \"for comprehensions\" do\n enum = 1..3\n assert for(x <- enum, do: x * 2) == [2, 4, 6]\n end\n\n test \"for comprehensions with matching\" do\n assert for({_, x} <- 1..3, do: x * 2) == []\n end\n\n test \"for comprehensions with pin matching\" do\n maps = [x: 1, y: 2, x: 3]\n assert for({:x, v} <- maps, do: v * 2) == [2, 6]\n x = :x\n assert for({^x, v} <- maps, do: v * 2) == [2, 6]\n end\n\n test \"for comprehensions with guards\" do\n assert for(x when x < 4 <- 1..10, do: x) == [1, 2, 3]\n assert for(x when x == 3 when x == 7 <- 1..10, do: x) == [3, 7]\n end\n\n test \"for comprehensions with guards and filters\" do\n assert for(\n {var, _}\n when is_atom(var) <- [{:foo, 1}, {2, :bar}],\n var = Atom.to_string(var),\n do: var\n ) == [\"foo\"]\n end\n\n test \"for comprehensions with map key matching\" do\n maps = [%{x: 1}, %{y: 2}, %{x: 3}]\n assert for(%{x: v} <- maps, do: v * 2) == [2, 6]\n x = :x\n assert for(%{^x => v} <- maps, do: v * 2) == [2, 6]\n end\n\n test \"for comprehensions with filters\" do\n assert for(x <- 1..3, x > 1, x < 3, do: x * 2) == [4]\n end\n\n test \"for comprehensions with unique values\" do\n list = [1, 1, 2, 3]\n assert for(x <- list, uniq: true, do: x * 2) == [2, 4, 6]\n assert for(x <- list, uniq: true, into: [], do: x * 2) == [2, 4, 6]\n assert for(x <- list, uniq: true, into: %{}, do: {x, 1}) == %{1 => 1, 2 => 1, 3 => 1}\n assert for(x <- list, uniq: true, into: \"\", do: to_bin(x * 2)) == <<2, 4, 6>>\n assert for(<>, uniq: true, into: \"\", do: to_bin(x)) == \"abc\"\n\n Process.put(:into_cont, [])\n Process.put(:into_done, false)\n Process.put(:into_halt, false)\n\n for x <- list, uniq: true, into: %Pdict{} do\n x * 2\n end\n\n assert Process.get(:into_cont) == [6, 4, 2]\n assert Process.get(:into_done)\n refute Process.get(:into_halt)\n\n assert_raise RuntimeError, \"oops\", fn ->\n for _ <- [1, 2, 3], uniq: true, into: %Pdict{}, do: raise(\"oops\")\n end\n\n assert Process.get(:into_halt)\n end\n\n test \"nested for comprehensions with unique values\" do\n assert for(x <- [1, 1, 2], uniq: true, do: for(y <- [3, 3], uniq: true, do: x * y)) == [\n [3],\n [6]\n ]\n\n assert for(<>,\n uniq: true,\n into: \"\",\n do: for(<>, uniq: true, into: \"\", do: to_bin(x) <> to_bin(y))\n ) == \"azbzcz\"\n end\n\n test \"for comprehensions with nilly filters\" do\n assert for(x <- 1..3, nilly(), do: x * 2) == []\n end\n\n test \"for comprehensions with unique option where value is not used\" do\n assert capture_io(:stderr, fn ->\n assert capture_io(fn ->\n Code.eval_quoted(\n quote do\n for x <- [1, 2, 1, 2], uniq: true, do: IO.puts(x)\n nil\n end\n )\n end) ==\n \"1\\n2\\n1\\n2\\n\"\n end) =~\n \"the :uniq option has no effect since the result of the for comprehension is not used\"\n end\n\n test \"for comprehensions with unique option where value is assigned to _\" do\n assert capture_io(:stderr, fn ->\n assert capture_io(fn ->\n Code.eval_quoted(\n quote do\n _ = for x <- [1, 2, 1, 2], uniq: true, do: IO.puts(x)\n nil\n end\n )\n end) ==\n \"1\\n2\\n1\\n2\\n\"\n end) =~\n \"the :uniq option has no effect since the result of the for comprehension is not used\"\n end\n\n test \"for comprehensions with errors on filters\" do\n assert_raise ArgumentError, fn ->\n for x <- 1..3, hd(x), do: :ok\n end\n end\n\n test \"for comprehensions with variables in filters\" do\n assert for(x <- 1..3, y = x + 1, y > 2, z = y, do: x * z) == [6, 12]\n end\n\n test \"for comprehensions with two enum generators\" do\n assert for(\n x <- [1, 2, 3],\n y <- [4, 5, 6],\n do: x * y\n ) == [4, 5, 6, 8, 10, 12, 12, 15, 18]\n end\n\n test \"for comprehensions with two enum generators and filters\" do\n assert for(\n x <- [1, 2, 3],\n y <- [4, 5, 6],\n y / 2 == x,\n do: x * y\n ) == [8, 18]\n end\n\n test \"for comprehensions generators precedence\" do\n assert for({_, _} = x <- [foo: :bar], do: x) == [foo: :bar]\n end\n\n test \"for comprehensions with shadowing\" do\n assert for(\n a <-\n (\n b = 1\n _ = b\n [1]\n ),\n b <- [2],\n do: a + b\n ) == [3]\n end\n\n test \"for comprehensions with binary, enum generators and filters\" do\n assert for(x <- [1, 2, 3], <<(y <- <<4, 5, 6>>)>>, y / 2 == x, do: x * y) == [8, 18]\n end\n\n test \"for comprehensions into list\" do\n enum = 1..3\n assert for(x <- enum, into: [], do: x * 2) == [2, 4, 6]\n end\n\n test \"for comprehensions into binary\" do\n enum = 0..3\n\n assert (for x <- enum, into: \"\" do\n to_bin(x * 2)\n end) == <<0, 2, 4, 6>>\n\n assert (for x <- enum, into: \"\" do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n end\n\n test \"for comprehensions into dynamic binary\" do\n enum = 0..3\n into = \"\"\n\n assert (for x <- enum, into: into do\n to_bin(x * 2)\n end) == <<0, 2, 4, 6>>\n\n assert (for x <- enum, into: into do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n\n into = <<7::size(1)>>\n\n assert (for x <- enum, into: into do\n to_bin(x * 2)\n end) == <<7::size(1), 0, 2, 4, 6>>\n\n assert (for x <- enum, into: into do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<7::size(1), 0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n end\n\n test \"for comprehensions where value is not used\" do\n enum = 1..3\n\n assert capture_io(fn ->\n for x <- enum, do: IO.puts(x)\n nil\n end) == \"1\\n2\\n3\\n\"\n end\n\n test \"for comprehensions with into\" do\n Process.put(:into_cont, [])\n Process.put(:into_done, false)\n Process.put(:into_halt, false)\n\n for x <- 1..3, into: %Pdict{} do\n x * 2\n end\n\n assert Process.get(:into_cont) == [6, 4, 2]\n assert Process.get(:into_done)\n refute Process.get(:into_halt)\n end\n\n test \"for comprehension with into leading to errors\" do\n Process.put(:into_cont, [])\n Process.put(:into_done, false)\n Process.put(:into_halt, false)\n\n catch_error(\n for x <- 1..3, into: %Pdict{} do\n if x > 2, do: raise(\"oops\"), else: x\n end\n )\n\n assert Process.get(:into_cont) == [2, 1]\n refute Process.get(:into_done)\n assert Process.get(:into_halt)\n end\n\n test \"for comprehension with into, generators and filters\" do\n Process.put(:into_cont, [])\n\n for x <- 1..3, Integer.is_odd(x), <>, into: %Pdict{} do\n x + y\n end\n\n assert IO.iodata_to_binary(Process.get(:into_cont)) == \"roohkpmmfi\"\n end\n\n test \"for comprehensions of map into map\" do\n enum = %{a: 2, b: 3}\n assert for({k, v} <- enum, into: %{}, do: {k, v * v}) == %{a: 4, b: 9}\n end\n\n test \"for comprehensions with reduce, generators and filters\" do\n acc =\n for x <- 1..3, Integer.is_odd(x), <>, reduce: %{} do\n acc -> Map.update(acc, x, [y], &[y | &1])\n end\n\n assert acc == %{1 => ~c\"olleh\", 3 => ~c\"olleh\"}\n end\n\n test \"for comprehensions with matched reduce\" do\n acc =\n for entry <- [1, 2, 3], reduce: {:ok, nil} do\n {:ok, _} ->\n {:ok, entry}\n\n {:error, _} = error ->\n error\n end\n\n assert acc == {:ok, 3}\n end\n\n ## List generators (inlined by the compiler)\n\n test \"list for comprehensions\" do\n list = [1, 2, 3]\n assert for(x <- list, do: x * 2) == [2, 4, 6]\n end\n\n test \"list for comprehensions with matching\" do\n assert for({_, x} <- [1, 2, a: 3, b: 4, c: 5], do: x * 2) == [6, 8, 10]\n end\n\n test \"list for comprehension matched to '_' on last line of block\" do\n assert (if Process.get(:unused, true) do\n _ = for x <- [1, 2, 3], do: x * 2\n end) == [2, 4, 6]\n end\n\n test \"list for comprehensions with filters\" do\n assert for(x <- [1, 2, 3], x > 1, x < 3, do: x * 2) == [4]\n end\n\n test \"list for comprehensions with nilly filters\" do\n assert for(x <- [1, 2, 3], nilly(), do: x * 2) == []\n end\n\n test \"list for comprehensions with errors on filters\" do\n assert_raise ArgumentError, fn ->\n for x <- [1, 2, 3], hd(Process.get(:unused, x)), do: x * 2\n end\n end\n\n test \"list for comprehensions with variables in filters\" do\n assert for(x <- [1, 2, 3], y = x + 1, y > 2, z = y, do: x * z) == [6, 12]\n end\n\n test \"list for comprehensions into list\" do\n enum = [1, 2, 3]\n assert for(x <- enum, into: [], do: x * 2) == [2, 4, 6]\n end\n\n test \"list for comprehensions into binary\" do\n enum = [0, 1, 2, 3]\n\n assert (for x <- enum, into: \"\" do\n to_bin(x * 2)\n end) == <<0, 2, 4, 6>>\n\n assert (for x <- enum, into: \"\" do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n end\n\n test \"list for comprehensions into dynamic binary\" do\n enum = [0, 1, 2, 3]\n into = \"\"\n\n assert (for x <- enum, into: into do\n to_bin(x * 2)\n end) == <<0, 2, 4, 6>>\n\n assert (for x <- enum, into: into do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n\n into = <<7::size(1)>>\n\n assert (for x <- enum, into: into do\n to_bin(x * 2)\n end) == <<7::size(1), 0, 2, 4, 6>>\n\n assert (for x <- enum, into: into do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<7::size(1), 0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n end\n\n test \"list for comprehensions where value is not used\" do\n enum = [1, 2, 3]\n\n assert capture_io(fn ->\n for x <- enum, do: IO.puts(x)\n nil\n end) == \"1\\n2\\n3\\n\"\n end\n\n test \"list for comprehensions with reduce, generators and filters\" do\n acc =\n for x <- [1, 2, 3], Integer.is_odd(x), <>, reduce: %{} do\n acc -> Map.update(acc, x, [y], &[y | &1])\n end\n\n assert acc == %{1 => ~c\"olleh\", 3 => ~c\"olleh\"}\n end\n\n ## Binary generators (inlined by the compiler)\n\n test \"binary for comprehensions\" do\n bin = <<1, 2, 3>>\n assert for(<>, do: x * 2) == [2, 4, 6]\n end\n\n test \"binary for comprehensions with inner binary\" do\n bin = <<1, 2, 3>>\n assert for(<<(<> <- bin)>>, do: x * 2) == [2, 4, 6]\n end\n\n test \"binary for comprehensions with two generators\" do\n assert for(<<(x <- <<1, 2, 3>>)>>, <<(y <- <<4, 5, 6>>)>>, y / 2 == x, do: x * y) == [8, 18]\n end\n\n test \"binary for comprehensions into list\" do\n bin = <<1, 2, 3>>\n assert for(<>, into: [], do: x * 2) == [2, 4, 6]\n end\n\n test \"binary for comprehensions into binary\" do\n bin = <<0, 1, 2, 3>>\n\n assert (for <>, into: \"\" do\n to_bin(x * 2)\n end) == <<0, 2, 4, 6>>\n\n assert (for <>, into: \"\" do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n end\n\n test \"binary for comprehensions into dynamic binary\" do\n bin = <<0, 1, 2, 3>>\n into = \"\"\n\n assert (for <>, into: into do\n to_bin(x * 2)\n end) == <<0, 2, 4, 6>>\n\n assert (for <>, into: into do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n\n into = <<7::size(1)>>\n\n assert (for <>, into: into do\n to_bin(x * 2)\n end) == <<7::size(1), 0, 2, 4, 6>>\n\n assert (for <>, into: into do\n if Integer.is_even(x), do: <>, else: <>\n end) == <<7::size(1), 0::size(2), 1::size(1), 2::size(2), 3::size(1)>>\n end\n\n test \"binary for comprehensions with literal matches\" do\n # Integers\n bin = <<1, 2, 1, 3, 1, 4>>\n assert for(<<1, x <- bin>>, into: \"\", do: to_bin(x)) == <<2, 3, 4>>\n assert for(<<1, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2, 3 => 3, 4 => 4}\n\n bin = <<1, 2, 3, 1, 4>>\n assert for(<<1, x <- bin>>, into: \"\", do: to_bin(x)) == <<2>>\n assert for(<<1, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}\n\n # Floats\n bin = <<1.0, 2, 1.0, 3, 1.0, 4>>\n assert for(<<1.0, x <- bin>>, into: \"\", do: to_bin(x)) == <<2, 3, 4>>\n assert for(<<1.0, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2, 3 => 3, 4 => 4}\n\n bin = <<1.0, 2, 3, 1.0, 4>>\n assert for(<<1.0, x <- bin>>, into: \"\", do: to_bin(x)) == <<2>>\n assert for(<<1.0, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}\n\n # Binaries\n bin = <<\"foo\", 2, \"foo\", 3, \"foo\", 4>>\n assert for(<<\"foo\", x <- bin>>, into: \"\", do: to_bin(x)) == <<2, 3, 4>>\n assert for(<<\"foo\", x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2, 3 => 3, 4 => 4}\n\n bin = <<\"foo\", 2, 3, \"foo\", 4>>\n assert for(<<\"foo\", x <- bin>>, into: \"\", do: to_bin(x)) == <<2>>\n assert for(<<\"foo\", x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}\n\n bin = <<\"foo\", 2, 3, 4, \"foo\", 5>>\n assert for(<<\"foo\", x <- bin>>, into: \"\", do: to_bin(x)) == <<2>>\n assert for(<<\"foo\", x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}\n end\n\n test \"binary for comprehensions with variable size\" do\n s = 16\n bin = <<1, 2, 3, 4, 5, 6>>\n assert for(<>, into: \"\", do: to_bin(div(x, 2))) == <<129, 130, 131>>\n\n s = 8\n bin = <<1, 2, 3, 4, 5, 6>>\n assert for(<>, into: \"\", do: <>) == <<2, 12, 30>>\n\n # Aligned\n bin = <<8, 1, 16, 2, 3>>\n assert for(<>, into: \"\", do: <>) == <<1, 2, 3>>\n assert for(<>, into: %{}, do: {s, x}) == %{8 => 1, 16 => 515}\n\n # Unaligned\n bin = <<8, 1, 32, 2, 3>>\n assert for(<>, into: \"\", do: <>) == <<1>>\n assert for(<>, into: %{}, do: {s, x}) == %{8 => 1}\n end\n\n test \"binary for comprehensions where value is not used\" do\n bin = <<1, 2, 3>>\n\n assert capture_io(fn ->\n for <>, do: IO.puts(x)\n nil\n end) == \"1\\n2\\n3\\n\"\n end\n\n test \"binary for comprehensions with reduce, generators and filters\" do\n bin = <<1, 2, 3>>\n\n acc =\n for <>, Integer.is_odd(x), <>, reduce: %{} do\n acc -> Map.update(acc, x, [y], &[y | &1])\n end\n\n assert acc == %{1 => ~c\"olleh\", 3 => ~c\"olleh\"}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/defaults_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.DefaultsTest do\n use ExUnit.Case, async: true\n\n import ExUnit.CaptureIO\n\n def fun_with_fn_defaults(\n x,\n fun1 \\\\ & &1,\n fun2 \\\\ & &1,\n y\n ) do\n {fun1.(x), fun2.(y)}\n end\n\n def fun_with_block_defaults(\n x,\n y \\\\ (\n default = \"y\"\n default\n ),\n z \\\\ (\n default = \"z\"\n default\n )\n ) do\n {x, y, z}\n end\n\n test \"with anonymous function defaults\" do\n assert {1, 2} = fun_with_fn_defaults(1, 2)\n assert {100, 2} = fun_with_fn_defaults(1, &(&1 * 100), 2)\n assert {100, 12} = fun_with_fn_defaults(1, &(&1 * 100), &(&1 + 10), 2)\n end\n\n test \"with block defaults\" do\n assert {1, \"y\", \"z\"} = fun_with_block_defaults(1)\n assert {1, 2, \"z\"} = fun_with_block_defaults(1, 2)\n assert {1, 2, 3} = fun_with_block_defaults(1, 2, 3)\n end\n\n test \"errors on accessing variable from default block\" do\n assert_compile_error(~r/undefined variable \\\"default\\\"/, fn ->\n defmodule VarDefaultScope do\n def test(_ \\\\ default = 1),\n do: default\n end\n end)\n end\n\n test \"errors on multiple defaults\" do\n message = ~r\"def hello/1 defines defaults multiple times\"\n\n assert_compile_error(message, fn ->\n defmodule Kernel.ErrorsTest.ClauseWithDefaults do\n def hello(_arg \\\\ 0)\n def hello(_arg \\\\ 1)\n end\n end)\n\n assert_compile_error(message, fn ->\n defmodule Kernel.ErrorsTest.ClauseWithDefaults do\n def hello(_arg \\\\ 0), do: nil\n def hello(_arg \\\\ 1), do: nil\n end\n end)\n\n assert_compile_error(message, fn ->\n defmodule Kernel.ErrorsTest.ClauseWithDefaults do\n def hello(_arg \\\\ 0)\n def hello(_arg \\\\ 1), do: nil\n end\n end)\n\n assert_compile_error(message, fn ->\n defmodule Kernel.ErrorsTest.ClauseWithDefaults do\n def hello(_arg \\\\ 0), do: nil\n def hello(_arg \\\\ 1)\n end\n end)\n\n assert_compile_error(\"undefined variable \\\"foo\\\"\", fn ->\n defmodule Kernel.ErrorsTest.ClauseWithDefaults5 do\n def hello(foo, bar \\\\ foo)\n def hello(foo, bar), do: foo + bar\n end\n end)\n end\n\n test \"errors on conflicting defaults\" do\n assert_compile_error(~r\"def hello/3 defaults conflicts with hello/2\", fn ->\n defmodule Kernel.ErrorsTest.DifferentDefsWithDefaults1 do\n def hello(a, b \\\\ nil), do: a + b\n def hello(a, b \\\\ nil, c \\\\ nil), do: a + b + c\n end\n end)\n\n assert_compile_error(~r\"def hello/2 conflicts with defaults from hello/3\", fn ->\n defmodule Kernel.ErrorsTest.DifferentDefsWithDefaults2 do\n def hello(a, b \\\\ nil, c \\\\ nil), do: a + b + c\n def hello(a, b \\\\ nil), do: a + b\n end\n end)\n end\n\n defp assert_compile_error(message, fun) do\n assert capture_io(:stderr, fn ->\n assert_raise CompileError, fun\n end) =~ message\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/deprecated_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.DeprecatedTest do\n use ExUnit.Case\n\n import PathHelpers\n\n test \"raises on invalid @deprecated\" do\n assert_raise ArgumentError, ~r\"should be a string with the reason\", fn ->\n defmodule InvalidDeprecated do\n @deprecated 1.2\n def foo, do: :bar\n end\n end\n end\n\n test \"takes into account deprecated from defaults\" do\n defmodule DefaultDeprecated do\n @deprecated \"reason\"\n def foo(x \\\\ true), do: x\n end\n\n assert DefaultDeprecated.__info__(:deprecated) == [\n {{:foo, 0}, \"reason\"},\n {{:foo, 1}, \"reason\"}\n ]\n end\n\n test \"add deprecated to __info__\" do\n write_beam(\n defmodule SampleDeprecated do\n @deprecated \"Use SampleDeprecated.bar/0 instead\"\n def foo, do: true\n\n def bar, do: false\n end\n )\n\n deprecated = [\n {{:foo, 0}, \"Use SampleDeprecated.bar/0 instead\"}\n ]\n\n assert SampleDeprecated.__info__(:deprecated) == deprecated\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/diagnostics_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.DiagnosticsTest do\n use ExUnit.Case, async: false\n\n import ExUnit.CaptureIO\n\n setup_all do\n previous = Application.get_env(:elixir, :ansi_enabled, false)\n Application.put_env(:elixir, :ansi_enabled, false)\n on_exit(fn -> Application.put_env(:elixir, :ansi_enabled, previous) end)\n end\n\n describe \"mismatched delimiter\" do\n test \"same line - handles unicode input\" do\n output =\n capture_raise(\n \"\"\"\n [1, 2, 3, 4, 5, 6) <- 😎\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:1:18:\n error: unexpected token: )\n │\n 1 │ [1, 2, 3, 4, 5, 6) <- 😎\n │ │ └ mismatched closing delimiter (expected \"]\")\n │ └ unclosed delimiter\n │\n └─ nofile:1:18\\\n \"\"\"\n end\n\n test \"same line\" do\n output =\n capture_raise(\n \"\"\"\n [1, 2, 3, 4, 5, 6)\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:1:18:\n error: unexpected token: )\n │\n 1 │ [1, 2, 3, 4, 5, 6)\n │ │ └ mismatched closing delimiter (expected \"]\")\n │ └ unclosed delimiter\n │\n └─ nofile:1:18\\\n \"\"\"\n end\n\n test \"same line with offset\" do\n output =\n capture_raise(\n \"\"\"\n [1, 2, 3, 4, 5, 6)\n \"\"\",\n MismatchedDelimiterError,\n line: 3\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:3:18:\n error: unexpected token: )\n │\n 3 │ [1, 2, 3, 4, 5, 6)\n │ │ └ mismatched closing delimiter (expected \"]\")\n │ └ unclosed delimiter\n │\n └─ nofile:3:18\\\n \"\"\"\n end\n\n test \"two-line span\" do\n output =\n capture_raise(\n \"\"\"\n [a, b, c\n d, f, g}\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:2:9:\n error: unexpected token: }\n │\n 1 │ [a, b, c\n │ └ unclosed delimiter\n 2 │ d, f, g}\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:2:9\\\n \"\"\"\n end\n\n test \"two-line span with offset\" do\n output =\n capture_raise(\n \"\"\"\n [a, b, c\n d, f, g}\n \"\"\",\n MismatchedDelimiterError,\n line: 3\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:4:9:\n error: unexpected token: }\n │\n 3 │ [a, b, c\n │ └ unclosed delimiter\n 4 │ d, f, g}\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:4:9\\\n \"\"\"\n end\n\n test \"many-line span\" do\n output =\n capture_raise(\n \"\"\"\n [ a,\n b,\n c,\n d\n e )\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:5:5:\n error: unexpected token: )\n │\n 1 │ [ a,\n │ └ unclosed delimiter\n 2 │ b,\n 3 │ c,\n 4 │ d\n 5 │ e )\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:5:5\\\n \"\"\"\n end\n\n test \"many-line span with offset\" do\n output =\n capture_raise(\n \"\"\"\n fn always_forget_end ->\n IO.inspect(2 + 2) + 2\n )\n \"\"\",\n MismatchedDelimiterError,\n line: 3\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:5:1:\n error: unexpected token: )\n │\n 3 │ fn always_forget_end ->\n │ └ unclosed delimiter\n 4 │ IO.inspect(2 + 2) + 2\n 5 │ )\n │ └ mismatched closing delimiter (expected \"end\")\n │\n └─ nofile:5:1\\\n \"\"\"\n end\n\n test \"line range - handles unicode input\" do\n output =\n capture_raise(\n \"\"\"\n defmodule A do\n IO.inspect(2 + 2)\n ) <- 😎\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:3:1:\n error: unexpected token: )\n │\n 1 │ defmodule A do\n │ └ unclosed delimiter\n 2 │ IO.inspect(2 + 2)\n 3 │ ) <- 😎\n │ └ mismatched closing delimiter (expected \"end\")\n │\n └─ nofile:3:1\\\n \"\"\"\n end\n\n test \"trim in between lines if too many\" do\n output =\n capture_raise(\n \"\"\"\n [ :a,\n :b,\n :c,\n :d,\n :e,\n :f,\n :g,\n :h\n )\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:9:1:\n error: unexpected token: )\n │\n 1 │ [ :a,\n │ └ unclosed delimiter\n ...\n 9 │ )\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:9:1\\\n \"\"\"\n end\n\n test \"trimmed line range - handles unicode input\" do\n output =\n capture_raise(\n \"\"\"\n [ :a,\n :b,\n :c,\n :d,\n :e,\n :f,\n :g,\n :h\n ) <- 😎\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:9:1:\n error: unexpected token: )\n │\n 1 │ [ :a,\n │ └ unclosed delimiter\n ...\n 9 │ ) <- 😎\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:9:1\\\n \"\"\"\n end\n\n test \"pads according to line number digits\" do\n output =\n capture_raise(\n \"\"\"\n [ a,\n #{String.duplicate(\"\\n\", 10)}\n b )\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:13:5:\n error: unexpected token: )\n │\n 1 │ [ a,\n │ └ unclosed delimiter\n ...\n 13 │ b )\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:13:5\\\n \"\"\"\n\n output =\n capture_raise(\n \"\"\"\n [ a,\n #{String.duplicate(\"\\n\", 400)}\n b )\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:403:5:\n error: unexpected token: )\n │\n 1 │ [ a,\n │ └ unclosed delimiter\n ...\n 403 │ b )\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:403:5\\\n \"\"\"\n\n output =\n capture_raise(\n \"\"\"\n #{String.duplicate(\"\\n\", 97)}\n [ a,\n #{String.duplicate(\"\\n\", 6)}\n b )\n \"\"\",\n MismatchedDelimiterError\n )\n\n assert output == \"\"\"\n ** (MismatchedDelimiterError) mismatched delimiter found on nofile:107:5:\n error: unexpected token: )\n │\n 99 │ [ a,\n │ └ unclosed delimiter\n ...\n 107 │ b )\n │ └ mismatched closing delimiter (expected \"]\")\n │\n └─ nofile:107:5\\\n \"\"\"\n end\n end\n\n describe \"token missing error\" do\n test \"missing parens terminator\" do\n output =\n capture_raise(\n \"\"\"\n my_numbers = [1, 2, 3, 4, 5, 6\n IO.inspect(my_numbers)\n \"\"\",\n TokenMissingError\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:2:23:\n error: missing terminator: ]\n │\n 1 │ my_numbers = [1, 2, 3, 4, 5, 6\n │ └ unclosed delimiter\n 2 │ IO.inspect(my_numbers)\n │ └ missing closing delimiter (expected \"]\")\n │\n └─ nofile:2:23\\\n \"\"\"\n end\n\n test \"missing heredoc terminator\" do\n output =\n capture_raise(\n \"\"\"\n a = \\\"\"\"\n test string\n\n IO.inspect(10 + 20)\n \"\"\",\n TokenMissingError\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:4:20:\n error: missing terminator: \\\"\"\" (for heredoc starting at line 1)\n │\n 1 │ a = \\\"\"\"\n │ └ unclosed delimiter\n 2 │ test string\n 3 │\\s\n 4 │ IO.inspect(10 + 20)\n │ └ missing closing delimiter (expected \\\"\"\")\n │\n └─ nofile:4:20\\\n \"\"\"\n end\n\n test \"missing sigil terminator\" do\n output =\n capture_raise(\"~s (for sigil ~s< starting at line 1)\n │\n 1 │ ~s\")\n │ └ unclosed delimiter\n │\n └─ nofile:1:10\\\n \"\"\"\n\n output =\n capture_raise(\"~s|foobar\", TokenMissingError)\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:1:10:\n error: missing terminator: | (for sigil ~s| starting at line 1)\n │\n 1 │ ~s|foobar\n │ │ └ missing closing delimiter (expected \"|\")\n │ └ unclosed delimiter\n │\n └─ nofile:1:10\\\n \"\"\"\n end\n\n test \"missing string terminator\" do\n output =\n capture_raise(\"\\\"foobar\", TokenMissingError)\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:1:8:\n error: missing terminator: \" (for string starting at line 1)\n │\n 1 │ \"foobar\n │ │ └ missing closing delimiter (expected \")\n │ └ unclosed delimiter\n │\n └─ nofile:1:8\\\n \"\"\"\n end\n\n test \"missing atom terminator\" do\n output =\n capture_raise(\":\\\"foobar\", TokenMissingError)\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:1:9:\n error: missing terminator: \" (for atom starting at line 1)\n │\n 1 │ :\"foobar\n │ │ └ missing closing delimiter (expected \")\n │ └ unclosed delimiter\n │\n └─ nofile:1:9\\\n \"\"\"\n end\n\n test \"missing function terminator\" do\n output =\n capture_raise(\"K.\\\"foobar\", TokenMissingError)\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:1:10:\n error: missing terminator: \" (for function name starting at line 1)\n │\n 1 │ K.\"foobar\n │ │ └ missing closing delimiter (expected \")\n │ └ unclosed delimiter\n │\n └─ nofile:1:10\\\n \"\"\"\n end\n\n test \"shows in between lines if EOL is not far below\" do\n output =\n capture_raise(\n \"\"\"\n my_numbers = [1, 2, 3, 4, 5, 6\n my_numbers\n |> Enum.map(&(&1 + 1))\n |> Enum.map(&(&1 * &1))\n |> IO.inspect()\n \"\"\",\n TokenMissingError\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:5:16:\n error: missing terminator: ]\n │\n 1 │ my_numbers = [1, 2, 3, 4, 5, 6\n │ └ unclosed delimiter\n 2 │ my_numbers\n 3 │ |> Enum.map(&(&1 + 1))\n 4 │ |> Enum.map(&(&1 * &1))\n 5 │ |> IO.inspect()\n │ └ missing closing delimiter (expected \"]\")\n │\n └─ nofile:5:16\\\n \"\"\"\n end\n\n test \"trims lines\" do\n output =\n capture_raise(\n \"\"\"\n my_numbers = (1, 2, 3, 4, 5, 6\n\n\n\n\n\n\n IO.inspect(my_numbers)\n \"\"\",\n TokenMissingError\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:8:23:\n error: missing terminator: )\n │\n 1 │ my_numbers = (1, 2, 3, 4, 5, 6\n │ └ unclosed delimiter\n ...\n 8 │ IO.inspect(my_numbers)\n │ └ missing closing delimiter (expected \")\")\n │\n └─ nofile:8:23\\\n \"\"\"\n end\n\n test \"shows the last non-empty line of a file\" do\n output =\n capture_raise(\n \"\"\"\n my_numbers = {1, 2, 3, 4, 5, 6\n IO.inspect(my_numbers)\n\n\n\n\n \"\"\",\n TokenMissingError\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:2:23:\n error: missing terminator: }\n │\n 1 │ my_numbers = {1, 2, 3, 4, 5, 6\n │ └ unclosed delimiter\n 2 │ IO.inspect(my_numbers)\n │ └ missing closing delimiter (expected \"}\")\n │\n └─ nofile:2:23\\\n \"\"\"\n end\n\n test \"supports unicode\" do\n output =\n capture_raise(\n \"\"\"\n my_emojis = [1, 2, 3, 4 # ⚗️\n IO.inspect(my_numbers)\n \"\"\",\n TokenMissingError\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:2:23:\n error: missing terminator: ]\n │\n 1 │ my_emojis = [1, 2, 3, 4 # ⚗️\n │ └ unclosed delimiter\n 2 │ IO.inspect(my_numbers)\n │ └ missing closing delimiter (expected \"]\")\n │\n └─ nofile:2:23\\\n \"\"\"\n end\n end\n\n describe \"compile-time exceptions\" do\n test \"SyntaxError (snippet)\" do\n output =\n capture_raise(\n \"\"\"\n [1, 2, 3, 4, 5, *]\n \"\"\",\n SyntaxError\n )\n\n assert output == \"\"\"\n ** (SyntaxError) invalid syntax found on nofile:1:17:\n error: syntax error before: '*'\n │\n 1 │ [1, 2, 3, 4, 5, *]\n │ ^\n │\n └─ nofile:1:17\\\n \"\"\"\n end\n\n test \"SyntaxError (snippet) with offset\" do\n output =\n capture_raise(\n \"\"\"\n [1, 2, 3, 4, 5, *]\n \"\"\",\n SyntaxError,\n line: 3\n )\n\n assert output == \"\"\"\n ** (SyntaxError) invalid syntax found on nofile:3:17:\n error: syntax error before: '*'\n │\n 3 │ [1, 2, 3, 4, 5, *]\n │ ^\n │\n └─ nofile:3:17\\\n \"\"\"\n end\n\n test \"TokenMissingError (snippet)\" do\n output =\n capture_raise(\n \"\"\"\n 1 +\n \"\"\",\n TokenMissingError\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:1:4:\n error: syntax error: expression is incomplete\n │\n 1 │ 1 +\n │ ^\n │\n └─ nofile:1:4\\\n \"\"\"\n end\n\n test \"TokenMissingError (snippet) with offset and column\" do\n output =\n capture_raise(\n \"\"\"\n 1 +\n \"\"\",\n TokenMissingError,\n line: 3,\n column: 3\n )\n\n assert output == \"\"\"\n ** (TokenMissingError) token missing on nofile:3:6:\n error: syntax error: expression is incomplete\n │\n 3 │ 1 +\n │ ^\n │\n └─ nofile:3:6\\\n \"\"\"\n end\n\n test \"TokenMissingError (unclosed delimiter)\" do\n expected = \"\"\"\n ** (TokenMissingError) token missing on nofile:1:5:\n error: missing terminator: end\n │\n 1 │ fn a\n │ │ └ missing closing delimiter (expected \"end\")\n │ └ unclosed delimiter\n │\n └─ nofile:1:5\\\n \"\"\"\n\n output =\n capture_raise(\n \"\"\"\n fn a\n \"\"\",\n TokenMissingError\n )\n\n assert output == expected\n end\n\n test \"keeps trailing whitespace if under threshold\" do\n expected = \"\"\"\n ** (SyntaxError) invalid syntax found on nofile:1:23:\n error: unexpected token: \"😎\" (column 23, code point U+****)\n │\n 1 │ a + 😎\n │ ^\n │\n └─ nofile:1:23\\\n \"\"\"\n\n output =\n capture_raise(\n \"\"\"\n a + 😎\n \"\"\",\n SyntaxError\n )\n\n assert output == expected\n end\n\n test \"limits trailing whitespace if too many\" do\n expected = \"\"\"\n ** (SyntaxError) invalid syntax found on nofile:1:43:\n error: unexpected token: \"😎\" (column 43, code point U+****)\n │\n 1 │ ... a + 😎\n │ ^\n │\n └─ nofile:1:43\\\n \"\"\"\n\n output =\n capture_raise(\n \"\"\"\n a + 😎\n \"\"\",\n SyntaxError\n )\n\n assert output == expected\n end\n\n test \"shows stacktrace if present\" do\n fake_stacktrace = [\n {:fake, :fun, 3, [file: \"nofile\", line: 10]},\n {:real, :fun, 2, [file: \"nofile\", line: 10]}\n ]\n\n expected = \"\"\"\n ** (TokenMissingError) token missing on nofile:1:4:\n error: syntax error: expression is incomplete\n │\n 1 │ 1 -\n │ ^\n │\n └─ nofile:1:4\n nofile:10: :fake.fun/3\n nofile:10: :real.fun/2\n \"\"\"\n\n output =\n capture_raise(\n \"\"\"\n 1 -\n \"\"\",\n TokenMissingError,\n stacktrace: fake_stacktrace\n )\n\n assert output == expected\n end\n\n test \"2-digit line errors stay aligned 1-digit line errors\" do\n fake_stacktrace = [\n {:fake, :fun, 3, [file: \"nofile\", line: 10]}\n ]\n\n expected = \"\"\"\n ** (TokenMissingError) token missing on nofile:12:4:\n error: syntax error: expression is incomplete\n │\n 12 │ 1 -\n │ ^\n │\n └─ nofile:12:4\n nofile:10: :fake.fun/3\n \"\"\"\n\n output =\n capture_raise(\n \"\"\"\n #{String.duplicate(\"\\n\", 10)}\n 1 -\n \"\"\",\n TokenMissingError,\n stacktrace: fake_stacktrace\n )\n\n assert output == expected\n end\n\n test \"handles unicode\" do\n source = \"\"\"\n defmodule Sample do\n def a do\n 10 + 😎\n end\n end\n \"\"\"\n\n output = capture_raise(source, SyntaxError)\n\n assert output =~ \"😎\"\n after\n purge(Sample)\n end\n end\n\n describe \"compiler warnings\" do\n @tag :tmp_dir\n test \"simple warning (line + column + file)\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"long-warning.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n defp a, do: Unknown.b()\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n │\n 3 │ defp a, do: Unknown.b()\n │ ~\n │\n └─ #{path}:3:23: Sample.a/0\n \"\"\"\n\n assert capture_eval(source) =~ expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"simple warning (line + file)\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"long-warning.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n defp a, do: Unknown.b()\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n │\n 3 │ defp a, do: Unknown.b()\n │ ~~~~~~~~~~~~~~~~~~~~~~~\n │\n └─ #{path}:3: Sample.a/0\n \"\"\"\n\n assert capture_eval(source, columns: false) =~ expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"simple warning with tabs (line + file)\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"long-warning.ex\")\n\n source = \"\"\"\n defmodule Sample do\n \\t@file \"#{path}\"\n \\tdefp a do\n \\t\\tUnknown.b()\n \\tend\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n │\n 4 │ \\t\\tUnknown.b()\n │ ~~~~~~~~~~~\n │\n └─ #{path}:4: Sample.a/0\n \"\"\"\n\n assert capture_eval(source, columns: false) =~ expected\n after\n purge(Sample)\n end\n\n test \"simple warning (no file)\" do\n source = \"\"\"\n defmodule Sample do\n defp a, do: Unknown.b()\n end\n \"\"\"\n\n expected = \"\"\"\n warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n └─ nofile:2:23: Sample.a/0\n \"\"\"\n\n assert capture_eval(source) =~ expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"IO.warn file+line\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"io-warn-file-line.ex\")\n\n source = \"\"\"\n IO.warn(\"oops\\\\nmulti\\\\nline\", file: __ENV__.file, line: __ENV__.line)\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: oops\n multi\n line\n │\n 1 │ IO.warn(\"oops\\\\nmulti\\\\nline\", file: __ENV__.file, line: __ENV__.line)\n │ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n │\n └─ tmp\\\n \"\"\"\n\n assert capture_io(:stderr, fn -> Code.eval_file(path) end) =~ expected\n end\n\n @tag :tmp_dir\n test \"IO.warn file+line+column\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"io-warn-file-line-column.ex\")\n\n source = \"\"\"\n IO.warn(\"oops\\\\nmulti\\\\nline\", file: __ENV__.file, line: __ENV__.line, column: 4)\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: oops\n multi\n line\n │\n 1 │ IO.warn(\"oops\\\\nmulti\\\\nline\", file: __ENV__.file, line: __ENV__.line, column: 4)\n │ ~\n │\n └─ tmp\\\n \"\"\"\n\n assert capture_io(:stderr, fn -> Code.eval_file(path) end) =~ expected\n end\n\n test \"IO.warn with missing data\" do\n assert capture_eval(\"\"\"\n IO.warn(\"oops-bad\", file: #{inspect(__ENV__.file)}, line: 3, column: nil)\n \"\"\") =~ \"warning: oops-bad\"\n\n assert capture_eval(\"\"\"\n IO.warn(\"oops-bad\", file: #{inspect(__ENV__.file)}, line: nil)\n \"\"\") =~ \"oops-bad\"\n\n assert capture_eval(\"\"\"\n IO.warn(\"oops-bad\", file: nil)\n \"\"\") =~ \"oops-bad\"\n end\n\n @tag :tmp_dir\n test \"trims lines if too many whitespaces\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"trim_warning_line.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def a do\n Unknown.bar(:test)\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: Unknown.bar/1 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n │\n 5 │ ... Unknown.bar(:test)\n │ ~\n │\n └─ #{path}:5:53: Sample.a/0\n\n \"\"\"\n\n assert capture_eval(source) == expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"handles unicode\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"warning_group_unicode.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def a do\n Unknown.bar(\"😎\")\n Unknown.bar(\"😎\")\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n assert capture_eval(source) =~ \"😎\"\n after\n purge(Sample)\n end\n end\n\n describe \"warning groups\" do\n test \"no file\" do\n source = \"\"\"\n defmodule Sample do\n def a do\n Unknown.bar()\n Unknown.bar()\n Unknown.bar()\n Unknown.bar()\n end\n end\n \"\"\"\n\n expected = \"\"\"\n warning: Unknown.bar/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n └─ nofile:3:13: Sample.a/0\n └─ nofile:4:13: Sample.a/0\n └─ nofile:5:13: Sample.a/0\n └─ nofile:6:13: Sample.a/0\n\n \"\"\"\n\n assert capture_eval(source) =~ expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"file + line + column\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"warning_group_nofile.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def a do\n Unknown.bar()\n Unknown.bar()\n Unknown.bar()\n Unknown.bar()\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: Unknown.bar/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n │\n 5 │ Unknown.bar()\n │ ~\n │\n └─ #{path}:5:13: Sample.a/0\n └─ #{path}:6:13: Sample.a/0\n └─ #{path}:7:13: Sample.a/0\n └─ #{path}:8:13: Sample.a/0\n\n \"\"\"\n\n assert capture_eval(source) == expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"file + line\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"warning_group_nofile.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def a do\n Unknown.bar()\n Unknown.bar()\n Unknown.bar()\n Unknown.bar()\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: Unknown.bar/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)\n │\n 5 │ Unknown.bar()\n │ ~~~~~~~~~~~~~\n │\n └─ #{path}:5: Sample.a/0\n └─ #{path}:6: Sample.a/0\n └─ #{path}:7: Sample.a/0\n └─ #{path}:8: Sample.a/0\n\n \"\"\"\n\n assert capture_eval(source, columns: false) == expected\n after\n purge(Sample)\n end\n end\n\n describe \"error diagnostics\" do\n @tag :tmp_dir\n test \"line only\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"error_line_only.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n def CamelCase do\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n error: function names should start with lowercase characters or underscore, invalid name CamelCase\n │\n 3 │ def CamelCase do\n │ ^^^^^^^^^^^^^^^^\n │\n └─ #{path}:3\n\n \"\"\"\n\n assert capture_compile(source, columns: false) == expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"shows span for unused variables\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"error_line_column.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def foo(unused_param) do\n :constant\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: variable \"unused_param\" is unused (if the variable is not meant to be used, prefix it with an underscore)\n │\n 4 │ def foo(unused_param) do\n │ ~~~~~~~~~~~~\n │\n └─ #{path}:4:11: Sample.foo/1\n\n \"\"\"\n\n assert capture_eval(source) == expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"shows span for undefined variables\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"undefined_variable_span.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def foo(a) do\n a - unknown_var\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n error: undefined variable \"unknown_var\"\n │\n 5 │ a - unknown_var\n │ ^^^^^^^^^^^\n │\n └─ #{path}:5:9: Sample.foo/1\n\n \"\"\"\n\n assert capture_compile(source) == expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"shows span for unknown local function calls\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"unknown_local_function_call.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def foo do\n _result = unknown_func_call!(:hello!)\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n error: undefined function unknown_func_call!/1 (expected Sample to define such a function or for it to be imported, but none are available)\n │\n 5 │ _result = unknown_func_call!(:hello!)\n │ ^^^^^^^^^^^^^^^^^^\n │\n └─ #{path}:5:15: Sample.foo/0\n\n \"\"\"\n\n assert capture_compile(source) == expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"line + column\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"error_line_column.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def foo do\n IO.puts(bar)\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n error: undefined variable \"bar\"\n │\n 5 │ IO.puts(bar)\n │ ^^^\n │\n └─ #{path}:5:13: Sample.foo/0\n\n \"\"\"\n\n assert capture_compile(source) == expected\n after\n purge(Sample)\n end\n\n test \"no file\" do\n expected = \"\"\"\n error: undefined function module_info/0 (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.module_info/0)\n └─ nofile:2:16: Sample.foo/0\n\n \"\"\"\n\n output =\n capture_compile(\"\"\"\n defmodule Sample do\n def foo, do: module_info()\n end\n \"\"\")\n\n assert expected == output\n after\n purge(Sample)\n end\n end\n\n describe \"warning diagnostics\" do\n @tag :tmp_dir\n test \"line only\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"warn_line.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n def a(unused), do: 1\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: variable \"unused\" is unused (if the variable is not meant to be used, prefix it with an underscore)\n │\n 3 │ def a(unused), do: 1\n │ ~~~~~~~~~~~~~~~~~~~~\n │\n └─ #{path}:3: Sample.a/1\n\n \"\"\"\n\n assert capture_eval(source, columns: false) == expected\n after\n purge(Sample)\n end\n\n @tag :tmp_dir\n test \"line + column\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"warn_line_column.ex\")\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n @foo 1\n\n def bar do\n @foo\n :ok\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n expected = \"\"\"\n warning: module attribute @foo in code block has no effect as it is never returned (remove the attribute or assign it to _ to avoid warnings)\n │\n 6 │ @foo\n │ ~\n │\n └─ #{path}:6:5: Sample.bar/0\n\n \"\"\"\n\n assert capture_eval(source) == expected\n after\n purge(Sample)\n end\n\n test \"no file\" do\n expected = \"\"\"\n warning: unused alias List\n └─ nofile:2:3\n\n \"\"\"\n\n output =\n capture_eval(\"\"\"\n defmodule Sample do\n alias :lists, as: List\n import MapSet\n new()\n end\n \"\"\")\n\n assert output == expected\n after\n purge(Sample)\n end\n end\n\n describe \"Code.print_diagnostic\" do\n @tag :tmp_dir\n test \"handles diagnostic with span\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"diagnostic_length.ex\")\n\n diagnostic = %{\n file: path,\n severity: :error,\n message: \"Diagnostic span test\",\n stacktrace: [],\n position: {4, 7},\n span: {4, 10},\n compiler_name: \"Elixir\"\n }\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def bar do\n nil\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n result =\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n Code.print_diagnostic(diagnostic)\n end)\n\n assert result == \"\"\"\n error: Diagnostic span test\n │\n 4 │ def bar do\n │ ^^^\n │\n └─ #{path}:4:7\n\n \"\"\"\n end\n\n @tag :tmp_dir\n test \"prints single marker for multiline diagnostic\", %{tmp_dir: tmp_dir} do\n path = make_relative_tmp(tmp_dir, \"diagnostic_length.ex\")\n\n diagnostic = %{\n file: path,\n severity: :error,\n message: \"Diagnostic span test\",\n stacktrace: [],\n position: {4, 7},\n span: {5, 2},\n compiler_name: \"Elixir\"\n }\n\n source = \"\"\"\n defmodule Sample do\n @file \"#{path}\"\n\n def bar do\n nil\n end\n end\n \"\"\"\n\n File.write!(path, source)\n\n result =\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n Code.print_diagnostic(diagnostic)\n end)\n\n assert result == \"\"\"\n error: Diagnostic span test\n │\n 4 │ def bar do\n │ ^\n │\n └─ #{path}:4:7\n\n \"\"\"\n end\n end\n\n defp make_relative_tmp(tmp_dir, filename) do\n # Compiler outputs relative, so we just grab the tmp dir\n tmp_dir\n |> Path.join(filename)\n |> Path.relative_to_cwd()\n end\n\n defp capture_eval(source, opts \\\\ [columns: true]) do\n capture_io(:stderr, fn ->\n quoted = Code.string_to_quoted!(source, opts)\n Code.eval_quoted(quoted)\n end)\n end\n\n defp capture_compile(source, opts \\\\ [columns: true]) do\n capture_io(:stderr, fn ->\n assert_raise CompileError, fn ->\n ast = Code.string_to_quoted!(source, opts)\n Code.eval_quoted(ast)\n end\n end)\n end\n\n defp capture_raise(source, exception, opts \\\\ []) do\n {stacktrace, opts} = Keyword.pop(opts, :stacktrace, [])\n\n e =\n assert_raise exception, fn ->\n ast = Code.string_to_quoted!(source, [columns: true] ++ opts)\n Code.eval_quoted(ast)\n end\n\n Exception.format(:error, e, stacktrace)\n end\n\n defp purge(module) when is_atom(module) do\n :code.purge(module)\n :code.delete(module)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/dialyzer_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.DialyzerTest do\n use ExUnit.Case, async: true\n\n @moduletag :dialyzer\n @moduletag :require_ast\n import PathHelpers\n\n setup_all do\n dir = tmp_path(\"dialyzer\")\n File.rm_rf!(dir)\n File.mkdir_p!(dir)\n\n plt =\n dir\n |> Path.join(\"base_plt\")\n |> String.to_charlist()\n\n # Some OSs (like Windows) do not provide the HOME environment variable.\n if !System.get_env(\"HOME\") do\n System.put_env(\"HOME\", System.user_home())\n end\n\n # Add a few key Elixir modules for types and macro functions\n mods = [\n :elixir,\n :elixir_env,\n :elixir_erl_pass,\n :inet,\n :maps,\n :sets,\n ArgumentError,\n Atom,\n Code,\n EEx,\n Enum,\n Exception,\n ExUnit.AssertionError,\n ExUnit.Assertions,\n IO,\n Kernel,\n Kernel.Utils,\n List,\n Macro,\n Macro.Env,\n MapSet,\n Module,\n Protocol,\n String,\n String.Chars,\n Task,\n Task.Supervisor,\n URI\n ]\n\n files = Enum.map(mods, &:code.which/1)\n dialyzer_run(analysis_type: :plt_build, output_plt: plt, apps: [:erts], files: files)\n\n # Compile Dialyzer fixtures\n source_files = Path.wildcard(Path.join(fixture_path(\"dialyzer\"), \"*\"))\n\n {:ok, _, _} =\n Kernel.ParallelCompiler.compile_to_path(source_files, dir, return_diagnostics: true)\n\n {:ok, [base_dir: dir, base_plt: plt]}\n end\n\n setup context do\n dir = String.to_charlist(context.tmp_dir)\n\n plt =\n dir\n |> Path.join(\"plt\")\n |> String.to_charlist()\n\n File.cp!(context.base_plt, plt)\n warnings = Map.get(context, :warnings, [])\n\n dialyzer = [\n analysis_type: :succ_typings,\n check_plt: false,\n files_rec: [dir],\n plts: [plt],\n warnings: warnings\n ]\n\n {:ok, [outdir: dir, dialyzer: dialyzer]}\n end\n\n @moduletag :tmp_dir\n\n @tag warnings: [:specdiffs]\n test \"no warnings on specdiffs\", context do\n copy_beam!(context, Dialyzer.RemoteCall)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on valid remote calls\", context do\n copy_beam!(context, Dialyzer.RemoteCall)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on rewrites\", context do\n copy_beam!(context, Dialyzer.Rewrite)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on raise\", context do\n copy_beam!(context, Dialyzer.Raise)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on in range\", context do\n copy_beam!(context, Dialyzer.InRange)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on macrocallback\", context do\n copy_beam!(context, Dialyzer.Macrocallback)\n copy_beam!(context, Dialyzer.Macrocallback.Impl)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on callback\", context do\n copy_beam!(context, Dialyzer.Callback)\n copy_beam!(context, Dialyzer.Callback.ImplAtom)\n copy_beam!(context, Dialyzer.Callback.ImplList)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on and/2 and or/2\", context do\n copy_beam!(context, Dialyzer.BooleanCheck)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on cond\", context do\n copy_beam!(context, Dialyzer.Cond)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on for comprehensions with bitstrings\", context do\n copy_beam!(context, Dialyzer.ForBitstring)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on for falsy check that always boolean\", context do\n copy_beam!(context, Dialyzer.ForBooleanCheck)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on with/else\", context do\n copy_beam!(context, Dialyzer.With)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on with when else has a no_return type\", context do\n copy_beam!(context, Dialyzer.WithNoReturn)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on with when multiple else clauses and one is a no_return\", context do\n copy_beam!(context, Dialyzer.WithThrowingElse)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on defmacrop\", context do\n copy_beam!(context, Dialyzer.Defmacrop)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warnings on try\", context do\n copy_beam!(context, Dialyzer.Try)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warning on is_struct/2\", context do\n copy_beam!(context, Dialyzer.IsStruct)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warning on ExUnit assertions\", context do\n copy_beam!(context, Dialyzer.Assertions)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warning due to opaqueness edge cases\", context do\n copy_beam!(context, Dialyzer.Opaqueness)\n assert_dialyze_no_warnings!(context)\n end\n\n test \"no warning in various non-regression cases\", context do\n copy_beam!(context, Dialyzer.Regressions)\n assert_dialyze_no_warnings!(context)\n end\n\n defp copy_beam!(context, module) do\n name = \"#{module}.beam\"\n File.cp!(Path.join(context.base_dir, name), Path.join(context.outdir, name))\n end\n\n defp assert_dialyze_no_warnings!(context) do\n case dialyzer_run(context.dialyzer) do\n [] ->\n :ok\n\n warnings ->\n formatted = for warn <- warnings, do: [:dialyzer.format_warning(warn), ?\\n]\n formatted |> IO.chardata_to_string() |> flunk()\n end\n end\n\n defp dialyzer_run(opts) do\n try do\n :dialyzer.run(opts)\n catch\n :throw, {:dialyzer_error, chardata} ->\n raise \"dialyzer error: \" <> IO.chardata_to_string(chardata)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/docs_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.DocsTest do\n use ExUnit.Case\n\n import PathHelpers\n\n defmacro wrong_doc_baz do\n quote do\n @doc \"Wrong doc\"\n @doc since: \"1.2\"\n def baz(_arg)\n def baz(arg), do: arg + 1\n end\n end\n\n test \"attributes format\" do\n defmodule DocAttributes do\n @moduledoc \"Module doc\"\n assert @moduledoc == \"Module doc\"\n assert Module.get_attribute(__MODULE__, :moduledoc) == {__ENV__.line - 2, \"Module doc\"}\n\n @typedoc \"Type doc\"\n assert @typedoc == \"Type doc\"\n assert Module.get_attribute(__MODULE__, :typedoc) == {__ENV__.line - 2, \"Type doc\"}\n @type foobar :: any\n\n @doc \"Function doc\"\n assert @doc == \"Function doc\"\n assert Module.get_attribute(__MODULE__, :doc) == {__ENV__.line - 2, \"Function doc\"}\n\n def foobar() do\n :ok\n end\n end\n end\n\n test \"compiled without docs\" do\n Code.compiler_options(docs: false)\n\n write_beam(\n defmodule WithoutDocs do\n @moduledoc \"Module doc\"\n\n @doc \"Some doc\"\n def foobar(arg), do: arg\n end\n )\n\n assert Code.fetch_docs(WithoutDocs) == {:error, :chunk_not_found}\n after\n Code.compiler_options(docs: true)\n end\n\n test \"compiled in memory does not have accessible docs\" do\n defmodule InMemoryDocs do\n @moduledoc \"Module doc\"\n\n @doc \"Some doc\"\n def foobar(arg), do: arg\n end\n\n assert Code.fetch_docs(InMemoryDocs) == {:error, :module_not_found}\n end\n\n test \"non-existent beam file\" do\n assert {:error, :module_not_found} = Code.fetch_docs(\"bad.beam\")\n end\n\n test \"raises on invalid @doc since: ...\" do\n assert_raise ArgumentError, ~r\"should be a string representing the version\", fn ->\n defmodule InvalidSince do\n @doc since: 1.2\n def foo, do: :bar\n end\n end\n end\n\n test \"raises on invalid @doc\" do\n assert_raise ArgumentError, ~r/When set dynamically, it should be {line, doc}/, fn ->\n defmodule DocAttributesFormat do\n Module.put_attribute(__MODULE__, :moduledoc, \"Other\")\n end\n end\n\n message = ~r/should be either false, nil, a string, or a keyword list/\n\n assert_raise ArgumentError, message, fn ->\n defmodule AtSyntaxDocAttributesFormat do\n @moduledoc :not_a_binary\n end\n end\n\n assert_raise ArgumentError, message, fn ->\n defmodule AtSyntaxDocAttributesFormat do\n @moduledoc true\n end\n end\n end\n\n describe \"compiled with docs\" do\n test \"infers signatures\" do\n write_beam(\n defmodule SignatureDocs do\n def arg_names([], [], %{}, [], %{}), do: false\n\n @year 2015\n def with_defaults(@year, arg \\\\ 0, year \\\\ @year, fun \\\\ &>=/2) do\n {fun, arg + year}\n end\n\n def with_map_and_default(%{key: value} \\\\ %{key: :default}), do: value\n def with_struct(%URI{}), do: :ok\n\n def with_underscore({_, _} = _two_tuple), do: :ok\n def with_underscore(_), do: :error\n\n def only_underscore(_), do: :ok\n\n def two_good_names(first, :ok), do: first\n def two_good_names(second, :error), do: second\n\n def really_long_signature(\n really_long_var_named_one,\n really_long_var_named_two,\n really_long_var_named_three\n ) do\n {really_long_var_named_one, really_long_var_named_two, really_long_var_named_three}\n end\n end\n )\n\n assert {:docs_v1, _, :elixir, _, _, _, docs} = Code.fetch_docs(SignatureDocs)\n signatures = for {{:function, n, a}, _, signature, _, %{}} <- docs, do: {{n, a}, signature}\n\n assert [\n arg_names,\n only_underscore,\n really_long_signature,\n two_good_names,\n with_defaults,\n with_map_and_default,\n with_struct,\n with_underscore\n ] = Enum.sort(signatures)\n\n # arg_names/5\n assert {{:arg_names, 5}, [\"arg_names(list1, list2, map1, list3, map2)\"]} = arg_names\n\n # only_underscore/1\n assert {{:only_underscore, 1}, [\"only_underscore(_)\"]} = only_underscore\n\n # really_long_signature/3\n assert {{:really_long_signature, 3},\n [\n \"really_long_signature(really_long_var_named_one, really_long_var_named_two, really_long_var_named_three)\"\n ]} = really_long_signature\n\n # two_good_names/2\n assert {{:two_good_names, 2}, [\"two_good_names(first, atom)\"]} = two_good_names\n\n # with_defaults/4\n assert {{:with_defaults, 4},\n [\"with_defaults(int, arg \\\\\\\\ 0, year \\\\\\\\ 2015, fun \\\\\\\\ &>=/2)\"]} = with_defaults\n\n # with_map_and_default/1\n assert {{:with_map_and_default, 1}, [\"with_map_and_default(map \\\\\\\\ %{key: :default})\"]} =\n with_map_and_default\n\n # with_struct/1\n assert {{:with_struct, 1}, [\"with_struct(uri)\"]} = with_struct\n\n # with_underscore/1\n assert {{:with_underscore, 1}, [\"with_underscore(two_tuple)\"]} = with_underscore\n end\n\n test \"includes docs for functions, modules, types and callbacks\" do\n line = __ENV__.line\n\n write_beam(\n defmodule SampleDocs do\n @moduledoc \"Module doc\"\n @moduledoc authors: \"Elixir Contributors\", purpose: :test\n\n @doc \"My struct\"\n defstruct [:sample]\n\n @typedoc \"Type doc\"\n @typedoc since: \"1.2.3\", color: :red\n @type foo(any) :: any\n\n @typedoc \"Opaque type doc\"\n @opaque bar(any) :: any\n\n @doc \"Callback doc\"\n @doc since: \"1.2.3\", color: :red, deprecated: \"use baz/2 instead\"\n @doc color: :blue, stable: true\n @callback foo(any) :: any\n\n @doc false\n @doc since: \"1.2.3\"\n @callback bar() :: term\n @callback baz(any, term) :: any\n\n @doc \"Callback with multiple clauses\"\n @callback callback_multi(integer) :: integer\n @callback callback_multi(atom) :: atom\n\n @doc \"Macrocallback doc\"\n @macrocallback qux(any) :: any\n\n @doc \"Macrocallback with multiple clauses\"\n @macrocallback macrocallback_multi(integer) :: integer\n @macrocallback macrocallback_multi(atom) :: atom\n\n @doc \"Function doc\"\n @doc since: \"1.2.3\", color: :red\n @doc color: :blue, stable: true\n @deprecated \"use baz/2 instead\"\n def foo(arg \\\\ 0), do: arg + 1\n\n @doc \"Multiple function head doc\"\n @deprecated \"something else\"\n def bar(_arg)\n def bar(arg), do: arg + 1\n\n require Kernel.DocsTest\n Kernel.DocsTest.wrong_doc_baz()\n\n @doc \"Multiple function head and docs\"\n @doc since: \"1.2.3\"\n def baz(_arg)\n\n @doc false\n def qux(true), do: false\n\n @doc \"A guard\"\n defguard is_zero(v) when v == 0\n\n # We do this to avoid the deprecation warning.\n module = Module\n module.add_doc(__MODULE__, __ENV__.line, :def, {:nullary, 0}, [], \"add_doc\")\n def nullary, do: 0\n\n defmodule SampleBehaviour do\n @callback foo(any()) :: any()\n end\n\n @behaviour SampleBehaviour\n end\n )\n\n assert {:docs_v1, _, :elixir, \"text/markdown\", %{\"en\" => module_doc}, module_doc_meta, docs} =\n Code.fetch_docs(SampleDocs)\n\n assert module_doc == \"Module doc\"\n\n file = String.to_charlist(__ENV__.file)\n\n source_annos = [:erl_anno.new({line + 3, 19})]\n\n assert %{\n # Generated meta\n source_path: ^file,\n source_annos: ^source_annos,\n behaviours: [SampleDocs.SampleBehaviour],\n # User meta\n authors: \"Elixir Contributors\",\n purpose: :test\n } = module_doc_meta\n\n [\n callback_bar,\n callback_baz,\n callback_multi,\n callback_foo,\n function_struct_0,\n function_struct_1,\n function_bar,\n function_baz,\n function_foo,\n function_nullary,\n function_qux,\n guard_is_zero,\n macrocallback_multi,\n macrocallback_qux,\n type_bar,\n type_foo\n ] = Enum.sort(docs)\n\n assert {{:callback, :bar, 0}, _, [], :hidden, %{}} = callback_bar\n assert {{:callback, :baz, 2}, _, [], :none, %{}} = callback_baz\n\n source_annos = [:erl_anno.new({line + 20, 21})]\n\n assert {{:callback, :foo, 1}, _, [], %{\"en\" => \"Callback doc\"},\n %{\n source_annos: ^source_annos,\n since: \"1.2.3\",\n deprecated: \"use baz/2 instead\",\n color: :blue,\n stable: true\n }} = callback_foo\n\n assert {{:callback, :callback_multi, 1}, _, [], %{\"en\" => \"Callback with multiple clauses\"},\n %{}} = callback_multi\n\n assert {{:function, :__struct__, 0}, _, [\"%Kernel.DocsTest.SampleDocs{}\"],\n %{\"en\" => \"My struct\"}, %{}} = function_struct_0\n\n assert {{:function, :__struct__, 1}, _, [\"__struct__(kv)\"], :hidden, %{}} =\n function_struct_1\n\n assert {{:function, :bar, 1}, _, [\"bar(arg)\"], %{\"en\" => \"Multiple function head doc\"},\n %{deprecated: \"something else\"}} = function_bar\n\n assert {{:function, :baz, 1}, _, [\"baz(arg)\"], %{\"en\" => \"Multiple function head and docs\"},\n %{since: \"1.2.3\"}} = function_baz\n\n source_annos = [:erl_anno.new({line + 42, 15})]\n\n assert {{:function, :foo, 1}, _, [\"foo(arg \\\\\\\\ 0)\"], %{\"en\" => \"Function doc\"},\n %{\n source_annos: ^source_annos,\n since: \"1.2.3\",\n deprecated: \"use baz/2 instead\",\n color: :blue,\n stable: true,\n defaults: 1\n }} = function_foo\n\n assert {{:function, :nullary, 0}, _, [\"nullary()\"], %{\"en\" => \"add_doc\"}, %{}} =\n function_nullary\n\n assert {{:function, :qux, 1}, _, [\"qux(bool)\"], :hidden, %{}} = function_qux\n\n source_annos = [:erl_anno.new({line + 60, 20})]\n\n assert {{:macro, :is_zero, 1}, _, [\"is_zero(v)\"], %{\"en\" => \"A guard\"},\n %{source_annos: ^source_annos, guard: true}} = guard_is_zero\n\n assert {{:macrocallback, :macrocallback_multi, 1}, _, [],\n %{\"en\" => \"Macrocallback with multiple clauses\"}, %{}} = macrocallback_multi\n\n assert {{:macrocallback, :qux, 1}, _, [], %{\"en\" => \"Macrocallback doc\"}, %{}} =\n macrocallback_qux\n\n assert {{:type, :bar, 1}, _, [], %{\"en\" => \"Opaque type doc\"}, %{opaque: true}} = type_bar\n\n source_annos = [:erl_anno.new({line + 12, 17})]\n\n assert {{:type, :foo, 1}, _, [], %{\"en\" => \"Type doc\"},\n %{\n source_annos: ^source_annos,\n since: \"1.2.3\",\n color: :red\n }} = type_foo\n end\n end\n\n test \"fetch docs chunk from doc/chunks\" do\n Code.compiler_options(docs: false)\n\n doc_chunks_path = Path.join([tmp_path(), \"doc\", \"chunks\"])\n File.rm_rf!(doc_chunks_path)\n File.mkdir_p!(doc_chunks_path)\n\n write_beam(\n defmodule ExternalDocs do\n end\n )\n\n assert Code.fetch_docs(ExternalDocs) == {:error, :chunk_not_found}\n\n path = Path.join([doc_chunks_path, \"#{ExternalDocs}.chunk\"])\n chunk = {:docs_v1, 1, :elixir, \"text/markdown\", %{\"en\" => \"Some docs\"}, %{}}\n File.write!(path, :erlang.term_to_binary(chunk))\n\n assert Code.fetch_docs(ExternalDocs) == chunk\n after\n Code.compiler_options(docs: true)\n end\n\n test \"@impl true doesn't set @doc false if previous implementation has docs\" do\n write_beam(\n defmodule Docs do\n defmodule SampleBehaviour do\n @callback foo(any()) :: any()\n @callback bar() :: any()\n @callback baz() :: any()\n end\n\n @behaviour SampleBehaviour\n\n @doc \"Foo docs\"\n def foo(nil), do: nil\n\n @impl true\n def foo(_), do: false\n\n @impl true\n def bar(), do: true\n\n @doc \"Baz docs\"\n @impl true\n def baz(), do: true\n\n def fuz(), do: true\n end\n )\n\n {:docs_v1, _, _, _, _, _, docs} = Code.fetch_docs(Docs)\n function_docs = for {{:function, name, arity}, _, _, doc, _} <- docs, do: {{name, arity}, doc}\n\n assert [\n {{:bar, 0}, :hidden},\n {{:baz, 0}, %{\"en\" => \"Baz docs\"}},\n {{:foo, 1}, %{\"en\" => \"Foo docs\"}},\n {{:fuz, 0}, :none}\n ] = Enum.sort(function_docs)\n end\n\n test \"generated functions are annotated as such\" do\n line = __ENV__.line\n\n write_beam(\n defmodule ToBeUsed do\n defmacro __using__(_) do\n quote generated: true do\n @doc \"Hello\"\n def foo, do: :bar\n end\n end\n end\n )\n\n write_beam(\n defmodule WillBeUsing do\n use ToBeUsed\n end\n )\n\n {:docs_v1, _, _, _, _, _, docs} = Code.fetch_docs(WillBeUsing)\n\n doc_anno = :erl_anno.new(line + 15)\n source_anno = :erl_anno.set_generated(true, :erl_anno.new(line + 15))\n\n assert [\n {{:function, :foo, 0}, ^doc_anno, [\"foo()\"], %{\"en\" => \"Hello\"},\n %{source_annos: [^source_anno]}}\n ] = docs\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/errors_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.ErrorsTest do\n use ExUnit.Case, async: true\n\n defmacro hello(_) do\n quote location: :keep do\n def hello, do: :world\n end\n end\n\n test \"no default arguments in fn\" do\n assert_compile_error(\n [\"nofile:1:1\", \"anonymous functions cannot have optional arguments\"],\n ~c\"fn x \\\\\\\\ 1 -> x end\"\n )\n\n assert_compile_error(\n [\"nofile:1:1\", \"anonymous functions cannot have optional arguments\"],\n ~c\"fn x, y \\\\\\\\ 1 -> x + y end\"\n )\n end\n\n test \"invalid __CALLER__\" do\n assert_compile_error(\n [\"nofile:1:34\", \"__CALLER__ is available only inside defmacro and defmacrop\"],\n ~c\"defmodule Sample do def hello do __CALLER__ end end\"\n )\n end\n\n test \"invalid __STACKTRACE__\" do\n assert_compile_error(\n [\n \"nofile:1:34\",\n \"__STACKTRACE__ is available only inside catch and rescue clauses of try expressions\"\n ],\n ~c\"defmodule Sample do def hello do __STACKTRACE__ end end\"\n )\n\n assert_compile_error(\n [\n \"nofile:1:66\",\n \"__STACKTRACE__ is available only inside catch and rescue clauses of try expressions\"\n ],\n ~c\"defmodule Sample do try do raise \\\"oops\\\" rescue _ -> def hello do __STACKTRACE__ end end end\"\n )\n end\n\n test \"undefined function\" do\n assert_compile_error(\n [\n \"hello.ex:4:5: \",\n \"undefined function bar/0 (expected Kernel.ErrorsTest.BadForm to define such a function or for it to be imported, but none are available)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.BadForm do\n @file \"hello.ex\"\n def foo do\n bar()\n end\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\n \"nofile:2:16\",\n \"undefined function module_info/0 (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.module_info/0)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.Info do\n def foo, do: module_info()\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\n \"nofile:3:16\",\n \"undefined function behaviour_info/1 (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.behaviour_info/1)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.BehaviourInfo do\n @callback dummy() :: :ok\n def foo, do: behaviour_info(:callbacks)\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\n \"nofile:3:5\",\n \"undefined function bar/1 (expected Kernel.ErrorsTest.BadForm to define such a function or for it to be imported, but none are available)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.BadForm do\n def foo do\n bar(\n baz(1, 2)\n )\n end\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\n \"nofile:8:5\",\n \"undefined function baz/0 (expected Sample to define such a function or for it to be imported, but none are available)\"\n ],\n ~c\"\"\"\n defmodule Sample do\n def foo do\n bar()\n end\n\n defoverridable [foo: 0]\n def foo do\n baz()\n end\n end\n \"\"\"\n )\n end\n\n test \"undefined function within unused function\" do\n assert_compile_error(\n [\"nofile:2:8\", \"undefined function bar/0\"],\n ~c\"\"\"\n defmodule Sample do\n defp foo, do: bar()\n end\n \"\"\"\n )\n end\n\n test \"undefined non-local function\" do\n assert_compile_error(\n [\"nofile:1:1\", \"undefined function call/2 (there is no such import)\"],\n ~c\"call foo, do: :foo\"\n )\n end\n\n test \"undefined variables\" do\n assert_compile_error(\n [\"nofile:3:13\", \"undefined variable \\\"bar\\\"\", \"nofile:4:13\", \"undefined variable \\\"baz\\\"\"],\n ~c\"\"\"\n defmodule Sample do\n def foo do\n IO.puts bar\n IO.puts baz\n end\n end\n \"\"\"\n )\n end\n\n test \"cascading from undefined variables\" do\n # Test that we show undefined modules/functions/macros on variable failure,\n # as sometimes the variable failure come from a missing module or require\n assert_compile_error(\n [\n \"nofile:3:23\",\n \"undefined variable \\\"bar\\\"\",\n \"nofile:3:19\",\n \"function UnknownModule.foo/1 is undefined (module UnknownModule is not available)\"\n ],\n ~c\"\"\"\n defmodule Sample do\n def foo do\n UnknownModule.foo(bar)\n end\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\n \"nofile:3:20\",\n \"undefined variable \\\"bar\\\"\",\n \"nofile:3:16\",\n \"function Enumerable.foo/1 is undefined or private\"\n ],\n ~c\"\"\"\n defmodule Sample do\n def foo do\n Enumerable.foo(bar)\n end\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\n \"nofile:3:29\",\n \"undefined variable \\\"bar\\\"\",\n \"nofile:3:23\",\n \"function Kernel.ErrorsTest.hello/1 is undefined or private\",\n \"there is a macro with the same name and arity\"\n ],\n ~c\"\"\"\n defmodule Sample do\n def foo do\n Kernel.ErrorsTest.hello(bar)\n end\n end\n \"\"\"\n )\n end\n\n test \"recursive variables on definition\" do\n assert_compile_error(\n [\n \"nofile:2:7: \",\n \"recursive variable definition in patterns:\",\n \"foo(x = y, y = z, z = x)\",\n \"the following variables form a cycle: \\\"x\\\", \\\"y\\\", \\\"z\\\"\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.RecursiveVars do\n def foo(x = y, y = z, z = x), do: {x, y, z}\n end\n \"\"\"\n )\n end\n\n test \"function without definition\" do\n assert_compile_error(\n [\"nofile:2:7: \", \"implementation not provided for predefined def foo/0\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.FunctionWithoutDefinition do\n def foo\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:10: \", \"implementation not provided for predefined def example/2\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.FunctionTemplate do\n defmacro __using__(_) do\n quote do\n def example(foo, bar \\\\\\\\ [])\n end\n end\n end\n\n defmodule Kernel.ErrorsTest.UseFunctionTemplate do\n use Kernel.ErrorsTest.FunctionTemplate\n end\n \"\"\"\n )\n end\n\n test \"guard without definition\" do\n assert_compile_error(\n [\"nofile:2:12: \", \"implementation not provided for predefined defmacro foo/1\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.GuardWithoutDefinition do\n defguard foo(bar)\n end\n \"\"\"\n )\n end\n\n test \"literal on map and struct\" do\n assert_compile_error(\n [\"nofile:1:10\", \"expected key-value pairs in a map, got: put_in(foo.bar.baz, nil)\"],\n ~c\"foo = 1; %{put_in(foo.bar.baz, nil), foo}\"\n )\n end\n\n test \"struct fields on defstruct\" do\n assert_eval_raise ArgumentError, [\"struct field names must be atoms, got: 1\"], ~c\"\"\"\n defmodule Kernel.ErrorsTest.StructFieldsOnDefstruct do\n defstruct [1, 2, 3]\n end\n \"\"\"\n end\n\n test \"struct access on body\" do\n assert_compile_error(\n [\n \"nofile:3:3\",\n \"cannot access struct Kernel.ErrorsTest.StructAccessOnBody, \" <>\n \"the struct was not yet defined or the struct \" <>\n \"is being accessed in the same context that defines it\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.StructAccessOnBody do\n defstruct %{name: \"Brasilia\"}\n %Kernel.ErrorsTest.StructAccessOnBody{}\n end\n \"\"\"\n )\n end\n\n describe \"struct errors\" do\n test \"bad errors\" do\n assert_compile_error(\n [\"nofile:1:1\", \"BadStruct.__struct__/1 is undefined, cannot expand struct BadStruct\"],\n ~c\"%BadStruct{}\"\n )\n\n assert_compile_error(\n [\"nofile:1:1\", \"BadStruct.__struct__/1 is undefined, cannot expand struct BadStruct\"],\n ~c\"%BadStruct{} = %{}\"\n )\n\n bad_struct_type_error =\n ~r\"expected Kernel.ErrorsTest.BadStructType.__struct__/(0|1) to return a map.*, got: :invalid\"\n\n defmodule BadStructType do\n def __struct__, do: :invalid\n def __struct__(_), do: :invalid\n end\n\n assert_compile_error(bad_struct_type_error, ~c\"%#{BadStructType}{}\")\n\n assert_raise ArgumentError, bad_struct_type_error, fn ->\n struct(BadStructType)\n end\n\n assert_raise ArgumentError, bad_struct_type_error, fn ->\n struct(BadStructType, foo: 1)\n end\n end\n\n test \"bad struct on module conflict\" do\n Code.put_compiler_option(:ignore_module_conflict, true)\n\n assert_compile_error(~r'MissingStructOnReload\\.__struct__/1 is undefined', ~c'''\n defmodule MissingStructOnReload do\n defstruct [:title]\n def d(), do: %MissingStructOnReload{}\n end\n\n defmodule MissingStructOnReload do\n def d(), do: %MissingStructOnReload{}\n end\n ''')\n after\n Code.put_compiler_option(:ignore_module_conflict, false)\n end\n\n test \"missing struct key\" do\n missing_struct_key_error =\n ~r\"expected Kernel.ErrorsTest.MissingStructKey.__struct__/(0|1) to return a map.*, got: %\\{\\}\"\n\n defmodule MissingStructKey do\n def __struct__, do: %{}\n def __struct__(_), do: %{}\n end\n\n assert_compile_error(missing_struct_key_error, ~c\"%#{MissingStructKey}{}\")\n\n assert_raise ArgumentError, missing_struct_key_error, fn ->\n struct(MissingStructKey)\n end\n\n assert_raise ArgumentError, missing_struct_key_error, fn ->\n struct(MissingStructKey, foo: 1)\n end\n\n invalid_struct_key_error =\n ~r\"expected Kernel.ErrorsTest.InvalidStructKey.__struct__/(0|1) to return a map.*, got: %\\{__struct__: 1\\}\"\n\n defmodule InvalidStructKey do\n def __struct__, do: %{__struct__: 1}\n def __struct__(_), do: %{__struct__: 1}\n end\n\n assert_compile_error(invalid_struct_key_error, ~c\"%#{InvalidStructKey}{}\")\n\n assert_raise ArgumentError, invalid_struct_key_error, fn ->\n struct(InvalidStructKey)\n end\n\n assert_raise ArgumentError, invalid_struct_key_error, fn ->\n struct(InvalidStructKey, foo: 1)\n end\n end\n\n test \"invalid struct\" do\n invalid_struct_name_error =\n ~r\"expected struct name returned by Kernel.ErrorsTest.InvalidStructName.__struct__/(0|1) to be Kernel.ErrorsTest.InvalidStructName, got: InvalidName\"\n\n defmodule InvalidStructName do\n def __struct__, do: %{__struct__: InvalidName}\n def __struct__(_), do: %{__struct__: InvalidName}\n end\n\n assert_compile_error(invalid_struct_name_error, ~c\"%#{InvalidStructName}{}\")\n\n assert_raise ArgumentError, invalid_struct_name_error, fn ->\n struct(InvalidStructName)\n end\n\n assert_raise ArgumentError, invalid_struct_name_error, fn ->\n struct(InvalidStructName, foo: 1)\n end\n end\n\n test \"good struct\" do\n defmodule GoodStruct do\n defstruct name: \"john\"\n end\n\n assert_eval_raise KeyError,\n [\"key :age not found\"],\n ~c\"%#{GoodStruct}{age: 27}\"\n\n assert_compile_error(\n [\"nofile:1:1\", \"unknown key :age for struct Kernel.ErrorsTest.GoodStruct\"],\n ~c\"%#{GoodStruct}{age: 27} = %{}\"\n )\n end\n\n test \"enforce @enforce_keys\" do\n defmodule EnforceKeys do\n @enforce_keys [:foo]\n defstruct(foo: nil)\n end\n\n assert_raise ArgumentError,\n \"@enforce_keys required keys ([:fo, :bar]) that are not defined in defstruct: [foo: nil]\",\n fn ->\n defmodule EnforceKeysError do\n @enforce_keys [:foo, :fo, :bar]\n defstruct(foo: nil)\n end\n end\n end\n end\n\n test \"invalid unquote\" do\n assert_compile_error([\"nofile:1:1\", \"unquote called outside quote\"], ~c\"unquote 1\")\n end\n\n test \"invalid unquote splicing in one-liners\" do\n assert_eval_raise ArgumentError,\n [\n \"unquote_splicing only works inside arguments and block contexts, \" <>\n \"wrap it in parens if you want it to work with one-liners\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.InvalidUnquoteSplicingInOneliners do\n defmacro oneliner2 do\n quote do: unquote_splicing 1\n end\n\n def callme do\n oneliner2\n end\n end\n \"\"\"\n end\n\n test \"invalid attribute\" do\n msg = ~r\"cannot inject attribute @foo into function/macro because cannot escape \"\n\n assert_raise ArgumentError, msg, fn ->\n defmodule InvalidAttribute do\n @foo fn -> nil end\n def bar, do: @foo\n end\n end\n end\n\n test \"typespec attributes set via Module.put_attribute/4\" do\n message =\n \"attributes type, typep, opaque, spec, callback, and macrocallback \" <>\n \"must be set directly via the @ notation\"\n\n for kind <- [:type, :typep, :opaque, :spec, :callback, :macrocallback] do\n assert_eval_raise ArgumentError,\n [message],\n \"\"\"\n defmodule PutTypespecAttribute do\n Module.put_attribute(__MODULE__, #{inspect(kind)}, {})\n end\n \"\"\"\n end\n end\n\n test \"invalid struct field value\" do\n msg = ~r\"invalid default value for struct field baz, cannot escape \"\n\n assert_raise ArgumentError, msg, fn ->\n defmodule InvalidStructFieldValue do\n defstruct baz: fn -> nil end\n end\n end\n end\n\n test \"invalid case clauses\" do\n assert_compile_error(\n [\"nofile:1:37\", \"expected one argument for \\\"do\\\" clauses (->) in \\\"case\\\"\"],\n ~c\"case nil do 0, z when not is_nil(z) -> z end\"\n )\n end\n\n test \"invalid fn args\" do\n exception =\n assert_eval_raise TokenMissingError,\n [\n \"nofile:1:5:\",\n ~r/missing terminator: end/\n ],\n ~c\"fn 1\"\n\n assert exception.opening_delimiter == :fn\n end\n\n test \"invalid escape\" do\n assert_eval_raise TokenMissingError,\n [\"nofile:1:3:\", \"invalid escape \\\\ at end of file\"],\n ~c\"1 \\\\\"\n end\n\n test \"show snippet on missing tokens\" do\n assert_eval_raise TokenMissingError,\n [\n \"nofile:1:25:\",\n \"missing terminator: end\",\n \"defmodule ShowSnippet do\\n\",\n \"└ unclosed delimiter\"\n ],\n ~c\"defmodule ShowSnippet do\"\n end\n\n test \"don't show snippet when error line is empty\" do\n assert_eval_raise TokenMissingError,\n [\"nofile:1:25:\", \"missing terminator: end\"],\n ~c\"defmodule ShowSnippet do\\n\\n\"\n end\n\n test \"function local conflict\" do\n assert_compile_error(\n [\"nofile:3:9: \", \"imported Kernel.&&/2 conflicts with local function\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.FunctionLocalConflict do\n def other, do: 1 && 2\n def _ && _, do: :error\n end\n \"\"\"\n )\n end\n\n test \"macro local conflict\" do\n assert_compile_error(\n [\n \"nofile:6:20\",\n \"call to local macro &&/2 conflicts with imported Kernel.&&/2, \" <>\n \"please rename the local macro or remove the conflicting import\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.MacroLocalConflict do\n def hello, do: 1 || 2\n defmacro _ || _, do: :ok\n\n defmacro _ && _, do: :error\n def world, do: 1 && 2\n end\n \"\"\"\n )\n end\n\n test \"macro with undefined local\" do\n assert_eval_raise UndefinedFunctionError,\n [\n \"function Kernel.ErrorsTest.MacroWithUndefinedLocal.unknown/1 is undefined (function not available)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.MacroWithUndefinedLocal do\n defmacrop bar, do: unknown(1)\n def baz, do: bar()\n end\n \"\"\"\n end\n\n test \"private macro\" do\n assert_eval_raise UndefinedFunctionError,\n [\n \"function Kernel.ErrorsTest.PrivateMacro.foo/0 is undefined (function not available)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.PrivateMacro do\n defmacrop foo, do: 1\n defmacro bar, do: __MODULE__.foo()\n defmacro baz, do: bar()\n end\n \"\"\"\n end\n\n test \"macro invoked before its definition\" do\n assert_compile_error(\n [\"nofile:2:16\", \"cannot invoke macro bar/0 before its definition\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.IncorrectMacroDispatch do\n def foo, do: bar()\n defmacro bar, do: :bar\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:2:16\", \"cannot invoke macro bar/0 before its definition\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.IncorrectMacropDispatch do\n def foo, do: bar()\n defmacrop bar, do: :ok\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:2:40\", \"cannot invoke macro bar/1 before its definition\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.IncorrectMacroDispatch do\n defmacro bar(a) when is_atom(a), do: bar([a])\n end\n \"\"\"\n )\n end\n\n test \"macro captured before its definition\" do\n assert_compile_error(\n [\"nofile:3:18\", \"cannot invoke macro is_ok/1 before its definition\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.IncorrectMacroDispatch.Capture do\n def foo do\n predicate = &is_ok/1\n Enum.any?([:ok, :error, :foo], predicate)\n end\n\n defmacro is_ok(atom), do: atom == :ok\n end\n \"\"\"\n )\n end\n\n test \"function definition with alias\" do\n assert_compile_error(\n [\n \"nofile:2:7\\n\",\n \"function names should start with lowercase characters or underscore, invalid name Bar\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.FunctionDefinitionWithAlias do\n def Bar do\n :baz\n end\n end\n \"\"\"\n )\n end\n\n test \"function import conflict\" do\n assert_compile_error(\n [\"nofile:3:16\", \"function exit/1 imported from both :erlang and Kernel, call is ambiguous\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.FunctionImportConflict do\n import :erlang, only: [exit: 1], warn: false\n def foo, do: exit(:test)\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:3:17\", \"function exit/1 imported from both :erlang and Kernel, call is ambiguous\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.FunctionImportConflict do\n import :erlang, only: [exit: 1], warn: false\n def foo, do: &exit/1\n end\n \"\"\"\n )\n end\n\n test \"ensure valid import :only option\" do\n assert_compile_error(\n [\n \"nofile:3:3\",\n \"invalid :only option for import, expected value to be an atom :functions, :macros, or a literal keyword list of function names with arity as values, got: x\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.Only do\n x = [flatten: 1]\n import List, only: x\n end\n \"\"\"\n )\n end\n\n test \"ensure valid import :except option\" do\n assert_compile_error(\n [\n \"nofile:3:3\",\n \"invalid :except option for import, expected value to be a literal keyword list of function names \" <>\n \"with arity as values, got: Module.__get_attribute__(Kernel.ErrorsTest.Only, :x, 3, true)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.Only do\n @x [flatten: 1]\n import List, except: @x\n end\n \"\"\"\n )\n end\n\n test \"def defmacro clause change\" do\n assert_compile_error(\n [\"nofile:3:12\\n\", \"defmacro foo/1 already defined as def in nofile:2\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.DefDefmacroClauseChange do\n def foo(1), do: 1\n defmacro foo(x), do: x\n end\n \"\"\"\n )\n end\n\n test \"def defp clause change from another file\" do\n assert_compile_error([\"nofile:4\\n\", \"def hello/0 already defined as defp\"], ~c\"\"\"\n defmodule Kernel.ErrorsTest.DefDefmacroClauseChange do\n require Kernel.ErrorsTest\n defp hello, do: :world\n Kernel.ErrorsTest.hello(:ok)\n end\n \"\"\")\n end\n\n test \"internal function overridden\" do\n assert_compile_error(\n [\"nofile:2:7\\n\", \"cannot define def __info__/1 as it is automatically defined by Elixir\"],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.InternalFunctionOverridden do\n def __info__(_), do: []\n end\n \"\"\"\n )\n end\n\n test \"invalid macro\" do\n assert_compile_error(\n \"invalid quoted expression: {:foo, :bar, :baz, :bat}\",\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.InvalidMacro do\n defmacrop oops do\n {:foo, :bar, :baz, :bat}\n end\n\n def test, do: oops()\n end\n \"\"\"\n )\n end\n\n test \"unloaded module\" do\n assert_compile_error(\n [\"nofile:1:1\", \"module Certainly.Doesnt.Exist is not loaded and could not be found\"],\n ~c\"import Certainly.Doesnt.Exist\"\n )\n end\n\n test \"module imported from the context it was defined in\" do\n assert_compile_error(\n [\n \"nofile:4:3\",\n \"module Kernel.ErrorsTest.ScheduledModule.Hygiene is not loaded but was defined.\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.ScheduledModule do\n defmodule Hygiene do\n end\n import Kernel.ErrorsTest.ScheduledModule.Hygiene\n end\n \"\"\"\n )\n end\n\n test \"module imported from the same module\" do\n assert_compile_error(\n [\n \"nofile:3:5\",\n \"you are trying to use/import/require the module Kernel.ErrorsTest.ScheduledModule.Hygiene which is currently being defined\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.ScheduledModule do\n defmodule Hygiene do\n import Kernel.ErrorsTest.ScheduledModule.Hygiene\n end\n end\n \"\"\"\n )\n end\n\n test \"invalid @compile inline\" do\n assert_compile_error(\n [\"nofile:1: \", \"undefined function foo/1 given to @compile :inline\"],\n ~c\"defmodule Test do @compile {:inline, foo: 1} end\"\n )\n\n assert_compile_error(\n [\"nofile:1: \", \"macro foo/1 given to @compile :inline\"],\n ~c\"defmodule Test do @compile {:inline, foo: 1}; defmacro foo(_), do: :ok end\"\n )\n end\n\n test \"invalid @nifs attribute\" do\n assert_compile_error(\n [\"nofile:1: \", \"undefined function foo/1 given to @nifs\"],\n ~c\"defmodule Test do @nifs [foo: 1] end\"\n )\n\n assert_compile_error(\n [\"nofile:1: \", \"undefined function foo/1 given to @nifs\"],\n ~c\"defmodule Test do @nifs [foo: 1]; defmacro foo(_) end\"\n )\n\n assert_eval_raise ArgumentError,\n [\"@nifs is a built-in module attribute\"],\n ~c\"defmodule Test do @nifs :not_an_option end\"\n end\n\n test \"invalid @dialyzer options\" do\n assert_compile_error(\n [\"nofile:1: \", \"undefined function foo/1 given to @dialyzer :nowarn_function\"],\n ~c\"defmodule Test do @dialyzer {:nowarn_function, {:foo, 1}} end\"\n )\n\n assert_compile_error(\n [\"nofile:1: \", \"macro foo/1 given to @dialyzer :nowarn_function\"],\n ~c\"defmodule Test do @dialyzer {:nowarn_function, {:foo, 1}}; defmacro foo(_), do: :ok end\"\n )\n\n assert_compile_error(\n [\"nofile:1: \", \"undefined function foo/1 given to @dialyzer :no_opaque\"],\n ~c\"defmodule Test do @dialyzer {:no_opaque, {:foo, 1}} end\"\n )\n\n assert_eval_raise ArgumentError,\n [\"invalid value for @dialyzer attribute: :not_an_option\"],\n ~c\"defmodule Test do @dialyzer :not_an_option end\"\n end\n\n test \"@on_load attribute format\" do\n assert_raise ArgumentError, ~r/should be an atom or an {atom, 0} tuple/, fn ->\n defmodule BadOnLoadAttribute do\n Module.put_attribute(__MODULE__, :on_load, \"not an atom\")\n end\n end\n end\n\n test \"duplicated @on_load attribute\" do\n assert_raise ArgumentError, \"the @on_load attribute can only be set once per module\", fn ->\n defmodule DuplicatedOnLoadAttribute do\n @on_load :foo\n @on_load :bar\n end\n end\n end\n\n test \"@on_load attribute with undefined function\" do\n assert_compile_error(\n [\"nofile:1: \", \"undefined function foo/0 given to @on_load\"],\n ~c\"defmodule UndefinedOnLoadFunction do @on_load :foo end\"\n )\n end\n\n test \"wrong kind for @on_load attribute\" do\n assert_compile_error(\n [\"nofile:1: \", \"macro foo/0 given to @on_load\"],\n ~c\"\"\"\n defmodule PrivateOnLoadFunction do\n @on_load :foo\n defmacro foo, do: :ok\n end\n \"\"\"\n )\n end\n\n test \"in definition module\" do\n assert_compile_error(\n [\n \"nofile:2: \",\n \"cannot define module Kernel.ErrorsTest.InDefinitionModule \" <>\n \"because it is currently being defined in nofile:1\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.InDefinitionModule do\n defmodule Elixir.Kernel.ErrorsTest.InDefinitionModule, do: true\n end\n \"\"\"\n )\n end\n\n test \"invalid definition\" do\n assert_compile_error(\n [\"nofile:1: \", \"invalid syntax in def 1.(hello)\"],\n ~c\"defmodule Kernel.ErrorsTest.InvalidDefinition, do: (def 1.(hello), do: true)\"\n )\n end\n\n test \"invalid function head\" do\n assert_compile_error(\n [\n \"nofile:2:7: \",\n \"patterns are not allowed in function head, only variables and default arguments (using \\\\\\\\)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.InvalidPatternsInFunctionHead do\n def foo(nil)\n def foo(_), do: :ok\n end\n \"\"\"\n )\n\n assert_compile_error(\n [\n \"nofile:2:7: \",\n \"guards are not allowed in function head, only variables and default arguments (using \\\\\\\\)\"\n ],\n ~c\"\"\"\n defmodule Kernel.ErrorsTest.InvalidGuardsInFunctionHead do\n def foo(x) when x == nil\n def foo(_), do: :ok\n end\n \"\"\"\n )\n\n assert_compile_error([\"nofile:2:7: \", \"missing :do option in \\\"def\\\"\"], ~c\"\"\"\n defmodule Kernel.ErrorsTest.BodyessFunctionWithGuard do\n def foo(n), true\n end\n \"\"\")\n\n assert_compile_error([\"nofile:2:7: \", \"missing :do option in \\\"def\\\"\"], ~c\"\"\"\n defmodule Kernel.ErrorsTest.BodyessFunctionWithGuard do\n def foo(n) when is_number(n), true\n end\n \"\"\")\n end\n\n test \"bad multi-call\" do\n assert_compile_error(\n [\n \"nofile:1:1\",\n \"invalid argument for alias, expected a compile time atom or alias, got: 42\"\n ],\n ~c\"alias IO.{ANSI, 42}\"\n )\n\n assert_compile_error(\n [\"nofile:1:1\", \":as option is not supported by multi-alias call\"],\n ~c\"alias Elixir.{Map}, as: Dict\"\n )\n\n assert_eval_raise UndefinedFunctionError,\n [\"function List.\\\"{}\\\"/1 is undefined or private\"],\n ~c\"[List.{Chars}, \\\"one\\\"]\"\n end\n\n test \"macros error stacktrace\" do\n assert [\n {:erlang, :+, [1, :foo], _},\n {Kernel.ErrorsTest.MacrosErrorStacktrace, :sample, 1, _} | _\n ] =\n rescue_stacktrace(\"\"\"\n defmodule Kernel.ErrorsTest.MacrosErrorStacktrace do\n defmacro sample(num), do: num + :foo\n def other, do: sample(1)\n end\n \"\"\")\n end\n\n test \"macros function clause stacktrace\" do\n assert [{__MODULE__, :sample, 1, _} | _] =\n rescue_stacktrace(\"\"\"\n defmodule Kernel.ErrorsTest.MacrosFunctionClauseStacktrace do\n import Kernel.ErrorsTest\n sample(1)\n end\n \"\"\")\n end\n\n test \"macros interpreted function clause stacktrace\" do\n assert [{Kernel.ErrorsTest.MacrosInterpretedFunctionClauseStacktrace, :sample, 1, _} | _] =\n rescue_stacktrace(\"\"\"\n defmodule Kernel.ErrorsTest.MacrosInterpretedFunctionClauseStacktrace do\n defmacro sample(0), do: 0\n def other, do: sample(1)\n end\n \"\"\")\n end\n\n test \"macros compiled callback\" do\n assert [{Kernel.ErrorsTest, :__before_compile__, [env], _} | _] =\n rescue_stacktrace(\"\"\"\n defmodule Kernel.ErrorsTest.MacrosCompiledCallback do\n Module.put_attribute(__MODULE__, :before_compile, Kernel.ErrorsTest)\n end\n \"\"\")\n\n assert %Macro.Env{module: Kernel.ErrorsTest.MacrosCompiledCallback} = env\n end\n\n test \"failed remote call stacktrace includes file/line info\" do\n try do\n bad_remote_call(Process.get(:unused, 1))\n rescue\n ArgumentError ->\n assert [\n {:erlang, :apply, [1, :foo, []], _},\n {__MODULE__, :bad_remote_call, 1, [file: _, line: _]} | _\n ] = __STACKTRACE__\n end\n end\n\n test \"def fails when rescue, else or catch don't have clauses\" do\n assert_compile_error(\n ~r\"invalid \\\"rescue\\\" block in \\\"def\\\", it expects \\\"pattern -> expr\\\" clauses\",\n \"\"\"\n defmodule Example do\n def foo do\n bar()\n rescue\n baz()\n end\n end\n \"\"\"\n )\n end\n\n test \"duplicate map keys\" do\n assert_compile_error([\"nofile:1:3\", \"key :a will be overridden in map\"], \"\"\"\n %{a: :b, a: :c} = %{a: :c}\n \"\"\")\n\n assert_compile_error([\"nofile:1:3\", \"key :a will be overridden in map\"], \"\"\"\n %{a: :b, a: :c, a: :d} = %{a: :c}\n \"\"\")\n end\n\n test \"| outside of cons\" do\n assert_compile_error([\"nofile:1:3\", \"misplaced operator |/2\"], \"1 | 2\")\n\n assert_compile_error(\n [\"nofile:1:45\", \"misplaced operator |/2\"],\n \"defmodule MisplacedOperator, do: (def bar(1 | 2), do: :ok)\"\n )\n end\n\n test \"reserved word used at module top-level\" do\n assert_eval_raise(\n ArgumentError,\n [\"unexpected reserved word at the top-level of the \\\"defmodule Foo\\\" do-block: catch\"],\n \"\"\"\n defmodule Foo do\n def foo, do: :foo catch :bar\n end\n \"\"\"\n )\n end\n\n defp bad_remote_call(x), do: x.foo()\n\n defmacro sample(0), do: 0\n\n defmacro before_compile(_) do\n quote(do: _)\n end\n\n ## Helpers\n\n defp assert_eval_raise(given_exception, messages, source) do\n exception =\n assert_raise given_exception, fn ->\n Code.eval_string(source)\n end\n\n error_msg = Exception.format(:error, exception, [])\n\n for msg <- messages do\n assert error_msg =~ msg\n end\n\n exception\n end\n\n defp assert_compile_error(messages, string) do\n captured =\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n ast = Code.string_to_quoted!(string, columns: true)\n assert_raise CompileError, fn -> Code.eval_quoted(ast) end\n end)\n\n for message <- List.wrap(messages) do\n assert captured =~ message\n end\n end\n\n defp rescue_stacktrace(string) do\n try do\n Code.eval_string(string)\n nil\n rescue\n _ -> __STACKTRACE__\n else\n _ -> flunk(\"Expected expression to fail\")\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/expansion_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.ExpansionTarget do\n defmacro seventeen, do: 17\n defmacro bar, do: \"bar\"\n\n defmacro message_hello(arg) do\n send(self(), :hello)\n arg\n end\nend\n\ndefmodule Kernel.ExpansionTest do\n use ExUnit.Case, async: true\n\n import ExUnit.CaptureIO\n\n describe \"__block__\" do\n test \"expands to nil when empty\" do\n assert expand(quote(do: unquote(:__block__)())) == nil\n end\n\n test \"expands to argument when arity is 1\" do\n assert expand(quote(do: unquote(:__block__)(1))) == 1\n end\n\n test \"is recursive to argument when arity is 1\" do\n expanded =\n quote do\n _ = 1\n 2\n end\n\n assert expand(quote(do: unquote(:__block__)(_ = 1, unquote(:__block__)(2)))) == expanded\n end\n\n test \"accumulates vars\" do\n before_expansion =\n quote do\n a = 1\n a\n end\n\n after_expansion =\n quote do\n a = 1\n a\n end\n\n assert expand(before_expansion) == after_expansion\n end\n end\n\n describe \"alias\" do\n test \"expand args, defines alias and returns itself\" do\n alias true, as: True\n\n input = quote(do: alias(:hello, as: World, warn: True))\n {output, env} = expand_env(input, __ENV__)\n\n assert output == :hello\n assert env.aliases == [{:\"Elixir.True\", true}, {:\"Elixir.World\", :hello}]\n end\n\n test \"invalid alias\" do\n message =\n ~r\"invalid value for option :as, expected a simple alias, got nested alias: Sample.Lists\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: alias(:lists, as: Sample.Lists)))\n end)\n\n message = ~r\"invalid argument for alias, expected a compile time atom or alias, got: 1 \\+ 2\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: alias(1 + 2)))\n end)\n\n message = ~r\"invalid value for option :as, expected an alias, got: :foobar\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: alias(:lists, as: :foobar)))\n end)\n\n message = ~r\"invalid value for option :as, expected an alias, got: :\\\"Elixir.foobar\\\"\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: alias(:lists, as: :\"Elixir.foobar\")))\n end)\n\n message =\n ~r\"alias cannot be inferred automatically for module: :lists, please use the :as option\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: alias(:lists)))\n end)\n end\n\n test \"invalid expansion\" do\n assert_compile_error(~r\"invalid alias: \\\"foo\\.Foo\\\"\", fn ->\n code =\n quote do\n foo = :foo\n foo.Foo\n end\n\n expand(code)\n end)\n end\n\n test \"raises if :as is passed to multi-alias aliases\" do\n assert_compile_error(~r\":as option is not supported by multi-alias call\", fn ->\n expand(quote(do: alias(Foo.{Bar, Baz}, as: BarBaz)))\n end)\n end\n\n test \"raises on multi-alias with non-atom base\" do\n assert_compile_error(~r\"invalid alias: \\\"foo\\\"\", fn ->\n expand(quote(do: alias(foo.{Bar, Baz})))\n end)\n end\n\n test \"invalid options\" do\n assert_compile_error(~r\"unsupported option :ops given to alias\", fn ->\n expand(quote(do: alias(Foo, ops: 1)))\n end)\n end\n end\n\n describe \"__aliases__\" do\n test \"expands even if no alias\" do\n assert expand(quote(do: World)) == :\"Elixir.World\"\n assert expand(quote(do: Elixir.World)) == :\"Elixir.World\"\n end\n\n test \"expands with alias\" do\n alias Hello, as: World\n assert expand_env(quote(do: World), __ENV__) |> elem(0) == :\"Elixir.Hello\"\n end\n\n test \"expands with alias is recursive\" do\n alias Source, as: Hello\n alias Hello, as: World\n assert expand_env(quote(do: World), __ENV__) |> elem(0) == :\"Elixir.Source\"\n end\n end\n\n describe \"import\" do\n test \"raises on conflicting options\" do\n message =\n ~r\":only and :except can only be given together to import when :only is :functions, :macros, or :sigils\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: import(Kernel, only: [], except: [])))\n end)\n end\n\n test \"invalid import option\" do\n assert_compile_error(~r\"unsupported option :ops given to import\", fn ->\n expand(quote(do: import(:lists, ops: 1)))\n end)\n end\n\n test \"raises for non-compile-time module\" do\n assert_compile_error(~r\"invalid argument for import, .*, got: {:a, :tuple}\", fn ->\n expand(quote(do: import({:a, :tuple})))\n end)\n end\n end\n\n describe \"require\" do\n test \"raises for non-compile-time module\" do\n assert_compile_error(~r\"invalid argument for require, .*, got: {:a, :tuple}\", fn ->\n expand(quote(do: require({:a, :tuple})))\n end)\n end\n\n test \"invalid options\" do\n assert_compile_error(~r\"unsupported option :ops given to require\", fn ->\n expand(quote(do: require(Foo, ops: 1)))\n end)\n end\n end\n\n describe \"=\" do\n test \"defines vars\" do\n {output, env} = expand_env(quote(do: a = 1), __ENV__)\n assert output == quote(do: a = 1)\n assert Macro.Env.has_var?(env, {:a, __MODULE__})\n end\n\n test \"does not define _\" do\n {output, env} = expand_env(quote(do: _ = 1), __ENV__)\n assert output == quote(do: _ = 1)\n assert Macro.Env.vars(env) == []\n end\n\n test \"errors on directly recursive definitions\" do\n assert_compile_error(\n ~r\"\"\"\n recursive variable definition in patterns:\n\n \\{x = \\{:ok, x\\}\\}\n\n the variable \"x\" \\(context Kernel.ExpansionTest\\) is defined in function of itself\n \"\"\",\n fn -> expand(quote(do: {x = {:ok, x}} = :ok)) end\n )\n\n assert_compile_error(\n ~r\"\"\"\n recursive variable definition in patterns:\n\n \\{\\{x, y\\} = \\{y, x\\}\\}\n\n the variable \"x\" \\(context Kernel.ExpansionTest\\) is defined in function of itself\n \"\"\",\n fn -> expand(quote(do: {{x, y} = {y, x}} = :ok)) end\n )\n\n assert_compile_error(\n ~r\"\"\"\n recursive variable definition in patterns:\n\n \\{\\{:x, y\\} = \\{x, :y\\}, x = y\\}\n\n the variable \"x\" \\(context Kernel.ExpansionTest\\) is defined recursively in function of \"y\" \\(context Kernel.ExpansionTest\\)\n \"\"\",\n fn -> expand(quote(do: {{:x, y} = {x, :y}, x = y} = :ok)) end\n )\n\n assert_compile_error(\n ~r\"\"\"\n recursive variable definition in patterns:\n\n \\{x = y, y = z, z = x\\}\n\n the following variables form a cycle: \"x\" \\(context Kernel.ExpansionTest\\), \"y\" \\(context Kernel.ExpansionTest\\), \"z\" \\(context Kernel.ExpansionTest\\)\n \"\"\",\n fn -> expand(quote(do: {x = y, y = z, z = x} = :ok)) end\n )\n end\n\n test \"complex recursive variable definitions\" do\n assert expand(\n quote do:\n {%{type: type, client_id: client_id} = message,\n %{type: type, client_id: client_id} = state} = :ok\n )\n\n assert_compile_error(\n ~r\"recursive variable definition in patterns\",\n fn ->\n expand(\n quote do:\n {%{type: type, client_id: client_id} = message,\n %{type: type, client_id: client_id} = state, client_id = type} = :ok\n )\n end\n )\n end\n end\n\n describe \"environment macros\" do\n test \"__MODULE__\" do\n assert expand(quote(do: __MODULE__)) == __MODULE__\n end\n\n test \"__DIR__\" do\n assert expand(quote(do: __DIR__)) == __DIR__\n end\n\n test \"__ENV__\" do\n env = %{__ENV__ | line: 0}\n assert expand_env(quote(do: __ENV__), env) == {Macro.escape(env), env}\n assert %{lexical_tracker: nil, tracers: []} = __ENV__\n end\n\n test \"__ENV__.accessor\" do\n env = %{__ENV__ | line: 0}\n assert expand_env(quote(do: __ENV__.file), env) == {__ENV__.file, env}\n\n assert expand_env(quote(do: __ENV__.unknown), env) ==\n {quote(do: unquote(Macro.escape(env)).unknown), env}\n\n assert __ENV__.lexical_tracker == nil\n assert __ENV__.tracers == []\n end\n\n test \"on match\" do\n assert_compile_error(\n ~r\"invalid pattern in match, __ENV__ is not allowed in matches\",\n fn -> expand(quote(do: __ENV__ = :ok)) end\n )\n\n assert_compile_error(\n ~r\"invalid pattern in match, __CALLER__ is not allowed in matches\",\n fn -> expand(quote(do: __CALLER__ = :ok)) end\n )\n\n assert_compile_error(\n ~r\"invalid pattern in match, __STACKTRACE__ is not allowed in matches\",\n fn -> expand(quote(do: __STACKTRACE__ = :ok)) end\n )\n end\n end\n\n describe \"vars\" do\n test \"raises on undefined var by default\" do\n assert_compile_error(~r\"undefined variable \\\"a\\\"\", fn ->\n expand_env({:a, [], nil}, __ENV__, [])\n end)\n end\n\n test \"expands vars to local call when :on_undefined_variable is :warn\" do\n Code.put_compiler_option(:on_undefined_variable, :warn)\n\n {output, env} = expand_env({:a, [], nil}, __ENV__, [])\n assert output == {:a, [if_undefined: :warn], []}\n assert Macro.Env.vars(env) == []\n after\n Code.put_compiler_option(:on_undefined_variable, :raise)\n end\n\n test \"expands vars to local call without warning\" do\n env = __ENV__\n\n {output, _, env} =\n :elixir_expand.expand({:a, [if_undefined: :apply], nil}, :elixir_env.env_to_ex(env), env)\n\n assert output == {:a, [if_undefined: :apply], []}\n assert Macro.Env.vars(env) == []\n end\n\n test \"raises when expanding var to local call\" do\n env = __ENV__\n\n assert_compile_error(~r\"undefined variable \\\"a\\\"\", fn ->\n :elixir_expand.expand({:a, [if_undefined: :raise], nil}, :elixir_env.env_to_ex(env), env)\n end)\n end\n\n test \"forces variable to exist\" do\n code =\n quote do\n var!(a) = 1\n var!(a)\n end\n\n assert expand(code)\n\n message = ~r\"undefined variable \\\"a\\\"\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: var!(a)))\n end)\n\n message = ~r\"undefined variable \\\"a\\\" \\(context Unknown\\)\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: var!(a, Unknown)))\n end)\n end\n\n test \"raises for _ used outside of a match\" do\n assert_compile_error(~r\"invalid use of _\", fn ->\n expand(quote(do: {1, 2, _}))\n end)\n end\n\n defmacrop var_ver(var, version) do\n quote do\n {unquote(var), [version: unquote(version)], __MODULE__}\n end\n end\n\n defp expand_with_version(expr) do\n env = :elixir_env.reset_vars(__ENV__)\n {expr, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)\n expr\n end\n\n test \"tracks variable version\" do\n assert {:__block__, _, [{:=, _, [var_ver(:x, 0), 0]}, {:=, _, [_, var_ver(:x, 0)]}]} =\n expand_with_version(\n quote do\n x = 0\n _ = x\n end\n )\n\n assert {:__block__, _,\n [\n {:=, _, [var_ver(:x, 0), 0]},\n {:=, _, [_, var_ver(:x, 0)]},\n {:=, _, [var_ver(:x, 1), 1]},\n {:=, _, [_, var_ver(:x, 1)]}\n ]} =\n expand_with_version(\n quote do\n x = 0\n _ = x\n x = 1\n _ = x\n end\n )\n\n assert {:__block__, _,\n [\n {:=, _, [var_ver(:x, 0), 0]},\n {:fn, _, [{:->, _, [[var_ver(:x, 1)], {:=, _, [var_ver(:x, 2), 2]}]}]},\n {:=, _, [_, var_ver(:x, 0)]},\n {:=, _, [var_ver(:x, 3), 3]}\n ]} =\n expand_with_version(\n quote do\n x = 0\n fn x -> x = 2 end\n _ = x\n x = 3\n end\n )\n\n assert {:__block__, _,\n [\n {:=, _, [var_ver(:x, 0), 0]},\n {:case, _, [:foo, [do: [{:->, _, [[var_ver(:x, 1)], var_ver(:x, 1)]}]]]},\n {:=, _, [_, var_ver(:x, 0)]},\n {:=, _, [var_ver(:x, 2), 2]}\n ]} =\n expand_with_version(\n quote do\n x = 0\n case(:foo, do: (x -> x))\n _ = x\n x = 2\n end\n )\n end\n end\n\n describe \"^\" do\n test \"expands args\" do\n before_expansion =\n quote do\n after_expansion = 1\n ^after_expansion = 1\n end\n\n after_expansion =\n quote do\n after_expansion = 1\n ^after_expansion = 1\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"raises outside match\" do\n assert_compile_error(~r\"misplaced operator \\^a\", fn ->\n expand(quote(do: ^a))\n end)\n end\n\n test \"raises without var\" do\n message =\n ~r\"invalid argument for unary operator \\^, expected an existing variable, got: \\^1\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: ^1 = 1))\n end)\n end\n\n test \"raises when the var is undefined\" do\n assert_compile_error(~r\"undefined variable \\^foo\", fn ->\n expand(quote(do: ^foo = :foo), [])\n end)\n end\n end\n\n describe \"locals\" do\n test \"expands to remote calls\" do\n assert {{:., _, [Kernel, :=~]}, _, [{:a, _, []}, {:b, _, []}]} = expand(quote(do: a =~ b))\n end\n\n test \"in matches\" do\n assert_compile_error(\n ~r\"cannot find or invoke local foo/1 inside a match. .+ Called as: foo\\(:bar\\)\",\n fn ->\n expand(quote(do: foo(:bar) = :bar))\n end\n )\n end\n\n test \"in guards\" do\n code = quote(do: fn pid when :erlang.==(pid, self) -> pid end)\n expanded_code = quote(do: fn pid when :erlang.==(pid, :erlang.self()) -> pid end)\n assert clean_meta(expand(code), [:imports, :context]) == expanded_code\n\n assert_compile_error(~r\"cannot find or invoke local foo/1\", fn ->\n expand(quote(do: fn arg when foo(arg) -> arg end))\n end)\n end\n\n test \"custom imports\" do\n before_expansion =\n quote do\n import Kernel.ExpansionTarget\n seventeen()\n end\n\n after_expansion =\n quote do\n :\"Elixir.Kernel.ExpansionTarget\"\n 17\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"invalid metadata\" do\n assert expand({:foo, [imports: 2, context: :unknown], [1, 2]}) ==\n {:foo, [imports: 2, context: :unknown], [1, 2]}\n end\n end\n\n describe \"floats\" do\n test \"cannot be 0.0 inside match\" do\n assert capture_io(:stderr, fn -> expand(quote(do: 0.0 = 0.0)) end) =~\n \"pattern matching on 0.0 is equivalent to matching only on +0.0\"\n\n assert {:=, [], [+0.0, +0.0]} = expand(quote(do: +0.0 = 0.0))\n assert {:=, [], [-0.0, +0.0]} = expand(quote(do: -0.0 = 0.0))\n end\n end\n\n describe \"tuples\" do\n test \"expanded as arguments\" do\n assert expand(quote(do: {after_expansion = 1, a})) == quote(do: {after_expansion = 1, a()})\n\n assert expand(quote(do: {b, after_expansion = 1, a})) ==\n quote(do: {b(), after_expansion = 1, a()})\n end\n end\n\n describe \"maps\" do\n test \"expanded as arguments\" do\n assert expand(quote(do: %{a: after_expansion = 1, b: a})) ==\n quote(do: %{a: after_expansion = 1, b: a()})\n end\n\n test \"with variables on keys inside patterns\" do\n ast =\n quote do\n %{(x = 1) => 1}\n end\n\n assert expand(ast) == ast\n\n ast =\n quote do\n x = 1\n %{%{^x => 1} => 2} = y()\n end\n\n assert expand(ast) == ast\n\n ast =\n quote do\n x = 1\n %{{^x} => 1} = %{{1} => 1}\n end\n\n assert expand(ast) == ast\n\n assert_compile_error(~r\"cannot use variable x as map key inside a pattern\", fn ->\n expand(quote(do: %{x => 1} = %{}))\n end)\n\n assert_compile_error(~r\"undefined variable \\^x\", fn ->\n expand(quote(do: {x, %{^x => 1}} = %{}), [])\n end)\n end\n\n test \"with binaries in keys inside patterns\" do\n before_ast =\n quote do\n %{<<0>> => nil} = %{<<0>> => nil}\n end\n\n after_ast =\n quote do\n %{<<0::integer>> => nil} = %{<<0::integer>> => nil}\n end\n\n assert expand(before_ast) |> clean_meta([:alignment]) == clean_bit_modifiers(after_ast)\n assert expand(after_ast) |> clean_meta([:alignment]) == clean_bit_modifiers(after_ast)\n\n ast =\n quote do\n x = 8\n %{<<0::integer-size(x)>> => nil} = %{<<0::integer>> => nil}\n end\n\n assert expand(ast) |> clean_meta([:alignment]) ==\n clean_bit_modifiers(ast) |> clean_meta([:context, :imports])\n\n assert_compile_error(~r\"cannot use variable x as map key inside a pattern\", fn ->\n expand(quote(do: %{<> => 1} = %{}), [])\n end)\n end\n\n test \"expects key-value pairs\" do\n assert_compile_error(~r\"expected key-value pairs in a map, got: :foo\", fn ->\n expand(quote(do: unquote({:%{}, [], [:foo]})))\n end)\n end\n end\n\n defmodule User do\n defstruct name: \"\", age: 0\n end\n\n describe \"structs\" do\n test \"expanded as arguments\" do\n assert expand(quote(do: %User{})) ==\n quote(do: %:\"Elixir.Kernel.ExpansionTest.User\"{age: 0, name: \"\"})\n\n assert expand(quote(do: %User{name: \"john doe\"})) ==\n quote(do: %:\"Elixir.Kernel.ExpansionTest.User\"{age: 0, name: \"john doe\"})\n end\n\n test \"expects atoms\" do\n expand(quote(do: %unknown{a: 1} = x))\n\n message = ~r\"expected struct name to be a compile time atom or alias\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: %unknown{a: 1}))\n end)\n\n message = ~r\"expected struct name to be a compile time atom or alias\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: %unquote(1){a: 1}))\n end)\n\n message = ~r\"expected struct name in a match to be a compile time atom, alias or a variable\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: %unquote(1){a: 1} = x))\n end)\n end\n\n test \"update syntax\" do\n expand(quote(do: %{%{a: 0} | a: 1}))\n\n assert_compile_error(~r\"cannot use map/struct update syntax in match\", fn ->\n expand(quote(do: %{%{a: 0} | a: 1} = %{}))\n end)\n end\n\n test \"dynamic syntax expands to itself\" do\n assert expand(quote(do: %x{} = 1)) == quote(do: %x{} = 1)\n end\n\n test \"invalid keys in structs\" do\n assert_compile_error(~r\"invalid key :erlang\\.\\+\\(1, 2\\) for struct\", fn ->\n expand(\n quote do\n %User{(1 + 2) => :my_value}\n end\n )\n end)\n end\n\n test \"unknown key in structs\" do\n message = ~r\"unknown key :foo for struct Kernel\\.ExpansionTest\\.User\"\n\n assert_compile_error(message, fn ->\n expand_env(quote(do: %User{foo: :my_value} = %{}), %{__ENV__ | function: nil})\n end)\n end\n end\n\n describe \"quote\" do\n test \"expanded to raw forms\" do\n assert expand(quote(do: quote(do: hello)), []) == {:{}, [], [:hello, [], __MODULE__]}\n end\n\n test \"raises if the :bind_quoted option is invalid\" do\n assert_compile_error(~r\"invalid :bind_quoted for quote\", fn ->\n expand(quote(do: quote(bind_quoted: self(), do: :ok)))\n end)\n\n assert_compile_error(~r\"invalid :bind_quoted for quote\", fn ->\n expand(quote(do: quote(bind_quoted: [{1, 2}], do: :ok)))\n end)\n end\n\n test \"raises for missing do\" do\n assert_compile_error(~r\"missing :do option in \\\"quote\\\"\", fn ->\n expand(quote(do: quote(context: Foo)))\n end)\n end\n\n test \"raises for invalid arguments\" do\n assert_compile_error(~r\"invalid arguments for \\\"quote\\\"\", fn ->\n expand(quote(do: quote(1 + 1)))\n end)\n end\n\n test \"raises unless its options are a keyword list\" do\n assert_compile_error(~r\"invalid options for quote, expected a keyword list\", fn ->\n expand(quote(do: quote(:foo, do: :foo)))\n end)\n end\n end\n\n describe \"anonymous calls\" do\n test \"expands base and args\" do\n assert expand(quote(do: a.(b))) == quote(do: a().(b()))\n end\n end\n\n describe \"remotes\" do\n test \"expands to Erlang\" do\n assert expand(quote(do: Kernel.is_atom(a))) == quote(do: :erlang.is_atom(a()))\n end\n\n test \"expands macros\" do\n assert expand(quote(do: Kernel.ExpansionTest.thirteen())) == 13\n end\n\n test \"expands receiver and args\" do\n assert expand(quote(do: a.is_atom(b))) == quote(do: a().is_atom(b()))\n\n assert expand(quote(do: (after_expansion = :foo).is_atom(a))) ==\n quote(do: (after_expansion = :foo).is_atom(a()))\n end\n\n test \"modules must be required for macros\" do\n before_expansion =\n quote do\n require Kernel.ExpansionTarget\n Kernel.ExpansionTarget.seventeen()\n end\n\n after_expansion =\n quote do\n :\"Elixir.Kernel.ExpansionTarget\"\n 17\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"in matches\" do\n message = ~r\"cannot invoke remote function Hello.fun_that_does_not_exist/0 inside a match\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: Hello.fun_that_does_not_exist() = :foo))\n end)\n\n message = ~r\"cannot invoke remote function :erlang.make_ref/0 inside a match\"\n assert_compile_error(message, fn -> expand(quote(do: make_ref() = :foo)) end)\n\n message = ~r\"invalid argument for \\+\\+ operator inside a match\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: \"a\" ++ \"b\" = \"ab\"))\n end)\n\n assert_compile_error(message, fn ->\n expand(quote(do: [1 | 2] ++ [3] = [1, 2, 3]))\n end)\n\n assert_compile_error(message, fn ->\n expand(quote(do: [1] ++ 2 ++ [3] = [1, 2, 3]))\n end)\n\n assert {:=, _, [-1, -1]} =\n expand(quote(do: -1 = -1))\n\n assert {:=, _, [1, 1]} =\n expand(quote(do: +1 = +1))\n\n assert {:=, _, [[{:|, _, [1, [{:|, _, [2, 3]}]]}], [1, 2, 3]]} =\n expand(quote(do: [1] ++ [2] ++ 3 = [1, 2, 3]))\n end\n\n test \"in guards\" do\n message =\n ~r\"cannot invoke remote function Hello.something_that_does_not_exist/1 inside a guard\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: fn arg when Hello.something_that_does_not_exist(arg) -> arg end))\n end)\n\n message = ~r\"cannot invoke remote function :erlang.make_ref/0 inside a guard\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: fn arg when make_ref() -> arg end))\n end)\n end\n\n test \"in guards with macros\" do\n message =\n ~r\"you must require the module Integer before invoking macro Integer.is_even/1 inside a guard\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: fn arg when Integer.is_even(arg) -> arg end))\n end)\n end\n\n test \"in guards with bitstrings\" do\n message = ~r\"cannot invoke remote function String.Chars.to_string/1 inside a guard\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: fn arg when \"#{arg}foo\" == \"argfoo\" -> arg end))\n end)\n\n assert_compile_error(message, fn ->\n expand(\n quote do\n fn arg when <<:\"Elixir.Kernel\".to_string(arg)::binary, \"foo\">> == \"argfoo\" ->\n arg\n end\n end\n )\n end)\n end\n end\n\n describe \"comprehensions\" do\n test \"variables do not leak with enums\" do\n before_expansion =\n quote do\n for(a <- b, do: c = 1)\n c\n end\n\n after_expansion =\n quote do\n for(a <- b(), do: c = 1)\n c()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"variables do not leak with binaries\" do\n before_expansion =\n quote do\n for(<>, do: c = 1)\n c\n end\n\n after_expansion =\n quote do\n for(<<(<> <- b())>>, do: c = 1)\n c()\n end\n\n assert expand(before_expansion) |> clean_meta([:alignment]) ==\n clean_bit_modifiers(after_expansion)\n end\n\n test \"variables inside generator args do not leak\" do\n before_expansion =\n quote do\n for(\n b <-\n (\n a = 1\n [2]\n ),\n do: {a, b}\n )\n\n a\n end\n\n after_expansion =\n quote do\n for(\n b <-\n (\n a = 1\n [2]\n ),\n do: {a(), b}\n )\n\n a()\n end\n\n assert expand(before_expansion) == after_expansion\n\n before_expansion =\n quote do\n for(\n b <-\n (\n a = 1\n [2]\n ),\n d <-\n (\n c = 3\n [4]\n ),\n do: {a, b, c, d}\n )\n end\n\n after_expansion =\n quote do\n for(\n b <-\n (\n a = 1\n [2]\n ),\n d <-\n (\n c = 3\n [4]\n ),\n do: {a(), b, c(), d},\n into: []\n )\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"variables inside filters are available in blocks\" do\n assert expand(quote(do: for(a <- b, c = a, do: c))) ==\n quote(do: for(a <- b(), c = a, do: c, into: []))\n end\n\n test \"variables inside options do not leak\" do\n before_expansion =\n quote do\n for(a <- c = b, into: [], do: 1)\n c\n end\n\n after_expansion =\n quote do\n for(a <- c = b(), do: 1, into: [])\n c()\n end\n\n assert expand(before_expansion) == after_expansion\n\n before_expansion =\n quote do\n for(a <- b, into: c = [], do: 1)\n c\n end\n\n after_expansion =\n quote do\n for(a <- b(), do: 1, into: c = [])\n c()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"must start with generators\" do\n assert_compile_error(~r\"for comprehensions must start with a generator\", fn ->\n expand(quote(do: for(is_atom(:foo), do: :foo)))\n end)\n\n assert_compile_error(~r\"for comprehensions must start with a generator\", fn ->\n expand(quote(do: for(do: :foo)))\n end)\n end\n\n test \"requires size on binary generators\" do\n message = ~r\"a binary field without size is only allowed at the end of a binary pattern\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: for(<>, do: x)))\n end)\n end\n\n test \"require do option\" do\n assert_compile_error(~r\"missing :do option in \\\"for\\\"\", fn ->\n expand(quote(do: for(_ <- 1..2)))\n end)\n end\n\n test \"uniq option is boolean\" do\n message = ~r\":uniq option for comprehensions only accepts a boolean, got: x\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: for(x <- 1..2, uniq: x, do: x)))\n end)\n end\n\n test \"raise error on invalid reduce\" do\n assert_compile_error(\n ~r\"cannot use :reduce alongside :into/:uniq in comprehension\",\n fn ->\n expand(quote(do: for(x <- 1..3, reduce: %{}, into: %{}, do: (acc -> acc))))\n end\n )\n\n assert_compile_error(\n ~r\"the do block was written using acc -> expr clauses but the :reduce option was not given\",\n fn -> expand(quote(do: for(x <- 1..3, do: (acc -> acc)))) end\n )\n\n assert_compile_error(\n ~r\"when using :reduce with comprehensions, the do block must be written using acc -> expr clauses\",\n fn -> expand(quote(do: for(x <- 1..3, reduce: %{}, do: x))) end\n )\n\n assert_compile_error(\n ~r\"when using :reduce with comprehensions, the do block must be written using acc -> expr clauses\",\n fn -> expand(quote(do: for(x <- 1..3, reduce: %{}, do: (acc, x -> x)))) end\n )\n\n assert_compile_error(\n ~r\"when using :reduce with comprehensions, the do block must be written using acc -> expr clauses\",\n fn -> expand(quote(do: for(x <- 1..3, reduce: %{}, do: (acc, x when 1 == 1 -> x)))) end\n )\n end\n\n test \"raise error for unknown options\" do\n assert_compile_error(~r\"unsupported option :else given to for\", fn ->\n expand(quote(do: for(_ <- 1..2, do: 1, else: 1)))\n end)\n\n assert_compile_error(~r\"unsupported option :other given to for\", fn ->\n expand(quote(do: for(_ <- 1..2, do: 1, other: 1)))\n end)\n end\n end\n\n describe \"with\" do\n test \"variables do not leak\" do\n before_expansion =\n quote do\n with({foo} <- {bar}, do: baz = :ok)\n baz\n end\n\n after_expansion =\n quote do\n with({foo} <- {bar()}, do: baz = :ok)\n baz()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"variables inside args expression do not leak\" do\n before_expansion =\n quote do\n with(\n b <-\n (\n a = 1\n 2\n ),\n do: {a, b}\n )\n\n a\n end\n\n after_expansion =\n quote do\n with(\n b <-\n (\n a = 1\n 2\n ),\n do: {a(), b}\n )\n\n a()\n end\n\n assert expand(before_expansion) == after_expansion\n\n before_expansion =\n quote do\n with(\n b <-\n (\n a = 1\n 2\n ),\n d <-\n (\n c = 3\n 4\n ),\n do: {a, b, c, d}\n )\n end\n\n after_expansion =\n quote do\n with(\n b <-\n (\n a = 1\n 2\n ),\n d <-\n (\n c = 3\n 4\n ),\n do: {a(), b, c(), d}\n )\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"variables are available in do option\" do\n before_expansion =\n quote do\n with({foo} <- {bar}, do: baz = foo)\n baz\n end\n\n after_expansion =\n quote do\n with({foo} <- {bar()}, do: baz = foo)\n baz()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"variables inside else do not leak\" do\n before_expansion =\n quote do\n with({foo} <- {bar}, do: :ok, else: (baz -> baz))\n baz\n end\n\n after_expansion =\n quote do\n with({foo} <- {bar()}, do: :ok, else: (baz -> baz))\n baz()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"fails if \\\"do\\\" is missing\" do\n assert_compile_error(~r\"missing :do option in \\\"with\\\"\", fn ->\n expand(quote(do: with(_ <- true, [])))\n end)\n end\n\n test \"fails on invalid else option\" do\n assert_compile_error(\n ~r\"invalid \\\"else\\\" block in \\\"with\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n expand(quote(do: with(_ <- true, do: :ok, else: [:error])))\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"else\\\" block in \\\"with\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n expand(quote(do: with(_ <- true, do: :ok, else: :error)))\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"else\\\" block in \\\"with\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n expand(quote(do: with(_ <- true, do: :ok, else: [])))\n end\n )\n end\n\n test \"fails for invalid options\" do\n # Only the required \"do\" is present alongside the unexpected option.\n assert_compile_error(~r\"unexpected option :foo in \\\"with\\\"\", fn ->\n expand(quote(do: with(_ <- true, foo: :bar, do: :ok)))\n end)\n\n # More options are present alongside the unexpected option.\n assert_compile_error(~r\"unexpected option :foo in \\\"with\\\"\", fn ->\n expand(quote(do: with(_ <- true, do: :ok, else: (_ -> :ok), foo: :bar)))\n end)\n\n assert_compile_error(~r\"unexpected option :foo in \\\"with\\\"\", fn ->\n expand(\n quote do\n with _ <- true, foo: :bar do\n :ok\n end\n end\n )\n end)\n end\n end\n\n describe \"&\" do\n test \"keeps locals\" do\n assert expand(quote(do: &unknown/2)) == {:&, [], [{:/, [], [{:unknown, [], nil}, 2]}]}\n assert expand(quote(do: &unknown(&1, &2))) == {:&, [], [{:/, [], [{:unknown, [], nil}, 2]}]}\n end\n\n test \"keeps position meta on & variables\" do\n assert expand(Code.string_to_quoted!(\"& &1\")) |> clean_meta([:counter]) ==\n {:fn, [capture: true, line: 1],\n [\n {:->, [line: 1],\n [\n [{:capture, [capture: 1, line: 1], nil}],\n {:capture, [capture: 1, line: 1], nil}\n ]}\n ]}\n end\n\n test \"removes no_parens when expanding 0-arity capture to fn\" do\n assert expand(quote(do: &foo().bar/0)) ==\n quote(do: fn -> foo().bar() end)\n end\n\n test \"expands remotes\" do\n assert expand(quote(do: &List.flatten/2)) ==\n quote(do: &:\"Elixir.List\".flatten/2)\n |> clean_meta([:imports, :context])\n\n assert expand(quote(do: &Kernel.is_atom/1)) ==\n quote(do: &:erlang.is_atom/1) |> clean_meta([:imports, :context])\n end\n\n test \"expands macros\" do\n before_expansion =\n quote do\n require Kernel.ExpansionTarget\n &Kernel.ExpansionTarget.seventeen/0\n end\n\n after_expansion =\n quote do\n :\"Elixir.Kernel.ExpansionTarget\"\n fn -> 17 end\n end\n\n assert clean_meta(expand(before_expansion), [:imports, :context, :no_parens]) ==\n after_expansion\n end\n\n test \"fails on non-continuous\" do\n assert_compile_error(~r\"capture argument &0 must be numbered between 1 and 255\", fn ->\n expand(quote(do: &foo(&0)))\n end)\n\n assert_compile_error(~r\"capture argument &2 cannot be defined without &1\", fn ->\n expand(quote(do: & &2))\n end)\n\n assert_compile_error(~r\"capture argument &255 cannot be defined without &1\", fn ->\n expand(quote(do: & &255))\n end)\n end\n\n test \"fails on block\" do\n message = ~r\"block expressions are not allowed inside the capture operator &, got: 1\\n2\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n &(\n 1\n 2\n )\n end\n\n expand(code)\n end)\n end\n\n test \"fails on other types\" do\n assert_compile_error(~r\"invalid args for &, expected one of:\", fn ->\n expand(quote(do: &:foo))\n end)\n end\n\n test \"fails on invalid arity\" do\n message = ~r\"capture argument &256 must be numbered between 1 and 255\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: &Mod.fun/256))\n end)\n end\n\n test \"fails when no captures\" do\n assert_compile_error(~r\"invalid args for &, expected one of:\", fn ->\n expand(quote(do: &foo()))\n end)\n end\n\n test \"fails on nested capture\" do\n assert_compile_error(~r\"nested captures are not allowed\", fn ->\n expand(quote(do: &(& &1)))\n end)\n end\n\n test \"fails on integers\" do\n assert_compile_error(\n ~r\"capture argument &1 must be used within the capture operator &\",\n fn -> expand(quote(do: &1)) end\n )\n end\n end\n\n describe \"fn\" do\n test \"expands each clause\" do\n before_expansion =\n quote do\n fn\n x -> x\n _ -> x\n end\n end\n\n after_expansion =\n quote do\n fn\n x -> x\n _ -> x()\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not share lexical scope between clauses\" do\n before_expansion =\n quote do\n fn\n 1 -> import List\n 2 -> flatten([1, 2, 3])\n end\n end\n\n after_expansion =\n quote do\n fn\n 1 -> :\"Elixir.List\"\n 2 -> flatten([1, 2, 3])\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expands guards\" do\n assert expand(quote(do: fn x when x when __ENV__.context -> true end)) ==\n quote(do: fn x when x when :guard -> true end)\n end\n\n test \"does not leak vars\" do\n before_expansion =\n quote do\n fn x -> x end\n x\n end\n\n after_expansion =\n quote do\n fn x -> x end\n x()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"raises on mixed arities\" do\n message = ~r\"cannot mix clauses with different arities in anonymous functions\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n fn\n x -> x\n x, y -> x + y\n end\n end\n\n expand(code)\n end)\n end\n end\n\n describe \"cond\" do\n test \"expands each clause\" do\n before_expansion =\n quote do\n cond do\n x = 1 -> x\n true -> x\n end\n end\n\n after_expansion =\n quote do\n cond do\n x = 1 -> x\n true -> x()\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not share lexical scope between clauses\" do\n before_expansion =\n quote do\n cond do\n 1 -> import List\n 2 -> flatten([1, 2, 3])\n end\n end\n\n after_expansion =\n quote do\n cond do\n 1 -> :\"Elixir.List\"\n 2 -> flatten([1, 2, 3])\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not leaks vars on head\" do\n before_expansion =\n quote do\n cond do\n x = 1 -> x\n y = 2 -> y\n end\n\n :erlang.+(x, y)\n end\n\n after_expansion =\n quote do\n cond do\n x = 1 -> x\n y = 2 -> y\n end\n\n :erlang.+(x(), y())\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not leak vars\" do\n before_expansion =\n quote do\n cond do\n 1 -> x = 1\n 2 -> y = 2\n end\n\n :erlang.+(x, y)\n end\n\n after_expansion =\n quote do\n cond do\n 1 -> x = 1\n 2 -> y = 2\n end\n\n :erlang.+(x(), y())\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expects exactly one do\" do\n assert_compile_error(~r\"missing :do option in \\\"cond\\\"\", fn ->\n expand(quote(do: cond([])))\n end)\n\n assert_compile_error(~r\"duplicate \\\"do\\\" clauses given for \\\"cond\\\"\", fn ->\n expand(quote(do: cond(do: (x -> x), do: (y -> y))))\n end)\n end\n\n test \"expects clauses\" do\n assert_compile_error(\n ~r\"invalid \\\"do\\\" block in \\\"cond\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n expand(quote(do: cond(do: :ok)))\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"do\\\" block in \\\"cond\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n expand(quote(do: cond(do: [:not, :clauses])))\n end\n )\n end\n\n test \"expects one argument in clauses\" do\n assert_compile_error(\n ~r\"expected one argument for \\\"do\\\" clauses \\(->\\) in \\\"cond\\\"\",\n fn ->\n code =\n quote do\n cond do\n _, _ -> :ok\n end\n end\n\n expand(code)\n end\n )\n end\n\n test \"raises for invalid arguments\" do\n assert_compile_error(~r\"invalid arguments for \\\"cond\\\"\", fn ->\n expand(quote(do: cond(:foo)))\n end)\n end\n\n test \"raises with invalid options\" do\n assert_compile_error(~r\"unexpected option :foo in \\\"cond\\\"\", fn ->\n expand(quote(do: cond(do: (1 -> 1), foo: :bar)))\n end)\n end\n\n test \"raises for _ in clauses\" do\n message = ~r\"invalid use of _ inside \\\"cond\\\"\\. If you want the last clause\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n cond do\n x -> x\n _ -> :raise\n end\n end\n\n expand(code)\n end)\n end\n end\n\n describe \"case\" do\n test \"expands each clause\" do\n before_expansion =\n quote do\n case w do\n x -> x\n _ -> x\n end\n end\n\n after_expansion =\n quote do\n case w() do\n x -> x\n _ -> x()\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not share lexical scope between clauses\" do\n before_expansion =\n quote do\n case w do\n 1 -> import List\n 2 -> flatten([1, 2, 3])\n end\n end\n\n after_expansion =\n quote do\n case w() do\n 1 -> :\"Elixir.List\"\n 2 -> flatten([1, 2, 3])\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expands guards\" do\n before_expansion =\n quote do\n case w do\n x when x when __ENV__.context -> true\n end\n end\n\n after_expansion =\n quote do\n case w() do\n x when x when :guard -> true\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not leaks vars on head\" do\n before_expansion =\n quote do\n case w do\n x -> x\n y -> y\n end\n\n :erlang.+(x, y)\n end\n\n after_expansion =\n quote do\n case w() do\n x -> x\n y -> y\n end\n\n :erlang.+(x(), y())\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not leak vars\" do\n before_expansion =\n quote do\n case w do\n x -> x = x\n y -> y = y\n end\n\n :erlang.+(x, y)\n end\n\n after_expansion =\n quote do\n case w() do\n x -> x = x\n y -> y = y\n end\n\n :erlang.+(x(), y())\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expects exactly one do\" do\n assert_compile_error(~r\"missing :do option in \\\"case\\\"\", fn ->\n expand(quote(do: case(e, [])))\n end)\n\n assert_compile_error(~r\"duplicate \\\"do\\\" clauses given for \\\"case\\\"\", fn ->\n expand(quote(do: case(e, do: (x -> x), do: (y -> y))))\n end)\n end\n\n test \"expects clauses\" do\n assert_compile_error(\n ~r\"invalid \\\"do\\\" block in \\\"case\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n case e do\n x\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"do\\\" block in \\\"case\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n case e do\n [:not, :clauses]\n end\n end\n\n expand(code)\n end\n )\n end\n\n test \"expects exactly one argument in clauses\" do\n assert_compile_error(\n ~r\"expected one argument for \\\"do\\\" clauses \\(->\\) in \\\"case\\\"\",\n fn ->\n code =\n quote do\n case e do\n _, _ -> :ok\n end\n end\n\n expand(code)\n end\n )\n end\n\n test \"fails with invalid arguments\" do\n assert_compile_error(~r\"invalid arguments for \\\"case\\\"\", fn ->\n expand(quote(do: case(:foo, :bar)))\n end)\n end\n\n test \"fails for invalid options\" do\n assert_compile_error(~r\"unexpected option :foo in \\\"case\\\"\", fn ->\n expand(quote(do: case(e, do: (x -> x), foo: :bar)))\n end)\n end\n end\n\n describe \"receive\" do\n test \"expands each clause\" do\n before_expansion =\n quote do\n receive do\n x -> x\n _ -> x\n end\n end\n\n after_expansion =\n quote do\n receive do\n x -> x\n _ -> x()\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not share lexical scope between clauses\" do\n before_expansion =\n quote do\n receive do\n 1 -> import List\n 2 -> flatten([1, 2, 3])\n end\n end\n\n after_expansion =\n quote do\n receive do\n 1 -> :\"Elixir.List\"\n 2 -> flatten([1, 2, 3])\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expands guards\" do\n before_expansion =\n quote do\n receive do\n x when x when __ENV__.context -> true\n end\n end\n\n after_expansion =\n quote do\n receive do\n x when x when :guard -> true\n end\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not leaks clause vars\" do\n before_expansion =\n quote do\n receive do\n x -> x\n y -> y\n end\n\n :erlang.+(x, y)\n end\n\n after_expansion =\n quote do\n receive do\n x -> x\n y -> y\n end\n\n :erlang.+(x(), y())\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not leak vars\" do\n before_expansion =\n quote do\n receive do\n x -> x = x\n y -> y = y\n end\n\n :erlang.+(x, y)\n end\n\n after_expansion =\n quote do\n receive do\n x -> x = x\n y -> y = y\n end\n\n :erlang.+(x(), y())\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"does not leak vars on after\" do\n before_expansion =\n quote do\n receive do\n x -> x = x\n after\n y ->\n y\n w = y\n end\n\n :erlang.+(x, w)\n end\n\n after_expansion =\n quote do\n receive do\n x -> x = x\n after\n y() ->\n y()\n w = y()\n end\n\n :erlang.+(x(), w())\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expects exactly one do or after\" do\n assert_compile_error(~r\"missing :do/:after option in \\\"receive\\\"\", fn ->\n expand(quote(do: receive([])))\n end)\n\n assert_compile_error(~r\"duplicate \\\"do\\\" clauses given for \\\"receive\\\"\", fn ->\n expand(quote(do: receive(do: (x -> x), do: (y -> y))))\n end)\n\n assert_compile_error(~r\"duplicate \\\"after\\\" clauses given for \\\"receive\\\"\", fn ->\n code =\n quote do\n receive do\n x -> x\n after\n y -> y\n after\n z -> z\n end\n end\n\n expand(code)\n end)\n end\n\n test \"expects clauses\" do\n assert_compile_error(\n ~r\"invalid \\\"do\\\" block in \\\"receive\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n receive do\n x\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"do\\\" block in \\\"receive\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n receive do\n [:not, :clauses]\n end\n end\n\n expand(code)\n end\n )\n end\n\n test \"expects on argument for do/after clauses\" do\n assert_compile_error(\n ~r\"expected one argument for \\\"do\\\" clauses \\(->\\) in \\\"receive\\\"\",\n fn ->\n code =\n quote do\n receive do\n _, _ -> :ok\n end\n end\n\n expand(code)\n end\n )\n\n message = ~r\"expected one argument for \\\"after\\\" clauses \\(->\\) in \\\"receive\\\"\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n receive do\n x -> x\n after\n _, _ -> :ok\n end\n end\n\n expand(code)\n end)\n end\n\n test \"expects a single clause for \\\"after\\\"\" do\n assert_compile_error(~r\"expected a single -> clause for :after in \\\"receive\\\"\", fn ->\n code =\n quote do\n receive do\n x -> x\n after\n 1 -> y\n 2 -> z\n end\n end\n\n expand(code)\n end)\n end\n\n test \"raises for invalid arguments\" do\n assert_compile_error(~r\"invalid arguments for \\\"receive\\\"\", fn ->\n expand(quote(do: receive(:foo)))\n end)\n end\n\n test \"raises with invalid options\" do\n assert_compile_error(~r\"unexpected option :foo in \\\"receive\\\"\", fn ->\n expand(quote(do: receive(do: (x -> x), foo: :bar)))\n end)\n end\n end\n\n describe \"try\" do\n test \"expands catch\" do\n before_expansion =\n quote do\n try do\n x\n catch\n x, y -> z = :erlang.+(x, y)\n end\n\n z\n end\n\n after_expansion =\n quote do\n try do\n x()\n catch\n x, y -> z = :erlang.+(x, y)\n end\n\n z()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expands catch with when\" do\n before_expansion =\n quote do\n try do\n x\n catch\n x when x -> z = :erlang.-(x)\n end\n\n z\n end\n\n after_expansion =\n quote do\n try do\n x()\n catch\n :throw, x when x -> z = :erlang.-(x)\n end\n\n z()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expands after\" do\n before_expansion =\n quote do\n try do\n x\n after\n z = y\n end\n\n z\n end\n\n after_expansion =\n quote do\n try do\n x()\n after\n z = y()\n end\n\n z()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expands else\" do\n before_expansion =\n quote do\n try do\n x\n catch\n _, _ -> :ok\n else\n z -> z\n end\n\n z\n end\n\n after_expansion =\n quote do\n try do\n x()\n catch\n _, _ -> :ok\n else\n z -> z\n end\n\n z()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expands rescue\" do\n before_expansion =\n quote do\n try do\n x\n rescue\n x -> x\n Error -> x\n end\n\n x\n end\n\n after_expansion =\n quote do\n try do\n x()\n rescue\n x -> x\n unquote(:in)(_, [:\"Elixir.Error\"]) -> x()\n end\n\n x()\n end\n\n assert expand(before_expansion) == after_expansion\n end\n\n test \"expects more than do\" do\n assert_compile_error(~r\"missing :catch/:rescue/:after option in \\\"try\\\"\", fn ->\n code =\n quote do\n try do\n x = y\n end\n\n x\n end\n\n expand(code)\n end)\n end\n\n test \"raises if do is missing\" do\n assert_compile_error(~r\"missing :do option in \\\"try\\\"\", fn ->\n expand(quote(do: try([])))\n end)\n end\n\n test \"expects at most one clause\" do\n assert_compile_error(~r\"duplicate \\\"do\\\" clauses given for \\\"try\\\"\", fn ->\n expand(quote(do: try(do: e, do: f)))\n end)\n\n assert_compile_error(~r\"duplicate \\\"rescue\\\" clauses given for \\\"try\\\"\", fn ->\n code =\n quote do\n try do\n e\n rescue\n x -> x\n rescue\n y -> y\n end\n end\n\n expand(code)\n end)\n\n assert_compile_error(~r\"duplicate \\\"after\\\" clauses given for \\\"try\\\"\", fn ->\n code =\n quote do\n try do\n e\n after\n x = y\n after\n x = y\n end\n end\n\n expand(code)\n end)\n\n assert_compile_error(~r\"duplicate \\\"else\\\" clauses given for \\\"try\\\"\", fn ->\n code =\n quote do\n try do\n e\n else\n x -> x\n else\n y -> y\n end\n end\n\n expand(code)\n end)\n\n assert_compile_error(~r\"duplicate \\\"catch\\\" clauses given for \\\"try\\\"\", fn ->\n code =\n quote do\n try do\n e\n catch\n x -> x\n catch\n y -> y\n end\n end\n\n expand(code)\n end)\n end\n\n test \"raises with invalid arguments\" do\n assert_compile_error(~r\"invalid arguments for \\\"try\\\"\", fn ->\n expand(quote(do: try(:foo)))\n end)\n end\n\n test \"raises with invalid options\" do\n assert_compile_error(~r\"unexpected option :foo in \\\"try\\\"\", fn ->\n expand(quote(do: try(do: x, foo: :bar)))\n end)\n end\n\n test \"expects exactly one argument in rescue clauses\" do\n assert_compile_error(\n ~r\"expected one argument for \\\"rescue\\\" clauses \\(->\\) in \\\"try\\\"\",\n fn ->\n code =\n quote do\n try do\n x\n rescue\n _, _ -> :ok\n end\n end\n\n expand(code)\n end\n )\n end\n\n test \"expects an alias, a variable, or \\\"var in [alias]\\\" as the argument of rescue clauses\" do\n assert_compile_error(~r\"invalid \\\"rescue\\\" clause\\. The clause should match\", fn ->\n code =\n quote do\n try do\n x\n rescue\n function(:call) -> :ok\n end\n end\n\n expand(code)\n end)\n end\n\n test \"expects one or two args for catch clauses\" do\n message = ~r\"expected one or two args for \\\"catch\\\" clauses \\(->\\) in \\\"try\\\"\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n try do\n x\n catch\n _, _, _ -> :ok\n end\n end\n\n expand(code)\n end)\n\n assert_compile_error(message, fn ->\n code =\n quote do\n try do\n x\n catch\n _, _, _ when 1 == 1 -> :ok\n end\n end\n\n expand(code)\n end)\n end\n\n test \"expects clauses for rescue, else, catch\" do\n assert_compile_error(\n ~r\"invalid \\\"rescue\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n rescue\n x\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"rescue\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n rescue\n [:not, :clauses]\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"rescue\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n rescue\n []\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"catch\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n catch\n x\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"catch\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n catch\n [:not, :clauses]\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"catch\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n catch\n []\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"else\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n catch\n _ -> :ok\n else\n x\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"else\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n catch\n _ -> :ok\n else\n [:not, :clauses]\n end\n end\n\n expand(code)\n end\n )\n\n assert_compile_error(\n ~r\"invalid \\\"else\\\" block in \\\"try\\\", it expects \\\"pattern -> expr\\\" clauses\",\n fn ->\n code =\n quote do\n try do\n e\n catch\n _ -> :ok\n else\n []\n end\n end\n\n expand(code)\n end\n )\n end\n end\n\n describe \"bitstrings\" do\n test \"parallel match\" do\n assert expand(quote(do: <> = <>)) |> clean_meta([:alignment]) ==\n quote(do: <> = <>)\n |> clean_bit_modifiers()\n\n assert expand(quote(do: <> = baz = <>)) |> clean_meta([:alignment]) ==\n quote(do: <> = baz = <>)\n |> clean_bit_modifiers()\n\n assert expand(quote(do: <> = <> = baz)) |> clean_meta([:alignment]) ==\n quote(do: <> = <> = baz())\n |> clean_bit_modifiers()\n end\n\n test \"invalid match\" do\n assert_compile_error(\n \"a bitstring only accepts binaries, numbers, and variables inside a match\",\n fn ->\n expand(quote(do: <<%{}>> = foo()))\n end\n )\n end\n\n test \"nested match\" do\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <> = rest()::binary>>))\n |> clean_meta([:alignment]) ==\n quote(do: <<45::integer, <<_::integer, _::binary>> = rest()::binary>>)\n |> clean_bit_modifiers()\n end\n\n test \"inlines binaries inside interpolation\" do\n import Kernel.ExpansionTarget\n\n # Check expansion happens only once\n assert expand(quote(do: \"foo#{message_hello(\"bar\")}\")) |> clean_meta([:alignment]) ==\n quote(do: <<\"foo\"::binary, \"bar\"::binary>>) |> clean_bit_modifiers()\n\n assert_received :hello\n refute_received :hello\n\n # And it also works in match\n assert expand(quote(do: \"foo#{bar()}\" = \"foobar\")) |> clean_meta([:alignment]) ==\n quote(do: <<\"foo\"::binary, \"bar\"::binary>> = \"foobar\")\n |> clean_bit_modifiers()\n end\n\n test \"inlines binaries inside interpolation is isomorphic after manual expansion\" do\n import Kernel.ExpansionTarget\n\n quoted = Macro.prewalk(quote(do: \"foo#{bar()}\" = \"foobar\"), &Macro.expand(&1, __ENV__))\n\n assert expand(quoted) |> clean_meta([:alignment]) ==\n quote(do: <<\"foo\"::binary, \"bar\"::binary>> = \"foobar\")\n |> clean_bit_modifiers()\n end\n\n test \"expands size * unit\" do\n import Kernel, except: [-: 1, -: 2]\n import Kernel.ExpansionTarget\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n end\n\n test \"expands binary/bitstring specifiers\" do\n import Kernel, except: [-: 1, -: 2]\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n message = ~r\"signed and unsigned specifiers are supported only on integer and float type\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <>))\n end)\n end\n\n test \"expands utf* specifiers\" do\n import Kernel, except: [-: 1, -: 2]\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n message = ~r\"signed and unsigned specifiers are supported only on integer and float type\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <>))\n end)\n\n assert_compile_error(~r\"size and unit are not supported on utf types\", fn ->\n expand(quote(do: <>))\n end)\n end\n\n test \"expands numbers specifiers\" do\n import Kernel, except: [-: 1, -: 2]\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n message =\n ~r\"integer and float types require a size specifier if the unit specifier is given\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <>))\n end)\n end\n\n test \"expands macro specifiers\" do\n import Kernel, except: [-: 1, -: 2]\n import Kernel.ExpansionTarget\n\n assert expand(quote(do: <>)) |> clean_meta([:alignment]) ==\n quote(do: <>) |> clean_bit_modifiers()\n\n assert expand(quote(do: <> = 1))\n |> clean_meta([:alignment]) ==\n quote(do: <> = 1)\n |> clean_bit_modifiers()\n end\n\n test \"expands macro in args\" do\n import Kernel, except: [-: 1, -: 2]\n\n before_expansion =\n quote do\n require Kernel.ExpansionTarget\n <>\n end\n\n after_expansion =\n quote do\n :\"Elixir.Kernel.ExpansionTarget\"\n <>\n end\n\n assert expand(before_expansion) |> clean_meta([:alignment]) ==\n clean_bit_modifiers(after_expansion)\n end\n\n test \"supports dynamic size\" do\n import Kernel, except: [-: 1, -: 2]\n\n before_expansion =\n quote do\n var = 1\n <>\n end\n\n after_expansion =\n quote do\n var = 1\n <>\n end\n\n assert expand(before_expansion) |> clean_meta([:alignment]) ==\n clean_bit_modifiers(after_expansion)\n end\n\n defmacro offset(size, binary) do\n quote do\n offset = unquote(size)\n <<_::size(^offset)>> = unquote(binary)\n end\n end\n\n test \"supports size from counters\" do\n assert offset(8, <<0>>)\n end\n\n test \"merges bitstrings\" do\n import Kernel, except: [-: 1, -: 2]\n\n assert expand(quote(do: <>, z>>)) |> clean_meta([:alignment]) ==\n quote(do: <>)\n |> clean_bit_modifiers()\n\n assert expand(quote(do: <>::bitstring, z>>))\n |> clean_meta([:alignment]) ==\n quote(do: <>)\n |> clean_bit_modifiers()\n end\n\n test \"merges binaries\" do\n import Kernel, except: [-: 1, -: 2]\n\n assert expand(quote(do: \"foo\" <> x)) |> clean_meta([:alignment]) ==\n quote(do: <<\"foo\"::binary, x()::binary>>) |> clean_bit_modifiers()\n\n assert expand(quote(do: \"foo\" <> <>)) |> clean_meta([:alignment]) ==\n quote(do: <<\"foo\"::binary, x()::integer-size(4), y()::integer-size(4)>>)\n |> clean_bit_modifiers()\n\n assert expand(quote(do: <<\"foo\", <>::binary>>))\n |> clean_meta([:alignment]) ==\n quote(do: <<\"foo\"::binary, x()::integer-size(4), y()::integer-size(4)>>)\n |> clean_bit_modifiers()\n end\n\n test \"guard expressions on size\" do\n import Kernel, except: [-: 1, -: 2, +: 1, +: 2, length: 1]\n\n # Arithmetic operations with literals and variables are valid expressions\n # for bitstring size in OTP 23+\n\n before_expansion =\n quote do\n var = 1\n <>\n end\n\n after_expansion =\n quote do\n var = 1\n <>\n end\n\n assert expand(before_expansion) |> clean_meta([:alignment]) ==\n clean_bit_modifiers(after_expansion)\n\n # Other valid guard expressions are also legal for bitstring size in OTP 23+\n\n before_expansion = quote(do: <>)\n after_expansion = quote(do: <>)\n\n assert expand(before_expansion) |> clean_meta([:alignment]) ==\n clean_bit_modifiers(after_expansion)\n end\n\n test \"map lookup on size\" do\n import Kernel, except: [-: 1, -: 2]\n\n before_expansion =\n quote do\n var = %{foo: 3}\n <>\n end\n\n after_expansion =\n quote do\n var = %{foo: 3}\n <>\n end\n\n assert expand(before_expansion) |> clean_meta([:alignment]) ==\n clean_bit_modifiers(after_expansion)\n end\n\n test \"raises on unaligned binaries in match\" do\n message = ~r\"its number of bits is not divisible by 8\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <> <> _ = \"foo\"))\n end)\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<1::4>> <> \"foo\"))\n end)\n end\n\n test \"raises on size or unit for literal bitstrings\" do\n message = ~r\"literal <<>> in bitstring supports only type specifiers\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<(<<\"foo\">>)::32>>))\n end)\n end\n\n test \"raises on size or unit for literal strings\" do\n message = ~r\"literal string in bitstring supports only endianness and type specifiers\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<\"foo\"::32>>))\n end)\n end\n\n test \"16-bit floats\" do\n import Kernel, except: [-: 1, -: 2]\n\n assert expand(quote(do: <<12.3::float-16>>)) |> clean_meta([:alignment]) ==\n quote(do: <<12.3::float-size(16)>>) |> clean_bit_modifiers()\n end\n\n test \"raises for invalid size * unit for floats\" do\n message = ~r\"float requires size\\*unit to be 16, 32, or 64 \\(default\\), got: 128\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<12.3::32*4>>))\n end)\n\n message = ~r\"float requires size\\*unit to be 16, 32, or 64 \\(default\\), got: 256\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<12.3::256>>))\n end)\n end\n\n test \"raises for invalid size\" do\n assert_compile_error(~r/undefined variable \"foo\"/, fn ->\n code =\n quote do\n fn <<_::size(foo)>> -> :ok end\n end\n\n expand(code, [])\n end)\n\n assert_compile_error(~r/undefined variable \"foo\"/, fn ->\n code =\n quote do\n fn <<_::size(foo), foo::size(8)>> -> :ok end\n end\n\n expand(code, [])\n end)\n\n assert_compile_error(~r/undefined variable \"foo\"/, fn ->\n code =\n quote do\n fn foo, <<_::size(foo)>> -> :ok end\n end\n\n expand(code, [])\n end)\n\n assert_compile_error(~r/undefined variable \"foo\"/, fn ->\n code =\n quote do\n fn foo, <<_::size(foo + 1)>> -> :ok end\n end\n\n expand(code, [])\n end)\n\n assert_compile_error(\n ~r\"cannot find or invoke local foo/0 inside a bitstring size specifier\",\n fn ->\n code =\n quote do\n fn <<_::size(foo())>> -> :ok end\n end\n\n expand(code, [])\n end\n )\n\n message = ~r\"anonymous call is not allowed inside a bitstring size specifier\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n fn <<_::size(foo.())>> -> :ok end\n end\n\n expand(code, [])\n end)\n\n message = ~r\"cannot invoke remote function inside a bitstring size specifier\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n foo = %{bar: true}\n fn <<_::size(foo.bar())>> -> :ok end\n end\n\n expand(code, [])\n end)\n\n message = ~r\"cannot invoke remote function Foo.bar/0 inside a bitstring size specifier\"\n\n assert_compile_error(message, fn ->\n code =\n quote do\n fn <<_::size(Foo.bar())>> -> :ok end\n end\n\n expand(code, [])\n end)\n end\n\n test \"raises for variable used both in pattern and size\" do\n assert_compile_error(~r/undefined variable \"foo\"/, fn ->\n code =\n quote do\n fn <> -> :ok end\n end\n\n expand(code, [])\n end)\n end\n\n test \"raises for invalid unit\" do\n message = ~r\"unit in bitstring expects an integer as argument, got: :oops\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<\"foo\"::size(8)-unit(:oops)>>))\n end)\n end\n\n test \"raises for unknown specifier\" do\n assert_compile_error(~r\"unknown bitstring specifier: unknown()\", fn ->\n expand(quote(do: <<1::unknown()>>))\n end)\n end\n\n test \"raises for conflicting specifiers\" do\n assert_compile_error(~r\"conflicting endianness specification for bit field\", fn ->\n expand(quote(do: <<1::little-big>>))\n end)\n\n assert_compile_error(~r\"conflicting unit specification for bit field\", fn ->\n expand(quote(do: <>))\n end)\n end\n\n test \"raises on binary fields with size in matches\" do\n assert expand(quote(do: <> = \"foobar\"))\n\n message = ~r\"a binary field without size is only allowed at the end of a binary pattern\"\n\n assert_compile_error(message, fn ->\n expand(quote(do: <> = \"foobar\"))\n end)\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<(<>), y::binary>> = \"foobar\"))\n end)\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<(<>), y::bitstring>> = \"foobar\"))\n end)\n\n assert_compile_error(message, fn ->\n expand(quote(do: <<(<>)::bitstring, y::bitstring>> = \"foobar\"))\n end)\n end\n end\n\n describe \"op ambiguity\" do\n test \"raises when a call is ambiguous\" do\n # We use string_to_quoted! here to avoid the formatter adding parentheses\n message = ~r[\"a -1\" looks like a function call but there is a variable named \"a\"]\n\n assert_compile_error(message, fn ->\n code =\n Code.string_to_quoted!(\"\"\"\n a = 1\n a -1\n \"\"\")\n\n expand(code)\n end)\n\n message =\n ~r[\"a -1\\.\\.\\(a \\+ 1\\)\" looks like a function call but there is a variable named \"a\"]\n\n assert_compile_error(message, fn ->\n code =\n Code.string_to_quoted!(\"\"\"\n a = 1\n a -1 .. a + 1\n \"\"\")\n\n expand(code)\n end)\n end\n end\n\n test \"handles invalid expressions\" do\n assert_compile_error(~r\"invalid quoted expression: {1, 2, 3}\", fn ->\n expand_env({1, 2, 3}, __ENV__)\n end)\n\n assert_compile_error(~r\"invalid quoted expression: #Function\\<\", fn ->\n expand({:sample, fn -> nil end})\n end)\n\n assert_compile_error(~r\"invalid pattern in match\", fn ->\n code =\n quote do\n x = & &1\n\n case true do\n x.(false) -> true\n end\n end\n\n expand(code)\n end)\n\n assert_compile_error(~r\"anonymous call is not allowed in guards\", fn ->\n code =\n quote do\n x = & &1\n\n case true do\n true when x.(true) -> true\n end\n end\n\n expand(code)\n end)\n\n assert_compile_error(~r\"invalid call foo\\(1\\)\\(2\\)\", fn ->\n expand(quote(do: foo(1)(2)))\n end)\n\n assert_compile_error(~r\"invalid call 1\\.foo\", fn ->\n expand(quote(do: 1.foo))\n end)\n\n assert_compile_error(~r\"invalid call 0\\.foo\", fn ->\n expand(quote(do: __ENV__.line.foo))\n end)\n\n assert_compile_error(~r\"misplaced operator ->\", fn ->\n expand(quote(do: (foo -> bar)))\n end)\n end\n\n ## Helpers\n\n defmacro thirteen do\n 13\n end\n\n defp assert_compile_error(message, fun) do\n assert capture_io(:stderr, fn ->\n assert_raise CompileError, fun\n end) =~ message\n end\n\n defp clean_meta(expr, vars) do\n cleaner = &Keyword.drop(&1, vars)\n Macro.prewalk(expr, &Macro.update_meta(&1, cleaner))\n end\n\n @bitstring_modifiers [\n :integer,\n :float,\n :binary,\n :utf8,\n :utf16,\n :utf32,\n :native,\n :signed,\n :bitstring,\n :little\n ]\n\n defp clean_bit_modifiers(expr) do\n Macro.prewalk(expr, fn\n {expr, meta, atom} when expr in @bitstring_modifiers and is_atom(atom) ->\n {expr, meta, nil}\n\n other ->\n other\n end)\n end\n\n defp expand(expr, extra_meta \\\\ [if_undefined: :apply]) do\n add_meta = &Keyword.merge(&1, extra_meta)\n\n expr\n |> Macro.postwalk(&Macro.update_meta(&1, add_meta))\n |> expand_env(__ENV__)\n |> elem(0)\n end\n\n defp expand_env(expr, env, to_clean \\\\ [:version, :inferred_bitstring_spec, :if_undefined]) do\n {{expr, scope, env}, _capture} =\n with_io(:stderr, fn ->\n :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)\n end)\n\n env = :elixir_env.to_caller({env.line, scope, env})\n {clean_meta(expr, to_clean), env}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/fn_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.FnTest do\n use ExUnit.Case, async: true\n\n test \"arithmetic constants on match\" do\n assert (fn -1 -> true end).(-1)\n assert (fn +1 -> true end).(1)\n end\n\n defp fun_match(x) do\n fn\n ^x -> true\n _ -> false\n end\n end\n\n test \"pin operator on match\" do\n refute fun_match(1).(0)\n assert fun_match(1).(1)\n refute fun_match(1).(1.0)\n end\n\n test \"guards with no args\" do\n fun = fn () when node() == :nonode@nohost -> true end\n assert is_function(fun, 0)\n end\n\n test \"case function hoisting does not affect anonymous fns\" do\n result =\n if Process.get(:unused, false) do\n user = :defined\n user\n else\n (fn ->\n user = :undefined\n user\n end).()\n end\n\n assert result == :undefined\n end\n\n test \"capture with access\" do\n assert (& &1[:hello]).(hello: :world) == :world\n end\n\n test \"capture remote\" do\n assert (&:erlang.atom_to_list/1).(:a) == ~c\"a\"\n assert (&Atom.to_charlist/1).(:a) == ~c\"a\"\n\n assert (&List.flatten/1).([[0]]) == [0]\n assert (&List.flatten/1).([[0]]) == [0]\n assert (&List.flatten(&1)).([[0]]) == [0]\n assert (&List.flatten(&1)) == (&List.flatten/1)\n end\n\n test \"capture local\" do\n assert (&atl/1).(:a) == ~c\"a\"\n assert (&atl/1).(:a) == ~c\"a\"\n assert (&atl(&1)).(:a) == ~c\"a\"\n end\n\n test \"capture local with question mark\" do\n assert (&atom?/1).(:a)\n assert (&atom?/1).(:a)\n assert (&atom?(&1)).(:a)\n end\n\n test \"capture imported\" do\n assert (&is_atom/1).(:a)\n assert (&is_atom/1).(:a)\n assert (&is_atom(&1)).(:a)\n assert (&is_atom(&1)) == (&is_atom/1)\n end\n\n test \"capture macro\" do\n assert (&to_string/1).(:a) == \"a\"\n assert (&to_string(&1)).(:a) == \"a\"\n assert (&Kernel.to_string/1).(:a) == \"a\"\n assert (&Kernel.to_string(&1)).(:a) == \"a\"\n end\n\n test \"capture operator\" do\n assert is_function(&+/2)\n assert is_function(& &&/2)\n assert is_function(&(&1 + &2), 2)\n assert is_function(&and/2)\n end\n\n test \"capture with variable module\" do\n mod = List\n assert (&mod.flatten(&1)).([1, [2], 3]) == [1, 2, 3]\n assert (&mod.flatten/1).([1, [2], 3]) == [1, 2, 3]\n assert (&mod.flatten/1) == (&List.flatten/1)\n end\n\n test \"local partial application\" do\n assert (&atb(&1, :utf8)).(:a) == \"a\"\n assert (&atb(List.to_atom(&1), :utf8)).(~c\"a\") == \"a\"\n end\n\n test \"imported partial application\" do\n import Record\n assert (&is_record(&1, :sample)).({:sample, 1})\n end\n\n test \"remote partial application\" do\n assert (&:erlang.binary_part(&1, 1, 2)).(\"foo\") == \"oo\"\n assert (&:erlang.binary_part(Atom.to_string(&1), 1, 2)).(:foo) == \"oo\"\n end\n\n test \"capture and partially apply tuples\" do\n assert (&{&1, &2}).(1, 2) == {1, 2}\n assert (&{&1, &2, &3}).(1, 2, 3) == {1, 2, 3}\n\n assert (&{1, &1}).(2) == {1, 2}\n assert (&{1, &1, &2}).(2, 3) == {1, 2, 3}\n end\n\n test \"capture and partially apply lists\" do\n assert (&[&1, &2]).(1, 2) == [1, 2]\n assert (&[&1, &2, &3]).(1, 2, 3) == [1, 2, 3]\n\n assert (&[1, &1]).(2) == [1, 2]\n assert (&[1, &1, &2]).(2, 3) == [1, 2, 3]\n\n assert (&[&1 | &2]).(1, 2) == [1 | 2]\n end\n\n test \"capture and partially apply on call\" do\n assert (& &1.module).(__ENV__) == __MODULE__\n end\n\n test \"capture block like\" do\n assert (&(!is_atom(&1))).(:foo) == false\n end\n\n test \"capture with function call\" do\n assert (& &1).(:ok) == :ok\n\n fun = fn a, b -> a + b end\n assert (&fun.(&1, 2)).(1) == 3\n end\n\n defmacro c(x) do\n quote do\n &(unquote(x) <> &1)\n end\n end\n\n test \"capture within capture through macro\" do\n assert (&c(&1).(\"b\")).(\"a\") == \"ab\"\n end\n\n defp atom?(atom) when is_atom(atom), do: true\n defp atom?(_), do: false\n\n defp atl(arg) do\n :erlang.atom_to_list(arg)\n end\n\n defp atb(arg, encoding) do\n :erlang.atom_to_binary(arg, encoding)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/guard_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.GuardTest do\n use ExUnit.Case, async: true\n\n import ExUnit.CaptureIO\n\n describe \"defguard(p) usage\" do\n defmodule GuardsInMacros do\n defguard is_foo(atom) when atom == :foo\n\n defmacro is_compile_time_foo(atom) when is_foo(atom) do\n quote do: unquote(__MODULE__).is_foo(unquote(atom))\n end\n end\n\n test \"guards can be used in other macros in the same module\" do\n require GuardsInMacros\n assert GuardsInMacros.is_foo(:foo)\n refute GuardsInMacros.is_foo(:baz)\n assert GuardsInMacros.is_compile_time_foo(:foo)\n end\n\n defmodule GuardsInFuns do\n defguard is_foo(atom) when atom == :foo\n defguard is_equal(foo, bar) when foo == bar\n\n def foo?(atom) when is_foo(atom) do\n is_foo(atom)\n end\n end\n\n test \"guards can be used in other funs in the same module\" do\n require GuardsInFuns\n assert GuardsInFuns.is_foo(:foo)\n refute GuardsInFuns.is_foo(:bar)\n end\n\n test \"guards do not change code evaluation semantics\" do\n require GuardsInFuns\n x = 1\n assert GuardsInFuns.is_equal(x = 2, x) == false\n assert x == 2\n end\n\n defmodule MacrosInGuards do\n defmacro is_foo(atom) do\n quote do\n unquote(atom) == :foo\n end\n end\n\n defguard is_foobar(atom) when is_foo(atom) or atom == :bar\n end\n\n test \"macros can be used in other guards in the same module\" do\n require MacrosInGuards\n assert MacrosInGuards.is_foobar(:foo)\n assert MacrosInGuards.is_foobar(:bar)\n refute MacrosInGuards.is_foobar(:baz)\n end\n\n defmodule UnquotedInGuardCall do\n @value :foo\n\n defguard unquote(String.to_atom(\"is_#{@value}\"))(x) when x == unquote(@value)\n end\n\n test \"guards names can be defined dynamically using unquote\" do\n require UnquotedInGuardCall\n assert UnquotedInGuardCall.is_foo(:foo)\n refute UnquotedInGuardCall.is_foo(:bar)\n end\n\n defmodule GuardsInGuards do\n defguard is_foo(atom) when atom == :foo\n defguard is_foobar(atom) when is_foo(atom) or atom == :bar\n end\n\n test \"guards can be used in other guards in the same module\" do\n require GuardsInGuards\n assert GuardsInGuards.is_foobar(:foo)\n assert GuardsInGuards.is_foobar(:bar)\n refute GuardsInGuards.is_foobar(:baz)\n end\n\n defmodule DefaultArgs do\n defguard is_divisible(value, remainder \\\\ 2)\n when is_integer(value) and rem(value, remainder) == 0\n end\n\n test \"permits default values in args\" do\n require DefaultArgs\n assert DefaultArgs.is_divisible(2)\n refute DefaultArgs.is_divisible(1)\n assert DefaultArgs.is_divisible(3, 3)\n refute DefaultArgs.is_divisible(3, 4)\n end\n\n test \"doesn't allow matching in args\" do\n assert_raise ArgumentError, ~r\"invalid syntax in defguard\", fn ->\n defmodule Integer.Args do\n defguard foo(value, 1) when is_integer(value)\n end\n end\n\n assert_raise ArgumentError, ~r\"invalid syntax in defguard\", fn ->\n defmodule String.Args do\n defguard foo(value, \"string\") when is_integer(value)\n end\n end\n\n assert_raise ArgumentError, ~r\"invalid syntax in defguard\", fn ->\n defmodule Atom.Args do\n defguard foo(value, :atom) when is_integer(value)\n end\n end\n\n assert_raise ArgumentError, ~r\"invalid syntax in defguard\", fn ->\n defmodule Tuple.Args do\n defguard foo(value, {foo, bar}) when is_integer(value)\n end\n end\n end\n\n defmodule GuardFromMacro do\n defmacro __using__(_) do\n quote do\n defguard is_even(value) when is_integer(value) and rem(value, 2) == 0\n end\n end\n end\n\n test \"defguard defines a guard from inside another macro\" do\n defmodule UseGuardFromMacro do\n use GuardFromMacro\n\n def assert! do\n assert is_even(0)\n refute is_even(1)\n end\n end\n\n UseGuardFromMacro.assert!()\n end\n\n defmodule IntegerPrivateGuards do\n defguardp is_even(value) when is_integer(value) and rem(value, 2) == 0\n\n def even_and_large?(value) when is_even(value) and value > 100, do: true\n def even_and_large?(_), do: false\n\n def even_and_small?(value) do\n if is_even(value) and value <= 100, do: true, else: false\n end\n end\n\n test \"defguardp defines private guards that work inside and outside guard clauses\" do\n assert IntegerPrivateGuards.even_and_large?(102)\n refute IntegerPrivateGuards.even_and_large?(98)\n refute IntegerPrivateGuards.even_and_large?(99)\n refute IntegerPrivateGuards.even_and_large?(103)\n\n assert IntegerPrivateGuards.even_and_small?(98)\n refute IntegerPrivateGuards.even_and_small?(99)\n refute IntegerPrivateGuards.even_and_small?(102)\n refute IntegerPrivateGuards.even_and_small?(103)\n\n assert_compile_error(~r\"cannot find or invoke local is_even/1\", fn ->\n defmodule IntegerPrivateGuardUtils do\n import IntegerPrivateGuards\n\n def even_and_large?(value) when is_even(value) and value > 100, do: true\n def even_and_large?(_), do: false\n end\n end)\n\n assert_compile_error(~r\"undefined function is_even/1\", fn ->\n defmodule IntegerPrivateFunctionUtils do\n import IntegerPrivateGuards\n\n def even_and_small?(value) do\n if is_even(value) and value <= 100, do: true, else: false\n end\n end\n end)\n end\n\n test \"requires a proper macro name\" do\n assert_raise ArgumentError, ~r\"invalid syntax in defguard\", fn ->\n defmodule(LiteralUsage, do: defguard(\"literal is bad\"))\n end\n\n assert_raise ArgumentError, ~r\"invalid syntax in defguard\", fn ->\n defmodule(RemoteUsage, do: defguard(Remote.call(is_bad)))\n end\n end\n\n test \"handles overriding appropriately\" do\n assert_compile_error(~r\"defmacro (.*?) already defined as def\", fn ->\n defmodule OverriddenFunUsage do\n def foo(bar), do: bar\n defguard foo(bar) when bar\n end\n end)\n\n assert_compile_error(~r\"defmacro (.*?) already defined as defp\", fn ->\n defmodule OverriddenPrivateFunUsage do\n defp foo(bar), do: bar\n defguard foo(bar) when bar\n end\n end)\n\n assert_compile_error(~r\"defmacro (.*?) already defined as defmacrop\", fn ->\n defmodule OverriddenPrivateFunUsage do\n defmacrop foo(bar), do: bar\n defguard foo(bar) when bar\n end\n end)\n\n assert_compile_error(~r\"defmacrop (.*?) already defined as def\", fn ->\n defmodule OverriddenFunUsage do\n def foo(bar), do: bar\n defguardp foo(bar) when bar\n end\n end)\n\n assert_compile_error(~r\"defmacrop (.*?) already defined as defp\", fn ->\n defmodule OverriddenPrivateFunUsage do\n defp foo(bar), do: bar\n defguardp foo(bar) when bar\n end\n end)\n\n assert_compile_error(~r\"defmacrop (.*?) already defined as defmacro\", fn ->\n defmodule OverriddenPrivateFunUsage do\n defmacro foo(bar), do: bar\n defguardp foo(bar) when bar\n end\n end)\n end\n\n test \"does not allow multiple guard clauses\" do\n assert_raise ArgumentError, ~r\"invalid syntax in defguard\", fn ->\n defmodule MultiGuardUsage do\n defguardp foo(bar, baz) when bar == 1 when baz == 2\n end\n end\n end\n\n test \"does not accept a block\" do\n assert_compile_error(~r\"undefined function defguard/2\", fn ->\n defmodule OnelinerBlockUsage do\n defguard(foo(bar), do: one_liner)\n end\n end)\n\n assert_compile_error(~r\"undefined function defguard/2\", fn ->\n defmodule MultilineBlockUsage do\n defguard foo(bar) do\n multi\n liner\n end\n end\n end)\n\n assert_compile_error(~r\"undefined function defguard/2\", fn ->\n defmodule ImplAndBlockUsage do\n defguard(foo(bar) when both_given, do: error)\n end\n end)\n end\n end\n\n describe \"defguard(p) compilation\" do\n test \"refuses to compile nonsensical code\" do\n assert_compile_error(\"cannot find or invoke local undefined/1\", fn ->\n defmodule UndefinedUsage do\n defguard foo(function) when undefined(function)\n end\n end)\n end\n\n test \"fails on expressions not allowed in guards\" do\n # Slightly unique errors\n\n assert_raise ArgumentError, ~r{invalid right argument for operator \"in\"}, fn ->\n defmodule RuntimeListUsage do\n defguard foo(bar, baz) when bar in baz\n end\n end\n\n assert_compile_error(\"cannot invoke remote function\", fn ->\n defmodule BadErlangFunctionUsage do\n defguard foo(bar) when :erlang.binary_to_atom(\"foo\")\n end\n end)\n\n assert_compile_error(\"cannot invoke remote function\", fn ->\n defmodule SendUsage do\n defguard foo(bar) when send(self(), :baz)\n end\n end)\n\n # Consistent errors\n\n assert_raise ArgumentError, ~r\"invalid expression in guard, ! is not allowed\", fn ->\n defmodule SoftNegationLogicUsage do\n defguard foo(logic) when !logic\n end\n end\n\n assert_raise ArgumentError, ~r\"invalid expression in guard, && is not allowed\", fn ->\n defmodule SoftAndLogicUsage do\n defguard foo(soft, logic) when soft && logic\n end\n end\n\n assert_raise ArgumentError, ~r\"invalid expression in guard, || is not allowed\", fn ->\n defmodule SoftOrLogicUsage do\n defguard foo(soft, logic) when soft || logic\n end\n end\n\n assert_compile_error(\n \"cannot invoke remote function :erlang\\.is_record/2 inside a guard\",\n fn ->\n defmodule IsRecord2Usage do\n defguard foo(rec) when :erlang.is_record(rec, :tag)\n end\n end\n )\n\n assert_compile_error(\n \"cannot invoke remote function :erlang\\.is_record/3 inside a guard\",\n fn ->\n defmodule IsRecord3Usage do\n defguard foo(rec) when :erlang.is_record(rec, :tag, 7)\n end\n end\n )\n\n assert_compile_error(\n ~r\"cannot invoke remote function :erlang\\.\\+\\+/2 inside a guard\",\n fn ->\n defmodule ListSubtractionUsage do\n defguard foo(list) when list ++ []\n end\n end\n )\n\n assert_compile_error(\n \"cannot invoke remote function :erlang\\.\\-\\-/2 inside a guard\",\n fn ->\n defmodule ListSubtractionUsage do\n defguard foo(list) when list -- []\n end\n end\n )\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule LocalCallUsage do\n defguard foo(local, call) when local.(call)\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule ComprehensionUsage do\n defguard foo(bar) when for(x <- [1, 2, 3], do: x * bar)\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule AliasUsage do\n defguard foo(bar) when alias(bar)\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule ImportUsage do\n defguard foo(bar) when import(bar)\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule RequireUsage do\n defguard foo(bar) when require(bar)\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule SuperUsage do\n defguard foo(bar) when super(bar)\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule SpawnUsage do\n defguard foo(bar) when spawn(& &1)\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule ReceiveUsage do\n defguard foo(bar) when receive(do: (baz -> baz))\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule CaseUsage do\n defguard foo(bar) when case(bar, do: (baz -> :baz))\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule CondUsage do\n defguard foo(bar) when cond(do: (bar -> :baz))\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule TryUsage do\n defguard foo(bar) when try(do: (baz -> baz))\n end\n end)\n\n assert_compile_error(\"invalid expression in guard\", fn ->\n defmodule WithUsage do\n defguard foo(bar) when with(do: (baz -> baz))\n end\n end)\n\n assert_compile_error(\n \"cannot invoke remote function inside a guard. \" <>\n \"If you want to do a map lookup instead, please remove parens from map.field()\",\n fn ->\n defmodule MapDot do\n def map_dot(map) when map.field(), do: true\n end\n end\n )\n\n assert_compile_error(\"cannot invoke remote function Module.fun/0 inside a guard\", fn ->\n defmodule MapDot do\n def map_dot(map) when Module.fun(), do: true\n end\n end)\n end\n end\n\n describe \"defguard(p) expansion\" do\n defguard with_unused_vars(foo, bar, _baz) when foo + bar\n\n test \"doesn't obscure unused variables\" do\n args = quote(do: [1 + 1, 2 + 2, 3 + 3])\n\n assert expand_defguard_to_string(:with_unused_vars, args, :guard) == \"\"\"\n :erlang.+(1 + 1, 2 + 2)\n \"\"\"\n\n assert expand_defguard_to_string(:with_unused_vars, args, nil) == \"\"\"\n {arg1, arg2} = {1 + 1, 2 + 2}\n :erlang.+(arg1, arg2)\n \"\"\"\n end\n\n defguard with_reused_vars(foo, bar, baz) when foo + foo + bar + baz\n\n test \"handles re-used variables\" do\n args = quote(do: [1 + 1, 2 + 2, 3 + 3])\n\n assert expand_defguard_to_string(:with_reused_vars, args, :guard) == \"\"\"\n :erlang.+(:erlang.+(:erlang.+(1 + 1, 1 + 1), 2 + 2), 3 + 3)\n \"\"\"\n\n assert expand_defguard_to_string(:with_reused_vars, args, nil) == \"\"\"\n {arg1, arg2, arg3} = {1 + 1, 2 + 2, 3 + 3}\n :erlang.+(:erlang.+(:erlang.+(arg1, arg1), arg2), arg3)\n \"\"\"\n end\n\n defguard in_list(a) when Kernel.in(a, [:test])\n\n test \"expands remote functions\" do\n assert expand_defguard_to_string(:in_list, [:not_test], :guard) == \"\"\"\n :erlang.\\\"=:=\\\"(:not_test, :test)\n \"\"\"\n end\n\n defp expand_defguard_to_string(fun, args, context) do\n {{:., [], [__MODULE__, fun]}, [], args}\n |> Macro.expand(%{__ENV__ | context: context})\n |> Macro.to_string()\n |> Kernel.<>(\"\\n\")\n end\n end\n\n defp assert_compile_error(message, fun) do\n assert capture_io(:stderr, fn ->\n assert_raise CompileError, fun\n end) =~ message\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/impl_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.ImplTest do\n use ExUnit.Case, async: true\n\n defp capture_err(fun) do\n ExUnit.CaptureIO.capture_io(:stderr, fun)\n end\n\n defp purge(module) do\n :code.purge(module)\n :code.delete(module)\n end\n\n setup do\n on_exit(fn -> purge(Kernel.ImplTest.ImplAttributes) end)\n end\n\n defprotocol AProtocol do\n def foo(term)\n def bar(term)\n end\n\n defmodule Behaviour do\n @callback foo() :: any\n end\n\n defmodule BehaviourWithArgument do\n @callback foo(any) :: any\n end\n\n defmodule BehaviourWithThreeArguments do\n @callback foo(any, any, any) :: any\n end\n\n defmodule UseBehaviourWithoutImpl do\n @callback foo_without_impl() :: any\n @callback bar_without_impl() :: any\n @callback baz_without_impl() :: any\n\n defmacro __using__(_opts) do\n quote do\n @behaviour Kernel.ImplTest.UseBehaviourWithoutImpl\n def foo_without_impl(), do: :auto_generated\n end\n end\n end\n\n defmodule UseBehaviourWithImpl do\n @callback foo_with_impl() :: any\n @callback bar_with_impl() :: any\n @callback baz_with_impl() :: any\n\n defmacro __using__(_opts) do\n quote do\n @behaviour Kernel.ImplTest.UseBehaviourWithImpl\n @impl true\n def foo_with_impl(), do: :auto_generated\n def bar_with_impl(), do: :auto_generated\n end\n end\n end\n\n defmodule MacroBehaviour do\n @macrocallback bar :: any\n end\n\n defmodule ManualBehaviour do\n def behaviour_info(:callbacks), do: [foo: 0]\n def behaviour_info(:optional_callbacks), do: :undefined\n end\n\n test \"sets @impl to boolean\" do\n defmodule ImplAttributes do\n @behaviour Behaviour\n\n @impl true\n def foo(), do: :ok\n\n @impl false\n def foo(term) do\n term\n end\n end\n end\n\n test \"sets @impl to nil\" do\n assert_raise ArgumentError, ~r/should be a module or a boolean/, fn ->\n defmodule ImplAttributes do\n @behaviour Behaviour\n @impl nil\n def foo(), do: :ok\n end\n end\n end\n\n test \"sets @impl to behaviour\" do\n defmodule ImplAttributes do\n @behaviour Behaviour\n @impl Behaviour\n def foo(), do: :ok\n end\n end\n\n test \"does not set @impl\" do\n defmodule ImplAttributes do\n @behaviour Behaviour\n def foo(), do: :ok\n end\n end\n\n test \"sets @impl to boolean on manual behaviour\" do\n defmodule ImplAttributes do\n @behaviour ManualBehaviour\n\n @impl true\n def foo(), do: :ok\n end\n end\n\n test \"warns of undefined module, but does not warn at @impl line\" do\n capture_err =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Abc\n\n @impl Abc\n def foo(), do: :ok\n end\n \"\"\")\n end)\n\n assert capture_err =~\n \"@behaviour Abc does not exist (in module Kernel.ImplTest.ImplAttributes)\"\n\n refute capture_err =~\n \"got \\\"@impl Abc\\\"\"\n end\n\n test \"warns of undefined behaviour, but does not warn at @impl line\" do\n capture_err =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Enum\n\n @impl Enum\n def foo(), do: :ok\n end\n \"\"\")\n end)\n\n assert capture_err =~\n \"module Enum is not a behaviour (in module Kernel.ImplTest.ImplAttributes)\"\n\n refute capture_err =~\n \"got \\\"@impl Abc\\\"\"\n end\n\n test \"warns of callbacks without impl and @impl has been set before\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @behaviour Kernel.ImplTest.MacroBehaviour\n\n @impl true\n def foo(), do: :ok\n\n defmacro bar(), do: :ok\n end\n \"\"\")\n end) =~\n \"module attribute @impl was not set for macro bar/0 callback (specified in Kernel.ImplTest.MacroBehaviour)\"\n end\n\n test \"warns of callbacks without impl and @impl has been set after\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @behaviour Kernel.ImplTest.MacroBehaviour\n\n defmacro bar(), do: :ok\n\n @impl true\n def foo(), do: :ok\n end\n \"\"\")\n end) =~\n \"module attribute @impl was not set for macro bar/0 callback (specified in Kernel.ImplTest.MacroBehaviour)\"\n end\n\n test \"warns when @impl is set on private function\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @impl true\n defp foo(), do: :ok\n end\n \"\"\")\n end) =~\n \"function foo/0 is private, @impl attribute is always discarded for private functions/macros\"\n end\n\n test \"warns when @impl is set and no function\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @impl true\n end\n \"\"\")\n end) =~ \"module attribute @impl was set but no definition follows it\"\n end\n\n test \"warns of @impl true and no behaviour\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @impl true\n def foo(), do: :ok\n end\n \"\"\")\n end) =~ \"got \\\"@impl true\\\" for function foo/0 but no behaviour was declared\"\n end\n\n test \"warns of @impl true with callback name not in behaviour\" do\n message =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @impl true\n def bar(), do: :ok\n end\n \"\"\")\n end)\n\n assert message =~\n \"got \\\"@impl true\\\" for function bar/0 but no behaviour specifies such callback\"\n\n assert message =~ \"The known callbacks are\"\n assert message =~ \"* Kernel.ImplTest.Behaviour.foo/0 (function)\"\n end\n\n test \"warns of @impl true with macro callback name not in behaviour\" do\n message =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.MacroBehaviour\n @impl true\n defmacro foo(), do: :ok\n end\n \"\"\")\n end)\n\n assert message =~\n \"got \\\"@impl true\\\" for macro foo/0 but no behaviour specifies such callback\"\n\n assert message =~ \"The known callbacks are\"\n assert message =~ \"* Kernel.ImplTest.MacroBehaviour.bar/0 (macro)\"\n end\n\n test \"warns of @impl true with callback kind not in behaviour\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.MacroBehaviour\n @impl true\n def foo(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl true\\\" for function foo/0 but no behaviour specifies such callback\"\n end\n\n test \"warns of @impl true with wrong arity\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @impl true\n def foo(arg), do: arg\n end\n \"\"\")\n end) =~\n \"got \\\"@impl true\\\" for function foo/1 but no behaviour specifies such callback\"\n end\n\n test \"warns of @impl false and there are no callbacks\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @impl false\n def baz(term), do: term\n end\n \"\"\")\n end) =~ \"got \\\"@impl false\\\" for function baz/1 but no behaviour was declared\"\n end\n\n test \"warns of @impl false and it is a callback\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @impl false\n def foo(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl false\\\" for function foo/0 but it is a callback specified in Kernel.ImplTest.Behaviour\"\n end\n\n test \"warns of @impl module and no behaviour\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @impl Kernel.ImplTest.Behaviour\n def foo(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl Kernel.ImplTest.Behaviour\\\" for function foo/0 but no behaviour was declared\"\n end\n\n test \"warns of @impl module with callback name not in behaviour\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @impl Kernel.ImplTest.Behaviour\n def bar(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl Kernel.ImplTest.Behaviour\\\" for function bar/0 but Kernel.ImplTest.Behaviour does not specify such callback\"\n end\n\n test \"warns of @impl module with macro callback name not in behaviour\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.MacroBehaviour\n @impl Kernel.ImplTest.MacroBehaviour\n defmacro foo(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl Kernel.ImplTest.MacroBehaviour\\\" for macro foo/0 but Kernel.ImplTest.MacroBehaviour does not specify such callback\"\n end\n\n test \"warns of @impl module with macro callback kind not in behaviour\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.MacroBehaviour\n @impl Kernel.ImplTest.MacroBehaviour\n def foo(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl Kernel.ImplTest.MacroBehaviour\\\" for function foo/0 but Kernel.ImplTest.MacroBehaviour does not specify such callback\"\n end\n\n test \"warns of @impl module and callback belongs to another known module\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @behaviour Kernel.ImplTest.MacroBehaviour\n @impl Kernel.ImplTest.Behaviour\n def bar(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl Kernel.ImplTest.Behaviour\\\" for function bar/0 but Kernel.ImplTest.Behaviour does not specify such callback\"\n end\n\n test \"warns of @impl module and callback belongs to another unknown module\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @impl Kernel.ImplTest.MacroBehaviour\n def bar(), do: :ok\n end\n \"\"\")\n end) =~\n \"got \\\"@impl Kernel.ImplTest.MacroBehaviour\\\" for function bar/0 but this behaviour was not declared with @behaviour\"\n end\n\n test \"does not warn of @impl when the function with default conforms with several typespecs\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @behaviour Kernel.ImplTest.BehaviourWithArgument\n\n @impl true\n def foo(args \\\\ []), do: args\n end\n \"\"\")\n end\n\n test \"does not warn of @impl when the function conforms to behaviour but has default value for arg\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.BehaviourWithArgument\n\n @impl true\n def foo(args \\\\ []), do: args\n end\n \"\"\")\n end\n\n test \"does not warn of @impl when the function conforms to behaviour but has additional trailing default args\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.BehaviourWithArgument\n\n @impl true\n def foo(arg_1, _args \\\\ []), do: arg_1\n end\n \"\"\")\n end\n\n test \"does not warn of @impl when the function conforms to behaviour but has additional leading default args\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.BehaviourWithArgument\n\n @impl true\n def foo(_defaulted_arg \\\\ [], args), do: args\n end\n \"\"\")\n end\n\n test \"does not warn of @impl when the function has more args than callback, but they're all defaulted\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.BehaviourWithArgument\n\n @impl true\n def foo(args \\\\ [], _bar \\\\ []), do: args\n end\n \"\"\")\n end\n\n test \"does not warn of @impl with defaults when the same function is defined multiple times\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.BehaviourWithArgument\n @behaviour Kernel.ImplTest.BehaviourWithThreeArguments\n\n @impl Kernel.ImplTest.BehaviourWithArgument\n def foo(_foo \\\\ [], _bar \\\\ []), do: :ok\n\n @impl Kernel.ImplTest.BehaviourWithThreeArguments\n def foo(_foo, _bar, _baz, _qux \\\\ []), do: :ok\n end\n \"\"\")\n end\n\n test \"does not warn of no @impl when overriding callback\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n\n def foo(), do: :overridable\n\n defoverridable Kernel.ImplTest.Behaviour\n\n def foo(), do: :overridden\n end\n \"\"\")\n end\n\n test \"does not warn of overridable function missing @impl\" do\n Code.eval_string(~S\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n\n def foo(), do: :overridable\n\n defoverridable Kernel.ImplTest.Behaviour\n\n @impl Kernel.ImplTest.Behaviour\n def foo(), do: :overridden\n end\n \"\"\")\n end\n\n test \"warns correctly of missing @impl only for end-user implemented function\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @behaviour Kernel.ImplTest.MacroBehaviour\n\n def foo(), do: :overridable\n\n defoverridable Kernel.ImplTest.Behaviour\n\n def foo(), do: :overridden\n\n @impl true\n defmacro bar(), do: :overridden\n end\n \"\"\")\n end) =~\n \"module attribute @impl was not set for function foo/0 callback (specified in Kernel.ImplTest.Behaviour)\"\n end\n\n test \"warns correctly of incorrect @impl in overridable callback\" do\n assert capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n @behaviour Kernel.ImplTest.MacroBehaviour\n\n @impl Kernel.ImplTest.MacroBehaviour\n def foo(), do: :overridable\n\n defoverridable Kernel.ImplTest.Behaviour\n\n @impl Kernel.ImplTest.Behaviour\n def foo(), do: :overridden\n end\n \"\"\")\n end) =~\n \"got \\\"@impl Kernel.ImplTest.MacroBehaviour\\\" for function foo/0 but Kernel.ImplTest.MacroBehaviour does not specify such callback\"\n end\n\n test \"warns only of non-generated functions in non-generated @impl\" do\n message =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n @behaviour Kernel.ImplTest.Behaviour\n use Kernel.ImplTest.UseBehaviourWithoutImpl\n\n @impl true\n def bar_without_impl(), do: :overridden\n def baz_without_impl(), do: :overridden\n\n defdelegate foo(), to: __MODULE__, as: :baz\n def baz(), do: :ok\n end\n \"\"\")\n end)\n\n assert message =~\n \"module attribute @impl was not set for function baz_without_impl/0 callback\"\n\n assert message =~\n \"module attribute @impl was not set for function foo/0 callback\"\n\n refute message =~ \"foo_without_impl/0\"\n end\n\n test \"warns only of non-generated functions in non-generated @impl in protocols\" do\n message =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defimpl Kernel.ImplTest.AProtocol, for: List do\n @impl true\n def foo(_list), do: :ok\n\n defdelegate bar(list), to: __MODULE__, as: :baz\n def baz(_list), do: :ok\n end\n \"\"\")\n end)\n\n assert message =~\n \"module attribute @impl was not set for function bar/1 callback\"\n end\n\n test \"warns only of generated functions in generated @impl\" do\n message =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.ImplTest.ImplAttributes do\n use Kernel.ImplTest.UseBehaviourWithImpl\n def baz_with_impl(), do: :overridden\n end\n \"\"\")\n end)\n\n assert message =~ \"module attribute @impl was not set for function bar_with_impl/0 callback\"\n refute message =~ \"foo_with_impl/0\"\n end\n\n test \"does not warn of overridable callback when using __before_compile__/1 hook\" do\n Code.eval_string(~S\"\"\"\n defmodule BeforeCompile do\n defmacro __before_compile__(_) do\n quote do\n @behaviour Kernel.ImplTest.Behaviour\n\n def foo(), do: :overridable\n\n defoverridable Kernel.ImplTest.Behaviour\n end\n end\n end\n\n defmodule Kernel.ImplTest.ImplAttributes do\n @before_compile BeforeCompile\n @behaviour Kernel.ImplTest.MacroBehaviour\n\n defmacro bar(), do: :overridable\n\n defoverridable Kernel.ImplTest.MacroBehaviour\n\n @impl Kernel.ImplTest.MacroBehaviour\n defmacro bar(), do: :overridden\n end\n \"\"\")\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/import_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.ImportTest do\n use ExUnit.Case, async: true\n\n # This should not warn due to the empty only\n import URI, only: []\n\n defmodule ImportAvailable do\n defmacro flatten do\n [flatten: 1]\n end\n end\n\n test \"multi-call\" do\n assert [List, String] = import(Elixir.{List, unquote(:String)})\n assert keymember?([a: 1], :a, 0)\n assert valid?(\"ø\")\n end\n\n test \"blank multi-call\" do\n assert [] = import(List.{})\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n test \"multi-call with options\" do\n assert [List] = import(Elixir.{List}, only: [])\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n test \"import all\" do\n assert :lists = import(:lists)\n assert flatten([1, [2], 3]) == [1, 2, 3]\n end\n\n test \"import except none\" do\n import :lists, except: []\n assert flatten([1, [2], 3]) == [1, 2, 3]\n end\n\n test \"import except one\" do\n import :lists, except: [duplicate: 2]\n assert flatten([1, [2], 3]) == [1, 2, 3]\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n test \"import only via macro\" do\n require ImportAvailable\n import :lists, only: ImportAvailable.flatten()\n assert flatten([1, [2], 3]) == [1, 2, 3]\n end\n\n defmacrop dynamic_opts do\n [only: [flatten: 1]]\n end\n\n test \"import with options via macro\" do\n import :lists, dynamic_opts()\n assert flatten([1, [2], 3]) == [1, 2, 3]\n end\n\n test \"import with double except\" do\n import :lists, except: [duplicate: 2]\n import :lists, except: [each: 2]\n assert append([1], [2, 3]) == [1, 2, 3]\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n test \"import except none respects previous import with except\" do\n import :lists, except: [duplicate: 2]\n import :lists, except: []\n assert append([1], [2, 3]) == [1, 2, 3]\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n test \"import except none respects previous import with only\" do\n import :lists, only: [append: 2]\n import :lists, except: []\n assert append([1], [2, 3]) == [1, 2, 3]\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n defmodule Underscored do\n def hello(x), do: x\n def __underscore__(x), do: x\n end\n\n defmodule ExplicitUnderscored do\n def __underscore__(x), do: x * 2\n end\n\n test \"import only with underscore\" do\n import Underscored, only: [__underscore__: 1]\n assert __underscore__(3) == 3\n end\n\n test \"import non-underscored\" do\n import ExplicitUnderscored, only: [__underscore__: 1]\n import Underscored\n assert hello(2) == 2\n assert __underscore__(3) == 6\n end\n\n defmodule MessedBitwise do\n defmacro bnot(x), do: x\n defmacro bor(x, _), do: x\n end\n\n import Bitwise, only: :functions\n\n test \"conflicting imports with only and except\" do\n import Bitwise, only: :functions, except: [bnot: 1]\n import MessedBitwise, only: [bnot: 1]\n assert bnot(0) == 0\n assert bor(0, 1) == 1\n end\n\n # This test is asserting that the imports in the\n # test above do not affect this test.\n test \"imports from other functions do not leak\" do\n assert band(1, 1) == 1\n assert bor(0, 1) == 1\n assert bnot(0) == -1\n end\n\n test \"import ambiguous\" do\n # Simply make sure that we can indeed import functions with\n # the same name and arity from different modules without the\n # import itself causing any errors.\n import List\n import String\n end\n\n test \"import many\" do\n [import(List), import(String)]\n assert capitalize(\"foo\") == \"Foo\"\n assert flatten([1, [2], 3]) == [1, 2, 3]\n end\n\n test \"does not import *_info in Erlang\" do\n import :gen_server, warn: false\n assert Macro.Env.lookup_import(__ENV__, {:module_info, 1}) == []\n assert Macro.Env.lookup_import(__ENV__, {:behaviour_info, 1}) == []\n end\n\n test \"does not import *_info in Elixir\" do\n import GenServer, warn: false\n assert Macro.Env.lookup_import(__ENV__, {:module_info, 1}) == []\n assert Macro.Env.lookup_import(__ENV__, {:behaviour_info, 1}) == []\n end\n\n defmodule ModuleWithSigils do\n def sigil_i(string, []), do: String.to_integer(string)\n\n defmacro sigil_I(string, []) do\n quote do\n String.to_integer(unquote(string))\n end\n end\n\n defmacro sigil_III(string, []) do\n quote do\n 3 * String.to_integer(unquote(string))\n end\n end\n\n def sigil_w(_string, []), do: []\n\n def bnot(x), do: x\n defmacro bor(x, _), do: x\n end\n\n test \"import only sigils\" do\n import Kernel, except: [sigil_w: 2]\n import ModuleWithSigils, only: :sigils\n\n # Ensure that both function and macro sigils are imported\n assert ~i'10' == 10\n assert ~I'10' == 10\n assert ~III'10' == 30\n assert ~w(abc def) == []\n\n # Ensure that non-sigil functions and macros from ModuleWithSigils were not loaded\n assert bnot(0) == -1\n assert bor(0, 1) == 1\n end\n\n test \"import only sigils with except\" do\n import ModuleWithSigils, only: :sigils, except: [sigil_w: 2]\n\n assert ~i'10' == 10\n assert ~I'10' == 10\n assert ~III'10' == 30\n assert ~w(abc def) == [\"abc\", \"def\"]\n end\n\n test \"import only removes the non-import part\" do\n import List\n import List, only: :macros\n # Buggy local duplicate is used because we asked only for macros\n assert duplicate([1], 2) == [1]\n end\n\n test \"import lexical on if\" do\n if false do\n import List\n flatten([1, [2], 3])\n flunk()\n else\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n end\n\n test \"import lexical on case\" do\n case Process.get(:unused, true) do\n false ->\n import List\n flatten([1, [2], 3])\n flunk()\n\n true ->\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n end\n\n test \"import lexical on for\" do\n for x <- [1, 2, 3], x > 10 do\n import List\n flatten([1, [2], 3])\n flunk()\n end\n\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n test \"import lexical on with\" do\n with [_ | _] <- List.flatten([]) do\n import List\n flatten([1, [2], 3])\n flunk()\n end\n\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n test \"import lexical on try\" do\n try do\n import List\n flatten([1, [2], 3])\n flunk()\n catch\n _, _ ->\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n # Buggy local duplicate is untouched\n assert duplicate([1], 2) == [1]\n end\n\n defp duplicate(list, _), do: list\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/lexical_tracker_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.LexicalTrackerTest do\n use ExUnit.Case, async: true\n\n alias Kernel.LexicalTracker, as: D\n defstruct used_by_tests: :ok\n\n setup do\n {:ok, pid} = D.start_link()\n {:ok, [pid: pid]}\n end\n\n test \"can add remote dispatch\", config do\n D.remote_dispatch(config[:pid], String, :runtime)\n assert D.references(config[:pid]) == {[], [], [String], []}\n\n D.remote_dispatch(config[:pid], String, :compile)\n assert D.references(config[:pid]) == {[String], [], [], []}\n\n D.remote_dispatch(config[:pid], String, :runtime)\n assert D.references(config[:pid]) == {[String], [], [], []}\n end\n\n test \"can add requires\", config do\n D.add_export(config[:pid], URI)\n assert D.references(config[:pid]) == {[], [URI], [], []}\n\n D.remote_dispatch(config[:pid], URI, :runtime)\n assert D.references(config[:pid]) == {[], [URI], [URI], []}\n\n D.remote_dispatch(config[:pid], URI, :compile)\n assert D.references(config[:pid]) == {[URI], [URI], [], []}\n end\n\n test \"can add module imports\", config do\n D.add_export(config[:pid], String)\n D.add_import(config[:pid], String, [], 1, true)\n\n D.import_dispatch(config[:pid], String, {:upcase, 1}, :runtime)\n assert D.references(config[:pid]) == {[], [String], [String], []}\n\n D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)\n assert D.references(config[:pid]) == {[String], [String], [], []}\n end\n\n test \"can add module with {function, arity} imports\", config do\n D.add_export(config[:pid], String)\n D.add_import(config[:pid], String, [upcase: 1], 1, true)\n\n D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)\n assert D.references(config[:pid]) == {[String], [String], [], []}\n end\n\n test \"can add aliases\", config do\n D.alias_dispatch(config[:pid], String)\n assert D.references(config[:pid]) == {[], [], [], []}\n end\n\n test \"unused module imports\", config do\n D.add_import(config[:pid], String, [], 1, true)\n assert D.collect_unused_imports(config[:pid]) == [{String, %{String => 1}}]\n end\n\n test \"used module imports are not unused\", config do\n D.add_import(config[:pid], String, [], 1, true)\n D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)\n assert D.collect_unused_imports(config[:pid]) == [{String, %{}}]\n end\n\n test \"unused {module, function, arity} imports\", config do\n D.add_import(config[:pid], String, [upcase: 1], 1, true)\n assert D.collect_unused_imports(config[:pid]) == [{String, %{String => 1, {:upcase, 1} => 1}}]\n end\n\n test \"used {module, function, arity} imports are not unused\", config do\n D.add_import(config[:pid], String, [upcase: 1], 1, true)\n D.add_import(config[:pid], String, [downcase: 1], 1, true)\n D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)\n assert D.collect_unused_imports(config[:pid]) == [{String, %{{:downcase, 1} => 1}}]\n end\n\n test \"overwriting {module, function, arity} import with module import\", config do\n D.add_import(config[:pid], String, [upcase: 1], 1, true)\n D.add_import(config[:pid], String, [], 1, true)\n D.import_dispatch(config[:pid], String, {:downcase, 1}, :compile)\n assert D.collect_unused_imports(config[:pid]) == [{String, %{}}]\n end\n\n test \"imports with no warn are not unused\", config do\n D.add_import(config[:pid], String, [], 1, false)\n assert D.collect_unused_imports(config[:pid]) == []\n end\n\n test \"unused requires\", config do\n D.warn_require(config[:pid], [], String, false)\n D.warn_require(config[:pid], [], List, false)\n D.remote_dispatch(config[:pid], String, :compile)\n assert D.collect_unused_requires(config[:pid]) == [{List, [], false, false}]\n end\n\n test \"function calls do not count as macro usage\", config do\n D.warn_require(config[:pid], [], String, false)\n D.remote_dispatch(config[:pid], String, :runtime)\n assert D.collect_unused_requires(config[:pid]) == [{String, [], false, false}]\n end\n\n test \"track alias usage through require\", config do\n D.warn_require(config[:pid], [], String, S)\n D.remote_dispatch(config[:pid], String, :runtime)\n assert D.collect_unused_requires(config[:pid]) == [{String, [], S, false}]\n D.alias_dispatch(config[:pid], S)\n assert D.collect_unused_requires(config[:pid]) == [{String, [], S, true}]\n end\n\n test \"unused aliases\", config do\n D.warn_alias(config[:pid], [], String, String)\n assert D.collect_unused_aliases(config[:pid]) == [{String, []}]\n end\n\n test \"used aliases are not unused\", config do\n D.warn_alias(config[:pid], [], String, String)\n D.alias_dispatch(config[:pid], String)\n assert D.collect_unused_aliases(config[:pid]) == []\n end\n\n test \"used aliases are not unused in reverse order\", config do\n D.alias_dispatch(config[:pid], String)\n D.warn_alias(config[:pid], [], String, String)\n assert D.collect_unused_aliases(config[:pid]) == []\n end\n\n describe \"references\" do\n test \"typespecs do not tag aliases nor types\" do\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.AliasTypespecs do\n alias Foo.Bar, as: Bar, warn: false\n @type bar :: Foo.Bar | Foo.Bar.t\n @opaque bar2 :: Foo.Bar.t\n @typep bar3 :: Foo.Bar.t\n @callback foo :: Foo.Bar.t\n @macrocallback foo2(Foo.Bar.t) :: Foo.Bar.t\n @spec foo(bar3) :: Foo.Bar.t\n def foo(_), do: :ok\n\n # References from specs are processed only late\n @after_compile __MODULE__\n def __after_compile__(env, _) do\n send(self(), {:references, Kernel.LexicalTracker.references(env.lexical_tracker)})\n end\n end\n \"\"\")\n\n assert_received {:references, {compile, _exports, runtime, _}}\n\n refute Elixir.Bar in runtime\n refute Elixir.Bar in compile\n\n refute Foo.Bar in runtime\n refute Foo.Bar in compile\n end\n\n test \"typespecs track structs as exports\" do\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.StructTypespecs do\n @type uri :: %URI{}\n\n # References from specs are processed only late\n @after_compile __MODULE__\n def __after_compile__(env, _) do\n send(self(), {:references, Kernel.LexicalTracker.references(env.lexical_tracker)})\n end\n end\n \"\"\")\n\n assert_received {:references, {compile, exports, runtime, _}}\n\n assert URI in runtime\n assert URI in exports\n refute URI in compile\n end\n\n test \"attributes adds dependency based on expansion\" do\n {{compile, _, _, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Attribute1 do\n @example [String, Enum, 3 + 10]\n def foo(atom) when atom in @example, do: atom\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute String in compile\n refute Enum in compile\n\n {{compile, _, _, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Attribute2 do\n @example [String, Enum]\n def foo(atom) when atom in @example, do: atom\n _ = @example\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert String in compile\n assert Enum in compile\n\n {{compile, _, _, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Attribute3 do\n @example [String, Enum]\n _ = Module.get_attribute(__MODULE__, :example)\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert String in compile\n assert Enum in compile\n\n {{compile, _, _, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Attribute4 do\n Module.register_attribute(__MODULE__, :example, accumulate: true)\n @example String\n def foo(atom) when atom in @example, do: atom\n @example Enum\n def bar(atom) when atom in @example, do: atom\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute String in compile\n refute Enum in compile\n\n {{compile, _, _, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Attribute5 do\n Module.register_attribute(__MODULE__, :example, accumulate: true)\n @example String\n def foo(atom) when atom in @example, do: atom\n @example Enum\n def bar(atom) when atom in @example, do: atom\n _ = Module.get_attribute(__MODULE__, :example)\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert String in compile\n assert Enum in compile\n\n {{compile, _, _, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Attribute6 do\n @example %{foo: Application.compile_env(:elixir, Enum, String)}\n def foo(atom) when atom == @example.foo, do: atom\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute String in compile\n refute Enum in compile\n\n {{compile, _, _, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Attribute7 do\n Module.register_attribute(__MODULE__, :example, accumulate: true)\n @example String\n @example Enum\n _ = Module.get_last_attribute(__MODULE__, :example)\n\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert String in compile\n assert Enum in compile\n end\n\n test \"@compile adds a runtime dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Compile do\n @compile {:no_warn_undefined, String}\n @compile {:no_warn_undefined, {Enum, :concat, 1}}\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute String in compile\n refute String in exports\n assert String in runtime\n\n refute Enum in compile\n refute Enum in exports\n assert Enum in runtime\n end\n\n def __before_compile__(_), do: :ok\n def __after_compile__(_, _), do: :ok\n def __on_definition__(_, _, _, _, _, _), do: :ok\n\n test \"module callbacks add a compile dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.BeforeCompile do\n @before_compile Kernel.LexicalTrackerTest\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert Kernel.LexicalTrackerTest in compile\n refute Kernel.LexicalTrackerTest in exports\n refute Kernel.LexicalTrackerTest in runtime\n\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.AfterCompile do\n @after_compile Kernel.LexicalTrackerTest\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert Kernel.LexicalTrackerTest in compile\n refute Kernel.LexicalTrackerTest in exports\n refute Kernel.LexicalTrackerTest in runtime\n\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.OnDefinition do\n @on_definition Kernel.LexicalTrackerTest\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert Kernel.LexicalTrackerTest in compile\n refute Kernel.LexicalTrackerTest in exports\n refute Kernel.LexicalTrackerTest in runtime\n end\n\n test \"defdelegate with literal adds runtime dependency\" do\n {{compile, _exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Defdelegate do\n defdelegate decode_query(query), to: URI\n\n opts = [to: Enum]\n defdelegate concat(enum), opts\n\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute URI in compile\n assert Enum in compile\n assert URI in runtime\n end\n\n test \"dbg adds a compile dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Dbg do\n def foo, do: dbg(:ok)\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert Macro in compile\n refute Macro in exports\n refute Macro in runtime\n\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.NoDbg do\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute Macro in compile\n refute Macro in exports\n refute Macro in runtime\n end\n\n test \"imports adds an export dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Imports do\n import String, warn: false\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute String in compile\n assert String in exports\n refute String in runtime\n end\n\n test \"structs are runtime/exports/compile time\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.StructRuntime do\n def expand, do: %URI{}\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute URI in compile\n assert URI in exports\n assert URI in runtime\n\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.StructCompile do\n _ = %URI{}\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert URI in compile\n assert URI in exports\n refute URI in runtime\n\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.StructPattern do\n def uri?(%URI{}), do: true\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute URI in compile\n refute URI in exports\n assert URI in runtime\n end\n\n test \"Macro.struct_info! adds an export dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.MacroStruct do\n # We do not use the alias because it would be a compile time\n # dependency. The alias may happen in practice, which is the\n # mechanism to make this expansion become a compile-time one.\n # However, in some cases, such as typespecs, we don't necessarily\n # want the compile-time dependency to happen.\n Macro.struct_info!(:\"Elixir.URI\", __ENV__)\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute URI in compile\n assert URI in exports\n refute URI in runtime\n end\n\n test \"aliases in patterns and guards inside functions do not add runtime dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.PatternGuardsRuntime do\n def uri_atom?(URI), do: true\n def range_struct?(range) when is_struct(range, Range), do: true\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute URI in compile\n refute URI in exports\n refute URI in runtime\n refute Range in compile\n refute Range in exports\n refute Range in runtime\n end\n\n test \"aliases in patterns and guards outside functions do add compile dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.PatternGuardsCompile do\n %URI{} = URI.parse(\"/\")\n case Range.new(1, 3) do\n range when is_struct(range, Range) -> :ok\n end\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert URI in compile\n assert URI in exports\n refute URI in runtime\n assert Range in compile\n refute Range in exports\n refute Range in runtime\n end\n\n test \"compile_env! does not add a compile dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.CompileEnvStruct do\n require Application\n Application.compile_env(:elixir, URI)\n Application.compile_env(:elixir, [:foo, URI, :bar])\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute URI in compile\n refute URI in exports\n assert URI in runtime\n end\n\n test \"defmodule does not add a compile dependency\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Defmodule do\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute Kernel.LexicalTrackerTest.Defmodule in compile\n refute Kernel.LexicalTrackerTest.Defmodule in exports\n refute Kernel.LexicalTrackerTest.Defmodule in runtime\n end\n\n test \"defmacro adds a compile-time dependency for local calls\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.Defmacro do\n defmacro uri(path) do\n Macro.escape(URI.parse(path))\n end\n\n def fun() do\n uri(\"/hello\")\n end\n\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert URI in compile\n refute URI in exports\n refute URI in runtime\n end\n\n test \"imported functions from quote adds dependencies\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.QuotedFun do\n import URI\n\n defmacro parse_root() do\n quote do\n parse(\"/\")\n end\n end\n end\n\n defmodule Kernel.LexicalTrackerTest.UsingQuotedFun do\n require Kernel.LexicalTrackerTest.QuotedFun, as: QF\n QF.parse_root()\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert URI in compile\n refute URI in exports\n refute URI in runtime\n end\n\n test \"imported macro from quote adds dependencies\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defmodule Kernel.LexicalTrackerTest.QuotedMacro do\n import Config\n\n defmacro config_env() do\n quote do\n config_env()\n end\n end\n end\n\n defmodule Kernel.LexicalTrackerTest.UsingQuotedMacro do\n require Kernel.LexicalTrackerTest.QuotedMacro, as: QM\n def fun(), do: QM.config_env()\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n assert Config in compile\n refute Config in exports\n refute Config in runtime\n end\n\n test \"defimpl does not add dependencies on for, only on impl\" do\n {{compile, exports, runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defimpl String.Chars, for: Kernel.LexicalTrackerTest do\n def to_string(val), do: val.used_by_tests\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute String.Chars in compile\n assert String.Chars in exports\n\n refute Kernel.LexicalTrackerTest in compile\n refute Kernel.LexicalTrackerTest in exports\n refute Kernel.LexicalTrackerTest in runtime\n end\n\n test \"defprotocol does not add dependencies on implementations\" do\n {{compile, _exports, _runtime, _}, _binding} =\n Code.eval_string(\"\"\"\n defprotocol Kernel.LexicalTracker.ProtocolTest do\n @fallback_to_any true\n def example(val)\n Kernel.LexicalTracker.references(__ENV__.lexical_tracker)\n end |> elem(3)\n \"\"\")\n\n refute Kernel.LexicalTracker.ProtocolTest.Any in compile\n refute Kernel.LexicalTracker.ProtocolTest.Tuple in compile\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/macros_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.MacrosTest.Nested do\n defmacro value, do: 1\n\n defmacro do_identity!(do: x) do\n x\n end\n\n defmacro unused_require do\n quote do\n require Integer\n end\n end\nend\n\ndefmodule Kernel.MacrosTest do\n use ExUnit.Case, async: true\n\n Kernel.MacrosTest.Nested = require Kernel.MacrosTest.Nested, as: Nested\n\n # Unused require from macro should not warn\n Kernel.MacrosTest.Nested.unused_require()\n\n @spec my_macro :: Macro.t()\n defmacro my_macro do\n quote(do: 1 + 1)\n end\n\n @spec my_private_macro :: Macro.t()\n defmacrop my_private_macro do\n quote(do: 1 + 3)\n end\n\n defmacro my_macro_with_default(value \\\\ 5) do\n quote(do: 1 + unquote(value))\n end\n\n defp by_two(x), do: x * 2\n\n defmacro my_macro_with_local(value) do\n value = by_two(by_two(value))\n quote(do: 1 + unquote(value))\n end\n\n defmacro my_macro_with_capture(value) do\n Enum.map(value, &by_two/1)\n end\n\n test \"require\" do\n assert Kernel.MacrosTest.Nested.value() == 1\n end\n\n test \"require with alias\" do\n assert Nested.value() == 1\n end\n\n test \"local with private macro\" do\n assert my_private_macro() == 4\n end\n\n test \"local with defaults macro\" do\n assert my_macro_with_default() == 6\n end\n\n test \"local with local call\" do\n assert my_macro_with_local(4) == 17\n end\n\n test \"local with capture\" do\n assert my_macro_with_capture([1, 2, 3]) == [2, 4, 6]\n end\n\n test \"macros cannot be called dynamically\" do\n x = String.to_atom(\"Elixir.Nested\")\n assert_raise UndefinedFunctionError, fn -> x.func() end\n end\n\n test \"macros with bang and do block have proper precedence\" do\n import Kernel.MacrosTest.Nested\n\n assert (do_identity! do\n 1\n end) == 1\n\n assert (Kernel.MacrosTest.Nested.do_identity! do\n 1\n end) == 1\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/overridable_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.Overridable do\n def sample do\n 1\n end\n\n def with_super do\n 1\n end\n\n def without_super do\n 1\n end\n\n def super_with_multiple_args(x, y) do\n x + y\n end\n\n def capture_super(x) do\n x\n end\n\n defmacro capture_super_macro(x) do\n x\n end\n\n def many_clauses(0) do\n 11\n end\n\n def many_clauses(1) do\n 13\n end\n\n def locals do\n undefined_function()\n end\n\n def multiple_overrides do\n [1]\n end\n\n def public_to_private do\n :public\n end\n\n defoverridable sample: 0,\n with_super: 0,\n without_super: 0,\n super_with_multiple_args: 2,\n capture_super: 1,\n capture_super_macro: 1,\n many_clauses: 1,\n locals: 0,\n multiple_overrides: 0,\n public_to_private: 0\n\n true = Module.overridable?(__MODULE__, {:without_super, 0})\n true = Module.overridable?(__MODULE__, {:with_super, 0})\n\n true = {:with_super, 0} in Module.overridables_in(__MODULE__)\n true = {:without_super, 0} in Module.overridables_in(__MODULE__)\n\n def without_super do\n :without_super\n end\n\n def with_super do\n super() + 2\n end\n\n true = Module.overridable?(__MODULE__, {:without_super, 0})\n true = Module.overridable?(__MODULE__, {:with_super, 0})\n\n true = {:with_super, 0} in Module.overridables_in(__MODULE__)\n true = {:without_super, 0} in Module.overridables_in(__MODULE__)\n\n def super_with_multiple_args(x, y) do\n super(x, y * 2)\n end\n\n def capture_super(x) do\n Enum.map(1..x, &super(&1)) ++ Enum.map(1..x, &super/1)\n end\n\n defmacro capture_super_macro(x) do\n Enum.map(1..x, &super(&1)) ++ Enum.map(1..x, &super/1)\n end\n\n def many_clauses(2) do\n 17\n end\n\n def many_clauses(3) do\n super(0) + super(1)\n end\n\n def many_clauses(x) do\n super(x)\n end\n\n def locals do\n :ok\n end\n\n def multiple_overrides do\n [2 | super()]\n end\n\n defp public_to_private do\n :private\n end\n\n def test_public_to_private do\n public_to_private()\n end\n\n defoverridable multiple_overrides: 0\n\n def multiple_overrides do\n [3 | super()]\n end\n\n ## Macros\n\n defmacro overridable_macro(x) do\n quote do\n unquote(x) + 100\n end\n end\n\n defoverridable overridable_macro: 1\n\n defmacro overridable_macro(x) do\n quote do\n unquote(super(x)) + 1000\n end\n end\n\n defmacrop private_macro(x) do\n quote do\n unquote(x) + 100\n end\n end\n\n defoverridable private_macro: 1\n\n defmacrop private_macro(x) do\n quote do\n unquote(super(x)) + 1000\n end\n end\n\n def private_macro_call(val \\\\ 11) do\n private_macro(val)\n end\n\n ## Defaults\n\n def with_default(a, b \\\\ 1) do\n a + b\n end\n\n defoverridable with_default: 2\n\n def with_default(a, b) do\n super(a + b, a + b)\n end\nend\n\ndefmodule Kernel.OverridableExampleBehaviour do\n @callback required_callback :: any\n @callback optional_callback :: any\n @macrocallback required_macro_callback(arg :: any) :: Macro.t()\n @macrocallback optional_macro_callback(arg :: any, arg2 :: any) :: Macro.t()\n @optional_callbacks optional_callback: 0, optional_macro_callback: 2\nend\n\ndefmodule Kernel.OverridableTest do\n require Kernel.Overridable, as: Overridable\n use ExUnit.Case, async: true\n\n defp purge(module) do\n :code.purge(module)\n :code.delete(module)\n end\n\n test \"overridable keeps function ordering\" do\n defmodule OverridableOrder do\n def not_private(str) do\n process_url(str)\n end\n\n def process_url(_str) do\n :first\n end\n\n # There was a bug where the order in which we removed\n # overridable expressions lead to errors. This module\n # aims to guarantee removing process_url/1 before we\n # remove the function that depends on it does not cause\n # errors. If it compiles, it works!\n defoverridable process_url: 1, not_private: 1\n\n def process_url(_str) do\n :second\n end\n end\n end\n\n test \"overridable works with defaults\" do\n defmodule OverridableDefault do\n def fun(value, opt \\\\ :from_parent) do\n {value, opt}\n end\n\n defmacro macro(value, opt \\\\ :from_parent) do\n {{value, opt}, Macro.escape(__CALLER__)}\n end\n\n # There was a bug where the default function would\n # attempt to call its overridable name instead of\n # func/1. If it compiles, it works!\n defoverridable fun: 1, fun: 2, macro: 1, macro: 2\n\n def fun(value) do\n {value, super(value)}\n end\n\n defmacro macro(value) do\n {{value, super(value)}, Macro.escape(__CALLER__)}\n end\n end\n\n defmodule OverridableCall do\n require OverridableDefault\n OverridableDefault.fun(:foo)\n OverridableDefault.macro(:bar)\n end\n end\n\n test \"overridable is made concrete if no other is defined\" do\n assert Overridable.sample() == 1\n end\n\n test \"overridable overridden with super\" do\n assert Overridable.with_super() == 3\n end\n\n test \"overridable overridden without super\" do\n assert Overridable.without_super() == :without_super\n end\n\n test \"public overridable overridden as private function\" do\n assert Overridable.test_public_to_private() == :private\n refute {:public_to_private, 0} in Overridable.module_info(:exports)\n end\n\n test \"overridable locals are ignored without super\" do\n assert Overridable.locals() == :ok\n end\n\n test \"calling super with multiple args\" do\n assert Overridable.super_with_multiple_args(1, 2) == 5\n end\n\n test \"calling super using function captures\" do\n assert Overridable.capture_super(5) == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n end\n\n test \"calling super of an overridable macro using function captures\" do\n assert Overridable.capture_super_macro(5) == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n end\n\n test \"super as a variable\" do\n super = :ok\n assert super == :ok\n end\n\n test \"overridable with many clauses\" do\n assert Overridable.many_clauses(0) == 11\n assert Overridable.many_clauses(1) == 13\n assert Overridable.many_clauses(2) == 17\n assert Overridable.many_clauses(3) == 24\n end\n\n test \"overridable definitions are private\" do\n refute {:\"with_super (overridable 0)\", 0} in Overridable.module_info(:exports)\n refute {:\"with_super (overridable 1)\", 0} in Overridable.module_info(:exports)\n end\n\n test \"multiple overrides\" do\n assert Overridable.multiple_overrides() == [3, 2, 1]\n end\n\n test \"with defaults\" do\n assert Overridable.with_default(5) == 12\n assert Overridable.with_default(5, 2) == 14\n end\n\n test \"overridable macros\" do\n a = 11\n assert Overridable.overridable_macro(a) == 1111\n assert Overridable.private_macro_call() == 1111\n end\n\n test \"invalid super call\" do\n messages = [\n \"nofile:4\",\n \"no super defined for foo/0 in module Kernel.OverridableOrder.Forwarding. \" <>\n \"Overridable functions available are: bar/0\"\n ]\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableOrder.Forwarding do\n def bar(), do: 1\n defoverridable bar: 0\n def foo(), do: super()\n end\n \"\"\")\n end)\n\n purge(Kernel.OverridableOrder.Forwarding)\n end\n\n test \"invalid super call with different arity\" do\n messages = [\n \"nofile:4\",\n \"super must be called with the same number of arguments as the current definition\"\n ]\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableSuper.DifferentArities do\n def bar(a), do: a\n defoverridable bar: 1\n def bar(_), do: super()\n end\n \"\"\")\n end)\n end\n\n test \"invalid super capture with different arity\" do\n messages = [\n \"nofile:4\",\n \"super must be called with the same number of arguments as the current definition\"\n ]\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableSuperCapture.DifferentArities do\n def bar(a), do: a\n defoverridable bar: 1\n def bar(_), do: (&super/0).()\n end\n \"\"\")\n end)\n end\n\n test \"does not allow to override a macro as a function\" do\n messages = [\n \"nofile:4\",\n \"cannot override macro (defmacro, defmacrop) foo/0 in module \" <>\n \"Kernel.OverridableMacro.FunctionOverride as a function (def, defp)\"\n ]\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableMacro.FunctionOverride do\n defmacro foo(), do: :ok\n defoverridable foo: 0\n def foo(), do: :invalid\n end\n \"\"\")\n end)\n\n purge(Kernel.OverridableMacro.FunctionOverride)\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableMacro.FunctionOverride do\n defmacro foo(), do: :ok\n defoverridable foo: 0\n def foo(), do: :invalid\n defoverridable foo: 0\n def foo(), do: :invalid\n end\n \"\"\")\n end)\n\n purge(Kernel.OverridableMacro.FunctionOverride)\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableMacro.FunctionOverride do\n defmacro foo(), do: :ok\n defoverridable foo: 0\n def foo(), do: super()\n end\n \"\"\")\n end)\n\n purge(Kernel.OverridableMacro.FunctionOverride)\n end\n\n test \"does not allow to override a function as a macro\" do\n messages = [\n \"nofile:4\",\n \"cannot override function (def, defp) foo/0 in module \" <>\n \"Kernel.OverridableFunction.MacroOverride as a macro (defmacro, defmacrop)\"\n ]\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableFunction.MacroOverride do\n def foo(), do: :ok\n defoverridable foo: 0\n defmacro foo(), do: :invalid\n end\n \"\"\")\n end)\n\n purge(Kernel.OverridableFunction.MacroOverride)\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableFunction.MacroOverride do\n def foo(), do: :ok\n defoverridable foo: 0\n defmacro foo(), do: :invalid\n defoverridable foo: 0\n defmacro foo(), do: :invalid\n end\n \"\"\")\n end)\n\n purge(Kernel.OverridableFunction.MacroOverride)\n\n assert_compile_error(messages, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableFunction.MacroOverride do\n def foo(), do: :ok\n defoverridable foo: 0\n defmacro foo(), do: super()\n end\n \"\"\")\n end)\n\n purge(Kernel.OverridableFunction.MacroOverride)\n end\n\n test \"undefined functions can't be marked as overridable\" do\n message = \"cannot make function foo/2 overridable because it was not defined\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableOrder.Foo do\n defoverridable foo: 2\n end\n \"\"\")\n end\n\n purge(Kernel.OverridableOrder.Foo)\n end\n\n test \"overrides with behaviour\" do\n defmodule OverridableWithBehaviour do\n @behaviour Elixir.Kernel.OverridableExampleBehaviour\n\n def required_callback(), do: \"original\"\n\n def optional_callback(), do: \"original\"\n\n def not_a_behaviour_callback(), do: \"original\"\n\n defmacro required_macro_callback(boolean) do\n quote do\n if unquote(boolean) do\n \"original\"\n end\n end\n end\n\n defoverridable Elixir.Kernel.OverridableExampleBehaviour\n\n defmacro optional_macro_callback(arg1, arg2), do: {arg1, arg2}\n\n assert Module.overridable?(__MODULE__, {:required_callback, 0})\n assert Module.overridable?(__MODULE__, {:optional_callback, 0})\n assert Module.overridable?(__MODULE__, {:required_macro_callback, 1})\n refute Module.overridable?(__MODULE__, {:optional_macro_callback, 1})\n refute Module.overridable?(__MODULE__, {:not_a_behaviour_callback, 1})\n end\n end\n\n test \"undefined module can't be passed as argument to defoverridable\" do\n message =\n \"cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it was not defined\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableTest.Foo do\n defoverridable Kernel.OverridableTest.Bar\n end\n \"\"\")\n end\n\n purge(Kernel.OverridableTest.Foo)\n end\n\n test \"module without @behaviour can't be passed as argument to defoverridable\" do\n message =\n \"cannot pass module Kernel.OverridableExampleBehaviour as argument to defoverridable/1\" <>\n \" because its corresponding behaviour is missing. Did you forget to add \" <>\n \"@behaviour Kernel.OverridableExampleBehaviour?\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableTest.Foo do\n defoverridable Kernel.OverridableExampleBehaviour\n end\n \"\"\")\n end\n\n purge(Kernel.OverridableTest.Foo)\n end\n\n test \"module with no callbacks can't be passed as argument to defoverridable\" do\n message =\n \"cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it does not define any callbacks\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableTest.Bar do\n end\n defmodule Kernel.OverridableTest.Foo do\n @behaviour Kernel.OverridableTest.Bar\n defoverridable Kernel.OverridableTest.Bar\n end\n \"\"\")\n end\n\n purge(Kernel.OverridableTest.Bar)\n purge(Kernel.OverridableTest.Foo)\n end\n\n test \"atom which is not a module can't be passed as argument to defoverridable\" do\n message = \"cannot pass module :abc as argument to defoverridable/1 because it was not defined\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule Kernel.OverridableTest.Foo do\n defoverridable :abc\n end\n \"\"\")\n end\n\n purge(Kernel.OverridableTest.Foo)\n end\n\n defp assert_compile_error(messages, fun) do\n captured =\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert_raise CompileError, fun\n end)\n\n for message <- List.wrap(messages) do\n assert captured =~ message\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/parallel_compiler_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\nimport PathHelpers\n\ndefmodule Kernel.ParallelCompilerTest do\n use ExUnit.Case\n import ExUnit.CaptureIO\n\n @no_warnings %{compile_warnings: [], runtime_warnings: []}\n\n defp compile(files, opts \\\\ []) do\n Kernel.ParallelCompiler.compile(files, [return_diagnostics: true] ++ opts)\n end\n\n defp purge(modules) do\n Enum.map(modules, fn mod ->\n :code.purge(mod)\n :code.delete(mod)\n end)\n end\n\n defp write_tmp(context, kv) do\n dir = tmp_path(context)\n File.rm_rf!(dir)\n File.mkdir_p!(dir)\n\n for {key, contents} <- kv do\n path = Path.join(dir, \"#{key}.ex\")\n File.write!(path, contents)\n path\n end\n end\n\n describe \"compile\" do\n test \"with profiling\" do\n fixtures =\n write_tmp(\n \"profile_time\",\n bar: \"\"\"\n defmodule HelloWorld do\n end\n \"\"\"\n )\n\n profile =\n capture_io(:stderr, fn ->\n assert {:ok, modules, @no_warnings} = compile(fixtures, profile: :time)\n\n assert HelloWorld in modules\n end)\n\n assert profile =~\n ~r\"\\[profile\\] [\\s\\d]{6}ms compiling \\+ 0ms waiting while compiling .*tmp/profile_time/bar.ex\"\n\n assert profile =~ ~r\"\\[profile\\] Finished compilation cycle of 1 modules in \\d+ms\"\n assert profile =~ ~r\"\\[profile\\] Finished group pass check of 1 modules in \\d+ms\"\n after\n purge([HelloWorld])\n end\n\n test \"immediately loads modules when not writing them to disk\" do\n fixtures =\n write_tmp(\n \"compile_loads\",\n will_be_loaded: \"\"\"\n defmodule WillBeLoaded do\n end\n true = Code.loaded?(WillBeLoaded)\n \"\"\"\n )\n\n assert {:ok, _modules, @no_warnings} = compile(fixtures)\n end\n\n test \"lazily loads modules when writing them to disk\" do\n fixtures =\n write_tmp(\n \"compile_lazy_loads\",\n will_be_lazy_loaded: \"\"\"\n defmodule WillBeLazyLoaded do\n end\n false = Code.loaded?(WillBeLazyLoaded)\n {:error, _} = Code.ensure_loaded(WillBeLazyLoaded)\n {:module, _} = Code.ensure_compiled(WillBeLazyLoaded)\n \"\"\",\n is_autoloaded: \"\"\"\n defmodule WillBeAutoLoaded do\n @compile {:autoload, true}\n end\n true = Code.loaded?(WillBeAutoLoaded)\n \"\"\"\n )\n\n assert {:ok, _modules, @no_warnings} =\n Kernel.ParallelCompiler.compile_to_path(fixtures, tmp_path(\"pcload\"),\n return_diagnostics: true\n )\n end\n\n test \"solves dependencies between modules\" do\n fixtures =\n write_tmp(\n \"parallel_compiler\",\n bar: \"\"\"\n defmodule BarParallel do\n end\n\n require FooParallel\n IO.puts(FooParallel.message())\n \"\"\",\n foo: \"\"\"\n defmodule FooParallel do\n # We use this ensure_compiled clause so both Foo and\n # Bar block. Foo depends on Unknown and Bar depends on\n # Foo. The compiler will see this dependency and first\n # release Foo and then Bar, compiling with success.\n {:error, _} = Code.ensure_compiled(Unknown)\n def message, do: \"message_from_foo\"\n end\n \"\"\"\n )\n\n assert capture_io(fn ->\n assert {:ok, modules, @no_warnings} = compile(fixtures)\n assert BarParallel in modules\n assert FooParallel in modules\n end) =~ \"message_from_foo\"\n after\n purge([FooParallel, BarParallel])\n end\n\n test \"solves dependencies between structs\" do\n fixtures =\n write_tmp(\n \"parallel_struct\",\n bar: \"\"\"\n defmodule BarStruct do\n defstruct name: \"\", foo: %FooStruct{}\n end\n \"\"\",\n foo: \"\"\"\n defmodule FooStruct do\n defstruct name: \"\"\n def bar?(%BarStruct{}), do: true\n end\n \"\"\"\n )\n\n assert {:ok, modules, @no_warnings} = compile(fixtures)\n assert [BarStruct, FooStruct] = Enum.sort(modules)\n after\n purge([FooStruct, BarStruct])\n end\n\n test \"solves dependencies between structs in typespecs\" do\n fixtures =\n write_tmp(\n \"parallel_typespec_struct\",\n bar: \"\"\"\n defmodule BarStruct do\n defstruct name: \"\"\n @type t :: %FooStruct{}\n end\n \"\"\",\n foo: \"\"\"\n defmodule FooStruct do\n defstruct name: \"\"\n @type t :: %BarStruct{}\n end\n \"\"\"\n )\n\n assert {:ok, modules, @no_warnings} = compile(fixtures)\n assert [BarStruct, FooStruct] = Enum.sort(modules)\n after\n purge([FooStruct, BarStruct])\n end\n\n test \"returns struct undefined error when local struct is undefined\" do\n [fixture] =\n write_tmp(\n \"compile_struct\",\n undef: \"\"\"\n defmodule Undef do\n def undef() do\n %__MODULE__{}\n end\n end\n \"\"\"\n )\n\n expected_msg = \"Undef.__struct__/1 is undefined, cannot expand struct Undef\"\n\n assert capture_io(:stderr, fn ->\n assert {:error,\n [\n %{file: ^fixture, position: {3, 5}, message: msg},\n %{file: ^fixture, position: 0, message: compile_msg}\n ], @no_warnings} =\n compile([fixture])\n\n assert msg =~ expected_msg\n assert compile_msg =~ \"cannot compile module Undef (errors have been logged)\"\n end) =~ expected_msg\n end\n\n test \"returns error when fails to expand struct\" do\n [fixture] =\n write_tmp(\n \"compile_struct_invalid_key\",\n undef: \"\"\"\n defmodule InvalidStructKey do\n def invalid_struct_key() do\n %Date{invalid_key: 2020}\n end\n end\n \"\"\"\n )\n\n expected_msg = \"** (KeyError) key :invalid_key not found\"\n\n assert capture_io(:stderr, fn ->\n assert {:error, [%{file: ^fixture, position: 3, message: msg}], @no_warnings} =\n compile([fixture])\n\n assert msg =~ expected_msg\n end) =~ expected_msg\n end\n\n test \"does not crash with pending monitor message\" do\n {pid, ref} = spawn_monitor(fn -> :ok end)\n\n [fixture] =\n write_tmp(\n \"quick_example\",\n quick_example: \"\"\"\n defmodule QuickExample do\n end\n \"\"\"\n )\n\n assert {:ok, [QuickExample], @no_warnings} = compile([fixture])\n assert_received {:DOWN, ^ref, _, ^pid, :normal}\n after\n purge([QuickExample])\n end\n\n test \"does not crash on external reports\" do\n [fixture] =\n write_tmp(\n \"compile_quoted\",\n quick_example: \"\"\"\n defmodule CompileQuoted do\n try do\n Code.compile_quoted({:fn, [], [{:->, [], [[], quote(do: unknown_var)]}]})\n rescue\n _ -> :ok\n end\n end\n \"\"\"\n )\n\n assert capture_io(:stderr, fn ->\n assert {:ok, [CompileQuoted], @no_warnings} = compile([fixture])\n end) =~ \"undefined variable \\\"unknown_var\\\"\"\n after\n purge([CompileQuoted])\n end\n\n test \"does not hang on missing dependencies\" do\n [fixture] =\n write_tmp(\n \"compile_does_not_hang\",\n with_behaviour_and_struct: \"\"\"\n # We need to ensure it won't block even after multiple calls.\n # So we use both behaviour and struct expansion below.\n defmodule WithBehaviourAndStruct do\n # @behaviour will call ensure_compiled().\n @behaviour :unknown\n # Struct expansion calls it as well.\n %ThisModuleWillNeverBeAvailable{}\n end\n \"\"\"\n )\n\n expected_msg =\n \"ThisModuleWillNeverBeAvailable.__struct__/1 is undefined, cannot expand struct ThisModuleWillNeverBeAvailable\"\n\n assert capture_io(:stderr, fn ->\n assert {:error,\n [\n %{file: ^fixture, position: {7, 3}, message: msg},\n %{file: ^fixture, position: 0, message: compile_msg}\n ], @no_warnings} =\n compile([fixture])\n\n assert msg =~ expected_msg\n\n assert compile_msg =~\n \"cannot compile module WithBehaviourAndStruct (errors have been logged)\"\n end) =~ expected_msg\n end\n\n test \"does not deadlock on missing dependencies\" do\n [missing_struct, depends_on] =\n write_tmp(\n \"does_not_deadlock\",\n missing_struct: \"\"\"\n defmodule MissingStruct do\n %ThisModuleWillNeverBeAvailable{}\n def hello, do: :ok\n end\n \"\"\",\n depends_on_missing_struct: \"\"\"\n MissingStruct.hello()\n \"\"\"\n )\n\n expected_msg =\n \"ThisModuleWillNeverBeAvailable.__struct__/1 is undefined, cannot expand struct ThisModuleWillNeverBeAvailable\"\n\n assert capture_io(:stderr, fn ->\n assert {:error,\n [\n %{file: ^missing_struct, position: {2, 3}, message: msg},\n %{file: ^missing_struct, position: 0, message: compile_msg}\n ], @no_warnings} =\n compile([missing_struct, depends_on])\n\n assert msg =~ expected_msg\n\n assert compile_msg =~\n \"cannot compile module MissingStruct (errors have been logged)\"\n end) =~ expected_msg\n end\n\n test \"does not deadlock on missing import/struct dependencies\" do\n [missing_import, depends_on] =\n write_tmp(\n \"import_and_structs\",\n missing_import: \"\"\"\n defmodule MissingStruct do\n import Unknown.Module\n end\n \"\"\",\n depends_on_missing_struct: \"\"\"\n %MissingStruct{}\n \"\"\"\n )\n\n expected_msg = \"module Unknown.Module is not loaded and could not be found\"\n\n assert capture_io(:stderr, fn ->\n assert {:error,\n [\n %{file: ^missing_import, position: {2, 3}, message: msg},\n %{file: ^missing_import, position: 0, message: compile_msg}\n ], @no_warnings} =\n compile([missing_import, depends_on])\n\n assert msg =~ expected_msg\n\n assert compile_msg =~\n \"cannot compile module MissingStruct (errors have been logged)\"\n end) =~ expected_msg\n end\n\n test \"handles deadlocks\" do\n [foo, bar] =\n write_tmp(\n \"parallel_deadlock\",\n foo: \"\"\"\n defmodule FooDeadlock do\n BarDeadlock.__info__(:module)\n end\n \"\"\",\n bar: \"\"\"\n defmodule BarDeadlock do\n %FooDeadlock{}\n end\n \"\"\"\n )\n\n msg =\n capture_io(:stderr, fn ->\n fixtures = [foo, bar]\n assert {:error, [bar_error, foo_error], @no_warnings} = compile(fixtures)\n\n assert %{file: ^bar, position: 2, message: \"deadlocked waiting on struct FooDeadlock\"} =\n bar_error\n\n assert %{file: ^foo, position: nil, message: \"deadlocked waiting on module BarDeadlock\"} =\n foo_error\n end)\n\n assert msg =~ \"Compilation failed because of a deadlock between files.\"\n assert msg =~ \"parallel_deadlock/foo.ex => BarDeadlock\"\n assert msg =~ \"parallel_deadlock/bar.ex => FooDeadlock\"\n assert msg =~ ~r\"== Compilation error in file .+parallel_deadlock/foo\\.ex ==\"\n assert msg =~ \"** (CompileError) deadlocked waiting on module BarDeadlock\"\n assert msg =~ ~r\"== Compilation error in file .+parallel_deadlock/bar\\.ex:2 ==\"\n assert msg =~ \"** (CompileError) deadlocked waiting on struct FooDeadlock\"\n end\n\n test \"does not deadlock from Code.ensure_compiled\" do\n [foo, bar] =\n write_tmp(\n \"parallel_ensure_nodeadlock\",\n foo: \"\"\"\n defmodule FooCircular do\n {:error, :unavailable} = Code.ensure_compiled(BarCircular)\n end\n \"\"\",\n bar: \"\"\"\n defmodule BarCircular do\n {:error, :unavailable} = Code.ensure_compiled(FooCircular)\n end\n \"\"\"\n )\n\n assert {:ok, _modules, @no_warnings} = compile([foo, bar])\n assert Enum.sort([FooCircular, BarCircular]) == [BarCircular, FooCircular]\n after\n purge([FooCircular, BarCircular])\n end\n\n test \"handles pmap compilation\" do\n [foo, bar] =\n write_tmp(\n \"async_compile\",\n foo: \"\"\"\n defmodule FooAsync do\n true = Code.can_await_module_compilation?()\n\n [BarAsync] =\n Kernel.ParallelCompiler.pmap([:ok], fn :ok ->\n true = Code.can_await_module_compilation?()\n BarAsync.__info__(:module)\n end)\n end\n \"\"\",\n bar: \"\"\"\n defmodule BarAsync do\n true = Code.can_await_module_compilation?()\n end\n \"\"\"\n )\n\n capture_io(:stderr, fn ->\n fixtures = [foo, bar]\n assert {:ok, modules, @no_warnings} = compile(fixtures)\n assert FooAsync in modules\n assert BarAsync in modules\n end)\n after\n purge([FooAsync, BarAsync])\n end\n\n test \"handles pmap deadlocks\" do\n [foo, bar] =\n write_tmp(\n \"async_deadlock\",\n foo: \"\"\"\n defmodule FooAsyncDeadlock do\n Kernel.ParallelCompiler.pmap([:ok], fn :ok ->\n BarAsyncDeadlock.__info__(:module)\n end)\n end\n \"\"\",\n bar: \"\"\"\n defmodule BarAsyncDeadlock do\n FooAsyncDeadlock.__info__(:module)\n end\n \"\"\"\n )\n\n capture_io(:stderr, fn ->\n fixtures = [foo, bar]\n assert {:error, [bar_error, foo_error], @no_warnings} = compile(fixtures)\n\n assert %{\n file: ^bar,\n position: nil,\n message: \"deadlocked waiting on module FooAsyncDeadlock\"\n } = bar_error\n\n assert %{file: ^foo, position: nil, message: \"deadlocked waiting on pmap [#PID<\" <> _} =\n foo_error\n end)\n end\n\n test \"does not use incorrect line number when error originates in another file\" do\n File.mkdir_p!(tmp_path())\n\n [a, b] =\n write_tmp(\n \"error_line\",\n a: \"\"\"\n defmodule PCA do\n def fun(arg), do: arg / 2\n end\n \"\"\",\n b: \"\"\"\n defmodule PCB do\n def fun(arg) do\n PCA.fun(arg)\n :ok\n end\n end\n PCB.fun(:not_a_number)\n \"\"\"\n )\n\n capture_io(:stderr, fn ->\n assert {:error, [%{file: ^b, position: 0, message: _}], _} = compile([a, b])\n end)\n end\n\n test \"gets both source and file on @file annotations\" do\n File.mkdir_p!(tmp_path())\n\n [a] =\n write_tmp(\n \"file_source\",\n a: \"\"\"\n defmodule FileAttr do\n @file \"unknown.foo.bar\"\n def fun, do: (unused = :ok)\n end\n \"\"\"\n )\n\n capture_io(:stderr, fn ->\n assert {:ok, [FileAttr], %{compile_warnings: [%{source: ^a, file: file, message: _}]}} =\n compile([a])\n\n assert String.ends_with?(file, \"unknown.foo.bar\")\n assert Path.type(file) == :absolute\n end)\n after\n purge([FileAttr])\n end\n\n test \"gets correct line number for UndefinedFunctionError\" do\n File.mkdir_p!(tmp_path())\n\n [fixture] =\n write_tmp(\"undef\",\n undef: \"\"\"\n defmodule UndefErrorLine do\n Bogus.fun()\n end\n \"\"\"\n )\n\n capture_io(:stderr, fn ->\n assert {:error, [%{file: ^fixture, position: 2, message: _}], _} = compile([fixture])\n end)\n end\n\n test \"gets correct file+line+column number for SyntaxError\" do\n File.mkdir_p!(tmp_path())\n\n [fixture] =\n write_tmp(\"error\",\n error: \"\"\"\n raise SyntaxError, file: \"foo/bar.ex\", line: 3, column: 10\n \"\"\"\n )\n\n file = Path.absname(\"foo/bar.ex\")\n\n capture_io(:stderr, fn ->\n assert {:error, [%{file: ^file, source: ^fixture, position: {3, 10}}], _} =\n compile([fixture])\n end)\n end\n\n test \"gets proper beam destinations from dynamic modules\" do\n fixtures =\n write_tmp(\n \"dynamic\",\n dynamic: \"\"\"\n Module.create(Dynamic, quote(do: :ok), file: \"dynamic.ex\")\n [_ | _] = :code.which(Dynamic)\n \"\"\"\n )\n\n assert {:ok, [Dynamic], @no_warnings} = compile(fixtures, dest: \"sample\")\n after\n purge([Dynamic])\n end\n end\n\n describe \"require\" do\n test \"returns struct undefined error when local struct is undefined\" do\n [fixture] =\n write_tmp(\n \"require_struct\",\n undef: \"\"\"\n defmodule Undef do\n def undef() do\n %__MODULE__{}\n end\n end\n \"\"\"\n )\n\n expected_msg = \"Undef.__struct__/1 is undefined, cannot expand struct Undef\"\n\n assert capture_io(:stderr, fn ->\n assert {:error,\n [\n %{file: ^fixture, position: {3, 5}, message: msg},\n %{file: ^fixture, position: 0, message: compile_msg}\n ], @no_warnings} =\n Kernel.ParallelCompiler.require([fixture], return_diagnostics: true)\n\n assert msg =~ expected_msg\n assert compile_msg =~ \"cannot compile module Undef (errors have been logged)\"\n end) =~ expected_msg\n end\n\n test \"does not hang on missing dependencies\" do\n [fixture] =\n write_tmp(\n \"require_does_not_hang\",\n with_behaviour_and_struct: \"\"\"\n # We need to ensure it won't block even after multiple calls.\n # So we use both behaviour and struct expansion below.\n defmodule WithBehaviourAndStruct do\n # @behaviour will call ensure_compiled().\n @behaviour :unknown\n # Struct expansion calls it as well.\n %ThisModuleWillNeverBeAvailable{}\n end\n \"\"\"\n )\n\n expected_msg =\n \"ThisModuleWillNeverBeAvailable.__struct__/1 is undefined, cannot expand struct ThisModuleWillNeverBeAvailable\"\n\n assert capture_io(:stderr, fn ->\n assert {:error,\n [\n %{file: ^fixture, position: {7, 3}, message: msg},\n %{file: ^fixture, position: 0, message: compile_msg}\n ], @no_warnings} =\n Kernel.ParallelCompiler.require([fixture], return_diagnostics: true)\n\n assert msg =~ expected_msg\n\n assert compile_msg =~\n \"cannot compile module WithBehaviourAndStruct (errors have been logged)\"\n end) =~ expected_msg\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/parser_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.ParserTest do\n use ExUnit.Case, async: true\n\n test \"empty\" do\n assert Code.string_to_quoted!(\"\") == {:__block__, [line: 1], []}\n assert Code.string_to_quoted!(\"\", columns: true) == {:__block__, [line: 1, column: 1], []}\n\n assert Code.string_to_quoted!(\" \\n\") == {:__block__, [line: 1], []}\n assert Code.string_to_quoted!(\" \\n\", columns: true) == {:__block__, [line: 1, column: 1], []}\n end\n\n describe \"nullary ops\" do\n test \"in expressions\" do\n assert parse!(\"..\") == {:.., [line: 1], []}\n assert parse!(\"...\") == {:..., [line: 1], []}\n end\n\n test \"in capture\" do\n assert parse!(\"&../0\") == {:&, [line: 1], [{:/, [line: 1], [{:.., [line: 1], nil}, 0]}]}\n assert parse!(\"&.../0\") == {:&, [line: 1], [{:/, [line: 1], [{:..., [line: 1], nil}, 0]}]}\n end\n\n test \"raises on ambiguous uses when also binary\" do\n assert_raise SyntaxError, ~r/syntax error before: do/, fn ->\n parse!(\"if .. do end\")\n end\n end\n end\n\n describe \"unary ops\" do\n test \"in keywords\" do\n assert parse!(\"f(!: :ok)\") == {:f, [line: 1], [[!: :ok]]}\n assert parse!(\"f @: :ok\") == {:f, [line: 1], [[@: :ok]]}\n end\n\n test \"in maps\" do\n assert parse!(\"%{+foo, bar => bat, ...baz}\") ==\n {:%{}, [line: 1],\n [\n {:+, [line: 1], [{:foo, [line: 1], nil}]},\n {{:bar, [line: 1], nil}, {:bat, [line: 1], nil}},\n {:..., [line: 1], [{:baz, [line: 1], nil}]}\n ]}\n end\n\n test \"ambiguous ops\" do\n assert parse!(\"f -var\") ==\n {:f, [ambiguous_op: nil, line: 1], [{:-, [line: 1], [{:var, [line: 1], nil}]}]}\n\n assert parse!(\"f -(var)\") ==\n {:f, [ambiguous_op: nil, line: 1], [{:-, [line: 1], [{:var, [line: 1], nil}]}]}\n\n assert parse!(\"f +-var\") ==\n {:f, [{:ambiguous_op, nil}, {:line, 1}],\n [{:+, [line: 1], [{:-, [line: 1], [{:var, [line: 1], nil}]}]}]}\n\n assert parse!(\"f - var\") ==\n {:-, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 1], nil}]}\n\n assert parse!(\"f --var\") ==\n {:--, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 1], nil}]}\n\n assert parse!(\"(f ->var)\") ==\n [{:->, [line: 1], [[{:f, [line: 1], nil}], {:var, [line: 1], nil}]}]\n end\n\n test \"ambiguous ops in keywords\" do\n assert parse!(\"f(+: :ok)\") == {:f, [line: 1], [[+: :ok]]}\n assert parse!(\"f +: :ok\") == {:f, [line: 1], [[+: :ok]]}\n assert parse!(\"f +:\\n:ok\") == {:f, [line: 1], [[+: :ok]]}\n end\n end\n\n describe \"ternary ops\" do\n test \"root\" do\n assert parse!(\"1..2//3\") == {:..//, [line: 1], [1, 2, 3]}\n assert parse!(\"(1..2)//3\") == {:..//, [line: 1], [1, 2, 3]}\n end\n\n test \"with do-blocks\" do\n assert parse!(\"foo do end..bar do end//baz do end\") == {\n :..//,\n [line: 1],\n [\n {:foo, [line: 1], [[do: {:__block__, [line: 1], []}]]},\n {:bar, [line: 1], [[do: {:__block__, [line: 1], []}]]},\n {:baz, [line: 1], [[do: {:__block__, [line: 1], []}]]}\n ]\n }\n end\n\n test \"with no parens\" do\n assert parse!(\"1..foo do end//bar bat\") == {\n :..//,\n [line: 1],\n [\n 1,\n {:foo, [line: 1], [[do: {:__block__, [line: 1], []}]]},\n {:bar, [line: 1], [{:bat, [line: 1], nil}]}\n ]\n }\n end\n\n test \"errors\" do\n msg =\n \"the range step operator (//) must immediately follow the range definition operator (..)\"\n\n assert_syntax_error([msg], \"foo..bar baz//bat\")\n assert_syntax_error([msg], \"foo++bar//bat\")\n assert_syntax_error([msg], \"foo..(bar//bat)\")\n end\n end\n\n describe \"\\\\\\\\ + newline\" do\n test \"with ambiguous ops\" do\n assert parse!(\"f \\\\\\n-var\") ==\n {:f, [ambiguous_op: nil, line: 1], [{:-, [line: 2], [{:var, [line: 2], nil}]}]}\n\n assert parse!(\"f \\\\\\n- var\") ==\n {:-, [line: 2], [{:f, [line: 1], nil}, {:var, [line: 2], nil}]}\n\n assert parse!(\"f -\\\\\\nvar\") ==\n {:-, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 2], nil}]}\n\n assert parse!(\"f -\\\\\\n var\") ==\n {:-, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 2], nil}]}\n end\n\n test \"with capture\" do\n assert parse!(\"&..//\\\\\\n/3\") ==\n {:&, [line: 1], [{:/, [line: 2], [{:..//, [line: 1], nil}, 3]}]}\n\n assert parse!(\"&\\\\\\n+/2\") == {:&, [line: 1], [{:/, [line: 2], [{:+, [line: 2], nil}, 2]}]}\n assert parse!(\"&\\\\\\n//2\") == {:&, [line: 1], [{:/, [line: 2], [{:/, [line: 2], nil}, 2]}]}\n assert parse!(\"&\\\\\\nor/2\") == {:&, [line: 1], [{:/, [line: 2], [{:or, [line: 2], nil}, 2]}]}\n\n assert parse!(\"&+\\\\\\n/2\") == {:&, [line: 1], [{:/, [line: 2], [{:+, [line: 1], nil}, 2]}]}\n assert parse!(\"&/\\\\\\n/2\") == {:&, [line: 1], [{:/, [line: 2], [{:/, [line: 1], nil}, 2]}]}\n assert parse!(\"&or\\\\\\n/2\") == {:&, [line: 1], [{:/, [line: 2], [{:or, [line: 1], nil}, 2]}]}\n\n assert parse!(\"&+/\\\\\\n2\") == {:&, [line: 1], [{:/, [line: 1], [{:+, [line: 1], nil}, 2]}]}\n assert parse!(\"&//\\\\\\n2\") == {:&, [line: 1], [{:/, [line: 1], [{:/, [line: 1], nil}, 2]}]}\n assert parse!(\"&or/\\\\\\n2\") == {:&, [line: 1], [{:/, [line: 1], [{:or, [line: 1], nil}, 2]}]}\n end\n end\n\n describe \"identifier unicode normalization\" do\n test \"stops at ascii codepoints\" do\n assert {:ok, {:ç, _, nil}} = Code.string_to_quoted(\"ç\\n\")\n assert {:ok, {:\\\\, _, [{:ç, _, nil}, 1]}} = Code.string_to_quoted(~S\"ç\\\\1\")\n end\n\n test \"nfc normalization is performed\" do\n # before elixir 1.14, non-nfc would error\n # non-nfc: \"ç\" (code points 0x0063 0x0327)\n # nfc-normalized: \"ç\" (code points 0x00E7)\n assert Code.eval_string(\"ç = 1; ç\") == {1, [ç: 1]}\n end\n\n test \"elixir's additional normalization is performed\" do\n # Common micro => Greek mu. See code formatter test too.\n assert Code.eval_string(\"µs = 1; μs\") == {1, [{:μs, 1}]}\n\n # commented out: math symbols capability in elixir\n # normalizations, to ensure that we *can* handle codepoints\n # that are Common-script and non-ASCII\n # assert Code.eval_string(\"_ℕ𝕩 = 1\") == {1, [{:\"_ℕ𝕩\", 1}]}\n end\n\n test \"handles graphemes inside quoted identifiers\" do\n string_to_quoted =\n fn code ->\n Code.string_to_quoted!(code,\n token_metadata: true,\n literal_encoder: &{:ok, {:__block__, &2, [&1]}},\n emit_warnings: false\n )\n end\n\n assert {\n {:., _, [{:foo, _, nil}, :\"➡️\"]},\n [no_parens: true, delimiter: ~S[\"], line: 1],\n []\n } = string_to_quoted.(~S|foo.\"➡️\"|)\n\n assert {\n {:., _, [{:foo, _, nil}, :\"➡️\"]},\n [no_parens: true, delimiter: ~S['], line: 1],\n []\n } = string_to_quoted.(~S|foo.'➡️'|)\n\n assert {:__block__, [delimiter: ~S[\"], line: 1], [:\"➡️\"]} = string_to_quoted.(~S|:\"➡️\"|)\n\n assert {:__block__, [delimiter: ~S['], line: 1], [:\"➡️\"]} = string_to_quoted.(~S|:'➡️'|)\n\n assert {:__block__, [closing: [line: 1], line: 1],\n [\n [\n {{:__block__, [delimiter: ~S[\"], format: :keyword, line: 1], [:\"➡️\"]},\n {:x, [line: 1], nil}}\n ]\n ]} = string_to_quoted.(~S|[\"➡️\": x]|)\n\n assert {:__block__, [closing: [line: 1], line: 1],\n [\n [\n {{:__block__, [delimiter: ~S['], format: :keyword, line: 1], [:\"➡️\"]},\n {:x, [line: 1], nil}}\n ]\n ]} = string_to_quoted.(~S|['➡️': x]|)\n end\n end\n\n describe \"strings/sigils\" do\n test \"delimiter information for sigils is included\" do\n string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: false)\n\n assert parse!(\"~r/foo/\") ==\n {:sigil_r, [delimiter: \"/\", line: 1], [{:<<>>, [line: 1], [\"foo\"]}, []]}\n\n assert string_to_quoted.(\"~r[foo]\") ==\n {:sigil_r, [delimiter: \"[\", line: 1], [{:<<>>, [line: 1], [\"foo\"]}, []]}\n\n assert string_to_quoted.(\"~r\\\"foo\\\"\") ==\n {:sigil_r, [delimiter: \"\\\"\", line: 1], [{:<<>>, [line: 1], [\"foo\"]}, []]}\n\n meta = [delimiter: \"\\\"\\\"\\\"\", line: 1]\n args = {:sigil_S, meta, [{:<<>>, [indentation: 0, line: 1], [\"sigil heredoc\\n\"]}, []]}\n assert string_to_quoted.(\"~S\\\"\\\"\\\"\\nsigil heredoc\\n\\\"\\\"\\\"\") == args\n\n meta = [delimiter: \"'''\", line: 1]\n args = {:sigil_S, meta, [{:<<>>, [indentation: 0, line: 1], [\"sigil heredoc\\n\"]}, []]}\n assert string_to_quoted.(\"~S'''\\nsigil heredoc\\n'''\") == args\n end\n\n test \"valid multi-letter sigils\" do\n string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: false)\n\n assert string_to_quoted.(\"~REGEX/foo/\") ==\n {:sigil_REGEX, [delimiter: \"/\", line: 1], [{:<<>>, [line: 1], [\"foo\"]}, []]}\n\n assert string_to_quoted.(\"~REGEX/foo/mods\") ==\n {:sigil_REGEX, [delimiter: \"/\", line: 1], [{:<<>>, [line: 1], [\"foo\"]}, ~c\"mods\"]}\n\n assert string_to_quoted.(\"~REGEX[foo]\") ==\n {:sigil_REGEX, [delimiter: \"[\", line: 1], [{:<<>>, [line: 1], [\"foo\"]}, []]}\n\n meta = [delimiter: \"\\\"\\\"\\\"\", line: 1]\n args = {:sigil_MAT, meta, [{:<<>>, [indentation: 0, line: 1], [\"1,2,3\\n\"]}, []]}\n assert string_to_quoted.(\"~MAT\\\"\\\"\\\"\\n1,2,3\\n\\\"\\\"\\\"\") == args\n\n args = {:sigil_FOO1, meta, [{:<<>>, [indentation: 0, line: 1], [\"1,2,3\\n\"]}, []]}\n assert string_to_quoted.(\"~FOO1\\\"\\\"\\\"\\n1,2,3\\n\\\"\\\"\\\"\") == args\n\n args = {:sigil_BAR321, meta, [{:<<>>, [indentation: 0, line: 1], [\"1,2,3\\n\"]}, []]}\n assert string_to_quoted.(\"~BAR321\\\"\\\"\\\"\\n1,2,3\\n\\\"\\\"\\\"\") == args\n\n args = {:sigil_I18N, meta, [{:<<>>, [indentation: 0, line: 1], [\"1,2,3\\n\"]}, []]}\n assert string_to_quoted.(\"~I18N\\\"\\\"\\\"\\n1,2,3\\n\\\"\\\"\\\"\") == args\n end\n\n test \"invalid multi-letter sigils\" do\n msg =\n ~r/invalid sigil name, it should be either a one-letter lowercase letter or an uppercase letter optionally followed by uppercase letters and digits/\n\n assert_syntax_error([\"nofile:1:1:\", msg], \"~Regex/foo/\")\n\n assert_syntax_error([\"nofile:1:1:\", msg], \"~FOo1{bar]\")\n\n assert_syntax_error([\"nofile:1:1:\", msg], \"~foo1{bar]\")\n end\n\n test \"sigil newlines\" do\n assert {:sigil_s, _, [{:<<>>, _, [\"here\\ndoc\"]}, []]} =\n Code.string_to_quoted!(~s|~s\"here\\ndoc\"|)\n\n assert {:sigil_s, _, [{:<<>>, _, [\"here\\r\\ndoc\"]}, []]} =\n Code.string_to_quoted!(~s|~s\"here\\r\\ndoc\"|)\n end\n\n test \"string newlines\" do\n assert Code.string_to_quoted!(~s|\"here\\ndoc\"|) == \"here\\ndoc\"\n assert Code.string_to_quoted!(~s|\"here\\r\\ndoc\"|) == \"here\\r\\ndoc\"\n assert Code.string_to_quoted!(~s|\"here\\\\\\ndoc\"|) == \"heredoc\"\n assert Code.string_to_quoted!(~s|\"here\\\\\\r\\ndoc\"|) == \"heredoc\"\n end\n\n test \"heredoc newlines\" do\n assert Code.string_to_quoted!(~s|\"\"\"\\nhere\\ndoc\\n\"\"\"|) == \"here\\ndoc\\n\"\n assert Code.string_to_quoted!(~s|\"\"\"\\r\\nhere\\r\\ndoc\\r\\n\"\"\"|) == \"here\\r\\ndoc\\r\\n\"\n assert Code.string_to_quoted!(~s| \"\"\"\\n here\\n doc\\n \"\"\"|) == \"here\\ndoc\\n\"\n assert Code.string_to_quoted!(~s| \"\"\"\\r\\n here\\r\\n doc\\r\\n \"\"\"|) == \"here\\r\\ndoc\\r\\n\"\n assert Code.string_to_quoted!(~s|\"\"\"\\nhere\\\\\\ndoc\\\\\\n\"\"\"|) == \"heredoc\"\n assert Code.string_to_quoted!(~s|\"\"\"\\r\\nhere\\\\\\r\\ndoc\\\\\\r\\n\"\"\"|) == \"heredoc\"\n end\n\n test \"heredoc indentation\" do\n meta = [delimiter: \"'''\", line: 1]\n args = {:sigil_S, meta, [{:<<>>, [indentation: 2, line: 1], [\" sigil heredoc\\n\"]}, []]}\n assert Code.string_to_quoted!(\"~S'''\\n sigil heredoc\\n '''\") == args\n end\n end\n\n describe \"string_to_quoted/2\" do\n test \"converts strings to quoted expressions\" do\n assert Code.string_to_quoted(\"1 + 2\") == {:ok, {:+, [line: 1], [1, 2]}}\n\n assert Code.string_to_quoted(\"a.1\") ==\n {:error, {[line: 1, column: 3], \"syntax error before: \", \"\\\"1\\\"\"}}\n end\n end\n\n describe \"string_to_quoted/2 and atom handling\" do\n test \"ensures :existing_atoms_only\" do\n assert Code.string_to_quoted(\":there_is_no_such_atom\", existing_atoms_only: true) ==\n {:error,\n {[line: 1, column: 1], \"unsafe atom does not exist: \", \"there_is_no_such_atom\"}}\n\n assert Code.string_to_quoted(\"~UNKNOWN'foo bar'\", existing_atoms_only: true) ==\n {:error, {[line: 1, column: 1], \"unsafe atom does not exist: \", \"sigil_UNKNOWN\"}}\n end\n\n test \"encodes atoms\" do\n ref = make_ref()\n\n encoder = fn atom, meta ->\n assert atom == \"there_is_no_such_atom\"\n assert meta[:line] == 1\n assert meta[:column] == 1\n {:ok, {:my, \"atom\", ref}}\n end\n\n assert {:ok, {:my, \"atom\", ^ref}} =\n Code.string_to_quoted(\":there_is_no_such_atom\", static_atoms_encoder: encoder)\n end\n\n test \"encodes vars\" do\n ref = make_ref()\n\n encoder = fn atom, meta ->\n assert atom == \"there_is_no_such_var\"\n assert meta[:line] == 1\n assert meta[:column] == 1\n {:ok, {:my, \"atom\", ref}}\n end\n\n assert {:ok, {{:my, \"atom\", ^ref}, [line: 1], nil}} =\n Code.string_to_quoted(\"there_is_no_such_var\", static_atoms_encoder: encoder)\n end\n\n test \"encodes quoted keyword keys\" do\n ref = make_ref()\n\n encoder = fn atom, meta ->\n assert atom == \"there is no such key\"\n assert meta[:line] == 1\n assert meta[:column] == 2\n {:ok, {:my, \"atom\", ref}}\n end\n\n assert {:ok, [{{:my, \"atom\", ^ref}, true}]} =\n Code.string_to_quoted(~S([\"there is no such key\": true]),\n static_atoms_encoder: encoder\n )\n end\n\n test \"encodes multi-letter sigils\" do\n ref = make_ref()\n\n encoder = fn atom, meta ->\n assert atom == \"sigil_UNKNOWN\"\n assert meta[:line] == 1\n assert meta[:column] == 1\n {:ok, ref}\n end\n\n assert {:ok, {^ref, [delimiter: \"'\", line: 1], [{:<<>>, [line: 1], [\"abc\"]}, []]}} =\n Code.string_to_quoted(\"~UNKNOWN'abc'\", static_atoms_encoder: encoder)\n end\n\n test \"addresses ambiguities\" do\n encoder = fn string, _meta -> {:ok, {:atom, string}} end\n\n # We check a=1 for precedence issues with a!=1, make sure it works\n assert Code.string_to_quoted!(\"a = 1\", static_atoms_encoder: encoder)\n assert Code.string_to_quoted!(\"a=1\", static_atoms_encoder: encoder)\n end\n\n test \"does not encode keywords\" do\n encoder = fn atom, _meta -> raise \"shouldn't be invoked for #{atom}\" end\n\n assert {:ok, {:fn, [line: 1], [{:->, [line: 1], [[1], 2]}]}} =\n Code.string_to_quoted(\"fn 1 -> 2 end\", static_atoms_encoder: encoder)\n\n assert {:ok, {:or, [line: 1], [true, false]}} =\n Code.string_to_quoted(\"true or false\", static_atoms_encoder: encoder)\n\n encoder = fn atom, _meta -> {:ok, {:encoded, atom}} end\n\n assert {:ok, [encoded: \"true\", encoded: \"do\", encoded: \"and\"]} =\n Code.string_to_quoted(\"[:true, :do, :and]\", static_atoms_encoder: encoder)\n\n assert {:ok, [{{:encoded, \"do\"}, 1}, {{:encoded, \"true\"}, 2}, {{:encoded, \"end\"}, 3}]} =\n Code.string_to_quoted(\"[do: 1, true: 2, end: 3]\", static_atoms_encoder: encoder)\n end\n\n test \"does not encode one-letter sigils\" do\n encoder = fn atom, _meta -> raise \"shouldn't be invoked for #{atom}\" end\n\n assert {:ok, {:sigil_z, [{:delimiter, \"'\"}, {:line, 1}], [{:<<>>, [line: 1], [\"foo\"]}, []]}} =\n Code.string_to_quoted(\"~z'foo'\", static_atoms_encoder: encoder)\n\n assert {:ok, {:sigil_Z, [{:delimiter, \"'\"}, {:line, 1}], [{:<<>>, [line: 1], [\"foo\"]}, []]}} =\n Code.string_to_quoted(\"~Z'foo'\", static_atoms_encoder: encoder)\n end\n\n test \"returns errors on long atoms even when using static_atoms_encoder\" do\n atom = String.duplicate(\"a\", 256)\n\n encoder = fn atom, _meta -> {:ok, atom} end\n\n assert Code.string_to_quoted(atom, static_atoms_encoder: encoder) ==\n {:error,\n {[line: 1, column: 1], \"atom length must be less than system limit: \", atom}}\n end\n\n test \"avoids crashes on invalid AST\" do\n encoder = fn atom, _meta -> {:ok, {:atom, [], [atom]}} end\n\n assert {:error, {_, \"missing terminator: )\", \"\"}} =\n Code.string_to_quoted(\"Module(\", static_atoms_encoder: encoder)\n\n assert {:error, {_, \"syntax error before: \", \"'('\"}} =\n Code.string_to_quoted(\"Module()\", static_atoms_encoder: encoder)\n end\n\n test \"may return errors\" do\n encoder = fn _atom, _meta ->\n {:error, \"Invalid atom name\"}\n end\n\n assert {:error, {[line: 1, column: 1], \"Invalid atom name: \", \"there_is_no_such_atom\"}} =\n Code.string_to_quoted(\":there_is_no_such_atom\", static_atoms_encoder: encoder)\n\n assert {:error, {[line: 1, column: 1], \"Invalid atom name: \", \"sigil_UNKNOWN\"}} =\n Code.string_to_quoted(\"~UNKNOWN'foo bar'\", static_atoms_encoder: encoder)\n end\n\n test \"may return tuples\" do\n encoder = fn string, _metadata ->\n try do\n {:ok, String.to_existing_atom(string)}\n rescue\n ArgumentError ->\n {:ok, {:user_atom, string}}\n end\n end\n\n assert {:ok, {:try, _, [[do: {:test, _, [{{:user_atom, \"atom_does_not_exist\"}, _, []}]}]]}} =\n Code.string_to_quoted(\"try do: test(atom_does_not_exist())\",\n static_atoms_encoder: encoder\n )\n end\n end\n\n describe \"string_to_quoted/2 with :columns\" do\n test \"includes column information\" do\n string_to_quoted = &Code.string_to_quoted(&1, columns: true)\n assert string_to_quoted.(\"1 + 2\") == {:ok, {:+, [line: 1, column: 3], [1, 2]}}\n\n foo = {:foo, [line: 1, column: 1], nil}\n bar = {:bar, [line: 1, column: 7], nil}\n assert string_to_quoted.(\"foo + bar\") == {:ok, {:+, [line: 1, column: 5], [foo, bar]}}\n\n nfc_abba = [225, 98, 98, 224]\n nfd_abba = [97, 769, 98, 98, 97, 768]\n context = [line: 1, column: 8]\n expr = \"\\\"ábbà\\\" = 1\"\n\n assert string_to_quoted.(String.normalize(expr, :nfc)) ==\n {:ok, {:=, context, [List.to_string(nfc_abba), 1]}}\n\n assert string_to_quoted.(String.normalize(expr, :nfd)) ==\n {:ok, {:=, context, [List.to_string(nfd_abba), 1]}}\n end\n\n test \"not in\" do\n assert Code.string_to_quoted!(\"a not in b\", columns: true) ==\n {:not, [line: 1, column: 3],\n [\n {:in, [line: 1, column: 7],\n [{:a, [line: 1, column: 1], nil}, {:b, [line: 1, column: 10], nil}]}\n ]}\n\n assert Code.string_to_quoted!(\"a not in b\", columns: true, token_metadata: true) ==\n {:not, [line: 1, column: 3],\n [\n {:in, [line: 1, column: 8],\n [{:a, [line: 1, column: 1], nil}, {:b, [line: 1, column: 11], nil}]}\n ]}\n\n assert Code.string_to_quoted!(\"a\\nnot in b\", columns: true, token_metadata: true) ==\n {:not, [newlines: 1, line: 2, column: 1],\n [\n {:in, [line: 2, column: 5],\n [{:a, [line: 1, column: 1], nil}, {:b, [line: 2, column: 8], nil}]}\n ]}\n\n assert Code.string_to_quoted!(\"a not in\\nb\", columns: true, token_metadata: true) ==\n {:not, [newlines: 1, line: 1, column: 3],\n [\n {:in, [line: 1, column: 7],\n [{:a, [line: 1, column: 1], nil}, {:b, [line: 2, column: 1], nil}]}\n ]}\n\n assert Code.string_to_quoted!(\"a\\nnot in\\nb\", columns: true, token_metadata: true) ==\n {:not, [newlines: 1, line: 2, column: 1],\n [\n {:in, [line: 2, column: 5],\n [{:a, [line: 1, column: 1], nil}, {:b, [line: 3, column: 1], nil}]}\n ]}\n end\n\n test \"deprecated not/in\" do\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert Code.string_to_quoted!(\"not a in b\", columns: true) ==\n {:not, [line: 1, column: 1],\n [\n {:in, [line: 1, column: 7],\n [\n {:a, [line: 1, column: 5], nil},\n {:b, [line: 1, column: 10], nil}\n ]}\n ]}\n end) =~ \"not expr1 in expr2\"\n\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert Code.string_to_quoted!(\"!a in b\", columns: true) ==\n {:!, [line: 1, column: 1],\n [\n {:in, [line: 1, column: 4],\n [\n {:a, [line: 1, column: 2], nil},\n {:b, [line: 1, column: 7], nil}\n ]}\n ]}\n end) =~ \"!expr1 in expr2\"\n end\n\n test \"handles maps and structs\" do\n assert Code.string_to_quoted(\"%{}\", columns: true) ==\n {:ok, {:%{}, [line: 1, column: 1], []}}\n\n assert Code.string_to_quoted(\"%:atom{}\", columns: true) ==\n {:ok, {:%, [line: 1, column: 1], [:atom, {:%{}, [line: 1, column: 7], []}]}}\n end\n end\n\n describe \"string_to_quoted/2 with :token_metadata\" do\n test \"adds end_of_expression information to blocks\" do\n file = \"\"\"\n one();two()\n three()\n\n four()\n\n\n five()\n \"\"\"\n\n args = [\n {:one,\n [\n end_of_expression: [newlines: 0, line: 1, column: 6],\n closing: [line: 1, column: 5],\n line: 1,\n column: 1\n ], []},\n {:two,\n [\n end_of_expression: [newlines: 1, line: 1, column: 12],\n closing: [line: 1, column: 11],\n line: 1,\n column: 7\n ], []},\n {:three,\n [\n end_of_expression: [newlines: 2, line: 2, column: 8],\n closing: [line: 2, column: 7],\n line: 2,\n column: 1\n ], []},\n {:four,\n [\n end_of_expression: [newlines: 3, line: 4, column: 7],\n closing: [line: 4, column: 6],\n line: 4,\n column: 1\n ], []},\n {:five,\n [\n end_of_expression: [newlines: 1, line: 7, column: 7],\n closing: [line: 7, column: 6],\n line: 7,\n column: 1\n ], []}\n ]\n\n assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==\n {:__block__, [], args}\n end\n\n test \"adds end_of_expression to the right hand side of ->\" do\n file = \"\"\"\n case true do\n :foo -> bar(); two()\n :baz -> bat()\n end\n \"\"\"\n\n assert Code.string_to_quoted!(file, token_metadata: true) ==\n {:case,\n [\n end_of_expression: [newlines: 1, line: 4],\n do: [line: 1],\n end: [line: 4],\n line: 1\n ],\n [\n true,\n [\n do: [\n {:->, [line: 2],\n [\n [:foo],\n {:__block__, [],\n [\n {:bar,\n [\n end_of_expression: [newlines: 0, line: 2],\n closing: [line: 2],\n line: 2\n ], []},\n {:two,\n [\n end_of_expression: [newlines: 1, line: 2],\n closing: [line: 2],\n line: 2\n ], []}\n ]}\n ]},\n {:->, [line: 3],\n [\n [:baz],\n {:bat,\n [\n end_of_expression: [newlines: 1, line: 3],\n closing: [line: 3],\n line: 3\n ], []}\n ]}\n ]\n ]\n ]}\n end\n\n test \"end of expression with literal\" do\n file = \"\"\"\n a do\n d ->\n (\n b -> c\n )\n end\n \"\"\"\n\n assert Code.string_to_quoted!(file,\n token_metadata: true,\n literal_encoder: &{:ok, {:__block__, &2, [&1]}}\n ) ==\n {:a,\n [\n end_of_expression: [newlines: 1, line: 6],\n do: [line: 1],\n end: [line: 6],\n line: 1\n ],\n [\n [\n {{:__block__, [line: 1], [:do]},\n [\n {:->, [newlines: 1, line: 2],\n [\n [{:d, [line: 2], nil}],\n {:__block__,\n [\n end_of_expression: [newlines: 1, line: 5],\n newlines: 1,\n closing: [line: 5],\n line: 3\n ],\n [\n [\n {:->, [line: 4],\n [\n [{:b, [line: 4], nil}],\n {:c, [end_of_expression: [newlines: 1, line: 4], line: 4], nil}\n ]}\n ]\n ]}\n ]}\n ]}\n ]\n ]}\n end\n\n test \"does not add end of expression to ->\" do\n file = \"\"\"\n case true do\n :foo -> :bar\n :baz -> :bat\n end\\\n \"\"\"\n\n assert Code.string_to_quoted!(file, token_metadata: true) ==\n {:case, [do: [line: 1], end: [line: 4], line: 1],\n [\n true,\n [\n do: [\n {:->, [line: 2], [[:foo], :bar]},\n {:->, [line: 3], [[:baz], :bat]}\n ]\n ]\n ]}\n end\n\n test \"adds pairing information\" do\n string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true)\n\n assert string_to_quoted.(\"foo\") == {:foo, [line: 1], nil}\n assert string_to_quoted.(\"foo()\") == {:foo, [closing: [line: 1], line: 1], []}\n\n assert string_to_quoted.(\"foo(\\n)\") ==\n {:foo, [newlines: 1, closing: [line: 2], line: 1], []}\n\n assert string_to_quoted.(\"%{\\n}\") == {:%{}, [newlines: 1, closing: [line: 2], line: 1], []}\n\n assert string_to_quoted.(\"foo(\\n) do\\nend\") ==\n {:foo, [do: [line: 2], end: [line: 3], newlines: 1, closing: [line: 2], line: 1],\n [[do: {:__block__, [line: 2], []}]]}\n\n assert string_to_quoted.(\"foo(\\n)(\\n)\") ==\n {{:foo, [newlines: 1, closing: [line: 2], line: 1], []},\n [newlines: 1, closing: [line: 3], line: 1], []}\n end\n\n test \"adds opening and closing information for single-expression block\" do\n file = \"1 + (2 + 3)\"\n\n assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==\n {:+, [line: 1, column: 3],\n [\n 1,\n {:+,\n [\n parens: [closing: [line: 1, column: 11], line: 1, column: 5],\n line: 1,\n column: 8\n ], [2, 3]}\n ]}\n\n file = \"1 + ((2 + 3))\"\n\n assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==\n {:+, [line: 1, column: 3],\n [\n 1,\n {:+,\n [\n parens: [closing: [line: 1, column: 13], line: 1, column: 5],\n parens: [closing: [line: 1, column: 12], line: 1, column: 6],\n line: 1,\n column: 9\n ], [2, 3]}\n ]}\n end\n\n test \"adds opening and closing information for tuples\" do\n string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true, columns: true)\n\n assert string_to_quoted.(\"{}\") ==\n {:{}, [closing: [line: 1, column: 2], line: 1, column: 1], []}\n\n assert string_to_quoted.(\"{123}\") ==\n {:{}, [closing: [line: 1, column: 5], line: 1, column: 1], [123]}\n\n assert string_to_quoted.(\"x.{}\") ==\n {{:., [line: 1, column: 2], [{:x, [line: 1, column: 1], nil}, :{}]},\n [closing: [line: 1, column: 4], line: 1, column: 2], []}\n\n assert string_to_quoted.(\"x.{123}\") ==\n {{:., [line: 1, column: 2], [{:x, [line: 1, column: 1], nil}, :{}]},\n [closing: [line: 1, column: 7], line: 1, column: 2], [123]}\n end\n\n test \"adds opening and closing information for empty block\" do\n string_to_quoted =\n &Code.string_to_quoted!(&1, token_metadata: true, columns: true, emit_warnings: false)\n\n file = \"()\"\n\n assert string_to_quoted.(file) ==\n {:__block__, [parens: [closing: [line: 1, column: 2], line: 1, column: 1]], []}\n\n file = \"(())\"\n\n assert string_to_quoted.(file) ==\n {:__block__,\n [\n parens: [closing: [line: 1, column: 4], line: 1, column: 1],\n parens: [closing: [line: 1, column: 3], line: 1, column: 2]\n ], []}\n\n file = \"\"\"\n (\n # Foo\n (\n # Bar\n )\n )\n \"\"\"\n\n assert string_to_quoted.(file) ==\n {:__block__,\n [\n end_of_expression: [newlines: 1, line: 6, column: 2],\n parens: [closing: [line: 6, column: 1], line: 1, column: 1],\n end_of_expression: [newlines: 1, line: 5, column: 4],\n parens: [closing: [line: 5, column: 3], line: 3, column: 3]\n ], []}\n end\n\n test \"adds opening and closing information for stab arguments\" do\n file = \"fn () -> x end \"\n\n assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==\n {:fn, [closing: [line: 1, column: 12], line: 1, column: 1],\n [\n {:->,\n [\n parens: [closing: [line: 1, column: 5], line: 1, column: 4],\n line: 1,\n column: 7\n ], [[], {:x, [line: 1, column: 10], nil}]}\n ]}\n\n file = \"fn (x, y) -> x end \"\n\n assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==\n {\n :fn,\n [{:closing, [line: 1, column: 16]}, {:line, 1}, {:column, 1}],\n [\n {:->,\n [\n parens: [closing: [line: 1, column: 9], line: 1, column: 4],\n line: 1,\n column: 11\n ],\n [\n [{:x, [line: 1, column: 5], nil}, {:y, [line: 1, column: 8], nil}],\n {:x, [line: 1, column: 14], nil}\n ]}\n ]\n }\n\n file = \"if true do (x, y) -> x end\"\n\n assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==\n {\n :if,\n [\n {:do, [line: 1, column: 9]},\n {:end, [line: 1, column: 24]},\n {:line, 1},\n {:column, 1}\n ],\n [\n true,\n [\n do: [\n {:->,\n [\n parens: [closing: [line: 1, column: 17], line: 1, column: 12],\n line: 1,\n column: 19\n ],\n [\n [{:x, [line: 1, column: 13], nil}, {:y, [line: 1, column: 16], nil}],\n {:x, [line: 1, column: 22], nil}\n ]}\n ]\n ]\n ]\n }\n end\n\n test \"with :literal_encoder\" do\n opts = [literal_encoder: &{:ok, {:__block__, &2, [&1]}}, token_metadata: true]\n string_to_quoted = &Code.string_to_quoted!(&1, opts)\n\n assert string_to_quoted.(~s(\"one\")) == {:__block__, [delimiter: \"\\\"\", line: 1], [\"one\"]}\n assert string_to_quoted.(\"?é\") == {:__block__, [token: \"?é\", line: 1], [233]}\n assert string_to_quoted.(\"0b10\") == {:__block__, [token: \"0b10\", line: 1], [2]}\n assert string_to_quoted.(\"12\") == {:__block__, [token: \"12\", line: 1], [12]}\n assert string_to_quoted.(\"0o123\") == {:__block__, [token: \"0o123\", line: 1], [83]}\n assert string_to_quoted.(\"0xEF\") == {:__block__, [token: \"0xEF\", line: 1], [239]}\n assert string_to_quoted.(\"12.3\") == {:__block__, [token: \"12.3\", line: 1], [12.3]}\n assert string_to_quoted.(\"nil\") == {:__block__, [line: 1], [nil]}\n assert string_to_quoted.(\":one\") == {:__block__, [line: 1], [:one]}\n\n assert string_to_quoted.(\"true\") == {:__block__, [line: 1], [true]}\n assert string_to_quoted.(\":true\") == {:__block__, [format: :atom, line: 1], [true]}\n\n assert string_to_quoted.(\"[one: :two]\") == {\n :__block__,\n [{:closing, [line: 1]}, {:line, 1}],\n [\n [\n {{:__block__, [format: :keyword, line: 1], [:one]},\n {:__block__, [line: 1], [:two]}}\n ]\n ]\n }\n\n assert string_to_quoted.(\"[1]\") ==\n {:__block__, [closing: [line: 1], line: 1],\n [[{:__block__, [token: \"1\", line: 1], [1]}]]}\n\n assert string_to_quoted.(~s(\"\"\"\\nhello\\n\"\"\")) ==\n {:__block__, [delimiter: ~s[\"\"\"], indentation: 0, line: 1], [\"hello\\n\"]}\n\n assert string_to_quoted.(~s[fn (1) -> \"hello\" end]) ==\n {:fn, [closing: [line: 1], line: 1],\n [\n {:->, [line: 1],\n [\n [\n {:__block__,\n [\n parens: [closing: [line: 1], line: 1],\n token: \"1\",\n line: 1\n ], [1]}\n ],\n {:__block__, [delimiter: \"\\\"\", line: 1], [\"hello\"]}\n ]}\n ]}\n\n assert string_to_quoted.(\"(1)\") ==\n {:__block__, [parens: [closing: [line: 1], line: 1], token: \"1\", line: 1], [1]}\n end\n\n test \"adds identifier_location for qualified identifiers\" do\n string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true, columns: true)\n\n assert string_to_quoted.(\"foo.\\nbar\") ==\n {{:., [line: 1, column: 4],\n [\n {:foo, [line: 1, column: 1], nil},\n :bar\n ]}, [no_parens: true, line: 2, column: 1], []}\n\n assert string_to_quoted.(\"foo\\n.\\nbar\") ==\n {{:., [line: 2, column: 1],\n [\n {:foo, [line: 1, column: 1], nil},\n :bar\n ]}, [no_parens: true, line: 3, column: 1], []}\n\n assert string_to_quoted.(~s[Foo.\\nbar(1)]) ==\n {{:., [line: 1, column: 4],\n [\n {:__aliases__, [last: [line: 1, column: 1], line: 1, column: 1], [:Foo]},\n :bar\n ]}, [closing: [line: 2, column: 6], line: 2, column: 1], [1]}\n end\n\n test \"adds metadata for the last alias segment\" do\n string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true)\n\n assert string_to_quoted.(\"Foo\") == {:__aliases__, [last: [line: 1], line: 1], [:Foo]}\n\n assert string_to_quoted.(\"Foo.\\nBar\\n.\\nBaz\") ==\n {:__aliases__, [last: [line: 4], line: 1], [:Foo, :Bar, :Baz]}\n\n assert string_to_quoted.(\"foo.\\nBar\\n.\\nBaz\") ==\n {:__aliases__, [last: [line: 4], line: 1], [{:foo, [line: 1], nil}, :Bar, :Baz]}\n end\n\n test \"adds metadata about assoc operator position in maps\" do\n opts = [\n literal_encoder: &{:ok, {:__block__, &2, [&1]}},\n token_metadata: true,\n columns: true\n ]\n\n string_to_quoted = &Code.string_to_quoted!(&1, opts)\n\n file = \"%{:key => 1, {} => {}}\"\n\n assert string_to_quoted.(file) ==\n {\n :%{},\n [closing: [line: 1, column: 22], line: 1, column: 1],\n [\n {{:__block__, [assoc: [line: 1, column: 8], line: 1, column: 3], [:key]},\n {:__block__, [token: \"1\", line: 1, column: 11], [1]}},\n {\n {:{},\n [\n assoc: [line: 1, column: 17],\n closing: [line: 1, column: 15],\n line: 1,\n column: 14\n ], []},\n {:{}, [closing: [line: 1, column: 21], line: 1, column: 20], []}\n }\n ]\n }\n end\n end\n\n describe \"syntax errors\" do\n test \"invalid heredoc start\" do\n assert_syntax_error(\n [\n \"nofile:1:4:\",\n ~r/heredoc allows only whitespace characters followed by a new line after opening \\\"\\\"\\\"/\n ],\n ~c\"\\\"\\\"\\\"bar\\n\\\"\\\"\\\"\"\n )\n end\n\n test \"invalid fn\" do\n assert_syntax_error(\n [\"nofile:1:1:\", \"expected anonymous functions to be defined with -> inside: 'fn'\"],\n ~c\"fn 1 end\"\n )\n\n assert_syntax_error(\n [\"nofile:2:\", \"unexpected operator ->. If you want to define multiple clauses,\"],\n ~c\"fn 1\\n2 -> 3 end\"\n )\n end\n\n test \"invalid token\" do\n assert_syntax_error(\n [\"nofile:1:1:\", ~s/unexpected token: \"#{\"\\u3164\"}\" (column 1, code point U+3164)/],\n ~c\"ㅤ = 1\"\n )\n\n assert_syntax_error(\n [\"nofile:1:7:\", ~s/unexpected token: \"#{\"\\u200B\"}\" (column 7, code point U+200B)/],\n ~c\"[foo: \\u200B]\\noops\"\n )\n\n assert_syntax_error(\n [\"nofile:1:1:\", ~s/unexpected token: carriage return (column 1, code point U+000D)/],\n ~c\"\\r\"\n )\n end\n\n test \"invalid bidi in source\" do\n assert_syntax_error(\n [\"nofile:1:1:\", ~s/invalid bidirectional formatting character in comment: \\\\u202A/],\n ~c\"# This is a \\u202A\"\n )\n\n assert_syntax_error(\n [\"nofile:1:6:\", \"invalid bidirectional formatting character in comment: \\\\u202A\"],\n ~c\"foo. # This is a \\u202A\"\n )\n\n assert_syntax_error(\n [\n \"nofile:1:12:\",\n \"invalid bidirectional formatting character in string: \\\\u202A. If you want to use such character, use it in its escaped \\\\u202A form instead\"\n ],\n ~c\"\\\"this is a \\u202A\\\"\"\n )\n\n assert_syntax_error(\n [\n \"nofile:1:13:\",\n \"invalid bidirectional formatting character in string: \\\\u202A. If you want to use such character, use it in its escaped \\\\u202A form instead\"\n ],\n ~c\"\\\"this is a \\\\\\u202A\\\"\"\n )\n end\n\n test \"invalid newline in source\" do\n assert_syntax_error(\n [\"nofile:1:1:\", ~s/invalid line break character in comment: \\\\u2028/],\n ~c\"# This is a \\u2028\"\n )\n\n assert_syntax_error(\n [\"nofile:1:6:\", \"invalid line break character in comment: \\\\u2028\"],\n ~c\"foo. # This is a \\u2028\"\n )\n\n assert_syntax_error(\n [\n \"nofile:1:12:\",\n \"invalid line break character in string: \\\\u2028. If you want to use such character, use it in its escaped \\\\u2028 form instead\"\n ],\n ~c\"\\\"this is a \\u2028\\\"\"\n )\n\n assert_syntax_error(\n [\n \"nofile:1:13:\",\n \"invalid line break character in string: \\\\u2028. If you want to use such character, use it in its escaped \\\\u2028 form instead\"\n ],\n ~c\"\\\"this is a \\\\\\u2028\\\"\"\n )\n end\n\n test \"reserved tokens\" do\n assert_syntax_error([\"nofile:1:1:\", \"reserved token: __aliases__\"], ~c\"__aliases__\")\n assert_syntax_error([\"nofile:1:1:\", \"reserved token: __block__\"], ~c\"__block__\")\n end\n\n test \"invalid alias terminator\" do\n assert_syntax_error([\"nofile:1:4:\", \"unexpected ( after alias Foo\"], ~c\"Foo()\")\n end\n\n test \"invalid quoted token\" do\n assert_syntax_error(\n [\"nofile:1:9:\", \"syntax error before: \\\"world\\\"\"],\n ~c\"\\\"hello\\\" \\\"world\\\"\"\n )\n\n assert_syntax_error(\n [\"nofile:1:3:\", \"syntax error before: 'Foobar'\"],\n ~c\"1 Foobar\"\n )\n\n assert_syntax_error(\n [\"nofile:1:5:\", \"syntax error before: foo\"],\n ~c\"Foo.:foo\"\n )\n\n assert_syntax_error(\n [\"nofile:1:5:\", \"syntax error before: \\\"foo\\\"\"],\n ~c\"Foo.:\\\"foo\\#{:bar}\\\"\"\n )\n\n assert_syntax_error(\n [\"nofile:1:5:\", \"syntax error before: \\\"\"],\n ~c\"Foo.:\\\"\\#{:bar}\\\"\"\n )\n end\n\n test \"invalid identifier\" do\n message =\n &[\"nofile:1:1:\", ~s/invalid character \"@\" (code point U+0040) in identifier: #{&1}/]\n\n assert_syntax_error(message.(\"foo@\"), ~c\"foo@\")\n assert_syntax_error(message.(\"foo@\"), ~c\"foo@ \")\n assert_syntax_error(message.(\"foo@bar\"), ~c\"foo@bar\")\n\n message =\n &[\"nofile:1:1:\", \"invalid character \\\"@\\\" (code point U+0040) in alias: #{&1}\"]\n\n assert_syntax_error(message.(\"Foo@\"), ~c\"Foo@\")\n assert_syntax_error(message.(\"Foo@bar\"), ~c\"Foo@bar\")\n\n message =\n [\n \"nofile:1:1:\",\n ~s/invalid character \"!\" (code point U+0021) in alias (only ASCII characters, without punctuation, are allowed): Foo!/\n ]\n\n assert_syntax_error(message, ~c\"Foo!\")\n\n message =\n [\n \"nofile:1:1:\",\n ~s/invalid character \"?\" (code point U+003F) in alias (only ASCII characters, without punctuation, are allowed): Foo?/\n ]\n\n assert_syntax_error(message, ~c\"Foo?\")\n\n message =\n [\n \"nofile:1:1:\",\n ~s/invalid character \"ó\" (code point U+00F3) in alias (only ASCII characters, without punctuation, are allowed): Foó/\n ]\n\n assert_syntax_error(message, ~c\"Foó\")\n\n # token suggestion heuristic:\n # \"for foO𝚳, NFKC isn't enough because 𝚳 nfkc's to Greek Μ, would be mixed script.\n # however the 'confusability skeleton' for that token produces an all-Latin foOM\n # and would tokenize -- so suggest that, in case that's what they want\"\n message = [\n \"Codepoint failed identifier tokenization, but a simpler form was found.\",\n \"Got:\",\n ~s/\"foO𝚳\" (code points 0x00066 0x0006F 0x0004F 0x1D6B3)/,\n \"Hint: You could write the above in a similar way that is accepted by Elixir:\",\n ~s/\"foOM\" (code points 0x00066 0x0006F 0x0004F 0x0004D)/,\n \"See https://hexdocs.pm/elixir/unicode-syntax.html for more information.\"\n ]\n\n assert_syntax_error(message, ~c\"foO𝚳\")\n\n # token suggestion heuristic:\n # \"for fooی𝚳, both NKFC and confusability would result in mixed scripts,\n # because the Farsi letter is confusable with a different Arabic letter.\n # Well, can't fix it all at once -- let's check for a suggestion just on\n # the one codepoint that triggered this, the 𝚳 -- that would at least\n # nudge them forwards.\"\n message = [\n \"Elixir expects unquoted Unicode atoms, variables, and calls to use allowed codepoints and to be in NFC form.\",\n \"Got:\",\n ~s/\"𝚳\" (code points 0x1D6B3)/,\n \"Hint: You could write the above in a compatible format that is accepted by Elixir:\",\n ~s/\"Μ\" (code points 0x0039C)/,\n \"See https://hexdocs.pm/elixir/unicode-syntax.html for more information.\"\n ]\n\n assert_syntax_error(message, ~c\"fooی𝚳\")\n end\n\n test \"keyword missing space\" do\n msg = [\"nofile:1:1:\", \"keyword argument must be followed by space after: foo:\"]\n\n assert_syntax_error(msg, \"foo:bar\")\n assert_syntax_error(msg, \"foo:+\")\n assert_syntax_error(msg, \"foo:+1\")\n end\n\n test \"invalid keyword list in tuple/binary\" do\n assert_syntax_error(\n [\"unexpected keyword list inside tuple\"],\n ~c\"{foo: :bar}\"\n )\n\n assert_syntax_error(\n [\"unexpected keyword list inside tuple\"],\n ~c\"{foo: :bar, baz: :bar}\"\n )\n\n assert_syntax_error(\n [\"unexpected keyword list inside bitstring\"],\n ~c\"<>\"\n )\n end\n\n test \"expression after keyword lists\" do\n assert_syntax_error(\n [\"unexpected expression after keyword list\"],\n ~c\"call foo: 1, :bar\"\n )\n\n assert_syntax_error(\n [\"unexpected expression after keyword list\"],\n ~c\"call(foo: 1, :bar)\"\n )\n\n assert_syntax_error(\n [\"unexpected expression after keyword list\"],\n ~c\"[foo: 1, :bar]\"\n )\n\n assert_syntax_error(\n [\"unexpected expression after keyword list\"],\n ~c\"%{foo: 1, :bar => :bar}\"\n )\n end\n\n test \"syntax errors include formatted snippet\" do\n message = [\"nofile:1:5:\", \"syntax error before:\", \"1 + * 3\", \"^\"]\n assert_syntax_error(message, \"1 + * 3\")\n end\n\n test \"invalid map start\" do\n assert_syntax_error(\n [\"nofile:1:7:\", \"expected %{ to define a map, got: %[\"],\n \"{:ok, %[], %{}}\"\n )\n\n assert_syntax_error(\n [\"nofile:1:3:\", \"unexpected space between % and {\"],\n \"% {1, 2, 3}\"\n )\n end\n\n test \"invalid access\" do\n msg = [\"nofile:1:6:\", \"too many arguments when accessing a value\"]\n assert_syntax_error(msg, \"foo[1, 2]\")\n assert_syntax_error(msg, \"foo[1, 2, 3]\")\n assert_syntax_error(msg, \"foo[1, 2, 3,]\")\n end\n\n test \"unexpected end\" do\n assert_syntax_error([\"nofile:1:3:\", \"unexpected reserved word: end\"], ~c\"1 end\")\n\n assert_syntax_error(\n [\n \"hint:\",\n \"the \\\"end\\\" on line 2 may not have a matching \\\"do\\\" defined before it (based on indentation)\"\n ],\n ~c\"\"\"\n defmodule MyApp do\n def one end\n def two do end\n end\n \"\"\"\n )\n\n assert_syntax_error(\n [\n \"hint:\",\n \"the \\\"end\\\" on line 3 may not have a matching \\\"do\\\" defined before it (based on indentation)\"\n ],\n ~c\"\"\"\n defmodule MyApp do\n def one\n end\n\n def two do\n end\n end\n \"\"\"\n )\n\n assert_syntax_error(\n [\n \"hint:\",\n \"the \\\"end\\\" on line 6 may not have a matching \\\"do\\\" defined before it (based on indentation)\"\n ],\n ~c\"\"\"\n defmodule MyApp do\n def one do\n end\n\n def two\n end\n end\n \"\"\"\n )\n end\n\n test \"invalid keywords\" do\n assert_syntax_error(\n [\"nofile:1:2:\", \"syntax error before: '.'\"],\n ~c\"+.foo\"\n )\n\n assert_syntax_error(\n [\"nofile:1:1:\", \"syntax error before: after. \\\"after\\\" is a reserved word\"],\n ~c\"after = 1\"\n )\n end\n\n test \"before sigil\" do\n msg = &[\"nofile:1:9:\", \"syntax error before: sigil ~s starting with content '#{&1}'\"]\n\n assert_syntax_error(msg.(\"bar baz\"), ~c\"~s(foo) ~s(bar baz)\")\n assert_syntax_error(msg.(\"\"), ~c\"~s(foo) ~s()\")\n assert_syntax_error(msg.(\"bar \"), ~c\"~s(foo) ~s(bar \\#{:baz})\")\n assert_syntax_error(msg.(\"\"), ~c\"~s(foo) ~s(\\#{:bar} baz)\")\n end\n\n test \"invalid do\" do\n assert_syntax_error(\n [\"nofile:1:10:\", \"unexpected reserved word: do.\"],\n ~c\"if true, do\\n\"\n )\n\n assert_syntax_error([\"nofile:1:9:\", \"unexpected keyword: do:.\"], ~c\"if true do:\\n\")\n end\n\n test \"invalid parens call\" do\n msg =\n [\n \"nofile:1:5:\",\n \"unexpected parentheses\",\n \"If you are making a function call, do not insert spaces between the function name and the opening parentheses.\",\n \"Syntax error before: '\\('\"\n ]\n\n assert_syntax_error(msg, ~c\"foo (hello, world)\")\n end\n\n test \"invalid nested no parens call\" do\n msg = [\"nofile:1:\", \"unexpected comma. Parentheses are required to solve ambiguity\"]\n\n assert_syntax_error(msg, ~c\"[foo 1, 2]\")\n assert_syntax_error(msg, ~c\"[foo bar 1, 2]\")\n assert_syntax_error(msg, ~c\"[do: foo 1, 2]\")\n assert_syntax_error(msg, ~c\"foo(do: bar 1, 2)\")\n assert_syntax_error(msg, ~c\"{foo 1, 2}\")\n assert_syntax_error(msg, ~c\"{foo bar 1, 2}\")\n assert_syntax_error(msg, ~c\"foo 1, foo 2, 3\")\n assert_syntax_error(msg, ~c\"foo 1, @bar 3, 4\")\n assert_syntax_error(msg, ~c\"foo 1, 2 + bar 3, 4\")\n assert_syntax_error(msg, ~c\"foo(1, foo 2, 3)\")\n\n interpret = fn x -> Macro.to_string(Code.string_to_quoted!(x)) end\n assert interpret.(\"f 1 + g h 2, 3\") == \"f(1 + g(h(2, 3)))\"\n\n assert interpret.(\"assert [] = TestRepo.all from p in Post, where: p.title in ^[]\") ==\n \"assert [] = TestRepo.all(from(p in Post, where: p.title in ^[]))\"\n end\n\n test \"invalid atom dot alias\" do\n msg =\n [\n \"nofile:1:6:\",\n \"atom cannot be followed by an alias. If the '.' was meant to be \" <>\n \"part of the atom's name, the atom name must be quoted. Syntax error before: '.'\"\n ]\n\n assert_syntax_error(msg, ~c\":foo.Bar\")\n assert_syntax_error(msg, ~c\":\\\"+\\\".Bar\")\n end\n\n test \"invalid map/struct\" do\n assert_syntax_error([\"nofile:1:15:\", \"syntax error before: '}'\"], ~c\"%{foo bar, baz}\")\n assert_syntax_error([\"nofile:1:8:\", \"syntax error before: '{'\"], ~c\"%{a, b}{a: :b}\")\n end\n\n test \"mismatching delimiters\" do\n assert_mismatched_delimiter_error(\n [\n \"nofile:1:9:\",\n \"unexpected token:\",\n \"└ unclosed delimiter\",\n \"└ mismatched closing delimiter\"\n ],\n ~c\"fn a -> )\"\n )\n\n assert_mismatched_delimiter_error(\n [\n \"nofile:1:16:\",\n \"unexpected token:\",\n \"└ unclosed delimiter\",\n \"└ mismatched closing delimiter\"\n ],\n ~c\"defmodule A do ]\"\n )\n\n assert_mismatched_delimiter_error(\n [\n \"nofile:1:9:\",\n \"unexpected token:\",\n \"└ unclosed delimiter\",\n \"└ mismatched closing delimiter\"\n ],\n ~c\"(1, 2, 3}\"\n )\n\n assert_mismatched_delimiter_error(\n [\n \"nofile:1:14:\",\n \"unexpected reserved word:\",\n \"└ unclosed delimiter\",\n \"└ mismatched closing delimiter\"\n ],\n ~c\"<<1, 2, 3, 4 end\"\n )\n end\n\n test \"invalid interpolation\" do\n assert_mismatched_delimiter_error(\n [\n \"nofile:1:17:\",\n \"unexpected token:\",\n \"└ unclosed delimiter\",\n \"└ mismatched closing delimiter\"\n ],\n ~c\"\\\"foo\\#{case 1 do )}bar\\\"\"\n )\n\n assert_mismatched_delimiter_error(\n [\n \"nofile:8:3:\",\n \"unexpected token: )\",\n \"└ unclosed delimiter\",\n \"└ mismatched closing delimiter\"\n ],\n ~c\"\"\"\n defmodule MyApp do\n (\n def one do\n # end\n\n def two do\n end\n )\n end\n \"\"\"\n )\n end\n\n test \"invalid end of expression\" do\n # All valid examples\n Code.eval_quoted(~c\"\"\"\n 1;\n 2;\n 3\n\n (;)\n (;1)\n (1;)\n (1; 2)\n\n fn -> 1; 2 end\n fn -> ; end\n\n if true do\n ;\n end\n\n try do\n ;\n catch\n _, _ -> ;\n after\n ;\n end\n \"\"\")\n\n # All invalid examples\n assert_syntax_error([\"nofile:1:3:\", \"syntax error before: ';'\"], ~c\"1+;\\n2\")\n\n assert_syntax_error([\"nofile:1:8:\", \"syntax error before: ';'\"], ~c\"max(1, ;2)\")\n end\n\n test \"invalid new line\" do\n assert_syntax_error(\n [\n \"nofile:3:6:\",\n \"unexpectedly reached end of line. The current expression is invalid or incomplete\",\n \"baz\",\n \"^\"\n ],\n ~c\"if true do\\n foo = [],\\n baz\\nend\"\n )\n end\n\n test \"invalid \\\"fn do expr end\\\"\" do\n assert_syntax_error(\n [\n \"nofile:1:4:\",\n \"unexpected reserved word: do. Anonymous functions are written as:\",\n \"fn pattern -> expression end\",\n \"Please remove the \\\"do\\\" keyword\",\n \"fn do :ok end\",\n \"^\"\n ],\n ~c\"fn do :ok end\"\n )\n end\n\n test \"characters literal are printed correctly in syntax errors\" do\n assert_syntax_error([\"nofile:1:5:\", \"syntax error before: ?a\"], ~c\":ok ?a\")\n assert_syntax_error([\"nofile:1:5:\", \"syntax error before: ?\\\\s\"], ~c\":ok ?\\\\s\")\n assert_syntax_error([\"nofile:1:5:\", \"syntax error before: ?す\"], ~c\":ok ?す\")\n end\n\n test \"character literals take newlines into account\" do\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert parse!(\"{?\\n}\\n{123}\") ==\n {:__block__, [], [{:{}, [line: 1], ~c\"\\n\"}, {:{}, [line: 3], ~c\"{\"}]}\n\n assert parse!(\"{?\\\\n}\\n{123}\") ==\n {:__block__, [], [{:{}, [line: 1], ~c\"\\n\"}, {:{}, [line: 2], ~c\"{\"}]}\n\n assert parse!(\"{?\\\\\\n}\\n{123}\") ==\n {:__block__, [], [{:{}, [line: 1], ~c\"\\n\"}, {:{}, [line: 3], ~c\"{\"}]}\n end)\n end\n\n test \"numbers are printed correctly in syntax errors\" do\n assert_syntax_error([\"nofile:1:5:\", ~s/syntax error before: \"12\"/], ~c\":ok 12\")\n assert_syntax_error([\"nofile:1:5:\", ~s/syntax error before: \"0b1\"/], ~c\":ok 0b1\")\n assert_syntax_error([\"nofile:1:5:\", ~s/syntax error before: \"12.3\"/], ~c\":ok 12.3\")\n\n assert_syntax_error(\n [\"nofile:1:1:\", ~s/invalid character \"_\" after number 123_456/],\n ~c\"123_456_foo\"\n )\n end\n\n test \"on hex errors\" do\n msg =\n \"invalid hex escape character, expected \\\\xHH where H is a hexadecimal digit. Syntax error after: \\\\x\"\n\n assert_syntax_error([\"nofile:1:2:\", msg], ~S[\"\\x\"])\n assert_syntax_error([\"nofile:1:1:\", msg], ~S[:\"\\x\"])\n assert_syntax_error([\"nofile:1:2:\", msg], ~S[\"\\x\": 123])\n assert_syntax_error([\"nofile:1:1:\", msg], ~s[\"\"\"\\n\\\\x\\n\"\"\"])\n end\n\n test \"on unicode errors\" do\n msg = \"invalid Unicode escape character\"\n\n assert_syntax_error([\"nofile:1:2:\", msg], ~S[\"\\u\"])\n assert_syntax_error([\"nofile:1:1:\", msg], ~S[:\"\\u\"])\n assert_syntax_error([\"nofile:1:2:\", msg], ~S[\"\\u\": 123])\n assert_syntax_error([\"nofile:1:1:\", msg], ~s[\"\"\"\\n\\\\u\\n\"\"\"])\n\n assert_syntax_error(\n [\n \"nofile:1:2:\",\n \"invalid or reserved Unicode code point \\\\u{FFFFFF}. Syntax error after: \\\\u\"\n ],\n ~S[\"\\u{FFFFFF}\"]\n )\n end\n\n test \"on interpolation in calls\" do\n msg =\n \"interpolation is not allowed when calling function/macro. Found interpolation in a call starting with: \\\"\"\n\n assert_syntax_error([msg], \".\\\"\\#{}\\\"\")\n assert_syntax_error([msg], \".\\\"a\\#{:b}\\\"c\")\n end\n\n test \"on long atoms\" do\n atom =\n \"@GR{+z]`_XrNla!d0ptDp(amr.oS&,UbT}v$L|rHHXGV{;W!>avHbD[T-G5xrzR6m?rQPot-37B@\"\n\n assert_syntax_error(\n [\"atom length must be less than system limit: \"],\n ~s{:\"#{atom}\"}\n )\n\n assert_syntax_error(\n [\"atom length must be less than system limit: \"],\n ~s{[\"#{atom}\": 123]}\n )\n end\n end\n\n defp parse!(string), do: Code.string_to_quoted!(string)\n\n defp assert_syntax_error(given_messages, source) do\n e = assert_raise SyntaxError, fn -> parse!(source) end\n assert_exception_msg(e, given_messages)\n end\n\n defp assert_mismatched_delimiter_error(given_messages, source) do\n e = assert_raise MismatchedDelimiterError, fn -> parse!(source) end\n assert_exception_msg(e, given_messages)\n end\n\n defp assert_exception_msg(exception, messages) do\n error_msg = Exception.format(:error, exception, [])\n\n for msg <- messages do\n assert error_msg =~ msg\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/quote_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.QuoteTest do\n use ExUnit.Case, async: true\n\n @some_fun &List.flatten/1\n\n test \"fun\" do\n assert is_function(@some_fun)\n end\n\n test \"list\" do\n assert quote(do: [1, 2, 3]) == [1, 2, 3]\n end\n\n test \"tuple\" do\n assert quote(do: {:a, 1}) == {:a, 1}\n end\n\n test \"keep line\" do\n line = __ENV__.line + 2\n\n assert quote(location: :keep, do: bar(1, 2, 3)) ==\n {:bar, [keep: {__ENV__.file, line}], [1, 2, 3]}\n end\n\n test \"fixed line\" do\n assert quote(line: 3, do: bar(1, 2, 3)) == {:bar, [line: 3], [1, 2, 3]}\n assert quote(line: false, do: bar(1, 2, 3)) == {:bar, [], [1, 2, 3]}\n assert quote(line: true, do: bar(1, 2, 3)) == {:bar, [line: __ENV__.line], [1, 2, 3]}\n end\n\n test \"file line\" do\n assert quote(file: \"foo\", line: 3, do: bar(1, 2, 3)) ==\n {:bar, [keep: {\"foo\", 3}], [1, 2, 3]}\n\n assert quote(file: \"foo\", line: false, do: bar(1, 2, 3)) ==\n {:bar, [keep: {\"foo\", 0}], [1, 2, 3]}\n\n assert quote(file: \"foo\", line: true, do: bar(1, 2, 3)) ==\n {:bar, [keep: {\"foo\", __ENV__.line - 1}], [1, 2, 3]}\n end\n\n test \"quote line var\" do\n line = __ENV__.line\n assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: line], [1, 2, 3]}\n\n assert_raise ArgumentError, fn ->\n line = \"oops\"\n quote(line: line, do: bar(1, 2, 3))\n end\n\n assert_raise ArgumentError, fn ->\n line = true\n quote(line: line, do: bar(1, 2, 3))\n end\n end\n\n test \"quote context var\" do\n context = :dynamic\n assert quote(context: context, do: bar) == {:bar, [], :dynamic}\n\n assert_raise ArgumentError, fn ->\n context = \"oops\"\n quote(context: context, do: bar)\n end\n\n assert_raise ArgumentError, fn ->\n context = nil\n quote(context: context, do: bar)\n end\n end\n\n test \"quote context bind_quoted\" do\n assert {:__block__, _,\n [{:=, [], [{:some_var, _, :fallback}, 321]}, {:some_var, _, :fallback}]} =\n (quote bind_quoted: [some_var: 321], context: __ENV__.context || :fallback do\n some_var\n end)\n end\n\n test \"operator precedence\" do\n assert {:+, _, [{:+, _, [1, _]}, 1]} = quote(do: 1 + Foo.l() + 1)\n assert {:+, _, [1, {_, _, [{:+, _, [1]}]}]} = quote(do: 1 + Foo.l(+1))\n end\n\n test \"generated\" do\n assert quote(generated: true, do: bar(1)) == {:bar, [generated: true], [1]}\n end\n\n test \"unquote call\" do\n assert quote(do: foo(bar)[unquote(:baz)]) == quote(do: foo(bar)[:baz])\n assert quote(do: unquote(:bar)()) == quote(do: bar())\n\n assert (quote do\n unquote(:bar)(1) do\n 2 + 3\n end\n end) ==\n (quote do\n bar 1 do\n 2 + 3\n end\n end)\n\n assert quote(do: foo.unquote(:bar)) == quote(do: foo.bar)\n assert quote(do: foo.unquote(:bar)()) == quote(do: foo.bar())\n assert quote(do: foo.unquote(:bar)(1)) == quote(do: foo.bar(1))\n\n assert (quote do\n foo.unquote(:bar)(1) do\n 2 + 3\n end\n end) ==\n (quote do\n foo.bar 1 do\n 2 + 3\n end\n end)\n\n assert quote(do: foo.unquote({:bar, [], nil})) == quote(do: foo.bar)\n assert quote(do: foo.unquote({:bar, [], nil})()) == quote(do: foo.bar())\n assert quote(do: foo.unquote({:bar, [], [1, 2]})) == quote(do: foo.bar(1, 2))\n\n assert Code.eval_quoted(quote(do: Foo.unquote(Bar))) == {Elixir.Foo.Bar, []}\n assert Code.eval_quoted(quote(do: Foo.unquote(quote(do: Bar)))) == {Elixir.Foo.Bar, []}\n\n assert_raise ArgumentError, fn ->\n quote(do: foo.unquote(1))\n end\n end\n\n test \"unquote call with dynamic line\" do\n assert quote(line: String.to_integer(\"123\"), do: Foo.unquote(:bar)()) ==\n quote(line: 123, do: Foo.bar())\n end\n\n test \"nested quote\" do\n assert {:quote, _, [[do: {:unquote, _, _}]]} = quote(do: quote(do: unquote(x)))\n end\n\n test \"import inside nested quote\" do\n # Check that we can evaluate imports from quote inside quote\n assert {{:to_string, meta, [123]}, _} = Code.eval_quoted(quote(do: quote(do: to_string(123))))\n assert meta[:imports] == [{1, Kernel}]\n end\n\n defmacrop nested_quote_in_macro do\n x = 1\n\n quote do\n x = unquote(x)\n\n quote do\n unquote(x)\n end\n end\n end\n\n test \"nested quote in macro\" do\n assert nested_quote_in_macro() == 1\n end\n\n defmodule Dyn do\n for {k, v} <- [foo: 1, bar: 2, baz: 3] do\n # Local call unquote\n def unquote(k)(), do: unquote(v)\n\n # Remote call unquote\n def unquote(k)(arg), do: __MODULE__.unquote(k)() + arg\n end\n end\n\n test \"dynamic definition with unquote\" do\n assert Dyn.foo() == 1\n assert Dyn.bar() == 2\n assert Dyn.baz() == 3\n\n assert Dyn.foo(1) == 2\n assert Dyn.bar(2) == 4\n assert Dyn.baz(3) == 6\n end\n\n test \"splice on root\" do\n contents = [1, 2, 3]\n\n assert quote(do: (unquote_splicing(contents))) ==\n (quote do\n 1\n 2\n 3\n end)\n end\n\n test \"splice with tail\" do\n contents = [1, 2, 3]\n\n assert quote(do: [unquote_splicing(contents) | [1, 2, 3]]) == [1, 2, 3, 1, 2, 3]\n\n assert quote(do: [unquote_splicing(contents) | val]) == quote(do: [1, 2, 3 | val])\n\n assert quote(do: [unquote_splicing(contents) | unquote([4])]) == quote(do: [1, 2, 3, 4])\n end\n\n test \"splice on stab\" do\n {fun, []} = Code.eval_quoted(quote(do: fn unquote_splicing([1, 2, 3]) -> :ok end), [])\n assert fun.(1, 2, 3) == :ok\n\n {fun, []} = Code.eval_quoted(quote(do: fn 1, unquote_splicing([2, 3]) -> :ok end), [])\n assert fun.(1, 2, 3) == :ok\n end\n\n test \"splice on definition\" do\n defmodule Hello do\n def world([unquote_splicing([\"foo\", \"bar\"]) | rest]) do\n rest\n end\n end\n\n assert Hello.world([\"foo\", \"bar\", \"baz\"]) == [\"baz\"]\n end\n\n test \"splice on map\" do\n assert %{unquote_splicing(foo: :bar)} == %{foo: :bar}\n assert %{unquote_splicing(foo: :bar), baz: :bat} == %{foo: :bar, baz: :bat}\n assert %{unquote_splicing(foo: :bar), :baz => :bat} == %{foo: :bar, baz: :bat}\n assert %{:baz => :bat, unquote_splicing(foo: :bar)} == %{foo: :bar, baz: :bat}\n\n map = %{foo: :default}\n assert %{map | unquote_splicing(foo: :bar)} == %{foo: :bar}\n end\n\n test \"when\" do\n assert [{:->, _, [[{:when, _, [1, 2, 3, 4]}], 5]}] = quote(do: (1, 2, 3 when 4 -> 5))\n\n assert [{:->, _, [[{:when, _, [1, 2, 3, {:when, _, [4, 5]}]}], 6]}] =\n quote(do: (1, 2, 3 when 4 when 5 -> 6))\n end\n\n test \"stab\" do\n assert [{:->, _, [[], 1]}] =\n (quote do\n () -> 1\n end)\n\n assert [{:->, _, [[], 1]}] = quote(do: (-> 1))\n end\n\n test \"empty block\" do\n # Since ; is allowed by itself, it must also be allowed inside ()\n # The exception to this rule is an empty (). While empty expressions\n # are allowed, an empty () is ambiguous. We also can't use quote here,\n # since the formatter will rewrite (;) to something else.\n assert {:ok, {:__block__, [line: 1], []}} = Code.string_to_quoted(\"(;)\")\n end\n\n test \"bind quoted\" do\n args = [\n {:=, [], [{:foo, [line: __ENV__.line + 4], Kernel.QuoteTest}, 3]},\n {:foo, [], Kernel.QuoteTest}\n ]\n\n quoted = quote(bind_quoted: [foo: 1 + 2], do: foo)\n assert quoted == {:__block__, [], args}\n end\n\n test \"literals\" do\n assert quote(do: []) == []\n assert quote(do: nil) == nil\n\n assert (quote do\n []\n end) == []\n\n assert (quote do\n nil\n end) == nil\n end\n\n defmacrop dynamic_opts do\n [line: 3]\n end\n\n test \"with dynamic opts\" do\n assert quote(dynamic_opts(), do: bar(1, 2, 3)) == {:bar, [line: 3], [1, 2, 3]}\n end\n\n test \"unary with integer precedence\" do\n assert quote(do: +1.foo) == quote(do: +1.foo)\n assert quote(do: (@1).foo) == quote(do: (@1).foo)\n assert quote(do: &1.foo) == quote(do: &1.foo)\n end\n\n test \"pipe precedence\" do\n assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =\n quote(do: foo |> bar |> baz)\n\n assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =\n (quote do\n foo do\n end\n |> bar\n |> baz\n end)\n\n assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =\n (quote do\n foo\n |> bar do\n end\n |> baz\n end)\n\n assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =\n (quote do\n foo\n |> bar\n |> baz do\n end\n end)\n\n assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =\n (quote do\n foo do\n end\n |> bar\n |> baz do\n end\n end)\n\n assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =\n (quote do\n foo do\n end\n |> bar do\n end\n |> baz do\n end\n end)\n end\n\n test \"capture\" do\n assert Code.string_to_quoted!(\"&1[:foo]\") == Code.string_to_quoted!(\"(&1)[:foo]\")\n assert Code.string_to_quoted!(\"&1 [:foo]\") == Code.string_to_quoted!(\"(&1)[:foo]\")\n assert Code.string_to_quoted!(\"& 1[:foo]\") == Code.string_to_quoted!(\"&(1[:foo])\")\n end\n\n test \"not and ! as rearrange ops\" do\n assert {:__block__, _, [{:not, [line: 1], [true]}]} = Code.string_to_quoted!(\"(not true)\")\n\n assert {:fn, _, [{:->, _, [[], {:not, _, [true]}]}]} =\n Code.string_to_quoted!(\"fn -> not true end\")\n end\nend\n\ndefmodule Kernel.QuoteTest.Errors do\n def line, do: __ENV__.line + 4\n\n defmacro defraise do\n quote location: :keep do\n def will_raise(_a, _b), do: raise(\"oops\")\n end\n end\n\n defmacro will_raise do\n quote(location: :keep, do: raise(\"oops\"))\n end\nend\n\ndefmodule Kernel.QuoteTest.ErrorsTest do\n use ExUnit.Case, async: true\n import Kernel.QuoteTest.Errors\n\n # Defines the add function\n defraise()\n\n @line line()\n test \"inside function error\" do\n try do\n will_raise(:a, :b)\n rescue\n RuntimeError ->\n mod = Kernel.QuoteTest.ErrorsTest\n file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()\n assert [{^mod, :will_raise, 2, [file: ^file, line: @line] ++ _} | _] = __STACKTRACE__\n end\n end\n\n @line __ENV__.line + 3\n test \"outside function error\" do\n try do\n will_raise()\n flunk(\"expected failure\")\n rescue\n RuntimeError ->\n mod = Kernel.QuoteTest.ErrorsTest\n file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()\n assert [{^mod, _, _, [file: ^file, line: @line] ++ _} | _] = __STACKTRACE__\n end\n end\nend\n\ndefmodule Kernel.QuoteTest.VarHygiene do\n defmacro no_interference do\n quote(do: a = 1)\n end\n\n defmacro write_interference do\n quote(do: var!(a) = 1)\n end\n\n defmacro read_interference do\n quote(do: 10 = var!(a))\n end\n\n defmacro cross_module_interference do\n quote(do: var!(a, Kernel.QuoteTest.VarHygieneTest) = 1)\n end\nend\n\ndefmodule Kernel.QuoteTest.VarHygieneTest do\n use ExUnit.Case, async: true\n import Kernel.QuoteTest.VarHygiene\n\n defmacrop cross_module_no_interference do\n quote(do: a = 10)\n end\n\n defmacrop read_cross_module do\n quote(do: var!(a, __MODULE__))\n end\n\n defmacrop nested(var, do: block) do\n quote do\n var = unquote(var)\n unquote(block)\n var\n end\n end\n\n defmacrop hat do\n quote do\n var = 1\n ^var = 1\n var\n end\n end\n\n test \"no interference\" do\n a = 10\n no_interference()\n assert a == 10\n end\n\n test \"cross module interference\" do\n cross_module_no_interference()\n cross_module_interference()\n assert read_cross_module() == 1\n end\n\n test \"write interference\" do\n write_interference()\n assert a == 1\n end\n\n test \"read interference\" do\n a = 10\n read_interference()\n end\n\n test \"hat\" do\n assert hat() == 1\n end\n\n test \"nested macro\" do\n assert (nested 1 do\n nested 2 do\n _ = :ok\n end\n end) == 1\n end\n\n test \"nested quoted\" do\n defmodule NestedQuote do\n defmacro __using__(_) do\n quote unquote: false do\n arg = quote(do: arg)\n\n def test(arg) do\n unquote(arg)\n end\n end\n end\n end\n\n defmodule UseNestedQuote do\n use NestedQuote\n end\n\n assert UseNestedQuote.test(\"foo\") == \"foo\"\n end\n\n test \"nested bind quoted\" do\n defmodule NestedBindQuoted do\n defmacrop macro(arg) do\n quote bind_quoted: [arg: arg] do\n quote bind_quoted: [arg: arg], do: String.duplicate(arg, 2)\n end\n end\n\n defmacro __using__(_) do\n quote do\n def test do\n unquote(macro(\"foo\"))\n end\n end\n end\n end\n\n defmodule UseNestedBindQuoted do\n use NestedBindQuoted\n end\n\n assert UseNestedBindQuoted.test() == \"foofoo\"\n end\nend\n\ndefmodule Kernel.QuoteTest.AliasHygiene do\n alias Dict, as: SuperDict\n\n defmacro dict do\n quote(do: Dict.Bar)\n end\n\n defmacro super_dict do\n quote(do: SuperDict.Bar)\n end\nend\n\ndefmodule Kernel.QuoteTest.AliasHygieneTest do\n use ExUnit.Case, async: true\n\n alias Dict, as: SuperDict\n\n test \"annotate aliases\" do\n assert {:__aliases__, [alias: false], [:Foo, :Bar]} = quote(do: Foo.Bar)\n assert {:__aliases__, [alias: false], [:Dict, :Bar]} = quote(do: Dict.Bar)\n assert {:__aliases__, [alias: Dict.Bar], [:SuperDict, :Bar]} = quote(do: SuperDict.Bar)\n\n # Edge-case\n assert {:__aliases__, _, [Elixir]} = quote(do: Elixir)\n end\n\n test \"expand aliases\" do\n assert Code.eval_quoted(quote(do: SuperDict.Bar)) == {Elixir.Dict.Bar, []}\n assert Code.eval_quoted(quote(do: alias!(SuperDict.Bar))) == {Elixir.SuperDict.Bar, []}\n end\n\n test \"expand aliases without macro\" do\n alias HashDict, as: SuperDict\n assert SuperDict.Bar == Elixir.HashDict.Bar\n end\n\n test \"expand aliases with macro does not expand source alias\" do\n alias HashDict, as: Dict, warn: false\n require Kernel.QuoteTest.AliasHygiene\n assert Kernel.QuoteTest.AliasHygiene.dict() == Elixir.Dict.Bar\n end\n\n test \"expand aliases with macro has higher preference\" do\n alias HashDict, as: SuperDict, warn: false\n require Kernel.QuoteTest.AliasHygiene\n assert Kernel.QuoteTest.AliasHygiene.super_dict() == Elixir.Dict.Bar\n end\nend\n\ndefmodule Kernel.QuoteTest.ImportsHygieneTest do\n use ExUnit.Case, async: true\n\n # We are redefining |> and using it inside the quote\n # and only inside the quote. This code should still compile.\n defmacro x |> f do\n quote do\n unquote(x) |> unquote(f)\n end\n end\n\n defmacrop get_list_length do\n quote do\n length(~c\"hello\")\n end\n end\n\n defmacrop get_list_length_with_pipe do\n quote do\n ~c\"hello\" |> length()\n end\n end\n\n defmacrop get_list_length_with_partial do\n quote do\n (&length(&1)).(~c\"hello\")\n end\n end\n\n defmacrop get_list_length_with_function do\n quote do\n (&length/1).(~c\"hello\")\n end\n end\n\n test \"expand imports\" do\n import Kernel, except: [length: 1]\n assert get_list_length() == 5\n assert get_list_length_with_pipe() == 5\n assert get_list_length_with_partial() == 5\n assert get_list_length_with_function() == 5\n end\n\n defmacrop get_string_length do\n import Kernel, except: [length: 1]\n\n quote do\n length(\"hello\")\n end\n end\n\n test \"lazy expand imports\" do\n import Kernel, except: [length: 1]\n import String, only: [length: 1]\n assert get_string_length() == 5\n end\n\n test \"lazy expand imports no conflicts\" do\n import Kernel, except: [length: 1]\n import String, only: [length: 1], warn: false\n\n assert get_list_length() == 5\n assert get_list_length_with_partial() == 5\n assert get_list_length_with_function() == 5\n end\n\n defmacrop with_length do\n quote do\n import Kernel, except: [length: 1]\n import String, only: [length: 1]\n length(~c\"hello\")\n end\n end\n\n test \"explicitly overridden imports\" do\n assert with_length() == 5\n end\n\n defmodule BinaryUtils do\n defmacro int32 do\n quote do\n integer - size(32)\n end\n end\n end\n\n test \"checks the context also for variables to zero-arity functions\" do\n import BinaryUtils\n {:int32, meta, __MODULE__} = quote(do: int32)\n assert meta[:imports] == [{0, BinaryUtils}]\n end\nend\n\ndefmodule Kernel.QuoteTest.HasUnquoteTest do\n use ExUnit.Case, async: true\n\n test \"expression without unquote returns false\" do\n ast =\n quote unquote: false do\n opts = [x: 5]\n x = Keyword.fetch!(opts, :x)\n x + 1\n end\n\n refute :elixir_quote.has_unquotes(ast)\n end\n\n test \"expression with unquote returns true\" do\n ast =\n quote unquote: false do\n [x: unquote(x)]\n end\n\n assert :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n unquote(module).fun(x)\n end\n\n assert :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n module.unquote(fun)(x)\n end\n\n assert :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n module.fun(unquote(x))\n end\n\n assert :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n module.fun(unquote_splicing(args))\n end\n\n assert :elixir_quote.has_unquotes(ast)\n end\n\n test \"expression with unquote within quote returns false\" do\n ast =\n quote unquote: false do\n quote do\n x + unquote(y)\n end\n end\n\n refute :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n quote do\n foo = bar(unquote_splicing(args))\n end\n end\n\n refute :elixir_quote.has_unquotes(ast)\n end\n\n test \"expression with unquote within unquote within quote returns true\" do\n ast =\n quote unquote: false do\n quote do\n x + unquote(unquote(y))\n end\n end\n\n assert :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n quote do\n foo = bar(unquote_splicing(unquote(args)))\n end\n end\n\n assert :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n quote do\n foo = bar(unquote(unquote_splicing(args)))\n end\n end\n\n assert :elixir_quote.has_unquotes(ast)\n end\n\n test \"expression within quote disabling unquotes always returns false\" do\n ast =\n quote unquote: false do\n quote unquote: false do\n x + unquote(unquote(y))\n end\n end\n\n refute :elixir_quote.has_unquotes(ast)\n\n ast =\n quote unquote: false do\n quote bind_quoted: [x: x] do\n x + unquote(unquote(y))\n end\n end\n\n refute :elixir_quote.has_unquotes(ast)\n end\n\n test \"unquote with invalid AST (shallow check)\" do\n for term <- [\n %{unescaped: :map},\n 1..10,\n {:bad_meta, nil, []},\n {:bad_arg, nil, 1},\n {:bad_tuple},\n make_ref(),\n [:improper | :list],\n [nested: {}]\n ] do\n message = \"\"\"\n tried to unquote invalid AST: #{inspect(term)}\n Did you forget to escape term using Macro.escape/1?\\\n \"\"\"\n\n assert_raise ArgumentError, message, fn -> quote do: unquote(term) end\n end\n end\n\n test \"unquote with invalid AST is not checked deeply\" do\n assert quote do: unquote(foo: [1 | 2]) == [foo: [1 | 2]]\n assert quote do: unquote(foo: [bar: %{}]) == [foo: [bar: %{}]]\n end\n\n test \"unquote_splicing with invalid AST\" do\n for args <- [\n \"not_a_list\",\n [:improper | :list],\n [%{unescaped: :map}],\n [1..10],\n [{:bad_meta, nil, []}],\n [{:bad_arg, nil, 1}],\n [{:bad_tuple}],\n [make_ref()],\n [nested: {}]\n ] do\n message =\n \"expected a list with quoted expressions in unquote_splicing/1, got: #{inspect(args)}\"\n\n assert_raise ArgumentError, message, fn -> quote do: [unquote_splicing(args)] end\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/raise_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.RaiseTest do\n use ExUnit.Case, async: true\n\n # Silence warnings\n defp atom, do: RuntimeError\n defp binary, do: \"message\"\n defp opts, do: [message: \"message\"]\n defp struct, do: %RuntimeError{message: \"message\"}\n\n @compile {:no_warn_undefined, DoNotExist}\n @trace [{:foo, :bar, 0, []}]\n\n test \"raise preserves the stacktrace\" do\n stacktrace =\n try do\n raise \"a\"\n rescue\n _ -> Enum.fetch!(__STACKTRACE__, 0)\n end\n\n file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()\n\n assert {__MODULE__, :\"test raise preserves the stacktrace\", _, [file: ^file, line: 22] ++ _} =\n stacktrace\n end\n\n test \"raise message\" do\n assert_raise RuntimeError, \"message\", fn ->\n raise \"message\"\n end\n\n assert_raise RuntimeError, \"message\", fn ->\n var = binary()\n raise var\n end\n end\n\n test \"raise with no arguments\" do\n assert_raise RuntimeError, fn ->\n raise RuntimeError\n end\n\n assert_raise RuntimeError, fn ->\n var = atom()\n raise var\n end\n end\n\n test \"raise with arguments\" do\n assert_raise RuntimeError, \"message\", fn ->\n raise RuntimeError, message: \"message\"\n end\n\n assert_raise RuntimeError, \"message\", fn ->\n atom = atom()\n opts = opts()\n raise atom, opts\n end\n end\n\n test \"raise existing exception\" do\n assert_raise RuntimeError, \"message\", fn ->\n raise %RuntimeError{message: \"message\"}\n end\n\n assert_raise RuntimeError, \"message\", fn ->\n var = struct()\n raise var\n end\n end\n\n test \"raise with error_info\" do\n {exception, stacktrace} =\n try do\n raise \"a\"\n rescue\n e -> {e, __STACKTRACE__}\n end\n\n assert [{__MODULE__, _, _, meta} | _] = stacktrace\n assert meta[:error_info] == %{module: Exception}\n\n assert Exception.format_error(exception, stacktrace) ==\n %{general: \"a\", reason: \"#Elixir.RuntimeError\"}\n end\n\n test \"reraise message\" do\n try do\n reraise \"message\", @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n\n try do\n var = binary()\n reraise var, @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n end\n\n test \"reraise with no arguments\" do\n try do\n reraise RuntimeError, @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n\n try do\n var = atom()\n reraise var, @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n end\n\n test \"reraise with arguments\" do\n try do\n reraise RuntimeError, [message: \"message\"], @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n\n try do\n atom = atom()\n opts = opts()\n reraise atom, opts, @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n end\n\n test \"reraise existing exception\" do\n try do\n reraise %RuntimeError{message: \"message\"}, @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n\n try do\n var = struct()\n reraise var, @trace\n flunk(\"should not reach\")\n rescue\n RuntimeError ->\n assert @trace == __STACKTRACE__\n end\n end\n\n describe \"rescue\" do\n test \"runtime error\" do\n result =\n try do\n raise \"an exception\"\n rescue\n RuntimeError -> true\n catch\n :error, _ -> false\n end\n\n assert result\n\n result =\n try do\n raise \"an exception\"\n rescue\n ArgumentError -> true\n catch\n :error, _ -> false\n end\n\n refute result\n end\n\n test \"named runtime error\" do\n result =\n try do\n raise \"an exception\"\n rescue\n x in [RuntimeError] -> Exception.message(x)\n catch\n :error, _ -> false\n end\n\n assert result == \"an exception\"\n end\n\n test \"named runtime or argument error\" do\n result =\n try do\n raise \"an exception\"\n rescue\n x in [ArgumentError, RuntimeError] -> Exception.message(x)\n catch\n :error, _ -> false\n end\n\n assert result == \"an exception\"\n end\n\n test \"named function clause (stacktrace) or runtime (no stacktrace) error\" do\n result =\n try do\n Access.get(Process.get(:unused, \"foo\"), 0)\n rescue\n x in [FunctionClauseError, CaseClauseError] -> Exception.message(x)\n end\n\n assert result == \"no function clause matching in Access.get/3\"\n end\n\n test \"with higher precedence than catch\" do\n result =\n try do\n raise \"an exception\"\n rescue\n _ -> true\n catch\n _, _ -> false\n end\n\n assert result\n end\n\n test \"argument error from Erlang\" do\n result =\n try do\n :erlang.error(:badarg)\n rescue\n ArgumentError -> true\n end\n\n assert result\n end\n\n test \"argument error from Elixir\" do\n result =\n try do\n raise ArgumentError, \"\"\n rescue\n ArgumentError -> true\n end\n\n assert result\n end\n\n test \"catch-all variable\" do\n result =\n try do\n raise \"an exception\"\n rescue\n x -> Exception.message(x)\n end\n\n assert result == \"an exception\"\n end\n\n test \"catch-all underscore\" do\n result =\n try do\n raise \"an exception\"\n rescue\n _ -> true\n end\n\n assert result\n end\n\n test \"catch-all unused variable\" do\n result =\n try do\n raise \"an exception\"\n rescue\n _any -> true\n end\n\n assert result\n end\n\n test \"catch-all with \\\"x in _\\\" syntax\" do\n result =\n try do\n raise \"an exception\"\n rescue\n exception in _ ->\n Exception.message(exception)\n end\n\n assert result == \"an exception\"\n end\n\n defmacrop argerr(e) do\n quote(do: unquote(e) in ArgumentError)\n end\n\n test \"with rescue macro\" do\n result =\n try do\n raise ArgumentError, \"oops, badarg\"\n rescue\n argerr(e) -> Exception.message(e)\n end\n\n assert result == \"oops, badarg\"\n end\n end\n\n describe \"normalize\" do\n test \"wrap custom Erlang error\" do\n result =\n try do\n :erlang.error(:sample)\n rescue\n x in [ErlangError] -> Exception.message(x)\n end\n\n assert result == \"Erlang error: :sample\"\n end\n\n test \"undefined function error\" do\n result =\n try do\n DoNotExist.for_sure()\n rescue\n x in [UndefinedFunctionError] -> Exception.message(x)\n end\n\n assert result ==\n \"function DoNotExist.for_sure/0 is undefined (module DoNotExist is not available). \" <>\n \"Make sure the module name is correct and has been specified in full (or that an alias has been defined)\"\n end\n\n test \"function clause error\" do\n result =\n try do\n Access.get(Process.get(:unused, :ok), :error)\n rescue\n x in [FunctionClauseError] -> Exception.message(x)\n end\n\n assert result == \"no function clause matching in Access.get/3\"\n end\n\n test \"badarg error\" do\n result =\n try do\n :erlang.error(:badarg)\n rescue\n x in [ArgumentError] -> Exception.message(x)\n end\n\n assert result == \"argument error\"\n end\n\n test \"tuple badarg error\" do\n result =\n try do\n :erlang.error({:badarg, [1, 2, 3]})\n rescue\n x in [ArgumentError] -> Exception.message(x)\n end\n\n assert result == \"argument error: [1, 2, 3]\"\n end\n\n test \"badarith error\" do\n result =\n try do\n :erlang.error(:badarith)\n rescue\n x in [ArithmeticError] -> Exception.message(x)\n end\n\n assert result == \"bad argument in arithmetic expression\"\n end\n\n test \"badarity error\" do\n fun = fn x -> x end\n string = \"#{inspect(fun)} with arity 1 called with 2 arguments (1, 2)\"\n\n result =\n try do\n Process.get(:unused, fun).(1, 2)\n rescue\n x in [BadArityError] -> Exception.message(x)\n end\n\n assert result == string\n end\n\n test \"badfun error\" do\n result =\n try do\n Process.get(:unused, :example).(2)\n rescue\n x in [BadFunctionError] -> Exception.message(x)\n end\n\n assert result == \"expected a function, got: :example\"\n end\n\n test \"badfun error when the function is gone\" do\n defmodule BadFunction.Missing do\n def fun, do: fn -> :ok end\n end\n\n fun = BadFunction.Missing.fun()\n\n :code.purge(BadFunction.Missing)\n :code.delete(BadFunction.Missing)\n\n defmodule BadFunction.Missing do\n def fun, do: fn -> :another end\n end\n\n :code.purge(BadFunction.Missing)\n\n try do\n fun.()\n rescue\n x in [BadFunctionError] ->\n assert Exception.message(x) =~\n ~r/function #Function<[0-9]\\.[0-9]*\\/0[^>]*> is invalid, likely because it points to an old version of the code/\n else\n _ -> flunk(\"this should not be invoked\")\n end\n end\n\n test \"badmatch error\" do\n result =\n try do\n [] = Range.to_list(1000_000..1_000_009)\n rescue\n x in [MatchError] -> Exception.message(x)\n end\n\n assert result ==\n \"\"\"\n no match of right hand side value:\n\n [1000000, 1000001, 1000002, 1000003, 1000004, 1000005, 1000006, 1000007,\n 1000008, 1000009]\n \"\"\"\n end\n\n test \"bad key error\" do\n result =\n try do\n %{Process.get(:unused, %{}) | foo: :bar}\n rescue\n x in [KeyError] -> Exception.message(x)\n end\n\n assert result == \"key :foo not found\"\n\n result =\n try do\n Process.get(:unused, %{}).foo\n rescue\n x in [KeyError] -> Exception.message(x)\n end\n\n assert result == \"key :foo not found in:\\n\\n %{}\\n\"\n end\n\n test \"bad map error\" do\n result =\n try do\n %{Process.get(:unused, 0) | foo: :bar}\n rescue\n x in [BadMapError] -> Exception.message(x)\n end\n\n assert result == \"expected a map, got:\\n\\n 0\\n\"\n end\n\n test \"bad boolean error\" do\n result =\n try do\n Process.get(:unused, 1) and true\n rescue\n x in [BadBooleanError] -> Exception.message(x)\n end\n\n assert result == \"expected a boolean on left-side of \\\"and\\\", got:\\n\\n 1\\n\"\n end\n\n test \"case clause error\" do\n x = :example\n\n result =\n try do\n case Process.get(:unused, 0) do\n ^x -> nil\n end\n rescue\n x in [CaseClauseError] -> Exception.message(x)\n end\n\n assert result == \"no case clause matching:\\n\\n 0\\n\"\n end\n\n test \"cond clause error\" do\n result =\n try do\n cond do\n !Process.get(:unused, 0) -> :ok\n end\n rescue\n x in [CondClauseError] -> Exception.message(x)\n end\n\n assert result == \"no cond clause evaluated to a truthy value\"\n end\n\n test \"try clause error\" do\n result =\n try do\n try do\n Process.get(:unused, :example)\n rescue\n _exception ->\n :ok\n else\n :other ->\n :ok\n end\n rescue\n x in [TryClauseError] -> Exception.message(x)\n end\n\n assert result == \"no try clause matching:\\n\\n :example\\n\"\n end\n\n test \"undefined function error as Erlang error\" do\n result =\n try do\n DoNotExist.for_sure()\n rescue\n x in [ErlangError] -> Exception.message(x)\n end\n\n assert result ==\n \"function DoNotExist.for_sure/0 is undefined (module DoNotExist is not available). \" <>\n \"Make sure the module name is correct and has been specified in full (or that an alias has been defined)\"\n end\n end\n\n defmacrop exceptions do\n [ErlangError]\n end\n\n test \"with macros\" do\n result =\n try do\n DoNotExist.for_sure()\n rescue\n x in exceptions() -> Exception.message(x)\n end\n\n assert result ==\n \"function DoNotExist.for_sure/0 is undefined (module DoNotExist is not available). \" <>\n \"Make sure the module name is correct and has been specified in full (or that an alias has been defined)\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/sigils_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.SigilsTest do\n use ExUnit.Case, async: true\n\n test \"sigil s\" do\n assert ~s(foo) == \"foo\"\n assert ~s(f#{:o}o) == \"foo\"\n assert ~s(f\\no) == \"f\\no\"\n end\n\n test \"sigil s with heredoc\" do\n assert \" foo\\n\\n\" == ~s\"\"\"\n f#{:o}o\\n\n \"\"\"\n end\n\n test \"sigil S\" do\n assert ~S(foo) == \"foo\"\n assert ~S[foo] == \"foo\"\n assert ~S{foo} == \"foo\"\n assert ~S'foo' == \"foo\"\n assert ~S\"foo\" == \"foo\"\n assert ~S == \"foo\"\n assert ~S/foo/ == \"foo\"\n assert ~S|foo| == \"foo\"\n assert ~S(f#{o}o) == \"f\\#{o}o\"\n assert ~S(f\\#{o}o) == \"f\\\\\\#{o}o\"\n assert ~S(f\\no) == \"f\\\\no\"\n end\n\n test \"sigil S newline\" do\n assert ~S(foo\\\nbar) in [\"foo\\\\\\nbar\", \"foo\\\\\\r\\nbar\"]\n end\n\n test \"sigil S with heredoc\" do\n assert \" f\\#{o}o\\\\n\\n\" == ~S\"\"\"\n f#{o}o\\n\n \"\"\"\n end\n\n test \"sigil s/S expand to binary when possible\" do\n assert Macro.expand(quote(do: ~s(foo)), __ENV__) == \"foo\"\n assert Macro.expand(quote(do: ~S(foo)), __ENV__) == \"foo\"\n end\n\n test \"sigil c\" do\n assert ~c(foo) == ~c\"foo\"\n assert ~c(f#{:o}o) == ~c\"foo\"\n assert ~c(f\\no) == ~c\"f\\no\"\n end\n\n test \"sigil C\" do\n assert ~C(foo) == ~c\"foo\"\n assert ~C[foo] == ~c\"foo\"\n assert ~C{foo} == ~c\"foo\"\n assert ~C'foo' == ~c\"foo\"\n assert ~C\"foo\" == ~c\"foo\"\n assert ~C|foo| == ~c\"foo\"\n assert ~C(f#{o}o) == ~c\"f\\#{o}o\"\n assert ~C(f\\no) == ~c\"f\\\\no\"\n end\n\n test \"sigil w\" do\n assert ~w() == []\n assert ~w([ , ]) == [\"[\", \",\", \"]\"]\n assert ~w(foo bar baz) == [\"foo\", \"bar\", \"baz\"]\n assert ~w(foo #{:bar} baz) == [\"foo\", \"bar\", \"baz\"]\n\n assert ~w(#{\"\"}) == []\n assert ~w(foo #{\"\"}) == [\"foo\"]\n assert ~w(#{\" foo bar \"}) == [\"foo\", \"bar\"]\n\n assert ~w(foo\\ #{:bar}) == [\"foo\", \"bar\"]\n assert ~w(foo\\ bar) == [\"foo\", \"bar\"]\n\n assert ~w(\n foo\n bar\n baz\n ) == [\"foo\", \"bar\", \"baz\"]\n\n assert ~w(foo bar baz)s == [\"foo\", \"bar\", \"baz\"]\n assert ~w(foo bar baz)a == [:foo, :bar, :baz]\n assert ~w(foo bar baz)c == [~c\"foo\", ~c\"bar\", ~c\"baz\"]\n\n bad_modifier = quote(do: ~w(foo bar baz)x)\n assert %ArgumentError{} = catch_error(Code.eval_quoted(bad_modifier))\n\n assert ~w(Foo Bar)a == [:Foo, :Bar]\n assert ~w(Foo.#{Bar}.Baz)a == [:\"Foo.Elixir.Bar.Baz\"]\n assert ~w(Foo.Bar)s == [\"Foo.Bar\"]\n assert ~w(Foo.#{Bar})c == [~c\"Foo.Elixir.Bar\"]\n\n # Ensure it is fully expanded at compile time\n assert Macro.expand(quote(do: ~w(a b c)a), __ENV__) == [:a, :b, :c]\n end\n\n test \"sigil W\" do\n assert ~W() == []\n assert ~W([ , ]) == [\"[\", \",\", \"]\"]\n assert ~W(foo #{bar} baz) == [\"foo\", \"\\#{bar}\", \"baz\"]\n\n assert ~W(foo\\ bar) == [\"foo\\\\\", \"bar\"]\n\n assert ~W(\n foo\n bar\n baz\n ) == [\"foo\", \"bar\", \"baz\"]\n\n assert ~W(foo bar baz)s == [\"foo\", \"bar\", \"baz\"]\n assert ~W(foo bar baz)a == [:foo, :bar, :baz]\n assert ~W(foo bar baz)c == [~c\"foo\", ~c\"bar\", ~c\"baz\"]\n\n bad_modifier = quote(do: ~W(foo bar baz)x)\n assert %ArgumentError{} = catch_error(Code.eval_quoted(bad_modifier))\n\n assert ~W(Foo #{Bar})a == [:Foo, :\"\\#{Bar}\"]\n assert ~W(Foo.Bar.Baz)a == [:\"Foo.Bar.Baz\"]\n end\n\n test \"sigils matching\" do\n assert ~s(f\\(oo) == \"f(oo\"\n assert ~s(fo\\)o) == \"fo)o\"\n assert ~s(f\\(o\\)o) == \"f(o)o\"\n assert ~s(f[oo) == \"f[oo\"\n assert ~s(fo]o) == \"fo]o\"\n end\n\n describe \"multi-letter sigils\" do\n def sigil_MAT(string, modifiers) do\n %{matrix: string, modifiers: modifiers}\n end\n\n test \"sigil MAT\" do\n assert ~MAT\"foo\" == %{matrix: \"foo\", modifiers: []}\n assert ~MAT[foo]i == %{matrix: \"foo\", modifiers: ~c\"i\"}\n assert ~MAT(\"1\")mod == %{matrix: \"\\\"1\\\"\", modifiers: ~c\"mod\"}\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/special_forms_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.SpecialFormsTest do\n use ExUnit.Case, async: true\n\n doctest Kernel.SpecialForms\n\n describe \"cond\" do\n test \"does not leak variables for one clause\" do\n x = 0\n\n cond do\n true ->\n x = 1\n x\n end\n\n assert x == 0\n end\n\n test \"does not leak variables for one clause with non-boolean as catch-all\" do\n x = 0\n\n cond do\n :otherwise ->\n x = 1\n x\n end\n\n assert x == 0\n end\n\n test \"does not leak variables for multiple clauses\" do\n x = 0\n\n cond do\n List.flatten([]) == [] ->\n x = 1\n x\n\n true ->\n x = 1\n x\n end\n\n assert x == 0\n end\n\n test \"does not leak variables from conditions\" do\n x = :not_nil\n\n result =\n cond do\n x = List.first([]) ->\n x\n\n true ->\n x\n end\n\n assert result == :not_nil\n end\n\n test \"does not warn on non-boolean as catch-all\" do\n cond do\n List.flatten([]) == [] -> :good\n :otherwise -> :also_good\n end\n end\n\n test \"cond_clause error keeps line number in stacktrace\" do\n try do\n cond do\n Process.get(:unused, false) -> :ok\n end\n rescue\n _ ->\n assert [{Kernel.SpecialFormsTest, _, _, meta} | _] = __STACKTRACE__\n assert meta[:file]\n assert meta[:line]\n end\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/string_tokenizer_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.StringTokenizerTest do\n use ExUnit.Case, async: true\n\n defp var({var, _, nil}), do: var\n defp aliases({:__aliases__, _, [alias]}), do: alias\n\n test \"tokenizes vars\" do\n assert Code.string_to_quoted!(\"_12\") |> var() == :_12\n assert Code.string_to_quoted!(\"ola\") |> var() == :ola\n assert Code.string_to_quoted!(\"ólá\") |> var() == :ólá\n assert Code.string_to_quoted!(\"óLÁ\") |> var() == :óLÁ\n assert Code.string_to_quoted!(\"ólá?\") |> var() == :ólá?\n assert Code.string_to_quoted!(\"ólá!\") |> var() == :ólá!\n assert Code.string_to_quoted!(\"こんにちは世界\") |> var() == :こんにちは世界\n assert {:error, _} = Code.string_to_quoted(\"v@r\")\n assert {:error, _} = Code.string_to_quoted(\"1var\")\n end\n\n test \"tokenizes atoms\" do\n assert Code.string_to_quoted!(\":_12\") == :_12\n assert Code.string_to_quoted!(\":ola\") == :ola\n assert Code.string_to_quoted!(\":ólá\") == :ólá\n assert Code.string_to_quoted!(\":ólá?\") == :ólá?\n assert Code.string_to_quoted!(\":ólá!\") == :ólá!\n assert Code.string_to_quoted!(\":ól@\") == :ól@\n assert Code.string_to_quoted!(\":ól@!\") == :ól@!\n assert Code.string_to_quoted!(\":ó@@!\") == :ó@@!\n assert Code.string_to_quoted!(\":Ola\") == :Ola\n assert Code.string_to_quoted!(\":Ólá\") == :Ólá\n assert Code.string_to_quoted!(\":ÓLÁ\") == :ÓLÁ\n assert Code.string_to_quoted!(\":ÓLÁ?\") == :ÓLÁ?\n assert Code.string_to_quoted!(\":ÓLÁ!\") == :ÓLÁ!\n assert Code.string_to_quoted!(\":ÓL@!\") == :ÓL@!\n assert Code.string_to_quoted!(\":Ó@@!\") == :Ó@@!\n assert Code.string_to_quoted!(\":こんにちは世界\") == :こんにちは世界\n assert {:error, _} = Code.string_to_quoted(\":123\")\n assert {:error, _} = Code.string_to_quoted(\":@123\")\n end\n\n test \"tokenizes keywords\" do\n assert Code.string_to_quoted!(\"[_12: 0]\") == [_12: 0]\n assert Code.string_to_quoted!(\"[ola: 0]\") == [ola: 0]\n assert Code.string_to_quoted!(\"[ólá: 0]\") == [ólá: 0]\n assert Code.string_to_quoted!(\"[ólá?: 0]\") == [ólá?: 0]\n assert Code.string_to_quoted!(\"[ólá!: 0]\") == [ólá!: 0]\n assert Code.string_to_quoted!(\"[ól@: 0]\") == [ól@: 0]\n assert Code.string_to_quoted!(\"[ól@!: 0]\") == [ól@!: 0]\n assert Code.string_to_quoted!(\"[ó@@!: 0]\") == [ó@@!: 0]\n assert Code.string_to_quoted!(\"[Ola: 0]\") == [Ola: 0]\n assert Code.string_to_quoted!(\"[Ólá: 0]\") == [Ólá: 0]\n assert Code.string_to_quoted!(\"[ÓLÁ: 0]\") == [ÓLÁ: 0]\n assert Code.string_to_quoted!(\"[ÓLÁ?: 0]\") == [ÓLÁ?: 0]\n assert Code.string_to_quoted!(\"[ÓLÁ!: 0]\") == [ÓLÁ!: 0]\n assert Code.string_to_quoted!(\"[ÓL@!: 0]\") == [ÓL@!: 0]\n assert Code.string_to_quoted!(\"[Ó@@!: 0]\") == [Ó@@!: 0]\n assert Code.string_to_quoted!(\"[こんにちは世界: 0]\") == [こんにちは世界: 0]\n assert {:error, _} = Code.string_to_quoted(\"[123: 0]\")\n assert {:error, _} = Code.string_to_quoted(\"[@123: 0]\")\n end\n\n test \"tokenizes aliases\" do\n assert Code.string_to_quoted!(\"Ola\") |> aliases() == String.to_atom(\"Ola\")\n assert Code.string_to_quoted!(\"M_123\") |> aliases() == String.to_atom(\"M_123\")\n assert {:error, _} = Code.string_to_quoted(\"Óla\")\n assert {:error, _} = Code.string_to_quoted(\"Olá\")\n assert {:error, _} = Code.string_to_quoted(\"Ol@\")\n assert {:error, _} = Code.string_to_quoted(\"Ola?\")\n assert {:error, _} = Code.string_to_quoted(\"Ola!\")\n end\n\n test \"tokenizes remote calls\" do\n # We chose the atom below because Erlang represents it using nested lists\n assert {{:., _, [:foo, :บูมเมอแรง]}, _, []} =\n Code.string_to_quoted!(\":foo.บูมเมอแรง()\")\n\n assert {{:., _, [:foo, :บูมเมอแรง]}, _, []} =\n Code.string_to_quoted!(\":foo.\\\"บูมเมอแรง\\\"()\")\n end\n\n describe \"script mixing\" do\n test \"prevents Restricted codepoints in identifiers\" do\n exception = assert_raise SyntaxError, fn -> Code.string_to_quoted!(\"_shibㅤ = 1\") end\n\n assert Exception.message(exception) =~\n \"unexpected token: \\\"ㅤ\\\" (column 6, code point U+3164)\"\n end\n\n test \"prevents unsafe mixing in identifiers\" do\n exception =\n assert_raise SyntaxError, fn ->\n Code.string_to_quoted!(\"if аdmin_, do: :ok, else: :err\")\n end\n\n assert Exception.message(exception) =~ \"nofile:1:9:\"\n assert Exception.message(exception) =~ \"invalid mixed-script identifier found: аdmin\"\n\n for s <- [\n \"\\\\u0430 а {Cyrillic}\",\n \"\\\\u0064 d {Latin}\",\n \"\\\\u006D m {Latin}\",\n \"\\\\u0069 i {Latin}\",\n \"\\\\u006E n {Latin}\",\n \"\\\\u005F _\"\n ] do\n assert Exception.message(exception) =~ s\n end\n\n # includes suggestion about what to change\n assert Exception.message(exception) =~ \"\"\"\n Hint: You could write the above in a similar way that is accepted by Elixir:\n \"\"\"\n\n assert Exception.message(exception) =~ \"\"\"\n \"admin_\" (code points 0x00061 0x00064 0x0006D 0x00069 0x0006E 0x0005F)\n \"\"\"\n\n # a is in cyrillic\n assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!(\"[аdmin: 1]\") end\n assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!(\"[{:аdmin, 1}]\") end\n assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!(\"quote do: аdmin(1)\") end\n\n # c is Latin\n assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!(\"http_cервер = 1\") end\n\n # T is in cyrillic\n assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!(\"[Тシャツ: 1]\") end\n end\n\n test \"allows legitimate script mixing\" do\n # Mixed script with supersets, numbers, and underscores\n assert Code.eval_string(\"幻한 = 1\") == {1, [幻한: 1]}\n assert Code.eval_string(\"幻한1 = 1\") == {1, [幻한1: 1]}\n assert Code.eval_string(\"__सवव_1? = 1\") == {1, [__सवव_1?: 1]}\n\n # Elixir's normalizations combine scriptsets of the 'from' and 'to' characters,\n # ex: {Common} MICRO => {Greek} MU == {Common, Greek}; Common intersects w/all\n assert Code.eval_string(\"μs = 1\") == {1, [μs: 1]}\n\n # Mixed scripts in variables\n assert Code.eval_string(\"http_сервер = 1\") == {1, [http_сервер: 1]}\n assert Code.eval_string(\"сервер_http = 1\") == {1, [сервер_http: 1]}\n\n # Mixed scripts in atoms\n assert Code.eval_string(\":T_シャツ\") == {:T_シャツ, []}\n end\n\n test \"bidi\" do\n # test that the implementation of String.Tokenizer.Security.unbidify/1 agrees\n # w/Unicode Bidi Algo (UAX9) for these (identifier-specific, no-bracket) examples\n #\n # you can create new examples with: https://util.unicode.org/UnicodeJsps/bidic.jsp?s=foo_%D9%84%D8%A7%D9%85%D8%AF%D8%A7_baz&b=0&u=140&d=2\n # inspired by (none of these are directly usable for our idents): https://www.unicode.org/Public/UCD/latest/ucd/BidiCharacterTest.txt\n #\n # there's a spurious ;A; after the identifier, because the semicolon is dir-neutral, and\n # deleting it makes these examples hard to read in many/most editors!\n \"\"\"\n foo;A;0066 006F 006F;0 1 2\n _foo_ ;A;005F 0066 006F 006F 005F;0 1 2 3 4\n __foo__ ;A;005F 005F 0066 006F 006F 005F 005F;0 1 2 3 4 5 6\n لامدا_foo ;A;0644 0627 0645 062F 0627 005F 0066 006F 006F;4 3 2 1 0 5 6 7 8\n foo_لامدا_baz ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 0062 0061 007A;0 1 2 3 8 7 6 5 4 9 10 11 12\n foo_لامدا ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627;0 1 2 3 8 7 6 5 4\n foo_لامدا1 ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 0031;0 1 2 3 9 8 7 6 5 4\n foo_لامدا_حدد ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F;0 1 2 3 12 11 10 9 8 7 6 5 4\n foo_لامدا_حدد1 ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F 0031;0 1 2 3 13 12 11 10 9 8 7 6 5 4\n foo_لامدا_حدد1_bar ;A; 0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F 0031 005F 0062 0061 0072;0 1 2 3 13 12 11 10 9 8 7 6 5 4 14 15 16 17\n foo_لامدا_حدد1_bar1 ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F 0031 005F 0062 0061 0072 0031;0 1 2 3 13 12 11 10 9 8 7 6 5 4 14 15 16 17 18\n \"\"\"\n |> String.split(\"\\n\", trim: true)\n |> Enum.map(&String.split(&1, \";\", trim: true))\n |> Enum.each(fn\n [ident, _, bytes, indices | _rest] ->\n bytes = String.split(bytes, \" \", trim: true) |> Enum.map(&String.to_integer(&1, 16))\n indices = String.split(indices, \" \", trim: true) |> Enum.map(&String.to_integer/1)\n display_ordered = for i <- indices, do: Enum.at(bytes, i)\n unbidified = String.Tokenizer.Security.unbidify(bytes)\n\n if display_ordered != unbidified do\n raise \"\"\"\n Failing String.Tokenizer.Security.unbidify/1 case for: '#{ident}'\n bytes : #{bytes |> Enum.map(&Integer.to_string(&1, 16)) |> Enum.join(\" \")}\n byte order : #{bytes |> Enum.intersperse(32)}\n uax9 order : #{display_ordered |> Enum.intersperse(32)}\n uax9 indices : #{indices |> Enum.join(\" \")}\n unbidify/1 : #{unbidified |> Enum.intersperse(32)}\n \"\"\"\n end\n end)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/tracers_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.TracersTest do\n use ExUnit.Case\n\n defp compile_string(string) do\n string\n |> Code.string_to_quoted!(columns: true)\n |> Code.compile_quoted()\n end\n\n def trace(event, %Macro.Env{} = env) do\n for {pid, _} <- Registry.lookup(__MODULE__, :tracers) do\n send(pid, {event, env})\n end\n\n :ok\n end\n\n setup_all do\n start_supervised!({Registry, keys: :duplicate, name: __MODULE__})\n Code.put_compiler_option(:tracers, [__MODULE__])\n\n on_exit(fn ->\n Code.put_compiler_option(:tracers, [])\n end)\n end\n\n setup do\n Registry.register(__MODULE__, :tracers, :unused)\n :ok\n end\n\n test \"traces start and stop\" do\n compile_string(\"\"\"\n Foo\n \"\"\")\n\n assert_received {:start, %{lexical_tracker: pid}} when is_pid(pid)\n assert_received {:stop, %{lexical_tracker: pid}} when is_pid(pid)\n end\n\n test \"traces alias references\" do\n compile_string(\"\"\"\n Foo\n \"\"\")\n\n assert_received {{:alias_reference, meta, Foo}, _}\n assert meta[:line] == 1\n assert meta[:column] == 1\n end\n\n test \"traces aliases\" do\n compile_string(\"\"\"\n alias Hello.World\n World\n\n alias Foo, as: Bar, warn: true\n Bar\n \"\"\")\n\n assert_received {{:alias, meta, Hello.World, World, []}, _}\n assert meta[:line] == 1\n assert meta[:column] == 1\n assert_received {{:alias_expansion, meta, World, Hello.World}, _}\n assert meta[:line] == 2\n assert meta[:column] == 1\n\n assert_received {{:alias, meta, Foo, Bar, [as: Bar, warn: true]}, _}\n assert meta[:line] == 4\n assert meta[:column] == 1\n assert_received {{:alias_expansion, meta, Bar, Foo}, _}\n assert meta[:line] == 5\n assert meta[:column] == 1\n end\n\n test \"traces imports\" do\n compile_string(\"\"\"\n import Integer, only: [is_odd: 1, parse: 1]\n true = is_odd(1)\n {1, \"\"} = parse(\"1\")\n \"\"\")\n\n assert_received {{:import, meta, Integer, only: [is_odd: 1, parse: 1]}, _}\n assert meta[:line] == 1\n assert meta[:column] == 1\n\n assert_received {{:imported_macro, meta, Integer, :is_odd, 1}, _}\n assert meta[:line] == 2\n assert meta[:column] == 8\n\n assert_received {{:imported_function, meta, Integer, :parse, 1}, _}\n assert meta[:line] == 3\n assert meta[:column] == 11\n\n refute_received {{:remote_function, _, Integer, :parse, 1}, _}\n end\n\n test \"traces imports via capture\" do\n compile_string(\"\"\"\n import Integer, only: [is_odd: 1, parse: 1]\n &is_odd/1\n &parse/1\n \"\"\")\n\n assert_received {{:import, meta, Integer, only: [is_odd: 1, parse: 1]}, _}\n assert meta[:line] == 1\n assert meta[:column] == 1\n\n assert_received {{:imported_macro, meta, Integer, :is_odd, 1}, _}\n assert meta[:line] == 2\n assert meta[:column] == 2\n\n assert_received {{:imported_function, meta, Integer, :parse, 1}, _}\n assert meta[:line] == 3\n assert meta[:column] == 2\n\n refute_received {{:remote_function, _meta, Integer, :parse, 1}, _}\n end\n\n test \"traces structs\" do\n compile_string(\"\"\"\n %URI{path: \"/\"}\n \"\"\")\n\n assert_received {{:struct_expansion, meta, URI, [:path]}, _}\n assert meta[:line] == 1\n assert meta[:column] == 1\n end\n\n test \"traces remote\" do\n compile_string(\"\"\"\n require Integer\n true = Integer.is_odd(1)\n {1, \"\"} = Integer.parse(\"1\")\n \"foo\" = Atom.to_string(:foo)\n \"\"\")\n\n assert_received {{:remote_macro, meta, Integer, :is_odd, 1}, _}\n assert meta[:line] == 2\n assert meta[:column] == 16\n\n assert_received {{:remote_function, meta, Integer, :parse, 1}, _}\n assert meta[:line] == 3\n assert meta[:column] == 19\n\n assert_received {{:remote_function, meta, Atom, :to_string, 1}, _}\n assert meta[:line] == 4\n assert meta[:column] == 14\n end\n\n test \"traces remote via captures\" do\n compile_string(\"\"\"\n require Integer\n &Integer.is_odd/1\n &Integer.parse/1\n \"\"\")\n\n assert_received {{:remote_macro, meta, Integer, :is_odd, 1}, _}\n assert meta[:line] == 2\n assert meta[:column] == 10\n\n assert_received {{:remote_function, meta, Integer, :parse, 1}, _}\n assert meta[:line] == 3\n assert meta[:column] == 10\n end\n\n test \"traces locals\" do\n compile_string(\"\"\"\n defmodule Sample do\n defmacro foo(arg), do: arg\n def bar(arg), do: arg\n def baz(arg), do: foo(arg) + bar(arg)\n end\n \"\"\")\n\n assert_received {{:local_macro, meta, :foo, 1}, _}\n assert meta[:line] == 4\n assert meta[:column] == 21\n\n assert_received {{:local_function, meta, :bar, 1}, _}\n assert meta[:line] == 4\n assert meta[:column] == 32\n after\n :code.purge(Sample)\n :code.delete(Sample)\n end\n\n test \"traces locals with capture\" do\n compile_string(\"\"\"\n defmodule Sample do\n defmacro foo(arg), do: arg\n def bar(arg), do: arg\n def baz(_), do: {&foo/1, &bar/1}\n end\n \"\"\")\n\n assert_received {{:local_macro, meta, :foo, 1}, _}\n assert meta[:line] == 4\n assert meta[:column] == 21\n\n assert_received {{:local_function, meta, :bar, 1}, _}\n assert meta[:line] == 4\n assert meta[:column] == 29\n after\n :code.purge(Sample)\n :code.delete(Sample)\n end\n\n test \"traces modules\" do\n compile_string(\"\"\"\n defmodule Sample do\n :ok\n end\n \"\"\")\n\n assert_received {:defmodule, %{module: Sample, function: nil}}\n assert_received {{:on_module, <<_::binary>>, :none}, %{module: Sample, function: nil}}\n after\n :code.purge(Sample)\n :code.delete(Sample)\n end\n\n test \"traces dynamic modules\" do\n compile_string(\"\"\"\n Module.create(Sample, :ok, __ENV__)\n \"\"\")\n\n assert_received {:defmodule, %{module: Sample, function: nil}}\n assert_received {{:on_module, <<_::binary>>, :none}, %{module: Sample, function: nil}}\n after\n :code.purge(Sample)\n :code.delete(Sample)\n end\n\n test \"traces module attribute expansion\" do\n compile_string(\"\"\"\n defmodule TracersModuleAttribute do\n @module URI\n @module\n end\n \"\"\")\n\n assert_received {{:alias_reference, [line: 3], URI}, %{file: \"@module\"}}\n end\n\n test \"traces string interpolation\" do\n compile_string(\"\"\"\n arg = 1 + 2\n \"foo\\#{arg}\"\n \"\"\")\n\n assert_received {{:remote_macro, meta, Kernel, :to_string, 1}, _env}\n assert meta[:from_interpolation]\n end\n\n test \"traces bracket access\" do\n compile_string(\"\"\"\n foo = %{bar: 3}\n foo[:bar]\n \"\"\")\n\n assert_received {{:remote_function, meta, Access, :get, 2}, _env}\n assert meta[:from_brackets]\n\n compile_string(\"\"\"\n defmodule TracerBracketAccess do\n @foo %{bar: 3}\n def a() do\n @foo[:bar]\n end\n end\n \"\"\")\n\n assert_received {{:remote_function, meta, Access, :get, 2}, _env}\n assert meta[:from_brackets]\n\n compile_string(\"\"\"\n %{bar: 3}[:bar]\n \"\"\")\n\n assert_received {{:remote_function, meta, Access, :get, 2}, _env}\n assert meta[:from_brackets]\n end\n\n test \"traces on_load\" do\n compile_string(\"\"\"\n defmodule TracerOnLoad do\n @on_load :init\n def init, do: :ok\n end\n \"\"\")\n\n assert_received {{:local_function, meta, :init, 0}, _}\n assert meta[:line] == 1\n end\n\n def __before_compile__(_), do: :ok\n def __after_compile__(_, _), do: :ok\n def __after_verify__(_), do: :ok\n def __on_definition__(_, _, _, _, _, _), do: :ok\n\n test \"traces compile time attributes\" do\n compile_string(\"\"\"\n defmodule TracerCompileAttributes do\n @before_compile Kernel.TracersTest\n @after_compile Kernel.TracersTest\n @on_definition Kernel.TracersTest\n @after_verify Kernel.TracersTest\n def hello, do: :world\n end\n \"\"\")\n\n assert_received {{:remote_function, meta, __MODULE__, :__before_compile__, 1}, _}\n assert meta[:line] == 1\n\n assert_received {{:remote_function, meta, __MODULE__, :__after_compile__, 2}, _}\n assert meta[:line] == 1\n\n assert_received {{:remote_function, meta, __MODULE__, :__after_verify__, 1}, _}\n assert meta[:line] == 1\n\n assert_received {{:remote_function, meta, __MODULE__, :__on_definition__, 6}, _}\n assert meta[:line] == 6\n end\n\n test \"traces super\" do\n compile_string(\"\"\"\n defmodule TracerOverridable do\n def local(x), do: x\n defoverridable [local: 1]\n def local(x), do: super(x)\n\n defmacro macro(x), do: x\n defoverridable [macro: 1]\n defmacro macro(x), do: super(x)\n\n def capture(x), do: x\n defoverridable [capture: 1]\n def capture(x), do: tap(x, &super/1)\n\n def capture_arg(x), do: x\n defoverridable [capture_arg: 1]\n def capture_arg(x), do: tap(x, &super(&1))\n end\n \"\"\")\n\n assert_received {{:local_function, _, :\"local (overridable 1)\", 1}, _}\n assert_received {{:local_function, _, :\"macro (overridable 1)\", 1}, _}\n assert_received {{:local_function, _, :\"capture (overridable 1)\", 1}, _}\n assert_received {{:local_function, _, :\"capture_arg (overridable 1)\", 1}, _}\n refute_received {{:local_function, _, _, _}, _}\n end\n\n test \"does not trace bind quoted twice\" do\n compile_string(\"\"\"\n quote bind_quoted: [foo: List.flatten([])] do\n foo\n end\n \"\"\")\n\n assert_received {{:remote_function, _, List, :flatten, 1}, _}\n refute_received {{:remote_function, _, List, :flatten, 1}, _}\n end\n\n test \"does not trace captures twice\" do\n compile_string(\"\"\"\n &List.flatten/1\n \"\"\")\n\n assert_received {{:remote_function, _, List, :flatten, 1}, _}\n refute_received {{:remote_function, _, List, :flatten, 1}, _}\n end\n\n \"\"\"\n # Make sure this module is compiled with column information\n defmodule MacroWithColumn do\n defmacro some_macro(list) do\n quote do\n Enum.map(unquote(list), fn str -> String.upcase(str) end)\n end\n end\n end\n \"\"\"\n |> Code.string_to_quoted!(columns: true)\n |> Code.compile_quoted()\n\n test \"traces quoted from macro expansion without column information\" do\n compile_string(\"\"\"\n require MacroWithColumn\n MacroWithColumn.some_macro([\"hello\", \"world\", \"!\"])\n \"\"\")\n\n assert_received {{:alias_reference, meta, Enum}, _env}\n refute meta[:column]\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/warning_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.WarningTest do\n use ExUnit.Case\n import ExUnit.CaptureIO\n\n defp capture_err(fun) when is_function(fun), do: capture_io(:stderr, fun)\n\n defp assert_messages_match(messages, output) when is_list(messages) do\n for message <- messages do\n assert output =~ message\n end\n end\n\n defp assert_warn_eval(messages, source) do\n captured =\n capture_err(fn ->\n quoted = Code.string_to_quoted!(source, columns: true)\n Code.eval_quoted(quoted)\n end)\n\n assert_messages_match(messages, captured)\n end\n\n defp assert_warn_quoted(messages, source) do\n captured =\n capture_err(fn ->\n Code.string_to_quoted!(source, columns: true)\n end)\n\n assert_messages_match(messages, captured)\n end\n\n defp assert_warn_compile(messages, source) do\n captured =\n capture_err(fn ->\n quoted = Code.string_to_quoted!(source, columns: true)\n Code.compile_quoted(quoted)\n end)\n\n assert_messages_match(messages, captured)\n end\n\n defp capture_eval(source) do\n capture_err(fn ->\n quoted = Code.string_to_quoted!(source, columns: true)\n Code.eval_quoted(quoted)\n end)\n end\n\n defp capture_compile(source) do\n capture_err(fn ->\n quoted = Code.string_to_quoted!(source, columns: true)\n Code.compile_quoted(quoted)\n end)\n end\n\n defmacro will_warn do\n quote file: \"demo\", line: true do\n %{dup: 1, dup: 2}\n end\n end\n\n test \"warnings from macro\" do\n assert_warn_eval(\n [\"demo:64\\n\", \"key :dup will be overridden in map\\n\"],\n \"\"\"\n import Kernel.WarningTest\n will_warn()\n \"\"\"\n )\n end\n\n test \"outdented heredoc\" do\n assert_warn_eval(\n [\"nofile:2:3\", \"outdented heredoc line\"],\n \"\"\"\n '''\n outdented\n '''\n \"\"\"\n )\n end\n\n test \"does not warn on incomplete tokenization\" do\n assert {:error, _} = Code.string_to_quoted(~s[:\"foobar\" do])\n end\n\n describe \"unicode identifier security\" do\n test \"warns on confusables\" do\n assert_warn_quoted(\n [\"nofile:1:6\", \"confusable identifier: 'a' looks like 'а' on line 1\"],\n \"а=1; a=1\"\n )\n\n assert_warn_quoted(\n [\"nofile:1:12\", \"confusable identifier: 'a' looks like 'а' on line 1\"],\n \"[{:а, 1}, {:a, 1}]\"\n )\n\n assert_warn_quoted(\n [\"nofile:1:8\", \"confusable identifier: 'a' looks like 'а' on line 1\"],\n \"[а: 1, a: 1]\"\n )\n\n assert_warn_quoted(\n [\"nofile:1:18\", \"confusable identifier: 'a' looks like 'а' on line 1\"],\n \"quote do: [а(1), a(1)]\"\n )\n\n assert_warn_quoted(\n [\"nofile:1:6\", \"confusable identifier: 'カ' looks like '力' on line 1\"],\n \"力=1; カ=1\"\n )\n\n # by convention, doesn't warn on ascii-only confusables\n assert capture_eval(\"x0 = xO = 1\") == \"\"\n assert capture_eval(\"l1 = ll = 1\") == \"\"\n\n # works with a custom atom encoder\n assert capture_err(fn ->\n Code.string_to_quoted(\"[{:а, 1}, {:a, 1}]\",\n static_atoms_encoder: fn token, _ -> {:ok, {:wrapped, token}} end\n )\n end) =~\n \"confusable identifier: 'a' looks like 'а' on line 1\"\n end\n\n test \"warns on LTR-confusables\" do\n # warning outputs in byte order (vs bidi algo display order, uax9), mentions presence of rtl\n assert_warn_quoted(\n [\"nofile:1:9\", \"'_1א' looks like '_א1'\", \"right-to-left characters\"],\n \"_א1 and _1א\"\n )\n\n assert_warn_quoted(\n [\n \"'a_1א' includes right-to-left characters\",\n \"\\\\u0061 a ltr\",\n \"\\\\u005F _ neutral\",\n \"\\\\u0031 1 weak_number\",\n \"\\\\u05D0 א rtl\",\n \"'a_א1' includes right-to-left characters:\",\n \"\\\\u0061 a ltr\",\n \"\\\\u005F _ neutral\",\n \"\\\\u05D0 א rtl\",\n \"\\\\u0031 1 weak_number\"\n ],\n \"a_א1 or a_1א\"\n )\n end\n end\n\n test \"operators formed by many of the same character followed by that character\" do\n assert_warn_eval(\n [\n \"nofile:1:12\",\n \"found \\\"+++\\\" followed by \\\"+\\\", please use a space between \\\"+++\\\" and the next \\\"+\\\"\"\n ],\n \"quote do: 1++++1\"\n )\n end\n\n test \"identifier that ends in ! followed by the = operator without a space in between\" do\n assert_warn_eval(\n [\"nofile:1:1\", \"found identifier \\\"foo!\\\", ending with \\\"!\\\"\"],\n \"foo!= 1\"\n )\n\n assert_warn_eval(\n [\"nofile:1:1\", \"found atom \\\":foo!\\\", ending with \\\"!\\\"\"],\n \":foo!= :foo!\"\n )\n end\n\n describe \"unnecessary quotes\" do\n test \"does not warn of unnecessary quotes in uppercase atoms/keywords\" do\n assert capture_eval(~s/:\"Foo\"/) == \"\"\n assert capture_eval(~s/[\"Foo\": :bar]/) == \"\"\n assert capture_eval(~s/:\"Foo\"/) == \"\"\n assert capture_eval(~s/:\"foo@bar\"/) == \"\"\n assert capture_eval(~s/:\"héllò\"/) == \"\"\n assert capture_eval(~s/:\"3L1X1R\"/) == \"\"\n end\n\n test \"warns of unnecessary quotes\" do\n assert_warn_eval(\n [\"nofile:1:1\", \"found quoted atom \\\"foo\\\" but the quotes are not required\"],\n ~s/:\"foo\"/\n )\n\n assert_warn_eval(\n [\"nofile:1:2\", \"found quoted keyword \\\"foo\\\" but the quotes are not required\"],\n ~s/[\"foo\": :bar]/\n )\n\n assert_warn_eval(\n [\"nofile:1:9\", \"found quoted call \\\"length\\\" but the quotes are not required\"],\n ~s/[Kernel.\"length\"([])]/\n )\n end\n end\n\n describe \"deprecated single quotes in atoms\" do\n test \"warns of single quotes in atoms\" do\n assert_warn_eval(\n [\n \"nofile:1:1\",\n \"single quotes around atoms are deprecated. Use double quotes instead\"\n ],\n ~s/:'a+b'/\n )\n end\n\n test \"warns twice of single and unnecessary atom quotes\" do\n assert_warn_eval(\n [\n \"nofile:1:1\",\n \"single quotes around atoms are deprecated. Use double quotes instead\",\n \"nofile:1:1\",\n \"found quoted atom \\\"ab\\\" but the quotes are not required\"\n ],\n ~s/:'ab'/\n )\n end\n\n test \"warns twice of single and unnecessary call quotes\" do\n assert_warn_eval(\n [\n \"nofile:1:9\",\n \"single quotes around calls are deprecated. Use double quotes instead\",\n \"nofile:1:9\",\n \"found quoted call \\\"length\\\" but the quotes are not required\"\n ],\n ~s/[Kernel.'length'([])]/\n )\n end\n end\n\n test \"warns on :: as atom\" do\n assert_warn_eval(\n [\n \"nofile:1:1\",\n \"atom ::: must be written between quotes, as in :\\\"::\\\", to avoid ambiguity\"\n ],\n ~s/:::/\n )\n end\n\n test \"unused variable\" do\n # Note we use compile_string because eval_string does not emit unused vars warning\n assert_warn_compile(\n [\n \"nofile:2:3\",\n \"variable \\\"module\\\" is unused\",\n \"nofile:3:13\",\n \"variable \\\"arg\\\" is unused\",\n \"nofile:5:1\",\n \"variable \\\"file\\\" is unused\"\n ],\n \"\"\"\n defmodule Sample do\n module = 1\n def hello(arg), do: nil\n end\n file = 2\n file = 3\n file\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused variable that could be pinned\" do\n # Note we use compile_string because eval_string does not emit unused vars warning\n assert_warn_compile(\n [\n \"nofile:4:12\",\n \"variable \\\"compare_local\\\" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)\",\n \"nofile:8:7\",\n \"variable \\\"compare_nested\\\" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)\"\n ],\n \"\"\"\n defmodule Sample do\n def test do\n compare_local = \"hello\"\n match?(compare_local, \"hello\")\n\n compare_nested = \"hello\"\n case \"hello\" do\n compare_nested -> true\n _other -> false\n end\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"duplicate pattern\" do\n output =\n capture_eval(\"\"\"\n defmodule Sample do\n var = quote(do: x)\n def hello(unquote(var) = unquote(var)), do: unquote(var)\n end\n \"\"\")\n\n assert output =~ \"this pattern is matched against itself inside a match: x = x\"\n after\n purge(Sample)\n end\n\n test \"unused compiler variable\" do\n output =\n capture_eval(\"\"\"\n defmodule Sample do\n def hello(__MODULE___), do: :ok\n def world(_R), do: :ok\n end\n \"\"\")\n\n assert output =~ \"unknown compiler variable \\\"__MODULE___\\\"\"\n assert output =~ \"nofile:2:13\"\n refute output =~ \"unknown compiler variable \\\"_R\\\"\"\n after\n purge(Sample)\n end\n\n test \"nested unused variable\" do\n messages = [\"undefined variable \\\"x\\\"\", \"variable \\\"x\\\" is unused\"]\n\n assert_compile_error(\n [\"nofile:5:1\", \"nofile:2:11\" | messages],\n \"\"\"\n case false do\n true -> x = 1\n _ -> 1\n end\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:1:12\", \"nofile:2:1\" | messages],\n \"\"\"\n false and (x = 1)\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:1:10\", \"nofile:2:1\" | messages],\n \"\"\"\n true or (x = 1)\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:2:3\", \"nofile:4:1\" | messages],\n \"\"\"\n if false do\n x = 1\n end\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:2:12\", \"nofile:5:1\" | messages],\n \"\"\"\n cond do\n false -> x = 1\n true -> 1\n end\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:2:11\", \"nofile:6:1\" | messages],\n \"\"\"\n receive do\n :foo -> x = 1\n after\n 0 -> 1\n end\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:1:11\", \"nofile:2:1\" | messages],\n \"\"\"\n false && (x = 1)\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:1:10\", \"nofile:2:1\" | messages],\n \"\"\"\n true || (x = 1)\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:2:3\", \"nofile:4:1\" | messages],\n \"\"\"\n with true <- true do\n x = false\n end\n x\n \"\"\"\n )\n\n assert_compile_error(\n [\"nofile:2:3\", \"nofile:4:1\" | messages],\n \"\"\"\n fn ->\n x = true\n end\n x\n \"\"\"\n )\n end\n\n test \"unused variable in redefined function in different file\" do\n output =\n capture_err(fn ->\n Code.eval_string(\"\"\"\n defmodule Sample do\n defmacro __using__(_) do\n quote location: :keep do\n def function(arg)\n end\n end\n end\n \"\"\")\n\n code = \"\"\"\n defmodule RedefineSample do\n use Sample\n def function(var123), do: nil\n end\n \"\"\"\n\n Code.eval_string(code, [], file: \"redefine_sample.ex\")\n end)\n\n assert output =~ \"redefine_sample.ex:3: \"\n assert output =~ \"variable \\\"var123\\\" is unused\"\n after\n purge(Sample)\n purge(RedefineSample)\n end\n\n test \"unused variable because re-declared in a match? pattern\" do\n assert_warn_eval(\n [\n \"nofile:1:16\",\n \"variable \\\"x\\\" is unused (there is a variable with the same name in the context,\",\n \"variable \\\"x\\\" is unused (if the variable is not meant to be used,\"\n ],\n \"\"\"\n fn x -> match?(x, :value) end\n \"\"\"\n )\n end\n\n test \"useless literal\" do\n message = \"code block contains unused literal \\\"oops\\\"\"\n\n assert_warn_eval(\n [\"nofile:1\\n\", message],\n \"\"\"\n \"oops\"\n :ok\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:1\\n\", message],\n \"\"\"\n fn ->\n \"oops\"\n :ok\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:1:5\\n\", message],\n \"\"\"\n try do\n \"oops\"\n :ok\n after\n :ok\n end\n \"\"\"\n )\n end\n\n test \"useless attr\" do\n assert_warn_eval(\n [\n \"nofile:4:3\",\n \"module attribute @foo in code block has no effect as it is never returned \",\n \"nofile:7:5\",\n \"module attribute @bar in code block has no effect as it is never returned \"\n ],\n \"\"\"\n defmodule Sample do\n @foo 1\n @bar 1\n @foo\n\n def bar do\n @bar\n :ok\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"useless var\" do\n message = \"variable foo in code block has no effect as it is never returned \"\n\n assert_warn_eval(\n [\"nofile:2:1\", message],\n \"\"\"\n foo = 1\n foo\n :ok\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:3:3\", message],\n \"\"\"\n fn ->\n foo = 1\n foo\n :ok\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:3:3\", message],\n \"\"\"\n try do\n foo = 1\n foo\n :ok\n after\n :ok\n end\n \"\"\"\n )\n\n assert capture_eval(\"\"\"\n node()\n :ok\n \"\"\") == \"\"\n end\n\n test \"underscored variable on match\" do\n assert_warn_eval(\n [\"nofile:1:8\", \"the underscored variable \\\"_arg\\\" appears more than once in a match\"],\n \"\"\"\n {_arg, _arg} = {1, 1}\n \"\"\"\n )\n end\n\n test \"underscored variable on use\" do\n assert_warn_eval(\n [\"nofile:1:12\", \"the underscored variable \\\"_var\\\" is used after being set\"],\n \"\"\"\n fn _var -> _var + 1 end\n \"\"\"\n )\n\n assert capture_eval(\"\"\"\n fn var!(_var, Foo) -> var!(_var, Foo) + 1 end\n \"\"\") == \"\"\n end\n\n test \"unused function\" do\n assert_warn_eval(\n [\"nofile:2:8: \", \"function hello/0 is unused\\n\"],\n \"\"\"\n defmodule Sample1 do\n defp hello, do: nil\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:2:8: \", \"function hello/1 is unused\\n\"],\n \"\"\"\n defmodule Sample2 do\n defp hello(0), do: hello(1)\n defp hello(1), do: :ok\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:4:8: \", \"function c/2 is unused\\n\"],\n ~S\"\"\"\n defmodule Sample3 do\n def a, do: nil\n def b, do: d(10)\n defp c(x, y \\\\ 1), do: [x, y]\n defp d(x), do: x\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:3:8: \", \"function b/2 is unused\\n\"],\n ~S\"\"\"\n defmodule Sample4 do\n def a, do: nil\n defp b(x \\\\ 1, y \\\\ 1)\n defp b(x, y), do: [x, y]\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:3:8: \", \"function b/0 is unused\\n\"],\n ~S\"\"\"\n defmodule Sample5 do\n def a, do: nil\n defp b(), do: unquote(1)\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2, Sample3, Sample4, Sample5])\n end\n\n test \"unused cyclic functions\" do\n assert_warn_eval(\n [\n \"nofile:2:8: \",\n \"function a/0 is unused\\n\",\n \"nofile:3:8: \",\n \"function b/0 is unused\\n\"\n ],\n \"\"\"\n defmodule Sample do\n defp a, do: b()\n defp b, do: a()\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused macro\" do\n assert_warn_eval(\n [\"nofile:2:13: \", \"macro hello/0 is unused\"],\n \"\"\"\n defmodule Sample do\n defmacrop hello, do: nil\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:2:13: \", \"macro hello/0 is unused\\n\"],\n ~S\"\"\"\n defmodule Sample2 do\n defmacrop hello do\n quote do: unquote(1)\n end\n end\n \"\"\"\n )\n after\n purge([Sample, Sample2])\n end\n\n test \"shadowing\" do\n assert capture_eval(\"\"\"\n defmodule Sample do\n def test(x) do\n case x do\n {:file, fid} -> fid\n {:path, _} -> fn(fid) -> fid end\n end\n end\n end\n \"\"\") == \"\"\n after\n purge(Sample)\n end\n\n test \"unused default args\" do\n assert_warn_eval(\n [\n \"nofile:3:8: \",\n \"default values for the optional arguments in the private function b/3 are never used\"\n ],\n ~S\"\"\"\n defmodule Sample1 do\n def a, do: b(1, 2, 3)\n defp b(arg1 \\\\ 1, arg2 \\\\ 2, arg3 \\\\ 3), do: [arg1, arg2, arg3]\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\n \"nofile:3:8: \",\n \"the default value for the last optional argument in the private function b/3 is never used\"\n ],\n ~S\"\"\"\n defmodule Sample2 do\n def a, do: b(1, 2)\n defp b(arg1 \\\\ 1, arg2 \\\\ 2, arg3 \\\\ 3), do: [arg1, arg2, arg3]\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\n \"nofile:3:8: \",\n \"the default values for the last 2 optional arguments in the private function b/4 are never used\"\n ],\n ~S\"\"\"\n defmodule Sample3 do\n def a, do: b(1, 2)\n defp b(arg1, arg2 \\\\ 2, arg3 \\\\ 3, arg4 \\\\ 4), do: [arg1, arg2, arg3, arg4]\n end\n \"\"\"\n )\n\n assert capture_eval(~S\"\"\"\n defmodule Sample4 do\n def a, do: b(1)\n defp b(arg1 \\\\ 1, arg2, arg3 \\\\ 3), do: [arg1, arg2, arg3]\n end\n \"\"\") == \"\"\n\n assert_warn_eval(\n [\n \"nofile:3:8: \",\n \"the default value for the last optional argument in the private function b/3 is never used\"\n ],\n ~S\"\"\"\n defmodule Sample5 do\n def a, do: b(1, 2)\n defp b(arg1 \\\\ 1, arg2 \\\\ 2, arg3 \\\\ 3)\n\n defp b(arg1, arg2, arg3), do: [arg1, arg2, arg3]\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2, Sample3, Sample4, Sample5])\n end\n\n test \"unused import\" do\n assert_warn_compile(\n [\"nofile:2:3\", \"unused import :lists\"],\n \"\"\"\n defmodule Sample do\n import :lists\n def a, do: nil\n end\n \"\"\"\n )\n\n assert_warn_compile(\n [\"nofile:1:1\", \"unused import :lists\"],\n \"\"\"\n import :lists\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unknown import\" do\n assert_warn_compile(\n [\"nofile:1:1\", \"cannot import Kernel.invalid/1 because it is undefined or private\"],\n \"\"\"\n import(Kernel, only: [invalid: 1])\n \"\"\"\n )\n end\n\n test \"conditional import\" do\n assert capture_err(fn ->\n defmodule KernelTest.ConditionalImport do\n if false do\n import Map, only: [new: 0]\n def fun, do: new()\n end\n end\n end) == \"\"\n after\n purge(Sample)\n end\n\n test \"unused import of one of the functions in :only\" do\n assert_warn_compile(\n [\n \"nofile:2:3\",\n \"unused import String.downcase/1\",\n \"nofile:2:3\",\n \"unused import String.trim/1\"\n ],\n \"\"\"\n defmodule Sample do\n import String, only: [upcase: 1, downcase: 1, trim: 1]\n def a, do: upcase(\"hello\")\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused import of any of the functions in :only\" do\n assert_warn_compile(\n [\"nofile:1:1\", \"unused import String\"],\n \"\"\"\n import String, only: [upcase: 1, downcase: 1]\n \"\"\"\n )\n end\n\n test \"unused import inside dynamic module\" do\n import List, only: [flatten: 1], warn: false\n\n assert capture_err(fn ->\n defmodule Sample do\n import String, only: [downcase: 1]\n\n def world do\n flatten([1, 2, 3])\n end\n end\n end) =~ \"unused import String\"\n after\n purge(Sample)\n end\n\n def with(a, b, c), do: [a, b, c]\n\n test \"import matches special form\" do\n assert_warn_compile(\n [\n \"nofile:1:1\",\n \"cannot import Kernel.WarningTest.with/3 because it conflicts with Elixir special forms\"\n ],\n \"\"\"\n import Kernel.WarningTest, only: [with: 3]\n :ok = with true <- true, true <- true, do: :ok\n \"\"\"\n )\n end\n\n test \"duplicated function on import options\" do\n assert_warn_compile(\n [\"nofile:2:3\", \"invalid :only option for import, wrap/1 is duplicated\"],\n \"\"\"\n defmodule Kernel.WarningsTest.DuplicatedFunctionOnImportOnly do\n import List, only: [wrap: 1, keyfind: 3, wrap: 1]\n end\n \"\"\"\n )\n\n assert_warn_compile(\n [\"nofile:2:3\", \"invalid :except option for import, wrap/1 is duplicated\"],\n \"\"\"\n defmodule Kernel.WarningsTest.DuplicatedFunctionOnImportExcept do\n import List, except: [wrap: 1, keyfind: 3, wrap: 1]\n end\n \"\"\"\n )\n end\n\n test \"conditional alias\" do\n assert capture_err(fn ->\n defmodule KernelTest.ConditionaAlias do\n if false do\n alias Map, as: M\n def fun, do: M.new()\n end\n end\n end) == \"\"\n end\n\n test \"unused alias\" do\n assert_warn_compile(\n [\"nofile:2:3\", \"unused alias List\"],\n \"\"\"\n defmodule Sample do\n alias :lists, as: List\n def a, do: nil\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused alias when also import\" do\n assert_warn_compile(\n [\"nofile:2:3\", \"unused alias List\"],\n \"\"\"\n defmodule Sample do\n alias :lists, as: List\n import MapSet\n new()\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"duplicate map keys\" do\n assert_warn_eval(\n [\n \"key :a will be overridden in map\",\n \"nofile:4:10\\n\",\n \"key :m will be overridden in map\",\n \"nofile:5:10\\n\",\n \"key 1 will be overridden in map\",\n \"nofile:6:10\\n\"\n ],\n \"\"\"\n defmodule DuplicateMapKeys do\n import ExUnit.Assertions\n\n assert %{a: :b, a: :c} == %{a: :c}\n assert %{m: :n, m: :o, m: :p} == %{m: :p}\n assert %{1 => 2, 1 => 3} == %{1 => 3}\n end\n \"\"\"\n )\n\n assert map_size(%{System.unique_integer() => 1, System.unique_integer() => 2}) == 2\n end\n\n test \"length(list) == 0 in guard\" do\n assert_warn_eval(\n [\n \"nofile:5:24\",\n \"do not use \\\"length(v) == 0\\\" to check if a list is empty\",\n \"Prefer to pattern match on an empty list or use \\\"v == []\\\" as a guard\"\n ],\n \"\"\"\n defmodule Sample do\n def list_case do\n v = []\n case v do\n _ when length(v) == 0 -> :ok\n _ -> :fail\n end\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"length(list) > 0 in guard\" do\n assert_warn_eval(\n [\n \"nofile:5:24\",\n \"do not use \\\"length(v) > 0\\\" to check if a list is not empty\",\n \"Prefer to pattern match on a non-empty list, such as [_ | _], or use \\\"v != []\\\" as a guard\"\n ],\n \"\"\"\n defmodule Sample do\n def list_case do\n v = []\n case v do\n _ when length(v) > 0 -> :ok\n _ -> :fail\n end\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"late function heads\" do\n assert_warn_eval(\n [\n \"nofile:4:7\\n\",\n \"function head for def add/2 must come at the top of its direct implementation\"\n ],\n \"\"\"\n defmodule Sample do\n def add(a, b), do: a + b\n @doc \"hello\"\n def add(a, b)\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"late function heads do not warn of meta programming\" do\n assert capture_eval(\"\"\"\n defmodule Sample1 do\n defmacro __using__(_) do\n quote do\n def add(a, b), do: a + b\n end\n end\n end\n\n defmodule Sample2 do\n use Sample1\n @doc \"hello\"\n def add(a, b)\n end\n \"\"\") == \"\"\n\n assert capture_eval(\"\"\"\n defmodule Sample3 do\n for fun <- [:foo, :bar] do\n def unquote(fun)(), do: unquote(fun)\n end\n\n def foo()\n def bar()\n end\n \"\"\") == \"\"\n after\n purge([Sample1, Sample2, Sample3])\n end\n\n test \"used import via alias\" do\n assert capture_eval(\"\"\"\n defmodule Sample1 do\n import List, only: [flatten: 1]\n\n defmacro generate do\n List.duplicate(quote(do: flatten([1, 2, 3])), 100)\n end\n end\n\n defmodule Sample2 do\n import Sample1\n generate()\n end\n \"\"\") == \"\"\n after\n purge([Sample1, Sample2])\n end\n\n test \"clause not match\" do\n assert_warn_eval(\n [\n \"nofile:3:7\\n\",\n ~r\"this clause( for hello/0)? cannot match because a previous clause at line 2 always matches\"\n ],\n \"\"\"\n defmodule Sample do\n def hello, do: nil\n def hello, do: nil\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"generated clause not match\" do\n assert_warn_eval(\n [\n \"nofile:10\\n\",\n ~r\"this clause( for hello/0)? cannot match because a previous clause at line 10 always matches\"\n ],\n \"\"\"\n defmodule Sample do\n defmacro __using__(_) do\n quote do\n def hello, do: nil\n def hello, do: nil\n end\n end\n end\n defmodule UseSample do\n use Sample\n end\n \"\"\"\n )\n after\n purge(Sample)\n purge(UseSample)\n end\n\n test \"deprecated closing sigil delimiter\" do\n assert_warn_eval([\"nofile:1:7\", \"deprecated\"], \"~S(foo\\\\))\")\n end\n\n test \"deprecated not left in right\" do\n assert_warn_eval([\"nofile:1:7\", \"deprecated\"], \"not 1 in [1, 2, 3]\")\n end\n\n test \"clause with defaults should be first\" do\n message = \"def hello/1 has multiple clauses and also declares default values\"\n\n assert_warn_eval(\n [\"nofile:3:7\\n\", message, \"the previous clause is defined on line 2\"],\n ~S\"\"\"\n defmodule Sample1 do\n def hello(arg), do: arg\n def hello(arg \\\\ 0), do: arg\n end\n \"\"\"\n )\n\n assert_warn_eval(\n [\"nofile:3:7\\n\", message, \"the previous clause is defined on line 2\"],\n ~S\"\"\"\n defmodule Sample2 do\n def hello(_arg)\n def hello(arg \\\\ 0), do: arg\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2])\n end\n\n test \"clauses with default should use header\" do\n assert_warn_eval(\n [\n \"nofile:3:7\\n\",\n \"def hello/1 has multiple clauses and also declares default values\",\n \"the previous clause is defined on line 2\"\n ],\n ~S\"\"\"\n defmodule Sample do\n def hello(arg \\\\ 0), do: arg\n def hello(arg), do: arg\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused with local with overridable\" do\n assert_warn_eval(\n [\"nofile:3:8: \", \"function world/0 is unused\"],\n \"\"\"\n defmodule Sample do\n def hello, do: world()\n defp world, do: :ok\n defoverridable [hello: 0]\n def hello, do: :ok\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"undefined module attribute\" do\n assert_warn_eval(\n [\n \"nofile:2: \",\n \"undefined module attribute @foo, please remove access to @foo or explicitly set it before access\"\n ],\n \"\"\"\n defmodule Sample do\n @foo\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"parens with module attribute\" do\n assert_warn_eval(\n [\n \"nofile:3: \",\n \"the @foo() notation (with parentheses) is deprecated, please use @foo (without parentheses) instead\"\n ],\n \"\"\"\n defmodule Sample do\n @foo 13\n @foo()\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"undefined module attribute in function\" do\n assert_warn_eval(\n [\n \"nofile:3: \",\n \"undefined module attribute @foo, please remove access to @foo or explicitly set it before access\"\n ],\n \"\"\"\n defmodule Sample do\n def hello do\n @foo\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"undefined module attribute with file\" do\n assert_warn_eval(\n [\n \"nofile:2: \",\n \"undefined module attribute @foo, please remove access to @foo or explicitly set it before access\"\n ],\n \"\"\"\n defmodule Sample do\n @foo\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"parse transform\" do\n assert_warn_eval(\n [\"nofile:1: \", \"@compile {:parse_transform, :ms_transform} is deprecated\"],\n \"\"\"\n defmodule Sample do\n @compile {:parse_transform, :ms_transform}\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"@compile inline no warning for unreachable function\" do\n refute capture_eval(\"\"\"\n defmodule Sample do\n @compile {:inline, foo: 1}\n\n defp foo(_), do: :ok\n end\n \"\"\") =~ \"inlined function foo/1 undefined\"\n after\n purge(Sample)\n end\n\n test \"no effect operator\" do\n assert_warn_eval(\n [\"nofile:3:7\\n\", \"use of operator != has no effect\"],\n \"\"\"\n defmodule Sample do\n def a(x) do\n x != :foo\n :ok\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"undefined function for behaviour\" do\n assert_warn_eval(\n [\n \"nofile:5: \",\n \"function foo/0 required by behaviour Sample1 is not implemented (in module Sample2)\"\n ],\n \"\"\"\n defmodule Sample1 do\n @callback foo :: term\n end\n\n defmodule Sample2 do\n @behaviour Sample1\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2])\n end\n\n test \"undefined macro for behaviour\" do\n assert_warn_eval(\n [\n \"nofile:5: \",\n \"macro foo/0 required by behaviour Sample1 is not implemented (in module Sample2)\"\n ],\n \"\"\"\n defmodule Sample1 do\n @macrocallback foo :: Macro.t\n end\n\n defmodule Sample2 do\n @behaviour Sample1\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2])\n end\n\n test \"wrong kind for behaviour\" do\n assert_warn_eval(\n [\n \"nofile:5: \",\n \"function foo/0 required by behaviour Sample1 was implemented as \\\"defmacro\\\" but should have been \\\"def\\\"\"\n ],\n \"\"\"\n defmodule Sample1 do\n @callback foo :: term\n end\n\n defmodule Sample2 do\n @behaviour Sample1\n defmacro foo, do: :ok\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2])\n end\n\n test \"conflicting behaviour\" do\n assert_warn_eval(\n [\n \"nofile:9: \",\n \"conflicting behaviours found. Callback function foo/0 is defined by both Sample1 and Sample2 (in module Sample3)\"\n ],\n \"\"\"\n defmodule Sample1 do\n @callback foo :: term\n end\n\n defmodule Sample2 do\n @callback foo :: term\n end\n\n defmodule Sample3 do\n @behaviour Sample1\n @behaviour Sample2\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2, Sample3])\n end\n\n test \"conflicting behaviour (but one optional callback)\" do\n message =\n capture_compile(\"\"\"\n defmodule Sample1 do\n @callback foo :: term\n end\n\n defmodule Sample2 do\n @callback foo :: term\n @callback bar :: term\n @optional_callbacks foo: 0\n end\n\n defmodule Sample3 do\n @behaviour Sample1\n @behaviour Sample2\n\n @impl Sample1\n def foo, do: 1\n @impl Sample2\n def bar, do: 2\n end\n \"\"\")\n\n assert message =~\n \"conflicting behaviours found. Callback function foo/0 is defined by both Sample1 and Sample2 (in module Sample3)\"\n\n refute message =~ \"module attribute @impl was not set\"\n refute message =~ \"this behaviour does not specify such callback\"\n after\n purge([Sample1, Sample2, Sample3])\n end\n\n test \"duplicate behaviour\" do\n assert_warn_eval(\n [\n \"nofile:5: \",\n \"the behaviour Sample1 has been declared twice (conflict in function foo/0 in module Sample2)\"\n ],\n \"\"\"\n defmodule Sample1 do\n @callback foo :: term\n end\n\n defmodule Sample2 do\n @behaviour Sample1\n @behaviour Sample1\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2])\n end\n\n test \"unknown remote call\" do\n assert capture_compile(\"\"\"\n defmodule Sample do\n def perform(), do: Unknown.call()\n end\n \"\"\") =~\n \"Unknown.call/0 is undefined (module Unknown is not available or is yet to be defined)\"\n after\n purge(Sample)\n end\n\n test \"undefined behaviour\" do\n assert_warn_eval(\n [\"nofile:1: \", \"@behaviour UndefinedBehaviour does not exist (in module Sample)\"],\n \"\"\"\n defmodule Sample do\n @behaviour UndefinedBehaviour\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"empty behaviours\" do\n assert_warn_eval(\n [\"nofile:3: \", \"module EmptyBehaviour is not a behaviour (in module Sample)\"],\n \"\"\"\n defmodule EmptyBehaviour do\n end\n defmodule Sample do\n @behaviour EmptyBehaviour\n end\n \"\"\"\n )\n after\n purge(Sample)\n purge(EmptyBehaviour)\n end\n\n test \"undefined function for protocol\" do\n assert_warn_eval(\n [\n \"nofile:5: \",\n \"function foo/1 required by protocol Sample1 is not implemented (in module Sample1.Atom)\"\n ],\n \"\"\"\n defprotocol Sample1 do\n def foo(subject)\n end\n\n defimpl Sample1, for: Atom do\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample1.Atom])\n end\n\n test \"ungrouped def name\" do\n assert_warn_eval(\n [\n \"nofile:4:7\\n\",\n \"clauses with the same name should be grouped together, \\\"def foo/2\\\" was previously defined (nofile:2)\"\n ],\n \"\"\"\n defmodule Sample do\n def foo(x, 1), do: x + 1\n def foo(), do: nil\n def foo(x, 2), do: x * 2\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"ungrouped def name and arity\" do\n assert_warn_eval(\n [\n \"nofile:4:7\\n\",\n \"clauses with the same name and arity (number of arguments) should be grouped together, \\\"def foo/2\\\" was previously defined (nofile:2)\"\n ],\n \"\"\"\n defmodule Sample do\n def foo(x, 1), do: x + 1\n def bar(), do: nil\n def foo(x, 2), do: x * 2\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"ungrouped defs do not warn of meta programming\" do\n assert capture_eval(\"\"\"\n defmodule Sample do\n for atom <- [:foo, :bar] do\n def from_string(unquote(to_string(atom))), do: unquote(atom)\n def to_string(unquote(atom)), do: unquote(to_string(atom))\n end\n end\n \"\"\") == \"\"\n after\n purge(Sample)\n end\n\n test \"warning with overridden file\" do\n assert_warn_eval(\n [\"sample:3:11:\", \"variable \\\"x\\\" is unused\"],\n \"\"\"\n defmodule Sample do\n @file \"sample\"\n def foo(x), do: :ok\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"warning on unnecessary code point escape\" do\n assert capture_eval(\"?\\\\n + ?\\\\\\\\\") == \"\"\n\n assert_warn_eval(\n [\"nofile:1:1\", \"unknown escape sequence ?\\\\w, use ?w instead\"],\n \"?\\\\w\"\n )\n end\n\n test \"warning on code point escape\" do\n assert_warn_eval(\n [\"nofile:1:1\", \"found ? followed by code point 0x20 (space), please use ?\\\\s instead\"],\n \"? \"\n )\n\n assert_warn_eval(\n [\"nofile:1:1\", \"found ?\\\\ followed by code point 0x20 (space), please use ?\\\\s instead\"],\n \"?\\\\ \"\n )\n end\n\n test \"duplicated docs in the same clause\" do\n output =\n capture_eval(\"\"\"\n defmodule Sample do\n @doc \"Something\"\n @doc \"Another\"\n def foo, do: :ok\n end\n \"\"\")\n\n assert output =~ \"redefining @doc attribute previously set at line 2\"\n assert output =~ \"nofile:3: Sample (module)\"\n after\n purge(Sample)\n end\n\n test \"duplicate docs across clauses\" do\n assert capture_eval(\"\"\"\n defmodule Sample1 do\n defmacro __using__(_) do\n quote do\n @doc \"hello\"\n def add(a, 1), do: a + 1\n end\n end\n end\n\n defmodule Sample2 do\n use Sample1\n @doc \"world\"\n def add(a, 2), do: a + 2\n end\n \"\"\") == \"\"\n\n assert_warn_eval(\n [\"nofile:4: \", \"redefining @doc attribute previously set at line\"],\n \"\"\"\n defmodule Sample3 do\n @doc \"hello\"\n def add(a, 1), do: a + 1\n @doc \"world\"\n def add(a, 2), do: a + 2\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2, Sample3])\n end\n\n test \"reserved doc metadata keys\" do\n {output, diagnostics} =\n Code.with_diagnostics([log: true], fn ->\n capture_eval(\"\"\"\n defmodule Sample do\n @typedoc opaque: false\n @type t :: binary\n\n @doc defaults: 3, since: \"1.2.3\"\n def foo(a), do: a\n end\n \"\"\")\n end)\n\n assert output =~ \"ignoring reserved documentation metadata key: :opaque\"\n assert output =~ \"nofile:2: \"\n assert output =~ \"ignoring reserved documentation metadata key: :defaults\"\n assert output =~ \"nofile:5: \"\n refute output =~ \":since\"\n\n assert [\n %{\n message: \"ignoring reserved documentation metadata key: :opaque\",\n position: 2,\n file: \"nofile\",\n severity: :warning\n },\n %{\n message: \"ignoring reserved documentation metadata key: :defaults\",\n position: 5,\n file: \"nofile\",\n severity: :warning\n }\n ] = diagnostics\n after\n purge(Sample)\n end\n\n describe \"typespecs\" do\n test \"unused types\" do\n output =\n capture_eval(\"\"\"\n defmodule Sample do\n @type pub :: any\n @opaque op :: any\n @typep priv :: any\n @typep priv_args(var1, var2) :: {var1, var2}\n @typep priv2 :: any\n @typep priv3 :: priv2 | atom\n\n @spec my_fun(priv3) :: pub\n def my_fun(var), do: var\n end\n \"\"\")\n\n assert output =~ \"nofile:4: \"\n assert output =~ \"type priv/0 is unused\"\n assert output =~ \"nofile:5: \"\n assert output =~ \"type priv_args/2 is unused\"\n refute output =~ \"type pub/0 is unused\"\n refute output =~ \"type op/0 is unused\"\n refute output =~ \"type priv2/0 is unused\"\n refute output =~ \"type priv3/0 is unused\"\n after\n purge(Sample)\n end\n\n test \"underspecified opaque types\" do\n output =\n capture_eval(\"\"\"\n defmodule Sample do\n @opaque op1 :: term\n @opaque op2 :: any\n @opaque op3 :: atom\n end\n \"\"\")\n\n assert output =~ \"nofile:2: \"\n assert output =~ \"@opaque type op1/0 is underspecified and therefore meaningless\"\n assert output =~ \"nofile:3: \"\n assert output =~ \"@opaque type op2/0 is underspecified and therefore meaningless\"\n refute output =~ \"nofile:4: \"\n refute output =~ \"op3\"\n after\n purge(Sample)\n end\n\n test \"underscored types variables\" do\n output =\n capture_eval(\"\"\"\n defmodule Sample do\n @type in_typespec_vars(_var1, _var1) :: atom\n @type in_typespec(_var2) :: {atom, _var2}\n\n @spec in_spec(_var3) :: {atom, _var3} when _var3: var\n def in_spec(a), do: {:ok, a}\n end\n \"\"\")\n\n assert output =~ \"nofile:2: \"\n assert output =~ ~r/the underscored type variable \"_var1\" is used more than once/\n assert output =~ \"nofile:3: \"\n assert output =~ ~r/the underscored type variable \"_var2\" is used more than once/\n assert output =~ \"nofile:5: \"\n assert output =~ ~r/the underscored type variable \"_var3\" is used more than once/\n after\n purge(Sample)\n end\n\n test \"typedoc on typep\" do\n assert_warn_eval(\n [\n \"nofile:2: \",\n \"type priv/0 is private, @typedoc's are always discarded for private types\"\n ],\n \"\"\"\n defmodule Sample do\n @typedoc \"Something\"\n @typep priv :: any\n @spec foo() :: priv\n def foo(), do: nil\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"discouraged types\" do\n string_discouraged =\n \"string() type use is discouraged. \" <>\n \"For character lists, use charlist() type, for strings, String.t()\\n\"\n\n nonempty_string_discouraged =\n \"nonempty_string() type use is discouraged. \" <>\n \"For non-empty character lists, use nonempty_charlist() type, for strings, String.t()\\n\"\n\n assert_warn_eval(\n [\n \"nofile:2: \",\n string_discouraged,\n \"nofile:3: \",\n nonempty_string_discouraged\n ],\n \"\"\"\n defmodule Sample do\n @type foo :: string()\n @type bar :: nonempty_string()\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"nested type annotations\" do\n message = \"invalid type annotation. Type annotations cannot be nested\"\n\n assert_warn_eval(\n [\"nofile:2: \", message],\n \"\"\"\n defmodule Sample1 do\n @type my_type :: ann_type :: nested_ann_type :: atom\n end\n \"\"\"\n )\n\n purge(Sample1)\n\n assert_warn_eval(\n [\"nofile:2: \", message],\n \"\"\"\n defmodule Sample2 do\n @type my_type :: ann_type :: nested_ann_type :: atom | port\n end\n \"\"\"\n )\n\n purge(Sample2)\n\n assert_warn_eval(\n [\"nofile:2: \", message],\n \"\"\"\n defmodule Sample3 do\n @spec foo :: {pid, ann_type :: nested_ann_type :: atom}\n def foo, do: nil\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2, Sample3])\n end\n\n test \"invalid fun\" do\n assert_warn_eval(\n [\n \"nofile:2: \",\n \"fun/1 is not valid in typespecs. Either specify fun() or use (... -> return) instead\"\n ],\n \"\"\"\n defmodule InvalidFunType do\n @type my_type :: fun(integer())\n end\n \"\"\"\n )\n end\n\n test \"invalid type annotations\" do\n assert_warn_eval(\n [\n \"nofile:2: \",\n \"invalid type annotation. The left side of :: must be a variable, got: pid()\"\n ],\n \"\"\"\n defmodule Sample1 do\n @type my_type :: (pid() :: atom)\n end\n \"\"\"\n )\n\n message =\n \"invalid type annotation. The left side of :: must be a variable, got: pid | ann_type. \" <>\n \"Note \\\"left | right :: ann\\\" is the same as \\\"(left | right) :: ann\\\"\"\n\n assert_warn_eval(\n [\"nofile:2: \", message],\n \"\"\"\n defmodule Sample2 do\n @type my_type :: pid | ann_type :: atom\n end\n \"\"\"\n )\n after\n purge([Sample1, Sample2])\n end\n end\n\n test \"attribute with no use\" do\n assert_warn_eval(\n [\"nofile:2: \", \"module attribute @at was set but never used\"],\n \"\"\"\n defmodule Sample do\n @at \"Something\"\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"registered attribute with no use\" do\n assert_warn_eval(\n [\"nofile:3: \", \"module attribute @at was set but never used\"],\n \"\"\"\n defmodule Sample do\n Module.register_attribute(__MODULE__, :at, [])\n @at \"Something\"\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"typedoc with no type\" do\n assert_warn_eval(\n [\"nofile:2: \", \"module attribute @typedoc was set but no type follows it\"],\n \"\"\"\n defmodule Sample do\n @typedoc \"Something\"\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"doc with no function\" do\n assert_warn_eval(\n [\"nofile:2: \", \"module attribute @doc was set but no definition follows it\"],\n \"\"\"\n defmodule Sample do\n @doc \"Something\"\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"pipe without explicit parentheses\" do\n assert_warn_eval(\n [\"nofile:2:1\", \"parentheses are required when piping into a function call\"],\n \"\"\"\n [5, 6, 7, 3]\n |> Enum.map_join \"\", &(Integer.to_string(&1))\n |> String.to_integer\n \"\"\"\n )\n end\n\n test \"keywords without explicit parentheses\" do\n assert_warn_eval(\n [\"nofile:2\\n\", \"missing parentheses for expression following \\\"label:\\\" keyword. \"],\n \"\"\"\n quote do\n IO.inspect arg, label: if true, do: \"foo\", else: \"baz\"\n end\n \"\"\"\n )\n end\n\n test \"do+end with operator without explicit parentheses\" do\n assert_warn_eval(\n [\"nofile:3\\n\", \"missing parentheses on expression following operator \\\"||\\\"\"],\n \"\"\"\n quote do\n case do\n end || raise 1, 2\n end\n \"\"\"\n )\n end\n\n test \"do+end with not in operator without explicit parentheses\" do\n assert_warn_eval(\n [\"nofile:3\\n\", \"missing parentheses on expression following operator \\\"not in\\\"\"],\n \"\"\"\n quote do\n case do\n end not in no_parens 1, 2\n end\n \"\"\"\n )\n end\n\n test \"variable is being expanded to function call (on_undefined_variable: warn)\" do\n capture_io(:stderr, fn ->\n Code.put_compiler_option(:on_undefined_variable, :warn)\n end)\n\n output =\n capture_eval(\"\"\"\n self\n defmodule Sample do\n def my_node(), do: node\n end\n \"\"\")\n\n assert output =~ \"variable \\\"self\\\" does not exist and is being expanded to \\\"self()\\\"\"\n assert output =~ \"nofile:1:1\"\n assert output =~ \"variable \\\"node\\\" does not exist and is being expanded to \\\"node()\\\"\"\n assert output =~ \"nofile:3:22\"\n after\n Code.put_compiler_option(:on_undefined_variable, :raise)\n purge(Sample)\n end\n\n defmodule User do\n defstruct [:name]\n end\n\n test \":__struct__ is ignored when using structs\" do\n assert capture_err(fn ->\n code = \"\"\"\n assert %Kernel.WarningTest.User{__struct__: Ignored, name: \"joe\"} ==\n %Kernel.WarningTest.User{name: \"joe\"}\n \"\"\"\n\n Code.eval_string(code, [], __ENV__)\n end) =~ \"key :__struct__ is ignored when using structs\"\n\n assert capture_err(fn ->\n code = \"\"\"\n user = %Kernel.WarningTest.User{name: \"meg\"}\n assert %Kernel.WarningTest.User{user | __struct__: Ignored, name: \"joe\"} ==\n %Kernel.WarningTest.User{__struct__: Kernel.WarningTest.User, name: \"joe\"}\n \"\"\"\n\n Code.eval_string(code, [], __ENV__)\n end) =~ \"key :__struct__ is ignored when using structs\"\n end\n\n test \"catch comes before rescue in try block\" do\n assert_warn_eval(\n [\"nofile:1:1\\n\", ~s(\"catch\" should always come after \"rescue\" in try)],\n \"\"\"\n try do\n :trying\n catch\n _ -> :caught\n rescue\n _ -> :error\n end\n \"\"\"\n )\n end\n\n test \"catch comes before rescue in def\" do\n assert_warn_eval(\n [\"nofile:2:7\\n\", ~s(\"catch\" should always come after \"rescue\" in def)],\n \"\"\"\n defmodule Sample do\n def foo do\n :trying\n catch\n _, _ -> :caught\n rescue\n _ -> :error\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused variable in defguard\" do\n assert_warn_eval(\n [\"nofile:2:21\", \"variable \\\"baz\\\" is unused\"],\n \"\"\"\n defmodule Sample do\n defguard foo(bar, baz) when bar\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused import in defguard\" do\n assert_warn_eval(\n [\"nofile:2:3\", \"unused import Record\\n\"],\n \"\"\"\n defmodule Sample do\n import Record\n defguard is_record(baz) when baz\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"unused private guard\" do\n assert_warn_eval(\n [\"nofile:2:13: \", \"macro foo/2 is unused\\n\"],\n \"\"\"\n defmodule Sample do\n defguardp foo(bar, baz) when bar + baz\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"defguard overriding defmacro\" do\n assert_warn_eval(\n [\n \"nofile:3:12\\n\",\n ~r\"this clause( for foo/1)? cannot match because a previous clause at line 2 always matches\"\n ],\n \"\"\"\n defmodule Sample do\n defmacro foo(bar), do: bar == :bar\n defguard foo(baz) when baz == :baz\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"defmacro overriding defguard\" do\n assert_warn_eval(\n [\n \"nofile:3:12\\n\",\n ~r\"this clause( for foo/1)? cannot match because a previous clause at line 2 always matches\"\n ],\n \"\"\"\n defmodule Sample do\n defguard foo(baz) when baz == :baz\n defmacro foo(bar), do: bar == :bar\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"deprecated GenServer super on callbacks\" do\n assert_warn_eval(\n [\"nofile:1: \", \"calling super for GenServer callback handle_call/3 is deprecated\"],\n \"\"\"\n defmodule Sample do\n use GenServer\n\n def handle_call(a, b, c) do\n super(a, b, c)\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"super is allowed on GenServer.child_spec/1\" do\n refute capture_eval(\"\"\"\n defmodule Sample do\n use GenServer\n\n def child_spec(opts) do\n super(opts)\n end\n end\n \"\"\") =~ \"calling super for GenServer callback child_spec/1 is deprecated\"\n after\n purge(Sample)\n end\n\n test \"def warns if only clause is else\" do\n assert_warn_compile(\n [\"nofile:2:7\\n\", \"\\\"else\\\" shouldn't be used as the only clause in \\\"def\\\"\"],\n \"\"\"\n defmodule Sample do\n def foo do\n :bar\n else\n _other -> :ok\n end\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"try warns if only clause is else\" do\n assert_warn_compile(\n [\"nofile:1:1\\n\", \"\\\"else\\\" shouldn't be used as the only clause in \\\"try\\\"\"],\n \"\"\"\n try do\n :ok\n else\n other -> other\n end\n \"\"\"\n )\n end\n\n test \"sigil w/W warns on trailing comma at macro expansion time\" do\n for sigil <- ~w(w W),\n modifier <- ~w(a s c) do\n output =\n capture_err(fn ->\n {:ok, ast} =\n \"~#{sigil}(foo, bar baz)#{modifier}\"\n |> Code.string_to_quoted()\n\n Macro.expand(ast, __ENV__)\n end)\n\n assert output =~ \"the sigils ~w/~W do not allow trailing commas\"\n end\n end\n\n test \"warnings on trailing comma on call\" do\n assert_warn_eval(\n [\"nofile:1:25\\n\", \"trailing commas are not allowed inside function/macro call arguments\"],\n \"Keyword.merge([], foo: 1,)\"\n )\n end\n\n test \"defstruct warns with duplicate keys\" do\n assert_warn_eval(\n [\"nofile:2: Sample\", \"duplicate key :foo found in struct\"],\n \"\"\"\n defmodule Sample do\n defstruct [:foo, :bar, foo: 1]\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"deprecate nullary remote zero-arity capture with parens\" do\n assert capture_eval(\"\"\"\n import System, only: [pid: 0]\n &pid/0\n \"\"\") == \"\"\n\n assert_warn_eval(\n [\n \"nofile:1:1\\n\",\n \"extra parentheses on a remote function capture &System.pid()/0 have been deprecated. Please remove the parentheses: &System.pid/0\"\n ],\n \"\"\"\n &System.pid()/0\n \"\"\"\n )\n end\n\n test \"deprecate &module.fun/arity captures with complex expressions as modules\" do\n assert_warn_eval(\n [\n \"nofile:2:\",\n \"\"\"\n expected the module in &module.fun/arity to expand to a variable or an atom, got: hd(modules)\n You can either compute the module name outside of & or convert it to a regular anonymous function.\n \"\"\"\n ],\n \"\"\"\n defmodule Sample do\n def foo(modules), do: &hd(modules).module_info/0\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"deprecate non-quoted variables in bitstring size modifiers\" do\n assert_warn_eval(\n [\n \"the variable \\\"a\\\" is accessed inside size(...) of a bitstring but it was defined outside of the match\",\n \"You must precede it with the pin operator\"\n ],\n \"\"\"\n a = \"foo\"\n <> <> _ = a\n \"fo\" = a\n \"\"\"\n )\n end\n\n defp assert_compile_error(messages, string) do\n captured =\n capture_err(fn ->\n assert_raise CompileError, fn ->\n ast = Code.string_to_quoted!(string, columns: true)\n Code.eval_quoted(ast)\n end\n end)\n\n for message <- List.wrap(messages) do\n assert captured =~ message\n end\n end\n\n defp purge(list) when is_list(list) do\n Enum.each(list, &purge/1)\n end\n\n test \"unused require\" do\n assert_warn_compile(\n [\"nofile:1:1\", \"unused require Logger\"],\n \"\"\"\n require Logger\n \"\"\"\n )\n\n # Within a module\n assert_warn_compile(\n [\"nofile:2:3\", \"unused require Application\"],\n \"\"\"\n defmodule Sample do\n require Application\n def a, do: nil\n end\n \"\"\"\n )\n\n # Unused require and alias\n assert_warn_compile(\n [\"nofile:2:3\", \"unused require Application (the alias is also unused)\"],\n \"\"\"\n defmodule Sample do\n require Application, as: A\n def a, do: nil\n end\n \"\"\"\n )\n\n # Unused require but used alias\n assert_warn_compile(\n [\"nofile:2:3\", \"unused require Application (convert it to an alias instead)\"],\n \"\"\"\n defmodule Sample do\n require Application, as: A\n def a, do: A.started_applications()\n end\n \"\"\"\n )\n after\n purge(Sample)\n end\n\n test \"conditional require\" do\n assert capture_err(fn ->\n defmodule KernelTest.ConditionalRequire do\n if false do\n require Integer\n def fun(x), do: Integer.is_odd(x)\n end\n end\n end) == \"\"\n after\n purge(Sample)\n end\n\n defp purge(module) when is_atom(module) do\n :code.purge(module)\n :code.delete(module)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel/with_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Kernel.WithTest do\n use ExUnit.Case, async: true\n\n test \"basic with\" do\n assert with({:ok, res} <- ok(41), do: res) == 41\n assert with(res <- four(), do: res + 10) == 14\n end\n\n test \"matching with\" do\n assert with(_..42//_ <- 1..42, do: :ok) == :ok\n assert with({:ok, res} <- error(), do: res) == :error\n assert with({:ok, _} = res <- ok(42), do: elem(res, 1)) == 42\n end\n\n test \"with guards\" do\n assert with(x when x < 2 <- four(), do: :ok) == 4\n assert with(x when x > 2 <- four(), do: :ok) == :ok\n assert with(x when x < 2 when x == 4 <- four(), do: :ok) == :ok\n end\n\n test \"pin matching with\" do\n key = :ok\n assert with({^key, res} <- ok(42), do: res) == 42\n end\n\n test \"pin matching with multiple else\" do\n key = :error\n\n first_else =\n with nil <- error() do\n :ok\n else\n ^key -> :pinned\n _other -> :other\n end\n\n assert first_else == :pinned\n\n second_else =\n with nil <- ok(42) do\n :ok\n else\n ^key -> :pinned\n _other -> :other\n end\n\n assert second_else == :other\n end\n\n test \"two levels with\" do\n result =\n with {:ok, n1} <- ok(11),\n n2 <- 22,\n do: n1 + n2\n\n assert result == 33\n\n result =\n with n1 <- 11,\n {:ok, n2} <- error(),\n do: n1 + n2\n\n assert result == :error\n end\n\n test \"binding inside with\" do\n result =\n with {:ok, n1} <- ok(11),\n n2 = n1 + 10,\n {:ok, n3} <- ok(22),\n do: n2 + n3\n\n assert result == 43\n\n result =\n with {:ok, n1} <- ok(11),\n n2 = n1 + 10,\n {:ok, n3} <- error(),\n do: n2 + n3\n\n assert result == :error\n end\n\n test \"does not leak variables to else\" do\n state = 1\n\n result =\n with 1 <- state,\n state = 2,\n :ok <- error(),\n do: state,\n else: (_ -> state)\n\n assert result == 1\n assert state == 1\n end\n\n test \"with shadowing\" do\n assert with(\n a <-\n (\n b = 1\n _ = b\n 1\n ),\n b <- 2,\n do: a + b\n ) == 3\n end\n\n test \"with extra guards\" do\n var =\n with %_{} = a <- struct(URI),\n %_{} <- a do\n :ok\n end\n\n assert var == :ok\n end\n\n test \"errors in with\" do\n assert_raise RuntimeError, fn ->\n with({:ok, res} <- oops(), do: res)\n end\n\n assert_raise RuntimeError, fn ->\n with({:ok, res} <- ok(42), oops(), do: res)\n end\n end\n\n test \"else conditions\" do\n assert (with {:ok, res} <- four() do\n res\n else\n {:error, error} -> error\n res -> res + 1\n end) == 5\n\n assert (with {:ok, res} <- four() do\n res\n else\n res when res == 4 -> res + 1\n res -> res\n end) == 5\n\n assert with({:ok, res} <- four(), do: res, else: (_ -> :error)) == :error\n end\n\n test \"else conditions with match error\" do\n assert_raise WithClauseError, \"no with clause matching:\\n\\n :error\\n\", fn ->\n with({:ok, res} <- error(), do: res, else: ({:error, error} -> error))\n end\n end\n\n defp four() do\n 4\n end\n\n defp error() do\n :error\n end\n\n defp ok(num) do\n {:ok, num}\n end\n\n defp oops() do\n raise(\"oops\")\n end\nend\n" }, { "path": "lib/elixir/test/elixir/kernel_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule KernelTest do\n use ExUnit.Case, async: true\n\n # Skip these doctests are they emit warnings\n doctest Kernel,\n except:\n [===: 2, !==: 2, and: 2, or: 2] ++\n [is_exception: 1, is_exception: 2, is_nil: 1, is_struct: 1, is_non_struct_map: 1]\n\n def id(arg), do: arg\n def id(arg1, arg2), do: {arg1, arg2}\n def empty_map, do: %{}\n\n defp purge(module) do\n :code.purge(module)\n :code.delete(module)\n end\n\n defp assert_eval_raise(error, msg, string) do\n assert_raise error, msg, fn ->\n Code.eval_string(string)\n end\n end\n\n test \"op ambiguity\" do\n max = 1\n assert max == 1\n assert max(1, 2) == 2\n end\n\n describe \"=/2\" do\n test \"can be reassigned\" do\n var = 1\n id(var)\n var = 2\n assert var == 2\n end\n\n test \"can be reassigned inside a list\" do\n _ = [var = 1, 2, 3]\n id(var)\n _ = [var = 2, 3, 4]\n assert var == 2\n end\n\n test \"can be reassigned inside a keyword list\" do\n _ = [a: var = 1, b: 2]\n id(var)\n _ = [b: var = 2, c: 3]\n assert var == 2\n end\n\n test \"can be reassigned inside a call\" do\n id(var = 1)\n id(var)\n id(var = 2)\n assert var == 2\n end\n\n test \"can be reassigned inside a multi-argument call\" do\n id(:arg, var = 1)\n id(:arg, var)\n id(:arg, var = 2)\n assert var == 2\n\n id(:arg, a: 1, b: var = 2)\n id(:arg, var)\n id(:arg, b: 2, c: var = 3)\n assert var == 3\n end\n\n test \"++/2 works in matches\" do\n [1, 2] ++ var = [1, 2]\n assert var == []\n\n [1, 2] ++ var = [1, 2, 3]\n assert var == [3]\n\n ~c\"ab\" ++ var = ~c\"abc\"\n assert var == ~c\"c\"\n\n [:a, :b] ++ var = [:a, :b, :c]\n assert var == [:c]\n end\n end\n\n test \"=~/2\" do\n assert \"abcd\" =~ ~r/c(d)/ == true\n assert \"abcd\" =~ ~r/e/ == false\n\n string = \"^ab+cd*$\"\n assert string =~ \"ab+\" == true\n assert string =~ \"bb\" == false\n\n assert \"abcd\" =~ ~r// == true\n assert \"abcd\" =~ \"\" == true\n\n assert \"\" =~ ~r// == true\n assert \"\" =~ \"\" == true\n\n assert \"\" =~ \"abcd\" == false\n assert \"\" =~ ~r/abcd/ == false\n end\n\n test \"^\" do\n x = List.first([1])\n\n assert_raise MatchError, fn ->\n {x, ^x} = {2, 2}\n x\n end\n end\n\n # Note we use `==` in assertions so `assert` does not rewrite `match?/2`.\n test \"match?/2\" do\n a = List.first([0])\n assert match?(b when b > a, 1) == true\n assert binding() == [a: 0]\n\n assert match?(b when b > a, -1) == false\n assert binding() == [a: 0]\n\n # Does not warn on underscored variables\n assert match?(_unused, a) == true\n end\n\n def exported?, do: not_exported?()\n defp not_exported?, do: true\n\n test \"function_exported?/3\" do\n assert function_exported?(__MODULE__, :exported?, 0)\n refute function_exported?(__MODULE__, :not_exported?, 0)\n end\n\n test \"macro_exported?/3\" do\n assert macro_exported?(Kernel, :in, 2) == true\n assert macro_exported?(Kernel, :def, 1) == true\n assert macro_exported?(Kernel, :def, 2) == true\n assert macro_exported?(Kernel, :def, 3) == false\n assert macro_exported?(Kernel, :no_such_macro, 2) == false\n assert macro_exported?(:erlang, :abs, 1) == false\n end\n\n test \"apply/3 and apply/2\" do\n assert apply(Enum, :reverse, [[1 | [2, 3]]]) == [3, 2, 1]\n assert apply(fn x -> x * 2 end, [2]) == 4\n end\n\n test \"binding/0 and binding/1\" do\n x = 1\n assert binding() == [x: 1]\n\n x = 2\n assert binding() == [x: 2]\n\n y = 3\n assert binding() == [x: 2, y: 3]\n\n var!(x, :foo) = 4\n assert binding() == [x: 2, y: 3]\n assert binding(:foo) == [x: 4]\n\n # No warnings\n _x = 1\n assert binding() == [_x: 1, x: 2, y: 3]\n end\n\n defmodule User do\n assert is_map(defstruct name: \"john\")\n # Ensure we keep the line information around.\n # It is important for debugging tools, ExDoc, etc.\n {:v1, :def, anno, _clauses} = Module.get_definition(__MODULE__, {:__struct__, 1})\n anno[:line] == __ENV__.line - 4\n end\n\n test \"struct/1 and struct/2\" do\n assert struct(User) == %User{name: \"john\"}\n\n user = struct(User, name: \"meg\")\n assert user == %User{name: \"meg\"}\n assert struct(user, %{name: \"meg\"}) == user\n\n assert struct(user, unknown: \"key\") == user\n assert struct(user, %{name: \"john\"}) == %User{name: \"john\"}\n assert struct(user, name: \"other\", __struct__: Post) == %User{name: \"other\"}\n end\n\n test \"struct!/1 and struct!/2\" do\n assert struct!(User) == %User{name: \"john\"}\n\n user = struct!(User, name: \"meg\")\n assert user == %User{name: \"meg\"}\n\n assert_raise KeyError, fn ->\n struct!(user, unknown: \"key\")\n end\n\n assert struct!(user, %{name: \"john\"}) == %User{name: \"john\"}\n assert struct!(user, name: \"other\", __struct__: Post) == %User{name: \"other\"}\n end\n\n test \"if/2 with invalid keys\" do\n error_message =\n \"invalid or duplicate keys for if, only \\\"do\\\" and an optional \\\"else\\\" are permitted\"\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"if true, foo: 7\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"if true, do: 6, boo: 7\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"if true, do: 7, do: 6\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"if true, do: 8, else: 7, else: 6\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"if true, else: 6\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"if true, []\")\n end\n end\n\n test \"unless/2 with invalid keys\" do\n error_message =\n \"invalid or duplicate keys for unless, only \\\"do\\\" \" <>\n \"and an optional \\\"else\\\" are permitted\"\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"unless true, foo: 7\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"unless true, do: 6, boo: 7\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"unless true, do: 7, do: 6\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"unless true, do: 8, else: 7, else: 6\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"unless true, else: 6\")\n end\n\n assert_raise ArgumentError, error_message, fn ->\n Code.eval_string(\"unless true, []\")\n end\n end\n\n test \"and/2\" do\n assert (true and false) == false\n assert (true and true) == true\n assert (true and 0) == 0\n assert (false and false) == false\n assert (false and true) == false\n assert (false and 0) == false\n assert (false and raise(\"oops\")) == false\n assert ((x = Process.get(:unused, true)) and not x) == false\n assert_raise BadBooleanError, fn -> Process.get(:unused, 0) and 1 end\n end\n\n test \"or/2\" do\n assert (true or false) == true\n assert (true or true) == true\n assert (true or 0) == true\n assert (true or raise(\"foo\")) == true\n assert (false or false) == false\n assert (false or true) == true\n assert (false or 0) == 0\n assert ((x = Process.get(:unused, false)) or not x) == true\n assert_raise BadBooleanError, fn -> Process.get(:unused, 0) or 1 end\n end\n\n defp delegate_is_struct(arg), do: is_struct(arg)\n\n defp guarded_is_struct(arg) when is_struct(arg), do: true\n defp guarded_is_struct(_arg), do: false\n\n defp struct_or_map?(arg) when is_struct(arg) or is_map(arg), do: true\n defp struct_or_map?(_arg), do: false\n\n test \"is_struct/1\" do\n assert delegate_is_struct(%{}) == false\n assert delegate_is_struct([]) == false\n assert delegate_is_struct(%Macro.Env{}) == true\n assert delegate_is_struct(%{__struct__: \"foo\"}) == false\n assert guarded_is_struct(%Macro.Env{}) == true\n assert guarded_is_struct(%{__struct__: \"foo\"}) == false\n assert guarded_is_struct([]) == false\n assert guarded_is_struct(%{}) == false\n end\n\n test \"is_struct/1 and other match works\" do\n assert struct_or_map?(%Macro.Env{}) == true\n assert struct_or_map?(%{}) == true\n assert struct_or_map?(10) == false\n end\n\n defp delegate_is_struct(arg, name), do: is_struct(arg, name)\n\n defp guarded_is_struct(arg, name) when is_struct(arg, name), do: true\n defp guarded_is_struct(_arg, _name), do: false\n\n defp struct_or_map?(arg, name) when is_struct(arg, name) or is_map(arg), do: true\n defp struct_or_map?(_arg, _name), do: false\n\n defp not_atom(), do: \"not atom\"\n\n test \"is_struct/2\" do\n assert delegate_is_struct(%{}, Macro.Env) == false\n assert delegate_is_struct([], Macro.Env) == false\n assert delegate_is_struct(%Macro.Env{}, Macro.Env) == true\n assert delegate_is_struct(%Macro.Env{}, URI) == false\n assert guarded_is_struct(%Macro.Env{}, Macro.Env) == true\n assert guarded_is_struct(%Macro.Env{}, URI) == false\n assert guarded_is_struct(%{__struct__: \"foo\"}, \"foo\") == false\n assert guarded_is_struct(%{__struct__: \"foo\"}, Macro.Env) == false\n assert guarded_is_struct([], Macro.Env) == false\n assert guarded_is_struct(%{}, Macro.Env) == false\n\n assert_raise ArgumentError, \"argument error\", fn ->\n is_struct(%{}, not_atom())\n end\n end\n\n test \"is_struct/2 and other match works\" do\n assert struct_or_map?(%{}, \"foo\") == false\n assert struct_or_map?(%{}, Macro.Env) == true\n assert struct_or_map?(%Macro.Env{}, Macro.Env) == true\n end\n\n defp delegate_is_non_struct_map(arg), do: is_non_struct_map(arg)\n\n defp guarded_is_non_struct_map(arg) when is_non_struct_map(arg), do: true\n defp guarded_is_non_struct_map(_arg), do: false\n\n defp non_struct_map_or_struct?(arg) when is_non_struct_map(arg) or is_struct(arg), do: true\n defp non_struct_map_or_struct?(_arg), do: false\n\n test \"is_non_struct_map/1\" do\n assert delegate_is_non_struct_map(%{}) == true\n assert delegate_is_non_struct_map([]) == false\n assert delegate_is_non_struct_map(%Macro.Env{}) == false\n assert delegate_is_non_struct_map(%{__struct__: \"foo\"}) == true\n assert guarded_is_non_struct_map(%Macro.Env{}) == false\n assert guarded_is_non_struct_map(%{__struct__: \"foo\"}) == true\n assert guarded_is_non_struct_map([]) == false\n assert guarded_is_non_struct_map(%{}) == true\n end\n\n test \"is_non_struct_map/1 and other match works\" do\n assert non_struct_map_or_struct?(%Macro.Env{}) == true\n assert non_struct_map_or_struct?(%{}) == true\n assert non_struct_map_or_struct?(10) == false\n end\n\n defp delegate_is_exception(arg), do: is_exception(arg)\n\n defp guarded_is_exception(arg) when is_exception(arg), do: true\n defp guarded_is_exception(_arg), do: false\n\n defp exception_or_map?(arg) when is_exception(arg) or is_map(arg), do: true\n defp exception_or_map?(_arg), do: false\n\n test \"is_exception/1\" do\n assert delegate_is_exception(%{}) == false\n assert delegate_is_exception([]) == false\n assert delegate_is_exception(%RuntimeError{}) == true\n assert delegate_is_exception(%{__exception__: \"foo\"}) == false\n assert guarded_is_exception(%RuntimeError{}) == true\n assert guarded_is_exception(%{__exception__: \"foo\"}) == false\n assert guarded_is_exception([]) == false\n assert guarded_is_exception(%{}) == false\n end\n\n test \"is_exception/1 and other match works\" do\n assert exception_or_map?(%RuntimeError{}) == true\n assert exception_or_map?(%{}) == true\n assert exception_or_map?(10) == false\n end\n\n defp delegate_is_exception(arg, name), do: is_exception(arg, name)\n\n defp guarded_is_exception(arg, name) when is_exception(arg, name), do: true\n defp guarded_is_exception(_arg, _name), do: false\n\n defp exception_or_map?(arg, name) when is_exception(arg, name) or is_map(arg), do: true\n defp exception_or_map?(_arg, _name), do: false\n\n test \"is_exception/2\" do\n assert delegate_is_exception(%{}, RuntimeError) == false\n assert delegate_is_exception([], RuntimeError) == false\n assert delegate_is_exception(%RuntimeError{}, RuntimeError) == true\n assert delegate_is_exception(%RuntimeError{}, Macro.Env) == false\n assert guarded_is_exception(%RuntimeError{}, RuntimeError) == true\n assert guarded_is_exception(%RuntimeError{}, Macro.Env) == false\n assert guarded_is_exception(%{__exception__: \"foo\"}, \"foo\") == false\n assert guarded_is_exception(%{__exception__: \"foo\"}, RuntimeError) == false\n assert guarded_is_exception([], RuntimeError) == false\n assert guarded_is_exception(%{}, RuntimeError) == false\n\n assert_raise ArgumentError, \"argument error\", fn ->\n delegate_is_exception(%{}, not_atom())\n end\n end\n\n test \"is_exception/2 and other match works\" do\n assert exception_or_map?(%{}, \"foo\") == false\n assert exception_or_map?(%{}, RuntimeError) == true\n assert exception_or_map?(%RuntimeError{}, RuntimeError) == true\n end\n\n test \"then/2\" do\n assert 1 |> then(fn x -> x * 2 end) == 2\n end\n\n test \"if/2 boolean optimization does not leak variables during expansion\" do\n if false do\n :ok\n else\n assert Macro.Env.vars(__ENV__) == []\n end\n end\n\n describe \"..\" do\n test \"returns 0..-1//1\" do\n assert (..) == 0..-1//1\n end\n end\n\n describe \"in/2\" do\n # This test may take a long time on machine with low resources\n @tag timeout: 120_000\n test \"too large list in guards\" do\n defmodule TooLargeList do\n @list Enum.map(1..1024, & &1)\n defguard is_value(value) when value in @list\n end\n end\n\n test \"with literals on right side\" do\n assert 2 in [1, 2, 3]\n assert 2 in 1..3\n refute 4 in [1, 2, 3]\n refute 4 in 1..3\n refute 2 in []\n refute false in []\n refute true in []\n end\n\n test \"with expressions on right side\" do\n list = [1, 2, 3]\n empty_list = []\n assert 2 in list\n refute 4 in list\n\n refute 4 in empty_list\n refute false in empty_list\n refute true in empty_list\n\n assert 2 in [1 | [2, 3]]\n assert 3 in [1 | list]\n\n some_call = & &1\n refute :x in [1, 2 | some_call.([3, 4])]\n assert :x in [1, 2 | some_call.([3, :x])]\n\n assert_raise ArgumentError, fn ->\n :x in [1, 2 | some_call.({3, 4})]\n end\n end\n\n @at_list1 [4, 5]\n @at_range 6..8\n @at_list2 [13, 14]\n def fun_in(x) when x in [0], do: :list\n def fun_in(x) when x in 1..3, do: :range\n def fun_in(x) when x in @at_list1, do: :at_list\n def fun_in(x) when x in @at_range, do: :at_range\n def fun_in(x) when x in [9 | [10, 11]], do: :list_cons\n def fun_in(x) when x in [12 | @at_list2], do: :list_cons_at\n def fun_in(x) when x in 21..15//1, do: raise(\"oops positive\")\n def fun_in(x) when x in 15..21//-1, do: raise(\"oops negative\")\n def fun_in(x) when x in 15..21//2, do: :range_step_2\n def fun_in(x) when x in 15..21//1, do: :range_step_1\n def fun_in(_), do: :none\n\n test \"in function guard\" do\n assert fun_in(0) == :list\n assert fun_in(1) == :range\n assert fun_in(2) == :range\n assert fun_in(3) == :range\n assert fun_in(5) == :at_list\n assert fun_in(6) == :at_range\n assert fun_in(7) == :at_range\n assert fun_in(8) == :at_range\n assert fun_in(9) == :list_cons\n assert fun_in(10) == :list_cons\n assert fun_in(11) == :list_cons\n assert fun_in(12) == :list_cons_at\n assert fun_in(13) == :list_cons_at\n assert fun_in(14) == :list_cons_at\n assert fun_in(15) == :range_step_2\n assert fun_in(16) == :range_step_1\n assert fun_in(17) == :range_step_2\n assert fun_in(22) == :none\n\n assert fun_in(0.0) == :none\n assert fun_in(1.0) == :none\n assert fun_in(2.0) == :none\n assert fun_in(3.0) == :none\n assert fun_in(6.0) == :none\n assert fun_in(7.0) == :none\n assert fun_in(8.0) == :none\n assert fun_in(9.0) == :none\n assert fun_in(10.0) == :none\n assert fun_in(11.0) == :none\n assert fun_in(12.0) == :none\n assert fun_in(13.0) == :none\n assert fun_in(14.0) == :none\n assert fun_in(15.0) == :none\n assert fun_in(16.0) == :none\n assert fun_in(17.0) == :none\n end\n\n def dynamic_step_in(x, y, z, w) when x in y..z//w, do: true\n def dynamic_step_in(_x, _y, _z, _w), do: false\n\n test \"in dynamic range with step function guard\" do\n assert dynamic_step_in(1, 1, 3, 1)\n assert dynamic_step_in(2, 1, 3, 1)\n assert dynamic_step_in(3, 1, 3, 1)\n\n refute dynamic_step_in(1, 1, 3, -1)\n refute dynamic_step_in(2, 1, 3, -1)\n refute dynamic_step_in(3, 1, 3, -1)\n\n assert dynamic_step_in(1, 3, 1, -1)\n assert dynamic_step_in(2, 3, 1, -1)\n assert dynamic_step_in(3, 3, 1, -1)\n\n refute dynamic_step_in(1, 3, 1, 1)\n refute dynamic_step_in(2, 3, 1, 1)\n refute dynamic_step_in(3, 3, 1, 1)\n\n assert dynamic_step_in(1, 1, 3, 2)\n refute dynamic_step_in(2, 1, 3, 2)\n assert dynamic_step_in(3, 1, 3, 2)\n assert dynamic_step_in(3, 1, 4, 2)\n refute dynamic_step_in(4, 1, 4, 2)\n end\n\n defmacrop case_in(x, y) do\n quote do\n case 0 do\n _ when unquote(x) in unquote(y) -> true\n _ -> false\n end\n end\n end\n\n test \"in case guard\" do\n assert case_in(1, [1, 2, 3]) == true\n assert case_in(1, 1..3) == true\n assert case_in(2, 1..3) == true\n assert case_in(3, 1..3) == true\n assert case_in(-3, -1..-3//-1) == true\n end\n\n def map_dot(map) when map.field, do: true\n def map_dot(_other), do: false\n\n test \"map dot guard\" do\n refute map_dot(:foo)\n refute map_dot(%{})\n refute map_dot(%{field: false})\n assert map_dot(%{field: true})\n end\n\n test \"performs all side-effects\" do\n assert 1 in [1, send(self(), 2)]\n assert_received 2\n\n assert 1 in [1 | send(self(), [2])]\n assert_received [2]\n\n assert 2 in [1 | send(self(), [2])]\n assert_received [2]\n end\n\n test \"has proper evaluation order\" do\n a = 1\n assert 1 in [a = 2, a]\n # silence unused var warning\n _ = a\n end\n\n test \"in module body\" do\n defmodule InSample do\n @foo [:a, :b]\n true = :a in @foo\n end\n after\n purge(InSample)\n end\n\n test \"inside and/2\" do\n response = Process.get(:unused, %{code: 200})\n\n if is_map(response) and response.code in 200..299 do\n :pass\n end\n\n # This module definition copies internal variable\n # defined during in/2 expansion.\n Module.create(InVarCopy, nil, __ENV__)\n purge(InVarCopy)\n end\n\n test \"with a non-literal non-escaped compile-time range in guards\" do\n message = ~r\"found unescaped value on the right side of in/2: 1..3\"\n\n assert_eval_raise(ArgumentError, message, \"\"\"\n defmodule InErrors do\n range = 1..3\n def foo(x) when x in unquote(range), do: :ok\n end\n \"\"\")\n end\n\n test \"with a non-compile-time range in guards\" do\n message = ~r/invalid right argument for operator \"in\", .* got: :hello/\n\n assert_eval_raise(ArgumentError, message, \"\"\"\n defmodule InErrors do\n def foo(x) when x in :hello, do: :ok\n end\n \"\"\")\n end\n\n test \"with a non-compile-time list cons in guards\" do\n message = ~r/invalid right argument for operator \"in\", .* got: \\[1 | list\\(\\)\\]/\n\n assert_eval_raise(ArgumentError, message, \"\"\"\n defmodule InErrors do\n def list, do: [1]\n def foo(x) when x in [1 | list()], do: :ok\n end\n \"\"\")\n end\n\n test \"with a compile-time non-list in tail in guards\" do\n message = ~r/invalid right argument for operator \"in\", .* got: \\[1 | 1..3\\]/\n\n assert_eval_raise(ArgumentError, message, \"\"\"\n defmodule InErrors do\n def foo(x) when x in [1 | 1..3], do: :ok\n end\n \"\"\")\n end\n\n test \"hoists variables and keeps order\" do\n # Ranges\n result = expand_to_string(quote(do: rand() in 1..2))\n assert result =~ \"var = rand()\"\n\n result = expand_to_string(quote(do: var in 1..2), :guard)\n\n assert result =~ \"\"\"\n :erlang.andalso(\n :erlang.is_integer(var),\n :erlang.andalso(:erlang.>=(var, 1), :erlang.\\\"=<\\\"(var, 2))\n )\\\n \"\"\"\n\n # Empty list\n assert expand_to_string(quote(do: :x in [])) =~ \"_ = :x\\nfalse\"\n assert expand_to_string(quote(do: :x in []), :guard) == \"false\"\n\n # Lists\n result = expand_to_string(quote(do: rand() in [1, 2]))\n assert result =~ \":lists.member(rand(), [1, 2]\"\n end\n\n test \"is optimized\" do\n assert expand_to_string(quote(do: foo in []), :guard) ==\n \"false\"\n\n assert expand_to_string(quote(do: foo in [1, 2, 3]), :guard) == \"\"\"\n :erlang.orelse(\n :erlang.orelse(:erlang.\\\"=:=\\\"(foo, 1), :erlang.\\\"=:=\\\"(foo, 2)),\n :erlang.\\\"=:=\\\"(foo, 3)\n )\\\n \"\"\"\n\n assert expand_to_string(quote(do: foo in 0..1), :guard) == \"\"\"\n :erlang.andalso(\n :erlang.is_integer(foo),\n :erlang.andalso(:erlang.>=(foo, 0), :erlang.\\\"=<\\\"(foo, 1))\n )\\\n \"\"\"\n\n assert expand_to_string(quote(do: foo in -1..0), :guard) == \"\"\"\n :erlang.andalso(\n :erlang.is_integer(foo),\n :erlang.andalso(:erlang.>=(foo, -1), :erlang.\\\"=<\\\"(foo, 0))\n )\\\n \"\"\"\n\n assert expand_to_string(quote(do: foo in 1..1), :guard) ==\n \":erlang.\\\"=:=\\\"(foo, 1)\"\n\n assert expand_to_string(quote(do: 2 in 1..3), :guard) ==\n \":erlang.andalso(:erlang.is_integer(2), :erlang.andalso(:erlang.>=(2, 1), :erlang.\\\"=<\\\"(2, 3)))\"\n end\n\n defp expand_to_string(ast, environment_or_context \\\\ __ENV__)\n\n defp expand_to_string(ast, context) when is_atom(context) do\n expand_to_string(ast, %{__ENV__ | context: context})\n end\n\n defp expand_to_string(ast, environment) do\n ast\n |> Macro.prewalk(&Macro.expand(&1, environment))\n |> Macro.to_string()\n end\n end\n\n describe \"__info__\" do\n test \":macros\" do\n assert {:in, 2} in Kernel.__info__(:macros)\n end\n\n test \":functions\" do\n refute {:__info__, 1} in Kernel.__info__(:functions)\n end\n\n test \":struct\" do\n assert Kernel.__info__(:struct) == nil\n assert [%{field: :scheme, default: nil} | _] = URI.__info__(:struct)\n end\n\n test \"others\" do\n assert Kernel.__info__(:module) == Kernel\n assert is_list(Kernel.__info__(:compile))\n assert is_list(Kernel.__info__(:attributes))\n end\n end\n\n describe \"@\" do\n test \"setting attribute with do-block\" do\n exception =\n catch_error(\n defmodule UpcaseAttrSample do\n @foo quote do\n :ok\n end\n end\n )\n\n assert exception.message =~ \"expected 0 or 1 argument for @foo, got 2\"\n assert exception.message =~ \"You probably want to wrap the argument value in parentheses\"\n end\n\n test \"setting attribute with uppercase\" do\n message = \"module attributes set via @ cannot start with an uppercase letter\"\n\n assert_raise ArgumentError, message, fn ->\n defmodule UpcaseAttrSample do\n @Upper\n end\n end\n end\n\n test \"matching attribute\" do\n assert_raise ArgumentError, ~r\"invalid usage of module attributes\", fn ->\n defmodule MatchAttributeInModule do\n @foo = 42\n end\n end\n\n assert_raise ArgumentError, ~r\"invalid usage of module attributes\", fn ->\n defmodule MatchAttributeInModule do\n @foo 16\n <<_::@foo>> = \"ab\"\n end\n end\n\n assert_raise ArgumentError, ~r\"invalid usage of module attributes\", fn ->\n defmodule MatchAttributeInModule do\n @foo 16\n <<_::size(@foo)>> = \"ab\"\n end\n end\n end\n end\n\n describe \"defdelegate\" do\n defdelegate my_flatten(list), to: List, as: :flatten\n\n dynamic = :dynamic_flatten\n defdelegate unquote(dynamic)(list), to: List, as: :flatten\n\n test \"dispatches to delegated functions\" do\n assert my_flatten([[1]]) == [1]\n end\n\n test \"with unquote\" do\n assert dynamic_flatten([[1]]) == [1]\n end\n\n test \"raises with non-variable arguments\" do\n assert_raise ArgumentError,\n \"guards are not allowed in defdelegate/2, got: when is_list(term) or is_binary(term)\",\n fn ->\n string = \"\"\"\n defmodule IntDelegateWithGuards do\n defdelegate foo(term) when is_list(term) or is_binary(term), to: List\n end\n \"\"\"\n\n Code.eval_string(string, [], __ENV__)\n end\n\n msg = \"defdelegate/2 only accepts function parameters, got: 1\"\n\n assert_raise ArgumentError, msg, fn ->\n string = \"\"\"\n defmodule IntDelegate do\n defdelegate foo(1), to: List\n end\n \"\"\"\n\n Code.eval_string(string, [], __ENV__)\n end\n\n assert_raise ArgumentError, msg, fn ->\n string = \"\"\"\n defmodule IntOptionDelegate do\n defdelegate foo(1 \\\\\\\\ 1), to: List\n end\n \"\"\"\n\n Code.eval_string(string, [], __ENV__)\n end\n end\n\n test \"raises when :to targeting the delegating module is given without the :as option\" do\n assert_raise ArgumentError,\n ~r/defdelegate function is calling itself, which will lead to an infinite loop. You should either change the value of the :to option or specify the :as option/,\n fn ->\n defmodule ImplAttributes do\n defdelegate foo(), to: __MODULE__\n end\n end\n end\n\n defdelegate my_reverse(list \\\\ []), to: :lists, as: :reverse\n defdelegate my_get(map \\\\ %{}, key, default \\\\ \"\"), to: Map, as: :get\n\n test \"accepts variable with optional arguments\" do\n assert my_reverse() == []\n assert my_reverse([1, 2, 3]) == [3, 2, 1]\n\n assert my_get(\"foo\") == \"\"\n assert my_get(%{}, \"foo\") == \"\"\n assert my_get(%{\"foo\" => \"bar\"}, \"foo\") == \"bar\"\n assert my_get(%{}, \"foo\", \"not_found\") == \"not_found\"\n end\n end\n\n describe \"defmodule\" do\n test \"expects atoms as module names\" do\n msg = ~r\"invalid module name: 3\"\n\n assert_raise ArgumentError, msg, fn ->\n defmodule 1 + 2, do: :ok\n end\n end\n\n test \"does not accept special atoms as module names\" do\n special_atoms = [nil, true, false]\n\n Enum.each(special_atoms, fn special_atom ->\n msg = ~r\"invalid module name: #{inspect(special_atom)}\"\n\n assert_raise ArgumentError, msg, fn ->\n defmodule special_atom, do: :ok\n end\n end)\n end\n\n test \"does not accept slashes in module names\" do\n assert_raise ArgumentError, ~r(invalid module name: :\"foo/bar\"), fn ->\n defmodule :\"foo/bar\", do: :ok\n end\n\n assert_raise ArgumentError, ~r(invalid module name: :\"foo\\\\\\\\bar\"), fn ->\n defmodule :\"foo\\\\bar\", do: :ok\n end\n end\n end\n\n describe \"access\" do\n defmodule StructAccess do\n defstruct [:foo, :bar]\n end\n\n test \"get_in/1\" do\n users = %{\"john\" => %{age: 27}, :meg => %{age: 23}}\n assert get_in(users[\"john\"][:age]) == 27\n assert get_in(users[\"dave\"][:age]) == nil\n assert get_in(users[\"john\"].age) == 27\n assert get_in(users[\"dave\"].age) == nil\n assert get_in(users.meg[:age]) == 23\n assert get_in(users.meg.age) == 23\n\n is_nil = nil\n assert get_in(is_nil.age) == nil\n\n assert_raise KeyError, ~r\"key :unknown not found\", fn -> get_in(users.unknown) end\n assert_raise KeyError, ~r\"key :unknown not found\", fn -> get_in(users.meg.unknown) end\n end\n\n test \"get_in/2\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n assert get_in(users, [\"john\", :age]) == 27\n assert get_in(users, [\"dave\", :age]) == nil\n assert get_in(nil, [\"john\", :age]) == nil\n\n map = %{\"fruits\" => [\"banana\", \"apple\", \"orange\"]}\n assert get_in(map, [\"fruits\", by_index(0)]) == \"banana\"\n assert get_in(map, [\"fruits\", by_index(3)]) == nil\n assert get_in(map, [\"unknown\", by_index(3)]) == nil\n end\n\n test \"put_in/3\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert put_in(users, [\"john\", :age], 28) == %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}\n\n assert_raise ArgumentError, \"could not put/update key \\\"john\\\" on a nil value\", fn ->\n put_in(nil, [\"john\", :age], 28)\n end\n end\n\n test \"put_in/2\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert put_in(users[\"john\"][:age], 28) == %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}\n\n assert put_in(users[\"john\"].age, 28) == %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}\n\n struct = %StructAccess{foo: %StructAccess{}}\n\n assert put_in(struct.foo.bar, :baz) ==\n %StructAccess{bar: nil, foo: %StructAccess{bar: :baz, foo: nil}}\n\n assert_raise BadMapError, fn ->\n put_in(users[\"dave\"].age, 19)\n end\n\n assert_raise KeyError, fn ->\n put_in(users[\"meg\"].unknown, \"value\")\n end\n end\n\n test \"update_in/3\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert update_in(users, [\"john\", :age], &(&1 + 1)) ==\n %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}\n\n assert_raise ArgumentError, \"could not put/update key \\\"john\\\" on a nil value\", fn ->\n update_in(nil, [\"john\", :age], fn _ -> %{} end)\n end\n\n assert_raise UndefinedFunctionError, fn ->\n pop_in(struct(Sample, []), [:name])\n end\n end\n\n test \"update_in/2\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert update_in(users[\"john\"][:age], &(&1 + 1)) ==\n %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}\n\n assert update_in(users[\"john\"].age, &(&1 + 1)) ==\n %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}\n\n struct = %StructAccess{foo: %StructAccess{bar: 41}}\n\n assert update_in(struct.foo.bar, &(&1 + 1)) ==\n %StructAccess{bar: nil, foo: %StructAccess{bar: 42, foo: nil}}\n\n assert_raise BadMapError, fn ->\n update_in(users[\"dave\"].age, &(&1 + 1))\n end\n\n assert_raise KeyError, fn ->\n put_in(users[\"meg\"].unknown, &(&1 + 1))\n end\n end\n\n test \"get_and_update_in/3\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert get_and_update_in(users, [\"john\", :age], &{&1, &1 + 1}) ==\n {27, %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}}\n\n map = %{\"fruits\" => [\"banana\", \"apple\", \"orange\"]}\n\n assert get_and_update_in(map, [\"fruits\", by_index(0)], &{&1, String.reverse(&1)}) ==\n {\"banana\", %{\"fruits\" => [\"ananab\", \"apple\", \"orange\"]}}\n\n assert get_and_update_in(map, [\"fruits\", by_index(3)], &{&1, &1}) ==\n {nil, %{\"fruits\" => [\"banana\", \"apple\", \"orange\"]}}\n\n assert get_and_update_in(map, [\"unknown\", by_index(3)], &{&1, []}) ==\n {:oops, %{\"fruits\" => [\"banana\", \"apple\", \"orange\"], \"unknown\" => []}}\n end\n\n test \"get_and_update_in/2\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert get_and_update_in(users[\"john\"].age, &{&1, &1 + 1}) ==\n {27, %{\"john\" => %{age: 28}, \"meg\" => %{age: 23}}}\n\n struct = %StructAccess{foo: %StructAccess{bar: 41}}\n\n assert get_and_update_in(struct.foo.bar, &{&1, &1 + 1}) ==\n {41, %StructAccess{bar: nil, foo: %StructAccess{bar: 42, foo: nil}}}\n\n assert_raise ArgumentError, \"could not put/update key \\\"john\\\" on a nil value\", fn ->\n get_and_update_in(nil[\"john\"][:age], fn nil -> {:ok, 28} end)\n end\n\n assert_raise BadMapError, fn ->\n get_and_update_in(users[\"dave\"].age, &{&1, &1 + 1})\n end\n\n assert_raise KeyError, fn ->\n get_and_update_in(users[\"meg\"].unknown, &{&1, &1 + 1})\n end\n end\n\n test \"pop_in/2\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert pop_in(users, [\"john\", :age]) ==\n {27, %{\"john\" => %{}, \"meg\" => %{age: 23}}}\n\n assert pop_in(users, [\"bob\", :age]) ==\n {nil, %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}}\n\n assert pop_in([], [:foo, :bar]) ==\n {nil, []}\n end\n\n test \"pop_in/2 with paths\" do\n map = %{\"fruits\" => [\"banana\", \"apple\", \"orange\"]}\n\n assert pop_in(map, [\"fruits\", by_index(0)]) ==\n {\"banana\", %{\"fruits\" => [\"apple\", \"orange\"]}}\n\n assert pop_in(map, [\"fruits\", by_index(3)]) == {nil, map}\n\n map = %{\"fruits\" => [%{name: \"banana\"}, %{name: \"apple\"}]}\n\n assert pop_in(map, [\"fruits\", by_index(0), :name]) ==\n {\"banana\", %{\"fruits\" => [%{}, %{name: \"apple\"}]}}\n\n assert pop_in(map, [\"fruits\", by_index(3), :name]) == {nil, map}\n end\n\n test \"pop_in/1\" do\n users = %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}\n\n assert pop_in(users[\"john\"]) == {%{age: 27}, %{\"meg\" => %{age: 23}}}\n\n assert pop_in(users[\"john\"][:age]) == {27, %{\"john\" => %{}, \"meg\" => %{age: 23}}}\n assert pop_in(users[\"john\"][:name]) == {nil, %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}}\n assert pop_in(users[\"bob\"][:age]) == {nil, %{\"john\" => %{age: 27}, \"meg\" => %{age: 23}}}\n\n users = %{john: [age: 27], meg: [age: 23]}\n\n assert pop_in(users.john[:age]) == {27, %{john: [], meg: [age: 23]}}\n assert pop_in(users.john[:name]) == {nil, %{john: [age: 27], meg: [age: 23]}}\n\n assert pop_in([][:foo][:bar]) == {nil, []}\n assert_raise KeyError, fn -> pop_in(users.bob[:age]) end\n end\n\n test \"pop_in/1,2 with nils\" do\n users = %{\"john\" => nil, \"meg\" => %{age: 23}}\n assert pop_in(users[\"john\"][:age]) == {nil, %{\"meg\" => %{age: 23}}}\n assert pop_in(users, [\"john\", :age]) == {nil, %{\"meg\" => %{age: 23}}}\n\n users = %{john: nil, meg: %{age: 23}}\n assert pop_in(users.john[:age]) == {nil, %{john: nil, meg: %{age: 23}}}\n assert pop_in(users, [:john, :age]) == {nil, %{meg: %{age: 23}}}\n\n x = nil\n assert_raise ArgumentError, fn -> pop_in(x[\"john\"][:age]) end\n assert_raise ArgumentError, fn -> pop_in(nil[\"john\"][:age]) end\n assert_raise ArgumentError, fn -> pop_in(nil, [\"john\", :age]) end\n end\n\n test \"with dynamic paths\" do\n map = empty_map()\n\n assert put_in(map[:foo], \"bar\") == %{foo: \"bar\"}\n assert put_in(empty_map()[:foo], \"bar\") == %{foo: \"bar\"}\n assert put_in(KernelTest.empty_map()[:foo], \"bar\") == %{foo: \"bar\"}\n assert put_in(__MODULE__.empty_map()[:foo], \"bar\") == %{foo: \"bar\"}\n\n assert_raise ArgumentError, ~r\"access at least one element,\", fn ->\n Code.eval_quoted(quote(do: put_in(map, \"bar\")), [])\n end\n\n assert_raise ArgumentError, ~r\"must start with a variable, local or remote call\", fn ->\n Code.eval_quoted(quote(do: put_in(map.foo(1, 2)[:bar], \"baz\")), [])\n end\n end\n\n def by_index(index) do\n fn\n :get, nil, _next ->\n raise \"won't be invoked\"\n\n :get, data, next ->\n next.(Enum.at(data, index))\n\n :get_and_update, nil, next ->\n next.(:oops)\n\n :get_and_update, data, next ->\n current = Enum.at(data, index)\n\n case next.(current) do\n {get, update} -> {get, List.replace_at(data, index, update)}\n :pop -> {current, List.delete_at(data, index)}\n end\n end\n end\n end\n\n describe \"pipeline\" do\n test \"simple\" do\n assert [1, [2], 3] |> List.flatten() == [1, 2, 3]\n end\n\n test \"nested\" do\n assert [1, [2], 3] |> List.flatten() |> Enum.map(&(&1 * 2)) == [2, 4, 6]\n end\n\n test \"local call\" do\n assert [1, [2], 3] |> List.flatten() |> local() == [2, 4, 6]\n end\n\n test \"with capture\" do\n assert Enum.map([1, 2, 3], &(&1 |> twice() |> twice())) == [4, 8, 12]\n end\n\n test \"with anonymous functions\" do\n assert 1 |> (&(&1 * 2)).() == 2\n assert [1] |> (&hd(&1)).() == 1\n end\n\n test \"reverse associativity\" do\n assert [1, [2], 3] |> (List.flatten() |> Enum.map(&(&1 * 2))) == [2, 4, 6]\n end\n\n defp twice(a), do: a * 2\n\n defp local(list) do\n Enum.map(list, &(&1 * 2))\n end\n end\n\n describe \"destructure\" do\n test \"less args\" do\n destructure [x, y, z], [1, 2, 3, 4, 5]\n assert x == 1\n assert y == 2\n assert z == 3\n end\n\n test \"more args\" do\n destructure [a, b, c, d, e], [1, 2, 3]\n assert a == 1\n assert b == 2\n assert c == 3\n assert d == nil\n assert e == nil\n end\n\n test \"equal args\" do\n destructure [a, b, c], [1, 2, 3]\n assert a == 1\n assert b == 2\n assert c == 3\n end\n\n test \"no values\" do\n destructure [a, b, c], []\n assert a == nil\n assert b == nil\n assert c == nil\n end\n\n test \"works as match\" do\n destructure [1, b, _], [1, 2, 3]\n assert b == 2\n end\n\n test \"nil values\" do\n destructure [a, b, c], a_nil()\n assert a == nil\n assert b == nil\n assert c == nil\n end\n\n test \"invalid match\" do\n a = List.first([3])\n\n assert_raise MatchError, fn ->\n destructure [^a, _b, _c], a_list()\n end\n end\n\n defp a_list, do: [1, 2, 3]\n defp a_nil, do: nil\n end\n\n describe \"use/2\" do\n import ExUnit.CaptureIO\n\n defmodule SampleA do\n defmacro __using__(opts) do\n prefix = Keyword.get(opts, :prefix, \"\")\n IO.puts(prefix <> \"A\")\n end\n end\n\n defmodule SampleB do\n defmacro __using__(_) do\n IO.puts(\"B\")\n end\n end\n\n test \"invalid argument is literal\" do\n message = \"invalid arguments for use, expected a compile time atom or alias, got: 42\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"use 42\")\n end\n end\n\n test \"invalid argument is variable\" do\n message = \"invalid arguments for use, expected a compile time atom or alias, got: variable\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"use variable\")\n end\n end\n\n test \"multi-call\" do\n assert capture_io(fn ->\n Code.eval_string(\"use KernelTest.{SampleA, SampleB,}\", [], __ENV__)\n end) == \"A\\nB\\n\"\n end\n\n test \"multi-call with options\" do\n assert capture_io(fn ->\n Code.eval_string(~S|use KernelTest.{SampleA}, prefix: \"-\"|, [], __ENV__)\n end) == \"-A\\n\"\n end\n\n test \"multi-call with unquote\" do\n assert capture_io(fn ->\n string = \"\"\"\n defmodule TestMod do\n def main() do\n use KernelTest.{SampleB, unquote(:SampleA)}\n end\n end\n \"\"\"\n\n Code.eval_string(string, [], __ENV__)\n end) == \"B\\nA\\n\"\n after\n purge(KernelTest.TestMod)\n end\n end\n\n test \"is_map_key/2\" do\n assert is_map_key(Map.new([]), :a) == false\n assert is_map_key(Map.new(b: 1), :a) == false\n assert is_map_key(Map.new(a: 1), :a) == true\n\n assert_raise BadMapError, fn ->\n is_map_key(Process.get(:unused, []), :a)\n end\n\n case Map.new(a: 1) do\n map when is_map_key(map, :a) -> true\n _ -> flunk(\"invalid guard\")\n end\n end\n\n test \"tap/1\" do\n import ExUnit.CaptureIO\n\n assert capture_io(fn ->\n tap(\"foo\", &IO.puts/1)\n end) == \"foo\\n\"\n\n assert 1 = tap(1, fn x -> x + 1 end)\n end\n\n test \"tl/1\" do\n assert tl([:one]) == []\n assert tl([1, 2, 3]) == [2, 3]\n assert_raise ArgumentError, fn -> tl(Process.get(:unused, [])) end\n\n assert tl([:a | :b]) == :b\n assert tl([:a, :b | :c]) == [:b | :c]\n end\n\n test \"hd/1\" do\n assert hd([1, 2, 3, 4]) == 1\n assert_raise ArgumentError, fn -> hd(Process.get(:unused, [])) end\n assert hd([1 | 2]) == 1\n end\n\n test \"floor/1\" do\n assert floor(1) === 1\n assert floor(1.0) === 1\n assert floor(0) === 0\n assert floor(0.0) === 0\n assert floor(-0.0) === 0\n assert floor(1.123) === 1\n assert floor(-10.123) === -11\n assert floor(-10) === -10\n assert floor(-10.0) === -10\n\n assert match?(x when floor(x) == 0, 0.2)\n end\n\n test \"ceil/1\" do\n assert ceil(1) === 1\n assert ceil(1.0) === 1\n assert ceil(0) === 0\n assert ceil(0.0) === 0\n assert ceil(-0.0) === 0\n assert ceil(1.123) === 2\n assert ceil(-10.123) === -10\n assert ceil(-10) === -10\n assert ceil(-10.0) === -10\n\n assert match?(x when ceil(x) == 1, 0.2)\n end\n\n test \"binary_slice/2\" do\n assert binary_slice(\"abc\", -1..0) == \"\"\n assert binary_slice(\"abc\", -5..-5) == \"\"\n assert binary_slice(\"x\", 0..0//2) == \"x\"\n assert binary_slice(\"abcde\", 1..3//2) == \"bd\"\n end\n\n test \"sigil_U/2\" do\n assert ~U[2015-01-13 13:00:07.123Z] == %DateTime{\n calendar: Calendar.ISO,\n day: 13,\n hour: 13,\n microsecond: {123_000, 3},\n minute: 0,\n month: 1,\n second: 7,\n std_offset: 0,\n time_zone: \"Etc/UTC\",\n utc_offset: 0,\n year: 2015,\n zone_abbr: \"UTC\"\n }\n\n assert_raise ArgumentError, ~r\"reason: :invalid_format\", fn ->\n Code.eval_string(~s{~U[2015-01-13 13:00]})\n end\n\n assert_raise ArgumentError, ~r\"reason: :invalid_format\", fn ->\n Code.eval_string(~s{~U[20150113 130007Z]})\n end\n\n assert_raise ArgumentError, ~r\"reason: :missing_offset\", fn ->\n Code.eval_string(~s{~U[2015-01-13 13:00:07]})\n end\n\n assert_raise ArgumentError, ~r\"reason: :non_utc_offset\", fn ->\n Code.eval_string(~s{~U[2015-01-13 13:00:07+00:30]})\n end\n end\n\n describe \"dbg/2\" do\n import ExUnit.CaptureIO\n\n test \"prints the given expression and returns its value\" do\n output = capture_io(fn -> assert dbg(List.duplicate(:foo, 3)) == [:foo, :foo, :foo] end)\n assert output =~ \"kernel_test.exs\"\n assert output =~ \"KernelTest\"\n assert output =~ \"List\"\n assert output =~ \"duplicate\"\n assert output =~ \":foo\"\n assert output =~ \"3\"\n end\n\n test \"prints the given expression with complex options\" do\n output = capture_io(fn -> assert dbg(123, [] ++ []) == 123 end)\n assert output =~ \"kernel_test.exs\"\n end\n\n test \"doesn't print any colors if :syntax_colors is []\" do\n output =\n capture_io(fn ->\n assert dbg(List.duplicate(:foo, 3), syntax_colors: []) == [:foo, :foo, :foo]\n end)\n\n assert output =~ \"kernel_test.exs\"\n assert output =~ \"KernelTest.\"\n assert output =~ \"List.duplicate(:foo, 3)\"\n assert output =~ \"[:foo, :foo, :foo]\"\n refute output =~ \"\\\\e[\"\n end\n\n test \"prints binding() if no arguments are given\" do\n my_var = 1\n my_other_var = :foo\n\n output = capture_io(fn -> dbg() end)\n\n assert output =~ \"binding()\"\n assert output =~ \"my_var:\"\n assert output =~ \"my_other_var:\"\n end\n\n test \"is not allowed in guards\" do\n message = \"invalid expression in guard, dbg is not allowed in guards\"\n\n assert_raise ArgumentError, Regex.compile!(message), fn ->\n defmodule DbgGuard do\n def dbg_guard() when dbg(1), do: true\n end\n end\n end\n\n test \"is not allowed in pattern matches\" do\n message = \"invalid expression in match, dbg is not allowed in patterns\"\n\n assert_eval_raise(ArgumentError, Regex.compile!(message), \"\"\"\n {:ok, dbg()} = make_ref()\n \"\"\")\n end\n end\n\n describe \"to_timeout/1\" do\n test \"works with keyword lists\" do\n assert to_timeout(hour: 2) == 1000 * 60 * 60 * 2\n assert to_timeout(minute: 74) == 1000 * 60 * 74\n assert to_timeout(second: 1293) == 1_293_000\n assert to_timeout(millisecond: 1_234_123) == 1_234_123\n\n assert to_timeout(hour: 2, minute: 30) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30\n assert to_timeout(minute: 30, hour: 2) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30\n assert to_timeout(minute: 74, second: 30) == 1000 * 60 * 74 + 1000 * 30\n end\n\n test \"raises on invalid values with keyword lists\" do\n for unit <- [:hour, :minute, :second, :millisecond],\n value <- [-1, 1.0, :not_an_int] do\n message =\n \"timeout component #{inspect(unit)} must be a non-negative integer, \" <>\n \"got: #{inspect(value)}\"\n\n assert_raise ArgumentError, message, fn -> to_timeout([{unit, value}]) end\n end\n end\n\n test \"raises on invalid keys with keyword lists\" do\n message =\n \"timeout component :not_a_unit is not a valid timeout component, valid values are: \" <>\n \":week, :day, :hour, :minute, :second, :millisecond\"\n\n assert_raise ArgumentError, message, fn -> to_timeout(minute: 3, not_a_unit: 1) end\n end\n\n test \"raises on duplicated components with keyword lists\" do\n assert_raise ArgumentError, \"timeout component :minute is duplicated\", fn ->\n to_timeout(minute: 3, hour: 2, minute: 1)\n end\n end\n\n test \"works with durations\" do\n assert to_timeout(Duration.new!(hour: 2)) == 1000 * 60 * 60 * 2\n assert to_timeout(Duration.new!(minute: 74)) == 1000 * 60 * 74\n assert to_timeout(Duration.new!(second: 1293)) == 1_293_000\n assert to_timeout(Duration.new!(microsecond: {1_234_123, 4})) == 1_234\n\n assert to_timeout(Duration.new!(hour: 2, minute: 30)) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30\n assert to_timeout(Duration.new!(minute: 30, hour: 2)) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30\n assert to_timeout(Duration.new!(minute: 74, second: 30)) == 1000 * 60 * 74 + 1000 * 30\n end\n\n test \"raises on durations with non-zero months or days\" do\n message = \"duration with a non-zero month cannot be reliably converted to timeouts\"\n\n assert_raise ArgumentError, message, fn ->\n to_timeout(Duration.new!(month: 3))\n end\n\n message = \"duration with a non-zero year cannot be reliably converted to timeouts\"\n\n assert_raise ArgumentError, message, fn ->\n to_timeout(Duration.new!(year: 1))\n end\n end\n\n test \"works with timeouts\" do\n assert to_timeout(1_000) == 1_000\n assert to_timeout(0) == 0\n assert to_timeout(:infinity) == :infinity\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/keyword_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule KeywordTest do\n use ExUnit.Case, async: true\n\n doctest Keyword\n\n test \"has a literal syntax\" do\n assert [B: 1] == [{:B, 1}]\n assert [foo?: :bar] == [{:foo?, :bar}]\n assert [||: 2, +: 1] == [{:||, 2}, {:+, 1}]\n assert [1, 2, three: :four] == [1, 2, {:three, :four}]\n end\n\n test \"is a :: operator on ambiguity\" do\n assert [{:\"::\", _, [{:a, _, _}, {:b, _, _}]}] = quote(do: [a :: b])\n end\n\n test \"supports optional comma\" do\n assert Code.eval_string(\"[a: 1, b: 2, c: 3,]\") == {[a: 1, b: 2, c: 3], []}\n end\n\n test \"implements (almost) all functions in Map\" do\n assert Map.__info__(:functions) -- Keyword.__info__(:functions) == [from_struct: 1]\n end\n\n test \"get_and_update/3 removes duplicates from the input keyword list\" do\n assert Keyword.get_and_update([a: 1, b: 2, a: 3], :a, fn value -> {value, value + 10} end) ==\n {1, [a: 11, b: 2]}\n end\n\n test \"get_and_update/3 raises on bad return value from the argument function\" do\n message = \"the given function must return a two-element tuple or :pop, got: 1\"\n\n assert_raise RuntimeError, message, fn ->\n Keyword.get_and_update([a: 1], :a, fn value -> value end)\n end\n\n message = \"the given function must return a two-element tuple or :pop, got: nil\"\n\n assert_raise RuntimeError, message, fn ->\n Keyword.get_and_update([], :a, fn value -> value end)\n end\n end\n\n test \"get_and_update!/3 removes duplicates from the input keyword list\" do\n assert Keyword.get_and_update!([a: 1, b: 2, a: 3], :a, fn value -> {value, value + 10} end) ==\n {1, [a: 11, b: 2]}\n end\n\n test \"get_and_update!/3 raises on bad return value from the argument function\" do\n message = \"the given function must return a two-element tuple or :pop, got: 1\"\n\n assert_raise RuntimeError, message, fn ->\n Keyword.get_and_update!([a: 1], :a, fn value -> value end)\n end\n end\n\n test \"update!\" do\n assert Keyword.update!([a: 1, b: 2, a: 3], :a, &(&1 * 2)) == [a: 2, b: 2]\n assert Keyword.update!([a: 1, b: 2, c: 3], :b, &(&1 * 2)) == [a: 1, b: 4, c: 3]\n end\n\n test \"replace\" do\n assert Keyword.replace([a: 1, b: 2, a: 3], :a, :new) == [a: :new, b: 2]\n assert Keyword.replace([a: 1, b: 2, a: 3], :a, 1) == [a: 1, b: 2]\n assert Keyword.replace([a: 1, b: 2, a: 3, b: 4], :a, 1) == [a: 1, b: 2, b: 4]\n assert Keyword.replace([a: 1, b: 2, c: 3, b: 4], :b, :new) == [a: 1, b: :new, c: 3]\n assert Keyword.replace([], :b, :new) == []\n assert Keyword.replace([a: 1, b: 2, a: 3], :c, :new) == [a: 1, b: 2, a: 3]\n end\n\n test \"replace!\" do\n assert Keyword.replace!([a: 1, b: 2, a: 3], :a, :new) == [a: :new, b: 2]\n assert Keyword.replace!([a: 1, b: 2, a: 3], :a, 1) == [a: 1, b: 2]\n assert Keyword.replace!([a: 1, b: 2, a: 3, b: 4], :a, 1) == [a: 1, b: 2, b: 4]\n assert Keyword.replace!([a: 1, b: 2, c: 3, b: 4], :b, :new) == [a: 1, b: :new, c: 3]\n\n assert_raise KeyError, \"key :b not found in:\\n\\n []\\n\", fn ->\n Keyword.replace!([], :b, :new)\n end\n\n assert_raise KeyError, \"key :c not found in:\\n\\n [a: 1, b: 2, a: 3]\\n\", fn ->\n Keyword.replace!([a: 1, b: 2, a: 3], :c, :new)\n end\n end\n\n test \"merge/2\" do\n assert Keyword.merge([a: 1, b: 2], c: 11, d: 12) == [a: 1, b: 2, c: 11, d: 12]\n assert Keyword.merge([], c: 11, d: 12) == [c: 11, d: 12]\n assert Keyword.merge([a: 1, b: 2], []) == [a: 1, b: 2]\n\n message = \"expected a keyword list as the first argument, got: [1, 2]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([1, 2], c: 11, d: 12)\n end\n\n message = \"expected a keyword list as the first argument, got: [1 | 2]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([1 | 2], c: 11, d: 12)\n end\n\n message = \"expected a keyword list as the second argument, got: [11, 12, 0]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([a: 1, b: 2], [11, 12, 0])\n end\n\n message = \"expected a keyword list as the second argument, got: [11 | 12]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([a: 1, b: 2], [11 | 12])\n end\n\n # duplicate keys in keywords1 are kept if key is not present in keywords2\n result = [a: 1, b: 2, a: 3, c: 11, d: 12]\n assert Keyword.merge([a: 1, b: 2, a: 3], c: 11, d: 12) == result\n\n result = [b: 2, a: 11]\n assert Keyword.merge([a: 1, b: 2, a: 3], a: 11) == result\n\n # duplicate keys in keywords2 are always kept\n result = [a: 1, b: 2, c: 11, c: 12, d: 13]\n assert Keyword.merge([a: 1, b: 2], c: 11, c: 12, d: 13) == result\n\n # any key in keywords1 is removed if key is present in keyword2\n result = [a: 1, b: 2, c: 11, c: 12, d: 13]\n assert Keyword.merge([a: 1, b: 2, c: 3, c: 4], c: 11, c: 12, d: 13) == result\n end\n\n test \"merge/3\" do\n fun = fn _key, value1, value2 -> value1 + value2 end\n\n assert Keyword.merge([a: 1, b: 2], [c: 11, d: 12], fun) == [a: 1, b: 2, c: 11, d: 12]\n assert Keyword.merge([], [c: 11, d: 12], fun) == [c: 11, d: 12]\n assert Keyword.merge([a: 1, b: 2], [], fun) == [a: 1, b: 2]\n\n message = \"expected a keyword list as the first argument, got: [1, 2]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([1, 2], [c: 11, d: 12], fun)\n end\n\n message = \"expected a keyword list as the first argument, got: [1 | 2]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([1 | 2], [c: 11, d: 12], fun)\n end\n\n message = \"expected a keyword list as the second argument, got: [{:x, 1}, :y, :z]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([a: 1, b: 2], [{:x, 1}, :y, :z], fun)\n end\n\n message = \"expected a keyword list as the second argument, got: [:x | :y]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([a: 1, b: 2], [:x | :y], fun)\n end\n\n message = \"expected a keyword list as the second argument, got: [{:x, 1} | :y]\"\n\n assert_raise ArgumentError, message, fn ->\n Keyword.merge([a: 1, b: 2], [{:x, 1} | :y], fun)\n end\n\n # duplicate keys in keywords1 are left untouched if key is not present in keywords2\n result = [a: 1, b: 2, a: 3, c: 11, d: 12]\n assert Keyword.merge([a: 1, b: 2, a: 3], [c: 11, d: 12], fun) == result\n\n result = [b: 2, a: 12]\n assert Keyword.merge([a: 1, b: 2, a: 3], [a: 11], fun) == result\n\n # duplicate keys in keywords2 are always kept\n result = [a: 1, b: 2, c: 11, c: 12, d: 13]\n assert Keyword.merge([a: 1, b: 2], [c: 11, c: 12, d: 13], fun) == result\n\n # every key in keywords1 is replaced with fun result if key is present in keyword2\n result = [a: 1, b: 2, c: 14, c: 54, d: 13]\n assert Keyword.merge([a: 1, b: 2, c: 3, c: 4], [c: 11, c: 50, d: 13], fun) == result\n end\n\n test \"merge/2 and merge/3 behave exactly the same way\" do\n fun = fn _key, _value1, value2 -> value2 end\n\n args = [\n {[a: 1, b: 2], [c: 11, d: 12]},\n {[], [c: 11, d: 12]},\n {[a: 1, b: 2], []},\n {[a: 1, b: 2, a: 3], [c: 11, d: 12]},\n {[a: 1, b: 2, a: 3], [a: 11]},\n {[a: 1, b: 2], [c: 11, c: 12, d: 13]},\n {[a: 1, b: 2, c: 3, c: 4], [c: 11, c: 12, d: 13]}\n ]\n\n args_error = [\n {[1, 2], [c: 11, d: 12]},\n {[1 | 2], [c: 11, d: 12]},\n {[a: 1, b: 2], [11, 12, 0]},\n {[a: 1, b: 2], [11 | 12]},\n {[a: 1, b: 2], [{:x, 1}, :y, :z]},\n {[a: 1, b: 2], [:x | :y]},\n {[a: 1, b: 2], [{:x, 1} | :y]}\n ]\n\n for {arg1, arg2} <- args do\n assert Keyword.merge(arg1, arg2) == Keyword.merge(arg1, arg2, fun)\n end\n\n for {arg1, arg2} <- args_error do\n error = assert_raise ArgumentError, fn -> Keyword.merge(arg1, arg2) end\n assert_raise ArgumentError, error.message, fn -> Keyword.merge(arg1, arg2, fun) end\n end\n end\n\n test \"validate/2 raises on invalid arguments\" do\n assert_raise ArgumentError,\n \"expected a keyword list as first argument, got invalid entry: :three\",\n fn -> Keyword.validate([:three], one: 1, two: 2) end\n\n assert_raise ArgumentError,\n \"expected the second argument to be a list of atoms or tuples, got: 3\",\n fn -> Keyword.validate([three: 3], [:three, 3, :two]) end\n end\n\n test \"split_with/2\" do\n assert Keyword.split_with([], fn {_k, v} -> rem(v, 2) == 0 end) == {[], []}\n\n assert Keyword.split_with([a: \"1\", a: 1, b: 2], fn {k, _v} -> k in [:a, :b] end) ==\n {[a: \"1\", a: 1, b: 2], []}\n\n assert Keyword.split_with([a: \"1\", a: 1, b: 2], fn {_k, v} -> v == 5 end) ==\n {[], [a: \"1\", a: 1, b: 2]}\n\n assert Keyword.split_with([a: \"1\", a: 1, b: 2], fn {k, v} -> k in [:a] and is_integer(v) end) ==\n {[a: 1], [a: \"1\", b: 2]}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/list/chars_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule List.Chars.AtomTest do\n use ExUnit.Case, async: true\n\n test \"basic\" do\n assert to_charlist(:foo) == ~c\"foo\"\n end\n\n test \"true false nil\" do\n assert to_charlist(false) == ~c\"false\"\n assert to_charlist(true) == ~c\"true\"\n assert to_charlist(nil) == ~c\"\"\n end\nend\n\ndefmodule List.Chars.BitStringTest do\n use ExUnit.Case, async: true\n\n test \"basic\" do\n assert to_charlist(\"foo\") == ~c\"foo\"\n end\nend\n\ndefmodule List.Chars.NumberTest do\n use ExUnit.Case, async: true\n\n test \"integer\" do\n assert to_charlist(1) == ~c\"1\"\n end\n\n test \"float\" do\n assert to_charlist(1.0) == ~c\"1.0\"\n end\nend\n\ndefmodule List.Chars.ListTest do\n use ExUnit.Case, async: true\n\n test \"basic\" do\n assert to_charlist([1, \"b\", 3]) == [1, \"b\", 3]\n end\nend\n" }, { "path": "lib/elixir/test/elixir/list_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule ListTest do\n use ExUnit.Case, async: true\n\n doctest List\n\n test \"cons cell precedence\" do\n assert [1 | List.flatten([2, 3])] == [1, 2, 3]\n end\n\n test \"optional comma\" do\n assert Code.eval_string(\"[1,]\") == {[1], []}\n assert Code.eval_string(\"[1, 2, 3,]\") == {[1, 2, 3], []}\n end\n\n test \"partial application\" do\n assert (&[&1, 2]).(1) == [1, 2]\n assert (&[&1, &2]).(1, 2) == [1, 2]\n assert (&[&2, &1]).(2, 1) == [1, 2]\n assert (&[&1 | &2]).(1, 2) == [1 | 2]\n assert (&[&1, &2 | &3]).(1, 2, 3) == [1, 2 | 3]\n end\n\n test \"delete/2\" do\n assert List.delete([:a, :b, :c], :a) == [:b, :c]\n assert List.delete([:a, :b, :c], :d) == [:a, :b, :c]\n assert List.delete([:a, :b, :b, :c], :b) == [:a, :b, :c]\n assert List.delete([], :b) == []\n end\n\n test \"wrap/1\" do\n assert List.wrap([1, 2, 3]) == [1, 2, 3]\n assert List.wrap(1) == [1]\n assert List.wrap(nil) == []\n end\n\n test \"flatten/1\" do\n assert List.flatten([1, 2, 3]) == [1, 2, 3]\n assert List.flatten([1, [2], 3]) == [1, 2, 3]\n assert List.flatten([[1, [2], 3]]) == [1, 2, 3]\n\n assert List.flatten([]) == []\n assert List.flatten([[]]) == []\n assert List.flatten([[], [[], []]]) == []\n end\n\n test \"flatten/2\" do\n assert List.flatten([1, 2, 3], [4, 5]) == [1, 2, 3, 4, 5]\n assert List.flatten([1, [2], 3], [4, 5]) == [1, 2, 3, 4, 5]\n assert List.flatten([[1, [2], 3]], [4, 5]) == [1, 2, 3, 4, 5]\n assert List.flatten([1, [], 2], [3, [], 4]) == [1, 2, 3, [], 4]\n end\n\n test \"foldl/3\" do\n assert List.foldl([1, 2, 3], 0, fn x, y -> x + y end) == 6\n assert List.foldl([1, 2, 3], 10, fn x, y -> x + y end) == 16\n assert List.foldl([1, 2, 3, 4], 0, fn x, y -> x - y end) == 2\n end\n\n test \"foldr/3\" do\n assert List.foldr([1, 2, 3], 0, fn x, y -> x + y end) == 6\n assert List.foldr([1, 2, 3], 10, fn x, y -> x + y end) == 16\n assert List.foldr([1, 2, 3, 4], 0, fn x, y -> x - y end) == -2\n end\n\n test \"duplicate/2\" do\n assert List.duplicate(1, 0) == []\n assert List.duplicate(1, 3) == [1, 1, 1]\n assert List.duplicate([1], 1) == [[1]]\n end\n\n test \"first/1\" do\n assert List.first([]) == nil\n assert List.first([1]) == 1\n assert List.first([1, 2, 3]) == 1\n end\n\n test \"first/2\" do\n assert List.first([], 1) == 1\n assert List.first([2], 1) == 2\n assert List.first([1, 2, 3], 1) == 1\n end\n\n test \"first!/1\" do\n assert List.first!([1]) == 1\n assert List.first!([1, 2, 3]) == 1\n\n assert_raise ArgumentError, \"attempted to get the first element of an empty list\", fn ->\n List.first!([])\n end\n end\n\n test \"last/1\" do\n assert List.last([]) == nil\n assert List.last([1]) == 1\n assert List.last([1, 2, 3]) == 3\n end\n\n test \"last/2\" do\n assert List.last([], 1) == 1\n assert List.last([2], 1) == 2\n assert List.last([1, 2, 3], 1) == 3\n end\n\n test \"last!/1\" do\n assert List.last!([1]) == 1\n assert List.last!([1, 2, 3]) == 3\n\n assert_raise ArgumentError, \"attempted to get the last element of an empty list\", fn ->\n List.last!([])\n end\n end\n\n test \"keyfind/4\" do\n assert List.keyfind([a: 1, b: 2], :a, 0) == {:a, 1}\n assert List.keyfind([a: 1, b: 2], 2, 1) == {:b, 2}\n assert List.keyfind([a: 1, b: 2], :c, 0) == nil\n end\n\n test \"keyreplace/4\" do\n assert List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3}) == [a: 3, b: 2]\n assert List.keyreplace([a: 1], :b, 0, {:b, 2}) == [a: 1]\n end\n\n test \"keysort/2\" do\n assert List.keysort([a: 4, b: 3, c: 5], 1) == [b: 3, a: 4, c: 5]\n assert List.keysort([a: 4, c: 1, b: 2], 0) == [a: 4, b: 2, c: 1]\n end\n\n test \"keysort/3 with stable sorting\" do\n collection = [\n {2, 4},\n {1, 5},\n {2, 2},\n {3, 1},\n {4, 3}\n ]\n\n # Stable sorting\n assert List.keysort(collection, 0) == [\n {1, 5},\n {2, 4},\n {2, 2},\n {3, 1},\n {4, 3}\n ]\n\n assert List.keysort(collection, 0) ==\n List.keysort(collection, 0, :asc)\n\n assert List.keysort(collection, 0, &\n List.starts_with?([1 | 2], [1 | 2])\n end\n end\n end\n\n describe \"ends_with?/2\" do\n test \"list and prefix are equal\" do\n assert List.ends_with?([], [])\n assert List.ends_with?([1], [1])\n assert List.ends_with?([1, 2, 3], [1, 2, 3])\n end\n\n test \"proper lists\" do\n refute List.ends_with?([2], [1, 2])\n assert List.ends_with?([1, 2, 3], [2, 3])\n refute List.ends_with?([2, 3, 4], [1, 2, 3, 4])\n end\n\n test \"list is empty\" do\n refute List.ends_with?([], [1])\n refute List.ends_with?([], [1, 2])\n end\n\n test \"prefix is empty\" do\n assert List.ends_with?([1], [])\n assert List.ends_with?([1, 2], [])\n assert List.ends_with?([1, 2, 3], [])\n end\n\n test \"only accepts proper lists\" do\n assert_raise ArgumentError, ~r/not a list/, fn ->\n List.ends_with?([1 | 2], [1 | 2])\n end\n end\n end\n\n test \"to_string/1\" do\n assert List.to_string([?æ, ?ß]) == \"æß\"\n assert List.to_string([?a, ?b, ?c]) == \"abc\"\n assert List.to_string([]) == \"\"\n assert List.to_string([[], []]) == \"\"\n\n assert_raise UnicodeConversionError, \"invalid code point 57343\", fn ->\n List.to_string([0xDFFF])\n end\n\n assert_raise UnicodeConversionError, \"invalid encoding starting at <<216, 0>>\", fn ->\n List.to_string([\"a\", \"b\", <<0xD800::size(16)>>])\n end\n\n assert_raise ArgumentError, ~r\"cannot convert the given list to a string\", fn ->\n List.to_string([:a, :b])\n end\n end\n\n test \"to_charlist/1\" do\n assert List.to_charlist([0x00E6, 0x00DF]) == ~c\"æß\"\n assert List.to_charlist([0x0061, \"bc\"]) == ~c\"abc\"\n assert List.to_charlist([0x0064, \"ee\", [~c\"p\"]]) == ~c\"deep\"\n\n assert_raise UnicodeConversionError, \"invalid code point 57343\", fn ->\n List.to_charlist([0xDFFF])\n end\n\n assert_raise UnicodeConversionError, \"invalid encoding starting at <<216, 0>>\", fn ->\n List.to_charlist([\"a\", \"b\", <<0xD800::size(16)>>])\n end\n\n assert_raise ArgumentError, ~r\"cannot convert the given list to a charlist\", fn ->\n List.to_charlist([:a, :b])\n end\n end\n\n describe \"myers_difference/2\" do\n test \"follows paper implementation\" do\n assert List.myers_difference([], []) == []\n assert List.myers_difference([], [1, 2, 3]) == [ins: [1, 2, 3]]\n assert List.myers_difference([1, 2, 3], []) == [del: [1, 2, 3]]\n assert List.myers_difference([1, 2, 3], [1, 2, 3]) == [eq: [1, 2, 3]]\n assert List.myers_difference([1, 2, 3], [1, 4, 2, 3]) == [eq: [1], ins: [4], eq: [2, 3]]\n assert List.myers_difference([1, 4, 2, 3], [1, 2, 3]) == [eq: [1], del: [4], eq: [2, 3]]\n assert List.myers_difference([1], [[1]]) == [del: [1], ins: [[1]]]\n assert List.myers_difference([[1]], [1]) == [del: [[1]], ins: [1]]\n end\n\n test \"rearranges inserts and equals for smaller diffs\" do\n assert List.myers_difference([3, 2, 0, 2], [2, 2, 0, 2]) ==\n [del: [3], ins: [2], eq: [2, 0, 2]]\n\n assert List.myers_difference([3, 2, 1, 0, 2], [2, 1, 2, 1, 0, 2]) ==\n [del: [3], ins: [2, 1], eq: [2, 1, 0, 2]]\n\n assert List.myers_difference([3, 2, 2, 1, 0, 2], [2, 2, 1, 2, 1, 0, 2]) ==\n [del: [3], eq: [2, 2, 1], ins: [2, 1], eq: [0, 2]]\n\n assert List.myers_difference([3, 2, 0, 2], [2, 2, 1, 0, 2]) ==\n [del: [3], eq: [2], ins: [2, 1], eq: [0, 2]]\n end\n end\n\n test \"improper?/1\" do\n assert List.improper?([1 | 2])\n assert List.improper?([1, 2, 3 | 4])\n refute List.improper?([])\n refute List.improper?([1])\n refute List.improper?([[1]])\n refute List.improper?([1, 2])\n refute List.improper?([1, 2, 3])\n end\n\n describe \"ascii_printable?/2\" do\n test \"proper lists without limit\" do\n assert List.ascii_printable?([])\n assert List.ascii_printable?(~c\"abc\")\n refute(List.ascii_printable?(~c\"abc\" ++ [0]))\n refute List.ascii_printable?(~c\"mañana\")\n\n printable_chars = ~c\"\\a\\b\\t\\n\\v\\f\\r\\e\" ++ Enum.to_list(32..126)\n non_printable_chars = ~c\"🌢áéíóúźç©¢🂭\"\n\n assert List.ascii_printable?(printable_chars)\n\n for char <- printable_chars do\n assert List.ascii_printable?([char])\n end\n\n refute List.ascii_printable?(non_printable_chars)\n\n for char <- non_printable_chars do\n refute List.ascii_printable?([char])\n end\n end\n\n test \"proper lists with limit\" do\n assert List.ascii_printable?([], 100)\n assert List.ascii_printable?(~c\"abc\" ++ [0], 2)\n end\n\n test \"improper lists\" do\n refute List.ascii_printable?(~c\"abc\" ++ ?d)\n assert List.ascii_printable?(~c\"abc\" ++ ?d, 3)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/macro/env_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule MacroEnvMacros do\n defmacro my_macro(arg) do\n quote do: foo(unquote(arg))\n end\n\n @deprecated \"this is deprecated\"\n defmacro my_deprecated_macro(arg), do: arg\nend\n\ndefmodule Macro.EnvTest do\n use ExUnit.Case, async: true\n\n import Macro.Env\n import ExUnit.CaptureIO\n\n alias List, as: CustomList, warn: false\n import MacroEnvMacros, warn: false\n\n def trace(event, _env) do\n send(self(), event)\n :ok\n end\n\n def meta, do: [file: \"some_file.exs\", line: 123]\n def env, do: %{__ENV__ | tracers: [__MODULE__], line: 456}\n\n doctest Macro.Env\n\n test \"inspect\" do\n assert inspect(__ENV__) =~ \"#Macro.Env<\"\n end\n\n test \"prune_compile_info\" do\n assert %Macro.Env{lexical_tracker: nil, tracers: []} =\n Macro.Env.prune_compile_info(%{__ENV__ | lexical_tracker: self(), tracers: [Foo]})\n end\n\n test \"stacktrace\" do\n env = %{__ENV__ | file: \"foo\", line: 12}\n\n assert Macro.Env.stacktrace(env) ==\n [{__MODULE__, :\"test stacktrace\", 1, [file: ~c\"foo\", line: 12]}]\n\n env = %{env | function: nil}\n\n assert Macro.Env.stacktrace(env) == [\n {__MODULE__, :__MODULE__, 0, [file: ~c\"foo\", line: 12]}\n ]\n\n env = %{env | module: nil}\n\n assert Macro.Env.stacktrace(env) ==\n [{:elixir_compiler, :__FILE__, 1, [file: ~c\"foo\", line: 12]}]\n end\n\n test \"context modules\" do\n defmodule Foo.Bar do\n assert __MODULE__ in __ENV__.context_modules\n end\n\n assert Foo.Bar in __ENV__.context_modules\n\n Code.compile_string(\"\"\"\n defmodule Foo.Bar.Compiled do\n true = __MODULE__ in __ENV__.context_modules\n end\n \"\"\")\n end\n\n test \"to_match/1\" do\n quote = quote(do: x in [])\n\n assert {:__block__, [], [{:=, [], [{:_, [], Kernel}, {:x, [], Macro.EnvTest}]}, false]} =\n Macro.expand_once(quote, __ENV__)\n\n assert Macro.expand_once(quote, Macro.Env.to_match(__ENV__)) == false\n end\n\n test \"prepend_tracer\" do\n assert %Macro.Env{tracers: [MyCustomTracer | _]} =\n Macro.Env.prepend_tracer(__ENV__, MyCustomTracer)\n end\n\n describe \"define_import/4\" do\n test \"with tracing\" do\n define_import(env(), meta(), List)\n assert_received {:import, _, List, []}\n\n define_import(env(), meta(), Integer, only: :macros, trace: false)\n refute_received {:import, _, Integer, _}\n end\n\n test \"with errors\" do\n message =\n \"invalid :only option for import, expected value to be an atom :functions, :macros, \" <>\n \"or a literal keyword list of function names with arity as values, got: \"\n\n assert define_import(env(), meta(), Integer, only: :unknown) ==\n {:error, message <> \":unknown\"}\n\n assert define_import(env(), meta(), Integer, only: [:unknown]) ==\n {:error, message <> \"[:unknown]\"}\n end\n\n test \"with warnings\" do\n assert capture_io(:stderr, fn ->\n define_import(env(), meta(), Integer, only: [is_odd: 1, is_odd: 1])\n end) =~ \"invalid :only option for import, is_odd/1 is duplicated\"\n\n assert {:ok, _env} =\n define_import(env(), meta(), Integer,\n only: [is_odd: 1, is_odd: 1],\n emit_warnings: false\n )\n end\n end\n\n describe \"expand_alias/4\" do\n test \"with tracing\" do\n {:alias, List} = expand_alias(env(), meta(), [:CustomList])\n assert_received {:alias_expansion, _, Elixir.CustomList, List}\n\n {:alias, List} = expand_alias(env(), meta(), [:CustomList], trace: false)\n refute_received {:alias_expansion, _, Elixir.CustomList, List}\n\n {:alias, List.Continues} = expand_alias(env(), meta(), [:CustomList, :Continues])\n assert_received {:alias_expansion, _, Elixir.CustomList, List}\n end\n end\n\n describe \"expand_require/6\" do\n test \"returns :error for functions and unknown modules\" do\n assert :error = expand_require(env(), meta(), List, :flatten, 1)\n assert :error = expand_require(env(), meta(), Unknown, :flatten, 1)\n end\n\n test \"returns :error for unrequired modules\" do\n assert :error = expand_require(env(), meta(), Integer, :is_odd, 1)\n end\n\n test \"expands required modules\" do\n assert {:macro, Integer, _} =\n expand_require(env(), [required: true] ++ meta(), Integer, :is_odd, 1)\n\n assert {:macro, Integer, _} =\n expand_require(%{env() | requires: [Integer]}, meta(), Integer, :is_odd, 1)\n\n assert {:macro, Integer, _} =\n expand_require(%{env() | module: Integer}, meta(), Integer, :is_odd, 1)\n end\n\n test \"expands with argument\" do\n {:macro, MacroEnvMacros, fun} = expand_require(env(), meta(), MacroEnvMacros, :my_macro, 1)\n assert fun.([], [quote(do: hello())]) == quote(do: foo(hello()))\n assert fun.([line: 789], [quote(do: hello())]) == quote(line: 789, do: foo(hello()))\n\n # do not propagate generated: true to arguments\n assert {:foo, outer_meta, [{:hello, inner_meta, []}]} =\n fun.([generated: true], [quote(do: hello())])\n\n assert outer_meta[:generated]\n refute inner_meta[:generated]\n end\n\n test \"with tracing and deprecations\" do\n message = \"MacroEnvMacros.my_deprecated_macro/1 is deprecated\"\n\n {:macro, MacroEnvMacros, fun} =\n expand_require(env(), meta(), MacroEnvMacros, :my_deprecated_macro, 1)\n\n assert capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message\n assert_received {:remote_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}\n\n {:macro, MacroEnvMacros, fun} =\n expand_require(env(), meta(), MacroEnvMacros, :my_deprecated_macro, 1,\n trace: false,\n check_deprecations: false\n )\n\n refute capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message\n refute_received {:remote_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}\n end\n end\n\n describe \"expand_import/5\" do\n test \"returns tagged :error for unknown imports\" do\n assert {:error, :not_found} = expand_import(env(), meta(), :flatten, 1)\n end\n\n test \"returns tagged :error for special forms\" do\n assert {:error, :not_found} = expand_import(env(), meta(), :case, 1)\n end\n\n test \"returns tagged :error for ambiguous\" do\n import Date, warn: false\n import Time, warn: false\n assert {:error, {:ambiguous, mods}} = expand_import(__ENV__, meta(), :new, 3)\n assert Enum.sort(mods) == [Date, Time]\n end\n\n test \"returns :function tuple\" do\n assert {:function, ExUnit.CaptureIO, :capture_io} =\n expand_import(env(), meta(), :capture_io, 1)\n end\n\n test \"expands with argument\" do\n {:macro, MacroEnvMacros, fun} = expand_import(env(), meta(), :my_macro, 1)\n assert fun.([], [quote(do: hello())]) == quote(do: foo(hello()))\n assert fun.([line: 789], [quote(do: hello())]) == quote(line: 789, do: foo(hello()))\n\n # do not propagate generated: true to arguments\n assert {:foo, outer_meta, [{:hello, inner_meta, []}]} =\n fun.([generated: true], [quote(do: hello())])\n\n assert outer_meta[:generated]\n refute inner_meta[:generated]\n end\n\n defmacro allow_locals_example, do: :ok\n\n test \"allow_locals\" do\n {:macro, Macro.EnvTest, fun} =\n expand_import(env(), meta(), :allow_locals_example, 0)\n\n assert fun.([], []) == :ok\n\n assert expand_import(env(), meta(), :allow_locals_example, 0, allow_locals: false) ==\n {:error, :not_found}\n\n assert expand_import(env(), meta(), :allow_locals_example, 0,\n allow_locals: fn -> send(self(), false) end\n ) ==\n {:error, :not_found}\n\n assert_received false\n end\n\n test \"with tracing and deprecations\" do\n message = \"MacroEnvMacros.my_deprecated_macro/1 is deprecated\"\n\n {:macro, MacroEnvMacros, fun} = expand_import(env(), meta(), :my_deprecated_macro, 1)\n\n assert capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message\n assert_received {:imported_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}\n\n {:macro, MacroEnvMacros, fun} =\n expand_import(env(), meta(), :my_deprecated_macro, 1,\n trace: false,\n check_deprecations: false\n )\n\n refute capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message\n refute_received {:imported_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/macro_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule Macro.ExternalTest do\n defmacro external do\n line = 18\n file = __ENV__.file\n ^line = __CALLER__.line\n ^file = __CALLER__.file\n ^line = Macro.Env.location(__CALLER__)[:line]\n ^file = Macro.Env.location(__CALLER__)[:file]\n end\n\n defmacro oror(left, right) do\n quote(do: unquote(left) || unquote(right))\n end\nend\n\ndefmodule CustomIf do\n def if(_cond, _expr) do\n \"custom if result\"\n end\nend\n\ndefmodule MacroTest do\n use ExUnit.Case, async: true\n doctest Macro\n\n # Changing the lines above will make compilation\n # fail since we are asserting on the caller lines\n import Macro.ExternalTest\n\n describe \"escape/2\" do\n test \"returns tuples with size equal to two\" do\n assert Macro.escape({:a, :b}) == {:a, :b}\n end\n\n test \"returns lists\" do\n assert Macro.escape([1, 2, 3]) == [1, 2, 3]\n end\n\n test \"escapes tuples with size different than two\" do\n assert Macro.escape({:a}) == {:{}, [], [:a]}\n assert Macro.escape({:a, :b, :c}) == {:{}, [], [:a, :b, :c]}\n assert Macro.escape({:a, {1, 2, 3}, :c}) == {:{}, [], [:a, {:{}, [], [1, 2, 3]}, :c]}\n\n # False positives\n assert Macro.escape({:quote, :foo, [:bar]}) == {:{}, [], [:quote, :foo, [:bar]]}\n assert Macro.escape({:quote, :foo, [:bar, :baz]}) == {:{}, [], [:quote, :foo, [:bar, :baz]]}\n end\n\n test \"escapes maps\" do\n assert Macro.escape(%{a: 1}) == {:%{}, [], [a: 1]}\n end\n\n test \"escapes bitstring\" do\n assert {:<<>>, [], args} = Macro.escape(<<300::12>>)\n assert [{:\"::\", [], [1, {:size, [], [4]}]}, {:\"::\", [], [\",\", {:binary, [], nil}]}] = args\n end\n\n test \"escapes recursively\" do\n assert Macro.escape([1, {:a, :b, :c}, 3]) == [1, {:{}, [], [:a, :b, :c]}, 3]\n end\n\n test \"escapes improper lists\" do\n assert Macro.escape([1 | 2]) == [{:|, [], [1, 2]}]\n assert Macro.escape([1, 2 | 3]) == [1, {:|, [], [2, 3]}]\n end\n\n test \"prunes metadata\" do\n meta = [nothing: :important, counter: 1]\n assert Macro.escape({:foo, meta, []}) == {:{}, [], [:foo, meta, []]}\n assert Macro.escape({:foo, meta, []}, prune_metadata: true) == {:{}, [], [:foo, [], []]}\n end\n\n test \"with unquote\" do\n contents = quote(unquote: false, do: unquote(1))\n assert Macro.escape(contents, unquote: true) == 1\n\n contents = quote(unquote: false, do: unquote(x))\n assert Macro.escape(contents, unquote: true) == {:x, [], MacroTest}\n\n contents = %{foo: quote(unquote: false, do: unquote(1))}\n assert Macro.escape(contents, unquote: true) == {:%{}, [], [foo: 1]}\n end\n\n test \"with generated\" do\n assert Macro.escape(%{a: {}}, generated: true) ==\n {:%{}, [generated: true], [a: {:{}, [], []}]}\n end\n\n defp eval_escaped(contents) do\n {eval, []} = Code.eval_quoted(Macro.escape(contents, unquote: true))\n eval\n end\n\n test \"with remote unquote\" do\n contents = quote(unquote: false, do: Kernel.unquote(:is_atom)(:ok))\n assert eval_escaped(contents) == quote(do: Kernel.is_atom(:ok))\n assert eval_escaped(%{foo: contents}) == %{foo: quote(do: Kernel.is_atom(:ok))}\n end\n\n test \"with nested unquote\" do\n contents =\n quote do\n quote(do: unquote(x))\n end\n\n assert eval_escaped(contents) == quote(do: quote(do: unquote(x)))\n end\n\n test \"with alias or no arguments remote unquote\" do\n contents = quote(unquote: false, do: Kernel.unquote(:self)())\n assert eval_escaped(contents) == quote(do: Kernel.self())\n\n contents = quote(unquote: false, do: x.unquote(Foo))\n assert eval_escaped(contents) == quote(do: x.unquote(Foo))\n end\n\n test \"with splicing\" do\n contents = quote(unquote: false, do: [1, 2, 3, 4, 5])\n assert Macro.escape(contents, unquote: true) == [1, 2, 3, 4, 5]\n\n contents = quote(unquote: false, do: [1, 2, unquote_splicing([3, 4, 5])])\n assert eval_escaped(contents) == [1, 2, 3, 4, 5]\n\n contents = quote(unquote: false, do: [unquote_splicing([1, 2, 3]), 4, 5])\n assert eval_escaped(contents) == [1, 2, 3, 4, 5]\n\n contents =\n quote(unquote: false, do: [unquote_splicing([1, 2, 3]), unquote_splicing([4, 5])])\n\n assert eval_escaped(contents) == [1, 2, 3, 4, 5]\n\n contents =\n quote(unquote: false, do: [1, unquote_splicing([2]), 3, unquote_splicing([4]), 5])\n\n assert eval_escaped(contents) == [1, 2, 3, 4, 5]\n\n contents =\n quote(unquote: false, do: [1, unquote_splicing([2]), 3, unquote_splicing([4]) | [5]])\n\n assert eval_escaped(contents) == [1, 2, 3, 4, 5]\n\n contents = %{foo: quote(unquote: false, do: [1, 2, unquote_splicing([3, 4, 5])])}\n assert eval_escaped(contents) == %{foo: [1, 2, 3, 4, 5]}\n end\n\n test \"does not add context to quote\" do\n assert Macro.escape({:quote, [], [[do: :foo]]}) == {:{}, [], [:quote, [], [[do: :foo]]]}\n end\n\n test \"escapes the content of :quote tuples\" do\n assert Macro.escape({:quote, [%{}], [{}]}) ==\n {:{}, [], [:quote, [{:%{}, [], []}], [{:{}, [], []}]]}\n\n assert Macro.escape([:foo, {:quote, [%{}], [{}]}]) ==\n [:foo, {:{}, [], [:quote, [{:%{}, [], []}], [{:{}, [], []}]]}]\n end\n\n @tag :re_import\n test \"escape regex will remove references and replace it by a call to :re.import/1\" do\n assert {\n :%{},\n [],\n [\n __struct__: Regex,\n re_pattern:\n {{:., [], [{:__aliases__, _, [:Regex]}, :__import_pattern__]},\n [required: true], [{:{}, [], [:re_exported_pattern | _]}]},\n source: \"foo\",\n opts: []\n ]\n } = Macro.escape(~r/foo/)\n end\n\n @tag :re_import\n test \"escape raises within structs fields\" do\n assert_raise ArgumentError,\n ~r\"Regex defines custom escaping rules which are not supported in struct defaults\",\n fn ->\n defmodule Test do\n defstruct my_regex: ~r/^hi$/\n end\n end\n end\n\n defmodule EscapedStruct do\n defstruct [:ast, :ref]\n\n def __escape__(%{ast: ast}), do: ast\n end\n\n test \"escape struct with custom __escape__ (valid AST)\" do\n struct = %EscapedStruct{ast: {:valid_ast, [], []}, ref: make_ref()}\n\n assert {:valid_ast, [], []} = Macro.escape(struct)\n end\n\n test \"escape struct with custom __escape__ (shallow invalid AST)\" do\n struct = %EscapedStruct{ast: %{invalid: :ast}, ref: make_ref()}\n\n assert_raise ArgumentError,\n \"MacroTest.EscapedStruct.__escape__/1 returned invalid AST: %{invalid: :ast}\",\n fn -> Macro.escape(struct) end\n end\n end\n\n describe \"expand_once/2\" do\n test \"with external macro\" do\n assert {:||, _, [1, false]} = Macro.expand_once(quote(do: oror(1, false)), __ENV__)\n end\n\n test \"with raw atom\" do\n assert Macro.expand_once(quote(do: :foo), __ENV__) == :foo\n end\n\n test \"with current module\" do\n assert Macro.expand_once(quote(do: __MODULE__), __ENV__) == __MODULE__\n end\n\n test \"with main\" do\n assert Macro.expand_once(quote(do: Elixir), __ENV__) == Elixir\n end\n\n test \"with simple alias\" do\n assert Macro.expand_once(quote(do: Foo), __ENV__) == Foo\n end\n\n test \"with current module plus alias\" do\n assert Macro.expand_once(quote(do: __MODULE__.Foo), __ENV__) == __MODULE__.Foo\n end\n\n test \"with main plus alias\" do\n assert Macro.expand_once(quote(do: Elixir.Foo), __ENV__) == Foo\n end\n\n test \"with custom alias\" do\n alias Foo, as: Bar\n assert Macro.expand_once(quote(do: Bar.Baz), __ENV__) == Foo.Baz\n end\n\n test \"with main plus custom alias\" do\n alias Foo, as: Bar, warn: false\n assert Macro.expand_once(quote(do: Elixir.Bar.Baz), __ENV__) == Elixir.Bar.Baz\n end\n\n test \"with call in alias\" do\n assert Macro.expand_once(quote(do: Foo.bar().Baz), __ENV__) == quote(do: Foo.bar().Baz)\n end\n\n test \"env\" do\n env = %{__ENV__ | line: 0, lexical_tracker: self()}\n\n expanded = Macro.expand_once(quote(do: __ENV__), env)\n assert Macro.validate(expanded) == :ok\n assert Code.eval_quoted(expanded) == {env, []}\n\n assert Macro.expand_once(quote(do: __ENV__.file), env) == env.file\n assert Macro.expand_once(quote(do: __ENV__.unknown), env) == quote(do: __ENV__.unknown)\n\n expanded = Macro.expand_once(quote(do: __ENV__.versioned_vars), env)\n assert Macro.validate(expanded) == :ok\n assert Code.eval_quoted(expanded) == {env.versioned_vars, []}\n end\n\n test \"env in :match context does not expand\" do\n env = %{__ENV__ | line: 0, lexical_tracker: self(), context: :match}\n\n expanded = Macro.expand_once(quote(do: __ENV__), env)\n assert expanded == quote(do: __ENV__)\n\n expanded = Macro.expand_once(quote(do: __ENV__.file), env)\n assert expanded == quote(do: __ENV__.file)\n end\n\n defmacro local_macro(), do: raise(\"ignored\")\n\n test \"vars\" do\n expr = {:local_macro, [], nil}\n assert Macro.expand_once(expr, __ENV__) == expr\n end\n\n defp expand_once_and_clean(quoted, env) do\n cleaner = &Keyword.drop(&1, [:counter, :type_check, :generated])\n\n quoted\n |> Macro.expand_once(env)\n |> Macro.prewalk(&Macro.update_meta(&1, cleaner))\n end\n\n test \"with imported macro\" do\n temp_var = {:x, [], Kernel}\n\n quoted =\n quote context: Kernel do\n case 1 do\n unquote(temp_var)\n when :erlang.orelse(\n :erlang.\"=:=\"(unquote(temp_var), false),\n :erlang.\"=:=\"(unquote(temp_var), nil)\n ) ->\n false\n\n unquote(temp_var) ->\n unquote(temp_var)\n end\n end\n\n assert expand_once_and_clean(quote(do: 1 || false), __ENV__) == quoted\n end\n\n test \"with require macro\" do\n temp_var = {:x, [], Kernel}\n\n quoted =\n quote context: Kernel do\n case 1 do\n unquote(temp_var)\n when :erlang.orelse(\n :erlang.\"=:=\"(unquote(temp_var), false),\n :erlang.\"=:=\"(unquote(temp_var), nil)\n ) ->\n false\n\n unquote(temp_var) ->\n unquote(temp_var)\n end\n end\n\n assert expand_once_and_clean(quote(do: Kernel.||(1, false)), __ENV__) == quoted\n end\n\n test \"with not expandable expression\" do\n expr = quote(do: other(1, 2, 3))\n assert Macro.expand_once(expr, __ENV__) == expr\n end\n\n test \"propagates :generated\" do\n assert {:||, meta, [1, false]} = Macro.expand_once(quote(do: oror(1, false)), __ENV__)\n refute meta[:generated]\n\n assert {:||, meta, [1, false]} =\n Macro.expand_once(quote(generated: true, do: oror(1, false)), __ENV__)\n\n assert meta[:generated]\n end\n\n test \"does not propagate :generated to unquoted\" do\n non_generated = quote do: foo()\n\n assert {:||, outer_meta, [{:foo, inner_meta, []}, false]} =\n Macro.expand_once(\n quote generated: true do\n oror(unquote(non_generated), false)\n end,\n __ENV__\n )\n\n assert outer_meta[:generated]\n refute inner_meta[:generated]\n end\n\n defmacro foo_bar(x) do\n y = quote do: bar(unquote(x))\n\n quote do: foo(unquote(y))\n end\n\n test \"propagates :generated to unquote within macro\" do\n non_generated = quote do: baz()\n\n assert {:foo, foo_meta, [{:bar, bar_meta, [{:baz, baz_meta, []}]}]} =\n Macro.expand_once(\n quote(generated: true, do: foo_bar(unquote(non_generated))),\n __ENV__\n )\n\n assert foo_meta[:generated]\n assert bar_meta[:generated]\n refute baz_meta[:generated]\n end\n\n test \"does not expand module attributes\" do\n message =\n \"could not call Module.get_attribute/2 because the module #{inspect(__MODULE__)} \" <>\n \"is already compiled. Use the Module.__info__/1 callback or Code.fetch_docs/1 instead\"\n\n assert_raise ArgumentError, message, fn ->\n Macro.expand_once(quote(do: @foo), __ENV__)\n end\n end\n end\n\n defp expand_and_clean(quoted, env) do\n cleaner = &Keyword.drop(&1, [:counter, :type_check, :generated])\n\n quoted\n |> Macro.expand(env)\n |> Macro.prewalk(&Macro.update_meta(&1, cleaner))\n end\n\n test \"expand/2\" do\n temp_var = {:x, [], Kernel}\n\n quoted =\n quote context: Kernel do\n case 1 do\n unquote(temp_var)\n when :erlang.orelse(\n :erlang.\"=:=\"(unquote(temp_var), false),\n :erlang.\"=:=\"(unquote(temp_var), nil)\n ) ->\n false\n\n unquote(temp_var) ->\n unquote(temp_var)\n end\n end\n\n assert expand_and_clean(quote(do: oror(1, false)), __ENV__) == quoted\n end\n\n test \"expand_literals/2\" do\n assert Macro.expand_literals(quote(do: Foo), __ENV__) == Foo\n assert Macro.expand_literals(quote(do: Foo + Bar), __ENV__) == quote(do: Foo + Bar)\n assert Macro.expand_literals(quote(do: __MODULE__), __ENV__) == __MODULE__\n assert Macro.expand_literals(quote(do: __MODULE__.Foo), __ENV__) == __MODULE__.Foo\n assert Macro.expand_literals(quote(do: [Foo, 1 + 2]), __ENV__) == [Foo, quote(do: 1 + 2)]\n end\n\n test \"expand_literals/3\" do\n fun = fn node, acc ->\n expanded = Macro.expand(node, __ENV__)\n {expanded, [expanded | acc]}\n end\n\n assert Macro.expand_literals(quote(do: Foo), [], fun) == {Foo, [Foo]}\n assert Macro.expand_literals(quote(do: Foo + Bar), [], fun) == {quote(do: Foo + Bar), []}\n assert Macro.expand_literals(quote(do: __MODULE__), [], fun) == {__MODULE__, [__MODULE__]}\n\n assert Macro.expand_literals(quote(do: __MODULE__.Foo), [], fun) ==\n {__MODULE__.Foo, [__MODULE__.Foo, __MODULE__]}\n end\n\n test \"var/2\" do\n assert Macro.var(:foo, nil) == {:foo, [], nil}\n assert Macro.var(:foo, Other) == {:foo, [], Other}\n end\n\n describe \"dbg/3\" do\n defmacrop dbg_format_no_newline(ast, options \\\\ quote(do: [syntax_colors: []])) do\n quote do\n ExUnit.CaptureIO.with_io(fn ->\n try do\n unquote(Macro.dbg(ast, options, __CALLER__))\n rescue\n e -> e\n end\n end)\n end\n end\n\n defmacrop dbg_format(ast, options \\\\ quote(do: [syntax_colors: []])) do\n quote do\n {result, formatted} =\n dbg_format_no_newline(unquote(ast), unquote(options))\n\n # Make sure there's an empty line after the output.\n assert String.ends_with?(formatted, \"\\n\\n\") or\n String.ends_with?(formatted, \"\\n\\n\" <> IO.ANSI.reset())\n\n {result, formatted}\n end\n end\n\n test \"simple expression\" do\n {result, formatted} = dbg_format(1 + 1)\n assert result == 2\n assert formatted =~ \"1 + 1 #=> 2\"\n end\n\n test \"variables\" do\n my_var = 1 + 1\n {result, formatted} = dbg_format(my_var)\n assert result == 2\n assert formatted =~ \"my_var #=> 2\"\n end\n\n test \"function call\" do\n {result, formatted} = dbg_format(Atom.to_string(:foo))\n\n assert result == \"foo\"\n assert formatted =~ ~s[Atom.to_string(:foo) #=> \"foo\"]\n end\n\n test \"multiline input\" do\n {result, formatted} =\n dbg_format(\n case 1 + 1 do\n 2 -> :two\n _other -> :math_is_broken\n end\n )\n\n assert result == :two\n\n assert formatted =~ \"\"\"\n case 1 + 1 do\n 2 -> :two\n _other -> :math_is_broken\n end #=> :two\n \"\"\"\n end\n\n defp abc, do: [:a, :b, :c]\n\n test \"pipeline on a single line\" do\n {result, formatted} = dbg_format(abc() |> tl() |> tl |> Kernel.hd())\n assert result == :c\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n \\nabc() #=> [:a, :b, :c]\n |> tl() #=> [:b, :c]\n |> tl #=> [:c]\n |> Kernel.hd() #=> :c\n \"\"\"\n\n # Regression for pipes sometimes erroneously ending with three newlines (one\n # extra than needed).\n assert formatted =~ ~r/[^\\n]\\n\\n$/\n end\n\n test \"pipeline on multiple lines\" do\n {result, formatted} =\n dbg_format(\n abc()\n |> tl()\n |> tl\n |> Kernel.hd()\n )\n\n assert result == :c\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n \\nabc() #=> [:a, :b, :c]\n |> tl() #=> [:b, :c]\n |> tl #=> [:c]\n |> Kernel.hd() #=> :c\n \"\"\"\n\n # Regression for pipes sometimes erroneously ending with three newlines (one\n # extra than needed).\n assert formatted =~ ~r/[^\\n]\\n\\n$/\n end\n\n test \"pipeline on multiple lines that raises\" do\n {result, formatted} =\n dbg_format_no_newline(\n abc()\n |> tl()\n |> tl()\n |> tl()\n |> tl()\n )\n\n assert %ArgumentError{} = result\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n abc() #=> [:a, :b, :c]\n |> tl() #=> [:b, :c]\n |> tl() #=> [:c]\n |> tl() #=> []\n \"\"\"\n end\n\n test \"simple boolean expressions\" do\n {result, formatted} = dbg_format(:rand.uniform() < 0.0 and length([]) == 0)\n assert result == false\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n :rand.uniform() < 0.0 #=> false\n :rand.uniform() < 0.0 and length([]) == 0 #=> false\n \"\"\"\n end\n\n test \"left-associative operators\" do\n {result, formatted} =\n dbg_format(List.first([]) || Process.get(:unknown, \"yes\") || raise(\"foo\"))\n\n assert result == \"yes\"\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n List.first([]) #=> nil\n List.first([]) || Process.get(:unknown, \"yes\") #=> \"yes\"\n List.first([]) || Process.get(:unknown, \"yes\") || raise \"foo\" #=> \"yes\"\n \"\"\"\n end\n\n test \"composite boolean expressions\" do\n true1 = length([]) == 0\n true2 = length([]) == 0\n {result, formatted} = dbg_format((true1 and true2) or (List.first([]) || true1))\n\n assert result == true\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n true1 #=> true\n true1 and true2 #=> true\n (true1 and true2) or (List.first([]) || true1) #=> true\n \"\"\"\n end\n\n test \"boolean expressions that raise\" do\n falsy = length([]) != 0\n x = 0\n\n {result, formatted} = dbg_format_no_newline((falsy || x) && 1 / x)\n\n assert %ArithmeticError{} = result\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n falsy #=> false\n falsy || x #=> 0\n \"\"\"\n end\n\n test \"block of code\" do\n {result, formatted} =\n dbg_format(\n (\n a = 1\n b = a + 2\n a + b\n )\n )\n\n assert result == 4\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n a = 1 #=> 1\n b = a + 2 #=> 3\n a + b #=> 4\n \"\"\"\n end\n\n test \"block that raises\" do\n {result, formatted} =\n dbg_format_no_newline(\n (\n a = 1\n b = a - 1\n a / b\n )\n )\n\n assert result == %ArithmeticError{}\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n a = 1 #=> 1\n b = a - 1 #=> 0\n \"\"\"\n end\n\n test \"case\" do\n list = List.flatten([1, 2, 3])\n\n {result, formatted} =\n dbg_format(\n case list do\n [] -> nil\n _ -> Enum.sum(list)\n end\n )\n\n assert result == 6\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n Case argument:\n list #=> [1, 2, 3]\n\n Case expression (clause #2 matched):\n case list do\n [] -> nil\n _ -> Enum.sum(list)\n end #=> 6\n \"\"\"\n end\n\n test \"case that raises\" do\n x = true\n\n {result, formatted} =\n dbg_format(\n case true and x do\n true -> raise \"oops\"\n false -> :ok\n end\n )\n\n assert %RuntimeError{} = result\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n Case argument:\n true and x #=> true\n \"\"\"\n end\n\n test \"case with guards\" do\n {result, formatted} =\n dbg_format(\n case 0..100//5 do\n %{first: first, last: last, step: step} when last > first ->\n count = div(last - first, step)\n {:ok, count}\n\n _ ->\n :error\n end\n )\n\n assert result == {:ok, 20}\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n Case argument:\n 0..100//5 #=> 0..100//5\n\n Case expression (clause #1 matched):\n case 0..100//5 do\n %{first: first, last: last, step: step} when last > first ->\n count = div(last - first, step)\n {:ok, count}\n\n _ ->\n :error\n end #=> {:ok, 20}\n \"\"\"\n end\n\n test \"cond\" do\n map = %{b: 5}\n\n {result, formatted} =\n dbg_format(\n cond do\n a = map[:a] -> a + 1\n b = map[:b] -> b * 2\n true -> nil\n end\n )\n\n assert result == 10\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n Cond clause (clause #2 matched):\n b = map[:b] #=> 5\n\n Cond expression:\n cond do\n a = map[:a] -> a + 1\n b = map[:b] -> b * 2\n true -> nil\n end #=> 10\n \"\"\"\n end\n\n test \"if expression\" do\n x = true\n map = %{a: 5, b: 1}\n\n {result, formatted} =\n dbg_format(\n if true and x do\n map[:a] * 2\n else\n map[:b]\n end\n )\n\n assert result == 10\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n If condition:\n true and x #=> true\n\n If expression:\n if true and x do\n map[:a] * 2\n else\n map[:b]\n end #=> 10\n \"\"\"\n end\n\n test \"if expression that raises\" do\n x = true\n\n {result, formatted} =\n dbg_format(\n if true and x do\n raise \"oops\"\n end\n )\n\n assert %RuntimeError{} = result\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n If condition:\n true and x #=> true\n \"\"\"\n end\n\n test \"if expression without else\" do\n x = true\n map = %{a: 5, b: 1}\n\n {result, formatted} =\n dbg_format(\n if false and x do\n map[:a] * 2\n end\n )\n\n assert result == nil\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n If condition:\n false and x #=> false\n\n If expression:\n if false and x do\n map[:a] * 2\n end #=> nil\n \"\"\"\n end\n\n test \"custom if definition\" do\n import Kernel, except: [if: 2]\n import CustomIf, only: [if: 2]\n\n {result, formatted} =\n dbg_format(\n if true do\n \"something\"\n end\n )\n\n assert result == \"custom if result\"\n\n assert formatted =~ \"\"\"\n if true do\n \"something\"\n end #=> \"custom if result\"\n \"\"\"\n end\n\n test \"with/1 (all clauses match)\" do\n opts = Process.get(:unused, %{width: 10, height: 15})\n\n {result, formatted} =\n dbg_format(\n with {:ok, width} <- Map.fetch(opts, :width),\n double_width = width * 2,\n IO.puts(\"just a side effect\"),\n {:ok, height} <- Map.fetch(opts, :height) do\n {:ok, double_width * height}\n end\n )\n\n assert result == {:ok, 300}\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n With clauses:\n Map.fetch(opts, :width) #=> {:ok, 10}\n width * 2 #=> 20\n Map.fetch(opts, :height) #=> {:ok, 15}\n\n With expression:\n with {:ok, width} <- Map.fetch(opts, :width),\n double_width = width * 2,\n IO.puts(\"just a side effect\"),\n {:ok, height} <- Map.fetch(opts, :height) do\n {:ok, double_width * height}\n end #=> {:ok, 300}\n \"\"\"\n end\n\n test \"with/1 (no else)\" do\n opts = Process.get(:unused, %{width: 10})\n\n {result, formatted} =\n dbg_format(\n with {:ok, width} <- Map.fetch(opts, :width),\n {:ok, height} <- Map.fetch(opts, :height) do\n {:ok, width * height}\n end\n )\n\n assert result == :error\n\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n With clauses:\n Map.fetch(opts, :width) #=> {:ok, 10}\n Map.fetch(opts, :height) #=> :error\n\n With expression:\n with {:ok, width} <- Map.fetch(opts, :width),\n {:ok, height} <- Map.fetch(opts, :height) do\n {:ok, width * height}\n end #=> :error\n \"\"\"\n end\n\n test \"with/1 (else clause)\" do\n opts = Process.get(:unused, %{width: 10})\n\n {result, formatted} =\n dbg_format(\n with {:ok, width} <- Map.fetch(opts, :width),\n {:ok, height} <- Map.fetch(opts, :height) do\n width * height\n else\n :error -> 0\n end\n )\n\n assert result == 0\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n With clauses:\n Map.fetch(opts, :width) #=> {:ok, 10}\n Map.fetch(opts, :height) #=> :error\n\n With expression:\n with {:ok, width} <- Map.fetch(opts, :width),\n {:ok, height} <- Map.fetch(opts, :height) do\n width * height\n else\n :error -> 0\n end #=> 0\n \"\"\"\n end\n\n test \"with/1 (guard)\" do\n opts = Process.get(:unused, %{width: 10, height: 0.0})\n\n {result, formatted} =\n dbg_format(\n with {:ok, width} when is_integer(width) <- Map.fetch(opts, :width),\n {:ok, height} when is_integer(height) <- Map.fetch(opts, :height) do\n width * height\n else\n _ -> nil\n end\n )\n\n assert result == nil\n assert formatted =~ \"macro_test.exs\"\n\n assert formatted =~ \"\"\"\n With clauses:\n Map.fetch(opts, :width) #=> {:ok, 10}\n Map.fetch(opts, :height) #=> {:ok, 0.0}\n\n With expression:\n with {:ok, width} when is_integer(width) <- Map.fetch(opts, :width),\n {:ok, height} when is_integer(height) <- Map.fetch(opts, :height) do\n width * height\n else\n _ -> nil\n end #=> nil\n \"\"\"\n end\n\n test \"with/1 (guard in else)\" do\n opts = Process.get(:unused, %{})\n\n {result, _formatted} =\n dbg_format(\n with {:ok, width} <- Map.fetch(opts, :width) do\n width\n else\n other when is_integer(other) -> :int\n other when is_atom(other) -> :atom\n end\n )\n\n assert result == :atom\n end\n\n test \"with/1 respects the WithClauseError\" do\n value = Enum.random([:unexpected])\n\n error =\n assert_raise WithClauseError, fn ->\n ExUnit.CaptureIO.capture_io(fn ->\n dbg(\n with :ok <- value do\n true\n else\n :error -> false\n end\n )\n end)\n end\n\n assert error.term == :unexpected\n end\n\n test \"with \\\"syntax_colors: []\\\" it doesn't print any color sequences\" do\n {_result, formatted} = dbg_format(\"hello\")\n refute formatted =~ \"\\e[\"\n end\n\n test \"with \\\"syntax_colors: [...]\\\" it forces color sequences\" do\n {_result, formatted} = dbg_format(\"hello\", syntax_colors: [string: :cyan])\n assert formatted =~ IO.iodata_to_binary(IO.ANSI.format([:cyan, ~s(\"hello\")]))\n end\n\n test \"forwards options to the underlying inspect calls\" do\n value = ~c\"hello\"\n assert {^value, formatted} = dbg_format(value, syntax_colors: [], charlists: :as_lists)\n assert formatted =~ \"value #=> [104, 101, 108, 108, 111]\\n\"\n end\n\n test \"with the :print_location option set to false, doesn't print any header\" do\n {result, formatted} = dbg_format(\"hello\", print_location: false)\n assert result == \"hello\"\n refute formatted =~ Path.basename(__ENV__.file)\n end\n end\n\n describe \"to_string/1\" do\n test \"converts quoted to string\" do\n assert Macro.to_string(quote do: hello(world)) == \"hello(world)\"\n end\n\n test \"converts invalid AST with inspect\" do\n assert Macro.to_string(1..3) == \"1..3\"\n end\n end\n\n describe \"to_string/2\" do\n defp macro_to_string(var, fun \\\\ fn _ast, string -> string end) do\n module = String.to_atom(\"Elixir.Macro\")\n module.to_string(var, fun)\n end\n\n test \"variable\" do\n assert macro_to_string(quote(do: foo)) == \"foo\"\n end\n\n test \"local call\" do\n assert macro_to_string(quote(do: foo(1, 2, 3))) == \"foo(1, 2, 3)\"\n assert macro_to_string(quote(do: foo([1, 2, 3]))) == \"foo([1, 2, 3])\"\n end\n\n test \"remote call\" do\n assert macro_to_string(quote(do: foo.bar(1, 2, 3))) == \"foo.bar(1, 2, 3)\"\n assert macro_to_string(quote(do: foo.bar([1, 2, 3]))) == \"foo.bar([1, 2, 3])\"\n\n quoted =\n quote do\n (foo do\n :ok\n end).bar([1, 2, 3])\n end\n\n assert macro_to_string(quoted) == \"(foo do\\n :ok\\nend).bar([1, 2, 3])\"\n end\n\n test \"nullary remote call\" do\n assert macro_to_string(quote do: foo.bar) == \"foo.bar\"\n assert macro_to_string(quote do: foo.bar()) == \"foo.bar()\"\n end\n\n test \"atom remote call\" do\n assert macro_to_string(quote(do: :foo.bar(1, 2, 3))) == \":foo.bar(1, 2, 3)\"\n end\n\n test \"remote and fun call\" do\n assert macro_to_string(quote(do: foo.bar().(1, 2, 3))) == \"foo.bar().(1, 2, 3)\"\n assert macro_to_string(quote(do: foo.bar().([1, 2, 3]))) == \"foo.bar().([1, 2, 3])\"\n end\n\n test \"unusual remote atom fun call\" do\n assert macro_to_string(quote(do: Foo.\"42\"())) == ~s/Foo.\"42\"()/\n assert macro_to_string(quote(do: Foo.\"Bar\"())) == ~s/Foo.\"Bar\"()/\n assert macro_to_string(quote(do: Foo.\"bar baz\"().\"\"())) == ~s/Foo.\"bar baz\"().\"\"()/\n assert macro_to_string(quote(do: Foo.\"%{}\"())) == ~s/Foo.\"%{}\"()/\n assert macro_to_string(quote(do: Foo.\"...\"())) == ~s/Foo.\"...\"()/\n end\n\n test \"atom fun call\" do\n assert macro_to_string(quote(do: :foo.(1, 2, 3))) == \":foo.(1, 2, 3)\"\n end\n\n test \"aliases call\" do\n assert macro_to_string(quote(do: Elixir)) == \"Elixir\"\n assert macro_to_string(quote(do: Foo)) == \"Foo\"\n assert macro_to_string(quote(do: Foo.Bar.baz(1, 2, 3))) == \"Foo.Bar.baz(1, 2, 3)\"\n assert macro_to_string(quote(do: Foo.Bar.baz([1, 2, 3]))) == \"Foo.Bar.baz([1, 2, 3])\"\n assert macro_to_string(quote(do: Foo.bar(<<>>, []))) == \"Foo.bar(<<>>, [])\"\n end\n\n test \"keyword call\" do\n assert macro_to_string(quote(do: Foo.bar(foo: :bar))) == \"Foo.bar(foo: :bar)\"\n assert macro_to_string(quote(do: Foo.bar(\"Elixir.Foo\": :bar))) == \"Foo.bar([{Foo, :bar}])\"\n end\n\n test \"sigil call\" do\n assert macro_to_string(quote(do: ~r\"123\")) == ~S/~r\"123\"/\n assert macro_to_string(quote(do: ~r\"\\n123\")) == ~S/~r\"\\n123\"/\n assert macro_to_string(quote(do: ~r\"12\\\"3\")) == ~S/~r\"12\\\"3\"/\n assert macro_to_string(quote(do: ~r/12\\/3/u)) == ~S\"~r/12\\/3/u\"\n assert macro_to_string(quote(do: ~r{\\n123})) == ~S/~r{\\n123}/\n assert macro_to_string(quote(do: ~r((1\\)(2\\)3))) == ~S/~r((1\\)(2\\)3)/\n assert macro_to_string(quote(do: ~r{\\n1{1\\}23})) == ~S/~r{\\n1{1\\}23}/\n assert macro_to_string(quote(do: ~r|12\\|3|)) == ~S\"~r|12\\|3|\"\n\n assert macro_to_string(quote(do: ~r[1#{two}3])) == ~S/~r[1#{two}3]/\n assert macro_to_string(quote(do: ~r[1[#{two}\\]3])) == ~S/~r[1[#{two}\\]3]/\n assert macro_to_string(quote(do: ~r'1#{two}3'u)) == ~S/~r'1#{two}3'u/\n\n assert macro_to_string(quote(do: ~R\"123\")) == ~S/~R\"123\"/\n assert macro_to_string(quote(do: ~R\"123\"u)) == ~S/~R\"123\"u/\n assert macro_to_string(quote(do: ~R\"\\n123\")) == ~S/~R\"\\n123\"/\n\n assert macro_to_string(quote(do: ~S[\"'(123)'\"])) == ~S/~S[\"'(123)'\"]/\n assert macro_to_string(quote(do: ~s\"#{\"foo\"}\")) == ~S/~s\"#{\"foo\"}\"/\n\n assert macro_to_string(quote(do: ~HTML[hi])) == ~S/~HTML[hi]/\n\n assert macro_to_string(\n quote do\n ~s\"\"\"\n \"\\\"\"foo\"\\\"\"\n \"\"\"\n end\n ) == ~s[~s\"\"\"\\n\"\\\\\"\"foo\"\\\\\"\"\\n\"\"\"]\n\n assert macro_to_string(\n quote do\n ~s'''\n '\\''foo'\\''\n '''\n end\n ) == ~s[~s'''\\n'\\\\''foo'\\\\''\\n''']\n\n assert macro_to_string(\n quote do\n ~s\"\"\"\n \"\\\"foo\\\"\"\n \"\"\"\n end\n ) == ~s[~s\"\"\"\\n\"\\\\\"foo\\\\\"\"\\n\"\"\"]\n\n assert macro_to_string(\n quote do\n ~s'''\n '\\\"foo\\\"'\n '''\n end\n ) == ~s[~s'''\\n'\\\\\"foo\\\\\"'\\n''']\n\n assert macro_to_string(\n quote do\n ~S\"\"\"\n \"123\"\n \"\"\"\n end\n ) == ~s[~S\"\"\"\\n\"123\"\\n\"\"\"]\n\n assert macro_to_string(\n quote do\n ~HTML\"\"\"\n \"123\"\n \"\"\"\n end\n ) == ~s[~HTML\"\"\"\\n\"123\"\\n\"\"\"]\n end\n\n test \"tuple call\" do\n assert macro_to_string(quote(do: alias(Foo.{Bar, Baz, Bong}))) ==\n \"alias(Foo.{Bar, Baz, Bong})\"\n\n assert macro_to_string(quote(do: foo(Foo.{}))) == \"foo(Foo.{})\"\n end\n\n test \"arrow\" do\n assert macro_to_string(quote(do: foo(1, (2 -> 3)))) == \"foo(1, (2 -> 3))\"\n end\n\n test \"block\" do\n quoted =\n quote do\n 1\n 2\n\n (\n :foo\n :bar\n )\n\n 3\n end\n\n expected = \"\"\"\n (\n 1\n 2\n (\n :foo\n :bar\n )\n 3\n )\n \"\"\"\n\n assert macro_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"not in\" do\n assert macro_to_string(quote(do: false not in [])) == \"false not in []\"\n end\n\n test \"if else\" do\n expected = \"\"\"\n if(foo) do\n bar\n else\n baz\n end\n \"\"\"\n\n assert macro_to_string(quote(do: if(foo, do: bar, else: baz))) <> \"\\n\" == expected\n end\n\n test \"case\" do\n quoted =\n quote do\n case foo do\n true ->\n 0\n\n false ->\n 1\n 2\n end\n end\n\n expected = \"\"\"\n case(foo) do\n true ->\n 0\n false ->\n 1\n 2\n end\n \"\"\"\n\n assert macro_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"try\" do\n quoted =\n quote do\n try do\n foo\n catch\n _, _ ->\n 2\n rescue\n ArgumentError ->\n 1\n after\n 4\n else\n _ ->\n 3\n end\n end\n\n expected = \"\"\"\n try do\n foo\n rescue\n ArgumentError ->\n 1\n catch\n _, _ ->\n 2\n else\n _ ->\n 3\n after\n 4\n end\n \"\"\"\n\n assert macro_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"fn\" do\n assert macro_to_string(quote(do: fn -> 1 + 2 end)) == \"fn -> 1 + 2 end\"\n assert macro_to_string(quote(do: fn x -> x + 1 end)) == \"fn x -> x + 1 end\"\n\n quoted =\n quote do\n fn x ->\n y = x + 1\n y\n end\n end\n\n expected = \"\"\"\n fn x ->\n y = x + 1\n y\n end\n \"\"\"\n\n assert macro_to_string(quoted) <> \"\\n\" == expected\n\n quoted =\n quote do\n fn\n x ->\n y = x + 1\n y\n\n z ->\n z\n end\n end\n\n expected = \"\"\"\n fn\n x ->\n y = x + 1\n y\n z ->\n z\n end\n \"\"\"\n\n assert macro_to_string(quoted) <> \"\\n\" == expected\n\n assert macro_to_string(quote(do: (fn x -> x end).(1))) == \"(fn x -> x end).(1)\"\n\n quoted =\n quote do\n (fn\n %{} -> :map\n _ -> :other\n end).(1)\n end\n\n expected = \"\"\"\n (fn\n %{} ->\n :map\n _ ->\n :other\n end).(1)\n \"\"\"\n\n assert macro_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"range\" do\n assert macro_to_string(quote(do: -1..+2)) == \"-1..+2\"\n assert macro_to_string(quote(do: Foo.integer()..3)) == \"Foo.integer()..3\"\n assert macro_to_string(quote(do: -1..+2//-3)) == \"-1..+2//-3\"\n\n assert macro_to_string(quote(do: Foo.integer()..3//Bar.bat())) ==\n \"Foo.integer()..3//Bar.bat()\"\n\n # invalid AST\n assert macro_to_string(-1..+2) == \"-1..2\"\n assert macro_to_string(-1..+2//-3) == \"-1..2//-3\"\n end\n\n test \"when\" do\n assert macro_to_string(quote(do: (-> x))) == \"(() -> x)\"\n assert macro_to_string(quote(do: (x when y -> z))) == \"(x when y -> z)\"\n assert macro_to_string(quote(do: (x, y when z -> w))) == \"((x, y) when z -> w)\"\n assert macro_to_string(quote(do: (x, y when z -> w))) == \"((x, y) when z -> w)\"\n end\n\n test \"nested\" do\n quoted =\n quote do\n defmodule Foo do\n def foo do\n 1 + 1\n end\n end\n end\n\n expected = \"\"\"\n defmodule(Foo) do\n def(foo) do\n 1 + 1\n end\n end\n \"\"\"\n\n assert macro_to_string(quoted) <> \"\\n\" == expected\n end\n\n test \"operator precedence\" do\n assert macro_to_string(quote(do: (1 + 2) * (3 - 4))) == \"(1 + 2) * (3 - 4)\"\n assert macro_to_string(quote(do: (1 + 2) * 3 - 4)) == \"(1 + 2) * 3 - 4\"\n assert macro_to_string(quote(do: 1 + 2 + 3)) == \"1 + 2 + 3\"\n assert macro_to_string(quote(do: 1 + 2 - 3)) == \"1 + 2 - 3\"\n end\n\n test \"capture operator\" do\n assert macro_to_string(quote(do: &foo/0)) == \"&foo/0\"\n assert macro_to_string(quote(do: &Foo.foo/0)) == \"&Foo.foo/0\"\n assert macro_to_string(quote(do: &(&1 + &2))) == \"&(&1 + &2)\"\n assert macro_to_string(quote(do: & &1)) == \"&(&1)\"\n assert macro_to_string(quote(do: & &1.(:x))) == \"&(&1.(:x))\"\n assert macro_to_string(quote(do: (& &1).(:x))) == \"(&(&1)).(:x)\"\n end\n\n test \"containers\" do\n assert macro_to_string(quote(do: {})) == \"{}\"\n assert macro_to_string(quote(do: [])) == \"[]\"\n assert macro_to_string(quote(do: {1, 2, 3})) == \"{1, 2, 3}\"\n assert macro_to_string(quote(do: [1, 2, 3])) == \"[1, 2, 3]\"\n assert macro_to_string(quote(do: [\"Elixir.Foo\": :bar])) == \"[{Foo, :bar}]\"\n assert macro_to_string(quote(do: %{})) == \"%{}\"\n assert macro_to_string(quote(do: %{:foo => :bar})) == \"%{foo: :bar}\"\n assert macro_to_string(quote(do: %{:\"Elixir.Foo\" => :bar})) == \"%{Foo => :bar}\"\n assert macro_to_string(quote(do: %{{1, 2} => [1, 2, 3]})) == \"%{{1, 2} => [1, 2, 3]}\"\n assert macro_to_string(quote(do: %{map | \"a\" => \"b\"})) == \"%{map | \\\"a\\\" => \\\"b\\\"}\"\n assert macro_to_string(quote(do: [1, 2, 3])) == \"[1, 2, 3]\"\n end\n\n test \"struct\" do\n assert macro_to_string(quote(do: %Test{})) == \"%Test{}\"\n assert macro_to_string(quote(do: %Test{foo: 1, bar: 1})) == \"%Test{foo: 1, bar: 1}\"\n assert macro_to_string(quote(do: %Test{struct | foo: 2})) == \"%Test{struct | foo: 2}\"\n assert macro_to_string(quote(do: %Test{} + 1)) == \"%Test{} + 1\"\n assert macro_to_string(quote(do: %Test{foo(1)} + 2)) == \"%Test{foo(1)} + 2\"\n end\n\n test \"binary operators\" do\n assert macro_to_string(quote(do: 1 + 2)) == \"1 + 2\"\n assert macro_to_string(quote(do: [1, 2 | 3])) == \"[1, 2 | 3]\"\n assert macro_to_string(quote(do: [h | t] = [1, 2, 3])) == \"[h | t] = [1, 2, 3]\"\n assert macro_to_string(quote(do: (x ++ y) ++ z)) == \"(x ++ y) ++ z\"\n assert macro_to_string(quote(do: (x +++ y) +++ z)) == \"(x +++ y) +++ z\"\n end\n\n test \"unary operators\" do\n assert macro_to_string(quote(do: not 1)) == \"not(1)\"\n assert macro_to_string(quote(do: not foo)) == \"not(foo)\"\n assert macro_to_string(quote(do: -1)) == \"-1\"\n assert macro_to_string(quote(do: +(+1))) == \"+(+1)\"\n assert macro_to_string(quote(do: !(foo > bar))) == \"!(foo > bar)\"\n assert macro_to_string(quote(do: @foo(bar))) == \"@foo(bar)\"\n assert macro_to_string(quote(do: identity(&1))) == \"identity(&1)\"\n end\n\n test \"access\" do\n assert macro_to_string(quote(do: a[b])) == \"a[b]\"\n assert macro_to_string(quote(do: a[1 + 2])) == \"a[1 + 2]\"\n assert macro_to_string(quote(do: (a || [a: 1])[:a])) == \"(a || [a: 1])[:a]\"\n assert macro_to_string(quote(do: Map.put(%{}, :a, 1)[:a])) == \"Map.put(%{}, :a, 1)[:a]\"\n end\n\n test \"keyword list\" do\n assert macro_to_string(quote(do: [a: a, b: b])) == \"[a: a, b: b]\"\n assert macro_to_string(quote(do: [a: 1, b: 1 + 2])) == \"[a: 1, b: 1 + 2]\"\n assert macro_to_string(quote(do: [\"a.b\": 1, c: 1 + 2])) == \"[\\\"a.b\\\": 1, c: 1 + 2]\"\n end\n\n test \"interpolation\" do\n assert macro_to_string(quote(do: \"foo#{bar}baz\")) == ~S[\"foo#{bar}baz\"]\n end\n\n test \"bit syntax\" do\n ast = quote(do: <<1::8*4>>)\n assert macro_to_string(ast) == \"<<1::8*4>>\"\n\n ast = quote(do: @type(foo :: <<_::8, _::_*4>>))\n assert macro_to_string(ast) == \"@type(foo :: <<_::8, _::_*4>>)\"\n\n ast = quote(do: <<69 - 4::bits-size(8 - 4)-unit(1), 65>>)\n assert macro_to_string(ast) == \"<<69 - 4::bits-size(8 - 4)-unit(1), 65>>\"\n\n ast = quote(do: <<(<<65>>), 65>>)\n assert macro_to_string(ast) == \"<<(<<65>>), 65>>\"\n\n ast = quote(do: <<65, (<<65>>)>>)\n assert macro_to_string(ast) == \"<<65, (<<65>>)>>\"\n\n ast = quote(do: for(<<(a::4 <- <<1, 2>>)>>, do: a))\n assert macro_to_string(ast) == \"for(<<(a :: 4 <- <<1, 2>>)>>) do\\n a\\nend\"\n end\n\n test \"charlist\" do\n assert macro_to_string(quote(do: [])) == \"[]\"\n assert macro_to_string(quote(do: ~c\"abc\")) == ~S/~c\"abc\"/\n assert macro_to_string(quote(do: [?a, ?b, ?c])) == ~S/~c\"abc\"/\n end\n\n test \"string\" do\n assert macro_to_string(quote(do: \"\")) == ~S/\"\"/\n assert macro_to_string(quote(do: \"abc\")) == ~S/\"abc\"/\n assert macro_to_string(quote(do: \"#{\"abc\"}\")) == ~S/\"#{\"abc\"}\"/\n end\n\n test \"last arg keyword list\" do\n assert macro_to_string(quote(do: foo([]))) == \"foo([])\"\n assert macro_to_string(quote(do: foo(x: y))) == \"foo(x: y)\"\n assert macro_to_string(quote(do: foo(x: 1 + 2))) == \"foo(x: 1 + 2)\"\n assert macro_to_string(quote(do: foo(x: y, p: q))) == \"foo(x: y, p: q)\"\n assert macro_to_string(quote(do: foo(a, x: y, p: q))) == \"foo(a, x: y, p: q)\"\n\n assert macro_to_string(quote(do: {[]})) == \"{[]}\"\n assert macro_to_string(quote(do: {[a: b]})) == \"{[a: b]}\"\n assert macro_to_string(quote(do: {x, a: b})) == \"{x, [a: b]}\"\n assert macro_to_string(quote(do: foo(else: a))) == \"foo(else: a)\"\n assert macro_to_string(quote(do: foo(catch: a))) == \"foo(catch: a)\"\n end\n\n test \"with fun\" do\n assert macro_to_string(quote(do: foo(1, 2, 3)), fn _, string -> \":#{string}:\" end) ==\n \":foo(:1:, :2:, :3:):\"\n\n assert macro_to_string(quote(do: Bar.foo(1, 2, 3)), fn _, string -> \":#{string}:\" end) ==\n \"::Bar:.foo(:1:, :2:, :3:):\"\n end\n end\n\n test \"validate/1\" do\n ref = make_ref()\n\n assert Macro.validate(1) == :ok\n assert Macro.validate(1.0) == :ok\n assert Macro.validate(:foo) == :ok\n assert Macro.validate(\"bar\") == :ok\n assert Macro.validate(<<0::8>>) == :ok\n assert Macro.validate(self()) == :ok\n assert Macro.validate({1, 2}) == :ok\n assert Macro.validate({:foo, [], :baz}) == :ok\n assert Macro.validate({:foo, [], []}) == :ok\n assert Macro.validate([1, 2, 3]) == :ok\n\n assert Macro.validate(<<0::4>>) == {:error, <<0::4>>}\n assert Macro.validate(ref) == {:error, ref}\n assert Macro.validate({1, ref}) == {:error, ref}\n assert Macro.validate({ref, 2}) == {:error, ref}\n assert Macro.validate([1, ref, 3]) == {:error, ref}\n assert Macro.validate({:foo, [], 0}) == {:error, {:foo, [], 0}}\n assert Macro.validate({:foo, 0, []}) == {:error, {:foo, 0, []}}\n end\n\n test \"decompose_call/1\" do\n assert Macro.decompose_call(quote(do: foo)) == {:foo, []}\n assert Macro.decompose_call(quote(do: foo())) == {:foo, []}\n assert Macro.decompose_call(quote(do: foo(1, 2, 3))) == {:foo, [1, 2, 3]}\n\n assert Macro.decompose_call(quote(do: M.N.foo(1, 2, 3))) ==\n {{:__aliases__, [alias: false], [:M, :N]}, :foo, [1, 2, 3]}\n\n assert Macro.decompose_call(quote(do: :foo.foo(1, 2, 3))) == {:foo, :foo, [1, 2, 3]}\n assert Macro.decompose_call(quote(do: 1.(1, 2, 3))) == :error\n assert Macro.decompose_call(quote(do: \"some string\")) == :error\n assert Macro.decompose_call(quote(do: {:foo, :bar, :baz})) == :error\n assert Macro.decompose_call(quote(do: {:foo, :bar, :baz, 42})) == :error\n end\n\n ## pipe/unpipe\n\n test \"pipe/3\" do\n assert Macro.pipe(1, quote(do: foo), 0) == quote(do: foo(1))\n assert Macro.pipe(1, quote(do: foo(2)), 0) == quote(do: foo(1, 2))\n assert Macro.pipe(1, quote(do: foo), -1) == quote(do: foo(1))\n assert Macro.pipe(2, quote(do: foo(1)), -1) == quote(do: foo(1, 2))\n\n assert Macro.pipe(quote(do: %{foo: \"bar\"}), quote(do: Access.get(:foo)), 0) ==\n quote(do: Access.get(%{foo: \"bar\"}, :foo))\n\n assert_raise ArgumentError, ~r\"cannot pipe 1 into 2\", fn ->\n Macro.pipe(1, 2, 0)\n end\n\n assert_raise ArgumentError, ~r\"cannot pipe 1 into \\{2, 3\\}\", fn ->\n Macro.pipe(1, {2, 3}, 0)\n end\n\n assert_raise ArgumentError, ~r\"cannot pipe 1 into 1 \\+ 1, the :\\+ operator can\", fn ->\n Macro.pipe(1, quote(do: 1 + 1), 0) == quote(do: foo(1))\n end\n\n assert_raise ArgumentError, ~r\"cannot pipe 1 into <<1>>\", fn ->\n Macro.pipe(1, quote(do: <<1>>), 0)\n end\n\n assert_raise ArgumentError, ~r\"cannot pipe 1 into the special form unquote/1\", fn ->\n Macro.pipe(1, quote(do: unquote()), 0)\n end\n\n assert_raise ArgumentError, ~r\"piping into a unary operator is not supported\", fn ->\n Macro.pipe(1, quote(do: +1), 0)\n end\n\n assert_raise ArgumentError, ~r\"cannot pipe Macro into Env\", fn ->\n Macro.pipe(Macro, quote(do: Env), 0)\n end\n\n assert_raise ArgumentError, ~r\"cannot pipe 1 into 2 && 3\", fn ->\n Macro.pipe(1, quote(do: 2 && 3), 0)\n end\n\n message = ~r\"cannot pipe :foo into an anonymous function without calling\"\n\n assert_raise ArgumentError, message, fn ->\n Macro.pipe(:foo, quote(do: fn x -> x end), 0)\n end\n\n message = ~r\"wrong operator precedence when piping into bracket-based access\"\n\n assert_raise ArgumentError, message, fn ->\n Macro.pipe(:foo, quote(do: %{foo: bar}[:foo]), 0)\n end\n end\n\n test \"unpipe/1\" do\n assert Macro.unpipe(quote(do: foo)) == quote(do: [{foo, 0}])\n assert Macro.unpipe(quote(do: foo |> bar)) == quote(do: [{foo, 0}, {bar, 0}])\n assert Macro.unpipe(quote(do: foo |> bar |> baz)) == quote(do: [{foo, 0}, {bar, 0}, {baz, 0}])\n end\n\n ## traverse/pre/postwalk\n\n test \"traverse/4\" do\n assert traverse({:foo, [], nil}) == [{:foo, [], nil}, {:foo, [], nil}]\n\n assert traverse({:foo, [], [1, 2, 3]}) ==\n [{:foo, [], [1, 2, 3]}, 1, 1, 2, 2, 3, 3, {:foo, [], [1, 2, 3]}]\n\n assert traverse({{:., [], [:foo, :bar]}, [], [1, 2, 3]}) ==\n [\n {{:., [], [:foo, :bar]}, [], [1, 2, 3]},\n {:., [], [:foo, :bar]},\n :foo,\n :foo,\n :bar,\n :bar,\n {:., [], [:foo, :bar]},\n 1,\n 1,\n 2,\n 2,\n 3,\n 3,\n {{:., [], [:foo, :bar]}, [], [1, 2, 3]}\n ]\n\n assert traverse({[1, 2, 3], [4, 5, 6]}) ==\n [\n {[1, 2, 3], [4, 5, 6]},\n [1, 2, 3],\n 1,\n 1,\n 2,\n 2,\n 3,\n 3,\n [1, 2, 3],\n [4, 5, 6],\n 4,\n 4,\n 5,\n 5,\n 6,\n 6,\n [4, 5, 6],\n {[1, 2, 3], [4, 5, 6]}\n ]\n end\n\n defp traverse(ast) do\n Macro.traverse(ast, [], &{&1, [&1 | &2]}, &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()\n end\n\n test \"prewalk/3\" do\n assert prewalk({:foo, [], nil}) == [{:foo, [], nil}]\n\n assert prewalk({:foo, [], [1, 2, 3]}) == [{:foo, [], [1, 2, 3]}, 1, 2, 3]\n\n assert prewalk({{:., [], [:foo, :bar]}, [], [1, 2, 3]}) ==\n [\n {{:., [], [:foo, :bar]}, [], [1, 2, 3]},\n {:., [], [:foo, :bar]},\n :foo,\n :bar,\n 1,\n 2,\n 3\n ]\n\n assert prewalk({[1, 2, 3], [4, 5, 6]}) ==\n [{[1, 2, 3], [4, 5, 6]}, [1, 2, 3], 1, 2, 3, [4, 5, 6], 4, 5, 6]\n end\n\n defp prewalk(ast) do\n Macro.prewalk(ast, [], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()\n end\n\n test \"postwalk/3\" do\n assert postwalk({:foo, [], nil}) == [{:foo, [], nil}]\n\n assert postwalk({:foo, [], [1, 2, 3]}) == [1, 2, 3, {:foo, [], [1, 2, 3]}]\n\n assert postwalk({{:., [], [:foo, :bar]}, [], [1, 2, 3]}) ==\n [\n :foo,\n :bar,\n {:., [], [:foo, :bar]},\n 1,\n 2,\n 3,\n {{:., [], [:foo, :bar]}, [], [1, 2, 3]}\n ]\n\n assert postwalk({[1, 2, 3], [4, 5, 6]}) ==\n [1, 2, 3, [1, 2, 3], 4, 5, 6, [4, 5, 6], {[1, 2, 3], [4, 5, 6]}]\n end\n\n test \"generate_arguments/2\" do\n assert Macro.generate_arguments(0, __MODULE__) == []\n assert Macro.generate_arguments(1, __MODULE__) == [{:arg1, [], __MODULE__}]\n assert Macro.generate_arguments(4, __MODULE__) |> length() == 4\n end\n\n defp postwalk(ast) do\n Macro.postwalk(ast, [], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()\n end\n\n test \"struct_info!/2 expands structs multiple levels deep\" do\n defmodule StructBang do\n @enforce_keys [:b]\n defstruct [:a, :b]\n\n assert Macro.struct_info!(StructBang, __ENV__) == [\n %{field: :a, default: nil, required: false},\n %{field: :b, default: nil, required: true}\n ]\n\n def within_function do\n assert Macro.struct_info!(StructBang, __ENV__) == [\n %{field: :a, default: nil, required: false},\n %{field: :b, default: nil, required: true}\n ]\n end\n\n defmodule Nested do\n assert Macro.struct_info!(StructBang, __ENV__) == [\n %{field: :a, default: nil, required: false},\n %{field: :b, default: nil, required: true}\n ]\n end\n end\n\n assert Macro.struct_info!(StructBang, __ENV__) == [\n %{field: :a, default: nil, required: false},\n %{field: :b, default: nil, required: true}\n ]\n end\n\n test \"prewalker/1\" do\n ast = quote do: :mod.foo(bar({1, 2}), [3, 4, five])\n map = Enum.map(Macro.prewalker(ast), & &1)\n\n assert map == [\n {{:., [], [:mod, :foo]}, [], [{:bar, [], [{1, 2}]}, [3, 4, {:five, [], MacroTest}]]},\n {:., [], [:mod, :foo]},\n :mod,\n :foo,\n {:bar, [], [{1, 2}]},\n {1, 2},\n 1,\n 2,\n [3, 4, {:five, [], MacroTest}],\n 3,\n 4,\n {:five, [], MacroTest}\n ]\n\n assert map == ast |> Macro.prewalk([], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()\n assert Enum.zip(Macro.prewalker(ast), []) == Enum.zip(map, [])\n\n for i <- 0..(length(map) + 1) do\n assert Enum.take(Macro.prewalker(ast), i) == Enum.take(map, i)\n end\n end\n\n test \"postwalker/1\" do\n ast = quote do: :mod.foo(bar({1, 2}), [3, 4, five])\n map = Enum.map(Macro.postwalker(ast), & &1)\n\n assert map == [\n :mod,\n :foo,\n {:., [], [:mod, :foo]},\n 1,\n 2,\n {1, 2},\n {:bar, [], [{1, 2}]},\n 3,\n 4,\n {:five, [], MacroTest},\n [3, 4, {:five, [], MacroTest}],\n {{:., [], [:mod, :foo]}, [], [{:bar, [], [{1, 2}]}, [3, 4, {:five, [], MacroTest}]]}\n ]\n\n assert map == ast |> Macro.postwalk([], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()\n assert Enum.zip(Macro.postwalker(ast), []) == Enum.zip(map, [])\n\n for i <- 0..(length(map) + 1) do\n assert Enum.take(Macro.postwalker(ast), i) == Enum.take(map, i)\n end\n end\n\n test \"operator?/2\" do\n assert Macro.operator?(:+, 2)\n assert Macro.operator?(:+, 1)\n refute Macro.operator?(:+, 0)\n end\n\n test \"quoted_literal?/1\" do\n assert Macro.quoted_literal?(quote(do: \"foo\"))\n assert Macro.quoted_literal?(quote(do: {\"foo\", 1}))\n assert Macro.quoted_literal?(quote(do: %{foo: \"bar\"}))\n assert Macro.quoted_literal?(quote(do: %URI{path: \"/\"}))\n assert Macro.quoted_literal?(quote(do: <<>>))\n assert Macro.quoted_literal?(quote(do: <<1, \"foo\", \"bar\"::utf16>>))\n assert Macro.quoted_literal?(quote(do: <<1000::size(8)-unit(4)>>))\n assert Macro.quoted_literal?(quote(do: <<1000::8*4>>))\n assert Macro.quoted_literal?(quote(do: <<102::unsigned-big-integer-size(8)>>))\n refute Macro.quoted_literal?(quote(do: {\"foo\", var}))\n refute Macro.quoted_literal?(quote(do: <<\"foo\"::size(name_size)>>))\n refute Macro.quoted_literal?(quote(do: <<\"foo\"::binary-size(name_size)>>))\n refute Macro.quoted_literal?(quote(do: <<\"foo\"::custom_modifier()>>))\n refute Macro.quoted_literal?(quote(do: <<102, rest::binary>>))\n end\n\n test \"underscore/1\" do\n assert Macro.underscore(\"foo\") == \"foo\"\n assert Macro.underscore(\"foo_bar\") == \"foo_bar\"\n assert Macro.underscore(\"Foo\") == \"foo\"\n assert Macro.underscore(\"FooBar\") == \"foo_bar\"\n assert Macro.underscore(\"FOOBar\") == \"foo_bar\"\n assert Macro.underscore(\"FooBAR\") == \"foo_bar\"\n assert Macro.underscore(\"FOO_BAR\") == \"foo_bar\"\n assert Macro.underscore(\"FoBaZa\") == \"fo_ba_za\"\n assert Macro.underscore(\"Foo10\") == \"foo10\"\n assert Macro.underscore(\"FOO10\") == \"foo10\"\n assert Macro.underscore(\"10Foo\") == \"10_foo\"\n assert Macro.underscore(\"FooBar10\") == \"foo_bar10\"\n assert Macro.underscore(\"FooBAR10\") == \"foo_bar10\"\n assert Macro.underscore(\"Foo10Bar\") == \"foo10_bar\"\n assert Macro.underscore(\"Foo.Bar\") == \"foo/bar\"\n assert Macro.underscore(Foo.Bar) == \"foo/bar\"\n assert Macro.underscore(\"API.V1.User\") == \"api/v1/user\"\n assert Macro.underscore(\"\") == \"\"\n end\n\n test \"camelize/1\" do\n assert Macro.camelize(\"Foo\") == \"Foo\"\n assert Macro.camelize(\"FooBar\") == \"FooBar\"\n assert Macro.camelize(\"foo\") == \"Foo\"\n assert Macro.camelize(\"foo_bar\") == \"FooBar\"\n assert Macro.camelize(\"foo_\") == \"Foo\"\n assert Macro.camelize(\"_foo\") == \"Foo\"\n assert Macro.camelize(\"foo10\") == \"Foo10\"\n assert Macro.camelize(\"_10foo\") == \"10foo\"\n assert Macro.camelize(\"foo_10\") == \"Foo10\"\n assert Macro.camelize(\"foo__10\") == \"Foo10\"\n assert Macro.camelize(\"foo__bar\") == \"FooBar\"\n assert Macro.camelize(\"foo/bar\") == \"Foo.Bar\"\n assert Macro.camelize(\"Foo.Bar\") == \"Foo.Bar\"\n assert Macro.camelize(\"foo1_0\") == \"Foo10\"\n assert Macro.camelize(\"foo_123_4_567\") == \"Foo1234567\"\n assert Macro.camelize(\"FOO_BAR\") == \"FOO_BAR\"\n assert Macro.camelize(\"FOO.BAR\") == \"FOO.BAR\"\n assert Macro.camelize(\"\") == \"\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/map_set_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule MapSetTest do\n use ExUnit.Case, async: true\n\n doctest MapSet\n\n test \"new/1\" do\n result = MapSet.new(1..5)\n assert MapSet.equal?(result, Enum.into(1..5, MapSet.new()))\n end\n\n test \"new/2\" do\n result = MapSet.new(1..5, &(&1 + 2))\n assert MapSet.equal?(result, Enum.into(3..7, MapSet.new()))\n end\n\n test \"put/2\" do\n result = MapSet.put(MapSet.new(), 1)\n assert MapSet.equal?(result, MapSet.new([1]))\n\n result = MapSet.put(MapSet.new([1, 3, 4]), 2)\n assert MapSet.equal?(result, MapSet.new(1..4))\n\n result = MapSet.put(MapSet.new(5..100), 10)\n assert MapSet.equal?(result, MapSet.new(5..100))\n end\n\n test \"union/2\" do\n result = MapSet.union(MapSet.new([1, 3, 4]), MapSet.new())\n assert MapSet.equal?(result, MapSet.new([1, 3, 4]))\n\n result = MapSet.union(MapSet.new(5..15), MapSet.new(10..25))\n assert MapSet.equal?(result, MapSet.new(5..25))\n\n result = MapSet.union(MapSet.new(1..120), MapSet.new(1..100))\n assert MapSet.equal?(result, MapSet.new(1..120))\n end\n\n test \"intersection/2\" do\n result = MapSet.intersection(MapSet.new(), MapSet.new(1..21))\n assert MapSet.equal?(result, MapSet.new())\n\n result = MapSet.intersection(MapSet.new(1..21), MapSet.new(4..24))\n assert MapSet.equal?(result, MapSet.new(4..21))\n\n result = MapSet.intersection(MapSet.new(2..100), MapSet.new(1..120))\n assert MapSet.equal?(result, MapSet.new(2..100))\n end\n\n test \"difference/2\" do\n result = MapSet.difference(MapSet.new(2..20), MapSet.new())\n assert MapSet.equal?(result, MapSet.new(2..20))\n\n result = MapSet.difference(MapSet.new(2..20), MapSet.new(1..21))\n assert MapSet.equal?(result, MapSet.new())\n\n result = MapSet.difference(MapSet.new(1..101), MapSet.new(2..100))\n assert MapSet.equal?(result, MapSet.new([1, 101]))\n end\n\n test \"symmetric_difference/2\" do\n result = MapSet.symmetric_difference(MapSet.new(1..5), MapSet.new(3..8))\n assert MapSet.equal?(result, MapSet.new([1, 2, 6, 7, 8]))\n\n result = MapSet.symmetric_difference(MapSet.new(), MapSet.new())\n assert MapSet.equal?(result, MapSet.new())\n\n result = MapSet.symmetric_difference(MapSet.new(1..5), MapSet.new(1..5))\n assert MapSet.equal?(result, MapSet.new())\n\n result = MapSet.symmetric_difference(MapSet.new([1, 2, 3]), MapSet.new())\n assert MapSet.equal?(result, MapSet.new([1, 2, 3]))\n\n result = MapSet.symmetric_difference(MapSet.new(), MapSet.new([1, 2, 3]))\n assert MapSet.equal?(result, MapSet.new([1, 2, 3]))\n end\n\n test \"disjoint?/2\" do\n assert MapSet.disjoint?(MapSet.new(), MapSet.new())\n assert MapSet.disjoint?(MapSet.new(1..6), MapSet.new(8..20))\n refute MapSet.disjoint?(MapSet.new(1..6), MapSet.new(5..15))\n refute MapSet.disjoint?(MapSet.new(1..120), MapSet.new(1..6))\n end\n\n test \"subset?/2\" do\n assert MapSet.subset?(MapSet.new(), MapSet.new())\n assert MapSet.subset?(MapSet.new(1..6), MapSet.new(1..10))\n assert MapSet.subset?(MapSet.new(1..6), MapSet.new(1..120))\n refute MapSet.subset?(MapSet.new(1..120), MapSet.new(1..6))\n end\n\n test \"equal?/2\" do\n assert MapSet.equal?(MapSet.new(), MapSet.new())\n refute MapSet.equal?(MapSet.new(1..20), MapSet.new(2..21))\n assert MapSet.equal?(MapSet.new(1..120), MapSet.new(1..120))\n end\n\n test \"delete/2\" do\n result = MapSet.delete(MapSet.new(), 1)\n assert MapSet.equal?(result, MapSet.new())\n\n result = MapSet.delete(MapSet.new(1..4), 5)\n assert MapSet.equal?(result, MapSet.new(1..4))\n\n result = MapSet.delete(MapSet.new(1..4), 1)\n assert MapSet.equal?(result, MapSet.new(2..4))\n\n result = MapSet.delete(MapSet.new(1..4), 2)\n assert MapSet.equal?(result, MapSet.new([1, 3, 4]))\n end\n\n test \"size/1\" do\n assert MapSet.size(MapSet.new()) == 0\n assert MapSet.size(MapSet.new(5..15)) == 11\n assert MapSet.size(MapSet.new(2..100)) == 99\n end\n\n test \"to_list/1\" do\n assert MapSet.to_list(MapSet.new()) == []\n\n list = MapSet.to_list(MapSet.new(1..20))\n assert Enum.sort(list) == Enum.to_list(1..20)\n\n list = MapSet.to_list(MapSet.new(5..120))\n assert Enum.sort(list) == Enum.to_list(5..120)\n end\n\n test \"filter/2\" do\n result = MapSet.filter(MapSet.new([1, nil, 2, false]), & &1)\n assert MapSet.equal?(result, MapSet.new(1..2))\n\n result = MapSet.filter(MapSet.new(1..10), &(&1 < 2 or &1 > 9))\n assert MapSet.equal?(result, MapSet.new([1, 10]))\n\n result = MapSet.filter(MapSet.new(~w(A a B b)), fn x -> String.downcase(x) == x end)\n assert MapSet.equal?(result, MapSet.new(~w(a b)))\n end\n\n test \"reject/2\" do\n result = MapSet.reject(MapSet.new(1..10), &(&1 < 8))\n assert MapSet.equal?(result, MapSet.new(8..10))\n\n result = MapSet.reject(MapSet.new([\"a\", :b, 1, 1.0]), &is_integer/1)\n assert MapSet.equal?(result, MapSet.new([\"a\", :b, 1.0]))\n\n result = MapSet.reject(MapSet.new(1..3), fn x -> rem(x, 2) == 0 end)\n assert MapSet.equal?(result, MapSet.new([1, 3]))\n end\n\n test \"split_with\" do\n assert MapSet.split_with(MapSet.new(), fn v -> rem(v, 2) == 0 end) ==\n {MapSet.new(), MapSet.new()}\n\n assert MapSet.split_with(MapSet.new([1, 2, 3]), fn v -> rem(v, 2) == 0 end) ==\n {MapSet.new([2]), MapSet.new([1, 3])}\n\n assert MapSet.split_with(MapSet.new([2, 4, 6]), fn v -> rem(v, 2) == 0 end) ==\n {MapSet.new([2, 4, 6]), MapSet.new([])}\n end\n\n test \"inspect\" do\n assert inspect(MapSet.new([?a])) == \"MapSet.new([97])\"\n end\nend\n" }, { "path": "lib/elixir/test/elixir/map_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule MapTest do\n use ExUnit.Case, async: true\n\n doctest Map\n\n @sample %{a: 1, b: 2}\n defp sample, do: Process.get(:unused, %{a: 1, b: 2})\n\n test \"maps in attributes\" do\n assert @sample == %{a: 1, b: 2}\n end\n\n test \"maps when quoted\" do\n assert quote(do: %{foo: 1}) == {:%{}, [], [{:foo, 1}]}\n end\n\n test \"maps keywords and atoms\" do\n assert [%{}: :%] == [{:%{}, :%}]\n assert [%: :%{}] == [{:%, :%{}}]\n end\n\n test \"maps with variables\" do\n a = 0\n assert %{a: a = 1, b: a} == %{a: 1, b: 0}\n assert a == 1\n end\n\n test \"maps with generated variables in key\" do\n assert %{\"#{1}\" => 1} == %{\"1\" => 1}\n assert %{for(x <- 1..3, do: x) => 1} == %{[1, 2, 3] => 1}\n assert %{with(x = 1, do: x) => 1} == %{1 => 1}\n assert %{with({:ok, x} <- {:ok, 1}, do: x) => 1} == %{1 => 1}\n\n assert %{\n try do\n raise \"error\"\n rescue\n _ -> 1\n end => 1\n } == %{1 => 1}\n\n assert %{\n try do\n throw(1)\n catch\n x -> x\n end => 1\n } == %{1 => 1}\n\n assert %{\n try do\n a = 1\n a\n rescue\n _ -> 2\n end => 1\n } == %{1 => 1}\n\n assert %{\n try do\n 1\n rescue\n _exception -> flunk(\"should not be invoked\")\n else\n a -> a\n end => 1\n } == %{1 => 1}\n end\n\n test \"matching with map as a key\" do\n assert %{%{1 => 2} => x} = %{%{1 => 2} => 3}\n assert x == 3\n end\n\n test \"is_map/1\" do\n assert is_map(Map.new())\n refute is_map(Enum.to_list(%{}))\n end\n\n test \"map_size/1\" do\n assert map_size(%{}) == 0\n assert map_size(sample()) == 2\n end\n\n test \"new/1\" do\n assert Map.new(%{a: 1, b: 2}) == %{a: 1, b: 2}\n assert Map.new(MapSet.new(a: 1, b: 2, a: 3)) == %{b: 2, a: 3}\n end\n\n test \"new/2\" do\n transformer = fn {key, value} -> {key, value * 2} end\n assert Map.new(%{a: 1, b: 2}, transformer) == %{a: 2, b: 4}\n assert Map.new(MapSet.new(a: 1, b: 2, a: 3), transformer) == %{b: 4, a: 6}\n end\n\n test \"take/2\" do\n assert Map.take(%{a: 1, b: 2, c: 3}, [:b, :c]) == %{b: 2, c: 3}\n assert Map.take(%{a: 1, b: 2, c: 3}, []) == %{}\n assert_raise BadMapError, fn -> Map.take(:foo, []) end\n end\n\n test \"drop/2\" do\n assert Map.drop(%{a: 1, b: 2, c: 3}, [:b, :c]) == %{a: 1}\n assert_raise BadMapError, fn -> Map.drop(:foo, []) end\n end\n\n test \"split/2\" do\n assert Map.split(%{a: 1, b: 2, c: 3}, [:b, :c]) == {%{b: 2, c: 3}, %{a: 1}}\n assert_raise BadMapError, fn -> Map.split(:foo, []) end\n end\n\n test \"split_with/2\" do\n assert Map.split_with(%{}, fn {_k, v} -> rem(v, 2) == 0 end) == {%{}, %{}}\n\n assert Map.split_with(%{a: 1, b: 2, c: 3}, fn {_k, v} -> rem(v, 2) == 0 end) ==\n {%{b: 2}, %{a: 1, c: 3}}\n\n assert Map.split_with(%{a: 2, b: 4, c: 6}, fn {_k, v} -> rem(v, 2) == 0 end) ==\n {%{a: 2, b: 4, c: 6}, %{}}\n\n assert Map.split_with(%{1 => 1, 2 => 2, 3 => 3}, fn {k, _v} -> rem(k, 2) == 0 end) ==\n {%{2 => 2}, %{1 => 1, 3 => 3}}\n\n assert Map.split_with(%{1 => 2, 3 => 4, 5 => 6}, fn {k, _v} -> rem(k, 2) == 0 end) ==\n {%{}, %{1 => 2, 3 => 4, 5 => 6}}\n end\n\n test \"get_and_update/3\" do\n message = \"the given function must return a two-element tuple or :pop, got: 1\"\n\n assert_raise RuntimeError, message, fn ->\n Map.get_and_update(%{a: 1}, :a, fn value -> value end)\n end\n end\n\n test \"get_and_update!/3\" do\n message = \"the given function must return a two-element tuple or :pop, got: 1\"\n\n assert_raise RuntimeError, message, fn ->\n Map.get_and_update!(%{a: 1}, :a, fn value -> value end)\n end\n end\n\n test \"maps with optional comma\" do\n assert Code.eval_string(\"%{a: :b,}\") == {%{a: :b}, []}\n assert Code.eval_string(\"%{1 => 2,}\") == {%{1 => 2}, []}\n assert Code.eval_string(\"%{1 => 2, a: :b,}\") == {%{1 => 2, a: :b}, []}\n end\n\n test \"update maps\" do\n assert %{sample() | a: 3} == %{a: 3, b: 2}\n\n assert_raise KeyError, fn ->\n %{sample() | c: 3}\n end\n end\n\n test \"map dot access\" do\n assert sample().a == 1\n\n assert_raise KeyError, fn ->\n sample().c\n end\n end\n\n test \"put/3 optimized by the compiler\" do\n map = %{a: 1, b: 2}\n\n assert Map.put(map, :a, 2) == %{a: 2, b: 2}\n assert Map.put(map, :c, 3) == %{a: 1, b: 2, c: 3}\n\n assert Map.put(%{map | a: 2}, :a, 3) == %{a: 3, b: 2}\n assert Map.put(%{map | a: 2}, :b, 3) == %{a: 2, b: 3}\n\n assert Map.put(map, :a, 2) |> Map.put(:a, 3) == %{a: 3, b: 2}\n assert Map.put(map, :a, 2) |> Map.put(:c, 3) == %{a: 2, b: 2, c: 3}\n assert Map.put(map, :c, 3) |> Map.put(:a, 2) == %{a: 2, b: 2, c: 3}\n assert Map.put(map, :c, 3) |> Map.put(:c, 4) == %{a: 1, b: 2, c: 4}\n end\n\n test \"merge/2 with map literals optimized by the compiler\" do\n map = %{a: 1, b: 2}\n\n assert Map.merge(map, %{a: 2}) == %{a: 2, b: 2}\n assert Map.merge(map, %{c: 3}) == %{a: 1, b: 2, c: 3}\n assert Map.merge(%{a: 2}, map) == %{a: 1, b: 2}\n assert Map.merge(%{c: 3}, map) == %{a: 1, b: 2, c: 3}\n\n assert Map.merge(%{map | a: 2}, %{a: 3}) == %{a: 3, b: 2}\n assert Map.merge(%{map | a: 2}, %{b: 3}) == %{a: 2, b: 3}\n assert Map.merge(%{a: 2}, %{map | a: 3}) == %{a: 3, b: 2}\n assert Map.merge(%{a: 2}, %{map | b: 3}) == %{a: 1, b: 3}\n\n assert Map.merge(map, %{a: 2}) |> Map.merge(%{a: 3, c: 3}) == %{a: 3, b: 2, c: 3}\n assert Map.merge(map, %{c: 3}) |> Map.merge(%{c: 4}) == %{a: 1, b: 2, c: 4}\n assert Map.merge(map, %{a: 3, c: 3}) |> Map.merge(%{a: 2}) == %{a: 2, b: 2, c: 3}\n end\n\n test \"merge/3\" do\n # When first map is bigger\n assert Map.merge(%{a: 1, b: 2, c: 3}, %{c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==\n %{a: 1, b: 2, c: :x, d: 5}\n\n # When second map is bigger\n assert Map.merge(%{b: 2, c: 3}, %{a: 1, c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==\n %{a: 1, b: 2, c: :x, d: 5}\n end\n\n test \"replace/3\" do\n map = %{c: 3, b: 2, a: 1}\n assert Map.replace(map, :b, 10) == %{c: 3, b: 10, a: 1}\n assert Map.replace(map, :a, 1) == map\n assert Map.replace(Process.get(:unused, map), :x, 1) == map\n end\n\n test \"replace!/3\" do\n map = Process.get(:unused, %{c: 3, b: 2, a: 1})\n assert Map.replace!(map, :b, 10) == %{c: 3, b: 10, a: 1}\n assert Map.replace!(map, :a, 1) == map\n\n assert_raise KeyError, ~r/key :x not found in:\\n\\n %{.*a: 1.*}/, fn ->\n Map.replace!(map, :x, 10)\n end\n end\n\n test \"intersect/2\" do\n map = %{a: 1, b: 2}\n\n assert Map.intersect(map, %{a: 2}) == %{a: 2}\n assert Map.intersect(map, %{c: 3}) == %{}\n assert Map.intersect(%{a: 2}, map) == %{a: 1}\n assert Map.intersect(%{c: 3}, map) == %{}\n\n assert Map.intersect(map, %{a: 2}) |> Map.intersect(%{a: 3, c: 3}) == %{a: 3}\n assert Map.intersect(map, %{c: 3}) |> Map.intersect(%{c: 4}) == %{}\n assert Map.intersect(map, %{a: 3, c: 3}) |> Map.intersect(%{a: 2}) == %{a: 2}\n end\n\n test \"intersect/3\" do\n # When first map is bigger\n assert Map.intersect(%{a: 1, b: 2, c: 3}, %{c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==\n %{c: :x}\n\n # When second map is bigger\n assert Map.intersect(%{b: 2, c: 3}, %{a: 1, c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==\n %{c: :x}\n end\n\n test \"implements (almost) all functions in Keyword\" do\n assert Keyword.__info__(:functions) -- Map.__info__(:functions) == [\n delete: 3,\n delete_first: 2,\n get_values: 2,\n keyword?: 1,\n pop_first: 2,\n pop_first: 3,\n pop_values: 2,\n validate: 2,\n validate!: 2\n ]\n end\n\n test \"variable keys\" do\n x = :key\n %{^x => :value} = %{x => :value}\n assert %{x => :value} == %{key: :value}\n assert (fn %{^x => :value} -> true end).(%{key: :value})\n\n map = %{x => :value}\n assert %{map | x => :new_value} == %{x => :new_value}\n end\n\n defmodule ExternalUser do\n defstruct name: \"john\", age: 27\n end\n\n test \"structs\" do\n assert %ExternalUser{} == %{__struct__: ExternalUser, name: \"john\", age: 27}\n assert %ExternalUser{name: \"meg\"} == %{__struct__: ExternalUser, name: \"meg\", age: 27}\n\n %ExternalUser{name: name} = %ExternalUser{}\n assert name == \"john\"\n end\n\n describe \"structs with variable name\" do\n test \"extracts the struct module\" do\n %module{name: \"john\"} = %ExternalUser{name: \"john\", age: 27}\n assert module == ExternalUser\n end\n\n test \"returns the struct on match\" do\n assert Code.eval_string(\"%struct{} = %ExternalUser{}\", [], __ENV__) ==\n {%ExternalUser{}, [struct: ExternalUser]}\n end\n\n test \"supports the pin operator\" do\n module = ExternalUser\n user = %ExternalUser{name: \"john\", age: 27}\n %^module{name: \"john\"} = user\n end\n\n test \"is supported in case\" do\n user = %ExternalUser{name: \"john\", age: 27}\n\n case user do\n %module{} = %{age: 27} -> assert module == ExternalUser\n end\n end\n\n defp destruct1(%module{}), do: module\n defp destruct2(%_{}), do: :ok\n\n test \"does not match\" do\n invalid_struct = Process.get(:unused, %{__struct__: \"foo\"})\n\n assert_raise CaseClauseError, fn ->\n case invalid_struct do\n %module{} -> module\n end\n end\n\n assert_raise CaseClauseError, fn ->\n case invalid_struct do\n %_{} -> :ok\n end\n end\n\n assert_raise CaseClauseError, fn ->\n foo = Process.get(:unused, \"foo\")\n\n case invalid_struct do\n %^foo{} -> :ok\n end\n end\n\n assert_raise FunctionClauseError, fn ->\n destruct1(invalid_struct)\n end\n\n assert_raise FunctionClauseError, fn ->\n destruct2(invalid_struct)\n end\n\n assert_raise MatchError, fn ->\n %module{} = invalid_struct\n _ = module\n end\n\n assert_raise MatchError, fn ->\n %_{} = invalid_struct\n end\n\n assert_raise MatchError, fn ->\n foo = Process.get(:unused, \"foo\")\n %^foo{} = invalid_struct\n end\n end\n end\n\n test \"structs when using dynamic modules\" do\n defmodule Module.concat(MapTest, DynamicUser) do\n defstruct [:name, :age]\n\n def sample do\n %__MODULE__{}\n end\n end\n end\n\n test \"structs when quoted\" do\n quoted =\n quote do\n %User{foo: 1}\n end\n\n assert {:%, [], [aliases, {:%{}, [], [{:foo, 1}]}]} = quoted\n assert aliases == {:__aliases__, [alias: false], [:User]}\n\n quoted =\n quote do\n %unquote(User){foo: 1}\n end\n\n assert quoted == {:%, [], [User, {:%{}, [], [{:foo, 1}]}]}\n end\n\n test \"structs with bitstring defaults\" do\n defmodule WithBitstring do\n defstruct bitstring: <<255, 127::7>>\n end\n\n info = Macro.struct_info!(WithBitstring, __ENV__)\n assert info == [%{default: <<255, 127::7>>, field: :bitstring, required: false}]\n end\n\n test \"defstruct can only be used once in a module\" do\n message =\n \"defstruct has already been called for TestMod, \" <>\n \"defstruct can only be called once per module\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule TestMod do\n defstruct [:foo]\n defstruct [:foo]\n end\n \"\"\")\n end\n end\n\n test \"defstruct allows keys to be enforced\" do\n message = \"the following keys must also be given when building struct TestMod: [:foo]\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule TestMod do\n @enforce_keys :foo\n defstruct [:foo]\n\n # Verify it remain set afterwards\n :foo = @enforce_keys\n\n def foo do\n %TestMod{}\n end\n end\n \"\"\")\n end\n end\n\n test \"defstruct raises on invalid enforce_keys\" do\n message = \"keys given to @enforce_keys must be atoms, got: \\\"foo\\\"\"\n\n assert_raise ArgumentError, message, fn ->\n Code.eval_string(\"\"\"\n defmodule TestMod do\n @enforce_keys \"foo\"\n defstruct [:foo]\n end\n \"\"\")\n end\n end\n\n test \"struct always expands context module\" do\n Code.compiler_options(ignore_module_conflict: true)\n\n defmodule LocalPoint do\n defstruct x: 0\n def new, do: %LocalPoint{}\n end\n\n assert LocalPoint.new() == %{__struct__: LocalPoint, x: 0}\n\n defmodule LocalPoint do\n defstruct x: 0, y: 0\n def new, do: %LocalPoint{}\n end\n\n assert LocalPoint.new() == %{__struct__: LocalPoint, x: 0, y: 0}\n after\n Code.compiler_options(ignore_module_conflict: false)\n end\n\n defmodule LocalUser do\n defmodule NestedUser do\n defstruct []\n end\n\n defstruct name: \"john\", nested: struct(NestedUser), context: %{}\n\n def new do\n %LocalUser{}\n end\n\n defmodule Context do\n def new do\n %LocalUser{}\n end\n end\n end\n\n test \"local and nested structs\" do\n assert LocalUser.new() == %LocalUser{name: \"john\", nested: %LocalUser.NestedUser{}}\n assert LocalUser.Context.new() == %LocalUser{name: \"john\", nested: %LocalUser.NestedUser{}}\n end\n\n defmodule :elixir_struct_from_erlang_module do\n defstruct [:hello]\n def world(%:elixir_struct_from_erlang_module{} = struct), do: struct\n end\n\n test \"struct from erlang module\" do\n struct = %:elixir_struct_from_erlang_module{}\n assert :elixir_struct_from_erlang_module.world(struct) == struct\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/descr_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"type_helper.exs\", __DIR__)\n\ndefmodule NoFieldsStruct do\n defstruct []\nend\n\ndefmodule Decimal do\n defstruct [:sign, :coef, :exp]\nend\n\ndefmodule Module.Types.DescrTest do\n use ExUnit.Case, async: true\n\n import Module.Types.Descr\n defmacro domain_key(arg) when is_atom(arg), do: [arg]\n\n defp number(), do: union(integer(), float())\n defp empty_tuple(), do: tuple([])\n defp tuple_of_size_at_least(n) when is_integer(n), do: open_tuple(List.duplicate(term(), n))\n defp tuple_of_size(n) when is_integer(n) and n >= 0, do: tuple(List.duplicate(term(), n))\n defp list(elem_type, tail_type), do: union(empty_list(), non_empty_list(elem_type, tail_type))\n defp map_with_default(descr), do: open_map([{to_domain_keys(:term), descr}])\n\n describe \"union\" do\n test \"bitmap\" do\n assert union(integer(), float()) == union(float(), integer())\n end\n\n test \"term\" do\n assert union(term(), float()) == term()\n assert union(term(), binary()) == term()\n assert union(term(), if_set(binary())) == if_set(term())\n end\n\n test \"none\" do\n assert union(none(), float()) == float()\n assert union(none(), binary()) == binary()\n end\n\n test \"atom\" do\n assert union(atom(), atom([:a])) == atom()\n assert union(atom([:a]), atom([:b])) == atom([:a, :b])\n assert union(atom([:a]), negation(atom([:b]))) == negation(atom([:b]))\n\n assert union(negation(atom([:a, :b])), negation(atom([:b, :c])))\n |> equal?(negation(atom([:b])))\n end\n\n test \"all primitive types\" do\n all = [\n atom(),\n integer(),\n float(),\n bitstring(),\n open_map(),\n non_empty_list(term(), term()),\n empty_list(),\n tuple(),\n fun(),\n pid(),\n port(),\n reference()\n ]\n\n assert Enum.reduce(all, &union/2) |> equal?(term())\n end\n\n test \"dynamic\" do\n assert equal?(union(dynamic(), dynamic()), dynamic())\n assert equal?(union(dynamic(), term()), term())\n assert equal?(union(term(), dynamic()), term())\n\n assert equal?(union(dynamic(atom()), atom()), atom())\n refute equal?(union(dynamic(atom()), atom()), dynamic(atom()))\n\n assert equal?(union(term(), dynamic(if_set(integer()))), union(term(), dynamic(not_set())))\n refute equal?(union(term(), dynamic(if_set(integer()))), dynamic(union(term(), not_set())))\n end\n\n test \"tuple\" do\n assert equal?(union(tuple(), tuple()), tuple())\n\n t = tuple([integer(), atom()])\n assert equal?(union(t, t), t)\n\n assert union(tuple([integer(), atom()]), tuple([float(), atom()]))\n |> equal?(tuple([union(integer(), float()), atom()]))\n\n assert union(tuple([integer(), atom()]), tuple([integer(), binary()]))\n |> equal?(tuple([integer(), union(atom(), binary())]))\n\n assert open_tuple([atom()])\n |> union(tuple([atom(), integer()]))\n |> equal?(open_tuple([atom()]))\n\n assert tuple([union(integer(), atom())])\n |> difference(open_tuple([atom()]))\n |> equal?(tuple([integer()]))\n end\n\n test \"map\" do\n assert equal?(union(open_map(), open_map()), open_map())\n assert equal?(union(closed_map(a: integer()), open_map()), open_map())\n assert equal?(union(closed_map(a: integer()), negation(closed_map(a: integer()))), term())\n\n a_integer_open = open_map(a: integer())\n assert equal?(union(closed_map(a: integer()), a_integer_open), a_integer_open)\n\n # Domain key types\n atom_to_atom = open_map([{domain_key(:atom), atom()}])\n atom_to_integer = open_map([{domain_key(:atom), integer()}])\n\n # Test union identity and different type maps\n assert union(atom_to_atom, atom_to_atom) == atom_to_atom\n\n # Test subtype relationships with domain key maps\n refute open_map([{domain_key(:atom), union(atom(), integer())}])\n |> subtype?(union(atom_to_atom, atom_to_integer))\n\n assert union(atom_to_atom, atom_to_integer)\n |> subtype?(open_map([{domain_key(:atom), union(atom(), integer())}]))\n\n # Test unions with empty and open maps\n assert union(empty_map(), open_map([{domain_key(:integer), atom()}]))\n |> equal?(open_map([{domain_key(:integer), atom()}]))\n\n assert union(open_map(), open_map([{domain_key(:integer), atom()}]))\n |> equal?(open_map())\n\n # Test union of open map and map with domain key\n assert union(open_map(), open_map([{domain_key(:integer), atom()}]))\n |> equal?(open_map())\n\n # Ensure no duplicate, no matter the order\n assert union(\n open_map(a: integer()),\n open_map(a: number(), b: binary())\n )\n |> union(open_map(a: integer())) ==\n union(\n open_map(a: number(), b: binary()),\n open_map(a: integer())\n )\n |> union(open_map(a: integer()))\n end\n\n test \"list\" do\n assert union(list(term()), list(term())) |> equal?(list(term()))\n assert union(list(integer()), list(term())) |> equal?(list(term()))\n\n assert union(difference(list(term()), list(integer())), list(integer()))\n |> equal?(list(term()))\n end\n\n test \"fun\" do\n assert equal?(union(fun(), fun()), fun())\n assert equal?(union(fun(), none_fun(1)), fun())\n\n dynamic_fun = intersection(fun(), dynamic())\n assert equal?(union(dynamic_fun, fun()), fun())\n end\n\n test \"optimizations (maps)\" do\n # The tests are checking the actual implementation, not the semantics.\n # This is why we are using structural comparisons.\n # It's fine to remove these if the implementation changes, but breaking\n # these might have an important impact on compile times.\n\n # Optimization one: same tags, all but one key are structurally equal\n assert union(\n open_map(a: float(), b: atom()),\n open_map(a: integer(), b: atom())\n )\n |> equal?(open_map(a: union(float(), integer()), b: atom()))\n\n assert union(\n closed_map(a: float(), b: atom()),\n closed_map(a: integer(), b: atom())\n ) == closed_map(a: union(float(), integer()), b: atom())\n\n # Optimization two: we can tell that one map is a subtype of the other:\n assert union(\n closed_map(a: term(), b: term()),\n closed_map(a: float(), b: binary())\n ) == closed_map(a: term(), b: term())\n\n assert union(\n open_map(a: term()),\n closed_map(a: float(), b: binary())\n ) == open_map(a: term())\n\n assert union(\n closed_map(a: float(), b: binary()),\n open_map(a: term())\n ) == open_map(a: term())\n\n assert union(\n closed_map(a: term(), b: tuple([term(), term()])),\n closed_map(a: float(), b: tuple([atom(), binary()]))\n ) == closed_map(a: term(), b: tuple([term(), term()]))\n end\n\n test \"optimizations (tuples)\" do\n # Optimization one: same tags, all but one key are structurally equal\n assert union(\n open_tuple([float(), atom()]),\n open_tuple([integer(), atom()])\n ) == open_tuple([union(float(), integer()), atom()])\n\n assert union(\n tuple([float(), atom()]),\n tuple([integer(), atom()])\n ) == tuple([union(float(), integer()), atom()])\n\n # Optimization two: we can tell that one tuple is a subtype of the other\n assert union(\n tuple([term(), term()]),\n tuple([float(), binary()])\n ) == tuple([term(), term()])\n\n assert union(\n open_tuple([term()]),\n tuple([float(), binary()])\n ) == open_tuple([term()])\n\n assert union(\n tuple([float(), binary()]),\n open_tuple([term()])\n ) == open_tuple([term()])\n end\n end\n\n describe \"intersection\" do\n test \"bitmap\" do\n assert intersection(integer(), union(integer(), float())) == integer()\n assert intersection(integer(), float()) == none()\n end\n\n test \"term\" do\n assert intersection(term(), term()) == term()\n assert intersection(term(), float()) == float()\n assert intersection(term(), binary()) == binary()\n end\n\n test \"none\" do\n assert intersection(none(), float()) == none()\n assert intersection(none(), binary()) == none()\n end\n\n test \"atom\" do\n assert intersection(atom(), atom()) == atom()\n assert intersection(atom(), atom([:a])) == atom([:a])\n assert intersection(atom([:a]), atom([:b])) == none()\n assert intersection(atom([:a]), negation(atom([:b]))) == atom([:a])\n end\n\n test \"dynamic\" do\n assert equal?(intersection(dynamic(), dynamic()), dynamic())\n assert equal?(intersection(dynamic(), term()), dynamic())\n assert equal?(intersection(term(), dynamic()), dynamic())\n assert empty?(intersection(dynamic(), none()))\n assert empty?(intersection(intersection(dynamic(), atom()), integer()))\n\n assert empty?(intersection(dynamic(not_set()), term()))\n refute empty?(intersection(dynamic(if_set(integer())), term()))\n\n # Check for structural equivalence\n assert intersection(dynamic(not_set()), term()) == none()\n end\n\n test \"tuple\" do\n assert empty?(intersection(open_tuple([atom()]), open_tuple([integer()])))\n\n assert intersection(open_tuple([atom()]), tuple([term(), integer()]))\n |> equal?(tuple([atom(), integer()]))\n\n assert intersection(tuple([term(), integer()]), tuple([atom(), term()]))\n |> equal?(tuple([atom(), integer()]))\n end\n\n test \"map\" do\n assert intersection(open_map(), open_map()) == open_map()\n assert equal?(intersection(closed_map(a: integer()), open_map()), closed_map(a: integer()))\n\n assert equal?(\n intersection(closed_map(a: integer()), open_map(a: integer())),\n closed_map(a: integer())\n )\n\n assert intersection(closed_map(a: integer()), open_map(b: not_set()))\n |> equal?(closed_map(a: integer()))\n\n assert intersection(closed_map(a: integer()), open_map(b: if_set(integer())))\n |> equal?(closed_map(a: integer()))\n\n assert equal?(\n intersection(closed_map(a: integer()), closed_map(a: if_set(integer()))),\n closed_map(a: integer())\n )\n\n assert empty?(intersection(closed_map(a: integer()), closed_map(a: atom())))\n\n # Maps leaves are actually optimized, so some of the code branches\n # can only be tested through negations. This is the intersection between\n # open_map(a: integer()) and open_map(b: integer())\n a_and_b =\n negation(union(negation(open_map(a: integer())), negation(open_map(b: integer()))))\n\n assert equal?(\n # The additional parts we are intersecting are empty\n intersection(\n union(a_and_b, closed_map(c: float())),\n union(a_and_b, closed_map(d: float()))\n ),\n a_and_b\n )\n\n # This is a regression triggered by an optimization\n assert intersection(\n closed_map(tag: atom([true]), halted: atom([true]), assigns: term()),\n union(\n closed_map(tag: atom([true]), halted: atom([true]), assigns: term()),\n closed_map(tag: atom([true]), halted: term(), assigns: open_map())\n )\n )\n |> equal?(closed_map(tag: atom([true]), halted: atom([true]), assigns: term()))\n end\n\n # Closed maps with not set keys should have no impact\n test \"map closed with not set keys\" do\n assert intersection(closed_map(a: integer()), closed_map(a: integer(), b: not_set())) ==\n closed_map(a: integer())\n\n assert intersection(closed_map(a: integer(), b: not_set()), closed_map(a: integer())) ==\n closed_map(a: integer())\n\n assert intersection(closed_map(a: integer()), closed_map(a: not_set())) ==\n none()\n\n assert intersection(\n closed_map(a: integer(), b: not_set()),\n closed_map(a: integer(), c: not_set())\n ) ==\n closed_map(a: integer())\n end\n\n test \"map with domain keys\" do\n # %{..., int => t1, atom => t2} and %{int => t3}\n # intersection is %{int => t1 and t3, atom => none}\n map1 = open_map([{domain_key(:integer), integer()}, {domain_key(:atom), atom()}])\n map2 = closed_map([{domain_key(:integer), number()}])\n\n intersection = intersection(map1, map2)\n\n expected =\n closed_map([{domain_key(:integer), integer()}, {domain_key(:atom), none()}])\n\n assert equal?(intersection, expected)\n\n # %{..., int => t1, atom => t2} and %{int => t3, pid => t4}\n # intersection is %{int =>t1 and t3, atom => none, pid => t4}\n map1 = open_map([{domain_key(:integer), integer()}, {domain_key(:atom), atom()}])\n map2 = closed_map([{domain_key(:integer), float()}, {domain_key(:pid), binary()}])\n\n intersection = intersection(map1, map2)\n\n expected =\n closed_map([\n {domain_key(:integer), intersection(integer(), float())},\n {domain_key(:atom), none()},\n {domain_key(:pid), binary()}\n ])\n\n assert equal?(intersection, expected)\n\n # %{..., int => t1, string => t3} and %{int => t4}\n # intersection is %{int => t1 and t4, string => none}\n map1 = open_map([{domain_key(:integer), integer()}, {domain_key(:binary), binary()}])\n map2 = closed_map([{domain_key(:integer), float()}])\n\n intersection = intersection(map1, map2)\n\n assert equal?(\n intersection,\n closed_map([\n {domain_key(:integer), intersection(integer(), float())},\n {domain_key(:binary), none()}\n ])\n )\n\n assert subtype?(empty_map(), closed_map([{domain_key(:integer), atom()}]))\n\n t1 = closed_map([{domain_key(:integer), atom()}])\n t2 = closed_map([{domain_key(:integer), binary()}])\n assert equal?(intersection(t1, t2), empty_map())\n\n t1 = closed_map([{domain_key(:integer), atom()}])\n t2 = closed_map([{domain_key(:atom), term()}])\n refute empty?(intersection(t1, t2))\n assert equal?(intersection(t1, t2), empty_map())\n end\n\n test \"list\" do\n assert intersection(list(term()), list(term())) == list(term())\n assert intersection(list(integer()), list(integer())) == list(integer())\n assert intersection(list(integer()), list(number())) == list(integer())\n assert intersection(list(integer()), list(atom())) == empty_list()\n\n # Empty list intersections\n assert intersection(empty_list(), list(term())) == empty_list()\n assert intersection(empty_list(), list(integer())) == empty_list()\n assert intersection(empty_list(), empty_list()) == empty_list()\n\n # List with any type\n assert intersection(list(term()), list(integer())) == list(integer())\n assert intersection(list(term()), list(integer())) == list(integer())\n\n # Intersection with more specific types\n assert intersection(list(integer()), list(atom([:a, :b]))) == empty_list()\n\n # Intersection with union types\n assert intersection(list(union(integer(), atom())), list(number())) == list(integer())\n\n # Intersection with dynamic\n assert equal?(\n intersection(dynamic(list(term())), list(integer())),\n dynamic(list(integer()))\n )\n\n assert equal?(intersection(dynamic(list(term())), list(term())), dynamic(list(term())))\n\n # Nested list intersections\n assert intersection(list(list(integer())), list(list(number()))) == list(list(integer()))\n assert intersection(list(list(integer())), list(list(atom()))) == list(empty_list())\n\n # Intersection with non-list types\n assert intersection(list(integer()), integer()) == none()\n\n # Tests for list with last element\n assert intersection(list(float(), atom()), list(number(), term())) == list(float(), atom())\n\n assert intersection(list(number(), atom()), list(float(), boolean())) ==\n list(float(), boolean())\n\n assert intersection(list(integer(), float()), list(number(), integer())) == empty_list()\n\n # Empty list with last element\n assert intersection(empty_list(), list(integer(), atom())) == empty_list()\n assert intersection(list(integer(), atom()), empty_list()) == empty_list()\n\n # List with any type and specific last element\n assert intersection(list(term(), atom()), list(float(), boolean())) ==\n list(float(), boolean())\n\n assert intersection(list(term(), term()), list(float(), atom())) == list(float(), atom())\n\n # Nested lists with last element\n assert intersection(list(list(integer()), atom()), list(list(number()), boolean())) ==\n list(list(integer()), boolean())\n\n assert list(list(integer(), atom()), float())\n |> intersection(list(list(number(), boolean()), integer())) == empty_list()\n\n # Union types in last element\n assert intersection(list(integer(), union(atom(), binary())), list(number(), atom())) ==\n list(integer(), atom())\n\n # Dynamic with last element\n assert intersection(dynamic(list(term(), atom())), list(integer(), boolean()))\n |> equal?(dynamic(list(integer(), boolean())))\n\n # Intersection with proper list (should result in empty list)\n assert intersection(list(integer(), atom()), list(integer())) == empty_list()\n end\n\n test \"function\" do\n assert not empty?(intersection(negation(none_fun(2)), negation(none_fun(3))))\n end\n end\n\n describe \"difference\" do\n test \"bitmap\" do\n assert difference(float(), integer()) == float()\n assert difference(union(float(), integer()), integer()) == float()\n assert difference(union(float(), integer()), binary()) == union(float(), integer())\n end\n\n test \"term\" do\n assert difference(float(), term()) == none()\n assert difference(integer(), term()) == none()\n end\n\n test \"none\" do\n assert difference(none(), integer()) == none()\n assert difference(none(), float()) == none()\n\n assert difference(integer(), none()) == integer()\n assert difference(float(), none()) == float()\n end\n\n test \"atom\" do\n assert difference(atom([:a]), atom()) == none()\n assert difference(atom([:a]), atom([:b])) == atom([:a])\n end\n\n test \"dynamic\" do\n assert equal?(dynamic(), difference(dynamic(), dynamic()))\n assert equal?(dynamic(), difference(term(), dynamic()))\n assert empty?(difference(dynamic(), term()))\n assert empty?(difference(none(), dynamic()))\n assert empty?(difference(dynamic(integer()), integer()))\n end\n\n test \"tuple\" do\n assert empty?(difference(open_tuple([atom()]), open_tuple([term()])))\n refute empty?(difference(tuple(), empty_tuple()))\n refute tuple_of_size_at_least(2) |> difference(tuple_of_size(2)) |> empty?()\n assert tuple_of_size_at_least(2) |> difference(tuple_of_size_at_least(1)) |> empty?()\n assert tuple_of_size_at_least(3) |> difference(tuple_of_size_at_least(3)) |> empty?()\n refute tuple_of_size_at_least(2) |> difference(tuple_of_size_at_least(3)) |> empty?()\n refute tuple([term(), term()]) |> difference(tuple([atom(), term()])) |> empty?()\n refute tuple([term(), term()]) |> difference(tuple([atom()])) |> empty?()\n assert tuple([term(), term()]) |> difference(tuple([term(), term()])) |> empty?()\n\n assert tuple_of_size_at_least(2)\n |> difference(tuple_of_size(2))\n |> difference(tuple_of_size_at_least(3))\n |> empty?()\n\n assert tuple([term(), term()])\n |> difference(tuple([atom()]))\n |> difference(open_tuple([term()]))\n |> difference(empty_tuple())\n |> empty?()\n\n refute difference(tuple(), empty_tuple())\n |> difference(open_tuple([term(), term()]))\n |> empty?()\n\n assert difference(open_tuple([term()]), open_tuple([term(), term()]))\n |> difference(tuple([term()]))\n |> empty?()\n\n assert tuple([union(atom(), integer()), term()])\n |> difference(open_tuple([atom(), term()]))\n |> difference(open_tuple([integer(), term()]))\n |> empty?()\n\n assert tuple([union(atom(), integer()), term()])\n |> difference(open_tuple([atom(), term()]))\n |> equal?(tuple([integer(), term()]))\n\n assert tuple([term(), union(atom(), integer()), term()])\n |> difference(open_tuple([term(), integer()]))\n |> equal?(tuple([term(), atom(), term()]))\n\n assert difference(tuple(), open_tuple([term(), term()]))\n |> equal?(union(tuple([term()]), tuple([])))\n end\n\n test \"tuple optimizations\" do\n # We do direct assertions because we want to check how it works underneath\n assert difference(tuple([]), tuple([atom()])) == tuple([])\n assert difference(tuple([]), open_tuple([atom()])) == tuple([])\n assert difference(open_tuple([atom()]), tuple([])) == open_tuple([atom()])\n assert difference(tuple([atom([:ok])]), tuple([atom([:error])])) == tuple([atom([:ok])])\n assert difference(tuple([atom([:ok])]), tuple([integer()])) == tuple([atom([:ok])])\n assert difference(tuple([integer()]), tuple([atom()])) == tuple([integer()])\n end\n\n test \"map\" do\n assert difference(open_map(), open_map()) == none()\n assert difference(open_map(), term()) == none()\n assert difference(open_map(), none()) == open_map()\n\n assert empty?(difference(closed_map(a: integer()), open_map()))\n\n assert difference(closed_map(a: integer(), b: if_set(atom())), closed_map(a: integer()))\n |> difference(closed_map(a: integer(), b: atom()))\n |> empty?()\n\n refute empty?(difference(open_map(), empty_map()))\n\n # Difference with single field closed map on rhs\n assert difference(closed_map(a: integer()), closed_map(a: integer())) == none()\n\n assert difference(open_map(a: atom()), closed_map(b: integer()))\n |> equal?(open_map(a: atom()))\n\n assert difference(open_map(a: integer()), closed_map(b: boolean()))\n |> equal?(open_map(a: integer()))\n\n # Difference with single field open map on rhs (they are optimized)\n assert difference(closed_map(a: integer()), open_map(a: integer())) == none()\n assert difference(closed_map(a: integer()), open_map(a: if_set(integer()))) == none()\n\n assert difference(closed_map(a: integer()), open_map(b: integer())) ==\n closed_map(a: integer())\n\n assert difference(closed_map(a: integer()), open_map(b: if_set(integer()))) == none()\n end\n\n test \"map (struct optimizations)\" do\n # We do direct assertions because we want to check how it works underneath\n atom_foo = atom([:foo])\n atom_bar = atom([:bar])\n\n assert difference(open_map(__struct__: atom_foo), open_map(__struct__: atom_bar)) ==\n open_map(__struct__: atom_foo)\n\n assert difference(closed_map(__struct__: atom_foo), open_map(__struct__: atom_bar)) ==\n closed_map(__struct__: atom_foo)\n\n assert difference(open_map(__struct__: atom_foo), closed_map(__struct__: atom_bar)) ==\n open_map(__struct__: atom_foo)\n\n assert difference(closed_map(__struct__: atom_foo), closed_map(__struct__: atom_bar)) ==\n closed_map(__struct__: atom_foo)\n\n assert difference(closed_map(__struct__: atom_foo), closed_map(__struct__: term())) ==\n none()\n\n assert difference(closed_map(__struct__: atom()), closed_map(__struct__: atom_bar)) ==\n closed_map(__struct__: difference(atom(), atom_bar))\n\n # Explicitly assert we keep it as cascading differences\n assert %{map: {{:closed, _}, :bdd_bot, :bdd_bot, _}} =\n difference(\n difference(\n open_map(value: term()),\n closed_map(__struct__: atom_foo, value: term())\n ),\n closed_map(__struct__: atom_bar, name: term())\n )\n end\n\n test \"map with domain keys\" do\n # Non-overlapping domain keys\n t1 = closed_map([{domain_key(:integer), atom()}])\n t2 = closed_map([{domain_key(:atom), binary()}])\n\n assert equal?(difference(t1, t2) |> union(empty_map()), t1)\n assert empty?(difference(t1, t1))\n\n # %{atom() => t1} and not %{atom() => t2} is not %{atom() => t1 and not t2}\n t3 = closed_map([{domain_key(:integer), atom()}])\n t4 = closed_map([{domain_key(:integer), atom([:ok])}])\n assert subtype?(difference(t3, t4), t3)\n\n refute difference(t3, t4)\n |> equal?(closed_map([{domain_key(:integer), difference(atom(), atom([:ok]))}]))\n\n # Difference with a non-domain key map\n t5 = closed_map([{domain_key(:integer), union(atom(), integer())}])\n t6 = closed_map(a: atom())\n assert equal?(difference(t5, t6), t5)\n\n # Removing atom keys from a map with defined atom keys\n a_number = closed_map(a: number())\n a_number_and_pids = closed_map([{:a, number()}, {domain_key(:atom), pid()}])\n atom_to_float = closed_map([{domain_key(:atom), float()}])\n atom_to_term = closed_map([{domain_key(:atom), term()}])\n atom_to_pid = closed_map([{domain_key(:atom), pid()}])\n t_diff = difference(a_number, atom_to_float)\n\n # Removing atom keys that map to float, make the :a key point to integer only.\n assert map_fetch_key(t_diff, :a) == {false, integer()}\n # %{a => number, atom => pid} and not %{atom => float} gives numbers on :a\n assert map_fetch_key(difference(a_number_and_pids, atom_to_float), :a) == {false, number()}\n\n assert map_fetch_key(t_diff, :foo) == :badkey\n\n assert subtype?(a_number, atom_to_term)\n refute subtype?(a_number, atom_to_float)\n\n # Removing all atom keys from map %{:a => type} means there is nothing left.\n assert empty?(difference(a_number, atom_to_term))\n refute empty?(intersection(atom_to_term, a_number))\n assert empty?(intersection(atom_to_pid, a_number))\n\n # (%{:a => number} and not %{:a => float}) is %{:a => integer}\n assert equal?(difference(a_number, atom_to_float), closed_map(a: integer()))\n end\n\n test \"list\" do\n # Basic list type differences\n assert difference(list(term()), empty_list()) == non_empty_list(term())\n assert difference(list(integer()), list(term())) |> empty?()\n\n assert difference(list(integer()), list(float()))\n |> equal?(non_empty_list(integer()))\n\n # All list of integers and floats, minus all lists of integers, is NOT all lists of floats\n refute difference(list(union(integer(), float())), list(integer()))\n |> equal?(non_empty_list(float()))\n\n # Interactions with empty_list()\n assert difference(empty_list(), list(term())) == none()\n assert difference(list(integer()), empty_list()) == non_empty_list(integer())\n\n # Nested list structures\n assert difference(list(list(integer())), list(list(float())))\n |> equal?(difference(list(list(integer())), list(empty_list())))\n\n # Lists with union types\n refute difference(list(union(integer(), float())), list(integer())) == list(float())\n refute difference(list(union(atom(), binary())), list(atom())) == list(binary())\n\n # Tests for list with last element\n assert difference(list(integer(), atom()), list(number(), term())) |> empty?()\n\n assert difference(\n list(atom(), term()),\n difference(list(atom(), term()), list(atom()))\n )\n |> equal?(list(atom()))\n\n assert difference(list(integer(), float()), list(number(), integer()))\n |> equal?(non_empty_list(integer(), difference(float(), integer())))\n\n # Empty list with last element\n assert difference(empty_list(), list(integer(), atom())) == none()\n\n assert difference(list(integer(), atom()), empty_list()) ==\n non_empty_list(integer(), atom())\n\n # List with any type and specific last element\n assert difference(list(term(), term()), list(term(), integer()))\n |> equal?(\n non_empty_list(term(), negation(union(integer(), non_empty_list(term(), term()))))\n )\n\n # Nested lists with last element\n # \"lists of (lists of integers), ending with atom\"\n # minus\n # \"lists of (lists of numbers), ending with boolean\"\n # gives:\n # \"non empty lists of (lists of integers), ending with (atom and not boolean)\"\n\n assert difference(list(list(integer()), atom()), list(list(number()), boolean()))\n |> equal?(non_empty_list(list(integer()), difference(atom(), boolean())))\n\n # Union types in last element\n assert difference(list(integer(), union(atom(), binary())), list(number(), atom()))\n |> equal?(\n union(\n non_empty_list(integer(), binary()),\n non_empty_list(difference(integer(), number()), union(atom(), binary()))\n )\n )\n\n # Dynamic with last element\n assert equal?(\n difference(dynamic(list(term(), atom())), list(integer(), term())),\n dynamic(difference(list(term(), atom()), list(integer(), term())))\n )\n\n # Difference with proper list\n assert difference(list(integer(), atom()), list(integer()))\n |> equal?(non_empty_list(integer(), atom()))\n end\n\n test \"fun\" do\n for arity <- [0, 1, 2, 3] do\n assert empty?(difference(none_fun(arity), none_fun(arity)))\n end\n\n assert empty?(difference(fun(), fun()))\n assert empty?(difference(none_fun(3), fun()))\n refute empty?(difference(fun(), none_fun(1)))\n refute empty?(difference(none_fun(2), none_fun(3)))\n assert empty?(intersection(none_fun(2), none_fun(3)))\n\n f1f2 = union(none_fun(1), none_fun(2))\n assert f1f2 |> difference(none_fun(1)) |> difference(none_fun(2)) |> empty?()\n assert none_fun(1) |> difference(difference(f1f2, none_fun(2))) |> empty?()\n assert f1f2 |> difference(none_fun(1)) |> equal?(none_fun(2))\n\n assert fun([integer()], term()) |> difference(fun([none()], term())) |> empty?()\n end\n end\n\n describe \"creation\" do\n test \"map hoists dynamic\" do\n assert dynamic(open_map(a: integer())) == open_map(a: dynamic(integer()))\n\n assert dynamic(open_map(a: union(integer(), binary()))) ==\n open_map(a: dynamic(integer()) |> union(binary()))\n\n # For domains too\n t1 = dynamic(open_map([{domain_key(:integer), integer()}]))\n t2 = open_map([{domain_key(:integer), dynamic(integer())}])\n assert t1 == t2\n\n # if_set on dynamic fields also must work\n t1 = dynamic(open_map(a: if_set(integer())))\n t2 = open_map(a: if_set(dynamic(integer())))\n assert t1 == t2\n end\n end\n\n describe \"subtype\" do\n test \"bitmap\" do\n assert subtype?(integer(), union(integer(), float()))\n assert subtype?(integer(), integer())\n assert subtype?(integer(), term())\n assert subtype?(none(), integer())\n assert subtype?(integer(), negation(float()))\n end\n\n test \"atom\" do\n assert subtype?(atom([:a]), atom())\n assert subtype?(atom([:a]), atom([:a]))\n assert subtype?(atom([:a]), term())\n assert subtype?(none(), atom([:a]))\n assert subtype?(atom([:a]), atom([:a, :b]))\n assert subtype?(atom([:a]), negation(atom([:b])))\n end\n\n test \"dynamic\" do\n assert subtype?(dynamic(), term())\n assert subtype?(dynamic(), dynamic())\n refute subtype?(term(), dynamic())\n assert subtype?(intersection(dynamic(), integer()), integer())\n assert subtype?(integer(), union(dynamic(), integer()))\n end\n\n test \"tuple\" do\n assert subtype?(empty_tuple(), tuple())\n assert subtype?(tuple([integer(), atom()]), tuple())\n refute subtype?(empty_tuple(), open_tuple([term()]))\n assert subtype?(tuple([integer(), atom()]), tuple([term(), term()]))\n refute subtype?(tuple([integer(), atom()]), tuple([integer(), integer()]))\n refute subtype?(tuple([integer(), atom()]), tuple([atom(), atom()]))\n\n assert subtype?(tuple([integer(), atom()]), open_tuple([integer(), atom()]))\n refute subtype?(tuple([term()]), open_tuple([term(), term()]))\n refute subtype?(tuple([integer(), atom()]), open_tuple([integer(), integer()]))\n refute subtype?(open_tuple([integer(), atom()]), tuple([integer(), integer()]))\n end\n\n test \"map\" do\n assert subtype?(open_map(), term())\n assert subtype?(closed_map(a: integer()), open_map())\n assert subtype?(closed_map(a: integer()), closed_map(a: integer()))\n assert subtype?(closed_map(a: integer()), open_map(a: integer()))\n assert subtype?(closed_map(a: integer(), b: atom()), open_map(a: integer()))\n assert subtype?(closed_map(a: integer()), closed_map(a: union(integer(), atom())))\n\n # optional\n refute subtype?(closed_map(a: if_set(integer())), closed_map(a: integer()))\n assert subtype?(closed_map(a: integer()), closed_map(a: if_set(integer())))\n refute subtype?(closed_map(a: if_set(term())), closed_map(a: term()))\n assert subtype?(closed_map(a: term()), closed_map(a: if_set(term())))\n\n # With domains\n t1 = closed_map([{domain_key(:integer), number()}])\n t2 = closed_map([{domain_key(:integer), integer()}])\n\n assert subtype?(t2, t1)\n\n t1_minus_t2 = difference(t1, t2)\n refute empty?(t1_minus_t2)\n\n assert subtype?(map_with_default(number()), open_map())\n t = difference(open_map(), map_with_default(number()))\n refute empty?(t)\n refute subtype?(open_map(), map_with_default(number()))\n assert subtype?(map_with_default(integer()), map_with_default(number()))\n refute subtype?(map_with_default(float()), map_with_default(atom()))\n\n assert equal?(\n intersection(map_with_default(number()), map_with_default(float())),\n map_with_default(float())\n )\n end\n\n test \"optional\" do\n refute subtype?(if_set(none()), term())\n refute subtype?(if_set(term()), term())\n assert subtype?(if_set(term()), if_set(term()))\n refute subtype?(if_set(term()), if_set(dynamic(term())))\n end\n\n test \"list\" do\n refute subtype?(non_empty_list(integer()), difference(list(number()), list(integer())))\n assert subtype?(list(term(), boolean()), list(term(), atom()))\n assert subtype?(list(integer()), list(term()))\n assert subtype?(list(term()), list(term(), term()))\n end\n\n test \"fun\" do\n assert equal?(fun([], term()), fun([], term()))\n refute equal?(fun([], integer()), fun([], atom()))\n refute subtype?(fun([none()], term()), fun([integer()], integer()))\n\n # Difference with argument/return type variations\n int_to_atom = fun([integer()], atom())\n num_to_atom = fun([number()], atom())\n int_to_bool = fun([integer()], boolean())\n\n # number->atom is a subtype of int->atom\n assert subtype?(num_to_atom, int_to_atom)\n refute subtype?(int_to_atom, num_to_atom)\n assert subtype?(int_to_bool, int_to_atom)\n refute subtype?(int_to_bool, num_to_atom)\n\n # Multi-arity\n f1 = fun([integer(), atom()], boolean())\n f2 = fun([number(), atom()], boolean())\n\n # (int,atom)->boolean is a subtype of (number,atom)->boolean\n # since number is a supertype of int\n assert subtype?(f2, f1)\n # f1 is not a subtype of f2\n refute subtype?(f1, f2)\n\n # Unary functions / Output covariance\n assert subtype?(fun([], float()), fun([], term()))\n refute subtype?(fun([], term()), fun([], float()))\n\n # Contravariance of domain\n refute subtype?(fun([integer()], boolean()), fun([number()], boolean()))\n assert subtype?(fun([number()], boolean()), fun([integer()], boolean()))\n\n # Nested function types\n higher_order = fun([fun([integer()], atom())], boolean())\n specific = fun([fun([number()], atom())], boolean())\n\n assert subtype?(higher_order, specific)\n refute subtype?(specific, higher_order)\n\n ## Multi-arity\n f = fun([none(), integer()], atom())\n assert subtype?(f, f)\n assert subtype?(f, fun([none(), integer()], term()))\n assert subtype?(fun([none(), number()], atom()), f)\n assert subtype?(fun([tuple(), number()], atom()), f)\n\n # (none, float -> atom) is not a subtype of (none, integer -> atom)\n # because float has an empty intersection with integer.\n # it's only possible to find this out by doing the\n # intersection one by one.\n refute subtype?(fun([none(), float()], atom()), f)\n refute subtype?(fun([pid(), float()], atom()), f)\n # A function with the wrong arity is refused\n refute subtype?(fun([none()], atom()), f)\n end\n end\n\n describe \"compatible\" do\n test \"intersection\" do\n assert compatible?(integer(), intersection(dynamic(), integer()))\n refute compatible?(intersection(dynamic(), integer()), atom())\n refute compatible?(atom(), intersection(dynamic(), integer()))\n refute compatible?(atom(), intersection(dynamic(), atom([:foo, :bar])))\n assert compatible?(intersection(dynamic(), atom()), atom([:foo, :bar]))\n assert compatible?(atom([:foo, :bar]), intersection(dynamic(), atom()))\n end\n\n test \"static\" do\n refute compatible?(atom(), atom([:foo, :bar]))\n refute compatible?(union(integer(), atom()), integer())\n refute compatible?(none(), integer())\n refute compatible?(union(atom(), dynamic()), integer())\n end\n\n test \"dynamic\" do\n assert compatible?(dynamic(), term())\n assert compatible?(term(), dynamic())\n assert compatible?(dynamic(), integer())\n assert compatible?(integer(), dynamic())\n end\n\n test \"tuple\" do\n assert compatible?(dynamic(tuple()), tuple([integer(), atom()]))\n end\n\n test \"map\" do\n assert compatible?(closed_map(a: integer()), open_map())\n assert compatible?(intersection(dynamic(), open_map()), closed_map(a: integer()))\n end\n\n test \"list\" do\n assert compatible?(dynamic(), list(term()))\n assert compatible?(dynamic(list(term())), list(integer()))\n assert compatible?(dynamic(list(term(), term())), list(integer(), integer()))\n end\n end\n\n describe \"empty?\" do\n test \"tuple\" do\n assert tuple([none()]) |> empty?()\n assert open_tuple([integer(), none()]) |> empty?()\n\n assert intersection(tuple([integer(), atom()]), open_tuple([atom()])) |> empty?()\n refute open_tuple([integer(), integer()]) |> difference(empty_tuple()) |> empty?()\n refute open_tuple([integer(), integer()]) |> difference(open_tuple([atom()])) |> empty?()\n refute open_tuple([term()]) |> difference(tuple([term()])) |> empty?()\n assert difference(tuple(), empty_tuple()) |> difference(open_tuple([term()])) |> empty?()\n assert difference(tuple(), open_tuple([term()])) |> difference(empty_tuple()) |> empty?()\n\n refute open_tuple([term()])\n |> difference(tuple([term()]))\n |> difference(tuple([term()]))\n |> empty?()\n\n assert tuple([integer(), union(integer(), atom())])\n |> difference(tuple([integer(), integer()]))\n |> difference(tuple([integer(), atom()]))\n |> empty?()\n end\n\n test \"map\" do\n assert open_map(a: none()) |> empty?()\n assert closed_map(a: integer(), b: none()) |> empty?()\n assert intersection(closed_map(b: atom()), open_map(a: integer())) |> empty?()\n end\n\n test \"fun\" do\n refute empty?(fun())\n refute empty?(none_fun(1))\n refute empty?(fun([integer()], atom()))\n\n assert empty?(intersection(none_fun(1), none_fun(2)))\n refute empty?(intersection(fun(), none_fun(1)))\n assert empty?(difference(none_fun(1), union(none_fun(1), none_fun(2))))\n end\n end\n\n describe \"function creation\" do\n test \"fun_from_non_overlapping_clauses\" do\n assert fun_from_non_overlapping_clauses([{[integer()], atom()}, {[float()], binary()}]) ==\n intersection(fun([integer()], atom()), fun([float()], binary()))\n end\n\n test \"fun_from_inferred_clauses\" do\n # No overlap\n assert fun_from_inferred_clauses([{[integer()], atom()}, {[float()], binary()}])\n |> equal?(\n intersection(\n fun_from_non_overlapping_clauses([{[integer()], atom()}, {[float()], binary()}]),\n fun([number()], dynamic())\n )\n )\n\n # Subsets\n assert fun_from_inferred_clauses([{[integer()], atom()}, {[number()], binary()}])\n |> equal?(\n fun_from_non_overlapping_clauses([\n {[integer()], dynamic(union(atom(), binary()))},\n {[number()], dynamic(union(atom(), binary()))}\n ])\n )\n\n assert fun_from_inferred_clauses([{[number()], binary()}, {[integer()], atom()}])\n |> equal?(\n fun_from_non_overlapping_clauses([\n {[integer()], dynamic(union(atom(), binary()))},\n {[number()], dynamic(union(atom(), binary()))}\n ])\n )\n\n # Partial\n assert fun_from_inferred_clauses([\n {[union(integer(), pid())], atom()},\n {[union(float(), pid())], binary()}\n ])\n |> equal?(\n fun_from_non_overlapping_clauses([\n {[union(integer(), pid())], dynamic(union(atom(), binary()))},\n {[union(float(), pid())], dynamic(union(atom(), binary()))}\n ])\n )\n\n # Difference\n assert fun_from_inferred_clauses([\n {[integer(), union(pid(), atom())], atom()},\n {[number(), pid()], binary()}\n ])\n |> equal?(\n fun_from_non_overlapping_clauses([\n {[integer(), union(pid(), atom())], dynamic(union(atom(), binary()))},\n {[number(), pid()], dynamic(union(atom(), binary()))}\n ])\n )\n end\n end\n\n describe \"function application\" do\n defp none_fun(arity), do: %{fun: {:union, %{arity => :bdd_top}}}\n\n test \"non funs\" do\n assert fun_apply(term(), [integer()]) == :badfun\n assert fun_apply(integer(), [integer()]) == :badfun\n assert fun_apply(union(integer(), none_fun(1)), [integer()]) == :badfun\n assert fun_apply(union(integer(), fun([integer()], atom())), [integer()]) == :badfun\n assert fun_apply(union(integer(), dynamic()), [integer()]) == :badfun\n end\n\n test \"static\" do\n # Full static\n assert fun_apply(fun(), [integer()]) == {:badarg, [none()]}\n assert fun_apply(difference(fun(), none_fun(2)), [integer()]) == {:badarg, [none()]}\n\n # Basic function application scenarios\n assert fun_apply(fun([integer()], atom()), [integer()]) == {:ok, atom()}\n assert fun_apply(fun([integer()], atom()), [float()]) == {:badarg, [integer()]}\n assert fun_apply(fun([integer()], atom()), [term()]) == {:badarg, [integer()]}\n\n # Union argument type: domain is int | float\n assert fun_apply(fun([union(integer(), float())], atom()), [integer()]) == {:ok, atom()}\n assert fun_apply(fun([union(integer(), float())], atom()), [float()]) == {:ok, atom()}\n\n assert fun_apply(fun([union(integer(), float())], atom()), [atom()]) ==\n {:badarg, [union(integer(), float())]}\n\n # 2-arity function\n assert fun_apply(fun([integer(), atom()], binary()), [integer(), atom()]) == {:ok, binary()}\n\n assert fun_apply(fun([integer(), atom()], binary()), [boolean(), atom()]) ==\n {:badarg, [integer(), atom()]}\n\n # Return types\n assert fun_apply(fun([integer()], none()), [integer()]) == {:ok, none()}\n assert fun_apply(fun([integer()], term()), [integer()]) == {:ok, term()}\n\n # Dynamic args\n assert fun_apply(fun([term()], term()), [dynamic()]) == {:ok, term()}\n\n assert fun_apply(fun([integer()], atom()), [dynamic(integer())])\n |> elem(1)\n |> equal?(atom())\n\n assert fun_apply(fun([integer()], atom()), [dynamic(float())]) == {:badarg, [integer()]}\n assert fun_apply(fun([integer()], atom()), [dynamic(term())]) == {:ok, dynamic()}\n\n # Arity mismatches\n assert fun_apply(fun([integer()], integer()), [term(), term()]) == {:badarity, [1]}\n assert fun_apply(fun([integer(), atom()], boolean()), [integer()]) == {:badarity, [2]}\n\n # Union of two different arities: always badarity regardless of which arity is called\n fun_mixed = union(fun([integer()], integer()), fun([integer(), atom()], boolean()))\n assert fun_apply(fun_mixed, [integer()]) == {:badarity, [1, 2]}\n assert fun_apply(fun_mixed, [integer(), atom()]) == {:badarity, [2, 1]}\n\n # Function intersection tests (no overlap)\n fun0 = intersection(fun([integer()], atom()), fun([float()], binary()))\n assert fun_apply(fun0, [integer()]) == {:ok, atom()}\n assert fun_apply(fun0, [float()]) == {:ok, binary()}\n assert fun_apply(fun0, [number()]) == {:ok, union(atom(), binary())}\n\n assert fun_apply(fun0, [dynamic(integer())]) |> elem(1) |> equal?(atom())\n assert fun_apply(fun0, [dynamic(float())]) |> elem(1) |> equal?(binary())\n assert fun_apply(fun0, [dynamic(number())]) |> elem(1) |> equal?(union(atom(), binary()))\n assert fun_apply(fun0, [dynamic()]) == {:ok, dynamic()}\n\n # Function intersection tests (overlap)\n fun1 = intersection(fun([integer()], atom()), fun([number()], term()))\n assert fun_apply(fun1, [integer()]) == {:ok, atom()}\n assert fun_apply(fun1, [float()]) == {:ok, term()}\n\n # Function intersection with unions\n fun2 =\n intersection(\n fun([union(integer(), atom())], term()),\n fun([union(integer(), pid())], atom())\n )\n\n assert fun_apply(fun2, [integer()]) == {:ok, atom()}\n assert fun_apply(fun2, [atom()]) == {:ok, term()}\n assert fun_apply(fun2, [pid()]) == {:ok, atom()}\n\n # Function intersection with same domain, different codomains\n assert fun([integer()], term())\n |> intersection(fun([integer()], atom()))\n |> fun_apply([integer()]) == {:ok, atom()}\n\n # Function intersection with singleton atoms\n fun3 = intersection(fun([atom([:ok])], atom([:success])), fun([atom([:ok])], atom([:done])))\n assert fun_apply(fun3, [atom([:ok])]) == {:ok, none()}\n end\n\n test \"static with dynamic signature\" do\n assert fun_apply(fun([dynamic()], term()), [dynamic()]) == {:ok, term()}\n assert fun_apply(fun([integer()], dynamic()), [integer()]) == {:ok, dynamic()}\n\n assert fun_apply(fun([dynamic()], integer()), [dynamic()]) ==\n {:ok, union(integer(), dynamic())}\n\n assert fun_apply(fun([dynamic(), atom()], float()), [dynamic(), atom()]) ==\n {:ok, union(float(), dynamic())}\n\n fun = fun([dynamic(integer())], atom())\n assert fun_apply(fun, [dynamic(integer())]) == {:ok, union(atom(), dynamic())}\n assert fun_apply(fun, [dynamic(number())]) == {:ok, dynamic()}\n assert fun_apply(fun, [integer()]) == {:ok, dynamic()}\n assert fun_apply(fun, [float()]) == {:badarg, [dynamic(integer())]}\n end\n\n defp dynamic_fun(args, return), do: dynamic(fun(args, return))\n\n test \"dynamic\" do\n # Full dynamic\n assert fun_apply(dynamic(), [integer()]) == {:ok, dynamic()}\n assert fun_apply(dynamic(none_fun(1)), [integer()]) == {:ok, dynamic()}\n assert fun_apply(difference(dynamic(), none_fun(2)), [integer()]) == {:ok, dynamic()}\n\n # Basic function application scenarios\n assert fun_apply(dynamic_fun([integer()], atom()), [integer()]) == {:ok, dynamic(atom())}\n assert fun_apply(dynamic_fun([integer()], atom()), [float()]) == {:ok, dynamic()}\n assert fun_apply(dynamic_fun([integer()], atom()), [term()]) == {:ok, dynamic()}\n assert fun_apply(dynamic_fun([integer()], none()), [integer()]) == {:ok, dynamic(none())}\n assert fun_apply(dynamic_fun([integer()], term()), [integer()]) == {:ok, dynamic()}\n\n # Dynamic return and dynamic args\n assert fun_apply(dynamic_fun([term()], term()), [dynamic()]) == {:ok, dynamic()}\n\n fun = dynamic_fun([integer()], binary())\n assert fun_apply(fun, [integer()]) == {:ok, dynamic(binary())}\n assert fun_apply(fun, [dynamic(integer())]) == {:ok, dynamic(binary())}\n assert fun_apply(fun, [dynamic(atom())]) == {:ok, dynamic()}\n\n # Arity mismatches\n assert fun_apply(dynamic_fun([integer()], integer()), [term(), term()]) == {:badarity, [1]}\n\n assert fun_apply(dynamic_fun([integer(), atom()], boolean()), [integer()]) ==\n {:badarity, [2]}\n\n # Union of two dynamic functions with different arities: the call may succeed,\n # so we pick the matching-arity arrows and wrap in dynamic().\n fun_dyn_mixed =\n union(dynamic_fun([integer()], integer()), dynamic_fun([integer(), atom()], boolean()))\n\n # picks arity-1 arrows → dynamic(integer())\n assert fun_apply(fun_dyn_mixed, [integer()]) == {:ok, dynamic(integer())}\n # picks arity-2 arrows → dynamic(boolean())\n assert fun_apply(fun_dyn_mixed, [integer(), atom()]) == {:ok, dynamic(boolean())}\n # no matching arity → badarity (no dynamic escape here)\n assert fun_apply(fun_dyn_mixed, [integer(), atom(), float()]) == {:badarity, [1, 2]}\n # arg outside arity-1 domain but dynamic-compatible → dynamic()\n assert fun_apply(fun_dyn_mixed, [atom()]) == {:ok, dynamic()}\n\n # Function intersection tests\n fun0 = intersection(dynamic_fun([integer()], atom()), dynamic_fun([float()], binary()))\n assert fun_apply(fun0, [integer()]) == {:ok, dynamic(atom())}\n assert fun_apply(fun0, [float()]) == {:ok, dynamic(binary())}\n assert fun_apply(fun0, [dynamic(integer())]) == {:ok, dynamic(atom())}\n assert fun_apply(fun0, [dynamic(float())]) == {:ok, dynamic(binary())}\n assert fun_apply(fun0, [dynamic(number())]) == {:ok, dynamic(union(binary(), atom()))}\n\n # Function intersection with subset domain\n fun1 = intersection(dynamic_fun([integer()], atom()), dynamic_fun([number()], term()))\n assert fun_apply(fun1, [integer()]) == {:ok, dynamic(atom())}\n assert fun_apply(fun1, [float()]) == {:ok, dynamic()}\n assert fun_apply(fun1, [dynamic(integer())]) == {:ok, dynamic(atom())}\n assert fun_apply(fun1, [dynamic(float())]) == {:ok, dynamic()}\n\n # Function intersection with same domain, different codomains\n assert dynamic_fun([integer()], term())\n |> intersection(dynamic_fun([integer()], atom()))\n |> fun_apply([integer()]) == {:ok, dynamic(atom())}\n\n # Function intersection with overlapping domains\n fun2 =\n intersection(\n dynamic_fun([union(integer(), atom())], term()),\n dynamic_fun([union(integer(), pid())], atom())\n )\n\n assert fun_apply(fun2, [integer()]) == {:ok, dynamic(atom())}\n assert fun_apply(fun2, [atom()]) == {:ok, dynamic()}\n assert fun_apply(fun2, [pid()]) |> elem(1) |> equal?(dynamic(atom()))\n\n assert fun_apply(fun2, [dynamic(integer())]) == {:ok, dynamic(atom())}\n assert fun_apply(fun2, [dynamic(atom())]) == {:ok, dynamic()}\n assert fun_apply(fun2, [dynamic(pid())]) |> elem(1) |> equal?(dynamic(atom()))\n\n # Function intersection with singleton atoms\n fun3 =\n intersection(\n dynamic_fun([atom([:ok])], atom([:success])),\n dynamic_fun([atom([:ok])], atom([:done]))\n )\n\n assert fun_apply(fun3, [atom([:ok])]) == {:ok, dynamic(none())}\n\n # Testing the special case of uplifiting both the function and argument\n # when the function is purely dynamic\n fun4 =\n intersection(\n dynamic_fun([integer()], integer()),\n dynamic_fun([boolean()], boolean())\n )\n\n # dynamic(int->int and bool->bool) applied to dynamic(int)\n assert fun_apply(fun4, [dynamic(integer())]) == {:ok, dynamic(integer())}\n\n # float escapes the domain so the result is dynamic()\n arg = dynamic(union(integer(), float()))\n assert fun_apply(fun4, [arg]) == {:ok, dynamic()}\n\n assert fun_apply(dynamic(), [integer()]) == {:ok, dynamic()}\n end\n\n test \"static and dynamic\" do\n # Bad arity\n fun_arities =\n union(\n fun([atom()], integer()),\n dynamic_fun([integer(), float()], binary())\n )\n\n assert fun_arities\n |> fun_apply([atom()])\n |> elem(1)\n |> equal?(integer())\n\n assert fun_arities |> fun_apply([integer(), float()]) == {:badarity, [1]}\n\n # Bad argument\n fun_args =\n union(\n fun([atom()], integer()),\n dynamic_fun([integer()], binary())\n )\n\n assert fun_args |> fun_apply([atom()]) == {:ok, dynamic()}\n assert fun_args |> fun_apply([integer()]) == {:badarg, [dynamic(atom())]}\n\n # ((bool->bool) or dyn(int->int))\n # booleans work, but not integers\n fun_mixed_gdom = union(fun([boolean()], boolean()), dynamic_fun([integer()], integer()))\n assert fun_apply(fun_mixed_gdom, [boolean()]) == {:ok, dynamic()}\n assert fun_apply(fun_mixed_gdom, [dynamic(boolean())]) == {:ok, union(dynamic(), boolean())}\n assert fun_apply(fun_mixed_gdom, [integer()]) == {:badarg, [dynamic(boolean())]}\n assert fun_apply(fun_mixed_gdom, [dynamic(integer())]) == {:badarg, [dynamic(boolean())]}\n\n # Badfun\n assert union(\n fun([atom()], integer()),\n dynamic_fun([integer()], binary()) |> intersection(none_fun(2))\n )\n |> fun_apply([atom()])\n |> elem(1)\n |> equal?(integer())\n\n assert union(\n fun([atom()], integer()) |> intersection(none_fun(2)),\n dynamic_fun([integer()], binary())\n )\n |> fun_apply([integer()]) == {:ok, dynamic(binary())}\n\n # Applying (dynamic or int) -> bool to (dynamic and float).\n # The domain is\n # gdom((dynamic or int) -> bool) = dom(int -> bool) or dynamic and dom(term -> bool)\n # = int or dynamic and term = int or dynamic\n\n # The domain check dynamic and float <= int or dynamic succeeds.\n # The static application (term -> bool) o float = bool is well-defined.\n # The dynamic application (int -> bool) o float is not well-defined (float not <: int),\n # but since it is dynamic it returns term wrapped in dynamic, which is dynamic.\n # Result: bool or dynamic.\n fun_type = fun([union(dynamic(), integer())], boolean())\n arg = dynamic(float())\n\n # Application yields bool or dynamic\n assert {:ok, result} = fun_apply(fun_type, [arg])\n assert equal?(union(boolean(), dynamic()), result)\n end\n end\n\n describe \"singleton?\" do\n test \"non-singleton?\" do\n refute singleton?(term())\n refute singleton?(none())\n refute singleton?(dynamic())\n refute singleton?(integer())\n refute singleton?(float())\n refute singleton?(pid())\n refute singleton?(reference())\n refute singleton?(fun(1))\n refute singleton?(non_empty_list(atom([:foo])))\n end\n\n @disguised_empty_map closed_map(key: atom([:value]))\n |> difference(open_map(key: atom(), optional: if_set(atom())))\n\n test \"atoms\" do\n assert singleton?(atom([:foo]))\n refute singleton?(atom([:foo, :bar]))\n assert singleton?(atom([:foo]) |> union(@disguised_empty_map))\n refute singleton?(atom() |> difference(atom([:foo])))\n end\n\n test \"empty list\" do\n assert singleton?(empty_list())\n refute singleton?(non_empty_list(term()))\n refute singleton?(union(empty_list(), atom([:foo])))\n assert singleton?(union(empty_list(), @disguised_empty_map))\n end\n\n test \"maps\" do\n assert singleton?(empty_map())\n assert singleton?(closed_map(key: atom([:value])))\n assert singleton?(closed_map(key: atom([:value])) |> union(@disguised_empty_map))\n refute singleton?(closed_map(key: binary()))\n refute singleton?(closed_map(key: if_set(atom([:value]))))\n refute singleton?(closed_map(__struct__: :term))\n refute singleton?(open_map())\n refute singleton?(open_map(key: atom([:value])))\n refute singleton?(union(closed_map(key: atom([:value])), closed_map(other: atom([:value]))))\n end\n\n test \"tuples\" do\n assert singleton?(tuple([]))\n assert singleton?(tuple([atom([:foo])]))\n refute singleton?(tuple([binary()]))\n refute singleton?(open_tuple([]))\n refute singleton?(union(tuple([atom([:value])]), tuple([atom([:other_value])])))\n refute singleton?(union(tuple([atom([:value])]), closed_map(other: atom([:value]))))\n end\n end\n\n describe \"projections\" do\n test \"booleaness\" do\n for type <- [none(), open_map(), negation(boolean()), difference(atom(), boolean())] do\n assert booleaness(type) == :none\n assert booleaness(dynamic(type)) == :none\n end\n\n for type <- [term(), dynamic(), atom(), boolean()] do\n assert booleaness(type) == :maybe_both\n assert booleaness(dynamic(type)) == :maybe_both\n end\n\n assert booleaness(atom([false])) == {false, :always}\n assert booleaness(dynamic(atom([false]))) == {false, :always}\n assert booleaness(dynamic(atom([false, :other]))) == {false, :maybe}\n assert booleaness(negation(atom([false]))) == {true, :maybe}\n\n assert booleaness(atom([true])) == {true, :always}\n assert booleaness(dynamic(atom([true]))) == {true, :always}\n assert booleaness(dynamic(atom([true, :other]))) == {true, :maybe}\n assert booleaness(negation(atom([true]))) == {false, :maybe}\n end\n\n test \"truthiness\" do\n for type <- [term(), none(), atom(), boolean(), union(atom([false]), integer())] do\n assert truthiness(type) == :undefined\n assert truthiness(dynamic(type)) == :undefined\n end\n\n for type <- [atom([false]), atom([nil]), atom([nil, false]), atom([false, nil])] do\n assert truthiness(type) == :always_false\n assert truthiness(dynamic(type)) == :always_false\n end\n\n for type <-\n [negation(atom()), atom([true]), negation(atom([false, nil])), atom([:ok]), integer()] do\n assert truthiness(type) == :always_true\n assert truthiness(dynamic(type)) == :always_true\n end\n end\n\n test \"atom_fetch\" do\n assert atom_fetch(term()) == :error\n assert atom_fetch(union(term(), dynamic(atom([:foo, :bar])))) == :error\n\n assert atom_fetch(atom()) == {:infinite, []}\n assert atom_fetch(dynamic()) == {:infinite, []}\n\n assert atom_fetch(atom([:foo, :bar])) ==\n {:finite, [:foo, :bar] |> :sets.from_list(version: 2) |> :sets.to_list()}\n\n assert atom_fetch(union(atom([:foo, :bar]), dynamic(atom()))) == {:infinite, []}\n assert atom_fetch(union(atom([:foo, :bar]), dynamic(term()))) == {:infinite, []}\n end\n\n test \"list_hd\" do\n assert list_hd(none()) == :badnonemptylist\n assert list_hd(term()) == :badnonemptylist\n assert list_hd(list(term())) == :badnonemptylist\n assert list_hd(empty_list()) == :badnonemptylist\n assert list_hd(non_empty_list(term())) == {:ok, term()}\n assert list_hd(non_empty_list(integer())) == {:ok, integer()}\n assert list_hd(difference(list(number()), list(integer()))) == {:ok, number()}\n assert list_hd(non_empty_list(atom(), float())) == {:ok, atom()}\n\n assert list_hd(dynamic()) == {:ok, dynamic()}\n assert list_hd(dynamic(list(integer()))) == {:ok, dynamic(integer())}\n assert list_hd(union(dynamic(), atom())) == :badnonemptylist\n assert list_hd(union(dynamic(), list(term()))) == :badnonemptylist\n\n assert list_hd(difference(list(number()), list(number()))) == :badnonemptylist\n assert list_hd(dynamic(difference(list(number()), list(number())))) == :badnonemptylist\n\n assert list_hd(union(dynamic(list(float())), non_empty_list(atom()))) ==\n {:ok, union(dynamic(float()), atom())}\n\n # If term() is in the tail, it means list(term()) is in the tail\n # and therefore any term can be returned from hd.\n assert list_hd(non_empty_list(atom(), term())) == {:ok, term()}\n assert list_hd(non_empty_list(atom(), negation(list(term(), term())))) == {:ok, atom()}\n end\n\n test \"list_of\" do\n assert list_of(term()) == :badproperlist\n assert list_of(none()) == :badproperlist\n assert list_of(empty_list()) == {true, none()}\n assert list_of(union(empty_list(), integer())) == :badproperlist\n assert list_of(non_empty_list(integer())) == {false, integer()}\n assert list_of(non_empty_list(integer(), atom())) == :badproperlist\n assert list_of(non_empty_list(integer(), term())) == :badproperlist\n assert list_of(non_empty_list(integer(), list(term()))) == {false, term()}\n assert list_of(list(integer()) |> union(list(integer(), integer()))) == :badproperlist\n assert list_of(list(integer()) |> union(integer())) == :badproperlist\n assert list_of(dynamic(list(integer()))) == {true, dynamic(integer())}\n assert list_of(dynamic(list(integer(), atom()))) == {true, nil}\n assert list_of(dynamic(non_empty_list(integer(), atom()))) == :badproperlist\n assert list_of(dynamic(union(empty_list(), integer()))) == {true, nil}\n\n # A list that the difference resolves to nothing\n list_with_tail =\n non_empty_list(atom(), union(integer(), empty_list()))\n |> difference(non_empty_list(atom([:ok]), integer()))\n |> difference(non_empty_list(atom(), term()))\n\n assert list_of(list_with_tail) == :badproperlist\n end\n\n test \"list_tl\" do\n assert list_tl(none()) == :badnonemptylist\n assert list_tl(term()) == :badnonemptylist\n assert list_tl(empty_list()) == :badnonemptylist\n assert list_tl(list(integer())) == :badnonemptylist\n assert list_tl(difference(list(number()), list(number()))) == :badnonemptylist\n\n assert list_tl(non_empty_list(integer())) == {:ok, list(integer())}\n\n assert list_tl(non_empty_list(integer(), atom())) ==\n {:ok, union(atom(), non_empty_list(integer(), atom()))}\n\n # The tail of either a (non empty) list of integers with an atom tail or a (non empty) list\n # of tuples with a float tail is either an atom, or a float, or a (possibly empty) list of\n # integers with an atom tail, or a (possibly empty) list of tuples with a float tail.\n assert list_tl(union(non_empty_list(integer(), atom()), non_empty_list(tuple(), float()))) ==\n {:ok,\n union(atom(), float())\n |> union(non_empty_list(integer(), atom()))\n |> union(non_empty_list(tuple(), float()))}\n\n assert list_tl(dynamic()) == {:ok, dynamic()}\n assert list_tl(dynamic(list(integer()))) == {:ok, dynamic(list(integer()))}\n\n assert list_tl(dynamic(list(integer(), atom()))) ==\n {:ok, dynamic(union(atom(), list(integer(), atom())))}\n end\n\n test \"tuple_fetch\" do\n assert tuple_fetch(term(), 0) == :badtuple\n assert tuple_fetch(integer(), 0) == :badtuple\n assert tuple_fetch(tuple([none(), atom()]), 1) == :badtuple\n assert tuple_fetch(tuple([none()]), 0) == :badtuple\n\n assert tuple_fetch(tuple([integer(), atom()]), 0) == {false, integer()}\n assert tuple_fetch(tuple([integer(), atom()]), 1) == {false, atom()}\n assert tuple_fetch(tuple([integer(), atom()]), 2) == :badindex\n\n assert tuple_fetch(open_tuple([integer(), atom()]), 0) == {false, integer()}\n assert tuple_fetch(open_tuple([integer(), atom()]), 1) == {false, atom()}\n assert tuple_fetch(open_tuple([integer(), atom()]), 2) == :badindex\n\n assert tuple_fetch(tuple([integer(), atom()]), -1) == :badindex\n assert tuple_fetch(empty_tuple(), 0) == :badindex\n assert difference(tuple(), tuple()) |> tuple_fetch(0) == :badtuple\n\n assert tuple([atom()]) |> difference(empty_tuple()) |> tuple_fetch(0) ==\n {false, atom()}\n\n assert difference(tuple([union(integer(), atom())]), open_tuple([atom()]))\n |> tuple_fetch(0) == {false, integer()}\n\n assert tuple_fetch(union(tuple([integer(), atom()]), dynamic(open_tuple([atom()]))), 1)\n |> Kernel.then(fn {opt, ty} -> opt and equal?(ty, union(atom(), dynamic())) end)\n\n assert tuple_fetch(union(tuple([integer()]), tuple([atom()])), 0) ==\n {false, union(integer(), atom())}\n\n assert tuple([integer(), atom(), union(atom(), integer())])\n |> difference(tuple([integer(), term(), atom()]))\n |> tuple_fetch(2) == {false, integer()}\n\n assert tuple([integer(), atom(), union(union(atom(), integer()), list(term()))])\n |> difference(tuple([integer(), term(), atom()]))\n |> difference(open_tuple([term(), atom(), list(term())]))\n |> tuple_fetch(2) == {false, integer()}\n\n assert tuple([integer(), atom(), integer()])\n |> difference(tuple([integer(), term(), integer()]))\n |> tuple_fetch(1) == :badtuple\n\n assert tuple([integer(), atom(), integer()])\n |> difference(tuple([integer(), term(), atom()]))\n |> tuple_fetch(2) == {false, integer()}\n\n assert tuple_fetch(tuple(), 0) == :badindex\n end\n\n test \"tuple_fetch with dynamic\" do\n assert tuple_fetch(dynamic(), 0) == {true, dynamic()}\n assert tuple_fetch(dynamic(empty_tuple()), 0) == :badindex\n assert tuple_fetch(dynamic(tuple([integer(), atom()])), 2) == :badindex\n assert tuple_fetch(union(dynamic(), integer()), 0) == :badtuple\n\n assert tuple_fetch(dynamic(tuple()), 0)\n |> Kernel.then(fn {opt, type} -> opt and equal?(type, dynamic()) end)\n\n assert tuple_fetch(union(dynamic(), open_tuple([atom()])), 0) ==\n {true, union(atom(), dynamic())}\n end\n\n test \"tuple_delete_at\" do\n assert tuple_delete_at(tuple([integer(), atom()]), 3) == :badindex\n assert tuple_delete_at(tuple([integer(), atom()]), -1) == :badindex\n assert tuple_delete_at(empty_tuple(), 0) == :badindex\n assert tuple_delete_at(integer(), 0) == :badtuple\n assert tuple_delete_at(term(), 0) == :badtuple\n assert tuple_delete_at(tuple([none()]), 0) == :badtuple\n\n # Test deleting an element from a closed tuple\n assert tuple_delete_at(tuple([integer(), atom(), boolean()]), 1) ==\n tuple([integer(), boolean()])\n\n # Test deleting the last element from a closed tuple\n assert tuple_delete_at(tuple([integer(), atom()]), 1) ==\n tuple([integer()])\n\n # Test deleting from an open tuple\n assert tuple_delete_at(open_tuple([integer(), atom(), boolean()]), 1) ==\n open_tuple([integer(), boolean()])\n\n # Test deleting from a dynamic tuple\n assert tuple_delete_at(dynamic(tuple([integer(), atom()])), 1) ==\n dynamic(tuple([integer()]))\n\n # Test deleting from a union of tuples\n assert tuple_delete_at(union(tuple([integer(), atom()]), tuple([float(), binary()])), 1)\n |> equal?(tuple([union(integer(), float())]))\n\n # Test deleting from an intersection of tuples\n assert intersection(tuple([integer(), atom()]), tuple([term(), boolean()]))\n |> tuple_delete_at(1) == tuple([integer()])\n\n # Test deleting from a difference of tuples\n assert difference(tuple([integer(), atom(), boolean()]), tuple([term(), term()]))\n |> tuple_delete_at(1)\n |> equal?(tuple([integer(), boolean()]))\n\n # Test deleting from a complex union involving dynamic\n assert union(tuple([integer(), atom()]), dynamic(tuple([float(), binary()])))\n |> tuple_delete_at(1)\n |> equal?(union(tuple([integer()]), dynamic(tuple([float()]))))\n\n # Successfully deleting at position `index` in a tuple means that the dynamic\n # values that succeed are intersected with tuples of size at least `index`\n assert dynamic(tuple()) |> tuple_delete_at(0) == dynamic(tuple())\n assert dynamic(term()) |> tuple_delete_at(0) == dynamic(tuple())\n\n assert dynamic(union(tuple(), integer()))\n |> tuple_delete_at(1)\n |> equal?(dynamic(tuple_of_size_at_least(1)))\n end\n\n test \"tuple_insert_at\" do\n assert tuple_insert_at(tuple([integer(), atom()]), 3, boolean()) == :badindex\n assert tuple_insert_at(tuple([integer(), atom()]), -1, boolean()) == :badindex\n assert tuple_insert_at(integer(), 0, boolean()) == :badtuple\n assert tuple_insert_at(term(), 0, boolean()) == :badtuple\n\n # Out-of-bounds in a union\n assert union(tuple([integer(), atom()]), tuple([float()]))\n |> tuple_insert_at(2, boolean()) == :badindex\n\n # Test inserting into a closed tuple\n assert tuple_insert_at(tuple([integer(), atom()]), 1, boolean()) ==\n tuple([integer(), boolean(), atom()])\n\n # Test inserting at the beginning of a tuple\n assert tuple_insert_at(tuple([integer(), atom()]), 0, boolean()) ==\n tuple([boolean(), integer(), atom()])\n\n # Test inserting at the end of a tuple\n assert tuple_insert_at(tuple([integer(), atom()]), 2, boolean()) ==\n tuple([integer(), atom(), boolean()])\n\n # Test inserting into an empty tuple\n assert tuple_insert_at(empty_tuple(), 0, integer()) == tuple([integer()])\n\n # Test inserting into an open tuple\n assert tuple_insert_at(open_tuple([integer(), atom()]), 1, boolean()) ==\n open_tuple([integer(), boolean(), atom()])\n\n # Test inserting a dynamic type\n assert tuple_insert_at(tuple([integer(), atom()]), 1, dynamic()) ==\n dynamic(tuple([integer(), term(), atom()]))\n\n # Test inserting into a dynamic tuple\n assert tuple_insert_at(dynamic(tuple([integer(), atom()])), 1, boolean()) ==\n dynamic(tuple([integer(), boolean(), atom()]))\n\n # Test inserting into a union of tuples\n assert tuple_insert_at(union(tuple([integer()]), tuple([atom()])), 0, boolean()) ==\n union(tuple([boolean(), integer()]), tuple([boolean(), atom()]))\n\n # Test inserting into a difference of tuples\n assert difference(tuple([integer(), atom(), boolean()]), tuple([term(), term()]))\n |> tuple_insert_at(1, float())\n |> equal?(tuple([integer(), float(), atom(), boolean()]))\n\n # Test inserting into a complex union involving dynamic\n assert union(tuple([integer(), atom()]), dynamic(tuple([float(), binary()])))\n |> tuple_insert_at(1, boolean())\n |> equal?(\n union(\n tuple([integer(), boolean(), atom()]),\n dynamic(tuple([float(), boolean(), binary()]))\n )\n )\n\n # If you successfully intersect at position index in a type, then the dynamic values\n # that succeed are intersected with tuples of size at least index\n assert dynamic(union(tuple(), integer()))\n |> tuple_insert_at(1, boolean())\n |> equal?(dynamic(open_tuple([term(), boolean()])))\n end\n\n test \"tuple_values\" do\n assert tuple_values(integer()) == :badtuple\n assert tuple_values(tuple([none()])) == :badtuple\n assert tuple_values(tuple([])) == none()\n assert tuple_values(tuple()) == term()\n assert tuple_values(open_tuple([integer()])) == term()\n assert tuple_values(tuple([integer(), atom()])) == union(integer(), atom())\n\n assert tuple_values(union(tuple([float(), pid()]), tuple([reference()]))) ==\n union(float(), union(pid(), reference()))\n\n assert tuple_values(difference(tuple([number(), atom()]), tuple([float(), term()]))) ==\n union(integer(), atom())\n\n assert union(tuple([atom([:ok])]), open_tuple([integer()]))\n |> difference(open_tuple([term(), term()]))\n |> tuple_values() == union(atom([:ok]), integer())\n\n assert tuple_values(difference(tuple([number(), atom()]), tuple([float(), atom([:ok])]))) ==\n union(number(), atom())\n\n assert tuple_values(dynamic(tuple())) == dynamic()\n assert tuple_values(dynamic(tuple([integer()]))) == dynamic(integer())\n\n assert tuple_values(union(dynamic(tuple([integer()])), tuple([atom()]))) ==\n union(dynamic(integer()), atom())\n\n assert tuple_values(union(dynamic(tuple()), integer())) == :badtuple\n assert tuple_values(dynamic(union(integer(), tuple([atom()])))) == dynamic(atom())\n\n assert tuple_values(union(dynamic(tuple([integer()])), tuple([integer()])))\n |> equal?(integer())\n end\n\n test \"map_to_list\" do\n assert map_to_list(:term) == :badmap\n assert map_to_list(integer()) == :badmap\n assert map_to_list(union(open_map(), integer())) == :badmap\n assert map_to_list(none()) == :badmap\n assert map_to_list(dynamic()) == {:ok, dynamic(list(tuple([term(), term()])))}\n\n # A non existent map type is refused\n assert open_map()\n |> difference(open_map(a: if_set(term()), c: if_set(term())))\n |> map_to_list() == :badmap\n\n assert map_to_list(empty_map()) == {:ok, empty_list()}\n assert map_to_list(open_map()) == {:ok, list(tuple([term(), term()]))}\n\n assert map_to_list(closed_map(a: integer())) ==\n {:ok, non_empty_list(tuple([atom([:a]), integer()]))}\n\n assert map_to_list(closed_map(a: term())) ==\n {:ok, non_empty_list(tuple([atom([:a]), term()]))}\n\n assert map_to_list(closed_map(a: integer(), b: atom())) ==\n {:ok,\n non_empty_list(\n tuple([atom([:a]), integer()])\n |> union(tuple([atom([:b]), atom()]))\n )}\n\n assert map_to_list(union(closed_map(a: float()), closed_map(b: pid()))) ==\n {:ok,\n non_empty_list(\n tuple([atom([:a]), float()])\n |> union(tuple([atom([:b]), pid()]))\n )}\n\n # Test with struct-like descrs\n assert map_to_list(closed_map(__struct__: term())) ==\n {:ok, non_empty_list(tuple([atom([:__struct__]), term()]))}\n\n # Test with domain keys\n assert map_to_list(closed_map([{domain_key(:integer), binary()}])) ==\n {:ok, list(tuple([integer(), binary()]))}\n\n assert map_to_list(closed_map([{domain_key(:tuple), binary()}])) ==\n {:ok, list(tuple([tuple(), binary()]))}\n\n # Test with both atom keys and domain keys\n map_with_both =\n closed_map([\n {:a, atom([:ok])},\n {:b, float()},\n {domain_key(:integer), binary()},\n {domain_key(:tuple), pid()}\n ])\n\n assert map_to_list(map_with_both) ==\n {:ok,\n non_empty_list(\n tuple([atom([:a]), atom([:ok])])\n |> union(tuple([atom([:b]), float()]))\n |> union(tuple([integer(), binary()]))\n |> union(tuple([tuple(), pid()]))\n )}\n\n # Test open maps - should return list of key-value tuples\n assert map_to_list(open_map()) == {:ok, list(tuple([term(), term()]))}\n assert map_to_list(open_map(a: integer())) == {:ok, non_empty_list(tuple([term(), term()]))}\n\n {:ok, list} = map_to_list(open_map([{domain_key(:integer), binary()}]))\n\n assert list(\n Enum.reduce(\n [binary(), float(), pid(), port(), reference()] ++\n [fun(), atom(), tuple(), open_map(), list(term(), term())],\n tuple([integer(), binary()]),\n fn domain, acc -> union(acc, tuple([domain, term()])) end\n )\n )\n |> equal?(list)\n\n # Test with multiple domain keys\n multiple_domains =\n closed_map([\n {domain_key(:integer), atom([:int])},\n {domain_key(:float), atom([:float])},\n {domain_key(:atom), binary()},\n {domain_key(:binary), integer()},\n {domain_key(:tuple), float()}\n ])\n\n assert map_to_list(multiple_domains) ==\n {:ok,\n list(\n tuple([integer(), atom([:int])])\n |> union(tuple([float(), atom([:float])]))\n |> union(tuple([atom(), binary()]))\n |> union(tuple([binary(), integer()]))\n |> union(tuple([tuple(), float()]))\n )}\n\n # Test dynamic maps\n assert map_to_list(dynamic(open_map())) ==\n {:ok, dynamic(list(tuple([term(), term()])))}\n\n assert map_to_list(dynamic(closed_map(a: integer()))) ==\n {:ok, dynamic(non_empty_list(tuple([atom([:a]), integer()])))}\n\n assert map_to_list(union(dynamic(closed_map(a: integer())), closed_map(b: atom()))) ==\n {:ok,\n union(\n non_empty_list(tuple([atom([:b]), atom()])),\n dynamic(\n non_empty_list(\n union(\n tuple([atom([:a]), integer()]),\n tuple([atom([:b]), atom()])\n )\n )\n )\n )}\n\n # A static integer is refused\n assert map_to_list(union(dynamic(open_map()), integer())) == :badmap\n\n # Test with negations\n assert map_to_list(\n difference(closed_map(a: integer(), b: atom()), closed_map(a: integer()))\n ) ==\n {:ok,\n non_empty_list(\n tuple([atom([:a]), integer()])\n |> union(tuple([atom([:b]), atom()]))\n )}\n\n # If a key is removed entirely by a negation, it should not appear in the result\n assert closed_map(a: if_set(integer()), b: atom())\n |> difference(closed_map(a: integer(), b: term()))\n |> map_to_list() ==\n {:ok, non_empty_list(tuple([atom([:b]), atom()]))}\n end\n\n test \"domain_to_args\" do\n # take complex tuples, normalize them, and check if they are still equal\n complex_tuples = [\n tuple([term(), atom(), number()])\n |> difference(tuple([atom(), atom(), float()])),\n # overlapping union and difference producing multiple variants\n difference(\n tuple([union(atom(), pid()), union(integer(), float())]),\n tuple([union(atom(), pid()), float()])\n )\n ]\n\n Enum.each(complex_tuples, fn domain ->\n args = domain_to_args(domain)\n\n assert Enum.reduce(args, none(), &union(args_to_domain(&1), &2))\n |> equal?(domain)\n end)\n end\n\n test \"map_fetch_key\" do\n assert map_fetch_key(term(), :a) == :badmap\n assert map_fetch_key(union(open_map(), integer()), :a) == :badmap\n assert map_fetch_key(difference(open_map(), open_map()), :a) == :badmap\n\n assert map_fetch_key(difference(closed_map(a: integer()), closed_map(a: term())), :a) ==\n :badmap\n\n assert map_fetch_key(open_map(), :a) == :badkey\n assert map_fetch_key(open_map(a: not_set()), :a) == :badkey\n assert map_fetch_key(union(closed_map(a: integer()), closed_map(b: atom())), :a) == :badkey\n\n assert map_fetch_key(closed_map(a: integer()), :a) == {false, integer()}\n\n assert map_fetch_key(union(closed_map(a: integer()), closed_map(a: atom())), :a) ==\n {false, union(integer(), atom())}\n\n {false, value_type} =\n open_map(my_map: open_map(foo: integer()))\n |> intersection(open_map(my_map: open_map(bar: boolean())))\n |> map_fetch_key(:my_map)\n\n assert equal?(value_type, open_map(foo: integer(), bar: boolean()))\n\n {false, value_type} =\n closed_map(a: union(integer(), atom()))\n |> difference(open_map(a: integer()))\n |> map_fetch_key(:a)\n\n assert equal?(value_type, atom())\n\n {false, value_type} =\n closed_map(a: integer(), b: atom())\n |> difference(closed_map(a: integer(), b: atom([:foo])))\n |> map_fetch_key(:a)\n\n assert equal?(value_type, integer())\n\n {false, value_type} =\n closed_map(a: integer())\n |> difference(closed_map(a: atom()))\n |> map_fetch_key(:a)\n\n assert equal?(value_type, integer())\n\n {false, value_type} =\n open_map(a: integer(), b: atom())\n |> union(closed_map(a: tuple()))\n |> map_fetch_key(:a)\n\n assert equal?(value_type, union(integer(), tuple()))\n\n {false, value_type} =\n closed_map(a: atom())\n |> difference(closed_map(a: atom([:foo, :bar])))\n |> difference(closed_map(a: atom([:bar])))\n |> map_fetch_key(:a)\n\n assert equal?(value_type, intersection(atom(), negation(atom([:foo, :bar]))))\n\n assert closed_map(a: union(atom([:ok]), pid()), b: integer(), c: tuple())\n |> difference(open_map(a: atom([:ok]), b: integer()))\n |> difference(open_map(a: atom(), c: tuple()))\n |> map_fetch_key(:a) == {false, pid()}\n\n assert closed_map(a: union(atom([:foo]), pid()), b: integer(), c: tuple())\n |> difference(open_map(a: atom([:foo]), b: integer()))\n |> difference(open_map(a: atom(), c: tuple()))\n |> map_fetch_key(:a) == {false, pid()}\n\n assert closed_map(a: union(atom([:foo, :bar, :baz]), integer()))\n |> difference(open_map(a: atom([:foo, :bar])))\n |> difference(open_map(a: atom([:foo, :baz])))\n |> map_fetch_key(:a) == {false, integer()}\n end\n\n test \"map_fetch_key with dynamic\" do\n assert map_fetch_key(dynamic(), :a) == {true, dynamic()}\n assert map_fetch_key(union(dynamic(), integer()), :a) == :badmap\n assert map_fetch_key(union(dynamic(open_map(a: integer())), integer()), :a) == :badmap\n assert map_fetch_key(union(dynamic(integer()), integer()), :a) == :badmap\n\n assert intersection(dynamic(), open_map(a: integer()))\n |> map_fetch_key(:a) == {false, intersection(integer(), dynamic())}\n\n {false, type} = union(dynamic(integer()), open_map(a: integer())) |> map_fetch_key(:a)\n assert equal?(type, integer())\n\n assert union(dynamic(integer()), open_map(a: if_set(integer()))) |> map_fetch_key(:a) ==\n :badkey\n\n assert union(dynamic(open_map(a: atom())), open_map(a: integer()))\n |> map_fetch_key(:a) == {false, union(dynamic(atom()), integer())}\n end\n\n test \"map_fetch_key with domain keys\" do\n integer_to_atom = open_map([{domain_key(:integer), atom()}])\n assert map_fetch_key(integer_to_atom, :foo) == :badkey\n\n # the key :a is for sure of type pid and exists in type\n # %{atom() => pid()} and not %{:a => not_set()}\n t1 = closed_map([{domain_key(:atom), pid()}])\n t2 = closed_map(a: not_set())\n t3 = open_map(a: not_set())\n\n # Indeed, t2 is equivalent to the empty map\n assert map_fetch_key(difference(t1, t2), :a) == :badkey\n assert map_fetch_key(difference(t1, t3), :a) == {false, pid()}\n\n t4 = closed_map([{domain_key(:pid), atom()}])\n assert map_fetch_key(difference(t1, t4) |> difference(t3), :a) == {false, pid()}\n\n assert map_fetch_key(closed_map([{domain_key(:atom), pid()}]), :a) == :badkey\n\n assert map_fetch_key(dynamic(closed_map([{domain_key(:atom), pid()}])), :a) ==\n {true, dynamic(pid())}\n\n assert closed_map([{domain_key(:atom), number()}])\n |> difference(open_map(a: if_set(integer())))\n |> map_fetch_key(:a) == {false, float()}\n\n assert closed_map([{domain_key(:atom), number()}])\n |> difference(closed_map(b: if_set(integer())))\n |> map_fetch_key(:a) == :badkey\n end\n end\n\n describe \"numberize\" do\n test \"with static\" do\n assert numberize(term()) == term()\n\n assert open_map(list: list(integer(), atom()), tuple: tuple([float(), binary(), integer()]))\n |> numberize() ==\n open_map(\n list: list(number(), atom()),\n tuple: tuple([number(), binary(), number()])\n )\n end\n\n test \"with dynamic\" do\n assert numberize(dynamic()) == dynamic()\n\n assert dynamic(list(binary(), float())) |> numberize() ==\n dynamic(list(binary(), number()))\n end\n end\n\n describe \"map_get\" do\n test \"with domain keys\" do\n assert map_get(term(), term()) == :badmap\n\n map_type = closed_map([{domain_key(:tuple), binary()}])\n assert map_get(map_type, tuple()) == {:ok, binary()}\n\n # Type with all domain types\n # %{:bar => :ok, integer() => :int, float() => :float, atom() => binary(), binary() => integer(), tuple() => float(), map() => pid(), reference() => port(), pid() => boolean()}\n all_domains =\n closed_map([\n {:bar, atom([:ok])},\n {domain_key(:integer), atom([:int])},\n {domain_key(:float), atom([:float])},\n {domain_key(:atom), binary()},\n {domain_key(:binary), integer()},\n {domain_key(:tuple), float()},\n {domain_key(:map), pid()},\n {domain_key(:reference), port()},\n {domain_key(:pid), reference()},\n {domain_key(:port), boolean()}\n ])\n\n assert map_get(all_domains, atom([:bar])) == {:ok, atom([:ok])}\n\n assert map_get(all_domains, integer()) == {:ok, atom([:int])}\n assert map_get(all_domains, number()) == {:ok, atom([:int, :float])}\n\n assert map_get(all_domains, empty_list()) == :error\n assert map_get(all_domains, atom([:foo])) == {:ok, binary()}\n assert map_get(all_domains, binary()) == {:ok, integer()}\n assert map_get(all_domains, tuple([integer(), atom()])) == {:ok, float()}\n assert map_get(all_domains, empty_map()) == {:ok, pid()}\n\n # Union\n assert map_get(all_domains, union(tuple(), empty_map())) ==\n {:ok, union(float(), pid())}\n\n # Removing all maps with tuple keys\n t_no_tuple = difference(all_domains, closed_map([{domain_key(:tuple), float()}]))\n t_really_no_tuple = difference(all_domains, open_map([{domain_key(:tuple), float()}]))\n assert subtype?(all_domains, open_map())\n # It's only closed maps, so it should not change\n assert map_get(t_no_tuple, tuple()) == {:ok, float()}\n # This time we actually removed all tuple to float keys\n assert map_get(t_really_no_tuple, tuple()) == :error\n\n t1 = closed_map([{domain_key(:tuple), integer()}])\n t2 = closed_map([{domain_key(:tuple), float()}])\n t3 = union(t1, t2)\n assert map_get(t3, tuple()) == {:ok, number()}\n end\n\n test \"with dynamic\" do\n assert map_get(dynamic(), term()) == {:ok, dynamic()}\n end\n\n test \"with atom fall back\" do\n map = closed_map([{:a, atom([:a])}, {:b, atom([:b])}, {domain_key(:atom), pid()}])\n\n assert map_get(map, atom([:a, :b])) ==\n {:ok, atom([:a, :b])}\n\n assert map_get(map, atom([:a, :c])) ==\n {:ok, union(atom([:a]), pid())}\n\n assert map_get(map, atom() |> difference(atom([:a, :b]))) ==\n {:ok, pid()}\n\n assert map_get(map, atom() |> difference(atom([:a]))) ==\n {:ok, union(atom([:b]), pid())}\n\n assert map_get(closed_map(a: atom([:a]), b: atom([:b])), atom()) ==\n {:ok, atom([:a, :b])}\n\n assert map_get(closed_map([{domain_key(:atom), integer()}]), atom([:a, :b])) ==\n {:ok, integer()}\n\n # Have one of the keys be a __struct__\n map = closed_map([{:a, atom([:a])}, {:__struct__, term()}, {domain_key(:atom), pid()}])\n {:ok, term} = map_get(map, atom() |> difference(atom([:a])))\n assert equal?(term, term())\n end\n\n test \"with lists\" do\n # Verify that empty_list() bitmap type maps to :list domain (not :empty_list domain)\n map_with_list_domain = closed_map([{domain_key(:list), atom([:empty])}])\n\n # empty_list() should access the :list domain\n assert map_get(map_with_list_domain, empty_list()) == {:ok, atom([:empty])}\n\n # non_empty_list() should also access the :list domain\n assert map_get(map_with_list_domain, non_empty_list(integer())) ==\n {:ok, atom([:empty])}\n\n # list() should also access the :list domain\n assert map_get(map_with_list_domain, list(integer())) ==\n {:ok, atom([:empty])}\n\n # If I create a map and instantiate both empty_list() and non_empty_list(integer()), it should return the union of the two types\n map =\n closed_map([{domain_key(:list), atom([:empty])}, {domain_key(:list), atom([:non_empty])}])\n\n assert map_get(map, empty_list()) == {:ok, atom([:empty, :non_empty])}\n\n assert map_get(map, non_empty_list(integer())) ==\n {:ok, atom([:empty, :non_empty])}\n\n assert map_get(map, list(integer())) == {:ok, atom([:empty, :non_empty])}\n end\n end\n\n describe \"map_update\" do\n test \"with static atom keys\" do\n assert map_update(open_map(key: binary()), atom([:key]), integer()) ==\n {binary(), open_map(key: integer()), []}\n\n assert map_update(dynamic(open_map(key: binary())), atom([:key]), integer()) ==\n {dynamic(binary()), dynamic(open_map(key: integer())), []}\n\n # Optional fail for static maps\n assert map_update(open_map(key: if_set(atom([:value]))), atom([:key]), integer()) ==\n {:error, [badkey: :key]}\n\n # ...unless forcing\n assert map_update(\n open_map(key: if_set(atom([:value]))),\n atom([:key]),\n integer(),\n true,\n true\n ) ==\n {atom([:value]), open_map(key: integer()), []}\n\n # But optional does not fail for dynamic ones\n assert map_update(dynamic(open_map(key: if_set(atom([:value])))), atom([:key]), integer()) ==\n {dynamic(atom([:value])), dynamic(open_map(key: integer())), []}\n\n assert map_update(dynamic(), atom([:key]), integer()) ==\n {dynamic(), dynamic(open_map(key: integer())), []}\n\n # Empty value fails for static maps\n assert map_update(closed_map(key: not_set()), atom([:key]), integer()) ==\n {:error, [badkey: :key]}\n\n # ...unless forcing\n assert map_update(closed_map(key: not_set()), atom([:key]), integer(), true, true) ==\n {none(), closed_map(key: integer()), []}\n\n # When putting multiple keys, we don't know which one will be set\n assert map_update(open_map(key1: atom(), key2: binary()), atom([:key1, :key2]), integer()) ==\n {union(atom(), binary()),\n union(\n open_map(key1: atom(), key2: integer()),\n open_map(key1: integer(), key2: binary())\n ), []}\n\n # When putting multiple keys, all have to be set\n assert map_update(open_map(key1: atom(), key2: binary()), atom([:key1, :key3]), integer()) ==\n {term(),\n union(\n open_map(key1: integer(), key2: binary()),\n open_map(key1: atom(), key2: binary(), key3: integer())\n ), [badkey: :key3]}\n\n # ...unless forcing\n assert map_update(\n open_map(key1: atom(), key2: binary()),\n atom([:key1, :key3]),\n integer(),\n true,\n true\n ) ==\n {term(),\n union(\n open_map(key1: integer(), key2: binary()),\n open_map(key1: atom(), key2: binary(), key3: integer())\n ), []}\n\n # ...unless dynamic\n assert map_update(dynamic(open_map()), atom([:key1, :key2]), integer()) ==\n {dynamic(), dynamic(union(open_map(key1: integer()), open_map(key2: integer()))),\n []}\n\n # A \"none\" map\n assert open_map()\n |> difference(open_map(a: if_set(term()), c: if_set(term())))\n |> map_update(atom([:b]), integer()) == {:error, [badkey: :b]}\n\n # ... even when forcing\n assert open_map()\n |> difference(open_map(a: if_set(term()), c: if_set(term())))\n |> map_update(atom([:b]), integer(), true, true) == {none(), none(), []}\n end\n\n test \"with dynamic atom keys\" do\n assert map_update(closed_map(key: atom([:value])), dynamic(), atom([:new_value])) ==\n {atom([:value]), closed_map(key: atom([:value, :new_value])), []}\n\n assert map_update(dynamic(closed_map(key: atom([:value]))), dynamic(), atom([:new_value])) ==\n {dynamic(atom([:value])), dynamic(closed_map(key: atom([:value, :new_value]))), []}\n\n # Check struct fields\n assert map_update(open_map(__struct__: term()), dynamic(atom()), integer()) ==\n {term(), open_map(__struct__: term()), []}\n\n # When precise dynamic keys are given, at least one must succeed\n assert map_update(\n closed_map(key1: atom(), key2: binary()),\n dynamic(atom([:key1, :key3])),\n integer()\n ) ==\n {atom(), closed_map(key1: integer(), key2: binary()), []}\n\n assert map_update(\n closed_map(key1: atom(), key2: binary()),\n dynamic(atom([:key3, :key4])),\n integer()\n ) == {:error, []}\n\n # ...unless forcing\n assert map_update(\n closed_map(key1: atom(), key2: binary()),\n dynamic(atom([:key3, :key4])),\n integer(),\n true,\n true\n ) ==\n {none(),\n union(\n closed_map(key1: atom(), key2: binary(), key3: integer()),\n closed_map(key1: atom(), key2: binary(), key4: integer())\n ), []}\n\n # ...unless open\n assert map_update(\n open_map(key1: atom(), key2: binary()),\n dynamic(atom([:key1, :key3])),\n integer()\n ) ==\n {term(),\n union(\n open_map(key1: integer(), key2: binary()),\n open_map(key1: atom(), key2: binary(), key3: integer())\n ), []}\n\n assert map_update(\n open_map(key1: atom(), key2: binary()),\n dynamic(atom([:key3, :key4])),\n integer()\n ) == {:error, []}\n end\n\n test \"with domain keys\" do\n map =\n closed_map([\n {domain_key(:integer), binary()},\n {domain_key(:pid), binary()},\n {domain_key(:port), binary()}\n ])\n\n assert map_update(map, none(), integer()) ==\n {:error, []}\n\n assert map_update(map, integer(), integer()) ==\n {binary(),\n closed_map([\n {domain_key(:integer), union(integer(), binary())},\n {domain_key(:pid), binary()},\n {domain_key(:port), binary()}\n ]), []}\n\n assert map_update(map, union(pid(), integer()), integer()) ==\n {binary(),\n closed_map([\n {domain_key(:integer), union(integer(), binary())},\n {domain_key(:pid), union(integer(), binary())},\n {domain_key(:port), binary()}\n ]), []}\n\n assert map_update(map, union(pid(), reference()), integer()) ==\n {binary(),\n closed_map([\n {domain_key(:integer), binary()},\n {domain_key(:pid), union(integer(), binary())},\n {domain_key(:port), binary()}\n ]), [baddomain: reference()]}\n\n assert map_update(map, union(pid(), dynamic(union(reference(), integer()))), integer()) ==\n {binary(),\n closed_map([\n {domain_key(:integer), union(integer(), binary())},\n {domain_key(:pid), union(integer(), binary())},\n {domain_key(:port), binary()}\n ]), []}\n\n assert map_update(map, union(pid(), dynamic(union(reference(), binary()))), integer()) ==\n {binary(),\n closed_map([\n {domain_key(:integer), binary()},\n {domain_key(:pid), union(integer(), binary())},\n {domain_key(:port), binary()}\n ]), []}\n\n assert map_update(map, dynamic(union(reference(), binary())), integer()) ==\n {:error, []}\n\n # ... unless forcing\n assert map_update(map, dynamic(union(reference(), binary())), integer(), true, true) ==\n {none(),\n closed_map([\n {domain_key(:integer), binary()},\n {domain_key(:pid), binary()},\n {domain_key(:port), binary()},\n {domain_key(:binary), integer()},\n {domain_key(:reference), integer()}\n ]), []}\n\n # Putting dynamic atom over record keys\n assert map_update(closed_map(key1: binary(), key2: pid()), atom(), integer()) ==\n {union(binary(), pid()),\n union(\n closed_map(key1: binary(), key2: integer()),\n closed_map(key1: union(integer(), binary()), key2: pid())\n ), [baddomain: atom()]}\n\n # ... unless forcing\n assert map_update(closed_map(key1: binary(), key2: pid()), atom(), integer(), true, true) ==\n {union(binary(), pid()),\n [\n closed_map([{domain_key(:atom), integer()}, key1: binary(), key2: pid()]),\n closed_map(key1: integer(), key2: pid()),\n closed_map(key1: binary(), key2: integer())\n ]\n |> Enum.reduce(&union/2), [baddomain: atom()]}\n\n assert map_update(closed_map(key1: binary(), key2: pid()), dynamic(atom()), integer()) ==\n {union(binary(), pid()),\n union(\n closed_map(key1: binary(), key2: integer()),\n closed_map(key1: union(integer(), binary()), key2: pid())\n ), []}\n\n # A \"none()\" map\n assert open_map()\n |> difference(open_map(a: if_set(term()), c: if_set(term())))\n |> map_update(binary(), integer()) == {:error, [baddomain: binary()]}\n\n # ... even when forcing\n {type, descr, errors} =\n open_map()\n |> difference(open_map(a: if_set(term()), c: if_set(term())))\n |> map_update(binary(), integer(), true, true)\n\n assert empty?(type)\n assert empty?(descr)\n assert errors == [baddomain: binary()]\n end\n\n test \"with mixed keys\" do\n assert map_update(dynamic(), union(atom([:key]), binary()), integer()) ==\n {dynamic(), dynamic(open_map()), []}\n\n # When precise dynamic keys are given, at least one must succeed\n assert map_update(\n closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),\n dynamic(union(atom([:key]), integer())),\n integer()\n ) ==\n {union(atom(), binary()),\n union(\n closed_map([{:key, integer()}, {domain_key(:integer), binary()}]),\n closed_map([{:key, atom()}, {domain_key(:integer), union(binary(), integer())}])\n ), []}\n\n # Negated keys\n assert map_update(\n closed_map(key1: binary(), key2: binary()),\n difference(atom(), atom([:key1])),\n integer()\n ) ==\n {binary(), closed_map(key1: binary(), key2: union(integer(), binary())),\n [baddomain: atom()]}\n\n assert map_update(\n closed_map([key1: binary(), key2: binary()] ++ [{domain_key(:atom), pid()}]),\n difference(atom(), atom([:key1])),\n integer()\n ) ==\n {union(binary(), pid()),\n union(\n closed_map([{domain_key(:atom), pid()}, key1: binary(), key2: integer()]),\n closed_map([\n {domain_key(:atom), union(pid(), integer())},\n key1: binary(),\n key2: binary()\n ])\n ), []}\n\n # Missing keys\n assert map_update(\n closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),\n dynamic(union(atom([:other_key]), pid())),\n integer()\n ) == {:error, []}\n\n # ...unless forcing\n assert map_update(\n closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),\n dynamic(union(atom([:other_key]), pid())),\n integer(),\n true,\n true\n ) ==\n {none(),\n union(\n closed_map([\n {:key, atom()},\n {domain_key(:integer), binary()},\n {domain_key(:pid), integer()}\n ]),\n closed_map([\n {:key, atom()},\n {:other_key, integer()},\n {domain_key(:integer), binary()}\n ])\n ), []}\n\n # Popping dynamic keys\n non_struct_map = difference(open_map(), open_map(__struct__: atom()))\n {type, descr, []} = map_update(non_struct_map, dynamic(), not_set(), true, true)\n assert type == term()\n assert equal?(descr, open_map(__struct__: if_set(negation(atom()))))\n end\n end\n\n describe \"map_put\" do\n test \"with static atom keys\" do\n assert map_put(open_map(key: binary()), atom([:key]), integer()) ==\n {:ok, open_map(key: integer())}\n\n assert map_put(dynamic(open_map(key: binary())), atom([:key]), integer()) ==\n {:ok, dynamic(open_map(key: integer()))}\n\n # Optional does not fail on put keys\n assert map_put(open_map(key: if_set(atom([:value]))), atom([:key]), integer()) ==\n {:ok, open_map(key: integer())}\n\n # But optional does not fail for dynamic ones\n assert map_put(dynamic(open_map(key: if_set(atom([:value])))), atom([:key]), integer()) ==\n {:ok, dynamic(open_map(key: integer()))}\n\n assert map_put(dynamic(), atom([:key]), integer()) ==\n {:ok, dynamic(open_map(key: integer()))}\n\n # Empty value does not fail for put\n assert map_put(closed_map(key: not_set()), atom([:key]), integer()) ==\n {:ok, closed_map(key: integer())}\n\n # When putting multiple keys, we don't know which one will be set\n assert map_put(open_map(key1: atom(), key2: binary()), atom([:key1, :key2]), integer()) ==\n {:ok,\n union(\n open_map(key1: atom(), key2: integer()),\n open_map(key1: integer(), key2: binary())\n )}\n\n # When putting multiple keys, set even missing keys\n assert map_put(open_map(key1: atom(), key2: binary()), atom([:key1, :key3]), integer()) ==\n {:ok,\n union(\n open_map(key1: atom(), key2: binary(), key3: integer()),\n open_map(key1: integer(), key2: binary())\n )}\n\n assert map_put(dynamic(open_map()), atom([:key1, :key2]), integer()) ==\n {:ok, dynamic(union(open_map(key1: integer()), open_map(key2: integer())))}\n end\n\n test \"with dynamic/term as key-value\" do\n assert map_put(closed_map(key: atom([:value])), dynamic(), dynamic()) ==\n {:ok, dynamic(open_map())}\n\n assert map_put(closed_map(key: atom([:value])), dynamic(), term()) ==\n {:ok, open_map()}\n\n assert map_put(closed_map(key: atom([:value])), term(), dynamic()) ==\n {:ok, dynamic(open_map())}\n\n assert map_put(closed_map(key: atom([:value])), term(), term()) ==\n {:ok, open_map()}\n\n assert map_put(dynamic(closed_map(key: atom([:value]))), term(), term()) ==\n {:ok, dynamic(open_map())}\n end\n\n test \"with dynamic atom keys\" do\n assert map_put(\n open_map(key1: atom(), key2: binary()),\n dynamic(atom([:key1, :key3])),\n integer()\n ) ==\n {:ok,\n union(\n open_map(key1: atom(), key2: binary(), key3: integer()),\n open_map(key1: integer(), key2: binary())\n )}\n\n assert map_put(\n open_map(key1: atom(), key2: binary()),\n dynamic(atom([:key3, :key4])),\n integer()\n ) ==\n {:ok,\n union(\n open_map(key1: atom(), key2: binary(), key3: integer()),\n open_map(key1: atom(), key2: binary(), key4: integer())\n )}\n end\n\n test \"with domain keys\" do\n map =\n closed_map([\n {domain_key(:integer), binary()},\n {domain_key(:pid), binary()},\n {domain_key(:port), binary()}\n ])\n\n assert map_put(map, integer(), integer()) ==\n {:ok,\n closed_map([\n {domain_key(:integer), union(integer(), binary())},\n {domain_key(:pid), binary()},\n {domain_key(:port), binary()}\n ])}\n\n assert map_put(map, union(pid(), integer()), integer()) ==\n {:ok,\n closed_map([\n {domain_key(:integer), union(integer(), binary())},\n {domain_key(:pid), union(integer(), binary())},\n {domain_key(:port), binary()}\n ])}\n\n assert map_put(map, union(pid(), reference()), integer()) ==\n {:ok,\n closed_map([\n {domain_key(:integer), binary()},\n {domain_key(:pid), union(integer(), binary())},\n {domain_key(:port), binary()},\n {domain_key(:reference), integer()}\n ])}\n\n assert map_put(map, union(pid(), dynamic(union(reference(), integer()))), integer()) ==\n {:ok,\n closed_map([\n {domain_key(:integer), union(integer(), binary())},\n {domain_key(:pid), union(integer(), binary())},\n {domain_key(:port), binary()},\n {domain_key(:reference), integer()}\n ])}\n\n assert map_put(map, dynamic(union(reference(), binary())), integer()) ==\n {:ok,\n closed_map([\n {domain_key(:integer), binary()},\n {domain_key(:pid), binary()},\n {domain_key(:port), binary()},\n {domain_key(:reference), integer()},\n {domain_key(:binary), integer()}\n ])}\n\n # Putting dynamic atom over record keys\n assert map_put(closed_map(key1: binary(), key2: binary()), atom(), integer()) ==\n {:ok,\n [\n closed_map(key1: binary(), key2: integer()),\n closed_map(key1: integer(), key2: binary()),\n closed_map([{domain_key(:atom), integer()}, key1: binary(), key2: binary()])\n ]\n |> Enum.reduce(&union/2)}\n end\n\n test \"with mixed keys\" do\n assert map_put(dynamic(), union(atom([:key]), binary()), integer()) ==\n {:ok, dynamic(open_map())}\n\n # When precise dynamic keys are given, at least one must succeed\n assert map_put(\n closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),\n dynamic(union(atom([:key]), integer())),\n integer()\n ) ==\n {:ok,\n union(\n closed_map([{:key, integer()}, {domain_key(:integer), binary()}]),\n closed_map([{:key, atom()}, {domain_key(:integer), union(binary(), integer())}])\n )}\n\n assert map_put(\n closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),\n dynamic(union(atom([:other_key]), pid())),\n integer()\n ) ==\n {:ok,\n union(\n closed_map([\n {:key, atom()},\n {:other_key, integer()},\n {domain_key(:integer), binary()}\n ]),\n closed_map([\n {:key, atom()},\n {domain_key(:integer), binary()},\n {domain_key(:pid), integer()}\n ])\n )}\n\n # Negated keys\n assert map_put(\n closed_map(key1: binary(), key2: binary()),\n difference(atom(), atom([:key1])),\n integer()\n ) ==\n {:ok,\n union(\n closed_map(key1: binary(), key2: integer()),\n closed_map([{domain_key(:atom), integer()}, key1: binary(), key2: binary()])\n )}\n\n assert map_put(\n closed_map([key1: binary(), key2: binary()] ++ [{domain_key(:atom), pid()}]),\n difference(atom(), atom([:key1])),\n integer()\n ) ==\n {:ok,\n union(\n closed_map([{domain_key(:atom), pid()}, key1: binary(), key2: integer()]),\n closed_map([\n {domain_key(:atom), union(integer(), pid())},\n key1: binary(),\n key2: binary()\n ])\n )}\n end\n end\n\n describe \"disjoint\" do\n test \"optional\" do\n assert disjoint?(term(), if_set(none()))\n assert disjoint?(term(), if_set(none()) |> union(non_empty_list(none())))\n end\n\n test \"map\" do\n refute disjoint?(open_map(), open_map(a: integer()))\n end\n end\n\n describe \"to_quoted\" do\n test \"none\" do\n assert none() |> to_quoted_string() == \"none()\"\n assert dynamic(none()) |> to_quoted_string() == \"none()\"\n end\n\n test \"bitmap\" do\n assert union(pid(), bitstring()) |> to_quoted_string() ==\n \"bitstring() or pid()\"\n\n assert union(integer(), union(float(), binary())) |> to_quoted_string() ==\n \"binary() or float() or integer()\"\n\n assert difference(bitstring(), binary()) |> union(integer()) |> to_quoted_string() ==\n \"(bitstring() and not binary()) or integer()\"\n end\n\n test \"bitmap (negation)\" do\n assert union(pid(), bitstring()) |> negation() |> to_quoted_string() ==\n \"not bitstring() and not pid()\"\n\n assert difference(bitstring(), binary())\n |> union(integer())\n |> negation()\n |> to_quoted_string() ==\n \"not (bitstring() and not binary()) and not integer()\"\n end\n\n test \"atom\" do\n assert atom() |> to_quoted_string() == \"atom()\"\n assert atom([:a]) |> to_quoted_string() == \":a\"\n assert atom([:a, :b]) |> to_quoted_string() == \":a or :b\"\n assert difference(atom(), atom([:a])) |> to_quoted_string() == \"atom() and not :a\"\n\n assert atom([Elixir]) |> to_quoted_string() == \"Elixir\"\n assert atom([Foo.Bar]) |> to_quoted_string() == \"Foo.Bar\"\n end\n\n test \"boolean\" do\n assert boolean() |> to_quoted_string() == \"boolean()\"\n assert atom([true, false, :a]) |> to_quoted_string() == \":a or boolean()\"\n assert atom([true, :a]) |> to_quoted_string() == \":a or true\"\n assert difference(atom(), boolean()) |> to_quoted_string() == \"atom() and not boolean()\"\n end\n\n test \"atom/boolean (negation)\" do\n assert atom() |> negation() |> to_quoted_string() == \"not atom()\"\n assert atom([:a, :b]) |> negation() |> to_quoted_string() == \"not :a and not :b\"\n assert boolean() |> negation() |> to_quoted_string() == \"not boolean()\"\n\n assert atom([true, false, :a]) |> negation() |> to_quoted_string() ==\n \"not :a and not boolean()\"\n end\n\n test \"dynamic\" do\n assert dynamic() |> to_quoted_string() == \"dynamic()\"\n\n assert intersection(atom(), dynamic()) |> to_quoted_string() == \"dynamic(atom())\"\n\n assert dynamic(union(atom(), integer())) |> union(integer()) |> to_quoted_string() ==\n \"dynamic(atom()) or integer()\"\n\n assert intersection(binary(), dynamic()) |> to_quoted_string() ==\n \"binary()\"\n\n assert intersection(bitstring(), dynamic()) |> to_quoted_string() ==\n \"dynamic(bitstring())\"\n\n assert intersection(bitstring_no_binary(), dynamic()) |> to_quoted_string() ==\n \"bitstring() and not binary()\"\n\n assert intersection(union(binary(), pid()), dynamic()) |> to_quoted_string() ==\n \"dynamic(binary() or pid())\"\n\n assert union(atom([:foo, :bar]), dynamic()) |> to_quoted_string() ==\n \"dynamic() or :bar or :foo\"\n\n assert intersection(dynamic(), closed_map(a: integer())) |> to_quoted_string() ==\n \"dynamic(%{a: integer()})\"\n end\n\n test \"dynamic (negation)\" do\n assert dynamic(negation(integer())) |> to_quoted_string() == \"dynamic(not integer())\"\n assert negation(dynamic(integer())) |> to_quoted_string() == \"dynamic() or not integer()\"\n\n assert union(atom(), dynamic(integer())) |> negation() |> to_quoted_string() ==\n \"dynamic(not atom()) or (not atom() and not integer())\"\n\n assert dynamic(union(atom(), integer()))\n |> negation()\n |> union(integer())\n |> to_quoted_string() ==\n \"dynamic() or not atom()\"\n end\n\n test \"list\" do\n assert list(term()) |> to_quoted_string() == \"list(term())\"\n assert list(integer()) |> to_quoted_string() == \"list(integer())\"\n\n assert list(term()) |> difference(empty_list()) |> to_quoted_string() ==\n \"non_empty_list(term())\"\n\n assert list(term()) |> difference(list(integer())) |> to_quoted_string() ==\n \"non_empty_list(term()) and not non_empty_list(integer())\"\n\n assert list(term())\n |> difference(list(integer()))\n |> difference(list(atom()))\n |> to_quoted_string() ==\n \"non_empty_list(term()) and not (non_empty_list(integer()) or non_empty_list(atom()))\"\n\n assert list(term(), integer()) |> to_quoted_string() ==\n \"empty_list() or non_empty_list(term(), integer())\"\n\n assert difference(list(term(), atom()), list(term(), boolean())) |> to_quoted_string() ==\n \"non_empty_list(term(), atom() and not boolean())\"\n\n assert list(term(), term()) |> to_quoted_string() ==\n \"empty_list() or non_empty_list(term(), term())\"\n\n # Test normalization\n\n # Remove duplicates\n assert union(list(integer()), list(integer())) |> to_quoted_string() == \"list(integer())\"\n\n # Merge subtypes\n assert union(list(float(), pid()), list(number(), pid())) |> to_quoted_string() ==\n \"empty_list() or non_empty_list(float() or integer(), pid())\"\n\n # Merge last element types\n assert union(list(atom([:ok]), integer()), list(atom([:ok]), float()))\n |> to_quoted_string() ==\n \"empty_list() or non_empty_list(:ok, float() or integer())\"\n\n assert union(dynamic(list(integer(), float())), dynamic(list(integer(), pid())))\n |> to_quoted_string() ==\n \"dynamic(empty_list() or non_empty_list(integer(), float() or pid()))\"\n\n list_with_tail =\n non_empty_list(atom(), union(integer(), empty_list()))\n |> difference(non_empty_list(atom([:ok]), integer()))\n |> difference(non_empty_list(atom(), integer()))\n\n # Check that simplifications occur.\n assert to_quoted_string(list_with_tail) == \"non_empty_list(atom())\"\n end\n\n test \"list (negation)\" do\n assert list(term()) |> negation() |> to_quoted_string() == \"not list(term())\"\n assert list(negation(integer())) |> to_quoted_string() == \"list(not integer())\"\n\n assert list(term()) |> difference(empty_list()) |> negation() |> to_quoted_string() ==\n \"not non_empty_list(term())\"\n\n assert non_empty_list(integer(), integer()) |> negation() |> to_quoted_string() ==\n \"not non_empty_list(integer(), integer())\"\n end\n\n test \"tuple\" do\n assert tuple([integer(), atom()]) |> to_quoted_string() == \"{integer(), atom()}\"\n\n assert tuple([integer(), dynamic(atom())]) |> to_quoted_string() ==\n \"dynamic({integer(), atom()})\"\n\n assert open_tuple([integer(), atom()]) |> to_quoted_string() == \"{integer(), atom(), ...}\"\n\n assert union(tuple([integer(), atom()]), open_tuple([atom()])) |> to_quoted_string() ==\n \"{atom(), ...} or {integer(), atom()}\"\n\n assert difference(tuple([integer(), atom()]), open_tuple([atom()])) |> to_quoted_string() ==\n \"{integer(), atom()}\"\n\n assert tuple([closed_map(a: integer()), open_map()]) |> to_quoted_string() ==\n \"{%{a: integer()}, map()}\"\n\n assert union(tuple([integer(), atom()]), tuple([integer(), atom()])) |> to_quoted_string() ==\n \"{integer(), atom()}\"\n\n assert union(tuple([integer(), atom()]), tuple([float(), atom()])) |> to_quoted_string() ==\n \"{float() or integer(), atom()}\"\n\n assert union(tuple([integer(), atom()]), tuple([float(), atom()]))\n |> union(tuple([pid(), pid(), port()]))\n |> union(tuple([pid(), pid(), atom()]))\n |> to_quoted_string() ==\n \"{float() or integer(), atom()} or {pid(), pid(), atom() or port()}\"\n\n assert union(open_tuple([integer()]), open_tuple([float()])) |> to_quoted_string() ==\n \"{float() or integer(), ...}\"\n\n # {:ok, {term(), integer()}} or {:ok, {term(), float()}} or {:exit, :kill} or {:exit, :timeout}\n assert tuple([atom([:ok]), tuple([term(), empty_list()])])\n |> union(tuple([atom([:ok]), tuple([term(), open_map()])]))\n |> union(tuple([atom([:exit]), atom([:kill])]))\n |> union(tuple([atom([:exit]), atom([:timeout])]))\n |> to_quoted_string() ==\n \"{:exit, :kill or :timeout} or {:ok, {term(), empty_list() or map()}}\"\n\n # Detection of duplicates\n assert tuple([atom([:ok]), term()])\n |> union(tuple([atom([:ok]), term()]))\n |> to_quoted_string() == \"{:ok, term()}\"\n\n assert tuple([closed_map(a: integer(), b: atom()), open_map()])\n |> union(tuple([closed_map(a: integer(), b: atom()), open_map()]))\n |> to_quoted_string() ==\n \"{%{a: integer(), b: atom()}, map()}\"\n\n # Nested fusion\n assert tuple([closed_map(a: integer(), b: atom()), open_map()])\n |> union(tuple([closed_map(a: float(), b: atom()), open_map()]))\n |> to_quoted_string() ==\n \"{%{a: float() or integer(), b: atom()}, map()}\"\n\n # Complex simplification of map/tuple combinations. Initial type is:\n # ```\n # dynamic(\n # :error or\n # ({%Decimal{coef: :inf, exp: integer(), sign: integer()}, binary()} or\n # {%Decimal{coef: :NaN, exp: integer(), sign: integer()}, binary()} or\n # {%Decimal{coef: integer(), exp: integer(), sign: integer()}, term()} or\n # {%Decimal{coef: :inf, exp: integer(), sign: integer()} or\n # %Decimal{coef: :NaN, exp: integer(), sign: integer()} or\n # %Decimal{coef: integer(), exp: integer(), sign: integer()}, term()})\n # )\n # ```\n decimal_inf =\n closed_map(\n __struct__: atom([Decimal]),\n coef: atom([:inf]),\n exp: integer(),\n sign: integer()\n )\n\n decimal_nan =\n closed_map(\n __struct__: atom([Decimal]),\n coef: atom([:NaN]),\n exp: integer(),\n sign: integer()\n )\n\n decimal_int =\n closed_map(\n __struct__: atom([Decimal]),\n coef: integer(),\n exp: integer(),\n sign: integer()\n )\n\n assert atom([:error])\n |> union(\n tuple([decimal_inf, binary()])\n |> union(\n tuple([decimal_nan, binary()])\n |> union(\n tuple([decimal_int, term()])\n |> union(tuple([union(decimal_inf, union(decimal_nan, decimal_int)), term()]))\n )\n )\n )\n |> dynamic()\n |> to_quoted_string() ==\n \"\"\"\n dynamic(\n :error or {%Decimal{sign: integer(), coef: :NaN or :inf or integer(), exp: integer()}, term()}\n )\\\n \"\"\"\n end\n\n test \"tuple (negation)\" do\n assert tuple([integer()]) |> negation() |> to_quoted_string() == \"not {integer()}\"\n assert tuple([negation(integer())]) |> to_quoted_string() == \"{not integer()}\"\n end\n\n test \"fun\" do\n assert fun() |> to_quoted_string() == \"fun()\"\n assert none_fun(1) |> to_quoted_string() == \"(none() -> term())\"\n\n assert none_fun(1)\n |> intersection(none_fun(2))\n |> to_quoted_string() == \"none()\"\n\n assert fun([integer(), float()], boolean()) |> to_quoted_string() ==\n \"(integer(), float() -> boolean())\"\n\n assert fun([integer()], boolean())\n |> union(fun([float()], boolean()))\n |> to_quoted_string() ==\n \"(integer() -> boolean()) or (float() -> boolean())\"\n\n assert fun([integer()], boolean())\n |> intersection(fun([float()], boolean()))\n |> to_quoted_string() ==\n \"(integer() -> boolean()) and (float() -> boolean())\"\n\n # Thanks to lazy BDDs, consecutive union of functions come out as the original union\n assert fun([integer()], integer())\n |> union(fun([float()], float()))\n |> union(fun([pid()], pid()))\n |> to_quoted_string() ==\n \"(integer() -> integer()) or (float() -> float()) or (pid() -> pid())\"\n\n assert fun(3) |> to_quoted_string() == \"(none(), none(), none() -> term())\"\n\n assert intersection(fun(), negation(fun())) |> to_quoted_string() == \"none()\"\n\n assert intersection(fun(), negation(fun(3))) |> to_quoted_string() ==\n \"fun() and not (none(), none(), none() -> term())\"\n end\n\n test \"fun with optimized intersections\" do\n assert fun([integer()], atom()) |> intersection(none_fun(1)) |> to_quoted_string() ==\n \"(integer() -> atom())\"\n\n assert fun([integer()], atom())\n |> difference(none_fun(2))\n |> intersection(none_fun(1))\n |> to_quoted_string() ==\n \"(integer() -> atom())\"\n end\n\n test \"fun with dynamic signatures\" do\n assert fun([dynamic(integer())], float()) |> to_quoted_string() ==\n \"(dynamic(integer()) -> float())\"\n\n assert fun([dynamic(atom())], float()) |> to_quoted_string() ==\n \"(dynamic(atom()) -> float())\"\n\n assert fun([integer(), float()], dynamic(atom())) |> to_quoted_string() ==\n \"(integer(), float() -> dynamic(atom()))\"\n\n domain_part = fun([dynamic(atom()) |> union(integer()), binary()], float())\n\n assert domain_part |> to_quoted_string() ==\n \"(dynamic(atom()) or integer(), binary() -> float())\"\n\n codomain_part = fun([pid(), float()], dynamic(atom()) |> union(integer()))\n\n assert codomain_part |> to_quoted_string() ==\n \"(pid(), float() -> dynamic(atom()) or integer())\"\n\n assert union(domain_part, codomain_part) |> to_quoted_string() ==\n \"\"\"\n (dynamic(atom()) or integer(), binary() -> float()) or\n (pid(), float() -> dynamic(atom()) or integer())\\\n \"\"\"\n\n assert intersection(domain_part, codomain_part) |> to_quoted_string() ==\n \"\"\"\n (dynamic(atom()) or integer(), binary() -> float()) and\n (pid(), float() -> dynamic(atom()) or integer())\\\n \"\"\"\n end\n\n test \"fun (negation)\" do\n assert fun([integer()], atom()) |> negation() |> to_quoted_string() ==\n \"not (integer() -> atom())\"\n end\n\n test \"map as records\" do\n assert empty_map() |> to_quoted_string() == \"empty_map()\"\n assert open_map() |> to_quoted_string() == \"map()\"\n\n assert closed_map(a: integer()) |> to_quoted_string() == \"%{a: integer()}\"\n assert open_map(a: float()) |> to_quoted_string() == \"%{..., a: float()}\"\n\n assert closed_map(\"Elixir.Foo.Bar\": integer()) |> to_quoted_string() ==\n \"%{Foo.Bar => integer()}\"\n\n assert open_map(\"Elixir.Foo.Bar\": float()) |> to_quoted_string() ==\n \"%{..., Foo.Bar => float()}\"\n\n assert difference(open_map(), open_map(a: term())) |> to_quoted_string() ==\n \"map() and not %{..., a: term()}\"\n\n assert closed_map(a: integer(), b: atom()) |> to_quoted_string() ==\n \"%{a: integer(), b: atom()}\"\n\n assert open_map(a: float())\n |> difference(closed_map(a: float()))\n |> to_quoted_string() == \"%{..., a: float()} and not %{a: float()}\"\n\n assert difference(open_map(), empty_map()) |> to_quoted_string() ==\n \"map() and not empty_map()\"\n\n assert closed_map(foo: union(integer(), not_set())) |> to_quoted_string() ==\n \"%{foo: if_set(integer())}\"\n\n # Test normalization\n assert open_map(a: integer(), b: atom())\n |> difference(open_map(b: atom()))\n |> union(open_map(a: integer()))\n |> to_quoted_string() == \"%{..., a: integer()}\"\n\n assert union(open_map(a: integer()), open_map(a: integer())) |> to_quoted_string() ==\n \"%{..., a: integer()}\"\n\n assert difference(open_map(a: number(), b: atom()), open_map(a: integer()))\n |> to_quoted_string() == \"%{..., a: float(), b: atom()}\"\n\n # Basic map fusion\n assert union(closed_map(a: integer()), closed_map(a: integer())) |> to_quoted_string() ==\n \"%{a: integer()}\"\n\n assert union(closed_map(a: integer()), closed_map(a: float())) |> to_quoted_string() ==\n \"%{a: float() or integer()}\"\n\n # Nested fusion\n assert union(closed_map(a: integer(), b: atom()), closed_map(a: float(), b: atom()))\n |> union(closed_map(x: pid(), y: pid(), z: port()))\n |> union(closed_map(x: pid(), y: pid(), z: atom()))\n |> to_quoted_string() ==\n \"%{a: float() or integer(), b: atom()} or %{x: pid(), y: pid(), z: atom() or port()}\"\n\n # Open map fusion\n assert union(open_map(a: integer()), open_map(a: float())) |> to_quoted_string() ==\n \"%{..., a: float() or integer()}\"\n\n # Fusing complex nested maps with unions\n assert closed_map(\n status: atom([:ok]),\n data: closed_map(value: term(), count: empty_list())\n )\n |> union(\n closed_map(\n status: atom([:ok]),\n data: closed_map(value: term(), count: open_map())\n )\n )\n |> union(closed_map(status: atom([:error]), reason: atom([:timeout])))\n |> union(closed_map(status: atom([:error]), reason: atom([:crash])))\n |> to_quoted_string() ==\n \"%{data: %{count: empty_list() or map(), value: term()}, status: :ok} or\\n %{reason: :crash or :timeout, status: :error}\"\n\n # Difference and union tests\n assert closed_map(status: atom([:ok]), value: term())\n |> difference(closed_map(status: atom([:ok]), value: float()))\n |> union(\n closed_map(status: atom([:ok]), value: term())\n |> difference(closed_map(status: atom([:ok]), value: integer()))\n )\n |> to_quoted_string() ==\n \"%{status: :ok, value: term()}\"\n\n # Nested map fusion\n assert closed_map(data: closed_map(x: integer(), y: atom()), meta: open_map())\n |> union(closed_map(data: closed_map(x: float(), y: atom()), meta: open_map()))\n |> to_quoted_string() ==\n \"%{data: %{x: float() or integer(), y: atom()}, meta: map()}\"\n\n # Test complex combinations\n assert intersection(\n open_map(a: number(), b: atom()),\n open_map(a: integer(), c: boolean())\n )\n |> union(difference(open_map(x: atom()), open_map(x: boolean())))\n |> to_quoted_string() ==\n \"%{..., a: integer(), b: atom(), c: boolean()} or %{..., x: atom() and not boolean()}\"\n\n assert closed_map(a: number(), b: atom(), c: pid())\n |> difference(closed_map(a: integer(), b: atom(), c: pid()))\n |> to_quoted_string() == \"%{a: float(), b: atom(), c: pid()}\"\n\n # No simplification compared to above, as it is an open map\n assert open_map(a: number(), b: atom())\n |> difference(closed_map(a: integer(), b: atom()))\n |> to_quoted_string() ==\n \"%{..., a: float() or integer(), b: atom()} and not %{a: integer(), b: atom()}\"\n\n # Remark: this simplification is order dependent. Having the first difference\n # after the second gives a different result.\n assert open_map(a: number(), b: atom(), c: union(pid(), port()))\n |> difference(open_map(a: integer(), b: atom(), c: union(pid(), port())))\n |> difference(open_map(a: float(), b: atom(), c: pid()))\n |> to_quoted_string() == \"%{..., a: float(), b: atom(), c: port()}\"\n\n assert open_map(a: number(), b: atom(), c: union(pid(), port()))\n |> difference(open_map(a: float(), b: atom(), c: pid()))\n |> difference(open_map(a: integer(), b: atom(), c: union(pid(), port())))\n |> to_quoted_string() == \"%{..., a: float(), b: atom(), c: port()}\"\n end\n\n test \"map as dictionaries\" do\n assert closed_map([{domain_key(:integer), integer()}])\n |> to_quoted_string() == \"%{integer() => integer()}\"\n\n assert closed_map([{domain_key(:integer), not_set()}, {:float, float()}])\n |> to_quoted_string() == \"%{integer() => not_set(), float: float()}\"\n end\n\n test \"map (negation)\" do\n assert open_map(a: integer()) |> negation() |> to_quoted_string() ==\n \"not %{..., a: integer()}\"\n\n assert open_map(a: negation(integer())) |> to_quoted_string() ==\n \"%{..., a: not integer()}\"\n\n assert closed_map(a: integer()) |> negation() |> to_quoted_string() ==\n \"not %{a: integer()}\"\n\n assert closed_map(a: negation(integer())) |> to_quoted_string() ==\n \"%{a: not integer()}\"\n end\n\n test \"structs\" do\n assert open_map(__struct__: term()) |> to_quoted_string() ==\n \"%{..., __struct__: term()}\"\n\n assert open_map(__struct__: atom([URI])) |> to_quoted_string() ==\n \"%{..., __struct__: URI}\"\n\n assert closed_map(__struct__: atom([URI])) |> to_quoted_string() ==\n \"%{__struct__: URI}\"\n\n assert closed_map(__struct__: atom([NoFieldsStruct])) |> to_quoted_string() ==\n \"%NoFieldsStruct{}\"\n\n assert closed_map(__struct__: atom([URI, Another])) |> to_quoted_string() ==\n \"%{__struct__: Another or URI}\"\n\n assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: term())\n |> to_quoted_string(collapse_structs: false) ==\n \"%Decimal{sign: term(), coef: term(), exp: term()}\"\n\n assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: term())\n |> to_quoted_string() ==\n \"%Decimal{}\"\n\n assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: integer())\n |> to_quoted_string() ==\n \"%Decimal{sign: integer()}\"\n\n # Does not fuse structs\n assert union(closed_map(__struct__: atom([Foo])), closed_map(__struct__: atom([Bar])))\n |> to_quoted_string() ==\n \"%{__struct__: Bar} or %{__struct__: Foo}\"\n\n # Properly format non_struct_map\n assert open_map(__struct__: if_set(negation(atom()))) |> to_quoted_string() ==\n \"non_struct_map()\"\n end\n end\n\n describe \"performance\" do\n test \"tuple difference\" do\n # Large difference with no duplicates\n descr1 =\n union(\n atom([:ignored, :reset]),\n tuple([atom([:font_style]), atom([:italic])])\n )\n\n descr2 =\n union(\n atom([:ignored, :reset]),\n union(\n tuple([atom([:font_style]), atom([:italic])]),\n Enum.reduce(\n for elem1 <- 1..5, elem2 <- 1..5 do\n tuple([atom([:\"f#{elem1}\"]), atom([:\"s#{elem2}\"])])\n end,\n &union/2\n )\n )\n )\n\n assert subtype?(descr1, descr2)\n refute subtype?(descr2, descr1)\n end\n\n test \"map difference\" do\n # Create a large map with various types\n map1 =\n open_map([\n {:id, integer()},\n {:name, binary()},\n {:age, union(integer(), atom())},\n {:email, binary()},\n {:active, boolean()},\n {:tags, list(atom())}\n ])\n\n # Create another large map with some differences and many more entries\n map2 =\n open_map(\n [\n {:id, integer()},\n {:name, binary()},\n {:age, integer()},\n {:email, binary()},\n {:active, boolean()},\n {:tags, non_empty_list(atom())},\n {:meta,\n open_map([\n {:created_at, binary()},\n {:updated_at, binary()},\n {:status, atom()}\n ])},\n {:permissions, tuple([atom(), integer(), atom()])},\n {:profile,\n open_map([\n {:bio, binary()},\n {:interests, non_empty_list(binary())},\n {:social_media,\n open_map([\n {:twitter, binary()},\n {:instagram, binary()},\n {:linkedin, binary()}\n ])}\n ])},\n {:notifications, boolean()}\n ] ++\n Enum.map(1..50, fn i ->\n {:\"field_#{i}\", atom([:\"value_#{i}\"])}\n end)\n )\n\n refute subtype?(map1, map2)\n assert subtype?(map2, map1)\n end\n\n test \"map intersection and then difference\" do\n actual = open_map(__struct__: atom(), __exception__: atom([true]))\n\n expected =\n for i <- 1..50 do\n name = :\"name_#{i}\"\n closed_map([__struct__: atom([name])] ++ [{name, binary()}])\n end\n |> Enum.reduce(&union/2)\n\n common = intersection(actual, expected)\n difference(actual, common)\n end\n\n test \"struct difference\" do\n entries =\n [\n closed_map(__struct__: atom([MapSet]), map: term()),\n closed_map(__struct__: atom([Jason.OrderedObject]), values: term()),\n closed_map(__struct__: atom([GenEvent.Stream]), timeout: term(), manager: term()),\n closed_map(__struct__: atom([HashDict]), size: term(), root: term()),\n closed_map(__struct__: atom([HashSet]), size: term(), root: term()),\n closed_map(\n __struct__: atom([IO.Stream]),\n raw: term(),\n device: term(),\n line_or_bytes: term()\n ),\n closed_map(__struct__: atom([Range]), first: term(), last: term(), step: term()),\n closed_map(\n __struct__: atom([Stream]),\n enum: term(),\n done: term(),\n funs: term(),\n accs: term()\n ),\n closed_map(\n __struct__: atom([Req.Response.Async]),\n pid: term(),\n ref: term(),\n stream_fun: term(),\n cancel_fun: term()\n ),\n closed_map(\n __struct__: atom([Postgrex.Stream]),\n options: term(),\n params: term(),\n query: term(),\n conn: term()\n ),\n closed_map(\n __struct__: atom([DBConnection.PrepareStream]),\n opts: term(),\n params: term(),\n query: term(),\n conn: term()\n ),\n closed_map(\n __struct__: atom([DBConnection.Stream]),\n opts: term(),\n params: term(),\n query: term(),\n conn: term()\n ),\n closed_map(\n __struct__: atom([Ecto.Adapters.SQL.Stream]),\n meta: term(),\n opts: term(),\n params: term(),\n statement: term()\n ),\n closed_map(\n __struct__: atom([Date.Range]),\n first: term(),\n last: term(),\n step: term(),\n first_in_iso_days: term(),\n last_in_iso_days: term()\n ),\n closed_map(\n __struct__: atom([File.Stream]),\n node: term(),\n raw: term(),\n path: term(),\n modes: term(),\n line_or_bytes: term()\n ),\n closed_map(\n __struct__: atom([Phoenix.LiveView.LiveStream]),\n name: term(),\n ref: term(),\n inserts: term(),\n deletes: term(),\n reset?: term(),\n dom_id: term(),\n consumable?: term()\n )\n ]\n\n range =\n closed_map(__struct__: atom([Range]), first: integer(), last: integer(), step: integer())\n\n assert subtype?(range, Enum.reduce(entries, &union/2))\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/expr_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"type_helper.exs\", __DIR__)\n\ndefmodule Module.Types.ExprTest do\n use ExUnit.Case, async: true\n\n import TypeHelper\n import Module.Types.Descr\n defmacro domain_key(arg) when is_atom(arg), do: [arg]\n\n defmacro generated_foo_call(x) do\n quote generated: true do\n unquote(x).foo()\n end\n end\n\n test \"literal\" do\n assert typecheck!(true) == atom([true])\n assert typecheck!(false) == atom([false])\n assert typecheck!(:foo) == atom([:foo])\n assert typecheck!(0) == integer()\n assert typecheck!(0.0) == float()\n assert typecheck!(\"foo\") == binary()\n assert typecheck!([]) == empty_list()\n assert typecheck!(%{}) == closed_map([])\n end\n\n test \"generated\" do\n assert typecheck!([x = 1], generated_foo_call(x)) == dynamic()\n end\n\n describe \"bitstrings\" do\n test \"integer alignment\" do\n assert typecheck!(<>) == binary()\n assert typecheck!(<>) == difference(bitstring(), binary())\n assert typecheck!(<>) == binary()\n assert typecheck!([size], <>) == bitstring()\n end\n\n test \"bitstring alignment\" do\n assert typecheck!(\n [coef, sign, exp],\n <>\n ) == binary()\n\n # This will be truncated to size, so it is a bitstring\n assert typecheck!([exp], <>) ==\n bitstring_no_binary()\n end\n end\n\n describe \"lists\" do\n test \"creating lists\" do\n assert typecheck!([1, 2]) == non_empty_list(integer())\n assert typecheck!([1, 2 | 3]) == non_empty_list(integer(), integer())\n assert typecheck!([1, 2 | [3, 4]]) == non_empty_list(integer())\n\n assert typecheck!([:ok, 123]) == non_empty_list(union(atom([:ok]), integer()))\n assert typecheck!([:ok | 123]) == non_empty_list(atom([:ok]), integer())\n assert typecheck!([x], [:ok, x]) == dynamic(non_empty_list(term()))\n assert typecheck!([x], [:ok | x]) == dynamic(non_empty_list(term(), term()))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x, y, z],\n (\n List.to_integer([x, y | z])\n {x, y, z}\n )\n ) == dynamic(tuple([integer(), integer(), list(integer())]))\n end\n\n test \"hd\" do\n assert typecheck!([x = [123, :foo]], hd(x)) == dynamic(union(atom([:foo]), integer()))\n assert typecheck!([x = [123 | :foo]], hd(x)) == dynamic(integer())\n\n assert typeerror!(hd([])) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Kernel.hd/1:\n\n hd([])\n\n given types:\n\n empty_list()\n\n but expected one of:\n\n non_empty_list(term(), term())\n \"\"\"\n\n assert typeerror!(hd(123)) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Kernel.hd/1:\n\n hd(123)\n\n given types:\n\n integer()\n\n but expected one of:\n\n non_empty_list(term(), term())\n \"\"\"\n end\n\n test \"tl\" do\n assert typecheck!([x = [123, :foo]], tl(x)) == dynamic(list(union(atom([:foo]), integer())))\n\n assert typecheck!([x = [123 | :foo]], tl(x)) ==\n dynamic(union(atom([:foo]), non_empty_list(integer(), atom([:foo]))))\n\n assert typeerror!(tl([])) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Kernel.tl/1:\n\n tl([])\n\n given types:\n\n empty_list()\n\n but expected one of:\n\n non_empty_list(term(), term())\n \"\"\"\n\n assert typeerror!(tl(123)) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Kernel.tl/1:\n\n tl(123)\n\n given types:\n\n integer()\n\n but expected one of:\n\n non_empty_list(term(), term())\n \"\"\"\n end\n end\n\n describe \"funs\" do\n test \"infers calls\" do\n assert typecheck!(\n [x],\n (\n x.(1, 2)\n x\n )\n ) == dynamic(fun(2))\n end\n\n test \"infers functions\" do\n assert typecheck!(& &1) |> equal?(fun([term()], dynamic()))\n\n assert typecheck!(fn -> :ok end) |> equal?(fun([], dynamic(atom([:ok]))))\n\n assert typecheck!(fn\n <<\"ok\">>, {} -> :ok\n <<\"error\">>, {} -> :error\n [_ | _], %{} -> :list\n end)\n |> equal?(\n intersection(\n fun(\n [non_empty_list(term(), term()), open_map()],\n dynamic(atom([:list]))\n ),\n fun(\n [binary(), tuple([])],\n dynamic(atom([:ok, :error]))\n )\n )\n )\n\n assert typecheck!(fn x -> Integer.to_string(x) end) ==\n fun([integer()], dynamic(binary()))\n end\n\n test \"application\" do\n assert typecheck!(\n [map],\n (fn\n %{a: a} = data -> %{data | b: a}\n %{} = data -> data\n end).(map)\n ) == dynamic()\n\n assert typecheck!(\n [],\n [true, false]\n |> Enum.random()\n |> then(fn\n true -> :ok\n _ -> :error\n end)\n ) == dynamic(atom([:ok, :error]))\n end\n\n test \"warns on redundant clauses\" do\n assert typewarn!(fn\n x when is_binary(x) -> x\n \"foo\" -> \"bar\"\n end)\n |> elem(1) == \"\"\"\n the following clause is redundant:\n\n \"foo\" ->\n\n previous clauses have already matched on the following types:\n\n binary()\n \"\"\"\n end\n\n test \"bad function\" do\n assert typeerror!([%x{}, a1, a2], x.(a1, a2)) == ~l\"\"\"\n expected a 2-arity function on function call:\n\n x.(a1, a2)\n\n but got type:\n\n dynamic(atom())\n\n where \"x\" was given the type:\n\n # type: dynamic(atom())\n # from: types_test.ex:LINE\n %x{}\n \"\"\"\n end\n\n test \"bad arity\" do\n assert typeerror!([a1, a2], (&String.to_integer/1).(a1, a2)) == ~l\"\"\"\n expected a 2-arity function on function call:\n\n (&String.to_integer/1).(a1, a2)\n\n but got function with arity 1:\n\n (binary() -> integer())\n \"\"\"\n end\n\n test \"bad argument\" do\n assert typeerror!([], (&String.to_integer/1).(:foo))\n |> strip_ansi() == ~l\"\"\"\n incompatible types given on function call:\n\n (&String.to_integer/1).(:foo)\n\n given types:\n\n :foo\n\n but function has type:\n\n (binary() -> integer())\n \"\"\"\n\n assert typeerror!(\n [x],\n (if x do\n &String.to_integer/1\n else\n &List.to_integer/1\n end).(:foo)\n )\n |> strip_ansi() == ~l\"\"\"\n incompatible types given on function call:\n\n (if x do\n &String.to_integer/1\n else\n &List.to_integer/1\n end).(:foo)\n\n given types:\n\n :foo\n\n but function has type:\n\n (binary() -> integer()) or (non_empty_list(integer()) -> integer())\n\n hint: the function has an empty domain and therefore cannot be applied to any argument. \\\n This may happen when you have a union of functions, which means the only valid argument \\\n to said function are types that satisfy all sides of the union (which may be none)\n \"\"\"\n end\n\n test \"bad arguments from inferred type\" do\n assert typeerror!(\n (\n fun = fn %{} -> :map end\n fun.(:error)\n )\n )\n |> strip_ansi() == \"\"\"\n incompatible types given on function call:\n\n fun.(:error)\n\n given types:\n\n :error\n\n but function has type:\n\n (map() -> dynamic(:map))\n \"\"\"\n end\n\n test \"capture printing\" do\n assert typeerror!(123 = &{:ok, &1}) == \"\"\"\n the following pattern will never match:\n\n 123 = &{:ok, &1}\n\n because the right-hand side has type:\n\n (term() -> dynamic({:ok, term()}))\n \"\"\"\n end\n\n test \"works when there are multiple clauses with lists and maps\" do\n type =\n typecheck!(fn\n [:oban, :job, _event], _measure, _meta, _opts ->\n :ok\n\n [:oban, :notifier, :switch], _measure, %{status: _status}, _opts ->\n :ok\n\n [:oban, :peer, :election, :stop], _measure, _meta, _opts ->\n :ok\n\n [:oban, :plugin, :exception], _measure, _meta, _opts ->\n :ok\n\n [:oban, :plugin, :stop], _measure, _meta, _opts ->\n :ok\n\n [:oban, :queue, :shutdown], _measure, %{orphaned: [_ | _]}, _opts ->\n :ok\n\n [:oban, :stager, :switch], _measure, %{mode: _mode}, _opts ->\n :ok\n\n _event, _measure, _meta, _opts ->\n :ok\n end)\n\n assert subtype?(type, fun([term(), term(), term(), term()], atom([:ok])))\n end\n end\n\n describe \"remotes\" do\n test \"dynamic calls\" do\n assert typecheck!([%x{}], x.foo_bar()) == dynamic()\n end\n\n test \"infers atoms\" do\n assert typecheck!(\n [x],\n (\n x.foo_bar()\n x\n )\n ) == dynamic(atom())\n\n assert typecheck!(\n [x],\n (\n x.foo_bar(123)\n x\n )\n ) == dynamic(atom())\n\n assert typecheck!(\n [x],\n (\n &x.foo_bar/1\n x\n )\n ) == dynamic(atom())\n end\n\n test \"infers maps\" do\n assert typecheck!(\n [x],\n (\n :foo = x.foo_bar\n 123 = x.baz_bat\n x\n )\n ) == dynamic(open_map(foo_bar: atom([:foo]), baz_bat: integer()))\n end\n\n test \"infers args\" do\n assert typecheck!(\n [x, y],\n (\n z = Integer.to_string(x + y)\n {x, y, z}\n )\n ) == dynamic(tuple([integer(), integer(), binary()]))\n end\n\n test \"undefined function warnings\" do\n assert typewarn!(URI.unknown(\"foo\")) ==\n {dynamic(), \"URI.unknown/1 is undefined or private\"}\n\n assert typewarn!(if(:rand.uniform() > 0.5, do: URI.unknown(\"foo\"))) ==\n {dynamic() |> union(atom([nil])), \"URI.unknown/1 is undefined or private\"}\n\n assert typewarn!(try(do: :ok, after: URI.unknown(\"foo\"))) ==\n {atom([:ok]), \"URI.unknown/1 is undefined or private\"}\n\n # Check it also emits over a union\n assert typewarn!(\n [x = Atom, y = GenServer, z],\n (\n mod =\n cond do\n z -> x\n true -> y\n end\n\n mod.to_string(:atom)\n )\n ) ==\n {union(dynamic(), binary()), \"GenServer.to_string/1 is undefined or private\"}\n end\n\n test \"calling a function with none()\" do\n assert typeerror!(Integer.to_string(raise \"oops\")) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Integer.to_string/1:\n\n Integer.to_string(raise RuntimeError.exception(\"oops\"))\n\n given types:\n\n none()\n\n the 1st argument is empty (often represented as none()), \\\n most likely because it is the result of an expression that \\\n always fails, such as a `raise` or a previous invalid call. \\\n This causes any function called with this value to fail\n \"\"\"\n end\n\n test \"calling a nullary function on non atoms\" do\n assert typeerror!([<>], x.foo_bar()) ==\n ~l\"\"\"\n expected a module (an atom) when invoking foo_bar/0 in expression:\n\n x.foo_bar()\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n <>\n\n #{hints(:dot)}\n \"\"\"\n end\n\n test \"calling a function on non atoms with arguments\" do\n assert typeerror!([<>], x.foo_bar(1, 2)) ==\n ~l\"\"\"\n expected a module (an atom) when invoking foo_bar/2 in expression:\n\n x.foo_bar(1, 2)\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n\n assert typeerror!(\n [<>, y = SomeMod, z],\n (\n mod =\n cond do\n z -> x\n true -> y\n end\n\n mod.to_string(:atom)\n )\n ) ==\n ~l\"\"\"\n expected a module (an atom) when invoking to_string/1 in expression:\n\n mod.to_string(:atom)\n\n where \"mod\" was given the type:\n\n # type: dynamic(SomeMod) or integer()\n # from: types_test.ex:LINE-9\n mod =\n cond do\n ...\n end\n \"\"\"\n end\n\n test \"calling a function with invalid arguments on variables\" do\n assert typeerror!(\n (\n x = List\n x.to_tuple(123)\n )\n )\n |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to List.to_tuple/1:\n\n x.to_tuple(123)\n\n given types:\n\n integer()\n\n but expected one of:\n\n list(term())\n\n where \"x\" was given the type:\n\n # type: List\n # from: types_test.ex:LINE-5\n x = List\n \"\"\"\n end\n\n test \"computes union of all combinations\" do\n assert typecheck!(\n [condition, arg],\n (\n mod = if condition, do: String, else: List\n res = mod.to_integer(arg)\n {arg, res}\n )\n ) == dynamic(tuple([union(binary(), non_empty_list(integer())), integer()]))\n\n assert typeerror!(\n [condition],\n (\n arg = if condition, do: \"foo\", else: [?f, ?o, ?o]\n mod = if condition, do: String, else: List\n mod.to_integer(arg)\n )\n )\n |> strip_ansi() == ~l\"\"\"\n incompatible types given to List.to_integer/1:\n\n mod.to_integer(arg)\n #=> invoked as List.to_integer/1\n\n given types:\n\n binary() or non_empty_list(integer())\n\n but expected one of:\n\n non_empty_list(integer())\n\n where \"arg\" was given the type:\n\n # type: binary() or non_empty_list(integer())\n # from: types_test.ex:LINE-5\n arg =\n if condition do\n \"foo\"\n else\n ~c\"foo\"\n end\n\n where \"mod\" was given the type:\n\n # type: List or String\n # from: types_test.ex:LINE-4\n mod =\n if condition do\n String\n else\n List\n end\n \"\"\"\n end\n\n test \"calling a function with conditional variables excluside to the application\" do\n assert typecheck!(\n [condition, arg],\n (\n mod = if condition, do: Integer, else: Float\n\n mod.parse(\n (\n query = \"+\" <> arg\n String.trim_trailing(query)\n )\n )\n )\n ) == dynamic()\n end\n end\n\n describe \"remote capture\" do\n test \"strong\" do\n assert typecheck!(&String.to_atom/1) == fun([binary()], atom())\n assert typecheck!(&:erlang.element/2) == fun([integer(), open_tuple([])], dynamic())\n end\n\n test \"unknown\" do\n assert typecheck!(&Module.Types.ExprTest.__ex_unit__/1) == dynamic(fun(1))\n assert typecheck!([x], &x.something/1) == dynamic(fun(1))\n end\n\n test \"capture a function with non atoms\" do\n assert typeerror!([<>], &x.foo_bar/2) ==\n ~l\"\"\"\n expected a module (an atom) when invoking foo_bar/2 in expression:\n\n &x.foo_bar/2\n\n but got type:\n\n integer()\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n end\n end\n\n describe \"binaries\" do\n test \"inference\" do\n assert typecheck!(\n [x, y],\n (\n <>\n {x, y}\n )\n ) == dynamic(tuple([union(float(), integer()), integer()]))\n end\n\n test \"warnings\" do\n assert typeerror!([<>], <>) ==\n ~l\"\"\"\n incompatible types in binary construction:\n\n <>\n\n got type:\n\n binary()\n\n but expected type:\n\n float() or integer()\n\n where \"x\" was given the type:\n\n # type: binary()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n\n assert typeerror!([<>], <>) ==\n ~l\"\"\"\n incompatible types in binary construction:\n\n <>\n\n got type:\n\n binary()\n\n but expected type:\n\n integer()\n\n where \"x\" was given the type:\n\n # type: binary()\n # from: types_test.ex:LINE-1\n <>\n\n #{hints(:inferred_bitstring_spec)}\n \"\"\"\n\n assert typeerror!([<>], <>) ==\n ~l\"\"\"\n incompatible types in binary construction:\n\n <>\n\n got type:\n\n integer()\n\n but expected type:\n\n binary()\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n <>\n\n #{hints(:inferred_bitstring_spec)}\n \"\"\"\n end\n\n test \"size ok\" do\n assert typecheck!([<>, z], <>) == bitstring()\n assert typedyn!([<>, z], <>) == dynamic(bitstring())\n end\n\n test \"size error\" do\n assert typeerror!([<>, y], <>) ==\n ~l\"\"\"\n expected an integer in binary size:\n\n size(x)\n\n got type:\n\n binary()\n\n where \"x\" was given the type:\n\n # type: binary()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n end\n end\n\n describe \"tuples\" do\n test \"creating tuples\" do\n assert typecheck!({:ok, 123}) == tuple([atom([:ok]), integer()])\n assert typecheck!([x], {:ok, x}) == dynamic(tuple([atom([:ok]), term()]))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x, y],\n (\n {:ok, :error} = {x, y}\n {x, y}\n )\n ) == dynamic(tuple([atom([:ok]), atom([:error])]))\n end\n\n test \"elem/2\" do\n assert typecheck!(elem({:ok, 123}, 0)) == atom([:ok])\n assert typecheck!(elem({:ok, 123}, 1)) == integer()\n assert typecheck!([x], elem({:ok, x}, 0)) == dynamic(atom([:ok]))\n assert typecheck!([x], elem({:ok, x}, 1)) == dynamic(term())\n\n assert typeerror!([<>], elem(x, 0)) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Kernel.elem/2:\n\n elem(x, 0)\n\n given types:\n\n float(), integer()\n\n but expected one of:\n\n {...}, integer()\n\n where \"x\" was given the type:\n\n # type: float()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n\n assert typeerror!(elem({:ok, 123}, 2)) ==\n ~l\"\"\"\n expected a tuple with at least 3 elements in Kernel.elem/2:\n\n elem({:ok, 123}, 2)\n\n the given type does not have the given index:\n\n {:ok, integer()}\n \"\"\"\n end\n\n test \"Tuple.insert_at/3\" do\n assert typecheck!(Tuple.insert_at({}, 0, \"foo\")) == tuple([binary()])\n\n assert typecheck!(Tuple.insert_at({:ok, 123}, 0, \"foo\")) ==\n tuple([binary(), atom([:ok]), integer()])\n\n assert typecheck!(Tuple.insert_at({:ok, 123}, 1, \"foo\")) ==\n tuple([atom([:ok]), binary(), integer()])\n\n assert typecheck!(Tuple.insert_at({:ok, 123}, 2, \"foo\")) ==\n tuple([atom([:ok]), integer(), binary()])\n\n assert typeerror!([<>], Tuple.insert_at(x, 0, \"foo\")) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Tuple.insert_at/3:\n\n Tuple.insert_at(x, 0, \"foo\")\n\n given types:\n\n float(), integer(), binary()\n\n but expected one of:\n\n {...}, integer(), term()\n\n where \"x\" was given the type:\n\n # type: float()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n\n assert typeerror!(Tuple.insert_at({:ok, 123}, 3, \"foo\")) ==\n ~l\"\"\"\n expected a tuple with at least 3 elements in Tuple.insert_at/3:\n\n Tuple.insert_at({:ok, 123}, 3, \"foo\")\n\n the given type does not have the given index:\n\n {:ok, integer()}\n \"\"\"\n end\n\n test \"Tuple.delete_at/2\" do\n assert typecheck!(Tuple.delete_at({:ok, 123}, 0)) == tuple([integer()])\n assert typecheck!(Tuple.delete_at({:ok, 123}, 1)) == tuple([atom([:ok])])\n assert typecheck!([x], Tuple.delete_at({:ok, x}, 0)) == dynamic(tuple([term()]))\n assert typecheck!([x], Tuple.delete_at({:ok, x}, 1)) == dynamic(tuple([atom([:ok])]))\n\n assert typeerror!([<>], Tuple.delete_at(x, 0)) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Tuple.delete_at/2:\n\n Tuple.delete_at(x, 0)\n\n given types:\n\n float(), integer()\n\n but expected one of:\n\n {...}, integer()\n\n where \"x\" was given the type:\n\n # type: float()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n\n assert typeerror!(Tuple.delete_at({:ok, 123}, 2)) ==\n ~l\"\"\"\n expected a tuple with at least 3 elements in Tuple.delete_at/2:\n\n Tuple.delete_at({:ok, 123}, 2)\n\n the given type does not have the given index:\n\n {:ok, integer()}\n \"\"\"\n end\n\n test \"Tuple.duplicate/2\" do\n assert typecheck!(Tuple.duplicate(123, 0)) == tuple([])\n assert typecheck!(Tuple.duplicate(123, 1)) == tuple([integer()])\n assert typecheck!(Tuple.duplicate(123, 2)) == tuple([integer(), integer()])\n assert typecheck!([x], Tuple.duplicate(x, 2)) == dynamic(tuple([term(), term()]))\n end\n end\n\n describe \"maps\" do\n test \"creating maps as records\" do\n assert typecheck!(%{foo: :bar}) == closed_map(foo: atom([:bar]))\n assert typecheck!([x], %{key: x}) == dynamic(closed_map(key: term()))\n end\n\n test \"creating maps as records with dynamic keys\" do\n assert typecheck!(\n (\n foo = :foo\n %{foo => :first, foo => :second}\n )\n ) == closed_map(foo: atom([:second]))\n\n assert typecheck!(\n (\n foo_or_bar =\n cond do\n :rand.uniform() > 0.5 -> :foo\n true -> :bar\n end\n\n %{foo_or_bar => :first, foo_or_bar => :second}\n )\n )\n |> equal?(\n closed_map(foo: atom([:second]))\n |> union(closed_map(bar: atom([:second])))\n |> union(closed_map(foo: atom([:first]), bar: atom([:second])))\n |> union(closed_map(bar: atom([:first]), foo: atom([:second])))\n )\n end\n\n test \"creating maps as dictionaries\" do\n assert typecheck!(%{123 => 456}) == closed_map([{domain_key(:integer), integer()}])\n\n # Since key cannot override :foo based on position, we preserve it\n assert typecheck!([key], %{key => 456, foo: :bar}) ==\n dynamic(\n closed_map([\n {to_domain_keys(:term), integer()},\n {:foo, atom([:bar])}\n ])\n )\n\n # Since key can override :foo based on position, we union it\n assert typecheck!([key], %{:foo => :bar, key => :baz}) ==\n dynamic(\n closed_map([\n {to_domain_keys(:term), atom([:baz])},\n {:foo, atom([:bar, :baz])}\n ])\n )\n\n # Since key cannot override :foo based on domain, we preserve it\n assert typecheck!(\n [arg],\n (\n key = String.to_integer(arg)\n %{:foo => :bar, key => :baz}\n )\n ) ==\n closed_map([\n {domain_key(:integer), atom([:baz])},\n {:foo, atom([:bar])}\n ])\n\n # Multiple keys are fully overridden for simplicity\n assert typecheck!(\n [arg],\n (\n foo_or_bar = if String.starts_with?(arg, \"0\"), do: :foo, else: :bar\n key = String.to_integer(arg)\n %{foo_or_bar => :old, key => :new}\n )\n ) ==\n union(\n closed_map([\n {domain_key(:integer), atom([:new])},\n {:foo, atom([:old])}\n ]),\n closed_map([\n {domain_key(:integer), atom([:new])},\n {:bar, atom([:old])}\n ])\n )\n end\n\n test \"updating to maps as records\" do\n assert typecheck!([x], %{x | x: :zero}) ==\n dynamic(open_map(x: atom([:zero])))\n\n assert typecheck!([x], %{%{x | x: :zero} | y: :one}) ==\n dynamic(open_map(x: atom([:zero]), y: atom([:one])))\n\n assert typecheck!(\n (\n foo_or_bar =\n cond do\n :rand.uniform() > 0.5 -> :key1\n true -> :key2\n end\n\n x = %{key1: :one, key2: :two}\n %{x | foo_or_bar => :one!, foo_or_bar => :two!}\n )\n )\n |> equal?(\n closed_map(key1: atom([:one]), key2: atom([:two!]))\n |> union(closed_map(key1: atom([:two!]), key2: atom([:one!])))\n |> union(closed_map(key1: atom([:one!]), key2: atom([:two!])))\n |> union(closed_map(key1: atom([:two!]), key2: atom([:two])))\n )\n\n assert typeerror!([x = :foo], %{x | x: :zero}) == ~l\"\"\"\n expected a map within map update syntax:\n\n %{x | x: :zero}\n\n but got type:\n\n dynamic(:foo)\n\n where \"x\" was given the type:\n\n # type: dynamic(:foo)\n # from: types_test.ex:LINE\n x = :foo\n \"\"\"\n\n assert typeerror!(\n (\n x = %{}\n %{x | x: :zero}\n )\n ) == ~l\"\"\"\n expected a map with key :x in map update syntax:\n\n %{x | x: :zero}\n\n but got type:\n\n empty_map()\n\n where \"x\" was given the type:\n\n # type: empty_map()\n # from: types_test.ex:LINE-3\n x = %{}\n \"\"\"\n\n # Assert we check all possible combinations\n assert typeerror!(\n (\n foo_or_bar =\n cond do\n :rand.uniform() > 0.5 -> :foo\n true -> :bar\n end\n\n x = %{foo: :baz}\n %{x | foo_or_bar => :bat}\n )\n ) == ~l\"\"\"\n expected a map with key :bar in map update syntax:\n\n %{x | foo_or_bar => :bat}\n\n but got type:\n\n %{foo: :baz}\n\n where \"foo_or_bar\" was given the type:\n\n # type: :bar or :foo\n # from: types_test.ex:LINE-9\n foo_or_bar =\n cond do\n ...\n end\n\n where \"x\" was given the type:\n\n # type: %{foo: :baz}\n # from: types_test.ex:LINE-3\n x = %{foo: :baz}\n \"\"\"\n\n # The goal of this assertion is to verify we assert keys,\n # even if they may be overridden later.\n assert typeerror!(\n [key],\n (\n x = %{key: :value}\n %{x | :foo => :baz, key => :bat}\n )\n ) == ~l\"\"\"\n expected a map with key :foo in map update syntax:\n\n %{x | :foo => :baz, key => :bat}\n\n but got type:\n\n %{key: :value}\n\n where \"key\" was given the type:\n\n # type: dynamic()\n # from: types_test.ex:LINE-5\n key\n\n where \"x\" was given the type:\n\n # type: %{key: :value}\n # from: types_test.ex:LINE-3\n x = %{key: :value}\n \"\"\"\n end\n\n test \"updating to maps as dictionaries\" do\n assert typecheck!(\n [key],\n (\n x = %{foo: :bar}\n %{x | key => :baz}\n )\n ) == closed_map(foo: atom([:bar, :baz]))\n\n # Override based on position\n assert typecheck!(\n [key],\n (\n x = %{foo: :bar, baz: :bat}\n %{x | key => :old, foo: :new}\n )\n ) == closed_map(foo: atom([:new]), baz: atom([:old, :bat]))\n\n assert typeerror!(\n [key],\n (\n x = %{String.to_integer(key) => :old}\n %{x | String.to_atom(key) => :new}\n )\n ) == ~l\"\"\"\n expected a map with key of type atom() in map update syntax:\n\n %{x | String.to_atom(key) => :new}\n\n but got type:\n\n %{integer() => :old}\n\n where \"key\" was given the type:\n\n # type: binary()\n # from: types_test.ex:LINE-3\n String.to_integer(key)\n\n where \"x\" was given the type:\n\n # type: %{integer() => :old}\n # from: types_test.ex:LINE-3\n x = %{String.to_integer(key) => :old}\n \"\"\"\n\n assert typeerror!(\n [key],\n (\n x = %{key: :old}\n %{x | String.to_atom(key) => :new}\n )\n ) == ~l\"\"\"\n expected a map with key of type atom() in map update syntax:\n\n %{x | String.to_atom(key) => :new}\n\n but got type:\n\n %{key: :old}\n\n where \"key\" was given the type:\n\n # type: binary()\n # from: types_test.ex:LINE-2\n String.to_atom(key)\n\n where \"x\" was given the type:\n\n # type: %{key: :old}\n # from: types_test.ex:LINE-3\n x = %{key: :old}\n \"\"\"\n end\n\n test \"nested map\" do\n assert typecheck!([x = %{}], x.foo.bar) == dynamic()\n end\n\n test \"accessing a field on not a map\" do\n assert typeerror!([<>], x.foo_bar) ==\n ~l\"\"\"\n expected a map or struct when accessing .foo_bar in expression:\n\n x.foo_bar\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n <>\n\n #{hints(:dot)}\n \"\"\"\n end\n end\n\n describe \"structs\" do\n test \"creating structs\" do\n assert typecheck!(%Point{}) ==\n closed_map(\n __struct__: atom([Point]),\n x: atom([nil]),\n y: atom([nil]),\n z: integer()\n )\n\n assert typecheck!(%Point{x: :zero}) ==\n closed_map(\n __struct__: atom([Point]),\n x: atom([:zero]),\n y: atom([nil]),\n z: integer()\n )\n end\n\n test \"updating unknown struct\" do\n {_, [diagnostic]} = typediag!([x], %UNKNOWN.URI{x | foo: 123})\n assert diagnostic.severity == :warning\n\n assert diagnostic.message ==\n \"struct UNKNOWN.URI is undefined (module UNKNOWN.URI is not available or is yet to be defined)\"\n\n {_, [diagnostic]} = typediag!([x], %Enumerable{x | foo: 123})\n assert diagnostic.severity == :warning\n\n assert diagnostic.message ==\n \"struct Enumerable is undefined (there is such module but it does not define a struct)\"\n end\n\n test \"updating field in unknown struct\" do\n assert typeerror!(\n [x],\n (\n %UNKNOWN.URI{x | foo: y = 123}\n y\n )\n ) =~\n \"struct UNKNOWN.URI is undefined (module UNKNOWN.URI is not available or is yet to be defined)\"\n end\n\n test \"updating unknown field\" do\n {_, [diagnostic]} = typediag!([%URI{} = x], %URI{x | unknown: 123})\n assert diagnostic.severity == :warning\n assert diagnostic.message == \"unknown key :unknown for struct URI\"\n end\n\n test \"updating structs\" do\n integer_date_type =\n dynamic(\n closed_map(\n __struct__: atom([Date]),\n day: integer(),\n calendar: atom(),\n month: term(),\n year: term()\n )\n )\n\n # When we know the type\n assert typecheck!([], %Date{Date.new!(1, 1, 1) | day: 31}) ==\n integer_date_type\n\n assert typecheck!([], %Date{%Date{Date.new!(1, 1, 1) | day: 13} | day: 31}) ==\n integer_date_type\n\n # When we don't know the type of var\n assert typeerror!([x], %Date{x | day: 31}) == ~l\"\"\"\n a struct for Date is expected on struct update:\n\n %Date{x | day: 31}\n\n but got type:\n\n dynamic()\n\n where \"x\" was given the type:\n\n # type: dynamic()\n # from: types_test.ex:LINE\n x\n\n when defining the variable \"x\", you must also pattern match on \"%Date{}\"\n \"\"\"\n\n # When we don't know the type of capture\n assert typeerror!([], &%Date{&1 | day: 31}) =~ ~l\"\"\"\n a struct for Date is expected on struct update:\n\n %Date{&1 | day: 31}\n\n but got type:\n\n dynamic()\n\n where \"capture\" was given the type:\n\n # type: dynamic()\n # from: types_test.ex:LINE\n &1\n\n instead of using &1, you must define an anonymous function, define a variable and pattern match on \"%Date{}\"\n \"\"\"\n\n # When we don't know the type of expression\n assert typeerror!([], %Date{SomeMod.fun() | day: 31}) =~ \"\"\"\n a struct for Date is expected on struct update:\n\n %Date{SomeMod.fun() | day: 31}\n\n but got type:\n\n dynamic()\n\n you must assign \"SomeMod.fun()\" to variable and pattern match on \"%Date{}\"\n \"\"\"\n end\n\n test \"accessing an unknown field on struct with diagnostic\" do\n {type, [diagnostic]} = typediag!(%Point{}.foo_bar)\n assert type == dynamic()\n assert diagnostic.span == {__ENV__.line - 2, 56}\n\n assert diagnostic.message == ~l\"\"\"\n unknown key .foo_bar in expression:\n\n %Point{x: nil, y: nil, z: 0}.foo_bar\n\n the given type does not have the given key:\n\n %Point{x: nil, y: nil, z: integer()}\n \"\"\"\n end\n\n test \"accessing an unknown field on struct in a var with diagnostic\" do\n {type, [diagnostic]} = typediag!([x = %URI{}], x.foo_bar)\n assert type == dynamic()\n assert diagnostic.span == {__ENV__.line - 2, 63}\n\n assert diagnostic.message == ~l\"\"\"\n unknown key .foo_bar in expression:\n\n x.foo_bar\n\n the given type does not have the given key:\n\n dynamic(%URI{\n scheme: term(),\n authority: term(),\n userinfo: term(),\n host: term(),\n port: term(),\n path: term(),\n query: term(),\n fragment: term()\n })\n\n where \"x\" was given the type:\n\n # type: dynamic(%URI{})\n # from: types_test.ex:LINE-4:43\n x = %URI{}\n \"\"\"\n\n assert [%{type: :variable, name: :x}] = diagnostic.details.typing_traces\n end\n\n test \"inspect struct definition\" do\n assert typeerror!(\n (\n p = %Point{x: 123}\n Integer.to_string(p)\n )\n )\n |> strip_ansi() == ~l\"\"\"\n incompatible types given to Integer.to_string/1:\n\n Integer.to_string(p)\n\n given types:\n\n %Point{x: integer(), y: nil, z: integer()}\n\n but expected one of:\n\n integer()\n\n where \"p\" was given the type:\n\n # type: %Point{x: integer(), y: nil, z: integer()}\n # from: types_test.ex:LINE-4\n p = %Point{..., x: 123}\n \"\"\"\n end\n end\n\n describe \"comparison\" do\n test \"in static mode\" do\n assert typecheck!([x = 123, y = 456.0], x < y) == boolean()\n assert typecheck!([x = 123, y = 456.0], x == y) == boolean()\n end\n\n test \"in dynamic mode\" do\n assert typedyn!([x = 123, y = 456.0], x < y) == dynamic(boolean())\n assert typedyn!([x = 123, y = 456.0], x == y) == dynamic(boolean())\n assert typedyn!([x = 123, y = 456], x == y) == dynamic(boolean())\n end\n\n test \"using literals\" do\n assert typecheck!(:foo == :bar) == boolean()\n end\n\n test \"min/max\" do\n assert typecheck!(min(123, 456.0)) == union(integer(), float())\n # min/max uses parametric types, which will carry dynamic regardless of being a strong arrow\n assert typecheck!([x = 123, y = 456.0], min(x, y)) == dynamic(union(integer(), float()))\n end\n\n test \"warns when comparison is constant\" do\n assert typeerror!([x = :foo, y = 321], min(x, y)) ==\n ~l\"\"\"\n comparison between distinct types found:\n\n min(x, y)\n\n given types:\n\n min(dynamic(:foo), integer())\n\n where \"x\" was given the type:\n\n # type: dynamic(:foo)\n # from: types_test.ex:LINE-1\n x = :foo\n\n where \"y\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n y = 321\n\n While Elixir can compare across all types, you are comparing across types \\\n which are always disjoint, and the result is either always true or always false\n \"\"\"\n\n assert typeerror!([x = 123, y = 456.0], x === y) ==\n ~l\"\"\"\n comparison between distinct types found:\n\n x === y\n\n given types:\n\n integer() === float()\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n x = 123\n\n where \"y\" was given the type:\n\n # type: float()\n # from: types_test.ex:LINE-1\n y = 456.0\n\n While Elixir can compare across all types, you are comparing across types \\\n which are always disjoint, and the result is either always true or always false\n \"\"\"\n end\n\n test \"warns on comparison with struct across dynamic call\" do\n assert typeerror!([x = %Point{}, y = %Point{}, mod = Kernel], mod.<=(x, y)) ==\n ~l\"\"\"\n comparison with structs found:\n\n mod.<=(x, y)\n\n given types:\n\n dynamic(%Point{}) <= dynamic(%Point{})\n\n where \"mod\" was given the type:\n\n # type: dynamic(Kernel)\n # from: types_test.ex:LINE-1\n mod = Kernel\n\n where \"x\" was given the type:\n\n # type: dynamic(%Point{})\n # from: types_test.ex:LINE-1\n x = %Point{}\n\n where \"y\" was given the type:\n\n # type: dynamic(%Point{})\n # from: types_test.ex:LINE-1\n y = %Point{}\n\n Comparison operators (>, <, >=, <=, min, and max) perform structural and not semantic comparison. Comparing with a struct won't give meaningful results. Structs that can be compared typically define a compare/2 function within their modules that can be used for semantic comparison.\n \"\"\"\n\n assert typeerror!(\n [x = %Point{}, mod = Kernel, condition],\n (\n y = if condition, do: 456, else: %Point{}\n mod.<=(x, y)\n )\n ) =~ \"comparison with structs found:\"\n\n assert typecheck!(\n [x = 123, mod = Kernel, condition],\n (\n y = if condition, do: 456, else: %Point{}\n mod.<=(x, y)\n )\n ) == boolean()\n\n assert typeerror!(\n [mod = Kernel, condition],\n (\n x = if condition, do: 123, else: %Point{}\n y = if condition, do: 456, else: %Point{}\n mod.<=(x, y)\n )\n ) =~ \"comparison with structs found:\"\n end\n end\n\n describe \":erlang rewrites\" do\n test \"Kernel.not/1\" do\n assert typecheck!([x], not is_list(x)) == boolean()\n end\n\n test \"Kernel.+/2\" do\n assert typeerror!([x = :foo, y = 123], x + y) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Kernel.+/2:\n\n x + y\n\n given types:\n\n dynamic(:foo), integer()\n\n but expected one of:\n\n #1\n integer(), integer()\n\n #2\n integer(), float()\n\n #3\n float(), integer()\n\n #4\n float(), float()\n\n where \"x\" was given the type:\n\n # type: dynamic(:foo)\n # from: types_test.ex:LINE-1\n x = :foo\n\n where \"y\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n y = 123\n \"\"\"\n end\n\n test \"Integer.to_string/1\" do\n assert typecheck!([x = 123], Integer.to_string(x)) == binary()\n\n assert typeerror!([x = :foo], Integer.to_string(x)) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Integer.to_string/1:\n\n Integer.to_string(x)\n\n given types:\n\n dynamic(:foo)\n\n but expected one of:\n\n integer()\n\n where \"x\" was given the type:\n\n # type: dynamic(:foo)\n # from: types_test.ex:LINE-1\n x = :foo\n \"\"\"\n end\n\n test \"Bitwise.bnot/1\" do\n assert typecheck!([x = 123], Bitwise.bnot(x)) == integer()\n\n assert typeerror!([x = :foo], Bitwise.bnot(x)) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Bitwise.bnot/1:\n\n Bitwise.bnot(x)\n\n given types:\n\n dynamic(:foo)\n\n but expected one of:\n\n integer()\n\n where \"x\" was given the type:\n\n # type: dynamic(:foo)\n # from: types_test.ex:LINE-1\n x = :foo\n \"\"\"\n end\n\n test \"Kernel.in/2\" do\n assert typecheck!(\n [x],\n (\n true = x in [:foo, 1, :bar, 2.0, :baz]\n x\n )\n ) ==\n dynamic(union(atom([:foo, :bar, :baz]), union(integer(), float())))\n\n assert typecheck!(\n [x],\n (\n false = x in [:foo, 1, :bar, 2.0, :baz]\n x\n )\n ) ==\n dynamic(negation(atom([:foo, :bar, :baz])))\n\n assert typecheck!(\n [x],\n (\n true = x not in [:foo, 1, :bar, 2.0, :baz]\n x\n )\n ) ==\n dynamic(negation(atom([:foo, :bar, :baz])))\n\n assert typecheck!(\n [x],\n (\n false = x not in [:foo, 1, :bar, 2.0, :baz]\n x\n )\n ) ==\n dynamic(union(atom([:foo, :bar, :baz]), union(integer(), float())))\n\n assert typeerror!([x = :ok], true = x in [:foo, 1.0, :baz]) =~ ~l\"\"\"\n comparison between distinct types found:\n\n x in [:foo, 1.0, :baz]\n\n given types:\n\n dynamic(:ok) in list(:baz or :foo or float())\n\n where \"x\" was given the type:\n\n # type: dynamic(:ok)\n # from: types_test.ex:LINE\n x = :ok\n \"\"\"\n\n assert typeerror!(\n [x],\n (\n true = x in [:foo, :bar]\n :baz = x\n )\n ) == ~l\"\"\"\n the following pattern will never match:\n\n :baz = x\n\n because the right-hand side has type:\n\n dynamic(:bar or :foo)\n\n where \"x\" was given the type:\n\n # type: dynamic(:bar or :foo)\n # from: types_test.ex:LINE-3\n x in [:foo, :bar]\n \"\"\"\n end\n end\n\n describe \"case\" do\n test \"does not type check literals\" do\n assert typecheck!(\n case :dev do\n :dev -> :ok\n :prod -> :error\n end\n ) == atom([:ok, :error])\n end\n\n test \"resets branches\" do\n assert typecheck!(\n [x],\n (\n case :rand.uniform() do\n y when y < 0.5 -> x.foo\n y when y > 0.5 -> x.bar()\n end\n\n x\n )\n ) == dynamic()\n end\n\n test \"returns unions of all clauses\" do\n assert typecheck!(\n [x],\n case x do\n :ok -> :ok\n :error -> :error\n end\n ) == atom([:ok, :error])\n\n assert typedyn!(\n [x],\n case x do\n :ok -> :ok\n :error -> :error\n end\n ) == dynamic(atom([:ok, :error]))\n end\n\n defmacrop generated(op) do\n Macro.update_meta(op, &([generated: true] ++ &1))\n end\n\n test \"ignores always failing guards\" do\n assert typecheck!(\n case System.get_env(\"foo\") do\n x when generated(x == false) or byte_size(x) >= 0 -> :binary\n _ -> nil\n end\n ) == atom([nil, :binary])\n\n assert typecheck!(\n case System.get_env(\"foo\") do\n x when generated(x == false) or x == nil -> nil\n _ -> :binary\n end\n ) == atom([nil, :binary])\n end\n\n test \"computes types based on previous branches\" do\n assert typecheck!(\n [condition],\n case condition do\n x when is_binary(x) -> {:binary, x}\n x when is_bitstring(x) -> {:bitstring, x}\n end\n ) ==\n dynamic(\n union(\n tuple([atom([:binary]), binary()]),\n tuple([atom([:bitstring]), bitstring_no_binary()])\n )\n )\n\n assert typecheck!(\n [condition],\n case condition do\n x = %{} when x != %{} -> :non_empty_map\n %{} -> :maybe_empty_map\n end\n ) ==\n atom([:non_empty_map, :maybe_empty_map])\n end\n\n test \"warns on redundant clauses\" do\n assert typewarn!(\n [x],\n case System.get_env(x) do\n nil -> 1\n b when is_binary(b) -> 2\n other -> other\n end\n )\n |> elem(1) =~ ~l\"\"\"\n the following clause cannot match because the previous clauses already matched all possible values:\n\n other ->\n\n it attempts to match on the result of:\n\n System.get_env(x)\n\n which has the already matched type:\n\n dynamic(nil or binary())\n \"\"\"\n\n assert typewarn!(\n [x],\n case String.to_atom(x) do\n :ok -> 1\n :ok -> 2\n end\n )\n |> elem(1) == ~l\"\"\"\n the following clause is redundant:\n\n :ok ->\n\n previous clauses have already matched on the following types:\n\n :ok\n \"\"\"\n\n assert typewarn!(\n [a, b],\n case {a, b} do\n {x, y} when is_integer(x) and is_integer(y) -> 1\n {x, y} when is_integer(x) and is_integer(y) -> 2\n end\n )\n |> elem(1) =~ ~l\"\"\"\n the following clause is redundant:\n\n {x, y} when is_integer(x) and is_integer(y) ->\n\n previous clauses have already matched on the following types:\n\n {integer(), integer()}\n \"\"\"\n end\n\n test \"reports error from clause that will never match\" do\n assert typeerror!(\n [x],\n case Atom.to_string(x) do\n :error -> :error\n x -> x\n end\n ) == ~l\"\"\"\n the following clause will never match:\n\n :error ->\n\n because it attempts to match on the result of:\n\n Atom.to_string(x)\n\n which has type:\n\n binary()\n \"\"\"\n end\n\n test \"reports errors from multiple clauses\" do\n {type, [_, _]} =\n typediag!(\n [x],\n case Atom.to_string(x) do\n :ok -> :ok\n :error -> :error\n end\n )\n\n assert type == atom([:ok, :error])\n end\n end\n\n describe \"conditionals\" do\n test \"if does not report on literals\" do\n assert typecheck!(\n if true do\n :ok\n end\n ) == atom([:ok, nil])\n end\n\n test \"and/or does not report on literals\" do\n assert typecheck!(false and true) == boolean()\n assert typecheck!(false or true) == atom([true])\n end\n\n test \"and reports violations\" do\n assert typeerror!([x = 123], x and true) =~ \"\"\"\n the following conditional expression will always fail:\n\n x\n\n because it evaluates to:\n\n integer()\n \"\"\"\n\n assert typeerror!([x = true], x and true) =~ \"\"\"\n the following conditional expression will always succeed:\n\n x\n\n because it evaluates to:\n\n dynamic(true)\n \"\"\"\n\n assert typeerror!([x = false], x and true) =~ \"\"\"\n the following conditional expression will never succeed:\n\n x\n\n because it evaluates to:\n\n dynamic(false)\n \"\"\"\n end\n\n test \"or reports violations\" do\n assert typeerror!([x = 123], x or true) =~ \"\"\"\n the following conditional expression will always fail:\n\n x\n\n because it evaluates to:\n\n integer()\n \"\"\"\n\n assert typeerror!([x = true], x or true) =~ \"\"\"\n the following conditional expression will always succeed:\n\n x\n\n because it evaluates to:\n\n dynamic(true)\n \"\"\"\n\n assert typeerror!([x = false], x or true) =~ \"\"\"\n the following conditional expression will never succeed:\n\n x\n\n because it evaluates to:\n\n dynamic(false)\n \"\"\"\n end\n\n test \"|| reports violations\" do\n assert typeerror!([x = 123], x || true) =~ \"\"\"\n the right-hand side of || will never be executed:\n\n x || ...\n\n because the left-hand side always evaluates to:\n\n integer()\n\n \"\"\"\n\n assert typeerror!([x = 123], System.get_env(\"foo\") || x || true) =~ \"\"\"\n the right-hand side of || (shown as ... below) will never be executed:\n\n System.get_env(\"foo\") || x || ...\n\n because the left-hand side always evaluates to:\n\n dynamic(binary() or integer())\n\n \"\"\"\n\n assert typewarn!([x = false], x || true) |> elem(1) =~ \"\"\"\n the right-hand side of || will always execute:\n\n x\n\n because the left-hand side always evaluates to:\n\n dynamic(false)\n \"\"\"\n end\n end\n\n describe \"receive\" do\n test \"returns unions of all clauses\" do\n assert typecheck!(\n receive do\n :ok -> :ok\n :error -> :error\n after\n 0 -> :timeout\n end\n ) == atom([:ok, :error, :timeout])\n\n assert typedyn!(\n receive do\n :ok -> :ok\n :error -> :error\n after\n 0 -> :timeout\n end\n ) == dynamic(atom([:ok, :error, :timeout]))\n end\n\n test \"infers type for timeout\" do\n assert typecheck!(\n [x],\n receive do\n after\n x -> x\n end\n ) == dynamic(union(integer(), atom([:infinity])))\n end\n\n test \"resets branches\" do\n assert typecheck!(\n [x, timeout = :infinity],\n (\n receive do\n y when y > 0.5 -> x.foo\n _ -> x.bar()\n after\n timeout -> <<^x::integer>> = :crypto.strong_rand_bytes(1)\n end\n\n x\n )\n ) == dynamic()\n end\n\n test \"computes difference across clauses\" do\n assert typecheck!(\n receive do\n x when is_binary(x) -> :ok\n y -> {:other, y}\n end\n ) == union(atom([:ok]), dynamic(tuple([atom([:other]), negation(binary())])))\n end\n\n test \"warns on redundant clauses\" do\n assert typewarn!(\n receive do\n x when is_binary(x) -> x\n \"foo\" -> \"bar\"\n end\n )\n |> elem(1) == \"\"\"\n the following clause is redundant:\n\n \"foo\" ->\n\n previous clauses have already matched on the following types:\n\n binary()\n \"\"\"\n end\n\n test \"errors on bad timeout\" do\n assert typeerror!(\n [x = :timeout],\n receive do\n after\n x -> :ok\n end\n ) == ~l\"\"\"\n expected \"after\" timeout given to receive to be an integer:\n\n x\n\n but got type:\n\n dynamic(:timeout)\n\n where \"x\" was given the type:\n\n # type: dynamic(:timeout)\n # from: types_test.ex:LINE-5\n x = :timeout\n \"\"\"\n\n # Check for compatibility, not subtyping\n assert typeerror!(\n [<>],\n receive do\n after\n if(:rand.uniform(), do: x, else: y) -> :ok\n end\n ) =~ \"expected \"\n after\n \" timeout given to receive to be an integer\"\n end\n end\n\n describe \"try\" do\n test \"returns unions of all clauses\" do\n assert typecheck!(\n try do\n :do\n rescue\n _ -> :rescue\n catch\n :implicit_caught -> :caught1\n :throw, :explicit_caught -> :caught2\n after\n :not_used\n end\n ) == atom([:do, :caught1, :caught2, :rescue])\n\n assert typecheck!(\n [x],\n try do\n x\n rescue\n _ -> :rescue\n catch\n :implicit_caught -> :caught1\n :throw, :explicit_caught -> :caught2\n after\n :not_used\n else\n :match -> :else1\n _ -> :else2\n end\n ) == atom([:caught1, :caught2, :rescue, :else1, :else2])\n end\n\n test \"resets branches (except after)\" do\n assert typecheck!(\n [x],\n (\n try do\n <<^x::float>> = :crypto.strong_rand_bytes(8)\n rescue\n ArgumentError -> x.foo\n catch\n _, _ -> x.bar()\n after\n <<^x::integer>> = :crypto.strong_rand_bytes(8)\n end\n\n x\n )\n ) == dynamic(integer())\n end\n\n test \"catch: computes difference across clauses\" do\n assert typecheck!(\n try do\n flunk(\"whatever\")\n catch\n x when is_binary(x) -> :ok\n y -> {:other, y}\n end\n ) == union(atom([:ok]), dynamic(tuple([atom([:other]), negation(binary())])))\n end\n\n test \"catch: warns on redundant clauses\" do\n assert typewarn!(\n try do\n flunk(\"whatever\")\n catch\n x when is_binary(x) -> x\n \"foo\" -> \"bar\"\n end\n )\n |> elem(1) == \"\"\"\n the following clause is redundant:\n\n :throw, \"foo\" ->\n\n previous clauses have already matched on the following types:\n\n :throw, binary()\n \"\"\"\n end\n\n test \"else: computes difference across clauses\" do\n assert typecheck!(\n try do\n Process.get(:x)\n rescue\n _ -> :unused\n else\n x when is_binary(x) -> :ok\n y -> {:other, y}\n end\n ) ==\n union(atom([:ok, :unused]), dynamic(tuple([atom([:other]), negation(binary())])))\n end\n\n test \"else: warns on redundant clauses\" do\n assert typewarn!(\n try do\n Process.get(:x)\n rescue\n _ -> :unused\n else\n x when is_binary(x) -> x\n \"foo\" -> \"bar\"\n end\n )\n |> elem(1) == \"\"\"\n the following clause is redundant:\n\n \"foo\" ->\n\n previous clauses have already matched on the following types:\n\n binary()\n \"\"\"\n end\n\n test \"else: reports error from clause that will never match\" do\n assert typeerror!(\n [x],\n try do\n Atom.to_string(x)\n rescue\n _ -> :ok\n else\n :error -> :error\n x -> x\n end\n ) == ~l\"\"\"\n the following clause will never match:\n\n :error ->\n\n because it attempts to match on the result of:\n\n Atom.to_string(x)\n\n which has type:\n\n binary()\n \"\"\"\n end\n\n test \"rescue: defines unions of exceptions\" do\n assert typecheck!(\n try do\n raise \"oops\"\n rescue\n e in [RuntimeError, ArgumentError] ->\n e\n end\n ) ==\n dynamic(\n union(\n closed_map(\n __struct__: atom([ArgumentError]),\n __exception__: atom([true]),\n message: term()\n ),\n closed_map(\n __struct__: atom([RuntimeError]),\n __exception__: atom([true]),\n message: term()\n )\n )\n )\n end\n\n test \"rescue: defines an open map of two fields in anonymous rescue\" do\n assert typecheck!(\n try do\n raise \"oops\"\n rescue\n e -> e\n end\n ) ==\n open_map(\n __struct__: atom(),\n __exception__: atom([true])\n )\n end\n\n test \"rescue: generates custom traces\" do\n assert typeerror!(\n try do\n raise \"oops\"\n rescue\n e -> Integer.to_string(e)\n end\n )\n |> strip_ansi() == ~l\"\"\"\n incompatible types given to Integer.to_string/1:\n\n Integer.to_string(e)\n\n given types:\n\n %{..., __exception__: true, __struct__: atom()}\n\n but expected one of:\n\n integer()\n\n where \"e\" was given the type:\n\n # type: %{..., __exception__: true, __struct__: atom()}\n # from: types_test.ex\n rescue e\n\n hint: when you rescue without specifying exception names, the variable is assigned a type of a struct but all of its fields are unknown. If you are trying to access an exception's :message key, either specify the exception names or use `Exception.message/1`.\n \"\"\"\n end\n\n test \"rescue: errors on undefined exceptions\" do\n assert typeerror!(\n try do\n :ok\n rescue\n e in UnknownError -> e\n end\n ) ==\n \"struct UnknownError is undefined (module UnknownError is not available or is yet to be defined)\"\n\n assert typeerror!(\n try do\n :ok\n rescue\n e in Enumerable -> e\n end\n ) ==\n \"struct Enumerable is undefined (there is such module but it does not define a struct)\"\n end\n\n test \"rescue: matches on stacktrace\" do\n assert typeerror!(\n try do\n :ok\n rescue\n _ ->\n [{_, _, args_or_arity, _} | _] = __STACKTRACE__\n args_or_arity.fun()\n end\n ) =~ ~l\"\"\"\n expected a module (an atom) when invoking fun/0 in expression:\n\n args_or_arity.fun()\n\n where \"args_or_arity\" was given the type:\n\n # type: integer() or list(term())\n # from: types_test.ex:LINE-3\n [{_, _, args_or_arity, _} | _] = __STACKTRACE__\n \"\"\"\n end\n end\n\n describe \"cond\" do\n test \"always true\" do\n assert typecheck!(\n cond do\n true -> :ok\n end\n ) == atom([:ok])\n\n assert typecheck!(\n [x, y],\n cond do\n y -> :y\n x -> :x\n end\n ) == atom([:x, :y])\n\n assert typedyn!(\n [x, y],\n cond do\n y -> :y\n x -> :x\n end\n ) == dynamic(atom([:x, :y]))\n\n assert typewarn!(\n [x, y = {:foo, :bar}],\n cond do\n y -> :y\n x -> :x\n end\n ) ==\n {atom([:x, :y]),\n ~l\"\"\"\n this clause in cond will always match:\n\n y\n\n since it has type:\n\n dynamic({:foo, :bar})\n\n where \"y\" was given the type:\n\n # type: dynamic({:foo, :bar})\n # from: types_test.ex:LINE-7\n y = {:foo, :bar}\n \"\"\"}\n end\n\n test \"always false\" do\n assert typewarn!(\n [x, y = false],\n cond do\n y -> :y\n x -> :x\n end\n ) ==\n {atom([:x, :y]),\n ~l\"\"\"\n this clause in cond will never match:\n\n y\n\n since it has type:\n\n dynamic(false)\n\n where \"y\" was given the type:\n\n # type: dynamic(false)\n # from: types_test.ex:LINE-7\n y = false\n \"\"\"}\n end\n\n test \"resets branches\" do\n assert typecheck!(\n [x],\n (\n cond do\n :rand.uniform() > 0.5 -> x.foo\n true -> x.bar()\n end\n\n x\n )\n ) == dynamic()\n end\n end\n\n describe \"comprehensions\" do\n test \"bitstring generators\" do\n assert typeerror!([<>], for(<>, do: y)) ==\n ~l\"\"\"\n expected the right side of <- in a binary generator to be a binary (or bitstring):\n\n x\n\n but got type:\n\n integer()\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n <>\n\n #{hints(:inferred_bitstring_spec)}\n \"\"\"\n\n # Check for compatibility, not subtyping\n assert typeerror!(\n [<>],\n for(< 0.5, do: x, else: y)>>, do: i)\n ) =~\n ~l\"\"\"\n expected the right side of <- in a binary generator to be a binary (or bitstring):\n\n if :rand.uniform() > 0.5 do\n x\n else\n y\n end\n\n but got type:\n\n binary() or integer()\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-3\n <>\n\n where \"y\" was given the type:\n\n # type: binary()\n # from: types_test.ex:LINE-3\n <<..., y::binary>>\n \"\"\"\n end\n\n test \"infers bitstring generators\" do\n assert typecheck!(\n [x],\n (\n for <<_ <- x>>, do: :ok\n x\n )\n ) == dynamic(bitstring())\n end\n\n test \":into\" do\n assert typecheck!([binary], for(<>, do: x)) == list(integer())\n assert typecheck!([binary], for(<>, do: x, into: [])) == list(integer())\n assert typecheck!([binary], for(<>, do: <>, into: \"\")) |> equal?(binary())\n assert typecheck!([binary, other], for(<>, do: x, into: other)) == dynamic()\n\n assert typecheck!([enum], for(x <- enum, do: x)) ==\n union(list(dynamic()), empty_list())\n\n assert typecheck!([enum], for(x <- enum, do: x, into: [])) ==\n union(list(dynamic()), empty_list())\n\n assert typecheck!([enum], for(x <- enum, do: <>, into: \"\")) |> equal?(binary())\n assert typecheck!([enum, other], for(x <- enum, do: x, into: other)) == dynamic()\n\n assert typecheck!(\n [binary],\n (\n into = if :rand.uniform() > 0.5, do: [], else: \"0\"\n for(<>, do: x, into: into)\n )\n ) == union(bitstring(), list(term()))\n\n assert typecheck!(\n [binary, empty_list = []],\n (\n into = if :rand.uniform() > 0.5, do: empty_list, else: \"0\"\n for(<>, do: x, into: into)\n )\n ) == union(bitstring(), list(term()))\n end\n\n test \":into incompatibility\" do\n assert typeerror!([binary], for(<>, do: x, into: \"\")) =~ ~l\"\"\"\n expected the body of a for-comprehension with into: binary() (or bitstring()) to be a binary (or bitstring):\n\n x\n\n but got type:\n\n integer()\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE\n <>\n \"\"\"\n end\n\n test \":reduce checks\" do\n assert typecheck!(\n [list],\n for _ <- list, reduce: :ok do\n :ok -> 1\n _ -> 2.0\n end\n ) == union(atom([:ok]), union(integer(), float()))\n end\n\n test \":reduce inference\" do\n assert typecheck!(\n [list, x],\n (\n 123 =\n for _ <- list, reduce: x do\n x -> x\n end\n\n x\n )\n ) == dynamic(integer())\n end\n\n test \":reduce warns on redundant clauses\" do\n assert typewarn!(\n [list, x],\n for _ <- list, reduce: x do\n x when is_binary(x) -> x\n \"foo\" -> \"bar\"\n end\n )\n |> elem(1) == \"\"\"\n the following clause is redundant:\n\n \"foo\" ->\n\n previous clauses have already matched on the following types:\n\n binary()\n \"\"\"\n end\n end\n\n describe \"with\" do\n test \"warns on redundant clauses in else\" do\n assert typewarn!(\n [x],\n with false <- x do\n x\n else\n x when is_binary(x) -> x\n \"foo\" -> \"bar\"\n end\n )\n |> elem(1) == ~l\"\"\"\n the following clause is redundant:\n\n \"foo\" ->\n\n previous clauses have already matched on the following types:\n\n binary()\n \"\"\"\n end\n end\n\n describe \"info\" do\n test \"__info__/1\" do\n assert typecheck!(GenServer.__info__(:functions)) == list(tuple([atom(), integer()]))\n\n assert typewarn!(:string.__info__(:functions)) ==\n {dynamic(), \":string.__info__/1 is undefined or private\"}\n\n assert typecheck!([x], x.__info__(:functions)) == list(tuple([atom(), integer()]))\n\n assert typeerror!([x], x.__info__(:whatever)) |> strip_ansi() =~ \"\"\"\n incompatible types given to __info__/1:\n\n x.__info__(:whatever)\n\n given types:\n\n :whatever\n \"\"\"\n end\n\n test \"__info__/1 for struct information\" do\n assert typecheck!(GenServer.__info__(:struct)) == atom([nil])\n\n assert typecheck!(URI.__info__(:struct)) ==\n list(closed_map(default: if_set(term()), field: atom()))\n\n assert typecheck!([x], x.__info__(:struct)) ==\n list(closed_map(default: if_set(term()), field: atom())) |> union(atom([nil]))\n end\n\n test \"behaviour_info/1\" do\n assert typecheck!([x], x.behaviour_info(:callbacks)) == list(tuple([atom(), integer()]))\n\n assert typecheck!(GenServer.behaviour_info(:callbacks)) == list(tuple([atom(), integer()]))\n\n assert typewarn!(String.behaviour_info(:callbacks)) ==\n {dynamic(), \"String.behaviour_info/1 is undefined or private\"}\n end\n\n test \"module_info/1\" do\n assert typecheck!([x], x.module_info(:exports)) == list(tuple([atom(), integer()]))\n assert typecheck!(GenServer.module_info(:exports)) == list(tuple([atom(), integer()]))\n end\n\n test \"module_info/0\" do\n assert typecheck!([x], x.module_info()) |> subtype?(list(tuple([atom(), term()])))\n assert typecheck!(GenServer.module_info()) |> subtype?(list(tuple([atom(), term()])))\n end\n end\n\n describe \"regressions\" do\n test \"clauses within multi-module apply\" do\n assert typecheck!(\n [value, format, debug?],\n (\n module =\n case format do\n \".integer\" -> Integer\n \".float\" -> Float\n end\n\n value\n |> then(\n if debug? do\n &IO.inspect/1\n else\n &Function.identity/1\n end\n )\n |> module.to_string()\n )\n ) == dynamic() or binary()\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/helpers_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"type_helper.exs\", __DIR__)\n\ndefmodule Module.Types.HelpersTest do\n use ExUnit.Case, async: true\n import Module.Types.Helpers\n\n describe \"expr_to_string/1\" do\n test \"common expressions\" do\n assert expr_to_string({1, 2}) == \"{1, 2}\"\n assert expr_to_string(quote(do: Foo.bar(arg))) == \"Foo.bar(arg)\"\n end\n\n test \"rewrites\" do\n assert expr_to_string(quote(do: :erlang.band(a, b))) == \"Bitwise.band(a, b)\"\n assert expr_to_string(quote(do: :erlang.orelse(a, b))) == \"a or b\"\n assert expr_to_string(quote(do: :erlang.\"=:=\"(a, b))) == \"a === b\"\n assert expr_to_string(quote(do: :erlang.list_to_atom(a))) == \"List.to_atom(a)\"\n assert expr_to_string(quote(do: :maps.remove(a, b))) == \"Map.delete(b, a)\"\n assert expr_to_string(quote(do: :erlang.element(1, a))) == \"elem(a, 0)\"\n assert expr_to_string(quote(do: :erlang.element(:erlang.+(a, 1), b))) == \"elem(b, a)\"\n end\n\n test \"Kernel macros\" do\n case = Macro.expand(quote(do: if(condition, do: :this, else: :that)), __ENV__)\n assert expr_to_string(case) == \"if condition do\\n :this\\nelse\\n :that\\nend\"\n\n case = Macro.expand(quote(do: :this || :that), __ENV__)\n assert expr_to_string(case) == \":this || :that\"\n\n case = Macro.expand(quote(do: :this && :that), __ENV__)\n assert expr_to_string(case) == \":this && :that\"\n\n case = Macro.expand(quote(do: !expr), __ENV__)\n assert expr_to_string(case) == \"!expr\"\n end\n\n test \"case/try/receive/cond\" do\n assert expr_to_string(\n quote do\n case expr do\n :this -> :this!\n :that -> :that!\n end\n end\n ) == \"case expr do\\n ...\\nend\"\n\n assert expr_to_string(\n quote do\n try do\n :this -> :this!\n :that -> :that!\n rescue\n _ ->\n nil\n end\n end\n ) == \"try do\\n ...\\nend\"\n\n assert expr_to_string(\n quote do\n cond do\n :this -> :this!\n :that -> :that!\n end\n end\n ) == \"cond do\\n ...\\nend\"\n\n assert expr_to_string(\n quote do\n receive do\n :this -> :this!\n :that -> :that!\n end\n end\n ) == \"receive do\\n ...\\nend\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/infer_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"type_helper.exs\", __DIR__)\n\ndefmodule Module.Types.InferTest do\n use ExUnit.Case, async: true\n\n import Module.Types.Descr\n\n defmacro infer(config, do: block) do\n quote do\n runtime_infer(unquote(config).test, unquote(Macro.escape(block)))\n end\n end\n\n defp runtime_infer(module, block) do\n {{:module, _, binary, _}, []} =\n Code.eval_quoted(\n quote do\n defmodule unquote(module), do: unquote(block)\n end,\n []\n )\n\n version = :elixir_erl.checker_version()\n {:ok, {_, [{~c\"ExCk\", chunk}]}} = :beam_lib.chunks(binary, [~c\"ExCk\"])\n {^version, data} = :erlang.binary_to_term(chunk)\n for {fun, %{sig: sig}} <- data.exports, into: %{}, do: {fun, sig}\n end\n\n test \"infer types from patterns\", config do\n types =\n infer config do\n def fun1(%y{}, %x{}, x = y, x = Point), do: :ok\n def fun2(%x{}, %y{}, x = y, x = Point), do: :ok\n def fun3(%y{}, %x{}, x = y, y = Point), do: :ok\n def fun4(%x{}, %y{}, x = y, y = Point), do: :ok\n end\n\n args = [\n open_map(__struct__: atom([Point])),\n open_map(__struct__: atom([Point])),\n atom([Point]),\n atom([Point])\n ]\n\n assert types[{:fun1, 4}] == {:infer, nil, [{args, atom([:ok])}]}\n assert types[{:fun2, 4}] == {:infer, nil, [{args, atom([:ok])}]}\n assert types[{:fun3, 4}] == {:infer, nil, [{args, atom([:ok])}]}\n assert types[{:fun4, 4}] == {:infer, nil, [{args, atom([:ok])}]}\n end\n\n test \"infer types from expressions\", config do\n types =\n infer config do\n def fun(x) do\n x.foo + x.bar\n end\n end\n\n number = union(integer(), float())\n\n assert types[{:fun, 1}] ==\n {:infer, nil, [{[open_map(foo: number, bar: number)], dynamic(number)}]}\n end\n\n test \"infer with Elixir built-in\", config do\n types =\n infer config do\n def parse(string), do: Integer.parse(string)\n end\n\n assert types[{:parse, 1}] ==\n {:infer, nil,\n [{[term()], dynamic(union(atom([:error]), tuple([integer(), binary()])))}]}\n end\n\n test \"merges patterns\", config do\n types =\n infer config do\n def fun(:ok), do: :one\n def fun(\"two\"), do: :two\n def fun(\"three\"), do: :three\n def fun(\"four\"), do: :four\n def fun(:error), do: :five\n end\n\n assert types[{:fun, 1}] ==\n {:infer, [union(atom([:ok, :error]), binary())],\n [\n {[atom([:ok])], atom([:one])},\n {[binary()], atom([:two, :three, :four])},\n {[atom([:error])], atom([:five])}\n ]}\n end\n\n test \"infers return types from private functions\", config do\n types =\n infer config do\n def pub(x), do: priv(x)\n defp priv(:ok), do: :ok\n defp priv(:error), do: :error\n end\n\n assert types[{:pub, 1}] ==\n {:infer, nil, [{[atom([:ok, :error])], dynamic(atom([:ok, :error]))}]}\n\n assert types[{:priv, 1}] == nil\n end\n\n test \"infers return types from super functions\", config do\n types =\n infer config do\n def pub(:ok), do: :ok\n def pub(:error), do: :error\n defoverridable pub: 1\n def pub(x), do: super(x)\n end\n\n assert types[{:pub, 1}] ==\n {:infer, nil, [{[atom([:ok, :error])], dynamic(atom([:ok, :error]))}]}\n end\n\n test \"infers return types even with loops\", config do\n types =\n infer config do\n def pub(x), do: pub(x)\n end\n\n assert types[{:pub, 1}] == {:infer, nil, [{[term()], dynamic()}]}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/integration_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"type_helper.exs\", __DIR__)\n\ndefmodule Module.Types.IntegrationTest do\n use ExUnit.Case\n\n import ExUnit.CaptureIO\n import Module.Types.Descr\n\n defp builtin_protocols do\n [\n Collectable,\n Enumerable,\n IEx.Info,\n Inspect,\n JSON.Encoder,\n List.Chars,\n String.Chars\n ]\n end\n\n test \"built-in protocols\" do\n builtin_protocols =\n for app <- ~w[eex elixir ex_unit iex logger mix]a,\n Application.ensure_loaded(app),\n module <- Application.spec(app, :modules),\n Code.ensure_loaded(module),\n function_exported?(module, :__protocol__, 1),\n do: module\n\n # If this test fails, update:\n # * lib/elixir/scripts/elixir_docs.ex\n assert Enum.sort(builtin_protocols) == builtin_protocols()\n end\n\n setup_all do\n Application.put_env(:elixir, :ansi_enabled, false)\n\n on_exit(fn ->\n Application.put_env(:elixir, :ansi_enabled, true)\n end)\n end\n\n describe \"ExCk chunk\" do\n test \"writes exports\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n defp a, do: :ok\n defmacrop b, do: a()\n def c, do: b()\n defmacro d, do: b()\n @deprecated \"oops\"\n def e, do: :ok\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n @callback f() :: :ok\n end\n \"\"\",\n \"c.ex\" => \"\"\"\n defmodule C do\n @macrocallback g() :: :ok\n end\n \"\"\"\n }\n\n modules = compile_modules(files)\n\n assert [\n {{:c, 0}, %{}},\n {{:e, 0}, %{deprecated: \"oops\", sig: {:infer, _, _}}}\n ] = read_chunk(modules[A]).exports\n\n assert read_chunk(modules[B]).exports == [\n {{:behaviour_info, 1}, %{sig: :none}}\n ]\n\n assert read_chunk(modules[C]).exports == [\n {{:behaviour_info, 1}, %{sig: :none}}\n ]\n end\n\n test \"writes exports with inferred map types\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n defstruct [:x, :y, :z]\n\n def struct_create_with_atom_keys(x) do\n infer(y = %A{x: x})\n {x, y}\n end\n\n def map_create_with_atom_keys(x) do\n infer(%{__struct__: A, x: x, y: nil, z: nil})\n x\n end\n\n def map_update_with_atom_keys(x) do\n infer(%{x | y: nil})\n x\n end\n\n def map_update_with_unknown_keys(x, key) do\n infer(%{x | key => 123})\n x\n end\n\n defp infer(%A{x: <<_::binary>>, y: nil}) do\n :ok\n end\n end\n \"\"\"\n }\n\n modules = compile_modules(files)\n exports = read_chunk(modules[A]).exports |> Map.new()\n\n return = fn name, arity ->\n pair = {name, arity}\n %{^pair => %{sig: {:infer, nil, [{_, return}]}}} = exports\n return\n end\n\n assert return.(:struct_create_with_atom_keys, 1) ==\n dynamic(\n tuple([\n binary(),\n closed_map(\n __struct__: atom([A]),\n x: binary(),\n y: atom([nil]),\n z: atom([nil])\n )\n ])\n )\n\n assert return.(:map_create_with_atom_keys, 1) == dynamic(binary())\n\n assert return.(:map_update_with_atom_keys, 1) ==\n dynamic(\n closed_map(\n __struct__: atom([A]),\n x: binary(),\n y: atom([nil]),\n z: term()\n )\n )\n\n assert return.(:map_update_with_unknown_keys, 2) ==\n dynamic(\n closed_map(\n __struct__: atom([A]),\n x: binary(),\n y: atom([nil]),\n z: term()\n )\n )\n end\n\n test \"writes exports with inferred function types\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def captured, do: &to_capture/1\n defp to_capture(<<\"ok\">>), do: :ok\n defp to_capture(<<\"error\">>), do: :error\n defp to_capture([_ | _]), do: :list\n end\n \"\"\"\n }\n\n modules = compile_modules(files)\n exports = read_chunk(modules[A]).exports |> Map.new()\n\n return = fn name, arity ->\n pair = {name, arity}\n %{^pair => %{sig: {:infer, nil, [{_, return}]}}} = exports\n return\n end\n\n assert return.(:captured, 0)\n |> equal?(\n fun_from_non_overlapping_clauses([\n {[binary()], dynamic(atom([:ok, :error]))},\n {[non_empty_list(term(), term())], dynamic(atom([:list]))}\n ])\n )\n end\n\n test \"writes exports for implementations\" do\n files = %{\n \"pi.ex\" => \"\"\"\n defprotocol Itself do\n @fallback_to_any true\n def itself(data)\n end\n\n defimpl Itself,\n for: [\n Atom,\n BitString,\n Float,\n Function,\n Integer,\n List,\n Map,\n Port,\n PID,\n Reference,\n Tuple,\n Any,\n Range,\n Unknown\n ] do\n def itself(data), do: data\n def this_wont_warn(:ok), do: :ok\n end\n \"\"\"\n }\n\n {modules, stderr} = with_io(:stderr, fn -> compile_modules(files) end)\n\n assert stderr =~\n \"you are implementing a protocol for Unknown but said module is not available\"\n\n refute stderr =~ \"this_wont_warn\"\n\n itself_arg = fn mod ->\n {_, %{sig: {:infer, nil, [{[domain], return}]}}} =\n List.keyfind(read_chunk(modules[mod]).exports, {:itself, 1}, 0)\n\n assert equal?(dynamic(domain), return)\n return\n end\n\n assert itself_arg.(Itself.Atom) == dynamic(atom())\n assert itself_arg.(Itself.BitString) == dynamic(bitstring())\n assert itself_arg.(Itself.Float) == dynamic(float())\n assert itself_arg.(Itself.Function) == dynamic(fun())\n assert itself_arg.(Itself.Integer) == dynamic(integer())\n\n assert itself_arg.(Itself.List) ==\n dynamic(union(empty_list(), non_empty_list(term(), term())))\n\n assert itself_arg.(Itself.Map) == dynamic(open_map(__struct__: if_set(negation(atom()))))\n assert itself_arg.(Itself.Port) == dynamic(port())\n assert itself_arg.(Itself.PID) == dynamic(pid())\n assert itself_arg.(Itself.Reference) == dynamic(reference())\n assert itself_arg.(Itself.Tuple) == dynamic(tuple())\n assert itself_arg.(Itself.Any) == dynamic(term())\n\n assert itself_arg.(Itself.Range) ==\n dynamic(\n closed_map(__struct__: atom([Range]), first: term(), last: term(), step: term())\n )\n\n assert itself_arg.(Itself.Unknown) == dynamic(open_map(__struct__: atom([Unknown])))\n end\n end\n\n describe \"type checking\" do\n test \"inferred remote calls\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def fun(:ok), do: :doki\n def fun(:error), do: :bad\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n def badarg do\n A.fun(:unknown)\n end\n\n def badmatch do\n :doki = A.fun(:error)\n end\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: incompatible types given to A.fun/1:\n\n A.fun(:unknown)\n \"\"\",\n \"\"\"\n but expected one of:\n\n #1\n :ok\n\n #2\n :error\n \"\"\",\n \"\"\"\n warning: the following pattern will never match:\n\n :doki = A.fun(:error)\n\n because the right-hand side has type:\n\n dynamic(:bad)\n \"\"\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"redundant clauses\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def foo(x, _) when is_integer(x), do: :one\n def foo(_, y) when is_integer(y), do: :two\n def foo(x, y) when is_integer(x) and is_integer(y), do: :three\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: the following clause is redundant:\n\n def foo(x, y) when is_integer(x) and is_integer(y)\n\n it has type:\n\n integer(), integer()\n\n previous clauses have already matched on the following types:\n\n term(), integer()\n integer(), term()\n\n │\n 4 │ def foo(x, y) when is_integer(x) and is_integer(y), do: :three\n │ ~\n │\n └─ a.ex:4:7: A.foo/2\n \"\"\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"mismatched locals\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def error(), do: private(raise \"oops\")\n def public(x), do: private(List.to_tuple(x))\n defp private(:ok), do: nil\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: incompatible types given to private/1:\n\n private(raise RuntimeError.exception(\"oops\"))\n\n \"\"\",\n \"the 1st argument is empty (often represented as none())\",\n \"\"\"\n type warning found at:\n │\n 2 │ def error(), do: private(raise \"oops\")\n │ ~\n │\n └─ a.ex:2:20: A.error/0\n \"\"\",\n \"\"\"\n warning: incompatible types given to private/1:\n\n private(List.to_tuple(x))\n \"\"\",\n \"\"\"\n type warning found at:\n │\n 3 │ def public(x), do: private(List.to_tuple(x))\n │ ~\n │\n └─ a.ex:3:22: A.public/1\n \"\"\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"unused private clauses\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def public(x) do\n private(List.to_tuple(x))\n end\n\n defp private(nil), do: nil\n defp private(\"foo\"), do: \"foo\"\n defp private({:ok, ok}), do: ok\n defp private({:error, error}), do: error\n defp private(\"bar\"), do: \"bar\"\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: this clause of defp private/1 is never used (or it will always fail when invoked)\n │\n 6 │ defp private(nil), do: nil\n │ ~\n │\n └─ a.ex:6:8: A.private/1\n \"\"\",\n \"\"\"\n warning: this clause of defp private/1 is never used (or it will always fail when invoked)\n │\n 7 │ defp private(\"foo\"), do: \"foo\"\n │ ~\n │\n └─ a.ex:7:8: A.private/1\n \"\"\",\n \"\"\"\n warning: this clause of defp private/1 is never used (or it will always fail when invoked)\n │\n 10 │ defp private(\"bar\"), do: \"bar\"\n │ ~\n │\n └─ a.ex:10:8: A.private/1\n \"\"\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"unused overridable private clauses\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n use B\n def public(x), do: private(x)\n defp private(x), do: super(List.to_tuple(x))\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n defmacro __using__(_) do\n quote do\n defp private({:ok, ok}), do: ok\n defp private(:error), do: :error\n defoverridable private: 1\n end\n end\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"unused private clauses without warnings\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n use B\n\n # Not all clauses are invoked, but do not warn since they are generated\n def public1(x), do: generated(List.to_tuple(x))\n\n # Avoid false positives caused by inference\n def public2(x), do: (:ok = raising_private(x))\n\n defp raising_private(true), do: :ok\n defp raising_private(false), do: raise \"oops\"\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n defmacro __using__(_) do\n quote generated: true do\n defp generated({:ok, ok}), do: ok\n defp generated(:error), do: :error\n end\n end\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"mismatched implementation\" do\n files = %{\n \"a.ex\" => \"\"\"\n defprotocol Itself do\n def itself(data)\n end\n\n defimpl Itself, for: Range do\n def itself(nil), do: nil\n def itself(%Range{} = range), do: range\n def itself(%Range{}), do: raise \"oops\"\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: the 1st pattern in clause will never match:\n\n nil\n\n because it is expected to receive type:\n\n dynamic(%Range{})\n\n hint: defimpl for Range requires its callbacks to match exclusively on %Range{}\n\n type warning found at:\n │\n 6 │ def itself(nil), do: nil\n │ ~~~~~~~~~~~~~~~~~~~~~~~~\n │\n └─ a.ex:6: Itself.Range.itself/1\n \"\"\",\n \"\"\"\n warning: the following clause is redundant:\n\n def itself(%Range{})\n\n it has type:\n\n %Range{}\n\n previous clauses have already matched on the following types:\n\n %Range{}\n\n │\n 8 │ def itself(%Range{}), do: raise \"oops\"\n │ ~\n │\n └─ a.ex:8:7: Itself.Range.itself/1\n \"\"\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n @tag :require_ast\n test \"no implementation\" do\n files = %{\n \"a.ex\" => \"\"\"\n defprotocol NoImplProtocol do\n def callback(data)\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule NoImplProtocol.Caller do\n def run do\n NoImplProtocol.callback(:hello)\n end\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: incompatible types given to NoImplProtocol.callback/1:\n\n NoImplProtocol.callback(:hello)\n\n given types:\n\n -:hello-\n\n but the NoImplProtocol protocol was not yet implemented for any type and therefore will always fail.\n\n This message will disappear once you define an implementation. If the protocol is part of a library, you may define a dummy implementation for development/test.\n\n type warning found at:\n │\n 3 │ NoImplProtocol.callback(:hello)\n │ ~\n │\n └─ b.ex:3:20: NoImplProtocol.Caller.run/0\n \"\"\"\n ]\n\n assert_warnings(files, warnings, consolidate_protocols: true)\n end\n\n @tag :require_ast\n test \"String.Chars protocol dispatch\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule FooBar do\n def example1(_.._//_ = data), do: to_string(data)\n def example2(_.._//_ = data), do: \"hello \\#{data} world\"\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: incompatible types given to String.Chars.to_string/1:\n\n to_string(data)\n\n given types:\n\n -dynamic(%Range{})-\n\n but expected a type that implements the String.Chars protocol.\n You either passed the wrong value or you must:\n\n 1. convert the given value to a string explicitly\n (use inspect/1 if you want to convert any data structure to a string)\n 2. implement the String.Chars protocol\n\n where \"data\" was given the type:\n\n # type: dynamic(%Range{})\n # from: a.ex:2:24\n _.._//_ = data\n\n hint: the String.Chars protocol is implemented for the following types:\n\n dynamic(\n %Date{} or %DateTime{} or %NaiveDateTime{} or %Time{} or %URI{} or %Version{} or\n %Version.Requirement{}\n ) or atom() or bitstring() or empty_list() or float() or integer() or\n non_empty_list(term(), term())\n \"\"\",\n \"\"\"\n warning: incompatible value given to string interpolation:\n\n data\n\n it has type:\n\n -dynamic(%Range{})-\n\n but expected a type that implements the String.Chars protocol.\n You either passed the wrong value or you must:\n\n 1. convert the given value to a string explicitly\n (use inspect/1 if you want to convert any data structure to a string)\n 2. implement the String.Chars protocol\n\n where \"data\" was given the type:\n\n # type: dynamic(%Range{})\n # from: a.ex:3:24\n _.._//_ = data\n \"\"\"\n ]\n\n assert_warnings(files, warnings, consolidate_protocols: true)\n end\n\n @tag :require_ast\n test \"Enumerable protocol dispatch\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule FooBar do\n def example1(%Date{} = date), do: for(x <- date, do: x)\n def example2(), do: for(i <- [1, 2, 3], into: Date.utc_today(), do: i * 2)\n def example3(), do: for(i <- [1, 2, 3], into: 456, do: i * 2)\n end\n \"\"\"\n }\n\n warnings = [\n \"\"\"\n warning: incompatible value given to for-comprehension:\n\n x <- date\n\n it has type:\n\n -dynamic(%Date{})-\n\n but expected a type that implements the Enumerable protocol.\n You either passed the wrong value or you must:\n\n 1. convert the given value to an Enumerable explicitly\n 2. implement the Enumerable protocol\n\n where \"date\" was given the type:\n\n # type: dynamic(%Date{})\n # from: a.ex:2:24\n %Date{} = date\n\n hint: the Enumerable protocol is implemented for the following types:\n\n dynamic(\n %Date.Range{} or %File.Stream{} or %GenEvent.Stream{} or %HashDict{} or %HashSet{} or\n %IO.Stream{} or %MapSet{} or %Range{} or %Stream{}\n ) or empty_list() or fun() or non_empty_list(term(), term()) or non_struct_map()\n \"\"\",\n \"\"\"\n warning: incompatible value given to :into option in for-comprehension:\n\n into: Date.utc_today()\n\n it has type:\n\n -dynamic(%Date{year: integer(), month: integer(), day: integer(), calendar: Calendar.ISO})-\n\n but expected a type that implements the Collectable protocol.\n You either passed the wrong value or you forgot to implement the protocol.\n\n hint: the Collectable protocol is implemented for the following types:\n\n dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or bitstring() or\n empty_list() or non_empty_list(term(), term()) or non_struct_map()\n \"\"\",\n \"\"\"\n warning: incompatible value given to :into option in for-comprehension:\n\n into: 456\n\n it has type:\n\n -integer()-\n\n but expected a type that implements the Collectable protocol.\n You either passed the wrong value or you forgot to implement the protocol.\n\n hint: the Collectable protocol is implemented for the following types:\n\n dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or bitstring() or\n empty_list() or non_empty_list(term(), term()) or non_struct_map()\n \"\"\"\n ]\n\n assert_warnings(files, warnings, consolidate_protocols: true)\n end\n\n test \"incompatible default argument\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def ok(x = :ok \\\\\\\\ nil) do\n x\n end\n end\n \"\"\"\n }\n\n warnings = [\n ~S\"\"\"\n warning: incompatible types given as default arguments to ok/1:\n\n -nil-\n\n but expected one of:\n\n :ok\n\n type warning found at:\n │\n 2 │ def ok(x = :ok \\\\ nil) do\n │ ~\n │\n └─ a.ex:2:18: A.ok/0\n \"\"\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"returns diagnostics with source and file\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @file \"generated.ex\"\n def fun(arg) do\n :ok = List.to_tuple(arg)\n end\n end\n \"\"\"\n }\n\n {_modules, warnings} = with_compile_warnings(files)\n\n assert [\n %{\n message: \"the following pattern will never match\" <> _,\n file: file,\n source: source\n }\n ] = warnings.runtime_warnings\n\n assert String.ends_with?(source, \"a.ex\")\n assert Path.type(source) == :absolute\n assert String.ends_with?(file, \"generated.ex\")\n assert Path.type(file) == :absolute\n after\n purge(A)\n end\n\n @tag :require_ast\n test \"regressions\" do\n files = %{\n # do not emit false positives from defguard\n \"a.ex\" => \"\"\"\n defmodule A do\n defguard is_non_nil_arity_function(fun, arity)\n when arity != nil and is_function(fun, arity)\n\n def check(fun, args) do\n is_non_nil_arity_function(fun, length(args))\n end\n end\n \"\"\",\n # do not parse binary segments as variables\n \"b.ex\" => \"\"\"\n defmodule B do\n def decode(byte) do\n case byte do\n enc when enc in [<<0x00>>, <<0x01>>] -> :ok\n end\n end\n end\n \"\"\",\n # String.Chars protocol dispatch on improper lists\n \"c.ex\" => \"\"\"\n defmodule C do\n def example, do: to_string([?a, ?b | \"!\"])\n end\n \"\"\"\n }\n\n assert_no_warnings(files, consolidate_protocols: true)\n end\n end\n\n describe \"performance regressions\" do\n test \"redundant clause checking on structs with many fields\" do\n files = %{\n \"big_struct.ex\" => \"\"\"\n defmodule BigStruct do\n defstruct [:f1, :f2, :f3, :f4, :f5, :f6, :f7, :f8, :f9, :f10,\n :f11, :f12, :f13, :f14, :f15, :f16, :f17, :f18, :f19, :f20,\n :f21, :f22, :f23, :f24, :f25, :f26, :f27, :f28, :f29, :f30,\n :f31, :f32, :f33, :value, :schema]\n def cast(%__MODULE__{value: nil, schema: %{k1: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k2: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k3: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k4: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k5: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k6: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k7: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k8: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k9: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k10: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k11: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k12: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k13: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k14: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k15: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k16: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k17: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k18: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k19: _}}), do: :ok\n def cast(%__MODULE__{value: nil, schema: %{k20: _}}), do: :ok\n # This different clause avoids optimizations from kick in many cases\n def cast(%__MODULE__{schema: %{target_key: x}}), do: x\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"redundant clause checking with nested open maps\" do\n files = %{\n \"nested_maps.ex\" => \"\"\"\n defmodule NestedMapsIssue do\n def foo(%{a: nil, b: %{c: true}}), do: :ok\n def foo(%{a: nil, b: %{c: false}}), do: :ok\n def foo(%{a: nil, b: %{d: x}}) when is_list(x), do: :ok\n def foo(%{a: nil, b: %{e: x}}) when is_list(x), do: :ok\n def foo(%{a: nil, b: %{f: x}}) when is_list(x), do: :ok\n def foo(%{a: nil}), do: :ok\n def foo(%{b: %{g: :one, h: x}}) when is_map(x), do: :ok\n def foo(%{b: %{g: _, i: x}}) when is_list(x), do: :ok\n def foo(%{b: %{g: _, j: x}}) when is_list(x), do: :ok\n def foo(%{b: %{g: _, k: x}}) when is_list(x), do: :ok\n def foo(%{b: %{g: :one}}), do: :ok\n def foo(%{b: %{g: :two}}), do: :ok\n def foo(%{b: %{g: :three}}), do: :ok\n def foo(%{b: %{g: :four}}), do: :ok\n def foo(%{b: %{g: :five}}), do: :ok\n def foo(%{b: %{g: :six}}), do: :ok\n def foo(%{b: %{l: x}}) when is_list(x), do: :ok\n def foo(%{b: %{m: x}}) when is_list(x), do: :ok\n def foo(%{b: %{n: x}}) when is_list(x), do: :ok\n def foo(%{b: %{o: x}}) when is_list(x), do: :ok\n def foo(%{b: %{p: x, q: y}}) when is_number(x) and is_number(y), do: :ok\n def foo(%{b: %{p: x}}) when is_number(x), do: :ok\n def foo(%{b: %{q: x}}) when is_number(x), do: :ok\n def foo(%{b: %{r: x}}) when is_integer(x), do: :ok\n def foo(%{b: %{s: x}}) when is_integer(x), do: :ok\n def foo(%{b: %{t: x}}) when is_binary(x), do: :ok\n def foo(%{b: %{u: x}}) when is_atom(x), do: :ok\n def foo(%{b: %{v: x}}) when is_integer(x), do: :ok\n def foo(%{b: %{w: x}}) when is_integer(x), do: :ok\n def foo(_), do: :ok\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"redundant clause checking of mixed open and closed maps\" do\n files = %{\n \"mixed_open_closed_maps.ex\" => \"\"\"\n defmodule MixedOpenClosedMaps do\n defmodule S1, do: defstruct([:name])\n defmodule S2, do: defstruct([:name])\n defmodule S3, do: defstruct([:name])\n defmodule S4, do: defstruct([:name])\n defmodule S5, do: defstruct([:name])\n defmodule S6, do: defstruct([:name])\n defmodule S7, do: defstruct([:name])\n defmodule S8, do: defstruct([:name])\n defmodule S9, do: defstruct([:name])\n defmodule S10, do: defstruct([:name])\n defmodule S11, do: defstruct([:name])\n defmodule S12, do: defstruct([:name])\n defmodule S13, do: defstruct([:name])\n defmodule S14, do: defstruct([:name])\n defmodule S15, do: defstruct([:name])\n defmodule S16, do: defstruct([:name])\n defmodule S17, do: defstruct([:name])\n defmodule S18, do: defstruct([:name])\n\n defmodule SValue do\n defstruct [:value]\n end\n\n def render(%S1{}), do: :ok\n def render(%S2{}), do: :ok\n def render(%S3{}), do: :ok\n def render(%S4{}), do: :ok\n def render(%S5{}), do: :ok\n def render(%S6{}), do: :ok\n def render(%S7{}), do: :ok\n def render(%S8{}), do: :ok\n def render(%S9{}), do: :ok\n def render(%S10{}), do: :ok\n def render(%S11{}), do: :ok\n def render(%S12{}), do: :ok\n def render(%S13{}), do: :ok\n def render(%S14{}), do: :ok\n def render(%S15{}), do: :ok\n def render(%S16{}), do: :ok\n def render(%S17{}), do: :ok\n def render(%S18{}), do: :ok\n # Having the closed map and the struct overlap on a key is important\n def render(%SValue{}), do: :ok\n def render(%{value: value}), do: value\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"redundant clause checking of open maps with distinct keys\" do\n files = %{\n \"large_head.ex\" => \"\"\"\n defmodule LargeHead do\n def id(%{node_id: id}) when is_binary(id), do: id\n def id(%{node: %{id: id}}) when is_binary(id), do: id\n def id(%{cluster: %{node_id: id}}) when is_binary(id), do: id\n def id(%{graph: %{node_id: id}}) when is_binary(id), do: id\n def id(%{vertex: %{node_id: id}}) when is_binary(id), do: id\n def id(%{collection: %{graph_id: id} = collection}) when is_binary(id), do: id(collection)\n def id(%{element: %{} = element}), do: id(element)\n def id(%{cluster_id: id}) when is_binary(id), do: id\n def id(%{region_id: id}) when is_binary(id), do: id\n def id(%{graph_id: id}) when is_binary(id), do: id\n def id(%{vertex_id: id}) when is_binary(id), do: id\n def id(%{path_id: id}) when is_binary(id), do: id\n def id(%{tree_id: id}) when is_binary(id), do: id\n def id(%{collection_id: id}) when is_binary(id), do: id\n def id(%{segment_id: id}) when is_binary(id), do: id\n def id(%{edge_id: id}) when is_binary(id), do: id\n def nested_access(%{graph: graph} = collection) do\n <<_::binary>> = id(graph)\n if collection.graph.cluster_id do\n {graph.id, graph.node_id, collection.graph.cluster_id}\n end\n end\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"pretty printing large tuples with negations\" do\n files = %{\n \"large_tuples.ex\" => \"\"\"\n defmodule LargeTuplesWithNegations do\n @abc [:a, :b]\n defguard g1(t) when tuple_size(t) < 10\n defguard g2(t, i) when elem(t, i) in @abc\n\n def main() do\n foo(Bar)\n end\n\n def foo(t) when g1(t) and g2(t, 0) and g2(t, 1) and g2(t, 2),\n do: {bar(elem(t, 3)), bar(elem(t, 4))}\n\n def foo(t) when g1(t) and g2(t, 1) and g2(t, 2) and g2(t, 3),\n do: {bar(elem(t, 4)), bar(elem(t, 5))}\n\n def foo(t) when g1(t) and g2(t, 2) and g2(t, 3) and g2(t, 4),\n do: {bar(elem(t, 5)), bar(elem(t, 6))}\n\n def foo(t) when g1(t) and g2(t, 3) and g2(t, 4) and g2(t, 5),\n do: {bar(elem(t, 6)), bar(elem(t, 0))}\n\n def foo(t) when g1(t) and g2(t, 4) and g2(t, 5) and g2(t, 6),\n do: {bar(elem(t, 0)), bar(elem(t, 1))}\n\n def foo(t) when g1(t) and g2(t, 5) and g2(t, 6) and g2(t, 0),\n do: {bar(elem(t, 1)), bar(elem(t, 2))}\n\n def foo(t) when g1(t) and g2(t, 6) and g2(t, 0) and g2(t, 1),\n do: {bar(elem(t, 2)), bar(elem(t, 3))}\n\n def bar(t) when g1(t) and g2(t, 0) and g2(t, 1) and g2(t, 2),\n do: {baz(elem(t, 3)), baz(elem(t, 4))}\n\n def bar(t) when g1(t) and g2(t, 1) and g2(t, 2) and g2(t, 3),\n do: {baz(elem(t, 4)), baz(elem(t, 5))}\n\n def bar(t) when g1(t) and g2(t, 2) and g2(t, 3) and g2(t, 4),\n do: {baz(elem(t, 5)), baz(elem(t, 6))}\n\n def bar(t) when g1(t) and g2(t, 3) and g2(t, 4) and g2(t, 5),\n do: {baz(elem(t, 6)), baz(elem(t, 0))}\n\n def bar(t) when g1(t) and g2(t, 4) and g2(t, 5) and g2(t, 6),\n do: {baz(elem(t, 0)), baz(elem(t, 1))}\n\n def bar(t) when g1(t) and g2(t, 5) and g2(t, 6) and g2(t, 0),\n do: {baz(elem(t, 1)), baz(elem(t, 2))}\n\n def bar(t) when g1(t) and g2(t, 6) and g2(t, 0) and g2(t, 1),\n do: {baz(elem(t, 2)), baz(elem(t, 3))}\n\n def baz(t) when g1(t) and elem(t, 0) in @abc and elem(t, 1) in @abc and elem(t, 2) in @abc,\n do: 0\n\n def baz(t) when g1(t) and elem(t, 1) in @abc and elem(t, 2) in @abc and elem(t, 3) in @abc,\n do: 1\n\n def baz(t) when g1(t) and elem(t, 2) in @abc and elem(t, 3) in @abc and elem(t, 4) in @abc,\n do: 2\n\n def baz(t) when g1(t) and elem(t, 3) in @abc and elem(t, 4) in @abc and elem(t, 5) in @abc,\n do: 3\n\n def baz(t) when g1(t) and elem(t, 4) in @abc and elem(t, 5) in @abc and elem(t, 6) in @abc,\n do: 4\n\n def baz(t) when g1(t) and elem(t, 5) in @abc and elem(t, 6) in @abc and elem(t, 0) in @abc,\n do: 5\n\n def baz(t) when g1(t) and elem(t, 6) in @abc and elem(t, 0) in @abc and elem(t, 1) in @abc,\n do: 6\n end\n \"\"\"\n }\n\n assert_warnings(files, [\"incompatible types given to foo/1\"])\n end\n end\n\n describe \"undefined warnings\" do\n test \"handles Erlang modules\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: :not_a_module.no_module()\n def b, do: :lists.no_func()\n end\n \"\"\"\n }\n\n warnings = [\n \":not_a_module.no_module/0 is undefined (module :not_a_module is not available or is yet to be defined)\",\n \"a.ex:2:28: A.a/0\",\n \":lists.no_func/0 is undefined or private\",\n \"a.ex:3:21: A.b/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"handles built in functions\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: Kernel.module_info()\n def b, do: Kernel.module_info(:functions)\n def c, do: Kernel.__info__(:functions)\n def d, do: GenServer.behaviour_info(:callbacks)\n def e, do: Kernel.behaviour_info(:callbacks)\n end\n \"\"\"\n }\n\n warnings = [\n \"Kernel.behaviour_info/1 is undefined or private\",\n \"a.ex:6:21: A.e/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"handles module body conditionals\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n if function_exported?(List, :flatten, 1) do\n List.flatten([1, 2, 3])\n else\n List.old_flatten([1, 2, 3])\n end\n\n if function_exported?(List, :flatten, 1) do\n def flatten(arg), do: List.flatten(arg)\n else\n def flatten(arg), do: List.old_flatten(arg)\n end\n\n if function_exported?(List, :flatten, 1) do\n def flatten2(arg), do: List.old_flatten(arg)\n else\n def flatten2(arg), do: List.flatten(arg)\n end\n end\n \"\"\"\n }\n\n warnings = [\n \"List.old_flatten/1 is undefined or private. Did you mean:\",\n \"* flatten/1\",\n \"* flatten/2\",\n \"a.ex:15:33: A.flatten2/1\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports missing functions\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: A.no_func()\n def b, do: A.a()\n\n @file \"external_source.ex\"\n def c, do: &A.no_func/1\n end\n \"\"\"\n }\n\n warnings = [\n \"A.no_func/0 is undefined or private\",\n \"a.ex:2:16: A.a/0\",\n \"A.no_func/1 is undefined or private\",\n \"external_source.ex:6:17: A.c/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports missing functions respecting arity\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: :ok\n def b, do: A.a(1)\n\n @file \"external_source.ex\"\n def c, do: A.b(1)\n end\n \"\"\"\n }\n\n warnings = [\n \"A.a/1 is undefined or private. Did you mean:\",\n \"* a/0\",\n \"a.ex:3:16: A.b/0\",\n \"A.b/1 is undefined or private. Did you mean:\",\n \"* b/0\",\n \"external_source.ex:6:16: A.c/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports missing modules\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: D.no_module()\n\n @file \"external_source.ex\"\n def c, do: E.no_module()\n\n def i, do: Io.puts \"hello\"\n end\n \"\"\"\n }\n\n warnings = [\n \"D.no_module/0 is undefined (module D is not available or is yet to be defined)\",\n \"a.ex:2:16: A.a/0\",\n \"E.no_module/0 is undefined (module E is not available or is yet to be defined)\",\n \"external_source.ex:5:16: A.c/0\",\n \"Io.puts/1 is undefined (module Io is not available or is yet to be defined)\",\n \"a.ex:7:17: A.i/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports missing captures\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: &A.no_func/0\n\n @file \"external_source.ex\"\n def c, do: &A.no_func/1\n end\n \"\"\"\n }\n\n warnings = [\n \"A.no_func/0 is undefined or private\",\n \"a.ex:2:17: A.a/0\",\n \"A.no_func/1 is undefined or private\",\n \"external_source.ex:5:17: A.c/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"doesn't report missing functions at compile time\" do\n files = %{\n \"a.ex\" => \"\"\"\n Enum.map([], fn _ -> BadReferencer.no_func4() end)\n\n if function_exported?(List, :flatten, 1) do\n List.flatten([1, 2, 3])\n else\n List.old_flatten([1, 2, 3])\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"handles multiple modules in one file\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: B.no_func()\n def b, do: B.a()\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n def a, do: A.no_func()\n def b, do: A.b()\n end\n \"\"\"\n }\n\n warnings = [\n \"B.no_func/0 is undefined or private\",\n \"a.ex:2:16: A.a/0\",\n \"A.no_func/0 is undefined or private\",\n \"b.ex:2:16: B.a/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"groups multiple warnings in one file\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: A.no_func()\n\n @file \"external_source.ex\"\n def b, do: A2.no_func()\n\n def c, do: A.no_func()\n def d, do: A2.no_func()\n end\n \"\"\"\n }\n\n warnings = [\n \"A2.no_func/0 is undefined (module A2 is not available or is yet to be defined)\",\n \"└─ a.ex:8:17: A.d/0\",\n \"└─ external_source.ex:5:17: A.b/0\",\n \"A.no_func/0 is undefined or private\",\n \"└─ a.ex:2:16: A.a/0\",\n \"└─ a.ex:7:16: A.c/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"hints exclude deprecated functions\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def to_charlist(a), do: a\n\n @deprecated \"Use String.to_charlist/1 instead\"\n def to_char_list(a), do: a\n\n def c(a), do: A.to_list(a)\n end\n \"\"\"\n }\n\n warnings = [\n \"A.to_list/1 is undefined or private. Did you mean:\",\n \"* to_charlist/1\",\n \"a.ex:7:19: A.c/1\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"do not warn of module defined in local (runtime) context\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a() do\n defmodule B do\n def b(), do: :ok\n end\n\n B.b()\n end\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n end\n\n test \"warn of unrequired module\" do\n files = %{\n \"ab.ex\" => \"\"\"\n defmodule A do\n def a(), do: B.b()\n end\n\n defmodule B do\n defmacro b(), do: :ok\n end\n \"\"\"\n }\n\n warnings = [\n \"Be sure to require B if you intend to invoke this macro\",\n \"ab.ex:2:18: A.a/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"excludes local no_warn_undefined\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @compile {:no_warn_undefined, [MissingModule, {MissingModule2, :func, 2}]}\n @compile {:no_warn_undefined, {B, :func, 2}}\n\n def a, do: MissingModule.func(1)\n def b, do: MissingModule2.func(1, 2)\n def c, do: MissingModule2.func(1)\n def d, do: MissingModule3.func(1, 2)\n def e, do: B.func(1)\n def f, do: B.func(1, 2)\n def g, do: B.func(1, 2, 3)\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n def func(_), do: :ok\n end\n \"\"\"\n }\n\n warnings = [\n \"MissingModule2.func/1 is undefined (module MissingModule2 is not available or is yet to be defined)\",\n \"a.ex:7:29: A.c/0\",\n \"MissingModule3.func/2 is undefined (module MissingModule3 is not available or is yet to be defined)\",\n \"a.ex:8:29: A.d/0\",\n \"B.func/3 is undefined or private. Did you mean:\",\n \"* func/1\",\n \"a.ex:11:16: A.g/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"warn of external nested module\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A.B do\n def a, do: :ok\n end\n defmodule A do\n alias A.B\n def a, do: B.a()\n def b, do: B.a(1)\n def c, do: B.no_func()\n end\n \"\"\"\n }\n\n warnings = [\n \"A.B.a/1 is undefined or private. Did you mean:\",\n \"* a/0\",\n \" def b, do: B.a(1)\",\n \"a.ex:7:16: A.b/0\",\n \"A.B.no_func/0 is undefined or private\",\n \"def c, do: B.no_func()\",\n \"a.ex:8:16: A.c/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"warn of compile time context module defined before calls\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n defmodule B do\n def a, do: :ok\n end\n def a, do: B.a()\n def b, do: B.a(1)\n def c, do: B.no_func()\n end\n \"\"\"\n }\n\n warnings = [\n \"A.B.a/1 is undefined or private. Did you mean:\",\n \"* a/0\",\n \" def b, do: B.a(1)\",\n \"a.ex:6:16: A.b/0\",\n \"A.B.no_func/0 is undefined or private\",\n \"def c, do: B.no_func()\",\n \"a.ex:7:16: A.c/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"warn of compile time context module defined after calls and aliased\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n alias A.B\n def a, do: B.a()\n def b, do: B.a(1)\n def c, do: B.no_func()\n defmodule B do\n def a, do: :ok\n end\n end\n \"\"\"\n }\n\n warnings = [\n \"A.B.a/1 is undefined or private. Did you mean:\",\n \"* a/0\",\n \" def b, do: B.a(1)\",\n \"a.ex:4:16: A.b/0\",\n \"A.B.no_func/0 is undefined or private\",\n \"def c, do: B.no_func()\",\n \"a.ex:5:16: A.c/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"excludes global no_warn_undefined\" do\n no_warn_undefined = Code.get_compiler_option(:no_warn_undefined)\n\n try do\n Code.compiler_options(\n no_warn_undefined: [MissingModule, {MissingModule2, :func, 2}, {B, :func, 2}]\n )\n\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @compile {:no_warn_undefined, [MissingModule, {MissingModule2, :func, 2}]}\n @compile {:no_warn_undefined, {B, :func, 2}}\n\n def a, do: MissingModule.func(1)\n def b, do: MissingModule2.func(1, 2)\n def c, do: MissingModule2.func(1)\n def d, do: MissingModule3.func(1, 2)\n def e, do: B.func(1)\n def f, do: B.func(1, 2)\n def g, do: B.func(1, 2, 3)\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n def func(_), do: :ok\n end\n \"\"\"\n }\n\n warnings = [\n \"MissingModule2.func/1 is undefined (module MissingModule2 is not available or is yet to be defined)\",\n \"a.ex:7:29: A.c/0\",\n \"MissingModule3.func/2 is undefined (module MissingModule3 is not available or is yet to be defined)\",\n \"a.ex:8:29: A.d/0\",\n \"B.func/3 is undefined or private. Did you mean:\",\n \"* func/1\",\n \"a.ex:11:16: A.g/0\"\n ]\n\n assert_warnings(files, warnings)\n after\n Code.compiler_options(no_warn_undefined: no_warn_undefined)\n end\n end\n\n test \"global no_warn_undefined :all\" do\n no_warn_undefined = Code.get_compiler_option(:no_warn_undefined)\n\n try do\n Code.compiler_options(no_warn_undefined: :all)\n\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n def a, do: MissingModule.func(1)\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n after\n Code.compiler_options(no_warn_undefined: no_warn_undefined)\n end\n end\n\n test \"global no_warn_undefined :all and local exclude\" do\n no_warn_undefined = Code.get_compiler_option(:no_warn_undefined)\n\n try do\n Code.compiler_options(no_warn_undefined: :all)\n\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @compile {:no_warn_undefined, MissingModule}\n\n def a, do: MissingModule.func(1)\n def b, do: MissingModule2.func(1, 2)\n end\n \"\"\"\n }\n\n assert_no_warnings(files)\n after\n Code.compiler_options(no_warn_undefined: no_warn_undefined)\n end\n end\n end\n\n describe \"after_verify\" do\n test \"reports functions\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @after_verify __MODULE__\n\n def __after_verify__(__MODULE__) do\n IO.warn \"from after_verify\", []\n end\n end\n \"\"\"\n }\n\n warning = [\n \"warning: \",\n \"from after_verify\"\n ]\n\n assert_warnings(files, warning)\n end\n end\n\n describe \"deprecated\" do\n test \"reports functions\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @deprecated \"oops\"\n def a, do: A.a()\n end\n \"\"\"\n }\n\n warnings = [\n \"A.a/0 is deprecated. oops\",\n \"a.ex:3:16: A.a/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports imported functions\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @deprecated \"oops\"\n def a, do: :ok\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n import A\n def b, do: a()\n end\n \"\"\"\n }\n\n warnings = [\n \"A.a/0 is deprecated. oops\",\n \"b.ex:3:14: B.b/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports structs\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @deprecated \"oops\"\n defstruct [:x, :y]\n def match(%A{}), do: :ok\n def build(:ok), do: %A{}\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n def match(%A{}), do: :ok\n def build(:ok), do: %A{}\n end\n \"\"\"\n }\n\n warnings = [\n \"A.__struct__/0 is deprecated. oops\",\n \"└─ a.ex:4:13: A.match/1\",\n \"└─ a.ex:5:23: A.build/1\",\n \"A.__struct__/0 is deprecated. oops\",\n \"└─ b.ex:2:13: B.match/1\",\n \"└─ b.ex:3:23: B.build/1\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports module body\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @deprecated \"oops\"\n def a, do: :ok\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n require A\n A.a()\n end\n \"\"\"\n }\n\n warnings = [\n \"A.a/0 is deprecated. oops\",\n \"b.ex:3:5: B (module)\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports macro\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @deprecated \"oops\"\n defmacro a, do: :ok\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n require A\n def b, do: A.a()\n end\n \"\"\"\n }\n\n warnings = [\n \"A.a/0 is deprecated. oops\",\n \"b.ex:3:16: B.b/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n\n test \"reports unquote functions\" do\n files = %{\n \"a.ex\" => \"\"\"\n defmodule A do\n @deprecated \"oops\"\n def a, do: :ok\n end\n \"\"\",\n \"b.ex\" => \"\"\"\n defmodule B do\n def b, do: unquote(&A.a/0)\n end\n \"\"\"\n }\n\n warnings = [\n \"A.a/0 is deprecated. oops\",\n \"b.ex: B.b/0\"\n ]\n\n assert_warnings(files, warnings)\n end\n end\n\n defp assert_warnings(files, expected, opts \\\\ [])\n\n defp assert_warnings(files, expected, opts) when is_binary(expected) do\n assert capture_compile_warnings(files, opts) == expected\n end\n\n defp assert_warnings(files, expecteds, opts) when is_list(expecteds) do\n output = capture_compile_warnings(files, opts)\n\n Enum.each(expecteds, fn expected ->\n assert output =~ expected\n end)\n end\n\n defp assert_no_warnings(files, opts \\\\ []) do\n assert capture_compile_warnings(files, opts) == \"\"\n end\n\n defp capture_compile_warnings(files, opts) do\n in_tmp(fn ->\n paths = generate_files(files)\n capture_io(:stderr, fn -> compile_to_path(paths, opts) end)\n end)\n end\n\n defp with_compile_warnings(files) do\n in_tmp(fn ->\n paths = generate_files(files)\n with_io(:stderr, fn -> compile_to_path(paths, []) end) |> elem(0)\n end)\n end\n\n defp compile_modules(files) do\n in_tmp(fn ->\n paths = generate_files(files)\n {modules, _warnings} = compile_to_path(paths, [])\n\n Map.new(modules, fn module ->\n {^module, binary, _filename} = :code.get_object_code(module)\n {module, binary}\n end)\n end)\n end\n\n defp compile_to_path(paths, opts) do\n if opts[:consolidate_protocols] do\n Code.prepend_path(\".\")\n\n result =\n compile_to_path_with_after_compile(paths, fn ->\n if Keyword.get(opts, :consolidate_protocols, false) do\n paths = [\".\", Application.app_dir(:elixir, \"ebin\")]\n protocols = Protocol.extract_protocols(paths)\n\n for protocol <- protocols do\n impls = Protocol.extract_impls(protocol, paths)\n {:ok, binary} = Protocol.consolidate(protocol, impls)\n File.write!(Atom.to_string(protocol) <> \".beam\", binary)\n purge(protocol)\n end\n end\n end)\n\n Code.delete_path(\".\")\n Enum.each(builtin_protocols(), &purge/1)\n\n result\n else\n compile_to_path_with_after_compile(paths, fn -> :ok end)\n end\n end\n\n defp compile_to_path_with_after_compile(paths, callback) do\n {:ok, modules, warnings} =\n Kernel.ParallelCompiler.compile_to_path(paths, \".\",\n return_diagnostics: true,\n after_compile: callback\n )\n\n for module <- modules do\n purge(module)\n end\n\n {modules, warnings}\n end\n\n defp generate_files(files) do\n for {file, contents} <- files do\n File.write!(file, contents)\n file\n end\n end\n\n defp read_chunk(binary) do\n assert {:ok, {_module, [{~c\"ExCk\", chunk}]}} = :beam_lib.chunks(binary, [~c\"ExCk\"])\n assert {:elixir_checker_v7, map} = :erlang.binary_to_term(chunk)\n map\n end\n\n defp purge(mod) do\n :code.delete(mod)\n :code.purge(mod)\n end\n\n defp in_tmp(fun) do\n path = PathHelpers.tmp_path(\"checker\")\n\n File.rm_rf!(path)\n File.mkdir_p!(path)\n File.cd!(path, fun)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/map_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"type_helper.exs\", __DIR__)\n\ndefmodule Module.Types.MapTest do\n # Tests for the Map module\n use ExUnit.Case, async: true\n\n import TypeHelper\n import Module.Types.Descr\n defmacro domain_key(arg) when is_atom(arg), do: [arg]\n\n describe \"inferred\" do\n test \"Map.new/0\" do\n assert typecheck!(Map.new()) == dynamic(empty_map())\n end\n\n test \"Map.equal?/2\" do\n assert typecheck!([x, y], {Map.equal?(x, y), x, y}) ==\n dynamic(tuple([boolean(), open_map(), open_map()]))\n end\n end\n\n describe \":maps.take/2\" do\n test \"checking\" do\n assert typecheck!(:maps.take(:key, %{key: 123})) ==\n tuple([integer(), empty_map()]) |> union(atom([:error]))\n\n assert typecheck!([x], :maps.take(:key, x)) ==\n union(\n dynamic(tuple([term(), open_map(key: not_set())])),\n atom([:error])\n )\n\n assert typecheck!([condition?, x], :maps.take(if(condition?, do: :foo, else: :bar), x)) ==\n union(\n dynamic(\n tuple([\n term(),\n union(\n open_map(foo: not_set()),\n open_map(bar: not_set())\n )\n ])\n ),\n atom([:error])\n )\n\n assert typecheck!([x], :maps.take(123, x)) ==\n union(\n dynamic(tuple([term(), open_map()])),\n atom([:error])\n )\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = :maps.take(:key, x)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], :maps.take(:foo, x)) =~\n \"incompatible types given to :maps.take/2\"\n\n assert typeerror!(:maps.take(:key, %{})) =~ \"\"\"\n incompatible types given to :maps.take/2:\n\n :maps.take(:key, %{})\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n therefore this function will always return :error\n \"\"\"\n end\n end\n\n describe \"Map.delete/2\" do\n test \"checking\" do\n assert typecheck!(Map.delete(%{}, :key)) ==\n empty_map()\n\n assert typecheck!(Map.delete(%{key: 123}, :key)) ==\n empty_map()\n\n assert typecheck!([x], Map.delete(x, :key)) ==\n dynamic(open_map(key: not_set()))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.delete(%{foo: 123}, if(condition?, do: :foo, else: :bar))\n ) ==\n union(\n empty_map(),\n closed_map(foo: integer())\n )\n\n assert typecheck!([x], Map.delete(x, 123)) == dynamic(open_map())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.delete(x, :key)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.delete(x, :key)) =~\n \"incompatible types given to Map.delete/2\"\n end\n\n test \"combined with put\" do\n assert typecheck!([x], x |> Map.delete(:key) |> Map.put(:key, \"123\")) ==\n dynamic(open_map(key: binary()))\n\n assert typecheck!([x, y], x |> Map.delete(:key) |> Map.put(String.to_atom(y), \"123\")) ==\n dynamic(open_map(key: if_set(binary())))\n end\n end\n\n describe \"Map.fetch/2\" do\n test \"checking\" do\n assert typecheck!(Map.fetch(%{key: 123}, :key)) ==\n tuple([atom([:ok]), integer()]) |> union(atom([:error]))\n\n assert typecheck!([x], Map.fetch(x, :key)) ==\n dynamic(tuple([atom([:ok]), term()])) |> union(atom([:error]))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.fetch(%{foo: 123}, if(condition?, do: :foo, else: :bar))\n ) == tuple([atom([:ok]), integer()]) |> union(atom([:error]))\n\n assert typecheck!([x], Map.fetch(x, 123)) ==\n dynamic(tuple([atom([:ok]), term()])) |> union(atom([:error]))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.fetch(x, :key)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!(Map.fetch(%{}, :foo)) =~\n \"\"\"\n incompatible types given to Map.fetch/2:\n\n Map.fetch(%{}, :foo)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :foo\n\n therefore this function will always return :error\n \"\"\"\n end\n end\n\n describe \"Map.fetch!/2\" do\n test \"checking\" do\n assert typecheck!(Map.fetch!(%{key: 123}, :key)) == integer()\n\n assert typecheck!([x], Map.fetch!(x, :key)) == dynamic()\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.fetch!(%{foo: 123}, if(condition?, do: :foo, else: :bar))\n ) == integer()\n\n assert typecheck!([x], Map.fetch!(x, 123)) == dynamic()\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n y = Integer.to_string(Map.fetch!(x, :key))\n {x, y}\n )\n ) == dynamic(tuple([open_map(key: integer()), binary()]))\n end\n\n test \"errors\" do\n assert typeerror!(Map.fetch!(%{}, :foo)) =~\n \"\"\"\n incompatible types given to Map.fetch!/2:\n\n Map.fetch!(%{}, :foo)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :foo\n\n therefore this function will always raise\n \"\"\"\n\n assert typeerror!(Map.fetch!(%{}, 123)) =~\n \"\"\"\n incompatible types given to Map.fetch!/2:\n\n Map.fetch!(%{}, 123)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n integer()\n\n therefore this function will always raise\n \"\"\"\n end\n end\n\n describe \"Map.from_keys/2\" do\n test \"checking\" do\n assert typecheck!([], Map.from_keys([], :value)) ==\n empty_map()\n\n assert typecheck!([x], Map.from_keys(x, :value)) ==\n open_map()\n\n assert typecheck!(\n (\n x = [:key1, :key2]\n Map.from_keys(x, 123)\n )\n ) ==\n closed_map(key1: if_set(integer()), key2: if_set(integer()))\n |> difference(empty_map())\n\n assert typecheck!(\n [condition?],\n (\n x = if condition?, do: [123, \"123\"], else: []\n Map.from_keys(x, 123)\n )\n ) ==\n closed_map([\n {domain_key(:integer), if_set(integer())},\n {domain_key(:binary), if_set(integer())}\n ])\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.from_keys(x, :value)\n x\n )\n ) == dynamic(list(term()))\n end\n\n test \"errors\" do\n assert typeerror!([x = %{}], Map.from_keys(x, :value)) =~\n \"incompatible types given to Map.from_keys/2\"\n end\n end\n\n describe \"Map.from_struct/1\" do\n test \"checking\" do\n assert typecheck!(Map.from_struct(%{})) ==\n empty_map()\n\n assert typecheck!(Map.from_struct(%{key: 123})) ==\n closed_map(key: integer())\n\n assert typecheck!(Map.from_struct(%URI{})) ==\n closed_map(\n authority: atom([nil]),\n fragment: atom([nil]),\n host: atom([nil]),\n path: atom([nil]),\n port: atom([nil]),\n query: atom([nil]),\n scheme: atom([nil]),\n userinfo: atom([nil])\n )\n\n assert typecheck!([x], Map.from_struct(x)) ==\n dynamic(open_map(__struct__: not_set()))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.from_struct(x)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.from_struct(x)) =~\n \"incompatible types given to Map.from_struct/1\"\n end\n end\n\n describe \"Map.get/2\" do\n test \"checking\" do\n assert typecheck!(Map.get(%{key: 123}, :key)) == integer() |> union(atom([nil]))\n\n assert typecheck!([x], Map.get(x, :key)) == dynamic(term()) |> union(atom([nil]))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.get(%{foo: 123}, if(condition?, do: :foo, else: :bar))\n ) == integer() |> union(atom([nil]))\n\n assert typecheck!([x], Map.get(x, 123)) == dynamic(term()) |> union(atom([nil]))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.get(x, :key)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!(Map.get(%{}, :foo)) =~\n \"\"\"\n incompatible types given to Map.get/2:\n\n Map.get(%{}, :foo)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :foo\n\n therefore this function will always return nil\n \"\"\"\n end\n end\n\n describe \"Map.get/3\" do\n test \"checking\" do\n assert typecheck!(Map.get(%{key: 123}, :key, 123)) == integer()\n\n assert typecheck!([x], Map.get(x, :key, 123)) == dynamic(term()) |> union(integer())\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.get(%{foo: 123}, if(condition?, do: :foo, else: :bar), 123)\n ) == integer()\n\n assert typecheck!([x], Map.get(x, 123, 123)) == dynamic(term()) |> union(integer())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.get(x, :key, 123)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!(Map.get(%{}, :foo, 123)) =~\n \"\"\"\n incompatible types given to Map.get/3:\n\n Map.get(%{}, :foo, 123)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :foo\n\n therefore this function will always return integer()\n \"\"\"\n end\n end\n\n describe \"Map.get_lazy/3\" do\n test \"checking\" do\n assert typecheck!(Map.get_lazy(%{key: 123}, :key, fn -> 123 end))\n |> equal?(integer())\n\n assert typecheck!([x], Map.get_lazy(x, :key, fn -> 123 end)) ==\n dynamic(term())\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.get_lazy(%{foo: 123}, if(condition?, do: :foo, else: :bar), fn -> 123 end)\n )\n |> equal?(integer())\n\n assert typecheck!([x], Map.get_lazy(x, 123, fn -> 123 end)) ==\n dynamic(term())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.get_lazy(x, :key, fn -> 123 end)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!(Map.get_lazy(%{}, :foo, fn -> 123 end)) =~\n \"\"\"\n incompatible types given to Map.get_lazy/3:\n\n Map.get_lazy(%{}, :foo, fn -> 123 end)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :foo\n\n therefore this function will always return integer()\n \"\"\"\n\n assert typeerror!(Map.get_lazy(%{}, :foo, 123)) =~\n \"\"\"\n expected a 0-arity function on function call within Map.get_lazy/3:\n\n Map.get_lazy(%{}, :foo, 123)\n\n but got type:\n\n integer()\n \"\"\"\n end\n end\n\n describe \"Map.keys/1\" do\n test \"checking\" do\n assert typecheck!([x = %{}], Map.keys(x)) == dynamic(list(term()))\n\n assert typecheck!(\n (\n x = %{}\n Map.keys(x)\n )\n ) == empty_list()\n\n assert typecheck!(\n (\n x = %{\"c\" => :three}\n Map.keys(x)\n )\n ) ==\n list(binary())\n\n assert typecheck!(\n (\n x = %{a: 1, b: \"two\"}\n Map.keys(x)\n )\n ) ==\n non_empty_list(union(atom([:a]), atom([:b])))\n\n assert typecheck!(\n (\n x = %{\"c\" => :three, a: 1, b: \"two\"}\n Map.keys(x)\n )\n ) ==\n non_empty_list(\n atom([:a])\n |> union(atom([:b]))\n |> union(binary())\n )\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.keys(x)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.keys(x)) =~ \"incompatible types given to Map.keys/1\"\n end\n end\n\n describe \"Map.pop/2\" do\n test \"checking\" do\n assert typecheck!(Map.pop(%{key: 123}, :key)) ==\n tuple([union(integer(), atom([nil])), empty_map()])\n\n assert typecheck!([x], Map.pop(x, :key)) ==\n dynamic(tuple([term(), open_map(key: not_set())]))\n\n assert typecheck!([condition?, x], Map.pop(x, if(condition?, do: :foo, else: :bar))) ==\n dynamic(\n tuple([\n term(),\n union(\n open_map(foo: not_set()),\n open_map(bar: not_set())\n )\n ])\n )\n\n assert typecheck!(\n [x],\n (\n x = %{String.to_integer(x) => :before}\n Map.pop(x, 123)\n )\n ) ==\n tuple([\n atom([:before, nil]),\n closed_map([{domain_key(:integer), atom([:before])}])\n ])\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.pop(x, :key)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.pop(x, :foo)) =~\n \"incompatible types given to Map.pop/2\"\n\n assert typeerror!(Map.pop(%{}, :key)) =~ \"\"\"\n incompatible types given to Map.pop/2:\n\n Map.pop(%{}, :key)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n \"\"\"\n end\n end\n\n describe \"Map.pop_lazy/3\" do\n test \"checking\" do\n assert typecheck!(Map.pop_lazy(%{key: 123}, :key, fn -> :error end)) ==\n dynamic(tuple([union(integer(), atom([:error])), empty_map()]))\n\n assert typecheck!([x], Map.pop_lazy(x, :key, fn -> :error end)) ==\n dynamic(tuple([term(), open_map(key: not_set())]))\n\n assert typecheck!(\n [condition?, x],\n Map.pop_lazy(x, if(condition?, do: :foo, else: :bar), fn -> :error end)\n ) ==\n dynamic(\n tuple([\n term(),\n union(\n open_map(foo: not_set()),\n open_map(bar: not_set())\n )\n ])\n )\n\n assert typecheck!(\n [x],\n (\n x = %{String.to_integer(x) => :before}\n Map.pop_lazy(x, 123, fn -> :after end)\n )\n ) ==\n dynamic(\n tuple([\n atom([:before, :after]),\n closed_map([{domain_key(:integer), atom([:before])}])\n ])\n )\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.pop_lazy(x, :key, fn -> :error end)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.pop_lazy(x, :foo, fn -> :error end)) =~\n \"incompatible types given to Map.pop_lazy/3\"\n\n assert typeerror!(Map.pop_lazy(%{}, :key, fn -> :error end)) =~ \"\"\"\n incompatible types given to Map.pop_lazy/3:\n\n Map.pop_lazy(%{}, :key, fn -> :error end)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n \"\"\"\n\n assert typeerror!(Map.pop_lazy(%{}, :foo, 123)) =~\n \"\"\"\n expected a 0-arity function on function call within Map.pop_lazy/3:\n\n Map.pop_lazy(%{}, :foo, 123)\n\n but got type:\n\n integer()\n \"\"\"\n end\n end\n\n describe \"Map.pop/3\" do\n test \"checking\" do\n assert typecheck!(Map.pop(%{key: 123}, :key, :error)) ==\n tuple([union(integer(), atom([:error])), empty_map()])\n\n assert typecheck!([x], Map.pop(x, :key, :error)) ==\n dynamic(tuple([term(), open_map(key: not_set())]))\n\n assert typecheck!([condition?, x], Map.pop(x, if(condition?, do: :foo, else: :bar), :error)) ==\n dynamic(\n tuple([\n term(),\n union(\n open_map(foo: not_set()),\n open_map(bar: not_set())\n )\n ])\n )\n\n assert typecheck!(\n [x],\n (\n x = %{String.to_integer(x) => :before}\n Map.pop(x, 123, :after)\n )\n ) ==\n tuple([\n atom([:before, :after]),\n closed_map([{domain_key(:integer), atom([:before])}])\n ])\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.pop(x, :key, :error)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.pop(x, :foo, :error)) =~\n \"incompatible types given to Map.pop/3\"\n\n assert typeerror!(Map.pop(%{}, :key, :error)) =~ \"\"\"\n incompatible types given to Map.pop/3:\n\n Map.pop(%{}, :key, :error)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n \"\"\"\n end\n end\n\n describe \"Map.pop!/2\" do\n test \"checking\" do\n assert typecheck!(Map.pop!(%{key: 123}, :key)) ==\n tuple([integer(), empty_map()])\n\n assert typecheck!([x], Map.pop!(x, :key)) ==\n dynamic(tuple([term(), open_map(key: not_set())]))\n\n assert typecheck!([condition?, x], Map.pop!(x, if(condition?, do: :foo, else: :bar))) ==\n dynamic(\n tuple([\n term(),\n union(\n open_map(foo: not_set()),\n open_map(bar: not_set())\n )\n ])\n )\n\n assert typecheck!([x], Map.pop!(x, 123)) ==\n dynamic(tuple([term(), open_map()]))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.pop!(x, :key)\n x\n )\n ) == dynamic(open_map(key: term()))\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.pop!(x, :foo)) =~\n \"incompatible types given to Map.pop!/2\"\n\n assert typeerror!(Map.pop!(%{}, :key)) =~ \"\"\"\n incompatible types given to Map.pop!/2:\n\n Map.pop!(%{}, :key)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n therefore this function will always raise\n \"\"\"\n end\n end\n\n describe \"Map.put/3\" do\n test \"checking\" do\n assert typecheck!(Map.put(%{}, :key, :value)) ==\n closed_map(key: atom([:value]))\n\n assert typecheck!(Map.put(%{key: 123}, :key, :value)) ==\n closed_map(key: atom([:value]))\n\n assert typecheck!([x], Map.put(x, :key, :value)) ==\n dynamic(open_map(key: atom([:value])))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.put(%{foo: 123}, if(condition?, do: :foo, else: :bar), \"123\")\n ) ==\n union(\n closed_map(foo: binary()),\n closed_map(foo: integer(), bar: binary())\n )\n\n assert typecheck!([x], Map.put(x, 123, 456)) == dynamic(open_map())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.put(x, :key, :value)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.put(x, :key, :value)) =~\n \"incompatible types given to Map.put/3\"\n end\n end\n\n describe \"Map.put_new_lazy/3\" do\n test \"checking\" do\n assert typecheck!(Map.put_new_lazy(%{}, :key, fn -> :value end)) ==\n closed_map(key: atom([:value]))\n\n assert typecheck!(Map.put_new_lazy(%{key: 123}, :key, fn -> :value end)) ==\n closed_map(key: integer())\n\n assert typecheck!([x], Map.put_new_lazy(x, :key, fn -> :value end)) ==\n dynamic(open_map(key: term()))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.put_new_lazy(%{foo: 123}, if(condition?, do: :foo, else: :bar), fn -> \"123\" end)\n ) == union(closed_map(foo: integer()), closed_map(foo: integer(), bar: binary()))\n\n assert typecheck!([], Map.put_new_lazy(%{789 => \"binary\"}, 123, fn -> 456 end)) ==\n closed_map([{domain_key(:integer), union(binary(), integer())}])\n\n assert typecheck!([x], Map.put_new_lazy(x, 123, fn -> 456 end)) == dynamic(open_map())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.put_new_lazy(x, :key, fn -> :value end)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.put_new_lazy(x, :key, fn -> :value end)) |> strip_ansi() =~\n \"\"\"\n incompatible types given to Map.put_new_lazy/3:\n\n Map.put_new_lazy(x, :key, fn -> :value end)\n\n given types:\n\n empty_list(), :key, (-> dynamic(:value))\n\n but expected one of:\n\n map(), term(), (-> term())\n \"\"\"\n\n assert typeerror!(Map.put_new_lazy(%{}, :foo, 123)) =~\n \"\"\"\n expected a 0-arity function on function call within Map.put_new_lazy/3:\n\n Map.put_new_lazy(%{}, :foo, 123)\n\n but got type:\n\n integer()\n \"\"\"\n end\n end\n\n describe \"Map.put_new/3\" do\n test \"checking\" do\n assert typecheck!(Map.put_new(%{}, :key, :value)) ==\n closed_map(key: atom([:value]))\n\n assert typecheck!(Map.put_new(%{key: 123}, :key, :value)) ==\n closed_map(key: integer())\n\n assert typecheck!([x], Map.put_new(x, :key, :value)) ==\n dynamic(open_map(key: term()))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.put_new(%{foo: 123}, if(condition?, do: :foo, else: :bar), \"123\")\n ) == union(closed_map(foo: integer()), closed_map(foo: integer(), bar: binary()))\n\n assert typecheck!([], Map.put_new(%{789 => \"binary\"}, 123, 456)) ==\n closed_map([{domain_key(:integer), union(binary(), integer())}])\n\n assert typecheck!([x], Map.put_new(x, 123, 456)) == dynamic(open_map())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.put_new(x, :key, :value)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.put_new(x, :key, :value)) |> strip_ansi() =~\n \"\"\"\n incompatible types given to Map.put_new/3:\n\n Map.put_new(x, :key, :value)\n\n given types:\n\n empty_list(), :key, :value\n\n but expected one of:\n\n map(), term(), term()\n \"\"\"\n end\n end\n\n describe \"Map.replace/3\" do\n test \"checking\" do\n assert typecheck!(Map.replace(%{key: 123}, :key, :value)) ==\n closed_map(key: atom([:value]))\n\n assert typecheck!([x], Map.replace(x, :key, :value)) ==\n dynamic(open_map(key: if_set(atom([:value]))))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.replace(%{foo: 123}, if(condition?, do: :foo, else: :bar), \"123\")\n ) == closed_map(foo: binary())\n\n assert typecheck!([x], Map.replace(x, 123, 456)) == dynamic(open_map())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.replace(x, :key, :value)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!(Map.replace(%{}, :key, :value)) =~\n \"\"\"\n incompatible types given to Map.replace/3:\n\n Map.replace(%{}, :key, :value)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n therefore this function will always do nothing\n \"\"\"\n end\n end\n\n describe \"Map.replace_lazy/3\" do\n test \"checking\" do\n assert typecheck!(Map.replace_lazy(%{key: 123}, :key, fn _ -> :value end)) ==\n dynamic(closed_map(key: atom([:value])))\n\n assert typecheck!([x], Map.replace_lazy(x, :key, fn _ -> :value end)) ==\n dynamic(open_map(key: if_set(atom([:value]))))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.replace_lazy(%{foo: 123}, if(condition?, do: :foo, else: :bar), fn _ ->\n \"123\"\n end)\n ) == dynamic(closed_map(foo: binary()))\n\n # Both succeed but different clauses\n assert typecheck!(\n [condition?],\n Map.replace_lazy(\n %{key1: :foo, key2: :bar},\n if(condition?, do: :key1, else: :key2),\n fn\n :foo -> 123\n :bar -> 123.0\n end\n )\n ) ==\n dynamic(\n union(\n closed_map(key1: atom([:foo]), key2: float()),\n closed_map(key1: integer(), key2: atom([:bar]))\n )\n )\n\n assert typecheck!([x], Map.replace_lazy(x, 123, fn _ -> 456 end)) == dynamic(open_map())\n\n assert typecheck!([], Map.replace_lazy(%{123 => 456}, 123, fn x -> x * 1.0 end)) ==\n dynamic(closed_map([{domain_key(:integer), union(integer(), float())}]))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.replace_lazy(x, :key, fn _ -> :value end)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!(Map.replace_lazy(%{}, :key, fn _ -> :value end)) =~\n \"\"\"\n incompatible types given to Map.replace_lazy/3:\n\n Map.replace_lazy(%{}, :key, fn _ -> :value end)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n therefore this function will always do nothing\n \"\"\"\n\n assert typeerror!(Map.replace_lazy(%{key: :foo}, :key, fn :bar -> :value end))\n |> strip_ansi() =~\n \"\"\"\n incompatible types given on function call within Map.replace_lazy/3:\n\n Map.replace_lazy(%{key: :foo}, :key, fn :bar -> :value end)\n\n given types:\n\n dynamic(:foo)\n\n but function has type:\n\n (:bar -> dynamic(:value))\n \"\"\"\n end\n end\n\n describe \"Map.replace!/3\" do\n test \"checking\" do\n assert typecheck!(Map.replace!(%{key: 123}, :key, :value)) ==\n closed_map(key: atom([:value]))\n\n assert typecheck!([x], Map.replace!(x, :key, :value)) ==\n dynamic(open_map(key: atom([:value])))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.replace!(%{foo: 123}, if(condition?, do: :foo, else: :bar), \"123\")\n ) == closed_map(foo: binary())\n\n assert typecheck!([x], Map.replace!(x, 123, 456)) == dynamic(open_map())\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.replace!(x, :key, :value)\n x\n )\n ) == dynamic(open_map(key: term()))\n end\n\n test \"errors\" do\n assert typeerror!(Map.replace!(%{}, :key, :value)) =~\n \"\"\"\n incompatible types given to Map.replace!/3:\n\n Map.replace!(%{}, :key, :value)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n therefore this function will always raise\n \"\"\"\n end\n end\n\n describe \"Map.to_list/1\" do\n test \"checking\" do\n assert typecheck!([x = %{}], Map.to_list(x)) == dynamic(list(tuple([term(), term()])))\n\n assert typecheck!(\n (\n x = %{}\n Map.to_list(x)\n )\n ) == empty_list()\n\n assert typecheck!(\n (\n x = %{\"c\" => :three}\n Map.to_list(x)\n )\n ) ==\n list(tuple([binary(), atom([:three])]))\n\n assert typecheck!(\n (\n x = %{a: 1, b: \"two\"}\n Map.to_list(x)\n )\n ) ==\n non_empty_list(\n union(tuple([atom([:a]), integer()]), tuple([atom([:b]), binary()]))\n )\n\n assert typecheck!(\n (\n x = %{\"c\" => :three, a: 1, b: \"two\"}\n Map.to_list(x)\n )\n ) ==\n non_empty_list(\n tuple([atom([:a]), integer()])\n |> union(tuple([atom([:b]), binary()]))\n |> union(tuple([binary(), atom([:three])]))\n )\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.to_list(x)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.to_list(x)) =~ \"incompatible types given to Map.to_list/1\"\n end\n end\n\n describe \"Map.update/4\" do\n test \"checking\" do\n assert typecheck!(Map.update(%{}, :key, :default, fn _ -> :value end)) ==\n dynamic(closed_map(key: atom([:default])))\n\n assert typecheck!(Map.update(%{key: 123}, :key, :default, fn _ -> :value end)) ==\n dynamic(closed_map(key: atom([:value])))\n\n assert typecheck!([x], Map.update(x, :key, :default, fn _ -> :value end)) ==\n dynamic(open_map(key: atom([:value, :default])))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.update(%{foo: 123}, if(condition?, do: :foo, else: :bar), :default, fn _ ->\n \"123\"\n end)\n ) ==\n dynamic(\n union(\n closed_map(foo: binary()),\n closed_map(foo: integer(), bar: atom([:default]))\n )\n )\n\n # Both succeed but different clauses\n assert typecheck!(\n [condition?],\n Map.update(\n %{key1: :foo, key2: :bar},\n if(condition?, do: :key1, else: :key2),\n :default,\n fn\n :foo -> 123\n :bar -> 123.0\n end\n )\n ) ==\n dynamic(\n union(\n closed_map(key1: atom([:foo]), key2: float()),\n closed_map(key1: integer(), key2: atom([:bar]))\n )\n )\n\n assert typecheck!([x], Map.update(x, 123, :default, fn _ -> 456 end)) == dynamic(open_map())\n\n integer_to_integer_float_atom =\n dynamic(\n closed_map([\n {domain_key(:integer), integer() |> union(float()) |> union(atom([:default]))}\n ])\n )\n\n assert typecheck!([], Map.update(%{123 => 456}, 123, :default, fn x -> x * 1.0 end)) ==\n integer_to_integer_float_atom\n\n assert typecheck!([], Map.update(%{123 => 456}, 456, :default, fn x -> x * 1.0 end)) ==\n integer_to_integer_float_atom\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.update(x, :key, :default, fn _ -> :value end)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!(Map.update(%{key: :foo}, :key, :default, fn :bar -> :value end))\n |> strip_ansi() =~\n \"\"\"\n incompatible types given on function call within Map.update/4:\n\n Map.update(%{key: :foo}, :key, :default, fn :bar -> :value end)\n\n given types:\n\n dynamic(:foo)\n\n but function has type:\n\n (:bar -> dynamic(:value))\n \"\"\"\n end\n end\n\n describe \"Map.update!/3\" do\n test \"checking\" do\n assert typecheck!(Map.update!(%{key: 123}, :key, fn _ -> :value end)) ==\n dynamic(closed_map(key: atom([:value])))\n\n assert typecheck!([x], Map.update!(x, :key, fn _ -> :value end)) ==\n dynamic(open_map(key: atom([:value])))\n\n # If one of them succeeds, we are still fine!\n assert typecheck!(\n [condition?],\n Map.update!(%{foo: 123}, if(condition?, do: :foo, else: :bar), fn _ -> \"123\" end)\n ) == dynamic(closed_map(foo: binary()))\n\n # Both succeed but different clauses\n assert typecheck!(\n [condition?],\n Map.update!(%{key1: :foo, key2: :bar}, if(condition?, do: :key1, else: :key2), fn\n :foo -> 123\n :bar -> 123.0\n end)\n ) ==\n dynamic(\n union(\n closed_map(key1: atom([:foo]), key2: float()),\n closed_map(key1: integer(), key2: atom([:bar]))\n )\n )\n\n assert typecheck!([x], Map.update!(x, 123, fn _ -> 456 end)) == dynamic(open_map())\n\n assert typecheck!([], Map.update!(%{123 => 456}, 123, fn x -> x * 1.0 end)) ==\n dynamic(closed_map([{domain_key(:integer), union(integer(), float())}]))\n\n assert typecheck!([], Map.update!(%{123 => 456}, 456, fn x -> x * 1.0 end)) ==\n dynamic(closed_map([{domain_key(:integer), union(integer(), float())}]))\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.update!(x, :key, fn _ -> :value end)\n x\n )\n ) == dynamic(open_map(key: term()))\n end\n\n test \"errors\" do\n assert typeerror!(Map.update!(%{}, :key, fn _ -> :value end)) =~\n \"\"\"\n incompatible types given to Map.update!/3:\n\n Map.update!(%{}, :key, fn _ -> :value end)\n\n the map:\n\n empty_map()\n\n does not have all required keys:\n\n :key\n\n therefore this function will always raise\n \"\"\"\n\n assert typeerror!(Map.update!(%{key: :foo}, :key, fn :bar -> :value end)) |> strip_ansi() =~\n \"\"\"\n incompatible types given on function call within Map.update!/3:\n\n Map.update!(%{key: :foo}, :key, fn :bar -> :value end)\n\n given types:\n\n dynamic(:foo)\n\n but function has type:\n\n (:bar -> dynamic(:value))\n \"\"\"\n end\n\n test \"with unknown function type\" do\n assert typecheck!([x], Map.update!(x, :body, &:zlib.gunzip/1)) ==\n dynamic(open_map(body: term()))\n end\n end\n\n describe \"Map.values/1\" do\n test \"checking\" do\n assert typecheck!([x = %{}], Map.values(x)) == dynamic(list(term()))\n\n assert typecheck!(\n (\n x = %{}\n Map.values(x)\n )\n ) == empty_list()\n\n assert typecheck!(\n (\n x = %{\"c\" => :three}\n Map.values(x)\n )\n ) ==\n list(atom([:three]))\n\n assert typecheck!(\n (\n x = %{a: 1, b: \"two\"}\n Map.values(x)\n )\n ) ==\n non_empty_list(union(integer(), binary()))\n\n assert typecheck!(\n (\n x = %{\"c\" => :three, a: 1, b: \"two\"}\n Map.values(x)\n )\n ) ==\n non_empty_list(\n integer()\n |> union(binary())\n |> union(atom([:three]))\n )\n end\n\n test \"inference\" do\n assert typecheck!(\n [x],\n (\n _ = Map.values(x)\n x\n )\n ) == dynamic(open_map())\n end\n\n test \"errors\" do\n assert typeerror!([x = []], Map.values(x)) =~ \"incompatible types given to Map.values/1\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/pattern_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"type_helper.exs\", __DIR__)\n\ndefmodule Module.Types.PatternTest do\n use ExUnit.Case, async: true\n\n import TypeHelper\n import Module.Types.Descr\n\n describe \"variables\" do\n test \"captures variables from simple assignment in head\" do\n assert typecheck!([x = :foo], x) == dynamic(atom([:foo]))\n assert typecheck!([:foo = x], x) == dynamic(atom([:foo]))\n end\n\n test \"captures variables from simple assignment in =\" do\n assert typecheck!(\n (\n x = :foo\n x\n )\n ) == atom([:foo])\n end\n\n test \"refines information across patterns\" do\n assert typecheck!([%y{}, %x{}, x = y, x = Point], y) == dynamic(atom([Point]))\n end\n\n test \"repeated refinements are ignored on reporting\" do\n assert typeerror!([{name, arity}, arity = 123], hd(Atom.to_charlist(name))) |> strip_ansi() ==\n ~l\"\"\"\n incompatible types given to Kernel.hd/1:\n\n hd(Atom.to_charlist(name))\n\n given types:\n\n empty_list() or non_empty_list(integer())\n\n but expected one of:\n\n non_empty_list(term(), term())\n\n where \"name\" was given the type:\n\n # type: dynamic(atom())\n # from: types_test.ex:LINE-1\n Atom.to_charlist(name)\n \"\"\"\n end\n\n test \"can be accessed even if they don't match\" do\n assert typeerror!(\n (\n # This will never match, info should not be \"corrupted\"\n [info | _] = __ENV__.function\n info\n )\n ) =~ \"the following pattern will never match\"\n end\n\n test \"does not check underscore\" do\n assert typecheck!(_ = raise(\"oops\")) == none()\n end\n end\n\n describe \"=\" do\n test \"precedence does not matter\" do\n uri_type = typecheck!([x = %URI{}], x)\n\n assert typecheck!(\n (\n x = %URI{} = URI.new!(\"/\")\n x\n )\n ) == uri_type\n\n assert typecheck!(\n (\n %URI{} = x = URI.new!(\"/\")\n x\n )\n ) == uri_type\n end\n\n test \"refines types\" do\n assert typecheck!(\n [x, foo = :foo, bar = 123],\n (\n {^foo, ^bar} = x\n x\n )\n ) == dynamic(tuple([atom([:foo]), integer()]))\n end\n\n test \"match propagation\" do\n assert typecheck!([x = {:ok, y}], is_integer(y), x) ==\n dynamic(tuple([atom([:ok]), integer()]))\n\n assert typecheck!(\n [x = {:ok, y}],\n (\n _ = Integer.to_string(y)\n x\n )\n ) ==\n dynamic(tuple([atom([:ok]), integer()]))\n end\n\n test \"reports incompatible types\" do\n assert typeerror!([x = 123 = \"123\"], x) == ~l\"\"\"\n the following pattern will never match:\n\n x = 123 = \"123\"\n \"\"\"\n\n assert typeerror!([x = {:ok, _} = {:error, _, _}], x) == ~l\"\"\"\n the following pattern will never match:\n\n x = {:ok, _} = {:error, _, _}\n \"\"\"\n\n assert typeerror!([{x = {:ok, y} = {:error, z, w}}], {x, y, z, w}) == ~l\"\"\"\n the following pattern will never match:\n\n {x = {:ok, y} = {:error, z, w}}\n \"\"\"\n\n assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) == ~l\"\"\"\n the following pattern will never match:\n\n a = b\n\n where \"b\" was given the type:\n\n # type: dynamic(:bar)\n # from: types_test.ex:LINE\n b = :bar\n \"\"\"\n\n assert typeerror!([{x, _} = {y, _}, x = :foo, y = :bar], {x, y}) == ~l\"\"\"\n the following pattern will never match:\n\n {x, _} = {y, _}\n\n where \"x\" was given the type:\n\n # type: dynamic(:foo)\n # from: types_test.ex:LINE\n x = :foo\n\n where \"y\" was given the type:\n\n # type: dynamic(:bar)\n # from: types_test.ex:LINE\n y = :bar\n \"\"\"\n\n assert typeerror!([{:ok, x} = {:ok, y}], is_integer(x) and is_atom(y), {x, y}) == ~l\"\"\"\n the following pattern will never match:\n\n {:ok, x} = {:ok, y}\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE\n is_integer(x)\n\n where \"y\" was given the type:\n\n # type: atom()\n # from: types_test.ex:LINE\n is_atom(y)\n \"\"\"\n end\n end\n\n describe \"structs\" do\n test \"unknown struct\" do\n {_, [diagnostic]} = typediag!([%UNKNOWN.URI{} = x], x)\n assert diagnostic.severity == :error\n\n assert diagnostic.message ==\n \"struct UNKNOWN.URI is undefined (module UNKNOWN.URI is not available or is yet to be defined)\"\n\n {_, [diagnostic]} = typediag!([%Enumerable{} = x], x)\n assert diagnostic.severity == :error\n\n assert diagnostic.message ==\n \"struct Enumerable is undefined (there is such module but it does not define a struct)\"\n end\n\n test \"fields access on unknown struct\" do\n assert typeerror!([%UNKNOWN.URI{reason: reason}], reason) =~\n \"struct UNKNOWN.URI is undefined (module UNKNOWN.URI is not available or is yet to be defined)\"\n end\n\n test \"unknown field\" do\n {_, [diagnostic]} = typediag!([%URI{unknown: _} = x], x)\n assert diagnostic.severity == :error\n assert diagnostic.message == \"unknown key :unknown for struct URI\"\n end\n\n test \"variable name\" do\n assert typecheck!([%x{}], x) == dynamic(atom())\n end\n\n test \"variable name fields\" do\n assert typecheck!([x = %_{}], x.__struct__) == dynamic(atom())\n assert typecheck!([x = %_{}], x) == dynamic(open_map(__struct__: atom()))\n\n assert typecheck!([x = %m{}, m = Point], x) ==\n dynamic(open_map(__struct__: atom([Point])))\n\n assert typecheck!([m = Point, x = %m{}], x) ==\n dynamic(open_map(__struct__: atom([Point])))\n\n assert typeerror!([m = 123], %^m{} = %Point{}) ==\n ~l\"\"\"\n expected an atom as struct name:\n\n %^m{}\n\n got type:\n\n integer()\n\n where \"m\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE-1\n m = 123\n \"\"\"\n end\n end\n\n describe \"maps\" do\n test \"atom keys in patterns\" do\n assert typecheck!([x = %{foo: :bar}], x) == dynamic(open_map(foo: atom([:bar])))\n assert typecheck!([x = %{123 => 456}], x) == dynamic(open_map())\n assert typecheck!([x = %{123 => 456, foo: :bar}], x) == dynamic(open_map(foo: atom([:bar])))\n assert typecheck!([%{foo: :bar = x}], x) == dynamic(atom([:bar]))\n\n assert typecheck!(\n [\n {:message, %{slug: slug}},\n %{assigns: %{app: %{slug: slug} = app}} = root\n ],\n {root, app, slug}\n ) ==\n dynamic(\n tuple([\n open_map(assigns: open_map(app: open_map(slug: term()))),\n open_map(slug: term()),\n term()\n ])\n )\n\n assert typecheck!(\n [\n %{assigns: %{app: %{slug: slug} = app}} = root,\n {:message, %{slug: slug}}\n ],\n {root, app, slug}\n ) ==\n dynamic(\n tuple([\n open_map(assigns: open_map(app: open_map(slug: term()))),\n open_map(slug: term()),\n term()\n ])\n )\n end\n\n test \"domain keys in patterns\" do\n assert typecheck!([x = %{123 => 456}], x) == dynamic(open_map())\n assert typecheck!([x = %{123 => 456, foo: :bar}], x) == dynamic(open_map(foo: atom([:bar])))\n assert typecheck!([%{\"123\" => :bar = x}], x) == dynamic(atom([:bar]))\n end\n\n test \"pinned variable key in patterns\" do\n assert typecheck!(\n (\n key = 123\n %{^key => value} = %{123 => :value}\n value\n )\n ) == atom([:value])\n\n assert typecheck!(\n [size, map],\n (\n %{<<123::size(^size)>> => _} = map\n {size, map}\n )\n ) == dynamic(tuple([integer(), open_map()]))\n\n assert(\n typecheck!(\n [key, map],\n (\n %{{:module, ^key} => _} = map\n {key, map}\n )\n ) == dynamic(tuple([term(), open_map()]))\n )\n end\n end\n\n describe \"tuples\" do\n test \"in patterns\" do\n assert typecheck!([x = {:ok, 123}], x) == dynamic(tuple([atom([:ok]), integer()]))\n assert typecheck!([{:x, y} = {x, :y}], {x, y}) == dynamic(tuple([atom([:x]), atom([:y])]))\n end\n end\n\n describe \"lists\" do\n test \"in patterns\" do\n assert typecheck!([x = [1, 2, 3]], x) ==\n dynamic(non_empty_list(integer()))\n\n assert typecheck!([x = [1, 2, 3 | y], y = :foo], x) ==\n dynamic(non_empty_list(integer(), atom([:foo])))\n\n assert typecheck!([x = [1, 2, 3 | y], y = [1.0, 2.0, 3.0]], x) ==\n dynamic(non_empty_list(union(integer(), float())))\n\n assert typecheck!([x = [:ok | z]], {x, z}) ==\n dynamic(tuple([non_empty_list(term(), term()), term()]))\n\n assert typecheck!([x = [a = :a, b = :b, c = :c]], {x, a, b, c}) ==\n dynamic(\n tuple([non_empty_list(atom([:a, :b, :c])), atom([:a]), atom([:b]), atom([:c])])\n )\n\n assert typecheck!([x = [y | z]], {x, y, z}) ==\n dynamic(tuple([non_empty_list(term(), term()), term(), term()]))\n end\n\n test \"in patterns through ++\" do\n assert typecheck!([x = [] ++ []], x) == dynamic(empty_list())\n\n assert typecheck!([x = [] ++ y, y = :foo], x) ==\n dynamic(atom([:foo]))\n\n assert typecheck!([x = [1, 2, 3] ++ y, y = :foo], x) ==\n dynamic(non_empty_list(integer(), atom([:foo])))\n\n assert typecheck!([x = [1, 2, 3] ++ y, y = [1.0, 2.0, 3.0]], x) ==\n dynamic(non_empty_list(union(integer(), float())))\n end\n\n test \"with lists inside tuples inside lists\" do\n assert typecheck!([[node_1 = {[arg]}, node_2 = {[arg]}]], {node_1, node_2, arg})\n |> equal?(\n dynamic(\n tuple([\n tuple([non_empty_list(term())]),\n tuple([non_empty_list(term())]),\n term()\n ])\n )\n )\n end\n\n test \"regressions\" do\n # This is a regression that happens because stacktrace may be\n # either three-element or four-element tuples, and it was failing\n # when we tried to access the fourth element\n assert typecheck!(\n try do\n raise \"oops\"\n rescue\n _ ->\n [{__MODULE__, fun, _args_or_arity, info} | _] = __STACKTRACE__\n {fun, length(info)}\n end\n ) == tuple([atom(), integer()])\n\n assert typecheck!(\n try do\n raise \"oops\"\n rescue\n _ ->\n [tuple | _] = __STACKTRACE__\n {__MODULE__, fun, _args_or_arity, info} = tuple\n {fun, length(info)}\n end\n ) == tuple([atom(), integer()])\n end\n end\n\n describe \"bitstrings\" do\n test \"alignment\" do\n assert typecheck!([<<_>> = x], x) == dynamic(binary())\n assert typecheck!([<<_::1>> = x], x) == dynamic(difference(bitstring(), binary()))\n assert typecheck!([<<_::4, _::4>> = x], x) == dynamic(binary())\n assert typecheck!([<> = x], x) == dynamic(bitstring())\n end\n\n test \"ok\" do\n assert typecheck!([<>], x) == integer()\n assert typecheck!([<>], x) == float()\n assert typecheck!([<>], x) == binary()\n assert typecheck!([<>], x) == integer()\n end\n\n test \"nested\" do\n assert typecheck!([<<0, <>::binary>>], x) == binary()\n\n assert typeerror!([<<0, <>::binary>>], x) == ~l\"\"\"\n incompatible types in binary matching:\n\n <<..., <>::binary>>\n\n got type:\n\n bitstring()\n\n but expected type:\n\n binary()\n\n where \"x\" was given the type:\n\n # type: bitstring()\n # from: types_test.ex:LINE\n <>\n \"\"\"\n end\n\n test \"error\" do\n assert typeerror!([<>], x) == ~l\"\"\"\n incompatible types assigned to \"x\":\n\n binary() !~ float()\n\n where \"x\" was given the types:\n\n # type: binary()\n # from: types_test.ex:LINE\n <>\n\n # type: float()\n # from: types_test.ex:LINE\n <<..., x::float>>\n \"\"\"\n\n assert typeerror!([<>], x) == ~l\"\"\"\n incompatible types assigned to \"x\":\n\n float() !~ integer()\n\n where \"x\" was given the types:\n\n # type: float()\n # from: types_test.ex:LINE\n <>\n\n # type: integer()\n # from: types_test.ex:LINE\n <<..., x>>\n\n #{hints(:inferred_bitstring_spec)}\n \"\"\"\n end\n\n test \"pin inference\" do\n assert typecheck!(\n [x, y],\n (\n <<^x>> = y\n x\n )\n ) == dynamic(integer())\n end\n\n test \"size ok\" do\n assert typecheck!([<>], :ok) == atom([:ok])\n end\n\n test \"size error\" do\n assert typeerror!([<>], :ok) ==\n ~l\"\"\"\n expected an integer in binary size:\n\n size(x)\n\n got type:\n\n float()\n\n where \"x\" was given the type:\n\n # type: float()\n # from: types_test.ex:LINE-1\n <>\n \"\"\"\n end\n\n test \"size pin inference\" do\n assert typecheck!(\n [x, y],\n (\n <<_::size(^x)>> = y\n x\n )\n ) == dynamic(integer())\n end\n end\n\n describe \"pin\" do\n test \"propagates across matches\" do\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case 123 do\n ^y -> x\n end\n end\n ) == dynamic(integer())\n\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case 123 do\n ^x -> y\n end\n end\n ) == dynamic(integer())\n end\n\n test \"propagates across guards\" do\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y when is_integer(y) -> x\n end\n ) == dynamic(integer())\n end\n\n test \"propagates across matches and guards\" do\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case true do\n true when is_integer(y) -> x\n end\n end\n ) == dynamic(integer())\n\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case true do\n true when is_integer(x) -> y\n end\n end\n ) == dynamic(integer())\n end\n\n test \"propagates across binary size in match\" do\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case Process.get(:another) do\n <<_::size(^y)>> -> x\n end\n end\n ) == dynamic(integer())\n\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case Process.get(:another) do\n <<_::size(^x)>> -> y\n end\n end\n ) == dynamic(integer())\n end\n\n test \"propagates across binary size in match inside a key\" do\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case Process.get(:another) do\n %{<<32::size(^y)>> => _} -> x\n end\n end\n ) == dynamic(integer())\n\n assert typecheck!(\n [x],\n case Process.get(:unused) do\n ^x = y ->\n case Process.get(:another) do\n %{<<32::size(^x)>> => _} -> y\n end\n end\n ) == dynamic(integer())\n end\n end\n\n describe \"guards\" do\n test \"not\" do\n assert typecheck!([x], not x, x) == dynamic(atom([false]))\n\n assert typecheck!([x], not x.foo, x) == dynamic(open_map(foo: atom([false])))\n\n assert typeerror!([x], not length(x), x) |> strip_ansi() == ~l\"\"\"\n incompatible types given to Kernel.not/1:\n\n not length(x)\n\n given types:\n\n integer()\n\n but expected one of:\n\n #1\n true\n\n #2\n false\n\n where \"x\" was given the type:\n\n # type: list(term())\n # from: types_test.ex:LINE\n length(x)\n \"\"\"\n end\n\n test \"hd/tl\" do\n assert typecheck!([x], is_list(x) and is_map(hd(x)) and is_map_key(hd(x), :tag), x) ==\n dynamic(non_empty_list(term(), term()))\n\n assert typeerror!([x], is_list(x) and is_map(hd(x)) and is_binary(hd(x)), x) =~ ~l\"\"\"\n this guard will never succeed:\n\n is_list(x) and is_map(hd(x)) and is_binary(hd(x))\n\n because it returns type:\n\n false\n\n where \"x\" was given the types:\n\n # type: empty_list() or non_empty_list(term(), term())\n # from: types_test.ex:649\n is_list(x)\n\n # type: non_empty_list(term(), term())\n # from: types_test.ex:649\n hd(x)\n \"\"\"\n end\n\n test \"is_struct/1\" do\n assert typecheck!([x], is_struct(x), x) == dynamic(open_map(__struct__: atom()))\n assert typecheck!([x], is_struct(x, URI), x) == dynamic(open_map(__struct__: atom([URI])))\n\n assert typecheck!([x], not is_struct(x), x)\n |> equal?(dynamic(negation(open_map(__struct__: atom()))))\n\n assert typecheck!([x], not is_struct(x, URI), x) == dynamic()\n end\n\n test \"is_binary/1\" do\n assert typecheck!([x], is_binary(x), x) == dynamic(binary())\n assert typecheck!([x], not is_binary(x), x) == dynamic(negation(binary()))\n\n assert typecheck!([x], is_bitstring(x), x) == dynamic(bitstring())\n assert typecheck!([x], not is_bitstring(x), x) == dynamic(negation(bitstring()))\n end\n\n test \"is_function/2\" do\n assert typecheck!([x], is_function(x, 3), x) == dynamic(fun(3))\n assert typecheck!([x], not is_function(x, 3), x) == dynamic(negation(fun(3)))\n end\n\n test \"is_map_key/2\" do\n assert typecheck!([x], is_map_key(x, :foo), x) == dynamic(open_map(foo: term()))\n assert typecheck!([x], not is_map_key(x, :foo), x) == dynamic(open_map(foo: not_set()))\n end\n\n test \"elem\" do\n assert typecheck!([x], elem(x, 1), x) ==\n dynamic(open_tuple([term(), atom([true])]))\n\n assert typecheck!([x], not elem(x, 1), x) ==\n dynamic(open_tuple([term(), atom([false])]))\n\n assert typecheck!([x], is_integer(elem(x, 1)), x) ==\n dynamic(open_tuple([term(), integer()]))\n end\n\n test \"map.field\" do\n assert typecheck!([x = %{foo: :bar}], x.bar, x) ==\n dynamic(open_map(foo: atom([:bar]), bar: atom([true])))\n\n assert typecheck!([x = %{foo: :bar}], not x.bar, x) ==\n dynamic(open_map(foo: atom([:bar]), bar: atom([false])))\n\n assert typeerror!([x = %Point{}], x.foo_bar, :ok) == ~l\"\"\"\n the following pattern will never match:\n\n x = %Point{}\n\n where \"x\" was given the type:\n\n # type: %{..., foo_bar: true}\n # from: types_test.ex:LINE\n x.foo_bar\n \"\"\"\n end\n\n test \"when checks\" do\n assert typecheck!([x], is_binary(x) when is_atom(x), x) == dynamic(union(binary(), atom()))\n\n assert typecheck!([x], is_binary(x) when map_size(x) >= 0, x) ==\n dynamic(union(binary(), open_map()))\n\n assert typecheck!([x], tuple_size(x) >= 0 when map_size(x) >= 0, x) ==\n dynamic(union(tuple(), open_map()))\n\n assert typecheck!([x, y], is_binary(x) when is_atom(y), {x, y}) ==\n dynamic(tuple([term(), term()]))\n end\n\n test \"conditional checks (andalso/orelse)\" do\n assert typecheck!([x], is_binary(x) or is_atom(x), x) == dynamic(union(binary(), atom()))\n\n assert typecheck!([x], is_binary(x) or map_size(x) >= 0, x) ==\n dynamic(union(binary(), open_map()))\n\n assert typecheck!([x, y], is_binary(x) or is_atom(y), {x, y}) ==\n dynamic(tuple([term(), term()]))\n\n assert typecheck!([x, y], is_binary(x) or map_size(y) >= 0, {x, y}) ==\n dynamic(tuple([term(), term()]))\n\n assert typecheck!([x], not (is_pid(x) and is_atom(x)), x) |> equal?(dynamic(term()))\n\n assert typecheck!([x, y], not (is_pid(x) and is_atom(y)), {x, y}) ==\n dynamic(tuple([term(), term()]))\n\n # Error\n assert typeerror!([x], is_pid(x) and is_atom(x), x) == ~l\"\"\"\n this guard will never succeed:\n\n is_pid(x) and is_atom(x)\n\n because it returns type:\n\n false\n\n where \"x\" was given the type:\n\n # type: pid()\n # from: types_test.ex:LINE\n is_pid(x)\n \"\"\"\n\n assert typeerror!([x], (is_binary(x) or is_atom(x)) and is_pid(x), x) == ~l\"\"\"\n this guard will never succeed:\n\n (is_binary(x) or is_atom(x)) and is_pid(x)\n\n because it returns type:\n\n false\n\n where \"x\" was given the type:\n\n # type: atom() or binary()\n # from: types_test.ex:LINE\n is_binary(x) or is_atom(x)\n \"\"\"\n end\n\n test \"conditional checks (and/or)\" do\n assert typecheck!([x], :erlang.or(is_binary(x), is_atom(x)), x) ==\n dynamic(union(binary(), atom()))\n\n assert typecheck!([x], :erlang.or(is_binary(x), map_size(x) >= 0), x) ==\n dynamic(open_map())\n\n assert typecheck!([x, y], :erlang.or(is_binary(x), is_atom(y)), {x, y}) ==\n dynamic(tuple([term(), term()]))\n\n assert typecheck!([x, y], :erlang.or(is_binary(x), map_size(y) >= 0), {x, y}) ==\n dynamic(tuple([term(), open_map()]))\n\n assert typecheck!([x], not :erlang.and(is_pid(x), is_atom(x)), x) |> equal?(dynamic(term()))\n\n assert typecheck!([x, y], not :erlang.and(is_pid(x), is_atom(y)), {x, y}) ==\n dynamic(tuple([term(), term()]))\n\n # Error\n assert typeerror!([x], :erlang.and(is_pid(x), is_atom(x)), x) == ~l\"\"\"\n this guard will never succeed:\n\n :erlang.and(is_pid(x), is_atom(x))\n\n because it returns type:\n\n false\n\n where \"x\" was given the type:\n\n # type: pid()\n # from: types_test.ex:LINE\n is_pid(x)\n \"\"\"\n\n assert typeerror!([x], :erlang.and(:erlang.or(is_binary(x), is_atom(x)), is_pid(x)), x) ==\n ~l\"\"\"\n this guard will never succeed:\n\n :erlang.and(:erlang.or(is_binary(x), is_atom(x)), is_pid(x))\n\n because it returns type:\n\n false\n\n where \"x\" was given the type:\n\n # type: atom() or binary()\n # from: types_test.ex:LINE-1\n :erlang.or(is_binary(x), is_atom(x))\n \"\"\"\n end\n\n test \"domain checks\" do\n # Regular domain check\n assert typecheck!([x, z], length(x) == z, x) == dynamic(list(term()))\n\n # erlang-or propagates\n assert typecheck!([x, y, z], :erlang.or(length(x) == z, map_size(y) == z), {x, y}) ==\n dynamic(tuple([list(term()), open_map()]))\n\n # erlang-and propagates\n assert typecheck!([x, y, z], :erlang.and(length(x) == z, map_size(y) == z), {x, y}) ==\n dynamic(tuple([list(term()), open_map()]))\n\n # or with mixed checks\n assert typecheck!([x, z], length(x) == z or is_map(x), x) ==\n dynamic(list(term()))\n\n # or does not propagate\n assert typecheck!([x, y, z], length(x) == z or map_size(y) == z, {x, y}) ==\n dynamic(tuple([list(term()), term()]))\n\n # and propagates\n assert typecheck!([x, y, z], length(x) == z and map_size(y) == z, {x, y}) ==\n dynamic(tuple([list(term()), open_map()]))\n\n # not or does propagate\n assert typecheck!([x, y, z], not (length(x) == z or map_size(y) == z), {x, y}) ==\n dynamic(tuple([list(term()), open_map()]))\n\n # not and does not propagate\n assert typecheck!([x, y, z], not (length(x) == z and map_size(y) == z), {x, y}) ==\n dynamic(tuple([list(term()), term()]))\n end\n\n test \"incompatible pattern and guards\" do\n assert typeerror!([x = {}], is_integer(x), x) == ~l\"\"\"\n the following pattern will never match:\n\n x = {}\n\n where \"x\" was given the type:\n\n # type: integer()\n # from: types_test.ex:LINE\n is_integer(x)\n \"\"\"\n end\n end\n\n describe \"equality in guards\" do\n test \"with non-singleton literals\" do\n assert typecheck!([x], x == \"foo\", x) == dynamic(binary())\n assert typecheck!([x], x === \"foo\", x) == dynamic(binary())\n assert typecheck!([x], x in [\"foo\", \"bar\", \"baz\"], x) == dynamic(binary())\n assert typecheck!([x], not (x == \"foo\"), x) == dynamic()\n assert typecheck!([x], not (x === \"foo\"), x) == dynamic()\n assert typecheck!([x], x not in [\"foo\", \"bar\", \"baz\"], x) == dynamic()\n\n assert typecheck!([x], x != \"foo\", x) == dynamic()\n assert typecheck!([x], x !== \"foo\", x) == dynamic()\n assert typecheck!([x], not (x != \"foo\"), x) == dynamic(binary())\n assert typecheck!([x], not (x !== \"foo\"), x) == dynamic(binary())\n end\n\n test \"with binaries\" do\n assert typecheck!([sep, token], token == <>, {sep, token}) ==\n dynamic(tuple([integer(), binary()]))\n end\n\n test \"with number literals\" do\n assert typecheck!([x], x == 1, x) == dynamic(union(integer(), float()))\n assert typecheck!([x], x === 1, x) == dynamic(integer())\n assert typecheck!([x], x in [1, 2, 3], x) == dynamic(integer())\n assert typecheck!([x], not (x == 1), x) == dynamic()\n assert typecheck!([x], not (x === 1), x) == dynamic()\n assert typecheck!([x], x not in [1, 2, 3], x) == dynamic()\n\n assert typecheck!([x], x != 1, x) == dynamic()\n assert typecheck!([x], x !== 1, x) == dynamic()\n assert typecheck!([x], not (x != 1), x) == dynamic(union(integer(), float()))\n assert typecheck!([x], not (x !== 1), x) == dynamic(integer())\n\n assert typecheck!([x], x == 1.0, x) == dynamic(union(integer(), float()))\n assert typecheck!([x], x === 1.0, x) == dynamic(float())\n assert typecheck!([x], x in [1.0, 2.0, 3.0], x) == dynamic(float())\n assert typecheck!([x], not (x == 1.0), x) == dynamic()\n assert typecheck!([x], not (x === 1.0), x) == dynamic()\n assert typecheck!([x], x not in [1.0, 2.0, 3.0], x) == dynamic()\n\n assert typecheck!([x], x != 1.0, x) == dynamic()\n assert typecheck!([x], x !== 1.0, x) == dynamic()\n assert typecheck!([x], not (x != 1.0), x) == dynamic(union(integer(), float()))\n assert typecheck!([x], not (x !== 1.0), x) == dynamic(float())\n end\n\n test \"with singleton literals\" do\n assert typecheck!([x], x == :foo, x) == dynamic(atom([:foo]))\n assert typecheck!([x], x === :foo, x) == dynamic(atom([:foo]))\n assert typecheck!([x], x in [:foo, :bar, :baz], x) == dynamic(atom([:foo, :bar, :baz]))\n assert typecheck!([x], not (x == :foo), x) == dynamic(negation(atom([:foo])))\n assert typecheck!([x], not (x === :foo), x) == dynamic(negation(atom([:foo])))\n assert typecheck!([x], x not in [:foo, :bar], x) == dynamic(negation(atom([:foo, :bar])))\n\n assert typecheck!([x], x != :foo, x) == dynamic(negation(atom([:foo])))\n assert typecheck!([x], x !== :foo, x) == dynamic(negation(atom([:foo])))\n assert typecheck!([x], not (x != :foo), x) == dynamic(atom([:foo]))\n assert typecheck!([x], not (x !== :foo), x) == dynamic(atom([:foo]))\n\n assert typecheck!([x], x == [], x) == dynamic(empty_list())\n assert typecheck!([x], x === [], x) == dynamic(empty_list())\n assert typecheck!([x], not (x == []), x) == dynamic(negation(empty_list()))\n assert typecheck!([x], not (x === []), x) == dynamic(negation(empty_list()))\n\n assert typecheck!([x], x != [], x) == dynamic(negation(empty_list()))\n assert typecheck!([x], x !== [], x) == dynamic(negation(empty_list()))\n assert typecheck!([x], not (x != []), x) == dynamic(empty_list())\n assert typecheck!([x], not (x !== []), x) == dynamic(empty_list())\n\n assert typecheck!([x], x != %{}, x) == dynamic(negation(empty_map()))\n assert typecheck!([x = %{}], x != %{}, x) == dynamic(difference(open_map(), empty_map()))\n end\n\n test \"mixed-in\" do\n assert typecheck!([x], x in [:foo, 1, :bar, 2.0, :baz], x) ==\n dynamic(union(atom([:foo, :bar, :baz]), union(integer(), float())))\n\n assert typecheck!([x], x not in [:foo, 1, :bar, 2.0, :baz], x) ==\n dynamic(negation(atom([:foo, :bar, :baz])))\n end\n\n test \"with singleton literals and composite types\" do\n assert typecheck!([x], x.key == :ok, x) == dynamic(open_map(key: atom([:ok])))\n assert typecheck!([x], hd(x) == :ok, x) == dynamic(non_empty_list(term(), term()))\n assert typecheck!([x], elem(x, 0) == :ok, x) == dynamic(open_tuple([atom([:ok])]))\n end\n\n test \"with expressions\" do\n # With numbers\n assert typecheck!([x, y], x == y and y === 42, {x, y}) ==\n dynamic(tuple([union(integer(), float()), integer()]))\n\n assert typecheck!([x, y], x == y and x === 42, {x, y}) ==\n dynamic(tuple([integer(), union(integer(), float())]))\n\n assert typecheck!([x, y], x != y and y === 42, {x, y}) ==\n dynamic(tuple([term(), integer()]))\n\n assert typecheck!([x, y], x === y and y === 42, {x, y}) ==\n dynamic(tuple([integer(), integer()]))\n\n assert typecheck!([x, y], x === y and x === 42, {x, y}) ==\n dynamic(tuple([integer(), integer()]))\n\n assert typecheck!([x, y], x !== y and y === 42, {x, y}) ==\n dynamic(tuple([term(), integer()]))\n\n # With non-singleton\n assert typecheck!([x, y], x == y and y === \"42\", {x, y}) ==\n dynamic(tuple([binary(), binary()]))\n\n assert typecheck!([x, y], x == y and x === \"42\", {x, y}) ==\n dynamic(tuple([binary(), binary()]))\n\n assert typecheck!([x, y], x != y and y === \"42\", {x, y}) ==\n dynamic(tuple([term(), binary()]))\n\n # With singleton\n assert typecheck!([x, y], x == y and y === :ok, {x, y}) ==\n dynamic(tuple([atom([:ok]), atom([:ok])]))\n\n assert typecheck!([x, y], x == y and x === :ok, {x, y}) ==\n dynamic(tuple([atom([:ok]), atom([:ok])]))\n\n assert typecheck!([x, y], x != y and y === :ok, {x, y}) ==\n dynamic(tuple([term(), atom([:ok])]))\n\n # With composite types\n assert typecheck!([x, y], x == {:ok, y} and y === 42, {x, y}) ==\n dynamic(tuple([tuple([atom([:ok]), union(integer(), float())]), integer()]))\n\n assert typecheck!([x, y], x != {:ok, y} and y === 42, {x, y}) ==\n dynamic(tuple([term(), integer()]))\n\n assert typecheck!([x, y], x == elem(y, 0) and y === {1, :ok}, {x, y}) ==\n dynamic(tuple([union(integer(), float()), tuple([integer(), atom([:ok])])]))\n\n assert typecheck!([x, y], x != elem(y, 0) and y === {1, :ok}, {x, y}) ==\n dynamic(tuple([term(), tuple([integer(), atom([:ok])])]))\n\n assert typecheck!([x, y], x == elem(y, 1) and y === {1, :ok}, {x, y}) ==\n dynamic(tuple([atom([:ok]), tuple([integer(), atom([:ok])])]))\n\n assert typecheck!([x, y], x != elem(y, 1) and y === {1, :ok}, {x, y}) ==\n dynamic(tuple([term(), tuple([integer(), atom([:ok])])]))\n end\n\n test \"warnings\" do\n assert typeerror!([x = {}], x == 0, x) =~ ~l\"\"\"\n the following pattern will never match:\n\n x = {}\n\n where \"x\" was given the type:\n\n # type: float() or integer()\n # from: types_test.ex:LINE\n x == 0\n \"\"\"\n\n assert typeerror!([x = {}], x == :foo, x) =~ ~l\"\"\"\n the following pattern will never match:\n\n x = {}\n\n where \"x\" was given the type:\n\n # type: :foo\n # from: types_test.ex:LINE\n x == :foo\n \"\"\"\n\n assert typeerror!([x = {}], not (x != :foo), x) =~ ~l\"\"\"\n the following pattern will never match:\n\n x = {}\n\n where \"x\" was given the type:\n\n # type: :foo\n # from: types_test.ex:LINE\n x != :foo\n \"\"\"\n\n # We cannot warn in this case because the inference itself will lead to disjoint types\n assert typecheck!([x = {}], not (x == :foo), x) == dynamic(tuple([]))\n assert typecheck!([x = {}], x != :foo, x) == dynamic(tuple([]))\n end\n end\n\n describe \"size comparison in guards\" do\n test \"length equality\" do\n assert typecheck!([x], length(x) != 0, x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], not (length(x) != 0), x) == dynamic(empty_list())\n\n assert typecheck!([x], 0 != length(x), x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], not (0 != length(x)), x) == dynamic(empty_list())\n end\n\n test \"length ordered\" do\n assert typecheck!([x], length(x) < 0, x) == dynamic(list(term()))\n assert typecheck!([x], length(x) >= 0, x) == dynamic(list(term()))\n assert typecheck!([x], length(x) <= 0, x) == dynamic(empty_list())\n\n assert typecheck!([x], 0 <= length(x), x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], 0 >= length(x), x) == dynamic(list(term()))\n assert typecheck!([x], 0 < length(x), x) == dynamic(list(term()))\n assert typecheck!([x], 0 > length(x), x) == dynamic(empty_list())\n\n assert typecheck!([x], not (length(x) > 0), x) == dynamic(empty_list())\n assert typecheck!([x], not (length(x) < 0), x) == dynamic(list(term()))\n assert typecheck!([x], not (length(x) >= 0), x) == dynamic(list(term()))\n assert typecheck!([x], not (length(x) <= 0), x) == dynamic(non_empty_list(term()))\n\n assert typecheck!([x], length(x) < 1, x) == dynamic(empty_list())\n\n assert typecheck!([x], length(x) > 2, x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], length(x) < 2, x) == dynamic(list(term()))\n assert typecheck!([x], length(x) >= 2, x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], length(x) <= 2, x) == dynamic(list(term()))\n\n assert typecheck!([x], 2 <= length(x), x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], 2 >= length(x), x) == dynamic(list(term()))\n assert typecheck!([x], 2 < length(x), x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], 2 > length(x), x) == dynamic(list(term()))\n\n assert typecheck!([x], not (length(x) > 2), x) == dynamic(list(term()))\n assert typecheck!([x], not (length(x) < 2), x) == dynamic(non_empty_list(term()))\n assert typecheck!([x], not (length(x) >= 2), x) == dynamic(list(term()))\n assert typecheck!([x], not (length(x) <= 2), x) == dynamic(non_empty_list(term()))\n end\n\n @non_empty_map difference(open_map(), empty_map())\n\n test \"map_size equality\" do\n assert typecheck!([x], map_size(x) == 0, x) == dynamic(empty_map())\n assert typecheck!([x], map_size(x) != 0, x) == dynamic(@non_empty_map)\n assert typecheck!([x], not (map_size(x) == 0), x) == dynamic(@non_empty_map)\n assert typecheck!([x], not (map_size(x) != 0), x) == dynamic(empty_map())\n\n assert typecheck!([x], 0 == map_size(x), x) == dynamic(empty_map())\n assert typecheck!([x], 0 != map_size(x), x) == dynamic(@non_empty_map)\n assert typecheck!([x], not (0 == map_size(x)), x) == dynamic(@non_empty_map)\n assert typecheck!([x], not (0 != map_size(x)), x) == dynamic(empty_map())\n end\n\n test \"map_size ordered\" do\n assert typecheck!([x], map_size(x) > 0, x) == dynamic(@non_empty_map)\n assert typecheck!([x], map_size(x) < 0, x) == dynamic(open_map())\n assert typecheck!([x], map_size(x) >= 0, x) == dynamic(open_map())\n assert typecheck!([x], map_size(x) <= 0, x) == dynamic(empty_map())\n\n assert typecheck!([x], 0 <= map_size(x), x) == dynamic(@non_empty_map)\n assert typecheck!([x], 0 >= map_size(x), x) == dynamic(open_map())\n assert typecheck!([x], 0 < map_size(x), x) == dynamic(open_map())\n assert typecheck!([x], 0 > map_size(x), x) == dynamic(empty_map())\n\n assert typecheck!([x], not (map_size(x) > 0), x) == dynamic(empty_map())\n assert typecheck!([x], not (map_size(x) < 0), x) == dynamic(open_map())\n assert typecheck!([x], not (map_size(x) >= 0), x) == dynamic(open_map())\n assert typecheck!([x], not (map_size(x) <= 0), x) == dynamic(@non_empty_map)\n\n assert typecheck!([x], map_size(x) < 1, x) == dynamic(empty_map())\n\n assert typecheck!([x], map_size(x) > 2, x) == dynamic(@non_empty_map)\n assert typecheck!([x], map_size(x) < 2, x) == dynamic(open_map())\n assert typecheck!([x], map_size(x) >= 2, x) == dynamic(@non_empty_map)\n assert typecheck!([x], map_size(x) <= 2, x) == dynamic(open_map())\n\n assert typecheck!([x], 2 <= map_size(x), x) == dynamic(@non_empty_map)\n assert typecheck!([x], 2 >= map_size(x), x) == dynamic(open_map())\n assert typecheck!([x], 2 < map_size(x), x) == dynamic(@non_empty_map)\n assert typecheck!([x], 2 > map_size(x), x) == dynamic(open_map())\n\n assert typecheck!([x], not (map_size(x) > 2), x) == dynamic(open_map())\n assert typecheck!([x], not (map_size(x) < 2), x) == dynamic(@non_empty_map)\n assert typecheck!([x], not (map_size(x) >= 2), x) == dynamic(open_map())\n assert typecheck!([x], not (map_size(x) <= 2), x) == dynamic(@non_empty_map)\n end\n\n @non_empty_tuple difference(open_tuple([]), tuple([]))\n @non_binary_tuple difference(open_tuple([]), tuple([term(), term()]))\n\n @open_binary_tuple open_tuple([term(), term()])\n @open_ternary_tuple open_tuple([term(), term(), term()])\n @non_open_binary_tuple difference(open_tuple([]), open_tuple([term(), term()]))\n @non_open_ternary_tuple difference(open_tuple([]), open_tuple([term(), term(), term()]))\n\n test \"tuple_size equality\" do\n assert typecheck!([x], tuple_size(x) == 0, x) == dynamic(tuple([]))\n assert typecheck!([x], tuple_size(x) != 0, x) == dynamic(@non_empty_tuple)\n assert typecheck!([x], not (tuple_size(x) == 0), x) == dynamic(@non_empty_tuple)\n assert typecheck!([x], not (tuple_size(x) != 0), x) == dynamic(tuple([]))\n\n assert typecheck!([x], 0 == tuple_size(x), x) == dynamic(tuple([]))\n assert typecheck!([x], 0 != tuple_size(x), x) == dynamic(@non_empty_tuple)\n assert typecheck!([x], not (0 == tuple_size(x)), x) == dynamic(@non_empty_tuple)\n assert typecheck!([x], not (0 != tuple_size(x)), x) == dynamic(tuple([]))\n\n assert typecheck!([x], tuple_size(x) == 2, x) == dynamic(tuple([term(), term()]))\n assert typecheck!([x], tuple_size(x) != 2, x) == dynamic(@non_binary_tuple)\n assert typecheck!([x], not (tuple_size(x) == 2), x) == dynamic(@non_binary_tuple)\n assert typecheck!([x], not (tuple_size(x) != 2), x) == dynamic(tuple([term(), term()]))\n\n assert typecheck!([x], 2 == tuple_size(x), x) == dynamic(tuple([term(), term()]))\n assert typecheck!([x], 2 != tuple_size(x), x) == dynamic(@non_binary_tuple)\n assert typecheck!([x], not (2 == tuple_size(x)), x) == dynamic(@non_binary_tuple)\n assert typecheck!([x], not (2 != tuple_size(x)), x) == dynamic(tuple([term(), term()]))\n end\n\n test \"tuple_size ordered\" do\n assert typecheck!([x], tuple_size(x) > 0, x) == dynamic(open_tuple([term()]))\n assert typecheck!([x], tuple_size(x) < 0, x) == dynamic(open_tuple([]))\n assert typecheck!([x], tuple_size(x) >= 0, x) == dynamic(open_tuple([]))\n assert typecheck!([x], tuple_size(x) <= 0, x) == dynamic(tuple([]))\n\n assert typecheck!([x], 0 <= tuple_size(x), x) == dynamic(open_tuple([term()]))\n assert typecheck!([x], 0 >= tuple_size(x), x) == dynamic(open_tuple([]))\n assert typecheck!([x], 0 < tuple_size(x), x) == dynamic(open_tuple([]))\n assert typecheck!([x], 0 > tuple_size(x), x) == dynamic(tuple([]))\n\n assert typecheck!([x], not (tuple_size(x) > 0), x) == dynamic(tuple([]))\n assert typecheck!([x], not (tuple_size(x) < 0), x) == dynamic(open_tuple([]))\n assert typecheck!([x], not (tuple_size(x) >= 0), x) == dynamic(open_tuple([]))\n assert typecheck!([x], not (tuple_size(x) <= 0), x) == dynamic(open_tuple([term()]))\n\n assert typecheck!([x], tuple_size(x) > 2, x) == dynamic(@open_ternary_tuple)\n assert typecheck!([x], tuple_size(x) < 2, x) == dynamic(@non_open_binary_tuple)\n assert typecheck!([x], tuple_size(x) >= 2, x) == dynamic(@open_binary_tuple)\n assert typecheck!([x], tuple_size(x) <= 2, x) == dynamic(@non_open_ternary_tuple)\n\n assert typecheck!([x], 2 <= tuple_size(x), x) == dynamic(@open_ternary_tuple)\n assert typecheck!([x], 2 >= tuple_size(x), x) == dynamic(@non_open_binary_tuple)\n assert typecheck!([x], 2 < tuple_size(x), x) == dynamic(@open_binary_tuple)\n assert typecheck!([x], 2 > tuple_size(x), x) == dynamic(@non_open_ternary_tuple)\n\n assert typecheck!([x], not (tuple_size(x) > 2), x) == dynamic(@non_open_ternary_tuple)\n assert typecheck!([x], not (tuple_size(x) < 2), x) == dynamic(@open_binary_tuple)\n assert typecheck!([x], not (tuple_size(x) >= 2), x) == dynamic(@non_open_binary_tuple)\n assert typecheck!([x], not (tuple_size(x) <= 2), x) == dynamic(@open_ternary_tuple)\n end\n end\n\n describe \"precision\" do\n test \"literals in patterns\" do\n assert precise?([:ok])\n refute precise?([123])\n refute precise?([123.0])\n refute precise?([\"string\"])\n end\n\n test \"variables in patterns\" do\n assert precise?([x])\n assert precise?([x, y])\n refute precise?([x, x])\n end\n\n test \"bitstrings in patterns\" do\n assert precise?([<<_::binary>>])\n assert precise?([<<_::bytes>>])\n assert precise?([<<_::bitstring>>])\n assert precise?([<<_::bits>>])\n assert precise?([<<(<<_::binary>>)::bits>>])\n\n refute precise?([<<>>])\n refute precise?([<<1, _::binary>>])\n refute precise?([<<1, _::bitstring>>])\n refute precise?([<<_::binary-size(8)>>])\n refute precise?([<<_::bitstring-size(8)>>])\n refute precise?([<<(<<123>>)::bits>>])\n end\n\n test \"tuples in patterns\" do\n assert precise?([{:ok, _}])\n refute precise?([{:ok, 123}])\n end\n\n test \"maps in patterns\" do\n assert precise?([%{ok: _}])\n assert precise?([%URI{path: _}])\n\n refute precise?([%{ok: 123}])\n refute precise?([%{\"foo\" => _}])\n end\n\n test \"lists in patterns\" do\n assert precise?([[]])\n assert precise?([[_ | _]])\n assert precise?([x, [y | z]])\n\n refute precise?([[x | y]], is_integer(x))\n refute precise?([[x | x]])\n refute precise?([x, [x | y]])\n\n refute precise?([[:ok | _]])\n refute precise?([[_ | :ok]])\n end\n\n test \"guards\" do\n assert precise?([x], is_integer(x))\n assert precise?([x], not is_integer(x))\n assert precise?([x], is_integer(x) or is_boolean(x))\n assert precise?([x], x == :ok or x == :error)\n assert precise?([x], x.key == :ok)\n assert precise?([x], elem(x, 0) == :ok)\n assert precise?([x], :erlang.map_get(:key, x) == :ok)\n assert precise?([x], x != :ok)\n assert precise?([x], not (x == :ok))\n assert precise?([x], x.key != :ok)\n assert precise?([x], not (x.key != :ok))\n assert precise?([x, y], x == :ok and y == :error)\n\n refute precise?([x, y], x == y)\n refute precise?([x], x == 123)\n refute precise?([x], x == 123.0)\n refute precise?([x], x > 123)\n refute precise?([x], x > :ok)\n refute precise?([x, y], x == hd(y))\n refute precise?([x], hd(x) == :ok)\n refute precise?([x, y], x == :ok and y == 123)\n refute precise?([x, y], x == :ok or y == :error)\n refute precise?([x], x <= 0 or x == :infinity)\n end\n\n test \"when guards\" do\n assert precise?([x, y], is_integer(x) when is_binary(x))\n refute precise?([x, y], is_integer(x) when is_binary(y))\n end\n\n test \"sized guards\" do\n # Tuples: everything goes\n assert precise?([x], tuple_size(x) == 0)\n assert precise?([x], tuple_size(x) != 0)\n assert precise?([x], tuple_size(x) > 0)\n assert precise?([x], tuple_size(x) >= 0)\n assert precise?([x], tuple_size(x) > 10)\n assert precise?([x], tuple_size(x) < 10)\n\n # Lists: only when compared to 0\n assert precise?([x], not (length(x) == 0))\n assert precise?([x], length(x) != 0)\n assert precise?([x], not (length(x) > 0))\n assert precise?([x], length(x) >= 0)\n assert precise?([x], length(x) < 1)\n\n refute precise?([x], length(x) == 1)\n refute precise?([x], length(x) != 1)\n refute precise?([x], length(x) > 1)\n refute precise?([x], length(x) <= 3)\n\n # Maps: only when compared to 0\n assert precise?([x], map_size(x) == 0)\n assert precise?([x], map_size(x) != 0)\n assert precise?([x], map_size(x) > 0)\n assert precise?([x], map_size(x) >= 0)\n assert precise?([x], map_size(x) < 1)\n\n refute precise?([x], map_size(x) == 1)\n refute precise?([x], map_size(x) != 1)\n refute precise?([x], map_size(x) > 1)\n refute precise?([x], map_size(x) <= 3)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module/types/type_helper.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../../test_helper.exs\", __DIR__)\n\ndefmodule Point do\n defstruct [:x, :y, z: 0]\nend\n\ndefmodule TypeHelper do\n alias Module.Types\n alias Module.Types.{Pattern, Expr, Descr}\n\n @doc \"\"\"\n Main helper for checking the precise of pattern plus guards.\n \"\"\"\n defmacro precise?(patterns, guards \\\\ true) do\n quote do\n unquote(precise(patterns, guards, __CALLER__))\n end\n end\n\n @doc \"\"\"\n Main helper for checking the given AST type checks without warnings in dynamic mode.\n \"\"\"\n defmacro typedyn!(patterns \\\\ [], guards \\\\ true, body) do\n quote do\n unquote(typecheck(:dynamic, patterns, guards, body, __CALLER__))\n |> TypeHelper.__typecheck__!()\n end\n end\n\n @doc \"\"\"\n Main helper for checking the given AST type checks without warnings in static mode.\n \"\"\"\n defmacro typecheck!(patterns \\\\ [], guards \\\\ true, body) do\n quote do\n unquote(typecheck(:static, patterns, guards, body, __CALLER__))\n |> TypeHelper.__typecheck__!()\n end\n end\n\n @doc \"\"\"\n Main helper for checking the given AST type checks errors.\n \"\"\"\n defmacro typeerror!(patterns \\\\ [], guards \\\\ true, body) do\n [patterns, guards, body] = prune_columns([patterns, guards, body])\n\n quote do\n unquote(typecheck(:static, patterns, guards, body, __CALLER__))\n |> TypeHelper.__typeerror__!()\n end\n end\n\n @doc \"\"\"\n Main helper for checking the given AST type warns.\n \"\"\"\n defmacro typewarn!(patterns \\\\ [], guards \\\\ true, body) do\n [patterns, guards, body] = prune_columns([patterns, guards, body])\n\n quote do\n unquote(typecheck(:static, patterns, guards, body, __CALLER__))\n |> TypeHelper.__typewarn__!()\n end\n end\n\n @doc \"\"\"\n Main helper for checking the diagnostic of a given AST.\n \"\"\"\n defmacro typediag!(patterns \\\\ [], guards \\\\ true, body) do\n quote do\n unquote(typecheck(:static, patterns, guards, body, __CALLER__))\n |> TypeHelper.__typediag__!()\n end\n end\n\n @doc false\n def __typecheck__!({type, %{warnings: []}}), do: type\n\n def __typecheck__!({_type, %{warnings: warnings, failed: false}}),\n do: raise(\"type checking ok but with warnings: #{inspect(warnings)}\")\n\n def __typecheck__!({_type, %{warnings: warnings, failed: true}}),\n do: raise(\"type checking errored with warnings: #{inspect(warnings)}\")\n\n @doc false\n def __typeerror__!({_type, %{warnings: [{module, warning, _locs} | _], failed: true}}),\n do: module.format_diagnostic(warning).message\n\n def __typeerror__!({_type, %{warnings: warnings, failed: false}}),\n do: raise(\"type checking with warnings but expected error: #{inspect(warnings)}\")\n\n def __typeerror__!({type, _}),\n do: raise(\"type checking ok but expected error: #{Descr.to_quoted_string(type)}\")\n\n @doc false\n def __typediag__!({type, %{warnings: [_ | _] = warnings}}),\n do: {type, for({module, arg, _} <- warnings, do: module.format_diagnostic(arg))}\n\n def __typediag__!({type, %{warnings: []}}),\n do: raise(\"type checking without diagnostics: #{Descr.to_quoted_string(type)}\")\n\n @doc false\n def __typewarn__!({type, %{warnings: [{module, warning, _locs}], failed: false}}),\n do: {type, module.format_diagnostic(warning).message}\n\n def __typewarn__!({type, %{warnings: []}}),\n do: raise(\"type checking ok without warnings: #{Descr.to_quoted_string(type)}\")\n\n def __typewarn__!({_type, %{warnings: warnings, failed: false}}),\n do: raise(\"type checking ok but many warnings: #{inspect(warnings)}\")\n\n def __typewarn__!({_type, %{warnings: warnings, failed: true}}),\n do: raise(\"type checking errored with warnings: #{inspect(warnings)}\")\n\n defp typecheck(mode, patterns, guards, body, env) do\n {patterns, guards, body} = expand_and_unpack(patterns, guards, body, env)\n\n quote do\n TypeHelper.__typecheck__(\n unquote(mode),\n unquote(Macro.escape(patterns)),\n unquote(Macro.escape(guards)),\n unquote(Macro.escape(body))\n )\n end\n end\n\n defp precise(patterns, guards, env) do\n {_, vars} =\n Macro.prewalk(patterns, [], fn\n {:\"::\", _, [left, _right]}, acc ->\n {left, acc}\n\n {name, _, ctx} = var, acc when is_atom(ctx) and name != :_ ->\n {var, [var | acc]}\n\n node, acc ->\n {node, acc}\n end)\n\n {patterns, guards, _body} = expand_and_unpack(patterns, guards, vars, env)\n\n quote do\n TypeHelper.__precise__?(\n unquote(Macro.escape(patterns)),\n unquote(Macro.escape(guards))\n )\n end\n end\n\n def __precise__?(patterns, guards) do\n stack = new_stack(:static)\n expected = Enum.map(patterns, fn _ -> Descr.dynamic() end)\n init_previous = Pattern.init_previous()\n tag = {:fn, patterns}\n\n {_trees, previous, _context} =\n Pattern.of_head(patterns, guards, expected, init_previous, tag, [], stack, new_context())\n\n previous != init_previous\n end\n\n def __typecheck__(mode, patterns, guards, body) do\n stack = new_stack(mode)\n expected = Enum.map(patterns, fn _ -> Descr.dynamic() end)\n previous = Pattern.init_previous()\n tag = {:fn, patterns}\n\n {_trees, _precise?, context} =\n Pattern.of_head(patterns, guards, expected, previous, tag, [], stack, new_context())\n\n Expr.of_expr(body, Descr.term(), :ok, stack, context)\n end\n\n defp expand_and_unpack(patterns, guards, body, env) do\n fun =\n quote do\n fn unquote_splicing(patterns) when unquote(guards) -> unquote(body) end\n end\n\n {ast, _, _} = :elixir_expand.expand(fun, :elixir_env.env_to_ex(env), env)\n {:fn, _, [{:->, _, [[{:when, _, args}], body]}]} = ast\n {patterns, [guards]} = Enum.split(args, -1)\n {patterns, flatten_when(guards), body}\n end\n\n defp flatten_when({:when, _meta, [left, right]}), do: [left | flatten_when(right)]\n defp flatten_when(other), do: [other]\n\n defp new_stack(mode) do\n cache =\n if mode == :infer do\n :none\n else\n {:ok, cache} = Module.ParallelChecker.start_link()\n cache\n end\n\n handler = fn _, fun_arity, _, _ -> raise \"no local lookup for: #{inspect(fun_arity)}\" end\n Types.stack(mode, \"types_test.ex\", TypesTest, {:test, 0}, [], cache, handler)\n end\n\n defp new_context() do\n Types.context()\n end\n\n @doc \"\"\"\n Interpolate the given hints.\n \"\"\"\n def hints(hints) do\n hints\n |> List.wrap()\n |> Module.Types.Helpers.format_hints()\n |> IO.iodata_to_binary()\n |> String.trim()\n end\n\n @doc \"\"\"\n A string-like sigil that replaces LINE references by actual line.\n \"\"\"\n defmacro sigil_l({:<<>>, meta, parts}, []) do\n parts =\n for part <- parts do\n if is_binary(part) do\n part\n |> replace_line(__CALLER__.line)\n |> :elixir_interpolation.unescape_string()\n else\n part\n end\n end\n\n {:<<>>, meta, parts}\n end\n\n @strip_ansi [IO.ANSI.green(), IO.ANSI.red(), IO.ANSI.reset()]\n\n @doc \"\"\"\n Strip ansi escapes from message.\n \"\"\"\n def strip_ansi(doc) do\n String.replace(doc, @strip_ansi, \"\")\n end\n\n defp replace_line(string, line) do\n [head | rest] = String.split(string, \"LINE\")\n\n rest =\n for part <- rest do\n case part do\n <> when num in ?0..?9 ->\n [Integer.to_string(line - num + ?0), part]\n\n part ->\n [Integer.to_string(line), part]\n end\n end\n\n IO.iodata_to_binary([head | rest])\n end\n\n defp prune_columns(ast) do\n Macro.prewalk(ast, fn node ->\n Macro.update_meta(node, &Keyword.delete(&1, :column))\n end)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/module_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule ModuleTest.ToBeUsed do\n def value, do: 1\n\n defmacro __using__(_) do\n target = __CALLER__.module\n Module.put_attribute(target, :has_callback, true)\n Module.put_attribute(target, :before_compile, __MODULE__)\n Module.put_attribute(target, :after_compile, __MODULE__)\n Module.put_attribute(target, :before_compile, {__MODULE__, :callback})\n quote(do: def(line, do: __ENV__.line))\n end\n\n defmacro __before_compile__(env) do\n quote(do: def(before_compile, do: unquote(Macro.Env.vars(env))))\n end\n\n defmacro __after_compile__(%Macro.Env{module: ModuleTest.ToUse} = env, bin)\n when is_binary(bin) do\n # Ensure module is not longer tracked as being loaded\n false = __MODULE__ in :elixir_module.compiler_modules()\n [] = Macro.Env.vars(env)\n :ok\n end\n\n defmacro callback(env) do\n value = Module.get_attribute(env.module, :has_callback)\n\n quote do\n def callback_value(true), do: unquote(value)\n end\n end\nend\n\ndefmodule ModuleTest.ToUse do\n # Moving the next line around can make tests fail\n 42 = __ENV__.line\n var = 1\n # Not available in callbacks\n _ = var\n def callback_value(false), do: false\n use ModuleTest.ToBeUsed\nend\n\ndefmodule ModuleTest do\n use ExUnit.Case, async: true\n\n doctest Module\n\n Module.register_attribute(__MODULE__, :register_unset_example, persist: true)\n Module.register_attribute(__MODULE__, :register_empty_example, accumulate: true, persist: true)\n Module.register_attribute(__MODULE__, :register_example, accumulate: true, persist: true)\n @register_example :it_works\n @register_example :still_works\n\n defp purge(module) do\n :code.purge(module)\n :code.delete(module)\n end\n\n defmacrop in_module(block) do\n quote do\n defmodule(Temp, unquote(block))\n purge(Temp)\n end\n end\n\n test \"module attributes returns value\" do\n in_module do\n assert @return([:foo, :bar]) == :ok\n _ = @return\n end\n end\n\n test \"raises on write access attempts from __after_compile__/2\" do\n contents =\n quote do\n @after_compile __MODULE__\n\n def __after_compile__(%Macro.Env{module: module}, bin) when is_binary(bin) do\n Module.put_attribute(module, :foo, 42)\n end\n end\n\n assert_raise ArgumentError,\n \"could not call Module.put_attribute/3 because the module ModuleTest.Raise is in read-only mode (@after_compile)\",\n fn ->\n Module.create(ModuleTest.Raise, contents, __ENV__)\n end\n end\n\n test \"supports read access to module from __after_compile__/2\" do\n defmodule ModuleTest.NoRaise do\n @after_compile __MODULE__\n @foo 42\n\n def __after_compile__(%Macro.Env{module: module}, bin) when is_binary(bin) do\n send(self(), Module.get_attribute(module, :foo))\n end\n end\n\n assert_received 42\n end\n\n test \"supports @after_verify for inlined modules\" do\n defmodule ModuleTest.AfterVerify do\n @after_verify __MODULE__\n\n def __after_verify__(ModuleTest.AfterVerify) do\n send(self(), ModuleTest.AfterVerify)\n end\n end\n\n assert_received ModuleTest.AfterVerify\n end\n\n test \"in memory modules are tagged as so\" do\n assert :code.which(__MODULE__) == ~c\"\"\n end\n\n ## Callbacks\n\n test \"retrieves line from use callsite\" do\n assert ModuleTest.ToUse.line() == 47\n end\n\n test \"executes custom before_compile callback\" do\n assert ModuleTest.ToUse.callback_value(true) == true\n assert ModuleTest.ToUse.callback_value(false) == false\n end\n\n test \"executes default before_compile callback\" do\n assert ModuleTest.ToUse.before_compile() == []\n end\n\n def __on_definition__(env, kind, name, args, guards, expr) do\n Process.put(env.module, {args, guards, expr})\n assert env.module == ModuleTest.OnDefinition\n assert kind == :def\n assert name == :hello\n assert Module.defines?(env.module, {:hello, 2})\n end\n\n test \"executes on definition callback\" do\n defmodule OnDefinition do\n @on_definition ModuleTest\n\n def hello(foo, bar)\n\n assert {[{:foo, _, _}, {:bar, _, _}], [], nil} = Process.get(ModuleTest.OnDefinition)\n\n def hello(foo, bar) do\n foo + bar\n end\n\n assert {[{:foo, _, _}, {:bar, _, _}], [], [do: {:+, _, [{:foo, _, nil}, {:bar, _, nil}]}]} =\n Process.get(ModuleTest.OnDefinition)\n end\n end\n\n defmacro __before_compile__(_) do\n quote do\n def constant, do: 1\n defoverridable constant: 0\n end\n end\n\n test \"may set overridable inside before_compile callback\" do\n defmodule OverridableWithBeforeCompile do\n @before_compile ModuleTest\n end\n\n assert OverridableWithBeforeCompile.constant() == 1\n end\n\n describe \"__info__(:attributes)\" do\n test \"reserved attributes\" do\n assert List.keyfind(ExUnit.Server.__info__(:attributes), :behaviour, 0) ==\n {:behaviour, [GenServer]}\n end\n\n test \"registered attributes\" do\n assert Enum.filter(__MODULE__.__info__(:attributes), &match?({:register_example, _}, &1)) ==\n [{:register_example, [:it_works]}, {:register_example, [:still_works]}]\n end\n\n test \"registered attributes with no values are not present\" do\n refute List.keyfind(__MODULE__.__info__(:attributes), :register_unset_example, 0)\n refute List.keyfind(__MODULE__.__info__(:attributes), :register_empty_example, 0)\n end\n end\n\n @some_attribute [1]\n @other_attribute [3, 2, 1]\n\n test \"inside function attributes\" do\n assert @some_attribute == [1]\n assert @other_attribute == [3, 2, 1]\n end\n\n ## Naming\n\n test \"concat\" do\n assert Module.concat(Foo, Bar) == Foo.Bar\n assert Module.concat(Foo, :Bar) == Foo.Bar\n assert Module.concat(Foo, \"Bar\") == Foo.Bar\n assert Module.concat(Foo, Bar.Baz) == Foo.Bar.Baz\n assert Module.concat(Foo, \"Bar.Baz\") == Foo.Bar.Baz\n assert Module.concat(Bar, nil) == Elixir.Bar\n end\n\n test \"safe concat\" do\n assert Module.safe_concat(Foo, :Bar) == Foo.Bar\n\n assert_raise ArgumentError, fn ->\n Module.safe_concat(SafeConcat, Doesnt.Exist)\n end\n end\n\n test \"split\" do\n module = Very.Long.Module.Name.And.Even.Longer\n assert Module.split(module) == [\"Very\", \"Long\", \"Module\", \"Name\", \"And\", \"Even\", \"Longer\"]\n assert Module.split(\"Elixir.Very.Long\") == [\"Very\", \"Long\"]\n\n assert_raise ArgumentError, \"expected an Elixir module, got: :just_an_atom\", fn ->\n Module.split(:just_an_atom)\n end\n\n assert_raise ArgumentError, \"expected an Elixir module, got: \\\"Foo\\\"\", fn ->\n Module.split(\"Foo\")\n end\n\n assert Module.concat(Module.split(module)) == module\n end\n\n test \"__MODULE__\" do\n assert Code.eval_string(\"__MODULE__.Foo\") |> elem(0) == Foo\n end\n\n test \"__ENV__.file\" do\n assert Path.basename(__ENV__.file) == \"module_test.exs\"\n end\n\n @file \"sample.ex\"\n test \"@file sets __ENV__.file\" do\n assert __ENV__.file == Path.absname(\"sample.ex\")\n end\n\n test \"@file raises when invalid\" do\n assert_raise ArgumentError, ~r\"@file is a built-in module attribute\", fn ->\n defmodule BadFile do\n @file :oops\n def my_fun, do: :ok\n end\n end\n end\n\n ## Creation\n\n test \"defmodule\" do\n result =\n defmodule Defmodule do\n 1 + 2\n end\n\n assert {:module, Defmodule, binary, 3} = result\n assert is_binary(binary)\n end\n\n test \"defmodule with atom\" do\n result =\n defmodule :root_defmodule do\n :ok\n end\n\n assert {:module, :root_defmodule, _, _} = result\n end\n\n test \"does not leak alias from atom\" do\n defmodule :\"Elixir.ModuleTest.RawModule\" do\n def hello, do: :world\n end\n\n refute __ENV__.aliases[Elixir.ModuleTest]\n refute __ENV__.aliases[Elixir.RawModule]\n assert ModuleTest.RawModule.hello() == :world\n end\n\n test \"does not leak alias from non-atom alias\" do\n defmodule __MODULE__.NonAtomAlias do\n def hello, do: :world\n end\n\n refute __ENV__.aliases[Elixir.ModuleTest]\n refute __ENV__.aliases[Elixir.NonAtomAlias]\n assert Elixir.ModuleTest.NonAtomAlias.hello() == :world\n end\n\n test \"does not leak alias from Elixir root alias\" do\n defmodule Elixir.ModuleTest.ElixirRootAlias do\n def hello, do: :world\n end\n\n refute __ENV__.aliases[Elixir.ModuleTest]\n refute __ENV__.aliases[Elixir.ElixirRootAlias]\n assert Elixir.ModuleTest.ElixirRootAlias.hello() == :world\n end\n\n test \"does not warn on captured underscored vars\" do\n _unused = 123\n\n defmodule __MODULE__.NoVarWarning do\n end\n end\n\n @compile {:no_warn_undefined, ModuleCreateSample}\n\n test \"create\" do\n contents =\n quote do\n def world, do: true\n end\n\n {:module, ModuleCreateSample, _, _} = Module.create(ModuleCreateSample, contents, __ENV__)\n assert ModuleCreateSample.world()\n end\n\n test \"create with a reserved module name\" do\n contents =\n quote do\n def world, do: true\n end\n\n assert_raise CompileError, ~r/cannot compile module Elixir/, fn ->\n Code.with_diagnostics(fn ->\n Module.create(Elixir, contents, __ENV__)\n end)\n end\n end\n\n @compile {:no_warn_undefined, ModuleTracersSample}\n\n test \"create with propagated tracers\" do\n contents =\n quote do\n def world, do: true\n end\n\n env = %{__ENV__ | tracers: [:invalid]}\n {:module, ModuleTracersSample, _, _} = Module.create(ModuleTracersSample, contents, env)\n assert ModuleTracersSample.world()\n end\n\n @compile {:no_warn_undefined, ModuleHygiene}\n\n test \"create with aliases/var hygiene\" do\n contents =\n quote do\n alias List, as: L\n\n def test do\n L.flatten([1, [2], 3])\n end\n end\n\n Module.create(ModuleHygiene, contents, __ENV__)\n assert ModuleHygiene.test() == [1, 2, 3]\n end\n\n test \"ensure function clauses are sorted (to avoid non-determinism in module vsn)\" do\n {_, _, binary, _} =\n defmodule Ordered do\n def foo(:foo), do: :bar\n def baz(:baz), do: :bat\n end\n\n {:ok, {ModuleTest.Ordered, [abstract_code: {:raw_abstract_v1, abstract_code}]}} =\n :beam_lib.chunks(binary, [:abstract_code])\n\n # We need to traverse functions instead of using :exports as exports are sorted\n funs = for {:function, _, name, arity, _} <- abstract_code, do: {name, arity}\n assert funs == [__info__: 1, baz: 1, foo: 1]\n end\n\n @compile {:no_warn_undefined, ModuleCreateGenerated}\n\n test \"create with generated true does not emit warnings\" do\n contents =\n quote generated: true do\n def world, do: true\n def world, do: false\n end\n\n {:module, ModuleCreateGenerated, _, _} =\n Module.create(ModuleCreateGenerated, contents, __ENV__)\n\n assert ModuleCreateGenerated.world()\n end\n\n test \"uses the debug_info chunk\" do\n {:module, ModuleCreateDebugInfo, binary, _} =\n Module.create(ModuleCreateDebugInfo, :ok, __ENV__)\n\n {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} =\n :beam_lib.chunks(binary, [:debug_info])\n\n {:ok, map} = backend.debug_info(:elixir_v1, ModuleCreateDebugInfo, data, [])\n assert map.module == ModuleCreateDebugInfo\n end\n\n test \"uses the debug_info chunk when explicitly set to true\" do\n {:module, ModuleCreateDebugInfoTrue, binary, _} =\n Module.create(ModuleCreateDebugInfoTrue, quote(do: @compile({:debug_info, true})), __ENV__)\n\n {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} =\n :beam_lib.chunks(binary, [:debug_info])\n\n {:ok, map} = backend.debug_info(:elixir_v1, ModuleCreateDebugInfoTrue, data, [])\n assert map.module == ModuleCreateDebugInfoTrue\n end\n\n test \"uses the debug_info chunk even if debug_info is set to false\" do\n {:module, ModuleCreateNoDebugInfo, binary, _} =\n Module.create(ModuleCreateNoDebugInfo, quote(do: @compile({:debug_info, false})), __ENV__)\n\n {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} =\n :beam_lib.chunks(binary, [:debug_info])\n\n assert backend.debug_info(:elixir_v1, ModuleCreateNoDebugInfo, data, []) == {:error, :missing}\n end\n\n test \"compiles to core\" do\n import PathHelpers\n\n write_beam(\n defmodule ExampleModule do\n end\n )\n\n {:ok, {ExampleModule, [{~c\"Dbgi\", dbgi}]}} =\n ExampleModule |> :code.which() |> :beam_lib.chunks([~c\"Dbgi\"])\n\n {:debug_info_v1, backend, data} = :erlang.binary_to_term(dbgi)\n {:ok, core} = backend.debug_info(:core_v1, ExampleModule, data, [])\n assert is_tuple(core)\n end\n\n test \"no function in module body\" do\n in_module do\n assert __ENV__.function == nil\n end\n end\n\n test \"does not use ETS tables named after the module\" do\n in_module do\n assert :ets.info(__MODULE__) == :undefined\n end\n end\n\n ## Definitions\n\n test \"defines?\" do\n in_module do\n refute Module.defines?(__MODULE__, {:foo, 0})\n def foo(), do: bar()\n assert Module.defines?(__MODULE__, {:foo, 0})\n assert Module.defines?(__MODULE__, {:foo, 0}, :def)\n\n refute Module.defines?(__MODULE__, {:bar, 0}, :defp)\n defp bar(), do: :ok\n assert Module.defines?(__MODULE__, {:bar, 0}, :defp)\n\n refute Module.defines?(__MODULE__, {:baz, 0}, :defmacro)\n defmacro baz(), do: :ok\n assert Module.defines?(__MODULE__, {:baz, 0}, :defmacro)\n end\n end\n\n test \"definitions in\" do\n in_module do\n defp bar(), do: :ok\n def foo(1, 2, 3), do: bar()\n\n defmacrop macro_bar(), do: 4\n defmacro macro_foo(1, 2, 3), do: macro_bar()\n\n assert Module.definitions_in(__MODULE__) |> Enum.sort() ==\n [{:bar, 0}, {:foo, 3}, {:macro_bar, 0}, {:macro_foo, 3}]\n\n assert Module.definitions_in(__MODULE__, :def) == [foo: 3]\n assert Module.definitions_in(__MODULE__, :defp) == [bar: 0]\n assert Module.definitions_in(__MODULE__, :defmacro) == [macro_foo: 3]\n assert Module.definitions_in(__MODULE__, :defmacrop) == [macro_bar: 0]\n\n defoverridable foo: 3\n\n assert Module.definitions_in(__MODULE__) |> Enum.sort() ==\n [{:bar, 0}, {:macro_bar, 0}, {:macro_foo, 3}]\n\n assert Module.definitions_in(__MODULE__, :def) == []\n end\n end\n\n test \"get_definition/2 and delete_definition/2\" do\n in_module do\n def foo(a, b), do: a + b\n\n assert {:v1, :def, def_meta,\n [\n {clause_meta, [{:a, _, nil}, {:b, _, nil}], [],\n {{:., _, [:erlang, :+]}, _, [{:a, _, nil}, {:b, _, nil}]}}\n ]} = Module.get_definition(__MODULE__, {:foo, 2})\n\n assert [line: _, column: _] = Keyword.take(def_meta, [:line, :column])\n assert [line: _, column: _] = Keyword.take(clause_meta, [:line, :column])\n assert {:v1, :def, _, []} = Module.get_definition(__MODULE__, {:foo, 2}, skip_clauses: true)\n\n assert Module.delete_definition(__MODULE__, {:foo, 2})\n assert Module.get_definition(__MODULE__, {:foo, 2}) == nil\n refute Module.delete_definition(__MODULE__, {:foo, 2})\n end\n end\n\n test \"make_overridable/2 with invalid arguments\" do\n contents =\n quote do\n Module.make_overridable(__MODULE__, [{:foo, 256}])\n end\n\n message =\n \"each element in tuple list has to be a {function_name :: atom, arity :: 0..255} \" <>\n \"tuple, got: {:foo, 256}\"\n\n assert_raise ArgumentError, message, fn ->\n Module.create(MakeOverridable, contents, __ENV__)\n end\n after\n purge(MakeOverridable)\n end\n\n test \"raise when called with already compiled module\" do\n message =\n \"could not call Module.get_attribute/2 because the module Enum is already compiled. \" <>\n \"Use the Module.__info__/1 callback or Code.fetch_docs/1 instead\"\n\n assert_raise ArgumentError, message, fn ->\n Module.get_attribute(Enum, :moduledoc)\n end\n end\n\n describe \"get_attribute/3\" do\n test \"returns a list when the attribute is marked as `accumulate: true`\" do\n in_module do\n Module.register_attribute(__MODULE__, :value, accumulate: true)\n assert Module.get_attribute(__MODULE__, :value) == []\n Module.put_attribute(__MODULE__, :value, 1)\n assert Module.get_attribute(__MODULE__, :value) == [1]\n Module.put_attribute(__MODULE__, :value, 2)\n assert Module.get_attribute(__MODULE__, :value) == [2, 1]\n end\n end\n\n test \"returns the value of the attribute if it exists\" do\n in_module do\n Module.put_attribute(__MODULE__, :attribute, 1)\n assert Module.get_attribute(__MODULE__, :attribute) == 1\n assert Module.get_attribute(__MODULE__, :attribute, :default) == 1\n Module.put_attribute(__MODULE__, :attribute, nil)\n assert Module.get_attribute(__MODULE__, :attribute, :default) == nil\n end\n end\n\n test \"returns the value of the attribute if persisted\" do\n in_module do\n Module.register_attribute(__MODULE__, :value, persist: true)\n assert Module.get_attribute(__MODULE__, :value, 123) == 123\n Module.put_attribute(__MODULE__, :value, 1)\n assert Module.get_attribute(__MODULE__, :value) == 1\n Module.put_attribute(__MODULE__, :value, 2)\n assert Module.get_attribute(__MODULE__, :value) == 2\n Module.delete_attribute(__MODULE__, :value)\n assert Module.get_attribute(__MODULE__, :value, 123) == 123\n end\n end\n\n test \"returns the passed default if the attribute does not exist\" do\n in_module do\n assert Module.get_attribute(__MODULE__, :attribute, :default) == :default\n end\n end\n end\n\n describe \"get_last_attribute/3\" do\n test \"returns the last set value when the attribute is marked as `accumulate: true`\" do\n in_module do\n Module.register_attribute(__MODULE__, :value, accumulate: true)\n Module.put_attribute(__MODULE__, :value, 1)\n assert Module.get_last_attribute(__MODULE__, :value) == 1\n Module.put_attribute(__MODULE__, :value, 2)\n assert Module.get_last_attribute(__MODULE__, :value) == 2\n end\n end\n\n test \"returns the value of the non-accumulate attribute if it exists\" do\n in_module do\n Module.put_attribute(__MODULE__, :attribute, 1)\n assert Module.get_last_attribute(__MODULE__, :attribute) == 1\n Module.put_attribute(__MODULE__, :attribute, nil)\n assert Module.get_last_attribute(__MODULE__, :attribute, :default) == nil\n end\n end\n\n test \"returns the passed default if the accumulate attribute has not yet been set\" do\n in_module do\n Module.register_attribute(__MODULE__, :value, accumulate: true)\n assert Module.get_last_attribute(__MODULE__, :value) == nil\n assert Module.get_last_attribute(__MODULE__, :value, :default) == :default\n end\n end\n\n test \"returns the passed default if the non-accumulate attribute does not exist\" do\n in_module do\n assert Module.get_last_attribute(__MODULE__, :value, :default) == :default\n end\n end\n end\n\n describe \"has_attribute?/2 and attributes_in/2\" do\n test \"returns true when attribute has been defined\" do\n in_module do\n @foo 1\n Module.register_attribute(__MODULE__, :bar, [])\n Module.register_attribute(__MODULE__, :baz, accumulate: true)\n Module.put_attribute(__MODULE__, :qux, 2)\n\n # silence warning\n _ = @foo\n\n assert Module.has_attribute?(__MODULE__, :foo)\n assert :foo in Module.attributes_in(__MODULE__)\n assert Module.has_attribute?(__MODULE__, :bar)\n assert :bar in Module.attributes_in(__MODULE__)\n assert Module.has_attribute?(__MODULE__, :baz)\n assert :baz in Module.attributes_in(__MODULE__)\n assert Module.has_attribute?(__MODULE__, :qux)\n assert :qux in Module.attributes_in(__MODULE__)\n end\n end\n\n test \"returns false when attribute has not been defined\" do\n in_module do\n refute Module.has_attribute?(__MODULE__, :foo)\n end\n end\n\n test \"returns false when attribute has been deleted\" do\n in_module do\n @foo 1\n Module.delete_attribute(__MODULE__, :foo)\n\n refute Module.has_attribute?(__MODULE__, :foo)\n end\n end\n end\n\n test \"@on_load\" do\n Process.register(self(), :on_load_test_process)\n\n defmodule OnLoadTest do\n @on_load :on_load\n\n defp on_load do\n send(:on_load_test_process, :on_loaded)\n :ok\n end\n end\n\n assert_received :on_loaded\n end\nend\n" }, { "path": "lib/elixir/test/elixir/option_parser_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule OptionParserTest do\n use ExUnit.Case, async: true\n\n doctest OptionParser\n\n test \"parses --key value option\" do\n assert OptionParser.parse([\"--source\", \"form_docs/\", \"other\"], switches: [source: :string]) ==\n {[source: \"form_docs/\"], [\"other\"], []}\n end\n\n test \"parses --key=value option\" do\n assert OptionParser.parse([\"--source=form_docs/\", \"other\"], switches: [source: :string]) ==\n {[source: \"form_docs/\"], [\"other\"], []}\n end\n\n test \"parses overrides options by default\" do\n assert OptionParser.parse(\n [\"--require\", \"foo\", \"--require\", \"bar\", \"baz\"],\n switches: [require: :string]\n ) == {[require: \"bar\"], [\"baz\"], []}\n end\n\n test \"parses multi-word option\" do\n config = [switches: [hello_world: :boolean]]\n assert OptionParser.next([\"--hello-world\"], config) == {:ok, :hello_world, true, []}\n assert OptionParser.next([\"--no-hello-world\"], config) == {:ok, :hello_world, false, []}\n\n assert OptionParser.next([\"--no-hello-world\"], strict: []) ==\n {:undefined, \"--no-hello-world\", nil, []}\n\n assert OptionParser.next([\"--no-hello_world\"], strict: []) ==\n {:undefined, \"--no-hello_world\", nil, []}\n\n config = [strict: [hello_world: :boolean]]\n assert OptionParser.next([\"--hello-world\"], config) == {:ok, :hello_world, true, []}\n assert OptionParser.next([\"--no-hello-world\"], config) == {:ok, :hello_world, false, []}\n assert OptionParser.next([\"--hello_world\"], config) == {:undefined, \"--hello_world\", nil, []}\n\n assert OptionParser.next([\"--no-hello_world\"], config) ==\n {:undefined, \"--no-hello_world\", nil, []}\n end\n\n test \"parses more than one key-value pair options using switches\" do\n opts = [switches: [source: :string, docs: :string]]\n\n assert OptionParser.parse([\"--source\", \"from_docs/\", \"--docs\", \"show\"], opts) ==\n {[source: \"from_docs/\", docs: \"show\"], [], []}\n\n assert OptionParser.parse([\"--source\", \"from_docs/\", \"--doc\", \"show\"], opts) ==\n {[source: \"from_docs/\", doc: \"show\"], [], []}\n\n assert OptionParser.parse([\"--source\", \"from_docs/\", \"--doc=show\"], opts) ==\n {[source: \"from_docs/\", doc: \"show\"], [], []}\n\n assert OptionParser.parse([\"--no-bool\"], strict: []) == {[], [], [{\"--no-bool\", nil}]}\n end\n\n test \"parses more than one key-value pair options using strict\" do\n opts = [strict: [source: :string, docs: :string]]\n\n assert OptionParser.parse([\"--source\", \"from_docs/\", \"--docs\", \"show\"], opts) ==\n {[source: \"from_docs/\", docs: \"show\"], [], []}\n\n assert OptionParser.parse([\"--source\", \"from_docs/\", \"--doc\", \"show\"], opts) ==\n {[source: \"from_docs/\"], [\"show\"], [{\"--doc\", nil}]}\n\n assert OptionParser.parse([\"--source\", \"from_docs/\", \"--doc=show\"], opts) ==\n {[source: \"from_docs/\"], [], [{\"--doc\", nil}]}\n\n assert OptionParser.parse([\"--no-bool\"], strict: []) == {[], [], [{\"--no-bool\", nil}]}\n end\n\n test \"collects multiple invalid options\" do\n argv = [\"--bad\", \"opt\", \"foo\", \"-o\", \"bad\", \"bar\"]\n\n assert OptionParser.parse(argv, switches: [bad: :integer]) ==\n {[], [\"foo\", \"bar\"], [{\"--bad\", \"opt\"}]}\n end\n\n test \"parse/2 raises when using both options: switches and strict\" do\n assert_raise ArgumentError, \":switches and :strict cannot be given together\", fn ->\n OptionParser.parse([\"--elixir\"], switches: [ex: :string], strict: [elixir: :string])\n end\n end\n\n test \"parse/2 raises an exception on invalid switch types/modifiers\" do\n assert_raise ArgumentError, \"invalid switch types/modifiers: :bad\", fn ->\n OptionParser.parse([\"--elixir\"], switches: [ex: :bad])\n end\n\n assert_raise ArgumentError, \"invalid switch types/modifiers: :bad, :bad_modifier\", fn ->\n OptionParser.parse([\"--elixir\"], switches: [ex: [:bad, :bad_modifier]])\n end\n end\n\n test \"parse!/2 raises an exception for an unknown option using strict\" do\n msg =\n \"\"\"\n 1 error found!\n --doc-bar : Unknown option. Did you mean --docs-bar?\n\n Supported options:\n --docs-bar STRING\n --source STRING\\\n \"\"\"\n\n assert_raise OptionParser.ParseError, msg, fn ->\n argv = [\"--source\", \"from_docs/\", \"--doc-bar\", \"show\"]\n OptionParser.parse!(argv, strict: [source: :string, docs_bar: :string])\n end\n\n assert_raise OptionParser.ParseError,\n \"\"\"\n 1 error found!\n --foo : Unknown option\n\n Supported options:\n --docs STRING\n --source STRING\\\n \"\"\",\n fn ->\n argv = [\"--source\", \"from_docs/\", \"--foo\", \"show\"]\n OptionParser.parse!(argv, strict: [source: :string, docs: :string])\n end\n end\n\n test \"parse!/2 raises an exception for an unknown option using strict when it is only off by underscores\" do\n msg =\n \"\"\"\n 1 error found!\n --docs_bar : Unknown option. Did you mean --docs-bar?\n\n Supported options:\n --docs-bar STRING\n --source STRING\\\n \"\"\"\n\n assert_raise OptionParser.ParseError, msg, fn ->\n argv = [\"--source\", \"from_docs/\", \"--docs_bar\", \"show\"]\n OptionParser.parse!(argv, strict: [source: :string, docs_bar: :string])\n end\n end\n\n test \"parse!/2 raises an exception when an option is of the wrong type\" do\n assert_raise OptionParser.ParseError,\n \"\"\"\n 1 error found!\n --bad : Expected type integer, got \"opt\"\n\n Supported options:\n --bad INTEGER\\\n \"\"\",\n fn ->\n argv = [\"--bad\", \"opt\", \"foo\", \"-o\", \"bad\", \"bar\"]\n OptionParser.parse!(argv, switches: [bad: :integer])\n end\n end\n\n test \"parse!/2 lists all supported options and aliases\" do\n expected_suggestion =\n \"\"\"\n 1 error found!\n --verbos : Unknown option. Did you mean --verbose?\n\n Supported options:\n --count INTEGER (alias: -c)\n --debug, --no-debug (alias: -d)\n --files STRING (alias: -f) (may be given more than once)\n --name STRING (alias: -n)\n --verbose, --no-verbose (alias: -v)\\\n \"\"\"\n\n assert_raise OptionParser.ParseError, expected_suggestion, fn ->\n OptionParser.parse!([\"--verbos\"],\n strict: [\n name: :string,\n count: :integer,\n verbose: :boolean,\n debug: :boolean,\n files: :keep\n ],\n aliases: [n: :name, c: :count, v: :verbose, d: :debug, f: :files]\n )\n end\n end\n\n test \"parse_head!/2 raises an exception when an option is of the wrong type\" do\n message =\n \"\"\"\n 1 error found!\n --number : Expected type integer, got \"lib\"\n\n Supported options:\n --number INTEGER\\\n \"\"\"\n\n assert_raise OptionParser.ParseError, message, fn ->\n argv = [\"--number\", \"lib\", \"test/enum_test.exs\"]\n OptionParser.parse_head!(argv, strict: [number: :integer])\n end\n end\n\n describe \"arguments\" do\n test \"parses until --\" do\n assert OptionParser.parse(\n [\"--source\", \"foo\", \"--\", \"1\", \"2\", \"3\"],\n switches: [source: :string]\n ) == {[source: \"foo\"], [\"1\", \"2\", \"3\"], []}\n\n assert OptionParser.parse_head(\n [\"--source\", \"foo\", \"--\", \"1\", \"2\", \"3\"],\n switches: [source: :string]\n ) == {[source: \"foo\"], [\"1\", \"2\", \"3\"], []}\n\n assert OptionParser.parse(\n [\"--source\", \"foo\", \"bar\", \"--\", \"-x\"],\n switches: [source: :string]\n ) == {[source: \"foo\"], [\"bar\", \"-x\"], []}\n\n assert OptionParser.parse_head(\n [\"--source\", \"foo\", \"bar\", \"--\", \"-x\"],\n switches: [source: :string]\n ) == {[source: \"foo\"], [\"bar\", \"--\", \"-x\"], []}\n end\n\n test \"return separators\" do\n assert OptionParser.parse_head([\"--\", \"foo\"],\n switches: [],\n return_separator: true\n ) == {[], [\"--\", \"foo\"], []}\n\n assert OptionParser.parse_head([\"--no-halt\", \"--\", \"foo\"],\n switches: [halt: :boolean],\n return_separator: true\n ) == {[halt: false], [\"--\", \"foo\"], []}\n\n assert OptionParser.parse_head([\"foo.exs\", \"--no-halt\", \"--\", \"foo\"],\n switches: [halt: :boolean],\n return_separator: true\n ) == {[], [\"foo.exs\", \"--no-halt\", \"--\", \"foo\"], []}\n end\n\n test \"parses - as argument\" do\n argv = [\"--foo\", \"-\", \"-b\", \"-\"]\n opts = [strict: [foo: :boolean, boo: :string], aliases: [b: :boo]]\n assert OptionParser.parse(argv, opts) == {[foo: true, boo: \"-\"], [\"-\"], []}\n end\n\n test \"parses until first non-option arguments\" do\n argv = [\"--source\", \"from_docs/\", \"test/enum_test.exs\", \"--verbose\"]\n\n assert OptionParser.parse_head(argv, switches: [source: :string]) ==\n {[source: \"from_docs/\"], [\"test/enum_test.exs\", \"--verbose\"], []}\n end\n end\n\n describe \"aliases\" do\n test \"supports boolean aliases\" do\n assert OptionParser.parse([\"-d\"], aliases: [d: :docs], switches: [docs: :boolean]) ==\n {[docs: true], [], []}\n end\n\n test \"supports non-boolean aliases\" do\n assert OptionParser.parse(\n [\"-s\", \"from_docs/\"],\n aliases: [s: :source],\n switches: [source: :string]\n ) == {[source: \"from_docs/\"], [], []}\n end\n\n test \"supports --key=value aliases\" do\n assert OptionParser.parse(\n [\"-s=from_docs/\", \"other\"],\n aliases: [s: :source],\n switches: [source: :string]\n ) == {[source: \"from_docs/\"], [\"other\"], []}\n end\n\n test \"parses -ab as -a -b\" do\n opts = [aliases: [a: :first, b: :second], switches: [second: :integer]]\n assert OptionParser.parse([\"-ab=1\"], opts) == {[first: true, second: 1], [], []}\n assert OptionParser.parse([\"-ab\", \"1\"], opts) == {[first: true, second: 1], [], []}\n\n opts = [aliases: [a: :first, b: :second], switches: [first: :boolean, second: :boolean]]\n assert OptionParser.parse([\"-ab\"], opts) == {[first: true, second: true], [], []}\n assert OptionParser.parse([\"-ab3\"], opts) == {[first: true], [], [{\"-b\", \"3\"}]}\n assert OptionParser.parse([\"-ab=bar\"], opts) == {[first: true], [], [{\"-b\", \"bar\"}]}\n assert OptionParser.parse([\"-ab3=bar\"], opts) == {[first: true], [], [{\"-b\", \"3=bar\"}]}\n assert OptionParser.parse([\"-3ab\"], opts) == {[], [\"-3ab\"], []}\n end\n end\n\n describe \"types\" do\n test \"parses configured booleans\" do\n assert OptionParser.parse([\"--docs=false\"], switches: [docs: :boolean]) ==\n {[docs: false], [], []}\n\n assert OptionParser.parse([\"--docs=true\"], switches: [docs: :boolean]) ==\n {[docs: true], [], []}\n\n assert OptionParser.parse([\"--docs=other\"], switches: [docs: :boolean]) ==\n {[], [], [{\"--docs\", \"other\"}]}\n\n assert OptionParser.parse([\"--docs=\"], switches: [docs: :boolean]) ==\n {[], [], [{\"--docs\", \"\"}]}\n\n assert OptionParser.parse([\"--docs\", \"foo\"], switches: [docs: :boolean]) ==\n {[docs: true], [\"foo\"], []}\n\n assert OptionParser.parse([\"--no-docs\", \"foo\"], switches: [docs: :boolean]) ==\n {[docs: false], [\"foo\"], []}\n\n assert OptionParser.parse([\"--no-docs=foo\", \"bar\"], switches: [docs: :boolean]) ==\n {[], [\"bar\"], [{\"--no-docs\", \"foo\"}]}\n\n assert OptionParser.parse([\"--no-docs=\", \"bar\"], switches: [docs: :boolean]) ==\n {[], [\"bar\"], [{\"--no-docs\", \"\"}]}\n end\n\n test \"does not set unparsed booleans\" do\n assert OptionParser.parse([\"foo\"], switches: [docs: :boolean]) == {[], [\"foo\"], []}\n end\n\n test \"keeps options on configured keep\" do\n argv = [\"--require\", \"foo\", \"--require\", \"bar\", \"baz\"]\n\n assert OptionParser.parse(argv, switches: [require: :keep]) ==\n {[require: \"foo\", require: \"bar\"], [\"baz\"], []}\n\n assert OptionParser.parse([\"--require\"], switches: [require: :keep]) ==\n {[], [], [{\"--require\", nil}]}\n end\n\n test \"parses configured strings\" do\n assert OptionParser.parse([\"--value\", \"1\", \"foo\"], switches: [value: :string]) ==\n {[value: \"1\"], [\"foo\"], []}\n\n assert OptionParser.parse([\"--value=1\", \"foo\"], switches: [value: :string]) ==\n {[value: \"1\"], [\"foo\"], []}\n\n assert OptionParser.parse([\"--value\"], switches: [value: :string]) ==\n {[], [], [{\"--value\", nil}]}\n\n assert OptionParser.parse([\"--no-value\"], switches: [value: :string]) ==\n {[no_value: true], [], []}\n end\n\n test \"parses configured counters\" do\n assert OptionParser.parse([\"--verbose\"], switches: [verbose: :count]) ==\n {[verbose: 1], [], []}\n\n assert OptionParser.parse([\"--verbose\", \"--verbose\"], switches: [verbose: :count]) ==\n {[verbose: 2], [], []}\n\n argv = [\"--verbose\", \"-v\", \"-v\", \"--\", \"bar\"]\n opts = [aliases: [v: :verbose], strict: [verbose: :count]]\n assert OptionParser.parse(argv, opts) == {[verbose: 3], [\"bar\"], []}\n end\n\n test \"parses configured integers\" do\n assert OptionParser.parse([\"--value\", \"1\", \"foo\"], switches: [value: :integer]) ==\n {[value: 1], [\"foo\"], []}\n\n assert OptionParser.parse([\"--value=1\", \"foo\"], switches: [value: :integer]) ==\n {[value: 1], [\"foo\"], []}\n\n assert OptionParser.parse([\"--value\", \"WAT\", \"foo\"], switches: [value: :integer]) ==\n {[], [\"foo\"], [{\"--value\", \"WAT\"}]}\n end\n\n test \"parses configured integers with keep\" do\n argv = [\"--value\", \"1\", \"--value\", \"2\", \"foo\"]\n\n assert OptionParser.parse(argv, switches: [value: [:integer, :keep]]) ==\n {[value: 1, value: 2], [\"foo\"], []}\n\n argv = [\"--value=1\", \"foo\", \"--value=2\", \"bar\"]\n\n assert OptionParser.parse(argv, switches: [value: [:integer, :keep]]) ==\n {[value: 1, value: 2], [\"foo\", \"bar\"], []}\n end\n\n test \"parses configured floats\" do\n assert OptionParser.parse([\"--value\", \"1.0\", \"foo\"], switches: [value: :float]) ==\n {[value: 1.0], [\"foo\"], []}\n\n assert OptionParser.parse([\"--value=1.0\", \"foo\"], switches: [value: :float]) ==\n {[value: 1.0], [\"foo\"], []}\n\n assert OptionParser.parse([\"--value\", \"WAT\", \"foo\"], switches: [value: :float]) ==\n {[], [\"foo\"], [{\"--value\", \"WAT\"}]}\n end\n\n test \"correctly handles negative integers\" do\n opts = [switches: [option: :integer], aliases: [o: :option]]\n assert OptionParser.parse([\"arg1\", \"-o43\"], opts) == {[option: 43], [\"arg1\"], []}\n assert OptionParser.parse([\"arg1\", \"-o\", \"-43\"], opts) == {[option: -43], [\"arg1\"], []}\n assert OptionParser.parse([\"arg1\", \"--option=-43\"], opts) == {[option: -43], [\"arg1\"], []}\n\n assert OptionParser.parse([\"arg1\", \"--option\", \"-43\"], opts) ==\n {[option: -43], [\"arg1\"], []}\n end\n\n test \"correctly handles negative floating-point numbers\" do\n opts = [switches: [option: :float], aliases: [o: :option]]\n assert OptionParser.parse([\"arg1\", \"-o43.2\"], opts) == {[option: 43.2], [\"arg1\"], []}\n assert OptionParser.parse([\"arg1\", \"-o\", \"-43.2\"], opts) == {[option: -43.2], [\"arg1\"], []}\n\n assert OptionParser.parse([\"arg1\", \"--option=-43.2\"], switches: [option: :float]) ==\n {[option: -43.2], [\"arg1\"], []}\n\n assert OptionParser.parse([\"arg1\", \"--option\", \"-43.2\"], opts) ==\n {[option: -43.2], [\"arg1\"], []}\n end\n\n test \"parses configured regexes\" do\n assert {[pattern: regex], [\"foo\"], []} =\n OptionParser.parse([\"--pattern\", \"a.*b\", \"foo\"], switches: [pattern: :regex])\n\n assert Regex.match?(regex, \"aXXXb\")\n refute Regex.match?(regex, \"xyz\")\n\n assert {[pattern: regex], [\"foo\"], []} =\n OptionParser.parse([\"--pattern=a.*b\", \"foo\"], switches: [pattern: :regex])\n\n assert Regex.match?(regex, \"aXXXb\")\n\n # Test Unicode support\n assert {[pattern: regex], [\"foo\"], []} =\n OptionParser.parse([\"--pattern\", \"café.*résumé\", \"foo\"],\n switches: [pattern: :regex]\n )\n\n assert Regex.match?(regex, \"café test résumé\")\n refute Regex.match?(regex, \"ascii only\")\n\n # Test invalid regex\n assert OptionParser.parse([\"--pattern\", \"[invalid\", \"foo\"], switches: [pattern: :regex]) ==\n {[], [\"foo\"], [{\"--pattern\", \"[invalid\"}]}\n end\n\n test \"parses configured regexes with keep\" do\n argv = [\"--pattern\", \"a.*\", \"--pattern\", \"b.*\", \"foo\"]\n\n assert {[pattern: regex1, pattern: regex2], [\"foo\"], []} =\n OptionParser.parse(argv, switches: [pattern: [:regex, :keep]])\n\n assert Regex.match?(regex1, \"aXXX\")\n assert Regex.match?(regex2, \"bXXX\")\n refute Regex.match?(regex1, \"bXXX\")\n refute Regex.match?(regex2, \"aXXX\")\n\n argv = [\"--pattern=a.*\", \"foo\", \"--pattern=b.*\", \"bar\"]\n\n assert {[pattern: regex1, pattern: regex2], [\"foo\", \"bar\"], []} =\n OptionParser.parse(argv, switches: [pattern: [:regex, :keep]])\n\n assert Regex.match?(regex1, \"aXXX\")\n assert Regex.match?(regex2, \"bXXX\")\n end\n\n test \"correctly handles regex compilation errors\" do\n opts = [switches: [pattern: :regex]]\n\n # Invalid regex patterns should be treated as errors\n assert OptionParser.parse([\"--pattern\", \"*invalid\"], opts) ==\n {[], [], [{\"--pattern\", \"*invalid\"}]}\n\n assert OptionParser.parse([\"--pattern\", \"[unclosed\"], opts) ==\n {[], [], [{\"--pattern\", \"[unclosed\"}]}\n\n assert OptionParser.parse([\"--pattern\", \"(?invalid)\"], opts) ==\n {[], [], [{\"--pattern\", \"(?invalid)\"}]}\n end\n\n test \"parse! raises an exception for invalid regex patterns\" do\n assert_raise OptionParser.ParseError,\n ~r/Invalid regular expression \\\"\\[invalid\\\": missing terminating \\] for character class at position \\d/,\n fn ->\n OptionParser.parse!([\"--pattern\", \"[invalid\"], switches: [pattern: :regex])\n end\n\n assert_raise OptionParser.ParseError,\n ~r/Invalid regular expression \\\"\\(\\?invalid\\)\\\": unrecognized character after \\(\\? or \\(\\?\\- at position \\d/,\n fn ->\n OptionParser.parse!([\"--pattern\", \"(?invalid)\"], switches: [pattern: :regex])\n end\n end\n end\n\n describe \"next\" do\n test \"with strict good options\" do\n config = [strict: [str: :string, int: :integer, bool: :boolean]]\n assert OptionParser.next([\"--str\", \"hello\", \"...\"], config) == {:ok, :str, \"hello\", [\"...\"]}\n assert OptionParser.next([\"--int=13\", \"...\"], config) == {:ok, :int, 13, [\"...\"]}\n assert OptionParser.next([\"--bool=false\", \"...\"], config) == {:ok, :bool, false, [\"...\"]}\n assert OptionParser.next([\"--no-bool\", \"...\"], config) == {:ok, :bool, false, [\"...\"]}\n assert OptionParser.next([\"--bool\", \"...\"], config) == {:ok, :bool, true, [\"...\"]}\n assert OptionParser.next([\"...\"], config) == {:error, [\"...\"]}\n end\n\n test \"with strict unknown options\" do\n config = [strict: [bool: :boolean]]\n\n assert OptionParser.next([\"--str\", \"13\", \"...\"], config) ==\n {:undefined, \"--str\", nil, [\"13\", \"...\"]}\n\n assert OptionParser.next([\"--int=hello\", \"...\"], config) ==\n {:undefined, \"--int\", \"hello\", [\"...\"]}\n\n assert OptionParser.next([\"-no-bool=other\", \"...\"], config) ==\n {:undefined, \"-no-bool\", \"other\", [\"...\"]}\n end\n\n test \"with strict bad type\" do\n config = [strict: [str: :string, int: :integer, bool: :boolean]]\n assert OptionParser.next([\"--str\", \"13\", \"...\"], config) == {:ok, :str, \"13\", [\"...\"]}\n\n assert OptionParser.next([\"--int=hello\", \"...\"], config) ==\n {:invalid, \"--int\", \"hello\", [\"...\"]}\n\n assert OptionParser.next([\"--int\", \"hello\", \"...\"], config) ==\n {:invalid, \"--int\", \"hello\", [\"...\"]}\n\n assert OptionParser.next([\"--bool=other\", \"...\"], config) ==\n {:invalid, \"--bool\", \"other\", [\"...\"]}\n end\n\n test \"with strict missing value\" do\n config = [strict: [str: :string, int: :integer, bool: :boolean]]\n assert OptionParser.next([\"--str\"], config) == {:invalid, \"--str\", nil, []}\n assert OptionParser.next([\"--int\"], config) == {:invalid, \"--int\", nil, []}\n assert OptionParser.next([\"--bool=\", \"...\"], config) == {:invalid, \"--bool\", \"\", [\"...\"]}\n\n assert OptionParser.next([\"--no-bool=\", \"...\"], config) ==\n {:invalid, \"--no-bool\", \"\", [\"...\"]}\n end\n end\n\n test \"split\" do\n assert OptionParser.split(~S[]) == []\n assert OptionParser.split(~S[foo]) == [\"foo\"]\n assert OptionParser.split(~S[foo bar]) == [\"foo\", \"bar\"]\n assert OptionParser.split(~S[ foo bar ]) == [\"foo\", \"bar\"]\n assert OptionParser.split(~S[foo\\ bar]) == [\"foo bar\"]\n assert OptionParser.split(~S[foo\" bar\"]) == [\"foo bar\"]\n assert OptionParser.split(~S[foo\\\" bar\\\"]) == [\"foo\\\"\", \"bar\\\"\"]\n assert OptionParser.split(~S[foo \"\\ bar\\\"\"]) == [\"foo\", \"\\\\ bar\\\"\"]\n assert OptionParser.split(~S[foo '\\\"bar\"\\'\\ ']) == [\"foo\", \"\\\\\\\"bar\\\"'\\\\ \"]\n end\n\n describe \"to_argv\" do\n test \"converts options back to switches\" do\n assert OptionParser.to_argv(foo_bar: \"baz\") == [\"--foo-bar\", \"baz\"]\n\n assert OptionParser.to_argv(bool: true, bool: false, discarded: nil) ==\n [\"--bool\", \"--no-bool\"]\n end\n\n test \"handles :count switch type\" do\n original = [\"--counter\", \"--counter\"]\n {opts, [], []} = OptionParser.parse(original, switches: [counter: :count])\n assert original == OptionParser.to_argv(opts, switches: [counter: :count])\n end\n end\nend\n\ndefmodule OptionsParserDeprecationsTest do\n use ExUnit.Case, async: true\n\n def assert_deprecated(fun) do\n assert ExUnit.CaptureIO.capture_io(:stderr, fun) =~\n \"not passing the :switches or :strict option to OptionParser is deprecated\"\n end\n\n test \"parses boolean option\" do\n assert_deprecated(fn ->\n assert OptionParser.parse([\"--docs\"]) == {[docs: true], [], []}\n end)\n end\n\n test \"parses more than one boolean option\" do\n assert_deprecated(fn ->\n assert OptionParser.parse([\"--docs\", \"--compile\"]) == {[docs: true, compile: true], [], []}\n end)\n end\n\n test \"parses more than one boolean options as the alias\" do\n assert_deprecated(fn ->\n assert OptionParser.parse([\"-d\", \"--compile\"], aliases: [d: :docs]) ==\n {[docs: true, compile: true], [], []}\n end)\n end\n\n test \"parses --key value option\" do\n assert_deprecated(fn ->\n assert OptionParser.parse([\"--source\", \"form_docs/\"]) == {[source: \"form_docs/\"], [], []}\n end)\n end\n\n test \"does not interpret undefined options with value as boolean\" do\n assert_deprecated(fn ->\n assert OptionParser.parse([\"--no-bool\"]) == {[no_bool: true], [], []}\n end)\n\n assert_deprecated(fn ->\n assert OptionParser.parse([\"--no-bool=...\", \"other\"]) == {[no_bool: \"...\"], [\"other\"], []}\n end)\n end\n\n test \"parses -ab as -a -b\" do\n assert_deprecated(fn ->\n assert OptionParser.parse([\"-ab\"], aliases: [a: :first, b: :second]) ==\n {[first: true, second: true], [], []}\n end)\n end\n\n test \"parses mixed options\" do\n argv = [\"--source\", \"from_docs/\", \"--compile\", \"-x\"]\n\n assert_deprecated(fn ->\n assert OptionParser.parse(argv, aliases: [x: :x]) ==\n {[source: \"from_docs/\", compile: true, x: true], [], []}\n end)\n end\n\n test \"parses more than one key-value pair options\" do\n assert_deprecated(fn ->\n assert OptionParser.parse([\"--source\", \"from_docs/\", \"--docs\", \"show\"]) ==\n {[source: \"from_docs/\", docs: \"show\"], [], []}\n end)\n end\n\n test \"multi-word option\" do\n assert_deprecated(fn ->\n assert OptionParser.next([\"--hello-world\"], []) == {:ok, :hello_world, true, []}\n end)\n\n assert_deprecated(fn ->\n assert OptionParser.next([\"--no-hello-world\"], []) == {:ok, :no_hello_world, true, []}\n end)\n\n assert_deprecated(fn ->\n assert OptionParser.next([\"--hello_world\"], []) == {:undefined, \"--hello_world\", nil, []}\n end)\n\n assert_deprecated(fn ->\n assert OptionParser.next([\"--no-hello_world\"], []) ==\n {:undefined, \"--no-hello_world\", nil, []}\n end)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/partition_supervisor_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule PartitionSupervisorTest do\n use ExUnit.Case, async: true\n\n describe \"child_spec\" do\n test \"uses the atom name as id\" do\n assert Supervisor.child_spec({PartitionSupervisor, name: Foo}, []) == %{\n id: Foo,\n start: {PartitionSupervisor, :start_link, [[name: Foo]]},\n type: :supervisor\n }\n end\n\n test \"uses the via value as id\" do\n via = {:via, Foo, {:bar, :baz}}\n\n assert Supervisor.child_spec({PartitionSupervisor, name: via}, []) == %{\n id: {:bar, :baz},\n start: {PartitionSupervisor, :start_link, [[name: via]]},\n type: :supervisor\n }\n end\n end\n\n describe \"start_link/1\" do\n test \"on success with atom name\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: DynamicSupervisor,\n name: config.test\n )\n\n assert PartitionSupervisor.partitions(config.test) == System.schedulers_online()\n\n refs =\n for _ <- 1..100 do\n ref = make_ref()\n\n DynamicSupervisor.start_child(\n {:via, PartitionSupervisor, {config.test, ref}},\n {Agent, fn -> ref end}\n )\n\n ref\n end\n\n agents =\n for {_, pid, _, _} <- PartitionSupervisor.which_children(config.test),\n {_, pid, _, _} <- DynamicSupervisor.which_children(pid),\n do: Agent.get(pid, & &1)\n\n assert Enum.sort(refs) == Enum.sort(agents)\n end\n\n test \"on success with via name\", config do\n {:ok, _} = Registry.start_link(keys: :unique, name: PartitionRegistry)\n\n name = {:via, Registry, {PartitionRegistry, config.test}}\n\n {:ok, _} = PartitionSupervisor.start_link(child_spec: {Agent, fn -> :hello end}, name: name)\n\n assert PartitionSupervisor.partitions(name) == System.schedulers_online()\n\n assert Agent.get({:via, PartitionSupervisor, {name, 0}}, & &1) == :hello\n end\n\n test \"with_arguments\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> raise \"unused\" end},\n with_arguments: fn [_fun], partition -> [fn -> partition end] end,\n partitions: 3,\n name: config.test\n )\n\n assert PartitionSupervisor.partitions(config.test) == 3\n\n assert Agent.get({:via, PartitionSupervisor, {config.test, 0}}, & &1) == 0\n assert Agent.get({:via, PartitionSupervisor, {config.test, 1}}, & &1) == 1\n assert Agent.get({:via, PartitionSupervisor, {config.test, 2}}, & &1) == 2\n\n assert Agent.get({:via, PartitionSupervisor, {config.test, 3}}, & &1) == 0\n assert Agent.get({:via, PartitionSupervisor, {config.test, -1}}, & &1) == 1\n end\n\n test \"raises without name\" do\n assert_raise ArgumentError,\n \"the :name option must be given to PartitionSupervisor\",\n fn -> PartitionSupervisor.start_link(child_spec: DynamicSupervisor) end\n end\n\n test \"raises without child_spec\" do\n assert_raise ArgumentError,\n \"the :child_spec option must be given to PartitionSupervisor\",\n fn -> PartitionSupervisor.start_link(name: Foo) end\n end\n\n test \"raises on bad partitions\" do\n assert_raise ArgumentError,\n \"the :partitions option must be a positive integer, got: 0\",\n fn ->\n PartitionSupervisor.start_link(\n name: Foo,\n child_spec: DynamicSupervisor,\n partitions: 0\n )\n end\n end\n\n test \"raises on bad with_arguments\" do\n assert_raise ArgumentError,\n ~r\"the :with_arguments option must be a function that receives two arguments\",\n fn ->\n PartitionSupervisor.start_link(\n name: Foo,\n child_spec: DynamicSupervisor,\n with_arguments: 123\n )\n end\n end\n\n test \"raises with bad auto_shutdown\" do\n assert_raise ArgumentError,\n \"the :auto_shutdown option must be :never, got: :any_significant\",\n fn ->\n PartitionSupervisor.start_link(\n child_spec: DynamicSupervisor,\n name: Foo,\n auto_shutdown: :any_significant\n )\n end\n end\n end\n\n describe \"stop/1\" do\n test \"is synchronous\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: config.test\n )\n\n assert PartitionSupervisor.stop(config.test) == :ok\n assert Process.whereis(config.test) == nil\n end\n\n test \"with via tuple\", config do\n {:ok, _} = Registry.start_link(keys: :unique, name: config.test)\n\n name = {:via, Registry, {config.test, :stop_test}}\n\n {:ok, pid} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: name\n )\n\n assert Process.alive?(pid)\n assert PartitionSupervisor.stop(name) == :ok\n refute Process.alive?(pid)\n end\n end\n\n describe \"partitions/1\" do\n test \"raises noproc for unknown atom partition supervisor\" do\n assert {:noproc, _} = catch_exit(PartitionSupervisor.partitions(:unknown))\n end\n\n test \"raises noproc for unknown via partition supervisor\", config do\n {:ok, _} = Registry.start_link(keys: :unique, name: config.test)\n via = {:via, Registry, {config.test, :unknown}}\n assert {:noproc, _} = catch_exit(PartitionSupervisor.partitions(via))\n end\n end\n\n describe \"resize!/1\" do\n test \"resizes the number of children\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: config.test,\n partitions: 8\n )\n\n for range <- [8..0//1, 0..8//1, Enum.shuffle(0..8)], i <- range do\n PartitionSupervisor.resize!(config.test, i)\n assert PartitionSupervisor.partitions(config.test) == i\n\n assert PartitionSupervisor.count_children(config.test) ==\n %{active: i, specs: 8, supervisors: 0, workers: 8}\n\n # Assert that we can still query across all range,\n # but they are routed properly, as long as we have\n # a single partition.\n children =\n for partition <- 0..7, i != 0, uniq: true do\n GenServer.whereis({:via, PartitionSupervisor, {config.test, partition}})\n end\n\n assert length(children) == i\n end\n end\n\n test \"raises on lookup after resizing to zero\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: config.test,\n partitions: 8\n )\n\n assert PartitionSupervisor.resize!(config.test, 0) == 8\n\n assert_raise ArgumentError, ~r\"has zero partitions\", fn ->\n GenServer.whereis({:via, PartitionSupervisor, {config.test, 0}})\n end\n\n assert PartitionSupervisor.resize!(config.test, 8) == 0\n end\n\n test \"raises if trying to increase the number of partitions\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: config.test,\n partitions: 8\n )\n\n assert_raise ArgumentError,\n \"the number of partitions to resize to must be a number between 0 and 8, got: 9\",\n fn -> PartitionSupervisor.resize!(config.test, 9) end\n end\n end\n\n describe \"which_children/1\" do\n test \"returns all partitions\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: config.test\n )\n\n assert PartitionSupervisor.partitions(config.test) == System.schedulers_online()\n\n children =\n config.test\n |> PartitionSupervisor.which_children()\n |> Enum.sort()\n\n for {child, partition} <- Enum.zip(children, 0..(System.schedulers_online() - 1)) do\n via = {:via, PartitionSupervisor, {config.test, partition}}\n assert child == {partition, GenServer.whereis(via), :worker, [Agent]}\n end\n end\n end\n\n describe \"count_children/1\" do\n test \"with workers\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: config.test\n )\n\n partitions = System.schedulers_online()\n\n assert PartitionSupervisor.count_children(config.test) ==\n %{active: partitions, specs: partitions, supervisors: 0, workers: partitions}\n end\n\n test \"with supervisors\", config do\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: DynamicSupervisor,\n name: config.test\n )\n\n partitions = System.schedulers_online()\n\n assert PartitionSupervisor.count_children(config.test) ==\n %{active: partitions, specs: partitions, supervisors: partitions, workers: 0}\n end\n\n test \"raises noproc for unknown partition supervisor\" do\n assert {:noproc, _} = catch_exit(PartitionSupervisor.count_children(:unknown))\n end\n\n test \"with via tuple\", config do\n {:ok, _} = Registry.start_link(keys: :unique, name: config.test)\n\n name = {:via, Registry, {config.test, :count_test}}\n\n {:ok, _} =\n PartitionSupervisor.start_link(\n child_spec: {Agent, fn -> %{} end},\n name: name\n )\n\n partitions = System.schedulers_online()\n\n assert PartitionSupervisor.count_children(name) ==\n %{active: partitions, specs: partitions, supervisors: 0, workers: partitions}\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/path_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule PathTest do\n use ExUnit.Case, async: true\n doctest Path\n\n if :file.native_name_encoding() == :utf8 do\n @tag :tmp_dir\n test \"wildcard with UTF-8\", config do\n File.mkdir_p(Path.join(config.tmp_dir, \"héllò\"))\n\n assert Path.wildcard(Path.join(config.tmp_dir, \"héllò\")) ==\n [Path.join(config.tmp_dir, \"héllò\")]\n after\n File.rm_rf(Path.join(config.tmp_dir, \"héllò\"))\n end\n end\n\n @tag :tmp_dir\n test \"wildcard/2\", config do\n hello = Path.join(config.tmp_dir, \"wildcard/.hello\")\n world = Path.join(config.tmp_dir, \"wildcard/.hello/world\")\n File.mkdir_p(world)\n\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/*/*\")) == []\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/**/*\")) == []\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/?hello/world\")) == []\n\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/*/*\"), match_dot: true) ==\n [world]\n\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/**/*\"), match_dot: true) ==\n [hello, world]\n\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/?hello/world\"), match_dot: true) ==\n [world]\n after\n File.rm_rf(Path.join(config.tmp_dir, \"wildcard\"))\n end\n\n @tag :tmp_dir\n test \"wildcard/2 follows ..\", config do\n hello = Path.join(config.tmp_dir, \"wildcard/hello\")\n world = Path.join(config.tmp_dir, \"wildcard/world\")\n File.mkdir_p(hello)\n File.touch(world)\n\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/w*/../h*\")) == []\n\n assert Path.wildcard(Path.join(config.tmp_dir, \"wildcard/h*/../w*\")) ==\n [Path.join(config.tmp_dir, \"wildcard/hello/../world\")]\n after\n File.rm_rf(Path.join(config.tmp_dir, \"wildcard\"))\n end\n\n test \"wildcard/2 raises on null byte\" do\n assert_raise ArgumentError, ~r/null byte/, fn -> Path.wildcard(\"foo\\0bar\") end\n end\n\n describe \"Windows\" do\n @describetag :windows\n\n test \"absname/1\" do\n assert Path.absname(\"//host/path\") == \"//host/path\"\n assert Path.absname(\"\\\\\\\\host\\\\path\") == \"//host/path\"\n assert Path.absname(\"\\\\/host\\\\path\") == \"//host/path\"\n assert Path.absname(\"/\\\\host\\\\path\") == \"//host/path\"\n\n assert Path.absname(\"c:/\") == \"c:/\"\n assert Path.absname(\"c:/host/path\") == \"c:/host/path\"\n\n cwd = File.cwd!()\n assert Path.absname(cwd |> String.split(\"/\") |> hd()) == cwd\n\n <> = cwd\n random = Enum.random(Enum.to_list(?c..?z) -- [letter])\n assert Path.absname(<>) == <>\n end\n\n test \"relative/1\" do\n assert Path.relative(\"C:/usr/local/bin\") == \"usr/local/bin\"\n assert Path.relative(\"C:\\\\usr\\\\local\\\\bin\") == \"usr\\\\local\\\\bin\"\n assert Path.relative(\"C:usr\\\\local\\\\bin\") == \"usr\\\\local\\\\bin\"\n\n assert Path.relative(\"/usr/local/bin\") == \"usr/local/bin\"\n assert Path.relative(\"usr/local/bin\") == \"usr/local/bin\"\n assert Path.relative(\"../usr/local/bin\") == \"../usr/local/bin\"\n end\n\n test \"relative_to/3\" do\n # should give same relative paths for both force true and false\n for force <- [true, false] do\n assert Path.relative_to(\"//usr/local/foo\", \"//usr/\", force: force) == \"local/foo\"\n\n assert Path.relative_to(\"D:/usr/local/foo\", \"D:/usr/\", force: force) == \"local/foo\"\n assert Path.relative_to(\"D:/usr/local/foo\", \"d:/usr/\", force: force) == \"local/foo\"\n assert Path.relative_to(\"d:/usr/local/foo\", \"D:/usr/\", force: force) == \"local/foo\"\n assert Path.relative_to(\"D:/usr/local/foo\", \"d:/\", force: force) == \"usr/local/foo\"\n assert Path.relative_to(\"D:/usr/local/foo\", \"D:/\", force: force) == \"usr/local/foo\"\n\n assert Path.relative_to(\"d:/usr/local/foo/..\", \"d:/usr/local\", force: force) == \".\"\n assert Path.relative_to(\"d:/usr/local/../foo\", \"d:/usr/foo\", force: force) == \".\"\n assert Path.relative_to(\"d:/usr/local/../foo/bar\", \"d:/usr/foo\", force: force) == \"bar\"\n assert Path.relative_to(\"d:/usr/local/../foo/./bar\", \"d:/usr/foo\", force: force) == \"bar\"\n\n assert Path.relative_to(\"d:/usr/local/../foo/bar/..\", \"d:/usr/foo\", force: force) == \".\"\n assert Path.relative_to(\"d:/usr/local/foo/..\", \"d:/usr/local/..\", force: force) == \"local\"\n assert Path.relative_to(\"d:/usr/local/foo/..\", \"d:/usr/local/.\", force: force) == \".\"\n end\n\n # different results for force: true\n assert Path.relative_to(\"d:/usr/local/../foo\", \"d:/usr/local\") == \"d:/usr/foo\"\n assert Path.relative_to(\"d:/usr/local/../foo\", \"d:/usr/local\", force: true) == \"../foo\"\n\n assert Path.relative_to(\"d:/usr/local/../foo/../bar\", \"d:/usr/foo\") == \"d:/usr/bar\"\n assert Path.relative_to(\"d:/usr/local/../foo/../bar\", \"d:/usr/foo\", force: true) == \"../bar\"\n\n # on different volumes with force: true it should return the original path\n assert Path.relative_to(\"d:/usr/local\", \"c:/usr/local\", force: true) == \"d:/usr/local\"\n assert Path.relative_to(\"d:/usr/local\", \"c:/another/local\", force: true) == \"d:/usr/local\"\n end\n\n test \"type/1\" do\n assert Path.type(\"C:/usr/local/bin\") == :absolute\n assert Path.type(~c\"C:\\\\usr\\\\local\\\\bin\") == :absolute\n assert Path.type(\"C:usr\\\\local\\\\bin\") == :volumerelative\n\n assert Path.type(\"/usr/local/bin\") == :volumerelative\n assert Path.type(~c\"usr/local/bin\") == :relative\n assert Path.type(\"../usr/local/bin\") == :relative\n\n assert Path.type(\"//host/path\") == :absolute\n assert Path.type(\"\\\\\\\\host\\\\path\") == :absolute\n assert Path.type(\"/\\\\host\\\\path\") == :absolute\n assert Path.type(\"\\\\/host\\\\path\") == :absolute\n end\n\n test \"split/1\" do\n assert Path.split(\"C:\\\\foo\\\\bar\") == [\"c:/\", \"foo\", \"bar\"]\n assert Path.split(\"C:/foo/bar\") == [\"c:/\", \"foo\", \"bar\"]\n end\n\n test \"safe_relative/1\" do\n assert Path.safe_relative(\"local/foo\") == {:ok, \"local/foo\"}\n assert Path.safe_relative(\"D:/usr/local/foo\") == :error\n assert Path.safe_relative(\"d:/usr/local/foo\") == :error\n assert Path.safe_relative(\"foo/../..\") == :error\n end\n\n test \"safe_relative/2\" do\n assert Path.safe_relative(\"local/foo/bar\", \"local\") == {:ok, \"local/foo/bar\"}\n assert Path.safe_relative(\"foo/..\", \"local\") == {:ok, \"\"}\n assert Path.safe_relative(\"..\", \"local/foo\") == :error\n assert Path.safe_relative(\"d:/usr/local/foo\", \"D:/\") == :error\n assert Path.safe_relative(\"D:/usr/local/foo\", \"d:/\") == :error\n end\n end\n\n describe \"Unix\" do\n @describetag :unix\n\n test \"relative/1\" do\n assert Path.relative(\"/usr/local/bin\") == \"usr/local/bin\"\n assert Path.relative(\"usr/local/bin\") == \"usr/local/bin\"\n assert Path.relative(\"../usr/local/bin\") == \"../usr/local/bin\"\n assert Path.relative(\"/\") == \".\"\n assert Path.relative(~c\"/\") == \".\"\n assert Path.relative([~c\"/usr\", ?/, \"local/bin\"]) == \"usr/local/bin\"\n end\n\n test \"relative_to/3\" do\n # subpaths of cwd, should give the same result for both force true and false\n for force <- [false, true] do\n assert Path.relative_to(\"/usr/local/foo\", \"/usr/local\", force: force) == \"foo\"\n assert Path.relative_to(\"/usr/local/foo\", \"/\", force: force) == \"usr/local/foo\"\n assert Path.relative_to(\"/usr/local/foo\", \"/usr/local/foo\", force: force) == \".\"\n assert Path.relative_to(\"/usr/local/foo/\", \"/usr/local/foo\", force: force) == \".\"\n assert Path.relative_to(\"/usr/local/foo\", \"/usr/local/foo/\", force: force) == \".\"\n\n assert Path.relative_to(\"/usr/local/foo/..\", \"/usr/local\", force: force) == \".\"\n assert Path.relative_to(\"/usr/local/../foo\", \"/usr/foo\", force: force) == \".\"\n assert Path.relative_to(\"/usr/local/../foo/bar\", \"/usr/foo\", force: force) == \"bar\"\n assert Path.relative_to(\"/usr/local/../foo/./bar\", \"/usr/foo\", force: force) == \"bar\"\n assert Path.relative_to(\"/usr/local/../foo/bar/..\", \"/usr/foo\", force: force) == \".\"\n\n assert Path.relative_to(\"/usr/local/foo/..\", \"/usr/local/..\", force: force) == \"local\"\n assert Path.relative_to(\"/usr/local/foo/..\", \"/usr/local/.\", force: force) == \".\"\n end\n\n # With relative second argument\n assert Path.relative_to(\"/usr/local/foo\", \"etc\") == \"/usr/local/foo\"\n assert Path.relative_to(\"/usr/local/foo\", \"etc\", force: true) == \"/usr/local/foo\"\n\n # Different relative paths for force true/false\n assert Path.relative_to(\"/usr/local/foo\", \"/etc\") == \"/usr/local/foo\"\n assert Path.relative_to(\"/usr/local/foo\", \"/etc\", force: true) == \"../usr/local/foo\"\n\n assert Path.relative_to(\"/usr/local/../foo\", \"/usr/local\") == \"/usr/foo\"\n assert Path.relative_to(\"/usr/local/../foo\", \"/usr/local\", force: true) == \"../foo\"\n\n assert Path.relative_to(\"/usr/local/../foo/../bar\", \"/usr/foo\") == \"/usr/bar\"\n assert Path.relative_to(\"/usr/local/../foo/../bar\", \"/usr/foo\", force: true) == \"../bar\"\n\n # More tests with force: true\n assert Path.relative_to(\"/etc\", \"/usr/local/foo\", force: true) == \"../../../etc\"\n assert Path.relative_to(~c\"/usr/local/foo\", \"/etc\", force: true) == \"../usr/local/foo\"\n assert Path.relative_to(\"/usr/local\", \"/usr/local/foo\", force: true) == \"..\"\n assert Path.relative_to(\"/usr/local/..\", \"/usr/local\", force: true) == \"..\"\n\n assert Path.relative_to(\"/usr/../etc/foo/../../bar\", \"/log/foo/../../usr/\", force: true) ==\n \"../bar\"\n end\n\n test \"type/1\" do\n assert Path.type(\"/usr/local/bin\") == :absolute\n assert Path.type(\"usr/local/bin\") == :relative\n assert Path.type(\"../usr/local/bin\") == :relative\n\n assert Path.type(~c\"/usr/local/bin\") == :absolute\n assert Path.type(~c\"usr/local/bin\") == :relative\n assert Path.type(~c\"../usr/local/bin\") == :relative\n\n assert Path.type([~c\"/usr/\", ~c\"local/bin\"]) == :absolute\n assert Path.type([~c\"usr/\", ~c\"local/bin\"]) == :relative\n assert Path.type([~c\"../usr\", ~c\"/local/bin\"]) == :relative\n end\n end\n\n test \"relative_to_cwd/2\" do\n assert Path.relative_to_cwd(__ENV__.file) == Path.relative_to(__ENV__.file, File.cwd!())\n\n assert Path.relative_to_cwd(to_charlist(__ENV__.file)) ==\n Path.relative_to(to_charlist(__ENV__.file), to_charlist(File.cwd!()))\n\n assert Path.relative_to_cwd(Path.dirname(File.cwd!()), force: true) == \"..\"\n\n [slash | split_cwd] = Path.split(File.cwd!())\n relative_to_root = List.duplicate(\"..\", length(split_cwd))\n\n assert Path.relative_to_cwd(slash) == slash\n assert Path.relative_to_cwd(slash, force: true) == Path.join(relative_to_root)\n end\n\n test \"absname/1,2\" do\n assert Path.absname(\"/\") |> strip_drive_letter_if_windows() == \"/\"\n assert Path.absname(\"/foo\") |> strip_drive_letter_if_windows() == \"/foo\"\n assert Path.absname(\"/./foo\") |> strip_drive_letter_if_windows() == \"/foo\"\n assert Path.absname(\"/foo/bar\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.absname(\"/foo/bar/\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.absname(\"/foo/bar/../bar\") |> strip_drive_letter_if_windows() == \"/foo/bar/../bar\"\n\n assert Path.absname(\"bar\", \"/foo\") == \"/foo/bar\"\n assert Path.absname(\"bar/\", \"/foo\") == \"/foo/bar\"\n assert Path.absname(\"bar/.\", \"/foo\") == \"/foo/bar/.\"\n assert Path.absname(\"bar/../bar\", \"/foo\") == \"/foo/bar/../bar\"\n assert Path.absname(\"bar/../bar\", \"foo\") == \"foo/bar/../bar\"\n assert Path.absname([\"bar/\", ?., ?., [\"/bar\"]], \"/foo\") == \"/foo/bar/../bar\"\n end\n\n test \"expand/1,2 with user home\" do\n home = System.user_home!() |> Path.absname()\n\n assert home == Path.expand(\"~\")\n assert home == Path.expand(~c\"~\")\n assert is_binary(Path.expand(\"~/foo\"))\n assert is_binary(Path.expand(~c\"~/foo\"))\n\n assert Path.expand(\"~/file\") == Path.join(home, \"file\")\n assert Path.expand(\"~/file\", \"whatever\") == Path.join(home, \"file\")\n assert Path.expand(\"file\", Path.expand(\"~\")) == Path.join(home, \"file\")\n assert Path.expand(\"file\", \"~\") == Path.join(home, \"file\")\n assert Path.expand(\"~file\") == Path.join(File.cwd!(), \"~file\")\n end\n\n test \"expand/1,2\" do\n assert Path.expand(\"/\") |> strip_drive_letter_if_windows() == \"/\"\n assert Path.expand(\"/foo/../..\") |> strip_drive_letter_if_windows() == \"/\"\n assert Path.expand(\"/foo\") |> strip_drive_letter_if_windows() == \"/foo\"\n assert Path.expand(\"/./foo\") |> strip_drive_letter_if_windows() == \"/foo\"\n assert Path.expand(\"/../foo\") |> strip_drive_letter_if_windows() == \"/foo\"\n assert Path.expand(\"/foo/bar\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.expand(\"/foo/bar/\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.expand(\"/foo/bar/.\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.expand(\"/foo/bar/../bar\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n\n assert Path.expand(\"bar\", \"/foo\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.expand(\"bar/\", \"/foo\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.expand(\"bar/.\", \"/foo\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n assert Path.expand(\"bar/../bar\", \"/foo\") |> strip_drive_letter_if_windows() == \"/foo/bar\"\n\n drive_letter =\n Path.expand(\"../bar/../bar\", \"/foo/../foo/../foo\") |> strip_drive_letter_if_windows()\n\n assert drive_letter == \"/bar\"\n\n drive_letter =\n Path.expand([~c\"..\", ?/, \"bar/../bar\"], ~c\"/foo/../foo/../foo\")\n |> strip_drive_letter_if_windows()\n\n assert \"/bar\" == drive_letter\n\n assert Path.expand(\"/..\") |> strip_drive_letter_if_windows() == \"/\"\n\n assert Path.expand(\"bar/../bar\", \"foo\") == Path.expand(\"foo/bar\")\n end\n\n test \"relative_to/3 (with relative paths)\" do\n # on cwd\n assert Path.relative_to(\"foo\", File.cwd!()) == \"foo\"\n assert Path.relative_to(\"./foo\", File.cwd!()) == \"foo\"\n assert Path.relative_to(\"./foo/.\", File.cwd!()) == \"foo\"\n assert Path.relative_to(\"./foo/./bar/.\", File.cwd!()) == \"foo/bar\"\n assert Path.relative_to(\"../foo/./bar/.\", File.cwd!()) == \"../foo/bar\"\n assert Path.relative_to(\"../foo/./bar/..\", File.cwd!()) == \"../foo\"\n assert Path.relative_to(\"../foo/../bar/..\", File.cwd!()) == \"..\"\n assert Path.relative_to(\"./foo/../bar/..\", File.cwd!()) == \".\"\n\n # both relative\n assert Path.relative_to(\"usr/local/foo\", \".\") == \"usr/local/foo\"\n assert Path.relative_to(\".\", \"usr/local/foo\") == \".\"\n assert Path.relative_to(\"usr/local/foo\", \"usr/local\") == \"foo\"\n assert Path.relative_to(\"usr/local/foo\", \"etc\") == \"../usr/local/foo\"\n assert Path.relative_to(~c\"usr/local/foo\", \"etc\") == \"../usr/local/foo\"\n assert Path.relative_to(\"usr/local/foo\", \"usr/local\") == \"foo\"\n assert Path.relative_to([\"usr\", ?/, ~c\"local/foo\"], ~c\"usr/local\") == \"foo\"\n end\n\n test \"safe_relative/1\" do\n assert Path.safe_relative(\"foo/bar\") == {:ok, \"foo/bar\"}\n assert Path.safe_relative(\"foo/..\") == {:ok, \"\"}\n assert Path.safe_relative(\"./foo\") == {:ok, \"foo\"}\n\n assert Path.safe_relative(\"/usr/local/foo\") == :error\n assert Path.safe_relative(\"foo/../..\") == :error\n end\n\n test \"safe_relative/2\" do\n assert Path.safe_relative(\"/usr/local/foo\", \"/usr/local\") == :error\n assert Path.safe_relative(\"../../..\", \"foo/bar\") == :error\n assert Path.safe_relative(\"../../..\", \"foo/bar\") == :error\n assert Path.safe_relative(\"/usr/local/foo\", \"/\") == :error\n end\n\n test \"rootname/2\" do\n assert Path.rootname(\"~/foo/bar.ex\", \".ex\") == \"~/foo/bar\"\n assert Path.rootname(\"~/foo/bar.exs\", \".ex\") == \"~/foo/bar.exs\"\n assert Path.rootname(\"~/foo/bar.old.ex\", \".ex\") == \"~/foo/bar.old\"\n assert Path.rootname([?~, ~c\"/foo/bar\", \".old.ex\"], ~c\".ex\") == \"~/foo/bar.old\"\n end\n\n test \"extname/1\" do\n assert Path.extname(\"foo.erl\") == \".erl\"\n assert Path.extname(\"~/foo/bar\") == \"\"\n\n assert Path.extname(~c\"foo.erl\") == \".erl\"\n assert Path.extname(~c\"~/foo/bar\") == \"\"\n end\n\n test \"dirname/1\" do\n assert Path.dirname(\"/foo/bar.ex\") == \"/foo\"\n assert Path.dirname(\"foo/bar.ex\") == \"foo\"\n\n assert Path.dirname(\"~/foo/bar.ex\") == \"~/foo\"\n assert Path.dirname(\"/foo/bar/baz/\") == \"/foo/bar/baz\"\n\n assert Path.dirname([?~, \"/foo\", ~c\"/bar.ex\"]) == \"~/foo\"\n end\n\n test \"basename/1,2\" do\n assert Path.basename(\"foo\") == \"foo\"\n assert Path.basename(\"/foo/bar\") == \"bar\"\n assert Path.basename(\"/\") == \"\"\n\n assert Path.basename(\"~/foo/bar.ex\", \".ex\") == \"bar\"\n assert Path.basename(\"~/foo/bar.exs\", \".ex\") == \"bar.exs\"\n assert Path.basename(\"~/for/bar.old.ex\", \".ex\") == \"bar.old\"\n\n assert Path.basename([?~, \"/for/bar\", ~c\".old.ex\"], \".ex\") == \"bar.old\"\n end\n\n test \"join/1\" do\n assert Path.join([\"\"]) == \"\"\n assert Path.join([\"foo\"]) == \"foo\"\n assert Path.join([\"/\", \"foo\", \"bar\"]) == \"/foo/bar\"\n assert Path.join([\"/\", \"foo\", \"bar\", \"/\"]) == \"/foo/bar\"\n assert Path.join([\"~\", \"foo\", \"bar\"]) == \"~/foo/bar\"\n assert Path.join([~c\"/foo/\", \"/bar/\"]) == \"/foo/bar\"\n assert Path.join([\"/\", \"\"]) == \"/\"\n assert Path.join([\"/\", \"\", \"bar\"]) == \"/bar\"\n assert Path.join([~c\"foo\", [?b, \"a\", ?r]]) == \"foo/bar\"\n assert Path.join([[?f, ~c\"o\", \"o\"]]) == \"foo\"\n end\n\n test \"join/2\" do\n assert Path.join(\"/foo\", \"bar\") == \"/foo/bar\"\n assert Path.join(\"~\", \"foo\") == \"~/foo\"\n\n assert Path.join(\"\", \"bar\") == \"bar\"\n assert Path.join(\"bar\", \"\") == \"bar\"\n assert Path.join(\"\", \"/bar\") == \"bar\"\n assert Path.join(\"/bar\", \"\") == \"/bar\"\n\n assert Path.join(\"foo\", \"/bar\") == \"foo/bar\"\n assert Path.join(\"/foo\", \"/bar\") == \"/foo/bar\"\n assert Path.join(\"/foo\", \"/bar\") == \"/foo/bar\"\n assert Path.join(\"/foo\", \"./bar\") == \"/foo/./bar\"\n\n assert Path.join(\"/foo\", \"/\") == \"/foo\"\n assert Path.join(\"/foo\", \"/bar/zar/\") == \"/foo/bar/zar\"\n\n assert Path.join([?/, \"foo\"], \"./bar\") == \"/foo/./bar\"\n assert Path.join([\"/foo\", \"bar\"], [\"fiz\", \"buz\"]) == \"/foobar/fizbuz\"\n end\n\n test \"split/1\" do\n assert Path.split(\"\") == []\n assert Path.split(\"foo\") == [\"foo\"]\n assert Path.split(\"/foo/bar\") == [\"/\", \"foo\", \"bar\"]\n assert Path.split([?/, \"foo/bar\"]) == [\"/\", \"foo\", \"bar\"]\n end\n\n if PathHelpers.windows?() do\n defp strip_drive_letter_if_windows([_d, ?: | rest]), do: rest\n defp strip_drive_letter_if_windows(<<_d, ?:, rest::binary>>), do: rest\n else\n defp strip_drive_letter_if_windows(path), do: path\n end\nend\n" }, { "path": "lib/elixir/test/elixir/port_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule PortTest do\n use ExUnit.Case, async: true\n\n test \"info/1,2 with registered name\" do\n {:ok, port} = :gen_udp.open(0)\n\n assert Port.info(port, :links) == {:links, [self()]}\n assert Port.info(port, :registered_name) == {:registered_name, []}\n\n Process.register(port, __MODULE__)\n\n assert Port.info(port, :registered_name) == {:registered_name, __MODULE__}\n\n :ok = :gen_udp.close(port)\n\n assert Port.info(port, :registered_name) == nil\n assert Port.info(port) == nil\n end\n\n # In contrast with other inlined functions,\n # it is important to test that monitor/1 is inlined,\n # this way we gain the monitor receive optimisation.\n test \"monitor/1 is inlined\" do\n assert expand(quote(do: Port.monitor(port())), __ENV__) ==\n quote(do: :erlang.monitor(:port, port()))\n end\n\n defp expand(expr, env) do\n {expr, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)\n expr\n end\nend\n" }, { "path": "lib/elixir/test/elixir/process_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule ProcessTest do\n use ExUnit.Case, async: true\n\n doctest Process\n\n test \"dictionary\" do\n assert Process.put(:foo, :bar) == nil\n assert Process.put(:foo, :baz) == :bar\n\n assert Enum.member?(Process.get_keys(), :foo)\n refute Enum.member?(Process.get_keys(), :bar)\n refute Enum.member?(Process.get_keys(), :baz)\n assert Process.get_keys(:bar) == []\n assert Process.get_keys(:baz) == [:foo]\n\n assert Process.get(:foo) == :baz\n assert Process.delete(:foo) == :baz\n assert Process.get(:foo) == nil\n end\n\n test \"group_leader/2 and group_leader/0\" do\n another = spawn_link(fn -> Process.sleep(1000) end)\n assert Process.group_leader(self(), another)\n assert Process.group_leader() == another\n end\n\n # In contrast with other inlined functions,\n # it is important to test that monitor/1,2 are inlined,\n # this way we gain the monitor receive optimisation.\n test \"monitor/1 and monitor/2 are inlined\" do\n assert expand(quote(do: Process.monitor(pid())), __ENV__) ==\n quote(do: :erlang.monitor(:process, pid()))\n\n assert expand(quote(do: Process.monitor(pid(), alias: :demonitor)), __ENV__) ==\n quote(do: :erlang.monitor(:process, pid(), alias: :demonitor))\n end\n\n test \"monitor/2 with monitor options\" do\n pid =\n spawn(fn ->\n receive do\n {:ping, source_alias} -> send(source_alias, :pong)\n end\n end)\n\n ref_and_alias = Process.monitor(pid, alias: :explicit_unalias)\n\n send(pid, {:ping, ref_and_alias})\n\n assert_receive :pong\n assert_receive {:DOWN, ^ref_and_alias, _, _, _}\n end\n\n test \"sleep/1\" do\n assert Process.sleep(0) == :ok\n end\n\n test \"sleep/1 with 2^32\" do\n {pid, monitor_ref} = spawn_monitor(fn -> Process.sleep(2 ** 32) end)\n refute_receive {:DOWN, ^monitor_ref, :process, ^pid, {:timeout_value, _trace}}, 100\n Process.exit(pid, :kill)\n end\n\n test \"info/2\" do\n pid = spawn(fn -> Process.sleep(1000) end)\n assert Process.info(pid, :priority) == {:priority, :normal}\n assert Process.info(pid, [:priority]) == [priority: :normal]\n\n Process.exit(pid, :kill)\n assert Process.info(pid, :backtrace) == nil\n assert Process.info(pid, [:backtrace, :status]) == nil\n end\n\n test \"info/2 with registered name\" do\n pid = spawn(fn -> nil end)\n Process.exit(pid, :kill)\n assert Process.info(pid, :registered_name) == nil\n assert Process.info(pid, [:registered_name]) == nil\n\n assert Process.info(self(), :registered_name) == {:registered_name, []}\n assert Process.info(self(), [:registered_name]) == [registered_name: []]\n\n Process.register(self(), __MODULE__)\n assert Process.info(self(), :registered_name) == {:registered_name, __MODULE__}\n assert Process.info(self(), [:registered_name]) == [registered_name: __MODULE__]\n end\n\n test \"send_after/3 sends messages once expired\" do\n Process.send_after(self(), :hello, 10)\n assert_receive :hello\n end\n\n test \"send_after/4 with absolute time sends message once expired\" do\n time = System.monotonic_time(:millisecond) + 10\n Process.send_after(self(), :hello, time, abs: true)\n assert_receive :hello\n end\n\n test \"send_after/3 returns a timer reference that can be read or cancelled\" do\n timer = Process.send_after(self(), :hello, 100_000)\n refute_received :hello\n assert is_integer(Process.read_timer(timer))\n assert is_integer(Process.cancel_timer(timer))\n\n timer = Process.send_after(self(), :hello, 0)\n assert_receive :hello\n assert Process.read_timer(timer) == false\n assert Process.cancel_timer(timer) == false\n\n timer = Process.send_after(self(), :hello, 100_000)\n assert Process.cancel_timer(timer, async: true)\n assert_receive {:cancel_timer, ^timer, result}\n assert is_integer(result)\n end\n\n test \"exit(pid, :normal) does not cause the target process to exit\" do\n Process.flag(:trap_exit, true)\n\n pid =\n spawn_link(fn ->\n receive do\n :done -> nil\n end\n end)\n\n true = Process.exit(pid, :normal)\n refute_receive {:EXIT, ^pid, :normal}, 100\n assert Process.alive?(pid)\n\n # now exit the process for real so it doesn't hang around\n true = Process.exit(pid, :abnormal)\n assert_receive {:EXIT, ^pid, :abnormal}\n refute Process.alive?(pid)\n end\n\n test \"exit(self(), :normal) causes the calling process to exit\" do\n Process.flag(:trap_exit, true)\n pid = spawn_link(fn -> Process.exit(self(), :normal) end)\n assert_receive {:EXIT, ^pid, :normal}\n refute Process.alive?(pid)\n end\n\n describe \"alias/0, alias/1, and unalias/1\" do\n test \"simple alias + unalias flow\" do\n server =\n spawn(fn ->\n receive do\n {:ping, alias} -> send(alias, :pong)\n end\n end)\n\n alias = Process.alias()\n Process.unalias(alias)\n\n send(server, {:ping, alias})\n refute_receive :pong, 20\n end\n\n test \"with :reply option when aliasing\" do\n server =\n spawn(fn ->\n receive do\n {:ping, alias} ->\n send(alias, :pong)\n send(alias, :extra_pong)\n end\n end)\n\n alias = Process.alias([:reply])\n\n send(server, {:ping, alias})\n assert_receive :pong\n refute_receive :extra_pong, 20\n end\n end\n\n describe \"get_label/1\" do\n test \"gets a process label, compatible with `:proc_lib.set_label/1`\" do\n label = {:some_label, :rand.uniform(99999)}\n assert :ok = :proc_lib.set_label(label)\n\n assert Process.get_label() == label\n assert Process.get_label(self()) == label\n end\n\n test \"returns nil when not set\" do\n pid = spawn(fn -> :ok end)\n assert Process.get_label(pid) == nil\n end\n end\n\n describe \"set_label/1\" do\n test \"sets a process label, compatible with `:proc_lib.get_label/1`\" do\n label = {:some_label, :rand.uniform(99999)}\n assert :ok = Process.set_label(label)\n\n assert :proc_lib.get_label(self()) == label\n end\n end\n\n defp expand(expr, env) do\n {expr, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)\n expr\n end\nend\n" }, { "path": "lib/elixir/test/elixir/protocol/consolidation_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\npath = Path.expand(\"../../ebin\", __DIR__)\nFile.mkdir_p!(path)\n\nfiles = Path.wildcard(PathHelpers.fixture_path(\"consolidation/*\"))\nKernel.ParallelCompiler.compile_to_path(files, path, return_diagnostics: true)\n\ndefmodule Protocol.ConsolidationTest do\n use ExUnit.Case, async: true\n alias Protocol.ConsolidationTest.{Sample, WithAny, NoImpl}\n\n defimpl WithAny, for: Map do\n def ok(map, _opts) do\n {:ok, map}\n end\n end\n\n defimpl WithAny, for: Any do\n def ok(any, _opts) do\n {:ok, any}\n end\n end\n\n defmodule NoImplStruct do\n defstruct a: 0, b: 0\n end\n\n defmodule ImplStruct do\n @derive [WithAny]\n defstruct a: 0, b: 0\n\n defimpl Sample do\n @compile {:no_warn_undefined, Unknown}\n\n def ok(struct) do\n Unknown.undefined(struct)\n end\n end\n end\n\n Code.append_path(path)\n\n # Any is ignored because there is no fallback\n :code.purge(Sample)\n :code.delete(Sample)\n {:ok, binary} = Protocol.consolidate(Sample, [Any, ImplStruct])\n :code.load_binary(Sample, ~c\"protocol_test.exs\", binary)\n\n defp sample_binary, do: unquote(binary)\n\n # Any should be moved to the end\n :code.purge(WithAny)\n :code.delete(WithAny)\n {:ok, binary} = Protocol.consolidate(WithAny, [Any, ImplStruct, Map])\n :code.load_binary(WithAny, ~c\"protocol_test.exs\", binary)\n\n defp with_any_binary, do: unquote(binary)\n\n # No Any\n :code.purge(NoImpl)\n :code.delete(NoImpl)\n {:ok, binary} = Protocol.consolidate(NoImpl, [])\n :code.load_binary(NoImpl, ~c\"protocol_test.exs\", binary)\n\n defp no_impl_binary, do: unquote(binary)\n\n test \"consolidated?/1\" do\n assert Protocol.consolidated?(WithAny)\n refute Protocol.consolidated?(Enumerable)\n end\n\n test \"consolidation warns on new implementations\" do\n output =\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n defimpl WithAny, for: Integer do\n def ok(_any, _opts), do: :ok\n end\n end)\n\n assert output =~ ~r\"the .+WithAny protocol has already been consolidated\"\n after\n :code.purge(WithAny.Integer)\n :code.delete(WithAny.Integer)\n end\n\n test \"consolidation warns on new implementations unless disabled\" do\n Code.put_compiler_option(:ignore_already_consolidated, true)\n\n defimpl WithAny, for: Integer do\n def ok(_any), do: :ok\n end\n after\n Code.put_compiler_option(:ignore_already_consolidated, false)\n :code.purge(WithAny.Integer)\n :code.delete(WithAny.Integer)\n end\n\n test \"consolidated implementations without fallback to any\" do\n assert is_nil(Sample.impl_for(:foo))\n assert is_nil(Sample.impl_for(fn x -> x end))\n assert is_nil(Sample.impl_for(1))\n assert is_nil(Sample.impl_for(1.1))\n assert is_nil(Sample.impl_for([]))\n assert is_nil(Sample.impl_for([1, 2, 3]))\n assert is_nil(Sample.impl_for({}))\n assert is_nil(Sample.impl_for({1, 2, 3}))\n assert is_nil(Sample.impl_for(\"foo\"))\n assert is_nil(Sample.impl_for(<<1>>))\n assert is_nil(Sample.impl_for(self()))\n assert is_nil(Sample.impl_for(%{}))\n assert is_nil(Sample.impl_for(hd(:erlang.ports())))\n assert is_nil(Sample.impl_for(make_ref()))\n\n assert Sample.impl_for(%ImplStruct{}) == Sample.Protocol.ConsolidationTest.ImplStruct\n assert Sample.impl_for(%NoImplStruct{}) == nil\n end\n\n test \"consolidated implementations with fallback to any\" do\n assert WithAny.impl_for(%NoImplStruct{}) == WithAny.Any\n\n # Derived\n assert WithAny.impl_for(%ImplStruct{}) ==\n Protocol.ConsolidationTest.WithAny.Protocol.ConsolidationTest.ImplStruct\n\n assert WithAny.impl_for(%{__struct__: \"foo\"}) == WithAny.Map\n assert WithAny.impl_for(%{}) == WithAny.Map\n assert WithAny.impl_for(self()) == WithAny.Any\n end\n\n test \"consolidation keeps docs\" do\n {:ok, {Sample, [{~c\"Docs\", docs_bin}]}} = :beam_lib.chunks(sample_binary(), [~c\"Docs\"])\n {:docs_v1, _, _, _, _, _, docs} = :erlang.binary_to_term(docs_bin)\n ok_doc = List.keyfind(docs, {:function, :ok, 1}, 0)\n\n assert {{:function, :ok, 1}, _, [\"ok(term)\"], %{\"en\" => \"Ok\"}, _} = ok_doc\n end\n\n @tag :requires_source\n test \"consolidation keeps source\" do\n assert Sample.__info__(:compile)[:source]\n end\n\n test \"consolidated keeps callbacks\" do\n {:ok, callbacks} = Code.Typespec.fetch_callbacks(sample_binary())\n assert callbacks != []\n end\n\n test \"consolidation updates attributes\" do\n assert Sample.__protocol__(:consolidated?)\n assert Sample.__protocol__(:impls) == {:consolidated, [ImplStruct]}\n assert WithAny.__protocol__(:consolidated?)\n assert WithAny.__protocol__(:impls) == {:consolidated, [Any, Map, ImplStruct]}\n assert NoImpl.__protocol__(:consolidated?)\n assert NoImpl.__protocol__(:impls) == {:consolidated, []}\n end\n\n describe \"exports\" do\n import Module.Types.Descr\n alias Module.Types.Of\n\n defp exports(binary) do\n {:ok, {_, [{~c\"ExCk\", check_bin}]}} = :beam_lib.chunks(binary, [~c\"ExCk\"])\n assert {:elixir_checker_v7, contents} = :erlang.binary_to_term(check_bin)\n Map.new(contents.exports)\n end\n\n test \"keeps deprecations\" do\n deprecated = [{{:ok, 1}, \"Reason\"}]\n assert deprecated == Sample.__info__(:deprecated)\n\n assert %{{:ok, 1} => %{deprecated: \"Reason\", sig: _}} = exports(sample_binary())\n end\n\n test \"defines signatures without fallback to any\" do\n exports = exports(sample_binary())\n\n assert %{{:impl_for, 1} => %{sig: {:strong, domain, clauses}}} = exports\n assert domain == [term()]\n\n assert clauses == [\n {[Of.impl(ImplStruct, :open)],\n atom([Sample.Protocol.ConsolidationTest.ImplStruct])},\n {[negation(Of.impl(ImplStruct, :open))], atom([nil])}\n ]\n\n assert %{{:impl_for!, 1} => %{sig: {:strong, domain, clauses}}} = exports\n assert domain == [Of.impl(ImplStruct, :open)]\n\n assert clauses == [\n {[Of.impl(ImplStruct, :open)],\n atom([Sample.Protocol.ConsolidationTest.ImplStruct])}\n ]\n\n assert %{{:ok, 1} => %{sig: {:strong, nil, clauses}}} = exports\n\n assert clauses == [\n {[Of.impl(ImplStruct, :open)], dynamic()}\n ]\n end\n\n test \"defines signatures with fallback to any\" do\n exports = exports(with_any_binary())\n\n assert %{\n {:impl_for, 1} => %{sig: {:strong, domain, clauses}},\n {:impl_for!, 1} => %{sig: {:strong, domain, clauses}}\n } = exports\n\n assert domain == [term()]\n\n assert clauses == [\n {[Of.impl(Map, :open)], atom([WithAny.Map])},\n {[Of.impl(ImplStruct, :open)],\n atom([WithAny.Protocol.ConsolidationTest.ImplStruct])},\n {[negation(union(Of.impl(ImplStruct, :open), Of.impl(Map, :open)))],\n atom([WithAny.Any])}\n ]\n\n assert %{{:ok, 2} => %{sig: {:strong, nil, clauses}}} = exports\n\n assert clauses == [\n {[term(), term()], dynamic()}\n ]\n end\n\n test \"defines signatures without implementation\" do\n exports = exports(no_impl_binary())\n\n assert %{{:impl_for, 1} => %{sig: {:strong, domain, clauses}}} = exports\n assert domain == [term()]\n assert clauses == [{[term()], atom([nil])}]\n\n assert %{{:impl_for!, 1} => %{sig: {:strong, domain, clauses}}} = exports\n assert domain == [none()]\n assert clauses == [{[none()], none()}]\n\n assert %{{:ok, 1} => %{sig: {:strong, nil, clauses}}} = exports\n assert clauses == [{[none()], dynamic()}]\n end\n end\n\n test \"consolidation errors on missing BEAM files\" do\n import PathHelpers\n\n write_beam(\n defmodule ExampleModule do\n end\n )\n\n defprotocol NoBeam do\n def example(arg)\n end\n\n assert Protocol.consolidate(ExampleModule, []) == {:error, :not_a_protocol}\n assert Protocol.consolidate(NoBeam, []) == {:error, :no_beam_info}\n end\n\n test \"protocol not implemented\" do\n message =\n \"protocol Protocol.ConsolidationTest.Sample not implemented for Atom. \" <>\n \"This protocol is implemented for: Protocol.ConsolidationTest.ImplStruct\" <>\n \"\\n\\nGot value:\\n\\n :foo\\n\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n sample = String.to_atom(\"Elixir.Protocol.ConsolidationTest.Sample\")\n sample.ok(:foo)\n end\n end\n\n describe \"extraction\" do\n test \"protocols\" do\n protos = Protocol.extract_protocols([Application.app_dir(:elixir, \"ebin\")])\n assert Enumerable in protos\n assert Inspect in protos\n end\n\n test \"protocols with expanded path\" do\n path = to_charlist(Application.app_dir(:elixir, \"ebin\"))\n {:ok, mods} = :file.list_dir(path)\n protos = Protocol.extract_protocols([{path, mods}])\n assert Enumerable in protos\n assert Inspect in protos\n end\n\n test \"implementations with charlist path\" do\n impls =\n Protocol.extract_impls(Enumerable, [to_charlist(Application.app_dir(:elixir, \"ebin\"))])\n\n assert List in impls\n assert Function in impls\n end\n\n test \"implementations with binary path\" do\n impls = Protocol.extract_impls(Enumerable, [Application.app_dir(:elixir, \"ebin\")])\n assert List in impls\n assert Function in impls\n end\n\n test \"implementations with expanded path\" do\n path = to_charlist(Application.app_dir(:elixir, \"ebin\"))\n {:ok, mods} = :file.list_dir(path)\n impls = Protocol.extract_impls(Enumerable, [{path, mods}])\n assert List in impls\n assert Function in impls\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/protocol_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule ProtocolTest do\n use ExUnit.Case, async: true\n\n doctest Protocol\n\n {_, _, sample_binary, _} =\n defprotocol Sample do\n @type t :: any\n @doc \"Ok\"\n @deprecated \"Reason\"\n @spec ok(t) :: boolean\n def ok(term)\n end\n\n @sample_binary sample_binary\n\n {_, _, with_any_binary, _} =\n defprotocol WithAny do\n @fallback_to_any true\n @doc \"Ok\"\n def ok(term)\n end\n\n @with_any_binary with_any_binary\n\n defprotocol Derivable do\n @undefined_impl_description \"you should try harder\"\n\n @impl true\n defmacro __deriving__(module, options) do\n struct = Macro.struct!(module, __CALLER__)\n\n quote do\n defimpl Derivable, for: unquote(module) do\n def ok(arg) do\n {:ok, arg, unquote(Macro.escape(struct)), unquote(options)}\n end\n end\n end\n end\n\n def ok(a)\n end\n\n defimpl Derivable, for: Any do\n def ok(arg) do\n {:ok, arg}\n end\n end\n\n defimpl WithAny, for: Map do\n def ok(map) do\n {:ok, map}\n end\n end\n\n defimpl WithAny, for: Any do\n def ok(any) do\n {:ok, any}\n end\n end\n\n defmodule NoImplStruct do\n defstruct a: 0, b: 0\n end\n\n defmodule ImplStruct do\n @derive [WithAny, Derivable]\n defstruct a: 0, b: 0\n\n defimpl Sample do\n @compile {:no_warn_undefined, Unknown}\n\n def ok(struct) do\n Unknown.undefined(struct)\n end\n end\n end\n\n defmodule ImplStructExplicitFor do\n defstruct a: 0, b: 0\n\n defimpl Sample, for: __MODULE__ do\n def ok(_struct), do: true\n end\n end\n\n test \"protocol implementations without any\" do\n assert is_nil(Sample.impl_for(:foo))\n assert is_nil(Sample.impl_for(fn x -> x end))\n assert is_nil(Sample.impl_for(1))\n assert is_nil(Sample.impl_for(1.1))\n assert is_nil(Sample.impl_for([]))\n assert is_nil(Sample.impl_for([1, 2, 3]))\n assert is_nil(Sample.impl_for({}))\n assert is_nil(Sample.impl_for({1, 2, 3}))\n assert is_nil(Sample.impl_for(\"foo\"))\n assert is_nil(Sample.impl_for(<<1>>))\n assert is_nil(Sample.impl_for(%{}))\n assert is_nil(Sample.impl_for(self()))\n assert is_nil(Sample.impl_for(hd(:erlang.ports())))\n assert is_nil(Sample.impl_for(make_ref()))\n\n assert Sample.impl_for(%ImplStruct{}) == Sample.ProtocolTest.ImplStruct\n assert Sample.impl_for(%ImplStructExplicitFor{}) == Sample.ProtocolTest.ImplStructExplicitFor\n assert Sample.impl_for(%NoImplStruct{}) == nil\n assert is_nil(Sample.impl_for(%{__struct__: nil}))\n end\n\n test \"protocol implementation with Any and struct fallbacks\" do\n assert WithAny.impl_for(%NoImplStruct{}) == WithAny.Any\n assert WithAny.impl_for(%{__struct__: nil}) == WithAny.Any\n assert WithAny.impl_for(%{__struct__: \"foo\"}) == WithAny.Map\n assert WithAny.impl_for(%{}) == WithAny.Map\n assert WithAny.impl_for(self()) == WithAny.Any\n\n # Derived\n assert WithAny.impl_for(%ImplStruct{}) == ProtocolTest.WithAny.ProtocolTest.ImplStruct\n end\n\n test \"protocol not implemented\" do\n message =\n \"\"\"\n protocol ProtocolTest.Sample not implemented for Atom\n\n Got value:\n\n :foo\n \"\"\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n sample = String.to_atom(\"Elixir.ProtocolTest.Sample\")\n sample.ok(:foo)\n end\n end\n\n test \"protocol documentation and deprecated\" do\n import PathHelpers\n\n write_beam(\n defprotocol SampleDocsProto do\n @doc \"Ok\"\n @deprecated \"Reason\"\n @spec ok(t) :: boolean\n def ok(term)\n end\n )\n\n write_beam(\n defimpl SampleDocsProto, for: List do\n def ok(_), do: true\n end\n )\n\n write_beam(\n defimpl SampleDocsProto, for: Map do\n @moduledoc \"for map\"\n\n def ok(_), do: true\n end\n )\n\n {:docs_v1, _, _, _, _, _, docs} = Code.fetch_docs(SampleDocsProto)\n\n assert {{:type, :t, 0}, _, [], %{\"en\" => type_doc}, _} = List.keyfind(docs, {:type, :t, 0}, 0)\n assert type_doc =~ \"All the types that implement this protocol\"\n\n assert {{:function, :ok, 1}, _, [\"ok(term)\"], %{\"en\" => \"Ok\"}, _} =\n List.keyfind(docs, {:function, :ok, 1}, 0)\n\n deprecated = SampleDocsProto.__info__(:deprecated)\n assert [{{:ok, 1}, \"Reason\"}] = deprecated\n\n {:docs_v1, _, _, _, :hidden, _, _} = Code.fetch_docs(SampleDocsProto.List)\n {:docs_v1, _, _, _, moduledoc, _, _} = Code.fetch_docs(SampleDocsProto.Map)\n assert moduledoc == %{\"en\" => \"for map\"}\n end\n\n @compile {:no_warn_undefined, WithAll}\n\n test \"protocol keeps underlying UndefinedFunctionError\" do\n assert_raise UndefinedFunctionError, fn ->\n WithAll.ok(%ImplStruct{})\n end\n end\n\n test \"protocol defines callbacks\" do\n assert [{:type, {17, 13}, :fun, args}] = get_callbacks(@sample_binary, :ok, 1)\n\n assert args == [\n {:type, {17, 13}, :product, [{:user_type, {17, 16}, :t, []}]},\n {:type, {17, 22}, :boolean, []}\n ]\n\n assert [{:type, 27, :fun, args}] = get_callbacks(@with_any_binary, :ok, 1)\n assert args == [{:type, 27, :product, [{:user_type, 27, :t, []}]}, {:type, 27, :term, []}]\n end\n\n test \"protocol defines t/0 type with documentation\" do\n assert {:type, {:t, {_, _, :any, []}, []}} = get_type(@sample_binary, :t, 0)\n end\n\n test \"protocol defines functions and attributes\" do\n assert Sample.__protocol__(:module) == Sample\n assert Sample.__protocol__(:functions) == [ok: 1]\n refute Sample.__protocol__(:consolidated?)\n assert Sample.__protocol__(:impls) == :not_consolidated\n assert Sample.__info__(:attributes)[:__protocol__] == [fallback_to_any: false]\n\n assert WithAny.__protocol__(:module) == WithAny\n assert WithAny.__protocol__(:functions) == [ok: 1]\n refute WithAny.__protocol__(:consolidated?)\n assert WithAny.__protocol__(:impls) == :not_consolidated\n assert WithAny.__info__(:attributes)[:__protocol__] == [fallback_to_any: true]\n end\n\n test \"defimpl\" do\n module = Module.concat(Sample, ImplStruct)\n assert module.__impl__(:for) == ImplStruct\n assert module.__impl__(:protocol) == Sample\n assert module.__info__(:attributes)[:__impl__] == [protocol: Sample, for: ImplStruct]\n end\n\n test \"defimpl with implicit derive\" do\n module = Module.concat(WithAny, ImplStruct)\n assert module.__impl__(:for) == ImplStruct\n assert module.__impl__(:protocol) == WithAny\n assert module.__info__(:attributes)[:__impl__] == [protocol: WithAny, for: ImplStruct]\n end\n\n test \"defimpl with explicit derive\" do\n module = Module.concat(Derivable, ImplStruct)\n assert module.__impl__(:for) == ImplStruct\n assert module.__impl__(:protocol) == Derivable\n assert module.__info__(:attributes)[:__impl__] == [protocol: Derivable, for: ImplStruct]\n end\n\n test \"defimpl with multiple for\" do\n defprotocol Multi do\n def test(a)\n end\n\n defimpl Multi, for: [Atom, Integer] do\n def test(a), do: a\n end\n\n assert Multi.test(1) == 1\n assert Multi.test(:a) == :a\n end\n\n test \"defimpl without :for option when outside a module\" do\n msg = \"defimpl/3 expects a :for option when declared outside a module\"\n\n assert_raise ArgumentError, msg, fn ->\n ast =\n quote do\n defimpl Sample do\n def ok(_term), do: true\n end\n end\n\n Code.eval_quoted(ast, [], %{__ENV__ | module: nil})\n end\n end\n\n defp get_callbacks(beam, name, arity) do\n {:ok, callbacks} = Code.Typespec.fetch_callbacks(beam)\n List.keyfind(callbacks, {name, arity}, 0) |> elem(1)\n end\n\n defp get_type(beam, name, arity) do\n {:ok, types} = Code.Typespec.fetch_types(beam)\n\n assert {:value, value} =\n :lists.search(&match?({_, {^name, _, args}} when length(args) == arity, &1), types)\n\n value\n end\n\n test \"derives protocol implicitly\" do\n struct = %ImplStruct{a: 1, b: 1}\n assert WithAny.ok(struct) == {:ok, struct}\n\n struct = %NoImplStruct{a: 1, b: 1}\n assert WithAny.ok(struct) == {:ok, struct}\n end\n\n test \"derives protocol explicitly\" do\n struct = %ImplStruct{a: 1, b: 1}\n assert Derivable.ok(struct) == {:ok, struct, %ImplStruct{}, []}\n\n assert_raise Protocol.UndefinedError,\n ~r\"protocol ProtocolTest.Derivable not implemented for ProtocolTest.NoImplStruct \\(a struct\\), you should try harder\",\n fn ->\n struct = %NoImplStruct{a: 1, b: 1}\n Derivable.ok(struct)\n end\n end\n\n test \"derives protocol explicitly with options\" do\n defmodule AnotherStruct do\n @derive [{Derivable, :ok}]\n @derive [WithAny]\n defstruct a: 0, b: 0\n end\n\n struct = struct(AnotherStruct, a: 1, b: 1)\n assert Derivable.ok(struct) == {:ok, struct, struct(AnotherStruct), :ok}\n end\n\n test \"derive protocol explicitly via API\" do\n defmodule InlineStruct do\n defstruct a: 0, b: 0\n end\n\n require Protocol\n assert Protocol.derive(Derivable, InlineStruct, :oops) == :ok\n\n struct = struct(InlineStruct, a: 1, b: 1)\n assert Derivable.ok(struct) == {:ok, struct, struct(InlineStruct), :oops}\n end\n\n @tag :requires_source\n test \"derived implementation keeps local file/line info\" do\n assert ProtocolTest.WithAny.ProtocolTest.ImplStruct.__info__(:compile)[:source] ==\n String.to_charlist(__ENV__.file)\n end\n\n describe \"warnings\" do\n import ExUnit.CaptureIO\n\n test \"with no definitions\" do\n assert capture_io(:stderr, fn ->\n defprotocol SampleWithNoDefinitions do\n end\n end) =~ \"protocols must define at least one function, but none was defined\"\n end\n\n test \"when @callbacks and friends are defined inside a protocol\" do\n message =\n capture_io(:stderr, fn ->\n defprotocol SampleWithCallbacks do\n @spec with_specs(any(), keyword()) :: tuple()\n def with_specs(term, options)\n\n @spec with_specs_and_when(any(), opts) :: tuple() when opts: keyword\n def with_specs_and_when(term, options)\n\n def without_specs(term, options \\\\ [])\n\n @callback foo :: {:ok, term}\n @callback foo_when(x) :: {:ok, x} when x: term\n @macrocallback bar(term) :: {:ok, term}\n\n @optional_callbacks [foo: 0]\n @optional_callbacks [without_specs: 2]\n end\n end)\n\n assert message =~\n \"default arguments in protocol definitions is deprecated\"\n\n assert message =~\n \"cannot define @callback foo/0 inside protocol, use def/1 to outline your protocol definition\"\n\n assert message =~\n \"cannot define @callback foo_when/1 inside protocol, use def/1 to outline your protocol definition\"\n\n assert message =~\n \"cannot define @macrocallback bar/1 inside protocol, use def/1 to outline your protocol definition\"\n\n assert message =~\n \"cannot define @optional_callbacks inside protocol, all of the protocol definitions are required\"\n end\n\n test \"when deriving after struct\" do\n assert capture_io(:stderr, fn ->\n defmodule DeriveTooLate do\n defstruct []\n @derive [{Derivable, :ok}]\n end\n end) =~\n \"module attribute @derive was set after defstruct, all @derive calls must come before defstruct\"\n end\n\n test \"when deriving with no struct\" do\n assert capture_io(:stderr, fn ->\n defmodule DeriveNeverUsed do\n @derive [{Derivable, :ok}]\n end\n end) =~\n \"module attribute @derive was set but never used (it must come before defstruct)\"\n end\n end\n\n describe \"errors\" do\n test \"cannot derive without any implementation\" do\n assert_raise ArgumentError,\n ~r\"could not load module #{inspect(Sample.Any)} due to reason :nofile, cannot derive #{inspect(Sample)}\",\n fn ->\n defmodule NotCompiled do\n @derive [Sample]\n defstruct hello: :world\n end\n end\n end\n end\nend\n\ndefmodule Protocol.DebugInfoTest do\n use ExUnit.Case\n\n test \"protocols always keep debug_info\" do\n Code.compiler_options(debug_info: false)\n\n {:module, _, binary, _} =\n defprotocol DebugInfoProto do\n def example(info)\n end\n\n assert {:ok, {DebugInfoProto, [debug_info: debug_info]}} =\n :beam_lib.chunks(binary, [:debug_info])\n\n assert {:debug_info_v1, :elixir_erl, {:elixir_v1, _, _}} = debug_info\n after\n Code.compiler_options(debug_info: true)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/range_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule RangeTest do\n use ExUnit.Case, async: true\n\n doctest Range\n\n defp reverse(first..last//step) do\n last..first//-step\n end\n\n defp assert_disjoint(r1, r2) do\n disjoint_assertions(r1, r2, true)\n end\n\n defp assert_overlap(r1, r2) do\n disjoint_assertions(r1, r2, false)\n end\n\n defp disjoint_assertions(r1, r2, expected) do\n # The caller should choose pairs of representative ranges, and we take care\n # here of commuting them.\n Enum.each([[r1, r2], [r2, r1]], fn [a, b] ->\n assert Range.disjoint?(a, b) == expected\n assert Range.disjoint?(reverse(a), b) == expected\n assert Range.disjoint?(a, reverse(b)) == expected\n assert Range.disjoint?(reverse(a), reverse(b)) == expected\n end)\n end\n\n test \"new\" do\n assert Range.new(1, 3) == 1..3//1\n assert Range.new(1, 3, 2) == 1..3//2\n assert Range.new(3, 1, -2) == 3..1//-2\n\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert Range.new(3, 1) == 3..1//-1\n end) =~ \"default to a step of -1\"\n end\n\n test \"fields\" do\n assert (1..3).first == 1\n assert (1..3).last == 3\n assert (1..3).step == 1\n assert (3..1//-1).step == -1\n assert (1..3//2).step == 2\n end\n\n test \"inspect\" do\n assert inspect(1..3) == \"1..3\"\n assert inspect(1..3//2) == \"1..3//2\"\n\n assert inspect(3..1//-1) == \"3..1//-1\"\n assert inspect(3..1//1) == \"3..1//1\"\n end\n\n test \"shift\" do\n assert Range.shift(0..10//2, 2) == 4..14//2\n assert Range.shift(0..10//2, 0) == 0..10//2\n assert Range.shift(10..0//-2, 2) == 6..-4//-2\n assert Range.shift(10..0//-2, -2) == 14..4//-2\n end\n\n test \"in guard equality\" do\n case {1, 1..1} do\n {n, range} when range == n..n//1 -> true\n end\n end\n\n test \"step is a non-zero integer\" do\n step = 1.0\n message = ~r\"the step to be a non-zero integer\"\n assert_raise ArgumentError, message, fn -> 1..3//step end\n\n step = 0\n message = ~r\"the step to be a non-zero integer\"\n assert_raise ArgumentError, message, fn -> 1..3//step end\n end\n\n describe \"disjoint?\" do\n test \"returns true for disjoint ranges\" do\n assert_disjoint(1..5, 6..9)\n assert_disjoint(-3..1, 2..3)\n assert_disjoint(-7..-5, -3..-1)\n\n assert Range.disjoint?(1..1, 2..2) == true\n assert Range.disjoint?(2..2, 1..1) == true\n end\n\n test \"returns false for ranges with common endpoints\" do\n assert_overlap(1..5, 5..9)\n assert_overlap(-1..0, 0..1)\n assert_overlap(-7..-5, -5..-1)\n end\n\n test \"returns false for ranges that overlap\" do\n assert_overlap(1..5, 3..7)\n assert_overlap(-3..1, -1..3)\n assert_overlap(-7..-5, -5..-1)\n\n assert Range.disjoint?(1..1, 1..1) == false\n end\n end\n\n describe \"split\" do\n @times 10\n\n test \"increasing ranges\" do\n for _ <- 1..@times do\n left = Enum.random(-10..10)\n right = Enum.random(-10..10)\n input = min(left, right)..max(left, right)//Enum.random(1..3)\n\n for split <- -3..3 do\n {left, right} = Range.split(input, split)\n assert input.first == left.first\n assert input.last == right.last\n assert input.step == left.step\n assert input.step == right.step\n\n assert Range.size(input) == Range.size(left) + Range.size(right),\n \"size mismatch: Range.split(#{inspect(input)}, #{split})\"\n end\n end\n end\n\n test \"decreasing ranges\" do\n for _ <- 1..@times do\n left = Enum.random(-10..10)\n right = Enum.random(-10..10)\n input = max(left, right)..min(left, right)//-Enum.random(1..3)\n\n for split <- -3..3 do\n {left, right} = Range.split(input, split)\n assert input.first == left.first\n assert input.last == right.last\n assert input.step == left.step\n assert input.step == right.step\n\n assert Range.size(input) == Range.size(left) + Range.size(right),\n \"size mismatch: Range.split(#{inspect(input)}, #{split})\"\n end\n end\n end\n\n test \"empty increasing ranges\" do\n for _ <- 1..@times,\n left = Enum.random(-10..10),\n right = Enum.random(-10..10),\n left != right do\n input = min(left, right)..max(left, right)//-Enum.random(1..3)\n\n for split <- -3..3 do\n {left, right} = Range.split(input, split)\n assert input.first == left.first\n assert input.last == right.last\n assert input.step == left.step\n assert input.step == right.step\n\n assert Range.size(input) == Range.size(left) + Range.size(right),\n \"size mismatch: Range.split(#{inspect(input)}, #{split})\"\n end\n end\n end\n\n test \"empty decreasing ranges\" do\n for _ <- 1..@times,\n left = Enum.random(-10..10),\n right = Enum.random(-10..10),\n left != right do\n input = max(left, right)..min(left, right)//Enum.random(1..3)\n\n for split <- -3..3 do\n {left, right} = Range.split(input, split)\n assert input.first == left.first\n assert input.last == right.last\n assert input.step == left.step\n assert input.step == right.step\n\n assert Range.size(input) == Range.size(left) + Range.size(right),\n \"size mismatch: Range.split(#{inspect(input)}, #{split})\"\n end\n end\n end\n end\n\n describe \"old ranges\" do\n test \"enum\" do\n asc = %{__struct__: Range, first: 1, last: 3}\n desc = %{__struct__: Range, first: 3, last: 1}\n\n assert Enum.to_list(asc) == [1, 2, 3]\n assert Enum.member?(asc, 2)\n assert Enum.count(asc) == 3\n assert Enum.drop(asc, 1) == [2, 3]\n assert Enum.slice([1, 2, 3, 4, 5, 6], asc) == [2, 3, 4]\n # testing private Enum.aggregate\n assert Enum.max(asc) == 3\n assert Enum.sum(asc) == 6\n assert Enum.min_max(asc) == {1, 3}\n assert Enum.reduce(asc, 0, fn a, b -> a + b end) == 6\n\n assert Enum.to_list(desc) == [3, 2, 1]\n assert Enum.member?(desc, 2)\n assert Enum.count(desc) == 3\n assert Enum.drop(desc, 1) == [2, 1]\n\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert Enum.slice([1, 2, 3, 4, 5, 6], desc) == []\n end) =~ \"negative steps are not supported in Enum.slice/2, pass 3..1//1 instead\"\n\n # testing private Enum.aggregate\n assert Enum.max(desc) == 3\n assert Enum.sum(desc) == 6\n assert Enum.min_max(desc) == {1, 3}\n assert Enum.reduce(desc, 0, fn a, b -> a + b end) == 6\n end\n\n test \"string\" do\n asc = %{__struct__: Range, first: 1, last: 3}\n desc = %{__struct__: Range, first: 3, last: 1}\n\n assert String.slice(\"elixir\", asc) == \"lix\"\n\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert String.slice(\"elixir\", desc) == \"\"\n end) =~ \"negative steps are not supported in String.slice/2, pass 3..1//1 instead\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/record_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule RecordTest do\n use ExUnit.Case, async: true\n\n require Record\n doctest Record\n\n test \"extract/2 extracts information from an Erlang file\" do\n assert Record.extract(:file_info, from_lib: \"kernel/include/file.hrl\") == [\n size: :undefined,\n type: :undefined,\n access: :undefined,\n atime: :undefined,\n mtime: :undefined,\n ctime: :undefined,\n mode: :undefined,\n links: :undefined,\n major_device: :undefined,\n minor_device: :undefined,\n inode: :undefined,\n uid: :undefined,\n gid: :undefined\n ]\n end\n\n test \"extract/2 handles nested records too\" do\n namespace = Record.extract(:xmlElement, from_lib: \"xmerl/include/xmerl.hrl\")[:namespace]\n assert is_tuple(namespace)\n assert elem(namespace, 0) == :xmlNamespace\n end\n\n test \"extract/2 with defstruct\" do\n defmodule StructExtract do\n defstruct Record.extract(:file_info, from_lib: \"kernel/include/file.hrl\")\n end\n\n assert %{__struct__: StructExtract, size: :undefined} = StructExtract.__struct__()\n end\n\n test \"extract_all/1 extracts all records information from an Erlang file\" do\n all_extract = Record.extract_all(from_lib: \"kernel/include/file.hrl\")\n # has been stable over the very long time\n assert length(all_extract) == 2\n assert all_extract[:file_info]\n assert all_extract[:file_descriptor]\n end\n\n # We need indirection to avoid warnings\n defp record?(data, kind) do\n Record.is_record(data, kind)\n end\n\n test \"is_record/2\" do\n assert record?({User, \"meg\", 27}, User)\n refute record?({User, \"meg\", 27}, Author)\n refute record?(13, Author)\n refute record?({\"user\", \"meg\", 27}, \"user\")\n refute record?({}, User)\n refute record?([], User)\n end\n\n # We need indirection to avoid warnings\n defp record?(data) do\n Record.is_record(data)\n end\n\n test \"is_record/1\" do\n assert record?({User, \"john\", 27})\n refute record?({\"john\", 27})\n refute record?(13)\n refute record?({})\n end\n\n def record_in_guard?(term) when Record.is_record(term), do: true\n def record_in_guard?(_), do: false\n\n def record_in_guard?(term, kind) when Record.is_record(term, kind), do: true\n def record_in_guard?(_, _), do: false\n\n test \"is_record/1,2 (in guard)\" do\n assert record_in_guard?({User, \"john\", 27})\n refute record_in_guard?({\"user\", \"john\", 27})\n\n assert record_in_guard?({User, \"john\", 27}, User)\n refute record_in_guard?({\"user\", \"john\", 27}, \"user\")\n end\n\n Record.defrecord(:timestamp, [:date, :time])\n Record.defrecord(:user, __MODULE__, name: \"john\", age: 25)\n\n Record.defrecordp(:file_info, Record.extract(:file_info, from_lib: \"kernel/include/file.hrl\"))\n\n Record.defrecordp(\n :certificate,\n :OTPCertificate,\n Record.extract(:OTPCertificate, from_lib: \"public_key/include/public_key.hrl\")\n )\n\n test \"records are tagged\" do\n assert elem(file_info(), 0) == :file_info\n end\n\n test \"records macros\" do\n record = user()\n assert user(record, :name) == \"john\"\n assert user(record, :age) == 25\n\n record = user(record, name: \"meg\")\n assert user(record, :name) == \"meg\"\n\n assert elem(record, user(:name)) == \"meg\"\n assert elem(record, 0) == RecordTest\n\n user(name: name) = record\n assert name == \"meg\"\n\n assert user(:name) == 1\n end\n\n test \"records with default values\" do\n record = user(_: :_, name: \"meg\")\n assert user(record, :name) == \"meg\"\n assert user(record, :age) == :_\n assert match?(user(_: _), user())\n end\n\n test \"records preserve side-effects order\" do\n user =\n user(\n age: send(self(), :age),\n name: send(self(), :name)\n )\n\n assert Process.info(self(), :messages) == {:messages, [:age, :name]}\n\n _ =\n user(user,\n age: send(self(), :update_age),\n name: send(self(), :update_name)\n )\n\n assert Process.info(self(), :messages) ==\n {:messages, [:age, :name, :update_age, :update_name]}\n end\n\n test \"nested records preserve side-effects order\" do\n user =\n user(\n age:\n user(\n age: send(self(), :inner_age),\n name: send(self(), :inner_name)\n ),\n name: send(self(), :name)\n )\n\n assert user == {RecordTest, :name, {RecordTest, :inner_name, :inner_age}}\n assert for(_ <- 1..3, do: assert_receive(_)) == [:inner_age, :inner_name, :name]\n\n user =\n user(\n name: send(self(), :name),\n age:\n user(\n age: send(self(), :inner_age),\n name: send(self(), :inner_name)\n )\n )\n\n assert user == {RecordTest, :name, {RecordTest, :inner_name, :inner_age}}\n assert for(_ <- 1..3, do: assert_receive(_)) == [:name, :inner_age, :inner_name]\n end\n\n Record.defrecord(\n :defaults,\n struct: ~D[2016-01-01],\n map: %{},\n tuple_zero: {},\n tuple_one: {1},\n tuple_two: {1, 2},\n tuple_three: {1, 2, 3},\n list: [1, 2, 3],\n call: MapSet.new(),\n string: \"abc\",\n binary: <<1, 2, 3>>,\n charlist: ~c\"abc\"\n )\n\n test \"records with literal defaults and on-the-fly record\" do\n assert defaults(defaults()) == [\n struct: ~D[2016-01-01],\n map: %{},\n tuple_zero: {},\n tuple_one: {1},\n tuple_two: {1, 2},\n tuple_three: {1, 2, 3},\n list: [1, 2, 3],\n call: MapSet.new(),\n string: \"abc\",\n binary: <<1, 2, 3>>,\n charlist: ~c\"abc\"\n ]\n\n assert defaults(defaults(), :struct) == ~D[2016-01-01]\n assert defaults(defaults(), :map) == %{}\n assert defaults(defaults(), :tuple_zero) == {}\n assert defaults(defaults(), :tuple_one) == {1}\n assert defaults(defaults(), :tuple_two) == {1, 2}\n assert defaults(defaults(), :tuple_three) == {1, 2, 3}\n assert defaults(defaults(), :list) == [1, 2, 3]\n assert defaults(defaults(), :call) == MapSet.new()\n assert defaults(defaults(), :string) == \"abc\"\n assert defaults(defaults(), :binary) == <<1, 2, 3>>\n assert defaults(defaults(), :charlist) == ~c\"abc\"\n end\n\n test \"records with literal defaults and record in a variable\" do\n defaults = defaults()\n\n assert defaults(defaults) == [\n struct: ~D[2016-01-01],\n map: %{},\n tuple_zero: {},\n tuple_one: {1},\n tuple_two: {1, 2},\n tuple_three: {1, 2, 3},\n list: [1, 2, 3],\n call: MapSet.new(),\n string: \"abc\",\n binary: <<1, 2, 3>>,\n charlist: ~c\"abc\"\n ]\n\n assert defaults(defaults, :struct) == ~D[2016-01-01]\n assert defaults(defaults, :map) == %{}\n assert defaults(defaults, :tuple_zero) == {}\n assert defaults(defaults, :tuple_one) == {1}\n assert defaults(defaults, :tuple_two) == {1, 2}\n assert defaults(defaults, :tuple_three) == {1, 2, 3}\n assert defaults(defaults, :list) == [1, 2, 3]\n assert defaults(defaults, :call) == MapSet.new()\n assert defaults(defaults, :string) == \"abc\"\n assert defaults(defaults, :binary) == <<1, 2, 3>>\n assert defaults(defaults, :charlist) == ~c\"abc\"\n end\n\n test \"records with dynamic arguments\" do\n record = file_info()\n assert file_info(record, :size) == :undefined\n\n record = user()\n assert user(record) == [name: \"john\", age: 25]\n assert user(user()) == [name: \"john\", age: 25]\n\n msg =\n \"expected argument to be a literal atom, literal keyword or a :file_info record, \" <>\n \"got runtime: {RecordTest, \\\"john\\\", 25}\"\n\n assert_raise ArgumentError, msg, fn ->\n file_info(record)\n end\n\n pretender = {RecordTest, \"john\"}\n\n msg =\n \"expected argument to be a RecordTest record with 2 fields, \" <>\n \"got: {RecordTest, \\\"john\\\"}\"\n\n assert_raise ArgumentError, msg, fn ->\n user(pretender)\n end\n\n pretender = {RecordTest, \"john\", 25, []}\n\n msg =\n \"expected argument to be a RecordTest record with 2 fields, \" <>\n \"got: {RecordTest, \\\"john\\\", 25, []}\"\n\n assert_raise ArgumentError, msg, fn ->\n user(pretender)\n end\n end\n\n test \"records visibility\" do\n assert macro_exported?(__MODULE__, :user, 0)\n refute macro_exported?(__MODULE__, :file_info, 1)\n end\n\n test \"records reflection\" do\n assert %{fields: [:name, :age], kind: :defrecord, name: :user, tag: RecordTest} in @__records__\n\n assert %{fields: [:date, :time], kind: :defrecord, name: :timestamp, tag: :timestamp} in @__records__\n end\n\n test \"records with no defaults\" do\n record = timestamp()\n assert timestamp(record, :date) == nil\n assert timestamp(record, :time) == nil\n\n record = timestamp(date: :foo, time: :bar)\n assert timestamp(record, :date) == :foo\n assert timestamp(record, :time) == :bar\n end\n\n test \"records defined multiple times\" do\n msg = \"cannot define record :r because a definition r/0 already exists\"\n\n assert_raise ArgumentError, msg, fn ->\n defmodule M do\n import Record\n defrecord :r, [:a]\n defrecord :r, [:a]\n end\n end\n end\n\n test \"macro and record with the same name defined\" do\n msg = \"cannot define record :a because a definition a/1 already exists\"\n\n assert_raise ArgumentError, msg, fn ->\n defmodule M do\n defmacro a(_) do\n end\n\n require Record\n Record.defrecord(:a, [:a])\n end\n end\n\n msg = \"cannot define record :a because a definition a/2 already exists\"\n\n assert_raise ArgumentError, msg, fn ->\n defmodule M do\n defmacro a(_, _) do\n end\n\n require Record\n Record.defrecord(:a, [:a])\n end\n end\n end\n\n test \"docs metadata\" do\n import PathHelpers\n\n write_beam(\n defmodule Metadata do\n Record.defrecord(:user, foo: 0, bar: \"baz\")\n end\n )\n\n {:docs_v1, 352, :elixir, \"text/markdown\", _, %{}, docs} = Code.fetch_docs(RecordTest.Metadata)\n {{:macro, :user, 1}, _meta, _sig, _docs, metadata} = List.keyfind(docs, {:macro, :user, 1}, 0)\n assert %{record: {:user, [foo: 0, bar: \"baz\"]}} = metadata\n end\n\n describe \"warnings\" do\n import ExUnit.CaptureIO\n\n test \"warns on bad record update input\" do\n assert capture_io(:stderr, fn ->\n defmodule RecordSample do\n require Record\n Record.defrecord(:user, __MODULE__, name: \"john\", age: 25)\n\n def fun do\n user(user(), _: :_, name: \"meg\")\n end\n end\n end) =~\n \"updating a record with a default (:_) is equivalent to creating a new record\"\n after\n purge(RecordSample)\n end\n\n test \"defrecord warns with duplicate keys\" do\n assert capture_io(:stderr, fn ->\n Code.eval_string(\"\"\"\n defmodule RecordSample do\n import Record\n defrecord :r, [:foo, :bar, foo: 1]\n end\n \"\"\")\n end) =~ \"duplicate key :foo found in record\"\n after\n purge(RecordSample)\n end\n\n defp purge(module) when is_atom(module) do\n :code.purge(module)\n :code.delete(module)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/regex_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule RegexTest do\n use ExUnit.Case, async: true\n\n doctest Regex\n\n test \"module attribute\" do\n defmodule ModAttr do\n @regex ~r/example/\n def regex, do: @regex\n\n @bare_regex :erlang.term_to_binary(@regex)\n def bare_regex, do: :erlang.binary_to_term(@bare_regex)\n\n # We don't rewrite outside of functions\n assert @regex.re_pattern == :erlang.binary_to_term(@bare_regex).re_pattern\n end\n\n if System.otp_release() >= \"28\" do\n assert ModAttr.regex().re_pattern != ModAttr.bare_regex().re_pattern\n else\n assert ModAttr.regex().re_pattern == ModAttr.bare_regex().re_pattern\n end\n end\n\n @tag :re_import\n test \"module attribute in match context\" do\n assert_raise(\n ArgumentError,\n ~r/escaped Regex structs are not allowed in match or guards/,\n fn ->\n Code.eval_quoted(\n quote do\n defmodule ModAttrGuard do\n @regex ~r/example/\n def example?(@regex), do: true\n def example?(_), do: false\n end\n end\n )\n end\n )\n end\n\n test \"multiline\" do\n refute Regex.match?(~r/^b$/, \"a\\nb\\nc\")\n assert Regex.match?(~r/^b$/m, \"a\\nb\\nc\")\n end\n\n @tag :re_import\n test \"export\" do\n # exported patterns have no structs, so these are structurally equal\n assert ~r/foo/E == Regex.compile!(\"foo\", [:export])\n\n assert Regex.match?(~r/foo/E, \"foo\")\n refute Regex.match?(~r/foo/E, \"Foo\")\n\n assert Regex.run(~r/c(d)/E, \"abcd\") == [\"cd\", \"d\"]\n assert Regex.run(~r/e/E, \"abcd\") == nil\n\n assert Regex.names(~r/(?foo)/E) == [\"FOO\"]\n end\n\n test \"precedence\" do\n assert {\"aa\", :unknown} |> elem(0) =~ ~r/(a)\\1/\n end\n\n test \"backreference\" do\n assert \"aa\" =~ ~r/(a)\\1/\n end\n\n test \"source\" do\n src = \"foo\"\n assert Regex.source(Regex.compile!(src)) == src\n assert Regex.source(~r/#{src}/) == src\n\n src = \"\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v\"\n assert Regex.source(Regex.compile!(src)) == src\n assert Regex.source(~r/#{src}/) == src\n\n src = \"\\a\\\\b\\\\d\\\\e\\f\\n\\r\\\\s\\t\\v\"\n assert Regex.source(Regex.compile!(src)) == src\n assert Regex.source(~r/#{src}/) == src\n end\n\n test \"literal source\" do\n assert Regex.source(Regex.compile!(\"foo\")) == \"foo\"\n assert Regex.source(~r\"foo\") == \"foo\"\n\n assert Regex.source(Regex.compile!(\"\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v\")) == \"\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v\"\n assert Regex.source(~r<\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v>) == \"\\\\a\\\\b\\\\d\\\\e\\\\f\\\\n\\\\r\\\\s\\\\t\\\\v\"\n end\n\n test \"Unicode\" do\n assert \"olá\" =~ ~r\"\\p{Latin}$\"u\n refute \"£\" =~ ~r/\\p{Lu}/u\n\n # Non breaking space matches [[:space:]] with Unicode\n assert <<0xA0::utf8>> =~ ~r/[[:space:]]/u\n assert <<0xA0::utf8>> =~ ~r/\\s/u\n assert <>> =~ ~r/<.>/\n end\n\n test \"ungreedy\" do\n assert Regex.run(~r/[\\d ]+/, \"1 2 3 4 5\"), [\"1 2 3 4 5\"]\n assert Regex.run(~r/[\\d ]?+/, \"1 2 3 4 5\"), [\"1\"]\n assert Regex.run(~r/[\\d ]+/U, \"1 2 3 4 5\"), [\"1\"]\n end\n\n test \"compile/1\" do\n {:ok, %Regex{}} = Regex.compile(\"foo\")\n assert {:error, _} = Regex.compile(\"*foo\")\n assert {:error, _} = Regex.compile(\"foo\", \"y\")\n assert {:error, _} = Regex.compile(\"foo\", \"uy\")\n end\n\n test \"compile/1 with Erlang options\" do\n {:ok, regex} = Regex.compile(\"foo\\\\sbar\", [:dotall, {:newline, :anycrlf}])\n assert \"foo\\nbar\" =~ regex\n end\n\n test \"compile!/1\" do\n assert %Regex{} = Regex.compile!(\"foo\")\n\n # The exact position changed between Erlang/OTP 28.1 and 28.3\n assert_raise Regex.CompileError, ~r/at position/, fn ->\n Regex.compile!(\"*foo\")\n end\n end\n\n test \"import/1\" do\n # no-op for non-exported regexes\n regex = ~r/foo/\n assert Regex.import(regex) == regex\n\n imported = Regex.import(~r/foo/E)\n\n assert imported.opts == []\n assert \"foo\" =~ imported\n assert {:re_pattern, _, _, _, _} = imported.re_pattern\n end\n\n test \"opts/1\" do\n assert Regex.opts(Regex.compile!(\"foo\", \"i\")) == [:caseless]\n assert Regex.opts(Regex.compile!(\"foo\", [:ucp])) == [:ucp]\n end\n\n test \"names/1\" do\n assert Regex.names(~r/(?foo)/) == [\"FOO\"]\n end\n\n test \"match?/2\" do\n assert Regex.match?(~r/foo/, \"foo\")\n refute Regex.match?(~r/foo/, \"FOO\")\n assert Regex.match?(~r/foo/i, \"FOO\")\n assert Regex.match?(~r/\\d{1,3}/i, \"123\")\n\n assert Regex.match?(~r/foo/, \"afooa\")\n refute Regex.match?(~r/^foo/, \"afooa\")\n assert Regex.match?(~r/^foo/, \"fooa\")\n refute Regex.match?(~r/foo$/, \"afooa\")\n assert Regex.match?(~r/foo$/, \"afoo\")\n end\n\n test \"named_captures/2\" do\n assert Regex.named_captures(~r/(?c)(?d)/, \"abcd\") == %{\"bar\" => \"d\", \"foo\" => \"c\"}\n assert Regex.named_captures(~r/c(?d)/, \"abcd\") == %{\"foo\" => \"d\"}\n assert Regex.named_captures(~r/c(?d)/, \"no_match\") == nil\n assert Regex.named_captures(~r/c(?d|e)/, \"abcd abce\") == %{\"foo\" => \"d\"}\n assert Regex.named_captures(~r/c(.)/, \"cat\") == %{}\n end\n\n test \"run/2\" do\n assert Regex.run(~r\"c(d)\", \"abcd\") == [\"cd\", \"d\"]\n assert Regex.run(~r\"e\", \"abcd\") == nil\n end\n\n test \"run/3 with :all_names as the value of the :capture option\" do\n assert Regex.run(~r/c(?d)/, \"abcd\", capture: :all_names) == [\"d\"]\n assert Regex.run(~r/c(?d)/, \"no_match\", capture: :all_names) == nil\n assert Regex.run(~r/c(?d|e)/, \"abcd abce\", capture: :all_names) == [\"d\"]\n end\n\n test \"run/3 with :index as the value of the :return option\" do\n assert Regex.run(~r\"c(d)\", \"abcd\", return: :index) == [{2, 2}, {3, 1}]\n assert Regex.run(~r\"e\", \"abcd\", return: :index) == nil\n end\n\n test \"run/3 with :offset\" do\n assert Regex.run(~r\"^foo\", \"foobar\", offset: 0) == [\"foo\"]\n assert Regex.run(~r\"^foo\", \"foobar\", offset: 2) == nil\n assert Regex.run(~r\"^foo\", \"foobar\", offset: 2, return: :index) == nil\n assert Regex.run(~r\"bar\", \"foobar\", offset: 2, return: :index) == [{3, 3}]\n end\n\n test \"scan/2\" do\n assert Regex.scan(~r\"c(d|e)\", \"abcd abce\") == [[\"cd\", \"d\"], [\"ce\", \"e\"]]\n assert Regex.scan(~r\"c(?:d|e)\", \"abcd abce\") == [[\"cd\"], [\"ce\"]]\n assert Regex.scan(~r\"e\", \"abcd\") == []\n end\n\n test \"scan/2 with :all_names as the value of the :capture option\" do\n assert Regex.scan(~r/cd/, \"abcd\", capture: :all_names) == []\n assert Regex.scan(~r/c(?d)/, \"abcd\", capture: :all_names) == [[\"d\"]]\n assert Regex.scan(~r/c(?d)/, \"no_match\", capture: :all_names) == []\n assert Regex.scan(~r/c(?d|e)/, \"abcd abce\", capture: :all_names) == [[\"d\"], [\"e\"]]\n end\n\n test \"scan/2 with :offset\" do\n assert Regex.scan(~r\"^foo\", \"foobar\", offset: 0) == [[\"foo\"]]\n assert Regex.scan(~r\"^foo\", \"foobar\", offset: 1) == []\n end\n\n test \"split/2,3\" do\n assert Regex.split(~r\",\", \"\") == [\"\"]\n assert Regex.split(~r\",\", \"\", trim: true) == []\n assert Regex.split(~r\",\", \"\", trim: true, parts: 2) == []\n\n assert Regex.split(~r\"=\", \"key=\") == [\"key\", \"\"]\n assert Regex.split(~r\"=\", \"=value\") == [\"\", \"value\"]\n\n assert Regex.split(~r\" \", \"foo bar baz\") == [\"foo\", \"bar\", \"baz\"]\n assert Regex.split(~r\" \", \"foo bar baz\", parts: :infinity) == [\"foo\", \"bar\", \"baz\"]\n assert Regex.split(~r\" \", \"foo bar baz\", parts: 10) == [\"foo\", \"bar\", \"baz\"]\n assert Regex.split(~r\" \", \"foo bar baz\", parts: 2) == [\"foo\", \"bar baz\"]\n\n assert Regex.split(~r\" \", \" foo bar baz \") == [\"\", \"foo\", \"bar\", \"baz\", \"\"]\n assert Regex.split(~r\" \", \" foo bar baz \", trim: true) == [\"foo\", \"bar\", \"baz\"]\n assert Regex.split(~r\" \", \" foo bar baz \", parts: 2) == [\"\", \"foo bar baz \"]\n assert Regex.split(~r\" \", \" foo bar baz \", trim: true, parts: 2) == [\"foo\", \"bar baz \"]\n\n assert Regex.split(~r/b\\K/, \"ababab\") == [\"ab\", \"ab\", \"ab\", \"\"]\n end\n\n test \"split/3 with the :on option\" do\n assert Regex.split(~r/()abc()/, \"xabcxabcx\", on: :none) == [\"xabcxabcx\"]\n\n parts = [\"x\", \"abc\", \"x\", \"abc\", \"x\"]\n assert Regex.split(~r/()abc()/, \"xabcxabcx\", on: :all_but_first) == parts\n\n assert Regex.split(~r/(?)abc(?)/, \"xabcxabcx\", on: [:first, :last]) == parts\n\n parts = [\"xabc\", \"xabc\", \"x\"]\n assert Regex.split(~r/(?)abc(?)/, \"xabcxabcx\", on: [:last, :first]) == parts\n\n assert Regex.split(~r/a(?b)c/, \"abc\", on: [:second]) == [\"a\", \"c\"]\n\n parts = [\"a\", \"c adc a\", \"c\"]\n assert Regex.split(~r/a(?b)c|a(?d)c/, \"abc adc abc\", on: [:second]) == parts\n\n assert Regex.split(~r/a(?b)c|a(?d)c/, \"abc adc abc\", on: [:second, :fourth]) ==\n [\"a\", \"c a\", \"c a\", \"c\"]\n end\n\n test \"split/3 with the :include_captures option\" do\n assert Regex.split(~r/([ln])/, \"Erlang\", include_captures: true) == [\"Er\", \"l\", \"a\", \"n\", \"g\"]\n assert Regex.split(~r/([kw])/, \"Elixir\", include_captures: true) == [\"Elixir\"]\n\n assert Regex.split(~r/([Ee]lixir)/, \"Elixir\", include_captures: true, trim: true) ==\n [\"Elixir\"]\n\n assert Regex.split(~r/([Ee]lixir)/, \"Elixir\", include_captures: true, trim: false) ==\n [\"\", \"Elixir\", \"\"]\n\n assert Regex.split(~r//, \"abc\", include_captures: true) ==\n [\"\", \"\", \"a\", \"\", \"b\", \"\", \"c\", \"\", \"\"]\n\n assert Regex.split(~r/a/, \"abc\", include_captures: true) == [\"\", \"a\", \"bc\"]\n assert Regex.split(~r/c/, \"abc\", include_captures: true) == [\"ab\", \"c\", \"\"]\n\n assert Regex.split(~r/[Ei]/, \"Elixir\", include_captures: true, parts: 2) ==\n [\"\", \"E\", \"lixir\"]\n\n assert Regex.split(~r/[Ei]/, \"Elixir\", include_captures: true, parts: 3) ==\n [\"\", \"E\", \"l\", \"i\", \"xir\"]\n\n assert Regex.split(~r/[Ei]/, \"Elixir\", include_captures: true, parts: 2, trim: true) ==\n [\"E\", \"lixir\"]\n\n assert Regex.split(~r/[Ei]/, \"Elixir\", include_captures: true, parts: 3, trim: true) ==\n [\"E\", \"l\", \"i\", \"xir\"]\n\n assert Regex.split(~r/b\\Kc/, \"abcabc\", include_captures: true) == [\"ab\", \"c\", \"ab\", \"c\", \"\"]\n assert Regex.split(~r/(b\\K)/, \"abab\", include_captures: true) == [\"ab\", \"\", \"ab\", \"\", \"\"]\n\n assert Regex.split(~r/(b\\K)/, \"abab\", include_captures: true, trim: true) == [\n \"ab\",\n \"\",\n \"ab\",\n \"\"\n ]\n end\n\n test \"replace/3,4\" do\n assert Regex.replace(~r/d/, \"abc\", \"d\") == \"abc\"\n assert Regex.replace(~r/b/, \"abc\", \"d\") == \"adc\"\n assert Regex.replace(~r/b/, \"abc\", \"[\\\\0]\") == \"a[b]c\"\n assert Regex.replace(~r[(b)], \"abc\", \"[\\\\1]\") == \"a[b]c\"\n assert Regex.replace(~r[(b)], \"abc\", \"[\\\\2]\") == \"a[]c\"\n assert Regex.replace(~r[(b)], \"abc\", \"[\\\\3]\") == \"a[]c\"\n assert Regex.replace(~r/b/, \"abc\", \"[\\\\g{0}]\") == \"a[b]c\"\n assert Regex.replace(~r[(b)], \"abc\", \"[\\\\g{1}]\") == \"a[b]c\"\n\n assert Regex.replace(~r/b/, \"abcbe\", \"d\") == \"adcde\"\n assert Regex.replace(~r/b/, \"abcbe\", \"d\", global: false) == \"adcbe\"\n\n assert Regex.replace(~r/ /, \"first third\", \"\\\\second\\\\\") == \"first\\\\second\\\\third\"\n assert Regex.replace(~r/ /, \"first third\", \"\\\\\\\\second\\\\\\\\\") == \"first\\\\second\\\\third\"\n\n assert Regex.replace(~r[a(b)c], \"abcabc\", fn -> \"ac\" end) == \"acac\"\n assert Regex.replace(~r[a(b)c], \"abcabc\", fn \"abc\" -> \"ac\" end) == \"acac\"\n assert Regex.replace(~r[a(b)c], \"abcabc\", fn \"abc\", \"b\" -> \"ac\" end) == \"acac\"\n assert Regex.replace(~r[a(b)c], \"abcabc\", fn \"abc\", \"b\", \"\" -> \"ac\" end) == \"acac\"\n assert Regex.replace(~r[a(b)c], \"abcabc\", fn \"abc\", \"b\" -> \"ac\" end, global: false) == \"acabc\"\n end\n\n test \"escape\" do\n assert matches_escaped?(\".\")\n refute matches_escaped?(\".\", \"x\")\n\n assert matches_escaped?(\"[\\w]\")\n refute matches_escaped?(\"[\\w]\", \"x\")\n\n assert matches_escaped?(\"\\\\\")\n\n assert matches_escaped?(\"\\\\xff\", \"\\\\xff\")\n refute matches_escaped?(\"\\\\xff\", \"\\xff\")\n\n assert matches_escaped?(\"(\")\n assert matches_escaped?(\"()\")\n assert matches_escaped?(\"(?:foo)\")\n\n assert matches_escaped?(\"\\\\A \\\\z\")\n assert matches_escaped?(\" x \")\n # Unicode spaces here\n assert matches_escaped?(\"  x    x \")\n assert matches_escaped?(\"# lol\")\n\n assert matches_escaped?(\"\\\\A.^$*+?()[{\\\\| \\t\\n\\x20\\\\z #hello\\u202F\\u205F\")\n assert Regex.match?(Regex.compile!(\"[\" <> Regex.escape(\"!-#\") <> \"]\"), \"-\")\n\n assert Regex.escape(\"{}\") == \"\\\\{\\\\}\"\n assert Regex.escape(\"[]\") == \"\\\\[\\\\]\"\n\n assert Regex.escape(\"{foo}\") == \"\\\\{foo\\\\}\"\n assert Regex.escape(\"[foo]\") == \"\\\\[foo\\\\]\"\n end\n\n defp matches_escaped?(string) do\n matches_escaped?(string, string)\n end\n\n defp matches_escaped?(string, match) do\n Regex.match?(~r/#{Regex.escape(string)}/simx, match)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/registry/duplicate_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Registry.DuplicateTest do\n use ExUnit.Case,\n async: true,\n parameterize:\n for(\n keys <- [:duplicate, {:duplicate, :pid}, {:duplicate, :key}],\n partitions <- [1, 8],\n do: %{keys: keys, partitions: partitions}\n )\n\n setup config do\n keys = config.keys\n partitions = config.partitions\n\n listeners =\n List.wrap(config[:base_listener]) |> Enum.map(&:\"#{&1}_#{partitions}_#{inspect(keys)}\")\n\n name = :\"#{config.test}_#{partitions}_#{inspect(keys)}\"\n opts = [keys: config.keys, name: name, partitions: partitions, listeners: listeners]\n {:ok, _} = start_supervised({Registry, opts})\n %{registry: name, listeners: listeners}\n end\n\n test \"starts configured number of partitions\", %{registry: registry, partitions: partitions} do\n assert length(Supervisor.which_children(registry)) == partitions\n end\n\n test \"counts 0 keys in an empty registry\", %{registry: registry} do\n assert 0 == Registry.count(registry)\n end\n\n test \"counts the number of keys in a registry\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n\n assert 2 == Registry.count(registry)\n end\n\n test \"has duplicate registrations\", %{registry: registry} do\n {:ok, pid} = Registry.register(registry, \"hello\", :value)\n assert is_pid(pid)\n assert Registry.keys(registry, self()) == [\"hello\"]\n assert Registry.values(registry, \"hello\", self()) == [:value]\n\n assert {:ok, pid} = Registry.register(registry, \"hello\", :value)\n assert is_pid(pid)\n assert Registry.keys(registry, self()) == [\"hello\", \"hello\"]\n assert Registry.values(registry, \"hello\", self()) == [:value, :value]\n\n {:ok, pid} = Registry.register(registry, \"world\", :value)\n assert is_pid(pid)\n assert Registry.keys(registry, self()) |> Enum.sort() == [\"hello\", \"hello\", \"world\"]\n end\n\n test \"has duplicate registrations across processes\", %{registry: registry} do\n {_, task} = register_task(registry, \"hello\", :world)\n assert Registry.keys(registry, self()) == []\n assert Registry.keys(registry, task) == [\"hello\"]\n assert Registry.values(registry, \"hello\", self()) == []\n assert Registry.values(registry, \"hello\", task) == [:world]\n\n assert {:ok, _pid} = Registry.register(registry, \"hello\", :value)\n assert Registry.keys(registry, self()) == [\"hello\"]\n assert Registry.values(registry, \"hello\", self()) == [:value]\n end\n\n test \"compares using matches\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, 1.0, :value)\n {:ok, _} = Registry.register(registry, 1, :value)\n assert Registry.keys(registry, self()) |> Enum.sort() == [1, 1.0]\n end\n\n test \"dispatches to multiple keys in serial\", %{registry: registry} do\n Process.flag(:trap_exit, true)\n parent = self()\n\n fun = fn _ -> raise \"will never be invoked\" end\n assert Registry.dispatch(registry, \"hello\", fun, parallel: false) == :ok\n\n {:ok, _} = Registry.register(registry, \"hello\", :value1)\n {:ok, _} = Registry.register(registry, \"hello\", :value2)\n {:ok, _} = Registry.register(registry, \"world\", :value3)\n\n fun = fn entries ->\n assert parent == self()\n for {pid, value} <- entries, do: send(pid, {:dispatch, value})\n end\n\n assert Registry.dispatch(registry, \"hello\", fun, parallel: false)\n\n assert_received {:dispatch, :value1}\n assert_received {:dispatch, :value2}\n refute_received {:dispatch, :value3}\n\n fun = fn entries ->\n assert parent == self()\n for {pid, value} <- entries, do: send(pid, {:dispatch, value})\n end\n\n assert Registry.dispatch(registry, \"world\", fun, parallel: false)\n\n refute_received {:dispatch, :value1}\n refute_received {:dispatch, :value2}\n assert_received {:dispatch, :value3}\n\n refute_received {:EXIT, _, _}\n end\n\n test \"dispatches to multiple keys in parallel\", context do\n %{registry: registry, partitions: partitions} = context\n Process.flag(:trap_exit, true)\n parent = self()\n\n fun = fn _ -> raise \"will never be invoked\" end\n assert Registry.dispatch(registry, \"hello\", fun, parallel: true) == :ok\n\n {:ok, _} = Registry.register(registry, \"hello\", :value1)\n {:ok, _} = Registry.register(registry, \"hello\", :value2)\n {:ok, _} = Registry.register(registry, \"world\", :value3)\n\n fun = fn entries ->\n if partitions == 8 do\n assert parent != self()\n else\n assert parent == self()\n end\n\n for {pid, value} <- entries, do: send(pid, {:dispatch, value})\n end\n\n assert Registry.dispatch(registry, \"hello\", fun, parallel: true)\n\n assert_received {:dispatch, :value1}\n assert_received {:dispatch, :value2}\n refute_received {:dispatch, :value3}\n\n fun = fn entries ->\n if partitions == 8 do\n assert parent != self()\n else\n assert parent == self()\n end\n\n for {pid, value} <- entries, do: send(pid, {:dispatch, value})\n end\n\n assert Registry.dispatch(registry, \"world\", fun, parallel: true)\n\n refute_received {:dispatch, :value1}\n refute_received {:dispatch, :value2}\n assert_received {:dispatch, :value3}\n\n refute_received {:EXIT, _, _}\n end\n\n test \"unregisters by key\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n assert Registry.keys(registry, self()) |> Enum.sort() == [\"hello\", \"hello\", \"world\"]\n\n :ok = Registry.unregister(registry, \"hello\")\n assert Registry.keys(registry, self()) == [\"world\"]\n\n :ok = Registry.unregister(registry, \"world\")\n assert Registry.keys(registry, self()) == []\n end\n\n test \"unregisters with no entries\", %{registry: registry} do\n assert Registry.unregister(registry, \"hello\") == :ok\n end\n\n test \"unregisters with tricky keys\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, :_, :foo)\n {:ok, _} = Registry.register(registry, :_, :bar)\n {:ok, _} = Registry.register(registry, \"hello\", \"a\")\n {:ok, _} = Registry.register(registry, \"hello\", \"b\")\n\n Registry.unregister(registry, :_)\n assert Registry.keys(registry, self()) |> Enum.sort() == [\"hello\", \"hello\"]\n end\n\n test \"supports match patterns\", %{registry: registry} do\n value1 = {1, :atom, 1}\n value2 = {2, :atom, 2}\n\n {:ok, _} = Registry.register(registry, \"hello\", value1)\n {:ok, _} = Registry.register(registry, \"hello\", value2)\n\n assert Registry.match(registry, \"hello\", {1, :_, :_}) == [{self(), value1}]\n assert Registry.match(registry, \"hello\", {1.0, :_, :_}) == []\n\n assert Registry.match(registry, \"hello\", {:_, :atom, :_}) |> Enum.sort() ==\n [{self(), value1}, {self(), value2}]\n\n assert Registry.match(registry, \"hello\", {:\"$1\", :_, :\"$1\"}) |> Enum.sort() ==\n [{self(), value1}, {self(), value2}]\n\n assert Registry.match(registry, \"hello\", {2, :_, :_}) == [{self(), value2}]\n assert Registry.match(registry, \"hello\", {2.0, :_, :_}) == []\n end\n\n test \"supports guards\", %{registry: registry} do\n value1 = {1, :atom, 1}\n value2 = {2, :atom, 2}\n\n {:ok, _} = Registry.register(registry, \"hello\", value1)\n {:ok, _} = Registry.register(registry, \"hello\", value2)\n\n assert Registry.match(registry, \"hello\", {:\"$1\", :_, :_}, [{:<, :\"$1\", 2}]) ==\n [{self(), value1}]\n\n assert Registry.match(registry, \"hello\", {:\"$1\", :_, :_}, [{:>, :\"$1\", 3}]) == []\n\n assert Registry.match(registry, \"hello\", {:\"$1\", :_, :_}, [{:<, :\"$1\", 3}]) |> Enum.sort() ==\n [{self(), value1}, {self(), value2}]\n\n assert Registry.match(registry, \"hello\", {:_, :\"$1\", :_}, [{:is_atom, :\"$1\"}])\n |> Enum.sort() == [{self(), value1}, {self(), value2}]\n end\n\n test \"count_match supports match patterns\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n assert 1 == Registry.count_match(registry, \"hello\", {1, :_, :_})\n assert 0 == Registry.count_match(registry, \"hello\", {1.0, :_, :_})\n assert 1 == Registry.count_match(registry, \"hello\", {:_, :atom, :_})\n assert 1 == Registry.count_match(registry, \"hello\", {:\"$1\", :_, :\"$1\"})\n assert 1 == Registry.count_match(registry, \"hello\", :_)\n assert 0 == Registry.count_match(registry, :_, :_)\n\n value2 = %{a: \"a\", b: \"b\"}\n {:ok, _} = Registry.register(registry, \"world\", value2)\n assert 1 == Registry.count_match(registry, \"world\", %{b: \"b\"})\n end\n\n test \"count_match supports guard conditions\", %{registry: registry} do\n value = {1, :atom, 2}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert 1 == Registry.count_match(registry, \"hello\", {:_, :_, :\"$1\"}, [{:>, :\"$1\", 1}])\n assert 0 == Registry.count_match(registry, \"hello\", {:_, :_, :\"$1\"}, [{:>, :\"$1\", 2}])\n assert 1 == Registry.count_match(registry, \"hello\", {:_, :\"$1\", :_}, [{:is_atom, :\"$1\"}])\n end\n\n test \"unregister_match supports patterns\", %{registry: registry} do\n value1 = {1, :atom, 1}\n value2 = {2, :atom, 2}\n\n {:ok, _} = Registry.register(registry, \"hello\", value1)\n {:ok, _} = Registry.register(registry, \"hello\", value2)\n\n Registry.unregister_match(registry, \"hello\", {2, :_, :_})\n assert Registry.lookup(registry, \"hello\") == [{self(), value1}]\n\n {:ok, _} = Registry.register(registry, \"hello\", value2)\n Registry.unregister_match(registry, \"hello\", {2.0, :_, :_})\n assert Registry.lookup(registry, \"hello\") == [{self(), value1}, {self(), value2}]\n Registry.unregister_match(registry, \"hello\", {:_, :atom, :_})\n assert Registry.lookup(registry, \"hello\") == []\n end\n\n test \"unregister_match supports guards\", %{registry: registry} do\n value1 = {1, :atom, 1}\n value2 = {2, :atom, 2}\n\n {:ok, _} = Registry.register(registry, \"hello\", value1)\n {:ok, _} = Registry.register(registry, \"hello\", value2)\n\n Registry.unregister_match(registry, \"hello\", {:\"$1\", :_, :_}, [{:<, :\"$1\", 2}])\n assert Registry.lookup(registry, \"hello\") == [{self(), value2}]\n end\n\n test \"unregister_match supports tricky keys\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, :_, :foo)\n {:ok, _} = Registry.register(registry, :_, :bar)\n {:ok, _} = Registry.register(registry, \"hello\", \"a\")\n {:ok, _} = Registry.register(registry, \"hello\", \"b\")\n\n Registry.unregister_match(registry, :_, :foo)\n assert Registry.lookup(registry, :_) == [{self(), :bar}]\n\n assert Registry.keys(registry, self()) |> Enum.sort() == [:_, \"hello\", \"hello\"]\n end\n\n @tag base_listener: :unique_listener\n test \"allows listeners\", %{registry: registry, listeners: [listener]} do\n Process.register(self(), listener)\n {_, task} = register_task(registry, \"hello\", :world)\n assert_received {:register, ^registry, \"hello\", ^task, :world}\n\n self = self()\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n assert_received {:register, ^registry, \"hello\", ^self, :value}\n\n :ok = Registry.unregister(registry, \"hello\")\n assert_received {:unregister, ^registry, \"hello\", ^self}\n after\n Process.unregister(listener)\n end\n\n test \"links and unlinks on register/unregister\", %{registry: registry} do\n {:ok, pid} = Registry.register(registry, \"hello\", :value)\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n {:ok, pid} = Registry.register(registry, \"world\", :value)\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n :ok = Registry.unregister(registry, \"hello\")\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n :ok = Registry.unregister(registry, \"world\")\n {:links, links} = Process.info(self(), :links)\n refute pid in links\n end\n\n test \"raises on unknown registry name\" do\n assert_raise ArgumentError, ~r/unknown registry/, fn ->\n Registry.register(:unknown, \"hello\", :value)\n end\n end\n\n test \"raises if attempt to be used on via\", %{registry: registry} do\n assert_raise ArgumentError, \":via is not supported for duplicate registries\", fn ->\n name = {:via, Registry, {registry, \"hello\"}}\n Agent.start_link(fn -> 0 end, name: name)\n end\n end\n\n test \"empty list for empty registry\", %{registry: registry} do\n assert Registry.select(registry, [{{:_, :_, :_}, [], [:\"$_\"]}]) == []\n end\n\n test \"select all\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n\n assert Registry.select(registry, [{{:\"$1\", :\"$2\", :\"$3\"}, [], [{{:\"$1\", :\"$2\", :\"$3\"}}]}])\n |> Enum.sort() ==\n [{\"hello\", self(), :value}, {\"hello\", self(), :value}]\n end\n\n test \"select supports full match specs\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{\"hello\", :\"$2\", :\"$3\"}, [], [{{\"hello\", :\"$2\", :\"$3\"}}]}\n ])\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{:\"$1\", self(), :\"$3\"}, [], [{{:\"$1\", self(), :\"$3\"}}]}\n ])\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", value}, [], [{{:\"$1\", :\"$2\", {value}}}]}\n ])\n\n assert [] ==\n Registry.select(registry, [\n {{\"world\", :\"$2\", :\"$3\"}, [], [{{\"world\", :\"$2\", :\"$3\"}}]}\n ])\n\n assert [] == Registry.select(registry, [{{:\"$1\", :\"$2\", {1.0, :_, :_}}, [], [:\"$_\"]}])\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", {:\"$3\", :atom, :\"$4\"}}, [],\n [{{:\"$1\", :\"$2\", {{:\"$3\", :atom, :\"$4\"}}}}]}\n ])\n\n assert [{\"hello\", self(), {1, :atom, 1}}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", {:\"$3\", :\"$4\", :\"$3\"}}, [],\n [{{:\"$1\", :\"$2\", {{:\"$3\", :\"$4\", :\"$3\"}}}}]}\n ])\n\n value2 = %{a: \"a\", b: \"b\"}\n {:ok, _} = Registry.register(registry, \"world\", value2)\n\n assert [:match] ==\n Registry.select(registry, [{{\"world\", self(), %{b: \"b\"}}, [], [:match]}])\n\n assert [\"hello\", \"world\"] ==\n Registry.select(registry, [{{:\"$1\", :_, :_}, [], [:\"$1\"]}]) |> Enum.sort()\n end\n\n test \"select supports guard conditions\", %{registry: registry} do\n value = {1, :atom, 2}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert [{\"hello\", self(), {1, :atom, 2}}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", {:\"$3\", :\"$4\", :\"$5\"}}, [{:>, :\"$5\", 1}],\n [{{:\"$1\", :\"$2\", {{:\"$3\", :\"$4\", :\"$5\"}}}}]}\n ])\n\n assert [] ==\n Registry.select(registry, [\n {{:_, :_, {:_, :_, :\"$1\"}}, [{:>, :\"$1\", 2}], [:\"$_\"]}\n ])\n\n assert [\"hello\"] ==\n Registry.select(registry, [\n {{:\"$1\", :_, {:_, :\"$2\", :_}}, [{:is_atom, :\"$2\"}], [:\"$1\"]}\n ])\n end\n\n test \"select allows multiple specs\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n\n assert [\"hello\", \"world\"] ==\n Registry.select(registry, [\n {{\"hello\", :_, :_}, [], [{:element, 1, :\"$_\"}]},\n {{\"world\", :_, :_}, [], [{:element, 1, :\"$_\"}]}\n ])\n |> Enum.sort()\n end\n\n test \"count_select supports match specs\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n assert 1 == Registry.count_select(registry, [{{:_, :_, value}, [], [true]}])\n assert 1 == Registry.count_select(registry, [{{\"hello\", :_, :_}, [], [true]}])\n assert 1 == Registry.count_select(registry, [{{:_, :_, {1, :atom, :_}}, [], [true]}])\n assert 1 == Registry.count_select(registry, [{{:_, :_, {:\"$1\", :_, :\"$1\"}}, [], [true]}])\n assert 0 == Registry.count_select(registry, [{{\"hello\", :_, nil}, [], [true]}])\n\n value2 = %{a: \"a\", b: \"b\"}\n {:ok, _} = Registry.register(registry, \"world\", value2)\n assert 1 == Registry.count_select(registry, [{{\"world\", :_, :_}, [], [true]}])\n end\n\n test \"count_select supports guard conditions\", %{registry: registry} do\n value = {1, :atom, 2}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert 1 ==\n Registry.count_select(registry, [\n {{:_, :_, {:_, :\"$1\", :_}}, [{:is_atom, :\"$1\"}], [true]}\n ])\n\n assert 1 ==\n Registry.count_select(registry, [\n {{:_, :_, {:_, :_, :\"$1\"}}, [{:>, :\"$1\", 1}], [true]}\n ])\n\n assert 0 ==\n Registry.count_select(registry, [\n {{:_, :_, {:_, :_, :\"$1\"}}, [{:>, :\"$1\", 2}], [true]}\n ])\n end\n\n test \"count_select allows multiple specs\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n\n assert 2 ==\n Registry.count_select(registry, [\n {{\"hello\", :_, :_}, [], [true]},\n {{\"world\", :_, :_}, [], [true]}\n ])\n end\n\n test \"rejects invalid tuple syntax\", %{partitions: partitions} do\n name = :\"test_invalid_tuple_#{partitions}\"\n\n assert_raise ArgumentError, ~r/expected :keys to be given and be one of/, fn ->\n Registry.start_link(keys: {:duplicate, :invalid}, name: name, partitions: partitions)\n end\n end\n\n test \"update_value is not supported\", %{registry: registry} do\n assert_raise ArgumentError, ~r/Registry.update_value\\/3 is not supported/, fn ->\n Registry.update_value(registry, \"hello\", fn val -> val end)\n end\n end\n\n defp register_task(registry, key, value) do\n parent = self()\n\n {:ok, task} =\n Task.start(fn ->\n send(parent, Registry.register(registry, key, value))\n Process.sleep(:infinity)\n end)\n\n assert_receive {:ok, owner}\n {owner, task}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/registry/unique_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Registry.UniqueTest do\n use ExUnit.Case,\n async: true,\n parameterize: [\n %{partitions: 1},\n %{partitions: 8}\n ]\n\n @keys :unique\n\n setup config do\n partitions = config.partitions\n listeners = List.wrap(config[:base_listener]) |> Enum.map(&:\"#{&1}_#{partitions}\")\n name = :\"#{config.test}_#{partitions}\"\n opts = [keys: @keys, name: name, partitions: partitions, listeners: listeners]\n {:ok, _} = start_supervised({Registry, opts})\n %{registry: name, listeners: listeners}\n end\n\n test \"starts configured number of partitions\", %{registry: registry, partitions: partitions} do\n assert length(Supervisor.which_children(registry)) == partitions\n end\n\n test \"counts 0 keys in an empty registry\", %{registry: registry} do\n assert 0 == Registry.count(registry)\n end\n\n test \"counts the number of keys in a registry\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n\n assert 2 == Registry.count(registry)\n end\n\n test \"has unique registrations\", %{registry: registry} do\n {:ok, pid} = Registry.register(registry, \"hello\", :value)\n assert is_pid(pid)\n assert Registry.keys(registry, self()) == [\"hello\"]\n assert Registry.values(registry, \"hello\", self()) == [:value]\n\n assert {:error, {:already_registered, pid}} = Registry.register(registry, \"hello\", :value)\n assert pid == self()\n assert Registry.keys(registry, self()) == [\"hello\"]\n assert Registry.values(registry, \"hello\", self()) == [:value]\n\n {:ok, pid} = Registry.register(registry, \"world\", :value)\n assert is_pid(pid)\n assert Registry.keys(registry, self()) |> Enum.sort() == [\"hello\", \"world\"]\n end\n\n test \"has unique registrations across processes\", %{registry: registry} do\n {_, task} = register_task(registry, \"hello\", :value)\n Process.link(Process.whereis(registry))\n assert Registry.keys(registry, task) == [\"hello\"]\n assert Registry.values(registry, \"hello\", task) == [:value]\n\n assert {:error, {:already_registered, ^task}} =\n Registry.register(registry, \"hello\", :recent)\n\n assert Registry.keys(registry, self()) == []\n assert Registry.values(registry, \"hello\", self()) == []\n\n {:links, links} = Process.info(self(), :links)\n assert Process.whereis(registry) in links\n end\n\n test \"has unique registrations even if partition is delayed\", %{registry: registry} do\n {owner, task} = register_task(registry, \"hello\", :value)\n\n assert Registry.register(registry, \"hello\", :other) ==\n {:error, {:already_registered, task}}\n\n :sys.suspend(owner)\n kill_and_assert_down(task)\n Registry.register(registry, \"hello\", :other)\n assert Registry.lookup(registry, \"hello\") == [{self(), :other}]\n end\n\n test \"supports match patterns\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n assert Registry.match(registry, \"hello\", {1, :_, :_}) == [{self(), value}]\n assert Registry.match(registry, \"hello\", {1.0, :_, :_}) == []\n assert Registry.match(registry, \"hello\", {:_, :atom, :_}) == [{self(), value}]\n assert Registry.match(registry, \"hello\", {:\"$1\", :_, :\"$1\"}) == [{self(), value}]\n assert Registry.match(registry, \"hello\", :_) == [{self(), value}]\n assert Registry.match(registry, :_, :_) == []\n\n value2 = %{a: \"a\", b: \"b\"}\n {:ok, _} = Registry.register(registry, \"world\", value2)\n assert Registry.match(registry, \"world\", %{b: \"b\"}) == [{self(), value2}]\n end\n\n test \"supports guard conditions\", %{registry: registry} do\n value = {1, :atom, 2}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert Registry.match(registry, \"hello\", {:_, :_, :\"$1\"}, [{:>, :\"$1\", 1}]) ==\n [{self(), value}]\n\n assert Registry.match(registry, \"hello\", {:_, :_, :\"$1\"}, [{:>, :\"$1\", 2}]) == []\n\n assert Registry.match(registry, \"hello\", {:_, :\"$1\", :_}, [{:is_atom, :\"$1\"}]) ==\n [{self(), value}]\n end\n\n test \"count_match supports match patterns\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n assert 1 == Registry.count_match(registry, \"hello\", {1, :_, :_})\n assert 0 == Registry.count_match(registry, \"hello\", {1.0, :_, :_})\n assert 1 == Registry.count_match(registry, \"hello\", {:_, :atom, :_})\n assert 1 == Registry.count_match(registry, \"hello\", {:\"$1\", :_, :\"$1\"})\n assert 1 == Registry.count_match(registry, \"hello\", :_)\n assert 0 == Registry.count_match(registry, :_, :_)\n\n value2 = %{a: \"a\", b: \"b\"}\n {:ok, _} = Registry.register(registry, \"world\", value2)\n assert 1 == Registry.count_match(registry, \"world\", %{b: \"b\"})\n end\n\n test \"count_match supports guard conditions\", %{registry: registry} do\n value = {1, :atom, 2}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert 1 == Registry.count_match(registry, \"hello\", {:_, :_, :\"$1\"}, [{:>, :\"$1\", 1}])\n assert 0 == Registry.count_match(registry, \"hello\", {:_, :_, :\"$1\"}, [{:>, :\"$1\", 2}])\n assert 1 == Registry.count_match(registry, \"hello\", {:_, :\"$1\", :_}, [{:is_atom, :\"$1\"}])\n end\n\n test \"unregister_match supports patterns\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n Registry.unregister_match(registry, \"hello\", {2, :_, :_})\n assert Registry.lookup(registry, \"hello\") == [{self(), value}]\n Registry.unregister_match(registry, \"hello\", {1.0, :_, :_})\n assert Registry.lookup(registry, \"hello\") == [{self(), value}]\n Registry.unregister_match(registry, \"hello\", {:_, :atom, :_})\n assert Registry.lookup(registry, \"hello\") == []\n end\n\n test \"unregister_match supports guards\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n Registry.unregister_match(registry, \"hello\", {:\"$1\", :_, :_}, [{:<, :\"$1\", 2}])\n assert Registry.lookup(registry, \"hello\") == []\n end\n\n test \"unregister_match supports tricky keys\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, :_, :foo)\n {:ok, _} = Registry.register(registry, \"hello\", \"b\")\n\n Registry.unregister_match(registry, :_, :foo)\n assert Registry.lookup(registry, :_) == []\n assert Registry.keys(registry, self()) |> Enum.sort() == [\"hello\"]\n end\n\n test \"compares using ===\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, 1.0, :value)\n {:ok, _} = Registry.register(registry, 1, :value)\n assert Registry.keys(registry, self()) |> Enum.sort() == [1, 1.0]\n end\n\n test \"updates current process value\", %{registry: registry} do\n assert Registry.update_value(registry, \"hello\", &raise/1) == :error\n register_task(registry, \"hello\", :value)\n assert Registry.update_value(registry, \"hello\", &raise/1) == :error\n\n Registry.register(registry, \"world\", 1)\n assert Registry.lookup(registry, \"world\") == [{self(), 1}]\n assert Registry.update_value(registry, \"world\", &(&1 + 1)) == {2, 1}\n assert Registry.lookup(registry, \"world\") == [{self(), 2}]\n end\n\n test \"dispatches to a single key\", %{registry: registry} do\n fun = fn _ -> raise \"will never be invoked\" end\n assert Registry.dispatch(registry, \"hello\", fun) == :ok\n\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n\n fun = fn [{pid, value}] -> send(pid, {:dispatch, value}) end\n assert Registry.dispatch(registry, \"hello\", fun)\n\n assert_received {:dispatch, :value}\n end\n\n test \"unregisters process by key\", %{registry: registry} do\n :ok = Registry.unregister(registry, \"hello\")\n\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n assert Registry.keys(registry, self()) |> Enum.sort() == [\"hello\", \"world\"]\n\n :ok = Registry.unregister(registry, \"hello\")\n assert Registry.keys(registry, self()) == [\"world\"]\n\n :ok = Registry.unregister(registry, \"world\")\n assert Registry.keys(registry, self()) == []\n end\n\n test \"unregisters with no entries\", %{registry: registry} do\n assert Registry.unregister(registry, \"hello\") == :ok\n end\n\n test \"unregisters with tricky keys\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, :_, :foo)\n {:ok, _} = Registry.register(registry, \"hello\", \"b\")\n\n Registry.unregister(registry, :_)\n assert Registry.lookup(registry, :_) == []\n assert Registry.keys(registry, self()) |> Enum.sort() == [\"hello\"]\n end\n\n @tag base_listener: :unique_listener\n test \"allows listeners\", %{registry: registry, listeners: [listener]} do\n Process.register(self(), listener)\n {_, task} = register_task(registry, \"hello\", :world)\n assert_received {:register, ^registry, \"hello\", ^task, :world}\n\n self = self()\n {:ok, _} = Registry.register(registry, \"world\", :value)\n assert_received {:register, ^registry, \"world\", ^self, :value}\n\n :ok = Registry.unregister(registry, \"world\")\n assert_received {:unregister, ^registry, \"world\", ^self}\n after\n Process.unregister(listener)\n end\n\n test \"links and unlinks on register/unregister\", %{registry: registry} do\n {:ok, pid} = Registry.register(registry, \"hello\", :value)\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n {:ok, pid} = Registry.register(registry, \"world\", :value)\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n :ok = Registry.unregister(registry, \"hello\")\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n :ok = Registry.unregister(registry, \"world\")\n {:links, links} = Process.info(self(), :links)\n refute pid in links\n end\n\n test \"raises on unknown registry name\" do\n assert_raise ArgumentError, ~r/unknown registry/, fn ->\n Registry.register(:unknown, \"hello\", :value)\n end\n end\n\n test \"via callbacks\", %{registry: registry} do\n name = {:via, Registry, {registry, \"hello\"}}\n\n # register_name\n {:ok, pid} = Agent.start_link(fn -> 0 end, name: name)\n\n # send\n assert Agent.update(name, &(&1 + 1)) == :ok\n\n # whereis_name\n assert Agent.get(name, & &1) == 1\n\n # unregister_name\n assert {:error, _} = Agent.start(fn -> raise \"oops\" end)\n\n # errors\n assert {:error, {:already_started, ^pid}} = Agent.start(fn -> 0 end, name: name)\n end\n\n test \"uses value provided in via\", %{registry: registry} do\n name = {:via, Registry, {registry, \"hello\", :value}}\n {:ok, pid} = Agent.start_link(fn -> 0 end, name: name)\n assert Registry.lookup(registry, \"hello\") == [{pid, :value}]\n end\n\n test \"empty list for empty registry\", %{registry: registry} do\n assert Registry.select(registry, [{{:_, :_, :_}, [], [:\"$_\"]}]) == []\n end\n\n test \"select all\", %{registry: registry} do\n name = {:via, Registry, {registry, \"hello\"}}\n {:ok, pid} = Agent.start_link(fn -> 0 end, name: name)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n\n assert Registry.select(registry, [{{:\"$1\", :\"$2\", :\"$3\"}, [], [{{:\"$1\", :\"$2\", :\"$3\"}}]}])\n |> Enum.sort() ==\n [{\"hello\", pid, nil}, {\"world\", self(), :value}]\n end\n\n test \"select supports full match specs\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{\"hello\", :\"$2\", :\"$3\"}, [], [{{\"hello\", :\"$2\", :\"$3\"}}]}\n ])\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{:\"$1\", self(), :\"$3\"}, [], [{{:\"$1\", self(), :\"$3\"}}]}\n ])\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", value}, [], [{{:\"$1\", :\"$2\", {value}}}]}\n ])\n\n assert [] ==\n Registry.select(registry, [\n {{\"world\", :\"$2\", :\"$3\"}, [], [{{\"world\", :\"$2\", :\"$3\"}}]}\n ])\n\n assert [] == Registry.select(registry, [{{:\"$1\", :\"$2\", {1.0, :_, :_}}, [], [:\"$_\"]}])\n\n assert [{\"hello\", self(), value}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", {:\"$3\", :atom, :\"$4\"}}, [],\n [{{:\"$1\", :\"$2\", {{:\"$3\", :atom, :\"$4\"}}}}]}\n ])\n\n assert [{\"hello\", self(), {1, :atom, 1}}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", {:\"$3\", :\"$4\", :\"$3\"}}, [],\n [{{:\"$1\", :\"$2\", {{:\"$3\", :\"$4\", :\"$3\"}}}}]}\n ])\n\n value2 = %{a: \"a\", b: \"b\"}\n {:ok, _} = Registry.register(registry, \"world\", value2)\n\n assert [:match] ==\n Registry.select(registry, [{{\"world\", self(), %{b: \"b\"}}, [], [:match]}])\n\n assert [\"hello\", \"world\"] ==\n Registry.select(registry, [{{:\"$1\", :_, :_}, [], [:\"$1\"]}]) |> Enum.sort()\n end\n\n test \"select supports guard conditions\", %{registry: registry} do\n value = {1, :atom, 2}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert [{\"hello\", self(), {1, :atom, 2}}] ==\n Registry.select(registry, [\n {{:\"$1\", :\"$2\", {:\"$3\", :\"$4\", :\"$5\"}}, [{:>, :\"$5\", 1}],\n [{{:\"$1\", :\"$2\", {{:\"$3\", :\"$4\", :\"$5\"}}}}]}\n ])\n\n assert [] ==\n Registry.select(registry, [\n {{:_, :_, {:_, :_, :\"$1\"}}, [{:>, :\"$1\", 2}], [:\"$_\"]}\n ])\n\n assert [\"hello\"] ==\n Registry.select(registry, [\n {{:\"$1\", :_, {:_, :\"$2\", :_}}, [{:is_atom, :\"$2\"}], [:\"$1\"]}\n ])\n end\n\n test \"select allows multiple specs\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n\n assert [\"hello\", \"world\"] ==\n Registry.select(registry, [\n {{\"hello\", :_, :_}, [], [{:element, 1, :\"$_\"}]},\n {{\"world\", :_, :_}, [], [{:element, 1, :\"$_\"}]}\n ])\n |> Enum.sort()\n end\n\n test \"select raises on incorrect shape of match spec\", %{registry: registry} do\n assert_raise ArgumentError, fn ->\n Registry.select(registry, [{:_, [], []}])\n end\n end\n\n test \"count_select supports match specs\", %{registry: registry} do\n value = {1, :atom, 1}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n assert 1 == Registry.count_select(registry, [{{:_, :_, value}, [], [true]}])\n assert 1 == Registry.count_select(registry, [{{\"hello\", :_, :_}, [], [true]}])\n assert 1 == Registry.count_select(registry, [{{:_, :_, {1, :atom, :_}}, [], [true]}])\n assert 1 == Registry.count_select(registry, [{{:_, :_, {:\"$1\", :_, :\"$1\"}}, [], [true]}])\n assert 0 == Registry.count_select(registry, [{{\"hello\", :_, nil}, [], [true]}])\n\n value2 = %{a: \"a\", b: \"b\"}\n {:ok, _} = Registry.register(registry, \"world\", value2)\n assert 1 == Registry.count_select(registry, [{{\"world\", :_, :_}, [], [true]}])\n end\n\n test \"count_select supports guard conditions\", %{registry: registry} do\n value = {1, :atom, 2}\n {:ok, _} = Registry.register(registry, \"hello\", value)\n\n assert 1 ==\n Registry.count_select(registry, [\n {{:_, :_, {:_, :\"$1\", :_}}, [{:is_atom, :\"$1\"}], [true]}\n ])\n\n assert 1 ==\n Registry.count_select(registry, [\n {{:_, :_, {:_, :_, :\"$1\"}}, [{:>, :\"$1\", 1}], [true]}\n ])\n\n assert 0 ==\n Registry.count_select(registry, [\n {{:_, :_, {:_, :_, :\"$1\"}}, [{:>, :\"$1\", 2}], [true]}\n ])\n end\n\n test \"count_select allows multiple specs\", %{registry: registry} do\n {:ok, _} = Registry.register(registry, \"hello\", :value)\n {:ok, _} = Registry.register(registry, \"world\", :value)\n\n assert 2 ==\n Registry.count_select(registry, [\n {{\"hello\", :_, :_}, [], [true]},\n {{\"world\", :_, :_}, [], [true]}\n ])\n end\n\n test \"count_select raises on incorrect shape of match spec\", %{registry: registry} do\n assert_raise ArgumentError, fn ->\n Registry.count_select(registry, [{:_, [], []}])\n end\n end\n\n test \"doesn't grow ets on already_registered\",\n %{registry: registry, partitions: partitions} do\n assert sum_pid_entries(registry, partitions) == 0\n\n {:ok, pid} = Registry.register(registry, \"hello\", :value)\n assert is_pid(pid)\n assert sum_pid_entries(registry, partitions) == 1\n\n {:ok, pid} = Registry.register(registry, \"world\", :value)\n assert is_pid(pid)\n assert sum_pid_entries(registry, partitions) == 2\n\n assert {:error, {:already_registered, _pid}} =\n Registry.register(registry, \"hello\", :value)\n\n assert sum_pid_entries(registry, partitions) == 2\n end\n\n test \"doesn't grow ets on already_registered across processes\",\n %{registry: registry, partitions: partitions} do\n assert sum_pid_entries(registry, partitions) == 0\n\n {_, task} = register_task(registry, \"hello\", :value)\n Process.link(Process.whereis(registry))\n\n assert sum_pid_entries(registry, partitions) == 1\n\n {:ok, pid} = Registry.register(registry, \"world\", :value)\n assert is_pid(pid)\n assert sum_pid_entries(registry, partitions) == 2\n\n assert {:error, {:already_registered, ^task}} =\n Registry.register(registry, \"hello\", :recent)\n\n assert sum_pid_entries(registry, partitions) == 2\n end\n\n defp register_task(registry, key, value) do\n parent = self()\n\n {:ok, task} =\n Task.start(fn ->\n send(parent, Registry.register(registry, key, value))\n Process.sleep(:infinity)\n end)\n\n assert_receive {:ok, owner}\n {owner, task}\n end\n\n defp kill_and_assert_down(pid) do\n ref = Process.monitor(pid)\n Process.exit(pid, :kill)\n assert_receive {:DOWN, ^ref, _, _, _}\n end\n\n defp sum_pid_entries(registry, partitions) do\n Enum.sum_by(0..(partitions - 1), fn partition ->\n registry\n |> Module.concat(\"PIDPartition#{partition}\")\n |> ets_entries()\n end)\n end\n\n defp ets_entries(table_name) do\n :ets.all()\n |> Enum.find_value(fn id -> :ets.info(id, :name) == table_name and :ets.info(id, :size) end)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/registry_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule Registry.CommonTest do\n use ExUnit.Case, async: true\n doctest Registry, except: [:moduledoc]\nend\n\ndefmodule Registry.Test do\n use ExUnit.Case,\n async: true,\n parameterize:\n for(\n keys <- [:unique, :duplicate, {:duplicate, :pid}, {:duplicate, :key}],\n partitions <- [1, 8],\n do: %{keys: keys, partitions: partitions}\n )\n\n setup config do\n keys = config.keys || :unique\n partitions = config.partitions\n\n listeners =\n List.wrap(config[:base_listener]) |> Enum.map(&:\"#{&1}_#{partitions}_#{inspect(keys)}\")\n\n name = :\"#{config.test}_#{partitions}_#{inspect(keys)}\"\n opts = [keys: keys, name: name, partitions: partitions, listeners: listeners]\n {:ok, _} = start_supervised({Registry, opts})\n %{registry: name, listeners: listeners}\n end\n\n # Note: those tests relies on internals\n test \"clean up registry on process crash\",\n %{registry: registry, partitions: partitions} do\n {_, task1} = register_task(registry, \"hello\", :value)\n {_, task2} = register_task(registry, \"world\", :value)\n\n kill_and_assert_down(task1)\n kill_and_assert_down(task2)\n\n # pid might be in different partition to key so need to sync with all\n # partitions before checking ETS tables are empty.\n if partitions > 1 do\n for i <- 0..(partitions - 1) do\n [{_, _, {partition, _}}] = :ets.lookup(registry, i)\n GenServer.call(partition, :sync)\n end\n\n for i <- 0..(partitions - 1) do\n [{_, key, {_, pid}}] = :ets.lookup(registry, i)\n assert :ets.tab2list(key) == []\n assert :ets.tab2list(pid) == []\n end\n else\n [{-1, {_, _, key, {partition, pid}, _}}] = :ets.lookup(registry, -1)\n GenServer.call(partition, :sync)\n assert :ets.tab2list(key) == []\n assert :ets.tab2list(pid) == []\n end\n end\n\n defp register_task(registry, key, value) do\n parent = self()\n\n {:ok, task} =\n Task.start(fn ->\n send(parent, Registry.register(registry, key, value))\n Process.sleep(:infinity)\n end)\n\n assert_receive {:ok, owner}\n {owner, task}\n end\n\n defp kill_and_assert_down(pid) do\n ref = Process.monitor(pid)\n Process.exit(pid, :kill)\n assert_receive {:DOWN, ^ref, _, _, _}\n end\nend\n\ndefmodule Registry.LockTest do\n use ExUnit.Case,\n async: true,\n parameterize: [\n %{keys: :unique, partitions: 1},\n %{keys: :unique, partitions: 8},\n %{keys: :duplicate, partitions: 1},\n %{keys: :duplicate, partitions: 8}\n ]\n\n setup config do\n keys = config.keys\n partitions = config.partitions\n name = :\"#{config.test}_#{keys}_#{partitions}\"\n opts = [keys: keys, name: name, partitions: partitions]\n {:ok, _} = start_supervised({Registry, opts})\n %{registry: name}\n end\n\n test \"does not lock when using different keys\", config do\n parent = self()\n\n task1 =\n Task.async(fn ->\n Registry.lock(config.registry, 1, fn ->\n send(parent, :locked1)\n assert_receive :unlock\n :done\n end)\n end)\n\n assert_receive :locked1\n\n task2 =\n Task.async(fn ->\n Registry.lock(config.registry, 2, fn ->\n send(parent, :locked2)\n assert_receive :unlock\n :done\n end)\n end)\n\n assert_receive :locked2\n\n send(task1.pid, :unlock)\n send(task2.pid, :unlock)\n assert Task.await(task1) == :done\n assert Task.await(task2) == :done\n assert Registry.lock(config.registry, 1, fn -> :done end) == :done\n assert Registry.lock(config.registry, 2, fn -> :done end) == :done\n end\n\n test \"locks when using the same key\", config do\n parent = self()\n\n task1 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n send(parent, :locked1)\n assert_receive :unlock\n :done\n end)\n end)\n\n assert_receive :locked1\n\n task2 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n send(parent, :locked2)\n :done\n end)\n end)\n\n refute_receive :locked2, 100\n\n send(task1.pid, :unlock)\n assert Task.await(task1) == :done\n assert_receive :locked2\n assert Task.await(task2) == :done\n assert Registry.lock(config.registry, :ok, fn -> :done end) == :done\n end\n\n @tag :capture_log\n test \"locks when the one holding the lock raises\", config do\n parent = self()\n\n task1 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n send(parent, :locked)\n assert_receive :unlock\n raise \"oops\"\n end)\n end)\n\n Process.unlink(task1.pid)\n assert_receive :locked\n\n task2 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n :done\n end)\n end)\n\n send(task1.pid, :unlock)\n assert {:exit, {%RuntimeError{message: \"oops\"}, [_ | _]}} = Task.yield(task1)\n assert Task.await(task2) == :done\n assert Registry.lock(config.registry, :ok, fn -> :done end) == :done\n end\n\n test \"locks when the one holding the lock terminates\", config do\n parent = self()\n\n task1 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n send(parent, :locked)\n assert_receive :unlock\n :done\n end)\n end)\n\n assert_receive :locked\n\n task2 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n :done\n end)\n end)\n\n assert Task.shutdown(task1, :brutal_kill) == nil\n assert Task.await(task2) == :done\n assert Registry.lock(config.registry, :ok, fn -> :done end) == :done\n end\n\n test \"locks when the one waiting for the lock terminates\", config do\n parent = self()\n\n task1 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n send(parent, :locked)\n assert_receive :unlock\n :done\n end)\n end)\n\n assert_receive :locked\n\n task2 =\n Task.async(fn ->\n Registry.lock(config.registry, :ok, fn ->\n :done\n end)\n end)\n\n :erlang.yield()\n assert Task.shutdown(task2, :brutal_kill) == nil\n\n send(task1.pid, :unlock)\n assert Task.await(task1) == :done\n assert Registry.lock(config.registry, :ok, fn -> :done end) == :done\n end\nend\n" }, { "path": "lib/elixir/test/elixir/stream_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule StreamTest do\n use ExUnit.Case, async: true\n\n doctest Stream\n\n defmodule Pdict do\n defstruct []\n\n defimpl Collectable do\n def into(struct) do\n fun = fn\n _, {:cont, x} -> Process.put(:stream_cont, [x | Process.get(:stream_cont)])\n _, :done -> Process.put(:stream_done, true)\n _, :halt -> Process.put(:stream_halt, true)\n end\n\n {struct, fun}\n end\n end\n end\n\n defmodule HaltAcc do\n defstruct [:acc]\n\n defimpl Enumerable do\n def count(_lazy), do: {:error, __MODULE__}\n\n def member?(_lazy, _value), do: {:error, __MODULE__}\n\n def slice(_lazy), do: {:error, __MODULE__}\n\n def reduce(lazy, _acc, _fun) do\n {:halted, Enum.to_list(lazy.acc)}\n end\n end\n end\n\n test \"streams as enumerables\" do\n stream = Stream.map([1, 2, 3], &(&1 * 2))\n\n # Reduce\n assert Enum.map(stream, &(&1 + 1)) == [3, 5, 7]\n # Member\n assert Enum.member?(stream, 4)\n refute Enum.member?(stream, 1)\n # Count\n assert Enum.count(stream) == 3\n end\n\n test \"streams are composable\" do\n stream = Stream.map([1, 2, 3], &(&1 * 2))\n assert lazy?(stream)\n\n stream = Stream.map(stream, &(&1 + 1))\n assert lazy?(stream)\n\n assert Enum.to_list(stream) == [3, 5, 7]\n end\n\n test \"chunk_every/2, chunk_every/3 and chunk_every/4\" do\n assert Stream.chunk_every([1, 2, 3, 4, 5], 2) |> Enum.to_list() == [[1, 2], [3, 4], [5]]\n\n assert Stream.chunk_every([1, 2, 3, 4, 5], 2, 2, [6]) |> Enum.to_list() ==\n [[1, 2], [3, 4], [5, 6]]\n\n assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) |> Enum.to_list() ==\n [[1, 2, 3], [3, 4, 5]]\n\n assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 2, 3, :discard) |> Enum.to_list() ==\n [[1, 2], [4, 5]]\n\n assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, []) |> Enum.to_list() ==\n [[1, 2, 3], [3, 4, 5], [5, 6]]\n\n assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list() ==\n [[1, 2, 3], [4, 5, 6]]\n\n assert Stream.chunk_every([1, 2, 3, 4, 5], 4, 4, 6..10) |> Enum.to_list() ==\n [[1, 2, 3, 4], [5, 6, 7, 8]]\n end\n\n test \"chunk_every/4 is zippable\" do\n stream = Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, [])\n list = Enum.to_list(stream)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n end\n\n test \"chunk_every/4 is haltable\" do\n assert 1..10 |> Stream.take(6) |> Stream.chunk_every(4, 4, [7, 8]) |> Enum.to_list() ==\n [[1, 2, 3, 4], [5, 6, 7, 8]]\n\n assert 1..10\n |> Stream.take(6)\n |> Stream.chunk_every(4, 4, [7, 8])\n |> Stream.take(3)\n |> Enum.to_list() == [[1, 2, 3, 4], [5, 6, 7, 8]]\n\n assert 1..10\n |> Stream.take(6)\n |> Stream.chunk_every(4, 4, [7, 8])\n |> Stream.take(2)\n |> Enum.to_list() == [[1, 2, 3, 4], [5, 6, 7, 8]]\n\n assert 1..10\n |> Stream.take(6)\n |> Stream.chunk_every(4, 4, [7, 8])\n |> Stream.take(1)\n |> Enum.to_list() == [[1, 2, 3, 4]]\n\n assert 1..6 |> Stream.take(6) |> Stream.chunk_every(4, 4, [7, 8]) |> Enum.to_list() ==\n [[1, 2, 3, 4], [5, 6, 7, 8]]\n end\n\n test \"chunk_by/2\" do\n stream = Stream.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1))\n\n assert lazy?(stream)\n assert Enum.to_list(stream) == [[1], [2, 2], [3], [4, 4, 6], [7, 7]]\n assert stream |> Stream.take(3) |> Enum.to_list() == [[1], [2, 2], [3]]\n assert 1..10 |> Stream.chunk_every(2) |> Enum.take(2) == [[1, 2], [3, 4]]\n end\n\n test \"chunk_by/2 is zippable\" do\n stream = Stream.chunk_by([1, 2, 2, 3], &(rem(&1, 2) == 1))\n list = Enum.to_list(stream)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n end\n\n test \"chunk_while/4\" do\n chunk_fun = fn i, acc ->\n cond do\n i > 10 -> {:halt, acc}\n rem(i, 2) == 0 -> {:cont, Enum.reverse([i | acc]), []}\n true -> {:cont, [i | acc]}\n end\n end\n\n after_fun = fn\n [] -> {:cont, []}\n acc -> {:cont, Enum.reverse(acc), []}\n end\n\n assert Stream.chunk_while([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [], chunk_fun, after_fun)\n |> Enum.to_list() == [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]\n\n assert Stream.chunk_while(0..9, [], chunk_fun, after_fun) |> Enum.to_list() ==\n [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9]]\n\n assert Stream.chunk_while(0..10, [], chunk_fun, after_fun) |> Enum.to_list() ==\n [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]\n\n assert Stream.chunk_while(0..11, [], chunk_fun, after_fun) |> Enum.to_list() ==\n [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]\n\n assert Stream.chunk_while([5, 7, 9, 11], [], chunk_fun, after_fun) |> Enum.to_list() ==\n [[5, 7, 9]]\n end\n\n test \"chunk_while/4 with inner halt\" do\n chunk_fun = fn\n i, [] ->\n {:cont, [i]}\n\n i, chunk ->\n if rem(i, 2) == 0 do\n {:cont, Enum.reverse(chunk), [i]}\n else\n {:cont, [i | chunk]}\n end\n end\n\n after_fun = fn\n [] -> {:cont, []}\n chunk -> {:cont, Enum.reverse(chunk), []}\n end\n\n assert Stream.chunk_while([1, 2, 3, 4, 5], [], chunk_fun, after_fun) |> Enum.at(0) == [1]\n end\n\n test \"chunk_while/4 regression case with concat\" do\n result =\n [\"WrongHeader\\nJohn Doe\", \"skipped\"]\n |> Stream.take(1)\n |> Stream.chunk_while(\n \"\",\n fn element, acc ->\n {acc, elements} = String.split(acc <> element, \"\\n\") |> List.pop_at(-1)\n {:cont, elements, acc}\n end,\n &{:cont, [&1], []}\n )\n |> Stream.concat()\n |> Enum.to_list()\n\n assert result == [\"WrongHeader\", \"John Doe\"]\n end\n\n test \"concat/1\" do\n stream = Stream.concat([1..3, [], [4, 5, 6], [], 7..9])\n assert is_function(stream)\n\n assert Enum.to_list(stream) == [1, 2, 3, 4, 5, 6, 7, 8, 9]\n assert Enum.take(stream, 5) == [1, 2, 3, 4, 5]\n\n stream = Stream.concat([1..3, [4, 5, 6], Stream.cycle(7..100)])\n assert is_function(stream)\n\n assert Enum.take(stream, 13) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]\n end\n\n test \"concat/2\" do\n stream = Stream.concat(1..3, 4..6)\n assert is_function(stream)\n\n assert Stream.cycle(stream) |> Enum.take(16) ==\n [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4]\n\n stream = Stream.concat(1..3, [])\n assert is_function(stream)\n assert Stream.cycle(stream) |> Enum.take(5) == [1, 2, 3, 1, 2]\n\n stream = Stream.concat(1..6, Stream.cycle(7..9))\n assert is_function(stream)\n assert Stream.drop(stream, 3) |> Enum.take(13) == [4, 5, 6, 7, 8, 9, 7, 8, 9, 7, 8, 9, 7]\n\n stream = Stream.concat(Stream.cycle(1..3), Stream.cycle(4..6))\n assert is_function(stream)\n assert Enum.take(stream, 13) == [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1]\n end\n\n test \"concat/2 is zippable\" do\n stream = 1..2 |> Stream.take(2) |> Stream.concat(3..4)\n assert Enum.zip(1..4, [1, 2, 3, 4]) == Enum.zip(1..4, stream)\n end\n\n test \"concat/2 does not intercept wrapped lazy enumeration\" do\n # concat returns a lazy enumeration that does not halt\n assert Stream.concat([[0], Stream.map([1, 2, 3], & &1), [4]])\n |> Stream.take_while(fn x -> x <= 4 end)\n |> Enum.to_list() == [0, 1, 2, 3, 4]\n\n # concat returns a lazy enumeration that does halts\n assert Stream.concat([[0], Stream.take_while(1..6, &(&1 <= 3)), [4]])\n |> Stream.take_while(fn x -> x <= 4 end)\n |> Enum.to_list() == [0, 1, 2, 3, 4]\n end\n\n test \"cycle/1\" do\n stream = Stream.cycle([1, 2, 3])\n assert is_function(stream)\n\n assert_raise ArgumentError, \"cannot cycle over an empty enumerable\", fn ->\n Stream.cycle([])\n end\n\n assert_raise ArgumentError, \"cannot cycle over an empty enumerable\", fn ->\n Stream.cycle(%{}) |> Enum.to_list()\n end\n\n assert Stream.cycle([1, 2, 3]) |> Stream.take(5) |> Enum.to_list() == [1, 2, 3, 1, 2]\n assert Enum.take(stream, 5) == [1, 2, 3, 1, 2]\n end\n\n test \"cycle/1 is zippable\" do\n stream = Stream.cycle([1, 2, 3])\n assert Enum.zip(1..6, [1, 2, 3, 1, 2, 3]) == Enum.zip(1..6, stream)\n end\n\n test \"cycle/1 with inner stream\" do\n assert [1, 2, 3] |> Stream.take(2) |> Stream.cycle() |> Enum.take(4) == [1, 2, 1, 2]\n end\n\n test \"cycle/1 with cycle/1 with cycle/1\" do\n assert [1] |> Stream.cycle() |> Stream.cycle() |> Stream.cycle() |> Enum.take(5) ==\n [1, 1, 1, 1, 1]\n end\n\n test \"dedup/1 is lazy\" do\n assert lazy?(Stream.dedup([1, 2, 3]))\n end\n\n test \"dedup/1\" do\n assert Stream.dedup([1, 1, 2, 1, 1, 2, 1]) |> Enum.to_list() == [1, 2, 1, 2, 1]\n assert Stream.dedup([2, 1, 1, 2, 1]) |> Enum.to_list() == [2, 1, 2, 1]\n assert Stream.dedup([1, 2, 3, 4]) |> Enum.to_list() == [1, 2, 3, 4]\n assert Stream.dedup([1, 1.0, 2.0, 2]) |> Enum.to_list() == [1, 1.0, 2.0, 2]\n assert Stream.dedup([]) |> Enum.to_list() == []\n\n assert Stream.dedup([nil, nil, true, {:value, true}]) |> Enum.to_list() ==\n [nil, true, {:value, true}]\n\n assert Stream.dedup([nil]) |> Enum.to_list() == [nil]\n end\n\n test \"dedup_by/2\" do\n assert Stream.dedup_by([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end)\n |> Enum.to_list() == [{1, :x}, {2, :y}, {1, :x}]\n end\n\n test \"drop/2\" do\n stream = Stream.drop(1..10, 5)\n assert lazy?(stream)\n assert Enum.to_list(stream) == [6, 7, 8, 9, 10]\n\n assert Enum.to_list(Stream.drop(1..5, 0)) == [1, 2, 3, 4, 5]\n assert Enum.to_list(Stream.drop(1..3, 5)) == []\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.drop(nats, 2) |> Enum.take(5) == [3, 4, 5, 6, 7]\n end\n\n test \"drop/2 with negative count\" do\n stream = Stream.drop(1..10, -5)\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 2, 3, 4, 5]\n\n stream = Stream.drop(1..10, -5)\n list = Enum.to_list(stream)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n end\n\n test \"drop/2 with negative count stream entries\" do\n par = self()\n\n pid =\n spawn_link(fn ->\n Enum.each(Stream.drop(&inbox_stream/2, -3), fn x -> send(par, {:stream, x}) end)\n end)\n\n send(pid, {:stream, 1})\n send(pid, {:stream, 2})\n send(pid, {:stream, 3})\n refute_receive {:stream, 1}, 100\n\n send(pid, {:stream, 4})\n assert_receive {:stream, 1}\n\n send(pid, {:stream, 5})\n assert_receive {:stream, 2}\n refute_receive {:stream, 3}, 100\n end\n\n test \"drop_every/2\" do\n assert 1..10\n |> Stream.drop_every(2)\n |> Enum.to_list() == [2, 4, 6, 8, 10]\n\n assert 1..10\n |> Stream.drop_every(3)\n |> Enum.to_list() == [2, 3, 5, 6, 8, 9]\n\n assert 1..10\n |> Stream.drop(2)\n |> Stream.drop_every(2)\n |> Stream.drop(1)\n |> Enum.to_list() == [6, 8, 10]\n\n assert 1..10\n |> Stream.drop_every(0)\n |> Enum.to_list() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\n assert []\n |> Stream.drop_every(10)\n |> Enum.to_list() == []\n end\n\n test \"drop_every/2 with negative integer\" do\n assert_raise FunctionClauseError, fn ->\n Stream.drop_every(1..10, -1)\n end\n end\n\n test \"drop_while/2\" do\n stream = Stream.drop_while(1..10, &(&1 <= 5))\n assert lazy?(stream)\n assert Enum.to_list(stream) == [6, 7, 8, 9, 10]\n\n assert Enum.to_list(Stream.drop_while(1..5, &(&1 <= 0))) == [1, 2, 3, 4, 5]\n assert Enum.to_list(Stream.drop_while(1..3, &(&1 <= 5))) == []\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.drop_while(nats, &(&1 <= 5)) |> Enum.take(5) == [6, 7, 8, 9, 10]\n end\n\n test \"duplicate/2\" do\n stream = Stream.duplicate(7, 7)\n\n assert is_function(stream)\n assert stream |> Stream.take(5) |> Enum.to_list() == [7, 7, 7, 7, 7]\n assert Enum.to_list(stream) == [7, 7, 7, 7, 7, 7, 7]\n end\n\n test \"each/2\" do\n Process.put(:stream_each, [])\n\n stream =\n Stream.each([1, 2, 3], fn x ->\n Process.put(:stream_each, [x | Process.get(:stream_each)])\n end)\n\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 2, 3]\n assert Process.get(:stream_each) == [3, 2, 1]\n end\n\n test \"filter/2\" do\n stream = Stream.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end)\n assert lazy?(stream)\n assert Enum.to_list(stream) == [2]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.filter(nats, &(rem(&1, 2) == 0)) |> Enum.take(5) == [2, 4, 6, 8, 10]\n end\n\n test \"flat_map/2\" do\n stream = Stream.flat_map([1, 2, 3], &[&1, &1 * 2])\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 2, 2, 4, 3, 6]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.flat_map(nats, &[&1, &1 * 2]) |> Enum.take(6) == [1, 2, 2, 4, 3, 6]\n end\n\n test \"flat_map/2 does not intercept wrapped lazy enumeration\" do\n # flat_map returns a lazy enumeration that does not halt\n assert [1, 2, 3, -1, -2]\n |> Stream.flat_map(fn x -> Stream.map([x, x + 1], & &1) end)\n |> Stream.take_while(fn x -> x >= 0 end)\n |> Enum.to_list() == [1, 2, 2, 3, 3, 4]\n\n # flat_map returns a lazy enumeration that does halts\n assert [1, 2, 3, -1, -2]\n |> Stream.flat_map(fn x -> Stream.take_while([x, x + 1, x + 2], &(&1 <= x + 1)) end)\n |> Stream.take_while(fn x -> x >= 0 end)\n |> Enum.to_list() == [1, 2, 2, 3, 3, 4]\n\n # flat_map returns a lazy enumeration that does halts wrapped in an enumerable\n assert [1, 2, 3, -1, -2]\n |> Stream.flat_map(fn x ->\n Stream.concat([x], Stream.take_while([x + 1, x + 2], &(&1 <= x + 1)))\n end)\n |> Stream.take_while(fn x -> x >= 0 end)\n |> Enum.to_list() == [1, 2, 2, 3, 3, 4]\n end\n\n test \"flat_map/2 is zippable\" do\n stream =\n [1, 2, 3, -1, -2]\n |> Stream.flat_map(fn x -> Stream.map([x, x + 1], & &1) end)\n |> Stream.take_while(fn x -> x >= 0 end)\n\n list = Enum.to_list(stream)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n end\n\n test \"flat_map/2 does not leave inner stream suspended\" do\n stream =\n Stream.flat_map([1, 2, 3], fn i ->\n Stream.resource(fn -> i end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_flat_map, true)\n end)\n end)\n\n Process.put(:stream_flat_map, false)\n assert stream |> Enum.take(3) == [1, 2, 3]\n assert Process.get(:stream_flat_map)\n end\n\n test \"flat_map/2 does not leave outer stream suspended\" do\n stream =\n Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_flat_map, true)\n end)\n\n stream = Stream.flat_map(stream, fn i -> [i, i + 1, i + 2] end)\n\n Process.put(:stream_flat_map, false)\n assert stream |> Enum.take(3) == [1, 2, 3]\n assert Process.get(:stream_flat_map)\n end\n\n test \"flat_map/2 closes on error\" do\n stream =\n Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_flat_map, true)\n end)\n\n stream = Stream.flat_map(stream, fn _ -> throw(:error) end)\n\n Process.put(:stream_flat_map, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_flat_map)\n end\n\n test \"flat_map/2 with inner flat_map/2\" do\n stream =\n Stream.flat_map(1..5, fn x ->\n Stream.flat_map([x], fn x ->\n x..(x * x)\n end)\n |> Stream.map(&(&1 * 1))\n end)\n\n assert Enum.take(stream, 5) == [1, 2, 3, 4, 3]\n end\n\n test \"flat_map/2 properly halts both inner and outer stream when inner stream is halted\" do\n # Fixes a bug that, when the inner stream was done,\n # sending it a halt would cause it to return the\n # inner stream was halted, forcing flat_map to get\n # the next value from the outer stream, evaluate it,\n # get another inner stream, just to halt it.\n # 2 should never be used\n assert [1, 2]\n |> Stream.flat_map(fn 1 -> Stream.repeatedly(fn -> 1 end) end)\n |> Stream.flat_map(fn 1 -> Stream.repeatedly(fn -> 1 end) end)\n |> Enum.take(1) == [1]\n end\n\n test \"interval/1\" do\n stream = Stream.interval(10)\n {time_us, value} = :timer.tc(fn -> Enum.take(stream, 5) end)\n\n assert value == [0, 1, 2, 3, 4]\n assert time_us >= 50000\n end\n\n test \"interval/1 with infinity\" do\n stream = Stream.interval(:infinity)\n spawn(Stream, :run, [stream])\n end\n\n test \"into/2 and run/1\" do\n Process.put(:stream_cont, [])\n Process.put(:stream_done, false)\n Process.put(:stream_halt, false)\n\n stream = Stream.into([1, 2, 3], %Pdict{})\n\n assert lazy?(stream)\n assert Stream.run(stream) == :ok\n assert Process.get(:stream_cont) == [3, 2, 1]\n assert Process.get(:stream_done)\n refute Process.get(:stream_halt)\n\n stream = Stream.into(fn _, _ -> raise \"error\" end, %Pdict{})\n catch_error(Stream.run(stream))\n assert Process.get(:stream_halt)\n end\n\n test \"into/3\" do\n Process.put(:stream_cont, [])\n Process.put(:stream_done, false)\n Process.put(:stream_halt, false)\n\n stream = Stream.into([1, 2, 3], %Pdict{}, fn x -> x * 2 end)\n\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 2, 3]\n assert Process.get(:stream_cont) == [6, 4, 2]\n assert Process.get(:stream_done)\n refute Process.get(:stream_halt)\n end\n\n test \"into/2 with halting\" do\n Process.put(:stream_cont, [])\n Process.put(:stream_done, false)\n Process.put(:stream_halt, false)\n\n stream = Stream.into([1, 2, 3], %Pdict{})\n\n assert lazy?(stream)\n assert Enum.take(stream, 1) == [1]\n assert Process.get(:stream_cont) == [1]\n assert Process.get(:stream_done)\n refute Process.get(:stream_halt)\n end\n\n test \"transform/3\" do\n stream = Stream.transform([1, 2, 3], 0, &{[&1, &2], &1 + &2})\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 0, 2, 1, 3, 3]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.transform(nats, 0, &{[&1, &2], &1 + &2}) |> Enum.take(6) == [1, 0, 2, 1, 3, 3]\n end\n\n test \"transform/3 with early halt\" do\n stream =\n fn -> throw(:error) end\n |> Stream.repeatedly()\n |> Stream.transform(nil, &{[&1, &2], &1})\n\n assert {:halted, nil} = Enumerable.reduce(stream, {:halt, nil}, fn _, _ -> throw(:error) end)\n end\n\n test \"transform/3 with early suspend\" do\n stream =\n Stream.repeatedly(fn -> throw(:error) end)\n |> Stream.transform(nil, &{[&1, &2], &1})\n\n assert {:suspended, nil, _} =\n Enumerable.reduce(stream, {:suspend, nil}, fn _, _ -> throw(:error) end)\n end\n\n test \"transform/3 with halt\" do\n stream =\n Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_transform, true)\n end)\n\n stream =\n Stream.transform(stream, 0, fn i, acc ->\n if acc < 3, do: {[i], acc + 1}, else: {:halt, acc}\n end)\n\n Process.put(:stream_transform, false)\n assert Enum.to_list(stream) == [1, 2, 3]\n assert Process.get(:stream_transform)\n end\n\n test \"transform/3 (via flat_map) handles multiple returns from suspension\" do\n assert [false]\n |> Stream.take(1)\n |> Stream.concat([true])\n |> Stream.flat_map(&[&1])\n |> Enum.to_list() == [false, true]\n end\n\n test \"iterate/2\" do\n stream = Stream.iterate(0, &(&1 + 2))\n assert Enum.take(stream, 5) == [0, 2, 4, 6, 8]\n stream = Stream.iterate(5, &(&1 + 2))\n assert Enum.take(stream, 5) == [5, 7, 9, 11, 13]\n\n # Only calculate values if needed\n stream = Stream.iterate(\"HELLO\", &raise/1)\n assert Enum.take(stream, 1) == [\"HELLO\"]\n end\n\n test \"map/2\" do\n stream = Stream.map([1, 2, 3], &(&1 * 2))\n assert lazy?(stream)\n assert Enum.to_list(stream) == [2, 4, 6]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.map(nats, &(&1 * 2)) |> Enum.take(5) == [2, 4, 6, 8, 10]\n assert Stream.map(nats, &(&1 - 2)) |> Stream.map(&(&1 * 2)) |> Enum.take(3) == [-2, 0, 2]\n end\n\n test \"map_every/3\" do\n assert 1..10\n |> Stream.map_every(2, &(&1 * 2))\n |> Enum.to_list() == [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]\n\n assert 1..10\n |> Stream.map_every(3, &(&1 * 2))\n |> Enum.to_list() == [2, 2, 3, 8, 5, 6, 14, 8, 9, 20]\n\n assert 1..10\n |> Stream.drop(2)\n |> Stream.map_every(2, &(&1 * 2))\n |> Stream.drop(1)\n |> Enum.to_list() == [4, 10, 6, 14, 8, 18, 10]\n\n assert 1..5\n |> Stream.map_every(0, &(&1 * 2))\n |> Enum.to_list() == [1, 2, 3, 4, 5]\n\n assert []\n |> Stream.map_every(10, &(&1 * 2))\n |> Enum.to_list() == []\n\n assert_raise FunctionClauseError, fn ->\n Stream.map_every(1..10, -1, &(&1 * 2))\n end\n end\n\n test \"reject/2\" do\n stream = Stream.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end)\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 3]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.reject(nats, &(rem(&1, 2) == 0)) |> Enum.take(5) == [1, 3, 5, 7, 9]\n end\n\n test \"repeatedly/1\" do\n stream = Stream.repeatedly(fn -> 1 end)\n assert Enum.take(stream, 5) == [1, 1, 1, 1, 1]\n stream = Stream.repeatedly(&:rand.uniform/0)\n [r1, r2] = Enum.take(stream, 2)\n assert r1 != r2\n end\n\n test \"resource/3 closes on outer errors\" do\n stream =\n Stream.resource(\n fn -> 1 end,\n fn\n 2 -> throw(:error)\n acc -> {[acc], acc + 1}\n end,\n fn 2 -> Process.put(:stream_resource, true) end\n )\n\n Process.put(:stream_resource, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_resource)\n end\n\n test \"resource/3 closes with correct accumulator on outer errors with inner single-element list\" do\n stream =\n Stream.resource(\n fn -> :start end,\n fn _ -> {[:error], :end} end,\n fn acc -> Process.put(:stream_resource, acc) end\n )\n |> Stream.map(fn :error -> throw(:error) end)\n\n Process.put(:stream_resource, nil)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_resource) == :end\n end\n\n test \"resource/3 closes with correct accumulator on outer errors with inner list\" do\n stream =\n Stream.resource(\n fn -> :start end,\n fn _ -> {[:ok, :error], :end} end,\n fn acc -> Process.put(:stream_resource, acc) end\n )\n |> Stream.map(fn acc -> if acc == :error, do: throw(:error), else: acc end)\n\n Process.put(:stream_resource, nil)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_resource) == :end\n end\n\n test \"resource/3 closes with correct accumulator on outer errors with inner enum\" do\n stream =\n Stream.resource(\n fn -> 1 end,\n fn acc -> {acc..(acc + 2), acc + 1} end,\n fn acc -> Process.put(:stream_resource, acc) end\n )\n |> Stream.map(fn x -> if x > 2, do: throw(:error), else: x end)\n\n Process.put(:stream_resource, nil)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_resource) == 2\n end\n\n test \"resource/3 is zippable\" do\n transform_fun = fn\n 10 -> {:halt, 10}\n acc -> {[acc], acc + 1}\n end\n\n after_fun = fn _ -> Process.put(:stream_resource, true) end\n stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)\n\n list = Enum.to_list(stream)\n Process.put(:stream_resource, false)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n assert Process.get(:stream_resource)\n end\n\n test \"resource/3 returning inner empty list\" do\n transform_fun = fn acc -> if rem(acc, 2) == 0, do: {[], acc + 1}, else: {[acc], acc + 1} end\n stream = Stream.resource(fn -> 1 end, transform_fun, fn _ -> :ok end)\n\n assert Enum.take(stream, 5) == [1, 3, 5, 7, 9]\n end\n\n test \"resource/3 halts with inner list\" do\n transform_fun = fn acc -> {[acc, acc + 1, acc + 2], acc + 1} end\n after_fun = fn _ -> Process.put(:stream_resource, true) end\n stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)\n\n Process.put(:stream_resource, false)\n assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]\n assert Process.get(:stream_resource)\n end\n\n test \"resource/3 closes on errors with inner list\" do\n transform_fun = fn acc -> {[acc, acc + 1, acc + 2], acc + 1} end\n after_fun = fn _ -> Process.put(:stream_resource, true) end\n stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)\n\n Process.put(:stream_resource, false)\n stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_resource)\n end\n\n test \"resource/3 is zippable with inner list\" do\n transform_fun = fn\n 10 -> {:halt, 10}\n acc -> {[acc, acc + 1, acc + 2], acc + 1}\n end\n\n after_fun = fn _ -> Process.put(:stream_resource, true) end\n stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)\n\n list = Enum.to_list(stream)\n Process.put(:stream_resource, false)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n assert Process.get(:stream_resource)\n end\n\n test \"resource/3 halts with inner enum\" do\n transform_fun = fn acc -> {acc..(acc + 2), acc + 1} end\n after_fun = fn _ -> Process.put(:stream_resource, true) end\n stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)\n\n Process.put(:stream_resource, false)\n assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]\n assert Process.get(:stream_resource)\n end\n\n test \"resource/3 closes on errors with inner enum\" do\n transform_fun = fn acc -> {acc..(acc + 2), acc + 1} end\n after_fun = fn _ -> Process.put(:stream_resource, true) end\n stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)\n\n Process.put(:stream_resource, false)\n stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_resource)\n end\n\n test \"resource/3 is zippable with inner enum\" do\n transform_fun = fn\n 10 -> {:halt, 10}\n acc -> {acc..(acc + 2), acc + 1}\n end\n\n after_fun = fn _ -> Process.put(:stream_resource, true) end\n stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)\n\n list = Enum.to_list(stream)\n Process.put(:stream_resource, false)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n assert Process.get(:stream_resource)\n end\n\n test \"transform/4\" do\n transform_fun = fn x, acc -> {[x, x + acc], x} end\n after_fun = fn 10 -> Process.put(:stream_transform, true) end\n stream = Stream.transform(1..10, fn -> 0 end, transform_fun, after_fun)\n Process.put(:stream_transform, false)\n\n assert Enum.to_list(stream) ==\n [1, 1, 2, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19]\n\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 with early halt\" do\n after_fun = fn nil -> Process.put(:stream_transform, true) end\n\n stream =\n fn -> throw(:error) end\n |> Stream.repeatedly()\n |> Stream.transform(fn -> nil end, &{[&1, &2], &1}, after_fun)\n\n Process.put(:stream_transform, false)\n assert {:halted, nil} = Enumerable.reduce(stream, {:halt, nil}, fn _, _ -> throw(:error) end)\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 with early suspend\" do\n after_fun = fn nil -> Process.put(:stream_transform, true) end\n\n stream =\n fn -> throw(:error) end\n |> Stream.repeatedly()\n |> Stream.transform(fn -> nil end, &{[&1, &2], &1}, after_fun)\n\n refute Process.get(:stream_transform)\n\n assert {:suspended, nil, _} =\n Enumerable.reduce(stream, {:suspend, nil}, fn _, _ -> throw(:error) end)\n end\n\n test \"transform/4 closes on outer errors\" do\n transform_fun = fn\n 3, _ -> throw(:error)\n x, acc -> {[x + acc], x}\n end\n\n after_fun = fn 2 -> Process.put(:stream_transform, true) end\n\n stream = Stream.transform(1..10, fn -> 0 end, transform_fun, after_fun)\n\n Process.put(:stream_transform, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 closes on nested errors\" do\n transform_fun = fn\n 3, _ -> throw(:error)\n x, acc -> {[x + acc], x}\n end\n\n after_fun = fn _ -> Process.put(:stream_transform_inner, true) end\n outer_after_fun = fn 0 -> Process.put(:stream_transform_outer, true) end\n\n stream =\n 1..10\n |> Stream.transform(fn -> 0 end, transform_fun, after_fun)\n |> Stream.transform(fn -> 0 end, fn x, acc -> {[x], acc} end, outer_after_fun)\n\n Process.put(:stream_transform_inner, false)\n Process.put(:stream_transform_outer, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_transform_inner)\n assert Process.get(:stream_transform_outer)\n end\n\n test \"transform/4 is zippable\" do\n transform_fun = fn\n 10, acc -> {:halt, acc}\n x, acc -> {[x + acc], x}\n end\n\n after_fun = fn 9 -> Process.put(:stream_transform, true) end\n stream = Stream.transform(1..20, fn -> 0 end, transform_fun, after_fun)\n\n list = Enum.to_list(stream)\n Process.put(:stream_transform, false)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 halts with inner list\" do\n transform_fun = fn x, acc -> {[x, x + 1, x + 2], acc} end\n after_fun = fn :acc -> Process.put(:stream_transform, true) end\n stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)\n\n Process.put(:stream_transform, false)\n assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 closes on errors with inner list\" do\n transform_fun = fn x, acc -> {[x, x + 1, x + 2], acc} end\n after_fun = fn :acc -> Process.put(:stream_transform, true) end\n stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)\n\n Process.put(:stream_transform, false)\n stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 is zippable with inner list\" do\n transform_fun = fn\n 10, acc -> {:halt, acc}\n x, acc -> {[x, x + 1, x + 2], acc}\n end\n\n after_fun = fn :inner -> Process.put(:stream_transform, true) end\n\n stream = Stream.transform(1..20, fn -> :inner end, transform_fun, after_fun)\n\n list = Enum.to_list(stream)\n Process.put(:stream_transform, false)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 halts with inner enum\" do\n transform_fun = fn x, acc -> {x..(x + 2), acc} end\n after_fun = fn :acc -> Process.put(:stream_transform, true) end\n stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)\n\n Process.put(:stream_transform, false)\n assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 closes on errors with inner enum\" do\n transform_fun = fn x, acc -> {x..(x + 2), acc} end\n after_fun = fn :acc -> Process.put(:stream_transform, true) end\n stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)\n\n Process.put(:stream_transform, false)\n stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_transform)\n end\n\n test \"transform/4 is zippable with inner enum\" do\n transform_fun = fn\n 10, acc -> {:halt, acc}\n x, acc -> {x..(x + 2), acc}\n end\n\n after_fun = fn :inner -> Process.put(:stream_transform, true) end\n stream = Stream.transform(1..20, fn -> :inner end, transform_fun, after_fun)\n\n list = Enum.to_list(stream)\n Process.put(:stream_transform, false)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n assert Process.get(:stream_transform)\n end\n\n test \"transform/5 emits last elements on done\" do\n stream =\n Stream.transform(\n 1..5//2,\n fn -> 0 end,\n fn i, _acc -> {i..(i + 1), i + 1} end,\n fn 6 -> {7..10, 10} end,\n fn i when is_integer(i) -> Process.put(__MODULE__, i) end\n )\n\n assert Enum.to_list(stream) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n assert Process.get(__MODULE__) == 10\n\n assert Enum.take(stream, 3) == [1, 2, 3]\n assert Process.get(__MODULE__) == 4\n\n assert Enum.take(stream, 4) == [1, 2, 3, 4]\n assert Process.get(__MODULE__) == 4\n\n assert Enum.take(stream, 7) == [1, 2, 3, 4, 5, 6, 7]\n assert Process.get(__MODULE__) == 10\n end\n\n test \"transform/5 emits last elements on inner halt done\" do\n stream =\n Stream.transform(\n Stream.take(1..15//2, 3),\n fn -> 0 end,\n fn i, _acc -> {i..(i + 1), i + 1} end,\n fn 6 -> {7..10, 10} end,\n fn i when is_integer(i) -> Process.put(__MODULE__, i) end\n )\n\n assert Enum.to_list(stream) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n assert Process.get(__MODULE__) == 10\n\n assert Enum.take(stream, 3) == [1, 2, 3]\n assert Process.get(__MODULE__) == 4\n\n assert Enum.take(stream, 4) == [1, 2, 3, 4]\n assert Process.get(__MODULE__) == 4\n\n assert Enum.take(stream, 7) == [1, 2, 3, 4, 5, 6, 7]\n assert Process.get(__MODULE__) == 10\n end\n\n test \"transform/5 does not halt twice\" do\n resource_start = fn -> 0 end\n\n resource_next = fn current ->\n if current < 5 do\n {[current], current + 1}\n else\n {:halt, current}\n end\n end\n\n resource_after = fn _ ->\n send(self(), {:halted, :resource})\n end\n\n transform_next = fn current, index -> {[current + 1], index} end\n transform_last = fn index -> {:halt, index} end\n\n transform_after = fn _ ->\n send(self(), {:halted, :transform})\n end\n\n Stream.resource(resource_start, resource_next, resource_after)\n |> Stream.transform(fn -> 1 end, transform_next, transform_last, transform_after)\n |> Stream.run()\n\n assert_received {:halted, :resource}\n assert_received {:halted, :transform}\n refute_received {:halted, :resource}\n refute_received {:halted, :transform}\n end\n\n test \"scan/2\" do\n stream = Stream.scan(1..5, &(&1 + &2))\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 3, 6, 10, 15]\n assert Stream.scan([], &(&1 + &2)) |> Enum.to_list() == []\n end\n\n test \"scan/3\" do\n stream = Stream.scan(1..5, 0, &(&1 + &2))\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 3, 6, 10, 15]\n assert Stream.scan([], 0, &(&1 + &2)) |> Enum.to_list() == []\n end\n\n test \"take/2\" do\n stream = Stream.take(1..1000, 5)\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 2, 3, 4, 5]\n\n assert Enum.to_list(Stream.take(1..1000, 0)) == []\n assert Enum.to_list(Stream.take([], 5)) == []\n assert Enum.to_list(Stream.take(1..3, 5)) == [1, 2, 3]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Enum.to_list(Stream.take(nats, 5)) == [1, 2, 3, 4, 5]\n\n stream = Stream.drop(1..100, 5)\n assert Stream.take(stream, 5) |> Enum.to_list() == [6, 7, 8, 9, 10]\n\n stream = 1..5 |> Stream.take(10) |> Stream.drop(15)\n assert {[], []} = Enum.split(stream, 5)\n\n stream = 1..20 |> Stream.take(10 + 5) |> Stream.drop(4)\n assert Enum.to_list(stream) == [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n end\n\n test \"take/2 does not consume next element on halt\" do\n assert [false, true]\n |> Stream.each(&(&1 && raise(\"oops\")))\n |> Stream.take(1)\n |> Stream.take_while(& &1)\n |> Enum.to_list() == []\n end\n\n test \"take/2 does not consume next element on suspend\" do\n assert [false, true]\n |> Stream.each(&(&1 && raise(\"oops\")))\n |> Stream.take(1)\n |> Stream.flat_map(&[&1])\n |> Enum.to_list() == [false]\n end\n\n test \"take/2 with negative count\" do\n Process.put(:stream_each, [])\n\n stream = Stream.take(1..100, -5)\n assert lazy?(stream)\n\n stream = Stream.each(stream, &Process.put(:stream_each, [&1 | Process.get(:stream_each)]))\n assert Enum.to_list(stream) == [96, 97, 98, 99, 100]\n assert Process.get(:stream_each) == [100, 99, 98, 97, 96]\n end\n\n test \"take/2 is zippable\" do\n stream = Stream.take(1..1000, 5)\n list = Enum.to_list(stream)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n end\n\n test \"take_every/2\" do\n assert 1..10\n |> Stream.take_every(2)\n |> Enum.to_list() == [1, 3, 5, 7, 9]\n\n assert 1..10\n |> Stream.take_every(3)\n |> Enum.to_list() == [1, 4, 7, 10]\n\n assert 1..10\n |> Stream.drop(2)\n |> Stream.take_every(2)\n |> Stream.drop(1)\n |> Enum.to_list() == [5, 7, 9]\n\n assert 1..10\n |> Stream.take_every(0)\n |> Enum.to_list() == []\n\n assert []\n |> Stream.take_every(10)\n |> Enum.to_list() == []\n end\n\n test \"take_every/2 with negative integer\" do\n assert_raise FunctionClauseError, fn ->\n Stream.take_every(1..10, -1)\n end\n end\n\n test \"take_while/2\" do\n stream = Stream.take_while(1..1000, &(&1 <= 5))\n assert lazy?(stream)\n assert Enum.to_list(stream) == [1, 2, 3, 4, 5]\n\n assert Enum.to_list(Stream.take_while(1..1000, &(&1 <= 0))) == []\n assert Enum.to_list(Stream.take_while(1..3, &(&1 <= 5))) == [1, 2, 3]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Enum.to_list(Stream.take_while(nats, &(&1 <= 5))) == [1, 2, 3, 4, 5]\n\n stream = Stream.drop(1..100, 5)\n assert Stream.take_while(stream, &(&1 < 11)) |> Enum.to_list() == [6, 7, 8, 9, 10]\n end\n\n test \"timer/1\" do\n stream = Stream.timer(10)\n\n {time_us, value} = :timer.tc(fn -> Enum.to_list(stream) end)\n\n assert value == [0]\n # We check for >= 5000 (us) instead of >= 10000 (us)\n # because the resolution on Windows system is not high\n # enough and we would get a difference of 9000 from\n # time to time. So a value halfway is good enough.\n assert time_us >= 5000\n end\n\n test \"timer/1 with infinity\" do\n stream = Stream.timer(:infinity)\n spawn(Stream, :run, [stream])\n end\n\n test \"unfold/2\" do\n stream = Stream.unfold(10, fn x -> if x > 0, do: {x, x - 1} end)\n assert Enum.take(stream, 5) == [10, 9, 8, 7, 6]\n stream = Stream.unfold(5, fn x -> if x > 0, do: {x, x - 1} end)\n assert Enum.to_list(stream) == [5, 4, 3, 2, 1]\n end\n\n test \"unfold/2 only calculates values if needed\" do\n stream = Stream.unfold(1, fn x -> if x > 0, do: {x, x - 1}, else: throw(:boom) end)\n assert Enum.take(stream, 1) == [1]\n\n stream = Stream.unfold(5, fn x -> if x > 0, do: {x, x - 1} end)\n assert Enum.to_list(Stream.take(stream, 2)) == [5, 4]\n end\n\n test \"unfold/2 is zippable\" do\n stream = Stream.unfold(10, fn x -> if x > 0, do: {x, x - 1} end)\n list = Enum.to_list(stream)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n end\n\n test \"uniq/1 & uniq/2\" do\n assert Stream.uniq([1, 2, 3, 2, 1]) |> Enum.to_list() == [1, 2, 3]\n end\n\n test \"uniq_by/2\" do\n assert Stream.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list() ==\n [{1, :x}, {2, :y}]\n\n assert Stream.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end)\n |> Enum.to_list() == [a: {:tea, 2}, c: {:coffee, 1}]\n end\n\n test \"zip/2\" do\n concat = Stream.concat(1..3, 4..6)\n cycle = Stream.cycle([:a, :b, :c])\n\n assert Stream.zip(concat, cycle) |> Enum.to_list() ==\n [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]\n end\n\n test \"zip_with/3\" do\n concat = Stream.concat(1..3, 4..6)\n cycle = Stream.cycle([:a, :b, :c])\n zip_fun = &List.to_tuple([&1, &2])\n\n assert Stream.zip_with(concat, cycle, zip_fun) |> Enum.to_list() ==\n [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]\n\n stream = Stream.concat(1..3, 4..6)\n other_stream = fn _, _ -> {:cont, [1, 2]} end\n result = Stream.zip_with(stream, other_stream, fn a, b -> a + b end) |> Enum.to_list()\n assert result == [2, 4]\n end\n\n test \"zip_with/2\" do\n concat = Stream.concat(1..3, 4..6)\n cycle = Stream.cycle([:a, :b, :c])\n zip_fun = &List.to_tuple/1\n\n assert Stream.zip_with([concat, cycle], zip_fun) |> Enum.to_list() ==\n [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]\n\n assert Stream.chunk_every([0, 1, 2, 3], 2) |> Stream.zip_with(zip_fun) |> Enum.to_list() ==\n [{0, 2}, {1, 3}]\n\n stream = %HaltAcc{acc: 1..3}\n assert Stream.zip_with([1..3, stream], zip_fun) |> Enum.to_list() == [{1, 1}, {2, 2}, {3, 3}]\n\n range_cycle = Stream.cycle(1..2)\n\n assert Stream.zip_with([1..3, range_cycle], zip_fun) |> Enum.to_list() == [\n {1, 1},\n {2, 2},\n {3, 1}\n ]\n end\n\n test \"zip_with/2 does not leave streams suspended\" do\n zip_with_fun = &List.to_tuple/1\n\n stream =\n Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_zip_with, true)\n end)\n\n Process.put(:stream_zip_with, false)\n\n assert Stream.zip_with([[:a, :b, :c], stream], zip_with_fun) |> Enum.to_list() == [\n a: 1,\n b: 2,\n c: 3\n ]\n\n assert Process.get(:stream_zip_with)\n\n Process.put(:stream_zip_with, false)\n\n assert Stream.zip_with([stream, [:a, :b, :c]], zip_with_fun) |> Enum.to_list() == [\n {1, :a},\n {2, :b},\n {3, :c}\n ]\n\n assert Process.get(:stream_zip_with)\n end\n\n test \"zip_with/2 does not leave streams suspended on halt\" do\n zip_with_fun = &List.to_tuple/1\n\n stream =\n Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_zip_with, :done)\n end)\n\n assert Stream.zip_with([[:a, :b, :c, :d, :e], stream], zip_with_fun) |> Enum.take(3) == [\n a: 1,\n b: 2,\n c: 3\n ]\n\n assert Process.get(:stream_zip_with) == :done\n end\n\n test \"zip_with/2 closes on inner error\" do\n zip_with_fun = &List.to_tuple/1\n stream = Stream.into([1, 2, 3], %Pdict{})\n\n stream =\n Stream.zip_with([stream, Stream.map([:a, :b, :c], fn _ -> throw(:error) end)], zip_with_fun)\n\n Process.put(:stream_done, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_done)\n end\n\n test \"zip_with/2 closes on outer error\" do\n zip_with_fun = &List.to_tuple/1\n\n stream =\n Stream.zip_with([Stream.into([1, 2, 3], %Pdict{}), [:a, :b, :c]], zip_with_fun)\n |> Stream.map(fn _ -> throw(:error) end)\n\n Process.put(:stream_done, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_done)\n end\n\n test \"zip/1\" do\n concat = Stream.concat(1..3, 4..6)\n cycle = Stream.cycle([:a, :b, :c])\n\n assert Stream.zip([concat, cycle]) |> Enum.to_list() ==\n [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]\n\n assert Stream.chunk_every([0, 1, 2, 3], 2) |> Stream.zip() |> Enum.to_list() ==\n [{0, 2}, {1, 3}]\n\n assert Stream.zip([]) |> Enum.to_list() == []\n\n stream = %HaltAcc{acc: 1..3}\n assert Stream.zip([1..3, stream]) |> Enum.to_list() == [{1, 1}, {2, 2}, {3, 3}]\n\n range_cycle = Stream.cycle(1..2)\n assert Stream.zip([1..3, range_cycle]) |> Enum.to_list() == [{1, 1}, {2, 2}, {3, 1}]\n end\n\n test \"zip/1 does not leave streams suspended\" do\n stream =\n Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_zip, true)\n end)\n\n Process.put(:stream_zip, false)\n assert Stream.zip([[:a, :b, :c], stream]) |> Enum.to_list() == [a: 1, b: 2, c: 3]\n assert Process.get(:stream_zip)\n\n Process.put(:stream_zip, false)\n assert Stream.zip([stream, [:a, :b, :c]]) |> Enum.to_list() == [{1, :a}, {2, :b}, {3, :c}]\n assert Process.get(:stream_zip)\n end\n\n test \"zip/1 does not leave streams suspended on halt\" do\n stream =\n Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->\n Process.put(:stream_zip, :done)\n end)\n\n assert Stream.zip([[:a, :b, :c, :d, :e], stream]) |> Enum.take(3) == [a: 1, b: 2, c: 3]\n\n assert Process.get(:stream_zip) == :done\n end\n\n test \"zip/1 closes on inner error\" do\n stream = Stream.into([1, 2, 3], %Pdict{})\n stream = Stream.zip([stream, Stream.map([:a, :b, :c], fn _ -> throw(:error) end)])\n\n Process.put(:stream_done, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_done)\n end\n\n test \"zip/1 closes on outer error\" do\n stream =\n Stream.zip([Stream.into([1, 2, 3], %Pdict{}), [:a, :b, :c]])\n |> Stream.map(fn _ -> throw(:error) end)\n\n Process.put(:stream_done, false)\n assert catch_throw(Enum.to_list(stream)) == :error\n assert Process.get(:stream_done)\n end\n\n test \"with_index/2\" do\n stream = Stream.with_index([1, 2, 3])\n assert lazy?(stream)\n assert Enum.to_list(stream) == [{1, 0}, {2, 1}, {3, 2}]\n\n stream = Stream.with_index([1, 2, 3], 10)\n assert Enum.to_list(stream) == [{1, 10}, {2, 11}, {3, 12}]\n\n nats = Stream.iterate(1, &(&1 + 1))\n assert Stream.with_index(nats) |> Enum.take(3) == [{1, 0}, {2, 1}, {3, 2}]\n end\n\n test \"intersperse/2 is lazy\" do\n assert lazy?(Stream.intersperse([], 0))\n end\n\n test \"intersperse/2 on an empty list\" do\n assert Enum.to_list(Stream.intersperse([], 0)) == []\n end\n\n test \"intersperse/2 on a single element list\" do\n assert Enum.to_list(Stream.intersperse([1], 0)) == [1]\n end\n\n test \"intersperse/2 on a multiple elements list\" do\n assert Enum.to_list(Stream.intersperse(1..3, 0)) == [1, 0, 2, 0, 3]\n end\n\n test \"intersperse/2 is zippable\" do\n stream = Stream.intersperse(1..10, 0)\n list = Enum.to_list(stream)\n assert Enum.zip(list, list) == Enum.zip(stream, stream)\n end\n\n test \"inspect/1\" do\n \"#Stream<[enum: 1..10, funs: \" <> _ = Stream.map(1..10, & &1) |> inspect()\n end\n\n defp lazy?(stream) do\n match?(%Stream{}, stream) or is_function(stream, 2)\n end\n\n defp inbox_stream({:suspend, acc}, f) do\n {:suspended, acc, &inbox_stream(&1, f)}\n end\n\n defp inbox_stream({:halt, acc}, _f) do\n {:halted, acc}\n end\n\n defp inbox_stream({:cont, acc}, f) do\n receive do\n {:stream, element} ->\n inbox_stream(f.(element, acc), f)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/string/chars_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule String.Chars.AtomTest do\n use ExUnit.Case, async: true\n\n doctest String.Chars\n\n test \"basic\" do\n assert to_string(:foo) == \"foo\"\n end\n\n test \"empty\" do\n assert to_string(:\"\") == \"\"\n end\n\n test \"true false nil\" do\n assert to_string(false) == \"false\"\n assert to_string(true) == \"true\"\n assert to_string(nil) == \"\"\n end\n\n test \"with uppercase\" do\n assert to_string(:fOO) == \"fOO\"\n assert to_string(:FOO) == \"FOO\"\n end\n\n test \"alias atom\" do\n assert to_string(Foo.Bar) == \"Elixir.Foo.Bar\"\n end\nend\n\ndefmodule String.Chars.BitStringTest do\n use ExUnit.Case, async: true\n\n test \"binary\" do\n assert to_string(\"foo\") == \"foo\"\n assert to_string(<>) == \"abc\"\n assert to_string(\"我今天要学习.\") == \"我今天要学习.\"\n end\nend\n\ndefmodule String.Chars.NumberTest do\n use ExUnit.Case, async: true\n\n test \"integer\" do\n assert to_string(100) == \"100\"\n end\n\n test \"float\" do\n assert to_string(1.0) == \"1.0\"\n assert to_string(1.0e10) == \"1.0e10\"\n end\nend\n\ndefmodule String.Chars.ListTest do\n use ExUnit.Case, async: true\n\n test \"basic\" do\n assert to_string([1, \"b\", 3]) == <<1, 98, 3>>\n end\n\n test \"printable\" do\n assert to_string(~c\"abc\") == \"abc\"\n end\n\n test \"charlist\" do\n assert to_string([0, 1, 2, 3, 255]) == <<0, 1, 2, 3, 195, 191>>\n\n assert to_string([0, [1, \"hello\"], 2, [[\"bye\"]]]) ==\n <<0, 1, 104, 101, 108, 108, 111, 2, 98, 121, 101>>\n end\n\n test \"empty\" do\n assert to_string([]) == \"\"\n end\nend\n\ndefmodule String.Chars.Version.RequirementTest do\n use ExUnit.Case, async: true\n\n test \"version requirement\" do\n {:ok, requirement} = Version.parse_requirement(\"== 2.0.1\")\n assert String.Chars.to_string(requirement) == \"== 2.0.1\"\n end\nend\n\ndefmodule String.Chars.URITest do\n use ExUnit.Case, async: true\n\n test \"uri\" do\n uri = URI.parse(\"http://google.com\")\n assert String.Chars.to_string(uri) == \"http://google.com\"\n\n uri_no_host = URI.parse(\"/foo/bar\")\n assert String.Chars.to_string(uri_no_host) == \"/foo/bar\"\n end\nend\n\ndefmodule String.Chars.ErrorsTest do\n use ExUnit.Case, async: true\n\n defmodule Foo do\n defstruct foo: \"bar\"\n end\n\n test \"bitstring\" do\n message =\n \"\"\"\n protocol String.Chars not implemented for BitString, cannot convert a bitstring to a string\n\n Got value:\n\n <<0, 1::size(4)>>\n \"\"\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n to_string(<<1::size(12)-integer-signed>>)\n end\n end\n\n test \"tuple\" do\n message = \"\"\"\n protocol String.Chars not implemented for Tuple\n\n Got value:\n\n {1, 2, 3}\n \"\"\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n to_string({1, 2, 3})\n end\n end\n\n test \"PID\" do\n message =\n ~r\"^protocol String\\.Chars not implemented for PID\\n\\nGot value:\\n\\n #PID<.+?>$\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n to_string(self())\n end\n end\n\n test \"ref\" do\n message =\n ~r\"^protocol String\\.Chars not implemented for Reference\\n\\nGot value:\\n\\n #Reference<.+?>$\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n to_string(make_ref()) == \"\"\n end\n end\n\n test \"function\" do\n message =\n ~r\"^protocol String\\.Chars not implemented for Function\\n\\nGot value:\\n\\n #Function<.+?>$\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n to_string(fn -> nil end)\n end\n end\n\n test \"port\" do\n [port | _] = Port.list()\n\n message =\n ~r\"^protocol String\\.Chars not implemented for Port\\n\\nGot value:\\n\\n #Port<.+?>$\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n to_string(port)\n end\n end\n\n test \"user-defined struct\" do\n message =\n \"protocol String\\.Chars not implemented for String.Chars.ErrorsTest.Foo (a struct)\\n\\nGot value:\\n\\n %String.Chars.ErrorsTest.Foo{foo: \\\"bar\\\"}\\n\"\n\n assert_raise Protocol.UndefinedError, message, fn ->\n to_string(%Foo{})\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/string_io_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule StringIOTest do\n use ExUnit.Case, async: true\n\n doctest StringIO\n\n test \"open and close\" do\n {:ok, pid} = StringIO.open(\"\")\n assert StringIO.close(pid) == {:ok, {\"\", \"\"}}\n end\n\n test \"contents\" do\n {:ok, pid} = StringIO.open(\"abc\")\n IO.write(pid, \"edf\")\n assert StringIO.contents(pid) == {\"abc\", \"edf\"}\n end\n\n test \"flush\" do\n {:ok, pid} = StringIO.open(\"\")\n IO.write(pid, \"edf\")\n assert StringIO.flush(pid) == \"edf\"\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n ## IO module\n\n test \"IO.read :line with \\\\n\" do\n {:ok, pid} = StringIO.open(\"abc\\n\")\n assert IO.read(pid, :line) == \"abc\\n\"\n assert IO.read(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.read :line with \\\\rn\" do\n {:ok, pid} = StringIO.open(\"abc\\r\\n\")\n assert IO.read(pid, :line) == \"abc\\n\"\n assert IO.read(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.read :line without line break\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.read(pid, :line) == \"abc\"\n assert IO.read(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.read :line with UTF-8\" do\n {:ok, pid} = StringIO.open(\"⼊\\n\")\n assert IO.read(pid, :line) == \"⼊\\n\"\n assert IO.read(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.read :line with invalid UTF-8\" do\n {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)\n assert IO.read(pid, :line) == {:error, :collect_line}\n assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, \"\"}\n end\n\n test \"IO.read count\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.read(pid, 2) == \"ab\"\n assert IO.read(pid, 8) == \"c\"\n assert IO.read(pid, 1) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.read count with UTF-8\" do\n {:ok, pid} = StringIO.open(\"あいう\")\n assert IO.read(pid, 2) == \"あい\"\n assert IO.read(pid, 8) == \"う\"\n assert IO.read(pid, 1) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.read count with invalid UTF-8\" do\n {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)\n assert IO.read(pid, 2) == {:error, :invalid_unicode}\n assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, \"\"}\n end\n\n test \"IO.binread :line with \\\\n\" do\n {:ok, pid} = StringIO.open(\"abc\\n\")\n assert IO.binread(pid, :line) == \"abc\\n\"\n assert IO.binread(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.binread :line with \\\\r\\\\n\" do\n {:ok, pid} = StringIO.open(\"abc\\r\\n\")\n assert IO.binread(pid, :line) == \"abc\\n\"\n assert IO.binread(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.binread :line without line break\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.binread(pid, :line) == \"abc\"\n assert IO.binread(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.binread :line with raw bytes\" do\n {:ok, pid} = StringIO.open(<<181, 255, 194, ?\\n>>)\n assert IO.binread(pid, :line) == <<181, 255, 194, ?\\n>>\n assert IO.binread(pid, :line) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.binread count\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.binread(pid, 2) == \"ab\"\n assert IO.binread(pid, 8) == \"c\"\n assert IO.binread(pid, 1) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.binread count with UTF-8\" do\n {:ok, pid} = StringIO.open(\"あいう\")\n assert IO.binread(pid, 2) == <<227, 129>>\n assert IO.binread(pid, 8) == <<130, 227, 129, 132, 227, 129, 134>>\n assert IO.binread(pid, 1) == :eof\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.write\" do\n {:ok, pid} = StringIO.open(\"\")\n assert IO.write(pid, \"foo\") == :ok\n assert StringIO.contents(pid) == {\"\", \"foo\"}\n end\n\n test \"IO.write with UTF-8\" do\n {:ok, pid} = StringIO.open(\"\")\n assert IO.write(pid, \"あいう\") == :ok\n assert StringIO.contents(pid) == {\"\", \"あいう\"}\n end\n\n test \"IO.write with non-printable arguments\" do\n {:ok, pid} = StringIO.open(\"\")\n\n assert_raise ArgumentError, fn ->\n IO.write(pid, [<<1::1>>])\n end\n\n assert_raise ErlangError, ~r/no_translation/, fn ->\n IO.write(pid, <<222>>)\n end\n end\n\n test \"IO.binwrite\" do\n {:ok, pid} = StringIO.open(\"\")\n assert IO.binwrite(pid, \"foo\") == :ok\n assert StringIO.contents(pid) == {\"\", \"foo\"}\n end\n\n test \"IO.binwrite with UTF-8\" do\n {:ok, pid} = StringIO.open(\"\")\n assert IO.binwrite(pid, \"あいう\") == :ok\n\n binary =\n <<195, 163, 194, 129, 194, 130, 195, 163>> <>\n <<194, 129, 194, 132, 195, 163, 194, 129, 194, 134>>\n\n assert StringIO.contents(pid) == {\"\", binary}\n end\n\n test \"IO.binwrite with bytes\" do\n {:ok, pid} = StringIO.open(\"\")\n assert IO.binwrite(pid, <<127, 128>>) == :ok\n assert StringIO.contents(pid) == {\"\", <<127, 194, 128>>}\n end\n\n test \"IO.binwrite with bytes and latin1 encoding\" do\n {:ok, pid} = StringIO.open(\"\", encoding: :latin1)\n assert IO.binwrite(pid, <<127, 128>>) == :ok\n assert StringIO.contents(pid) == {\"\", <<127, 128>>}\n end\n\n test \"IO.puts\" do\n {:ok, pid} = StringIO.open(\"\")\n assert IO.puts(pid, \"abc\") == :ok\n assert StringIO.contents(pid) == {\"\", \"abc\\n\"}\n end\n\n test \"IO.puts with non-printable arguments\" do\n {:ok, pid} = StringIO.open(\"\")\n\n assert_raise ArgumentError, fn ->\n IO.puts(pid, [<<1::1>>])\n end\n end\n\n test \"IO.inspect\" do\n {:ok, pid} = StringIO.open(\"\")\n assert IO.inspect(pid, {}, []) == {}\n assert StringIO.contents(pid) == {\"\", \"{}\\n\"}\n end\n\n test \"IO.getn\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.getn(pid, \">\", 2) == \"ab\"\n assert StringIO.contents(pid) == {\"c\", \"\"}\n end\n\n test \"IO.getn with UTF-8\" do\n {:ok, pid} = StringIO.open(\"あいう\")\n assert IO.getn(pid, \">\", 2) == \"あい\"\n assert StringIO.contents(pid) == {\"う\", \"\"}\n end\n\n test \"IO.getn with invalid UTF-8\" do\n {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)\n assert IO.getn(pid, \">\", 2) == {:error, :invalid_unicode}\n assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, \"\"}\n end\n\n test \"IO.getn with capture_prompt\" do\n {:ok, pid} = StringIO.open(\"abc\", capture_prompt: true)\n assert IO.getn(pid, \">\", 2) == \"ab\"\n assert StringIO.contents(pid) == {\"c\", \">\"}\n end\n\n test \"IO.gets with \\\\n\" do\n {:ok, pid} = StringIO.open(\"abc\\nd\")\n assert IO.gets(pid, \">\") == \"abc\\n\"\n assert StringIO.contents(pid) == {\"d\", \"\"}\n end\n\n test \"IO.gets with \\\\r\\\\n\" do\n {:ok, pid} = StringIO.open(\"abc\\r\\nd\")\n assert IO.gets(pid, \">\") == \"abc\\n\"\n assert StringIO.contents(pid) == {\"d\", \"\"}\n end\n\n test \"IO.gets without line breaks\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.gets(pid, \">\") == \"abc\"\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.gets with invalid UTF-8\" do\n {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)\n assert IO.gets(pid, \">\") == {:error, :collect_line}\n assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, \"\"}\n end\n\n test \"IO.gets with capture_prompt\" do\n {:ok, pid} = StringIO.open(\"abc\\n\", capture_prompt: true)\n assert IO.gets(pid, \">\") == \"abc\\n\"\n assert StringIO.contents(pid) == {\"\", \">\"}\n end\n\n test \":io.get_password\" do\n {:ok, pid} = StringIO.open(\"abc\\n\")\n assert :io.get_password(pid) == \"abc\\n\"\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.stream\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.stream(pid, 2) |> Enum.to_list() == [\"ab\", \"c\"]\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \"IO.stream with invalid UTF-8\" do\n {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)\n\n assert_raise IO.StreamError, \"error during streaming: :invalid_unicode\", fn ->\n IO.stream(pid, 2) |> Enum.to_list()\n end\n\n assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, \"\"}\n end\n\n test \"IO.binstream\" do\n {:ok, pid} = StringIO.open(\"abc\")\n assert IO.stream(pid, 2) |> Enum.to_list() == [\"ab\", \"c\"]\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n defp get_until(pid, encoding, prompt, module, function) do\n :io.request(pid, {:get_until, encoding, prompt, module, function, []})\n end\n\n defmodule GetUntilCallbacks do\n def until_eof(continuation, :eof) do\n {:done, continuation, :eof}\n end\n\n def until_eof(continuation, content) do\n {:more, continuation ++ content}\n end\n\n def until_eof_then_try_more(~c\"magic-stop-prefix\" ++ continuation, :eof) do\n {:done, continuation, :eof}\n end\n\n def until_eof_then_try_more(continuation, :eof) do\n {:more, ~c\"magic-stop-prefix\" ++ continuation}\n end\n\n def until_eof_then_try_more(continuation, content) do\n {:more, continuation ++ content}\n end\n\n def up_to_3_bytes(continuation, :eof) do\n {:done, continuation, :eof}\n end\n\n def up_to_3_bytes(continuation, content) do\n case continuation ++ content do\n [a, b, c | tail] -> {:done, [a, b, c], tail}\n str -> {:more, str}\n end\n end\n\n def up_to_3_bytes_discard_rest(continuation, :eof) do\n {:done, continuation, :eof}\n end\n\n def up_to_3_bytes_discard_rest(continuation, content) do\n case continuation ++ content do\n [a, b, c | _tail] -> {:done, [a, b, c], :eof}\n str -> {:more, str}\n end\n end\n end\n\n test \"get_until with up_to_3_bytes\" do\n {:ok, pid} = StringIO.open(\"abcdefg\")\n result = get_until(pid, :unicode, \"\", GetUntilCallbacks, :up_to_3_bytes)\n assert result == \"abc\"\n assert IO.read(pid, :eof) == \"defg\"\n end\n\n test \"get_until with up_to_3_bytes_discard_rest\" do\n {:ok, pid} = StringIO.open(\"abcdefg\")\n result = get_until(pid, :unicode, \"\", GetUntilCallbacks, :up_to_3_bytes_discard_rest)\n assert result == \"abc\"\n assert IO.read(pid, :eof) == :eof\n end\n\n test \"get_until with until_eof\" do\n {:ok, pid} = StringIO.open(\"abc\\nd\")\n result = get_until(pid, :unicode, \"\", GetUntilCallbacks, :until_eof)\n assert result == \"abc\\nd\"\n end\n\n test \"get_until with until_eof and \\\\r\\\\n\" do\n {:ok, pid} = StringIO.open(\"abc\\r\\nd\")\n result = get_until(pid, :unicode, \"\", GetUntilCallbacks, :until_eof)\n assert result == \"abc\\r\\nd\"\n end\n\n test \"get_until with until_eof capturing prompt\" do\n {:ok, pid} = StringIO.open(\"abc\\nd\", capture_prompt: true)\n result = get_until(pid, :unicode, \">\", GetUntilCallbacks, :until_eof)\n assert result == \"abc\\nd\"\n assert StringIO.contents(pid) == {\"\", \">>>\"}\n end\n\n test \"get_until with until_eof_then_try_more\" do\n {:ok, pid} = StringIO.open(\"abc\\nd\")\n result = get_until(pid, :unicode, \"\", GetUntilCallbacks, :until_eof_then_try_more)\n assert result == \"abc\\nd\"\n end\n\n test \"get_until with invalid UTF-8\" do\n {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)\n result = get_until(pid, :unicode, \"\", GetUntilCallbacks, :until_eof)\n assert result == :error\n end\n\n test \"get_until with raw bytes (latin1)\" do\n {:ok, pid} = StringIO.open(<<181, 255, 194, ?\\n>>)\n result = get_until(pid, :latin1, \"\", GetUntilCallbacks, :until_eof)\n assert result == <<181, 255, 194, ?\\n>>\n end\n\n test \":io.erl_scan_form/2\" do\n {:ok, pid} = StringIO.open(\"1.\")\n result = :io.scan_erl_form(pid, ~c\"p>\")\n assert result == {:ok, [{:integer, 1, 1}, {:dot, 1}], 1}\n assert StringIO.contents(pid) == {\"\", \"\"}\n end\n\n test \":io.erl_scan_form/2 with capture_prompt\" do\n {:ok, pid} = StringIO.open(\"1.\", capture_prompt: true)\n result = :io.scan_erl_form(pid, ~c\"p>\")\n assert result == {:ok, [{:integer, 1, 1}, {:dot, 1}], 1}\n assert StringIO.contents(pid) == {\"\", \"p>p>\"}\n end\n\n test \"returns enotsup for files\" do\n {:ok, pid} = StringIO.open(\"123\")\n assert :file.position(pid, :cur) == {:error, :enotsup}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/string_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule StringTest do\n use ExUnit.Case, async: true\n\n doctest String\n\n test \"next_codepoint/1\" do\n assert String.next_codepoint(\"ésoj\") == {\"é\", \"soj\"}\n assert String.next_codepoint(<<255>>) == {<<255>>, \"\"}\n assert String.next_codepoint(\"\") == nil\n end\n\n # test cases described in https://mortoray.com/2013/11/27/the-string-type-is-broken/\n test \"Unicode\" do\n assert String.reverse(\"noël\") == \"lëon\"\n assert String.slice(\"noël\", 0..2) == \"noë\"\n assert String.length(\"noël\") == 4\n\n assert String.length(\"\") == 2\n assert String.slice(\"\", 1..1) == \"\"\n assert String.reverse(\"\") == \"\"\n\n assert String.upcase(\"baffle\") == \"BAFFLE\"\n\n assert String.equivalent?(\"noël\", \"noël\")\n end\n\n test \"split/1,2,3\" do\n assert String.split(\"\") == []\n assert String.split(\"foo bar\") == [\"foo\", \"bar\"]\n assert String.split(\" foo bar\") == [\"foo\", \"bar\"]\n assert String.split(\"foo bar \") == [\"foo\", \"bar\"]\n assert String.split(\" foo bar \") == [\"foo\", \"bar\"]\n assert String.split(\"foo\\t\\n\\v\\f\\r\\sbar\\n\") == [\"foo\", \"bar\"]\n assert String.split(\"foo\" <> <<194, 133>> <> \"bar\") == [\"foo\", \"bar\"]\n # information separators are not considered whitespace\n assert String.split(\"foo\\u001Fbar\") == [\"foo\\u001Fbar\"]\n # no-break space is excluded\n assert String.split(\"foo\\00A0bar\") == [\"foo\\00A0bar\"]\n assert String.split(\"foo\\u202Fbar\") == [\"foo\\u202Fbar\"]\n\n assert String.split(\"a,b,c\", \",\") == [\"a\", \"b\", \"c\"]\n assert String.split(\"a,b\", \".\") == [\"a,b\"]\n assert String.split(\"1,2 3,4\", [\" \", \",\"]) == [\"1\", \"2\", \"3\", \"4\"]\n\n assert String.split(\"\", \",\") == [\"\"]\n assert String.split(\" a b c \", \" \") == [\"\", \"a\", \"b\", \"c\", \"\"]\n assert String.split(\" a b c \", \" \", parts: :infinity) == [\"\", \"a\", \"b\", \"c\", \"\"]\n assert String.split(\" a b c \", \" \", parts: 1) == [\" a b c \"]\n assert String.split(\" a b c \", \" \", parts: 2) == [\"\", \"a b c \"]\n\n assert String.split(\"\", \",\", trim: true) == []\n assert String.split(\" a b c \", \" \", trim: true) == [\"a\", \"b\", \"c\"]\n assert String.split(\" a b c \", \" \", trim: true, parts: :infinity) == [\"a\", \"b\", \"c\"]\n assert String.split(\" a b c \", \" \", trim: true, parts: 1) == [\" a b c \"]\n assert String.split(\" a b c \", \" \", trim: true, parts: 2) == [\"a\", \"b c \"]\n\n assert String.split(\"abé\", \"\") == [\"\", \"a\", \"b\", \"é\", \"\"]\n assert String.split(\"abé\", \"\", parts: :infinity) == [\"\", \"a\", \"b\", \"é\", \"\"]\n assert String.split(\"abé\", \"\", parts: 1) == [\"abé\"]\n assert String.split(\"abé\", \"\", parts: 2) == [\"\", \"abé\"]\n assert String.split(\"abé\", \"\", parts: 3) == [\"\", \"a\", \"bé\"]\n assert String.split(\"abé\", \"\", parts: 4) == [\"\", \"a\", \"b\", \"é\"]\n assert String.split(\"abé\", \"\", parts: 5) == [\"\", \"a\", \"b\", \"é\", \"\"]\n assert String.split(\"abé\", \"\", parts: 10) == [\"\", \"a\", \"b\", \"é\", \"\"]\n assert String.split(\"abé\", \"\", trim: true) == [\"a\", \"b\", \"é\"]\n assert String.split(\"abé\", \"\", trim: true, parts: :infinity) == [\"a\", \"b\", \"é\"]\n assert String.split(\"abé\", \"\", trim: true, parts: 2) == [\"a\", \"bé\"]\n assert String.split(\"abé\", \"\", trim: true, parts: 3) == [\"a\", \"b\", \"é\"]\n assert String.split(\"abé\", \"\", trim: true, parts: 4) == [\"a\", \"b\", \"é\"]\n\n assert String.split(\"noël\", \"\") == [\"\", \"n\", \"o\", \"ë\", \"l\", \"\"]\n assert String.split(\"x-\", \"-\", parts: 2, trim: true) == [\"x\"]\n assert String.split(\"x-x-\", \"-\", parts: 3, trim: true) == [\"x\", \"x\"]\n\n assert String.split(\"hello\", []) == [\"hello\"]\n assert String.split(\"hello\", [], trim: true) == [\"hello\"]\n assert String.split(\"\", []) == [\"\"]\n assert String.split(\"\", [], trim: true) == []\n\n assert_raise ArgumentError, fn ->\n String.split(\"a,b,c\", [\"\"])\n end\n\n assert_raise ArgumentError, fn ->\n String.split(\"a,b,c\", [\"\"])\n end\n end\n\n test \"split/2,3 with regex\" do\n assert String.split(\"\", ~r{,}) == [\"\"]\n assert String.split(\"\", ~r{,}, trim: true) == []\n assert String.split(\"a,b\", ~r{,}) == [\"a\", \"b\"]\n assert String.split(\"a,b,c\", ~r{,}) == [\"a\", \"b\", \"c\"]\n assert String.split(\"a,b,c\", ~r{,}, parts: 2) == [\"a\", \"b,c\"]\n assert String.split(\"a,b.c \", ~r{\\W}) == [\"a\", \"b\", \"c\", \"\"]\n assert String.split(\"a,b.c \", ~r{\\W}, trim: false) == [\"a\", \"b\", \"c\", \"\"]\n assert String.split(\"a,b\", ~r{\\.}) == [\"a,b\"]\n end\n\n test \"split/2,3 with compiled pattern\" do\n pattern = :binary.compile_pattern(\"-\")\n\n assert String.split(\"x-\", pattern) == [\"x\", \"\"]\n assert String.split(\"x-\", pattern, parts: 2, trim: true) == [\"x\"]\n assert String.split(\"x-x-\", pattern, parts: 3, trim: true) == [\"x\", \"x\"]\n end\n\n test \"split/2,3 with malformed\" do\n assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, \"\", parts: 1) ==\n [<<225, 158, 128, 225, 158, 185, 225>>]\n\n assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, \"\", parts: 2) ==\n [\"\", <<225, 158, 128, 225, 158, 185, 225>>]\n\n assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, \"\", parts: 3) ==\n [\"\", \"កឹ\", <<225>>]\n\n assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, \"\", parts: 4) ==\n [\"\", \"កឹ\", <<225>>, \"\"]\n end\n\n test \"splitter/2,3\" do\n assert String.splitter(\"a,b,c\", \",\") |> Enum.to_list() == [\"a\", \"b\", \"c\"]\n assert String.splitter(\"a,b\", \".\") |> Enum.to_list() == [\"a,b\"]\n assert String.splitter(\"1,2 3,4\", [\" \", \",\"]) |> Enum.to_list() == [\"1\", \"2\", \"3\", \"4\"]\n assert String.splitter(\"\", \",\") |> Enum.to_list() == [\"\"]\n\n assert String.splitter(\"\", \",\", trim: true) |> Enum.to_list() == []\n assert String.splitter(\" a b c \", \" \", trim: true) |> Enum.to_list() == [\"a\", \"b\", \"c\"]\n assert String.splitter(\" a b c \", \" \", trim: true) |> Enum.take(1) == [\"a\"]\n assert String.splitter(\" a b c \", \" \", trim: true) |> Enum.take(2) == [\"a\", \"b\"]\n\n assert String.splitter(\"hello\", []) |> Enum.to_list() == [\"hello\"]\n assert String.splitter(\"hello\", [], trim: true) |> Enum.to_list() == [\"hello\"]\n assert String.splitter(\"\", []) |> Enum.to_list() == [\"\"]\n assert String.splitter(\"\", [], trim: true) |> Enum.to_list() == []\n\n assert String.splitter(\"1,2 3,4 5\", \"\") |> Enum.take(4) == [\"\", \"1\", \",\", \"2\"]\n\n assert_raise ArgumentError, fn ->\n String.splitter(\"a\", [\"\"])\n end\n end\n\n test \"split_at/2\" do\n assert String.split_at(\"\", 0) == {\"\", \"\"}\n assert String.split_at(\"\", -1) == {\"\", \"\"}\n assert String.split_at(\"\", 1) == {\"\", \"\"}\n\n assert String.split_at(\"abc\", 0) == {\"\", \"abc\"}\n assert String.split_at(\"abc\", 2) == {\"ab\", \"c\"}\n assert String.split_at(\"abc\", 3) == {\"abc\", \"\"}\n assert String.split_at(\"abc\", 4) == {\"abc\", \"\"}\n assert String.split_at(\"abc\", 1000) == {\"abc\", \"\"}\n\n assert String.split_at(\"abc\", -1) == {\"ab\", \"c\"}\n assert String.split_at(\"abc\", -3) == {\"\", \"abc\"}\n assert String.split_at(\"abc\", -4) == {\"\", \"abc\"}\n assert String.split_at(\"abc\", -1000) == {\"\", \"abc\"}\n end\n\n test \"split_at/2 with malformed\" do\n assert String.split_at(<>, 2) == {<>, <<10, ?a>>}\n assert String.split_at(<<107, 205, 135, 184>>, 1) == {<<107, 205, 135>>, <<184>>}\n\n assert String.split_at(<<225, 158, 128, 225, 158, 185, 225>>, 0) ==\n {\"\", <<225, 158, 128, 225, 158, 185, 225>>}\n\n assert String.split_at(<<225, 158, 128, 225, 158, 185, 225>>, 1) ==\n {\"កឹ\", <<225>>}\n\n assert String.split_at(<<225, 158, 128, 225, 158, 185, 225>>, 2) ==\n {<<225, 158, 128, 225, 158, 185, 225>>, \"\"}\n end\n\n test \"upcase/1\" do\n assert String.upcase(\"123 abcd 456 efg hij ( %$#) kl mnop @ qrst = -_ uvwxyz\") ==\n \"123 ABCD 456 EFG HIJ ( %$#) KL MNOP @ QRST = -_ UVWXYZ\"\n\n assert String.upcase(\"\") == \"\"\n assert String.upcase(\"abcD\") == \"ABCD\"\n end\n\n test \"upcase/1 with UTF-8\" do\n assert String.upcase(\"& % # àáâ ãäå 1 2 ç æ\") == \"& % # ÀÁ ÃÄÅ 1 2 Ç Æ\"\n assert String.upcase(\"àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ\") == \"ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ\"\n end\n\n test \"upcase/1 with UTF-8 multibyte\" do\n assert String.upcase(\"straße\") == \"STRASSE\"\n assert String.upcase(\"áüÈß\") == \"ÁÜÈSS\"\n end\n\n test \"upcase/1 with ascii\" do\n assert String.upcase(\"olá\", :ascii) == \"OLá\"\n end\n\n test \"upcase/1 with turkic\" do\n assert String.upcase(\"ıi\", :turkic) == \"Iİ\"\n assert String.upcase(\"Iİ\", :turkic) == \"Iİ\"\n end\n\n test \"downcase/1\" do\n assert String.downcase(\"123 ABcD 456 EfG HIJ ( %$#) KL MNOP @ QRST = -_ UVWXYZ\") ==\n \"123 abcd 456 efg hij ( %$#) kl mnop @ qrst = -_ uvwxyz\"\n\n assert String.downcase(\"abcD\") == \"abcd\"\n assert String.downcase(\"\") == \"\"\n end\n\n test \"downcase/1 with UTF-8\" do\n assert String.downcase(\"& % # ÀÁ ÃÄÅ 1 2 Ç Æ\") == \"& % # àáâ ãäå 1 2 ç æ\"\n assert String.downcase(\"ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ\") == \"àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ\"\n assert String.downcase(\"áüÈß\") == \"áüèß\"\n end\n\n test \"downcase/1 with greek final sigma\" do\n assert String.downcase(\"Σ\") == \"σ\"\n assert String.downcase(\"ΣΣ\") == \"σσ\"\n assert String.downcase(\"Σ ΣΣ\") == \"σ σσ\"\n assert String.downcase(\"ΜΕΣ'ΑΠΟ\") == \"μεσ'απο\"\n assert String.downcase(\"ΑΣ'ΤΟΥΣ\") == \"ασ'τουσ\"\n\n assert String.downcase(\"Σ\", :greek) == \"σ\"\n assert String.downcase(\"Σ ΣΣ\", :greek) == \"σ σς\"\n assert String.downcase(\"Σ ΣΑΣ Σ\", :greek) == \"σ σας σ\"\n assert String.downcase(\"ΜΕΣ'ΑΠΟ\", :greek) == \"μεσ'απο\"\n assert String.downcase(\"ΑΣ'ΤΟΥΣ\", :greek) == \"ασ'τους\"\n end\n\n test \"downcase/1 with ascii\" do\n assert String.downcase(\"OLÁ\", :ascii) == \"olÁ\"\n end\n\n test \"downcase/1 with turkic\" do\n assert String.downcase(\"Iİ\", :turkic) == \"ıi\"\n assert String.downcase(\"İ\", :turkic) == \"i\"\n\n assert String.downcase(\"ıi\", :turkic) == \"ıi\"\n assert String.downcase(\"i\", :turkic) == \"i\"\n\n assert String.downcase(\"İ\") == \"i̇\"\n end\n\n test \"capitalize/1\" do\n assert String.capitalize(\"\") == \"\"\n assert String.capitalize(\"1\") == \"1\"\n assert String.capitalize(\"abc\") == \"Abc\"\n assert String.capitalize(\"ABC\") == \"Abc\"\n assert String.capitalize(\"c b a\") == \"C b a\"\n assert String.capitalize(\"1ABC\") == \"1abc\"\n assert String.capitalize(\"_aBc1\") == \"_abc1\"\n assert String.capitalize(\" aBc1\") == \" abc1\"\n assert String.capitalize(\"àáâ\") == \"Àáâ\"\n assert String.capitalize(\"ÀÁÂ\") == \"Àáâ\"\n assert String.capitalize(\"âáà\") == \"Âáà\"\n assert String.capitalize(\"ÂÁÀ\") == \"Âáà\"\n assert String.capitalize(\"òóôõö\") == \"Òóôõö\"\n assert String.capitalize(\"ÒÓÔÕÖ\") == \"Òóôõö\"\n assert String.capitalize(\"fin\") == \"Fin\"\n\n assert String.capitalize(\"ABC\", :ascii) == \"Abc\"\n assert String.capitalize(\"àáâ\", :ascii) == \"àáâ\"\n assert String.capitalize(\"aáA\", :ascii) == \"Aáa\"\n\n assert String.capitalize(\"iii\", :turkic) == \"İii\"\n assert String.capitalize(\"ııı\", :turkic) == \"Iıı\"\n assert String.capitalize(\"İii\", :turkic) == \"İii\"\n assert String.capitalize(\"Iıı\", :turkic) == \"Iıı\"\n\n assert String.capitalize(<<138, ?B, ?C>>) == <<138, ?b, ?c>>\n\n assert String.capitalize(<<225, 158, 128, 225, 158, 185, 225>>) ==\n <<225, 158, 128, 225, 158, 185, 225>>\n end\n\n test \"replace_leading/3\" do\n assert String.replace_leading(\"aa abc \", \"a\", \"b\") == \"bb abc \"\n assert String.replace_leading(\"__ abc \", \"_\", \"b\") == \"bb abc \"\n assert String.replace_leading(\"aaaaaaaa \", \"a\", \"b\") == \"bbbbbbbb \"\n assert String.replace_leading(\"aaaaaaaa \", \"aaa\", \"b\") == \"bbaa \"\n assert String.replace_leading(\"aaaaaaaaa\", \"a\", \"b\") == \"bbbbbbbbb\"\n assert String.replace_leading(\"]]]]]]\", \"]\", \"[]\") == \"[][][][][][]\"\n assert String.replace_leading(\"]]]]]]]]\", \"]\", \"\") == \"\"\n assert String.replace_leading(\"]]]]]] ]\", \"]\", \"\") == \" ]\"\n assert String.replace_leading(\"猫猫 cat \", \"猫\", \"й\") == \"йй cat \"\n assert String.replace_leading(\"test\", \"t\", \"T\") == \"Test\"\n assert String.replace_leading(\"t\", \"t\", \"T\") == \"T\"\n assert String.replace_leading(\"aaa\", \"b\", \"c\") == \"aaa\"\n\n message = ~r/cannot use an empty string/\n\n assert_raise ArgumentError, message, fn ->\n String.replace_leading(\"foo\", \"\", \"bar\")\n end\n\n assert_raise ArgumentError, message, fn ->\n String.replace_leading(\"\", \"\", \"bar\")\n end\n end\n\n test \"replace_trailing/3\" do\n assert String.replace_trailing(\" abc aa\", \"a\", \"b\") == \" abc bb\"\n assert String.replace_trailing(\" abc __\", \"_\", \"b\") == \" abc bb\"\n assert String.replace_trailing(\" aaaaaaaa\", \"a\", \"b\") == \" bbbbbbbb\"\n assert String.replace_trailing(\" aaaaaaaa\", \"aaa\", \"b\") == \" aabb\"\n assert String.replace_trailing(\"aaaaaaaaa\", \"a\", \"b\") == \"bbbbbbbbb\"\n assert String.replace_trailing(\"]]]]]]\", \"]\", \"[]\") == \"[][][][][][]\"\n assert String.replace_trailing(\"]]]]]]]]\", \"]\", \"\") == \"\"\n assert String.replace_trailing(\"] ]]]]]]\", \"]\", \"\") == \"] \"\n assert String.replace_trailing(\" cat 猫猫\", \"猫\", \"й\") == \" cat йй\"\n assert String.replace_trailing(\"test\", \"t\", \"T\") == \"tesT\"\n assert String.replace_trailing(\"t\", \"t\", \"T\") == \"T\"\n assert String.replace_trailing(\"aaa\", \"b\", \"c\") == \"aaa\"\n\n message = ~r/cannot use an empty string/\n\n assert_raise ArgumentError, message, fn ->\n String.replace_trailing(\"foo\", \"\", \"bar\")\n end\n\n assert_raise ArgumentError, message, fn ->\n String.replace_trailing(\"\", \"\", \"bar\")\n end\n end\n\n test \"trim/1,2\" do\n assert String.trim(\"\") == \"\"\n assert String.trim(\" abc \") == \"abc\"\n assert String.trim(\"a abc a\\n\\n\") == \"a abc a\"\n assert String.trim(\"a abc a\\t\\n\\v\\f\\r\\s\") == \"a abc a\"\n\n assert String.trim(\"___ abc ___\", \"_\") == \" abc \"\n assert String.trim(\"猫猫猫cat猫猫猫\", \"猫猫\") == \"猫cat猫\"\n # no-break space\n assert String.trim(\"\\u00A0a abc a\\u00A0\") == \"a abc a\"\n # whitespace defined as a range\n assert String.trim(\"\\u2008a abc a\\u2005\") == \"a abc a\"\n end\n\n test \"trim_leading/1,2\" do\n assert String.trim_leading(\"\") == \"\"\n assert String.trim_leading(\" abc \") == \"abc \"\n assert String.trim_leading(\"a abc a\") == \"a abc a\"\n assert String.trim_leading(\"\\n\\na abc a\") == \"a abc a\"\n assert String.trim_leading(\"\\t\\n\\v\\f\\r\\sa abc a\") == \"a abc a\"\n assert String.trim_leading(<<194, 133, \"a abc a\">>) == \"a abc a\"\n # information separators are not whitespace\n assert String.trim_leading(\"\\u001F a abc a\") == \"\\u001F a abc a\"\n # no-break space\n assert String.trim_leading(\"\\u00A0 a abc a\") == \"a abc a\"\n\n assert String.trim_leading(\"aa aaa\", \"aaa\") == \"aa aaa\"\n assert String.trim_leading(\"aaa aaa\", \"aa\") == \"a aaa\"\n assert String.trim_leading(\"aa abc \", \"a\") == \" abc \"\n assert String.trim_leading(\"__ abc \", \"_\") == \" abc \"\n assert String.trim_leading(\"aaaaaaaaa \", \"a\") == \" \"\n assert String.trim_leading(\"aaaaaaaaaa\", \"a\") == \"\"\n assert String.trim_leading(\"]]]]]] ]\", \"]\") == \" ]\"\n assert String.trim_leading(\"猫猫 cat \", \"猫\") == \" cat \"\n assert String.trim_leading(\"test\", \"t\") == \"est\"\n assert String.trim_leading(\"t\", \"t\") == \"\"\n assert String.trim_leading(\"\", \"t\") == \"\"\n end\n\n test \"trim_trailing/1,2\" do\n assert String.trim_trailing(\"\") == \"\"\n assert String.trim_trailing(\"1\\n\") == \"1\"\n assert String.trim_trailing(\"\\r\\n\") == \"\"\n assert String.trim_trailing(\" abc \") == \" abc\"\n assert String.trim_trailing(\" abc a\") == \" abc a\"\n assert String.trim_trailing(\"a abc a\\n\\n\") == \"a abc a\"\n assert String.trim_trailing(\"a abc a\\t\\n\\v\\f\\r\\s\") == \"a abc a\"\n assert String.trim_trailing(<<\"a abc a\", 194, 133>>) == \"a abc a\"\n # information separators are not whitespace\n assert String.trim_trailing(\"a abc a \\u001F\") == \"a abc a \\u001F\"\n # no-break space\n assert String.trim_trailing(\"a abc a \\u00A0\") == \"a abc a\"\n\n assert String.trim_trailing(\"aaa aa\", \"aaa\") == \"aaa aa\"\n assert String.trim_trailing(\"aaa aaa\", \"aa\") == \"aaa a\"\n assert String.trim_trailing(\" abc aa\", \"a\") == \" abc \"\n assert String.trim_trailing(\" abc __\", \"_\") == \" abc \"\n assert String.trim_trailing(\" aaaaaaaaa\", \"a\") == \" \"\n assert String.trim_trailing(\"aaaaaaaaaa\", \"a\") == \"\"\n assert String.trim_trailing(\"] ]]]]]]\", \"]\") == \"] \"\n assert String.trim_trailing(\" cat 猫猫\", \"猫\") == \" cat \"\n assert String.trim_trailing(\"test\", \"t\") == \"tes\"\n assert String.trim_trailing(\"t\", \"t\") == \"\"\n assert String.trim_trailing(\"\", \"t\") == \"\"\n end\n\n test \"pad_leading/2,3\" do\n assert String.pad_leading(\"\", 5) == \" \"\n assert String.pad_leading(\"abc\", 5) == \" abc\"\n assert String.pad_leading(\" abc \", 9) == \" abc \"\n assert String.pad_leading(\"猫\", 5) == \" 猫\"\n assert String.pad_leading(\"-\", 0) == \"-\"\n assert String.pad_leading(\"-\", 1) == \"-\"\n\n assert String.pad_leading(\"---\", 5, \"abc\") == \"ab---\"\n assert String.pad_leading(\"---\", 9, \"abc\") == \"abcabc---\"\n\n assert String.pad_leading(\"---\", 5, [\"abc\"]) == \"abcabc---\"\n assert String.pad_leading(\"--\", 6, [\"a\", \"bc\"]) == \"abcabc--\"\n\n message = \"expected a string padding element, got: 10\"\n\n assert_raise ArgumentError, message, fn ->\n String.pad_leading(\"-\", 3, [\"-\", 10])\n end\n end\n\n test \"pad_trailing/2,3\" do\n assert String.pad_trailing(\"\", 5) == \" \"\n assert String.pad_trailing(\"abc\", 5) == \"abc \"\n assert String.pad_trailing(\" abc \", 9) == \" abc \"\n assert String.pad_trailing(\"猫\", 5) == \"猫 \"\n assert String.pad_trailing(\"-\", 0) == \"-\"\n assert String.pad_trailing(\"-\", 1) == \"-\"\n\n assert String.pad_trailing(\"---\", 5, \"abc\") == \"---ab\"\n assert String.pad_trailing(\"---\", 9, \"abc\") == \"---abcabc\"\n\n assert String.pad_trailing(\"---\", 5, [\"abc\"]) == \"---abcabc\"\n assert String.pad_trailing(\"--\", 6, [\"a\", \"bc\"]) == \"--abcabc\"\n\n message = \"expected a string padding element, got: 10\"\n\n assert_raise ArgumentError, message, fn ->\n String.pad_trailing(\"-\", 3, [\"-\", 10])\n end\n end\n\n test \"reverse/1\" do\n assert String.reverse(\"\") == \"\"\n assert String.reverse(\"abc\") == \"cba\"\n assert String.reverse(\"Hello World\") == \"dlroW olleH\"\n assert String.reverse(\"Hello ∂og\") == \"go∂ olleH\"\n assert String.reverse(\"Ā̀stute\") == \"etutsĀ̀\"\n assert String.reverse(String.reverse(\"Hello World\")) == \"Hello World\"\n assert String.reverse(String.reverse(\"Hello \\r\\n World\")) == \"Hello \\r\\n World\"\n end\n\n describe \"replace/3\" do\n test \"with empty string and string replacement\" do\n assert String.replace(\"elixir\", \"\", \"\") == \"elixir\"\n assert String.replace(\"ELIXIR\", \"\", \".\") == \".E.L.I.X.I.R.\"\n assert String.replace(\"ELIXIR\", \"\", \".\", global: true) == \".E.L.I.X.I.R.\"\n assert String.replace(\"ELIXIR\", \"\", \".\", global: false) == \".ELIXIR\"\n\n assert_raise ArgumentError, fn ->\n String.replace(\"elixir\", [\"\"], \"\")\n end\n end\n\n test \"with empty string and string replacement with malformed\" do\n assert String.replace(<<225, 158, 128, 225, 158, 185, 225>>, \"\", \".\") == \".កឹ.\\xE1.\"\n end\n\n test \"with empty pattern list\" do\n assert String.replace(\"elixir\", [], \"anything\") == \"elixir\"\n end\n\n test \"with match pattern and string replacement\" do\n assert String.replace(\"a,b,c\", \",\", \"-\") == \"a-b-c\"\n assert String.replace(\"a,b,c\", [\",\", \"b\"], \"-\") == \"a---c\"\n\n assert String.replace(\"a,b,c\", \",\", \"-\", global: false) == \"a-b,c\"\n assert String.replace(\"a,b,c\", [\",\", \"b\"], \"-\", global: false) == \"a-b,c\"\n assert String.replace(\"ãéã\", \"é\", \"e\", global: false) == \"ãeã\"\n end\n\n test \"with regex and string replacement\" do\n assert String.replace(\"a,b,c\", ~r/,(.)/, \",\\\\1\\\\1\") == \"a,bb,cc\"\n assert String.replace(\"a,b,c\", ~r/,(.)/, \",\\\\1\\\\1\", global: false) == \"a,bb,c\"\n end\n\n test \"with empty string and function replacement\" do\n assert String.replace(\"elixir\", \"\", fn \"\" -> \"\" end) == \"elixir\"\n assert String.replace(\"ELIXIR\", \"\", fn \"\" -> \".\" end) == \".E.L.I.X.I.R.\"\n assert String.replace(\"ELIXIR\", \"\", fn \"\" -> \".\" end, global: true) == \".E.L.I.X.I.R.\"\n assert String.replace(\"ELIXIR\", \"\", fn \"\" -> \".\" end, global: false) == \".ELIXIR\"\n\n assert String.replace(\"elixir\", \"\", fn \"\" -> [\"\"] end) == \"elixir\"\n assert String.replace(\"ELIXIR\", \"\", fn \"\" -> [\".\"] end) == \".E.L.I.X.I.R.\"\n assert String.replace(\"ELIXIR\", \"\", fn \"\" -> [\".\"] end, global: true) == \".E.L.I.X.I.R.\"\n assert String.replace(\"ELIXIR\", \"\", fn \"\" -> [\".\"] end, global: false) == \".ELIXIR\"\n end\n\n test \"with match pattern and function replacement\" do\n assert String.replace(\"a,b,c\", \",\", fn \",\" -> \"-\" end) == \"a-b-c\"\n assert String.replace(\"a,b,c\", [\",\", \"b\"], fn x -> \"[#{x}]\" end) == \"a[,][b][,]c\"\n assert String.replace(\"a,b,c\", [\",\", \"b\"], fn x -> [?[, x, ?]] end) == \"a[,][b][,]c\"\n\n assert String.replace(\"a,b,c\", \",\", fn \",\" -> \"-\" end, global: false) == \"a-b,c\"\n assert String.replace(\"a,b,c\", [\",\", \"b\"], fn x -> \"[#{x}]\" end, global: false) == \"a[,]b,c\"\n assert String.replace(\"ãéã\", \"é\", fn \"é\" -> \"e\" end, global: false) == \"ãeã\"\n end\n\n test \"with regex and function replacement\" do\n assert String.replace(\"a,b,c\", ~r/,(.)/, fn x -> \"#{x}#{x}\" end) == \"a,b,b,c,c\"\n assert String.replace(\"a,b,c\", ~r/,(.)/, fn x -> [x, x] end) == \"a,b,b,c,c\"\n assert String.replace(\"a,b,c\", ~r/,(.)/, fn x -> \"#{x}#{x}\" end, global: false) == \"a,b,b,c\"\n assert String.replace(\"a,b,c\", ~r/,(.)/, fn x -> [x, x] end, global: false) == \"a,b,b,c\"\n end\n end\n\n test \"duplicate/2\" do\n assert String.duplicate(\"abc\", 0) == \"\"\n assert String.duplicate(\"abc\", 1) == \"abc\"\n assert String.duplicate(\"abc\", 2) == \"abcabc\"\n assert String.duplicate(\"&ã$\", 2) == \"&ã$&ã$\"\n\n assert_raise ArgumentError, fn ->\n String.duplicate(\"abc\", -1)\n end\n end\n\n test \"codepoints/1\" do\n assert String.codepoints(\"elixir\") == [\"e\", \"l\", \"i\", \"x\", \"i\", \"r\"]\n # slovak\n assert String.codepoints(\"elixír\") == [\"e\", \"l\", \"i\", \"x\", \"í\", \"r\"]\n # armenian\n assert String.codepoints(\"ոգելից ըմպելիք\") ==\n [\"ո\", \"գ\", \"ե\", \"լ\", \"ի\", \"ց\", \" \", \"ը\", \"մ\", \"պ\", \"ե\", \"լ\", \"ի\", \"ք\"]\n\n # belarussian\n assert String.codepoints(\"эліксір\") == [\"э\", \"л\", \"і\", \"к\", \"с\", \"і\", \"р\"]\n # greek\n assert String.codepoints(\"ελιξήριο\") == [\"ε\", \"λ\", \"ι\", \"ξ\", \"ή\", \"ρ\", \"ι\", \"ο\"]\n # hebraic\n assert String.codepoints(\"סם חיים\") == [\"ס\", \"ם\", \" \", \"ח\", \"י\", \"י\", \"ם\"]\n # hindi\n assert String.codepoints(\"अमृत\") == [\"अ\", \"म\", \"ृ\", \"त\"]\n # bengali\n assert String.codepoints(\"স্পর্শমণি\") == [\"স\", \"্\", \"প\", \"র\", \"্\", \"শ\", \"ম\", \"ণ\", \"ি\"]\n # gujarati\n assert String.codepoints(\"સર્વશ્રેષ્ઠ ઇલાજ\") ==\n [\"સ\", \"ર\", \"્\", \"વ\", \"શ\", \"્\", \"ર\", \"ે\", \"ષ\", \"્\", \"ઠ\", \" \", \"ઇ\", \"લ\", \"ા\", \"જ\"]\n\n # japanese\n assert String.codepoints(\"世界中の一番\") == [\"世\", \"界\", \"中\", \"の\", \"一\", \"番\"]\n assert String.codepoints(\"がガちゃ\") == [\"が\", \"ガ\", \"ち\", \"ゃ\"]\n assert String.codepoints(\"\") == []\n\n assert String.codepoints(\"ϖͲϥЫݎߟΈټϘለДШव׆ש؇؊صلټܗݎޥޘ߉ऌ૫ሏᶆ℆ℙℱ ⅚Ⅷ↠∈⌘①ffi\") ==\n [\"ϖ\", \"Ͳ\", \"ϥ\", \"Ы\", \"ݎ\", \"ߟ\", \"Έ\"] ++\n [\"ټ\", \"Ϙ\", \"ለ\", \"Д\", \"Ш\", \"व\"] ++\n [\"׆\", \"ש\", \"؇\", \"؊\", \"ص\", \"ل\", \"ټ\"] ++\n [\"ܗ\", \"ݎ\", \"ޥ\", \"ޘ\", \"߉\", \"ऌ\", \"૫\"] ++\n [\"ሏ\", \"ᶆ\", \"℆\", \"ℙ\", \"ℱ\", \" \", \"⅚\"] ++ [\"Ⅷ\", \"↠\", \"∈\", \"⌘\", \"①\", \"ffi\"]\n end\n\n test \"equivalent?/2\" do\n assert String.equivalent?(\"\", \"\")\n assert String.equivalent?(\"elixir\", \"elixir\")\n assert String.equivalent?(\"뢴\", \"뢴\")\n assert String.equivalent?(\"ṩ\", \"ṩ\")\n refute String.equivalent?(\"ELIXIR\", \"elixir\")\n refute String.equivalent?(\"døge\", \"dóge\")\n end\n\n test \"graphemes/1\" do\n # Extended\n assert String.graphemes(\"Ā̀stute\") == [\"Ā̀\", \"s\", \"t\", \"u\", \"t\", \"e\"]\n # CLRF\n assert String.graphemes(\"\\r\\n\\f\") == [\"\\r\\n\", \"\\f\"]\n # Regional indicator\n assert String.graphemes(\"\\u{1F1E6}\\u{1F1E7}\") == [\"\\u{1F1E6}\\u{1F1E7}\"]\n assert String.graphemes(\"\\u{1F1E6}\\u{1F1E7}\\u{1F1E8}\") == [\"\\u{1F1E6}\\u{1F1E7}\", \"\\u{1F1E8}\"]\n # Hangul\n assert String.graphemes(\"\\u1100\\u115D\\uB4A4\") == [\"ᄀᅝ뒤\"]\n # Special Marking with Extended\n assert String.graphemes(\"a\\u0300\\u0903\") == [\"a\\u0300\\u0903\"]\n end\n\n test \"next_grapheme/1\" do\n assert String.next_grapheme(\"Ā̀stute\") == {\"Ā̀\", \"stute\"}\n assert String.next_grapheme(<<225, 158, 128, 225, 158, 185, 225>>) == {\"កឹ\", <<225>>}\n assert String.next_grapheme(\"\") == nil\n end\n\n describe \"randomized\" do\n test \"next_grapheme\" do\n for _ <- 1..10 do\n bin = :crypto.strong_rand_bytes(20)\n\n try do\n bin |> Stream.unfold(&String.next_grapheme/1) |> Enum.to_list()\n rescue\n # Ignore malformed pictographic sequences\n _ -> :ok\n else\n list ->\n assert Enum.all?(list, &is_binary/1), \"cannot build graphemes for #{inspect(bin)}\"\n end\n end\n end\n\n test \"split empty\" do\n for _ <- 1..10 do\n bin = :crypto.strong_rand_bytes(20)\n\n try do\n String.split(bin, \"\")\n rescue\n # Ignore malformed pictographic sequences\n _ -> :ok\n else\n split ->\n assert Enum.all?(split, &is_binary/1), \"cannot split #{inspect(bin)}\"\n assert IO.iodata_to_binary(split) == bin\n end\n end\n end\n\n test \"graphemes\" do\n for _ <- 1..10 do\n bin = :crypto.strong_rand_bytes(20)\n\n try do\n String.graphemes(bin)\n rescue\n # Ignore malformed pictographic sequences\n _ -> :ok\n else\n graphemes ->\n assert Enum.all?(graphemes, &is_binary/1),\n \"cannot build graphemes for #{inspect(bin)}\"\n\n assert IO.iodata_to_binary(graphemes) == bin\n end\n end\n end\n end\n\n test \"first/1\" do\n assert String.first(\"elixir\") == \"e\"\n assert String.first(\"íelixr\") == \"í\"\n assert String.first(\"եոգլից ըմպելիք\") == \"ե\"\n assert String.first(\"лэіксір\") == \"л\"\n assert String.first(\"ελιξήριο\") == \"ε\"\n assert String.first(\"סם חיים\") == \"ס\"\n assert String.first(\"がガちゃ\") == \"が\"\n assert String.first(\"Ā̀stute\") == \"Ā̀\"\n assert String.first(\"\") == nil\n end\n\n test \"last/1\" do\n assert String.last(\"elixir\") == \"r\"\n assert String.last(\"elixrí\") == \"í\"\n assert String.last(\"եոգլից ըմպելիքե\") == \"ե\"\n assert String.last(\"ліксірэ\") == \"э\"\n assert String.last(\"ειξήριολ\") == \"λ\"\n assert String.last(\"סם ייםח\") == \"ח\"\n assert String.last(\"がガちゃ\") == \"ゃ\"\n assert String.last(\"Ā̀\") == \"Ā̀\"\n assert String.last(\"\") == nil\n end\n\n test \"length/1\" do\n assert String.length(\"elixir\") == 6\n assert String.length(\"elixrí\") == 6\n assert String.length(\"եոգլից\") == 6\n assert String.length(\"ліксрэ\") == 6\n assert String.length(\"ειξήριολ\") == 8\n assert String.length(\"סם ייםח\") == 7\n assert String.length(\"がガちゃ\") == 4\n assert String.length(\"Ā̀stute\") == 6\n assert String.length(\"👨‍👩‍👧‍👦\") == 1\n assert String.length(\"\") == 0\n end\n\n test \"at/2\" do\n assert String.at(\"л\", 0) == \"л\"\n assert String.at(\"elixir\", 1) == \"l\"\n assert String.at(\"がガちゃ\", 2) == \"ち\"\n assert String.at(\"л\", 10) == nil\n assert String.at(\"elixir\", -1) == \"r\"\n assert String.at(\"がガちゃ\", -2) == \"ち\"\n assert String.at(\"л\", -3) == nil\n assert String.at(\"Ā̀stute\", 1) == \"s\"\n assert String.at(\"elixir\", 6) == nil\n end\n\n test \"slice/3\" do\n assert String.slice(\"elixir\", 1, 3) == \"lix\"\n assert String.slice(\"あいうえお\", 2, 2) == \"うえ\"\n assert String.slice(\"ειξήριολ\", 2, 3) == \"ξήρ\"\n assert String.slice(\"elixir\", 3, 4) == \"xir\"\n assert String.slice(\"あいうえお\", 3, 5) == \"えお\"\n assert String.slice(\"ειξήριολ\", 5, 4) == \"ιολ\"\n assert String.slice(\"elixir\", -3, 2) == \"xi\"\n assert String.slice(\"あいうえお\", -4, 3) == \"いうえ\"\n assert String.slice(\"ειξήριολ\", -5, 3) == \"ήρι\"\n assert String.slice(\"elixir\", -10, 1) == \"e\"\n assert String.slice(\"あいうえお\", -10, 2) == \"あい\"\n assert String.slice(\"ειξήριολ\", -10, 3) == \"ειξ\"\n assert String.slice(\"elixir\", 8, 2) == \"\"\n assert String.slice(\"あいうえお\", 6, 2) == \"\"\n assert String.slice(\"ειξήριολ\", 8, 1) == \"\"\n assert String.slice(\"ειξήριολ\", 9, 1) == \"\"\n assert String.slice(\"elixir\", 0, 0) == \"\"\n assert String.slice(\"elixir\", 5, 0) == \"\"\n assert String.slice(\"elixir\", -5, 0) == \"\"\n assert String.slice(\"elixir\", -10, 10) == \"elixir\"\n assert String.slice(\"\", 0, 1) == \"\"\n assert String.slice(\"\", 1, 1) == \"\"\n end\n\n test \"slice/2\" do\n assert String.slice(\"elixir\", 0..-2//1) == \"elixi\"\n assert String.slice(\"elixir\", 1..3) == \"lix\"\n assert String.slice(\"elixir\", -5..-3) == \"lix\"\n assert String.slice(\"elixir\", -5..3) == \"lix\"\n assert String.slice(\"elixir\", -10..10) == \"elixir\"\n assert String.slice(\"あいうえお\", 2..3) == \"うえ\"\n assert String.slice(\"ειξήριολ\", 2..4) == \"ξήρ\"\n assert String.slice(\"elixir\", 3..6) == \"xir\"\n assert String.slice(\"あいうえお\", 3..7) == \"えお\"\n assert String.slice(\"ειξήριολ\", 5..8) == \"ιολ\"\n assert String.slice(\"elixir\", -3..-2) == \"xi\"\n assert String.slice(\"あいうえお\", -4..-2) == \"いうえ\"\n assert String.slice(\"ειξήριολ\", -5..-3) == \"ήρι\"\n assert String.slice(\"elixir\", 8..9) == \"\"\n assert String.slice(\"あいうえお\", 6..7) == \"\"\n assert String.slice(\"ειξήριολ\", 8..8) == \"\"\n assert String.slice(\"ειξήριολ\", 9..9) == \"\"\n assert String.slice(\"\", 0..0) == \"\"\n assert String.slice(\"\", 1..1) == \"\"\n assert String.slice(\"あいうえお\", -2..-4//1) == \"\"\n assert String.slice(\"あいうえお\", -10..-15//1) == \"\"\n assert String.slice(\"hello あいうえお Unicode\", 8..-1//1) == \"うえお Unicode\"\n assert String.slice(\"abc\", -1..14) == \"c\"\n assert String.slice(\"a·̀ͯ‿.⁀:\", 0..-2//1) == \"a·̀ͯ‿.⁀\"\n\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert String.slice(\"elixir\", 0..-2//-1) == \"elixi\"\n end) =~ \"negative steps are not supported in String.slice/2, pass 0..-2//1 instead\"\n end\n\n test \"slice/2 with steps\" do\n assert String.slice(\"elixir\", 0..-2//2) == \"eii\"\n assert String.slice(\"elixir\", 1..3//2) == \"lx\"\n assert String.slice(\"elixir\", -5..-3//2) == \"lx\"\n assert String.slice(\"elixir\", -5..3//2) == \"lx\"\n assert String.slice(\"あいうえお\", 2..3//2) == \"う\"\n assert String.slice(\"ειξήριολ\", 2..4//2) == \"ξρ\"\n assert String.slice(\"elixir\", 3..6//2) == \"xr\"\n assert String.slice(\"あいうえお\", 3..7//2) == \"え\"\n assert String.slice(\"ειξήριολ\", 5..8//2) == \"ιλ\"\n assert String.slice(\"elixir\", -3..-2//2) == \"x\"\n assert String.slice(\"あいうえお\", -4..-2//2) == \"いえ\"\n assert String.slice(\"ειξήριολ\", -5..-3//2) == \"ήι\"\n assert String.slice(\"elixir\", 8..9//2) == \"\"\n assert String.slice(\"\", 0..0//2) == \"\"\n assert String.slice(\"\", 1..1//2) == \"\"\n assert String.slice(\"あいうえお\", -2..-4//2) == \"\"\n assert String.slice(\"あいうえお\", -10..-15//2) == \"\"\n assert String.slice(\"hello あいうえお Unicode\", 8..-1//2) == \"うおUioe\"\n assert String.slice(\"abc\", -1..14//2) == \"c\"\n assert String.slice(\"a·̀ͯ‿.⁀:\", 0..-2//2) == \"a‿⁀\"\n end\n\n test \"byte_slice/2\" do\n # ASCII\n assert String.byte_slice(\"elixir\", 0, 6) == \"elixir\"\n assert String.byte_slice(\"elixir\", 0, 5) == \"elixi\"\n assert String.byte_slice(\"elixir\", 1, 4) == \"lixi\"\n assert String.byte_slice(\"elixir\", 0, 10) == \"elixir\"\n assert String.byte_slice(\"elixir\", -3, 10) == \"xir\"\n assert String.byte_slice(\"elixir\", -10, 10) == \"elixir\"\n assert String.byte_slice(\"elixir\", 1, 0) == \"\"\n assert String.byte_slice(\"elixir\", 10, 10) == \"\"\n\n # 2 byte\n assert String.byte_slice(\"héllò\", 1, 4) == \"éll\"\n assert String.byte_slice(\"héllò\", 1, 5) == \"éll\"\n assert String.byte_slice(\"héllò\", 1, 6) == \"éllò\"\n assert String.byte_slice(\"héllò\", 2, 4) == \"llò\"\n\n # 3 byte\n assert String.byte_slice(\"hかllか\", 1, 4) == \"かl\"\n assert String.byte_slice(\"hかllか\", 1, 5) == \"かll\"\n assert String.byte_slice(\"hかllか\", 1, 6) == \"かll\"\n assert String.byte_slice(\"hかllか\", 1, 7) == \"かll\"\n assert String.byte_slice(\"hかllか\", 1, 8) == \"かllか\"\n assert String.byte_slice(\"hかllか\", 2, 4) == \"ll\"\n assert String.byte_slice(\"hかllか\", 2, 5) == \"llか\"\n\n # 4 byte\n assert String.byte_slice(\"h😍ll😍\", 1, 4) == \"😍\"\n assert String.byte_slice(\"h😍ll😍\", 1, 5) == \"😍l\"\n assert String.byte_slice(\"h😍ll😍\", 1, 6) == \"😍ll\"\n assert String.byte_slice(\"h😍ll😍\", 1, 7) == \"😍ll\"\n assert String.byte_slice(\"h😍ll😍\", 1, 8) == \"😍ll\"\n assert String.byte_slice(\"h😍ll😍\", 1, 9) == \"😍ll\"\n assert String.byte_slice(\"h😍ll😍\", 1, 10) == \"😍ll😍\"\n assert String.byte_slice(\"h😍ll😍\", 2, 5) == \"ll\"\n assert String.byte_slice(\"h😍ll😍\", 2, 6) == \"ll😍\"\n\n # Already truncated\n assert String.byte_slice(<<178, \"ll\", 178>>, 0, 10) == \"ll\"\n\n # Already invalid\n assert String.byte_slice(<<255, \"ll\", 255>>, 0, 10) == <<255, \"ll\", 255>>\n end\n\n test \"valid?/1\" do\n assert String.valid?(\"afds\")\n assert String.valid?(\"øsdfh\")\n assert String.valid?(\"dskfjあska\")\n assert String.valid?(<<0xEF, 0xB7, 0x90>>)\n\n refute String.valid?(<<0xFFFF::16>>)\n refute String.valid?(\"asd\" <> <<0xFFFF::16>>)\n\n assert String.valid?(\"afdsafdsafds\", :fast_ascii)\n assert String.valid?(\"øsdfhøsdfh\", :fast_ascii)\n assert String.valid?(\"dskfjあskadskfjあska\", :fast_ascii)\n assert String.valid?(<<0xEF, 0xB7, 0x90, 0xEF, 0xB7, 0x90, 0xEF, 0xB7, 0x90>>, :fast_ascii)\n\n refute String.valid?(<<0xFFFF::16>>, :fast_ascii)\n refute String.valid?(\"asdasdasd\" <> <<0xFFFF::16>>, :fast_ascii)\n end\n\n test \"replace_invalid\" do\n assert String.replace_invalid(\"\") === \"\"\n assert String.replace_invalid(<<0xFF>>) === \"�\"\n assert String.replace_invalid(<<0xFF, 0xFF, 0xFF>>) === \"���\"\n\n # Valid ASCII\n assert String.replace_invalid(\"hello\") === \"hello\"\n\n # Valid UTF-8\n assert String.replace_invalid(\"こんにちは\") === \"こんにちは\"\n\n # 2/3 byte truncated \"ề\"\n assert String.replace_invalid(<<225, 187>>) === \"�\"\n assert String.replace_invalid(\"nem rán b\" <> <<225, 187>> <> \" bề\") === \"nem rán b� bề\"\n\n # 2/4 byte truncated \"😔\"\n assert String.replace_invalid(<<240, 159>>) === \"�\"\n assert String.replace_invalid(\"It's so over \" <> <<240, 159>>) === \"It's so over �\"\n\n # 3/4 byte truncated \"😃\"\n assert String.replace_invalid(<<240, 159, 152>>) === \"�\"\n assert String.replace_invalid(\"We're so back \" <> <<240, 159, 152>>) === \"We're so back �\"\n\n # 3 byte overlong \"e\"\n assert String.replace_invalid(<<0b11100000, 0b10000001, 0b10100101>>) === \"���\"\n end\n\n test \"chunk/2 with :valid trait\" do\n assert String.chunk(\"\", :valid) == []\n\n assert String.chunk(\"ødskfjあ\\x11ska\", :valid) == [\"ødskfjあ\\x11ska\"]\n end\n\n test \"chunk/2 with :printable trait\" do\n assert String.chunk(\"\", :printable) == []\n\n assert String.chunk(\"ødskfjあska\", :printable) == [\"ødskfjあska\"]\n assert String.chunk(\"abc\\u{0FFFF}def\", :printable) == [\"abc\", <<0x0FFFF::utf8>>, \"def\"]\n\n assert String.chunk(\"\\x06ab\\x05cdef\\x03\\0\", :printable) ==\n [<<6>>, \"ab\", <<5>>, \"cdef\", <<3, 0>>]\n end\n\n test \"starts_with?/2\" do\n assert String.starts_with?(\"hello\", \"he\")\n assert String.starts_with?(\"hello\", \"hello\")\n refute String.starts_with?(\"hello\", [])\n assert String.starts_with?(\"hello\", \"\")\n assert String.starts_with?(\"hello\", [\"\"])\n assert String.starts_with?(\"hello\", [\"hellö\", \"hell\"])\n assert String.starts_with?(\"エリクシア\", \"エリ\")\n refute String.starts_with?(\"hello\", \"lo\")\n refute String.starts_with?(\"hello\", \"hellö\")\n refute String.starts_with?(\"hello\", [\"hellö\", \"goodbye\"])\n refute String.starts_with?(\"エリクシア\", \"仙丹\")\n end\n\n test \"ends_with?/2\" do\n assert String.ends_with?(\"hello\", \"lo\")\n assert String.ends_with?(\"hello\", \"hello\")\n refute String.ends_with?(\"hello\", [])\n assert String.ends_with?(\"hello\", [\"hell\", \"lo\", \"xx\"])\n assert String.ends_with?(\"hello\", [\"hellö\", \"lo\"])\n assert String.ends_with?(\"エリクシア\", \"シア\")\n refute String.ends_with?(\"hello\", \"he\")\n refute String.ends_with?(\"hello\", \"hellö\")\n refute String.ends_with?(\"hello\", [\"hel\", \"goodbye\"])\n refute String.ends_with?(\"エリクシア\", \"仙丹\")\n end\n\n test \"contains?/2\" do\n assert String.contains?(\"elixir of life\", \"of\")\n assert String.contains?(\"エリクシア\", \"シ\")\n refute String.contains?(\"elixir of life\", [])\n assert String.contains?(\"elixir of life\", \"\")\n assert String.contains?(\"elixir of life\", [\"\"])\n assert String.contains?(\"elixir of life\", [\"mercury\", \"life\"])\n refute String.contains?(\"elixir of life\", \"death\")\n refute String.contains?(\"エリクシア\", \"仙\")\n refute String.contains?(\"elixir of life\", [\"death\", \"mercury\", \"eternal life\"])\n end\n\n test \"to_charlist/1\" do\n assert String.to_charlist(\"æß\") == [?æ, ?ß]\n assert String.to_charlist(\"abc\") == [?a, ?b, ?c]\n\n assert_raise UnicodeConversionError, \"invalid encoding starting at <<223, 255>>\", fn ->\n String.to_charlist(<<0xDF, 0xFF>>)\n end\n\n assert_raise UnicodeConversionError, \"incomplete encoding starting at <<195>>\", fn ->\n String.to_charlist(<<106, 111, 115, 195>>)\n end\n end\n\n test \"to_float/1\" do\n assert String.to_float(\"3.0\") == 3.0\n\n three = fn -> \"3\" end\n assert_raise ArgumentError, fn -> String.to_float(three.()) end\n\n dot_three = fn -> \".3\" end\n assert_raise ArgumentError, fn -> String.to_float(dot_three.()) end\n end\n\n test \"jaro_distance/2\" do\n assert String.jaro_distance(\"same\", \"same\") == 1.0\n assert String.jaro_distance(\"any\", \"\") == 0.0\n assert String.jaro_distance(\"\", \"any\") == 0.0\n assert String.jaro_distance(\"martha\", \"marhta\") == 0.9444444444444445\n assert String.jaro_distance(\"martha\", \"marhha\") == 0.888888888888889\n assert String.jaro_distance(\"marhha\", \"martha\") == 0.888888888888889\n assert String.jaro_distance(\"dwayne\", \"duane\") == 0.8222222222222223\n assert String.jaro_distance(\"dixon\", \"dicksonx\") == 0.7666666666666666\n assert String.jaro_distance(\"xdicksonx\", \"dixon\") == 0.7518518518518519\n assert String.jaro_distance(\"shackleford\", \"shackelford\") == 0.9696969696969697\n assert String.jaro_distance(\"dunningham\", \"cunnigham\") == 0.8962962962962964\n assert String.jaro_distance(\"nichleson\", \"nichulson\") == 0.9259259259259259\n assert String.jaro_distance(\"jones\", \"johnson\") == 0.7904761904761904\n assert String.jaro_distance(\"massey\", \"massie\") == 0.888888888888889\n assert String.jaro_distance(\"abroms\", \"abrams\") == 0.888888888888889\n assert String.jaro_distance(\"hardin\", \"martinez\") == 0.7222222222222222\n assert String.jaro_distance(\"itman\", \"smith\") == 0.4666666666666666\n assert String.jaro_distance(\"jeraldine\", \"geraldine\") == 0.9259259259259259\n assert String.jaro_distance(\"michelle\", \"michael\") == 0.8690476190476191\n assert String.jaro_distance(\"julies\", \"julius\") == 0.888888888888889\n assert String.jaro_distance(\"tanya\", \"tonya\") == 0.8666666666666667\n assert String.jaro_distance(\"sean\", \"susan\") == 0.7833333333333333\n assert String.jaro_distance(\"jon\", \"john\") == 0.9166666666666666\n assert String.jaro_distance(\"jon\", \"jan\") == 0.7777777777777777\n assert String.jaro_distance(\"семена\", \"стремя\") == 0.6666666666666666\n assert String.jaro_distance(\"Sunday\", \"Saturday\") == 0.7194444444444444\n end\n\n test \"myers_difference/2\" do\n assert String.myers_difference(\"\", \"abc\") == [ins: \"abc\"]\n assert String.myers_difference(\"abc\", \"\") == [del: \"abc\"]\n assert String.myers_difference(\"\", \"\") == []\n assert String.myers_difference(\"abc\", \"abc\") == [eq: \"abc\"]\n assert String.myers_difference(\"abc\", \"aйbc\") == [eq: \"a\", ins: \"й\", eq: \"bc\"]\n assert String.myers_difference(\"aйbc\", \"abc\") == [eq: \"a\", del: \"й\", eq: \"bc\"]\n end\n\n test \"normalize/2\" do\n assert String.normalize(\"ŝ\", :nfd) == \"ŝ\"\n assert String.normalize(\"ḇravô\", :nfd) == \"ḇravô\"\n assert String.normalize(\"ṩierra\", :nfd) == \"ṩierra\"\n assert String.normalize(\"뢴\", :nfd) == \"뢴\"\n assert String.normalize(\"êchǭ\", :nfc) == \"êchǭ\"\n assert String.normalize(\"거̄\", :nfc) == \"거̄\"\n assert String.normalize(\"뢴\", :nfc) == \"뢴\"\n\n ## Error cases\n assert String.normalize(<<15, 216>>, :nfc) == <<15, 216>>\n assert String.normalize(<<15, 216>>, :nfd) == <<15, 216>>\n assert String.normalize(<<216, 15>>, :nfc) == <<216, 15>>\n assert String.normalize(<<216, 15>>, :nfd) == <<216, 15>>\n\n assert String.normalize(<<15, 216>>, :nfkc) == <<15, 216>>\n assert String.normalize(<<15, 216>>, :nfkd) == <<15, 216>>\n assert String.normalize(<<216, 15>>, :nfkc) == <<216, 15>>\n assert String.normalize(<<216, 15>>, :nfkd) == <<216, 15>>\n\n ## Cases from NormalizationTest.txt\n\n # 05B8 05B9 05B1 0591 05C3 05B0 05AC 059F\n # 05B1 05B8 05B9 0591 05C3 05B0 05AC 059F\n # HEBREW POINT QAMATS, HEBREW POINT HOLAM, HEBREW POINT HATAF SEGOL,\n # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,\n # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA\n assert String.normalize(\"ֱָֹ֑׃ְ֬֟\", :nfc) == \"ֱָֹ֑׃ְ֬֟\"\n\n # 095D (exclusion list)\n # 0922 093C\n # DEVANAGARI LETTER RHA\n assert String.normalize(\"ढ़\", :nfc) == \"ढ़\"\n\n # 0061 0315 0300 05AE 0340 0062\n # 00E0 05AE 0300 0315 0062\n # LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT,\n # HEBREW ACCENT ZINOR, COMBINING GRAVE TONE MARK, LATIN SMALL LETTER B\n assert String.normalize(\"à֮̀̕b\", :nfc) == \"à֮̀̕b\"\n\n # 0344\n # 0308 0301\n # COMBINING GREEK DIALYTIKA TONOS\n assert String.normalize(\"\\u0344\", :nfc) == \"\\u0308\\u0301\"\n\n # 115B9 0334 115AF\n # 115B9 0334 115AF\n # SIDDHAM VOWEL SIGN AI, COMBINING TILDE OVERLAY, SIDDHAM VOWEL SIGN AA\n assert String.normalize(\"𑖹̴𑖯\", :nfc) == \"𑖹̴𑖯\"\n\n # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,\n # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA\n assert String.normalize(\"ֱָֹ֑׃ְ֬֟\", :nfc) == \"ֱָֹ֑׃ְ֬֟\"\n\n # 095D (exclusion list)\n # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,\n # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA\n assert String.normalize(\"ֱָֹ֑׃ְ֬֟\", :nfc) == \"ֱָֹ֑׃ְ֬֟\"\n\n # 095D (exclusion list)\n # 0922 093C\n # DEVANAGARI LETTER RHA\n assert String.normalize(\"ढ़\", :nfc) == \"ढ़\"\n\n # 0061 0315 0300 05AE 0340 0062\n # 00E0 05AE 0300 0315 0062\n # LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT,\n # HEBREW ACCENT ZINOR, COMBINING GRAVE TONE MARK, LATIN SMALL LETTER B\n assert String.normalize(\"à֮̀̕b\", :nfc) == \"à֮̀̕b\"\n\n # 0344\n # 0308 0301\n # COMBINING GREEK DIALYTIKA TONOS\n assert String.normalize(\"\\u0344\", :nfc) == \"\\u0308\\u0301\"\n\n # 115B9 0334 115AF\n # 115B9 0334 115AF\n # SIDDHAM VOWEL SIGN AI, COMBINING TILDE OVERLAY, SIDDHAM VOWEL SIGN AA\n assert String.normalize(\"𑖹̴𑖯\", :nfc) == \"𑖹̴𑖯\"\n\n # (ff; ff; ff; ff; ff; ) LATIN SMALL LIGATURE FF\n # FB00;FB00;FB00;0066 0066;0066 0066;\n assert String.normalize(\"ff\", :nfkd) == \"\\u0066\\u0066\"\n\n # (fl; fl; fl; fl; fl; ) LATIN SMALL LIGATURE FL\n # FB02;FB02;FB02;0066 006C;0066 006C;\n assert String.normalize(\"fl\", :nfkd) == \"\\u0066\\u006C\"\n\n # (ſt; ſt; ſt; st; st; ) LATIN SMALL LIGATURE LONG S T\n # FB05;FB05;FB05;0073 0074;0073 0074;\n assert String.normalize(\"ſt\", :nfkd) == \"\\u0073\\u0074\"\n\n # (st; st; st; st; st; ) LATIN SMALL LIGATURE ST\n # FB06;FB06;FB06;0073 0074;0073 0074;\n assert String.normalize(\"\\u0073\\u0074\", :nfkc) == \"\\u0073\\u0074\"\n\n # (ﬓ; ﬓ; ﬓ; մն; մն; ) ARMENIAN SMALL LIGATURE MEN NOW\n # FB13;FB13;FB13;0574 0576;0574 0576;\n assert String.normalize(\"\\u0574\\u0576\", :nfkc) == \"\\u0574\\u0576\"\n end\n\n # Carriage return can be a grapheme cluster if followed by\n # newline so we test some corner cases here.\n test \"carriage return\" do\n assert String.at(\"\\r\\t\\v\", 0) == \"\\r\"\n assert String.at(\"\\r\\t\\v\", 1) == \"\\t\"\n assert String.at(\"\\r\\t\\v\", 2) == \"\\v\"\n assert String.at(\"\\xFF\\r\\t\\v\", 1) == \"\\r\"\n assert String.at(\"\\r\\xFF\\t\\v\", 2) == \"\\t\"\n assert String.at(\"\\r\\t\\xFF\\v\", 3) == \"\\v\"\n\n assert String.last(\"\\r\\t\\v\") == \"\\v\"\n assert String.last(\"\\r\\xFF\\t\\xFF\\v\") == \"\\v\"\n\n assert String.next_grapheme(\"\\r\\t\\v\") == {\"\\r\", \"\\t\\v\"}\n assert String.next_grapheme(\"\\t\\v\") == {\"\\t\", \"\\v\"}\n assert String.next_grapheme(\"\\v\") == {\"\\v\", \"\"}\n\n assert String.length(\"\\r\\t\\v\") == 3\n assert String.length(\"\\r\\xFF\\t\\v\") == 4\n assert String.length(\"\\r\\t\\xFF\\v\") == 4\n\n assert String.bag_distance(\"\\r\\t\\xFF\\v\", \"\\xFF\\r\\n\\xFF\") == 0.25\n assert String.split(\"\\r\\t\\v\", \"\") == [\"\", \"\\r\", \"\\t\", \"\\v\", \"\"]\n end\nend\n" }, { "path": "lib/elixir/test/elixir/supervisor_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule SupervisorTest do\n use ExUnit.Case, async: true\n\n defmodule Stack do\n use GenServer\n\n def start_link({state, opts}) do\n GenServer.start_link(__MODULE__, state, opts)\n end\n\n def init(args) do\n {:ok, args}\n end\n\n def handle_call(:pop, _from, [h | t]) do\n {:reply, h, t}\n end\n\n def handle_call(:stop, _from, stack) do\n # There is a race condition between genserver terminations.\n # So we will explicitly unregister it here.\n try do\n self() |> Process.info(:registered_name) |> elem(1) |> Process.unregister()\n rescue\n _ -> :ok\n end\n\n {:stop, :normal, :ok, stack}\n end\n\n def handle_cast({:push, h}, t) do\n {:noreply, [h | t]}\n end\n end\n\n defmodule Stack.Sup do\n use Supervisor\n\n def init(pair) do\n Supervisor.init([{Stack, pair}], strategy: :one_for_one)\n end\n end\n\n test \"generates child_spec/1\" do\n assert Stack.Sup.child_spec([:hello]) == %{\n id: Stack.Sup,\n start: {Stack.Sup, :start_link, [[:hello]]},\n type: :supervisor\n }\n\n defmodule CustomSup do\n use Supervisor,\n id: :id,\n restart: :temporary,\n start: {:foo, :bar, []}\n\n def init(arg) do\n arg\n end\n end\n\n assert CustomSup.child_spec([:hello]) == %{\n id: :id,\n restart: :temporary,\n start: {:foo, :bar, []},\n type: :supervisor\n }\n end\n\n test \"child_spec/2\" do\n assert Supervisor.child_spec(Task, []) ==\n %{id: Task, restart: :temporary, start: {Task, :start_link, [[]]}}\n\n assert Supervisor.child_spec({Task, :foo}, []) ==\n %{id: Task, restart: :temporary, start: {Task, :start_link, [:foo]}}\n\n assert Supervisor.child_spec(%{id: Task}, []) == %{id: Task}\n\n assert Supervisor.child_spec(\n Task,\n id: :foo,\n start: {:foo, :bar, []},\n restart: :permanent,\n shutdown: :infinity\n ) == %{id: :foo, start: {:foo, :bar, []}, restart: :permanent, shutdown: :infinity}\n\n message = ~r\"The module SupervisorTest was given as a child.*\\nbut it does not implement\"m\n\n assert_raise ArgumentError, message, fn ->\n Supervisor.child_spec(SupervisorTest, [])\n end\n\n message = ~r\"The module Unknown was given as a child.*but it does not exist\"m\n\n assert_raise ArgumentError, message, fn ->\n Supervisor.child_spec(Unknown, [])\n end\n\n message = ~r\"supervisors expect each child to be one of\"\n\n assert_raise ArgumentError, message, fn ->\n Supervisor.child_spec(\"other\", [])\n end\n end\n\n test \"init/2\" do\n flags = %{intensity: 3, period: 5, strategy: :one_for_one, auto_shutdown: :never}\n children = [%{id: Task, restart: :temporary, start: {Task, :start_link, [[]]}}]\n assert Supervisor.init([Task], strategy: :one_for_one) == {:ok, {flags, children}}\n\n flags = %{intensity: 1, period: 2, strategy: :one_for_all, auto_shutdown: :never}\n children = [%{id: Task, restart: :temporary, start: {Task, :start_link, [:foo]}}]\n\n assert Supervisor.init(\n [{Task, :foo}],\n strategy: :one_for_all,\n max_restarts: 1,\n max_seconds: 2\n ) == {:ok, {flags, children}}\n\n assert_raise ArgumentError, \"expected :strategy option to be given\", fn ->\n Supervisor.init([], [])\n end\n end\n\n test \"init/2 with old and new child specs\" do\n flags = %{intensity: 3, period: 5, strategy: :one_for_one, auto_shutdown: :never}\n\n children = [\n %{id: Task, restart: :temporary, start: {Task, :start_link, [[]]}},\n old_spec = {Task, {Task, :start_link, []}, :permanent, 5000, :worker, [Task]}\n ]\n\n assert Supervisor.init([Task, old_spec], strategy: :one_for_one) ==\n {:ok, {flags, children}}\n end\n\n test \"start_link/2 with via\" do\n Supervisor.start_link([], strategy: :one_for_one, name: {:via, :global, :via_sup})\n assert Supervisor.which_children({:via, :global, :via_sup}) == []\n end\n\n test \"start_link/3 with global\" do\n Supervisor.start_link([], strategy: :one_for_one, name: {:global, :global_sup})\n assert Supervisor.which_children({:global, :global_sup}) == []\n end\n\n test \"start_link/3 with local\" do\n Supervisor.start_link([], strategy: :one_for_one, name: :my_sup)\n assert Supervisor.which_children(:my_sup) == []\n end\n\n test \"start_link/2\" do\n children = [{Stack, {[:hello], [name: :dyn_stack]}}]\n {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)\n\n wait_until_registered(:dyn_stack)\n assert GenServer.call(:dyn_stack, :pop) == :hello\n assert GenServer.call(:dyn_stack, :stop) == :ok\n\n wait_until_registered(:dyn_stack)\n assert GenServer.call(:dyn_stack, :pop) == :hello\n Supervisor.stop(pid)\n\n assert_raise ArgumentError, ~r\"expected :name option to be one of the following:\", fn ->\n name = \"my_gen_server_name\"\n Supervisor.start_link(children, name: name, strategy: :one_for_one)\n end\n\n assert_raise ArgumentError, ~r\"expected :name option to be one of the following:\", fn ->\n name = {:invalid_tuple, \"my_gen_server_name\"}\n Supervisor.start_link(children, name: name, strategy: :one_for_one)\n end\n\n assert_raise ArgumentError, ~r\"expected :name option to be one of the following:\", fn ->\n name = {:via, \"Via\", \"my_gen_server_name\"}\n Supervisor.start_link(children, name: name, strategy: :one_for_one)\n end\n end\n\n test \"start_link/2 with old and new specs\" do\n children = [\n {Stack, {[:hello], []}},\n {:old_stack, {SupervisorTest.Stack, :start_link, [{[:hello], []}]}, :permanent, 5000,\n :worker, [SupervisorTest.Stack]}\n ]\n\n {:ok, _} = Supervisor.start_link(children, strategy: :one_for_one)\n end\n\n test \"start_link/3\" do\n {:ok, pid} = Supervisor.start_link(Stack.Sup, {[:hello], [name: :stat_stack]})\n wait_until_registered(:stat_stack)\n assert GenServer.call(:stat_stack, :pop) == :hello\n Supervisor.stop(pid)\n end\n\n describe \"start_child/2\" do\n test \"supports old child spec\" do\n {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)\n child = {Task, {Task, :start_link, [fn -> :ok end]}, :temporary, 5000, :worker, [Task]}\n assert {:ok, pid} = Supervisor.start_child(pid, child)\n assert is_pid(pid)\n end\n\n test \"supports new child spec as tuple\" do\n {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)\n child = %{id: Task, restart: :temporary, start: {Task, :start_link, [fn -> :ok end]}}\n assert {:ok, pid} = Supervisor.start_child(pid, child)\n assert is_pid(pid)\n end\n\n test \"supports new child spec\" do\n {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)\n child = {Task, fn -> :timer.sleep(:infinity) end}\n assert {:ok, pid} = Supervisor.start_child(pid, child)\n assert is_pid(pid)\n end\n\n test \"with invalid child spec\" do\n {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)\n\n assert Supervisor.start_child(pid, %{}) == {:error, :missing_id}\n assert Supervisor.start_child(pid, {1, 2, 3, 4, 5, 6}) == {:error, {:invalid_mfa, 2}}\n\n assert Supervisor.start_child(pid, %{id: 1, start: {Task, :foo, :bar}}) ==\n {:error, {:invalid_mfa, {Task, :foo, :bar}}}\n\n assert Supervisor.start_child(pid, %{id: 1, start: {Task, :foo, [:bar]}, shutdown: -1}) ==\n {:error, {:invalid_shutdown, -1}}\n end\n\n test \"with valid child spec\" do\n Process.flag(:trap_exit, true)\n\n {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)\n\n for n <- 0..1 do\n assert {:ok, child_pid} =\n Supervisor.start_child(pid, %{\n id: n,\n start: {Task, :start_link, [fn -> Process.sleep(:infinity) end]},\n shutdown: n\n })\n\n assert_kill(child_pid, :shutdown)\n end\n end\n end\n\n test \"child life cycle\" do\n {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)\n\n assert Supervisor.which_children(pid) == []\n assert Supervisor.count_children(pid) == %{specs: 0, active: 0, supervisors: 0, workers: 0}\n\n child_spec = Supervisor.child_spec({Stack, {[:hello], []}}, [])\n {:ok, stack} = Supervisor.start_child(pid, child_spec)\n assert GenServer.call(stack, :pop) == :hello\n\n assert Supervisor.which_children(pid) ==\n [{SupervisorTest.Stack, stack, :worker, [SupervisorTest.Stack]}]\n\n assert Supervisor.count_children(pid) == %{specs: 1, active: 1, supervisors: 0, workers: 1}\n\n assert Supervisor.delete_child(pid, Stack) == {:error, :running}\n assert Supervisor.terminate_child(pid, Stack) == :ok\n\n {:ok, stack} = Supervisor.restart_child(pid, Stack)\n assert GenServer.call(stack, :pop) == :hello\n\n assert Supervisor.terminate_child(pid, Stack) == :ok\n assert Supervisor.delete_child(pid, Stack) == :ok\n Supervisor.stop(pid)\n end\n\n defp wait_until_registered(name) do\n if !Process.whereis(name) do\n wait_until_registered(name)\n end\n end\n\n defp assert_kill(pid, reason) do\n ref = Process.monitor(pid)\n Process.exit(pid, reason)\n assert_receive {:DOWN, ^ref, _, _, _}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/system_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule SystemTest do\n use ExUnit.Case\n import PathHelpers\n\n test \"build_info/0\" do\n build_info = System.build_info()\n assert is_map(build_info)\n assert is_binary(build_info[:build])\n assert is_binary(build_info[:date])\n assert is_binary(build_info[:revision])\n assert is_binary(build_info[:version])\n assert is_binary(build_info[:otp_release])\n\n if build_info[:revision] != \"\" do\n assert String.length(build_info[:revision]) >= 7\n end\n\n version_file = Path.join([__DIR__, \"../../../..\", \"VERSION\"]) |> Path.expand()\n {:ok, version} = File.read(version_file)\n assert build_info[:version] == String.trim(version)\n assert build_info[:build] =~ \"compiled with Erlang/OTP\"\n end\n\n test \"user_home/0\" do\n assert is_binary(System.user_home())\n assert is_binary(System.user_home!())\n end\n\n test \"tmp_dir/0\" do\n assert is_binary(System.tmp_dir())\n assert is_binary(System.tmp_dir!())\n end\n\n test \"endianness/0\" do\n assert System.endianness() in [:little, :big]\n assert System.endianness() == System.compiled_endianness()\n end\n\n test \"pid/0\" do\n assert is_binary(System.pid())\n end\n\n test \"argv/0\" do\n list = elixir(~c\"-e \\\"IO.inspect System.argv()\\\" -- -o opt arg1 arg2 --long-opt 10\")\n {args, _} = Code.eval_string(list, [])\n assert args == [\"-o\", \"opt\", \"arg1\", \"arg2\", \"--long-opt\", \"10\"]\n end\n\n @test_var \"SYSTEM_ELIXIR_ENV_TEST_VAR\"\n\n test \"get_env/put_env/delete_env\" do\n assert System.get_env(@test_var) == nil\n assert System.get_env(@test_var, \"SAMPLE\") == \"SAMPLE\"\n assert System.fetch_env(@test_var) == :error\n\n message = \"could not fetch environment variable #{inspect(@test_var)} because it is not set\"\n assert_raise System.EnvError, message, fn -> System.fetch_env!(@test_var) end\n\n System.put_env(@test_var, \"SAMPLE\")\n\n assert System.get_env(@test_var) == \"SAMPLE\"\n assert System.get_env()[@test_var] == \"SAMPLE\"\n assert System.fetch_env(@test_var) == {:ok, \"SAMPLE\"}\n assert System.fetch_env!(@test_var) == \"SAMPLE\"\n\n System.delete_env(@test_var)\n assert System.get_env(@test_var) == nil\n\n assert_raise ArgumentError, ~r[cannot execute System.put_env/2 for key with \\\"=\\\"], fn ->\n System.put_env(\"FOO=BAR\", \"BAZ\")\n end\n end\n\n test \"put_env/2\" do\n System.put_env(%{@test_var => \"MAP_STRING\"})\n assert System.get_env(@test_var) == \"MAP_STRING\"\n\n System.put_env([{String.to_atom(@test_var), \"KW_ATOM\"}])\n assert System.get_env(@test_var) == \"KW_ATOM\"\n\n System.put_env([{String.to_atom(@test_var), nil}])\n assert System.get_env(@test_var) == nil\n end\n\n test \"cmd/2 raises for null bytes\" do\n assert_raise ArgumentError, ~r\"cannot execute System.cmd/3 for program with null byte\", fn ->\n System.cmd(\"null\\0byte\", [])\n end\n end\n\n test \"cmd/3 raises with non-binary arguments\" do\n assert_raise ArgumentError, ~r\"all arguments for System.cmd/3 must be binaries\", fn ->\n System.cmd(\"ls\", [~c\"/usr\"])\n end\n end\n\n describe \"Windows\" do\n @describetag :windows\n\n test \"cmd/2\" do\n assert {\"hello\\r\\n\", 0} = System.cmd(\"cmd\", ~w[/c echo hello])\n end\n\n test \"cmd/3 (with options)\" do\n opts = [\n into: [],\n cd: File.cwd!(),\n env: %{\"foo\" => \"bar\", \"baz\" => nil},\n arg0: \"echo\",\n stderr_to_stdout: true,\n parallelism: true,\n use_stdio: true\n ]\n\n assert {[\"hello\\r\\n\"], 0} = System.cmd(\"cmd\", ~w[/c echo hello], opts)\n end\n\n @echo \"echo-elixir-test\"\n @tag :tmp_dir\n test \"cmd/3 with absolute and relative paths\", config do\n echo = Path.join(config.tmp_dir, @echo)\n File.mkdir_p!(Path.dirname(echo))\n File.ln_s!(System.find_executable(\"cmd\"), echo)\n\n File.cd!(Path.dirname(echo), fn ->\n # There is a bug in OTP where find_executable is finding\n # entries on the current directory. If this is the case,\n # we should avoid the assertion below.\n if !System.find_executable(@echo) do\n assert :enoent = catch_error(System.cmd(@echo, ~w[/c echo hello]))\n end\n\n assert {\"hello\\r\\n\", 0} =\n System.cmd(Path.join(File.cwd!(), @echo), ~w[/c echo hello], [{:arg0, \"echo\"}])\n end)\n end\n\n test \"shell/1\" do\n assert {\"hello\\r\\n\", 0} = System.shell(\"echo hello\")\n end\n\n test \"shell/2 (with options)\" do\n opts = [\n into: [],\n cd: File.cwd!(),\n env: %{\"foo\" => \"bar\", \"baz\" => nil},\n stderr_to_stdout: true,\n parallelism: true,\n use_stdio: true\n ]\n\n assert {[\"bar\\r\\n\"], 0} = System.shell(\"echo %foo%\", opts)\n end\n end\n\n describe \"Unix\" do\n @describetag :unix\n\n test \"cmd/2\" do\n assert {\"hello\\n\", 0} = System.cmd(\"echo\", [\"hello\"])\n end\n\n test \"cmd/3 (with options)\" do\n opts = [\n into: [],\n cd: File.cwd!(),\n env: %{\"foo\" => \"bar\", \"baz\" => nil},\n arg0: \"echo\",\n stderr_to_stdout: true,\n parallelism: true,\n use_stdio: true\n ]\n\n assert {[\"hello\\n\"], 0} = System.cmd(\"echo\", [\"hello\"], opts)\n end\n\n test \"cmd/3 (can't use `use_stdio: false, stderr_to_stdout: true`)\" do\n opts = [\n into: [],\n cd: File.cwd!(),\n env: %{\"foo\" => \"bar\", \"baz\" => nil},\n arg0: \"echo\",\n stderr_to_stdout: true,\n use_stdio: false\n ]\n\n message = ~r\"cannot use \\\"stderr_to_stdout: true\\\" and \\\"use_stdio: false\\\"\"\n\n assert_raise ArgumentError, message, fn ->\n System.cmd(\"echo\", [\"hello\"], opts)\n end\n end\n\n test \"cmd/3 by line\" do\n assert {[\"hello\", \"world\"], 0} =\n System.cmd(\"echo\", [\"hello\\nworld\"], into: [], lines: 1024)\n\n assert {[\"hello\", \"world\"], 0} =\n System.cmd(\"echo\", [\"-n\", \"hello\\nworld\"], into: [], lines: 3)\n end\n\n @echo \"echo-elixir-test\"\n @tag :tmp_dir\n test \"cmd/3 with absolute and relative paths\", config do\n echo = Path.join(config.tmp_dir, @echo)\n File.mkdir_p!(Path.dirname(echo))\n File.ln_s!(System.find_executable(\"echo\"), echo)\n\n File.cd!(Path.dirname(echo), fn ->\n # There is a bug in OTP where find_executable is finding\n # entries on the current directory. If this is the case,\n # we should avoid the assertion below.\n if !System.find_executable(@echo) do\n assert :enoent = catch_error(System.cmd(@echo, [\"hello\"]))\n end\n\n assert {\"hello\\n\", 0} =\n System.cmd(Path.join(File.cwd!(), @echo), [\"hello\"], [{:arg0, \"echo\"}])\n end)\n end\n\n test \"shell/1\" do\n assert {\"hello\\n\", 0} = System.shell(\"echo hello\")\n end\n\n test \"shell/1 with interpolation\" do\n assert {\"1\\n2\\n\", 0} = System.shell(\"x=1; echo $x; echo '2'\")\n end\n\n test \"shell/1 with empty string\" do\n assert {\"\", 0} = System.shell(\"\")\n assert {\"\", 0} = System.shell(\" \")\n end\n\n @tag timeout: 1_000\n test \"shell/1 returns when command awaits input\" do\n assert {\"\", 0} = System.shell(\"cat\", close_stdin: true)\n end\n\n test \"shell/1 with comment\" do\n assert {\"1\\n\", 0} = System.shell(\"echo '1' # comment\")\n end\n\n test \"shell/2 (with options)\" do\n opts = [\n into: [],\n cd: File.cwd!(),\n env: %{\"foo\" => \"bar\", \"baz\" => nil},\n stderr_to_stdout: true,\n use_stdio: true\n ]\n\n assert {[\"bar\\n\"], 0} = System.shell(\"echo $foo\", opts)\n end\n end\n\n @tag :unix\n test \"vm signals\" do\n assert System.trap_signal(:sigquit, :example, fn -> :ok end) == {:ok, :example}\n assert System.trap_signal(:sigquit, :example, fn -> :ok end) == {:error, :already_registered}\n assert {:ok, ref} = System.trap_signal(:sigquit, fn -> :ok end)\n\n assert System.untrap_signal(:sigquit, :example) == :ok\n assert System.trap_signal(:sigquit, :example, fn -> :ok end) == {:ok, :example}\n assert System.trap_signal(:sigquit, ref, fn -> :ok end) == {:error, :already_registered}\n\n assert System.untrap_signal(:sigusr1, :example) == {:error, :not_found}\n assert System.untrap_signal(:sigquit, :example) == :ok\n assert System.untrap_signal(:sigquit, :example) == {:error, :not_found}\n assert System.untrap_signal(:sigquit, ref) == :ok\n assert System.untrap_signal(:sigquit, ref) == {:error, :not_found}\n end\n\n @tag :unix\n test \"os signals\" do\n parent = self()\n\n assert System.trap_signal(:sighup, :example, fn ->\n send(parent, :sighup_called)\n :ok\n end) == {:ok, :example}\n\n {\"\", 0} = System.cmd(\"kill\", [\"-s\", \"hup\", System.pid()])\n\n assert_receive :sighup_called\n after\n System.untrap_signal(:sighup, :example)\n end\n\n test \"find_executable/1\" do\n assert System.find_executable(\"erl\")\n assert is_binary(System.find_executable(\"erl\"))\n assert !System.find_executable(\"does-not-really-exist-from-elixir\")\n\n message = ~r\"cannot execute System.find_executable/1 for program with null byte\"\n\n assert_raise ArgumentError, message, fn ->\n System.find_executable(\"null\\0byte\")\n end\n end\n\n test \"monotonic_time/0\" do\n assert is_integer(System.monotonic_time())\n end\n\n test \"monotonic_time/1\" do\n assert is_integer(System.monotonic_time(:nanosecond))\n assert abs(System.monotonic_time(:microsecond)) < abs(System.monotonic_time(:nanosecond))\n end\n\n test \"system_time/0\" do\n assert is_integer(System.system_time())\n end\n\n test \"system_time/1\" do\n assert is_integer(System.system_time(:nanosecond))\n assert abs(System.system_time(:microsecond)) < abs(System.system_time(:nanosecond))\n end\n\n test \"time_offset/0 and time_offset/1\" do\n assert is_integer(System.time_offset())\n assert is_integer(System.time_offset(:second))\n end\n\n test \"os_time/0\" do\n assert is_integer(System.os_time())\n end\n\n test \"os_time/1\" do\n assert is_integer(System.os_time(:nanosecond))\n assert abs(System.os_time(:microsecond)) < abs(System.os_time(:nanosecond))\n end\n\n test \"unique_integer/0 and unique_integer/1\" do\n assert is_integer(System.unique_integer())\n assert System.unique_integer([:positive]) > 0\n\n assert System.unique_integer([:positive, :monotonic]) <\n System.unique_integer([:positive, :monotonic])\n end\n\n test \"convert_time_unit/3\" do\n time = System.monotonic_time(:nanosecond)\n assert abs(System.convert_time_unit(time, :nanosecond, :microsecond)) < abs(time)\n end\n\n test \"schedulers/0\" do\n assert System.schedulers() >= 1\n end\n\n test \"schedulers_online/0\" do\n assert System.schedulers_online() >= 1\n end\n\n test \"otp_release/0\" do\n assert is_binary(System.otp_release())\n end\nend\n" }, { "path": "lib/elixir/test/elixir/task/supervisor_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"../test_helper.exs\", __DIR__)\n\ndefmodule Task.SupervisorTest do\n use ExUnit.Case\n\n @moduletag :capture_log\n\n setup do\n {:ok, pid} = Task.Supervisor.start_link()\n {:ok, supervisor: pid}\n end\n\n def wait_and_send(caller, atom) do\n send(caller, :ready)\n receive do: (true -> true)\n send(caller, atom)\n end\n\n def sleep(number) do\n Process.sleep(number)\n number\n end\n\n test \"can be supervised directly\", config do\n modules = [{Task.Supervisor, name: config.test}]\n assert {:ok, _} = Supervisor.start_link(modules, strategy: :one_for_one)\n assert Process.whereis(config.test)\n end\n\n test \"start with spawn_opt\" do\n {:ok, pid} = Task.Supervisor.start_link(spawn_opt: [priority: :high])\n assert Process.info(pid, :priority) == {:priority, :high}\n end\n\n test \"multiple supervisors can be supervised and identified with simple child spec\" do\n {:ok, _} = Registry.start_link(keys: :unique, name: TaskSup.Registry)\n\n children = [\n {Task.Supervisor, strategy: :one_for_one, name: :simple_name},\n {Task.Supervisor, strategy: :one_for_one, name: {:global, :global_name}},\n {Task.Supervisor,\n strategy: :one_for_one, name: {:via, Registry, {TaskSup.Registry, \"via_name\"}}}\n ]\n\n assert {:ok, supsup} = Supervisor.start_link(children, strategy: :one_for_one)\n\n assert {:ok, no_name_dynsup} =\n Supervisor.start_child(supsup, {Task.Supervisor, strategy: :one_for_one})\n\n assert Task.Supervisor.children(:simple_name) == []\n assert Task.Supervisor.children({:global, :global_name}) == []\n assert Task.Supervisor.children({:via, Registry, {TaskSup.Registry, \"via_name\"}}) == []\n assert Task.Supervisor.children(no_name_dynsup) == []\n\n assert Supervisor.start_child(supsup, {Task.Supervisor, strategy: :one_for_one}) ==\n {:error, {:already_started, no_name_dynsup}}\n end\n\n test \"counts and returns children\", config do\n assert Task.Supervisor.children(config[:supervisor]) == []\n\n assert Supervisor.count_children(config[:supervisor]) ==\n %{active: 0, specs: 0, supervisors: 0, workers: 0}\n\n assert DynamicSupervisor.count_children(config[:supervisor]) ==\n %{active: 0, specs: 0, supervisors: 0, workers: 0}\n end\n\n describe \"async/1\" do\n test \"spawns tasks under the supervisor\", config do\n parent = self()\n fun = fn -> wait_and_send(parent, :done) end\n task = Task.Supervisor.async(config[:supervisor], fun)\n assert Task.Supervisor.children(config[:supervisor]) == [task.pid]\n\n # Assert the struct\n assert task.__struct__ == Task\n assert is_pid(task.pid)\n assert is_reference(task.ref)\n\n # Assert the link\n {:links, links} = Process.info(self(), :links)\n assert task.pid in links\n\n receive do: (:ready -> :ok)\n\n # Assert the initial call\n {:name, fun_name} = Function.info(fun, :name)\n assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid)\n\n # Run the task\n send(task.pid, true)\n\n # Assert response and monitoring messages\n ref = task.ref\n assert_receive {^ref, :done}\n assert_receive {:DOWN, ^ref, _, _, :normal}\n end\n\n test \"with custom shutdown\", config do\n Process.flag(:trap_exit, true)\n parent = self()\n\n fun = fn -> wait_and_send(parent, :done) end\n %{pid: pid} = Task.Supervisor.async(config[:supervisor], fun, shutdown: :brutal_kill)\n\n Process.exit(config[:supervisor], :shutdown)\n assert_receive {:DOWN, _, _, ^pid, :killed}\n end\n\n test \"raises when :max_children is reached\" do\n {:ok, sup} = Task.Supervisor.start_link(max_children: 1)\n Task.Supervisor.async(sup, fn -> Process.sleep(:infinity) end)\n\n assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->\n Task.Supervisor.async(sup, fn -> :ok end)\n end\n end\n\n test \"with $callers\", config do\n sup = config[:supervisor]\n grandparent = self()\n\n Task.Supervisor.async(sup, fn ->\n parent = self()\n assert Process.get(:\"$callers\") == [grandparent]\n assert Process.get(:\"$ancestors\") == [sup, grandparent]\n\n Task.Supervisor.async(sup, fn ->\n assert Process.get(:\"$callers\") == [parent, grandparent]\n assert Process.get(:\"$ancestors\") == [sup, grandparent]\n end)\n |> Task.await()\n end)\n |> Task.await()\n end\n end\n\n test \"async/3\", config do\n args = [self(), :done]\n task = Task.Supervisor.async(config[:supervisor], __MODULE__, :wait_and_send, args)\n assert Task.Supervisor.children(config[:supervisor]) == [task.pid]\n\n receive do: (:ready -> :ok)\n assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid)\n\n send(task.pid, true)\n assert task.__struct__ == Task\n assert task.mfa == {__MODULE__, :wait_and_send, 2}\n assert Task.await(task) == :done\n end\n\n describe \"async_nolink/1\" do\n test \"spawns a task under the supervisor without linking to the caller\", config do\n parent = self()\n fun = fn -> wait_and_send(parent, :done) end\n task = Task.Supervisor.async_nolink(config[:supervisor], fun)\n assert Task.Supervisor.children(config[:supervisor]) == [task.pid]\n\n # Assert the struct\n assert task.__struct__ == Task\n assert is_pid(task.pid)\n assert is_reference(task.ref)\n assert task.mfa == {:erlang, :apply, 2}\n\n # Refute the link\n {:links, links} = Process.info(self(), :links)\n refute task.pid in links\n\n receive do: (:ready -> :ok)\n\n # Assert the initial call\n {:name, fun_name} = Function.info(fun, :name)\n assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid)\n\n # Run the task\n send(task.pid, true)\n\n # Assert response and monitoring messages\n ref = task.ref\n assert_receive {^ref, :done}\n assert_receive {:DOWN, ^ref, _, _, :normal}\n end\n\n test \"with custom shutdown\", config do\n Process.flag(:trap_exit, true)\n parent = self()\n\n fun = fn -> wait_and_send(parent, :done) end\n %{pid: pid} = Task.Supervisor.async_nolink(config[:supervisor], fun, shutdown: :brutal_kill)\n\n Process.exit(config[:supervisor], :shutdown)\n assert_receive {:DOWN, _, _, ^pid, :killed}\n end\n\n test \"raises when :max_children is reached\" do\n {:ok, sup} = Task.Supervisor.start_link(max_children: 1)\n\n Task.Supervisor.async_nolink(sup, fn -> Process.sleep(:infinity) end)\n\n assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->\n Task.Supervisor.async_nolink(sup, fn -> :ok end)\n end\n end\n end\n\n test \"async_nolink/3\", config do\n args = [self(), :done]\n task = Task.Supervisor.async_nolink(config[:supervisor], __MODULE__, :wait_and_send, args)\n assert Task.Supervisor.children(config[:supervisor]) == [task.pid]\n\n receive do: (:ready -> :ok)\n assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid)\n\n send(task.pid, true)\n assert task.__struct__ == Task\n assert task.mfa == {__MODULE__, :wait_and_send, 2}\n assert Task.await(task) == :done\n end\n\n test \"start_child/1\", config do\n parent = self()\n fun = fn -> wait_and_send(parent, :done) end\n {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], fun)\n assert Task.Supervisor.children(config[:supervisor]) == [pid]\n\n {:links, links} = Process.info(self(), :links)\n refute pid in links\n\n receive do: (:ready -> :ok)\n {:name, fun_name} = Function.info(fun, :name)\n assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(pid)\n\n send(pid, true)\n assert_receive :done\n end\n\n test \"start_child/3\", config do\n args = [self(), :done]\n\n {:ok, pid} =\n Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, args)\n\n assert Task.Supervisor.children(config[:supervisor]) == [pid]\n\n {:links, links} = Process.info(self(), :links)\n refute pid in links\n\n receive do: (:ready -> :ok)\n assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(pid)\n\n send(pid, true)\n assert_receive :done\n end\n\n test \"start_child/1 with custom shutdown\", config do\n Process.flag(:trap_exit, true)\n parent = self()\n\n fun = fn -> wait_and_send(parent, :done) end\n {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], fun, shutdown: :brutal_kill)\n\n Process.monitor(pid)\n Process.exit(config[:supervisor], :shutdown)\n assert_receive {:DOWN, _, _, ^pid, :killed}\n end\n\n test \"start_child/1 with custom restart\", config do\n parent = self()\n\n fun = fn -> wait_and_send(parent, :done) end\n {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], fun, restart: :permanent)\n\n assert_receive :ready\n Process.monitor(pid)\n Process.exit(pid, :shutdown)\n assert_receive {:DOWN, _, _, ^pid, :shutdown}\n assert_receive :ready\n end\n\n test \"start_child/1 with $callers\", config do\n sup = config[:supervisor]\n grandparent = self()\n\n Task.Supervisor.start_child(sup, fn ->\n parent = self()\n assert Process.get(:\"$callers\") == [grandparent]\n assert Process.get(:\"$ancestors\") == [sup, grandparent]\n\n Task.Supervisor.start_child(sup, fn ->\n assert Process.get(:\"$callers\") == [parent, grandparent]\n assert Process.get(:\"$ancestors\") == [sup, grandparent]\n send(grandparent, :done)\n end)\n end)\n\n assert_receive :done\n end\n\n test \"terminate_child/2\", config do\n args = [self(), :done]\n\n {:ok, pid} =\n Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, args)\n\n assert Task.Supervisor.children(config[:supervisor]) == [pid]\n assert Task.Supervisor.terminate_child(config[:supervisor], pid) == :ok\n assert Task.Supervisor.children(config[:supervisor]) == []\n assert Task.Supervisor.terminate_child(config[:supervisor], pid) == {:error, :not_found}\n end\n\n describe \"await/1\" do\n test \"demonitors and unalias on timeout\", config do\n task =\n Task.Supervisor.async(config[:supervisor], fn ->\n assert_receive :go\n :done\n end)\n\n assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}\n new_ref = Process.monitor(task.pid)\n old_ref = task.ref\n\n send(task.pid, :go)\n assert_receive {:DOWN, ^new_ref, _, _, _}\n refute_received {^old_ref, :done}\n refute_received {:DOWN, ^old_ref, _, _, _}\n end\n\n test \"exits on task throw\", config do\n Process.flag(:trap_exit, true)\n task = Task.Supervisor.async(config[:supervisor], fn -> throw(:unknown) end)\n\n assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =\n catch_exit(Task.await(task))\n end\n\n test \"exits on task error\", config do\n Process.flag(:trap_exit, true)\n task = Task.Supervisor.async(config[:supervisor], fn -> raise \"oops\" end)\n assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))\n end\n\n test \"exits on task exit\", config do\n Process.flag(:trap_exit, true)\n task = Task.Supervisor.async(config[:supervisor], fn -> exit(:unknown) end)\n assert {:unknown, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))\n end\n end\n\n describe \"async_stream\" do\n @opts []\n test \"streams an enumerable with fun\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream(1..4, &sleep/1, @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"streams an enumerable with mfa\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream(1..4, __MODULE__, :sleep, [], @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"streams an enumerable without leaking tasks\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream(1..4, &sleep/1, @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n\n refute_received _\n end\n\n test \"streams an enumerable with slowest first\", %{supervisor: supervisor} do\n Process.flag(:trap_exit, true)\n\n assert supervisor\n |> Task.Supervisor.async_stream(4..1//-1, &sleep/1, @opts)\n |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1]\n end\n\n test \"streams an enumerable with exits\", %{supervisor: supervisor} do\n Process.flag(:trap_exit, true)\n\n assert supervisor\n |> Task.Supervisor.async_stream(1..4, &yield_and_exit(Integer.to_string(&1)), @opts)\n |> Enum.to_list() == [exit: \"1\", exit: \"2\", exit: \"3\", exit: \"4\"]\n end\n\n test \"shuts down unused tasks\", %{supervisor: supervisor} do\n collection = [0, :infinity, :infinity, :infinity]\n\n assert supervisor\n |> Task.Supervisor.async_stream(collection, &sleep/1, @opts)\n |> Enum.take(1) == [ok: 0]\n\n assert Process.info(self(), :links) == {:links, [supervisor]}\n end\n\n test \"shuts down unused tasks without leaking messages\", %{supervisor: supervisor} do\n collection = [0, :infinity, :infinity, :infinity]\n\n assert supervisor\n |> Task.Supervisor.async_stream(collection, &sleep/1, @opts)\n |> Enum.take(1) == [ok: 0]\n\n refute_received _\n end\n\n test \"raises an error if :max_children is reached with clean stream shutdown\",\n %{supervisor: unused_supervisor} do\n {:ok, supervisor} = Task.Supervisor.start_link(max_children: 1)\n collection = [:infinity, :infinity, :infinity]\n\n assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->\n supervisor\n |> Task.Supervisor.async_stream(collection, &sleep/1, max_concurrency: 2)\n |> Enum.to_list()\n end\n\n {:links, links} = Process.info(self(), :links)\n assert MapSet.new(links) == MapSet.new([unused_supervisor, supervisor])\n refute_received _\n end\n\n test \"with $callers\", config do\n sup = config[:supervisor]\n grandparent = self()\n\n Task.Supervisor.async_stream(sup, [1], fn 1 ->\n parent = self()\n assert Process.get(:\"$callers\") == [grandparent]\n assert Process.get(:\"$ancestors\") == [sup, grandparent]\n\n Task.Supervisor.async_stream(sup, [1], fn 1 ->\n assert Process.get(:\"$callers\") == [parent, grandparent]\n assert Process.get(:\"$ancestors\") == [sup, grandparent]\n send(grandparent, :done)\n end)\n |> Stream.run()\n end)\n |> Stream.run()\n\n assert_receive :done\n end\n\n test \"consuming from another process\", config do\n parent = self()\n stream = Task.Supervisor.async_stream(config[:supervisor], [1, 2, 3], &send(parent, &1))\n Task.start(Stream, :run, [stream])\n assert_receive 1\n assert_receive 2\n assert_receive 3\n end\n\n test \"with timeout and :zip_input_on_exit set to true\", %{supervisor: supervisor} do\n opts = Keyword.merge(@opts, zip_input_on_exit: true, on_timeout: :kill_task, timeout: 50)\n\n assert supervisor\n |> Task.Supervisor.async_stream([1, 100], &sleep/1, opts)\n |> Enum.to_list() == [ok: 1, exit: {100, :timeout}]\n end\n\n test \"with outer halt on failure and :zip_input_on_exit\", %{supervisor: supervisor} do\n Process.flag(:trap_exit, true)\n opts = Keyword.merge(@opts, zip_input_on_exit: true)\n\n assert supervisor\n |> Task.Supervisor.async_stream(1..8, &exit/1, opts)\n |> Enum.take(4) == [exit: {1, 1}, exit: {2, 2}, exit: {3, 3}, exit: {4, 4}]\n end\n\n test \"does not allow streaming with invalid :shutdown\", %{supervisor: supervisor} do\n message = \":shutdown must be either a positive integer or :brutal_kill\"\n\n assert_raise ArgumentError, message, fn ->\n Task.Supervisor.async_stream(supervisor, [], fn _ -> :ok end, shutdown: :unknown)\n end\n end\n end\n\n describe \"async_stream_nolink\" do\n @opts [max_concurrency: 4]\n\n test \"streams an enumerable with fun\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream_nolink(1..4, &sleep/1, @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"streams an enumerable with mfa\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream_nolink(1..4, __MODULE__, :sleep, [], @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"streams an enumerable without leaking tasks\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream_nolink(1..4, &sleep/1, @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n\n refute_received _\n end\n\n test \"streams an enumerable with slowest first\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream_nolink(4..1//-1, &sleep/1, @opts)\n |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1]\n end\n\n test \"streams an enumerable with exits\", %{supervisor: supervisor} do\n assert supervisor\n |> Task.Supervisor.async_stream_nolink(1..4, &yield_and_exit/1, @opts)\n |> Enum.to_list() == [exit: 1, exit: 2, exit: 3, exit: 4]\n end\n\n test \"shuts down unused tasks\", %{supervisor: supervisor} do\n collection = [0, :infinity, :infinity, :infinity]\n\n assert supervisor\n |> Task.Supervisor.async_stream_nolink(collection, &sleep/1, @opts)\n |> Enum.take(1) == [ok: 0]\n\n assert Process.info(self(), :links) == {:links, [supervisor]}\n end\n\n test \"shuts down unused tasks without leaking messages\", %{supervisor: supervisor} do\n collection = [0, :infinity, :infinity, :infinity]\n\n assert supervisor\n |> Task.Supervisor.async_stream_nolink(collection, &sleep/1, @opts)\n |> Enum.take(1) == [ok: 0]\n\n refute_received _\n end\n\n test \"raises an error if :max_children is reached with clean stream shutdown\",\n %{supervisor: unused_supervisor} do\n {:ok, supervisor} = Task.Supervisor.start_link(max_children: 1)\n collection = [:infinity, :infinity, :infinity]\n\n assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->\n supervisor\n |> Task.Supervisor.async_stream_nolink(collection, &sleep/1, max_concurrency: 2)\n |> Enum.to_list()\n end\n\n {:links, links} = Process.info(self(), :links)\n assert MapSet.new(links) == MapSet.new([unused_supervisor, supervisor])\n refute_received _\n end\n end\n\n def yield_and_exit(value) do\n # We call yield first so we give the parent a chance to monitor\n :erlang.yield()\n :erlang.exit(value)\n end\nend\n" }, { "path": "lib/elixir/test/elixir/task_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule TaskTest do\n use ExUnit.Case\n doctest Task\n @moduletag :capture_log\n\n def wait_and_send(caller, atom) do\n send(caller, :ready)\n receive do: (true -> true)\n send(caller, atom)\n end\n\n defp create_task_in_other_process do\n caller = self()\n spawn(fn -> send(caller, Task.async(fn -> nil end)) end)\n receive do: (task -> task)\n end\n\n defp create_dummy_task(reason) do\n {pid, ref} = spawn_monitor(Kernel, :exit, [reason])\n\n receive do\n {:DOWN, ^ref, _, _, _} ->\n %Task{ref: ref, pid: pid, owner: self(), mfa: {__MODULE__, :create_dummy_task, 1}}\n end\n end\n\n def sleep(number) do\n Process.sleep(number)\n number\n end\n\n def wait_until_down(task) do\n ref = Process.monitor(task.pid)\n assert_receive {:DOWN, ^ref, _, _, _}\n end\n\n test \"can be supervised directly\" do\n assert {:ok, _} = Supervisor.start_link([{Task, fn -> :ok end}], strategy: :one_for_one)\n end\n\n test \"generates child_spec/1\" do\n defmodule MyTask do\n use Task\n end\n\n assert MyTask.child_spec([:hello]) == %{\n id: MyTask,\n restart: :temporary,\n start: {MyTask, :start_link, [[:hello]]}\n }\n\n defmodule CustomTask do\n use Task, id: :id, restart: :permanent, shutdown: :infinity, start: {:foo, :bar, []}\n end\n\n assert CustomTask.child_spec([:hello]) == %{\n id: :id,\n restart: :permanent,\n shutdown: :infinity,\n start: {:foo, :bar, []}\n }\n end\n\n test \"async/1\" do\n parent = self()\n fun = fn -> wait_and_send(parent, :done) end\n task = Task.async(fun)\n\n # Assert the struct\n assert task.__struct__ == Task\n assert is_pid(task.pid)\n assert is_reference(task.ref)\n assert task.mfa == {:erlang, :apply, 2}\n\n # Assert the link\n {:links, links} = Process.info(self(), :links)\n assert task.pid in links\n\n receive do: (:ready -> :ok)\n\n # Assert the initial call\n {:name, fun_name} = Function.info(fun, :name)\n assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid)\n\n # Run the task\n send(task.pid, true)\n\n # Assert response and monitoring messages\n ref = task.ref\n assert_receive {^ref, :done}\n assert_receive {:DOWN, ^ref, _, _, :normal}\n end\n\n test \"async/3\" do\n task = Task.async(__MODULE__, :wait_and_send, [self(), :done])\n assert task.__struct__ == Task\n assert task.mfa == {__MODULE__, :wait_and_send, 2}\n\n {:links, links} = Process.info(self(), :links)\n assert task.pid in links\n\n receive do: (:ready -> :ok)\n assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid)\n\n send(task.pid, true)\n assert Task.await(task) === :done\n assert_receive :done\n end\n\n test \"async with $callers\" do\n grandparent = self()\n\n Task.async(fn ->\n parent = self()\n assert Process.get(:\"$callers\") == [grandparent]\n\n Task.async(fn ->\n assert Process.get(:\"$callers\") == [parent, grandparent]\n end)\n |> Task.await()\n end)\n |> Task.await()\n end\n\n test \"start/1\" do\n parent = self()\n fun = fn -> wait_and_send(parent, :done) end\n {:ok, pid} = Task.start(fun)\n\n {:links, links} = Process.info(self(), :links)\n refute pid in links\n\n receive do: (:ready -> :ok)\n\n {:name, fun_name} = Function.info(fun, :name)\n assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(pid)\n\n send(pid, true)\n assert_receive :done\n end\n\n test \"start/3\" do\n {:ok, pid} = Task.start(__MODULE__, :wait_and_send, [self(), :done])\n\n {:links, links} = Process.info(self(), :links)\n refute pid in links\n\n receive do: (:ready -> :ok)\n\n assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(pid)\n\n send(pid, true)\n assert_receive :done\n end\n\n test \"completed/1\" do\n task = Task.completed(:done)\n assert task.__struct__ == Task\n\n refute task.pid\n\n assert Task.await(task) == :done\n end\n\n test \"start_link/1\" do\n parent = self()\n fun = fn -> wait_and_send(parent, :done) end\n {:ok, pid} = Task.start_link(fun)\n\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n receive do: (:ready -> :ok)\n\n {:name, fun_name} = Function.info(fun, :name)\n assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(pid)\n\n send(pid, true)\n assert_receive :done\n end\n\n test \"start_link/3\" do\n {:ok, pid} = Task.start_link(__MODULE__, :wait_and_send, [self(), :done])\n\n {:links, links} = Process.info(self(), :links)\n assert pid in links\n\n receive do: (:ready -> :ok)\n\n assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(pid)\n\n send(pid, true)\n assert_receive :done\n end\n\n test \"start_link with $callers\" do\n grandparent = self()\n\n Task.start_link(fn ->\n parent = self()\n assert Process.get(:\"$callers\") == [grandparent]\n\n Task.start_link(fn ->\n assert Process.get(:\"$callers\") == [parent, grandparent]\n send(grandparent, :done)\n end)\n end)\n\n assert_receive :done\n end\n\n describe \"ignore/1\" do\n test \"discards on time replies\" do\n task = Task.async(fn -> :ok end)\n wait_until_down(task)\n assert Task.ignore(task) == {:ok, :ok}\n assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}\n end\n\n test \"discards late replies\" do\n task =\n Task.async(fn ->\n assert_receive(:go)\n :ok\n end)\n\n assert Task.ignore(task) == nil\n send(task.pid, :go)\n wait_until_down(task)\n assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}\n end\n\n test \"discards on-time failures\" do\n Process.flag(:trap_exit, true)\n task = Task.async(fn -> exit(:oops) end)\n wait_until_down(task)\n assert Task.ignore(task) == {:exit, :oops}\n assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}\n end\n\n test \"discards late failures\" do\n task =\n Task.async(fn ->\n assert_receive(:go)\n exit(:oops)\n end)\n\n assert Task.ignore(task) == nil\n send(task.pid, :go)\n wait_until_down(task)\n assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}\n end\n\n test \"exits on :noconnection\" do\n ref = make_ref()\n task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}\n send(self(), {:DOWN, ref, self(), self(), :noconnection})\n assert catch_exit(Task.ignore(task)) |> elem(0) == {:nodedown, node()}\n end\n\n test \"can ignore completed tasks\" do\n assert Task.ignore(Task.completed(:done)) == {:ok, :done}\n end\n end\n\n describe \"await/2\" do\n test \"demonitors and unalias on timeout\" do\n task =\n Task.async(fn ->\n assert_receive :go\n :done\n end)\n\n assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}\n send(task.pid, :go)\n ref = task.ref\n\n wait_until_down(task)\n refute_received {^ref, :done}\n refute_received {:DOWN, ^ref, _, _, _}\n end\n\n test \"exits on timeout\" do\n task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}\n end\n\n test \"exits on normal exit\" do\n task = Task.async(fn -> exit(:normal) end)\n assert catch_exit(Task.await(task)) == {:normal, {Task, :await, [task, 5000]}}\n end\n\n test \"exits on task throw\" do\n Process.flag(:trap_exit, true)\n task = Task.async(fn -> throw(:unknown) end)\n\n assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =\n catch_exit(Task.await(task))\n end\n\n test \"exits on task error\" do\n Process.flag(:trap_exit, true)\n task = Task.async(fn -> raise \"oops\" end)\n assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))\n end\n\n @compile {:no_warn_undefined, :module_does_not_exist}\n\n test \"exits on task undef module error\" do\n Process.flag(:trap_exit, true)\n task = Task.async(&:module_does_not_exist.undef/0)\n\n assert {exit_status, mfa} = catch_exit(Task.await(task))\n assert {:undef, [{:module_does_not_exist, :undef, _, _} | _]} = exit_status\n assert {Task, :await, [^task, 5000]} = mfa\n end\n\n @compile {:no_warn_undefined, {TaskTest, :undef, 0}}\n\n test \"exits on task undef function error\" do\n Process.flag(:trap_exit, true)\n task = Task.async(&TaskTest.undef/0)\n\n assert {{:undef, [{TaskTest, :undef, _, _} | _]}, {Task, :await, [^task, 5000]}} =\n catch_exit(Task.await(task))\n end\n\n test \"exits on task exit\" do\n Process.flag(:trap_exit, true)\n task = Task.async(fn -> exit(:unknown) end)\n assert {:unknown, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))\n end\n\n test \"exits on :noconnection\" do\n ref = make_ref()\n task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}\n send(self(), {:DOWN, ref, :process, self(), :noconnection})\n assert catch_exit(Task.await(task)) |> elem(0) == {:nodedown, node()}\n end\n\n test \"exits on :noconnection from named monitor\" do\n ref = make_ref()\n task = %Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n send(self(), {:DOWN, ref, :process, {:name, :node}, :noconnection})\n assert catch_exit(Task.await(task)) |> elem(0) == {:nodedown, :node}\n end\n\n test \"raises when invoked from a non-owner process\" do\n task = create_task_in_other_process()\n\n message =\n \"task #{inspect(task)} must be queried from the owner \" <>\n \"but was queried from #{inspect(self())}\"\n\n assert_raise ArgumentError, message, fn -> Task.await(task, 1) end\n end\n end\n\n describe \"await_many/2\" do\n test \"returns list of replies\" do\n tasks = for val <- [1, 3, 9], do: Task.async(fn -> val end)\n assert Task.await_many(tasks) == [1, 3, 9]\n end\n\n test \"returns replies in input order ignoring response order\" do\n refs = [ref_1 = make_ref(), ref_2 = make_ref(), ref_3 = make_ref()]\n\n tasks =\n Enum.map(refs, fn ref ->\n %Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n end)\n\n send(self(), {ref_2, 3})\n send(self(), {ref_3, 9})\n send(self(), {ref_1, 1})\n assert Task.await_many(tasks) == [1, 3, 9]\n end\n\n test \"returns an empty list immediately\" do\n assert Task.await_many([]) == []\n end\n\n test \"ignores messages from other processes\" do\n other_ref = make_ref()\n tasks = for val <- [:a, :b], do: Task.async(fn -> val end)\n send(self(), other_ref)\n send(self(), {other_ref, :z})\n send(self(), {:DOWN, other_ref, :process, 1, :goodbye})\n assert Task.await_many(tasks) == [:a, :b]\n assert_received ^other_ref\n assert_received {^other_ref, :z}\n assert_received {:DOWN, ^other_ref, :process, 1, :goodbye}\n end\n\n test \"ignores additional messages after reply\" do\n refs = [ref_1 = make_ref(), ref_2 = make_ref()]\n\n tasks =\n Enum.map(refs, fn ref ->\n %Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n end)\n\n send(self(), {ref_2, :b})\n send(self(), {ref_2, :other})\n send(self(), {ref_1, :a})\n assert Task.await_many(tasks) == [:a, :b]\n assert_received {^ref_2, :other}\n end\n\n test \"exits on timeout\" do\n tasks = [Task.async(fn -> Process.sleep(:infinity) end)]\n assert catch_exit(Task.await_many(tasks, 0)) == {:timeout, {Task, :await_many, [tasks, 0]}}\n end\n\n test \"exits with same reason when task exits\" do\n tasks = [Task.async(fn -> exit(:normal) end)]\n assert catch_exit(Task.await_many(tasks)) == {:normal, {Task, :await_many, [tasks, 5000]}}\n end\n\n test \"exits immediately when any task exits\" do\n tasks = [\n Task.async(fn -> Process.sleep(:infinity) end),\n Task.async(fn -> exit(:normal) end)\n ]\n\n assert catch_exit(Task.await_many(tasks)) == {:normal, {Task, :await_many, [tasks, 5000]}}\n end\n\n test \"exits immediately when any task crashes\" do\n Process.flag(:trap_exit, true)\n\n tasks = [\n Task.async(fn -> Process.sleep(:infinity) end),\n Task.async(fn -> exit(:unknown) end)\n ]\n\n assert catch_exit(Task.await_many(tasks)) == {:unknown, {Task, :await_many, [tasks, 5000]}}\n\n # Make sure all monitors are cleared up afterwards too\n Enum.each(tasks, &Process.exit(&1.pid, :kill))\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"exits immediately when any task throws\" do\n Process.flag(:trap_exit, true)\n\n tasks = [\n Task.async(fn -> Process.sleep(:infinity) end),\n Task.async(fn -> throw(:unknown) end)\n ]\n\n assert {{{:nocatch, :unknown}, _}, {Task, :await_many, [^tasks, 5000]}} =\n catch_exit(Task.await_many(tasks))\n end\n\n test \"exits immediately on any task error\" do\n Process.flag(:trap_exit, true)\n\n tasks = [\n Task.async(fn -> Process.sleep(:infinity) end),\n Task.async(fn -> raise \"oops\" end)\n ]\n\n assert {{%RuntimeError{}, _}, {Task, :await_many, [^tasks, 5000]}} =\n catch_exit(Task.await_many(tasks))\n end\n\n test \"exits immediately on :noconnection\" do\n tasks = [\n Task.async(fn -> Process.sleep(:infinity) end),\n %Task{ref: ref = make_ref(), owner: self(), pid: self(), mfa: {__MODULE__, :test, 1}}\n ]\n\n send(self(), {:DOWN, ref, :process, self(), :noconnection})\n assert catch_exit(Task.await_many(tasks)) |> elem(0) == {:nodedown, node()}\n end\n\n test \"exits immediately on :noconnection from named monitor\" do\n tasks = [\n Task.async(fn -> Process.sleep(:infinity) end),\n %Task{ref: ref = make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n ]\n\n send(self(), {:DOWN, ref, :process, {:name, :node}, :noconnection})\n assert catch_exit(Task.await_many(tasks)) |> elem(0) == {:nodedown, :node}\n end\n\n test \"raises when invoked from a non-owner process\" do\n tasks = [\n Task.async(fn -> Process.sleep(:infinity) end),\n bad_task = create_task_in_other_process()\n ]\n\n message =\n \"task #{inspect(bad_task)} must be queried from the owner \" <>\n \"but was queried from #{inspect(self())}\"\n\n assert_raise ArgumentError, message, fn -> Task.await_many(tasks, 1) end\n end\n end\n\n describe \"yield/2\" do\n test \"returns {:ok, result} when reply and :DOWN in message queue\" do\n task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, self(), :abnormal})\n assert Task.yield(task, 0) == {:ok, :result}\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns nil on timeout\" do\n task = %Task{ref: make_ref(), pid: nil, owner: self(), mfa: {__MODULE__, :test, 1}}\n assert Task.yield(task, 0) == nil\n end\n\n test \"return exit on normal exit\" do\n task = Task.async(fn -> exit(:normal) end)\n assert Task.yield(task) == {:exit, :normal}\n end\n\n test \"exits on :noconnection\" do\n ref = make_ref()\n task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}\n send(self(), {:DOWN, ref, self(), self(), :noconnection})\n assert catch_exit(Task.yield(task)) |> elem(0) == {:nodedown, node()}\n end\n\n test \"raises when invoked from a non-owner process\" do\n task = create_task_in_other_process()\n\n message =\n \"task #{inspect(task)} must be queried from the owner \" <>\n \"but was queried from #{inspect(self())}\"\n\n assert_raise ArgumentError, message, fn -> Task.yield(task, 1) end\n end\n end\n\n describe \"yield_many/2\" do\n test \"returns {:ok, result} when reply and :DOWN in message queue\" do\n task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, self(), :abnormal})\n assert Task.yield_many([task], 0) == [{task, {:ok, :result}}]\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns nil on timeout by default\" do\n task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n assert Task.yield_many([task], 0) == [{task, nil}]\n end\n\n test \"shuts down on timeout when configured\" do\n Process.flag(:trap_exit, true)\n task = Task.async(fn -> Process.sleep(:infinity) end)\n assert Task.yield_many([task], timeout: 0, on_timeout: :kill_task) == [{task, nil}]\n refute Process.alive?(task.pid)\n end\n\n test \"ignores on timeout when configured\" do\n task =\n Task.async(fn ->\n receive do\n :done -> :ok\n end\n end)\n\n assert Task.yield_many([task], timeout: 0, on_timeout: :ignore) == [{task, nil}]\n assert Process.alive?(task.pid)\n\n ref = Process.monitor(task.pid)\n send(task.pid, :done)\n assert_receive {:DOWN, ^ref, _, _, _}\n\n assert Task.yield(task, 0) == nil\n end\n\n test \"return exit on normal exit\" do\n task = Task.async(fn -> exit(:normal) end)\n assert Task.yield_many([task]) == [{task, {:exit, :normal}}]\n end\n\n test \"exits on :noconnection\" do\n ref = make_ref()\n task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}\n send(self(), {:DOWN, ref, :process, self(), :noconnection})\n assert catch_exit(Task.yield_many([task])) |> elem(0) == {:nodedown, node()}\n end\n\n test \"raises when invoked from a non-owner process\" do\n task = create_task_in_other_process()\n\n message =\n \"task #{inspect(task)} must be queried from the owner \" <>\n \"but was queried from #{inspect(self())}\"\n\n assert_raise ArgumentError, message, fn -> Task.yield_many([task], 1) end\n end\n\n test \"returns results from multiple tasks\" do\n task1 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n task2 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n task3 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n\n send(self(), {task1.ref, :result})\n send(self(), {:DOWN, task3.ref, :process, self(), :normal})\n\n assert Task.yield_many([task1, task2, task3], 0) ==\n [{task1, {:ok, :result}}, {task2, nil}, {task3, {:exit, :normal}}]\n end\n\n test \"returns results from multiple tasks with limit\" do\n task1 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n task2 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n task3 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n\n send(self(), {task1.ref, :result})\n send(self(), {:DOWN, task3.ref, :process, self(), :normal})\n\n assert Task.yield_many([task1, task2, task3], limit: 1, timeout: :infinity) ==\n [{task1, {:ok, :result}}, {task2, nil}, {task3, nil}]\n\n assert Task.yield_many([task2, task3], limit: 1, timeout: :infinity) ==\n [{task2, nil}, {task3, {:exit, :normal}}]\n end\n\n test \"returns results from multiple tasks with limit and on timeout\" do\n Process.flag(:trap_exit, true)\n task1 = Task.async(fn -> Process.sleep(:infinity) end)\n task2 = Task.async(fn -> :done end)\n\n assert Task.yield_many([task1, task2], timeout: :infinity, on_timeout: :kill_task, limit: 1) ==\n [{task1, nil}, {task2, {:ok, :done}}]\n\n assert Process.alive?(task1.pid)\n\n assert Task.yield_many([task1], timeout: 0, on_timeout: :kill_task, limit: 1) ==\n [{task1, nil}]\n\n refute Process.alive?(task1.pid)\n end\n\n test \"returns results on infinity timeout\" do\n task1 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n task2 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n task3 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}\n\n send(self(), {task1.ref, :result})\n send(self(), {task2.ref, :result})\n send(self(), {:DOWN, task3.ref, :process, self(), :normal})\n\n assert Task.yield_many([task1, task2, task3], :infinity) ==\n [{task1, {:ok, :result}}, {task2, {:ok, :result}}, {task3, {:exit, :normal}}]\n end\n end\n\n describe \"shutdown/2\" do\n test \"returns {:ok, result} when reply and abnormal :DOWN in message queue\" do\n task = create_dummy_task(:abnormal)\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})\n assert Task.shutdown(task) == {:ok, :result}\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns {:ok, result} when reply and normal :DOWN in message queue\" do\n task = create_dummy_task(:normal)\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, task.pid, :normal})\n assert Task.shutdown(task) == {:ok, :result}\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns {:ok, result} when reply and shut down :DOWN in message queue\" do\n task = create_dummy_task(:shutdown)\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})\n assert Task.shutdown(task) == {:ok, :result}\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns nil on shutting down task\" do\n task = Task.async(:timer, :sleep, [:infinity])\n assert Task.shutdown(task) == nil\n end\n\n test \"returns exit on abnormal :DOWN in message queue\" do\n task = create_dummy_task(:abnormal)\n send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})\n assert Task.shutdown(task) == {:exit, :abnormal}\n end\n\n test \"returns exit on normal :DOWN in message queue\" do\n task = create_dummy_task(:normal)\n send(self(), {:DOWN, task.ref, :process, task.pid, :normal})\n assert Task.shutdown(task) == {:exit, :normal}\n end\n\n test \"returns nil on shutdown :DOWN in message queue\" do\n task = create_dummy_task(:shutdown)\n send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})\n assert Task.shutdown(task) == nil\n end\n\n test \"returns exit on killed :DOWN in message queue\" do\n task = create_dummy_task(:killed)\n send(self(), {:DOWN, task.ref, :process, task.pid, :killed})\n assert Task.shutdown(task) == {:exit, :killed}\n end\n\n test \"exits on noconnection :DOWN in message queue\" do\n task = create_dummy_task(:noconnection)\n send(self(), {:DOWN, task.ref, :process, task.pid, :noconnection})\n\n assert catch_exit(Task.shutdown(task)) ==\n {{:nodedown, node()}, {Task, :shutdown, [task, 5000]}}\n end\n\n test \"ignores if task PID is nil\" do\n ref = make_ref()\n send(self(), {ref, :done})\n\n assert Task.shutdown(%Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}) ==\n {:ok, :done}\n\n ref = make_ref()\n send(self(), {:DOWN, ref, :process, self(), :done})\n\n assert Task.shutdown(%Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}) ==\n {:exit, :done}\n end\n\n test \"raises when invoked from a non-owner process\" do\n task = create_task_in_other_process()\n\n message =\n \"task #{inspect(task)} must be queried from the owner \" <>\n \"but was queried from #{inspect(self())}\"\n\n assert_raise ArgumentError, message, fn -> Task.shutdown(task) end\n end\n\n test \"returns nil on killing task\" do\n caller = self()\n\n task =\n Task.async(fn ->\n Process.flag(:trap_exit, true)\n wait_and_send(caller, :ready)\n Process.sleep(:infinity)\n end)\n\n receive do: (:ready -> :ok)\n\n assert Task.shutdown(task, :brutal_kill) == nil\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns {:exit, :noproc} if task handled\" do\n task = create_dummy_task(:noproc)\n assert Task.shutdown(task) == {:exit, :noproc}\n end\n end\n\n describe \"shutdown/2 with :brutal_kill\" do\n test \"returns {:ok, result} when reply and abnormal :DOWN in message queue\" do\n task = create_dummy_task(:abnormal)\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})\n assert Task.shutdown(task, :brutal_kill) == {:ok, :result}\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns {:ok, result} when reply and normal :DOWN in message queue\" do\n task = create_dummy_task(:normal)\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, task.pid, :normal})\n assert Task.shutdown(task, :brutal_kill) == {:ok, :result}\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns {:ok, result} when reply and shut down :DOWN in message queue\" do\n task = create_dummy_task(:shutdown)\n send(self(), {task.ref, :result})\n send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})\n assert Task.shutdown(task, :brutal_kill) == {:ok, :result}\n refute_received {:DOWN, _, _, _, _}\n end\n\n test \"returns nil on killed :DOWN in message queue\" do\n task = create_dummy_task(:killed)\n send(self(), {:DOWN, task.ref, :process, task.pid, :killed})\n assert Task.shutdown(task, :brutal_kill) == nil\n end\n\n test \"returns exit on abnormal :DOWN in message queue\" do\n task = create_dummy_task(:abnormal)\n send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})\n assert Task.shutdown(task, :brutal_kill) == {:exit, :abnormal}\n end\n\n test \"returns exit on normal :DOWN in message queue\" do\n task = create_dummy_task(:normal)\n send(self(), {:DOWN, task.ref, :process, task.pid, :normal})\n assert Task.shutdown(task, :brutal_kill) == {:exit, :normal}\n end\n\n test \"returns exit on shutdown :DOWN in message queue\" do\n task = create_dummy_task(:shutdown)\n send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})\n assert Task.shutdown(task, :brutal_kill) == {:exit, :shutdown}\n end\n\n test \"exits on noconnection :DOWN in message queue\" do\n task = create_dummy_task(:noconnection)\n send(self(), {:DOWN, task.ref, :process, task.pid, :noconnection})\n\n assert catch_exit(Task.shutdown(task, :brutal_kill)) ==\n {{:nodedown, node()}, {Task, :shutdown, [task, :brutal_kill]}}\n end\n\n test \"returns exit on killing task after shutdown timeout\" do\n caller = self()\n\n task =\n Task.async(fn ->\n Process.flag(:trap_exit, true)\n wait_and_send(caller, :ready)\n Process.sleep(:infinity)\n end)\n\n receive do: (:ready -> :ok)\n assert Task.shutdown(task, 1) == {:exit, :killed}\n end\n\n test \"returns {:exit, :noproc} if task handled\" do\n task = create_dummy_task(:noproc)\n assert Task.shutdown(task, :brutal_kill) == {:exit, :noproc}\n end\n end\n\n describe \"async_stream/2\" do\n test \"timeout\" do\n assert catch_exit([:infinity] |> Task.async_stream(&sleep/1, timeout: 0) |> Enum.to_list()) ==\n {:timeout, {Task.Supervised, :stream, [0]}}\n\n refute_received _\n end\n\n test \"streams an enumerable with ordered: false\" do\n opts = [max_concurrency: 1, ordered: false]\n\n assert 4..1//-1\n |> Task.async_stream(&sleep(&1 * 100), opts)\n |> Enum.to_list() == [ok: 400, ok: 300, ok: 200, ok: 100]\n\n opts = [max_concurrency: 4, ordered: false]\n\n assert 4..1//-1\n |> Task.async_stream(&sleep(&1 * 100), opts)\n |> Enum.to_list() == [ok: 100, ok: 200, ok: 300, ok: 400]\n end\n\n test \"streams an enumerable with ordered: false, on_timeout: :kill_task\" do\n opts = [max_concurrency: 4, ordered: false, on_timeout: :kill_task, timeout: 50]\n\n assert [100, 1, 100, 1]\n |> Task.async_stream(&sleep/1, opts)\n |> Enum.to_list() == [ok: 1, ok: 1, exit: :timeout, exit: :timeout]\n\n refute_received _\n end\n\n test \"streams an enumerable with infinite timeout\" do\n [ok: :ok] = Task.async_stream([1], fn _ -> :ok end, timeout: :infinity) |> Enum.to_list()\n end\n\n test \"does not allow streaming with max_concurrency = 0\" do\n assert_raise ArgumentError, \":max_concurrency must be an integer greater than zero\", fn ->\n Task.async_stream([1], fn _ -> :ok end, max_concurrency: 0)\n end\n end\n\n test \"does not allow streaming with invalid :on_timeout\" do\n assert_raise ArgumentError, \":on_timeout must be either :exit or :kill_task\", fn ->\n Task.async_stream([1], fn _ -> :ok end, on_timeout: :unknown)\n end\n end\n\n test \"does not allow streaming with invalid :timeout\" do\n assert_raise ArgumentError, \":timeout must be either a positive integer or :infinity\", fn ->\n Task.async_stream([1], fn _ -> :ok end, timeout: :unknown)\n end\n end\n\n test \"streams with fake down messages on the inbox\" do\n parent = self()\n\n assert Task.async_stream([:ok], fn :ok ->\n {:links, links} = Process.info(self(), :links)\n\n for link <- links do\n send(link, {:DOWN, make_ref(), :process, parent, :oops})\n end\n\n :ok\n end)\n |> Enum.to_list() == [ok: :ok]\n end\n\n test \"with $callers\" do\n grandparent = self()\n\n Task.async_stream([1], fn 1 ->\n parent = self()\n assert Process.get(:\"$callers\") == [grandparent]\n\n Task.async_stream([1], fn 1 ->\n assert Process.get(:\"$callers\") == [parent, grandparent]\n send(grandparent, :done)\n end)\n |> Stream.run()\n end)\n |> Stream.run()\n\n assert_receive :done\n end\n\n test \"consuming from another process\" do\n parent = self()\n stream = Task.async_stream([1, 2, 3], &send(parent, &1))\n Task.start(Stream, :run, [stream])\n assert_receive 1\n assert_receive 2\n assert_receive 3\n end\n\n test \"wrapping a flat_map/concat with a haltable stream\" do\n result =\n Stream.take([:foo, :bar], 1)\n |> Stream.concat([1, 2])\n |> Task.async_stream(& &1)\n |> Enum.to_list()\n\n assert result == [ok: :foo, ok: 1, ok: 2]\n end\n end\n\n for {desc, concurrency} <- [==: 4, <: 2, >: 8] do\n describe \"async_stream with max_concurrency #{desc} tasks\" do\n @opts [max_concurrency: concurrency]\n\n test \"streams an enumerable with fun\" do\n assert 1..4\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"streams an enumerable with mfa\" do\n assert 1..4\n |> Task.async_stream(__MODULE__, :sleep, [], @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"streams an enumerable without leaking tasks\" do\n assert 1..4\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n\n refute_received _\n end\n\n test \"streams an enumerable with slowest first\" do\n Process.flag(:trap_exit, true)\n\n assert 4..1//-1\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1]\n end\n\n test \"streams an enumerable with exits\" do\n Process.flag(:trap_exit, true)\n\n assert 1..4\n |> Task.async_stream(&exit/1, @opts)\n |> Enum.to_list() == [exit: 1, exit: 2, exit: 3, exit: 4]\n\n refute_received {:EXIT, _, _}\n end\n\n test \"shuts down unused tasks\" do\n assert [0, :infinity, :infinity, :infinity]\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.take(1) == [ok: 0]\n\n assert Process.info(self(), :links) == {:links, []}\n end\n\n test \"shuts down unused tasks without leaking messages\" do\n assert [0, :infinity, :infinity, :infinity]\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.take(1) == [ok: 0]\n\n refute_received _\n end\n\n test \"is zippable on success\" do\n task = 1..4 |> Task.async_stream(&sleep/1, @opts) |> Stream.map(&elem(&1, 1))\n assert Enum.zip(task, task) == [{1, 1}, {2, 2}, {3, 3}, {4, 4}]\n end\n\n test \"is zippable on failure\" do\n Process.flag(:trap_exit, true)\n task = 1..4 |> Task.async_stream(&exit/1, @opts) |> Stream.map(&elem(&1, 1))\n assert Enum.zip(task, task) == [{1, 1}, {2, 2}, {3, 3}, {4, 4}]\n end\n\n test \"is zippable with slowest first\" do\n task = 4..1//-1 |> Task.async_stream(&sleep/1, @opts) |> Stream.map(&elem(&1, 1))\n assert Enum.zip(task, task) == [{4, 4}, {3, 3}, {2, 2}, {1, 1}]\n end\n\n test \"with inner halt on success\" do\n assert 1..8\n |> Stream.take(4)\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"with inner halt on failure\" do\n Process.flag(:trap_exit, true)\n\n assert 1..8\n |> Stream.take(4)\n |> Task.async_stream(&exit/1, @opts)\n |> Enum.to_list() == [exit: 1, exit: 2, exit: 3, exit: 4]\n end\n\n test \"with inner halt and slowest first\" do\n assert 8..1//-1\n |> Stream.take(4)\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.to_list() == [ok: 8, ok: 7, ok: 6, ok: 5]\n end\n\n test \"with outer halt on success\" do\n assert 1..8\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.take(4) == [ok: 1, ok: 2, ok: 3, ok: 4]\n end\n\n test \"with outer halt on failure\" do\n Process.flag(:trap_exit, true)\n\n assert 1..8\n |> Task.async_stream(&exit/1, @opts)\n |> Enum.take(4) == [exit: 1, exit: 2, exit: 3, exit: 4]\n end\n\n test \"with outer halt and slowest first\" do\n assert 8..1//-1\n |> Task.async_stream(&sleep/1, @opts)\n |> Enum.take(4) == [ok: 8, ok: 7, ok: 6, ok: 5]\n end\n\n test \"terminates inner effect\" do\n stream =\n 1..4\n |> Task.async_stream(&sleep/1, @opts)\n |> Stream.transform(fn -> :ok end, fn x, acc -> {[x], acc} end, fn _ ->\n Process.put(:stream_transform, true)\n end)\n\n Process.put(:stream_transform, false)\n assert Enum.to_list(stream) == [ok: 1, ok: 2, ok: 3, ok: 4]\n assert Process.get(:stream_transform)\n end\n\n test \"terminates outer effect\" do\n stream =\n 1..4\n |> Stream.transform(fn -> :ok end, fn x, acc -> {[x], acc} end, fn _ ->\n Process.put(:stream_transform, true)\n end)\n |> Task.async_stream(&sleep/1, @opts)\n\n Process.put(:stream_transform, false)\n assert Enum.to_list(stream) == [ok: 1, ok: 2, ok: 3, ok: 4]\n assert Process.get(:stream_transform)\n end\n\n test \"with :on_timeout set to :kill_task\" do\n opts = Keyword.merge(@opts, on_timeout: :kill_task, timeout: 50)\n\n assert [100, 1, 100, 1]\n |> Task.async_stream(&sleep/1, opts)\n |> Enum.to_list() == [exit: :timeout, ok: 1, exit: :timeout, ok: 1]\n\n refute_received _\n end\n\n test \"with timeout and :zip_input_on_exit set to true\" do\n opts = Keyword.merge(@opts, zip_input_on_exit: true, on_timeout: :kill_task, timeout: 50)\n\n assert [1, 100]\n |> Task.async_stream(&sleep/1, opts)\n |> Enum.to_list() == [ok: 1, exit: {100, :timeout}]\n end\n\n test \"with outer halt on failure and :zip_input_on_exit\" do\n Process.flag(:trap_exit, true)\n opts = Keyword.merge(@opts, zip_input_on_exit: true)\n\n assert 1..8\n |> Task.async_stream(&exit/1, opts)\n |> Enum.take(4) == [exit: {1, 1}, exit: {2, 2}, exit: {3, 3}, exit: {4, 4}]\n end\n end\n end\n\n describe \"default :logger reporter\" do\n setup do\n translator = :logger.get_primary_config().filters[:logger_translator]\n assert :ok = :logger.remove_primary_filter(:logger_translator)\n on_exit(fn -> :logger.add_primary_filter(:logger_translator, translator) end)\n end\n\n test \"logs a terminated task\" do\n parent = self()\n {:ok, pid} = Task.start_link(__MODULE__, :task, [parent])\n\n assert ExUnit.CaptureLog.capture_log(fn ->\n ref = Process.monitor(pid)\n send(pid, :go)\n receive do: ({:DOWN, ^ref, _, _, _} -> :ok)\n end) =~ ~r\"\"\"\n \\[error\\] \\*\\* Task #{inspect(pid)} terminating\n \\*\\* Started from #{inspect(parent)}\n \\*\\* When function == &TaskTest.task/1\n \\*\\* arguments == \\[#PID<\\d+\\.\\d+\\.\\d+>\\]\n \\*\\* Reason for termination ==\\s\n \\*\\* {%RuntimeError{message: \"oops\"},\n \"\"\"\n end\n\n test \"logs a terminated task with a process label\" do\n fun = fn ->\n Process.set_label({:any, \"term\"})\n raise \"oops\"\n end\n\n parent = self()\n {:ok, pid} = Task.start_link(__MODULE__, :task, [parent, fun])\n\n assert ExUnit.CaptureLog.capture_log(fn ->\n ref = Process.monitor(pid)\n send(pid, :go)\n receive do: ({:DOWN, ^ref, _, _, _} -> :ok)\n end) =~ ~r\"\"\"\n \\[error\\] \\*\\* Task #PID<\\d+\\.\\d+\\.\\d+> terminating\n \\*\\* Process Label == {:any, \"term\"}\n \\*\\* Started from #PID<\\d+\\.\\d+\\.\\d+>\n \\*\\* When function == &TaskTest.task/2\n \\*\\* arguments == \\[#PID<\\d+\\.\\d+\\.\\d+>,\n #Function<.+>\\]\n \\*\\* Reason for termination ==\\s\n \\*\\* {%RuntimeError{message: \"oops\"},\n \"\"\"\n end\n end\n\n def task(parent, fun \\\\ fn -> raise \"oops\" end) do\n mon = Process.monitor(parent)\n Process.unlink(parent)\n\n receive do\n :go ->\n fun.()\n\n {:DOWN, ^mon, _, _, _} ->\n exit(:shutdown)\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/test_helper.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\n# Beam files compiled on demand\npath = Path.expand(\"../../tmp/beams\", __DIR__)\nFile.rm_rf!(path)\nFile.mkdir_p!(path)\nCode.prepend_path(path)\n\nApplication.put_env(:elixir, :ansi_enabled, true)\nCode.compiler_options(debug_info: true, infer_signatures: [:elixir])\n\ndefmodule PathHelpers do\n def fixture_path() do\n Path.expand(\"fixtures\", __DIR__)\n end\n\n def tmp_path() do\n Path.expand(\"../../tmp\", __DIR__)\n end\n\n def fixture_path(extra) do\n Path.join(fixture_path(), extra)\n end\n\n def tmp_path(extra) do\n Path.join(tmp_path(), extra)\n end\n\n def elixir(args, executable_extension \\\\ \"\") do\n run_cmd(elixir_executable(executable_extension), args)\n end\n\n def elixir_executable(extension \\\\ \"\") do\n executable_path(\"elixir\", extension)\n end\n\n def elixirc(args, executable_extension \\\\ \"\") do\n run_cmd(elixirc_executable(executable_extension), args)\n end\n\n def elixirc_executable(extension \\\\ \"\") do\n executable_path(\"elixirc\", extension)\n end\n\n def iex(args, executable_extension \\\\ \"\") do\n run_cmd(iex_executable(executable_extension), args)\n end\n\n def iex_executable(extension \\\\ \"\") do\n executable_path(\"iex\", extension)\n end\n\n def write_beam({:module, name, bin, _} = res) do\n File.mkdir_p!(unquote(path))\n beam_path = Path.join(unquote(path), Atom.to_string(name) <> \".beam\")\n File.write!(beam_path, bin)\n\n :code.purge(name)\n :code.delete(name)\n\n res\n end\n\n defp run_cmd(executable, args) do\n ~c\"#{executable} #{IO.chardata_to_string(args)}#{redirect_std_err_on_win()}\"\n |> :os.cmd()\n |> :unicode.characters_to_binary()\n end\n\n defp executable_path(name, extension) do\n Path.expand(\"../../../../bin/#{name}#{extension}\", __DIR__)\n end\n\n if match?({:win32, _}, :os.type()) do\n def windows?, do: true\n def executable_extension, do: \".bat\"\n def redirect_std_err_on_win, do: \" 2>&1\"\n else\n def windows?, do: false\n def executable_extension, do: \"\"\n def redirect_std_err_on_win, do: \"\"\n end\nend\n\ndefmodule CodeFormatterHelpers do\n defmacro assert_same(good, opts \\\\ []) do\n quote bind_quoted: [good: good, opts: opts] do\n assert IO.iodata_to_binary(Code.format_string!(good, opts)) == String.trim(good)\n end\n end\n\n defmacro assert_format(bad, good, opts \\\\ []) do\n quote bind_quoted: [bad: bad, good: good, opts: opts] do\n result = String.trim(good)\n assert IO.iodata_to_binary(Code.format_string!(bad, opts)) == result\n assert IO.iodata_to_binary(Code.format_string!(good, opts)) == result\n end\n end\nend\n\nepmd_exclude = if match?({:win32, _}, :os.type()), do: [epmd: true], else: []\nos_exclude = if PathHelpers.windows?(), do: [unix: true], else: [windows: true]\n\n{line_exclude, line_include} =\n if line = System.get_env(\"LINE\"), do: {[:test], [line: line]}, else: {[], []}\n\ndistributed_exclude =\n if Code.ensure_loaded?(:peer) and Node.alive?() do\n {:ok, _pid, node} = :peer.start(%{name: :secondary})\n true = :erpc.call(node, :code, :set_path, [:code.get_path()])\n {:ok, _} = :erpc.call(node, :application, :ensure_all_started, [:elixir])\n []\n else\n [distributed: true]\n end\n\nsource_exclude =\n if :deterministic in :compile.env_compiler_options() do\n [:requires_source]\n else\n []\n end\n\nCode.require_file(\"../../scripts/cover_record.exs\", __DIR__)\n\ncover_exclude =\n if CoverageRecorder.maybe_record(\"elixir\") do\n [:require_ast]\n else\n []\n end\n\n# OTP 28.1+\nre_import_exclude =\n if Code.ensure_loaded?(:re) and function_exported?(:re, :import, 1) do\n []\n else\n [:re_import]\n end\n\nmaybe_seed_opt = if seed = System.get_env(\"SEED\"), do: [seed: String.to_integer(seed)], else: []\n\nex_unit_opts =\n [\n trace: !!System.get_env(\"TRACE\"),\n exclude:\n epmd_exclude ++\n os_exclude ++\n line_exclude ++\n distributed_exclude ++ source_exclude ++ cover_exclude ++ re_import_exclude,\n include: line_include,\n assert_receive_timeout: String.to_integer(System.get_env(\"ELIXIR_ASSERT_TIMEOUT\", \"300\"))\n ] ++ maybe_seed_opt\n\nExUnit.start(ex_unit_opts)\n" }, { "path": "lib/elixir/test/elixir/tuple_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule TupleTest do\n use ExUnit.Case, async: true\n\n doctest Tuple\n\n # Tuple-related functions in the Kernel module.\n\n test \"Kernel.elem/2\" do\n assert elem({:a, :b, :c}, 1) == :b\n end\n\n test \"Kernel.put_elem/3\" do\n assert put_elem({:a, :b, :c}, 1, :d) == {:a, :d, :c}\n end\n\n test \"keyword syntax is supported in tuple literals\" do\n assert {1, 2, three: :four} == {1, 2, [three: :four]}\n end\n\n test \"optional comma is supported in tuple literals\" do\n assert Code.eval_string(\"{1,}\") == {{1}, []}\n assert Code.eval_string(\"{1, 2, 3,}\") == {{1, 2, 3}, []}\n end\n\n test \"partial application\" do\n assert (&{&1, 2}).(1) == {1, 2}\n assert (&{&1, &2}).(1, 2) == {1, 2}\n assert (&{&2, &1}).(2, 1) == {1, 2}\n end\n\n # Tuple module\n # We check two variants of each function due to inlining.\n\n test \"duplicate/2\" do\n assert Tuple.duplicate(:foo, 0) == {}\n assert Tuple.duplicate(:foo, 3) == {:foo, :foo, :foo}\n\n mod = Tuple\n assert mod.duplicate(:foo, 0) == {}\n assert mod.duplicate(:foo, 3) == {:foo, :foo, :foo}\n end\n\n test \"insert_at/3\" do\n assert Tuple.insert_at({:bar, :baz}, 0, :foo) == {:foo, :bar, :baz}\n\n mod = Tuple\n assert mod.insert_at({:bar, :baz}, 0, :foo) == {:foo, :bar, :baz}\n end\n\n test \"delete_at/2\" do\n assert Tuple.delete_at({:foo, :bar, :baz}, 0) == {:bar, :baz}\n\n mod = Tuple\n assert mod.delete_at({:foo, :bar, :baz}, 0) == {:bar, :baz}\n end\nend\n" }, { "path": "lib/elixir/test/elixir/typespec_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\n# Holds tests for both Kernel.Typespec and Code.Typespec\ndefmodule TypespecTest do\n use ExUnit.Case, async: true\n alias TypespecTest.TypespecSample\n\n defstruct [:hello]\n\n defmacrop test_module(do: block) do\n quote do\n {:module, _, bytecode, _} =\n defmodule TypespecSample do\n unquote(block)\n end\n\n :code.purge(TypespecSample)\n :code.delete(TypespecSample)\n bytecode\n end\n end\n\n defp types(bytecode) do\n bytecode\n |> Code.Typespec.fetch_types()\n |> elem(1)\n |> Enum.sort()\n end\n\n @skip_specs [__info__: 1]\n\n defp specs(bytecode) do\n bytecode\n |> Code.Typespec.fetch_specs()\n |> elem(1)\n |> Enum.reject(fn {sign, _} -> sign in @skip_specs end)\n |> Enum.sort()\n end\n\n defp callbacks(bytecode) do\n bytecode\n |> Code.Typespec.fetch_callbacks()\n |> elem(1)\n |> Enum.sort()\n end\n\n describe \"Kernel.Typespec errors\" do\n test \"invalid type specification\" do\n assert_raise Kernel.TypespecError, ~r\"invalid type specification: my_type = 1\", fn ->\n test_module do\n @type my_type = 1\n end\n end\n end\n\n test \"unexpected expression in typespec\" do\n assert_raise Kernel.TypespecError, ~r\"unexpected expression in typespec: \\\"foobar\\\"\", fn ->\n test_module do\n @type my_type :: \"foobar\"\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"unexpected expression in typespec: integer\\(\\)\\(\\)\",\n fn ->\n test_module do\n @type my_type :: integer()()\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"unexpected expression in typespec: %URI\\.t\\(\\)\\{\\}\",\n fn ->\n test_module do\n @type my_type :: %URI.t(){}\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"unexpected expression in typespec: t\\.Foo\",\n fn ->\n test_module do\n @type my_type :: t.Foo\n end\n end\n end\n\n test \"invalid function specification\" do\n assert_raise Kernel.TypespecError, ~r\"invalid type specification: \\\"not a spec\\\"\", fn ->\n test_module do\n @spec \"not a spec\"\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"invalid type specification: 1 :: 2\", fn ->\n test_module do\n @spec 1 :: 2\n end\n end\n end\n\n test \"undefined type\" do\n assert_raise Kernel.TypespecError, ~r\"type foo/0 undefined\", fn ->\n test_module do\n @type omg :: foo\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"type foo/2 undefined\", fn ->\n test_module do\n @type omg :: foo(atom, integer)\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"type bar/0 undefined\", fn ->\n test_module do\n @spec foo(bar, integer) :: {atom, integer}\n def foo(var1, var2), do: {var1, var2}\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"type foo/0 undefined\", fn ->\n test_module do\n @type omg :: __MODULE__.foo()\n end\n end\n end\n\n test \"redefined type\" do\n assert_raise Kernel.TypespecError,\n ~r\"type foo/0 is already defined in .*test/elixir/typespec_test.exs:138\",\n fn ->\n test_module do\n @type foo :: atom\n @type foo :: integer\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"type foo/2 is already defined in .*test/elixir/typespec_test.exs:148\",\n fn ->\n test_module do\n @type foo :: atom\n @type foo(var1, var2) :: {var1, var2}\n @type foo(x, y) :: {x, y}\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"type foo/0 is already defined in .*test/elixir/typespec_test.exs:157\",\n fn ->\n test_module do\n @type foo :: atom\n @typep foo :: integer\n end\n end\n end\n\n test \"type variable unused (singleton type variable)\" do\n assert_raise Kernel.TypespecError, ~r\"type variable x is used only once\", fn ->\n test_module do\n @type foo(x) :: integer\n end\n end\n end\n\n test \"type variable starting with underscore\" do\n test_module do\n assert @type(foo(_hello) :: integer) == :ok\n end\n end\n\n test \"type variable named _\" do\n assert_raise Kernel.TypespecError, ~r\"type variable '_' is invalid\", fn ->\n test_module do\n @type foo(_) :: integer\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"type variable '_' is invalid\", fn ->\n test_module do\n @type foo(_, _) :: integer\n end\n end\n end\n\n test \"spec for undefined function\" do\n assert_compile_error(~r\"spec for undefined function omg/0\", fn ->\n test_module do\n @spec omg :: atom\n end\n end)\n end\n\n test \"spec variable used only once (singleton type variable)\" do\n assert_raise Kernel.TypespecError, ~r\"type variable x is used only once\", fn ->\n test_module do\n @spec foo(x, integer) :: integer when x: var\n def foo(x, y), do: x + y\n end\n end\n end\n\n test \"spec with ... outside of fn and lists\" do\n assert_raise Kernel.TypespecError, ~r\"... in typespecs is only allowed inside lists\", fn ->\n test_module do\n @spec foo(...) :: :ok\n def foo(x), do: x\n end\n end\n end\n\n test \"invalid optional callback\" do\n assert_compile_error(~r\"invalid optional callback :foo\", fn ->\n test_module do\n @optional_callbacks :foo\n end\n end)\n end\n\n test \"unknown optional callback\" do\n assert_compile_error(~r\"unknown callback foo/1 given as optional callback\", fn ->\n test_module do\n @optional_callbacks foo: 1\n end\n end)\n end\n\n test \"repeated optional callback\" do\n message = ~r\"foo/1 has been specified as optional callback more than once\"\n\n assert_compile_error(message, fn ->\n test_module do\n @callback foo(:ok) :: :ok\n @optional_callbacks foo: 1, foo: 1\n end\n end)\n end\n\n test \"behaviour_info/1 explicitly defined alongside @callback/@macrocallback\" do\n message = ~r\"cannot define @callback attribute for foo/1 when behaviour_info/1\"\n\n assert_compile_error(message, fn ->\n test_module do\n @callback foo(:ok) :: :ok\n def behaviour_info(_), do: []\n end\n end)\n\n message = ~r\"cannot define @macrocallback attribute for foo/1 when behaviour_info/1\"\n\n assert_compile_error(message, fn ->\n test_module do\n @macrocallback foo(:ok) :: :ok\n def behaviour_info(_), do: []\n end\n end)\n end\n\n test \"default is not supported\" do\n assert_raise ArgumentError, fn ->\n test_module do\n @callback hello(num \\\\ 0 :: integer) :: integer\n end\n end\n\n assert_raise ArgumentError, fn ->\n test_module do\n @callback hello(num :: integer \\\\ 0) :: integer\n end\n end\n\n assert_raise ArgumentError, fn ->\n test_module do\n @macrocallback hello(num \\\\ 0 :: integer) :: Macro.t()\n end\n end\n\n assert_raise ArgumentError, fn ->\n test_module do\n @macrocallback hello(num :: integer \\\\ 0) :: Macro.t()\n end\n end\n\n assert_raise ArgumentError, fn ->\n test_module do\n @spec hello(num \\\\ 0 :: integer) :: integer\n end\n end\n\n assert_raise ArgumentError, fn ->\n test_module do\n @spec hello(num :: integer \\\\ 0) :: integer\n end\n end\n end\n\n test \"@spec shows readable error message when return type is missing\" do\n message = ~r\"type specification missing return type: my_fun\\(integer\\)\"\n\n assert_raise Kernel.TypespecError, message, fn ->\n test_module do\n @spec my_fun(integer)\n end\n end\n end\n end\n\n describe \"Kernel.Typespec definitions\" do\n test \"typespec declarations return :ok\" do\n test_module do\n def foo(), do: nil\n\n assert @type(foo :: any()) == :ok\n assert @typep(foop :: any()) == :ok\n assert @spec(foo() :: nil) == :ok\n assert @opaque(my_type :: atom) == :ok\n assert @callback(foo(foop) :: integer) == :ok\n assert @macrocallback(foo(integer) :: integer) == :ok\n end\n end\n\n test \"@type with a single type\" do\n bytecode =\n test_module do\n @type my_type :: term\n end\n\n assert [type: {:my_type, {:type, _, :term, []}, []}] = types(bytecode)\n end\n\n test \"@type with an atom/alias\" do\n bytecode =\n test_module do\n @type foo :: :foo\n @type bar :: Bar\n end\n\n assert [\n type: {:bar, {:atom, _, Bar}, []},\n type: {:foo, {:atom, _, :foo}, []}\n ] = types(bytecode)\n end\n\n test \"@type with an integer\" do\n bytecode =\n test_module do\n @type pos :: 10\n @type neg :: -10\n end\n\n assert [\n type: {:neg, {:op, _, :-, {:integer, _, 10}}, []},\n type: {:pos, {:integer, _, 10}, []}\n ] = types(bytecode)\n end\n\n test \"@type with a tuple\" do\n bytecode =\n test_module do\n @type tup :: tuple()\n @type one :: {123}\n end\n\n assert [\n type: {:one, {:type, _, :tuple, [{:integer, _, 123}]}, []},\n type: {:tup, {:type, _, :tuple, :any}, []}\n ] = types(bytecode)\n end\n\n test \"@type with a remote type\" do\n bytecode =\n test_module do\n @type my_type :: Remote.Some.type()\n @type my_type_arg :: Remote.type(integer)\n end\n\n assert [type: my_type, type: my_type_arg] = types(bytecode)\n\n assert {:my_type, type, []} = my_type\n assert {:remote_type, _, [{:atom, _, Remote.Some}, {:atom, _, :type}, []]} = type\n\n assert {:my_type_arg, type, []} = my_type_arg\n assert {:remote_type, _, args} = type\n assert [{:atom, _, Remote}, {:atom, _, :type}, [{:type, _, :integer, []}]] = args\n end\n\n test \"@type with a binary\" do\n bytecode =\n test_module do\n @type bin :: binary\n @type empty :: <<>>\n @type size :: <<_::3>>\n @type unit :: <<_::_*8>>\n @type size_and_unit :: <<_::3, _::_*8>>\n @type size_prod_unit :: <<_::3*8>>\n end\n\n assert [\n type: {:bin, {:type, _, :binary, []}, []},\n type: {:empty, {:type, _, :binary, [{:integer, _, 0}, {:integer, _, 0}]}, []},\n type: {:size, {:type, _, :binary, [{:integer, _, 3}, {:integer, _, 0}]}, []},\n type:\n {:size_and_unit, {:type, _, :binary, [{:integer, _, 3}, {:integer, _, 8}]}, []},\n type:\n {:size_prod_unit,\n {:type, _, :binary,\n [{:op, _, :*, {:integer, _, 3}, {:integer, _, 8}}, {:integer, _, 0}]}, []},\n type: {:unit, {:type, _, :binary, [{:integer, _, 0}, {:integer, _, 8}]}, []}\n ] = types(bytecode)\n end\n\n test \"@type with invalid binary spec\" do\n assert_raise Kernel.TypespecError, ~r\"invalid binary specification\", fn ->\n test_module do\n @type my_type :: <<_::atom()>>\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"invalid binary specification\", fn ->\n test_module do\n @type my_type :: <<_::integer>>\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"invalid binary specification\", fn ->\n test_module do\n @type my_type :: <<_::(-4)>>\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"invalid binary specification\", fn ->\n test_module do\n @type my_type :: <<_::3, _::_*atom>>\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"invalid binary specification\", fn ->\n test_module do\n @type my_type :: <<_::3, _::_*(-8)>>\n end\n end\n\n assert_raise Kernel.TypespecError, ~r\"invalid binary specification\", fn ->\n test_module do\n @type my_type :: <<_::3, _::_*257>>\n end\n end\n end\n\n test \"@type with a range op\" do\n bytecode =\n test_module do\n @type range1 :: 1..10\n @type range2 :: -1..1\n end\n\n assert [\n {:type, {:range1, {:type, _, :range, range1_args}, []}},\n {:type, {:range2, {:type, _, :range, range2_args}, []}}\n ] = types(bytecode)\n\n assert [{:integer, _, 1}, {:integer, _, 10}] = range1_args\n assert [{:op, _, :-, {:integer, _, 1}}, {:integer, _, 1}] = range2_args\n end\n\n test \"@type with invalid range\" do\n assert_raise Kernel.TypespecError, ~r\"invalid range specification\", fn ->\n test_module do\n @type my_type :: atom..10\n end\n end\n end\n\n test \"@type with a keyword map\" do\n bytecode =\n test_module do\n @type my_type :: %{hello: :world}\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :map, [arg]} = type\n assert {:type, _, :map_field_exact, [{:atom, _, :hello}, {:atom, _, :world}]} = arg\n end\n\n test \"@type with a map\" do\n bytecode =\n test_module do\n @type my_type :: %{required(:a) => :b, optional(:c) => :d}\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :map, [arg1, arg2]} = type\n assert {:type, _, :map_field_exact, [{:atom, _, :a}, {:atom, _, :b}]} = arg1\n assert {:type, _, :map_field_assoc, [{:atom, _, :c}, {:atom, _, :d}]} = arg2\n end\n\n test \"@type with a struct\" do\n bytecode =\n test_module do\n defstruct hello: nil, other: nil\n @type my_type :: %TypespecSample{hello: :world}\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :map, [struct, arg1, arg2]} = type\n assert {:type, _, :map_field_exact, struct_args} = struct\n assert [{:atom, _, :__struct__}, {:atom, _, TypespecSample}] = struct_args\n assert {:type, _, :map_field_exact, [{:atom, _, :hello}, {:atom, _, :world}]} = arg1\n assert {:type, _, :map_field_exact, [{:atom, _, :other}, {:type, _, :term, []}]} = arg2\n end\n\n test \"@type with an exception struct\" do\n bytecode =\n test_module do\n defexception [:message]\n @type my_type :: %TypespecSample{}\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :map, [struct, arg1, arg2]} = type\n assert {:type, _, :map_field_exact, struct_args} = struct\n assert [{:atom, _, :__struct__}, {:atom, _, TypespecSample}] = struct_args\n assert {:type, _, :map_field_exact, [{:atom, _, :__exception__}, {:atom, _, true}]} = arg1\n assert {:type, _, :map_field_exact, [{:atom, _, :message}, {:type, _, :term, []}]} = arg2\n end\n\n @fields Enum.map(10..42, &{:\"f#{&1}\", :ok})\n\n test \"@type with a large struct\" do\n bytecode =\n test_module do\n defstruct unquote(@fields)\n @type my_type :: %TypespecSample{unquote_splicing(@fields)}\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :map, [struct, arg1, arg2 | _]} = type\n assert {:type, _, :map_field_exact, struct_args} = struct\n assert [{:atom, _, :__struct__}, {:atom, _, TypespecSample}] = struct_args\n assert {:type, _, :map_field_exact, [{:atom, _, :f10}, {:atom, _, :ok}]} = arg1\n assert {:type, _, :map_field_exact, [{:atom, _, :f11}, {:atom, _, :ok}]} = arg2\n end\n\n test \"@type with struct does not @enforce_keys\" do\n bytecode =\n test_module do\n @enforce_keys [:other]\n defstruct hello: nil, other: nil\n @type my_type :: %TypespecSample{hello: :world}\n end\n\n assert [type: {:my_type, _type, []}] = types(bytecode)\n end\n\n test \"@type with undefined struct\" do\n assert_raise ArgumentError, ~r\"ThisModuleDoesNotExist.__struct__/1 is undefined\", fn ->\n test_module do\n @type my_type :: %ThisModuleDoesNotExist{}\n end\n end\n\n assert_raise ArgumentError, ~r\"cannot access struct TypespecTest.TypespecSample\", fn ->\n test_module do\n @type my_type :: %TypespecSample{}\n end\n end\n end\n\n test \"@type with a struct with undefined field\" do\n assert_raise Kernel.TypespecError,\n ~r\"undefined field :no_field on struct TypespecTest.TypespecSample\",\n fn ->\n test_module do\n defstruct [:hello, :eric]\n @type my_type :: %TypespecSample{no_field: :world}\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"undefined field :no_field on struct TypespecTest.TypespecSample\",\n fn ->\n test_module do\n defstruct [:hello, :eric]\n @type my_type :: %__MODULE__{no_field: :world}\n end\n end\n end\n\n test \"@type when overriding Elixir built-in\" do\n assert_raise Kernel.TypespecError, ~r\"type struct/0 is a built-in type\", fn ->\n test_module do\n @type struct :: :oops\n end\n end\n end\n\n test \"@type when overriding Erlang built-in\" do\n assert_raise Kernel.TypespecError, ~r\"type list/0 is a built-in type\", fn ->\n test_module do\n @type list :: :oops\n end\n end\n end\n\n test \"@type with public record\" do\n bytecode =\n test_module do\n require Record\n Record.defrecord(:timestamp, date: 1, time: 2)\n @type my_type :: record(:timestamp, time: :foo)\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :tuple, [timestamp, term, foo]} = type\n assert {:atom, 0, :timestamp} = timestamp\n assert {:ann_type, 0, [{:var, 0, :date}, {:type, 0, :term, []}]} = term\n assert {:ann_type, 0, [{:var, 0, :time}, {:atom, 0, :foo}]} = foo\n end\n\n test \"@type with private record\" do\n bytecode =\n test_module do\n require Record\n Record.defrecordp(:timestamp, date: 1, time: 2)\n @type my_type :: record(:timestamp, time: :foo)\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :tuple, args} = type\n\n assert [\n {:atom, 0, :timestamp},\n {:ann_type, 0, [{:var, 0, :date}, {:type, 0, :term, []}]},\n {:ann_type, 0, [{:var, 0, :time}, {:atom, 0, :foo}]}\n ] = args\n end\n\n test \"@type with named record\" do\n bytecode =\n test_module do\n require Record\n Record.defrecord(:timestamp, :my_timestamp, date: 1, time: 2)\n @type my_type :: record(:timestamp, time: :foo)\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :tuple, [my_timestamp, term, _foo]} = type\n assert {:atom, 0, :my_timestamp} = my_timestamp\n assert {:ann_type, 0, [{:var, 0, :date}, {:type, 0, :term, []}]} = term\n assert {:ann_type, 0, [{:var, 0, :time}, {:atom, 0, :foo}]}\n end\n\n test \"@type with undefined record\" do\n assert_raise Kernel.TypespecError, ~r\"unknown record :this_record_does_not_exist\", fn ->\n test_module do\n @type my_type :: record(:this_record_does_not_exist, [])\n end\n end\n end\n\n test \"@type with a record with undefined field\" do\n assert_raise Kernel.TypespecError, ~r\"undefined field no_field on record :timestamp\", fn ->\n test_module do\n require Record\n Record.defrecord(:timestamp, date: 1, time: 2)\n @type my_type :: record(:timestamp, no_field: :foo)\n end\n end\n end\n\n test \"@type with a record which declares the name as the type `atom` rather than an atom literal\" do\n assert_raise Kernel.TypespecError, ~r\"expected the record name to be an atom literal\", fn ->\n test_module do\n @type my_type :: record(atom, field: :foo)\n end\n end\n end\n\n test \"@type named record/0 warns\" do\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n bytecode =\n test_module do\n @type record :: binary\n @spec foo?(record) :: boolean\n def foo?(_), do: true\n end\n\n assert [type: {:record, {:type, _, :binary, []}, []}] = types(bytecode)\n end) =~ \"type record/0 is overriding a built-in type\"\n end\n\n test \"@type with an invalid map notation\" do\n assert_raise Kernel.TypespecError, ~r\"invalid map specification\", fn ->\n test_module do\n @type content :: %{atom | String.t() => term}\n end\n end\n end\n\n test \"@type with list shortcuts\" do\n bytecode =\n test_module do\n @type my_type :: []\n @type my_type1 :: [integer]\n @type my_type2 :: [integer, ...]\n end\n\n assert [\n type: {:my_type, {:type, _, nil, []}, []},\n type: {:my_type1, {:type, _, :list, [{:type, _, :integer, []}]}, []},\n type: {:my_type2, {:type, _, :nonempty_list, [{:type, _, :integer, []}]}, []}\n ] = types(bytecode)\n end\n\n test \"@type with a fun\" do\n bytecode =\n test_module do\n @type my_type :: (... -> any)\n end\n\n assert [type: {:my_type, {:type, _, :fun, [{:type, _, :any}, {:type, _, :any, []}]}, []}] =\n types(bytecode)\n end\n\n test \"@type with a fun with multiple arguments and return type\" do\n bytecode =\n test_module do\n @type my_type :: (integer, integer -> integer)\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :fun, [args, return_type]} = type\n assert {:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]} = args\n assert {:type, _, :integer, []} = return_type\n end\n\n test \"@type with a fun with no arguments and return type\" do\n bytecode =\n test_module do\n @type my_type :: (-> integer)\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :fun, [{:type, _, :product, []}, {:type, _, :integer, []}]} = type\n end\n\n test \"@type with a fun with any arity and return type\" do\n bytecode =\n test_module do\n @type my_type :: (... -> integer)\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :fun, [{:type, _, :any}, {:type, _, :integer, []}]} = type\n end\n\n test \"@type with a union\" do\n bytecode =\n test_module do\n @type my_type :: integer | charlist | atom\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :union, [integer, charlist, atom]} = type\n assert {:type, _, :integer, []} = integer\n assert {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :charlist}, []]} = charlist\n assert {:type, _, :atom, []} = atom\n end\n\n test \"@type with keywords\" do\n bytecode =\n test_module do\n @type my_type :: [first: integer, step: integer, last: integer]\n end\n\n assert [type: {:my_type, type, []}] = types(bytecode)\n assert {:type, _, :list, [{:type, _, :union, union_types}]} = type\n\n assert [\n {:type, _, :tuple, [{:atom, _, :first}, {:type, _, :integer, []}]},\n {:type, _, :tuple, [{:atom, _, :step}, {:type, _, :integer, []}]},\n {:type, _, :tuple, [{:atom, _, :last}, {:type, _, :integer, []}]}\n ] = union_types\n end\n\n test \"@type with parameters\" do\n bytecode =\n test_module do\n @type my_type(x) :: x\n @type my_type1(x) :: list(x)\n @type my_type2(x, y) :: {x, y}\n end\n\n assert [\n type: {:my_type, {:var, _, :x}, [{:var, _, :x}]},\n type: {:my_type1, {:type, _, :list, [{:var, _, :x}]}, [{:var, _, :x}]},\n type: {:my_type2, my_type2, [{:var, _, :x}, {:var, _, :y}]}\n ] = types(bytecode)\n\n assert {:type, _, :tuple, [{:var, _, :x}, {:var, _, :y}]} = my_type2\n end\n\n test \"@type with annotations\" do\n bytecode =\n test_module do\n @type my_type :: named :: integer\n @type my_type1 :: (a :: integer -> integer)\n end\n\n assert [type: {:my_type, my_type, []}, type: {:my_type1, my_type1, []}] = types(bytecode)\n\n assert {:ann_type, _, [{:var, _, :named}, {:type, _, :integer, []}]} = my_type\n\n assert {:type, _, :fun, [fun_args, fun_return]} = my_type1\n assert {:type, _, :product, [{:ann_type, _, [a, {:type, _, :integer, []}]}]} = fun_args\n assert {:var, _, :a} = a\n assert {:type, _, :integer, []} = fun_return\n end\n\n test \"@type unquote fragment\" do\n quoted =\n quote unquote: false do\n name = :my_type\n type = :foo\n @type unquote(name)() :: unquote(type)\n end\n\n bytecode =\n test_module do\n Code.eval_quoted(quoted, [], module: __MODULE__)\n end\n\n assert [type: {:my_type, {:atom, _, :foo}, []}] = types(bytecode)\n end\n\n test \"@type with module attributes\" do\n bytecode =\n test_module do\n @keyword Keyword\n @type kw :: @keyword.t\n @type kw(value) :: @keyword.t(value)\n end\n\n assert [type: {:kw, kw, _}, type: {:kw, kw_with_value, [{:var, _, :value}]}] =\n types(bytecode)\n\n assert {:remote_type, _, [{:atom, _, Keyword}, {:atom, _, :t}, []]} = kw\n assert {:remote_type, _, kw_with_value_args} = kw_with_value\n assert [{:atom, _, Keyword}, {:atom, _, :t}, [{:var, _, :value}]] = kw_with_value_args\n end\n\n test \"@type with macro in alias\" do\n bytecode =\n test_module do\n defmacro module() do\n quote do: __MODULE__\n end\n\n @type my_type :: module().Foo\n end\n\n assert [type: {:my_type, {:atom, _, TypespecTest.TypespecSample.Foo}, []}] = types(bytecode)\n end\n\n test \"@type with a reserved signature\" do\n assert_raise Kernel.TypespecError,\n ~r\"type required\\/1 is a reserved type and it cannot be defined\",\n fn ->\n test_module do\n @type required(arg) :: any()\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"type optional\\/1 is a reserved type and it cannot be defined\",\n fn ->\n test_module do\n @type optional(arg) :: any()\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"type required\\/1 is a reserved type and it cannot be defined\",\n fn ->\n test_module do\n @typep required(arg) :: any()\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"type optional\\/1 is a reserved type and it cannot be defined\",\n fn ->\n test_module do\n @typep optional(arg) :: any()\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"type required\\/1 is a reserved type and it cannot be defined\",\n fn ->\n test_module do\n @opaque required(arg) :: any()\n end\n end\n\n assert_raise Kernel.TypespecError,\n ~r\"type optional\\/1 is a reserved type and it cannot be defined\",\n fn ->\n test_module do\n @opaque optional(arg) :: any()\n end\n end\n end\n\n test \"invalid remote @type with module attribute that does not evaluate to a module\" do\n assert_raise Kernel.TypespecError, ~r/\\(@foo is \"bar\"\\)/, fn ->\n test_module do\n @foo \"bar\"\n @type t :: @foo.t\n end\n end\n end\n\n test \"defines_type?\" do\n test_module do\n @type my_type :: tuple\n @type my_type(a) :: [a]\n assert Kernel.Typespec.defines_type?(__MODULE__, {:my_type, 0})\n assert Kernel.Typespec.defines_type?(__MODULE__, {:my_type, 1})\n refute Kernel.Typespec.defines_type?(__MODULE__, {:my_type, 2})\n end\n end\n\n test \"spec_to_callback/2\" do\n bytecode =\n test_module do\n @spec foo() :: term()\n def foo(), do: :ok\n Kernel.Typespec.spec_to_callback(__MODULE__, {:foo, 0})\n end\n\n assert specs(bytecode) == callbacks(bytecode)\n end\n\n test \"@opaque\" do\n bytecode =\n test_module do\n @opaque my_type(x) :: x\n end\n\n assert [opaque: {:my_type, {:var, _, :x}, [{:var, _, :x}]}] = types(bytecode)\n end\n\n test \"@spec\" do\n bytecode =\n test_module do\n def my_fun1(x), do: x\n def my_fun2(), do: :ok\n def my_fun3(x, y), do: {x, y}\n def my_fun4(x), do: x\n @spec my_fun1(integer) :: integer\n @spec my_fun2() :: integer\n @spec my_fun3(integer, integer) :: {integer, integer}\n @spec my_fun4(x :: integer) :: integer\n end\n\n assert [my_fun1, my_fun2, my_fun3, my_fun4] = specs(bytecode)\n\n assert {{:my_fun1, 1}, [{:type, _, :fun, args}]} = my_fun1\n assert [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}] = args\n\n assert {{:my_fun2, 0}, [{:type, _, :fun, args}]} = my_fun2\n assert [{:type, _, :product, []}, {:type, _, :integer, []}] = args\n\n assert {{:my_fun3, 2}, [{:type, _, :fun, [arg1, arg2]}]} = my_fun3\n assert {:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]} = arg1\n assert {:type, _, :tuple, [{:type, _, :integer, []}, {:type, _, :integer, []}]} = arg2\n\n assert {{:my_fun4, 1}, [{:type, _, :fun, args}]} = my_fun4\n assert [x, {:type, _, :integer, []}] = args\n assert {:type, _, :product, [{:ann_type, _, [{:var, _, :x}, {:type, _, :integer, []}]}]} = x\n end\n\n test \"@spec with vars matching built-ins\" do\n bytecode =\n test_module do\n def my_fun1(x), do: x\n def my_fun2(x), do: x\n @spec my_fun1(tuple) :: tuple\n @spec my_fun2(tuple) :: tuple when tuple: {integer, integer}\n end\n\n assert [my_fun1, my_fun2] = specs(bytecode)\n\n assert {{:my_fun1, 1}, [{:type, _, :fun, args}]} = my_fun1\n assert [{:type, _, :product, [{:type, _, :tuple, :any}]}, {:type, _, :tuple, :any}] = args\n\n assert {{:my_fun2, 1}, [{:type, _, :bounded_fun, args}]} = my_fun2\n\n assert [type, _] = args\n\n assert {:type, _, :fun, [{:type, _, :product, [{:var, _, :tuple}]}, {:var, _, :tuple}]} =\n type\n end\n\n test \"@spec with guards\" do\n bytecode =\n test_module do\n def my_fun1(x), do: x\n @spec my_fun1(x) :: boolean when x: integer\n\n def my_fun2(x), do: x\n @spec my_fun2(x) :: x when x: var\n\n def my_fun3(_x, y), do: y\n @spec my_fun3(x, y) :: y when y: x, x: var\n end\n\n assert [my_fun1, my_fun2, my_fun3] = specs(bytecode)\n\n assert {{:my_fun1, 1}, [{:type, _, :bounded_fun, args}]} = my_fun1\n assert [{:type, _, :fun, [product, {:type, _, :boolean, []}]}, constraints] = args\n assert {:type, _, :product, [{:var, _, :x}]} = product\n assert [{:type, _, :constraint, subtype}] = constraints\n assert [{:atom, _, :is_subtype}, [{:var, _, :x}, {:type, _, :integer, []}]] = subtype\n\n assert {{:my_fun2, 1}, [{:type, _, :fun, args}]} = my_fun2\n assert [{:type, _, :product, [{:var, _, :x}]}, {:var, _, :x}] = args\n\n assert {{:my_fun3, 2}, [{:type, _, :bounded_fun, args}]} = my_fun3\n assert [{:type, _, :fun, fun_type}, [{:type, _, :constraint, constraint_type}]] = args\n assert [{:type, _, :product, [{:var, _, :x}, {:var, _, :y}]}, {:var, _, :y}] = fun_type\n assert [{:atom, _, :is_subtype}, [{:var, _, :y}, {:var, _, :x}]] = constraint_type\n end\n\n test \"@type, @opaque, and @typep as module attributes\" do\n defmodule TypeModuleAttributes do\n @type type1 :: boolean\n @opaque opaque1 :: boolean\n @typep typep1 :: boolean\n\n def type1, do: @type\n def opaque1, do: @opaque\n def typep1, do: @typep\n\n @type type2 :: atom\n @type type3 :: pid\n @opaque opaque2 :: atom\n @opaque opaque3 :: pid\n @typep typep2 :: atom\n\n def type2, do: @type\n def opaque2, do: @opaque\n def typep2, do: @typep\n\n # Avoid unused warnings\n @spec foo(typep1) :: typep2\n def foo(_x), do: :ok\n end\n\n assert [\n {:type, {:\"::\", _, [{:type1, _, _}, {:boolean, _, _}]}, {TypeModuleAttributes, _}}\n ] = TypeModuleAttributes.type1()\n\n assert [\n {:type, {:\"::\", _, [{:type3, _, _}, {:pid, _, _}]}, {TypeModuleAttributes, _}},\n {:type, {:\"::\", _, [{:type2, _, _}, {:atom, _, _}]}, {TypeModuleAttributes, _}},\n {:type, {:\"::\", _, [{:type1, _, _}, {:boolean, _, _}]}, {TypeModuleAttributes, _}}\n ] = TypeModuleAttributes.type2()\n\n assert [\n {:opaque, {:\"::\", _, [{:opaque1, _, _}, {:boolean, _, _}]},\n {TypeModuleAttributes, _}}\n ] = TypeModuleAttributes.opaque1()\n\n assert [\n {:opaque, {:\"::\", _, [{:opaque3, _, _}, {:pid, _, _}]}, {TypeModuleAttributes, _}},\n {:opaque, {:\"::\", _, [{:opaque2, _, _}, {:atom, _, _}]},\n {TypeModuleAttributes, _}},\n {:opaque, {:\"::\", _, [{:opaque1, _, _}, {:boolean, _, _}]},\n {TypeModuleAttributes, _}}\n ] = TypeModuleAttributes.opaque2()\n\n assert [\n {:typep, {:\"::\", _, [{:typep1, _, _}, {:boolean, _, _}]},\n {TypeModuleAttributes, _}}\n ] = TypeModuleAttributes.typep1()\n\n assert [\n {:typep, {:\"::\", _, [{:typep2, _, _}, {:atom, _, _}]}, {TypeModuleAttributes, _}},\n {:typep, {:\"::\", _, [{:typep1, _, _}, {:boolean, _, _}]},\n {TypeModuleAttributes, _}}\n ] = TypeModuleAttributes.typep2()\n after\n :code.purge(TypeModuleAttributes)\n :code.delete(TypeModuleAttributes)\n end\n\n test \"@spec, @callback, and @macrocallback as module attributes\" do\n defmodule SpecModuleAttributes do\n @callback callback1 :: integer\n @macrocallback macrocallback1 :: integer\n\n @spec spec1 :: boolean\n def spec1, do: @spec\n\n @callback callback2 :: var when var: boolean\n @macrocallback macrocallback2 :: var when var: boolean\n\n @spec spec2 :: atom\n def spec2, do: @spec\n\n @spec spec3 :: pid\n def spec3, do: :ok\n def spec4, do: @spec\n\n def callback, do: @callback\n def macrocallback, do: @macrocallback\n end\n\n assert [\n {:spec, {:\"::\", _, [{:spec1, _, _}, {:boolean, _, _}]}, {SpecModuleAttributes, _}}\n ] = SpecModuleAttributes.spec1()\n\n assert [\n {:spec, {:\"::\", _, [{:spec2, _, _}, {:atom, _, _}]}, {SpecModuleAttributes, _}},\n {:spec, {:\"::\", _, [{:spec1, _, _}, {:boolean, _, _}]}, {SpecModuleAttributes, _}}\n ] = SpecModuleAttributes.spec2()\n\n assert [\n {:spec, {:\"::\", _, [{:spec3, _, _}, {:pid, _, _}]}, {SpecModuleAttributes, _}},\n {:spec, {:\"::\", _, [{:spec2, _, _}, {:atom, _, _}]}, {SpecModuleAttributes, _}},\n {:spec, {:\"::\", _, [{:spec1, _, _}, {:boolean, _, _}]}, {SpecModuleAttributes, _}}\n ] = SpecModuleAttributes.spec4()\n\n assert [\n {:callback,\n {:when, _,\n [{:\"::\", _, [{:callback2, _, _}, {:var, _, _}]}, [var: {:boolean, _, _}]]},\n {SpecModuleAttributes, _}},\n {:callback, {:\"::\", _, [{:callback1, _, _}, {:integer, _, _}]},\n {SpecModuleAttributes, _}}\n ] = SpecModuleAttributes.callback()\n\n assert [\n {:macrocallback,\n {:when, _,\n [{:\"::\", _, [{:macrocallback2, _, _}, {:var, _, _}]}, [var: {:boolean, _, _}]]},\n {SpecModuleAttributes, _}},\n {:macrocallback, {:\"::\", _, [{:macrocallback1, _, _}, {:integer, _, _}]},\n {SpecModuleAttributes, _}}\n ] = SpecModuleAttributes.macrocallback()\n after\n :code.purge(SpecModuleAttributes)\n :code.delete(SpecModuleAttributes)\n end\n\n test \"@callback\" do\n bytecode =\n test_module do\n @callback my_fun(integer) :: integer\n @callback my_fun(list) :: list\n @callback my_fun() :: integer\n @callback my_fun(integer, integer) :: {integer, integer}\n end\n\n assert [my_fun_0, my_fun_1, my_fun_2] = callbacks(bytecode)\n\n assert {{:my_fun, 0}, [{:type, _, :fun, args}]} = my_fun_0\n assert [{:type, _, :product, []}, {:type, _, :integer, []}] = args\n\n assert {{:my_fun, 1}, [clause1, clause2]} = my_fun_1\n assert {:type, _, :fun, args1} = clause1\n assert [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}] = args1\n assert {:type, _, :fun, args2} = clause2\n assert [{:type, _, :product, [{:type, _, :list, []}]}, {:type, _, :list, []}] = args2\n\n assert {{:my_fun, 2}, [{:type, _, :fun, [args_type, return_type]}]} = my_fun_2\n\n assert {:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]} =\n args_type\n\n assert {:type, _, :tuple, [{:type, _, :integer, []}, {:type, _, :integer, []}]} =\n return_type\n end\n\n test \"block handling\" do\n bytecode =\n test_module do\n @spec foo((-> [integer])) :: integer\n def foo(_), do: 1\n end\n\n assert [{{:foo, 1}, [{:type, _, :fun, [args, return]}]}] = specs(bytecode)\n assert {:type, _, :product, [{:type, _, :fun, fun_args}]} = args\n assert [{:type, _, :product, []}, {:type, _, :list, [{:type, _, :integer, []}]}] = fun_args\n assert {:type, _, :integer, []} = return\n end\n end\n\n describe \"Code.Typespec\" do\n test \"type_to_quoted\" do\n quoted =\n Enum.sort([\n quote(do: @type(tuple(arg) :: {:tuple, arg})),\n quote(do: @type(with_ann() :: t :: atom())),\n quote(do: @type(a_tuple() :: tuple())),\n quote(do: @type(empty_tuple() :: {})),\n quote(do: @type(one_tuple() :: {:foo})),\n quote(do: @type(two_tuple() :: {:foo, :bar})),\n quote(do: @type(custom_tuple() :: tuple(:foo))),\n quote(do: @type(imm_type_1() :: 1)),\n quote(do: @type(imm_type_2() :: :foo)),\n quote(do: @type(simple_type() :: integer())),\n quote(do: @type(param_type(p) :: [p])),\n quote(do: @type(union_type() :: integer() | binary() | boolean())),\n quote(do: @type(binary_type1() :: <<_::_*8>>)),\n quote(do: @type(binary_type2() :: <<_::3>>)),\n quote(do: @type(binary_type3() :: <<_::3, _::_*8>>)),\n quote(do: @type(binary_type4() :: <<_::3*8>>)),\n quote(do: @type(tuple_type() :: {integer()})),\n quote(do: @type(ftype() :: (-> any()) | (-> integer()) | (integer() -> integer()))),\n quote(do: @type(cl() :: charlist())),\n quote(do: @type(st() :: struct())),\n quote(do: @type(ab() :: as_boolean(term()))),\n quote(do: @type(kw() :: keyword())),\n quote(do: @type(kwt() :: keyword(term()))),\n quote(do: @type(vaf() :: (... -> any()))),\n quote(do: @type(rng() :: 1..10)),\n quote(do: @type(opts() :: [first: integer(), step: integer(), last: integer()])),\n quote(do: @type(ops() :: {+1, -1})),\n quote(do: @type(map(arg) :: {:map, arg})),\n quote(do: @type(a_map() :: map())),\n quote(do: @type(empty_map() :: %{})),\n quote(do: @type(my_map() :: %{hello: :world})),\n quote(do: @type(my_req_map() :: %{required(0) => :foo})),\n quote(do: @type(my_opt_map() :: %{optional(0) => :foo})),\n quote(do: @type(my_struct() :: %TypespecTest{hello: :world})),\n quote(do: @type(custom_map() :: map(:foo))),\n quote(do: @type(list1() :: list())),\n quote(do: @type(list2() :: [0])),\n quote(do: @type(list3() :: [...])),\n quote(do: @type(list4() :: [0, ...])),\n quote(do: @type(nil_list() :: []))\n ])\n\n bytecode =\n test_module do\n Code.eval_quoted(quoted, [], module: __MODULE__)\n end\n\n types = types(bytecode)\n\n Enum.each(Enum.zip(types, quoted), fn {{:type, type}, definition} ->\n ast = Code.Typespec.type_to_quoted(type)\n assert Macro.to_string(quote(do: @type(unquote(ast)))) == Macro.to_string(definition)\n end)\n end\n\n test \"type_to_quoted for paren_type\" do\n type = {:my_type, {:paren_type, 0, [{:type, 0, :integer, []}]}, []}\n\n assert Code.Typespec.type_to_quoted(type) ==\n {:\"::\", [], [{:my_type, [], []}, {:integer, [line: 0], []}]}\n end\n\n test \"spec_to_quoted\" do\n quoted =\n Enum.sort([\n quote(do: @spec(foo() :: integer())),\n quote(do: @spec(foo() :: union())),\n quote(do: @spec(foo() :: union(integer()))),\n quote(do: @spec(foo() :: truly_union())),\n quote(do: @spec(foo(union()) :: union())),\n quote(do: @spec(foo(union(integer())) :: union(integer()))),\n quote(do: @spec(foo(truly_union()) :: truly_union())),\n quote(do: @spec(foo(atom()) :: integer() | [{}])),\n quote(do: @spec(foo(arg) :: integer() when [arg: integer()])),\n quote(do: @spec(foo(arg) :: arg when [arg: var])),\n quote(do: @spec(foo(arg :: atom()) :: atom()))\n ])\n\n bytecode =\n test_module do\n @type union :: any()\n @type union(t) :: t\n @type truly_union :: list | map | union\n\n def foo(), do: 1\n def foo(arg), do: arg\n Code.eval_quoted(quote(do: (unquote_splicing(quoted))), [], module: __MODULE__)\n end\n\n specs =\n Enum.flat_map(specs(bytecode), fn {{_, _}, specs} ->\n Enum.map(specs, fn spec ->\n quote(do: @spec(unquote(Code.Typespec.spec_to_quoted(:foo, spec))))\n end)\n end)\n\n specs_with_quoted = specs |> Enum.sort() |> Enum.zip(quoted)\n\n Enum.each(specs_with_quoted, fn {spec, definition} ->\n assert Macro.to_string(spec) == Macro.to_string(definition)\n end)\n end\n\n test \"spec_to_quoted with maps with __struct__ key\" do\n defmodule StructA do\n defstruct [:key]\n end\n\n defmodule StructB do\n defstruct [:key]\n end\n\n bytecode =\n test_module do\n @spec single_struct(%StructA{}) :: :ok\n def single_struct(arg), do: {:ok, arg}\n\n @spec single_struct_key(%{__struct__: StructA}) :: :ok\n def single_struct_key(arg), do: {:ok, arg}\n\n @spec single_struct_key_type(%{__struct__: atom()}) :: :ok\n def single_struct_key_type(arg), do: {:ok, arg}\n\n @spec union_struct(%StructA{} | %StructB{}) :: :ok\n def union_struct(arg), do: {:ok, arg}\n\n @spec union_struct_key(%{__struct__: StructA | StructB}) :: :ok\n def union_struct_key(arg), do: {:ok, arg}\n\n @spec union_struct_key_type(%{__struct__: atom() | StructA | binary()}) :: :ok\n def union_struct_key_type(arg), do: {:ok, arg}\n end\n\n [\n {{:single_struct, 1}, [ast_single_struct]},\n {{:single_struct_key, 1}, [ast_single_struct_key]},\n {{:single_struct_key_type, 1}, [ast_single_struct_key_type]},\n {{:union_struct, 1}, [ast_union_struct]},\n {{:union_struct_key, 1}, [ast_union_struct_key]},\n {{:union_struct_key_type, 1}, [ast_union_struct_key_type]}\n ] = specs(bytecode)\n\n assert Code.Typespec.spec_to_quoted(:single_struct, ast_single_struct)\n |> Macro.to_string() ==\n \"single_struct(%TypespecTest.StructA{key: term()}) :: :ok\"\n\n assert Code.Typespec.spec_to_quoted(:single_struct_key, ast_single_struct_key)\n |> Macro.to_string() ==\n \"single_struct_key(%TypespecTest.StructA{}) :: :ok\"\n\n assert Code.Typespec.spec_to_quoted(:single_struct_key_type, ast_single_struct_key_type)\n |> Macro.to_string() ==\n \"single_struct_key_type(%{__struct__: atom()}) :: :ok\"\n\n assert Code.Typespec.spec_to_quoted(:union_struct, ast_union_struct) |> Macro.to_string() ==\n \"union_struct(%TypespecTest.StructA{key: term()} | %TypespecTest.StructB{key: term()}) :: :ok\"\n\n assert Code.Typespec.spec_to_quoted(:union_struct_key, ast_union_struct_key)\n |> Macro.to_string() ==\n \"union_struct_key(%{__struct__: TypespecTest.StructA | TypespecTest.StructB}) :: :ok\"\n\n assert Code.Typespec.spec_to_quoted(:union_struct_key_type, ast_union_struct_key_type)\n |> Macro.to_string() ==\n \"union_struct_key_type(%{__struct__: atom() | TypespecTest.StructA | binary()}) :: :ok\"\n end\n\n test \"non-variables are given as arguments\" do\n msg = ~r/The type one_bad_variable\\/1 has an invalid argument\\(s\\): String.t\\(\\)/\n\n assert_raise Kernel.TypespecError, msg, fn ->\n test_module do\n @type one_bad_variable(String.t()) :: String.t()\n end\n end\n\n msg = ~r/The type two_bad_variables\\/2 has an invalid argument\\(s\\): :ok, Enumerable.t\\(\\)/\n\n assert_raise Kernel.TypespecError, msg, fn ->\n test_module do\n @type two_bad_variables(:ok, Enumerable.t()) :: {:ok, []}\n end\n end\n\n msg = ~r/The type one_bad_one_good\\/2 has an invalid argument\\(s\\): \\\"\\\"/\n\n assert_raise Kernel.TypespecError, msg, fn ->\n test_module do\n @type one_bad_one_good(input1, \"\") :: {:ok, input1}\n end\n end\n end\n\n test \"retrieval invalid data\" do\n assert Code.Typespec.fetch_types(Unknown) == :error\n assert Code.Typespec.fetch_specs(Unknown) == :error\n end\n\n # This is a test that implements all types specified in lib/elixir/pages/typespecs.md\n test \"documented types and their AST\" do\n defmodule SomeStruct do\n defstruct [:key]\n end\n\n quoted =\n Enum.sort([\n ## Basic types\n quote(do: @type(basic_any() :: any())),\n quote(do: @type(basic_none() :: none())),\n quote(do: @type(basic_atom() :: atom())),\n quote(do: @type(basic_map() :: map())),\n quote(do: @type(basic_pid() :: pid())),\n quote(do: @type(basic_port() :: port())),\n quote(do: @type(basic_reference() :: reference())),\n quote(do: @type(basic_struct() :: struct())),\n quote(do: @type(basic_tuple() :: tuple())),\n\n # Numbers\n quote(do: @type(basic_float() :: float())),\n quote(do: @type(basic_integer() :: integer())),\n quote(do: @type(basic_neg_integer() :: neg_integer())),\n quote(do: @type(basic_non_neg_integer() :: non_neg_integer())),\n quote(do: @type(basic_pos_integer() :: pos_integer())),\n\n # Lists\n quote(do: @type(basic_list_type() :: list(integer()))),\n quote(do: @type(basic_nonempty_list_type() :: nonempty_list(integer()))),\n quote do\n @type basic_maybe_improper_list_type() :: maybe_improper_list(integer(), atom())\n end,\n quote do\n @type basic_nonempty_improper_list_type() :: nonempty_improper_list(integer(), atom())\n end,\n quote do\n @type basic_nonempty_maybe_improper_list_type() ::\n nonempty_maybe_improper_list(integer(), atom())\n end,\n\n ## Literals\n quote(do: @type(literal_atom() :: :atom)),\n quote(do: @type(literal_integer() :: 1)),\n quote(do: @type(literal_integers() :: 1..10)),\n quote(do: @type(literal_empty_bitstring() :: <<>>)),\n quote(do: @type(literal_size_0() :: <<_::0>>)),\n quote(do: @type(literal_unit_1() :: <<_::_*1>>)),\n quote(do: @type(literal_size_1_unit_8() :: <<_::100, _::_*256>>)),\n quote(do: @type(literal_function_arity_any() :: (... -> integer()))),\n quote(do: @type(literal_function_arity_0() :: (-> integer()))),\n quote(do: @type(literal_function_arity_2() :: (integer(), atom() -> integer()))),\n quote(do: @type(literal_list_type() :: [integer()])),\n quote(do: @type(literal_empty_list() :: [])),\n quote(do: @type(literal_list_nonempty() :: [...])),\n quote(do: @type(literal_nonempty_list_type() :: [atom(), ...])),\n quote(do: @type(literal_keyword_list_fixed_key() :: [key: integer()])),\n quote(do: @type(literal_keyword_list_fixed_key2() :: [{:key, integer()}])),\n quote(do: @type(literal_keyword_list_type_key() :: [{binary(), integer()}])),\n quote(do: @type(literal_empty_map() :: %{})),\n quote(do: @type(literal_map_with_key() :: %{key: integer()})),\n quote(\n do: @type(literal_map_with_required_key() :: %{required(bitstring()) => integer()})\n ),\n quote(\n do: @type(literal_map_with_optional_key() :: %{optional(bitstring()) => integer()})\n ),\n quote(do: @type(literal_struct_all_fields_any_type() :: %SomeStruct{})),\n quote(do: @type(literal_struct_all_fields_key_type() :: %SomeStruct{key: integer()})),\n quote(do: @type(literal_empty_tuple() :: {})),\n quote(do: @type(literal_2_element_tuple() :: {1, 2})),\n\n ## Built-in types\n quote(do: @type(built_in_term() :: term())),\n quote(do: @type(built_in_arity() :: arity())),\n quote(do: @type(built_in_as_boolean() :: as_boolean(:t))),\n quote(do: @type(built_in_binary() :: binary())),\n quote(do: @type(built_in_bitstring() :: bitstring())),\n quote(do: @type(built_in_boolean() :: boolean())),\n quote(do: @type(built_in_byte() :: byte())),\n quote(do: @type(built_in_char() :: char())),\n quote(do: @type(built_in_charlist() :: charlist())),\n quote(do: @type(built_in_nonempty_charlist() :: nonempty_charlist())),\n quote(do: @type(built_in_fun() :: fun())),\n quote(do: @type(built_in_function() :: function())),\n quote(do: @type(built_in_identifier() :: identifier())),\n quote(do: @type(built_in_iodata() :: iodata())),\n quote(do: @type(built_in_iolist() :: iolist())),\n quote(do: @type(built_in_keyword() :: keyword())),\n quote(do: @type(built_in_keyword_value_type() :: keyword(:t))),\n quote(do: @type(built_in_list() :: list())),\n quote(do: @type(built_in_nonempty_list() :: nonempty_list())),\n quote(do: @type(built_in_maybe_improper_list() :: maybe_improper_list())),\n quote(\n do: @type(built_in_nonempty_maybe_improper_list() :: nonempty_maybe_improper_list())\n ),\n quote(do: @type(built_in_mfa() :: mfa())),\n quote(do: @type(built_in_module() :: module())),\n quote(do: @type(built_in_no_return() :: no_return())),\n quote(do: @type(built_in_node() :: node())),\n quote(do: @type(built_in_number() :: number())),\n quote(do: @type(built_in_struct() :: struct())),\n quote(do: @type(built_in_timeout() :: timeout())),\n\n ## Remote types\n quote(do: @type(remote_enum_t0() :: Enum.t())),\n quote(do: @type(remote_keyword_t1() :: Keyword.t(integer())))\n ])\n\n bytecode =\n test_module do\n Code.eval_quoted(quoted, [], module: __MODULE__)\n end\n\n types = types(bytecode)\n\n Enum.each(Enum.zip(types, quoted), fn {{:type, type}, definition} ->\n ast = Code.Typespec.type_to_quoted(type)\n ast_string = Macro.to_string(quote(do: @type(unquote(ast))))\n\n case type do\n # These cases do not translate directly to their own string version.\n {:basic_list_type, _, _} ->\n assert ast_string == \"@type basic_list_type() :: [integer()]\"\n\n {:basic_nonempty_list_type, _, _} ->\n assert ast_string == \"@type basic_nonempty_list_type() :: [integer(), ...]\"\n\n {:literal_empty_bitstring, _, _} ->\n assert ast_string == \"@type literal_empty_bitstring() :: <<_::0>>\"\n\n {:literal_keyword_list_fixed_key, _, _} ->\n assert ast_string == \"@type literal_keyword_list_fixed_key() :: [{:key, integer()}]\"\n\n {:literal_keyword_list_fixed_key2, _, _} ->\n assert ast_string == \"@type literal_keyword_list_fixed_key2() :: [{:key, integer()}]\"\n\n {:literal_struct_all_fields_any_type, _, _} ->\n assert ast_string ==\n \"@type literal_struct_all_fields_any_type() :: %TypespecTest.SomeStruct{key: term()}\"\n\n {:literal_struct_all_fields_key_type, _, _} ->\n assert ast_string ==\n \"@type literal_struct_all_fields_key_type() :: %TypespecTest.SomeStruct{key: integer()}\"\n\n {:built_in_nonempty_list, _, _} ->\n assert ast_string == \"@type built_in_nonempty_list() :: [...]\"\n\n _ ->\n assert ast_string == Macro.to_string(definition)\n end\n end)\n end\n end\n\n describe \"behaviour_info\" do\n defmodule SampleCallbacks do\n @callback first(integer) :: integer\n @callback foo(atom(), binary) :: binary\n @callback bar(External.hello(), my_var :: binary) :: binary\n @callback guarded(my_var) :: my_var when my_var: binary\n @callback orr(atom | integer) :: atom\n @callback literal(123, {atom}, :foo, [integer], true) :: atom\n @macrocallback last(integer) :: Macro.t()\n @macrocallback last() :: atom\n @optional_callbacks bar: 2, last: 0\n @optional_callbacks first: 1\n end\n\n test \"defines callbacks\" do\n expected_callbacks = [\n \"MACRO-last\": 1,\n \"MACRO-last\": 2,\n bar: 2,\n first: 1,\n foo: 2,\n guarded: 1,\n literal: 5,\n orr: 1\n ]\n\n assert Enum.sort(SampleCallbacks.behaviour_info(:callbacks)) == expected_callbacks\n end\n\n test \"defines optional callbacks\" do\n assert Enum.sort(SampleCallbacks.behaviour_info(:optional_callbacks)) ==\n [\"MACRO-last\": 1, bar: 2, first: 1]\n end\n end\n\n @tag tmp_dir: true\n test \"erlang module\", c do\n erlc(c, :typespec_test_mod, \"\"\"\n -module(typespec_test_mod).\n -export([f/1]).\n -export_type([t/1]).\n\n -type t(X) :: list(X).\n\n -spec f(X) -> X.\n f(X) -> X.\n \"\"\")\n\n [type: type] = types(:typespec_test_mod)\n\n assert Code.Typespec.type_to_quoted(type) ==\n {:\"::\", [],\n [\n {:t, [], [{:x, meta(5, 9), nil}]},\n [{:x, meta(5, 20), nil}]\n ]}\n\n [{{:f, 1}, [spec]}] = specs(:typespec_test_mod)\n\n assert Code.Typespec.spec_to_quoted(:f, spec) ==\n {:when, meta(7, 8),\n [\n {:\"::\", meta(7, 8),\n [{:f, meta(7, 8), [{:x, meta(7, 9), nil}]}, {:x, meta(7, 15), nil}]},\n [x: {:var, meta(7, 8), nil}]\n ]}\n end\n\n defp meta(line, column) do\n [line: line, column: column]\n end\n\n defp erlc(context, module, code) do\n dir = context.tmp_dir\n\n src_path = Path.join([dir, \"#{module}.erl\"])\n src_path |> Path.dirname() |> File.mkdir_p!()\n File.write!(src_path, code)\n\n ebin_dir = Path.join(dir, \"ebin\")\n File.mkdir_p!(ebin_dir)\n\n {:ok, module} =\n :compile.file(String.to_charlist(src_path), [\n :debug_info,\n outdir: String.to_charlist(ebin_dir)\n ])\n\n true = Code.prepend_path(ebin_dir)\n {:module, ^module} = :code.load_file(module)\n\n ExUnit.Callbacks.on_exit(fn ->\n :code.purge(module)\n :code.delete(module)\n File.rm_rf!(dir)\n end)\n\n :ok\n end\n\n defp assert_compile_error(message, fun) do\n assert ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert_raise CompileError, fun\n end) =~ message\n end\nend\n" }, { "path": "lib/elixir/test/elixir/uri_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule URITest do\n use ExUnit.Case, async: true\n\n doctest URI\n\n test \"encode/1,2\" do\n assert URI.encode(\"4_test.is-s~\") == \"4_test.is-s~\"\n\n assert URI.encode(\"\\r\\n&<%>\\\" ゆ\", &URI.char_unreserved?/1) ==\n \"%0D%0A%26%3C%25%3E%22%20%E3%82%86\"\n end\n\n test \"encode_www_form/1\" do\n assert URI.encode_www_form(\"4test ~1.x\") == \"4test+~1.x\"\n assert URI.encode_www_form(\"poll:146%\") == \"poll%3A146%25\"\n assert URI.encode_www_form(\"/\\n+/ゆ\") == \"%2F%0A%2B%2F%E3%82%86\"\n end\n\n test \"encode_query/1,2\" do\n assert URI.encode_query([{:foo, :bar}, {:baz, :quux}]) == \"foo=bar&baz=quux\"\n assert URI.encode_query([{\"foo\", \"bar\"}, {\"baz\", \"quux\"}]) == \"foo=bar&baz=quux\"\n\n assert URI.encode_query([{\"foo z\", :bar}]) == \"foo+z=bar\"\n assert URI.encode_query([{\"foo z\", :bar}], :rfc3986) == \"foo%20z=bar\"\n assert URI.encode_query([{\"foo z\", :bar}], :www_form) == \"foo+z=bar\"\n\n assert URI.encode_query([{\"foo[]\", \"+=/?&# Ñ\"}]) ==\n \"foo%5B%5D=%2B%3D%2F%3F%26%23+%C3%91\"\n\n assert URI.encode_query([{\"foo[]\", \"+=/?&# Ñ\"}], :rfc3986) ==\n \"foo%5B%5D=%2B%3D%2F%3F%26%23%20%C3%91\"\n\n assert URI.encode_query([{\"foo[]\", \"+=/?&# Ñ\"}], :www_form) ==\n \"foo%5B%5D=%2B%3D%2F%3F%26%23+%C3%91\"\n\n assert_raise ArgumentError, fn ->\n URI.encode_query([{\"foo\", ~c\"bar\"}])\n end\n\n assert_raise ArgumentError, fn ->\n URI.encode_query([{~c\"foo\", \"bar\"}])\n end\n end\n\n test \"decode_query/1,2,3\" do\n assert URI.decode_query(\"\", %{}) == %{}\n\n assert URI.decode_query(\"safe=off\", %{\"cookie\" => \"foo\"}) ==\n %{\"safe\" => \"off\", \"cookie\" => \"foo\"}\n\n assert URI.decode_query(\"q=search%20query&cookie=ab%26cd&block+buster=\") ==\n %{\"block buster\" => \"\", \"cookie\" => \"ab&cd\", \"q\" => \"search query\"}\n\n assert URI.decode_query(\"q=search%20query&cookie=ab%26cd&block+buster=\", %{}, :rfc3986) ==\n %{\"block+buster\" => \"\", \"cookie\" => \"ab&cd\", \"q\" => \"search query\"}\n\n assert URI.decode_query(\"something=weird%3Dhappening\") == %{\"something\" => \"weird=happening\"}\n\n assert URI.decode_query(\"=\") == %{\"\" => \"\"}\n assert URI.decode_query(\"key\") == %{\"key\" => \"\"}\n assert URI.decode_query(\"key=\") == %{\"key\" => \"\"}\n assert URI.decode_query(\"=value\") == %{\"\" => \"value\"}\n assert URI.decode_query(\"something=weird=happening\") == %{\"something\" => \"weird=happening\"}\n end\n\n test \"query_decoder/1,2\" do\n decoder = URI.query_decoder(\"q=search%20query&cookie=ab%26cd&block+buster=\")\n expected = [{\"q\", \"search query\"}, {\"cookie\", \"ab&cd\"}, {\"block buster\", \"\"}]\n assert Enum.map(decoder, & &1) == expected\n\n decoder = URI.query_decoder(\"q=search%20query&cookie=ab%26cd&block+buster=\", :rfc3986)\n expected = [{\"q\", \"search query\"}, {\"cookie\", \"ab&cd\"}, {\"block+buster\", \"\"}]\n assert Enum.map(decoder, & &1) == expected\n end\n\n test \"decode/1\" do\n assert URI.decode(\"%0D%0A%26%3C%25%3E%22%20%E3%82%86\") == \"\\r\\n&<%>\\\" ゆ\"\n assert URI.decode(\"%2f%41%4a%55\") == \"/AJU\"\n assert URI.decode(\"4_t+st.is-s~\") == \"4_t+st.is-s~\"\n assert URI.decode(\"% invalid\") == \"% invalid\"\n assert URI.decode(\"invalid %\") == \"invalid %\"\n assert URI.decode(\"%%\") == \"%%\"\n end\n\n test \"decode_www_form/1\" do\n assert URI.decode_www_form(\"%3Eval+ue%2B\") == \">val ue+\"\n assert URI.decode_www_form(\"%E3%82%86+\") == \"ゆ \"\n assert URI.decode_www_form(\"% invalid\") == \"% invalid\"\n assert URI.decode_www_form(\"invalid %\") == \"invalid %\"\n assert URI.decode_www_form(\"%%\") == \"%%\"\n end\n\n describe \"new/1\" do\n test \"empty\" do\n assert URI.new(\"\") == {:ok, %URI{}}\n end\n\n test \"errors on bad URIs\" do\n assert URI.new(\"/>\") == {:error, \">\"}\n assert URI.new(\":https\") == {:error, \":\"}\n assert URI.new(\"ht\\0tps://foo.com\") == {:error, \"\\0\"}\n end\n end\n\n describe \"new!/1\" do\n test \"returns the given URI if a %URI{} struct is given\" do\n assert URI.new!(uri = %URI{scheme: \"http\", host: \"foo.com\"}) == uri\n end\n\n test \"works with HTTP scheme\" do\n expected_uri = %URI{\n scheme: \"http\",\n host: \"foo.com\",\n path: \"/path/to/something\",\n query: \"foo=bar&bar=foo\",\n fragment: \"fragment\",\n port: 80,\n userinfo: nil\n }\n\n assert URI.new!(\"http://foo.com/path/to/something?foo=bar&bar=foo#fragment\") ==\n expected_uri\n end\n\n test \"works with HTTPS scheme\" do\n expected_uri = %URI{\n scheme: \"https\",\n host: \"foo.com\",\n query: nil,\n fragment: nil,\n port: 443,\n path: nil,\n userinfo: nil\n }\n\n assert URI.new!(\"https://foo.com\") == expected_uri\n end\n\n test \"works with file scheme\" do\n expected_uri = %URI{\n scheme: \"file\",\n host: \"\",\n path: \"/foo/bar/baz\",\n userinfo: nil,\n query: nil,\n fragment: nil,\n port: nil\n }\n\n assert URI.new!(\"file:///foo/bar/baz\") == expected_uri\n end\n\n test \"works with FTP scheme\" do\n expected_uri = %URI{\n scheme: \"ftp\",\n host: \"private.ftp-server.example.com\",\n userinfo: \"user001:password\",\n path: \"/my_directory/my_file.txt\",\n query: nil,\n fragment: nil,\n port: 21\n }\n\n ftp = \"ftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt\"\n assert URI.new!(ftp) == expected_uri\n end\n\n test \"works with SFTP scheme\" do\n expected_uri = %URI{\n scheme: \"sftp\",\n host: \"private.ftp-server.example.com\",\n userinfo: \"user001:password\",\n path: \"/my_directory/my_file.txt\",\n query: nil,\n fragment: nil,\n port: 22\n }\n\n sftp = \"sftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt\"\n assert URI.new!(sftp) == expected_uri\n end\n\n test \"works with TFTP scheme\" do\n expected_uri = %URI{\n scheme: \"tftp\",\n host: \"private.ftp-server.example.com\",\n userinfo: \"user001:password\",\n path: \"/my_directory/my_file.txt\",\n query: nil,\n fragment: nil,\n port: 69\n }\n\n tftp = \"tftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt\"\n assert URI.new!(tftp) == expected_uri\n end\n\n test \"works with LDAP scheme\" do\n expected_uri = %URI{\n scheme: \"ldap\",\n host: \"\",\n userinfo: nil,\n path: \"/dc=example,dc=com\",\n query: \"?sub?(givenName=John)\",\n fragment: nil,\n port: 389\n }\n\n assert URI.new!(\"ldap:///dc=example,dc=com??sub?(givenName=John)\") == expected_uri\n\n expected_uri = %URI{\n scheme: \"ldap\",\n host: \"ldap.example.com\",\n userinfo: nil,\n path: \"/cn=John%20Doe,dc=foo,dc=com\",\n fragment: nil,\n port: 389,\n query: nil\n }\n\n assert URI.new!(\"ldap://ldap.example.com/cn=John%20Doe,dc=foo,dc=com\") == expected_uri\n end\n\n test \"can parse IPv6 addresses\" do\n addresses = [\n # undefined\n \"::\",\n # loopback\n \"::1\",\n # unicast\n \"1080::8:800:200C:417A\",\n # multicast\n \"FF01::101\",\n # link-local\n \"fe80::\",\n # abbreviated\n \"2607:f3f0:2:0:216:3cff:fef0:174a\",\n # mixed hex case\n \"2607:f3F0:2:0:216:3cFf:Fef0:174A\",\n # complete\n \"2051:0db8:2d5a:3521:8313:ffad:1242:8e2e\",\n # embedded IPv4\n \"::00:192.168.10.184\"\n ]\n\n Enum.each(addresses, fn addr ->\n simple_uri = URI.new!(\"http://[#{addr}]/\")\n assert simple_uri.host == addr\n\n userinfo_uri = URI.new!(\"http://user:pass@[#{addr}]/\")\n assert userinfo_uri.host == addr\n assert userinfo_uri.userinfo == \"user:pass\"\n\n port_uri = URI.new!(\"http://[#{addr}]:2222/\")\n assert port_uri.host == addr\n assert port_uri.port == 2222\n\n userinfo_port_uri = URI.new!(\"http://user:pass@[#{addr}]:2222/\")\n assert userinfo_port_uri.host == addr\n assert userinfo_port_uri.userinfo == \"user:pass\"\n assert userinfo_port_uri.port == 2222\n end)\n end\n\n test \"downcases the scheme\" do\n assert URI.new!(\"hTtP://google.com\").scheme == \"http\"\n end\n\n test \"preserves empty fragments\" do\n assert URI.new!(\"http://example.com#\").fragment == \"\"\n assert URI.new!(\"http://example.com/#\").fragment == \"\"\n assert URI.new!(\"http://example.com/test#\").fragment == \"\"\n end\n\n test \"preserves an empty query\" do\n assert URI.new!(\"http://foo.com/?\").query == \"\"\n end\n\n test \"without scheme, undefined port after host translates to nil\" do\n assert URI.new!(\"//https://www.example.com\") ==\n %URI{\n scheme: nil,\n userinfo: nil,\n host: \"https\",\n port: nil,\n path: \"//www.example.com\",\n query: nil,\n fragment: nil\n }\n end\n\n test \"with scheme, undefined port after host translates to nil\" do\n assert URI.new!(\"myscheme://myhost:/path/info\") ==\n %URI{\n scheme: \"myscheme\",\n userinfo: nil,\n host: \"myhost\",\n port: nil,\n path: \"/path/info\",\n query: nil,\n fragment: nil\n }\n end\n end\n\n test \"http://http://http://@http://http://?http://#http://\" do\n assert URI.parse(\"http://http://http://@http://http://?http://#http://\") ==\n %URI{\n scheme: \"http\",\n authority: \"http:\",\n userinfo: nil,\n host: \"http\",\n port: 80,\n path: \"//http://@http://http://\",\n query: \"http://\",\n fragment: \"http://\"\n }\n\n assert URI.new!(\"http://http://http://@http://http://?http://#http://\") ==\n %URI{\n scheme: \"http\",\n userinfo: nil,\n host: \"http\",\n port: 80,\n path: \"//http://@http://http://\",\n query: \"http://\",\n fragment: \"http://\"\n }\n end\n\n test \"default_port/1,2\" do\n assert URI.default_port(\"http\") == 80\n\n try do\n URI.default_port(\"http\", 8000)\n assert URI.default_port(\"http\") == 8000\n after\n URI.default_port(\"http\", 80)\n end\n\n assert URI.default_port(\"unknown\") == nil\n URI.default_port(\"unknown\", 13)\n assert URI.default_port(\"unknown\") == 13\n end\n\n test \"to_string/1 and Kernel.to_string/1\" do\n assert to_string(URI.new!(\"http://google.com\")) == \"http://google.com\"\n assert to_string(URI.new!(\"http://google.com:443\")) == \"http://google.com:443\"\n assert to_string(URI.new!(\"https://google.com:443\")) == \"https://google.com\"\n assert to_string(URI.new!(\"file:/path\")) == \"file:/path\"\n assert to_string(URI.new!(\"file:///path\")) == \"file:///path\"\n assert to_string(URI.new!(\"file://///path\")) == \"file://///path\"\n assert to_string(URI.new!(\"http://lol:wut@google.com\")) == \"http://lol:wut@google.com\"\n assert to_string(URI.new!(\"http://google.com/elixir\")) == \"http://google.com/elixir\"\n assert to_string(URI.new!(\"http://google.com?q=lol\")) == \"http://google.com?q=lol\"\n assert to_string(URI.new!(\"http://google.com?q=lol#omg\")) == \"http://google.com?q=lol#omg\"\n assert to_string(URI.new!(\"//google.com/elixir\")) == \"//google.com/elixir\"\n assert to_string(URI.new!(\"//google.com:8080/elixir\")) == \"//google.com:8080/elixir\"\n assert to_string(URI.new!(\"//user:password@google.com/\")) == \"//user:password@google.com/\"\n assert to_string(URI.new!(\"http://[2001:db8::]:8080\")) == \"http://[2001:db8::]:8080\"\n assert to_string(URI.new!(\"http://[2001:db8::]\")) == \"http://[2001:db8::]\"\n\n assert URI.to_string(URI.new!(\"http://google.com\")) == \"http://google.com\"\n assert URI.to_string(URI.new!(\"gid:hello/123\")) == \"gid:hello/123\"\n\n assert URI.to_string(URI.new!(\"//user:password@google.com/\")) ==\n \"//user:password@google.com/\"\n\n assert_raise ArgumentError,\n ~r\":path in URI must be empty or an absolute path if URL has a :host\",\n fn -> %URI{host: \"foo.com\", path: \"hello/123\"} |> URI.to_string() end\n end\n\n describe \"merge/2\" do\n test \"with valid paths\" do\n assert URI.merge(\"http://google.com/foo\", \"http://example.com/baz\")\n |> to_string() == \"http://example.com/baz\"\n\n assert URI.merge(\"http://google.com/foo\", \"http://example.com/.././bar/../../baz\")\n |> to_string() == \"http://example.com/baz\"\n\n assert URI.merge(\"http://google.com/foo\", \"//example.com/baz\")\n |> to_string() == \"http://example.com/baz\"\n\n assert URI.merge(\"http://google.com/foo\", URI.new!(\"//example.com/baz\"))\n |> to_string() == \"http://example.com/baz\"\n\n assert URI.merge(\"http://google.com/foo\", \"//example.com/.././bar/../../../baz\")\n |> to_string() == \"http://example.com/baz\"\n\n assert URI.merge(\"http://example.com\", URI.new!(\"/foo\"))\n |> to_string() == \"http://example.com/foo\"\n\n assert URI.merge(\"http://example.com\", URI.new!(\"/.././bar/../../../baz\"))\n |> to_string() == \"http://example.com/baz\"\n\n base = URI.new!(\"http://example.com/foo/bar\")\n assert URI.merge(base, \"\") |> to_string() == \"http://example.com/foo/bar\"\n assert URI.merge(base, \"#fragment\") |> to_string() == \"http://example.com/foo/bar#fragment\"\n assert URI.merge(base, \"?query\") |> to_string() == \"http://example.com/foo/bar?query\"\n assert URI.merge(base, %URI{}) |> to_string() == \"http://example.com/foo/bar\"\n\n assert URI.merge(base, %URI{fragment: \"fragment\"})\n |> to_string() == \"http://example.com/foo/bar#fragment\"\n\n base = URI.new!(\"http://example.com\")\n assert URI.merge(base, \"/foo\") |> to_string() == \"http://example.com/foo\"\n assert URI.merge(base, \"foo\") |> to_string() == \"http://example.com/foo\"\n\n base = URI.new!(\"http://example.com/foo/bar\")\n assert URI.merge(base, \"/baz\") |> to_string() == \"http://example.com/baz\"\n assert URI.merge(base, \"baz\") |> to_string() == \"http://example.com/foo/baz\"\n assert URI.merge(base, \"../baz\") |> to_string() == \"http://example.com/baz\"\n assert URI.merge(base, \".././baz\") |> to_string() == \"http://example.com/baz\"\n assert URI.merge(base, \"./baz\") |> to_string() == \"http://example.com/foo/baz\"\n assert URI.merge(base, \"bar/./baz\") |> to_string() == \"http://example.com/foo/bar/baz\"\n\n base = URI.new!(\"http://example.com/foo/bar/\")\n assert URI.merge(base, \"/baz\") |> to_string() == \"http://example.com/baz\"\n assert URI.merge(base, \"baz\") |> to_string() == \"http://example.com/foo/bar/baz\"\n assert URI.merge(base, \"../baz\") |> to_string() == \"http://example.com/foo/baz\"\n assert URI.merge(base, \".././baz\") |> to_string() == \"http://example.com/foo/baz\"\n assert URI.merge(base, \"./baz\") |> to_string() == \"http://example.com/foo/bar/baz\"\n assert URI.merge(base, \"bar/./baz\") |> to_string() == \"http://example.com/foo/bar/bar/baz\"\n\n base = URI.new!(\"http://example.com/foo/bar/baz\")\n assert URI.merge(base, \"../../foobar\") |> to_string() == \"http://example.com/foobar\"\n assert URI.merge(base, \"../../../foobar\") |> to_string() == \"http://example.com/foobar\"\n\n assert URI.merge(base, \"../../../../../../foobar\") |> to_string() ==\n \"http://example.com/foobar\"\n\n base = URI.new!(\"http://example.com/foo/../bar\")\n assert URI.merge(base, \"baz\") |> to_string() == \"http://example.com/baz\"\n\n base = URI.new!(\"http://example.com/foo/./bar\")\n assert URI.merge(base, \"baz\") |> to_string() == \"http://example.com/foo/baz\"\n\n base = URI.new!(\"http://example.com/foo?query1\")\n assert URI.merge(base, \"?query2\") |> to_string() == \"http://example.com/foo?query2\"\n assert URI.merge(base, \"\") |> to_string() == \"http://example.com/foo?query1\"\n\n base = URI.new!(\"http://example.com/foo#fragment1\")\n assert URI.merge(base, \"#fragment2\") |> to_string() == \"http://example.com/foo#fragment2\"\n assert URI.merge(base, \"\") |> to_string() == \"http://example.com/foo\"\n\n page_url = \"https://example.com/guide/\"\n image_url = \"https://images.example.com/t/1600x/https://images.example.com/foo.jpg\"\n\n assert URI.merge(URI.new!(page_url), URI.new!(image_url)) |> to_string() ==\n \"https://images.example.com/t/1600x/https://images.example.com/foo.jpg\"\n end\n\n test \"error on relative base\" do\n assert_raise ArgumentError, \"you must merge onto an absolute URI\", fn ->\n URI.merge(\"/relative\", \"\")\n end\n end\n\n test \"base without host\" do\n assert URI.merge(\"tag:example\", \"foo\") |> to_string == \"tag:foo\"\n assert URI.merge(\"tag:example\", \"#fragment\") |> to_string == \"tag:example#fragment\"\n end\n\n test \"base without host and path\" do\n assert URI.merge(\"ex:\", \"test\") |> to_string() == \"ex:test\"\n assert URI.merge(\"ex:\", \"a/b/c\") |> to_string() == \"ex:a/b/c\"\n assert URI.merge(\"ex:\", \"a/b/./../c\") |> to_string() == \"ex:a/c\"\n assert URI.merge(\"ex:\", \"test?query=value\") |> to_string() == \"ex:test?query=value\"\n assert URI.merge(\"mailto:\", \"user@example.com\") |> to_string() == \"mailto:user@example.com\"\n assert URI.merge(\"urn:isbn\", \"0451450523\") |> to_string() == \"urn:0451450523\"\n end\n\n test \"with RFC examples\" do\n # These are examples from:\n #\n # https://www.rfc-editor.org/rfc/rfc3986#section-5.4.1\n # https://www.rfc-editor.org/rfc/rfc3986#section-5.4.2\n #\n # They are taken verbatim from the above document for easy comparison\n\n base = \"http://a/b/c/d;p?q\"\n\n rel_and_result = %{\n \"g:h\" => \"g:h\",\n \"g\" => \"http://a/b/c/g\",\n \"./g\" => \"http://a/b/c/g\",\n \"g/\" => \"http://a/b/c/g/\",\n \"/g\" => \"http://a/g\",\n \"//g\" => \"http://g\",\n \"?y\" => \"http://a/b/c/d;p?y\",\n \"g?y\" => \"http://a/b/c/g?y\",\n \"#s\" => \"http://a/b/c/d;p?q#s\",\n \"g#s\" => \"http://a/b/c/g#s\",\n \"g?y#s\" => \"http://a/b/c/g?y#s\",\n \";x\" => \"http://a/b/c/;x\",\n \"g;x\" => \"http://a/b/c/g;x\",\n \"g;x?y#s\" => \"http://a/b/c/g;x?y#s\",\n \"\" => \"http://a/b/c/d;p?q\",\n \".\" => \"http://a/b/c/\",\n \"./\" => \"http://a/b/c/\",\n \"..\" => \"http://a/b/\",\n \"../\" => \"http://a/b/\",\n \"../g\" => \"http://a/b/g\",\n \"../..\" => \"http://a/\",\n \"../../\" => \"http://a/\",\n \"../../g\" => \"http://a/g\",\n \"../../../g\" => \"http://a/g\",\n \"../../../../g\" => \"http://a/g\",\n \"/./g\" => \"http://a/g\",\n \"/../g\" => \"http://a/g\",\n \"g.\" => \"http://a/b/c/g.\",\n \".g\" => \"http://a/b/c/.g\",\n \"g..\" => \"http://a/b/c/g..\",\n \"..g\" => \"http://a/b/c/..g\",\n \"./../g\" => \"http://a/b/g\",\n \"./g/.\" => \"http://a/b/c/g/\",\n \"g/./h\" => \"http://a/b/c/g/h\",\n \"g/../h\" => \"http://a/b/c/h\",\n \"g;x=1/./y\" => \"http://a/b/c/g;x=1/y\",\n \"g;x=1/../y\" => \"http://a/b/c/y\",\n \"g?y/./x\" => \"http://a/b/c/g?y/./x\",\n \"g?y/../x\" => \"http://a/b/c/g?y/../x\",\n \"g#s/./x\" => \"http://a/b/c/g#s/./x\",\n \"g#s/../x\" => \"http://a/b/c/g#s/../x\",\n \"http:g\" => \"http:g\"\n }\n\n for {rel, result} <- rel_and_result do\n assert URI.merge(base, rel) |> URI.to_string() == result\n end\n end\n\n test \"with W3C examples\" do\n # These examples are from the W3C JSON-LD test suite:\n #\n # https://w3c.github.io/json-ld-api/tests/toRdf-manifest#t0124\n # https://w3c.github.io/json-ld-api/tests/toRdf-manifest#t0125\n # https://w3c.github.io/json-ld-api/tests/toRdf-manifest#t0123\n\n base1 = \"http://a/bb/ccc/.\"\n\n rel_and_result1 = %{\n \"g:h\" => \"g:h\",\n \"g\" => \"http://a/bb/ccc/g\",\n \"./g\" => \"http://a/bb/ccc/g\",\n \"g/\" => \"http://a/bb/ccc/g/\",\n \"/g\" => \"http://a/g\",\n \"//g\" => \"http://g\",\n \"?y\" => \"http://a/bb/ccc/.?y\",\n \"g?y\" => \"http://a/bb/ccc/g?y\",\n \"#s\" => \"http://a/bb/ccc/.#s\",\n \"g#s\" => \"http://a/bb/ccc/g#s\",\n \"g?y#s\" => \"http://a/bb/ccc/g?y#s\",\n \";x\" => \"http://a/bb/ccc/;x\",\n \"g;x\" => \"http://a/bb/ccc/g;x\",\n \"g;x?y#s\" => \"http://a/bb/ccc/g;x?y#s\",\n \"\" => \"http://a/bb/ccc/.\",\n \".\" => \"http://a/bb/ccc/\",\n \"./\" => \"http://a/bb/ccc/\",\n \"..\" => \"http://a/bb/\",\n \"../\" => \"http://a/bb/\",\n \"../g\" => \"http://a/bb/g\",\n \"../..\" => \"http://a/\",\n \"../../\" => \"http://a/\",\n \"../../g\" => \"http://a/g\",\n \"../../../g\" => \"http://a/g\",\n \"../../../../g\" => \"http://a/g\",\n \"/./g\" => \"http://a/g\",\n \"/../g\" => \"http://a/g\",\n \"g.\" => \"http://a/bb/ccc/g.\",\n \".g\" => \"http://a/bb/ccc/.g\",\n \"g..\" => \"http://a/bb/ccc/g..\",\n \"..g\" => \"http://a/bb/ccc/..g\",\n \"./../g\" => \"http://a/bb/g\",\n \"./g/.\" => \"http://a/bb/ccc/g/\",\n \"g/./h\" => \"http://a/bb/ccc/g/h\",\n \"g/../h\" => \"http://a/bb/ccc/h\",\n \"g;x=1/./y\" => \"http://a/bb/ccc/g;x=1/y\",\n \"g;x=1/../y\" => \"http://a/bb/ccc/y\",\n \"g?y/./x\" => \"http://a/bb/ccc/g?y/./x\",\n \"g?y/../x\" => \"http://a/bb/ccc/g?y/../x\",\n \"g#s/./x\" => \"http://a/bb/ccc/g#s/./x\",\n \"g#s/../x\" => \"http://a/bb/ccc/g#s/../x\",\n \"http:g\" => \"http:g\"\n }\n\n for {rel, result} <- rel_and_result1 do\n assert URI.merge(base1, rel) |> URI.to_string() == result\n end\n\n base2 = \"http://a/bb/ccc/..\"\n\n rel_and_result2 = %{\n \"g:h\" => \"g:h\",\n \"g\" => \"http://a/bb/ccc/g\",\n \"./g\" => \"http://a/bb/ccc/g\",\n \"g/\" => \"http://a/bb/ccc/g/\",\n \"/g\" => \"http://a/g\",\n \"//g\" => \"http://g\",\n \"?y\" => \"http://a/bb/ccc/..?y\",\n \"g?y\" => \"http://a/bb/ccc/g?y\",\n \"#s\" => \"http://a/bb/ccc/..#s\",\n \"g#s\" => \"http://a/bb/ccc/g#s\",\n \"g?y#s\" => \"http://a/bb/ccc/g?y#s\",\n \";x\" => \"http://a/bb/ccc/;x\",\n \"g;x\" => \"http://a/bb/ccc/g;x\",\n \"g;x?y#s\" => \"http://a/bb/ccc/g;x?y#s\",\n \"\" => \"http://a/bb/ccc/..\",\n \".\" => \"http://a/bb/ccc/\",\n \"./\" => \"http://a/bb/ccc/\",\n \"..\" => \"http://a/bb/\",\n \"../\" => \"http://a/bb/\",\n \"../g\" => \"http://a/bb/g\",\n \"../..\" => \"http://a/\",\n \"../../\" => \"http://a/\",\n \"../../g\" => \"http://a/g\",\n \"../../../g\" => \"http://a/g\",\n \"../../../../g\" => \"http://a/g\",\n \"/./g\" => \"http://a/g\",\n \"/../g\" => \"http://a/g\",\n \"g.\" => \"http://a/bb/ccc/g.\",\n \".g\" => \"http://a/bb/ccc/.g\",\n \"g..\" => \"http://a/bb/ccc/g..\",\n \"..g\" => \"http://a/bb/ccc/..g\",\n \"./../g\" => \"http://a/bb/g\",\n \"./g/.\" => \"http://a/bb/ccc/g/\",\n \"g/./h\" => \"http://a/bb/ccc/g/h\",\n \"g/../h\" => \"http://a/bb/ccc/h\",\n \"g;x=1/./y\" => \"http://a/bb/ccc/g;x=1/y\",\n \"g;x=1/../y\" => \"http://a/bb/ccc/y\",\n \"g?y/./x\" => \"http://a/bb/ccc/g?y/./x\",\n \"g?y/../x\" => \"http://a/bb/ccc/g?y/../x\",\n \"g#s/./x\" => \"http://a/bb/ccc/g#s/./x\",\n \"g#s/../x\" => \"http://a/bb/ccc/g#s/../x\",\n \"http:g\" => \"http:g\"\n }\n\n for {rel, result} <- rel_and_result2 do\n assert URI.merge(base2, rel) |> URI.to_string() == result\n end\n\n base3 = \"http://a/bb/ccc/../d;p?q\"\n\n rel_and_result = %{\n \"g:h\" => \"g:h\",\n \"g\" => \"http://a/bb/g\",\n \"./g\" => \"http://a/bb/g\",\n \"g/\" => \"http://a/bb/g/\",\n \"/g\" => \"http://a/g\",\n \"//g\" => \"http://g\",\n \"?y\" => \"http://a/bb/ccc/../d;p?y\",\n \"g?y\" => \"http://a/bb/g?y\",\n \"#s\" => \"http://a/bb/ccc/../d;p?q#s\",\n \"g#s\" => \"http://a/bb/g#s\",\n \"g?y#s\" => \"http://a/bb/g?y#s\",\n \";x\" => \"http://a/bb/;x\",\n \"g;x\" => \"http://a/bb/g;x\",\n \"g;x?y#s\" => \"http://a/bb/g;x?y#s\",\n \"\" => \"http://a/bb/ccc/../d;p?q\",\n \".\" => \"http://a/bb/\",\n \"./\" => \"http://a/bb/\",\n \"..\" => \"http://a/\",\n \"../\" => \"http://a/\",\n \"../g\" => \"http://a/g\",\n \"../..\" => \"http://a/\",\n \"../../\" => \"http://a/\",\n \"../../g\" => \"http://a/g\",\n \"../../../g\" => \"http://a/g\",\n \"../../../../g\" => \"http://a/g\",\n \"/./g\" => \"http://a/g\",\n \"/../g\" => \"http://a/g\",\n \"g.\" => \"http://a/bb/g.\",\n \".g\" => \"http://a/bb/.g\",\n \"g..\" => \"http://a/bb/g..\",\n \"..g\" => \"http://a/bb/..g\",\n \"./../g\" => \"http://a/g\",\n \"./g/.\" => \"http://a/bb/g/\",\n \"g/./h\" => \"http://a/bb/g/h\",\n \"g/../h\" => \"http://a/bb/h\",\n \"g;x=1/./y\" => \"http://a/bb/g;x=1/y\",\n \"g;x=1/../y\" => \"http://a/bb/y\",\n \"g?y/./x\" => \"http://a/bb/g?y/./x\",\n \"g?y/../x\" => \"http://a/bb/g?y/../x\",\n \"g#s/./x\" => \"http://a/bb/g#s/./x\",\n \"g#s/../x\" => \"http://a/bb/g#s/../x\",\n \"http:g\" => \"http:g\"\n }\n\n for {rel, result} <- rel_and_result do\n assert URI.merge(base3, rel) |> URI.to_string() == result\n end\n end\n end\n\n test \"append_query/2\" do\n assert URI.append_query(URI.parse(\"http://example.com/?x=1\"), \"x=2\").query == \"x=1&x=2\"\n assert URI.append_query(URI.parse(\"http://example.com/?x=1&\"), \"x=2\").query == \"x=1&x=2\"\n end\n\n describe \"append_path/2\" do\n test \"with valid paths\" do\n examples = [\n {\"http://example.com\", \"/\", \"http://example.com/\"},\n {\"http://example.com/\", \"/foo\", \"http://example.com/foo\"},\n {\"http://example.com/foo\", \"/bar\", \"http://example.com/foo/bar\"},\n {\"http://example.com/foo\", \"/bar/\", \"http://example.com/foo/bar/\"},\n {\"http://example.com/foo\", \"/bar/baz\", \"http://example.com/foo/bar/baz\"},\n {\"http://example.com/foo?var=1\", \"/bar/\", \"http://example.com/foo/bar/?var=1\"},\n {\"https://example.com/page/\", \"/urn:example:page\",\n \"https://example.com/page/urn:example:page\"}\n ]\n\n for {base_url, path, expected_result} <- examples do\n result =\n base_url\n |> URI.parse()\n |> URI.append_path(path)\n |> URI.to_string()\n\n assert result == expected_result, \"\"\"\n Path did not append as expected\n\n base_url: #{inspect(base_url)}\n path: #{inspect(path)}\n\n result: #{inspect(result)}\n expected_result: #{inspect(expected_result)}\n \"\"\"\n end\n end\n\n test \"errors on invalid paths\" do\n base_uri = URI.parse(\"http://example.com\")\n\n assert_raise ArgumentError,\n ~S|path must start with \"/\", got: \"foo\"|,\n fn ->\n URI.append_path(base_uri, \"foo\")\n end\n\n assert_raise ArgumentError,\n ~S|path cannot start with \"//\", got: \"//foo\"|,\n fn ->\n URI.append_path(base_uri, \"//foo\")\n end\n end\n end\n\n ## Deprecate API\n\n describe \"authority\" do\n test \"to_string\" do\n assert URI.to_string(%URI{authority: \"foo@example.com:80\"}) ==\n \"//foo@example.com:80\"\n\n assert URI.to_string(%URI{userinfo: \"bar\", host: \"example.org\", port: 81}) ==\n \"//bar@example.org:81\"\n\n assert URI.to_string(%URI{\n authority: \"foo@example.com:80\",\n userinfo: \"bar\",\n host: \"example.org\",\n port: 81\n }) ==\n \"//bar@example.org:81\"\n end\n end\n\n describe \"parse/1\" do\n test \"returns the given URI if a %URI{} struct is given\" do\n assert URI.parse(uri = %URI{scheme: \"http\", host: \"foo.com\"}) == uri\n end\n\n test \"works with HTTP scheme\" do\n expected_uri = %URI{\n scheme: \"http\",\n host: \"foo.com\",\n path: \"/path/to/something\",\n query: \"foo=bar&bar=foo\",\n fragment: \"fragment\",\n port: 80,\n authority: \"foo.com\",\n userinfo: nil\n }\n\n assert URI.parse(\"http://foo.com/path/to/something?foo=bar&bar=foo#fragment\") ==\n expected_uri\n end\n\n test \"works with HTTPS scheme\" do\n expected_uri = %URI{\n scheme: \"https\",\n host: \"foo.com\",\n authority: \"foo.com\",\n query: nil,\n fragment: nil,\n port: 443,\n path: nil,\n userinfo: nil\n }\n\n assert URI.parse(\"https://foo.com\") == expected_uri\n end\n\n test \"works with \\\"file\\\" scheme\" do\n expected_uri = %URI{\n scheme: \"file\",\n host: \"\",\n path: \"/foo/bar/baz\",\n userinfo: nil,\n query: nil,\n fragment: nil,\n port: nil,\n authority: \"\"\n }\n\n assert URI.parse(\"file:///foo/bar/baz\") == expected_uri\n end\n\n test \"works with FTP scheme\" do\n expected_uri = %URI{\n scheme: \"ftp\",\n host: \"private.ftp-server.example.com\",\n userinfo: \"user001:password\",\n authority: \"user001:password@private.ftp-server.example.com\",\n path: \"/my_directory/my_file.txt\",\n query: nil,\n fragment: nil,\n port: 21\n }\n\n ftp = \"ftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt\"\n assert URI.parse(ftp) == expected_uri\n end\n\n test \"works with SFTP scheme\" do\n expected_uri = %URI{\n scheme: \"sftp\",\n host: \"private.ftp-server.example.com\",\n userinfo: \"user001:password\",\n authority: \"user001:password@private.ftp-server.example.com\",\n path: \"/my_directory/my_file.txt\",\n query: nil,\n fragment: nil,\n port: 22\n }\n\n sftp = \"sftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt\"\n assert URI.parse(sftp) == expected_uri\n end\n\n test \"works with TFTP scheme\" do\n expected_uri = %URI{\n scheme: \"tftp\",\n host: \"private.ftp-server.example.com\",\n userinfo: \"user001:password\",\n authority: \"user001:password@private.ftp-server.example.com\",\n path: \"/my_directory/my_file.txt\",\n query: nil,\n fragment: nil,\n port: 69\n }\n\n tftp = \"tftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt\"\n assert URI.parse(tftp) == expected_uri\n end\n\n test \"works with LDAP scheme\" do\n expected_uri = %URI{\n scheme: \"ldap\",\n host: \"\",\n authority: \"\",\n userinfo: nil,\n path: \"/dc=example,dc=com\",\n query: \"?sub?(givenName=John)\",\n fragment: nil,\n port: 389\n }\n\n assert URI.parse(\"ldap:///dc=example,dc=com??sub?(givenName=John)\") == expected_uri\n\n expected_uri = %URI{\n scheme: \"ldap\",\n host: \"ldap.example.com\",\n authority: \"ldap.example.com\",\n userinfo: nil,\n path: \"/cn=John%20Doe,dc=foo,dc=com\",\n fragment: nil,\n port: 389,\n query: nil\n }\n\n assert URI.parse(\"ldap://ldap.example.com/cn=John%20Doe,dc=foo,dc=com\") == expected_uri\n end\n\n test \"works with WebSocket scheme\" do\n expected_uri = %URI{\n authority: \"ws.example.com\",\n fragment: \"content\",\n host: \"ws.example.com\",\n path: \"/path/to\",\n port: 80,\n query: \"here\",\n scheme: \"ws\",\n userinfo: nil\n }\n\n assert URI.parse(\"ws://ws.example.com/path/to?here#content\") == expected_uri\n end\n\n test \"works with WebSocket Secure scheme\" do\n expected_uri = %URI{\n authority: \"ws.example.com\",\n fragment: \"content\",\n host: \"ws.example.com\",\n path: \"/path/to\",\n port: 443,\n query: \"here\",\n scheme: \"wss\",\n userinfo: nil\n }\n\n assert URI.parse(\"wss://ws.example.com/path/to?here#content\") == expected_uri\n end\n\n test \"splits authority\" do\n expected_uri = %URI{\n scheme: \"http\",\n host: \"foo.com\",\n path: nil,\n query: nil,\n fragment: nil,\n port: 4444,\n authority: \"foo:bar@foo.com:4444\",\n userinfo: \"foo:bar\"\n }\n\n assert URI.parse(\"http://foo:bar@foo.com:4444\") == expected_uri\n\n expected_uri = %URI{\n scheme: \"https\",\n host: \"foo.com\",\n path: nil,\n query: nil,\n fragment: nil,\n port: 443,\n authority: \"foo:bar@foo.com\",\n userinfo: \"foo:bar\"\n }\n\n assert URI.parse(\"https://foo:bar@foo.com\") == expected_uri\n\n expected_uri = %URI{\n scheme: \"http\",\n host: \"foo.com\",\n path: nil,\n query: nil,\n fragment: nil,\n port: 4444,\n authority: \"foo.com:4444\",\n userinfo: nil\n }\n\n assert URI.parse(\"http://foo.com:4444\") == expected_uri\n end\n\n test \"can parse bad URIs\" do\n assert URI.parse(\"\")\n assert URI.parse(\"https:??@?F?@#>F//23/\")\n\n assert URI.parse(\":https\").path == \":https\"\n assert URI.parse(\"https\").path == \"https\"\n assert URI.parse(\"ht\\0tps://foo.com\").path == \"ht\\0tps://foo.com\"\n end\n\n test \"can parse IPv6 addresses\" do\n addresses = [\n # undefined\n \"::\",\n # loopback\n \"::1\",\n # unicast\n \"1080::8:800:200C:417A\",\n # multicast\n \"FF01::101\",\n # link-local\n \"fe80::\",\n # abbreviated\n \"2607:f3f0:2:0:216:3cff:fef0:174a\",\n # mixed hex case\n \"2607:f3F0:2:0:216:3cFf:Fef0:174A\",\n # complete\n \"2051:0db8:2d5a:3521:8313:ffad:1242:8e2e\",\n # embedded IPv4\n \"::00:192.168.10.184\"\n ]\n\n Enum.each(addresses, fn addr ->\n simple_uri = URI.parse(\"http://[#{addr}]/\")\n assert simple_uri.authority == \"[#{addr}]\"\n assert simple_uri.host == addr\n\n userinfo_uri = URI.parse(\"http://user:pass@[#{addr}]/\")\n assert userinfo_uri.authority == \"user:pass@[#{addr}]\"\n assert userinfo_uri.host == addr\n assert userinfo_uri.userinfo == \"user:pass\"\n\n port_uri = URI.parse(\"http://[#{addr}]:2222/\")\n assert port_uri.authority == \"[#{addr}]:2222\"\n assert port_uri.host == addr\n assert port_uri.port == 2222\n\n userinfo_port_uri = URI.parse(\"http://user:pass@[#{addr}]:2222/\")\n assert userinfo_port_uri.authority == \"user:pass@[#{addr}]:2222\"\n assert userinfo_port_uri.host == addr\n assert userinfo_port_uri.userinfo == \"user:pass\"\n assert userinfo_port_uri.port == 2222\n end)\n end\n\n test \"downcases the scheme\" do\n assert URI.parse(\"hTtP://google.com\").scheme == \"http\"\n end\n\n test \"preserves empty fragments\" do\n assert URI.parse(\"http://example.com#\").fragment == \"\"\n assert URI.parse(\"http://example.com/#\").fragment == \"\"\n assert URI.parse(\"http://example.com/test#\").fragment == \"\"\n end\n\n test \"preserves an empty query\" do\n assert URI.parse(\"http://foo.com/?\").query == \"\"\n end\n\n test \"merges empty path\" do\n base = URI.parse(\"http://example.com\")\n assert URI.merge(base, \"/foo\") |> to_string() == \"http://example.com/foo\"\n assert URI.merge(base, \"foo\") |> to_string() == \"http://example.com/foo\"\n end\n\n test \"merges when base path is empty string\" do\n base = %URI{scheme: \"http\", host: \"example.com\", path: \"\"}\n assert URI.merge(base, \"foo\") |> to_string() == \"http://example.com/foo\"\n assert URI.merge(base, \"/bar\") |> to_string() == \"http://example.com/bar\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/elixir/version_test.exs", "content": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: 2021 The Elixir Team\n# SPDX-FileCopyrightText: 2012 Plataformatec\n\nCode.require_file(\"test_helper.exs\", __DIR__)\n\ndefmodule VersionTest do\n use ExUnit.Case, async: true\n\n doctest Version\n\n alias Version.Parser\n\n test \"compare/2 with valid versions\" do\n assert Version.compare(\"1.0.1\", \"1.0.0\") == :gt\n assert Version.compare(\"1.1.0\", \"1.0.1\") == :gt\n assert Version.compare(\"2.1.1\", \"1.2.2\") == :gt\n assert Version.compare(\"1.0.0\", \"1.0.0-dev\") == :gt\n assert Version.compare(\"1.2.3-dev\", \"0.1.2\") == :gt\n assert Version.compare(\"1.0.0-a.b\", \"1.0.0-a\") == :gt\n assert Version.compare(\"1.0.0-b\", \"1.0.0-a.b\") == :gt\n assert Version.compare(\"1.0.0-a\", \"1.0.0-0\") == :gt\n assert Version.compare(\"1.0.0-a.b\", \"1.0.0-a.a\") == :gt\n\n assert Version.compare(\"1.0.0\", \"1.0.1\") == :lt\n assert Version.compare(\"1.0.1\", \"1.1.0\") == :lt\n assert Version.compare(\"1.2.2\", \"2.1.1\") == :lt\n assert Version.compare(\"1.0.0-dev\", \"1.0.0\") == :lt\n assert Version.compare(\"0.1.2\", \"1.2.3-dev\") == :lt\n assert Version.compare(\"1.0.0-a\", \"1.0.0-a.b\") == :lt\n assert Version.compare(\"1.0.0-a.b\", \"1.0.0-b\") == :lt\n assert Version.compare(\"1.0.0-0\", \"1.0.0-a\") == :lt\n assert Version.compare(\"1.0.0-a.a\", \"1.0.0-a.b\") == :lt\n\n assert Version.compare(\"1.0.0\", \"1.0.0\") == :eq\n assert Version.compare(\"1.0.0-dev\", \"1.0.0-dev\") == :eq\n assert Version.compare(\"1.0.0-a\", \"1.0.0-a\") == :eq\n assert Version.compare(\"1.5.0-rc.0\", \"1.5.0-rc0\") == :lt\n end\n\n test \"compare/2 with invalid versions\" do\n assert_raise Version.InvalidVersionError, fn ->\n Version.compare(\"1.0\", \"1.0.0\")\n end\n\n assert_raise Version.InvalidVersionError, fn ->\n Version.compare(\"1.0.0-dev\", \"1.0\")\n end\n\n assert_raise Version.InvalidVersionError, fn ->\n Version.compare(\"foo\", \"1.0.0-a\")\n end\n end\n\n test \"lexes specifications properly\" do\n assert Parser.lexer(\"== > >= < <= ~>\") |> Enum.reverse() == [:==, :>, :>=, :<, :<=, :~>]\n assert Parser.lexer(\"2.3.0\") |> Enum.reverse() == [:==, \"2.3.0\"]\n assert Parser.lexer(\">>=\") |> Enum.reverse() == [:>, :>=]\n assert Parser.lexer(\">2.4.0\") |> Enum.reverse() == [:>, \"2.4.0\"]\n assert Parser.lexer(\"> 2.4.0\") |> Enum.reverse() == [:>, \"2.4.0\"]\n assert Parser.lexer(\" > 2.4.0\") |> Enum.reverse() == [:>, \"2.4.0\"]\n assert Parser.lexer(\" or 2.1.0\") |> Enum.reverse() == [:or, :==, \"2.1.0\"]\n assert Parser.lexer(\" and 2.1.0\") |> Enum.reverse() == [:and, :==, \"2.1.0\"]\n\n assert Parser.lexer(\">= 2.0.0 and < 2.1.0\") |> Enum.reverse() ==\n [:>=, \"2.0.0\", :and, :<, \"2.1.0\"]\n\n assert Parser.lexer(\">= 2.0.0 or < 2.1.0\") |> Enum.reverse() ==\n [:>=, \"2.0.0\", :or, :<, \"2.1.0\"]\n end\n\n test \"parse/1\" do\n assert {:ok, %Version{major: 1, minor: 2, patch: 3}} = Version.parse(\"1.2.3\")\n\n assert {:ok, %Version{major: 1, minor: 4, patch: 5, build: \"ignore\"}} =\n Version.parse(\"1.4.5+ignore\")\n\n assert {:ok, %Version{major: 0, minor: 0, patch: 1, build: \"sha.0702245\"}} =\n Version.parse(\"0.0.1+sha.0702245\")\n\n assert {:ok, %Version{major: 1, minor: 4, patch: 5, pre: [\"6-g3318bd5\"]}} =\n Version.parse(\"1.4.5-6-g3318bd5\")\n\n assert {:ok, %Version{major: 1, minor: 4, patch: 5, pre: [6, 7, \"eight\"]}} =\n Version.parse(\"1.4.5-6.7.eight\")\n\n assert {:ok, %Version{major: 1, minor: 4, patch: 5, pre: [\"6-g3318bd5\"]}} =\n Version.parse(\"1.4.5-6-g3318bd5+ignore\")\n\n assert Version.parse(\"foobar\") == :error\n assert Version.parse(\"2\") == :error\n assert Version.parse(\"2.\") == :error\n assert Version.parse(\"2.3\") == :error\n assert Version.parse(\"2.3.\") == :error\n assert Version.parse(\"2.3.0-\") == :error\n assert Version.parse(\"2.3.0+\") == :error\n assert Version.parse(\"2.3.0.\") == :error\n assert Version.parse(\"2.3.0.4\") == :error\n assert Version.parse(\"2.3.-rc.1\") == :error\n assert Version.parse(\"2.3.+rc.1\") == :error\n assert Version.parse(\"2.3.0-01\") == :error\n assert Version.parse(\"2.3.00-1\") == :error\n assert Version.parse(\"2.3.00\") == :error\n assert Version.parse(\"2.03.0\") == :error\n assert Version.parse(\"02.3.0\") == :error\n assert Version.parse(\"0. 0.0\") == :error\n assert Version.parse(\"0.1.0-&&pre\") == :error\n end\n\n test \"to_string/1\" do\n assert Version.parse!(\"1.0.0\") |> Version.to_string() == \"1.0.0\"\n assert Version.parse!(\"1.0.0-dev\") |> Version.to_string() == \"1.0.0-dev\"\n assert Version.parse!(\"1.0.0+lol\") |> Version.to_string() == \"1.0.0+lol\"\n assert Version.parse!(\"1.0.0-dev+lol\") |> Version.to_string() == \"1.0.0-dev+lol\"\n assert Version.parse!(\"1.0.0-dev+lol.4\") |> Version.to_string() == \"1.0.0-dev+lol.4\"\n assert Version.parse!(\"1.0.0-0\") |> Version.to_string() == \"1.0.0-0\"\n assert Version.parse!(\"1.0.0-rc.0\") |> Version.to_string() == \"1.0.0-rc.0\"\n assert %Version{major: 1, minor: 0, patch: 0} |> Version.to_string() == \"1.0.0\"\n end\n\n test \"to_string/1 via protocol\" do\n assert Version.parse!(\"1.0.0\") |> to_string() == \"1.0.0\"\n end\n\n test \"inspect/1\" do\n assert Version.parse!(\"1.0.0\") |> inspect() == \"%Version{major: 1, minor: 0, patch: 0}\"\n end\n\n test \"match?/2 with invalid versions\" do\n assert_raise Version.InvalidVersionError, fn ->\n Version.match?(\"foo\", \"2.3.0\")\n end\n\n assert_raise Version.InvalidVersionError, fn ->\n Version.match?(\"2.3\", \"2.3.0\")\n end\n\n assert_raise Version.InvalidRequirementError, fn ->\n Version.match?(\"2.3.0\", \"foo\")\n end\n\n assert_raise Version.InvalidRequirementError, fn ->\n Version.match?(\"2.3.0\", \"2.3\")\n end\n end\n\n test \"==\" do\n assert Version.match?(\"2.3.0\", \"2.3.0\")\n refute Version.match?(\"2.4.0\", \"2.3.0\")\n\n assert Version.match?(\"2.3.0\", \"== 2.3.0\")\n refute Version.match?(\"2.4.0\", \"== 2.3.0\")\n\n assert Version.match?(\"1.0.0\", \"1.0.0\")\n assert Version.match?(\"1.0.0\", \"1.0.0\")\n\n assert Version.match?(\"1.2.3-alpha\", \"1.2.3-alpha\")\n\n assert Version.match?(\"0.9.3\", \"== 0.9.3+dev\")\n\n {:ok, vsn} = Version.parse(\"2.3.0\")\n assert Version.match?(vsn, \"2.3.0\")\n end\n\n test \"!=\" do\n ExUnit.CaptureIO.capture_io(:stderr, fn ->\n assert Version.match?(\"2.4.0\", \"!2.3.0\")\n refute Version.match?(\"2.3.0\", \"!2.3.0\")\n\n assert Version.match?(\"2.4.0\", \"!= 2.3.0\")\n refute Version.match?(\"2.3.0\", \"!= 2.3.0\")\n end)\n end\n\n test \">\" do\n assert Version.match?(\"2.4.0\", \"> 2.3.0\")\n refute Version.match?(\"2.2.0\", \"> 2.3.0\")\n refute Version.match?(\"2.3.0\", \"> 2.3.0\")\n\n assert Version.match?(\"1.2.3\", \"> 1.2.3-alpha\")\n assert Version.match?(\"1.2.3-alpha.1\", \"> 1.2.3-alpha\")\n assert Version.match?(\"1.2.3-alpha.beta.sigma\", \"> 1.2.3-alpha.beta\")\n refute Version.match?(\"1.2.3-alpha.10\", \"< 1.2.3-alpha.1\")\n refute Version.match?(\"0.10.2-dev\", \"> 0.10.2\")\n\n refute Version.match?(\"1.5.0-rc.0\", \"> 1.5.0-rc0\")\n assert Version.match?(\"1.5.0-rc0\", \"> 1.5.0-rc.0\")\n end\n\n test \">=\" do\n assert Version.match?(\"2.4.0\", \">= 2.3.0\")\n refute Version.match?(\"2.2.0\", \">= 2.3.0\")\n assert Version.match?(\"2.3.0\", \">= 2.3.0\")\n\n assert Version.match?(\"2.0.0\", \">= 1.0.0\")\n assert Version.match?(\"1.0.0\", \">= 1.0.0\")\n\n refute Version.match?(\"1.5.0-rc.0\", \">= 1.5.0-rc0\")\n assert Version.match?(\"1.5.0-rc0\", \">= 1.5.0-rc.0\")\n end\n\n test \"<\" do\n assert Version.match?(\"2.2.0\", \"< 2.3.0\")\n refute Version.match?(\"2.4.0\", \"< 2.3.0\")\n refute Version.match?(\"2.3.0\", \"< 2.3.0\")\n\n assert Version.match?(\"0.10.2-dev\", \"< 0.10.2\")\n\n refute Version.match?(\"1.0.0\", \"< 1.0.0-dev\")\n refute Version.match?(\"1.2.3-dev\", \"< 0.1.2\")\n end\n\n test \"<=\" do\n assert Version.match?(\"2.2.0\", \"<= 2.3.0\")\n refute Version.match?(\"2.4.0\", \"<= 2.3.0\")\n assert Version.match?(\"2.3.0\", \"<= 2.3.0\")\n end\n\n describe \"~>\" do\n test \"regular cases\" do\n assert Version.match?(\"3.0.0\", \"~> 3.0\")\n assert Version.match?(\"3.2.0\", \"~> 3.0\")\n refute Version.match?(\"4.0.0\", \"~> 3.0\")\n refute Version.match?(\"4.4.0\", \"~> 3.0\")\n\n assert Version.match?(\"3.0.2\", \"~> 3.0.0\")\n assert Version.match?(\"3.0.0\", \"~> 3.0.0\")\n refute Version.match?(\"3.1.0\", \"~> 3.0.0\")\n refute Version.match?(\"3.4.0\", \"~> 3.0.0\")\n\n assert Version.match?(\"3.6.0\", \"~> 3.5\")\n assert Version.match?(\"3.5.0\", \"~> 3.5\")\n refute Version.match?(\"4.0.0\", \"~> 3.5\")\n refute Version.match?(\"5.0.0\", \"~> 3.5\")\n\n assert Version.match?(\"3.5.2\", \"~> 3.5.0\")\n assert Version.match?(\"3.5.4\", \"~> 3.5.0\")\n refute Version.match?(\"3.6.0\", \"~> 3.5.0\")\n refute Version.match?(\"3.6.3\", \"~> 3.5.0\")\n\n assert Version.match?(\"0.9.3\", \"~> 0.9.3-dev\")\n refute Version.match?(\"0.10.0\", \"~> 0.9.3-dev\")\n\n refute Version.match?(\"0.3.0-dev\", \"~> 0.2.0\")\n\n assert Version.match?(\"1.11.0-dev\", \"~> 1.11-dev\")\n assert Version.match?(\"1.11.0\", \"~> 1.11-dev\")\n assert Version.match?(\"1.12.0\", \"~> 1.11-dev\")\n refute Version.match?(\"1.10.0\", \"~> 1.11-dev\")\n refute Version.match?(\"2.0.0\", \"~> 1.11-dev\")\n\n refute Version.match?(\"1.5.0-rc.0\", \"~> 1.5.0-rc0\")\n assert Version.match?(\"1.5.0-rc0\", \"~> 1.5.0-rc.0\")\n\n assert_raise Version.InvalidRequirementError, fn ->\n Version.match?(\"3.0.0\", \"~> 3\")\n end\n end\n\n test \"~> will never include pre-release versions of its upper bound\" do\n refute Version.match?(\"2.2.0-dev\", \"~> 2.1.0\")\n refute Version.match?(\"2.2.0-dev\", \"~> 2.1.0\", allow_pre: false)\n refute Version.match?(\"2.2.0-dev\", \"~> 2.1.0-dev\")\n refute Version.match?(\"2.2.0-dev\", \"~> 2.1.0-dev\", allow_pre: false)\n end\n end\n\n test \"allow_pre\" do\n assert Version.match?(\"1.1.0\", \"~> 1.0\", allow_pre: true)\n assert Version.match?(\"1.1.0\", \"~> 1.0\", allow_pre: false)\n assert Version.match?(\"1.1.0-beta\", \"~> 1.0\", allow_pre: true)\n refute Version.match?(\"1.1.0-beta\", \"~> 1.0\", allow_pre: false)\n assert Version.match?(\"1.0.1-beta\", \"~> 1.0.0-beta\", allow_pre: false)\n\n assert Version.match?(\"1.1.0\", \">= 1.0.0\", allow_pre: true)\n assert Version.match?(\"1.1.0\", \">= 1.0.0\", allow_pre: false)\n assert Version.match?(\"1.1.0-beta\", \">= 1.0.0\", allow_pre: true)\n refute Version.match?(\"1.1.0-beta\", \">= 1.0.0\", allow_pre: false)\n assert Version.match?(\"1.1.0-beta\", \">= 1.0.0-beta\", allow_pre: false)\n end\n\n test \"and\" do\n assert Version.match?(\"0.9.3\", \"> 0.9.0 and < 0.10.0\")\n refute Version.match?(\"0.10.2\", \"> 0.9.0 and < 0.10.0\")\n end\n\n test \"or\" do\n assert Version.match?(\"0.9.1\", \"0.9.1 or 0.9.3 or 0.9.5\")\n assert Version.match?(\"0.9.3\", \"0.9.1 or 0.9.3 or 0.9.5\")\n assert Version.match?(\"0.9.5\", \"0.9.1 or 0.9.3 or 0.9.5\")\n refute Version.match?(\"0.9.6\", \"0.9.1 or 0.9.3 or 0.9.5\")\n end\n\n test \"and/or\" do\n req = \"< 0.2.0 and >= 0.1.0 or >= 0.7.0\"\n assert Version.match?(\"0.1.0\", req)\n assert Version.match?(\"0.1.5\", req)\n refute Version.match?(\"0.3.0\", req)\n refute Version.match?(\"0.6.0\", req)\n assert Version.match?(\"0.7.0\", req)\n assert Version.match?(\"0.7.5\", req)\n\n req = \">= 0.7.0 or < 0.2.0 and >= 0.1.0\"\n assert Version.match?(\"0.1.0\", req)\n assert Version.match?(\"0.1.5\", req)\n refute Version.match?(\"0.3.0\", req)\n refute Version.match?(\"0.6.0\", req)\n assert Version.match?(\"0.7.0\", req)\n assert Version.match?(\"0.7.5\", req)\n\n req = \"< 0.2.0 and >= 0.1.0 or < 0.8.0 and >= 0.7.0\"\n assert Version.match?(\"0.1.0\", req)\n assert Version.match?(\"0.1.5\", req)\n refute Version.match?(\"0.3.0\", req)\n refute Version.match?(\"0.6.0\", req)\n assert Version.match?(\"0.7.0\", req)\n assert Version.match?(\"0.7.5\", req)\n\n req = \"== 0.2.0 or >= 0.3.0 and < 0.4.0 or == 0.7.0\"\n assert Version.match?(\"0.2.0\", req)\n refute Version.match?(\"0.2.5\", req)\n assert Version.match?(\"0.3.0\", req)\n assert Version.match?(\"0.3.5\", req)\n refute Version.match?(\"0.4.0\", req)\n assert Version.match?(\"0.7.0\", req)\n end\n\n describe \"requirement\" do\n test \"compile_requirement/1\" do\n {:ok, req} = Version.parse_requirement(\"1.2.3\")\n assert req == Version.compile_requirement(req)\n\n assert Version.match?(\"1.2.3\", req)\n refute Version.match?(\"1.2.4\", req)\n\n assert Version.parse_requirement(\"1 . 2 . 3\") == :error\n assert Version.parse_requirement(\"== >= 1.2.3\") == :error\n assert Version.parse_requirement(\"1.2.3 and or 4.5.6\") == :error\n assert Version.parse_requirement(\">= 1\") == :error\n assert Version.parse_requirement(\"1.2.3 >=\") == :error\n end\n\n test \"inspect/1\" do\n assert Version.parse_requirement!(\"1.0.0\") |> inspect() ==\n \"Version.parse_requirement!(\\\"1.0.0\\\")\"\n end\n end\nend\n" }, { "path": "lib/elixir/test/erlang/atom_test.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(atom_test).\n-export([kv/1]).\n-include_lib(\"eunit/include/eunit.hrl\").\n\neval(Content) ->\n Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<\"nofile\">>, []),\n {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),\n {Value, Binding}.\n\nkv([{Key, nil}]) -> Key.\n\natom_with_punctuation_test() ->\n {foo@bar, []} = eval(\":foo@bar\"),\n {'a?', []} = eval(\":a?\"),\n {'a!', []} = eval(\":a!\"),\n {'||', []} = eval(\":||\"),\n {'...', []} = eval(\":...\").\n\natom_quoted_call_test() ->\n {3, []} = eval(\"Kernel.\\\"+\\\"(1, 2)\").\n\nkv_with_quotes_test() ->\n {'foo bar', []} = eval(\":atom_test.kv(\\\"foo bar\\\": nil)\").\n\nkv_with_interpolation_test() ->\n {'foo', []} = eval(\":atom_test.kv(\\\"#{\\\"foo\\\"}\\\": nil)\"),\n {'foo', []} = eval(\":atom_test.kv(\\\"#{\\\"fo\\\"}o\\\": nil)\"),\n {'foo', _} = eval(\"a = \\\"f\\\"; :atom_test.kv(\\\"#{a}#{\\\"o\\\"}o\\\": nil)\").\n\nquoted_atom_test() ->\n {'+', []} = eval(\":\\\"+\\\"\"),\n {'foo bar', []} = eval(\":\\\"foo bar\\\"\").\n\natom_with_interpolation_test() ->\n {foo, []} = eval(\":\\\"f#{\\\"o\\\"}o\\\"\"),\n {foo, _} = eval(\"a=\\\"foo\\\"; :\\\"#{a}\\\"\"),\n {foo, _} = eval(\"a=\\\"oo\\\"; :\\\"f#{a}\\\"\"),\n {foo, _} = eval(\"a=\\\"fo\\\"; :\\\"#{a}o\\\"\"),\n {fof, _} = eval(\"a=\\\"f\\\"; :\\\"#{a}o#{a}\\\"\").\n\nquoted_atom_chars_are_escaped_test() ->\n {'\"', []} = eval(\":\\\"\\\\\\\"\\\"\").\n" }, { "path": "lib/elixir/test/erlang/control_test.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(control_test).\n-include_lib(\"eunit/include/eunit.hrl\").\n\nto_erl(String) ->\n Forms = elixir:'string_to_quoted!'(String, 1, 1, <<\"nofile\">>, []),\n {Expr, _, _, _} = elixir:quoted_to_erl(Forms, elixir:env_for_eval([])),\n Expr.\n\ncond_line_test() ->\n {'case', 1, _,\n [{clause, 2, _, _, _},\n {clause, 3, _, _, _}]\n } = to_erl(\"cond do\\n 1 -> :ok\\n 2 -> :ok\\nend\").\n\nfloat_match_test() ->\n {'case', _, _,\n [{clause, _, [{op, _, '+', {float, _, +0.0}}], [], [{atom, _, pos}]},\n {clause, _, [{op, _, '-', {float, _, +0.0}}], [], [{atom, _, neg}]}]\n } = to_erl(\"case X do\\n +0.0 -> :pos\\n -0.0 -> :neg\\nend\").\n\n% Optimized\n\noptimized_if_test() ->\n {'case', _, _,\n [{clause, _, [{atom, _, false}], [], [{atom, _, 'else'}]},\n {clause, _, [{atom, _, true}], [], [{atom, _, do}]}]\n } = to_erl(\"if is_list([]), do: :do, else: :else\").\n\noptimized_andand_test() ->\n {'case', _, _,\n [{clause, _,\n [{var, _, Var}],\n [[{op, _, 'orelse', _, _}]],\n [{var, _, Var}]},\n {clause, _, [{var, _, '_'}], [], [{atom, 1, done}]}]\n } = to_erl(\"is_list([]) && :done\").\n\noptimized_oror_test() ->\n {'case', _, _,\n [{clause, 1,\n [{var, 1, _}],\n [[{op, _, 'orelse', _, _}]],\n [{atom, 1, done}]},\n {clause, 1, [{var, 1, Var}], [], [{var, 1, Var}]}]\n } = to_erl(\"is_list([]) || :done\").\n\noptimized_and_test() ->\n {'case',_, _,\n [{clause, _, [{atom, _, false}], [], [{atom, _, false}]},\n {clause, _, [{atom, _, true}], [], [{atom, _, done}]}]\n } = to_erl(\"is_list([]) and :done\").\n\noptimized_or_test() ->\n {'case', _, _,\n [{clause, _, [{atom, _, false}], [], [{atom, _, done}]},\n {clause, _, [{atom, _, true}], [], [{atom, _, true}]}]\n } = to_erl(\"is_list([]) or :done\").\n\nno_after_in_try_test() ->\n {'try', _, [_], [], [_], []} = to_erl(\"try do :foo.bar() catch _ -> :ok end\").\n\noptimized_inspect_interpolation_test() ->\n {bin, _,\n [{bin_element, _,\n {call, _, {remote, _,{atom, _, 'Elixir.Kernel'}, {atom, _, inspect}}, [_]},\n default, [binary]}]} = to_erl(\"\\\"#{inspect(1)}\\\"\").\n\noptimized_map_put_test() ->\n {map, _,\n [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},\n {map_field_assoc, _, {atom, _, b}, {integer, _, 2}}]\n } = to_erl(\"Map.put(%{a: 1}, :b, 2)\").\n\noptimized_map_put_variable_test() ->\n {block, _,\n [_,\n {map, _, {var, _, _},\n [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}}]\n }]\n } = to_erl(\"x = %{}; Map.put(x, :a, 1)\").\n\noptimized_nested_map_put_variable_test() ->\n {block, _,\n [_,\n {map, _, {var, _, _},\n [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},\n {map_field_assoc, _, {atom, _, b}, {integer, _, 2}}]\n }]\n } = to_erl(\"x = %{}; Map.put(Map.put(x, :a, 1), :b, 2)\").\n\noptimized_map_merge_test() ->\n {map, _,\n [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},\n {map_field_assoc, _, {atom, _, b}, {integer, _, 2}},\n {map_field_assoc, _, {atom, _, c}, {integer, _, 3}}]\n } = to_erl(\"Map.merge(%{a: 1, b: 2}, %{c: 3})\").\n\noptimized_map_merge_variable_test() ->\n {block, _,\n [_,\n {map, _, {var, _, _},\n [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}}]\n }]\n } = to_erl(\"x = %{}; Map.merge(x, %{a: 1})\").\n\noptimized_map_update_and_merge_test() ->\n {block, _,\n [_,\n {map, _, {var, _, _},\n [{map_field_exact, _, {atom, _, a}, {integer, _, 2}},\n {map_field_assoc, _, {atom, _, b}, {integer, _, 3}}]\n }]\n } = to_erl(\"x = %{a: 1}; Map.merge(%{x | a: 2}, %{b: 3})\"),\n {block, _,\n [_,\n {call, _, {remote, _, {atom, _, maps}, {atom, _, merge}},\n [{map, _,\n [{map_field_assoc, _, {atom, _, a}, {integer, _, 2}}]},\n {map, _, {var, _, _},\n [{map_field_exact, _, {atom, _, b}, {integer, _, 3}}]}]\n }]\n } = to_erl(\"x = %{a: 1}; Map.merge(%{a: 2}, %{x | b: 3})\").\n\noptimized_nested_map_merge_variable_test() ->\n {block, _,\n [_,\n {map, _, {var, _, _},\n [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},\n {map_field_assoc, _, {atom, _, b}, {integer, _, 2}}]\n }]\n } = to_erl(\"x = %{}; Map.merge(Map.merge(x, %{a: 1}), %{b: 2})\").\n\noptimized_map_set_new_test() ->\n {map, _,\n [\n {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.MapSet'}},\n {map_field_assoc, _,\n {atom, _, map},\n {map, _, [\n {map_field_assoc, _, {integer, _, 1}, {nil, _}},\n {map_field_assoc, _, {integer, _, 2}, {nil, _}},\n {map_field_assoc, _, {integer, _, 3}, {nil, _}}\n ]}\n }\n ]\n } = to_erl(\"MapSet.new([1, 2, 3])\").\n\nnot_optimized_map_set_new_with_range_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.MapSet'}, {atom, _, new}}, [\n {map, _, [\n {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Range'}},\n {map_field_assoc, _, {atom, _, first}, {integer, _, 1}},\n {map_field_assoc, _, {atom, _, last}, {integer, _, 3}},\n {map_field_assoc, _, {atom, _, step}, {integer, _, 1}}\n ]}\n ]\n } = to_erl(\"MapSet.new(1..3)\").\n\nmap_set_new_with_failing_args_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.MapSet'}, {atom, _, new}}, [\n {atom, _, not_an_enumerable}\n ]\n } = to_erl(\"MapSet.new(:not_an_enumerable)\").\n\noptimized_date_shift_duration_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.Date'}, {atom, _, shift}}, [\n {atom, _, non_important},\n {map, _, [\n {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},\n {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},\n {map_field_assoc, _, {atom, _, minute}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, second}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, week}, {integer, _, 1}},\n {map_field_assoc, _, {atom, _, year}, {integer, _, 0}}\n ]}\n ]\n } = to_erl(\"Date.shift(:non_important, week: 1)\").\n\nnot_optimized_date_shift_duration_unsupported_unit_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.Date'}, {atom, _, shift}}, [\n {atom, _, non_important},\n {cons, _, {tuple, _, [{atom, _, hour}, {integer, _, 1}]}, {nil, _}}\n ]\n } = to_erl(\"Date.shift(:non_important, hour: 1)\").\n\noptimized_time_shift_duration_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.Time'}, {atom, _, shift}}, [\n {atom, _, non_important},\n {map, _, [\n {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},\n {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},\n {map_field_assoc, _, {atom, _, minute}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, second}, {integer, _, 2}},\n {map_field_assoc, _, {atom, _, week}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, year}, {integer, _, 0}}\n ]}\n ]\n } = to_erl(\"Time.shift(:non_important, second: 2)\").\n\nnot_optimized_time_shift_duration_unsupported_unit_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.Time'}, {atom, _, shift}}, [\n {atom, _, non_important},\n {cons, _, {tuple, _, [{atom, _, day}, {integer, _, 2}]}, {nil, _}}\n ]\n } = to_erl(\"Time.shift(:non_important, day: 2)\").\n\noptimized_date_time_shift_duration_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.DateTime'}, {atom, _, shift}}, [\n {atom, _, non_important},\n {map, _, [\n {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},\n {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},\n {map_field_assoc, _, {atom, _, minute}, {integer, _, 3}},\n {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, second}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, week}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, year}, {integer, _, 0}}\n ]}\n ]\n } = to_erl(\"DateTime.shift(:non_important, minute: 3)\").\n\nnon_optimized_date_time_shift_duration_unknown_unit_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.DateTime'}, {atom, _, shift}}, [\n {atom, _, non_important},\n {cons, _, {tuple, _, [{atom, _, unknown}, {integer, _, 3}]}, {nil, _}}\n ]\n } = to_erl(\"DateTime.shift(:non_important, unknown: 3)\").\n\noptimized_naive_date_time_shift_duration_test() ->\n {call, _,\n {remote, _, {atom, _, 'Elixir.NaiveDateTime'}, {atom, _, shift}}, [\n {atom, _, non_important},\n {map, _, [\n {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},\n {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},\n {map_field_assoc, _, {atom, _, minute}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, second}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, week}, {integer, _, 0}},\n {map_field_assoc, _, {atom, _, year}, {integer, _, 4}}\n ]}\n ]\n } = to_erl(\"NaiveDateTime.shift(:non_important, year: 4)\")." }, { "path": "lib/elixir/test/erlang/function_test.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(function_test).\n-include_lib(\"eunit/include/eunit.hrl\").\n\neval(Content) ->\n Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<\"nofile\">>, []),\n {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),\n {Value, lists:sort(Binding)}.\n\nfunction_arg_do_end_test() ->\n {3, _} = eval(\"if true do\\n1 + 2\\nend\"),\n {nil, _} = eval(\"if true do end\").\n\nfunction_stab_end_test() ->\n {_, [{a, Fun3}]} = eval(\"a = fn -> 1 + 2 end\"),\n 3 = Fun3().\n\nfunction_stab_newlines_test() ->\n {_, [{a, Fun3}]} = eval(\"a = fn\\n->\\n1 + 2\\nend\"),\n 3 = Fun3().\n\nfunction_stab_many_test() ->\n {_, [{a, Fun}]} = eval(\"a = fn\\n{:foo, x} -> x\\n{:bar, x} -> x\\nend\"),\n 1 = Fun({foo, 1}),\n 2 = Fun({bar, 2}).\n\nfunction_stab_inline_test() ->\n {_, [{a, Fun}]} = eval(\"a = fn {:foo, x} -> x; {:bar, x} -> x end\"),\n 1 = Fun({foo, 1}),\n 2 = Fun({bar, 2}).\n\nfunction_with_args_test() ->\n {Fun, _} = eval(\"fn(a, b) -> a + b end\"),\n 3 = Fun(1, 2).\n\nfunction_with_kv_args_test() ->\n {Fun, _} = eval(\"fn(a, [other: b, another: c]) -> a + b + c end\"),\n 6 = Fun(1, [{other, 2}, {another, 3}]).\n\nfunction_as_closure_test() ->\n {_, [{a, Res1} | _]} = eval(\"b = 1; a = fn -> b + 2 end\"),\n 3 = Res1().\n\nfunction_apply_test() ->\n {3, _} = eval(\"a = fn -> 3 end; apply a, []\").\n\nfunction_apply_with_args_test() ->\n {3, _} = eval(\"a = fn b -> b + 2 end; apply a, [1]\").\n\nfunction_apply_and_clojure_test() ->\n {3, _} = eval(\"b = 1; a = fn -> b + 2 end; apply a, []\").\n\nfunction_parens_test() ->\n {0, _} = eval(\"(fn() -> 0 end).()\"),\n {1, _} = eval(\"(fn(1) -> 1 end).(1)\"),\n {3, _} = eval(\"(fn(1, 2) -> 3 end).(1, 2)\"),\n\n {0, _} = eval(\"(fn() -> 0 end).()\"),\n {1, _} = eval(\"(fn(1) -> 1 end).(1)\"),\n {3, _} = eval(\"(fn(1, 2) -> 3 end).(1, 2)\").\n\n%% Function calls\n\nfunction_call_test() ->\n {3, _} = eval(\"x = fn a, b -> a + b end\\nx.(1, 2)\").\n\nfunction_call_without_arg_test() ->\n {3, _} = eval(\"x = fn -> 2 + 1 end\\nx.()\").\n\nfunction_call_do_end_test() ->\n {[1, [{do, 2}, {'else', 3}]], _} = eval(\"x = fn a, b -> [a, b] end\\nx.(1) do\\n2\\nelse 3\\nend\").\n\nfunction_call_with_assignment_test() ->\n {3, [{a, _}, {c, 3}]} = eval(\"a = fn x -> x + 2 end; c = a.(1)\").\n\nfunction_calls_with_multiple_expressions_test() ->\n {26, _} = eval(\"a = fn a, b -> a + b end; a.((3 + 4 - 1), (2 * 10))\").\n\nfunction_calls_with_multiple_args_with_line_breaks_test() ->\n {5, _} = eval(\"a = fn a, b -> a + b end; a.(\\n3,\\n2\\n)\").\n\nfunction_calls_with_parenthesis_test() ->\n {3, [{a, _}, {b, 1}]} = eval(\"a = (fn x -> x + 2 end).(b = 1)\").\n\nfunction_call_with_a_single_space_test() ->\n {3, _} = eval(\"a = fn a, b -> a + b end; a. (1, 2)\"),\n {3, _} = eval(\"a = fn a, b -> a + b end; a .(1, 2)\").\n\nfunction_call_with_spaces_test() ->\n {3, _} = eval(\"a = fn a, b -> a + b end; a . (1, 2)\").\n\nfunction_call_without_assigning_with_spaces_test() ->\n {3, _} = eval(\"(fn a, b -> a + b end) . (1, 2)\").\n\nfunction_call_with_assignment_and_spaces_test() ->\n {3, [{a, _}, {c, 3}]} = eval(\"a = fn x -> x + 2 end; c = a . (1)\").\n\nfunction_call_with_multiple_spaces_test() ->\n {3, _} = eval(\"a = fn a, b -> a + b end; a . (1, 2)\").\n\nfunction_call_with_multiline_test() ->\n {3, _} = eval(\"a = fn a, b -> a + b end; a . \\n (1, 2)\").\n\nfunction_call_with_tabs_test() ->\n {3, _} = eval(\"a = fn a, b -> a + b end; a .\\n\\t(1, 2)\").\n\nfunction_call_with_args_and_nested_when_test() ->\n {Fun, _} = eval(\"fn a, b when a == 1 when b == 2 -> a + b end\"),\n 3 = Fun(1, 2),\n 2 = Fun(0, 2),\n 1 = Fun(1, 0),\n ?assertError(function_clause, Fun(0, 0)).\n\nfunction_call_with_parens_args_and_nested_when_test() ->\n {Fun, _} = eval(\"fn\\n(a, b) when a == 1 when b == 2 -> a + b\\nend\"),\n 3 = Fun(1, 2),\n 2 = Fun(0, 2),\n 1 = Fun(1, 0),\n ?assertError(function_clause, Fun(0, 0)).\n\n%% Partial application\n\nrequire_partial_application_test() ->\n {Fun, _} = eval(\"&List.flatten(&1)\"),\n Fun = fun 'Elixir.List':flatten/1.\n\nimport_partial_application_test() ->\n {Fun, _} = eval(\"&is_atom(&1)\"),\n Fun = fun erlang:is_atom/1.\n" }, { "path": "lib/elixir/test/erlang/string_test.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(string_test).\n-include(\"../../src/elixir.hrl\").\n-include_lib(\"eunit/include/eunit.hrl\").\n\neval(Content) ->\n Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<\"nofile\">>, []),\n {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),\n {Value, Binding}.\n\nextract_interpolations(String) ->\n case elixir_interpolation:extract(1, 1, #elixir_tokenizer{}, true, String ++ [$\"], $\") of\n {error, Error} ->\n Error;\n {_, _, Parts, _, _, _} ->\n Parts\n end.\n\n% Interpolations\n\nextract_interpolations_without_interpolation_test() ->\n [\"foo\"] = extract_interpolations(\"foo\").\n\nextract_interpolations_with_escaped_interpolation_test() ->\n [\"f\\\\#{o}o\"] = extract_interpolations(\"f\\\\#{o}o\"),\n {1, 10, [\"f\\\\#{o}o\"], [], _, _} =\n elixir_interpolation:extract(1, 2, #elixir_tokenizer{}, true, \"f\\\\#{o}o\\\"\", $\").\n\nextract_interpolations_with_interpolation_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 6, nil}, [{atom, {1, 4, _}, o}]},\n \"o\"] = extract_interpolations(\"f#{:o}o\").\n\nextract_interpolations_with_two_interpolations_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 6, nil}, [{atom, {1, 4, _}, o}]},\n {{1, 7, nil}, {1, 11, nil}, [{atom, {1, 9, _}, o}]},\n \"o\"] = extract_interpolations(\"f#{:o}#{:o}o\").\n\nextract_interpolations_with_only_two_interpolations_test() ->\n [{{1, 1, nil}, {1, 5, nil}, [{atom, {1, 3, _}, o}]},\n {{1, 6, nil}, {1, 10, nil}, [{atom, {1, 8, _}, o}]}] = extract_interpolations(\"#{:o}#{:o}\").\n\nextract_interpolations_with_tuple_inside_interpolation_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 7, nil}, [{'{', {1, 4, nil}}, {int, {1, 5, 1}, \"1\"}, {'}', {1, 6, nil}}]},\n \"o\"] = extract_interpolations(\"f#{{1}}o\").\n\nextract_interpolations_with_many_expressions_inside_interpolation_test() ->\n [\"f\",\n {{1, 2, nil}, {2, 2, nil}, [{int, {1, 4, 1}, \"1\"}, {eol, {1, 5, 1}}, {int, {2, 1, 2}, \"2\"}]},\n \"o\"] = extract_interpolations(\"f#{1\\n2}o\").\n\nextract_interpolations_with_right_curly_inside_string_inside_interpolation_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 9, nil}, [{bin_string, {1, 4, nil}, [<<\"f}o\">>]}]},\n \"o\"] = extract_interpolations(\"f#{\\\"f}o\\\"}o\").\n\nextract_interpolations_with_left_curly_inside_string_inside_interpolation_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 9, nil}, [{bin_string, {1, 4, nil}, [<<\"f{o\">>]}]},\n \"o\"] = extract_interpolations(\"f#{\\\"f{o\\\"}o\").\n\nextract_interpolations_with_escaped_quote_inside_string_inside_interpolation_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 10, nil}, [{bin_string, {1, 4, nil}, [<<\"f\\\"o\">>]}]},\n \"o\"] = extract_interpolations(\"f#{\\\"f\\\\\\\"o\\\"}o\").\n\nextract_interpolations_with_less_than_operation_inside_interpolation_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 7, nil}, [{int, {1, 4, 1}, \"1\"}, {rel_op, {1, 5, nil}, '<'}, {int, {1, 6, 2}, \"2\"}]},\n \"o\"] = extract_interpolations(\"f#{1<2}o\").\n\nextract_interpolations_with_an_escaped_character_test() ->\n [\"f\",\n {{1, 2, nil}, {1, 16, nil}, [{char, {1, 4, \"?\\\\a\"}, 7}, {rel_op, {1, 8, nil}, '>'}, {char, {1, 10, \"?\\\\a\"}, 7}]}\n ] = extract_interpolations(\"f#{?\\\\a > ?\\\\a }\").\n\nextract_interpolations_with_invalid_expression_inside_interpolation_test() ->\n {[{line, 1}, {column, 4}], \"unexpected token: \", _} = extract_interpolations(\"f#{:1}o\").\n\n%% Bin strings\n\nempty_test() ->\n {<<\"\">>, _} = eval(\"\\\"\\\"\").\n\nstring_with_double_quotes_test() ->\n {<<\"f\\\"o\\\"o\">>, _} = eval(\"\\\"f\\\\\\\"o\\\\\\\"o\\\"\").\n\nstring_with_newline_test() ->\n {<<\"f\\no\">>, _} = eval(\"\\\"f\\no\\\"\").\n\nstring_with_slash_test() ->\n {<<\"f\\\\o\">>, _} = eval(\"\\\"f\\\\\\\\o\\\"\").\n\nstring_with_bell_character_test() ->\n {<<\"f\\ao\">>, _} = eval(\"\\\"f\\ao\\\"\").\n\nstring_with_interpolation_test() ->\n {<<\"foo\">>, _} = eval(\"\\\"f#{\\\"o\\\"}o\\\"\").\n\nstring_with_another_string_inside_string_inside_interpolation_test() ->\n {<<\"fbaro\">>, _} = eval(\"\\\"f#{\\\"b#{\\\"a\\\"}r\\\"}o\\\"\").\n\nstring_with_another_string_with_curly_inside_interpolation_test() ->\n {<<\"fb}ro\">>, _} = eval(\"\\\"f#{\\\"b}r\\\"}o\\\"\").\n\nstring_with_atom_with_separator_inside_interpolation_test() ->\n {<<\"f}o\">>, _} = eval(\"\\\"f#{\\\"}\\\"}o\\\"\").\n\nstring_with_lower_case_hex_interpolation_test() ->\n {<<\"jklmno\">>, _} = eval(\"\\\"\\\\x6a\\\\x6b\\\\x6c\\\\x6d\\\\x6e\\\\x6f\\\"\").\n\nstring_with_upper_case_hex_interpolation_test() ->\n {<<\"jklmno\">>, _} = eval(\"\\\"\\\\x6A\\\\x6B\\\\x6C\\\\x6D\\\\x6E\\\\x6F\\\"\").\n\nstring_without_interpolation_and_escaped_test() ->\n {<<\"f#o\">>, _} = eval(\"\\\"f\\\\#o\\\"\").\n\nstring_with_escaped_interpolation_test() ->\n {<<\"f#{'o}o\">>, _} = eval(\"\\\"f\\\\#{'o}o\\\"\").\n\nstring_with_the_end_of_line_slash_test() ->\n {<<\"fo\">>, _} = eval(\"\\\"f\\\\\\no\\\"\"),\n {<<\"fo\">>, _} = eval(\"\\\"f\\\\\\r\\no\\\"\").\n\ninvalid_string_interpolation_test() ->\n ?assertError(#{'__struct__' := 'Elixir.TokenMissingError'}, eval(\"\\\"f#{some\\\"\")),\n ?assertError(#{'__struct__' := 'Elixir.TokenMissingError'}, eval(\"\\\"f#{1+\")).\n\nunterminated_string_interpolation_test() ->\n ?assertError(#{'__struct__' := 'Elixir.TokenMissingError'}, eval(\"\\\"foo\")).\n\nchar_test() ->\n {99, []} = eval(\"?1 + ?2\"),\n {10, []} = eval(\"?\\\\n\"),\n {40, []} = eval(\"?(\").\n" }, { "path": "lib/elixir/test/erlang/test_helper.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(test_helper).\n-export([test/0, run_and_remove/2, throw_elixir/1, throw_erlang/1]).\n-define(TESTS, [\n atom_test,\n control_test,\n function_test,\n string_test,\n tokenizer_test\n]).\n\ntest() ->\n application:ensure_all_started(elixir),\n case eunit:test(?TESTS) of\n error -> erlang:halt(1);\n _Res -> erlang:halt(0)\n end.\n\n% Execute a piece of code and purge given modules right after\nrun_and_remove(Fun, Modules) ->\n try\n Fun()\n after\n [code:purge(Module) || Module <- Modules],\n [code:delete(Module) || Module <- Modules]\n end.\n\n% Throws an error with the Erlang Abstract Form from the Elixir string\nthrow_elixir(String) ->\n Forms = elixir:'string_to_quoted!'(String, 1, 1, <<\"nofile\">>, []),\n {Expr, _, _, _} = elixir:quoted_to_erl(Forms, elixir:env_for_eval([])),\n erlang:error(io:format(\"~p~n\", [Expr])).\n\n% Throws an error with the Erlang Abstract Form from the Erlang string\nthrow_erlang(String) ->\n {ok, Tokens, _} = erl_scan:string(String),\n {ok, [Form]} = erl_parse:parse_exprs(Tokens),\n erlang:error(io:format(\"~p~n\", [Form])).\n" }, { "path": "lib/elixir/test/erlang/tokenizer_test.erl", "content": "%% SPDX-License-Identifier: Apache-2.0\n%% SPDX-FileCopyrightText: 2021 The Elixir Team\n%% SPDX-FileCopyrightText: 2012 Plataformatec\n\n-module(tokenizer_test).\n-include_lib(\"eunit/include/eunit.hrl\").\n\ntokenize(String) ->\n tokenize(String, []).\n\ntokenize(String, Opts) ->\n {ok, _Line, _Column, _Warnings, Result, []} = elixir_tokenizer:tokenize(String, 1, Opts),\n lists:reverse(Result).\n\ntokenize_error(String) ->\n {error, Error, _, _, _} = elixir_tokenizer:tokenize(String, 1, []),\n Error.\n\ntokenize_warnings(String) ->\n {ok, _Line, _Column, Warnings, Result, []} = elixir_tokenizer:tokenize(String, 1, []),\n {lists:reverse(Result), Warnings}.\n\ntype_test() ->\n [{int, {1, 1, 1}, \"1\"},\n {type_op, {1, 3, nil}, '::'},\n {int, {1, 6, 3}, \"3\"}] = tokenize(\"1 :: 3\"),\n [{'true', {1, 1, nil}},\n {type_op, {1, 5, nil}, '::'},\n {int, {1, 7, 3}, \"3\"}] = tokenize(\"true::3\"),\n [{identifier, {1, 1, _}, name},\n {'.', {1, 5, nil}},\n {paren_identifier, {1, 6, _}, '::'},\n {'(', {1, 8, nil}},\n {int, {1, 9, 3}, \"3\"},\n {')', {1, 10, nil}}] = tokenize(\"name.::(3)\").\n\narithmetic_test() ->\n [{int, {1, 1, 1}, \"1\"},\n {dual_op, {1, 3, nil}, '+'},\n {int, {1, 5, 2}, \"2\"},\n {dual_op, {1, 7, nil}, '+'},\n {int, {1, 9, 3}, \"3\"}] = tokenize(\"1 + 2 + 3\").\n\nop_kw_test() ->\n [{atom, {1, 1, _}, foo},\n {dual_op, {1, 5, nil}, '+'},\n {atom, {1, 6, _}, bar}] = tokenize(\":foo+:bar\").\n\nscientific_test() ->\n [{flt, {1, 1, 0.1}, \"1.0e-1\"}] = tokenize(\"1.0e-1\"),\n [{flt, {1, 1, 0.1}, \"1.0E-1\"}] = tokenize(\"1.0E-1\"),\n [{flt, {1, 1, 1.2345678e-7}, \"1_234.567_8e-10\"}] = tokenize(\"1_234.567_8e-10\"),\n {[{line, 1}, {column, 1}], \"invalid float number \", \"1.0e309\"} = tokenize_error(\"1.0e309\").\n\nhex_bin_octal_test() ->\n [{int, {1, 1, 255}, \"0xFF\"}] = tokenize(\"0xFF\"),\n [{int, {1, 1, 255}, \"0xF_F\"}] = tokenize(\"0xF_F\"),\n [{int, {1, 1, 63}, \"0o77\"}] = tokenize(\"0o77\"),\n [{int, {1, 1, 63}, \"0o7_7\"}] = tokenize(\"0o7_7\"),\n [{int, {1, 1, 3}, \"0b11\"}] = tokenize(\"0b11\"),\n [{int, {1, 1, 3}, \"0b1_1\"}] = tokenize(\"0b1_1\").\n\nunquoted_atom_test() ->\n [{atom, {1, 1, _}, '+'}] = tokenize(\":+\"),\n [{atom, {1, 1, _}, '-'}] = tokenize(\":-\"),\n [{atom, {1, 1, _}, '*'}] = tokenize(\":*\"),\n [{atom, {1, 1, _}, '/'}] = tokenize(\":/\"),\n [{atom, {1, 1, _}, '='}] = tokenize(\":=\"),\n [{atom, {1, 1, _}, '&&'}] = tokenize(\":&&\").\n\nquoted_atom_test() ->\n [{atom_quoted, {1, 1, $\"}, 'foo bar'}] = tokenize(\":\\\"foo bar\\\"\").\n\noversized_atom_test() ->\n OversizedAtom = string:copies(\"a\", 256),\n {[{line, 1}, {column, 1}], \"atom length must be less than system limit: \", OversizedAtom} =\n tokenize_error([$: | OversizedAtom]).\n\nop_atom_test() ->\n [{atom, {1, 1, _}, f0_1}] = tokenize(\":f0_1\").\n\nkw_test() ->\n [{kw_identifier, {1, 1, _}, do}] = tokenize(\"do: \"),\n [{kw_identifier, {1, 1, _}, a@}] = tokenize(\"a@: \"),\n [{kw_identifier, {1, 1, _}, 'A@'}] = tokenize(\"A@: \"),\n [{kw_identifier, {1, 1, _}, a@b}] = tokenize(\"a@b: \"),\n [{kw_identifier, {1, 1, _}, 'A@!'}] = tokenize(\"A@!: \"),\n [{kw_identifier, {1, 1, _}, 'a@!'}] = tokenize(\"a@!: \"),\n [{kw_identifier, {1, 1, _}, foo}, {bin_string, {1, 6, nil}, [<<\"bar\">>]}] = tokenize(\"foo: \\\"bar\\\"\"),\n [{kw_identifier, {1, 1, _}, '+'}, {bin_string, {1, 6, nil}, [<<\"bar\">>]}] = tokenize(\"\\\"+\\\": \\\"bar\\\"\").\n\nint_test() ->\n [{int, {1, 1, 123}, \"123\"}] = tokenize(\"123\"),\n [{int, {1, 1, 123}, \"123\"}, {';', {1, 4, 0}}] = tokenize(\"123;\"),\n [{eol, {1, 1, 2}}, {int, {3, 1, 123}, \"123\"}] = tokenize(\"\\n\\n123\"),\n [{int, {1, 3, 123}, \"123\"}, {int, {1, 8, 234}, \"234\"}] = tokenize(\" 123 234 \"),\n [{int, {1, 1, 7}, \"007\"}] = tokenize(\"007\"),\n [{int, {1, 1, 100000}, \"0100000\"}] = tokenize(\"0100000\").\n\nfloat_test() ->\n [{flt, {1, 1, 12.3}, \"12.3\"}] = tokenize(\"12.3\"),\n [{flt, {1, 1, 12.3}, \"12.3\"}, {';', {1, 5, 0}}] = tokenize(\"12.3;\"),\n [{eol, {1, 1, 2}}, {flt, {3, 1, 12.3}, \"12.3\"}] = tokenize(\"\\n\\n12.3\"),\n [{flt, {1, 3, 12.3}, \"12.3\"}, {flt, {1, 9, 23.4}, \"23.4\"}] = tokenize(\" 12.3 23.4 \"),\n [{flt, {1, 1, 12.3}, \"00_12.3_00\"}] = tokenize(\"00_12.3_00\"),\n OversizedFloat = string:copies(\"9\", 310) ++ \".0\",\n {[{line, 1}, {column, 1}], \"invalid float number \", OversizedFloat} = tokenize_error(OversizedFloat).\n\nidentifier_test() ->\n [{identifier, {1, 1, _}, abc}] = tokenize(\"abc \"),\n [{identifier, {1, 1, _}, 'abc?'}] = tokenize(\"abc?\"),\n [{identifier, {1, 1, _}, 'abc!'}] = tokenize(\"abc!\"),\n [{identifier, {1, 1, _}, 'a0c!'}] = tokenize(\"a0c!\"),\n [{paren_identifier, {1, 1, _}, 'a0c'}, {'(', {1, 4, nil}}, {')', {1, 5, nil}}] = tokenize(\"a0c()\"),\n [{paren_identifier, {1, 1, _}, 'a0c!'}, {'(', {1, 5, nil}}, {')', {1, 6, nil}}] = tokenize(\"a0c!()\").\n\nmodule_macro_test() ->\n [{identifier, {1, 1, _}, '__MODULE__'}] = tokenize(\"__MODULE__\").\n\ndot_test() ->\n [{identifier, {1, 1, _}, foo},\n {'.', {1, 4, nil}},\n {identifier, {1, 5, _}, bar},\n {'.', {1, 8, nil}},\n {identifier, {1, 9, _}, baz}] = tokenize(\"foo.bar.baz\").\n\ndot_keyword_test() ->\n [{identifier, {1, 1, _}, foo},\n {'.', {1, 4, nil}},\n {identifier, {1, 5, _}, do}] = tokenize(\"foo.do\").\n\nnewline_test() ->\n [{identifier, {1, 1, _}, foo},\n {'.', {2, 1, nil}},\n {identifier, {2, 2, _}, bar}] = tokenize(\"foo\\n.bar\"),\n [{int, {1, 1, 1}, \"1\"},\n {concat_op, {2, 1, 1}, '++'},\n {int, {2, 3, 2}, \"2\"}] = tokenize(\"1\\n++2\").\n\ndot_newline_operator_test() ->\n [{identifier, {1, 1, _}, foo},\n {'.', {1, 4, nil}},\n {identifier, {2, 1, _}, '+'},\n {int, {2, 2, 1}, \"1\"}] = tokenize(\"foo.\\n+1\"),\n [{identifier, {1, 1, _}, foo},\n {'.', {1, 4, nil}},\n {identifier, {2, 1, _}, '+'},\n {int, {2, 2, 1}, \"1\"}] = tokenize(\"foo.#bar\\n+1\").\n\ndot_call_operator_test() ->\n [{identifier, {1, 1, _}, f},\n {dot_call_op, {1, 2, nil}, '.'},\n {'(', {1, 3, nil}},\n {')', {1, 4, nil}}] = tokenize(\"f.()\").\n\naliases_test() ->\n [{'alias', {1, 1, _}, 'Foo'}] = tokenize(\"Foo\"),\n [{'alias', {1, 1, _}, 'Foo'},\n {'.', {1, 4, nil}},\n {'alias', {1, 5, _}, 'Bar'},\n {'.', {1, 8, nil}},\n {'alias', {1, 9, _}, 'Baz'}] = tokenize(\"Foo.Bar.Baz\").\n\nstring_test() ->\n [{bin_string, {1, 1, nil}, [<<\"foo\">>]}] = tokenize(\"\\\"foo\\\"\"),\n [{bin_string, {1, 1, nil}, [<<\"f\\\"\">>]}] = tokenize(\"\\\"f\\\\\\\"\\\"\").\n\nheredoc_test() ->\n [{bin_heredoc, {1, 1, nil}, 0, [<<\"heredoc\\n\">>]}] = tokenize(\"\\\"\\\"\\\"\\nheredoc\\n\\\"\\\"\\\"\"),\n [{bin_heredoc, {1, 1, nil}, 1, [<<\"heredoc\\n\">>]}, {';', {3, 5, 0}}] = tokenize(\"\\\"\\\"\\\"\\n heredoc\\n \\\"\\\"\\\";\").\n\nempty_string_test() ->\n [{bin_string, {1, 1, nil}, [<<>>]}] = tokenize(\"\\\"\\\"\").\n\nconcat_test() ->\n [{identifier, {1, 1, _}, x},\n {concat_op, {1, 3, nil}, '++'},\n {identifier, {1, 6, _}, y}] = tokenize(\"x ++ y\"),\n [{identifier, {1, 1, _}, x},\n {concat_op, {1, 3, nil}, '+++'},\n {identifier, {1, 7, _}, y}] = tokenize(\"x +++ y\").\n\nspace_test() ->\n [{op_identifier, {1, 1, _}, foo},\n {dual_op, {1, 5, nil}, '-'},\n {int, {1, 6, 2}, \"2\"}] = tokenize(\"foo -2\"),\n [{op_identifier, {1, 1, _}, foo},\n {dual_op, {1, 6, nil}, '-'},\n {int, {1, 7, 2}, \"2\"}] = tokenize(\"foo -2\").\n\nchars_test() ->\n [{char, {1, 1, \"?a\"}, 97}] = tokenize(\"?a\"),\n [{char, {1, 1, \"?c\"}, 99}] = tokenize(\"?c\"),\n [{char, {1, 1, \"?\\\\0\"}, 0}] = tokenize(\"?\\\\0\"),\n [{char, {1, 1, \"?\\\\a\"}, 7}] = tokenize(\"?\\\\a\"),\n [{char, {1, 1, \"?\\\\n\"}, 10}] = tokenize(\"?\\\\n\"),\n [{char, {1, 1, \"?\\\\\\\\\"}, 92}] = tokenize(\"?\\\\\\\\\").\n\ninterpolation_test() ->\n [{bin_string, {1, 1, nil}, [<<\"f\">>, {{1, 3, nil},{1, 7, nil}, [{identifier, {1, 5, _}, oo}]}]},\n {concat_op, {1, 10, nil}, '<>'},\n {bin_string, {1, 13, nil}, [<<>>]}] = tokenize(\"\\\"f#{oo}\\\" <> \\\"\\\"\").\n\nescaped_interpolation_test() ->\n [{bin_string, {1, 1, nil}, [<<\"f#{oo}\">>]},\n {concat_op, {1, 11, nil}, '<>'},\n {bin_string, {1, 14, nil}, [<<>>]}] = tokenize(\"\\\"f\\\\#{oo}\\\" <> \\\"\\\"\").\n\ncapture_test() ->\n % Parens precedence\n [{capture_op, {1, 1, nil}, '&'},\n {unary_op, {1, 2, nil}, 'not'},\n {int, {1, 6, 1}, \"1\"},\n {',', {1, 7, 0}},\n {int, {1, 9, 2}, \"2\"}] = tokenize(\"¬ 1, 2\"),\n\n % Operators\n [{capture_op, {1, 1, nil}, '&'},\n {identifier, {1, 2, _}, '||'},\n {mult_op, {1, 4, nil}, '/'},\n {int, {1, 5, 2}, \"2\"}] = tokenize(\"&||/2\"),\n [{capture_op, {1, 1, nil}, '&'},\n {identifier, {1, 2, _}, 'or'},\n {mult_op, {1, 4, nil}, '/'},\n {int, {1, 5, 2}, \"2\"}] = tokenize(\"&or/2\"),\n [{capture_op,{1,1,nil},'&'},\n {identifier,{1,3,_},'+'},\n {mult_op,{1,4,nil},'/'},\n {int,{1,5,1},\"1\"}] = tokenize(\"& +/1\"),\n [{capture_op,{1,1,nil},'&'},\n {identifier,{1,3,_},'&'},\n {mult_op,{1,4,nil},'/'},\n {int,{1,5,1},\"1\"}] = tokenize(\"& &/1\"),\n [{capture_op,{1,1,nil},'&'},\n {identifier,{1,3,_},'..//'},\n {mult_op,{1,7,nil},'/'},\n {int,{1,8,3},\"3\"}] = tokenize(\"& ..///3\"),\n [{capture_op, {1,1,nil}, '&'},\n {identifier, {1,3,_}, '/'},\n {mult_op, {1,5,nil}, '/'},\n {int, {1,6,2}, \"2\"}] = tokenize(\"& / /2\"),\n [{capture_op, {1,1,nil}, '&'},\n {identifier, {1,2,_}, '/'},\n {mult_op, {1,4,nil}, '/'},\n {int, {1,5,2}, \"2\"}] = tokenize(\"&/ /2\"),\n\n % Only operators\n [{identifier,{1,1,_},'&'},\n {mult_op,{1,2,nil},'/'},\n {int,{1,3,1},\"1\"}] = tokenize(\"&/1\"),\n [{identifier,{1,1,_},'+'},\n {mult_op,{1,2,nil},'/'},\n {int,{1,3,1},\"1\"}] = tokenize(\"+/1\"),\n [{identifier, {1,1,_}, '/'},\n {mult_op, {1,3,nil}, '/'},\n {int, {1,4,2}, \"2\"}] = tokenize(\"/ /2\"),\n [{identifier, {1,1,_}, '..//'},\n {mult_op, {1,5,nil}, '/'},\n {int, {1,6,3}, \"3\"}] = tokenize(\"..///3\").\n\nvc_merge_conflict_test() ->\n {[{line, 1}, {column, 1}], \"found an unexpected version control marker, please resolve the conflicts: \", \"<<<<<<< HEAD\"} =\n tokenize_error(\"<<<<<<< HEAD\\n[1, 2, 3]\").\n\nsigil_terminator_test() ->\n [{sigil, {1, 1, {1, 8}}, sigil_r, [<<\"foo\">>], [], nil, <<\"/\">>}] = tokenize(\"~r/foo/\"),\n [{sigil, {1, 1, {1, 8}}, sigil_r, [<<\"foo\">>], [], nil, <<\"[\">>}] = tokenize(\"~r[foo]\"),\n [{sigil, {1, 1, {1, 8}}, sigil_r, [<<\"foo\">>], [], nil, <<\"\\\"\">>}] = tokenize(\"~r\\\"foo\\\"\"),\n [{sigil, {1, 1, {1, 8}}, sigil_r, [<<\"foo\">>], [], nil, <<\"/\">>},\n {comp_op, {1, 9, nil}, '=='},\n {identifier, {1, 12, _}, bar}] = tokenize(\"~r/foo/ == bar\"),\n [{sigil, {1, 1, {1, 10}}, sigil_r, [<<\"foo\">>], \"iu\", nil, <<\"/\">>},\n {comp_op, {1, 11, nil}, '=='},\n {identifier, {1, 14, _}, bar}] = tokenize(\"~r/foo/iu == bar\"),\n [{sigil, {1, 1, {1, 12}}, sigil_M, [<<\"1 2 3\">>], \"u8\", nil, <<\"[\">>}] = tokenize(\"~M[1 2 3]u8\").\n\nsigil_heredoc_test() ->\n [{sigil, {1, 1, {3, 4}}, sigil_S, [<<\"sigil heredoc\\n\">>], [], 0, <<\"\\\"\\\"\\\"\">>}] = tokenize(\"~S\\\"\\\"\\\"\\nsigil heredoc\\n\\\"\\\"\\\"\"),\n [{sigil, {1, 1, {3, 4}}, sigil_S, [<<\"sigil heredoc\\n\">>], [], 0, <<\"'''\">>}] = tokenize(\"~S'''\\nsigil heredoc\\n'''\"),\n [{sigil, {1, 1, {3, 6}}, sigil_S, [<<\"sigil heredoc\\n\">>], [], 2, <<\"\\\"\\\"\\\"\">>}] = tokenize(\"~S\\\"\\\"\\\"\\n sigil heredoc\\n \\\"\\\"\\\"\"),\n [{sigil, {1, 1, {3, 6}}, sigil_s, [<<\"sigil heredoc\\n\">>], [], 2, <<\"\\\"\\\"\\\"\">>}] = tokenize(\"~s\\\"\\\"\\\"\\n sigil heredoc\\n \\\"\\\"\\\"\").\n\ninvalid_sigil_delimiter_test() ->\n {[{line, 1}, {column, 1}], \"invalid sigil delimiter: \", Message} = tokenize_error(\"~s\\\\\"),\n true = lists:prefix(\"\\\"\\\\\\\" (column 3, code point U+005C)\", lists:flatten(Message)).\n\ndeprecated_operators_test() ->\n {\n [{xor_op, {1, 1, nil}, '^^^'}, {int, {1, 4, 1}, \"1\"}],\n [{{1, 1}, \"^^^ is deprecated. It is typically used as xor but it has the wrong precedence, use Bitwise.bxor/2 instead\"}]\n } = tokenize_warnings(\"^^^1\"),\n {\n [{unary_op, {1, 1, nil}, '~~~'}, {int, {1, 4, 1}, \"1\"}],\n [{{1, 1}, \"~~~ is deprecated. Use Bitwise.bnot/1 instead for clarity\"}]\n } = tokenize_warnings(\"~~~1\").\n" }, { "path": "lib/elixir/unicode/IdentifierType.txt", "content": "# IdentifierType.txt\n# Date: 2025-08-04, 21:58:43 GMT\n# © 2025 Unicode®, Inc.\n# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.\n# For terms of use and license, see https://www.unicode.org/terms_of_use.html\n#\n# Unicode Security Mechanisms for UTS #39\n# Version: 17.0.0\n#\n# For documentation and usage, see https://www.unicode.org/reports/tr39\n#\n# Format\n#\n# Field 0: code point\n# Field 1: set of Identifier_Type values\n# See the \"Identifier_Status and Identifier_Type\" table of UTS #39:\n# https://www.unicode.org/reports/tr39/#Identifier_Status_and_Type\n\n#\n# For the purpose of regular expressions, the property Identifier_Type is defined as\n# mapping each code point to a set of enumerated values.\n# The short name of Identifier_Type is ID_Type.\n# The possible values are:\n# Not_Character, Deprecated, Default_Ignorable, Not_NFKC, Not_XID,\n# Exclusion, Obsolete, Technical, Uncommon_Use, Limited_Use, Inclusion, Recommended\n# The short name of each value is the same as its long name.\n\n# All code points not explicitly listed for Identifier_Type\n# have the value Not_Character.\n\n# @missing: 0000..10FFFF; Not_Character\n\n# As usual, sets are unordered, with no duplicate values.\n\n\n#\tIdentifier_Type:\tRecommended\n\n0030..0039 ; Recommended # 1.1 [10] DIGIT ZERO..DIGIT NINE\n0041..005A ; Recommended # 1.1 [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z\n005F ; Recommended # 1.1 LOW LINE\n0061..007A ; Recommended # 1.1 [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z\n00C0..00D6 ; Recommended # 1.1 [23] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER O WITH DIAERESIS\n00D8..00F6 ; Recommended # 1.1 [31] LATIN CAPITAL LETTER O WITH STROKE..LATIN SMALL LETTER O WITH DIAERESIS\n00F8..0113 ; Recommended # 1.1 [28] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER E WITH MACRON\n0116..012B ; Recommended # 1.1 [22] LATIN CAPITAL LETTER E WITH DOT ABOVE..LATIN SMALL LETTER I WITH MACRON\n012E..0131 ; Recommended # 1.1 [4] LATIN CAPITAL LETTER I WITH OGONEK..LATIN SMALL LETTER DOTLESS I\n0134..0137 ; Recommended # 1.1 [4] LATIN CAPITAL LETTER J WITH CIRCUMFLEX..LATIN SMALL LETTER K WITH CEDILLA\n0139..013E ; Recommended # 1.1 [6] LATIN CAPITAL LETTER L WITH ACUTE..LATIN SMALL LETTER L WITH CARON\n0141..0148 ; Recommended # 1.1 [8] LATIN CAPITAL LETTER L WITH STROKE..LATIN SMALL LETTER N WITH CARON\n014A..014D ; Recommended # 1.1 [4] LATIN CAPITAL LETTER ENG..LATIN SMALL LETTER O WITH MACRON\n0150..0155 ; Recommended # 1.1 [6] LATIN CAPITAL LETTER O WITH DOUBLE ACUTE..LATIN SMALL LETTER R WITH ACUTE\n0158..0161 ; Recommended # 1.1 [10] LATIN CAPITAL LETTER R WITH CARON..LATIN SMALL LETTER S WITH CARON\n0164..017E ; Recommended # 1.1 [27] LATIN CAPITAL LETTER T WITH CARON..LATIN SMALL LETTER Z WITH CARON\n0181 ; Recommended # 1.1 LATIN CAPITAL LETTER B WITH HOOK\n0186 ; Recommended # 1.1 LATIN CAPITAL LETTER OPEN O\n0189..018A ; Recommended # 1.1 [2] LATIN CAPITAL LETTER AFRICAN D..LATIN CAPITAL LETTER D WITH HOOK\n018E..0192 ; Recommended # 1.1 [5] LATIN CAPITAL LETTER REVERSED E..LATIN SMALL LETTER F WITH HOOK\n0194 ; Recommended # 1.1 LATIN CAPITAL LETTER GAMMA\n0196..0199 ; Recommended # 1.1 [4] LATIN CAPITAL LETTER IOTA..LATIN SMALL LETTER K WITH HOOK\n019D ; Recommended # 1.1 LATIN CAPITAL LETTER N WITH LEFT HOOK\n01A0..01A1 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER O WITH HORN..LATIN SMALL LETTER O WITH HORN\n01AF..01B0 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER U WITH HORN..LATIN SMALL LETTER U WITH HORN\n01B2..01B4 ; Recommended # 1.1 [3] LATIN CAPITAL LETTER V WITH HOOK..LATIN SMALL LETTER Y WITH HOOK\n01B7 ; Recommended # 1.1 LATIN CAPITAL LETTER EZH\n01CD..01D4 ; Recommended # 1.1 [8] LATIN CAPITAL LETTER A WITH CARON..LATIN SMALL LETTER U WITH CARON\n01DD ; Recommended # 1.1 LATIN SMALL LETTER TURNED E\n01E6..01E9 ; Recommended # 1.1 [4] LATIN CAPITAL LETTER G WITH CARON..LATIN SMALL LETTER K WITH CARON\n01EE..01EF ; Recommended # 1.1 [2] LATIN CAPITAL LETTER EZH WITH CARON..LATIN SMALL LETTER EZH WITH CARON\n01F8..01F9 ; Recommended # 3.0 [2] LATIN CAPITAL LETTER N WITH GRAVE..LATIN SMALL LETTER N WITH GRAVE\n0218..021B ; Recommended # 3.0 [4] LATIN CAPITAL LETTER S WITH COMMA BELOW..LATIN SMALL LETTER T WITH COMMA BELOW\n0244 ; Recommended # 5.0 LATIN CAPITAL LETTER U BAR\n024C..024D ; Recommended # 5.0 [2] LATIN CAPITAL LETTER R WITH STROKE..LATIN SMALL LETTER R WITH STROKE\n0253..0254 ; Recommended # 1.1 [2] LATIN SMALL LETTER B WITH HOOK..LATIN SMALL LETTER OPEN O\n0256..0257 ; Recommended # 1.1 [2] LATIN SMALL LETTER D WITH TAIL..LATIN SMALL LETTER D WITH HOOK\n0259 ; Recommended # 1.1 LATIN SMALL LETTER SCHWA\n025B ; Recommended # 1.1 LATIN SMALL LETTER OPEN E\n0263 ; Recommended # 1.1 LATIN SMALL LETTER GAMMA\n0268..0269 ; Recommended # 1.1 [2] LATIN SMALL LETTER I WITH STROKE..LATIN SMALL LETTER IOTA\n0272 ; Recommended # 1.1 LATIN SMALL LETTER N WITH LEFT HOOK\n0289 ; Recommended # 1.1 LATIN SMALL LETTER U BAR\n028B ; Recommended # 1.1 LATIN SMALL LETTER V WITH HOOK\n0292 ; Recommended # 1.1 LATIN SMALL LETTER EZH\n0300..0304 ; Recommended # 1.1 [5] COMBINING GRAVE ACCENT..COMBINING MACRON\n0306..030C ; Recommended # 1.1 [7] COMBINING BREVE..COMBINING CARON\n031B ; Recommended # 1.1 COMBINING HORN\n0323 ; Recommended # 1.1 COMBINING DOT BELOW\n0326..0328 ; Recommended # 1.1 [3] COMBINING COMMA BELOW..COMBINING OGONEK\n0331 ; Recommended # 1.1 COMBINING MACRON BELOW\n0386 ; Recommended # 1.1 GREEK CAPITAL LETTER ALPHA WITH TONOS\n0388..038A ; Recommended # 1.1 [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS\n038C ; Recommended # 1.1 GREEK CAPITAL LETTER OMICRON WITH TONOS\n038E..03A1 ; Recommended # 1.1 [20] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK CAPITAL LETTER RHO\n03A3..03CE ; Recommended # 1.1 [44] GREEK CAPITAL LETTER SIGMA..GREEK SMALL LETTER OMEGA WITH TONOS\n0401..040C ; Recommended # 1.1 [12] CYRILLIC CAPITAL LETTER IO..CYRILLIC CAPITAL LETTER KJE\n040E..044F ; Recommended # 1.1 [66] CYRILLIC CAPITAL LETTER SHORT U..CYRILLIC SMALL LETTER YA\n0451..045C ; Recommended # 1.1 [12] CYRILLIC SMALL LETTER IO..CYRILLIC SMALL LETTER KJE\n045E..045F ; Recommended # 1.1 [2] CYRILLIC SMALL LETTER SHORT U..CYRILLIC SMALL LETTER DZHE\n0490..049B ; Recommended # 1.1 [12] CYRILLIC CAPITAL LETTER GHE WITH UPTURN..CYRILLIC SMALL LETTER KA WITH DESCENDER\n049E..04A5 ; Recommended # 1.1 [8] CYRILLIC CAPITAL LETTER KA WITH STROKE..CYRILLIC SMALL LIGATURE EN GHE\n04A8..04B7 ; Recommended # 1.1 [16] CYRILLIC CAPITAL LETTER ABKHASIAN HA..CYRILLIC SMALL LETTER CHE WITH DESCENDER\n04BA..04C0 ; Recommended # 1.1 [7] CYRILLIC CAPITAL LETTER SHHA..CYRILLIC LETTER PALOCHKA\n04CF ; Recommended # 5.0 CYRILLIC SMALL LETTER PALOCHKA\n04D0..04D9 ; Recommended # 1.1 [10] CYRILLIC CAPITAL LETTER A WITH BREVE..CYRILLIC SMALL LETTER SCHWA\n04DC..04E9 ; Recommended # 1.1 [14] CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS..CYRILLIC SMALL LETTER BARRED O\n04EE..04F5 ; Recommended # 1.1 [8] CYRILLIC CAPITAL LETTER U WITH MACRON..CYRILLIC SMALL LETTER CHE WITH DIAERESIS\n04F8..04F9 ; Recommended # 1.1 [2] CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS..CYRILLIC SMALL LETTER YERU WITH DIAERESIS\n0524..0525 ; Recommended # 5.2 [2] CYRILLIC CAPITAL LETTER PE WITH DESCENDER..CYRILLIC SMALL LETTER PE WITH DESCENDER\n0531..0556 ; Recommended # 1.1 [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH\n0561..0586 ; Recommended # 1.1 [38] ARMENIAN SMALL LETTER AYB..ARMENIAN SMALL LETTER FEH\n05D0..05EA ; Recommended # 1.1 [27] HEBREW LETTER ALEF..HEBREW LETTER TAV\n0620 ; Recommended # 6.0 ARABIC LETTER KASHMIRI YEH\n0621..063A ; Recommended # 1.1 [26] ARABIC LETTER HAMZA..ARABIC LETTER GHAIN\n063D ; Recommended # 5.1 ARABIC LETTER FARSI YEH WITH INVERTED V\n0641..0652 ; Recommended # 1.1 [18] ARABIC LETTER FEH..ARABIC SUKUN\n0654..0655 ; Recommended # 3.0 [2] ARABIC HAMZA ABOVE..ARABIC HAMZA BELOW\n0660..0669 ; Recommended # 1.1 [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE\n0670 ; Recommended # 1.1 ARABIC LETTER SUPERSCRIPT ALEF\n0672 ; Recommended # 1.1 ARABIC LETTER ALEF WITH WAVY HAMZA ABOVE\n0674 ; Recommended # 1.1 ARABIC LETTER HIGH HAMZA\n0679..068F ; Recommended # 1.1 [23] ARABIC LETTER TTEH..ARABIC LETTER DAL WITH THREE DOTS ABOVE DOWNWARDS\n0691..069A ; Recommended # 1.1 [10] ARABIC LETTER RREH..ARABIC LETTER SEEN WITH DOT BELOW AND DOT ABOVE\n069F..06A0 ; Recommended # 1.1 [2] ARABIC LETTER TAH WITH THREE DOTS ABOVE..ARABIC LETTER AIN WITH THREE DOTS ABOVE\n06A2 ; Recommended # 1.1 ARABIC LETTER FEH WITH DOT MOVED BELOW\n06A4..06AB ; Recommended # 1.1 [8] ARABIC LETTER VEH..ARABIC LETTER KAF WITH RING\n06AD..06B1 ; Recommended # 1.1 [5] ARABIC LETTER NG..ARABIC LETTER NGOEH\n06B3 ; Recommended # 1.1 ARABIC LETTER GUEH\n06B5..06B7 ; Recommended # 1.1 [3] ARABIC LETTER LAM WITH SMALL V..ARABIC LETTER LAM WITH THREE DOTS ABOVE\n06BA..06BE ; Recommended # 1.1 [5] ARABIC LETTER NOON GHUNNA..ARABIC LETTER HEH DOACHASHMEE\n06C0..06CE ; Recommended # 1.1 [15] ARABIC LETTER HEH WITH YEH ABOVE..ARABIC LETTER YEH WITH SMALL V\n06CF ; Recommended # 3.0 ARABIC LETTER WAW WITH DOT ABOVE\n06D0..06D3 ; Recommended # 1.1 [4] ARABIC LETTER E..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE\n06D5 ; Recommended # 1.1 ARABIC LETTER AE\n06EE..06EF ; Recommended # 4.0 [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V\n06F0..06F9 ; Recommended # 1.1 [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE\n06FF ; Recommended # 4.0 ARABIC LETTER HEH WITH INVERTED V\n0751..0752 ; Recommended # 4.1 [2] ARABIC LETTER BEH WITH DOT BELOW AND THREE DOTS ABOVE..ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW\n0756 ; Recommended # 4.1 ARABIC LETTER BEH WITH SMALL V\n0760 ; Recommended # 4.1 ARABIC LETTER FEH WITH TWO DOTS BELOW\n0762..0763 ; Recommended # 4.1 [2] ARABIC LETTER KEHEH WITH DOT ABOVE..ARABIC LETTER KEHEH WITH THREE DOTS ABOVE\n0766..0768 ; Recommended # 4.1 [3] ARABIC LETTER MEEM WITH DOT BELOW..ARABIC LETTER NOON WITH SMALL TAH\n076A ; Recommended # 4.1 ARABIC LETTER LAM WITH BAR\n076E..0771 ; Recommended # 5.1 [4] ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH BELOW..ARABIC LETTER REH WITH SMALL ARABIC LETTER TAH AND TWO DOTS\n0780..07B0 ; Recommended # 3.0 [49] THAANA LETTER HAA..THAANA SUKUN\n07B1 ; Recommended # 3.2 THAANA LETTER NAA\n088F ; Recommended # 17.0 ARABIC LETTER NOON WITH RING ABOVE\n08A0 ; Recommended # 6.1 ARABIC LETTER BEH WITH SMALL V BELOW\n08A2..08A9 ; Recommended # 6.1 [8] ARABIC LETTER JEEM WITH TWO DOTS ABOVE..ARABIC LETTER YEH WITH TWO DOTS BELOW AND DOT ABOVE\n08BB..08BD ; Recommended # 9.0 [3] ARABIC LETTER AFRICAN FEH..ARABIC LETTER AFRICAN NOON\n08BE..08C2 ; Recommended # 13.0 [5] ARABIC LETTER PEH WITH SMALL V..ARABIC LETTER KEHEH WITH SMALL V\n08C7 ; Recommended # 13.0 ARABIC LETTER LAM WITH SMALL ARABIC LETTER TAH ABOVE\n0901..0903 ; Recommended # 1.1 [3] DEVANAGARI SIGN CANDRABINDU..DEVANAGARI SIGN VISARGA\n0905..090B ; Recommended # 1.1 [7] DEVANAGARI LETTER A..DEVANAGARI LETTER VOCALIC R\n090D..0928 ; Recommended # 1.1 [28] DEVANAGARI LETTER CANDRA E..DEVANAGARI LETTER NA\n092A..0933 ; Recommended # 1.1 [10] DEVANAGARI LETTER PA..DEVANAGARI LETTER LLA\n0935..0939 ; Recommended # 1.1 [5] DEVANAGARI LETTER VA..DEVANAGARI LETTER HA\n093A..093B ; Recommended # 6.0 [2] DEVANAGARI VOWEL SIGN OE..DEVANAGARI VOWEL SIGN OOE\n093C ; Recommended # 1.1 DEVANAGARI SIGN NUKTA\n093E..0943 ; Recommended # 1.1 [6] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN VOCALIC R\n0945..094D ; Recommended # 1.1 [9] DEVANAGARI VOWEL SIGN CANDRA E..DEVANAGARI SIGN VIRAMA\n094F ; Recommended # 6.0 DEVANAGARI VOWEL SIGN AW\n0956..0957 ; Recommended # 6.0 [2] DEVANAGARI VOWEL SIGN UE..DEVANAGARI VOWEL SIGN UUE\n0966..096F ; Recommended # 1.1 [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE\n0972 ; Recommended # 5.1 DEVANAGARI LETTER CANDRA A\n0973..0977 ; Recommended # 6.0 [5] DEVANAGARI LETTER OE..DEVANAGARI LETTER UUE\n097B..097C ; Recommended # 5.0 [2] DEVANAGARI LETTER GGA..DEVANAGARI LETTER JJA\n097E..097F ; Recommended # 5.0 [2] DEVANAGARI LETTER DDDA..DEVANAGARI LETTER BBA\n0981..0983 ; Recommended # 1.1 [3] BENGALI SIGN CANDRABINDU..BENGALI SIGN VISARGA\n0985..098B ; Recommended # 1.1 [7] BENGALI LETTER A..BENGALI LETTER VOCALIC R\n098F..0990 ; Recommended # 1.1 [2] BENGALI LETTER E..BENGALI LETTER AI\n0993..09A8 ; Recommended # 1.1 [22] BENGALI LETTER O..BENGALI LETTER NA\n09AA..09B0 ; Recommended # 1.1 [7] BENGALI LETTER PA..BENGALI LETTER RA\n09B2 ; Recommended # 1.1 BENGALI LETTER LA\n09B6..09B9 ; Recommended # 1.1 [4] BENGALI LETTER SHA..BENGALI LETTER HA\n09BC ; Recommended # 1.1 BENGALI SIGN NUKTA\n09BE..09C4 ; Recommended # 1.1 [7] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN VOCALIC RR\n09C7..09C8 ; Recommended # 1.1 [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI\n09CB..09CD ; Recommended # 1.1 [3] BENGALI VOWEL SIGN O..BENGALI SIGN VIRAMA\n09CE ; Recommended # 4.1 BENGALI LETTER KHANDA TA\n09E6..09F1 ; Recommended # 1.1 [12] BENGALI DIGIT ZERO..BENGALI LETTER RA WITH LOWER DIAGONAL\n0A02 ; Recommended # 1.1 GURMUKHI SIGN BINDI\n0A05..0A0A ; Recommended # 1.1 [6] GURMUKHI LETTER A..GURMUKHI LETTER UU\n0A0F..0A10 ; Recommended # 1.1 [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI\n0A13..0A28 ; Recommended # 1.1 [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA\n0A2A..0A30 ; Recommended # 1.1 [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA\n0A32 ; Recommended # 1.1 GURMUKHI LETTER LA\n0A35 ; Recommended # 1.1 GURMUKHI LETTER VA\n0A38..0A39 ; Recommended # 1.1 [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA\n0A3C ; Recommended # 1.1 GURMUKHI SIGN NUKTA\n0A3E..0A42 ; Recommended # 1.1 [5] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN UU\n0A47..0A48 ; Recommended # 1.1 [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI\n0A4B..0A4D ; Recommended # 1.1 [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA\n0A5C ; Recommended # 1.1 GURMUKHI LETTER RRA\n0A70..0A71 ; Recommended # 1.1 [2] GURMUKHI TIPPI..GURMUKHI ADDAK\n0A82..0A83 ; Recommended # 1.1 [2] GUJARATI SIGN ANUSVARA..GUJARATI SIGN VISARGA\n0A85..0A8B ; Recommended # 1.1 [7] GUJARATI LETTER A..GUJARATI LETTER VOCALIC R\n0A8C ; Recommended # 4.0 GUJARATI LETTER VOCALIC L\n0A8D ; Recommended # 1.1 GUJARATI VOWEL CANDRA E\n0A8F..0A91 ; Recommended # 1.1 [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O\n0A93..0AA8 ; Recommended # 1.1 [22] GUJARATI LETTER O..GUJARATI LETTER NA\n0AAA..0AB0 ; Recommended # 1.1 [7] GUJARATI LETTER PA..GUJARATI LETTER RA\n0AB2..0AB3 ; Recommended # 1.1 [2] GUJARATI LETTER LA..GUJARATI LETTER LLA\n0AB5..0AB9 ; Recommended # 1.1 [5] GUJARATI LETTER VA..GUJARATI LETTER HA\n0ABC ; Recommended # 1.1 GUJARATI SIGN NUKTA\n0ABE..0AC5 ; Recommended # 1.1 [8] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN CANDRA E\n0AC7..0AC9 ; Recommended # 1.1 [3] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN CANDRA O\n0ACB..0ACD ; Recommended # 1.1 [3] GUJARATI VOWEL SIGN O..GUJARATI SIGN VIRAMA\n0AE6..0AEF ; Recommended # 1.1 [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE\n0B01..0B03 ; Recommended # 1.1 [3] ORIYA SIGN CANDRABINDU..ORIYA SIGN VISARGA\n0B05..0B0B ; Recommended # 1.1 [7] ORIYA LETTER A..ORIYA LETTER VOCALIC R\n0B0F..0B10 ; Recommended # 1.1 [2] ORIYA LETTER E..ORIYA LETTER AI\n0B13..0B28 ; Recommended # 1.1 [22] ORIYA LETTER O..ORIYA LETTER NA\n0B2A..0B30 ; Recommended # 1.1 [7] ORIYA LETTER PA..ORIYA LETTER RA\n0B32..0B33 ; Recommended # 1.1 [2] ORIYA LETTER LA..ORIYA LETTER LLA\n0B36..0B39 ; Recommended # 1.1 [4] ORIYA LETTER SHA..ORIYA LETTER HA\n0B3C ; Recommended # 1.1 ORIYA SIGN NUKTA\n0B3E..0B43 ; Recommended # 1.1 [6] ORIYA VOWEL SIGN AA..ORIYA VOWEL SIGN VOCALIC R\n0B47..0B48 ; Recommended # 1.1 [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI\n0B4B..0B4D ; Recommended # 1.1 [3] ORIYA VOWEL SIGN O..ORIYA SIGN VIRAMA\n0B56 ; Recommended # 1.1 ORIYA AI LENGTH MARK\n0B5F ; Recommended # 1.1 ORIYA LETTER YYA\n0B71 ; Recommended # 4.0 ORIYA LETTER WA\n0B83 ; Recommended # 1.1 TAMIL SIGN VISARGA\n0B85..0B8A ; Recommended # 1.1 [6] TAMIL LETTER A..TAMIL LETTER UU\n0B8E..0B90 ; Recommended # 1.1 [3] TAMIL LETTER E..TAMIL LETTER AI\n0B92..0B95 ; Recommended # 1.1 [4] TAMIL LETTER O..TAMIL LETTER KA\n0B99..0B9A ; Recommended # 1.1 [2] TAMIL LETTER NGA..TAMIL LETTER CA\n0B9C ; Recommended # 1.1 TAMIL LETTER JA\n0B9E..0B9F ; Recommended # 1.1 [2] TAMIL LETTER NYA..TAMIL LETTER TTA\n0BA3..0BA4 ; Recommended # 1.1 [2] TAMIL LETTER NNA..TAMIL LETTER TA\n0BA8..0BAA ; Recommended # 1.1 [3] TAMIL LETTER NA..TAMIL LETTER PA\n0BAE..0BB5 ; Recommended # 1.1 [8] TAMIL LETTER MA..TAMIL LETTER VA\n0BB6 ; Recommended # 4.1 TAMIL LETTER SHA\n0BB7..0BB9 ; Recommended # 1.1 [3] TAMIL LETTER SSA..TAMIL LETTER HA\n0BBE..0BC2 ; Recommended # 1.1 [5] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN UU\n0BC6..0BC8 ; Recommended # 1.1 [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI\n0BCA..0BCD ; Recommended # 1.1 [4] TAMIL VOWEL SIGN O..TAMIL SIGN VIRAMA\n0C02..0C03 ; Recommended # 1.1 [2] TELUGU SIGN ANUSVARA..TELUGU SIGN VISARGA\n0C05..0C0B ; Recommended # 1.1 [7] TELUGU LETTER A..TELUGU LETTER VOCALIC R\n0C0E..0C10 ; Recommended # 1.1 [3] TELUGU LETTER E..TELUGU LETTER AI\n0C12..0C28 ; Recommended # 1.1 [23] TELUGU LETTER O..TELUGU LETTER NA\n0C2A..0C30 ; Recommended # 1.1 [7] TELUGU LETTER PA..TELUGU LETTER RA\n0C32..0C33 ; Recommended # 1.1 [2] TELUGU LETTER LA..TELUGU LETTER LLA\n0C35..0C39 ; Recommended # 1.1 [5] TELUGU LETTER VA..TELUGU LETTER HA\n0C3E..0C44 ; Recommended # 1.1 [7] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN VOCALIC RR\n0C46..0C48 ; Recommended # 1.1 [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI\n0C4A..0C4D ; Recommended # 1.1 [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA\n0C82..0C83 ; Recommended # 1.1 [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA\n0C85..0C8B ; Recommended # 1.1 [7] KANNADA LETTER A..KANNADA LETTER VOCALIC R\n0C8E..0C90 ; Recommended # 1.1 [3] KANNADA LETTER E..KANNADA LETTER AI\n0C92..0CA8 ; Recommended # 1.1 [23] KANNADA LETTER O..KANNADA LETTER NA\n0CAA..0CB0 ; Recommended # 1.1 [7] KANNADA LETTER PA..KANNADA LETTER RA\n0CB2..0CB3 ; Recommended # 1.1 [2] KANNADA LETTER LA..KANNADA LETTER LLA\n0CB5..0CB9 ; Recommended # 1.1 [5] KANNADA LETTER VA..KANNADA LETTER HA\n0CBE..0CC3 ; Recommended # 1.1 [6] KANNADA VOWEL SIGN AA..KANNADA VOWEL SIGN VOCALIC R\n0CC6..0CC8 ; Recommended # 1.1 [3] KANNADA VOWEL SIGN E..KANNADA VOWEL SIGN AI\n0CCA..0CCD ; Recommended # 1.1 [4] KANNADA VOWEL SIGN O..KANNADA SIGN VIRAMA\n0CE6..0CEF ; Recommended # 1.1 [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE\n0D02..0D03 ; Recommended # 1.1 [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA\n0D05..0D0B ; Recommended # 1.1 [7] MALAYALAM LETTER A..MALAYALAM LETTER VOCALIC R\n0D0E..0D10 ; Recommended # 1.1 [3] MALAYALAM LETTER E..MALAYALAM LETTER AI\n0D12..0D28 ; Recommended # 1.1 [23] MALAYALAM LETTER O..MALAYALAM LETTER NA\n0D2A..0D39 ; Recommended # 1.1 [16] MALAYALAM LETTER PA..MALAYALAM LETTER HA\n0D3E..0D43 ; Recommended # 1.1 [6] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN VOCALIC R\n0D46..0D48 ; Recommended # 1.1 [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI\n0D4A..0D4B ; Recommended # 1.1 [2] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN OO\n0D4D ; Recommended # 1.1 MALAYALAM SIGN VIRAMA\n0D57 ; Recommended # 1.1 MALAYALAM AU LENGTH MARK\n0D7A..0D7F ; Recommended # 5.1 [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K\n0D82..0D83 ; Recommended # 3.0 [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA\n0D85..0D8D ; Recommended # 3.0 [9] SINHALA LETTER AYANNA..SINHALA LETTER IRUYANNA\n0D91..0D96 ; Recommended # 3.0 [6] SINHALA LETTER EYANNA..SINHALA LETTER AUYANNA\n0D9A..0D9D ; Recommended # 3.0 [4] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER MAHAAPRAANA GAYANNA\n0D9F..0DB1 ; Recommended # 3.0 [19] SINHALA LETTER SANYAKA GAYANNA..SINHALA LETTER DANTAJA NAYANNA\n0DB3..0DBB ; Recommended # 3.0 [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA\n0DBD ; Recommended # 3.0 SINHALA LETTER DANTAJA LAYANNA\n0DC0..0DC6 ; Recommended # 3.0 [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA\n0DCA ; Recommended # 3.0 SINHALA SIGN AL-LAKUNA\n0DCF..0DD4 ; Recommended # 3.0 [6] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA\n0DD6 ; Recommended # 3.0 SINHALA VOWEL SIGN DIGA PAA-PILLA\n0DD8..0DDE ; Recommended # 3.0 [7] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA\n0DF2 ; Recommended # 3.0 SINHALA VOWEL SIGN DIGA GAETTA-PILLA\n0E01..0E32 ; Recommended # 1.1 [50] THAI CHARACTER KO KAI..THAI CHARACTER SARA AA\n0E34..0E3A ; Recommended # 1.1 [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU\n0E40..0E4D ; Recommended # 1.1 [14] THAI CHARACTER SARA E..THAI CHARACTER NIKHAHIT\n0E50..0E59 ; Recommended # 1.1 [10] THAI DIGIT ZERO..THAI DIGIT NINE\n0E81..0E82 ; Recommended # 1.1 [2] LAO LETTER KO..LAO LETTER KHO SUNG\n0E84 ; Recommended # 1.1 LAO LETTER KHO TAM\n0E87..0E88 ; Recommended # 1.1 [2] LAO LETTER NGO..LAO LETTER CO\n0E8A ; Recommended # 1.1 LAO LETTER SO TAM\n0E8D ; Recommended # 1.1 LAO LETTER NYO\n0E94..0E97 ; Recommended # 1.1 [4] LAO LETTER DO..LAO LETTER THO TAM\n0E99..0E9F ; Recommended # 1.1 [7] LAO LETTER NO..LAO LETTER FO SUNG\n0EA1..0EA3 ; Recommended # 1.1 [3] LAO LETTER MO..LAO LETTER LO LING\n0EA5 ; Recommended # 1.1 LAO LETTER LO LOOT\n0EA7 ; Recommended # 1.1 LAO LETTER WO\n0EAA..0EAB ; Recommended # 1.1 [2] LAO LETTER SO SUNG..LAO LETTER HO SUNG\n0EAD..0EAE ; Recommended # 1.1 [2] LAO LETTER O..LAO LETTER HO TAM\n0EB0..0EB2 ; Recommended # 1.1 [3] LAO VOWEL SIGN A..LAO VOWEL SIGN AA\n0EB4..0EB9 ; Recommended # 1.1 [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU\n0EBB..0EBD ; Recommended # 1.1 [3] LAO VOWEL SIGN MAI KON..LAO SEMIVOWEL SIGN NYO\n0EC0..0EC4 ; Recommended # 1.1 [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI\n0EC6 ; Recommended # 1.1 LAO KO LA\n0EC8..0ECD ; Recommended # 1.1 [6] LAO TONE MAI EK..LAO NIGGAHITA\n0ED0..0ED9 ; Recommended # 1.1 [10] LAO DIGIT ZERO..LAO DIGIT NINE\n0F20..0F29 ; Recommended # 2.0 [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE\n0F40..0F42 ; Recommended # 2.0 [3] TIBETAN LETTER KA..TIBETAN LETTER GA\n0F44..0F47 ; Recommended # 2.0 [4] TIBETAN LETTER NGA..TIBETAN LETTER JA\n0F49..0F4C ; Recommended # 2.0 [4] TIBETAN LETTER NYA..TIBETAN LETTER DDA\n0F4E..0F51 ; Recommended # 2.0 [4] TIBETAN LETTER NNA..TIBETAN LETTER DA\n0F53..0F56 ; Recommended # 2.0 [4] TIBETAN LETTER NA..TIBETAN LETTER BA\n0F58..0F5B ; Recommended # 2.0 [4] TIBETAN LETTER MA..TIBETAN LETTER DZA\n0F5D..0F68 ; Recommended # 2.0 [12] TIBETAN LETTER WA..TIBETAN LETTER A\n0F71..0F72 ; Recommended # 2.0 [2] TIBETAN VOWEL SIGN AA..TIBETAN VOWEL SIGN I\n0F74 ; Recommended # 2.0 TIBETAN VOWEL SIGN U\n0F7A..0F80 ; Recommended # 2.0 [7] TIBETAN VOWEL SIGN E..TIBETAN VOWEL SIGN REVERSED I\n0F84 ; Recommended # 2.0 TIBETAN MARK HALANTA\n0F90..0F92 ; Recommended # 2.0 [3] TIBETAN SUBJOINED LETTER KA..TIBETAN SUBJOINED LETTER GA\n0F94..0F95 ; Recommended # 2.0 [2] TIBETAN SUBJOINED LETTER NGA..TIBETAN SUBJOINED LETTER CA\n0F96 ; Recommended # 3.0 TIBETAN SUBJOINED LETTER CHA\n0F97 ; Recommended # 2.0 TIBETAN SUBJOINED LETTER JA\n0F99..0F9C ; Recommended # 2.0 [4] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER DDA\n0F9E..0FA1 ; Recommended # 2.0 [4] TIBETAN SUBJOINED LETTER NNA..TIBETAN SUBJOINED LETTER DA\n0FA3..0FA6 ; Recommended # 2.0 [4] TIBETAN SUBJOINED LETTER NA..TIBETAN SUBJOINED LETTER BA\n0FA8..0FAB ; Recommended # 2.0 [4] TIBETAN SUBJOINED LETTER MA..TIBETAN SUBJOINED LETTER DZA\n0FAD ; Recommended # 2.0 TIBETAN SUBJOINED LETTER WA\n0FB1..0FB7 ; Recommended # 2.0 [7] TIBETAN SUBJOINED LETTER YA..TIBETAN SUBJOINED LETTER HA\n0FB8 ; Recommended # 3.0 TIBETAN SUBJOINED LETTER A\n0FBA..0FBC ; Recommended # 3.0 [3] TIBETAN SUBJOINED LETTER FIXED-FORM WA..TIBETAN SUBJOINED LETTER FIXED-FORM RA\n1000..1021 ; Recommended # 3.0 [34] MYANMAR LETTER KA..MYANMAR LETTER A\n1022 ; Recommended # 5.1 MYANMAR LETTER SHAN A\n1023..1027 ; Recommended # 3.0 [5] MYANMAR LETTER I..MYANMAR LETTER E\n1028 ; Recommended # 5.1 MYANMAR LETTER MON E\n1029..102A ; Recommended # 3.0 [2] MYANMAR LETTER O..MYANMAR LETTER AU\n102B ; Recommended # 5.1 MYANMAR VOWEL SIGN TALL AA\n102C..1032 ; Recommended # 3.0 [7] MYANMAR VOWEL SIGN AA..MYANMAR VOWEL SIGN AI\n1033..1035 ; Recommended # 5.1 [3] MYANMAR VOWEL SIGN MON II..MYANMAR VOWEL SIGN E ABOVE\n1036..1039 ; Recommended # 3.0 [4] MYANMAR SIGN ANUSVARA..MYANMAR SIGN VIRAMA\n103A..103F ; Recommended # 5.1 [6] MYANMAR SIGN ASAT..MYANMAR LETTER GREAT SA\n1040..1049 ; Recommended # 3.0 [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE\n105A..1064 ; Recommended # 5.1 [11] MYANMAR LETTER MON NGA..MYANMAR TONE MARK SGAW KAREN KE PHO\n1075..108A ; Recommended # 5.1 [22] MYANMAR LETTER SHAN KA..MYANMAR SIGN SHAN TONE-6\n108F ; Recommended # 5.1 MYANMAR SIGN RUMAI PALAUNG TONE-5\n10C7 ; Recommended # 6.1 GEORGIAN CAPITAL LETTER YN\n10CD ; Recommended # 6.1 GEORGIAN CAPITAL LETTER AEN\n10D0..10F0 ; Recommended # 1.1 [33] GEORGIAN LETTER AN..GEORGIAN LETTER HAE\n1200..1206 ; Recommended # 3.0 [7] ETHIOPIC SYLLABLE HA..ETHIOPIC SYLLABLE HO\n1208..1246 ; Recommended # 3.0 [63] ETHIOPIC SYLLABLE LA..ETHIOPIC SYLLABLE QO\n1247 ; Recommended # 4.1 ETHIOPIC SYLLABLE QOA\n1248 ; Recommended # 3.0 ETHIOPIC SYLLABLE QWA\n124A..124D ; Recommended # 3.0 [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE\n1250..1256 ; Recommended # 3.0 [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO\n1258 ; Recommended # 3.0 ETHIOPIC SYLLABLE QHWA\n125A..125D ; Recommended # 3.0 [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE\n1260..1286 ; Recommended # 3.0 [39] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XO\n1288 ; Recommended # 3.0 ETHIOPIC SYLLABLE XWA\n128A..128D ; Recommended # 3.0 [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE\n1290..12AE ; Recommended # 3.0 [31] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KO\n12B0 ; Recommended # 3.0 ETHIOPIC SYLLABLE KWA\n12B2..12B5 ; Recommended # 3.0 [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE\n12B8..12BE ; Recommended # 3.0 [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO\n12C0 ; Recommended # 3.0 ETHIOPIC SYLLABLE KXWA\n12C2..12C5 ; Recommended # 3.0 [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE\n12C8..12CE ; Recommended # 3.0 [7] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE WO\n12CF ; Recommended # 4.1 ETHIOPIC SYLLABLE WOA\n12D0..12D6 ; Recommended # 3.0 [7] ETHIOPIC SYLLABLE PHARYNGEAL A..ETHIOPIC SYLLABLE PHARYNGEAL O\n12D8..12EE ; Recommended # 3.0 [23] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE YO\n12EF ; Recommended # 4.1 ETHIOPIC SYLLABLE YOA\n12F0..12F7 ; Recommended # 3.0 [8] ETHIOPIC SYLLABLE DA..ETHIOPIC SYLLABLE DWA\n1300..130E ; Recommended # 3.0 [15] ETHIOPIC SYLLABLE JA..ETHIOPIC SYLLABLE GO\n1310 ; Recommended # 3.0 ETHIOPIC SYLLABLE GWA\n1312..1315 ; Recommended # 3.0 [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE\n1318..131E ; Recommended # 3.0 [7] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE GGO\n1320..1346 ; Recommended # 3.0 [39] ETHIOPIC SYLLABLE THA..ETHIOPIC SYLLABLE TZO\n1348..1359 ; Recommended # 3.0 [18] ETHIOPIC SYLLABLE FA..ETHIOPIC SYLLABLE MYA\n1780..179C ; Recommended # 3.0 [29] KHMER LETTER KA..KHMER LETTER VO\n179F..17A2 ; Recommended # 3.0 [4] KHMER LETTER SA..KHMER LETTER QA\n17A5..17A7 ; Recommended # 3.0 [3] KHMER INDEPENDENT VOWEL QI..KHMER INDEPENDENT VOWEL QU\n17AA..17B3 ; Recommended # 3.0 [10] KHMER INDEPENDENT VOWEL QUUV..KHMER INDEPENDENT VOWEL QAU\n17B6..17CD ; Recommended # 3.0 [24] KHMER VOWEL SIGN AA..KHMER SIGN TOANDAKHIAT\n17D0 ; Recommended # 3.0 KHMER SIGN SAMYOK SANNYA\n17D2 ; Recommended # 3.0 KHMER SIGN COENG\n17E0..17E9 ; Recommended # 3.0 [10] KHMER DIGIT ZERO..KHMER DIGIT NINE\n1C90..1CBA ; Recommended # 11.0 [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN\n1CBD..1CBF ; Recommended # 11.0 [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN\n1E0C..1E0D ; Recommended # 1.1 [2] LATIN CAPITAL LETTER D WITH DOT BELOW..LATIN SMALL LETTER D WITH DOT BELOW\n1E12..1E13 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW\n1E20..1E21 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER G WITH MACRON..LATIN SMALL LETTER G WITH MACRON\n1E24..1E25 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER H WITH DOT BELOW..LATIN SMALL LETTER H WITH DOT BELOW\n1E36..1E37 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER L WITH DOT BELOW..LATIN SMALL LETTER L WITH DOT BELOW\n1E3C..1E3F ; Recommended # 1.1 [4] LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER M WITH ACUTE\n1E42..1E4B ; Recommended # 1.1 [10] LATIN CAPITAL LETTER M WITH DOT BELOW..LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW\n1E5A..1E5B ; Recommended # 1.1 [2] LATIN CAPITAL LETTER R WITH DOT BELOW..LATIN SMALL LETTER R WITH DOT BELOW\n1E62..1E63 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER S WITH DOT BELOW..LATIN SMALL LETTER S WITH DOT BELOW\n1E6C..1E6D ; Recommended # 1.1 [2] LATIN CAPITAL LETTER T WITH DOT BELOW..LATIN SMALL LETTER T WITH DOT BELOW\n1E70..1E71 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW\n1E8C..1E8D ; Recommended # 1.1 [2] LATIN CAPITAL LETTER X WITH DIAERESIS..LATIN SMALL LETTER X WITH DIAERESIS\n1E92..1E93 ; Recommended # 1.1 [2] LATIN CAPITAL LETTER Z WITH DOT BELOW..LATIN SMALL LETTER Z WITH DOT BELOW\n1E9E ; Recommended # 5.1 LATIN CAPITAL LETTER SHARP S\n1EA0..1EF9 ; Recommended # 1.1 [90] LATIN CAPITAL LETTER A WITH DOT BELOW..LATIN SMALL LETTER Y WITH TILDE\n1FA0..1FAF ; Recommended # 1.1 [16] GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI..GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI\n1FB2..1FB4 ; Recommended # 1.1 [3] GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI\n1FEC ; Recommended # 1.1 GREEK CAPITAL LETTER RHO WITH DASIA\n3005..3007 ; Recommended # 1.1 [3] IDEOGRAPHIC ITERATION MARK..IDEOGRAPHIC NUMBER ZERO\n3041..3094 ; Recommended # 1.1 [84] HIRAGANA LETTER SMALL A..HIRAGANA LETTER VU\n3095..3096 ; Recommended # 3.2 [2] HIRAGANA LETTER SMALL KA..HIRAGANA LETTER SMALL KE\n309D..309E ; Recommended # 1.1 [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK\n30A1..30FA ; Recommended # 1.1 [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO\n30FC..30FE ; Recommended # 1.1 [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK\n3447 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3447\n3473 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3473\n34E4 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-34E4\n3577 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3577\n359E ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-359E\n35A1 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-35A1\n35AD ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-35AD\n35BF ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-35BF\n35CE ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-35CE\n35F3 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-35F3\n35FE ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-35FE\n360E ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-360E\n361A ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-361A\n3918 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3918\n3960 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3960\n396E ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-396E\n39CF..39D0 ; Recommended # 3.0 [2] CJK UNIFIED IDEOGRAPH-39CF..CJK UNIFIED IDEOGRAPH-39D0\n39DB ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-39DB\n39DF ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-39DF\n39F8 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-39F8\n39FE ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-39FE\n3A18 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3A18\n3A52 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3A52\n3A5C ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3A5C\n3A67 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3A67\n3A73 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3A73\n3B39 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3B39\n3B4E ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3B4E\n3BA3 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3BA3\n3C6E ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3C6E\n3CE0 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3CE0\n3DE7 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3DE7\n3DEB ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3DEB\n3E74 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3E74\n3ED0 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-3ED0\n4056 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4056\n4065 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4065\n406A ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-406A\n40BB ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-40BB\n40DF ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-40DF\n4137 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4137\n415F ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-415F\n4337 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4337\n43AC ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-43AC\n43B1 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-43B1\n43D3 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-43D3\n43DD ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-43DD\n4443 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4443\n44D6 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-44D6\n44EA ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-44EA\n4606 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4606\n464C ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-464C\n4661 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4661\n4723 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4723\n4729 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4729\n477C ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-477C\n478D ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-478D\n47F4 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-47F4\n4882 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4882\n4947 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4947\n497A ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-497A\n497D ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-497D\n4982..4983 ; Recommended # 3.0 [2] CJK UNIFIED IDEOGRAPH-4982..CJK UNIFIED IDEOGRAPH-4983\n4985..4986 ; Recommended # 3.0 [2] CJK UNIFIED IDEOGRAPH-4985..CJK UNIFIED IDEOGRAPH-4986\n499B ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-499B\n499F ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-499F\n49B6..49B7 ; Recommended # 3.0 [2] CJK UNIFIED IDEOGRAPH-49B6..CJK UNIFIED IDEOGRAPH-49B7\n4A12 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4A12\n4AB8 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4AB8\n4C77 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4C77\n4C7D ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4C7D\n4C81 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4C81\n4C85 ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4C85\n4C9D..4CA3 ; Recommended # 3.0 [7] CJK UNIFIED IDEOGRAPH-4C9D..CJK UNIFIED IDEOGRAPH-4CA3\n4D13..4D19 ; Recommended # 3.0 [7] CJK UNIFIED IDEOGRAPH-4D13..CJK UNIFIED IDEOGRAPH-4D19\n4DAE ; Recommended # 3.0 CJK UNIFIED IDEOGRAPH-4DAE\n4E00..4E11 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-4E11\n4E13..4E28 ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-4E13..CJK UNIFIED IDEOGRAPH-4E28\n4E2A..4E67 ; Recommended # 1.1 [62] CJK UNIFIED IDEOGRAPH-4E2A..CJK UNIFIED IDEOGRAPH-4E67\n4E69..4E78 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-4E69..CJK UNIFIED IDEOGRAPH-4E78\n4E7A..4E95 ; Recommended # 1.1 [28] CJK UNIFIED IDEOGRAPH-4E7A..CJK UNIFIED IDEOGRAPH-4E95\n4E97..4EA2 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-4E97..CJK UNIFIED IDEOGRAPH-4EA2\n4EA4..4EBB ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-4EA4..CJK UNIFIED IDEOGRAPH-4EBB\n4EBD..4ECB ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-4EBD..CJK UNIFIED IDEOGRAPH-4ECB\n4ECD..4EE6 ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-4ECD..CJK UNIFIED IDEOGRAPH-4EE6\n4EE8..4EF7 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-4EE8..CJK UNIFIED IDEOGRAPH-4EF7\n4EFB ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-4EFB\n4EFD ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-4EFD\n4EFF..4F06 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-4EFF..CJK UNIFIED IDEOGRAPH-4F06\n4F08..4F15 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-4F08..CJK UNIFIED IDEOGRAPH-4F15\n4F17..4F27 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-4F17..CJK UNIFIED IDEOGRAPH-4F27\n4F29..4F30 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-4F29..CJK UNIFIED IDEOGRAPH-4F30\n4F32..4F34 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-4F32..CJK UNIFIED IDEOGRAPH-4F34\n4F36 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-4F36\n4F38..4F3F ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-4F38..CJK UNIFIED IDEOGRAPH-4F3F\n4F41..4F43 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-4F41..CJK UNIFIED IDEOGRAPH-4F43\n4F45..4F70 ; Recommended # 1.1 [44] CJK UNIFIED IDEOGRAPH-4F45..CJK UNIFIED IDEOGRAPH-4F70\n4F72..4F8B ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-4F72..CJK UNIFIED IDEOGRAPH-4F8B\n4F8D ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-4F8D\n4F8F..4FA1 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-4F8F..CJK UNIFIED IDEOGRAPH-4FA1\n4FA3..4FBC ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-4FA3..CJK UNIFIED IDEOGRAPH-4FBC\n4FBE..4FC5 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-4FBE..CJK UNIFIED IDEOGRAPH-4FC5\n4FC7 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-4FC7\n4FC9..4FCB ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-4FC9..CJK UNIFIED IDEOGRAPH-4FCB\n4FCD..4FE1 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-4FCD..CJK UNIFIED IDEOGRAPH-4FE1\n4FE3..4FFB ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-4FE3..CJK UNIFIED IDEOGRAPH-4FFB\n4FFE..500F ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-4FFE..CJK UNIFIED IDEOGRAPH-500F\n5011..5033 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-5011..CJK UNIFIED IDEOGRAPH-5033\n5035..5037 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5035..CJK UNIFIED IDEOGRAPH-5037\n5039..503C ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5039..CJK UNIFIED IDEOGRAPH-503C\n503E..5041 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-503E..CJK UNIFIED IDEOGRAPH-5041\n5043..5051 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-5043..CJK UNIFIED IDEOGRAPH-5051\n5053..5057 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5053..CJK UNIFIED IDEOGRAPH-5057\n5059..507B ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-5059..CJK UNIFIED IDEOGRAPH-507B\n507D..5080 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-507D..CJK UNIFIED IDEOGRAPH-5080\n5082..5092 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-5082..CJK UNIFIED IDEOGRAPH-5092\n5094..5096 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5094..CJK UNIFIED IDEOGRAPH-5096\n5098..509E ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5098..CJK UNIFIED IDEOGRAPH-509E\n50A2..50B8 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-50A2..CJK UNIFIED IDEOGRAPH-50B8\n50BA..50C2 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-50BA..CJK UNIFIED IDEOGRAPH-50C2\n50C4..50D7 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-50C4..CJK UNIFIED IDEOGRAPH-50D7\n50D9..50DE ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-50D9..CJK UNIFIED IDEOGRAPH-50DE\n50E0 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-50E0\n50E3..50EA ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-50E3..CJK UNIFIED IDEOGRAPH-50EA\n50EC..50F3 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-50EC..CJK UNIFIED IDEOGRAPH-50F3\n50F5..50F6 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-50F5..CJK UNIFIED IDEOGRAPH-50F6\n50F8..511A ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-50F8..CJK UNIFIED IDEOGRAPH-511A\n511C..5127 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-511C..CJK UNIFIED IDEOGRAPH-5127\n5129..512A ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5129..CJK UNIFIED IDEOGRAPH-512A\n512C..5141 ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-512C..CJK UNIFIED IDEOGRAPH-5141\n5143..5149 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5143..CJK UNIFIED IDEOGRAPH-5149\n514B..514E ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-514B..CJK UNIFIED IDEOGRAPH-514E\n5150..5152 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5150..CJK UNIFIED IDEOGRAPH-5152\n5154..5157 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5154..CJK UNIFIED IDEOGRAPH-5157\n5159..515F ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5159..CJK UNIFIED IDEOGRAPH-515F\n5161..5163 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5161..CJK UNIFIED IDEOGRAPH-5163\n5165..5171 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-5165..CJK UNIFIED IDEOGRAPH-5171\n5173..517D ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-5173..CJK UNIFIED IDEOGRAPH-517D\n517F..5182 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-517F..CJK UNIFIED IDEOGRAPH-5182\n5185..518D ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-5185..CJK UNIFIED IDEOGRAPH-518D\n518F..51A0 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-518F..CJK UNIFIED IDEOGRAPH-51A0\n51A2 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-51A2\n51A4..51AC ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-51A4..CJK UNIFIED IDEOGRAPH-51AC\n51AE..51B7 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-51AE..CJK UNIFIED IDEOGRAPH-51B7\n51B9 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-51B9\n51BB..51C1 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-51BB..CJK UNIFIED IDEOGRAPH-51C1\n51C3..51D1 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-51C3..CJK UNIFIED IDEOGRAPH-51D1\n51D4..51DE ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-51D4..CJK UNIFIED IDEOGRAPH-51DE\n51E0..51EB ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-51E0..CJK UNIFIED IDEOGRAPH-51EB\n51ED ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-51ED\n51EF..51F1 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-51EF..CJK UNIFIED IDEOGRAPH-51F1\n51F3..5252 ; Recommended # 1.1 [96] CJK UNIFIED IDEOGRAPH-51F3..CJK UNIFIED IDEOGRAPH-5252\n5254..5265 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-5254..CJK UNIFIED IDEOGRAPH-5265\n5267..5278 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-5267..CJK UNIFIED IDEOGRAPH-5278\n527A..5284 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-527A..CJK UNIFIED IDEOGRAPH-5284\n5286..528D ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5286..CJK UNIFIED IDEOGRAPH-528D\n528F..52C3 ; Recommended # 1.1 [53] CJK UNIFIED IDEOGRAPH-528F..CJK UNIFIED IDEOGRAPH-52C3\n52C5..52C7 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-52C5..CJK UNIFIED IDEOGRAPH-52C7\n52C9..52CB ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-52C9..CJK UNIFIED IDEOGRAPH-52CB\n52CD ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-52CD\n52CF..52D0 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-52CF..CJK UNIFIED IDEOGRAPH-52D0\n52D2..52D3 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-52D2..CJK UNIFIED IDEOGRAPH-52D3\n52D5..52E0 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-52D5..CJK UNIFIED IDEOGRAPH-52E0\n52E2..52E4 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-52E2..CJK UNIFIED IDEOGRAPH-52E4\n52E6..52ED ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-52E6..CJK UNIFIED IDEOGRAPH-52ED\n52EF..5302 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-52EF..CJK UNIFIED IDEOGRAPH-5302\n5305..5317 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-5305..CJK UNIFIED IDEOGRAPH-5317\n5319..531A ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5319..CJK UNIFIED IDEOGRAPH-531A\n531C..531D ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-531C..CJK UNIFIED IDEOGRAPH-531D\n531F..5326 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-531F..CJK UNIFIED IDEOGRAPH-5326\n5328 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5328\n532A..5331 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-532A..CJK UNIFIED IDEOGRAPH-5331\n5333..5334 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5333..CJK UNIFIED IDEOGRAPH-5334\n5337..5341 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-5337..CJK UNIFIED IDEOGRAPH-5341\n5343..535A ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-5343..CJK UNIFIED IDEOGRAPH-535A\n535C ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-535C\n535E..5369 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-535E..CJK UNIFIED IDEOGRAPH-5369\n536B..536C ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-536B..CJK UNIFIED IDEOGRAPH-536C\n536E..537F ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-536E..CJK UNIFIED IDEOGRAPH-537F\n5381..53A0 ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-5381..CJK UNIFIED IDEOGRAPH-53A0\n53A2..53A9 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-53A2..CJK UNIFIED IDEOGRAPH-53A9\n53AC..53AE ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-53AC..CJK UNIFIED IDEOGRAPH-53AE\n53B0..53B9 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-53B0..CJK UNIFIED IDEOGRAPH-53B9\n53BB..53C4 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-53BB..CJK UNIFIED IDEOGRAPH-53C4\n53C6..53CE ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-53C6..CJK UNIFIED IDEOGRAPH-53CE\n53D0..53DC ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-53D0..CJK UNIFIED IDEOGRAPH-53DC\n53DF..53E6 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-53DF..CJK UNIFIED IDEOGRAPH-53E6\n53E8..53FE ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-53E8..CJK UNIFIED IDEOGRAPH-53FE\n5401..5419 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-5401..CJK UNIFIED IDEOGRAPH-5419\n541B..5421 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-541B..CJK UNIFIED IDEOGRAPH-5421\n5423..544B ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-5423..CJK UNIFIED IDEOGRAPH-544B\n544D..545C ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-544D..CJK UNIFIED IDEOGRAPH-545C\n545E..5468 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-545E..CJK UNIFIED IDEOGRAPH-5468\n546A..5489 ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-546A..CJK UNIFIED IDEOGRAPH-5489\n548B..54B4 ; Recommended # 1.1 [42] CJK UNIFIED IDEOGRAPH-548B..CJK UNIFIED IDEOGRAPH-54B4\n54B6..54F5 ; Recommended # 1.1 [64] CJK UNIFIED IDEOGRAPH-54B6..CJK UNIFIED IDEOGRAPH-54F5\n54F7..5514 ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-54F7..CJK UNIFIED IDEOGRAPH-5514\n5516..5517 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5516..CJK UNIFIED IDEOGRAPH-5517\n551A..5546 ; Recommended # 1.1 [45] CJK UNIFIED IDEOGRAPH-551A..CJK UNIFIED IDEOGRAPH-5546\n5548..555F ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-5548..CJK UNIFIED IDEOGRAPH-555F\n5561..5579 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-5561..CJK UNIFIED IDEOGRAPH-5579\n557B..55DF ; Recommended # 1.1 [101] CJK UNIFIED IDEOGRAPH-557B..CJK UNIFIED IDEOGRAPH-55DF\n55E1..55F7 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-55E1..CJK UNIFIED IDEOGRAPH-55F7\n55F9..5609 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-55F9..CJK UNIFIED IDEOGRAPH-5609\n560C..561F ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-560C..CJK UNIFIED IDEOGRAPH-561F\n5621..562A ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-5621..CJK UNIFIED IDEOGRAPH-562A\n562C..5636 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-562C..CJK UNIFIED IDEOGRAPH-5636\n5638..563B ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5638..CJK UNIFIED IDEOGRAPH-563B\n563D..5643 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-563D..CJK UNIFIED IDEOGRAPH-5643\n5645..564A ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-5645..CJK UNIFIED IDEOGRAPH-564A\n564C..5650 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-564C..CJK UNIFIED IDEOGRAPH-5650\n5652..5655 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5652..CJK UNIFIED IDEOGRAPH-5655\n5657..565E ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5657..CJK UNIFIED IDEOGRAPH-565E\n5660 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5660\n5662..5674 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-5662..CJK UNIFIED IDEOGRAPH-5674\n5676..567C ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5676..CJK UNIFIED IDEOGRAPH-567C\n567E..5687 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-567E..CJK UNIFIED IDEOGRAPH-5687\n5689..568A ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5689..CJK UNIFIED IDEOGRAPH-568A\n568C..5695 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-568C..CJK UNIFIED IDEOGRAPH-5695\n5697..569D ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5697..CJK UNIFIED IDEOGRAPH-569D\n569F..56B9 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-569F..CJK UNIFIED IDEOGRAPH-56B9\n56BB..56CE ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-56BB..CJK UNIFIED IDEOGRAPH-56CE\n56D0..56D8 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-56D0..CJK UNIFIED IDEOGRAPH-56D8\n56DA..56E5 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-56DA..CJK UNIFIED IDEOGRAPH-56E5\n56E7..56F5 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-56E7..CJK UNIFIED IDEOGRAPH-56F5\n56F7 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-56F7\n56F9..56FA ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-56F9..CJK UNIFIED IDEOGRAPH-56FA\n56FD..5704 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-56FD..CJK UNIFIED IDEOGRAPH-5704\n5706..5710 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-5706..CJK UNIFIED IDEOGRAPH-5710\n5712..5716 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5712..CJK UNIFIED IDEOGRAPH-5716\n5718..5720 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-5718..CJK UNIFIED IDEOGRAPH-5720\n5722..5723 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5722..CJK UNIFIED IDEOGRAPH-5723\n5725..573C ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-5725..CJK UNIFIED IDEOGRAPH-573C\n573E..5742 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-573E..CJK UNIFIED IDEOGRAPH-5742\n5744..5747 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5744..CJK UNIFIED IDEOGRAPH-5747\n5749..5754 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-5749..CJK UNIFIED IDEOGRAPH-5754\n5757 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5757\n5759..5762 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-5759..CJK UNIFIED IDEOGRAPH-5762\n5764..5777 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-5764..CJK UNIFIED IDEOGRAPH-5777\n5779..5780 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5779..CJK UNIFIED IDEOGRAPH-5780\n5782..5786 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5782..CJK UNIFIED IDEOGRAPH-5786\n5788..5795 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-5788..CJK UNIFIED IDEOGRAPH-5795\n5797..57A7 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-5797..CJK UNIFIED IDEOGRAPH-57A7\n57A9..57C9 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-57A9..CJK UNIFIED IDEOGRAPH-57C9\n57CB..57D0 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-57CB..CJK UNIFIED IDEOGRAPH-57D0\n57D2..57DA ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-57D2..CJK UNIFIED IDEOGRAPH-57DA\n57DC..5816 ; Recommended # 1.1 [59] CJK UNIFIED IDEOGRAPH-57DC..CJK UNIFIED IDEOGRAPH-5816\n5819..584F ; Recommended # 1.1 [55] CJK UNIFIED IDEOGRAPH-5819..CJK UNIFIED IDEOGRAPH-584F\n5851..5855 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5851..CJK UNIFIED IDEOGRAPH-5855\n5857..585F ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-5857..CJK UNIFIED IDEOGRAPH-585F\n5861..5865 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5861..CJK UNIFIED IDEOGRAPH-5865\n5868..5876 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-5868..CJK UNIFIED IDEOGRAPH-5876\n5878..5894 ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-5878..CJK UNIFIED IDEOGRAPH-5894\n5896..58A9 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-5896..CJK UNIFIED IDEOGRAPH-58A9\n58AB..58B5 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-58AB..CJK UNIFIED IDEOGRAPH-58B5\n58B7..58BF ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-58B7..CJK UNIFIED IDEOGRAPH-58BF\n58C1..58C2 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-58C1..CJK UNIFIED IDEOGRAPH-58C2\n58C5..58CC ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-58C5..CJK UNIFIED IDEOGRAPH-58CC\n58CE..58CF ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-58CE..CJK UNIFIED IDEOGRAPH-58CF\n58D1..58E0 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-58D1..CJK UNIFIED IDEOGRAPH-58E0\n58E2..58E5 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-58E2..CJK UNIFIED IDEOGRAPH-58E5\n58E7..58F4 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-58E7..CJK UNIFIED IDEOGRAPH-58F4\n58F6..5900 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-58F6..CJK UNIFIED IDEOGRAPH-5900\n5902..5904 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5902..CJK UNIFIED IDEOGRAPH-5904\n5906..5907 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5906..CJK UNIFIED IDEOGRAPH-5907\n5909..5910 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5909..CJK UNIFIED IDEOGRAPH-5910\n5912 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5912\n5914..5922 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-5914..CJK UNIFIED IDEOGRAPH-5922\n5924..5932 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-5924..CJK UNIFIED IDEOGRAPH-5932\n5934..5935 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5934..CJK UNIFIED IDEOGRAPH-5935\n5937..5958 ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-5937..CJK UNIFIED IDEOGRAPH-5958\n595A ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-595A\n595C..59B6 ; Recommended # 1.1 [91] CJK UNIFIED IDEOGRAPH-595C..CJK UNIFIED IDEOGRAPH-59B6\n59B8..59E6 ; Recommended # 1.1 [47] CJK UNIFIED IDEOGRAPH-59B8..CJK UNIFIED IDEOGRAPH-59E6\n59E8..5A23 ; Recommended # 1.1 [60] CJK UNIFIED IDEOGRAPH-59E8..CJK UNIFIED IDEOGRAPH-5A23\n5A25 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5A25\n5A27..5A2B ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5A27..CJK UNIFIED IDEOGRAPH-5A2B\n5A2D..5A2F ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5A2D..CJK UNIFIED IDEOGRAPH-5A2F\n5A31..5A53 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-5A31..CJK UNIFIED IDEOGRAPH-5A53\n5A55..5A58 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5A55..CJK UNIFIED IDEOGRAPH-5A58\n5A5A..5A6E ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-5A5A..CJK UNIFIED IDEOGRAPH-5A6E\n5A70 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5A70\n5A72..5A86 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-5A72..CJK UNIFIED IDEOGRAPH-5A86\n5A88..5A8C ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5A88..CJK UNIFIED IDEOGRAPH-5A8C\n5A8E..5AAA ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-5A8E..CJK UNIFIED IDEOGRAPH-5AAA\n5AAC..5AD2 ; Recommended # 1.1 [39] CJK UNIFIED IDEOGRAPH-5AAC..CJK UNIFIED IDEOGRAPH-5AD2\n5AD4..5AEE ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-5AD4..CJK UNIFIED IDEOGRAPH-5AEE\n5AF1..5B09 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-5AF1..CJK UNIFIED IDEOGRAPH-5B09\n5B0B..5B0C ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5B0B..CJK UNIFIED IDEOGRAPH-5B0C\n5B0E..5B38 ; Recommended # 1.1 [43] CJK UNIFIED IDEOGRAPH-5B0E..CJK UNIFIED IDEOGRAPH-5B38\n5B3A..5B45 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-5B3A..CJK UNIFIED IDEOGRAPH-5B45\n5B47..5B4E ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5B47..CJK UNIFIED IDEOGRAPH-5B4E\n5B50..5B51 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5B50..CJK UNIFIED IDEOGRAPH-5B51\n5B53..5B5F ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-5B53..CJK UNIFIED IDEOGRAPH-5B5F\n5B62..5B6E ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-5B62..CJK UNIFIED IDEOGRAPH-5B6E\n5B70..5B78 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-5B70..CJK UNIFIED IDEOGRAPH-5B78\n5B7A..5B7D ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5B7A..CJK UNIFIED IDEOGRAPH-5B7D\n5B7F..5B85 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5B7F..CJK UNIFIED IDEOGRAPH-5B85\n5B87..5B8F ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-5B87..CJK UNIFIED IDEOGRAPH-5B8F\n5B91..5BA8 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-5B91..CJK UNIFIED IDEOGRAPH-5BA8\n5BAA..5BB1 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5BAA..CJK UNIFIED IDEOGRAPH-5BB1\n5BB3..5BB6 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5BB3..CJK UNIFIED IDEOGRAPH-5BB6\n5BB8..5BBB ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5BB8..CJK UNIFIED IDEOGRAPH-5BBB\n5BBD..5BC7 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-5BBD..CJK UNIFIED IDEOGRAPH-5BC7\n5BC9..5BD9 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-5BC9..CJK UNIFIED IDEOGRAPH-5BD9\n5BDB..5BFF ; Recommended # 1.1 [37] CJK UNIFIED IDEOGRAPH-5BDB..CJK UNIFIED IDEOGRAPH-5BFF\n5C01..5C1A ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-5C01..CJK UNIFIED IDEOGRAPH-5C1A\n5C1C..5C22 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5C1C..CJK UNIFIED IDEOGRAPH-5C22\n5C24..5C25 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5C24..CJK UNIFIED IDEOGRAPH-5C25\n5C27..5C28 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5C27..CJK UNIFIED IDEOGRAPH-5C28\n5C2A..5C35 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-5C2A..CJK UNIFIED IDEOGRAPH-5C35\n5C37..5C59 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-5C37..CJK UNIFIED IDEOGRAPH-5C59\n5C5B..5C84 ; Recommended # 1.1 [42] CJK UNIFIED IDEOGRAPH-5C5B..CJK UNIFIED IDEOGRAPH-5C84\n5C86..5CB3 ; Recommended # 1.1 [46] CJK UNIFIED IDEOGRAPH-5C86..CJK UNIFIED IDEOGRAPH-5CB3\n5CB5..5CB8 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-5CB5..CJK UNIFIED IDEOGRAPH-5CB8\n5CBA..5CD4 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-5CBA..CJK UNIFIED IDEOGRAPH-5CD4\n5CD6..5CDC ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5CD6..CJK UNIFIED IDEOGRAPH-5CDC\n5CDE..5CF4 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-5CDE..CJK UNIFIED IDEOGRAPH-5CF4\n5CF6..5D2A ; Recommended # 1.1 [53] CJK UNIFIED IDEOGRAPH-5CF6..CJK UNIFIED IDEOGRAPH-5D2A\n5D2C..5D2E ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5D2C..CJK UNIFIED IDEOGRAPH-5D2E\n5D30..5D3A ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-5D30..CJK UNIFIED IDEOGRAPH-5D3A\n5D3C..5D52 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-5D3C..CJK UNIFIED IDEOGRAPH-5D52\n5D54..5D56 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-5D54..CJK UNIFIED IDEOGRAPH-5D56\n5D58..5D5F ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5D58..CJK UNIFIED IDEOGRAPH-5D5F\n5D61..5D82 ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-5D61..CJK UNIFIED IDEOGRAPH-5D82\n5D84..5D95 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-5D84..CJK UNIFIED IDEOGRAPH-5D95\n5D97..5DA2 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-5D97..CJK UNIFIED IDEOGRAPH-5DA2\n5DA5..5DAA ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-5DA5..CJK UNIFIED IDEOGRAPH-5DAA\n5DAC..5DB2 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-5DAC..CJK UNIFIED IDEOGRAPH-5DB2\n5DB4..5DB8 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5DB4..CJK UNIFIED IDEOGRAPH-5DB8\n5DBA..5DC3 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-5DBA..CJK UNIFIED IDEOGRAPH-5DC3\n5DC5..5DD6 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-5DC5..CJK UNIFIED IDEOGRAPH-5DD6\n5DD8..5DD9 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-5DD8..CJK UNIFIED IDEOGRAPH-5DD9\n5DDB ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5DDB\n5DDD..5DF5 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-5DDD..CJK UNIFIED IDEOGRAPH-5DF5\n5DF7..5E11 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-5DF7..CJK UNIFIED IDEOGRAPH-5E11\n5E13..5E47 ; Recommended # 1.1 [53] CJK UNIFIED IDEOGRAPH-5E13..CJK UNIFIED IDEOGRAPH-5E47\n5E49..5E50 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5E49..CJK UNIFIED IDEOGRAPH-5E50\n5E52..5E91 ; Recommended # 1.1 [64] CJK UNIFIED IDEOGRAPH-5E52..CJK UNIFIED IDEOGRAPH-5E91\n5E93..5EB9 ; Recommended # 1.1 [39] CJK UNIFIED IDEOGRAPH-5E93..CJK UNIFIED IDEOGRAPH-5EB9\n5EBB..5EBF ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-5EBB..CJK UNIFIED IDEOGRAPH-5EBF\n5EC1..5EEA ; Recommended # 1.1 [42] CJK UNIFIED IDEOGRAPH-5EC1..CJK UNIFIED IDEOGRAPH-5EEA\n5EEC..5EF8 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-5EEC..CJK UNIFIED IDEOGRAPH-5EF8\n5EFA..5F0D ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-5EFA..CJK UNIFIED IDEOGRAPH-5F0D\n5F0F..5F3A ; Recommended # 1.1 [44] CJK UNIFIED IDEOGRAPH-5F0F..CJK UNIFIED IDEOGRAPH-5F3A\n5F3C ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-5F3C\n5F3E..5F8E ; Recommended # 1.1 [81] CJK UNIFIED IDEOGRAPH-5F3E..CJK UNIFIED IDEOGRAPH-5F8E\n5F90..5F99 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-5F90..CJK UNIFIED IDEOGRAPH-5F99\n5F9B..5FA2 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-5F9B..CJK UNIFIED IDEOGRAPH-5FA2\n5FA5..5FAF ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-5FA5..CJK UNIFIED IDEOGRAPH-5FAF\n5FB1..5FC1 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-5FB1..CJK UNIFIED IDEOGRAPH-5FC1\n5FC3..5FCD ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-5FC3..CJK UNIFIED IDEOGRAPH-5FCD\n5FCF..5FDA ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-5FCF..CJK UNIFIED IDEOGRAPH-5FDA\n5FDC..5FE1 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-5FDC..CJK UNIFIED IDEOGRAPH-5FE1\n5FE3..5FEB ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-5FE3..CJK UNIFIED IDEOGRAPH-5FEB\n5FED..5FFB ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-5FED..CJK UNIFIED IDEOGRAPH-5FFB\n5FFD..6022 ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-5FFD..CJK UNIFIED IDEOGRAPH-6022\n6024..6055 ; Recommended # 1.1 [50] CJK UNIFIED IDEOGRAPH-6024..CJK UNIFIED IDEOGRAPH-6055\n6057..6060 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-6057..CJK UNIFIED IDEOGRAPH-6060\n6062..6070 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-6062..CJK UNIFIED IDEOGRAPH-6070\n6072..6073 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-6072..CJK UNIFIED IDEOGRAPH-6073\n6075..6090 ; Recommended # 1.1 [28] CJK UNIFIED IDEOGRAPH-6075..CJK UNIFIED IDEOGRAPH-6090\n6092 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6092\n6094..60A4 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-6094..CJK UNIFIED IDEOGRAPH-60A4\n60A6..60D1 ; Recommended # 1.1 [44] CJK UNIFIED IDEOGRAPH-60A6..CJK UNIFIED IDEOGRAPH-60D1\n60D3..60D5 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-60D3..CJK UNIFIED IDEOGRAPH-60D5\n60D7..60DD ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-60D7..CJK UNIFIED IDEOGRAPH-60DD\n60DF..60E4 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-60DF..CJK UNIFIED IDEOGRAPH-60E4\n60E6..60FC ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-60E6..CJK UNIFIED IDEOGRAPH-60FC\n60FE..6101 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-60FE..CJK UNIFIED IDEOGRAPH-6101\n6103..6106 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6103..CJK UNIFIED IDEOGRAPH-6106\n6108..6110 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-6108..CJK UNIFIED IDEOGRAPH-6110\n6112..611D ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-6112..CJK UNIFIED IDEOGRAPH-611D\n611F..6130 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-611F..CJK UNIFIED IDEOGRAPH-6130\n6132 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6132\n6134 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6134\n6136..6137 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-6136..CJK UNIFIED IDEOGRAPH-6137\n613A..615F ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-613A..CJK UNIFIED IDEOGRAPH-615F\n6161..617A ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-6161..CJK UNIFIED IDEOGRAPH-617A\n617C..617E ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-617C..CJK UNIFIED IDEOGRAPH-617E\n6180..6185 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-6180..CJK UNIFIED IDEOGRAPH-6185\n6187..6196 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-6187..CJK UNIFIED IDEOGRAPH-6196\n6198..619B ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6198..CJK UNIFIED IDEOGRAPH-619B\n619D..61B8 ; Recommended # 1.1 [28] CJK UNIFIED IDEOGRAPH-619D..CJK UNIFIED IDEOGRAPH-61B8\n61BA ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-61BA\n61BC..61D2 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-61BC..CJK UNIFIED IDEOGRAPH-61D2\n61D4 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-61D4\n61D6..61EB ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-61D6..CJK UNIFIED IDEOGRAPH-61EB\n61ED..61EE ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-61ED..CJK UNIFIED IDEOGRAPH-61EE\n61F0..6204 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-61F0..CJK UNIFIED IDEOGRAPH-6204\n6206..6234 ; Recommended # 1.1 [47] CJK UNIFIED IDEOGRAPH-6206..CJK UNIFIED IDEOGRAPH-6234\n6236..6238 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6236..CJK UNIFIED IDEOGRAPH-6238\n623A..6256 ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-623A..CJK UNIFIED IDEOGRAPH-6256\n6258..628C ; Recommended # 1.1 [53] CJK UNIFIED IDEOGRAPH-6258..CJK UNIFIED IDEOGRAPH-628C\n628E..629C ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-628E..CJK UNIFIED IDEOGRAPH-629C\n629E..62DD ; Recommended # 1.1 [64] CJK UNIFIED IDEOGRAPH-629E..CJK UNIFIED IDEOGRAPH-62DD\n62DF..62E9 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-62DF..CJK UNIFIED IDEOGRAPH-62E9\n62EB..6309 ; Recommended # 1.1 [31] CJK UNIFIED IDEOGRAPH-62EB..CJK UNIFIED IDEOGRAPH-6309\n630B..6316 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-630B..CJK UNIFIED IDEOGRAPH-6316\n6318..6330 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-6318..CJK UNIFIED IDEOGRAPH-6330\n6332..6336 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-6332..CJK UNIFIED IDEOGRAPH-6336\n6338..635A ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-6338..CJK UNIFIED IDEOGRAPH-635A\n635C..638A ; Recommended # 1.1 [47] CJK UNIFIED IDEOGRAPH-635C..CJK UNIFIED IDEOGRAPH-638A\n638C..6392 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-638C..CJK UNIFIED IDEOGRAPH-6392\n6394..63D0 ; Recommended # 1.1 [61] CJK UNIFIED IDEOGRAPH-6394..CJK UNIFIED IDEOGRAPH-63D0\n63D2..643A ; Recommended # 1.1 [105] CJK UNIFIED IDEOGRAPH-63D2..CJK UNIFIED IDEOGRAPH-643A\n643D..6448 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-643D..CJK UNIFIED IDEOGRAPH-6448\n644A..6459 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-644A..CJK UNIFIED IDEOGRAPH-6459\n645B..647D ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-645B..CJK UNIFIED IDEOGRAPH-647D\n647F..6485 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-647F..CJK UNIFIED IDEOGRAPH-6485\n6487..64A0 ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-6487..CJK UNIFIED IDEOGRAPH-64A0\n64A2..64AE ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-64A2..CJK UNIFIED IDEOGRAPH-64AE\n64B0..64B5 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-64B0..CJK UNIFIED IDEOGRAPH-64B5\n64B7..64C7 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-64B7..CJK UNIFIED IDEOGRAPH-64C7\n64C9..64D4 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-64C9..CJK UNIFIED IDEOGRAPH-64D4\n64D6..64ED ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-64D6..CJK UNIFIED IDEOGRAPH-64ED\n64EF..64F4 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-64EF..CJK UNIFIED IDEOGRAPH-64F4\n64F6..64F8 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-64F6..CJK UNIFIED IDEOGRAPH-64F8\n64FA..6501 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-64FA..CJK UNIFIED IDEOGRAPH-6501\n6503..6509 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-6503..CJK UNIFIED IDEOGRAPH-6509\n650B..651E ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-650B..CJK UNIFIED IDEOGRAPH-651E\n6520..6527 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-6520..CJK UNIFIED IDEOGRAPH-6527\n6529..653F ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-6529..CJK UNIFIED IDEOGRAPH-653F\n6541 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6541\n6543..6559 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-6543..CJK UNIFIED IDEOGRAPH-6559\n655B..655E ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-655B..CJK UNIFIED IDEOGRAPH-655E\n6560..657C ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-6560..CJK UNIFIED IDEOGRAPH-657C\n657E..6589 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-657E..CJK UNIFIED IDEOGRAPH-6589\n658B..6599 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-658B..CJK UNIFIED IDEOGRAPH-6599\n659B..65B4 ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-659B..CJK UNIFIED IDEOGRAPH-65B4\n65B6..65BD ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-65B6..CJK UNIFIED IDEOGRAPH-65BD\n65BF..65C7 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-65BF..CJK UNIFIED IDEOGRAPH-65C7\n65CA..65D0 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-65CA..CJK UNIFIED IDEOGRAPH-65D0\n65D2..65D7 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-65D2..CJK UNIFIED IDEOGRAPH-65D7\n65D9..65DB ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-65D9..CJK UNIFIED IDEOGRAPH-65DB\n65DD..65E3 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-65DD..CJK UNIFIED IDEOGRAPH-65E3\n65E5..65E9 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-65E5..CJK UNIFIED IDEOGRAPH-65E9\n65EB..65F8 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-65EB..CJK UNIFIED IDEOGRAPH-65F8\n65FA..65FD ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-65FA..CJK UNIFIED IDEOGRAPH-65FD\n65FF..6616 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-65FF..CJK UNIFIED IDEOGRAPH-6616\n6618..662B ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-6618..CJK UNIFIED IDEOGRAPH-662B\n662D..6636 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-662D..CJK UNIFIED IDEOGRAPH-6636\n6639..6647 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-6639..CJK UNIFIED IDEOGRAPH-6647\n6649..664C ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6649..CJK UNIFIED IDEOGRAPH-664C\n664E..665F ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-664E..CJK UNIFIED IDEOGRAPH-665F\n6661..6662 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-6661..CJK UNIFIED IDEOGRAPH-6662\n6664..6691 ; Recommended # 1.1 [46] CJK UNIFIED IDEOGRAPH-6664..CJK UNIFIED IDEOGRAPH-6691\n6693..669B ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-6693..CJK UNIFIED IDEOGRAPH-669B\n669D ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-669D\n669F..66AB ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-669F..CJK UNIFIED IDEOGRAPH-66AB\n66AE..66CF ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-66AE..CJK UNIFIED IDEOGRAPH-66CF\n66D1..66D2 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-66D1..CJK UNIFIED IDEOGRAPH-66D2\n66D4..66D6 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-66D4..CJK UNIFIED IDEOGRAPH-66D6\n66D8..66DE ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-66D8..CJK UNIFIED IDEOGRAPH-66DE\n66E0..66EE ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-66E0..CJK UNIFIED IDEOGRAPH-66EE\n66F0..6701 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-66F0..CJK UNIFIED IDEOGRAPH-6701\n6703..6706 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6703..CJK UNIFIED IDEOGRAPH-6706\n6708..6718 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-6708..CJK UNIFIED IDEOGRAPH-6718\n671A..6723 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-671A..CJK UNIFIED IDEOGRAPH-6723\n6725..6728 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6725..CJK UNIFIED IDEOGRAPH-6728\n672A..6766 ; Recommended # 1.1 [61] CJK UNIFIED IDEOGRAPH-672A..CJK UNIFIED IDEOGRAPH-6766\n6768..6787 ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-6768..CJK UNIFIED IDEOGRAPH-6787\n6789..6795 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-6789..CJK UNIFIED IDEOGRAPH-6795\n6797..67BC ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-6797..CJK UNIFIED IDEOGRAPH-67BC\n67BE ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-67BE\n67C0..67D4 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-67C0..CJK UNIFIED IDEOGRAPH-67D4\n67D6 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-67D6\n67D8..67F8 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-67D8..CJK UNIFIED IDEOGRAPH-67F8\n67FA..6800 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-67FA..CJK UNIFIED IDEOGRAPH-6800\n6802..6814 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-6802..CJK UNIFIED IDEOGRAPH-6814\n6816..6826 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-6816..CJK UNIFIED IDEOGRAPH-6826\n6828..682F ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-6828..CJK UNIFIED IDEOGRAPH-682F\n6831..6857 ; Recommended # 1.1 [39] CJK UNIFIED IDEOGRAPH-6831..CJK UNIFIED IDEOGRAPH-6857\n6859 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6859\n685B..685D ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-685B..CJK UNIFIED IDEOGRAPH-685D\n685F..6879 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-685F..CJK UNIFIED IDEOGRAPH-6879\n687B..6894 ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-687B..CJK UNIFIED IDEOGRAPH-6894\n6896..6898 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6896..CJK UNIFIED IDEOGRAPH-6898\n689A..68A4 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-689A..CJK UNIFIED IDEOGRAPH-68A4\n68A6..68B7 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-68A6..CJK UNIFIED IDEOGRAPH-68B7\n68B9..68C2 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-68B9..CJK UNIFIED IDEOGRAPH-68C2\n68C4..68D8 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-68C4..CJK UNIFIED IDEOGRAPH-68D8\n68DA..68E1 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-68DA..CJK UNIFIED IDEOGRAPH-68E1\n68E3..68E4 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-68E3..CJK UNIFIED IDEOGRAPH-68E4\n68E6..6908 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-68E6..CJK UNIFIED IDEOGRAPH-6908\n690A..693D ; Recommended # 1.1 [52] CJK UNIFIED IDEOGRAPH-690A..CJK UNIFIED IDEOGRAPH-693D\n693F..694C ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-693F..CJK UNIFIED IDEOGRAPH-694C\n694E..699E ; Recommended # 1.1 [81] CJK UNIFIED IDEOGRAPH-694E..CJK UNIFIED IDEOGRAPH-699E\n69A0..69A1 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-69A0..CJK UNIFIED IDEOGRAPH-69A1\n69A3..69BF ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-69A3..CJK UNIFIED IDEOGRAPH-69BF\n69C1..69D0 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-69C1..CJK UNIFIED IDEOGRAPH-69D0\n69D3..69D4 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-69D3..CJK UNIFIED IDEOGRAPH-69D4\n69D8..6A02 ; Recommended # 1.1 [43] CJK UNIFIED IDEOGRAPH-69D8..CJK UNIFIED IDEOGRAPH-6A02\n6A04..6A1B ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-6A04..CJK UNIFIED IDEOGRAPH-6A1B\n6A1D..6A23 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-6A1D..CJK UNIFIED IDEOGRAPH-6A23\n6A25..6A36 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-6A25..CJK UNIFIED IDEOGRAPH-6A36\n6A38..6A49 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-6A38..CJK UNIFIED IDEOGRAPH-6A49\n6A4B..6A5B ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-6A4B..CJK UNIFIED IDEOGRAPH-6A5B\n6A5D..6A6D ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-6A5D..CJK UNIFIED IDEOGRAPH-6A6D\n6A6F ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6A6F\n6A71..6A85 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-6A71..CJK UNIFIED IDEOGRAPH-6A85\n6A87..6A89 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6A87..CJK UNIFIED IDEOGRAPH-6A89\n6A8B..6A8E ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6A8B..CJK UNIFIED IDEOGRAPH-6A8E\n6A90..6A98 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-6A90..CJK UNIFIED IDEOGRAPH-6A98\n6A9A..6A9C ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6A9A..CJK UNIFIED IDEOGRAPH-6A9C\n6A9E..6AB0 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-6A9E..CJK UNIFIED IDEOGRAPH-6AB0\n6AB2..6ABD ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-6AB2..CJK UNIFIED IDEOGRAPH-6ABD\n6ABF ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6ABF\n6AC1..6AC3 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6AC1..CJK UNIFIED IDEOGRAPH-6AC3\n6AC5..6AC8 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6AC5..CJK UNIFIED IDEOGRAPH-6AC8\n6ACA..6AD7 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-6ACA..CJK UNIFIED IDEOGRAPH-6AD7\n6AD9..6AE8 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-6AD9..CJK UNIFIED IDEOGRAPH-6AE8\n6AEA..6B0D ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-6AEA..CJK UNIFIED IDEOGRAPH-6B0D\n6B0F..6B1A ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-6B0F..CJK UNIFIED IDEOGRAPH-6B1A\n6B1C..6B2D ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-6B1C..CJK UNIFIED IDEOGRAPH-6B2D\n6B2F..6B34 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-6B2F..CJK UNIFIED IDEOGRAPH-6B34\n6B36..6B3F ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-6B36..CJK UNIFIED IDEOGRAPH-6B3F\n6B41..6B56 ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-6B41..CJK UNIFIED IDEOGRAPH-6B56\n6B59..6B5C ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6B59..CJK UNIFIED IDEOGRAPH-6B5C\n6B5E..6B67 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-6B5E..CJK UNIFIED IDEOGRAPH-6B67\n6B69..6B6B ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6B69..CJK UNIFIED IDEOGRAPH-6B6B\n6B6D ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6B6D\n6B6F..6B70 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-6B6F..CJK UNIFIED IDEOGRAPH-6B70\n6B72..6B74 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6B72..CJK UNIFIED IDEOGRAPH-6B74\n6B76..6B7C ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-6B76..CJK UNIFIED IDEOGRAPH-6B7C\n6B7E..6BB7 ; Recommended # 1.1 [58] CJK UNIFIED IDEOGRAPH-6B7E..CJK UNIFIED IDEOGRAPH-6BB7\n6BB9..6BE8 ; Recommended # 1.1 [48] CJK UNIFIED IDEOGRAPH-6BB9..CJK UNIFIED IDEOGRAPH-6BE8\n6BEA..6BF0 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-6BEA..CJK UNIFIED IDEOGRAPH-6BF0\n6BF2..6BF3 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-6BF2..CJK UNIFIED IDEOGRAPH-6BF3\n6BF5..6BF9 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-6BF5..CJK UNIFIED IDEOGRAPH-6BF9\n6BFB..6C09 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-6BFB..CJK UNIFIED IDEOGRAPH-6C09\n6C0B..6C1B ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-6C0B..CJK UNIFIED IDEOGRAPH-6C1B\n6C1D..6C2C ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-6C1D..CJK UNIFIED IDEOGRAPH-6C2C\n6C2E..6C3B ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-6C2E..CJK UNIFIED IDEOGRAPH-6C3B\n6C3D..6C44 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-6C3D..CJK UNIFIED IDEOGRAPH-6C44\n6C46..6C6B ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-6C46..CJK UNIFIED IDEOGRAPH-6C6B\n6C6D ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6C6D\n6C6F..6C9F ; Recommended # 1.1 [49] CJK UNIFIED IDEOGRAPH-6C6F..CJK UNIFIED IDEOGRAPH-6C9F\n6CA1..6CD7 ; Recommended # 1.1 [55] CJK UNIFIED IDEOGRAPH-6CA1..CJK UNIFIED IDEOGRAPH-6CD7\n6CD9..6CF3 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-6CD9..CJK UNIFIED IDEOGRAPH-6CF3\n6CF5..6D01 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-6CF5..CJK UNIFIED IDEOGRAPH-6D01\n6D03..6D1B ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-6D03..CJK UNIFIED IDEOGRAPH-6D1B\n6D1D..6D23 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-6D1D..CJK UNIFIED IDEOGRAPH-6D23\n6D25..6D70 ; Recommended # 1.1 [76] CJK UNIFIED IDEOGRAPH-6D25..CJK UNIFIED IDEOGRAPH-6D70\n6D72..6D80 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-6D72..CJK UNIFIED IDEOGRAPH-6D80\n6D82..6D95 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-6D82..CJK UNIFIED IDEOGRAPH-6D95\n6D97..6DAF ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-6D97..CJK UNIFIED IDEOGRAPH-6DAF\n6DB2..6DB5 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6DB2..CJK UNIFIED IDEOGRAPH-6DB5\n6DB7..6DFD ; Recommended # 1.1 [71] CJK UNIFIED IDEOGRAPH-6DB7..CJK UNIFIED IDEOGRAPH-6DFD\n6E00 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6E00\n6E03..6E05 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-6E03..CJK UNIFIED IDEOGRAPH-6E05\n6E07..6E11 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-6E07..CJK UNIFIED IDEOGRAPH-6E11\n6E13..6E17 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-6E13..CJK UNIFIED IDEOGRAPH-6E17\n6E19..6E29 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-6E19..CJK UNIFIED IDEOGRAPH-6E29\n6E2B..6E4B ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-6E2B..CJK UNIFIED IDEOGRAPH-6E4B\n6E4D..6E6B ; Recommended # 1.1 [31] CJK UNIFIED IDEOGRAPH-6E4D..CJK UNIFIED IDEOGRAPH-6E6B\n6E6D..6E7A ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-6E6D..CJK UNIFIED IDEOGRAPH-6E7A\n6E7E..6E8A ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-6E7E..CJK UNIFIED IDEOGRAPH-6E8A\n6E8C..6E94 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-6E8C..CJK UNIFIED IDEOGRAPH-6E94\n6E96..6EDA ; Recommended # 1.1 [69] CJK UNIFIED IDEOGRAPH-6E96..CJK UNIFIED IDEOGRAPH-6EDA\n6EDC..6EE2 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-6EDC..CJK UNIFIED IDEOGRAPH-6EE2\n6EE4..6F03 ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-6EE4..CJK UNIFIED IDEOGRAPH-6F03\n6F05..6F0A ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-6F05..CJK UNIFIED IDEOGRAPH-6F0A\n6F0C..6F41 ; Recommended # 1.1 [54] CJK UNIFIED IDEOGRAPH-6F0C..CJK UNIFIED IDEOGRAPH-6F41\n6F43..6F47 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-6F43..CJK UNIFIED IDEOGRAPH-6F47\n6F49 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6F49\n6F4B..6F78 ; Recommended # 1.1 [46] CJK UNIFIED IDEOGRAPH-6F4B..CJK UNIFIED IDEOGRAPH-6F78\n6F7A..6F97 ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-6F7A..CJK UNIFIED IDEOGRAPH-6F97\n6F99 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-6F99\n6F9B..6F9E ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-6F9B..CJK UNIFIED IDEOGRAPH-6F9E\n6FA0..6FB6 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-6FA0..CJK UNIFIED IDEOGRAPH-6FB6\n6FB8..6FC4 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-6FB8..CJK UNIFIED IDEOGRAPH-6FC4\n6FC6..6FCF ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-6FC6..CJK UNIFIED IDEOGRAPH-6FCF\n6FD1..6FD2 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-6FD1..CJK UNIFIED IDEOGRAPH-6FD2\n6FD4..6FF4 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-6FD4..CJK UNIFIED IDEOGRAPH-6FF4\n6FF6..6FFC ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-6FF6..CJK UNIFIED IDEOGRAPH-6FFC\n6FFE..700F ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-6FFE..CJK UNIFIED IDEOGRAPH-700F\n7011..7012 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-7011..CJK UNIFIED IDEOGRAPH-7012\n7014..7046 ; Recommended # 1.1 [51] CJK UNIFIED IDEOGRAPH-7014..CJK UNIFIED IDEOGRAPH-7046\n7048..704A ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7048..CJK UNIFIED IDEOGRAPH-704A\n704C..704D ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-704C..CJK UNIFIED IDEOGRAPH-704D\n704F..7071 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-704F..CJK UNIFIED IDEOGRAPH-7071\n7074..707A ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-7074..CJK UNIFIED IDEOGRAPH-707A\n707C..7080 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-707C..CJK UNIFIED IDEOGRAPH-7080\n7082..708C ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7082..CJK UNIFIED IDEOGRAPH-708C\n708E..7096 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-708E..CJK UNIFIED IDEOGRAPH-7096\n7098..709A ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7098..CJK UNIFIED IDEOGRAPH-709A\n709C..70A9 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-709C..CJK UNIFIED IDEOGRAPH-70A9\n70AB..70B1 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-70AB..CJK UNIFIED IDEOGRAPH-70B1\n70B3..70B5 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-70B3..CJK UNIFIED IDEOGRAPH-70B5\n70B7..70D4 ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-70B7..CJK UNIFIED IDEOGRAPH-70D4\n70D6..70FD ; Recommended # 1.1 [40] CJK UNIFIED IDEOGRAPH-70D6..CJK UNIFIED IDEOGRAPH-70FD\n70FF..7107 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-70FF..CJK UNIFIED IDEOGRAPH-7107\n7109..7123 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-7109..CJK UNIFIED IDEOGRAPH-7123\n7125..7132 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-7125..CJK UNIFIED IDEOGRAPH-7132\n7135..7156 ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-7135..CJK UNIFIED IDEOGRAPH-7156\n7158..716A ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-7158..CJK UNIFIED IDEOGRAPH-716A\n716C ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-716C\n716E..718C ; Recommended # 1.1 [31] CJK UNIFIED IDEOGRAPH-716E..CJK UNIFIED IDEOGRAPH-718C\n718E..7195 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-718E..CJK UNIFIED IDEOGRAPH-7195\n7197..71A5 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-7197..CJK UNIFIED IDEOGRAPH-71A5\n71A7..71AA ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-71A7..CJK UNIFIED IDEOGRAPH-71AA\n71AC..71B5 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-71AC..CJK UNIFIED IDEOGRAPH-71B5\n71B7..71CB ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-71B7..CJK UNIFIED IDEOGRAPH-71CB\n71CD..71D2 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-71CD..CJK UNIFIED IDEOGRAPH-71D2\n71D4..71F2 ; Recommended # 1.1 [31] CJK UNIFIED IDEOGRAPH-71D4..CJK UNIFIED IDEOGRAPH-71F2\n71F4..71F9 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-71F4..CJK UNIFIED IDEOGRAPH-71F9\n71FB..720A ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-71FB..CJK UNIFIED IDEOGRAPH-720A\n720C..7210 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-720C..CJK UNIFIED IDEOGRAPH-7210\n7212..7214 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7212..CJK UNIFIED IDEOGRAPH-7214\n7216 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7216\n7218..721F ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-7218..CJK UNIFIED IDEOGRAPH-721F\n7221..7223 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7221..CJK UNIFIED IDEOGRAPH-7223\n7226..722E ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-7226..CJK UNIFIED IDEOGRAPH-722E\n7230..7233 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7230..CJK UNIFIED IDEOGRAPH-7233\n7235..7244 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-7235..CJK UNIFIED IDEOGRAPH-7244\n7246..724D ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-7246..CJK UNIFIED IDEOGRAPH-724D\n724F ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-724F\n7251..7254 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7251..CJK UNIFIED IDEOGRAPH-7254\n7256..72AA ; Recommended # 1.1 [85] CJK UNIFIED IDEOGRAPH-7256..CJK UNIFIED IDEOGRAPH-72AA\n72AC..72BD ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-72AC..CJK UNIFIED IDEOGRAPH-72BD\n72BF..7301 ; Recommended # 1.1 [67] CJK UNIFIED IDEOGRAPH-72BF..CJK UNIFIED IDEOGRAPH-7301\n7303..730F ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-7303..CJK UNIFIED IDEOGRAPH-730F\n7311..7327 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-7311..CJK UNIFIED IDEOGRAPH-7327\n7329..7352 ; Recommended # 1.1 [42] CJK UNIFIED IDEOGRAPH-7329..CJK UNIFIED IDEOGRAPH-7352\n7354..739B ; Recommended # 1.1 [72] CJK UNIFIED IDEOGRAPH-7354..CJK UNIFIED IDEOGRAPH-739B\n739D..73C0 ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-739D..CJK UNIFIED IDEOGRAPH-73C0\n73C2..73F2 ; Recommended # 1.1 [49] CJK UNIFIED IDEOGRAPH-73C2..CJK UNIFIED IDEOGRAPH-73F2\n73F4..73FA ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-73F4..CJK UNIFIED IDEOGRAPH-73FA\n73FC..7417 ; Recommended # 1.1 [28] CJK UNIFIED IDEOGRAPH-73FC..CJK UNIFIED IDEOGRAPH-7417\n7419..7438 ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-7419..CJK UNIFIED IDEOGRAPH-7438\n743A..743D ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-743A..CJK UNIFIED IDEOGRAPH-743D\n743F..7446 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-743F..CJK UNIFIED IDEOGRAPH-7446\n7448 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7448\n744A..7457 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-744A..CJK UNIFIED IDEOGRAPH-7457\n7459..747A ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-7459..CJK UNIFIED IDEOGRAPH-747A\n747C..7483 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-747C..CJK UNIFIED IDEOGRAPH-7483\n7485..7495 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-7485..CJK UNIFIED IDEOGRAPH-7495\n7497..749C ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7497..CJK UNIFIED IDEOGRAPH-749C\n749E..74C6 ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-749E..CJK UNIFIED IDEOGRAPH-74C6\n74C8 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-74C8\n74CA..74CB ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-74CA..CJK UNIFIED IDEOGRAPH-74CB\n74CD..74EA ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-74CD..CJK UNIFIED IDEOGRAPH-74EA\n74EC..751F ; Recommended # 1.1 [52] CJK UNIFIED IDEOGRAPH-74EC..CJK UNIFIED IDEOGRAPH-751F\n7521..7540 ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-7521..CJK UNIFIED IDEOGRAPH-7540\n7542..7551 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-7542..CJK UNIFIED IDEOGRAPH-7551\n7553..7554 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-7553..CJK UNIFIED IDEOGRAPH-7554\n7556..755D ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-7556..CJK UNIFIED IDEOGRAPH-755D\n755F..7560 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-755F..CJK UNIFIED IDEOGRAPH-7560\n7562..7570 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-7562..CJK UNIFIED IDEOGRAPH-7570\n7572..757A ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-7572..CJK UNIFIED IDEOGRAPH-757A\n757C..7584 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-757C..CJK UNIFIED IDEOGRAPH-7584\n7586..75A8 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-7586..CJK UNIFIED IDEOGRAPH-75A8\n75AA..75B6 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-75AA..CJK UNIFIED IDEOGRAPH-75B6\n75B8..75DB ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-75B8..CJK UNIFIED IDEOGRAPH-75DB\n75DD..75ED ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-75DD..CJK UNIFIED IDEOGRAPH-75ED\n75EF..762B ; Recommended # 1.1 [61] CJK UNIFIED IDEOGRAPH-75EF..CJK UNIFIED IDEOGRAPH-762B\n762D..7643 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-762D..CJK UNIFIED IDEOGRAPH-7643\n7646..7650 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7646..CJK UNIFIED IDEOGRAPH-7650\n7652..7654 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7652..CJK UNIFIED IDEOGRAPH-7654\n7656..7672 ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-7656..CJK UNIFIED IDEOGRAPH-7672\n7674..768C ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-7674..CJK UNIFIED IDEOGRAPH-768C\n768E..76A0 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-768E..CJK UNIFIED IDEOGRAPH-76A0\n76A3..76A4 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-76A3..CJK UNIFIED IDEOGRAPH-76A4\n76A6..76A7 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-76A6..CJK UNIFIED IDEOGRAPH-76A7\n76A9..76B2 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-76A9..CJK UNIFIED IDEOGRAPH-76B2\n76B4..76B5 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-76B4..CJK UNIFIED IDEOGRAPH-76B5\n76B7..76C0 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-76B7..CJK UNIFIED IDEOGRAPH-76C0\n76C2..76CA ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-76C2..CJK UNIFIED IDEOGRAPH-76CA\n76CC..76D8 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-76CC..CJK UNIFIED IDEOGRAPH-76D8\n76DA..76EA ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-76DA..CJK UNIFIED IDEOGRAPH-76EA\n76EC..76FF ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-76EC..CJK UNIFIED IDEOGRAPH-76FF\n7701 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7701\n7703..770D ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7703..CJK UNIFIED IDEOGRAPH-770D\n770F..7720 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-770F..CJK UNIFIED IDEOGRAPH-7720\n7722..772A ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-7722..CJK UNIFIED IDEOGRAPH-772A\n772C..773E ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-772C..CJK UNIFIED IDEOGRAPH-773E\n7740..7741 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-7740..CJK UNIFIED IDEOGRAPH-7741\n7743..7763 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-7743..CJK UNIFIED IDEOGRAPH-7763\n7765..7795 ; Recommended # 1.1 [49] CJK UNIFIED IDEOGRAPH-7765..CJK UNIFIED IDEOGRAPH-7795\n7797..77A3 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-7797..CJK UNIFIED IDEOGRAPH-77A3\n77A5..77BD ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-77A5..CJK UNIFIED IDEOGRAPH-77BD\n77BF..77C0 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-77BF..CJK UNIFIED IDEOGRAPH-77C0\n77C2..77D1 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-77C2..CJK UNIFIED IDEOGRAPH-77D1\n77D3..77DC ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-77D3..CJK UNIFIED IDEOGRAPH-77DC\n77DE..77E3 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-77DE..CJK UNIFIED IDEOGRAPH-77E3\n77E5 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-77E5\n77E7..77F3 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-77E7..CJK UNIFIED IDEOGRAPH-77F3\n77F6..7823 ; Recommended # 1.1 [46] CJK UNIFIED IDEOGRAPH-77F6..CJK UNIFIED IDEOGRAPH-7823\n7825..7835 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-7825..CJK UNIFIED IDEOGRAPH-7835\n7837..7841 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7837..CJK UNIFIED IDEOGRAPH-7841\n7843..7845 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7843..CJK UNIFIED IDEOGRAPH-7845\n7847..784A ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7847..CJK UNIFIED IDEOGRAPH-784A\n784C..7875 ; Recommended # 1.1 [42] CJK UNIFIED IDEOGRAPH-784C..CJK UNIFIED IDEOGRAPH-7875\n7877..7887 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-7877..CJK UNIFIED IDEOGRAPH-7887\n7889..78C1 ; Recommended # 1.1 [57] CJK UNIFIED IDEOGRAPH-7889..CJK UNIFIED IDEOGRAPH-78C1\n78C3..78C6 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-78C3..CJK UNIFIED IDEOGRAPH-78C6\n78C8..78D1 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-78C8..CJK UNIFIED IDEOGRAPH-78D1\n78D3..78EF ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-78D3..CJK UNIFIED IDEOGRAPH-78EF\n78F1..78F7 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-78F1..CJK UNIFIED IDEOGRAPH-78F7\n78F9..78FF ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-78F9..CJK UNIFIED IDEOGRAPH-78FF\n7901..7907 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-7901..CJK UNIFIED IDEOGRAPH-7907\n7909..790C ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7909..CJK UNIFIED IDEOGRAPH-790C\n790E..7914 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-790E..CJK UNIFIED IDEOGRAPH-7914\n7916..791E ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-7916..CJK UNIFIED IDEOGRAPH-791E\n7921..7931 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-7921..CJK UNIFIED IDEOGRAPH-7931\n7933..7935 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7933..CJK UNIFIED IDEOGRAPH-7935\n7937..7958 ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-7937..CJK UNIFIED IDEOGRAPH-7958\n795A..796B ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-795A..CJK UNIFIED IDEOGRAPH-796B\n796D ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-796D\n796F..7974 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-796F..CJK UNIFIED IDEOGRAPH-7974\n7977..7985 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-7977..CJK UNIFIED IDEOGRAPH-7985\n7988..799D ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-7988..CJK UNIFIED IDEOGRAPH-799D\n799F..79A8 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-799F..CJK UNIFIED IDEOGRAPH-79A8\n79AA..79BB ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-79AA..CJK UNIFIED IDEOGRAPH-79BB\n79BD..79C3 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-79BD..CJK UNIFIED IDEOGRAPH-79C3\n79C5..79C6 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-79C5..CJK UNIFIED IDEOGRAPH-79C6\n79C8..79CB ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-79C8..CJK UNIFIED IDEOGRAPH-79CB\n79CD..79D3 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-79CD..CJK UNIFIED IDEOGRAPH-79D3\n79D5..79D6 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-79D5..CJK UNIFIED IDEOGRAPH-79D6\n79D8..7A00 ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-79D8..CJK UNIFIED IDEOGRAPH-7A00\n7A02..7A06 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-7A02..CJK UNIFIED IDEOGRAPH-7A06\n7A08 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7A08\n7A0A..7A2B ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-7A0A..CJK UNIFIED IDEOGRAPH-7A2B\n7A2D..7A37 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7A2D..CJK UNIFIED IDEOGRAPH-7A37\n7A39 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7A39\n7A3B..7A63 ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-7A3B..CJK UNIFIED IDEOGRAPH-7A63\n7A65..7A69 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-7A65..CJK UNIFIED IDEOGRAPH-7A69\n7A6B..7A6E ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7A6B..CJK UNIFIED IDEOGRAPH-7A6E\n7A70..7A81 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-7A70..CJK UNIFIED IDEOGRAPH-7A81\n7A83..7A99 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-7A83..CJK UNIFIED IDEOGRAPH-7A99\n7A9C..7AB8 ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-7A9C..CJK UNIFIED IDEOGRAPH-7AB8\n7ABA ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7ABA\n7ABE..7AC1 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7ABE..CJK UNIFIED IDEOGRAPH-7AC1\n7AC3..7AC5 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7AC3..CJK UNIFIED IDEOGRAPH-7AC5\n7AC7..7AE8 ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-7AC7..CJK UNIFIED IDEOGRAPH-7AE8\n7AEA..7AF4 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7AEA..CJK UNIFIED IDEOGRAPH-7AF4\n7AF6..7AFB ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7AF6..CJK UNIFIED IDEOGRAPH-7AFB\n7AFD..7B06 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-7AFD..CJK UNIFIED IDEOGRAPH-7B06\n7B08..7B1E ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-7B08..CJK UNIFIED IDEOGRAPH-7B1E\n7B20..7B26 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-7B20..CJK UNIFIED IDEOGRAPH-7B26\n7B28 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7B28\n7B2A..7B41 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-7B2A..CJK UNIFIED IDEOGRAPH-7B41\n7B43..7B52 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-7B43..CJK UNIFIED IDEOGRAPH-7B52\n7B54..7BA2 ; Recommended # 1.1 [79] CJK UNIFIED IDEOGRAPH-7B54..CJK UNIFIED IDEOGRAPH-7BA2\n7BA4 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7BA4\n7BA6..7BAF ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-7BA6..CJK UNIFIED IDEOGRAPH-7BAF\n7BB1 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7BB1\n7BB3..7BF9 ; Recommended # 1.1 [71] CJK UNIFIED IDEOGRAPH-7BB3..CJK UNIFIED IDEOGRAPH-7BF9\n7BFB..7C1A ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-7BFB..CJK UNIFIED IDEOGRAPH-7C1A\n7C1C..7C2D ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-7C1C..CJK UNIFIED IDEOGRAPH-7C2D\n7C30..7C51 ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-7C30..CJK UNIFIED IDEOGRAPH-7C51\n7C53..7C54 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-7C53..CJK UNIFIED IDEOGRAPH-7C54\n7C56..7C5C ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-7C56..CJK UNIFIED IDEOGRAPH-7C5C\n7C5E..7C75 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-7C5E..CJK UNIFIED IDEOGRAPH-7C75\n7C77..7C86 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-7C77..CJK UNIFIED IDEOGRAPH-7C86\n7C88..7C92 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7C88..CJK UNIFIED IDEOGRAPH-7C92\n7C94..7C99 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7C94..CJK UNIFIED IDEOGRAPH-7C99\n7C9B..7CAB ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-7C9B..CJK UNIFIED IDEOGRAPH-7CAB\n7CAD..7CD2 ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-7CAD..CJK UNIFIED IDEOGRAPH-7CD2\n7CD4..7CD9 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7CD4..CJK UNIFIED IDEOGRAPH-7CD9\n7CDC..7CE0 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-7CDC..CJK UNIFIED IDEOGRAPH-7CE0\n7CE2 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7CE2\n7CE4 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7CE4\n7CE7..7CFB ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-7CE7..CJK UNIFIED IDEOGRAPH-7CFB\n7CFD..7CFE ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-7CFD..CJK UNIFIED IDEOGRAPH-7CFE\n7D00..7D22 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-7D00..CJK UNIFIED IDEOGRAPH-7D22\n7D24..7D29 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7D24..CJK UNIFIED IDEOGRAPH-7D29\n7D2B..7D2C ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-7D2B..CJK UNIFIED IDEOGRAPH-7D2C\n7D2E..7D47 ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-7D2E..CJK UNIFIED IDEOGRAPH-7D47\n7D49..7D4C ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7D49..CJK UNIFIED IDEOGRAPH-7D4C\n7D4E..7D59 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-7D4E..CJK UNIFIED IDEOGRAPH-7D59\n7D5B..7D63 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-7D5B..CJK UNIFIED IDEOGRAPH-7D63\n7D65..7D77 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-7D65..CJK UNIFIED IDEOGRAPH-7D77\n7D79..7D81 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-7D79..CJK UNIFIED IDEOGRAPH-7D81\n7D83..7D94 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-7D83..CJK UNIFIED IDEOGRAPH-7D94\n7D96..7D97 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-7D96..CJK UNIFIED IDEOGRAPH-7D97\n7D99..7DA3 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7D99..CJK UNIFIED IDEOGRAPH-7DA3\n7DA5..7DA7 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-7DA5..CJK UNIFIED IDEOGRAPH-7DA7\n7DA9..7DCC ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-7DA9..CJK UNIFIED IDEOGRAPH-7DCC\n7DCE..7DD2 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-7DCE..CJK UNIFIED IDEOGRAPH-7DD2\n7DD4..7DE4 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-7DD4..CJK UNIFIED IDEOGRAPH-7DE4\n7DE6..7DEA ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-7DE6..CJK UNIFIED IDEOGRAPH-7DEA\n7DEC..7DFC ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-7DEC..CJK UNIFIED IDEOGRAPH-7DFC\n7E00..7E17 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-7E00..CJK UNIFIED IDEOGRAPH-7E17\n7E19..7E5A ; Recommended # 1.1 [66] CJK UNIFIED IDEOGRAPH-7E19..CJK UNIFIED IDEOGRAPH-7E5A\n7E5C..7E63 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-7E5C..CJK UNIFIED IDEOGRAPH-7E63\n7E65..7E9C ; Recommended # 1.1 [56] CJK UNIFIED IDEOGRAPH-7E65..CJK UNIFIED IDEOGRAPH-7E9C\n7E9E..7F3A ; Recommended # 1.1 [157] CJK UNIFIED IDEOGRAPH-7E9E..CJK UNIFIED IDEOGRAPH-7F3A\n7F3D..7F40 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7F3D..CJK UNIFIED IDEOGRAPH-7F40\n7F42..7F45 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-7F42..CJK UNIFIED IDEOGRAPH-7F45\n7F47..7F58 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-7F47..CJK UNIFIED IDEOGRAPH-7F58\n7F5A..7F83 ; Recommended # 1.1 [42] CJK UNIFIED IDEOGRAPH-7F5A..CJK UNIFIED IDEOGRAPH-7F83\n7F85..7F8F ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-7F85..CJK UNIFIED IDEOGRAPH-7F8F\n7F91..7F96 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7F91..CJK UNIFIED IDEOGRAPH-7F96\n7F98 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-7F98\n7F9A..7FB3 ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-7F9A..CJK UNIFIED IDEOGRAPH-7FB3\n7FB5..7FD5 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-7FB5..CJK UNIFIED IDEOGRAPH-7FD5\n7FD7..7FDC ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7FD7..CJK UNIFIED IDEOGRAPH-7FDC\n7FDE..7FE3 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-7FDE..CJK UNIFIED IDEOGRAPH-7FE3\n7FE5..8009 ; Recommended # 1.1 [37] CJK UNIFIED IDEOGRAPH-7FE5..CJK UNIFIED IDEOGRAPH-8009\n800B..802E ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-800B..CJK UNIFIED IDEOGRAPH-802E\n8030..803B ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-8030..CJK UNIFIED IDEOGRAPH-803B\n803D..803F ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-803D..CJK UNIFIED IDEOGRAPH-803F\n8041..8065 ; Recommended # 1.1 [37] CJK UNIFIED IDEOGRAPH-8041..CJK UNIFIED IDEOGRAPH-8065\n8067..8087 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-8067..CJK UNIFIED IDEOGRAPH-8087\n8089..808D ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-8089..CJK UNIFIED IDEOGRAPH-808D\n808F..8093 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-808F..CJK UNIFIED IDEOGRAPH-8093\n8095..80A5 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-8095..CJK UNIFIED IDEOGRAPH-80A5\n80A9..80B2 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-80A9..CJK UNIFIED IDEOGRAPH-80B2\n80B4..80B8 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-80B4..CJK UNIFIED IDEOGRAPH-80B8\n80BA..80DE ; Recommended # 1.1 [37] CJK UNIFIED IDEOGRAPH-80BA..CJK UNIFIED IDEOGRAPH-80DE\n80E0..8102 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-80E0..CJK UNIFIED IDEOGRAPH-8102\n8105..8133 ; Recommended # 1.1 [47] CJK UNIFIED IDEOGRAPH-8105..CJK UNIFIED IDEOGRAPH-8133\n8136..8183 ; Recommended # 1.1 [78] CJK UNIFIED IDEOGRAPH-8136..CJK UNIFIED IDEOGRAPH-8183\n8185..818F ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-8185..CJK UNIFIED IDEOGRAPH-818F\n8191..8195 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-8191..CJK UNIFIED IDEOGRAPH-8195\n8197..81CA ; Recommended # 1.1 [52] CJK UNIFIED IDEOGRAPH-8197..CJK UNIFIED IDEOGRAPH-81CA\n81CC..81E3 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-81CC..CJK UNIFIED IDEOGRAPH-81E3\n81E5..81EE ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-81E5..CJK UNIFIED IDEOGRAPH-81EE\n81F1..8212 ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-81F1..CJK UNIFIED IDEOGRAPH-8212\n8214..8223 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-8214..CJK UNIFIED IDEOGRAPH-8223\n8225..8240 ; Recommended # 1.1 [28] CJK UNIFIED IDEOGRAPH-8225..CJK UNIFIED IDEOGRAPH-8240\n8242..8264 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-8242..CJK UNIFIED IDEOGRAPH-8264\n8266..828B ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-8266..CJK UNIFIED IDEOGRAPH-828B\n828D..82B1 ; Recommended # 1.1 [37] CJK UNIFIED IDEOGRAPH-828D..CJK UNIFIED IDEOGRAPH-82B1\n82B3..82E1 ; Recommended # 1.1 [47] CJK UNIFIED IDEOGRAPH-82B3..CJK UNIFIED IDEOGRAPH-82E1\n82E3..82FB ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-82E3..CJK UNIFIED IDEOGRAPH-82FB\n82FD..8309 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-82FD..CJK UNIFIED IDEOGRAPH-8309\n830B..830F ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-830B..CJK UNIFIED IDEOGRAPH-830F\n8311..832F ; Recommended # 1.1 [31] CJK UNIFIED IDEOGRAPH-8311..CJK UNIFIED IDEOGRAPH-832F\n8331..8354 ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-8331..CJK UNIFIED IDEOGRAPH-8354\n8356..83BD ; Recommended # 1.1 [104] CJK UNIFIED IDEOGRAPH-8356..CJK UNIFIED IDEOGRAPH-83BD\n83BF..83E5 ; Recommended # 1.1 [39] CJK UNIFIED IDEOGRAPH-83BF..CJK UNIFIED IDEOGRAPH-83E5\n83E7..83EC ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-83E7..CJK UNIFIED IDEOGRAPH-83EC\n83EE..8413 ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-83EE..CJK UNIFIED IDEOGRAPH-8413\n8415 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-8415\n8418..841E ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-8418..CJK UNIFIED IDEOGRAPH-841E\n8420..8457 ; Recommended # 1.1 [56] CJK UNIFIED IDEOGRAPH-8420..CJK UNIFIED IDEOGRAPH-8457\n8459..8482 ; Recommended # 1.1 [42] CJK UNIFIED IDEOGRAPH-8459..CJK UNIFIED IDEOGRAPH-8482\n8484..8494 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-8484..CJK UNIFIED IDEOGRAPH-8494\n8496..84B6 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-8496..CJK UNIFIED IDEOGRAPH-84B6\n84B8..84C2 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-84B8..CJK UNIFIED IDEOGRAPH-84C2\n84C4..84EC ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-84C4..CJK UNIFIED IDEOGRAPH-84EC\n84EE..8504 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-84EE..CJK UNIFIED IDEOGRAPH-8504\n8506..850F ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-8506..CJK UNIFIED IDEOGRAPH-850F\n8511..8531 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-8511..CJK UNIFIED IDEOGRAPH-8531\n8534..854B ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-8534..CJK UNIFIED IDEOGRAPH-854B\n854D..854F ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-854D..CJK UNIFIED IDEOGRAPH-854F\n8551..857E ; Recommended # 1.1 [46] CJK UNIFIED IDEOGRAPH-8551..CJK UNIFIED IDEOGRAPH-857E\n8580..8592 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-8580..CJK UNIFIED IDEOGRAPH-8592\n8594..85B1 ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-8594..CJK UNIFIED IDEOGRAPH-85B1\n85B3..85BA ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-85B3..CJK UNIFIED IDEOGRAPH-85BA\n85BC..85CB ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-85BC..CJK UNIFIED IDEOGRAPH-85CB\n85CD..85ED ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-85CD..CJK UNIFIED IDEOGRAPH-85ED\n85EF..85F2 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-85EF..CJK UNIFIED IDEOGRAPH-85F2\n85F4..85FB ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-85F4..CJK UNIFIED IDEOGRAPH-85FB\n85FD..8602 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-85FD..CJK UNIFIED IDEOGRAPH-8602\n8604..860C ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-8604..CJK UNIFIED IDEOGRAPH-860C\n860F ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-860F\n8611..8614 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-8611..CJK UNIFIED IDEOGRAPH-8614\n8616..861C ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-8616..CJK UNIFIED IDEOGRAPH-861C\n861E..8636 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-861E..CJK UNIFIED IDEOGRAPH-8636\n8638..8656 ; Recommended # 1.1 [31] CJK UNIFIED IDEOGRAPH-8638..CJK UNIFIED IDEOGRAPH-8656\n8658..8674 ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-8658..CJK UNIFIED IDEOGRAPH-8674\n8676..8688 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-8676..CJK UNIFIED IDEOGRAPH-8688\n868A..8691 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-868A..CJK UNIFIED IDEOGRAPH-8691\n8693..869F ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-8693..CJK UNIFIED IDEOGRAPH-869F\n86A1..86A5 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-86A1..CJK UNIFIED IDEOGRAPH-86A5\n86A7..86D4 ; Recommended # 1.1 [46] CJK UNIFIED IDEOGRAPH-86A7..CJK UNIFIED IDEOGRAPH-86D4\n86D6..86DF ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-86D6..CJK UNIFIED IDEOGRAPH-86DF\n86E1..86E6 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-86E1..CJK UNIFIED IDEOGRAPH-86E6\n86E8..86FC ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-86E8..CJK UNIFIED IDEOGRAPH-86FC\n86FE..871C ; Recommended # 1.1 [31] CJK UNIFIED IDEOGRAPH-86FE..CJK UNIFIED IDEOGRAPH-871C\n871E..872E ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-871E..CJK UNIFIED IDEOGRAPH-872E\n8730..873C ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-8730..CJK UNIFIED IDEOGRAPH-873C\n873E..8744 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-873E..CJK UNIFIED IDEOGRAPH-8744\n8746..8770 ; Recommended # 1.1 [43] CJK UNIFIED IDEOGRAPH-8746..CJK UNIFIED IDEOGRAPH-8770\n8772..878D ; Recommended # 1.1 [28] CJK UNIFIED IDEOGRAPH-8772..CJK UNIFIED IDEOGRAPH-878D\n878F..8798 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-878F..CJK UNIFIED IDEOGRAPH-8798\n879A..87D9 ; Recommended # 1.1 [64] CJK UNIFIED IDEOGRAPH-879A..CJK UNIFIED IDEOGRAPH-87D9\n87DB..87EF ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-87DB..CJK UNIFIED IDEOGRAPH-87EF\n87F1..8806 ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-87F1..CJK UNIFIED IDEOGRAPH-8806\n8808..8811 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-8808..CJK UNIFIED IDEOGRAPH-8811\n8813..882C ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-8813..CJK UNIFIED IDEOGRAPH-882C\n882E..8839 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-882E..CJK UNIFIED IDEOGRAPH-8839\n883B..8846 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-883B..CJK UNIFIED IDEOGRAPH-8846\n8848..8857 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-8848..CJK UNIFIED IDEOGRAPH-8857\n8859..885B ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-8859..CJK UNIFIED IDEOGRAPH-885B\n885D..885E ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-885D..CJK UNIFIED IDEOGRAPH-885E\n8860..8879 ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-8860..CJK UNIFIED IDEOGRAPH-8879\n887B..88E5 ; Recommended # 1.1 [107] CJK UNIFIED IDEOGRAPH-887B..CJK UNIFIED IDEOGRAPH-88E5\n88E7..88E8 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-88E7..CJK UNIFIED IDEOGRAPH-88E8\n88EA..88EC ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-88EA..CJK UNIFIED IDEOGRAPH-88EC\n88EE..8902 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-88EE..CJK UNIFIED IDEOGRAPH-8902\n8904..890E ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-8904..CJK UNIFIED IDEOGRAPH-890E\n8910..8923 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-8910..CJK UNIFIED IDEOGRAPH-8923\n8925..8964 ; Recommended # 1.1 [64] CJK UNIFIED IDEOGRAPH-8925..CJK UNIFIED IDEOGRAPH-8964\n8966..8974 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-8966..CJK UNIFIED IDEOGRAPH-8974\n8976..897C ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-8976..CJK UNIFIED IDEOGRAPH-897C\n897E..898C ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-897E..CJK UNIFIED IDEOGRAPH-898C\n898E..898F ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-898E..CJK UNIFIED IDEOGRAPH-898F\n8991..8993 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-8991..CJK UNIFIED IDEOGRAPH-8993\n8995..8998 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-8995..CJK UNIFIED IDEOGRAPH-8998\n899A..89AF ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-899A..CJK UNIFIED IDEOGRAPH-89AF\n89B1..89B3 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-89B1..CJK UNIFIED IDEOGRAPH-89B3\n89B5..89BA ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-89B5..CJK UNIFIED IDEOGRAPH-89BA\n89BD..89ED ; Recommended # 1.1 [49] CJK UNIFIED IDEOGRAPH-89BD..CJK UNIFIED IDEOGRAPH-89ED\n89EF..89F4 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-89EF..CJK UNIFIED IDEOGRAPH-89F4\n89F6..89F8 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-89F6..CJK UNIFIED IDEOGRAPH-89F8\n89FA..89FC ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-89FA..CJK UNIFIED IDEOGRAPH-89FC\n89FE..8A04 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-89FE..CJK UNIFIED IDEOGRAPH-8A04\n8A07..8A13 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-8A07..CJK UNIFIED IDEOGRAPH-8A13\n8A15..8A18 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-8A15..CJK UNIFIED IDEOGRAPH-8A18\n8A1A..8A1F ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8A1A..CJK UNIFIED IDEOGRAPH-8A1F\n8A22..8A2A ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-8A22..CJK UNIFIED IDEOGRAPH-8A2A\n8A2C..8A3C ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-8A2C..CJK UNIFIED IDEOGRAPH-8A3C\n8A3E..8A4A ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-8A3E..CJK UNIFIED IDEOGRAPH-8A4A\n8A4C..8A63 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-8A4C..CJK UNIFIED IDEOGRAPH-8A63\n8A65..8A77 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-8A65..CJK UNIFIED IDEOGRAPH-8A77\n8A79..8A7C ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-8A79..CJK UNIFIED IDEOGRAPH-8A7C\n8A7E..8A87 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-8A7E..CJK UNIFIED IDEOGRAPH-8A87\n8A89..8A9E ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-8A89..CJK UNIFIED IDEOGRAPH-8A9E\n8AA0..8AAE ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-8AA0..CJK UNIFIED IDEOGRAPH-8AAE\n8AB0..8AB6 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-8AB0..CJK UNIFIED IDEOGRAPH-8AB6\n8AB8..8ACF ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-8AB8..CJK UNIFIED IDEOGRAPH-8ACF\n8AD1..8AEB ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-8AD1..CJK UNIFIED IDEOGRAPH-8AEB\n8AED..8B28 ; Recommended # 1.1 [60] CJK UNIFIED IDEOGRAPH-8AED..CJK UNIFIED IDEOGRAPH-8B28\n8B2A..8B31 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-8B2A..CJK UNIFIED IDEOGRAPH-8B31\n8B33..8B37 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-8B33..CJK UNIFIED IDEOGRAPH-8B37\n8B39..8B3E ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8B39..CJK UNIFIED IDEOGRAPH-8B3E\n8B40..8B60 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-8B40..CJK UNIFIED IDEOGRAPH-8B60\n8B63..8B68 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8B63..CJK UNIFIED IDEOGRAPH-8B68\n8B6A..8B74 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-8B6A..CJK UNIFIED IDEOGRAPH-8B74\n8B76..8B7B ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8B76..CJK UNIFIED IDEOGRAPH-8B7B\n8B7D..8B80 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-8B7D..CJK UNIFIED IDEOGRAPH-8B80\n8B82..8B86 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-8B82..CJK UNIFIED IDEOGRAPH-8B86\n8B88..8B8C ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-8B88..CJK UNIFIED IDEOGRAPH-8B8C\n8B8E ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-8B8E\n8B90..8B9A ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-8B90..CJK UNIFIED IDEOGRAPH-8B9A\n8B9C..8C37 ; Recommended # 1.1 [156] CJK UNIFIED IDEOGRAPH-8B9C..CJK UNIFIED IDEOGRAPH-8C37\n8C39..8C3F ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-8C39..CJK UNIFIED IDEOGRAPH-8C3F\n8C41..8C43 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-8C41..CJK UNIFIED IDEOGRAPH-8C43\n8C45..8C50 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-8C45..CJK UNIFIED IDEOGRAPH-8C50\n8C54..8C57 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-8C54..CJK UNIFIED IDEOGRAPH-8C57\n8C59..8C73 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-8C59..CJK UNIFIED IDEOGRAPH-8C73\n8C75..8C7E ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-8C75..CJK UNIFIED IDEOGRAPH-8C7E\n8C80..8C82 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-8C80..CJK UNIFIED IDEOGRAPH-8C82\n8C84..8C86 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-8C84..CJK UNIFIED IDEOGRAPH-8C86\n8C88..8C8A ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-8C88..CJK UNIFIED IDEOGRAPH-8C8A\n8C8C..8C9A ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-8C8C..CJK UNIFIED IDEOGRAPH-8C9A\n8C9C..8CA5 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-8C9C..CJK UNIFIED IDEOGRAPH-8CA5\n8CA7..8CCA ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-8CA7..CJK UNIFIED IDEOGRAPH-8CCA\n8CCC..8CD5 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-8CCC..CJK UNIFIED IDEOGRAPH-8CD5\n8CD7 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-8CD7\n8CD9..8CE8 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-8CD9..CJK UNIFIED IDEOGRAPH-8CE8\n8CEA..8CF6 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-8CEA..CJK UNIFIED IDEOGRAPH-8CF6\n8CF8..8D00 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-8CF8..CJK UNIFIED IDEOGRAPH-8D00\n8D02..8D10 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-8D02..CJK UNIFIED IDEOGRAPH-8D10\n8D13..8D7B ; Recommended # 1.1 [105] CJK UNIFIED IDEOGRAPH-8D13..CJK UNIFIED IDEOGRAPH-8D7B\n8D7D..8DA5 ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-8D7D..CJK UNIFIED IDEOGRAPH-8DA5\n8DA7..8DBF ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-8DA7..CJK UNIFIED IDEOGRAPH-8DBF\n8DC1..8DE4 ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-8DC1..CJK UNIFIED IDEOGRAPH-8DE4\n8DE6..8E00 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-8DE6..CJK UNIFIED IDEOGRAPH-8E00\n8E02..8E0A ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-8E02..CJK UNIFIED IDEOGRAPH-8E0A\n8E0C..8E31 ; Recommended # 1.1 [38] CJK UNIFIED IDEOGRAPH-8E0C..CJK UNIFIED IDEOGRAPH-8E31\n8E33..8E45 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-8E33..CJK UNIFIED IDEOGRAPH-8E45\n8E47..8E4E ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-8E47..CJK UNIFIED IDEOGRAPH-8E4E\n8E50..8E6D ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-8E50..CJK UNIFIED IDEOGRAPH-8E6D\n8E6F..8E74 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8E6F..CJK UNIFIED IDEOGRAPH-8E74\n8E76 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-8E76\n8E78 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-8E78\n8E7A..8E9A ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-8E7A..CJK UNIFIED IDEOGRAPH-8E9A\n8E9C..8EA1 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8E9C..CJK UNIFIED IDEOGRAPH-8EA1\n8EA3..8EB2 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-8EA3..CJK UNIFIED IDEOGRAPH-8EB2\n8EB4..8EB5 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-8EB4..CJK UNIFIED IDEOGRAPH-8EB5\n8EB8..8EC0 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-8EB8..CJK UNIFIED IDEOGRAPH-8EC0\n8EC2..8EC3 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-8EC2..CJK UNIFIED IDEOGRAPH-8EC3\n8EC5..8ED8 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-8EC5..CJK UNIFIED IDEOGRAPH-8ED8\n8EDA..8EEF ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-8EDA..CJK UNIFIED IDEOGRAPH-8EEF\n8EF1..8F0E ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-8EF1..CJK UNIFIED IDEOGRAPH-8F0E\n8F10..8F2C ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-8F10..CJK UNIFIED IDEOGRAPH-8F2C\n8F2E..8F39 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-8F2E..CJK UNIFIED IDEOGRAPH-8F39\n8F3B..8F40 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8F3B..CJK UNIFIED IDEOGRAPH-8F40\n8F42..8F9C ; Recommended # 1.1 [91] CJK UNIFIED IDEOGRAPH-8F42..CJK UNIFIED IDEOGRAPH-8F9C\n8F9E..8FA3 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8F9E..CJK UNIFIED IDEOGRAPH-8FA3\n8FA5..8FB2 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-8FA5..CJK UNIFIED IDEOGRAPH-8FB2\n8FB4..8FC2 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-8FB4..CJK UNIFIED IDEOGRAPH-8FC2\n8FC4..8FC9 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-8FC4..CJK UNIFIED IDEOGRAPH-8FC9\n8FCB..8FE6 ; Recommended # 1.1 [28] CJK UNIFIED IDEOGRAPH-8FCB..CJK UNIFIED IDEOGRAPH-8FE6\n8FE8..9029 ; Recommended # 1.1 [66] CJK UNIFIED IDEOGRAPH-8FE8..CJK UNIFIED IDEOGRAPH-9029\n902B ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-902B\n902D..9036 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-902D..CJK UNIFIED IDEOGRAPH-9036\n9038..903F ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-9038..CJK UNIFIED IDEOGRAPH-903F\n9041..9045 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-9041..CJK UNIFIED IDEOGRAPH-9045\n9047..90AA ; Recommended # 1.1 [100] CJK UNIFIED IDEOGRAPH-9047..CJK UNIFIED IDEOGRAPH-90AA\n90AC..90CB ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-90AC..CJK UNIFIED IDEOGRAPH-90CB\n90CE..90D1 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-90CE..CJK UNIFIED IDEOGRAPH-90D1\n90D3..90F5 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-90D3..CJK UNIFIED IDEOGRAPH-90F5\n90F7..9109 ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-90F7..CJK UNIFIED IDEOGRAPH-9109\n910B..913B ; Recommended # 1.1 [49] CJK UNIFIED IDEOGRAPH-910B..CJK UNIFIED IDEOGRAPH-913B\n913E..9158 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-913E..CJK UNIFIED IDEOGRAPH-9158\n915A..917A ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-915A..CJK UNIFIED IDEOGRAPH-917A\n917C..9194 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-917C..CJK UNIFIED IDEOGRAPH-9194\n9196..9197 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9196..CJK UNIFIED IDEOGRAPH-9197\n9199..91A8 ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-9199..CJK UNIFIED IDEOGRAPH-91A8\n91AA..91BE ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-91AA..CJK UNIFIED IDEOGRAPH-91BE\n91C0..91C3 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-91C0..CJK UNIFIED IDEOGRAPH-91C3\n91C5..91DF ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-91C5..CJK UNIFIED IDEOGRAPH-91DF\n91E1..91EE ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-91E1..CJK UNIFIED IDEOGRAPH-91EE\n91F0..9212 ; Recommended # 1.1 [35] CJK UNIFIED IDEOGRAPH-91F0..CJK UNIFIED IDEOGRAPH-9212\n9214..921E ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-9214..CJK UNIFIED IDEOGRAPH-921E\n9220..9221 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9220..CJK UNIFIED IDEOGRAPH-9221\n9223..9242 ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-9223..CJK UNIFIED IDEOGRAPH-9242\n9244..9268 ; Recommended # 1.1 [37] CJK UNIFIED IDEOGRAPH-9244..CJK UNIFIED IDEOGRAPH-9268\n926B..9280 ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-926B..CJK UNIFIED IDEOGRAPH-9280\n9282..9283 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9282..CJK UNIFIED IDEOGRAPH-9283\n9285..929D ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-9285..CJK UNIFIED IDEOGRAPH-929D\n929F..92BC ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-929F..CJK UNIFIED IDEOGRAPH-92BC\n92BE..92D3 ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-92BE..CJK UNIFIED IDEOGRAPH-92D3\n92D5..92DA ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-92D5..CJK UNIFIED IDEOGRAPH-92DA\n92DC..92E1 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-92DC..CJK UNIFIED IDEOGRAPH-92E1\n92E3..931B ; Recommended # 1.1 [57] CJK UNIFIED IDEOGRAPH-92E3..CJK UNIFIED IDEOGRAPH-931B\n931D..932F ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-931D..CJK UNIFIED IDEOGRAPH-932F\n9332..9361 ; Recommended # 1.1 [48] CJK UNIFIED IDEOGRAPH-9332..CJK UNIFIED IDEOGRAPH-9361\n9363..9367 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-9363..CJK UNIFIED IDEOGRAPH-9367\n9369..936A ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9369..CJK UNIFIED IDEOGRAPH-936A\n936C..936E ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-936C..CJK UNIFIED IDEOGRAPH-936E\n9370..9372 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-9370..CJK UNIFIED IDEOGRAPH-9372\n9374..9377 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9374..CJK UNIFIED IDEOGRAPH-9377\n9379..937E ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9379..CJK UNIFIED IDEOGRAPH-937E\n9380 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9380\n9382..938A ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-9382..CJK UNIFIED IDEOGRAPH-938A\n938C..939B ; Recommended # 1.1 [16] CJK UNIFIED IDEOGRAPH-938C..CJK UNIFIED IDEOGRAPH-939B\n939D..939F ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-939D..CJK UNIFIED IDEOGRAPH-939F\n93A1..93AA ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-93A1..CJK UNIFIED IDEOGRAPH-93AA\n93AC..93BA ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-93AC..CJK UNIFIED IDEOGRAPH-93BA\n93BC..93DF ; Recommended # 1.1 [36] CJK UNIFIED IDEOGRAPH-93BC..CJK UNIFIED IDEOGRAPH-93DF\n93E1..93F2 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-93E1..CJK UNIFIED IDEOGRAPH-93F2\n93F4..9401 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-93F4..CJK UNIFIED IDEOGRAPH-9401\n9403..9416 ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-9403..CJK UNIFIED IDEOGRAPH-9416\n9418..941B ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9418..CJK UNIFIED IDEOGRAPH-941B\n941D ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-941D\n9420..9423 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9420..CJK UNIFIED IDEOGRAPH-9423\n9425..9442 ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-9425..CJK UNIFIED IDEOGRAPH-9442\n9444..944D ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-9444..CJK UNIFIED IDEOGRAPH-944D\n944F..946B ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-944F..CJK UNIFIED IDEOGRAPH-946B\n946D..947A ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-946D..CJK UNIFIED IDEOGRAPH-947A\n947C..9577 ; Recommended # 1.1 [252] CJK UNIFIED IDEOGRAPH-947C..CJK UNIFIED IDEOGRAPH-9577\n957A..957D ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-957A..CJK UNIFIED IDEOGRAPH-957D\n957F..9584 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-957F..CJK UNIFIED IDEOGRAPH-9584\n9586..9596 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-9586..CJK UNIFIED IDEOGRAPH-9596\n9598..95B2 ; Recommended # 1.1 [27] CJK UNIFIED IDEOGRAPH-9598..CJK UNIFIED IDEOGRAPH-95B2\n95B5..95B7 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-95B5..CJK UNIFIED IDEOGRAPH-95B7\n95B9..95C0 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-95B9..CJK UNIFIED IDEOGRAPH-95C0\n95C2..95D8 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-95C2..CJK UNIFIED IDEOGRAPH-95D8\n95DA..95DC ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-95DA..CJK UNIFIED IDEOGRAPH-95DC\n95DE..9624 ; Recommended # 1.1 [71] CJK UNIFIED IDEOGRAPH-95DE..CJK UNIFIED IDEOGRAPH-9624\n9627..9628 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9627..CJK UNIFIED IDEOGRAPH-9628\n962A..963D ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-962A..CJK UNIFIED IDEOGRAPH-963D\n963F..9655 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-963F..CJK UNIFIED IDEOGRAPH-9655\n9658..9678 ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-9658..CJK UNIFIED IDEOGRAPH-9678\n967A ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-967A\n967C..967E ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-967C..CJK UNIFIED IDEOGRAPH-967E\n9680 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9680\n9683..968B ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-9683..CJK UNIFIED IDEOGRAPH-968B\n968D..9695 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-968D..CJK UNIFIED IDEOGRAPH-9695\n9697..9699 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-9697..CJK UNIFIED IDEOGRAPH-9699\n969B..969C ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-969B..CJK UNIFIED IDEOGRAPH-969C\n969E ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-969E\n96A0..96AA ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-96A0..CJK UNIFIED IDEOGRAPH-96AA\n96AC..96AE ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-96AC..CJK UNIFIED IDEOGRAPH-96AE\n96B0..96B4 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-96B0..CJK UNIFIED IDEOGRAPH-96B4\n96B6..96E3 ; Recommended # 1.1 [46] CJK UNIFIED IDEOGRAPH-96B6..CJK UNIFIED IDEOGRAPH-96E3\n96E5 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-96E5\n96E8..96FB ; Recommended # 1.1 [20] CJK UNIFIED IDEOGRAPH-96E8..CJK UNIFIED IDEOGRAPH-96FB\n96FD..9713 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-96FD..CJK UNIFIED IDEOGRAPH-9713\n9715..9716 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9715..CJK UNIFIED IDEOGRAPH-9716\n9718..9719 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9718..CJK UNIFIED IDEOGRAPH-9719\n971C..9732 ; Recommended # 1.1 [23] CJK UNIFIED IDEOGRAPH-971C..CJK UNIFIED IDEOGRAPH-9732\n9735..9736 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9735..CJK UNIFIED IDEOGRAPH-9736\n9738..973F ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-9738..CJK UNIFIED IDEOGRAPH-973F\n9742..974C ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-9742..CJK UNIFIED IDEOGRAPH-974C\n974E..9756 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-974E..CJK UNIFIED IDEOGRAPH-9756\n9758..9762 ; Recommended # 1.1 [11] CJK UNIFIED IDEOGRAPH-9758..CJK UNIFIED IDEOGRAPH-9762\n9764..9774 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-9764..CJK UNIFIED IDEOGRAPH-9774\n9776..9786 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-9776..CJK UNIFIED IDEOGRAPH-9786\n9788 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9788\n978A..979A ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-978A..CJK UNIFIED IDEOGRAPH-979A\n979C..97A8 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-979C..CJK UNIFIED IDEOGRAPH-97A8\n97AA..97AF ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-97AA..CJK UNIFIED IDEOGRAPH-97AF\n97B2..97B4 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-97B2..CJK UNIFIED IDEOGRAPH-97B4\n97B6..97BD ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-97B6..CJK UNIFIED IDEOGRAPH-97BD\n97BF ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-97BF\n97C1..97D1 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-97C1..CJK UNIFIED IDEOGRAPH-97D1\n97D3..97FB ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-97D3..CJK UNIFIED IDEOGRAPH-97FB\n97FD..981E ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-97FD..CJK UNIFIED IDEOGRAPH-981E\n9820..9824 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-9820..CJK UNIFIED IDEOGRAPH-9824\n9826..9829 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9826..CJK UNIFIED IDEOGRAPH-9829\n982B..9832 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-982B..CJK UNIFIED IDEOGRAPH-9832\n9834..9839 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9834..CJK UNIFIED IDEOGRAPH-9839\n983B..983D ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-983B..CJK UNIFIED IDEOGRAPH-983D\n983F..9841 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-983F..CJK UNIFIED IDEOGRAPH-9841\n9843..9846 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9843..CJK UNIFIED IDEOGRAPH-9846\n9848..9855 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-9848..CJK UNIFIED IDEOGRAPH-9855\n9857..9865 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-9857..CJK UNIFIED IDEOGRAPH-9865\n9867 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9867\n9869..98B6 ; Recommended # 1.1 [78] CJK UNIFIED IDEOGRAPH-9869..CJK UNIFIED IDEOGRAPH-98B6\n98B8..98C9 ; Recommended # 1.1 [18] CJK UNIFIED IDEOGRAPH-98B8..CJK UNIFIED IDEOGRAPH-98C9\n98CB..98E3 ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-98CB..CJK UNIFIED IDEOGRAPH-98E3\n98E5..98EB ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-98E5..CJK UNIFIED IDEOGRAPH-98EB\n98ED..98F0 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-98ED..CJK UNIFIED IDEOGRAPH-98F0\n98F2..98F7 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-98F2..CJK UNIFIED IDEOGRAPH-98F7\n98F9..98FA ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-98F9..CJK UNIFIED IDEOGRAPH-98FA\n98FC..9918 ; Recommended # 1.1 [29] CJK UNIFIED IDEOGRAPH-98FC..CJK UNIFIED IDEOGRAPH-9918\n991A..993A ; Recommended # 1.1 [33] CJK UNIFIED IDEOGRAPH-991A..CJK UNIFIED IDEOGRAPH-993A\n993C..9943 ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-993C..CJK UNIFIED IDEOGRAPH-9943\n9945..9959 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-9945..CJK UNIFIED IDEOGRAPH-9959\n995B..995C ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-995B..CJK UNIFIED IDEOGRAPH-995C\n995E..99BE ; Recommended # 1.1 [97] CJK UNIFIED IDEOGRAPH-995E..CJK UNIFIED IDEOGRAPH-99BE\n99C0..99DF ; Recommended # 1.1 [32] CJK UNIFIED IDEOGRAPH-99C0..CJK UNIFIED IDEOGRAPH-99DF\n99E1..99E5 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-99E1..CJK UNIFIED IDEOGRAPH-99E5\n99E7..99EA ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-99E7..CJK UNIFIED IDEOGRAPH-99EA\n99EC..99F4 ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-99EC..CJK UNIFIED IDEOGRAPH-99F4\n99F6..9A0F ; Recommended # 1.1 [26] CJK UNIFIED IDEOGRAPH-99F6..CJK UNIFIED IDEOGRAPH-9A0F\n9A11..9A16 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9A11..CJK UNIFIED IDEOGRAPH-9A16\n9A19..9A3A ; Recommended # 1.1 [34] CJK UNIFIED IDEOGRAPH-9A19..CJK UNIFIED IDEOGRAPH-9A3A\n9A3C..9A50 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-9A3C..CJK UNIFIED IDEOGRAPH-9A50\n9A52..9A57 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9A52..CJK UNIFIED IDEOGRAPH-9A57\n9A59..9A5C ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9A59..CJK UNIFIED IDEOGRAPH-9A5C\n9A5E..9A62 ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-9A5E..CJK UNIFIED IDEOGRAPH-9A62\n9A64..9AA8 ; Recommended # 1.1 [69] CJK UNIFIED IDEOGRAPH-9A64..CJK UNIFIED IDEOGRAPH-9AA8\n9AAA..9ABC ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-9AAA..CJK UNIFIED IDEOGRAPH-9ABC\n9ABE..9AC7 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-9ABE..CJK UNIFIED IDEOGRAPH-9AC7\n9AC9..9AD6 ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-9AC9..CJK UNIFIED IDEOGRAPH-9AD6\n9AD8..9ADF ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-9AD8..CJK UNIFIED IDEOGRAPH-9ADF\n9AE1..9AE3 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-9AE1..CJK UNIFIED IDEOGRAPH-9AE3\n9AE5..9AE7 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-9AE5..CJK UNIFIED IDEOGRAPH-9AE7\n9AEA..9AEF ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9AEA..CJK UNIFIED IDEOGRAPH-9AEF\n9AF1..9AFF ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-9AF1..CJK UNIFIED IDEOGRAPH-9AFF\n9B01 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9B01\n9B03..9B08 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9B03..CJK UNIFIED IDEOGRAPH-9B08\n9B0A..9B13 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-9B0A..CJK UNIFIED IDEOGRAPH-9B13\n9B15..9B1A ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9B15..CJK UNIFIED IDEOGRAPH-9B1A\n9B1C..9B33 ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-9B1C..CJK UNIFIED IDEOGRAPH-9B33\n9B35..9B3C ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-9B35..CJK UNIFIED IDEOGRAPH-9B3C\n9B3E..9B3F ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9B3E..CJK UNIFIED IDEOGRAPH-9B3F\n9B41..9B4F ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-9B41..CJK UNIFIED IDEOGRAPH-9B4F\n9B51..9B56 ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9B51..CJK UNIFIED IDEOGRAPH-9B56\n9B58..9B61 ; Recommended # 1.1 [10] CJK UNIFIED IDEOGRAPH-9B58..CJK UNIFIED IDEOGRAPH-9B61\n9B63..9B71 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-9B63..CJK UNIFIED IDEOGRAPH-9B71\n9B73..9B88 ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-9B73..CJK UNIFIED IDEOGRAPH-9B88\n9B8A..9B8B ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9B8A..CJK UNIFIED IDEOGRAPH-9B8B\n9B8D..9B98 ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-9B8D..CJK UNIFIED IDEOGRAPH-9B98\n9B9A..9BC1 ; Recommended # 1.1 [40] CJK UNIFIED IDEOGRAPH-9B9A..CJK UNIFIED IDEOGRAPH-9BC1\n9BC3..9BF5 ; Recommended # 1.1 [51] CJK UNIFIED IDEOGRAPH-9BC3..CJK UNIFIED IDEOGRAPH-9BF5\n9BF7..9BFF ; Recommended # 1.1 [9] CJK UNIFIED IDEOGRAPH-9BF7..CJK UNIFIED IDEOGRAPH-9BFF\n9C02 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9C02\n9C04..9C41 ; Recommended # 1.1 [62] CJK UNIFIED IDEOGRAPH-9C04..CJK UNIFIED IDEOGRAPH-9C41\n9C43..9C4E ; Recommended # 1.1 [12] CJK UNIFIED IDEOGRAPH-9C43..CJK UNIFIED IDEOGRAPH-9C4E\n9C50 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9C50\n9C52..9C60 ; Recommended # 1.1 [15] CJK UNIFIED IDEOGRAPH-9C52..CJK UNIFIED IDEOGRAPH-9C60\n9C62..9C63 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9C62..CJK UNIFIED IDEOGRAPH-9C63\n9C65..9C7A ; Recommended # 1.1 [22] CJK UNIFIED IDEOGRAPH-9C65..CJK UNIFIED IDEOGRAPH-9C7A\n9C7C..9D0B ; Recommended # 1.1 [144] CJK UNIFIED IDEOGRAPH-9C7C..CJK UNIFIED IDEOGRAPH-9D0B\n9D0E..9D10 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-9D0E..CJK UNIFIED IDEOGRAPH-9D10\n9D12..9D26 ; Recommended # 1.1 [21] CJK UNIFIED IDEOGRAPH-9D12..CJK UNIFIED IDEOGRAPH-9D26\n9D28..9D34 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-9D28..CJK UNIFIED IDEOGRAPH-9D34\n9D36..9D3B ; Recommended # 1.1 [6] CJK UNIFIED IDEOGRAPH-9D36..CJK UNIFIED IDEOGRAPH-9D3B\n9D3D..9D6C ; Recommended # 1.1 [48] CJK UNIFIED IDEOGRAPH-9D3D..CJK UNIFIED IDEOGRAPH-9D6C\n9D6E..9D94 ; Recommended # 1.1 [39] CJK UNIFIED IDEOGRAPH-9D6E..CJK UNIFIED IDEOGRAPH-9D94\n9D96..9DAD ; Recommended # 1.1 [24] CJK UNIFIED IDEOGRAPH-9D96..CJK UNIFIED IDEOGRAPH-9DAD\n9DAF..9DBC ; Recommended # 1.1 [14] CJK UNIFIED IDEOGRAPH-9DAF..CJK UNIFIED IDEOGRAPH-9DBC\n9DBE..9DBF ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9DBE..CJK UNIFIED IDEOGRAPH-9DBF\n9DC1..9DE9 ; Recommended # 1.1 [41] CJK UNIFIED IDEOGRAPH-9DC1..CJK UNIFIED IDEOGRAPH-9DE9\n9DEB..9DFB ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-9DEB..CJK UNIFIED IDEOGRAPH-9DFB\n9DFD..9E0D ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-9DFD..CJK UNIFIED IDEOGRAPH-9E0D\n9E0F..9E15 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-9E0F..CJK UNIFIED IDEOGRAPH-9E15\n9E17..9E1B ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-9E17..CJK UNIFIED IDEOGRAPH-9E1B\n9E1D..9E7A ; Recommended # 1.1 [94] CJK UNIFIED IDEOGRAPH-9E1D..CJK UNIFIED IDEOGRAPH-9E7A\n9E7C..9E8E ; Recommended # 1.1 [19] CJK UNIFIED IDEOGRAPH-9E7C..CJK UNIFIED IDEOGRAPH-9E8E\n9E91..9E97 ; Recommended # 1.1 [7] CJK UNIFIED IDEOGRAPH-9E91..CJK UNIFIED IDEOGRAPH-9E97\n9E99..9E9D ; Recommended # 1.1 [5] CJK UNIFIED IDEOGRAPH-9E99..CJK UNIFIED IDEOGRAPH-9E9D\n9E9F..9EA1 ; Recommended # 1.1 [3] CJK UNIFIED IDEOGRAPH-9E9F..CJK UNIFIED IDEOGRAPH-9EA1\n9EA3..9EAA ; Recommended # 1.1 [8] CJK UNIFIED IDEOGRAPH-9EA3..CJK UNIFIED IDEOGRAPH-9EAA\n9EAD..9EB0 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9EAD..CJK UNIFIED IDEOGRAPH-9EB0\n9EB2..9EEB ; Recommended # 1.1 [58] CJK UNIFIED IDEOGRAPH-9EB2..CJK UNIFIED IDEOGRAPH-9EEB\n9EED..9EF0 ; Recommended # 1.1 [4] CJK UNIFIED IDEOGRAPH-9EED..CJK UNIFIED IDEOGRAPH-9EF0\n9EF2..9F02 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-9EF2..CJK UNIFIED IDEOGRAPH-9F02\n9F04..9F10 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-9F04..CJK UNIFIED IDEOGRAPH-9F10\n9F12..9F13 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9F12..CJK UNIFIED IDEOGRAPH-9F13\n9F15..9F25 ; Recommended # 1.1 [17] CJK UNIFIED IDEOGRAPH-9F15..CJK UNIFIED IDEOGRAPH-9F25\n9F27..9F44 ; Recommended # 1.1 [30] CJK UNIFIED IDEOGRAPH-9F27..CJK UNIFIED IDEOGRAPH-9F44\n9F46..9F52 ; Recommended # 1.1 [13] CJK UNIFIED IDEOGRAPH-9F46..CJK UNIFIED IDEOGRAPH-9F52\n9F54..9F6C ; Recommended # 1.1 [25] CJK UNIFIED IDEOGRAPH-9F54..CJK UNIFIED IDEOGRAPH-9F6C\n9F6E..9FA0 ; Recommended # 1.1 [51] CJK UNIFIED IDEOGRAPH-9F6E..CJK UNIFIED IDEOGRAPH-9FA0\n9FA2 ; Recommended # 1.1 CJK UNIFIED IDEOGRAPH-9FA2\n9FA4..9FA5 ; Recommended # 1.1 [2] CJK UNIFIED IDEOGRAPH-9FA4..CJK UNIFIED IDEOGRAPH-9FA5\nA78D ; Recommended # 6.0 LATIN CAPITAL LETTER TURNED H\nA7AA ; Recommended # 6.1 LATIN CAPITAL LETTER H WITH HOOK\nAA7B ; Recommended # 5.2 MYANMAR SIGN PAO KAREN TONE\nAC00..D7A3 ; Recommended # 2.0 [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH\n11301 ; Recommended # 7.0 GRANTHA SIGN CANDRABINDU\n11303 ; Recommended # 7.0 GRANTHA SIGN VISARGA\n1133C ; Recommended # 7.0 GRANTHA SIGN NUKTA\n1E7E0..1E7E6 ; Recommended # 14.0 [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO\n1E7E8..1E7EB ; Recommended # 14.0 [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE\n1E7ED..1E7EE ; Recommended # 14.0 [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE\n1E7F0..1E7FE ; Recommended # 14.0 [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE\n2070E ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-2070E\n20731 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20731\n20779 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20779\n20C53 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20C53\n20C78 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20C78\n20C96 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20C96\n20CCF ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20CCF\n20CD5 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20CD5\n20D15 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20D15\n20D7C ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20D7C\n20D7F ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20D7F\n20E0E..20E0F ; Recommended # 3.1 [2] CJK UNIFIED IDEOGRAPH-20E0E..CJK UNIFIED IDEOGRAPH-20E0F\n20E77 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20E77\n20E9D ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20E9D\n20EA2 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20EA2\n20ED7 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20ED7\n20EF9..20EFA ; Recommended # 3.1 [2] CJK UNIFIED IDEOGRAPH-20EF9..CJK UNIFIED IDEOGRAPH-20EFA\n20F2D..20F2E ; Recommended # 3.1 [2] CJK UNIFIED IDEOGRAPH-20F2D..CJK UNIFIED IDEOGRAPH-20F2E\n20F4C ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20F4C\n20FB4 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20FB4\n20FBC ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20FBC\n20FEA ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-20FEA\n2105C ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-2105C\n2106F ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-2106F\n21075..21076 ; Recommended # 3.1 [2] CJK UNIFIED IDEOGRAPH-21075..CJK UNIFIED IDEOGRAPH-21076\n2107B ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-2107B\n210C1 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-210C1\n210C9 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-210C9\n211D9 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-211D9\n220C7 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-220C7\n227B5 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-227B5\n22AD5 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22AD5\n22B43 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22B43\n22BCA ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22BCA\n22C51 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22C51\n22C55 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22C55\n22CC2 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22CC2\n22D08 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22D08\n22D4C ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22D4C\n22D67 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22D67\n22EB3 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-22EB3\n23CB7 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-23CB7\n244D3 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-244D3\n24DB8 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-24DB8\n24DEA ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-24DEA\n2512B ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-2512B\n26258 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-26258\n267CC ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-267CC\n269F2 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-269F2\n269FA ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-269FA\n27A3E ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-27A3E\n2815D ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-2815D\n28207 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-28207\n282E2 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-282E2\n28CCA ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-28CCA\n28CCD ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-28CCD\n28CD2 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-28CD2\n29D98 ; Recommended # 3.1 CJK UNIFIED IDEOGRAPH-29D98\n\n# Total code points: 33773\n\n#\tIdentifier_Type:\tInclusion\n\n0027 ; Inclusion # 1.1 APOSTROPHE\n002D..002E ; Inclusion # 1.1 [2] HYPHEN-MINUS..FULL STOP\n003A ; Inclusion # 1.1 COLON\n00B7 ; Inclusion # 1.1 MIDDLE DOT\n02BB..02BC ; Inclusion # 1.1 [2] MODIFIER LETTER TURNED COMMA..MODIFIER LETTER APOSTROPHE\n058A ; Inclusion # 3.0 ARMENIAN HYPHEN\n05F3..05F4 ; Inclusion # 1.1 [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM\n06FD..06FE ; Inclusion # 3.0 [2] ARABIC SIGN SINDHI AMPERSAND..ARABIC SIGN SINDHI POSTPOSITION MEN\n0F0B ; Inclusion # 2.0 TIBETAN MARK INTERSYLLABIC TSHEG\n2010 ; Inclusion # 1.1 HYPHEN\n2019 ; Inclusion # 1.1 RIGHT SINGLE QUOTATION MARK\n2027 ; Inclusion # 1.1 HYPHENATION POINT\n30A0 ; Inclusion # 3.2 KATAKANA-HIRAGANA DOUBLE HYPHEN\n30FB ; Inclusion # 1.1 KATAKANA MIDDLE DOT\n\n# Total code points: 18\n\n#\tIdentifier_Type:\tLimited_Use\n\n0710..072C ; Limited_Use # 3.0 [29] SYRIAC LETTER ALAPH..SYRIAC LETTER TAW\n072D..072F ; Limited_Use # 4.0 [3] SYRIAC LETTER PERSIAN BHETH..SYRIAC LETTER PERSIAN DHALATH\n0730..073F ; Limited_Use # 3.0 [16] SYRIAC PTHAHA ABOVE..SYRIAC RWAHA\n074D..074F ; Limited_Use # 4.0 [3] SYRIAC LETTER SOGDIAN ZHAIN..SYRIAC LETTER SOGDIAN FE\n07C0..07E7 ; Limited_Use # 5.0 [40] NKO DIGIT ZERO..NKO LETTER NYA WOLOSO\n07EB..07F5 ; Limited_Use # 5.0 [11] NKO COMBINING SHORT HIGH TONE..NKO LOW TONE APOSTROPHE\n07FD ; Limited_Use # 11.0 NKO DANTAYALAN\n0840..085B ; Limited_Use # 6.0 [28] MANDAIC LETTER HALQA..MANDAIC GEMINATION MARK\n0860..086A ; Limited_Use # 10.0 [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA\n13A0..13F4 ; Limited_Use # 3.0 [85] CHEROKEE LETTER A..CHEROKEE LETTER YV\n13F5 ; Limited_Use # 8.0 CHEROKEE LETTER MV\n13F8..13FD ; Limited_Use # 8.0 [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV\n1401..166C ; Limited_Use # 3.0 [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA\n166F..1676 ; Limited_Use # 3.0 [8] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS NNGAA\n1677..167F ; Limited_Use # 5.2 [9] CANADIAN SYLLABICS WOODS-CREE THWEE..CANADIAN SYLLABICS BLACKFOOT W\n18B0..18F5 ; Limited_Use # 5.2 [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S\n1900..191C ; Limited_Use # 4.0 [29] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER HA\n191D..191E ; Limited_Use # 7.0 [2] LIMBU LETTER GYAN..LIMBU LETTER TRA\n1920..192B ; Limited_Use # 4.0 [12] LIMBU VOWEL SIGN A..LIMBU SUBJOINED LETTER WA\n1930..193B ; Limited_Use # 4.0 [12] LIMBU SMALL LETTER KA..LIMBU SIGN SA-I\n1946..196D ; Limited_Use # 4.0 [40] LIMBU DIGIT ZERO..TAI LE LETTER AI\n1970..1974 ; Limited_Use # 4.0 [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6\n1980..19A9 ; Limited_Use # 4.1 [42] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW XVA\n19AA..19AB ; Limited_Use # 5.2 [2] NEW TAI LUE LETTER HIGH SUA..NEW TAI LUE LETTER LOW SUA\n19B0..19C9 ; Limited_Use # 4.1 [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2\n19D0..19D9 ; Limited_Use # 4.1 [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE\n19DA ; Limited_Use # 5.2 NEW TAI LUE THAM DIGIT ONE\n1A20..1A5E ; Limited_Use # 5.2 [63] TAI THAM LETTER HIGH KA..TAI THAM CONSONANT SIGN SA\n1A60..1A7C ; Limited_Use # 5.2 [29] TAI THAM SIGN SAKOT..TAI THAM SIGN KHUEN-LUE KARAN\n1A7F..1A89 ; Limited_Use # 5.2 [11] TAI THAM COMBINING CRYPTOGRAMMIC DOT..TAI THAM HORA DIGIT NINE\n1A90..1A99 ; Limited_Use # 5.2 [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE\n1AA7 ; Limited_Use # 5.2 TAI THAM SIGN MAI YAMOK\n1B00..1B4B ; Limited_Use # 5.0 [76] BALINESE SIGN ULU RICEM..BALINESE LETTER ASYURA SASAK\n1B4C ; Limited_Use # 14.0 BALINESE LETTER ARCHAIC JNYA\n1B50..1B59 ; Limited_Use # 5.0 [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE\n1B80..1BAA ; Limited_Use # 5.1 [43] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PAMAAEH\n1BAB..1BAD ; Limited_Use # 6.1 [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA\n1BAE..1BB9 ; Limited_Use # 5.1 [12] SUNDANESE LETTER KHA..SUNDANESE DIGIT NINE\n1BBA..1BBF ; Limited_Use # 6.1 [6] SUNDANESE AVAGRAHA..SUNDANESE LETTER FINAL M\n1BC0..1BF3 ; Limited_Use # 6.0 [52] BATAK LETTER A..BATAK PANONGONAN\n1C00..1C37 ; Limited_Use # 5.1 [56] LEPCHA LETTER KA..LEPCHA SIGN NUKTA\n1C40..1C49 ; Limited_Use # 5.1 [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE\n1C4D..1C7D ; Limited_Use # 5.1 [49] LEPCHA LETTER TTA..OL CHIKI AHAD\n2D30..2D65 ; Limited_Use # 4.1 [54] TIFINAGH LETTER YA..TIFINAGH LETTER YAZZ\n2D66..2D67 ; Limited_Use # 6.1 [2] TIFINAGH LETTER YE..TIFINAGH LETTER YO\n2D7F ; Limited_Use # 6.0 TIFINAGH CONSONANT JOINER\n3105..312C ; Limited_Use # 1.1 [40] BOPOMOFO LETTER B..BOPOMOFO LETTER GN\n312D ; Limited_Use # 5.1 BOPOMOFO LETTER IH\n312F ; Limited_Use # 11.0 BOPOMOFO LETTER NN\n31A0..31B7 ; Limited_Use # 3.0 [24] BOPOMOFO LETTER BU..BOPOMOFO FINAL LETTER H\n31B8..31BA ; Limited_Use # 6.0 [3] BOPOMOFO LETTER GH..BOPOMOFO LETTER ZY\n31BB..31BF ; Limited_Use # 13.0 [5] BOPOMOFO FINAL LETTER G..BOPOMOFO LETTER AH\nA000..A48C ; Limited_Use # 3.0 [1165] YI SYLLABLE IT..YI SYLLABLE YYR\nA4D0..A4FD ; Limited_Use # 5.2 [46] LISU LETTER BA..LISU LETTER TONE MYA JEU\nA500..A60C ; Limited_Use # 5.1 [269] VAI SYLLABLE EE..VAI SYLLABLE LENGTHENER\nA613..A629 ; Limited_Use # 5.1 [23] VAI SYMBOL FEENG..VAI DIGIT NINE\nA6A0..A6F1 ; Limited_Use # 5.2 [82] BAMUM LETTER A..BAMUM COMBINING MARK TUKWENTIS\nA800..A827 ; Limited_Use # 4.1 [40] SYLOTI NAGRI LETTER A..SYLOTI NAGRI VOWEL SIGN OO\nA82C ; Limited_Use # 13.0 SYLOTI NAGRI SIGN ALTERNATE HASANTA\nA880..A8C4 ; Limited_Use # 5.1 [69] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VIRAMA\nA8C5 ; Limited_Use # 9.0 SAURASHTRA SIGN CANDRABINDU\nA8D0..A8D9 ; Limited_Use # 5.1 [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE\nA900..A92D ; Limited_Use # 5.1 [46] KAYAH LI DIGIT ZERO..KAYAH LI TONE CALYA PLOPHU\nA980..A9C0 ; Limited_Use # 5.2 [65] JAVANESE SIGN PANYANGGA..JAVANESE PANGKON\nA9D0..A9D9 ; Limited_Use # 5.2 [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE\nAA00..AA36 ; Limited_Use # 5.1 [55] CHAM LETTER A..CHAM CONSONANT SIGN WA\nAA40..AA4D ; Limited_Use # 5.1 [14] CHAM LETTER FINAL K..CHAM CONSONANT SIGN FINAL H\nAA50..AA59 ; Limited_Use # 5.1 [10] CHAM DIGIT ZERO..CHAM DIGIT NINE\nAA80..AAC2 ; Limited_Use # 5.2 [67] TAI VIET LETTER LOW KO..TAI VIET TONE MAI SONG\nAADB..AADD ; Limited_Use # 5.2 [3] TAI VIET SYMBOL KON..TAI VIET SYMBOL SAM\nAAE0..AAEF ; Limited_Use # 6.1 [16] MEETEI MAYEK LETTER E..MEETEI MAYEK VOWEL SIGN AAU\nAAF2..AAF6 ; Limited_Use # 6.1 [5] MEETEI MAYEK ANJI..MEETEI MAYEK VIRAMA\nAB70..ABBF ; Limited_Use # 8.0 [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA\nABC0..ABEA ; Limited_Use # 5.2 [43] MEETEI MAYEK LETTER KOK..MEETEI MAYEK VOWEL SIGN NUNG\nABEC..ABED ; Limited_Use # 5.2 [2] MEETEI MAYEK LUM IYEK..MEETEI MAYEK APUN IYEK\nABF0..ABF9 ; Limited_Use # 5.2 [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE\n104B0..104D3 ; Limited_Use # 9.0 [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA\n104D8..104FB ; Limited_Use # 9.0 [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA\n10D00..10D27 ; Limited_Use # 11.0 [40] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA SIGN TASSI\n10D30..10D39 ; Limited_Use # 11.0 [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE\n11100..11134 ; Limited_Use # 6.1 [53] CHAKMA SIGN CANDRABINDU..CHAKMA MAAYYAA\n11136..1113F ; Limited_Use # 6.1 [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE\n11144..11146 ; Limited_Use # 11.0 [3] CHAKMA LETTER LHAA..CHAKMA VOWEL SIGN EI\n11147 ; Limited_Use # 13.0 CHAKMA LETTER VAA\n11400..1144A ; Limited_Use # 9.0 [75] NEWA LETTER A..NEWA SIDDHI\n11450..11459 ; Limited_Use # 9.0 [10] NEWA DIGIT ZERO..NEWA DIGIT NINE\n1145E ; Limited_Use # 11.0 NEWA SANDHI MARK\n1145F ; Limited_Use # 12.0 NEWA LETTER VEDIC ANUSVARA\n11460..11461 ; Limited_Use # 13.0 [2] NEWA SIGN JIHVAMULIYA..NEWA SIGN UPADHMANIYA\n11AB0..11ABF ; Limited_Use # 14.0 [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA\n11FB0 ; Limited_Use # 13.0 LISU LETTER YHA\n16800..16A38 ; Limited_Use # 6.0 [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ\n16F00..16F44 ; Limited_Use # 6.1 [69] MIAO LETTER PA..MIAO LETTER HHA\n16F45..16F4A ; Limited_Use # 12.0 [6] MIAO LETTER BRI..MIAO LETTER RTE\n16F4F ; Limited_Use # 12.0 MIAO SIGN CONSONANT MODIFIER BAR\n16F50..16F7E ; Limited_Use # 6.1 [47] MIAO LETTER NASALIZATION..MIAO VOWEL SIGN NG\n16F7F..16F87 ; Limited_Use # 12.0 [9] MIAO VOWEL SIGN UOG..MIAO VOWEL SIGN UI\n16F8F..16F9F ; Limited_Use # 6.1 [17] MIAO TONE RIGHT..MIAO LETTER REFORMED TONE-8\n1E100..1E12C ; Limited_Use # 12.0 [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W\n1E130..1E13D ; Limited_Use # 12.0 [14] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER\n1E140..1E149 ; Limited_Use # 12.0 [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE\n1E14E ; Limited_Use # 12.0 NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ\n1E2C0..1E2F9 ; Limited_Use # 12.0 [58] WANCHO LETTER AA..WANCHO DIGIT NINE\n1E900..1E94A ; Limited_Use # 9.0 [75] ADLAM CAPITAL LETTER ALIF..ADLAM NUKTA\n1E94B ; Limited_Use # 12.0 ADLAM NASALIZATION MARK\n1E950..1E959 ; Limited_Use # 9.0 [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE\n\n# Total code points: 5044\n\n#\tIdentifier_Type:\tLimited_Use Uncommon_Use\n\nA9CF ; Limited_Use Uncommon_Use # 5.2 JAVANESE PANGRANGKEP\n\n# Total code points: 1\n\n#\tIdentifier_Type:\tLimited_Use Technical\n\n0740..074A ; Limited_Use Technical # 3.0 [11] SYRIAC FEMININE DOT..SYRIAC BARREKH\n1B6B..1B73 ; Limited_Use Technical # 5.0 [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG\n1DFA ; Limited_Use Technical # 14.0 COMBINING DOT BELOW LEFT\n\n# Total code points: 21\n\n#\tIdentifier_Type:\tLimited_Use Obsolete\n\n07E8..07EA ; Limited_Use Obsolete # 5.0 [3] NKO LETTER JONA JA..NKO LETTER JONA RA\n07FA ; Limited_Use Obsolete # 5.0 NKO LAJANYALAN\n312E ; Limited_Use Obsolete # 10.0 BOPOMOFO LETTER O WITH DOT ABOVE\nA610..A612 ; Limited_Use Obsolete # 5.1 [3] VAI SYLLABLE NDOLE FA..VAI SYLLABLE NDOLE SOO\nA62A..A62B ; Limited_Use Obsolete # 5.1 [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO\n\n# Total code points: 10\n\n#\tIdentifier_Type:\tLimited_Use Not_XID\n\n02EA..02EB ; Limited_Use Not_XID # 3.0 [2] MODIFIER LETTER YIN DEPARTING TONE MARK..MODIFIER LETTER YANG DEPARTING TONE MARK\n0700..070D ; Limited_Use Not_XID # 3.0 [14] SYRIAC END OF PARAGRAPH..SYRIAC HARKLEAN ASTERISCUS\n070F ; Limited_Use Not_XID # 3.0 SYRIAC ABBREVIATION MARK\n07F6..07F9 ; Limited_Use Not_XID # 5.0 [4] NKO SYMBOL OO DENNEN..NKO EXCLAMATION MARK\n07FE..07FF ; Limited_Use Not_XID # 11.0 [2] NKO DOROME SIGN..NKO TAMAN SIGN\n085E ; Limited_Use Not_XID # 6.0 MANDAIC PUNCTUATION\n1400 ; Limited_Use Not_XID # 5.2 CANADIAN SYLLABICS HYPHEN\n166D..166E ; Limited_Use Not_XID # 3.0 [2] CANADIAN SYLLABICS CHI SIGN..CANADIAN SYLLABICS FULL STOP\n1940 ; Limited_Use Not_XID # 4.0 LIMBU SIGN LOO\n1944..1945 ; Limited_Use Not_XID # 4.0 [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK\n19DE..19DF ; Limited_Use Not_XID # 4.1 [2] NEW TAI LUE SIGN LAE..NEW TAI LUE SIGN LAEV\n1AA0..1AA6 ; Limited_Use Not_XID # 5.2 [7] TAI THAM SIGN WIANG..TAI THAM SIGN REVERSED ROTATED RANA\n1AA8..1AAD ; Limited_Use Not_XID # 5.2 [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG\n1B4E..1B4F ; Limited_Use Not_XID # 16.0 [2] BALINESE INVERTED CARIK SIKI..BALINESE INVERTED CARIK PAREREN\n1B5A..1B6A ; Limited_Use Not_XID # 5.0 [17] BALINESE PANTI..BALINESE MUSICAL SYMBOL DANG GEDE\n1B74..1B7C ; Limited_Use Not_XID # 5.0 [9] BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG..BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING\n1B7D..1B7E ; Limited_Use Not_XID # 14.0 [2] BALINESE PANTI LANTANG..BALINESE PAMADA LANTANG\n1B7F ; Limited_Use Not_XID # 16.0 BALINESE PANTI BAWAK\n1BFC..1BFF ; Limited_Use Not_XID # 6.0 [4] BATAK SYMBOL BINDU NA METEK..BATAK SYMBOL BINDU PANGOLAT\n1C3B..1C3F ; Limited_Use Not_XID # 5.1 [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK\n1C7E..1C7F ; Limited_Use Not_XID # 5.1 [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD\n1CC0..1CC7 ; Limited_Use Not_XID # 6.1 [8] SUNDANESE PUNCTUATION BINDU SURYA..SUNDANESE PUNCTUATION BINDU BA SATANGA\n2D70 ; Limited_Use Not_XID # 6.0 TIFINAGH SEPARATOR MARK\nA490..A4A1 ; Limited_Use Not_XID # 3.0 [18] YI RADICAL QOT..YI RADICAL GA\nA4A2..A4A3 ; Limited_Use Not_XID # 3.2 [2] YI RADICAL ZUP..YI RADICAL CYT\nA4A4..A4B3 ; Limited_Use Not_XID # 3.0 [16] YI RADICAL DDUR..YI RADICAL JO\nA4B4 ; Limited_Use Not_XID # 3.2 YI RADICAL NZUP\nA4B5..A4C0 ; Limited_Use Not_XID # 3.0 [12] YI RADICAL JJY..YI RADICAL SHAT\nA4C1 ; Limited_Use Not_XID # 3.2 YI RADICAL ZUR\nA4C2..A4C4 ; Limited_Use Not_XID # 3.0 [3] YI RADICAL SHOP..YI RADICAL ZZIET\nA4C5 ; Limited_Use Not_XID # 3.2 YI RADICAL NBIE\nA4C6 ; Limited_Use Not_XID # 3.0 YI RADICAL KE\nA4FE..A4FF ; Limited_Use Not_XID # 5.2 [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP\nA60D..A60F ; Limited_Use Not_XID # 5.1 [3] VAI COMMA..VAI QUESTION MARK\nA6F2..A6F7 ; Limited_Use Not_XID # 5.2 [6] BAMUM NJAEMLI..BAMUM QUESTION MARK\nA828..A82B ; Limited_Use Not_XID # 4.1 [4] SYLOTI NAGRI POETRY MARK-1..SYLOTI NAGRI POETRY MARK-4\nA8CE..A8CF ; Limited_Use Not_XID # 5.1 [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA\nA92F ; Limited_Use Not_XID # 5.1 KAYAH LI SIGN SHYA\nA9C1..A9CD ; Limited_Use Not_XID # 5.2 [13] JAVANESE LEFT RERENGGAN..JAVANESE TURNED PADA PISELEH\nA9DE..A9DF ; Limited_Use Not_XID # 5.2 [2] JAVANESE PADA TIRTA TUMETES..JAVANESE PADA ISEN-ISEN\nAA5C..AA5F ; Limited_Use Not_XID # 5.1 [4] CHAM PUNCTUATION SPIRAL..CHAM PUNCTUATION TRIPLE DANDA\nAADE..AADF ; Limited_Use Not_XID # 5.2 [2] TAI VIET SYMBOL HO HOI..TAI VIET SYMBOL KOI KOI\nAAF0..AAF1 ; Limited_Use Not_XID # 6.1 [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM\nABEB ; Limited_Use Not_XID # 5.2 MEETEI MAYEK CHEIKHEI\n11140..11143 ; Limited_Use Not_XID # 6.1 [4] CHAKMA SECTION MARK..CHAKMA QUESTION MARK\n1144B..1144F ; Limited_Use Not_XID # 9.0 [5] NEWA DANDA..NEWA ABBREVIATION SIGN\n1145A ; Limited_Use Not_XID # 13.0 NEWA DOUBLE COMMA\n1145B ; Limited_Use Not_XID # 9.0 NEWA PLACEHOLDER MARK\n1145D ; Limited_Use Not_XID # 9.0 NEWA INSERTION SIGN\n1E14F ; Limited_Use Not_XID # 12.0 NYIAKENG PUACHUE HMONG CIRCLED CA\n1E2FF ; Limited_Use Not_XID # 12.0 WANCHO NGUN SIGN\n1E95E..1E95F ; Limited_Use Not_XID # 9.0 [2] ADLAM INITIAL EXCLAMATION MARK..ADLAM INITIAL QUESTION MARK\n\n# Total code points: 209\n\n#\tIdentifier_Type:\tUncommon_Use\n\n0114..0115 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER E WITH BREVE..LATIN SMALL LETTER E WITH BREVE\n012C..012D ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER I WITH BREVE..LATIN SMALL LETTER I WITH BREVE\n014E..014F ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER O WITH BREVE..LATIN SMALL LETTER O WITH BREVE\n0156..0157 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER R WITH CEDILLA..LATIN SMALL LETTER R WITH CEDILLA\n0162..0163 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER T WITH CEDILLA..LATIN SMALL LETTER T WITH CEDILLA\n0182..0185 ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER B WITH TOPBAR..LATIN SMALL LETTER TONE SIX\n0187..0188 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER C WITH HOOK..LATIN SMALL LETTER C WITH HOOK\n018B..018C ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER D WITH TOPBAR..LATIN SMALL LETTER D WITH TOPBAR\n0193 ; Uncommon_Use # 1.1 LATIN CAPITAL LETTER G WITH HOOK\n0195 ; Uncommon_Use # 1.1 LATIN SMALL LETTER HV\n019A..019C ; Uncommon_Use # 1.1 [3] LATIN SMALL LETTER L WITH BAR..LATIN CAPITAL LETTER TURNED M\n019E..019F ; Uncommon_Use # 1.1 [2] LATIN SMALL LETTER N WITH LONG RIGHT LEG..LATIN CAPITAL LETTER O WITH MIDDLE TILDE\n01A2..01A9 ; Uncommon_Use # 1.1 [8] LATIN CAPITAL LETTER OI..LATIN CAPITAL LETTER ESH\n01AC..01AE ; Uncommon_Use # 1.1 [3] LATIN CAPITAL LETTER T WITH HOOK..LATIN CAPITAL LETTER T WITH RETROFLEX HOOK\n01B1 ; Uncommon_Use # 1.1 LATIN CAPITAL LETTER UPSILON\n01B5..01B6 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER Z WITH STROKE..LATIN SMALL LETTER Z WITH STROKE\n01B8 ; Uncommon_Use # 1.1 LATIN CAPITAL LETTER EZH REVERSED\n01BC..01BD ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER TONE FIVE..LATIN SMALL LETTER TONE FIVE\n01D5..01DC ; Uncommon_Use # 1.1 [8] LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON..LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE\n01DE..01E5 ; Uncommon_Use # 1.1 [8] LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON..LATIN SMALL LETTER G WITH STROKE\n01EA..01ED ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER O WITH OGONEK..LATIN SMALL LETTER O WITH OGONEK AND MACRON\n01F0 ; Uncommon_Use # 1.1 LATIN SMALL LETTER J WITH CARON\n01F4..01F5 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER G WITH ACUTE..LATIN SMALL LETTER G WITH ACUTE\n01FA..01FF ; Uncommon_Use # 1.1 [6] LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE..LATIN SMALL LETTER O WITH STROKE AND ACUTE\n021E..021F ; Uncommon_Use # 3.0 [2] LATIN CAPITAL LETTER H WITH CARON..LATIN SMALL LETTER H WITH CARON\n0220 ; Uncommon_Use # 3.2 LATIN CAPITAL LETTER N WITH LONG RIGHT LEG\n0221 ; Uncommon_Use # 4.0 LATIN SMALL LETTER D WITH CURL\n0222..0233 ; Uncommon_Use # 3.0 [18] LATIN CAPITAL LETTER OU..LATIN SMALL LETTER Y WITH MACRON\n0237..0241 ; Uncommon_Use # 4.1 [11] LATIN SMALL LETTER DOTLESS J..LATIN CAPITAL LETTER GLOTTAL STOP\n0242..0243 ; Uncommon_Use # 5.0 [2] LATIN SMALL LETTER GLOTTAL STOP..LATIN CAPITAL LETTER B WITH STROKE\n0245..024B ; Uncommon_Use # 5.0 [7] LATIN CAPITAL LETTER TURNED V..LATIN SMALL LETTER Q WITH HOOK TAIL\n024E..024F ; Uncommon_Use # 5.0 [2] LATIN CAPITAL LETTER Y WITH STROKE..LATIN SMALL LETTER Y WITH STROKE\n0305 ; Uncommon_Use # 1.1 COMBINING OVERLINE\n030D ; Uncommon_Use # 1.1 COMBINING VERTICAL LINE ABOVE\n0316 ; Uncommon_Use # 1.1 COMBINING GRAVE ACCENT BELOW\n0321..0322 ; Uncommon_Use # 1.1 [2] COMBINING PALATALIZED HOOK BELOW..COMBINING RETROFLEX HOOK BELOW\n0332 ; Uncommon_Use # 1.1 COMBINING LOW LINE\n0334 ; Uncommon_Use # 1.1 COMBINING TILDE OVERLAY\n0336 ; Uncommon_Use # 1.1 COMBINING LONG STROKE OVERLAY\n0358 ; Uncommon_Use # 4.1 COMBINING DOT ABOVE RIGHT\n0400 ; Uncommon_Use # 3.0 CYRILLIC CAPITAL LETTER IE WITH GRAVE\n040D ; Uncommon_Use # 3.0 CYRILLIC CAPITAL LETTER I WITH GRAVE\n0450 ; Uncommon_Use # 3.0 CYRILLIC SMALL LETTER IE WITH GRAVE\n045D ; Uncommon_Use # 3.0 CYRILLIC SMALL LETTER I WITH GRAVE\n048A..048B ; Uncommon_Use # 3.2 [2] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER SHORT I WITH TAIL\n048C..048F ; Uncommon_Use # 3.0 [4] CYRILLIC CAPITAL LETTER SEMISOFT SIGN..CYRILLIC SMALL LETTER ER WITH TICK\n04C1..04C4 ; Uncommon_Use # 1.1 [4] CYRILLIC CAPITAL LETTER ZHE WITH BREVE..CYRILLIC SMALL LETTER KA WITH HOOK\n04C5..04C6 ; Uncommon_Use # 3.2 [2] CYRILLIC CAPITAL LETTER EL WITH TAIL..CYRILLIC SMALL LETTER EL WITH TAIL\n04C7..04C8 ; Uncommon_Use # 1.1 [2] CYRILLIC CAPITAL LETTER EN WITH HOOK..CYRILLIC SMALL LETTER EN WITH HOOK\n04C9..04CA ; Uncommon_Use # 3.2 [2] CYRILLIC CAPITAL LETTER EN WITH TAIL..CYRILLIC SMALL LETTER EN WITH TAIL\n04CB..04CC ; Uncommon_Use # 1.1 [2] CYRILLIC CAPITAL LETTER KHAKASSIAN CHE..CYRILLIC SMALL LETTER KHAKASSIAN CHE\n04CD..04CE ; Uncommon_Use # 3.2 [2] CYRILLIC CAPITAL LETTER EM WITH TAIL..CYRILLIC SMALL LETTER EM WITH TAIL\n04DA..04DB ; Uncommon_Use # 1.1 [2] CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS..CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS\n04EA..04EB ; Uncommon_Use # 1.1 [2] CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS..CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS\n04EC..04ED ; Uncommon_Use # 3.0 [2] CYRILLIC CAPITAL LETTER E WITH DIAERESIS..CYRILLIC SMALL LETTER E WITH DIAERESIS\n04F6..04F7 ; Uncommon_Use # 4.1 [2] CYRILLIC CAPITAL LETTER GHE WITH DESCENDER..CYRILLIC SMALL LETTER GHE WITH DESCENDER\n04FA..04FF ; Uncommon_Use # 5.0 [6] CYRILLIC CAPITAL LETTER GHE WITH STROKE AND HOOK..CYRILLIC SMALL LETTER HA WITH STROKE\n0510..0513 ; Uncommon_Use # 5.0 [4] CYRILLIC CAPITAL LETTER REVERSED ZE..CYRILLIC SMALL LETTER EL WITH HOOK\n0591..05A1 ; Uncommon_Use # 2.0 [17] HEBREW ACCENT ETNAHTA..HEBREW ACCENT PAZER\n05A3..05AF ; Uncommon_Use # 2.0 [13] HEBREW ACCENT MUNAH..HEBREW MARK MASORA CIRCLE\n05B0..05B9 ; Uncommon_Use # 1.1 [10] HEBREW POINT SHEVA..HEBREW POINT HOLAM\n05BA ; Uncommon_Use # 5.0 HEBREW POINT HOLAM HASER FOR VAV\n05BB..05BD ; Uncommon_Use # 1.1 [3] HEBREW POINT QUBUTS..HEBREW POINT METEG\n05BF ; Uncommon_Use # 1.1 HEBREW POINT RAFE\n05C1..05C2 ; Uncommon_Use # 1.1 [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT\n05C4 ; Uncommon_Use # 2.0 HEBREW MARK UPPER DOT\n05EF ; Uncommon_Use # 11.0 HEBREW YOD TRIANGLE\n05F0..05F2 ; Uncommon_Use # 1.1 [3] HEBREW LIGATURE YIDDISH DOUBLE VAV..HEBREW LIGATURE YIDDISH DOUBLE YOD\n0610..0615 ; Uncommon_Use # 4.0 [6] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL HIGH TAH\n0616..061A ; Uncommon_Use # 5.1 [5] ARABIC SMALL HIGH LIGATURE ALEF WITH LAM WITH YEH..ARABIC SMALL KASRA\n0656..0658 ; Uncommon_Use # 4.0 [3] ARABIC SUBSCRIPT ALEF..ARABIC MARK NOON GHUNNA\n0659..065E ; Uncommon_Use # 4.1 [6] ARABIC ZWARAKAY..ARABIC FATHA WITH TWO DOTS\n065F ; Uncommon_Use # 6.0 ARABIC WAVY HAMZA BELOW\n069B..069E ; Uncommon_Use # 1.1 [4] ARABIC LETTER SEEN WITH THREE DOTS BELOW..ARABIC LETTER SAD WITH THREE DOTS ABOVE\n06A1 ; Uncommon_Use # 1.1 ARABIC LETTER DOTLESS FEH\n06A3 ; Uncommon_Use # 1.1 ARABIC LETTER FEH WITH DOT BELOW\n06B2 ; Uncommon_Use # 1.1 ARABIC LETTER GAF WITH TWO DOTS BELOW\n06B4 ; Uncommon_Use # 1.1 ARABIC LETTER GAF WITH THREE DOTS ABOVE\n06B8..06B9 ; Uncommon_Use # 3.0 [2] ARABIC LETTER LAM WITH THREE DOTS BELOW..ARABIC LETTER NOON WITH DOT BELOW\n06BF ; Uncommon_Use # 3.0 ARABIC LETTER TCHEH WITH DOT ABOVE\n06D6..06DC ; Uncommon_Use # 1.1 [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN\n06DF..06E4 ; Uncommon_Use # 1.1 [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA\n06E7..06E8 ; Uncommon_Use # 1.1 [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON\n06EA..06ED ; Uncommon_Use # 1.1 [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM\n06FA..06FC ; Uncommon_Use # 3.0 [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW\n0750 ; Uncommon_Use # 4.1 ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW\n0753..0755 ; Uncommon_Use # 4.1 [3] ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW AND TWO DOTS ABOVE..ARABIC LETTER BEH WITH INVERTED SMALL V BELOW\n0757..075F ; Uncommon_Use # 4.1 [9] ARABIC LETTER HAH WITH TWO DOTS ABOVE..ARABIC LETTER AIN WITH TWO DOTS VERTICALLY ABOVE\n0761 ; Uncommon_Use # 4.1 ARABIC LETTER FEH WITH THREE DOTS POINTING UPWARDS BELOW\n0764..0765 ; Uncommon_Use # 4.1 [2] ARABIC LETTER KEHEH WITH THREE DOTS POINTING UPWARDS BELOW..ARABIC LETTER MEEM WITH DOT ABOVE\n0769 ; Uncommon_Use # 4.1 ARABIC LETTER NOON WITH SMALL V\n076B..076D ; Uncommon_Use # 4.1 [3] ARABIC LETTER REH WITH TWO DOTS VERTICALLY ABOVE..ARABIC LETTER SEEN WITH TWO DOTS VERTICALLY ABOVE\n0772..077D ; Uncommon_Use # 5.1 [12] ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH ABOVE..ARABIC LETTER SEEN WITH EXTENDED ARABIC-INDIC DIGIT FOUR ABOVE\n0889..088D ; Uncommon_Use # 14.0 [5] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC LETTER KEHEH WITH TWO DOTS VERTICALLY BELOW\n0897 ; Uncommon_Use # 16.0 ARABIC PEPET\n0898..089F ; Uncommon_Use # 14.0 [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA\n08A1 ; Uncommon_Use # 7.0 ARABIC LETTER BEH WITH HAMZA ABOVE\n08AA..08AC ; Uncommon_Use # 6.1 [3] ARABIC LETTER REH WITH LOOP..ARABIC LETTER ROHINGYA YEH\n08B2 ; Uncommon_Use # 7.0 ARABIC LETTER ZAIN WITH INVERTED V ABOVE\n08B3..08B4 ; Uncommon_Use # 8.0 [2] ARABIC LETTER AIN WITH THREE DOTS BELOW..ARABIC LETTER KAF WITH DOT BELOW\n08B6..08BA ; Uncommon_Use # 9.0 [5] ARABIC LETTER BEH WITH SMALL MEEM ABOVE..ARABIC LETTER YEH WITH TWO DOTS BELOW AND SMALL NOON ABOVE\n08C3..08C6 ; Uncommon_Use # 13.0 [4] ARABIC LETTER GHAIN WITH THREE DOTS ABOVE..ARABIC LETTER JEEM WITH THREE DOTS BELOW\n08C8 ; Uncommon_Use # 14.0 ARABIC LETTER GRAF\n08CA..08D2 ; Uncommon_Use # 14.0 [9] ARABIC SMALL HIGH FARSI YEH..ARABIC LARGE ROUND DOT INSIDE CIRCLE BELOW\n08D3 ; Uncommon_Use # 11.0 ARABIC SMALL LOW WAW\n08D4..08E1 ; Uncommon_Use # 9.0 [14] ARABIC SMALL HIGH WORD AR-RUB..ARABIC SMALL HIGH SIGN SAFHA\n08E3 ; Uncommon_Use # 8.0 ARABIC TURNED DAMMA BELOW\n08E4..08FE ; Uncommon_Use # 6.1 [27] ARABIC CURLY FATHA..ARABIC DAMMA WITH DOT\n08FF ; Uncommon_Use # 7.0 ARABIC MARK SIDEWAYS NOON GHUNNA\n0900 ; Uncommon_Use # 5.2 DEVANAGARI SIGN INVERTED CANDRABINDU\n0904 ; Uncommon_Use # 4.0 DEVANAGARI LETTER SHORT A\n0929 ; Uncommon_Use # 1.1 DEVANAGARI LETTER NNNA\n0934 ; Uncommon_Use # 1.1 DEVANAGARI LETTER LLLA\n0944 ; Uncommon_Use # 1.1 DEVANAGARI VOWEL SIGN VOCALIC RR\n0955 ; Uncommon_Use # 5.2 DEVANAGARI VOWEL SIGN CANDRA LONG E\n0979..097A ; Uncommon_Use # 5.2 [2] DEVANAGARI LETTER ZHA..DEVANAGARI LETTER HEAVY YA\n098C ; Uncommon_Use # 1.1 BENGALI LETTER VOCALIC L\n09D7 ; Uncommon_Use # 1.1 BENGALI AU LENGTH MARK\n09FE ; Uncommon_Use # 11.0 BENGALI SANDHI MARK\n0A01 ; Uncommon_Use # 4.0 GURMUKHI SIGN ADAK BINDI\n0A03 ; Uncommon_Use # 4.0 GURMUKHI SIGN VISARGA\n0A51 ; Uncommon_Use # 5.1 GURMUKHI SIGN UDAAT\n0A66..0A6F ; Uncommon_Use # 1.1 [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE\n0A72..0A73 ; Uncommon_Use # 1.1 [2] GURMUKHI IRI..GURMUKHI URA\n0A75 ; Uncommon_Use # 5.1 GURMUKHI SIGN YAKASH\n0A81 ; Uncommon_Use # 1.1 GUJARATI SIGN CANDRABINDU\n0AF9 ; Uncommon_Use # 8.0 GUJARATI LETTER ZHA\n0AFA..0AFF ; Uncommon_Use # 10.0 [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE\n0B0C ; Uncommon_Use # 1.1 ORIYA LETTER VOCALIC L\n0B35 ; Uncommon_Use # 4.0 ORIYA LETTER VA\n0B44 ; Uncommon_Use # 5.1 ORIYA VOWEL SIGN VOCALIC RR\n0B55 ; Uncommon_Use # 13.0 ORIYA SIGN OVERLINE\n0B57 ; Uncommon_Use # 1.1 ORIYA AU LENGTH MARK\n0B62..0B63 ; Uncommon_Use # 5.1 [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL\n0B66..0B6F ; Uncommon_Use # 1.1 [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE\n0BD7 ; Uncommon_Use # 1.1 TAMIL AU LENGTH MARK\n0BE6 ; Uncommon_Use # 4.1 TAMIL DIGIT ZERO\n0BE7..0BEF ; Uncommon_Use # 1.1 [9] TAMIL DIGIT ONE..TAMIL DIGIT NINE\n0C01 ; Uncommon_Use # 1.1 TELUGU SIGN CANDRABINDU\n0C04 ; Uncommon_Use # 11.0 TELUGU SIGN COMBINING ANUSVARA ABOVE\n0C0C ; Uncommon_Use # 1.1 TELUGU LETTER VOCALIC L\n0C31 ; Uncommon_Use # 1.1 TELUGU LETTER RRA\n0C3C ; Uncommon_Use # 14.0 TELUGU SIGN NUKTA\n0C55..0C56 ; Uncommon_Use # 1.1 [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK\n0C5A ; Uncommon_Use # 8.0 TELUGU LETTER RRRA\n0C5D ; Uncommon_Use # 14.0 TELUGU LETTER NAKAARA POLLU\n0C62..0C63 ; Uncommon_Use # 5.1 [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL\n0C66..0C6F ; Uncommon_Use # 1.1 [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE\n0C80 ; Uncommon_Use # 9.0 KANNADA SIGN SPACING CANDRABINDU\n0CBC ; Uncommon_Use # 4.0 KANNADA SIGN NUKTA\n0CC4 ; Uncommon_Use # 1.1 KANNADA VOWEL SIGN VOCALIC RR\n0CD5..0CD6 ; Uncommon_Use # 1.1 [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK\n0CDD ; Uncommon_Use # 14.0 KANNADA LETTER NAKAARA POLLU\n0CF3 ; Uncommon_Use # 15.0 KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT\n0D00 ; Uncommon_Use # 10.0 MALAYALAM SIGN COMBINING ANUSVARA ABOVE\n0D0C ; Uncommon_Use # 1.1 MALAYALAM LETTER VOCALIC L\n0D29 ; Uncommon_Use # 6.0 MALAYALAM LETTER NNNA\n0D44 ; Uncommon_Use # 5.1 MALAYALAM VOWEL SIGN VOCALIC RR\n0D54..0D56 ; Uncommon_Use # 9.0 [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL\n0D62..0D63 ; Uncommon_Use # 5.1 [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL\n0D66..0D6F ; Uncommon_Use # 1.1 [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE\n0D8E ; Uncommon_Use # 3.0 SINHALA LETTER IRUUYANNA\n0DE6..0DEF ; Uncommon_Use # 7.0 [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE\n0E4E ; Uncommon_Use # 1.1 THAI CHARACTER YAMAKKAN\n0E86 ; Uncommon_Use # 12.0 LAO LETTER PALI GHA\n0E89 ; Uncommon_Use # 12.0 LAO LETTER PALI CHA\n0E8C ; Uncommon_Use # 12.0 LAO LETTER PALI JHA\n0E8E..0E93 ; Uncommon_Use # 12.0 [6] LAO LETTER PALI NYA..LAO LETTER PALI NNA\n0E98 ; Uncommon_Use # 12.0 LAO LETTER PALI DHA\n0EA0 ; Uncommon_Use # 12.0 LAO LETTER PALI BHA\n0EA8..0EA9 ; Uncommon_Use # 12.0 [2] LAO LETTER SANSKRIT SHA..LAO LETTER SANSKRIT SSA\n0EAC ; Uncommon_Use # 12.0 LAO LETTER PALI LLA\n0EBA ; Uncommon_Use # 12.0 LAO SIGN PALI VIRAMA\n0ECE ; Uncommon_Use # 15.0 LAO YAMAKKAN\n0EDE..0EDF ; Uncommon_Use # 6.1 [2] LAO LETTER KHMU GO..LAO LETTER KHMU NYO\n0F39 ; Uncommon_Use # 2.0 TIBETAN MARK TSA -PHRU\n0F6B..0F6C ; Uncommon_Use # 5.1 [2] TIBETAN LETTER KKA..TIBETAN LETTER RRA\n0FAE..0FB0 ; Uncommon_Use # 3.0 [3] TIBETAN SUBJOINED LETTER ZHA..TIBETAN SUBJOINED LETTER -A\n1065..1074 ; Uncommon_Use # 5.1 [16] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR VOWEL SIGN KAYAH EE\n108B..108E ; Uncommon_Use # 5.1 [4] MYANMAR SIGN SHAN COUNCIL TONE-2..MYANMAR LETTER RUMAI PALAUNG FA\n1090..1099 ; Uncommon_Use # 5.1 [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE\n109A..109D ; Uncommon_Use # 5.2 [4] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON AI\n10F7..10F8 ; Uncommon_Use # 3.2 [2] GEORGIAN LETTER YN..GEORGIAN LETTER ELIFI\n10FD..10FF ; Uncommon_Use # 6.1 [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN\n1207 ; Uncommon_Use # 4.1 ETHIOPIC SYLLABLE HOA\n1287 ; Uncommon_Use # 4.1 ETHIOPIC SYLLABLE XOA\n12AF ; Uncommon_Use # 4.1 ETHIOPIC SYLLABLE KOA\n12F8..12FF ; Uncommon_Use # 3.0 [8] ETHIOPIC SYLLABLE DDA..ETHIOPIC SYLLABLE DDWA\n130F ; Uncommon_Use # 4.1 ETHIOPIC SYLLABLE GOA\n131F ; Uncommon_Use # 4.1 ETHIOPIC SYLLABLE GGWAA\n1347 ; Uncommon_Use # 4.1 ETHIOPIC SYLLABLE TZOA\n135A ; Uncommon_Use # 3.0 ETHIOPIC SYLLABLE FYA\n135D..135E ; Uncommon_Use # 6.0 [2] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING VOWEL LENGTH MARK\n135F ; Uncommon_Use # 4.1 ETHIOPIC COMBINING GEMINATION MARK\n1380..138F ; Uncommon_Use # 4.1 [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE\n179D..179E ; Uncommon_Use # 3.0 [2] KHMER LETTER SHA..KHMER LETTER SSO\n17A9 ; Uncommon_Use # 3.0 KHMER INDEPENDENT VOWEL QUU\n17D7 ; Uncommon_Use # 3.0 KHMER SIGN LEK TOO\n1AC1..1ACE ; Uncommon_Use # 14.0 [14] COMBINING LEFT PARENTHESIS ABOVE LEFT..COMBINING LATIN SMALL LETTER INSULAR T\n1C89..1C8A ; Uncommon_Use # 16.0 [2] CYRILLIC CAPITAL LETTER TJE..CYRILLIC SMALL LETTER TJE\n1E02..1E0B ; Uncommon_Use # 1.1 [10] LATIN CAPITAL LETTER B WITH DOT ABOVE..LATIN SMALL LETTER D WITH DOT ABOVE\n1E0E..1E11 ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER D WITH LINE BELOW..LATIN SMALL LETTER D WITH CEDILLA\n1E14..1E17 ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER E WITH MACRON AND GRAVE..LATIN SMALL LETTER E WITH MACRON AND ACUTE\n1E1C..1E1F ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE..LATIN SMALL LETTER F WITH DOT ABOVE\n1E22..1E23 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER H WITH DOT ABOVE..LATIN SMALL LETTER H WITH DOT ABOVE\n1E26..1E29 ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER H WITH DIAERESIS..LATIN SMALL LETTER H WITH CEDILLA\n1E2E..1E35 ; Uncommon_Use # 1.1 [8] LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE..LATIN SMALL LETTER K WITH LINE BELOW\n1E38..1E3B ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON..LATIN SMALL LETTER L WITH LINE BELOW\n1E40..1E41 ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER M WITH DOT ABOVE..LATIN SMALL LETTER M WITH DOT ABOVE\n1E4C..1E59 ; Uncommon_Use # 1.1 [14] LATIN CAPITAL LETTER O WITH TILDE AND ACUTE..LATIN SMALL LETTER R WITH DOT ABOVE\n1E5C..1E61 ; Uncommon_Use # 1.1 [6] LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON..LATIN SMALL LETTER S WITH DOT ABOVE\n1E64..1E6B ; Uncommon_Use # 1.1 [8] LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE..LATIN SMALL LETTER T WITH DOT ABOVE\n1E6E..1E6F ; Uncommon_Use # 1.1 [2] LATIN CAPITAL LETTER T WITH LINE BELOW..LATIN SMALL LETTER T WITH LINE BELOW\n1E78..1E8B ; Uncommon_Use # 1.1 [20] LATIN CAPITAL LETTER U WITH TILDE AND ACUTE..LATIN SMALL LETTER X WITH DOT ABOVE\n1E8E..1E91 ; Uncommon_Use # 1.1 [4] LATIN CAPITAL LETTER Y WITH DOT ABOVE..LATIN SMALL LETTER Z WITH CIRCUMFLEX\n1E94..1E99 ; Uncommon_Use # 1.1 [6] LATIN CAPITAL LETTER Z WITH LINE BELOW..LATIN SMALL LETTER Y WITH RING ABOVE\n2054 ; Uncommon_Use # 4.0 INVERTED UNDERTIE\n2C68..2C6C ; Uncommon_Use # 5.0 [5] LATIN SMALL LETTER H WITH DESCENDER..LATIN SMALL LETTER Z WITH DESCENDER\n2D80..2D96 ; Uncommon_Use # 4.1 [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE\n2DA0..2DA6 ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO\n2DA8..2DAE ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO\n2DB0..2DB6 ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO\n2DB8..2DBE ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO\n2DC0..2DC6 ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO\n2DC8..2DCE ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO\n2DD0..2DD6 ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO\n2DD8..2DDE ; Uncommon_Use # 4.1 [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO\n3099..309A ; Uncommon_Use # 1.1 [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK\n3400..3446 ; Uncommon_Use # 3.0 [71] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-3446\n3448..3472 ; Uncommon_Use # 3.0 [43] CJK UNIFIED IDEOGRAPH-3448..CJK UNIFIED IDEOGRAPH-3472\n3474..34E3 ; Uncommon_Use # 3.0 [112] CJK UNIFIED IDEOGRAPH-3474..CJK UNIFIED IDEOGRAPH-34E3\n34E5..3576 ; Uncommon_Use # 3.0 [146] CJK UNIFIED IDEOGRAPH-34E5..CJK UNIFIED IDEOGRAPH-3576\n3578..359D ; Uncommon_Use # 3.0 [38] CJK UNIFIED IDEOGRAPH-3578..CJK UNIFIED IDEOGRAPH-359D\n359F..35A0 ; Uncommon_Use # 3.0 [2] CJK UNIFIED IDEOGRAPH-359F..CJK UNIFIED IDEOGRAPH-35A0\n35A2..35AC ; Uncommon_Use # 3.0 [11] CJK UNIFIED IDEOGRAPH-35A2..CJK UNIFIED IDEOGRAPH-35AC\n35AE..35BE ; Uncommon_Use # 3.0 [17] CJK UNIFIED IDEOGRAPH-35AE..CJK UNIFIED IDEOGRAPH-35BE\n35C0..35CD ; Uncommon_Use # 3.0 [14] CJK UNIFIED IDEOGRAPH-35C0..CJK UNIFIED IDEOGRAPH-35CD\n35CF..35F2 ; Uncommon_Use # 3.0 [36] CJK UNIFIED IDEOGRAPH-35CF..CJK UNIFIED IDEOGRAPH-35F2\n35F4..35FD ; Uncommon_Use # 3.0 [10] CJK UNIFIED IDEOGRAPH-35F4..CJK UNIFIED IDEOGRAPH-35FD\n35FF..360D ; Uncommon_Use # 3.0 [15] CJK UNIFIED IDEOGRAPH-35FF..CJK UNIFIED IDEOGRAPH-360D\n360F..3619 ; Uncommon_Use # 3.0 [11] CJK UNIFIED IDEOGRAPH-360F..CJK UNIFIED IDEOGRAPH-3619\n361B..3917 ; Uncommon_Use # 3.0 [765] CJK UNIFIED IDEOGRAPH-361B..CJK UNIFIED IDEOGRAPH-3917\n3919..395F ; Uncommon_Use # 3.0 [71] CJK UNIFIED IDEOGRAPH-3919..CJK UNIFIED IDEOGRAPH-395F\n3961..396D ; Uncommon_Use # 3.0 [13] CJK UNIFIED IDEOGRAPH-3961..CJK UNIFIED IDEOGRAPH-396D\n396F..39CE ; Uncommon_Use # 3.0 [96] CJK UNIFIED IDEOGRAPH-396F..CJK UNIFIED IDEOGRAPH-39CE\n39D1..39DA ; Uncommon_Use # 3.0 [10] CJK UNIFIED IDEOGRAPH-39D1..CJK UNIFIED IDEOGRAPH-39DA\n39DC..39DE ; Uncommon_Use # 3.0 [3] CJK UNIFIED IDEOGRAPH-39DC..CJK UNIFIED IDEOGRAPH-39DE\n39E0..39F7 ; Uncommon_Use # 3.0 [24] CJK UNIFIED IDEOGRAPH-39E0..CJK UNIFIED IDEOGRAPH-39F7\n39F9..39FD ; Uncommon_Use # 3.0 [5] CJK UNIFIED IDEOGRAPH-39F9..CJK UNIFIED IDEOGRAPH-39FD\n39FF..3A17 ; Uncommon_Use # 3.0 [25] CJK UNIFIED IDEOGRAPH-39FF..CJK UNIFIED IDEOGRAPH-3A17\n3A19..3A51 ; Uncommon_Use # 3.0 [57] CJK UNIFIED IDEOGRAPH-3A19..CJK UNIFIED IDEOGRAPH-3A51\n3A53..3A5B ; Uncommon_Use # 3.0 [9] CJK UNIFIED IDEOGRAPH-3A53..CJK UNIFIED IDEOGRAPH-3A5B\n3A5D..3A66 ; Uncommon_Use # 3.0 [10] CJK UNIFIED IDEOGRAPH-3A5D..CJK UNIFIED IDEOGRAPH-3A66\n3A68..3A72 ; Uncommon_Use # 3.0 [11] CJK UNIFIED IDEOGRAPH-3A68..CJK UNIFIED IDEOGRAPH-3A72\n3A74..3B38 ; Uncommon_Use # 3.0 [197] CJK UNIFIED IDEOGRAPH-3A74..CJK UNIFIED IDEOGRAPH-3B38\n3B3A..3B4D ; Uncommon_Use # 3.0 [20] CJK UNIFIED IDEOGRAPH-3B3A..CJK UNIFIED IDEOGRAPH-3B4D\n3B4F..3BA2 ; Uncommon_Use # 3.0 [84] CJK UNIFIED IDEOGRAPH-3B4F..CJK UNIFIED IDEOGRAPH-3BA2\n3BA4..3C6D ; Uncommon_Use # 3.0 [202] CJK UNIFIED IDEOGRAPH-3BA4..CJK UNIFIED IDEOGRAPH-3C6D\n3C6F..3CDF ; Uncommon_Use # 3.0 [113] CJK UNIFIED IDEOGRAPH-3C6F..CJK UNIFIED IDEOGRAPH-3CDF\n3CE1..3DE6 ; Uncommon_Use # 3.0 [262] CJK UNIFIED IDEOGRAPH-3CE1..CJK UNIFIED IDEOGRAPH-3DE6\n3DE8..3DEA ; Uncommon_Use # 3.0 [3] CJK UNIFIED IDEOGRAPH-3DE8..CJK UNIFIED IDEOGRAPH-3DEA\n3DEC..3E73 ; Uncommon_Use # 3.0 [136] CJK UNIFIED IDEOGRAPH-3DEC..CJK UNIFIED IDEOGRAPH-3E73\n3E75..3ECF ; Uncommon_Use # 3.0 [91] CJK UNIFIED IDEOGRAPH-3E75..CJK UNIFIED IDEOGRAPH-3ECF\n3ED1..4055 ; Uncommon_Use # 3.0 [389] CJK UNIFIED IDEOGRAPH-3ED1..CJK UNIFIED IDEOGRAPH-4055\n4057..4064 ; Uncommon_Use # 3.0 [14] CJK UNIFIED IDEOGRAPH-4057..CJK UNIFIED IDEOGRAPH-4064\n4066..4069 ; Uncommon_Use # 3.0 [4] CJK UNIFIED IDEOGRAPH-4066..CJK UNIFIED IDEOGRAPH-4069\n406B..40BA ; Uncommon_Use # 3.0 [80] CJK UNIFIED IDEOGRAPH-406B..CJK UNIFIED IDEOGRAPH-40BA\n40BC..40DE ; Uncommon_Use # 3.0 [35] CJK UNIFIED IDEOGRAPH-40BC..CJK UNIFIED IDEOGRAPH-40DE\n40E0..4136 ; Uncommon_Use # 3.0 [87] CJK UNIFIED IDEOGRAPH-40E0..CJK UNIFIED IDEOGRAPH-4136\n4138..415E ; Uncommon_Use # 3.0 [39] CJK UNIFIED IDEOGRAPH-4138..CJK UNIFIED IDEOGRAPH-415E\n4160..4336 ; Uncommon_Use # 3.0 [471] CJK UNIFIED IDEOGRAPH-4160..CJK UNIFIED IDEOGRAPH-4336\n4338..43AB ; Uncommon_Use # 3.0 [116] CJK UNIFIED IDEOGRAPH-4338..CJK UNIFIED IDEOGRAPH-43AB\n43AD..43B0 ; Uncommon_Use # 3.0 [4] CJK UNIFIED IDEOGRAPH-43AD..CJK UNIFIED IDEOGRAPH-43B0\n43B2..43D2 ; Uncommon_Use # 3.0 [33] CJK UNIFIED IDEOGRAPH-43B2..CJK UNIFIED IDEOGRAPH-43D2\n43D4..43DC ; Uncommon_Use # 3.0 [9] CJK UNIFIED IDEOGRAPH-43D4..CJK UNIFIED IDEOGRAPH-43DC\n43DE..4442 ; Uncommon_Use # 3.0 [101] CJK UNIFIED IDEOGRAPH-43DE..CJK UNIFIED IDEOGRAPH-4442\n4444..44D5 ; Uncommon_Use # 3.0 [146] CJK UNIFIED IDEOGRAPH-4444..CJK UNIFIED IDEOGRAPH-44D5\n44D7..44E9 ; Uncommon_Use # 3.0 [19] CJK UNIFIED IDEOGRAPH-44D7..CJK UNIFIED IDEOGRAPH-44E9\n44EB..4605 ; Uncommon_Use # 3.0 [283] CJK UNIFIED IDEOGRAPH-44EB..CJK UNIFIED IDEOGRAPH-4605\n4607..464B ; Uncommon_Use # 3.0 [69] CJK UNIFIED IDEOGRAPH-4607..CJK UNIFIED IDEOGRAPH-464B\n464D..4660 ; Uncommon_Use # 3.0 [20] CJK UNIFIED IDEOGRAPH-464D..CJK UNIFIED IDEOGRAPH-4660\n4662..4722 ; Uncommon_Use # 3.0 [193] CJK UNIFIED IDEOGRAPH-4662..CJK UNIFIED IDEOGRAPH-4722\n4724..4728 ; Uncommon_Use # 3.0 [5] CJK UNIFIED IDEOGRAPH-4724..CJK UNIFIED IDEOGRAPH-4728\n472A..477B ; Uncommon_Use # 3.0 [82] CJK UNIFIED IDEOGRAPH-472A..CJK UNIFIED IDEOGRAPH-477B\n477D..478C ; Uncommon_Use # 3.0 [16] CJK UNIFIED IDEOGRAPH-477D..CJK UNIFIED IDEOGRAPH-478C\n478E..47F3 ; Uncommon_Use # 3.0 [102] CJK UNIFIED IDEOGRAPH-478E..CJK UNIFIED IDEOGRAPH-47F3\n47F5..4881 ; Uncommon_Use # 3.0 [141] CJK UNIFIED IDEOGRAPH-47F5..CJK UNIFIED IDEOGRAPH-4881\n4883..4946 ; Uncommon_Use # 3.0 [196] CJK UNIFIED IDEOGRAPH-4883..CJK UNIFIED IDEOGRAPH-4946\n4948..4979 ; Uncommon_Use # 3.0 [50] CJK UNIFIED IDEOGRAPH-4948..CJK UNIFIED IDEOGRAPH-4979\n497B..497C ; Uncommon_Use # 3.0 [2] CJK UNIFIED IDEOGRAPH-497B..CJK UNIFIED IDEOGRAPH-497C\n497E..4981 ; Uncommon_Use # 3.0 [4] CJK UNIFIED IDEOGRAPH-497E..CJK UNIFIED IDEOGRAPH-4981\n4984 ; Uncommon_Use # 3.0 CJK UNIFIED IDEOGRAPH-4984\n4987..499A ; Uncommon_Use # 3.0 [20] CJK UNIFIED IDEOGRAPH-4987..CJK UNIFIED IDEOGRAPH-499A\n499C..499E ; Uncommon_Use # 3.0 [3] CJK UNIFIED IDEOGRAPH-499C..CJK UNIFIED IDEOGRAPH-499E\n49A0..49B5 ; Uncommon_Use # 3.0 [22] CJK UNIFIED IDEOGRAPH-49A0..CJK UNIFIED IDEOGRAPH-49B5\n49B8..4A11 ; Uncommon_Use # 3.0 [90] CJK UNIFIED IDEOGRAPH-49B8..CJK UNIFIED IDEOGRAPH-4A11\n4A13..4AB7 ; Uncommon_Use # 3.0 [165] CJK UNIFIED IDEOGRAPH-4A13..CJK UNIFIED IDEOGRAPH-4AB7\n4AB9..4C76 ; Uncommon_Use # 3.0 [446] CJK UNIFIED IDEOGRAPH-4AB9..CJK UNIFIED IDEOGRAPH-4C76\n4C78..4C7C ; Uncommon_Use # 3.0 [5] CJK UNIFIED IDEOGRAPH-4C78..CJK UNIFIED IDEOGRAPH-4C7C\n4C7E..4C80 ; Uncommon_Use # 3.0 [3] CJK UNIFIED IDEOGRAPH-4C7E..CJK UNIFIED IDEOGRAPH-4C80\n4C82..4C84 ; Uncommon_Use # 3.0 [3] CJK UNIFIED IDEOGRAPH-4C82..CJK UNIFIED IDEOGRAPH-4C84\n4C86..4C9C ; Uncommon_Use # 3.0 [23] CJK UNIFIED IDEOGRAPH-4C86..CJK UNIFIED IDEOGRAPH-4C9C\n4CA4..4D12 ; Uncommon_Use # 3.0 [111] CJK UNIFIED IDEOGRAPH-4CA4..CJK UNIFIED IDEOGRAPH-4D12\n4D1A..4DAD ; Uncommon_Use # 3.0 [148] CJK UNIFIED IDEOGRAPH-4D1A..CJK UNIFIED IDEOGRAPH-4DAD\n4DAF..4DB5 ; Uncommon_Use # 3.0 [7] CJK UNIFIED IDEOGRAPH-4DAF..CJK UNIFIED IDEOGRAPH-4DB5\n4DB6..4DBF ; Uncommon_Use # 13.0 [10] CJK UNIFIED IDEOGRAPH-4DB6..CJK UNIFIED IDEOGRAPH-4DBF\n4E12 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4E12\n4E29 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4E29\n4E68 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4E68\n4E79 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4E79\n4E96 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4E96\n4EA3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4EA3\n4EBC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4EBC\n4ECC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4ECC\n4EE7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4EE7\n4EF8..4EFA ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-4EF8..CJK UNIFIED IDEOGRAPH-4EFA\n4EFC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4EFC\n4EFE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4EFE\n4F07 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F07\n4F16 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F16\n4F28 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F28\n4F31 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F31\n4F35 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F35\n4F37 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F37\n4F40 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F40\n4F44 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F44\n4F71 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F71\n4F8C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F8C\n4F8E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4F8E\n4FA2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4FA2\n4FBD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4FBD\n4FC6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4FC6\n4FC8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4FC8\n4FCC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4FCC\n4FE2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-4FE2\n4FFC..4FFD ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-4FFC..CJK UNIFIED IDEOGRAPH-4FFD\n5010 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5010\n5034 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5034\n5038 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5038\n503D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-503D\n5042 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5042\n5052 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5052\n5058 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5058\n507C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-507C\n5081 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5081\n5093 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5093\n5097 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5097\n509F..50A1 ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-509F..CJK UNIFIED IDEOGRAPH-50A1\n50B9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-50B9\n50C3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-50C3\n50D8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-50D8\n50DF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-50DF\n50E1..50E2 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-50E1..CJK UNIFIED IDEOGRAPH-50E2\n50EB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-50EB\n50F4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-50F4\n50F7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-50F7\n511B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-511B\n5128 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5128\n512B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-512B\n5142 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5142\n514A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-514A\n514F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-514F\n5153 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5153\n5158 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5158\n5160 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5160\n5164 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5164\n5172 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5172\n517E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-517E\n5183..5184 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5183..CJK UNIFIED IDEOGRAPH-5184\n518E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-518E\n51A1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51A1\n51A3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51A3\n51AD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51AD\n51B8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51B8\n51BA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51BA\n51C2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51C2\n51D2..51D3 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-51D2..CJK UNIFIED IDEOGRAPH-51D3\n51DF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51DF\n51EC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51EC\n51EE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51EE\n51F2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-51F2\n5253 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5253\n5266 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5266\n5279 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5279\n5285 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5285\n528E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-528E\n52C4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52C4\n52C8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52C8\n52CC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52CC\n52CE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52CE\n52D1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52D1\n52D4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52D4\n52E1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52E1\n52E5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52E5\n52EE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-52EE\n5303..5304 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5303..CJK UNIFIED IDEOGRAPH-5304\n5318 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5318\n531B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-531B\n531E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-531E\n5327 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5327\n5329 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5329\n5332 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5332\n5335..5336 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5335..CJK UNIFIED IDEOGRAPH-5336\n5342 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5342\n535B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-535B\n535D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-535D\n536A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-536A\n536D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-536D\n5380 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5380\n53A1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-53A1\n53AA..53AB ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-53AA..CJK UNIFIED IDEOGRAPH-53AB\n53AF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-53AF\n53BA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-53BA\n53C5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-53C5\n53CF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-53CF\n53DD..53DE ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-53DD..CJK UNIFIED IDEOGRAPH-53DE\n53E7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-53E7\n53FF..5400 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-53FF..CJK UNIFIED IDEOGRAPH-5400\n541A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-541A\n5422 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5422\n544C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-544C\n545D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-545D\n5469 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5469\n548A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-548A\n54B5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-54B5\n54F6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-54F6\n5515 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5515\n5518..5519 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5518..CJK UNIFIED IDEOGRAPH-5519\n5547 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5547\n5560 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5560\n557A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-557A\n55E0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-55E0\n55F8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-55F8\n560A..560B ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-560A..CJK UNIFIED IDEOGRAPH-560B\n5620 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5620\n562B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-562B\n5637 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5637\n563C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-563C\n5644 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5644\n564B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-564B\n5651 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5651\n5656 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5656\n565F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-565F\n5661 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5661\n5675 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5675\n567D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-567D\n5688 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5688\n568B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-568B\n5696 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5696\n569E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-569E\n56BA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-56BA\n56CF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-56CF\n56D9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-56D9\n56E6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-56E6\n56F6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-56F6\n56F8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-56F8\n56FB..56FC ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-56FB..CJK UNIFIED IDEOGRAPH-56FC\n5705 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5705\n5711 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5711\n5717 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5717\n5721 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5721\n5724 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5724\n573D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-573D\n5743 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5743\n5748 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5748\n5755..5756 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5755..CJK UNIFIED IDEOGRAPH-5756\n5758 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5758\n5763 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5763\n5778 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5778\n5781 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5781\n5787 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5787\n5796 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5796\n57A8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-57A8\n57CA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-57CA\n57D1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-57D1\n57DB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-57DB\n5817..5818 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5817..CJK UNIFIED IDEOGRAPH-5818\n5850 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5850\n5856 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5856\n5860 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5860\n5866..5867 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5866..CJK UNIFIED IDEOGRAPH-5867\n5877 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5877\n5895 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5895\n58AA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58AA\n58B6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58B6\n58C0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58C0\n58C3..58C4 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-58C3..CJK UNIFIED IDEOGRAPH-58C4\n58CD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58CD\n58D0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58D0\n58E1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58E1\n58E6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58E6\n58F5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-58F5\n5901 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5901\n5905 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5905\n5908 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5908\n5911 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5911\n5913 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5913\n5923 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5923\n5933 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5933\n5936 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5936\n5959 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5959\n595B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-595B\n59B7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-59B7\n59E7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-59E7\n5A24 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A24\n5A26 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A26\n5A2C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A2C\n5A30 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A30\n5A54 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A54\n5A59 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A59\n5A6F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A6F\n5A71 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A71\n5A87 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A87\n5A8D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5A8D\n5AAB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5AAB\n5AD3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5AD3\n5AEF..5AF0 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5AEF..CJK UNIFIED IDEOGRAPH-5AF0\n5B0A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B0A\n5B0D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B0D\n5B39 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B39\n5B46 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B46\n5B4F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B4F\n5B52 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B52\n5B60..5B61 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5B60..CJK UNIFIED IDEOGRAPH-5B61\n5B6F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B6F\n5B79 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B79\n5B7E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B7E\n5B86 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B86\n5B90 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5B90\n5BA9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5BA9\n5BB2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5BB2\n5BB7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5BB7\n5BBC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5BBC\n5BC8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5BC8\n5BDA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5BDA\n5C00 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C00\n5C1B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C1B\n5C23 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C23\n5C26 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C26\n5C29 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C29\n5C36 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C36\n5C5A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C5A\n5C85 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5C85\n5CB4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5CB4\n5CB9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5CB9\n5CD5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5CD5\n5CDD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5CDD\n5CF5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5CF5\n5D2B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D2B\n5D2F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D2F\n5D3B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D3B\n5D53 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D53\n5D57 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D57\n5D60 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D60\n5D83 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D83\n5D96 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5D96\n5DA3..5DA4 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5DA3..CJK UNIFIED IDEOGRAPH-5DA4\n5DAB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DAB\n5DB3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DB3\n5DB9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DB9\n5DC4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DC4\n5DD7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DD7\n5DDA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DDA\n5DDC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DDC\n5DF6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5DF6\n5E12 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5E12\n5E48 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5E48\n5E51 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5E51\n5E92 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5E92\n5EBA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5EBA\n5EC0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5EC0\n5EEB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5EEB\n5EF9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5EF9\n5F0E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5F0E\n5F3B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5F3B\n5F3D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5F3D\n5F8F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5F8F\n5F9A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5F9A\n5FA3..5FA4 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-5FA3..CJK UNIFIED IDEOGRAPH-5FA4\n5FB0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5FB0\n5FC2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5FC2\n5FCE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5FCE\n5FDB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5FDB\n5FE2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5FE2\n5FEC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5FEC\n5FFC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-5FFC\n6023 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6023\n6056 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6056\n6061 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6061\n6071 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6071\n6074 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6074\n6091 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6091\n6093 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6093\n60A5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-60A5\n60D2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-60D2\n60D6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-60D6\n60DE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-60DE\n60E5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-60E5\n60FD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-60FD\n6102 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6102\n6107 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6107\n6111 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6111\n611E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-611E\n6131 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6131\n6133 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6133\n6135 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6135\n6138..6139 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-6138..CJK UNIFIED IDEOGRAPH-6139\n6160 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6160\n617B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-617B\n617F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-617F\n6186 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6186\n6197 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6197\n619C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-619C\n61B9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-61B9\n61BB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-61BB\n61D3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-61D3\n61D5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-61D5\n61EC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-61EC\n61EF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-61EF\n6205 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6205\n6235 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6235\n6239 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6239\n6257 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6257\n628D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-628D\n629D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-629D\n62DE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-62DE\n62EA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-62EA\n630A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-630A\n6317 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6317\n6331 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6331\n6337 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6337\n635B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-635B\n638B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-638B\n6393 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6393\n63D1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-63D1\n643B..643C ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-643B..CJK UNIFIED IDEOGRAPH-643C\n6449 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6449\n645A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-645A\n647E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-647E\n6486 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6486\n64A1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64A1\n64AF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64AF\n64B6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64B6\n64C8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64C8\n64D5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64D5\n64EE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64EE\n64F5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64F5\n64F9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-64F9\n6502 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6502\n650A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-650A\n651F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-651F\n6528 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6528\n6540 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6540\n6542 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6542\n655A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-655A\n655F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-655F\n657D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-657D\n658A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-658A\n659A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-659A\n65B5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65B5\n65BE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65BE\n65C8..65C9 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-65C8..CJK UNIFIED IDEOGRAPH-65C9\n65D1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65D1\n65D8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65D8\n65DC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65DC\n65E4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65E4\n65EA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65EA\n65F9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65F9\n65FE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-65FE\n6617 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6617\n662C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-662C\n6637..6638 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-6637..CJK UNIFIED IDEOGRAPH-6638\n6648 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6648\n664D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-664D\n6660 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6660\n6663 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6663\n6692 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6692\n669C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-669C\n669E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-669E\n66AC..66AD ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-66AC..CJK UNIFIED IDEOGRAPH-66AD\n66D0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-66D0\n66D3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-66D3\n66D7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-66D7\n66DF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-66DF\n66EF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-66EF\n6702 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6702\n6707 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6707\n6719 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6719\n6724 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6724\n6729 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6729\n6767 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6767\n6788 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6788\n6796 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6796\n67BD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-67BD\n67BF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-67BF\n67D5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-67D5\n67D7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-67D7\n67F9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-67F9\n6801 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6801\n6815 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6815\n6827 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6827\n6830 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6830\n6858 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6858\n685A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-685A\n685E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-685E\n687A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-687A\n6895 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6895\n6899 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6899\n68A5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-68A5\n68B8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-68B8\n68C3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-68C3\n68D9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-68D9\n68E2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-68E2\n68E5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-68E5\n6909 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6909\n693E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-693E\n694D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-694D\n699F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-699F\n69A2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-69A2\n69C0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-69C0\n69D1..69D2 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-69D1..CJK UNIFIED IDEOGRAPH-69D2\n69D5..69D7 ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-69D5..CJK UNIFIED IDEOGRAPH-69D7\n6A03 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A03\n6A1C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A1C\n6A24 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A24\n6A37 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A37\n6A4A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A4A\n6A5C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A5C\n6A6E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A6E\n6A70 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A70\n6A86 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A86\n6A8A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A8A\n6A8F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A8F\n6A99 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A99\n6A9D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6A9D\n6AB1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6AB1\n6ABE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6ABE\n6AC0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6AC0\n6AC4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6AC4\n6AC9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6AC9\n6AD8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6AD8\n6AE9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6AE9\n6B0E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B0E\n6B1B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B1B\n6B2E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B2E\n6B35 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B35\n6B40 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B40\n6B57..6B58 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-6B57..CJK UNIFIED IDEOGRAPH-6B58\n6B5D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B5D\n6B68 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B68\n6B6C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B6C\n6B6E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B6E\n6B71 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B71\n6B75 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B75\n6B7D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6B7D\n6BB8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6BB8\n6BE9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6BE9\n6BF1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6BF1\n6BF4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6BF4\n6BFA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6BFA\n6C0A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6C0A\n6C1C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6C1C\n6C2D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6C2D\n6C3C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6C3C\n6C45 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6C45\n6C6C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6C6C\n6C6E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6C6E\n6CA0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6CA0\n6CD8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6CD8\n6CF4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6CF4\n6D02 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6D02\n6D1C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6D1C\n6D24 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6D24\n6D71 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6D71\n6D81 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6D81\n6D96 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6D96\n6DB0..6DB1 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-6DB0..CJK UNIFIED IDEOGRAPH-6DB1\n6DB6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6DB6\n6DFE..6DFF ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-6DFE..CJK UNIFIED IDEOGRAPH-6DFF\n6E01..6E02 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-6E01..CJK UNIFIED IDEOGRAPH-6E02\n6E06 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E06\n6E12 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E12\n6E18 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E18\n6E2A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E2A\n6E4C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E4C\n6E6C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E6C\n6E7B..6E7D ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-6E7B..CJK UNIFIED IDEOGRAPH-6E7D\n6E8B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E8B\n6E95 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6E95\n6EDB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6EDB\n6EE3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6EE3\n6F04 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F04\n6F0B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F0B\n6F42 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F42\n6F48 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F48\n6F4A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F4A\n6F79 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F79\n6F98 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F98\n6F9A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F9A\n6F9F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6F9F\n6FB7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6FB7\n6FC5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6FC5\n6FD0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6FD0\n6FD3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6FD3\n6FF5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6FF5\n6FFD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-6FFD\n7010 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7010\n7013 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7013\n7047 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7047\n704B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-704B\n704E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-704E\n7072..7073 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7072..CJK UNIFIED IDEOGRAPH-7073\n707B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-707B\n7081 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7081\n708D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-708D\n7097 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7097\n709B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-709B\n70AA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-70AA\n70B2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-70B2\n70B6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-70B6\n70D5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-70D5\n70FE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-70FE\n7108 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7108\n7124 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7124\n7133..7134 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7133..CJK UNIFIED IDEOGRAPH-7134\n7157 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7157\n716B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-716B\n716D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-716D\n718D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-718D\n7196 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7196\n71A6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-71A6\n71AB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-71AB\n71B6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-71B6\n71CC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-71CC\n71D3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-71D3\n71F3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-71F3\n71FA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-71FA\n720B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-720B\n7211 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7211\n7215 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7215\n7217 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7217\n7220 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7220\n7224..7225 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7224..CJK UNIFIED IDEOGRAPH-7225\n722F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-722F\n7234 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7234\n7245 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7245\n724E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-724E\n7250 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7250\n7255 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7255\n72AB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-72AB\n72BE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-72BE\n7302 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7302\n7310 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7310\n7328 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7328\n7353 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7353\n739C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-739C\n73C1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-73C1\n73F3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-73F3\n73FB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-73FB\n7418 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7418\n7439 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7439\n743E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-743E\n7447 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7447\n7449 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7449\n7458 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7458\n747B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-747B\n7484 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7484\n7496 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7496\n749D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-749D\n74C7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-74C7\n74C9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-74C9\n74CC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-74CC\n74EB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-74EB\n7520 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7520\n7541 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7541\n7552 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7552\n7555 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7555\n755E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-755E\n7561 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7561\n7571 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7571\n757B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-757B\n7585 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7585\n75A9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-75A9\n75B7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-75B7\n75DC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-75DC\n75EE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-75EE\n762C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-762C\n7644..7645 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7644..CJK UNIFIED IDEOGRAPH-7645\n7651 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7651\n7655 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7655\n7673 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7673\n768D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-768D\n76A1..76A2 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-76A1..CJK UNIFIED IDEOGRAPH-76A2\n76A5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76A5\n76A8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76A8\n76B3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76B3\n76B6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76B6\n76C1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76C1\n76CB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76CB\n76D9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76D9\n76EB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-76EB\n7700 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7700\n7702 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7702\n770E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-770E\n7721 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7721\n772B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-772B\n773F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-773F\n7742 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7742\n7764 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7764\n7796 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7796\n77A4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-77A4\n77BE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-77BE\n77C1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-77C1\n77D2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-77D2\n77DD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-77DD\n77E4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-77E4\n77E6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-77E6\n77F4..77F5 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-77F4..CJK UNIFIED IDEOGRAPH-77F5\n7824 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7824\n7836 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7836\n7842 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7842\n7846 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7846\n784B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-784B\n7876 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7876\n7888 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7888\n78C2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-78C2\n78C7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-78C7\n78D2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-78D2\n78F0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-78F0\n78F8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-78F8\n7900 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7900\n7908 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7908\n790D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-790D\n7915 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7915\n791F..7920 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-791F..CJK UNIFIED IDEOGRAPH-7920\n7932 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7932\n7936 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7936\n7959 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7959\n796C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-796C\n796E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-796E\n7975..7976 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7975..CJK UNIFIED IDEOGRAPH-7976\n7986..7987 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7986..CJK UNIFIED IDEOGRAPH-7987\n799E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-799E\n79A9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-79A9\n79BC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-79BC\n79C4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-79C4\n79C7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-79C7\n79CC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-79CC\n79D4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-79D4\n79D7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-79D7\n7A01 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A01\n7A07 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A07\n7A09 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A09\n7A2C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A2C\n7A38 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A38\n7A3A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A3A\n7A64 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A64\n7A6A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A6A\n7A6F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A6F\n7A82 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7A82\n7A9A..7A9B ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7A9A..CJK UNIFIED IDEOGRAPH-7A9B\n7AB9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7AB9\n7ABB..7ABD ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-7ABB..CJK UNIFIED IDEOGRAPH-7ABD\n7AC2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7AC2\n7AC6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7AC6\n7AE9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7AE9\n7AF5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7AF5\n7AFC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7AFC\n7B07 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7B07\n7B1F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7B1F\n7B27 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7B27\n7B29 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7B29\n7B42 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7B42\n7B53 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7B53\n7BA3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7BA3\n7BA5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7BA5\n7BB0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7BB0\n7BB2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7BB2\n7BFA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7BFA\n7C1B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C1B\n7C2E..7C2F ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7C2E..CJK UNIFIED IDEOGRAPH-7C2F\n7C52 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C52\n7C55 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C55\n7C5D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C5D\n7C76 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C76\n7C87 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C87\n7C93 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C93\n7C9A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7C9A\n7CAC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7CAC\n7CD3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7CD3\n7CDA..7CDB ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7CDA..CJK UNIFIED IDEOGRAPH-7CDB\n7CE1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7CE1\n7CE3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7CE3\n7CE5..7CE6 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7CE5..CJK UNIFIED IDEOGRAPH-7CE6\n7CFC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7CFC\n7CFF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7CFF\n7D23 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D23\n7D2A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D2A\n7D2D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D2D\n7D48 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D48\n7D4D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D4D\n7D5A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D5A\n7D64 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D64\n7D78 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D78\n7D82 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D82\n7D95 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D95\n7D98 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7D98\n7DA4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7DA4\n7DA8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7DA8\n7DCD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7DCD\n7DD3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7DD3\n7DE5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7DE5\n7DEB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7DEB\n7DFD..7DFF ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-7DFD..CJK UNIFIED IDEOGRAPH-7DFF\n7E18 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7E18\n7E5B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7E5B\n7E64 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7E64\n7E9D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7E9D\n7F3B..7F3C ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-7F3B..CJK UNIFIED IDEOGRAPH-7F3C\n7F41 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7F41\n7F46 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7F46\n7F59 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7F59\n7F84 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7F84\n7F90 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7F90\n7F97 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7F97\n7F99 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7F99\n7FB4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7FB4\n7FD6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7FD6\n7FDD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7FDD\n7FE4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-7FE4\n800A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-800A\n802F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-802F\n803C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-803C\n8040 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8040\n8066 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8066\n8088 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8088\n808E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-808E\n8094 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8094\n80A6..80A8 ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-80A6..CJK UNIFIED IDEOGRAPH-80A8\n80B3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-80B3\n80B9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-80B9\n80DF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-80DF\n8103..8104 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8103..CJK UNIFIED IDEOGRAPH-8104\n8134..8135 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8134..CJK UNIFIED IDEOGRAPH-8135\n8184 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8184\n8190 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8190\n8196 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8196\n81CB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-81CB\n81E4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-81E4\n81EF..81F0 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-81EF..CJK UNIFIED IDEOGRAPH-81F0\n8213 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8213\n8224 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8224\n8241 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8241\n8265 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8265\n828C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-828C\n82B2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-82B2\n82E2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-82E2\n82FC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-82FC\n830A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-830A\n8310 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8310\n8330 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8330\n8355 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8355\n83BE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-83BE\n83E6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-83E6\n83ED ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-83ED\n8414 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8414\n8416..8417 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8416..CJK UNIFIED IDEOGRAPH-8417\n841F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-841F\n8458 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8458\n8483 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8483\n8495 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8495\n84B7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-84B7\n84C3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-84C3\n84ED ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-84ED\n8505 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8505\n8510 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8510\n8532..8533 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8532..CJK UNIFIED IDEOGRAPH-8533\n854C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-854C\n8550 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8550\n857F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-857F\n8593 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8593\n85B2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-85B2\n85BB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-85BB\n85CC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-85CC\n85EE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-85EE\n85F3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-85F3\n85FC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-85FC\n8603 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8603\n860D..860E ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-860D..CJK UNIFIED IDEOGRAPH-860E\n8610 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8610\n8615 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8615\n861D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-861D\n8637 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8637\n8657 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8657\n8675 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8675\n8689 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8689\n8692 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8692\n86A0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-86A0\n86A6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-86A6\n86D5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-86D5\n86E0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-86E0\n86E7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-86E7\n86FD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-86FD\n871D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-871D\n872F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-872F\n873D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-873D\n8745 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8745\n8771 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8771\n878E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-878E\n8799 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8799\n87DA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-87DA\n87F0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-87F0\n8807 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8807\n8812 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8812\n882D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-882D\n883A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-883A\n8847 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8847\n8858 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8858\n885C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-885C\n885F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-885F\n887A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-887A\n88E6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-88E6\n88E9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-88E9\n88ED ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-88ED\n8903 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8903\n890F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-890F\n8924 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8924\n8965 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8965\n8975 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8975\n897D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-897D\n898D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-898D\n8990 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8990\n8994 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8994\n8999 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8999\n89B0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-89B0\n89B4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-89B4\n89BB..89BC ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-89BB..CJK UNIFIED IDEOGRAPH-89BC\n89EE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-89EE\n89F5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-89F5\n89F9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-89F9\n89FD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-89FD\n8A05..8A06 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8A05..CJK UNIFIED IDEOGRAPH-8A06\n8A14 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A14\n8A19 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A19\n8A20..8A21 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8A20..CJK UNIFIED IDEOGRAPH-8A21\n8A2B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A2B\n8A3D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A3D\n8A4B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A4B\n8A64 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A64\n8A78 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A78\n8A7D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A7D\n8A88 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A88\n8A9F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8A9F\n8AAF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8AAF\n8AB7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8AB7\n8AD0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8AD0\n8AEC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8AEC\n8B29 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B29\n8B32 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B32\n8B38 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B38\n8B3F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B3F\n8B61..8B62 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8B61..CJK UNIFIED IDEOGRAPH-8B62\n8B69 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B69\n8B75 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B75\n8B7C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B7C\n8B81 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B81\n8B87 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B87\n8B8D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B8D\n8B8F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B8F\n8B9B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8B9B\n8C38 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C38\n8C40 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C40\n8C44 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C44\n8C51..8C53 ; Uncommon_Use # 1.1 [3] CJK UNIFIED IDEOGRAPH-8C51..CJK UNIFIED IDEOGRAPH-8C53\n8C58 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C58\n8C74 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C74\n8C7F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C7F\n8C83 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C83\n8C87 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C87\n8C8B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C8B\n8C9B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8C9B\n8CA6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8CA6\n8CCB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8CCB\n8CD6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8CD6\n8CD8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8CD8\n8CE9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8CE9\n8CF7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8CF7\n8D01 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8D01\n8D11..8D12 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8D11..CJK UNIFIED IDEOGRAPH-8D12\n8D7C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8D7C\n8DA6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8DA6\n8DC0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8DC0\n8DE5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8DE5\n8E01 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E01\n8E0B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E0B\n8E32 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E32\n8E46 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E46\n8E4F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E4F\n8E6E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E6E\n8E75 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E75\n8E77 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E77\n8E79 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E79\n8E9B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8E9B\n8EA2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8EA2\n8EB3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8EB3\n8EB6..8EB7 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-8EB6..CJK UNIFIED IDEOGRAPH-8EB7\n8EC1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8EC1\n8EC4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8EC4\n8ED9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8ED9\n8EF0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8EF0\n8F0F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8F0F\n8F2D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8F2D\n8F3A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8F3A\n8F41 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8F41\n8F9D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8F9D\n8FA4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8FA4\n8FB3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8FB3\n8FC3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8FC3\n8FCA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8FCA\n8FE7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-8FE7\n902A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-902A\n902C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-902C\n9037 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9037\n9040 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9040\n9046 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9046\n90AB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-90AB\n90CC..90CD ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-90CC..CJK UNIFIED IDEOGRAPH-90CD\n90D2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-90D2\n90F6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-90F6\n910A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-910A\n913C..913D ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-913C..CJK UNIFIED IDEOGRAPH-913D\n9159 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9159\n917B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-917B\n9195 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9195\n9198 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9198\n91A9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-91A9\n91BF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-91BF\n91C4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-91C4\n91E0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-91E0\n91EF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-91EF\n9213 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9213\n921F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-921F\n9222 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9222\n9243 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9243\n9269..926A ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9269..CJK UNIFIED IDEOGRAPH-926A\n9281 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9281\n9284 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9284\n929E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-929E\n92BD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-92BD\n92D4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-92D4\n92DB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-92DB\n92E2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-92E2\n931C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-931C\n9330..9331 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9330..CJK UNIFIED IDEOGRAPH-9331\n9362 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9362\n9368 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9368\n936B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-936B\n936F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-936F\n9373 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9373\n9378 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9378\n937F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-937F\n9381 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9381\n938B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-938B\n939C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-939C\n93A0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-93A0\n93AB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-93AB\n93BB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-93BB\n93E0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-93E0\n93F3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-93F3\n9402 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9402\n9417 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9417\n941C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-941C\n941E..941F ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-941E..CJK UNIFIED IDEOGRAPH-941F\n9424 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9424\n9443 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9443\n944E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-944E\n946C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-946C\n947B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-947B\n9578..9579 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9578..CJK UNIFIED IDEOGRAPH-9579\n957E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-957E\n9585 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9585\n9597 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9597\n95B3..95B4 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-95B3..CJK UNIFIED IDEOGRAPH-95B4\n95B8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-95B8\n95C1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-95C1\n95D9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-95D9\n95DD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-95DD\n9625..9626 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9625..CJK UNIFIED IDEOGRAPH-9626\n9629 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9629\n963E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-963E\n9656..9657 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9656..CJK UNIFIED IDEOGRAPH-9657\n9679 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9679\n967B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-967B\n967F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-967F\n9681..9682 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9681..CJK UNIFIED IDEOGRAPH-9682\n968C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-968C\n9696 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9696\n969A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-969A\n969D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-969D\n969F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-969F\n96AB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-96AB\n96AF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-96AF\n96B5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-96B5\n96E4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-96E4\n96E6..96E7 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-96E6..CJK UNIFIED IDEOGRAPH-96E7\n96FC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-96FC\n9714 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9714\n9717 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9717\n971A..971B ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-971A..CJK UNIFIED IDEOGRAPH-971B\n9733..9734 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9733..CJK UNIFIED IDEOGRAPH-9734\n9737 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9737\n9740..9741 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9740..CJK UNIFIED IDEOGRAPH-9741\n974D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-974D\n9757 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9757\n9763 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9763\n9775 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9775\n9787 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9787\n9789 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9789\n979B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-979B\n97A9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-97A9\n97B0..97B1 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-97B0..CJK UNIFIED IDEOGRAPH-97B1\n97B5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-97B5\n97BE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-97BE\n97C0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-97C0\n97D2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-97D2\n97FC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-97FC\n981F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-981F\n9825 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9825\n982A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-982A\n9833 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9833\n983A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-983A\n983E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-983E\n9842 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9842\n9847 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9847\n9856 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9856\n9866 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9866\n9868 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9868\n98B7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-98B7\n98CA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-98CA\n98E4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-98E4\n98EC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-98EC\n98F1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-98F1\n98F8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-98F8\n98FB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-98FB\n9919 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9919\n993B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-993B\n9944 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9944\n995A ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-995A\n995D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-995D\n99BF ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-99BF\n99E0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-99E0\n99E6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-99E6\n99EB ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-99EB\n99F5 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-99F5\n9A10 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9A10\n9A17..9A18 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9A17..CJK UNIFIED IDEOGRAPH-9A18\n9A3B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9A3B\n9A51 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9A51\n9A58 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9A58\n9A5D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9A5D\n9A63 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9A63\n9AA9 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9AA9\n9ABD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9ABD\n9AC8 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9AC8\n9AD7 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9AD7\n9AE0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9AE0\n9AE4 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9AE4\n9AE8..9AE9 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9AE8..CJK UNIFIED IDEOGRAPH-9AE9\n9AF0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9AF0\n9B00 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B00\n9B02 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B02\n9B09 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B09\n9B14 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B14\n9B1B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B1B\n9B34 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B34\n9B3D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B3D\n9B40 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B40\n9B50 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B50\n9B57 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B57\n9B62 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B62\n9B72 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B72\n9B89 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B89\n9B8C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B8C\n9B99 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9B99\n9BC2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9BC2\n9BF6 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9BF6\n9C00..9C01 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9C00..CJK UNIFIED IDEOGRAPH-9C01\n9C03 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9C03\n9C42 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9C42\n9C4F ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9C4F\n9C51 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9C51\n9C61 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9C61\n9C64 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9C64\n9C7B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9C7B\n9D0C..9D0D ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9D0C..CJK UNIFIED IDEOGRAPH-9D0D\n9D11 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9D11\n9D27 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9D27\n9D35 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9D35\n9D3C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9D3C\n9D6D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9D6D\n9D95 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9D95\n9DAE ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9DAE\n9DBD ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9DBD\n9DC0 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9DC0\n9DEA ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9DEA\n9DFC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9DFC\n9E0E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9E0E\n9E16 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9E16\n9E1C ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9E1C\n9E7B ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9E7B\n9E8F..9E90 ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9E8F..CJK UNIFIED IDEOGRAPH-9E90\n9E98 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9E98\n9E9E ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9E9E\n9EA2 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9EA2\n9EAB..9EAC ; Uncommon_Use # 1.1 [2] CJK UNIFIED IDEOGRAPH-9EAB..CJK UNIFIED IDEOGRAPH-9EAC\n9EB1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9EB1\n9EEC ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9EEC\n9EF1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9EF1\n9F03 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9F03\n9F11 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9F11\n9F14 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9F14\n9F26 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9F26\n9F45 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9F45\n9F53 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9F53\n9F6D ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9F6D\n9FA1 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9FA1\n9FA3 ; Uncommon_Use # 1.1 CJK UNIFIED IDEOGRAPH-9FA3\n9FA6..9FBB ; Uncommon_Use # 4.1 [22] CJK UNIFIED IDEOGRAPH-9FA6..CJK UNIFIED IDEOGRAPH-9FBB\n9FBC..9FC3 ; Uncommon_Use # 5.1 [8] CJK UNIFIED IDEOGRAPH-9FBC..CJK UNIFIED IDEOGRAPH-9FC3\n9FC4..9FCB ; Uncommon_Use # 5.2 [8] CJK UNIFIED IDEOGRAPH-9FC4..CJK UNIFIED IDEOGRAPH-9FCB\n9FCC ; Uncommon_Use # 6.1 CJK UNIFIED IDEOGRAPH-9FCC\n9FCD..9FD5 ; Uncommon_Use # 8.0 [9] CJK UNIFIED IDEOGRAPH-9FCD..CJK UNIFIED IDEOGRAPH-9FD5\n9FD6..9FEA ; Uncommon_Use # 10.0 [21] CJK UNIFIED IDEOGRAPH-9FD6..CJK UNIFIED IDEOGRAPH-9FEA\n9FEB..9FEF ; Uncommon_Use # 11.0 [5] CJK UNIFIED IDEOGRAPH-9FEB..CJK UNIFIED IDEOGRAPH-9FEF\n9FF0..9FFC ; Uncommon_Use # 13.0 [13] CJK UNIFIED IDEOGRAPH-9FF0..CJK UNIFIED IDEOGRAPH-9FFC\n9FFD..9FFF ; Uncommon_Use # 14.0 [3] CJK UNIFIED IDEOGRAPH-9FFD..CJK UNIFIED IDEOGRAPH-9FFF\nA66F ; Uncommon_Use # 5.1 COMBINING CYRILLIC VZMET\nA67C..A67D ; Uncommon_Use # 5.1 [2] COMBINING CYRILLIC KAVYKA..COMBINING CYRILLIC PAYEROK\nA78B..A78C ; Uncommon_Use # 5.1 [2] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER SALTILLO\nA78F ; Uncommon_Use # 8.0 LATIN LETTER SINOLOGICAL DOT\nA792..A793 ; Uncommon_Use # 6.1 [2] LATIN CAPITAL LETTER C WITH BAR..LATIN SMALL LETTER C WITH BAR\nA7B2..A7B7 ; Uncommon_Use # 8.0 [6] LATIN CAPITAL LETTER J WITH CROSSED-TAIL..LATIN SMALL LETTER OMEGA\nA7B8..A7B9 ; Uncommon_Use # 11.0 [2] LATIN CAPITAL LETTER U WITH STROKE..LATIN SMALL LETTER U WITH STROKE\nA7C2..A7C3 ; Uncommon_Use # 12.0 [2] LATIN CAPITAL LETTER ANGLICANA W..LATIN SMALL LETTER ANGLICANA W\nA7CB..A7CD ; Uncommon_Use # 16.0 [3] LATIN CAPITAL LETTER RAMS HORN..LATIN SMALL LETTER S WITH DIAGONAL STROKE\nA7CE..A7CF ; Uncommon_Use # 17.0 [2] LATIN CAPITAL LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER PHARYNGEAL VOICED FRICATIVE\nA7DA..A7DC ; Uncommon_Use # 16.0 [3] LATIN CAPITAL LETTER LAMBDA..LATIN CAPITAL LETTER LAMBDA WITH STROKE\nA9E7..A9FE ; Uncommon_Use # 7.0 [24] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING BHA\nAA60..AA76 ; Uncommon_Use # 5.2 [23] MYANMAR LETTER KHAMTI GA..MYANMAR LOGOGRAM KHAMTI HM\nAA7A ; Uncommon_Use # 5.2 MYANMAR LETTER AITON RA\nAA7C..AA7F ; Uncommon_Use # 7.0 [4] MYANMAR SIGN TAI LAING TONE-2..MYANMAR LETTER SHWE PALAUNG SHA\nAB01..AB06 ; Uncommon_Use # 6.0 [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO\nAB09..AB0E ; Uncommon_Use # 6.0 [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO\nAB11..AB16 ; Uncommon_Use # 6.0 [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO\nAB20..AB26 ; Uncommon_Use # 6.0 [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO\nAB28..AB2E ; Uncommon_Use # 6.0 [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO\nAB60..AB63 ; Uncommon_Use # 8.0 [4] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER UO\nAB66..AB67 ; Uncommon_Use # 12.0 [2] LATIN SMALL LETTER DZ DIGRAPH WITH RETROFLEX HOOK..LATIN SMALL LETTER TS DIGRAPH WITH RETROFLEX HOOK\nFA0E..FA0F ; Uncommon_Use # 1.1 [2] CJK COMPATIBILITY IDEOGRAPH-FA0E..CJK COMPATIBILITY IDEOGRAPH-FA0F\nFA11 ; Uncommon_Use # 1.1 CJK COMPATIBILITY IDEOGRAPH-FA11\nFA13..FA14 ; Uncommon_Use # 1.1 [2] CJK COMPATIBILITY IDEOGRAPH-FA13..CJK COMPATIBILITY IDEOGRAPH-FA14\nFA1F ; Uncommon_Use # 1.1 CJK COMPATIBILITY IDEOGRAPH-FA1F\nFA21 ; Uncommon_Use # 1.1 CJK COMPATIBILITY IDEOGRAPH-FA21\nFA23..FA24 ; Uncommon_Use # 1.1 [2] CJK COMPATIBILITY IDEOGRAPH-FA23..CJK COMPATIBILITY IDEOGRAPH-FA24\nFA27..FA29 ; Uncommon_Use # 1.1 [3] CJK COMPATIBILITY IDEOGRAPH-FA27..CJK COMPATIBILITY IDEOGRAPH-FA29\n10780 ; Uncommon_Use # 14.0 MODIFIER LETTER SMALL CAPITAL AA\n10EC2..10EC4 ; Uncommon_Use # 16.0 [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW\n10EC7 ; Uncommon_Use # 17.0 ARABIC LETTER YEH WITH FOUR DOTS BELOW\n10EFA ; Uncommon_Use # 17.0 ARABIC DOUBLE VERTICAL BAR BELOW\n10EFC ; Uncommon_Use # 16.0 ARABIC COMBINING ALEF OVERLAY\n10EFD..10EFF ; Uncommon_Use # 15.0 [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA\n1133B ; Uncommon_Use # 11.0 COMBINING BINDU BELOW\n116D0..116E3 ; Uncommon_Use # 16.0 [20] MYANMAR PAO DIGIT ZERO..MYANMAR EASTERN PWO KAREN DIGIT NINE\n1AFF0..1AFF3 ; Uncommon_Use # 14.0 [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5\n1AFF5..1AFFB ; Uncommon_Use # 14.0 [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5\n1AFFD..1AFFE ; Uncommon_Use # 14.0 [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8\n20000..2070D ; Uncommon_Use # 3.1 [1806] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2070D\n2070F..20730 ; Uncommon_Use # 3.1 [34] CJK UNIFIED IDEOGRAPH-2070F..CJK UNIFIED IDEOGRAPH-20730\n20732..20778 ; Uncommon_Use # 3.1 [71] CJK UNIFIED IDEOGRAPH-20732..CJK UNIFIED IDEOGRAPH-20778\n2077A..20C52 ; Uncommon_Use # 3.1 [1241] CJK UNIFIED IDEOGRAPH-2077A..CJK UNIFIED IDEOGRAPH-20C52\n20C54..20C77 ; Uncommon_Use # 3.1 [36] CJK UNIFIED IDEOGRAPH-20C54..CJK UNIFIED IDEOGRAPH-20C77\n20C79..20C95 ; Uncommon_Use # 3.1 [29] CJK UNIFIED IDEOGRAPH-20C79..CJK UNIFIED IDEOGRAPH-20C95\n20C97..20CCE ; Uncommon_Use # 3.1 [56] CJK UNIFIED IDEOGRAPH-20C97..CJK UNIFIED IDEOGRAPH-20CCE\n20CD0..20CD4 ; Uncommon_Use # 3.1 [5] CJK UNIFIED IDEOGRAPH-20CD0..CJK UNIFIED IDEOGRAPH-20CD4\n20CD6..20D14 ; Uncommon_Use # 3.1 [63] CJK UNIFIED IDEOGRAPH-20CD6..CJK UNIFIED IDEOGRAPH-20D14\n20D16..20D7B ; Uncommon_Use # 3.1 [102] CJK UNIFIED IDEOGRAPH-20D16..CJK UNIFIED IDEOGRAPH-20D7B\n20D7D..20D7E ; Uncommon_Use # 3.1 [2] CJK UNIFIED IDEOGRAPH-20D7D..CJK UNIFIED IDEOGRAPH-20D7E\n20D80..20E0D ; Uncommon_Use # 3.1 [142] CJK UNIFIED IDEOGRAPH-20D80..CJK UNIFIED IDEOGRAPH-20E0D\n20E10..20E76 ; Uncommon_Use # 3.1 [103] CJK UNIFIED IDEOGRAPH-20E10..CJK UNIFIED IDEOGRAPH-20E76\n20E78..20E9C ; Uncommon_Use # 3.1 [37] CJK UNIFIED IDEOGRAPH-20E78..CJK UNIFIED IDEOGRAPH-20E9C\n20E9E..20EA1 ; Uncommon_Use # 3.1 [4] CJK UNIFIED IDEOGRAPH-20E9E..CJK UNIFIED IDEOGRAPH-20EA1\n20EA3..20ED6 ; Uncommon_Use # 3.1 [52] CJK UNIFIED IDEOGRAPH-20EA3..CJK UNIFIED IDEOGRAPH-20ED6\n20ED8..20EF8 ; Uncommon_Use # 3.1 [33] CJK UNIFIED IDEOGRAPH-20ED8..CJK UNIFIED IDEOGRAPH-20EF8\n20EFB..20F2C ; Uncommon_Use # 3.1 [50] CJK UNIFIED IDEOGRAPH-20EFB..CJK UNIFIED IDEOGRAPH-20F2C\n20F2F..20F4B ; Uncommon_Use # 3.1 [29] CJK UNIFIED IDEOGRAPH-20F2F..CJK UNIFIED IDEOGRAPH-20F4B\n20F4D..20FB3 ; Uncommon_Use # 3.1 [103] CJK UNIFIED IDEOGRAPH-20F4D..CJK UNIFIED IDEOGRAPH-20FB3\n20FB5..20FBB ; Uncommon_Use # 3.1 [7] CJK UNIFIED IDEOGRAPH-20FB5..CJK UNIFIED IDEOGRAPH-20FBB\n20FBD..20FE9 ; Uncommon_Use # 3.1 [45] CJK UNIFIED IDEOGRAPH-20FBD..CJK UNIFIED IDEOGRAPH-20FE9\n20FEB..2105B ; Uncommon_Use # 3.1 [113] CJK UNIFIED IDEOGRAPH-20FEB..CJK UNIFIED IDEOGRAPH-2105B\n2105D..2106E ; Uncommon_Use # 3.1 [18] CJK UNIFIED IDEOGRAPH-2105D..CJK UNIFIED IDEOGRAPH-2106E\n21070..21074 ; Uncommon_Use # 3.1 [5] CJK UNIFIED IDEOGRAPH-21070..CJK UNIFIED IDEOGRAPH-21074\n21077..2107A ; Uncommon_Use # 3.1 [4] CJK UNIFIED IDEOGRAPH-21077..CJK UNIFIED IDEOGRAPH-2107A\n2107C..210C0 ; Uncommon_Use # 3.1 [69] CJK UNIFIED IDEOGRAPH-2107C..CJK UNIFIED IDEOGRAPH-210C0\n210C2..210C8 ; Uncommon_Use # 3.1 [7] CJK UNIFIED IDEOGRAPH-210C2..CJK UNIFIED IDEOGRAPH-210C8\n210CA..211D8 ; Uncommon_Use # 3.1 [271] CJK UNIFIED IDEOGRAPH-210CA..CJK UNIFIED IDEOGRAPH-211D8\n211DA..220C6 ; Uncommon_Use # 3.1 [3821] CJK UNIFIED IDEOGRAPH-211DA..CJK UNIFIED IDEOGRAPH-220C6\n220C8..227B4 ; Uncommon_Use # 3.1 [1773] CJK UNIFIED IDEOGRAPH-220C8..CJK UNIFIED IDEOGRAPH-227B4\n227B6..22AD4 ; Uncommon_Use # 3.1 [799] CJK UNIFIED IDEOGRAPH-227B6..CJK UNIFIED IDEOGRAPH-22AD4\n22AD6..22B42 ; Uncommon_Use # 3.1 [109] CJK UNIFIED IDEOGRAPH-22AD6..CJK UNIFIED IDEOGRAPH-22B42\n22B44..22BC9 ; Uncommon_Use # 3.1 [134] CJK UNIFIED IDEOGRAPH-22B44..CJK UNIFIED IDEOGRAPH-22BC9\n22BCB..22C50 ; Uncommon_Use # 3.1 [134] CJK UNIFIED IDEOGRAPH-22BCB..CJK UNIFIED IDEOGRAPH-22C50\n22C52..22C54 ; Uncommon_Use # 3.1 [3] CJK UNIFIED IDEOGRAPH-22C52..CJK UNIFIED IDEOGRAPH-22C54\n22C56..22CC1 ; Uncommon_Use # 3.1 [108] CJK UNIFIED IDEOGRAPH-22C56..CJK UNIFIED IDEOGRAPH-22CC1\n22CC3..22D07 ; Uncommon_Use # 3.1 [69] CJK UNIFIED IDEOGRAPH-22CC3..CJK UNIFIED IDEOGRAPH-22D07\n22D09..22D4B ; Uncommon_Use # 3.1 [67] CJK UNIFIED IDEOGRAPH-22D09..CJK UNIFIED IDEOGRAPH-22D4B\n22D4D..22D66 ; Uncommon_Use # 3.1 [26] CJK UNIFIED IDEOGRAPH-22D4D..CJK UNIFIED IDEOGRAPH-22D66\n22D68..22EB2 ; Uncommon_Use # 3.1 [331] CJK UNIFIED IDEOGRAPH-22D68..CJK UNIFIED IDEOGRAPH-22EB2\n22EB4..23CB6 ; Uncommon_Use # 3.1 [3587] CJK UNIFIED IDEOGRAPH-22EB4..CJK UNIFIED IDEOGRAPH-23CB6\n23CB8..244D2 ; Uncommon_Use # 3.1 [2075] CJK UNIFIED IDEOGRAPH-23CB8..CJK UNIFIED IDEOGRAPH-244D2\n244D4..24DB7 ; Uncommon_Use # 3.1 [2276] CJK UNIFIED IDEOGRAPH-244D4..CJK UNIFIED IDEOGRAPH-24DB7\n24DB9..24DE9 ; Uncommon_Use # 3.1 [49] CJK UNIFIED IDEOGRAPH-24DB9..CJK UNIFIED IDEOGRAPH-24DE9\n24DEB..2512A ; Uncommon_Use # 3.1 [832] CJK UNIFIED IDEOGRAPH-24DEB..CJK UNIFIED IDEOGRAPH-2512A\n2512C..26257 ; Uncommon_Use # 3.1 [4396] CJK UNIFIED IDEOGRAPH-2512C..CJK UNIFIED IDEOGRAPH-26257\n26259..267CB ; Uncommon_Use # 3.1 [1395] CJK UNIFIED IDEOGRAPH-26259..CJK UNIFIED IDEOGRAPH-267CB\n267CD..269F1 ; Uncommon_Use # 3.1 [549] CJK UNIFIED IDEOGRAPH-267CD..CJK UNIFIED IDEOGRAPH-269F1\n269F3..269F9 ; Uncommon_Use # 3.1 [7] CJK UNIFIED IDEOGRAPH-269F3..CJK UNIFIED IDEOGRAPH-269F9\n269FB..27A3D ; Uncommon_Use # 3.1 [4163] CJK UNIFIED IDEOGRAPH-269FB..CJK UNIFIED IDEOGRAPH-27A3D\n27A3F..2815C ; Uncommon_Use # 3.1 [1822] CJK UNIFIED IDEOGRAPH-27A3F..CJK UNIFIED IDEOGRAPH-2815C\n2815E..28206 ; Uncommon_Use # 3.1 [169] CJK UNIFIED IDEOGRAPH-2815E..CJK UNIFIED IDEOGRAPH-28206\n28208..282E1 ; Uncommon_Use # 3.1 [218] CJK UNIFIED IDEOGRAPH-28208..CJK UNIFIED IDEOGRAPH-282E1\n282E3..28CC9 ; Uncommon_Use # 3.1 [2535] CJK UNIFIED IDEOGRAPH-282E3..CJK UNIFIED IDEOGRAPH-28CC9\n28CCB..28CCC ; Uncommon_Use # 3.1 [2] CJK UNIFIED IDEOGRAPH-28CCB..CJK UNIFIED IDEOGRAPH-28CCC\n28CCE..28CD1 ; Uncommon_Use # 3.1 [4] CJK UNIFIED IDEOGRAPH-28CCE..CJK UNIFIED IDEOGRAPH-28CD1\n28CD3..29D97 ; Uncommon_Use # 3.1 [4293] CJK UNIFIED IDEOGRAPH-28CD3..CJK UNIFIED IDEOGRAPH-29D97\n29D99..2A6D6 ; Uncommon_Use # 3.1 [2366] CJK UNIFIED IDEOGRAPH-29D99..CJK UNIFIED IDEOGRAPH-2A6D6\n2A6D7..2A6DD ; Uncommon_Use # 13.0 [7] CJK UNIFIED IDEOGRAPH-2A6D7..CJK UNIFIED IDEOGRAPH-2A6DD\n2A6DE..2A6DF ; Uncommon_Use # 14.0 [2] CJK UNIFIED IDEOGRAPH-2A6DE..CJK UNIFIED IDEOGRAPH-2A6DF\n2A700..2B734 ; Uncommon_Use # 5.2 [4149] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B734\n2B735..2B738 ; Uncommon_Use # 14.0 [4] CJK UNIFIED IDEOGRAPH-2B735..CJK UNIFIED IDEOGRAPH-2B738\n2B739 ; Uncommon_Use # 15.0 CJK UNIFIED IDEOGRAPH-2B739\n2B73A..2B73F ; Uncommon_Use # 17.0 [6] CJK UNIFIED IDEOGRAPH-2B73A..CJK UNIFIED IDEOGRAPH-2B73F\n2B740..2B81D ; Uncommon_Use # 6.0 [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D\n2B820..2CEA1 ; Uncommon_Use # 8.0 [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1\n2CEA2..2CEAD ; Uncommon_Use # 17.0 [12] CJK UNIFIED IDEOGRAPH-2CEA2..CJK UNIFIED IDEOGRAPH-2CEAD\n2CEB0..2EBE0 ; Uncommon_Use # 10.0 [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0\n2EBF0..2EE5D ; Uncommon_Use # 15.1 [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D\n30000..3134A ; Uncommon_Use # 13.0 [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A\n31350..323AF ; Uncommon_Use # 15.0 [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF\n323B0..33479 ; Uncommon_Use # 17.0 [4298] CJK UNIFIED IDEOGRAPH-323B0..CJK UNIFIED IDEOGRAPH-33479\n\n# Total code points: 83130\n\n#\tIdentifier_Type:\tUncommon_Use Technical\n\n05C7 ; Uncommon_Use Technical # 4.1 HEBREW POINT QAMATS QATAN\n0653 ; Uncommon_Use Technical # 3.0 ARABIC MADDAH ABOVE\n0D8F..0D90 ; Uncommon_Use Technical # 3.0 [2] SINHALA LETTER ILUYANNA..SINHALA LETTER ILUUYANNA\n0DDF ; Uncommon_Use Technical # 3.0 SINHALA VOWEL SIGN GAYANUKITTA\n0DF3 ; Uncommon_Use Technical # 3.0 SINHALA VOWEL SIGN DIGA GAYANUKITTA\n0FC6 ; Uncommon_Use Technical # 3.0 TIBETAN SYMBOL PADMA GDAN\n10F9..10FA ; Uncommon_Use Technical # 4.1 [2] GEORGIAN LETTER TURNED GAN..GEORGIAN LETTER AIN\nFB1E ; Uncommon_Use Technical # 1.1 HEBREW POINT JUDEO-SPANISH VARIKA\nFE2E..FE2F ; Uncommon_Use Technical # 8.0 [2] COMBINING CYRILLIC TITLO LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF\n\n# Total code points: 12\n\n#\tIdentifier_Type:\tUncommon_Use Technical Not_XID\n\n1D1DE..1D1E8 ; Uncommon_Use Technical Not_XID # 8.0 [11] MUSICAL SYMBOL KIEVAN C CLEF..MUSICAL SYMBOL KIEVAN FLAT SIGN\n\n# Total code points: 11\n\n#\tIdentifier_Type:\tUncommon_Use Exclusion\n\n18A9 ; Uncommon_Use Exclusion # 3.0 MONGOLIAN LETTER ALI GALI DAGALGA\n16A40..16A5E ; Uncommon_Use Exclusion # 7.0 [31] MRO LETTER TA..MRO LETTER TEK\n16A60..16A69 ; Uncommon_Use Exclusion # 7.0 [10] MRO DIGIT ZERO..MRO DIGIT NINE\n\n# Total code points: 42\n\n#\tIdentifier_Type:\tUncommon_Use Obsolete\n\n05A2 ; Uncommon_Use Obsolete # 4.1 HEBREW ACCENT ATNAH HAFUKH\n05C5 ; Uncommon_Use Obsolete # 4.1 HEBREW MARK LOWER DOT\n0F6A ; Uncommon_Use Obsolete # 3.0 TIBETAN LETTER FIXED-FORM RA\n0F82..0F83 ; Uncommon_Use Obsolete # 2.0 [2] TIBETAN SIGN NYI ZLA NAA DA..TIBETAN SIGN SNA LDAN\n1050..1059 ; Uncommon_Use Obsolete # 3.0 [10] MYANMAR LETTER SHA..MYANMAR VOWEL SIGN VOCALIC LL\nA69E ; Uncommon_Use Obsolete # 8.0 COMBINING CYRILLIC LETTER EF\nA8FD ; Uncommon_Use Obsolete # 8.0 DEVANAGARI JAIN OM\n\n# Total code points: 17\n\n#\tIdentifier_Type:\tUncommon_Use Obsolete Not_XID\n\nA8FC ; Uncommon_Use Obsolete Not_XID # 8.0 DEVANAGARI SIGN SIDDHAM\n\n# Total code points: 1\n\n#\tIdentifier_Type:\tUncommon_Use Not_XID\n\n218A..218B ; Uncommon_Use Not_XID # 8.0 [2] TURNED DIGIT TWO..TURNED DIGIT THREE\n2BEC..2BEF ; Uncommon_Use Not_XID # 8.0 [4] LEFTWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS..DOWNWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS\n1F54F ; Uncommon_Use Not_XID # 8.0 BOWL OF HYGIEIA\n\n# Total code points: 7\n\n#\tIdentifier_Type:\tTechnical\n\n0180 ; Technical # 1.1 LATIN SMALL LETTER B WITH STROKE\n01C0..01C3 ; Technical # 1.1 [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK\n0200..0217 ; Technical # 1.1 [24] LATIN CAPITAL LETTER A WITH DOUBLE GRAVE..LATIN SMALL LETTER U WITH INVERTED BREVE\n0234..0236 ; Technical # 4.0 [3] LATIN SMALL LETTER L WITH CURL..LATIN SMALL LETTER T WITH CURL\n0250..0252 ; Technical # 1.1 [3] LATIN SMALL LETTER TURNED A..LATIN SMALL LETTER TURNED ALPHA\n0255 ; Technical # 1.1 LATIN SMALL LETTER C WITH CURL\n0258 ; Technical # 1.1 LATIN SMALL LETTER REVERSED E\n025A ; Technical # 1.1 LATIN SMALL LETTER SCHWA WITH HOOK\n025C..0262 ; Technical # 1.1 [7] LATIN SMALL LETTER REVERSED OPEN E..LATIN LETTER SMALL CAPITAL G\n0264..0267 ; Technical # 1.1 [4] LATIN SMALL LETTER RAMS HORN..LATIN SMALL LETTER HENG WITH HOOK\n026A..0271 ; Technical # 1.1 [8] LATIN LETTER SMALL CAPITAL I..LATIN SMALL LETTER M WITH HOOK\n0273..0276 ; Technical # 1.1 [4] LATIN SMALL LETTER N WITH RETROFLEX HOOK..LATIN LETTER SMALL CAPITAL OE\n0278..027B ; Technical # 1.1 [4] LATIN SMALL LETTER PHI..LATIN SMALL LETTER TURNED R WITH HOOK\n027D..0288 ; Technical # 1.1 [12] LATIN SMALL LETTER R WITH TAIL..LATIN SMALL LETTER T WITH RETROFLEX HOOK\n028A ; Technical # 1.1 LATIN SMALL LETTER UPSILON\n028C..0291 ; Technical # 1.1 [6] LATIN SMALL LETTER TURNED V..LATIN SMALL LETTER Z WITH CURL\n0293..029D ; Technical # 1.1 [11] LATIN SMALL LETTER EZH WITH CURL..LATIN SMALL LETTER J WITH CROSSED-TAIL\n029F..02A8 ; Technical # 1.1 [10] LATIN LETTER SMALL CAPITAL L..LATIN SMALL LETTER TC DIGRAPH WITH CURL\n02A9..02AD ; Technical # 3.0 [5] LATIN SMALL LETTER FENG DIGRAPH..LATIN LETTER BIDENTAL PERCUSSIVE\n02AE..02AF ; Technical # 4.0 [2] LATIN SMALL LETTER TURNED H WITH FISHHOOK..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL\n02B9..02BA ; Technical # 1.1 [2] MODIFIER LETTER PRIME..MODIFIER LETTER DOUBLE PRIME\n02BD..02C1 ; Technical # 1.1 [5] MODIFIER LETTER REVERSED COMMA..MODIFIER LETTER REVERSED GLOTTAL STOP\n02C6..02D1 ; Technical # 1.1 [12] MODIFIER LETTER CIRCUMFLEX ACCENT..MODIFIER LETTER HALF TRIANGULAR COLON\n02EC ; Technical # 3.0 MODIFIER LETTER VOICING\n02EE ; Technical # 3.0 MODIFIER LETTER DOUBLE APOSTROPHE\n030E..0315 ; Technical # 1.1 [8] COMBINING DOUBLE VERTICAL LINE ABOVE..COMBINING COMMA ABOVE RIGHT\n0317..031A ; Technical # 1.1 [4] COMBINING ACUTE ACCENT BELOW..COMBINING LEFT ANGLE ABOVE\n031C..0320 ; Technical # 1.1 [5] COMBINING LEFT HALF RING BELOW..COMBINING MINUS SIGN BELOW\n0324..0325 ; Technical # 1.1 [2] COMBINING DIAERESIS BELOW..COMBINING RING BELOW\n0329..0330 ; Technical # 1.1 [8] COMBINING VERTICAL LINE BELOW..COMBINING TILDE BELOW\n0333 ; Technical # 1.1 COMBINING DOUBLE LOW LINE\n0335 ; Technical # 1.1 COMBINING SHORT STROKE OVERLAY\n0337..033F ; Technical # 1.1 [9] COMBINING SHORT SOLIDUS OVERLAY..COMBINING DOUBLE OVERLINE\n0342 ; Technical # 1.1 COMBINING GREEK PERISPOMENI\n0346..034E ; Technical # 3.0 [9] COMBINING BRIDGE ABOVE..COMBINING UPWARDS ARROW BELOW\n0350..0357 ; Technical # 4.0 [8] COMBINING RIGHT ARROWHEAD ABOVE..COMBINING RIGHT HALF RING ABOVE\n0359..035C ; Technical # 4.1 [4] COMBINING ASTERISK BELOW..COMBINING DOUBLE BREVE BELOW\n035D..035F ; Technical # 4.0 [3] COMBINING DOUBLE BREVE..COMBINING DOUBLE MACRON BELOW\n0360..0361 ; Technical # 1.1 [2] COMBINING DOUBLE TILDE..COMBINING DOUBLE INVERTED BREVE\n0362 ; Technical # 3.0 COMBINING DOUBLE RIGHTWARDS ARROW BELOW\n03CF ; Technical # 5.1 GREEK CAPITAL KAI SYMBOL\n03D7 ; Technical # 3.0 GREEK KAI SYMBOL\n0559 ; Technical # 1.1 ARMENIAN MODIFIER LETTER LEFT HALF RING\n0560 ; Technical # 11.0 ARMENIAN SMALL LETTER TURNED AYB\n0588 ; Technical # 11.0 ARMENIAN SMALL LETTER YI WITH STROKE\n0671 ; Technical # 1.1 ARABIC LETTER ALEF WASLA\n06E5..06E6 ; Technical # 1.1 [2] ARABIC SMALL WAW..ARABIC SMALL YEH\n0870..0887 ; Technical # 14.0 [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT\n08C9 ; Technical # 14.0 ARABIC SMALL FARSI YEH\n0950 ; Technical # 1.1 DEVANAGARI OM\n0953..0954 ; Technical # 1.1 [2] DEVANAGARI GRAVE ACCENT..DEVANAGARI ACUTE ACCENT\n097D ; Technical # 4.1 DEVANAGARI LETTER GLOTTAL STOP\n0A74 ; Technical # 1.1 GURMUKHI EK ONKAR\n0AD0 ; Technical # 1.1 GUJARATI OM\n0B82 ; Technical # 1.1 TAMIL SIGN ANUSVARA\n0BD0 ; Technical # 5.1 TAMIL OM\n0D81 ; Technical # 13.0 SINHALA SIGN CANDRABINDU\n0EAF ; Technical # 1.1 LAO ELLIPSIS\n0F00 ; Technical # 2.0 TIBETAN SYLLABLE OM\n0F18..0F19 ; Technical # 2.0 [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS\n0F35 ; Technical # 2.0 TIBETAN MARK NGAS BZUNG NYI ZLA\n0F37 ; Technical # 2.0 TIBETAN MARK NGAS BZUNG SGOR RTAGS\n0F3E..0F3F ; Technical # 2.0 [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES\n17CE..17CF ; Technical # 3.0 [2] KHMER SIGN KAKABAT..KHMER SIGN AHSDA\n1ABF..1AC0 ; Technical # 13.0 [2] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER TURNED W BELOW\n1ACF..1ADD ; Technical # 17.0 [15] COMBINING DOUBLE CARON..COMBINING DOT-AND-RING BELOW\n1AE0..1AEB ; Technical # 17.0 [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE\n1D00..1D2B ; Technical # 4.0 [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL\n1D2F ; Technical # 4.0 MODIFIER LETTER CAPITAL BARRED B\n1D3B ; Technical # 4.0 MODIFIER LETTER CAPITAL REVERSED N\n1D4E ; Technical # 4.0 MODIFIER LETTER SMALL TURNED I\n1D6B ; Technical # 4.0 LATIN SMALL LETTER UE\n1D6C..1D77 ; Technical # 4.1 [12] LATIN SMALL LETTER B WITH MIDDLE TILDE..LATIN SMALL LETTER TURNED G\n1D79..1D9A ; Technical # 4.1 [34] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK\n1DC4..1DCA ; Technical # 5.0 [7] COMBINING MACRON-ACUTE..COMBINING LATIN SMALL LETTER R BELOW\n1DCB..1DCD ; Technical # 5.1 [3] COMBINING BREVE-MACRON..COMBINING DOUBLE CIRCUMFLEX ABOVE\n1DCF..1DD0 ; Technical # 5.1 [2] COMBINING ZIGZAG BELOW..COMBINING IS BELOW\n1DE7..1DF5 ; Technical # 7.0 [15] COMBINING LATIN SMALL LETTER ALPHA..COMBINING UP TACK ABOVE\n1DF6..1DF9 ; Technical # 10.0 [4] COMBINING KAVYKA ABOVE RIGHT..COMBINING WIDE INVERTED BRIDGE BELOW\n1DFB ; Technical # 9.0 COMBINING DELETION MARK\n1DFC ; Technical # 6.0 COMBINING DOUBLE INVERTED BREVE BELOW\n1DFD ; Technical # 5.2 COMBINING ALMOST EQUAL TO BELOW\n1DFE..1DFF ; Technical # 5.0 [2] COMBINING LEFT ARROWHEAD ABOVE..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW\n1E00..1E01 ; Technical # 1.1 [2] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER A WITH RING BELOW\n1E18..1E1B ; Technical # 1.1 [4] LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER E WITH TILDE BELOW\n1E2A..1E2D ; Technical # 1.1 [4] LATIN CAPITAL LETTER H WITH BREVE BELOW..LATIN SMALL LETTER I WITH TILDE BELOW\n1E72..1E77 ; Technical # 1.1 [6] LATIN CAPITAL LETTER U WITH DIAERESIS BELOW..LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW\n1E9C..1E9D ; Technical # 5.1 [2] LATIN SMALL LETTER LONG S WITH DIAGONAL STROKE..LATIN SMALL LETTER LONG S WITH HIGH STROKE\n1E9F ; Technical # 5.1 LATIN SMALL LETTER DELTA\n1EFA..1EFF ; Technical # 5.1 [6] LATIN CAPITAL LETTER MIDDLE-WELSH LL..LATIN SMALL LETTER Y WITH LOOP\n203F..2040 ; Technical # 1.1 [2] UNDERTIE..CHARACTER TIE\n20D0..20DC ; Technical # 1.1 [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE\n20E1 ; Technical # 1.1 COMBINING LEFT RIGHT ARROW ABOVE\n20E5..20EA ; Technical # 3.2 [6] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING LEFTWARDS ARROW OVERLAY\n20EB ; Technical # 4.1 COMBINING LONG DOUBLE SOLIDUS OVERLAY\n20EC..20EF ; Technical # 5.0 [4] COMBINING RIGHTWARDS HARPOON WITH BARB DOWNWARDS..COMBINING RIGHT ARROW BELOW\n20F0 ; Technical # 5.1 COMBINING ASTERISK ABOVE\n2118 ; Technical # 1.1 SCRIPT CAPITAL P\n212E ; Technical # 1.1 ESTIMATED SYMBOL\n2C60..2C67 ; Technical # 5.0 [8] LATIN CAPITAL LETTER L WITH DOUBLE BAR..LATIN CAPITAL LETTER H WITH DESCENDER\n2C77 ; Technical # 5.0 LATIN SMALL LETTER TAILLESS PHI\n2C78..2C7B ; Technical # 5.1 [4] LATIN SMALL LETTER E WITH NOTCH..LATIN LETTER SMALL CAPITAL TURNED E\n2D27 ; Technical # 6.1 GEORGIAN SMALL LETTER YN\n2D2D ; Technical # 6.1 GEORGIAN SMALL LETTER AEN\n3021..302D ; Technical # 1.1 [13] HANGZHOU NUMERAL ONE..IDEOGRAPHIC ENTERING TONE MARK\n3031..3035 ; Technical # 1.1 [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF\n303B..303C ; Technical # 3.2 [2] VERTICAL IDEOGRAPHIC ITERATION MARK..MASU MARK\nA717..A71A ; Technical # 5.0 [4] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOWER RIGHT CORNER ANGLE\nA71B..A71F ; Technical # 5.1 [5] MODIFIER LETTER RAISED UP ARROW..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK\nA788 ; Technical # 5.1 MODIFIER LETTER LOW CIRCUMFLEX ACCENT\nA78E ; Technical # 6.0 LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT\nA7AE ; Technical # 9.0 LATIN CAPITAL LETTER SMALL CAPITAL I\nA7AF ; Technical # 11.0 LATIN LETTER SMALL CAPITAL Q\nA7BA..A7BF ; Technical # 12.0 [6] LATIN CAPITAL LETTER GLOTTAL A..LATIN SMALL LETTER GLOTTAL U\nA7C5..A7C6 ; Technical # 12.0 [2] LATIN CAPITAL LETTER S WITH HOOK..LATIN CAPITAL LETTER Z WITH PALATAL HOOK\nA7FA ; Technical # 6.0 LATIN LETTER SMALL CAPITAL TURNED M\nAB68 ; Technical # 13.0 LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE\nFE20..FE23 ; Technical # 1.1 [4] COMBINING LIGATURE LEFT HALF..COMBINING DOUBLE TILDE RIGHT HALF\nFE24..FE26 ; Technical # 5.1 [3] COMBINING MACRON LEFT HALF..COMBINING CONJOINING MACRON\nFE27..FE2D ; Technical # 7.0 [7] COMBINING LIGATURE LEFT HALF BELOW..COMBINING CONJOINING MACRON BELOW\nFE73 ; Technical # 3.2 ARABIC TAIL FRAGMENT\n10EC5..10EC6 ; Technical # 17.0 [2] ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW..ARABIC LETTER THIN NOON\n10EFB ; Technical # 17.0 ARABIC SMALL LOW NOON\n16FF2..16FF6 ; Technical # 17.0 [5] CHINESE SMALL SIMPLIFIED ER..YANGQIN SIGN SLOW TWO BEATS\n1CF00..1CF2D ; Technical # 14.0 [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT\n1CF30..1CF46 ; Technical # 14.0 [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG\n1D165..1D169 ; Technical # 3.1 [5] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING TREMOLO-3\n1D16D..1D172 ; Technical # 3.1 [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5\n1D17B..1D182 ; Technical # 3.1 [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE\n1D185..1D18B ; Technical # 3.1 [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE\n1D1AA..1D1AD ; Technical # 3.1 [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO\n1DF00..1DF1E ; Technical # 14.0 [31] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER S WITH CURL\n1DF25..1DF2A ; Technical # 15.0 [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK\n\n# Total code points: 682\n\n#\tIdentifier_Type:\tTechnical Exclusion\n\n2CF0..2CF1 ; Technical Exclusion # 5.2 [2] COPTIC COMBINING SPIRITUS ASPER..COPTIC COMBINING SPIRITUS LENIS\n\n# Total code points: 2\n\n#\tIdentifier_Type:\tTechnical Obsolete\n\n018D ; Technical Obsolete # 1.1 LATIN SMALL LETTER TURNED DELTA\n01AA..01AB ; Technical Obsolete # 1.1 [2] LATIN LETTER REVERSED ESH LOOP..LATIN SMALL LETTER T WITH PALATAL HOOK\n01BA..01BB ; Technical Obsolete # 1.1 [2] LATIN SMALL LETTER EZH WITH TAIL..LATIN LETTER TWO WITH STROKE\n01BE ; Technical Obsolete # 1.1 LATIN LETTER INVERTED GLOTTAL STOP WITH STROKE\n0277 ; Technical Obsolete # 1.1 LATIN SMALL LETTER CLOSED OMEGA\n027C ; Technical Obsolete # 1.1 LATIN SMALL LETTER R WITH LONG LEG\n029E ; Technical Obsolete # 1.1 LATIN SMALL LETTER TURNED K\n03F3 ; Technical Obsolete # 1.1 GREEK LETTER YOT\n03FC ; Technical Obsolete # 4.1 GREEK RHO WITH STROKE SYMBOL\n0484..0486 ; Technical Obsolete # 1.1 [3] COMBINING CYRILLIC PALATALIZATION..COMBINING CYRILLIC PSILI PNEUMATA\n0487 ; Technical Obsolete # 5.1 COMBINING CYRILLIC POKRYTIE\n0D04 ; Technical Obsolete # 13.0 MALAYALAM LETTER VEDIC ANUSVARA\n17D1 ; Technical Obsolete # 3.0 KHMER SIGN VIRIAM\n17DD ; Technical Obsolete # 4.0 KHMER SIGN ATTHACAN\n1DC0..1DC3 ; Technical Obsolete # 4.1 [4] COMBINING DOTTED GRAVE ACCENT..COMBINING SUSPENSION MARK\n1DCE ; Technical Obsolete # 5.1 COMBINING OGONEK ABOVE\n1DD1..1DE6 ; Technical Obsolete # 5.1 [22] COMBINING UR ABOVE..COMBINING LATIN SMALL LETTER Z\n1FB0..1FB1 ; Technical Obsolete # 1.1 [2] GREEK SMALL LETTER ALPHA WITH VRACHY..GREEK SMALL LETTER ALPHA WITH MACRON\n2180..2182 ; Technical Obsolete # 1.1 [3] ROMAN NUMERAL ONE THOUSAND C D..ROMAN NUMERAL TEN THOUSAND\n2183 ; Technical Obsolete # 3.0 ROMAN NUMERAL REVERSED ONE HUNDRED\n302E..302F ; Technical Obsolete # 1.1 [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK\nA722..A72F ; Technical Obsolete # 5.1 [14] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CUATRILLO WITH COMMA\n1D242..1D244 ; Technical Obsolete # 4.1 [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME\n\n# Total code points: 70\n\n#\tIdentifier_Type:\tTechnical Obsolete Not_XID\n\n2E00..2E0D ; Technical Obsolete Not_XID # 4.1 [14] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT RAISED OMISSION BRACKET\n\n# Total code points: 14\n\n#\tIdentifier_Type:\tTechnical Not_XID\n\n0375 ; Technical Not_XID # 1.1 GREEK LOWER NUMERAL SIGN\n0888 ; Technical Not_XID # 14.0 ARABIC RAISED ROUND DOT\n20DD..20E0 ; Technical Not_XID # 1.1 [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH\n20E2..20E3 ; Technical Not_XID # 3.0 [2] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING KEYCAP\n20E4 ; Technical Not_XID # 3.2 COMBINING ENCLOSING UPWARD POINTING TRIANGLE\n24EB..24FE ; Technical Not_XID # 3.2 [20] NEGATIVE CIRCLED NUMBER ELEVEN..DOUBLE CIRCLED NUMBER TEN\n24FF ; Technical Not_XID # 4.0 NEGATIVE CIRCLED DIGIT ZERO\n2800..28FF ; Technical Not_XID # 3.0 [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678\n327F ; Technical Not_XID # 1.1 KOREAN STANDARD SYMBOL\n4DC0..4DFF ; Technical Not_XID # 4.0 [64] HEXAGRAM FOR THE CREATIVE HEAVEN..HEXAGRAM FOR BEFORE COMPLETION\nA708..A716 ; Technical Not_XID # 4.1 [15] MODIFIER LETTER EXTRA-HIGH DOTTED TONE BAR..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR\nFBB2..FBC1 ; Technical Not_XID # 6.0 [16] ARABIC SYMBOL DOT ABOVE..ARABIC SYMBOL SMALL TAH BELOW\nFBC2 ; Technical Not_XID # 14.0 ARABIC SYMBOL WASLA ABOVE\nFBC3..FBD2 ; Technical Not_XID # 17.0 [16] ARABIC LIGATURE JALLA WA-ALAA..ARABIC LIGATURE ALAYHI AR-RAHMAH\nFD3E..FD3F ; Technical Not_XID # 1.1 [2] ORNATE LEFT PARENTHESIS..ORNATE RIGHT PARENTHESIS\nFD40..FD4F ; Technical Not_XID # 14.0 [16] ARABIC LIGATURE RAHIMAHU ALLAAH..ARABIC LIGATURE RAHIMAHUM ALLAAH\nFD90..FD91 ; Technical Not_XID # 17.0 [2] ARABIC LIGATURE RAHMATU ALLAAHI ALAYH..ARABIC LIGATURE RAHMATU ALLAAHI ALAYHAA\nFDC8..FDCE ; Technical Not_XID # 17.0 [7] ARABIC LIGATURE RAHIMAHU ALLAAH TAAALAA..ARABIC LIGATURE KARRAMA ALLAAHU WAJHAH\nFDCF ; Technical Not_XID # 14.0 ARABIC LIGATURE SALAAMUHU ALAYNAA\nFDFD ; Technical Not_XID # 4.0 ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM\nFDFE..FDFF ; Technical Not_XID # 14.0 [2] ARABIC LIGATURE SUBHAANAHU WA TAAALAA..ARABIC LIGATURE AZZA WA JALL\nFE45..FE46 ; Technical Not_XID # 3.2 [2] SESAME DOT..WHITE SESAME DOT\n1CF50..1CFC3 ; Technical Not_XID # 14.0 [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK\n1D000..1D0F5 ; Technical Not_XID # 3.1 [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO\n1D100..1D126 ; Technical Not_XID # 3.1 [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2\n1D129 ; Technical Not_XID # 5.1 MUSICAL SYMBOL MULTIPLE MEASURE REST\n1D12A..1D15D ; Technical Not_XID # 3.1 [52] MUSICAL SYMBOL DOUBLE SHARP..MUSICAL SYMBOL WHOLE NOTE\n1D16A..1D16C ; Technical Not_XID # 3.1 [3] MUSICAL SYMBOL FINGERED TREMOLO-1..MUSICAL SYMBOL FINGERED TREMOLO-3\n1D183..1D184 ; Technical Not_XID # 3.1 [2] MUSICAL SYMBOL ARPEGGIATO UP..MUSICAL SYMBOL ARPEGGIATO DOWN\n1D18C..1D1A9 ; Technical Not_XID # 3.1 [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH\n1D1AE..1D1BA ; Technical Not_XID # 3.1 [13] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL SEMIBREVIS BLACK\n1D1C1..1D1DD ; Technical Not_XID # 3.1 [29] MUSICAL SYMBOL LONGA PERFECTA REST..MUSICAL SYMBOL PES SUBPUNCTIS\n1D1E9..1D1EA ; Technical Not_XID # 14.0 [2] MUSICAL SYMBOL SORI..MUSICAL SYMBOL KORON\n1D300..1D356 ; Technical Not_XID # 4.0 [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING\n\n# Total code points: 1052\n\n#\tIdentifier_Type:\tExclusion\n\n03E2..03EF ; Exclusion # 1.1 [14] COPTIC CAPITAL LETTER SHEI..COPTIC SMALL LETTER DEI\n0800..082D ; Exclusion # 5.2 [46] SAMARITAN LETTER ALAF..SAMARITAN MARK NEQUDAA\n1681..169A ; Exclusion # 3.0 [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH\n16A0..16EA ; Exclusion # 3.0 [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X\n16EE..16F0 ; Exclusion # 3.0 [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL\n16F1..16F8 ; Exclusion # 7.0 [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC\n1700..170C ; Exclusion # 3.2 [13] TAGALOG LETTER A..TAGALOG LETTER YA\n170D ; Exclusion # 14.0 TAGALOG LETTER RA\n170E..1714 ; Exclusion # 3.2 [7] TAGALOG LETTER LA..TAGALOG SIGN VIRAMA\n1715 ; Exclusion # 14.0 TAGALOG SIGN PAMUDPOD\n171F ; Exclusion # 14.0 TAGALOG LETTER ARCHAIC RA\n1720..1734 ; Exclusion # 3.2 [21] HANUNOO LETTER A..HANUNOO SIGN PAMUDPOD\n1740..1753 ; Exclusion # 3.2 [20] BUHID LETTER A..BUHID VOWEL SIGN U\n1760..176C ; Exclusion # 3.2 [13] TAGBANWA LETTER A..TAGBANWA LETTER YA\n176E..1770 ; Exclusion # 3.2 [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA\n1772..1773 ; Exclusion # 3.2 [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U\n1810..1819 ; Exclusion # 3.0 [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE\n1820..1877 ; Exclusion # 3.0 [88] MONGOLIAN LETTER A..MONGOLIAN LETTER MANCHU ZHA\n1878 ; Exclusion # 11.0 MONGOLIAN LETTER CHA WITH TWO DOTS\n1880..18A8 ; Exclusion # 3.0 [41] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER MANCHU ALI GALI BHA\n18AA ; Exclusion # 5.1 MONGOLIAN LETTER MANCHU ALI GALI LHA\n1A00..1A1B ; Exclusion # 4.1 [28] BUGINESE LETTER KA..BUGINESE VOWEL SIGN AE\n1CFA ; Exclusion # 12.0 VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA\n2C00..2C2E ; Exclusion # 4.1 [47] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC CAPITAL LETTER LATINATE MYSLITE\n2C2F ; Exclusion # 14.0 GLAGOLITIC CAPITAL LETTER CAUDATE CHRIVI\n2C30..2C5E ; Exclusion # 4.1 [47] GLAGOLITIC SMALL LETTER AZU..GLAGOLITIC SMALL LETTER LATINATE MYSLITE\n2C5F ; Exclusion # 14.0 GLAGOLITIC SMALL LETTER CAUDATE CHRIVI\n2C80..2CE4 ; Exclusion # 4.1 [101] COPTIC CAPITAL LETTER ALFA..COPTIC SYMBOL KAI\n2CEB..2CEF ; Exclusion # 5.2 [5] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC COMBINING NI ABOVE\n2CF2..2CF3 ; Exclusion # 6.1 [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI\nA840..A873 ; Exclusion # 5.0 [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU\nA930..A953 ; Exclusion # 5.1 [36] REJANG LETTER KA..REJANG VIRAMA\n10000..1000B ; Exclusion # 4.0 [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE\n1000D..10026 ; Exclusion # 4.0 [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO\n10028..1003A ; Exclusion # 4.0 [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO\n1003C..1003D ; Exclusion # 4.0 [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE\n1003F..1004D ; Exclusion # 4.0 [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO\n10050..1005D ; Exclusion # 4.0 [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089\n10080..100FA ; Exclusion # 4.0 [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305\n10280..1029C ; Exclusion # 5.1 [29] LYCIAN LETTER A..LYCIAN LETTER X\n102A0..102D0 ; Exclusion # 5.1 [49] CARIAN LETTER A..CARIAN LETTER UUU3\n10300..1031E ; Exclusion # 3.1 [31] OLD ITALIC LETTER A..OLD ITALIC LETTER UU\n1031F ; Exclusion # 7.0 OLD ITALIC LETTER ESS\n1032D..1032F ; Exclusion # 10.0 [3] OLD ITALIC LETTER YE..OLD ITALIC LETTER SOUTHERN TSE\n10330..1034A ; Exclusion # 3.1 [27] GOTHIC LETTER AHSA..GOTHIC LETTER NINE HUNDRED\n10350..1037A ; Exclusion # 7.0 [43] OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII\n10380..1039D ; Exclusion # 4.0 [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU\n103A0..103C3 ; Exclusion # 4.1 [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA\n103C8..103CF ; Exclusion # 4.1 [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH\n103D1..103D5 ; Exclusion # 4.1 [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED\n10400..10425 ; Exclusion # 3.1 [38] DESERET CAPITAL LETTER LONG I..DESERET CAPITAL LETTER ENG\n10426..10427 ; Exclusion # 4.0 [2] DESERET CAPITAL LETTER OI..DESERET CAPITAL LETTER EW\n10428..1044D ; Exclusion # 3.1 [38] DESERET SMALL LETTER LONG I..DESERET SMALL LETTER ENG\n1044E..1049D ; Exclusion # 4.0 [80] DESERET SMALL LETTER OI..OSMANYA LETTER OO\n104A0..104A9 ; Exclusion # 4.0 [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE\n10500..10527 ; Exclusion # 7.0 [40] ELBASAN LETTER A..ELBASAN LETTER KHE\n10530..10563 ; Exclusion # 7.0 [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW\n10570..1057A ; Exclusion # 14.0 [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA\n1057C..1058A ; Exclusion # 14.0 [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE\n1058C..10592 ; Exclusion # 14.0 [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE\n10594..10595 ; Exclusion # 14.0 [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE\n10597..105A1 ; Exclusion # 14.0 [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA\n105A3..105B1 ; Exclusion # 14.0 [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE\n105B3..105B9 ; Exclusion # 14.0 [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE\n105BB..105BC ; Exclusion # 14.0 [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE\n105C0..105F3 ; Exclusion # 16.0 [52] TODHRI LETTER A..TODHRI LETTER OO\n10600..10736 ; Exclusion # 7.0 [311] LINEAR A SIGN AB001..LINEAR A SIGN A664\n10740..10755 ; Exclusion # 7.0 [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE\n10760..10767 ; Exclusion # 7.0 [8] LINEAR A SIGN A800..LINEAR A SIGN A807\n10800..10805 ; Exclusion # 4.0 [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA\n10808 ; Exclusion # 4.0 CYPRIOT SYLLABLE JO\n1080A..10835 ; Exclusion # 4.0 [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO\n10837..10838 ; Exclusion # 4.0 [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE\n1083C ; Exclusion # 4.0 CYPRIOT SYLLABLE ZA\n1083F ; Exclusion # 4.0 CYPRIOT SYLLABLE ZO\n10840..10855 ; Exclusion # 5.2 [22] IMPERIAL ARAMAIC LETTER ALEPH..IMPERIAL ARAMAIC LETTER TAW\n10860..10876 ; Exclusion # 7.0 [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW\n10880..1089E ; Exclusion # 7.0 [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW\n108E0..108F2 ; Exclusion # 8.0 [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH\n108F4..108F5 ; Exclusion # 8.0 [2] HATRAN LETTER SHIN..HATRAN LETTER TAW\n10900..10915 ; Exclusion # 5.0 [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU\n10920..10939 ; Exclusion # 5.1 [26] LYDIAN LETTER A..LYDIAN LETTER C\n10940..10959 ; Exclusion # 17.0 [26] SIDETIC LETTER N01..SIDETIC LETTER N26\n10980..109B7 ; Exclusion # 6.1 [56] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC CURSIVE LETTER DA\n109BE..109BF ; Exclusion # 6.1 [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN\n10A00..10A03 ; Exclusion # 4.1 [4] KHAROSHTHI LETTER A..KHAROSHTHI VOWEL SIGN VOCALIC R\n10A05..10A06 ; Exclusion # 4.1 [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O\n10A0C..10A13 ; Exclusion # 4.1 [8] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI LETTER GHA\n10A15..10A17 ; Exclusion # 4.1 [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA\n10A19..10A33 ; Exclusion # 4.1 [27] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER TTTHA\n10A34..10A35 ; Exclusion # 11.0 [2] KHAROSHTHI LETTER TTTA..KHAROSHTHI LETTER VHA\n10A38..10A3A ; Exclusion # 4.1 [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW\n10A3F ; Exclusion # 4.1 KHAROSHTHI VIRAMA\n10A60..10A7C ; Exclusion # 5.2 [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH\n10A80..10A9C ; Exclusion # 7.0 [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH\n10AC0..10AC7 ; Exclusion # 7.0 [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW\n10AC9..10AE6 ; Exclusion # 7.0 [30] MANICHAEAN LETTER ZAYIN..MANICHAEAN ABBREVIATION MARK BELOW\n10B00..10B35 ; Exclusion # 5.2 [54] AVESTAN LETTER A..AVESTAN LETTER HE\n10B40..10B55 ; Exclusion # 5.2 [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW\n10B60..10B72 ; Exclusion # 5.2 [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW\n10B80..10B91 ; Exclusion # 7.0 [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW\n10C00..10C48 ; Exclusion # 5.2 [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH\n10C80..10CB2 ; Exclusion # 8.0 [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US\n10CC0..10CF2 ; Exclusion # 8.0 [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US\n10D40..10D65 ; Exclusion # 16.0 [38] GARAY DIGIT ZERO..GARAY CAPITAL LETTER OLD NA\n10D69..10D6D ; Exclusion # 16.0 [5] GARAY VOWEL SIGN E..GARAY CONSONANT NASALIZATION MARK\n10D6F..10D85 ; Exclusion # 16.0 [23] GARAY REDUPLICATION MARK..GARAY SMALL LETTER OLD NA\n10E80..10EA9 ; Exclusion # 13.0 [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET\n10EAB..10EAC ; Exclusion # 13.0 [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK\n10EB0..10EB1 ; Exclusion # 13.0 [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE\n10F00..10F1C ; Exclusion # 11.0 [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL\n10F27 ; Exclusion # 11.0 OLD SOGDIAN LIGATURE AYIN-DALETH\n10F30..10F50 ; Exclusion # 11.0 [33] SOGDIAN LETTER ALEPH..SOGDIAN COMBINING STROKE BELOW\n10F70..10F85 ; Exclusion # 14.0 [22] OLD UYGHUR LETTER ALEPH..OLD UYGHUR COMBINING TWO DOTS BELOW\n10FB0..10FC4 ; Exclusion # 13.0 [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW\n10FE0..10FF6 ; Exclusion # 12.0 [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH\n11000..11046 ; Exclusion # 6.0 [71] BRAHMI SIGN CANDRABINDU..BRAHMI VIRAMA\n11066..1106F ; Exclusion # 6.0 [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE\n11070..11075 ; Exclusion # 14.0 [6] BRAHMI SIGN OLD TAMIL VIRAMA..BRAHMI LETTER OLD TAMIL LLA\n1107F ; Exclusion # 7.0 BRAHMI NUMBER JOINER\n11080..110BA ; Exclusion # 5.2 [59] KAITHI SIGN CANDRABINDU..KAITHI SIGN NUKTA\n110C2 ; Exclusion # 14.0 KAITHI VOWEL SIGN VOCALIC R\n110D0..110E8 ; Exclusion # 6.1 [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE\n110F0..110F9 ; Exclusion # 6.1 [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE\n11150..11173 ; Exclusion # 7.0 [36] MAHAJANI LETTER A..MAHAJANI SIGN NUKTA\n11176 ; Exclusion # 7.0 MAHAJANI LIGATURE SHRI\n11180..111C4 ; Exclusion # 6.1 [69] SHARADA SIGN CANDRABINDU..SHARADA OM\n111C9..111CC ; Exclusion # 8.0 [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK\n111CE..111CF ; Exclusion # 13.0 [2] SHARADA VOWEL SIGN PRISHTHAMATRA E..SHARADA SIGN INVERTED CANDRABINDU\n111D0..111D9 ; Exclusion # 6.1 [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE\n111DA ; Exclusion # 7.0 SHARADA EKAM\n111DC ; Exclusion # 8.0 SHARADA HEADSTROKE\n11200..11211 ; Exclusion # 7.0 [18] KHOJKI LETTER A..KHOJKI LETTER JJA\n11213..11237 ; Exclusion # 7.0 [37] KHOJKI LETTER NYA..KHOJKI SIGN SHADDA\n1123E ; Exclusion # 9.0 KHOJKI SIGN SUKUN\n1123F..11241 ; Exclusion # 15.0 [3] KHOJKI LETTER QA..KHOJKI VOWEL SIGN VOCALIC R\n11280..11286 ; Exclusion # 8.0 [7] MULTANI LETTER A..MULTANI LETTER GA\n11288 ; Exclusion # 8.0 MULTANI LETTER GHA\n1128A..1128D ; Exclusion # 8.0 [4] MULTANI LETTER CA..MULTANI LETTER JJA\n1128F..1129D ; Exclusion # 8.0 [15] MULTANI LETTER NYA..MULTANI LETTER BA\n1129F..112A8 ; Exclusion # 8.0 [10] MULTANI LETTER BHA..MULTANI LETTER RHA\n112B0..112EA ; Exclusion # 7.0 [59] KHUDAWADI LETTER A..KHUDAWADI SIGN VIRAMA\n112F0..112F9 ; Exclusion # 7.0 [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE\n11300 ; Exclusion # 8.0 GRANTHA SIGN COMBINING ANUSVARA ABOVE\n11302 ; Exclusion # 7.0 GRANTHA SIGN ANUSVARA\n11305..1130C ; Exclusion # 7.0 [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L\n1130F..11310 ; Exclusion # 7.0 [2] GRANTHA LETTER EE..GRANTHA LETTER AI\n11313..11328 ; Exclusion # 7.0 [22] GRANTHA LETTER OO..GRANTHA LETTER NA\n1132A..11330 ; Exclusion # 7.0 [7] GRANTHA LETTER PA..GRANTHA LETTER RA\n11332..11333 ; Exclusion # 7.0 [2] GRANTHA LETTER LA..GRANTHA LETTER LLA\n11335..11339 ; Exclusion # 7.0 [5] GRANTHA LETTER VA..GRANTHA LETTER HA\n1133D..11344 ; Exclusion # 7.0 [8] GRANTHA SIGN AVAGRAHA..GRANTHA VOWEL SIGN VOCALIC RR\n11347..11348 ; Exclusion # 7.0 [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI\n1134B..1134D ; Exclusion # 7.0 [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA\n11350 ; Exclusion # 8.0 GRANTHA OM\n11357 ; Exclusion # 7.0 GRANTHA AU LENGTH MARK\n1135D..11363 ; Exclusion # 7.0 [7] GRANTHA SIGN PLUTA..GRANTHA VOWEL SIGN VOCALIC LL\n11366..1136C ; Exclusion # 7.0 [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX\n11370..11374 ; Exclusion # 7.0 [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA\n11380..11389 ; Exclusion # 16.0 [10] TULU-TIGALARI LETTER A..TULU-TIGALARI LETTER VOCALIC LL\n1138B ; Exclusion # 16.0 TULU-TIGALARI LETTER EE\n1138E ; Exclusion # 16.0 TULU-TIGALARI LETTER AI\n11390..113B5 ; Exclusion # 16.0 [38] TULU-TIGALARI LETTER OO..TULU-TIGALARI LETTER LLLA\n113B7..113C0 ; Exclusion # 16.0 [10] TULU-TIGALARI SIGN AVAGRAHA..TULU-TIGALARI VOWEL SIGN VOCALIC LL\n113C2 ; Exclusion # 16.0 TULU-TIGALARI VOWEL SIGN EE\n113C5 ; Exclusion # 16.0 TULU-TIGALARI VOWEL SIGN AI\n113C7..113CA ; Exclusion # 16.0 [4] TULU-TIGALARI VOWEL SIGN OO..TULU-TIGALARI SIGN CANDRA ANUNASIKA\n113CC..113D3 ; Exclusion # 16.0 [8] TULU-TIGALARI SIGN ANUSVARA..TULU-TIGALARI SIGN PLUTA\n113E1..113E2 ; Exclusion # 16.0 [2] TULU-TIGALARI VEDIC TONE SVARITA..TULU-TIGALARI VEDIC TONE ANUDATTA\n11480..114C5 ; Exclusion # 7.0 [70] TIRHUTA ANJI..TIRHUTA GVANG\n114C7 ; Exclusion # 7.0 TIRHUTA OM\n114D0..114D9 ; Exclusion # 7.0 [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE\n11580..115B5 ; Exclusion # 7.0 [54] SIDDHAM LETTER A..SIDDHAM VOWEL SIGN VOCALIC RR\n115B8..115C0 ; Exclusion # 7.0 [9] SIDDHAM VOWEL SIGN E..SIDDHAM SIGN NUKTA\n115D8..115DD ; Exclusion # 8.0 [6] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM VOWEL SIGN ALTERNATE UU\n11600..11640 ; Exclusion # 7.0 [65] MODI LETTER A..MODI SIGN ARDHACANDRA\n11644 ; Exclusion # 7.0 MODI SIGN HUVA\n11650..11659 ; Exclusion # 7.0 [10] MODI DIGIT ZERO..MODI DIGIT NINE\n11680..116B7 ; Exclusion # 6.1 [56] TAKRI LETTER A..TAKRI SIGN NUKTA\n116B8 ; Exclusion # 12.0 TAKRI LETTER ARCHAIC KHA\n116C0..116C9 ; Exclusion # 6.1 [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE\n11700..11719 ; Exclusion # 8.0 [26] AHOM LETTER KA..AHOM LETTER JHA\n1171A ; Exclusion # 11.0 AHOM LETTER ALTERNATE BA\n1171D..1172B ; Exclusion # 8.0 [15] AHOM CONSONANT SIGN MEDIAL LA..AHOM SIGN KILLER\n11730..11739 ; Exclusion # 8.0 [10] AHOM DIGIT ZERO..AHOM DIGIT NINE\n11740..11746 ; Exclusion # 14.0 [7] AHOM LETTER CA..AHOM LETTER LLA\n11800..1183A ; Exclusion # 11.0 [59] DOGRA LETTER A..DOGRA SIGN NUKTA\n118A0..118E9 ; Exclusion # 7.0 [74] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI DIGIT NINE\n118FF ; Exclusion # 7.0 WARANG CITI OM\n11900..11906 ; Exclusion # 13.0 [7] DIVES AKURU LETTER A..DIVES AKURU LETTER E\n11909 ; Exclusion # 13.0 DIVES AKURU LETTER O\n1190C..11913 ; Exclusion # 13.0 [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA\n11915..11916 ; Exclusion # 13.0 [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA\n11918..11935 ; Exclusion # 13.0 [30] DIVES AKURU LETTER DDA..DIVES AKURU VOWEL SIGN E\n11937..11938 ; Exclusion # 13.0 [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O\n1193B..11943 ; Exclusion # 13.0 [9] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN NUKTA\n11950..11959 ; Exclusion # 13.0 [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE\n119A0..119A7 ; Exclusion # 12.0 [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR\n119AA..119D7 ; Exclusion # 12.0 [46] NANDINAGARI LETTER E..NANDINAGARI VOWEL SIGN VOCALIC RR\n119DA..119E1 ; Exclusion # 12.0 [8] NANDINAGARI VOWEL SIGN E..NANDINAGARI SIGN AVAGRAHA\n119E3..119E4 ; Exclusion # 12.0 [2] NANDINAGARI HEADSTROKE..NANDINAGARI VOWEL SIGN PRISHTHAMATRA E\n11A00..11A3E ; Exclusion # 10.0 [63] ZANABAZAR SQUARE LETTER A..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA\n11A47 ; Exclusion # 10.0 ZANABAZAR SQUARE SUBJOINER\n11A50..11A83 ; Exclusion # 10.0 [52] SOYOMBO LETTER A..SOYOMBO LETTER KSSA\n11A84..11A85 ; Exclusion # 12.0 [2] SOYOMBO SIGN JIHVAMULIYA..SOYOMBO SIGN UPADHMANIYA\n11A86..11A99 ; Exclusion # 10.0 [20] SOYOMBO CLUSTER-INITIAL LETTER RA..SOYOMBO SUBJOINER\n11A9D ; Exclusion # 11.0 SOYOMBO MARK PLUTA\n11AC0..11AF8 ; Exclusion # 7.0 [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL\n11B60..11B67 ; Exclusion # 17.0 [8] SHARADA VOWEL SIGN OE..SHARADA VOWEL SIGN CANDRA O\n11BC0..11BE0 ; Exclusion # 16.0 [33] SUNUWAR LETTER DEVI..SUNUWAR LETTER KLOKO\n11BF0..11BF9 ; Exclusion # 16.0 [10] SUNUWAR DIGIT ZERO..SUNUWAR DIGIT NINE\n11C00..11C08 ; Exclusion # 9.0 [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L\n11C0A..11C36 ; Exclusion # 9.0 [45] BHAIKSUKI LETTER E..BHAIKSUKI VOWEL SIGN VOCALIC L\n11C38..11C40 ; Exclusion # 9.0 [9] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN AVAGRAHA\n11C50..11C59 ; Exclusion # 9.0 [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE\n11C72..11C8F ; Exclusion # 9.0 [30] MARCHEN LETTER KA..MARCHEN LETTER A\n11C92..11CA7 ; Exclusion # 9.0 [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA\n11CA9..11CB6 ; Exclusion # 9.0 [14] MARCHEN SUBJOINED LETTER YA..MARCHEN SIGN CANDRABINDU\n11D00..11D06 ; Exclusion # 10.0 [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E\n11D08..11D09 ; Exclusion # 10.0 [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O\n11D0B..11D36 ; Exclusion # 10.0 [44] MASARAM GONDI LETTER AU..MASARAM GONDI VOWEL SIGN VOCALIC R\n11D3A ; Exclusion # 10.0 MASARAM GONDI VOWEL SIGN E\n11D3C..11D3D ; Exclusion # 10.0 [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O\n11D3F..11D47 ; Exclusion # 10.0 [9] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI RA-KARA\n11D50..11D59 ; Exclusion # 10.0 [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE\n11D60..11D65 ; Exclusion # 11.0 [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU\n11D67..11D68 ; Exclusion # 11.0 [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI\n11D6A..11D8E ; Exclusion # 11.0 [37] GUNJALA GONDI LETTER OO..GUNJALA GONDI VOWEL SIGN UU\n11D90..11D91 ; Exclusion # 11.0 [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI\n11D93..11D98 ; Exclusion # 11.0 [6] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI OM\n11DA0..11DA9 ; Exclusion # 11.0 [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE\n11DB0..11DDB ; Exclusion # 17.0 [44] TOLONG SIKI LETTER I..TOLONG SIKI UNGGA\n11DE0..11DE9 ; Exclusion # 17.0 [10] TOLONG SIKI DIGIT ZERO..TOLONG SIKI DIGIT NINE\n11EE0..11EF6 ; Exclusion # 11.0 [23] MAKASAR LETTER KA..MAKASAR VOWEL SIGN O\n11F00..11F10 ; Exclusion # 15.0 [17] KAWI SIGN CANDRABINDU..KAWI LETTER O\n11F12..11F3A ; Exclusion # 15.0 [41] KAWI LETTER KA..KAWI VOWEL SIGN VOCALIC R\n11F3E..11F42 ; Exclusion # 15.0 [5] KAWI VOWEL SIGN E..KAWI CONJOINER\n11F50..11F59 ; Exclusion # 15.0 [10] KAWI DIGIT ZERO..KAWI DIGIT NINE\n11F5A ; Exclusion # 16.0 KAWI SIGN NUKTA\n12000..1236E ; Exclusion # 5.0 [879] CUNEIFORM SIGN A..CUNEIFORM SIGN ZUM\n1236F..12398 ; Exclusion # 7.0 [42] CUNEIFORM SIGN KAP ELAMITE..CUNEIFORM SIGN UM TIMES ME\n12399 ; Exclusion # 8.0 CUNEIFORM SIGN U U\n12400..12462 ; Exclusion # 5.0 [99] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN OLD ASSYRIAN ONE QUARTER\n12463..1246E ; Exclusion # 7.0 [12] CUNEIFORM NUMERIC SIGN ONE QUARTER GUR..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM\n12480..12543 ; Exclusion # 8.0 [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU\n12F90..12FF0 ; Exclusion # 14.0 [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114\n13000..1342E ; Exclusion # 5.2 [1071] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH AA032\n1342F ; Exclusion # 15.0 EGYPTIAN HIEROGLYPH V011D\n13440..13455 ; Exclusion # 15.0 [22] EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED\n13460..143FA ; Exclusion # 16.0 [3995] EGYPTIAN HIEROGLYPH-13460..EGYPTIAN HIEROGLYPH-143FA\n14400..14646 ; Exclusion # 8.0 [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530\n16100..16139 ; Exclusion # 16.0 [58] GURUNG KHEMA LETTER A..GURUNG KHEMA DIGIT NINE\n16A70..16ABE ; Exclusion # 14.0 [79] TANGSA LETTER OZ..TANGSA LETTER ZA\n16AC0..16AC9 ; Exclusion # 14.0 [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE\n16AD0..16AED ; Exclusion # 7.0 [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I\n16AF0..16AF4 ; Exclusion # 7.0 [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE\n16B00..16B36 ; Exclusion # 7.0 [55] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG MARK CIM TAUM\n16B40..16B43 ; Exclusion # 7.0 [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM\n16B50..16B59 ; Exclusion # 7.0 [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE\n16B63..16B77 ; Exclusion # 7.0 [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS\n16B7D..16B8F ; Exclusion # 7.0 [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ\n16D40..16D6C ; Exclusion # 16.0 [45] KIRAT RAI SIGN ANUSVARA..KIRAT RAI SIGN SAAT\n16D70..16D79 ; Exclusion # 16.0 [10] KIRAT RAI DIGIT ZERO..KIRAT RAI DIGIT NINE\n16E40..16E7F ; Exclusion # 11.0 [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y\n16EA0..16EB8 ; Exclusion # 17.0 [25] BERIA ERFE CAPITAL LETTER ARKAB..BERIA ERFE CAPITAL LETTER AY\n16EBB..16ED3 ; Exclusion # 17.0 [25] BERIA ERFE SMALL LETTER ARKAB..BERIA ERFE SMALL LETTER AY\n16FE0 ; Exclusion # 9.0 TANGUT ITERATION MARK\n16FE1 ; Exclusion # 10.0 NUSHU ITERATION MARK\n16FE4 ; Exclusion # 13.0 KHITAN SMALL SCRIPT FILLER\n17000..187EC ; Exclusion # 9.0 [6125] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187EC\n187ED..187F1 ; Exclusion # 11.0 [5] TANGUT IDEOGRAPH-187ED..TANGUT IDEOGRAPH-187F1\n187F2..187F7 ; Exclusion # 12.0 [6] TANGUT IDEOGRAPH-187F2..TANGUT IDEOGRAPH-187F7\n187F8..187FF ; Exclusion # 17.0 [8] TANGUT IDEOGRAPH-187F8..TANGUT IDEOGRAPH-187FF\n18800..18AF2 ; Exclusion # 9.0 [755] TANGUT COMPONENT-001..TANGUT COMPONENT-755\n18AF3..18CD5 ; Exclusion # 13.0 [483] TANGUT COMPONENT-756..KHITAN SMALL SCRIPT CHARACTER-18CD5\n18CFF ; Exclusion # 16.0 KHITAN SMALL SCRIPT CHARACTER-18CFF\n18D00..18D08 ; Exclusion # 13.0 [9] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D08\n18D09..18D1E ; Exclusion # 17.0 [22] TANGUT IDEOGRAPH-18D09..TANGUT IDEOGRAPH-18D1E\n18D80..18DF2 ; Exclusion # 17.0 [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883\n1B170..1B2FB ; Exclusion # 10.0 [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB\n1BC00..1BC6A ; Exclusion # 7.0 [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M\n1BC70..1BC7C ; Exclusion # 7.0 [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK\n1BC80..1BC88 ; Exclusion # 7.0 [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL\n1BC90..1BC99 ; Exclusion # 7.0 [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW\n1BC9D..1BC9E ; Exclusion # 7.0 [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK\n1DA00..1DA36 ; Exclusion # 8.0 [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN\n1DA3B..1DA6C ; Exclusion # 8.0 [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT\n1DA75 ; Exclusion # 8.0 SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS\n1DA84 ; Exclusion # 8.0 SIGNWRITING LOCATION HEAD NECK\n1DA9B..1DA9F ; Exclusion # 8.0 [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6\n1DAA1..1DAAF ; Exclusion # 8.0 [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16\n1E000..1E006 ; Exclusion # 9.0 [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE\n1E008..1E018 ; Exclusion # 9.0 [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU\n1E01B..1E021 ; Exclusion # 9.0 [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI\n1E023..1E024 ; Exclusion # 9.0 [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS\n1E026..1E02A ; Exclusion # 9.0 [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA\n1E290..1E2AE ; Exclusion # 14.0 [31] TOTO LETTER PA..TOTO SIGN RISING TONE\n1E4D0..1E4F9 ; Exclusion # 15.0 [42] NAG MUNDARI LETTER O..NAG MUNDARI DIGIT NINE\n1E5D0..1E5FA ; Exclusion # 16.0 [43] OL ONAL LETTER O..OL ONAL DIGIT NINE\n1E6C0..1E6DE ; Exclusion # 17.0 [31] TAI YO LETTER LOW KO..TAI YO LETTER HIGH KVO\n1E6E0..1E6F5 ; Exclusion # 17.0 [22] TAI YO LETTER AA..TAI YO SIGN OM\n1E6FE..1E6FF ; Exclusion # 17.0 [2] TAI YO SYMBOL MUEANG..TAI YO XAM LAI\n1E800..1E8C4 ; Exclusion # 7.0 [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON\n1E8D0..1E8D6 ; Exclusion # 7.0 [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS\n\n# Total code points: 20862\n\n#\tIdentifier_Type:\tExclusion Not_XID\n\n0830..083E ; Exclusion Not_XID # 5.2 [15] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION ANNAAU\n1680 ; Exclusion Not_XID # 3.0 OGHAM SPACE MARK\n169B..169C ; Exclusion Not_XID # 3.0 [2] OGHAM FEATHER MARK..OGHAM REVERSED FEATHER MARK\n16EB..16ED ; Exclusion Not_XID # 3.0 [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION\n1735..1736 ; Exclusion Not_XID # 3.2 [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION\n1800..180A ; Exclusion Not_XID # 3.0 [11] MONGOLIAN BIRGA..MONGOLIAN NIRUGU\n1A1E..1A1F ; Exclusion Not_XID # 4.1 [2] BUGINESE PALLAWA..BUGINESE END OF SECTION\n2CE5..2CEA ; Exclusion Not_XID # 4.1 [6] COPTIC SYMBOL MI RO..COPTIC SYMBOL SHIMA SIMA\n2CF9..2CFF ; Exclusion Not_XID # 4.1 [7] COPTIC OLD NUBIAN FULL STOP..COPTIC MORPHOLOGICAL DIVIDER\n2E30 ; Exclusion Not_XID # 5.1 RING POINT\n2E3C ; Exclusion Not_XID # 7.0 STENOGRAPHIC FULL STOP\nA874..A877 ; Exclusion Not_XID # 5.0 [4] PHAGS-PA SINGLE HEAD MARK..PHAGS-PA MARK DOUBLE SHAD\nA95F ; Exclusion Not_XID # 5.1 REJANG SECTION MARK\n10100..10102 ; Exclusion Not_XID # 4.0 [3] AEGEAN WORD SEPARATOR LINE..AEGEAN CHECK MARK\n10107..10133 ; Exclusion Not_XID # 4.0 [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND\n10137..1013F ; Exclusion Not_XID # 4.0 [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT\n10320..10323 ; Exclusion Not_XID # 3.1 [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY\n1039F ; Exclusion Not_XID # 4.0 UGARITIC WORD DIVIDER\n103D0 ; Exclusion Not_XID # 4.1 OLD PERSIAN WORD DIVIDER\n1056F ; Exclusion Not_XID # 7.0 CAUCASIAN ALBANIAN CITATION MARK\n10857..1085F ; Exclusion Not_XID # 5.2 [9] IMPERIAL ARAMAIC SECTION SIGN..IMPERIAL ARAMAIC NUMBER TEN THOUSAND\n10877..1087F ; Exclusion Not_XID # 7.0 [9] PALMYRENE LEFT-POINTING FLEURON..PALMYRENE NUMBER TWENTY\n108A7..108AF ; Exclusion Not_XID # 7.0 [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED\n108FB..108FF ; Exclusion Not_XID # 8.0 [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED\n10916..10919 ; Exclusion Not_XID # 5.0 [4] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER ONE HUNDRED\n1091A..1091B ; Exclusion Not_XID # 5.2 [2] PHOENICIAN NUMBER TWO..PHOENICIAN NUMBER THREE\n1091F ; Exclusion Not_XID # 5.0 PHOENICIAN WORD SEPARATOR\n1093F ; Exclusion Not_XID # 5.1 LYDIAN TRIANGULAR MARK\n109BC..109BD ; Exclusion Not_XID # 8.0 [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF\n109C0..109CF ; Exclusion Not_XID # 8.0 [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY\n109D2..109FF ; Exclusion Not_XID # 8.0 [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS\n10A40..10A47 ; Exclusion Not_XID # 4.1 [8] KHAROSHTHI DIGIT ONE..KHAROSHTHI NUMBER ONE THOUSAND\n10A48 ; Exclusion Not_XID # 11.0 KHAROSHTHI FRACTION ONE HALF\n10A50..10A58 ; Exclusion Not_XID # 4.1 [9] KHAROSHTHI PUNCTUATION DOT..KHAROSHTHI PUNCTUATION LINES\n10A7D..10A7F ; Exclusion Not_XID # 5.2 [3] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMERIC INDICATOR\n10A9D..10A9F ; Exclusion Not_XID # 7.0 [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY\n10AC8 ; Exclusion Not_XID # 7.0 MANICHAEAN SIGN UD\n10AEB..10AF6 ; Exclusion Not_XID # 7.0 [12] MANICHAEAN NUMBER ONE..MANICHAEAN PUNCTUATION LINE FILLER\n10B39..10B3F ; Exclusion Not_XID # 5.2 [7] AVESTAN ABBREVIATION MARK..LARGE ONE RING OVER TWO RINGS PUNCTUATION\n10B58..10B5F ; Exclusion Not_XID # 5.2 [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND\n10B78..10B7F ; Exclusion Not_XID # 5.2 [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND\n10B99..10B9C ; Exclusion Not_XID # 7.0 [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT\n10BA9..10BAF ; Exclusion Not_XID # 7.0 [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED\n10CFA..10CFF ; Exclusion Not_XID # 8.0 [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND\n10D6E ; Exclusion Not_XID # 16.0 GARAY HYPHEN\n10D8E..10D8F ; Exclusion Not_XID # 16.0 [2] GARAY PLUS SIGN..GARAY MINUS SIGN\n10EAD ; Exclusion Not_XID # 13.0 YEZIDI HYPHENATION MARK\n10F1D..10F26 ; Exclusion Not_XID # 11.0 [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF\n10F51..10F59 ; Exclusion Not_XID # 11.0 [9] SOGDIAN NUMBER ONE..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT\n10F86..10F89 ; Exclusion Not_XID # 14.0 [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS\n10FC5..10FCB ; Exclusion Not_XID # 13.0 [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED\n11047..1104D ; Exclusion Not_XID # 6.0 [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS\n11052..11065 ; Exclusion Not_XID # 6.0 [20] BRAHMI NUMBER ONE..BRAHMI NUMBER ONE THOUSAND\n110BB..110BC ; Exclusion Not_XID # 5.2 [2] KAITHI ABBREVIATION SIGN..KAITHI ENUMERATION SIGN\n110BD ; Exclusion Not_XID # 5.2 KAITHI NUMBER SIGN\n110BE..110C1 ; Exclusion Not_XID # 5.2 [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA\n110CD ; Exclusion Not_XID # 11.0 KAITHI NUMBER SIGN ABOVE\n11174..11175 ; Exclusion Not_XID # 7.0 [2] MAHAJANI ABBREVIATION SIGN..MAHAJANI SECTION MARK\n111C5..111C8 ; Exclusion Not_XID # 6.1 [4] SHARADA DANDA..SHARADA SEPARATOR\n111CD ; Exclusion Not_XID # 7.0 SHARADA SUTRA MARK\n111DB ; Exclusion Not_XID # 8.0 SHARADA SIGN SIDDHAM\n111DD..111DF ; Exclusion Not_XID # 8.0 [3] SHARADA CONTINUATION SIGN..SHARADA SECTION MARK-2\n11238..1123D ; Exclusion Not_XID # 7.0 [6] KHOJKI DANDA..KHOJKI ABBREVIATION SIGN\n112A9 ; Exclusion Not_XID # 8.0 MULTANI SECTION MARK\n113D4..113D5 ; Exclusion Not_XID # 16.0 [2] TULU-TIGALARI DANDA..TULU-TIGALARI DOUBLE DANDA\n113D7..113D8 ; Exclusion Not_XID # 16.0 [2] TULU-TIGALARI SIGN OM PUSHPIKA..TULU-TIGALARI SIGN SHRII PUSHPIKA\n114C6 ; Exclusion Not_XID # 7.0 TIRHUTA ABBREVIATION SIGN\n115C1..115C9 ; Exclusion Not_XID # 7.0 [9] SIDDHAM SIGN SIDDHAM..SIDDHAM END OF TEXT MARK\n115CA..115D7 ; Exclusion Not_XID # 8.0 [14] SIDDHAM SECTION MARK WITH TRIDENT AND U-SHAPED ORNAMENTS..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES\n11641..11643 ; Exclusion Not_XID # 7.0 [3] MODI DANDA..MODI ABBREVIATION SIGN\n11660..1166C ; Exclusion Not_XID # 9.0 [13] MONGOLIAN BIRGA WITH ORNAMENT..MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT\n116B9 ; Exclusion Not_XID # 14.0 TAKRI ABBREVIATION SIGN\n1173A..1173F ; Exclusion Not_XID # 8.0 [6] AHOM NUMBER TEN..AHOM SYMBOL VI\n1183B ; Exclusion Not_XID # 11.0 DOGRA ABBREVIATION SIGN\n118EA..118F2 ; Exclusion Not_XID # 7.0 [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY\n11944..11946 ; Exclusion Not_XID # 13.0 [3] DIVES AKURU DOUBLE DANDA..DIVES AKURU END OF TEXT MARK\n119E2 ; Exclusion Not_XID # 12.0 NANDINAGARI SIGN SIDDHAM\n11A3F..11A46 ; Exclusion Not_XID # 10.0 [8] ZANABAZAR SQUARE INITIAL HEAD MARK..ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK\n11A9A..11A9C ; Exclusion Not_XID # 10.0 [3] SOYOMBO MARK TSHEG..SOYOMBO MARK DOUBLE SHAD\n11A9E..11AA2 ; Exclusion Not_XID # 10.0 [5] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO TERMINAL MARK-2\n11BE1 ; Exclusion Not_XID # 16.0 SUNUWAR SIGN PVO\n11C41..11C45 ; Exclusion Not_XID # 9.0 [5] BHAIKSUKI DANDA..BHAIKSUKI GAP FILLER-2\n11C5A..11C6C ; Exclusion Not_XID # 9.0 [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK\n11C70..11C71 ; Exclusion Not_XID # 9.0 [2] MARCHEN HEAD MARK..MARCHEN MARK SHAD\n11EF7..11EF8 ; Exclusion Not_XID # 11.0 [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION\n11F43..11F4F ; Exclusion Not_XID # 15.0 [13] KAWI DANDA..KAWI PUNCTUATION CLOSING SPIRAL\n12470..12473 ; Exclusion Not_XID # 5.0 [4] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL TRICOLON\n12474 ; Exclusion Not_XID # 7.0 CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON\n12FF1..12FF2 ; Exclusion Not_XID # 14.0 [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302\n13430..13438 ; Exclusion Not_XID # 12.0 [9] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END SEGMENT\n13439..1343F ; Exclusion Not_XID # 15.0 [7] EGYPTIAN HIEROGLYPH INSERT AT MIDDLE..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE\n16A6E..16A6F ; Exclusion Not_XID # 7.0 [2] MRO DANDA..MRO DOUBLE DANDA\n16AF5 ; Exclusion Not_XID # 7.0 BASSA VAH FULL STOP\n16B37..16B3F ; Exclusion Not_XID # 7.0 [9] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN XYEEM FAIB\n16B44..16B45 ; Exclusion Not_XID # 7.0 [2] PAHAWH HMONG SIGN XAUS..PAHAWH HMONG SIGN CIM TSOV ROG\n16B5B..16B61 ; Exclusion Not_XID # 7.0 [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS\n16D6D..16D6F ; Exclusion Not_XID # 16.0 [3] KIRAT RAI SIGN YUPI..KIRAT RAI DOUBLE DANDA\n16E80..16E9A ; Exclusion Not_XID # 11.0 [27] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN EXCLAMATION OH\n1BC9C ; Exclusion Not_XID # 7.0 DUPLOYAN SIGN O WITH CROSS\n1BC9F ; Exclusion Not_XID # 7.0 DUPLOYAN PUNCTUATION CHINOOK FULL STOP\n1D800..1D9FF ; Exclusion Not_XID # 8.0 [512] SIGNWRITING HAND-FIST INDEX..SIGNWRITING HEAD\n1DA37..1DA3A ; Exclusion Not_XID # 8.0 [4] SIGNWRITING AIR BLOW SMALL ROTATIONS..SIGNWRITING BREATH EXHALE\n1DA6D..1DA74 ; Exclusion Not_XID # 8.0 [8] SIGNWRITING SHOULDER HIP SPINE..SIGNWRITING TORSO-FLOORPLANE TWISTING\n1DA76..1DA83 ; Exclusion Not_XID # 8.0 [14] SIGNWRITING LIMB COMBINATION..SIGNWRITING LOCATION DEPTH\n1DA85..1DA8B ; Exclusion Not_XID # 8.0 [7] SIGNWRITING LOCATION TORSO..SIGNWRITING PARENTHESIS\n1E5FF ; Exclusion Not_XID # 16.0 OL ONAL ABBREVIATION SIGN\n1E8C7..1E8CF ; Exclusion Not_XID # 7.0 [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE\n\n# Total code points: 1142\n\n#\tIdentifier_Type:\tObsolete\n\n0138 ; Obsolete # 1.1 LATIN SMALL LETTER KRA\n01B9 ; Obsolete # 1.1 LATIN SMALL LETTER EZH REVERSED\n01BF ; Obsolete # 1.1 LATIN LETTER WYNN\n01F6..01F7 ; Obsolete # 3.0 [2] LATIN CAPITAL LETTER HWAIR..LATIN CAPITAL LETTER WYNN\n021C..021D ; Obsolete # 3.0 [2] LATIN CAPITAL LETTER YOGH..LATIN SMALL LETTER YOGH\n0345 ; Obsolete # 1.1 COMBINING GREEK YPOGEGRAMMENI\n0363..036F ; Obsolete # 3.2 [13] COMBINING LATIN SMALL LETTER A..COMBINING LATIN SMALL LETTER X\n0370..0373 ; Obsolete # 5.1 [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI\n0376..0377 ; Obsolete # 5.1 [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA\n037B..037D ; Obsolete # 5.0 [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL\n037F ; Obsolete # 7.0 GREEK CAPITAL LETTER YOT\n03D8..03D9 ; Obsolete # 3.2 [2] GREEK LETTER ARCHAIC KOPPA..GREEK SMALL LETTER ARCHAIC KOPPA\n03DA ; Obsolete # 1.1 GREEK LETTER STIGMA\n03DB ; Obsolete # 3.0 GREEK SMALL LETTER STIGMA\n03DC ; Obsolete # 1.1 GREEK LETTER DIGAMMA\n03DD ; Obsolete # 3.0 GREEK SMALL LETTER DIGAMMA\n03DE ; Obsolete # 1.1 GREEK LETTER KOPPA\n03DF ; Obsolete # 3.0 GREEK SMALL LETTER KOPPA\n03E0 ; Obsolete # 1.1 GREEK LETTER SAMPI\n03E1 ; Obsolete # 3.0 GREEK SMALL LETTER SAMPI\n03F7..03F8 ; Obsolete # 4.0 [2] GREEK CAPITAL LETTER SHO..GREEK SMALL LETTER SHO\n03FA..03FB ; Obsolete # 4.0 [2] GREEK CAPITAL LETTER SAN..GREEK SMALL LETTER SAN\n03FD..03FF ; Obsolete # 4.1 [3] GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL..GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL\n0460..0481 ; Obsolete # 1.1 [34] CYRILLIC CAPITAL LETTER OMEGA..CYRILLIC SMALL LETTER KOPPA\n0483 ; Obsolete # 1.1 COMBINING CYRILLIC TITLO\n049C..049D ; Obsolete # 1.1 [2] CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE..CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE\n04A6..04A7 ; Obsolete # 1.1 [2] CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK..CYRILLIC SMALL LETTER PE WITH MIDDLE HOOK\n04B8..04B9 ; Obsolete # 1.1 [2] CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE..CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE\n0500..050F ; Obsolete # 3.2 [16] CYRILLIC CAPITAL LETTER KOMI DE..CYRILLIC SMALL LETTER KOMI TJE\n0514..0523 ; Obsolete # 5.1 [16] CYRILLIC CAPITAL LETTER LHA..CYRILLIC SMALL LETTER EN WITH MIDDLE HOOK\n0526..0527 ; Obsolete # 6.0 [2] CYRILLIC CAPITAL LETTER SHHA WITH DESCENDER..CYRILLIC SMALL LETTER SHHA WITH DESCENDER\n0528..052F ; Obsolete # 7.0 [8] CYRILLIC CAPITAL LETTER EN WITH LEFT HOOK..CYRILLIC SMALL LETTER EL WITH DESCENDER\n063B..063C ; Obsolete # 5.1 [2] ARABIC LETTER KEHEH WITH TWO DOTS ABOVE..ARABIC LETTER KEHEH WITH THREE DOTS BELOW\n063E..063F ; Obsolete # 5.1 [2] ARABIC LETTER FARSI YEH WITH TWO DOTS ABOVE..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE\n0640 ; Obsolete # 1.1 ARABIC TATWEEL\n066E..066F ; Obsolete # 3.2 [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF\n0690 ; Obsolete # 1.1 ARABIC LETTER DAL WITH FOUR DOTS ABOVE\n06AC ; Obsolete # 1.1 ARABIC LETTER KAF WITH DOT ABOVE\n077E..077F ; Obsolete # 5.1 [2] ARABIC LETTER SEEN WITH INVERTED V..ARABIC LETTER KAF WITH TWO DOTS ABOVE\n088E ; Obsolete # 14.0 ARABIC VERTICAL TAIL\n08AD..08B1 ; Obsolete # 7.0 [5] ARABIC LETTER LOW ALEF..ARABIC LETTER STRAIGHT WAW\n08B5 ; Obsolete # 14.0 ARABIC LETTER QAF WITH DOT BELOW AND NO DOTS ABOVE\n090C ; Obsolete # 1.1 DEVANAGARI LETTER VOCALIC L\n093D ; Obsolete # 1.1 DEVANAGARI SIGN AVAGRAHA\n094E ; Obsolete # 5.2 DEVANAGARI VOWEL SIGN PRISHTHAMATRA E\n0951..0952 ; Obsolete # 1.1 [2] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI STRESS SIGN ANUDATTA\n0960..0963 ; Obsolete # 1.1 [4] DEVANAGARI LETTER VOCALIC RR..DEVANAGARI VOWEL SIGN VOCALIC LL\n0971 ; Obsolete # 5.1 DEVANAGARI SIGN HIGH SPACING DOT\n0978 ; Obsolete # 7.0 DEVANAGARI LETTER MARWARI DDA\n0980 ; Obsolete # 7.0 BENGALI ANJI\n09BD ; Obsolete # 4.0 BENGALI SIGN AVAGRAHA\n09E0..09E3 ; Obsolete # 1.1 [4] BENGALI LETTER VOCALIC RR..BENGALI VOWEL SIGN VOCALIC LL\n09FC ; Obsolete # 10.0 BENGALI LETTER VEDIC ANUSVARA\n0ABD ; Obsolete # 1.1 GUJARATI SIGN AVAGRAHA\n0AE0 ; Obsolete # 1.1 GUJARATI LETTER VOCALIC RR\n0AE1..0AE3 ; Obsolete # 4.0 [3] GUJARATI LETTER VOCALIC LL..GUJARATI VOWEL SIGN VOCALIC LL\n0B3D ; Obsolete # 1.1 ORIYA SIGN AVAGRAHA\n0B60..0B61 ; Obsolete # 1.1 [2] ORIYA LETTER VOCALIC RR..ORIYA LETTER VOCALIC LL\n0C00 ; Obsolete # 7.0 TELUGU SIGN COMBINING CANDRABINDU ABOVE\n0C34 ; Obsolete # 7.0 TELUGU LETTER LLLA\n0C3D ; Obsolete # 5.1 TELUGU SIGN AVAGRAHA\n0C58..0C59 ; Obsolete # 5.1 [2] TELUGU LETTER TSA..TELUGU LETTER DZA\n0C5C ; Obsolete # 17.0 TELUGU ARCHAIC SHRII\n0C60..0C61 ; Obsolete # 1.1 [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL\n0C81 ; Obsolete # 7.0 KANNADA SIGN CANDRABINDU\n0C8C ; Obsolete # 1.1 KANNADA LETTER VOCALIC L\n0CB1 ; Obsolete # 1.1 KANNADA LETTER RRA\n0CBD ; Obsolete # 4.0 KANNADA SIGN AVAGRAHA\n0CDC ; Obsolete # 17.0 KANNADA ARCHAIC SHRII\n0CDE ; Obsolete # 1.1 KANNADA LETTER FA\n0CE0..0CE1 ; Obsolete # 1.1 [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL\n0CE2..0CE3 ; Obsolete # 5.0 [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL\n0CF1..0CF2 ; Obsolete # 5.0 [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA\n0D01 ; Obsolete # 7.0 MALAYALAM SIGN CANDRABINDU\n0D3A ; Obsolete # 6.0 MALAYALAM LETTER TTTA\n0D3B..0D3C ; Obsolete # 10.0 [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA\n0D3D ; Obsolete # 5.1 MALAYALAM SIGN AVAGRAHA\n0D4C ; Obsolete # 1.1 MALAYALAM VOWEL SIGN AU\n0D4E ; Obsolete # 6.0 MALAYALAM LETTER DOT REPH\n0D5F ; Obsolete # 8.0 MALAYALAM LETTER ARCHAIC II\n0D60..0D61 ; Obsolete # 1.1 [2] MALAYALAM LETTER VOCALIC RR..MALAYALAM LETTER VOCALIC LL\n0D9E ; Obsolete # 3.0 SINHALA LETTER KANTAJA NAASIKYAYA\n0F86..0F8B ; Obsolete # 2.0 [6] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN GRU MED RGYINGS\n0F8C..0F8F ; Obsolete # 6.0 [4] TIBETAN SIGN INVERTED MCHU CAN..TIBETAN SUBJOINED SIGN INVERTED MCHU CAN\n10A0..10C5 ; Obsolete # 1.1 [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE\n10F1..10F6 ; Obsolete # 1.1 [6] GEORGIAN LETTER HE..GEORGIAN LETTER FI\n1100..1159 ; Obsolete # 1.1 [90] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG YEORINHIEUH\n115A..115E ; Obsolete # 5.2 [5] HANGUL CHOSEONG KIYEOK-TIKEUT..HANGUL CHOSEONG TIKEUT-RIEUL\n1161..11A2 ; Obsolete # 1.1 [66] HANGUL JUNGSEONG A..HANGUL JUNGSEONG SSANGARAEA\n11A3..11A7 ; Obsolete # 5.2 [5] HANGUL JUNGSEONG A-EU..HANGUL JUNGSEONG O-YAE\n11A8..11F9 ; Obsolete # 1.1 [82] HANGUL JONGSEONG KIYEOK..HANGUL JONGSEONG YEORINHIEUH\n11FA..11FF ; Obsolete # 5.2 [6] HANGUL JONGSEONG KIYEOK-NIEUN..HANGUL JONGSEONG SSANGNIEUN\n1369..1371 ; Obsolete # 3.0 [9] ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE\n17A8 ; Obsolete # 3.0 KHMER INDEPENDENT VOWEL QUK\n17D3 ; Obsolete # 3.0 KHMER SIGN BATHAMASAT\n17DC ; Obsolete # 3.0 KHMER SIGN AVAKRAHASANYA\n1AB0..1ABD ; Obsolete # 7.0 [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW\n1C80..1C88 ; Obsolete # 9.0 [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK\n1CD0..1CD2 ; Obsolete # 5.2 [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA\n1CD4..1CF2 ; Obsolete # 5.2 [31] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC SIGN ARDHAVISARGA\n1CF3..1CF6 ; Obsolete # 6.1 [4] VEDIC SIGN ROTATED ARDHAVISARGA..VEDIC SIGN UPADHMANIYA\n1CF7 ; Obsolete # 10.0 VEDIC SIGN ATIKRAMA\n1CF8..1CF9 ; Obsolete # 7.0 [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE\n1F00..1F15 ; Obsolete # 1.1 [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA\n1F18..1F1D ; Obsolete # 1.1 [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA\n1F20..1F45 ; Obsolete # 1.1 [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA\n1F48..1F4D ; Obsolete # 1.1 [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA\n1F50..1F57 ; Obsolete # 1.1 [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI\n1F59 ; Obsolete # 1.1 GREEK CAPITAL LETTER UPSILON WITH DASIA\n1F5B ; Obsolete # 1.1 GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA\n1F5D ; Obsolete # 1.1 GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA\n1F5F..1F70 ; Obsolete # 1.1 [18] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER ALPHA WITH VARIA\n1F72 ; Obsolete # 1.1 GREEK SMALL LETTER EPSILON WITH VARIA\n1F74 ; Obsolete # 1.1 GREEK SMALL LETTER ETA WITH VARIA\n1F76 ; Obsolete # 1.1 GREEK SMALL LETTER IOTA WITH VARIA\n1F78 ; Obsolete # 1.1 GREEK SMALL LETTER OMICRON WITH VARIA\n1F7A ; Obsolete # 1.1 GREEK SMALL LETTER UPSILON WITH VARIA\n1F7C ; Obsolete # 1.1 GREEK SMALL LETTER OMEGA WITH VARIA\n1F80..1F9F ; Obsolete # 1.1 [32] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI\n1FB6..1FBA ; Obsolete # 1.1 [5] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH VARIA\n1FBC ; Obsolete # 1.1 GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI\n1FC2..1FC4 ; Obsolete # 1.1 [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI\n1FC6..1FC8 ; Obsolete # 1.1 [3] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER EPSILON WITH VARIA\n1FCA ; Obsolete # 1.1 GREEK CAPITAL LETTER ETA WITH VARIA\n1FCC ; Obsolete # 1.1 GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI\n1FD0..1FD2 ; Obsolete # 1.1 [3] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA\n1FD6..1FDA ; Obsolete # 1.1 [5] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH VARIA\n1FE0..1FE2 ; Obsolete # 1.1 [3] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA\n1FE4..1FEA ; Obsolete # 1.1 [7] GREEK SMALL LETTER RHO WITH PSILI..GREEK CAPITAL LETTER UPSILON WITH VARIA\n1FF2..1FF4 ; Obsolete # 1.1 [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI\n1FF6..1FF8 ; Obsolete # 1.1 [3] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMICRON WITH VARIA\n1FFA ; Obsolete # 1.1 GREEK CAPITAL LETTER OMEGA WITH VARIA\n1FFC ; Obsolete # 1.1 GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI\n2132 ; Obsolete # 1.1 TURNED CAPITAL F\n214E ; Obsolete # 5.0 TURNED SMALL F\n2184 ; Obsolete # 5.0 LATIN SMALL LETTER REVERSED C\n2185..2188 ; Obsolete # 5.1 [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND\n2C6D..2C6F ; Obsolete # 5.1 [3] LATIN CAPITAL LETTER ALPHA..LATIN CAPITAL LETTER TURNED A\n2C70 ; Obsolete # 5.2 LATIN CAPITAL LETTER TURNED ALPHA\n2C71..2C73 ; Obsolete # 5.1 [3] LATIN SMALL LETTER V WITH RIGHT HOOK..LATIN SMALL LETTER W WITH HOOK\n2C74..2C76 ; Obsolete # 5.0 [3] LATIN SMALL LETTER V WITH CURL..LATIN SMALL LETTER HALF H\n2C7E..2C7F ; Obsolete # 5.2 [2] LATIN CAPITAL LETTER S WITH SWASH TAIL..LATIN CAPITAL LETTER Z WITH SWASH TAIL\n2D00..2D25 ; Obsolete # 4.1 [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE\n2DE0..2DFF ; Obsolete # 5.1 [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS\n31F0..31FF ; Obsolete # 3.2 [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO\nA640..A65F ; Obsolete # 5.1 [32] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER YN\nA660..A661 ; Obsolete # 6.0 [2] CYRILLIC CAPITAL LETTER REVERSED TSE..CYRILLIC SMALL LETTER REVERSED TSE\nA662..A66E ; Obsolete # 5.1 [13] CYRILLIC CAPITAL LETTER SOFT DE..CYRILLIC LETTER MULTIOCULAR O\nA674..A67B ; Obsolete # 6.1 [8] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC LETTER OMEGA\nA67F..A697 ; Obsolete # 5.1 [25] CYRILLIC PAYEROK..CYRILLIC SMALL LETTER SHWE\nA698..A69B ; Obsolete # 7.0 [4] CYRILLIC CAPITAL LETTER DOUBLE O..CYRILLIC SMALL LETTER CROSSED O\nA69F ; Obsolete # 6.1 COMBINING CYRILLIC LETTER IOTIFIED E\nA730..A76F ; Obsolete # 5.1 [64] LATIN LETTER SMALL CAPITAL F..LATIN SMALL LETTER CON\nA771..A787 ; Obsolete # 5.1 [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T\nA790..A791 ; Obsolete # 6.0 [2] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER N WITH DESCENDER\nA794..A79F ; Obsolete # 7.0 [12] LATIN SMALL LETTER C WITH PALATAL HOOK..LATIN SMALL LETTER VOLAPUK UE\nA7A0..A7A9 ; Obsolete # 6.0 [10] LATIN CAPITAL LETTER G WITH OBLIQUE STROKE..LATIN SMALL LETTER S WITH OBLIQUE STROKE\nA7AB..A7AD ; Obsolete # 7.0 [3] LATIN CAPITAL LETTER REVERSED OPEN E..LATIN CAPITAL LETTER L WITH BELT\nA7B0..A7B1 ; Obsolete # 7.0 [2] LATIN CAPITAL LETTER TURNED K..LATIN CAPITAL LETTER TURNED T\nA7C0..A7C1 ; Obsolete # 14.0 [2] LATIN CAPITAL LETTER OLD POLISH O..LATIN SMALL LETTER OLD POLISH O\nA7C4 ; Obsolete # 12.0 LATIN CAPITAL LETTER C WITH PALATAL HOOK\nA7C7..A7CA ; Obsolete # 13.0 [4] LATIN CAPITAL LETTER D WITH SHORT STROKE OVERLAY..LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY\nA7D0..A7D1 ; Obsolete # 14.0 [2] LATIN CAPITAL LETTER CLOSED INSULAR G..LATIN SMALL LETTER CLOSED INSULAR G\nA7D2 ; Obsolete # 17.0 LATIN CAPITAL LETTER DOUBLE THORN\nA7D3 ; Obsolete # 14.0 LATIN SMALL LETTER DOUBLE THORN\nA7D4 ; Obsolete # 17.0 LATIN CAPITAL LETTER DOUBLE WYNN\nA7D5..A7D9 ; Obsolete # 14.0 [5] LATIN SMALL LETTER DOUBLE WYNN..LATIN SMALL LETTER SIGMOID S\nA7F5..A7F6 ; Obsolete # 13.0 [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H\nA7F7 ; Obsolete # 7.0 LATIN EPIGRAPHIC LETTER SIDEWAYS I\nA7FB..A7FF ; Obsolete # 5.1 [5] LATIN EPIGRAPHIC LETTER REVERSED F..LATIN EPIGRAPHIC LETTER ARCHAIC M\nA8E0..A8F7 ; Obsolete # 5.2 [24] COMBINING DEVANAGARI DIGIT ZERO..DEVANAGARI SIGN CANDRABINDU AVAGRAHA\nA8FB ; Obsolete # 5.2 DEVANAGARI HEADSTROKE\nA8FE..A8FF ; Obsolete # 11.0 [2] DEVANAGARI LETTER AY..DEVANAGARI VOWEL SIGN AY\nA960..A97C ; Obsolete # 5.2 [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH\nA9E0..A9E6 ; Obsolete # 7.0 [7] MYANMAR LETTER SHAN GHA..MYANMAR MODIFIER LETTER SHAN REDUPLICATION\nAB30..AB5A ; Obsolete # 7.0 [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG\nAB64..AB65 ; Obsolete # 7.0 [2] LATIN SMALL LETTER INVERTED ALPHA..GREEK LETTER SMALL CAPITAL OMEGA\nD7B0..D7C6 ; Obsolete # 5.2 [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E\nD7CB..D7FB ; Obsolete # 5.2 [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH\n10140..10174 ; Obsolete # 4.1 [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS\n101FD ; Obsolete # 5.1 PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE\n102E0 ; Obsolete # 7.0 COPTIC EPACT THOUSANDS MARK\n16FE3 ; Obsolete # 12.0 OLD CHINESE ITERATION MARK\n16FF0..16FF1 ; Obsolete # 13.0 [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY\n1B000..1B001 ; Obsolete # 6.0 [2] KATAKANA LETTER ARCHAIC E..HIRAGANA LETTER ARCHAIC YE\n1B002..1B11E ; Obsolete # 10.0 [285] HENTAIGANA LETTER A-1..HENTAIGANA LETTER N-MU-MO-2\n1B11F..1B122 ; Obsolete # 14.0 [4] HIRAGANA LETTER ARCHAIC WU..KATAKANA LETTER ARCHAIC WU\n1B132 ; Obsolete # 15.0 HIRAGANA LETTER SMALL KO\n1B150..1B152 ; Obsolete # 12.0 [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO\n1B155 ; Obsolete # 15.0 KATAKANA LETTER SMALL KO\n1B164..1B167 ; Obsolete # 12.0 [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N\n1E08F ; Obsolete # 15.0 COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I\n\n# Total code points: 1639\n\n#\tIdentifier_Type:\tObsolete Not_XID\n\n0482 ; Obsolete Not_XID # 1.1 CYRILLIC THOUSANDS SIGN\n0488..0489 ; Obsolete Not_XID # 3.0 [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN\n05C6 ; Obsolete Not_XID # 4.1 HEBREW PUNCTUATION NUN HAFUKHA\n17D8 ; Obsolete Not_XID # 3.0 KHMER SIGN BEYYAL\n1CD3 ; Obsolete Not_XID # 5.2 VEDIC SIGN NIHSHVASA\n2056 ; Obsolete Not_XID # 4.1 THREE DOT PUNCTUATION\n2058..205E ; Obsolete Not_XID # 4.1 [7] FOUR DOT PUNCTUATION..VERTICAL FOUR DOTS\n2127 ; Obsolete Not_XID # 1.1 INVERTED OHM SIGN\n214F ; Obsolete Not_XID # 5.1 SYMBOL FOR SAMARITAN SOURCE\n2E0E..2E16 ; Obsolete Not_XID # 4.1 [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE\n2E2A..2E2F ; Obsolete Not_XID # 5.1 [6] TWO DOTS OVER ONE DOT PUNCTUATION..VERTICAL TILDE\n2E31 ; Obsolete Not_XID # 5.2 WORD SEPARATOR MIDDLE DOT\n2E32 ; Obsolete Not_XID # 6.1 TURNED COMMA\n2E35 ; Obsolete Not_XID # 6.1 TURNED SEMICOLON\n2E39 ; Obsolete Not_XID # 6.1 TOP HALF SECTION SIGN\n301E ; Obsolete Not_XID # 1.1 DOUBLE PRIME QUOTATION MARK\nA670..A673 ; Obsolete Not_XID # 5.1 [4] COMBINING CYRILLIC TEN MILLIONS SIGN..SLAVONIC ASTERISK\nA700..A707 ; Obsolete Not_XID # 4.1 [8] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER CHINESE TONE YANG RU\nA8F8..A8FA ; Obsolete Not_XID # 5.2 [3] DEVANAGARI SIGN PUSHPIKA..DEVANAGARI CARET\n101D0..101FC ; Obsolete Not_XID # 5.1 [45] PHAISTOS DISC SIGN PEDESTRIAN..PHAISTOS DISC SIGN WAVY BAND\n102E1..102FB ; Obsolete Not_XID # 7.0 [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED\n1D200..1D241 ; Obsolete Not_XID # 4.1 [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54\n1D245 ; Obsolete Not_XID # 4.1 GREEK MUSICAL LEIMMA\n\n# Total code points: 190\n\n#\tIdentifier_Type:\tNot_XID\n\n0009..000D ; Not_XID # 1.1 [5] ..\n0020..0026 ; Not_XID # 1.1 [7] SPACE..AMPERSAND\n0028..002C ; Not_XID # 1.1 [5] LEFT PARENTHESIS..COMMA\n002F ; Not_XID # 1.1 SOLIDUS\n003B..0040 ; Not_XID # 1.1 [6] SEMICOLON..COMMERCIAL AT\n005B..005E ; Not_XID # 1.1 [4] LEFT SQUARE BRACKET..CIRCUMFLEX ACCENT\n0060 ; Not_XID # 1.1 GRAVE ACCENT\n007B..007E ; Not_XID # 1.1 [4] LEFT CURLY BRACKET..TILDE\n0085 ; Not_XID # 1.1 \n00A1..00A7 ; Not_XID # 1.1 [7] INVERTED EXCLAMATION MARK..SECTION SIGN\n00A9 ; Not_XID # 1.1 COPYRIGHT SIGN\n00AB..00AC ; Not_XID # 1.1 [2] LEFT-POINTING DOUBLE ANGLE QUOTATION MARK..NOT SIGN\n00AE ; Not_XID # 1.1 REGISTERED SIGN\n00B0..00B1 ; Not_XID # 1.1 [2] DEGREE SIGN..PLUS-MINUS SIGN\n00B6 ; Not_XID # 1.1 PILCROW SIGN\n00BB ; Not_XID # 1.1 RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK\n00BF ; Not_XID # 1.1 INVERTED QUESTION MARK\n00D7 ; Not_XID # 1.1 MULTIPLICATION SIGN\n00F7 ; Not_XID # 1.1 DIVISION SIGN\n02C2..02C5 ; Not_XID # 1.1 [4] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER DOWN ARROWHEAD\n02D2..02D7 ; Not_XID # 1.1 [6] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER MINUS SIGN\n02DE ; Not_XID # 1.1 MODIFIER LETTER RHOTIC HOOK\n02DF ; Not_XID # 3.0 MODIFIER LETTER CROSS ACCENT\n02E5..02E9 ; Not_XID # 1.1 [5] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER EXTRA-LOW TONE BAR\n02ED ; Not_XID # 3.0 MODIFIER LETTER UNASPIRATED\n02EF..02FF ; Not_XID # 4.0 [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW\n03F6 ; Not_XID # 3.2 GREEK REVERSED LUNATE EPSILON SYMBOL\n055A..055F ; Not_XID # 1.1 [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK\n0589 ; Not_XID # 1.1 ARMENIAN FULL STOP\n058D..058E ; Not_XID # 7.0 [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN\n058F ; Not_XID # 6.1 ARMENIAN DRAM SIGN\n05BE ; Not_XID # 1.1 HEBREW PUNCTUATION MAQAF\n05C0 ; Not_XID # 1.1 HEBREW PUNCTUATION PASEQ\n05C3 ; Not_XID # 1.1 HEBREW PUNCTUATION SOF PASUQ\n0600..0603 ; Not_XID # 4.0 [4] ARABIC NUMBER SIGN..ARABIC SIGN SAFHA\n0604 ; Not_XID # 6.1 ARABIC SIGN SAMVAT\n0605 ; Not_XID # 7.0 ARABIC NUMBER MARK ABOVE\n0606..060A ; Not_XID # 5.1 [5] ARABIC-INDIC CUBE ROOT..ARABIC-INDIC PER TEN THOUSAND SIGN\n060B ; Not_XID # 4.1 AFGHANI SIGN\n060C ; Not_XID # 1.1 ARABIC COMMA\n060D..060F ; Not_XID # 4.0 [3] ARABIC DATE SEPARATOR..ARABIC SIGN MISRA\n061B ; Not_XID # 1.1 ARABIC SEMICOLON\n061D ; Not_XID # 14.0 ARABIC END OF TEXT MARK\n061E ; Not_XID # 4.1 ARABIC TRIPLE DOT PUNCTUATION MARK\n061F ; Not_XID # 1.1 ARABIC QUESTION MARK\n066A..066D ; Not_XID # 1.1 [4] ARABIC PERCENT SIGN..ARABIC FIVE POINTED STAR\n06D4 ; Not_XID # 1.1 ARABIC FULL STOP\n06DD ; Not_XID # 1.1 ARABIC END OF AYAH\n06DE ; Not_XID # 1.1 ARABIC START OF RUB EL HIZB\n06E9 ; Not_XID # 1.1 ARABIC PLACE OF SAJDAH\n0890..0891 ; Not_XID # 14.0 [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE\n08E2 ; Not_XID # 9.0 ARABIC DISPUTED END OF AYAH\n0964..0965 ; Not_XID # 1.1 [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA\n0970 ; Not_XID # 1.1 DEVANAGARI ABBREVIATION SIGN\n09F2..09FA ; Not_XID # 1.1 [9] BENGALI RUPEE MARK..BENGALI ISSHAR\n09FB ; Not_XID # 5.2 BENGALI GANDA MARK\n09FD ; Not_XID # 10.0 BENGALI ABBREVIATION SIGN\n0A76 ; Not_XID # 11.0 GURMUKHI ABBREVIATION SIGN\n0AF0 ; Not_XID # 6.1 GUJARATI ABBREVIATION SIGN\n0AF1 ; Not_XID # 4.0 GUJARATI RUPEE SIGN\n0B70 ; Not_XID # 1.1 ORIYA ISSHAR\n0B72..0B77 ; Not_XID # 6.0 [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS\n0BF0..0BF2 ; Not_XID # 1.1 [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND\n0BF3..0BFA ; Not_XID # 4.0 [8] TAMIL DAY SIGN..TAMIL NUMBER SIGN\n0C77 ; Not_XID # 12.0 TELUGU SIGN SIDDHAM\n0C78..0C7F ; Not_XID # 5.1 [8] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU SIGN TUUMU\n0C84 ; Not_XID # 11.0 KANNADA SIGN SIDDHAM\n0D4F ; Not_XID # 9.0 MALAYALAM SIGN PARA\n0D58..0D5E ; Not_XID # 9.0 [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH\n0D70..0D75 ; Not_XID # 5.1 [6] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE QUARTERS\n0D76..0D78 ; Not_XID # 9.0 [3] MALAYALAM FRACTION ONE SIXTEENTH..MALAYALAM FRACTION THREE SIXTEENTHS\n0D79 ; Not_XID # 5.1 MALAYALAM DATE MARK\n0DF4 ; Not_XID # 3.0 SINHALA PUNCTUATION KUNDDALIYA\n0E3F ; Not_XID # 1.1 THAI CURRENCY SYMBOL BAHT\n0E4F ; Not_XID # 1.1 THAI CHARACTER FONGMAN\n0E5A..0E5B ; Not_XID # 1.1 [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT\n0F01..0F0A ; Not_XID # 2.0 [10] TIBETAN MARK GTER YIG MGO TRUNCATED A..TIBETAN MARK BKA- SHOG YIG MGO\n0F0D..0F17 ; Not_XID # 2.0 [11] TIBETAN MARK SHAD..TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS\n0F1A..0F1F ; Not_XID # 2.0 [6] TIBETAN SIGN RDEL DKAR GCIG..TIBETAN SIGN RDEL DKAR RDEL NAG\n0F2A..0F34 ; Not_XID # 2.0 [11] TIBETAN DIGIT HALF ONE..TIBETAN MARK BSDUS RTAGS\n0F36 ; Not_XID # 2.0 TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN\n0F38 ; Not_XID # 2.0 TIBETAN MARK CHE MGO\n0F3A..0F3D ; Not_XID # 2.0 [4] TIBETAN MARK GUG RTAGS GYON..TIBETAN MARK ANG KHANG GYAS\n0F85 ; Not_XID # 2.0 TIBETAN MARK PALUTA\n0FBE..0FC5 ; Not_XID # 3.0 [8] TIBETAN KU RU KHA..TIBETAN SYMBOL RDO RJE\n0FC7..0FCC ; Not_XID # 3.0 [6] TIBETAN SYMBOL RDO RJE RGYA GRAM..TIBETAN SYMBOL NOR BU BZHI -KHYIL\n0FCE ; Not_XID # 5.1 TIBETAN SIGN RDEL NAG RDEL DKAR\n0FCF ; Not_XID # 3.0 TIBETAN SIGN RDEL NAG GSUM\n0FD0..0FD1 ; Not_XID # 4.1 [2] TIBETAN MARK BSKA- SHOG GI MGO RGYAN..TIBETAN MARK MNYAM YIG GI MGO RGYAN\n0FD2..0FD4 ; Not_XID # 5.1 [3] TIBETAN MARK NYIS TSHEG..TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA\n0FD5..0FD8 ; Not_XID # 5.2 [4] RIGHT-FACING SVASTI SIGN..LEFT-FACING SVASTI SIGN WITH DOTS\n0FD9..0FDA ; Not_XID # 6.0 [2] TIBETAN MARK LEADING MCHAN RTAGS..TIBETAN MARK TRAILING MCHAN RTAGS\n104A..104F ; Not_XID # 3.0 [6] MYANMAR SIGN LITTLE SECTION..MYANMAR SYMBOL GENITIVE\n109E..109F ; Not_XID # 5.1 [2] MYANMAR SYMBOL SHAN ONE..MYANMAR SYMBOL SHAN EXCLAMATION\n10FB ; Not_XID # 1.1 GEORGIAN PARAGRAPH SEPARATOR\n1360 ; Not_XID # 4.1 ETHIOPIC SECTION MARK\n1361..1368 ; Not_XID # 3.0 [8] ETHIOPIC WORDSPACE..ETHIOPIC PARAGRAPH SEPARATOR\n1372..137C ; Not_XID # 3.0 [11] ETHIOPIC NUMBER TEN..ETHIOPIC NUMBER TEN THOUSAND\n1390..1399 ; Not_XID # 4.1 [10] ETHIOPIC TONAL MARK YIZET..ETHIOPIC TONAL MARK KURT\n17D4..17D6 ; Not_XID # 3.0 [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH\n17D9..17DB ; Not_XID # 3.0 [3] KHMER SIGN PHNAEK MUAN..KHMER CURRENCY SYMBOL RIEL\n17F0..17F9 ; Not_XID # 4.0 [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON\n19E0..19FF ; Not_XID # 4.0 [32] KHMER SYMBOL PATHAMASAT..KHMER SYMBOL DAP-PRAM ROC\n1ABE ; Not_XID # 7.0 COMBINING PARENTHESES OVERLAY\n2012..2016 ; Not_XID # 1.1 [5] FIGURE DASH..DOUBLE VERTICAL LINE\n2018 ; Not_XID # 1.1 LEFT SINGLE QUOTATION MARK\n201A..2023 ; Not_XID # 1.1 [10] SINGLE LOW-9 QUOTATION MARK..TRIANGULAR BULLET\n2028..2029 ; Not_XID # 1.1 [2] LINE SEPARATOR..PARAGRAPH SEPARATOR\n2030..2032 ; Not_XID # 1.1 [3] PER MILLE SIGN..PRIME\n2035 ; Not_XID # 1.1 REVERSED PRIME\n2038..203B ; Not_XID # 1.1 [4] CARET..REFERENCE MARK\n203D ; Not_XID # 1.1 INTERROBANG\n2041..2046 ; Not_XID # 1.1 [6] CARET INSERTION POINT..RIGHT SQUARE BRACKET WITH QUILL\n204A..204D ; Not_XID # 3.0 [4] TIRONIAN SIGN ET..BLACK RIGHTWARDS BULLET\n204E..2052 ; Not_XID # 3.2 [5] LOW ASTERISK..COMMERCIAL MINUS SIGN\n2053 ; Not_XID # 4.0 SWUNG DASH\n2055 ; Not_XID # 4.1 FLOWER PUNCTUATION MARK\n20A0..20A7 ; Not_XID # 1.1 [8] EURO-CURRENCY SIGN..PESETA SIGN\n20A9..20AA ; Not_XID # 1.1 [2] WON SIGN..NEW SHEQEL SIGN\n20AB ; Not_XID # 2.0 DONG SIGN\n20AC ; Not_XID # 2.1 EURO SIGN\n20AD..20AF ; Not_XID # 3.0 [3] KIP SIGN..DRACHMA SIGN\n20B0..20B1 ; Not_XID # 3.2 [2] GERMAN PENNY SIGN..PESO SIGN\n20B2..20B5 ; Not_XID # 4.1 [4] GUARANI SIGN..CEDI SIGN\n20B6..20B8 ; Not_XID # 5.2 [3] LIVRE TOURNOIS SIGN..TENGE SIGN\n20B9 ; Not_XID # 6.0 INDIAN RUPEE SIGN\n20BA ; Not_XID # 6.2 TURKISH LIRA SIGN\n20BB..20BD ; Not_XID # 7.0 [3] NORDIC MARK SIGN..RUBLE SIGN\n20BE ; Not_XID # 8.0 LARI SIGN\n20BF ; Not_XID # 10.0 BITCOIN SIGN\n20C0 ; Not_XID # 14.0 SOM SIGN\n20C1 ; Not_XID # 17.0 SAUDI RIYAL SIGN\n2104 ; Not_XID # 1.1 CENTRE LINE SYMBOL\n2108 ; Not_XID # 1.1 SCRUPLE\n2114 ; Not_XID # 1.1 L B BAR SYMBOL\n2117 ; Not_XID # 1.1 SOUND RECORDING COPYRIGHT\n211E..211F ; Not_XID # 1.1 [2] PRESCRIPTION TAKE..RESPONSE\n2123 ; Not_XID # 1.1 VERSICLE\n2125 ; Not_XID # 1.1 OUNCE SIGN\n2129 ; Not_XID # 1.1 TURNED GREEK SMALL LETTER IOTA\n213A ; Not_XID # 3.0 ROTATED CAPITAL Q\n2141..2144 ; Not_XID # 3.2 [4] TURNED SANS-SERIF CAPITAL G..TURNED SANS-SERIF CAPITAL Y\n214A..214B ; Not_XID # 3.2 [2] PROPERTY LINE..TURNED AMPERSAND\n214C ; Not_XID # 4.1 PER SIGN\n214D ; Not_XID # 5.0 AKTIESELSKAB\n2190..21EA ; Not_XID # 1.1 [91] LEFTWARDS ARROW..UPWARDS WHITE ARROW FROM BAR\n21EB..21F3 ; Not_XID # 3.0 [9] UPWARDS WHITE ARROW ON PEDESTAL..UP DOWN WHITE ARROW\n21F4..21FF ; Not_XID # 3.2 [12] RIGHT ARROW WITH SMALL CIRCLE..LEFT RIGHT OPEN-HEADED ARROW\n2200..222B ; Not_XID # 1.1 [44] FOR ALL..INTEGRAL\n222E ; Not_XID # 1.1 CONTOUR INTEGRAL\n2231..22F1 ; Not_XID # 1.1 [193] CLOCKWISE INTEGRAL..DOWN RIGHT DIAGONAL ELLIPSIS\n22F2..22FF ; Not_XID # 3.2 [14] ELEMENT OF WITH LONG HORIZONTAL STROKE..Z NOTATION BAG MEMBERSHIP\n2300 ; Not_XID # 1.1 DIAMETER SIGN\n2301 ; Not_XID # 3.0 ELECTRIC ARROW\n2302..2328 ; Not_XID # 1.1 [39] HOUSE..KEYBOARD\n232B..237A ; Not_XID # 1.1 [80] ERASE TO THE LEFT..APL FUNCTIONAL SYMBOL ALPHA\n237B ; Not_XID # 3.0 NOT CHECK MARK\n237C ; Not_XID # 3.2 RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW\n237D..239A ; Not_XID # 3.0 [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL\n239B..23CE ; Not_XID # 3.2 [52] LEFT PARENTHESIS UPPER HOOK..RETURN SYMBOL\n23CF..23D0 ; Not_XID # 4.0 [2] EJECT SYMBOL..VERTICAL LINE EXTENSION\n23D1..23DB ; Not_XID # 4.1 [11] METRICAL BREVE..FUSE\n23DC..23E7 ; Not_XID # 5.0 [12] TOP PARENTHESIS..ELECTRICAL INTERSECTION\n23E8 ; Not_XID # 5.2 DECIMAL EXPONENT SYMBOL\n23E9..23F3 ; Not_XID # 6.0 [11] BLACK RIGHT-POINTING DOUBLE TRIANGLE..HOURGLASS WITH FLOWING SAND\n23F4..23FA ; Not_XID # 7.0 [7] BLACK MEDIUM LEFT-POINTING TRIANGLE..BLACK CIRCLE FOR RECORD\n23FB..23FE ; Not_XID # 9.0 [4] POWER SYMBOL..POWER SLEEP SYMBOL\n23FF ; Not_XID # 10.0 OBSERVER EYE SYMBOL\n2400..2424 ; Not_XID # 1.1 [37] SYMBOL FOR NULL..SYMBOL FOR NEWLINE\n2425..2426 ; Not_XID # 3.0 [2] SYMBOL FOR DELETE FORM TWO..SYMBOL FOR SUBSTITUTE FORM TWO\n2427..2429 ; Not_XID # 16.0 [3] SYMBOL FOR DELETE SQUARE CHECKER BOARD FORM..SYMBOL FOR DELETE MEDIUM SHADE FORM\n2440..244A ; Not_XID # 1.1 [11] OCR HOOK..OCR DOUBLE BACKSLASH\n2500..2595 ; Not_XID # 1.1 [150] BOX DRAWINGS LIGHT HORIZONTAL..RIGHT ONE EIGHTH BLOCK\n2596..259F ; Not_XID # 3.2 [10] QUADRANT LOWER LEFT..QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT\n25A0..25EF ; Not_XID # 1.1 [80] BLACK SQUARE..LARGE CIRCLE\n25F0..25F7 ; Not_XID # 3.0 [8] WHITE SQUARE WITH UPPER LEFT QUADRANT..WHITE CIRCLE WITH UPPER RIGHT QUADRANT\n25F8..25FF ; Not_XID # 3.2 [8] UPPER LEFT TRIANGLE..LOWER RIGHT TRIANGLE\n2600..2613 ; Not_XID # 1.1 [20] BLACK SUN WITH RAYS..SALTIRE\n2614..2615 ; Not_XID # 4.0 [2] UMBRELLA WITH RAIN DROPS..HOT BEVERAGE\n2616..2617 ; Not_XID # 3.2 [2] WHITE SHOGI PIECE..BLACK SHOGI PIECE\n2618 ; Not_XID # 4.1 SHAMROCK\n2619 ; Not_XID # 3.0 REVERSED ROTATED FLORAL HEART BULLET\n261A..266F ; Not_XID # 1.1 [86] BLACK LEFT POINTING INDEX..MUSIC SHARP SIGN\n2670..2671 ; Not_XID # 3.0 [2] WEST SYRIAC CROSS..EAST SYRIAC CROSS\n2672..267D ; Not_XID # 3.2 [12] UNIVERSAL RECYCLING SYMBOL..PARTIALLY-RECYCLED PAPER SYMBOL\n267E..267F ; Not_XID # 4.1 [2] PERMANENT PAPER SIGN..WHEELCHAIR SYMBOL\n2680..2689 ; Not_XID # 3.2 [10] DIE FACE-1..BLACK CIRCLE WITH TWO WHITE DOTS\n268A..2691 ; Not_XID # 4.0 [8] MONOGRAM FOR YANG..BLACK FLAG\n2692..269C ; Not_XID # 4.1 [11] HAMMER AND PICK..FLEUR-DE-LIS\n269D ; Not_XID # 5.1 OUTLINED WHITE STAR\n269E..269F ; Not_XID # 5.2 [2] THREE LINES CONVERGING RIGHT..THREE LINES CONVERGING LEFT\n26A0..26A1 ; Not_XID # 4.0 [2] WARNING SIGN..HIGH VOLTAGE SIGN\n26A2..26B1 ; Not_XID # 4.1 [16] DOUBLED FEMALE SIGN..FUNERAL URN\n26B2 ; Not_XID # 5.0 NEUTER\n26B3..26BC ; Not_XID # 5.1 [10] CERES..SESQUIQUADRATE\n26BD..26BF ; Not_XID # 5.2 [3] SOCCER BALL..SQUARED KEY\n26C0..26C3 ; Not_XID # 5.1 [4] WHITE DRAUGHTS MAN..BLACK DRAUGHTS KING\n26C4..26CD ; Not_XID # 5.2 [10] SNOWMAN WITHOUT SNOW..DISABLED CAR\n26CE ; Not_XID # 6.0 OPHIUCHUS\n26CF..26E1 ; Not_XID # 5.2 [19] PICK..RESTRICTED LEFT ENTRY-2\n26E2 ; Not_XID # 6.0 ASTRONOMICAL SYMBOL FOR URANUS\n26E3 ; Not_XID # 5.2 HEAVY CIRCLE WITH STROKE AND TWO DOTS ABOVE\n26E4..26E7 ; Not_XID # 6.0 [4] PENTAGRAM..INVERTED PENTAGRAM\n26E8..26FF ; Not_XID # 5.2 [24] BLACK CROSS ON SHIELD..WHITE FLAG WITH HORIZONTAL MIDDLE BLACK STRIPE\n2700 ; Not_XID # 7.0 BLACK SAFETY SCISSORS\n2701..2704 ; Not_XID # 1.1 [4] UPPER BLADE SCISSORS..WHITE SCISSORS\n2705 ; Not_XID # 6.0 WHITE HEAVY CHECK MARK\n2706..2709 ; Not_XID # 1.1 [4] TELEPHONE LOCATION SIGN..ENVELOPE\n270A..270B ; Not_XID # 6.0 [2] RAISED FIST..RAISED HAND\n270C..2727 ; Not_XID # 1.1 [28] VICTORY HAND..WHITE FOUR POINTED STAR\n2728 ; Not_XID # 6.0 SPARKLES\n2729..274B ; Not_XID # 1.1 [35] STRESS OUTLINED WHITE STAR..HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK\n274C ; Not_XID # 6.0 CROSS MARK\n274D ; Not_XID # 1.1 SHADOWED WHITE CIRCLE\n274E ; Not_XID # 6.0 NEGATIVE SQUARED CROSS MARK\n274F..2752 ; Not_XID # 1.1 [4] LOWER RIGHT DROP-SHADOWED WHITE SQUARE..UPPER RIGHT SHADOWED WHITE SQUARE\n2753..2755 ; Not_XID # 6.0 [3] BLACK QUESTION MARK ORNAMENT..WHITE EXCLAMATION MARK ORNAMENT\n2756 ; Not_XID # 1.1 BLACK DIAMOND MINUS WHITE X\n2757 ; Not_XID # 5.2 HEAVY EXCLAMATION MARK SYMBOL\n2758..275E ; Not_XID # 1.1 [7] LIGHT VERTICAL BAR..HEAVY DOUBLE COMMA QUOTATION MARK ORNAMENT\n275F..2760 ; Not_XID # 6.0 [2] HEAVY LOW SINGLE COMMA QUOTATION MARK ORNAMENT..HEAVY LOW DOUBLE COMMA QUOTATION MARK ORNAMENT\n2761..2767 ; Not_XID # 1.1 [7] CURVED STEM PARAGRAPH SIGN ORNAMENT..ROTATED FLORAL HEART BULLET\n2768..2775 ; Not_XID # 3.2 [14] MEDIUM LEFT PARENTHESIS ORNAMENT..MEDIUM RIGHT CURLY BRACKET ORNAMENT\n2776..2794 ; Not_XID # 1.1 [31] DINGBAT NEGATIVE CIRCLED DIGIT ONE..HEAVY WIDE-HEADED RIGHTWARDS ARROW\n2795..2797 ; Not_XID # 6.0 [3] HEAVY PLUS SIGN..HEAVY DIVISION SIGN\n2798..27AF ; Not_XID # 1.1 [24] HEAVY SOUTH EAST ARROW..NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW\n27B0 ; Not_XID # 6.0 CURLY LOOP\n27B1..27BE ; Not_XID # 1.1 [14] NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW..OPEN-OUTLINED RIGHTWARDS ARROW\n27BF ; Not_XID # 6.0 DOUBLE CURLY LOOP\n27C0..27C6 ; Not_XID # 4.1 [7] THREE DIMENSIONAL ANGLE..RIGHT S-SHAPED BAG DELIMITER\n27C7..27CA ; Not_XID # 5.0 [4] OR WITH DOT INSIDE..VERTICAL BAR WITH HORIZONTAL STROKE\n27CB ; Not_XID # 6.1 MATHEMATICAL RISING DIAGONAL\n27CC ; Not_XID # 5.1 LONG DIVISION\n27CD ; Not_XID # 6.1 MATHEMATICAL FALLING DIAGONAL\n27CE..27CF ; Not_XID # 6.0 [2] SQUARED LOGICAL AND..SQUARED LOGICAL OR\n27D0..27EB ; Not_XID # 3.2 [28] WHITE DIAMOND WITH CENTRED DOT..MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET\n27EC..27EF ; Not_XID # 5.1 [4] MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET..MATHEMATICAL RIGHT FLATTENED PARENTHESIS\n27F0..27FF ; Not_XID # 3.2 [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW\n2900..2A0B ; Not_XID # 3.2 [268] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..SUMMATION WITH INTEGRAL\n2A0D..2A73 ; Not_XID # 3.2 [103] FINITE PART INTEGRAL..EQUALS SIGN ABOVE TILDE OPERATOR\n2A77..2ADB ; Not_XID # 3.2 [101] EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW..TRANSVERSAL INTERSECTION\n2ADD..2AFF ; Not_XID # 3.2 [35] NONFORKING..N-ARY WHITE VERTICAL BAR\n2B00..2B0D ; Not_XID # 4.0 [14] NORTH EAST WHITE ARROW..UP DOWN BLACK ARROW\n2B0E..2B13 ; Not_XID # 4.1 [6] RIGHTWARDS ARROW WITH TIP DOWNWARDS..SQUARE WITH BOTTOM HALF BLACK\n2B14..2B1A ; Not_XID # 5.0 [7] SQUARE WITH UPPER RIGHT DIAGONAL HALF BLACK..DOTTED SQUARE\n2B1B..2B1F ; Not_XID # 5.1 [5] BLACK LARGE SQUARE..BLACK PENTAGON\n2B20..2B23 ; Not_XID # 5.0 [4] WHITE PENTAGON..HORIZONTAL BLACK HEXAGON\n2B24..2B4C ; Not_XID # 5.1 [41] BLACK LARGE CIRCLE..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR\n2B4D..2B4F ; Not_XID # 7.0 [3] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..SHORT BACKSLANTED SOUTH ARROW\n2B50..2B54 ; Not_XID # 5.1 [5] WHITE MEDIUM STAR..WHITE RIGHT-POINTING PENTAGON\n2B55..2B59 ; Not_XID # 5.2 [5] HEAVY LARGE CIRCLE..HEAVY CIRCLED SALTIRE\n2B5A..2B73 ; Not_XID # 7.0 [26] SLANTED NORTH ARROW WITH HOOKED HEAD..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR\n2B76..2B95 ; Not_XID # 7.0 [32] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..RIGHTWARDS BLACK ARROW\n2B96 ; Not_XID # 17.0 EQUALS SIGN WITH INFINITY ABOVE\n2B97 ; Not_XID # 13.0 SYMBOL FOR TYPE A ELECTRONICS\n2B98..2BB9 ; Not_XID # 7.0 [34] THREE-D TOP-LIGHTED LEFTWARDS EQUILATERAL ARROWHEAD..UP ARROWHEAD IN A RECTANGLE BOX\n2BBA..2BBC ; Not_XID # 11.0 [3] OVERLAPPING WHITE SQUARES..OVERLAPPING BLACK SQUARES\n2BBD..2BC8 ; Not_XID # 7.0 [12] BALLOT BOX WITH LIGHT X..BLACK MEDIUM RIGHT-POINTING TRIANGLE CENTRED\n2BC9 ; Not_XID # 12.0 NEPTUNE FORM TWO\n2BCA..2BD1 ; Not_XID # 7.0 [8] TOP HALF BLACK CIRCLE..UNCERTAINTY SIGN\n2BD2 ; Not_XID # 10.0 GROUP MARK\n2BD3..2BEB ; Not_XID # 11.0 [25] PLUTO FORM TWO..STAR WITH RIGHT HALF BLACK\n2BF0..2BFE ; Not_XID # 11.0 [15] ERIS FORM ONE..REVERSED RIGHT ANGLE\n2BFF ; Not_XID # 12.0 HELLSCHREIBER PAUSE SYMBOL\n2E17 ; Not_XID # 4.1 DOUBLE OBLIQUE HYPHEN\n2E18..2E1B ; Not_XID # 5.1 [4] INVERTED INTERROBANG..TILDE WITH RING ABOVE\n2E1C..2E1D ; Not_XID # 4.1 [2] LEFT LOW PARAPHRASE BRACKET..RIGHT LOW PARAPHRASE BRACKET\n2E1E..2E29 ; Not_XID # 5.1 [12] TILDE WITH DOT ABOVE..RIGHT DOUBLE PARENTHESIS\n2E33..2E34 ; Not_XID # 6.1 [2] RAISED DOT..RAISED COMMA\n2E36..2E38 ; Not_XID # 6.1 [3] DAGGER WITH LEFT GUARD..TURNED DAGGER\n2E3A..2E3B ; Not_XID # 6.1 [2] TWO-EM DASH..THREE-EM DASH\n2E3D..2E42 ; Not_XID # 7.0 [6] VERTICAL SIX DOTS..DOUBLE LOW-REVERSED-9 QUOTATION MARK\n2E43..2E44 ; Not_XID # 9.0 [2] DASH WITH LEFT UPTURN..DOUBLE SUSPENSION MARK\n2E45..2E49 ; Not_XID # 10.0 [5] INVERTED LOW KAVYKA..DOUBLE STACKED COMMA\n2E4A..2E4E ; Not_XID # 11.0 [5] DOTTED SOLIDUS..PUNCTUS ELEVATUS MARK\n2E4F ; Not_XID # 12.0 CORNISH VERSE DIVIDER\n2E50..2E52 ; Not_XID # 13.0 [3] CROSS PATTY WITH RIGHT CROSSBAR..TIRONIAN SIGN CAPITAL ET\n2E53..2E5D ; Not_XID # 14.0 [11] MEDIEVAL EXCLAMATION MARK..OBLIQUE HYPHEN\n2E80..2E99 ; Not_XID # 3.0 [26] CJK RADICAL REPEAT..CJK RADICAL RAP\n2E9B..2E9E ; Not_XID # 3.0 [4] CJK RADICAL CHOKE..CJK RADICAL DEATH\n2EA0..2EF2 ; Not_XID # 3.0 [83] CJK RADICAL CIVILIAN..CJK RADICAL J-SIMPLIFIED TURTLE\n2FF0..2FFB ; Not_XID # 3.0 [12] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID\n2FFC..2FFF ; Not_XID # 15.1 [4] IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION\n3001..3004 ; Not_XID # 1.1 [4] IDEOGRAPHIC COMMA..JAPANESE INDUSTRIAL STANDARD SYMBOL\n3008..301D ; Not_XID # 1.1 [22] LEFT ANGLE BRACKET..REVERSED DOUBLE PRIME QUOTATION MARK\n301F..3020 ; Not_XID # 1.1 [2] LOW DOUBLE PRIME QUOTATION MARK..POSTAL MARK FACE\n3030 ; Not_XID # 1.1 WAVY DASH\n3037 ; Not_XID # 1.1 IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL\n303D ; Not_XID # 3.2 PART ALTERNATION MARK\n303E ; Not_XID # 3.0 IDEOGRAPHIC VARIATION INDICATOR\n303F ; Not_XID # 1.1 IDEOGRAPHIC HALF FILL SPACE\n3190..3191 ; Not_XID # 1.1 [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK\n31C0..31CF ; Not_XID # 4.1 [16] CJK STROKE T..CJK STROKE N\n31D0..31E3 ; Not_XID # 5.1 [20] CJK STROKE H..CJK STROKE Q\n31E4..31E5 ; Not_XID # 16.0 [2] CJK STROKE HXG..CJK STROKE SZP\n31EF ; Not_XID # 15.1 IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION\n3248..324F ; Not_XID # 5.2 [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE\nA67E ; Not_XID # 5.1 CYRILLIC KAVYKA\nA720..A721 ; Not_XID # 5.0 [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE\nA789..A78A ; Not_XID # 5.1 [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN\nA830..A839 ; Not_XID # 5.2 [10] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC QUANTITY MARK\nA92E ; Not_XID # 5.1 KAYAH LI SIGN CWI\nAA77..AA79 ; Not_XID # 5.2 [3] MYANMAR SYMBOL AITON EXCLAMATION..MYANMAR SYMBOL AITON TWO\nAB5B ; Not_XID # 7.0 MODIFIER BREVE WITH INVERTED BREVE\nAB6A..AB6B ; Not_XID # 13.0 [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK\nFFF9..FFFB ; Not_XID # 3.0 [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR\nFFFC ; Not_XID # 2.1 OBJECT REPLACEMENT CHARACTER\nFFFD ; Not_XID # 1.1 REPLACEMENT CHARACTER\n10175..1018A ; Not_XID # 4.1 [22] GREEK ONE HALF SIGN..GREEK ZERO SIGN\n1018B..1018C ; Not_XID # 7.0 [2] GREEK ONE QUARTER SIGN..GREEK SINUSOID SIGN\n1018D..1018E ; Not_XID # 9.0 [2] GREEK INDICTION SIGN..NOMISMA SIGN\n10190..1019B ; Not_XID # 5.1 [12] ROMAN SEXTANS SIGN..ROMAN CENTURIAL SIGN\n1019C ; Not_XID # 13.0 ASCIA SYMBOL\n101A0 ; Not_XID # 7.0 GREEK SYMBOL TAU RHO\n10E60..10E7E ; Not_XID # 5.2 [31] RUMI DIGIT ONE..RUMI FRACTION TWO THIRDS\n10ED0..10ED8 ; Not_XID # 17.0 [9] ARABIC BIBLICAL END OF VERSE..ARABIC LIGATURE NAWWARA ALLAAHU MARQADAH\n111E1..111F4 ; Not_XID # 7.0 [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND\n11B00..11B09 ; Not_XID # 15.0 [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU\n11FC0..11FF1 ; Not_XID # 12.0 [50] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL SIGN VAKAIYARAA\n11FFF ; Not_XID # 12.0 TAMIL PUNCTUATION END OF TEXT\n16FE2 ; Not_XID # 12.0 OLD CHINESE HOOK MARK\n1CC00..1CCD5 ; Not_XID # 16.0 [214] UP-POINTING GO-KART..LOWER RIGHT QUADRANT STANDING KNIGHT\n1CCFA..1CCFC ; Not_XID # 17.0 [3] SNAKE SYMBOL..NOSE SYMBOL\n1CD00..1CEB3 ; Not_XID # 16.0 [436] BLOCK OCTANT-3..BLACK RIGHT TRIANGLE CARET\n1CEBA..1CED0 ; Not_XID # 17.0 [23] FRAGILE SYMBOL..LEUKOTHEA\n1CEE0..1CEF0 ; Not_XID # 17.0 [17] GEOMANTIC FIGURE POPULUS..MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR\n1D2C0..1D2D3 ; Not_XID # 15.0 [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN\n1D2E0..1D2F3 ; Not_XID # 11.0 [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN\n1D360..1D371 ; Not_XID # 5.0 [18] COUNTING ROD UNIT DIGIT ONE..COUNTING ROD TENS DIGIT NINE\n1D372..1D378 ; Not_XID # 11.0 [7] IDEOGRAPHIC TALLY MARK ONE..TALLY MARK FIVE\n1EC71..1ECB4 ; Not_XID # 11.0 [68] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ ALTERNATE LAKH MARK\n1ED01..1ED3D ; Not_XID # 12.0 [61] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ FRACTION ONE SIXTH\n1EEF0..1EEF1 ; Not_XID # 6.1 [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL\n1F000..1F02B ; Not_XID # 5.1 [44] MAHJONG TILE EAST WIND..MAHJONG TILE BACK\n1F030..1F093 ; Not_XID # 5.1 [100] DOMINO TILE HORIZONTAL BACK..DOMINO TILE VERTICAL-06-06\n1F0A0..1F0AE ; Not_XID # 6.0 [15] PLAYING CARD BACK..PLAYING CARD KING OF SPADES\n1F0B1..1F0BE ; Not_XID # 6.0 [14] PLAYING CARD ACE OF HEARTS..PLAYING CARD KING OF HEARTS\n1F0BF ; Not_XID # 7.0 PLAYING CARD RED JOKER\n1F0C1..1F0CF ; Not_XID # 6.0 [15] PLAYING CARD ACE OF DIAMONDS..PLAYING CARD BLACK JOKER\n1F0D1..1F0DF ; Not_XID # 6.0 [15] PLAYING CARD ACE OF CLUBS..PLAYING CARD WHITE JOKER\n1F0E0..1F0F5 ; Not_XID # 7.0 [22] PLAYING CARD FOOL..PLAYING CARD TRUMP-21\n1F10B..1F10C ; Not_XID # 7.0 [2] DINGBAT CIRCLED SANS-SERIF DIGIT ZERO..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO\n1F10D..1F10F ; Not_XID # 13.0 [3] CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH\n1F12F ; Not_XID # 11.0 COPYLEFT SYMBOL\n1F150..1F156 ; Not_XID # 6.0 [7] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER G\n1F157 ; Not_XID # 5.2 NEGATIVE CIRCLED LATIN CAPITAL LETTER H\n1F158..1F15E ; Not_XID # 6.0 [7] NEGATIVE CIRCLED LATIN CAPITAL LETTER I..NEGATIVE CIRCLED LATIN CAPITAL LETTER O\n1F15F ; Not_XID # 5.2 NEGATIVE CIRCLED LATIN CAPITAL LETTER P\n1F160..1F169 ; Not_XID # 6.0 [10] NEGATIVE CIRCLED LATIN CAPITAL LETTER Q..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z\n1F16D..1F16F ; Not_XID # 13.0 [3] CIRCLED CC..CIRCLED HUMAN FIGURE\n1F170..1F178 ; Not_XID # 6.0 [9] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER I\n1F179 ; Not_XID # 5.2 NEGATIVE SQUARED LATIN CAPITAL LETTER J\n1F17A ; Not_XID # 6.0 NEGATIVE SQUARED LATIN CAPITAL LETTER K\n1F17B..1F17C ; Not_XID # 5.2 [2] NEGATIVE SQUARED LATIN CAPITAL LETTER L..NEGATIVE SQUARED LATIN CAPITAL LETTER M\n1F17D..1F17E ; Not_XID # 6.0 [2] NEGATIVE SQUARED LATIN CAPITAL LETTER N..NEGATIVE SQUARED LATIN CAPITAL LETTER O\n1F17F ; Not_XID # 5.2 NEGATIVE SQUARED LATIN CAPITAL LETTER P\n1F180..1F189 ; Not_XID # 6.0 [10] NEGATIVE SQUARED LATIN CAPITAL LETTER Q..NEGATIVE SQUARED LATIN CAPITAL LETTER Z\n1F18A..1F18D ; Not_XID # 5.2 [4] CROSSED NEGATIVE SQUARED LATIN CAPITAL LETTER P..NEGATIVE SQUARED SA\n1F18E..1F18F ; Not_XID # 6.0 [2] NEGATIVE SQUARED AB..NEGATIVE SQUARED WC\n1F191..1F19A ; Not_XID # 6.0 [10] SQUARED CL..SQUARED VS\n1F19B..1F1AC ; Not_XID # 9.0 [18] SQUARED THREE D..SQUARED VOD\n1F1AD ; Not_XID # 13.0 MASK WORK SYMBOL\n1F1E6..1F1FF ; Not_XID # 6.0 [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z\n1F260..1F265 ; Not_XID # 10.0 [6] ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI\n1F300..1F320 ; Not_XID # 6.0 [33] CYCLONE..SHOOTING STAR\n1F321..1F32C ; Not_XID # 7.0 [12] THERMOMETER..WIND BLOWING FACE\n1F32D..1F32F ; Not_XID # 8.0 [3] HOT DOG..BURRITO\n1F330..1F335 ; Not_XID # 6.0 [6] CHESTNUT..CACTUS\n1F336 ; Not_XID # 7.0 HOT PEPPER\n1F337..1F37C ; Not_XID # 6.0 [70] TULIP..BABY BOTTLE\n1F37D ; Not_XID # 7.0 FORK AND KNIFE WITH PLATE\n1F37E..1F37F ; Not_XID # 8.0 [2] BOTTLE WITH POPPING CORK..POPCORN\n1F380..1F393 ; Not_XID # 6.0 [20] RIBBON..GRADUATION CAP\n1F394..1F39F ; Not_XID # 7.0 [12] HEART WITH TIP ON THE LEFT..ADMISSION TICKETS\n1F3A0..1F3C4 ; Not_XID # 6.0 [37] CAROUSEL HORSE..SURFER\n1F3C5 ; Not_XID # 7.0 SPORTS MEDAL\n1F3C6..1F3CA ; Not_XID # 6.0 [5] TROPHY..SWIMMER\n1F3CB..1F3CE ; Not_XID # 7.0 [4] WEIGHT LIFTER..RACING CAR\n1F3CF..1F3D3 ; Not_XID # 8.0 [5] CRICKET BAT AND BALL..TABLE TENNIS PADDLE AND BALL\n1F3D4..1F3DF ; Not_XID # 7.0 [12] SNOW CAPPED MOUNTAIN..STADIUM\n1F3E0..1F3F0 ; Not_XID # 6.0 [17] HOUSE BUILDING..EUROPEAN CASTLE\n1F3F1..1F3F7 ; Not_XID # 7.0 [7] WHITE PENNANT..LABEL\n1F3F8..1F3FF ; Not_XID # 8.0 [8] BADMINTON RACQUET AND SHUTTLECOCK..EMOJI MODIFIER FITZPATRICK TYPE-6\n1F400..1F43E ; Not_XID # 6.0 [63] RAT..PAW PRINTS\n1F43F ; Not_XID # 7.0 CHIPMUNK\n1F440 ; Not_XID # 6.0 EYES\n1F441 ; Not_XID # 7.0 EYE\n1F442..1F4F7 ; Not_XID # 6.0 [182] EAR..CAMERA\n1F4F8 ; Not_XID # 7.0 CAMERA WITH FLASH\n1F4F9..1F4FC ; Not_XID # 6.0 [4] VIDEO CAMERA..VIDEOCASSETTE\n1F4FD..1F4FE ; Not_XID # 7.0 [2] FILM PROJECTOR..PORTABLE STEREO\n1F4FF ; Not_XID # 8.0 PRAYER BEADS\n1F500..1F53D ; Not_XID # 6.0 [62] TWISTED RIGHTWARDS ARROWS..DOWN-POINTING SMALL RED TRIANGLE\n1F53E..1F53F ; Not_XID # 7.0 [2] LOWER RIGHT SHADOWED WHITE CIRCLE..UPPER RIGHT SHADOWED WHITE CIRCLE\n1F540..1F543 ; Not_XID # 6.1 [4] CIRCLED CROSS POMMEE..NOTCHED LEFT SEMICIRCLE WITH THREE DOTS\n1F544..1F54A ; Not_XID # 7.0 [7] NOTCHED RIGHT SEMICIRCLE WITH THREE DOTS..DOVE OF PEACE\n1F54B..1F54E ; Not_XID # 8.0 [4] KAABA..MENORAH WITH NINE BRANCHES\n1F550..1F567 ; Not_XID # 6.0 [24] CLOCK FACE ONE OCLOCK..CLOCK FACE TWELVE-THIRTY\n1F568..1F579 ; Not_XID # 7.0 [18] RIGHT SPEAKER..JOYSTICK\n1F57A ; Not_XID # 9.0 MAN DANCING\n1F57B..1F5A3 ; Not_XID # 7.0 [41] LEFT HAND TELEPHONE RECEIVER..BLACK DOWN POINTING BACKHAND INDEX\n1F5A4 ; Not_XID # 9.0 BLACK HEART\n1F5A5..1F5FA ; Not_XID # 7.0 [86] DESKTOP COMPUTER..WORLD MAP\n1F5FB..1F5FF ; Not_XID # 6.0 [5] MOUNT FUJI..MOYAI\n1F600 ; Not_XID # 6.1 GRINNING FACE\n1F601..1F610 ; Not_XID # 6.0 [16] GRINNING FACE WITH SMILING EYES..NEUTRAL FACE\n1F611 ; Not_XID # 6.1 EXPRESSIONLESS FACE\n1F612..1F614 ; Not_XID # 6.0 [3] UNAMUSED FACE..PENSIVE FACE\n1F615 ; Not_XID # 6.1 CONFUSED FACE\n1F616 ; Not_XID # 6.0 CONFOUNDED FACE\n1F617 ; Not_XID # 6.1 KISSING FACE\n1F618 ; Not_XID # 6.0 FACE THROWING A KISS\n1F619 ; Not_XID # 6.1 KISSING FACE WITH SMILING EYES\n1F61A ; Not_XID # 6.0 KISSING FACE WITH CLOSED EYES\n1F61B ; Not_XID # 6.1 FACE WITH STUCK-OUT TONGUE\n1F61C..1F61E ; Not_XID # 6.0 [3] FACE WITH STUCK-OUT TONGUE AND WINKING EYE..DISAPPOINTED FACE\n1F61F ; Not_XID # 6.1 WORRIED FACE\n1F620..1F625 ; Not_XID # 6.0 [6] ANGRY FACE..DISAPPOINTED BUT RELIEVED FACE\n1F626..1F627 ; Not_XID # 6.1 [2] FROWNING FACE WITH OPEN MOUTH..ANGUISHED FACE\n1F628..1F62B ; Not_XID # 6.0 [4] FEARFUL FACE..TIRED FACE\n1F62C ; Not_XID # 6.1 GRIMACING FACE\n1F62D ; Not_XID # 6.0 LOUDLY CRYING FACE\n1F62E..1F62F ; Not_XID # 6.1 [2] FACE WITH OPEN MOUTH..HUSHED FACE\n1F630..1F633 ; Not_XID # 6.0 [4] FACE WITH OPEN MOUTH AND COLD SWEAT..FLUSHED FACE\n1F634 ; Not_XID # 6.1 SLEEPING FACE\n1F635..1F640 ; Not_XID # 6.0 [12] DIZZY FACE..WEARY CAT FACE\n1F641..1F642 ; Not_XID # 7.0 [2] SLIGHTLY FROWNING FACE..SLIGHTLY SMILING FACE\n1F643..1F644 ; Not_XID # 8.0 [2] UPSIDE-DOWN FACE..FACE WITH ROLLING EYES\n1F645..1F64F ; Not_XID # 6.0 [11] FACE WITH NO GOOD GESTURE..PERSON WITH FOLDED HANDS\n1F650..1F67F ; Not_XID # 7.0 [48] NORTH WEST POINTING LEAF..REVERSE CHECKER BOARD\n1F680..1F6C5 ; Not_XID # 6.0 [70] ROCKET..LEFT LUGGAGE\n1F6C6..1F6CF ; Not_XID # 7.0 [10] TRIANGLE WITH ROUNDED CORNERS..BED\n1F6D0 ; Not_XID # 8.0 PLACE OF WORSHIP\n1F6D1..1F6D2 ; Not_XID # 9.0 [2] OCTAGONAL SIGN..SHOPPING TROLLEY\n1F6D3..1F6D4 ; Not_XID # 10.0 [2] STUPA..PAGODA\n1F6D5 ; Not_XID # 12.0 HINDU TEMPLE\n1F6D6..1F6D7 ; Not_XID # 13.0 [2] HUT..ELEVATOR\n1F6D8 ; Not_XID # 17.0 LANDSLIDE\n1F6DC ; Not_XID # 15.0 WIRELESS\n1F6DD..1F6DF ; Not_XID # 14.0 [3] PLAYGROUND SLIDE..RING BUOY\n1F6E0..1F6EC ; Not_XID # 7.0 [13] HAMMER AND WRENCH..AIRPLANE ARRIVING\n1F6F0..1F6F3 ; Not_XID # 7.0 [4] SATELLITE..PASSENGER SHIP\n1F6F4..1F6F6 ; Not_XID # 9.0 [3] SCOOTER..CANOE\n1F6F7..1F6F8 ; Not_XID # 10.0 [2] SLED..FLYING SAUCER\n1F6F9 ; Not_XID # 11.0 SKATEBOARD\n1F6FA ; Not_XID # 12.0 AUTO RICKSHAW\n1F6FB..1F6FC ; Not_XID # 13.0 [2] PICKUP TRUCK..ROLLER SKATE\n1F700..1F773 ; Not_XID # 6.0 [116] ALCHEMICAL SYMBOL FOR QUINTESSENCE..ALCHEMICAL SYMBOL FOR HALF OUNCE\n1F774..1F776 ; Not_XID # 15.0 [3] LOT OF FORTUNE..LUNAR ECLIPSE\n1F777..1F77A ; Not_XID # 17.0 [4] VESTA FORM TWO..PARTHENOPE FORM TWO\n1F77B..1F77F ; Not_XID # 15.0 [5] HAUMEA..ORCUS\n1F780..1F7D4 ; Not_XID # 7.0 [85] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..HEAVY TWELVE POINTED PINWHEEL STAR\n1F7D5..1F7D8 ; Not_XID # 11.0 [4] CIRCLED TRIANGLE..NEGATIVE CIRCLED SQUARE\n1F7D9 ; Not_XID # 15.0 NINE POINTED WHITE STAR\n1F7E0..1F7EB ; Not_XID # 12.0 [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE\n1F7F0 ; Not_XID # 14.0 HEAVY EQUALS SIGN\n1F800..1F80B ; Not_XID # 7.0 [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD\n1F810..1F847 ; Not_XID # 7.0 [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW\n1F850..1F859 ; Not_XID # 7.0 [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW\n1F860..1F887 ; Not_XID # 7.0 [40] WIDE-HEADED LEFTWARDS LIGHT BARB ARROW..WIDE-HEADED SOUTH WEST VERY HEAVY BARB ARROW\n1F890..1F8AD ; Not_XID # 7.0 [30] LEFTWARDS TRIANGLE ARROWHEAD..WHITE ARROW SHAFT WIDTH TWO THIRDS\n1F8B0..1F8B1 ; Not_XID # 13.0 [2] ARROW POINTING UPWARDS THEN NORTH WEST..ARROW POINTING RIGHTWARDS THEN CURVING SOUTH WEST\n1F8B2..1F8BB ; Not_XID # 16.0 [10] RIGHTWARDS ARROW WITH LOWER HOOK..SOUTH WEST ARROW FROM BAR\n1F8C0..1F8C1 ; Not_XID # 16.0 [2] LEFTWARDS ARROW FROM DOWNWARDS ARROW..RIGHTWARDS ARROW FROM DOWNWARDS ARROW\n1F8D0..1F8D8 ; Not_XID # 17.0 [9] LONG RIGHTWARDS ARROW OVER LONG LEFTWARDS ARROW..LONG LEFT RIGHT ARROW WITH DEPENDENT LOBE\n1F900..1F90B ; Not_XID # 10.0 [12] CIRCLED CROSS FORMEE WITH FOUR DOTS..DOWNWARD FACING NOTCHED HOOK WITH DOT\n1F90C ; Not_XID # 13.0 PINCHED FINGERS\n1F90D..1F90F ; Not_XID # 12.0 [3] WHITE HEART..PINCHING HAND\n1F910..1F918 ; Not_XID # 8.0 [9] ZIPPER-MOUTH FACE..SIGN OF THE HORNS\n1F919..1F91E ; Not_XID # 9.0 [6] CALL ME HAND..HAND WITH INDEX AND MIDDLE FINGERS CROSSED\n1F91F ; Not_XID # 10.0 I LOVE YOU HAND SIGN\n1F920..1F927 ; Not_XID # 9.0 [8] FACE WITH COWBOY HAT..SNEEZING FACE\n1F928..1F92F ; Not_XID # 10.0 [8] FACE WITH ONE EYEBROW RAISED..SHOCKED FACE WITH EXPLODING HEAD\n1F930 ; Not_XID # 9.0 PREGNANT WOMAN\n1F931..1F932 ; Not_XID # 10.0 [2] BREAST-FEEDING..PALMS UP TOGETHER\n1F933..1F93E ; Not_XID # 9.0 [12] SELFIE..HANDBALL\n1F93F ; Not_XID # 12.0 DIVING MASK\n1F940..1F94B ; Not_XID # 9.0 [12] WILTED FLOWER..MARTIAL ARTS UNIFORM\n1F94C ; Not_XID # 10.0 CURLING STONE\n1F94D..1F94F ; Not_XID # 11.0 [3] LACROSSE STICK AND BALL..FLYING DISC\n1F950..1F95E ; Not_XID # 9.0 [15] CROISSANT..PANCAKES\n1F95F..1F96B ; Not_XID # 10.0 [13] DUMPLING..CANNED FOOD\n1F96C..1F970 ; Not_XID # 11.0 [5] LEAFY GREEN..SMILING FACE WITH SMILING EYES AND THREE HEARTS\n1F971 ; Not_XID # 12.0 YAWNING FACE\n1F972 ; Not_XID # 13.0 SMILING FACE WITH TEAR\n1F973..1F976 ; Not_XID # 11.0 [4] FACE WITH PARTY HORN AND PARTY HAT..FREEZING FACE\n1F977..1F978 ; Not_XID # 13.0 [2] NINJA..DISGUISED FACE\n1F979 ; Not_XID # 14.0 FACE HOLDING BACK TEARS\n1F97A ; Not_XID # 11.0 FACE WITH PLEADING EYES\n1F97B ; Not_XID # 12.0 SARI\n1F97C..1F97F ; Not_XID # 11.0 [4] LAB COAT..FLAT SHOE\n1F980..1F984 ; Not_XID # 8.0 [5] CRAB..UNICORN FACE\n1F985..1F991 ; Not_XID # 9.0 [13] EAGLE..SQUID\n1F992..1F997 ; Not_XID # 10.0 [6] GIRAFFE FACE..CRICKET\n1F998..1F9A2 ; Not_XID # 11.0 [11] KANGAROO..SWAN\n1F9A3..1F9A4 ; Not_XID # 13.0 [2] MAMMOTH..DODO\n1F9A5..1F9AA ; Not_XID # 12.0 [6] SLOTH..OYSTER\n1F9AB..1F9AD ; Not_XID # 13.0 [3] BEAVER..SEAL\n1F9AE..1F9AF ; Not_XID # 12.0 [2] GUIDE DOG..PROBING CANE\n1F9B0..1F9B9 ; Not_XID # 11.0 [10] EMOJI COMPONENT RED HAIR..SUPERVILLAIN\n1F9BA..1F9BF ; Not_XID # 12.0 [6] SAFETY VEST..MECHANICAL LEG\n1F9C0 ; Not_XID # 8.0 CHEESE WEDGE\n1F9C1..1F9C2 ; Not_XID # 11.0 [2] CUPCAKE..SALT SHAKER\n1F9C3..1F9CA ; Not_XID # 12.0 [8] BEVERAGE BOX..ICE CUBE\n1F9CB ; Not_XID # 13.0 BUBBLE TEA\n1F9CC ; Not_XID # 14.0 TROLL\n1F9CD..1F9CF ; Not_XID # 12.0 [3] STANDING PERSON..DEAF PERSON\n1F9D0..1F9E6 ; Not_XID # 10.0 [23] FACE WITH MONOCLE..SOCKS\n1F9E7..1F9FF ; Not_XID # 11.0 [25] RED GIFT ENVELOPE..NAZAR AMULET\n1FA00..1FA53 ; Not_XID # 12.0 [84] NEUTRAL CHESS KING..BLACK CHESS KNIGHT-BISHOP\n1FA54..1FA57 ; Not_XID # 17.0 [4] WHITE CHESS FERZ..BLACK CHESS ALFIL\n1FA60..1FA6D ; Not_XID # 11.0 [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER\n1FA70..1FA73 ; Not_XID # 12.0 [4] BALLET SHOES..SHORTS\n1FA74 ; Not_XID # 13.0 THONG SANDAL\n1FA75..1FA77 ; Not_XID # 15.0 [3] LIGHT BLUE HEART..PINK HEART\n1FA78..1FA7A ; Not_XID # 12.0 [3] DROP OF BLOOD..STETHOSCOPE\n1FA7B..1FA7C ; Not_XID # 14.0 [2] X-RAY..CRUTCH\n1FA80..1FA82 ; Not_XID # 12.0 [3] YO-YO..PARACHUTE\n1FA83..1FA86 ; Not_XID # 13.0 [4] BOOMERANG..NESTING DOLLS\n1FA87..1FA88 ; Not_XID # 15.0 [2] MARACAS..FLUTE\n1FA89 ; Not_XID # 16.0 HARP\n1FA8A ; Not_XID # 17.0 TROMBONE\n1FA8E ; Not_XID # 17.0 TREASURE CHEST\n1FA8F ; Not_XID # 16.0 SHOVEL\n1FA90..1FA95 ; Not_XID # 12.0 [6] RINGED PLANET..BANJO\n1FA96..1FAA8 ; Not_XID # 13.0 [19] MILITARY HELMET..ROCK\n1FAA9..1FAAC ; Not_XID # 14.0 [4] MIRROR BALL..HAMSA\n1FAAD..1FAAF ; Not_XID # 15.0 [3] FOLDING HAND FAN..KHANDA\n1FAB0..1FAB6 ; Not_XID # 13.0 [7] FLY..FEATHER\n1FAB7..1FABA ; Not_XID # 14.0 [4] LOTUS..NEST WITH EGGS\n1FABB..1FABD ; Not_XID # 15.0 [3] HYACINTH..WING\n1FABE ; Not_XID # 16.0 LEAFLESS TREE\n1FABF ; Not_XID # 15.0 GOOSE\n1FAC0..1FAC2 ; Not_XID # 13.0 [3] ANATOMICAL HEART..PEOPLE HUGGING\n1FAC3..1FAC5 ; Not_XID # 14.0 [3] PREGNANT MAN..PERSON WITH CROWN\n1FAC6 ; Not_XID # 16.0 FINGERPRINT\n1FAC8 ; Not_XID # 17.0 HAIRY CREATURE\n1FACD ; Not_XID # 17.0 ORCA\n1FACE..1FACF ; Not_XID # 15.0 [2] MOOSE..DONKEY\n1FAD0..1FAD6 ; Not_XID # 13.0 [7] BLUEBERRIES..TEAPOT\n1FAD7..1FAD9 ; Not_XID # 14.0 [3] POURING LIQUID..JAR\n1FADA..1FADB ; Not_XID # 15.0 [2] GINGER ROOT..PEA POD\n1FADC ; Not_XID # 16.0 ROOT VEGETABLE\n1FADF ; Not_XID # 16.0 SPLATTER\n1FAE0..1FAE7 ; Not_XID # 14.0 [8] MELTING FACE..BUBBLES\n1FAE8 ; Not_XID # 15.0 SHAKING FACE\n1FAE9 ; Not_XID # 16.0 FACE WITH BAGS UNDER EYES\n1FAEA ; Not_XID # 17.0 DISTORTED FACE\n1FAEF ; Not_XID # 17.0 FIGHT CLOUD\n1FAF0..1FAF6 ; Not_XID # 14.0 [7] HAND WITH INDEX FINGER AND THUMB CROSSED..HEART HANDS\n1FAF7..1FAF8 ; Not_XID # 15.0 [2] LEFTWARDS PUSHING HAND..RIGHTWARDS PUSHING HAND\n1FB00..1FB92 ; Not_XID # 13.0 [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK\n1FB94..1FBCA ; Not_XID # 13.0 [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON\n1FBCB..1FBEF ; Not_XID # 16.0 [37] WHITE CROSS MARK..TOP LEFT JUSTIFIED LOWER RIGHT QUARTER BLACK CIRCLE\n1FBFA ; Not_XID # 17.0 ALARM BELL SYMBOL\n\n# Total code points: 6487\n\n#\tIdentifier_Type:\tNot_NFKC\n\n00A0 ; Not_NFKC # 1.1 NO-BREAK SPACE\n00A8 ; Not_NFKC # 1.1 DIAERESIS\n00AA ; Not_NFKC # 1.1 FEMININE ORDINAL INDICATOR\n00AF ; Not_NFKC # 1.1 MACRON\n00B2..00B5 ; Not_NFKC # 1.1 [4] SUPERSCRIPT TWO..MICRO SIGN\n00B8..00BA ; Not_NFKC # 1.1 [3] CEDILLA..MASCULINE ORDINAL INDICATOR\n00BC..00BE ; Not_NFKC # 1.1 [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS\n0132..0133 ; Not_NFKC # 1.1 [2] LATIN CAPITAL LIGATURE IJ..LATIN SMALL LIGATURE IJ\n013F..0140 ; Not_NFKC # 1.1 [2] LATIN CAPITAL LETTER L WITH MIDDLE DOT..LATIN SMALL LETTER L WITH MIDDLE DOT\n017F ; Not_NFKC # 1.1 LATIN SMALL LETTER LONG S\n01C4..01CC ; Not_NFKC # 1.1 [9] LATIN CAPITAL LETTER DZ WITH CARON..LATIN SMALL LETTER NJ\n01F1..01F3 ; Not_NFKC # 1.1 [3] LATIN CAPITAL LETTER DZ..LATIN SMALL LETTER DZ\n02B0..02B8 ; Not_NFKC # 1.1 [9] MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y\n02D8..02DD ; Not_NFKC # 1.1 [6] BREVE..DOUBLE ACUTE ACCENT\n02E0..02E4 ; Not_NFKC # 1.1 [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP\n0340..0341 ; Not_NFKC # 1.1 [2] COMBINING GRAVE TONE MARK..COMBINING ACUTE TONE MARK\n0343..0344 ; Not_NFKC # 1.1 [2] COMBINING GREEK KORONIS..COMBINING GREEK DIALYTIKA TONOS\n0374 ; Not_NFKC # 1.1 GREEK NUMERAL SIGN\n037A ; Not_NFKC # 1.1 GREEK YPOGEGRAMMENI\n037E ; Not_NFKC # 1.1 GREEK QUESTION MARK\n0384..0385 ; Not_NFKC # 1.1 [2] GREEK TONOS..GREEK DIALYTIKA TONOS\n0387 ; Not_NFKC # 1.1 GREEK ANO TELEIA\n03D0..03D6 ; Not_NFKC # 1.1 [7] GREEK BETA SYMBOL..GREEK PI SYMBOL\n03F0..03F2 ; Not_NFKC # 1.1 [3] GREEK KAPPA SYMBOL..GREEK LUNATE SIGMA SYMBOL\n03F4..03F5 ; Not_NFKC # 3.1 [2] GREEK CAPITAL THETA SYMBOL..GREEK LUNATE EPSILON SYMBOL\n03F9 ; Not_NFKC # 4.0 GREEK CAPITAL LUNATE SIGMA SYMBOL\n0587 ; Not_NFKC # 1.1 ARMENIAN SMALL LIGATURE ECH YIWN\n0675..0678 ; Not_NFKC # 1.1 [4] ARABIC LETTER HIGH HAMZA ALEF..ARABIC LETTER HIGH HAMZA YEH\n0958..095F ; Not_NFKC # 1.1 [8] DEVANAGARI LETTER QA..DEVANAGARI LETTER YYA\n09DC..09DD ; Not_NFKC # 1.1 [2] BENGALI LETTER RRA..BENGALI LETTER RHA\n09DF ; Not_NFKC # 1.1 BENGALI LETTER YYA\n0A33 ; Not_NFKC # 1.1 GURMUKHI LETTER LLA\n0A36 ; Not_NFKC # 1.1 GURMUKHI LETTER SHA\n0A59..0A5B ; Not_NFKC # 1.1 [3] GURMUKHI LETTER KHHA..GURMUKHI LETTER ZA\n0A5E ; Not_NFKC # 1.1 GURMUKHI LETTER FA\n0B5C..0B5D ; Not_NFKC # 1.1 [2] ORIYA LETTER RRA..ORIYA LETTER RHA\n0E33 ; Not_NFKC # 1.1 THAI CHARACTER SARA AM\n0EB3 ; Not_NFKC # 1.1 LAO VOWEL SIGN AM\n0EDC..0EDD ; Not_NFKC # 1.1 [2] LAO HO NO..LAO HO MO\n0F0C ; Not_NFKC # 2.0 TIBETAN MARK DELIMITER TSHEG BSTAR\n0F43 ; Not_NFKC # 2.0 TIBETAN LETTER GHA\n0F4D ; Not_NFKC # 2.0 TIBETAN LETTER DDHA\n0F52 ; Not_NFKC # 2.0 TIBETAN LETTER DHA\n0F57 ; Not_NFKC # 2.0 TIBETAN LETTER BHA\n0F5C ; Not_NFKC # 2.0 TIBETAN LETTER DZHA\n0F69 ; Not_NFKC # 2.0 TIBETAN LETTER KSSA\n0F73 ; Not_NFKC # 2.0 TIBETAN VOWEL SIGN II\n0F75..0F76 ; Not_NFKC # 2.0 [2] TIBETAN VOWEL SIGN UU..TIBETAN VOWEL SIGN VOCALIC R\n0F78 ; Not_NFKC # 2.0 TIBETAN VOWEL SIGN VOCALIC L\n0F81 ; Not_NFKC # 2.0 TIBETAN VOWEL SIGN REVERSED II\n0F93 ; Not_NFKC # 2.0 TIBETAN SUBJOINED LETTER GHA\n0F9D ; Not_NFKC # 2.0 TIBETAN SUBJOINED LETTER DDHA\n0FA2 ; Not_NFKC # 2.0 TIBETAN SUBJOINED LETTER DHA\n0FA7 ; Not_NFKC # 2.0 TIBETAN SUBJOINED LETTER BHA\n0FAC ; Not_NFKC # 2.0 TIBETAN SUBJOINED LETTER DZHA\n0FB9 ; Not_NFKC # 2.0 TIBETAN SUBJOINED LETTER KSSA\n10FC ; Not_NFKC # 4.1 MODIFIER LETTER GEORGIAN NAR\n1D2C..1D2E ; Not_NFKC # 4.0 [3] MODIFIER LETTER CAPITAL A..MODIFIER LETTER CAPITAL B\n1D30..1D3A ; Not_NFKC # 4.0 [11] MODIFIER LETTER CAPITAL D..MODIFIER LETTER CAPITAL N\n1D3C..1D4D ; Not_NFKC # 4.0 [18] MODIFIER LETTER CAPITAL O..MODIFIER LETTER SMALL G\n1D4F..1D6A ; Not_NFKC # 4.0 [28] MODIFIER LETTER SMALL K..GREEK SUBSCRIPT SMALL LETTER CHI\n1D78 ; Not_NFKC # 4.1 MODIFIER LETTER CYRILLIC EN\n1D9B..1DBF ; Not_NFKC # 4.1 [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA\n1E9A ; Not_NFKC # 1.1 LATIN SMALL LETTER A WITH RIGHT HALF RING\n1E9B ; Not_NFKC # 2.0 LATIN SMALL LETTER LONG S WITH DOT ABOVE\n1F71 ; Not_NFKC # 1.1 GREEK SMALL LETTER ALPHA WITH OXIA\n1F73 ; Not_NFKC # 1.1 GREEK SMALL LETTER EPSILON WITH OXIA\n1F75 ; Not_NFKC # 1.1 GREEK SMALL LETTER ETA WITH OXIA\n1F77 ; Not_NFKC # 1.1 GREEK SMALL LETTER IOTA WITH OXIA\n1F79 ; Not_NFKC # 1.1 GREEK SMALL LETTER OMICRON WITH OXIA\n1F7B ; Not_NFKC # 1.1 GREEK SMALL LETTER UPSILON WITH OXIA\n1F7D ; Not_NFKC # 1.1 GREEK SMALL LETTER OMEGA WITH OXIA\n1FBB ; Not_NFKC # 1.1 GREEK CAPITAL LETTER ALPHA WITH OXIA\n1FBD..1FC1 ; Not_NFKC # 1.1 [5] GREEK KORONIS..GREEK DIALYTIKA AND PERISPOMENI\n1FC9 ; Not_NFKC # 1.1 GREEK CAPITAL LETTER EPSILON WITH OXIA\n1FCB ; Not_NFKC # 1.1 GREEK CAPITAL LETTER ETA WITH OXIA\n1FCD..1FCF ; Not_NFKC # 1.1 [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI\n1FD3 ; Not_NFKC # 1.1 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA\n1FDB ; Not_NFKC # 1.1 GREEK CAPITAL LETTER IOTA WITH OXIA\n1FDD..1FDF ; Not_NFKC # 1.1 [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI\n1FE3 ; Not_NFKC # 1.1 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA\n1FEB ; Not_NFKC # 1.1 GREEK CAPITAL LETTER UPSILON WITH OXIA\n1FED..1FEF ; Not_NFKC # 1.1 [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA\n1FF9 ; Not_NFKC # 1.1 GREEK CAPITAL LETTER OMICRON WITH OXIA\n1FFB ; Not_NFKC # 1.1 GREEK CAPITAL LETTER OMEGA WITH OXIA\n1FFD..1FFE ; Not_NFKC # 1.1 [2] GREEK OXIA..GREEK DASIA\n2000..200A ; Not_NFKC # 1.1 [11] EN QUAD..HAIR SPACE\n2011 ; Not_NFKC # 1.1 NON-BREAKING HYPHEN\n2017 ; Not_NFKC # 1.1 DOUBLE LOW LINE\n2024..2026 ; Not_NFKC # 1.1 [3] ONE DOT LEADER..HORIZONTAL ELLIPSIS\n202F ; Not_NFKC # 3.0 NARROW NO-BREAK SPACE\n2033..2034 ; Not_NFKC # 1.1 [2] DOUBLE PRIME..TRIPLE PRIME\n2036..2037 ; Not_NFKC # 1.1 [2] REVERSED DOUBLE PRIME..REVERSED TRIPLE PRIME\n203C ; Not_NFKC # 1.1 DOUBLE EXCLAMATION MARK\n203E ; Not_NFKC # 1.1 OVERLINE\n2047 ; Not_NFKC # 3.2 DOUBLE QUESTION MARK\n2048..2049 ; Not_NFKC # 3.0 [2] QUESTION EXCLAMATION MARK..EXCLAMATION QUESTION MARK\n2057 ; Not_NFKC # 3.2 QUADRUPLE PRIME\n205F ; Not_NFKC # 3.2 MEDIUM MATHEMATICAL SPACE\n2070 ; Not_NFKC # 1.1 SUPERSCRIPT ZERO\n2071 ; Not_NFKC # 3.2 SUPERSCRIPT LATIN SMALL LETTER I\n2074..208E ; Not_NFKC # 1.1 [27] SUPERSCRIPT FOUR..SUBSCRIPT RIGHT PARENTHESIS\n2090..2094 ; Not_NFKC # 4.1 [5] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER SCHWA\n2095..209C ; Not_NFKC # 6.0 [8] LATIN SUBSCRIPT SMALL LETTER H..LATIN SUBSCRIPT SMALL LETTER T\n20A8 ; Not_NFKC # 1.1 RUPEE SIGN\n2100..2103 ; Not_NFKC # 1.1 [4] ACCOUNT OF..DEGREE CELSIUS\n2105..2107 ; Not_NFKC # 1.1 [3] CARE OF..EULER CONSTANT\n2109..2113 ; Not_NFKC # 1.1 [11] DEGREE FAHRENHEIT..SCRIPT SMALL L\n2115..2116 ; Not_NFKC # 1.1 [2] DOUBLE-STRUCK CAPITAL N..NUMERO SIGN\n2119..211D ; Not_NFKC # 1.1 [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R\n2120..2122 ; Not_NFKC # 1.1 [3] SERVICE MARK..TRADE MARK SIGN\n2124 ; Not_NFKC # 1.1 DOUBLE-STRUCK CAPITAL Z\n2126 ; Not_NFKC # 1.1 OHM SIGN\n2128 ; Not_NFKC # 1.1 BLACK-LETTER CAPITAL Z\n212A..212D ; Not_NFKC # 1.1 [4] KELVIN SIGN..BLACK-LETTER CAPITAL C\n212F..2131 ; Not_NFKC # 1.1 [3] SCRIPT SMALL E..SCRIPT CAPITAL F\n2133..2138 ; Not_NFKC # 1.1 [6] SCRIPT CAPITAL M..DALET SYMBOL\n2139 ; Not_NFKC # 3.0 INFORMATION SOURCE\n213B ; Not_NFKC # 4.0 FACSIMILE SIGN\n213C ; Not_NFKC # 4.1 DOUBLE-STRUCK SMALL PI\n213D..2140 ; Not_NFKC # 3.2 [4] DOUBLE-STRUCK SMALL GAMMA..DOUBLE-STRUCK N-ARY SUMMATION\n2145..2149 ; Not_NFKC # 3.2 [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J\n2150..2152 ; Not_NFKC # 5.2 [3] VULGAR FRACTION ONE SEVENTH..VULGAR FRACTION ONE TENTH\n2153..217F ; Not_NFKC # 1.1 [45] VULGAR FRACTION ONE THIRD..SMALL ROMAN NUMERAL ONE THOUSAND\n2189 ; Not_NFKC # 5.2 VULGAR FRACTION ZERO THIRDS\n222C..222D ; Not_NFKC # 1.1 [2] DOUBLE INTEGRAL..TRIPLE INTEGRAL\n222F..2230 ; Not_NFKC # 1.1 [2] SURFACE INTEGRAL..VOLUME INTEGRAL\n2460..24EA ; Not_NFKC # 1.1 [139] CIRCLED DIGIT ONE..CIRCLED DIGIT ZERO\n2A0C ; Not_NFKC # 3.2 QUADRUPLE INTEGRAL OPERATOR\n2A74..2A76 ; Not_NFKC # 3.2 [3] DOUBLE COLON EQUAL..THREE CONSECUTIVE EQUALS SIGNS\n2ADC ; Not_NFKC # 3.2 FORKING\n2C7C..2C7D ; Not_NFKC # 5.1 [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V\n2D6F ; Not_NFKC # 4.1 TIFINAGH MODIFIER LETTER LABIALIZATION MARK\n2E9F ; Not_NFKC # 3.0 CJK RADICAL MOTHER\n2EF3 ; Not_NFKC # 3.0 CJK RADICAL C-SIMPLIFIED TURTLE\n2F00..2FD5 ; Not_NFKC # 3.0 [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE\n3000 ; Not_NFKC # 1.1 IDEOGRAPHIC SPACE\n3036 ; Not_NFKC # 1.1 CIRCLED POSTAL MARK\n3038..303A ; Not_NFKC # 3.0 [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY\n309B..309C ; Not_NFKC # 1.1 [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK\n309F ; Not_NFKC # 3.2 HIRAGANA DIGRAPH YORI\n30FF ; Not_NFKC # 3.2 KATAKANA DIGRAPH KOTO\n3131..3163 ; Not_NFKC # 1.1 [51] HANGUL LETTER KIYEOK..HANGUL LETTER I\n3165..318E ; Not_NFKC # 1.1 [42] HANGUL LETTER SSANGNIEUN..HANGUL LETTER ARAEAE\n3192..319F ; Not_NFKC # 1.1 [14] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION MAN MARK\n3200..321C ; Not_NFKC # 1.1 [29] PARENTHESIZED HANGUL KIYEOK..PARENTHESIZED HANGUL CIEUC U\n321D..321E ; Not_NFKC # 4.0 [2] PARENTHESIZED KOREAN CHARACTER OJEON..PARENTHESIZED KOREAN CHARACTER O HU\n3220..3243 ; Not_NFKC # 1.1 [36] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH REACH\n3244..3247 ; Not_NFKC # 5.2 [4] CIRCLED IDEOGRAPH QUESTION..CIRCLED IDEOGRAPH KOTO\n3250 ; Not_NFKC # 4.0 PARTNERSHIP SIGN\n3251..325F ; Not_NFKC # 3.2 [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE\n3260..327B ; Not_NFKC # 1.1 [28] CIRCLED HANGUL KIYEOK..CIRCLED HANGUL HIEUH A\n327C..327D ; Not_NFKC # 4.0 [2] CIRCLED KOREAN CHARACTER CHAMKO..CIRCLED KOREAN CHARACTER JUEUI\n327E ; Not_NFKC # 4.1 CIRCLED HANGUL IEUNG U\n3280..32B0 ; Not_NFKC # 1.1 [49] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH NIGHT\n32B1..32BF ; Not_NFKC # 3.2 [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY\n32C0..32CB ; Not_NFKC # 1.1 [12] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER\n32CC..32CF ; Not_NFKC # 4.0 [4] SQUARE HG..LIMITED LIABILITY SIGN\n32D0..32FE ; Not_NFKC # 1.1 [47] CIRCLED KATAKANA A..CIRCLED KATAKANA WO\n32FF ; Not_NFKC # 12.1 SQUARE ERA NAME REIWA\n3300..3376 ; Not_NFKC # 1.1 [119] SQUARE APAATO..SQUARE PC\n3377..337A ; Not_NFKC # 4.0 [4] SQUARE DM..SQUARE IU\n337B..33DD ; Not_NFKC # 1.1 [99] SQUARE ERA NAME HEISEI..SQUARE WB\n33DE..33DF ; Not_NFKC # 4.0 [2] SQUARE V OVER M..SQUARE A OVER M\n33E0..33FE ; Not_NFKC # 1.1 [31] IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE..IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE\n33FF ; Not_NFKC # 4.0 SQUARE GAL\nA69C..A69D ; Not_NFKC # 7.0 [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN\nA770 ; Not_NFKC # 5.1 MODIFIER LETTER US\nA7F1 ; Not_NFKC # 17.0 MODIFIER LETTER CAPITAL S\nA7F2..A7F4 ; Not_NFKC # 14.0 [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q\nA7F8..A7F9 ; Not_NFKC # 6.1 [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE\nAB5C..AB5F ; Not_NFKC # 7.0 [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK\nAB69 ; Not_NFKC # 13.0 MODIFIER LETTER SMALL TURNED W\nF900..FA0D ; Not_NFKC # 1.1 [270] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA0D\nFA10 ; Not_NFKC # 1.1 CJK COMPATIBILITY IDEOGRAPH-FA10\nFA12 ; Not_NFKC # 1.1 CJK COMPATIBILITY IDEOGRAPH-FA12\nFA15..FA1E ; Not_NFKC # 1.1 [10] CJK COMPATIBILITY IDEOGRAPH-FA15..CJK COMPATIBILITY IDEOGRAPH-FA1E\nFA20 ; Not_NFKC # 1.1 CJK COMPATIBILITY IDEOGRAPH-FA20\nFA22 ; Not_NFKC # 1.1 CJK COMPATIBILITY IDEOGRAPH-FA22\nFA25..FA26 ; Not_NFKC # 1.1 [2] CJK COMPATIBILITY IDEOGRAPH-FA25..CJK COMPATIBILITY IDEOGRAPH-FA26\nFA2A..FA2D ; Not_NFKC # 1.1 [4] CJK COMPATIBILITY IDEOGRAPH-FA2A..CJK COMPATIBILITY IDEOGRAPH-FA2D\nFA2E..FA2F ; Not_NFKC # 6.1 [2] CJK COMPATIBILITY IDEOGRAPH-FA2E..CJK COMPATIBILITY IDEOGRAPH-FA2F\nFA30..FA6A ; Not_NFKC # 3.2 [59] CJK COMPATIBILITY IDEOGRAPH-FA30..CJK COMPATIBILITY IDEOGRAPH-FA6A\nFA6B..FA6D ; Not_NFKC # 5.2 [3] CJK COMPATIBILITY IDEOGRAPH-FA6B..CJK COMPATIBILITY IDEOGRAPH-FA6D\nFA70..FAD9 ; Not_NFKC # 4.1 [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9\nFB00..FB06 ; Not_NFKC # 1.1 [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST\nFB13..FB17 ; Not_NFKC # 1.1 [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH\nFB1D ; Not_NFKC # 3.0 HEBREW LETTER YOD WITH HIRIQ\nFB1F..FB36 ; Not_NFKC # 1.1 [24] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER ZAYIN WITH DAGESH\nFB38..FB3C ; Not_NFKC # 1.1 [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH\nFB3E ; Not_NFKC # 1.1 HEBREW LETTER MEM WITH DAGESH\nFB40..FB41 ; Not_NFKC # 1.1 [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH\nFB43..FB44 ; Not_NFKC # 1.1 [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH\nFB46..FBB1 ; Not_NFKC # 1.1 [108] HEBREW LETTER TSADI WITH DAGESH..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM\nFBD3..FD3D ; Not_NFKC # 1.1 [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM\nFD50..FD8F ; Not_NFKC # 1.1 [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM\nFD92..FDC7 ; Not_NFKC # 1.1 [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM\nFDF0..FDFB ; Not_NFKC # 1.1 [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU\nFDFC ; Not_NFKC # 3.2 RIAL SIGN\nFE10..FE19 ; Not_NFKC # 4.1 [10] PRESENTATION FORM FOR VERTICAL COMMA..PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS\nFE30..FE44 ; Not_NFKC # 1.1 [21] PRESENTATION FORM FOR VERTICAL TWO DOT LEADER..PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET\nFE47..FE48 ; Not_NFKC # 4.0 [2] PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET..PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET\nFE49..FE52 ; Not_NFKC # 1.1 [10] DASHED OVERLINE..SMALL FULL STOP\nFE54..FE66 ; Not_NFKC # 1.1 [19] SMALL SEMICOLON..SMALL EQUALS SIGN\nFE68..FE6B ; Not_NFKC # 1.1 [4] SMALL REVERSE SOLIDUS..SMALL COMMERCIAL AT\nFE70..FE72 ; Not_NFKC # 1.1 [3] ARABIC FATHATAN ISOLATED FORM..ARABIC DAMMATAN ISOLATED FORM\nFE74 ; Not_NFKC # 1.1 ARABIC KASRATAN ISOLATED FORM\nFE76..FEFC ; Not_NFKC # 1.1 [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM\nFF01..FF5E ; Not_NFKC # 1.1 [94] FULLWIDTH EXCLAMATION MARK..FULLWIDTH TILDE\nFF5F..FF60 ; Not_NFKC # 3.2 [2] FULLWIDTH LEFT WHITE PARENTHESIS..FULLWIDTH RIGHT WHITE PARENTHESIS\nFF61..FF9F ; Not_NFKC # 1.1 [63] HALFWIDTH IDEOGRAPHIC FULL STOP..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK\nFFA1..FFBE ; Not_NFKC # 1.1 [30] HALFWIDTH HANGUL LETTER KIYEOK..HALFWIDTH HANGUL LETTER HIEUH\nFFC2..FFC7 ; Not_NFKC # 1.1 [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E\nFFCA..FFCF ; Not_NFKC # 1.1 [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE\nFFD2..FFD7 ; Not_NFKC # 1.1 [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU\nFFDA..FFDC ; Not_NFKC # 1.1 [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I\nFFE0..FFE6 ; Not_NFKC # 1.1 [7] FULLWIDTH CENT SIGN..FULLWIDTH WON SIGN\nFFE8..FFEE ; Not_NFKC # 1.1 [7] HALFWIDTH FORMS LIGHT VERTICAL..HALFWIDTH WHITE CIRCLE\n10781..10785 ; Not_NFKC # 14.0 [5] MODIFIER LETTER SUPERSCRIPT TRIANGULAR COLON..MODIFIER LETTER SMALL B WITH HOOK\n10787..107B0 ; Not_NFKC # 14.0 [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK\n107B2..107BA ; Not_NFKC # 14.0 [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL\n1CCD6..1CCF9 ; Not_NFKC # 16.0 [36] OUTLINED LATIN CAPITAL LETTER A..OUTLINED DIGIT NINE\n1D15E..1D164 ; Not_NFKC # 3.1 [7] MUSICAL SYMBOL HALF NOTE..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE\n1D1BB..1D1C0 ; Not_NFKC # 3.1 [6] MUSICAL SYMBOL MINIMA..MUSICAL SYMBOL FUSA BLACK\n1D400..1D454 ; Not_NFKC # 3.1 [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G\n1D456..1D49C ; Not_NFKC # 3.1 [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A\n1D49E..1D49F ; Not_NFKC # 3.1 [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D\n1D4A2 ; Not_NFKC # 3.1 MATHEMATICAL SCRIPT CAPITAL G\n1D4A5..1D4A6 ; Not_NFKC # 3.1 [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K\n1D4A9..1D4AC ; Not_NFKC # 3.1 [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q\n1D4AE..1D4B9 ; Not_NFKC # 3.1 [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D\n1D4BB ; Not_NFKC # 3.1 MATHEMATICAL SCRIPT SMALL F\n1D4BD..1D4C0 ; Not_NFKC # 3.1 [4] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL K\n1D4C1 ; Not_NFKC # 4.0 MATHEMATICAL SCRIPT SMALL L\n1D4C2..1D4C3 ; Not_NFKC # 3.1 [2] MATHEMATICAL SCRIPT SMALL M..MATHEMATICAL SCRIPT SMALL N\n1D4C5..1D505 ; Not_NFKC # 3.1 [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B\n1D507..1D50A ; Not_NFKC # 3.1 [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G\n1D50D..1D514 ; Not_NFKC # 3.1 [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q\n1D516..1D51C ; Not_NFKC # 3.1 [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y\n1D51E..1D539 ; Not_NFKC # 3.1 [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B\n1D53B..1D53E ; Not_NFKC # 3.1 [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G\n1D540..1D544 ; Not_NFKC # 3.1 [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M\n1D546 ; Not_NFKC # 3.1 MATHEMATICAL DOUBLE-STRUCK CAPITAL O\n1D54A..1D550 ; Not_NFKC # 3.1 [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y\n1D552..1D6A3 ; Not_NFKC # 3.1 [338] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL MONOSPACE SMALL Z\n1D6A4..1D6A5 ; Not_NFKC # 4.1 [2] MATHEMATICAL ITALIC SMALL DOTLESS I..MATHEMATICAL ITALIC SMALL DOTLESS J\n1D6A8..1D7C9 ; Not_NFKC # 3.1 [290] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL\n1D7CA..1D7CB ; Not_NFKC # 5.0 [2] MATHEMATICAL BOLD CAPITAL DIGAMMA..MATHEMATICAL BOLD SMALL DIGAMMA\n1D7CE..1D7FF ; Not_NFKC # 3.1 [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE\n1E030..1E06D ; Not_NFKC # 15.0 [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE\n1EE00..1EE03 ; Not_NFKC # 6.1 [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL\n1EE05..1EE1F ; Not_NFKC # 6.1 [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF\n1EE21..1EE22 ; Not_NFKC # 6.1 [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM\n1EE24 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL INITIAL HEH\n1EE27 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL INITIAL HAH\n1EE29..1EE32 ; Not_NFKC # 6.1 [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF\n1EE34..1EE37 ; Not_NFKC # 6.1 [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH\n1EE39 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL INITIAL DAD\n1EE3B ; Not_NFKC # 6.1 ARABIC MATHEMATICAL INITIAL GHAIN\n1EE42 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED JEEM\n1EE47 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED HAH\n1EE49 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED YEH\n1EE4B ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED LAM\n1EE4D..1EE4F ; Not_NFKC # 6.1 [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN\n1EE51..1EE52 ; Not_NFKC # 6.1 [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF\n1EE54 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED SHEEN\n1EE57 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED KHAH\n1EE59 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED DAD\n1EE5B ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED GHAIN\n1EE5D ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED DOTLESS NOON\n1EE5F ; Not_NFKC # 6.1 ARABIC MATHEMATICAL TAILED DOTLESS QAF\n1EE61..1EE62 ; Not_NFKC # 6.1 [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM\n1EE64 ; Not_NFKC # 6.1 ARABIC MATHEMATICAL STRETCHED HEH\n1EE67..1EE6A ; Not_NFKC # 6.1 [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF\n1EE6C..1EE72 ; Not_NFKC # 6.1 [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF\n1EE74..1EE77 ; Not_NFKC # 6.1 [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH\n1EE79..1EE7C ; Not_NFKC # 6.1 [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH\n1EE7E ; Not_NFKC # 6.1 ARABIC MATHEMATICAL STRETCHED DOTLESS FEH\n1EE80..1EE89 ; Not_NFKC # 6.1 [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH\n1EE8B..1EE9B ; Not_NFKC # 6.1 [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN\n1EEA1..1EEA3 ; Not_NFKC # 6.1 [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL\n1EEA5..1EEA9 ; Not_NFKC # 6.1 [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH\n1EEAB..1EEBB ; Not_NFKC # 6.1 [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN\n1F100..1F10A ; Not_NFKC # 5.2 [11] DIGIT ZERO FULL STOP..DIGIT NINE COMMA\n1F110..1F12E ; Not_NFKC # 5.2 [31] PARENTHESIZED LATIN CAPITAL LETTER A..CIRCLED WZ\n1F130 ; Not_NFKC # 6.0 SQUARED LATIN CAPITAL LETTER A\n1F131 ; Not_NFKC # 5.2 SQUARED LATIN CAPITAL LETTER B\n1F132..1F13C ; Not_NFKC # 6.0 [11] SQUARED LATIN CAPITAL LETTER C..SQUARED LATIN CAPITAL LETTER M\n1F13D ; Not_NFKC # 5.2 SQUARED LATIN CAPITAL LETTER N\n1F13E ; Not_NFKC # 6.0 SQUARED LATIN CAPITAL LETTER O\n1F13F ; Not_NFKC # 5.2 SQUARED LATIN CAPITAL LETTER P\n1F140..1F141 ; Not_NFKC # 6.0 [2] SQUARED LATIN CAPITAL LETTER Q..SQUARED LATIN CAPITAL LETTER R\n1F142 ; Not_NFKC # 5.2 SQUARED LATIN CAPITAL LETTER S\n1F143..1F145 ; Not_NFKC # 6.0 [3] SQUARED LATIN CAPITAL LETTER T..SQUARED LATIN CAPITAL LETTER V\n1F146 ; Not_NFKC # 5.2 SQUARED LATIN CAPITAL LETTER W\n1F147..1F149 ; Not_NFKC # 6.0 [3] SQUARED LATIN CAPITAL LETTER X..SQUARED LATIN CAPITAL LETTER Z\n1F14A..1F14E ; Not_NFKC # 5.2 [5] SQUARED HV..SQUARED PPV\n1F14F ; Not_NFKC # 6.0 SQUARED WC\n1F16A..1F16B ; Not_NFKC # 6.1 [2] RAISED MC SIGN..RAISED MD SIGN\n1F16C ; Not_NFKC # 12.0 RAISED MR SIGN\n1F190 ; Not_NFKC # 5.2 SQUARE DJ\n1F200 ; Not_NFKC # 5.2 SQUARE HIRAGANA HOKA\n1F201..1F202 ; Not_NFKC # 6.0 [2] SQUARED KATAKANA KOKO..SQUARED KATAKANA SA\n1F210..1F231 ; Not_NFKC # 5.2 [34] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-6253\n1F232..1F23A ; Not_NFKC # 6.0 [9] SQUARED CJK UNIFIED IDEOGRAPH-7981..SQUARED CJK UNIFIED IDEOGRAPH-55B6\n1F23B ; Not_NFKC # 9.0 SQUARED CJK UNIFIED IDEOGRAPH-914D\n1F240..1F248 ; Not_NFKC # 5.2 [9] TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C..TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557\n1F250..1F251 ; Not_NFKC # 6.0 [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT\n1FBF0..1FBF9 ; Not_NFKC # 13.0 [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE\n2F800..2FA1D ; Not_NFKC # 3.1 [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D\n\n# Total code points: 4958\n\n#\tIdentifier_Type:\tDefault_Ignorable\n\n00AD ; Default_Ignorable # 1.1 SOFT HYPHEN\n034F ; Default_Ignorable # 3.2 COMBINING GRAPHEME JOINER\n061C ; Default_Ignorable # 6.3 ARABIC LETTER MARK\n115F..1160 ; Default_Ignorable # 1.1 [2] HANGUL CHOSEONG FILLER..HANGUL JUNGSEONG FILLER\n17B4..17B5 ; Default_Ignorable # 3.0 [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA\n180B..180D ; Default_Ignorable # 3.0 [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE\n180E ; Default_Ignorable # 3.0 MONGOLIAN VOWEL SEPARATOR\n180F ; Default_Ignorable # 14.0 MONGOLIAN FREE VARIATION SELECTOR FOUR\n200B..200F ; Default_Ignorable # 1.1 [5] ZERO WIDTH SPACE..RIGHT-TO-LEFT MARK\n202A..202E ; Default_Ignorable # 1.1 [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE\n2060..2063 ; Default_Ignorable # 3.2 [4] WORD JOINER..INVISIBLE SEPARATOR\n2064 ; Default_Ignorable # 5.1 INVISIBLE PLUS\n2066..2069 ; Default_Ignorable # 6.3 [4] LEFT-TO-RIGHT ISOLATE..POP DIRECTIONAL ISOLATE\n3164 ; Default_Ignorable # 1.1 HANGUL FILLER\nFE00..FE0F ; Default_Ignorable # 3.2 [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16\nFEFF ; Default_Ignorable # 1.1 ZERO WIDTH NO-BREAK SPACE\nFFA0 ; Default_Ignorable # 1.1 HALFWIDTH HANGUL FILLER\n1BCA0..1BCA3 ; Default_Ignorable # 7.0 [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP\n1D173..1D17A ; Default_Ignorable # 3.1 [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE\nE0020..E007F ; Default_Ignorable # 3.1 [96] TAG SPACE..CANCEL TAG\nE0100..E01EF ; Default_Ignorable # 4.0 [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256\n\n# Total code points: 398\n\n#\tIdentifier_Type:\tDeprecated\n\n0149 ; Deprecated # 1.1 LATIN SMALL LETTER N PRECEDED BY APOSTROPHE\n0673 ; Deprecated # 1.1 ARABIC LETTER ALEF WITH WAVY HAMZA BELOW\n0F77 ; Deprecated # 2.0 TIBETAN VOWEL SIGN VOCALIC RR\n0F79 ; Deprecated # 2.0 TIBETAN VOWEL SIGN VOCALIC LL\n17A3..17A4 ; Deprecated # 3.0 [2] KHMER INDEPENDENT VOWEL QAQ..KHMER INDEPENDENT VOWEL QAA\n206A..206F ; Deprecated # 1.1 [6] INHIBIT SYMMETRIC SWAPPING..NOMINAL DIGIT SHAPES\n2329..232A ; Deprecated # 1.1 [2] LEFT-POINTING ANGLE BRACKET..RIGHT-POINTING ANGLE BRACKET\nE0001 ; Deprecated # 3.1 LANGUAGE TAG\n\n# Total code points: 15\n" }, { "path": "lib/elixir/unicode/PropList.txt", "content": "# PropList-17.0.0.txt\n# Date: 2025-06-30, 06:19:01 GMT\n# © 2025 Unicode®, Inc.\n# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.\n# For terms of use and license, see https://www.unicode.org/terms_of_use.html\n#\n# Unicode Character Database\n# For documentation, see https://www.unicode.org/reports/tr44/\n\n# ================================================\n\n0009..000D ; White_Space # Cc [5] ..\n0020 ; White_Space # Zs SPACE\n0085 ; White_Space # Cc \n00A0 ; White_Space # Zs NO-BREAK SPACE\n1680 ; White_Space # Zs OGHAM SPACE MARK\n2000..200A ; White_Space # Zs [11] EN QUAD..HAIR SPACE\n2028 ; White_Space # Zl LINE SEPARATOR\n2029 ; White_Space # Zp PARAGRAPH SEPARATOR\n202F ; White_Space # Zs NARROW NO-BREAK SPACE\n205F ; White_Space # Zs MEDIUM MATHEMATICAL SPACE\n3000 ; White_Space # Zs IDEOGRAPHIC SPACE\n\n# Total code points: 25\n\n# ================================================\n\n061C ; Bidi_Control # Cf ARABIC LETTER MARK\n200E..200F ; Bidi_Control # Cf [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK\n202A..202E ; Bidi_Control # Cf [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE\n2066..2069 ; Bidi_Control # Cf [4] LEFT-TO-RIGHT ISOLATE..POP DIRECTIONAL ISOLATE\n\n# Total code points: 12\n\n# ================================================\n\n200C..200D ; Join_Control # Cf [2] ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER\n\n# Total code points: 2\n\n# ================================================\n\n002D ; Dash # Pd HYPHEN-MINUS\n058A ; Dash # Pd ARMENIAN HYPHEN\n05BE ; Dash # Pd HEBREW PUNCTUATION MAQAF\n1400 ; Dash # Pd CANADIAN SYLLABICS HYPHEN\n1806 ; Dash # Pd MONGOLIAN TODO SOFT HYPHEN\n2010..2015 ; Dash # Pd [6] HYPHEN..HORIZONTAL BAR\n2053 ; Dash # Po SWUNG DASH\n207B ; Dash # Sm SUPERSCRIPT MINUS\n208B ; Dash # Sm SUBSCRIPT MINUS\n2212 ; Dash # Sm MINUS SIGN\n2E17 ; Dash # Pd DOUBLE OBLIQUE HYPHEN\n2E1A ; Dash # Pd HYPHEN WITH DIAERESIS\n2E3A..2E3B ; Dash # Pd [2] TWO-EM DASH..THREE-EM DASH\n2E40 ; Dash # Pd DOUBLE HYPHEN\n2E5D ; Dash # Pd OBLIQUE HYPHEN\n301C ; Dash # Pd WAVE DASH\n3030 ; Dash # Pd WAVY DASH\n30A0 ; Dash # Pd KATAKANA-HIRAGANA DOUBLE HYPHEN\nFE31..FE32 ; Dash # Pd [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH\nFE58 ; Dash # Pd SMALL EM DASH\nFE63 ; Dash # Pd SMALL HYPHEN-MINUS\nFF0D ; Dash # Pd FULLWIDTH HYPHEN-MINUS\n10D6E ; Dash # Pd GARAY HYPHEN\n10EAD ; Dash # Pd YEZIDI HYPHENATION MARK\n\n# Total code points: 31\n\n# ================================================\n\n002D ; Hyphen # Pd HYPHEN-MINUS\n00AD ; Hyphen # Cf SOFT HYPHEN\n058A ; Hyphen # Pd ARMENIAN HYPHEN\n1806 ; Hyphen # Pd MONGOLIAN TODO SOFT HYPHEN\n2010..2011 ; Hyphen # Pd [2] HYPHEN..NON-BREAKING HYPHEN\n2E17 ; Hyphen # Pd DOUBLE OBLIQUE HYPHEN\n30FB ; Hyphen # Po KATAKANA MIDDLE DOT\nFE63 ; Hyphen # Pd SMALL HYPHEN-MINUS\nFF0D ; Hyphen # Pd FULLWIDTH HYPHEN-MINUS\nFF65 ; Hyphen # Po HALFWIDTH KATAKANA MIDDLE DOT\n\n# Total code points: 11\n\n# ================================================\n\n0022 ; Quotation_Mark # Po QUOTATION MARK\n0027 ; Quotation_Mark # Po APOSTROPHE\n00AB ; Quotation_Mark # Pi LEFT-POINTING DOUBLE ANGLE QUOTATION MARK\n00BB ; Quotation_Mark # Pf RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK\n2018 ; Quotation_Mark # Pi LEFT SINGLE QUOTATION MARK\n2019 ; Quotation_Mark # Pf RIGHT SINGLE QUOTATION MARK\n201A ; Quotation_Mark # Ps SINGLE LOW-9 QUOTATION MARK\n201B..201C ; Quotation_Mark # Pi [2] SINGLE HIGH-REVERSED-9 QUOTATION MARK..LEFT DOUBLE QUOTATION MARK\n201D ; Quotation_Mark # Pf RIGHT DOUBLE QUOTATION MARK\n201E ; Quotation_Mark # Ps DOUBLE LOW-9 QUOTATION MARK\n201F ; Quotation_Mark # Pi DOUBLE HIGH-REVERSED-9 QUOTATION MARK\n2039 ; Quotation_Mark # Pi SINGLE LEFT-POINTING ANGLE QUOTATION MARK\n203A ; Quotation_Mark # Pf SINGLE RIGHT-POINTING ANGLE QUOTATION MARK\n2E42 ; Quotation_Mark # Ps DOUBLE LOW-REVERSED-9 QUOTATION MARK\n300C ; Quotation_Mark # Ps LEFT CORNER BRACKET\n300D ; Quotation_Mark # Pe RIGHT CORNER BRACKET\n300E ; Quotation_Mark # Ps LEFT WHITE CORNER BRACKET\n300F ; Quotation_Mark # Pe RIGHT WHITE CORNER BRACKET\n301D ; Quotation_Mark # Ps REVERSED DOUBLE PRIME QUOTATION MARK\n301E..301F ; Quotation_Mark # Pe [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK\nFE41 ; Quotation_Mark # Ps PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET\nFE42 ; Quotation_Mark # Pe PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET\nFE43 ; Quotation_Mark # Ps PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET\nFE44 ; Quotation_Mark # Pe PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET\nFF02 ; Quotation_Mark # Po FULLWIDTH QUOTATION MARK\nFF07 ; Quotation_Mark # Po FULLWIDTH APOSTROPHE\nFF62 ; Quotation_Mark # Ps HALFWIDTH LEFT CORNER BRACKET\nFF63 ; Quotation_Mark # Pe HALFWIDTH RIGHT CORNER BRACKET\n\n# Total code points: 30\n\n# ================================================\n\n0021 ; Terminal_Punctuation # Po EXCLAMATION MARK\n002C ; Terminal_Punctuation # Po COMMA\n002E ; Terminal_Punctuation # Po FULL STOP\n003A..003B ; Terminal_Punctuation # Po [2] COLON..SEMICOLON\n003F ; Terminal_Punctuation # Po QUESTION MARK\n037E ; Terminal_Punctuation # Po GREEK QUESTION MARK\n0387 ; Terminal_Punctuation # Po GREEK ANO TELEIA\n0589 ; Terminal_Punctuation # Po ARMENIAN FULL STOP\n05C3 ; Terminal_Punctuation # Po HEBREW PUNCTUATION SOF PASUQ\n060C ; Terminal_Punctuation # Po ARABIC COMMA\n061B ; Terminal_Punctuation # Po ARABIC SEMICOLON\n061D..061F ; Terminal_Punctuation # Po [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK\n06D4 ; Terminal_Punctuation # Po ARABIC FULL STOP\n0700..070A ; Terminal_Punctuation # Po [11] SYRIAC END OF PARAGRAPH..SYRIAC CONTRACTION\n070C ; Terminal_Punctuation # Po SYRIAC HARKLEAN METOBELUS\n07F8..07F9 ; Terminal_Punctuation # Po [2] NKO COMMA..NKO EXCLAMATION MARK\n0830..0835 ; Terminal_Punctuation # Po [6] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION SHIYYAALAA\n0837..083E ; Terminal_Punctuation # Po [8] SAMARITAN PUNCTUATION MELODIC QITSA..SAMARITAN PUNCTUATION ANNAAU\n085E ; Terminal_Punctuation # Po MANDAIC PUNCTUATION\n0964..0965 ; Terminal_Punctuation # Po [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA\n0E5A..0E5B ; Terminal_Punctuation # Po [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT\n0F08 ; Terminal_Punctuation # Po TIBETAN MARK SBRUL SHAD\n0F0D..0F12 ; Terminal_Punctuation # Po [6] TIBETAN MARK SHAD..TIBETAN MARK RGYA GRAM SHAD\n104A..104B ; Terminal_Punctuation # Po [2] MYANMAR SIGN LITTLE SECTION..MYANMAR SIGN SECTION\n1361..1368 ; Terminal_Punctuation # Po [8] ETHIOPIC WORDSPACE..ETHIOPIC PARAGRAPH SEPARATOR\n166E ; Terminal_Punctuation # Po CANADIAN SYLLABICS FULL STOP\n16EB..16ED ; Terminal_Punctuation # Po [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION\n1735..1736 ; Terminal_Punctuation # Po [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION\n17D4..17D6 ; Terminal_Punctuation # Po [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH\n17DA ; Terminal_Punctuation # Po KHMER SIGN KOOMUUT\n1802..1805 ; Terminal_Punctuation # Po [4] MONGOLIAN COMMA..MONGOLIAN FOUR DOTS\n1808..1809 ; Terminal_Punctuation # Po [2] MONGOLIAN MANCHU COMMA..MONGOLIAN MANCHU FULL STOP\n1944..1945 ; Terminal_Punctuation # Po [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK\n1AA8..1AAB ; Terminal_Punctuation # Po [4] TAI THAM SIGN KAAN..TAI THAM SIGN SATKAANKUU\n1B4E..1B4F ; Terminal_Punctuation # Po [2] BALINESE INVERTED CARIK SIKI..BALINESE INVERTED CARIK PAREREN\n1B5A..1B5B ; Terminal_Punctuation # Po [2] BALINESE PANTI..BALINESE PAMADA\n1B5D..1B5F ; Terminal_Punctuation # Po [3] BALINESE CARIK PAMUNGKAH..BALINESE CARIK PAREREN\n1B7D..1B7F ; Terminal_Punctuation # Po [3] BALINESE PANTI LANTANG..BALINESE PANTI BAWAK\n1C3B..1C3F ; Terminal_Punctuation # Po [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK\n1C7E..1C7F ; Terminal_Punctuation # Po [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD\n2024 ; Terminal_Punctuation # Po ONE DOT LEADER\n203C..203D ; Terminal_Punctuation # Po [2] DOUBLE EXCLAMATION MARK..INTERROBANG\n2047..2049 ; Terminal_Punctuation # Po [3] DOUBLE QUESTION MARK..EXCLAMATION QUESTION MARK\n2CF9..2CFB ; Terminal_Punctuation # Po [3] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN INDIRECT QUESTION MARK\n2E2E ; Terminal_Punctuation # Po REVERSED QUESTION MARK\n2E3C ; Terminal_Punctuation # Po STENOGRAPHIC FULL STOP\n2E41 ; Terminal_Punctuation # Po REVERSED COMMA\n2E4C ; Terminal_Punctuation # Po MEDIEVAL COMMA\n2E4E..2E4F ; Terminal_Punctuation # Po [2] PUNCTUS ELEVATUS MARK..CORNISH VERSE DIVIDER\n2E53..2E54 ; Terminal_Punctuation # Po [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK\n3001..3002 ; Terminal_Punctuation # Po [2] IDEOGRAPHIC COMMA..IDEOGRAPHIC FULL STOP\nA4FE..A4FF ; Terminal_Punctuation # Po [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP\nA60D..A60F ; Terminal_Punctuation # Po [3] VAI COMMA..VAI QUESTION MARK\nA6F3..A6F7 ; Terminal_Punctuation # Po [5] BAMUM FULL STOP..BAMUM QUESTION MARK\nA876..A877 ; Terminal_Punctuation # Po [2] PHAGS-PA MARK SHAD..PHAGS-PA MARK DOUBLE SHAD\nA8CE..A8CF ; Terminal_Punctuation # Po [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA\nA92F ; Terminal_Punctuation # Po KAYAH LI SIGN SHYA\nA9C7..A9C9 ; Terminal_Punctuation # Po [3] JAVANESE PADA PANGKAT..JAVANESE PADA LUNGSI\nAA5D..AA5F ; Terminal_Punctuation # Po [3] CHAM PUNCTUATION DANDA..CHAM PUNCTUATION TRIPLE DANDA\nAADF ; Terminal_Punctuation # Po TAI VIET SYMBOL KOI KOI\nAAF0..AAF1 ; Terminal_Punctuation # Po [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM\nABEB ; Terminal_Punctuation # Po MEETEI MAYEK CHEIKHEI\nFE12 ; Terminal_Punctuation # Po PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP\nFE15..FE16 ; Terminal_Punctuation # Po [2] PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK..PRESENTATION FORM FOR VERTICAL QUESTION MARK\nFE50..FE52 ; Terminal_Punctuation # Po [3] SMALL COMMA..SMALL FULL STOP\nFE54..FE57 ; Terminal_Punctuation # Po [4] SMALL SEMICOLON..SMALL EXCLAMATION MARK\nFF01 ; Terminal_Punctuation # Po FULLWIDTH EXCLAMATION MARK\nFF0C ; Terminal_Punctuation # Po FULLWIDTH COMMA\nFF0E ; Terminal_Punctuation # Po FULLWIDTH FULL STOP\nFF1A..FF1B ; Terminal_Punctuation # Po [2] FULLWIDTH COLON..FULLWIDTH SEMICOLON\nFF1F ; Terminal_Punctuation # Po FULLWIDTH QUESTION MARK\nFF61 ; Terminal_Punctuation # Po HALFWIDTH IDEOGRAPHIC FULL STOP\nFF64 ; Terminal_Punctuation # Po HALFWIDTH IDEOGRAPHIC COMMA\n1039F ; Terminal_Punctuation # Po UGARITIC WORD DIVIDER\n103D0 ; Terminal_Punctuation # Po OLD PERSIAN WORD DIVIDER\n10857 ; Terminal_Punctuation # Po IMPERIAL ARAMAIC SECTION SIGN\n1091F ; Terminal_Punctuation # Po PHOENICIAN WORD SEPARATOR\n10A56..10A57 ; Terminal_Punctuation # Po [2] KHAROSHTHI PUNCTUATION DANDA..KHAROSHTHI PUNCTUATION DOUBLE DANDA\n10AF0..10AF5 ; Terminal_Punctuation # Po [6] MANICHAEAN PUNCTUATION STAR..MANICHAEAN PUNCTUATION TWO DOTS\n10B3A..10B3F ; Terminal_Punctuation # Po [6] TINY TWO DOTS OVER ONE DOT PUNCTUATION..LARGE ONE RING OVER TWO RINGS PUNCTUATION\n10B99..10B9C ; Terminal_Punctuation # Po [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT\n10F55..10F59 ; Terminal_Punctuation # Po [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT\n10F86..10F89 ; Terminal_Punctuation # Po [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS\n11047..1104D ; Terminal_Punctuation # Po [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS\n110BE..110C1 ; Terminal_Punctuation # Po [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA\n11141..11143 ; Terminal_Punctuation # Po [3] CHAKMA DANDA..CHAKMA QUESTION MARK\n111C5..111C6 ; Terminal_Punctuation # Po [2] SHARADA DANDA..SHARADA DOUBLE DANDA\n111CD ; Terminal_Punctuation # Po SHARADA SUTRA MARK\n111DE..111DF ; Terminal_Punctuation # Po [2] SHARADA SECTION MARK-1..SHARADA SECTION MARK-2\n11238..1123C ; Terminal_Punctuation # Po [5] KHOJKI DANDA..KHOJKI DOUBLE SECTION MARK\n112A9 ; Terminal_Punctuation # Po MULTANI SECTION MARK\n113D4..113D5 ; Terminal_Punctuation # Po [2] TULU-TIGALARI DANDA..TULU-TIGALARI DOUBLE DANDA\n1144B..1144D ; Terminal_Punctuation # Po [3] NEWA DANDA..NEWA COMMA\n1145A..1145B ; Terminal_Punctuation # Po [2] NEWA DOUBLE COMMA..NEWA PLACEHOLDER MARK\n115C2..115C5 ; Terminal_Punctuation # Po [4] SIDDHAM DANDA..SIDDHAM SEPARATOR BAR\n115C9..115D7 ; Terminal_Punctuation # Po [15] SIDDHAM END OF TEXT MARK..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES\n11641..11642 ; Terminal_Punctuation # Po [2] MODI DANDA..MODI DOUBLE DANDA\n1173C..1173E ; Terminal_Punctuation # Po [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI\n11944 ; Terminal_Punctuation # Po DIVES AKURU DOUBLE DANDA\n11946 ; Terminal_Punctuation # Po DIVES AKURU END OF TEXT MARK\n11A42..11A43 ; Terminal_Punctuation # Po [2] ZANABAZAR SQUARE MARK SHAD..ZANABAZAR SQUARE MARK DOUBLE SHAD\n11A9B..11A9C ; Terminal_Punctuation # Po [2] SOYOMBO MARK SHAD..SOYOMBO MARK DOUBLE SHAD\n11AA1..11AA2 ; Terminal_Punctuation # Po [2] SOYOMBO TERMINAL MARK-1..SOYOMBO TERMINAL MARK-2\n11C41..11C43 ; Terminal_Punctuation # Po [3] BHAIKSUKI DANDA..BHAIKSUKI WORD SEPARATOR\n11C71 ; Terminal_Punctuation # Po MARCHEN MARK SHAD\n11EF7..11EF8 ; Terminal_Punctuation # Po [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION\n11F43..11F44 ; Terminal_Punctuation # Po [2] KAWI DANDA..KAWI DOUBLE DANDA\n12470..12474 ; Terminal_Punctuation # Po [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON\n16A6E..16A6F ; Terminal_Punctuation # Po [2] MRO DANDA..MRO DOUBLE DANDA\n16AF5 ; Terminal_Punctuation # Po BASSA VAH FULL STOP\n16B37..16B39 ; Terminal_Punctuation # Po [3] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN CIM CHEEM\n16B44 ; Terminal_Punctuation # Po PAHAWH HMONG SIGN XAUS\n16D6E..16D6F ; Terminal_Punctuation # Po [2] KIRAT RAI DANDA..KIRAT RAI DOUBLE DANDA\n16E97..16E98 ; Terminal_Punctuation # Po [2] MEDEFAIDRIN COMMA..MEDEFAIDRIN FULL STOP\n1BC9F ; Terminal_Punctuation # Po DUPLOYAN PUNCTUATION CHINOOK FULL STOP\n1DA87..1DA8A ; Terminal_Punctuation # Po [4] SIGNWRITING COMMA..SIGNWRITING COLON\n\n# Total code points: 291\n\n# ================================================\n\n005E ; Other_Math # Sk CIRCUMFLEX ACCENT\n03D0..03D2 ; Other_Math # L& [3] GREEK BETA SYMBOL..GREEK UPSILON WITH HOOK SYMBOL\n03D5 ; Other_Math # L& GREEK PHI SYMBOL\n03F0..03F1 ; Other_Math # L& [2] GREEK KAPPA SYMBOL..GREEK RHO SYMBOL\n03F4..03F5 ; Other_Math # L& [2] GREEK CAPITAL THETA SYMBOL..GREEK LUNATE EPSILON SYMBOL\n2016 ; Other_Math # Po DOUBLE VERTICAL LINE\n2032..2034 ; Other_Math # Po [3] PRIME..TRIPLE PRIME\n2040 ; Other_Math # Pc CHARACTER TIE\n2061..2064 ; Other_Math # Cf [4] FUNCTION APPLICATION..INVISIBLE PLUS\n207D ; Other_Math # Ps SUPERSCRIPT LEFT PARENTHESIS\n207E ; Other_Math # Pe SUPERSCRIPT RIGHT PARENTHESIS\n208D ; Other_Math # Ps SUBSCRIPT LEFT PARENTHESIS\n208E ; Other_Math # Pe SUBSCRIPT RIGHT PARENTHESIS\n20D0..20DC ; Other_Math # Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE\n20E1 ; Other_Math # Mn COMBINING LEFT RIGHT ARROW ABOVE\n20E5..20E6 ; Other_Math # Mn [2] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING DOUBLE VERTICAL STROKE OVERLAY\n20EB..20EF ; Other_Math # Mn [5] COMBINING LONG DOUBLE SOLIDUS OVERLAY..COMBINING RIGHT ARROW BELOW\n2102 ; Other_Math # L& DOUBLE-STRUCK CAPITAL C\n2107 ; Other_Math # L& EULER CONSTANT\n210A..2113 ; Other_Math # L& [10] SCRIPT SMALL G..SCRIPT SMALL L\n2115 ; Other_Math # L& DOUBLE-STRUCK CAPITAL N\n2119..211D ; Other_Math # L& [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R\n2124 ; Other_Math # L& DOUBLE-STRUCK CAPITAL Z\n2128 ; Other_Math # L& BLACK-LETTER CAPITAL Z\n2129 ; Other_Math # So TURNED GREEK SMALL LETTER IOTA\n212C..212D ; Other_Math # L& [2] SCRIPT CAPITAL B..BLACK-LETTER CAPITAL C\n212F..2131 ; Other_Math # L& [3] SCRIPT SMALL E..SCRIPT CAPITAL F\n2133..2134 ; Other_Math # L& [2] SCRIPT CAPITAL M..SCRIPT SMALL O\n2135..2138 ; Other_Math # Lo [4] ALEF SYMBOL..DALET SYMBOL\n213C..213F ; Other_Math # L& [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI\n2145..2149 ; Other_Math # L& [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J\n2195..2199 ; Other_Math # So [5] UP DOWN ARROW..SOUTH WEST ARROW\n219C..219F ; Other_Math # So [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW\n21A1..21A2 ; Other_Math # So [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL\n21A4..21A5 ; Other_Math # So [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR\n21A7 ; Other_Math # So DOWNWARDS ARROW FROM BAR\n21A9..21AD ; Other_Math # So [5] LEFTWARDS ARROW WITH HOOK..LEFT RIGHT WAVE ARROW\n21B0..21B1 ; Other_Math # So [2] UPWARDS ARROW WITH TIP LEFTWARDS..UPWARDS ARROW WITH TIP RIGHTWARDS\n21B6..21B7 ; Other_Math # So [2] ANTICLOCKWISE TOP SEMICIRCLE ARROW..CLOCKWISE TOP SEMICIRCLE ARROW\n21BC..21CD ; Other_Math # So [18] LEFTWARDS HARPOON WITH BARB UPWARDS..LEFTWARDS DOUBLE ARROW WITH STROKE\n21D0..21D1 ; Other_Math # So [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW\n21D3 ; Other_Math # So DOWNWARDS DOUBLE ARROW\n21D5..21DB ; Other_Math # So [7] UP DOWN DOUBLE ARROW..RIGHTWARDS TRIPLE ARROW\n21DD ; Other_Math # So RIGHTWARDS SQUIGGLE ARROW\n21E4..21E5 ; Other_Math # So [2] LEFTWARDS ARROW TO BAR..RIGHTWARDS ARROW TO BAR\n2308 ; Other_Math # Ps LEFT CEILING\n2309 ; Other_Math # Pe RIGHT CEILING\n230A ; Other_Math # Ps LEFT FLOOR\n230B ; Other_Math # Pe RIGHT FLOOR\n23B4..23B5 ; Other_Math # So [2] TOP SQUARE BRACKET..BOTTOM SQUARE BRACKET\n23B7 ; Other_Math # So RADICAL SYMBOL BOTTOM\n23D0 ; Other_Math # So VERTICAL LINE EXTENSION\n23E2 ; Other_Math # So WHITE TRAPEZIUM\n25A0..25A1 ; Other_Math # So [2] BLACK SQUARE..WHITE SQUARE\n25AE..25B6 ; Other_Math # So [9] BLACK VERTICAL RECTANGLE..BLACK RIGHT-POINTING TRIANGLE\n25BC..25C0 ; Other_Math # So [5] BLACK DOWN-POINTING TRIANGLE..BLACK LEFT-POINTING TRIANGLE\n25C6..25C7 ; Other_Math # So [2] BLACK DIAMOND..WHITE DIAMOND\n25CA..25CB ; Other_Math # So [2] LOZENGE..WHITE CIRCLE\n25CF..25D3 ; Other_Math # So [5] BLACK CIRCLE..CIRCLE WITH UPPER HALF BLACK\n25E2 ; Other_Math # So BLACK LOWER RIGHT TRIANGLE\n25E4 ; Other_Math # So BLACK UPPER LEFT TRIANGLE\n25E7..25EC ; Other_Math # So [6] SQUARE WITH LEFT HALF BLACK..WHITE UP-POINTING TRIANGLE WITH DOT\n2605..2606 ; Other_Math # So [2] BLACK STAR..WHITE STAR\n2640 ; Other_Math # So FEMALE SIGN\n2642 ; Other_Math # So MALE SIGN\n2660..2663 ; Other_Math # So [4] BLACK SPADE SUIT..BLACK CLUB SUIT\n266D..266E ; Other_Math # So [2] MUSIC FLAT SIGN..MUSIC NATURAL SIGN\n27C5 ; Other_Math # Ps LEFT S-SHAPED BAG DELIMITER\n27C6 ; Other_Math # Pe RIGHT S-SHAPED BAG DELIMITER\n27E6 ; Other_Math # Ps MATHEMATICAL LEFT WHITE SQUARE BRACKET\n27E7 ; Other_Math # Pe MATHEMATICAL RIGHT WHITE SQUARE BRACKET\n27E8 ; Other_Math # Ps MATHEMATICAL LEFT ANGLE BRACKET\n27E9 ; Other_Math # Pe MATHEMATICAL RIGHT ANGLE BRACKET\n27EA ; Other_Math # Ps MATHEMATICAL LEFT DOUBLE ANGLE BRACKET\n27EB ; Other_Math # Pe MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET\n27EC ; Other_Math # Ps MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET\n27ED ; Other_Math # Pe MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET\n27EE ; Other_Math # Ps MATHEMATICAL LEFT FLATTENED PARENTHESIS\n27EF ; Other_Math # Pe MATHEMATICAL RIGHT FLATTENED PARENTHESIS\n2983 ; Other_Math # Ps LEFT WHITE CURLY BRACKET\n2984 ; Other_Math # Pe RIGHT WHITE CURLY BRACKET\n2985 ; Other_Math # Ps LEFT WHITE PARENTHESIS\n2986 ; Other_Math # Pe RIGHT WHITE PARENTHESIS\n2987 ; Other_Math # Ps Z NOTATION LEFT IMAGE BRACKET\n2988 ; Other_Math # Pe Z NOTATION RIGHT IMAGE BRACKET\n2989 ; Other_Math # Ps Z NOTATION LEFT BINDING BRACKET\n298A ; Other_Math # Pe Z NOTATION RIGHT BINDING BRACKET\n298B ; Other_Math # Ps LEFT SQUARE BRACKET WITH UNDERBAR\n298C ; Other_Math # Pe RIGHT SQUARE BRACKET WITH UNDERBAR\n298D ; Other_Math # Ps LEFT SQUARE BRACKET WITH TICK IN TOP CORNER\n298E ; Other_Math # Pe RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER\n298F ; Other_Math # Ps LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER\n2990 ; Other_Math # Pe RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER\n2991 ; Other_Math # Ps LEFT ANGLE BRACKET WITH DOT\n2992 ; Other_Math # Pe RIGHT ANGLE BRACKET WITH DOT\n2993 ; Other_Math # Ps LEFT ARC LESS-THAN BRACKET\n2994 ; Other_Math # Pe RIGHT ARC GREATER-THAN BRACKET\n2995 ; Other_Math # Ps DOUBLE LEFT ARC GREATER-THAN BRACKET\n2996 ; Other_Math # Pe DOUBLE RIGHT ARC LESS-THAN BRACKET\n2997 ; Other_Math # Ps LEFT BLACK TORTOISE SHELL BRACKET\n2998 ; Other_Math # Pe RIGHT BLACK TORTOISE SHELL BRACKET\n29D8 ; Other_Math # Ps LEFT WIGGLY FENCE\n29D9 ; Other_Math # Pe RIGHT WIGGLY FENCE\n29DA ; Other_Math # Ps LEFT DOUBLE WIGGLY FENCE\n29DB ; Other_Math # Pe RIGHT DOUBLE WIGGLY FENCE\n29FC ; Other_Math # Ps LEFT-POINTING CURVED ANGLE BRACKET\n29FD ; Other_Math # Pe RIGHT-POINTING CURVED ANGLE BRACKET\nFE61 ; Other_Math # Po SMALL ASTERISK\nFE63 ; Other_Math # Pd SMALL HYPHEN-MINUS\nFE68 ; Other_Math # Po SMALL REVERSE SOLIDUS\nFF3C ; Other_Math # Po FULLWIDTH REVERSE SOLIDUS\nFF3E ; Other_Math # Sk FULLWIDTH CIRCUMFLEX ACCENT\n1D400..1D454 ; Other_Math # L& [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G\n1D456..1D49C ; Other_Math # L& [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A\n1D49E..1D49F ; Other_Math # L& [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D\n1D4A2 ; Other_Math # L& MATHEMATICAL SCRIPT CAPITAL G\n1D4A5..1D4A6 ; Other_Math # L& [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K\n1D4A9..1D4AC ; Other_Math # L& [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q\n1D4AE..1D4B9 ; Other_Math # L& [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D\n1D4BB ; Other_Math # L& MATHEMATICAL SCRIPT SMALL F\n1D4BD..1D4C3 ; Other_Math # L& [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N\n1D4C5..1D505 ; Other_Math # L& [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B\n1D507..1D50A ; Other_Math # L& [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G\n1D50D..1D514 ; Other_Math # L& [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q\n1D516..1D51C ; Other_Math # L& [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y\n1D51E..1D539 ; Other_Math # L& [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B\n1D53B..1D53E ; Other_Math # L& [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G\n1D540..1D544 ; Other_Math # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M\n1D546 ; Other_Math # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O\n1D54A..1D550 ; Other_Math # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y\n1D552..1D6A5 ; Other_Math # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J\n1D6A8..1D6C0 ; Other_Math # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA\n1D6C2..1D6DA ; Other_Math # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA\n1D6DC..1D6FA ; Other_Math # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA\n1D6FC..1D714 ; Other_Math # L& [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA\n1D716..1D734 ; Other_Math # L& [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA\n1D736..1D74E ; Other_Math # L& [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA\n1D750..1D76E ; Other_Math # L& [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA\n1D770..1D788 ; Other_Math # L& [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA\n1D78A..1D7A8 ; Other_Math # L& [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA\n1D7AA..1D7C2 ; Other_Math # L& [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA\n1D7C4..1D7CB ; Other_Math # L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA\n1D7CE..1D7FF ; Other_Math # Nd [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE\n1EE00..1EE03 ; Other_Math # Lo [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL\n1EE05..1EE1F ; Other_Math # Lo [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF\n1EE21..1EE22 ; Other_Math # Lo [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM\n1EE24 ; Other_Math # Lo ARABIC MATHEMATICAL INITIAL HEH\n1EE27 ; Other_Math # Lo ARABIC MATHEMATICAL INITIAL HAH\n1EE29..1EE32 ; Other_Math # Lo [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF\n1EE34..1EE37 ; Other_Math # Lo [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH\n1EE39 ; Other_Math # Lo ARABIC MATHEMATICAL INITIAL DAD\n1EE3B ; Other_Math # Lo ARABIC MATHEMATICAL INITIAL GHAIN\n1EE42 ; Other_Math # Lo ARABIC MATHEMATICAL TAILED JEEM\n1EE47 ; Other_Math # Lo ARABIC MATHEMATICAL TAILED HAH\n1EE49 ; Other_Math # Lo ARABIC MATHEMATICAL TAILED YEH\n1EE4B ; Other_Math # Lo ARABIC MATHEMATICAL TAILED LAM\n1EE4D..1EE4F ; Other_Math # Lo [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN\n1EE51..1EE52 ; Other_Math # Lo [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF\n1EE54 ; Other_Math # Lo ARABIC MATHEMATICAL TAILED SHEEN\n1EE57 ; Other_Math # Lo ARABIC MATHEMATICAL TAILED KHAH\n1EE59 ; Other_Math # Lo ARABIC MATHEMATICAL TAILED DAD\n1EE5B ; Other_Math # Lo ARABIC MATHEMATICAL TAILED GHAIN\n1EE5D ; Other_Math # Lo ARABIC MATHEMATICAL TAILED DOTLESS NOON\n1EE5F ; Other_Math # Lo ARABIC MATHEMATICAL TAILED DOTLESS QAF\n1EE61..1EE62 ; Other_Math # Lo [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM\n1EE64 ; Other_Math # Lo ARABIC MATHEMATICAL STRETCHED HEH\n1EE67..1EE6A ; Other_Math # Lo [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF\n1EE6C..1EE72 ; Other_Math # Lo [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF\n1EE74..1EE77 ; Other_Math # Lo [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH\n1EE79..1EE7C ; Other_Math # Lo [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH\n1EE7E ; Other_Math # Lo ARABIC MATHEMATICAL STRETCHED DOTLESS FEH\n1EE80..1EE89 ; Other_Math # Lo [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH\n1EE8B..1EE9B ; Other_Math # Lo [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN\n1EEA1..1EEA3 ; Other_Math # Lo [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL\n1EEA5..1EEA9 ; Other_Math # Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH\n1EEAB..1EEBB ; Other_Math # Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN\n\n# Total code points: 1362\n\n# ================================================\n\n0030..0039 ; Hex_Digit # Nd [10] DIGIT ZERO..DIGIT NINE\n0041..0046 ; Hex_Digit # L& [6] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER F\n0061..0066 ; Hex_Digit # L& [6] LATIN SMALL LETTER A..LATIN SMALL LETTER F\nFF10..FF19 ; Hex_Digit # Nd [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE\nFF21..FF26 ; Hex_Digit # L& [6] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER F\nFF41..FF46 ; Hex_Digit # L& [6] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER F\n\n# Total code points: 44\n\n# ================================================\n\n0030..0039 ; ASCII_Hex_Digit # Nd [10] DIGIT ZERO..DIGIT NINE\n0041..0046 ; ASCII_Hex_Digit # L& [6] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER F\n0061..0066 ; ASCII_Hex_Digit # L& [6] LATIN SMALL LETTER A..LATIN SMALL LETTER F\n\n# Total code points: 22\n\n# ================================================\n\n0345 ; Other_Alphabetic # Mn COMBINING GREEK YPOGEGRAMMENI\n0363..036F ; Other_Alphabetic # Mn [13] COMBINING LATIN SMALL LETTER A..COMBINING LATIN SMALL LETTER X\n05B0..05BD ; Other_Alphabetic # Mn [14] HEBREW POINT SHEVA..HEBREW POINT METEG\n05BF ; Other_Alphabetic # Mn HEBREW POINT RAFE\n05C1..05C2 ; Other_Alphabetic # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT\n05C4..05C5 ; Other_Alphabetic # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT\n05C7 ; Other_Alphabetic # Mn HEBREW POINT QAMATS QATAN\n0610..061A ; Other_Alphabetic # Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA\n064B..0657 ; Other_Alphabetic # Mn [13] ARABIC FATHATAN..ARABIC INVERTED DAMMA\n0659..065F ; Other_Alphabetic # Mn [7] ARABIC ZWARAKAY..ARABIC WAVY HAMZA BELOW\n0670 ; Other_Alphabetic # Mn ARABIC LETTER SUPERSCRIPT ALEF\n06D6..06DC ; Other_Alphabetic # Mn [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN\n06E1..06E4 ; Other_Alphabetic # Mn [4] ARABIC SMALL HIGH DOTLESS HEAD OF KHAH..ARABIC SMALL HIGH MADDA\n06E7..06E8 ; Other_Alphabetic # Mn [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON\n06ED ; Other_Alphabetic # Mn ARABIC SMALL LOW MEEM\n0711 ; Other_Alphabetic # Mn SYRIAC LETTER SUPERSCRIPT ALAPH\n0730..073F ; Other_Alphabetic # Mn [16] SYRIAC PTHAHA ABOVE..SYRIAC RWAHA\n07A6..07B0 ; Other_Alphabetic # Mn [11] THAANA ABAFILI..THAANA SUKUN\n0816..0817 ; Other_Alphabetic # Mn [2] SAMARITAN MARK IN..SAMARITAN MARK IN-ALAF\n081B..0823 ; Other_Alphabetic # Mn [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A\n0825..0827 ; Other_Alphabetic # Mn [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U\n0829..082C ; Other_Alphabetic # Mn [4] SAMARITAN VOWEL SIGN LONG I..SAMARITAN VOWEL SIGN SUKUN\n0897 ; Other_Alphabetic # Mn ARABIC PEPET\n08D4..08DF ; Other_Alphabetic # Mn [12] ARABIC SMALL HIGH WORD AR-RUB..ARABIC SMALL HIGH WORD WAQFA\n08E3..08E9 ; Other_Alphabetic # Mn [7] ARABIC TURNED DAMMA BELOW..ARABIC CURLY KASRATAN\n08F0..0902 ; Other_Alphabetic # Mn [19] ARABIC OPEN FATHATAN..DEVANAGARI SIGN ANUSVARA\n0903 ; Other_Alphabetic # Mc DEVANAGARI SIGN VISARGA\n093A ; Other_Alphabetic # Mn DEVANAGARI VOWEL SIGN OE\n093B ; Other_Alphabetic # Mc DEVANAGARI VOWEL SIGN OOE\n093E..0940 ; Other_Alphabetic # Mc [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II\n0941..0948 ; Other_Alphabetic # Mn [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI\n0949..094C ; Other_Alphabetic # Mc [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU\n094E..094F ; Other_Alphabetic # Mc [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW\n0955..0957 ; Other_Alphabetic # Mn [3] DEVANAGARI VOWEL SIGN CANDRA LONG E..DEVANAGARI VOWEL SIGN UUE\n0962..0963 ; Other_Alphabetic # Mn [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL\n0981 ; Other_Alphabetic # Mn BENGALI SIGN CANDRABINDU\n0982..0983 ; Other_Alphabetic # Mc [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA\n09BE..09C0 ; Other_Alphabetic # Mc [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II\n09C1..09C4 ; Other_Alphabetic # Mn [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR\n09C7..09C8 ; Other_Alphabetic # Mc [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI\n09CB..09CC ; Other_Alphabetic # Mc [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU\n09D7 ; Other_Alphabetic # Mc BENGALI AU LENGTH MARK\n09E2..09E3 ; Other_Alphabetic # Mn [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL\n0A01..0A02 ; Other_Alphabetic # Mn [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI\n0A03 ; Other_Alphabetic # Mc GURMUKHI SIGN VISARGA\n0A3E..0A40 ; Other_Alphabetic # Mc [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II\n0A41..0A42 ; Other_Alphabetic # Mn [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU\n0A47..0A48 ; Other_Alphabetic # Mn [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI\n0A4B..0A4C ; Other_Alphabetic # Mn [2] GURMUKHI VOWEL SIGN OO..GURMUKHI VOWEL SIGN AU\n0A51 ; Other_Alphabetic # Mn GURMUKHI SIGN UDAAT\n0A70..0A71 ; Other_Alphabetic # Mn [2] GURMUKHI TIPPI..GURMUKHI ADDAK\n0A75 ; Other_Alphabetic # Mn GURMUKHI SIGN YAKASH\n0A81..0A82 ; Other_Alphabetic # Mn [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA\n0A83 ; Other_Alphabetic # Mc GUJARATI SIGN VISARGA\n0ABE..0AC0 ; Other_Alphabetic # Mc [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II\n0AC1..0AC5 ; Other_Alphabetic # Mn [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E\n0AC7..0AC8 ; Other_Alphabetic # Mn [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI\n0AC9 ; Other_Alphabetic # Mc GUJARATI VOWEL SIGN CANDRA O\n0ACB..0ACC ; Other_Alphabetic # Mc [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU\n0AE2..0AE3 ; Other_Alphabetic # Mn [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL\n0AFA..0AFC ; Other_Alphabetic # Mn [3] GUJARATI SIGN SUKUN..GUJARATI SIGN MADDAH\n0B01 ; Other_Alphabetic # Mn ORIYA SIGN CANDRABINDU\n0B02..0B03 ; Other_Alphabetic # Mc [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA\n0B3E ; Other_Alphabetic # Mc ORIYA VOWEL SIGN AA\n0B3F ; Other_Alphabetic # Mn ORIYA VOWEL SIGN I\n0B40 ; Other_Alphabetic # Mc ORIYA VOWEL SIGN II\n0B41..0B44 ; Other_Alphabetic # Mn [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR\n0B47..0B48 ; Other_Alphabetic # Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI\n0B4B..0B4C ; Other_Alphabetic # Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU\n0B56 ; Other_Alphabetic # Mn ORIYA AI LENGTH MARK\n0B57 ; Other_Alphabetic # Mc ORIYA AU LENGTH MARK\n0B62..0B63 ; Other_Alphabetic # Mn [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL\n0B82 ; Other_Alphabetic # Mn TAMIL SIGN ANUSVARA\n0BBE..0BBF ; Other_Alphabetic # Mc [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I\n0BC0 ; Other_Alphabetic # Mn TAMIL VOWEL SIGN II\n0BC1..0BC2 ; Other_Alphabetic # Mc [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU\n0BC6..0BC8 ; Other_Alphabetic # Mc [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI\n0BCA..0BCC ; Other_Alphabetic # Mc [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU\n0BD7 ; Other_Alphabetic # Mc TAMIL AU LENGTH MARK\n0C00 ; Other_Alphabetic # Mn TELUGU SIGN COMBINING CANDRABINDU ABOVE\n0C01..0C03 ; Other_Alphabetic # Mc [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA\n0C04 ; Other_Alphabetic # Mn TELUGU SIGN COMBINING ANUSVARA ABOVE\n0C3E..0C40 ; Other_Alphabetic # Mn [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II\n0C41..0C44 ; Other_Alphabetic # Mc [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR\n0C46..0C48 ; Other_Alphabetic # Mn [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI\n0C4A..0C4C ; Other_Alphabetic # Mn [3] TELUGU VOWEL SIGN O..TELUGU VOWEL SIGN AU\n0C55..0C56 ; Other_Alphabetic # Mn [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK\n0C62..0C63 ; Other_Alphabetic # Mn [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL\n0C81 ; Other_Alphabetic # Mn KANNADA SIGN CANDRABINDU\n0C82..0C83 ; Other_Alphabetic # Mc [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA\n0CBE ; Other_Alphabetic # Mc KANNADA VOWEL SIGN AA\n0CBF ; Other_Alphabetic # Mn KANNADA VOWEL SIGN I\n0CC0..0CC4 ; Other_Alphabetic # Mc [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR\n0CC6 ; Other_Alphabetic # Mn KANNADA VOWEL SIGN E\n0CC7..0CC8 ; Other_Alphabetic # Mc [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI\n0CCA..0CCB ; Other_Alphabetic # Mc [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO\n0CCC ; Other_Alphabetic # Mn KANNADA VOWEL SIGN AU\n0CD5..0CD6 ; Other_Alphabetic # Mc [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK\n0CE2..0CE3 ; Other_Alphabetic # Mn [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL\n0CF3 ; Other_Alphabetic # Mc KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT\n0D00..0D01 ; Other_Alphabetic # Mn [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU\n0D02..0D03 ; Other_Alphabetic # Mc [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA\n0D3E..0D40 ; Other_Alphabetic # Mc [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II\n0D41..0D44 ; Other_Alphabetic # Mn [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR\n0D46..0D48 ; Other_Alphabetic # Mc [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI\n0D4A..0D4C ; Other_Alphabetic # Mc [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU\n0D57 ; Other_Alphabetic # Mc MALAYALAM AU LENGTH MARK\n0D62..0D63 ; Other_Alphabetic # Mn [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL\n0D81 ; Other_Alphabetic # Mn SINHALA SIGN CANDRABINDU\n0D82..0D83 ; Other_Alphabetic # Mc [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA\n0DCF..0DD1 ; Other_Alphabetic # Mc [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA\n0DD2..0DD4 ; Other_Alphabetic # Mn [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA\n0DD6 ; Other_Alphabetic # Mn SINHALA VOWEL SIGN DIGA PAA-PILLA\n0DD8..0DDF ; Other_Alphabetic # Mc [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA\n0DF2..0DF3 ; Other_Alphabetic # Mc [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA\n0E31 ; Other_Alphabetic # Mn THAI CHARACTER MAI HAN-AKAT\n0E34..0E3A ; Other_Alphabetic # Mn [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU\n0E4D ; Other_Alphabetic # Mn THAI CHARACTER NIKHAHIT\n0EB1 ; Other_Alphabetic # Mn LAO VOWEL SIGN MAI KAN\n0EB4..0EB9 ; Other_Alphabetic # Mn [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU\n0EBB..0EBC ; Other_Alphabetic # Mn [2] LAO VOWEL SIGN MAI KON..LAO SEMIVOWEL SIGN LO\n0ECD ; Other_Alphabetic # Mn LAO NIGGAHITA\n0F71..0F7E ; Other_Alphabetic # Mn [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO\n0F7F ; Other_Alphabetic # Mc TIBETAN SIGN RNAM BCAD\n0F80..0F83 ; Other_Alphabetic # Mn [4] TIBETAN VOWEL SIGN REVERSED I..TIBETAN SIGN SNA LDAN\n0F8D..0F97 ; Other_Alphabetic # Mn [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA\n0F99..0FBC ; Other_Alphabetic # Mn [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA\n102B..102C ; Other_Alphabetic # Mc [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA\n102D..1030 ; Other_Alphabetic # Mn [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU\n1031 ; Other_Alphabetic # Mc MYANMAR VOWEL SIGN E\n1032..1036 ; Other_Alphabetic # Mn [5] MYANMAR VOWEL SIGN AI..MYANMAR SIGN ANUSVARA\n1038 ; Other_Alphabetic # Mc MYANMAR SIGN VISARGA\n103B..103C ; Other_Alphabetic # Mc [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA\n103D..103E ; Other_Alphabetic # Mn [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA\n1056..1057 ; Other_Alphabetic # Mc [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR\n1058..1059 ; Other_Alphabetic # Mn [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL\n105E..1060 ; Other_Alphabetic # Mn [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA\n1062..1064 ; Other_Alphabetic # Mc [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO\n1067..106D ; Other_Alphabetic # Mc [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5\n1071..1074 ; Other_Alphabetic # Mn [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE\n1082 ; Other_Alphabetic # Mn MYANMAR CONSONANT SIGN SHAN MEDIAL WA\n1083..1084 ; Other_Alphabetic # Mc [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E\n1085..1086 ; Other_Alphabetic # Mn [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y\n1087..108C ; Other_Alphabetic # Mc [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3\n108D ; Other_Alphabetic # Mn MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE\n108F ; Other_Alphabetic # Mc MYANMAR SIGN RUMAI PALAUNG TONE-5\n109A..109C ; Other_Alphabetic # Mc [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A\n109D ; Other_Alphabetic # Mn MYANMAR VOWEL SIGN AITON AI\n1712..1713 ; Other_Alphabetic # Mn [2] TAGALOG VOWEL SIGN I..TAGALOG VOWEL SIGN U\n1732..1733 ; Other_Alphabetic # Mn [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U\n1752..1753 ; Other_Alphabetic # Mn [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U\n1772..1773 ; Other_Alphabetic # Mn [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U\n17B6 ; Other_Alphabetic # Mc KHMER VOWEL SIGN AA\n17B7..17BD ; Other_Alphabetic # Mn [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA\n17BE..17C5 ; Other_Alphabetic # Mc [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU\n17C6 ; Other_Alphabetic # Mn KHMER SIGN NIKAHIT\n17C7..17C8 ; Other_Alphabetic # Mc [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU\n1885..1886 ; Other_Alphabetic # Mn [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA\n18A9 ; Other_Alphabetic # Mn MONGOLIAN LETTER ALI GALI DAGALGA\n1920..1922 ; Other_Alphabetic # Mn [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U\n1923..1926 ; Other_Alphabetic # Mc [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU\n1927..1928 ; Other_Alphabetic # Mn [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O\n1929..192B ; Other_Alphabetic # Mc [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA\n1930..1931 ; Other_Alphabetic # Mc [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA\n1932 ; Other_Alphabetic # Mn LIMBU SMALL LETTER ANUSVARA\n1933..1938 ; Other_Alphabetic # Mc [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA\n1A17..1A18 ; Other_Alphabetic # Mn [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U\n1A19..1A1A ; Other_Alphabetic # Mc [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O\n1A1B ; Other_Alphabetic # Mn BUGINESE VOWEL SIGN AE\n1A55 ; Other_Alphabetic # Mc TAI THAM CONSONANT SIGN MEDIAL RA\n1A56 ; Other_Alphabetic # Mn TAI THAM CONSONANT SIGN MEDIAL LA\n1A57 ; Other_Alphabetic # Mc TAI THAM CONSONANT SIGN LA TANG LAI\n1A58..1A5E ; Other_Alphabetic # Mn [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA\n1A61 ; Other_Alphabetic # Mc TAI THAM VOWEL SIGN A\n1A62 ; Other_Alphabetic # Mn TAI THAM VOWEL SIGN MAI SAT\n1A63..1A64 ; Other_Alphabetic # Mc [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA\n1A65..1A6C ; Other_Alphabetic # Mn [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW\n1A6D..1A72 ; Other_Alphabetic # Mc [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI\n1A73..1A74 ; Other_Alphabetic # Mn [2] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN MAI KANG\n1ABF..1AC0 ; Other_Alphabetic # Mn [2] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER TURNED W BELOW\n1ACC..1ACE ; Other_Alphabetic # Mn [3] COMBINING LATIN SMALL LETTER INSULAR G..COMBINING LATIN SMALL LETTER INSULAR T\n1B00..1B03 ; Other_Alphabetic # Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG\n1B04 ; Other_Alphabetic # Mc BALINESE SIGN BISAH\n1B35 ; Other_Alphabetic # Mc BALINESE VOWEL SIGN TEDUNG\n1B36..1B3A ; Other_Alphabetic # Mn [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA\n1B3B ; Other_Alphabetic # Mc BALINESE VOWEL SIGN RA REPA TEDUNG\n1B3C ; Other_Alphabetic # Mn BALINESE VOWEL SIGN LA LENGA\n1B3D..1B41 ; Other_Alphabetic # Mc [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG\n1B42 ; Other_Alphabetic # Mn BALINESE VOWEL SIGN PEPET\n1B43 ; Other_Alphabetic # Mc BALINESE VOWEL SIGN PEPET TEDUNG\n1B80..1B81 ; Other_Alphabetic # Mn [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR\n1B82 ; Other_Alphabetic # Mc SUNDANESE SIGN PANGWISAD\n1BA1 ; Other_Alphabetic # Mc SUNDANESE CONSONANT SIGN PAMINGKAL\n1BA2..1BA5 ; Other_Alphabetic # Mn [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU\n1BA6..1BA7 ; Other_Alphabetic # Mc [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG\n1BA8..1BA9 ; Other_Alphabetic # Mn [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG\n1BAC..1BAD ; Other_Alphabetic # Mn [2] SUNDANESE CONSONANT SIGN PASANGAN MA..SUNDANESE CONSONANT SIGN PASANGAN WA\n1BE7 ; Other_Alphabetic # Mc BATAK VOWEL SIGN E\n1BE8..1BE9 ; Other_Alphabetic # Mn [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE\n1BEA..1BEC ; Other_Alphabetic # Mc [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O\n1BED ; Other_Alphabetic # Mn BATAK VOWEL SIGN KARO O\n1BEE ; Other_Alphabetic # Mc BATAK VOWEL SIGN U\n1BEF..1BF1 ; Other_Alphabetic # Mn [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H\n1C24..1C2B ; Other_Alphabetic # Mc [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU\n1C2C..1C33 ; Other_Alphabetic # Mn [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T\n1C34..1C35 ; Other_Alphabetic # Mc [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG\n1C36 ; Other_Alphabetic # Mn LEPCHA SIGN RAN\n1DD3..1DF4 ; Other_Alphabetic # Mn [34] COMBINING LATIN SMALL LETTER FLATTENED OPEN A ABOVE..COMBINING LATIN SMALL LETTER U WITH DIAERESIS\n24B6..24E9 ; Other_Alphabetic # So [52] CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN SMALL LETTER Z\n2DE0..2DFF ; Other_Alphabetic # Mn [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS\nA674..A67B ; Other_Alphabetic # Mn [8] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC LETTER OMEGA\nA69E..A69F ; Other_Alphabetic # Mn [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E\nA802 ; Other_Alphabetic # Mn SYLOTI NAGRI SIGN DVISVARA\nA80B ; Other_Alphabetic # Mn SYLOTI NAGRI SIGN ANUSVARA\nA823..A824 ; Other_Alphabetic # Mc [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I\nA825..A826 ; Other_Alphabetic # Mn [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E\nA827 ; Other_Alphabetic # Mc SYLOTI NAGRI VOWEL SIGN OO\nA880..A881 ; Other_Alphabetic # Mc [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA\nA8B4..A8C3 ; Other_Alphabetic # Mc [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU\nA8C5 ; Other_Alphabetic # Mn SAURASHTRA SIGN CANDRABINDU\nA8FF ; Other_Alphabetic # Mn DEVANAGARI VOWEL SIGN AY\nA926..A92A ; Other_Alphabetic # Mn [5] KAYAH LI VOWEL UE..KAYAH LI VOWEL O\nA947..A951 ; Other_Alphabetic # Mn [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R\nA952 ; Other_Alphabetic # Mc REJANG CONSONANT SIGN H\nA980..A982 ; Other_Alphabetic # Mn [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR\nA983 ; Other_Alphabetic # Mc JAVANESE SIGN WIGNYAN\nA9B4..A9B5 ; Other_Alphabetic # Mc [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG\nA9B6..A9B9 ; Other_Alphabetic # Mn [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT\nA9BA..A9BB ; Other_Alphabetic # Mc [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE\nA9BC..A9BD ; Other_Alphabetic # Mn [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET\nA9BE..A9BF ; Other_Alphabetic # Mc [2] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE CONSONANT SIGN CAKRA\nA9E5 ; Other_Alphabetic # Mn MYANMAR SIGN SHAN SAW\nAA29..AA2E ; Other_Alphabetic # Mn [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE\nAA2F..AA30 ; Other_Alphabetic # Mc [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI\nAA31..AA32 ; Other_Alphabetic # Mn [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE\nAA33..AA34 ; Other_Alphabetic # Mc [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA\nAA35..AA36 ; Other_Alphabetic # Mn [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA\nAA43 ; Other_Alphabetic # Mn CHAM CONSONANT SIGN FINAL NG\nAA4C ; Other_Alphabetic # Mn CHAM CONSONANT SIGN FINAL M\nAA4D ; Other_Alphabetic # Mc CHAM CONSONANT SIGN FINAL H\nAA7B ; Other_Alphabetic # Mc MYANMAR SIGN PAO KAREN TONE\nAA7C ; Other_Alphabetic # Mn MYANMAR SIGN TAI LAING TONE-2\nAA7D ; Other_Alphabetic # Mc MYANMAR SIGN TAI LAING TONE-5\nAAB0 ; Other_Alphabetic # Mn TAI VIET MAI KANG\nAAB2..AAB4 ; Other_Alphabetic # Mn [3] TAI VIET VOWEL I..TAI VIET VOWEL U\nAAB7..AAB8 ; Other_Alphabetic # Mn [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA\nAABE ; Other_Alphabetic # Mn TAI VIET VOWEL AM\nAAEB ; Other_Alphabetic # Mc MEETEI MAYEK VOWEL SIGN II\nAAEC..AAED ; Other_Alphabetic # Mn [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI\nAAEE..AAEF ; Other_Alphabetic # Mc [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU\nAAF5 ; Other_Alphabetic # Mc MEETEI MAYEK VOWEL SIGN VISARGA\nABE3..ABE4 ; Other_Alphabetic # Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP\nABE5 ; Other_Alphabetic # Mn MEETEI MAYEK VOWEL SIGN ANAP\nABE6..ABE7 ; Other_Alphabetic # Mc [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP\nABE8 ; Other_Alphabetic # Mn MEETEI MAYEK VOWEL SIGN UNAP\nABE9..ABEA ; Other_Alphabetic # Mc [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG\nFB1E ; Other_Alphabetic # Mn HEBREW POINT JUDEO-SPANISH VARIKA\n10376..1037A ; Other_Alphabetic # Mn [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII\n10A01..10A03 ; Other_Alphabetic # Mn [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R\n10A05..10A06 ; Other_Alphabetic # Mn [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O\n10A0C..10A0F ; Other_Alphabetic # Mn [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA\n10D24..10D27 ; Other_Alphabetic # Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI\n10D69 ; Other_Alphabetic # Mn GARAY VOWEL SIGN E\n10EAB..10EAC ; Other_Alphabetic # Mn [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK\n10EFA..10EFC ; Other_Alphabetic # Mn [3] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC COMBINING ALEF OVERLAY\n11000 ; Other_Alphabetic # Mc BRAHMI SIGN CANDRABINDU\n11001 ; Other_Alphabetic # Mn BRAHMI SIGN ANUSVARA\n11002 ; Other_Alphabetic # Mc BRAHMI SIGN VISARGA\n11038..11045 ; Other_Alphabetic # Mn [14] BRAHMI VOWEL SIGN AA..BRAHMI VOWEL SIGN AU\n11073..11074 ; Other_Alphabetic # Mn [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O\n11080..11081 ; Other_Alphabetic # Mn [2] KAITHI SIGN CANDRABINDU..KAITHI SIGN ANUSVARA\n11082 ; Other_Alphabetic # Mc KAITHI SIGN VISARGA\n110B0..110B2 ; Other_Alphabetic # Mc [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II\n110B3..110B6 ; Other_Alphabetic # Mn [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI\n110B7..110B8 ; Other_Alphabetic # Mc [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU\n110C2 ; Other_Alphabetic # Mn KAITHI VOWEL SIGN VOCALIC R\n11100..11102 ; Other_Alphabetic # Mn [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA\n11127..1112B ; Other_Alphabetic # Mn [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU\n1112C ; Other_Alphabetic # Mc CHAKMA VOWEL SIGN E\n1112D..11132 ; Other_Alphabetic # Mn [6] CHAKMA VOWEL SIGN AI..CHAKMA AU MARK\n11145..11146 ; Other_Alphabetic # Mc [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI\n11180..11181 ; Other_Alphabetic # Mn [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA\n11182 ; Other_Alphabetic # Mc SHARADA SIGN VISARGA\n111B3..111B5 ; Other_Alphabetic # Mc [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II\n111B6..111BE ; Other_Alphabetic # Mn [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O\n111BF ; Other_Alphabetic # Mc SHARADA VOWEL SIGN AU\n111CE ; Other_Alphabetic # Mc SHARADA VOWEL SIGN PRISHTHAMATRA E\n111CF ; Other_Alphabetic # Mn SHARADA SIGN INVERTED CANDRABINDU\n1122C..1122E ; Other_Alphabetic # Mc [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II\n1122F..11231 ; Other_Alphabetic # Mn [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI\n11232..11233 ; Other_Alphabetic # Mc [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU\n11234 ; Other_Alphabetic # Mn KHOJKI SIGN ANUSVARA\n11237 ; Other_Alphabetic # Mn KHOJKI SIGN SHADDA\n1123E ; Other_Alphabetic # Mn KHOJKI SIGN SUKUN\n11241 ; Other_Alphabetic # Mn KHOJKI VOWEL SIGN VOCALIC R\n112DF ; Other_Alphabetic # Mn KHUDAWADI SIGN ANUSVARA\n112E0..112E2 ; Other_Alphabetic # Mc [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II\n112E3..112E8 ; Other_Alphabetic # Mn [6] KHUDAWADI VOWEL SIGN U..KHUDAWADI VOWEL SIGN AU\n11300..11301 ; Other_Alphabetic # Mn [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU\n11302..11303 ; Other_Alphabetic # Mc [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA\n1133E..1133F ; Other_Alphabetic # Mc [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I\n11340 ; Other_Alphabetic # Mn GRANTHA VOWEL SIGN II\n11341..11344 ; Other_Alphabetic # Mc [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR\n11347..11348 ; Other_Alphabetic # Mc [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI\n1134B..1134C ; Other_Alphabetic # Mc [2] GRANTHA VOWEL SIGN OO..GRANTHA VOWEL SIGN AU\n11357 ; Other_Alphabetic # Mc GRANTHA AU LENGTH MARK\n11362..11363 ; Other_Alphabetic # Mc [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL\n113B8..113BA ; Other_Alphabetic # Mc [3] TULU-TIGALARI VOWEL SIGN AA..TULU-TIGALARI VOWEL SIGN II\n113BB..113C0 ; Other_Alphabetic # Mn [6] TULU-TIGALARI VOWEL SIGN U..TULU-TIGALARI VOWEL SIGN VOCALIC LL\n113C2 ; Other_Alphabetic # Mc TULU-TIGALARI VOWEL SIGN EE\n113C5 ; Other_Alphabetic # Mc TULU-TIGALARI VOWEL SIGN AI\n113C7..113CA ; Other_Alphabetic # Mc [4] TULU-TIGALARI VOWEL SIGN OO..TULU-TIGALARI SIGN CANDRA ANUNASIKA\n113CC..113CD ; Other_Alphabetic # Mc [2] TULU-TIGALARI SIGN ANUSVARA..TULU-TIGALARI SIGN VISARGA\n11435..11437 ; Other_Alphabetic # Mc [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II\n11438..1143F ; Other_Alphabetic # Mn [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI\n11440..11441 ; Other_Alphabetic # Mc [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU\n11443..11444 ; Other_Alphabetic # Mn [2] NEWA SIGN CANDRABINDU..NEWA SIGN ANUSVARA\n11445 ; Other_Alphabetic # Mc NEWA SIGN VISARGA\n114B0..114B2 ; Other_Alphabetic # Mc [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II\n114B3..114B8 ; Other_Alphabetic # Mn [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL\n114B9 ; Other_Alphabetic # Mc TIRHUTA VOWEL SIGN E\n114BA ; Other_Alphabetic # Mn TIRHUTA VOWEL SIGN SHORT E\n114BB..114BE ; Other_Alphabetic # Mc [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU\n114BF..114C0 ; Other_Alphabetic # Mn [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA\n114C1 ; Other_Alphabetic # Mc TIRHUTA SIGN VISARGA\n115AF..115B1 ; Other_Alphabetic # Mc [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II\n115B2..115B5 ; Other_Alphabetic # Mn [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR\n115B8..115BB ; Other_Alphabetic # Mc [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU\n115BC..115BD ; Other_Alphabetic # Mn [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA\n115BE ; Other_Alphabetic # Mc SIDDHAM SIGN VISARGA\n115DC..115DD ; Other_Alphabetic # Mn [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU\n11630..11632 ; Other_Alphabetic # Mc [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II\n11633..1163A ; Other_Alphabetic # Mn [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI\n1163B..1163C ; Other_Alphabetic # Mc [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU\n1163D ; Other_Alphabetic # Mn MODI SIGN ANUSVARA\n1163E ; Other_Alphabetic # Mc MODI SIGN VISARGA\n11640 ; Other_Alphabetic # Mn MODI SIGN ARDHACANDRA\n116AB ; Other_Alphabetic # Mn TAKRI SIGN ANUSVARA\n116AC ; Other_Alphabetic # Mc TAKRI SIGN VISARGA\n116AD ; Other_Alphabetic # Mn TAKRI VOWEL SIGN AA\n116AE..116AF ; Other_Alphabetic # Mc [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II\n116B0..116B5 ; Other_Alphabetic # Mn [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU\n1171D ; Other_Alphabetic # Mn AHOM CONSONANT SIGN MEDIAL LA\n1171E ; Other_Alphabetic # Mc AHOM CONSONANT SIGN MEDIAL RA\n1171F ; Other_Alphabetic # Mn AHOM CONSONANT SIGN MEDIAL LIGATING RA\n11720..11721 ; Other_Alphabetic # Mc [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA\n11722..11725 ; Other_Alphabetic # Mn [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU\n11726 ; Other_Alphabetic # Mc AHOM VOWEL SIGN E\n11727..1172A ; Other_Alphabetic # Mn [4] AHOM VOWEL SIGN AW..AHOM VOWEL SIGN AM\n1182C..1182E ; Other_Alphabetic # Mc [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II\n1182F..11837 ; Other_Alphabetic # Mn [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA\n11838 ; Other_Alphabetic # Mc DOGRA SIGN VISARGA\n11930..11935 ; Other_Alphabetic # Mc [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E\n11937..11938 ; Other_Alphabetic # Mc [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O\n1193B..1193C ; Other_Alphabetic # Mn [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU\n11940 ; Other_Alphabetic # Mc DIVES AKURU MEDIAL YA\n11942 ; Other_Alphabetic # Mc DIVES AKURU MEDIAL RA\n119D1..119D3 ; Other_Alphabetic # Mc [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II\n119D4..119D7 ; Other_Alphabetic # Mn [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR\n119DA..119DB ; Other_Alphabetic # Mn [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI\n119DC..119DF ; Other_Alphabetic # Mc [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA\n119E4 ; Other_Alphabetic # Mc NANDINAGARI VOWEL SIGN PRISHTHAMATRA E\n11A01..11A0A ; Other_Alphabetic # Mn [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK\n11A35..11A38 ; Other_Alphabetic # Mn [4] ZANABAZAR SQUARE SIGN CANDRABINDU..ZANABAZAR SQUARE SIGN ANUSVARA\n11A39 ; Other_Alphabetic # Mc ZANABAZAR SQUARE SIGN VISARGA\n11A3B..11A3E ; Other_Alphabetic # Mn [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA\n11A51..11A56 ; Other_Alphabetic # Mn [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE\n11A57..11A58 ; Other_Alphabetic # Mc [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU\n11A59..11A5B ; Other_Alphabetic # Mn [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK\n11A8A..11A96 ; Other_Alphabetic # Mn [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA\n11A97 ; Other_Alphabetic # Mc SOYOMBO SIGN VISARGA\n11B60 ; Other_Alphabetic # Mn SHARADA VOWEL SIGN OE\n11B61 ; Other_Alphabetic # Mc SHARADA VOWEL SIGN OOE\n11B62..11B64 ; Other_Alphabetic # Mn [3] SHARADA VOWEL SIGN UE..SHARADA VOWEL SIGN SHORT E\n11B65 ; Other_Alphabetic # Mc SHARADA VOWEL SIGN SHORT O\n11B66 ; Other_Alphabetic # Mn SHARADA VOWEL SIGN CANDRA E\n11B67 ; Other_Alphabetic # Mc SHARADA VOWEL SIGN CANDRA O\n11C2F ; Other_Alphabetic # Mc BHAIKSUKI VOWEL SIGN AA\n11C30..11C36 ; Other_Alphabetic # Mn [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L\n11C38..11C3D ; Other_Alphabetic # Mn [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA\n11C3E ; Other_Alphabetic # Mc BHAIKSUKI SIGN VISARGA\n11C92..11CA7 ; Other_Alphabetic # Mn [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA\n11CA9 ; Other_Alphabetic # Mc MARCHEN SUBJOINED LETTER YA\n11CAA..11CB0 ; Other_Alphabetic # Mn [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA\n11CB1 ; Other_Alphabetic # Mc MARCHEN VOWEL SIGN I\n11CB2..11CB3 ; Other_Alphabetic # Mn [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E\n11CB4 ; Other_Alphabetic # Mc MARCHEN VOWEL SIGN O\n11CB5..11CB6 ; Other_Alphabetic # Mn [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU\n11D31..11D36 ; Other_Alphabetic # Mn [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R\n11D3A ; Other_Alphabetic # Mn MASARAM GONDI VOWEL SIGN E\n11D3C..11D3D ; Other_Alphabetic # Mn [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O\n11D3F..11D41 ; Other_Alphabetic # Mn [3] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI SIGN VISARGA\n11D43 ; Other_Alphabetic # Mn MASARAM GONDI SIGN CANDRA\n11D47 ; Other_Alphabetic # Mn MASARAM GONDI RA-KARA\n11D8A..11D8E ; Other_Alphabetic # Mc [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU\n11D90..11D91 ; Other_Alphabetic # Mn [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI\n11D93..11D94 ; Other_Alphabetic # Mc [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU\n11D95 ; Other_Alphabetic # Mn GUNJALA GONDI SIGN ANUSVARA\n11D96 ; Other_Alphabetic # Mc GUNJALA GONDI SIGN VISARGA\n11EF3..11EF4 ; Other_Alphabetic # Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U\n11EF5..11EF6 ; Other_Alphabetic # Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O\n11F00..11F01 ; Other_Alphabetic # Mn [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA\n11F03 ; Other_Alphabetic # Mc KAWI SIGN VISARGA\n11F34..11F35 ; Other_Alphabetic # Mc [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA\n11F36..11F3A ; Other_Alphabetic # Mn [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R\n11F3E..11F3F ; Other_Alphabetic # Mc [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI\n11F40 ; Other_Alphabetic # Mn KAWI VOWEL SIGN EU\n1611E..16129 ; Other_Alphabetic # Mn [12] GURUNG KHEMA VOWEL SIGN AA..GURUNG KHEMA VOWEL LENGTH MARK\n1612A..1612C ; Other_Alphabetic # Mc [3] GURUNG KHEMA CONSONANT SIGN MEDIAL YA..GURUNG KHEMA CONSONANT SIGN MEDIAL HA\n1612D..1612E ; Other_Alphabetic # Mn [2] GURUNG KHEMA SIGN ANUSVARA..GURUNG KHEMA CONSONANT SIGN MEDIAL RA\n16F4F ; Other_Alphabetic # Mn MIAO SIGN CONSONANT MODIFIER BAR\n16F51..16F87 ; Other_Alphabetic # Mc [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI\n16F8F..16F92 ; Other_Alphabetic # Mn [4] MIAO TONE RIGHT..MIAO TONE BELOW\n16FF0..16FF1 ; Other_Alphabetic # Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY\n1BC9E ; Other_Alphabetic # Mn DUPLOYAN DOUBLE MARK\n1E000..1E006 ; Other_Alphabetic # Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE\n1E008..1E018 ; Other_Alphabetic # Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU\n1E01B..1E021 ; Other_Alphabetic # Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI\n1E023..1E024 ; Other_Alphabetic # Mn [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS\n1E026..1E02A ; Other_Alphabetic # Mn [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA\n1E08F ; Other_Alphabetic # Mn COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I\n1E6E3 ; Other_Alphabetic # Mn TAI YO SIGN UE\n1E6E6 ; Other_Alphabetic # Mn TAI YO SIGN AU\n1E6EE..1E6EF ; Other_Alphabetic # Mn [2] TAI YO SIGN AY..TAI YO SIGN ANG\n1E6F5 ; Other_Alphabetic # Mn TAI YO SIGN OM\n1E947 ; Other_Alphabetic # Mn ADLAM HAMZA\n1F130..1F149 ; Other_Alphabetic # So [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z\n1F150..1F169 ; Other_Alphabetic # So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z\n1F170..1F189 ; Other_Alphabetic # So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z\n\n# Total code points: 1510\n\n# ================================================\n\n3006 ; Ideographic # Lo IDEOGRAPHIC CLOSING MARK\n3007 ; Ideographic # Nl IDEOGRAPHIC NUMBER ZERO\n3021..3029 ; Ideographic # Nl [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE\n3038..303A ; Ideographic # Nl [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY\n3400..4DBF ; Ideographic # Lo [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF\n4E00..9FFF ; Ideographic # Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF\nF900..FA6D ; Ideographic # Lo [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D\nFA70..FAD9 ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9\n16FE4 ; Ideographic # Mn KHITAN SMALL SCRIPT FILLER\n16FF2..16FF3 ; Ideographic # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER\n16FF4..16FF6 ; Ideographic # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS\n17000..18CD5 ; Ideographic # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5\n18CFF..18D1E ; Ideographic # Lo [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E\n18D80..18DF2 ; Ideographic # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883\n1B170..1B2FB ; Ideographic # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB\n20000..2A6DF ; Ideographic # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF\n2A700..2B81D ; Ideographic # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D\n2B820..2CEAD ; Ideographic # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD\n2CEB0..2EBE0 ; Ideographic # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0\n2EBF0..2EE5D ; Ideographic # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D\n2F800..2FA1D ; Ideographic # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D\n30000..3134A ; Ideographic # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A\n31350..33479 ; Ideographic # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479\n\n# Total code points: 110943\n\n# ================================================\n\n005E ; Diacritic # Sk CIRCUMFLEX ACCENT\n0060 ; Diacritic # Sk GRAVE ACCENT\n00A8 ; Diacritic # Sk DIAERESIS\n00AF ; Diacritic # Sk MACRON\n00B4 ; Diacritic # Sk ACUTE ACCENT\n00B7 ; Diacritic # Po MIDDLE DOT\n00B8 ; Diacritic # Sk CEDILLA\n02B0..02C1 ; Diacritic # Lm [18] MODIFIER LETTER SMALL H..MODIFIER LETTER REVERSED GLOTTAL STOP\n02C2..02C5 ; Diacritic # Sk [4] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER DOWN ARROWHEAD\n02C6..02D1 ; Diacritic # Lm [12] MODIFIER LETTER CIRCUMFLEX ACCENT..MODIFIER LETTER HALF TRIANGULAR COLON\n02D2..02DF ; Diacritic # Sk [14] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER CROSS ACCENT\n02E0..02E4 ; Diacritic # Lm [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP\n02E5..02EB ; Diacritic # Sk [7] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER YANG DEPARTING TONE MARK\n02EC ; Diacritic # Lm MODIFIER LETTER VOICING\n02ED ; Diacritic # Sk MODIFIER LETTER UNASPIRATED\n02EE ; Diacritic # Lm MODIFIER LETTER DOUBLE APOSTROPHE\n02EF..02FF ; Diacritic # Sk [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW\n0300..034E ; Diacritic # Mn [79] COMBINING GRAVE ACCENT..COMBINING UPWARDS ARROW BELOW\n0350..0357 ; Diacritic # Mn [8] COMBINING RIGHT ARROWHEAD ABOVE..COMBINING RIGHT HALF RING ABOVE\n035D..0362 ; Diacritic # Mn [6] COMBINING DOUBLE BREVE..COMBINING DOUBLE RIGHTWARDS ARROW BELOW\n0374 ; Diacritic # Lm GREEK NUMERAL SIGN\n0375 ; Diacritic # Sk GREEK LOWER NUMERAL SIGN\n037A ; Diacritic # Lm GREEK YPOGEGRAMMENI\n0384..0385 ; Diacritic # Sk [2] GREEK TONOS..GREEK DIALYTIKA TONOS\n0483..0487 ; Diacritic # Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE\n0559 ; Diacritic # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING\n0591..05BD ; Diacritic # Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG\n05BF ; Diacritic # Mn HEBREW POINT RAFE\n05C1..05C2 ; Diacritic # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT\n05C4..05C5 ; Diacritic # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT\n05C7 ; Diacritic # Mn HEBREW POINT QAMATS QATAN\n064B..0652 ; Diacritic # Mn [8] ARABIC FATHATAN..ARABIC SUKUN\n0657..0658 ; Diacritic # Mn [2] ARABIC INVERTED DAMMA..ARABIC MARK NOON GHUNNA\n06DF..06E0 ; Diacritic # Mn [2] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH UPRIGHT RECTANGULAR ZERO\n06E5..06E6 ; Diacritic # Lm [2] ARABIC SMALL WAW..ARABIC SMALL YEH\n06EA..06EC ; Diacritic # Mn [3] ARABIC EMPTY CENTRE LOW STOP..ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE\n0730..074A ; Diacritic # Mn [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH\n07A6..07B0 ; Diacritic # Mn [11] THAANA ABAFILI..THAANA SUKUN\n07EB..07F3 ; Diacritic # Mn [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE\n07F4..07F5 ; Diacritic # Lm [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE\n0818..0819 ; Diacritic # Mn [2] SAMARITAN MARK OCCLUSION..SAMARITAN MARK DAGESH\n0898..089F ; Diacritic # Mn [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA\n08C9 ; Diacritic # Lm ARABIC SMALL FARSI YEH\n08CA..08D2 ; Diacritic # Mn [9] ARABIC SMALL HIGH FARSI YEH..ARABIC LARGE ROUND DOT INSIDE CIRCLE BELOW\n08E3..08FE ; Diacritic # Mn [28] ARABIC TURNED DAMMA BELOW..ARABIC DAMMA WITH DOT\n093C ; Diacritic # Mn DEVANAGARI SIGN NUKTA\n094D ; Diacritic # Mn DEVANAGARI SIGN VIRAMA\n0951..0954 ; Diacritic # Mn [4] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI ACUTE ACCENT\n0971 ; Diacritic # Lm DEVANAGARI SIGN HIGH SPACING DOT\n09BC ; Diacritic # Mn BENGALI SIGN NUKTA\n09CD ; Diacritic # Mn BENGALI SIGN VIRAMA\n0A3C ; Diacritic # Mn GURMUKHI SIGN NUKTA\n0A4D ; Diacritic # Mn GURMUKHI SIGN VIRAMA\n0ABC ; Diacritic # Mn GUJARATI SIGN NUKTA\n0ACD ; Diacritic # Mn GUJARATI SIGN VIRAMA\n0AFD..0AFF ; Diacritic # Mn [3] GUJARATI SIGN THREE-DOT NUKTA ABOVE..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE\n0B3C ; Diacritic # Mn ORIYA SIGN NUKTA\n0B4D ; Diacritic # Mn ORIYA SIGN VIRAMA\n0B55 ; Diacritic # Mn ORIYA SIGN OVERLINE\n0BCD ; Diacritic # Mn TAMIL SIGN VIRAMA\n0C3C ; Diacritic # Mn TELUGU SIGN NUKTA\n0C4D ; Diacritic # Mn TELUGU SIGN VIRAMA\n0CBC ; Diacritic # Mn KANNADA SIGN NUKTA\n0CCD ; Diacritic # Mn KANNADA SIGN VIRAMA\n0D3B..0D3C ; Diacritic # Mn [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA\n0D4D ; Diacritic # Mn MALAYALAM SIGN VIRAMA\n0DCA ; Diacritic # Mn SINHALA SIGN AL-LAKUNA\n0E3A ; Diacritic # Mn THAI CHARACTER PHINTHU\n0E47..0E4C ; Diacritic # Mn [6] THAI CHARACTER MAITAIKHU..THAI CHARACTER THANTHAKHAT\n0E4E ; Diacritic # Mn THAI CHARACTER YAMAKKAN\n0EBA ; Diacritic # Mn LAO SIGN PALI VIRAMA\n0EC8..0ECC ; Diacritic # Mn [5] LAO TONE MAI EK..LAO CANCELLATION MARK\n0F18..0F19 ; Diacritic # Mn [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS\n0F35 ; Diacritic # Mn TIBETAN MARK NGAS BZUNG NYI ZLA\n0F37 ; Diacritic # Mn TIBETAN MARK NGAS BZUNG SGOR RTAGS\n0F39 ; Diacritic # Mn TIBETAN MARK TSA -PHRU\n0F3E..0F3F ; Diacritic # Mc [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES\n0F82..0F84 ; Diacritic # Mn [3] TIBETAN SIGN NYI ZLA NAA DA..TIBETAN MARK HALANTA\n0F86..0F87 ; Diacritic # Mn [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS\n0FC6 ; Diacritic # Mn TIBETAN SYMBOL PADMA GDAN\n1037 ; Diacritic # Mn MYANMAR SIGN DOT BELOW\n1039..103A ; Diacritic # Mn [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT\n1063..1064 ; Diacritic # Mc [2] MYANMAR TONE MARK SGAW KAREN HATHI..MYANMAR TONE MARK SGAW KAREN KE PHO\n1069..106D ; Diacritic # Mc [5] MYANMAR SIGN WESTERN PWO KAREN TONE-1..MYANMAR SIGN WESTERN PWO KAREN TONE-5\n1087..108C ; Diacritic # Mc [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3\n108D ; Diacritic # Mn MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE\n108F ; Diacritic # Mc MYANMAR SIGN RUMAI PALAUNG TONE-5\n109A..109B ; Diacritic # Mc [2] MYANMAR SIGN KHAMTI TONE-1..MYANMAR SIGN KHAMTI TONE-3\n135D..135F ; Diacritic # Mn [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK\n1714 ; Diacritic # Mn TAGALOG SIGN VIRAMA\n1715 ; Diacritic # Mc TAGALOG SIGN PAMUDPOD\n1734 ; Diacritic # Mc HANUNOO SIGN PAMUDPOD\n17C9..17D3 ; Diacritic # Mn [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT\n17DD ; Diacritic # Mn KHMER SIGN ATTHACAN\n1939..193B ; Diacritic # Mn [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I\n1A60 ; Diacritic # Mn TAI THAM SIGN SAKOT\n1A75..1A7C ; Diacritic # Mn [8] TAI THAM SIGN TONE-1..TAI THAM SIGN KHUEN-LUE KARAN\n1A7F ; Diacritic # Mn TAI THAM COMBINING CRYPTOGRAMMIC DOT\n1AB0..1ABD ; Diacritic # Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW\n1ABE ; Diacritic # Me COMBINING PARENTHESES OVERLAY\n1AC1..1ACB ; Diacritic # Mn [11] COMBINING LEFT PARENTHESIS ABOVE LEFT..COMBINING TRIPLE ACUTE ACCENT\n1ACF..1ADD ; Diacritic # Mn [15] COMBINING DOUBLE CARON..COMBINING DOT-AND-RING BELOW\n1AE0..1AEB ; Diacritic # Mn [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE\n1B34 ; Diacritic # Mn BALINESE SIGN REREKAN\n1B44 ; Diacritic # Mc BALINESE ADEG ADEG\n1B6B..1B73 ; Diacritic # Mn [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG\n1BAA ; Diacritic # Mc SUNDANESE SIGN PAMAAEH\n1BAB ; Diacritic # Mn SUNDANESE SIGN VIRAMA\n1BE6 ; Diacritic # Mn BATAK SIGN TOMPI\n1BF2..1BF3 ; Diacritic # Mc [2] BATAK PANGOLAT..BATAK PANONGONAN\n1C36..1C37 ; Diacritic # Mn [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA\n1C78..1C7D ; Diacritic # Lm [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD\n1CD0..1CD2 ; Diacritic # Mn [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA\n1CD3 ; Diacritic # Po VEDIC SIGN NIHSHVASA\n1CD4..1CE0 ; Diacritic # Mn [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA\n1CE1 ; Diacritic # Mc VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA\n1CE2..1CE8 ; Diacritic # Mn [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL\n1CED ; Diacritic # Mn VEDIC SIGN TIRYAK\n1CF4 ; Diacritic # Mn VEDIC TONE CANDRA ABOVE\n1CF7 ; Diacritic # Mc VEDIC SIGN ATIKRAMA\n1CF8..1CF9 ; Diacritic # Mn [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE\n1D2C..1D6A ; Diacritic # Lm [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI\n1D9B..1DBE ; Diacritic # Lm [36] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL EZH\n1DC4..1DCF ; Diacritic # Mn [12] COMBINING MACRON-ACUTE..COMBINING ZIGZAG BELOW\n1DF5..1DFF ; Diacritic # Mn [11] COMBINING UP TACK ABOVE..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW\n1FBD ; Diacritic # Sk GREEK KORONIS\n1FBF..1FC1 ; Diacritic # Sk [3] GREEK PSILI..GREEK DIALYTIKA AND PERISPOMENI\n1FCD..1FCF ; Diacritic # Sk [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI\n1FDD..1FDF ; Diacritic # Sk [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI\n1FED..1FEF ; Diacritic # Sk [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA\n1FFD..1FFE ; Diacritic # Sk [2] GREEK OXIA..GREEK DASIA\n2CEF..2CF1 ; Diacritic # Mn [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS\n2E2F ; Diacritic # Lm VERTICAL TILDE\n302A..302D ; Diacritic # Mn [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK\n302E..302F ; Diacritic # Mc [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK\n3099..309A ; Diacritic # Mn [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK\n309B..309C ; Diacritic # Sk [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK\n30FC ; Diacritic # Lm KATAKANA-HIRAGANA PROLONGED SOUND MARK\nA66F ; Diacritic # Mn COMBINING CYRILLIC VZMET\nA67C..A67D ; Diacritic # Mn [2] COMBINING CYRILLIC KAVYKA..COMBINING CYRILLIC PAYEROK\nA67F ; Diacritic # Lm CYRILLIC PAYEROK\nA69C..A69D ; Diacritic # Lm [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN\nA6F0..A6F1 ; Diacritic # Mn [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS\nA700..A716 ; Diacritic # Sk [23] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR\nA717..A71F ; Diacritic # Lm [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK\nA720..A721 ; Diacritic # Sk [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE\nA788 ; Diacritic # Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT\nA789..A78A ; Diacritic # Sk [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN\nA7F1 ; Diacritic # Lm MODIFIER LETTER CAPITAL S\nA7F8..A7F9 ; Diacritic # Lm [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE\nA806 ; Diacritic # Mn SYLOTI NAGRI SIGN HASANTA\nA82C ; Diacritic # Mn SYLOTI NAGRI SIGN ALTERNATE HASANTA\nA8C4 ; Diacritic # Mn SAURASHTRA SIGN VIRAMA\nA8E0..A8F1 ; Diacritic # Mn [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA\nA92B..A92D ; Diacritic # Mn [3] KAYAH LI TONE PLOPHU..KAYAH LI TONE CALYA PLOPHU\nA92E ; Diacritic # Po KAYAH LI SIGN CWI\nA953 ; Diacritic # Mc REJANG VIRAMA\nA9B3 ; Diacritic # Mn JAVANESE SIGN CECAK TELU\nA9C0 ; Diacritic # Mc JAVANESE PANGKON\nA9E5 ; Diacritic # Mn MYANMAR SIGN SHAN SAW\nAA7B ; Diacritic # Mc MYANMAR SIGN PAO KAREN TONE\nAA7C ; Diacritic # Mn MYANMAR SIGN TAI LAING TONE-2\nAA7D ; Diacritic # Mc MYANMAR SIGN TAI LAING TONE-5\nAABF ; Diacritic # Mn TAI VIET TONE MAI EK\nAAC0 ; Diacritic # Lo TAI VIET TONE MAI NUENG\nAAC1 ; Diacritic # Mn TAI VIET TONE MAI THO\nAAC2 ; Diacritic # Lo TAI VIET TONE MAI SONG\nAAF6 ; Diacritic # Mn MEETEI MAYEK VIRAMA\nAB5B ; Diacritic # Sk MODIFIER BREVE WITH INVERTED BREVE\nAB5C..AB5F ; Diacritic # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK\nAB69 ; Diacritic # Lm MODIFIER LETTER SMALL TURNED W\nAB6A..AB6B ; Diacritic # Sk [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK\nABEC ; Diacritic # Mc MEETEI MAYEK LUM IYEK\nABED ; Diacritic # Mn MEETEI MAYEK APUN IYEK\nFB1E ; Diacritic # Mn HEBREW POINT JUDEO-SPANISH VARIKA\nFE20..FE2F ; Diacritic # Mn [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF\nFF3E ; Diacritic # Sk FULLWIDTH CIRCUMFLEX ACCENT\nFF40 ; Diacritic # Sk FULLWIDTH GRAVE ACCENT\nFF70 ; Diacritic # Lm HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK\nFF9E..FF9F ; Diacritic # Lm [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK\nFFE3 ; Diacritic # Sk FULLWIDTH MACRON\n102E0 ; Diacritic # Mn COPTIC EPACT THOUSANDS MARK\n10780..10785 ; Diacritic # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK\n10787..107B0 ; Diacritic # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK\n107B2..107BA ; Diacritic # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL\n10A38..10A3A ; Diacritic # Mn [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW\n10A3F ; Diacritic # Mn KHAROSHTHI VIRAMA\n10AE5..10AE6 ; Diacritic # Mn [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW\n10D22..10D23 ; Diacritic # Lo [2] HANIFI ROHINGYA MARK SAKIN..HANIFI ROHINGYA MARK NA KHONNA\n10D24..10D27 ; Diacritic # Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI\n10D4E ; Diacritic # Lm GARAY VOWEL LENGTH MARK\n10D69..10D6D ; Diacritic # Mn [5] GARAY VOWEL SIGN E..GARAY CONSONANT NASALIZATION MARK\n10EFA ; Diacritic # Mn ARABIC DOUBLE VERTICAL BAR BELOW\n10EFD..10EFF ; Diacritic # Mn [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA\n10F46..10F50 ; Diacritic # Mn [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW\n10F82..10F85 ; Diacritic # Mn [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW\n11046 ; Diacritic # Mn BRAHMI VIRAMA\n11070 ; Diacritic # Mn BRAHMI SIGN OLD TAMIL VIRAMA\n110B9..110BA ; Diacritic # Mn [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA\n11133..11134 ; Diacritic # Mn [2] CHAKMA VIRAMA..CHAKMA MAAYYAA\n11173 ; Diacritic # Mn MAHAJANI SIGN NUKTA\n111C0 ; Diacritic # Mc SHARADA SIGN VIRAMA\n111CA..111CC ; Diacritic # Mn [3] SHARADA SIGN NUKTA..SHARADA EXTRA SHORT VOWEL MARK\n11235 ; Diacritic # Mc KHOJKI SIGN VIRAMA\n11236 ; Diacritic # Mn KHOJKI SIGN NUKTA\n112E9..112EA ; Diacritic # Mn [2] KHUDAWADI SIGN NUKTA..KHUDAWADI SIGN VIRAMA\n1133B..1133C ; Diacritic # Mn [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA\n1134D ; Diacritic # Mc GRANTHA SIGN VIRAMA\n11366..1136C ; Diacritic # Mn [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX\n11370..11374 ; Diacritic # Mn [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA\n113CE ; Diacritic # Mn TULU-TIGALARI SIGN VIRAMA\n113CF ; Diacritic # Mc TULU-TIGALARI SIGN LOOPED VIRAMA\n113D0 ; Diacritic # Mn TULU-TIGALARI CONJOINER\n113D2 ; Diacritic # Mn TULU-TIGALARI GEMINATION MARK\n113D3 ; Diacritic # Lo TULU-TIGALARI SIGN PLUTA\n113E1..113E2 ; Diacritic # Mn [2] TULU-TIGALARI VEDIC TONE SVARITA..TULU-TIGALARI VEDIC TONE ANUDATTA\n11442 ; Diacritic # Mn NEWA SIGN VIRAMA\n11446 ; Diacritic # Mn NEWA SIGN NUKTA\n114C2..114C3 ; Diacritic # Mn [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA\n115BF..115C0 ; Diacritic # Mn [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA\n1163F ; Diacritic # Mn MODI SIGN VIRAMA\n116B6 ; Diacritic # Mc TAKRI SIGN VIRAMA\n116B7 ; Diacritic # Mn TAKRI SIGN NUKTA\n1172B ; Diacritic # Mn AHOM SIGN KILLER\n11839..1183A ; Diacritic # Mn [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA\n1193D ; Diacritic # Mc DIVES AKURU SIGN HALANTA\n1193E ; Diacritic # Mn DIVES AKURU VIRAMA\n11943 ; Diacritic # Mn DIVES AKURU SIGN NUKTA\n119E0 ; Diacritic # Mn NANDINAGARI SIGN VIRAMA\n11A34 ; Diacritic # Mn ZANABAZAR SQUARE SIGN VIRAMA\n11A47 ; Diacritic # Mn ZANABAZAR SQUARE SUBJOINER\n11A99 ; Diacritic # Mn SOYOMBO SUBJOINER\n11C3F ; Diacritic # Mn BHAIKSUKI SIGN VIRAMA\n11D42 ; Diacritic # Mn MASARAM GONDI SIGN NUKTA\n11D44..11D45 ; Diacritic # Mn [2] MASARAM GONDI SIGN HALANTA..MASARAM GONDI VIRAMA\n11D97 ; Diacritic # Mn GUNJALA GONDI VIRAMA\n11DD9 ; Diacritic # Lm TOLONG SIKI SIGN SELA\n11F41 ; Diacritic # Mc KAWI SIGN KILLER\n11F42 ; Diacritic # Mn KAWI CONJOINER\n11F5A ; Diacritic # Mn KAWI SIGN NUKTA\n13447..13455 ; Diacritic # Mn [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED\n1612F ; Diacritic # Mn GURUNG KHEMA SIGN THOLHOMA\n16AF0..16AF4 ; Diacritic # Mn [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE\n16B30..16B36 ; Diacritic # Mn [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM\n16D6B..16D6C ; Diacritic # Lm [2] KIRAT RAI SIGN VIRAMA..KIRAT RAI SIGN SAAT\n16F8F..16F92 ; Diacritic # Mn [4] MIAO TONE RIGHT..MIAO TONE BELOW\n16F93..16F9F ; Diacritic # Lm [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8\n16FF0..16FF1 ; Diacritic # Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY\n1AFF0..1AFF3 ; Diacritic # Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5\n1AFF5..1AFFB ; Diacritic # Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5\n1AFFD..1AFFE ; Diacritic # Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8\n1CF00..1CF2D ; Diacritic # Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT\n1CF30..1CF46 ; Diacritic # Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG\n1D167..1D169 ; Diacritic # Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3\n1D16D..1D172 ; Diacritic # Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5\n1D17B..1D182 ; Diacritic # Mn [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE\n1D185..1D18B ; Diacritic # Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE\n1D1AA..1D1AD ; Diacritic # Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO\n1E030..1E06D ; Diacritic # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE\n1E130..1E136 ; Diacritic # Mn [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D\n1E2AE ; Diacritic # Mn TOTO SIGN RISING TONE\n1E2EC..1E2EF ; Diacritic # Mn [4] WANCHO TONE TUP..WANCHO TONE KOINI\n1E5EE..1E5EF ; Diacritic # Mn [2] OL ONAL SIGN MU..OL ONAL SIGN IKIR\n1E8D0..1E8D6 ; Diacritic # Mn [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS\n1E944..1E946 ; Diacritic # Mn [3] ADLAM ALIF LENGTHENER..ADLAM GEMINATION MARK\n1E948..1E94A ; Diacritic # Mn [3] ADLAM CONSONANT MODIFIER..ADLAM NUKTA\n\n# Total code points: 1247\n\n# ================================================\n\n00B7 ; Extender # Po MIDDLE DOT\n02D0..02D1 ; Extender # Lm [2] MODIFIER LETTER TRIANGULAR COLON..MODIFIER LETTER HALF TRIANGULAR COLON\n0640 ; Extender # Lm ARABIC TATWEEL\n07FA ; Extender # Lm NKO LAJANYALAN\n0A71 ; Extender # Mn GURMUKHI ADDAK\n0AFB ; Extender # Mn GUJARATI SIGN SHADDA\n0B55 ; Extender # Mn ORIYA SIGN OVERLINE\n0E46 ; Extender # Lm THAI CHARACTER MAIYAMOK\n0EC6 ; Extender # Lm LAO KO LA\n180A ; Extender # Po MONGOLIAN NIRUGU\n1843 ; Extender # Lm MONGOLIAN LETTER TODO LONG VOWEL SIGN\n1AA7 ; Extender # Lm TAI THAM SIGN MAI YAMOK\n1C36 ; Extender # Mn LEPCHA SIGN RAN\n1C7B ; Extender # Lm OL CHIKI RELAA\n3005 ; Extender # Lm IDEOGRAPHIC ITERATION MARK\n3031..3035 ; Extender # Lm [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF\n309D..309E ; Extender # Lm [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK\n30FC..30FE ; Extender # Lm [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK\nA015 ; Extender # Lm YI SYLLABLE WU\nA60C ; Extender # Lm VAI SYLLABLE LENGTHENER\nA9CF ; Extender # Lm JAVANESE PANGRANGKEP\nA9E6 ; Extender # Lm MYANMAR MODIFIER LETTER SHAN REDUPLICATION\nAA70 ; Extender # Lm MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION\nAADD ; Extender # Lm TAI VIET SYMBOL SAM\nAAF3..AAF4 ; Extender # Lm [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK\nFF70 ; Extender # Lm HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK\n10781..10782 ; Extender # Lm [2] MODIFIER LETTER SUPERSCRIPT TRIANGULAR COLON..MODIFIER LETTER SUPERSCRIPT HALF TRIANGULAR COLON\n10D4E ; Extender # Lm GARAY VOWEL LENGTH MARK\n10D6A ; Extender # Mn GARAY CONSONANT GEMINATION MARK\n10D6F ; Extender # Lm GARAY REDUPLICATION MARK\n11237 ; Extender # Mn KHOJKI SIGN SHADDA\n1135D ; Extender # Lo GRANTHA SIGN PLUTA\n113D2 ; Extender # Mn TULU-TIGALARI GEMINATION MARK\n113D3 ; Extender # Lo TULU-TIGALARI SIGN PLUTA\n115C6..115C8 ; Extender # Po [3] SIDDHAM REPETITION MARK-1..SIDDHAM REPETITION MARK-3\n11A98 ; Extender # Mn SOYOMBO GEMINATION MARK\n11DD9 ; Extender # Lm TOLONG SIKI SIGN SELA\n16B42..16B43 ; Extender # Lm [2] PAHAWH HMONG SIGN VOS NRUA..PAHAWH HMONG SIGN IB YAM\n16FE0..16FE1 ; Extender # Lm [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK\n16FE3 ; Extender # Lm OLD CHINESE ITERATION MARK\n16FF2..16FF3 ; Extender # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER\n1E13C..1E13D ; Extender # Lm [2] NYIAKENG PUACHUE HMONG SIGN XW XW..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER\n1E5EF ; Extender # Mn OL ONAL SIGN IKIR\n1E944..1E946 ; Extender # Mn [3] ADLAM ALIF LENGTHENER..ADLAM GEMINATION MARK\n\n# Total code points: 62\n\n# ================================================\n\n00AA ; Other_Lowercase # Lo FEMININE ORDINAL INDICATOR\n00BA ; Other_Lowercase # Lo MASCULINE ORDINAL INDICATOR\n02B0..02B8 ; Other_Lowercase # Lm [9] MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y\n02C0..02C1 ; Other_Lowercase # Lm [2] MODIFIER LETTER GLOTTAL STOP..MODIFIER LETTER REVERSED GLOTTAL STOP\n02E0..02E4 ; Other_Lowercase # Lm [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP\n0345 ; Other_Lowercase # Mn COMBINING GREEK YPOGEGRAMMENI\n037A ; Other_Lowercase # Lm GREEK YPOGEGRAMMENI\n10FC ; Other_Lowercase # Lm MODIFIER LETTER GEORGIAN NAR\n1D2C..1D6A ; Other_Lowercase # Lm [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI\n1D78 ; Other_Lowercase # Lm MODIFIER LETTER CYRILLIC EN\n1D9B..1DBF ; Other_Lowercase # Lm [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA\n2071 ; Other_Lowercase # Lm SUPERSCRIPT LATIN SMALL LETTER I\n207F ; Other_Lowercase # Lm SUPERSCRIPT LATIN SMALL LETTER N\n2090..209C ; Other_Lowercase # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T\n2170..217F ; Other_Lowercase # Nl [16] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL ONE THOUSAND\n24D0..24E9 ; Other_Lowercase # So [26] CIRCLED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z\n2C7C..2C7D ; Other_Lowercase # Lm [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V\nA69C..A69D ; Other_Lowercase # Lm [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN\nA770 ; Other_Lowercase # Lm MODIFIER LETTER US\nA7F1..A7F4 ; Other_Lowercase # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q\nA7F8..A7F9 ; Other_Lowercase # Lm [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE\nAB5C..AB5F ; Other_Lowercase # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK\nAB69 ; Other_Lowercase # Lm MODIFIER LETTER SMALL TURNED W\n10780 ; Other_Lowercase # Lm MODIFIER LETTER SMALL CAPITAL AA\n10783..10785 ; Other_Lowercase # Lm [3] MODIFIER LETTER SMALL AE..MODIFIER LETTER SMALL B WITH HOOK\n10787..107B0 ; Other_Lowercase # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK\n107B2..107BA ; Other_Lowercase # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL\n1E030..1E06D ; Other_Lowercase # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE\n\n# Total code points: 312\n\n# ================================================\n\n2160..216F ; Other_Uppercase # Nl [16] ROMAN NUMERAL ONE..ROMAN NUMERAL ONE THOUSAND\n24B6..24CF ; Other_Uppercase # So [26] CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN CAPITAL LETTER Z\n1F130..1F149 ; Other_Uppercase # So [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z\n1F150..1F169 ; Other_Uppercase # So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z\n1F170..1F189 ; Other_Uppercase # So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z\n\n# Total code points: 120\n\n# ================================================\n\nFDD0..FDEF ; Noncharacter_Code_Point # Cn [32] ..\nFFFE..FFFF ; Noncharacter_Code_Point # Cn [2] ..\n1FFFE..1FFFF ; Noncharacter_Code_Point # Cn [2] ..\n2FFFE..2FFFF ; Noncharacter_Code_Point # Cn [2] ..\n3FFFE..3FFFF ; Noncharacter_Code_Point # Cn [2] ..\n4FFFE..4FFFF ; Noncharacter_Code_Point # Cn [2] ..\n5FFFE..5FFFF ; Noncharacter_Code_Point # Cn [2] ..\n6FFFE..6FFFF ; Noncharacter_Code_Point # Cn [2] ..\n7FFFE..7FFFF ; Noncharacter_Code_Point # Cn [2] ..\n8FFFE..8FFFF ; Noncharacter_Code_Point # Cn [2] ..\n9FFFE..9FFFF ; Noncharacter_Code_Point # Cn [2] ..\nAFFFE..AFFFF ; Noncharacter_Code_Point # Cn [2] ..\nBFFFE..BFFFF ; Noncharacter_Code_Point # Cn [2] ..\nCFFFE..CFFFF ; Noncharacter_Code_Point # Cn [2] ..\nDFFFE..DFFFF ; Noncharacter_Code_Point # Cn [2] ..\nEFFFE..EFFFF ; Noncharacter_Code_Point # Cn [2] ..\nFFFFE..FFFFF ; Noncharacter_Code_Point # Cn [2] ..\n10FFFE..10FFFF; Noncharacter_Code_Point # Cn [2] ..\n\n# Total code points: 66\n\n# ================================================\n\n09BE ; Other_Grapheme_Extend # Mc BENGALI VOWEL SIGN AA\n09D7 ; Other_Grapheme_Extend # Mc BENGALI AU LENGTH MARK\n0B3E ; Other_Grapheme_Extend # Mc ORIYA VOWEL SIGN AA\n0B57 ; Other_Grapheme_Extend # Mc ORIYA AU LENGTH MARK\n0BBE ; Other_Grapheme_Extend # Mc TAMIL VOWEL SIGN AA\n0BD7 ; Other_Grapheme_Extend # Mc TAMIL AU LENGTH MARK\n0CC0 ; Other_Grapheme_Extend # Mc KANNADA VOWEL SIGN II\n0CC2 ; Other_Grapheme_Extend # Mc KANNADA VOWEL SIGN UU\n0CC7..0CC8 ; Other_Grapheme_Extend # Mc [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI\n0CCA..0CCB ; Other_Grapheme_Extend # Mc [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO\n0CD5..0CD6 ; Other_Grapheme_Extend # Mc [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK\n0D3E ; Other_Grapheme_Extend # Mc MALAYALAM VOWEL SIGN AA\n0D57 ; Other_Grapheme_Extend # Mc MALAYALAM AU LENGTH MARK\n0DCF ; Other_Grapheme_Extend # Mc SINHALA VOWEL SIGN AELA-PILLA\n0DDF ; Other_Grapheme_Extend # Mc SINHALA VOWEL SIGN GAYANUKITTA\n1715 ; Other_Grapheme_Extend # Mc TAGALOG SIGN PAMUDPOD\n1734 ; Other_Grapheme_Extend # Mc HANUNOO SIGN PAMUDPOD\n1B35 ; Other_Grapheme_Extend # Mc BALINESE VOWEL SIGN TEDUNG\n1B3B ; Other_Grapheme_Extend # Mc BALINESE VOWEL SIGN RA REPA TEDUNG\n1B3D ; Other_Grapheme_Extend # Mc BALINESE VOWEL SIGN LA LENGA TEDUNG\n1B43..1B44 ; Other_Grapheme_Extend # Mc [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG\n1BAA ; Other_Grapheme_Extend # Mc SUNDANESE SIGN PAMAAEH\n1BF2..1BF3 ; Other_Grapheme_Extend # Mc [2] BATAK PANGOLAT..BATAK PANONGONAN\n200C ; Other_Grapheme_Extend # Cf ZERO WIDTH NON-JOINER\n302E..302F ; Other_Grapheme_Extend # Mc [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK\nA953 ; Other_Grapheme_Extend # Mc REJANG VIRAMA\nA9C0 ; Other_Grapheme_Extend # Mc JAVANESE PANGKON\nFF9E..FF9F ; Other_Grapheme_Extend # Lm [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK\n111C0 ; Other_Grapheme_Extend # Mc SHARADA SIGN VIRAMA\n11235 ; Other_Grapheme_Extend # Mc KHOJKI SIGN VIRAMA\n1133E ; Other_Grapheme_Extend # Mc GRANTHA VOWEL SIGN AA\n1134D ; Other_Grapheme_Extend # Mc GRANTHA SIGN VIRAMA\n11357 ; Other_Grapheme_Extend # Mc GRANTHA AU LENGTH MARK\n113B8 ; Other_Grapheme_Extend # Mc TULU-TIGALARI VOWEL SIGN AA\n113C2 ; Other_Grapheme_Extend # Mc TULU-TIGALARI VOWEL SIGN EE\n113C5 ; Other_Grapheme_Extend # Mc TULU-TIGALARI VOWEL SIGN AI\n113C7..113C9 ; Other_Grapheme_Extend # Mc [3] TULU-TIGALARI VOWEL SIGN OO..TULU-TIGALARI AU LENGTH MARK\n113CF ; Other_Grapheme_Extend # Mc TULU-TIGALARI SIGN LOOPED VIRAMA\n114B0 ; Other_Grapheme_Extend # Mc TIRHUTA VOWEL SIGN AA\n114BD ; Other_Grapheme_Extend # Mc TIRHUTA VOWEL SIGN SHORT O\n115AF ; Other_Grapheme_Extend # Mc SIDDHAM VOWEL SIGN AA\n116B6 ; Other_Grapheme_Extend # Mc TAKRI SIGN VIRAMA\n11930 ; Other_Grapheme_Extend # Mc DIVES AKURU VOWEL SIGN AA\n1193D ; Other_Grapheme_Extend # Mc DIVES AKURU SIGN HALANTA\n11F41 ; Other_Grapheme_Extend # Mc KAWI SIGN KILLER\n16FF0..16FF1 ; Other_Grapheme_Extend # Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY\n1D165..1D166 ; Other_Grapheme_Extend # Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM\n1D16D..1D172 ; Other_Grapheme_Extend # Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5\nE0020..E007F ; Other_Grapheme_Extend # Cf [96] TAG SPACE..CANCEL TAG\n\n# Total code points: 160\n\n# ================================================\n\n2FF0..2FF1 ; IDS_Binary_Operator # So [2] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO BELOW\n2FF4..2FFD ; IDS_Binary_Operator # So [10] IDEOGRAPHIC DESCRIPTION CHARACTER FULL SURROUND..IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER RIGHT\n31EF ; IDS_Binary_Operator # So IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION\n\n# Total code points: 13\n\n# ================================================\n\n2FF2..2FF3 ; IDS_Trinary_Operator # So [2] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO MIDDLE AND RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO MIDDLE AND BELOW\n\n# Total code points: 2\n\n# ================================================\n\n2FFE..2FFF ; IDS_Unary_Operator # So [2] IDEOGRAPHIC DESCRIPTION CHARACTER HORIZONTAL REFLECTION..IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION\n\n# Total code points: 2\n\n# ================================================\n\n2E80..2E99 ; Radical # So [26] CJK RADICAL REPEAT..CJK RADICAL RAP\n2E9B..2EF3 ; Radical # So [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE\n2F00..2FD5 ; Radical # So [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE\n\n# Total code points: 329\n\n# ================================================\n\n3400..4DBF ; Unified_Ideograph # Lo [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF\n4E00..9FFF ; Unified_Ideograph # Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF\nFA0E..FA0F ; Unified_Ideograph # Lo [2] CJK COMPATIBILITY IDEOGRAPH-FA0E..CJK COMPATIBILITY IDEOGRAPH-FA0F\nFA11 ; Unified_Ideograph # Lo CJK COMPATIBILITY IDEOGRAPH-FA11\nFA13..FA14 ; Unified_Ideograph # Lo [2] CJK COMPATIBILITY IDEOGRAPH-FA13..CJK COMPATIBILITY IDEOGRAPH-FA14\nFA1F ; Unified_Ideograph # Lo CJK COMPATIBILITY IDEOGRAPH-FA1F\nFA21 ; Unified_Ideograph # Lo CJK COMPATIBILITY IDEOGRAPH-FA21\nFA23..FA24 ; Unified_Ideograph # Lo [2] CJK COMPATIBILITY IDEOGRAPH-FA23..CJK COMPATIBILITY IDEOGRAPH-FA24\nFA27..FA29 ; Unified_Ideograph # Lo [3] CJK COMPATIBILITY IDEOGRAPH-FA27..CJK COMPATIBILITY IDEOGRAPH-FA29\n20000..2A6DF ; Unified_Ideograph # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF\n2A700..2B81D ; Unified_Ideograph # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D\n2B820..2CEAD ; Unified_Ideograph # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD\n2CEB0..2EBE0 ; Unified_Ideograph # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0\n2EBF0..2EE5D ; Unified_Ideograph # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D\n30000..3134A ; Unified_Ideograph # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A\n31350..33479 ; Unified_Ideograph # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479\n\n# Total code points: 101996\n\n# ================================================\n\n034F ; Other_Default_Ignorable_Code_Point # Mn COMBINING GRAPHEME JOINER\n115F..1160 ; Other_Default_Ignorable_Code_Point # Lo [2] HANGUL CHOSEONG FILLER..HANGUL JUNGSEONG FILLER\n17B4..17B5 ; Other_Default_Ignorable_Code_Point # Mn [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA\n2065 ; Other_Default_Ignorable_Code_Point # Cn \n3164 ; Other_Default_Ignorable_Code_Point # Lo HANGUL FILLER\nFFA0 ; Other_Default_Ignorable_Code_Point # Lo HALFWIDTH HANGUL FILLER\nFFF0..FFF8 ; Other_Default_Ignorable_Code_Point # Cn [9] ..\nE0000 ; Other_Default_Ignorable_Code_Point # Cn \nE0002..E001F ; Other_Default_Ignorable_Code_Point # Cn [30] ..\nE0080..E00FF ; Other_Default_Ignorable_Code_Point # Cn [128] ..\nE01F0..E0FFF ; Other_Default_Ignorable_Code_Point # Cn [3600] ..\n\n# Total code points: 3776\n\n# ================================================\n\n0149 ; Deprecated # L& LATIN SMALL LETTER N PRECEDED BY APOSTROPHE\n0673 ; Deprecated # Lo ARABIC LETTER ALEF WITH WAVY HAMZA BELOW\n0F77 ; Deprecated # Mn TIBETAN VOWEL SIGN VOCALIC RR\n0F79 ; Deprecated # Mn TIBETAN VOWEL SIGN VOCALIC LL\n17A3..17A4 ; Deprecated # Lo [2] KHMER INDEPENDENT VOWEL QAQ..KHMER INDEPENDENT VOWEL QAA\n206A..206F ; Deprecated # Cf [6] INHIBIT SYMMETRIC SWAPPING..NOMINAL DIGIT SHAPES\n2329 ; Deprecated # Ps LEFT-POINTING ANGLE BRACKET\n232A ; Deprecated # Pe RIGHT-POINTING ANGLE BRACKET\nE0001 ; Deprecated # Cf LANGUAGE TAG\n\n# Total code points: 15\n\n# ================================================\n\n0069..006A ; Soft_Dotted # L& [2] LATIN SMALL LETTER I..LATIN SMALL LETTER J\n012F ; Soft_Dotted # L& LATIN SMALL LETTER I WITH OGONEK\n0249 ; Soft_Dotted # L& LATIN SMALL LETTER J WITH STROKE\n0268 ; Soft_Dotted # L& LATIN SMALL LETTER I WITH STROKE\n029D ; Soft_Dotted # L& LATIN SMALL LETTER J WITH CROSSED-TAIL\n02B2 ; Soft_Dotted # Lm MODIFIER LETTER SMALL J\n03F3 ; Soft_Dotted # L& GREEK LETTER YOT\n0456 ; Soft_Dotted # L& CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I\n0458 ; Soft_Dotted # L& CYRILLIC SMALL LETTER JE\n1D62 ; Soft_Dotted # Lm LATIN SUBSCRIPT SMALL LETTER I\n1D96 ; Soft_Dotted # L& LATIN SMALL LETTER I WITH RETROFLEX HOOK\n1DA4 ; Soft_Dotted # Lm MODIFIER LETTER SMALL I WITH STROKE\n1DA8 ; Soft_Dotted # Lm MODIFIER LETTER SMALL J WITH CROSSED-TAIL\n1E2D ; Soft_Dotted # L& LATIN SMALL LETTER I WITH TILDE BELOW\n1ECB ; Soft_Dotted # L& LATIN SMALL LETTER I WITH DOT BELOW\n2071 ; Soft_Dotted # Lm SUPERSCRIPT LATIN SMALL LETTER I\n2148..2149 ; Soft_Dotted # L& [2] DOUBLE-STRUCK ITALIC SMALL I..DOUBLE-STRUCK ITALIC SMALL J\n2C7C ; Soft_Dotted # Lm LATIN SUBSCRIPT SMALL LETTER J\n1D422..1D423 ; Soft_Dotted # L& [2] MATHEMATICAL BOLD SMALL I..MATHEMATICAL BOLD SMALL J\n1D456..1D457 ; Soft_Dotted # L& [2] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL ITALIC SMALL J\n1D48A..1D48B ; Soft_Dotted # L& [2] MATHEMATICAL BOLD ITALIC SMALL I..MATHEMATICAL BOLD ITALIC SMALL J\n1D4BE..1D4BF ; Soft_Dotted # L& [2] MATHEMATICAL SCRIPT SMALL I..MATHEMATICAL SCRIPT SMALL J\n1D4F2..1D4F3 ; Soft_Dotted # L& [2] MATHEMATICAL BOLD SCRIPT SMALL I..MATHEMATICAL BOLD SCRIPT SMALL J\n1D526..1D527 ; Soft_Dotted # L& [2] MATHEMATICAL FRAKTUR SMALL I..MATHEMATICAL FRAKTUR SMALL J\n1D55A..1D55B ; Soft_Dotted # L& [2] MATHEMATICAL DOUBLE-STRUCK SMALL I..MATHEMATICAL DOUBLE-STRUCK SMALL J\n1D58E..1D58F ; Soft_Dotted # L& [2] MATHEMATICAL BOLD FRAKTUR SMALL I..MATHEMATICAL BOLD FRAKTUR SMALL J\n1D5C2..1D5C3 ; Soft_Dotted # L& [2] MATHEMATICAL SANS-SERIF SMALL I..MATHEMATICAL SANS-SERIF SMALL J\n1D5F6..1D5F7 ; Soft_Dotted # L& [2] MATHEMATICAL SANS-SERIF BOLD SMALL I..MATHEMATICAL SANS-SERIF BOLD SMALL J\n1D62A..1D62B ; Soft_Dotted # L& [2] MATHEMATICAL SANS-SERIF ITALIC SMALL I..MATHEMATICAL SANS-SERIF ITALIC SMALL J\n1D65E..1D65F ; Soft_Dotted # L& [2] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL I..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL J\n1D692..1D693 ; Soft_Dotted # L& [2] MATHEMATICAL MONOSPACE SMALL I..MATHEMATICAL MONOSPACE SMALL J\n1DF1A ; Soft_Dotted # L& LATIN SMALL LETTER I WITH STROKE AND RETROFLEX HOOK\n1E04C..1E04D ; Soft_Dotted # Lm [2] MODIFIER LETTER CYRILLIC SMALL BYELORUSSIAN-UKRAINIAN I..MODIFIER LETTER CYRILLIC SMALL JE\n1E068 ; Soft_Dotted # Lm CYRILLIC SUBSCRIPT SMALL LETTER BYELORUSSIAN-UKRAINIAN I\n\n# Total code points: 50\n\n# ================================================\n\n0E40..0E44 ; Logical_Order_Exception # Lo [5] THAI CHARACTER SARA E..THAI CHARACTER SARA AI MAIMALAI\n0EC0..0EC4 ; Logical_Order_Exception # Lo [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI\n19B5..19B7 ; Logical_Order_Exception # Lo [3] NEW TAI LUE VOWEL SIGN E..NEW TAI LUE VOWEL SIGN O\n19BA ; Logical_Order_Exception # Lo NEW TAI LUE VOWEL SIGN AY\nAAB5..AAB6 ; Logical_Order_Exception # Lo [2] TAI VIET VOWEL E..TAI VIET VOWEL O\nAAB9 ; Logical_Order_Exception # Lo TAI VIET VOWEL UEA\nAABB..AABC ; Logical_Order_Exception # Lo [2] TAI VIET VOWEL AUE..TAI VIET VOWEL AY\n\n# Total code points: 19\n\n# ================================================\n\n1885..1886 ; Other_ID_Start # Mn [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA\n2118 ; Other_ID_Start # Sm SCRIPT CAPITAL P\n212E ; Other_ID_Start # So ESTIMATED SYMBOL\n309B..309C ; Other_ID_Start # Sk [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK\n\n# Total code points: 6\n\n# ================================================\n\n00B7 ; Other_ID_Continue # Po MIDDLE DOT\n0387 ; Other_ID_Continue # Po GREEK ANO TELEIA\n1369..1371 ; Other_ID_Continue # No [9] ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE\n19DA ; Other_ID_Continue # No NEW TAI LUE THAM DIGIT ONE\n200C..200D ; Other_ID_Continue # Cf [2] ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER\n30FB ; Other_ID_Continue # Po KATAKANA MIDDLE DOT\nFF65 ; Other_ID_Continue # Po HALFWIDTH KATAKANA MIDDLE DOT\n\n# Total code points: 16\n\n# ================================================\n\n00B2..00B3 ; ID_Compat_Math_Continue # No [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE\n00B9 ; ID_Compat_Math_Continue # No SUPERSCRIPT ONE\n2070 ; ID_Compat_Math_Continue # No SUPERSCRIPT ZERO\n2074..2079 ; ID_Compat_Math_Continue # No [6] SUPERSCRIPT FOUR..SUPERSCRIPT NINE\n207A..207C ; ID_Compat_Math_Continue # Sm [3] SUPERSCRIPT PLUS SIGN..SUPERSCRIPT EQUALS SIGN\n207D ; ID_Compat_Math_Continue # Ps SUPERSCRIPT LEFT PARENTHESIS\n207E ; ID_Compat_Math_Continue # Pe SUPERSCRIPT RIGHT PARENTHESIS\n2080..2089 ; ID_Compat_Math_Continue # No [10] SUBSCRIPT ZERO..SUBSCRIPT NINE\n208A..208C ; ID_Compat_Math_Continue # Sm [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN\n208D ; ID_Compat_Math_Continue # Ps SUBSCRIPT LEFT PARENTHESIS\n208E ; ID_Compat_Math_Continue # Pe SUBSCRIPT RIGHT PARENTHESIS\n2202 ; ID_Compat_Math_Continue # Sm PARTIAL DIFFERENTIAL\n2207 ; ID_Compat_Math_Continue # Sm NABLA\n221E ; ID_Compat_Math_Continue # Sm INFINITY\n1D6C1 ; ID_Compat_Math_Continue # Sm MATHEMATICAL BOLD NABLA\n1D6DB ; ID_Compat_Math_Continue # Sm MATHEMATICAL BOLD PARTIAL DIFFERENTIAL\n1D6FB ; ID_Compat_Math_Continue # Sm MATHEMATICAL ITALIC NABLA\n1D715 ; ID_Compat_Math_Continue # Sm MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL\n1D735 ; ID_Compat_Math_Continue # Sm MATHEMATICAL BOLD ITALIC NABLA\n1D74F ; ID_Compat_Math_Continue # Sm MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL\n1D76F ; ID_Compat_Math_Continue # Sm MATHEMATICAL SANS-SERIF BOLD NABLA\n1D789 ; ID_Compat_Math_Continue # Sm MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL\n1D7A9 ; ID_Compat_Math_Continue # Sm MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA\n1D7C3 ; ID_Compat_Math_Continue # Sm MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL\n\n# Total code points: 43\n\n# ================================================\n\n2202 ; ID_Compat_Math_Start # Sm PARTIAL DIFFERENTIAL\n2207 ; ID_Compat_Math_Start # Sm NABLA\n221E ; ID_Compat_Math_Start # Sm INFINITY\n1D6C1 ; ID_Compat_Math_Start # Sm MATHEMATICAL BOLD NABLA\n1D6DB ; ID_Compat_Math_Start # Sm MATHEMATICAL BOLD PARTIAL DIFFERENTIAL\n1D6FB ; ID_Compat_Math_Start # Sm MATHEMATICAL ITALIC NABLA\n1D715 ; ID_Compat_Math_Start # Sm MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL\n1D735 ; ID_Compat_Math_Start # Sm MATHEMATICAL BOLD ITALIC NABLA\n1D74F ; ID_Compat_Math_Start # Sm MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL\n1D76F ; ID_Compat_Math_Start # Sm MATHEMATICAL SANS-SERIF BOLD NABLA\n1D789 ; ID_Compat_Math_Start # Sm MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL\n1D7A9 ; ID_Compat_Math_Start # Sm MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA\n1D7C3 ; ID_Compat_Math_Start # Sm MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL\n\n# Total code points: 13\n\n# ================================================\n\n0021 ; Sentence_Terminal # Po EXCLAMATION MARK\n002E ; Sentence_Terminal # Po FULL STOP\n003F ; Sentence_Terminal # Po QUESTION MARK\n0589 ; Sentence_Terminal # Po ARMENIAN FULL STOP\n061D..061F ; Sentence_Terminal # Po [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK\n06D4 ; Sentence_Terminal # Po ARABIC FULL STOP\n0700..0702 ; Sentence_Terminal # Po [3] SYRIAC END OF PARAGRAPH..SYRIAC SUBLINEAR FULL STOP\n07F9 ; Sentence_Terminal # Po NKO EXCLAMATION MARK\n0837 ; Sentence_Terminal # Po SAMARITAN PUNCTUATION MELODIC QITSA\n0839 ; Sentence_Terminal # Po SAMARITAN PUNCTUATION QITSA\n083D..083E ; Sentence_Terminal # Po [2] SAMARITAN PUNCTUATION SOF MASHFAAT..SAMARITAN PUNCTUATION ANNAAU\n0964..0965 ; Sentence_Terminal # Po [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA\n104A..104B ; Sentence_Terminal # Po [2] MYANMAR SIGN LITTLE SECTION..MYANMAR SIGN SECTION\n1362 ; Sentence_Terminal # Po ETHIOPIC FULL STOP\n1367..1368 ; Sentence_Terminal # Po [2] ETHIOPIC QUESTION MARK..ETHIOPIC PARAGRAPH SEPARATOR\n166E ; Sentence_Terminal # Po CANADIAN SYLLABICS FULL STOP\n1735..1736 ; Sentence_Terminal # Po [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION\n17D4..17D5 ; Sentence_Terminal # Po [2] KHMER SIGN KHAN..KHMER SIGN BARIYOOSAN\n1803 ; Sentence_Terminal # Po MONGOLIAN FULL STOP\n1809 ; Sentence_Terminal # Po MONGOLIAN MANCHU FULL STOP\n1944..1945 ; Sentence_Terminal # Po [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK\n1AA8..1AAB ; Sentence_Terminal # Po [4] TAI THAM SIGN KAAN..TAI THAM SIGN SATKAANKUU\n1B4E..1B4F ; Sentence_Terminal # Po [2] BALINESE INVERTED CARIK SIKI..BALINESE INVERTED CARIK PAREREN\n1B5A..1B5B ; Sentence_Terminal # Po [2] BALINESE PANTI..BALINESE PAMADA\n1B5E..1B5F ; Sentence_Terminal # Po [2] BALINESE CARIK SIKI..BALINESE CARIK PAREREN\n1B7D..1B7F ; Sentence_Terminal # Po [3] BALINESE PANTI LANTANG..BALINESE PANTI BAWAK\n1C3B..1C3C ; Sentence_Terminal # Po [2] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION NYET THYOOM TA-ROL\n1C7E..1C7F ; Sentence_Terminal # Po [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD\n2024 ; Sentence_Terminal # Po ONE DOT LEADER\n203C..203D ; Sentence_Terminal # Po [2] DOUBLE EXCLAMATION MARK..INTERROBANG\n2047..2049 ; Sentence_Terminal # Po [3] DOUBLE QUESTION MARK..EXCLAMATION QUESTION MARK\n2CF9..2CFB ; Sentence_Terminal # Po [3] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN INDIRECT QUESTION MARK\n2E2E ; Sentence_Terminal # Po REVERSED QUESTION MARK\n2E3C ; Sentence_Terminal # Po STENOGRAPHIC FULL STOP\n2E53..2E54 ; Sentence_Terminal # Po [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK\n3002 ; Sentence_Terminal # Po IDEOGRAPHIC FULL STOP\nA4FF ; Sentence_Terminal # Po LISU PUNCTUATION FULL STOP\nA60E..A60F ; Sentence_Terminal # Po [2] VAI FULL STOP..VAI QUESTION MARK\nA6F3 ; Sentence_Terminal # Po BAMUM FULL STOP\nA6F7 ; Sentence_Terminal # Po BAMUM QUESTION MARK\nA876..A877 ; Sentence_Terminal # Po [2] PHAGS-PA MARK SHAD..PHAGS-PA MARK DOUBLE SHAD\nA8CE..A8CF ; Sentence_Terminal # Po [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA\nA92F ; Sentence_Terminal # Po KAYAH LI SIGN SHYA\nA9C8..A9C9 ; Sentence_Terminal # Po [2] JAVANESE PADA LINGSA..JAVANESE PADA LUNGSI\nAA5D..AA5F ; Sentence_Terminal # Po [3] CHAM PUNCTUATION DANDA..CHAM PUNCTUATION TRIPLE DANDA\nAAF0..AAF1 ; Sentence_Terminal # Po [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM\nABEB ; Sentence_Terminal # Po MEETEI MAYEK CHEIKHEI\nFE12 ; Sentence_Terminal # Po PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP\nFE15..FE16 ; Sentence_Terminal # Po [2] PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK..PRESENTATION FORM FOR VERTICAL QUESTION MARK\nFE52 ; Sentence_Terminal # Po SMALL FULL STOP\nFE56..FE57 ; Sentence_Terminal # Po [2] SMALL QUESTION MARK..SMALL EXCLAMATION MARK\nFF01 ; Sentence_Terminal # Po FULLWIDTH EXCLAMATION MARK\nFF0E ; Sentence_Terminal # Po FULLWIDTH FULL STOP\nFF1F ; Sentence_Terminal # Po FULLWIDTH QUESTION MARK\nFF61 ; Sentence_Terminal # Po HALFWIDTH IDEOGRAPHIC FULL STOP\n10A56..10A57 ; Sentence_Terminal # Po [2] KHAROSHTHI PUNCTUATION DANDA..KHAROSHTHI PUNCTUATION DOUBLE DANDA\n10F55..10F59 ; Sentence_Terminal # Po [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT\n10F86..10F89 ; Sentence_Terminal # Po [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS\n11047..11048 ; Sentence_Terminal # Po [2] BRAHMI DANDA..BRAHMI DOUBLE DANDA\n110BE..110C1 ; Sentence_Terminal # Po [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA\n11141..11143 ; Sentence_Terminal # Po [3] CHAKMA DANDA..CHAKMA QUESTION MARK\n111C5..111C6 ; Sentence_Terminal # Po [2] SHARADA DANDA..SHARADA DOUBLE DANDA\n111CD ; Sentence_Terminal # Po SHARADA SUTRA MARK\n111DE..111DF ; Sentence_Terminal # Po [2] SHARADA SECTION MARK-1..SHARADA SECTION MARK-2\n11238..11239 ; Sentence_Terminal # Po [2] KHOJKI DANDA..KHOJKI DOUBLE DANDA\n1123B..1123C ; Sentence_Terminal # Po [2] KHOJKI SECTION MARK..KHOJKI DOUBLE SECTION MARK\n112A9 ; Sentence_Terminal # Po MULTANI SECTION MARK\n113D4..113D5 ; Sentence_Terminal # Po [2] TULU-TIGALARI DANDA..TULU-TIGALARI DOUBLE DANDA\n1144B..1144C ; Sentence_Terminal # Po [2] NEWA DANDA..NEWA DOUBLE DANDA\n115C2..115C3 ; Sentence_Terminal # Po [2] SIDDHAM DANDA..SIDDHAM DOUBLE DANDA\n115C9..115D7 ; Sentence_Terminal # Po [15] SIDDHAM END OF TEXT MARK..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES\n11641..11642 ; Sentence_Terminal # Po [2] MODI DANDA..MODI DOUBLE DANDA\n1173C..1173E ; Sentence_Terminal # Po [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI\n11944 ; Sentence_Terminal # Po DIVES AKURU DOUBLE DANDA\n11946 ; Sentence_Terminal # Po DIVES AKURU END OF TEXT MARK\n11A42..11A43 ; Sentence_Terminal # Po [2] ZANABAZAR SQUARE MARK SHAD..ZANABAZAR SQUARE MARK DOUBLE SHAD\n11A9B..11A9C ; Sentence_Terminal # Po [2] SOYOMBO MARK SHAD..SOYOMBO MARK DOUBLE SHAD\n11C41..11C42 ; Sentence_Terminal # Po [2] BHAIKSUKI DANDA..BHAIKSUKI DOUBLE DANDA\n11EF7..11EF8 ; Sentence_Terminal # Po [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION\n11F43..11F44 ; Sentence_Terminal # Po [2] KAWI DANDA..KAWI DOUBLE DANDA\n16A6E..16A6F ; Sentence_Terminal # Po [2] MRO DANDA..MRO DOUBLE DANDA\n16AF5 ; Sentence_Terminal # Po BASSA VAH FULL STOP\n16B37..16B38 ; Sentence_Terminal # Po [2] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN VOS TSHAB CEEB\n16B44 ; Sentence_Terminal # Po PAHAWH HMONG SIGN XAUS\n16D6E..16D6F ; Sentence_Terminal # Po [2] KIRAT RAI DANDA..KIRAT RAI DOUBLE DANDA\n16E98 ; Sentence_Terminal # Po MEDEFAIDRIN FULL STOP\n1BC9F ; Sentence_Terminal # Po DUPLOYAN PUNCTUATION CHINOOK FULL STOP\n1DA88 ; Sentence_Terminal # Po SIGNWRITING FULL STOP\n\n# Total code points: 170\n\n# ================================================\n\n180B..180D ; Variation_Selector # Mn [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE\n180F ; Variation_Selector # Mn MONGOLIAN FREE VARIATION SELECTOR FOUR\nFE00..FE0F ; Variation_Selector # Mn [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16\nE0100..E01EF ; Variation_Selector # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256\n\n# Total code points: 260\n\n# ================================================\n\n0009..000D ; Pattern_White_Space # Cc [5] ..\n0020 ; Pattern_White_Space # Zs SPACE\n0085 ; Pattern_White_Space # Cc \n200E..200F ; Pattern_White_Space # Cf [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK\n2028 ; Pattern_White_Space # Zl LINE SEPARATOR\n2029 ; Pattern_White_Space # Zp PARAGRAPH SEPARATOR\n\n# Total code points: 11\n\n# ================================================\n\n0021..0023 ; Pattern_Syntax # Po [3] EXCLAMATION MARK..NUMBER SIGN\n0024 ; Pattern_Syntax # Sc DOLLAR SIGN\n0025..0027 ; Pattern_Syntax # Po [3] PERCENT SIGN..APOSTROPHE\n0028 ; Pattern_Syntax # Ps LEFT PARENTHESIS\n0029 ; Pattern_Syntax # Pe RIGHT PARENTHESIS\n002A ; Pattern_Syntax # Po ASTERISK\n002B ; Pattern_Syntax # Sm PLUS SIGN\n002C ; Pattern_Syntax # Po COMMA\n002D ; Pattern_Syntax # Pd HYPHEN-MINUS\n002E..002F ; Pattern_Syntax # Po [2] FULL STOP..SOLIDUS\n003A..003B ; Pattern_Syntax # Po [2] COLON..SEMICOLON\n003C..003E ; Pattern_Syntax # Sm [3] LESS-THAN SIGN..GREATER-THAN SIGN\n003F..0040 ; Pattern_Syntax # Po [2] QUESTION MARK..COMMERCIAL AT\n005B ; Pattern_Syntax # Ps LEFT SQUARE BRACKET\n005C ; Pattern_Syntax # Po REVERSE SOLIDUS\n005D ; Pattern_Syntax # Pe RIGHT SQUARE BRACKET\n005E ; Pattern_Syntax # Sk CIRCUMFLEX ACCENT\n0060 ; Pattern_Syntax # Sk GRAVE ACCENT\n007B ; Pattern_Syntax # Ps LEFT CURLY BRACKET\n007C ; Pattern_Syntax # Sm VERTICAL LINE\n007D ; Pattern_Syntax # Pe RIGHT CURLY BRACKET\n007E ; Pattern_Syntax # Sm TILDE\n00A1 ; Pattern_Syntax # Po INVERTED EXCLAMATION MARK\n00A2..00A5 ; Pattern_Syntax # Sc [4] CENT SIGN..YEN SIGN\n00A6 ; Pattern_Syntax # So BROKEN BAR\n00A7 ; Pattern_Syntax # Po SECTION SIGN\n00A9 ; Pattern_Syntax # So COPYRIGHT SIGN\n00AB ; Pattern_Syntax # Pi LEFT-POINTING DOUBLE ANGLE QUOTATION MARK\n00AC ; Pattern_Syntax # Sm NOT SIGN\n00AE ; Pattern_Syntax # So REGISTERED SIGN\n00B0 ; Pattern_Syntax # So DEGREE SIGN\n00B1 ; Pattern_Syntax # Sm PLUS-MINUS SIGN\n00B6 ; Pattern_Syntax # Po PILCROW SIGN\n00BB ; Pattern_Syntax # Pf RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK\n00BF ; Pattern_Syntax # Po INVERTED QUESTION MARK\n00D7 ; Pattern_Syntax # Sm MULTIPLICATION SIGN\n00F7 ; Pattern_Syntax # Sm DIVISION SIGN\n2010..2015 ; Pattern_Syntax # Pd [6] HYPHEN..HORIZONTAL BAR\n2016..2017 ; Pattern_Syntax # Po [2] DOUBLE VERTICAL LINE..DOUBLE LOW LINE\n2018 ; Pattern_Syntax # Pi LEFT SINGLE QUOTATION MARK\n2019 ; Pattern_Syntax # Pf RIGHT SINGLE QUOTATION MARK\n201A ; Pattern_Syntax # Ps SINGLE LOW-9 QUOTATION MARK\n201B..201C ; Pattern_Syntax # Pi [2] SINGLE HIGH-REVERSED-9 QUOTATION MARK..LEFT DOUBLE QUOTATION MARK\n201D ; Pattern_Syntax # Pf RIGHT DOUBLE QUOTATION MARK\n201E ; Pattern_Syntax # Ps DOUBLE LOW-9 QUOTATION MARK\n201F ; Pattern_Syntax # Pi DOUBLE HIGH-REVERSED-9 QUOTATION MARK\n2020..2027 ; Pattern_Syntax # Po [8] DAGGER..HYPHENATION POINT\n2030..2038 ; Pattern_Syntax # Po [9] PER MILLE SIGN..CARET\n2039 ; Pattern_Syntax # Pi SINGLE LEFT-POINTING ANGLE QUOTATION MARK\n203A ; Pattern_Syntax # Pf SINGLE RIGHT-POINTING ANGLE QUOTATION MARK\n203B..203E ; Pattern_Syntax # Po [4] REFERENCE MARK..OVERLINE\n2041..2043 ; Pattern_Syntax # Po [3] CARET INSERTION POINT..HYPHEN BULLET\n2044 ; Pattern_Syntax # Sm FRACTION SLASH\n2045 ; Pattern_Syntax # Ps LEFT SQUARE BRACKET WITH QUILL\n2046 ; Pattern_Syntax # Pe RIGHT SQUARE BRACKET WITH QUILL\n2047..2051 ; Pattern_Syntax # Po [11] DOUBLE QUESTION MARK..TWO ASTERISKS ALIGNED VERTICALLY\n2052 ; Pattern_Syntax # Sm COMMERCIAL MINUS SIGN\n2053 ; Pattern_Syntax # Po SWUNG DASH\n2055..205E ; Pattern_Syntax # Po [10] FLOWER PUNCTUATION MARK..VERTICAL FOUR DOTS\n2190..2194 ; Pattern_Syntax # Sm [5] LEFTWARDS ARROW..LEFT RIGHT ARROW\n2195..2199 ; Pattern_Syntax # So [5] UP DOWN ARROW..SOUTH WEST ARROW\n219A..219B ; Pattern_Syntax # Sm [2] LEFTWARDS ARROW WITH STROKE..RIGHTWARDS ARROW WITH STROKE\n219C..219F ; Pattern_Syntax # So [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW\n21A0 ; Pattern_Syntax # Sm RIGHTWARDS TWO HEADED ARROW\n21A1..21A2 ; Pattern_Syntax # So [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL\n21A3 ; Pattern_Syntax # Sm RIGHTWARDS ARROW WITH TAIL\n21A4..21A5 ; Pattern_Syntax # So [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR\n21A6 ; Pattern_Syntax # Sm RIGHTWARDS ARROW FROM BAR\n21A7..21AD ; Pattern_Syntax # So [7] DOWNWARDS ARROW FROM BAR..LEFT RIGHT WAVE ARROW\n21AE ; Pattern_Syntax # Sm LEFT RIGHT ARROW WITH STROKE\n21AF..21CD ; Pattern_Syntax # So [31] DOWNWARDS ZIGZAG ARROW..LEFTWARDS DOUBLE ARROW WITH STROKE\n21CE..21CF ; Pattern_Syntax # Sm [2] LEFT RIGHT DOUBLE ARROW WITH STROKE..RIGHTWARDS DOUBLE ARROW WITH STROKE\n21D0..21D1 ; Pattern_Syntax # So [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW\n21D2 ; Pattern_Syntax # Sm RIGHTWARDS DOUBLE ARROW\n21D3 ; Pattern_Syntax # So DOWNWARDS DOUBLE ARROW\n21D4 ; Pattern_Syntax # Sm LEFT RIGHT DOUBLE ARROW\n21D5..21F3 ; Pattern_Syntax # So [31] UP DOWN DOUBLE ARROW..UP DOWN WHITE ARROW\n21F4..22FF ; Pattern_Syntax # Sm [268] RIGHT ARROW WITH SMALL CIRCLE..Z NOTATION BAG MEMBERSHIP\n2300..2307 ; Pattern_Syntax # So [8] DIAMETER SIGN..WAVY LINE\n2308 ; Pattern_Syntax # Ps LEFT CEILING\n2309 ; Pattern_Syntax # Pe RIGHT CEILING\n230A ; Pattern_Syntax # Ps LEFT FLOOR\n230B ; Pattern_Syntax # Pe RIGHT FLOOR\n230C..231F ; Pattern_Syntax # So [20] BOTTOM RIGHT CROP..BOTTOM RIGHT CORNER\n2320..2321 ; Pattern_Syntax # Sm [2] TOP HALF INTEGRAL..BOTTOM HALF INTEGRAL\n2322..2328 ; Pattern_Syntax # So [7] FROWN..KEYBOARD\n2329 ; Pattern_Syntax # Ps LEFT-POINTING ANGLE BRACKET\n232A ; Pattern_Syntax # Pe RIGHT-POINTING ANGLE BRACKET\n232B..237B ; Pattern_Syntax # So [81] ERASE TO THE LEFT..NOT CHECK MARK\n237C ; Pattern_Syntax # Sm RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW\n237D..239A ; Pattern_Syntax # So [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL\n239B..23B3 ; Pattern_Syntax # Sm [25] LEFT PARENTHESIS UPPER HOOK..SUMMATION BOTTOM\n23B4..23DB ; Pattern_Syntax # So [40] TOP SQUARE BRACKET..FUSE\n23DC..23E1 ; Pattern_Syntax # Sm [6] TOP PARENTHESIS..BOTTOM TORTOISE SHELL BRACKET\n23E2..2429 ; Pattern_Syntax # So [72] WHITE TRAPEZIUM..SYMBOL FOR DELETE MEDIUM SHADE FORM\n242A..243F ; Pattern_Syntax # Cn [22] ..\n2440..244A ; Pattern_Syntax # So [11] OCR HOOK..OCR DOUBLE BACKSLASH\n244B..245F ; Pattern_Syntax # Cn [21] ..\n2500..25B6 ; Pattern_Syntax # So [183] BOX DRAWINGS LIGHT HORIZONTAL..BLACK RIGHT-POINTING TRIANGLE\n25B7 ; Pattern_Syntax # Sm WHITE RIGHT-POINTING TRIANGLE\n25B8..25C0 ; Pattern_Syntax # So [9] BLACK RIGHT-POINTING SMALL TRIANGLE..BLACK LEFT-POINTING TRIANGLE\n25C1 ; Pattern_Syntax # Sm WHITE LEFT-POINTING TRIANGLE\n25C2..25F7 ; Pattern_Syntax # So [54] BLACK LEFT-POINTING SMALL TRIANGLE..WHITE CIRCLE WITH UPPER RIGHT QUADRANT\n25F8..25FF ; Pattern_Syntax # Sm [8] UPPER LEFT TRIANGLE..LOWER RIGHT TRIANGLE\n2600..266E ; Pattern_Syntax # So [111] BLACK SUN WITH RAYS..MUSIC NATURAL SIGN\n266F ; Pattern_Syntax # Sm MUSIC SHARP SIGN\n2670..2767 ; Pattern_Syntax # So [248] WEST SYRIAC CROSS..ROTATED FLORAL HEART BULLET\n2768 ; Pattern_Syntax # Ps MEDIUM LEFT PARENTHESIS ORNAMENT\n2769 ; Pattern_Syntax # Pe MEDIUM RIGHT PARENTHESIS ORNAMENT\n276A ; Pattern_Syntax # Ps MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT\n276B ; Pattern_Syntax # Pe MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT\n276C ; Pattern_Syntax # Ps MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT\n276D ; Pattern_Syntax # Pe MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT\n276E ; Pattern_Syntax # Ps HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT\n276F ; Pattern_Syntax # Pe HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT\n2770 ; Pattern_Syntax # Ps HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT\n2771 ; Pattern_Syntax # Pe HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT\n2772 ; Pattern_Syntax # Ps LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT\n2773 ; Pattern_Syntax # Pe LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT\n2774 ; Pattern_Syntax # Ps MEDIUM LEFT CURLY BRACKET ORNAMENT\n2775 ; Pattern_Syntax # Pe MEDIUM RIGHT CURLY BRACKET ORNAMENT\n2794..27BF ; Pattern_Syntax # So [44] HEAVY WIDE-HEADED RIGHTWARDS ARROW..DOUBLE CURLY LOOP\n27C0..27C4 ; Pattern_Syntax # Sm [5] THREE DIMENSIONAL ANGLE..OPEN SUPERSET\n27C5 ; Pattern_Syntax # Ps LEFT S-SHAPED BAG DELIMITER\n27C6 ; Pattern_Syntax # Pe RIGHT S-SHAPED BAG DELIMITER\n27C7..27E5 ; Pattern_Syntax # Sm [31] OR WITH DOT INSIDE..WHITE SQUARE WITH RIGHTWARDS TICK\n27E6 ; Pattern_Syntax # Ps MATHEMATICAL LEFT WHITE SQUARE BRACKET\n27E7 ; Pattern_Syntax # Pe MATHEMATICAL RIGHT WHITE SQUARE BRACKET\n27E8 ; Pattern_Syntax # Ps MATHEMATICAL LEFT ANGLE BRACKET\n27E9 ; Pattern_Syntax # Pe MATHEMATICAL RIGHT ANGLE BRACKET\n27EA ; Pattern_Syntax # Ps MATHEMATICAL LEFT DOUBLE ANGLE BRACKET\n27EB ; Pattern_Syntax # Pe MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET\n27EC ; Pattern_Syntax # Ps MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET\n27ED ; Pattern_Syntax # Pe MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET\n27EE ; Pattern_Syntax # Ps MATHEMATICAL LEFT FLATTENED PARENTHESIS\n27EF ; Pattern_Syntax # Pe MATHEMATICAL RIGHT FLATTENED PARENTHESIS\n27F0..27FF ; Pattern_Syntax # Sm [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW\n2800..28FF ; Pattern_Syntax # So [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678\n2900..2982 ; Pattern_Syntax # Sm [131] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..Z NOTATION TYPE COLON\n2983 ; Pattern_Syntax # Ps LEFT WHITE CURLY BRACKET\n2984 ; Pattern_Syntax # Pe RIGHT WHITE CURLY BRACKET\n2985 ; Pattern_Syntax # Ps LEFT WHITE PARENTHESIS\n2986 ; Pattern_Syntax # Pe RIGHT WHITE PARENTHESIS\n2987 ; Pattern_Syntax # Ps Z NOTATION LEFT IMAGE BRACKET\n2988 ; Pattern_Syntax # Pe Z NOTATION RIGHT IMAGE BRACKET\n2989 ; Pattern_Syntax # Ps Z NOTATION LEFT BINDING BRACKET\n298A ; Pattern_Syntax # Pe Z NOTATION RIGHT BINDING BRACKET\n298B ; Pattern_Syntax # Ps LEFT SQUARE BRACKET WITH UNDERBAR\n298C ; Pattern_Syntax # Pe RIGHT SQUARE BRACKET WITH UNDERBAR\n298D ; Pattern_Syntax # Ps LEFT SQUARE BRACKET WITH TICK IN TOP CORNER\n298E ; Pattern_Syntax # Pe RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER\n298F ; Pattern_Syntax # Ps LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER\n2990 ; Pattern_Syntax # Pe RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER\n2991 ; Pattern_Syntax # Ps LEFT ANGLE BRACKET WITH DOT\n2992 ; Pattern_Syntax # Pe RIGHT ANGLE BRACKET WITH DOT\n2993 ; Pattern_Syntax # Ps LEFT ARC LESS-THAN BRACKET\n2994 ; Pattern_Syntax # Pe RIGHT ARC GREATER-THAN BRACKET\n2995 ; Pattern_Syntax # Ps DOUBLE LEFT ARC GREATER-THAN BRACKET\n2996 ; Pattern_Syntax # Pe DOUBLE RIGHT ARC LESS-THAN BRACKET\n2997 ; Pattern_Syntax # Ps LEFT BLACK TORTOISE SHELL BRACKET\n2998 ; Pattern_Syntax # Pe RIGHT BLACK TORTOISE SHELL BRACKET\n2999..29D7 ; Pattern_Syntax # Sm [63] DOTTED FENCE..BLACK HOURGLASS\n29D8 ; Pattern_Syntax # Ps LEFT WIGGLY FENCE\n29D9 ; Pattern_Syntax # Pe RIGHT WIGGLY FENCE\n29DA ; Pattern_Syntax # Ps LEFT DOUBLE WIGGLY FENCE\n29DB ; Pattern_Syntax # Pe RIGHT DOUBLE WIGGLY FENCE\n29DC..29FB ; Pattern_Syntax # Sm [32] INCOMPLETE INFINITY..TRIPLE PLUS\n29FC ; Pattern_Syntax # Ps LEFT-POINTING CURVED ANGLE BRACKET\n29FD ; Pattern_Syntax # Pe RIGHT-POINTING CURVED ANGLE BRACKET\n29FE..2AFF ; Pattern_Syntax # Sm [258] TINY..N-ARY WHITE VERTICAL BAR\n2B00..2B2F ; Pattern_Syntax # So [48] NORTH EAST WHITE ARROW..WHITE VERTICAL ELLIPSE\n2B30..2B44 ; Pattern_Syntax # Sm [21] LEFT ARROW WITH SMALL CIRCLE..RIGHTWARDS ARROW THROUGH SUPERSET\n2B45..2B46 ; Pattern_Syntax # So [2] LEFTWARDS QUADRUPLE ARROW..RIGHTWARDS QUADRUPLE ARROW\n2B47..2B4C ; Pattern_Syntax # Sm [6] REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR\n2B4D..2B73 ; Pattern_Syntax # So [39] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR\n2B74..2B75 ; Pattern_Syntax # Cn [2] ..\n2B76..2BFF ; Pattern_Syntax # So [138] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..HELLSCHREIBER PAUSE SYMBOL\n2E00..2E01 ; Pattern_Syntax # Po [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER\n2E02 ; Pattern_Syntax # Pi LEFT SUBSTITUTION BRACKET\n2E03 ; Pattern_Syntax # Pf RIGHT SUBSTITUTION BRACKET\n2E04 ; Pattern_Syntax # Pi LEFT DOTTED SUBSTITUTION BRACKET\n2E05 ; Pattern_Syntax # Pf RIGHT DOTTED SUBSTITUTION BRACKET\n2E06..2E08 ; Pattern_Syntax # Po [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER\n2E09 ; Pattern_Syntax # Pi LEFT TRANSPOSITION BRACKET\n2E0A ; Pattern_Syntax # Pf RIGHT TRANSPOSITION BRACKET\n2E0B ; Pattern_Syntax # Po RAISED SQUARE\n2E0C ; Pattern_Syntax # Pi LEFT RAISED OMISSION BRACKET\n2E0D ; Pattern_Syntax # Pf RIGHT RAISED OMISSION BRACKET\n2E0E..2E16 ; Pattern_Syntax # Po [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE\n2E17 ; Pattern_Syntax # Pd DOUBLE OBLIQUE HYPHEN\n2E18..2E19 ; Pattern_Syntax # Po [2] INVERTED INTERROBANG..PALM BRANCH\n2E1A ; Pattern_Syntax # Pd HYPHEN WITH DIAERESIS\n2E1B ; Pattern_Syntax # Po TILDE WITH RING ABOVE\n2E1C ; Pattern_Syntax # Pi LEFT LOW PARAPHRASE BRACKET\n2E1D ; Pattern_Syntax # Pf RIGHT LOW PARAPHRASE BRACKET\n2E1E..2E1F ; Pattern_Syntax # Po [2] TILDE WITH DOT ABOVE..TILDE WITH DOT BELOW\n2E20 ; Pattern_Syntax # Pi LEFT VERTICAL BAR WITH QUILL\n2E21 ; Pattern_Syntax # Pf RIGHT VERTICAL BAR WITH QUILL\n2E22 ; Pattern_Syntax # Ps TOP LEFT HALF BRACKET\n2E23 ; Pattern_Syntax # Pe TOP RIGHT HALF BRACKET\n2E24 ; Pattern_Syntax # Ps BOTTOM LEFT HALF BRACKET\n2E25 ; Pattern_Syntax # Pe BOTTOM RIGHT HALF BRACKET\n2E26 ; Pattern_Syntax # Ps LEFT SIDEWAYS U BRACKET\n2E27 ; Pattern_Syntax # Pe RIGHT SIDEWAYS U BRACKET\n2E28 ; Pattern_Syntax # Ps LEFT DOUBLE PARENTHESIS\n2E29 ; Pattern_Syntax # Pe RIGHT DOUBLE PARENTHESIS\n2E2A..2E2E ; Pattern_Syntax # Po [5] TWO DOTS OVER ONE DOT PUNCTUATION..REVERSED QUESTION MARK\n2E2F ; Pattern_Syntax # Lm VERTICAL TILDE\n2E30..2E39 ; Pattern_Syntax # Po [10] RING POINT..TOP HALF SECTION SIGN\n2E3A..2E3B ; Pattern_Syntax # Pd [2] TWO-EM DASH..THREE-EM DASH\n2E3C..2E3F ; Pattern_Syntax # Po [4] STENOGRAPHIC FULL STOP..CAPITULUM\n2E40 ; Pattern_Syntax # Pd DOUBLE HYPHEN\n2E41 ; Pattern_Syntax # Po REVERSED COMMA\n2E42 ; Pattern_Syntax # Ps DOUBLE LOW-REVERSED-9 QUOTATION MARK\n2E43..2E4F ; Pattern_Syntax # Po [13] DASH WITH LEFT UPTURN..CORNISH VERSE DIVIDER\n2E50..2E51 ; Pattern_Syntax # So [2] CROSS PATTY WITH RIGHT CROSSBAR..CROSS PATTY WITH LEFT CROSSBAR\n2E52..2E54 ; Pattern_Syntax # Po [3] TIRONIAN SIGN CAPITAL ET..MEDIEVAL QUESTION MARK\n2E55 ; Pattern_Syntax # Ps LEFT SQUARE BRACKET WITH STROKE\n2E56 ; Pattern_Syntax # Pe RIGHT SQUARE BRACKET WITH STROKE\n2E57 ; Pattern_Syntax # Ps LEFT SQUARE BRACKET WITH DOUBLE STROKE\n2E58 ; Pattern_Syntax # Pe RIGHT SQUARE BRACKET WITH DOUBLE STROKE\n2E59 ; Pattern_Syntax # Ps TOP HALF LEFT PARENTHESIS\n2E5A ; Pattern_Syntax # Pe TOP HALF RIGHT PARENTHESIS\n2E5B ; Pattern_Syntax # Ps BOTTOM HALF LEFT PARENTHESIS\n2E5C ; Pattern_Syntax # Pe BOTTOM HALF RIGHT PARENTHESIS\n2E5D ; Pattern_Syntax # Pd OBLIQUE HYPHEN\n2E5E..2E7F ; Pattern_Syntax # Cn [34] ..\n3001..3003 ; Pattern_Syntax # Po [3] IDEOGRAPHIC COMMA..DITTO MARK\n3008 ; Pattern_Syntax # Ps LEFT ANGLE BRACKET\n3009 ; Pattern_Syntax # Pe RIGHT ANGLE BRACKET\n300A ; Pattern_Syntax # Ps LEFT DOUBLE ANGLE BRACKET\n300B ; Pattern_Syntax # Pe RIGHT DOUBLE ANGLE BRACKET\n300C ; Pattern_Syntax # Ps LEFT CORNER BRACKET\n300D ; Pattern_Syntax # Pe RIGHT CORNER BRACKET\n300E ; Pattern_Syntax # Ps LEFT WHITE CORNER BRACKET\n300F ; Pattern_Syntax # Pe RIGHT WHITE CORNER BRACKET\n3010 ; Pattern_Syntax # Ps LEFT BLACK LENTICULAR BRACKET\n3011 ; Pattern_Syntax # Pe RIGHT BLACK LENTICULAR BRACKET\n3012..3013 ; Pattern_Syntax # So [2] POSTAL MARK..GETA MARK\n3014 ; Pattern_Syntax # Ps LEFT TORTOISE SHELL BRACKET\n3015 ; Pattern_Syntax # Pe RIGHT TORTOISE SHELL BRACKET\n3016 ; Pattern_Syntax # Ps LEFT WHITE LENTICULAR BRACKET\n3017 ; Pattern_Syntax # Pe RIGHT WHITE LENTICULAR BRACKET\n3018 ; Pattern_Syntax # Ps LEFT WHITE TORTOISE SHELL BRACKET\n3019 ; Pattern_Syntax # Pe RIGHT WHITE TORTOISE SHELL BRACKET\n301A ; Pattern_Syntax # Ps LEFT WHITE SQUARE BRACKET\n301B ; Pattern_Syntax # Pe RIGHT WHITE SQUARE BRACKET\n301C ; Pattern_Syntax # Pd WAVE DASH\n301D ; Pattern_Syntax # Ps REVERSED DOUBLE PRIME QUOTATION MARK\n301E..301F ; Pattern_Syntax # Pe [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK\n3020 ; Pattern_Syntax # So POSTAL MARK FACE\n3030 ; Pattern_Syntax # Pd WAVY DASH\nFD3E ; Pattern_Syntax # Pe ORNATE LEFT PARENTHESIS\nFD3F ; Pattern_Syntax # Ps ORNATE RIGHT PARENTHESIS\nFE45..FE46 ; Pattern_Syntax # Po [2] SESAME DOT..WHITE SESAME DOT\n\n# Total code points: 2760\n\n# ================================================\n\n0600..0605 ; Prepended_Concatenation_Mark # Cf [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE\n06DD ; Prepended_Concatenation_Mark # Cf ARABIC END OF AYAH\n070F ; Prepended_Concatenation_Mark # Cf SYRIAC ABBREVIATION MARK\n0890..0891 ; Prepended_Concatenation_Mark # Cf [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE\n08E2 ; Prepended_Concatenation_Mark # Cf ARABIC DISPUTED END OF AYAH\n110BD ; Prepended_Concatenation_Mark # Cf KAITHI NUMBER SIGN\n110CD ; Prepended_Concatenation_Mark # Cf KAITHI NUMBER SIGN ABOVE\n\n# Total code points: 13\n\n# ================================================\n\n1F1E6..1F1FF ; Regional_Indicator # So [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z\n\n# Total code points: 26\n\n# ================================================\n\n0654..0655 ; Modifier_Combining_Mark # Mn [2] ARABIC HAMZA ABOVE..ARABIC HAMZA BELOW\n0658 ; Modifier_Combining_Mark # Mn ARABIC MARK NOON GHUNNA\n06DC ; Modifier_Combining_Mark # Mn ARABIC SMALL HIGH SEEN\n06E3 ; Modifier_Combining_Mark # Mn ARABIC SMALL LOW SEEN\n06E7..06E8 ; Modifier_Combining_Mark # Mn [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON\n08CA..08CB ; Modifier_Combining_Mark # Mn [2] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH YEH BARREE WITH TWO DOTS BELOW\n08CD..08CF ; Modifier_Combining_Mark # Mn [3] ARABIC SMALL HIGH ZAH..ARABIC LARGE ROUND DOT BELOW\n08D3 ; Modifier_Combining_Mark # Mn ARABIC SMALL LOW WAW\n08F3 ; Modifier_Combining_Mark # Mn ARABIC SMALL HIGH WAW\n\n# Total code points: 14\n\n# EOF\n" }, { "path": "lib/elixir/unicode/PropertyValueAliases.txt", "content": "# PropertyValueAliases-17.0.0.txt\n# Date: 2025-06-30, 06:16:21 GMT\n# © 2025 Unicode®, Inc.\n# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.\n# For terms of use and license, see https://www.unicode.org/terms_of_use.html\n#\n# Unicode Character Database\n# For documentation, see https://www.unicode.org/reports/tr44/\n#\n# This file contains aliases for property values used in the UCD.\n# These names can be used for XML formats of UCD data, for regular-expression\n# property tests, and other programmatic textual descriptions of Unicode data.\n#\n# The names may be translated in appropriate environments, and additional\n# aliases may be useful.\n#\n# FORMAT\n#\n# Each line describes a property value name.\n# This consists of three or more fields, separated by semicolons.\n#\n# First Field: The first field describes the property for which that\n# property value name is used.\n#\n# Second Field: The second field is the short name for the property value.\n# It is typically an abbreviation, but in a number of cases it is simply\n# a duplicate of the \"long name\" in the third field.\n#\n# Third Field: The third field is the long name for the property value, \n# typically the formal name used in documentation about the property value.\n#\n# In the case of Canonical_Combining_Class (ccc), there are 4 fields: \n# The second field is numeric, the third is the short name, and the fourth is the long name.\n#\n# The above are the preferred aliases. Other aliases may be listed in additional fields.\n#\n# Loose matching should be applied to all property names and property values, with\n# the exception of String Property values. With loose matching of property names and\n# values, the case distinctions, whitespace, hyphens, and '_' are ignored.\n# For Numeric Property values, numeric equivalence is applied: thus \"01.00\"\n# is equivalent to \"1\".\n#\n# NOTE: Property value names are NOT unique across properties. For example:\n#\n# AL means Arabic Letter for the Bidi_Class property, and\n# AL means Above_Left for the Canonical_Combining_Class property, and\n# AL means Alphabetic for the Line_Break property.\n#\n# In addition, some property names may be the same as some property value names.\n# For example:\n#\n# sc means the Script property, and\n# Sc means the General_Category property value Currency_Symbol (Sc)\n#\n# The combination of property value and property name is, however, unique.\n#\n# For more information, see UAX #44, Unicode Character Database, and\n# UTS #18, Unicode Regular Expressions.\n# ================================================\n\n\n# ASCII_Hex_Digit (AHex)\n\nAHex; N ; No ; F ; False\nAHex; Y ; Yes ; T ; True\n\n# Age (age)\n\nage; 1.1 ; V1_1\nage; 2.0 ; V2_0\nage; 2.1 ; V2_1\nage; 3.0 ; V3_0\nage; 3.1 ; V3_1\nage; 3.2 ; V3_2\nage; 4.0 ; V4_0\nage; 4.1 ; V4_1\nage; 5.0 ; V5_0\nage; 5.1 ; V5_1\nage; 5.2 ; V5_2\nage; 6.0 ; V6_0\nage; 6.1 ; V6_1\nage; 6.2 ; V6_2\nage; 6.3 ; V6_3\nage; 7.0 ; V7_0\nage; 8.0 ; V8_0\nage; 9.0 ; V9_0\nage; 10.0 ; V10_0\nage; 11.0 ; V11_0\nage; 12.0 ; V12_0\nage; 12.1 ; V12_1\nage; 13.0 ; V13_0\nage; 14.0 ; V14_0\nage; 15.0 ; V15_0\nage; 15.1 ; V15_1\nage; 16.0 ; V16_0\nage; 17.0 ; V17_0\nage; NA ; Unassigned\n\n# Alphabetic (Alpha)\n\nAlpha; N ; No ; F ; False\nAlpha; Y ; Yes ; T ; True\n\n# Bidi_Class (bc)\n\nbc ; AL ; Arabic_Letter\nbc ; AN ; Arabic_Number\nbc ; B ; Paragraph_Separator\nbc ; BN ; Boundary_Neutral\nbc ; CS ; Common_Separator\nbc ; EN ; European_Number\nbc ; ES ; European_Separator\nbc ; ET ; European_Terminator\nbc ; FSI ; First_Strong_Isolate\nbc ; L ; Left_To_Right\nbc ; LRE ; Left_To_Right_Embedding\nbc ; LRI ; Left_To_Right_Isolate\nbc ; LRO ; Left_To_Right_Override\nbc ; NSM ; Nonspacing_Mark\nbc ; ON ; Other_Neutral\nbc ; PDF ; Pop_Directional_Format\nbc ; PDI ; Pop_Directional_Isolate\nbc ; R ; Right_To_Left\nbc ; RLE ; Right_To_Left_Embedding\nbc ; RLI ; Right_To_Left_Isolate\nbc ; RLO ; Right_To_Left_Override\nbc ; S ; Segment_Separator\nbc ; WS ; White_Space\n\n# Bidi_Control (Bidi_C)\n\nBidi_C; N ; No ; F ; False\nBidi_C; Y ; Yes ; T ; True\n\n# Bidi_Mirrored (Bidi_M)\n\nBidi_M; N ; No ; F ; False\nBidi_M; Y ; Yes ; T ; True\n\n# Bidi_Mirroring_Glyph (bmg)\n\n\n# Bidi_Paired_Bracket (bpb)\n\n# @missing: 0000..10FFFF; Bidi_Paired_Bracket; \n\n# Bidi_Paired_Bracket_Type (bpt)\n\nbpt; c ; Close\nbpt; n ; None\nbpt; o ; Open\n# @missing: 0000..10FFFF; Bidi_Paired_Bracket_Type; n\n\n# Block (blk)\n\nblk; Adlam ; Adlam\nblk; Aegean_Numbers ; Aegean_Numbers\nblk; Ahom ; Ahom\nblk; Alchemical ; Alchemical_Symbols\nblk; Alphabetic_PF ; Alphabetic_Presentation_Forms\nblk; Anatolian_Hieroglyphs ; Anatolian_Hieroglyphs\nblk; Ancient_Greek_Music ; Ancient_Greek_Musical_Notation\nblk; Ancient_Greek_Numbers ; Ancient_Greek_Numbers\nblk; Ancient_Symbols ; Ancient_Symbols\nblk; Arabic ; Arabic\nblk; Arabic_Ext_A ; Arabic_Extended_A\nblk; Arabic_Ext_B ; Arabic_Extended_B\nblk; Arabic_Ext_C ; Arabic_Extended_C\nblk; Arabic_Math ; Arabic_Mathematical_Alphabetic_Symbols\nblk; Arabic_PF_A ; Arabic_Presentation_Forms_A ; Arabic_Presentation_Forms-A\nblk; Arabic_PF_B ; Arabic_Presentation_Forms_B\nblk; Arabic_Sup ; Arabic_Supplement\nblk; Armenian ; Armenian\nblk; Arrows ; Arrows\nblk; ASCII ; Basic_Latin\nblk; Avestan ; Avestan\nblk; Balinese ; Balinese\nblk; Bamum ; Bamum\nblk; Bamum_Sup ; Bamum_Supplement\nblk; Bassa_Vah ; Bassa_Vah\nblk; Batak ; Batak\nblk; Bengali ; Bengali\nblk; Beria_Erfe ; Beria_Erfe\nblk; Bhaiksuki ; Bhaiksuki\nblk; Block_Elements ; Block_Elements\nblk; Bopomofo ; Bopomofo\nblk; Bopomofo_Ext ; Bopomofo_Extended\nblk; Box_Drawing ; Box_Drawing\nblk; Brahmi ; Brahmi\nblk; Braille ; Braille_Patterns\nblk; Buginese ; Buginese\nblk; Buhid ; Buhid\nblk; Byzantine_Music ; Byzantine_Musical_Symbols\nblk; Carian ; Carian\nblk; Caucasian_Albanian ; Caucasian_Albanian\nblk; Chakma ; Chakma\nblk; Cham ; Cham\nblk; Cherokee ; Cherokee\nblk; Cherokee_Sup ; Cherokee_Supplement\nblk; Chess_Symbols ; Chess_Symbols\nblk; Chorasmian ; Chorasmian\nblk; CJK ; CJK_Unified_Ideographs\nblk; CJK_Compat ; CJK_Compatibility\nblk; CJK_Compat_Forms ; CJK_Compatibility_Forms\nblk; CJK_Compat_Ideographs ; CJK_Compatibility_Ideographs\nblk; CJK_Compat_Ideographs_Sup ; CJK_Compatibility_Ideographs_Supplement\nblk; CJK_Ext_A ; CJK_Unified_Ideographs_Extension_A\nblk; CJK_Ext_B ; CJK_Unified_Ideographs_Extension_B\nblk; CJK_Ext_C ; CJK_Unified_Ideographs_Extension_C\nblk; CJK_Ext_D ; CJK_Unified_Ideographs_Extension_D\nblk; CJK_Ext_E ; CJK_Unified_Ideographs_Extension_E\nblk; CJK_Ext_F ; CJK_Unified_Ideographs_Extension_F\nblk; CJK_Ext_G ; CJK_Unified_Ideographs_Extension_G\nblk; CJK_Ext_H ; CJK_Unified_Ideographs_Extension_H\nblk; CJK_Ext_I ; CJK_Unified_Ideographs_Extension_I\nblk; CJK_Ext_J ; CJK_Unified_Ideographs_Extension_J\nblk; CJK_Radicals_Sup ; CJK_Radicals_Supplement\nblk; CJK_Strokes ; CJK_Strokes\nblk; CJK_Symbols ; CJK_Symbols_And_Punctuation\nblk; Compat_Jamo ; Hangul_Compatibility_Jamo\nblk; Control_Pictures ; Control_Pictures\nblk; Coptic ; Coptic\nblk; Coptic_Epact_Numbers ; Coptic_Epact_Numbers\nblk; Counting_Rod ; Counting_Rod_Numerals\nblk; Cuneiform ; Cuneiform\nblk; Cuneiform_Numbers ; Cuneiform_Numbers_And_Punctuation\nblk; Currency_Symbols ; Currency_Symbols\nblk; Cypriot_Syllabary ; Cypriot_Syllabary\nblk; Cypro_Minoan ; Cypro_Minoan\nblk; Cyrillic ; Cyrillic\nblk; Cyrillic_Ext_A ; Cyrillic_Extended_A\nblk; Cyrillic_Ext_B ; Cyrillic_Extended_B\nblk; Cyrillic_Ext_C ; Cyrillic_Extended_C\nblk; Cyrillic_Ext_D ; Cyrillic_Extended_D\nblk; Cyrillic_Sup ; Cyrillic_Supplement ; Cyrillic_Supplementary\nblk; Deseret ; Deseret\nblk; Devanagari ; Devanagari\nblk; Devanagari_Ext ; Devanagari_Extended\nblk; Devanagari_Ext_A ; Devanagari_Extended_A\nblk; Diacriticals ; Combining_Diacritical_Marks\nblk; Diacriticals_Ext ; Combining_Diacritical_Marks_Extended\nblk; Diacriticals_For_Symbols ; Combining_Diacritical_Marks_For_Symbols; Combining_Marks_For_Symbols\nblk; Diacriticals_Sup ; Combining_Diacritical_Marks_Supplement\nblk; Dingbats ; Dingbats\nblk; Dives_Akuru ; Dives_Akuru\nblk; Dogra ; Dogra\nblk; Domino ; Domino_Tiles\nblk; Duployan ; Duployan\nblk; Early_Dynastic_Cuneiform ; Early_Dynastic_Cuneiform\nblk; Egyptian_Hieroglyph_Format_Controls; Egyptian_Hieroglyph_Format_Controls\nblk; Egyptian_Hieroglyphs ; Egyptian_Hieroglyphs\nblk; Egyptian_Hieroglyphs_Ext_A ; Egyptian_Hieroglyphs_Extended_A\nblk; Elbasan ; Elbasan\nblk; Elymaic ; Elymaic\nblk; Emoticons ; Emoticons\nblk; Enclosed_Alphanum ; Enclosed_Alphanumerics\nblk; Enclosed_Alphanum_Sup ; Enclosed_Alphanumeric_Supplement\nblk; Enclosed_CJK ; Enclosed_CJK_Letters_And_Months\nblk; Enclosed_Ideographic_Sup ; Enclosed_Ideographic_Supplement\nblk; Ethiopic ; Ethiopic\nblk; Ethiopic_Ext ; Ethiopic_Extended\nblk; Ethiopic_Ext_A ; Ethiopic_Extended_A\nblk; Ethiopic_Ext_B ; Ethiopic_Extended_B\nblk; Ethiopic_Sup ; Ethiopic_Supplement\nblk; Garay ; Garay\nblk; Geometric_Shapes ; Geometric_Shapes\nblk; Geometric_Shapes_Ext ; Geometric_Shapes_Extended\nblk; Georgian ; Georgian\nblk; Georgian_Ext ; Georgian_Extended\nblk; Georgian_Sup ; Georgian_Supplement\nblk; Glagolitic ; Glagolitic\nblk; Glagolitic_Sup ; Glagolitic_Supplement\nblk; Gothic ; Gothic\nblk; Grantha ; Grantha\nblk; Greek ; Greek_And_Coptic\nblk; Greek_Ext ; Greek_Extended\nblk; Gujarati ; Gujarati\nblk; Gunjala_Gondi ; Gunjala_Gondi\nblk; Gurmukhi ; Gurmukhi\nblk; Gurung_Khema ; Gurung_Khema\nblk; Half_And_Full_Forms ; Halfwidth_And_Fullwidth_Forms\nblk; Half_Marks ; Combining_Half_Marks\nblk; Hangul ; Hangul_Syllables\nblk; Hanifi_Rohingya ; Hanifi_Rohingya\nblk; Hanunoo ; Hanunoo\nblk; Hatran ; Hatran\nblk; Hebrew ; Hebrew\nblk; High_PU_Surrogates ; High_Private_Use_Surrogates\nblk; High_Surrogates ; High_Surrogates\nblk; Hiragana ; Hiragana\nblk; IDC ; Ideographic_Description_Characters\nblk; Ideographic_Symbols ; Ideographic_Symbols_And_Punctuation\nblk; Imperial_Aramaic ; Imperial_Aramaic\nblk; Indic_Number_Forms ; Common_Indic_Number_Forms\nblk; Indic_Siyaq_Numbers ; Indic_Siyaq_Numbers\nblk; Inscriptional_Pahlavi ; Inscriptional_Pahlavi\nblk; Inscriptional_Parthian ; Inscriptional_Parthian\nblk; IPA_Ext ; IPA_Extensions\nblk; Jamo ; Hangul_Jamo\nblk; Jamo_Ext_A ; Hangul_Jamo_Extended_A\nblk; Jamo_Ext_B ; Hangul_Jamo_Extended_B\nblk; Javanese ; Javanese\nblk; Kaithi ; Kaithi\nblk; Kaktovik_Numerals ; Kaktovik_Numerals\nblk; Kana_Ext_A ; Kana_Extended_A\nblk; Kana_Ext_B ; Kana_Extended_B\nblk; Kana_Sup ; Kana_Supplement\nblk; Kanbun ; Kanbun\nblk; Kangxi ; Kangxi_Radicals\nblk; Kannada ; Kannada\nblk; Katakana ; Katakana\nblk; Katakana_Ext ; Katakana_Phonetic_Extensions\nblk; Kawi ; Kawi\nblk; Kayah_Li ; Kayah_Li\nblk; Kharoshthi ; Kharoshthi\nblk; Khitan_Small_Script ; Khitan_Small_Script\nblk; Khmer ; Khmer\nblk; Khmer_Symbols ; Khmer_Symbols\nblk; Khojki ; Khojki\nblk; Khudawadi ; Khudawadi\nblk; Kirat_Rai ; Kirat_Rai\nblk; Lao ; Lao\nblk; Latin_1_Sup ; Latin_1_Supplement ; Latin_1\nblk; Latin_Ext_A ; Latin_Extended_A\nblk; Latin_Ext_Additional ; Latin_Extended_Additional\nblk; Latin_Ext_B ; Latin_Extended_B\nblk; Latin_Ext_C ; Latin_Extended_C\nblk; Latin_Ext_D ; Latin_Extended_D\nblk; Latin_Ext_E ; Latin_Extended_E\nblk; Latin_Ext_F ; Latin_Extended_F\nblk; Latin_Ext_G ; Latin_Extended_G\nblk; Lepcha ; Lepcha\nblk; Letterlike_Symbols ; Letterlike_Symbols\nblk; Limbu ; Limbu\nblk; Linear_A ; Linear_A\nblk; Linear_B_Ideograms ; Linear_B_Ideograms\nblk; Linear_B_Syllabary ; Linear_B_Syllabary\nblk; Lisu ; Lisu\nblk; Lisu_Sup ; Lisu_Supplement\nblk; Low_Surrogates ; Low_Surrogates\nblk; Lycian ; Lycian\nblk; Lydian ; Lydian\nblk; Mahajani ; Mahajani\nblk; Mahjong ; Mahjong_Tiles\nblk; Makasar ; Makasar\nblk; Malayalam ; Malayalam\nblk; Mandaic ; Mandaic\nblk; Manichaean ; Manichaean\nblk; Marchen ; Marchen\nblk; Masaram_Gondi ; Masaram_Gondi\nblk; Math_Alphanum ; Mathematical_Alphanumeric_Symbols\nblk; Math_Operators ; Mathematical_Operators\nblk; Mayan_Numerals ; Mayan_Numerals\nblk; Medefaidrin ; Medefaidrin\nblk; Meetei_Mayek ; Meetei_Mayek\nblk; Meetei_Mayek_Ext ; Meetei_Mayek_Extensions\nblk; Mende_Kikakui ; Mende_Kikakui\nblk; Meroitic_Cursive ; Meroitic_Cursive\nblk; Meroitic_Hieroglyphs ; Meroitic_Hieroglyphs\nblk; Miao ; Miao\nblk; Misc_Arrows ; Miscellaneous_Symbols_And_Arrows\nblk; Misc_Math_Symbols_A ; Miscellaneous_Mathematical_Symbols_A\nblk; Misc_Math_Symbols_B ; Miscellaneous_Mathematical_Symbols_B\nblk; Misc_Pictographs ; Miscellaneous_Symbols_And_Pictographs\nblk; Misc_Symbols ; Miscellaneous_Symbols\nblk; Misc_Symbols_Sup ; Miscellaneous_Symbols_Supplement\nblk; Misc_Technical ; Miscellaneous_Technical\nblk; Modi ; Modi\nblk; Modifier_Letters ; Spacing_Modifier_Letters\nblk; Modifier_Tone_Letters ; Modifier_Tone_Letters\nblk; Mongolian ; Mongolian\nblk; Mongolian_Sup ; Mongolian_Supplement\nblk; Mro ; Mro\nblk; Multani ; Multani\nblk; Music ; Musical_Symbols\nblk; Myanmar ; Myanmar\nblk; Myanmar_Ext_A ; Myanmar_Extended_A\nblk; Myanmar_Ext_B ; Myanmar_Extended_B\nblk; Myanmar_Ext_C ; Myanmar_Extended_C\nblk; Nabataean ; Nabataean\nblk; Nag_Mundari ; Nag_Mundari\nblk; Nandinagari ; Nandinagari\nblk; NB ; No_Block\nblk; New_Tai_Lue ; New_Tai_Lue\nblk; Newa ; Newa\nblk; NKo ; NKo\nblk; Number_Forms ; Number_Forms\nblk; Nushu ; Nushu\nblk; Nyiakeng_Puachue_Hmong ; Nyiakeng_Puachue_Hmong\nblk; OCR ; Optical_Character_Recognition\nblk; Ogham ; Ogham\nblk; Ol_Chiki ; Ol_Chiki\nblk; Ol_Onal ; Ol_Onal\nblk; Old_Hungarian ; Old_Hungarian\nblk; Old_Italic ; Old_Italic\nblk; Old_North_Arabian ; Old_North_Arabian\nblk; Old_Permic ; Old_Permic\nblk; Old_Persian ; Old_Persian\nblk; Old_Sogdian ; Old_Sogdian\nblk; Old_South_Arabian ; Old_South_Arabian\nblk; Old_Turkic ; Old_Turkic\nblk; Old_Uyghur ; Old_Uyghur\nblk; Oriya ; Oriya\nblk; Ornamental_Dingbats ; Ornamental_Dingbats\nblk; Osage ; Osage\nblk; Osmanya ; Osmanya\nblk; Ottoman_Siyaq_Numbers ; Ottoman_Siyaq_Numbers\nblk; Pahawh_Hmong ; Pahawh_Hmong\nblk; Palmyrene ; Palmyrene\nblk; Pau_Cin_Hau ; Pau_Cin_Hau\nblk; Phags_Pa ; Phags_Pa\nblk; Phaistos ; Phaistos_Disc\nblk; Phoenician ; Phoenician\nblk; Phonetic_Ext ; Phonetic_Extensions\nblk; Phonetic_Ext_Sup ; Phonetic_Extensions_Supplement\nblk; Playing_Cards ; Playing_Cards\nblk; Psalter_Pahlavi ; Psalter_Pahlavi\nblk; PUA ; Private_Use_Area ; Private_Use\nblk; Punctuation ; General_Punctuation\nblk; Rejang ; Rejang\nblk; Rumi ; Rumi_Numeral_Symbols\nblk; Runic ; Runic\nblk; Samaritan ; Samaritan\nblk; Saurashtra ; Saurashtra\nblk; Sharada ; Sharada\nblk; Sharada_Sup ; Sharada_Supplement\nblk; Shavian ; Shavian\nblk; Shorthand_Format_Controls ; Shorthand_Format_Controls\nblk; Siddham ; Siddham\nblk; Sidetic ; Sidetic\nblk; Sinhala ; Sinhala\nblk; Sinhala_Archaic_Numbers ; Sinhala_Archaic_Numbers\nblk; Small_Forms ; Small_Form_Variants\nblk; Small_Kana_Ext ; Small_Kana_Extension\nblk; Sogdian ; Sogdian\nblk; Sora_Sompeng ; Sora_Sompeng\nblk; Soyombo ; Soyombo\nblk; Specials ; Specials\nblk; Sundanese ; Sundanese\nblk; Sundanese_Sup ; Sundanese_Supplement\nblk; Sunuwar ; Sunuwar\nblk; Sup_Arrows_A ; Supplemental_Arrows_A\nblk; Sup_Arrows_B ; Supplemental_Arrows_B\nblk; Sup_Arrows_C ; Supplemental_Arrows_C\nblk; Sup_Math_Operators ; Supplemental_Mathematical_Operators\nblk; Sup_PUA_A ; Supplementary_Private_Use_Area_A\nblk; Sup_PUA_B ; Supplementary_Private_Use_Area_B\nblk; Sup_Punctuation ; Supplemental_Punctuation\nblk; Sup_Symbols_And_Pictographs ; Supplemental_Symbols_And_Pictographs\nblk; Super_And_Sub ; Superscripts_And_Subscripts\nblk; Sutton_SignWriting ; Sutton_SignWriting\nblk; Syloti_Nagri ; Syloti_Nagri\nblk; Symbols_And_Pictographs_Ext_A ; Symbols_And_Pictographs_Extended_A\nblk; Symbols_For_Legacy_Computing ; Symbols_For_Legacy_Computing\nblk; Symbols_For_Legacy_Computing_Sup ; Symbols_For_Legacy_Computing_Supplement\nblk; Syriac ; Syriac\nblk; Syriac_Sup ; Syriac_Supplement\nblk; Tagalog ; Tagalog\nblk; Tagbanwa ; Tagbanwa\nblk; Tags ; Tags\nblk; Tai_Le ; Tai_Le\nblk; Tai_Tham ; Tai_Tham\nblk; Tai_Viet ; Tai_Viet\nblk; Tai_Xuan_Jing ; Tai_Xuan_Jing_Symbols\nblk; Tai_Yo ; Tai_Yo\nblk; Takri ; Takri\nblk; Tamil ; Tamil\nblk; Tamil_Sup ; Tamil_Supplement\nblk; Tangsa ; Tangsa\nblk; Tangut ; Tangut\nblk; Tangut_Components ; Tangut_Components\nblk; Tangut_Components_Sup ; Tangut_Components_Supplement\nblk; Tangut_Sup ; Tangut_Supplement\nblk; Telugu ; Telugu\nblk; Thaana ; Thaana\nblk; Thai ; Thai\nblk; Tibetan ; Tibetan\nblk; Tifinagh ; Tifinagh\nblk; Tirhuta ; Tirhuta\nblk; Todhri ; Todhri\nblk; Tolong_Siki ; Tolong_Siki\nblk; Toto ; Toto\nblk; Transport_And_Map ; Transport_And_Map_Symbols\nblk; Tulu_Tigalari ; Tulu_Tigalari\nblk; UCAS ; Unified_Canadian_Aboriginal_Syllabics; Canadian_Syllabics\nblk; UCAS_Ext ; Unified_Canadian_Aboriginal_Syllabics_Extended\nblk; UCAS_Ext_A ; Unified_Canadian_Aboriginal_Syllabics_Extended_A\nblk; Ugaritic ; Ugaritic\nblk; Vai ; Vai\nblk; Vedic_Ext ; Vedic_Extensions\nblk; Vertical_Forms ; Vertical_Forms\nblk; Vithkuqi ; Vithkuqi\nblk; VS ; Variation_Selectors\nblk; VS_Sup ; Variation_Selectors_Supplement\nblk; Wancho ; Wancho\nblk; Warang_Citi ; Warang_Citi\nblk; Yezidi ; Yezidi\nblk; Yi_Radicals ; Yi_Radicals\nblk; Yi_Syllables ; Yi_Syllables\nblk; Yijing ; Yijing_Hexagram_Symbols\nblk; Zanabazar_Square ; Zanabazar_Square\nblk; Znamenny_Music ; Znamenny_Musical_Notation\n\n# Canonical_Combining_Class (ccc)\n\nccc; 0; NR ; Not_Reordered\nccc; 1; OV ; Overlay\nccc; 6; HANR ; Han_Reading\nccc; 7; NK ; Nukta\nccc; 8; KV ; Kana_Voicing\nccc; 9; VR ; Virama\nccc; 10; CCC10 ; CCC10\nccc; 11; CCC11 ; CCC11\nccc; 12; CCC12 ; CCC12\nccc; 13; CCC13 ; CCC13\nccc; 14; CCC14 ; CCC14\nccc; 15; CCC15 ; CCC15\nccc; 16; CCC16 ; CCC16\nccc; 17; CCC17 ; CCC17\nccc; 18; CCC18 ; CCC18\nccc; 19; CCC19 ; CCC19\nccc; 20; CCC20 ; CCC20\nccc; 21; CCC21 ; CCC21\nccc; 22; CCC22 ; CCC22\nccc; 23; CCC23 ; CCC23\nccc; 24; CCC24 ; CCC24\nccc; 25; CCC25 ; CCC25\nccc; 26; CCC26 ; CCC26\nccc; 27; CCC27 ; CCC27\nccc; 28; CCC28 ; CCC28\nccc; 29; CCC29 ; CCC29\nccc; 30; CCC30 ; CCC30\nccc; 31; CCC31 ; CCC31\nccc; 32; CCC32 ; CCC32\nccc; 33; CCC33 ; CCC33\nccc; 34; CCC34 ; CCC34\nccc; 35; CCC35 ; CCC35\nccc; 36; CCC36 ; CCC36\nccc; 84; CCC84 ; CCC84\nccc; 91; CCC91 ; CCC91\nccc; 103; CCC103 ; CCC103\nccc; 107; CCC107 ; CCC107\nccc; 118; CCC118 ; CCC118\nccc; 122; CCC122 ; CCC122\nccc; 129; CCC129 ; CCC129\nccc; 130; CCC130 ; CCC130\nccc; 132; CCC132 ; CCC132\nccc; 133; CCC133 ; CCC133 # RESERVED\nccc; 200; ATBL ; Attached_Below_Left\nccc; 202; ATB ; Attached_Below\nccc; 214; ATA ; Attached_Above\nccc; 216; ATAR ; Attached_Above_Right\nccc; 218; BL ; Below_Left\nccc; 220; B ; Below\nccc; 222; BR ; Below_Right\nccc; 224; L ; Left\nccc; 226; R ; Right\nccc; 228; AL ; Above_Left\nccc; 230; A ; Above\nccc; 232; AR ; Above_Right\nccc; 233; DB ; Double_Below\nccc; 234; DA ; Double_Above\nccc; 240; IS ; Iota_Subscript\n\n# Case_Folding (cf)\n\n# @missing: 0000..10FFFF; Case_Folding; \n\n# Case_Ignorable (CI)\n\nCI ; N ; No ; F ; False\nCI ; Y ; Yes ; T ; True\n\n# Cased (Cased)\n\nCased; N ; No ; F ; False\nCased; Y ; Yes ; T ; True\n\n# Changes_When_Casefolded (CWCF)\n\nCWCF; N ; No ; F ; False\nCWCF; Y ; Yes ; T ; True\n\n# Changes_When_Casemapped (CWCM)\n\nCWCM; N ; No ; F ; False\nCWCM; Y ; Yes ; T ; True\n\n# Changes_When_Lowercased (CWL)\n\nCWL; N ; No ; F ; False\nCWL; Y ; Yes ; T ; True\n\n# Changes_When_NFKC_Casefolded (CWKCF)\n\nCWKCF; N ; No ; F ; False\nCWKCF; Y ; Yes ; T ; True\n\n# Changes_When_Titlecased (CWT)\n\nCWT; N ; No ; F ; False\nCWT; Y ; Yes ; T ; True\n\n# Changes_When_Uppercased (CWU)\n\nCWU; N ; No ; F ; False\nCWU; Y ; Yes ; T ; True\n\n# Composition_Exclusion (CE)\n\nCE ; N ; No ; F ; False\nCE ; Y ; Yes ; T ; True\n\n# Dash (Dash)\n\nDash; N ; No ; F ; False\nDash; Y ; Yes ; T ; True\n\n# Decomposition_Mapping (dm)\n\n# @missing: 0000..10FFFF; Decomposition_Mapping; \n\n# Decomposition_Type (dt)\n\ndt ; Can ; Canonical ; can\ndt ; Com ; Compat ; com\ndt ; Enc ; Circle ; enc\ndt ; Fin ; Final ; fin\ndt ; Font ; Font ; font\ndt ; Fra ; Fraction ; fra\ndt ; Init ; Initial ; init\ndt ; Iso ; Isolated ; iso\ndt ; Med ; Medial ; med\ndt ; Nar ; Narrow ; nar\ndt ; Nb ; Nobreak ; nb\ndt ; None ; None ; none\ndt ; Sml ; Small ; sml\ndt ; Sqr ; Square ; sqr\ndt ; Sub ; Sub ; sub\ndt ; Sup ; Super ; sup\ndt ; Vert ; Vertical ; vert\ndt ; Wide ; Wide ; wide\n\n# Default_Ignorable_Code_Point (DI)\n\nDI ; N ; No ; F ; False\nDI ; Y ; Yes ; T ; True\n\n# Deprecated (Dep)\n\nDep; N ; No ; F ; False\nDep; Y ; Yes ; T ; True\n\n# Diacritic (Dia)\n\nDia; N ; No ; F ; False\nDia; Y ; Yes ; T ; True\n\n# East_Asian_Width (ea)\n\nea ; A ; Ambiguous\nea ; F ; Fullwidth\nea ; H ; Halfwidth\nea ; N ; Neutral\nea ; Na ; Narrow\nea ; W ; Wide\n\n# Emoji (Emoji)\n\nEmoji; N ; No ; F ; False\nEmoji; Y ; Yes ; T ; True\n\n# Emoji_Component (EComp)\n\nEComp; N ; No ; F ; False\nEComp; Y ; Yes ; T ; True\n\n# Emoji_Modifier (EMod)\n\nEMod; N ; No ; F ; False\nEMod; Y ; Yes ; T ; True\n\n# Emoji_Modifier_Base (EBase)\n\nEBase; N ; No ; F ; False\nEBase; Y ; Yes ; T ; True\n\n# Emoji_Presentation (EPres)\n\nEPres; N ; No ; F ; False\nEPres; Y ; Yes ; T ; True\n\n# Equivalent_Unified_Ideograph (EqUIdeo)\n\n\n# Expands_On_NFC (XO_NFC)\n\nXO_NFC; N ; No ; F ; False\nXO_NFC; Y ; Yes ; T ; True\n\n# Expands_On_NFD (XO_NFD)\n\nXO_NFD; N ; No ; F ; False\nXO_NFD; Y ; Yes ; T ; True\n\n# Expands_On_NFKC (XO_NFKC)\n\nXO_NFKC; N ; No ; F ; False\nXO_NFKC; Y ; Yes ; T ; True\n\n# Expands_On_NFKD (XO_NFKD)\n\nXO_NFKD; N ; No ; F ; False\nXO_NFKD; Y ; Yes ; T ; True\n\n# Extended_Pictographic (ExtPict)\n\nExtPict; N ; No ; F ; False\nExtPict; Y ; Yes ; T ; True\n\n# Extender (Ext)\n\nExt; N ; No ; F ; False\nExt; Y ; Yes ; T ; True\n\n# FC_NFKC_Closure (FC_NFKC)\n\n# @missing: 0000..10FFFF; FC_NFKC_Closure; \n\n# Full_Composition_Exclusion (Comp_Ex)\n\nComp_Ex; N ; No ; F ; False\nComp_Ex; Y ; Yes ; T ; True\n\n# General_Category (gc)\n\ngc ; C ; Other # Cc | Cf | Cn | Co | Cs\ngc ; Cc ; Control ; cntrl\ngc ; Cf ; Format\ngc ; Cn ; Unassigned\ngc ; Co ; Private_Use\ngc ; Cs ; Surrogate\ngc ; L ; Letter # Ll | Lm | Lo | Lt | Lu\ngc ; LC ; Cased_Letter # Ll | Lt | Lu\ngc ; Ll ; Lowercase_Letter\ngc ; Lm ; Modifier_Letter\ngc ; Lo ; Other_Letter\ngc ; Lt ; Titlecase_Letter\ngc ; Lu ; Uppercase_Letter\ngc ; M ; Mark ; Combining_Mark # Mc | Me | Mn\ngc ; Mc ; Spacing_Mark\ngc ; Me ; Enclosing_Mark\ngc ; Mn ; Nonspacing_Mark\ngc ; N ; Number # Nd | Nl | No\ngc ; Nd ; Decimal_Number ; digit\ngc ; Nl ; Letter_Number\ngc ; No ; Other_Number\ngc ; P ; Punctuation ; punct # Pc | Pd | Pe | Pf | Pi | Po | Ps\ngc ; Pc ; Connector_Punctuation\ngc ; Pd ; Dash_Punctuation\ngc ; Pe ; Close_Punctuation\ngc ; Pf ; Final_Punctuation\ngc ; Pi ; Initial_Punctuation\ngc ; Po ; Other_Punctuation\ngc ; Ps ; Open_Punctuation\ngc ; S ; Symbol # Sc | Sk | Sm | So\ngc ; Sc ; Currency_Symbol\ngc ; Sk ; Modifier_Symbol\ngc ; Sm ; Math_Symbol\ngc ; So ; Other_Symbol\ngc ; Z ; Separator # Zl | Zp | Zs\ngc ; Zl ; Line_Separator\ngc ; Zp ; Paragraph_Separator\ngc ; Zs ; Space_Separator\n# @missing: 0000..10FFFF; General_Category; Unassigned\n\n# Grapheme_Base (Gr_Base)\n\nGr_Base; N ; No ; F ; False\nGr_Base; Y ; Yes ; T ; True\n\n# Grapheme_Cluster_Break (GCB)\n\nGCB; CN ; Control\nGCB; CR ; CR\nGCB; EB ; E_Base\nGCB; EBG ; E_Base_GAZ\nGCB; EM ; E_Modifier\nGCB; EX ; Extend\nGCB; GAZ ; Glue_After_Zwj\nGCB; L ; L\nGCB; LF ; LF\nGCB; LV ; LV\nGCB; LVT ; LVT\nGCB; PP ; Prepend\nGCB; RI ; Regional_Indicator\nGCB; SM ; SpacingMark\nGCB; T ; T\nGCB; V ; V\nGCB; XX ; Other\nGCB; ZWJ ; ZWJ\n\n# Grapheme_Extend (Gr_Ext)\n\nGr_Ext; N ; No ; F ; False\nGr_Ext; Y ; Yes ; T ; True\n\n# Grapheme_Link (Gr_Link)\n\nGr_Link; N ; No ; F ; False\nGr_Link; Y ; Yes ; T ; True\n\n# Hangul_Syllable_Type (hst)\n\nhst; L ; Leading_Jamo\nhst; LV ; LV_Syllable\nhst; LVT ; LVT_Syllable\nhst; NA ; Not_Applicable\nhst; T ; Trailing_Jamo\nhst; V ; Vowel_Jamo\n\n# Hex_Digit (Hex)\n\nHex; N ; No ; F ; False\nHex; Y ; Yes ; T ; True\n\n# Hyphen (Hyphen)\n\nHyphen; N ; No ; F ; False\nHyphen; Y ; Yes ; T ; True\n\n# IDS_Binary_Operator (IDSB)\n\nIDSB; N ; No ; F ; False\nIDSB; Y ; Yes ; T ; True\n\n# IDS_Trinary_Operator (IDST)\n\nIDST; N ; No ; F ; False\nIDST; Y ; Yes ; T ; True\n\n# IDS_Unary_Operator (IDSU)\n\nIDSU; N ; No ; F ; False\nIDSU; Y ; Yes ; T ; True\n\n# ID_Compat_Math_Continue (ID_Compat_Math_Continue)\n\nID_Compat_Math_Continue; N ; No ; F ; False\nID_Compat_Math_Continue; Y ; Yes ; T ; True\n\n# ID_Compat_Math_Start (ID_Compat_Math_Start)\n\nID_Compat_Math_Start; N ; No ; F ; False\nID_Compat_Math_Start; Y ; Yes ; T ; True\n\n# ID_Continue (IDC)\n\nIDC; N ; No ; F ; False\nIDC; Y ; Yes ; T ; True\n\n# ID_Start (IDS)\n\nIDS; N ; No ; F ; False\nIDS; Y ; Yes ; T ; True\n\n# ISO_Comment (isc)\n\n# @missing: 0000..10FFFF; ISO_Comment; \n\n# Ideographic (Ideo)\n\nIdeo; N ; No ; F ; False\nIdeo; Y ; Yes ; T ; True\n\n# Indic_Conjunct_Break (InCB)\n\nInCB; Consonant ; Consonant\nInCB; Extend ; Extend\nInCB; Linker ; Linker\nInCB; None ; None\n\n# Indic_Positional_Category (InPC)\n\nInPC; Bottom ; Bottom\nInPC; Bottom_And_Left ; Bottom_And_Left\nInPC; Bottom_And_Right ; Bottom_And_Right\nInPC; Left ; Left\nInPC; Left_And_Right ; Left_And_Right\nInPC; NA ; Not_Applicable\nInPC; Overstruck ; Overstruck\nInPC; Right ; Right\nInPC; Top ; Top\nInPC; Top_And_Bottom ; Top_And_Bottom\nInPC; Top_And_Bottom_And_Left ; Top_And_Bottom_And_Left\nInPC; Top_And_Bottom_And_Right ; Top_And_Bottom_And_Right\nInPC; Top_And_Left ; Top_And_Left\nInPC; Top_And_Left_And_Right ; Top_And_Left_And_Right\nInPC; Top_And_Right ; Top_And_Right\nInPC; Visual_Order_Left ; Visual_Order_Left\n\n# Indic_Syllabic_Category (InSC)\n\nInSC; Avagraha ; Avagraha\nInSC; Bindu ; Bindu\nInSC; Brahmi_Joining_Number ; Brahmi_Joining_Number\nInSC; Cantillation_Mark ; Cantillation_Mark\nInSC; Consonant ; Consonant\nInSC; Consonant_Dead ; Consonant_Dead\nInSC; Consonant_Final ; Consonant_Final\nInSC; Consonant_Head_Letter ; Consonant_Head_Letter\nInSC; Consonant_Initial_Postfixed ; Consonant_Initial_Postfixed\nInSC; Consonant_Killer ; Consonant_Killer\nInSC; Consonant_Medial ; Consonant_Medial\nInSC; Consonant_Placeholder ; Consonant_Placeholder\nInSC; Consonant_Preceding_Repha ; Consonant_Preceding_Repha\nInSC; Consonant_Prefixed ; Consonant_Prefixed\nInSC; Consonant_Subjoined ; Consonant_Subjoined\nInSC; Consonant_Succeeding_Repha ; Consonant_Succeeding_Repha\nInSC; Consonant_With_Stacker ; Consonant_With_Stacker\nInSC; Gemination_Mark ; Gemination_Mark\nInSC; Invisible_Stacker ; Invisible_Stacker\nInSC; Joiner ; Joiner\nInSC; Modifying_Letter ; Modifying_Letter\nInSC; Non_Joiner ; Non_Joiner\nInSC; Nukta ; Nukta\nInSC; Number ; Number\nInSC; Number_Joiner ; Number_Joiner\nInSC; Other ; Other\nInSC; Pure_Killer ; Pure_Killer\nInSC; Register_Shifter ; Register_Shifter\nInSC; Reordering_Killer ; Reordering_Killer\nInSC; Syllable_Modifier ; Syllable_Modifier\nInSC; Tone_Letter ; Tone_Letter\nInSC; Tone_Mark ; Tone_Mark\nInSC; Virama ; Virama\nInSC; Visarga ; Visarga\nInSC; Vowel ; Vowel\nInSC; Vowel_Dependent ; Vowel_Dependent\nInSC; Vowel_Independent ; Vowel_Independent\n\n# Jamo_Short_Name (JSN)\n\nJSN; A ; A\nJSN; AE ; AE\nJSN; B ; B\nJSN; BB ; BB\nJSN; BS ; BS\nJSN; C ; C\nJSN; D ; D\nJSN; DD ; DD\nJSN; E ; E\nJSN; EO ; EO\nJSN; EU ; EU\nJSN; G ; G\nJSN; GG ; GG\nJSN; GS ; GS\nJSN; H ; H\nJSN; I ; I\nJSN; J ; J\nJSN; JJ ; JJ\nJSN; K ; K\nJSN; L ; L\nJSN; LB ; LB\nJSN; LG ; LG\nJSN; LH ; LH\nJSN; LM ; LM\nJSN; LP ; LP\nJSN; LS ; LS\nJSN; LT ; LT\nJSN; M ; M\nJSN; N ; N\nJSN; NG ; NG\nJSN; NH ; NH\nJSN; NJ ; NJ\nJSN; O ; O\nJSN; OE ; OE\nJSN; P ; P\nJSN; R ; R\nJSN; S ; S\nJSN; SS ; SS\nJSN; T ; T\nJSN; U ; U\nJSN; WA ; WA\nJSN; WAE ; WAE\nJSN; WE ; WE\nJSN; WEO ; WEO\nJSN; WI ; WI\nJSN; YA ; YA\nJSN; YAE ; YAE\nJSN; YE ; YE\nJSN; YEO ; YEO\nJSN; YI ; YI\nJSN; YO ; YO\nJSN; YU ; YU\n# @missing: 0000..10FFFF; Jamo_Short_Name; \n\n# Join_Control (Join_C)\n\nJoin_C; N ; No ; F ; False\nJoin_C; Y ; Yes ; T ; True\n\n# Joining_Group (jg)\n\njg ; African_Feh ; African_Feh\njg ; African_Noon ; African_Noon\njg ; African_Qaf ; African_Qaf\njg ; Ain ; Ain\njg ; Alaph ; Alaph\njg ; Alef ; Alef\njg ; Beh ; Beh\njg ; Beth ; Beth\njg ; Burushaski_Yeh_Barree ; Burushaski_Yeh_Barree\njg ; Dal ; Dal\njg ; Dalath_Rish ; Dalath_Rish\njg ; E ; E\njg ; Farsi_Yeh ; Farsi_Yeh\njg ; Fe ; Fe\njg ; Feh ; Feh\njg ; Final_Semkath ; Final_Semkath\njg ; Gaf ; Gaf\njg ; Gamal ; Gamal\njg ; Hah ; Hah\njg ; Hanifi_Rohingya_Kinna_Ya ; Hanifi_Rohingya_Kinna_Ya\njg ; Hanifi_Rohingya_Pa ; Hanifi_Rohingya_Pa\njg ; He ; He\njg ; Heh ; Heh\njg ; Heh_Goal ; Heh_Goal\njg ; Heth ; Heth\njg ; Kaf ; Kaf\njg ; Kaph ; Kaph\njg ; Kashmiri_Yeh ; Kashmiri_Yeh\njg ; Khaph ; Khaph\njg ; Knotted_Heh ; Knotted_Heh\njg ; Lam ; Lam\njg ; Lamadh ; Lamadh\njg ; Malayalam_Bha ; Malayalam_Bha\njg ; Malayalam_Ja ; Malayalam_Ja\njg ; Malayalam_Lla ; Malayalam_Lla\njg ; Malayalam_Llla ; Malayalam_Llla\njg ; Malayalam_Nga ; Malayalam_Nga\njg ; Malayalam_Nna ; Malayalam_Nna\njg ; Malayalam_Nnna ; Malayalam_Nnna\njg ; Malayalam_Nya ; Malayalam_Nya\njg ; Malayalam_Ra ; Malayalam_Ra\njg ; Malayalam_Ssa ; Malayalam_Ssa\njg ; Malayalam_Tta ; Malayalam_Tta\njg ; Manichaean_Aleph ; Manichaean_Aleph\njg ; Manichaean_Ayin ; Manichaean_Ayin\njg ; Manichaean_Beth ; Manichaean_Beth\njg ; Manichaean_Daleth ; Manichaean_Daleth\njg ; Manichaean_Dhamedh ; Manichaean_Dhamedh\njg ; Manichaean_Five ; Manichaean_Five\njg ; Manichaean_Gimel ; Manichaean_Gimel\njg ; Manichaean_Heth ; Manichaean_Heth\njg ; Manichaean_Hundred ; Manichaean_Hundred\njg ; Manichaean_Kaph ; Manichaean_Kaph\njg ; Manichaean_Lamedh ; Manichaean_Lamedh\njg ; Manichaean_Mem ; Manichaean_Mem\njg ; Manichaean_Nun ; Manichaean_Nun\njg ; Manichaean_One ; Manichaean_One\njg ; Manichaean_Pe ; Manichaean_Pe\njg ; Manichaean_Qoph ; Manichaean_Qoph\njg ; Manichaean_Resh ; Manichaean_Resh\njg ; Manichaean_Sadhe ; Manichaean_Sadhe\njg ; Manichaean_Samekh ; Manichaean_Samekh\njg ; Manichaean_Taw ; Manichaean_Taw\njg ; Manichaean_Ten ; Manichaean_Ten\njg ; Manichaean_Teth ; Manichaean_Teth\njg ; Manichaean_Thamedh ; Manichaean_Thamedh\njg ; Manichaean_Twenty ; Manichaean_Twenty\njg ; Manichaean_Waw ; Manichaean_Waw\njg ; Manichaean_Yodh ; Manichaean_Yodh\njg ; Manichaean_Zayin ; Manichaean_Zayin\njg ; Meem ; Meem\njg ; Mim ; Mim\njg ; No_Joining_Group ; No_Joining_Group\njg ; Noon ; Noon\njg ; Nun ; Nun\njg ; Nya ; Nya\njg ; Pe ; Pe\njg ; Qaf ; Qaf\njg ; Qaph ; Qaph\njg ; Reh ; Reh\njg ; Reversed_Pe ; Reversed_Pe\njg ; Rohingya_Yeh ; Rohingya_Yeh\njg ; Sad ; Sad\njg ; Sadhe ; Sadhe\njg ; Seen ; Seen\njg ; Semkath ; Semkath\njg ; Shin ; Shin\njg ; Straight_Waw ; Straight_Waw\njg ; Swash_Kaf ; Swash_Kaf\njg ; Syriac_Waw ; Syriac_Waw\njg ; Tah ; Tah\njg ; Taw ; Taw\njg ; Teh_Marbuta ; Teh_Marbuta\njg ; Teh_Marbuta_Goal ; Teh_Marbuta_Goal ; Hamza_On_Heh_Goal\njg ; Teth ; Teth\njg ; Thin_Noon ; Thin_Noon\njg ; Thin_Yeh ; Thin_Yeh\njg ; Vertical_Tail ; Vertical_Tail\njg ; Waw ; Waw\njg ; Yeh ; Yeh\njg ; Yeh_Barree ; Yeh_Barree\njg ; Yeh_With_Tail ; Yeh_With_Tail\njg ; Yudh ; Yudh\njg ; Yudh_He ; Yudh_He\njg ; Zain ; Zain\njg ; Zhain ; Zhain\n\n# Joining_Type (jt)\n\njt ; C ; Join_Causing\njt ; D ; Dual_Joining\njt ; L ; Left_Joining\njt ; R ; Right_Joining\njt ; T ; Transparent\njt ; U ; Non_Joining\n\n# Line_Break (lb)\n\nlb ; AI ; Ambiguous\nlb ; AK ; Aksara\nlb ; AL ; Alphabetic\nlb ; AP ; Aksara_Prebase\nlb ; AS ; Aksara_Start\nlb ; B2 ; Break_Both\nlb ; BA ; Break_After\nlb ; BB ; Break_Before\nlb ; BK ; Mandatory_Break\nlb ; CB ; Contingent_Break\nlb ; CJ ; Conditional_Japanese_Starter\nlb ; CL ; Close_Punctuation\nlb ; CM ; Combining_Mark\nlb ; CP ; Close_Parenthesis\nlb ; CR ; Carriage_Return\nlb ; EB ; E_Base\nlb ; EM ; E_Modifier\nlb ; EX ; Exclamation\nlb ; GL ; Glue\nlb ; H2 ; H2\nlb ; H3 ; H3\nlb ; HH ; Unambiguous_Hyphen\nlb ; HL ; Hebrew_Letter\nlb ; HY ; Hyphen\nlb ; ID ; Ideographic\nlb ; IN ; Inseparable ; Inseperable\nlb ; IS ; Infix_Numeric\nlb ; JL ; JL\nlb ; JT ; JT\nlb ; JV ; JV\nlb ; LF ; Line_Feed\nlb ; NL ; Next_Line\nlb ; NS ; Nonstarter\nlb ; NU ; Numeric\nlb ; OP ; Open_Punctuation\nlb ; PO ; Postfix_Numeric\nlb ; PR ; Prefix_Numeric\nlb ; QU ; Quotation\nlb ; RI ; Regional_Indicator\nlb ; SA ; Complex_Context\nlb ; SG ; Surrogate\nlb ; SP ; Space\nlb ; SY ; Break_Symbols\nlb ; VF ; Virama_Final\nlb ; VI ; Virama\nlb ; WJ ; Word_Joiner\nlb ; XX ; Unknown\nlb ; ZW ; ZWSpace\nlb ; ZWJ ; ZWJ\n\n# Logical_Order_Exception (LOE)\n\nLOE; N ; No ; F ; False\nLOE; Y ; Yes ; T ; True\n\n# Lowercase (Lower)\n\nLower; N ; No ; F ; False\nLower; Y ; Yes ; T ; True\n\n# Lowercase_Mapping (lc)\n\n# @missing: 0000..10FFFF; Lowercase_Mapping; \n\n# Math (Math)\n\nMath; N ; No ; F ; False\nMath; Y ; Yes ; T ; True\n\n# Modifier_Combining_Mark (MCM)\n\nMCM; N ; No ; F ; False\nMCM; Y ; Yes ; T ; True\n\n# NFC_Quick_Check (NFC_QC)\n\nNFC_QC; M ; Maybe\nNFC_QC; N ; No\nNFC_QC; Y ; Yes\n\n# NFD_Quick_Check (NFD_QC)\n\nNFD_QC; N ; No\nNFD_QC; Y ; Yes\n\n# NFKC_Casefold (NFKC_CF)\n\n\n# NFKC_Quick_Check (NFKC_QC)\n\nNFKC_QC; M ; Maybe\nNFKC_QC; N ; No\nNFKC_QC; Y ; Yes\n\n# NFKC_Simple_Casefold (NFKC_SCF)\n\n\n# NFKD_Quick_Check (NFKD_QC)\n\nNFKD_QC; N ; No\nNFKD_QC; Y ; Yes\n\n# Name (na)\n\n# @missing: 0000..10FFFF; Name; \n\n# Name_Alias (Name_Alias)\n\n# @missing: 0000..10FFFF; Name_Alias; \n\n# Noncharacter_Code_Point (NChar)\n\nNChar; N ; No ; F ; False\nNChar; Y ; Yes ; T ; True\n\n# Numeric_Type (nt)\n\nnt ; De ; Decimal\nnt ; Di ; Digit\nnt ; None ; None\nnt ; Nu ; Numeric\n\n# Numeric_Value (nv)\n\n# @missing: 0000..10FFFF; Numeric_Value; NaN\n\n# Other_Alphabetic (OAlpha)\n\nOAlpha; N ; No ; F ; False\nOAlpha; Y ; Yes ; T ; True\n\n# Other_Default_Ignorable_Code_Point (ODI)\n\nODI; N ; No ; F ; False\nODI; Y ; Yes ; T ; True\n\n# Other_Grapheme_Extend (OGr_Ext)\n\nOGr_Ext; N ; No ; F ; False\nOGr_Ext; Y ; Yes ; T ; True\n\n# Other_ID_Continue (OIDC)\n\nOIDC; N ; No ; F ; False\nOIDC; Y ; Yes ; T ; True\n\n# Other_ID_Start (OIDS)\n\nOIDS; N ; No ; F ; False\nOIDS; Y ; Yes ; T ; True\n\n# Other_Lowercase (OLower)\n\nOLower; N ; No ; F ; False\nOLower; Y ; Yes ; T ; True\n\n# Other_Math (OMath)\n\nOMath; N ; No ; F ; False\nOMath; Y ; Yes ; T ; True\n\n# Other_Uppercase (OUpper)\n\nOUpper; N ; No ; F ; False\nOUpper; Y ; Yes ; T ; True\n\n# Pattern_Syntax (Pat_Syn)\n\nPat_Syn; N ; No ; F ; False\nPat_Syn; Y ; Yes ; T ; True\n\n# Pattern_White_Space (Pat_WS)\n\nPat_WS; N ; No ; F ; False\nPat_WS; Y ; Yes ; T ; True\n\n# Prepended_Concatenation_Mark (PCM)\n\nPCM; N ; No ; F ; False\nPCM; Y ; Yes ; T ; True\n\n# Quotation_Mark (QMark)\n\nQMark; N ; No ; F ; False\nQMark; Y ; Yes ; T ; True\n\n# Radical (Radical)\n\nRadical; N ; No ; F ; False\nRadical; Y ; Yes ; T ; True\n\n# Regional_Indicator (RI)\n\nRI ; N ; No ; F ; False\nRI ; Y ; Yes ; T ; True\n\n# Script (sc)\n\nsc ; Adlm ; Adlam\nsc ; Aghb ; Caucasian_Albanian\nsc ; Ahom ; Ahom\nsc ; Arab ; Arabic\nsc ; Armi ; Imperial_Aramaic\nsc ; Armn ; Armenian\nsc ; Avst ; Avestan\nsc ; Bali ; Balinese\nsc ; Bamu ; Bamum\nsc ; Bass ; Bassa_Vah\nsc ; Batk ; Batak\nsc ; Beng ; Bengali\nsc ; Berf ; Beria_Erfe\nsc ; Bhks ; Bhaiksuki\nsc ; Bopo ; Bopomofo\nsc ; Brah ; Brahmi\nsc ; Brai ; Braille\nsc ; Bugi ; Buginese\nsc ; Buhd ; Buhid\nsc ; Cakm ; Chakma\nsc ; Cans ; Canadian_Aboriginal\nsc ; Cari ; Carian\nsc ; Cham ; Cham\nsc ; Cher ; Cherokee\nsc ; Chrs ; Chorasmian\nsc ; Copt ; Coptic ; Qaac\nsc ; Cpmn ; Cypro_Minoan\nsc ; Cprt ; Cypriot\nsc ; Cyrl ; Cyrillic\nsc ; Deva ; Devanagari\nsc ; Diak ; Dives_Akuru\nsc ; Dogr ; Dogra\nsc ; Dsrt ; Deseret\nsc ; Dupl ; Duployan\nsc ; Egyp ; Egyptian_Hieroglyphs\nsc ; Elba ; Elbasan\nsc ; Elym ; Elymaic\nsc ; Ethi ; Ethiopic\nsc ; Gara ; Garay\nsc ; Geor ; Georgian\nsc ; Glag ; Glagolitic\nsc ; Gong ; Gunjala_Gondi\nsc ; Gonm ; Masaram_Gondi\nsc ; Goth ; Gothic\nsc ; Gran ; Grantha\nsc ; Grek ; Greek\nsc ; Gujr ; Gujarati\nsc ; Gukh ; Gurung_Khema\nsc ; Guru ; Gurmukhi\nsc ; Hang ; Hangul\nsc ; Hani ; Han\nsc ; Hano ; Hanunoo\nsc ; Hatr ; Hatran\nsc ; Hebr ; Hebrew\nsc ; Hira ; Hiragana\nsc ; Hluw ; Anatolian_Hieroglyphs\nsc ; Hmng ; Pahawh_Hmong\nsc ; Hmnp ; Nyiakeng_Puachue_Hmong\nsc ; Hrkt ; Katakana_Or_Hiragana\nsc ; Hung ; Old_Hungarian\nsc ; Ital ; Old_Italic\nsc ; Java ; Javanese\nsc ; Kali ; Kayah_Li\nsc ; Kana ; Katakana\nsc ; Kawi ; Kawi\nsc ; Khar ; Kharoshthi\nsc ; Khmr ; Khmer\nsc ; Khoj ; Khojki\nsc ; Kits ; Khitan_Small_Script\nsc ; Knda ; Kannada\nsc ; Krai ; Kirat_Rai\nsc ; Kthi ; Kaithi\nsc ; Lana ; Tai_Tham\nsc ; Laoo ; Lao\nsc ; Latn ; Latin\nsc ; Lepc ; Lepcha\nsc ; Limb ; Limbu\nsc ; Lina ; Linear_A\nsc ; Linb ; Linear_B\nsc ; Lisu ; Lisu\nsc ; Lyci ; Lycian\nsc ; Lydi ; Lydian\nsc ; Mahj ; Mahajani\nsc ; Maka ; Makasar\nsc ; Mand ; Mandaic\nsc ; Mani ; Manichaean\nsc ; Marc ; Marchen\nsc ; Medf ; Medefaidrin\nsc ; Mend ; Mende_Kikakui\nsc ; Merc ; Meroitic_Cursive\nsc ; Mero ; Meroitic_Hieroglyphs\nsc ; Mlym ; Malayalam\nsc ; Modi ; Modi\nsc ; Mong ; Mongolian\nsc ; Mroo ; Mro\nsc ; Mtei ; Meetei_Mayek\nsc ; Mult ; Multani\nsc ; Mymr ; Myanmar\nsc ; Nagm ; Nag_Mundari\nsc ; Nand ; Nandinagari\nsc ; Narb ; Old_North_Arabian\nsc ; Nbat ; Nabataean\nsc ; Newa ; Newa\nsc ; Nkoo ; Nko\nsc ; Nshu ; Nushu\nsc ; Ogam ; Ogham\nsc ; Olck ; Ol_Chiki\nsc ; Onao ; Ol_Onal\nsc ; Orkh ; Old_Turkic\nsc ; Orya ; Oriya\nsc ; Osge ; Osage\nsc ; Osma ; Osmanya\nsc ; Ougr ; Old_Uyghur\nsc ; Palm ; Palmyrene\nsc ; Pauc ; Pau_Cin_Hau\nsc ; Perm ; Old_Permic\nsc ; Phag ; Phags_Pa\nsc ; Phli ; Inscriptional_Pahlavi\nsc ; Phlp ; Psalter_Pahlavi\nsc ; Phnx ; Phoenician\nsc ; Plrd ; Miao\nsc ; Prti ; Inscriptional_Parthian\nsc ; Rjng ; Rejang\nsc ; Rohg ; Hanifi_Rohingya\nsc ; Runr ; Runic\nsc ; Samr ; Samaritan\nsc ; Sarb ; Old_South_Arabian\nsc ; Saur ; Saurashtra\nsc ; Sgnw ; SignWriting\nsc ; Shaw ; Shavian\nsc ; Shrd ; Sharada\nsc ; Sidd ; Siddham\nsc ; Sidt ; Sidetic\nsc ; Sind ; Khudawadi\nsc ; Sinh ; Sinhala\nsc ; Sogd ; Sogdian\nsc ; Sogo ; Old_Sogdian\nsc ; Sora ; Sora_Sompeng\nsc ; Soyo ; Soyombo\nsc ; Sund ; Sundanese\nsc ; Sunu ; Sunuwar\nsc ; Sylo ; Syloti_Nagri\nsc ; Syrc ; Syriac\nsc ; Tagb ; Tagbanwa\nsc ; Takr ; Takri\nsc ; Tale ; Tai_Le\nsc ; Talu ; New_Tai_Lue\nsc ; Taml ; Tamil\nsc ; Tang ; Tangut\nsc ; Tavt ; Tai_Viet\nsc ; Tayo ; Tai_Yo\nsc ; Telu ; Telugu\nsc ; Tfng ; Tifinagh\nsc ; Tglg ; Tagalog\nsc ; Thaa ; Thaana\nsc ; Thai ; Thai\nsc ; Tibt ; Tibetan\nsc ; Tirh ; Tirhuta\nsc ; Tnsa ; Tangsa\nsc ; Todr ; Todhri\nsc ; Tols ; Tolong_Siki\nsc ; Toto ; Toto\nsc ; Tutg ; Tulu_Tigalari\nsc ; Ugar ; Ugaritic\nsc ; Vaii ; Vai\nsc ; Vith ; Vithkuqi\nsc ; Wara ; Warang_Citi\nsc ; Wcho ; Wancho\nsc ; Xpeo ; Old_Persian\nsc ; Xsux ; Cuneiform\nsc ; Yezi ; Yezidi\nsc ; Yiii ; Yi\nsc ; Zanb ; Zanabazar_Square\nsc ; Zinh ; Inherited ; Qaai\nsc ; Zyyy ; Common\nsc ; Zzzz ; Unknown\n\n# Script_Extensions (scx)\n\n\n# Sentence_Break (SB)\n\nSB ; AT ; ATerm\nSB ; CL ; Close\nSB ; CR ; CR\nSB ; EX ; Extend\nSB ; FO ; Format\nSB ; LE ; OLetter\nSB ; LF ; LF\nSB ; LO ; Lower\nSB ; NU ; Numeric\nSB ; SC ; SContinue\nSB ; SE ; Sep\nSB ; SP ; Sp\nSB ; ST ; STerm\nSB ; UP ; Upper\nSB ; XX ; Other\n\n# Sentence_Terminal (STerm)\n\nSTerm; N ; No ; F ; False\nSTerm; Y ; Yes ; T ; True\n\n# Simple_Case_Folding (scf)\n\n# @missing: 0000..10FFFF; Simple_Case_Folding; \n\n# Simple_Lowercase_Mapping (slc)\n\n# @missing: 0000..10FFFF; Simple_Lowercase_Mapping; \n\n# Simple_Titlecase_Mapping (stc)\n\n# @missing: 0000..10FFFF; Simple_Titlecase_Mapping; \n\n# Simple_Uppercase_Mapping (suc)\n\n# @missing: 0000..10FFFF; Simple_Uppercase_Mapping; \n\n# Soft_Dotted (SD)\n\nSD ; N ; No ; F ; False\nSD ; Y ; Yes ; T ; True\n\n# Terminal_Punctuation (Term)\n\nTerm; N ; No ; F ; False\nTerm; Y ; Yes ; T ; True\n\n# Titlecase_Mapping (tc)\n\n# @missing: 0000..10FFFF; Titlecase_Mapping; \n\n# Unicode_1_Name (na1)\n\n# @missing: 0000..10FFFF; Unicode_1_Name; \n\n# Unified_Ideograph (UIdeo)\n\nUIdeo; N ; No ; F ; False\nUIdeo; Y ; Yes ; T ; True\n\n# Uppercase (Upper)\n\nUpper; N ; No ; F ; False\nUpper; Y ; Yes ; T ; True\n\n# Uppercase_Mapping (uc)\n\n# @missing: 0000..10FFFF; Uppercase_Mapping; \n\n# Variation_Selector (VS)\n\nVS ; N ; No ; F ; False\nVS ; Y ; Yes ; T ; True\n\n# Vertical_Orientation (vo)\n\nvo ; R ; Rotated\nvo ; Tr ; Transformed_Rotated\nvo ; Tu ; Transformed_Upright\nvo ; U ; Upright\n\n# White_Space (WSpace)\n\nWSpace; N ; No ; F ; False\nWSpace; Y ; Yes ; T ; True\n\n# Word_Break (WB)\n\nWB ; CR ; CR\nWB ; DQ ; Double_Quote\nWB ; EB ; E_Base\nWB ; EBG ; E_Base_GAZ\nWB ; EM ; E_Modifier\nWB ; EX ; ExtendNumLet\nWB ; Extend ; Extend\nWB ; FO ; Format\nWB ; GAZ ; Glue_After_Zwj\nWB ; HL ; Hebrew_Letter\nWB ; KA ; Katakana\nWB ; LE ; ALetter\nWB ; LF ; LF\nWB ; MB ; MidNumLet\nWB ; ML ; MidLetter\nWB ; MN ; MidNum\nWB ; NL ; Newline\nWB ; NU ; Numeric\nWB ; RI ; Regional_Indicator\nWB ; SQ ; Single_Quote\nWB ; WSegSpace ; WSegSpace\nWB ; XX ; Other\nWB ; ZWJ ; ZWJ\n\n# XID_Continue (XIDC)\n\nXIDC; N ; No ; F ; False\nXIDC; Y ; Yes ; T ; True\n\n# XID_Start (XIDS)\n\nXIDS; N ; No ; F ; False\nXIDS; Y ; Yes ; T ; True\n\n# cjkAccountingNumeric (cjkAccountingNumeric)\n\n# @missing: 0000..10FFFF; cjkAccountingNumeric; NaN\n\n# cjkCompatibilityVariant (cjkCompatibilityVariant)\n\n# @missing: 0000..10FFFF; cjkCompatibilityVariant; \n\n# cjkIICore (cjkIICore)\n\n# @missing: 0000..10FFFF; cjkIICore; \n\n# cjkIRG_GSource (cjkIRG_GSource)\n\n# @missing: 0000..10FFFF; cjkIRG_GSource; \n\n# cjkIRG_HSource (cjkIRG_HSource)\n\n# @missing: 0000..10FFFF; cjkIRG_HSource; \n\n# cjkIRG_JSource (cjkIRG_JSource)\n\n# @missing: 0000..10FFFF; cjkIRG_JSource; \n\n# cjkIRG_KPSource (cjkIRG_KPSource)\n\n# @missing: 0000..10FFFF; cjkIRG_KPSource; \n\n# cjkIRG_KSource (cjkIRG_KSource)\n\n# @missing: 0000..10FFFF; cjkIRG_KSource; \n\n# cjkIRG_MSource (cjkIRG_MSource)\n\n# @missing: 0000..10FFFF; cjkIRG_MSource; \n\n# cjkIRG_SSource (cjkIRG_SSource)\n\n# @missing: 0000..10FFFF; cjkIRG_SSource; \n\n# cjkIRG_TSource (cjkIRG_TSource)\n\n# @missing: 0000..10FFFF; cjkIRG_TSource; \n\n# cjkIRG_UKSource (cjkIRG_UKSource)\n\n# @missing: 0000..10FFFF; cjkIRG_UKSource; \n\n# cjkIRG_USource (cjkIRG_USource)\n\n# @missing: 0000..10FFFF; cjkIRG_USource; \n\n# cjkIRG_VSource (cjkIRG_VSource)\n\n# @missing: 0000..10FFFF; cjkIRG_VSource; \n\n# cjkOtherNumeric (cjkOtherNumeric)\n\n# @missing: 0000..10FFFF; cjkOtherNumeric; NaN\n\n# cjkPrimaryNumeric (cjkPrimaryNumeric)\n\n# @missing: 0000..10FFFF; cjkPrimaryNumeric; NaN\n\n# cjkRSUnicode (cjkRSUnicode)\n\n# @missing: 0000..10FFFF; cjkRSUnicode; \n\n# kEH_Cat (kEH_Cat)\n\n# @missing: 0000..10FFFF; kEH_Cat; \n\n# kEH_Desc (kEH_Desc)\n\n# @missing: 0000..10FFFF; kEH_Desc; \n\n# kEH_HG (kEH_HG)\n\n# @missing: 0000..10FFFF; kEH_HG; \n\n# kEH_IFAO (kEH_IFAO)\n\n# @missing: 0000..10FFFF; kEH_IFAO; \n\n# kEH_JSesh (kEH_JSesh)\n\n# @missing: 0000..10FFFF; kEH_JSesh; \n\n# kEH_NoMirror (kEH_NoMirror)\n\nkEH_NoMirror; N ; No ; F ; False\nkEH_NoMirror; Y ; Yes ; T ; True\n\n# kEH_NoRotate (kEH_NoRotate)\n\nkEH_NoRotate; N ; No ; F ; False\nkEH_NoRotate; Y ; Yes ; T ; True\n\n# kMandarin (cjkMandarin)\n\n# @missing: 0000..10FFFF; kMandarin; \n\n# kTotalStrokes (cjkTotalStrokes)\n\n# @missing: 0000..10FFFF; kTotalStrokes; \n\n# kUnihanCore2020 (cjkUnihanCore2020)\n\n# @missing: 0000..10FFFF; kUnihanCore2020; \n\n# EOF\n" }, { "path": "lib/elixir/unicode/ScriptExtensions.txt", "content": "# ScriptExtensions-17.0.0.txt\n# Date: 2025-08-01, 21:42:00 GMT\n# © 2025 Unicode®, Inc.\n# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.\n# For terms of use and license, see https://www.unicode.org/terms_of_use.html\n#\n# Unicode Character Database\n# For documentation, see https://www.unicode.org/reports/tr44/\n#\n# The Script_Extensions property indicates which characters are commonly used\n# with more than one script, but with a limited number of scripts.\n# For each code point, there is one or more property values. Each such value is a Script property value.\n# For more information, see:\n# UAX #24, Unicode Script Property: https://www.unicode.org/reports/tr24/\n# Especially the sections:\n# https://www.unicode.org/reports/tr24/#Assignment_Script_Values\n# https://www.unicode.org/reports/tr24/#Assignment_ScriptX_Values\n#\n# Each Script_Extensions value in this file consists of a set\n# of one or more abbreviated Script property values. The ordering of the\n# values in that set is not material, but for stability in presentation\n# it is given here as alphabetical.\n#\n# All code points not explicitly listed for Script_Extensions\n# have as their value the corresponding Script property value.\n#\n# @missing: 0000..10FFFF;