[new-repo] Add pylint package as per OSRB process.
Adding all the directories from the github repo except doc/ and elisp directory as per fxbug.dev/78609.
Bug: 68256
Change-Id: I8f9c107e82d2828c4e6cbaf24fad415819e416ea
diff --git a/.copyrite_aliases b/.copyrite_aliases
new file mode 100644
index 0000000..191fbe8
--- /dev/null
+++ b/.copyrite_aliases
@@ -0,0 +1,111 @@
+[
+ {
+ "mails": [
+ "cpopa@cloudbasesolutions.com",
+ "pcmanticore@gmail.com"
+ ],
+ "authoritative_mail": "pcmanticore@gmail.com",
+ "name": "Claudiu Popa"
+ },
+ {
+ "mails": [
+ "pierre.sassoulas@gmail.com",
+ "pierre.sassoulas@cea.fr",
+ "pierre.sassoulas@wisebim.fr"
+ ],
+ "authoritative_mail": "pierre.sassoulas@gmail.com",
+ "name": "Pierre Sassoulas"
+ },
+ {
+ "mails": [
+ "alexandre.fayolle@logilab.fr",
+ "emile.anclin@logilab.fr",
+ "david.douard@logilab.fr",
+ "laura.medioni@logilab.fr",
+ "anthony.truchet@logilab.fr",
+ "alain.leufroy@logilab.fr",
+ "julien.cristau@logilab.fr",
+ "Adrien.DiMascio@logilab.fr",
+ "emile@crater.logilab.fr",
+ "sylvain.thenault@logilab.fr",
+ "pierre-yves.david@logilab.fr",
+ "nicolas.chauvat@logilab.fr",
+ "afayolle.ml@free.fr",
+ "aurelien.campeas@logilab.fr",
+ "charles.hebert@logilab.fr",
+ "julien.jehannet@logilab.fr",
+ "lmedioni@logilab.fr"
+ ],
+ "authoritative_mail": "contact@logilab.fr",
+ "name": "LOGILAB S.A. (Paris, FRANCE)"
+ },
+ {
+ "mails": [
+ "moylop260@vauxoo.com"
+ ],
+ "name": "Moises Lopez",
+ "authoritative_mail": "moylop260@vauxoo.com"
+ },
+ {
+ "mails": [
+ "nathaniel@google.com",
+ "mbp@google.com",
+ "tmarek@google.com",
+ "shlomme@gmail.com",
+ "balparda@google.com",
+ "dlindquist@google.com"
+ ],
+ "name": "Google, Inc."
+ },
+ {
+ "mails": [
+ "ashley@awhetter.co.uk",
+ "awhetter.2011@my.bristol.ac.uk",
+ "asw@dneg.com",
+ "AWhetter@users.noreply.github.com"
+ ],
+ "name": "Ashley Whetter",
+ "authoritative_mail": "ashley@awhetter.co.uk"
+ },
+ {
+ "mails": [
+ "ville.skytta@iki.fi",
+ "ville.skytta@upcloud.com"
+ ],
+ "authoritative_mail": "ville.skytta@iki.fi",
+ "name": "Ville Skyttä"
+ },
+ {
+ "mails": [
+ "ubuntu@ip-172-31-89-59.ec2.internal",
+ "eli88fine@gmail.com",
+ "ejfine@gmail.com"
+ ],
+ "authoritative_mail": "ejfine@gmail.com",
+ "name": "Eli Fine"
+ },
+ {
+ "mails": [
+ "andi.finkler@gmail.com",
+ "3929834+DudeNr33@users.noreply.github.com"
+ ],
+ "authoritative_mail": "andi.finkler@gmail.com",
+ "name": "Andreas Finkler"
+ },
+ {
+ "mails": [
+ "matusvalo@users.noreply.github.com",
+ "matusvalo@gmail.com"
+ ],
+ "authoritative_mail": "matusvalo@users.noreply.github.com",
+ "name": "Matus Valo"
+ },
+ {
+ "mails": [
+ "66853113+pre-commit-ci[bot]@users.noreply.github.com",
+ "49699333+dependabot[bot]@users.noreply.github.com"
+ ],
+ "authoritative_mail": "bot@noreply.github.com",
+ "name": "bot"
+ }
+]
diff --git a/.coveragerc b/.coveragerc
new file mode 100644
index 0000000..3e7af77
--- /dev/null
+++ b/.coveragerc
@@ -0,0 +1,19 @@
+[paths]
+source =
+ pylint
+
+[report]
+include =
+ pylint/*
+omit =
+ */test/*
+exclude_lines =
+ # Re-enable default pragma
+ pragma: no cover
+
+ # Debug-only code
+ def __repr__
+
+ # Type checking code not executed during pytest runs
+ if TYPE_CHECKING:
+ @overload
diff --git a/.flake8 b/.flake8
new file mode 100644
index 0000000..9a701d7
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,7 @@
+[flake8]
+ignore =
+ E203, W503, # Incompatible with black see https://github.com/ambv/black/issues/315
+ E501, # Lot of lines too long right now
+
+max-line-length=88
+max-complexity=39
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
new file mode 100644
index 0000000..e3c97eb
--- /dev/null
+++ b/.github/CONTRIBUTING.md
@@ -0,0 +1,2 @@
+Please read the
+[contribute doc](https://github.com/PyCQA/pylint/blob/master/doc/development_guide/contribute.rst).
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..2d3f2d2
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+tidelift: "pypi/pylint"
diff --git a/.github/ISSUE_TEMPLATE/1_Bug_report.md b/.github/ISSUE_TEMPLATE/1_Bug_report.md
new file mode 100644
index 0000000..88a20e0
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/1_Bug_report.md
@@ -0,0 +1,63 @@
+---
+name: Bug report
+about: Report a bug in pylint
+---
+
+<!--
+ Hi there! Thank you for discovering and submitting an issue.
+
+ Before you submit this, make sure that the issue doesn't already exist
+ or if it is not closed.
+
+ Is your issue fixed on the preview release?:
+ pip install pylint astroid --pre -U
+-->
+
+### Steps to reproduce
+
+<!--
+Given a file `a.py`:
+```python
+# (Disable message unrelated to the bug)
+# pylint: disable=missing-docstring,...
+
+```
+
+Given multiple files:
+```
+__init__.py
+a.py
+module\
+ __init__.py
+ b.py
+ c.py
+```
+-->
+
+### Current behavior
+
+<!--
+Result of `pylint a.py`:
+```
+
+```
+-->
+
+### Expected behavior
+
+### pylint --version output
+
+Result of `pylint --version` output:
+
+```
+
+```
+
+<!--
+Additional dependencies:
+```
+pandas==0.23.2
+marshmallow==3.10.0
+...
+```
+-->
diff --git a/.github/ISSUE_TEMPLATE/2_Feature_request.md b/.github/ISSUE_TEMPLATE/2_Feature_request.md
new file mode 100644
index 0000000..1a0a398
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/2_Feature_request.md
@@ -0,0 +1,23 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+---
+
+<!--
+ Hi there! Thank you for wanting to make pylint better.
+
+ Before you submit this, make sure that this feature wasn't
+ already requested or if it is not already implemented in the master branch.
+-->
+
+### Is your feature request related to a problem? Please describe
+
+A clear and concise description of what the problem is.
+
+### Describe the solution you'd like
+
+A clear and concise description of what you want to happen.
+
+### Additional context
+
+Add any other context about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/3_Question.md b/.github/ISSUE_TEMPLATE/3_Question.md
new file mode 100644
index 0000000..7e9187d
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/3_Question.md
@@ -0,0 +1,8 @@
+---
+name: Support question
+about:
+ Questions about pylint that are not covered in the documentation
+ (https://pylint.pycqa.org/en/latest/)
+---
+
+## Question
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000..05a2447
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,39 @@
+<!--
+
+Thank you for submitting a PR to pylint!
+
+To ease the process of reviewing your PR, do make sure to complete the following boxes.
+
+You can also read more about contributing to pylint in this document:
+https://github.com/PyCQA/pylint/blob/master/doc/development_guide/contribute.rst#repository
+-->
+
+## Steps
+
+- [ ] Add yourself to CONTRIBUTORS if you are a new contributor.
+- [ ] Add a ChangeLog entry describing what your PR does.
+- [ ] If it's a new feature or an important bug fix, add a What's New entry in
+ `doc/whatsnew/<current release.rst>`.
+- [ ] Write a good description on what the PR does.
+
+## Description
+
+## Type of Changes
+
+<!-- Leave the corresponding lines for the applicable type of change: -->
+
+| | Type |
+| --- | ---------------------- |
+| ✓ | :bug: Bug fix |
+| ✓ | :sparkles: New feature |
+| ✓ | :hammer: Refactoring |
+| ✓ | :scroll: Docs |
+
+## Related Issue
+
+<!--
+If this PR fixes a particular issue, use the following to automatically close that issue
+once this PR gets merged:
+
+Closes #XXX
+-->
diff --git a/.github/SECURITY.md b/.github/SECURITY.md
new file mode 100644
index 0000000..bbe6fc2
--- /dev/null
+++ b/.github/SECURITY.md
@@ -0,0 +1 @@
+Coordinated Disclosure Plan: https://tidelift.com/security
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..877047a
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,19 @@
+version: 2
+updates:
+ - package-ecosystem: "pip"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ labels:
+ - "dependency"
+ open-pull-requests-limit: 10
+ rebase-strategy: "disabled"
+
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ labels:
+ - "dependency"
+ open-pull-requests-limit: 10
+ rebase-strategy: "disabled"
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
new file mode 100644
index 0000000..ec28fb9
--- /dev/null
+++ b/.github/workflows/ci.yaml
@@ -0,0 +1,477 @@
+name: CI
+
+on:
+ push:
+ branches:
+ - master
+ - 2.*
+ pull_request: ~
+
+env:
+ CACHE_VERSION: 2
+ DEFAULT_PYTHON: 3.6
+ PRE_COMMIT_CACHE: ~/.cache/pre-commit
+
+jobs:
+ prepare-base:
+ name: Prepare base dependencies
+ runs-on: ubuntu-latest
+ outputs:
+ python-key: ${{ steps.generate-python-key.outputs.key }}
+ pre-commit-key: ${{ steps.generate-pre-commit-key.outputs.key }}
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ with:
+ fetch-depth: 0
+ - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ env.DEFAULT_PYTHON }}
+ - name: Generate partial Python venv restore key
+ id: generate-python-key
+ run: >-
+ echo "::set-output name=key::base-venv-${{ env.CACHE_VERSION }}-${{
+ hashFiles('setup.cfg', 'requirements_test.txt', 'requirements_test_min.txt')
+ }}"
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key: >-
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ steps.generate-python-key.outputs.key }}
+ restore-keys: |
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-base-venv-${{ env.CACHE_VERSION }}-
+ - name: Create Python virtual environment
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ python -m venv venv
+ . venv/bin/activate
+ python -m pip install -U pip setuptools wheel
+ pip install -U -r requirements_test.txt
+ - name: Generate pre-commit restore key
+ id: generate-pre-commit-key
+ run: >-
+ echo "::set-output name=key::pre-commit-${{ env.CACHE_VERSION }}-${{
+ hashFiles('.pre-commit-config.yaml') }}"
+ - name: Restore pre-commit environment
+ id: cache-precommit
+ uses: actions/cache@v2.1.6
+ with:
+ path: ${{ env.PRE_COMMIT_CACHE }}
+ key: >-
+ ${{ runner.os }}-${{ steps.generate-pre-commit-key.outputs.key }}
+ restore-keys: |
+ ${{ runner.os }}-pre-commit-${{ env.CACHE_VERSION }}-
+ - name: Install pre-commit dependencies
+ if: steps.cache-precommit.outputs.cache-hit != 'true'
+ run: |
+ . venv/bin/activate
+ pre-commit install --install-hooks
+
+ formatting:
+ name: Run pre-commit checks
+ runs-on: ubuntu-latest
+ needs: prepare-base
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ env.DEFAULT_PYTHON }}
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key:
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ needs.prepare-base.outputs.python-key }}
+ - name: Fail job if Python cache restore failed
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore Python venv from cache"
+ exit 1
+ - name: Restore pre-commit environment
+ id: cache-precommit
+ uses: actions/cache@v2.1.6
+ with:
+ path: ${{ env.PRE_COMMIT_CACHE }}
+ key: ${{ runner.os }}-${{ needs.prepare-base.outputs.pre-commit-key }}
+ - name: Fail job if pre-commit cache restore failed
+ if: steps.cache-precommit.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore pre-commit environment from cache"
+ exit 1
+ - name: Run formatting check
+ run: |
+ . venv/bin/activate
+ pip install -e .
+ pre-commit run pylint --all-files
+
+ spelling:
+ name: Run spelling checks
+ runs-on: ubuntu-latest
+ needs: prepare-base
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ env.DEFAULT_PYTHON }}
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key:
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ needs.prepare-base.outputs.python-key }}
+ - name: Fail job if Python cache restore failed
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore Python venv from cache"
+ exit 1
+ - name: Run spelling checks
+ run: |
+ . venv/bin/activate
+ pytest tests/ -k unittest_spelling
+
+ prepare-tests-linux:
+ name: Prepare tests for Python ${{ matrix.python-version }} (Linux)
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ python-version: [3.6, 3.7, 3.8, 3.9, 3.10-dev]
+ outputs:
+ python-key: ${{ steps.generate-python-key.outputs.key }}
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ with:
+ fetch-depth: 0
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Generate partial Python venv restore key
+ id: generate-python-key
+ run: >-
+ echo "::set-output name=key::venv-${{ env.CACHE_VERSION }}-${{
+ hashFiles('setup.cfg', 'requirements_test.txt', 'requirements_test_min.txt')
+ }}"
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key: >-
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ steps.generate-python-key.outputs.key }}
+ restore-keys: |
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ env.CACHE_VERSION }}-
+ - name: Create Python virtual environment
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ python -m venv venv
+ . venv/bin/activate
+ python -m pip install -U pip setuptools wheel
+ pip install -U -r requirements_test.txt
+
+ pytest-linux:
+ name: Run tests Python ${{ matrix.python-version }} (Linux)
+ runs-on: ubuntu-latest
+ needs: prepare-tests-linux
+ strategy:
+ fail-fast: false
+ matrix:
+ python-version: [3.6, 3.7, 3.8, 3.9, 3.10-dev]
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key:
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ needs.prepare-tests-linux.outputs.python-key }}
+ - name: Fail job if Python cache restore failed
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore Python venv from cache"
+ exit 1
+ - name: Run pytest
+ run: |
+ . venv/bin/activate
+ pytest --benchmark-disable --cov --cov-report= tests/
+ - name: Upload coverage artifact
+ uses: actions/upload-artifact@v2.2.4
+ with:
+ name: coverage-${{ matrix.python-version }}
+ path: .coverage
+
+ coverage:
+ name: Process test coverage
+ runs-on: ubuntu-latest
+ needs: ["prepare-tests-linux", "pytest-linux"]
+ strategy:
+ matrix:
+ python-version: [3.8]
+ env:
+ COVERAGERC_FILE: .coveragerc
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key:
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ needs.prepare-tests-linux.outputs.python-key }}
+ - name: Fail job if Python cache restore failed
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore Python venv from cache"
+ exit 1
+ - name: Download all coverage artifacts
+ uses: actions/download-artifact@v2.0.10
+ - name: Combine coverage results
+ run: |
+ . venv/bin/activate
+ coverage combine coverage*/.coverage
+ coverage report --rcfile=${{ env.COVERAGERC_FILE }}
+ - name: Upload coverage to Coveralls
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ run: |
+ . venv/bin/activate
+ coveralls --rcfile=${{ env.COVERAGERC_FILE }} --service=github
+
+ benchmark-linux:
+ name: Run benchmark tests Python ${{ matrix.python-version }} (Linux)
+ runs-on: ubuntu-latest
+ needs: prepare-tests-linux
+ strategy:
+ fail-fast: false
+ matrix:
+ python-version: [3.8, 3.9]
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key:
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ needs.prepare-tests-linux.outputs.python-key }}
+ - name: Fail job if Python cache restore failed
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore Python venv from cache"
+ exit 1
+ - name: Run pytest
+ run: |
+ . venv/bin/activate
+ pip install pygal
+ pip install -e .
+ pytest --exitfirst \
+ --benchmark-only \
+ --benchmark-autosave \
+ --benchmark-save-data \
+ --benchmark-group-by="group"
+ - name: Create partial artifact name suffix
+ id: artifact-name-suffix
+ run: >-
+ echo "::set-output name=datetime::"$(date "+%Y%m%d_%H%M")
+ - name: Upload benchmark artifact
+ uses: actions/upload-artifact@v2.2.4
+ with:
+ name:
+ benchmark-${{ runner.os }}-${{ matrix.python-version }}_${{
+ steps.artifact-name-suffix.outputs.datetime }}
+ path: .benchmarks/
+
+ prepare-tests-windows:
+ name: Prepare tests for Python ${{ matrix.python-version }} (Windows)
+ runs-on: windows-latest
+ strategy:
+ matrix:
+ python-version: [3.6, 3.7, 3.8, 3.9, 3.10-dev]
+ outputs:
+ python-key: ${{ steps.generate-python-key.outputs.key }}
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ with:
+ fetch-depth: 0
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Generate partial Python venv restore key
+ id: generate-python-key
+ run: >-
+ echo "::set-output name=key::venv-${{ env.CACHE_VERSION }}-${{
+ hashFiles('setup.cfg', 'requirements_test_min.txt')
+ }}"
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key: >-
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ steps.generate-python-key.outputs.key }}
+ restore-keys: |
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ env.CACHE_VERSION }}-
+ - name: Create Python virtual environment
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ python -m venv venv
+ . venv\\Scripts\\activate
+ python -m pip install -U pip setuptools wheel
+ pip install -U -r requirements_test_min.txt
+
+ pytest-windows:
+ name: Run tests Python ${{ matrix.python-version }} (Windows)
+ runs-on: windows-latest
+ needs: prepare-tests-windows
+ strategy:
+ fail-fast: false
+ matrix:
+ python-version: [3.6, 3.7, 3.8, 3.9, 3.10-dev]
+ steps:
+ - name: Set temp directory
+ run: echo "TEMP=$env:USERPROFILE\AppData\Local\Temp" >> $env:GITHUB_ENV
+ # Workaround to set correct temp directory on Windows
+ # https://github.com/actions/virtual-environments/issues/712
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key:
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ needs.prepare-tests-windows.outputs.python-key }}
+ - name: Fail job if Python cache restore failed
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore Python venv from cache"
+ exit 1
+ - name: Run pytest
+ run: |
+ . venv\\Scripts\\activate
+ pytest --benchmark-disable tests/
+
+ prepare-tests-pypy:
+ name: Prepare tests for Python ${{ matrix.python-version }}
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ python-version: ["pypy3"]
+ outputs:
+ python-key: ${{ steps.generate-python-key.outputs.key }}
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ with:
+ fetch-depth: 0
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Generate partial Python venv restore key
+ id: generate-python-key
+ run: >-
+ echo "::set-output name=key::venv-${{ env.CACHE_VERSION }}-${{
+ hashFiles('setup.cfg', 'requirements_test_min.txt')
+ }}"
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key: >-
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ steps.generate-python-key.outputs.key }}
+ restore-keys: |
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ env.CACHE_VERSION }}-
+ - name: Create Python virtual environment
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ python -m venv venv
+ . venv/bin/activate
+ python -m pip install -U pip setuptools wheel
+ pip install -U -r requirements_test_min.txt
+
+ pytest-pypy:
+ name: Run tests Python ${{ matrix.python-version }}
+ runs-on: ubuntu-latest
+ needs: prepare-tests-pypy
+ strategy:
+ fail-fast: false
+ matrix:
+ python-version: ["pypy3"]
+ steps:
+ - name: Check out code from GitHub
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ matrix.python-version }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Restore Python virtual environment
+ id: cache-venv
+ uses: actions/cache@v2.1.6
+ with:
+ path: venv
+ key:
+ ${{ runner.os }}-${{ steps.python.outputs.python-version }}-${{
+ needs.prepare-tests-pypy.outputs.python-key }}
+ - name: Fail job if Python cache restore failed
+ if: steps.cache-venv.outputs.cache-hit != 'true'
+ run: |
+ echo "Failed to restore Python venv from cache"
+ exit 1
+ - name: Run pytest
+ run: |
+ . venv/bin/activate
+ pytest --benchmark-disable tests/
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..046af6f
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,37 @@
+name: Release
+
+on:
+ release:
+ types:
+ - published
+
+env:
+ DEFAULT_PYTHON: 3.9
+
+jobs:
+ release-pypi:
+ name: Upload release to PyPI
+ runs-on: ubuntu-latest
+ steps:
+ - name: Check out code from Github
+ uses: actions/checkout@v2.3.4
+ - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+ id: python
+ uses: actions/setup-python@v2.2.2
+ with:
+ python-version: ${{ env.DEFAULT_PYTHON }}
+ - name: Install requirements
+ run: |
+ python -m pip install -U pip twine wheel
+ python -m pip install -U "setuptools>=56.0.0"
+ - name: Build distributions
+ run: |
+ python setup.py sdist bdist_wheel
+ - name: Upload to PyPI
+ if: github.event_name == 'release' && startsWith(github.ref, 'refs/tags')
+ env:
+ TWINE_REPOSITORY: pypi
+ TWINE_USERNAME: __token__
+ TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+ run: |
+ twine upload --verbose dist/*
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..3d96061
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,21 @@
+# Do not add entries specific to your dev environment or development
+# preferences in this file. You can use the global .gitignore for that:
+# git config --global core.excludesFile '~/.gitignore'
+/log
+*.py[cod]
+/build
+/doc/_build
+/dist/
+/pylint.egg-info/
+.tox
+*.sw[a-z]
+doc/technical_reference/extensions.rst
+doc/technical_reference/features.rst
+pyve
+build-stamp
+.coverage
+.coverage.*
+.cache/
+.eggs/
+.pytest_cache/
+.mypy_cache/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..f4f30bf
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,86 @@
+ci:
+ skip: [pylint]
+
+repos:
+ - repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v4.0.1
+ hooks:
+ - id: trailing-whitespace
+ exclude: "tests/functional/t/trailing_whitespaces.py"
+ - id: end-of-file-fixer
+ exclude: "tests/functional/m/missing/missing_final_newline.py|tests/functional/t/trailing_newlines.py"
+ - repo: https://github.com/myint/autoflake
+ rev: v1.4
+ hooks:
+ - id: autoflake
+ exclude: &fixtures tests/functional/|tests/input|tests/extensions/data|tests/regrtest_data/|tests/data/
+ args:
+ - --in-place
+ - --remove-all-unused-imports
+ - --expand-star-imports
+ - --remove-duplicate-keys
+ - --remove-unused-variables
+ - repo: https://github.com/asottile/pyupgrade
+ rev: v2.19.4
+ hooks:
+ - id: pyupgrade
+ args: [--py36-plus]
+ exclude: *fixtures
+ - repo: https://github.com/PyCQA/isort
+ rev: 5.8.0
+ hooks:
+ - id: isort
+ - repo: https://github.com/psf/black
+ rev: 21.6b0
+ hooks:
+ - id: black
+ args: [--safe, --quiet]
+ exclude: *fixtures
+ - repo: https://github.com/Pierre-Sassoulas/black-disable-checker/
+ rev: 1.0.1
+ hooks:
+ - id: black-disable-checker
+ - repo: https://github.com/PyCQA/flake8
+ rev: 3.9.2
+ hooks:
+ - id: flake8
+ exclude: *fixtures
+ - repo: local
+ hooks:
+ - id: pylint
+ name: pylint
+ entry: pylint
+ language: system
+ types: [python]
+ args:
+ [
+ "-rn",
+ "-sn",
+ "--rcfile=pylintrc",
+ "--load-plugins=pylint.extensions.docparams",
+ ]
+ # disabled plugins: pylint.extensions.mccabe
+ exclude: tests/functional/|tests/input|tests/extensions/data|tests/regrtest_data/|tests/data/|doc/
+ - id: fix-documentation
+ name: Fix documentation
+ entry: python3 -m script.fix_documentation
+ language: system
+ types: [text]
+ files: ^(ChangeLog|doc/whatsnew/\d+\.\d+\.rst)
+ - repo: https://github.com/pre-commit/mirrors-mypy
+ rev: v0.902
+ hooks:
+ - id: mypy
+ name: mypy
+ entry: mypy
+ language: python
+ types: [python]
+ args: []
+ require_serial: true
+ additional_dependencies: ["types-pkg_resources==0.1.2", "types-toml==0.1.2"]
+ exclude: tests/functional/|tests/input|tests/extensions/data|tests/regrtest_data/|tests/data/|doc/|bin/
+ - repo: https://github.com/pre-commit/mirrors-prettier
+ rev: v2.3.1
+ hooks:
+ - id: prettier
+ args: [--prose-wrap=always, --print-width=88]
diff --git a/.pre-commit-hooks.yaml b/.pre-commit-hooks.yaml
new file mode 100644
index 0000000..1bec079
--- /dev/null
+++ b/.pre-commit-hooks.yaml
@@ -0,0 +1,6 @@
+- id: pylint
+ name: pylint
+ entry: pylint
+ language: python
+ types: [python]
+ require_serial: true
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 0000000..f3e25df
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,11 @@
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+sphinx:
+ configuration: doc/conf.py
+
+python:
+ version: 3.7
+ install:
+ - requirements: doc/requirements.txt
diff --git a/CONTRIBUTORS.txt b/CONTRIBUTORS.txt
new file mode 100644
index 0000000..b1de7ff
--- /dev/null
+++ b/CONTRIBUTORS.txt
@@ -0,0 +1,505 @@
+Contributors
+------------
+
+Current team:
+
+* Ashley Whetter: maintainer, contributor
+
+* Bryce Guinta: maintainer, contributor
+
+* Claudiu Popa: maintainer, contributor
+
+* Cara Vinson: astroid committer.
+
+* Guillaume Peillex: committer
+
+* Łukasz Rogalski: committer.
+
+* Roy Williams (Lyft): committer
+
+ added check for implementing __eq__ without implementing __hash__,
+ Added Python 3 check for accessing Exception.message.
+ Added Python 3 check for calling encode/decode with invalid codecs.
+ Added Python 3 check for accessing sys.maxint.
+ Added Python 3 check for bad import statements.
+ Added Python 3 check for accessing deprecated methods on the 'string' module,
+ various patches.
+
+* Dmitry Pribysh: committer
+
+ multiple-imports, not-iterable, not-a-mapping, various patches.
+
+* Jim Robertson: committer
+
+Ex-maintainers:
+
+* Sylvain Thenault (Logilab): main author / maintainer
+
+* Torsten Marek (Google): committer / contributor
+
+
+We would not be here without folks that contributed patches, pull requests,
+issues and their time to pylint. We're incredibly grateful to all of these
+contributors:
+
+
+* Daniel Balparda (Google): GPyLint maintainer (Google's pylint variant),
+ various patches
+
+* Martin Pool (Google): warnings for anomalous backslashes, symbolic names for
+ messages (like 'unused'), etc
+
+* Alexandre Fayolle (Logilab): TkInter gui, documentation, debian support
+
+* Julien Cristau, Emile Anclin (Logilab): python 3 support
+
+* Sandro Tosi: Debian packaging
+
+* Mads Kiilerich, Boris Feld, Bill Wendling, Sebastian Ulrich:
+ various patches
+
+* Brian van den Broek: windows installation documentation
+
+* Amaury Forgeot d'Arc: check names imported from a module exists in the module
+
+* Benjamin Niemann: allow block level enabling/disabling of messages
+
+* Nathaniel Manista: suspicious lambda checking
+
+* David Shea: invalid sequence and slice index
+
+* Carl Crowder: don't evaluate the value of arguments for 'dangerous-default-value'
+
+* Michal Nowikowski: wrong-spelling-in-comment, wrong-spelling-in-docstring,
+ parallel execution on multiple CPUs and other patches.
+
+* David Lindquist: logging-format-interpolation warning.
+
+* Brett Cannon: Port source code to be Python 2/3 compatible, Python 3
+ checker.
+
+* Vlad Temian: redundant-unittest-assert and the JSON reporter.
+
+* Cosmin Poieană: unichr-builtin and improvements to bad-open-mode.
+
+* Viorel Știrbu: intern-builtin warning.
+
+* Dan Goldsmith: support for msg-template in HTML reporter.
+
+* Chris Rebert: unidiomatic-typecheck.
+
+* Steven Myint: duplicate-except.
+
+* Radu Ciorba: not-context-manager and confusing-with-statement warnings.
+
+* Bruno Daniel: check_docs extension.
+
+* James Morgensen: ignored-modules option applies to import errors.
+
+* Cezar Elnazli: deprecated-method
+
+* Stéphane Wirtel: nonlocal-without-binding
+
+* Laura Medioni (Logilab, on behalf of the CNES): misplaced-comparison-constant,
+ no-classmethod-decorator, no-staticmethod-decorator, too-many-nested-blocks,
+ too-many-boolean-expressions, unneeded-not, wrong-import-order, ungrouped-imports,
+ wrong-import-position, redefined-variable-type
+
+* Aru Sahni: Git ignoring, regex-based ignores
+
+* Mike Frysinger: contributor.
+
+* Moisés López (Vauxoo): Support for deprecated-modules in modules not installed,
+ Refactor wrong-import-order to integrate it with `isort` library
+ Add check too-complex with mccabe for cyclomatic complexity
+ Refactor wrong-import-position to skip try-import and nested cases
+ Add consider-merging-isinstance, superfluous-else-return
+ Fix consider-using-ternary for 'True and True and True or True' case
+
+* Luis Escobar (Vauxoo), Moisés López (Vauxoo): Add bad-docstring-quotes and docstring-first-line-empty
+
+* Yannick Brehon: contributor.
+
+* Glenn Matthews: autogenerated documentation for optional extensions,
+ bug fixes and enhancements for docparams (née check_docs) extension
+
+* Elias Dorneles: minor adjust to config defaults and docs
+
+* Yuri Bochkarev: Added epytext support to docparams extension.
+
+* Alexander Todorov: added new error conditions to 'bad-super-call',
+ Added new check for incorrect len(SEQUENCE) usage,
+ Added new extension for comparison against empty string constants,
+ Added new extension which detects comparing integers to zero,
+ Added new useless-return checker,
+ Added new try-except-raise checker
+
+* Erik Eriksson - Added overlapping-except error check.
+
+* Anthony Foglia (Google): Added simple string slots check.
+
+* Derek Gustafson: contributor
+
+* Petr Pulc: require whitespace around annotations
+
+* John Paraskevopoulos: add 'differing-param-doc' and 'differing-type-doc'
+
+* Martin von Gagern (Google): Added 'raising-format-tuple' warning.
+
+* Ahirnish Pareek, 'keyword-arg-before-var-arg' check
+
+* Daniel Miller: contributor.
+
+* Bryce Guinta: contributor
+
+* Martin Bašti: contributor
+ Added new check for shallow copy of os.environ
+
+* Jacques Kvam: contributor
+
+* Brian Shaginaw: prevent error on exception check for functions
+
+* Ioana Tagirta: fix bad thread instantiation check
+
+* Reverb Chu: contributor
+
+* Tobias Hernstig: contributor
+
+* Konstantin Manna: contributor
+
+* Andreas Freimuth: fix indentation checking with tabs
+
+* Renat Galimov: contributor
+
+* Thomas Snowden: fix missing-docstring for inner functions
+
+* Mitchell Young: minor adjustment to docparams
+
+* Marianna Polatoglou: minor contribution for wildcard import check
+
+* Ben Green: contributor
+
+* Benjamin Freeman: contributor
+
+* Fureigh: contributor
+
+* Jace Browning: updated default report format with clickable paths
+
+* Sushobhit (sushobhit27): contributor
+ Added new check 'comparison-with-itself'.
+ Added new check 'useless-import-alias'.
+ Added support of annotations in missing-type-doc and missing-return-type-doc.
+ Added new check 'comparison-with-callable'.
+ Removed six package dependency.
+ Added new check 'chained-comparison'.
+ Added new check 'useless-object-inheritance'.
+
+* Mariatta Wijaya: contributor
+ Added new check `logging-fstring-interpolation`
+ Documentation typo fixes
+
+* Jason Owen: contributor
+
+* Mark Roman Miller: fix inline defs in too-many-statements
+
+* Adam Dangoor: contributor
+
+* Gary Tyler McLeod: contributor
+
+* Wolfgang Grafen, Axel Muller, Fabio Zadrozny, Pierre Rouleau,
+ Maarten ter Huurne, Mirko Friedenhagen and all the Logilab's team (among others).
+
+* Matej Marusak: contributor
+
+* Nick Drozd: contributor, performance improvements to astroid
+
+* Kosarchuk Sergey: contributor
+
+* Carey Metcalfe: demoted `try-except-raise` from error to warning
+
+* Marcus Näslund (naslundx): contributor
+
+* Natalie Serebryakova: contributor
+
+* Caio Carrara: contributor
+
+* Roberto Leinardi: PyCharm plugin maintainer
+
+* Aivar Annamaa: contributor
+
+* Hornwitser: fix import graph
+
+* Yuri Gribov: contributor
+
+* Drew Risinger: committer (docs)
+
+* Ben James
+
+* Tomer Chachamu, Richard Goodman: simplifiable-if-expression
+
+* Alan Chan: contributor
+
+* Benjamin Drung: contributing Debian Developer
+
+* Scott Worley: contributor
+
+* Michael Hudson-Doyle
+
+* Lucas Cimon: contributor
+
+* Mike Miller: contributor
+
+* Sergei Lebedev: contributor
+
+* Sasha Bagan
+
+* Pablo Galindo Salgado: contributor
+ Fix false positive 'Non-iterable value' with async comprehensions.
+
+* Matus Valo
+
+* Sardorbek Imomaliev: contributor
+
+* Justin Li (justinnhli)
+
+* Nicolas Dickreuter
+
+* Pascal Corpet
+
+* Svetoslav Neykov: contributor
+
+* Federico Bond: contributor
+
+* Fantix King (UChicago): contributor
+
+* Yory (yory8): contributor
+
+* Thomas Hisch: contributor
+
+* Clément Pit-Claudel : contributor
+
+* Goudcode: contributor
+
+* Paul Renvoise : contributor
+
+* Bluesheeptoken: contributor
+
+* Michael Scott Cuthbert: contributor
+
+* Pierre Sassoulas : maintainer, contributor
+
+* Nathan Marrow
+
+* Taewon Kim : contributor
+
+* Daniil Kharkov: contributor
+
+* Tyler N. Thieding: contributor
+
+* Zeb Nicholls: contributor
+ - Made W9011 compatible with 'of' syntax in return types
+
+* Martin Vielsmaier: contributor
+
+* Agustin Toledo: contributor
+
+* Nicholas Smith: contributor
+
+* Peter Kolbus (Garmin): contributor
+
+* Oisin Moran: contributor
+
+* Andrzej Klajnert: contributor
+
+* Andrés Pérez Hortal: contributor
+
+* Niko Wenselowski: contributor
+
+* Danny Hermes: contributor
+
+* Eric Froemling: contributor
+
+* Robert Schweizer: contributor
+
+* Hugo van Kemenade: contributor
+
+* Mikhail Fesenko: contributor
+
+* Trevor Bekolay: contributor
+ - Added --list-msgs-enabled command
+
+* Rémi Cardona: contributor
+
+* Daniel Draper: contributor
+
+* Gabriel R. Sezefredo: contributor
+ - Fixed "exception-escape" false positive with generators
+
+* laike9m: contributor
+
+* Janne Rönkkö: contributor
+
+* Hugues Bruant: contributor
+
+* Tim Gates: contributor
+
+* Enji Cooper: contributor
+
+* Bastien Vallet: contributor
+
+* Pek Chhan: contributor
+
+* Craig Henriques: contributor
+
+* Matthijs Blom: contributor
+
+* Andy Palmer: contributor
+
+* Wes Turner (Google): added new check 'inconsistent-quotes'
+
+* Athos Ribeiro
+ Fixed dict-keys-not-iterating false positive for inverse containment checks
+
+* Anubhav: contributor
+
+* Ben Graham: contributor
+
+* Anthony Tan: contributor
+
+* Benny Müller: contributor
+
+* Bernie Gray: contributor
+
+* Slavfox: contributor
+
+* Matthew Beckers (mattlbeck): contributor
+
+* Yang Yang: contributor
+
+* Andrew J. Simmons (anjsimmo): contributor
+
+* Damien Baty: contributor
+
+* Daniel R. Neal (danrneal): contributer
+
+* Jeremy Fleischman (jfly): contributer
+
+* Shiv Venkatasubrahmanyam
+
+* Jochen Preusche (iilei): contributor
+
+* Ram Rachum (cool-RR)
+
+* Pieter Engelbrecht
+
+* Ethan Leba: contributor
+
+* Matěj Grabovský: contributor
+
+* Yeting Li (yetingli): contributor
+
+* Frost Ming (frostming): contributor
+
+* Luigi Bertaco Cristofolini (luigibertaco): contributor
+
+* Eli Fine (eli88fine): Fixed false positive duplicate code warning for lines with symbols only
+
+* Ganden Schaffner: contributor
+
+* Josselin Feist: contributor
+
+* David Cain: contributor
+
+* Pedro Algarvio (s0undt3ch): contributor
+
+* Luigi Bertaco Cristofolini (luigibertaco): contributor
+
+* Or Bahari
+
+* Joshua Cannon: contributor
+
+* Giuseppe Valente: contributor
+
+* Takashi Hirashima: contributor
+
+* Joffrey Mander: contributor
+
+* Julien Palard: contributor
+
+* Raphael Gaschignard: contributor
+
+* Sorin Sbarnea: contributor
+
+* Gergely Kalmár: contributor
+
+* Batuhan Taskaya: contributor
+
+* Frank Harrison (doublethefish): contributor
+
+* Gauthier Sebaux: contributor
+
+* Logan Miller (komodo472): contributor
+
+* Matthew Suozzo: contributor
+
+* Marc Mueller (cdce8p): contributor
+
+* David Gilman: contributor
+
+* Ikraduya Edian: contributor
+ - Added new checks 'consider-using-generator' and 'use-a-generator'.
+
+* Tiago Honorato: contributor
+
+* Lefteris Karapetsas: contributor
+
+* Louis Sautier: contributor
+
+* Quentin Young: contributor
+
+* Alexander Kapshuna: contributor
+
+* Mark Byrne: contributor
+
+* Konstantina Saketou: contributor
+
+* Andrew Howe: contributor
+
+* James Sinclair (irgeek): contributor
+
+* Andreas Finkler: contributor
+
+* Aidan Haase, Elizabeth Bott: contributor
+
+* Sebastian Müller: contributor
+
+* Ramiro Leal-Cavazos (ramiro050): Fixed bug preventing pylint from working with emacs tramp
+
+* manderj: contributor
+
+* qwiddle: contributor
+
+* das-intensity: contributor
+
+* Jiajunsu (victor): contributor
+
+* Andrew Haigh (nelfin): contributor
+
+* Pang Yu Shao (yushao2): contributor
+
+* Aditya Gupta (adityagupta1089) : contributor
+ - Added ignore_signatures to duplicate checker
+
+* Jacob Walls: contributor
+
+* ruro: contributor
+
+* David Liu (david-yz-liu): contributor
+
+* Bernard Nauwelaerts: contributor
+
+* Fabian Damken: contributor
+
+* Markus Siebenhaar: contributor
+
+* Lorena Buciu (lorena-b): contributor
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..90412b9
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,5551 @@
+------------------
+Pylint's ChangeLog
+------------------
+
+What's New in Pylint 2.9.0?
+===========================
+Release date: TBA
+
+..
+ Put new features and bugfixes here and also in 'doc/whatsnew/2.9.rst'
+
+* ``setuptools_scm`` has been removed and replaced by ``tbump`` in order to not
+ have hidden runtime dependencies to setuptools
+
+* Appveyor is no longer used in the continuous integration
+
+* Added ``deprecated-decorator``: Emitted when deprecated decorator is used.
+
+ Closes #4429
+
+* Added ``ignore-paths`` behaviour. Defined regex patterns are matched against full file path.
+
+ Close #2541
+
+* Fix false negative for ``consider-using-with`` if calls like ``open()`` were used outside of assignment expressions.
+
+* The warning for ``arguments-differ`` now signals explicitly the difference it detected
+ by naming the argument or arguments that changed and the type of change that occurred.
+
+* Suppress ``consider-using-with`` inside context managers.
+
+ Closes #4430
+
+* Added ``--fail-on`` option to return non-zero exit codes regardless of ``--fail-under`` value.
+
+* numversion tuple contains integers again to fix multiple pylint's plugins that relied on it
+
+ Closes #4420
+
+* Fix false-positive ``too-many-ancestors`` when inheriting from builtin classes,
+ especially from the ``collections.abc`` module
+
+ Closes #4166
+ Closes #4415
+
+* Stdlib deprecated modules check is moved to stdlib checker. New deprecated
+modules are added.
+
+* Fix raising false-positive ``no-member`` on abstract properties
+
+* Created new error message called ``arguments-renamed`` which identifies any changes at the parameter
+ names of overridden functions.
+
+ Closes #3536
+
+* New checker ``consider-using-dict-items``. Emitted when iterating over dictionary keys and then
+ indexing the same dictionary with the key within loop body.
+
+ Closes #3389
+
+* Don't emit ``import-error`` if import guarded behind ``if sys.version_info >= (x, x)``
+
+* Fix incompatibility with Python 3.6.0 caused by ``typing.Counter`` and ``typing.NoReturn`` usage
+
+ Closes #4412
+
+* New checker ``use-maxsplit-arg``. Emitted either when accessing only the first or last
+ element of ``str.split()``.
+
+ Closes #4440
+
+* Add ignore_signatures to duplicate code checker
+
+ Closes #3619
+
+* Fix documentation errors in "Block disables" paragraph of User Guide.
+
+* New checker ``unnecessary-dict-index-lookup``. Emitted when iterating over dictionary items
+ (key-value pairs) and accessing the value by index lookup.
+
+ Closes #4470
+
+* New checker``consider-using-from-import``. Emitted when a submodule/member of a package is imported and aliased
+ with the same name.
+
+ Closes #2309
+
+* Allow comma-separated list in ``output-format`` and separate output files for
+ each specified format.
+
+ Closes #1798
+
+* Make ``using-constant-test`` detect constant tests consisting of list literals like ``[]`` and
+ ``[1, 2, 3]``.
+
+* Improved error message of ``unnecessary-comprehension`` checker by providing code suggestion.
+
+ Closes #4499
+
+* New checker ``unused-private-member``. Emitted when a private member (i.e., starts with ``__``) of a class
+ is defined but not used.
+
+ Closes #4483
+
+* Fix false negative of ``consider-using-enumerate`` when iterating over an attribute.
+
+ Closes #3657
+
+* New checker ``invalid-class-object``. Emitted when a non-class is assigned to a ``__class__`` attribute.
+
+ Closes #585
+
+* Fix a crash when a plugin from the configuration could not be loaded and raise an error
+ 'bad-plugin-value' instead
+
+Closes #4555
+
+* Added handling of floating point values when parsing configuration from pyproject.toml
+
+ Closes #4518
+
+* ``invalid-length-returned``, now also works when nothing at all is returned
+ following an upgrade in astroid.
+
+* ``logging-format-interpolation`` and ``logging-not-lazy``, now works on logger
+ class created from renamed logging import following an upgrade in astroid.
+
+* Fix false-positive ``no-member`` with generic base class
+
+ Closes PyCQA/astroid#942
+
+* Fix ``assigning-non-slot`` false-positive with base that inherits from ``typing.Generic``
+
+ Closes #4509
+ Closes PyCQA/astroid#999
+
+* New checker ``invalid-all-format``. Emitted when ``__all__`` has an invalid format,
+ i.e. isn't a ``tuple`` or ``list``.
+
+* Fix false positive ``unused-variable`` and ``undefined-variable`` with
+ Pattern Matching in Python 3.10
+
+* New checker ``await-outside-async``. Emitted when await is used outside an async function.
+
+* Clarify documentation for ``typing`` extension.
+
+ Closes #4545
+
+* Add new extension ``CodeStyleChecker``. It includes checkers that can improve code
+ consistency. As such they don't necessarily provide a performance benefit
+ and are often times opinionated.
+
+ * New checker ``consider-using-tuple``. Emitted when an in-place defined
+ list or set can be replaced by a tuple.
+
+ * New checker ``consider-using-namedtuple-or-dataclass``. Emitted when dictionary values
+ can be replaced by namedtuples or dataclass instances.
+
+* Fix error that occurred when using ``slice`` as subscript for dict.
+
+* Reduce false-positives around inference of ``.value`` and ``.name``
+ properties on ``Enum`` subclasses, following an upgrade in astroid
+
+ Closes #1932
+ Closes #2062
+
+* Fix issue with ``cached_property`` that caused ``invalid-overridden-method`` error
+ when overriding a ``property``.
+
+ Closes #4023
+
+
+What's New in Pylint 2.8.3?
+===========================
+Release date: 2021-05-31
+
+* Astroid has been pinned to 2.5.6 for the 2.8 branch see #4527.
+
+
+What's New in Pylint 2.8.2?
+===========================
+Release date: 2021-04-26
+
+* Keep ``__pkginfo__.numversion`` a tuple to avoid breaking pylint-django.
+
+ Closes #4405
+
+* scm_setuptools has been added to the packaging.
+
+* Pylint's tags are now the standard form ``vX.Y.Z`` and not ``pylint-X.Y.Z`` anymore.
+
+* New warning message ``deprecated-class``. This message is emitted if import or call deprecated class of the
+standard library (like ``collections.Iterable`` that will be removed in Python 3.10).
+
+Closes #4388
+
+
+What's New in Pylint 2.8.1?
+===========================
+Release date: 2021-04-25
+
+* Add numversion back (temporarily) in ``__pkginfo__`` because it broke Pylama and revert the unnecessary
+ ``pylint.version`` breaking change.
+
+ Closes #4399
+
+
+What's New in Pylint 2.8.0?
+===========================
+Release date: 2021-04-24
+
+* New refactoring message ``consider-using-with``. This message is emitted if resource-allocating functions or methods of the
+ standard library (like ``open()`` or ``threading.Lock.acquire()``) that can be used as a context manager are called without
+ a ``with`` block.
+
+ Closes #3413
+
+* Resolve false positives on unused variables in decorator functions
+
+ Closes #4252
+
+* Add new extension ``ConfusingConsecutiveElifChecker``. This optional checker emits a refactoring message (R5601 ``confusing-consecutive-elif``)
+ if if/elif statements with different indentation levels follow directly one after the other.
+
+* New option ``--output=<file>`` to output result to a file rather than printing to stdout.
+
+ Closes #1070
+
+* Use a prescriptive message for ``unidiomatic-typecheck``
+
+ Closes #3891
+
+* Apply ``const-naming-style`` to module constants annotated with
+ ``typing.Final``
+
+* The packaging is now done via setuptools exclusively. ``doc``, ``tests``, ``man``, ``elisp`` and ``Changelog`` are
+ not packaged anymore - reducing the size of the package by 75%.
+
+* Debian packaging is now (officially) done in https://salsa.debian.org/python-team/packages/pylint.
+
+* The 'doc' extra-require has been removed.
+
+* ``__pkginfo__`` now only contain ``__version__`` (also accessible with ``pylint.__version__``), other meta-information are still
+ accessible with ``from importlib import metadata;metadata.metadata('pylint')``.
+
+* COPYING has been renamed to LICENSE for standardization.
+
+* Fix false-positive ``used-before-assignment`` in function returns.
+
+ Closes #4301
+
+* Updated ``astroid`` to 2.5.3
+
+ Closes #2822, #4206, #4284
+
+* Add ``consider-using-min-max-builtin`` check for if statement which could be replaced by Python builtin min or max
+
+ Closes #3406
+
+* Don't auto-enable postponed evaluation of type annotations with Python 3.10
+
+* Update ``astroid`` to 2.5.4
+
+* Add new extension ``TypingChecker``. This optional checker can detect the use of deprecated typing aliases
+ and can suggest the use of the alternative union syntax where possible.
+ (For example, 'typing.Dict' can be replaced by 'dict', and 'typing.Unions' by '|', etc.)
+ Make sure to check the config options if you plan on using it!
+
+* Reactivates old counts in report mode.
+
+ Closes #3819
+
+* During detection of ``inconsistent-return-statements`` consider that ``assert False`` is a return node.
+
+ Closes #4019
+
+* Run will not fail if score exactly equals ``config.fail_under``.
+
+* Functions that never returns may declare ``NoReturn`` as type hints, so that
+ ``inconsistent-return-statements`` is not emitted.
+
+ Closes #4122, #4188
+
+* Improved protected access checks to allow access inside class methods
+
+ Closes #1159
+
+* Fix issue with PEP 585 syntax and the use of ``collections.abc.Set``
+
+* Fix issue that caused class variables annotated with ``typing.ClassVar`` to be
+ identified as class constants. Now, class variables annotated with
+ ``typing.Final`` are identified as such.
+
+ Closes #4277
+
+* Continuous integration with read the doc has been added.
+
+ Closes #3850
+
+* Don't show ``DuplicateBasesError`` for attribute access
+
+* Fix crash when checking ``setup.cfg`` for pylint config when there are non-ascii characters in there
+
+ Closes #4328
+
+* Allow code flanked in backticks to be skipped by spellchecker
+
+ Closes #4319
+
+* Allow Python tool directives (for black, flake8, zimports, isort, mypy, bandit, pycharm) at beginning of comments to be skipped by spellchecker
+
+ Closes #4320
+
+* Fix issue that caused emacs pylint to fail when used with tramp
+
+* Improve check for invalid PEP 585 syntax inside functions
+ if postponed evaluation of type annotations is enabled
+
+* Improve check for invalid PEP 585 syntax as default function arguments
+
+
+What's New in Pylint 2.7.4?
+===========================
+Release date: 2021-03-30
+
+
+* Fix a problem with disabled msgid not being ignored
+
+ Closes #4265
+
+* Fix issue with annotated class constants
+
+ Closes #4264
+
+
+What's New in Pylint 2.7.3?
+===========================
+Release date: 2021-03-29
+
+* Introduce logic for checking deprecated attributes in DeprecationMixin.
+
+* Reduce usage of blacklist/whitelist terminology. Notably, ``extension-pkg-allow-list`` is an
+ alternative to ``extension-pkg-whitelist`` and the message ``blacklisted-name`` is now emitted as
+ ``disallowed-name``. The previous names are accepted to maintain backward compatibility.
+
+* Move deprecated checker to ``DeprecatedMixin``
+
+ Closes #4086
+
+* Bump ``astroid`` version to ``2.5.2``
+
+* Fix false positive for ``method-hidden`` when using private attribute and method
+
+ Closes #3936
+
+* ``use-symbolic-message-instead`` now also works on legacy messages like ``C0111`` (``missing-docstring``).
+
+* Remove unwanted print to stdout from ``_emit_no_member``
+
+* Introduce a command-line option to specify pyreverse output directory
+
+ Closes #4159
+
+* Fix issue with Enums and ``class-attribute-naming-style=snake_case``
+
+ Closes #4149
+
+* Add ``allowed-redefined-builtins`` option for fine tuning ``redefined-builtin`` check.
+
+ Close #3263
+
+* Fix issue when executing with ``python -m pylint``
+
+ Closes #4161
+
+* Exempt ``typing.TypedDict`` from ``too-few-public-methods`` check.
+
+ Closes #4180
+
+* Fix false-positive ``no-member`` for typed annotations without default value.
+
+ Closes #3167
+
+* Add ``--class-const-naming-style`` for Enum constants and class variables annotated
+ with ``typing.ClassVar``
+
+ Closes #4181
+
+* Fix astroid.Inference error for undefined-variables with ``len()```
+
+ Closes #4215
+
+* Fix column index on FIXME warning messages
+
+ Closes #4218
+
+* Improve handling of assignment expressions, better edge case handling
+
+ Closes #3763, #4238
+
+* Improve check if class is subscriptable PEP585
+
+* Fix documentation and filename handling of --import-graph
+
+* Fix false-positive for ``unused-import`` on class keyword arguments
+
+ Closes #3202
+
+* Fix regression with plugins on PYTHONPATH if latter is cwd
+
+ Closes #4252
+
+
+What's New in Pylint 2.7.2?
+===========================
+Release date: 2021-02-28
+
+* Fix False Positive on ``Enum.__members__.items()``, ``Enum.__members__.values``, and ``Enum.__members__.keys``
+ Closes #4123
+
+* Properly strip dangerous sys.path entries (not just the first one)
+
+ Closes #3636
+
+* Workflow and packaging improvements
+
+
+What's New in Pylint 2.7.1?
+===========================
+Release date: 2021-02-23
+
+* Expose ``UnittestLinter`` in pylint.testutils
+
+* Don't check directories starting with '.' when using register_plugins
+
+ Closes #4119
+
+
+What's New in Pylint 2.7.0?
+===========================
+Release date: 2021-02-21
+
+* Introduce DeprecationMixin for reusable deprecation checks.
+
+ Closes #4049
+
+* Fix false positive for ``builtin-not-iterating`` when ``map`` receives iterable
+
+ Closes #4078
+
+* Python 3.6+ is now required.
+
+* Fix false positive for ``builtin-not-iterating`` when ``zip`` receives iterable
+
+* Add ``nan-comparison`` check for NaN comparisons
+
+* Bug fix for empty-comment message line number.
+
+ Closes #4009
+
+* Only emit ``bad-reversed-sequence`` on dictionaries if below py3.8
+
+ Closes #3940
+
+* Handle class decorators applied to function.
+
+ Closes #3882
+
+* Add check for empty comments
+
+* Fix minor documentation issue in contribute.rst
+
+* Enums are now required to be named in UPPER_CASE by ``invalid-name``.
+
+ Close #3834
+
+* Add missing checks for deprecated functions.
+
+* Postponed evaluation of annotations are now recognized by default if python version is above 3.10
+
+ Closes #3992
+
+* Fix column metadata for anomalous backslash lints
+
+* Drop support for Python 3.5
+
+* Add support for pep585 with postponed evaluation
+
+ Closes #3320
+
+* Check alternative union syntax - PEP 604
+
+ Closes #4065
+
+* Fix multiple false positives with assignment expressions
+
+ Closes #3347, #3953, #3865, #3275
+
+* Fix TypedDict inherit-non-class false-positive Python 3.9+
+
+ Closes #1927
+
+* Fix issue with nested PEP 585 syntax
+
+* Fix issue with nested PEP 604 syntax
+
+* Fix a crash in ``undefined-variable`` caused by chained attributes in metaclass
+
+ Close #3742
+
+* Fix false positive for ``not-async-context-manager`` when ``contextlib.asynccontextmanager`` is used
+
+ Close #3862
+
+* Fix linter multiprocessing pool shutdown (triggered warnings when runned in parallels with other pytest plugins)
+
+ Closes #3779
+
+* Fix a false-positive emission of ``no-self-use`` and ``unused-argument`` for methods
+ of generic structural types (`Protocol[T]`)
+
+ Closes #3885
+
+* Fix bug that lead to duplicate messages when using ``--jobs 2`` or more.
+
+ Close #3584
+
+* Adds option ``check-protected-access-in-special-methods`` in the ClassChecker to activate/deactivate
+ ``protected-access`` message emission for single underscore prefixed attribute in special methods.
+
+ Close #3120
+
+* Fix vulnerable regular expressions in ``pyreverse``
+
+ Close #3811
+
+* ``inconsistent-return-statements`` message is now emitted if one of ``try/except`` statement
+ is not returning explicitly while the other do.
+
+ Closes #3468
+
+* Fix ``useless-super-delegation`` false positive when default keyword argument is a dictionnary.
+
+ Close #3773
+
+* Fix a crash when a specified config file does not exist
+
+* Add support to ``ignored-argument-names`` in DocstringParameterChecker and adds ``useless-param-doc`` and ``useless-type-doc`` messages.
+
+ Close #3800
+
+* Enforce docparams consistently when docstring is not present
+
+ Close #2738
+
+* Fix ``duplicate-code`` false positive when lines only contain whitespace and non-alphanumeric characters (e.g. parentheses, bracket, comma, etc.)
+
+* Improve lint message for ``singleton-comparison`` with bools
+
+* Fix spell-checker crash on indented docstring lines that look like # comments
+
+ Close #3786
+
+* Fix AttributeError in checkers/refactoring.py
+
+* Improve sphinx directives spelling filter
+
+* Fix a bug with postponed evaluation when using aliases for annotations.
+
+ Close #3798
+
+* Fix minor documentation issues
+
+* Improve the performance of the line length check.
+
+* Removed incorrect deprecation of ``inspect.getfullargspec``
+
+* Fix ``signature-differs`` false positive for functions with variadics
+
+ Close #3737
+
+* Fix a crash in ``consider-using-enumerate`` when encountering ``range()`` without arguments
+
+ Close #3735
+
+* ``len-as-conditions`` is now triggered only for classes that are inheriting directly from list, dict, or set and not implementing the ``__bool__`` function, or from generators like range or list/dict/set comprehension. This should reduce the false positives for other classes, like pandas's DataFrame or numpy's Array.
+
+ Close #1879
+
+* Fixes duplicate-errors not working with -j2+
+
+ Close #3314
+
+* ``generated-members`` now matches the qualified name of members
+
+ Close #2498
+
+* Add check for bool function to ``len-as-condition``
+
+* Add ``simplifiable-condition`` check for extraneous constants in conditionals using and/or.
+
+* Add ``condition-evals-to-constant`` check for conditionals using and/or that evaluate to a constant.
+
+ Close #3407
+
+* Changed setup.py to work with [distlib](https://pypi.org/project/distlib)
+
+ Close #3555
+
+* New check: ``consider-using-generator``
+
+ This check warns when a comprehension is used inside an ``any`` or ``all`` function,
+ since it is unnecessary and should be replaced by a generator instead.
+ Using a generator would be less code and way faster.
+
+ Close #3165
+
+* Add Github Actions to replace Travis and AppVeyor in the future
+
+
+What's New in Pylint 2.6.1?
+===========================
+
+* Astroid version has been set as < 2.5
+
+ Close #4093
+
+
+What's New in Pylint 2.6.0?
+===========================
+
+Release date: 2020-08-20
+
+* Fix various scope-related bugs in ``undefined-variable`` checker
+
+ Close #1082, #3434, #3461
+
+* bad-continuation and bad-whitespace have been removed, black or another formatter can help you with this better than Pylint
+
+ Close #246, #289, #638, #747, #1148, #1179, #1943, #2041, #2301, #2304, #2944, #3565
+
+* The no-space-check option has been removed. It's no longer possible to consider empty line like a ``trailing-whitespace`` by using clever options
+
+ Close #1368
+
+* ``missing-kwoa`` is no longer emitted when dealing with overload functions
+
+ Close #3655
+
+* mixed-indentation has been removed, it is no longer useful since TabError is included directly in python3
+
+ Close #2984 #3573
+
+* Add ``super-with-arguments`` check for flagging instances of Python 2 style super calls.
+
+* Add an faq detailing which messages to disable to avoid duplicates w/ other popular linters
+
+* Fix superfluous-parens false-positive for the walrus operator
+
+ Close #3383
+
+* Fix ``fail-under`` not accepting floats
+
+* Fix a bug with ``ignore-docstrings`` ignoring all lines in a module
+
+* Fix ``pre-commit`` config that could lead to undetected duplicate lines of code
+
+* Fix a crash in parallel mode when the module's filepath is not set
+
+ Close #3564
+
+* Add ``raise-missing-from`` check for exceptions that should have a cause.
+
+* Support both isort 4 and isort 5. If you have pinned isort 4 in your projet requirements, nothing changes. If you use isort 5, though, note that the ``known-standard-library`` option is not interpreted the same in isort 4 and isort 5 (see the migration guide in isort documentation for further details). For compatibility's sake for most pylint users, the ``known-standard-library`` option in pylint now maps to ``extra-standard-library`` in isort 5. If you really want what ``known-standard-library`` now means in isort 5, you must disable the ``wrong-import-order`` check in pylint and run isort manually with a proper isort configuration file.
+
+ Close #3722
+
+
+What's New in Pylint 2.5.4?
+===========================
+
+* Fix a crash caused by not guarding against ``InferenceError`` when calling ``infer_call_result``
+
+ Close #3690
+
+* Fix a crash in parallel mode when the module's filepath is not set
+
+ Close #3564
+
+
+What's New in Pylint 2.5.3?
+===========================
+
+Release date: 2020-06-8
+
+* Fix a regression where disable comments that have checker names with numbers in them are not parsed correctly
+
+ Close #3666
+
+* ``property-with-parameters`` properly handles abstract properties
+
+ Close #3600
+
+* ``continue-in-finally`` no longer emitted on Python 3.8 where it's now valid
+
+ Close #3612
+
+* Fix a regression where messages with dash are not fully parsed
+
+ Close #3604
+
+* In a TOML configuration file, it's now possible to use rich (non-string) types, such as list, integer or boolean instead of strings. For example, one can now define a *list* of message identifiers to enable like this::
+
+ enable = [
+ "use-symbolic-message-instead",
+ "useless-suppression",
+ ]
+
+ Close #3538
+
+* Fix a regression where the score was not reported with multiple jobs
+
+ Close #3547
+
+* Protect against ``AttributeError`` when checking ``cell-var-from-loop``
+
+ Close #3646
+
+
+What's New in Pylint 2.5.2?
+===========================
+
+Release date: 2020-05-05
+
+* ``pylint.Run`` accepts ``do_exit`` as a deprecated parameter
+
+ Close #3590
+
+
+What's New in Pylint 2.5.1?
+===========================
+
+Release date: 2020-05-05
+
+* Fix a crash in ``method-hidden`` lookup for unknown base classes
+
+ Close #3527
+
+* Revert pylint.Run's ``exit`` parameter to ``do_exit``
+
+ This has been inadvertently changed several releases ago to ``do_exit``.
+
+ Close #3533
+
+* ``no-value-for-parameter`` variadic detection has improved for assign statements
+
+ Close #3563
+
+* Allow package files to be properly discovered with multiple jobs
+
+ Close #3524
+
+* Allow linting directories without ``__init__.py`` which was a regression in 2.5.
+
+ Close #3528
+
+
+What's New in Pylint 2.5.0?
+===========================
+
+Release date: 2020-04-27
+
+* Fix a false negative for ``undefined-variable`` when using class attribute in comprehension.
+
+ Close #3494
+
+* Fix a false positive for ``undefined-variable`` when using class attribute in decorator or as type hint.
+
+ Close #511
+ Close #1976
+
+* Remove HTML quoting of messages in JSON output.
+
+ Close #2769
+
+* Adjust the ``invalid-name`` rule to work with non-ASCII identifiers and add the ``non-ascii-name`` rule.
+
+ Close #2725
+
+* Positional-only arguments are taken in account for ``useless-super-delegation``
+
+* ``unidiomatic-typecheck`` is no longer emitted for ``in`` and ``not in`` operators
+
+ Close #3337
+
+* Positional-only argument annotations are taken in account for ``unused-import``
+
+ Close #3462
+
+* Add a command to list available extensions.
+
+* Allow used variables to be properly consumed when different checks are enabled / disabled
+
+ Close #3445
+
+* Fix dangerous-default-value rule to account for keyword argument defaults
+
+ Close #3373
+
+* Fix a false positive of ``self-assigning-variable`` on tuple unpacking.
+
+ Close #3433
+
+* ``no-self-use`` is no longer emitted for typing stubs.
+
+ Close #3439
+
+* Fix a false positive for ``undefined-variable`` when ``__class__`` is used
+
+ Close #3090
+
+* Emit ``invalid-name`` for variables defined in loops at module level.
+
+ Close #2695
+
+* Add a check for cases where the second argument to ``isinstance`` is not a type.
+
+ Close #3308
+
+* Add 'notes-rgx' option, to be used for fixme check.
+
+ Close #2874
+
+* ``function-redefined`` exempts function redefined on a condition.
+
+ Close #2410
+
+* ``typing.overload`` functions are exempted from docstring checks
+
+ Close #3350
+
+* Emit ``invalid-overridden-method`` for improper async def overrides.
+
+ Close #3355
+
+* Do not allow ``python -m pylint ...`` to import user code
+
+ ``python -m pylint ...`` adds the current working directory as the first element
+ of ``sys.path``. This opens up a potential security hole where ``pylint`` will import
+ user level code as long as that code resides in modules having the same name as stdlib
+ or pylint's own modules.
+
+ Close #3386
+
+* Add ``dummy-variables-rgx`` option for ``_redeclared-assigned-name`` check.
+
+ Close #3341
+
+* Fixed graph creation for relative paths
+
+* Add a check for asserts on string literals.
+
+ Close #3284
+
+* ``not in`` is considered iterating context for some of the Python 3 porting checkers.
+
+* A new check ``inconsistent-quotes`` was added.
+
+* Add a check for non string assignment to __name__ attribute.
+
+ Close #583
+
+* ``__pow__``, ``__imatmul__``, ``__trunc__``, ``__floor__``, and ``__ceil__`` are recognized as special method names.
+
+ Close #3281
+
+* Added errors for protocol functions when invalid return types are detected.
+ E0304 (invalid-bool-returned): __bool__ did not return a bool
+ E0305 (invalid-index-returned): __index__ did not return an integer
+ E0306 (invalid-repr-returned): __repr__ did not return a string
+ E0307 (invalid-str-returned): __str__ did not return a string
+ E0308 (invalid-bytes-returned): __bytes__ did not return a string
+ E0309 (invalid-hash-returned): __hash__ did not return an integer
+ E0310 (invalid-length-hint-returned): __length_hint__ did not return a non-negative integer
+ E0311 (invalid-format-returned): __format__ did not return a string
+ E0312 (invalid-getnewargs-returned): __getnewargs__ did not return a tuple
+ E0313 (invalid-getnewargs-ex-returned): __getnewargs_ex__ did not return a tuple of the form (tuple, dict)
+
+ Close #560
+
+* ``missing-*-docstring`` can look for ``__doc__`` assignments.
+
+ Close #3301
+
+* ``undefined-variable`` can now find undefined loop iterables
+
+ Close #498
+
+* ``safe_infer`` can infer a value as long as all the paths share the same type.
+
+ Close #2503
+
+* Add a --fail-under <score> flag, also configurable in a .pylintrc file. If the final score is more than the specified score, it's considered a success and pylint exits with exitcode 0. Otherwise, it's considered a failure and pylint exits with its current exitcode based on the messages issued.
+
+ Close #2242
+
+* Don't emit ``line-too-long`` for multilines when ``disable=line-too-long`` comment stands at their end
+
+ Close #2957
+
+* Fixed an ``AttributeError`` caused by improper handling of ``dataclasses`` inference in ``pyreverse``
+
+ Close #3256
+
+* Do not exempt bare except from ``undefined-variable`` and similar checks
+
+ If a node was wrapped in a ``TryExcept``, ``pylint`` was taking a hint
+ from the except handler when deciding to emit or not a message.
+ We were treating bare except as a fully fledged ignore but only
+ the corresponding exceptions should be handled that way (e.g. ``NameError`` or ``ImportError``)
+
+ Close #3235
+
+* No longer emit ``assignment-from-no-return`` when a function only raises an exception
+
+ Close #3218
+
+* Allow import aliases to exempt ``import-error`` when used in type annotations.
+
+ Close #3178
+
+* ``Ellipsis` is exempted from ``multiple-statements`` for function overloads.
+
+ Close #3224
+
+* No longer emit ``invalid-name`` for non-constants found at module level.
+
+ Pylint was taking the following statement from PEP-8 too far, considering
+ all module level variables as constants, which is not what the statement is saying:
+
+ `Constants are usually defined on a module level and written in
+ all capital letters with underscores separating words.`
+
+ Close #3111
+ Close #3132
+
+* Allow ``implicit-str-concat-in-sequence`` to be emitted for string juxtaposition
+
+ Close #3030
+
+* ``implicit-str-concat-in-sequence`` was renamed ``implicit-str-concat``
+
+* The ``json`` reporter no longer bypasses ``redirect_stdout``. Close #3227
+
+* Move ``NoFileError``, ``OutputLine``, ``FunctionalTestReporter``,
+ ``FunctionalTestFile``, ``LintModuleTest`` and related methods from
+ ``test_functional.py`` to ``pylint.testutils`` to help testing for 3rd
+ party pylint plugins.
+
+* Can read config from a setup.cfg or pyproject.toml file.
+
+ Close #617
+
+* Fix exception-escape false positive with generators
+
+ Close #3128
+
+* ``inspect.getargvalues`` is no longer marked as deprecated.
+
+* A new check ``f-string-without-interpolation`` was added
+
+ Close #3190
+
+* Flag mutable ``collections.*`` utilities as dangerous defaults
+
+ Close #3183
+
+* ``docparams`` extension supports multiple types in raises sections.
+
+ Multiple types can also be separated by commas in all valid sections.
+
+ Closes #2729
+
+* Allow parallel linting when run under Prospector
+
+* Fixed false positives of ``method-hidden`` when a subclass defines the method that is being hidden.
+
+ Closes #414
+
+* Python 3 porting mode is 30-50% faster on most codebases
+
+* Python 3 porting mode no longer swallows syntax errors
+
+ Closes #2956
+
+* Pass the actual PyLinter object to sub processes to allow using custom
+ PyLinter classes.
+
+ PyLinter object (and all its members except reporter) needs to support
+ pickling so the PyLinter object can be passed to worker processes.
+
+* Clean up setup.py
+
+ Make pytest-runner a requirement only if running tests, similar to McCabe.
+
+ Clean up the setup.py file, resolving a number of warnings around it.
+
+* Handle SyntaxError in files passed via ``--from-stdin`` option
+
+ Pylint no longer outputs a traceback, if a file, read from stdin,
+ contains a syntaxerror.
+
+* Fix uppercase style to disallow 3+ uppercase followed by lowercase.
+
+* Fixed ``undefined-variable`` and ``unused-import`` false positives
+ when using a metaclass via an attribute.
+
+ Close #1603
+
+* Emit ``unused-argument`` for functions that partially uses their argument list before raising an exception.
+
+ Close #3246
+
+* Fixed ``broad_try_clause`` extension to check try/finally statements and to
+ check for nested statements (e.g., inside of an ``if`` statement).
+
+* Recognize classes explicitly inheriting from ``abc.ABC`` or having an
+ ``abc.ABCMeta`` metaclass as abstract. This makes them not trigger W0223.
+
+ Closes #3098
+
+* Fix overzealous ``arguments-differ`` when overridden function uses variadics
+
+ No message is emitted if the overriding function provides positional or
+ keyword variadics in its signature that can feasibly accept and pass on
+ all parameters given by the overridden function.
+
+ Close #1482
+ Close #1553
+
+* Multiple types of string formatting are allowed in logging functions.
+
+ The ``logging-fstring-interpolation`` message has been brought back to allow
+ multiple types of string formatting to be used.
+
+ Close #3361
+
+
+What's New in Pylint 2.4.4?
+===========================
+Release date: 2019-11-13
+
+* Exempt all the names found in type annotations from ``unused-import``
+
+ The previous code was assuming that only ``typing`` names need to be
+ exempted, but we need to do that for the rest of the type comment
+ names as well.
+
+ Close #3112
+
+* Relax type import detection for names that do not come from the ``typing`` module
+
+ Close #3191
+
+
+What's New in Pylint 2.4.3?
+===========================
+
+Release date: 2019-10-18
+
+* Fix an issue with ``unnecessary-comprehension`` in comprehensions with additional repacking of elements.
+
+ Close #3148
+
+* ``import-outside-toplevel`` is emitted for ``ImportFrom`` nodes as well.
+
+ Close #3175
+
+* Do not emit ``no-method-argument`` for functions using positional only args.
+
+ Close #3161
+
+* ``consider-using-sys-exit`` is no longer emitted when ``exit`` is imported in the local scope.
+
+ Close #3147
+
+* ``invalid-overridden-method`` takes ``abc.abstractproperty`` in account
+
+ Close #3150
+
+* Fixed ``missing-yield-type-doc`` getting incorrectly raised when
+ a generator does not document a yield type but has a type annotation.
+
+ Closes #3185
+
+* ``typing.overload`` functions are exempted from ``too-many-function-args``
+
+ Close #3170
+
+
+What's New in Pylint 2.4.2?
+===========================
+
+Release date: 2019-09-30
+
+
+* ``ignored-modules`` can skip submodules. Close #3135
+
+* ``self-assigning-variable`` skips class level assignments.
+
+ Close #2930
+
+* ``consider-using-sys-exit`` is exempted when ``exit()`` is imported from ``sys``
+
+ Close #3145
+
+* Exempt annotated assignments without variable from ``class-variable-slots-conflict``
+
+ Close #3141
+
+* Fix ``utils.is_error`` to account for functions returning early.
+
+ This fixes a false negative with ``unused-variable`` which was no longer triggered
+ when a function raised an exception as the last instruction, but the body of the function
+ still had unused variables.
+
+ Close #3028
+
+
+What's New in Pylint 2.4.1?
+===========================
+
+Release date: 2019-09-25
+
+
+* Exempt type checking definitions defined in both clauses of a type checking guard
+
+ Close #3127
+
+
+* Exempt type checking definitions inside the type check guard
+
+ In a7f236528bb3758886b97285a56f3f9ce5b13a99 we added basic support
+ for emitting ``used-before-assignment`` if a variable was only defined
+ inside a type checking guard (using ``TYPE_CHECKING`` variable from `typing`)
+ Unfortunately that missed the case of using those type checking imports
+ inside the guard itself, which triggered spurious used-before-assignment errors.
+
+ Close #3119
+
+* Require astroid >= 2.3 to avoid any compatibility issues.
+
+
+What's New in Pylint 2.4.0?
+===========================
+
+Release date: 2019-09-24
+
+* New check: ``import-outside-toplevel``
+
+ This check warns when modules are imported from places other than a
+ module toplevel, e.g. inside a function or a class.
+
+* Handle inference ambiguity for ``invalid-format-index``
+
+ Close #2752
+
+* Removed Python 2 specific checks such as ``relative-import``,
+ ``invalid-encoded-data``, ``missing-super-argument``.
+
+* Support forward references for ``function-redefined`` check.
+
+ Close #2540
+
+* Handle redefinitions in case of type checking imports.
+
+ Close #2834
+
+* Added a new check, ``consider-using-sys-exit``
+
+ This check is emitted when we detect that a quit() or exit() is invoked
+ instead of sys.exit(), which is the preferred way of exiting in program.
+
+ Close #2925
+
+* ``useless-suppression`` check now ignores ``cyclic-import`` suppressions,
+ which could lead to false postiives due to incomplete context at the time
+ of the check.
+
+ Close #3064
+
+* Added new checks, ``no-else-break`` and ``no-else-continue``
+
+ These checks highlight unnecessary ``else`` and ``elif`` blocks after
+ ``break`` and ``continue`` statements.
+
+ Close #2327
+
+* Don't emit ``protected-access`` when a single underscore prefixed attribute
+ is used inside a special method
+
+ Close #1802
+
+* Fix the "statement" values in the PyLinter's stats reports by module.
+
+* Added a new check, ``invalid-overridden-method``
+
+ This check is emitted when we detect that a method is overridden
+ as a property or a property is overridden as a method. This can indicate
+ a bug in the application code that will trigger a runtime error.
+
+ Close #2670
+
+* Added a new check, ``arguments-out-of-order``
+
+ This check warns if you have arguments with names that match those in
+ a function's signature but you are passing them in to the function
+ in a different order.
+
+ Close #2975
+
+* Added a new check, ``redeclared-assigned-name``
+
+ This check is emitted when ``pylint`` detects that a name
+ was assigned one or multiple times in the same assignment,
+ which indicate a potential bug.
+ Close #2898
+
+* Ignore lambda calls with variadic arguments without a context.
+
+ Inferring variadic positional arguments and keyword arguments
+ will result into empty Tuples and Dicts, which can lead in
+ some cases to false positives with regard to no-value-for-parameter.
+ In order to avoid this, until we'll have support for call context
+ propagation, we're ignoring such cases if detected.
+ We already did that for function calls, but the previous fix
+ was not taking in consideration ``lambdas``
+
+ Close #2918
+
+* Added a new check, ``self-assigning-variable``
+
+ This check is emitted when we detect that a variable is assigned
+ to itself, which might indicate a potential bug in the code application.
+ Close #2930
+
+* Added a new check, ``property-with-parameters``.
+
+ This check is emitted when we detect that a defined property also
+ has parameters, which are useless.
+ Close #3006
+
+* Excluded protocol classes from a couple of checks. Close #3002.
+
+* Add a check ``unnecessary-comprehension`` that detects unnecessary comprehensions.
+
+ This check is emitted when ``pylint`` finds list-, set- or dict-comprehensions,
+ that are unnecessary and can be rewritten with the list-, set- or dict-constructors.
+
+ Close #2905
+
+* Excluded PEP 526 instance and class variables from ``no-member``. Close #2945
+
+* Excluded ``attrs`` from ``too-few-public-methods`` check. Close #2988.
+
+* ``unused-import`` emitted for the right import names in function scopes.
+
+ Close #2928
+
+* Dropped support for Python 3.4.
+
+* ``assignment-from-no-return`` not triggered for async methods.
+
+ Close #2902
+
+* Don't emit ``attribute-defined-outside-init`` for variables defined in setters.
+
+ Close #409
+
+* Syntax errors report the column number.
+
+ Close #2914
+
+* Support fully qualified typing imports for type annotations.
+
+ Close #2915
+
+* Exclude ``__dict__`` from ``attribute-defined-outside-init``
+
+* Fix pointer on spelling check when the error are more than one time in the same line.
+
+ Close #2895
+
+* Fix crash happening when parent of called object cannot be determined
+
+* Allow of in ``GoogleDocstring.re_multiple_type``
+
+* Added ``subprocess-run-check`` to handle subrocess.run without explicitly set ``check`` keyword.
+
+ Close #2848
+
+* When we can't infer bare except handlers, skip ``try-except-raise``
+
+ Close #2853
+
+* Handle more ``unnecessary-lambda`` cases when dealing with additional kwargs in wrapped calls
+
+ Close #2845
+
+* Better postponed evaluation of annotations handling
+
+ Close #2847
+
+* Support postponed evaluation of annotations for variable annotations.
+
+ Close #2838
+
+* ``epylint.py_run`` defaults to ``python`` in case the current executable is not a Python one.
+
+ Close #2837
+
+* Ignore raw docstrings when running Similarities checker with ``ignore-docstrings=yes`` option
+
+* Fix crash when calling ``inherit_from_std_ex`` on a class which is its own ancestor
+
+ Close #2680
+
+* Added a new check that warns the user if a function call is used inside a test but parentheses are missing.
+
+ Close #2658
+
+* ``len-as-condition`` now only fires when a ``len(x)`` call is made without an explicit comparison
+
+ The message and description accompanying this checker has been changed
+ reflect this new behavior, by explicitly asking to either rely on the
+ fact that empty sequence are false or to compare the length with a scalar.
+
+ Close #2684
+
+* Add ``preferred-module`` checker that notify if an import has a replacement module that should be used.
+
+ This check is emitted when ``pylint`` finds an imported module that has a
+ preferred replacement listed in ``preferred-modules``.
+
+* ``assigning-non-slot`` not emitted for classes with unknown base classes.
+
+ Close #2807
+
+* ``old-division`` is not emitted for non-Const nodes.
+
+ Close #2808
+
+* Added method arguments to the dot writer for pyreverse.
+
+ Close #2139
+
+* Support for linting file from stdin.
+
+ IDEs may benefit from the support for linting from an in-memory file.
+
+ Close #1187
+
+* Added a new check ``class-variable-slots-conflict``
+
+ This check is emitted when ``pylint`` finds a class variable that conflicts with a slot
+ name, which would raise a ``ValueError`` at runtime.
+
+* Added new check: dict-iter-missing-items (E1141)
+
+ Close #2761
+
+* Fix issue with pylint name in output of python -m pylint --version
+
+ Close #2764
+
+* Relicense logo material under the CC BY-SA 4.0 license.
+
+* Skip ``if`` expressions from f-strings for the ``check_elif`` checker
+
+ Close #2816
+
+* C0412 (ungrouped-import) is now compatible with isort.
+
+ Close #2806
+
+* Added new extension to detect too much code in a try clause
+
+ Close #2877
+
+* ``signature-mutators`` option was added
+
+ With this option, users can choose to ignore ``too-many-function-args``, ``unexpected-keyword-arg``,
+ and ``no-value-for-parameter`` for functions decorated with decorators that change
+ the signature of a decorated function.
+
+ Close #259
+
+* Fixed a pragma comment on its own physical line being ignored when part
+ of a logical line with the previous physical line.
+
+ Close #199
+
+* Fixed false ``undefined-loop-variable`` for a function defined in the loop,
+ that uses the variable defined in that loop.
+
+ Close #202
+
+* Fixed ``unused-argument`` and ``function-redefined`` getting raised for
+ functions decorated with ``typing.overload``.
+
+ Close #1581
+
+* Fixed a false positive with ``consider-using-dict-comprehension`` for constructions that can't be converted to a comprehension
+
+ Close #2963
+
+* Added ``__post_init__`` to ``defining-attr-methods`` in order to avoid ``attribute-defined-outside-init`` in dataclasses.
+
+ Close #2581
+
+* Changed description of W0199 to use the term 2-item-tuple instead of 2-uple.
+
+* Allow a ``.`` as a prefix for Sphinx name resolution.
+
+* Checkers must now keep a 1 to 1 relationship between "msgid" (ie: C1234) and "symbol" (ie : human-readable-symbol)
+* In checkers, an old_names can now be used for multiple new messages and pylint is now a little faster
+
+Caused by #1164. It means if you do a partial old_names for a message definition an exception will tell you that you
+must rename the associated identification.
+
+* Allow the choice of f-strings as a valid way of formatting logging strings.
+
+ Closes #2395
+
+* Added ``--list-msgs-enabled`` command to list all enabled and disabled messages given the current RC file and command line arguments.
+
+
+What's New in Pylint 2.3.0?
+===========================
+
+Release date: 2019-02-27
+
+* Protect against ``NonDeducibleTypeHierarchy`` when calling semi-private ``is_subtype``
+
+ ``astroid.helpers.is_subtype`` raises ``NonDeducibleTypeHierarchy`` when it cannot infer
+ the base classes of the given types, but that makes sense in its context given that
+ the method is mostly used to inform the inference process about the hierarchy of classes.
+ Doesn't make that much sense for ``pylint`` itself, which is why we're handling the
+ exception here, rather than in ``astroid``
+
+ Close PyCQA/astroid#644
+
+* Added a new command line option ``list-groups`` for listing all the check groups ``pylint`` knows about.
+
+* Allow ``BaseException`` for emitting ``broad-except``, just like ``Exception``.
+
+ Close #2741
+
+* Fixed a crash that occurred for ``bad-str-strip-call`` when ``strip()`` received ``None``
+
+ Close #2743
+
+* Don't emit ``*-not-iterating`` checks for builtins consumed by ``itertools``
+
+ Close #2731
+
+* Fix a crash caused by iterating over ``Uninferable`` in a string formatting check.
+
+ Close #2727
+
+* Fixed false positives for ``no-self-argument`` and ``unsubscriptable-object`` when using ``__class_getitem__`` (new in Python 3.7)
+
+ Close #2416
+
+* Support ``Ellipsis`` as a synonym for ``pass`` statements.
+
+ Close #2718
+
+* ``fixme`` gets triggered only on comments.
+
+ Close #2321
+
+* Fixed a false positive for ``unused-variable`` and ``nonlocal`` assignments
+
+ Close #2671
+
+* Added ``load_configuration()`` hook for plugins
+
+ New optional hook for plugins is added: ``load_configuration()``.
+ This hook is executed after configuration is loaded to prevent
+ overwriting plugin specific configuration via user-based
+ configuration.
+
+ Close #2635
+
+* Fix missing-raises-doc false positive (W9006)
+
+ Close #1502
+
+* Exempt starred unpacking from ``*-not-iterating`` Python 3 checks
+
+ Close #2651
+
+* Make ``compare-to-zero`` less zealous by checking against equality and identity
+
+ Close #2645
+
+* Add ``no-else-raise`` warning (R1720)
+
+ Close #2558
+
+* Exempt ``yield from`` from ``*-not-iterating`` Python 3 checks.
+
+ Close #2643
+
+* Fix incorrect generation of ``no-else-return`` warnings (R1705)
+
+ Fixed issue where ``if`` statements with nested ``if`` statements
+ were incorrectly being flagged as ``no-else-return`` in some cases and
+ not being flagged as ``no-else-return`` in other cases. Added tests
+ for verification and updated pylint source files to eliminate newly
+ exposed warnings.
+
+* Fix false positive with ``not-async-context-manager`` caused by not understanding ``contextlib.asynccontextmanager``
+
+ Close #2440
+
+* Refactor ``bad-reversed-sequence`` to account for more objects that can define ``__reversed__``
+
+ One such object would be an enum class, for which ``__reversed__`` yields each individual enum.
+ As such, the check for ``bad-reversed-sequence`` needs to not differentiate between classes
+ and instances when it comes for checking of ``__reversed__`` presence.
+
+ Close #2598
+
+* Added ``wrong-exception-operation``
+
+ Used when an operation is done against an exception, but the operation
+ is not valid for the exception in question. Usually emitted when having
+ binary operations between exceptions in except handlers.
+
+ Close #2494
+
+* ``no-member`` is emitted for enums when they lack a member
+
+ Previously we weren't doing this because we detected a
+ ``__getattr__`` implementation on the ``Enum`` class
+ (and this check is skipped for classes with ``__getattr__``),
+ but that is fine for Enums, given that they are inferred in a customised
+ way in astroid.
+
+ Close #2565
+
+* Generalize ``chained-comparison``
+
+ Previous version incorrectly detects `a < b < c and b < d` and fails to
+ detect `a < b < c and c < d`.
+
+* Avoid popping __main__ when using multiple jobs
+
+ Close #2689
+
+* Add a new option 'check-str-concat-over-line-jumps' to check 'implicit-str-concat-in-sequence'
+
+* Fixes for the new style logging format linter.
+
+ The number of arguments was not handled properly, leading to an always
+ successful check.
+
+* Fix false positive ``not-callable`` for uninferable properties.
+
+* Fix false positive ``useless-else-on-loop`` if the break is deep in the else
+ of an inner loop.
+
+* Minor improvements to the help text for a few options.
+
+
+What's New in Pylint 2.2.2?
+===========================
+
+Release date: 2018-11-28
+
+* Change the ``logging-format-style`` to use name identifier instead of their
+ corresponding Python identifiers
+
+ This is to prevent users having to think about escaping the default value for
+ ``logging-format-style`` in the generated config file. Also our config parsing
+ utilities don't quite support escaped values when it comes to ``choices`` detection,
+ so this would have needed various hacks around that.
+
+ Closes #2614
+
+
+What's New in Pylint 2.2.1?
+===========================
+
+Release date: 2018-11-27
+
+* Fix a crash caused by ``implicit-str-concat-in-sequence`` and multi-bytes characters.
+
+ Closes #2610
+
+
+What's New in Pylint 2.2?
+=========================
+
+Release date: 2018-11-25
+
+ * Consider ``range()`` objects for ``undefined-loop-variable`` leaking from iteration.
+
+ Close #2533
+
+ * ``deprecated-method`` can use the attribute name for identifying a deprecated method
+
+ Previously we were using the fully qualified name, which we still do, but the fully
+ qualified name for some ``unittest`` deprecated aliases leads to a generic
+ deprecation function. Instead on relying on that, we now also rely on the attribute
+ name, which should solve some false positives.
+
+ Close #1653
+ Close #1946
+
+ * Fix compatibility with changes to stdlib tokenizer.
+
+ * ``pylint`` is less eager to consume the whole line for pragmas
+
+ Close #2485
+
+ * Obtain the correct number of CPUs for virtualized or containerized environments.
+
+ Close #2519
+
+ * Change ``unbalanced-tuple-unpacking`` back to a warning.
+
+ It used to be a warning until a couple of years ago, after it was promoted to
+ an error. But the check might be suggesting the wrong thing in some cases,
+ for instance when checking against ``sys.argv`` which cannot be known at static
+ analysis time. Given it might rely on potential unknown data, it's best to
+ have it as a warning.
+
+ Close #2522
+
+ * Remove ``enumerate`` usage suggestion when defining ``__iter__`` (C0200)
+
+ Close #2477
+
+ * Emit ``too-many-starred-assignment`` only when the number of Starred nodes is per assignment elements
+
+ Close #2513
+
+ * ``try-except-raise`` checker now handles multilevel inheritance hirerachy for exceptions correctly.
+
+ Close #2484
+
+ * Add a new check, ``simplifiable-if-expression`` for expressions like ``True if cond else False``.
+
+ Close #2487
+
+ * ``too-few-public-methods`` is not reported for ``typing.NamedTuple``
+
+ Close #2459
+
+ * ```too-few-public-methods`` is not reported for dataclasses created with options.
+
+ Close #2488
+
+ * Remove wrong modules from 'bad-python3-import'.
+
+ Close #2453
+
+ * The ``json`` reporter prints an empty list when no messages are emitted
+
+ Close #2446
+
+ * Add a new check, ``duplicate-string-formatting-argument``
+
+ This new check is emitted whenever a duplicate string formatting argument
+ is found.
+
+ Close #497
+
+ * ``assignment-from-no-return`` is not emitted for coroutines.
+
+ Close #1715
+
+ * Report format string type mismatches.
+
+ * ``consider-using-ternary`` and ``simplified-boolean-expression`` no longer emit for sequence based checks
+
+ Close #2473
+
+ * Handle ``AstroidSyntaxError`` when trying to import a module.
+
+ Close #2313
+
+ * Allow ``__module__`` to be redefined at a class level. Close #2451
+
+ * ``pylint`` used to emit a ``unused-variable`` error if unused import was found in the function. Now instead of
+ ``unused-variable``, ``unused-import`` is emitted.
+
+ Close #2421
+
+ * Handle asyncio.coroutine when looking for ``not-an-iterable`` check.
+
+ Close #996
+
+ * The ``locally-enabled`` check is gone.
+
+ Close #2442
+
+ * Infer decorated methods when looking for method-hidden
+
+ Close #2369
+
+ * Pick the latest value from the inferred values when looking for ``raising-non-exception``
+
+ Close #2431
+
+ * Extend the TYPE_CHECKING guard to TYPE_CHECKING name as well, not just the attribute
+
+ Close #2411
+
+ * Ignore import x.y.z as z cases for checker ``useless-import-alias``.
+
+ Close #2309
+
+ * Fix false positive ``undefined-variable`` and ``used-before-assignment`` with nonlocal keyword usage.
+
+ Close #2049
+
+ * Stop ``protected-access`` exception for missing class attributes
+
+ * Don't emit ``assignment-from-no-return`` for decorated function nodes
+
+ Close #2385
+
+ * ``unnecessary-pass`` is now also emitted when a function or class contains only docstring and pass statement.
+
+ In Python, stubbed functions often have a body that contains just a single ``pass`` statement,
+ indicating that the function doesn't do anything. However, a stubbed function can also have just a
+ docstring, and function with a docstring and no body also does nothing.
+
+ Close #2208
+
+ * ``duplicate-argument-name`` is emitted for more than one duplicate argument per function
+
+ Close #1712
+
+ * Allow double indentation levels for more distinguishable indentations
+
+ Close #741
+
+ * Consider tuples in exception handler for ``try-except-raise``.
+ Close #2389
+
+ * Fix astroid.ClassDef check in checkers.utils.is_subclass_of
+
+ * Fix wildcard imports being ignored by the import checker
+
+ * Fix external/internal distinction being broken in the import graph
+
+ * Fix wildcard import check not skipping ``__init__.py``
+
+ Close #2430
+
+ * Add new option to logging checker, ``logging_format_style``
+
+ * Fix --ignore-imports to understand multi-line imports
+
+ Close #1422
+ Close #2019
+
+ * Add a new check 'implicit-str-concat-in-sequence' to spot string concatenation inside lists, sets & tuples.
+
+ * ``literal-comparison`` is now emitted for 0 and 1 literals.
+
+
+What's New in Pylint 2.1.1?
+===========================
+
+Release date: 2018-08-07
+
+ * fix pylint crash due to ``misplaced-format-function`` not correctly handling class attribute.
+ Close #2384
+
+ * Do not emit \*-builtin for Python 3 builtin checks when the builtin is used inside a try-except
+
+ Close PyCQA/pylint#2228
+
+ * ``simplifiable-if-statement`` not emitted when dealing with subscripts
+
+
+What's New in Pylint 2.1?
+=========================
+
+Release date: 2018-08-01
+ * ``trailing-comma-tuple`` gets emitted for ``yield`` statements as well.
+
+ Close #2363
+
+ * Get only the arguments of the scope function for ``redefined-argument-from-local``
+
+ Close #2364
+
+ * Add a check ``misplaced-format-function`` which is emitted if format function is used on
+ non str object.
+
+ Close #2200
+
+ * ``chain.from_iterable`` no longer emits `dict-{}-not-iterating` when dealing with dict values and keys
+
+ * Demote the ``try-except-raise`` message from an error to a warning (E0705 -> W0706)
+
+ Close #2323
+
+ * Correctly handle the new name of the Python implementation of the ``abc`` module.
+
+ Close PyCQA/astroid#2288
+
+ * Modules with ``__getattr__`` are exempted by default from ``no-member``
+
+ There's no easy way to figure out if a module has a particular member when
+ the said module uses ``__getattr__``, which is a new addition to Python 3.7.
+ Instead we assume the safe thing to do, in the same way we do for classes,
+ and skip those modules from checking.
+
+ Close #2331
+
+ * Fix a false positive ``invalid name`` message when method or attribute name is longer then 30 characters.
+
+ Close #2047
+
+ * Include the type of the next branch in ``no-else-return``
+
+ Close #2295
+
+ * Fix inconsistent behaviour for bad-continuation on first line of file
+
+ Close #2281
+
+ * Fix not being able to disable certain messages on the last line through
+ the global disable option
+
+ Close #2278
+
+ * Don't emit ``useless-return`` when we have a single statement that is the return itself
+
+ We still want to be explicit when a function is supposed to return
+ an optional value; even though ``pass`` could still work, it's not explicit
+ enough and the function might look like it's missing an implementation.
+ Close #2300
+
+ * Fix false-positive undefined-variable for self referential class name in lamdbas
+
+ Close #704
+
+ * Don't crash when ``pylint`` is unable to infer the value of an argument to ``next()``
+
+ Close #2316
+
+ * Don't emit ``not-an-iterable`` when dealing with async iterators.
+
+ But do emit it when using the usual iteration protocol against
+ async iterators.
+
+ Close #2311
+
+ * Can specify a default docstring type for when the check cannot guess the type
+
+ Close #1169
+
+
+What's New in Pylint 2.0?
+=========================
+
+Release date: 2018-07-15
+ * ``try-except-raise`` should not be emitted if there are any parent exception class handlers.
+
+ Close #2284
+
+ * ``trailing-comma-tuple`` can be emitted for ``return`` statements as well.
+
+ Close #2269
+
+ * Fix a false positive ``inconsistent-return-statements`` message when exception is raised
+ inside an else statement.
+
+ Close #1782
+
+ * ``ImportFrom`` nodes correctly use the full name for the import sorting checks.
+
+ Close #2181
+
+ * [].extend and similar builtin operations don't emit `dict-*-not-iterating` with the Python 3 porting checker
+
+ Close #2187
+
+ * Add a check ``consider-using-dict-comprehension`` which is emitted if for dict initialization
+ the old style with list comprehensions is used.
+
+ * Add a check ``consider-using-set-comprehension`` which is emitted if for set initialization
+ the old style with list comprehensions is used.
+
+ * ``logging-not-lazy`` is emitted whenever pylint infers that a string is built with addition
+
+ Close #2193
+
+ * Add a check ``chained-comparison`` which is emitted if a boolean operation can be simplified
+ by chaining some of its operations.
+ e.g "a < b and b < c", can be simplified as "a < b < c".
+
+ Close #2032
+
+ * Add a check ``consider-using-in`` for comparisons of a variable against
+ multiple values with "==" and "or"s instead of checking if the variable
+ is contained "in" a tuple of those values.
+
+ * ``in`` is considered iterating context for some of the Python 3 porting checkers
+
+ Close #2186
+
+ * Add ``--ignore-none`` flag to control if pylint should warn about ``no-member`` where the owner is None
+
+ * Fix a false positive related to ``too-many-arguments`` and bounded ``__get__`` methods
+
+ Close #2172
+
+ * ``mcs`` as the first parameter of metaclass's ``__new__`` method was replaced by ``cls``
+
+ Close #2028
+
+ * ``assignment-from-no-return`` considers methods as well.
+
+ Close #2081
+
+ * Support typing.TYPE_CHECKING for *unused-import* errors
+
+ Close #1948
+
+ * Inferred classes at a function level no longer emit ``invalid-name``
+ when they don't respect the variable regular expression
+
+ Close #1049
+
+ * Added basic support for postponed evaluation of function annotations.
+
+ Close #2069
+
+ * Fix a bug with ``missing-kwoa`` and variadics parameters
+
+ Close #1111
+
+ * ``simplifiable-if-statement`` takes in account only when assigning to same targets
+
+ Close #1984
+
+ * Make ``len-as-condition`` test more cases, such as ``len() < 1`` or ``len <= 0``
+
+ * Fix false-positive ``line-too-long`` message emission for
+ commented line at the end of a module
+
+ Close #1950
+
+ * Fix false-positive ``bad-continuation`` for with statements
+
+ Close #461
+
+ * Don't warn about ``stop-iteration-return`` when using ``next()`` over ``itertools.count``
+
+ Close #2158
+
+ * Add a check ``consider-using-get`` for unidiomatic usage of value/default-retrieval
+ for a key from a dictionary
+
+ Close #2076
+
+ * invalid-slice-index is not emitted when the slice is used as index for a complex object.
+
+ We only use a handful of known objects (list, set and friends) to figure out if
+ we should emit invalid-slice-index when the slice is used to subscript an object.
+
+ * Don't emit ``unused-import`` anymore for typing imports used in type comments.
+
+ * Add a new check 'useless-import-alias'.
+
+ Close #2052
+
+ * Add ``comparison-with-callable`` to warn for comparison with bare callable, without calling it.
+
+ Close #2082
+
+ * Don't warn for ``missing-type-doc`` and/or ``missing-return-type-doc``, if type
+ annotations exist on the function signature for a parameter and/or return type.
+ Close #2083
+
+ * Add ``--exit-zero`` option for continuous integration scripts to more
+ easily call Pylint in environments that abort when a program returns a
+ non-zero (error) status code.
+
+ Close #2042
+
+ * Warn if the first argument of an instance/ class method gets assigned
+
+ Close #977
+
+ * New check ``comparison-with-itself`` to check comparison between same value.
+
+ Close #2051
+
+ * Add a new warning, 'logging-fstring-interpolation', emitted when f-string
+ is used within logging function calls.
+
+ Close #1998
+
+ * Don't show 'useless-super-delegation' if the subclass method has different type annotations.
+
+ Close #1923
+
+ * Add ``unhashable-dict-key`` check.
+
+ Closes #586
+
+ * Don't warn that a global variable is unused if it is defined by an import
+
+ Close #1453
+
+ * Skip wildcard import check for ``__init__.py``.
+
+ Close #2026
+
+ * The Python 3 porting mode can now run with Python 3 as well.
+
+ * ``too-few-public-methods`` is not emitted for dataclasses.
+
+ Close #1793
+
+ * New verbose mode option, enabled with ``--verbose`` command line flag, to
+ display of extra non-checker-related output. It is disabled by default.
+
+ Close #1863
+
+ * ``undefined-loop-variable`` takes in consideration non-empty iterred objects before emitting
+
+ Close #2039
+
+ * Add support for numpydoc optional return value names.
+
+ Close #2030
+
+ * ``singleton-comparison`` accounts for negative checks
+
+ Close #2037
+
+ * Add a check ``consider-using-in`` for comparisons of a variable against
+ multiple values with "==" and "or"s instead of checking if the variable
+ is contained "in" a tuple of those values.
+
+ Close #1977
+
+ * defaultdict and subclasses of dict are now handled for dict-iter-* checks
+
+ Close #2005
+
+ * ``logging-format-interpolation`` also emits when f-strings are used instead of % syntax.
+
+ Close #1788
+
+ * Don't trigger misplaced-bare-raise when the raise is in a finally clause
+
+ Close #1924
+
+ * Add a new check, ``possibly-unused-variable``.
+
+ This is similar to ``unused-variable``, the only difference is that it is
+ emitted when we detect a locals() call in the scope of the unused variable.
+ The ``locals()`` call could potentially use the said variable, by consuming
+ all values that are present up to the point of the call. This new check
+ allows to disable this error when the user intentionally uses ``locals()``
+ to consume everything.
+
+ Close #1909.
+
+ * ``no-else-return`` accounts for multiple cases
+
+ The check was a bit overrestrictive because we were checking for
+ return nodes in the .orelse node. At that point though the if statement
+ can be refactored to not have the orelse. This improves the detection of
+ other cases, for instance it now detects TryExcept nodes that are part of
+ the .else branch.
+
+ Close #1852
+
+ * Added two new checks, ``invalid-envvar-value`` and ``invalid-envvar-default``.
+
+ The former is trigger whenever pylint detects that environment variable manipulation
+ functions uses a different type than strings, while the latter is emitted whenever
+ the said functions are using a default variable of different type than expected.
+
+ * Add a check ``consider-using-join`` for concatenation of strings using str.join(sequence)
+
+ Close #1952
+
+ * Add a check ``consider-swap-variables`` for swapping variables with tuple unpacking
+
+ Close #1922
+
+ * Add new checker ``try-except-raise`` that warns the user if an except handler block
+ has a ``raise`` statement as its first operator. The warning is shown when there is
+ a bare raise statement, effectively re-raising the exception that was caught or the
+ type of the exception being raised is the same as the one being handled.
+
+ * Don't crash on invalid strings when checking for ``logging-format-interpolation``
+
+ Close #1944
+
+ * Exempt ``__doc__`` from triggering a ``redefined-builtin``
+
+ ``__doc__`` can be used to specify a docstring for a module without
+ passing it as a first-statement string.
+
+ * Fix false positive bad-whitespace from function arguments with default
+ values and annotations
+
+ Close #1831
+
+ * Fix stop-iteration-return false positive when next builtin has a
+ default value in a generator
+
+ Close #1830
+
+ * Fix emission of false positive ``no-member`` message for class with "private" attributes whose name is mangled.
+
+ Close #1643
+
+ * Fixed a crash which occurred when ``Uninferable`` wasn't properly handled in ``stop-iteration-return``
+
+ Close #1779
+
+ * Use the proper node to get the name for redefined functions (#1792)
+
+ Close #1774
+
+ * Don't crash when encountering bare raises while checking inconsistent returns
+
+ Close #1773
+
+ * Fix a false positive ``inconsistent-return-statements`` message when if statement is inside try/except.
+
+ Close #1770
+
+ * Fix a false positive ``inconsistent-return-statements`` message when while loop are used.
+
+ Close #1772
+
+ * Correct column number for whitespace conventions.
+
+ Previously the column was stuck at 0
+
+ Close #1649
+
+ * Fix ``unused-argument`` false positives with overshadowed variable in
+ dictionary comprehension.
+
+ Close #1731
+
+ * Fix false positive ``inconsistent-return-statements`` message when never
+ returning functions are used (i.e sys.exit for example).
+
+ Close #1771
+
+ * Fix error when checking if function is exception, as in ``bad-exception-context``.
+
+ * Fix false positive ``inconsistent-return-statements`` message when a
+ function is defined under an if statement.
+
+ Close #1794
+
+ * New ``useless-return`` message when function or method ends with a "return" or
+ "return None" statement and this is the only return statement in the body.
+
+ * Fix false positive ``inconsistent-return-statements`` message by
+ avoiding useless exception inference if the exception is not handled.
+
+ Close #1794 (second part)
+
+ * Fix bad thread instantiation check when target function is provided in args.
+
+ Close #1840
+
+ * Fixed false positive when a numpy Attributes section follows a Parameters
+ section
+
+ Close #1867
+
+ * Fix incorrect file path when file absolute path contains multiple ``path_strip_prefix`` strings.
+
+ Close #1120
+
+ * Fix false positive undefined-variable for lambda argument in class definitions
+
+ Close #1824
+
+ * Add of a new checker that warns the user if some messages are enabled or disabled
+ by id instead of symbol.
+
+ Close #1599
+
+ * Suppress false-positive ``not-callable`` messages from certain
+ staticmethod descriptors
+
+ Close #1699
+
+ * Fix indentation handling with tabs
+
+ Close #1148
+
+ * Fix false-positive ``bad-continuation`` error
+
+ Close #638
+
+ * Fix false positive unused-variable in lambda default arguments
+
+ Close #1921
+ Close #1552
+ Close #1099
+ Close #210
+
+ * Updated the default report format to include paths that can be clicked on in some terminals (e.g. iTerm).
+
+ * Fix inline def behavior with ``too-many-statements`` checker
+
+ Close #1978
+
+ * Fix ``KeyError`` raised when using docparams and NotImplementedError is documented.
+
+ Close #2102
+
+ * Fix 'method-hidden' raised when assigning to a property or data descriptor.
+
+ * Fix emitting ``useless-super-delegation`` when changing the default value of keyword arguments.
+
+ Close #2022
+
+ * Expand ignored-argument-names include starred arguments and keyword arguments
+
+ Close #2214
+
+ * Fix false-positive undefined-variable in nested lambda
+
+ Close #760
+
+ * Fix false-positive ``bad-whitespace`` message for typing annoatations
+ with ellipses in them
+
+ Close 1992
+
+ * Broke down "missing-docstrings" between "module", "class" and "function"
+
+ For this to work we had to make multiple messages with the same old name
+ possible.
+
+ Closes #1164
+
+
+What's New in Pylint 1.9?
+=========================
+
+Release date: 2018-05-15
+
+ * Added two new Python 3 porting checks, ``exception-escape`` and ``comprehension-escape``
+
+ These two are emitted whenever pylint detects that a variable defined in the
+ said blocks is used outside of the given block. On Python 3 these values are deleted.
+
+ * Added a new ``deprecated-sys-function``, emitted when accessing removed sys members.
+
+ * Added ``xreadlines-attribute``, emitted when the ``xreadlines()`` attribute is accessed.
+
+ * The Python 3 porting mode can now run with Python 3 as well.
+
+ * docparams extension allows abstract methods to document what overriding
+ implementations should return, and to raise NotImplementedError without
+ documenting it.
+
+ Closes #2044
+
+ * Special methods do not count towards ``too-few-methods``,
+ and are considered part of the public API.
+
+ * Enum classes do not trigger ``too-few-methods``
+
+ Close #605
+
+ * Added a new Python 2/3 check for accessing ``operator.div``, which is removed in Python 3
+
+ Close #1936
+
+ * Added a new Python 2/3 check for accessing removed urllib functions
+
+ Close #1997
+
+
+What's New in Pylint 1.8.1?
+===========================
+
+Release date: 2017-12-15
+
+ * Wrong version number in __pkginfo__.
+
+
+What's New in Pylint 1.8?
+=========================
+
+Release date: 2017-12-15
+
+ * Respect disable=... in config file when running with --py3k.
+
+ * New warning ``shallow-copy-environ`` added
+
+ Shallow copy of os.environ doesn't work as people may expect. os.environ
+ is not a dict object but rather a proxy object, so any changes made
+ on copy may have unexpected effects on os.environ
+
+ Instead of copy.copy(os.environ) method os.environ.copy() should be
+ used.
+
+ See https://bugs.python.org/issue15373 for details.
+
+ Close #1301
+
+ * Do not display no-absolute-import warning multiple times per file.
+
+ * ``trailing-comma-tuple`` refactor check now extends to assignment with
+ more than one element (such as lists)
+
+ Close #1713
+
+ * Fixing u'' string in superfluous-parens message
+
+ Close #1420
+
+ * ``abstract-class-instantiated`` is now emitted for all inference paths.
+
+ Close #1673
+
+ * Add set of predefined naming style to ease configuration of checking
+ naming conventions.
+
+ Closes #1013
+
+ * Added a new check, ``keyword-arg-before-vararg``
+
+ This is emitted for function definitions
+ in which keyword arguments are placed before variable
+ positional arguments (\*args).
+
+ This may lead to args list getting modified if keyword argument's value
+ is not provided in the function call assuming it will take default value
+ provided in the definition.
+
+ * The ``invalid-name`` check contains the name of the template that caused the failure
+
+ Close #1176
+
+ * Using the -j flag won't start more child linters than needed.
+
+ Contributed by Roman Ivanov in #1614
+
+ * Fix a false positive with bad-python3-import on relative imports
+
+ Close #1608
+
+ * Added a new Python 3 check, ``non-ascii-bytes-literals``
+
+ Close #1545
+
+ * Added a couple of new Python 3 checks for accessing dict methods in non-iterable context
+
+ * Protocol checks (not-a-mapping, not-an-iterable and co.) aren't emitted on classes with dynamic getattr
+
+ * Added a new warning, 'bad-thread-instantiation'
+
+ This message is emitted when the threading.Thread class does not
+ receive the target argument, but receives just one argument, which
+ is by default the group parameter.
+
+ Close #1327
+
+ * In non-quiet mode, absolute path of used config file is logged to
+ standard error.
+ Close #1519
+
+ * Raise meaningful exception for invalid reporter class being selected
+
+ When unknown reporter class will be selected as Pylint reporter,
+ meaningful error message would be raised instead of bare ``ImportError``
+ or ``AttribueError`` related to module or reporter class being not found.
+ Close #1388
+
+ * Added a new Python 3 check for accessing removed functions from itertools
+ like ``izip`` or ``ifilterfalse``
+
+ * Added a new Python 3 check for accessing removed fields from the types
+ module like ``UnicodeType`` or ``XRangeType``
+
+ * Added a new Python 3 check for declaring a method ``next`` that would have
+ been treated as an iterator in Python 2 but a normal function in Python 3.
+
+ * Added a new key-value pair in json output. The key is ``message-id``
+ and the value is the message id.
+ Close #1512
+
+ * Added a new Python 3.0 check for raising a StopIteration inside a generator.
+ The check about raising a StopIteration inside a generator is also valid if the exception
+ raised inherit from StopIteration.
+ Close #1385
+
+ * Added a new warning, ``raising-format-tuple``, to detect multi-argument
+ exception construction instead of message string formatting.
+
+ * Added a new check for method of logging module that concatenate string via + operator
+ Close #1479
+
+ * Added parameter for limiting number of suggestions in spellchecking checkers
+
+ * Fix a corner-case in ``consider-using-ternary`` checker.
+
+ When object ``A`` used in ``X and A or B`` was falsy in boolean context,
+ Pylint incorrectly emitted non-equivalent ternary-based suggestion.
+ After a change message is correctly not emitted for this case.
+ Close #1559
+
+ * Added ``suggestion-mode`` configuration flag. When flag is enabled, informational
+ message is emitted instead of cryptic error message for attributes accessed on
+ c-extensions.
+ Close #1466
+
+ * Fix a false positive ``useless-super-delegation`` message when
+ parameters default values are different from those used in the base class.
+ Close #1085
+
+ * Disabling 'wrong-import-order', 'wrong-import-position', or
+ 'ungrouped-imports' for a single line now prevents that line from
+ triggering violations on subsequent lines.
+
+ Close #1336
+
+ * Added a new Python check for inconsistent return statements inside method or function.
+ Close #1267
+
+ * Fix ``superfluous-parens`` false positive related to handling logical statements
+ involving ``in`` operator.
+
+ Close #574
+
+ * ``function-redefined`` message is no longer emitted for functions and
+ methods which names matches dummy variable name regular expression.
+ Close #1369
+
+ * Fix ``missing-param-doc`` and ``missing-type-doc`` false positives when
+ mixing ``Args`` and ``Keyword Args`` in Google docstring.
+ Close #1409
+
+ * Fix ``missing-docstring`` false negatives when modules, classes, or methods
+ consist of compound statements that exceed the ``docstring-min-length``
+
+ * Fix ``useless-else-on-loop`` false positives when break statements are
+ deeply nested inside loop.
+ Close #1661
+
+ * Fix no ``wrong-import-order`` message emitted on ordering of first and third party
+ libraries. With this fix, pylint distinguishes third and first party
+ modules when checking import order.
+ Close #1702
+
+ * Fix ``pylint disable=fixme`` directives ignored for comments following the
+ last statement in a file.
+ Close #1681
+
+ * Fix ``line-too-long`` message deactivated by wrong disable directive.
+ The directive ``disable=fixme`` doesn't deactivate anymore the emission
+ of ``line-too-long`` message for long commented lines.
+ Close #1741
+
+ * If the rcfile specified on the command line doesn't exist, then an
+ IOError exception is raised.
+ Close #1747
+
+ * Fix the wrong scope of the ``disable=`` directive after a commented line.
+ For example when a ``disable=line-too-long`` directive is at the end of
+ a long commented line, it no longer disables the emission of ``line-too-long``
+ message for lines that follow.
+ Close #1742
+
+
+What's New in Pylint 1.7.1?
+===========================
+
+Release date: 2017-04-17
+
+ * Fix a false positive which occurred when an exception was reraised
+
+ Close #1419
+
+ * Fix a false positive of ``disallow-trailing-tuple``
+
+ The check was improved by verifying for non-terminating newlines, which
+ should exempt function calls and function definitions from the check
+ Close #1424
+
+
+What's New in Pylint 1.7?
+=========================
+
+Release date: 2017-04-13
+
+ * Don't emit missing-final-newline or trailing-whitespace for formfeeds (page breaks).
+
+ Close #1218 and #1219
+
+ * Don't emit by default no-member if we have opaque inference objects in the inference results
+
+ This is controlled through the new flag ignore-on-opaque-inference, which is by
+ default True. The inference can return multiple potential results while
+ evaluating a Python object, but some branches might not be evaluated, which
+ results in partial inference. In that case, it might be useful to still emit
+ no-member and other checks for the rest of the inferred objects.
+
+ * Added new message ``assign-to-new-keyword`` to warn about assigning to names which
+ will become a keyword in future Python releases.
+
+ Close #1351
+
+ * Split the 'missing or differing' in parameter documentation in different error.
+ 'differing-param-doc' covers the differing part of the old 'missing-param-doc',
+ and 'differing-type-doc' covers the differing part of the old 'missing-type-doc'
+
+ Close #1342
+
+ * Added a new error, 'used-prior-global-declaration', which is emitted when a name
+ is used prior a global declaration in a function. This causes a SyntaxError in
+ Python 3.6
+
+ Close #1257
+
+ * The protocol checks are emitting their messages when a special method is set to None.
+
+ Close #1263
+
+ * Properly detect if imported name is assigned to same name in different
+ scope.
+
+ Close #636, #848, #851, and #900
+
+ * Require one space for annotations with type hints, as per PEP 8.
+
+ * 'trailing-comma-tuple' check was added
+
+ This message is emitted when pylint finds an one-element tuple,
+ created by a stray comma. This can suggest a potential problem in the
+ code and it is recommended to use parantheses in order to emphasise the
+ creation of a tuple, rather than relying on the comma itself.
+
+ * Don't emit not-callable for instances with unknown bases.
+
+ Close #1213
+
+ * Treat keyword only arguments the same as positional arguments with regard to unused-argument check
+
+ * Don't try to access variables defined in a separate scope when checking for ``protected-access``
+
+ * Added new check to detect incorrect usage of len(SEQUENCE) inside
+ test conditions.
+
+ * Added new extension to detect comparisons against empty string constants
+
+ * Added new extension to detect comparisons of integers against zero
+
+ * Added new error conditions for 'bad-super-call'
+
+ Now detects ``super(type(self), self)`` and ``super(self.__class__, self)``
+ which can lead to recursion loop in derived classes.
+
+ * PyLinter.should_analyze_file has a new optional parameter, called ``is_argument``
+
+ Close #1079
+
+ * Add attribute hints for missing members
+
+ Closes #1035
+
+ * Add a new warning, 'redefined-argument-from-local'
+
+ Closes #649
+
+ * Support inline comments for comma separated values in the config file
+
+ Closes #1024
+
+ * epylint.py_run's *script* parameter was removed.
+
+ * epylint.py_run now uses ``shell=False`` for running the underlying process.
+
+ Closes #441
+
+ * Added a new warning, 'useless-super-delegation'
+
+ Close 839.
+
+ * Added a new error, 'invalid-metaclass', raised when
+ we can detect that a class is using an improper metaclass.
+
+ Close #579
+
+ * Added a new refactoring message, 'literal-comparison'.
+
+ Close #786
+
+ * arguments-differ takes in consideration kwonlyargs and variadics
+
+ Close #983
+
+ * Removed --optimized-ast. Part of #975.
+
+ * Removed --files-output option. Part of #975.
+
+ * Removed pylint-gui from the package.
+
+ * Removed the HTML reporter. Part of #975.
+
+ * ignored-argument-names is now used for ignoring arguments for unused-variable check.
+
+ This option was used for ignoring arguments when computing the correct number of arguments
+ a function should have, but for handling the arguments with regard
+ to unused-variable check, dummy-variables-rgx was used instead. Now, ignored-argument-names
+ is used for its original purpose and also for ignoring the matched arguments for
+ the unused-variable check. This offers a better control of what should be ignored
+ and how.
+ Also, the same option was moved from the design checker to the variables checker,
+ which means that the option now appears under the ``[VARIABLES]`` section inside
+ the configuration file.
+ Close #862.
+
+ * Fix a false positive for keyword variadics with regard to keyword only arguments.
+
+ If a keyword only argument was necessary for a function, but that function was called
+ with keyword variadics (\**kwargs), then we were emitting a missing-kwoa false positive,
+ which is now fixed.
+
+ Close #934.
+
+ * Fix some false positives with unknown sized variadics.
+
+ Close #878
+
+ * Added a new extension, check_docstring, for checking PEP 257 conventions.
+
+ Closes #868.
+
+ * config files with BOM markers can now be read.
+
+ Close #864.
+
+ * epylint.py_run does not crash on big files, using .communicate() instead of .wait()
+
+ Close #599
+
+ * Disable reports by default and show the evaluation score by default
+
+ As per discussion from issue #746, the reports were disabled by
+ default in order to simplify the interaction between the tool
+ and the users. The score is still shown by default, as a way of
+ closely measuring when it increases or decreases due to changes
+ brought to the code.
+
+ * Disable the information category messages by default.
+
+ This is a step towards making pylint more sane, as
+ per the discussion from issue #746.
+
+ * Catch more cases as not proper iterables for __slots__ with
+ regard to invalid-slots pattern. Closes issue #775.
+
+ * empty indent strings are rejected.
+
+ * Added a new error, 'relative-beyond-top-level', which is emitted
+ when a relative import was attempted beyond the top level package.
+
+ Closes issue #588.
+
+ * Added a new warning, 'unsupported-assignment-operation', which is
+ emitted when item assignment is tried on an object which doesn't
+ have this ability. Closes issue #591.
+
+ * Added a new warning, 'unsupported-delete-operation', which is
+ emitted when item deletion is tried on an object which doesn't
+ have this ability. Closes issue #592.
+
+ * Fix a false positive of 'redundant-returns-doc', occurred when the documented
+ function was using *yield* instead of *return*.
+
+ Closes issue #984.
+
+ * Fix false positives of 'missing-[raises|params|type]-doc' due to not
+ recognizing keyword synonyms supported by Sphinx.
+
+ * Added a new refactoring message, 'consider-merging-isinstance', which is
+ emitted whenever we can detect that consecutive isinstance calls can be
+ merged together.
+
+ Closes issue #968
+
+ * Fix a false positive of 'missing-param-doc' and 'missing-type-doc',
+ occurred when a class docstring uses the 'For the parameters, see'
+ magic string but the class __init__ docstring does not, or vice versa.
+
+ * ``redefined-outer-name`` is now also emitted when a nested loop's target
+ variable is the same as a target variable in an outer loop.
+
+ Closes issue #911.
+
+ * Added proper exception type inference for 'missing-raises-doc'.
+
+ * Added InvalidMessageError exception class to replace asserts in
+ pylint.utils.
+
+ * More thorough validation in MessagesStore.register_messages() to avoid
+ one message accidentally overwriting another.
+
+ * InvalidMessageError, UnknownMessage, and EmptyReport exceptions are
+ moved to the new pylint.exceptions submodule.
+
+ * UnknownMessage and EmptyReport are renamed to UnknownMessageError and
+ EmptyReportError.
+
+ * Warnings 'missing-returns-type-doc' and 'missing-yields-type-doc'
+ have each been split into two warnings - 'missing-[return|yield]-doc'
+ and 'missing-[return|yield]-type-doc'.
+
+ * Added epytext support to docparams extension.
+
+ Closes #1029.
+
+ * Support having plugins with the same name and with options defined
+
+ Closes #1018
+
+ * Sort configuration options in a section
+
+ Closes #1087
+
+ * Added a new Python 3 warning around implementing '__div__', '__idiv__', or
+ '__rdiv__' as those methods are phased out in Python 3.
+
+ * Added a new warning, 'overlapping-except', which is
+ emitted when two exceptions in the same except-clause are aliases
+ for each other or one exceptions is an ancestor of another.
+
+ * Avoid crashing on ill-formatted strings when checking for string formatting errors.
+
+ * Added a new Python 3 warning for calling 'str.encode' or 'str.decode' with a non-text
+ encoding.
+
+ * Added new coding convention message, 'single-string-used-for-slots'.
+
+ Closes #1166
+
+ * Added a new Python 3 check for accessing 'sys.maxint' which was removed in Python 3 in favor
+ of 'sys.maxsize'
+
+ * Added a new Python 3 check for bad imports.
+
+ * Added a new Python 3 check for accessing deprecated string functions.
+
+ * Do not warn about unused arguments or function being redefined in singledispatch
+ registered implementations.
+
+ Closes #1032 and #1034
+
+ * Added refactoring message 'no-else-return'.
+
+ * Improve unused-variable checker to warn about unused variables in module scope.
+
+ Closes #919
+
+ * Ignore modules import as _ when checking for unused imports.
+
+ Closes #1190
+
+ * Improve handing of Python 3 classes with metaclasses declared in nested scopes.
+
+ Closes #1177
+
+ * Added refactoring message 'consider-using-ternary'.
+
+ Closes #1204
+
+ * Bug-fix for false-positive logging-format-interpolation` when format specifications
+ are used in formatted string.
+
+ Fixes #572
+
+ * Added a new switch ``single-line-class-stmt`` to allow single-line declaration
+ of empty class bodies.
+
+ Closes #738
+
+ * Protected access in form ``type(self)._attribute`` are now allowed.
+
+ Fixes #1031
+
+ * Let the user modify msg-template when Pylint is called from a Python script
+
+ Fixes #1269
+
+ * Imports checker supports new switch ``allow-wildcard-with-all`` which disables
+ warning on wildcard import when imported module defines ``__all__`` variable.
+
+ Fixes #831
+
+ * ``too-many-format-args`` and ``too-few-format-args`` are emitted correctly when
+ starred expression are used in RHS tuple.
+
+ Fixes #957
+
+ * ``cyclic-import`` checker supports local disable clauses. When one
+ of cycle imports was done in scope where disable clause was active,
+ cycle is not reported as violation.
+
+ Fixes #59
+
+
+What's new in Pylint 1.6.3?
+===========================
+
+Release date: 2016-07-18
+
+ * Do not crash when inferring uninferable exception types for docparams extension
+
+ Close #998
+
+
+What's new in Pylint 1.6.2?
+===========================
+
+Release date: TBA
+
+ * Do not crash when printing the help of options with default regular expressions
+
+ Close #990
+
+ * More granular versions for deprecated modules.
+
+ Close #991
+
+
+What's new in Pylint 1.6.1?
+===========================
+
+Release date: 2016-07-07
+
+ * Use environment markers for supporting conditional dependencies.
+
+
+What's New in Pylint 1.6.0?
+===========================
+
+Release date: 2016-07-03
+
+ * Added a new extension, ``pylint.extensions.mccabe``, for warning
+ about complexity in code.
+
+ * Deprecate support for --optimize-ast. Part of #975.
+
+ * Deprecate support for the HTML output. Part of #975.
+
+ * Deprecate support for --output-files. Part of #975.
+
+ * Fixed a documentation error for the check_docs extension. Fixes #735.
+
+ * Made the list of property-defining decorators configurable.
+
+ * Fix a bug where the top name of a qualified import was detected as unused variable.
+
+ Close #923.
+
+ * bad-builtin is now an extension check.
+
+ * generated-members support qualified name through regular expressions.
+
+ For instance, one can specify a regular expression as --generated-members=astroid.node_classes.*
+ for ignoring every no-member error that is accessed as in ``astroid.node_classes.missing.object``.
+
+ * Add the ability to ignore files based on regex matching, with the new ``--ignore-patterns``
+ option.
+
+ This addresses issue #156 by allowing for multiple ignore patterns
+ to be specified. Rather than clobber the existing ignore option, we
+ introduced a new one called ignore-patterns.
+
+ * Added a new error, 'trailing-newlines', which is emitted when a file
+ has trailing new lines.
+
+ Closes issue #682.
+
+ * Add a new option, 'redefining-builtins-modules', for controlling the modules
+ which can redefine builtins, such as six.moves and future.builtins.
+
+ Close #464.
+
+ * 'reimported' is emitted when the same name is imported from different module.
+
+ Close #162.
+
+ * Add a new recommendation checker, 'consider-iterating-dictionary', which is emitted
+ which is emitted when a dictionary is iterated through .keys().
+
+ Close #699
+
+ * Use the configparser backport for Python 2
+
+ This fixes a problem we were having with comments inside values, which is fixed
+ in Python 3's configparser.
+ Close #828
+
+ * A new error was added, 'invalid-length-returned', when the ``__len__``
+ special method returned something else than a non-negative number.
+
+ Close issue #557
+
+ * Switch to using isort internally for wrong-import-order.
+
+ Closes #879.
+
+ * check_docs extension can find constructor parameters in __init__.
+
+ Closes #887.
+
+ * Don't warn about invalid-sequence-index if the indexed object has unknown base
+ classes.
+
+ Closes #867
+
+ * Don't crash when checking, for super-init-not-called, a method defined in an if block.
+
+ * Do not emit import-error or no-name-in-module for fallback import blocks by default.
+
+ Until now, we warned with these errors when a fallback import block (a TryExcept block
+ that contained imports for Python 2 and 3) was found, but this gets cumbersome when
+ trying to write compatible code. As such, we don't check these blocks by default,
+ but the analysis can be enforced by using the new ``--analyse-fallback-block`` flag.
+
+ Close #769.
+
+
+What's New in Pylint 1.5.5?
+===========================
+
+Release date: 2016-03-21
+
+
+ * Let visit_importfrom from Python 3 porting checker be called when everything is disabled
+
+ Because the visit method was filtering the patterns it was expecting to be activated,
+ it didn't run when everything but one pattern was disabled, leading to spurious false
+ positives
+
+ Close #852
+
+ * Don't emit unsubscriptable-value for classes with unknown
+ base classes.
+
+ Close #776.
+
+ * Use an OrderedDict for storing the configuration elements
+
+ This fixes an issue related to impredictible order of the disable / enable
+ elements from a config file. In certain cases, the disable was coming before
+ the enable which resulted in classes of errors to be enabled, even though the intention
+ was to disable them. The best example for this was in the context of running multiple
+ processes, each one of it having different enables / disables that affected the output.
+
+ Close #815
+
+ * Don't consider bare and broad except handlers as ignoring NameError,
+ AttributeError and similar exceptions, in the context of checkers for
+ these issues.
+
+ Closes issue #826
+
+
+What's New in Pylint 1.5.4?
+===========================
+
+Release date: 2016-01-15
+
+
+ * Merge StringMethodChecker with StringFormatChecker. This fixes a
+ bug where disabling all the messages and enabling only a handful of
+ messages from the StringFormatChecker would have resulted in no
+ messages at all.
+
+ * Don't apply unneeded-not over sets.
+
+
+What's New in Pylint 1.5.3?
+===========================
+
+Release date: 2016-01-11
+
+ * Handle the import fallback idiom with regard to wrong-import-order.
+
+ Closes issue #750.
+
+ * Decouple the displaying of reports from the displaying of messages
+
+ Some reporters are aggregating the messages instead of displaying
+ them when they are available. The actual displaying was conflatted
+ in the generate_reports. Unfortunately this behaviour was flaky
+ and in the case of the JSON reporter, the messages weren't shown
+ at all if a file had syntax errors or if it was missing.
+ In order to fix this, the aggregated messages can now be
+ displayed with Reporter.display_message, while the reports are
+ displayed with display_reports.
+
+ Closes issues #766 and #765.
+
+ * Ignore function calls with variadic arguments without a context.
+
+ Inferring variadic positional arguments and keyword arguments
+ will result into empty Tuples and Dicts, which can lead in
+ some cases to false positives with regard to no-value-for-parameter.
+ In order to avoid this, until we'll have support for call context
+ propagation, we're ignoring such cases if detected.
+ Closes issue #722.
+
+ * Treat AsyncFunctionDef just like FunctionDef nodes,
+ by implementing visit_asyncfunctiondef in terms of
+ visit_functiondef.
+
+ Closes issue #767.
+
+ * Take in account kwonlyargs when verifying that arguments
+ are defined with the check_docs extension.
+
+ Closes issue #745.
+
+ * Suppress reporting 'unneeded-not' inside ``__ne__`` methods
+
+ Closes issue #749.
+
+
+What's New in Pylint 1.5.2?
+===========================
+
+Release date: 2015-12-21
+
+ * Don't crash if graphviz is not installed, instead emit a
+ warning letting the user to know.
+
+ Closes issue #168.
+
+ * Accept only functions and methods for the deprecated-method checker.
+
+ This prevents a crash which can occur when an object doesn't have
+ .qname() method after the inference.
+
+ * Don't emit super-on-old-class on classes with unknown bases.
+ Closes issue #721.
+
+ * Allow statements in ``if`` or ``try`` blocks containing imports.
+
+ Closes issue #714.
+
+
+What's New in Pylint 1.5.1?
+===========================
+
+Release date: 2015-12-02
+
+
+ * Fix a crash which occurred when old visit methods are encountered
+ in plugin modules. Closes issue #711.
+
+ * Add wrong-import-position to check_messages's decorator arguments
+ for ImportChecker.leave_module
+ This fixes an esoteric bug which occurs when ungrouped-imports and
+ wrong-import-order are disabled and pylint is executed on multiple files.
+ What happens is that without wrong-import-position in check_messages,
+ leave_module will never be called, which means that the first non-import node
+ from other files might leak into the current file,
+ leading to wrong-import-position being emitted by pylint.
+
+ * Fix a crash which occurred when old visit methods are encountered
+ in plugin modules. Closes issue #711.
+
+ * Don't emit import-self and cyclic-import for relative imports
+ of modules with the same name as the package itself.
+ Closes issues #708 and #706.
+
+
+What's New in Pylint 1.5.0?
+===========================
+
+Release date: 2015-11-29
+
+
+ * Added multiple warnings related to imports. 'wrong-import-order'
+ is emitted when PEP 8 recommendations regarding imports are not
+ respected (that is, standard imports should be followed by third-party
+ imports and then by local imports). 'ungrouped-imports' is emitted
+ when imports from the same package or module are not placed
+ together, but scattered around in the code. 'wrong-import-position'
+ is emitted when code is mixed with imports, being recommended for the
+ latter to be at the top of the file, in order to figure out easier by
+ a human reader what dependencies a module has.
+ Closes issue #692.
+
+ * Added a new refactoring warning, 'unneeded-not', emitted
+ when an expression with the not operator could be simplified.
+ Closes issue #670.
+
+ * Added a new refactoring warning, 'simplifiable-if-statement',
+ used when an if statement could be reduced to a boolean evaluation
+ of its test. Closes issue #698.
+
+ * Added a new refactoring warning, 'too-many-boolean-expressions',
+ used when an if statement contains too many boolean expressions,
+ which makes the code less maintainable and harder to understand.
+ Closes issue #677.
+
+ * Property methods are shown as attributes instead of functions in
+ pyreverse class diagrams. Closes Issue #284
+
+ * Add a new refactoring error, 'too-many-nested-blocks', which is emitted
+ when a function or a method has too many nested blocks, which makes the
+ code less readable and harder to understand. Closes issue #668.
+
+ * Add a new error, 'unsubscriptable-object', that is emitted when
+ value used in subscription expression doesn't support subscription
+ (i.e. doesn't define __getitem__ method).
+
+ * Don't warn about abstract classes instantiated in their own
+ body. Closes issue #627.
+
+ * Obsolete options are not present by default in the generated
+ configuration file. Closes issue #632.
+
+ * non-iterator-returned can detect classes with iterator-metaclasses.
+ Closes issue #679.
+
+ * Add a new error, 'unsupported-membership-test', emitted when value
+ to the right of the 'in' operator doesn't support membership test
+ protocol (i.e. doesn't define __contains__/__iter__/__getitem__)
+
+ * Add new errors, 'not-an-iterable', emitted when non-iterable value
+ is used in an iterating context (starargs, for-statement,
+ comprehensions, etc), and 'not-a-mapping', emitted when non-mapping
+ value is used in a mapping context. Closes issue #563.
+
+ * Make 'no-self-use' checker not emit a warning if there is a 'super()'
+ call inside the method.
+ Closes issue #667.
+
+ * Add checker to identify multiple imports on one line.
+ Closes issue #598.
+
+ * Fix unused-argument false positive when the "+=" operator is used.
+ Closes issue #518.
+
+ * Don't emit import-error for ignored modules. PyLint will not emit import
+ errors for any import which is, or is a subpackage of, a module in
+ the ignored-modules list. Closes issue #223.
+
+ * Fix unused-import false positive when the import is used in a
+ class assignment. Closes issue #475
+
+ * Add a new error, 'not-context-manager', emitted when something
+ that doesn't implement __enter__ and __exit__ is used in a with
+ statement.
+
+ * Add a new warning, 'confusing-with-statement', emitted by the
+ base checker, when an ambiguous looking with statement is used.
+ For example `with open() as first, second` which looks like a
+ tuple assignment but is actually 2 context managers.
+
+ * Add a new warning, 'duplicate-except', emitted when there is an
+ exception handler which handles an exception type that was handled
+ before. Closes issue #485.
+
+ * A couple of warnings got promoted to errors, since they could uncover
+ potential bugs in the code. These warnings are: assignment-from-none,
+ unbalanced-tuple-unpacking, unpacking-non-sequence, non-iterator-returned.
+ Closes issue #388.
+
+ * Allow ending a pragma control with a semicolon. In this way, users
+ can continue a pragma control with a reason for why it is used,
+ as in `# pylint: disable=old-style-class;reason=...`.
+ Closes issue #449.
+
+ * --jobs can be used with --load-plugins now. Closes issue #456.
+
+ * Improve the performance of --jobs when dealing only with a package
+ name. Closes issue #479.
+
+ * Don't emit an unused-wildcard-import when the imported name comes
+ from another module and it is in fact a __future__ name.
+
+ * The colorized reporter now works on Windows. Closes issue #96.
+
+ * Remove pointless-except warning. It was previously disabled by
+ default and it wasn't very useful. Closes issue #506.
+
+ * Fix a crash on Python 3 related to the string checker, which
+ crashed when it encountered a bytes string with a .format
+ method called.
+
+ * Don't warn about no-self-use for builtin properties.
+
+ * Fix a false positive for bad-reversed-sequence, when a subclass
+ of a ``dict`` provides a __reversed__ method.
+
+ * Change the default no-docstring-rgx so missing-docstring isn't
+ emitted for private functions.
+
+ * Don't emit redefined-outer-name for __future__ directives.
+ Closes issue #520.
+
+ * Provide some hints for the bad-builtin message. Closes issue #522.
+
+ * When checking for invalid arguments to a callable, in typecheck.py,
+ look up for the __init__ in case the found __new__ comes from builtins.
+
+ Since the __new__ comes from builtins, it will not have attached any
+ information regarding what parameters it expects, so the check
+ will be useless. Retrieving __init__ in that case will at least
+ detect a couple of false negatives. Closes issue #429.
+
+ * Don't emit no-member for classes with unknown bases.
+
+ Since we don't know what those bases might add, we simply ignore
+ the error in this case.
+
+ * Lookup in the implicit metaclass when checking for no-member,
+ if the class in question has an implicit metaclass, which is
+ True for new style classes. Closes issue #438.
+
+ * Add two new warnings, duplicate-bases and inconsistent-mro.
+
+ duplicate-bases is emitted when a class has the same bases
+ listed more than once in its bases definition, while inconsistent-mro
+ is emitted when no sane mro hierarchy can be determined. Closes issue #526.
+
+ * Remove interface-not-implemented warning. Closes issue #532.
+
+ * Remove the rest of interface checks: interface-is-not-class,
+ missing-interface-method, unresolved-interface. The reason is that
+ its better to start recommending ABCs instead of the old Zope era
+ of interfaces. One side effect of this change is that ignore-iface-methods
+ becomes a noop, it's deprecated and it will be removed at some time.
+
+ * Emit a proper deprecation warning for reporters.BaseReporter.add_message.
+
+ The alternative way is to use handle_message. add_message will be removed in
+ Pylint 1.6.
+
+ * Added new module 'extensions' for optional checkers with the test
+ directory 'test/extensions' and documentation file 'doc/extensions.rst'.
+
+ * Added new checker 'extensions.check_docs' that verifies parameter
+ documention in Sphinx, Google, and Numpy style.
+
+ * Detect undefined variable cases, where the "definition" of an undefined
+ variable was in del statement. Instead of emitting used-before-assignment,
+ which is totally misleading, it now emits undefined-variable.
+ Closes issue #528.
+
+ * Don't emit attribute-defined-outside-init and access-member-before-definition
+ for mixin classes. Actual errors can occur in mixin classes, but this is
+ controlled by the ignore-mixin-members option. Closes issue #412.
+
+ * Improve the detection of undefined variables and variables used before
+ assignment for variables used as default arguments to function,
+ where the variable was first defined in the class scope.
+ Closes issue #342 and issue #404.
+
+ * Add a new warning, 'unexpected-special-method-signature', which is emitted
+ when a special method (dunder method) doesn't have the expected signature,
+ which can lead to actual errors in the application code.
+ Closes issue #253.
+
+ * Remove 'bad-context-manager' due to the inclusion of 'unexpected-special-method-signature'.
+
+ * Don't emit no-name-in-module if the import is guarded by an ImportError, Exception or
+ a bare except clause.
+
+ * Don't emit no-member if the attribute access node is protected by an
+ except handler, which handles AttributeError, Exception or it is a
+ bare except.
+
+ * Don't emit import-error if the import is guarded by an ImportError, Exception or a
+ bare except clause.
+
+ * Don't emit undefined-variable if the node is guarded by a NameError, Exception
+ or bare except clause.
+
+ * Add a new warning, 'using-constant-test', which is emitted when a conditional
+ statement (If, IfExp) uses a test which is always constant, such as numbers,
+ classes, functions etc. This is most likely an error from the user's part.
+ Closes issue #524.
+
+ * Don't emit 'raising-non-exception' when the exception has unknown
+ bases. We don't know what those bases actually are and it's better
+ to assume that the user knows what he is doing rather than emitting
+ a message which can be considered a false positive.
+
+ * Look for a .pylintrc configuration file in the current folder,
+ if pylintrc is not found. Dotted pylintrc files will not be searched
+ in the parents of the current folder, as it is done for pylintrc.
+
+ * Add a new error, 'invalid-unary-type-operand', emitted when
+ an unary operand is used on something which doesn't support that
+ operation (for instance, using the unary bitwise inversion operator
+ on an instance which doesn't implement __invert__).
+
+ * Take in consideration differences between arguments of various
+ type of functions (classmethods, staticmethods, properties)
+ when checking for ``arguments-differ``. Closes issue #548.
+
+ * astroid.inspector was moved to pylint.pyreverse, since it belongs
+ there and it doesn't need to be in astroid.
+
+ * astroid.utils.LocalsVisitor was moved to pylint.pyreverse.LocalsVisitor.
+
+ * pylint.checkers.utils.excepts_import_error was removed.
+ Use pylint.chekcers.utils.error_of_type instead.
+
+ * Don't emit undefined-all-variables for nodes which can't be
+ inferred (YES nodes).
+
+ * yield-outside-func is also emitted for ``yield from``.
+
+ * Add a new error, 'too-many-star-expressions', emitted when
+ there are more than one starred expression (`*x`) in an assignment.
+ The warning is emitted only on Python 3.
+
+ * Add a new error, 'invalid-star-assignment-target', emitted when
+ a starred expression (`*x`) is used as the lhs side of an assignment,
+ as in `*x = [1, 2]`. This is not a SyntaxError on Python 3 though.
+
+ * Detect a couple of objects which can't be base classes (bool,
+ slice, range and memoryview, which weren't detected until now).
+
+ * Add a new error for the Python 3 porting checker, ``import-star-module-level``,
+ which is used when a star import is detected in another scope than the
+ module level, which is an error on Python 3. Using this will emit a
+ SyntaxWarning on Python 2.
+
+ * Add a new error, 'star-needs-assignment-target', emitted on Python 3 when
+ a Starred expression (`*x`) is not used in an assignment target. This is not
+ caught when parsing the AST on Python 3, so it needs to be a separate check.
+
+ * Add a new error, 'unsupported-binary-operation', emitted when
+ two a binary arithmetic operation is executed between two objects
+ which don't support it (a number plus a string for instance).
+ This is currently disabled, since the it exhibits way too many false
+ positives, but it will be reenabled as soon as possible.
+
+ * New imported features from astroid into pyreverse: pyreverse.inspector.Project,
+ pyreverse.inspector.project_from_files and pyreverse.inspector.interfaces.
+
+ These were moved since they didn't belong in astroid.
+
+ * Enable misplaced-future for Python 3. Closes issue #580.
+
+ * Add a new error, 'nonlocal-and-global', which is emitted when a
+ name is found to be both nonlocal and global in the same scope.
+ Closes issue #581.
+
+ * ignored-classes option can work with qualified names (ignored-classes=optparse.Values)
+ Closes issue #297.
+
+ * ignored-modules can work with qualified names as well as with Unix pattern
+ matching for recursive ignoring. Closes issues #244.
+
+ * Improve detection of relative imports in non-packages, as well as importing
+ missing modules with a relative import from a package.
+
+ * Don't emit no-init if not all the bases from a class are known.
+ Closes issue #604.
+
+ * --no-space-check option accepts ``empty-line`` as a possible option.
+ Closes issue #541.
+
+ * --generate-rcfile generates by default human readable symbols
+ for the --disable option. Closes issue #608.
+
+ * Improved the not-in-loop checker to properly detect more cases.
+
+ * Add a new error, 'continue-in-finally', which is emitted when
+ the ``continue`` keyword is found inside a ``finally`` clause, which
+ is a SyntaxError.
+
+ * The --zope flag is deprecated and it is slated for removal
+ in Pylint 1.6.
+
+ The reason behind this removal is the fact that it's a specialized
+ flag and there are solutions for the original problem:
+ use --generated-members with the members that causes problems
+ when using Zope or add AST transforms tailored to the zope
+ project.
+
+ At the same time, --include-ids and --symbols will also be removed
+ in Pylint 1.6. Closes issue #570.
+
+ * missing-module-attribute was removed and the corresponding
+ CLI option, required-attributes, which is slated for removal
+ in Pylint 1.6.
+
+ * missing-reversed-argument was removed.
+
+ The reason behind this is that this kind of errors should be
+ detected by the type checker for *all* the builtins and not
+ as a special case for the reversed builtin. This will happen
+ shortly in the future.
+
+ * --comment flag is obsolete and it will be removed in Pylint 1.6.
+
+ * --profile flag is obsolete and it will be removed in Pylint 1.6.
+
+ * Add a new error, 'misplaced-bare-raise'.
+
+ The error is used when a bare raise is not used inside an except clause.
+ This can generate a RuntimeError in Python, if there are no active exceptions
+ to be reraised. While it works in Python 2 due to the fact that the exception
+ leaks outside of the except block, it's nevertheless a behaviour that
+ a user shouldn't depend upon, since it's not obvious to the reader of the code
+ what exception will be raised and it will not be compatible with Python 3 anyhow.
+ Closes issue #633.
+
+ * Bring logilab-common's ureports into pylint.reporters.
+
+ With this change, we moved away from depending on logilab-common,
+ having in Pylint all the components that were used from logilab-common.
+ The API should be considered an implementation detail and can change at
+ some point in the future.
+ Closes issue #621.
+
+ * ``reimported`` is emitted for reimported objects on the same line.
+
+ Closes issue #639.
+
+ * Abbreviations of command line options are not supported anymore.
+
+ Using abbreviations for CLI options was never considered to be
+ a feature of pylint, this fact being only a side effect of using optparse.
+ As this was the case, using --load-plugin or other abbreviation
+ for --load-plugins never actually worked, while it also didn't raise
+ an error. Closes issue #424.
+
+ * Add a new error, 'nonlocal-without-binding'
+
+ The error is emitted on Python 3 when a nonlocal name is not bound
+ to any variable in the parents scopes. Closes issue #582.
+
+ * 'deprecated-module' can be shown for modules which aren't
+ available. Closes issue #362.
+
+ * Don't consider a class abstract if its members can't
+ be properly inferred.
+
+ This fixes a false positive related to abstract-class-instantiated.
+ Closes issue #648.
+
+ * Add a new checker for the async features added by PEP 492.
+
+ * Add a new error, 'yield-inside-async-function', emitted on
+ Python 3.5 and upwards when the ``yield`` statement is found inside
+ a new coroutine function (PEP 492).
+
+ * Add a new error, 'not-async-context-manager', emitted when
+ an async context manager block is used with an object which doesn't
+ support this protocol (PEP 492).
+
+ * Add a new convention warning, 'singleton-comparison', emitted when
+ comparison to True, False or None is found.
+
+ * Don't emit 'assigning-non-slot' for descriptors. Closes issue #652.
+
+ * Add a new error, 'repeated-keyword', when a keyword argument is passed
+ multiple times into a function call.
+
+ This is similar with redundant-keyword-arg, but it's mildly different
+ that it needs to be a separate error.
+
+ * --enable=all can now be used. Closes issue #142.
+
+ * Add a new convention message, 'misplaced-comparison-constant',
+ emitted when a constant is placed in the left hand side of a comparison,
+ as in '5 == func()'. This is also called Yoda condition, since the
+ flow of code reminds of the Star Wars green character, conditions usually
+ encountered in languages with variabile assignments in conditional
+ statements.
+
+ * Add a new convention message, 'consider-using-enumerate', which is
+ emitted when code that uses ``range`` and ``len`` for iterating is encountered.
+ Closes issue #684.
+
+ * Added two new refactoring messages, 'no-classmethod-decorator' and
+ 'no-staticmethod-decorator', which are emitted when a static method or a class
+ method is declared without using decorators syntax.
+
+ Closes issue #675.
+
+
+
+What's New in Pylint 1.4.3?
+===========================
+
+Release date: 2015-03-14
+
+
+ * Remove three warnings: star-args, abstract-class-little-used,
+ abstract-class-not-used. These warnings don't add any real value
+ and they don't imply errors or problems in the code.
+
+ * Added a new option for controlling the peephole optimizer in astroid.
+ The option ``--optimize-ast`` will control the peephole optimizer,
+ which is used to optimize a couple of AST subtrees. The current problem
+ solved by the peephole optimizer is when multiple joined strings,
+ with the addition operator, are encountered. If the numbers of such
+ strings is high enough, Pylint will then fail with a maximum recursion
+ depth exceeded error, due to its visitor architecture. The peephole
+ just transforms such calls, if it can, into the final resulting string
+ and this exhibit a problem, because the visit_binop method stops being
+ called (in the optimized AST it will be a Const node).
+
+
+What's New in Pylint 1.4.2?
+===========================
+
+Release date: 2015-03-11
+
+ * Don't require a docstring for empty modules. Closes issue #261.
+
+ * Fix a false positive with ``too-few-format-args`` string warning,
+ emitted when the string format contained a normal positional
+ argument ('{0}'), mixed with a positional argument which did
+ an attribute access ('{0.__class__}').
+ Closes issue #463.
+
+ * Take in account all the methods from the ancestors
+ when checking for too-few-public-methods. Closes issue #471.
+
+ * Catch enchant errors and emit 'invalid-characters-in-docstring'
+ when checking for spelling errors. Closes issue #469.
+
+ * Use all the inferred statements for the super-init-not-called
+ check. Closes issue #389.
+
+ * Add a new warning, 'unichr-builtin', emitted by the Python 3
+ porting checker, when the unichr builtin is found. Closes issue #472.
+
+ * Add a new warning, 'intern-builtin', emitted by the Python 3
+ porting checker, when the intern builtin is found. Closes issue #473.
+
+ * Add support for editable installations.
+
+ * The HTML output accepts the ``--msg-template`` option. Patch by
+ Dan Goldsmith.
+
+ * Add 'map-builtin-not-iterating' (replacing 'implicit-map-evaluation'),
+ 'zip-builtin-not-iterating', 'range-builtin-not-iterating', and
+ 'filter-builtin-not-iterating' which are emitted by ``--py3k`` when the
+ appropriate built-in is not used in an iterating context (semantics
+ taken from 2to3).
+
+ * Add a new warning, 'unidiomatic-typecheck', emitted when an explicit
+ typecheck uses type() instead of isinstance(). For example,
+ `type(x) == Y` instead of `isinstance(x, Y)`. Patch by Chris Rebert.
+ Closes issue #299.
+
+ * Add support for combining the Python 3 checker mode with the --jobs
+ flag (--py3k and --jobs). Closes issue #467.
+
+ * Add a new warning for the Python 3 porting checker, 'using-cmp-argument',
+ emitted when the ``cmp`` argument for the ``list.sort`` or ``sorted builtin``
+ is encountered.
+
+ * Make the --py3k flag commutative with the -E flag. Also, this patch
+ fixes the leaks of error messages from the Python 3 checker when
+ the errors mode was activated. Closes issue #437.
+
+
+What's New in Pylint 1.4.1?
+===========================
+
+Release date: 2015-01-16
+
+ * Look only in the current function's scope for bad-super-call.
+ Closes issue #403.
+
+ * Check the return of properties when checking for not-callable.
+ Closes issue #406.
+
+ * Warn about using the input() or round() built-ins for Python 3.
+ Closes issue #411.
+
+ * Proper abstract method lookup while checking for
+ abstract-class-instantiated. Closes issue #401.
+
+ * Use a mro traversal for finding abstract methods. Closes issue #415.
+
+ * Fix a false positive with catching-non-exception and tuples of
+ exceptions.
+
+ * Fix a false negative with raising-non-exception, when the raise used
+ an uninferrable exception context.
+
+ * Fix a false positive on Python 2 for raising-bad-type, when
+ raising tuples in the form 'raise (ZeroDivisionError, None)'.
+
+ * Fix a false positive with invalid-slots-objects, where the slot entry
+ was a unicode string on Python 2. Closes issue #421.
+
+ * Add a new warning, 'redundant-unittest-assert', emitted when using
+ unittest's methods assertTrue and assertFalse with constant value
+ as argument. Patch by Vlad Temian.
+
+ * Add a new JSON reporter, usable through -f flag.
+
+ * Add the method names for the 'signature-differs' and 'argument-differs'
+ warnings. Closes issue #433.
+
+ * Don't compile test files when installing.
+
+ * Fix a crash which occurred when using multiple jobs and the files
+ given as argument didn't exist at all.
+
+
+What's New in Pylint 1.4.0?
+============================
+
+Release date: 2014-11-23
+
+
+ * Added new options for controlling the loading of C extensions.
+ By default, only C extensions from the stdlib will be loaded
+ into the active Python interpreter for inspection, because they
+ can run arbitrary code on import. The option
+ ``--extension-pkg-whitelist`` can be used to specify modules
+ or packages that are safe to load.
+
+ * Change default max-line-length to 100 rather than 80
+
+ * Drop BaseRawChecker class which were only there for backward
+ compat for a while now
+
+ * Don't try to analyze string formatting with objects coming from
+ function arguments. Closes issue #373.
+
+ * Port source code to be Python 2/3 compatible. This drops the
+ need for 2to3, but does drop support for Python 2.5.
+
+ * Each message now comes with a confidence level attached, and
+ can be filtered base on this level. This allows to filter out
+ all messages that were emitted even though an inference failure
+ happened during checking.
+
+ * Improved presenting unused-import message. Closes issue #293.
+
+ * Add new checker for finding spelling errors. New messages:
+ wrong-spelling-in-comment, wrong-spelling-in-docstring.
+ New options: spelling-dict, spelling-ignore-words.
+
+ * Add new '-j' option for running checks in sub-processes.
+
+ * Added new checks for line endings if they are mixed (LF vs CRLF)
+ or if they are not as expected. New messages: mixed-line-endings,
+ unexpected-line-ending-format. New option: expected-line-ending-format.
+
+ * 'dangerous-default-value' no longer evaluates the value of the arguments,
+ which could result in long error messages or sensitive data being leaked.
+ Closes issue #282
+
+ * Fix a false positive with string formatting checker, when
+ encountering a string which uses only position-based arguments.
+ Closes issue #285.
+
+ * Fix a false positive with string formatting checker, when using
+ keyword argument packing. Closes issue #288.
+
+ * Proper handle class level scope for lambdas.
+
+ * Handle 'too-few-format-args' or 'too-many-format-args' for format
+ strings with both named and positional fields. Closes issue #286.
+
+ * Analyze only strings by the string format checker. Closes issue #287.
+
+ * Properly handle nested format string fields. Closes issue #294.
+
+ * Don't emit 'attribute-defined-outside-init' if the attribute
+ was set by a function call in a defining method. Closes issue #192.
+
+ * Properly handle unicode format strings for Python 2.
+ Closes issue #296.
+
+ * Don't emit 'import-error' if an import was protected by a try-except,
+ which excepted ImportError.
+
+ * Fix an 'unused-import' false positive, when the error was emitted
+ for all the members imported with 'from import' form.
+ Closes issue #304.
+
+ * Don't emit 'invalid-name' when assigning a name in an
+ ImportError handler. Closes issue #302.
+
+ * Don't count branches from nested functions.
+
+ * Fix a false positive with 'too-few-format-args', when the format
+ strings contains duplicate manual position arguments.
+ Closes issue #310.
+
+ * fixme regex handles comments without spaces after the hash.
+ Closes issue #311.
+
+ * Don't emit 'unused-import' when a special object is imported
+ (__all__, __doc__ etc.). Closes issue #309.
+
+ * Look in the metaclass, if defined, for members not found in the current
+ class. Closes issue #306.
+
+ * Don't emit 'protected-access' if the attribute is accessed using
+ a property defined at the class level.
+
+ * Detect calls of the parent's __init__, through a binded super() call.
+
+ * Check that a class has an explicitly defined metaclass before
+ emitting 'old-style-class' for Python 2.
+
+ * Emit 'catching-non-exception' for non-class nodes. Closes issue #303.
+
+ * Order of reporting is consistent.
+
+ * Add a new warning, 'boolean-datetime', emitted when an instance
+ of 'datetime.time' is used in a boolean context. Closes issue #239.
+
+ * Fix a crash which occurred while checking for 'method-hidden',
+ when the parent frame was something different than a function.
+
+ * Generate html output for missing files. Closes issue #320.
+
+ * Fix a false positive with 'too-many-format-args', when the format
+ string contains mixed attribute access arguments and manual
+ fields. Closes issue #322.
+
+ * Extend the cases where 'undefined-variable' and 'used-before-assignment'
+ can be detected. Closes issue #291.
+
+ * Add support for customising callback identifiers, by adding a new
+ '--callbacks' command line option. Closes issue #326.
+
+ * Add a new warning, 'logging-format-interpolation', emitted when .format()
+ string interpolation is used within logging function calls.
+
+ * Don't emit 'unbalanced-tuple-unpacking' when the rhs of the assignment
+ is a variable length argument. Closes issue #329.
+
+ * Add a new warning, 'inherit-non-class', emitted when a class inherits
+ from something which is not a class. Closes issue #331.
+
+ * Fix another false positives with 'undefined-variable', where the variable
+ can be found as a class assignment and used in a function annotation.
+ Closes issue #342.
+
+ * Handle assignment of the string format method to a variable.
+ Closes issue #351.
+
+ * Support wheel packaging format for PyPi. Closes issue #334.
+
+ * Check that various built-ins that do not exist in Python 3 are not
+ used: apply, basestring, buffer, cmp, coerce, execfile, file, long
+ raw_input, reduce, StandardError, unicode, reload and xrange.
+
+ * Warn for magic methods which are not used in any way in Python 3:
+ __coerce__, __delslice__, __getslice__, __setslice__, __cmp__,
+ __oct__, __nonzero__ and __hex__.
+
+ * Don't emit 'assigning-non-slot' when the assignment is for a property.
+ Closes issue #359.
+
+ * Fix for regression: '{path}' was no longer accepted in '--msg-template'.
+
+ * Report the percentage of all messages, not just for errors and warnings.
+ Closes issue #319.
+
+ * 'too-many-public-methods' is reported only for methods defined in a class,
+ not in its ancestors. Closes issue #248.
+
+ * 'too-many-lines' disable pragma can be located on any line, not only the
+ first. Closes issue #321.
+
+ * Warn in Python 2 when an import statement is found without a
+ corresponding ``from __future__ import absolute_import``.
+
+ * Warn in Python 2 when a non-floor division operation is found without
+ a corresponding ``from __future__ import division``.
+
+ * Add a new option, 'exclude-protected', for excluding members
+ from the protected-access warning. Closes issue #48.
+
+ * Warn in Python 2 when using dict.iter*(), dict.view*(); none of these
+ methods are available in Python 3.
+
+ * Warn in Python 2 when calling an object's next() method; Python 3 uses
+ __next__() instead.
+
+ * Warn when assigning to __metaclass__ at a class scope; in Python 3 a
+ metaclass is specified as an argument to the 'class' statement.
+
+ * Warn when performing parameter tuple unpacking; it is not supported in
+ Python 3.
+
+ * 'abstract-class-instantiated' is also emitted for Python 2.
+ It was previously disabled.
+
+ * Add 'long-suffix' error, emitted when encountering the long suffix
+ on numbers.
+
+ * Add support for disabling a checker, by specifying an 'enabled'
+ attribute on the checker class.
+
+ * Add a new CLI option, --py3k, for enabling Python 3 porting mode. This
+ mode will disable all other checkers and will emit warnings and
+ errors for constructs which are invalid or removed in Python 3.
+
+ * Add 'old-octal-literal' to Python 3 porting checker, emitted when
+ encountering octals with the old syntax.
+
+ * Add 'implicit-map-evaluation' to Python 3 porting checker, emitted
+ when encountering the use of map builtin, without explicit evaluation.
+
+
+
+What's New in Pylint 1.3.0?
+===========================
+
+Release date: 2014-07-26
+
+ * Allow hanging continued indentation for implicitly concatenated
+ strings. Closes issue #232.
+
+ * Pylint works under Python 2.5 again, and its test suite passes.
+
+ * Fix some false positives for the cellvar-from-loop warnings.
+ Closes issue #233.
+
+ * Return new astroid class nodes when the inferencer can detect that
+ that result of a function invocation on a type (like ``type`` or
+ `abc.ABCMeta`) is requested. Closes #205.
+
+ * Emit 'undefined-variable' for undefined names when using the
+ Python 3 ``metaclass=`` argument.
+
+ * Checkers respect priority now. Close issue #229.
+
+ * Fix a false positive regarding W0511. Closes issue #149.
+
+ * Fix unused-import false positive with Python 3 metaclasses (#143).
+
+ * Don't warn with 'bad-format-character' when encountering
+ the 'a' format on Python 3.
+
+ * Add multiple checks for PEP 3101 advanced string formatting:
+ 'bad-format-string', 'missing-format-argument-key',
+ 'unused-format-string-argument', 'format-combined-specification',
+ 'missing-format-attribute' and 'invalid-format-index'.
+
+ * Issue broad-except and bare-except even if the number
+ of except handlers is different than 1. Fixes issue #113.
+
+ * Issue attribute-defined-outside-init for all cases, not just
+ for the last assignment. Closes issue #262.
+
+ * Emit 'not-callable' when calling properties. Closes issue #268.
+
+ * Fix a false positive with unbalanced iterable unpacking,
+ when encountering starred nodes. Closes issue #273.
+
+ * Add new checks, 'invalid-slice-index' and 'invalid-sequence-index'
+ for invalid sequence and slice indices.
+
+ * Add 'assigning-non-slot' warning, which detects assignments to
+ attributes not defined in slots.
+
+ * Don't emit 'no-name-in-module' for ignored modules.
+ Closes issue #223.
+
+ * Fix an 'unused-variable' false positive, where the variable is
+ assigned through an import. Closes issue #196.
+
+ * Definition order is considered for classes, function arguments
+ and annotations. Closes issue #257.
+
+ * Don't emit 'unused-variable' when assigning to a nonlocal.
+ Closes issue #275.
+
+ * Do not let ImportError propagate from the import checker, leading to crash
+ in some namespace package related cases. Closes issue #203.
+
+ * Don't emit 'pointless-string-statement' for attribute docstrings.
+ Closes issue #193.
+
+ * Use the proper mode for pickle when opening and writing the stats file.
+ Closes issue #148.
+
+ * Don't emit hidden-method message when the attribute has been
+ monkey-patched, you're on your own when you do that.
+
+ * Only emit attribute-defined-outside-init for definition within the same
+ module as the offended class, avoiding to mangle the output in some cases.
+
+ * Don't emit 'unnecessary-lambda' if the body of the lambda call contains
+ call chaining. Closes issue #243.
+
+ * Don't emit 'missing-docstring' when the actual docstring uses ``.format``.
+ Closes issue #281.
+
+
+What's New in Pylint 1.2.1?
+===========================
+
+Release date: 2014-04-30
+
+ * Restore the ability to specify the init-hook option via the
+ configuration file, which was accidentally broken in 1.2.0.
+
+ * Add a new warning [bad-continuation] for badly indentend continued
+ lines.
+
+ * Emit [assignment-from-none] when the function contains bare returns.
+ Fixes BitBucket issue #191.
+
+ * Added a new warning for closing over variables that are
+ defined in loops. Fixes Bitbucket issue #176.
+
+ * Do not warn about \u escapes in string literals when Unicode literals
+ are used for Python 2.*. Fixes BitBucket issue #151.
+
+ * Extend the checking for unbalanced-tuple-unpacking and
+ unpacking-non-sequence to instance attribute unpacking as well.
+
+ * Fix explicit checking of python script (1.2 regression, #219)
+
+ * Restore --init-hook, renamed accidentally into --init-hooks in 1.2.0
+ (#211)
+
+ * Add 'indexing-exception' warning, which detects that indexing
+ an exception occurs in Python 2 (behaviour removed in Python 3).
+
+
+What's New in Pylint 1.2.0?
+===========================
+
+Release date: 2014-04-18
+
+ * Pass the current python paths to pylint process when invoked via
+ epylint. Fixes BitBucket issue #133.
+
+ * Add -i / --include-ids and -s / --symbols back as completely ignored
+ options. Fixes BitBucket issue #180.
+
+ * Extend the number of cases in which logging calls are detected. Fixes
+ bitbucket issue #182.
+
+ * Improve pragma handling to not detect pylint:* strings in non-comments.
+ Fixes BitBucket issue #79.
+
+ * Do not crash with UnknownMessage if an unknown message ID/name appears
+ in disable or enable in the configuration. Patch by Cole Robinson.
+ Fixes bitbucket issue #170.
+
+ * Add new warning 'eval-used', checking that the builtin function ``eval``
+ was used.
+
+ * Make it possible to show a naming hint for invalid name by setting
+ include-naming-hint. Also make the naming hints configurable. Fixes
+ BitBucket issue #138.
+
+ * Added support for enforcing multiple, but consistent name styles for
+ different name types inside a single module; based on a patch written
+ by morbo@google.com.
+
+ * Also warn about empty docstrings on overridden methods; contributed
+ by sebastianu@google.com.
+
+ * Also inspect arguments to constructor calls, and emit relevant
+ warnings; contributed by sebastianu@google.com.
+
+ * Added a new configuration option logging-modules to make the list
+ of module names that can be checked for 'logging-not-lazy' et. al.
+ configurable; contributed by morbo@google.com.
+
+ * ensure init-hooks is evaluated before other options, notably load-plugins
+ (#166)
+
+ * Python 2.5 support restored: fixed small issues preventing pylint to run
+ on python 2.5. Bitbucket issues #50 and #62.
+
+ * bitbucket #128: pylint doesn't crash when looking
+ for used-before-assignment in context manager
+ assignments.
+
+ * Add new warning, 'bad-reversed-sequence', for checking that the
+ reversed() builtin receive a sequence (implements __getitem__ and __len__,
+ without being a dict or a dict subclass) or an instance which implements
+ __reversed__.
+
+ * Mark ``file`` as a bad function when using python2 (closes #8).
+
+ * Add new warning 'bad-exception-context', checking
+ that ``raise ... from ...`` uses a proper exception context
+ (None or an exception).
+
+ * Enhance the check for 'used-before-assignment' to look
+ for 'nonlocal' uses.
+
+ * Emit 'undefined-all-variable' if a package's __all__
+ variable contains a missing submodule (closes #126).
+
+ * Add a new warning 'abstract-class-instantiated' for checking
+ that abstract classes created with ``abc`` module and
+ with abstract methods are instantied.
+
+ * Do not warn about 'return-arg-in-generator' in Python 3.3+.
+
+ * Do not warn about 'abstract-method' when the abstract method
+ is implemented through assignment (#155).
+
+ * Improve cyclic import detection in the case of packages, patch by Buck
+ Golemon
+
+ * Add new warnings for checking proper class __slots__:
+ ``invalid-slots-object`` and ``invalid-slots``.
+
+ * Search for rc file in `~/.config/pylintrc` if `~/.pylintrc`
+ doesn't exists (#121)
+
+ * Don't register the newstyle checker w/ python >= 3
+
+ * Fix unused-import false positive w/ augment assignment (#78)
+
+ * Fix access-member-before-definition false negative wrt aug assign (#164)
+
+ * Do not attempt to analyze non python file, eg .so file (#122)
+
+
+What's New in Pylint 1.1.0?
+===========================
+
+Release date: 2013-12-22
+
+ * Add new check for use of deprecated pragma directives "pylint:disable-msg"
+ or "pylint:enable-msg" (I0022, deprecated-pragma) which was previously
+ emitted as a regular warn().
+
+ * Avoid false used-before-assignment for except handler defined
+ identifier used on the same line (#111).
+
+ * Combine 'no-space-after-operator', 'no-space-after-comma' and
+ 'no-space-before-operator' into a new warning 'bad-whitespace'.
+
+ * Add a new warning 'superfluous-parens' for unnecessary
+ parentheses after certain keywords.
+
+ * Fix a potential crash in the redefine-in-handler warning
+ if the redefined name is a nested getattr node.
+
+ * Add a new option for the multi-statement warning to
+ allow single-line if statements.
+
+ * Add 'bad-context-manager' error, checking that '__exit__'
+ special method accepts the right number of arguments.
+
+ * Run pylint as a python module 'python -m pylint' (anatoly techtonik).
+
+ * Check for non-exception classes inside an except clause.
+
+ * epylint support options to give to pylint after the file to analyze and
+ have basic input validation (bitbucket #53 and #54), patches provided by
+ felipeochoa and Brian Lane.
+
+ * Added a new warning, 'non-iterator-returned', for non-iterators
+ returned by '__iter__'.
+
+ * Add new checks for unpacking non-sequences in assignments
+ (unpacking-non-sequence) as well as unbalanced tuple unpacking
+ (unbalanced-tuple-unpacking).
+
+ * useless-else-on-loop not emitted if there is a break in the
+ else clause of inner loop (#117).
+
+ * don't mark ``input`` as a bad function when using python3 (#110).
+
+ * badly-implemented-container caused several problems in its
+ current implementation. Deactivate it until we have something
+ better. See #112 for instance.
+
+ * Use attribute regexp for properties in python3, as in python2
+
+ * Create the PYLINTHOME directory when needed, it might fail and lead to
+ spurious warnings on import of pylint.config.
+
+ * Fix setup.py so that pylint properly install on Windows when using python3
+
+ * Various documentation fixes and enhancements
+
+ * Fix issue #55 (false-positive trailing-whitespace on Windows)
+
+
+What's New in Pylint 1.0.0?
+===========================
+
+Release date: 2013-08-06
+
+
+ * Add check for the use of 'exec' function
+
+ * New --msg-template option to control output, deprecating "msvc" and
+ "parseable" output formats as well as killing ``--include-ids`` and ``--symbols``
+ options
+
+ * Do not emit [fixme] for every line if the config value 'notes'
+ is empty, but [fixme] is enabled.
+
+ * Emit warnings about lines exceeding the column limit when
+ those lines are inside multiline docstrings.
+
+ * Do not double-check parameter names with the regex for parameters and
+ inline variables.
+
+ * Added a new warning missing-final-newline (C0304) for files missing
+ the final newline.
+
+ * Methods that are decorated as properties are now treated as attributes
+ for the purposes of name checking.
+
+ * Names of derived instance class member are not checked any more.
+
+ * Names in global statements are now checked against the regular
+ expression for constants.
+
+ * For toplevel name assignment, the class name regex will be used if
+ pylint can detect that value on the right-hand side is a class
+ (like collections.namedtuple()).
+
+ * Simplified invalid-name message
+
+ * Added a new warning invalid-encoded-data (W0512) for files that
+ contain data that cannot be decoded with the specified or
+ default encoding.
+
+ * New warning bad-open-mode (W1501) for calls to open (or file) that
+ specify invalid open modes (Original implementation by Sasha Issayev).
+
+ * New warning old-style-class (C1001) for classes that do not have any
+ base class.
+
+ * Add new name type 'class_attribute' for attributes defined
+ in class scope. By default, allow both const and variable names.
+
+ * New warning trailing-whitespace (C0303) that warns about
+ trailing whitespace.
+
+ * Added a new warning unpacking-in-except (W0712) about unpacking
+ exceptions in handlers, which is unsupported in Python 3.
+
+ * Add a configuration option for missing-docstring to
+ optionally exempt short functions/methods/classes from
+ the check.
+
+ * Add the type of the offending node to missing-docstring
+ and empty-docstring.
+
+ * New utility classes for per-checker unittests in testutils.py
+
+ * Do not warn about redefinitions of variables that match the
+ dummy regex.
+
+ * Do not treat all variables starting with _ as dummy variables,
+ only _ itself.
+
+ * Make the line-too-long warning configurable by adding a regex for lines
+ for with the length limit should not be enforced
+
+ * Do not warn about a long line if a pylint disable
+ option brings it above the length limit
+
+ * Do not flag names in nested with statements as undefined.
+
+ * Added a new warning 'old-raise-syntax' for the deprecated syntax
+ raise Exception, args
+
+ * Support for PEP 3102 and new missing-kwoa (E1125) message for missing
+ mandatory keyword argument (logilab.org's #107788)
+
+ * Fix spelling of max-branchs option, now max-branches
+
+ * Added a new base class and interface for checkers that work on the
+ tokens rather than the syntax, and only tokenize the input file
+ once.
+
+ * Follow astng renaming to astroid
+
+ * bitbucket #37: check for unbalanced unpacking in assignments
+
+ * bitbucket #25: fix incomplete-protocol false positive for read-only
+ containers like tuple
+
+ * bitbucket #16: fix False positive E1003 on Python 3 for argument-less super()
+
+ * bitbucket #6: put back documentation in source distribution
+
+ * bitbucket #15: epylint shouldn't hang anymore when there is a large
+ output on pylint'stderr
+
+ * bitbucket #7: fix epylint w/ python3
+
+ * bitbucket #3: remove string module from the default list of deprecated
+ modules
+
+
+What's New in Pylint 0.28.0?
+============================
+
+Release date: 2013-04-25
+
+ * bitbucket #1: fix "dictionary changed size during iteration" crash
+
+ * #74013: new E1310[bad-str-strip-call] message warning when a call to a
+ {l,r,}strip method contains duplicate characters (patch by Torsten Marek)
+
+ * #123233: new E0108[duplicate-argument-name] message reporting duplicate
+ argument names
+
+ * #81378: emit W0120[useless-else-on-loop] for loops without break
+
+ * #124660: internal dependencies should not appear in external dependencies
+ report
+
+ * #124662: fix name error causing crash when symbols are included in output
+ messages
+
+ * #123285: apply pragmas for warnings attached to lines to physical source
+ code lines
+
+ * #123259: do not emit E0105 for yield expressions inside lambdas
+
+ * #123892: don't crash when attempting to show source code line that can't
+ be encoded with the current locale settings
+
+ * Simplify checks for dangerous default values by unifying tests for all
+ different mutable compound literals.
+
+ * Improve the description for E1124[redundant-keyword-arg]
+
+
+What's New in Pylint 0.27.0?
+============================
+
+Release date: 2013-02-26
+
+ * #20693: replace pylint.el by Ian Eure version (patch by J.Kotta)
+
+ * #105327: add support for --disable=all option and deprecate the
+ 'disable-all' inline directive in favour of 'skip-file' (patch by
+ A.Fayolle)
+
+ * #110840: add messages I0020 and I0021 for reporting of suppressed
+ messages and useless suppression pragmas. (patch by Torsten Marek)
+
+ * #112728: add warning E0604 for non-string objects in __all__
+ (patch by Torsten Marek)
+
+ * #120657: add warning W0110/deprecated-lambda when a map/filter
+ of a lambda could be a comprehension (patch by Martin Pool)
+
+ * #113231: logging checker now looks at instances of Logger classes
+ in addition to the base logging module. (patch by Mike Bryant)
+
+ * #111799: don't warn about octal escape sequence, but warn about \o
+ which is not octal in Python (patch by Martin Pool)
+
+ * #110839: bind <F5> to Run button in pylint-gui
+
+ * #115580: fix erroneous W0212 (access to protected member) on super call
+ (patch by Martin Pool)
+
+ * #110853: fix a crash when an __init__ method in a base class has been
+ created by assignment rather than direct function definition (patch by
+ Torsten Marek)
+
+ * #110838: fix pylint-gui crash when include-ids is activated (patch by
+ Omega Weapon)
+
+ * #112667: fix emission of reimport warnings for mixed imports and extend
+ the testcase (patch by Torsten Marek)
+
+ * #112698: fix crash related to non-inferable __all__ attributes and
+ invalid __all__ contents (patch by Torsten Marek)
+
+ * Python 3 related fixes:
+
+ * #110213: fix import of checkers broken with python 3.3, causing
+ "No such message id W0704" breakage
+
+ * #120635: redefine cmp function used in pylint.reporters
+
+ * Include full warning id for I0020 and I0021 and make sure to flush
+ warnings after each module, not at the end of the pylint run.
+ (patch by Torsten Marek)
+
+ * Changed the regular expression for inline options so that it must be
+ preceded by a # (patch by Torsten Marek)
+
+ * Make dot output for import graph predictable and not depend
+ on ordering of strings in hashes. (patch by Torsten Marek)
+
+ * Add hooks for import path setup and move pylint's sys.path
+ modifications into them. (patch by Torsten Marek)
+
+
+What's New in Pylint 0.26.0?
+============================
+
+Release date: 2012-10-05
+
+ * #106534: add --ignore-imports option to code similarity checking
+ and 'symilar' command line tool (patch by Ry4an Brase)
+
+ * #104571: check for anomalous backslash escape, introducing new
+ W1401 and W1402 messages (patch by Martin Pool)
+
+ * #100707: check for boolop being used as exception class, introducing
+ new W0711 message (patch by Tim Hatch)
+
+ * #4014: improve checking of metaclass methods first args, introducing
+ new C0204 message (patch by lothiraldan@gmail.com finalized by sthenault)
+
+ * #4685: check for consistency of a module's __all__ variable,
+ introducing new E0603 message
+
+ * #105337: allow custom reporter in output-format (patch by Kevin Jing Qiu)
+
+ * #104420: check for protocol completness and avoid false R0903
+ (patch by Peter Hammond)
+
+ * #100654: fix grammatical error for W0332 message (using 'l' as
+ long int identifier)
+
+ * #103656: fix W0231 false positive for missing call to object.__init__
+ (patch by lothiraldan@gmail.com)
+
+ * #63424: fix similarity report disabling by properly renaming it to RP0801
+
+ * #103949: create a console_scripts entry point to be used by
+ easy_install, buildout and pip
+
+ * fix cross-interpreter issue (non compatible access to __builtins__)
+
+ * stop including tests files in distribution, they causes crash when
+ installed with python3 (#72022, #82417, #76910)
+
+
+What's New in Pylint 0.25.2?
+============================
+
+Release date: 2012-07-17
+
+ * #93591: Correctly emit warnings about clobbered variable names when an
+ except handler contains a tuple of names instead of a single name.
+ (patch by tmarek@google.com)
+
+ * #7394: W0212 (access to protected member) not emitted on assigments
+ (patch by lothiraldan@gmail.com)
+
+ * #18772; no prototype consistency check for mangled methods (patch by
+ lothiraldan@gmail.com)
+
+ * #92911: emit W0102 when sets are used as default arguments in functions
+ (patch by tmarek@google.com)
+
+ * #77982: do not emit E0602 for loop variables of comprehensions
+ used as argument values inside a decorator (patch by tmarek@google.com)
+
+ * #89092: don't emit E0202 (attribute hiding a method) on @property methods
+
+ * #92584: fix pylint-gui crash due to internal API change
+
+ * #87192: fix crash when decorators are accessed through more than one dot
+ (for instance @a.b is fine, @a.b.c crash)
+
+ * #88914: fix parsing of --generated-members options, leading to crash
+ when using a regexp value set
+
+ * fix potential crashes with utils.safe_infer raising InferenceError
+
+
+What's New in Pylint 0.25.1?
+============================
+
+Release date: 2011-12-08
+
+ * #81078: Warn if names in exception handlers clobber overwrite
+ existing names (patch by tmarek@google.com)
+
+ * #81113: Fix W0702 messages appearing with the wrong line number.
+ (patch by tmarek@google.com)
+
+ * #50461, #52020, #51222: Do not issue warnings when using 2.6's
+ property.setter/deleter functionality (patch by dneil@google.com)
+
+ * #9188, #4024: Do not trigger W0631 if a loop variable is assigned
+ in the else branch of a for loop.
+
+
+What's New in Pylint 0.25.0?
+============================
+
+Release date: 2011-10-7
+
+ * #74742: make allowed name for first argument of class method configurable
+ (patch by Google)
+
+ * #74087: handle case where inference of a module return YES; this avoid
+ some cases of "TypeError: '_Yes' object does not support indexing" (patch
+ by Google)
+
+ * #74745: make "too general" exception names configurable (patch by Google)
+
+ * #74747: crash occurs when lookup up a special attribute in class scope
+ (patch by google)
+
+ * #76920: crash if on eg "pylint --rcfile" (patch by Torsten Marek)
+
+ * #77237: warning for E0202 may be very misleading
+
+ * #73941: HTML report messages table is badly rendered
+
+
+What's New in Pylint 0.24.0?
+============================
+
+Release date: 2011-07-18
+
+ * #69738: add regular expressions support for "generated-members"
+
+ * ids of logging and string_format checkers have been changed:
+ logging: 65 -> 12, string_format: 99 -> 13
+ Also add documentation to say that ids of range 1-50 shall be reserved
+ to pylint internal checkers
+
+ * #69993: Additional string format checks for logging module:
+ check for missing arguments, too many arguments, or invalid string
+ formats in the logging checker module. Contributed by Daniel Arena
+
+ * #69220: add column offset to the reports. If you've a custom reporter,
+ this change may break it has now location gain a new item giving the
+ column offset.
+
+ * #60828: Fix false positive in reimport check
+
+ * #70495: absolute imports fail depending on module path (patch by Jacek Konieczny)
+
+ * #22273: Fix --ignore option documentation to match reality
+
+
+What's New in Pylint 0.23.0?
+============================
+
+Release date: 2011-01-11
+
+ * documentation update, add manpages
+
+ * several performance improvements
+
+ * finalize python3 support
+
+ * new W0106 warning 'Expression "%s" is assigned to nothing'
+
+ * drop E0501 and E0502 messages about wrong source encoding: not anymore
+ interesting since it's a syntax error for python >= 2.5 and we now only
+ support this python version and above.
+
+ * don't emit W0221 or W0222 when methods as variable arguments (eg \*arg
+ and/or \*\*args). Patch submitted by Charles Duffy.
+
+
+What's New in Pylint 0.22.0?
+============================
+
+Release date: 2010-11-15
+
+ * python versions: minimal python3.x support; drop python < 2.5 support
+
+
+What's New in Pylint 0.21.4?
+============================
+
+Release date: 2010-10-27
+
+ * fix #48066: pylint crashes when redirecting output containing non-ascii characters
+
+ * fix #19799: "pylint -blah" exit with status 2
+
+ * update documentation
+
+
+What's New in Pylint 0.21.3?
+============================
+
+Release date: 2010-09-28
+
+ * restored python 2.3 compatibility. Along with logilab-astng
+ 0.21.3 and logilab-common 0.52, this will much probably be the
+ latest release supporting python < 2.5.
+
+
+What's New in Pylint 0.21.2?
+============================
+
+Release date: 2010-08-26
+
+ * fix #36193: import checker raise exception on cyclic import
+
+ * fix #28796: regression in --generated-members introduced pylint 0.20
+
+ * some documentation cleanups
+
+
+What's New in Pylint 0.21.1?
+============================
+
+Release date: 2010-06-04
+
+ * fix #28962: pylint crash with new options, due to missing stats data while
+ writing the Statistics by types report
+
+ * updated man page to 0.21 or greater command line usage (fix debian #582494)
+
+
+What's New in Pylint 0.21.0?
+============================
+
+Release date: 2010-05-11
+
+ * command line updated (closes #9774, #9787, #9992, #22962):
+
+ * all enable-* / disable-* options have been merged into --enable / --disable
+
+ * BACKWARD INCOMPATIBLE CHANGE: short name of --errors-only becomes -E, -e being
+ affected to --enable
+
+ * pylint --help output much simplified, with --long-help available to get the
+ complete one
+
+ * revisited gui, thanks to students from Toronto university (they are great
+ contributors to this release!)
+
+ * fix #21591: html reporter produces no output if reports is set to 'no'
+
+ * fix #4581: not Missing docstring (C0111) warning if a method is overridden
+
+ * fix #4683: Non-ASCII characters count double if utf8 encode
+
+ * fix #9018: when using defining-attr-method, method order matters
+
+ * fix #4595: Comma not followed by a space should not occurs on trailing comma
+ in list/tuple/dict definition
+
+ * fix #22585: [Patch] fix man warnings for pyreverse.1 manpage
+
+ * fix #20067: AttributeError: 'NoneType' object has no attribute 'name' with with
+
+
+
+What's New in Pylint 0.20.0?
+============================
+
+Release date: 2010-03-01
+
+ * fix #19498: fix windows batch file
+
+ * fix #19339: pylint.el : non existing py-mod-map
+ (closes Debian Bug report logs - #475939)
+
+ * implement #18860, new W0199 message on assert (a, b)
+
+ * implement #9776, 'W0150' break or return statement in finally block may
+ swallow exception.
+
+ * fix #9263, __init__ and __new__ are checked for unused arguments
+
+ * fix #20991, class scope definitions ignored in a genexpr
+
+ * fix #5975, Abstract intermediate class not recognized as such
+
+ * fix #5977, yield and return statement have their own counters, no more R0911
+ (Too many return statements) when a function have many yield stamtements
+
+ * implement #5564, function / method arguments with leading "_" are ignored in
+ arguments / local variables count.
+
+ * implement #9982, E0711 specific error message when raising NotImplemented
+
+ * remove --cache-size option
+
+
+What's New in Pylint 0.19.0?
+============================
+
+Release date: 2009-12-18
+
+ * implement #18947, #5561: checker for function arguments
+
+ * include James Lingard string format checker
+
+ * include simple message (ids) listing by Vincent Ferotin (#9791)
+
+ * --errors-only does not hide fatal error anymore
+
+ * include james Lingard patches for ++/-- and duplicate key in dicts
+
+ * include James Lingard patches for function call arguments checker
+
+ * improved flymake code and doc provided by Derek Harland
+
+ * refactor and fix the imports checker
+
+ * fix #18862: E0601 false positive with lambda functions
+
+ * fix #8764: More than one statement on a single line false positive with
+ try/except/finally
+
+ * fix #9215: false undefined variable error in lambda function
+
+ * fix for w0108 false positive (Nathaniel)
+
+ * fix test/fulltest.sh
+
+ * #5821 added a utility function to run pylint in another process (patch provide by Vincent Ferotin)
+
+
+What's New in Pylint 0.18.0?
+============================
+
+Release date: 2009-03-25
+
+ * tests ok with python 2.4, 2.5, 2.6. 2.3 not tested
+
+ * fix #8687, W0613 false positive on inner function
+
+ * fix #8350, C0322 false positive on multi-line string
+
+ * fix #8332: set E0501 line no to the first line where non ascii character
+ has been found
+
+ * avoid some E0203 / E0602 false negatives by detecting respectively
+ AttributeError / NameError
+
+ * implements #4037: don't issue W0142 (* or ** magic) when they are barely
+ passed from */** arguments
+
+ * complete #5573: more complete list of special methods, also skip W0613
+ for python internal method
+
+ * don't show information messages by default
+
+ * integration of Yuen Ho Wong's patches on emacs lisp files
+
+
+What's New in Pylint 0.17.0?
+============================
+
+Release date: 2009-03-19
+
+ * semicolon check : move W0601 to W0301
+
+ * remove rpython : remove all rpython checker, modules and tests
+
+ * astng 0.18 compatibility: support for _ast module modifies interfaces
+
+
+What's New in Pylint 0.16.0?
+============================
+
+Release date: 2009-01-28
+
+ * change [en|dis]able-msg-cat options: only accept message categories
+ identified by their first letter (eg IRCWEF) without the need for comma
+ as separator
+
+ * add epylint.bat script to fix Windows installation
+
+ * setuptools/easy_install support
+
+ * include a modified version of Maarten ter Huurne patch to avoid W0613
+ warning on arguments from overridden method
+
+ * implement #5575 drop dumb W0704 message) by adding W0704 to ignored
+ messages by default
+
+ * new W0108 message, checking for suspicious lambda (provided by Nathaniel
+ Manista)
+
+ * fix W0631, false positive reported by Paul Hachmann
+
+ * fix #6951: false positive with W0104
+
+ * fix #6949
+
+ * patches by Mads Kiilerich:
+
+ * implement #4691, make pylint exits with a non zero return
+ status if any messages other then Information are issued
+
+ * fix #3711, #5626 (name resolution bug w/ decorator and class members)
+
+ * fix #6954
+
+
+What's New in Pylint 0.15.2?
+============================
+
+Release date: 2008-10-13
+
+ * fix #5672: W0706 weirdness ( W0706 removed )
+
+ * fix #5998: documentation points to wrong url for mailing list
+
+ * fix #6022: no error message on wrong module names
+
+ * fix #6040: pytest doesn't run test/func_test.py
+
+
+What's New in Pylint 0.15.1?
+============================
+
+Release date: 2008-09-15
+
+ * fix #4910: default values are missing in manpage
+
+ * fix #5991: missing files in 0.15.0 tarball
+
+ * fix #5993: epylint should work with python 2.3
+
+
+What's New in Pylint 0.15.0?
+============================
+
+Release date: 2008-09-10
+
+ * include pyreverse package and class diagram generation
+
+ * included Stefan Rank's patch to deal with 2.4 relative import
+
+ * included Robert Kirkpatrick's tutorial and typos fixes
+
+ * fix bug in reenabling message
+
+ * fix #2473: invoking pylint on __init__.py (hopefully)
+
+ * typecheck: acquired-members option has been dropped in favor of the more
+ generic generated-members option. If the zope option is set, the behaviour
+ is now to add some default values to generated-members.
+
+ * flymake integration: added bin/epylint and elisp/pylint-flymake.el
+
+
+What's New in Pylint 0.14.0?
+============================
+
+Release date: 2008-01-14
+
+ * fix #3733: Messages (dis)appear depending on order of file names
+
+ * fix #4026: pylint.el should require compile
+
+ * fix a bug in colorized reporter, spotted by Dave Borowitz
+
+ * applied patch from Stefan Rank to avoid W0410 false positive when
+ multiple "from __future__" import statements
+
+ * implement #4012: flag back tick as deprecated (new W0333 message)
+
+ * new ignored-class option on typecheck checker allowing to skip members
+ checking based on class name (patch provided by Thomas W Barr)
+
+
+What's New in Pylint 0.13.2?
+============================
+
+Release date: 2007-06-07
+
+ * fix disable-checker option so that it won't accidentally enable the
+ rpython checker which is disabled by default
+
+ * added note about the gedit plugin into documentation
+
+
+
+What's New in Pylint 0.13.1?
+============================
+
+Release date: 2007-03-02
+
+ * fix some unexplained 0.13.0 packaging issue which led to a bunch of
+ files missing from the distribution
+
+
+
+What's New in Pylint 0.13.0?
+============================
+
+Release date: 2007-02-28
+
+ * new RPython (Restricted Python) checker for PyPy fellow or people
+ wanting to get a compiled version of their python program using the
+ translator of the PyPy project. For more information about PyPy or
+ RPython, visit http://codespeak.net/pypy/
+
+ * new E0104 and E0105 messages introduced to respectively warn about
+ "return" and "yield" outside function or method
+
+ * new E0106 message when "yield" and "return something" are mixed in a
+ function or method
+
+ * new W0107 message for unnecessary pass statement
+
+ * new W0614 message to differentiate between unused ``import X`` and
+ unused `from X import *` (#3209, patch submitted by Daniel Drake)
+
+ * included Daniel Drake's patch to have a different message E1003 instead of
+ E1001 when a missing member is found but an inference failure has been
+ detected
+
+ * msvs reporter for Visual Studio line number reporting (#3285)
+
+ * allow disable-all option inline (#3218, patch submitted by Daniel Drake)
+
+ * --init-hook option to call arbitrary code necessary to set
+ environment (eg sys.path) (#3156)
+
+ * One more Daniel's patch fixing a command line option parsing
+ problem, this'll definitely be the DDrake release :)
+
+ * fix #3184: crashes on "return" outside function
+
+ * fix #3205: W0704 false positive
+
+ * fix #3123: W0212 false positive on static method
+
+ * fix #2485: W0222 false positive
+
+ * fix #3259: when a message is explicitly enabled, check the checker
+ emitting it is enabled
+
+
+What's New in Pylint 0.12.2?
+============================
+
+Release date: 2006-11-23
+
+ * fix #3143: W0233 bug w/ YES objects
+
+ * fix #3119: Off-by-one error counting lines in a file
+
+ * fix #3117: ease sys.stdout overriding for reporters
+
+ * fix #2508: E0601 false positive with lambda
+
+ * fix #3125: E1101 false positive and a message duplication. Only the last part
+ is actually fixed since the initial false positive is due to dynamic setting of
+ attributes on the decimal.Context class.
+
+ * fix #3149: E0101 false positives and introduced E0100 for generator __init__
+ methods
+
+ * fixed some format checker false positives
+
+
+What's New in Pylint 0.12.1?
+============================
+
+
+Release date: 2006-09-25
+
+ * fixed python >= 2.4 format false positive with multiple lines statement
+
+ * fixed some 2.5 issues
+
+ * fixed generator expression scope bug (depends on astng 0.16.1)
+
+ * stop requiring __revision__
+
+
+What's New in Pylint 0.12.0?
+============================
+
+
+Release date: 2006-08-10
+
+ * usability changes:
+
+ * parseable, html and color options are now handled by a single
+ output-format option
+
+ * enable-<checkerid> and disable-all options are now handled by
+ two (exclusive) enable-checker and disable-checker options
+ taking a comma separated list of checker names as value
+
+ * renamed debug-mode option to errors-only
+
+ * started a reference user manual
+
+ * new W0212 message for access to protected member from client code
+ (close #14081)
+
+ * new W0105 and W0106 messages extracted from W0104 (statement seems
+ to have no effect) respectively when the statement is actually string
+ (that's sometimes used instead of comments for documentation) or an
+ empty statement generated by a useless semicolon
+
+ * reclassified W0302 to C0302
+
+ * fix so that global messages are not anymore connected to the last
+ analyzed module (close #10106)
+
+ * fix some bugs related to local disabling of messages
+
+ * fix cr/lf pb when generating the rc file on windows platforms
+
+
+What's New in Pylint 0.11.0?
+============================
+
+Release date: 2006-04-19
+
+ * fix crash caused by the exceptions checker in some case
+
+ * fix some E1101 false positive with abstract method or classes defining
+ __getattr__
+
+ * dirty fix to avoid "_socketobject" has not "connect" member. The actual
+ problem is that astng isn't able to understand the code used to create
+ socket.socket object with exec
+
+ * added an option in the similarity checker to ignore docstrings, enabled
+ by default
+
+ * included patch from Benjamin Niemann to allow block level
+ enabling/disabling of messages
+
+
+What's New in Pylint 0.10.0?
+============================
+
+Release date: 2006-03-06
+
+ * WARNING, this release include some configuration changes (see below),
+ so you may have to check and update your own configuration file(s) if
+ you use one
+
+ * this release require the 0.15 version of astng or superior (it will save
+ you a lot of pylint crashes...)
+
+ * W0705 has been reclassified to E0701, and is now detecting more
+ inheriting problem, and a false positive when empty except clause is
+ following an Exception catch has been fixed (close #10422)
+
+ * E0212 and E0214 (metaclass/class method should have mcs/cls as first
+ argument have been reclassified to C0202 and C0203 since this not as
+ well established as "self" for instance method (E0213)
+
+ * W0224 has been reclassified into F0220 (failed to resolve interfaces
+ implemented by a class)
+
+ * a new typecheck checker, introducing the following checks:
+
+ - E1101, access to unexistent member (implements #10430), remove
+ the need of E0201 and so some options has been moved from the
+ classes checker to this one
+ - E1102, calling a non callable object
+ - E1111 and W1111 when an assignment is done on a function call but the
+ inferred function returns None (implements #10431)
+
+ * change in the base checker:
+
+ - checks module level and instance attribute names (new const-rgx
+ and attr-rgx configuration option) (implements #10209 and
+ #10440)
+ - list comprehension and generator expression variables have their
+ own regular expression (the inlinevar-rgx option) (implements
+ #9146)
+ - the C0101 check with its min-name-length option has
+ been removed (this can be specified in the regxp after all...)
+ - W0103 and W0121 are now handled by the variables checker
+ (W0103 is now W0603 and W0604 has been splitted into different messages)
+ - W0131 and W0132 messages have been reclassified to C0111 and
+ C0112 respectively
+ - new W0104 message on statement without effect
+
+ * regexp support for dummy-variables (dummy-variables-rgx option
+ replace dummy-variables) (implements #10027)
+
+ * better global statement handling, see W0602, W0603, W0604 messages
+ (implements #10344 and #10236)
+
+ * --debug-mode option, disabling all checkers without error message
+ and filtering others to only display error
+
+ * fixed some R0201 (method could be a function) false positive
+
+
+What's New in Pylint 0.9.0?
+============================
+
+Release date: 2006-01-10
+
+ * a lot of updates to follow astng 0.14 API changes, so install
+ logilab-astng 0.14 or greater before using this version of pylint
+
+ * checker number 10 ! newstyle will search for problems regarding old
+ style / new style classes usage problems (rely on astng 0.14 new
+ style detection feature)
+
+ * new 'load-plugins' options to load additional pylint plugins (usable
+ from the command line or from a configuration file) (implements
+ #10031)
+
+ * check if a "pylintrc" file exists in the current working directory
+ before using the one specified in the PYLINTRC environment variable
+ or the default ~/.pylintrc or /etc/pylintrc
+
+ * fixed W0706 (Identifier used to raise an exception is assigned...)
+ false positive and reraising a catched exception instance
+
+ * fixed E0611 (No name get in module blabla) false positive when accessing
+ to a class'__dict__
+
+ * fixed some E0203 ("access to member before its definition") false
+ positive
+
+ * fixed E0214 ("metaclass method first argument should be mcs) false
+ positive with staticmethod used on a metaclass
+
+ * fixed packaging which was missing the test/regrtest_data directory
+
+ * W0212 (method could be a function) has been reclassified in the
+ REFACTOR category as R0201, and is no more considerer when a method
+ overrides an abstract method from an ancestor class
+
+ * include module name in W0401 (wildcard import), as suggested by
+ Amaury
+
+ * when using the '--parseable', path are written relative to the
+ current working directory if in a sub-directory of it (#9789)
+
+ * 'pylint --version' shows logilab-astng and logilab-common versions
+
+ * fixed pylint.el to handle space in file names
+
+ * misc lint style fixes
+
+
+What's New in Pylint 0.8.1?
+============================
+
+
+Release date: 2005-11-07
+
+ * fix "deprecated module" false positive when the code imports a
+ module whose name starts with a deprecated module's name (close
+ #10061)
+
+ * fix "module has no name __dict__" false positive (close #10039)
+
+ * fix "access to undefined variable __path__" false positive (close
+ #10065)
+
+ * fix "explicit return in __init__" false positive when return is
+ actually in an inner function (close #10075)
+
+
+What's New in Pylint 0.8.0?
+============================
+
+Release date: 2005-10-21
+
+ * check names imported from a module exists in the module (E0611),
+ patch contributed by Amaury Forgeot d'Arc
+
+ * print a warning (W0212) for methods that could be a function
+ (implements #9100)
+
+ * new --defining-attr-methods option on classes checker
+
+ * new --acquired-members option on the classes checker, used when
+ --zope=yes to avoid false positive on acquired attributes (listed
+ using this new option) (close #8616)
+
+ * generate one E0602 for each use of an undefined variable
+ (previously, only one for the first use but not for the following)
+ (implements #1000)
+
+ * make profile option saveable
+
+ * fix Windows .bat file, patch contributed by Amaury Forgeot d'Arc
+
+ * fix one more false positive for E0601 (access before definition)
+ with for loop such as "for i in range(10): print i" (test
+ func_noerror_defined_and_used_on_same_line)
+
+ * fix false positive for E0201 (undefined member) when accessing to
+ __name__ on a class object
+
+ * fix astng checkers traversal order
+
+ * fix bug in format checker when parsing a file from a platform
+ using different new line characters (close #9239)
+
+ * fix encoding detection regexp
+
+ * fix --rcfile handling (support for --rcfile=file, close #9590)
+
+
+What's New in Pylint 0.7.0?
+============================
+
+
+Release date: 2005-05-27
+
+ * WARNING: pylint is no longer a logilab subpackage. Users may have to
+ manually remove the old logilab/pylint directory.
+
+ * introduce a new --additional-builtins option to handle user defined
+ builtins
+
+ * --reports option has now -r as short alias, and -i for --include-ids
+
+ * fix a bug in the variables checker which may causing some false
+ positives when variables are defined and used within the same
+ statement (test func_noerror_defined_and_used_on_same_line)
+
+ * this time, real fix of the "disable-msg in the config file" problem,
+ test added to unittest_lint
+
+ * fix bug with --list-messages and python -OO
+
+ * fix possible false positive for W0201
+
+
+What's New in Pylint 0.6.4?
+===========================
+
+
+Release date: 2005-04-14
+
+ * allow to parse files without extension when a path is given on the
+ command line (test noext)
+
+ * don't fail if we are unable to read an inline option (e.g. inside a
+ module), just produce an information message (test func_i0010)
+
+ * new message E0103 for break or continue outside loop (close #8883,
+ test func_continue_not_in_loop)
+
+ * fix bug in the variables checker, causing non detection of some
+ actual name error (close #8884, test
+ func_nameerror_on_string_substitution)
+
+ * fix bug in the classes checker which was making pylint crash if
+ "object" is assigned in a class inheriting from it (test
+ func_noerror_object_as_class_attribute)
+
+ * fix problem with the similar checker when related options are
+ defined in a configuration file
+
+ * new --generate-man option to generate pylint's man page (require the
+ latest logilab.common (>= 0.9.3)
+
+ * packaged (generated...) man page
+
+
+What's New in Pylint 0.6.3?
+===========================
+
+Release date: 2005-02-24
+
+ * fix scope problem which may cause false positive and true negative
+ on E0602
+
+ * fix problem with some options such as disable-msg causing error when
+ they are coming from the configuration file
+
+
+What's New in Pylint 0.6.2?
+============================
+
+
+Release date: 2005-02-16
+
+ * fix false positive on E0201 ("access to undefined member") with
+ metaclasses
+
+ * fix false positive on E0203 ("access to member before its
+ definition") when attributes are defined in a parent class
+
+ * fix false positive on W0706 ("identifier used to raise an exception
+ assigned to...")
+
+ * fix interpretation of "\t" as value for the indent-string
+ configuration variable
+
+ * fix --rcfile so that --rcfile=pylintrc (only --rcfile pylintrc was
+ working in earlier release)
+
+ * new raw checker example in the examples/ directory
+
+
+What's New in Pylint 0.6.1?
+===========================
+
+Release date: 2005-02-04
+
+ * new --rcfile option to specify the configuration file without the
+ PYLINTRC environment variable
+
+ * added an example module for a custom pylint checker (see the
+ example/ directory)
+
+ * some fixes to handle fixes in common 0.9.1 (should however still working
+ with common 0.9.0, even if upgrade is recommended)
+
+
+What's New in Pylint 0.6.0?
+===========================
+
+Release date: 2005-01-20
+
+ * refix pylint emacs mode
+
+ * no more traceback when just typing "pylint"
+
+ * fix a bug which may cause crashes on resolving parent classes
+
+ * fix problems with the format checker: don't chock on files
+ containing multiple CR, avoid C0322, C0323, C0324 false positives
+ with triple quoted string with quote inside
+
+ * correctly detect access to member defined latter in __init__ method
+
+ * now depends on common 0.8.1 to fix problem with interface resolution
+ (close #8606)
+
+ * new --list-msgs option describing available checkers and their
+ messages
+
+ * added windows specific documentation to the README file, contributed
+ by Brian van den Broek
+
+ * updated doc/features.txt (actually this file is now generated using
+ the --list-msgs option), more entries into the FAQ
+
+ * improved tests coverage
+
+
+What's New in Pylint 0.5.0?
+===========================
+
+Release date: 2004-10-19
+
+ * avoid importing analyzed modules !
+
+ * new Refactor and Convention message categories. Some Warnings have been
+ remaped into those new categories
+
+ * added "similar", a tool to find copied and pasted lines of code,
+ both using a specific command line tool and integrated as a
+ pylint's checker
+
+ * imports checker may report import dependencies as a dot graph
+
+ * new checker regrouping most Refactor detection (with some new metrics)
+
+ * more command line options storable in the configuration file
+
+ * fix bug with total / undocumented number of methods
+
+
+What's New in Pylint 0.4.2?
+===========================
+
+Release date: 2004-07-08
+
+ * fix pylint emacs mode
+
+ * fix classes checkers to handler twisted interfaces
+
+
+What's New in Pylint 0.4.1?
+===========================
+
+Release date: 2004-05-14
+
+ * fix the setup.py script to allow bdist_winst (well, the generated
+ installer has not been tested...) with the necessary
+ logilab/__init__.py file
+
+ * fix file naming convention as suggested by Andreas Amoroso
+
+ * fix stupid crash bug with bad method names
+
+
+What's New in Pylint 0.4.0?
+===========================
+
+Release date: 2004-05-10
+
+ * fix file path with --parsable
+
+ * --parsable option has been renamed to --parseable
+
+ * added patch from Andreas Amoroso to output message to files instead
+ of standard output
+
+ * added Run to the list of correct variable names
+
+ * fix variable names regexp and checking of local classes names
+
+ * some basic handling of metaclasses
+
+ * no-docstring-rgx apply now on classes too
+
+ * new option to specify a different regexp for methods than for
+ functions
+
+ * do not display the evaluation report when no statements has been
+ analysed
+
+ * fixed crash with a class nested in a method
+
+ * fixed format checker to deals with triple quoted string and
+ lines with code and comment mixed
+
+ * use logilab.common.ureports to layout reports
+
+
+What's New in Pylint 0.3.3?
+===========================
+
+Release date: 2004-02-17
+
+ * added a parsable text output, used when the --parsable option is
+ provided
+
+ * added an emacs mode using this output, available in the distrib's
+ elisp directory
+
+ * fixed some typos in messages
+
+ * change include-ids options to yn, and allow it to be in the
+ configuration file
+
+ * do not chock on corrupted stats files
+
+ * fixed bug in the format checker which may stop pylint execution
+
+ * provide scripts for unix and windows to wrap the minimal pylint tk
+ gui
+
+
+
+What's New in Pylint 0.3.2?
+===========================
+
+Release date: 2003-12-23
+
+ * html-escape messages in the HTML reporter (bug reported by Juergen
+ Hermann)
+
+ * added "TODO" to the list of default note tags
+
+ * added "rexec" to the list of default deprecated modules
+
+ * fixed typos in some messages
+
+
+
+What's New in Pylint 0.3.1?
+===========================
+
+
+Release date: 2003-12-05
+
+ * bug fix in format and classes checkers
+
+ * remove print statement from imports checkers
+
+ * provide a simple tk gui, essentially useful for windows users
+
+
+
+What's New in Pylint 0.3.0?
+===========================
+
+
+Release date: 2003-11-20
+
+ * new exceptions checker, checking for string exception and empty
+ except clauses.
+
+ * imports checker checks for reimport of modules
+
+ * classes checker checks for calls to ancestor's __init__ and abstract
+ method not overridden. It doesn't complain anymore for unused import in
+ __init__ files, and provides a new option ignore-interface-methods,
+ useful when you're using zope Interface implementation in your project
+
+ * base checker checks for disallowed builtins call (controlled by the
+ bad-functions option) and for use of * and **
+
+ * format checker checks for use of <> and "l" as long int marker
+
+ * major internal API changes
+
+ * use the rewrite of astng, based on compiler.ast
+
+ * added unique id for messages, as suggested by Wolfgang Grafen
+
+ * added unique id for reports
+
+ * can take multiple modules or files as argument
+
+ * new options command line options : --disable-msg, --enable-msg,
+ --help-msg, --include-ids, --reports, --disable-report, --cache-size
+
+ * --version shows the version of the python interpreter
+
+ * removed some options which are now replaced by [en|dis]able-msg, or
+ disable-report
+
+ * read disable-msg and enable-msg options in source files (should be
+ in comments on the top of the file, in the form
+ "# pylint: disable-msg=W0402"
+
+ * new message for modules importing themselves instead of the "cyclic
+ import" message
+
+ * fix bug with relative and cyclic imports
+
+ * fix bug in imports checker (cycle was not always detected)
+
+ * still fixes in format checker : don't check comment and docstring,
+ check first line after an indent
+
+ * allowed/prohibited names now apply to all identifiers, not only
+ variables, so changed the configuration option from
+ (good|bad)-variable-names to (good|bad)-names
+
+ * added string, rexec and Bastion to the default list of deprecated
+ modules
+
+ * do not print redefinition warning for function/class/method defined
+ in mutually exclusive branches
+
+
+
+What's New in Pylint 0.2.1?
+===========================
+
+
+Release date: 2003-10-10
+
+ * added some documentation, fixed some typos
+
+ * set environment variable PYLINT_IMPORT to 1 during pylint execution.
+
+ * check that variables "imported" using the global statement exist
+
+ * indentation problems are now warning instead of errors
+
+ * fix checkers.initialize to try to load all files with a known python
+ extension (patch from wrobell)
+
+ * fix a bunch of messages
+
+ * fix sample configuration file
+
+ * fix the bad-construction option
+
+ * fix encoding checker
+
+ * fix format checker
+
+
+What's New in Pylint 0.2.0?
+===========================
+
+
+Release date: 2003-09-12
+
+ * new source encoding / FIXME checker (pep 263)
+
+ * new --zope option which trigger Zope import. Useful to check Zope
+ products code.
+
+ * new --comment option which enable the evaluation note comment
+ (disabled by default).
+
+ * a ton of bug fixes
+
+ * easy functional test infrastructure
+
+
+What's New in Pylint 0.1.2?
+===========================
+
+
+Release date: 2003-06-18
+
+ * bug fix release
+
+ * remove dependency to pyreverse
+
+
+What's New in Pylint 0.1.1?
+===========================
+
+
+Release date: 2003-06-01
+
+ * much more functionalities !
+
+
+What's New in Pylint 0.1?
+===========================
+
+Release date: 2003-05-19
+
+ * initial release
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..aafe62a
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,7 @@
+FROM python:3.9.0-alpine3.12
+
+COPY ./ /tmp/build
+WORKDIR /tmp/build
+RUN python setup.py install && rm -rf /tmp/build
+
+ENTRYPOINT ["pylint"]
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..8c4c849
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,340 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..0ea68b1
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,14 @@
+recursive-exclude pylint *.rst
+prune .github
+prune doc
+prune elisp
+prune examples
+prune tests
+prune script
+exclude .*
+exclude ChangeLog
+exclude Dockerfile
+exclude README.rst
+exclude pylintrc
+exclude requirements_*.txt
+exclude tox.ini
diff --git a/README.rst b/README.rst
new file mode 100644
index 0000000..af52d05
--- /dev/null
+++ b/README.rst
@@ -0,0 +1,170 @@
+
+README for Pylint - https://pylint.pycqa.org/
+=============================================
+
+.. image:: https://github.com/PyCQA/pylint/actions/workflows/ci.yaml/badge.svg?branch=master
+ :target: https://github.com/PyCQA/pylint/actions
+
+.. image:: https://coveralls.io/repos/github/PyCQA/pylint/badge.svg?branch=master
+ :target: https://coveralls.io/github/PyCQA/pylint?branch=master
+
+
+.. image:: https://img.shields.io/pypi/v/pylint.svg
+ :alt: Pypi Package version
+ :target: https://pypi.python.org/pypi/pylint
+
+.. image:: https://readthedocs.org/projects/pylint/badge/?version=latest
+ :target: https://pylint.readthedocs.io/en/latest/?badge=latest
+ :alt: Documentation Status
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+ :target: https://github.com/ambv/black
+
+.. image:: https://results.pre-commit.ci/badge/github/PyCQA/pylint/master.svg
+ :target: https://results.pre-commit.ci/latest/github/PyCQA/pylint/master
+ :alt: pre-commit.ci status
+
+.. |tideliftlogo| image:: https://raw.githubusercontent.com/PyCQA/pylint/master/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png
+ :width: 75
+ :height: 60
+ :alt: Tidelift
+
+.. list-table::
+ :widths: 10 100
+
+ * - |tideliftlogo|
+ - Professional support for pylint is available as part of the `Tidelift
+ Subscription`_. Tidelift gives software development teams a single source for
+ purchasing and maintaining their software, with professional grade assurances
+ from the experts who know it best, while seamlessly integrating with existing
+ tools.
+
+.. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-pylint?utm_source=pypi-pylint&utm_medium=referral&utm_campaign=readme
+
+
+======
+Pylint
+======
+
+**It's not just a linter that annoys you!**
+
+Pylint is a Python static code analysis tool which looks for programming errors,
+helps enforcing a coding standard, sniffs for code smells and offers simple refactoring
+suggestions.
+
+It's highly configurable, having special pragmas to control its errors and warnings
+from within your code, as well as from an extensive configuration file.
+It is also possible to write your own plugins for adding your own checks or for
+extending pylint in one way or another.
+
+It's a free software distributed under the GNU General Public Licence unless
+otherwise specified.
+
+Development is hosted on GitHub: https://github.com/PyCQA/pylint/
+
+You can use the code-quality@python.org mailing list to discuss about
+Pylint. Subscribe at https://mail.python.org/mailman/listinfo/code-quality/
+or read the archives at https://mail.python.org/pipermail/code-quality/
+
+Pull requests are amazing and most welcome.
+
+Install
+-------
+
+Pylint can be simply installed by running::
+
+ pip install pylint
+
+If you are using Python 3.6+, upgrade to get full support for your version::
+
+ pip install pylint --upgrade
+
+If you want to install from a source distribution, extract the tarball and run
+the following command ::
+
+ python setup.py install
+
+
+Do make sure to do the same for astroid, which is used internally by pylint.
+
+For debian and rpm packages, use your usual tools according to your Linux distribution.
+
+More information about installation and available distribution format
+can be found here_.
+
+Documentation
+-------------
+
+The documentation lives at https://pylint.pycqa.org/.
+
+Pylint is shipped with following additional commands:
+
+* pyreverse: an UML diagram generator
+* symilar: an independent similarities checker
+* epylint: Emacs and Flymake compatible Pylint
+
+
+Testing
+-------
+
+We use tox_ and pytest-benchmark_ for running the test suite. You should be able to install it with::
+
+ pip install tox pytest pytest-benchmark
+
+
+To run the test suite for a particular Python version, you can do::
+
+ tox -e py37
+
+
+To run individual tests with ``tox``, you can do::
+
+ tox -e py37 -- -k name_of_the_test
+
+
+We use pytest_ for testing ``pylint``, which you can use without using ``tox`` for a faster development cycle.
+
+If you want to run tests on a specific portion of the code with pytest_, (pytest-cov_) and your local python version::
+
+ # ( pip install pytest-cov )
+ # Everything:
+ python3 -m pytest tests/
+ # Everything in tests/message with coverage for the relevant code:
+ python3 -m pytest tests/message/ --cov=pylint.message
+ coverage html
+ # Only the functional test "missing_kwoa_py3":
+ python3 -m pytest "tests/test_functional.py::test_functional[missing_kwoa_py3]"
+
+
+Do not forget to clone astroid_ and install the last version::
+
+
+ git clone https://github.com/PyCQA/astroid.git
+
+ # From source
+ python3 astroid/setup.py build sdist
+ pip3 install astroid/dist/astroid*.tar.gz
+
+ # Using an editable installation
+ cd astroid
+ python3 -m pip install -e .
+
+
+For more detailed information, check the documentation.
+
+.. _here: https://pylint.pycqa.org/en/latest/user_guide/installation.html
+.. _tox: https://tox.readthedocs.io/en/latest/
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _pytest-benchmark: https://pytest-benchmark.readthedocs.io/en/latest/index.html
+.. _pytest-cov: https://pypi.org/project/pytest-cov/
+.. _astroid: https://github.com/PyCQA/astroid
+
+License
+-------
+
+pylint is, with a few exceptions listed below, `GPLv2 <https://github.com/PyCQA/pylint/blob/master/LICENSE>`_.
+
+The icon files are licensed under the `CC BY-SA 4.0 <https://creativecommons.org/licenses/by-sa/4.0/>`_ license:
+
+- `doc/logo.png <https://raw.githubusercontent.com/PyCQA/pylint/master/doc/logo.png>`_
+- `doc/logo.svg <https://raw.githubusercontent.com/PyCQA/pylint/master/doc/logo.svg>`_
diff --git a/examples/custom.py b/examples/custom.py
new file mode 100644
index 0000000..7ee97bb
--- /dev/null
+++ b/examples/custom.py
@@ -0,0 +1,74 @@
+import astroid
+
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IAstroidChecker
+
+
+# This is our checker class.
+# Checkers should always inherit from `BaseChecker`.
+class MyAstroidChecker(BaseChecker):
+ """Add class member attributes to the class locals dictionary."""
+
+ # This class variable defines the type of checker that we are implementing.
+ # In this case, we are implementing an AST checker.
+ __implements__ = IAstroidChecker
+
+ # The name defines a custom section of the config for this checker.
+ name = "custom"
+ # The priority indicates the order that pylint will run the checkers.
+ priority = -1
+ # This class variable declares the messages (ie the warnings and errors)
+ # that the checker can emit.
+ msgs = {
+ # Each message has a code, a message that the user will see,
+ # a unique symbol that identifies the message,
+ # and a detailed help message
+ # that will be included in the documentation.
+ "W0001": ("Message that will be emitted", "message-symbol", "Message help")
+ }
+ # This class variable declares the options
+ # that are configurable by the user.
+ options = (
+ # Each option definition has a name which is used on the command line
+ # and in config files, and a dictionary of arguments
+ # (similar to those to those to
+ # argparse.ArgumentParser.add_argument).
+ (
+ "store-locals-indicator",
+ {
+ "default": "properties",
+ "help": (
+ "The expression name that indicates that the locals should "
+ "be stored"
+ ),
+ },
+ ),
+ )
+
+ def visit_call(self, node):
+ """Called when a :class:`.astroid.node_classes.Call` node is visited.
+
+ See :mod:`astroid` for the description of available nodes.
+
+ :param node: The node to check.
+ :type node: astroid.node_classes.Call
+ """
+ if not (
+ isinstance(node.func, astroid.Attribute)
+ and isinstance(node.func.expr, astroid.Name)
+ and node.func.expr.name == self.config.store_locals_indicator
+ and node.func.attrname == "create"
+ ):
+ return
+ in_class = node.frame()
+ for param in node.args:
+ in_class.locals[param.name] = node
+
+
+def register(linter):
+ """This required method auto registers the checker.
+
+ :param linter: The linter to register the checker to.
+ :type linter: pylint.lint.PyLinter
+ """
+ linter.register_checker(MyAstroidChecker(linter))
diff --git a/examples/custom_raw.py b/examples/custom_raw.py
new file mode 100644
index 0000000..63e4aeb
--- /dev/null
+++ b/examples/custom_raw.py
@@ -0,0 +1,38 @@
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IRawChecker
+
+
+class MyRawChecker(BaseChecker):
+ """check for line continuations with '\' instead of using triple
+ quoted string or parenthesis
+ """
+
+ __implements__ = IRawChecker
+
+ name = "custom_raw"
+ msgs = {
+ "W9901": (
+ "use \\ for line continuation",
+ "backslash-line-continuation",
+ (
+ "Used when a \\ is used for a line continuation instead"
+ " of using triple quoted string or parenthesis."
+ ),
+ )
+ }
+ options = ()
+
+ def process_module(self, node):
+ """process a module
+
+ the module's content is accessible via node.stream() function
+ """
+ with node.stream() as stream:
+ for (lineno, line) in enumerate(stream):
+ if line.rstrip().endswith("\\"):
+ self.add_message("backslash-line-continuation", line=lineno)
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(MyRawChecker(linter))
diff --git a/examples/deprecation_checker.py b/examples/deprecation_checker.py
new file mode 100644
index 0000000..93910b7
--- /dev/null
+++ b/examples/deprecation_checker.py
@@ -0,0 +1,99 @@
+"""
+Example checker detecting deprecated functions/methods. Following example searches for usages of
+deprecated function `deprecated_function` and deprecated method `MyClass.deprecated_method`
+from module mymodule:
+
+.. code-block:: console
+ $ cat mymodule.py
+ def deprecated_function():
+ pass
+
+ def myfunction(arg0, arg1, deprecated_arg1=None, arg2='foo', arg3='bar', deprecated_arg2='spam'):
+ pass
+
+ class MyClass:
+ def deprecated_method(self):
+ pass
+
+ def mymethod(self, arg0, arg1, deprecated1=None, arg2='foo', deprecated2='bar', arg3='spam'):
+ pass
+
+ $ cat mymain.py
+ from mymodule import deprecated_function, myfunction, MyClass
+
+ deprecated_function()
+ myfunction(0, 1, 'deprecated_arg1', deprecated_arg2=None)
+ MyClass().deprecated_method()
+ MyClass().mymethod(0, 1, deprecated1=None, deprecated2=None)
+
+ $ pylint --load-plugins=deprecation_checker mymain.py
+ ************* Module mymain
+ mymain.py:3:0: W1505: Using deprecated method deprecated_function() (deprecated-method)
+ mymain.py:4:0: W1511: Using deprecated argument deprecated_arg1 of method myfunction() (deprecated-argument)
+ mymain.py:4:0: W1511: Using deprecated argument deprecated_arg2 of method myfunction() (deprecated-argument)
+ mymain.py:5:0: W1505: Using deprecated method deprecated_method() (deprecated-method)
+ mymain.py:6:0: W1511: Using deprecated argument deprecated1 of method mymethod() (deprecated-argument)
+ mymain.py:6:0: W1511: Using deprecated argument deprecated2 of method mymethod() (deprecated-argument)
+
+ ------------------------------------------------------------------
+ Your code has been rated at 2.00/10 (previous run: 2.00/10, +0.00)
+"""
+from typing import Set, Tuple, Union
+
+from pylint.checkers import BaseChecker, DeprecatedMixin
+from pylint.interfaces import IAstroidChecker
+
+
+class DeprecationChecker(DeprecatedMixin, BaseChecker):
+ """Class implementing deprecation checker."""
+
+ # DeprecationMixin class is Mixin class implementing logic for searching deprecated methods and functions.
+ # The list of deprecated methods/functions is defined by implementing class via deprecated_methods callback.
+ # DeprecatedMixin class is overriding attributes of BaseChecker hence must be specified *before* BaseChecker
+ # in list of base classes.
+
+ __implements__ = (IAstroidChecker,)
+ # The name defines a custom section of the config for this checker.
+ name = "deprecated"
+
+ def deprecated_methods(self) -> Set[str]:
+ """Callback method called by DeprecatedMixin for every method/function found in the code.
+
+ Returns:
+ collections.abc.Container of deprecated function/method names.
+ """
+ return {"mymodule.deprecated_function", "mymodule.MyClass.deprecated_method"}
+
+ def deprecated_arguments(
+ self, method: str
+ ) -> Tuple[Tuple[Union[int, None], str], ...]:
+ """Callback returning the deprecated arguments of method/function.
+
+ Returns:
+ collections.abc.Iterable in form:
+ ((POSITION1, PARAM1), (POSITION2: PARAM2) ...)
+ where
+ * POSITIONX - position of deprecated argument PARAMX in function definition.
+ If argument is keyword-only, POSITIONX should be None.
+ * PARAMX - name of the deprecated argument.
+ """
+ if method == "mymodule.myfunction":
+ # myfunction() has two deprecated arguments:
+ # * deprecated_arg1 defined at 2nd position and
+ # * deprecated_arg2 defined at 5th position.
+ return ((2, "deprecated_arg1"), (5, "deprecated_arg2"))
+ if method == "mymodule.MyClass.mymethod":
+ # mymethod() has two deprecated arguments:
+ # * deprecated1 defined at 2nd position and
+ # * deprecated2 defined at 4th position.
+ return ((2, "deprecated1"), (4, "deprecated2"))
+ return ()
+
+
+def register(linter):
+ """This required method auto registers the checker.
+
+ :param linter: The linter to register the checker to.
+ :type linter: pylint.lint.PyLinter
+ """
+ linter.register_checker(DeprecationChecker(linter))
diff --git a/examples/pylintrc b/examples/pylintrc
new file mode 100644
index 0000000..1a98ef6
--- /dev/null
+++ b/examples/pylintrc
@@ -0,0 +1,600 @@
+[MASTER]
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code.
+extension-pkg-allow-list=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
+# for backward compatibility.)
+extension-pkg-whitelist=
+
+# Specify a score threshold to be exceeded before program exits with error.
+fail-under=10
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=CVS
+
+# Files or directories matching the regex patterns are skipped. The regex
+# matches against base names, not paths.
+ignore-patterns=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
+# number of processors available to use.
+jobs=1
+
+# Control the amount of potential inferred values when inferring a single
+# object. This can help the performance when dealing with large functions or
+# complex, nested conditions.
+limit-inference-results=100
+
+# List of plugins (as comma separated values of python module names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# When enabled, pylint would attempt to guess common misconfiguration and emit
+# user-friendly hints instead of false-positive error messages.
+suggestion-mode=yes
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
+confidence=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=print-statement,
+ parameter-unpacking,
+ unpacking-in-except,
+ old-raise-syntax,
+ backtick,
+ long-suffix,
+ old-ne-operator,
+ old-octal-literal,
+ import-star-module-level,
+ non-ascii-bytes-literal,
+ raw-checker-failed,
+ bad-inline-option,
+ locally-disabled,
+ file-ignored,
+ suppressed-message,
+ useless-suppression,
+ deprecated-pragma,
+ use-symbolic-message-instead,
+ apply-builtin,
+ basestring-builtin,
+ buffer-builtin,
+ cmp-builtin,
+ coerce-builtin,
+ execfile-builtin,
+ file-builtin,
+ long-builtin,
+ raw_input-builtin,
+ reduce-builtin,
+ standarderror-builtin,
+ unicode-builtin,
+ xrange-builtin,
+ coerce-method,
+ delslice-method,
+ getslice-method,
+ setslice-method,
+ no-absolute-import,
+ old-division,
+ dict-iter-method,
+ dict-view-method,
+ next-method-called,
+ metaclass-assignment,
+ indexing-exception,
+ raising-string,
+ reload-builtin,
+ oct-method,
+ hex-method,
+ nonzero-method,
+ cmp-method,
+ input-builtin,
+ round-builtin,
+ intern-builtin,
+ unichr-builtin,
+ map-builtin-not-iterating,
+ zip-builtin-not-iterating,
+ range-builtin-not-iterating,
+ filter-builtin-not-iterating,
+ using-cmp-argument,
+ eq-without-hash,
+ div-method,
+ idiv-method,
+ rdiv-method,
+ exception-message-attribute,
+ invalid-str-codec,
+ sys-max-int,
+ bad-python3-import,
+ deprecated-string-function,
+ deprecated-str-translate-call,
+ deprecated-itertools-function,
+ deprecated-types-field,
+ next-method-defined,
+ dict-items-not-iterating,
+ dict-keys-not-iterating,
+ dict-values-not-iterating,
+ deprecated-operator-function,
+ deprecated-urllib-function,
+ xreadlines-attribute,
+ deprecated-sys-function,
+ exception-escape,
+ comprehension-escape
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=c-extension-no-member
+
+
+[REPORTS]
+
+# Python expression which should return a score less than or equal to 10. You
+# have access to the variables 'error', 'warning', 'refactor', and 'convention'
+# which contain the number of messages in each category, as well as 'statement'
+# which is the total number of statements analyzed. This score is used by the
+# global evaluation report (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details.
+#msg-template=
+
+# Set the output format. Available formats are text, parseable, colorized, json
+# and msvs (visual studio). You can also give a reporter class, e.g.
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Tells whether to display a full report or only the messages.
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=sys.exit
+
+
+[LOGGING]
+
+# Format style used to check logging format string. `old` means using %
+# formatting and `new` is for `{}` formatting.
+logging-format-style=old
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format.
+logging-modules=logging
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes.
+max-spelling-suggestions=4
+
+# Spelling dictionary name. Available dictionaries: none. To make it work,
+# install the python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains the private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to the private dictionary (see the
+# --spelling-private-dict-file option) instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+ XXX,
+ TODO
+
+# Regular expression of note tags to take in consideration.
+#notes-rgx=
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# Tells whether to warn about missing members when the owner of the attribute
+# is inferred to be None.
+ignore-none=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis). It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The minimum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+# List of decorators that change the signature of a decorated function.
+signature-mutators=
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid defining new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+ _cb
+
+# A regular expression matching the name of dummy variables (i.e. expected to
+# not be used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore.
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
+# tab).
+indent-string=' '
+
+# Maximum number of characters on a single line.
+max-line-length=100
+
+# Maximum number of lines in a module.
+max-module-lines=1000
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=trailing-comma,
+ dict-separator
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[SIMILARITIES]
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+
+[BASIC]
+
+# Naming style matching correct argument names.
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style.
+#argument-rgx=
+
+# Naming style matching correct attribute names.
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style.
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma.
+bad-names=foo,
+ bar,
+ baz,
+ toto,
+ tutu,
+ tata
+
+# Bad variable names regexes, separated by a comma. If names match any regex,
+# they will always be refused
+bad-names-rgxs=
+
+# Naming style matching correct class attribute names.
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style.
+#class-attribute-rgx=
+
+# Naming style matching correct class names.
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-
+# style.
+#class-rgx=
+
+# Naming style matching correct constant names.
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style.
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names.
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style.
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=i,
+ j,
+ k,
+ ex,
+ Run,
+ _
+
+# Good variable names regexes, separated by a comma. If names match any regex,
+# they will always be accepted
+good-names-rgxs=
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names.
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style.
+#inlinevar-rgx=
+
+# Naming style matching correct method names.
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style.
+#method-rgx=
+
+# Naming style matching correct module names.
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style.
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+# These decorators are taken in consideration only for invalid-name.
+property-classes=abc.abstractproperty
+
+# Naming style matching correct variable names.
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style.
+#variable-rgx=
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=no
+
+# This flag controls whether the implicit-str-concat should generate a warning
+# on implicit string concatenation in sequences defined over several lines.
+check-str-concat-over-line-jumps=no
+
+
+[IMPORTS]
+
+# List of modules that can be imported at any level, not just the top level
+# one.
+allow-any-import-level=
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Deprecated modules which should not be used, separated by a comma.
+deprecated-modules=optparse,tkinter.tix
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled).
+ext-import-graph=
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled).
+import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled).
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Couples of modules and preferred modules, separated by a comma.
+preferred-modules=
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+ __new__,
+ setUp,
+ __post_init__
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,
+ _fields,
+ _replace,
+ _source,
+ _make
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=cls
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method.
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in an if statement (see R0916).
+max-bool-expr=5
+
+# Maximum number of branch for function / method body.
+max-branches=12
+
+# Maximum number of locals for function / method body.
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body.
+max-returns=6
+
+# Maximum number of statements in function / method body.
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "BaseException, Exception".
+overgeneral-exceptions=BaseException,
+ Exception
diff --git a/examples/pylintrc_camelcase b/examples/pylintrc_camelcase
new file mode 100644
index 0000000..d5cdaa9
--- /dev/null
+++ b/examples/pylintrc_camelcase
@@ -0,0 +1,22 @@
+# This pylintrc file will use the default settings except for the
+# naming conventions, which will allow for camel case naming as found
+# in Java code or several libraries such as PyQt, etc.
+
+[BASIC]
+# Regular expression which should only match correct module names
+module-rgx=(([a-z][a-z0-9]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression which should only match correct class names
+class-rgx=[A-Z][a-zA-Z0-9]+$
+
+# Regular expression which should only match correct function names
+function-rgx=[a-z_][a-zA-Z0-9]*$
+
+# Regular expression which should only match correct method names
+method-rgx=[a-z_][a-zA-Z0-9]*$
+
+# Regular expression which should only match correct argument names
+argument-rgx=[a-z][a-zA-Z0-9]*$
+
+# Regular expression which should only match correct variable names
+variable-rgx=[a-z][a-zA-Z0-9]*$
diff --git a/pylint/__init__.py b/pylint/__init__.py
new file mode 100644
index 0000000..14bf18d
--- /dev/null
+++ b/pylint/__init__.py
@@ -0,0 +1,78 @@
+# Copyright (c) 2008, 2012 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014, 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import os
+import sys
+
+from pylint.__pkginfo__ import __version__
+
+# pylint: disable=import-outside-toplevel
+
+
+def run_pylint():
+ from pylint.lint import Run as PylintRun
+
+ try:
+ PylintRun(sys.argv[1:])
+ except KeyboardInterrupt:
+ sys.exit(1)
+
+
+def run_epylint():
+ from pylint.epylint import Run as EpylintRun
+
+ EpylintRun()
+
+
+def run_pyreverse():
+ """run pyreverse"""
+ from pylint.pyreverse.main import Run as PyreverseRun
+
+ PyreverseRun(sys.argv[1:])
+
+
+def run_symilar():
+ """run symilar"""
+ from pylint.checkers.similar import Run as SimilarRun
+
+ SimilarRun(sys.argv[1:])
+
+
+def modify_sys_path() -> None:
+ """Modify sys path for execution as Python module.
+
+ Strip out the current working directory from sys.path.
+ Having the working directory in `sys.path` means that `pylint` might
+ inadvertently import user code from modules having the same name as
+ stdlib or pylint's own modules.
+ CPython issue: https://bugs.python.org/issue33053
+
+ - Remove the first entry. This will always be either "" or the working directory
+ - Remove the working directory from the second and third entries
+ if PYTHONPATH includes a ":" at the beginning or the end.
+ https://github.com/PyCQA/pylint/issues/3636
+ Don't remove it if PYTHONPATH contains the cwd or '.' as the entry will
+ only be added once.
+ - Don't remove the working directory from the rest. It will be included
+ if pylint is installed in an editable configuration (as the last item).
+ https://github.com/PyCQA/pylint/issues/4161
+ """
+ sys.path.pop(0)
+ env_pythonpath = os.environ.get("PYTHONPATH", "")
+ cwd = os.getcwd()
+ if env_pythonpath.startswith(":") and env_pythonpath not in (f":{cwd}", ":."):
+ sys.path.pop(0)
+ elif env_pythonpath.endswith(":") and env_pythonpath not in (f"{cwd}:", ".:"):
+ sys.path.pop(1)
+
+
+version = __version__
+__all__ = ["__version__", "version"]
diff --git a/pylint/__main__.py b/pylint/__main__.py
new file mode 100644
index 0000000..0415e32
--- /dev/null
+++ b/pylint/__main__.py
@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import pylint
+
+pylint.modify_sys_path()
+pylint.run_pylint()
diff --git a/pylint/__pkginfo__.py b/pylint/__pkginfo__.py
new file mode 100644
index 0000000..681c693
--- /dev/null
+++ b/pylint/__pkginfo__.py
@@ -0,0 +1,35 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+from typing import Tuple
+
+__version__ = "2.9.0-dev1"
+
+
+def get_numversion_from_version(v: str) -> Tuple:
+ """Kept for compatibility reason
+
+ See https://github.com/PyCQA/pylint/issues/4399
+ https://github.com/PyCQA/pylint/issues/4420,
+ """
+ v = v.replace("pylint-", "")
+ version = []
+ for n in v.split(".")[0:3]:
+ try:
+ version.append(int(n))
+ except ValueError:
+ num = ""
+ for c in n:
+ if c.isdigit():
+ num += c
+ else:
+ break
+ try:
+ version.append(int(num))
+ except ValueError:
+ version.append(0)
+ while len(version) != 3:
+ version.append(0)
+ return tuple(version)
+
+
+numversion = get_numversion_from_version(__version__)
diff --git a/pylint/checkers/__init__.py b/pylint/checkers/__init__.py
new file mode 100644
index 0000000..74d1bae
--- /dev/null
+++ b/pylint/checkers/__init__.py
@@ -0,0 +1,86 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2013 buck@yelp.com <buck@yelp.com>
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019 Bruno P. Kinoshita <kinow@users.noreply.github.com>
+# Copyright (c) 2020-2021 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Matus Valo <matusvalo@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""utilities methods and classes for checkers
+
+Base id of standard checkers (used in msg and report ids):
+01: base
+02: classes
+03: format
+04: import
+05: misc
+06: variables
+07: exceptions
+08: similar
+09: design_analysis
+10: newstyle
+11: typecheck
+12: logging
+13: string_format
+14: string_constant
+15: stdlib
+16: python3
+17: refactoring
+18-50: not yet used: reserved for future internal checkers.
+51-99: perhaps used: reserved for external checkers
+
+The raw_metrics checker has no number associated since it doesn't emit any
+messages nor reports. XXX not true, emit a 07 report !
+
+"""
+
+from pylint.checkers.base_checker import BaseChecker, BaseTokenChecker
+from pylint.checkers.deprecated import DeprecatedMixin
+from pylint.checkers.mapreduce_checker import MapReduceMixin
+from pylint.utils import diff_string, register_plugins
+
+
+def table_lines_from_stats(stats, old_stats, columns):
+ """get values listed in <columns> from <stats> and <old_stats>,
+ and return a formated list of values, designed to be given to a
+ ureport.Table object
+ """
+ lines = []
+ for m_type in columns:
+ new = stats[m_type]
+ old = old_stats.get(m_type)
+ if old is not None:
+ diff_str = diff_string(old, new)
+ else:
+ old, diff_str = "NC", "NC"
+ new = "%.3f" % new if isinstance(new, float) else str(new)
+ old = "%.3f" % old if isinstance(old, float) else str(old)
+ lines += (m_type.replace("_", " "), new, old, diff_str)
+ return lines
+
+
+def initialize(linter):
+ """initialize linter with checkers in this package"""
+ register_plugins(linter, __path__[0])
+
+
+__all__ = [
+ "BaseChecker",
+ "BaseTokenChecker",
+ "initialize",
+ "MapReduceMixin",
+ "DeprecatedMixin",
+ "register_plugins",
+]
diff --git a/pylint/checkers/async.py b/pylint/checkers/async.py
new file mode 100644
index 0000000..4dd0192
--- /dev/null
+++ b/pylint/checkers/async.py
@@ -0,0 +1,94 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Checker for anything related to the async protocol (PEP 492)."""
+
+import sys
+
+import astroid
+
+from pylint import checkers, interfaces, utils
+from pylint.checkers import utils as checker_utils
+from pylint.checkers.utils import decorated_with
+
+
+class AsyncChecker(checkers.BaseChecker):
+ __implements__ = interfaces.IAstroidChecker
+ name = "async"
+ msgs = {
+ "E1700": (
+ "Yield inside async function",
+ "yield-inside-async-function",
+ "Used when an `yield` or `yield from` statement is "
+ "found inside an async function.",
+ {"minversion": (3, 5)},
+ ),
+ "E1701": (
+ "Async context manager '%s' doesn't implement __aenter__ and __aexit__.",
+ "not-async-context-manager",
+ "Used when an async context manager is used with an object "
+ "that does not implement the async context management protocol.",
+ {"minversion": (3, 5)},
+ ),
+ }
+
+ def open(self):
+ self._ignore_mixin_members = utils.get_global_option(
+ self, "ignore-mixin-members"
+ )
+ self._async_generators = ["contextlib.asynccontextmanager"]
+
+ @checker_utils.check_messages("yield-inside-async-function")
+ def visit_asyncfunctiondef(self, node):
+ for child in node.nodes_of_class(astroid.Yield):
+ if child.scope() is node and (
+ sys.version_info[:2] == (3, 5) or isinstance(child, astroid.YieldFrom)
+ ):
+ self.add_message("yield-inside-async-function", node=child)
+
+ @checker_utils.check_messages("not-async-context-manager")
+ def visit_asyncwith(self, node):
+ for ctx_mgr, _ in node.items:
+ inferred = checker_utils.safe_infer(ctx_mgr)
+ if inferred is None or inferred is astroid.Uninferable:
+ continue
+
+ if isinstance(inferred, astroid.AsyncFunctionDef):
+ # Check if we are dealing with a function decorated
+ # with contextlib.asynccontextmanager.
+ if decorated_with(inferred, self._async_generators):
+ continue
+ elif isinstance(inferred, astroid.bases.AsyncGenerator):
+ # Check if we are dealing with a function decorated
+ # with contextlib.asynccontextmanager.
+ if decorated_with(inferred.parent, self._async_generators):
+ continue
+ else:
+ try:
+ inferred.getattr("__aenter__")
+ inferred.getattr("__aexit__")
+ except astroid.exceptions.NotFoundError:
+ if isinstance(inferred, astroid.Instance):
+ # If we do not know the bases of this class,
+ # just skip it.
+ if not checker_utils.has_known_bases(inferred):
+ continue
+ # Just ignore mixin classes.
+ if self._ignore_mixin_members:
+ if inferred.name[-5:].lower() == "mixin":
+ continue
+ else:
+ continue
+ self.add_message(
+ "not-async-context-manager", node=node, args=(inferred.name,)
+ )
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(AsyncChecker(linter))
diff --git a/pylint/checkers/base.py b/pylint/checkers/base.py
new file mode 100644
index 0000000..cd753a4
--- /dev/null
+++ b/pylint/checkers/base.py
@@ -0,0 +1,2597 @@
+# Copyright (c) 2006-2016 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2010 Daniel Harding <dharding@gmail.com>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Nick Bastin <nick.bastin@gmail.com>
+# Copyright (c) 2015 Michael Kefeder <oss@multiwave.ch>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Stephane Wirtel <stephane@wirtel.be>
+# Copyright (c) 2015 Cosmin Poieana <cmin@ropython.org>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Radu Ciorba <radu@devrandom.ro>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016, 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016, 2018 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Elias Dorneles <eliasdorneles@gmail.com>
+# Copyright (c) 2016 Yannack <yannack@users.noreply.github.com>
+# Copyright (c) 2016 Alex Jurkiewicz <alex@jurkiewi.cz>
+# Copyright (c) 2017, 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2017, 2019-2021 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 danields <danields761@gmail.com>
+# Copyright (c) 2017 Jacques Kvam <jwkvam@gmail.com>
+# Copyright (c) 2017 ttenhoeve-aa <ttenhoeve@appannie.com>
+# Copyright (c) 2018-2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2018-2019 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Sergei Lebedev <185856+superbobry@users.noreply.github.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Natalie Serebryakova <natalie.serebryakova@Natalies-MacBook-Pro.local>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 SergeyKosarchuk <sergeykosarchuk@gmail.com>
+# Copyright (c) 2018 Steven M. Vascellaro <svascellaro@gmail.com>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Chris Lamb <chris@chris-lamb.co.uk>
+# Copyright (c) 2018 glmdgrielson <32415403+glmdgrielson@users.noreply.github.com>
+# Copyright (c) 2019 Daniel Draper <Germandrummer92@users.noreply.github.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Niko Wenselowski <niko@nerdno.de>
+# Copyright (c) 2019 Nikita Sobolev <mail@sobolevn.me>
+# Copyright (c) 2019 Oisín Moran <OisinMoran@users.noreply.github.com>
+# Copyright (c) 2019 Fantix King <fantix@uchicago.edu>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 ethan-leba <ethanleba5@gmail.com>
+# Copyright (c) 2020 へーさん <hira9603859504@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Ram Rachum <ram@rachum.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2020 bernie gray <bfgray3@users.noreply.github.com>
+# Copyright (c) 2020 Gabriel R Sezefredo <g@briel.dev>
+# Copyright (c) 2020 Benny <benny.mueller91@gmail.com>
+# Copyright (c) 2020 Anubhav <35621759+anubh-v@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 David Liu <david@cs.toronto.edu>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 Or Bahari <orbahari@mail.tau.ac.il>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""basic checker for Python code"""
+import builtins
+import collections
+import itertools
+import re
+import sys
+from typing import Pattern
+
+import astroid
+
+from pylint import checkers, exceptions, interfaces
+from pylint import utils as lint_utils
+from pylint.checkers import utils
+from pylint.checkers.utils import (
+ is_overload_stub,
+ is_property_deleter,
+ is_property_setter,
+)
+from pylint.reporters.ureports import nodes as reporter_nodes
+
+
+class NamingStyle:
+ """It may seem counterintuitive that single naming style has multiple "accepted"
+ forms of regular expressions, but we need to special-case stuff like dunder names
+ in method names."""
+
+ ANY: Pattern[str] = re.compile(".*")
+ CLASS_NAME_RGX: Pattern[str] = ANY
+ MOD_NAME_RGX: Pattern[str] = ANY
+ CONST_NAME_RGX: Pattern[str] = ANY
+ COMP_VAR_RGX: Pattern[str] = ANY
+ DEFAULT_NAME_RGX: Pattern[str] = ANY
+ CLASS_ATTRIBUTE_RGX: Pattern[str] = ANY
+
+ @classmethod
+ def get_regex(cls, name_type):
+ return {
+ "module": cls.MOD_NAME_RGX,
+ "const": cls.CONST_NAME_RGX,
+ "class": cls.CLASS_NAME_RGX,
+ "function": cls.DEFAULT_NAME_RGX,
+ "method": cls.DEFAULT_NAME_RGX,
+ "attr": cls.DEFAULT_NAME_RGX,
+ "argument": cls.DEFAULT_NAME_RGX,
+ "variable": cls.DEFAULT_NAME_RGX,
+ "class_attribute": cls.CLASS_ATTRIBUTE_RGX,
+ "class_const": cls.CONST_NAME_RGX,
+ "inlinevar": cls.COMP_VAR_RGX,
+ }[name_type]
+
+
+class SnakeCaseStyle(NamingStyle):
+ """Regex rules for snake_case naming style."""
+
+ CLASS_NAME_RGX = re.compile(r"[^\W\dA-Z][^\WA-Z]+$")
+ MOD_NAME_RGX = re.compile(r"[^\W\dA-Z][^\WA-Z]*$")
+ CONST_NAME_RGX = re.compile(r"([^\W\dA-Z][^\WA-Z]*|__.*__)$")
+ COMP_VAR_RGX = re.compile(r"[^\W\dA-Z][^\WA-Z]*$")
+ DEFAULT_NAME_RGX = re.compile(
+ r"([^\W\dA-Z][^\WA-Z]{2,}|_[^\WA-Z]*|__[^\WA-Z\d_][^\WA-Z]+__)$"
+ )
+ CLASS_ATTRIBUTE_RGX = re.compile(r"([^\W\dA-Z][^\WA-Z]{2,}|__.*__)$")
+
+
+class CamelCaseStyle(NamingStyle):
+ """Regex rules for camelCase naming style."""
+
+ CLASS_NAME_RGX = re.compile(r"[^\W\dA-Z][^\W_]+$")
+ MOD_NAME_RGX = re.compile(r"[^\W\dA-Z][^\W_]*$")
+ CONST_NAME_RGX = re.compile(r"([^\W\dA-Z][^\W_]*|__.*__)$")
+ COMP_VAR_RGX = re.compile(r"[^\W\dA-Z][^\W_]*$")
+ DEFAULT_NAME_RGX = re.compile(r"([^\W\dA-Z][^\W_]{2,}|__[^\W\dA-Z_]\w+__)$")
+ CLASS_ATTRIBUTE_RGX = re.compile(r"([^\W\dA-Z][^\W_]{2,}|__.*__)$")
+
+
+class PascalCaseStyle(NamingStyle):
+ """Regex rules for PascalCase naming style."""
+
+ CLASS_NAME_RGX = re.compile(r"[^\W\da-z][^\W_]+$")
+ MOD_NAME_RGX = re.compile(r"[^\W\da-z][^\W_]+$")
+ CONST_NAME_RGX = re.compile(r"([^\W\da-z][^\W_]*|__.*__)$")
+ COMP_VAR_RGX = re.compile(r"[^\W\da-z][^\W_]+$")
+ DEFAULT_NAME_RGX = re.compile(r"([^\W\da-z][^\W_]{2,}|__[^\W\dA-Z_]\w+__)$")
+ CLASS_ATTRIBUTE_RGX = re.compile(r"[^\W\da-z][^\W_]{2,}$")
+
+
+class UpperCaseStyle(NamingStyle):
+ """Regex rules for UPPER_CASE naming style."""
+
+ CLASS_NAME_RGX = re.compile(r"[^\W\da-z][^\Wa-z]+$")
+ MOD_NAME_RGX = re.compile(r"[^\W\da-z][^\Wa-z]+$")
+ CONST_NAME_RGX = re.compile(r"([^\W\da-z][^\Wa-z]*|__.*__)$")
+ COMP_VAR_RGX = re.compile(r"[^\W\da-z][^\Wa-z]+$")
+ DEFAULT_NAME_RGX = re.compile(r"([^\W\da-z][^\Wa-z]{2,}|__[^\W\dA-Z_]\w+__)$")
+ CLASS_ATTRIBUTE_RGX = re.compile(r"[^\W\da-z][^\Wa-z]{2,}$")
+
+
+class AnyStyle(NamingStyle):
+ pass
+
+
+NAMING_STYLES = {
+ "snake_case": SnakeCaseStyle,
+ "camelCase": CamelCaseStyle,
+ "PascalCase": PascalCaseStyle,
+ "UPPER_CASE": UpperCaseStyle,
+ "any": AnyStyle,
+}
+
+# do not require a doc string on private/system methods
+NO_REQUIRED_DOC_RGX = re.compile("^_")
+REVERSED_PROTOCOL_METHOD = "__reversed__"
+SEQUENCE_PROTOCOL_METHODS = ("__getitem__", "__len__")
+REVERSED_METHODS = (SEQUENCE_PROTOCOL_METHODS, (REVERSED_PROTOCOL_METHOD,))
+TYPECHECK_COMPARISON_OPERATORS = frozenset(("is", "is not", "==", "!="))
+LITERAL_NODE_TYPES = (astroid.Const, astroid.Dict, astroid.List, astroid.Set)
+UNITTEST_CASE = "unittest.case"
+BUILTINS = builtins.__name__
+TYPE_QNAME = "%s.type" % BUILTINS
+ABC_METACLASSES = {"_py_abc.ABCMeta", "abc.ABCMeta"} # Python 3.7+,
+
+# Name categories that are always consistent with all naming conventions.
+EXEMPT_NAME_CATEGORIES = {"exempt", "ignore"}
+
+# A mapping from qname -> symbol, to be used when generating messages
+# about dangerous default values as arguments
+DEFAULT_ARGUMENT_SYMBOLS = dict(
+ zip(
+ [".".join([BUILTINS, x]) for x in ("set", "dict", "list")],
+ ["set()", "{}", "[]"],
+ ),
+ **{
+ x: "%s()" % x
+ for x in (
+ "collections.deque",
+ "collections.ChainMap",
+ "collections.Counter",
+ "collections.OrderedDict",
+ "collections.defaultdict",
+ "collections.UserDict",
+ "collections.UserList",
+ )
+ },
+)
+REVERSED_COMPS = {"<": ">", "<=": ">=", ">": "<", ">=": "<="}
+COMPARISON_OPERATORS = frozenset(("==", "!=", "<", ">", "<=", ">="))
+# List of methods which can be redefined
+REDEFINABLE_METHODS = frozenset(("__module__",))
+TYPING_FORWARD_REF_QNAME = "typing.ForwardRef"
+
+
+def _redefines_import(node):
+ """Detect that the given node (AssignName) is inside an
+ exception handler and redefines an import from the tryexcept body.
+ Returns True if the node redefines an import, False otherwise.
+ """
+ current = node
+ while current and not isinstance(current.parent, astroid.ExceptHandler):
+ current = current.parent
+ if not current or not utils.error_of_type(current.parent, ImportError):
+ return False
+ try_block = current.parent.parent
+ for import_node in try_block.nodes_of_class((astroid.ImportFrom, astroid.Import)):
+ for name, alias in import_node.names:
+ if alias:
+ if alias == node.name:
+ return True
+ elif name == node.name:
+ return True
+ return False
+
+
+def in_loop(node):
+ """return True if the node is inside a kind of for loop"""
+ parent = node.parent
+ while parent is not None:
+ if isinstance(
+ parent,
+ (
+ astroid.For,
+ astroid.ListComp,
+ astroid.SetComp,
+ astroid.DictComp,
+ astroid.GeneratorExp,
+ ),
+ ):
+ return True
+ parent = parent.parent
+ return False
+
+
+def in_nested_list(nested_list, obj):
+ """return true if the object is an element of <nested_list> or of a nested
+ list
+ """
+ for elmt in nested_list:
+ if isinstance(elmt, (list, tuple)):
+ if in_nested_list(elmt, obj):
+ return True
+ elif elmt == obj:
+ return True
+ return False
+
+
+def _get_break_loop_node(break_node):
+ """
+ Returns the loop node that holds the break node in arguments.
+
+ Args:
+ break_node (astroid.Break): the break node of interest.
+
+ Returns:
+ astroid.For or astroid.While: the loop node holding the break node.
+ """
+ loop_nodes = (astroid.For, astroid.While)
+ parent = break_node.parent
+ while not isinstance(parent, loop_nodes) or break_node in getattr(
+ parent, "orelse", []
+ ):
+ break_node = parent
+ parent = parent.parent
+ if parent is None:
+ break
+ return parent
+
+
+def _loop_exits_early(loop):
+ """
+ Returns true if a loop may ends up in a break statement.
+
+ Args:
+ loop (astroid.For, astroid.While): the loop node inspected.
+
+ Returns:
+ bool: True if the loop may ends up in a break statement, False otherwise.
+ """
+ loop_nodes = (astroid.For, astroid.While)
+ definition_nodes = (astroid.FunctionDef, astroid.ClassDef)
+ inner_loop_nodes = [
+ _node
+ for _node in loop.nodes_of_class(loop_nodes, skip_klass=definition_nodes)
+ if _node != loop
+ ]
+ return any(
+ _node
+ for _node in loop.nodes_of_class(astroid.Break, skip_klass=definition_nodes)
+ if _get_break_loop_node(_node) not in inner_loop_nodes
+ )
+
+
+def _is_multi_naming_match(match, node_type, confidence):
+ return (
+ match is not None
+ and match.lastgroup is not None
+ and match.lastgroup not in EXEMPT_NAME_CATEGORIES
+ and (node_type != "method" or confidence != interfaces.INFERENCE_FAILURE)
+ )
+
+
+BUILTIN_PROPERTY = "builtins.property"
+
+
+def _get_properties(config):
+ """Returns a tuple of property classes and names.
+
+ Property classes are fully qualified, such as 'abc.abstractproperty' and
+ property names are the actual names, such as 'abstract_property'.
+ """
+ property_classes = {BUILTIN_PROPERTY}
+ property_names = set() # Not returning 'property', it has its own check.
+ if config is not None:
+ property_classes.update(config.property_classes)
+ property_names.update(
+ prop.rsplit(".", 1)[-1] for prop in config.property_classes
+ )
+ return property_classes, property_names
+
+
+def _determine_function_name_type(node: astroid.FunctionDef, config=None):
+ """Determine the name type whose regex the a function's name should match.
+
+ :param node: A function node.
+ :param config: Configuration from which to pull additional property classes.
+ :type config: :class:`optparse.Values`
+
+ :returns: One of ('function', 'method', 'attr')
+ :rtype: str
+ """
+ property_classes, property_names = _get_properties(config)
+ if not node.is_method():
+ return "function"
+
+ if is_property_setter(node) or is_property_deleter(node):
+ # If the function is decorated using the prop_method.{setter,getter}
+ # form, treat it like an attribute as well.
+ return "attr"
+
+ if node.decorators:
+ decorators = node.decorators.nodes
+ else:
+ decorators = []
+ for decorator in decorators:
+ # If the function is a property (decorated with @property
+ # or @abc.abstractproperty), the name type is 'attr'.
+ if isinstance(decorator, astroid.Name) or (
+ isinstance(decorator, astroid.Attribute)
+ and decorator.attrname in property_names
+ ):
+ inferred = utils.safe_infer(decorator)
+ if (
+ inferred
+ and hasattr(inferred, "qname")
+ and inferred.qname() in property_classes
+ ):
+ return "attr"
+ return "method"
+
+
+def _has_abstract_methods(node):
+ """
+ Determine if the given `node` has abstract methods.
+
+ The methods should be made abstract by decorating them
+ with `abc` decorators.
+ """
+ return len(utils.unimplemented_abstract_methods(node)) > 0
+
+
+def report_by_type_stats(sect, stats, old_stats):
+ """make a report of
+
+ * percentage of different types documented
+ * percentage of different types with a bad name
+ """
+ # percentage of different types documented and/or with a bad name
+ nice_stats = {}
+ for node_type in ("module", "class", "method", "function"):
+ try:
+ total = stats[node_type]
+ except KeyError as e:
+ raise exceptions.EmptyReportError() from e
+ nice_stats[node_type] = {}
+ if total != 0:
+ try:
+ documented = total - stats["undocumented_" + node_type]
+ percent = (documented * 100.0) / total
+ nice_stats[node_type]["percent_documented"] = "%.2f" % percent
+ except KeyError:
+ nice_stats[node_type]["percent_documented"] = "NC"
+ try:
+ percent = (stats["badname_" + node_type] * 100.0) / total
+ nice_stats[node_type]["percent_badname"] = "%.2f" % percent
+ except KeyError:
+ nice_stats[node_type]["percent_badname"] = "NC"
+ lines = ("type", "number", "old number", "difference", "%documented", "%badname")
+ for node_type in ("module", "class", "method", "function"):
+ new = stats[node_type]
+ old = old_stats.get(node_type, None)
+ if old is not None:
+ diff_str = lint_utils.diff_string(old, new)
+ else:
+ old, diff_str = "NC", "NC"
+ lines += (
+ node_type,
+ str(new),
+ str(old),
+ diff_str,
+ nice_stats[node_type].get("percent_documented", "0"),
+ nice_stats[node_type].get("percent_badname", "0"),
+ )
+ sect.append(reporter_nodes.Table(children=lines, cols=6, rheaders=1))
+
+
+def redefined_by_decorator(node):
+ """return True if the object is a method redefined via decorator.
+
+ For example:
+ @property
+ def x(self): return self._x
+ @x.setter
+ def x(self, value): self._x = value
+ """
+ if node.decorators:
+ for decorator in node.decorators.nodes:
+ if (
+ isinstance(decorator, astroid.Attribute)
+ and getattr(decorator.expr, "name", None) == node.name
+ ):
+ return True
+ return False
+
+
+class _BasicChecker(checkers.BaseChecker):
+ __implements__ = interfaces.IAstroidChecker
+ name = "basic"
+
+
+class BasicErrorChecker(_BasicChecker):
+ msgs = {
+ "E0100": (
+ "__init__ method is a generator",
+ "init-is-generator",
+ "Used when the special class method __init__ is turned into a "
+ "generator by a yield in its body.",
+ ),
+ "E0101": (
+ "Explicit return in __init__",
+ "return-in-init",
+ "Used when the special class method __init__ has an explicit "
+ "return value.",
+ ),
+ "E0102": (
+ "%s already defined line %s",
+ "function-redefined",
+ "Used when a function / class / method is redefined.",
+ ),
+ "E0103": (
+ "%r not properly in loop",
+ "not-in-loop",
+ "Used when break or continue keywords are used outside a loop.",
+ ),
+ "E0104": (
+ "Return outside function",
+ "return-outside-function",
+ 'Used when a "return" statement is found outside a function or method.',
+ ),
+ "E0105": (
+ "Yield outside function",
+ "yield-outside-function",
+ 'Used when a "yield" statement is found outside a function or method.',
+ ),
+ "E0106": (
+ "Return with argument inside generator",
+ "return-arg-in-generator",
+ 'Used when a "return" statement with an argument is found '
+ "outside in a generator function or method (e.g. with some "
+ '"yield" statements).',
+ {"maxversion": (3, 3)},
+ ),
+ "E0107": (
+ "Use of the non-existent %s operator",
+ "nonexistent-operator",
+ "Used when you attempt to use the C-style pre-increment or "
+ "pre-decrement operator -- and ++, which doesn't exist in Python.",
+ ),
+ "E0108": (
+ "Duplicate argument name %s in function definition",
+ "duplicate-argument-name",
+ "Duplicate argument names in function definitions are syntax errors.",
+ ),
+ "E0110": (
+ "Abstract class %r with abstract methods instantiated",
+ "abstract-class-instantiated",
+ "Used when an abstract class with `abc.ABCMeta` as metaclass "
+ "has abstract methods and is instantiated.",
+ ),
+ "W0120": (
+ "Else clause on loop without a break statement",
+ "useless-else-on-loop",
+ "Loops should only have an else clause if they can exit early "
+ "with a break statement, otherwise the statements under else "
+ "should be on the same scope as the loop itself.",
+ ),
+ "E0112": (
+ "More than one starred expression in assignment",
+ "too-many-star-expressions",
+ "Emitted when there are more than one starred "
+ "expressions (`*x`) in an assignment. This is a SyntaxError.",
+ ),
+ "E0113": (
+ "Starred assignment target must be in a list or tuple",
+ "invalid-star-assignment-target",
+ "Emitted when a star expression is used as a starred assignment target.",
+ ),
+ "E0114": (
+ "Can use starred expression only in assignment target",
+ "star-needs-assignment-target",
+ "Emitted when a star expression is not used in an assignment target.",
+ ),
+ "E0115": (
+ "Name %r is nonlocal and global",
+ "nonlocal-and-global",
+ "Emitted when a name is both nonlocal and global.",
+ ),
+ "E0116": (
+ "'continue' not supported inside 'finally' clause",
+ "continue-in-finally",
+ "Emitted when the `continue` keyword is found "
+ "inside a finally clause, which is a SyntaxError.",
+ {"maxversion": (3, 8)},
+ ),
+ "E0117": (
+ "nonlocal name %s found without binding",
+ "nonlocal-without-binding",
+ "Emitted when a nonlocal variable does not have an attached "
+ "name somewhere in the parent scopes",
+ ),
+ "E0118": (
+ "Name %r is used prior to global declaration",
+ "used-prior-global-declaration",
+ "Emitted when a name is used prior a global declaration, "
+ "which results in an error since Python 3.6.",
+ {"minversion": (3, 6)},
+ ),
+ }
+
+ @utils.check_messages("function-redefined")
+ def visit_classdef(self, node):
+ self._check_redefinition("class", node)
+
+ def _too_many_starred_for_tuple(self, assign_tuple):
+ starred_count = 0
+ for elem in assign_tuple.itered():
+ if isinstance(elem, astroid.Tuple):
+ return self._too_many_starred_for_tuple(elem)
+ if isinstance(elem, astroid.Starred):
+ starred_count += 1
+ return starred_count > 1
+
+ @utils.check_messages("too-many-star-expressions", "invalid-star-assignment-target")
+ def visit_assign(self, node):
+ # Check *a, *b = ...
+ assign_target = node.targets[0]
+ # Check *a = b
+ if isinstance(node.targets[0], astroid.Starred):
+ self.add_message("invalid-star-assignment-target", node=node)
+
+ if not isinstance(assign_target, astroid.Tuple):
+ return
+ if self._too_many_starred_for_tuple(assign_target):
+ self.add_message("too-many-star-expressions", node=node)
+
+ @utils.check_messages("star-needs-assignment-target")
+ def visit_starred(self, node):
+ """Check that a Starred expression is used in an assignment target."""
+ if isinstance(node.parent, astroid.Call):
+ # f(*args) is converted to Call(args=[Starred]), so ignore
+ # them for this check.
+ return
+ if isinstance(
+ node.parent, (astroid.List, astroid.Tuple, astroid.Set, astroid.Dict)
+ ):
+ # PEP 448 unpacking.
+ return
+
+ stmt = node.statement()
+ if not isinstance(stmt, astroid.Assign):
+ return
+
+ if stmt.value is node or stmt.value.parent_of(node):
+ self.add_message("star-needs-assignment-target", node=node)
+
+ @utils.check_messages(
+ "init-is-generator",
+ "return-in-init",
+ "function-redefined",
+ "return-arg-in-generator",
+ "duplicate-argument-name",
+ "nonlocal-and-global",
+ "used-prior-global-declaration",
+ )
+ def visit_functiondef(self, node):
+ self._check_nonlocal_and_global(node)
+ self._check_name_used_prior_global(node)
+ if not redefined_by_decorator(
+ node
+ ) and not utils.is_registered_in_singledispatch_function(node):
+ self._check_redefinition(node.is_method() and "method" or "function", node)
+ # checks for max returns, branch, return in __init__
+ returns = node.nodes_of_class(
+ astroid.Return, skip_klass=(astroid.FunctionDef, astroid.ClassDef)
+ )
+ if node.is_method() and node.name == "__init__":
+ if node.is_generator():
+ self.add_message("init-is-generator", node=node)
+ else:
+ values = [r.value for r in returns]
+ # Are we returning anything but None from constructors
+ if any(v for v in values if not utils.is_none(v)):
+ self.add_message("return-in-init", node=node)
+ # Check for duplicate names by clustering args with same name for detailed report
+ arg_clusters = collections.defaultdict(list)
+ arguments = filter(None, [node.args.args, node.args.kwonlyargs])
+
+ for arg in itertools.chain.from_iterable(arguments):
+ arg_clusters[arg.name].append(arg)
+
+ # provide detailed report about each repeated argument
+ for argument_duplicates in arg_clusters.values():
+ if len(argument_duplicates) != 1:
+ for argument in argument_duplicates:
+ self.add_message(
+ "duplicate-argument-name",
+ line=argument.lineno,
+ node=argument,
+ args=(argument.name,),
+ )
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ def _check_name_used_prior_global(self, node):
+
+ scope_globals = {
+ name: child
+ for child in node.nodes_of_class(astroid.Global)
+ for name in child.names
+ if child.scope() is node
+ }
+
+ if not scope_globals:
+ return
+
+ for node_name in node.nodes_of_class(astroid.Name):
+ if node_name.scope() is not node:
+ continue
+
+ name = node_name.name
+ corresponding_global = scope_globals.get(name)
+ if not corresponding_global:
+ continue
+
+ global_lineno = corresponding_global.fromlineno
+ if global_lineno and global_lineno > node_name.fromlineno:
+ self.add_message(
+ "used-prior-global-declaration", node=node_name, args=(name,)
+ )
+
+ def _check_nonlocal_and_global(self, node):
+ """Check that a name is both nonlocal and global."""
+
+ def same_scope(current):
+ return current.scope() is node
+
+ from_iter = itertools.chain.from_iterable
+ nonlocals = set(
+ from_iter(
+ child.names
+ for child in node.nodes_of_class(astroid.Nonlocal)
+ if same_scope(child)
+ )
+ )
+
+ if not nonlocals:
+ return
+
+ global_vars = set(
+ from_iter(
+ child.names
+ for child in node.nodes_of_class(astroid.Global)
+ if same_scope(child)
+ )
+ )
+ for name in nonlocals.intersection(global_vars):
+ self.add_message("nonlocal-and-global", args=(name,), node=node)
+
+ @utils.check_messages("return-outside-function")
+ def visit_return(self, node):
+ if not isinstance(node.frame(), astroid.FunctionDef):
+ self.add_message("return-outside-function", node=node)
+
+ @utils.check_messages("yield-outside-function")
+ def visit_yield(self, node):
+ self._check_yield_outside_func(node)
+
+ @utils.check_messages("yield-outside-function")
+ def visit_yieldfrom(self, node):
+ self._check_yield_outside_func(node)
+
+ @utils.check_messages("not-in-loop", "continue-in-finally")
+ def visit_continue(self, node):
+ self._check_in_loop(node, "continue")
+
+ @utils.check_messages("not-in-loop")
+ def visit_break(self, node):
+ self._check_in_loop(node, "break")
+
+ @utils.check_messages("useless-else-on-loop")
+ def visit_for(self, node):
+ self._check_else_on_loop(node)
+
+ @utils.check_messages("useless-else-on-loop")
+ def visit_while(self, node):
+ self._check_else_on_loop(node)
+
+ @utils.check_messages("nonexistent-operator")
+ def visit_unaryop(self, node):
+ """check use of the non-existent ++ and -- operator operator"""
+ if (
+ (node.op in "+-")
+ and isinstance(node.operand, astroid.UnaryOp)
+ and (node.operand.op == node.op)
+ ):
+ self.add_message("nonexistent-operator", node=node, args=node.op * 2)
+
+ def _check_nonlocal_without_binding(self, node, name):
+ current_scope = node.scope()
+ while True:
+ if current_scope.parent is None:
+ break
+
+ if not isinstance(current_scope, (astroid.ClassDef, astroid.FunctionDef)):
+ self.add_message("nonlocal-without-binding", args=(name,), node=node)
+ return
+
+ if name not in current_scope.locals:
+ current_scope = current_scope.parent.scope()
+ continue
+
+ # Okay, found it.
+ return
+
+ if not isinstance(current_scope, astroid.FunctionDef):
+ self.add_message("nonlocal-without-binding", args=(name,), node=node)
+
+ @utils.check_messages("nonlocal-without-binding")
+ def visit_nonlocal(self, node):
+ for name in node.names:
+ self._check_nonlocal_without_binding(node, name)
+
+ @utils.check_messages("abstract-class-instantiated")
+ def visit_call(self, node):
+ """Check instantiating abstract class with
+ abc.ABCMeta as metaclass.
+ """
+ try:
+ for inferred in node.func.infer():
+ self._check_inferred_class_is_abstract(inferred, node)
+ except astroid.InferenceError:
+ return
+
+ def _check_inferred_class_is_abstract(self, inferred, node):
+ if not isinstance(inferred, astroid.ClassDef):
+ return
+
+ klass = utils.node_frame_class(node)
+ if klass is inferred:
+ # Don't emit the warning if the class is instantiated
+ # in its own body or if the call is not an instance
+ # creation. If the class is instantiated into its own
+ # body, we're expecting that it knows what it is doing.
+ return
+
+ # __init__ was called
+ abstract_methods = _has_abstract_methods(inferred)
+
+ if not abstract_methods:
+ return
+
+ metaclass = inferred.metaclass()
+
+ if metaclass is None:
+ # Python 3.4 has `abc.ABC`, which won't be detected
+ # by ClassNode.metaclass()
+ for ancestor in inferred.ancestors():
+ if ancestor.qname() == "abc.ABC":
+ self.add_message(
+ "abstract-class-instantiated", args=(inferred.name,), node=node
+ )
+ break
+
+ return
+
+ if metaclass.qname() in ABC_METACLASSES:
+ self.add_message(
+ "abstract-class-instantiated", args=(inferred.name,), node=node
+ )
+
+ def _check_yield_outside_func(self, node):
+ if not isinstance(node.frame(), (astroid.FunctionDef, astroid.Lambda)):
+ self.add_message("yield-outside-function", node=node)
+
+ def _check_else_on_loop(self, node):
+ """Check that any loop with an else clause has a break statement."""
+ if node.orelse and not _loop_exits_early(node):
+ self.add_message(
+ "useless-else-on-loop",
+ node=node,
+ # This is not optimal, but the line previous
+ # to the first statement in the else clause
+ # will usually be the one that contains the else:.
+ line=node.orelse[0].lineno - 1,
+ )
+
+ def _check_in_loop(self, node, node_name):
+ """check that a node is inside a for or while loop"""
+ _node = node.parent
+ while _node:
+ if isinstance(_node, (astroid.For, astroid.While)):
+ if node not in _node.orelse:
+ return
+
+ if isinstance(_node, (astroid.ClassDef, astroid.FunctionDef)):
+ break
+ if (
+ isinstance(_node, astroid.TryFinally)
+ and node in _node.finalbody
+ and isinstance(node, astroid.Continue)
+ ):
+ self.add_message("continue-in-finally", node=node)
+
+ _node = _node.parent
+
+ self.add_message("not-in-loop", node=node, args=node_name)
+
+ def _check_redefinition(self, redeftype, node):
+ """check for redefinition of a function / method / class name"""
+ parent_frame = node.parent.frame()
+
+ # Ignore function stubs created for type information
+ redefinitions = parent_frame.locals[node.name]
+ defined_self = next(
+ (local for local in redefinitions if not utils.is_overload_stub(local)),
+ node,
+ )
+ if defined_self is not node and not astroid.are_exclusive(node, defined_self):
+ # Additional checks for methods which are not considered
+ # redefined, since they are already part of the base API.
+ if (
+ isinstance(parent_frame, astroid.ClassDef)
+ and node.name in REDEFINABLE_METHODS
+ ):
+ return
+
+ # Skip typing.overload() functions.
+ if utils.is_overload_stub(node):
+ return
+
+ # Exempt functions redefined on a condition.
+ if isinstance(node.parent, astroid.If):
+ # Exempt "if not <func>" cases
+ if (
+ isinstance(node.parent.test, astroid.UnaryOp)
+ and node.parent.test.op == "not"
+ and isinstance(node.parent.test.operand, astroid.Name)
+ and node.parent.test.operand.name == node.name
+ ):
+ return
+
+ # Exempt "if <func> is not None" cases
+ # pylint: disable=too-many-boolean-expressions
+ if (
+ isinstance(node.parent.test, astroid.Compare)
+ and isinstance(node.parent.test.left, astroid.Name)
+ and node.parent.test.left.name == node.name
+ and node.parent.test.ops[0][0] == "is"
+ and isinstance(node.parent.test.ops[0][1], astroid.Const)
+ and node.parent.test.ops[0][1].value is None
+ ):
+ return
+
+ # Check if we have forward references for this node.
+ try:
+ redefinition_index = redefinitions.index(node)
+ except ValueError:
+ pass
+ else:
+ for redefinition in redefinitions[:redefinition_index]:
+ inferred = utils.safe_infer(redefinition)
+ if (
+ inferred
+ and isinstance(inferred, astroid.Instance)
+ and inferred.qname() == TYPING_FORWARD_REF_QNAME
+ ):
+ return
+
+ dummy_variables_rgx = lint_utils.get_global_option(
+ self, "dummy-variables-rgx", default=None
+ )
+ if dummy_variables_rgx and dummy_variables_rgx.match(node.name):
+ return
+ self.add_message(
+ "function-redefined",
+ node=node,
+ args=(redeftype, defined_self.fromlineno),
+ )
+
+
+class BasicChecker(_BasicChecker):
+ """checks for :
+ * doc strings
+ * number of arguments, local variables, branches, returns and statements in
+ functions, methods
+ * required module attributes
+ * dangerous default values as arguments
+ * redefinition of function / method / class
+ * uses of the global statement
+ """
+
+ __implements__ = interfaces.IAstroidChecker
+
+ name = "basic"
+ msgs = {
+ "W0101": (
+ "Unreachable code",
+ "unreachable",
+ 'Used when there is some code behind a "return" or "raise" '
+ "statement, which will never be accessed.",
+ ),
+ "W0102": (
+ "Dangerous default value %s as argument",
+ "dangerous-default-value",
+ "Used when a mutable value as list or dictionary is detected in "
+ "a default value for an argument.",
+ ),
+ "W0104": (
+ "Statement seems to have no effect",
+ "pointless-statement",
+ "Used when a statement doesn't have (or at least seems to) any effect.",
+ ),
+ "W0105": (
+ "String statement has no effect",
+ "pointless-string-statement",
+ "Used when a string is used as a statement (which of course "
+ "has no effect). This is a particular case of W0104 with its "
+ "own message so you can easily disable it if you're using "
+ "those strings as documentation, instead of comments.",
+ ),
+ "W0106": (
+ 'Expression "%s" is assigned to nothing',
+ "expression-not-assigned",
+ "Used when an expression that is not a function call is assigned "
+ "to nothing. Probably something else was intended.",
+ ),
+ "W0108": (
+ "Lambda may not be necessary",
+ "unnecessary-lambda",
+ "Used when the body of a lambda expression is a function call "
+ "on the same argument list as the lambda itself; such lambda "
+ "expressions are in all but a few cases replaceable with the "
+ "function being called in the body of the lambda.",
+ ),
+ "W0109": (
+ "Duplicate key %r in dictionary",
+ "duplicate-key",
+ "Used when a dictionary expression binds the same key multiple times.",
+ ),
+ "W0122": (
+ "Use of exec",
+ "exec-used",
+ 'Used when you use the "exec" statement (function for Python '
+ "3), to discourage its usage. That doesn't "
+ "mean you cannot use it !",
+ ),
+ "W0123": (
+ "Use of eval",
+ "eval-used",
+ 'Used when you use the "eval" function, to discourage its '
+ "usage. Consider using `ast.literal_eval` for safely evaluating "
+ "strings containing Python expressions "
+ "from untrusted sources. ",
+ ),
+ "W0150": (
+ "%s statement in finally block may swallow exception",
+ "lost-exception",
+ "Used when a break or a return statement is found inside the "
+ "finally clause of a try...finally block: the exceptions raised "
+ "in the try clause will be silently swallowed instead of being "
+ "re-raised.",
+ ),
+ "W0199": (
+ "Assert called on a 2-item-tuple. Did you mean 'assert x,y'?",
+ "assert-on-tuple",
+ "A call of assert on a tuple will always evaluate to true if "
+ "the tuple is not empty, and will always evaluate to false if "
+ "it is.",
+ ),
+ "W0124": (
+ 'Following "as" with another context manager looks like a tuple.',
+ "confusing-with-statement",
+ "Emitted when a `with` statement component returns multiple values "
+ "and uses name binding with `as` only for a part of those values, "
+ "as in with ctx() as a, b. This can be misleading, since it's not "
+ "clear if the context manager returns a tuple or if the node without "
+ "a name binding is another context manager.",
+ ),
+ "W0125": (
+ "Using a conditional statement with a constant value",
+ "using-constant-test",
+ "Emitted when a conditional statement (If or ternary if) "
+ "uses a constant value for its test. This might not be what "
+ "the user intended to do.",
+ ),
+ "W0126": (
+ "Using a conditional statement with potentially wrong function or method call due to missing parentheses",
+ "missing-parentheses-for-call-in-test",
+ "Emitted when a conditional statement (If or ternary if) "
+ "seems to wrongly call a function due to missing parentheses",
+ ),
+ "W0127": (
+ "Assigning the same variable %r to itself",
+ "self-assigning-variable",
+ "Emitted when we detect that a variable is assigned to itself",
+ ),
+ "W0128": (
+ "Redeclared variable %r in assignment",
+ "redeclared-assigned-name",
+ "Emitted when we detect that a variable was redeclared in the same assignment.",
+ ),
+ "E0111": (
+ "The first reversed() argument is not a sequence",
+ "bad-reversed-sequence",
+ "Used when the first argument to reversed() builtin "
+ "isn't a sequence (does not implement __reversed__, "
+ "nor __getitem__ and __len__",
+ ),
+ "E0119": (
+ "format function is not called on str",
+ "misplaced-format-function",
+ "Emitted when format function is not called on str object. "
+ 'e.g doing print("value: {}").format(123) instead of '
+ 'print("value: {}".format(123)). This might not be what the user '
+ "intended to do.",
+ ),
+ "W0129": (
+ "Assert statement has a string literal as its first argument. The assert will %s fail.",
+ "assert-on-string-literal",
+ "Used when an assert statement has a string literal as its first argument, which will "
+ "cause the assert to always pass.",
+ ),
+ }
+
+ reports = (("RP0101", "Statistics by type", report_by_type_stats),)
+
+ def __init__(self, linter):
+ _BasicChecker.__init__(self, linter)
+ self.stats = None
+ self._tryfinallys = None
+
+ def open(self):
+ """initialize visit variables and statistics"""
+ self._tryfinallys = []
+ self.stats = self.linter.add_stats(module=0, function=0, method=0, class_=0)
+
+ @utils.check_messages("using-constant-test", "missing-parentheses-for-call-in-test")
+ def visit_if(self, node):
+ self._check_using_constant_test(node, node.test)
+
+ @utils.check_messages("using-constant-test", "missing-parentheses-for-call-in-test")
+ def visit_ifexp(self, node):
+ self._check_using_constant_test(node, node.test)
+
+ @utils.check_messages("using-constant-test", "missing-parentheses-for-call-in-test")
+ def visit_comprehension(self, node):
+ if node.ifs:
+ for if_test in node.ifs:
+ self._check_using_constant_test(node, if_test)
+
+ def _check_using_constant_test(self, node, test):
+ const_nodes = (
+ astroid.Module,
+ astroid.scoped_nodes.GeneratorExp,
+ astroid.Lambda,
+ astroid.FunctionDef,
+ astroid.ClassDef,
+ astroid.bases.Generator,
+ astroid.UnboundMethod,
+ astroid.BoundMethod,
+ astroid.Module,
+ )
+ structs = (astroid.Dict, astroid.Tuple, astroid.Set, astroid.List)
+
+ # These nodes are excepted, since they are not constant
+ # values, requiring a computation to happen.
+ except_nodes = (
+ astroid.Call,
+ astroid.BinOp,
+ astroid.BoolOp,
+ astroid.UnaryOp,
+ astroid.Subscript,
+ )
+ inferred = None
+ emit = isinstance(test, (astroid.Const,) + structs + const_nodes)
+ if not isinstance(test, except_nodes):
+ inferred = utils.safe_infer(test)
+
+ if emit:
+ self.add_message("using-constant-test", node=node)
+ elif isinstance(inferred, const_nodes):
+ # If the constant node is a FunctionDef or Lambda then
+ # it may be a illicit function call due to missing parentheses
+ call_inferred = None
+ try:
+ if isinstance(inferred, astroid.FunctionDef):
+ call_inferred = inferred.infer_call_result()
+ elif isinstance(inferred, astroid.Lambda):
+ call_inferred = inferred.infer_call_result(node)
+ except astroid.InferenceError:
+ call_inferred = None
+ if call_inferred:
+ try:
+ for inf_call in call_inferred:
+ if inf_call != astroid.Uninferable:
+ self.add_message(
+ "missing-parentheses-for-call-in-test", node=node
+ )
+ break
+ except astroid.InferenceError:
+ pass
+ self.add_message("using-constant-test", node=node)
+
+ def visit_module(self, _):
+ """check module name, docstring and required arguments"""
+ self.stats["module"] += 1
+
+ def visit_classdef(self, node): # pylint: disable=unused-argument
+ """check module name, docstring and redefinition
+ increment branch counter
+ """
+ self.stats["class"] += 1
+
+ @utils.check_messages(
+ "pointless-statement", "pointless-string-statement", "expression-not-assigned"
+ )
+ def visit_expr(self, node):
+ """Check for various kind of statements without effect"""
+ expr = node.value
+ if isinstance(expr, astroid.Const) and isinstance(expr.value, str):
+ # treat string statement in a separated message
+ # Handle PEP-257 attribute docstrings.
+ # An attribute docstring is defined as being a string right after
+ # an assignment at the module level, class level or __init__ level.
+ scope = expr.scope()
+ if isinstance(
+ scope, (astroid.ClassDef, astroid.Module, astroid.FunctionDef)
+ ):
+ if isinstance(scope, astroid.FunctionDef) and scope.name != "__init__":
+ pass
+ else:
+ sibling = expr.previous_sibling()
+ if (
+ sibling is not None
+ and sibling.scope() is scope
+ and isinstance(sibling, (astroid.Assign, astroid.AnnAssign))
+ ):
+ return
+ self.add_message("pointless-string-statement", node=node)
+ return
+
+ # Ignore if this is :
+ # * a direct function call
+ # * the unique child of a try/except body
+ # * a yield statement
+ # * an ellipsis (which can be used on Python 3 instead of pass)
+ # warn W0106 if we have any underlying function call (we can't predict
+ # side effects), else pointless-statement
+ if (
+ isinstance(expr, (astroid.Yield, astroid.Await, astroid.Call))
+ or (
+ isinstance(node.parent, astroid.TryExcept)
+ and node.parent.body == [node]
+ )
+ or (isinstance(expr, astroid.Const) and expr.value is Ellipsis)
+ ):
+ return
+ if any(expr.nodes_of_class(astroid.Call)):
+ self.add_message(
+ "expression-not-assigned", node=node, args=expr.as_string()
+ )
+ else:
+ self.add_message("pointless-statement", node=node)
+
+ @staticmethod
+ def _filter_vararg(node, call_args):
+ # Return the arguments for the given call which are
+ # not passed as vararg.
+ for arg in call_args:
+ if isinstance(arg, astroid.Starred):
+ if (
+ isinstance(arg.value, astroid.Name)
+ and arg.value.name != node.args.vararg
+ ):
+ yield arg
+ else:
+ yield arg
+
+ @staticmethod
+ def _has_variadic_argument(args, variadic_name):
+ if not args:
+ return True
+ for arg in args:
+ if isinstance(arg.value, astroid.Name):
+ if arg.value.name != variadic_name:
+ return True
+ else:
+ return True
+ return False
+
+ @utils.check_messages("unnecessary-lambda")
+ def visit_lambda(self, node):
+ """check whether or not the lambda is suspicious"""
+ # if the body of the lambda is a call expression with the same
+ # argument list as the lambda itself, then the lambda is
+ # possibly unnecessary and at least suspicious.
+ if node.args.defaults:
+ # If the arguments of the lambda include defaults, then a
+ # judgment cannot be made because there is no way to check
+ # that the defaults defined by the lambda are the same as
+ # the defaults defined by the function called in the body
+ # of the lambda.
+ return
+ call = node.body
+ if not isinstance(call, astroid.Call):
+ # The body of the lambda must be a function call expression
+ # for the lambda to be unnecessary.
+ return
+ if isinstance(node.body.func, astroid.Attribute) and isinstance(
+ node.body.func.expr, astroid.Call
+ ):
+ # Chained call, the intermediate call might
+ # return something else (but we don't check that, yet).
+ return
+
+ call_site = astroid.arguments.CallSite.from_call(call)
+ ordinary_args = list(node.args.args)
+ new_call_args = list(self._filter_vararg(node, call.args))
+ if node.args.kwarg:
+ if self._has_variadic_argument(call.kwargs, node.args.kwarg):
+ return
+
+ if node.args.vararg:
+ if self._has_variadic_argument(call.starargs, node.args.vararg):
+ return
+ elif call.starargs:
+ return
+
+ if call.keywords:
+ # Look for additional keyword arguments that are not part
+ # of the lambda's signature
+ lambda_kwargs = {keyword.name for keyword in node.args.defaults}
+ if len(lambda_kwargs) != len(call_site.keyword_arguments):
+ # Different lengths, so probably not identical
+ return
+ if set(call_site.keyword_arguments).difference(lambda_kwargs):
+ return
+
+ # The "ordinary" arguments must be in a correspondence such that:
+ # ordinary_args[i].name == call.args[i].name.
+ if len(ordinary_args) != len(new_call_args):
+ return
+ for arg, passed_arg in zip(ordinary_args, new_call_args):
+ if not isinstance(passed_arg, astroid.Name):
+ return
+ if arg.name != passed_arg.name:
+ return
+
+ self.add_message("unnecessary-lambda", line=node.fromlineno, node=node)
+
+ @utils.check_messages("dangerous-default-value")
+ def visit_functiondef(self, node):
+ """check function name, docstring, arguments, redefinition,
+ variable names, max locals
+ """
+ self.stats["method" if node.is_method() else "function"] += 1
+ self._check_dangerous_default(node)
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ def _check_dangerous_default(self, node):
+ """Check for dangerous default values as arguments."""
+
+ def is_iterable(internal_node):
+ return isinstance(internal_node, (astroid.List, astroid.Set, astroid.Dict))
+
+ defaults = node.args.defaults or [] + node.args.kw_defaults or []
+ for default in defaults:
+ if not default:
+ continue
+ try:
+ value = next(default.infer())
+ except astroid.InferenceError:
+ continue
+
+ if (
+ isinstance(value, astroid.Instance)
+ and value.qname() in DEFAULT_ARGUMENT_SYMBOLS
+ ):
+ if value is default:
+ msg = DEFAULT_ARGUMENT_SYMBOLS[value.qname()]
+ elif isinstance(value, astroid.Instance) or is_iterable(value):
+ # We are here in the following situation(s):
+ # * a dict/set/list/tuple call which wasn't inferred
+ # to a syntax node ({}, () etc.). This can happen
+ # when the arguments are invalid or unknown to
+ # the inference.
+ # * a variable from somewhere else, which turns out to be a list
+ # or a dict.
+ if is_iterable(default):
+ msg = value.pytype()
+ elif isinstance(default, astroid.Call):
+ msg = f"{value.name}() ({value.qname()})"
+ else:
+ msg = f"{default.as_string()} ({value.qname()})"
+ else:
+ # this argument is a name
+ msg = f"{default.as_string()} ({DEFAULT_ARGUMENT_SYMBOLS[value.qname()]})"
+ self.add_message("dangerous-default-value", node=node, args=(msg,))
+
+ @utils.check_messages("unreachable", "lost-exception")
+ def visit_return(self, node):
+ """1 - check is the node has a right sibling (if so, that's some
+ unreachable code)
+ 2 - check is the node is inside the finally clause of a try...finally
+ block
+ """
+ self._check_unreachable(node)
+ # Is it inside final body of a try...finally bloc ?
+ self._check_not_in_finally(node, "return", (astroid.FunctionDef,))
+
+ @utils.check_messages("unreachable")
+ def visit_continue(self, node):
+ """check is the node has a right sibling (if so, that's some unreachable
+ code)
+ """
+ self._check_unreachable(node)
+
+ @utils.check_messages("unreachable", "lost-exception")
+ def visit_break(self, node):
+ """1 - check is the node has a right sibling (if so, that's some
+ unreachable code)
+ 2 - check is the node is inside the finally clause of a try...finally
+ block
+ """
+ # 1 - Is it right sibling ?
+ self._check_unreachable(node)
+ # 2 - Is it inside final body of a try...finally bloc ?
+ self._check_not_in_finally(node, "break", (astroid.For, astroid.While))
+
+ @utils.check_messages("unreachable")
+ def visit_raise(self, node):
+ """check if the node has a right sibling (if so, that's some unreachable
+ code)
+ """
+ self._check_unreachable(node)
+
+ @utils.check_messages("exec-used")
+ def visit_exec(self, node):
+ """just print a warning on exec statements"""
+ self.add_message("exec-used", node=node)
+
+ def _check_misplaced_format_function(self, call_node):
+ if not isinstance(call_node.func, astroid.Attribute):
+ return
+ if call_node.func.attrname != "format":
+ return
+
+ expr = utils.safe_infer(call_node.func.expr)
+ if expr is astroid.Uninferable:
+ return
+ if not expr:
+ # we are doubtful on inferred type of node, so here just check if format
+ # was called on print()
+ call_expr = call_node.func.expr
+ if not isinstance(call_expr, astroid.Call):
+ return
+ if (
+ isinstance(call_expr.func, astroid.Name)
+ and call_expr.func.name == "print"
+ ):
+ self.add_message("misplaced-format-function", node=call_node)
+
+ @utils.check_messages(
+ "eval-used", "exec-used", "bad-reversed-sequence", "misplaced-format-function"
+ )
+ def visit_call(self, node):
+ """visit a Call node -> check if this is not a disallowed builtin
+ call and check for * or ** use
+ """
+ self._check_misplaced_format_function(node)
+ if isinstance(node.func, astroid.Name):
+ name = node.func.name
+ # ignore the name if it's not a builtin (i.e. not defined in the
+ # locals nor globals scope)
+ if not (name in node.frame() or name in node.root()):
+ if name == "exec":
+ self.add_message("exec-used", node=node)
+ elif name == "reversed":
+ self._check_reversed(node)
+ elif name == "eval":
+ self.add_message("eval-used", node=node)
+
+ @utils.check_messages("assert-on-tuple", "assert-on-string-literal")
+ def visit_assert(self, node):
+ """check whether assert is used on a tuple or string literal."""
+ if (
+ node.fail is None
+ and isinstance(node.test, astroid.Tuple)
+ and len(node.test.elts) == 2
+ ):
+ self.add_message("assert-on-tuple", node=node)
+
+ if isinstance(node.test, astroid.Const) and isinstance(node.test.value, str):
+ if node.test.value:
+ when = "never"
+ else:
+ when = "always"
+ self.add_message("assert-on-string-literal", node=node, args=(when,))
+
+ @utils.check_messages("duplicate-key")
+ def visit_dict(self, node):
+ """check duplicate key in dictionary"""
+ keys = set()
+ for k, _ in node.items:
+ if isinstance(k, astroid.Const):
+ key = k.value
+ if key in keys:
+ self.add_message("duplicate-key", node=node, args=key)
+ keys.add(key)
+
+ def visit_tryfinally(self, node):
+ """update try...finally flag"""
+ self._tryfinallys.append(node)
+
+ def leave_tryfinally(self, node): # pylint: disable=unused-argument
+ """update try...finally flag"""
+ self._tryfinallys.pop()
+
+ def _check_unreachable(self, node):
+ """check unreachable code"""
+ unreach_stmt = node.next_sibling()
+ if unreach_stmt is not None:
+ self.add_message("unreachable", node=unreach_stmt)
+
+ def _check_not_in_finally(self, node, node_name, breaker_classes=()):
+ """check that a node is not inside a finally clause of a
+ try...finally statement.
+ If we found before a try...finally bloc a parent which its type is
+ in breaker_classes, we skip the whole check."""
+ # if self._tryfinallys is empty, we're not an in try...finally block
+ if not self._tryfinallys:
+ return
+ # the node could be a grand-grand...-children of the try...finally
+ _parent = node.parent
+ _node = node
+ while _parent and not isinstance(_parent, breaker_classes):
+ if hasattr(_parent, "finalbody") and _node in _parent.finalbody:
+ self.add_message("lost-exception", node=node, args=node_name)
+ return
+ _node = _parent
+ _parent = _node.parent
+
+ def _check_reversed(self, node):
+ """check that the argument to `reversed` is a sequence"""
+ try:
+ argument = utils.safe_infer(utils.get_argument_from_call(node, position=0))
+ except utils.NoSuchArgumentError:
+ pass
+ else:
+ if argument is astroid.Uninferable:
+ return
+ if argument is None:
+ # Nothing was inferred.
+ # Try to see if we have iter().
+ if isinstance(node.args[0], astroid.Call):
+ try:
+ func = next(node.args[0].func.infer())
+ except astroid.InferenceError:
+ return
+ if getattr(
+ func, "name", None
+ ) == "iter" and utils.is_builtin_object(func):
+ self.add_message("bad-reversed-sequence", node=node)
+ return
+
+ if isinstance(argument, (astroid.List, astroid.Tuple)):
+ return
+
+ if isinstance(argument, astroid.Instance):
+ if any(
+ ancestor.name == "dict" and utils.is_builtin_object(ancestor)
+ for ancestor in itertools.chain(
+ (argument._proxied,), argument._proxied.ancestors()
+ )
+ ):
+ # Mappings aren't accepted by reversed(), unless
+ # they provide explicitly a __reversed__ method.
+ try:
+ argument.locals[REVERSED_PROTOCOL_METHOD]
+ except KeyError:
+ self.add_message("bad-reversed-sequence", node=node)
+ return
+
+ if hasattr(argument, "getattr"):
+ # everything else is not a proper sequence for reversed()
+ for methods in REVERSED_METHODS:
+ for meth in methods:
+ try:
+ argument.getattr(meth)
+ except astroid.NotFoundError:
+ break
+ else:
+ break
+ else:
+ self.add_message("bad-reversed-sequence", node=node)
+ else:
+ self.add_message("bad-reversed-sequence", node=node)
+
+ @utils.check_messages("confusing-with-statement")
+ def visit_with(self, node):
+ # a "with" statement with multiple managers corresponds
+ # to one AST "With" node with multiple items
+ pairs = node.items
+ if pairs:
+ for prev_pair, pair in zip(pairs, pairs[1:]):
+ if isinstance(prev_pair[1], astroid.AssignName) and (
+ pair[1] is None and not isinstance(pair[0], astroid.Call)
+ ):
+ # Don't emit a message if the second is a function call
+ # there's no way that can be mistaken for a name assignment.
+ # If the line number doesn't match
+ # we assume it's a nested "with".
+ self.add_message("confusing-with-statement", node=node)
+
+ def _check_self_assigning_variable(self, node):
+ # Detect assigning to the same variable.
+
+ scope = node.scope()
+ scope_locals = scope.locals
+
+ rhs_names = []
+ targets = node.targets
+ if isinstance(targets[0], astroid.Tuple):
+ if len(targets) != 1:
+ # A complex assignment, so bail out early.
+ return
+ targets = targets[0].elts
+ if len(targets) == 1:
+ # Unpacking a variable into the same name.
+ return
+
+ if isinstance(node.value, astroid.Name):
+ if len(targets) != 1:
+ return
+ rhs_names = [node.value]
+ elif isinstance(node.value, astroid.Tuple):
+ rhs_count = len(node.value.elts)
+ if len(targets) != rhs_count or rhs_count == 1:
+ return
+ rhs_names = node.value.elts
+
+ for target, lhs_name in zip(targets, rhs_names):
+ if not isinstance(lhs_name, astroid.Name):
+ continue
+ if not isinstance(target, astroid.AssignName):
+ continue
+ if isinstance(scope, astroid.ClassDef) and target.name in scope_locals:
+ # Check that the scope is different than a class level, which is usually
+ # a pattern to expose module level attributes as class level ones.
+ continue
+ if target.name == lhs_name.name:
+ self.add_message(
+ "self-assigning-variable", args=(target.name,), node=target
+ )
+
+ def _check_redeclared_assign_name(self, targets):
+ dummy_variables_rgx = lint_utils.get_global_option(
+ self, "dummy-variables-rgx", default=None
+ )
+
+ for target in targets:
+ if not isinstance(target, astroid.Tuple):
+ continue
+
+ found_names = []
+ for element in target.elts:
+ if isinstance(element, astroid.Tuple):
+ self._check_redeclared_assign_name([element])
+ elif isinstance(element, astroid.AssignName) and element.name != "_":
+ if dummy_variables_rgx and dummy_variables_rgx.match(element.name):
+ return
+ found_names.append(element.name)
+
+ names = collections.Counter(found_names)
+ for name, count in names.most_common():
+ if count > 1:
+ self.add_message(
+ "redeclared-assigned-name", args=(name,), node=target
+ )
+
+ @utils.check_messages("self-assigning-variable", "redeclared-assigned-name")
+ def visit_assign(self, node):
+ self._check_self_assigning_variable(node)
+ self._check_redeclared_assign_name(node.targets)
+
+ @utils.check_messages("redeclared-assigned-name")
+ def visit_for(self, node):
+ self._check_redeclared_assign_name([node.target])
+
+
+KNOWN_NAME_TYPES = {
+ "module",
+ "const",
+ "class",
+ "function",
+ "method",
+ "attr",
+ "argument",
+ "variable",
+ "class_attribute",
+ "class_const",
+ "inlinevar",
+}
+
+HUMAN_READABLE_TYPES = {
+ "module": "module",
+ "const": "constant",
+ "class": "class",
+ "function": "function",
+ "method": "method",
+ "attr": "attribute",
+ "argument": "argument",
+ "variable": "variable",
+ "class_attribute": "class attribute",
+ "class_const": "class constant",
+ "inlinevar": "inline iteration",
+}
+
+DEFAULT_NAMING_STYLES = {
+ "module": "snake_case",
+ "const": "UPPER_CASE",
+ "class": "PascalCase",
+ "function": "snake_case",
+ "method": "snake_case",
+ "attr": "snake_case",
+ "argument": "snake_case",
+ "variable": "snake_case",
+ "class_attribute": "any",
+ "class_const": "UPPER_CASE",
+ "inlinevar": "any",
+}
+
+
+def _create_naming_options():
+ name_options = []
+ for name_type in sorted(KNOWN_NAME_TYPES):
+ human_readable_name = HUMAN_READABLE_TYPES[name_type]
+ default_style = DEFAULT_NAMING_STYLES[name_type]
+ name_type = name_type.replace("_", "-")
+ name_options.append(
+ (
+ f"{name_type}-naming-style",
+ {
+ "default": default_style,
+ "type": "choice",
+ "choices": list(NAMING_STYLES.keys()),
+ "metavar": "<style>",
+ "help": "Naming style matching correct %s names."
+ % (human_readable_name,),
+ },
+ )
+ )
+ name_options.append(
+ (
+ f"{name_type}-rgx",
+ {
+ "default": None,
+ "type": "regexp",
+ "metavar": "<regexp>",
+ "help": "Regular expression matching correct %s names. Overrides %s-naming-style."
+ % (human_readable_name, name_type),
+ },
+ )
+ )
+ return tuple(name_options)
+
+
+class NameChecker(_BasicChecker):
+ msgs = {
+ "C0103": (
+ '%s name "%s" doesn\'t conform to %s',
+ "invalid-name",
+ "Used when the name doesn't conform to naming rules "
+ "associated to its type (constant, variable, class...).",
+ ),
+ "C0104": (
+ 'Disallowed name "%s"',
+ "disallowed-name",
+ "Used when the name matches bad-names or bad-names-rgxs- (unauthorized names).",
+ {
+ "old_names": [
+ ("C0102", "blacklisted-name"),
+ ]
+ },
+ ),
+ "C0144": (
+ '%s name "%s" contains a non-ASCII unicode character',
+ "non-ascii-name",
+ "Used when the name contains at least one non-ASCII unicode character.",
+ ),
+ "W0111": (
+ "Name %s will become a keyword in Python %s",
+ "assign-to-new-keyword",
+ "Used when assignment will become invalid in future "
+ "Python release due to introducing new keyword.",
+ ),
+ }
+
+ options = (
+ (
+ "good-names",
+ {
+ "default": ("i", "j", "k", "ex", "Run", "_"),
+ "type": "csv",
+ "metavar": "<names>",
+ "help": "Good variable names which should always be accepted,"
+ " separated by a comma.",
+ },
+ ),
+ (
+ "good-names-rgxs",
+ {
+ "default": "",
+ "type": "regexp_csv",
+ "metavar": "<names>",
+ "help": "Good variable names regexes, separated by a comma. If names match any regex,"
+ " they will always be accepted",
+ },
+ ),
+ (
+ "bad-names",
+ {
+ "default": ("foo", "bar", "baz", "toto", "tutu", "tata"),
+ "type": "csv",
+ "metavar": "<names>",
+ "help": "Bad variable names which should always be refused, "
+ "separated by a comma.",
+ },
+ ),
+ (
+ "bad-names-rgxs",
+ {
+ "default": "",
+ "type": "regexp_csv",
+ "metavar": "<names>",
+ "help": "Bad variable names regexes, separated by a comma. If names match any regex,"
+ " they will always be refused",
+ },
+ ),
+ (
+ "name-group",
+ {
+ "default": (),
+ "type": "csv",
+ "metavar": "<name1:name2>",
+ "help": (
+ "Colon-delimited sets of names that determine each"
+ " other's naming style when the name regexes"
+ " allow several styles."
+ ),
+ },
+ ),
+ (
+ "include-naming-hint",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "Include a hint for the correct naming format with invalid-name.",
+ },
+ ),
+ (
+ "property-classes",
+ {
+ "default": ("abc.abstractproperty",),
+ "type": "csv",
+ "metavar": "<decorator names>",
+ "help": "List of decorators that produce properties, such as "
+ "abc.abstractproperty. Add to this list to register "
+ "other decorators that produce valid properties. "
+ "These decorators are taken in consideration only for invalid-name.",
+ },
+ ),
+ ) + _create_naming_options()
+
+ KEYWORD_ONSET = {(3, 7): {"async", "await"}}
+
+ def __init__(self, linter):
+ _BasicChecker.__init__(self, linter)
+ self._name_category = {}
+ self._name_group = {}
+ self._bad_names = {}
+ self._name_regexps = {}
+ self._name_hints = {}
+ self._good_names_rgxs_compiled = []
+ self._bad_names_rgxs_compiled = []
+ self._non_ascii_rgx_compiled = re.compile("[^\u0000-\u007F]")
+
+ def open(self):
+ self.stats = self.linter.add_stats(
+ badname_module=0,
+ badname_class=0,
+ badname_function=0,
+ badname_method=0,
+ badname_attr=0,
+ badname_const=0,
+ badname_variable=0,
+ badname_inlinevar=0,
+ badname_argument=0,
+ badname_class_attribute=0,
+ badname_class_const=0,
+ )
+ for group in self.config.name_group:
+ for name_type in group.split(":"):
+ self._name_group[name_type] = f"group_{group}"
+
+ regexps, hints = self._create_naming_rules()
+ self._name_regexps = regexps
+ self._name_hints = hints
+ self._good_names_rgxs_compiled = [
+ re.compile(rgxp) for rgxp in self.config.good_names_rgxs
+ ]
+ self._bad_names_rgxs_compiled = [
+ re.compile(rgxp) for rgxp in self.config.bad_names_rgxs
+ ]
+
+ def _create_naming_rules(self):
+ regexps = {}
+ hints = {}
+
+ for name_type in KNOWN_NAME_TYPES:
+ naming_style_option_name = f"{name_type}_naming_style"
+ naming_style_name = getattr(self.config, naming_style_option_name)
+
+ regexps[name_type] = NAMING_STYLES[naming_style_name].get_regex(name_type)
+
+ custom_regex_setting_name = f"{name_type}_rgx"
+ custom_regex = getattr(self.config, custom_regex_setting_name, None)
+ if custom_regex is not None:
+ regexps[name_type] = custom_regex
+
+ if custom_regex is not None:
+ hints[name_type] = "%r pattern" % custom_regex.pattern
+ else:
+ hints[name_type] = "%s naming style" % naming_style_name
+
+ return regexps, hints
+
+ @utils.check_messages("disallowed-name", "invalid-name", "non-ascii-name")
+ def visit_module(self, node):
+ self._check_name("module", node.name.split(".")[-1], node)
+ self._bad_names = {}
+
+ def leave_module(self, node): # pylint: disable=unused-argument
+ for all_groups in self._bad_names.values():
+ if len(all_groups) < 2:
+ continue
+ groups = collections.defaultdict(list)
+ min_warnings = sys.maxsize
+ for group in all_groups.values():
+ groups[len(group)].append(group)
+ min_warnings = min(len(group), min_warnings)
+ if len(groups[min_warnings]) > 1:
+ by_line = sorted(
+ groups[min_warnings],
+ key=lambda group: min(warning[0].lineno for warning in group),
+ )
+ warnings = itertools.chain(*by_line[1:])
+ else:
+ warnings = groups[min_warnings][0]
+ for args in warnings:
+ self._raise_name_warning(*args)
+
+ @utils.check_messages(
+ "disallowed-name", "invalid-name", "assign-to-new-keyword", "non-ascii-name"
+ )
+ def visit_classdef(self, node):
+ self._check_assign_to_new_keyword_violation(node.name, node)
+ self._check_name("class", node.name, node)
+ for attr, anodes in node.instance_attrs.items():
+ if not any(node.instance_attr_ancestors(attr)):
+ self._check_name("attr", attr, anodes[0])
+
+ @utils.check_messages(
+ "disallowed-name", "invalid-name", "assign-to-new-keyword", "non-ascii-name"
+ )
+ def visit_functiondef(self, node):
+ # Do not emit any warnings if the method is just an implementation
+ # of a base class method.
+ self._check_assign_to_new_keyword_violation(node.name, node)
+ confidence = interfaces.HIGH
+ if node.is_method():
+ if utils.overrides_a_method(node.parent.frame(), node.name):
+ return
+ confidence = (
+ interfaces.INFERENCE
+ if utils.has_known_bases(node.parent.frame())
+ else interfaces.INFERENCE_FAILURE
+ )
+
+ self._check_name(
+ _determine_function_name_type(node, config=self.config),
+ node.name,
+ node,
+ confidence,
+ )
+ # Check argument names
+ args = node.args.args
+ if args is not None:
+ self._recursive_check_names(args, node)
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ @utils.check_messages("disallowed-name", "invalid-name", "non-ascii-name")
+ def visit_global(self, node):
+ for name in node.names:
+ self._check_name("const", name, node)
+
+ @utils.check_messages(
+ "disallowed-name", "invalid-name", "assign-to-new-keyword", "non-ascii-name"
+ )
+ def visit_assignname(self, node):
+ """check module level assigned names"""
+ self._check_assign_to_new_keyword_violation(node.name, node)
+ frame = node.frame()
+ assign_type = node.assign_type()
+ if isinstance(assign_type, astroid.Comprehension):
+ self._check_name("inlinevar", node.name, node)
+ elif isinstance(frame, astroid.Module):
+ if isinstance(assign_type, astroid.Assign):
+ if isinstance(utils.safe_infer(assign_type.value), astroid.ClassDef):
+ self._check_name("class", node.name, node)
+ # Don't emit if the name redefines an import
+ # in an ImportError except handler.
+ elif not _redefines_import(node) and isinstance(
+ utils.safe_infer(assign_type.value), astroid.Const
+ ):
+ self._check_name("const", node.name, node)
+ elif isinstance(
+ assign_type, astroid.AnnAssign
+ ) and utils.is_assign_name_annotated_with(node, "Final"):
+ self._check_name("const", node.name, node)
+ elif isinstance(frame, astroid.FunctionDef):
+ # global introduced variable aren't in the function locals
+ if node.name in frame and node.name not in frame.argnames():
+ if not _redefines_import(node):
+ self._check_name("variable", node.name, node)
+ elif isinstance(frame, astroid.ClassDef):
+ if not list(frame.local_attr_ancestors(node.name)):
+ for ancestor in frame.ancestors():
+ if (
+ ancestor.name == "Enum"
+ and ancestor.root().name == "enum"
+ or utils.is_assign_name_annotated_with(node, "Final")
+ ):
+ self._check_name("class_const", node.name, node)
+ break
+ else:
+ self._check_name("class_attribute", node.name, node)
+
+ def _recursive_check_names(self, args, node):
+ """check names in a possibly recursive list <arg>"""
+ for arg in args:
+ if isinstance(arg, astroid.AssignName):
+ self._check_name("argument", arg.name, node)
+ else:
+ self._recursive_check_names(arg.elts, node)
+
+ def _find_name_group(self, node_type):
+ return self._name_group.get(node_type, node_type)
+
+ def _raise_name_warning(
+ self, node, node_type, name, confidence, warning="invalid-name"
+ ):
+ type_label = HUMAN_READABLE_TYPES[node_type]
+ hint = self._name_hints[node_type]
+ if self.config.include_naming_hint:
+ hint += " (%r pattern)" % self._name_regexps[node_type].pattern
+ args = (
+ (type_label.capitalize(), name, hint)
+ if warning == "invalid-name"
+ else (type_label.capitalize(), name)
+ )
+
+ self.add_message(warning, node=node, args=args, confidence=confidence)
+ self.stats["badname_" + node_type] += 1
+
+ def _name_allowed_by_regex(self, name: str) -> bool:
+ return name in self.config.good_names or any(
+ pattern.match(name) for pattern in self._good_names_rgxs_compiled
+ )
+
+ def _name_disallowed_by_regex(self, name: str) -> bool:
+ return name in self.config.bad_names or any(
+ pattern.match(name) for pattern in self._bad_names_rgxs_compiled
+ )
+
+ def _check_name(self, node_type, name, node, confidence=interfaces.HIGH):
+ """check for a name using the type's regexp"""
+ non_ascii_match = self._non_ascii_rgx_compiled.match(name)
+ if non_ascii_match is not None:
+ self._raise_name_warning(
+ node, node_type, name, confidence, warning="non-ascii-name"
+ )
+
+ def _should_exempt_from_invalid_name(node):
+ if node_type == "variable":
+ inferred = utils.safe_infer(node)
+ if isinstance(inferred, astroid.ClassDef):
+ return True
+ return False
+
+ if self._name_allowed_by_regex(name=name):
+ return
+ if self._name_disallowed_by_regex(name=name):
+ self.stats["badname_" + node_type] += 1
+ self.add_message("disallowed-name", node=node, args=name)
+ return
+ regexp = self._name_regexps[node_type]
+ match = regexp.match(name)
+
+ if _is_multi_naming_match(match, node_type, confidence):
+ name_group = self._find_name_group(node_type)
+ bad_name_group = self._bad_names.setdefault(name_group, {})
+ warnings = bad_name_group.setdefault(match.lastgroup, [])
+ warnings.append((node, node_type, name, confidence))
+
+ if match is None and not _should_exempt_from_invalid_name(node):
+ self._raise_name_warning(node, node_type, name, confidence)
+
+ def _check_assign_to_new_keyword_violation(self, name, node):
+ keyword_first_version = self._name_became_keyword_in_version(
+ name, self.KEYWORD_ONSET
+ )
+ if keyword_first_version is not None:
+ self.add_message(
+ "assign-to-new-keyword",
+ node=node,
+ args=(name, keyword_first_version),
+ confidence=interfaces.HIGH,
+ )
+
+ @staticmethod
+ def _name_became_keyword_in_version(name, rules):
+ for version, keywords in rules.items():
+ if name in keywords and sys.version_info < version:
+ return ".".join(str(v) for v in version)
+ return None
+
+
+class DocStringChecker(_BasicChecker):
+ msgs = {
+ "C0112": (
+ "Empty %s docstring",
+ "empty-docstring",
+ "Used when a module, function, class or method has an empty "
+ "docstring (it would be too easy ;).",
+ {"old_names": [("W0132", "old-empty-docstring")]},
+ ),
+ "C0114": (
+ "Missing module docstring",
+ "missing-module-docstring",
+ "Used when a module has no docstring."
+ "Empty modules do not require a docstring.",
+ {"old_names": [("C0111", "missing-docstring")]},
+ ),
+ "C0115": (
+ "Missing class docstring",
+ "missing-class-docstring",
+ "Used when a class has no docstring."
+ "Even an empty class must have a docstring.",
+ {"old_names": [("C0111", "missing-docstring")]},
+ ),
+ "C0116": (
+ "Missing function or method docstring",
+ "missing-function-docstring",
+ "Used when a function or method has no docstring."
+ "Some special methods like __init__ do not require a "
+ "docstring.",
+ {"old_names": [("C0111", "missing-docstring")]},
+ ),
+ }
+ options = (
+ (
+ "no-docstring-rgx",
+ {
+ "default": NO_REQUIRED_DOC_RGX,
+ "type": "regexp",
+ "metavar": "<regexp>",
+ "help": "Regular expression which should only match "
+ "function or class names that do not require a "
+ "docstring.",
+ },
+ ),
+ (
+ "docstring-min-length",
+ {
+ "default": -1,
+ "type": "int",
+ "metavar": "<int>",
+ "help": (
+ "Minimum line length for functions/classes that"
+ " require docstrings, shorter ones are exempt."
+ ),
+ },
+ ),
+ )
+
+ def open(self):
+ self.stats = self.linter.add_stats(
+ undocumented_module=0,
+ undocumented_function=0,
+ undocumented_method=0,
+ undocumented_class=0,
+ )
+
+ @utils.check_messages("missing-docstring", "empty-docstring")
+ def visit_module(self, node):
+ self._check_docstring("module", node)
+
+ @utils.check_messages("missing-docstring", "empty-docstring")
+ def visit_classdef(self, node):
+ if self.config.no_docstring_rgx.match(node.name) is None:
+ self._check_docstring("class", node)
+
+ @utils.check_messages("missing-docstring", "empty-docstring")
+ def visit_functiondef(self, node):
+ if self.config.no_docstring_rgx.match(node.name) is None:
+ ftype = "method" if node.is_method() else "function"
+ if (
+ is_property_setter(node)
+ or is_property_deleter(node)
+ or is_overload_stub(node)
+ ):
+ return
+
+ if isinstance(node.parent.frame(), astroid.ClassDef):
+ overridden = False
+ confidence = (
+ interfaces.INFERENCE
+ if utils.has_known_bases(node.parent.frame())
+ else interfaces.INFERENCE_FAILURE
+ )
+ # check if node is from a method overridden by its ancestor
+ for ancestor in node.parent.frame().ancestors():
+ if node.name in ancestor and isinstance(
+ ancestor[node.name], astroid.FunctionDef
+ ):
+ overridden = True
+ break
+ self._check_docstring(
+ ftype, node, report_missing=not overridden, confidence=confidence
+ )
+ elif isinstance(node.parent.frame(), astroid.Module):
+ self._check_docstring(ftype, node)
+ else:
+ return
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ def _check_docstring(
+ self, node_type, node, report_missing=True, confidence=interfaces.HIGH
+ ):
+ """check the node has a non empty docstring"""
+ docstring = node.doc
+ if docstring is None:
+ docstring = _infer_dunder_doc_attribute(node)
+
+ if docstring is None:
+ if not report_missing:
+ return
+ lines = utils.get_node_last_lineno(node) - node.lineno
+
+ if node_type == "module" and not lines:
+ # If the module has no body, there's no reason
+ # to require a docstring.
+ return
+ max_lines = self.config.docstring_min_length
+
+ if node_type != "module" and max_lines > -1 and lines < max_lines:
+ return
+ self.stats["undocumented_" + node_type] += 1
+ if (
+ node.body
+ and isinstance(node.body[0], astroid.Expr)
+ and isinstance(node.body[0].value, astroid.Call)
+ ):
+ # Most likely a string with a format call. Let's see.
+ func = utils.safe_infer(node.body[0].value.func)
+ if isinstance(func, astroid.BoundMethod) and isinstance(
+ func.bound, astroid.Instance
+ ):
+ # Strings.
+ if func.bound.name in ("str", "unicode", "bytes"):
+ return
+ if node_type == "module":
+ message = "missing-module-docstring"
+ elif node_type == "class":
+ message = "missing-class-docstring"
+ else:
+ message = "missing-function-docstring"
+ self.add_message(message, node=node, confidence=confidence)
+ elif not docstring.strip():
+ self.stats["undocumented_" + node_type] += 1
+ self.add_message(
+ "empty-docstring", node=node, args=(node_type,), confidence=confidence
+ )
+
+
+class PassChecker(_BasicChecker):
+ """check if the pass statement is really necessary"""
+
+ msgs = {
+ "W0107": (
+ "Unnecessary pass statement",
+ "unnecessary-pass",
+ 'Used when a "pass" statement that can be avoided is encountered.',
+ )
+ }
+
+ @utils.check_messages("unnecessary-pass")
+ def visit_pass(self, node):
+ if len(node.parent.child_sequence(node)) > 1 or (
+ isinstance(node.parent, (astroid.ClassDef, astroid.FunctionDef))
+ and (node.parent.doc is not None)
+ ):
+ self.add_message("unnecessary-pass", node=node)
+
+
+def _is_one_arg_pos_call(call):
+ """Is this a call with exactly 1 argument,
+ where that argument is positional?
+ """
+ return isinstance(call, astroid.Call) and len(call.args) == 1 and not call.keywords
+
+
+def _infer_dunder_doc_attribute(node):
+ # Try to see if we have a `__doc__` attribute.
+ try:
+ docstring = node["__doc__"]
+ except KeyError:
+ return None
+
+ docstring = utils.safe_infer(docstring)
+ if not docstring:
+ return None
+ if not isinstance(docstring, astroid.Const):
+ return None
+ return docstring.value
+
+
+class ComparisonChecker(_BasicChecker):
+ """Checks for comparisons
+
+ - singleton comparison: 'expr == True', 'expr == False' and 'expr == None'
+ - yoda condition: 'const "comp" right' where comp can be '==', '!=', '<',
+ '<=', '>' or '>=', and right can be a variable, an attribute, a method or
+ a function
+ """
+
+ msgs = {
+ "C0121": (
+ "Comparison %s should be %s",
+ "singleton-comparison",
+ "Used when an expression is compared to singleton "
+ "values like True, False or None.",
+ ),
+ "C0122": (
+ "Comparison should be %s",
+ "misplaced-comparison-constant",
+ "Used when the constant is placed on the left side "
+ "of a comparison. It is usually clearer in intent to "
+ "place it in the right hand side of the comparison.",
+ ),
+ "C0123": (
+ "Use isinstance() rather than type() for a typecheck.",
+ "unidiomatic-typecheck",
+ "The idiomatic way to perform an explicit typecheck in "
+ "Python is to use isinstance(x, Y) rather than "
+ "type(x) == Y, type(x) is Y. Though there are unusual "
+ "situations where these give different results.",
+ {"old_names": [("W0154", "old-unidiomatic-typecheck")]},
+ ),
+ "R0123": (
+ "Comparison to literal",
+ "literal-comparison",
+ "Used when comparing an object to a literal, which is usually "
+ "what you do not want to do, since you can compare to a different "
+ "literal than what was expected altogether.",
+ ),
+ "R0124": (
+ "Redundant comparison - %s",
+ "comparison-with-itself",
+ "Used when something is compared against itself.",
+ ),
+ "W0143": (
+ "Comparing against a callable, did you omit the parenthesis?",
+ "comparison-with-callable",
+ "This message is emitted when pylint detects that a comparison with a "
+ "callable was made, which might suggest that some parenthesis were omitted, "
+ "resulting in potential unwanted behaviour.",
+ ),
+ "W0177": (
+ "Comparison %s should be %s",
+ "nan-comparison",
+ "Used when an expression is compared to NaN"
+ "values like numpy.NaN and float('nan')",
+ ),
+ }
+
+ def _check_singleton_comparison(
+ self, left_value, right_value, root_node, checking_for_absence: bool = False
+ ):
+ """Check if == or != is being used to compare a singleton value"""
+ singleton_values = (True, False, None)
+
+ def _is_singleton_const(node) -> bool:
+ return isinstance(node, astroid.Const) and any(
+ node.value is value for value in singleton_values
+ )
+
+ if _is_singleton_const(left_value):
+ singleton, other_value = left_value.value, right_value
+ elif _is_singleton_const(right_value):
+ singleton, other_value = right_value.value, left_value
+ else:
+ return
+
+ singleton_comparison_example = {False: "'{} is {}'", True: "'{} is not {}'"}
+
+ # True/False singletons have a special-cased message in case the user is
+ # mistakenly using == or != to check for truthiness
+ if singleton in (True, False):
+ suggestion_template = (
+ "{} if checking for the singleton value {}, or {} if testing for {}"
+ )
+ truthiness_example = {False: "not {}", True: "{}"}
+ truthiness_phrase = {True: "truthiness", False: "falsiness"}
+
+ # Looks for comparisons like x == True or x != False
+ checking_truthiness = singleton is not checking_for_absence
+
+ suggestion = suggestion_template.format(
+ singleton_comparison_example[checking_for_absence].format(
+ left_value.as_string(), right_value.as_string()
+ ),
+ singleton,
+ (
+ "'bool({})'"
+ if not utils.is_test_condition(root_node) and checking_truthiness
+ else "'{}'"
+ ).format(
+ truthiness_example[checking_truthiness].format(
+ other_value.as_string()
+ )
+ ),
+ truthiness_phrase[checking_truthiness],
+ )
+ else:
+ suggestion = singleton_comparison_example[checking_for_absence].format(
+ left_value.as_string(), right_value.as_string()
+ )
+ self.add_message(
+ "singleton-comparison",
+ node=root_node,
+ args=(f"'{root_node.as_string()}'", suggestion),
+ )
+
+ def _check_nan_comparison(
+ self, left_value, right_value, root_node, checking_for_absence: bool = False
+ ):
+ def _is_float_nan(node):
+ try:
+ if isinstance(node, astroid.Call) and len(node.args) == 1:
+ if (
+ node.args[0].value.lower() == "nan"
+ and node.inferred()[0].pytype() == "builtins.float"
+ ):
+ return True
+ return False
+ except AttributeError:
+ return False
+
+ def _is_numpy_nan(node):
+ if isinstance(node, astroid.Attribute) and node.attrname == "NaN":
+ if isinstance(node.expr, astroid.Name):
+ return node.expr.name in ("numpy", "nmp", "np")
+ return False
+
+ def _is_nan(node) -> bool:
+ return _is_float_nan(node) or _is_numpy_nan(node)
+
+ nan_left = _is_nan(left_value)
+ if not nan_left and not _is_nan(right_value):
+ return
+
+ absence_text = ""
+ if checking_for_absence:
+ absence_text = "not "
+ if nan_left:
+ suggestion = f"'{absence_text}math.isnan({right_value.as_string()})'"
+ else:
+ suggestion = f"'{absence_text}math.isnan({left_value.as_string()})'"
+ self.add_message(
+ "nan-comparison",
+ node=root_node,
+ args=(f"'{root_node.as_string()}'", suggestion),
+ )
+
+ def _check_literal_comparison(self, literal, node):
+ """Check if we compare to a literal, which is usually what we do not want to do."""
+ nodes = (astroid.List, astroid.Tuple, astroid.Dict, astroid.Set)
+ is_other_literal = isinstance(literal, nodes)
+ is_const = False
+ if isinstance(literal, astroid.Const):
+ if isinstance(literal.value, bool) or literal.value is None:
+ # Not interested in this values.
+ return
+ is_const = isinstance(literal.value, (bytes, str, int, float))
+
+ if is_const or is_other_literal:
+ self.add_message("literal-comparison", node=node)
+
+ def _check_misplaced_constant(self, node, left, right, operator):
+ if isinstance(right, astroid.Const):
+ return
+ operator = REVERSED_COMPS.get(operator, operator)
+ suggestion = f"{right.as_string()} {operator} {left.value!r}"
+ self.add_message("misplaced-comparison-constant", node=node, args=(suggestion,))
+
+ def _check_logical_tautology(self, node):
+ """Check if identifier is compared against itself.
+ :param node: Compare node
+ :type node: astroid.node_classes.Compare
+ :Example:
+ val = 786
+ if val == val: # [comparison-with-itself]
+ pass
+ """
+ left_operand = node.left
+ right_operand = node.ops[0][1]
+ operator = node.ops[0][0]
+ if isinstance(left_operand, astroid.Const) and isinstance(
+ right_operand, astroid.Const
+ ):
+ left_operand = left_operand.value
+ right_operand = right_operand.value
+ elif isinstance(left_operand, astroid.Name) and isinstance(
+ right_operand, astroid.Name
+ ):
+ left_operand = left_operand.name
+ right_operand = right_operand.name
+
+ if left_operand == right_operand:
+ suggestion = f"{left_operand} {operator} {right_operand}"
+ self.add_message("comparison-with-itself", node=node, args=(suggestion,))
+
+ def _check_callable_comparison(self, node):
+ operator = node.ops[0][0]
+ if operator not in COMPARISON_OPERATORS:
+ return
+
+ bare_callables = (astroid.FunctionDef, astroid.BoundMethod)
+ left_operand, right_operand = node.left, node.ops[0][1]
+ # this message should be emitted only when there is comparison of bare callable
+ # with non bare callable.
+ if (
+ sum(
+ 1
+ for operand in (left_operand, right_operand)
+ if isinstance(utils.safe_infer(operand), bare_callables)
+ )
+ == 1
+ ):
+ self.add_message("comparison-with-callable", node=node)
+
+ @utils.check_messages(
+ "singleton-comparison",
+ "misplaced-comparison-constant",
+ "unidiomatic-typecheck",
+ "literal-comparison",
+ "comparison-with-itself",
+ "comparison-with-callable",
+ )
+ def visit_compare(self, node):
+ self._check_callable_comparison(node)
+ self._check_logical_tautology(node)
+ self._check_unidiomatic_typecheck(node)
+ # NOTE: this checker only works with binary comparisons like 'x == 42'
+ # but not 'x == y == 42'
+ if len(node.ops) != 1:
+ return
+
+ left = node.left
+ operator, right = node.ops[0]
+ if operator in COMPARISON_OPERATORS and isinstance(left, astroid.Const):
+ self._check_misplaced_constant(node, left, right, operator)
+
+ if operator in ("==", "!="):
+ self._check_singleton_comparison(
+ left, right, node, checking_for_absence=operator == "!="
+ )
+
+ if operator in ("==", "!=", "is", "is not"):
+ self._check_nan_comparison(
+ left, right, node, checking_for_absence=operator in ("!=", "is not")
+ )
+ if operator in ("is", "is not"):
+ self._check_literal_comparison(right, node)
+
+ def _check_unidiomatic_typecheck(self, node):
+ operator, right = node.ops[0]
+ if operator in TYPECHECK_COMPARISON_OPERATORS:
+ left = node.left
+ if _is_one_arg_pos_call(left):
+ self._check_type_x_is_y(node, left, operator, right)
+
+ def _check_type_x_is_y(self, node, left, operator, right):
+ """Check for expressions like type(x) == Y."""
+ left_func = utils.safe_infer(left.func)
+ if not (
+ isinstance(left_func, astroid.ClassDef) and left_func.qname() == TYPE_QNAME
+ ):
+ return
+
+ if operator in ("is", "is not") and _is_one_arg_pos_call(right):
+ right_func = utils.safe_infer(right.func)
+ if (
+ isinstance(right_func, astroid.ClassDef)
+ and right_func.qname() == TYPE_QNAME
+ ):
+ # type(x) == type(a)
+ right_arg = utils.safe_infer(right.args[0])
+ if not isinstance(right_arg, LITERAL_NODE_TYPES):
+ # not e.g. type(x) == type([])
+ return
+ self.add_message("unidiomatic-typecheck", node=node)
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(BasicErrorChecker(linter))
+ linter.register_checker(BasicChecker(linter))
+ linter.register_checker(NameChecker(linter))
+ linter.register_checker(DocStringChecker(linter))
+ linter.register_checker(PassChecker(linter))
+ linter.register_checker(ComparisonChecker(linter))
diff --git a/pylint/checkers/base_checker.py b/pylint/checkers/base_checker.py
new file mode 100644
index 0000000..0ef186f
--- /dev/null
+++ b/pylint/checkers/base_checker.py
@@ -0,0 +1,185 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2013 buck@yelp.com <buck@yelp.com>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019 Bruno P. Kinoshita <kinow@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+import functools
+from inspect import cleandoc
+from typing import Any
+
+from pylint.config import OptionsProviderMixIn
+from pylint.constants import _MSG_ORDER, WarningScope
+from pylint.exceptions import InvalidMessageError
+from pylint.interfaces import UNDEFINED, IRawChecker, ITokenChecker, implements
+from pylint.message.message_definition import MessageDefinition
+from pylint.utils import get_rst_section, get_rst_title
+
+
+@functools.total_ordering
+class BaseChecker(OptionsProviderMixIn):
+
+ # checker name (you may reuse an existing one)
+ name: str = ""
+ # options level (0 will be displaying in --help, 1 in --long-help)
+ level = 1
+ # ordered list of options to control the checker behaviour
+ options: Any = ()
+ # messages issued by this checker
+ msgs: Any = {}
+ # reports issued by this checker
+ reports: Any = ()
+ # mark this checker as enabled or not.
+ enabled: bool = True
+
+ def __init__(self, linter=None):
+ """checker instances should have the linter as argument
+
+ :param ILinter linter: is an object implementing ILinter."""
+ if self.name is not None:
+ self.name = self.name.lower()
+ OptionsProviderMixIn.__init__(self)
+ self.linter = linter
+
+ def __gt__(self, other):
+ """Permit to sort a list of Checker by name."""
+ return f"{self.name}{self.msgs}".__gt__(f"{other.name}{other.msgs}")
+
+ def __repr__(self):
+ status = "Checker" if self.enabled else "Disabled checker"
+ msgs = "', '".join(self.msgs.keys())
+ return f"{status} '{self.name}' (responsible for '{msgs}')"
+
+ def __str__(self):
+ """This might be incomplete because multiple class inheriting BaseChecker
+ can have the same name. Cf MessageHandlerMixIn.get_full_documentation()"""
+ return self.get_full_documentation(
+ msgs=self.msgs, options=self.options_and_values(), reports=self.reports
+ )
+
+ def get_full_documentation(self, msgs, options, reports, doc=None, module=None):
+ result = ""
+ checker_title = "%s checker" % (self.name.replace("_", " ").title())
+ if module:
+ # Provide anchor to link against
+ result += ".. _%s:\n\n" % module
+ result += "%s\n" % get_rst_title(checker_title, "~")
+ if module:
+ result += "This checker is provided by ``%s``.\n" % module
+ result += "Verbatim name of the checker is ``%s``.\n\n" % self.name
+ if doc:
+ # Provide anchor to link against
+ result += get_rst_title(f"{checker_title} Documentation", "^")
+ result += "%s\n\n" % cleandoc(doc)
+ # options might be an empty generator and not be False when casted to boolean
+ options = list(options)
+ if options:
+ result += get_rst_title(f"{checker_title} Options", "^")
+ result += "%s\n" % get_rst_section(None, options)
+ if msgs:
+ result += get_rst_title(f"{checker_title} Messages", "^")
+ for msgid, msg in sorted(
+ msgs.items(), key=lambda kv: (_MSG_ORDER.index(kv[0][0]), kv[1])
+ ):
+ msg = self.create_message_definition_from_tuple(msgid, msg)
+ result += "%s\n" % msg.format_help(checkerref=False)
+ result += "\n"
+ if reports:
+ result += get_rst_title(f"{checker_title} Reports", "^")
+ for report in reports:
+ result += ":%s: %s\n" % report[:2]
+ result += "\n"
+ result += "\n"
+ return result
+
+ def add_message(
+ self, msgid, line=None, node=None, args=None, confidence=None, col_offset=None
+ ):
+ if not confidence:
+ confidence = UNDEFINED
+ self.linter.add_message(msgid, line, node, args, confidence, col_offset)
+
+ def check_consistency(self):
+ """Check the consistency of msgid.
+
+ msg ids for a checker should be a string of len 4, where the two first
+ characters are the checker id and the two last the msg id in this
+ checker.
+
+ :raises InvalidMessageError: If the checker id in the messages are not
+ always the same."""
+ checker_id = None
+ existing_ids = []
+ for message in self.messages:
+ if checker_id is not None and checker_id != message.msgid[1:3]:
+ error_msg = "Inconsistent checker part in message id "
+ error_msg += f"'{message.msgid}' (expected 'x{checker_id}xx' "
+ error_msg += f"because we already had {existing_ids})."
+ raise InvalidMessageError(error_msg)
+ checker_id = message.msgid[1:3]
+ existing_ids.append(message.msgid)
+
+ def create_message_definition_from_tuple(self, msgid, msg_tuple):
+ if implements(self, (IRawChecker, ITokenChecker)):
+ default_scope = WarningScope.LINE
+ else:
+ default_scope = WarningScope.NODE
+ options = {}
+ if len(msg_tuple) > 3:
+ (msg, symbol, descr, options) = msg_tuple
+ elif len(msg_tuple) > 2:
+ (msg, symbol, descr) = msg_tuple
+ else:
+ error_msg = """Messages should have a msgid and a symbol. Something like this :
+
+"W1234": (
+ "message",
+ "message-symbol",
+ "Message description with detail.",
+ ...
+),
+"""
+ raise InvalidMessageError(error_msg)
+ options.setdefault("scope", default_scope)
+ return MessageDefinition(self, msgid, msg, descr, symbol, **options)
+
+ @property
+ def messages(self) -> list:
+ return [
+ self.create_message_definition_from_tuple(msgid, msg_tuple)
+ for msgid, msg_tuple in sorted(self.msgs.items())
+ ]
+
+ # dummy methods implementing the IChecker interface
+
+ def get_message_definition(self, msgid):
+ for message_definition in self.messages:
+ if message_definition.msgid == msgid:
+ return message_definition
+ error_msg = f"MessageDefinition for '{msgid}' does not exists. "
+ error_msg += f"Choose from {[m.msgid for m in self.messages]}."
+ raise InvalidMessageError(error_msg)
+
+ def open(self):
+ """called before visiting project (i.e set of modules)"""
+
+ def close(self):
+ """called after visiting project (i.e set of modules)"""
+
+
+class BaseTokenChecker(BaseChecker):
+ """Base class for checkers that want to have access to the token stream."""
+
+ def process_tokens(self, tokens):
+ """Should be overridden by subclasses."""
+ raise NotImplementedError()
diff --git a/pylint/checkers/classes.py b/pylint/checkers/classes.py
new file mode 100644
index 0000000..4d86a6b
--- /dev/null
+++ b/pylint/checkers/classes.py
@@ -0,0 +1,2329 @@
+# Copyright (c) 2006-2016 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2010 Maarten ter Huurne <maarten@treewalker.org>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2014 David Pursehouse <david.pursehouse@gmail.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2016 Anthony Foglia <afoglia@users.noreply.github.com>
+# Copyright (c) 2016 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2016 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2017, 2019-2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018-2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2018-2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Ben Green <benhgreen@icloud.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 mattlbeck <17108752+mattlbeck@users.noreply.github.com>
+# Copyright (c) 2019-2020 craig-sh <craig-sh@users.noreply.github.com>
+# Copyright (c) 2019 Janne Rönkkö <jannero@users.noreply.github.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Grygorii Iermolenko <gyermolenko@gmail.com>
+# Copyright (c) 2019 Andrzej Klajnert <github@aklajnert.pl>
+# Copyright (c) 2019 Pascal Corpet <pcorpet@users.noreply.github.com>
+# Copyright (c) 2020 GergelyKalmar <gergely.kalmar@logikal.jp>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@users.noreply.github.com>
+# Copyright (c) 2021 Konstantina Saketou <56515303+ksaketou@users.noreply.github.com>
+# Copyright (c) 2021 James Sinclair <james@nurfherder.com>
+# Copyright (c) 2021 tiagohonorato <61059243+tiagohonorato@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""classes checker for Python code
+"""
+import collections
+from itertools import chain, zip_longest
+from typing import List, Pattern
+
+import astroid
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import (
+ PYMETHODS,
+ SPECIAL_METHODS_PARAMS,
+ check_messages,
+ class_is_abstract,
+ decorated_with,
+ decorated_with_property,
+ has_known_bases,
+ is_attr_private,
+ is_attr_protected,
+ is_builtin_object,
+ is_comprehension,
+ is_iterable,
+ is_overload_stub,
+ is_property_setter,
+ is_property_setter_or_deleter,
+ is_protocol_class,
+ node_frame_class,
+ overrides_a_method,
+ safe_infer,
+ unimplemented_abstract_methods,
+)
+from pylint.interfaces import IAstroidChecker
+from pylint.utils import get_global_option
+
+NEXT_METHOD = "__next__"
+INVALID_BASE_CLASSES = {"bool", "range", "slice", "memoryview"}
+BUILTIN_DECORATORS = {"builtins.property", "builtins.classmethod"}
+
+# Dealing with useless override detection, with regard
+# to parameters vs arguments
+
+_CallSignature = collections.namedtuple(
+ "_CallSignature", "args kws starred_args starred_kws"
+)
+_ParameterSignature = collections.namedtuple(
+ "_ParameterSignature", "args kwonlyargs varargs kwargs"
+)
+
+
+def _signature_from_call(call):
+ kws = {}
+ args = []
+ starred_kws = []
+ starred_args = []
+ for keyword in call.keywords or []:
+ arg, value = keyword.arg, keyword.value
+ if arg is None and isinstance(value, astroid.Name):
+ # Starred node and we are interested only in names,
+ # otherwise some transformation might occur for the parameter.
+ starred_kws.append(value.name)
+ elif isinstance(value, astroid.Name):
+ kws[arg] = value.name
+ else:
+ kws[arg] = None
+
+ for arg in call.args:
+ if isinstance(arg, astroid.Starred) and isinstance(arg.value, astroid.Name):
+ # Positional variadic and a name, otherwise some transformation
+ # might have occurred.
+ starred_args.append(arg.value.name)
+ elif isinstance(arg, astroid.Name):
+ args.append(arg.name)
+ else:
+ args.append(None)
+
+ return _CallSignature(args, kws, starred_args, starred_kws)
+
+
+def _signature_from_arguments(arguments):
+ kwarg = arguments.kwarg
+ vararg = arguments.vararg
+ args = [
+ arg.name
+ for arg in chain(arguments.posonlyargs, arguments.args)
+ if arg.name != "self"
+ ]
+ kwonlyargs = [arg.name for arg in arguments.kwonlyargs]
+ return _ParameterSignature(args, kwonlyargs, vararg, kwarg)
+
+
+def _definition_equivalent_to_call(definition, call):
+ """Check if a definition signature is equivalent to a call."""
+ if definition.kwargs:
+ same_kw_variadics = definition.kwargs in call.starred_kws
+ else:
+ same_kw_variadics = not call.starred_kws
+ if definition.varargs:
+ same_args_variadics = definition.varargs in call.starred_args
+ else:
+ same_args_variadics = not call.starred_args
+ same_kwonlyargs = all(kw in call.kws for kw in definition.kwonlyargs)
+ same_args = definition.args == call.args
+
+ no_additional_kwarg_arguments = True
+ if call.kws:
+ for keyword in call.kws:
+ is_arg = keyword in call.args
+ is_kwonly = keyword in definition.kwonlyargs
+ if not is_arg and not is_kwonly:
+ # Maybe this argument goes into **kwargs,
+ # or it is an extraneous argument.
+ # In any case, the signature is different than
+ # the call site, which stops our search.
+ no_additional_kwarg_arguments = False
+ break
+
+ return all(
+ (
+ same_args,
+ same_kwonlyargs,
+ same_args_variadics,
+ same_kw_variadics,
+ no_additional_kwarg_arguments,
+ )
+ )
+
+
+# Deal with parameters overridding in two methods.
+
+
+def _positional_parameters(method):
+ positional = method.args.args
+ if method.type in ("classmethod", "method"):
+ positional = positional[1:]
+ return positional
+
+
+def _get_node_type(node, potential_types):
+ """
+ Return the type of the node if it exists in potential_types.
+
+ Args:
+ node (astroid.node): node to get the type of.
+ potential_types (tuple): potential types of the node.
+
+ Returns:
+ type: type of the node or None.
+ """
+ for potential_type in potential_types:
+ if isinstance(node, potential_type):
+ return potential_type
+ return None
+
+
+def _check_arg_equality(node_a, node_b, attr_name):
+ """
+ Check equality of nodes based on the comparison of their attributes named attr_name.
+
+ Args:
+ node_a (astroid.node): first node to compare.
+ node_b (astroid.node): second node to compare.
+ attr_name (str): name of the nodes attribute to use for comparison.
+
+ Returns:
+ bool: True if node_a.attr_name == node_b.attr_name, False otherwise.
+ """
+ return getattr(node_a, attr_name) == getattr(node_b, attr_name)
+
+
+def _has_different_parameters_default_value(original, overridden):
+ """
+ Check if original and overridden methods arguments have different default values
+
+ Return True if one of the overridden arguments has a default
+ value different from the default value of the original argument
+ If one of the method doesn't have argument (.args is None)
+ return False
+ """
+ if original.args is None or overridden.args is None:
+ return False
+
+ all_args = chain(original.args, original.kwonlyargs)
+ original_param_names = [param.name for param in all_args]
+ default_missing = object()
+ for param_name in original_param_names:
+ try:
+ original_default = original.default_value(param_name)
+ except astroid.exceptions.NoDefault:
+ original_default = default_missing
+ try:
+ overridden_default = overridden.default_value(param_name)
+ except astroid.exceptions.NoDefault:
+ overridden_default = default_missing
+
+ default_list = [
+ arg == default_missing for arg in (original_default, overridden_default)
+ ]
+ if any(default_list) and not all(default_list):
+ # Only one arg has no default value
+ return True
+
+ astroid_type_compared_attr = {
+ astroid.Const: "value",
+ astroid.ClassDef: "name",
+ astroid.Tuple: "elts",
+ astroid.List: "elts",
+ astroid.Dict: "items",
+ }
+ handled_types = tuple(
+ astroid_type for astroid_type in astroid_type_compared_attr
+ )
+ original_type = _get_node_type(original_default, handled_types)
+ if original_type:
+ # We handle only astroid types that are inside the dict astroid_type_compared_attr
+ if not isinstance(overridden_default, original_type):
+ # Two args with same name but different types
+ return True
+ if not _check_arg_equality(
+ original_default,
+ overridden_default,
+ astroid_type_compared_attr[original_type],
+ ):
+ # Two args with same type but different values
+ return True
+ return False
+
+
+def _has_different_parameters(
+ original: List[astroid.AssignName],
+ overridden: List[astroid.AssignName],
+ dummy_parameter_regex: Pattern,
+) -> List[str]:
+ result = []
+ zipped = zip_longest(original, overridden)
+ for original_param, overridden_param in zipped:
+ params = (original_param, overridden_param)
+ if not all(params):
+ return ["Number of parameters "]
+
+ # check for the arguments' name
+ names = [param.name for param in params]
+ if any(dummy_parameter_regex.match(name) for name in names):
+ continue
+ if original_param.name != overridden_param.name:
+ result.append(
+ f"Parameter '{original_param.name}' has been renamed "
+ f"to '{overridden_param.name}' in"
+ )
+
+ return result
+
+
+def _different_parameters(
+ original: astroid.FunctionDef,
+ overridden: astroid.FunctionDef,
+ dummy_parameter_regex: Pattern,
+) -> List[str]:
+ """Determine if the two methods have different parameters
+
+ They are considered to have different parameters if:
+
+ * they have different positional parameters, including different names
+
+ * one of the methods is having variadics, while the other is not
+
+ * they have different keyword only parameters.
+
+ """
+ output_messages = []
+ original_parameters = _positional_parameters(original)
+ overridden_parameters = _positional_parameters(overridden)
+
+ # Copy kwonlyargs list so that we don't affect later function linting
+ original_kwonlyargs = original.args.kwonlyargs
+
+ # Allow positional/keyword variadic in overridden to match against any
+ # positional/keyword argument in original.
+ # Keep any arguments that are found seperately in overridden to satisfy
+ # later tests
+ if overridden.args.vararg:
+ overidden_names = [v.name for v in overridden_parameters]
+ original_parameters = [
+ v for v in original_parameters if v.name in overidden_names
+ ]
+
+ if overridden.args.kwarg:
+ overidden_names = [v.name for v in overridden.args.kwonlyargs]
+ original_kwonlyargs = [
+ v for v in original.args.kwonlyargs if v.name in overidden_names
+ ]
+
+ different_positional = _has_different_parameters(
+ original_parameters, overridden_parameters, dummy_parameter_regex
+ )
+ different_kwonly = _has_different_parameters(
+ original_kwonlyargs, overridden.args.kwonlyargs, dummy_parameter_regex
+ )
+ if different_kwonly and different_positional:
+ if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
+ output_messages.append("Number of parameters ")
+ output_messages += different_positional[1:]
+ output_messages += different_kwonly[1:]
+ else:
+ output_messages += different_positional
+ output_messages += different_kwonly
+ else:
+ if different_positional:
+ output_messages += different_positional
+ if different_kwonly:
+ output_messages += different_kwonly
+
+ if original.name in PYMETHODS:
+ # Ignore the difference for special methods. If the parameter
+ # numbers are different, then that is going to be caught by
+ # unexpected-special-method-signature.
+ # If the names are different, it doesn't matter, since they can't
+ # be used as keyword arguments anyway.
+ output_messages.clear()
+
+ # Arguments will only violate LSP if there are variadics in the original
+ # that are then removed from the overridden
+ kwarg_lost = original.args.kwarg and not overridden.args.kwarg
+ vararg_lost = original.args.vararg and not overridden.args.vararg
+
+ if kwarg_lost or vararg_lost:
+ output_messages += ["Variadics removed in"]
+
+ return output_messages
+
+
+def _is_invalid_base_class(cls):
+ return cls.name in INVALID_BASE_CLASSES and is_builtin_object(cls)
+
+
+def _has_data_descriptor(cls, attr):
+ attributes = cls.getattr(attr)
+ for attribute in attributes:
+ try:
+ for inferred in attribute.infer():
+ if isinstance(inferred, astroid.Instance):
+ try:
+ inferred.getattr("__get__")
+ inferred.getattr("__set__")
+ except astroid.NotFoundError:
+ continue
+ else:
+ return True
+ except astroid.InferenceError:
+ # Can't infer, avoid emitting a false positive in this case.
+ return True
+ return False
+
+
+def _called_in_methods(func, klass, methods):
+ """Check if the func was called in any of the given methods,
+ belonging to the *klass*. Returns True if so, False otherwise.
+ """
+ if not isinstance(func, astroid.FunctionDef):
+ return False
+ for method in methods:
+ try:
+ inferred = klass.getattr(method)
+ except astroid.NotFoundError:
+ continue
+ for infer_method in inferred:
+ for call in infer_method.nodes_of_class(astroid.Call):
+ try:
+ bound = next(call.func.infer())
+ except (astroid.InferenceError, StopIteration):
+ continue
+ if not isinstance(bound, astroid.BoundMethod):
+ continue
+ func_obj = bound._proxied
+ if isinstance(func_obj, astroid.UnboundMethod):
+ func_obj = func_obj._proxied
+ if func_obj.name == func.name:
+ return True
+ return False
+
+
+def _is_attribute_property(name, klass):
+ """Check if the given attribute *name* is a property in the given *klass*.
+
+ It will look for `property` calls or for functions
+ with the given name, decorated by `property` or `property`
+ subclasses.
+ Returns ``True`` if the name is a property in the given klass,
+ ``False`` otherwise.
+ """
+
+ try:
+ attributes = klass.getattr(name)
+ except astroid.NotFoundError:
+ return False
+ property_name = f"{astroid.bases.BUILTINS}.property"
+ for attr in attributes:
+ if attr is astroid.Uninferable:
+ continue
+ try:
+ inferred = next(attr.infer())
+ except astroid.InferenceError:
+ continue
+ if isinstance(inferred, astroid.FunctionDef) and decorated_with_property(
+ inferred
+ ):
+ return True
+ if inferred.pytype() != property_name:
+ continue
+
+ cls = node_frame_class(inferred)
+ if cls == klass.declared_metaclass():
+ continue
+ return True
+ return False
+
+
+def _has_bare_super_call(fundef_node):
+ for call in fundef_node.nodes_of_class(astroid.Call):
+ func = call.func
+ if isinstance(func, astroid.Name) and func.name == "super" and not call.args:
+ return True
+ return False
+
+
+def _safe_infer_call_result(node, caller, context=None):
+ """
+ Safely infer the return value of a function.
+
+ Returns None if inference failed or if there is some ambiguity (more than
+ one node has been inferred). Otherwise returns inferred value.
+ """
+ try:
+ inferit = node.infer_call_result(caller, context=context)
+ value = next(inferit)
+ except astroid.InferenceError:
+ return None # inference failed
+ except StopIteration:
+ return None # no values inferred
+ try:
+ next(inferit)
+ return None # there is ambiguity on the inferred node
+ except astroid.InferenceError:
+ return None # there is some kind of ambiguity
+ except StopIteration:
+ return value
+
+
+def _has_same_layout_slots(slots, assigned_value):
+ inferred = next(assigned_value.infer())
+ if isinstance(inferred, astroid.ClassDef):
+ other_slots = inferred.slots()
+ if all(
+ first_slot and second_slot and first_slot.value == second_slot.value
+ for (first_slot, second_slot) in zip_longest(slots, other_slots)
+ ):
+ return True
+ return False
+
+
+MSGS = { # pylint: disable=consider-using-namedtuple-or-dataclass
+ "F0202": (
+ "Unable to check methods signature (%s / %s)",
+ "method-check-failed",
+ "Used when Pylint has been unable to check methods signature "
+ "compatibility for an unexpected reason. Please report this kind "
+ "if you don't make sense of it.",
+ ),
+ "E0202": (
+ "An attribute defined in %s line %s hides this method",
+ "method-hidden",
+ "Used when a class defines a method which is hidden by an "
+ "instance attribute from an ancestor class or set by some "
+ "client code.",
+ ),
+ "E0203": (
+ "Access to member %r before its definition line %s",
+ "access-member-before-definition",
+ "Used when an instance member is accessed before it's actually assigned.",
+ ),
+ "W0201": (
+ "Attribute %r defined outside __init__",
+ "attribute-defined-outside-init",
+ "Used when an instance attribute is defined outside the __init__ method.",
+ ),
+ "W0212": (
+ "Access to a protected member %s of a client class", # E0214
+ "protected-access",
+ "Used when a protected member (i.e. class member with a name "
+ "beginning with an underscore) is access outside the class or a "
+ "descendant of the class where it's defined.",
+ ),
+ "E0211": (
+ "Method has no argument",
+ "no-method-argument",
+ "Used when a method which should have the bound instance as "
+ "first argument has no argument defined.",
+ ),
+ "E0213": (
+ 'Method should have "self" as first argument',
+ "no-self-argument",
+ 'Used when a method has an attribute different the "self" as '
+ "first argument. This is considered as an error since this is "
+ "a so common convention that you shouldn't break it!",
+ ),
+ "C0202": (
+ "Class method %s should have %s as first argument",
+ "bad-classmethod-argument",
+ "Used when a class method has a first argument named differently "
+ "than the value specified in valid-classmethod-first-arg option "
+ '(default to "cls"), recommended to easily differentiate them '
+ "from regular instance methods.",
+ ),
+ "C0203": (
+ "Metaclass method %s should have %s as first argument",
+ "bad-mcs-method-argument",
+ "Used when a metaclass method has a first argument named "
+ "differently than the value specified in valid-classmethod-first"
+ '-arg option (default to "cls"), recommended to easily '
+ "differentiate them from regular instance methods.",
+ ),
+ "C0204": (
+ "Metaclass class method %s should have %s as first argument",
+ "bad-mcs-classmethod-argument",
+ "Used when a metaclass class method has a first argument named "
+ "differently than the value specified in valid-metaclass-"
+ 'classmethod-first-arg option (default to "mcs"), recommended to '
+ "easily differentiate them from regular instance methods.",
+ ),
+ "W0211": (
+ "Static method with %r as first argument",
+ "bad-staticmethod-argument",
+ 'Used when a static method has "self" or a value specified in '
+ "valid-classmethod-first-arg option or "
+ "valid-metaclass-classmethod-first-arg option as first argument.",
+ ),
+ "R0201": (
+ "Method could be a function",
+ "no-self-use",
+ "Used when a method doesn't use its bound instance, and so could "
+ "be written as a function.",
+ ),
+ "W0221": (
+ "%s %s %r method",
+ "arguments-differ",
+ "Used when a method has a different number of arguments than in "
+ "the implemented interface or in an overridden method.",
+ ),
+ "W0222": (
+ "Signature differs from %s %r method",
+ "signature-differs",
+ "Used when a method signature is different than in the "
+ "implemented interface or in an overridden method.",
+ ),
+ "W0223": (
+ "Method %r is abstract in class %r but is not overridden",
+ "abstract-method",
+ "Used when an abstract method (i.e. raise NotImplementedError) is "
+ "not overridden in concrete class.",
+ ),
+ "W0231": (
+ "__init__ method from base class %r is not called",
+ "super-init-not-called",
+ "Used when an ancestor class method has an __init__ method "
+ "which is not called by a derived class.",
+ ),
+ "W0232": (
+ "Class has no __init__ method",
+ "no-init",
+ "Used when a class has no __init__ method, neither its parent classes.",
+ ),
+ "W0233": (
+ "__init__ method from a non direct base class %r is called",
+ "non-parent-init-called",
+ "Used when an __init__ method is called on a class which is not "
+ "in the direct ancestors for the analysed class.",
+ ),
+ "W0235": (
+ "Useless super delegation in method %r",
+ "useless-super-delegation",
+ "Used whenever we can detect that an overridden method is useless, "
+ "relying on super() delegation to do the same thing as another method "
+ "from the MRO.",
+ ),
+ "W0236": (
+ "Method %r was expected to be %r, found it instead as %r",
+ "invalid-overridden-method",
+ "Used when we detect that a method was overridden in a way "
+ "that does not match its base class "
+ "which could result in potential bugs at runtime.",
+ ),
+ "W0237": (
+ "%s %s %r method",
+ "arguments-renamed",
+ "Used when a method parameter has a different name than in "
+ "the implemented interface or in an overridden method.",
+ ),
+ "W0238": (
+ "Unused private member `%s.%s`",
+ "unused-private-member",
+ "Emitted when a private member of a class is defined but not used.",
+ ),
+ "E0236": (
+ "Invalid object %r in __slots__, must contain only non empty strings",
+ "invalid-slots-object",
+ "Used when an invalid (non-string) object occurs in __slots__.",
+ ),
+ "E0237": (
+ "Assigning to attribute %r not defined in class slots",
+ "assigning-non-slot",
+ "Used when assigning to an attribute not defined in the class slots.",
+ ),
+ "E0238": (
+ "Invalid __slots__ object",
+ "invalid-slots",
+ "Used when an invalid __slots__ is found in class. "
+ "Only a string, an iterable or a sequence is permitted.",
+ ),
+ "E0239": (
+ "Inheriting %r, which is not a class.",
+ "inherit-non-class",
+ "Used when a class inherits from something which is not a class.",
+ ),
+ "E0240": (
+ "Inconsistent method resolution order for class %r",
+ "inconsistent-mro",
+ "Used when a class has an inconsistent method resolution order.",
+ ),
+ "E0241": (
+ "Duplicate bases for class %r",
+ "duplicate-bases",
+ "Used when a class has duplicate bases.",
+ ),
+ "E0242": (
+ "Value %r in slots conflicts with class variable",
+ "class-variable-slots-conflict",
+ "Used when a value in __slots__ conflicts with a class variable, property or method.",
+ ),
+ "E0243": (
+ "Invalid __class__ object",
+ "invalid-class-object",
+ "Used when an invalid object is assigned to a __class__ property. "
+ "Only a class is permitted.",
+ ),
+ "R0202": (
+ "Consider using a decorator instead of calling classmethod",
+ "no-classmethod-decorator",
+ "Used when a class method is defined without using the decorator syntax.",
+ ),
+ "R0203": (
+ "Consider using a decorator instead of calling staticmethod",
+ "no-staticmethod-decorator",
+ "Used when a static method is defined without using the decorator syntax.",
+ ),
+ "C0205": (
+ "Class __slots__ should be a non-string iterable",
+ "single-string-used-for-slots",
+ "Used when a class __slots__ is a simple string, rather than an iterable.",
+ ),
+ "R0205": (
+ "Class %r inherits from object, can be safely removed from bases in python3",
+ "useless-object-inheritance",
+ "Used when a class inherit from object, which under python3 is implicit, "
+ "hence can be safely removed from bases.",
+ ),
+ "R0206": (
+ "Cannot have defined parameters for properties",
+ "property-with-parameters",
+ "Used when we detect that a property also has parameters, which are useless, "
+ "given that properties cannot be called with additional arguments.",
+ ),
+}
+
+
+def _scope_default():
+ return collections.defaultdict(list)
+
+
+class ScopeAccessMap:
+ """Store the accessed variables per scope."""
+
+ def __init__(self):
+ self._scopes = collections.defaultdict(_scope_default)
+
+ def set_accessed(self, node):
+ """Set the given node as accessed."""
+
+ frame = node_frame_class(node)
+ if frame is None:
+ # The node does not live in a class.
+ return
+ self._scopes[frame][node.attrname].append(node)
+
+ def accessed(self, scope):
+ """Get the accessed variables for the given scope."""
+ return self._scopes.get(scope, {})
+
+
+class ClassChecker(BaseChecker):
+ """checks for :
+ * methods without self as first argument
+ * overridden methods signature
+ * access only to existent members via self
+ * attributes not defined in the __init__ method
+ * unreachable code
+ """
+
+ __implements__ = (IAstroidChecker,)
+
+ # configuration section name
+ name = "classes"
+ # messages
+ msgs = MSGS
+ priority = -2
+ # configuration options
+ options = (
+ (
+ "defining-attr-methods",
+ {
+ "default": ("__init__", "__new__", "setUp", "__post_init__"),
+ "type": "csv",
+ "metavar": "<method names>",
+ "help": "List of method names used to declare (i.e. assign) \
+instance attributes.",
+ },
+ ),
+ (
+ "valid-classmethod-first-arg",
+ {
+ "default": ("cls",),
+ "type": "csv",
+ "metavar": "<argument names>",
+ "help": "List of valid names for the first argument in \
+a class method.",
+ },
+ ),
+ (
+ "valid-metaclass-classmethod-first-arg",
+ {
+ "default": ("cls",),
+ "type": "csv",
+ "metavar": "<argument names>",
+ "help": "List of valid names for the first argument in \
+a metaclass class method.",
+ },
+ ),
+ (
+ "exclude-protected",
+ {
+ "default": (
+ # namedtuple public API.
+ "_asdict",
+ "_fields",
+ "_replace",
+ "_source",
+ "_make",
+ ),
+ "type": "csv",
+ "metavar": "<protected access exclusions>",
+ "help": (
+ "List of member names, which should be excluded "
+ "from the protected access warning."
+ ),
+ },
+ ),
+ (
+ "check-protected-access-in-special-methods",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Warn about protected attribute access inside special methods",
+ },
+ ),
+ )
+
+ def __init__(self, linter=None):
+ BaseChecker.__init__(self, linter)
+ self._accessed = ScopeAccessMap()
+ self._first_attrs = []
+ self._meth_could_be_func = None
+
+ @astroid.decorators.cachedproperty
+ def _dummy_rgx(self):
+ return get_global_option(self, "dummy-variables-rgx", default=None)
+
+ @astroid.decorators.cachedproperty
+ def _ignore_mixin(self):
+ return get_global_option(self, "ignore-mixin-members", default=True)
+
+ @check_messages(
+ "abstract-method",
+ "no-init",
+ "invalid-slots",
+ "single-string-used-for-slots",
+ "invalid-slots-object",
+ "class-variable-slots-conflict",
+ "inherit-non-class",
+ "useless-object-inheritance",
+ "inconsistent-mro",
+ "duplicate-bases",
+ )
+ def visit_classdef(self, node):
+ """init visit variable _accessed"""
+ self._check_bases_classes(node)
+ # if not an exception or a metaclass
+ if node.type == "class" and has_known_bases(node):
+ try:
+ node.local_attr("__init__")
+ except astroid.NotFoundError:
+ self.add_message("no-init", args=node, node=node)
+ self._check_slots(node)
+ self._check_proper_bases(node)
+ self._check_consistent_mro(node)
+
+ def _check_consistent_mro(self, node):
+ """Detect that a class has a consistent mro or duplicate bases."""
+ try:
+ node.mro()
+ except astroid.InconsistentMroError:
+ self.add_message("inconsistent-mro", args=node.name, node=node)
+ except astroid.DuplicateBasesError:
+ self.add_message("duplicate-bases", args=node.name, node=node)
+ except NotImplementedError:
+ # Old style class, there's no mro so don't do anything.
+ pass
+
+ def _check_proper_bases(self, node):
+ """
+ Detect that a class inherits something which is not
+ a class or a type.
+ """
+ for base in node.bases:
+ ancestor = safe_infer(base)
+ if not ancestor:
+ continue
+ if isinstance(ancestor, astroid.Instance) and ancestor.is_subtype_of(
+ f"{astroid.bases.BUILTINS}.type"
+ ):
+ continue
+
+ if not isinstance(ancestor, astroid.ClassDef) or _is_invalid_base_class(
+ ancestor
+ ):
+ self.add_message("inherit-non-class", args=base.as_string(), node=node)
+
+ if ancestor.name == object.__name__:
+ self.add_message(
+ "useless-object-inheritance", args=node.name, node=node
+ )
+
+ @check_messages("unused-private-member", "attribute-defined-outside-init")
+ def leave_classdef(self, node: astroid.ClassDef) -> None:
+ """close a class node:
+ check that instance attributes are defined in __init__ and check
+ access to existent members
+ """
+ self._check_unused_private_members(node)
+ self._check_attribute_defined_outside_init(node)
+
+ def _check_unused_private_members(self, node: astroid.ClassDef) -> None:
+ # Check for unused private functions
+ for function_def in node.nodes_of_class(astroid.FunctionDef):
+ found = False
+ if not is_attr_private(function_def.name):
+ continue
+ for attribute in node.nodes_of_class(astroid.Attribute):
+ if (
+ attribute.attrname == function_def.name
+ and attribute.scope() != function_def # We ignore recursive calls
+ and attribute.expr.name in ("self", node.name)
+ ):
+ found = True
+ break
+ if not found:
+ self.add_message(
+ "unused-private-member",
+ node=function_def,
+ args=(
+ node.name,
+ f"{function_def.name}({function_def.args.as_string()})",
+ ),
+ )
+
+ # Check for unused private variables
+ for assign_name in node.nodes_of_class(astroid.AssignName):
+ found = False
+ if isinstance(assign_name.parent, astroid.Arguments):
+ continue # Ignore function arguments
+ if not is_attr_private(assign_name.name):
+ continue
+ for child in node.nodes_of_class((astroid.Name, astroid.Attribute)):
+ if (
+ isinstance(child, astroid.Name) and child.name == assign_name.name
+ ) or (
+ isinstance(child, astroid.Attribute)
+ and child.attrname == assign_name.name
+ and child.expr.name in ("cls", node.name)
+ ):
+ found = True
+ break
+ if not found:
+ self.add_message(
+ "unused-private-member",
+ node=assign_name,
+ args=(node.name, assign_name.name),
+ )
+
+ # Check for unused private attributes
+ for assign_attr in node.nodes_of_class(astroid.AssignAttr):
+ found = False
+ if not is_attr_private(assign_attr.attrname):
+ continue
+ for attribute in node.nodes_of_class(astroid.Attribute):
+ if (
+ attribute.attrname == assign_attr.attrname
+ and attribute.expr.name == assign_attr.expr.name
+ ):
+ found = True
+ break
+ if not found:
+ self.add_message(
+ "unused-private-member",
+ node=assign_attr,
+ args=(node.name, assign_attr.attrname),
+ )
+
+ def _check_attribute_defined_outside_init(self, cnode: astroid.ClassDef) -> None:
+ # check access to existent members on non metaclass classes
+ if self._ignore_mixin and cnode.name[-5:].lower() == "mixin":
+ # We are in a mixin class. No need to try to figure out if
+ # something is missing, since it is most likely that it will
+ # miss.
+ return
+
+ accessed = self._accessed.accessed(cnode)
+ if cnode.type != "metaclass":
+ self._check_accessed_members(cnode, accessed)
+ # checks attributes are defined in an allowed method such as __init__
+ if not self.linter.is_message_enabled("attribute-defined-outside-init"):
+ return
+ defining_methods = self.config.defining_attr_methods
+ current_module = cnode.root()
+ for attr, nodes in cnode.instance_attrs.items():
+ # Exclude `__dict__` as it is already defined.
+ if attr == "__dict__":
+ continue
+
+ # Skip nodes which are not in the current module and it may screw up
+ # the output, while it's not worth it
+ nodes = [
+ n
+ for n in nodes
+ if not isinstance(n.statement(), (astroid.Delete, astroid.AugAssign))
+ and n.root() is current_module
+ ]
+ if not nodes:
+ continue # error detected by typechecking
+
+ # Check if any method attr is defined in is a defining method
+ # or if we have the attribute defined in a setter.
+ frames = (node.frame() for node in nodes)
+ if any(
+ frame.name in defining_methods or is_property_setter(frame)
+ for frame in frames
+ ):
+ continue
+
+ # check attribute is defined in a parent's __init__
+ for parent in cnode.instance_attr_ancestors(attr):
+ attr_defined = False
+ # check if any parent method attr is defined in is a defining method
+ for node in parent.instance_attrs[attr]:
+ if node.frame().name in defining_methods:
+ attr_defined = True
+ if attr_defined:
+ # we're done :)
+ break
+ else:
+ # check attribute is defined as a class attribute
+ try:
+ cnode.local_attr(attr)
+ except astroid.NotFoundError:
+ for node in nodes:
+ if node.frame().name not in defining_methods:
+ # If the attribute was set by a call in any
+ # of the defining methods, then don't emit
+ # the warning.
+ if _called_in_methods(
+ node.frame(), cnode, defining_methods
+ ):
+ continue
+ self.add_message(
+ "attribute-defined-outside-init", args=attr, node=node
+ )
+
+ def visit_functiondef(self, node):
+ """check method arguments, overriding"""
+ # ignore actual functions
+ if not node.is_method():
+ return
+
+ self._check_useless_super_delegation(node)
+ self._check_property_with_parameters(node)
+
+ klass = node.parent.frame()
+ self._meth_could_be_func = True
+ # check first argument is self if this is actually a method
+ self._check_first_arg_for_type(node, klass.type == "metaclass")
+ if node.name == "__init__":
+ self._check_init(node)
+ return
+ # check signature if the method overloads inherited method
+ for overridden in klass.local_attr_ancestors(node.name):
+ # get astroid for the searched method
+ try:
+ parent_function = overridden[node.name]
+ except KeyError:
+ # we have found the method but it's not in the local
+ # dictionary.
+ # This may happen with astroid build from living objects
+ continue
+ if not isinstance(parent_function, astroid.FunctionDef):
+ continue
+ self._check_signature(node, parent_function, "overridden", klass)
+ self._check_invalid_overridden_method(node, parent_function)
+ break
+
+ if node.decorators:
+ for decorator in node.decorators.nodes:
+ if isinstance(decorator, astroid.Attribute) and decorator.attrname in (
+ "getter",
+ "setter",
+ "deleter",
+ ):
+ # attribute affectation will call this method, not hiding it
+ return
+ if isinstance(decorator, astroid.Name):
+ if decorator.name == "property":
+ # attribute affectation will either call a setter or raise
+ # an attribute error, anyway not hiding the function
+ return
+
+ # Infer the decorator and see if it returns something useful
+ inferred = safe_infer(decorator)
+ if not inferred:
+ return
+ if isinstance(inferred, astroid.FunctionDef):
+ # Okay, it's a decorator, let's see what it can infer.
+ try:
+ inferred = next(inferred.infer_call_result(inferred))
+ except astroid.InferenceError:
+ return
+ try:
+ if (
+ isinstance(inferred, (astroid.Instance, astroid.ClassDef))
+ and inferred.getattr("__get__")
+ and inferred.getattr("__set__")
+ ):
+ return
+ except astroid.AttributeInferenceError:
+ pass
+
+ # check if the method is hidden by an attribute
+ try:
+ overridden = klass.instance_attr(node.name)[0]
+ overridden_frame = overridden.frame()
+ if (
+ isinstance(overridden_frame, astroid.FunctionDef)
+ and overridden_frame.type == "method"
+ ):
+ overridden_frame = overridden_frame.parent.frame()
+ if not (
+ isinstance(overridden_frame, astroid.ClassDef)
+ and klass.is_subtype_of(overridden_frame.qname())
+ ):
+ return
+
+ # If a subclass defined the method then it's not our fault.
+ for ancestor in klass.ancestors():
+ if node.name in ancestor.instance_attrs and is_attr_private(node.name):
+ return
+ for obj in ancestor.lookup(node.name)[1]:
+ if isinstance(obj, astroid.FunctionDef):
+ return
+ args = (overridden.root().name, overridden.fromlineno)
+ self.add_message("method-hidden", args=args, node=node)
+ except astroid.NotFoundError:
+ pass
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ def _check_useless_super_delegation(self, function):
+ """Check if the given function node is an useless method override
+
+ We consider it *useless* if it uses the super() builtin, but having
+ nothing additional whatsoever than not implementing the method at all.
+ If the method uses super() to delegate an operation to the rest of the MRO,
+ and if the method called is the same as the current one, the arguments
+ passed to super() are the same as the parameters that were passed to
+ this method, then the method could be removed altogether, by letting
+ other implementation to take precedence.
+ """
+
+ if (
+ not function.is_method()
+ # With decorators is a change of use
+ or function.decorators
+ ):
+ return
+
+ body = function.body
+ if len(body) != 1:
+ # Multiple statements, which means this overridden method
+ # could do multiple things we are not aware of.
+ return
+
+ statement = body[0]
+ if not isinstance(statement, (astroid.Expr, astroid.Return)):
+ # Doing something else than what we are interested into.
+ return
+
+ call = statement.value
+ if (
+ not isinstance(call, astroid.Call)
+ # Not a super() attribute access.
+ or not isinstance(call.func, astroid.Attribute)
+ ):
+ return
+
+ # Should be a super call.
+ try:
+ super_call = next(call.func.expr.infer())
+ except astroid.InferenceError:
+ return
+ else:
+ if not isinstance(super_call, astroid.objects.Super):
+ return
+
+ # The name should be the same.
+ if call.func.attrname != function.name:
+ return
+
+ # Should be a super call with the MRO pointer being the
+ # current class and the type being the current instance.
+ current_scope = function.parent.scope()
+ if (
+ super_call.mro_pointer != current_scope
+ or not isinstance(super_call.type, astroid.Instance)
+ or super_call.type.name != current_scope.name
+ ):
+ return
+
+ # Check values of default args
+ klass = function.parent.frame()
+ meth_node = None
+ for overridden in klass.local_attr_ancestors(function.name):
+ # get astroid for the searched method
+ try:
+ meth_node = overridden[function.name]
+ except KeyError:
+ # we have found the method but it's not in the local
+ # dictionary.
+ # This may happen with astroid build from living objects
+ continue
+ if (
+ not isinstance(meth_node, astroid.FunctionDef)
+ # If the method have an ancestor which is not a
+ # function then it is legitimate to redefine it
+ or _has_different_parameters_default_value(
+ meth_node.args, function.args
+ )
+ ):
+ return
+ break
+
+ # Detect if the parameters are the same as the call's arguments.
+ params = _signature_from_arguments(function.args)
+ args = _signature_from_call(call)
+
+ if meth_node is not None:
+
+ def form_annotations(arguments):
+ annotations = chain(
+ (arguments.posonlyargs_annotations or []), arguments.annotations
+ )
+ return [ann.as_string() for ann in annotations if ann is not None]
+
+ called_annotations = form_annotations(function.args)
+ overridden_annotations = form_annotations(meth_node.args)
+ if called_annotations and overridden_annotations:
+ if called_annotations != overridden_annotations:
+ return
+
+ if _definition_equivalent_to_call(params, args):
+ self.add_message(
+ "useless-super-delegation", node=function, args=(function.name,)
+ )
+
+ def _check_property_with_parameters(self, node):
+ if (
+ node.args.args
+ and len(node.args.args) > 1
+ and decorated_with_property(node)
+ and not is_property_setter(node)
+ ):
+ self.add_message("property-with-parameters", node=node)
+
+ def _check_invalid_overridden_method(self, function_node, parent_function_node):
+ parent_is_property = decorated_with_property(
+ parent_function_node
+ ) or is_property_setter_or_deleter(parent_function_node)
+ current_is_property = decorated_with_property(
+ function_node
+ ) or is_property_setter_or_deleter(function_node)
+ if parent_is_property and not current_is_property:
+ self.add_message(
+ "invalid-overridden-method",
+ args=(function_node.name, "property", function_node.type),
+ node=function_node,
+ )
+ elif not parent_is_property and current_is_property:
+ self.add_message(
+ "invalid-overridden-method",
+ args=(function_node.name, "method", "property"),
+ node=function_node,
+ )
+
+ parent_is_async = isinstance(parent_function_node, astroid.AsyncFunctionDef)
+ current_is_async = isinstance(function_node, astroid.AsyncFunctionDef)
+
+ if parent_is_async and not current_is_async:
+ self.add_message(
+ "invalid-overridden-method",
+ args=(function_node.name, "async", "non-async"),
+ node=function_node,
+ )
+
+ elif not parent_is_async and current_is_async:
+ self.add_message(
+ "invalid-overridden-method",
+ args=(function_node.name, "non-async", "async"),
+ node=function_node,
+ )
+
+ def _check_slots(self, node):
+ if "__slots__" not in node.locals:
+ return
+ for slots in node.igetattr("__slots__"):
+ # check if __slots__ is a valid type
+ if slots is astroid.Uninferable:
+ continue
+ if not is_iterable(slots) and not is_comprehension(slots):
+ self.add_message("invalid-slots", node=node)
+ continue
+
+ if isinstance(slots, astroid.Const):
+ # a string, ignore the following checks
+ self.add_message("single-string-used-for-slots", node=node)
+ continue
+ if not hasattr(slots, "itered"):
+ # we can't obtain the values, maybe a .deque?
+ continue
+
+ if isinstance(slots, astroid.Dict):
+ values = [item[0] for item in slots.items]
+ else:
+ values = slots.itered()
+ if values is astroid.Uninferable:
+ return
+ for elt in values:
+ try:
+ self._check_slots_elt(elt, node)
+ except astroid.InferenceError:
+ continue
+
+ def _check_slots_elt(self, elt, node):
+ for inferred in elt.infer():
+ if inferred is astroid.Uninferable:
+ continue
+ if not isinstance(inferred, astroid.Const) or not isinstance(
+ inferred.value, str
+ ):
+ self.add_message(
+ "invalid-slots-object", args=inferred.as_string(), node=elt
+ )
+ continue
+ if not inferred.value:
+ self.add_message(
+ "invalid-slots-object", args=inferred.as_string(), node=elt
+ )
+
+ # Check if we have a conflict with a class variable.
+ class_variable = node.locals.get(inferred.value)
+ if class_variable:
+ # Skip annotated assignments which don't conflict at all with slots.
+ if len(class_variable) == 1:
+ parent = class_variable[0].parent
+ if isinstance(parent, astroid.AnnAssign) and parent.value is None:
+ return
+ self.add_message(
+ "class-variable-slots-conflict", args=(inferred.value,), node=elt
+ )
+
+ def leave_functiondef(self, node):
+ """on method node, check if this method couldn't be a function
+
+ ignore class, static and abstract methods, initializer,
+ methods overridden from a parent class.
+ """
+ if node.is_method():
+ if node.args.args is not None:
+ self._first_attrs.pop()
+ if not self.linter.is_message_enabled("no-self-use"):
+ return
+ class_node = node.parent.frame()
+ if (
+ self._meth_could_be_func
+ and node.type == "method"
+ and node.name not in PYMETHODS
+ and not (
+ node.is_abstract()
+ or overrides_a_method(class_node, node.name)
+ or decorated_with_property(node)
+ or _has_bare_super_call(node)
+ or is_protocol_class(class_node)
+ or is_overload_stub(node)
+ )
+ ):
+ self.add_message("no-self-use", node=node)
+
+ def visit_attribute(self, node):
+ """check if the getattr is an access to a class member
+ if so, register it. Also check for access to protected
+ class member from outside its class (but ignore __special__
+ methods)
+ """
+ # Check self
+ if self._uses_mandatory_method_param(node):
+ self._accessed.set_accessed(node)
+ return
+ if not self.linter.is_message_enabled("protected-access"):
+ return
+
+ self._check_protected_attribute_access(node)
+
+ @check_messages("assigning-non-slot", "invalid-class-object")
+ def visit_assignattr(self, node: astroid.AssignAttr) -> None:
+ if isinstance(
+ node.assign_type(), astroid.AugAssign
+ ) and self._uses_mandatory_method_param(node):
+ self._accessed.set_accessed(node)
+ self._check_in_slots(node)
+ self._check_invalid_class_object(node)
+
+ def _check_invalid_class_object(self, node: astroid.AssignAttr) -> None:
+ if not node.attrname == "__class__":
+ return
+ inferred = safe_infer(node.parent.value)
+ if isinstance(inferred, astroid.ClassDef) or inferred is astroid.Uninferable:
+ # If is uninferrable, we allow it to prevent false positives
+ return
+ self.add_message("invalid-class-object", node=node)
+
+ def _check_in_slots(self, node):
+ """Check that the given AssignAttr node
+ is defined in the class slots.
+ """
+ inferred = safe_infer(node.expr)
+ if not isinstance(inferred, astroid.Instance):
+ return
+
+ klass = inferred._proxied
+ if not has_known_bases(klass):
+ return
+ if "__slots__" not in klass.locals or not klass.newstyle:
+ return
+
+ # If 'typing.Generic' is a base of bases of klass, the cached version
+ # of 'slots()' might have been evaluated incorrectly, thus deleted cache entry.
+ if any(base.qname() == "typing.Generic" for base in klass.mro()):
+ cache = getattr(klass, "__cache", None)
+ if cache and cache.get(klass.slots) is not None:
+ del cache[klass.slots]
+
+ slots = klass.slots()
+ if slots is None:
+ return
+ # If any ancestor doesn't use slots, the slots
+ # defined for this class are superfluous.
+ if any(
+ "__slots__" not in ancestor.locals and ancestor.name != "object"
+ for ancestor in klass.ancestors()
+ ):
+ return
+
+ if not any(slot.value == node.attrname for slot in slots):
+ # If we have a '__dict__' in slots, then
+ # assigning any name is valid.
+ if not any(slot.value == "__dict__" for slot in slots):
+ if _is_attribute_property(node.attrname, klass):
+ # Properties circumvent the slots mechanism,
+ # so we should not emit a warning for them.
+ return
+ if node.attrname in klass.locals and _has_data_descriptor(
+ klass, node.attrname
+ ):
+ # Descriptors circumvent the slots mechanism as well.
+ return
+ if node.attrname == "__class__" and _has_same_layout_slots(
+ slots, node.parent.value
+ ):
+ return
+ self.add_message("assigning-non-slot", args=(node.attrname,), node=node)
+
+ @check_messages(
+ "protected-access", "no-classmethod-decorator", "no-staticmethod-decorator"
+ )
+ def visit_assign(self, assign_node):
+ self._check_classmethod_declaration(assign_node)
+ node = assign_node.targets[0]
+ if not isinstance(node, astroid.AssignAttr):
+ return
+
+ if self._uses_mandatory_method_param(node):
+ return
+ self._check_protected_attribute_access(node)
+
+ def _check_classmethod_declaration(self, node):
+ """Checks for uses of classmethod() or staticmethod()
+
+ When a @classmethod or @staticmethod decorator should be used instead.
+ A message will be emitted only if the assignment is at a class scope
+ and only if the classmethod's argument belongs to the class where it
+ is defined.
+ `node` is an assign node.
+ """
+ if not isinstance(node.value, astroid.Call):
+ return
+
+ # check the function called is "classmethod" or "staticmethod"
+ func = node.value.func
+ if not isinstance(func, astroid.Name) or func.name not in (
+ "classmethod",
+ "staticmethod",
+ ):
+ return
+
+ msg = (
+ "no-classmethod-decorator"
+ if func.name == "classmethod"
+ else "no-staticmethod-decorator"
+ )
+ # assignment must be at a class scope
+ parent_class = node.scope()
+ if not isinstance(parent_class, astroid.ClassDef):
+ return
+
+ # Check if the arg passed to classmethod is a class member
+ classmeth_arg = node.value.args[0]
+ if not isinstance(classmeth_arg, astroid.Name):
+ return
+
+ method_name = classmeth_arg.name
+ if any(method_name == member.name for member in parent_class.mymethods()):
+ self.add_message(msg, node=node.targets[0])
+
+ def _check_protected_attribute_access(self, node):
+ """Given an attribute access node (set or get), check if attribute
+ access is legitimate. Call _check_first_attr with node before calling
+ this method. Valid cases are:
+ * self._attr in a method or cls._attr in a classmethod. Checked by
+ _check_first_attr.
+ * Klass._attr inside "Klass" class.
+ * Klass2._attr inside "Klass" class when Klass2 is a base class of
+ Klass.
+ """
+ attrname = node.attrname
+
+ if (
+ is_attr_protected(attrname)
+ and attrname not in self.config.exclude_protected
+ ):
+
+ klass = node_frame_class(node)
+
+ # In classes, check we are not getting a parent method
+ # through the class object or through super
+ callee = node.expr.as_string()
+
+ # We are not in a class, no remaining valid case
+ if klass is None:
+ self.add_message("protected-access", node=node, args=attrname)
+ return
+
+ # If the expression begins with a call to super, that's ok.
+ if (
+ isinstance(node.expr, astroid.Call)
+ and isinstance(node.expr.func, astroid.Name)
+ and node.expr.func.name == "super"
+ ):
+ return
+
+ # If the expression begins with a call to type(self), that's ok.
+ if self._is_type_self_call(node.expr):
+ return
+
+ # We are in a class, one remaining valid cases, Klass._attr inside
+ # Klass
+ if not (callee == klass.name or callee in klass.basenames):
+ # Detect property assignments in the body of the class.
+ # This is acceptable:
+ #
+ # class A:
+ # b = property(lambda: self._b)
+
+ stmt = node.parent.statement()
+ if (
+ isinstance(stmt, astroid.Assign)
+ and len(stmt.targets) == 1
+ and isinstance(stmt.targets[0], astroid.AssignName)
+ ):
+ name = stmt.targets[0].name
+ if _is_attribute_property(name, klass):
+ return
+
+ if (
+ self._is_classmethod(node.frame())
+ and self._is_inferred_instance(node.expr, klass)
+ and self._is_class_attribute(attrname, klass)
+ ):
+ return
+
+ licit_protected_member = not attrname.startswith("__")
+ if (
+ not self.config.check_protected_access_in_special_methods
+ and licit_protected_member
+ and self._is_called_inside_special_method(node)
+ ):
+ return
+
+ self.add_message("protected-access", node=node, args=attrname)
+
+ @staticmethod
+ def _is_called_inside_special_method(node: astroid.node_classes.NodeNG) -> bool:
+ """
+ Returns true if the node is located inside a special (aka dunder) method
+ """
+ try:
+ frame_name = node.frame().name
+ except AttributeError:
+ return False
+ return frame_name and frame_name in PYMETHODS
+
+ def _is_type_self_call(self, expr):
+ return (
+ isinstance(expr, astroid.Call)
+ and isinstance(expr.func, astroid.Name)
+ and expr.func.name == "type"
+ and len(expr.args) == 1
+ and self._is_mandatory_method_param(expr.args[0])
+ )
+
+ @staticmethod
+ def _is_classmethod(func):
+ """Check if the given *func* node is a class method."""
+
+ return isinstance(func, astroid.FunctionDef) and (
+ func.type == "classmethod" or func.name == "__class_getitem__"
+ )
+
+ @staticmethod
+ def _is_inferred_instance(expr, klass):
+ """Check if the inferred value of the given *expr* is an instance of *klass*."""
+
+ inferred = safe_infer(expr)
+ if not isinstance(inferred, astroid.Instance):
+ return False
+
+ return inferred._proxied is klass
+
+ @staticmethod
+ def _is_class_attribute(name, klass):
+ """Check if the given attribute *name* is a class or instance member of the given *klass*.
+
+ Returns ``True`` if the name is a property in the given klass,
+ ``False`` otherwise.
+ """
+
+ try:
+ klass.getattr(name)
+ return True
+ except astroid.NotFoundError:
+ pass
+
+ try:
+ klass.instance_attr(name)
+ return True
+ except astroid.NotFoundError:
+ return False
+
+ def visit_name(self, node):
+ """check if the name handle an access to a class member
+ if so, register it
+ """
+ if self._first_attrs and (
+ node.name == self._first_attrs[-1] or not self._first_attrs[-1]
+ ):
+ self._meth_could_be_func = False
+
+ def _check_accessed_members(self, node, accessed):
+ """check that accessed members are defined"""
+ excs = ("AttributeError", "Exception", "BaseException")
+ for attr, nodes in accessed.items():
+ try:
+ # is it a class attribute ?
+ node.local_attr(attr)
+ # yes, stop here
+ continue
+ except astroid.NotFoundError:
+ pass
+ # is it an instance attribute of a parent class ?
+ try:
+ next(node.instance_attr_ancestors(attr))
+ # yes, stop here
+ continue
+ except StopIteration:
+ pass
+ # is it an instance attribute ?
+ try:
+ defstmts = node.instance_attr(attr)
+ except astroid.NotFoundError:
+ pass
+ else:
+ # filter out augment assignment nodes
+ defstmts = [stmt for stmt in defstmts if stmt not in nodes]
+ if not defstmts:
+ # only augment assignment for this node, no-member should be
+ # triggered by the typecheck checker
+ continue
+ # filter defstmts to only pick the first one when there are
+ # several assignments in the same scope
+ scope = defstmts[0].scope()
+ defstmts = [
+ stmt
+ for i, stmt in enumerate(defstmts)
+ if i == 0 or stmt.scope() is not scope
+ ]
+ # if there are still more than one, don't attempt to be smarter
+ # than we can be
+ if len(defstmts) == 1:
+ defstmt = defstmts[0]
+ # check that if the node is accessed in the same method as
+ # it's defined, it's accessed after the initial assignment
+ frame = defstmt.frame()
+ lno = defstmt.fromlineno
+ for _node in nodes:
+ if (
+ _node.frame() is frame
+ and _node.fromlineno < lno
+ and not astroid.are_exclusive(
+ _node.statement(), defstmt, excs
+ )
+ ):
+ self.add_message(
+ "access-member-before-definition",
+ node=_node,
+ args=(attr, lno),
+ )
+
+ def _check_first_arg_for_type(self, node, metaclass=0):
+ """check the name of first argument, expect:
+
+ * 'self' for a regular method
+ * 'cls' for a class method or a metaclass regular method (actually
+ valid-classmethod-first-arg value)
+ * 'mcs' for a metaclass class method (actually
+ valid-metaclass-classmethod-first-arg)
+ * not one of the above for a static method
+ """
+ # don't care about functions with unknown argument (builtins)
+ if node.args.args is None:
+ return
+ if node.args.posonlyargs:
+ first_arg = node.args.posonlyargs[0].name
+ elif node.args.args:
+ first_arg = node.argnames()[0]
+ else:
+ first_arg = None
+ self._first_attrs.append(first_arg)
+ first = self._first_attrs[-1]
+ # static method
+ if node.type == "staticmethod":
+ if (
+ first_arg == "self"
+ or first_arg in self.config.valid_classmethod_first_arg
+ or first_arg in self.config.valid_metaclass_classmethod_first_arg
+ ):
+ self.add_message("bad-staticmethod-argument", args=first, node=node)
+ return
+ self._first_attrs[-1] = None
+ # class / regular method with no args
+ elif not node.args.args and not node.args.posonlyargs:
+ self.add_message("no-method-argument", node=node)
+ # metaclass
+ elif metaclass:
+ # metaclass __new__ or classmethod
+ if node.type == "classmethod":
+ self._check_first_arg_config(
+ first,
+ self.config.valid_metaclass_classmethod_first_arg,
+ node,
+ "bad-mcs-classmethod-argument",
+ node.name,
+ )
+ # metaclass regular method
+ else:
+ self._check_first_arg_config(
+ first,
+ self.config.valid_classmethod_first_arg,
+ node,
+ "bad-mcs-method-argument",
+ node.name,
+ )
+ # regular class
+ else: # pylint: disable=else-if-used
+ # class method
+ if node.type == "classmethod" or node.name == "__class_getitem__":
+ self._check_first_arg_config(
+ first,
+ self.config.valid_classmethod_first_arg,
+ node,
+ "bad-classmethod-argument",
+ node.name,
+ )
+ # regular method without self as argument
+ elif first != "self":
+ self.add_message("no-self-argument", node=node)
+
+ def _check_first_arg_config(self, first, config, node, message, method_name):
+ if first not in config:
+ if len(config) == 1:
+ valid = repr(config[0])
+ else:
+ valid = ", ".join(repr(v) for v in config[:-1])
+ valid = f"{valid} or {config[-1]!r}"
+ self.add_message(message, args=(method_name, valid), node=node)
+
+ def _check_bases_classes(self, node):
+ """check that the given class node implements abstract methods from
+ base classes
+ """
+
+ def is_abstract(method):
+ return method.is_abstract(pass_is_abstract=False)
+
+ # check if this class abstract
+ if class_is_abstract(node):
+ return
+
+ methods = sorted(
+ unimplemented_abstract_methods(node, is_abstract).items(),
+ key=lambda item: item[0],
+ )
+ for name, method in methods:
+ owner = method.parent.frame()
+ if owner is node:
+ continue
+ # owner is not this class, it must be a parent class
+ # check that the ancestor's method is not abstract
+ if name in node.locals:
+ # it is redefined as an attribute or with a descriptor
+ continue
+ self.add_message("abstract-method", node=node, args=(name, owner.name))
+
+ def _check_init(self, node):
+ """check that the __init__ method call super or ancestors'__init__
+ method (unless it is used for type hinting with `typing.overload`)
+ """
+ if not self.linter.is_message_enabled(
+ "super-init-not-called"
+ ) and not self.linter.is_message_enabled("non-parent-init-called"):
+ return
+ klass_node = node.parent.frame()
+ to_call = _ancestors_to_call(klass_node)
+ not_called_yet = dict(to_call)
+ for stmt in node.nodes_of_class(astroid.Call):
+ expr = stmt.func
+ if not isinstance(expr, astroid.Attribute) or expr.attrname != "__init__":
+ continue
+ # skip the test if using super
+ if (
+ isinstance(expr.expr, astroid.Call)
+ and isinstance(expr.expr.func, astroid.Name)
+ and expr.expr.func.name == "super"
+ ):
+ return
+ try:
+ for klass in expr.expr.infer():
+ if klass is astroid.Uninferable:
+ continue
+ # The inferred klass can be super(), which was
+ # assigned to a variable and the `__init__`
+ # was called later.
+ #
+ # base = super()
+ # base.__init__(...)
+
+ if (
+ isinstance(klass, astroid.Instance)
+ and isinstance(klass._proxied, astroid.ClassDef)
+ and is_builtin_object(klass._proxied)
+ and klass._proxied.name == "super"
+ ):
+ return
+ if isinstance(klass, astroid.objects.Super):
+ return
+ try:
+ del not_called_yet[klass]
+ except KeyError:
+ if klass not in to_call:
+ self.add_message(
+ "non-parent-init-called", node=expr, args=klass.name
+ )
+ except astroid.InferenceError:
+ continue
+ for klass, method in not_called_yet.items():
+ if decorated_with(node, ["typing.overload"]):
+ continue
+ cls = node_frame_class(method)
+ if klass.name == "object" or (cls and cls.name == "object"):
+ continue
+ self.add_message("super-init-not-called", args=klass.name, node=node)
+
+ def _check_signature(self, method1, refmethod, class_type, cls):
+ """check that the signature of the two given methods match"""
+ if not (
+ isinstance(method1, astroid.FunctionDef)
+ and isinstance(refmethod, astroid.FunctionDef)
+ ):
+ self.add_message(
+ "method-check-failed", args=(method1, refmethod), node=method1
+ )
+ return
+
+ instance = cls.instantiate_class()
+ method1 = astroid.scoped_nodes.function_to_method(method1, instance)
+ refmethod = astroid.scoped_nodes.function_to_method(refmethod, instance)
+
+ # Don't care about functions with unknown argument (builtins).
+ if method1.args.args is None or refmethod.args.args is None:
+ return
+
+ # Ignore private to class methods.
+ if is_attr_private(method1.name):
+ return
+ # Ignore setters, they have an implicit extra argument,
+ # which shouldn't be taken in consideration.
+ if is_property_setter(method1):
+ return
+
+ arg_differ_output = _different_parameters(
+ refmethod, method1, dummy_parameter_regex=self._dummy_rgx
+ )
+ if len(arg_differ_output) > 0:
+ for msg in arg_differ_output:
+ if "Number" in msg:
+ total_args_method1 = len(method1.args.args)
+ if method1.args.vararg:
+ total_args_method1 += 1
+ if method1.args.kwarg:
+ total_args_method1 += 1
+ if method1.args.kwonlyargs:
+ total_args_method1 += len(method1.args.kwonlyargs)
+ total_args_refmethod = len(refmethod.args.args)
+ if refmethod.args.vararg:
+ total_args_refmethod += 1
+ if refmethod.args.kwarg:
+ total_args_refmethod += 1
+ if refmethod.args.kwonlyargs:
+ total_args_refmethod += len(refmethod.args.kwonlyargs)
+ error_type = "arguments-differ"
+ msg_args = (
+ msg
+ + f"was {total_args_refmethod} in '{refmethod.parent.name}.{refmethod.name}' and "
+ f"is now {total_args_method1} in",
+ class_type,
+ f"{method1.parent.name}.{method1.name}",
+ )
+ elif "renamed" in msg:
+ error_type = "arguments-renamed"
+ msg_args = (
+ msg,
+ class_type,
+ f"{method1.parent.name}.{method1.name}",
+ )
+ else:
+ error_type = "arguments-differ"
+ msg_args = (
+ msg,
+ class_type,
+ f"{method1.parent.name}.{method1.name}",
+ )
+ self.add_message(error_type, args=msg_args, node=method1)
+ elif (
+ len(method1.args.defaults) < len(refmethod.args.defaults)
+ and not method1.args.vararg
+ ):
+ self.add_message(
+ "signature-differs", args=(class_type, method1.name), node=method1
+ )
+
+ def _uses_mandatory_method_param(self, node):
+ """Check that attribute lookup name use first attribute variable name
+
+ Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
+ """
+ return self._is_mandatory_method_param(node.expr)
+
+ def _is_mandatory_method_param(self, node):
+ """Check if astroid.Name corresponds to first attribute variable name
+
+ Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
+ """
+ return (
+ self._first_attrs
+ and isinstance(node, astroid.Name)
+ and node.name == self._first_attrs[-1]
+ )
+
+
+class SpecialMethodsChecker(BaseChecker):
+ """Checker which verifies that special methods
+ are implemented correctly.
+ """
+
+ __implements__ = (IAstroidChecker,)
+ name = "classes"
+ msgs = {
+ "E0301": (
+ "__iter__ returns non-iterator",
+ "non-iterator-returned",
+ "Used when an __iter__ method returns something which is not an "
+ "iterable (i.e. has no `%s` method)" % NEXT_METHOD,
+ {
+ "old_names": [
+ ("W0234", "old-non-iterator-returned-1"),
+ ("E0234", "old-non-iterator-returned-2"),
+ ]
+ },
+ ),
+ "E0302": (
+ "The special method %r expects %s param(s), %d %s given",
+ "unexpected-special-method-signature",
+ "Emitted when a special method was defined with an "
+ "invalid number of parameters. If it has too few or "
+ "too many, it might not work at all.",
+ {"old_names": [("E0235", "bad-context-manager")]},
+ ),
+ "E0303": (
+ "__len__ does not return non-negative integer",
+ "invalid-length-returned",
+ "Used when a __len__ method returns something which is not a "
+ "non-negative integer",
+ ),
+ "E0304": (
+ "__bool__ does not return bool",
+ "invalid-bool-returned",
+ "Used when a __bool__ method returns something which is not a bool",
+ ),
+ "E0305": (
+ "__index__ does not return int",
+ "invalid-index-returned",
+ "Used when an __index__ method returns something which is not "
+ "an integer",
+ ),
+ "E0306": (
+ "__repr__ does not return str",
+ "invalid-repr-returned",
+ "Used when a __repr__ method returns something which is not a string",
+ ),
+ "E0307": (
+ "__str__ does not return str",
+ "invalid-str-returned",
+ "Used when a __str__ method returns something which is not a string",
+ ),
+ "E0308": (
+ "__bytes__ does not return bytes",
+ "invalid-bytes-returned",
+ "Used when a __bytes__ method returns something which is not bytes",
+ ),
+ "E0309": (
+ "__hash__ does not return int",
+ "invalid-hash-returned",
+ "Used when a __hash__ method returns something which is not an integer",
+ ),
+ "E0310": (
+ "__length_hint__ does not return non-negative integer",
+ "invalid-length-hint-returned",
+ "Used when a __length_hint__ method returns something which is not a "
+ "non-negative integer",
+ ),
+ "E0311": (
+ "__format__ does not return str",
+ "invalid-format-returned",
+ "Used when a __format__ method returns something which is not a string",
+ ),
+ "E0312": (
+ "__getnewargs__ does not return a tuple",
+ "invalid-getnewargs-returned",
+ "Used when a __getnewargs__ method returns something which is not "
+ "a tuple",
+ ),
+ "E0313": (
+ "__getnewargs_ex__ does not return a tuple containing (tuple, dict)",
+ "invalid-getnewargs-ex-returned",
+ "Used when a __getnewargs_ex__ method returns something which is not "
+ "of the form tuple(tuple, dict)",
+ ),
+ }
+ priority = -2
+
+ def __init__(self, linter=None):
+ BaseChecker.__init__(self, linter)
+ self._protocol_map = {
+ "__iter__": self._check_iter,
+ "__len__": self._check_len,
+ "__bool__": self._check_bool,
+ "__index__": self._check_index,
+ "__repr__": self._check_repr,
+ "__str__": self._check_str,
+ "__bytes__": self._check_bytes,
+ "__hash__": self._check_hash,
+ "__length_hint__": self._check_length_hint,
+ "__format__": self._check_format,
+ "__getnewargs__": self._check_getnewargs,
+ "__getnewargs_ex__": self._check_getnewargs_ex,
+ }
+
+ @check_messages(
+ "unexpected-special-method-signature",
+ "non-iterator-returned",
+ "invalid-length-returned",
+ "invalid-bool-returned",
+ "invalid-index-returned",
+ "invalid-repr-returned",
+ "invalid-str-returned",
+ "invalid-bytes-returned",
+ "invalid-hash-returned",
+ "invalid-length-hint-returned",
+ "invalid-format-returned",
+ "invalid-getnewargs-returned",
+ "invalid-getnewargs-ex-returned",
+ )
+ def visit_functiondef(self, node):
+ if not node.is_method():
+ return
+
+ inferred = _safe_infer_call_result(node, node)
+ # Only want to check types that we are able to infer
+ if inferred and node.name in self._protocol_map:
+ self._protocol_map[node.name](node, inferred)
+
+ if node.name in PYMETHODS:
+ self._check_unexpected_method_signature(node)
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ def _check_unexpected_method_signature(self, node):
+ expected_params = SPECIAL_METHODS_PARAMS[node.name]
+
+ if expected_params is None:
+ # This can support a variable number of parameters.
+ return
+ if not node.args.args and not node.args.vararg:
+ # Method has no parameter, will be caught
+ # by no-method-argument.
+ return
+
+ if decorated_with(node, [astroid.bases.BUILTINS + ".staticmethod"]):
+ # We expect to not take in consideration self.
+ all_args = node.args.args
+ else:
+ all_args = node.args.args[1:]
+ mandatory = len(all_args) - len(node.args.defaults)
+ optional = len(node.args.defaults)
+ current_params = mandatory + optional
+
+ if isinstance(expected_params, tuple):
+ # The expected number of parameters can be any value from this
+ # tuple, although the user should implement the method
+ # to take all of them in consideration.
+ emit = mandatory not in expected_params
+ expected_params = "between %d or %d" % expected_params
+ else:
+ # If the number of mandatory parameters doesn't
+ # suffice, the expected parameters for this
+ # function will be deduced from the optional
+ # parameters.
+ rest = expected_params - mandatory
+ if rest == 0:
+ emit = False
+ elif rest < 0:
+ emit = True
+ elif rest > 0:
+ emit = not ((optional - rest) >= 0 or node.args.vararg)
+
+ if emit:
+ verb = "was" if current_params <= 1 else "were"
+ self.add_message(
+ "unexpected-special-method-signature",
+ args=(node.name, expected_params, current_params, verb),
+ node=node,
+ )
+
+ @staticmethod
+ def _is_wrapped_type(node, type_):
+ return (
+ isinstance(node, astroid.Instance)
+ and node.name == type_
+ and not isinstance(node, astroid.Const)
+ )
+
+ @staticmethod
+ def _is_int(node):
+ if SpecialMethodsChecker._is_wrapped_type(node, "int"):
+ return True
+
+ return isinstance(node, astroid.Const) and isinstance(node.value, int)
+
+ @staticmethod
+ def _is_str(node):
+ if SpecialMethodsChecker._is_wrapped_type(node, "str"):
+ return True
+
+ return isinstance(node, astroid.Const) and isinstance(node.value, str)
+
+ @staticmethod
+ def _is_bool(node):
+ if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
+ return True
+
+ return isinstance(node, astroid.Const) and isinstance(node.value, bool)
+
+ @staticmethod
+ def _is_bytes(node):
+ if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
+ return True
+
+ return isinstance(node, astroid.Const) and isinstance(node.value, bytes)
+
+ @staticmethod
+ def _is_tuple(node):
+ if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
+ return True
+
+ return isinstance(node, astroid.Const) and isinstance(node.value, tuple)
+
+ @staticmethod
+ def _is_dict(node):
+ if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
+ return True
+
+ return isinstance(node, astroid.Const) and isinstance(node.value, dict)
+
+ @staticmethod
+ def _is_iterator(node):
+ if node is astroid.Uninferable:
+ # Just ignore Uninferable objects.
+ return True
+ if isinstance(node, astroid.bases.Generator):
+ # Generators can be iterated.
+ return True
+
+ if isinstance(node, astroid.Instance):
+ try:
+ node.local_attr(NEXT_METHOD)
+ return True
+ except astroid.NotFoundError:
+ pass
+ elif isinstance(node, astroid.ClassDef):
+ metaclass = node.metaclass()
+ if metaclass and isinstance(metaclass, astroid.ClassDef):
+ try:
+ metaclass.local_attr(NEXT_METHOD)
+ return True
+ except astroid.NotFoundError:
+ pass
+ return False
+
+ def _check_iter(self, node, inferred):
+ if not self._is_iterator(inferred):
+ self.add_message("non-iterator-returned", node=node)
+
+ def _check_len(self, node, inferred):
+ if not self._is_int(inferred):
+ self.add_message("invalid-length-returned", node=node)
+ elif isinstance(inferred, astroid.Const) and inferred.value < 0:
+ self.add_message("invalid-length-returned", node=node)
+
+ def _check_bool(self, node, inferred):
+ if not self._is_bool(inferred):
+ self.add_message("invalid-bool-returned", node=node)
+
+ def _check_index(self, node, inferred):
+ if not self._is_int(inferred):
+ self.add_message("invalid-index-returned", node=node)
+
+ def _check_repr(self, node, inferred):
+ if not self._is_str(inferred):
+ self.add_message("invalid-repr-returned", node=node)
+
+ def _check_str(self, node, inferred):
+ if not self._is_str(inferred):
+ self.add_message("invalid-str-returned", node=node)
+
+ def _check_bytes(self, node, inferred):
+ if not self._is_bytes(inferred):
+ self.add_message("invalid-bytes-returned", node=node)
+
+ def _check_hash(self, node, inferred):
+ if not self._is_int(inferred):
+ self.add_message("invalid-hash-returned", node=node)
+
+ def _check_length_hint(self, node, inferred):
+ if not self._is_int(inferred):
+ self.add_message("invalid-length-hint-returned", node=node)
+ elif isinstance(inferred, astroid.Const) and inferred.value < 0:
+ self.add_message("invalid-length-hint-returned", node=node)
+
+ def _check_format(self, node, inferred):
+ if not self._is_str(inferred):
+ self.add_message("invalid-format-returned", node=node)
+
+ def _check_getnewargs(self, node, inferred):
+ if not self._is_tuple(inferred):
+ self.add_message("invalid-getnewargs-returned", node=node)
+
+ def _check_getnewargs_ex(self, node, inferred):
+ if not self._is_tuple(inferred):
+ self.add_message("invalid-getnewargs-ex-returned", node=node)
+ return
+
+ if not isinstance(inferred, astroid.Tuple):
+ # If it's not an astroid.Tuple we can't analyze it further
+ return
+
+ found_error = False
+
+ if len(inferred.elts) != 2:
+ found_error = True
+ else:
+ for arg, check in (
+ (inferred.elts[0], self._is_tuple),
+ (inferred.elts[1], self._is_dict),
+ ):
+
+ if isinstance(arg, astroid.Call):
+ arg = safe_infer(arg)
+
+ if arg and arg is not astroid.Uninferable:
+ if not check(arg):
+ found_error = True
+ break
+
+ if found_error:
+ self.add_message("invalid-getnewargs-ex-returned", node=node)
+
+
+def _ancestors_to_call(klass_node, method="__init__"):
+ """return a dictionary where keys are the list of base classes providing
+ the queried method, and so that should/may be called from the method node
+ """
+ to_call = {}
+ for base_node in klass_node.ancestors(recurs=False):
+ try:
+ to_call[base_node] = next(base_node.igetattr(method))
+ except astroid.InferenceError:
+ continue
+ return to_call
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(ClassChecker(linter))
+ linter.register_checker(SpecialMethodsChecker(linter))
diff --git a/pylint/checkers/deprecated.py b/pylint/checkers/deprecated.py
new file mode 100644
index 0000000..ce1563a
--- /dev/null
+++ b/pylint/checkers/deprecated.py
@@ -0,0 +1,237 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Checker mixin for deprecated functionality."""
+from itertools import chain
+from typing import Any, Container, Iterable, Tuple, Union
+
+import astroid
+
+from pylint.checkers import utils
+from pylint.checkers.utils import safe_infer
+
+ACCEPTABLE_NODES = (
+ astroid.BoundMethod,
+ astroid.UnboundMethod,
+ astroid.FunctionDef,
+ astroid.ClassDef,
+)
+
+
+class DeprecatedMixin:
+ """A mixin implementing logic for checking deprecated symbols.
+ A class implementing mixin must define "deprecated-method" Message.
+ """
+
+ msgs: Any = {
+ "W1505": (
+ "Using deprecated method %s()",
+ "deprecated-method",
+ "The method is marked as deprecated and will be removed in the future.",
+ ),
+ "W1511": (
+ "Using deprecated argument %s of method %s()",
+ "deprecated-argument",
+ "The argument is marked as deprecated and will be removed in the future.",
+ ),
+ "W0402": (
+ "Uses of a deprecated module %r",
+ "deprecated-module",
+ "A module marked as deprecated is imported.",
+ ),
+ "W1512": (
+ "Using deprecated class %s of module %s",
+ "deprecated-class",
+ "The class is marked as deprecated and will be removed in the future.",
+ ),
+ "W1513": (
+ "Using deprecated decorator %s()",
+ "deprecated-decorator",
+ "The decorator is marked as deprecated and will be removed in the future.",
+ ),
+ }
+
+ @utils.check_messages(
+ "deprecated-method",
+ "deprecated-argument",
+ "deprecated-class",
+ )
+ def visit_call(self, node: astroid.Call) -> None:
+ """Called when a :class:`.astroid.node_classes.Call` node is visited."""
+ try:
+ self.check_deprecated_class_in_call(node)
+ for inferred in node.func.infer():
+ # Calling entry point for deprecation check logic.
+ self.check_deprecated_method(node, inferred)
+ except astroid.InferenceError:
+ pass
+
+ @utils.check_messages(
+ "deprecated-module",
+ "deprecated-class",
+ )
+ def visit_import(self, node):
+ """triggered when an import statement is seen"""
+ for name in (name for name, _ in node.names):
+ self.check_deprecated_module(node, name)
+ if "." in name:
+ # Checking deprecation for import module with class
+ mod_name, class_name = name.split(".", 1)
+ self.check_deprecated_class(node, mod_name, (class_name,))
+
+ def deprecated_decorators(self) -> Iterable:
+ """Callback returning the deprecated decorators.
+
+ Returns:
+ collections.abc.Container of deprecated decorator names.
+ """
+ # pylint: disable=no-self-use
+ return ()
+
+ @utils.check_messages("deprecated-decorator")
+ def visit_decorators(self, node):
+ """Triggered when a decorator statement is seen"""
+ children = list(node.get_children())
+ if not children:
+ return
+ if isinstance(children[0], astroid.Call):
+ inf = safe_infer(children[0].func)
+ else:
+ inf = safe_infer(children[0])
+ qname = inf.qname() if inf else None
+ if qname in self.deprecated_decorators():
+ self.add_message("deprecated-decorator", node=node, args=qname)
+
+ @utils.check_messages(
+ "deprecated-module",
+ "deprecated-class",
+ )
+ def visit_importfrom(self, node):
+ """triggered when a from statement is seen"""
+ basename = node.modname
+ self.check_deprecated_module(node, basename)
+ class_names = (name for name, _ in node.names)
+ self.check_deprecated_class(node, basename, class_names)
+
+ def deprecated_methods(self) -> Container[str]:
+ """Callback returning the deprecated methods/functions.
+
+ Returns:
+ collections.abc.Container of deprecated function/method names.
+ """
+ # pylint: disable=no-self-use
+ return ()
+
+ def deprecated_arguments(
+ self, method: str
+ ) -> Iterable[Tuple[Union[int, None], str]]:
+ """Callback returning the deprecated arguments of method/function.
+
+ Args:
+ method (str): name of function/method checked for deprecated arguments
+
+ Returns:
+ collections.abc.Iterable in form:
+ ((POSITION1, PARAM1), (POSITION2: PARAM2) ...)
+ where
+ * POSITIONX - position of deprecated argument PARAMX in function definition.
+ If argument is keyword-only, POSITIONX should be None.
+ * PARAMX - name of the deprecated argument.
+ E.g. suppose function:
+
+ .. code-block:: python
+ def bar(arg1, arg2, arg3, arg4, arg5='spam')
+
+ with deprecated arguments `arg2` and `arg4`. `deprecated_arguments` should return:
+
+ .. code-block:: python
+ ((1, 'arg2'), (3, 'arg4'))
+ """
+ # pylint: disable=no-self-use
+ # pylint: disable=unused-argument
+ return ()
+
+ def deprecated_modules(self) -> Iterable:
+ """Callback returning the deprecated modules.
+
+ Returns:
+ collections.abc.Container of deprecated module names.
+ """
+ # pylint: disable=no-self-use
+ return ()
+
+ def deprecated_classes(self, module: str) -> Iterable:
+ """Callback returning the deprecated classes of module.
+
+ Args:
+ module (str): name of module checked for deprecated classes
+
+ Returns:
+ collections.abc.Container of deprecated class names.
+ """
+ # pylint: disable=no-self-use
+ # pylint: disable=unused-argument
+ return ()
+
+ def check_deprecated_module(self, node, mod_path):
+ """Checks if the module is deprecated"""
+
+ for mod_name in self.deprecated_modules():
+ if mod_path == mod_name or mod_path.startswith(mod_name + "."):
+ self.add_message("deprecated-module", node=node, args=mod_path)
+
+ def check_deprecated_method(self, node, inferred):
+ """Executes the checker for the given node. This method should
+ be called from the checker implementing this mixin.
+ """
+
+ # Reject nodes which aren't of interest to us.
+ if not isinstance(inferred, ACCEPTABLE_NODES):
+ return
+
+ if isinstance(node.func, astroid.Attribute):
+ func_name = node.func.attrname
+ elif isinstance(node.func, astroid.Name):
+ func_name = node.func.name
+ else:
+ # Not interested in other nodes.
+ return
+
+ qname = inferred.qname()
+ if any(name in self.deprecated_methods() for name in (qname, func_name)):
+ self.add_message("deprecated-method", node=node, args=(func_name,))
+ return
+ num_of_args = len(node.args)
+ kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
+ for position, arg_name in chain(
+ self.deprecated_arguments(func_name), self.deprecated_arguments(qname)
+ ):
+ if arg_name in kwargs:
+ # function was called with deprecated argument as keyword argument
+ self.add_message(
+ "deprecated-argument", node=node, args=(arg_name, func_name)
+ )
+ elif position is not None and position < num_of_args:
+ # function was called with deprecated argument as positional argument
+ self.add_message(
+ "deprecated-argument", node=node, args=(arg_name, func_name)
+ )
+
+ def check_deprecated_class(self, node, mod_name, class_names):
+ """Checks if the class is deprecated"""
+
+ for class_name in class_names:
+ if class_name in self.deprecated_classes(mod_name):
+ self.add_message(
+ "deprecated-class", node=node, args=(class_name, mod_name)
+ )
+
+ def check_deprecated_class_in_call(self, node):
+ """Checks if call the deprecated class"""
+
+ if isinstance(node.func, astroid.Attribute) and isinstance(
+ node.func.expr, astroid.Name
+ ):
+ mod_name = node.func.expr.name
+ class_name = node.func.attrname
+ self.check_deprecated_class(node, mod_name, (class_name,))
diff --git a/pylint/checkers/design_analysis.py b/pylint/checkers/design_analysis.py
new file mode 100644
index 0000000..09b28b3
--- /dev/null
+++ b/pylint/checkers/design_analysis.py
@@ -0,0 +1,589 @@
+# Copyright (c) 2006, 2009-2010, 2012-2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012, 2014 Google, Inc.
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 ahirnish <ahirnish@gmail.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Mark Miller <725mrm@gmail.com>
+# Copyright (c) 2018 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Michael Scott Cuthbert <cuthbert@mit.edu>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""check for signs of poor design"""
+
+import re
+from collections import defaultdict
+
+import astroid
+from astroid import nodes
+
+from pylint import utils
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+MSGS = { # pylint: disable=consider-using-namedtuple-or-dataclass
+ "R0901": (
+ "Too many ancestors (%s/%s)",
+ "too-many-ancestors",
+ "Used when class has too many parent classes, try to reduce "
+ "this to get a simpler (and so easier to use) class.",
+ ),
+ "R0902": (
+ "Too many instance attributes (%s/%s)",
+ "too-many-instance-attributes",
+ "Used when class has too many instance attributes, try to reduce "
+ "this to get a simpler (and so easier to use) class.",
+ ),
+ "R0903": (
+ "Too few public methods (%s/%s)",
+ "too-few-public-methods",
+ "Used when class has too few public methods, so be sure it's "
+ "really worth it.",
+ ),
+ "R0904": (
+ "Too many public methods (%s/%s)",
+ "too-many-public-methods",
+ "Used when class has too many public methods, try to reduce "
+ "this to get a simpler (and so easier to use) class.",
+ ),
+ "R0911": (
+ "Too many return statements (%s/%s)",
+ "too-many-return-statements",
+ "Used when a function or method has too many return statement, "
+ "making it hard to follow.",
+ ),
+ "R0912": (
+ "Too many branches (%s/%s)",
+ "too-many-branches",
+ "Used when a function or method has too many branches, "
+ "making it hard to follow.",
+ ),
+ "R0913": (
+ "Too many arguments (%s/%s)",
+ "too-many-arguments",
+ "Used when a function or method takes too many arguments.",
+ ),
+ "R0914": (
+ "Too many local variables (%s/%s)",
+ "too-many-locals",
+ "Used when a function or method has too many local variables.",
+ ),
+ "R0915": (
+ "Too many statements (%s/%s)",
+ "too-many-statements",
+ "Used when a function or method has too many statements. You "
+ "should then split it in smaller functions / methods.",
+ ),
+ "R0916": (
+ "Too many boolean expressions in if statement (%s/%s)",
+ "too-many-boolean-expressions",
+ "Used when an if statement contains too many boolean expressions.",
+ ),
+}
+SPECIAL_OBJ = re.compile("^_{2}[a-z]+_{2}$")
+DATACLASSES_DECORATORS = frozenset({"dataclass", "attrs"})
+DATACLASS_IMPORT = "dataclasses"
+TYPING_NAMEDTUPLE = "typing.NamedTuple"
+TYPING_TYPEDDICT = "typing.TypedDict"
+
+# Set of stdlib classes to ignore when calculating number of ancestors
+STDLIB_CLASSES_IGNORE_ANCESTOR = frozenset(
+ (
+ "builtins.object",
+ "builtins.tuple",
+ "builtins.dict",
+ "builtins.list",
+ "builtins.set",
+ "bulitins.frozenset",
+ "collections.ChainMap",
+ "collections.Counter",
+ "collections.OrderedDict",
+ "collections.UserDict",
+ "collections.UserList",
+ "collections.UserString",
+ "collections.defaultdict",
+ "collections.deque",
+ "collections.namedtuple",
+ "_collections_abc.Awaitable",
+ "_collections_abc.Coroutine",
+ "_collections_abc.AsyncIterable",
+ "_collections_abc.AsyncIterator",
+ "_collections_abc.AsyncGenerator",
+ "_collections_abc.Hashable",
+ "_collections_abc.Iterable",
+ "_collections_abc.Iterator",
+ "_collections_abc.Generator",
+ "_collections_abc.Reversible",
+ "_collections_abc.Sized",
+ "_collections_abc.Container",
+ "_collections_abc.Collection",
+ "_collections_abc.Set",
+ "_collections_abc.MutableSet",
+ "_collections_abc.Mapping",
+ "_collections_abc.MutableMapping",
+ "_collections_abc.MappingView",
+ "_collections_abc.KeysView",
+ "_collections_abc.ItemsView",
+ "_collections_abc.ValuesView",
+ "_collections_abc.Sequence",
+ "_collections_abc.MutableSequence",
+ "_collections_abc.ByteString",
+ "typing.Tuple",
+ "typing.List",
+ "typing.Dict",
+ "typing.Set",
+ "typing.FrozenSet",
+ "typing.Deque",
+ "typing.DefaultDict",
+ "typing.OrderedDict",
+ "typing.Counter",
+ "typing.ChainMap",
+ "typing.Awaitable",
+ "typing.Coroutine",
+ "typing.AsyncIterable",
+ "typing.AsyncIterator",
+ "typing.AsyncGenerator",
+ "typing.Iterable",
+ "typing.Iterator",
+ "typing.Generator",
+ "typing.Reversible",
+ "typing.Container",
+ "typing.Collection",
+ "typing.AbstractSet",
+ "typing.MutableSet",
+ "typing.Mapping",
+ "typing.MutableMapping",
+ "typing.Sequence",
+ "typing.MutableSequence",
+ "typing.ByteString",
+ "typing.MappingView",
+ "typing.KeysView",
+ "typing.ItemsView",
+ "typing.ValuesView",
+ "typing.ContextManager",
+ "typing.AsyncContextManger",
+ "typing.Hashable",
+ "typing.Sized",
+ )
+)
+
+
+def _is_exempt_from_public_methods(node: astroid.ClassDef) -> bool:
+ """Check if a class is exempt from too-few-public-methods"""
+
+ # If it's a typing.Namedtuple, typing.TypedDict or an Enum
+ for ancestor in node.ancestors():
+ if ancestor.name == "Enum" and ancestor.root().name == "enum":
+ return True
+ if ancestor.qname() in (TYPING_NAMEDTUPLE, TYPING_TYPEDDICT):
+ return True
+
+ # Or if it's a dataclass
+ if not node.decorators:
+ return False
+
+ root_locals = set(node.root().locals)
+ for decorator in node.decorators.nodes:
+ if isinstance(decorator, astroid.Call):
+ decorator = decorator.func
+ if not isinstance(decorator, (astroid.Name, astroid.Attribute)):
+ continue
+ if isinstance(decorator, astroid.Name):
+ name = decorator.name
+ else:
+ name = decorator.attrname
+ if name in DATACLASSES_DECORATORS and (
+ root_locals.intersection(DATACLASSES_DECORATORS)
+ or DATACLASS_IMPORT in root_locals
+ ):
+ return True
+ return False
+
+
+def _count_boolean_expressions(bool_op):
+ """Counts the number of boolean expressions in BoolOp `bool_op` (recursive)
+
+ example: a and (b or c or (d and e)) ==> 5 boolean expressions
+ """
+ nb_bool_expr = 0
+ for bool_expr in bool_op.get_children():
+ if isinstance(bool_expr, astroid.BoolOp):
+ nb_bool_expr += _count_boolean_expressions(bool_expr)
+ else:
+ nb_bool_expr += 1
+ return nb_bool_expr
+
+
+def _count_methods_in_class(node):
+ all_methods = sum(1 for method in node.methods() if not method.name.startswith("_"))
+ # Special methods count towards the number of public methods,
+ # but don't count towards there being too many methods.
+ for method in node.mymethods():
+ if SPECIAL_OBJ.search(method.name) and method.name != "__init__":
+ all_methods += 1
+ return all_methods
+
+
+class MisdesignChecker(BaseChecker):
+ """checks for sign of poor/misdesign:
+ * number of methods, attributes, local variables...
+ * size, complexity of functions, methods
+ """
+
+ __implements__ = (IAstroidChecker,)
+
+ # configuration section name
+ name = "design"
+ # messages
+ msgs = MSGS
+ priority = -2
+ # configuration options
+ options = (
+ (
+ "max-args",
+ {
+ "default": 5,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of arguments for function / method.",
+ },
+ ),
+ (
+ "max-locals",
+ {
+ "default": 15,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of locals for function / method body.",
+ },
+ ),
+ (
+ "max-returns",
+ {
+ "default": 6,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of return / yield for function / "
+ "method body.",
+ },
+ ),
+ (
+ "max-branches",
+ {
+ "default": 12,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of branch for function / method body.",
+ },
+ ),
+ (
+ "max-statements",
+ {
+ "default": 50,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of statements in function / method body.",
+ },
+ ),
+ (
+ "max-parents",
+ {
+ "default": 7,
+ "type": "int",
+ "metavar": "<num>",
+ "help": "Maximum number of parents for a class (see R0901).",
+ },
+ ),
+ (
+ "max-attributes",
+ {
+ "default": 7,
+ "type": "int",
+ "metavar": "<num>",
+ "help": "Maximum number of attributes for a class \
+(see R0902).",
+ },
+ ),
+ (
+ "min-public-methods",
+ {
+ "default": 2,
+ "type": "int",
+ "metavar": "<num>",
+ "help": "Minimum number of public methods for a class \
+(see R0903).",
+ },
+ ),
+ (
+ "max-public-methods",
+ {
+ "default": 20,
+ "type": "int",
+ "metavar": "<num>",
+ "help": "Maximum number of public methods for a class \
+(see R0904).",
+ },
+ ),
+ (
+ "max-bool-expr",
+ {
+ "default": 5,
+ "type": "int",
+ "metavar": "<num>",
+ "help": "Maximum number of boolean expressions in an if "
+ "statement (see R0916).",
+ },
+ ),
+ )
+
+ def __init__(self, linter=None):
+ BaseChecker.__init__(self, linter)
+ self.stats = None
+ self._returns = None
+ self._branches = None
+ self._stmts = None
+
+ def open(self):
+ """initialize visit variables"""
+ self.stats = self.linter.add_stats()
+ self._returns = []
+ self._branches = defaultdict(int)
+ self._stmts = []
+
+ def _inc_all_stmts(self, amount):
+ for i, _ in enumerate(self._stmts):
+ self._stmts[i] += amount
+
+ @astroid.decorators.cachedproperty
+ def _ignored_argument_names(self):
+ return utils.get_global_option(self, "ignored-argument-names", default=None)
+
+ @check_messages(
+ "too-many-ancestors",
+ "too-many-instance-attributes",
+ "too-few-public-methods",
+ "too-many-public-methods",
+ )
+ def visit_classdef(self, node: nodes.ClassDef):
+ """check size of inheritance hierarchy and number of instance attributes"""
+ nb_parents = sum(
+ 1
+ for ancestor in node.ancestors()
+ if ancestor.qname() not in STDLIB_CLASSES_IGNORE_ANCESTOR
+ )
+ if nb_parents > self.config.max_parents:
+ self.add_message(
+ "too-many-ancestors",
+ node=node,
+ args=(nb_parents, self.config.max_parents),
+ )
+
+ if len(node.instance_attrs) > self.config.max_attributes:
+ self.add_message(
+ "too-many-instance-attributes",
+ node=node,
+ args=(len(node.instance_attrs), self.config.max_attributes),
+ )
+
+ @check_messages("too-few-public-methods", "too-many-public-methods")
+ def leave_classdef(self, node):
+ """check number of public methods"""
+ my_methods = sum(
+ 1 for method in node.mymethods() if not method.name.startswith("_")
+ )
+
+ # Does the class contain less than n public methods ?
+ # This checks only the methods defined in the current class,
+ # since the user might not have control over the classes
+ # from the ancestors. It avoids some false positives
+ # for classes such as unittest.TestCase, which provides
+ # a lot of assert methods. It doesn't make sense to warn
+ # when the user subclasses TestCase to add his own tests.
+ if my_methods > self.config.max_public_methods:
+ self.add_message(
+ "too-many-public-methods",
+ node=node,
+ args=(my_methods, self.config.max_public_methods),
+ )
+
+ # Stop here for exception, metaclass, interface classes and other
+ # classes for which we don't need to count the methods.
+ if node.type != "class" or _is_exempt_from_public_methods(node):
+ return
+
+ # Does the class contain more than n public methods ?
+ # This checks all the methods defined by ancestors and
+ # by the current class.
+ all_methods = _count_methods_in_class(node)
+ if all_methods < self.config.min_public_methods:
+ self.add_message(
+ "too-few-public-methods",
+ node=node,
+ args=(all_methods, self.config.min_public_methods),
+ )
+
+ @check_messages(
+ "too-many-return-statements",
+ "too-many-branches",
+ "too-many-arguments",
+ "too-many-locals",
+ "too-many-statements",
+ "keyword-arg-before-vararg",
+ )
+ def visit_functiondef(self, node):
+ """check function name, docstring, arguments, redefinition,
+ variable names, max locals
+ """
+ # init branch and returns counters
+ self._returns.append(0)
+ # check number of arguments
+ args = node.args.args
+ ignored_argument_names = self._ignored_argument_names
+ if args is not None:
+ ignored_args_num = 0
+ if ignored_argument_names:
+ ignored_args_num = sum(
+ 1 for arg in args if ignored_argument_names.match(arg.name)
+ )
+
+ argnum = len(args) - ignored_args_num
+ if argnum > self.config.max_args:
+ self.add_message(
+ "too-many-arguments",
+ node=node,
+ args=(len(args), self.config.max_args),
+ )
+ else:
+ ignored_args_num = 0
+ # check number of local variables
+ locnum = len(node.locals) - ignored_args_num
+ if locnum > self.config.max_locals:
+ self.add_message(
+ "too-many-locals", node=node, args=(locnum, self.config.max_locals)
+ )
+ # init new statements counter
+ self._stmts.append(1)
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ @check_messages(
+ "too-many-return-statements",
+ "too-many-branches",
+ "too-many-arguments",
+ "too-many-locals",
+ "too-many-statements",
+ )
+ def leave_functiondef(self, node):
+ """most of the work is done here on close:
+ checks for max returns, branch, return in __init__
+ """
+ returns = self._returns.pop()
+ if returns > self.config.max_returns:
+ self.add_message(
+ "too-many-return-statements",
+ node=node,
+ args=(returns, self.config.max_returns),
+ )
+ branches = self._branches[node]
+ if branches > self.config.max_branches:
+ self.add_message(
+ "too-many-branches",
+ node=node,
+ args=(branches, self.config.max_branches),
+ )
+ # check number of statements
+ stmts = self._stmts.pop()
+ if stmts > self.config.max_statements:
+ self.add_message(
+ "too-many-statements",
+ node=node,
+ args=(stmts, self.config.max_statements),
+ )
+
+ leave_asyncfunctiondef = leave_functiondef
+
+ def visit_return(self, _):
+ """count number of returns"""
+ if not self._returns:
+ return # return outside function, reported by the base checker
+ self._returns[-1] += 1
+
+ def visit_default(self, node):
+ """default visit method -> increments the statements counter if
+ necessary
+ """
+ if node.is_statement:
+ self._inc_all_stmts(1)
+
+ def visit_tryexcept(self, node):
+ """increments the branches counter"""
+ branches = len(node.handlers)
+ if node.orelse:
+ branches += 1
+ self._inc_branch(node, branches)
+ self._inc_all_stmts(branches)
+
+ def visit_tryfinally(self, node):
+ """increments the branches counter"""
+ self._inc_branch(node, 2)
+ self._inc_all_stmts(2)
+
+ @check_messages("too-many-boolean-expressions")
+ def visit_if(self, node):
+ """increments the branches counter and checks boolean expressions"""
+ self._check_boolean_expressions(node)
+ branches = 1
+ # don't double count If nodes coming from some 'elif'
+ if node.orelse and (
+ len(node.orelse) > 1 or not isinstance(node.orelse[0], astroid.If)
+ ):
+ branches += 1
+ self._inc_branch(node, branches)
+ self._inc_all_stmts(branches)
+
+ def _check_boolean_expressions(self, node):
+ """Go through "if" node `node` and counts its boolean expressions
+
+ if the "if" node test is a BoolOp node
+ """
+ condition = node.test
+ if not isinstance(condition, astroid.BoolOp):
+ return
+ nb_bool_expr = _count_boolean_expressions(condition)
+ if nb_bool_expr > self.config.max_bool_expr:
+ self.add_message(
+ "too-many-boolean-expressions",
+ node=condition,
+ args=(nb_bool_expr, self.config.max_bool_expr),
+ )
+
+ def visit_while(self, node):
+ """increments the branches counter"""
+ branches = 1
+ if node.orelse:
+ branches += 1
+ self._inc_branch(node, branches)
+
+ visit_for = visit_while
+
+ def _inc_branch(self, node, branchesnum=1):
+ """increments the branches counter"""
+ self._branches[node.scope()] += branchesnum
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(MisdesignChecker(linter))
diff --git a/pylint/checkers/exceptions.py b/pylint/checkers/exceptions.py
new file mode 100644
index 0000000..41e4204
--- /dev/null
+++ b/pylint/checkers/exceptions.py
@@ -0,0 +1,593 @@
+# Copyright (c) 2006-2011, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2011-2014 Google, Inc.
+# Copyright (c) 2012 Tim Hatch <tim@timhatch.com>
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Rene Zhang <rz99@cornell.edu>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Steven Myint <hg@stevenmyint.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Erik <erik.eriksson@yahoo.com>
+# Copyright (c) 2016 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Martin von Gagern <gagern@google.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Natalie Serebryakova <natalie.serebryakova@Natalies-MacBook-Pro.local>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Carey Metcalfe <carey@cmetcalfe.ca>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Djailla <bastien.vallet@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Ram Rachum <ram@rachum.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Checks for various exception related errors."""
+import builtins
+import inspect
+import typing
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+def _builtin_exceptions():
+ def predicate(obj):
+ return isinstance(obj, type) and issubclass(obj, BaseException)
+
+ members = inspect.getmembers(builtins, predicate)
+ return {exc.__name__ for (_, exc) in members}
+
+
+def _annotated_unpack_infer(stmt, context=None):
+ """
+ Recursively generate nodes inferred by the given statement.
+ If the inferred value is a list or a tuple, recurse on the elements.
+ Returns an iterator which yields tuples in the format
+ ('original node', 'inferred node').
+ """
+ if isinstance(stmt, (astroid.List, astroid.Tuple)):
+ for elt in stmt.elts:
+ inferred = utils.safe_infer(elt)
+ if inferred and inferred is not astroid.Uninferable:
+ yield elt, inferred
+ return
+ for inferred in stmt.infer(context):
+ if inferred is astroid.Uninferable:
+ continue
+ yield stmt, inferred
+
+
+def _is_raising(body: typing.List) -> bool:
+ """Return true if the given statement node raise an exception"""
+ for node in body:
+ if isinstance(node, astroid.Raise):
+ return True
+ return False
+
+
+OVERGENERAL_EXCEPTIONS = ("BaseException", "Exception")
+BUILTINS_NAME = builtins.__name__
+
+MSGS = { # pylint: disable=consider-using-namedtuple-or-dataclass
+ "E0701": (
+ "Bad except clauses order (%s)",
+ "bad-except-order",
+ "Used when except clauses are not in the correct order (from the "
+ "more specific to the more generic). If you don't fix the order, "
+ "some exceptions may not be caught by the most specific handler.",
+ ),
+ "E0702": (
+ "Raising %s while only classes or instances are allowed",
+ "raising-bad-type",
+ "Used when something which is neither a class, an instance or a "
+ "string is raised (i.e. a `TypeError` will be raised).",
+ ),
+ "E0703": (
+ "Exception context set to something which is not an exception, nor None",
+ "bad-exception-context",
+ 'Used when using the syntax "raise ... from ...", '
+ "where the exception context is not an exception, "
+ "nor None.",
+ ),
+ "E0704": (
+ "The raise statement is not inside an except clause",
+ "misplaced-bare-raise",
+ "Used when a bare raise is not used inside an except clause. "
+ "This generates an error, since there are no active exceptions "
+ "to be reraised. An exception to this rule is represented by "
+ "a bare raise inside a finally clause, which might work, as long "
+ "as an exception is raised inside the try block, but it is "
+ "nevertheless a code smell that must not be relied upon.",
+ ),
+ "E0710": (
+ "Raising a new style class which doesn't inherit from BaseException",
+ "raising-non-exception",
+ "Used when a new style class which doesn't inherit from "
+ "BaseException is raised.",
+ ),
+ "E0711": (
+ "NotImplemented raised - should raise NotImplementedError",
+ "notimplemented-raised",
+ "Used when NotImplemented is raised instead of NotImplementedError",
+ ),
+ "E0712": (
+ "Catching an exception which doesn't inherit from Exception: %s",
+ "catching-non-exception",
+ "Used when a class which doesn't inherit from "
+ "Exception is used as an exception in an except clause.",
+ ),
+ "W0702": (
+ "No exception type(s) specified",
+ "bare-except",
+ "Used when an except clause doesn't specify exceptions type to catch.",
+ ),
+ "W0703": (
+ "Catching too general exception %s",
+ "broad-except",
+ "Used when an except catches a too general exception, "
+ "possibly burying unrelated errors.",
+ ),
+ "W0705": (
+ "Catching previously caught exception type %s",
+ "duplicate-except",
+ "Used when an except catches a type that was already caught by "
+ "a previous handler.",
+ ),
+ "W0706": (
+ "The except handler raises immediately",
+ "try-except-raise",
+ "Used when an except handler uses raise as its first or only "
+ "operator. This is useless because it raises back the exception "
+ "immediately. Remove the raise operator or the entire "
+ "try-except-raise block!",
+ ),
+ "W0707": (
+ "Consider explicitly re-raising using the 'from' keyword",
+ "raise-missing-from",
+ "Python 3's exception chaining means it shows the traceback of the "
+ "current exception, but also the original exception. Not using `raise "
+ "from` makes the traceback inaccurate, because the message implies "
+ "there is a bug in the exception-handling code itself, which is a "
+ "separate situation than wrapping an exception.",
+ ),
+ "W0711": (
+ 'Exception to catch is the result of a binary "%s" operation',
+ "binary-op-exception",
+ "Used when the exception to catch is of the form "
+ '"except A or B:". If intending to catch multiple, '
+ 'rewrite as "except (A, B):"',
+ ),
+ "W0715": (
+ "Exception arguments suggest string formatting might be intended",
+ "raising-format-tuple",
+ "Used when passing multiple arguments to an exception "
+ "constructor, the first of them a string literal containing what "
+ "appears to be placeholders intended for formatting",
+ ),
+ "W0716": (
+ "Invalid exception operation. %s",
+ "wrong-exception-operation",
+ "Used when an operation is done against an exception, but the operation "
+ "is not valid for the exception in question. Usually emitted when having "
+ "binary operations between exceptions in except handlers.",
+ ),
+}
+
+
+class BaseVisitor:
+ """Base class for visitors defined in this module."""
+
+ def __init__(self, checker, node):
+ self._checker = checker
+ self._node = node
+
+ def visit(self, node):
+ name = node.__class__.__name__.lower()
+ dispatch_meth = getattr(self, "visit_" + name, None)
+ if dispatch_meth:
+ dispatch_meth(node)
+ else:
+ self.visit_default(node)
+
+ def visit_default(self, node): # pylint: disable=unused-argument
+ """Default implementation for all the nodes."""
+
+
+class ExceptionRaiseRefVisitor(BaseVisitor):
+ """Visit references (anything that is not an AST leaf)."""
+
+ def visit_name(self, name):
+ if name.name == "NotImplemented":
+ self._checker.add_message("notimplemented-raised", node=self._node)
+
+ def visit_call(self, call):
+ if isinstance(call.func, astroid.Name):
+ self.visit_name(call.func)
+ if (
+ len(call.args) > 1
+ and isinstance(call.args[0], astroid.Const)
+ and isinstance(call.args[0].value, str)
+ ):
+ msg = call.args[0].value
+ if "%" in msg or ("{" in msg and "}" in msg):
+ self._checker.add_message("raising-format-tuple", node=self._node)
+
+
+class ExceptionRaiseLeafVisitor(BaseVisitor):
+ """Visitor for handling leaf kinds of a raise value."""
+
+ def visit_const(self, const):
+ if not isinstance(const.value, str):
+ # raising-string will be emitted from python3 porting checker.
+ self._checker.add_message(
+ "raising-bad-type", node=self._node, args=const.value.__class__.__name__
+ )
+
+ def visit_instance(self, instance):
+ # pylint: disable=protected-access
+ cls = instance._proxied
+ self.visit_classdef(cls)
+
+ # Exception instances have a particular class type
+ visit_exceptioninstance = visit_instance
+
+ def visit_classdef(self, cls):
+ if not utils.inherit_from_std_ex(cls) and utils.has_known_bases(cls):
+ if cls.newstyle:
+ self._checker.add_message("raising-non-exception", node=self._node)
+
+ def visit_tuple(self, _):
+ self._checker.add_message("raising-bad-type", node=self._node, args="tuple")
+
+ def visit_default(self, node):
+ name = getattr(node, "name", node.__class__.__name__)
+ self._checker.add_message("raising-bad-type", node=self._node, args=name)
+
+
+class ExceptionsChecker(checkers.BaseChecker):
+ """Exception related checks."""
+
+ __implements__ = interfaces.IAstroidChecker
+
+ name = "exceptions"
+ msgs = MSGS
+ priority = -4
+ options = (
+ (
+ "overgeneral-exceptions",
+ {
+ "default": OVERGENERAL_EXCEPTIONS,
+ "type": "csv",
+ "metavar": "<comma-separated class names>",
+ "help": "Exceptions that will emit a warning "
+ 'when being caught. Defaults to "%s".'
+ % (", ".join(OVERGENERAL_EXCEPTIONS),),
+ },
+ ),
+ )
+
+ def open(self):
+ self._builtin_exceptions = _builtin_exceptions()
+ super().open()
+
+ @utils.check_messages(
+ "misplaced-bare-raise",
+ "raising-bad-type",
+ "raising-non-exception",
+ "notimplemented-raised",
+ "bad-exception-context",
+ "raising-format-tuple",
+ "raise-missing-from",
+ )
+ def visit_raise(self, node):
+ if node.exc is None:
+ self._check_misplaced_bare_raise(node)
+ return
+
+ if node.cause is None:
+ self._check_raise_missing_from(node)
+ else:
+ self._check_bad_exception_context(node)
+
+ expr = node.exc
+ ExceptionRaiseRefVisitor(self, node).visit(expr)
+
+ try:
+ inferred_value = expr.inferred()[-1]
+ except astroid.InferenceError:
+ pass
+ else:
+ if inferred_value:
+ ExceptionRaiseLeafVisitor(self, node).visit(inferred_value)
+
+ def _check_misplaced_bare_raise(self, node):
+ # Filter out if it's present in __exit__.
+ scope = node.scope()
+ if (
+ isinstance(scope, astroid.FunctionDef)
+ and scope.is_method()
+ and scope.name == "__exit__"
+ ):
+ return
+
+ current = node
+ # Stop when a new scope is generated or when the raise
+ # statement is found inside a TryFinally.
+ ignores = (astroid.ExceptHandler, astroid.FunctionDef)
+ while current and not isinstance(current.parent, ignores):
+ current = current.parent
+
+ expected = (astroid.ExceptHandler,)
+ if not current or not isinstance(current.parent, expected):
+ self.add_message("misplaced-bare-raise", node=node)
+
+ def _check_bad_exception_context(self, node: astroid.Raise) -> None:
+ """Verify that the exception context is properly set.
+
+ An exception context can be only `None` or an exception.
+ """
+ cause = utils.safe_infer(node.cause)
+ if cause in (astroid.Uninferable, None):
+ return
+
+ if isinstance(cause, astroid.Const):
+ if cause.value is not None:
+ self.add_message("bad-exception-context", node=node)
+ elif not isinstance(cause, astroid.ClassDef) and not utils.inherit_from_std_ex(
+ cause
+ ):
+ self.add_message("bad-exception-context", node=node)
+
+ def _check_raise_missing_from(self, node: astroid.Raise) -> None:
+ if node.exc is None:
+ # This is a plain `raise`, raising the previously-caught exception. No need for a
+ # cause.
+ return
+ # We'd like to check whether we're inside an `except` clause:
+ containing_except_node = utils.find_except_wrapper_node_in_scope(node)
+ if not containing_except_node:
+ return
+ # We found a surrounding `except`! We're almost done proving there's a
+ # `raise-missing-from` here. The only thing we need to protect against is that maybe
+ # the `raise` is raising the exception that was caught, possibly with some shenanigans
+ # like `exc.with_traceback(whatever)`. We won't analyze these, we'll just assume
+ # there's a violation on two simple cases: `raise SomeException(whatever)` and `raise
+ # SomeException`.
+ if containing_except_node.name is None:
+ # The `except` doesn't have an `as exception:` part, meaning there's no way that
+ # the `raise` is raising the same exception.
+ self.add_message("raise-missing-from", node=node)
+ elif isinstance(node.exc, astroid.Call) and isinstance(
+ node.exc.func, astroid.Name
+ ):
+ # We have a `raise SomeException(whatever)`.
+ self.add_message("raise-missing-from", node=node)
+ elif (
+ isinstance(node.exc, astroid.Name)
+ and node.exc.name != containing_except_node.name.name
+ ):
+ # We have a `raise SomeException`.
+ self.add_message("raise-missing-from", node=node)
+
+ def _check_catching_non_exception(self, handler, exc, part):
+ if isinstance(exc, astroid.Tuple):
+ # Check if it is a tuple of exceptions.
+ inferred = [utils.safe_infer(elt) for elt in exc.elts]
+ if any(node is astroid.Uninferable for node in inferred):
+ # Don't emit if we don't know every component.
+ return
+ if all(
+ node
+ and (utils.inherit_from_std_ex(node) or not utils.has_known_bases(node))
+ for node in inferred
+ ):
+ return
+
+ if not isinstance(exc, astroid.ClassDef):
+ # Don't emit the warning if the inferred stmt
+ # is None, but the exception handler is something else,
+ # maybe it was redefined.
+ if isinstance(exc, astroid.Const) and exc.value is None:
+ if (
+ isinstance(handler.type, astroid.Const)
+ and handler.type.value is None
+ ) or handler.type.parent_of(exc):
+ # If the exception handler catches None or
+ # the exception component, which is None, is
+ # defined by the entire exception handler, then
+ # emit a warning.
+ self.add_message(
+ "catching-non-exception",
+ node=handler.type,
+ args=(part.as_string(),),
+ )
+ else:
+ self.add_message(
+ "catching-non-exception",
+ node=handler.type,
+ args=(part.as_string(),),
+ )
+ return
+
+ if (
+ not utils.inherit_from_std_ex(exc)
+ and exc.name not in self._builtin_exceptions
+ ):
+ if utils.has_known_bases(exc):
+ self.add_message(
+ "catching-non-exception", node=handler.type, args=(exc.name,)
+ )
+
+ def _check_try_except_raise(self, node):
+ def gather_exceptions_from_handler(
+ handler,
+ ) -> typing.Optional[typing.List[astroid.node_classes.NodeNG]]:
+ exceptions: typing.List[astroid.node_classes.NodeNG] = []
+ if handler.type:
+ exceptions_in_handler = utils.safe_infer(handler.type)
+ if isinstance(exceptions_in_handler, astroid.Tuple):
+ exceptions = list(
+ {
+ exception
+ for exception in exceptions_in_handler.elts
+ if isinstance(exception, astroid.Name)
+ }
+ )
+ elif exceptions_in_handler:
+ exceptions = [exceptions_in_handler]
+ else:
+ # Break when we cannot infer anything reliably.
+ return None
+ return exceptions
+
+ bare_raise = False
+ handler_having_bare_raise = None
+ excs_in_bare_handler = []
+ for handler in node.handlers:
+ if bare_raise:
+ # check that subsequent handler is not parent of handler which had bare raise.
+ # since utils.safe_infer can fail for bare except, check it before.
+ # also break early if bare except is followed by bare except.
+
+ excs_in_current_handler = gather_exceptions_from_handler(handler)
+ if not excs_in_current_handler:
+ break
+ if excs_in_bare_handler is None:
+ # It can be `None` when the inference failed
+ break
+ for exc_in_current_handler in excs_in_current_handler:
+ inferred_current = utils.safe_infer(exc_in_current_handler)
+ if any(
+ utils.is_subclass_of(utils.safe_infer(e), inferred_current)
+ for e in excs_in_bare_handler
+ ):
+ bare_raise = False
+ break
+
+ # `raise` as the first operator inside the except handler
+ if _is_raising([handler.body[0]]):
+ # flags when there is a bare raise
+ if handler.body[0].exc is None:
+ bare_raise = True
+ handler_having_bare_raise = handler
+ excs_in_bare_handler = gather_exceptions_from_handler(handler)
+ else:
+ if bare_raise:
+ self.add_message("try-except-raise", node=handler_having_bare_raise)
+
+ @utils.check_messages("wrong-exception-operation")
+ def visit_binop(self, node):
+ if isinstance(node.parent, astroid.ExceptHandler):
+ # except (V | A)
+ suggestion = "Did you mean '({}, {})' instead?".format(
+ node.left.as_string(),
+ node.right.as_string(),
+ )
+ self.add_message("wrong-exception-operation", node=node, args=(suggestion,))
+
+ @utils.check_messages("wrong-exception-operation")
+ def visit_compare(self, node):
+ if isinstance(node.parent, astroid.ExceptHandler):
+ # except (V < A)
+ suggestion = "Did you mean '({}, {})' instead?".format(
+ node.left.as_string(),
+ ", ".join(operand.as_string() for _, operand in node.ops),
+ )
+ self.add_message("wrong-exception-operation", node=node, args=(suggestion,))
+
+ @utils.check_messages(
+ "bare-except",
+ "broad-except",
+ "try-except-raise",
+ "binary-op-exception",
+ "bad-except-order",
+ "catching-non-exception",
+ "duplicate-except",
+ )
+ def visit_tryexcept(self, node):
+ """check for empty except"""
+ self._check_try_except_raise(node)
+ exceptions_classes = []
+ nb_handlers = len(node.handlers)
+ for index, handler in enumerate(node.handlers):
+ if handler.type is None:
+ if not _is_raising(handler.body):
+ self.add_message("bare-except", node=handler)
+
+ # check if an "except:" is followed by some other
+ # except
+ if index < (nb_handlers - 1):
+ msg = "empty except clause should always appear last"
+ self.add_message("bad-except-order", node=node, args=msg)
+
+ elif isinstance(handler.type, astroid.BoolOp):
+ self.add_message(
+ "binary-op-exception", node=handler, args=handler.type.op
+ )
+ else:
+ try:
+ excs = list(_annotated_unpack_infer(handler.type))
+ except astroid.InferenceError:
+ continue
+
+ for part, exc in excs:
+ if exc is astroid.Uninferable:
+ continue
+ if isinstance(exc, astroid.Instance) and utils.inherit_from_std_ex(
+ exc
+ ):
+ # pylint: disable=protected-access
+ exc = exc._proxied
+
+ self._check_catching_non_exception(handler, exc, part)
+
+ if not isinstance(exc, astroid.ClassDef):
+ continue
+
+ exc_ancestors = [
+ anc
+ for anc in exc.ancestors()
+ if isinstance(anc, astroid.ClassDef)
+ ]
+
+ for previous_exc in exceptions_classes:
+ if previous_exc in exc_ancestors:
+ msg = "{} is an ancestor class of {}".format(
+ previous_exc.name,
+ exc.name,
+ )
+ self.add_message(
+ "bad-except-order", node=handler.type, args=msg
+ )
+ if (
+ exc.name in self.config.overgeneral_exceptions
+ and exc.root().name == utils.EXCEPTIONS_MODULE
+ and not _is_raising(handler.body)
+ ):
+ self.add_message(
+ "broad-except", args=exc.name, node=handler.type
+ )
+
+ if exc in exceptions_classes:
+ self.add_message(
+ "duplicate-except", args=exc.name, node=handler.type
+ )
+
+ exceptions_classes += [exc for _, exc in excs]
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(ExceptionsChecker(linter))
diff --git a/pylint/checkers/format.py b/pylint/checkers/format.py
new file mode 100644
index 0000000..8987752
--- /dev/null
+++ b/pylint/checkers/format.py
@@ -0,0 +1,801 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012-2015 Google, Inc.
+# Copyright (c) 2013 moxian <aleftmail@inbox.ru>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 frost-nzcr4 <frost.nzcr4@jagmort.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Mike Frysinger <vapier@gentoo.org>
+# Copyright (c) 2015 Fabio Natali <me@fabionatali.com>
+# Copyright (c) 2015 Harut <yes@harutune.name>
+# Copyright (c) 2015 Mihai Balint <balint.mihai@gmail.com>
+# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Petr Pulc <petrpulc@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2017, 2019-2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2017 Krzysztof Czapla <k.czapla68@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 James M. Allen <james.m.allen@gmail.com>
+# Copyright (c) 2017 vinnyrose <vinnyrose@users.noreply.github.com>
+# Copyright (c) 2018-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2018, 2020 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Michael Hudson-Doyle <michael.hudson@canonical.com>
+# Copyright (c) 2018 Natalie Serebryakova <natalie.serebryakova@Natalies-MacBook-Pro.local>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Marcus Näslund <naslundx@gmail.com>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Fureigh <rhys.fureigh@gsa.gov>
+# Copyright (c) 2018 Andreas Freimuth <andreas.freimuth@united-bits.de>
+# Copyright (c) 2018 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Raphael Gaschignard <raphael@rtpg.co>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Python code format's checker.
+
+By default try to follow Guido's style guide :
+
+https://www.python.org/doc/essays/styleguide/
+
+Some parts of the process_token method is based from The Tab Nanny std module.
+"""
+
+import tokenize
+from functools import reduce # pylint: disable=redefined-builtin
+from typing import List
+
+from astroid import nodes
+
+from pylint.checkers import BaseTokenChecker
+from pylint.checkers.utils import (
+ check_messages,
+ is_overload_stub,
+ is_protocol_class,
+ node_frame_class,
+)
+from pylint.constants import WarningScope
+from pylint.interfaces import IAstroidChecker, IRawChecker, ITokenChecker
+from pylint.utils.pragma_parser import OPTION_PO, PragmaParserError, parse_pragma
+
+_ASYNC_TOKEN = "async"
+_KEYWORD_TOKENS = [
+ "assert",
+ "del",
+ "elif",
+ "except",
+ "for",
+ "if",
+ "in",
+ "not",
+ "raise",
+ "return",
+ "while",
+ "yield",
+ "with",
+]
+
+_SPACED_OPERATORS = [
+ "==",
+ "<",
+ ">",
+ "!=",
+ "<>",
+ "<=",
+ ">=",
+ "+=",
+ "-=",
+ "*=",
+ "**=",
+ "/=",
+ "//=",
+ "&=",
+ "|=",
+ "^=",
+ "%=",
+ ">>=",
+ "<<=",
+]
+_OPENING_BRACKETS = ["(", "[", "{"]
+_CLOSING_BRACKETS = [")", "]", "}"]
+_TAB_LENGTH = 8
+
+_EOL = frozenset([tokenize.NEWLINE, tokenize.NL, tokenize.COMMENT])
+_JUNK_TOKENS = (tokenize.COMMENT, tokenize.NL)
+
+# Whitespace checking policy constants
+_MUST = 0
+_MUST_NOT = 1
+_IGNORE = 2
+
+MSGS = {
+ "C0301": (
+ "Line too long (%s/%s)",
+ "line-too-long",
+ "Used when a line is longer than a given number of characters.",
+ ),
+ "C0302": (
+ "Too many lines in module (%s/%s)", # was W0302
+ "too-many-lines",
+ "Used when a module has too many lines, reducing its readability.",
+ ),
+ "C0303": (
+ "Trailing whitespace",
+ "trailing-whitespace",
+ "Used when there is whitespace between the end of a line and the newline.",
+ ),
+ "C0304": (
+ "Final newline missing",
+ "missing-final-newline",
+ "Used when the last line in a file is missing a newline.",
+ ),
+ "C0305": (
+ "Trailing newlines",
+ "trailing-newlines",
+ "Used when there are trailing blank lines in a file.",
+ ),
+ "W0311": (
+ "Bad indentation. Found %s %s, expected %s",
+ "bad-indentation",
+ "Used when an unexpected number of indentation's tabulations or "
+ "spaces has been found.",
+ ),
+ "W0301": (
+ "Unnecessary semicolon", # was W0106
+ "unnecessary-semicolon",
+ 'Used when a statement is ended by a semi-colon (";"), which '
+ "isn't necessary (that's python, not C ;).",
+ ),
+ "C0321": (
+ "More than one statement on a single line",
+ "multiple-statements",
+ "Used when more than on statement are found on the same line.",
+ {"scope": WarningScope.NODE},
+ ),
+ "C0325": (
+ "Unnecessary parens after %r keyword",
+ "superfluous-parens",
+ "Used when a single item in parentheses follows an if, for, or "
+ "other keyword.",
+ ),
+ "C0327": (
+ "Mixed line endings LF and CRLF",
+ "mixed-line-endings",
+ "Used when there are mixed (LF and CRLF) newline signs in a file.",
+ ),
+ "C0328": (
+ "Unexpected line ending format. There is '%s' while it should be '%s'.",
+ "unexpected-line-ending-format",
+ "Used when there is different newline than expected.",
+ ),
+}
+
+
+def _last_token_on_line_is(tokens, line_end, token):
+ return (
+ line_end > 0
+ and tokens.token(line_end - 1) == token
+ or line_end > 1
+ and tokens.token(line_end - 2) == token
+ and tokens.type(line_end - 1) == tokenize.COMMENT
+ )
+
+
+# The contexts for hanging indents.
+# A hanging indented dictionary value after :
+HANGING_DICT_VALUE = "dict-value"
+# Hanging indentation in an expression.
+HANGING = "hanging"
+# Hanging indentation in a block header.
+HANGING_BLOCK = "hanging-block"
+# Continued indentation inside an expression.
+CONTINUED = "continued"
+# Continued indentation in a block header.
+CONTINUED_BLOCK = "continued-block"
+
+SINGLE_LINE = "single"
+WITH_BODY = "multi"
+
+
+class TokenWrapper:
+ """A wrapper for readable access to token information."""
+
+ def __init__(self, tokens):
+ self._tokens = tokens
+
+ def token(self, idx):
+ return self._tokens[idx][1]
+
+ def type(self, idx):
+ return self._tokens[idx][0]
+
+ def start_line(self, idx):
+ return self._tokens[idx][2][0]
+
+ def start_col(self, idx):
+ return self._tokens[idx][2][1]
+
+ def line(self, idx):
+ return self._tokens[idx][4]
+
+
+class FormatChecker(BaseTokenChecker):
+ """checks for :
+ * unauthorized constructions
+ * strict indentation
+ * line length
+ """
+
+ __implements__ = (ITokenChecker, IAstroidChecker, IRawChecker)
+
+ # configuration section name
+ name = "format"
+ # messages
+ msgs = MSGS
+ # configuration options
+ # for available dict keys/values see the optik parser 'add_option' method
+ options = (
+ (
+ "max-line-length",
+ {
+ "default": 100,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of characters on a single line.",
+ },
+ ),
+ (
+ "ignore-long-lines",
+ {
+ "type": "regexp",
+ "metavar": "<regexp>",
+ "default": r"^\s*(# )?<?https?://\S+>?$",
+ "help": (
+ "Regexp for a line that is allowed to be longer than the limit."
+ ),
+ },
+ ),
+ (
+ "single-line-if-stmt",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": (
+ "Allow the body of an if to be on the same "
+ "line as the test if there is no else."
+ ),
+ },
+ ),
+ (
+ "single-line-class-stmt",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": (
+ "Allow the body of a class to be on the same "
+ "line as the declaration if body contains "
+ "single statement."
+ ),
+ },
+ ),
+ (
+ "max-module-lines",
+ {
+ "default": 1000,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of lines in a module.",
+ },
+ ),
+ (
+ "indent-string",
+ {
+ "default": " ",
+ "type": "non_empty_string",
+ "metavar": "<string>",
+ "help": "String used as indentation unit. This is usually "
+ '" " (4 spaces) or "\\t" (1 tab).',
+ },
+ ),
+ (
+ "indent-after-paren",
+ {
+ "type": "int",
+ "metavar": "<int>",
+ "default": 4,
+ "help": "Number of spaces of indent required inside a hanging "
+ "or continued line.",
+ },
+ ),
+ (
+ "expected-line-ending-format",
+ {
+ "type": "choice",
+ "metavar": "<empty or LF or CRLF>",
+ "default": "",
+ "choices": ["", "LF", "CRLF"],
+ "help": (
+ "Expected format of line ending, "
+ "e.g. empty (any line ending), LF or CRLF."
+ ),
+ },
+ ),
+ )
+
+ def __init__(self, linter=None):
+ BaseTokenChecker.__init__(self, linter)
+ self._lines = None
+ self._visited_lines = None
+ self._bracket_stack = [None]
+
+ def new_line(self, tokens, line_end, line_start):
+ """a new line has been encountered, process it if necessary"""
+ if _last_token_on_line_is(tokens, line_end, ";"):
+ self.add_message("unnecessary-semicolon", line=tokens.start_line(line_end))
+
+ line_num = tokens.start_line(line_start)
+ line = tokens.line(line_start)
+ if tokens.type(line_start) not in _JUNK_TOKENS:
+ self._lines[line_num] = line.split("\n")[0]
+ self.check_lines(line, line_num)
+
+ def process_module(self, _module):
+ pass
+
+ def _check_keyword_parentheses(
+ self, tokens: List[tokenize.TokenInfo], start: int
+ ) -> None:
+ """Check that there are not unnecessary parentheses after a keyword.
+
+ Parens are unnecessary if there is exactly one balanced outer pair on a
+ line, and it is followed by a colon, and contains no commas (i.e. is not a
+ tuple).
+
+ Args:
+ tokens: list of Tokens; the entire list of Tokens.
+ start: int; the position of the keyword in the token list.
+ """
+ # If the next token is not a paren, we're fine.
+ if self._bracket_stack[-1] == ":" and tokens[start].string == "for":
+ self._bracket_stack.pop()
+ if tokens[start + 1].string != "(":
+ return
+ found_and_or = False
+ contains_walrus_operator = False
+ walrus_operator_depth = 0
+ depth = 0
+ keyword_token = str(tokens[start].string)
+ line_num = tokens[start].start[0]
+ for i in range(start, len(tokens) - 1):
+ token = tokens[i]
+
+ # If we hit a newline, then assume any parens were for continuation.
+ if token.type == tokenize.NL:
+ return
+ # Since the walrus operator doesn't exist below python3.8, the tokenizer
+ # generates independent tokens
+ if (
+ token.string == ":=" # <-- python3.8+ path
+ or token.string + tokens[i + 1].string == ":="
+ ):
+ contains_walrus_operator = True
+ walrus_operator_depth = depth
+ if token.string == "(":
+ depth += 1
+ elif token.string == ")":
+ depth -= 1
+ if depth:
+ continue
+ # ')' can't happen after if (foo), since it would be a syntax error.
+ if tokens[i + 1].string in (":", ")", "]", "}", "in") or tokens[
+ i + 1
+ ].type in (tokenize.NEWLINE, tokenize.ENDMARKER, tokenize.COMMENT):
+ # The empty tuple () is always accepted.
+ if contains_walrus_operator and walrus_operator_depth - 1 == depth:
+ # Reset variable for possible following expressions
+ contains_walrus_operator = False
+ continue
+ if i == start + 2:
+ return
+ if keyword_token == "not":
+ if not found_and_or:
+ self.add_message(
+ "superfluous-parens", line=line_num, args=keyword_token
+ )
+ elif keyword_token in ("return", "yield"):
+ self.add_message(
+ "superfluous-parens", line=line_num, args=keyword_token
+ )
+ elif not found_and_or:
+ self.add_message(
+ "superfluous-parens", line=line_num, args=keyword_token
+ )
+ return
+ elif depth == 1:
+ # This is a tuple, which is always acceptable.
+ if token[1] == ",":
+ return
+ # 'and' and 'or' are the only boolean operators with lower precedence
+ # than 'not', so parens are only required when they are found.
+ if token[1] in ("and", "or"):
+ found_and_or = True
+ # A yield inside an expression must always be in parentheses,
+ # quit early without error.
+ elif token[1] == "yield":
+ return
+ # A generator expression always has a 'for' token in it, and
+ # the 'for' token is only legal inside parens when it is in a
+ # generator expression. The parens are necessary here, so bail
+ # without an error.
+ elif token[1] == "for":
+ return
+
+ def _prepare_token_dispatcher(self):
+ dispatch = {}
+ for tokens, handler in ((_KEYWORD_TOKENS, self._check_keyword_parentheses),):
+ for token in tokens:
+ dispatch[token] = handler
+ return dispatch
+
+ def process_tokens(self, tokens):
+ """process tokens and search for :
+
+ _ too long lines (i.e. longer than <max_chars>)
+ _ optionally bad construct (if given, bad_construct must be a compiled
+ regular expression).
+ """
+ self._bracket_stack = [None]
+ indents = [0]
+ check_equal = False
+ line_num = 0
+ self._lines = {}
+ self._visited_lines = {}
+ token_handlers = self._prepare_token_dispatcher()
+ self._last_line_ending = None
+ last_blank_line_num = 0
+ for idx, (tok_type, token, start, _, line) in enumerate(tokens):
+ if start[0] != line_num:
+ line_num = start[0]
+ # A tokenizer oddity: if an indented line contains a multi-line
+ # docstring, the line member of the INDENT token does not contain
+ # the full line; therefore we check the next token on the line.
+ if tok_type == tokenize.INDENT:
+ self.new_line(TokenWrapper(tokens), idx - 1, idx + 1)
+ else:
+ self.new_line(TokenWrapper(tokens), idx - 1, idx)
+
+ if tok_type == tokenize.NEWLINE:
+ # a program statement, or ENDMARKER, will eventually follow,
+ # after some (possibly empty) run of tokens of the form
+ # (NL | COMMENT)* (INDENT | DEDENT+)?
+ # If an INDENT appears, setting check_equal is wrong, and will
+ # be undone when we see the INDENT.
+ check_equal = True
+ self._check_line_ending(token, line_num)
+ elif tok_type == tokenize.INDENT:
+ check_equal = False
+ self.check_indent_level(token, indents[-1] + 1, line_num)
+ indents.append(indents[-1] + 1)
+ elif tok_type == tokenize.DEDENT:
+ # there's nothing we need to check here! what's important is
+ # that when the run of DEDENTs ends, the indentation of the
+ # program statement (or ENDMARKER) that triggered the run is
+ # equal to what's left at the top of the indents stack
+ check_equal = True
+ if len(indents) > 1:
+ del indents[-1]
+ elif tok_type == tokenize.NL:
+ if not line.strip("\r\n"):
+ last_blank_line_num = line_num
+ elif tok_type not in (tokenize.COMMENT, tokenize.ENCODING):
+ # This is the first concrete token following a NEWLINE, so it
+ # must be the first token of the next program statement, or an
+ # ENDMARKER; the "line" argument exposes the leading whitespace
+ # for this statement; in the case of ENDMARKER, line is an empty
+ # string, so will properly match the empty string with which the
+ # "indents" stack was seeded
+ if check_equal:
+ check_equal = False
+ self.check_indent_level(line, indents[-1], line_num)
+
+ if tok_type == tokenize.NUMBER and token.endswith("l"):
+ self.add_message("lowercase-l-suffix", line=line_num)
+
+ try:
+ handler = token_handlers[token]
+ except KeyError:
+ pass
+ else:
+ handler(tokens, idx)
+
+ line_num -= 1 # to be ok with "wc -l"
+ if line_num > self.config.max_module_lines:
+ # Get the line where the too-many-lines (or its message id)
+ # was disabled or default to 1.
+ message_definition = self.linter.msgs_store.get_message_definitions(
+ "too-many-lines"
+ )[0]
+ names = (message_definition.msgid, "too-many-lines")
+ line = next(
+ filter(None, (self.linter._pragma_lineno.get(name) for name in names)),
+ 1,
+ )
+ self.add_message(
+ "too-many-lines",
+ args=(line_num, self.config.max_module_lines),
+ line=line,
+ )
+
+ # See if there are any trailing lines. Do not complain about empty
+ # files like __init__.py markers.
+ if line_num == last_blank_line_num and line_num > 0:
+ self.add_message("trailing-newlines", line=line_num)
+
+ def _check_line_ending(self, line_ending, line_num):
+ # check if line endings are mixed
+ if self._last_line_ending is not None:
+ # line_ending == "" indicates a synthetic newline added at
+ # the end of a file that does not, in fact, end with a
+ # newline.
+ if line_ending and line_ending != self._last_line_ending:
+ self.add_message("mixed-line-endings", line=line_num)
+
+ self._last_line_ending = line_ending
+
+ # check if line ending is as expected
+ expected = self.config.expected_line_ending_format
+ if expected:
+ # reduce multiple \n\n\n\n to one \n
+ line_ending = reduce(lambda x, y: x + y if x != y else x, line_ending, "")
+ line_ending = "LF" if line_ending == "\n" else "CRLF"
+ if line_ending != expected:
+ self.add_message(
+ "unexpected-line-ending-format",
+ args=(line_ending, expected),
+ line=line_num,
+ )
+
+ @check_messages("multiple-statements")
+ def visit_default(self, node):
+ """check the node line number and check it if not yet done"""
+ if not node.is_statement:
+ return
+ if not node.root().pure_python:
+ return
+ prev_sibl = node.previous_sibling()
+ if prev_sibl is not None:
+ prev_line = prev_sibl.fromlineno
+ # The line on which a finally: occurs in a try/finally
+ # is not directly represented in the AST. We infer it
+ # by taking the last line of the body and adding 1, which
+ # should be the line of finally:
+ elif (
+ isinstance(node.parent, nodes.TryFinally) and node in node.parent.finalbody
+ ):
+ prev_line = node.parent.body[0].tolineno + 1
+ else:
+ prev_line = node.parent.statement().fromlineno
+ line = node.fromlineno
+ assert line, node
+ if prev_line == line and self._visited_lines.get(line) != 2:
+ self._check_multi_statement_line(node, line)
+ return
+ if line in self._visited_lines:
+ return
+ try:
+ tolineno = node.blockstart_tolineno
+ except AttributeError:
+ tolineno = node.tolineno
+ assert tolineno, node
+ lines = []
+ for line in range(line, tolineno + 1):
+ self._visited_lines[line] = 1
+ try:
+ lines.append(self._lines[line].rstrip())
+ except KeyError:
+ lines.append("")
+
+ def _check_multi_statement_line(self, node, line):
+ """Check for lines containing multiple statements."""
+ # Do not warn about multiple nested context managers
+ # in with statements.
+ if isinstance(node, nodes.With):
+ return
+ # For try... except... finally..., the two nodes
+ # appear to be on the same line due to how the AST is built.
+ if isinstance(node, nodes.TryExcept) and isinstance(
+ node.parent, nodes.TryFinally
+ ):
+ return
+ if (
+ isinstance(node.parent, nodes.If)
+ and not node.parent.orelse
+ and self.config.single_line_if_stmt
+ ):
+ return
+ if (
+ isinstance(node.parent, nodes.ClassDef)
+ and len(node.parent.body) == 1
+ and self.config.single_line_class_stmt
+ ):
+ return
+
+ # Function overloads that use ``Ellipsis`` are exempted.
+ if (
+ isinstance(node, nodes.Expr)
+ and isinstance(node.value, nodes.Const)
+ and node.value.value is Ellipsis
+ ):
+ frame = node.frame()
+ if is_overload_stub(frame) or is_protocol_class(node_frame_class(frame)):
+ return
+
+ self.add_message("multiple-statements", node=node)
+ self._visited_lines[line] = 2
+
+ def check_line_ending(self, line: str, i: int) -> None:
+ """
+ Check that the final newline is not missing and that there is no trailing whitespace.
+ """
+ if not line.endswith("\n"):
+ self.add_message("missing-final-newline", line=i)
+ return
+ # exclude \f (formfeed) from the rstrip
+ stripped_line = line.rstrip("\t\n\r\v ")
+ if line[len(stripped_line) :] not in ("\n", "\r\n"):
+ self.add_message(
+ "trailing-whitespace", line=i, col_offset=len(stripped_line)
+ )
+
+ def check_line_length(self, line: str, i: int) -> None:
+ """
+ Check that the line length is less than the authorized value
+ """
+ max_chars = self.config.max_line_length
+ ignore_long_line = self.config.ignore_long_lines
+ line = line.rstrip()
+ if len(line) > max_chars and not ignore_long_line.search(line):
+ self.add_message("line-too-long", line=i, args=(len(line), max_chars))
+
+ @staticmethod
+ def remove_pylint_option_from_lines(options_pattern_obj) -> str:
+ """
+ Remove the `# pylint ...` pattern from lines
+ """
+ lines = options_pattern_obj.string
+ purged_lines = (
+ lines[: options_pattern_obj.start(1)].rstrip()
+ + lines[options_pattern_obj.end(1) :]
+ )
+ return purged_lines
+
+ @staticmethod
+ def is_line_length_check_activated(pylint_pattern_match_object) -> bool:
+ """
+ Return true if the line length check is activated
+ """
+ try:
+ for pragma in parse_pragma(pylint_pattern_match_object.group(2)):
+ if pragma.action == "disable" and "line-too-long" in pragma.messages:
+ return False
+ except PragmaParserError:
+ # Printing useful information dealing with this error is done in the lint package
+ pass
+ return True
+
+ @staticmethod
+ def specific_splitlines(lines: str) -> List[str]:
+ """
+ Split lines according to universal newlines except those in a specific sets
+ """
+ unsplit_ends = {
+ "\v",
+ "\x0b",
+ "\f",
+ "\x0c",
+ "\x1c",
+ "\x1d",
+ "\x1e",
+ "\x85",
+ "\u2028",
+ "\u2029",
+ }
+ res = []
+ buffer = ""
+ for atomic_line in lines.splitlines(True):
+ if atomic_line[-1] not in unsplit_ends:
+ res.append(buffer + atomic_line)
+ buffer = ""
+ else:
+ buffer += atomic_line
+ return res
+
+ def check_lines(self, lines: str, lineno: int) -> None:
+ """
+ Check lines have :
+ - a final newline
+ - no trailing whitespace
+ - less than a maximum number of characters
+ """
+ # we're first going to do a rough check whether any lines in this set
+ # go over the line limit. If none of them do, then we don't need to
+ # parse out the pylint options later on and can just assume that these
+ # lines are clean
+
+ # we'll also handle the line ending check here to avoid double-iteration
+ # unless the line lengths are suspect
+
+ max_chars = self.config.max_line_length
+
+ split_lines = self.specific_splitlines(lines)
+
+ for offset, line in enumerate(split_lines):
+ self.check_line_ending(line, lineno + offset)
+
+ # hold onto the initial lineno for later
+ potential_line_length_warning = False
+ for offset, line in enumerate(split_lines):
+ # this check is purposefully simple and doesn't rstrip
+ # since this is running on every line you're checking it's
+ # advantageous to avoid doing a lot of work
+ if len(line) > max_chars:
+ potential_line_length_warning = True
+ break
+
+ # if there were no lines passing the max_chars config, we don't bother
+ # running the full line check (as we've met an even more strict condition)
+ if not potential_line_length_warning:
+ return
+
+ # Line length check may be deactivated through `pylint: disable` comment
+ mobj = OPTION_PO.search(lines)
+ if mobj:
+ if not self.is_line_length_check_activated(mobj):
+ # the line length check is deactivated, we can stop here
+ return
+ # The 'pylint: disable whatever' should not be taken into account for line length count
+ lines = self.remove_pylint_option_from_lines(mobj)
+
+ # here we re-run specific_splitlines since we have filtered out pylint options above
+ for offset, line in enumerate(self.specific_splitlines(lines)):
+ self.check_line_length(line, lineno + offset)
+
+ def check_indent_level(self, string, expected, line_num):
+ """return the indent level of the string"""
+ indent = self.config.indent_string
+ if indent == "\\t": # \t is not interpreted in the configuration file
+ indent = "\t"
+ level = 0
+ unit_size = len(indent)
+ while string[:unit_size] == indent:
+ string = string[unit_size:]
+ level += 1
+ suppl = ""
+ while string and string[0] in " \t":
+ suppl += string[0]
+ string = string[1:]
+ if level != expected or suppl:
+ i_type = "spaces"
+ if indent[0] == "\t":
+ i_type = "tabs"
+ self.add_message(
+ "bad-indentation",
+ line=line_num,
+ args=(level * unit_size + len(suppl), i_type, expected * unit_size),
+ )
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(FormatChecker(linter))
diff --git a/pylint/checkers/imports.py b/pylint/checkers/imports.py
new file mode 100644
index 0000000..ceadaef
--- /dev/null
+++ b/pylint/checkers/imports.py
@@ -0,0 +1,1017 @@
+# Copyright (c) 2006-2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2013 buck@yelp.com <buck@yelp.com>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Cezar <celnazli@bitdefender.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Noam Yorav-Raphael <noamraph@gmail.com>
+# Copyright (c) 2015 James Morgensen <james.morgensen@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Jared Garst <cultofjared@gmail.com>
+# Copyright (c) 2016 Maik Röder <maikroeder@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Michka Popoff <michkapopoff@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Erik Wright <erik.wright@shopify.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Hornwitser <github@hornwitser.no>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Natalie Serebryakova <natalie.serebryakova@Natalies-MacBook-Pro.local>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Marianna Polatoglou <mpolatoglou@bloomberg.net>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Nick Smith <clickthisnick@users.noreply.github.com>
+# Copyright (c) 2019 Paul Renvoisé <renvoisepaul@gmail.com>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Matus Valo <matusvalo@users.noreply.github.com>
+# Copyright (c) 2021 Andrew Howe <howeaj@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""imports checkers for Python code"""
+
+import collections
+import copy
+import os
+import sys
+from distutils import sysconfig
+from typing import Dict, List, Union
+
+import astroid
+
+from pylint.checkers import BaseChecker, DeprecatedMixin
+from pylint.checkers.utils import (
+ check_messages,
+ is_from_fallback_block,
+ node_ignores_exception,
+)
+from pylint.exceptions import EmptyReportError
+from pylint.graph import DotBackend, get_cycles
+from pylint.interfaces import IAstroidChecker
+from pylint.reporters.ureports.nodes import Paragraph, VerbatimText, VNode
+from pylint.utils import IsortDriver, get_global_option
+
+
+def _qualified_names(modname):
+ """Split the names of the given module into subparts
+
+ For example,
+ _qualified_names('pylint.checkers.ImportsChecker')
+ returns
+ ['pylint', 'pylint.checkers', 'pylint.checkers.ImportsChecker']
+ """
+ names = modname.split(".")
+ return [".".join(names[0 : i + 1]) for i in range(len(names))]
+
+
+def _get_import_name(importnode, modname):
+ """Get a prepared module name from the given import node
+
+ In the case of relative imports, this will return the
+ absolute qualified module name, which might be useful
+ for debugging. Otherwise, the initial module name
+ is returned unchanged.
+ """
+ if isinstance(importnode, astroid.ImportFrom):
+ if importnode.level:
+ root = importnode.root()
+ if isinstance(root, astroid.Module):
+ modname = root.relative_to_absolute_name(
+ modname, level=importnode.level
+ )
+ return modname
+
+
+def _get_first_import(node, context, name, base, level, alias):
+ """return the node where [base.]<name> is imported or None if not found"""
+ fullname = f"{base}.{name}" if base else name
+
+ first = None
+ found = False
+ for first in context.body:
+ if first is node:
+ continue
+ if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
+ continue
+ if isinstance(first, astroid.Import):
+ if any(fullname == iname[0] for iname in first.names):
+ found = True
+ break
+ elif isinstance(first, astroid.ImportFrom):
+ if level == first.level:
+ for imported_name, imported_alias in first.names:
+ if fullname == f"{first.modname}.{imported_name}":
+ found = True
+ break
+ if (
+ name != "*"
+ and name == imported_name
+ and not (alias or imported_alias)
+ ):
+ found = True
+ break
+ if found:
+ break
+ if found and not astroid.are_exclusive(first, node):
+ return first
+ return None
+
+
+def _ignore_import_failure(node, modname, ignored_modules):
+ for submodule in _qualified_names(modname):
+ if submodule in ignored_modules:
+ return True
+
+ # ignore import failure if guarded by `sys.version_info` test
+ if isinstance(node.parent, astroid.If) and isinstance(
+ node.parent.test, astroid.Compare
+ ):
+ value = node.parent.test.left
+ if isinstance(value, astroid.Subscript):
+ value = value.value
+ if (
+ isinstance(value, astroid.Attribute)
+ and value.as_string() == "sys.version_info"
+ ):
+ return True
+
+ return node_ignores_exception(node, ImportError)
+
+
+# utilities to represents import dependencies as tree and dot graph ###########
+
+
+def _make_tree_defs(mod_files_list):
+ """get a list of 2-uple (module, list_of_files_which_import_this_module),
+ it will return a dictionary to represent this as a tree
+ """
+ tree_defs = {}
+ for mod, files in mod_files_list:
+ node = (tree_defs, ())
+ for prefix in mod.split("."):
+ node = node[0].setdefault(prefix, [{}, []])
+ node[1] += files
+ return tree_defs
+
+
+def _repr_tree_defs(data, indent_str=None):
+ """return a string which represents imports as a tree"""
+ lines = []
+ nodes = data.items()
+ for i, (mod, (sub, files)) in enumerate(sorted(nodes, key=lambda x: x[0])):
+ if not files:
+ files = ""
+ else:
+ files = "(%s)" % ",".join(sorted(files))
+ if indent_str is None:
+ lines.append(f"{mod} {files}")
+ sub_indent_str = " "
+ else:
+ lines.append(fr"{indent_str}\-{mod} {files}")
+ if i == len(nodes) - 1:
+ sub_indent_str = "%s " % indent_str
+ else:
+ sub_indent_str = "%s| " % indent_str
+ if sub:
+ lines.append(_repr_tree_defs(sub, sub_indent_str))
+ return "\n".join(lines)
+
+
+def _dependencies_graph(filename: str, dep_info: Dict[str, List[str]]) -> str:
+ """write dependencies as a dot (graphviz) file"""
+ done = {}
+ printer = DotBackend(os.path.splitext(os.path.basename(filename))[0], rankdir="LR")
+ printer.emit('URL="." node[shape="box"]')
+ for modname, dependencies in sorted(dep_info.items()):
+ done[modname] = 1
+ printer.emit_node(modname)
+ for depmodname in dependencies:
+ if depmodname not in done:
+ done[depmodname] = 1
+ printer.emit_node(depmodname)
+ for depmodname, dependencies in sorted(dep_info.items()):
+ for modname in dependencies:
+ printer.emit_edge(modname, depmodname)
+ return printer.generate(filename)
+
+
+def _make_graph(filename: str, dep_info: Dict[str, List[str]], sect: VNode, gtype: str):
+ """generate a dependencies graph and add some information about it in the
+ report's section
+ """
+ outputfile = _dependencies_graph(filename, dep_info)
+ sect.append(Paragraph(f"{gtype}imports graph has been written to {outputfile}"))
+
+
+# the import checker itself ###################################################
+
+MSGS = {
+ "E0401": (
+ "Unable to import %s",
+ "import-error",
+ "Used when pylint has been unable to import a module.",
+ {"old_names": [("F0401", "old-import-error")]},
+ ),
+ "E0402": (
+ "Attempted relative import beyond top-level package",
+ "relative-beyond-top-level",
+ "Used when a relative import tries to access too many levels "
+ "in the current package.",
+ ),
+ "R0401": (
+ "Cyclic import (%s)",
+ "cyclic-import",
+ "Used when a cyclic import between two or more modules is detected.",
+ ),
+ "R0402": (
+ "Use 'from %s import %s' instead",
+ "consider-using-from-import",
+ "Emitted when a submodule/member of a package is imported and "
+ "aliased with the same name. "
+ "E.g., instead of ``import pandas.DataFrame as DataFrame`` use "
+ "``from pandas import DataFrame``",
+ ),
+ "W0401": (
+ "Wildcard import %s",
+ "wildcard-import",
+ "Used when `from module import *` is detected.",
+ ),
+ "W0402": (
+ "Uses of a deprecated module %r",
+ "deprecated-module",
+ "Used a module marked as deprecated is imported.",
+ ),
+ "W0404": (
+ "Reimport %r (imported line %s)",
+ "reimported",
+ "Used when a module is reimported multiple times.",
+ ),
+ "W0406": (
+ "Module import itself",
+ "import-self",
+ "Used when a module is importing itself.",
+ ),
+ "W0407": (
+ "Prefer importing %r instead of %r",
+ "preferred-module",
+ "Used when a module imported has a preferred replacement module.",
+ ),
+ "W0410": (
+ "__future__ import is not the first non docstring statement",
+ "misplaced-future",
+ "Python 2.5 and greater require __future__ import to be the "
+ "first non docstring statement in the module.",
+ ),
+ "C0410": (
+ "Multiple imports on one line (%s)",
+ "multiple-imports",
+ "Used when import statement importing multiple modules is detected.",
+ ),
+ "C0411": (
+ "%s should be placed before %s",
+ "wrong-import-order",
+ "Used when PEP8 import order is not respected (standard imports "
+ "first, then third-party libraries, then local imports)",
+ ),
+ "C0412": (
+ "Imports from package %s are not grouped",
+ "ungrouped-imports",
+ "Used when imports are not grouped by packages",
+ ),
+ "C0413": (
+ 'Import "%s" should be placed at the top of the module',
+ "wrong-import-position",
+ "Used when code and imports are mixed",
+ ),
+ "C0414": (
+ "Import alias does not rename original package",
+ "useless-import-alias",
+ "Used when an import alias is same as original package."
+ "e.g using import numpy as numpy instead of import numpy as np",
+ ),
+ "C0415": (
+ "Import outside toplevel (%s)",
+ "import-outside-toplevel",
+ "Used when an import statement is used anywhere other than the module "
+ "toplevel. Move this import to the top of the file.",
+ ),
+}
+
+
+DEFAULT_STANDARD_LIBRARY = ()
+DEFAULT_KNOWN_THIRD_PARTY = ("enchant",)
+DEFAULT_PREFERRED_MODULES = ()
+
+
+class ImportsChecker(DeprecatedMixin, BaseChecker):
+ """checks for
+ * external modules dependencies
+ * relative / wildcard imports
+ * cyclic imports
+ * uses of deprecated modules
+ * uses of modules instead of preferred modules
+ """
+
+ __implements__ = IAstroidChecker
+
+ name = "imports"
+ msgs = MSGS
+ priority = -2
+ default_deprecated_modules = ()
+
+ options = (
+ (
+ "deprecated-modules",
+ {
+ "default": default_deprecated_modules,
+ "type": "csv",
+ "metavar": "<modules>",
+ "help": "Deprecated modules which should not be used,"
+ " separated by a comma.",
+ },
+ ),
+ (
+ "preferred-modules",
+ {
+ "default": DEFAULT_PREFERRED_MODULES,
+ "type": "csv",
+ "metavar": "<module:preferred-module>",
+ "help": "Couples of modules and preferred modules,"
+ " separated by a comma.",
+ },
+ ),
+ (
+ "import-graph",
+ {
+ "default": "",
+ "type": "string",
+ "metavar": "<file.gv>",
+ "help": "Output a graph (.gv or any supported image format) of"
+ " all (i.e. internal and external) dependencies to the given file"
+ " (report RP0402 must not be disabled).",
+ },
+ ),
+ (
+ "ext-import-graph",
+ {
+ "default": "",
+ "type": "string",
+ "metavar": "<file.gv>",
+ "help": "Output a graph (.gv or any supported image format)"
+ " of external dependencies to the given file"
+ " (report RP0402 must not be disabled).",
+ },
+ ),
+ (
+ "int-import-graph",
+ {
+ "default": "",
+ "type": "string",
+ "metavar": "<file.gv>",
+ "help": "Output a graph (.gv or any supported image format)"
+ " of internal dependencies to the given file"
+ " (report RP0402 must not be disabled).",
+ },
+ ),
+ (
+ "known-standard-library",
+ {
+ "default": DEFAULT_STANDARD_LIBRARY,
+ "type": "csv",
+ "metavar": "<modules>",
+ "help": "Force import order to recognize a module as part of "
+ "the standard compatibility libraries.",
+ },
+ ),
+ (
+ "known-third-party",
+ {
+ "default": DEFAULT_KNOWN_THIRD_PARTY,
+ "type": "csv",
+ "metavar": "<modules>",
+ "help": "Force import order to recognize a module as part of "
+ "a third party library.",
+ },
+ ),
+ (
+ "allow-any-import-level",
+ {
+ "default": (),
+ "type": "csv",
+ "metavar": "<modules>",
+ "help": (
+ "List of modules that can be imported at any level, not just "
+ "the top level one."
+ ),
+ },
+ ),
+ (
+ "analyse-fallback-blocks",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "Analyse import fallback blocks. This can be used to "
+ "support both Python 2 and 3 compatible code, which "
+ "means that the block might have code that exists "
+ "only in one or another interpreter, leading to false "
+ "positives when analysed.",
+ },
+ ),
+ (
+ "allow-wildcard-with-all",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "Allow wildcard imports from modules that define __all__.",
+ },
+ ),
+ )
+
+ def __init__(self, linter=None):
+ BaseChecker.__init__(self, linter)
+ self.stats = None
+ self.import_graph = None
+ self._imports_stack = []
+ self._first_non_import_node = None
+ self._module_pkg = {} # mapping of modules to the pkg they belong in
+ self._allow_any_import_level = set()
+ self.reports = (
+ ("RP0401", "External dependencies", self._report_external_dependencies),
+ ("RP0402", "Modules dependencies graph", self._report_dependencies_graph),
+ )
+
+ self._site_packages = self._compute_site_packages()
+
+ @staticmethod
+ def _compute_site_packages():
+ def _normalized_path(path):
+ return os.path.normcase(os.path.abspath(path))
+
+ paths = set()
+ real_prefix = getattr(sys, "real_prefix", None)
+ for prefix in filter(None, (real_prefix, sys.prefix)):
+ path = sysconfig.get_python_lib(prefix=prefix)
+ path = _normalized_path(path)
+ paths.add(path)
+
+ # Handle Debian's derivatives /usr/local.
+ if os.path.isfile("/etc/debian_version"):
+ for prefix in filter(None, (real_prefix, sys.prefix)):
+ libpython = os.path.join(
+ prefix,
+ "local",
+ "lib",
+ "python" + sysconfig.get_python_version(),
+ "dist-packages",
+ )
+ paths.add(libpython)
+ return paths
+
+ def open(self):
+ """called before visiting project (i.e set of modules)"""
+ self.linter.add_stats(dependencies={})
+ self.linter.add_stats(cycles=[])
+ self.stats = self.linter.stats
+ self.import_graph = collections.defaultdict(set)
+ self._module_pkg = {} # mapping of modules to the pkg they belong in
+ self._excluded_edges = collections.defaultdict(set)
+ self._ignored_modules = get_global_option(self, "ignored-modules", default=[])
+ # Build a mapping {'module': 'preferred-module'}
+ self.preferred_modules = dict(
+ module.split(":")
+ for module in self.config.preferred_modules
+ if ":" in module
+ )
+ self._allow_any_import_level = set(self.config.allow_any_import_level)
+
+ def _import_graph_without_ignored_edges(self):
+ filtered_graph = copy.deepcopy(self.import_graph)
+ for node in filtered_graph:
+ filtered_graph[node].difference_update(self._excluded_edges[node])
+ return filtered_graph
+
+ def close(self):
+ """called before visiting project (i.e set of modules)"""
+ if self.linter.is_message_enabled("cyclic-import"):
+ graph = self._import_graph_without_ignored_edges()
+ vertices = list(graph)
+ for cycle in get_cycles(graph, vertices=vertices):
+ self.add_message("cyclic-import", args=" -> ".join(cycle))
+
+ def deprecated_modules(self):
+ """Callback returning the deprecated modules."""
+ return self.config.deprecated_modules
+
+ @check_messages(*MSGS)
+ def visit_import(self, node):
+ """triggered when an import statement is seen"""
+ self._check_reimport(node)
+ self._check_import_as_rename(node)
+ self._check_toplevel(node)
+
+ names = [name for name, _ in node.names]
+ if len(names) >= 2:
+ self.add_message("multiple-imports", args=", ".join(names), node=node)
+
+ for name in names:
+ self.check_deprecated_module(node, name)
+ self._check_preferred_module(node, name)
+ imported_module = self._get_imported_module(node, name)
+ if isinstance(node.parent, astroid.Module):
+ # Allow imports nested
+ self._check_position(node)
+ if isinstance(node.scope(), astroid.Module):
+ self._record_import(node, imported_module)
+
+ if imported_module is None:
+ continue
+
+ self._add_imported_module(node, imported_module.name)
+
+ @check_messages(*MSGS)
+ def visit_importfrom(self, node):
+ """triggered when a from statement is seen"""
+ basename = node.modname
+ imported_module = self._get_imported_module(node, basename)
+
+ self._check_import_as_rename(node)
+ self._check_misplaced_future(node)
+ self.check_deprecated_module(node, basename)
+ self._check_preferred_module(node, basename)
+ self._check_wildcard_imports(node, imported_module)
+ self._check_same_line_imports(node)
+ self._check_reimport(node, basename=basename, level=node.level)
+ self._check_toplevel(node)
+
+ if isinstance(node.parent, astroid.Module):
+ # Allow imports nested
+ self._check_position(node)
+ if isinstance(node.scope(), astroid.Module):
+ self._record_import(node, imported_module)
+ if imported_module is None:
+ return
+ for name, _ in node.names:
+ if name != "*":
+ self._add_imported_module(node, f"{imported_module.name}.{name}")
+ else:
+ self._add_imported_module(node, imported_module.name)
+
+ @check_messages(*MSGS)
+ def leave_module(self, node):
+ # Check imports are grouped by category (standard, 3rd party, local)
+ std_imports, ext_imports, loc_imports = self._check_imports_order(node)
+
+ # Check that imports are grouped by package within a given category
+ met_import = set() # set for 'import x' style
+ met_from = set() # set for 'from x import y' style
+ current_package = None
+ for import_node, import_name in std_imports + ext_imports + loc_imports:
+ if not self.linter.is_message_enabled(
+ "ungrouped-imports", import_node.fromlineno
+ ):
+ continue
+ if isinstance(import_node, astroid.node_classes.ImportFrom):
+ met = met_from
+ else:
+ met = met_import
+ package, _, _ = import_name.partition(".")
+ if current_package and current_package != package and package in met:
+ self.add_message("ungrouped-imports", node=import_node, args=package)
+ current_package = package
+ met.add(package)
+
+ self._imports_stack = []
+ self._first_non_import_node = None
+
+ def compute_first_non_import_node(self, node):
+ if not self.linter.is_message_enabled("wrong-import-position", node.fromlineno):
+ return
+ # if the node does not contain an import instruction, and if it is the
+ # first node of the module, keep a track of it (all the import positions
+ # of the module will be compared to the position of this first
+ # instruction)
+ if self._first_non_import_node:
+ return
+ if not isinstance(node.parent, astroid.Module):
+ return
+ nested_allowed = [astroid.TryExcept, astroid.TryFinally]
+ is_nested_allowed = [
+ allowed for allowed in nested_allowed if isinstance(node, allowed)
+ ]
+ if is_nested_allowed and any(
+ node.nodes_of_class((astroid.Import, astroid.ImportFrom))
+ ):
+ return
+ if isinstance(node, astroid.Assign):
+ # Add compatibility for module level dunder names
+ # https://www.python.org/dev/peps/pep-0008/#module-level-dunder-names
+ valid_targets = [
+ isinstance(target, astroid.AssignName)
+ and target.name.startswith("__")
+ and target.name.endswith("__")
+ for target in node.targets
+ ]
+ if all(valid_targets):
+ return
+ self._first_non_import_node = node
+
+ visit_tryfinally = (
+ visit_tryexcept
+ ) = (
+ visit_assignattr
+ ) = (
+ visit_assign
+ ) = (
+ visit_ifexp
+ ) = visit_comprehension = visit_expr = visit_if = compute_first_non_import_node
+
+ def visit_functiondef(self, node):
+ if not self.linter.is_message_enabled("wrong-import-position", node.fromlineno):
+ return
+ # If it is the first non import instruction of the module, record it.
+ if self._first_non_import_node:
+ return
+
+ # Check if the node belongs to an `If` or a `Try` block. If they
+ # contain imports, skip recording this node.
+ if not isinstance(node.parent.scope(), astroid.Module):
+ return
+
+ root = node
+ while not isinstance(root.parent, astroid.Module):
+ root = root.parent
+
+ if isinstance(root, (astroid.If, astroid.TryFinally, astroid.TryExcept)):
+ if any(root.nodes_of_class((astroid.Import, astroid.ImportFrom))):
+ return
+
+ self._first_non_import_node = node
+
+ visit_classdef = visit_for = visit_while = visit_functiondef
+
+ def _check_misplaced_future(self, node):
+ basename = node.modname
+ if basename == "__future__":
+ # check if this is the first non-docstring statement in the module
+ prev = node.previous_sibling()
+ if prev:
+ # consecutive future statements are possible
+ if not (
+ isinstance(prev, astroid.ImportFrom)
+ and prev.modname == "__future__"
+ ):
+ self.add_message("misplaced-future", node=node)
+ return
+
+ def _check_same_line_imports(self, node):
+ # Detect duplicate imports on the same line.
+ names = (name for name, _ in node.names)
+ counter = collections.Counter(names)
+ for name, count in counter.items():
+ if count > 1:
+ self.add_message("reimported", node=node, args=(name, node.fromlineno))
+
+ def _check_position(self, node):
+ """Check `node` import or importfrom node position is correct
+
+ Send a message if `node` comes before another instruction
+ """
+ # if a first non-import instruction has already been encountered,
+ # it means the import comes after it and therefore is not well placed
+ if self._first_non_import_node:
+ self.add_message("wrong-import-position", node=node, args=node.as_string())
+
+ def _record_import(self, node, importedmodnode):
+ """Record the package `node` imports from"""
+ if isinstance(node, astroid.ImportFrom):
+ importedname = node.modname
+ else:
+ importedname = importedmodnode.name if importedmodnode else None
+ if not importedname:
+ importedname = node.names[0][0].split(".")[0]
+
+ if isinstance(node, astroid.ImportFrom) and (node.level or 0) >= 1:
+ # We need the importedname with first point to detect local package
+ # Example of node:
+ # 'from .my_package1 import MyClass1'
+ # the output should be '.my_package1' instead of 'my_package1'
+ # Example of node:
+ # 'from . import my_package2'
+ # the output should be '.my_package2' instead of '{pyfile}'
+ importedname = "." + importedname
+
+ self._imports_stack.append((node, importedname))
+
+ @staticmethod
+ def _is_fallback_import(node, imports):
+ imports = [import_node for (import_node, _) in imports]
+ return any(astroid.are_exclusive(import_node, node) for import_node in imports)
+
+ def _check_imports_order(self, _module_node):
+ """Checks imports of module `node` are grouped by category
+
+ Imports must follow this order: standard, 3rd party, local
+ """
+ std_imports = []
+ third_party_imports = []
+ first_party_imports = []
+ # need of a list that holds third or first party ordered import
+ external_imports = []
+ local_imports = []
+ third_party_not_ignored = []
+ first_party_not_ignored = []
+ local_not_ignored = []
+ isort_driver = IsortDriver(self.config)
+ for node, modname in self._imports_stack:
+ if modname.startswith("."):
+ package = "." + modname.split(".")[1]
+ else:
+ package = modname.split(".")[0]
+ nested = not isinstance(node.parent, astroid.Module)
+ ignore_for_import_order = not self.linter.is_message_enabled(
+ "wrong-import-order", node.fromlineno
+ )
+ import_category = isort_driver.place_module(package)
+ node_and_package_import = (node, package)
+ if import_category in ("FUTURE", "STDLIB"):
+ std_imports.append(node_and_package_import)
+ wrong_import = (
+ third_party_not_ignored
+ or first_party_not_ignored
+ or local_not_ignored
+ )
+ if self._is_fallback_import(node, wrong_import):
+ continue
+ if wrong_import and not nested:
+ self.add_message(
+ "wrong-import-order",
+ node=node,
+ args=(
+ 'standard import "%s"' % node.as_string(),
+ '"%s"' % wrong_import[0][0].as_string(),
+ ),
+ )
+ elif import_category == "THIRDPARTY":
+ third_party_imports.append(node_and_package_import)
+ external_imports.append(node_and_package_import)
+ if not nested and not ignore_for_import_order:
+ third_party_not_ignored.append(node_and_package_import)
+ wrong_import = first_party_not_ignored or local_not_ignored
+ if wrong_import and not nested:
+ self.add_message(
+ "wrong-import-order",
+ node=node,
+ args=(
+ 'third party import "%s"' % node.as_string(),
+ '"%s"' % wrong_import[0][0].as_string(),
+ ),
+ )
+ elif import_category == "FIRSTPARTY":
+ first_party_imports.append(node_and_package_import)
+ external_imports.append(node_and_package_import)
+ if not nested and not ignore_for_import_order:
+ first_party_not_ignored.append(node_and_package_import)
+ wrong_import = local_not_ignored
+ if wrong_import and not nested:
+ self.add_message(
+ "wrong-import-order",
+ node=node,
+ args=(
+ 'first party import "%s"' % node.as_string(),
+ '"%s"' % wrong_import[0][0].as_string(),
+ ),
+ )
+ elif import_category == "LOCALFOLDER":
+ local_imports.append((node, package))
+ if not nested and not ignore_for_import_order:
+ local_not_ignored.append((node, package))
+ return std_imports, external_imports, local_imports
+
+ def _get_imported_module(self, importnode, modname):
+ try:
+ return importnode.do_import_module(modname)
+ except astroid.TooManyLevelsError:
+ if _ignore_import_failure(importnode, modname, self._ignored_modules):
+ return None
+ self.add_message("relative-beyond-top-level", node=importnode)
+ except astroid.AstroidSyntaxError as exc:
+ message = "Cannot import {!r} due to syntax error {!r}".format(
+ modname, str(exc.error) # pylint: disable=no-member; false positive
+ )
+ self.add_message("syntax-error", line=importnode.lineno, args=message)
+
+ except astroid.AstroidBuildingException:
+ if not self.linter.is_message_enabled("import-error"):
+ return None
+ if _ignore_import_failure(importnode, modname, self._ignored_modules):
+ return None
+ if not self.config.analyse_fallback_blocks and is_from_fallback_block(
+ importnode
+ ):
+ return None
+
+ dotted_modname = _get_import_name(importnode, modname)
+ self.add_message("import-error", args=repr(dotted_modname), node=importnode)
+ return None
+
+ def _add_imported_module(self, node, importedmodname):
+ """notify an imported module, used to analyze dependencies"""
+ module_file = node.root().file
+ context_name = node.root().name
+ base = os.path.splitext(os.path.basename(module_file))[0]
+
+ try:
+ importedmodname = astroid.modutils.get_module_part(
+ importedmodname, module_file
+ )
+ except ImportError:
+ pass
+
+ if context_name == importedmodname:
+ self.add_message("import-self", node=node)
+
+ elif not astroid.modutils.is_standard_module(importedmodname):
+ # if this is not a package __init__ module
+ if base != "__init__" and context_name not in self._module_pkg:
+ # record the module's parent, or the module itself if this is
+ # a top level module, as the package it belongs to
+ self._module_pkg[context_name] = context_name.rsplit(".", 1)[0]
+
+ # handle dependencies
+ importedmodnames = self.stats["dependencies"].setdefault(
+ importedmodname, set()
+ )
+ if context_name not in importedmodnames:
+ importedmodnames.add(context_name)
+
+ # update import graph
+ self.import_graph[context_name].add(importedmodname)
+ if not self.linter.is_message_enabled("cyclic-import", line=node.lineno):
+ self._excluded_edges[context_name].add(importedmodname)
+
+ def _check_preferred_module(self, node, mod_path):
+ """check if the module has a preferred replacement"""
+ if mod_path in self.preferred_modules:
+ self.add_message(
+ "preferred-module",
+ node=node,
+ args=(self.preferred_modules[mod_path], mod_path),
+ )
+
+ def _check_import_as_rename(
+ self, node: Union[astroid.Import, astroid.ImportFrom]
+ ) -> None:
+ names = node.names
+ for name in names:
+ if not all(name):
+ return
+
+ splitted_packages = name[0].rsplit(".", maxsplit=1)
+ import_name = splitted_packages[-1]
+ aliased_name = name[1]
+ if import_name != aliased_name:
+ continue
+
+ if len(splitted_packages) == 1:
+ self.add_message("useless-import-alias", node=node)
+ elif len(splitted_packages) == 2:
+ self.add_message(
+ "consider-using-from-import",
+ node=node,
+ args=(splitted_packages[0], import_name),
+ )
+
+ def _check_reimport(self, node, basename=None, level=None):
+ """check if the import is necessary (i.e. not already done)"""
+ if not self.linter.is_message_enabled("reimported"):
+ return
+
+ frame = node.frame()
+ root = node.root()
+ contexts = [(frame, level)]
+ if root is not frame:
+ contexts.append((root, None))
+
+ for known_context, known_level in contexts:
+ for name, alias in node.names:
+ first = _get_first_import(
+ node, known_context, name, basename, known_level, alias
+ )
+ if first is not None:
+ self.add_message(
+ "reimported", node=node, args=(name, first.fromlineno)
+ )
+
+ def _report_external_dependencies(self, sect, _, _dummy):
+ """return a verbatim layout for displaying dependencies"""
+ dep_info = _make_tree_defs(self._external_dependencies_info().items())
+ if not dep_info:
+ raise EmptyReportError()
+ tree_str = _repr_tree_defs(dep_info)
+ sect.append(VerbatimText(tree_str))
+
+ def _report_dependencies_graph(self, sect, _, _dummy):
+ """write dependencies as a dot (graphviz) file"""
+ dep_info = self.stats["dependencies"]
+ if not dep_info or not (
+ self.config.import_graph
+ or self.config.ext_import_graph
+ or self.config.int_import_graph
+ ):
+ raise EmptyReportError()
+ filename = self.config.import_graph
+ if filename:
+ _make_graph(filename, dep_info, sect, "")
+ filename = self.config.ext_import_graph
+ if filename:
+ _make_graph(filename, self._external_dependencies_info(), sect, "external ")
+ filename = self.config.int_import_graph
+ if filename:
+ _make_graph(filename, self._internal_dependencies_info(), sect, "internal ")
+
+ def _filter_dependencies_graph(self, internal):
+ """build the internal or the external dependency graph"""
+ graph = collections.defaultdict(set)
+ for importee, importers in self.stats["dependencies"].items():
+ for importer in importers:
+ package = self._module_pkg.get(importer, importer)
+ is_inside = importee.startswith(package)
+ if is_inside and internal or not is_inside and not internal:
+ graph[importee].add(importer)
+ return graph
+
+ @astroid.decorators.cached
+ def _external_dependencies_info(self):
+ """return cached external dependencies information or build and
+ cache them
+ """
+ return self._filter_dependencies_graph(internal=False)
+
+ @astroid.decorators.cached
+ def _internal_dependencies_info(self):
+ """return cached internal dependencies information or build and
+ cache them
+ """
+ return self._filter_dependencies_graph(internal=True)
+
+ def _check_wildcard_imports(self, node, imported_module):
+ if node.root().package:
+ # Skip the check if in __init__.py issue #2026
+ return
+
+ wildcard_import_is_allowed = self._wildcard_import_is_allowed(imported_module)
+ for name, _ in node.names:
+ if name == "*" and not wildcard_import_is_allowed:
+ self.add_message("wildcard-import", args=node.modname, node=node)
+
+ def _wildcard_import_is_allowed(self, imported_module):
+ return (
+ self.config.allow_wildcard_with_all
+ and imported_module is not None
+ and "__all__" in imported_module.locals
+ )
+
+ def _check_toplevel(self, node):
+ """Check whether the import is made outside the module toplevel."""
+ # If the scope of the import is a module, then obviously it is
+ # not outside the module toplevel.
+ if isinstance(node.scope(), astroid.Module):
+ return
+
+ module_names = [
+ f"{node.modname}.{name[0]}"
+ if isinstance(node, astroid.ImportFrom)
+ else name[0]
+ for name in node.names
+ ]
+
+ # Get the full names of all the imports that are only allowed at the module level
+ scoped_imports = [
+ name for name in module_names if name not in self._allow_any_import_level
+ ]
+
+ if scoped_imports:
+ self.add_message(
+ "import-outside-toplevel", args=", ".join(scoped_imports), node=node
+ )
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(ImportsChecker(linter))
diff --git a/pylint/checkers/logging.py b/pylint/checkers/logging.py
new file mode 100644
index 0000000..084c7a9
--- /dev/null
+++ b/pylint/checkers/logging.py
@@ -0,0 +1,417 @@
+# Copyright (c) 2009-2011, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2009, 2012, 2014 Google, Inc.
+# Copyright (c) 2012 Mike Bryant <leachim@leachim.info>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016, 2019-2020 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Chris Murray <chris@chrismurray.scot>
+# Copyright (c) 2017 guillaume2 <guillaume.peillex@gmail.col>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Alan Chan <achan961117@gmail.com>
+# Copyright (c) 2018 Yury Gribov <tetra2005@gmail.com>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Mariatta Wijaya <mariatta@python.org>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Djailla <bastien.vallet@gmail.com>
+# Copyright (c) 2019 Svet <svet@hyperscience.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""checker for use of Python logging
+"""
+import string
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.checkers.utils import check_messages
+
+MSGS = { # pylint: disable=consider-using-namedtuple-or-dataclass
+ "W1201": (
+ "Use %s formatting in logging functions",
+ "logging-not-lazy",
+ "Used when a logging statement has a call form of "
+ '"logging.<logging method>(format_string % (format_args...))". '
+ "Use another type of string formatting instead. "
+ "You can use % formatting but leave interpolation to "
+ "the logging function by passing the parameters as arguments. "
+ "If logging-fstring-interpolation is disabled then "
+ "you can use fstring formatting. "
+ "If logging-format-interpolation is disabled then "
+ "you can use str.format.",
+ ),
+ "W1202": (
+ "Use %s formatting in logging functions",
+ "logging-format-interpolation",
+ "Used when a logging statement has a call form of "
+ '"logging.<logging method>(format_string.format(format_args...))". '
+ "Use another type of string formatting instead. "
+ "You can use % formatting but leave interpolation to "
+ "the logging function by passing the parameters as arguments. "
+ "If logging-fstring-interpolation is disabled then "
+ "you can use fstring formatting. "
+ "If logging-not-lazy is disabled then "
+ "you can use % formatting as normal.",
+ ),
+ "W1203": (
+ "Use %s formatting in logging functions",
+ "logging-fstring-interpolation",
+ "Used when a logging statement has a call form of "
+ '"logging.<logging method>(f"...")".'
+ "Use another type of string formatting instead. "
+ "You can use % formatting but leave interpolation to "
+ "the logging function by passing the parameters as arguments. "
+ "If logging-format-interpolation is disabled then "
+ "you can use str.format. "
+ "If logging-not-lazy is disabled then "
+ "you can use % formatting as normal.",
+ ),
+ "E1200": (
+ "Unsupported logging format character %r (%#02x) at index %d",
+ "logging-unsupported-format",
+ "Used when an unsupported format character is used in a logging "
+ "statement format string.",
+ ),
+ "E1201": (
+ "Logging format string ends in middle of conversion specifier",
+ "logging-format-truncated",
+ "Used when a logging statement format string terminates before "
+ "the end of a conversion specifier.",
+ ),
+ "E1205": (
+ "Too many arguments for logging format string",
+ "logging-too-many-args",
+ "Used when a logging format string is given too many arguments.",
+ ),
+ "E1206": (
+ "Not enough arguments for logging format string",
+ "logging-too-few-args",
+ "Used when a logging format string is given too few arguments.",
+ ),
+}
+
+
+CHECKED_CONVENIENCE_FUNCTIONS = {
+ "critical",
+ "debug",
+ "error",
+ "exception",
+ "fatal",
+ "info",
+ "warn",
+ "warning",
+}
+
+
+def is_method_call(func, types=(), methods=()):
+ """Determines if a BoundMethod node represents a method call.
+
+ Args:
+ func (astroid.BoundMethod): The BoundMethod AST node to check.
+ types (Optional[String]): Optional sequence of caller type names to restrict check.
+ methods (Optional[String]): Optional sequence of method names to restrict check.
+
+ Returns:
+ bool: true if the node represents a method call for the given type and
+ method names, False otherwise.
+ """
+ return (
+ isinstance(func, astroid.BoundMethod)
+ and isinstance(func.bound, astroid.Instance)
+ and (func.bound.name in types if types else True)
+ and (func.name in methods if methods else True)
+ )
+
+
+class LoggingChecker(checkers.BaseChecker):
+ """Checks use of the logging module."""
+
+ __implements__ = interfaces.IAstroidChecker
+ name = "logging"
+ msgs = MSGS
+
+ options = (
+ (
+ "logging-modules",
+ {
+ "default": ("logging",),
+ "type": "csv",
+ "metavar": "<comma separated list>",
+ "help": "Logging modules to check that the string format "
+ "arguments are in logging function parameter format.",
+ },
+ ),
+ (
+ "logging-format-style",
+ {
+ "default": "old",
+ "type": "choice",
+ "metavar": "<old (%) or new ({)>",
+ "choices": ["old", "new"],
+ "help": "The type of string formatting that logging methods do. "
+ "`old` means using % formatting, `new` is for `{}` formatting.",
+ },
+ ),
+ )
+
+ def visit_module(self, node): # pylint: disable=unused-argument
+ """Clears any state left in this checker from last module checked."""
+ # The code being checked can just as easily "import logging as foo",
+ # so it is necessary to process the imports and store in this field
+ # what name the logging module is actually given.
+ self._logging_names = set()
+ logging_mods = self.config.logging_modules
+
+ self._format_style = self.config.logging_format_style
+
+ self._logging_modules = set(logging_mods)
+ self._from_imports = {}
+ for logging_mod in logging_mods:
+ parts = logging_mod.rsplit(".", 1)
+ if len(parts) > 1:
+ self._from_imports[parts[0]] = parts[1]
+
+ def visit_importfrom(self, node):
+ """Checks to see if a module uses a non-Python logging module."""
+ try:
+ logging_name = self._from_imports[node.modname]
+ for module, as_name in node.names:
+ if module == logging_name:
+ self._logging_names.add(as_name or module)
+ except KeyError:
+ pass
+
+ def visit_import(self, node):
+ """Checks to see if this module uses Python's built-in logging."""
+ for module, as_name in node.names:
+ if module in self._logging_modules:
+ self._logging_names.add(as_name or module)
+
+ @check_messages(*MSGS)
+ def visit_call(self, node):
+ """Checks calls to logging methods."""
+
+ def is_logging_name():
+ return (
+ isinstance(node.func, astroid.Attribute)
+ and isinstance(node.func.expr, astroid.Name)
+ and node.func.expr.name in self._logging_names
+ )
+
+ def is_logger_class():
+ try:
+ for inferred in node.func.infer():
+ if isinstance(inferred, astroid.BoundMethod):
+ parent = inferred._proxied.parent
+ if isinstance(parent, astroid.ClassDef) and (
+ parent.qname() == "logging.Logger"
+ or any(
+ ancestor.qname() == "logging.Logger"
+ for ancestor in parent.ancestors()
+ )
+ ):
+ return True, inferred._proxied.name
+ except astroid.exceptions.InferenceError:
+ pass
+ return False, None
+
+ if is_logging_name():
+ name = node.func.attrname
+ else:
+ result, name = is_logger_class()
+ if not result:
+ return
+ self._check_log_method(node, name)
+
+ def _check_log_method(self, node, name):
+ """Checks calls to logging.log(level, format, *format_args)."""
+ if name == "log":
+ if node.starargs or node.kwargs or len(node.args) < 2:
+ # Either a malformed call, star args, or double-star args. Beyond
+ # the scope of this checker.
+ return
+ format_pos = 1
+ elif name in CHECKED_CONVENIENCE_FUNCTIONS:
+ if node.starargs or node.kwargs or not node.args:
+ # Either no args, star args, or double-star args. Beyond the
+ # scope of this checker.
+ return
+ format_pos = 0
+ else:
+ return
+
+ if isinstance(node.args[format_pos], astroid.BinOp):
+ binop = node.args[format_pos]
+ emit = binop.op == "%"
+ if binop.op == "+":
+ total_number_of_strings = sum(
+ 1
+ for operand in (binop.left, binop.right)
+ if self._is_operand_literal_str(utils.safe_infer(operand))
+ )
+ emit = total_number_of_strings > 0
+ if emit:
+ self.add_message(
+ "logging-not-lazy",
+ node=node,
+ args=(self._helper_string(node),),
+ )
+ elif isinstance(node.args[format_pos], astroid.Call):
+ self._check_call_func(node.args[format_pos])
+ elif isinstance(node.args[format_pos], astroid.Const):
+ self._check_format_string(node, format_pos)
+ elif isinstance(node.args[format_pos], astroid.JoinedStr):
+ self.add_message(
+ "logging-fstring-interpolation",
+ node=node,
+ args=(self._helper_string(node),),
+ )
+
+ def _helper_string(self, node):
+ """Create a string that lists the valid types of formatting for this node."""
+ valid_types = ["lazy %"]
+
+ if not self.linter.is_message_enabled(
+ "logging-fstring-formatting", node.fromlineno
+ ):
+ valid_types.append("fstring")
+ if not self.linter.is_message_enabled(
+ "logging-format-interpolation", node.fromlineno
+ ):
+ valid_types.append(".format()")
+ if not self.linter.is_message_enabled("logging-not-lazy", node.fromlineno):
+ valid_types.append("%")
+
+ return " or ".join(valid_types)
+
+ @staticmethod
+ def _is_operand_literal_str(operand):
+ """
+ Return True if the operand in argument is a literal string
+ """
+ return isinstance(operand, astroid.Const) and operand.name == "str"
+
+ def _check_call_func(self, node):
+ """Checks that function call is not format_string.format().
+
+ Args:
+ node (astroid.node_classes.Call):
+ Call AST node to be checked.
+ """
+ func = utils.safe_infer(node.func)
+ types = ("str", "unicode")
+ methods = ("format",)
+ if is_method_call(func, types, methods) and not is_complex_format_str(
+ func.bound
+ ):
+ self.add_message(
+ "logging-format-interpolation",
+ node=node,
+ args=(self._helper_string(node),),
+ )
+
+ def _check_format_string(self, node, format_arg):
+ """Checks that format string tokens match the supplied arguments.
+
+ Args:
+ node (astroid.node_classes.NodeNG): AST node to be checked.
+ format_arg (int): Index of the format string in the node arguments.
+ """
+ num_args = _count_supplied_tokens(node.args[format_arg + 1 :])
+ if not num_args:
+ # If no args were supplied the string is not interpolated and can contain
+ # formatting characters - it's used verbatim. Don't check any further.
+ return
+
+ format_string = node.args[format_arg].value
+ required_num_args = 0
+ if isinstance(format_string, bytes):
+ format_string = format_string.decode()
+ if isinstance(format_string, str):
+ try:
+ if self._format_style == "old":
+ keyword_args, required_num_args, _, _ = utils.parse_format_string(
+ format_string
+ )
+ if keyword_args:
+ # Keyword checking on logging strings is complicated by
+ # special keywords - out of scope.
+ return
+ elif self._format_style == "new":
+ (
+ keyword_arguments,
+ implicit_pos_args,
+ explicit_pos_args,
+ ) = utils.parse_format_method_string(format_string)
+
+ keyword_args_cnt = len(
+ {k for k, l in keyword_arguments if not isinstance(k, int)}
+ )
+ required_num_args = (
+ keyword_args_cnt + implicit_pos_args + explicit_pos_args
+ )
+ except utils.UnsupportedFormatCharacter as ex:
+ char = format_string[ex.index]
+ self.add_message(
+ "logging-unsupported-format",
+ node=node,
+ args=(char, ord(char), ex.index),
+ )
+ return
+ except utils.IncompleteFormatString:
+ self.add_message("logging-format-truncated", node=node)
+ return
+ if num_args > required_num_args:
+ self.add_message("logging-too-many-args", node=node)
+ elif num_args < required_num_args:
+ self.add_message("logging-too-few-args", node=node)
+
+
+def is_complex_format_str(node):
+ """Checks if node represents a string with complex formatting specs.
+
+ Args:
+ node (astroid.node_classes.NodeNG): AST node to check
+ Returns:
+ bool: True if inferred string uses complex formatting, False otherwise
+ """
+ inferred = utils.safe_infer(node)
+ if inferred is None or not (
+ isinstance(inferred, astroid.Const) and isinstance(inferred.value, str)
+ ):
+ return True
+ try:
+ parsed = list(string.Formatter().parse(inferred.value))
+ except ValueError:
+ # This format string is invalid
+ return False
+ for _, _, format_spec, _ in parsed:
+ if format_spec:
+ return True
+ return False
+
+
+def _count_supplied_tokens(args):
+ """Counts the number of tokens in an args list.
+
+ The Python log functions allow for special keyword arguments: func,
+ exc_info and extra. To handle these cases correctly, we only count
+ arguments that aren't keywords.
+
+ Args:
+ args (list): AST nodes that are arguments for a log format string.
+
+ Returns:
+ int: Number of AST nodes that aren't keywords.
+ """
+ return sum(1 for arg in args if not isinstance(arg, astroid.Keyword))
+
+
+def register(linter):
+ """Required method to auto-register this checker."""
+ linter.register_checker(LoggingChecker(linter))
diff --git a/pylint/checkers/mapreduce_checker.py b/pylint/checkers/mapreduce_checker.py
new file mode 100644
index 0000000..36cc012
--- /dev/null
+++ b/pylint/checkers/mapreduce_checker.py
@@ -0,0 +1,20 @@
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+import abc
+
+
+class MapReduceMixin(metaclass=abc.ABCMeta):
+ """A mixin design to allow multiprocess/threaded runs of a Checker"""
+
+ @abc.abstractmethod
+ def get_map_data(self):
+ """Returns mergable/reducible data that will be examined"""
+
+ @classmethod
+ @abc.abstractmethod
+ def reduce_map_data(cls, linter, data):
+ """For a given Checker, receives data for all mapped runs"""
diff --git a/pylint/checkers/misc.py b/pylint/checkers/misc.py
new file mode 100644
index 0000000..4ae912f
--- /dev/null
+++ b/pylint/checkers/misc.py
@@ -0,0 +1,187 @@
+# Copyright (c) 2006, 2009-2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Alexandru Coman <fcoman@bitdefender.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 glegoux <gilles.legoux@gmail.com>
+# Copyright (c) 2017-2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Mikhail Fesenko <proggga@gmail.com>
+# Copyright (c) 2018 Rogalski, Lukasz <lukasz.rogalski@intel.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 wtracy <afishionado@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2020 Benny <benny.mueller91@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Konstantina Saketou <56515303+ksaketou@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+"""Check source code is ascii only or has an encoding declaration (PEP 263)"""
+
+import re
+import tokenize
+
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IRawChecker, ITokenChecker
+from pylint.message import MessagesHandlerMixIn
+from pylint.utils.pragma_parser import OPTION_PO, PragmaParserError, parse_pragma
+
+
+class ByIdManagedMessagesChecker(BaseChecker):
+
+ """Checks for messages that are enabled or disabled by id instead of symbol."""
+
+ __implements__ = IRawChecker
+ name = "miscellaneous"
+ msgs = {
+ "I0023": (
+ "%s",
+ "use-symbolic-message-instead",
+ "Used when a message is enabled or disabled by id.",
+ )
+ }
+ options = ()
+
+ def process_module(self, module):
+ """Inspect the source file to find messages activated or deactivated by id."""
+ managed_msgs = MessagesHandlerMixIn.get_by_id_managed_msgs()
+ for (mod_name, msgid, symbol, lineno, is_disabled) in managed_msgs:
+ if mod_name == module.name:
+ verb = "disable" if is_disabled else "enable"
+ txt = f"'{msgid}' is cryptic: use '# pylint: {verb}={symbol}' instead"
+ self.add_message("use-symbolic-message-instead", line=lineno, args=txt)
+ MessagesHandlerMixIn.clear_by_id_managed_msgs()
+
+
+class EncodingChecker(BaseChecker):
+
+ """checks for:
+ * warning notes in the code like FIXME, XXX
+ * encoding issues.
+ """
+
+ __implements__ = (IRawChecker, ITokenChecker)
+
+ # configuration section name
+ name = "miscellaneous"
+ msgs = {
+ "W0511": (
+ "%s",
+ "fixme",
+ "Used when a warning note as FIXME or XXX is detected.",
+ )
+ }
+
+ options = (
+ (
+ "notes",
+ {
+ "type": "csv",
+ "metavar": "<comma separated values>",
+ "default": ("FIXME", "XXX", "TODO"),
+ "help": (
+ "List of note tags to take in consideration, "
+ "separated by a comma."
+ ),
+ },
+ ),
+ (
+ "notes-rgx",
+ {
+ "type": "string",
+ "metavar": "<regexp>",
+ "help": "Regular expression of note tags to take in consideration.",
+ },
+ ),
+ )
+
+ def open(self):
+ super().open()
+
+ notes = "|".join(re.escape(note) for note in self.config.notes)
+ if self.config.notes_rgx:
+ regex_string = fr"#\s*({notes}|{self.config.notes_rgx})\b"
+ else:
+ regex_string = r"#\s*(%s)\b" % (notes)
+
+ self._fixme_pattern = re.compile(regex_string, re.I)
+
+ def _check_encoding(self, lineno, line, file_encoding):
+ try:
+ return line.decode(file_encoding)
+ except UnicodeDecodeError:
+ pass
+ except LookupError:
+ if line.startswith("#") and "coding" in line and file_encoding in line:
+ msg = f"Cannot decode using encoding '{file_encoding}', bad encoding"
+ self.add_message("syntax-error", line=lineno, args=msg)
+ return None
+
+ def process_module(self, module):
+ """inspect the source file to find encoding problem"""
+ if module.file_encoding:
+ encoding = module.file_encoding
+ else:
+ encoding = "ascii"
+
+ with module.stream() as stream:
+ for lineno, line in enumerate(stream):
+ self._check_encoding(lineno + 1, line, encoding)
+
+ def process_tokens(self, tokens):
+ """inspect the source to find fixme problems"""
+ if not self.config.notes:
+ return
+ comments = (
+ token_info for token_info in tokens if token_info.type == tokenize.COMMENT
+ )
+ for comment in comments:
+ comment_text = comment.string[1:].lstrip() # trim '#' and whitespaces
+
+ # handle pylint disable clauses
+ disable_option_match = OPTION_PO.search(comment_text)
+ if disable_option_match:
+ try:
+ values = []
+ try:
+ for pragma_repr in (
+ p_rep
+ for p_rep in parse_pragma(disable_option_match.group(2))
+ if p_rep.action == "disable"
+ ):
+ values.extend(pragma_repr.messages)
+ except PragmaParserError:
+ # Printing useful information dealing with this error is done in the lint package
+ pass
+ if set(values) & set(self.config.notes):
+ continue
+ except ValueError:
+ self.add_message(
+ "bad-inline-option",
+ args=disable_option_match.group(1).strip(),
+ line=comment.start[0],
+ )
+ continue
+
+ # emit warnings if necessary
+ match = self._fixme_pattern.search("#" + comment_text.lower())
+ if match:
+ self.add_message(
+ "fixme",
+ col_offset=comment.start[1] + 1,
+ args=comment_text,
+ line=comment.start[0],
+ )
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(EncodingChecker(linter))
+ linter.register_checker(ByIdManagedMessagesChecker(linter))
diff --git a/pylint/checkers/newstyle.py b/pylint/checkers/newstyle.py
new file mode 100644
index 0000000..0c33446
--- /dev/null
+++ b/pylint/checkers/newstyle.py
@@ -0,0 +1,135 @@
+# Copyright (c) 2006, 2008-2011, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2016 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Natalie Serebryakova <natalie.serebryakova@Natalies-MacBook-Pro.local>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Robert Schweizer <robert_schweizer@gmx.de>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""check for new / old style related problems
+"""
+import astroid
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages, has_known_bases, node_frame_class
+from pylint.interfaces import IAstroidChecker
+
+MSGS = {
+ "E1003": (
+ "Bad first argument %r given to super()",
+ "bad-super-call",
+ "Used when another argument than the current class is given as "
+ "first argument of the super builtin.",
+ )
+}
+
+
+class NewStyleConflictChecker(BaseChecker):
+ """checks for usage of new style capabilities on old style classes and
+ other new/old styles conflicts problems
+ * use of property, __slots__, super
+ * "super" usage
+ """
+
+ __implements__ = (IAstroidChecker,)
+
+ # configuration section name
+ name = "newstyle"
+ # messages
+ msgs = MSGS
+ priority = -2
+ # configuration options
+ options = ()
+
+ @check_messages("bad-super-call")
+ def visit_functiondef(self, node):
+ """check use of super"""
+ # ignore actual functions or method within a new style class
+ if not node.is_method():
+ return
+ klass = node.parent.frame()
+ for stmt in node.nodes_of_class(astroid.Call):
+ if node_frame_class(stmt) != node_frame_class(node):
+ # Don't look down in other scopes.
+ continue
+
+ expr = stmt.func
+ if not isinstance(expr, astroid.Attribute):
+ continue
+
+ call = expr.expr
+ # skip the test if using super
+ if not (
+ isinstance(call, astroid.Call)
+ and isinstance(call.func, astroid.Name)
+ and call.func.name == "super"
+ ):
+ continue
+
+ # super should not be used on an old style class
+ if klass.newstyle or not has_known_bases(klass):
+ # super first arg should not be the class
+ if not call.args:
+ continue
+
+ # calling super(type(self), self) can lead to recursion loop
+ # in derived classes
+ arg0 = call.args[0]
+ if (
+ isinstance(arg0, astroid.Call)
+ and isinstance(arg0.func, astroid.Name)
+ and arg0.func.name == "type"
+ ):
+ self.add_message("bad-super-call", node=call, args=("type",))
+ continue
+
+ # calling super(self.__class__, self) can lead to recursion loop
+ # in derived classes
+ if (
+ len(call.args) >= 2
+ and isinstance(call.args[1], astroid.Name)
+ and call.args[1].name == "self"
+ and isinstance(arg0, astroid.Attribute)
+ and arg0.attrname == "__class__"
+ ):
+ self.add_message(
+ "bad-super-call", node=call, args=("self.__class__",)
+ )
+ continue
+
+ try:
+ supcls = call.args and next(call.args[0].infer(), None)
+ except astroid.InferenceError:
+ continue
+
+ if klass is not supcls:
+ name = None
+ # if supcls is not Uninferable, then supcls was inferred
+ # and use its name. Otherwise, try to look
+ # for call.args[0].name
+ if supcls:
+ name = supcls.name
+ elif call.args and hasattr(call.args[0], "name"):
+ name = call.args[0].name
+ if name:
+ self.add_message("bad-super-call", node=call, args=(name,))
+
+ visit_asyncfunctiondef = visit_functiondef
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(NewStyleConflictChecker(linter))
diff --git a/pylint/checkers/python3.py b/pylint/checkers/python3.py
new file mode 100644
index 0000000..53b7534
--- /dev/null
+++ b/pylint/checkers/python3.py
@@ -0,0 +1,1433 @@
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014-2015 Brett Cannon <brett@python.org>
+# Copyright (c) 2015 Simu Toni <simutoni@gmail.com>
+# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2015 Cosmin Poieana <cmin@ropython.org>
+# Copyright (c) 2015 Viorel Stirbu <viorels@gmail.com>
+# Copyright (c) 2016, 2018 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2016-2017 Roy Williams <roy.williams.iii@gmail.com>
+# Copyright (c) 2016 Roy Williams <rwilliams@lyft.com>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Erik <erik.eriksson@yahoo.com>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017-2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2017 Daniel Miller <millerdev@gmail.com>
+# Copyright (c) 2017 ahirnish <ahirnish@gmail.com>
+# Copyright (c) 2018-2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 sbagan <pnlbagan@gmail.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Aivar Annamaa <aivarannamaa@users.noreply.github.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2018 gaurikholkar <f2013002@goa.bits-pilani.ac.in>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2019 Hugues Bruant <hugues.bruant@affirm.com>
+# Copyright (c) 2019 Gabriel R Sezefredo <gabriel@sezefredo.com.br>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 bluesheeptoken <louis.fruleux1@gmail.com>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 谭九鼎 <109224573@qq.com>
+# Copyright (c) 2020 Federico Bond <federicobond@gmail.com>
+# Copyright (c) 2020 Athos Ribeiro <athoscr@fedoraproject.org>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 bot <bot@noreply.github.com>
+# Copyright (c) 2021 Tiago Honorato <tiagohonorato1@gmail.com>
+# Copyright (c) 2021 tiagohonorato <61059243+tiagohonorato@users.noreply.github.com>
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Check Python 2 code for Python 2/3 source-compatible issues."""
+import itertools
+import re
+import tokenize
+from collections import namedtuple
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.checkers.utils import find_try_except_wrapper_node, node_ignores_exception
+from pylint.constants import WarningScope
+from pylint.interfaces import INFERENCE, INFERENCE_FAILURE
+
+_ZERO = re.compile("^0+$")
+
+
+def _is_old_octal(literal):
+ if _ZERO.match(literal):
+ return False
+ if re.match(r"0\d+", literal):
+ try:
+ int(literal, 8)
+ except ValueError:
+ return False
+ return True
+ return None
+
+
+def _inferred_value_is_dict(value):
+ if isinstance(value, astroid.Dict):
+ return True
+ return isinstance(value, astroid.Instance) and "dict" in value.basenames
+
+
+def _infer_if_relevant_attr(node, relevant_attrs):
+ return node.expr.infer() if node.attrname in relevant_attrs else []
+
+
+def _is_builtin(node):
+ return getattr(node, "name", None) in ("__builtin__", "builtins")
+
+
+_ACCEPTS_ITERATOR = {
+ "iter",
+ "list",
+ "tuple",
+ "sorted",
+ "set",
+ "sum",
+ "any",
+ "all",
+ "enumerate",
+ "dict",
+ "filter",
+ "reversed",
+ "max",
+ "min",
+ "frozenset",
+ "OrderedDict",
+ "zip",
+ "map",
+}
+ATTRIBUTES_ACCEPTS_ITERATOR = {"join", "from_iterable"}
+_BUILTIN_METHOD_ACCEPTS_ITERATOR = {
+ "builtins.list.extend",
+ "builtins.dict.update",
+ "builtins.set.update",
+}
+DICT_METHODS = {"items", "keys", "values"}
+
+
+def _in_iterating_context(node):
+ """Check if the node is being used as an iterator.
+
+ Definition is taken from lib2to3.fixer_util.in_special_context().
+ """
+ parent = node.parent
+ # Since a call can't be the loop variant we only need to know if the node's
+ # parent is a 'for' loop to know it's being used as the iterator for the
+ # loop.
+ if isinstance(parent, astroid.For):
+ return True
+ # Need to make sure the use of the node is in the iterator part of the
+ # comprehension.
+ if isinstance(parent, astroid.Comprehension):
+ if parent.iter == node:
+ return True
+ # Various built-ins can take in an iterable or list and lead to the same
+ # value.
+ elif isinstance(parent, astroid.Call):
+ if isinstance(parent.func, astroid.Name):
+ if parent.func.name in _ACCEPTS_ITERATOR:
+ return True
+ elif isinstance(parent.func, astroid.Attribute):
+ if parent.func.attrname in ATTRIBUTES_ACCEPTS_ITERATOR:
+ return True
+
+ inferred = utils.safe_infer(parent.func)
+ if inferred:
+ if inferred.qname() in _BUILTIN_METHOD_ACCEPTS_ITERATOR:
+ return True
+ root = inferred.root()
+ if root and root.name == "itertools":
+ return True
+ # If the call is in an unpacking, there's no need to warn,
+ # since it can be considered iterating.
+ elif isinstance(parent, astroid.Assign) and isinstance(
+ parent.targets[0], (astroid.List, astroid.Tuple)
+ ):
+ if len(parent.targets[0].elts) > 1:
+ return True
+ # If the call is in a containment check, we consider that to
+ # be an iterating context
+ elif (
+ isinstance(parent, astroid.Compare)
+ and len(parent.ops) == 1
+ and parent.ops[0][0] in ["in", "not in"]
+ ):
+ return True
+ # Also if it's an `yield from`, that's fair
+ elif isinstance(parent, astroid.YieldFrom):
+ return True
+ if isinstance(parent, astroid.Starred):
+ return True
+ return False
+
+
+def _is_conditional_import(node):
+ """Checks if an import node is in the context of a conditional."""
+ parent = node.parent
+ return isinstance(
+ parent, (astroid.TryExcept, astroid.ExceptHandler, astroid.If, astroid.IfExp)
+ )
+
+
+Branch = namedtuple("Branch", ["node", "is_py2_only"])
+
+
+class Python3Checker(checkers.BaseChecker):
+
+ __implements__ = interfaces.IAstroidChecker
+ enabled = False
+ name = "python3"
+
+ msgs = {
+ # Errors for what will syntactically break in Python 3, warnings for
+ # everything else.
+ "E1601": (
+ "print statement used",
+ "print-statement",
+ "Used when a print statement is used "
+ "(`print` is a function in Python 3)",
+ ),
+ "E1602": (
+ "Parameter unpacking specified",
+ "parameter-unpacking",
+ "Used when parameter unpacking is specified for a function"
+ "(Python 3 doesn't allow it)",
+ ),
+ "E1603": (
+ "Implicit unpacking of exceptions is not supported in Python 3",
+ "unpacking-in-except",
+ "Python3 will not allow implicit unpacking of "
+ "exceptions in except clauses. "
+ "See https://www.python.org/dev/peps/pep-3110/",
+ {"old_names": [("W0712", "old-unpacking-in-except")]},
+ ),
+ "E1604": (
+ "Use raise ErrorClass(args) instead of raise ErrorClass, args.",
+ "old-raise-syntax",
+ "Used when the alternate raise syntax "
+ "'raise foo, bar' is used "
+ "instead of 'raise foo(bar)'.",
+ {"old_names": [("W0121", "old-old-raise-syntax")]},
+ ),
+ "E1605": (
+ "Use of the `` operator",
+ "backtick",
+ 'Used when the deprecated "``" (backtick) operator is used '
+ "instead of the str() function.",
+ {"scope": WarningScope.NODE, "old_names": [("W0333", "old-backtick")]},
+ ),
+ "E1609": (
+ "Import * only allowed at module level",
+ "import-star-module-level",
+ "Used when the import star syntax is used somewhere "
+ "else than the module level.",
+ {"maxversion": (3, 0)},
+ ),
+ "W1601": (
+ "apply built-in referenced",
+ "apply-builtin",
+ "Used when the apply built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1602": (
+ "basestring built-in referenced",
+ "basestring-builtin",
+ "Used when the basestring built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1603": (
+ "buffer built-in referenced",
+ "buffer-builtin",
+ "Used when the buffer built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1604": (
+ "cmp built-in referenced",
+ "cmp-builtin",
+ "Used when the cmp built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1605": (
+ "coerce built-in referenced",
+ "coerce-builtin",
+ "Used when the coerce built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1606": (
+ "execfile built-in referenced",
+ "execfile-builtin",
+ "Used when the execfile built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1607": (
+ "file built-in referenced",
+ "file-builtin",
+ "Used when the file built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1608": (
+ "long built-in referenced",
+ "long-builtin",
+ "Used when the long built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1609": (
+ "raw_input built-in referenced",
+ "raw_input-builtin",
+ "Used when the raw_input built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1610": (
+ "reduce built-in referenced",
+ "reduce-builtin",
+ "Used when the reduce built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1611": (
+ "StandardError built-in referenced",
+ "standarderror-builtin",
+ "Used when the StandardError built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1612": (
+ "unicode built-in referenced",
+ "unicode-builtin",
+ "Used when the unicode built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1613": (
+ "xrange built-in referenced",
+ "xrange-builtin",
+ "Used when the xrange built-in function is referenced "
+ "(missing from Python 3)",
+ ),
+ "W1614": (
+ "__coerce__ method defined",
+ "coerce-method",
+ "Used when a __coerce__ method is defined "
+ "(method is not used by Python 3)",
+ ),
+ "W1615": (
+ "__delslice__ method defined",
+ "delslice-method",
+ "Used when a __delslice__ method is defined "
+ "(method is not used by Python 3)",
+ ),
+ "W1616": (
+ "__getslice__ method defined",
+ "getslice-method",
+ "Used when a __getslice__ method is defined "
+ "(method is not used by Python 3)",
+ ),
+ "W1617": (
+ "__setslice__ method defined",
+ "setslice-method",
+ "Used when a __setslice__ method is defined "
+ "(method is not used by Python 3)",
+ ),
+ "W1618": (
+ "import missing `from __future__ import absolute_import`",
+ "no-absolute-import",
+ "Used when an import is not accompanied by "
+ "``from __future__ import absolute_import`` "
+ "(default behaviour in Python 3)",
+ ),
+ "W1619": (
+ "division w/o __future__ statement",
+ "old-division",
+ "Used for non-floor division w/o a float literal or "
+ "``from __future__ import division`` "
+ "(Python 3 returns a float for int division unconditionally)",
+ ),
+ "W1620": (
+ "Calling a dict.iter*() method",
+ "dict-iter-method",
+ "Used for calls to dict.iterkeys(), itervalues() or iteritems() "
+ "(Python 3 lacks these methods)",
+ ),
+ "W1621": (
+ "Calling a dict.view*() method",
+ "dict-view-method",
+ "Used for calls to dict.viewkeys(), viewvalues() or viewitems() "
+ "(Python 3 lacks these methods)",
+ ),
+ "W1622": (
+ "Called a next() method on an object",
+ "next-method-called",
+ "Used when an object's next() method is called "
+ "(Python 3 uses the next() built-in function)",
+ ),
+ "W1623": (
+ "Assigning to a class's __metaclass__ attribute",
+ "metaclass-assignment",
+ "Used when a metaclass is specified by assigning to __metaclass__ "
+ "(Python 3 specifies the metaclass as a class statement argument)",
+ ),
+ "W1624": (
+ "Indexing exceptions will not work on Python 3",
+ "indexing-exception",
+ "Indexing exceptions will not work on Python 3. Use "
+ "`exception.args[index]` instead.",
+ {"old_names": [("W0713", "old-indexing-exception")]},
+ ),
+ "W1625": (
+ "Raising a string exception",
+ "raising-string",
+ "Used when a string exception is raised. This will not "
+ "work on Python 3.",
+ {"old_names": [("W0701", "old-raising-string")]},
+ ),
+ "W1626": (
+ "reload built-in referenced",
+ "reload-builtin",
+ "Used when the reload built-in function is referenced "
+ "(missing from Python 3). You can use instead imp.reload "
+ "or importlib.reload.",
+ ),
+ "W1627": (
+ "__oct__ method defined",
+ "oct-method",
+ "Used when an __oct__ method is defined "
+ "(method is not used by Python 3)",
+ ),
+ "W1628": (
+ "__hex__ method defined",
+ "hex-method",
+ "Used when a __hex__ method is defined (method is not used by Python 3)",
+ ),
+ "W1629": (
+ "__nonzero__ method defined",
+ "nonzero-method",
+ "Used when a __nonzero__ method is defined "
+ "(method is not used by Python 3)",
+ ),
+ "W1630": (
+ "__cmp__ method defined",
+ "cmp-method",
+ "Used when a __cmp__ method is defined (method is not used by Python 3)",
+ ),
+ # 'W1631': replaced by W1636
+ "W1632": (
+ "input built-in referenced",
+ "input-builtin",
+ "Used when the input built-in is referenced "
+ "(backwards-incompatible semantics in Python 3)",
+ ),
+ "W1633": (
+ "round built-in referenced",
+ "round-builtin",
+ "Used when the round built-in is referenced "
+ "(backwards-incompatible semantics in Python 3)",
+ ),
+ "W1634": (
+ "intern built-in referenced",
+ "intern-builtin",
+ "Used when the intern built-in is referenced "
+ "(Moved to sys.intern in Python 3)",
+ ),
+ "W1635": (
+ "unichr built-in referenced",
+ "unichr-builtin",
+ "Used when the unichr built-in is referenced (Use chr in Python 3)",
+ ),
+ "W1636": (
+ "map built-in referenced when not iterating",
+ "map-builtin-not-iterating",
+ "Used when the map built-in is referenced in a non-iterating "
+ "context (returns an iterator in Python 3)",
+ {"old_names": [("W1631", "implicit-map-evaluation")]},
+ ),
+ "W1637": (
+ "zip built-in referenced when not iterating",
+ "zip-builtin-not-iterating",
+ "Used when the zip built-in is referenced in a non-iterating "
+ "context (returns an iterator in Python 3)",
+ ),
+ "W1638": (
+ "range built-in referenced when not iterating",
+ "range-builtin-not-iterating",
+ "Used when the range built-in is referenced in a non-iterating "
+ "context (returns a range in Python 3)",
+ ),
+ "W1639": (
+ "filter built-in referenced when not iterating",
+ "filter-builtin-not-iterating",
+ "Used when the filter built-in is referenced in a non-iterating "
+ "context (returns an iterator in Python 3)",
+ ),
+ "W1640": (
+ "Using the cmp argument for list.sort / sorted",
+ "using-cmp-argument",
+ "Using the cmp argument for list.sort or the sorted "
+ "builtin should be avoided, since it was removed in "
+ "Python 3. Using either `key` or `functools.cmp_to_key` "
+ "should be preferred.",
+ ),
+ "W1641": (
+ "Implementing __eq__ without also implementing __hash__",
+ "eq-without-hash",
+ "Used when a class implements __eq__ but not __hash__. In Python 2, objects "
+ "get object.__hash__ as the default implementation, in Python 3 objects get "
+ "None as their default __hash__ implementation if they also implement __eq__.",
+ ),
+ "W1642": (
+ "__div__ method defined",
+ "div-method",
+ "Used when a __div__ method is defined. Using `__truediv__` and setting"
+ "__div__ = __truediv__ should be preferred."
+ "(method is not used by Python 3)",
+ ),
+ "W1643": (
+ "__idiv__ method defined",
+ "idiv-method",
+ "Used when an __idiv__ method is defined. Using `__itruediv__` and setting"
+ "__idiv__ = __itruediv__ should be preferred."
+ "(method is not used by Python 3)",
+ ),
+ "W1644": (
+ "__rdiv__ method defined",
+ "rdiv-method",
+ "Used when a __rdiv__ method is defined. Using `__rtruediv__` and setting"
+ "__rdiv__ = __rtruediv__ should be preferred."
+ "(method is not used by Python 3)",
+ ),
+ "W1645": (
+ "Exception.message removed in Python 3",
+ "exception-message-attribute",
+ "Used when the message attribute is accessed on an Exception. Use "
+ "str(exception) instead.",
+ ),
+ "W1646": (
+ "non-text encoding used in str.decode",
+ "invalid-str-codec",
+ "Used when using str.encode or str.decode with a non-text encoding. Use "
+ "codecs module to handle arbitrary codecs.",
+ ),
+ "W1647": (
+ "sys.maxint removed in Python 3",
+ "sys-max-int",
+ "Used when accessing sys.maxint. Use sys.maxsize instead.",
+ ),
+ "W1648": (
+ "Module moved in Python 3",
+ "bad-python3-import",
+ "Used when importing a module that no longer exists in Python 3.",
+ ),
+ "W1649": (
+ "Accessing a deprecated function on the string module",
+ "deprecated-string-function",
+ "Used when accessing a string function that has been deprecated in Python 3.",
+ ),
+ "W1650": (
+ "Using str.translate with deprecated deletechars parameters",
+ "deprecated-str-translate-call",
+ "Used when using the deprecated deletechars parameters from str.translate. Use "
+ "re.sub to remove the desired characters ",
+ ),
+ "W1651": (
+ "Accessing a deprecated function on the itertools module",
+ "deprecated-itertools-function",
+ "Used when accessing a function on itertools that has been removed in Python 3.",
+ ),
+ "W1652": (
+ "Accessing a deprecated fields on the types module",
+ "deprecated-types-field",
+ "Used when accessing a field on types that has been removed in Python 3.",
+ ),
+ "W1653": (
+ "next method defined",
+ "next-method-defined",
+ "Used when a next method is defined that would be an iterator in Python 2 but "
+ "is treated as a normal function in Python 3.",
+ ),
+ "W1654": (
+ "dict.items referenced when not iterating",
+ "dict-items-not-iterating",
+ "Used when dict.items is referenced in a non-iterating "
+ "context (returns an iterator in Python 3)",
+ ),
+ "W1655": (
+ "dict.keys referenced when not iterating",
+ "dict-keys-not-iterating",
+ "Used when dict.keys is referenced in a non-iterating "
+ "context (returns an iterator in Python 3)",
+ ),
+ "W1656": (
+ "dict.values referenced when not iterating",
+ "dict-values-not-iterating",
+ "Used when dict.values is referenced in a non-iterating "
+ "context (returns an iterator in Python 3)",
+ ),
+ "W1657": (
+ "Accessing a removed attribute on the operator module",
+ "deprecated-operator-function",
+ "Used when accessing a field on operator module that has been "
+ "removed in Python 3.",
+ ),
+ "W1658": (
+ "Accessing a removed attribute on the urllib module",
+ "deprecated-urllib-function",
+ "Used when accessing a field on urllib module that has been "
+ "removed or moved in Python 3.",
+ ),
+ "W1659": (
+ "Accessing a removed xreadlines attribute",
+ "xreadlines-attribute",
+ "Used when accessing the xreadlines() function on a file stream, "
+ "removed in Python 3.",
+ ),
+ "W1660": (
+ "Accessing a removed attribute on the sys module",
+ "deprecated-sys-function",
+ "Used when accessing a field on sys module that has been "
+ "removed in Python 3.",
+ ),
+ "W1661": (
+ "Using an exception object that was bound by an except handler",
+ "exception-escape",
+ "Emitted when using an exception, that was bound in an except "
+ "handler, outside of the except handler. On Python 3 these "
+ "exceptions will be deleted once they get out "
+ "of the except handler.",
+ ),
+ "W1662": (
+ "Using a variable that was bound inside a comprehension",
+ "comprehension-escape",
+ "Emitted when using a variable, that was bound in a comprehension "
+ "handler, outside of the comprehension itself. On Python 3 these "
+ "variables will be deleted outside of the "
+ "comprehension.",
+ ),
+ }
+
+ _bad_builtins = frozenset(
+ [
+ "apply",
+ "basestring",
+ "buffer",
+ "cmp",
+ "coerce",
+ "execfile",
+ "file",
+ "input", # Not missing, but incompatible semantics
+ "intern",
+ "long",
+ "raw_input",
+ "reduce",
+ "round", # Not missing, but incompatible semantics
+ "StandardError",
+ "unichr",
+ "unicode",
+ "xrange",
+ "reload",
+ ]
+ )
+
+ _unused_magic_methods = frozenset(
+ [
+ "__coerce__",
+ "__delslice__",
+ "__getslice__",
+ "__setslice__",
+ "__oct__",
+ "__hex__",
+ "__nonzero__",
+ "__cmp__",
+ "__div__",
+ "__idiv__",
+ "__rdiv__",
+ ]
+ )
+
+ _invalid_encodings = frozenset(
+ [
+ "base64_codec",
+ "base64",
+ "base_64",
+ "bz2_codec",
+ "bz2",
+ "hex_codec",
+ "hex",
+ "quopri_codec",
+ "quopri",
+ "quotedprintable",
+ "quoted_printable",
+ "uu_codec",
+ "uu",
+ "zlib_codec",
+ "zlib",
+ "zip",
+ "rot13",
+ "rot_13",
+ ]
+ )
+
+ _bad_python3_module_map = {
+ "sys-max-int": {"sys": frozenset(["maxint"])},
+ "deprecated-itertools-function": {
+ "itertools": frozenset(
+ ["izip", "ifilter", "imap", "izip_longest", "ifilterfalse"]
+ )
+ },
+ "deprecated-types-field": {
+ "types": frozenset(
+ [
+ "EllipsisType",
+ "XRangeType",
+ "ComplexType",
+ "StringType",
+ "TypeType",
+ "LongType",
+ "UnicodeType",
+ "ClassType",
+ "BufferType",
+ "StringTypes",
+ "NotImplementedType",
+ "NoneType",
+ "InstanceType",
+ "FloatType",
+ "SliceType",
+ "UnboundMethodType",
+ "ObjectType",
+ "IntType",
+ "TupleType",
+ "ListType",
+ "DictType",
+ "FileType",
+ "DictionaryType",
+ "BooleanType",
+ "DictProxyType",
+ ]
+ )
+ },
+ "bad-python3-import": frozenset(
+ [
+ "anydbm",
+ "BaseHTTPServer",
+ "__builtin__",
+ "CGIHTTPServer",
+ "ConfigParser",
+ "copy_reg",
+ "cPickle",
+ "cStringIO",
+ "Cookie",
+ "cookielib",
+ "dbhash",
+ "dumbdbm",
+ "dumbdb",
+ "Dialog",
+ "DocXMLRPCServer",
+ "FileDialog",
+ "FixTk",
+ "gdbm",
+ "htmlentitydefs",
+ "HTMLParser",
+ "httplib",
+ "markupbase",
+ "Queue",
+ "repr",
+ "robotparser",
+ "ScrolledText",
+ "SimpleDialog",
+ "SimpleHTTPServer",
+ "SimpleXMLRPCServer",
+ "StringIO",
+ "dummy_thread",
+ "SocketServer",
+ "test.test_support",
+ "Tkinter",
+ "Tix",
+ "Tkconstants",
+ "tkColorChooser",
+ "tkCommonDialog",
+ "Tkdnd",
+ "tkFileDialog",
+ "tkFont",
+ "tkMessageBox",
+ "tkSimpleDialog",
+ "UserList",
+ "UserString",
+ "whichdb",
+ "_winreg",
+ "xmlrpclib",
+ "audiodev",
+ "Bastion",
+ "bsddb185",
+ "bsddb3",
+ "Canvas",
+ "cfmfile",
+ "cl",
+ "commands",
+ "compiler",
+ "dircache",
+ "dl",
+ "exception",
+ "fpformat",
+ "htmllib",
+ "ihooks",
+ "imageop",
+ "imputil",
+ "linuxaudiodev",
+ "md5",
+ "mhlib",
+ "mimetools",
+ "MimeWriter",
+ "mimify",
+ "multifile",
+ "mutex",
+ "new",
+ "popen2",
+ "posixfile",
+ "pure",
+ "rexec",
+ "rfc822",
+ "sets",
+ "sha",
+ "sgmllib",
+ "sre",
+ "stringold",
+ "sunaudio",
+ "sv",
+ "test.testall",
+ "thread",
+ "timing",
+ "toaiff",
+ "user",
+ "urllib2",
+ "urlparse",
+ ]
+ ),
+ "deprecated-string-function": {
+ "string": frozenset(
+ [
+ "maketrans",
+ "atof",
+ "atoi",
+ "atol",
+ "capitalize",
+ "expandtabs",
+ "find",
+ "rfind",
+ "index",
+ "rindex",
+ "count",
+ "lower",
+ "letters",
+ "split",
+ "rsplit",
+ "splitfields",
+ "join",
+ "joinfields",
+ "lstrip",
+ "rstrip",
+ "strip",
+ "swapcase",
+ "translate",
+ "upper",
+ "ljust",
+ "rjust",
+ "center",
+ "zfill",
+ "replace",
+ "lowercase",
+ "letters",
+ "uppercase",
+ "atol_error",
+ "atof_error",
+ "atoi_error",
+ "index_error",
+ ]
+ )
+ },
+ "deprecated-operator-function": {"operator": frozenset({"div"})},
+ "deprecated-urllib-function": {
+ "urllib": frozenset(
+ {
+ "addbase",
+ "addclosehook",
+ "addinfo",
+ "addinfourl",
+ "always_safe",
+ "basejoin",
+ "ftpcache",
+ "ftperrors",
+ "ftpwrapper",
+ "getproxies",
+ "getproxies_environment",
+ "getproxies_macosx_sysconf",
+ "main",
+ "noheaders",
+ "pathname2url",
+ "proxy_bypass",
+ "proxy_bypass_environment",
+ "proxy_bypass_macosx_sysconf",
+ "quote",
+ "quote_plus",
+ "reporthook",
+ "splitattr",
+ "splithost",
+ "splitnport",
+ "splitpasswd",
+ "splitport",
+ "splitquery",
+ "splittag",
+ "splittype",
+ "splituser",
+ "splitvalue",
+ "unquote",
+ "unquote_plus",
+ "unwrap",
+ "url2pathname",
+ "urlcleanup",
+ "urlencode",
+ "urlopen",
+ "urlretrieve",
+ }
+ )
+ },
+ "deprecated-sys-function": {"sys": frozenset({"exc_clear"})},
+ }
+
+ _deprecated_attrs = frozenset(
+ itertools.chain.from_iterable(
+ attr
+ for module_map in _bad_python3_module_map.values()
+ if isinstance(module_map, dict)
+ for attr in module_map.values()
+ )
+ )
+
+ _relevant_call_attrs = (
+ DICT_METHODS | _deprecated_attrs | {"encode", "decode", "translate"}
+ )
+
+ _python_2_tests = frozenset(
+ astroid.extract_node(x).repr_tree()
+ for x in (
+ "sys.version_info[0] == 2",
+ "sys.version_info[0] < 3",
+ "sys.version_info == (2, 7)",
+ "sys.version_info <= (2, 7)",
+ "sys.version_info < (3, 0)",
+ )
+ )
+
+ def __init__(self, *args, **kwargs):
+ self._future_division = False
+ self._future_absolute_import = False
+ self._modules_warned_about = set()
+ self._branch_stack = []
+ super().__init__(*args, **kwargs)
+
+ # pylint: disable=keyword-arg-before-vararg, arguments-differ
+ def add_message(self, msg_id, always_warn=False, *args, **kwargs):
+ if always_warn or not (
+ self._branch_stack and self._branch_stack[-1].is_py2_only
+ ):
+ super().add_message(msg_id, *args, **kwargs)
+
+ def _is_py2_test(self, node):
+ if isinstance(node.test, astroid.Attribute) and isinstance(
+ node.test.expr, astroid.Name
+ ):
+ if node.test.expr.name == "six" and node.test.attrname == "PY2":
+ return True
+ elif (
+ isinstance(node.test, astroid.Compare)
+ and node.test.repr_tree() in self._python_2_tests
+ ):
+ return True
+ return False
+
+ def visit_if(self, node):
+ self._branch_stack.append(Branch(node, self._is_py2_test(node)))
+
+ def leave_if(self, node):
+ new_node = self._branch_stack.pop().node
+ assert new_node == node
+
+ def visit_ifexp(self, node):
+ self._branch_stack.append(Branch(node, self._is_py2_test(node)))
+
+ def leave_ifexp(self, node):
+ new_node = self._branch_stack.pop()
+ assert new_node.node == node
+
+ def visit_module(self, node): # pylint: disable=unused-argument
+ """Clear checker state after previous module."""
+ self._future_division = False
+ self._future_absolute_import = False
+
+ def visit_functiondef(self, node):
+ if node.is_method():
+ if node.name in self._unused_magic_methods:
+ method_name = node.name
+ if node.name.startswith("__"):
+ method_name = node.name[2:-2]
+ self.add_message(method_name + "-method", node=node)
+ elif node.name == "next":
+ # If there is a method named `next` declared, if it is invokable
+ # with zero arguments then it implements the Iterator protocol.
+ # This means if the method is an instance method or a
+ # classmethod 1 argument should cause a failure, if it is a
+ # staticmethod 0 arguments should cause a failure.
+ failing_arg_count = 1
+ if utils.decorated_with(
+ node, [astroid.bases.BUILTINS + ".staticmethod"]
+ ):
+ failing_arg_count = 0
+ if len(node.args.args) == failing_arg_count:
+ self.add_message("next-method-defined", node=node)
+
+ @utils.check_messages("parameter-unpacking")
+ def visit_arguments(self, node):
+ for arg in node.args:
+ if isinstance(arg, astroid.Tuple):
+ self.add_message("parameter-unpacking", node=arg)
+
+ @utils.check_messages("comprehension-escape")
+ def visit_listcomp(self, node):
+ names = {
+ generator.target.name
+ for generator in node.generators
+ if isinstance(generator.target, astroid.AssignName)
+ }
+ scope = node.parent.scope()
+ scope_names = scope.nodes_of_class(astroid.Name, skip_klass=astroid.FunctionDef)
+ has_redefined_assign_name = any(
+ assign_name
+ for assign_name in scope.nodes_of_class(
+ astroid.AssignName, skip_klass=astroid.FunctionDef
+ )
+ if assign_name.name in names and assign_name.lineno > node.lineno
+ )
+ if has_redefined_assign_name:
+ return
+
+ emitted_for_names = set()
+ scope_names = list(scope_names)
+ for scope_name in scope_names:
+ if (
+ scope_name.name not in names
+ or scope_name.lineno <= node.lineno
+ or scope_name.name in emitted_for_names
+ or scope_name.scope() == node
+ ):
+ continue
+
+ emitted_for_names.add(scope_name.name)
+ self.add_message("comprehension-escape", node=scope_name)
+
+ def visit_name(self, node):
+ """Detect when a "bad" built-in is referenced."""
+ found_node, _ = node.lookup(node.name)
+ if not _is_builtin(found_node):
+ return
+ if node.name not in self._bad_builtins:
+ return
+ if node_ignores_exception(node) or isinstance(
+ find_try_except_wrapper_node(node), astroid.ExceptHandler
+ ):
+ return
+
+ message = node.name.lower() + "-builtin"
+ self.add_message(message, node=node)
+
+ @utils.check_messages("print-statement")
+ def visit_print(self, node):
+ self.add_message("print-statement", node=node, always_warn=True)
+
+ def _warn_if_deprecated(self, node, module, attributes, report_on_modules=True):
+ for message, module_map in self._bad_python3_module_map.items():
+ if module in module_map and module not in self._modules_warned_about:
+ if isinstance(module_map, frozenset):
+ if report_on_modules:
+ self._modules_warned_about.add(module)
+ self.add_message(message, node=node)
+ elif attributes and module_map[module].intersection(attributes):
+ self.add_message(message, node=node)
+
+ def visit_importfrom(self, node):
+ if node.modname == "__future__":
+ for name, _ in node.names:
+ if name == "division":
+ self._future_division = True
+ elif name == "absolute_import":
+ self._future_absolute_import = True
+ else:
+ if not self._future_absolute_import:
+ if self.linter.is_message_enabled("no-absolute-import"):
+ self.add_message("no-absolute-import", node=node)
+ self._future_absolute_import = True
+ if not _is_conditional_import(node) and not node.level:
+ self._warn_if_deprecated(node, node.modname, {x[0] for x in node.names})
+
+ if node.names[0][0] == "*":
+ if self.linter.is_message_enabled("import-star-module-level"):
+ if not isinstance(node.scope(), astroid.Module):
+ self.add_message("import-star-module-level", node=node)
+
+ def visit_import(self, node):
+ if not self._future_absolute_import:
+ if self.linter.is_message_enabled("no-absolute-import"):
+ self.add_message("no-absolute-import", node=node)
+ self._future_absolute_import = True
+ if not _is_conditional_import(node):
+ for name, _ in node.names:
+ self._warn_if_deprecated(node, name, None)
+
+ @utils.check_messages("metaclass-assignment")
+ def visit_classdef(self, node):
+ if "__metaclass__" in node.locals:
+ self.add_message("metaclass-assignment", node=node)
+ locals_and_methods = set(node.locals).union(x.name for x in node.mymethods())
+ if "__eq__" in locals_and_methods and "__hash__" not in locals_and_methods:
+ self.add_message("eq-without-hash", node=node)
+
+ @utils.check_messages("old-division")
+ def visit_binop(self, node):
+ if not self._future_division and node.op == "/":
+ for arg in (node.left, node.right):
+ inferred = utils.safe_infer(arg)
+ # If we can infer the object and that object is not an int, bail out.
+ if inferred and not (
+ (
+ isinstance(inferred, astroid.Const)
+ and isinstance(inferred.value, int)
+ )
+ or (
+ isinstance(inferred, astroid.Instance)
+ and inferred.name == "int"
+ )
+ ):
+ break
+ else:
+ self.add_message("old-division", node=node)
+
+ def _check_cmp_argument(self, node):
+ # Check that the `cmp` argument is used
+ kwargs = []
+ if isinstance(node.func, astroid.Attribute) and node.func.attrname == "sort":
+ inferred = utils.safe_infer(node.func.expr)
+ if not inferred:
+ return
+
+ builtins_list = f"{astroid.bases.BUILTINS}.list"
+ if isinstance(inferred, astroid.List) or inferred.qname() == builtins_list:
+ kwargs = node.keywords
+
+ elif isinstance(node.func, astroid.Name) and node.func.name == "sorted":
+ inferred = utils.safe_infer(node.func)
+ if not inferred:
+ return
+
+ builtins_sorted = f"{astroid.bases.BUILTINS}.sorted"
+ if inferred.qname() == builtins_sorted:
+ kwargs = node.keywords
+
+ for kwarg in kwargs or []:
+ if kwarg.arg == "cmp":
+ self.add_message("using-cmp-argument", node=node)
+ return
+
+ @staticmethod
+ def _is_constant_string_or_name(node):
+ if isinstance(node, astroid.Const):
+ return isinstance(node.value, str)
+ return isinstance(node, astroid.Name)
+
+ @staticmethod
+ def _is_none(node):
+ return isinstance(node, astroid.Const) and node.value is None
+
+ @staticmethod
+ def _has_only_n_positional_args(node, number_of_args):
+ return len(node.args) == number_of_args and all(node.args) and not node.keywords
+
+ @staticmethod
+ def _could_be_string(inferred_types):
+ confidence = INFERENCE if inferred_types else INFERENCE_FAILURE
+ for inferred_type in inferred_types:
+ if inferred_type is astroid.Uninferable:
+ confidence = INFERENCE_FAILURE
+ elif not (
+ isinstance(inferred_type, astroid.Const)
+ and isinstance(inferred_type.value, str)
+ ):
+ return None
+ return confidence
+
+ def visit_call(self, node):
+ self._check_cmp_argument(node)
+
+ if isinstance(node.func, astroid.Attribute):
+ inferred_types = set()
+
+ try:
+ for inferred_receiver in _infer_if_relevant_attr(
+ node.func, self._relevant_call_attrs
+ ):
+ if inferred_receiver is astroid.Uninferable:
+ continue
+ inferred_types.add(inferred_receiver)
+ if isinstance(inferred_receiver, astroid.Module):
+ self._warn_if_deprecated(
+ node,
+ inferred_receiver.name,
+ {node.func.attrname},
+ report_on_modules=False,
+ )
+ if (
+ _inferred_value_is_dict(inferred_receiver)
+ and node.func.attrname in DICT_METHODS
+ ):
+ if not _in_iterating_context(node):
+ checker = f"dict-{node.func.attrname}-not-iterating"
+ self.add_message(checker, node=node)
+ except astroid.InferenceError:
+ pass
+ if node.args:
+ is_str_confidence = self._could_be_string(inferred_types)
+ if is_str_confidence:
+ if (
+ node.func.attrname in ("encode", "decode")
+ and len(node.args) >= 1
+ and node.args[0]
+ ):
+ first_arg = node.args[0]
+ self._validate_encoding(first_arg, node)
+ if (
+ node.func.attrname == "translate"
+ and self._has_only_n_positional_args(node, 2)
+ and self._is_none(node.args[0])
+ and self._is_constant_string_or_name(node.args[1])
+ ):
+ # The above statement looking for calls of the form:
+ #
+ # foo.translate(None, 'abc123')
+ #
+ # or
+ #
+ # foo.translate(None, some_variable)
+ #
+ # This check is somewhat broad and _may_ have some false positives, but
+ # after checking several large codebases it did not have any false
+ # positives while finding several real issues. This call pattern seems
+ # rare enough that the trade off is worth it.
+ self.add_message(
+ "deprecated-str-translate-call",
+ node=node,
+ confidence=is_str_confidence,
+ )
+ return
+ if node.keywords:
+ return
+ if node.func.attrname == "next":
+ self.add_message("next-method-called", node=node)
+ elif node.func.attrname in ("iterkeys", "itervalues", "iteritems"):
+ self.add_message("dict-iter-method", node=node)
+ elif node.func.attrname in ("viewkeys", "viewvalues", "viewitems"):
+ self.add_message("dict-view-method", node=node)
+ elif isinstance(node.func, astroid.Name):
+ found_node = node.func.lookup(node.func.name)[0]
+ if _is_builtin(found_node):
+ if node.func.name in ("filter", "map", "range", "zip"):
+ if not _in_iterating_context(node):
+ checker = f"{node.func.name}-builtin-not-iterating"
+ self.add_message(checker, node=node)
+ elif node.func.name == "open" and node.keywords:
+ kwargs = node.keywords
+ for kwarg in kwargs or []:
+ if kwarg.arg == "encoding":
+ self._validate_encoding(kwarg.value, node)
+ break
+
+ def _validate_encoding(self, encoding, node):
+ if isinstance(encoding, astroid.Const):
+ value = encoding.value
+ if value in self._invalid_encodings:
+ self.add_message("invalid-str-codec", node=node)
+
+ @utils.check_messages("indexing-exception")
+ def visit_subscript(self, node):
+ """Look for indexing exceptions."""
+ try:
+ for inferred in node.value.infer():
+ if not isinstance(inferred, astroid.Instance):
+ continue
+ if utils.inherit_from_std_ex(inferred):
+ self.add_message("indexing-exception", node=node)
+ except astroid.InferenceError:
+ return
+
+ def visit_assignattr(self, node):
+ if isinstance(node.assign_type(), astroid.AugAssign):
+ self.visit_attribute(node)
+
+ def visit_delattr(self, node):
+ self.visit_attribute(node)
+
+ @utils.check_messages("exception-message-attribute", "xreadlines-attribute")
+ def visit_attribute(self, node):
+ """Look for removed attributes"""
+ if node.attrname == "xreadlines":
+ self.add_message("xreadlines-attribute", node=node)
+ return
+
+ exception_message = "message"
+ try:
+ for inferred in _infer_if_relevant_attr(
+ node, self._deprecated_attrs | {exception_message}
+ ):
+ if isinstance(inferred, astroid.Instance) and utils.inherit_from_std_ex(
+ inferred
+ ):
+ if node.attrname == exception_message:
+
+ # Exceptions with .message clearly defined are an exception
+ if exception_message in inferred.instance_attrs:
+ continue
+ self.add_message("exception-message-attribute", node=node)
+ if isinstance(inferred, astroid.Module):
+ self._warn_if_deprecated(
+ node, inferred.name, {node.attrname}, report_on_modules=False
+ )
+ except astroid.InferenceError:
+ return
+
+ @utils.check_messages("unpacking-in-except", "comprehension-escape")
+ def visit_excepthandler(self, node):
+ """Visit an except handler block and check for exception unpacking."""
+
+ def _is_used_in_except_block(node, block):
+ current = node
+ while current and current is not block:
+ current = current.parent
+ return current is not None
+
+ if isinstance(node.name, (astroid.Tuple, astroid.List)):
+ self.add_message("unpacking-in-except", node=node)
+ return
+
+ if not node.name:
+ return
+
+ # Find any names
+ scope = node.parent.scope()
+ scope_names = scope.nodes_of_class(astroid.Name, skip_klass=astroid.FunctionDef)
+ scope_names = list(scope_names)
+ potential_leaked_names = [
+ scope_name
+ for scope_name in scope_names
+ if scope_name.name == node.name.name
+ and scope_name.lineno > node.lineno
+ and not _is_used_in_except_block(scope_name, node)
+ ]
+ reassignments_for_same_name = {
+ assign_name.lineno
+ for assign_name in scope.nodes_of_class(
+ astroid.AssignName, skip_klass=astroid.FunctionDef
+ )
+ if assign_name.name == node.name.name
+ }
+ for leaked_name in potential_leaked_names:
+ if any(
+ node.lineno < elem < leaked_name.lineno
+ for elem in reassignments_for_same_name
+ ):
+ continue
+ self.add_message("exception-escape", node=leaked_name)
+
+ @utils.check_messages("backtick")
+ def visit_repr(self, node):
+ self.add_message("backtick", node=node)
+
+ @utils.check_messages("raising-string", "old-raise-syntax")
+ def visit_raise(self, node):
+ """Visit a raise statement and check for raising
+ strings or old-raise-syntax.
+ """
+
+ # Ignore empty raise.
+ if node.exc is None:
+ return
+ expr = node.exc
+ if self._check_raise_value(node, expr):
+ return
+ try:
+ value = next(astroid.unpack_infer(expr))
+ except astroid.InferenceError:
+ return
+ self._check_raise_value(node, value)
+
+ def _check_raise_value(self, node, expr):
+ if isinstance(expr, astroid.Const):
+ value = expr.value
+ if isinstance(value, str):
+ self.add_message("raising-string", node=node)
+ return True
+ return None
+
+
+class Python3TokenChecker(checkers.BaseTokenChecker):
+ __implements__ = interfaces.ITokenChecker
+ name = "python3"
+ enabled = False
+
+ msgs = {
+ "E1606": (
+ "Use of long suffix",
+ "long-suffix",
+ 'Used when "l" or "L" is used to mark a long integer. '
+ "This will not work in Python 3, since `int` and `long` "
+ "types have merged.",
+ {"maxversion": (3, 0)},
+ ),
+ "E1607": (
+ "Use of the <> operator",
+ "old-ne-operator",
+ 'Used when the deprecated "<>" operator is used instead '
+ 'of "!=". This is removed in Python 3.',
+ {"maxversion": (3, 0), "old_names": [("W0331", "old-old-ne-operator")]},
+ ),
+ "E1608": (
+ "Use of old octal literal",
+ "old-octal-literal",
+ "Used when encountering the old octal syntax, "
+ "removed in Python 3. To use the new syntax, "
+ "prepend 0o on the number.",
+ {"maxversion": (3, 0)},
+ ),
+ "E1610": (
+ "Non-ascii bytes literals not supported in 3.x",
+ "non-ascii-bytes-literal",
+ "Used when non-ascii bytes literals are found in a program. "
+ "They are no longer supported in Python 3.",
+ {"maxversion": (3, 0)},
+ ),
+ }
+
+ def process_tokens(self, tokens):
+ for idx, (tok_type, token, start, _, _) in enumerate(tokens):
+ if tok_type == tokenize.NUMBER:
+ if token.lower().endswith("l"):
+ # This has a different semantic than lowercase-l-suffix.
+ self.add_message("long-suffix", line=start[0])
+ elif _is_old_octal(token):
+ self.add_message("old-octal-literal", line=start[0])
+ if tokens[idx][1] == "<>":
+ self.add_message("old-ne-operator", line=tokens[idx][2][0])
+ if tok_type == tokenize.STRING and token.startswith("b"):
+ if any(elem for elem in token if ord(elem) > 127):
+ self.add_message("non-ascii-bytes-literal", line=start[0])
+
+
+def register(linter):
+ linter.register_checker(Python3Checker(linter))
+ linter.register_checker(Python3TokenChecker(linter))
diff --git a/pylint/checkers/raw_metrics.py b/pylint/checkers/raw_metrics.py
new file mode 100644
index 0000000..68dfd47
--- /dev/null
+++ b/pylint/checkers/raw_metrics.py
@@ -0,0 +1,122 @@
+# Copyright (c) 2007, 2010, 2013, 2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Mike Frysinger <vapier@gentoo.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020-2021 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 谭九鼎 <109224573@qq.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import tokenize
+from typing import Any
+
+from pylint.checkers import BaseTokenChecker
+from pylint.exceptions import EmptyReportError
+from pylint.interfaces import ITokenChecker
+from pylint.reporters.ureports.nodes import Table
+from pylint.utils import diff_string
+
+
+def report_raw_stats(sect, stats, old_stats):
+ """calculate percentage of code / doc / comment / empty"""
+ total_lines = stats["total_lines"]
+ if not total_lines:
+ raise EmptyReportError()
+ sect.description = "%s lines have been analyzed" % total_lines
+ lines = ("type", "number", "%", "previous", "difference")
+ for node_type in ("code", "docstring", "comment", "empty"):
+ key = node_type + "_lines"
+ total = stats[key]
+ percent = float(total * 100) / total_lines
+ old = old_stats.get(key, None)
+ if old is not None:
+ diff_str = diff_string(old, total)
+ else:
+ old, diff_str = "NC", "NC"
+ lines += (node_type, str(total), "%.2f" % percent, str(old), diff_str)
+ sect.append(Table(children=lines, cols=5, rheaders=1))
+
+
+class RawMetricsChecker(BaseTokenChecker):
+ """does not check anything but gives some raw metrics :
+ * total number of lines
+ * total number of code lines
+ * total number of docstring lines
+ * total number of comments lines
+ * total number of empty lines
+ """
+
+ __implements__ = (ITokenChecker,)
+
+ # configuration section name
+ name = "metrics"
+ # configuration options
+ options = ()
+ # messages
+ msgs: Any = {}
+ # reports
+ reports = (("RP0701", "Raw metrics", report_raw_stats),)
+
+ def __init__(self, linter):
+ BaseTokenChecker.__init__(self, linter)
+ self.stats = None
+
+ def open(self):
+ """init statistics"""
+ self.stats = self.linter.add_stats(
+ total_lines=0,
+ code_lines=0,
+ empty_lines=0,
+ docstring_lines=0,
+ comment_lines=0,
+ )
+
+ def process_tokens(self, tokens):
+ """update stats"""
+ i = 0
+ tokens = list(tokens)
+ while i < len(tokens):
+ i, lines_number, line_type = get_type(tokens, i)
+ self.stats["total_lines"] += lines_number
+ self.stats[line_type] += lines_number
+
+
+JUNK = (tokenize.NL, tokenize.INDENT, tokenize.NEWLINE, tokenize.ENDMARKER)
+
+
+def get_type(tokens, start_index):
+ """return the line type : docstring, comment, code, empty"""
+ i = start_index
+ start = tokens[i][2]
+ pos = start
+ line_type = None
+ while i < len(tokens) and tokens[i][2][0] == start[0]:
+ tok_type = tokens[i][0]
+ pos = tokens[i][3]
+ if line_type is None:
+ if tok_type == tokenize.STRING:
+ line_type = "docstring_lines"
+ elif tok_type == tokenize.COMMENT:
+ line_type = "comment_lines"
+ elif tok_type in JUNK:
+ pass
+ else:
+ line_type = "code_lines"
+ i += 1
+ if line_type is None:
+ line_type = "empty_lines"
+ elif i < len(tokens) and tokens[i][0] == tokenize.NEWLINE:
+ i += 1
+ return i, pos[0] - start[0] + 1, line_type
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(RawMetricsChecker(linter))
diff --git a/pylint/checkers/refactoring/__init__.py b/pylint/checkers/refactoring/__init__.py
new file mode 100644
index 0000000..4f30084
--- /dev/null
+++ b/pylint/checkers/refactoring/__init__.py
@@ -0,0 +1,52 @@
+# Copyright (c) 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2017-2018, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017-2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2017 Hugo <hugovk@users.noreply.github.com>
+# Copyright (c) 2017 Łukasz Sznuk <ls@rdprojekt.pl>
+# Copyright (c) 2017 Alex Hearn <alex.d.hearn@gmail.com>
+# Copyright (c) 2017 Antonio Ossa <aaossa@uc.cl>
+# Copyright (c) 2018-2019 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Justin Li <justinnhli@gmail.com>
+# Copyright (c) 2018 Jim Robertson <jrobertson98atx@gmail.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Ben James <benjames1999@hotmail.co.uk>
+# Copyright (c) 2018 Tomer Chachamu <tomer.chachamu@gmail.com>
+# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2018 Konstantin Manna <Konstantin@Manna.uno>
+# Copyright (c) 2018 Konstantin <Github@pheanex.de>
+# Copyright (c) 2018 Matej Marušák <marusak.matej@gmail.com>
+# Copyright (c) 2018 Mr. Senko <atodorov@mrsenko.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Rémi Cardona <remi.cardona@polyconseil.fr>
+# Copyright (c) 2019 Robert Schweizer <robert_schweizer@gmx.de>
+# Copyright (c) 2019 PHeanEX <github@pheanex.de>
+# Copyright (c) 2019 Paul Renvoise <PaulRenvoise@users.noreply.github.com>
+# Copyright (c) 2020 ethan-leba <ethanleba5@gmail.com>
+# Copyright (c) 2020 lrjball <50599110+lrjball@users.noreply.github.com>
+# Copyright (c) 2020 Yang Yang <y4n9squared@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Looks for code which can be refactored."""
+
+
+from pylint.checkers.refactoring.len_checker import LenChecker
+from pylint.checkers.refactoring.not_checker import NotChecker
+from pylint.checkers.refactoring.recommendation_checker import RecommendationChecker
+from pylint.checkers.refactoring.refactoring_checker import RefactoringChecker
+
+__all__ = ["LenChecker", "NotChecker", "RecommendationChecker", "RefactoringChecker"]
+
+
+def register(linter):
+ """Required method to auto register this checker."""
+ linter.register_checker(RefactoringChecker(linter))
+ linter.register_checker(NotChecker(linter))
+ linter.register_checker(RecommendationChecker(linter))
+ linter.register_checker(LenChecker(linter))
diff --git a/pylint/checkers/refactoring/len_checker.py b/pylint/checkers/refactoring/len_checker.py
new file mode 100644
index 0000000..1132a63
--- /dev/null
+++ b/pylint/checkers/refactoring/len_checker.py
@@ -0,0 +1,121 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+from typing import List
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+class LenChecker(checkers.BaseChecker):
+ """Checks for incorrect usage of len() inside conditions.
+ Pep8 states:
+ For sequences, (strings, lists, tuples), use the fact that empty sequences are false.
+
+ Yes: if not seq:
+ if seq:
+
+ No: if len(seq):
+ if not len(seq):
+
+ Problems detected:
+ * if len(sequence):
+ * if not len(sequence):
+ * elif len(sequence):
+ * elif not len(sequence):
+ * while len(sequence):
+ * while not len(sequence):
+ * assert len(sequence):
+ * assert not len(sequence):
+ * bool(len(sequence))
+ """
+
+ __implements__ = (interfaces.IAstroidChecker,)
+
+ # configuration section name
+ name = "refactoring"
+ msgs = {
+ "C1801": (
+ "Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty",
+ "len-as-condition",
+ "Used when Pylint detects that len(sequence) is being used "
+ "without explicit comparison inside a condition to determine if a sequence is empty. "
+ "Instead of coercing the length to a boolean, either "
+ "rely on the fact that empty sequences are false or "
+ "compare the length against a scalar.",
+ )
+ }
+
+ priority = -2
+ options = ()
+
+ @utils.check_messages("len-as-condition")
+ def visit_call(self, node):
+ # a len(S) call is used inside a test condition
+ # could be if, while, assert or if expression statement
+ # e.g. `if len(S):`
+ if not utils.is_call_of_name(node, "len"):
+ return
+ # the len() call could also be nested together with other
+ # boolean operations, e.g. `if z or len(x):`
+ parent = node.parent
+ while isinstance(parent, astroid.BoolOp):
+ parent = parent.parent
+ # we're finally out of any nested boolean operations so check if
+ # this len() call is part of a test condition
+ if not utils.is_test_condition(node, parent):
+ return
+ len_arg = node.args[0]
+ generator_or_comprehension = (
+ astroid.ListComp,
+ astroid.SetComp,
+ astroid.DictComp,
+ astroid.GeneratorExp,
+ )
+ if isinstance(len_arg, generator_or_comprehension):
+ # The node is a generator or comprehension as in len([x for x in ...])
+ self.add_message("len-as-condition", node=node)
+ return
+ try:
+ instance = next(len_arg.infer())
+ except astroid.InferenceError:
+ # Probably undefined-varible, abort check
+ return
+ mother_classes = self.base_classes_of_node(instance)
+ affected_by_pep8 = any(
+ t in mother_classes for t in ("str", "tuple", "list", "set")
+ )
+ if "range" in mother_classes or (
+ affected_by_pep8 and not self.instance_has_bool(instance)
+ ):
+ self.add_message("len-as-condition", node=node)
+
+ @staticmethod
+ def instance_has_bool(class_def: astroid.ClassDef) -> bool:
+ try:
+ class_def.getattr("__bool__")
+ return True
+ except astroid.AttributeInferenceError:
+ ...
+ return False
+
+ @utils.check_messages("len-as-condition")
+ def visit_unaryop(self, node):
+ """`not len(S)` must become `not S` regardless if the parent block
+ is a test condition or something else (boolean expression)
+ e.g. `if not len(S):`"""
+ if (
+ isinstance(node, astroid.UnaryOp)
+ and node.op == "not"
+ and utils.is_call_of_name(node.operand, "len")
+ ):
+ self.add_message("len-as-condition", node=node)
+
+ @staticmethod
+ def base_classes_of_node(instance: astroid.nodes.ClassDef) -> List[astroid.Name]:
+ """Return all the classes names that a ClassDef inherit from including 'object'."""
+ try:
+ return [instance.name] + [x.name for x in instance.ancestors()]
+ except TypeError:
+ return [instance.name]
diff --git a/pylint/checkers/refactoring/not_checker.py b/pylint/checkers/refactoring/not_checker.py
new file mode 100644
index 0000000..ea3bae3
--- /dev/null
+++ b/pylint/checkers/refactoring/not_checker.py
@@ -0,0 +1,87 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import builtins
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+class NotChecker(checkers.BaseChecker):
+ """checks for too many not in comparison expressions
+
+ - "not not" should trigger a warning
+ - "not" followed by a comparison should trigger a warning
+ """
+
+ __implements__ = (interfaces.IAstroidChecker,)
+ msgs = {
+ "C0113": (
+ 'Consider changing "%s" to "%s"',
+ "unneeded-not",
+ "Used when a boolean expression contains an unneeded negation.",
+ )
+ }
+ name = "refactoring"
+ reverse_op = {
+ "<": ">=",
+ "<=": ">",
+ ">": "<=",
+ ">=": "<",
+ "==": "!=",
+ "!=": "==",
+ "in": "not in",
+ "is": "is not",
+ }
+ # sets are not ordered, so for example "not set(LEFT_VALS) <= set(RIGHT_VALS)" is
+ # not equivalent to "set(LEFT_VALS) > set(RIGHT_VALS)"
+ skipped_nodes = (astroid.Set,)
+ # 'builtins' py3, '__builtin__' py2
+ skipped_classnames = [
+ f"{builtins.__name__}.{qname}" for qname in ("set", "frozenset")
+ ]
+
+ @utils.check_messages("unneeded-not")
+ def visit_unaryop(self, node):
+ if node.op != "not":
+ return
+ operand = node.operand
+
+ if isinstance(operand, astroid.UnaryOp) and operand.op == "not":
+ self.add_message(
+ "unneeded-not",
+ node=node,
+ args=(node.as_string(), operand.operand.as_string()),
+ )
+ elif isinstance(operand, astroid.Compare):
+ left = operand.left
+ # ignore multiple comparisons
+ if len(operand.ops) > 1:
+ return
+ operator, right = operand.ops[0]
+ if operator not in self.reverse_op:
+ return
+ # Ignore __ne__ as function of __eq__
+ frame = node.frame()
+ if frame.name == "__ne__" and operator == "==":
+ return
+ for _type in (utils.node_type(left), utils.node_type(right)):
+ if not _type:
+ return
+ if isinstance(_type, self.skipped_nodes):
+ return
+ if (
+ isinstance(_type, astroid.Instance)
+ and _type.qname() in self.skipped_classnames
+ ):
+ return
+ suggestion = "{} {} {}".format(
+ left.as_string(),
+ self.reverse_op[operator],
+ right.as_string(),
+ )
+ self.add_message(
+ "unneeded-not", node=node, args=(node.as_string(), suggestion)
+ )
diff --git a/pylint/checkers/refactoring/recommendation_checker.py b/pylint/checkers/refactoring/recommendation_checker.py
new file mode 100644
index 0000000..6ea3871
--- /dev/null
+++ b/pylint/checkers/refactoring/recommendation_checker.py
@@ -0,0 +1,263 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+from typing import cast
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+class RecommendationChecker(checkers.BaseChecker):
+
+ __implements__ = (interfaces.IAstroidChecker,)
+ name = "refactoring"
+ msgs = {
+ "C0200": (
+ "Consider using enumerate instead of iterating with range and len",
+ "consider-using-enumerate",
+ "Emitted when code that iterates with range and len is "
+ "encountered. Such code can be simplified by using the "
+ "enumerate builtin.",
+ ),
+ "C0201": (
+ "Consider iterating the dictionary directly instead of calling .keys()",
+ "consider-iterating-dictionary",
+ "Emitted when the keys of a dictionary are iterated through the .keys() "
+ "method. It is enough to just iterate through the dictionary itself, as "
+ 'in "for key in dictionary".',
+ ),
+ "C0206": (
+ "Consider iterating with .items()",
+ "consider-using-dict-items",
+ "Emitted when iterating over the keys of a dictionary and accessing the "
+ "value by index lookup. "
+ "Both the key and value can be accessed by iterating using the .items() "
+ "method of the dictionary instead.",
+ ),
+ "C0207": (
+ "Use %s instead",
+ "use-maxsplit-arg",
+ "Emitted when accessing only the first or last element of str.split(). "
+ "The first and last element can be accessed by using "
+ "str.split(sep, maxsplit=1)[0] or str.rsplit(sep, maxsplit=1)[-1] "
+ "instead.",
+ ),
+ }
+
+ @staticmethod
+ def _is_builtin(node, function):
+ inferred = utils.safe_infer(node)
+ if not inferred:
+ return False
+ return utils.is_builtin_object(inferred) and inferred.name == function
+
+ @utils.check_messages("consider-iterating-dictionary", "use-maxsplit-arg")
+ def visit_call(self, node: astroid.Call) -> None:
+ self._check_consider_iterating_dictionary(node)
+ self._check_use_maxsplit_arg(node)
+
+ def _check_consider_iterating_dictionary(self, node: astroid.Call) -> None:
+ if not isinstance(node.func, astroid.Attribute):
+ return
+ if node.func.attrname != "keys":
+ return
+ if not isinstance(node.parent, (astroid.For, astroid.Comprehension)):
+ return
+
+ inferred = utils.safe_infer(node.func)
+ if not isinstance(inferred, astroid.BoundMethod) or not isinstance(
+ inferred.bound, astroid.Dict
+ ):
+ return
+
+ if isinstance(node.parent, (astroid.For, astroid.Comprehension)):
+ self.add_message("consider-iterating-dictionary", node=node)
+
+ def _check_use_maxsplit_arg(self, node: astroid.Call) -> None:
+ """Add message when accessing first or last elements of a str.split() or str.rsplit()."""
+
+ # Check if call is split() or rsplit()
+ if (
+ isinstance(node.func, astroid.Attribute)
+ and node.func.attrname in ("split", "rsplit")
+ and isinstance(utils.safe_infer(node.func), astroid.BoundMethod)
+ ):
+ try:
+ utils.get_argument_from_call(node, 0, "sep")
+ except utils.NoSuchArgumentError:
+ return
+
+ try:
+ # Ignore if maxsplit arg has been set
+ utils.get_argument_from_call(node, 1, "maxsplit")
+ return
+ except utils.NoSuchArgumentError:
+ pass
+
+ if isinstance(node.parent, astroid.Subscript):
+ try:
+ subscript_value = utils.get_subscript_const_value(node.parent).value
+ except utils.InferredTypeError:
+ return
+
+ if subscript_value in (-1, 0):
+ fn_name = node.func.attrname
+ new_fn = "rsplit" if subscript_value == -1 else "split"
+ new_name = (
+ node.func.as_string().rsplit(fn_name, maxsplit=1)[0]
+ + new_fn
+ + f"({node.args[0].as_string()}, maxsplit=1)[{subscript_value}]"
+ )
+ self.add_message("use-maxsplit-arg", node=node, args=(new_name,))
+
+ @utils.check_messages("consider-using-enumerate", "consider-using-dict-items")
+ def visit_for(self, node: astroid.For) -> None:
+ self._check_consider_using_enumerate(node)
+ self._check_consider_using_dict_items(node)
+
+ def _check_consider_using_enumerate(self, node: astroid.For) -> None:
+ """Emit a convention whenever range and len are used for indexing."""
+ # Verify that we have a `range([start], len(...), [stop])` call and
+ # that the object which is iterated is used as a subscript in the
+ # body of the for.
+
+ # Is it a proper range call?
+ if not isinstance(node.iter, astroid.Call):
+ return
+ if not self._is_builtin(node.iter.func, "range"):
+ return
+ if not node.iter.args:
+ return
+ is_constant_zero = (
+ isinstance(node.iter.args[0], astroid.Const)
+ and node.iter.args[0].value == 0
+ )
+ if len(node.iter.args) == 2 and not is_constant_zero:
+ return
+ if len(node.iter.args) > 2:
+ return
+
+ # Is it a proper len call?
+ if not isinstance(node.iter.args[-1], astroid.Call):
+ return
+ second_func = node.iter.args[-1].func
+ if not self._is_builtin(second_func, "len"):
+ return
+ len_args = node.iter.args[-1].args
+ if not len_args or len(len_args) != 1:
+ return
+ iterating_object = len_args[0]
+ if isinstance(iterating_object, astroid.Name):
+ expected_subscript_val_type = astroid.Name
+ elif isinstance(iterating_object, astroid.Attribute):
+ expected_subscript_val_type = astroid.Attribute
+ else:
+ return
+ # If we're defining __iter__ on self, enumerate won't work
+ scope = node.scope()
+ if (
+ isinstance(iterating_object, astroid.Name)
+ and iterating_object.name == "self"
+ and scope.name == "__iter__"
+ ):
+ return
+
+ # Verify that the body of the for loop uses a subscript
+ # with the object that was iterated. This uses some heuristics
+ # in order to make sure that the same object is used in the
+ # for body.
+ for child in node.body:
+ for subscript in child.nodes_of_class(astroid.Subscript):
+ subscript = cast(astroid.Subscript, subscript)
+ if not isinstance(subscript.value, expected_subscript_val_type):
+ continue
+
+ value = subscript.slice
+ if not isinstance(value, astroid.Name):
+ continue
+ if subscript.value.scope() != node.scope():
+ # Ignore this subscript if it's not in the same
+ # scope. This means that in the body of the for
+ # loop, another scope was created, where the same
+ # name for the iterating object was used.
+ continue
+ if value.name == node.target.name and (
+ isinstance(subscript.value, astroid.Name)
+ and iterating_object.name == subscript.value.name
+ or isinstance(subscript.value, astroid.Attribute)
+ and iterating_object.attrname == subscript.value.attrname
+ ):
+ self.add_message("consider-using-enumerate", node=node)
+ return
+
+ def _check_consider_using_dict_items(self, node: astroid.For) -> None:
+ """Add message when accessing dict values by index lookup."""
+ # Verify that we have a .keys() call and
+ # that the object which is iterated is used as a subscript in the
+ # body of the for.
+
+ iterating_object_name = utils.get_iterating_dictionary_name(node)
+ if iterating_object_name is None:
+ return
+
+ # Verify that the body of the for loop uses a subscript
+ # with the object that was iterated. This uses some heuristics
+ # in order to make sure that the same object is used in the
+ # for body.
+ for child in node.body:
+ for subscript in child.nodes_of_class(astroid.Subscript):
+ subscript = cast(astroid.Subscript, subscript)
+
+ if not isinstance(subscript.value, (astroid.Name, astroid.Attribute)):
+ continue
+
+ value = subscript.slice
+ if (
+ not isinstance(value, astroid.Name)
+ or value.name != node.target.name
+ or iterating_object_name != subscript.value.as_string()
+ ):
+ continue
+ last_definition_lineno = value.lookup(value.name)[1][-1].lineno
+ if last_definition_lineno > node.lineno:
+ # Ignore this subscript if it has been redefined after
+ # the for loop. This checks for the line number using .lookup()
+ # to get the line number where the iterating object was last
+ # defined and compare that to the for loop's line number
+ continue
+ if (
+ isinstance(subscript.parent, astroid.Assign)
+ and subscript in subscript.parent.targets
+ or isinstance(subscript.parent, astroid.AugAssign)
+ and subscript == subscript.parent.target
+ ):
+ # Ignore this subscript if it is the target of an assignment
+ continue
+
+ self.add_message("consider-using-dict-items", node=node)
+ return
+
+ @utils.check_messages("consider-using-dict-items")
+ def visit_comprehension(self, node: astroid.Comprehension) -> None:
+ iterating_object_name = utils.get_iterating_dictionary_name(node)
+ if iterating_object_name is None:
+ return
+
+ for child in node.parent.get_children():
+ for subscript in child.nodes_of_class(astroid.Subscript):
+ subscript = cast(astroid.Subscript, subscript)
+
+ if not isinstance(subscript.value, (astroid.Name, astroid.Attribute)):
+ continue
+
+ value = subscript.slice
+ if (
+ not isinstance(value, astroid.Name)
+ or value.name != node.target.name
+ or iterating_object_name != subscript.value.as_string()
+ ):
+ continue
+
+ self.add_message("consider-using-dict-items", node=node)
+ return
diff --git a/pylint/checkers/refactoring/refactoring_checker.py b/pylint/checkers/refactoring/refactoring_checker.py
new file mode 100644
index 0000000..e771db7
--- /dev/null
+++ b/pylint/checkers/refactoring/refactoring_checker.py
@@ -0,0 +1,1750 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+import copy
+import itertools
+import tokenize
+from functools import reduce
+from typing import List, Optional, Tuple, Union, cast
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint import utils as lint_utils
+from pylint.checkers import utils
+from pylint.checkers.utils import node_frame_class
+
+KNOWN_INFINITE_ITERATORS = {"itertools.count"}
+BUILTIN_EXIT_FUNCS = frozenset(("quit", "exit"))
+CALLS_THAT_COULD_BE_REPLACED_BY_WITH = frozenset(
+ (
+ "threading.lock.acquire",
+ "threading._RLock.acquire",
+ "threading.Semaphore.acquire",
+ "multiprocessing.managers.BaseManager.start",
+ "multiprocessing.managers.SyncManager.start",
+ )
+)
+CALLS_RETURNING_CONTEXT_MANAGERS = frozenset(
+ (
+ "_io.open", # regular 'open()' call
+ "codecs.open",
+ "urllib.request.urlopen",
+ "tempfile.NamedTemporaryFile",
+ "tempfile.SpooledTemporaryFile",
+ "tempfile.TemporaryDirectory",
+ "zipfile.ZipFile",
+ "zipfile.PyZipFile",
+ "zipfile.ZipFile.open",
+ "zipfile.PyZipFile.open",
+ "tarfile.TarFile",
+ "tarfile.TarFile.open",
+ "multiprocessing.context.BaseContext.Pool",
+ "concurrent.futures.thread.ThreadPoolExecutor",
+ "concurrent.futures.process.ProcessPoolExecutor",
+ "subprocess.Popen",
+ )
+)
+
+
+def _if_statement_is_always_returning(if_node, returning_node_class) -> bool:
+ for node in if_node.body:
+ if isinstance(node, returning_node_class):
+ return True
+ return False
+
+
+def _is_trailing_comma(tokens: List[tokenize.TokenInfo], index: int) -> bool:
+ """Check if the given token is a trailing comma
+
+ :param tokens: Sequence of modules tokens
+ :type tokens: list[tokenize.TokenInfo]
+ :param int index: Index of token under check in tokens
+ :returns: True if the token is a comma which trails an expression
+ :rtype: bool
+ """
+ token = tokens[index]
+ if token.exact_type != tokenize.COMMA:
+ return False
+ # Must have remaining tokens on the same line such as NEWLINE
+ left_tokens = itertools.islice(tokens, index + 1, None)
+
+ def same_start_token(
+ other_token: tokenize.TokenInfo, _token: tokenize.TokenInfo = token
+ ) -> bool:
+ return other_token.start[0] == _token.start[0]
+
+ same_line_remaining_tokens = list(
+ itertools.takewhile(same_start_token, left_tokens)
+ )
+ # Note: If the newline is tokenize.NEWLINE and not tokenize.NL
+ # then the newline denotes the end of expression
+ is_last_element = all(
+ other_token.type in (tokenize.NEWLINE, tokenize.COMMENT)
+ for other_token in same_line_remaining_tokens
+ )
+ if not same_line_remaining_tokens or not is_last_element:
+ return False
+
+ def get_curline_index_start():
+ """Get the index denoting the start of the current line"""
+ for subindex, token in enumerate(reversed(tokens[:index])):
+ # See Lib/tokenize.py and Lib/token.py in cpython for more info
+ if token.type == tokenize.NEWLINE:
+ return index - subindex
+ return 0
+
+ curline_start = get_curline_index_start()
+ expected_tokens = {"return", "yield"}
+ for prevtoken in tokens[curline_start:index]:
+ if "=" in prevtoken.string or prevtoken.string in expected_tokens:
+ return True
+ return False
+
+
+def _is_inside_context_manager(node):
+ frame = node.frame()
+ if not isinstance(
+ frame, (astroid.FunctionDef, astroid.BoundMethod, astroid.UnboundMethod)
+ ):
+ return False
+ return frame.name == "__enter__" or utils.decorated_with(
+ frame, "contextlib.contextmanager"
+ )
+
+
+class RefactoringChecker(checkers.BaseTokenChecker):
+ """Looks for code which can be refactored
+
+ This checker also mixes the astroid and the token approaches
+ in order to create knowledge about whether an "else if" node
+ is a true "else if" node, or an "elif" node.
+ """
+
+ __implements__ = (interfaces.ITokenChecker, interfaces.IAstroidChecker)
+
+ name = "refactoring"
+
+ msgs = {
+ "R1701": (
+ "Consider merging these isinstance calls to isinstance(%s, (%s))",
+ "consider-merging-isinstance",
+ "Used when multiple consecutive isinstance calls can be merged into one.",
+ ),
+ "R1706": (
+ "Consider using ternary (%s)",
+ "consider-using-ternary",
+ "Used when one of known pre-python 2.5 ternary syntax is used.",
+ ),
+ "R1709": (
+ "Boolean expression may be simplified to %s",
+ "simplify-boolean-expression",
+ "Emitted when redundant pre-python 2.5 ternary syntax is used.",
+ ),
+ "R1726": (
+ "Boolean condition '%s' may be simplified to '%s'",
+ "simplifiable-condition",
+ "Emitted when a boolean condition is able to be simplified.",
+ ),
+ "R1727": (
+ "Boolean condition '%s' will always evaluate to '%s'",
+ "condition-evals-to-constant",
+ "Emitted when a boolean condition can be simplified to a constant value.",
+ ),
+ "R1702": (
+ "Too many nested blocks (%s/%s)",
+ "too-many-nested-blocks",
+ "Used when a function or a method has too many nested "
+ "blocks. This makes the code less understandable and "
+ "maintainable.",
+ {"old_names": [("R0101", "old-too-many-nested-blocks")]},
+ ),
+ "R1703": (
+ "The if statement can be replaced with %s",
+ "simplifiable-if-statement",
+ "Used when an if statement can be replaced with 'bool(test)'. ",
+ {"old_names": [("R0102", "old-simplifiable-if-statement")]},
+ ),
+ "R1704": (
+ "Redefining argument with the local name %r",
+ "redefined-argument-from-local",
+ "Used when a local name is redefining an argument, which might "
+ "suggest a potential error. This is taken in account only for "
+ "a handful of name binding operations, such as for iteration, "
+ "with statement assignment and exception handler assignment.",
+ ),
+ "R1705": (
+ 'Unnecessary "%s" after "return"',
+ "no-else-return",
+ "Used in order to highlight an unnecessary block of "
+ "code following an if containing a return statement. "
+ "As such, it will warn when it encounters an else "
+ "following a chain of ifs, all of them containing a "
+ "return statement.",
+ ),
+ "R1707": (
+ "Disallow trailing comma tuple",
+ "trailing-comma-tuple",
+ "In Python, a tuple is actually created by the comma symbol, "
+ "not by the parentheses. Unfortunately, one can actually create a "
+ "tuple by misplacing a trailing comma, which can lead to potential "
+ "weird bugs in your code. You should always use parentheses "
+ "explicitly for creating a tuple.",
+ ),
+ "R1708": (
+ "Do not raise StopIteration in generator, use return statement instead",
+ "stop-iteration-return",
+ "According to PEP479, the raise of StopIteration to end the loop of "
+ "a generator may lead to hard to find bugs. This PEP specify that "
+ "raise StopIteration has to be replaced by a simple return statement",
+ ),
+ "R1710": (
+ "Either all return statements in a function should return an expression, "
+ "or none of them should.",
+ "inconsistent-return-statements",
+ "According to PEP8, if any return statement returns an expression, "
+ "any return statements where no value is returned should explicitly "
+ "state this as return None, and an explicit return statement "
+ "should be present at the end of the function (if reachable)",
+ ),
+ "R1711": (
+ "Useless return at end of function or method",
+ "useless-return",
+ 'Emitted when a single "return" or "return None" statement is found '
+ "at the end of function or method definition. This statement can safely be "
+ "removed because Python will implicitly return None",
+ ),
+ "R1712": (
+ "Consider using tuple unpacking for swapping variables",
+ "consider-swap-variables",
+ "You do not have to use a temporary variable in order to "
+ 'swap variables. Using "tuple unpacking" to directly swap '
+ "variables makes the intention more clear.",
+ ),
+ "R1713": (
+ "Consider using str.join(sequence) for concatenating "
+ "strings from an iterable",
+ "consider-using-join",
+ "Using str.join(sequence) is faster, uses less memory "
+ "and increases readability compared to for-loop iteration.",
+ ),
+ "R1714": (
+ 'Consider merging these comparisons with "in" to %r',
+ "consider-using-in",
+ "To check if a variable is equal to one of many values,"
+ 'combine the values into a tuple and check if the variable is contained "in" it '
+ "instead of checking for equality against each of the values."
+ "This is faster and less verbose.",
+ ),
+ "R1715": (
+ "Consider using dict.get for getting values from a dict "
+ "if a key is present or a default if not",
+ "consider-using-get",
+ "Using the builtin dict.get for getting a value from a dictionary "
+ "if a key is present or a default if not, is simpler and considered "
+ "more idiomatic, although sometimes a bit slower",
+ ),
+ "R1716": (
+ "Simplify chained comparison between the operands",
+ "chained-comparison",
+ "This message is emitted when pylint encounters boolean operation like"
+ '"a < b and b < c", suggesting instead to refactor it to "a < b < c"',
+ ),
+ "R1717": (
+ "Consider using a dictionary comprehension",
+ "consider-using-dict-comprehension",
+ "Emitted when we detect the creation of a dictionary "
+ "using the dict() callable and a transient list. "
+ "Although there is nothing syntactically wrong with this code, "
+ "it is hard to read and can be simplified to a dict comprehension."
+ "Also it is faster since you don't need to create another "
+ "transient list",
+ ),
+ "R1718": (
+ "Consider using a set comprehension",
+ "consider-using-set-comprehension",
+ "Although there is nothing syntactically wrong with this code, "
+ "it is hard to read and can be simplified to a set comprehension."
+ "Also it is faster since you don't need to create another "
+ "transient list",
+ ),
+ "R1719": (
+ "The if expression can be replaced with %s",
+ "simplifiable-if-expression",
+ "Used when an if expression can be replaced with 'bool(test)'. ",
+ ),
+ "R1720": (
+ 'Unnecessary "%s" after "raise"',
+ "no-else-raise",
+ "Used in order to highlight an unnecessary block of "
+ "code following an if containing a raise statement. "
+ "As such, it will warn when it encounters an else "
+ "following a chain of ifs, all of them containing a "
+ "raise statement.",
+ ),
+ "R1721": (
+ "Unnecessary use of a comprehension, use %s instead.",
+ "unnecessary-comprehension",
+ "Instead of using an identity comprehension, "
+ "consider using the list, dict or set constructor. "
+ "It is faster and simpler.",
+ ),
+ "R1722": (
+ "Consider using sys.exit()",
+ "consider-using-sys-exit",
+ "Instead of using exit() or quit(), consider using the sys.exit().",
+ ),
+ "R1723": (
+ 'Unnecessary "%s" after "break"',
+ "no-else-break",
+ "Used in order to highlight an unnecessary block of "
+ "code following an if containing a break statement. "
+ "As such, it will warn when it encounters an else "
+ "following a chain of ifs, all of them containing a "
+ "break statement.",
+ ),
+ "R1724": (
+ 'Unnecessary "%s" after "continue"',
+ "no-else-continue",
+ "Used in order to highlight an unnecessary block of "
+ "code following an if containing a continue statement. "
+ "As such, it will warn when it encounters an else "
+ "following a chain of ifs, all of them containing a "
+ "continue statement.",
+ ),
+ "R1725": (
+ "Consider using Python 3 style super() without arguments",
+ "super-with-arguments",
+ "Emitted when calling the super() builtin with the current class "
+ "and instance. On Python 3 these arguments are the default and they can be omitted.",
+ ),
+ "R1728": (
+ "Consider using a generator instead '%s(%s)'",
+ "consider-using-generator",
+ "If your container can be large using "
+ "a generator will bring better performance.",
+ ),
+ "R1729": (
+ "Use a generator instead '%s(%s)'",
+ "use-a-generator",
+ "Comprehension inside of 'any' or 'all' is unnecessary. "
+ "A generator would be sufficient and faster.",
+ ),
+ "R1730": (
+ "Consider using '%s' instead of unnecessary if block",
+ "consider-using-min-builtin",
+ "Using the min builtin instead of a conditional improves readability and conciseness.",
+ ),
+ "R1731": (
+ "Consider using '%s' instead of unnecessary if block",
+ "consider-using-max-builtin",
+ "Using the max builtin instead of a conditional improves readability and conciseness.",
+ ),
+ "R1732": (
+ "Consider using 'with' for resource-allocating operations",
+ "consider-using-with",
+ "Emitted if a resource-allocating assignment or call may be replaced by a 'with' block. "
+ "By using 'with' the release of the allocated resources is ensured even in the case of an exception.",
+ ),
+ "R1733": (
+ "Unnecessary dictionary index lookup, use '%s' instead",
+ "unnecessary-dict-index-lookup",
+ "Emitted when iterating over the dictionary items (key-item pairs) and accessing the "
+ "value by index lookup. "
+ "The value can be accessed directly instead.",
+ ),
+ }
+ options = (
+ (
+ "max-nested-blocks",
+ {
+ "default": 5,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of nested blocks for function / method body",
+ },
+ ),
+ (
+ "never-returning-functions",
+ {
+ "default": ("sys.exit", "argparse.parse_error"),
+ "type": "csv",
+ "help": "Complete name of functions that never returns. When checking "
+ "for inconsistent-return-statements if a never returning function is "
+ "called then it will be considered as an explicit return statement "
+ "and no message will be printed.",
+ },
+ ),
+ )
+
+ priority = 0
+
+ def __init__(self, linter=None):
+ checkers.BaseTokenChecker.__init__(self, linter)
+ self._return_nodes = {}
+ self._init()
+ self._never_returning_functions = None
+
+ def _init(self):
+ self._nested_blocks = []
+ self._elifs = []
+ self._nested_blocks_msg = None
+ self._reported_swap_nodes = set()
+ self._can_simplify_bool_op = False
+
+ def open(self):
+ # do this in open since config not fully initialized in __init__
+ self._never_returning_functions = set(self.config.never_returning_functions)
+
+ @astroid.decorators.cachedproperty
+ def _dummy_rgx(self):
+ return lint_utils.get_global_option(self, "dummy-variables-rgx", default=None)
+
+ @staticmethod
+ def _is_bool_const(node):
+ return isinstance(node.value, astroid.Const) and isinstance(
+ node.value.value, bool
+ )
+
+ def _is_actual_elif(self, node):
+ """Check if the given node is an actual elif
+
+ This is a problem we're having with the builtin ast module,
+ which splits `elif` branches into a separate if statement.
+ Unfortunately we need to know the exact type in certain
+ cases.
+ """
+ if isinstance(node.parent, astroid.If):
+ orelse = node.parent.orelse
+ # current if node must directly follow an "else"
+ if orelse and orelse == [node]:
+ if (node.lineno, node.col_offset) in self._elifs:
+ return True
+ return False
+
+ def _check_simplifiable_if(self, node):
+ """Check if the given if node can be simplified.
+
+ The if statement can be reduced to a boolean expression
+ in some cases. For instance, if there are two branches
+ and both of them return a boolean value that depends on
+ the result of the statement's test, then this can be reduced
+ to `bool(test)` without losing any functionality.
+ """
+
+ if self._is_actual_elif(node):
+ # Not interested in if statements with multiple branches.
+ return
+ if len(node.orelse) != 1 or len(node.body) != 1:
+ return
+
+ # Check if both branches can be reduced.
+ first_branch = node.body[0]
+ else_branch = node.orelse[0]
+ if isinstance(first_branch, astroid.Return):
+ if not isinstance(else_branch, astroid.Return):
+ return
+ first_branch_is_bool = self._is_bool_const(first_branch)
+ else_branch_is_bool = self._is_bool_const(else_branch)
+ reduced_to = "'return bool(test)'"
+ elif isinstance(first_branch, astroid.Assign):
+ if not isinstance(else_branch, astroid.Assign):
+ return
+
+ # Check if we assign to the same value
+ first_branch_targets = [
+ target.name
+ for target in first_branch.targets
+ if isinstance(target, astroid.AssignName)
+ ]
+ else_branch_targets = [
+ target.name
+ for target in else_branch.targets
+ if isinstance(target, astroid.AssignName)
+ ]
+ if not first_branch_targets or not else_branch_targets:
+ return
+ if sorted(first_branch_targets) != sorted(else_branch_targets):
+ return
+
+ first_branch_is_bool = self._is_bool_const(first_branch)
+ else_branch_is_bool = self._is_bool_const(else_branch)
+ reduced_to = "'var = bool(test)'"
+ else:
+ return
+
+ if not first_branch_is_bool or not else_branch_is_bool:
+ return
+ if not first_branch.value.value:
+ # This is a case that can't be easily simplified and
+ # if it can be simplified, it will usually result in a
+ # code that's harder to understand and comprehend.
+ # Let's take for instance `arg and arg <= 3`. This could theoretically be
+ # reduced to `not arg or arg > 3`, but the net result is that now the
+ # condition is harder to understand, because it requires understanding of
+ # an extra clause:
+ # * first, there is the negation of truthness with `not arg`
+ # * the second clause is `arg > 3`, which occurs when arg has a
+ # a truth value, but it implies that `arg > 3` is equivalent
+ # with `arg and arg > 3`, which means that the user must
+ # think about this assumption when evaluating `arg > 3`.
+ # The original form is easier to grasp.
+ return
+
+ self.add_message("simplifiable-if-statement", node=node, args=(reduced_to,))
+
+ def process_tokens(self, tokens):
+ # Process tokens and look for 'if' or 'elif'
+ for index, token in enumerate(tokens):
+ token_string = token[1]
+ if token_string == "elif":
+ # AST exists by the time process_tokens is called, so
+ # it's safe to assume tokens[index+1]
+ # exists. tokens[index+1][2] is the elif's position as
+ # reported by CPython and PyPy,
+ # tokens[index][2] is the actual position and also is
+ # reported by IronPython.
+ self._elifs.extend([tokens[index][2], tokens[index + 1][2]])
+ elif _is_trailing_comma(tokens, index):
+ if self.linter.is_message_enabled("trailing-comma-tuple"):
+ self.add_message("trailing-comma-tuple", line=token.start[0])
+
+ def leave_module(self, _):
+ self._init()
+
+ @utils.check_messages("too-many-nested-blocks")
+ def visit_tryexcept(self, node):
+ self._check_nested_blocks(node)
+
+ visit_tryfinally = visit_tryexcept
+ visit_while = visit_tryexcept
+
+ def _check_redefined_argument_from_local(self, name_node):
+ if self._dummy_rgx and self._dummy_rgx.match(name_node.name):
+ return
+ if not name_node.lineno:
+ # Unknown position, maybe it is a manually built AST?
+ return
+
+ scope = name_node.scope()
+ if not isinstance(scope, astroid.FunctionDef):
+ return
+
+ for defined_argument in scope.args.nodes_of_class(
+ astroid.AssignName, skip_klass=(astroid.Lambda,)
+ ):
+ if defined_argument.name == name_node.name:
+ self.add_message(
+ "redefined-argument-from-local",
+ node=name_node,
+ args=(name_node.name,),
+ )
+
+ @utils.check_messages(
+ "redefined-argument-from-local",
+ "too-many-nested-blocks",
+ "unnecessary-dict-index-lookup",
+ )
+ def visit_for(self, node):
+ self._check_nested_blocks(node)
+ self._check_unnecessary_dict_index_lookup(node)
+
+ for name in node.target.nodes_of_class(astroid.AssignName):
+ self._check_redefined_argument_from_local(name)
+
+ @utils.check_messages("redefined-argument-from-local")
+ def visit_excepthandler(self, node):
+ if node.name and isinstance(node.name, astroid.AssignName):
+ self._check_redefined_argument_from_local(node.name)
+
+ @utils.check_messages("redefined-argument-from-local")
+ def visit_with(self, node):
+ for _, names in node.items:
+ if not names:
+ continue
+ for name in names.nodes_of_class(astroid.AssignName):
+ self._check_redefined_argument_from_local(name)
+
+ def _check_superfluous_else(self, node, msg_id, returning_node_class):
+ if not node.orelse:
+ # Not interested in if statements without else.
+ return
+
+ if self._is_actual_elif(node):
+ # Not interested in elif nodes; only if
+ return
+
+ if _if_statement_is_always_returning(node, returning_node_class):
+ orelse = node.orelse[0]
+ followed_by_elif = (orelse.lineno, orelse.col_offset) in self._elifs
+ self.add_message(
+ msg_id, node=node, args="elif" if followed_by_elif else "else"
+ )
+
+ def _check_superfluous_else_return(self, node):
+ return self._check_superfluous_else(
+ node, msg_id="no-else-return", returning_node_class=astroid.Return
+ )
+
+ def _check_superfluous_else_raise(self, node):
+ return self._check_superfluous_else(
+ node, msg_id="no-else-raise", returning_node_class=astroid.Raise
+ )
+
+ def _check_superfluous_else_break(self, node):
+ return self._check_superfluous_else(
+ node, msg_id="no-else-break", returning_node_class=astroid.Break
+ )
+
+ def _check_superfluous_else_continue(self, node):
+ return self._check_superfluous_else(
+ node, msg_id="no-else-continue", returning_node_class=astroid.Continue
+ )
+
+ @staticmethod
+ def _type_and_name_are_equal(node_a, node_b):
+ for _type in (astroid.Name, astroid.AssignName):
+ if all(isinstance(_node, _type) for _node in (node_a, node_b)):
+ return node_a.name == node_b.name
+ if all(isinstance(_node, astroid.Const) for _node in (node_a, node_b)):
+ return node_a.value == node_b.value
+ return False
+
+ def _is_dict_get_block(self, node):
+
+ # "if <compare node>"
+ if not isinstance(node.test, astroid.Compare):
+ return False
+
+ # Does not have a single statement in the guard's body
+ if len(node.body) != 1:
+ return False
+
+ # Look for a single variable assignment on the LHS and a subscript on RHS
+ stmt = node.body[0]
+ if not (
+ isinstance(stmt, astroid.Assign)
+ and len(node.body[0].targets) == 1
+ and isinstance(node.body[0].targets[0], astroid.AssignName)
+ and isinstance(stmt.value, astroid.Subscript)
+ ):
+ return False
+
+ # The subscript's slice needs to be the same as the test variable.
+ slice_value = stmt.value.slice
+ if not (
+ self._type_and_name_are_equal(stmt.value.value, node.test.ops[0][1])
+ and self._type_and_name_are_equal(slice_value, node.test.left)
+ ):
+ return False
+
+ # The object needs to be a dictionary instance
+ return isinstance(utils.safe_infer(node.test.ops[0][1]), astroid.Dict)
+
+ def _check_consider_get(self, node):
+ if_block_ok = self._is_dict_get_block(node)
+ if if_block_ok and not node.orelse:
+ self.add_message("consider-using-get", node=node)
+ elif (
+ if_block_ok
+ and len(node.orelse) == 1
+ and isinstance(node.orelse[0], astroid.Assign)
+ and self._type_and_name_are_equal(
+ node.orelse[0].targets[0], node.body[0].targets[0]
+ )
+ and len(node.orelse[0].targets) == 1
+ ):
+ self.add_message("consider-using-get", node=node)
+
+ @utils.check_messages(
+ "too-many-nested-blocks",
+ "simplifiable-if-statement",
+ "no-else-return",
+ "no-else-raise",
+ "no-else-break",
+ "no-else-continue",
+ "consider-using-get",
+ )
+ def visit_if(self, node):
+ self._check_simplifiable_if(node)
+ self._check_nested_blocks(node)
+ self._check_superfluous_else_return(node)
+ self._check_superfluous_else_raise(node)
+ self._check_superfluous_else_break(node)
+ self._check_superfluous_else_continue(node)
+ self._check_consider_get(node)
+ self._check_consider_using_min_max_builtin(node)
+
+ def _check_consider_using_min_max_builtin(self, node: astroid.If):
+ """Check if the given if node can be refactored as an min/max python builtin."""
+ if self._is_actual_elif(node) or node.orelse:
+ # Not interested in if statements with multiple branches.
+ return
+
+ if len(node.body) != 1:
+ return
+
+ body = node.body[0]
+ # Check if condition can be reduced.
+ if not hasattr(body, "targets") or len(body.targets) != 1:
+ return
+
+ target = body.targets[0]
+ if not (
+ isinstance(node.test, astroid.Compare)
+ and not isinstance(target, astroid.Subscript)
+ and not isinstance(node.test.left, astroid.Subscript)
+ and isinstance(body, astroid.Assign)
+ ):
+ return
+
+ # Check that the assignation is on the same variable.
+ if hasattr(node.test.left, "name"):
+ left_operand = node.test.left.name
+ elif hasattr(node.test.left, "attrname"):
+ left_operand = node.test.left.attrname
+ else:
+ return
+
+ if hasattr(target, "name"):
+ target_assignation = target.name
+ elif hasattr(target, "attrname"):
+ target_assignation = target.attrname
+ else:
+ return
+
+ if not (left_operand == target_assignation):
+ return
+
+ if len(node.test.ops) > 1:
+ return
+
+ if not isinstance(body.value, (astroid.Name, astroid.Const)):
+ return
+
+ operator, right_statement = node.test.ops[0]
+ if isinstance(body.value, astroid.Name):
+ body_value = body.value.name
+ else:
+ body_value = body.value.value
+
+ if isinstance(right_statement, astroid.Name):
+ right_statement_value = right_statement.name
+ elif isinstance(right_statement, astroid.Const):
+ right_statement_value = right_statement.value
+ else:
+ return
+
+ # Verify the right part of the statement is the same.
+ if right_statement_value != body_value:
+ return
+
+ if operator in ("<", "<="):
+ reduced_to = "{target} = max({target}, {item})".format(
+ target=target_assignation, item=body_value
+ )
+ self.add_message(
+ "consider-using-max-builtin", node=node, args=(reduced_to,)
+ )
+ elif operator in (">", ">="):
+ reduced_to = "{target} = min({target}, {item})".format(
+ target=target_assignation, item=body_value
+ )
+ self.add_message(
+ "consider-using-min-builtin", node=node, args=(reduced_to,)
+ )
+
+ @utils.check_messages("simplifiable-if-expression")
+ def visit_ifexp(self, node):
+ self._check_simplifiable_ifexp(node)
+
+ def _check_simplifiable_ifexp(self, node):
+ if not isinstance(node.body, astroid.Const) or not isinstance(
+ node.orelse, astroid.Const
+ ):
+ return
+
+ if not isinstance(node.body.value, bool) or not isinstance(
+ node.orelse.value, bool
+ ):
+ return
+
+ if isinstance(node.test, astroid.Compare):
+ test_reduced_to = "test"
+ else:
+ test_reduced_to = "bool(test)"
+
+ if (node.body.value, node.orelse.value) == (True, False):
+ reduced_to = f"'{test_reduced_to}'"
+ elif (node.body.value, node.orelse.value) == (False, True):
+ reduced_to = "'not test'"
+ else:
+ return
+
+ self.add_message("simplifiable-if-expression", node=node, args=(reduced_to,))
+
+ @utils.check_messages(
+ "too-many-nested-blocks", "inconsistent-return-statements", "useless-return"
+ )
+ def leave_functiondef(self, node):
+ # check left-over nested blocks stack
+ self._emit_nested_blocks_message_if_needed(self._nested_blocks)
+ # new scope = reinitialize the stack of nested blocks
+ self._nested_blocks = []
+ # check consistent return statements
+ self._check_consistent_returns(node)
+ # check for single return or return None at the end
+ self._check_return_at_the_end(node)
+ self._return_nodes[node.name] = []
+
+ @utils.check_messages("stop-iteration-return")
+ def visit_raise(self, node):
+ self._check_stop_iteration_inside_generator(node)
+
+ def _check_stop_iteration_inside_generator(self, node):
+ """Check if an exception of type StopIteration is raised inside a generator"""
+ frame = node.frame()
+ if not isinstance(frame, astroid.FunctionDef) or not frame.is_generator():
+ return
+ if utils.node_ignores_exception(node, StopIteration):
+ return
+ if not node.exc:
+ return
+ exc = utils.safe_infer(node.exc)
+ if not exc or not isinstance(exc, (astroid.Instance, astroid.ClassDef)):
+ return
+ if self._check_exception_inherit_from_stopiteration(exc):
+ self.add_message("stop-iteration-return", node=node)
+
+ @staticmethod
+ def _check_exception_inherit_from_stopiteration(exc):
+ """Return True if the exception node in argument inherit from StopIteration"""
+ stopiteration_qname = f"{utils.EXCEPTIONS_MODULE}.StopIteration"
+ return any(_class.qname() == stopiteration_qname for _class in exc.mro())
+
+ def _check_consider_using_comprehension_constructor(self, node):
+ if (
+ isinstance(node.func, astroid.Name)
+ and node.args
+ and isinstance(node.args[0], astroid.ListComp)
+ ):
+ if node.func.name == "dict" and not isinstance(
+ node.args[0].elt, astroid.Call
+ ):
+ message_name = "consider-using-dict-comprehension"
+ self.add_message(message_name, node=node)
+ elif node.func.name == "set":
+ message_name = "consider-using-set-comprehension"
+ self.add_message(message_name, node=node)
+
+ def _check_consider_using_generator(self, node):
+ # 'any' and 'all' definitely should use generator, while 'list' and 'tuple' need to be considered first
+ # See https://github.com/PyCQA/pylint/pull/3309#discussion_r576683109
+ checked_call = ["any", "all", "list", "tuple"]
+ if (
+ isinstance(node, astroid.Call)
+ and node.func
+ and isinstance(node.func, astroid.Name)
+ and node.func.name in checked_call
+ ):
+ # functions in checked_calls take exactly one argument
+ # check whether the argument is list comprehension
+ if len(node.args) == 1 and isinstance(node.args[0], astroid.ListComp):
+ # remove square brackets '[]'
+ inside_comp = node.args[0].as_string()[1:-1]
+ call_name = node.func.name
+ if call_name in ["any", "all"]:
+ self.add_message(
+ "use-a-generator",
+ node=node,
+ args=(call_name, inside_comp),
+ )
+ else:
+ self.add_message(
+ "consider-using-generator",
+ node=node,
+ args=(call_name, inside_comp),
+ )
+
+ @utils.check_messages(
+ "stop-iteration-return",
+ "consider-using-dict-comprehension",
+ "consider-using-set-comprehension",
+ "consider-using-sys-exit",
+ "super-with-arguments",
+ "consider-using-generator",
+ "consider-using-with",
+ )
+ def visit_call(self, node):
+ self._check_raising_stopiteration_in_generator_next_call(node)
+ self._check_consider_using_comprehension_constructor(node)
+ self._check_quit_exit_call(node)
+ self._check_super_with_arguments(node)
+ self._check_consider_using_generator(node)
+ self._check_consider_using_with(node)
+
+ @staticmethod
+ def _has_exit_in_scope(scope):
+ exit_func = scope.locals.get("exit")
+ return bool(
+ exit_func and isinstance(exit_func[0], (astroid.ImportFrom, astroid.Import))
+ )
+
+ def _check_quit_exit_call(self, node):
+
+ if isinstance(node.func, astroid.Name) and node.func.name in BUILTIN_EXIT_FUNCS:
+ # If we have `exit` imported from `sys` in the current or global scope, exempt this instance.
+ local_scope = node.scope()
+ if self._has_exit_in_scope(local_scope) or self._has_exit_in_scope(
+ node.root()
+ ):
+ return
+ self.add_message("consider-using-sys-exit", node=node)
+
+ def _check_super_with_arguments(self, node):
+ if not isinstance(node.func, astroid.Name) or node.func.name != "super":
+ return
+
+ # pylint: disable=too-many-boolean-expressions
+ if (
+ len(node.args) != 2
+ or not isinstance(node.args[1], astroid.Name)
+ or node.args[1].name != "self"
+ or not isinstance(node.args[0], astroid.Name)
+ or not isinstance(node.args[1], astroid.Name)
+ or node_frame_class(node) is None
+ or node.args[0].name != node_frame_class(node).name
+ ):
+ return
+
+ self.add_message("super-with-arguments", node=node)
+
+ def _check_raising_stopiteration_in_generator_next_call(self, node):
+ """Check if a StopIteration exception is raised by the call to next function
+
+ If the next value has a default value, then do not add message.
+
+ :param node: Check to see if this Call node is a next function
+ :type node: :class:`astroid.node_classes.Call`
+ """
+
+ def _looks_like_infinite_iterator(param):
+ inferred = utils.safe_infer(param)
+ if inferred:
+ return inferred.qname() in KNOWN_INFINITE_ITERATORS
+ return False
+
+ if isinstance(node.func, astroid.Attribute):
+ # A next() method, which is now what we want.
+ return
+
+ inferred = utils.safe_infer(node.func)
+ if getattr(inferred, "name", "") == "next":
+ frame = node.frame()
+ # The next builtin can only have up to two
+ # positional arguments and no keyword arguments
+ has_sentinel_value = len(node.args) > 1
+ if (
+ isinstance(frame, astroid.FunctionDef)
+ and frame.is_generator()
+ and not has_sentinel_value
+ and not utils.node_ignores_exception(node, StopIteration)
+ and not _looks_like_infinite_iterator(node.args[0])
+ ):
+ self.add_message("stop-iteration-return", node=node)
+
+ def _check_nested_blocks(self, node):
+ """Update and check the number of nested blocks"""
+ # only check block levels inside functions or methods
+ if not isinstance(node.scope(), astroid.FunctionDef):
+ return
+ # messages are triggered on leaving the nested block. Here we save the
+ # stack in case the current node isn't nested in the previous one
+ nested_blocks = self._nested_blocks[:]
+ if node.parent == node.scope():
+ self._nested_blocks = [node]
+ else:
+ # go through ancestors from the most nested to the less
+ for ancestor_node in reversed(self._nested_blocks):
+ if ancestor_node == node.parent:
+ break
+ self._nested_blocks.pop()
+ # if the node is an elif, this should not be another nesting level
+ if isinstance(node, astroid.If) and self._is_actual_elif(node):
+ if self._nested_blocks:
+ self._nested_blocks.pop()
+ self._nested_blocks.append(node)
+
+ # send message only once per group of nested blocks
+ if len(nested_blocks) > len(self._nested_blocks):
+ self._emit_nested_blocks_message_if_needed(nested_blocks)
+
+ def _emit_nested_blocks_message_if_needed(self, nested_blocks):
+ if len(nested_blocks) > self.config.max_nested_blocks:
+ self.add_message(
+ "too-many-nested-blocks",
+ node=nested_blocks[0],
+ args=(len(nested_blocks), self.config.max_nested_blocks),
+ )
+
+ @staticmethod
+ def _duplicated_isinstance_types(node):
+ """Get the duplicated types from the underlying isinstance calls.
+
+ :param astroid.BoolOp node: Node which should contain a bunch of isinstance calls.
+ :returns: Dictionary of the comparison objects from the isinstance calls,
+ to duplicate values from consecutive calls.
+ :rtype: dict
+ """
+ duplicated_objects = set()
+ all_types = collections.defaultdict(set)
+
+ for call in node.values:
+ if not isinstance(call, astroid.Call) or len(call.args) != 2:
+ continue
+
+ inferred = utils.safe_infer(call.func)
+ if not inferred or not utils.is_builtin_object(inferred):
+ continue
+
+ if inferred.name != "isinstance":
+ continue
+
+ isinstance_object = call.args[0].as_string()
+ isinstance_types = call.args[1]
+
+ if isinstance_object in all_types:
+ duplicated_objects.add(isinstance_object)
+
+ if isinstance(isinstance_types, astroid.Tuple):
+ elems = [
+ class_type.as_string() for class_type in isinstance_types.itered()
+ ]
+ else:
+ elems = [isinstance_types.as_string()]
+ all_types[isinstance_object].update(elems)
+
+ # Remove all keys which not duplicated
+ return {
+ key: value for key, value in all_types.items() if key in duplicated_objects
+ }
+
+ def _check_consider_merging_isinstance(self, node):
+ """Check isinstance calls which can be merged together."""
+ if node.op != "or":
+ return
+
+ first_args = self._duplicated_isinstance_types(node)
+ for duplicated_name, class_names in first_args.items():
+ names = sorted(name for name in class_names)
+ self.add_message(
+ "consider-merging-isinstance",
+ node=node,
+ args=(duplicated_name, ", ".join(names)),
+ )
+
+ def _check_consider_using_in(self, node):
+ allowed_ops = {"or": "==", "and": "!="}
+
+ if node.op not in allowed_ops or len(node.values) < 2:
+ return
+
+ for value in node.values:
+ if (
+ not isinstance(value, astroid.Compare)
+ or len(value.ops) != 1
+ or value.ops[0][0] not in allowed_ops[node.op]
+ ):
+ return
+ for comparable in value.left, value.ops[0][1]:
+ if isinstance(comparable, astroid.Call):
+ return
+
+ # Gather variables and values from comparisons
+ variables, values = [], []
+ for value in node.values:
+ variable_set = set()
+ for comparable in value.left, value.ops[0][1]:
+ if isinstance(comparable, astroid.Name):
+ variable_set.add(comparable.as_string())
+ values.append(comparable.as_string())
+ variables.append(variable_set)
+
+ # Look for (common-)variables that occur in all comparisons
+ common_variables = reduce(lambda a, b: a.intersection(b), variables)
+
+ if not common_variables:
+ return
+
+ # Gather information for the suggestion
+ common_variable = sorted(list(common_variables))[0]
+ comprehension = "in" if node.op == "or" else "not in"
+ values = list(collections.OrderedDict.fromkeys(values))
+ values.remove(common_variable)
+ values_string = ", ".join(values) if len(values) != 1 else values[0] + ","
+ suggestion = f"{common_variable} {comprehension} ({values_string})"
+
+ self.add_message("consider-using-in", node=node, args=(suggestion,))
+
+ def _check_chained_comparison(self, node):
+ """Check if there is any chained comparison in the expression.
+
+ Add a refactoring message if a boolOp contains comparison like a < b and b < c,
+ which can be chained as a < b < c.
+
+ Care is taken to avoid simplifying a < b < c and b < d.
+ """
+ if node.op != "and" or len(node.values) < 2:
+ return
+
+ def _find_lower_upper_bounds(comparison_node, uses):
+ left_operand = comparison_node.left
+ for operator, right_operand in comparison_node.ops:
+ for operand in (left_operand, right_operand):
+ value = None
+ if isinstance(operand, astroid.Name):
+ value = operand.name
+ elif isinstance(operand, astroid.Const):
+ value = operand.value
+
+ if value is None:
+ continue
+
+ if operator in ("<", "<="):
+ if operand is left_operand:
+ uses[value]["lower_bound"].add(comparison_node)
+ elif operand is right_operand:
+ uses[value]["upper_bound"].add(comparison_node)
+ elif operator in (">", ">="):
+ if operand is left_operand:
+ uses[value]["upper_bound"].add(comparison_node)
+ elif operand is right_operand:
+ uses[value]["lower_bound"].add(comparison_node)
+ left_operand = right_operand
+
+ uses = collections.defaultdict(
+ lambda: {"lower_bound": set(), "upper_bound": set()}
+ )
+ for comparison_node in node.values:
+ if isinstance(comparison_node, astroid.Compare):
+ _find_lower_upper_bounds(comparison_node, uses)
+
+ for _, bounds in uses.items():
+ num_shared = len(bounds["lower_bound"].intersection(bounds["upper_bound"]))
+ num_lower_bounds = len(bounds["lower_bound"])
+ num_upper_bounds = len(bounds["upper_bound"])
+ if num_shared < num_lower_bounds and num_shared < num_upper_bounds:
+ self.add_message("chained-comparison", node=node)
+ break
+
+ @staticmethod
+ def _apply_boolean_simplification_rules(operator, values):
+ """Removes irrelevant values or returns shortcircuiting values
+
+ This function applies the following two rules:
+ 1) an OR expression with True in it will always be true, and the
+ reverse for AND
+
+ 2) False values in OR expressions are only relevant if all values are
+ false, and the reverse for AND"""
+ simplified_values = []
+
+ for subnode in values:
+ inferred_bool = None
+ if not next(subnode.nodes_of_class(astroid.Name), False):
+ inferred = utils.safe_infer(subnode)
+ if inferred:
+ inferred_bool = inferred.bool_value()
+
+ if not isinstance(inferred_bool, bool):
+ simplified_values.append(subnode)
+ elif (operator == "or") == inferred_bool:
+ return [subnode]
+
+ return simplified_values or [astroid.Const(operator == "and")]
+
+ def _simplify_boolean_operation(self, bool_op):
+ """Attempts to simplify a boolean operation
+
+ Recursively applies simplification on the operator terms,
+ and keeps track of whether reductions have been made."""
+ children = list(bool_op.get_children())
+ intermediate = [
+ self._simplify_boolean_operation(child)
+ if isinstance(child, astroid.BoolOp)
+ else child
+ for child in children
+ ]
+ result = self._apply_boolean_simplification_rules(bool_op.op, intermediate)
+ if len(result) < len(children):
+ self._can_simplify_bool_op = True
+ if len(result) == 1:
+ return result[0]
+ simplified_bool_op = copy.copy(bool_op)
+ simplified_bool_op.postinit(result)
+ return simplified_bool_op
+
+ def _check_simplifiable_condition(self, node):
+ """Check if a boolean condition can be simplified.
+
+ Variables will not be simplified, even in the value can be inferred,
+ and expressions like '3 + 4' will remain expanded."""
+ if not utils.is_test_condition(node):
+ return
+
+ self._can_simplify_bool_op = False
+ simplified_expr = self._simplify_boolean_operation(node)
+
+ if not self._can_simplify_bool_op:
+ return
+
+ if not next(simplified_expr.nodes_of_class(astroid.Name), False):
+ self.add_message(
+ "condition-evals-to-constant",
+ node=node,
+ args=(node.as_string(), simplified_expr.as_string()),
+ )
+ else:
+ self.add_message(
+ "simplifiable-condition",
+ node=node,
+ args=(node.as_string(), simplified_expr.as_string()),
+ )
+
+ @utils.check_messages(
+ "consider-merging-isinstance",
+ "consider-using-in",
+ "chained-comparison",
+ "simplifiable-condition",
+ "condition-evals-to-constant",
+ )
+ def visit_boolop(self, node):
+ self._check_consider_merging_isinstance(node)
+ self._check_consider_using_in(node)
+ self._check_chained_comparison(node)
+ self._check_simplifiable_condition(node)
+
+ @staticmethod
+ def _is_simple_assignment(node):
+ return (
+ isinstance(node, astroid.Assign)
+ and len(node.targets) == 1
+ and isinstance(node.targets[0], astroid.node_classes.AssignName)
+ and isinstance(node.value, astroid.node_classes.Name)
+ )
+
+ def _check_swap_variables(self, node):
+ if not node.next_sibling() or not node.next_sibling().next_sibling():
+ return
+ assignments = [node, node.next_sibling(), node.next_sibling().next_sibling()]
+ if not all(self._is_simple_assignment(node) for node in assignments):
+ return
+ if any(node in self._reported_swap_nodes for node in assignments):
+ return
+ left = [node.targets[0].name for node in assignments]
+ right = [node.value.name for node in assignments]
+ if left[0] == right[-1] and left[1:] == right[:-1]:
+ self._reported_swap_nodes.update(assignments)
+ message = "consider-swap-variables"
+ self.add_message(message, node=node)
+
+ @utils.check_messages(
+ "simplify-boolean-expression",
+ "consider-using-ternary",
+ "consider-swap-variables",
+ )
+ def visit_assign(self, node):
+ self._check_swap_variables(node)
+ if self._is_and_or_ternary(node.value):
+ cond, truth_value, false_value = self._and_or_ternary_arguments(node.value)
+ else:
+ return
+
+ if all(
+ isinstance(value, astroid.Compare) for value in (truth_value, false_value)
+ ):
+ return
+
+ inferred_truth_value = utils.safe_infer(truth_value)
+ if inferred_truth_value in (None, astroid.Uninferable):
+ truth_boolean_value = True
+ else:
+ truth_boolean_value = truth_value.bool_value()
+
+ if truth_boolean_value is False:
+ message = "simplify-boolean-expression"
+ suggestion = false_value.as_string()
+ else:
+ message = "consider-using-ternary"
+ suggestion = "{truth} if {cond} else {false}".format(
+ truth=truth_value.as_string(),
+ cond=cond.as_string(),
+ false=false_value.as_string(),
+ )
+ self.add_message(message, node=node, args=(suggestion,))
+
+ visit_return = visit_assign
+
+ def _check_consider_using_with(self, node: astroid.Call):
+ inferred = utils.safe_infer(node.func)
+ if not inferred:
+ return
+ could_be_used_in_with = (
+ # things like ``lock.acquire()``
+ inferred.qname() in CALLS_THAT_COULD_BE_REPLACED_BY_WITH
+ or (
+ # things like ``open("foo")`` which are not already inside a ``with`` statement
+ inferred.qname() in CALLS_RETURNING_CONTEXT_MANAGERS
+ and not isinstance(node.parent, astroid.With)
+ )
+ )
+ if could_be_used_in_with and not _is_inside_context_manager(node):
+ self.add_message("consider-using-with", node=node)
+
+ def _check_consider_using_join(self, aug_assign):
+ """
+ We start with the augmented assignment and work our way upwards.
+ Names of variables for nodes if match successful:
+ result = '' # assign
+ for number in ['1', '2', '3'] # for_loop
+ result += number # aug_assign
+ """
+ for_loop = aug_assign.parent
+ if not isinstance(for_loop, astroid.For) or len(for_loop.body) > 1:
+ return
+ assign = for_loop.previous_sibling()
+ if not isinstance(assign, astroid.Assign):
+ return
+ result_assign_names = {
+ target.name
+ for target in assign.targets
+ if isinstance(target, astroid.AssignName)
+ }
+
+ is_concat_loop = (
+ aug_assign.op == "+="
+ and isinstance(aug_assign.target, astroid.AssignName)
+ and len(for_loop.body) == 1
+ and aug_assign.target.name in result_assign_names
+ and isinstance(assign.value, astroid.Const)
+ and isinstance(assign.value.value, str)
+ and isinstance(aug_assign.value, astroid.Name)
+ and aug_assign.value.name == for_loop.target.name
+ )
+ if is_concat_loop:
+ self.add_message("consider-using-join", node=aug_assign)
+
+ @utils.check_messages("consider-using-join")
+ def visit_augassign(self, node):
+ self._check_consider_using_join(node)
+
+ @utils.check_messages("unnecessary-comprehension", "unnecessary-dict-index-lookup")
+ def visit_comprehension(self, node: astroid.Comprehension) -> None:
+ self._check_unnecessary_comprehension(node)
+ self._check_unnecessary_dict_index_lookup(node)
+
+ def _check_unnecessary_comprehension(self, node: astroid.Comprehension) -> None:
+ if (
+ isinstance(node.parent, astroid.GeneratorExp)
+ or len(node.ifs) != 0
+ or len(node.parent.generators) != 1
+ or node.is_async
+ ):
+ return
+
+ if (
+ isinstance(node.parent, astroid.DictComp)
+ and isinstance(node.parent.key, astroid.Name)
+ and isinstance(node.parent.value, astroid.Name)
+ and isinstance(node.target, astroid.Tuple)
+ and all(isinstance(elt, astroid.AssignName) for elt in node.target.elts)
+ ):
+ expr_list = [node.parent.key.name, node.parent.value.name]
+ target_list = [elt.name for elt in node.target.elts]
+
+ elif isinstance(node.parent, (astroid.ListComp, astroid.SetComp)):
+ expr = node.parent.elt
+ if isinstance(expr, astroid.Name):
+ expr_list = expr.name
+ elif isinstance(expr, astroid.Tuple):
+ if any(not isinstance(elt, astroid.Name) for elt in expr.elts):
+ return
+ expr_list = [elt.name for elt in expr.elts]
+ else:
+ expr_list = []
+ target = node.parent.generators[0].target
+ target_list = (
+ target.name
+ if isinstance(target, astroid.AssignName)
+ else (
+ [
+ elt.name
+ for elt in target.elts
+ if isinstance(elt, astroid.AssignName)
+ ]
+ if isinstance(target, astroid.Tuple)
+ else []
+ )
+ )
+ else:
+ return
+ if expr_list == target_list != []:
+ args: Optional[Tuple[str]] = None
+ inferred = utils.safe_infer(node.iter)
+ if isinstance(node.parent, astroid.DictComp) and isinstance(
+ inferred, astroid.objects.DictItems
+ ):
+ args = (f"{node.iter.func.expr.as_string()}",)
+ elif (
+ isinstance(node.parent, astroid.ListComp)
+ and isinstance(inferred, astroid.List)
+ ) or (
+ isinstance(node.parent, astroid.SetComp)
+ and isinstance(inferred, astroid.Set)
+ ):
+ args = (f"{node.iter.as_string()}",)
+ if args:
+ self.add_message("unnecessary-comprehension", node=node, args=args)
+ return
+
+ if isinstance(node.parent, astroid.DictComp):
+ func = "dict"
+ elif isinstance(node.parent, astroid.ListComp):
+ func = "list"
+ elif isinstance(node.parent, astroid.SetComp):
+ func = "set"
+ else:
+ return
+
+ self.add_message(
+ "unnecessary-comprehension",
+ node=node,
+ args=(f"{func}({node.iter.as_string()})",),
+ )
+
+ @staticmethod
+ def _is_and_or_ternary(node):
+ """
+ Returns true if node is 'condition and true_value or false_value' form.
+
+ All of: condition, true_value and false_value should not be a complex boolean expression
+ """
+ return (
+ isinstance(node, astroid.BoolOp)
+ and node.op == "or"
+ and len(node.values) == 2
+ and isinstance(node.values[0], astroid.BoolOp)
+ and not isinstance(node.values[1], astroid.BoolOp)
+ and node.values[0].op == "and"
+ and not isinstance(node.values[0].values[1], astroid.BoolOp)
+ and len(node.values[0].values) == 2
+ )
+
+ @staticmethod
+ def _and_or_ternary_arguments(node):
+ false_value = node.values[1]
+ condition, true_value = node.values[0].values
+ return condition, true_value, false_value
+
+ def visit_functiondef(self, node):
+ self._return_nodes[node.name] = list(
+ node.nodes_of_class(astroid.Return, skip_klass=astroid.FunctionDef)
+ )
+
+ def _check_consistent_returns(self, node: astroid.FunctionDef) -> None:
+ """Check that all return statements inside a function are consistent.
+
+ Return statements are consistent if:
+ - all returns are explicit and if there is no implicit return;
+ - all returns are empty and if there is, possibly, an implicit return.
+
+ Args:
+ node (astroid.FunctionDef): the function holding the return statements.
+
+ """
+ # explicit return statements are those with a not None value
+ explicit_returns = [
+ _node for _node in self._return_nodes[node.name] if _node.value is not None
+ ]
+ if not explicit_returns:
+ return
+ if len(explicit_returns) == len(
+ self._return_nodes[node.name]
+ ) and self._is_node_return_ended(node):
+ return
+ self.add_message("inconsistent-return-statements", node=node)
+
+ def _is_if_node_return_ended(self, node: astroid.If) -> bool:
+ """Check if the If node ends with an explicit return statement.
+
+ Args:
+ node (astroid.If): If node to be checked.
+
+ Returns:
+ bool: True if the node ends with an explicit statement, False otherwise.
+ """
+ # Do not check if inner function definition are return ended.
+ is_if_returning = any(
+ self._is_node_return_ended(_ifn)
+ for _ifn in node.body
+ if not isinstance(_ifn, astroid.FunctionDef)
+ )
+ if not node.orelse:
+ # If there is not orelse part then the if statement is returning if :
+ # - there is at least one return statement in its siblings;
+ # - the if body is itself returning.
+ if not self._has_return_in_siblings(node):
+ return False
+ return is_if_returning
+ # If there is an orelse part then both if body and orelse part should return.
+ is_orelse_returning = any(
+ self._is_node_return_ended(_ore)
+ for _ore in node.orelse
+ if not isinstance(_ore, astroid.FunctionDef)
+ )
+ return is_if_returning and is_orelse_returning
+
+ def _is_raise_node_return_ended(self, node: astroid.Raise) -> bool:
+ """Check if the Raise node ends with an explicit return statement.
+
+ Args:
+ node (astroid.Raise): Raise node to be checked.
+
+ Returns:
+ bool: True if the node ends with an explicit statement, False otherwise.
+ """
+ # a Raise statement doesn't need to end with a return statement
+ # but if the exception raised is handled, then the handler has to
+ # ends with a return statement
+ if not node.exc:
+ # Ignore bare raises
+ return True
+ if not utils.is_node_inside_try_except(node):
+ # If the raise statement is not inside a try/except statement
+ # then the exception is raised and cannot be caught. No need
+ # to infer it.
+ return True
+ exc = utils.safe_infer(node.exc)
+ if exc is None or exc is astroid.Uninferable or not hasattr(exc, "pytype"):
+ return False
+ exc_name = exc.pytype().split(".")[-1]
+ handlers = utils.get_exception_handlers(node, exc_name)
+ handlers = list(handlers) if handlers is not None else []
+ if handlers:
+ # among all the handlers handling the exception at least one
+ # must end with a return statement
+ return any(self._is_node_return_ended(_handler) for _handler in handlers)
+ # if no handlers handle the exception then it's ok
+ return True
+
+ def _is_node_return_ended(self, node: astroid.node_classes.NodeNG) -> bool:
+ """Check if the node ends with an explicit return statement.
+
+ Args:
+ node (astroid.node_classes.NodeNG): node to be checked.
+
+ Returns:
+ bool: True if the node ends with an explicit statement, False otherwise.
+
+ """
+ # Recursion base case
+ if isinstance(node, astroid.Return):
+ return True
+ if isinstance(node, astroid.Call):
+ try:
+ funcdef_node = node.func.inferred()[0]
+ if self._is_function_def_never_returning(funcdef_node):
+ return True
+ except astroid.InferenceError:
+ pass
+ # Avoid the check inside while loop as we don't know
+ # if they will be completed
+ if isinstance(node, astroid.While):
+ return True
+ if isinstance(node, astroid.Raise):
+ return self._is_raise_node_return_ended(node)
+ if isinstance(node, astroid.If):
+ return self._is_if_node_return_ended(node)
+ if isinstance(node, astroid.TryExcept):
+ handlers = {
+ _child
+ for _child in node.get_children()
+ if isinstance(_child, astroid.ExceptHandler)
+ }
+ all_but_handler = set(node.get_children()) - handlers
+ return any(
+ self._is_node_return_ended(_child) for _child in all_but_handler
+ ) and all(self._is_node_return_ended(_child) for _child in handlers)
+ if (
+ isinstance(node, astroid.Assert)
+ and isinstance(node.test, astroid.Const)
+ and not node.test.value
+ ):
+ # consider assert False as a return node
+ return True
+ # recurses on the children of the node
+ return any(self._is_node_return_ended(_child) for _child in node.get_children())
+
+ @staticmethod
+ def _has_return_in_siblings(node: astroid.node_classes.NodeNG) -> bool:
+ """
+ Returns True if there is at least one return in the node's siblings
+ """
+ next_sibling = node.next_sibling()
+ while next_sibling:
+ if isinstance(next_sibling, astroid.Return):
+ return True
+ next_sibling = next_sibling.next_sibling()
+ return False
+
+ def _is_function_def_never_returning(self, node: astroid.FunctionDef) -> bool:
+ """Return True if the function never returns. False otherwise.
+
+ Args:
+ node (astroid.FunctionDef): function definition node to be analyzed.
+
+ Returns:
+ bool: True if the function never returns, False otherwise.
+ """
+ if isinstance(node, astroid.FunctionDef) and node.returns:
+ return (
+ isinstance(node.returns, astroid.Attribute)
+ and node.returns.attrname == "NoReturn"
+ or isinstance(node.returns, astroid.Name)
+ and node.returns.name == "NoReturn"
+ )
+ try:
+ return node.qname() in self._never_returning_functions
+ except TypeError:
+ return False
+
+ def _check_return_at_the_end(self, node):
+ """Check for presence of a *single* return statement at the end of a
+ function. "return" or "return None" are useless because None is the
+ default return type if they are missing.
+
+ NOTE: produces a message only if there is a single return statement
+ in the function body. Otherwise _check_consistent_returns() is called!
+ Per its implementation and PEP8 we can have a "return None" at the end
+ of the function body if there are other return statements before that!
+ """
+ if len(self._return_nodes[node.name]) > 1:
+ return
+ if len(node.body) <= 1:
+ return
+
+ last = node.body[-1]
+ if isinstance(last, astroid.Return):
+ # e.g. "return"
+ if last.value is None:
+ self.add_message("useless-return", node=node)
+ # return None"
+ elif isinstance(last.value, astroid.Const) and (last.value.value is None):
+ self.add_message("useless-return", node=node)
+
+ def _check_unnecessary_dict_index_lookup(
+ self, node: Union[astroid.For, astroid.Comprehension]
+ ) -> None:
+ """Add message when accessing dict values by index lookup."""
+ # Verify that we have a .items() call and
+ # that the object which is iterated is used as a subscript in the
+ # body of the for.
+ # Is it a proper items call?
+ if (
+ isinstance(node.iter, astroid.Call)
+ and isinstance(node.iter.func, astroid.Attribute)
+ and node.iter.func.attrname == "items"
+ ):
+ inferred = utils.safe_infer(node.iter.func)
+ if not isinstance(inferred, astroid.BoundMethod):
+ return
+ iterating_object_name = node.iter.func.expr.as_string()
+
+ # Verify that the body of the for loop uses a subscript
+ # with the object that was iterated. This uses some heuristics
+ # in order to make sure that the same object is used in the
+ # for body.
+
+ children = (
+ node.body
+ if isinstance(node, astroid.For)
+ else node.parent.get_children()
+ )
+ for child in children:
+ for subscript in child.nodes_of_class(astroid.Subscript):
+ subscript = cast(astroid.Subscript, subscript)
+
+ if not isinstance(
+ subscript.value, (astroid.Name, astroid.Attribute)
+ ):
+ continue
+
+ value = subscript.slice
+
+ if isinstance(node, astroid.For) and (
+ isinstance(subscript.parent, astroid.Assign)
+ and subscript in subscript.parent.targets
+ or isinstance(subscript.parent, astroid.AugAssign)
+ and subscript == subscript.parent.target
+ ):
+ # Ignore this subscript if it is the target of an assignment
+ continue
+
+ # Case where .items is assigned to k,v (i.e., for k, v in d.items())
+ if isinstance(value, astroid.Name):
+ if (
+ not isinstance(node.target, astroid.Tuple)
+ or value.name != node.target.elts[0].name
+ or iterating_object_name != subscript.value.as_string()
+ ):
+ continue
+
+ if (
+ isinstance(node, astroid.For)
+ and value.lookup(value.name)[1][-1].lineno > node.lineno
+ ):
+ # Ignore this subscript if it has been redefined after
+ # the for loop. This checks for the line number using .lookup()
+ # to get the line number where the iterating object was last
+ # defined and compare that to the for loop's line number
+ continue
+
+ self.add_message(
+ "unnecessary-dict-index-lookup",
+ node=subscript,
+ args=(node.target.elts[1].as_string()),
+ )
+
+ # Case where .items is assigned to single var (i.e., for item in d.items())
+ elif isinstance(value, astroid.Subscript):
+ if (
+ not isinstance(node.target, astroid.AssignName)
+ or node.target.name != value.value.name
+ or iterating_object_name != subscript.value.as_string()
+ ):
+ continue
+
+ if (
+ isinstance(node, astroid.For)
+ and value.value.lookup(value.value.name)[1][-1].lineno
+ > node.lineno
+ ):
+ # Ignore this subscript if it has been redefined after
+ # the for loop. This checks for the line number using .lookup()
+ # to get the line number where the iterating object was last
+ # defined and compare that to the for loop's line number
+ continue
+
+ # check if subscripted by 0 (key)
+ inferred = utils.safe_infer(value.slice)
+ if (
+ not isinstance(inferred, astroid.Const)
+ or inferred.value != 0
+ ):
+ continue
+ self.add_message(
+ "unnecessary-dict-index-lookup",
+ node=subscript,
+ args=("1".join(value.as_string().rsplit("0", maxsplit=1)),),
+ )
diff --git a/pylint/checkers/similar.py b/pylint/checkers/similar.py
new file mode 100644
index 0000000..048abd1
--- /dev/null
+++ b/pylint/checkers/similar.py
@@ -0,0 +1,544 @@
+# Copyright (c) 2006, 2008-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 Ry4an Brase <ry4an-hg@ry4an.org>
+# Copyright (c) 2012 Google, Inc.
+# Copyright (c) 2012 Anthony VEREZ <anthony.verez.external@cassidian.com>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2017, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2017 Mikhail Fesenko <proggga@gmail.com>
+# Copyright (c) 2018 Scott Worley <scottworley@scottworley.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Taewon D. Kim <kimt33@mcmaster.ca>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2020 Eli Fine <ejfine@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Shiv Venkatasubrahmanyam <shvenkat@users.noreply.github.com>
+# Copyright (c) 2021 bot <bot@noreply.github.com>
+# Copyright (c) 2021 Aditya Gupta <adityagupta1089@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+# pylint: disable=redefined-builtin
+"""a similarities / code duplication command line tool and pylint checker
+"""
+import functools
+import re
+import sys
+from collections import defaultdict
+from getopt import getopt
+from io import TextIOWrapper
+from itertools import chain, groupby
+from typing import List
+
+import astroid
+
+from pylint.checkers import BaseChecker, MapReduceMixin, table_lines_from_stats
+from pylint.interfaces import IRawChecker
+from pylint.reporters.ureports.nodes import Table
+from pylint.utils import decoding_stream
+
+REGEX_FOR_LINES_WITH_CONTENT = re.compile(r".*\w+")
+
+
+class Similar:
+ """finds copy-pasted lines of code in a project"""
+
+ def __init__(
+ self,
+ min_lines: int = 4,
+ ignore_comments: bool = False,
+ ignore_docstrings: bool = False,
+ ignore_imports: bool = False,
+ ignore_signatures: bool = False,
+ ) -> None:
+ self.min_lines = min_lines
+ self.ignore_comments = ignore_comments
+ self.ignore_docstrings = ignore_docstrings
+ self.ignore_imports = ignore_imports
+ self.ignore_signatures = ignore_signatures
+ self.linesets: List["LineSet"] = []
+
+ def append_stream(
+ self, streamid: str, stream: TextIOWrapper, encoding=None
+ ) -> None:
+ """append a file to search for similarities"""
+ if encoding is None:
+ readlines = stream.readlines
+ else:
+ readlines = decoding_stream(stream, encoding).readlines
+ try:
+ self.linesets.append(
+ LineSet(
+ streamid,
+ readlines(),
+ self.ignore_comments,
+ self.ignore_docstrings,
+ self.ignore_imports,
+ self.ignore_signatures,
+ )
+ )
+ except UnicodeDecodeError:
+ pass
+
+ def run(self):
+ """start looking for similarities and display results on stdout"""
+ self._display_sims(self._compute_sims())
+
+ def _compute_sims(self):
+ """compute similarities in appended files"""
+ no_duplicates = defaultdict(list)
+ for num, lineset1, idx1, lineset2, idx2 in self._iter_sims():
+ duplicate = no_duplicates[num]
+ for couples in duplicate:
+ if (lineset1, idx1) in couples or (lineset2, idx2) in couples:
+ couples.add((lineset1, idx1))
+ couples.add((lineset2, idx2))
+ break
+ else:
+ duplicate.append({(lineset1, idx1), (lineset2, idx2)})
+ sims = []
+ for num, ensembles in no_duplicates.items():
+ for couples in ensembles:
+ sims.append((num, couples))
+ sims.sort()
+ sims.reverse()
+ return sims
+
+ def _display_sims(self, sims):
+ """display computed similarities on stdout"""
+ nb_lignes_dupliquees = 0
+ for num, couples in sims:
+ print()
+ print(num, "similar lines in", len(couples), "files")
+ couples = sorted(couples)
+ lineset = idx = None
+ for lineset, idx in couples:
+ print(f"=={lineset.name}:{idx}")
+ if lineset:
+ for line in lineset._real_lines[idx : idx + num]:
+ print(" ", line.rstrip())
+ nb_lignes_dupliquees += num * (len(couples) - 1)
+ nb_total_lignes = sum(len(lineset) for lineset in self.linesets)
+ print(
+ "TOTAL lines=%s duplicates=%s percent=%.2f"
+ % (
+ nb_total_lignes,
+ nb_lignes_dupliquees,
+ nb_lignes_dupliquees * 100.0 / nb_total_lignes,
+ )
+ )
+
+ def _find_common(self, lineset1, lineset2):
+ """find similarities in the two given linesets"""
+ lines1 = lineset1.enumerate_stripped
+ lines2 = lineset2.enumerate_stripped
+ find = lineset2.find
+ index1 = 0
+ min_lines = self.min_lines
+ while index1 < len(lineset1):
+ skip = 1
+ num = 0
+ for index2 in find(lineset1[index1]):
+ num_lines_with_content = 0
+ for num, ((_, line1), (_, line2)) in enumerate(
+ zip(lines1(index1), lines2(index2))
+ ):
+ if line1 != line2:
+ if num_lines_with_content > min_lines:
+ yield num, lineset1, index1, lineset2, index2
+ skip = max(skip, num)
+ break
+ if re.match(REGEX_FOR_LINES_WITH_CONTENT, line1):
+ num_lines_with_content += 1
+ else:
+ # we may have reached the end
+ num += 1
+ if num_lines_with_content > min_lines:
+ yield num, lineset1, index1, lineset2, index2
+ skip = max(skip, num)
+ index1 += skip
+
+ def _iter_sims(self):
+ """iterate on similarities among all files, by making a cartesian
+ product
+ """
+ for idx, lineset in enumerate(self.linesets[:-1]):
+ for lineset2 in self.linesets[idx + 1 :]:
+ yield from self._find_common(lineset, lineset2)
+
+ def get_map_data(self):
+ """Returns the data we can use for a map/reduce process
+
+ In this case we are returning this instance's Linesets, that is all file
+ information that will later be used for vectorisation.
+ """
+ return self.linesets
+
+ def combine_mapreduce_data(self, linesets_collection):
+ """Reduces and recombines data into a format that we can report on
+
+ The partner function of get_map_data()"""
+ self.linesets = [line for lineset in linesets_collection for line in lineset]
+
+
+def stripped_lines(
+ lines,
+ ignore_comments: bool,
+ ignore_docstrings: bool,
+ ignore_imports: bool,
+ ignore_signatures: bool,
+):
+ """return lines with leading/trailing whitespace and any ignored code
+ features removed
+ """
+ if ignore_imports or ignore_signatures:
+ tree = astroid.parse("".join(lines))
+ if ignore_imports:
+ node_is_import_by_lineno = (
+ (node.lineno, isinstance(node, (astroid.Import, astroid.ImportFrom)))
+ for node in tree.body
+ )
+ line_begins_import = {
+ lineno: all(is_import for _, is_import in node_is_import_group)
+ for lineno, node_is_import_group in groupby(
+ node_is_import_by_lineno, key=lambda x: x[0]
+ )
+ }
+ current_line_is_import = False
+ if ignore_signatures:
+ functions = [
+ n
+ for n in tree.body
+ if isinstance(n, (astroid.FunctionDef, astroid.AsyncFunctionDef))
+ ]
+ signature_lines = set(
+ chain(*(range(func.fromlineno, func.body[0].lineno) for func in functions))
+ )
+
+ strippedlines = []
+ docstring = None
+ for lineno, line in enumerate(lines, start=1):
+ line = line.strip()
+ if ignore_docstrings:
+ if not docstring:
+ if line.startswith('"""') or line.startswith("'''"):
+ docstring = line[:3]
+ line = line[3:]
+ elif line.startswith('r"""') or line.startswith("r'''"):
+ docstring = line[1:4]
+ line = line[4:]
+ if docstring:
+ if line.endswith(docstring):
+ docstring = None
+ line = ""
+ if ignore_imports:
+ current_line_is_import = line_begins_import.get(
+ lineno, current_line_is_import
+ )
+ if current_line_is_import:
+ line = ""
+ if ignore_comments:
+ line = line.split("#", 1)[0].strip()
+ if ignore_signatures and lineno in signature_lines:
+ line = ""
+ strippedlines.append(line)
+ return strippedlines
+
+
+@functools.total_ordering
+class LineSet:
+ """Holds and indexes all the lines of a single source file"""
+
+ def __init__(
+ self,
+ name,
+ lines,
+ ignore_comments=False,
+ ignore_docstrings=False,
+ ignore_imports=False,
+ ignore_signatures=False,
+ ):
+ self.name = name
+ self._real_lines = lines
+ self._stripped_lines = stripped_lines(
+ lines, ignore_comments, ignore_docstrings, ignore_imports, ignore_signatures
+ )
+ self._index = self._mk_index()
+
+ def __str__(self):
+ return "<Lineset for %s>" % self.name
+
+ def __len__(self):
+ return len(self._real_lines)
+
+ def __getitem__(self, index):
+ return self._stripped_lines[index]
+
+ def __lt__(self, other):
+ return self.name < other.name
+
+ def __hash__(self):
+ return id(self)
+
+ def __eq__(self, other):
+ if not isinstance(other, LineSet):
+ return False
+ return self.__dict__ == other.__dict__
+
+ def enumerate_stripped(self, start_at=0):
+ """return an iterator on stripped lines, starting from a given index
+ if specified, else 0
+ """
+ idx = start_at
+ if start_at:
+ lines = self._stripped_lines[start_at:]
+ else:
+ lines = self._stripped_lines
+ for line in lines:
+ # if line:
+ yield idx, line
+ idx += 1
+
+ def find(self, stripped_line):
+ """return positions of the given stripped line in this set"""
+ return self._index.get(stripped_line, ())
+
+ def _mk_index(self):
+ """create the index for this set"""
+ index = defaultdict(list)
+ for line_no, line in enumerate(self._stripped_lines):
+ if line:
+ index[line].append(line_no)
+ return index
+
+
+MSGS = {
+ "R0801": (
+ "Similar lines in %s files\n%s",
+ "duplicate-code",
+ "Indicates that a set of similar lines has been detected "
+ "among multiple file. This usually means that the code should "
+ "be refactored to avoid this duplication.",
+ )
+}
+
+
+def report_similarities(sect, stats, old_stats):
+ """make a layout with some stats about duplication"""
+ lines = ["", "now", "previous", "difference"]
+ lines += table_lines_from_stats(
+ stats, old_stats, ("nb_duplicated_lines", "percent_duplicated_lines")
+ )
+ sect.append(Table(children=lines, cols=4, rheaders=1, cheaders=1))
+
+
+# wrapper to get a pylint checker from the similar class
+class SimilarChecker(BaseChecker, Similar, MapReduceMixin):
+ """checks for similarities and duplicated code. This computation may be
+ memory / CPU intensive, so you should disable it if you experiment some
+ problems.
+ """
+
+ __implements__ = (IRawChecker,)
+ # configuration section name
+ name = "similarities"
+ # messages
+ msgs = MSGS
+ # configuration options
+ # for available dict keys/values see the optik parser 'add_option' method
+ options = (
+ (
+ "min-similarity-lines", # type: ignore
+ {
+ "default": 4,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Minimum lines number of a similarity.",
+ },
+ ),
+ (
+ "ignore-comments",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Ignore comments when computing similarities.",
+ },
+ ),
+ (
+ "ignore-docstrings",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Ignore docstrings when computing similarities.",
+ },
+ ),
+ (
+ "ignore-imports",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Ignore imports when computing similarities.",
+ },
+ ),
+ (
+ "ignore-signatures",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Ignore function signatures when computing similarities.",
+ },
+ ),
+ )
+ # reports
+ reports = (("RP0801", "Duplication", report_similarities),) # type: ignore
+
+ def __init__(self, linter=None):
+ BaseChecker.__init__(self, linter)
+ Similar.__init__(
+ self, min_lines=4, ignore_comments=True, ignore_docstrings=True
+ )
+ self.stats = None
+
+ def set_option(self, optname, value, action=None, optdict=None):
+ """method called to set an option (registered in the options list)
+
+ Overridden to report options setting to Similar
+ """
+ BaseChecker.set_option(self, optname, value, action, optdict)
+ if optname == "min-similarity-lines":
+ self.min_lines = self.config.min_similarity_lines
+ elif optname == "ignore-comments":
+ self.ignore_comments = self.config.ignore_comments
+ elif optname == "ignore-docstrings":
+ self.ignore_docstrings = self.config.ignore_docstrings
+ elif optname == "ignore-imports":
+ self.ignore_imports = self.config.ignore_imports
+ elif optname == "ignore-signatures":
+ self.ignore_signatures = self.config.ignore_signatures
+
+ def open(self):
+ """init the checkers: reset linesets and statistics information"""
+ self.linesets = []
+ self.stats = self.linter.add_stats(
+ nb_duplicated_lines=0, percent_duplicated_lines=0
+ )
+
+ def process_module(self, node):
+ """process a module
+
+ the module's content is accessible via the stream object
+
+ stream must implement the readlines method
+ """
+ with node.stream() as stream:
+ self.append_stream(self.linter.current_name, stream, node.file_encoding)
+
+ def close(self):
+ """compute and display similarities on closing (i.e. end of parsing)"""
+ total = sum(len(lineset) for lineset in self.linesets)
+ duplicated = 0
+ stats = self.stats
+ for num, couples in self._compute_sims():
+ msg = []
+ lineset = idx = None
+ for lineset, idx in couples:
+ msg.append(f"=={lineset.name}:{idx}")
+ msg.sort()
+
+ if lineset:
+ for line in lineset._real_lines[idx : idx + num]:
+ msg.append(line.rstrip())
+
+ self.add_message("R0801", args=(len(couples), "\n".join(msg)))
+ duplicated += num * (len(couples) - 1)
+ stats["nb_duplicated_lines"] = duplicated
+ stats["percent_duplicated_lines"] = total and duplicated * 100.0 / total
+
+ def get_map_data(self):
+ """Passthru override"""
+ return Similar.get_map_data(self)
+
+ @classmethod
+ def reduce_map_data(cls, linter, data):
+ """Reduces and recombines data into a format that we can report on
+
+ The partner function of get_map_data()"""
+ recombined = SimilarChecker(linter)
+ recombined.open()
+ Similar.combine_mapreduce_data(recombined, linesets_collection=data)
+ recombined.close()
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(SimilarChecker(linter))
+
+
+def usage(status=0):
+ """display command line usage information"""
+ print("finds copy pasted blocks in a set of files")
+ print()
+ print(
+ "Usage: symilar [-d|--duplicates min_duplicated_lines] \
+[-i|--ignore-comments] [--ignore-docstrings] [--ignore-imports] [--ignore-signatures] file1..."
+ )
+ sys.exit(status)
+
+
+def Run(argv=None):
+ """standalone command line access point"""
+ if argv is None:
+ argv = sys.argv[1:]
+
+ s_opts = "hdi"
+ l_opts = (
+ "help",
+ "duplicates=",
+ "ignore-comments",
+ "ignore-imports",
+ "ignore-docstrings",
+ "ignore-signatures",
+ )
+ min_lines = 4
+ ignore_comments = False
+ ignore_docstrings = False
+ ignore_imports = False
+ ignore_signatures = False
+ opts, args = getopt(argv, s_opts, l_opts)
+ for opt, val in opts:
+ if opt in ("-d", "--duplicates"):
+ min_lines = int(val)
+ elif opt in ("-h", "--help"):
+ usage()
+ elif opt in ("-i", "--ignore-comments"):
+ ignore_comments = True
+ elif opt in ("--ignore-docstrings",):
+ ignore_docstrings = True
+ elif opt in ("--ignore-imports",):
+ ignore_imports = True
+ elif opt in ("--ignore-signatures",):
+ ignore_signatures = True
+ if not args:
+ usage(1)
+ sim = Similar(
+ min_lines, ignore_comments, ignore_docstrings, ignore_imports, ignore_signatures
+ )
+ for filename in args:
+ with open(filename) as stream:
+ sim.append_stream(filename, stream)
+ sim.run()
+ sys.exit(0)
+
+
+if __name__ == "__main__":
+ Run()
diff --git a/pylint/checkers/spelling.py b/pylint/checkers/spelling.py
new file mode 100644
index 0000000..718d607
--- /dev/null
+++ b/pylint/checkers/spelling.py
@@ -0,0 +1,473 @@
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017, 2020 Pedro Algarvio <pedro@algarvio.me>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Mikhail Fesenko <proggga@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2019 agutole <toldo_carp@hotmail.com>
+# Copyright (c) 2020 Ganden Schaffner <gschaffner@pm.me>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2021 bot <bot@noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 Eli Fine <ejfine@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Checker for spelling errors in comments and docstrings.
+"""
+import os
+import re
+import tokenize
+from typing import Pattern
+
+from pylint.checkers import BaseTokenChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker, ITokenChecker
+
+try:
+ import enchant
+ from enchant.tokenize import (
+ Chunker,
+ EmailFilter,
+ Filter,
+ URLFilter,
+ WikiWordFilter,
+ get_tokenizer,
+ )
+except ImportError:
+ enchant = None
+
+ class EmailFilter: # type: ignore
+ ...
+
+ class URLFilter: # type: ignore
+ ...
+
+ class WikiWordFilter: # type: ignore
+ ...
+
+ class Filter: # type: ignore
+ def _skip(self, word):
+ raise NotImplementedError
+
+ class Chunker: # type: ignore
+ pass
+
+ def get_tokenizer(
+ tag=None, chunkers=None, filters=None
+ ): # pylint: disable=unused-argument
+ return Filter()
+
+
+if enchant is not None:
+ br = enchant.Broker()
+ dicts = br.list_dicts()
+ dict_choices = [""] + [d[0] for d in dicts]
+ dicts = [f"{d[0]} ({d[1].name})" for d in dicts]
+ dicts = ", ".join(dicts)
+ instr = ""
+else:
+ dicts = "none"
+ dict_choices = [""]
+ instr = " To make it work, install the 'python-enchant' package."
+
+
+class WordsWithDigitsFilter(Filter):
+ """Skips words with digits."""
+
+ def _skip(self, word):
+ for char in word:
+ if char.isdigit():
+ return True
+ return False
+
+
+class WordsWithUnderscores(Filter):
+ """Skips words with underscores.
+
+ They are probably function parameter names.
+ """
+
+ def _skip(self, word):
+ return "_" in word
+
+
+class RegExFilter(Filter):
+ """Parent class for filters using regular expressions.
+
+ This filter skips any words the match the expression
+ assigned to the class attribute ``_pattern``.
+
+ """
+
+ _pattern: Pattern[str]
+
+ def _skip(self, word) -> bool:
+ return bool(self._pattern.match(word))
+
+
+class CamelCasedWord(RegExFilter):
+ r"""Filter skipping over camelCasedWords.
+ This filter skips any words matching the following regular expression:
+
+ ^([a-z]\w+[A-Z]+\w+)
+
+ That is, any words that are camelCasedWords.
+ """
+ _pattern = re.compile(r"^([a-z]+([\d]|[A-Z])(?:\w+)?)")
+
+
+class SphinxDirectives(RegExFilter):
+ r"""Filter skipping over Sphinx Directives.
+ This filter skips any words matching the following regular expression:
+
+ ^(:([a-z]+)){1,2}:`([^`]+)(`)?
+
+ That is, for example, :class:`BaseQuery`
+ """
+ # The final ` in the pattern is optional because enchant strips it out
+ _pattern = re.compile(r"^(:([a-z]+)){1,2}:`([^`]+)(`)?")
+
+
+class ForwardSlashChunker(Chunker):
+ """
+ This chunker allows splitting words like 'before/after' into 'before' and 'after'
+ """
+
+ def next(self):
+ while True:
+ if not self._text:
+ raise StopIteration()
+ if "/" not in self._text:
+ text = self._text
+ self._offset = 0
+ self._text = ""
+ return (text, 0)
+ pre_text, post_text = self._text.split("/", 1)
+ self._text = post_text
+ self._offset = 0
+ if (
+ not pre_text
+ or not post_text
+ or not pre_text[-1].isalpha()
+ or not post_text[0].isalpha()
+ ):
+ self._text = ""
+ self._offset = 0
+ return (pre_text + "/" + post_text, 0)
+ return (pre_text, 0)
+
+ def _next(self):
+ while True:
+ if "/" not in self._text:
+ return (self._text, 0)
+ pre_text, post_text = self._text.split("/", 1)
+ if not pre_text or not post_text:
+ break
+ if not pre_text[-1].isalpha() or not post_text[0].isalpha():
+ raise StopIteration()
+ self._text = pre_text + " " + post_text
+ raise StopIteration()
+
+
+CODE_FLANKED_IN_BACKTICK_REGEX = re.compile(r"(\s|^)(`{1,2})([^`]+)(\2)([^`]|$)")
+
+
+def _strip_code_flanked_in_backticks(line: str) -> str:
+ """Alter line so code flanked in backticks is ignored.
+
+ Pyenchant automatically strips backticks when parsing tokens,
+ so this cannot be done at the individual filter level."""
+
+ def replace_code_but_leave_surrounding_characters(match_obj) -> str:
+ return match_obj.group(1) + match_obj.group(5)
+
+ return CODE_FLANKED_IN_BACKTICK_REGEX.sub(
+ replace_code_but_leave_surrounding_characters, line
+ )
+
+
+class SpellingChecker(BaseTokenChecker):
+ """Check spelling in comments and docstrings"""
+
+ __implements__ = (ITokenChecker, IAstroidChecker)
+ name = "spelling"
+ msgs = {
+ "C0401": (
+ "Wrong spelling of a word '%s' in a comment:\n%s\n"
+ "%s\nDid you mean: '%s'?",
+ "wrong-spelling-in-comment",
+ "Used when a word in comment is not spelled correctly.",
+ ),
+ "C0402": (
+ "Wrong spelling of a word '%s' in a docstring:\n%s\n"
+ "%s\nDid you mean: '%s'?",
+ "wrong-spelling-in-docstring",
+ "Used when a word in docstring is not spelled correctly.",
+ ),
+ "C0403": (
+ "Invalid characters %r in a docstring",
+ "invalid-characters-in-docstring",
+ "Used when a word in docstring cannot be checked by enchant.",
+ ),
+ }
+ options = (
+ (
+ "spelling-dict",
+ {
+ "default": "",
+ "type": "choice",
+ "metavar": "<dict name>",
+ "choices": dict_choices,
+ "help": "Spelling dictionary name. "
+ "Available dictionaries: %s.%s" % (dicts, instr),
+ },
+ ),
+ (
+ "spelling-ignore-words",
+ {
+ "default": "",
+ "type": "string",
+ "metavar": "<comma separated words>",
+ "help": "List of comma separated words that should not be checked.",
+ },
+ ),
+ (
+ "spelling-private-dict-file",
+ {
+ "default": "",
+ "type": "string",
+ "metavar": "<path to file>",
+ "help": "A path to a file that contains the private "
+ "dictionary; one word per line.",
+ },
+ ),
+ (
+ "spelling-store-unknown-words",
+ {
+ "default": "n",
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "Tells whether to store unknown words to the "
+ "private dictionary (see the "
+ "--spelling-private-dict-file option) instead of "
+ "raising a message.",
+ },
+ ),
+ (
+ "max-spelling-suggestions",
+ {
+ "default": 4,
+ "type": "int",
+ "metavar": "N",
+ "help": "Limits count of emitted suggestions for spelling mistakes.",
+ },
+ ),
+ (
+ "spelling-ignore-comment-directives",
+ {
+ "default": "fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:",
+ "type": "string",
+ "metavar": "<comma separated words>",
+ "help": "List of comma separated words that should be considered directives if they appear and the beginning of a comment and should not be checked.",
+ },
+ ),
+ )
+
+ def open(self):
+ self.initialized = False
+ self.private_dict_file = None
+
+ if enchant is None:
+ return
+ dict_name = self.config.spelling_dict
+ if not dict_name:
+ return
+
+ self.ignore_list = [
+ w.strip() for w in self.config.spelling_ignore_words.split(",")
+ ]
+ # "param" appears in docstring in param description and
+ # "pylint" appears in comments in pylint pragmas.
+ self.ignore_list.extend(["param", "pylint"])
+
+ self.ignore_comment_directive_list = [
+ w.strip() for w in self.config.spelling_ignore_comment_directives.split(",")
+ ]
+
+ # Expand tilde to allow e.g. spelling-private-dict-file = ~/.pylintdict
+ if self.config.spelling_private_dict_file:
+ self.config.spelling_private_dict_file = os.path.expanduser(
+ self.config.spelling_private_dict_file
+ )
+
+ if self.config.spelling_private_dict_file:
+ self.spelling_dict = enchant.DictWithPWL(
+ dict_name, self.config.spelling_private_dict_file
+ )
+ self.private_dict_file = open( # pylint: disable=consider-using-with
+ self.config.spelling_private_dict_file, "a"
+ )
+ else:
+ self.spelling_dict = enchant.Dict(dict_name)
+
+ if self.config.spelling_store_unknown_words:
+ self.unknown_words = set()
+
+ self.tokenizer = get_tokenizer(
+ dict_name,
+ chunkers=[ForwardSlashChunker],
+ filters=[
+ EmailFilter,
+ URLFilter,
+ WikiWordFilter,
+ WordsWithDigitsFilter,
+ WordsWithUnderscores,
+ CamelCasedWord,
+ SphinxDirectives,
+ ],
+ )
+ self.initialized = True
+
+ def close(self):
+ if self.private_dict_file:
+ self.private_dict_file.close()
+
+ def _check_spelling(self, msgid, line, line_num):
+ original_line = line
+ try:
+ initial_space = re.search(r"^[^\S]\s*", line).regs[0][1]
+ except (IndexError, AttributeError):
+ initial_space = 0
+ if line.strip().startswith("#") and "docstring" not in msgid:
+ line = line.strip()[1:]
+ # A ``Filter`` cannot determine if the directive is at the beginning of a line,
+ # nor determine if a colon is present or not (``pyenchant`` strips trailing colons).
+ # So implementing this here.
+ for iter_directive in self.ignore_comment_directive_list:
+ if line.startswith(" " + iter_directive):
+ line = line[(len(iter_directive) + 1) :]
+ break
+ starts_with_comment = True
+ else:
+ starts_with_comment = False
+
+ line = _strip_code_flanked_in_backticks(line)
+
+ for word, word_start_at in self.tokenizer(line.strip()):
+ word_start_at += initial_space
+ lower_cased_word = word.casefold()
+
+ # Skip words from ignore list.
+ if word in self.ignore_list or lower_cased_word in self.ignore_list:
+ continue
+
+ # Strip starting u' from unicode literals and r' from raw strings.
+ if word.startswith(("u'", 'u"', "r'", 'r"')) and len(word) > 2:
+ word = word[2:]
+ lower_cased_word = lower_cased_word[2:]
+
+ # If it is a known word, then continue.
+ try:
+ if self.spelling_dict.check(lower_cased_word):
+ # The lower cased version of word passed spell checking
+ continue
+
+ # If we reached this far, it means there was a spelling mistake.
+ # Let's retry with the original work because 'unicode' is a
+ # spelling mistake but 'Unicode' is not
+ if self.spelling_dict.check(word):
+ continue
+ except enchant.errors.Error:
+ self.add_message(
+ "invalid-characters-in-docstring", line=line_num, args=(word,)
+ )
+ continue
+
+ # Store word to private dict or raise a message.
+ if self.config.spelling_store_unknown_words:
+ if lower_cased_word not in self.unknown_words:
+ self.private_dict_file.write("%s\n" % lower_cased_word)
+ self.unknown_words.add(lower_cased_word)
+ else:
+ # Present up to N suggestions.
+ suggestions = self.spelling_dict.suggest(word)
+ del suggestions[self.config.max_spelling_suggestions :]
+ line_segment = line[word_start_at:]
+ match = re.search(r"(\W|^)(%s)(\W|$)" % word, line_segment)
+ if match:
+ # Start position of second group in regex.
+ col = match.regs[2][0]
+ else:
+ col = line_segment.index(word)
+ col += word_start_at
+ if starts_with_comment:
+ col += 1
+ indicator = (" " * col) + ("^" * len(word))
+ all_suggestion = "' or '".join(suggestions)
+ args = (word, original_line, indicator, f"'{all_suggestion}'")
+ self.add_message(msgid, line=line_num, args=args)
+
+ def process_tokens(self, tokens):
+ if not self.initialized:
+ return
+
+ # Process tokens and look for comments.
+ for (tok_type, token, (start_row, _), _, _) in tokens:
+ if tok_type == tokenize.COMMENT:
+ if start_row == 1 and token.startswith("#!/"):
+ # Skip shebang lines
+ continue
+ if token.startswith("# pylint:"):
+ # Skip pylint enable/disable comments
+ continue
+ self._check_spelling("wrong-spelling-in-comment", token, start_row)
+
+ @check_messages("wrong-spelling-in-docstring")
+ def visit_module(self, node):
+ if not self.initialized:
+ return
+ self._check_docstring(node)
+
+ @check_messages("wrong-spelling-in-docstring")
+ def visit_classdef(self, node):
+ if not self.initialized:
+ return
+ self._check_docstring(node)
+
+ @check_messages("wrong-spelling-in-docstring")
+ def visit_functiondef(self, node):
+ if not self.initialized:
+ return
+ self._check_docstring(node)
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ def _check_docstring(self, node):
+ """check the node has any spelling errors"""
+ docstring = node.doc
+ if not docstring:
+ return
+
+ start_line = node.lineno + 1
+
+ # Go through lines of docstring
+ for idx, line in enumerate(docstring.splitlines()):
+ self._check_spelling("wrong-spelling-in-docstring", line, start_line + idx)
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(SpellingChecker(linter))
diff --git a/pylint/checkers/stdlib.py b/pylint/checkers/stdlib.py
new file mode 100644
index 0000000..d450dbc
--- /dev/null
+++ b/pylint/checkers/stdlib.py
@@ -0,0 +1,630 @@
+# Copyright (c) 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Cosmin Poieana <cmin@ropython.org>
+# Copyright (c) 2014 Vlad Temian <vladtemian@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Cezar <celnazli@bitdefender.com>
+# Copyright (c) 2015 Chris Rebert <code@rebertia.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Jared Garst <cultofjared@gmail.com>
+# Copyright (c) 2017 Renat Galimov <renat2017@gmail.com>
+# Copyright (c) 2017 Martin <MartinBasti@users.noreply.github.com>
+# Copyright (c) 2017 Christopher Zurcher <zurcher@users.noreply.github.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Banjamin Freeman <befreeman@users.noreply.github.com>
+# Copyright (c) 2018 Ioana Tagirta <ioana.tagirta@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Julien Palard <julien@palard.fr>
+# Copyright (c) 2019 laike9m <laike9m@users.noreply.github.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Robert Schweizer <robert_schweizer@gmx.de>
+# Copyright (c) 2019 fadedDexofan <fadedDexofan@gmail.com>
+# Copyright (c) 2020 Sorin Sbarnea <ssbarnea@redhat.com>
+# Copyright (c) 2020 Federico Bond <federicobond@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 谭九鼎 <109224573@qq.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Matus Valo <matusvalo@users.noreply.github.com>
+# Copyright (c) 2021 victor <16359131+jiajunsu@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Checkers for various standard library functions."""
+
+import sys
+from collections.abc import Iterable
+
+import astroid
+
+from pylint.checkers import BaseChecker, DeprecatedMixin, utils
+from pylint.interfaces import IAstroidChecker
+
+OPEN_FILES = {"open", "file"}
+UNITTEST_CASE = "unittest.case"
+THREADING_THREAD = "threading.Thread"
+COPY_COPY = "copy.copy"
+OS_ENVIRON = "os._Environ"
+ENV_GETTERS = {"os.getenv"}
+SUBPROCESS_POPEN = "subprocess.Popen"
+SUBPROCESS_RUN = "subprocess.run"
+OPEN_MODULE = "_io"
+
+
+DEPRECATED_MODULES = {
+ (0, 0, 0): {"tkinter.tix", "fpectl"},
+ (3, 2, 0): {"optparse"},
+ (3, 4, 0): {"imp"},
+ (3, 5, 0): {"formatter"},
+ (3, 6, 0): {"asynchat", "asyncore"},
+ (3, 7, 0): {"macpath"},
+ (3, 9, 0): {"lib2to3", "parser", "symbol", "binhex"},
+}
+
+DEPRECATED_ARGUMENTS = {
+ (0, 0, 0): {
+ "int": ((None, "x"),),
+ "bool": ((None, "x"),),
+ "float": ((None, "x"),),
+ },
+ (3, 8, 0): {
+ "asyncio.tasks.sleep": ((None, "loop"),),
+ "asyncio.tasks.gather": ((None, "loop"),),
+ "asyncio.tasks.shield": ((None, "loop"),),
+ "asyncio.tasks.wait_for": ((None, "loop"),),
+ "asyncio.tasks.wait": ((None, "loop"),),
+ "asyncio.tasks.as_completed": ((None, "loop"),),
+ "asyncio.subprocess.create_subprocess_exec": ((None, "loop"),),
+ "asyncio.subprocess.create_subprocess_shell": ((4, "loop"),),
+ "gettext.translation": ((5, "codeset"),),
+ "gettext.install": ((2, "codeset"),),
+ "functools.partialmethod": ((None, "func"),),
+ "weakref.finalize": ((None, "func"), (None, "obj")),
+ "profile.Profile.runcall": ((None, "func"),),
+ "cProfile.Profile.runcall": ((None, "func"),),
+ "bdb.Bdb.runcall": ((None, "func"),),
+ "trace.Trace.runfunc": ((None, "func"),),
+ "curses.wrapper": ((None, "func"),),
+ "unittest.case.TestCase.addCleanup": ((None, "function"),),
+ "concurrent.futures.thread.ThreadPoolExecutor.submit": ((None, "fn"),),
+ "concurrent.futures.process.ProcessPoolExecutor.submit": ((None, "fn"),),
+ "contextlib._BaseExitStack.callback": ((None, "callback"),),
+ "contextlib.AsyncExitStack.push_async_callback": ((None, "callback"),),
+ "multiprocessing.managers.Server.create": ((None, "c"), (None, "typeid")),
+ "multiprocessing.managers.SharedMemoryServer.create": (
+ (None, "c"),
+ (None, "typeid"),
+ ),
+ },
+ (3, 9, 0): {"random.Random.shuffle": ((1, "random"),)},
+}
+
+DEPRECATED_DECORATORS = {
+ (3, 8, 0): {"asyncio.coroutine"},
+ (3, 3, 0): {
+ "abc.abstractclassmethod",
+ "abc.abstractstaticmethod",
+ "abc.abstractproperty",
+ },
+}
+
+
+DEPRECATED_METHODS = {
+ 0: {
+ "cgi.parse_qs",
+ "cgi.parse_qsl",
+ "ctypes.c_buffer",
+ "distutils.command.register.register.check_metadata",
+ "distutils.command.sdist.sdist.check_metadata",
+ "tkinter.Misc.tk_menuBar",
+ "tkinter.Menu.tk_bindForTraversal",
+ },
+ 2: {
+ (2, 6, 0): {
+ "commands.getstatus",
+ "os.popen2",
+ "os.popen3",
+ "os.popen4",
+ "macostools.touched",
+ },
+ (2, 7, 0): {
+ "unittest.case.TestCase.assertEquals",
+ "unittest.case.TestCase.assertNotEquals",
+ "unittest.case.TestCase.assertAlmostEquals",
+ "unittest.case.TestCase.assertNotAlmostEquals",
+ "unittest.case.TestCase.assert_",
+ "xml.etree.ElementTree.Element.getchildren",
+ "xml.etree.ElementTree.Element.getiterator",
+ "xml.etree.ElementTree.XMLParser.getiterator",
+ "xml.etree.ElementTree.XMLParser.doctype",
+ },
+ },
+ 3: {
+ (3, 0, 0): {
+ "inspect.getargspec",
+ "failUnlessEqual",
+ "assertEquals",
+ "failIfEqual",
+ "assertNotEquals",
+ "failUnlessAlmostEqual",
+ "assertAlmostEquals",
+ "failIfAlmostEqual",
+ "assertNotAlmostEquals",
+ "failUnless",
+ "assert_",
+ "failUnlessRaises",
+ "failIf",
+ "assertRaisesRegexp",
+ "assertRegexpMatches",
+ "assertNotRegexpMatches",
+ },
+ (3, 1, 0): {
+ "base64.encodestring",
+ "base64.decodestring",
+ "ntpath.splitunc",
+ "os.path.splitunc",
+ "os.stat_float_times",
+ },
+ (3, 2, 0): {
+ "cgi.escape",
+ "configparser.RawConfigParser.readfp",
+ "xml.etree.ElementTree.Element.getchildren",
+ "xml.etree.ElementTree.Element.getiterator",
+ "xml.etree.ElementTree.XMLParser.getiterator",
+ "xml.etree.ElementTree.XMLParser.doctype",
+ },
+ (3, 3, 0): {
+ "inspect.getmoduleinfo",
+ "logging.warn",
+ "logging.Logger.warn",
+ "logging.LoggerAdapter.warn",
+ "nntplib._NNTPBase.xpath",
+ "platform.popen",
+ },
+ (3, 4, 0): {
+ "importlib.find_loader",
+ "plistlib.readPlist",
+ "plistlib.writePlist",
+ "plistlib.readPlistFromBytes",
+ "plistlib.writePlistToBytes",
+ },
+ (3, 4, 4): {"asyncio.tasks.async"},
+ (3, 5, 0): {
+ "fractions.gcd",
+ "inspect.formatargspec",
+ "inspect.getcallargs",
+ "platform.linux_distribution",
+ "platform.dist",
+ },
+ (3, 6, 0): {"importlib._bootstrap_external.FileLoader.load_module"},
+ (3, 7, 0): {
+ "sys.set_coroutine_wrapper",
+ "sys.get_coroutine_wrapper",
+ "aifc.openfp",
+ "asyncio.Task.current_task",
+ "asyncio.Task.all_task",
+ "locale.format",
+ "ssl.wrap_socket",
+ "sunau.openfp",
+ "wave.openfp",
+ },
+ (3, 8, 0): {
+ "gettext.lgettext",
+ "gettext.ldgettext",
+ "gettext.lngettext",
+ "gettext.ldngettext",
+ "gettext.bind_textdomain_codeset",
+ "gettext.NullTranslations.output_charset",
+ "gettext.NullTranslations.set_output_charset",
+ "threading.Thread.isAlive",
+ },
+ (3, 9, 0): {
+ "binascii.b2a_hqx",
+ "binascii.a2b_hqx",
+ "binascii.rlecode_hqx",
+ "binascii.rledecode_hqx",
+ },
+ (3, 10, 0): {
+ "_sqlite3.enable_shared_cache",
+ "pathlib.Path.link_to",
+ },
+ },
+}
+
+
+DEPRECATED_CLASSES = {
+ (3, 3, 0): {
+ "importlib.abc": {
+ "Finder",
+ },
+ "pkgutil": {
+ "ImpImporter",
+ "ImpLoader",
+ },
+ "collections": {
+ "Awaitable",
+ "Coroutine",
+ "AsyncIterable",
+ "AsyncIterator",
+ "AsyncGenerator",
+ "Hashable",
+ "Iterable",
+ "Iterator",
+ "Generator",
+ "Reversible",
+ "Sized",
+ "Container",
+ "Callable",
+ "Collection",
+ "Set",
+ "MutableSet",
+ "Mapping",
+ "MutableMapping",
+ "MappingView",
+ "KeysView",
+ "ItemsView",
+ "ValuesView",
+ "Sequence",
+ "MutableSequence",
+ "ByteString",
+ },
+ },
+ (3, 9, 0): {
+ "smtpd": {
+ "MailmanProxy",
+ }
+ },
+}
+
+
+def _check_mode_str(mode):
+ # check type
+ if not isinstance(mode, str):
+ return False
+ # check syntax
+ modes = set(mode)
+ _mode = "rwatb+Ux"
+ creating = "x" in modes
+ if modes - set(_mode) or len(mode) > len(modes):
+ return False
+ # check logic
+ reading = "r" in modes
+ writing = "w" in modes
+ appending = "a" in modes
+ text = "t" in modes
+ binary = "b" in modes
+ if "U" in modes:
+ if writing or appending or creating:
+ return False
+ reading = True
+ if text and binary:
+ return False
+ total = reading + writing + appending + creating
+ if total > 1:
+ return False
+ if not (reading or writing or appending or creating):
+ return False
+ return True
+
+
+class StdlibChecker(DeprecatedMixin, BaseChecker):
+ __implements__ = (IAstroidChecker,)
+ name = "stdlib"
+
+ msgs = {
+ "W1501": (
+ '"%s" is not a valid mode for open.',
+ "bad-open-mode",
+ "Python supports: r, w, a[, x] modes with b, +, "
+ "and U (only with r) options. "
+ "See https://docs.python.org/2/library/functions.html#open",
+ ),
+ "W1502": (
+ "Using datetime.time in a boolean context.",
+ "boolean-datetime",
+ "Using datetime.time in a boolean context can hide "
+ "subtle bugs when the time they represent matches "
+ "midnight UTC. This behaviour was fixed in Python 3.5. "
+ "See https://bugs.python.org/issue13936 for reference.",
+ {"maxversion": (3, 5)},
+ ),
+ "W1503": (
+ "Redundant use of %s with constant value %r",
+ "redundant-unittest-assert",
+ "The first argument of assertTrue and assertFalse is "
+ "a condition. If a constant is passed as parameter, that "
+ "condition will be always true. In this case a warning "
+ "should be emitted.",
+ ),
+ "W1505": (
+ "Using deprecated method %s()",
+ "deprecated-method",
+ "The method is marked as deprecated and will be removed in "
+ "a future version of Python. Consider looking for an "
+ "alternative in the documentation.",
+ ),
+ "W1506": (
+ "threading.Thread needs the target function",
+ "bad-thread-instantiation",
+ "The warning is emitted when a threading.Thread class "
+ "is instantiated without the target function being passed. "
+ "By default, the first parameter is the group param, not the target param. ",
+ ),
+ "W1507": (
+ "Using copy.copy(os.environ). Use os.environ.copy() instead. ",
+ "shallow-copy-environ",
+ "os.environ is not a dict object but proxy object, so "
+ "shallow copy has still effects on original object. "
+ "See https://bugs.python.org/issue15373 for reference. ",
+ ),
+ "E1507": (
+ "%s does not support %s type argument",
+ "invalid-envvar-value",
+ "Env manipulation functions support only string type arguments. "
+ "See https://docs.python.org/3/library/os.html#os.getenv. ",
+ ),
+ "W1508": (
+ "%s default type is %s. Expected str or None.",
+ "invalid-envvar-default",
+ "Env manipulation functions return None or str values. "
+ "Supplying anything different as a default may cause bugs. "
+ "See https://docs.python.org/3/library/os.html#os.getenv. ",
+ ),
+ "W1509": (
+ "Using preexec_fn keyword which may be unsafe in the presence "
+ "of threads",
+ "subprocess-popen-preexec-fn",
+ "The preexec_fn parameter is not safe to use in the presence "
+ "of threads in your application. The child process could "
+ "deadlock before exec is called. If you must use it, keep it "
+ "trivial! Minimize the number of libraries you call into."
+ "https://docs.python.org/3/library/subprocess.html#popen-constructor",
+ ),
+ "W1510": (
+ "Using subprocess.run without explicitly set `check` is not recommended.",
+ "subprocess-run-check",
+ "The check parameter should always be used with explicitly set "
+ "`check` keyword to make clear what the error-handling behavior is."
+ "https://docs.python.org/3/library/subprocess.html#subprocess.run",
+ ),
+ "W1511": (
+ "Using deprecated argument %s of method %s()",
+ "deprecated-argument",
+ "The argument is marked as deprecated and will be removed in the future.",
+ ),
+ "W1512": (
+ "Using deprecated class %s of module %s",
+ "deprecated-class",
+ "The class is marked as deprecated and will be removed in the future.",
+ ),
+ "W1513": (
+ "Using deprecated decorator %s()",
+ "deprecated-decorator",
+ "The decorator is marked as deprecated and will be removed in the future.",
+ ),
+ }
+
+ def __init__(self, linter=None):
+ BaseChecker.__init__(self, linter)
+ self._deprecated_methods = set()
+ self._deprecated_methods.update(DEPRECATED_METHODS[0])
+ for since_vers, func_list in DEPRECATED_METHODS[sys.version_info[0]].items():
+ if since_vers <= sys.version_info:
+ self._deprecated_methods.update(func_list)
+ self._deprecated_attributes = dict()
+ for since_vers, func_list in DEPRECATED_ARGUMENTS.items():
+ if since_vers <= sys.version_info:
+ self._deprecated_attributes.update(func_list)
+ self._deprecated_classes = dict()
+ for since_vers, class_list in DEPRECATED_CLASSES.items():
+ if since_vers <= sys.version_info:
+ self._deprecated_classes.update(class_list)
+ self._deprecated_modules = set()
+ for since_vers, mod_list in DEPRECATED_MODULES.items():
+ if since_vers <= sys.version_info:
+ self._deprecated_modules.update(mod_list)
+ self._deprecated_decorators = set()
+ for since_vers, decorator_list in DEPRECATED_DECORATORS.items():
+ if since_vers <= sys.version_info:
+ self._deprecated_decorators.update(decorator_list)
+
+ def _check_bad_thread_instantiation(self, node):
+ if not node.kwargs and not node.keywords and len(node.args) <= 1:
+ self.add_message("bad-thread-instantiation", node=node)
+
+ def _check_for_preexec_fn_in_popen(self, node):
+ if node.keywords:
+ for keyword in node.keywords:
+ if keyword.arg == "preexec_fn":
+ self.add_message("subprocess-popen-preexec-fn", node=node)
+
+ def _check_for_check_kw_in_run(self, node):
+ kwargs = {keyword.arg for keyword in (node.keywords or ())}
+ if "check" not in kwargs:
+ self.add_message("subprocess-run-check", node=node)
+
+ def _check_shallow_copy_environ(self, node):
+ arg = utils.get_argument_from_call(node, position=0)
+ for inferred in arg.inferred():
+ if inferred.qname() == OS_ENVIRON:
+ self.add_message("shallow-copy-environ", node=node)
+ break
+
+ @utils.check_messages(
+ "bad-open-mode",
+ "redundant-unittest-assert",
+ "deprecated-method",
+ "deprecated-argument",
+ "bad-thread-instantiation",
+ "shallow-copy-environ",
+ "invalid-envvar-value",
+ "invalid-envvar-default",
+ "subprocess-popen-preexec-fn",
+ "subprocess-run-check",
+ "deprecated-class",
+ )
+ def visit_call(self, node):
+ """Visit a Call node."""
+ try:
+ self.check_deprecated_class_in_call(node)
+ for inferred in node.func.infer():
+ if inferred is astroid.Uninferable:
+ continue
+ if inferred.root().name == OPEN_MODULE:
+ if getattr(node.func, "name", None) in OPEN_FILES:
+ self._check_open_mode(node)
+ elif inferred.root().name == UNITTEST_CASE:
+ self._check_redundant_assert(node, inferred)
+ elif isinstance(inferred, astroid.ClassDef):
+ if inferred.qname() == THREADING_THREAD:
+ self._check_bad_thread_instantiation(node)
+ elif inferred.qname() == SUBPROCESS_POPEN:
+ self._check_for_preexec_fn_in_popen(node)
+ elif isinstance(inferred, astroid.FunctionDef):
+ name = inferred.qname()
+ if name == COPY_COPY:
+ self._check_shallow_copy_environ(node)
+ elif name in ENV_GETTERS:
+ self._check_env_function(node, inferred)
+ elif name == SUBPROCESS_RUN:
+ self._check_for_check_kw_in_run(node)
+ self.check_deprecated_method(node, inferred)
+ except astroid.InferenceError:
+ return
+
+ @utils.check_messages("boolean-datetime")
+ def visit_unaryop(self, node):
+ if node.op == "not":
+ self._check_datetime(node.operand)
+
+ @utils.check_messages("boolean-datetime")
+ def visit_if(self, node):
+ self._check_datetime(node.test)
+
+ @utils.check_messages("boolean-datetime")
+ def visit_ifexp(self, node):
+ self._check_datetime(node.test)
+
+ @utils.check_messages("boolean-datetime")
+ def visit_boolop(self, node):
+ for value in node.values:
+ self._check_datetime(value)
+
+ def _check_redundant_assert(self, node, infer):
+ if (
+ isinstance(infer, astroid.BoundMethod)
+ and node.args
+ and isinstance(node.args[0], astroid.Const)
+ and infer.name in ["assertTrue", "assertFalse"]
+ ):
+ self.add_message(
+ "redundant-unittest-assert",
+ args=(infer.name, node.args[0].value),
+ node=node,
+ )
+
+ def _check_datetime(self, node):
+ """Check that a datetime was inferred.
+ If so, emit boolean-datetime warning.
+ """
+ try:
+ inferred = next(node.infer())
+ except astroid.InferenceError:
+ return
+ if (
+ isinstance(inferred, astroid.Instance)
+ and inferred.qname() == "datetime.time"
+ ):
+ self.add_message("boolean-datetime", node=node)
+
+ def _check_open_mode(self, node):
+ """Check that the mode argument of an open or file call is valid."""
+ try:
+ mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
+ except utils.NoSuchArgumentError:
+ return
+ if mode_arg:
+ mode_arg = utils.safe_infer(mode_arg)
+ if isinstance(mode_arg, astroid.Const) and not _check_mode_str(
+ mode_arg.value
+ ):
+ self.add_message("bad-open-mode", node=node, args=mode_arg.value)
+
+ def _check_env_function(self, node, infer):
+ env_name_kwarg = "key"
+ env_value_kwarg = "default"
+ if node.keywords:
+ kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
+ else:
+ kwargs = None
+ if node.args:
+ env_name_arg = node.args[0]
+ elif kwargs and env_name_kwarg in kwargs:
+ env_name_arg = kwargs[env_name_kwarg]
+ else:
+ env_name_arg = None
+
+ if env_name_arg:
+ self._check_invalid_envvar_value(
+ node=node,
+ message="invalid-envvar-value",
+ call_arg=utils.safe_infer(env_name_arg),
+ infer=infer,
+ allow_none=False,
+ )
+
+ if len(node.args) == 2:
+ env_value_arg = node.args[1]
+ elif kwargs and env_value_kwarg in kwargs:
+ env_value_arg = kwargs[env_value_kwarg]
+ else:
+ env_value_arg = None
+
+ if env_value_arg:
+ self._check_invalid_envvar_value(
+ node=node,
+ infer=infer,
+ message="invalid-envvar-default",
+ call_arg=utils.safe_infer(env_value_arg),
+ allow_none=True,
+ )
+
+ def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
+ if call_arg in (astroid.Uninferable, None):
+ return
+
+ name = infer.qname()
+ if isinstance(call_arg, astroid.Const):
+ emit = False
+ if call_arg.value is None:
+ emit = not allow_none
+ elif not isinstance(call_arg.value, str):
+ emit = True
+ if emit:
+ self.add_message(message, node=node, args=(name, call_arg.pytype()))
+ else:
+ self.add_message(message, node=node, args=(name, call_arg.pytype()))
+
+ def deprecated_modules(self):
+ """Callback returning the deprecated modules."""
+ return self._deprecated_modules
+
+ def deprecated_methods(self):
+ return self._deprecated_methods
+
+ def deprecated_arguments(self, method: str):
+ return self._deprecated_attributes.get(method, ())
+
+ def deprecated_classes(self, module: str):
+ return self._deprecated_classes.get(module, ())
+
+ def deprecated_decorators(self) -> Iterable:
+ return self._deprecated_decorators
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(StdlibChecker(linter))
diff --git a/pylint/checkers/strings.py b/pylint/checkers/strings.py
new file mode 100644
index 0000000..a3c8c88
--- /dev/null
+++ b/pylint/checkers/strings.py
@@ -0,0 +1,981 @@
+# Copyright (c) 2009-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2010 Daniel Harding <dharding@gmail.com>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Rene Zhang <rz99@cornell.edu>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016, 2018 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2016 Peter Dawyndt <Peter.Dawyndt@UGent.be>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018-2019 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Alan Chan <achan961117@gmail.com>
+# Copyright (c) 2018 Yury Gribov <tetra2005@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Wes Turner <westurner@google.com>
+# Copyright (c) 2019 Djailla <bastien.vallet@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Matthew Suozzo <msuozzo@google.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 谭九鼎 <109224573@qq.com>
+# Copyright (c) 2020 Anthony <tanant@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Peter Kolbus <peter.kolbus@garmin.com>
+
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Checker for string formatting operations.
+"""
+
+import builtins
+import collections
+import numbers
+import re
+import tokenize
+from typing import TYPE_CHECKING, Iterable
+
+import astroid
+
+from pylint.checkers import BaseChecker, BaseTokenChecker, utils
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker, IRawChecker, ITokenChecker
+
+if TYPE_CHECKING:
+ from typing import Counter # typing.Counter added in Python 3.6.1
+
+_AST_NODE_STR_TYPES = ("__builtin__.unicode", "__builtin__.str", "builtins.str")
+# Prefixes for both strings and bytes literals per
+# https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
+_PREFIXES = {
+ "r",
+ "u",
+ "R",
+ "U",
+ "f",
+ "F",
+ "fr",
+ "Fr",
+ "fR",
+ "FR",
+ "rf",
+ "rF",
+ "Rf",
+ "RF",
+ "b",
+ "B",
+ "br",
+ "Br",
+ "bR",
+ "BR",
+ "rb",
+ "rB",
+ "Rb",
+ "RB",
+}
+SINGLE_QUOTED_REGEX = re.compile("(%s)?'''" % "|".join(_PREFIXES))
+DOUBLE_QUOTED_REGEX = re.compile('(%s)?"""' % "|".join(_PREFIXES))
+QUOTE_DELIMITER_REGEX = re.compile("(%s)?(\"|')" % "|".join(_PREFIXES), re.DOTALL)
+
+MSGS = { # pylint: disable=consider-using-namedtuple-or-dataclass
+ "E1300": (
+ "Unsupported format character %r (%#02x) at index %d",
+ "bad-format-character",
+ "Used when an unsupported format character is used in a format string.",
+ ),
+ "E1301": (
+ "Format string ends in middle of conversion specifier",
+ "truncated-format-string",
+ "Used when a format string terminates before the end of a "
+ "conversion specifier.",
+ ),
+ "E1302": (
+ "Mixing named and unnamed conversion specifiers in format string",
+ "mixed-format-string",
+ "Used when a format string contains both named (e.g. '%(foo)d') "
+ "and unnamed (e.g. '%d') conversion specifiers. This is also "
+ "used when a named conversion specifier contains * for the "
+ "minimum field width and/or precision.",
+ ),
+ "E1303": (
+ "Expected mapping for format string, not %s",
+ "format-needs-mapping",
+ "Used when a format string that uses named conversion specifiers "
+ "is used with an argument that is not a mapping.",
+ ),
+ "W1300": (
+ "Format string dictionary key should be a string, not %s",
+ "bad-format-string-key",
+ "Used when a format string that uses named conversion specifiers "
+ "is used with a dictionary whose keys are not all strings.",
+ ),
+ "W1301": (
+ "Unused key %r in format string dictionary",
+ "unused-format-string-key",
+ "Used when a format string that uses named conversion specifiers "
+ "is used with a dictionary that contains keys not required by the "
+ "format string.",
+ ),
+ "E1304": (
+ "Missing key %r in format string dictionary",
+ "missing-format-string-key",
+ "Used when a format string that uses named conversion specifiers "
+ "is used with a dictionary that doesn't contain all the keys "
+ "required by the format string.",
+ ),
+ "E1305": (
+ "Too many arguments for format string",
+ "too-many-format-args",
+ "Used when a format string that uses unnamed conversion "
+ "specifiers is given too many arguments.",
+ ),
+ "E1306": (
+ "Not enough arguments for format string",
+ "too-few-format-args",
+ "Used when a format string that uses unnamed conversion "
+ "specifiers is given too few arguments",
+ ),
+ "E1307": (
+ "Argument %r does not match format type %r",
+ "bad-string-format-type",
+ "Used when a type required by format string "
+ "is not suitable for actual argument type",
+ ),
+ "E1310": (
+ "Suspicious argument in %s.%s call",
+ "bad-str-strip-call",
+ "The argument to a str.{l,r,}strip call contains a duplicate character, ",
+ ),
+ "W1302": (
+ "Invalid format string",
+ "bad-format-string",
+ "Used when a PEP 3101 format string is invalid.",
+ ),
+ "W1303": (
+ "Missing keyword argument %r for format string",
+ "missing-format-argument-key",
+ "Used when a PEP 3101 format string that uses named fields "
+ "doesn't receive one or more required keywords.",
+ ),
+ "W1304": (
+ "Unused format argument %r",
+ "unused-format-string-argument",
+ "Used when a PEP 3101 format string that uses named "
+ "fields is used with an argument that "
+ "is not required by the format string.",
+ ),
+ "W1305": (
+ "Format string contains both automatic field numbering "
+ "and manual field specification",
+ "format-combined-specification",
+ "Used when a PEP 3101 format string contains both automatic "
+ "field numbering (e.g. '{}') and manual field "
+ "specification (e.g. '{0}').",
+ ),
+ "W1306": (
+ "Missing format attribute %r in format specifier %r",
+ "missing-format-attribute",
+ "Used when a PEP 3101 format string uses an "
+ "attribute specifier ({0.length}), but the argument "
+ "passed for formatting doesn't have that attribute.",
+ ),
+ "W1307": (
+ "Using invalid lookup key %r in format specifier %r",
+ "invalid-format-index",
+ "Used when a PEP 3101 format string uses a lookup specifier "
+ "({a[1]}), but the argument passed for formatting "
+ "doesn't contain or doesn't have that key as an attribute.",
+ ),
+ "W1308": (
+ "Duplicate string formatting argument %r, consider passing as named argument",
+ "duplicate-string-formatting-argument",
+ "Used when we detect that a string formatting is "
+ "repeating an argument instead of using named string arguments",
+ ),
+ "W1309": (
+ "Using an f-string that does not have any interpolated variables",
+ "f-string-without-interpolation",
+ "Used when we detect an f-string that does not use any interpolation variables, "
+ "in which case it can be either a normal string or a bug in the code.",
+ ),
+}
+
+OTHER_NODES = (
+ astroid.Const,
+ astroid.List,
+ astroid.Lambda,
+ astroid.FunctionDef,
+ astroid.ListComp,
+ astroid.SetComp,
+ astroid.GeneratorExp,
+)
+
+BUILTINS_STR = builtins.__name__ + ".str"
+BUILTINS_FLOAT = builtins.__name__ + ".float"
+BUILTINS_INT = builtins.__name__ + ".int"
+
+
+def get_access_path(key, parts):
+ """Given a list of format specifiers, returns
+ the final access path (e.g. a.b.c[0][1]).
+ """
+ path = []
+ for is_attribute, specifier in parts:
+ if is_attribute:
+ path.append(f".{specifier}")
+ else:
+ path.append(f"[{specifier!r}]")
+ return str(key) + "".join(path)
+
+
+def arg_matches_format_type(arg_type, format_type):
+ if format_type in "sr":
+ # All types can be printed with %s and %r
+ return True
+ if isinstance(arg_type, astroid.Instance):
+ arg_type = arg_type.pytype()
+ if arg_type == BUILTINS_STR:
+ return format_type == "c"
+ if arg_type == BUILTINS_FLOAT:
+ return format_type in "deEfFgGn%"
+ if arg_type == BUILTINS_INT:
+ # Integers allow all types
+ return True
+ return False
+ return True
+
+
+class StringFormatChecker(BaseChecker):
+ """Checks string formatting operations to ensure that the format string
+ is valid and the arguments match the format string.
+ """
+
+ __implements__ = (IAstroidChecker,)
+ name = "string"
+ msgs = MSGS
+
+ # pylint: disable=too-many-branches
+ @check_messages(
+ "bad-format-character",
+ "truncated-format-string",
+ "mixed-format-string",
+ "bad-format-string-key",
+ "missing-format-string-key",
+ "unused-format-string-key",
+ "bad-string-format-type",
+ "format-needs-mapping",
+ "too-many-format-args",
+ "too-few-format-args",
+ "bad-string-format-type",
+ )
+ def visit_binop(self, node):
+ if node.op != "%":
+ return
+ left = node.left
+ args = node.right
+
+ if not (isinstance(left, astroid.Const) and isinstance(left.value, str)):
+ return
+ format_string = left.value
+ try:
+ (
+ required_keys,
+ required_num_args,
+ required_key_types,
+ required_arg_types,
+ ) = utils.parse_format_string(format_string)
+ except utils.UnsupportedFormatCharacter as exc:
+ formatted = format_string[exc.index]
+ self.add_message(
+ "bad-format-character",
+ node=node,
+ args=(formatted, ord(formatted), exc.index),
+ )
+ return
+ except utils.IncompleteFormatString:
+ self.add_message("truncated-format-string", node=node)
+ return
+ if required_keys and required_num_args:
+ # The format string uses both named and unnamed format
+ # specifiers.
+ self.add_message("mixed-format-string", node=node)
+ elif required_keys:
+ # The format string uses only named format specifiers.
+ # Check that the RHS of the % operator is a mapping object
+ # that contains precisely the set of keys required by the
+ # format string.
+ if isinstance(args, astroid.Dict):
+ keys = set()
+ unknown_keys = False
+ for k, _ in args.items:
+ if isinstance(k, astroid.Const):
+ key = k.value
+ if isinstance(key, str):
+ keys.add(key)
+ else:
+ self.add_message(
+ "bad-format-string-key", node=node, args=key
+ )
+ else:
+ # One of the keys was something other than a
+ # constant. Since we can't tell what it is,
+ # suppress checks for missing keys in the
+ # dictionary.
+ unknown_keys = True
+ if not unknown_keys:
+ for key in required_keys:
+ if key not in keys:
+ self.add_message(
+ "missing-format-string-key", node=node, args=key
+ )
+ for key in keys:
+ if key not in required_keys:
+ self.add_message(
+ "unused-format-string-key", node=node, args=key
+ )
+ for key, arg in args.items:
+ if not isinstance(key, astroid.Const):
+ continue
+ format_type = required_key_types.get(key.value, None)
+ arg_type = utils.safe_infer(arg)
+ if (
+ format_type is not None
+ and arg_type not in (None, astroid.Uninferable)
+ and not arg_matches_format_type(arg_type, format_type)
+ ):
+ self.add_message(
+ "bad-string-format-type",
+ node=node,
+ args=(arg_type.pytype(), format_type),
+ )
+ elif isinstance(args, (OTHER_NODES, astroid.Tuple)):
+ type_name = type(args).__name__
+ self.add_message("format-needs-mapping", node=node, args=type_name)
+ # else:
+ # The RHS of the format specifier is a name or
+ # expression. It may be a mapping object, so
+ # there's nothing we can check.
+ else:
+ # The format string uses only unnamed format specifiers.
+ # Check that the number of arguments passed to the RHS of
+ # the % operator matches the number required by the format
+ # string.
+ args_elts = ()
+ if isinstance(args, astroid.Tuple):
+ rhs_tuple = utils.safe_infer(args)
+ num_args = None
+ if hasattr(rhs_tuple, "elts"):
+ args_elts = rhs_tuple.elts
+ num_args = len(args_elts)
+ elif isinstance(args, (OTHER_NODES, (astroid.Dict, astroid.DictComp))):
+ args_elts = [args]
+ num_args = 1
+ else:
+ # The RHS of the format specifier is a name or
+ # expression. It could be a tuple of unknown size, so
+ # there's nothing we can check.
+ num_args = None
+ if num_args is not None:
+ if num_args > required_num_args:
+ self.add_message("too-many-format-args", node=node)
+ elif num_args < required_num_args:
+ self.add_message("too-few-format-args", node=node)
+ for arg, format_type in zip(args_elts, required_arg_types):
+ if not arg:
+ continue
+ arg_type = utils.safe_infer(arg)
+ if (
+ arg_type
+ not in (
+ None,
+ astroid.Uninferable,
+ )
+ and not arg_matches_format_type(arg_type, format_type)
+ ):
+ self.add_message(
+ "bad-string-format-type",
+ node=node,
+ args=(arg_type.pytype(), format_type),
+ )
+
+ @check_messages("f-string-without-interpolation")
+ def visit_joinedstr(self, node):
+ if isinstance(node.parent, astroid.FormattedValue):
+ return
+ for value in node.values:
+ if isinstance(value, astroid.FormattedValue):
+ return
+ self.add_message("f-string-without-interpolation", node=node)
+
+ @check_messages(*MSGS)
+ def visit_call(self, node):
+ func = utils.safe_infer(node.func)
+ if (
+ isinstance(func, astroid.BoundMethod)
+ and isinstance(func.bound, astroid.Instance)
+ and func.bound.name in ("str", "unicode", "bytes")
+ ):
+ if func.name in ("strip", "lstrip", "rstrip") and node.args:
+ arg = utils.safe_infer(node.args[0])
+ if not isinstance(arg, astroid.Const) or not isinstance(arg.value, str):
+ return
+ if len(arg.value) != len(set(arg.value)):
+ self.add_message(
+ "bad-str-strip-call",
+ node=node,
+ args=(func.bound.name, func.name),
+ )
+ elif func.name == "format":
+ self._check_new_format(node, func)
+
+ def _detect_vacuous_formatting(self, node, positional_arguments):
+ counter = collections.Counter(
+ arg.name for arg in positional_arguments if isinstance(arg, astroid.Name)
+ )
+ for name, count in counter.items():
+ if count == 1:
+ continue
+ self.add_message(
+ "duplicate-string-formatting-argument", node=node, args=(name,)
+ )
+
+ def _check_new_format(self, node, func):
+ """Check the new string formatting."""
+ # Skip format nodes which don't have an explicit string on the
+ # left side of the format operation.
+ # We do this because our inference engine can't properly handle
+ # redefinitions of the original string.
+ # Note that there may not be any left side at all, if the format method
+ # has been assigned to another variable. See issue 351. For example:
+ #
+ # fmt = 'some string {}'.format
+ # fmt('arg')
+ if isinstance(node.func, astroid.Attribute) and not isinstance(
+ node.func.expr, astroid.Const
+ ):
+ return
+ if node.starargs or node.kwargs:
+ return
+ try:
+ strnode = next(func.bound.infer())
+ except astroid.InferenceError:
+ return
+ if not (isinstance(strnode, astroid.Const) and isinstance(strnode.value, str)):
+ return
+ try:
+ call_site = astroid.arguments.CallSite.from_call(node)
+ except astroid.InferenceError:
+ return
+
+ try:
+ fields, num_args, manual_pos = utils.parse_format_method_string(
+ strnode.value
+ )
+ except utils.IncompleteFormatString:
+ self.add_message("bad-format-string", node=node)
+ return
+
+ positional_arguments = call_site.positional_arguments
+ named_arguments = call_site.keyword_arguments
+ named_fields = {field[0] for field in fields if isinstance(field[0], str)}
+ if num_args and manual_pos:
+ self.add_message("format-combined-specification", node=node)
+ return
+
+ check_args = False
+ # Consider "{[0]} {[1]}" as num_args.
+ num_args += sum(1 for field in named_fields if field == "")
+ if named_fields:
+ for field in named_fields:
+ if field and field not in named_arguments:
+ self.add_message(
+ "missing-format-argument-key", node=node, args=(field,)
+ )
+ for field in named_arguments:
+ if field not in named_fields:
+ self.add_message(
+ "unused-format-string-argument", node=node, args=(field,)
+ )
+ # num_args can be 0 if manual_pos is not.
+ num_args = num_args or manual_pos
+ if positional_arguments or num_args:
+ empty = any(True for field in named_fields if field == "")
+ if named_arguments or empty:
+ # Verify the required number of positional arguments
+ # only if the .format got at least one keyword argument.
+ # This means that the format strings accepts both
+ # positional and named fields and we should warn
+ # when one of the them is missing or is extra.
+ check_args = True
+ else:
+ check_args = True
+ if check_args:
+ # num_args can be 0 if manual_pos is not.
+ num_args = num_args or manual_pos
+ if len(positional_arguments) > num_args:
+ self.add_message("too-many-format-args", node=node)
+ elif len(positional_arguments) < num_args:
+ self.add_message("too-few-format-args", node=node)
+
+ self._detect_vacuous_formatting(node, positional_arguments)
+ self._check_new_format_specifiers(node, fields, named_arguments)
+
+ def _check_new_format_specifiers(self, node, fields, named):
+ """
+ Check attribute and index access in the format
+ string ("{0.a}" and "{0[a]}").
+ """
+ for key, specifiers in fields:
+ # Obtain the argument. If it can't be obtained
+ # or inferred, skip this check.
+ if key == "":
+ # {[0]} will have an unnamed argument, defaulting
+ # to 0. It will not be present in `named`, so use the value
+ # 0 for it.
+ key = 0
+ if isinstance(key, numbers.Number):
+ try:
+ argname = utils.get_argument_from_call(node, key)
+ except utils.NoSuchArgumentError:
+ continue
+ else:
+ if key not in named:
+ continue
+ argname = named[key]
+ if argname in (astroid.Uninferable, None):
+ continue
+ try:
+ argument = utils.safe_infer(argname)
+ except astroid.InferenceError:
+ continue
+ if not specifiers or not argument:
+ # No need to check this key if it doesn't
+ # use attribute / item access
+ continue
+ if argument.parent and isinstance(argument.parent, astroid.Arguments):
+ # Ignore any object coming from an argument,
+ # because we can't infer its value properly.
+ continue
+ previous = argument
+ parsed = []
+ for is_attribute, specifier in specifiers:
+ if previous is astroid.Uninferable:
+ break
+ parsed.append((is_attribute, specifier))
+ if is_attribute:
+ try:
+ previous = previous.getattr(specifier)[0]
+ except astroid.NotFoundError:
+ if (
+ hasattr(previous, "has_dynamic_getattr")
+ and previous.has_dynamic_getattr()
+ ):
+ # Don't warn if the object has a custom __getattr__
+ break
+ path = get_access_path(key, parsed)
+ self.add_message(
+ "missing-format-attribute",
+ args=(specifier, path),
+ node=node,
+ )
+ break
+ else:
+ warn_error = False
+ if hasattr(previous, "getitem"):
+ try:
+ previous = previous.getitem(astroid.Const(specifier))
+ except (
+ astroid.AstroidIndexError,
+ astroid.AstroidTypeError,
+ astroid.AttributeInferenceError,
+ ):
+ warn_error = True
+ except astroid.InferenceError:
+ break
+ if previous is astroid.Uninferable:
+ break
+ else:
+ try:
+ # Lookup __getitem__ in the current node,
+ # but skip further checks, because we can't
+ # retrieve the looked object
+ previous.getattr("__getitem__")
+ break
+ except astroid.NotFoundError:
+ warn_error = True
+ if warn_error:
+ path = get_access_path(key, parsed)
+ self.add_message(
+ "invalid-format-index", args=(specifier, path), node=node
+ )
+ break
+
+ try:
+ previous = next(previous.infer())
+ except astroid.InferenceError:
+ # can't check further if we can't infer it
+ break
+
+
+class StringConstantChecker(BaseTokenChecker):
+ """Check string literals"""
+
+ __implements__ = (IAstroidChecker, ITokenChecker, IRawChecker)
+ name = "string"
+ msgs = {
+ "W1401": (
+ "Anomalous backslash in string: '%s'. "
+ "String constant might be missing an r prefix.",
+ "anomalous-backslash-in-string",
+ "Used when a backslash is in a literal string but not as an escape.",
+ ),
+ "W1402": (
+ "Anomalous Unicode escape in byte string: '%s'. "
+ "String constant might be missing an r or u prefix.",
+ "anomalous-unicode-escape-in-string",
+ "Used when an escape like \\u is encountered in a byte "
+ "string where it has no effect.",
+ ),
+ "W1404": (
+ "Implicit string concatenation found in %s",
+ "implicit-str-concat",
+ "String literals are implicitly concatenated in a "
+ "literal iterable definition : "
+ "maybe a comma is missing ?",
+ {"old_names": [("W1403", "implicit-str-concat-in-sequence")]},
+ ),
+ "W1405": (
+ "Quote delimiter %s is inconsistent with the rest of the file",
+ "inconsistent-quotes",
+ "Quote delimiters are not used consistently throughout a module "
+ "(with allowances made for avoiding unnecessary escaping).",
+ ),
+ }
+ options = (
+ (
+ "check-str-concat-over-line-jumps",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "This flag controls whether the "
+ "implicit-str-concat should generate a warning "
+ "on implicit string concatenation in sequences defined over "
+ "several lines.",
+ },
+ ),
+ (
+ "check-quote-consistency",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "This flag controls whether inconsistent-quotes generates a "
+ "warning when the character used as a quote delimiter is used "
+ "inconsistently within a module.",
+ },
+ ),
+ )
+
+ # Characters that have a special meaning after a backslash in either
+ # Unicode or byte strings.
+ ESCAPE_CHARACTERS = "abfnrtvx\n\r\t\\'\"01234567"
+
+ # Characters that have a special meaning after a backslash but only in
+ # Unicode strings.
+ UNICODE_ESCAPE_CHARACTERS = "uUN"
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.string_tokens = {} # token position -> (token value, next token)
+
+ def process_module(self, module):
+ self._unicode_literals = "unicode_literals" in module.future_imports
+
+ def process_tokens(self, tokens):
+ encoding = "ascii"
+ for i, (tok_type, token, start, _, line) in enumerate(tokens):
+ if tok_type == tokenize.ENCODING:
+ # this is always the first token processed
+ encoding = token
+ elif tok_type == tokenize.STRING:
+ # 'token' is the whole un-parsed token; we can look at the start
+ # of it to see whether it's a raw or unicode string etc.
+ self.process_string_token(token, start[0], start[1])
+ # We figure the next token, ignoring comments & newlines:
+ j = i + 1
+ while j < len(tokens) and tokens[j].type in (
+ tokenize.NEWLINE,
+ tokenize.NL,
+ tokenize.COMMENT,
+ ):
+ j += 1
+ next_token = tokens[j] if j < len(tokens) else None
+ if encoding != "ascii":
+ # We convert `tokenize` character count into a byte count,
+ # to match with astroid `.col_offset`
+ start = (start[0], len(line[: start[1]].encode(encoding)))
+ self.string_tokens[start] = (str_eval(token), next_token)
+
+ if self.config.check_quote_consistency:
+ self.check_for_consistent_string_delimiters(tokens)
+
+ @check_messages("implicit-str-concat")
+ def visit_list(self, node):
+ self.check_for_concatenated_strings(node.elts, "list")
+
+ @check_messages("implicit-str-concat")
+ def visit_set(self, node):
+ self.check_for_concatenated_strings(node.elts, "set")
+
+ @check_messages("implicit-str-concat")
+ def visit_tuple(self, node):
+ self.check_for_concatenated_strings(node.elts, "tuple")
+
+ def visit_assign(self, node):
+ if isinstance(node.value, astroid.Const) and isinstance(node.value.value, str):
+ self.check_for_concatenated_strings([node.value], "assignment")
+
+ def check_for_consistent_string_delimiters(
+ self, tokens: Iterable[tokenize.TokenInfo]
+ ) -> None:
+ """Adds a message for each string using inconsistent quote delimiters.
+
+ Quote delimiters are used inconsistently if " and ' are mixed in a module's
+ shortstrings without having done so to avoid escaping an internal quote
+ character.
+
+ Args:
+ tokens: The tokens to be checked against for consistent usage.
+ """
+ # typing.Counter added in Python 3.6.1 so this type hint must be a comment
+ string_delimiters = collections.Counter() # type: Counter[str]
+
+ # First, figure out which quote character predominates in the module
+ for tok_type, token, _, _, _ in tokens:
+ if tok_type == tokenize.STRING and _is_quote_delimiter_chosen_freely(token):
+ string_delimiters[_get_quote_delimiter(token)] += 1
+
+ if len(string_delimiters) > 1:
+ # Ties are broken arbitrarily
+ most_common_delimiter = string_delimiters.most_common(1)[0][0]
+ for tok_type, token, start, _, _ in tokens:
+ if tok_type != tokenize.STRING:
+ continue
+ quote_delimiter = _get_quote_delimiter(token)
+ if (
+ _is_quote_delimiter_chosen_freely(token)
+ and quote_delimiter != most_common_delimiter
+ ):
+ self.add_message(
+ "inconsistent-quotes", line=start[0], args=(quote_delimiter,)
+ )
+
+ def check_for_concatenated_strings(self, elements, iterable_type):
+ for elt in elements:
+ if not (
+ isinstance(elt, astroid.Const) and elt.pytype() in _AST_NODE_STR_TYPES
+ ):
+ continue
+ if elt.col_offset < 0:
+ # This can happen in case of escaped newlines
+ continue
+ if (elt.lineno, elt.col_offset) not in self.string_tokens:
+ # This may happen with Latin1 encoding
+ # cf. https://github.com/PyCQA/pylint/issues/2610
+ continue
+ matching_token, next_token = self.string_tokens[
+ (elt.lineno, elt.col_offset)
+ ]
+ # We detect string concatenation: the AST Const is the
+ # combination of 2 string tokens
+ if matching_token != elt.value and next_token is not None:
+ if next_token.type == tokenize.STRING and (
+ next_token.start[0] == elt.lineno
+ or self.config.check_str_concat_over_line_jumps
+ ):
+ self.add_message(
+ "implicit-str-concat", line=elt.lineno, args=(iterable_type,)
+ )
+
+ def process_string_token(self, token, start_row, start_col):
+ quote_char = None
+ index = None
+ for index, char in enumerate(token):
+ if char in "'\"":
+ quote_char = char
+ break
+ if quote_char is None:
+ return
+
+ prefix = token[:index].lower() # markers like u, b, r.
+ after_prefix = token[index:]
+ # Chop off quotes
+ quote_length = (
+ 3 if after_prefix[:3] == after_prefix[-3:] == 3 * quote_char else 1
+ )
+ string_body = after_prefix[quote_length:-quote_length]
+ # No special checks on raw strings at the moment.
+ if "r" not in prefix:
+ self.process_non_raw_string_token(
+ prefix,
+ string_body,
+ start_row,
+ start_col + len(prefix) + quote_length,
+ )
+
+ def process_non_raw_string_token(
+ self, prefix, string_body, start_row, string_start_col
+ ):
+ """check for bad escapes in a non-raw string.
+
+ prefix: lowercase string of eg 'ur' string prefix markers.
+ string_body: the un-parsed body of the string, not including the quote
+ marks.
+ start_row: integer line number in the source.
+ string_start_col: integer col number of the string start in the source.
+ """
+ # Walk through the string; if we see a backslash then escape the next
+ # character, and skip over it. If we see a non-escaped character,
+ # alert, and continue.
+ #
+ # Accept a backslash when it escapes a backslash, or a quote, or
+ # end-of-line, or one of the letters that introduce a special escape
+ # sequence <https://docs.python.org/reference/lexical_analysis.html>
+ #
+ index = 0
+ while True:
+ index = string_body.find("\\", index)
+ if index == -1:
+ break
+ # There must be a next character; having a backslash at the end
+ # of the string would be a SyntaxError.
+ next_char = string_body[index + 1]
+ match = string_body[index : index + 2]
+ # The column offset will vary depending on whether the string token
+ # is broken across lines. Calculate relative to the nearest line
+ # break or relative to the start of the token's line.
+ last_newline = string_body.rfind("\n", 0, index)
+ if last_newline == -1:
+ line = start_row
+ col_offset = index + string_start_col
+ else:
+ line = start_row + string_body.count("\n", 0, index)
+ col_offset = index - last_newline - 1
+ if next_char in self.UNICODE_ESCAPE_CHARACTERS:
+ if "u" in prefix:
+ pass
+ elif "b" not in prefix:
+ pass # unicode by default
+ else:
+ self.add_message(
+ "anomalous-unicode-escape-in-string",
+ line=line,
+ args=(match,),
+ col_offset=col_offset,
+ )
+ elif next_char not in self.ESCAPE_CHARACTERS:
+ self.add_message(
+ "anomalous-backslash-in-string",
+ line=line,
+ args=(match,),
+ col_offset=col_offset,
+ )
+ # Whether it was a valid escape or not, backslash followed by
+ # another character can always be consumed whole: the second
+ # character can never be the start of a new backslash escape.
+ index += 2
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(StringFormatChecker(linter))
+ linter.register_checker(StringConstantChecker(linter))
+
+
+def str_eval(token):
+ """
+ Mostly replicate `ast.literal_eval(token)` manually to avoid any performance hit.
+ This supports f-strings, contrary to `ast.literal_eval`.
+ We have to support all string literal notations:
+ https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
+ """
+ if token[0:2].lower() in ("fr", "rf"):
+ token = token[2:]
+ elif token[0].lower() in ("r", "u", "f"):
+ token = token[1:]
+ if token[0:3] in ('"""', "'''"):
+ return token[3:-3]
+ return token[1:-1]
+
+
+def _is_long_string(string_token: str) -> bool:
+ """Is this string token a "longstring" (is it triple-quoted)?
+
+ Long strings are triple-quoted as defined in
+ https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
+
+ This function only checks characters up through the open quotes. Because it's meant
+ to be applied only to tokens that represent string literals, it doesn't bother to
+ check for close-quotes (demonstrating that the literal is a well-formed string).
+
+ Args:
+ string_token: The string token to be parsed.
+
+ Returns:
+ A boolean representing whether or not this token matches a longstring
+ regex.
+ """
+ return bool(
+ SINGLE_QUOTED_REGEX.match(string_token)
+ or DOUBLE_QUOTED_REGEX.match(string_token)
+ )
+
+
+def _get_quote_delimiter(string_token: str) -> str:
+ """Returns the quote character used to delimit this token string.
+
+ This function does little checking for whether the token is a well-formed
+ string.
+
+ Args:
+ string_token: The token to be parsed.
+
+ Returns:
+ A string containing solely the first quote delimiter character in the passed
+ string.
+
+ Raises:
+ ValueError: No quote delimiter characters are present.
+ """
+ match = QUOTE_DELIMITER_REGEX.match(string_token)
+ if not match:
+ raise ValueError("string token %s is not a well-formed string" % string_token)
+ return match.group(2)
+
+
+def _is_quote_delimiter_chosen_freely(string_token: str) -> bool:
+ """Was there a non-awkward option for the quote delimiter?
+
+ Args:
+ string_token: The quoted string whose delimiters are to be checked.
+
+ Returns:
+ Whether there was a choice in this token's quote character that would
+ not have involved backslash-escaping an interior quote character. Long
+ strings are excepted from this analysis under the assumption that their
+ quote characters are set by policy.
+ """
+ quote_delimiter = _get_quote_delimiter(string_token)
+ unchosen_delimiter = '"' if quote_delimiter == "'" else "'"
+ return bool(
+ quote_delimiter
+ and not _is_long_string(string_token)
+ and unchosen_delimiter not in str_eval(string_token)
+ )
diff --git a/pylint/checkers/typecheck.py b/pylint/checkers/typecheck.py
new file mode 100644
index 0000000..8ee88ff
--- /dev/null
+++ b/pylint/checkers/typecheck.py
@@ -0,0 +1,1975 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2009 James Lingard <jchl@aristanetworks.com>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 David Shea <dshea@redhat.com>
+# Copyright (c) 2014 Steven Myint <hg@stevenmyint.com>
+# Copyright (c) 2014 Holger Peters <email@holger-peters.de>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Anentropic <ego@anentropic.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Rene Zhang <rz99@cornell.edu>
+# Copyright (c) 2015 Radu Ciorba <radu@devrandom.ro>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016, 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2016 Jürgen Hermann <jh@web.de>
+# Copyright (c) 2016 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2016 Filipe Brandenburger <filbranden@google.com>
+# Copyright (c) 2017-2018, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018-2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2018 Pablo Galindo <Pablogsal@gmail.com>
+# Copyright (c) 2018 Jim Robertson <jrobertson98atx@gmail.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Ben Green <benhgreen@icloud.com>
+# Copyright (c) 2018 Konstantin <Github@pheanex.de>
+# Copyright (c) 2018 Justin Li <justinnhli@users.noreply.github.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Andy Palmer <25123779+ninezerozeronine@users.noreply.github.com>
+# Copyright (c) 2019 mattlbeck <17108752+mattlbeck@users.noreply.github.com>
+# Copyright (c) 2019 Martin Vielsmaier <martin.vielsmaier@gmail.com>
+# Copyright (c) 2019 Santiago Castro <bryant@montevideo.com.uy>
+# Copyright (c) 2019 yory8 <39745367+yory8@users.noreply.github.com>
+# Copyright (c) 2019 Federico Bond <federicobond@gmail.com>
+# Copyright (c) 2019 Pascal Corpet <pcorpet@users.noreply.github.com>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 Julien Palard <julien@palard.fr>
+# Copyright (c) 2020 Ram Rachum <ram@rachum.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2020 Anubhav <35621759+anubh-v@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@users.noreply.github.com>
+# Copyright (c) 2021 Andrew Haigh <nelfin@gmail.com>
+# Copyright (c) 2021 Jens H. Nielsen <Jens.Nielsen@microsoft.com>
+# Copyright (c) 2021 Ikraduya Edian <ikraduya@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""try to find more bugs in the code using astroid inference capabilities
+"""
+
+import builtins
+import fnmatch
+import heapq
+import itertools
+import operator
+import re
+import shlex
+import sys
+import types
+from collections import deque
+from collections.abc import Sequence
+from functools import singledispatch
+from typing import Pattern, Tuple
+
+import astroid
+
+from pylint.checkers import BaseChecker, utils
+from pylint.checkers.utils import (
+ check_messages,
+ decorated_with,
+ decorated_with_property,
+ has_known_bases,
+ is_builtin_object,
+ is_classdef_type,
+ is_comprehension,
+ is_inside_abstract_class,
+ is_iterable,
+ is_mapping,
+ is_overload_stub,
+ is_postponed_evaluation_enabled,
+ is_super,
+ node_ignores_exception,
+ safe_infer,
+ supports_delitem,
+ supports_getitem,
+ supports_membership_test,
+ supports_setitem,
+)
+from pylint.constants import PY310_PLUS
+from pylint.interfaces import INFERENCE, IAstroidChecker
+from pylint.utils import get_global_option
+
+BUILTINS = builtins.__name__
+STR_FORMAT = {"%s.str.format" % BUILTINS}
+ASYNCIO_COROUTINE = "asyncio.coroutines.coroutine"
+BUILTIN_TUPLE = "builtins.tuple"
+TYPE_ANNOTATION_NODES_TYPES = (
+ astroid.AnnAssign,
+ astroid.Arguments,
+ astroid.FunctionDef,
+)
+
+
+def _unflatten(iterable):
+ for index, elem in enumerate(iterable):
+ if isinstance(elem, Sequence) and not isinstance(elem, str):
+ yield from _unflatten(elem)
+ elif elem and not index:
+ # We're interested only in the first element.
+ yield elem
+
+
+def _flatten_container(iterable):
+ # Flatten nested containers into a single iterable
+ for item in iterable:
+ if isinstance(item, (list, tuple, types.GeneratorType)):
+ yield from _flatten_container(item)
+ else:
+ yield item
+
+
+def _is_owner_ignored(owner, attrname, ignored_classes, ignored_modules):
+ """Check if the given owner should be ignored
+
+ This will verify if the owner's module is in *ignored_modules*
+ or the owner's module fully qualified name is in *ignored_modules*
+ or if the *ignored_modules* contains a pattern which catches
+ the fully qualified name of the module.
+
+ Also, similar checks are done for the owner itself, if its name
+ matches any name from the *ignored_classes* or if its qualified
+ name can be found in *ignored_classes*.
+ """
+ ignored_modules = set(ignored_modules)
+ module_name = owner.root().name
+ module_qname = owner.root().qname()
+
+ for ignore in ignored_modules:
+ # Try to match the module name / fully qualified name directly
+ if module_qname in ignored_modules or module_name in ignored_modules:
+ return True
+
+ # Try to see if the ignores pattern match against the module name.
+ if fnmatch.fnmatch(module_qname, ignore):
+ return True
+
+ # Otherwise we might have a root module name being ignored,
+ # and the qualified owner has more levels of depth.
+ parts = deque(module_name.split("."))
+ current_module = ""
+
+ while parts:
+ part = parts.popleft()
+ if not current_module:
+ current_module = part
+ else:
+ current_module += f".{part}"
+ if current_module in ignored_modules:
+ return True
+
+ # Match against ignored classes.
+ ignored_classes = set(ignored_classes)
+ if hasattr(owner, "qname"):
+ qname = owner.qname()
+ else:
+ qname = ""
+ return any(ignore in (attrname, qname) for ignore in ignored_classes)
+
+
+@singledispatch
+def _node_names(node):
+ if not hasattr(node, "locals"):
+ return []
+ return node.locals.keys()
+
+
+@_node_names.register(astroid.ClassDef)
+@_node_names.register(astroid.Instance)
+def _(node):
+ values = itertools.chain(node.instance_attrs.keys(), node.locals.keys())
+
+ try:
+ mro = node.mro()[1:]
+ except (NotImplementedError, TypeError):
+ mro = node.ancestors()
+
+ other_values = [value for cls in mro for value in _node_names(cls)]
+ return itertools.chain(values, other_values)
+
+
+def _string_distance(seq1, seq2):
+ seq2_length = len(seq2)
+
+ row = list(range(1, seq2_length + 1)) + [0]
+ for seq1_index, seq1_char in enumerate(seq1):
+ last_row = row
+ row = [0] * seq2_length + [seq1_index + 1]
+
+ for seq2_index, seq2_char in enumerate(seq2):
+ row[seq2_index] = min(
+ last_row[seq2_index] + 1,
+ row[seq2_index - 1] + 1,
+ last_row[seq2_index - 1] + (seq1_char != seq2_char),
+ )
+
+ return row[seq2_length - 1]
+
+
+def _similar_names(owner, attrname, distance_threshold, max_choices):
+ """Given an owner and a name, try to find similar names
+
+ The similar names are searched given a distance metric and only
+ a given number of choices will be returned.
+ """
+ possible_names = []
+ names = _node_names(owner)
+
+ for name in names:
+ if name == attrname:
+ continue
+
+ distance = _string_distance(attrname, name)
+ if distance <= distance_threshold:
+ possible_names.append((name, distance))
+
+ # Now get back the values with a minimum, up to the given
+ # limit or choices.
+ picked = [
+ name
+ for (name, _) in heapq.nsmallest(
+ max_choices, possible_names, key=operator.itemgetter(1)
+ )
+ ]
+ return sorted(picked)
+
+
+def _missing_member_hint(owner, attrname, distance_threshold, max_choices):
+ names = _similar_names(owner, attrname, distance_threshold, max_choices)
+ if not names:
+ # No similar name.
+ return ""
+
+ names = [repr(name) for name in names]
+ if len(names) == 1:
+ names = ", ".join(names)
+ else:
+ names = "one of {} or {}".format(", ".join(names[:-1]), names[-1])
+
+ return f"; maybe {names}?"
+
+
+MSGS = {
+ "E1101": (
+ "%s %r has no %r member%s",
+ "no-member",
+ "Used when a variable is accessed for an unexistent member.",
+ {"old_names": [("E1103", "maybe-no-member")]},
+ ),
+ "I1101": (
+ "%s %r has no %r member%s, but source is unavailable. Consider "
+ "adding this module to extension-pkg-allow-list if you want "
+ "to perform analysis based on run-time introspection of living objects.",
+ "c-extension-no-member",
+ "Used when a variable is accessed for non-existent member of C "
+ "extension. Due to unavailability of source static analysis is impossible, "
+ "but it may be performed by introspecting living objects in run-time.",
+ ),
+ "E1102": (
+ "%s is not callable",
+ "not-callable",
+ "Used when an object being called has been inferred to a non "
+ "callable object.",
+ ),
+ "E1111": (
+ "Assigning result of a function call, where the function has no return",
+ "assignment-from-no-return",
+ "Used when an assignment is done on a function call but the "
+ "inferred function doesn't return anything.",
+ ),
+ "E1120": (
+ "No value for argument %s in %s call",
+ "no-value-for-parameter",
+ "Used when a function call passes too few arguments.",
+ ),
+ "E1121": (
+ "Too many positional arguments for %s call",
+ "too-many-function-args",
+ "Used when a function call passes too many positional arguments.",
+ ),
+ "E1123": (
+ "Unexpected keyword argument %r in %s call",
+ "unexpected-keyword-arg",
+ "Used when a function call passes a keyword argument that "
+ "doesn't correspond to one of the function's parameter names.",
+ ),
+ "E1124": (
+ "Argument %r passed by position and keyword in %s call",
+ "redundant-keyword-arg",
+ "Used when a function call would result in assigning multiple "
+ "values to a function parameter, one value from a positional "
+ "argument and one from a keyword argument.",
+ ),
+ "E1125": (
+ "Missing mandatory keyword argument %r in %s call",
+ "missing-kwoa",
+ (
+ "Used when a function call does not pass a mandatory"
+ " keyword-only argument."
+ ),
+ ),
+ "E1126": (
+ "Sequence index is not an int, slice, or instance with __index__",
+ "invalid-sequence-index",
+ "Used when a sequence type is indexed with an invalid type. "
+ "Valid types are ints, slices, and objects with an __index__ "
+ "method.",
+ ),
+ "E1127": (
+ "Slice index is not an int, None, or instance with __index__",
+ "invalid-slice-index",
+ "Used when a slice index is not an integer, None, or an object "
+ "with an __index__ method.",
+ ),
+ "E1128": (
+ "Assigning result of a function call, where the function returns None",
+ "assignment-from-none",
+ "Used when an assignment is done on a function call but the "
+ "inferred function returns nothing but None.",
+ {"old_names": [("W1111", "old-assignment-from-none")]},
+ ),
+ "E1129": (
+ "Context manager '%s' doesn't implement __enter__ and __exit__.",
+ "not-context-manager",
+ "Used when an instance in a with statement doesn't implement "
+ "the context manager protocol(__enter__/__exit__).",
+ ),
+ "E1130": (
+ "%s",
+ "invalid-unary-operand-type",
+ "Emitted when a unary operand is used on an object which does not "
+ "support this type of operation.",
+ ),
+ "E1131": (
+ "%s",
+ "unsupported-binary-operation",
+ "Emitted when a binary arithmetic operation between two "
+ "operands is not supported.",
+ ),
+ "E1132": (
+ "Got multiple values for keyword argument %r in function call",
+ "repeated-keyword",
+ "Emitted when a function call got multiple values for a keyword.",
+ ),
+ "E1135": (
+ "Value '%s' doesn't support membership test",
+ "unsupported-membership-test",
+ "Emitted when an instance in membership test expression doesn't "
+ "implement membership protocol (__contains__/__iter__/__getitem__).",
+ ),
+ "E1136": (
+ "Value '%s' is unsubscriptable",
+ "unsubscriptable-object",
+ "Emitted when a subscripted value doesn't support subscription "
+ "(i.e. doesn't define __getitem__ method or __class_getitem__ for a class).",
+ ),
+ "E1137": (
+ "%r does not support item assignment",
+ "unsupported-assignment-operation",
+ "Emitted when an object does not support item assignment "
+ "(i.e. doesn't define __setitem__ method).",
+ ),
+ "E1138": (
+ "%r does not support item deletion",
+ "unsupported-delete-operation",
+ "Emitted when an object does not support item deletion "
+ "(i.e. doesn't define __delitem__ method).",
+ ),
+ "E1139": (
+ "Invalid metaclass %r used",
+ "invalid-metaclass",
+ "Emitted whenever we can detect that a class is using, "
+ "as a metaclass, something which might be invalid for using as "
+ "a metaclass.",
+ ),
+ "E1140": (
+ "Dict key is unhashable",
+ "unhashable-dict-key",
+ "Emitted when a dict key is not hashable "
+ "(i.e. doesn't define __hash__ method).",
+ ),
+ "E1141": (
+ "Unpacking a dictionary in iteration without calling .items()",
+ "dict-iter-missing-items",
+ "Emitted when trying to iterate through a dict without calling .items()",
+ ),
+ "E1142": (
+ "'await' should be used within an async function",
+ "await-outside-async",
+ "Emitted when await is used outside an async function.",
+ ),
+ "W1113": (
+ "Keyword argument before variable positional arguments list "
+ "in the definition of %s function",
+ "keyword-arg-before-vararg",
+ "When defining a keyword argument before variable positional arguments, one can "
+ "end up in having multiple values passed for the aforementioned parameter in "
+ "case the method is called with keyword arguments.",
+ ),
+ "W1114": (
+ "Positional arguments appear to be out of order",
+ "arguments-out-of-order",
+ "Emitted when the caller's argument names fully match the parameter "
+ "names in the function signature but do not have the same order.",
+ ),
+ "W1115": (
+ "Non-string value assigned to __name__",
+ "non-str-assignment-to-dunder-name",
+ "Emitted when a non-string vaue is assigned to __name__",
+ ),
+ "W1116": (
+ "Second argument of isinstance is not a type",
+ "isinstance-second-argument-not-valid-type",
+ "Emitted when the second argument of an isinstance call is not a type.",
+ ),
+}
+
+# builtin sequence types in Python 2 and 3.
+SEQUENCE_TYPES = {
+ "str",
+ "unicode",
+ "list",
+ "tuple",
+ "bytearray",
+ "xrange",
+ "range",
+ "bytes",
+ "memoryview",
+}
+
+
+def _emit_no_member(node, owner, owner_name, ignored_mixins=True, ignored_none=True):
+ """Try to see if no-member should be emitted for the given owner.
+
+ The following cases are ignored:
+
+ * the owner is a function and it has decorators.
+ * the owner is an instance and it has __getattr__, __getattribute__ implemented
+ * the module is explicitly ignored from no-member checks
+ * the owner is a class and the name can be found in its metaclass.
+ * The access node is protected by an except handler, which handles
+ AttributeError, Exception or bare except.
+ """
+ # pylint: disable=too-many-return-statements
+ if node_ignores_exception(node, AttributeError):
+ return False
+ if ignored_none and isinstance(owner, astroid.Const) and owner.value is None:
+ return False
+ if is_super(owner) or getattr(owner, "type", None) == "metaclass":
+ return False
+ if owner_name and ignored_mixins and owner_name[-5:].lower() == "mixin":
+ return False
+ if isinstance(owner, astroid.FunctionDef) and (
+ owner.decorators or owner.is_abstract()
+ ):
+ return False
+ if isinstance(owner, (astroid.Instance, astroid.ClassDef)):
+ if owner.has_dynamic_getattr():
+ # Issue #2565: Don't ignore enums, as they have a `__getattr__` but it's not
+ # invoked at this point.
+ try:
+ metaclass = owner.metaclass()
+ except astroid.MroError:
+ return False
+ if metaclass:
+ # Renamed in Python 3.10 to `EnumType`
+ return metaclass.qname() in ("enum.EnumMeta", "enum.EnumType")
+ return False
+ if not has_known_bases(owner):
+ return False
+
+ # Exclude typed annotations, since these might actually exist
+ # at some point during the runtime of the program.
+ if utils.is_attribute_typed_annotation(owner, node.attrname):
+ return False
+ if isinstance(owner, astroid.objects.Super):
+ # Verify if we are dealing with an invalid Super object.
+ # If it is invalid, then there's no point in checking that
+ # it has the required attribute. Also, don't fail if the
+ # MRO is invalid.
+ try:
+ owner.super_mro()
+ except (astroid.MroError, astroid.SuperError):
+ return False
+ if not all(has_known_bases(base) for base in owner.type.mro()):
+ return False
+ if isinstance(owner, astroid.Module):
+ try:
+ owner.getattr("__getattr__")
+ return False
+ except astroid.NotFoundError:
+ pass
+ if owner_name and node.attrname.startswith("_" + owner_name):
+ # Test if an attribute has been mangled ('private' attribute)
+ unmangled_name = node.attrname.split("_" + owner_name)[-1]
+ try:
+ if owner.getattr(unmangled_name, context=None) is not None:
+ return False
+ except astroid.NotFoundError:
+ return True
+ if (
+ owner.parent
+ and isinstance(owner.parent, astroid.ClassDef)
+ and owner.parent.name == "EnumMeta"
+ and owner_name == "__members__"
+ and node.attrname in ["items", "values", "keys"]
+ ):
+ # Avoid false positive on Enum.__members__.{items(), values, keys}
+ # See https://github.com/PyCQA/pylint/issues/4123
+ return False
+
+ return True
+
+
+def _determine_callable(callable_obj):
+ # Ordering is important, since BoundMethod is a subclass of UnboundMethod,
+ # and Function inherits Lambda.
+ parameters = 0
+ if hasattr(callable_obj, "implicit_parameters"):
+ parameters = callable_obj.implicit_parameters()
+ if isinstance(callable_obj, astroid.BoundMethod):
+ # Bound methods have an extra implicit 'self' argument.
+ return callable_obj, parameters, callable_obj.type
+ if isinstance(callable_obj, astroid.UnboundMethod):
+ return callable_obj, parameters, "unbound method"
+ if isinstance(callable_obj, astroid.FunctionDef):
+ return callable_obj, parameters, callable_obj.type
+ if isinstance(callable_obj, astroid.Lambda):
+ return callable_obj, parameters, "lambda"
+ if isinstance(callable_obj, astroid.ClassDef):
+ # Class instantiation, lookup __new__ instead.
+ # If we only find object.__new__, we can safely check __init__
+ # instead. If __new__ belongs to builtins, then we look
+ # again for __init__ in the locals, since we won't have
+ # argument information for the builtin __new__ function.
+ try:
+ # Use the last definition of __new__.
+ new = callable_obj.local_attr("__new__")[-1]
+ except astroid.NotFoundError:
+ new = None
+
+ from_object = new and new.parent.scope().name == "object"
+ from_builtins = new and new.root().name in sys.builtin_module_names
+
+ if not new or from_object or from_builtins:
+ try:
+ # Use the last definition of __init__.
+ callable_obj = callable_obj.local_attr("__init__")[-1]
+ except astroid.NotFoundError as e:
+ # do nothing, covered by no-init.
+ raise ValueError from e
+ else:
+ callable_obj = new
+
+ if not isinstance(callable_obj, astroid.FunctionDef):
+ raise ValueError
+ # both have an extra implicit 'cls'/'self' argument.
+ return callable_obj, parameters, "constructor"
+
+ raise ValueError
+
+
+def _has_parent_of_type(node, node_type, statement):
+ """Check if the given node has a parent of the given type."""
+ parent = node.parent
+ while not isinstance(parent, node_type) and statement.parent_of(parent):
+ parent = parent.parent
+ return isinstance(parent, node_type)
+
+
+def _no_context_variadic_keywords(node, scope):
+ statement = node.statement()
+ variadics = ()
+
+ if isinstance(scope, astroid.Lambda) and not isinstance(scope, astroid.FunctionDef):
+ variadics = list(node.keywords or []) + node.kwargs
+ elif isinstance(
+ statement, (astroid.Return, astroid.Expr, astroid.Assign)
+ ) and isinstance(statement.value, astroid.Call):
+ call = statement.value
+ variadics = list(call.keywords or []) + call.kwargs
+
+ return _no_context_variadic(node, scope.args.kwarg, astroid.Keyword, variadics)
+
+
+def _no_context_variadic_positional(node, scope):
+ variadics = ()
+ if isinstance(scope, astroid.Lambda) and not isinstance(scope, astroid.FunctionDef):
+ variadics = node.starargs + node.kwargs
+ else:
+ statement = node.statement()
+ if isinstance(
+ statement, (astroid.Expr, astroid.Return, astroid.Assign)
+ ) and isinstance(statement.value, astroid.Call):
+ call = statement.value
+ variadics = call.starargs + call.kwargs
+
+ return _no_context_variadic(node, scope.args.vararg, astroid.Starred, variadics)
+
+
+def _no_context_variadic(node, variadic_name, variadic_type, variadics):
+ """Verify if the given call node has variadic nodes without context
+
+ This is a workaround for handling cases of nested call functions
+ which don't have the specific call context at hand.
+ Variadic arguments (variable positional arguments and variable
+ keyword arguments) are inferred, inherently wrong, by astroid
+ as a Tuple, respectively a Dict with empty elements.
+ This can lead pylint to believe that a function call receives
+ too few arguments.
+ """
+ scope = node.scope()
+ is_in_lambda_scope = not isinstance(scope, astroid.FunctionDef) and isinstance(
+ scope, astroid.Lambda
+ )
+ statement = node.statement()
+ for name in statement.nodes_of_class(astroid.Name):
+ if name.name != variadic_name:
+ continue
+
+ inferred = safe_infer(name)
+ if isinstance(inferred, (astroid.List, astroid.Tuple)):
+ length = len(inferred.elts)
+ elif isinstance(inferred, astroid.Dict):
+ length = len(inferred.items)
+ else:
+ continue
+
+ if is_in_lambda_scope and isinstance(inferred.parent, astroid.Arguments):
+ # The statement of the variadic will be the assignment itself,
+ # so we need to go the lambda instead
+ inferred_statement = inferred.parent.parent
+ else:
+ inferred_statement = inferred.statement()
+
+ if not length and isinstance(inferred_statement, astroid.Lambda):
+ is_in_starred_context = _has_parent_of_type(node, variadic_type, statement)
+ used_as_starred_argument = any(
+ variadic.value == name or variadic.value.parent_of(name)
+ for variadic in variadics
+ )
+ if is_in_starred_context or used_as_starred_argument:
+ return True
+ return False
+
+
+def _is_invalid_metaclass(metaclass):
+ try:
+ mro = metaclass.mro()
+ except NotImplementedError:
+ # Cannot have a metaclass which is not a newstyle class.
+ return True
+ else:
+ if not any(is_builtin_object(cls) and cls.name == "type" for cls in mro):
+ return True
+ return False
+
+
+def _infer_from_metaclass_constructor(cls, func):
+ """Try to infer what the given *func* constructor is building
+
+ :param astroid.FunctionDef func:
+ A metaclass constructor. Metaclass definitions can be
+ functions, which should accept three arguments, the name of
+ the class, the bases of the class and the attributes.
+ The function could return anything, but usually it should
+ be a proper metaclass.
+ :param astroid.ClassDef cls:
+ The class for which the *func* parameter should generate
+ a metaclass.
+ :returns:
+ The class generated by the function or None,
+ if we couldn't infer it.
+ :rtype: astroid.ClassDef
+ """
+ context = astroid.context.InferenceContext()
+
+ class_bases = astroid.List()
+ class_bases.postinit(elts=cls.bases)
+
+ attrs = astroid.Dict()
+ local_names = [(name, values[-1]) for name, values in cls.locals.items()]
+ attrs.postinit(local_names)
+
+ builder_args = astroid.Tuple()
+ builder_args.postinit([cls.name, class_bases, attrs])
+
+ context.callcontext = astroid.context.CallContext(builder_args)
+ try:
+ inferred = next(func.infer_call_result(func, context), None)
+ except astroid.InferenceError:
+ return None
+ return inferred or None
+
+
+def _is_c_extension(module_node):
+ return (
+ not astroid.modutils.is_standard_module(module_node.name)
+ and not module_node.fully_defined()
+ )
+
+
+def _is_invalid_isinstance_type(arg):
+ # Return True if we are sure that arg is not a type
+ inferred = utils.safe_infer(arg)
+ if not inferred:
+ # Cannot infer it so skip it.
+ return False
+ if isinstance(inferred, astroid.Tuple):
+ return any(_is_invalid_isinstance_type(elt) for elt in inferred.elts)
+ if isinstance(inferred, astroid.ClassDef):
+ return False
+ if isinstance(inferred, astroid.Instance) and inferred.qname() == BUILTIN_TUPLE:
+ return False
+ return True
+
+
+class TypeChecker(BaseChecker):
+ """try to find bugs in the code using type inference"""
+
+ __implements__ = (IAstroidChecker,)
+
+ # configuration section name
+ name = "typecheck"
+ # messages
+ msgs = MSGS
+ priority = -1
+ # configuration options
+ options = (
+ (
+ "ignore-on-opaque-inference",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "This flag controls whether pylint should warn about "
+ "no-member and similar checks whenever an opaque object "
+ "is returned when inferring. The inference can return "
+ "multiple potential results while evaluating a Python object, "
+ "but some branches might not be evaluated, which results in "
+ "partial inference. In that case, it might be useful to still emit "
+ "no-member and other checks for the rest of the inferred objects.",
+ },
+ ),
+ (
+ "ignore-mixin-members",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": 'Tells whether missing members accessed in mixin \
+class should be ignored. A mixin class is detected if its name ends with \
+"mixin" (case insensitive).',
+ },
+ ),
+ (
+ "ignore-none",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "Tells whether to warn about missing members when the owner "
+ "of the attribute is inferred to be None.",
+ },
+ ),
+ (
+ "ignored-modules",
+ {
+ "default": (),
+ "type": "csv",
+ "metavar": "<module names>",
+ "help": "List of module names for which member attributes "
+ "should not be checked (useful for modules/projects "
+ "where namespaces are manipulated during runtime and "
+ "thus existing member attributes cannot be "
+ "deduced by static analysis). It supports qualified "
+ "module names, as well as Unix pattern matching.",
+ },
+ ),
+ # the defaults here are *stdlib* names that (almost) always
+ # lead to false positives, since their idiomatic use is
+ # 'too dynamic' for pylint to grok.
+ (
+ "ignored-classes",
+ {
+ "default": ("optparse.Values", "thread._local", "_thread._local"),
+ "type": "csv",
+ "metavar": "<members names>",
+ "help": "List of class names for which member attributes "
+ "should not be checked (useful for classes with "
+ "dynamically set attributes). This supports "
+ "the use of qualified names.",
+ },
+ ),
+ (
+ "generated-members",
+ {
+ "default": (),
+ "type": "string",
+ "metavar": "<members names>",
+ "help": "List of members which are set dynamically and \
+missed by pylint inference system, and so shouldn't trigger E1101 when \
+accessed. Python regular expressions are accepted.",
+ },
+ ),
+ (
+ "contextmanager-decorators",
+ {
+ "default": ["contextlib.contextmanager"],
+ "type": "csv",
+ "metavar": "<decorator names>",
+ "help": "List of decorators that produce context managers, "
+ "such as contextlib.contextmanager. Add to this list "
+ "to register other decorators that produce valid "
+ "context managers.",
+ },
+ ),
+ (
+ "missing-member-hint-distance",
+ {
+ "default": 1,
+ "type": "int",
+ "metavar": "<member hint edit distance>",
+ "help": "The minimum edit distance a name should have in order "
+ "to be considered a similar match for a missing member name.",
+ },
+ ),
+ (
+ "missing-member-max-choices",
+ {
+ "default": 1,
+ "type": "int",
+ "metavar": "<member hint max choices>",
+ "help": "The total number of similar names that should be taken in "
+ "consideration when showing a hint for a missing member.",
+ },
+ ),
+ (
+ "missing-member-hint",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<missing member hint>",
+ "help": "Show a hint with possible names when a member name was not "
+ "found. The aspect of finding the hint is based on edit distance.",
+ },
+ ),
+ (
+ "signature-mutators",
+ {
+ "default": [],
+ "type": "csv",
+ "metavar": "<decorator names>",
+ "help": "List of decorators that change the signature of "
+ "a decorated function.",
+ },
+ ),
+ )
+
+ @astroid.decorators.cachedproperty
+ def _suggestion_mode(self):
+ return get_global_option(self, "suggestion-mode", default=True)
+
+ @astroid.decorators.cachedproperty
+ def _compiled_generated_members(self) -> Tuple[Pattern, ...]:
+ # do this lazily since config not fully initialized in __init__
+ # generated_members may contain regular expressions
+ # (surrounded by quote `"` and followed by a comma `,`)
+ # REQUEST,aq_parent,"[a-zA-Z]+_set{1,2}"' =>
+ # ('REQUEST', 'aq_parent', '[a-zA-Z]+_set{1,2}')
+ generated_members = self.config.generated_members
+ if isinstance(generated_members, str):
+ gen = shlex.shlex(generated_members)
+ gen.whitespace += ","
+ gen.wordchars += r"[]-+\.*?()|"
+ generated_members = tuple(tok.strip('"') for tok in gen)
+ return tuple(re.compile(exp) for exp in generated_members)
+
+ @check_messages("keyword-arg-before-vararg")
+ def visit_functiondef(self, node):
+ # check for keyword arg before varargs
+ if node.args.vararg and node.args.defaults:
+ self.add_message("keyword-arg-before-vararg", node=node, args=(node.name))
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ @check_messages("invalid-metaclass")
+ def visit_classdef(self, node):
+ def _metaclass_name(metaclass):
+ if isinstance(metaclass, (astroid.ClassDef, astroid.FunctionDef)):
+ return metaclass.name
+ return metaclass.as_string()
+
+ metaclass = node.declared_metaclass()
+ if not metaclass:
+ return
+
+ if isinstance(metaclass, astroid.FunctionDef):
+ # Try to infer the result.
+ metaclass = _infer_from_metaclass_constructor(node, metaclass)
+ if not metaclass:
+ # Don't do anything if we cannot infer the result.
+ return
+
+ if isinstance(metaclass, astroid.ClassDef):
+ if _is_invalid_metaclass(metaclass):
+ self.add_message(
+ "invalid-metaclass", node=node, args=(_metaclass_name(metaclass),)
+ )
+ else:
+ self.add_message(
+ "invalid-metaclass", node=node, args=(_metaclass_name(metaclass),)
+ )
+
+ def visit_assignattr(self, node):
+ if isinstance(node.assign_type(), astroid.AugAssign):
+ self.visit_attribute(node)
+
+ def visit_delattr(self, node):
+ self.visit_attribute(node)
+
+ @check_messages("no-member", "c-extension-no-member")
+ def visit_attribute(self, node):
+ """check that the accessed attribute exists
+
+ to avoid too much false positives for now, we'll consider the code as
+ correct if a single of the inferred nodes has the accessed attribute.
+
+ function/method, super call and metaclasses are ignored
+ """
+ if any(
+ pattern.match(name)
+ for name in (node.attrname, node.as_string())
+ for pattern in self._compiled_generated_members
+ ):
+ return
+
+ try:
+ inferred = list(node.expr.infer())
+ except astroid.InferenceError:
+ return
+
+ # list of (node, nodename) which are missing the attribute
+ missingattr = set()
+
+ non_opaque_inference_results = [
+ owner
+ for owner in inferred
+ if owner is not astroid.Uninferable
+ and not isinstance(owner, astroid.nodes.Unknown)
+ ]
+ if (
+ len(non_opaque_inference_results) != len(inferred)
+ and self.config.ignore_on_opaque_inference
+ ):
+ # There is an ambiguity in the inference. Since we can't
+ # make sure that we won't emit a false positive, we just stop
+ # whenever the inference returns an opaque inference object.
+ return
+ for owner in non_opaque_inference_results:
+ name = getattr(owner, "name", None)
+ if _is_owner_ignored(
+ owner, name, self.config.ignored_classes, self.config.ignored_modules
+ ):
+ continue
+
+ qualname = f"{owner.pytype()}.{node.attrname}"
+ if any(
+ pattern.match(qualname) for pattern in self._compiled_generated_members
+ ):
+ return
+
+ try:
+ if not [
+ n
+ for n in owner.getattr(node.attrname)
+ if not isinstance(n.statement(), astroid.AugAssign)
+ ]:
+ missingattr.add((owner, name))
+ continue
+ except AttributeError:
+ continue
+ except astroid.DuplicateBasesError:
+ continue
+ except astroid.NotFoundError:
+ # This can't be moved before the actual .getattr call,
+ # because there can be more values inferred and we are
+ # stopping after the first one which has the attribute in question.
+ # The problem is that if the first one has the attribute,
+ # but we continue to the next values which doesn't have the
+ # attribute, then we'll have a false positive.
+ # So call this only after the call has been made.
+ if not _emit_no_member(
+ node,
+ owner,
+ name,
+ ignored_mixins=self.config.ignore_mixin_members,
+ ignored_none=self.config.ignore_none,
+ ):
+ continue
+ missingattr.add((owner, name))
+ continue
+ # stop on the first found
+ break
+ else:
+ # we have not found any node with the attributes, display the
+ # message for inferred nodes
+ done = set()
+ for owner, name in missingattr:
+ if isinstance(owner, astroid.Instance):
+ actual = owner._proxied
+ else:
+ actual = owner
+ if actual in done:
+ continue
+ done.add(actual)
+
+ msg, hint = self._get_nomember_msgid_hint(node, owner)
+ self.add_message(
+ msg,
+ node=node,
+ args=(owner.display_type(), name, node.attrname, hint),
+ confidence=INFERENCE,
+ )
+
+ def _get_nomember_msgid_hint(self, node, owner):
+ suggestions_are_possible = self._suggestion_mode and isinstance(
+ owner, astroid.Module
+ )
+ if suggestions_are_possible and _is_c_extension(owner):
+ msg = "c-extension-no-member"
+ hint = ""
+ else:
+ msg = "no-member"
+ if self.config.missing_member_hint:
+ hint = _missing_member_hint(
+ owner,
+ node.attrname,
+ self.config.missing_member_hint_distance,
+ self.config.missing_member_max_choices,
+ )
+ else:
+ hint = ""
+ return msg, hint
+
+ @check_messages(
+ "assignment-from-no-return",
+ "assignment-from-none",
+ "non-str-assignment-to-dunder-name",
+ )
+ def visit_assign(self, node):
+ """
+ Process assignments in the AST.
+ """
+
+ self._check_assignment_from_function_call(node)
+ self._check_dundername_is_string(node)
+
+ def _check_assignment_from_function_call(self, node):
+ """check that if assigning to a function call, the function is
+ possibly returning something valuable
+ """
+ if not isinstance(node.value, astroid.Call):
+ return
+
+ function_node = safe_infer(node.value.func)
+ funcs = (astroid.FunctionDef, astroid.UnboundMethod, astroid.BoundMethod)
+ if not isinstance(function_node, funcs):
+ return
+
+ # Unwrap to get the actual function object
+ if isinstance(function_node, astroid.BoundMethod) and isinstance(
+ function_node._proxied, astroid.UnboundMethod
+ ):
+ function_node = function_node._proxied._proxied
+
+ # Make sure that it's a valid function that we can analyze.
+ # Ordered from less expensive to more expensive checks.
+ # pylint: disable=too-many-boolean-expressions
+ if (
+ not function_node.is_function
+ or isinstance(function_node, astroid.AsyncFunctionDef)
+ or function_node.decorators
+ or function_node.is_generator()
+ or function_node.is_abstract(pass_is_abstract=False)
+ or utils.is_error(function_node)
+ or not function_node.root().fully_defined()
+ ):
+ return
+
+ returns = list(
+ function_node.nodes_of_class(astroid.Return, skip_klass=astroid.FunctionDef)
+ )
+ if not returns:
+ self.add_message("assignment-from-no-return", node=node)
+ else:
+ for rnode in returns:
+ if not (
+ isinstance(rnode.value, astroid.Const)
+ and rnode.value.value is None
+ or rnode.value is None
+ ):
+ break
+ else:
+ self.add_message("assignment-from-none", node=node)
+
+ def _check_dundername_is_string(self, node):
+ """
+ Check a string is assigned to self.__name__
+ """
+
+ # Check the left hand side of the assignment is <something>.__name__
+ lhs = node.targets[0]
+ if not isinstance(lhs, astroid.node_classes.AssignAttr):
+ return
+ if not lhs.attrname == "__name__":
+ return
+
+ # If the right hand side is not a string
+ rhs = node.value
+ if isinstance(rhs, astroid.Const) and isinstance(rhs.value, str):
+ return
+ inferred = utils.safe_infer(rhs)
+ if not inferred:
+ return
+ if not (
+ isinstance(inferred, astroid.Const) and isinstance(inferred.value, str)
+ ):
+ # Add the message
+ self.add_message("non-str-assignment-to-dunder-name", node=node)
+
+ def _check_uninferable_call(self, node):
+ """
+ Check that the given uninferable Call node does not
+ call an actual function.
+ """
+ if not isinstance(node.func, astroid.Attribute):
+ return
+
+ # Look for properties. First, obtain
+ # the lhs of the Attribute node and search the attribute
+ # there. If that attribute is a property or a subclass of properties,
+ # then most likely it's not callable.
+
+ expr = node.func.expr
+ klass = safe_infer(expr)
+ if (
+ klass is None
+ or klass is astroid.Uninferable
+ or not isinstance(klass, astroid.Instance)
+ ):
+ return
+
+ try:
+ attrs = klass._proxied.getattr(node.func.attrname)
+ except astroid.NotFoundError:
+ return
+
+ for attr in attrs:
+ if attr is astroid.Uninferable:
+ continue
+ if not isinstance(attr, astroid.FunctionDef):
+ continue
+
+ # Decorated, see if it is decorated with a property.
+ # Also, check the returns and see if they are callable.
+ if decorated_with_property(attr):
+
+ try:
+ all_returns_are_callable = all(
+ return_node.callable() or return_node is astroid.Uninferable
+ for return_node in attr.infer_call_result(node)
+ )
+ except astroid.InferenceError:
+ continue
+
+ if not all_returns_are_callable:
+ self.add_message(
+ "not-callable", node=node, args=node.func.as_string()
+ )
+ break
+
+ def _check_argument_order(self, node, call_site, called, called_param_names):
+ """Match the supplied argument names against the function parameters.
+ Warn if some argument names are not in the same order as they are in
+ the function signature.
+ """
+ # Check for called function being an object instance function
+ # If so, ignore the initial 'self' argument in the signature
+ try:
+ is_classdef = isinstance(called.parent, astroid.scoped_nodes.ClassDef)
+ if is_classdef and called_param_names[0] == "self":
+ called_param_names = called_param_names[1:]
+ except IndexError:
+ return
+
+ try:
+ # extract argument names, if they have names
+ calling_parg_names = [p.name for p in call_site.positional_arguments]
+
+ # Additionally get names of keyword arguments to use in a full match
+ # against parameters
+ calling_kwarg_names = [
+ arg.name for arg in call_site.keyword_arguments.values()
+ ]
+ except AttributeError:
+ # the type of arg does not provide a `.name`. In this case we
+ # stop checking for out-of-order arguments because it is only relevant
+ # for named variables.
+ return
+
+ # Don't check for ordering if there is an unmatched arg or param
+ arg_set = set(calling_parg_names) | set(calling_kwarg_names)
+ param_set = set(called_param_names)
+ if arg_set != param_set:
+ return
+
+ # Warn based on the equality of argument ordering
+ if calling_parg_names != called_param_names[: len(calling_parg_names)]:
+ self.add_message("arguments-out-of-order", node=node, args=())
+
+ def _check_isinstance_args(self, node):
+ if len(node.args) != 2:
+ # isinstance called with wrong number of args
+ return
+
+ second_arg = node.args[1]
+ if _is_invalid_isinstance_type(second_arg):
+ self.add_message("isinstance-second-argument-not-valid-type", node=node)
+
+ # pylint: disable=too-many-branches,too-many-locals
+ @check_messages(*(list(MSGS.keys())))
+ def visit_call(self, node):
+ """check that called functions/methods are inferred to callable objects,
+ and that the arguments passed to the function match the parameters in
+ the inferred function's definition
+ """
+ called = safe_infer(node.func)
+ # only function, generator and object defining __call__ are allowed
+ # Ignore instances of descriptors since astroid cannot properly handle them
+ # yet
+ if called and not called.callable():
+ if isinstance(called, astroid.Instance) and (
+ not has_known_bases(called)
+ or (
+ called.parent is not None
+ and isinstance(called.scope(), astroid.ClassDef)
+ and "__get__" in called.locals
+ )
+ ):
+ # Don't emit if we can't make sure this object is callable.
+ pass
+ else:
+ self.add_message("not-callable", node=node, args=node.func.as_string())
+
+ self._check_uninferable_call(node)
+ try:
+ called, implicit_args, callable_name = _determine_callable(called)
+ except ValueError:
+ # Any error occurred during determining the function type, most of
+ # those errors are handled by different warnings.
+ return
+
+ if called.args.args is None:
+ if called.name == "isinstance":
+ # Verify whether second argument of isinstance is a valid type
+ self._check_isinstance_args(node)
+ # Built-in functions have no argument information.
+ return
+
+ if len(called.argnames()) != len(set(called.argnames())):
+ # Duplicate parameter name (see duplicate-argument). We can't really
+ # make sense of the function call in this case, so just return.
+ return
+
+ # Build the set of keyword arguments, checking for duplicate keywords,
+ # and count the positional arguments.
+ call_site = astroid.arguments.CallSite.from_call(node)
+
+ # Warn about duplicated keyword arguments, such as `f=24, **{'f': 24}`
+ for keyword in call_site.duplicated_keywords:
+ self.add_message("repeated-keyword", node=node, args=(keyword,))
+
+ if call_site.has_invalid_arguments() or call_site.has_invalid_keywords():
+ # Can't make sense of this.
+ return
+
+ # Has the function signature changed in ways we cannot reliably detect?
+ if hasattr(called, "decorators") and decorated_with(
+ called, self.config.signature_mutators
+ ):
+ return
+
+ num_positional_args = len(call_site.positional_arguments)
+ keyword_args = list(call_site.keyword_arguments.keys())
+ overload_function = is_overload_stub(called)
+
+ # Determine if we don't have a context for our call and we use variadics.
+ node_scope = node.scope()
+ if isinstance(node_scope, (astroid.Lambda, astroid.FunctionDef)):
+ has_no_context_positional_variadic = _no_context_variadic_positional(
+ node, node_scope
+ )
+ has_no_context_keywords_variadic = _no_context_variadic_keywords(
+ node, node_scope
+ )
+ else:
+ has_no_context_positional_variadic = (
+ has_no_context_keywords_variadic
+ ) = False
+
+ # These are coming from the functools.partial implementation in astroid
+ already_filled_positionals = getattr(called, "filled_positionals", 0)
+ already_filled_keywords = getattr(called, "filled_keywords", {})
+
+ keyword_args += list(already_filled_keywords)
+ num_positional_args += implicit_args + already_filled_positionals
+
+ # Analyze the list of formal parameters.
+ args = list(itertools.chain(called.args.posonlyargs or (), called.args.args))
+ num_mandatory_parameters = len(args) - len(called.args.defaults)
+ parameters = []
+ parameter_name_to_index = {}
+ for i, arg in enumerate(args):
+ if isinstance(arg, astroid.Tuple):
+ name = None
+ # Don't store any parameter names within the tuple, since those
+ # are not assignable from keyword arguments.
+ else:
+ assert isinstance(arg, astroid.AssignName)
+ # This occurs with:
+ # def f( (a), (b) ): pass
+ name = arg.name
+ parameter_name_to_index[name] = i
+ if i >= num_mandatory_parameters:
+ defval = called.args.defaults[i - num_mandatory_parameters]
+ else:
+ defval = None
+ parameters.append([(name, defval), False])
+
+ kwparams = {}
+ for i, arg in enumerate(called.args.kwonlyargs):
+ if isinstance(arg, astroid.Keyword):
+ name = arg.arg
+ else:
+ assert isinstance(arg, astroid.AssignName)
+ name = arg.name
+ kwparams[name] = [called.args.kw_defaults[i], False]
+
+ self._check_argument_order(
+ node, call_site, called, [p[0][0] for p in parameters]
+ )
+
+ # 1. Match the positional arguments.
+ for i in range(num_positional_args):
+ if i < len(parameters):
+ parameters[i][1] = True
+ elif called.args.vararg is not None:
+ # The remaining positional arguments get assigned to the *args
+ # parameter.
+ break
+ elif not overload_function:
+ # Too many positional arguments.
+ self.add_message(
+ "too-many-function-args", node=node, args=(callable_name,)
+ )
+ break
+
+ # 2. Match the keyword arguments.
+ for keyword in keyword_args:
+ if keyword in parameter_name_to_index:
+ i = parameter_name_to_index[keyword]
+ if parameters[i][1]:
+ # Duplicate definition of function parameter.
+
+ # Might be too hardcoded, but this can actually
+ # happen when using str.format and `self` is passed
+ # by keyword argument, as in `.format(self=self)`.
+ # It's perfectly valid to so, so we're just skipping
+ # it if that's the case.
+ if not (keyword == "self" and called.qname() in STR_FORMAT):
+ self.add_message(
+ "redundant-keyword-arg",
+ node=node,
+ args=(keyword, callable_name),
+ )
+ else:
+ parameters[i][1] = True
+ elif keyword in kwparams:
+ if kwparams[keyword][1]:
+ # Duplicate definition of function parameter.
+ self.add_message(
+ "redundant-keyword-arg",
+ node=node,
+ args=(keyword, callable_name),
+ )
+ else:
+ kwparams[keyword][1] = True
+ elif called.args.kwarg is not None:
+ # The keyword argument gets assigned to the **kwargs parameter.
+ pass
+ elif not overload_function:
+ # Unexpected keyword argument.
+ self.add_message(
+ "unexpected-keyword-arg", node=node, args=(keyword, callable_name)
+ )
+
+ # 3. Match the **kwargs, if any.
+ if node.kwargs:
+ for i, [(name, defval), assigned] in enumerate(parameters):
+ # Assume that *kwargs provides values for all remaining
+ # unassigned named parameters.
+ if name is not None:
+ parameters[i][1] = True
+ else:
+ # **kwargs can't assign to tuples.
+ pass
+
+ # Check that any parameters without a default have been assigned
+ # values.
+ for [(name, defval), assigned] in parameters:
+ if (defval is None) and not assigned:
+ if name is None:
+ display_name = "<tuple>"
+ else:
+ display_name = repr(name)
+ if not has_no_context_positional_variadic and not overload_function:
+ self.add_message(
+ "no-value-for-parameter",
+ node=node,
+ args=(display_name, callable_name),
+ )
+
+ for name, val in kwparams.items():
+ defval, assigned = val
+ if (
+ defval is None
+ and not assigned
+ and not has_no_context_keywords_variadic
+ and not overload_function
+ ):
+ self.add_message("missing-kwoa", node=node, args=(name, callable_name))
+
+ def _check_invalid_sequence_index(self, subscript: astroid.Subscript):
+ # Look for index operations where the parent is a sequence type.
+ # If the types can be determined, only allow indices to be int,
+ # slice or instances with __index__.
+ parent_type = safe_infer(subscript.value)
+ if not isinstance(
+ parent_type, (astroid.ClassDef, astroid.Instance)
+ ) or not has_known_bases(parent_type):
+ return None
+
+ # Determine what method on the parent this index will use
+ # The parent of this node will be a Subscript, and the parent of that
+ # node determines if the Subscript is a get, set, or delete operation.
+ if subscript.ctx is astroid.Store:
+ methodname = "__setitem__"
+ elif subscript.ctx is astroid.Del:
+ methodname = "__delitem__"
+ else:
+ methodname = "__getitem__"
+
+ # Check if this instance's __getitem__, __setitem__, or __delitem__, as
+ # appropriate to the statement, is implemented in a builtin sequence
+ # type. This way we catch subclasses of sequence types but skip classes
+ # that override __getitem__ and which may allow non-integer indices.
+ try:
+ methods = astroid.interpreter.dunder_lookup.lookup(parent_type, methodname)
+ if methods is astroid.Uninferable:
+ return None
+ itemmethod = methods[0]
+ except (
+ astroid.NotFoundError,
+ astroid.AttributeInferenceError,
+ IndexError,
+ ):
+ return None
+ if (
+ not isinstance(itemmethod, astroid.FunctionDef)
+ or itemmethod.root().name != BUILTINS
+ or not itemmethod.parent
+ or itemmethod.parent.name not in SEQUENCE_TYPES
+ ):
+ return None
+
+ # For ExtSlice objects coming from visit_extslice, no further
+ # inference is necessary, since if we got this far the ExtSlice
+ # is an error.
+ if isinstance(subscript.value, astroid.ExtSlice):
+ index_type = subscript.value
+ else:
+ index_type = safe_infer(subscript.slice)
+ if index_type is None or index_type is astroid.Uninferable:
+ return None
+ # Constants must be of type int
+ if isinstance(index_type, astroid.Const):
+ if isinstance(index_type.value, int):
+ return None
+ # Instance values must be int, slice, or have an __index__ method
+ elif isinstance(index_type, astroid.Instance):
+ if index_type.pytype() in (BUILTINS + ".int", BUILTINS + ".slice"):
+ return None
+ try:
+ index_type.getattr("__index__")
+ return None
+ except astroid.NotFoundError:
+ pass
+ elif isinstance(index_type, astroid.Slice):
+ # A slice can be present
+ # here after inferring the index node, which could
+ # be a `slice(...)` call for instance.
+ return self._check_invalid_slice_index(index_type)
+
+ # Anything else is an error
+ self.add_message("invalid-sequence-index", node=subscript)
+ return None
+
+ @check_messages("invalid-sequence-index")
+ def visit_extslice(self, node):
+ if not node.parent or not hasattr(node.parent, "value"):
+ return None
+ # Check extended slice objects as if they were used as a sequence
+ # index to check if the object being sliced can support them
+ return self._check_invalid_sequence_index(node.parent)
+
+ def _check_invalid_slice_index(self, node):
+ # Check the type of each part of the slice
+ invalid_slices = 0
+ for index in (node.lower, node.upper, node.step):
+ if index is None:
+ continue
+
+ index_type = safe_infer(index)
+ if index_type is None or index_type is astroid.Uninferable:
+ continue
+
+ # Constants must of type int or None
+ if isinstance(index_type, astroid.Const):
+ if isinstance(index_type.value, (int, type(None))):
+ continue
+ # Instance values must be of type int, None or an object
+ # with __index__
+ elif isinstance(index_type, astroid.Instance):
+ if index_type.pytype() in (BUILTINS + ".int", BUILTINS + ".NoneType"):
+ continue
+
+ try:
+ index_type.getattr("__index__")
+ return
+ except astroid.NotFoundError:
+ pass
+ invalid_slices += 1
+
+ if not invalid_slices:
+ return
+
+ # Anything else is an error, unless the object that is indexed
+ # is a custom object, which knows how to handle this kind of slices
+ parent = node.parent
+ if isinstance(parent, astroid.ExtSlice):
+ parent = parent.parent
+ if isinstance(parent, astroid.Subscript):
+ inferred = safe_infer(parent.value)
+ if inferred is None or inferred is astroid.Uninferable:
+ # Don't know what this is
+ return
+ known_objects = (
+ astroid.List,
+ astroid.Dict,
+ astroid.Tuple,
+ astroid.objects.FrozenSet,
+ astroid.Set,
+ )
+ if not isinstance(inferred, known_objects):
+ # Might be an instance that knows how to handle this slice object
+ return
+ for _ in range(invalid_slices):
+ self.add_message("invalid-slice-index", node=node)
+
+ @check_messages("not-context-manager")
+ def visit_with(self, node):
+ for ctx_mgr, _ in node.items:
+ context = astroid.context.InferenceContext()
+ inferred = safe_infer(ctx_mgr, context=context)
+ if inferred is None or inferred is astroid.Uninferable:
+ continue
+
+ if isinstance(inferred, astroid.bases.Generator):
+ # Check if we are dealing with a function decorated
+ # with contextlib.contextmanager.
+ if decorated_with(
+ inferred.parent, self.config.contextmanager_decorators
+ ):
+ continue
+ # If the parent of the generator is not the context manager itself,
+ # that means that it could have been returned from another
+ # function which was the real context manager.
+ # The following approach is more of a hack rather than a real
+ # solution: walk all the inferred statements for the
+ # given *ctx_mgr* and if you find one function scope
+ # which is decorated, consider it to be the real
+ # manager and give up, otherwise emit not-context-manager.
+ # See the test file for not_context_manager for a couple
+ # of self explaining tests.
+
+ # Retrieve node from all previusly visited nodes in the the inference history
+ context_path_names = filter(None, _unflatten(context.path))
+ inferred_paths = _flatten_container(
+ safe_infer(path) for path in context_path_names
+ )
+ for inferred_path in inferred_paths:
+ if not inferred_path:
+ continue
+ scope = inferred_path.scope()
+ if not isinstance(scope, astroid.FunctionDef):
+ continue
+ if decorated_with(scope, self.config.contextmanager_decorators):
+ break
+ else:
+ self.add_message(
+ "not-context-manager", node=node, args=(inferred.name,)
+ )
+ else:
+ try:
+ inferred.getattr("__enter__")
+ inferred.getattr("__exit__")
+ except astroid.NotFoundError:
+ if isinstance(inferred, astroid.Instance):
+ # If we do not know the bases of this class,
+ # just skip it.
+ if not has_known_bases(inferred):
+ continue
+ # Just ignore mixin classes.
+ if self.config.ignore_mixin_members:
+ if inferred.name[-5:].lower() == "mixin":
+ continue
+
+ self.add_message(
+ "not-context-manager", node=node, args=(inferred.name,)
+ )
+
+ @check_messages("invalid-unary-operand-type")
+ def visit_unaryop(self, node):
+ """Detect TypeErrors for unary operands."""
+
+ for error in node.type_errors():
+ # Let the error customize its output.
+ self.add_message("invalid-unary-operand-type", args=str(error), node=node)
+
+ @check_messages("unsupported-binary-operation")
+ def visit_binop(self, node: astroid.BinOp):
+ if node.op == "|":
+ self._detect_unsupported_alternative_union_syntax(node)
+
+ def _detect_unsupported_alternative_union_syntax(self, node: astroid.BinOp) -> None:
+ """Detect if unsupported alternative Union syntax (PEP 604) was used."""
+ if PY310_PLUS: # 310+ supports the new syntax
+ return
+
+ if isinstance(
+ node.parent, TYPE_ANNOTATION_NODES_TYPES
+ ) and not is_postponed_evaluation_enabled(node):
+ # Use in type annotations only allowed if
+ # postponed evaluation is enabled.
+ self._check_unsupported_alternative_union_syntax(node)
+
+ if isinstance(
+ node.parent,
+ (
+ astroid.Assign,
+ astroid.Call,
+ astroid.Keyword,
+ astroid.Dict,
+ astroid.Tuple,
+ astroid.Set,
+ astroid.List,
+ astroid.BinOp,
+ ),
+ ):
+ # Check other contexts the syntax might appear, but are invalid.
+ # Make sure to filter context if postponed evaluation is enabled
+ # and parent is allowed node type.
+ allowed_nested_syntax = False
+ if is_postponed_evaluation_enabled(node):
+ parent_node = node.parent
+ while True:
+ if isinstance(parent_node, TYPE_ANNOTATION_NODES_TYPES):
+ allowed_nested_syntax = True
+ break
+ parent_node = parent_node.parent
+ if isinstance(parent_node, astroid.Module):
+ break
+ if not allowed_nested_syntax:
+ self._check_unsupported_alternative_union_syntax(node)
+
+ def _check_unsupported_alternative_union_syntax(self, node: astroid.BinOp) -> None:
+ """Check if left or right node is of type `type`."""
+ msg = "unsupported operand type(s) for |"
+ for n in (node.left, node.right):
+ n = astroid.helpers.object_type(n)
+ if isinstance(n, astroid.ClassDef) and is_classdef_type(n):
+ self.add_message("unsupported-binary-operation", args=msg, node=node)
+ break
+
+ @check_messages("unsupported-binary-operation")
+ def _visit_binop(self, node):
+ """Detect TypeErrors for binary arithmetic operands."""
+ self._check_binop_errors(node)
+
+ @check_messages("unsupported-binary-operation")
+ def _visit_augassign(self, node):
+ """Detect TypeErrors for augmented binary arithmetic operands."""
+ self._check_binop_errors(node)
+
+ def _check_binop_errors(self, node):
+ for error in node.type_errors():
+ # Let the error customize its output.
+ if any(
+ isinstance(obj, astroid.ClassDef) and not has_known_bases(obj)
+ for obj in (error.left_type, error.right_type)
+ ):
+ continue
+ self.add_message("unsupported-binary-operation", args=str(error), node=node)
+
+ def _check_membership_test(self, node):
+ if is_inside_abstract_class(node):
+ return
+ if is_comprehension(node):
+ return
+ inferred = safe_infer(node)
+ if inferred is None or inferred is astroid.Uninferable:
+ return
+ if not supports_membership_test(inferred):
+ self.add_message(
+ "unsupported-membership-test", args=node.as_string(), node=node
+ )
+
+ @check_messages("unsupported-membership-test")
+ def visit_compare(self, node):
+ if len(node.ops) != 1:
+ return
+
+ op, right = node.ops[0]
+ if op in ["in", "not in"]:
+ self._check_membership_test(right)
+
+ @check_messages(
+ "unsubscriptable-object",
+ "unsupported-assignment-operation",
+ "unsupported-delete-operation",
+ "unhashable-dict-key",
+ "invalid-sequence-index",
+ "invalid-slice-index",
+ )
+ def visit_subscript(self, node):
+ self._check_invalid_sequence_index(node)
+
+ supported_protocol = None
+ if isinstance(node.value, (astroid.ListComp, astroid.DictComp)):
+ return
+
+ if isinstance(node.value, astroid.Dict):
+ # Assert dict key is hashable
+ inferred = safe_infer(node.slice)
+ if inferred not in (None, astroid.Uninferable):
+ try:
+ hash_fn = next(inferred.igetattr("__hash__"))
+ except astroid.InferenceError:
+ pass
+ else:
+ if getattr(hash_fn, "value", True) is None:
+ self.add_message("unhashable-dict-key", node=node.value)
+
+ if node.ctx == astroid.Load:
+ supported_protocol = supports_getitem
+ msg = "unsubscriptable-object"
+ elif node.ctx == astroid.Store:
+ supported_protocol = supports_setitem
+ msg = "unsupported-assignment-operation"
+ elif node.ctx == astroid.Del:
+ supported_protocol = supports_delitem
+ msg = "unsupported-delete-operation"
+
+ if isinstance(node.value, astroid.SetComp):
+ self.add_message(msg, args=node.value.as_string(), node=node.value)
+ return
+
+ if is_inside_abstract_class(node):
+ return
+
+ inferred = safe_infer(node.value)
+
+ if inferred is None or inferred is astroid.Uninferable:
+ return
+
+ if getattr(inferred, "decorators", None):
+ first_decorator = astroid.helpers.safe_infer(inferred.decorators.nodes[0])
+ if isinstance(first_decorator, astroid.ClassDef):
+ inferred = first_decorator.instantiate_class()
+ else:
+ return # It would be better to handle function
+ # decorators, but let's start slow.
+
+ if not supported_protocol(inferred, node):
+ self.add_message(msg, args=node.value.as_string(), node=node.value)
+
+ @check_messages("dict-items-missing-iter")
+ def visit_for(self, node):
+ if not isinstance(node.target, astroid.node_classes.Tuple):
+ # target is not a tuple
+ return
+ if not len(node.target.elts) == 2:
+ # target is not a tuple of two elements
+ return
+
+ iterable = node.iter
+ if not isinstance(iterable, astroid.node_classes.Name):
+ # it's not a bare variable
+ return
+
+ inferred = safe_infer(iterable)
+ if not inferred:
+ return
+ if not isinstance(inferred, astroid.node_classes.Dict):
+ # the iterable is not a dict
+ return
+
+ self.add_message("dict-iter-missing-items", node=node)
+
+
+class IterableChecker(BaseChecker):
+ """
+ Checks for non-iterables used in an iterable context.
+ Contexts include:
+ - for-statement
+ - starargs in function call
+ - `yield from`-statement
+ - list, dict and set comprehensions
+ - generator expressions
+ Also checks for non-mappings in function call kwargs.
+ """
+
+ __implements__ = (IAstroidChecker,)
+ name = "typecheck"
+
+ msgs = {
+ "E1133": (
+ "Non-iterable value %s is used in an iterating context",
+ "not-an-iterable",
+ "Used when a non-iterable value is used in place where "
+ "iterable is expected",
+ ),
+ "E1134": (
+ "Non-mapping value %s is used in a mapping context",
+ "not-a-mapping",
+ "Used when a non-mapping value is used in place where "
+ "mapping is expected",
+ ),
+ }
+
+ @staticmethod
+ def _is_asyncio_coroutine(node):
+ if not isinstance(node, astroid.Call):
+ return False
+
+ inferred_func = safe_infer(node.func)
+ if not isinstance(inferred_func, astroid.FunctionDef):
+ return False
+ if not inferred_func.decorators:
+ return False
+ for decorator in inferred_func.decorators.nodes:
+ inferred_decorator = safe_infer(decorator)
+ if not isinstance(inferred_decorator, astroid.FunctionDef):
+ continue
+ if inferred_decorator.qname() != ASYNCIO_COROUTINE:
+ continue
+ return True
+ return False
+
+ def _check_iterable(self, node, check_async=False):
+ if is_inside_abstract_class(node) or is_comprehension(node):
+ return
+ inferred = safe_infer(node)
+ if not inferred:
+ return
+ if not is_iterable(inferred, check_async=check_async):
+ self.add_message("not-an-iterable", args=node.as_string(), node=node)
+
+ def _check_mapping(self, node):
+ if is_inside_abstract_class(node):
+ return
+ if isinstance(node, astroid.DictComp):
+ return
+ inferred = safe_infer(node)
+ if inferred is None or inferred is astroid.Uninferable:
+ return
+ if not is_mapping(inferred):
+ self.add_message("not-a-mapping", args=node.as_string(), node=node)
+
+ @check_messages("not-an-iterable")
+ def visit_for(self, node):
+ self._check_iterable(node.iter)
+
+ @check_messages("not-an-iterable")
+ def visit_asyncfor(self, node):
+ self._check_iterable(node.iter, check_async=True)
+
+ @check_messages("not-an-iterable")
+ def visit_yieldfrom(self, node):
+ if self._is_asyncio_coroutine(node.value):
+ return
+ self._check_iterable(node.value)
+
+ @check_messages("not-an-iterable", "not-a-mapping")
+ def visit_call(self, node):
+ for stararg in node.starargs:
+ self._check_iterable(stararg.value)
+ for kwarg in node.kwargs:
+ self._check_mapping(kwarg.value)
+
+ @check_messages("not-an-iterable")
+ def visit_listcomp(self, node):
+ for gen in node.generators:
+ self._check_iterable(gen.iter, check_async=gen.is_async)
+
+ @check_messages("not-an-iterable")
+ def visit_dictcomp(self, node):
+ for gen in node.generators:
+ self._check_iterable(gen.iter, check_async=gen.is_async)
+
+ @check_messages("not-an-iterable")
+ def visit_setcomp(self, node):
+ for gen in node.generators:
+ self._check_iterable(gen.iter, check_async=gen.is_async)
+
+ @check_messages("not-an-iterable")
+ def visit_generatorexp(self, node):
+ for gen in node.generators:
+ self._check_iterable(gen.iter, check_async=gen.is_async)
+
+ @check_messages("await-outside-async")
+ def visit_await(self, node: astroid.Await) -> None:
+ self._check_await_outside_coroutine(node)
+
+ def _check_await_outside_coroutine(self, node: astroid.Await) -> None:
+ node_scope = node.scope()
+ while not isinstance(node_scope, astroid.Module):
+ if isinstance(node_scope, astroid.AsyncFunctionDef):
+ return
+ if isinstance(node_scope, astroid.FunctionDef):
+ break
+ node_scope = node_scope.parent.scope()
+ self.add_message("await-outside-async", node=node)
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(TypeChecker(linter))
+ linter.register_checker(IterableChecker(linter))
diff --git a/pylint/checkers/utils.py b/pylint/checkers/utils.py
new file mode 100644
index 0000000..af255ab
--- /dev/null
+++ b/pylint/checkers/utils.py
@@ -0,0 +1,1512 @@
+# Copyright (c) 2006-2007, 2009-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2009 Mads Kiilerich <mads@kiilerich.com>
+# Copyright (c) 2010 Daniel Harding <dharding@gmail.com>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Ricardo Gemignani <ricardo.gemignani@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Radu Ciorba <radu@devrandom.ro>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016, 2018-2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016-2017 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2016 Brian C. Lane <bcl@redhat.com>
+# Copyright (c) 2017-2018, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 ttenhoeve-aa <ttenhoeve@appannie.com>
+# Copyright (c) 2018 Alan Chan <achan961117@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Yury Gribov <tetra2005@gmail.com>
+# Copyright (c) 2018 Caio Carrara <ccarrara@redhat.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Brian Shaginaw <brian.shaginaw@warbyparker.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Matthijs Blom <19817960+MatthijsBlom@users.noreply.github.com>
+# Copyright (c) 2019 Djailla <bastien.vallet@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Nathan Marrow <nmarrow@google.com>
+# Copyright (c) 2019 Svet <svet@hyperscience.com>
+# Copyright (c) 2019 Pascal Corpet <pcorpet@users.noreply.github.com>
+# Copyright (c) 2020 Batuhan Taskaya <batuhanosmantaskaya@gmail.com>
+# Copyright (c) 2020 Luigi <luigi.cristofolini@q-ctrl.com>
+# Copyright (c) 2020 ethan-leba <ethanleba5@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Andrew Simmons <anjsimmo@gmail.com>
+# Copyright (c) 2020 Ram Rachum <ram@rachum.com>
+# Copyright (c) 2020 Slavfox <slavfoxman@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""some functions that may be useful for various checkers
+"""
+import builtins
+import itertools
+import numbers
+import re
+import string
+from functools import lru_cache, partial
+from typing import (
+ Any,
+ Callable,
+ Dict,
+ Iterable,
+ List,
+ Match,
+ Optional,
+ Set,
+ Tuple,
+ Union,
+)
+
+import _string
+import astroid
+
+BUILTINS_NAME = builtins.__name__
+COMP_NODE_TYPES = (
+ astroid.ListComp,
+ astroid.SetComp,
+ astroid.DictComp,
+ astroid.GeneratorExp,
+)
+EXCEPTIONS_MODULE = "builtins"
+ABC_MODULES = {"abc", "_py_abc"}
+ABC_METHODS = {
+ "abc.abstractproperty",
+ "abc.abstractmethod",
+ "abc.abstractclassmethod",
+ "abc.abstractstaticmethod",
+}
+TYPING_PROTOCOLS = frozenset(
+ {"typing.Protocol", "typing_extensions.Protocol", ".Protocol"}
+)
+ITER_METHOD = "__iter__"
+AITER_METHOD = "__aiter__"
+NEXT_METHOD = "__next__"
+GETITEM_METHOD = "__getitem__"
+CLASS_GETITEM_METHOD = "__class_getitem__"
+SETITEM_METHOD = "__setitem__"
+DELITEM_METHOD = "__delitem__"
+CONTAINS_METHOD = "__contains__"
+KEYS_METHOD = "keys"
+
+# Dictionary which maps the number of expected parameters a
+# special method can have to a set of special methods.
+# The following keys are used to denote the parameters restrictions:
+#
+# * None: variable number of parameters
+# * number: exactly that number of parameters
+# * tuple: this are the odd ones. Basically it means that the function
+# can work with any number of arguments from that tuple,
+# although it's best to implement it in order to accept
+# all of them.
+_SPECIAL_METHODS_PARAMS = {
+ None: ("__new__", "__init__", "__call__"),
+ 0: (
+ "__del__",
+ "__repr__",
+ "__str__",
+ "__bytes__",
+ "__hash__",
+ "__bool__",
+ "__dir__",
+ "__len__",
+ "__length_hint__",
+ "__iter__",
+ "__reversed__",
+ "__neg__",
+ "__pos__",
+ "__abs__",
+ "__invert__",
+ "__complex__",
+ "__int__",
+ "__float__",
+ "__index__",
+ "__trunc__",
+ "__floor__",
+ "__ceil__",
+ "__enter__",
+ "__aenter__",
+ "__getnewargs_ex__",
+ "__getnewargs__",
+ "__getstate__",
+ "__reduce__",
+ "__copy__",
+ "__unicode__",
+ "__nonzero__",
+ "__await__",
+ "__aiter__",
+ "__anext__",
+ "__fspath__",
+ ),
+ 1: (
+ "__format__",
+ "__lt__",
+ "__le__",
+ "__eq__",
+ "__ne__",
+ "__gt__",
+ "__ge__",
+ "__getattr__",
+ "__getattribute__",
+ "__delattr__",
+ "__delete__",
+ "__instancecheck__",
+ "__subclasscheck__",
+ "__getitem__",
+ "__missing__",
+ "__delitem__",
+ "__contains__",
+ "__add__",
+ "__sub__",
+ "__mul__",
+ "__truediv__",
+ "__floordiv__",
+ "__rfloordiv__",
+ "__mod__",
+ "__divmod__",
+ "__lshift__",
+ "__rshift__",
+ "__and__",
+ "__xor__",
+ "__or__",
+ "__radd__",
+ "__rsub__",
+ "__rmul__",
+ "__rtruediv__",
+ "__rmod__",
+ "__rdivmod__",
+ "__rpow__",
+ "__rlshift__",
+ "__rrshift__",
+ "__rand__",
+ "__rxor__",
+ "__ror__",
+ "__iadd__",
+ "__isub__",
+ "__imul__",
+ "__itruediv__",
+ "__ifloordiv__",
+ "__imod__",
+ "__ilshift__",
+ "__irshift__",
+ "__iand__",
+ "__ixor__",
+ "__ior__",
+ "__ipow__",
+ "__setstate__",
+ "__reduce_ex__",
+ "__deepcopy__",
+ "__cmp__",
+ "__matmul__",
+ "__rmatmul__",
+ "__imatmul__",
+ "__div__",
+ ),
+ 2: ("__setattr__", "__get__", "__set__", "__setitem__", "__set_name__"),
+ 3: ("__exit__", "__aexit__"),
+ (0, 1): ("__round__",),
+ (1, 2): ("__pow__",),
+}
+
+SPECIAL_METHODS_PARAMS = {
+ name: params
+ for params, methods in _SPECIAL_METHODS_PARAMS.items()
+ for name in methods # type: ignore
+}
+PYMETHODS = set(SPECIAL_METHODS_PARAMS)
+
+SUBSCRIPTABLE_CLASSES_PEP585 = frozenset(
+ (
+ "builtins.tuple",
+ "builtins.list",
+ "builtins.dict",
+ "builtins.set",
+ "builtins.frozenset",
+ "builtins.type",
+ "collections.deque",
+ "collections.defaultdict",
+ "collections.OrderedDict",
+ "collections.Counter",
+ "collections.ChainMap",
+ "_collections_abc.Awaitable",
+ "_collections_abc.Coroutine",
+ "_collections_abc.AsyncIterable",
+ "_collections_abc.AsyncIterator",
+ "_collections_abc.AsyncGenerator",
+ "_collections_abc.Iterable",
+ "_collections_abc.Iterator",
+ "_collections_abc.Generator",
+ "_collections_abc.Reversible",
+ "_collections_abc.Container",
+ "_collections_abc.Collection",
+ "_collections_abc.Callable",
+ "_collections_abc.Set",
+ "_collections_abc.MutableSet",
+ "_collections_abc.Mapping",
+ "_collections_abc.MutableMapping",
+ "_collections_abc.Sequence",
+ "_collections_abc.MutableSequence",
+ "_collections_abc.ByteString",
+ "_collections_abc.MappingView",
+ "_collections_abc.KeysView",
+ "_collections_abc.ItemsView",
+ "_collections_abc.ValuesView",
+ "contextlib.AbstractContextManager",
+ "contextlib.AbstractAsyncContextManager",
+ "re.Pattern",
+ "re.Match",
+ )
+)
+
+
+class NoSuchArgumentError(Exception):
+ pass
+
+
+class InferredTypeError(Exception):
+ pass
+
+
+def is_inside_lambda(node: astroid.node_classes.NodeNG) -> bool:
+ """Return true if given node is inside lambda"""
+ parent = node.parent
+ while parent is not None:
+ if isinstance(parent, astroid.Lambda):
+ return True
+ parent = parent.parent
+ return False
+
+
+def get_all_elements(
+ node: astroid.node_classes.NodeNG,
+) -> Iterable[astroid.node_classes.NodeNG]:
+ """Recursively returns all atoms in nested lists and tuples."""
+ if isinstance(node, (astroid.Tuple, astroid.List)):
+ for child in node.elts:
+ yield from get_all_elements(child)
+ else:
+ yield node
+
+
+def is_super(node: astroid.node_classes.NodeNG) -> bool:
+ """return True if the node is referencing the "super" builtin function"""
+ if getattr(node, "name", None) == "super" and node.root().name == BUILTINS_NAME:
+ return True
+ return False
+
+
+def is_error(node: astroid.scoped_nodes.FunctionDef) -> bool:
+ """Return true if the given function node only raises an exception"""
+ return len(node.body) == 1 and isinstance(node.body[0], astroid.Raise)
+
+
+builtins = builtins.__dict__.copy() # type: ignore
+SPECIAL_BUILTINS = ("__builtins__",) # '__path__', '__file__')
+
+
+def is_builtin_object(node: astroid.node_classes.NodeNG) -> bool:
+ """Returns True if the given node is an object from the __builtin__ module."""
+ return node and node.root().name == BUILTINS_NAME
+
+
+def is_builtin(name: str) -> bool:
+ """return true if <name> could be considered as a builtin defined by python"""
+ return name in builtins or name in SPECIAL_BUILTINS # type: ignore
+
+
+def is_defined_in_scope(
+ var_node: astroid.node_classes.NodeNG,
+ varname: str,
+ scope: astroid.node_classes.NodeNG,
+) -> bool:
+ if isinstance(scope, astroid.If):
+ for node in scope.body:
+ if (
+ isinstance(node, astroid.Assign)
+ and any(
+ isinstance(target, astroid.AssignName) and target.name == varname
+ for target in node.targets
+ )
+ ) or (isinstance(node, astroid.Nonlocal) and varname in node.names):
+ return True
+ elif isinstance(scope, (COMP_NODE_TYPES, astroid.For)):
+ for ass_node in scope.nodes_of_class(astroid.AssignName):
+ if ass_node.name == varname:
+ return True
+ elif isinstance(scope, astroid.With):
+ for expr, ids in scope.items:
+ if expr.parent_of(var_node):
+ break
+ if ids and isinstance(ids, astroid.AssignName) and ids.name == varname:
+ return True
+ elif isinstance(scope, (astroid.Lambda, astroid.FunctionDef)):
+ if scope.args.is_argument(varname):
+ # If the name is found inside a default value
+ # of a function, then let the search continue
+ # in the parent's tree.
+ if scope.args.parent_of(var_node):
+ try:
+ scope.args.default_value(varname)
+ scope = scope.parent
+ is_defined_in_scope(var_node, varname, scope)
+ except astroid.NoDefault:
+ pass
+ return True
+ if getattr(scope, "name", None) == varname:
+ return True
+ elif isinstance(scope, astroid.ExceptHandler):
+ if isinstance(scope.name, astroid.AssignName):
+ ass_node = scope.name
+ if ass_node.name == varname:
+ return True
+ return False
+
+
+def is_defined_before(var_node: astroid.Name) -> bool:
+ """Check if the given variable node is defined before
+
+ Verify that the variable node is defined by a parent node
+ (list, set, dict, or generator comprehension, lambda)
+ or in a previous sibling node on the same line
+ (statement_defining ; statement_using).
+ """
+ varname = var_node.name
+ _node = var_node.parent
+ while _node:
+ if is_defined_in_scope(var_node, varname, _node):
+ return True
+ _node = _node.parent
+ # possibly multiple statements on the same line using semi colon separator
+ stmt = var_node.statement()
+ _node = stmt.previous_sibling()
+ lineno = stmt.fromlineno
+ while _node and _node.fromlineno == lineno:
+ for assign_node in _node.nodes_of_class(astroid.AssignName):
+ if assign_node.name == varname:
+ return True
+ for imp_node in _node.nodes_of_class((astroid.ImportFrom, astroid.Import)):
+ if varname in [name[1] or name[0] for name in imp_node.names]:
+ return True
+ _node = _node.previous_sibling()
+ return False
+
+
+def is_default_argument(
+ node: astroid.node_classes.NodeNG,
+ scope: Optional[astroid.node_classes.NodeNG] = None,
+) -> bool:
+ """return true if the given Name node is used in function or lambda
+ default argument's value
+ """
+ if not scope:
+ scope = node.scope()
+ if isinstance(scope, (astroid.FunctionDef, astroid.Lambda)):
+ for default_node in scope.args.defaults:
+ for default_name_node in default_node.nodes_of_class(astroid.Name):
+ if default_name_node is node:
+ return True
+ return False
+
+
+def is_func_decorator(node: astroid.node_classes.NodeNG) -> bool:
+ """return true if the name is used in function decorator"""
+ parent = node.parent
+ while parent is not None:
+ if isinstance(parent, astroid.Decorators):
+ return True
+ if parent.is_statement or isinstance(
+ parent,
+ (
+ astroid.Lambda,
+ astroid.scoped_nodes.ComprehensionScope,
+ astroid.scoped_nodes.ListComp,
+ ),
+ ):
+ break
+ parent = parent.parent
+ return False
+
+
+def is_ancestor_name(
+ frame: astroid.ClassDef, node: astroid.node_classes.NodeNG
+) -> bool:
+ """return True if `frame` is an astroid.Class node with `node` in the
+ subtree of its bases attribute
+ """
+ if not isinstance(frame, astroid.ClassDef):
+ return False
+ for base in frame.bases:
+ if node in base.nodes_of_class(astroid.Name):
+ return True
+ return False
+
+
+def assign_parent(node: astroid.node_classes.NodeNG) -> astroid.node_classes.NodeNG:
+ """return the higher parent which is not an AssignName, Tuple or List node"""
+ while node and isinstance(node, (astroid.AssignName, astroid.Tuple, astroid.List)):
+ node = node.parent
+ return node
+
+
+def overrides_a_method(class_node: astroid.ClassDef, name: str) -> bool:
+ """return True if <name> is a method overridden from an ancestor"""
+ for ancestor in class_node.ancestors():
+ if name in ancestor and isinstance(ancestor[name], astroid.FunctionDef):
+ return True
+ return False
+
+
+def check_messages(*messages: str) -> Callable:
+ """decorator to store messages that are handled by a checker method"""
+
+ def store_messages(func):
+ func.checks_msgs = messages
+ return func
+
+ return store_messages
+
+
+class IncompleteFormatString(Exception):
+ """A format string ended in the middle of a format specifier."""
+
+
+class UnsupportedFormatCharacter(Exception):
+ """A format character in a format string is not one of the supported
+ format characters."""
+
+ def __init__(self, index):
+ Exception.__init__(self, index)
+ self.index = index
+
+
+def parse_format_string(
+ format_string: str,
+) -> Tuple[Set[str], int, Dict[str, str], List[str]]:
+ """Parses a format string, returning a tuple of (keys, num_args), where keys
+ is the set of mapping keys in the format string, and num_args is the number
+ of arguments required by the format string. Raises
+ IncompleteFormatString or UnsupportedFormatCharacter if a
+ parse error occurs."""
+ keys = set()
+ key_types = dict()
+ pos_types = []
+ num_args = 0
+
+ def next_char(i):
+ i += 1
+ if i == len(format_string):
+ raise IncompleteFormatString
+ return (i, format_string[i])
+
+ i = 0
+ while i < len(format_string):
+ char = format_string[i]
+ if char == "%":
+ i, char = next_char(i)
+ # Parse the mapping key (optional).
+ key = None
+ if char == "(":
+ depth = 1
+ i, char = next_char(i)
+ key_start = i
+ while depth != 0:
+ if char == "(":
+ depth += 1
+ elif char == ")":
+ depth -= 1
+ i, char = next_char(i)
+ key_end = i - 1
+ key = format_string[key_start:key_end]
+
+ # Parse the conversion flags (optional).
+ while char in "#0- +":
+ i, char = next_char(i)
+ # Parse the minimum field width (optional).
+ if char == "*":
+ num_args += 1
+ i, char = next_char(i)
+ else:
+ while char in string.digits:
+ i, char = next_char(i)
+ # Parse the precision (optional).
+ if char == ".":
+ i, char = next_char(i)
+ if char == "*":
+ num_args += 1
+ i, char = next_char(i)
+ else:
+ while char in string.digits:
+ i, char = next_char(i)
+ # Parse the length modifier (optional).
+ if char in "hlL":
+ i, char = next_char(i)
+ # Parse the conversion type (mandatory).
+ flags = "diouxXeEfFgGcrs%a"
+ if char not in flags:
+ raise UnsupportedFormatCharacter(i)
+ if key:
+ keys.add(key)
+ key_types[key] = char
+ elif char != "%":
+ num_args += 1
+ pos_types.append(char)
+ i += 1
+ return keys, num_args, key_types, pos_types
+
+
+def split_format_field_names(format_string) -> Tuple[str, Iterable[Tuple[bool, str]]]:
+ try:
+ return _string.formatter_field_name_split(format_string)
+ except ValueError as e:
+ raise IncompleteFormatString() from e
+
+
+def collect_string_fields(format_string) -> Iterable[Optional[str]]:
+ """Given a format string, return an iterator
+ of all the valid format fields. It handles nested fields
+ as well.
+ """
+ formatter = string.Formatter()
+ try:
+ parseiterator = formatter.parse(format_string)
+ for result in parseiterator:
+ if all(item is None for item in result[1:]):
+ # not a replacement format
+ continue
+ name = result[1]
+ nested = result[2]
+ yield name
+ if nested:
+ yield from collect_string_fields(nested)
+ except ValueError as exc:
+ # Probably the format string is invalid.
+ if exc.args[0].startswith("cannot switch from manual"):
+ # On Jython, parsing a string with both manual
+ # and automatic positions will fail with a ValueError,
+ # while on CPython it will simply return the fields,
+ # the validation being done in the interpreter (?).
+ # We're just returning two mixed fields in order
+ # to trigger the format-combined-specification check.
+ yield ""
+ yield "1"
+ return
+ raise IncompleteFormatString(format_string) from exc
+
+
+def parse_format_method_string(
+ format_string: str,
+) -> Tuple[List[Tuple[str, List[Tuple[bool, str]]]], int, int]:
+ """
+ Parses a PEP 3101 format string, returning a tuple of
+ (keyword_arguments, implicit_pos_args_cnt, explicit_pos_args),
+ where keyword_arguments is the set of mapping keys in the format string, implicit_pos_args_cnt
+ is the number of arguments required by the format string and
+ explicit_pos_args is the number of arguments passed with the position.
+ """
+ keyword_arguments = []
+ implicit_pos_args_cnt = 0
+ explicit_pos_args = set()
+ for name in collect_string_fields(format_string):
+ if name and str(name).isdigit():
+ explicit_pos_args.add(str(name))
+ elif name:
+ keyname, fielditerator = split_format_field_names(name)
+ if isinstance(keyname, numbers.Number):
+ explicit_pos_args.add(str(keyname))
+ try:
+ keyword_arguments.append((keyname, list(fielditerator)))
+ except ValueError as e:
+ raise IncompleteFormatString() from e
+ else:
+ implicit_pos_args_cnt += 1
+ return keyword_arguments, implicit_pos_args_cnt, len(explicit_pos_args)
+
+
+def is_attr_protected(attrname: str) -> bool:
+ """return True if attribute name is protected (start with _ and some other
+ details), False otherwise.
+ """
+ return (
+ attrname[0] == "_"
+ and attrname != "_"
+ and not (attrname.startswith("__") and attrname.endswith("__"))
+ )
+
+
+def node_frame_class(node: astroid.node_classes.NodeNG) -> Optional[astroid.ClassDef]:
+ """Return the class that is wrapping the given node
+
+ The function returns a class for a method node (or a staticmethod or a
+ classmethod), otherwise it returns `None`.
+ """
+ klass = node.frame()
+ nodes_to_check = (
+ astroid.node_classes.NodeNG,
+ astroid.UnboundMethod,
+ astroid.BaseInstance,
+ )
+ while (
+ klass
+ and isinstance(klass, nodes_to_check)
+ and not isinstance(klass, astroid.ClassDef)
+ ):
+ if klass.parent is None:
+ klass = None
+ else:
+ klass = klass.parent.frame()
+
+ return klass
+
+
+def is_attr_private(attrname: str) -> Optional[Match[str]]:
+ """Check that attribute name is private (at least two leading underscores,
+ at most one trailing underscore)
+ """
+ regex = re.compile("^_{2,}.*[^_]+_?$")
+ return regex.match(attrname)
+
+
+def get_argument_from_call(
+ call_node: astroid.Call, position: int = None, keyword: str = None
+) -> astroid.Name:
+ """Returns the specified argument from a function call.
+
+ :param astroid.Call call_node: Node representing a function call to check.
+ :param int position: position of the argument.
+ :param str keyword: the keyword of the argument.
+
+ :returns: The node representing the argument, None if the argument is not found.
+ :rtype: astroid.Name
+ :raises ValueError: if both position and keyword are None.
+ :raises NoSuchArgumentError: if no argument at the provided position or with
+ the provided keyword.
+ """
+ if position is None and keyword is None:
+ raise ValueError("Must specify at least one of: position or keyword.")
+ if position is not None:
+ try:
+ return call_node.args[position]
+ except IndexError:
+ pass
+ if keyword and call_node.keywords:
+ for arg in call_node.keywords:
+ if arg.arg == keyword:
+ return arg.value
+
+ raise NoSuchArgumentError
+
+
+def inherit_from_std_ex(node: astroid.node_classes.NodeNG) -> bool:
+ """
+ Return true if the given class node is subclass of
+ exceptions.Exception.
+ """
+ ancestors = node.ancestors() if hasattr(node, "ancestors") else []
+ for ancestor in itertools.chain([node], ancestors):
+ if (
+ ancestor.name in ("Exception", "BaseException")
+ and ancestor.root().name == EXCEPTIONS_MODULE
+ ):
+ return True
+ return False
+
+
+def error_of_type(handler: astroid.ExceptHandler, error_type) -> bool:
+ """
+ Check if the given exception handler catches
+ the given error_type.
+
+ The *handler* parameter is a node, representing an ExceptHandler node.
+ The *error_type* can be an exception, such as AttributeError,
+ the name of an exception, or it can be a tuple of errors.
+ The function will return True if the handler catches any of the
+ given errors.
+ """
+
+ def stringify_error(error):
+ if not isinstance(error, str):
+ return error.__name__
+ return error
+
+ if not isinstance(error_type, tuple):
+ error_type = (error_type,) # type: ignore
+ expected_errors = {stringify_error(error) for error in error_type} # type: ignore
+ if not handler.type:
+ return False
+ return handler.catch(expected_errors)
+
+
+def decorated_with_property(node: astroid.FunctionDef) -> bool:
+ """Detect if the given function node is decorated with a property."""
+ if not node.decorators:
+ return False
+ for decorator in node.decorators.nodes:
+ try:
+ if _is_property_decorator(decorator):
+ return True
+ except astroid.InferenceError:
+ pass
+ return False
+
+
+def _is_property_kind(node, *kinds):
+ if not isinstance(node, (astroid.UnboundMethod, astroid.FunctionDef)):
+ return False
+ if node.decorators:
+ for decorator in node.decorators.nodes:
+ if isinstance(decorator, astroid.Attribute) and decorator.attrname in kinds:
+ return True
+ return False
+
+
+def is_property_setter(node: astroid.FunctionDef) -> bool:
+ """Check if the given node is a property setter"""
+ return _is_property_kind(node, "setter")
+
+
+def is_property_deleter(node: astroid.FunctionDef) -> bool:
+ """Check if the given node is a property deleter"""
+ return _is_property_kind(node, "deleter")
+
+
+def is_property_setter_or_deleter(node: astroid.FunctionDef) -> bool:
+ """Check if the given node is either a property setter or a deleter"""
+ return _is_property_kind(node, "setter", "deleter")
+
+
+def _is_property_decorator(decorator: astroid.Name) -> bool:
+ for inferred in decorator.infer():
+ if isinstance(inferred, astroid.ClassDef):
+ if inferred.qname() in ("builtins.property", "functools.cached_property"):
+ return True
+ for ancestor in inferred.ancestors():
+ if (
+ ancestor.name == "property"
+ and ancestor.root().name == BUILTINS_NAME
+ ):
+ return True
+ return False
+
+
+def decorated_with(
+ func: Union[astroid.FunctionDef, astroid.BoundMethod, astroid.UnboundMethod],
+ qnames: Iterable[str],
+) -> bool:
+ """Determine if the `func` node has a decorator with the qualified name `qname`."""
+ decorators = func.decorators.nodes if func.decorators else []
+ for decorator_node in decorators:
+ if isinstance(decorator_node, astroid.Call):
+ # We only want to infer the function name
+ decorator_node = decorator_node.func
+ try:
+ if any(
+ i is not None and i.qname() in qnames or i.name in qnames
+ for i in decorator_node.infer()
+ ):
+ return True
+ except astroid.InferenceError:
+ continue
+ return False
+
+
+@lru_cache(maxsize=1024)
+def unimplemented_abstract_methods(
+ node: astroid.ClassDef, is_abstract_cb: astroid.FunctionDef = None
+) -> Dict[str, astroid.node_classes.NodeNG]:
+ """
+ Get the unimplemented abstract methods for the given *node*.
+
+ A method can be considered abstract if the callback *is_abstract_cb*
+ returns a ``True`` value. The check defaults to verifying that
+ a method is decorated with abstract methods.
+ The function will work only for new-style classes. For old-style
+ classes, it will simply return an empty dictionary.
+ For the rest of them, it will return a dictionary of abstract method
+ names and their inferred objects.
+ """
+ if is_abstract_cb is None:
+ is_abstract_cb = partial(decorated_with, qnames=ABC_METHODS)
+ visited: Dict[str, astroid.node_classes.NodeNG] = {}
+ try:
+ mro = reversed(node.mro())
+ except NotImplementedError:
+ # Old style class, it will not have a mro.
+ return {}
+ except astroid.ResolveError:
+ # Probably inconsistent hierarchy, don'try
+ # to figure this out here.
+ return {}
+ for ancestor in mro:
+ for obj in ancestor.values():
+ inferred = obj
+ if isinstance(obj, astroid.AssignName):
+ inferred = safe_infer(obj)
+ if not inferred:
+ # Might be an abstract function,
+ # but since we don't have enough information
+ # in order to take this decision, we're taking
+ # the *safe* decision instead.
+ if obj.name in visited:
+ del visited[obj.name]
+ continue
+ if not isinstance(inferred, astroid.FunctionDef):
+ if obj.name in visited:
+ del visited[obj.name]
+ if isinstance(inferred, astroid.FunctionDef):
+ # It's critical to use the original name,
+ # since after inferring, an object can be something
+ # else than expected, as in the case of the
+ # following assignment.
+ #
+ # class A:
+ # def keys(self): pass
+ # __iter__ = keys
+ abstract = is_abstract_cb(inferred)
+ if abstract:
+ visited[obj.name] = inferred
+ elif not abstract and obj.name in visited:
+ del visited[obj.name]
+ return visited
+
+
+def find_try_except_wrapper_node(
+ node: astroid.node_classes.NodeNG,
+) -> Optional[Union[astroid.ExceptHandler, astroid.TryExcept]]:
+ """Return the ExceptHandler or the TryExcept node in which the node is."""
+ current = node
+ ignores = (astroid.ExceptHandler, astroid.TryExcept)
+ while current and not isinstance(current.parent, ignores):
+ current = current.parent
+
+ if current and isinstance(current.parent, ignores):
+ return current.parent
+ return None
+
+
+def find_except_wrapper_node_in_scope(
+ node: astroid.node_classes.NodeNG,
+) -> Optional[Union[astroid.ExceptHandler, astroid.TryExcept]]:
+ """Return the ExceptHandler in which the node is, without going out of scope."""
+ current = node
+ while current.parent is not None:
+ current = current.parent
+ if isinstance(current, astroid.scoped_nodes.LocalsDictNodeNG):
+ # If we're inside a function/class definition, we don't want to keep checking
+ # higher ancestors for `except` clauses, because if these exist, it means our
+ # function/class was defined in an `except` clause, rather than the current code
+ # actually running in an `except` clause.
+ return None
+ if isinstance(current, astroid.ExceptHandler):
+ return current
+ return None
+
+
+def is_from_fallback_block(node: astroid.node_classes.NodeNG) -> bool:
+ """Check if the given node is from a fallback import block."""
+ context = find_try_except_wrapper_node(node)
+ if not context:
+ return False
+
+ if isinstance(context, astroid.ExceptHandler):
+ other_body = context.parent.body
+ handlers = context.parent.handlers
+ else:
+ other_body = itertools.chain.from_iterable(
+ handler.body for handler in context.handlers
+ )
+ handlers = context.handlers
+
+ has_fallback_imports = any(
+ isinstance(import_node, (astroid.ImportFrom, astroid.Import))
+ for import_node in other_body
+ )
+ ignores_import_error = _except_handlers_ignores_exception(handlers, ImportError)
+ return ignores_import_error or has_fallback_imports
+
+
+def _except_handlers_ignores_exception(
+ handlers: astroid.ExceptHandler, exception
+) -> bool:
+ func = partial(error_of_type, error_type=(exception,))
+ return any(func(handler) for handler in handlers)
+
+
+def get_exception_handlers(
+ node: astroid.node_classes.NodeNG, exception=Exception
+) -> Optional[List[astroid.ExceptHandler]]:
+ """Return the collections of handlers handling the exception in arguments.
+
+ Args:
+ node (astroid.NodeNG): A node that is potentially wrapped in a try except.
+ exception (builtin.Exception or str): exception or name of the exception.
+
+ Returns:
+ list: the collection of handlers that are handling the exception or None.
+
+ """
+ context = find_try_except_wrapper_node(node)
+ if isinstance(context, astroid.TryExcept):
+ return [
+ handler for handler in context.handlers if error_of_type(handler, exception)
+ ]
+ return []
+
+
+def is_node_inside_try_except(node: astroid.Raise) -> bool:
+ """Check if the node is directly under a Try/Except statement.
+ (but not under an ExceptHandler!)
+
+ Args:
+ node (astroid.Raise): the node raising the exception.
+
+ Returns:
+ bool: True if the node is inside a try/except statement, False otherwise.
+ """
+ context = find_try_except_wrapper_node(node)
+ return isinstance(context, astroid.TryExcept)
+
+
+def node_ignores_exception(
+ node: astroid.node_classes.NodeNG, exception=Exception
+) -> bool:
+ """Check if the node is in a TryExcept which handles the given exception.
+
+ If the exception is not given, the function is going to look for bare
+ excepts.
+ """
+ managing_handlers = get_exception_handlers(node, exception)
+ if not managing_handlers:
+ return False
+ return any(managing_handlers)
+
+
+def class_is_abstract(node: astroid.ClassDef) -> bool:
+ """return true if the given class node should be considered as an abstract
+ class
+ """
+ # Only check for explicit metaclass=ABCMeta on this specific class
+ meta = node.declared_metaclass()
+ if meta is not None:
+ if meta.name == "ABCMeta" and meta.root().name in ABC_MODULES:
+ return True
+
+ for ancestor in node.ancestors():
+ if ancestor.name == "ABC" and ancestor.root().name in ABC_MODULES:
+ # abc.ABC inheritance
+ return True
+
+ for method in node.methods():
+ if method.parent.frame() is node:
+ if method.is_abstract(pass_is_abstract=False):
+ return True
+ return False
+
+
+def _supports_protocol_method(value: astroid.node_classes.NodeNG, attr: str) -> bool:
+ try:
+ attributes = value.getattr(attr)
+ except astroid.NotFoundError:
+ return False
+
+ first = attributes[0]
+ if isinstance(first, astroid.AssignName):
+ if isinstance(first.parent.value, astroid.Const):
+ return False
+ return True
+
+
+def is_comprehension(node: astroid.node_classes.NodeNG) -> bool:
+ comprehensions = (
+ astroid.ListComp,
+ astroid.SetComp,
+ astroid.DictComp,
+ astroid.GeneratorExp,
+ )
+ return isinstance(node, comprehensions)
+
+
+def _supports_mapping_protocol(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol_method(
+ value, GETITEM_METHOD
+ ) and _supports_protocol_method(value, KEYS_METHOD)
+
+
+def _supports_membership_test_protocol(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol_method(value, CONTAINS_METHOD)
+
+
+def _supports_iteration_protocol(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol_method(value, ITER_METHOD) or _supports_protocol_method(
+ value, GETITEM_METHOD
+ )
+
+
+def _supports_async_iteration_protocol(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol_method(value, AITER_METHOD)
+
+
+def _supports_getitem_protocol(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol_method(value, GETITEM_METHOD)
+
+
+def _supports_setitem_protocol(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol_method(value, SETITEM_METHOD)
+
+
+def _supports_delitem_protocol(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol_method(value, DELITEM_METHOD)
+
+
+def _is_abstract_class_name(name: str) -> bool:
+ lname = name.lower()
+ is_mixin = lname.endswith("mixin")
+ is_abstract = lname.startswith("abstract")
+ is_base = lname.startswith("base") or lname.endswith("base")
+ return is_mixin or is_abstract or is_base
+
+
+def is_inside_abstract_class(node: astroid.node_classes.NodeNG) -> bool:
+ while node is not None:
+ if isinstance(node, astroid.ClassDef):
+ if class_is_abstract(node):
+ return True
+ name = getattr(node, "name", None)
+ if name is not None and _is_abstract_class_name(name):
+ return True
+ node = node.parent
+ return False
+
+
+def _supports_protocol(
+ value: astroid.node_classes.NodeNG, protocol_callback: astroid.FunctionDef
+) -> bool:
+ if isinstance(value, astroid.ClassDef):
+ if not has_known_bases(value):
+ return True
+ # classobj can only be iterable if it has an iterable metaclass
+ meta = value.metaclass()
+ if meta is not None:
+ if protocol_callback(meta):
+ return True
+ if isinstance(value, astroid.BaseInstance):
+ if not has_known_bases(value):
+ return True
+ if value.has_dynamic_getattr():
+ return True
+ if protocol_callback(value):
+ return True
+
+ if (
+ isinstance(value, astroid.bases.Proxy)
+ and isinstance(value._proxied, astroid.BaseInstance)
+ and has_known_bases(value._proxied)
+ ):
+ value = value._proxied
+ return protocol_callback(value)
+
+ return False
+
+
+def is_iterable(value: astroid.node_classes.NodeNG, check_async: bool = False) -> bool:
+ if check_async:
+ protocol_check = _supports_async_iteration_protocol
+ else:
+ protocol_check = _supports_iteration_protocol
+ return _supports_protocol(value, protocol_check)
+
+
+def is_mapping(value: astroid.node_classes.NodeNG) -> bool:
+ return _supports_protocol(value, _supports_mapping_protocol)
+
+
+def supports_membership_test(value: astroid.node_classes.NodeNG) -> bool:
+ supported = _supports_protocol(value, _supports_membership_test_protocol)
+ return supported or is_iterable(value)
+
+
+def supports_getitem(
+ value: astroid.node_classes.NodeNG, node: astroid.node_classes.NodeNG
+) -> bool:
+ if isinstance(value, astroid.ClassDef):
+ if _supports_protocol_method(value, CLASS_GETITEM_METHOD):
+ return True
+ if is_class_subscriptable_pep585_with_postponed_evaluation_enabled(value, node):
+ return True
+ return _supports_protocol(value, _supports_getitem_protocol)
+
+
+def supports_setitem(value: astroid.node_classes.NodeNG, *_: Any) -> bool:
+ return _supports_protocol(value, _supports_setitem_protocol)
+
+
+def supports_delitem(value: astroid.node_classes.NodeNG, *_: Any) -> bool:
+ return _supports_protocol(value, _supports_delitem_protocol)
+
+
+def _get_python_type_of_node(node):
+ pytype = getattr(node, "pytype", None)
+ if callable(pytype):
+ return pytype()
+ return None
+
+
+@lru_cache(maxsize=1024)
+def safe_infer(
+ node: astroid.node_classes.NodeNG, context=None
+) -> Optional[astroid.node_classes.NodeNG]:
+ """Return the inferred value for the given node.
+
+ Return None if inference failed or if there is some ambiguity (more than
+ one node has been inferred of different types).
+ """
+ inferred_types = set()
+ try:
+ infer_gen = node.infer(context=context)
+ value = next(infer_gen)
+ except astroid.InferenceError:
+ return None
+
+ if value is not astroid.Uninferable:
+ inferred_types.add(_get_python_type_of_node(value))
+
+ try:
+ for inferred in infer_gen:
+ inferred_type = _get_python_type_of_node(inferred)
+ if inferred_type not in inferred_types:
+ return None # If there is ambiguity on the inferred node.
+ except astroid.InferenceError:
+ return None # There is some kind of ambiguity
+ except StopIteration:
+ return value
+ return value if len(inferred_types) <= 1 else None
+
+
+def has_known_bases(klass: astroid.ClassDef, context=None) -> bool:
+ """Return true if all base classes of a class could be inferred."""
+ try:
+ return klass._all_bases_known
+ except AttributeError:
+ pass
+ for base in klass.bases:
+ result = safe_infer(base, context=context)
+ if (
+ not isinstance(result, astroid.ClassDef)
+ or result is klass
+ or not has_known_bases(result, context=context)
+ ):
+ klass._all_bases_known = False
+ return False
+ klass._all_bases_known = True
+ return True
+
+
+def is_none(node: astroid.node_classes.NodeNG) -> bool:
+ return (
+ node is None
+ or (isinstance(node, astroid.Const) and node.value is None)
+ or (isinstance(node, astroid.Name) and node.name == "None")
+ )
+
+
+def node_type(node: astroid.node_classes.NodeNG) -> Optional[type]:
+ """Return the inferred type for `node`
+
+ If there is more than one possible type, or if inferred type is Uninferable or None,
+ return None
+ """
+ # check there is only one possible type for the assign node. Else we
+ # don't handle it for now
+ types = set()
+ try:
+ for var_type in node.infer():
+ if var_type == astroid.Uninferable or is_none(var_type):
+ continue
+ types.add(var_type)
+ if len(types) > 1:
+ return None
+ except astroid.InferenceError:
+ return None
+ return types.pop() if types else None
+
+
+def is_registered_in_singledispatch_function(node: astroid.FunctionDef) -> bool:
+ """Check if the given function node is a singledispatch function."""
+
+ singledispatch_qnames = (
+ "functools.singledispatch",
+ "singledispatch.singledispatch",
+ )
+
+ if not isinstance(node, astroid.FunctionDef):
+ return False
+
+ decorators = node.decorators.nodes if node.decorators else []
+ for decorator in decorators:
+ # func.register are function calls
+ if not isinstance(decorator, astroid.Call):
+ continue
+
+ func = decorator.func
+ if not isinstance(func, astroid.Attribute) or func.attrname != "register":
+ continue
+
+ try:
+ func_def = next(func.expr.infer())
+ except astroid.InferenceError:
+ continue
+
+ if isinstance(func_def, astroid.FunctionDef):
+ # pylint: disable=redundant-keyword-arg; some flow inference goes wrong here
+ return decorated_with(func_def, singledispatch_qnames)
+
+ return False
+
+
+def get_node_last_lineno(node: astroid.node_classes.NodeNG) -> int:
+ """
+ Get the last lineno of the given node. For a simple statement this will just be node.lineno,
+ but for a node that has child statements (e.g. a method) this will be the lineno of the last
+ child statement recursively.
+ """
+ # 'finalbody' is always the last clause in a try statement, if present
+ if getattr(node, "finalbody", False):
+ return get_node_last_lineno(node.finalbody[-1])
+ # For if, while, and for statements 'orelse' is always the last clause.
+ # For try statements 'orelse' is the last in the absence of a 'finalbody'
+ if getattr(node, "orelse", False):
+ return get_node_last_lineno(node.orelse[-1])
+ # try statements have the 'handlers' last if there is no 'orelse' or 'finalbody'
+ if getattr(node, "handlers", False):
+ return get_node_last_lineno(node.handlers[-1])
+ # All compound statements have a 'body'
+ if getattr(node, "body", False):
+ return get_node_last_lineno(node.body[-1])
+ # Not a compound statement
+ return node.lineno
+
+
+def is_postponed_evaluation_enabled(node: astroid.node_classes.NodeNG) -> bool:
+ """Check if the postponed evaluation of annotations is enabled"""
+ module = node.root()
+ return "annotations" in module.future_imports
+
+
+def is_class_subscriptable_pep585_with_postponed_evaluation_enabled(
+ value: astroid.ClassDef, node: astroid.node_classes.NodeNG
+) -> bool:
+ """Check if class is subscriptable with PEP 585 and
+ postponed evaluation enabled.
+ """
+ return (
+ is_postponed_evaluation_enabled(node)
+ and value.qname() in SUBSCRIPTABLE_CLASSES_PEP585
+ and is_node_in_type_annotation_context(node)
+ )
+
+
+def is_node_in_type_annotation_context(node: astroid.node_classes.NodeNG) -> bool:
+ """Check if node is in type annotation context.
+
+ Check for 'AnnAssign', function 'Arguments',
+ or part of function return type anntation.
+ """
+ # pylint: disable=too-many-boolean-expressions
+ current_node, parent_node = node, node.parent
+ while True:
+ if (
+ isinstance(parent_node, astroid.AnnAssign)
+ and parent_node.annotation == current_node
+ or isinstance(parent_node, astroid.Arguments)
+ and current_node
+ in (
+ *parent_node.annotations,
+ *parent_node.posonlyargs_annotations,
+ *parent_node.kwonlyargs_annotations,
+ parent_node.varargannotation,
+ parent_node.kwargannotation,
+ )
+ or isinstance(parent_node, astroid.FunctionDef)
+ and parent_node.returns == current_node
+ ):
+ return True
+ current_node, parent_node = parent_node, parent_node.parent
+ if isinstance(parent_node, astroid.Module):
+ return False
+
+
+def is_subclass_of(child: astroid.ClassDef, parent: astroid.ClassDef) -> bool:
+ """
+ Check if first node is a subclass of second node.
+ :param child: Node to check for subclass.
+ :param parent: Node to check for superclass.
+ :returns: True if child is derived from parent. False otherwise.
+ """
+ if not all(isinstance(node, astroid.ClassDef) for node in (child, parent)):
+ return False
+
+ for ancestor in child.ancestors():
+ try:
+ if astroid.helpers.is_subtype(ancestor, parent):
+ return True
+ except astroid.exceptions._NonDeducibleTypeHierarchy:
+ continue
+ return False
+
+
+@lru_cache(maxsize=1024)
+def is_overload_stub(node: astroid.node_classes.NodeNG) -> bool:
+ """Check if a node if is a function stub decorated with typing.overload.
+
+ :param node: Node to check.
+ :returns: True if node is an overload function stub. False otherwise.
+ """
+ decorators = getattr(node, "decorators", None)
+ return bool(decorators and decorated_with(node, ["typing.overload", "overload"]))
+
+
+def is_protocol_class(cls: astroid.node_classes.NodeNG) -> bool:
+ """Check if the given node represents a protocol class
+
+ :param cls: The node to check
+ :returns: True if the node is a typing protocol class, false otherwise.
+ """
+ if not isinstance(cls, astroid.ClassDef):
+ return False
+
+ # Use .ancestors() since not all protocol classes can have
+ # their mro deduced.
+ return any(parent.qname() in TYPING_PROTOCOLS for parent in cls.ancestors())
+
+
+def is_call_of_name(node: astroid.node_classes.NodeNG, name: str) -> bool:
+ """Checks if node is a function call with the given name"""
+ return (
+ isinstance(node, astroid.Call)
+ and isinstance(node.func, astroid.Name)
+ and node.func.name == name
+ )
+
+
+def is_test_condition(
+ node: astroid.node_classes.NodeNG,
+ parent: Optional[astroid.node_classes.NodeNG] = None,
+) -> bool:
+ """Returns true if the given node is being tested for truthiness"""
+ parent = parent or node.parent
+ if isinstance(parent, (astroid.While, astroid.If, astroid.IfExp, astroid.Assert)):
+ return node is parent.test or parent.test.parent_of(node)
+ if isinstance(parent, astroid.Comprehension):
+ return node in parent.ifs
+ return is_call_of_name(parent, "bool") and parent.parent_of(node)
+
+
+def is_classdef_type(node: astroid.ClassDef) -> bool:
+ """Test if ClassDef node is Type."""
+ if node.name == "type":
+ return True
+ for base in node.bases:
+ if isinstance(base, astroid.Name) and base.name == "type":
+ return True
+ return False
+
+
+def is_attribute_typed_annotation(
+ node: Union[astroid.ClassDef, astroid.Instance], attr_name: str
+) -> bool:
+ """Test if attribute is typed annotation in current node
+ or any base nodes.
+ """
+ attribute = node.locals.get(attr_name, [None])[0]
+ if (
+ attribute
+ and isinstance(attribute, astroid.AssignName)
+ and isinstance(attribute.parent, astroid.AnnAssign)
+ ):
+ return True
+ for base in node.bases:
+ inferred = safe_infer(base)
+ if (
+ inferred
+ and isinstance(inferred, astroid.ClassDef)
+ and is_attribute_typed_annotation(inferred, attr_name)
+ ):
+ return True
+ return False
+
+
+def is_assign_name_annotated_with(node: astroid.AssignName, typing_name: str) -> bool:
+ """Test if AssignName node has `typing_name` annotation.
+
+ Especially useful to check for `typing._SpecialForm` instances
+ like: `Union`, `Optional`, `Literal`, `ClassVar`, `Final`.
+ """
+ if not isinstance(node.parent, astroid.AnnAssign):
+ return False
+ annotation = node.parent.annotation
+ if isinstance(annotation, astroid.Subscript):
+ annotation = annotation.value
+ if (
+ isinstance(annotation, astroid.Name)
+ and annotation.name == typing_name
+ or isinstance(annotation, astroid.Attribute)
+ and annotation.attrname == typing_name
+ ):
+ return True
+ return False
+
+
+def get_iterating_dictionary_name(
+ node: Union[astroid.For, astroid.Comprehension]
+) -> Optional[str]:
+ """Get the name of the dictionary which keys are being iterated over on
+ a `astroid.For` or `astroid.Comprehension` node.
+
+ If the iterating object is not either the keys method of a dictionary
+ or a dictionary itself, this returns None.
+ """
+ # Is it a proper keys call?
+ if (
+ isinstance(node.iter, astroid.Call)
+ and isinstance(node.iter.func, astroid.Attribute)
+ and node.iter.func.attrname == "keys"
+ ):
+ inferred = safe_infer(node.iter.func)
+ if not isinstance(inferred, astroid.BoundMethod):
+ return None
+ return node.iter.as_string().rpartition(".keys")[0]
+
+ # Is it a dictionary?
+ if isinstance(node.iter, (astroid.Name, astroid.Attribute)):
+ inferred = safe_infer(node.iter)
+ if not isinstance(inferred, astroid.Dict):
+ return None
+ return node.iter.as_string()
+
+ return None
+
+
+def get_subscript_const_value(node: astroid.Subscript) -> astroid.Const:
+ """
+ Returns the value 'subscript.slice' of a Subscript node.
+
+ :param node: Subscript Node to extract value from
+ :returns: Const Node containing subscript value
+ :raises InferredTypeError: if the subscript node cannot be inferred as a Const
+ """
+ inferred = safe_infer(node.slice)
+ if not isinstance(inferred, astroid.Const):
+ raise InferredTypeError(
+ "Subscript.slice cannot be inferred as an astroid.Const"
+ )
+
+ return inferred
diff --git a/pylint/checkers/variables.py b/pylint/checkers/variables.py
new file mode 100644
index 0000000..3ddafd5
--- /dev/null
+++ b/pylint/checkers/variables.py
@@ -0,0 +1,2152 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2009 Mads Kiilerich <mads@kiilerich.com>
+# Copyright (c) 2010 Daniel Harding <dharding@gmail.com>
+# Copyright (c) 2011-2014, 2017 Google, Inc.
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Ricardo Gemignani <ricardo.gemignani@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Radu Ciorba <radu@devrandom.ro>
+# Copyright (c) 2015 Simu Toni <simutoni@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016, 2018-2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016, 2018 Jakub Wilk <jwilk@jwilk.net>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Grant Welch <gwelch925+github@gmail.com>
+# Copyright (c) 2017-2018, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017-2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2017 Dan Garrette <dhgarrette@gmail.com>
+# Copyright (c) 2018-2019 Jim Robertson <jrobertson98atx@gmail.com>
+# Copyright (c) 2018 Mike Miller <mtmiller@users.noreply.github.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Drew <drewrisinger@users.noreply.github.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Marianna Polatoglou <mpolatoglou@bloomberg.net>
+# Copyright (c) 2018 mar-chi-pan <mar.polatoglou@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2019 Djailla <bastien.vallet@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Andrew Simmons <anjsimmo@gmail.com>
+# Copyright (c) 2020 Andrew Simmons <a.simmons@deakin.edu.au>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2020 Ashley Whetter <ashleyw@activestate.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 haasea <44787650+haasea@users.noreply.github.com>
+# Copyright (c) 2021 Alexander Kapshuna <kapsh@kap.sh>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""variables checkers for Python code
+"""
+import collections
+import copy
+import itertools
+import os
+import re
+from functools import lru_cache
+
+import astroid
+
+from pylint.checkers import BaseChecker, utils
+from pylint.checkers.utils import is_postponed_evaluation_enabled
+from pylint.constants import PY39_PLUS
+from pylint.interfaces import HIGH, INFERENCE, INFERENCE_FAILURE, IAstroidChecker
+from pylint.utils import get_global_option
+
+SPECIAL_OBJ = re.compile("^_{2}[a-z]+_{2}$")
+FUTURE = "__future__"
+# regexp for ignored argument name
+IGNORED_ARGUMENT_NAMES = re.compile("_.*|^ignored_|^unused_")
+# In Python 3.7 abc has a Python implementation which is preferred
+# by astroid. Unfortunately this also messes up our explicit checks
+# for `abc`
+METACLASS_NAME_TRANSFORMS = {"_py_abc": "abc"}
+TYPING_TYPE_CHECKS_GUARDS = frozenset({"typing.TYPE_CHECKING", "TYPE_CHECKING"})
+BUILTIN_RANGE = "builtins.range"
+TYPING_MODULE = "typing"
+TYPING_NAMES = frozenset(
+ {
+ "Any",
+ "Callable",
+ "ClassVar",
+ "Generic",
+ "Optional",
+ "Tuple",
+ "Type",
+ "TypeVar",
+ "Union",
+ "AbstractSet",
+ "ByteString",
+ "Container",
+ "ContextManager",
+ "Hashable",
+ "ItemsView",
+ "Iterable",
+ "Iterator",
+ "KeysView",
+ "Mapping",
+ "MappingView",
+ "MutableMapping",
+ "MutableSequence",
+ "MutableSet",
+ "Sequence",
+ "Sized",
+ "ValuesView",
+ "Awaitable",
+ "AsyncIterator",
+ "AsyncIterable",
+ "Coroutine",
+ "Collection",
+ "AsyncGenerator",
+ "AsyncContextManager",
+ "Reversible",
+ "SupportsAbs",
+ "SupportsBytes",
+ "SupportsComplex",
+ "SupportsFloat",
+ "SupportsInt",
+ "SupportsRound",
+ "Counter",
+ "Deque",
+ "Dict",
+ "DefaultDict",
+ "List",
+ "Set",
+ "FrozenSet",
+ "NamedTuple",
+ "Generator",
+ "AnyStr",
+ "Text",
+ "Pattern",
+ "BinaryIO",
+ }
+)
+
+
+def _is_from_future_import(stmt, name):
+ """Check if the name is a future import from another module."""
+ try:
+ module = stmt.do_import_module(stmt.modname)
+ except astroid.AstroidBuildingException:
+ return None
+
+ for local_node in module.locals.get(name, []):
+ if isinstance(local_node, astroid.ImportFrom) and local_node.modname == FUTURE:
+ return True
+ return None
+
+
+def in_for_else_branch(parent, stmt):
+ """Returns True if stmt in inside the else branch for a parent For stmt."""
+ return isinstance(parent, astroid.For) and any(
+ else_stmt.parent_of(stmt) or else_stmt == stmt for else_stmt in parent.orelse
+ )
+
+
+@lru_cache(maxsize=1000)
+def overridden_method(klass, name):
+ """get overridden method if any"""
+ try:
+ parent = next(klass.local_attr_ancestors(name))
+ except (StopIteration, KeyError):
+ return None
+ try:
+ meth_node = parent[name]
+ except KeyError:
+ # We have found an ancestor defining <name> but it's not in the local
+ # dictionary. This may happen with astroid built from living objects.
+ return None
+ if isinstance(meth_node, astroid.FunctionDef):
+ return meth_node
+ return None
+
+
+def _get_unpacking_extra_info(node, inferred):
+ """return extra information to add to the message for unpacking-non-sequence
+ and unbalanced-tuple-unpacking errors
+ """
+ more = ""
+ inferred_module = inferred.root().name
+ if node.root().name == inferred_module:
+ if node.lineno == inferred.lineno:
+ more = " %s" % inferred.as_string()
+ elif inferred.lineno:
+ more = " defined at line %s" % inferred.lineno
+ elif inferred.lineno:
+ more = f" defined at line {inferred.lineno} of {inferred_module}"
+ return more
+
+
+def _detect_global_scope(node, frame, defframe):
+ """Detect that the given frames shares a global
+ scope.
+
+ Two frames shares a global scope when neither
+ of them are hidden under a function scope, as well
+ as any of parent scope of them, until the root scope.
+ In this case, depending from something defined later on
+ will not work, because it is still undefined.
+
+ Example:
+ class A:
+ # B has the same global scope as `C`, leading to a NameError.
+ class B(C): ...
+ class C: ...
+
+ """
+ def_scope = scope = None
+ if frame and frame.parent:
+ scope = frame.parent.scope()
+ if defframe and defframe.parent:
+ def_scope = defframe.parent.scope()
+ if isinstance(frame, astroid.FunctionDef):
+ # If the parent of the current node is a
+ # function, then it can be under its scope
+ # (defined in, which doesn't concern us) or
+ # the `->` part of annotations. The same goes
+ # for annotations of function arguments, they'll have
+ # their parent the Arguments node.
+ if not isinstance(node.parent, (astroid.FunctionDef, astroid.Arguments)):
+ return False
+ elif any(
+ not isinstance(f, (astroid.ClassDef, astroid.Module)) for f in (frame, defframe)
+ ):
+ # Not interested in other frames, since they are already
+ # not in a global scope.
+ return False
+
+ break_scopes = []
+ for current_scope in (scope, def_scope):
+ # Look for parent scopes. If there is anything different
+ # than a module or a class scope, then they frames don't
+ # share a global scope.
+ parent_scope = current_scope
+ while parent_scope:
+ if not isinstance(parent_scope, (astroid.ClassDef, astroid.Module)):
+ break_scopes.append(parent_scope)
+ break
+ if parent_scope.parent:
+ parent_scope = parent_scope.parent.scope()
+ else:
+ break
+ if break_scopes and len(set(break_scopes)) != 1:
+ # Store different scopes than expected.
+ # If the stored scopes are, in fact, the very same, then it means
+ # that the two frames (frame and defframe) shares the same scope,
+ # and we could apply our lineno analysis over them.
+ # For instance, this works when they are inside a function, the node
+ # that uses a definition and the definition itself.
+ return False
+ # At this point, we are certain that frame and defframe shares a scope
+ # and the definition of the first depends on the second.
+ return frame.lineno < defframe.lineno
+
+
+def _infer_name_module(node, name):
+ context = astroid.context.InferenceContext()
+ context.lookupname = name
+ return node.infer(context, asname=False)
+
+
+def _fix_dot_imports(not_consumed):
+ """Try to fix imports with multiple dots, by returning a dictionary
+ with the import names expanded. The function unflattens root imports,
+ like 'xml' (when we have both 'xml.etree' and 'xml.sax'), to 'xml.etree'
+ and 'xml.sax' respectively.
+ """
+ names = {}
+ for name, stmts in not_consumed.items():
+ if any(
+ isinstance(stmt, astroid.AssignName)
+ and isinstance(stmt.assign_type(), astroid.AugAssign)
+ for stmt in stmts
+ ):
+ continue
+ for stmt in stmts:
+ if not isinstance(stmt, (astroid.ImportFrom, astroid.Import)):
+ continue
+ for imports in stmt.names:
+ second_name = None
+ import_module_name = imports[0]
+ if import_module_name == "*":
+ # In case of wildcard imports,
+ # pick the name from inside the imported module.
+ second_name = name
+ else:
+ name_matches_dotted_import = False
+ if (
+ import_module_name.startswith(name)
+ and import_module_name.find(".") > -1
+ ):
+ name_matches_dotted_import = True
+
+ if name_matches_dotted_import or name in imports:
+ # Most likely something like 'xml.etree',
+ # which will appear in the .locals as 'xml'.
+ # Only pick the name if it wasn't consumed.
+ second_name = import_module_name
+ if second_name and second_name not in names:
+ names[second_name] = stmt
+ return sorted(names.items(), key=lambda a: a[1].fromlineno)
+
+
+def _find_frame_imports(name, frame):
+ """
+ Detect imports in the frame, with the required
+ *name*. Such imports can be considered assignments.
+ Returns True if an import for the given name was found.
+ """
+ imports = frame.nodes_of_class((astroid.Import, astroid.ImportFrom))
+ for import_node in imports:
+ for import_name, import_alias in import_node.names:
+ # If the import uses an alias, check only that.
+ # Otherwise, check only the import name.
+ if import_alias:
+ if import_alias == name:
+ return True
+ elif import_name and import_name == name:
+ return True
+ return None
+
+
+def _import_name_is_global(stmt, global_names):
+ for import_name, import_alias in stmt.names:
+ # If the import uses an alias, check only that.
+ # Otherwise, check only the import name.
+ if import_alias:
+ if import_alias in global_names:
+ return True
+ elif import_name in global_names:
+ return True
+ return False
+
+
+def _flattened_scope_names(iterator):
+ values = (set(stmt.names) for stmt in iterator)
+ return set(itertools.chain.from_iterable(values))
+
+
+def _assigned_locally(name_node):
+ """
+ Checks if name_node has corresponding assign statement in same scope
+ """
+ assign_stmts = name_node.scope().nodes_of_class(astroid.AssignName)
+ return any(a.name == name_node.name for a in assign_stmts)
+
+
+def _is_type_checking_import(node):
+ parent = node.parent
+ if not isinstance(parent, astroid.If):
+ return False
+ test = parent.test
+ return test.as_string() in TYPING_TYPE_CHECKS_GUARDS
+
+
+def _has_locals_call_after_node(stmt, scope):
+ skip_nodes = (
+ astroid.FunctionDef,
+ astroid.ClassDef,
+ astroid.Import,
+ astroid.ImportFrom,
+ )
+ for call in scope.nodes_of_class(astroid.Call, skip_klass=skip_nodes):
+ inferred = utils.safe_infer(call.func)
+ if (
+ utils.is_builtin_object(inferred)
+ and getattr(inferred, "name", None) == "locals"
+ ):
+ if stmt.lineno < call.lineno:
+ return True
+ return False
+
+
+MSGS = {
+ "E0601": (
+ "Using variable %r before assignment",
+ "used-before-assignment",
+ "Used when a local variable is accessed before its assignment.",
+ ),
+ "E0602": (
+ "Undefined variable %r",
+ "undefined-variable",
+ "Used when an undefined variable is accessed.",
+ ),
+ "E0603": (
+ "Undefined variable name %r in __all__",
+ "undefined-all-variable",
+ "Used when an undefined variable name is referenced in __all__.",
+ ),
+ "E0604": (
+ "Invalid object %r in __all__, must contain only strings",
+ "invalid-all-object",
+ "Used when an invalid (non-string) object occurs in __all__.",
+ ),
+ "E0605": (
+ "Invalid format for __all__, must be tuple or list",
+ "invalid-all-format",
+ "Used when __all__ has an invalid format.",
+ ),
+ "E0611": (
+ "No name %r in module %r",
+ "no-name-in-module",
+ "Used when a name cannot be found in a module.",
+ ),
+ "W0601": (
+ "Global variable %r undefined at the module level",
+ "global-variable-undefined",
+ 'Used when a variable is defined through the "global" statement '
+ "but the variable is not defined in the module scope.",
+ ),
+ "W0602": (
+ "Using global for %r but no assignment is done",
+ "global-variable-not-assigned",
+ 'Used when a variable is defined through the "global" statement '
+ "but no assignment to this variable is done.",
+ ),
+ "W0603": (
+ "Using the global statement", # W0121
+ "global-statement",
+ 'Used when you use the "global" statement to update a global '
+ "variable. Pylint just try to discourage this "
+ "usage. That doesn't mean you cannot use it !",
+ ),
+ "W0604": (
+ "Using the global statement at the module level", # W0103
+ "global-at-module-level",
+ 'Used when you use the "global" statement at the module level '
+ "since it has no effect",
+ ),
+ "W0611": (
+ "Unused %s",
+ "unused-import",
+ "Used when an imported module or variable is not used.",
+ ),
+ "W0612": (
+ "Unused variable %r",
+ "unused-variable",
+ "Used when a variable is defined but not used.",
+ ),
+ "W0613": (
+ "Unused argument %r",
+ "unused-argument",
+ "Used when a function or method argument is not used.",
+ ),
+ "W0614": (
+ "Unused import %s from wildcard import",
+ "unused-wildcard-import",
+ "Used when an imported module or variable is not used from a "
+ "`'from X import *'` style import.",
+ ),
+ "W0621": (
+ "Redefining name %r from outer scope (line %s)",
+ "redefined-outer-name",
+ "Used when a variable's name hides a name defined in the outer scope.",
+ ),
+ "W0622": (
+ "Redefining built-in %r",
+ "redefined-builtin",
+ "Used when a variable or function override a built-in.",
+ ),
+ "W0631": (
+ "Using possibly undefined loop variable %r",
+ "undefined-loop-variable",
+ "Used when a loop variable (i.e. defined by a for loop or "
+ "a list comprehension or a generator expression) is used outside "
+ "the loop.",
+ ),
+ "W0632": (
+ "Possible unbalanced tuple unpacking with "
+ "sequence%s: "
+ "left side has %d label(s), right side has %d value(s)",
+ "unbalanced-tuple-unpacking",
+ "Used when there is an unbalanced tuple unpacking in assignment",
+ {"old_names": [("E0632", "old-unbalanced-tuple-unpacking")]},
+ ),
+ "E0633": (
+ "Attempting to unpack a non-sequence%s",
+ "unpacking-non-sequence",
+ "Used when something which is not "
+ "a sequence is used in an unpack assignment",
+ {"old_names": [("W0633", "old-unpacking-non-sequence")]},
+ ),
+ "W0640": (
+ "Cell variable %s defined in loop",
+ "cell-var-from-loop",
+ "A variable used in a closure is defined in a loop. "
+ "This will result in all closures using the same value for "
+ "the closed-over variable.",
+ ),
+ "W0641": (
+ "Possibly unused variable %r",
+ "possibly-unused-variable",
+ "Used when a variable is defined but might not be used. "
+ "The possibility comes from the fact that locals() might be used, "
+ "which could consume or not the said variable",
+ ),
+ "W0642": (
+ "Invalid assignment to %s in method",
+ "self-cls-assignment",
+ "Invalid assignment to self or cls in instance or class method "
+ "respectively.",
+ ),
+}
+
+
+ScopeConsumer = collections.namedtuple(
+ "ScopeConsumer", "to_consume consumed scope_type"
+)
+
+
+class NamesConsumer:
+ """
+ A simple class to handle consumed, to consume and scope type info of node locals
+ """
+
+ def __init__(self, node, scope_type):
+ self._atomic = ScopeConsumer(copy.copy(node.locals), {}, scope_type)
+ self.node = node
+
+ def __repr__(self):
+ to_consumes = [f"{k}->{v}" for k, v in self._atomic.to_consume.items()]
+ consumed = [f"{k}->{v}" for k, v in self._atomic.consumed.items()]
+ to_consumes = ", ".join(to_consumes)
+ consumed = ", ".join(consumed)
+ return f"""
+to_consume : {to_consumes}
+consumed : {consumed}
+scope_type : {self._atomic.scope_type}
+"""
+
+ def __iter__(self):
+ return iter(self._atomic)
+
+ @property
+ def to_consume(self):
+ return self._atomic.to_consume
+
+ @property
+ def consumed(self):
+ return self._atomic.consumed
+
+ @property
+ def scope_type(self):
+ return self._atomic.scope_type
+
+ def mark_as_consumed(self, name, new_node):
+ """
+ Mark the name as consumed and delete it from
+ the to_consume dictionary
+ """
+ self.consumed[name] = new_node
+ del self.to_consume[name]
+
+ def get_next_to_consume(self, node):
+ # Get the definition of `node` from this scope
+ name = node.name
+ parent_node = node.parent
+ found_node = self.to_consume.get(name)
+ if (
+ found_node
+ and isinstance(parent_node, astroid.Assign)
+ and parent_node == found_node[0].parent
+ ):
+ lhs = found_node[0].parent.targets[0]
+ if lhs.name == name: # this name is defined in this very statement
+ found_node = None
+
+ if (
+ found_node
+ and isinstance(parent_node, astroid.For)
+ and parent_node.iter == node
+ and parent_node.target in found_node
+ ):
+ found_node = None
+ return found_node
+
+
+# pylint: disable=too-many-public-methods
+class VariablesChecker(BaseChecker):
+ """checks for
+ * unused variables / imports
+ * undefined variables
+ * redefinition of variable from builtins or from an outer scope
+ * use of variable before assignment
+ * __all__ consistency
+ * self/cls assignment
+ """
+
+ __implements__ = IAstroidChecker
+
+ name = "variables"
+ msgs = MSGS
+ priority = -1
+ options = (
+ (
+ "init-import",
+ {
+ "default": 0,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "Tells whether we should check for unused import in "
+ "__init__ files.",
+ },
+ ),
+ (
+ "dummy-variables-rgx",
+ {
+ "default": "_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_",
+ "type": "regexp",
+ "metavar": "<regexp>",
+ "help": "A regular expression matching the name of dummy "
+ "variables (i.e. expected to not be used).",
+ },
+ ),
+ (
+ "additional-builtins",
+ {
+ "default": (),
+ "type": "csv",
+ "metavar": "<comma separated list>",
+ "help": "List of additional names supposed to be defined in "
+ "builtins. Remember that you should avoid defining new builtins "
+ "when possible.",
+ },
+ ),
+ (
+ "callbacks",
+ {
+ "default": ("cb_", "_cb"),
+ "type": "csv",
+ "metavar": "<callbacks>",
+ "help": "List of strings which can identify a callback "
+ "function by name. A callback name must start or "
+ "end with one of those strings.",
+ },
+ ),
+ (
+ "redefining-builtins-modules",
+ {
+ "default": (
+ "six.moves",
+ "past.builtins",
+ "future.builtins",
+ "builtins",
+ "io",
+ ),
+ "type": "csv",
+ "metavar": "<comma separated list>",
+ "help": "List of qualified module names which can have objects "
+ "that can redefine builtins.",
+ },
+ ),
+ (
+ "ignored-argument-names",
+ {
+ "default": IGNORED_ARGUMENT_NAMES,
+ "type": "regexp",
+ "metavar": "<regexp>",
+ "help": "Argument names that match this expression will be "
+ "ignored. Default to name with leading underscore.",
+ },
+ ),
+ (
+ "allow-global-unused-variables",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": "Tells whether unused global variables should be treated as a violation.",
+ },
+ ),
+ (
+ "allowed-redefined-builtins",
+ {
+ "default": (),
+ "type": "csv",
+ "metavar": "<comma separated list>",
+ "help": "List of names allowed to shadow builtins",
+ },
+ ),
+ )
+
+ def __init__(self, linter=None):
+ BaseChecker.__init__(self, linter)
+ self._to_consume = (
+ None # list of tuples: (to_consume:dict, consumed:dict, scope_type:str)
+ )
+ self._checking_mod_attr = None
+ self._loop_variables = []
+ self._type_annotation_names = []
+ self._postponed_evaluation_enabled = False
+
+ @utils.check_messages("redefined-outer-name")
+ def visit_for(self, node):
+ assigned_to = [
+ var.name for var in node.target.nodes_of_class(astroid.AssignName)
+ ]
+
+ # Only check variables that are used
+ dummy_rgx = self.config.dummy_variables_rgx
+ assigned_to = [var for var in assigned_to if not dummy_rgx.match(var)]
+
+ for variable in assigned_to:
+ for outer_for, outer_variables in self._loop_variables:
+ if variable in outer_variables and not in_for_else_branch(
+ outer_for, node
+ ):
+ self.add_message(
+ "redefined-outer-name",
+ args=(variable, outer_for.fromlineno),
+ node=node,
+ )
+ break
+
+ self._loop_variables.append((node, assigned_to))
+
+ @utils.check_messages("redefined-outer-name")
+ def leave_for(self, node):
+ self._loop_variables.pop()
+ self._store_type_annotation_names(node)
+
+ def visit_module(self, node):
+ """visit module : update consumption analysis variable
+ checks globals doesn't overrides builtins
+ """
+ self._to_consume = [NamesConsumer(node, "module")]
+ self._postponed_evaluation_enabled = is_postponed_evaluation_enabled(node)
+
+ for name, stmts in node.locals.items():
+ if utils.is_builtin(name):
+ if self._should_ignore_redefined_builtin(stmts[0]) or name == "__doc__":
+ continue
+ self.add_message("redefined-builtin", args=name, node=stmts[0])
+
+ @utils.check_messages(
+ "unused-import",
+ "unused-wildcard-import",
+ "redefined-builtin",
+ "undefined-all-variable",
+ "invalid-all-object",
+ "invalid-all-format",
+ "unused-variable",
+ )
+ def leave_module(self, node):
+ """leave module: check globals"""
+ assert len(self._to_consume) == 1
+
+ self._check_metaclasses(node)
+ not_consumed = self._to_consume.pop().to_consume
+ # attempt to check for __all__ if defined
+ if "__all__" in node.locals:
+ self._check_all(node, not_consumed)
+
+ # check for unused globals
+ self._check_globals(not_consumed)
+
+ # don't check unused imports in __init__ files
+ if not self.config.init_import and node.package:
+ return
+
+ self._check_imports(not_consumed)
+
+ def visit_classdef(self, node):
+ """visit class: update consumption analysis variable"""
+ self._to_consume.append(NamesConsumer(node, "class"))
+
+ def leave_classdef(self, _):
+ """leave class: update consumption analysis variable"""
+ # do not check for not used locals here (no sense)
+ self._to_consume.pop()
+
+ def visit_lambda(self, node):
+ """visit lambda: update consumption analysis variable"""
+ self._to_consume.append(NamesConsumer(node, "lambda"))
+
+ def leave_lambda(self, _):
+ """leave lambda: update consumption analysis variable"""
+ # do not check for not used locals here
+ self._to_consume.pop()
+
+ def visit_generatorexp(self, node):
+ """visit genexpr: update consumption analysis variable"""
+ self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+ def leave_generatorexp(self, _):
+ """leave genexpr: update consumption analysis variable"""
+ # do not check for not used locals here
+ self._to_consume.pop()
+
+ def visit_dictcomp(self, node):
+ """visit dictcomp: update consumption analysis variable"""
+ self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+ def leave_dictcomp(self, _):
+ """leave dictcomp: update consumption analysis variable"""
+ # do not check for not used locals here
+ self._to_consume.pop()
+
+ def visit_setcomp(self, node):
+ """visit setcomp: update consumption analysis variable"""
+ self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+ def leave_setcomp(self, _):
+ """leave setcomp: update consumption analysis variable"""
+ # do not check for not used locals here
+ self._to_consume.pop()
+
+ def visit_functiondef(self, node):
+ """visit function: update consumption analysis variable and check locals"""
+ self._to_consume.append(NamesConsumer(node, "function"))
+ if not (
+ self.linter.is_message_enabled("redefined-outer-name")
+ or self.linter.is_message_enabled("redefined-builtin")
+ ):
+ return
+ globs = node.root().globals
+ for name, stmt in node.items():
+ if name in globs and not isinstance(stmt, astroid.Global):
+ definition = globs[name][0]
+ if (
+ isinstance(definition, astroid.ImportFrom)
+ and definition.modname == FUTURE
+ ):
+ # It is a __future__ directive, not a symbol.
+ continue
+
+ # Do not take in account redefined names for the purpose
+ # of type checking.:
+ if any(
+ isinstance(definition.parent, astroid.If)
+ and definition.parent.test.as_string() in TYPING_TYPE_CHECKS_GUARDS
+ for definition in globs[name]
+ ):
+ continue
+
+ line = definition.fromlineno
+ if not self._is_name_ignored(stmt, name):
+ self.add_message(
+ "redefined-outer-name", args=(name, line), node=stmt
+ )
+
+ elif (
+ utils.is_builtin(name)
+ and not self._allowed_redefined_builtin(name)
+ and not self._should_ignore_redefined_builtin(stmt)
+ ):
+ # do not print Redefining builtin for additional builtins
+ self.add_message("redefined-builtin", args=name, node=stmt)
+
+ def leave_functiondef(self, node):
+ """leave function: check function's locals are consumed"""
+ self._check_metaclasses(node)
+
+ if node.type_comment_returns:
+ self._store_type_annotation_node(node.type_comment_returns)
+ if node.type_comment_args:
+ for argument_annotation in node.type_comment_args:
+ self._store_type_annotation_node(argument_annotation)
+
+ not_consumed = self._to_consume.pop().to_consume
+ if not (
+ self.linter.is_message_enabled("unused-variable")
+ or self.linter.is_message_enabled("possibly-unused-variable")
+ or self.linter.is_message_enabled("unused-argument")
+ ):
+ return
+
+ # Don't check arguments of function which are only raising an exception.
+ if utils.is_error(node):
+ return
+
+ # Don't check arguments of abstract methods or within an interface.
+ is_method = node.is_method()
+ if is_method and node.is_abstract():
+ return
+
+ global_names = _flattened_scope_names(node.nodes_of_class(astroid.Global))
+ nonlocal_names = _flattened_scope_names(node.nodes_of_class(astroid.Nonlocal))
+ for name, stmts in not_consumed.items():
+ self._check_is_unused(name, node, stmts[0], global_names, nonlocal_names)
+
+ visit_asyncfunctiondef = visit_functiondef
+ leave_asyncfunctiondef = leave_functiondef
+
+ @utils.check_messages(
+ "global-variable-undefined",
+ "global-variable-not-assigned",
+ "global-statement",
+ "global-at-module-level",
+ "redefined-builtin",
+ )
+ def visit_global(self, node):
+ """check names imported exists in the global scope"""
+ frame = node.frame()
+ if isinstance(frame, astroid.Module):
+ self.add_message("global-at-module-level", node=node)
+ return
+
+ module = frame.root()
+ default_message = True
+ locals_ = node.scope().locals
+ for name in node.names:
+ try:
+ assign_nodes = module.getattr(name)
+ except astroid.NotFoundError:
+ # unassigned global, skip
+ assign_nodes = []
+
+ not_defined_locally_by_import = not any(
+ isinstance(local, astroid.node_classes.Import)
+ for local in locals_.get(name, ())
+ )
+ if not assign_nodes and not_defined_locally_by_import:
+ self.add_message("global-variable-not-assigned", args=name, node=node)
+ default_message = False
+ continue
+
+ for anode in assign_nodes:
+ if (
+ isinstance(anode, astroid.AssignName)
+ and anode.name in module.special_attributes
+ ):
+ self.add_message("redefined-builtin", args=name, node=node)
+ break
+ if anode.frame() is module:
+ # module level assignment
+ break
+ else:
+ if not_defined_locally_by_import:
+ # global undefined at the module scope
+ self.add_message("global-variable-undefined", args=name, node=node)
+ default_message = False
+
+ if default_message:
+ self.add_message("global-statement", node=node)
+
+ def visit_assignname(self, node):
+ if isinstance(node.assign_type(), astroid.AugAssign):
+ self.visit_name(node)
+
+ def visit_delname(self, node):
+ self.visit_name(node)
+
+ def visit_name(self, node):
+ """Check that a name is defined in the current scope"""
+ stmt = node.statement()
+ if stmt.fromlineno is None:
+ # name node from an astroid built from live code, skip
+ assert not stmt.root().file.endswith(".py")
+ return
+
+ name = node.name
+ frame = stmt.scope()
+ start_index = len(self._to_consume) - 1
+
+ undefined_variable_is_enabled = self.linter.is_message_enabled(
+ "undefined-variable"
+ )
+ used_before_assignment_is_enabled = self.linter.is_message_enabled(
+ "used-before-assignment"
+ )
+
+ # iterates through parent scopes, from the inner to the outer
+ base_scope_type = self._to_consume[start_index].scope_type
+ # pylint: disable=too-many-nested-blocks; refactoring this block is a pain.
+ for i in range(start_index, -1, -1):
+ current_consumer = self._to_consume[i]
+
+ # The list of base classes in the class definition is not part
+ # of the class body.
+ # If the current scope is a class scope but it's not the inner
+ # scope, ignore it. This prevents to access this scope instead of
+ # the globals one in function members when there are some common
+ # names.
+ if current_consumer.scope_type == "class" and (
+ utils.is_ancestor_name(current_consumer.node, node)
+ or (i != start_index and self._ignore_class_scope(node))
+ ):
+ continue
+
+ # Ignore inner class scope for keywords in class definition
+ if (
+ current_consumer.scope_type == "class"
+ and isinstance(node.parent, astroid.Keyword)
+ and isinstance(node.parent.parent, astroid.ClassDef)
+ ):
+ continue
+
+ # if the name node is used as a function default argument's value or as
+ # a decorator, then start from the parent frame of the function instead
+ # of the function frame - and thus open an inner class scope
+ if (
+ current_consumer.scope_type == "function"
+ and self._defined_in_function_definition(node, current_consumer.node)
+ ):
+ # ignore function scope if is an annotation/default/decorator, as not in the body
+ continue
+
+ if current_consumer.scope_type == "lambda" and utils.is_default_argument(
+ node, current_consumer.node
+ ):
+ continue
+
+ # the name has already been consumed, only check it's not a loop
+ # variable used outside the loop
+ # avoid the case where there are homonyms inside function scope and
+ # comprehension current scope (avoid bug #1731)
+ if name in current_consumer.consumed and not (
+ current_consumer.scope_type == "comprehension"
+ and self._has_homonym_in_upper_function_scope(node, i)
+ ):
+ defnode = utils.assign_parent(current_consumer.consumed[name][0])
+ self._check_late_binding_closure(node, defnode)
+ self._loopvar_name(node, name)
+ break
+
+ found_node = current_consumer.get_next_to_consume(node)
+ if found_node is None:
+ continue
+
+ # checks for use before assignment
+ defnode = utils.assign_parent(current_consumer.to_consume[name][0])
+
+ if (
+ undefined_variable_is_enabled or used_before_assignment_is_enabled
+ ) and defnode is not None:
+ self._check_late_binding_closure(node, defnode)
+ defstmt = defnode.statement()
+ defframe = defstmt.frame()
+ # The class reuses itself in the class scope.
+ recursive_klass = (
+ frame is defframe
+ and defframe.parent_of(node)
+ and isinstance(defframe, astroid.ClassDef)
+ and node.name == defframe.name
+ )
+
+ if (
+ recursive_klass
+ and utils.is_inside_lambda(node)
+ and (
+ not utils.is_default_argument(node)
+ or node.scope().parent.scope() is not defframe
+ )
+ ):
+ # Self-referential class references are fine in lambda's --
+ # As long as they are not part of the default argument directly
+ # under the scope of the parent self-referring class.
+ # Example of valid default argument:
+ # class MyName3:
+ # myattr = 1
+ # mylambda3 = lambda: lambda a=MyName3: a
+ # Example of invalid default argument:
+ # class MyName4:
+ # myattr = 1
+ # mylambda4 = lambda a=MyName4: lambda: a
+
+ # If the above conditional is True,
+ # there is no possibility of undefined-variable
+ # Also do not consume class name
+ # (since consuming blocks subsequent checks)
+ # -- quit
+ break
+
+ (
+ maybee0601,
+ annotation_return,
+ use_outer_definition,
+ ) = self._is_variable_violation(
+ node,
+ name,
+ defnode,
+ stmt,
+ defstmt,
+ frame,
+ defframe,
+ base_scope_type,
+ recursive_klass,
+ )
+
+ if use_outer_definition:
+ continue
+
+ if (
+ maybee0601
+ and not utils.is_defined_before(node)
+ and not astroid.are_exclusive(stmt, defstmt, ("NameError",))
+ ):
+
+ # Used and defined in the same place, e.g `x += 1` and `del x`
+ defined_by_stmt = defstmt is stmt and isinstance(
+ node, (astroid.DelName, astroid.AssignName)
+ )
+ if (
+ recursive_klass
+ or defined_by_stmt
+ or annotation_return
+ or isinstance(defstmt, astroid.Delete)
+ ):
+ if not utils.node_ignores_exception(node, NameError):
+
+ # Handle postponed evaluation of annotations
+ if not (
+ self._postponed_evaluation_enabled
+ and isinstance(
+ stmt,
+ (
+ astroid.AnnAssign,
+ astroid.FunctionDef,
+ astroid.Arguments,
+ ),
+ )
+ and name in node.root().locals
+ ):
+ self.add_message(
+ "undefined-variable", args=name, node=node
+ )
+ elif base_scope_type != "lambda":
+ # E0601 may *not* occurs in lambda scope.
+
+ # Handle postponed evaluation of annotations
+ if not (
+ self._postponed_evaluation_enabled
+ and isinstance(
+ stmt, (astroid.AnnAssign, astroid.FunctionDef)
+ )
+ ):
+ self.add_message(
+ "used-before-assignment", args=name, node=node
+ )
+ elif base_scope_type == "lambda":
+ # E0601 can occur in class-level scope in lambdas, as in
+ # the following example:
+ # class A:
+ # x = lambda attr: f + attr
+ # f = 42
+ if isinstance(frame, astroid.ClassDef) and name in frame.locals:
+ if isinstance(node.parent, astroid.Arguments):
+ if stmt.fromlineno <= defstmt.fromlineno:
+ # Doing the following is fine:
+ # class A:
+ # x = 42
+ # y = lambda attr=x: attr
+ self.add_message(
+ "used-before-assignment", args=name, node=node
+ )
+ else:
+ self.add_message(
+ "undefined-variable", args=name, node=node
+ )
+ elif current_consumer.scope_type == "lambda":
+ self.add_message("undefined-variable", node=node, args=name)
+
+ current_consumer.mark_as_consumed(name, found_node)
+ # check it's not a loop variable used outside the loop
+ self._loopvar_name(node, name)
+ break
+ else:
+ # we have not found the name, if it isn't a builtin, that's an
+ # undefined name !
+ if undefined_variable_is_enabled and not (
+ name in astroid.Module.scope_attrs
+ or utils.is_builtin(name)
+ or name in self.config.additional_builtins
+ or (
+ name == "__class__"
+ and isinstance(frame, astroid.FunctionDef)
+ and frame.is_method()
+ )
+ ):
+ if not utils.node_ignores_exception(node, NameError):
+ self.add_message("undefined-variable", args=name, node=node)
+
+ @utils.check_messages("no-name-in-module")
+ def visit_import(self, node):
+ """check modules attribute accesses"""
+ if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
+ # No need to verify this, since ImportError is already
+ # handled by the client code.
+ return
+
+ for name, _ in node.names:
+ parts = name.split(".")
+ try:
+ module = next(_infer_name_module(node, parts[0]))
+ except astroid.ResolveError:
+ continue
+ if not isinstance(module, astroid.Module):
+ continue
+ self._check_module_attrs(node, module, parts[1:])
+
+ @utils.check_messages("no-name-in-module")
+ def visit_importfrom(self, node):
+ """check modules attribute accesses"""
+ if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
+ # No need to verify this, since ImportError is already
+ # handled by the client code.
+ return
+
+ name_parts = node.modname.split(".")
+ try:
+ module = node.do_import_module(name_parts[0])
+ except astroid.AstroidBuildingException:
+ return
+ module = self._check_module_attrs(node, module, name_parts[1:])
+ if not module:
+ return
+ for name, _ in node.names:
+ if name == "*":
+ continue
+ self._check_module_attrs(node, module, name.split("."))
+
+ @utils.check_messages(
+ "unbalanced-tuple-unpacking", "unpacking-non-sequence", "self-cls-assignment"
+ )
+ def visit_assign(self, node):
+ """Check unbalanced tuple unpacking for assignments
+ and unpacking non-sequences as well as in case self/cls
+ get assigned.
+ """
+ self._check_self_cls_assign(node)
+ if not isinstance(node.targets[0], (astroid.Tuple, astroid.List)):
+ return
+
+ targets = node.targets[0].itered()
+ try:
+ inferred = utils.safe_infer(node.value)
+ if inferred is not None:
+ self._check_unpacking(inferred, node, targets)
+ except astroid.InferenceError:
+ return
+
+ # listcomp have now also their scope
+ def visit_listcomp(self, node):
+ """visit dictcomp: update consumption analysis variable"""
+ self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+ def leave_listcomp(self, _):
+ """leave dictcomp: update consumption analysis variable"""
+ # do not check for not used locals here
+ self._to_consume.pop()
+
+ def leave_assign(self, node):
+ self._store_type_annotation_names(node)
+
+ def leave_with(self, node):
+ self._store_type_annotation_names(node)
+
+ def visit_arguments(self, node):
+ for annotation in node.type_comment_args:
+ self._store_type_annotation_node(annotation)
+
+ # Relying on other checker's options, which might not have been initialized yet.
+ @astroid.decorators.cachedproperty
+ def _analyse_fallback_blocks(self):
+ return get_global_option(self, "analyse-fallback-blocks", default=False)
+
+ @astroid.decorators.cachedproperty
+ def _ignored_modules(self):
+ return get_global_option(self, "ignored-modules", default=[])
+
+ @astroid.decorators.cachedproperty
+ def _allow_global_unused_variables(self):
+ return get_global_option(self, "allow-global-unused-variables", default=True)
+
+ @staticmethod
+ def _defined_in_function_definition(node, frame):
+ in_annotation_or_default_or_decorator = False
+ if isinstance(frame, astroid.FunctionDef) and node.statement() is frame:
+ in_annotation_or_default_or_decorator = (
+ (
+ node in frame.args.annotations
+ or node in frame.args.posonlyargs_annotations
+ or node in frame.args.kwonlyargs_annotations
+ or node is frame.args.varargannotation
+ or node is frame.args.kwargannotation
+ )
+ or frame.args.parent_of(node)
+ or (frame.decorators and frame.decorators.parent_of(node))
+ or (
+ frame.returns
+ and (node is frame.returns or frame.returns.parent_of(node))
+ )
+ )
+ return in_annotation_or_default_or_decorator
+
+ @staticmethod
+ def _in_lambda_or_comprehension_body(
+ node: astroid.node_classes.NodeNG, frame: astroid.node_classes.NodeNG
+ ) -> bool:
+ """return True if node within a lambda/comprehension body (or similar) and thus should not have access to class attributes in frame"""
+ child = node
+ parent = node.parent
+ while parent is not None:
+ if parent is frame:
+ return False
+ if isinstance(parent, astroid.Lambda) and child is not parent.args:
+ # Body of lambda should not have access to class attributes.
+ return True
+ if (
+ isinstance(parent, astroid.node_classes.Comprehension)
+ and child is not parent.iter
+ ):
+ # Only iter of list/set/dict/generator comprehension should have access.
+ return True
+ if isinstance(parent, astroid.scoped_nodes.ComprehensionScope) and not (
+ parent.generators and child is parent.generators[0]
+ ):
+ # Body of list/set/dict/generator comprehension should not have access to class attributes.
+ # Furthermore, only the first generator (if multiple) in comprehension should have access.
+ return True
+ child = parent
+ parent = parent.parent
+ return False
+
+ @staticmethod
+ def _is_variable_violation(
+ node,
+ name,
+ defnode,
+ stmt,
+ defstmt,
+ frame,
+ defframe,
+ base_scope_type,
+ recursive_klass,
+ ):
+ # pylint: disable=too-many-nested-blocks
+ # node: Node to check for violation
+ # name: name of node to check violation for
+ # frame: Scope of statement of node
+ # base_scope_type: local scope type
+ maybee0601 = True
+ annotation_return = False
+ use_outer_definition = False
+ if frame is not defframe:
+ maybee0601 = _detect_global_scope(node, frame, defframe)
+ elif defframe.parent is None:
+ # we are at the module level, check the name is not
+ # defined in builtins
+ if name in defframe.scope_attrs or astroid.builtin_lookup(name)[1]:
+ maybee0601 = False
+ else:
+ # we are in a local scope, check the name is not
+ # defined in global or builtin scope
+ # skip this lookup if name is assigned later in function scope/lambda
+ # Note: the node.frame() is not the same as the `frame` argument which is
+ # equivalent to frame.statement().scope()
+ forbid_lookup = (
+ isinstance(frame, astroid.FunctionDef)
+ or isinstance(node.frame(), astroid.Lambda)
+ ) and _assigned_locally(node)
+ if not forbid_lookup and defframe.root().lookup(name)[1]:
+ maybee0601 = False
+ use_outer_definition = stmt == defstmt and not isinstance(
+ defnode, astroid.node_classes.Comprehension
+ )
+ # check if we have a nonlocal
+ elif name in defframe.locals:
+ maybee0601 = not any(
+ isinstance(child, astroid.Nonlocal) and name in child.names
+ for child in defframe.get_children()
+ )
+
+ if (
+ base_scope_type == "lambda"
+ and isinstance(frame, astroid.ClassDef)
+ and name in frame.locals
+ ):
+
+ # This rule verifies that if the definition node of the
+ # checked name is an Arguments node and if the name
+ # is used a default value in the arguments defaults
+ # and the actual definition of the variable label
+ # is happening before the Arguments definition.
+ #
+ # bar = None
+ # foo = lambda bar=bar: bar
+ #
+ # In this case, maybee0601 should be False, otherwise
+ # it should be True.
+ maybee0601 = not (
+ isinstance(defnode, astroid.Arguments)
+ and node in defnode.defaults
+ and frame.locals[name][0].fromlineno < defstmt.fromlineno
+ )
+ elif isinstance(defframe, astroid.ClassDef) and isinstance(
+ frame, astroid.FunctionDef
+ ):
+ # Special rule for function return annotations,
+ # which uses the same name as the class where
+ # the function lives.
+ if node is frame.returns and defframe.parent_of(frame.returns):
+ maybee0601 = annotation_return = True
+
+ if (
+ maybee0601
+ and defframe.name in defframe.locals
+ and defframe.locals[name][0].lineno < frame.lineno
+ ):
+ # Detect class assignments with the same
+ # name as the class. In this case, no warning
+ # should be raised.
+ maybee0601 = False
+ if isinstance(node.parent, astroid.Arguments):
+ maybee0601 = stmt.fromlineno <= defstmt.fromlineno
+ elif recursive_klass:
+ maybee0601 = True
+ else:
+ maybee0601 = maybee0601 and stmt.fromlineno <= defstmt.fromlineno
+ if maybee0601 and stmt.fromlineno == defstmt.fromlineno:
+ if (
+ isinstance(defframe, astroid.FunctionDef)
+ and frame is defframe
+ and defframe.parent_of(node)
+ and stmt is not defstmt
+ ):
+ # Single statement function, with the statement on the
+ # same line as the function definition
+ maybee0601 = False
+ elif (
+ isinstance(
+ defstmt,
+ (
+ astroid.Assign,
+ astroid.AnnAssign,
+ astroid.AugAssign,
+ astroid.Expr,
+ ),
+ )
+ and isinstance(defstmt.value, astroid.IfExp)
+ and frame is defframe
+ and defframe.parent_of(node)
+ and stmt is defstmt
+ ):
+ # Single statement if, with assingment expression on same
+ # line as assigment
+ # x = b if (b := True) else False
+ maybee0601 = False
+ elif (
+ isinstance( # pylint: disable=too-many-boolean-expressions
+ defnode, astroid.NamedExpr
+ )
+ and frame is defframe
+ and defframe.parent_of(stmt)
+ and stmt is defstmt
+ and (
+ (
+ defnode.lineno == node.lineno
+ and defnode.col_offset < node.col_offset
+ )
+ or (defnode.lineno < node.lineno)
+ or (
+ # Issue in the `ast` module until py39
+ # Nodes in a multiline string have the same lineno
+ # Could be false-positive without check
+ not PY39_PLUS
+ and defnode.lineno == node.lineno
+ and isinstance(
+ defstmt,
+ (
+ astroid.Assign,
+ astroid.AnnAssign,
+ astroid.AugAssign,
+ astroid.Return,
+ ),
+ )
+ and isinstance(defstmt.value, astroid.JoinedStr)
+ )
+ )
+ ):
+ # Expressions, with assignment expressions
+ # Use only after assignment
+ # b = (c := 2) and c
+ maybee0601 = False
+
+ # Look for type checking definitions inside a type checking guard.
+ if isinstance(defstmt, (astroid.Import, astroid.ImportFrom)):
+ defstmt_parent = defstmt.parent
+
+ if (
+ isinstance(defstmt_parent, astroid.If)
+ and defstmt_parent.test.as_string() in TYPING_TYPE_CHECKS_GUARDS
+ ):
+ # Exempt those definitions that are used inside the type checking
+ # guard or that are defined in both type checking guard branches.
+ used_in_branch = defstmt_parent.parent_of(node)
+ defined_in_or_else = False
+
+ for definition in defstmt_parent.orelse:
+ if isinstance(definition, astroid.Assign):
+ defined_in_or_else = any(
+ target.name == name for target in definition.targets
+ )
+ if defined_in_or_else:
+ break
+
+ if not used_in_branch and not defined_in_or_else:
+ maybee0601 = True
+
+ return maybee0601, annotation_return, use_outer_definition
+
+ def _ignore_class_scope(self, node):
+ """
+ Return True if the node is in a local class scope, as an assignment.
+
+ :param node: Node considered
+ :type node: astroid.Node
+ :return: True if the node is in a local class scope, as an assignment. False otherwise.
+ :rtype: bool
+ """
+ # Detect if we are in a local class scope, as an assignment.
+ # For example, the following is fair game.
+ #
+ # class A:
+ # b = 1
+ # c = lambda b=b: b * b
+ #
+ # class B:
+ # tp = 1
+ # def func(self, arg: tp):
+ # ...
+ # class C:
+ # tp = 2
+ # def func(self, arg=tp):
+ # ...
+ # class C:
+ # class Tp:
+ # pass
+ # class D(Tp):
+ # ...
+
+ name = node.name
+ frame = node.statement().scope()
+ in_annotation_or_default_or_decorator = self._defined_in_function_definition(
+ node, frame
+ )
+ in_ancestor_list = utils.is_ancestor_name(frame, node)
+ if in_annotation_or_default_or_decorator or in_ancestor_list:
+ frame_locals = frame.parent.scope().locals
+ else:
+ frame_locals = frame.locals
+ return not (
+ (
+ isinstance(frame, astroid.ClassDef)
+ or in_annotation_or_default_or_decorator
+ )
+ and not self._in_lambda_or_comprehension_body(node, frame)
+ and name in frame_locals
+ )
+
+ def _loopvar_name(self, node, name):
+ # filter variables according to node's scope
+ if not self.linter.is_message_enabled("undefined-loop-variable"):
+ return
+ astmts = [stmt for stmt in node.lookup(name)[1] if hasattr(stmt, "assign_type")]
+ # If this variable usage exists inside a function definition
+ # that exists in the same loop,
+ # the usage is safe because the function will not be defined either if
+ # the variable is not defined.
+ scope = node.scope()
+ if isinstance(scope, astroid.FunctionDef) and any(
+ asmt.statement().parent_of(scope) for asmt in astmts
+ ):
+ return
+
+ # filter variables according their respective scope test is_statement
+ # and parent to avoid #74747. This is not a total fix, which would
+ # introduce a mechanism similar to special attribute lookup in
+ # modules. Also, in order to get correct inference in this case, the
+ # scope lookup rules would need to be changed to return the initial
+ # assignment (which does not exist in code per se) as well as any later
+ # modifications.
+ if (
+ not astmts
+ or (astmts[0].is_statement or astmts[0].parent)
+ and astmts[0].statement().parent_of(node)
+ ):
+ _astmts = []
+ else:
+ _astmts = astmts[:1]
+ for i, stmt in enumerate(astmts[1:]):
+ if astmts[i].statement().parent_of(stmt) and not in_for_else_branch(
+ astmts[i].statement(), stmt
+ ):
+ continue
+ _astmts.append(stmt)
+ astmts = _astmts
+ if len(astmts) != 1:
+ return
+
+ assign = astmts[0].assign_type()
+ if not (
+ isinstance(
+ assign, (astroid.For, astroid.Comprehension, astroid.GeneratorExp)
+ )
+ and assign.statement() is not node.statement()
+ ):
+ return
+
+ # For functions we can do more by inferring the length of the itered object
+ if not isinstance(assign, astroid.For):
+ self.add_message("undefined-loop-variable", args=name, node=node)
+ return
+
+ try:
+ inferred = next(assign.iter.infer())
+ except astroid.InferenceError:
+ self.add_message("undefined-loop-variable", args=name, node=node)
+ else:
+ if (
+ isinstance(inferred, astroid.Instance)
+ and inferred.qname() == BUILTIN_RANGE
+ ):
+ # Consider range() objects safe, even if they might not yield any results.
+ return
+
+ # Consider sequences.
+ sequences = (
+ astroid.List,
+ astroid.Tuple,
+ astroid.Dict,
+ astroid.Set,
+ astroid.objects.FrozenSet,
+ )
+ if not isinstance(inferred, sequences):
+ self.add_message("undefined-loop-variable", args=name, node=node)
+ return
+
+ elements = getattr(inferred, "elts", getattr(inferred, "items", []))
+ if not elements:
+ self.add_message("undefined-loop-variable", args=name, node=node)
+
+ def _check_is_unused(self, name, node, stmt, global_names, nonlocal_names):
+ # pylint: disable=too-many-branches
+ # Ignore some special names specified by user configuration.
+ if self._is_name_ignored(stmt, name):
+ return
+ # Ignore names that were added dynamically to the Function scope
+ if (
+ isinstance(node, astroid.FunctionDef)
+ and name == "__class__"
+ and len(node.locals["__class__"]) == 1
+ and isinstance(node.locals["__class__"][0], astroid.ClassDef)
+ ):
+ return
+
+ # Ignore names imported by the global statement.
+ if isinstance(stmt, (astroid.Global, astroid.Import, astroid.ImportFrom)):
+ # Detect imports, assigned to global statements.
+ if global_names and _import_name_is_global(stmt, global_names):
+ return
+
+ argnames = list(
+ itertools.chain(node.argnames(), [arg.name for arg in node.args.kwonlyargs])
+ )
+ # Care about functions with unknown argument (builtins)
+ if name in argnames:
+ self._check_unused_arguments(name, node, stmt, argnames)
+ else:
+ if stmt.parent and isinstance(
+ stmt.parent, (astroid.Assign, astroid.AnnAssign)
+ ):
+ if name in nonlocal_names:
+ return
+
+ qname = asname = None
+ if isinstance(stmt, (astroid.Import, astroid.ImportFrom)):
+ # Need the complete name, which we don't have in .locals.
+ if len(stmt.names) > 1:
+ import_names = next(
+ (names for names in stmt.names if name in names), None
+ )
+ else:
+ import_names = stmt.names[0]
+ if import_names:
+ qname, asname = import_names
+ name = asname or qname
+
+ if _has_locals_call_after_node(stmt, node.scope()):
+ message_name = "possibly-unused-variable"
+ else:
+ if isinstance(stmt, astroid.Import):
+ if asname is not None:
+ msg = f"{qname} imported as {asname}"
+ else:
+ msg = "import %s" % name
+ self.add_message("unused-import", args=msg, node=stmt)
+ return
+ if isinstance(stmt, astroid.ImportFrom):
+ if asname is not None:
+ msg = f"{qname} imported from {stmt.modname} as {asname}"
+ else:
+ msg = f"{name} imported from {stmt.modname}"
+ self.add_message("unused-import", args=msg, node=stmt)
+ return
+ message_name = "unused-variable"
+
+ if isinstance(stmt, astroid.FunctionDef) and stmt.decorators:
+ return
+
+ # Don't check function stubs created only for type information
+ if utils.is_overload_stub(node):
+ return
+
+ self.add_message(message_name, args=name, node=stmt)
+
+ def _is_name_ignored(self, stmt, name):
+ authorized_rgx = self.config.dummy_variables_rgx
+ if (
+ isinstance(stmt, astroid.AssignName)
+ and isinstance(stmt.parent, astroid.Arguments)
+ or isinstance(stmt, astroid.Arguments)
+ ):
+ regex = self.config.ignored_argument_names
+ else:
+ regex = authorized_rgx
+ return regex and regex.match(name)
+
+ def _check_unused_arguments(self, name, node, stmt, argnames):
+ is_method = node.is_method()
+ klass = node.parent.frame()
+ if is_method and isinstance(klass, astroid.ClassDef):
+ confidence = (
+ INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
+ )
+ else:
+ confidence = HIGH
+
+ if is_method:
+ # Don't warn for the first argument of a (non static) method
+ if node.type != "staticmethod" and name == argnames[0]:
+ return
+ # Don't warn for argument of an overridden method
+ overridden = overridden_method(klass, node.name)
+ if overridden is not None and name in overridden.argnames():
+ return
+ if node.name in utils.PYMETHODS and node.name not in (
+ "__init__",
+ "__new__",
+ ):
+ return
+ # Don't check callback arguments
+ if any(
+ node.name.startswith(cb) or node.name.endswith(cb)
+ for cb in self.config.callbacks
+ ):
+ return
+ # Don't check arguments of singledispatch.register function.
+ if utils.is_registered_in_singledispatch_function(node):
+ return
+
+ # Don't check function stubs created only for type information
+ if utils.is_overload_stub(node):
+ return
+
+ # Don't check protocol classes
+ if utils.is_protocol_class(klass):
+ return
+
+ self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
+
+ def _check_late_binding_closure(self, node, assignment_node):
+ if not self.linter.is_message_enabled("cell-var-from-loop"):
+ return
+
+ def _is_direct_lambda_call():
+ return (
+ isinstance(node_scope.parent, astroid.Call)
+ and node_scope.parent.func is node_scope
+ )
+
+ node_scope = node.scope()
+ if not isinstance(node_scope, (astroid.Lambda, astroid.FunctionDef)):
+ return
+ if isinstance(node.parent, astroid.Arguments):
+ return
+
+ if isinstance(assignment_node, astroid.Comprehension):
+ if assignment_node.parent.parent_of(node.scope()):
+ self.add_message("cell-var-from-loop", node=node, args=node.name)
+ else:
+ assign_scope = assignment_node.scope()
+ maybe_for = assignment_node
+ while maybe_for and not isinstance(maybe_for, astroid.For):
+ if maybe_for is assign_scope:
+ break
+ maybe_for = maybe_for.parent
+ else:
+ if (
+ maybe_for
+ and maybe_for.parent_of(node_scope)
+ and not _is_direct_lambda_call()
+ and not isinstance(node_scope.statement(), astroid.Return)
+ ):
+ self.add_message("cell-var-from-loop", node=node, args=node.name)
+
+ def _should_ignore_redefined_builtin(self, stmt):
+ if not isinstance(stmt, astroid.ImportFrom):
+ return False
+ return stmt.modname in self.config.redefining_builtins_modules
+
+ def _allowed_redefined_builtin(self, name):
+ return name in self.config.allowed_redefined_builtins
+
+ def _has_homonym_in_upper_function_scope(self, node, index):
+ """
+ Return True if there is a node with the same name in the to_consume dict of an upper scope
+ and if that scope is a function
+
+ :param node: node to check for
+ :type node: astroid.Node
+ :param index: index of the current consumer inside self._to_consume
+ :type index: int
+ :return: True if there is a node with the same name in the to_consume dict of an upper scope
+ and if that scope is a function
+ :rtype: bool
+ """
+ for _consumer in self._to_consume[index - 1 :: -1]:
+ if _consumer.scope_type == "function" and node.name in _consumer.to_consume:
+ return True
+ return False
+
+ def _store_type_annotation_node(self, type_annotation):
+ """Given a type annotation, store all the name nodes it refers to"""
+ if isinstance(type_annotation, astroid.Name):
+ self._type_annotation_names.append(type_annotation.name)
+ return
+
+ if not isinstance(type_annotation, astroid.Subscript):
+ return
+
+ if (
+ isinstance(type_annotation.value, astroid.Attribute)
+ and isinstance(type_annotation.value.expr, astroid.Name)
+ and type_annotation.value.expr.name == TYPING_MODULE
+ ):
+ self._type_annotation_names.append(TYPING_MODULE)
+ return
+
+ self._type_annotation_names.extend(
+ annotation.name
+ for annotation in type_annotation.nodes_of_class(astroid.Name)
+ )
+
+ def _store_type_annotation_names(self, node):
+ type_annotation = node.type_annotation
+ if not type_annotation:
+ return
+ self._store_type_annotation_node(node.type_annotation)
+
+ def _check_self_cls_assign(self, node):
+ """Check that self/cls don't get assigned"""
+ assign_names = {
+ target.name
+ for target in node.targets
+ if isinstance(target, astroid.AssignName)
+ }
+ scope = node.scope()
+ nonlocals_with_same_name = any(
+ child
+ for child in scope.body
+ if isinstance(child, astroid.Nonlocal) and assign_names & set(child.names)
+ )
+ if nonlocals_with_same_name:
+ scope = node.scope().parent.scope()
+
+ if not (
+ isinstance(scope, astroid.scoped_nodes.FunctionDef)
+ and scope.is_method()
+ and "builtins.staticmethod" not in scope.decoratornames()
+ ):
+ return
+ argument_names = scope.argnames()
+ if not argument_names:
+ return
+ self_cls_name = argument_names[0]
+ target_assign_names = (
+ target.name
+ for target in node.targets
+ if isinstance(target, astroid.node_classes.AssignName)
+ )
+ if self_cls_name in target_assign_names:
+ self.add_message("self-cls-assignment", node=node, args=(self_cls_name,))
+
+ def _check_unpacking(self, inferred, node, targets):
+ """Check for unbalanced tuple unpacking
+ and unpacking non sequences.
+ """
+ if utils.is_inside_abstract_class(node):
+ return
+ if utils.is_comprehension(node):
+ return
+ if inferred is astroid.Uninferable:
+ return
+ if (
+ isinstance(inferred.parent, astroid.Arguments)
+ and isinstance(node.value, astroid.Name)
+ and node.value.name == inferred.parent.vararg
+ ):
+ # Variable-length argument, we can't determine the length.
+ return
+ if isinstance(inferred, (astroid.Tuple, astroid.List)):
+ # attempt to check unpacking is properly balanced
+ values = inferred.itered()
+ if len(targets) != len(values):
+ # Check if we have starred nodes.
+ if any(isinstance(target, astroid.Starred) for target in targets):
+ return
+ self.add_message(
+ "unbalanced-tuple-unpacking",
+ node=node,
+ args=(
+ _get_unpacking_extra_info(node, inferred),
+ len(targets),
+ len(values),
+ ),
+ )
+ # attempt to check unpacking may be possible (ie RHS is iterable)
+ elif not utils.is_iterable(inferred):
+ self.add_message(
+ "unpacking-non-sequence",
+ node=node,
+ args=(_get_unpacking_extra_info(node, inferred),),
+ )
+
+ def _check_module_attrs(self, node, module, module_names):
+ """check that module_names (list of string) are accessible through the
+ given module
+ if the latest access name corresponds to a module, return it
+ """
+ while module_names:
+ name = module_names.pop(0)
+ if name == "__dict__":
+ module = None
+ break
+ try:
+ module = next(module.getattr(name)[0].infer())
+ if module is astroid.Uninferable:
+ return None
+ except astroid.NotFoundError:
+ if module.name in self._ignored_modules:
+ return None
+ self.add_message(
+ "no-name-in-module", args=(name, module.name), node=node
+ )
+ return None
+ except astroid.InferenceError:
+ return None
+ if module_names:
+ modname = module.name if module else "__dict__"
+ self.add_message(
+ "no-name-in-module", node=node, args=(".".join(module_names), modname)
+ )
+ return None
+ if isinstance(module, astroid.Module):
+ return module
+ return None
+
+ def _check_all(self, node, not_consumed):
+ assigned = next(node.igetattr("__all__"))
+ if assigned is astroid.Uninferable:
+ return
+
+ if not isinstance(assigned, (astroid.Tuple, astroid.List)):
+ self.add_message("invalid-all-format", node=assigned)
+ return
+
+ for elt in getattr(assigned, "elts", ()):
+ try:
+ elt_name = next(elt.infer())
+ except astroid.InferenceError:
+ continue
+ if elt_name is astroid.Uninferable:
+ continue
+ if not elt_name.parent:
+ continue
+
+ if not isinstance(elt_name, astroid.Const) or not isinstance(
+ elt_name.value, str
+ ):
+ self.add_message("invalid-all-object", args=elt.as_string(), node=elt)
+ continue
+
+ elt_name = elt_name.value
+ # If elt is in not_consumed, remove it from not_consumed
+ if elt_name in not_consumed:
+ del not_consumed[elt_name]
+ continue
+
+ if elt_name not in node.locals:
+ if not node.package:
+ self.add_message(
+ "undefined-all-variable", args=(elt_name,), node=elt
+ )
+ else:
+ basename = os.path.splitext(node.file)[0]
+ if os.path.basename(basename) == "__init__":
+ name = node.name + "." + elt_name
+ try:
+ astroid.modutils.file_from_modpath(name.split("."))
+ except ImportError:
+ self.add_message(
+ "undefined-all-variable", args=(elt_name,), node=elt
+ )
+ except SyntaxError:
+ # don't yield a syntax-error warning,
+ # because it will be later yielded
+ # when the file will be checked
+ pass
+
+ def _check_globals(self, not_consumed):
+ if self._allow_global_unused_variables:
+ return
+ for name, nodes in not_consumed.items():
+ for node in nodes:
+ self.add_message("unused-variable", args=(name,), node=node)
+
+ def _check_imports(self, not_consumed):
+ local_names = _fix_dot_imports(not_consumed)
+ checked = set()
+ for name, stmt in local_names:
+ for imports in stmt.names:
+ real_name = imported_name = imports[0]
+ if imported_name == "*":
+ real_name = name
+ as_name = imports[1]
+ if real_name in checked:
+ continue
+ if name not in (real_name, as_name):
+ continue
+ checked.add(real_name)
+
+ is_type_annotation_import = (
+ imported_name in self._type_annotation_names
+ or as_name in self._type_annotation_names
+ )
+ if isinstance(stmt, astroid.Import) or (
+ isinstance(stmt, astroid.ImportFrom) and not stmt.modname
+ ):
+ if isinstance(stmt, astroid.ImportFrom) and SPECIAL_OBJ.search(
+ imported_name
+ ):
+ # Filter special objects (__doc__, __all__) etc.,
+ # because they can be imported for exporting.
+ continue
+
+ if is_type_annotation_import:
+ # Most likely a typing import if it wasn't used so far.
+ continue
+
+ if as_name == "_":
+ continue
+ if as_name is None:
+ msg = "import %s" % imported_name
+ else:
+ msg = f"{imported_name} imported as {as_name}"
+ if not _is_type_checking_import(stmt):
+ self.add_message("unused-import", args=msg, node=stmt)
+ elif isinstance(stmt, astroid.ImportFrom) and stmt.modname != FUTURE:
+ if SPECIAL_OBJ.search(imported_name):
+ # Filter special objects (__doc__, __all__) etc.,
+ # because they can be imported for exporting.
+ continue
+
+ if _is_from_future_import(stmt, name):
+ # Check if the name is in fact loaded from a
+ # __future__ import in another module.
+ continue
+
+ if is_type_annotation_import:
+ # Most likely a typing import if it wasn't used so far.
+ continue
+
+ if imported_name == "*":
+ self.add_message("unused-wildcard-import", args=name, node=stmt)
+ else:
+ if as_name is None:
+ msg = f"{imported_name} imported from {stmt.modname}"
+ else:
+ fields = (imported_name, stmt.modname, as_name)
+ msg = "%s imported from %s as %s" % fields
+ if not _is_type_checking_import(stmt):
+ self.add_message("unused-import", args=msg, node=stmt)
+ del self._to_consume
+
+ def _check_metaclasses(self, node):
+ """Update consumption analysis for metaclasses."""
+ consumed = [] # [(scope_locals, consumed_key)]
+
+ for child_node in node.get_children():
+ if isinstance(child_node, astroid.ClassDef):
+ consumed.extend(self._check_classdef_metaclasses(child_node, node))
+
+ # Pop the consumed items, in order to avoid having
+ # unused-import and unused-variable false positives
+ for scope_locals, name in consumed:
+ scope_locals.pop(name, None)
+
+ def _check_classdef_metaclasses(self, klass, parent_node):
+ if not klass._metaclass:
+ # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
+ return []
+
+ consumed = [] # [(scope_locals, consumed_key)]
+ metaclass = klass.metaclass()
+
+ name = None
+ if isinstance(klass._metaclass, astroid.Name):
+ name = klass._metaclass.name
+ elif isinstance(klass._metaclass, astroid.Attribute) and klass._metaclass.expr:
+ attr = klass._metaclass.expr
+ while not isinstance(attr, astroid.Name):
+ attr = attr.expr
+ name = attr.name
+ elif metaclass:
+ name = metaclass.root().name
+
+ found = None
+ name = METACLASS_NAME_TRANSFORMS.get(name, name)
+ if name:
+ # check enclosing scopes starting from most local
+ for scope_locals, _, _ in self._to_consume[::-1]:
+ found = scope_locals.get(name)
+ if found:
+ consumed.append((scope_locals, name))
+ break
+
+ if found is None and not metaclass:
+ name = None
+ if isinstance(klass._metaclass, astroid.Name):
+ name = klass._metaclass.name
+ elif (
+ isinstance(klass._metaclass, astroid.Attribute)
+ and klass._metaclass.expr
+ ):
+ name = klass._metaclass.expr.name
+
+ if name is not None:
+ if not (
+ name in astroid.Module.scope_attrs
+ or utils.is_builtin(name)
+ or name in self.config.additional_builtins
+ or name in parent_node.locals
+ ):
+ self.add_message("undefined-variable", node=klass, args=(name,))
+
+ return consumed
+
+
+def register(linter):
+ """required method to auto register this checker"""
+ linter.register_checker(VariablesChecker(linter))
diff --git a/pylint/config/__init__.py b/pylint/config/__init__.py
new file mode 100644
index 0000000..a4246e2
--- /dev/null
+++ b/pylint/config/__init__.py
@@ -0,0 +1,119 @@
+# Copyright (c) 2006-2010, 2012-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2008 pyves@crater.logilab.fr <pyves@crater.logilab.fr>
+# Copyright (c) 2013 Google, Inc.
+# Copyright (c) 2013 John McGehee <jmcgehee@altera.com>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2015 John Kirkham <jakirkham@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Erik <erik.eriksson@yahoo.com>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017-2019 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2017 ahirnish <ahirnish@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 Jim Robertson <jrobertson98atx@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Gary Tyler McLeod <mail@garytyler.com>
+# Copyright (c) 2018 Konstantin <Github@pheanex.de>
+# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Janne Rönkkö <jannero@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import os
+import pickle
+import sys
+
+from pylint.config.configuration_mixin import ConfigurationMixIn
+from pylint.config.find_default_config_files import find_default_config_files
+from pylint.config.man_help_formatter import _ManHelpFormatter
+from pylint.config.option import Option
+from pylint.config.option_manager_mixin import OptionsManagerMixIn
+from pylint.config.option_parser import OptionParser
+from pylint.config.options_provider_mixin import OptionsProviderMixIn, UnsupportedAction
+
+__all__ = [
+ "ConfigurationMixIn",
+ "find_default_config_files",
+ "_ManHelpFormatter",
+ "Option",
+ "OptionsManagerMixIn",
+ "OptionParser",
+ "OptionsProviderMixIn",
+ "UnsupportedAction",
+]
+
+USER_HOME = os.path.expanduser("~")
+if "PYLINTHOME" in os.environ:
+ PYLINT_HOME = os.environ["PYLINTHOME"]
+ if USER_HOME == "~":
+ USER_HOME = os.path.dirname(PYLINT_HOME)
+elif USER_HOME == "~":
+ PYLINT_HOME = ".pylint.d"
+else:
+ PYLINT_HOME = os.path.join(USER_HOME, ".pylint.d")
+
+
+def _get_pdata_path(base_name, recurs):
+ base_name = base_name.replace(os.sep, "_")
+ return os.path.join(PYLINT_HOME, f"{base_name}{recurs}.stats")
+
+
+def load_results(base):
+ data_file = _get_pdata_path(base, 1)
+ try:
+ with open(data_file, "rb") as stream:
+ return pickle.load(stream)
+ except Exception: # pylint: disable=broad-except
+ return {}
+
+
+def save_results(results, base):
+ if not os.path.exists(PYLINT_HOME):
+ try:
+ os.mkdir(PYLINT_HOME)
+ except OSError:
+ print("Unable to create directory %s" % PYLINT_HOME, file=sys.stderr)
+ data_file = _get_pdata_path(base, 1)
+ try:
+ with open(data_file, "wb") as stream:
+ pickle.dump(results, stream)
+ except OSError as ex:
+ print(f"Unable to create file {data_file}: {ex}", file=sys.stderr)
+
+
+def find_pylintrc():
+ """search the pylint rc file and return its path if it find it, else None"""
+ for config_file in find_default_config_files():
+ if config_file.endswith("pylintrc"):
+ return config_file
+
+ return None
+
+
+PYLINTRC = find_pylintrc()
+
+ENV_HELP = (
+ """
+The following environment variables are used:
+ * PYLINTHOME
+ Path to the directory where persistent data for the run will be stored. If
+not found, it defaults to ~/.pylint.d/ or .pylint.d (in the current working
+directory).
+ * PYLINTRC
+ Path to the configuration file. See the documentation for the method used
+to search for configuration file.
+"""
+ % globals() # type: ignore
+)
diff --git a/pylint/config/configuration_mixin.py b/pylint/config/configuration_mixin.py
new file mode 100644
index 0000000..2b8402b
--- /dev/null
+++ b/pylint/config/configuration_mixin.py
@@ -0,0 +1,26 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+from pylint.config.option_manager_mixin import OptionsManagerMixIn
+from pylint.config.options_provider_mixin import OptionsProviderMixIn
+
+
+class ConfigurationMixIn(OptionsManagerMixIn, OptionsProviderMixIn):
+ """basic mixin for simple configurations which don't need the
+ manager / providers model"""
+
+ def __init__(self, *args, **kwargs):
+ if not args:
+ kwargs.setdefault("usage", "")
+ OptionsManagerMixIn.__init__(self, *args, **kwargs)
+ OptionsProviderMixIn.__init__(self)
+ if not getattr(self, "option_groups", None):
+ self.option_groups = []
+ for _, optdict in self.options:
+ try:
+ gdef = (optdict["group"].upper(), "")
+ except KeyError:
+ continue
+ if gdef not in self.option_groups:
+ self.option_groups.append(gdef)
+ self.register_options_provider(self, own_group=False)
diff --git a/pylint/config/find_default_config_files.py b/pylint/config/find_default_config_files.py
new file mode 100644
index 0000000..2994d8d
--- /dev/null
+++ b/pylint/config/find_default_config_files.py
@@ -0,0 +1,69 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import configparser
+import os
+
+import toml
+from toml.decoder import TomlDecodeError
+
+
+def _toml_has_config(path):
+ with open(path) as toml_handle:
+ try:
+ content = toml.load(toml_handle)
+ except TomlDecodeError as error:
+ print(f"Failed to load '{path}': {error}")
+ return False
+
+ try:
+ content["tool"]["pylint"]
+ except KeyError:
+ return False
+
+ return True
+
+
+def _cfg_has_config(path):
+ parser = configparser.ConfigParser()
+ parser.read(path, encoding="utf-8")
+ return any(section.startswith("pylint.") for section in parser.sections())
+
+
+def find_default_config_files():
+ """Find all possible config files."""
+ rc_names = ("pylintrc", ".pylintrc")
+ config_names = rc_names + ("pyproject.toml", "setup.cfg")
+ for config_name in config_names:
+ if os.path.isfile(config_name):
+ if config_name.endswith(".toml") and not _toml_has_config(config_name):
+ continue
+ if config_name.endswith(".cfg") and not _cfg_has_config(config_name):
+ continue
+
+ yield os.path.abspath(config_name)
+
+ if os.path.isfile("__init__.py"):
+ curdir = os.path.abspath(os.getcwd())
+ while os.path.isfile(os.path.join(curdir, "__init__.py")):
+ curdir = os.path.abspath(os.path.join(curdir, ".."))
+ for rc_name in rc_names:
+ rc_path = os.path.join(curdir, rc_name)
+ if os.path.isfile(rc_path):
+ yield rc_path
+
+ if "PYLINTRC" in os.environ and os.path.exists(os.environ["PYLINTRC"]):
+ if os.path.isfile(os.environ["PYLINTRC"]):
+ yield os.environ["PYLINTRC"]
+ else:
+ user_home = os.path.expanduser("~")
+ if user_home not in ("~", "/root"):
+ home_rc = os.path.join(user_home, ".pylintrc")
+ if os.path.isfile(home_rc):
+ yield home_rc
+ home_rc = os.path.join(user_home, ".config", "pylintrc")
+ if os.path.isfile(home_rc):
+ yield home_rc
+
+ if os.path.isfile("/etc/pylintrc"):
+ yield "/etc/pylintrc"
diff --git a/pylint/config/man_help_formatter.py b/pylint/config/man_help_formatter.py
new file mode 100644
index 0000000..a7b2272
--- /dev/null
+++ b/pylint/config/man_help_formatter.py
@@ -0,0 +1,115 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import optparse # pylint: disable=deprecated-module
+import sys
+import time
+
+
+# pylint: disable=abstract-method; by design?
+class _ManHelpFormatter(optparse.HelpFormatter):
+ def __init__(
+ self, indent_increment=0, max_help_position=24, width=79, short_first=0
+ ):
+ optparse.HelpFormatter.__init__(
+ self, indent_increment, max_help_position, width, short_first
+ )
+
+ def format_heading(self, heading):
+ return ".SH %s\n" % heading.upper()
+
+ def format_description(self, description):
+ return description
+
+ def format_option(self, option):
+ try:
+ optstring = option.option_strings
+ except AttributeError:
+ optstring = self.format_option_strings(option)
+ if option.help:
+ help_text = self.expand_default(option)
+ help_string = " ".join(line.strip() for line in help_text.splitlines())
+ help_string = help_string.replace("\\", "\\\\")
+ help_string = help_string.replace("[current:", "[default:")
+ else:
+ help_string = ""
+ return f""".IP "{optstring}"
+{help_string}
+"""
+
+ def format_head(self, optparser, pkginfo, section=1):
+ long_desc = ""
+ try:
+ pgm = optparser._get_prog_name()
+ except AttributeError:
+ # py >= 2.4.X (dunno which X exactly, at least 2)
+ pgm = optparser.get_prog_name()
+ short_desc = self.format_short_description(pgm, pkginfo.description)
+ if hasattr(pkginfo, "long_desc"):
+ long_desc = self.format_long_description(pgm, pkginfo.long_desc)
+ return f"""{self.format_title(pgm, section)}
+{short_desc}
+{self.format_synopsis(pgm)}
+{long_desc}"""
+
+ @staticmethod
+ def format_title(pgm, section):
+ date = "%d-%02d-%02d" % time.localtime()[:3]
+ return f'.TH {pgm} {section} "{date}" {pgm}'
+
+ @staticmethod
+ def format_short_description(pgm, short_desc):
+ return f""".SH NAME
+.B {pgm}
+\\- {short_desc.strip()}
+"""
+
+ @staticmethod
+ def format_synopsis(pgm):
+ return f""".SH SYNOPSIS
+.B {pgm}
+[
+.I OPTIONS
+] [
+.I <arguments>
+]
+"""
+
+ @staticmethod
+ def format_long_description(pgm, long_desc):
+ long_desc = "\n".join(line.lstrip() for line in long_desc.splitlines())
+ long_desc = long_desc.replace("\n.\n", "\n\n")
+ if long_desc.lower().startswith(pgm):
+ long_desc = long_desc[len(pgm) :]
+ return f""".SH DESCRIPTION
+.B {pgm}
+{long_desc.strip()}
+"""
+
+ @staticmethod
+ def format_tail(pkginfo):
+ tail = f""".SH SEE ALSO
+/usr/share/doc/pythonX.Y-{getattr(pkginfo, "debian_name", "pylint")}/
+
+.SH BUGS
+Please report bugs on the project\'s mailing list:
+{pkginfo.mailinglist}
+
+.SH AUTHOR
+{pkginfo.author} <{pkginfo.author_email}>
+"""
+ if hasattr(pkginfo, "copyright"):
+ tail += f"""
+.SH COPYRIGHT
+{pkginfo.copyright}
+"""
+ return tail
+
+
+def _generate_manpage(optparser, pkginfo, section=1, stream=sys.stdout, level=0):
+ formatter = _ManHelpFormatter()
+ formatter.output_level = level
+ formatter.parser = optparser
+ print(formatter.format_head(optparser, pkginfo, section), file=stream)
+ print(optparser.format_option_help(formatter), file=stream)
+ print(formatter.format_tail(pkginfo), file=stream)
diff --git a/pylint/config/option.py b/pylint/config/option.py
new file mode 100644
index 0000000..cf53ada
--- /dev/null
+++ b/pylint/config/option.py
@@ -0,0 +1,176 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import copy
+import optparse # pylint: disable=deprecated-module
+import re
+
+from pylint import utils
+
+
+# pylint: disable=unused-argument
+def _csv_validator(_, name, value):
+ return utils._check_csv(value)
+
+
+# pylint: disable=unused-argument
+def _regexp_validator(_, name, value):
+ if hasattr(value, "pattern"):
+ return value
+ return re.compile(value)
+
+
+# pylint: disable=unused-argument
+def _regexp_csv_validator(_, name, value):
+ return [_regexp_validator(_, name, val) for val in _csv_validator(_, name, value)]
+
+
+def _choice_validator(choices, name, value):
+ if value not in choices:
+ msg = "option %s: invalid value: %r, should be in %s"
+ raise optparse.OptionValueError(msg % (name, value, choices))
+ return value
+
+
+def _yn_validator(opt, _, value):
+ if isinstance(value, int):
+ return bool(value)
+ if value in ("y", "yes"):
+ return True
+ if value in ("n", "no"):
+ return False
+ msg = "option %s: invalid yn value %r, should be in (y, yes, n, no)"
+ raise optparse.OptionValueError(msg % (opt, value))
+
+
+def _multiple_choice_validator(choices, name, value):
+ values = utils._check_csv(value)
+ for csv_value in values:
+ if csv_value not in choices:
+ msg = "option %s: invalid value: %r, should be in %s"
+ raise optparse.OptionValueError(msg % (name, csv_value, choices))
+ return values
+
+
+def _non_empty_string_validator(opt, _, value):
+ if not value:
+ msg = "indent string can't be empty."
+ raise optparse.OptionValueError(msg)
+ return utils._unquote(value)
+
+
+def _multiple_choices_validating_option(opt, name, value):
+ return _multiple_choice_validator(opt.choices, name, value)
+
+
+def _py_version_validator(_, name, value):
+ if not isinstance(value, tuple):
+ try:
+ value = tuple(int(val) for val in value.split("."))
+ except (ValueError, AttributeError):
+ raise optparse.OptionValueError(f"Invalid format for {name}") from None
+ return value
+
+
+VALIDATORS = {
+ "string": utils._unquote,
+ "int": int,
+ "float": float,
+ "regexp": re.compile,
+ "regexp_csv": _regexp_csv_validator,
+ "csv": _csv_validator,
+ "yn": _yn_validator,
+ "choice": lambda opt, name, value: _choice_validator(opt["choices"], name, value),
+ "multiple_choice": lambda opt, name, value: _multiple_choice_validator(
+ opt["choices"], name, value
+ ),
+ "non_empty_string": _non_empty_string_validator,
+ "py_version": _py_version_validator,
+}
+
+
+def _call_validator(opttype, optdict, option, value):
+ if opttype not in VALIDATORS:
+ raise Exception('Unsupported type "%s"' % opttype)
+ try:
+ return VALIDATORS[opttype](optdict, option, value)
+ except TypeError:
+ try:
+ return VALIDATORS[opttype](value)
+ except Exception as e:
+ raise optparse.OptionValueError(
+ f"{option} value ({value!r}) should be of type {opttype}"
+ ) from e
+
+
+def _validate(value, optdict, name=""):
+ """return a validated value for an option according to its type
+
+ optional argument name is only used for error message formatting
+ """
+ try:
+ _type = optdict["type"]
+ except KeyError:
+ return value
+ return _call_validator(_type, optdict, name, value)
+
+
+# pylint: disable=no-member
+class Option(optparse.Option):
+ TYPES = optparse.Option.TYPES + (
+ "regexp",
+ "regexp_csv",
+ "csv",
+ "yn",
+ "multiple_choice",
+ "non_empty_string",
+ "py_version",
+ )
+ ATTRS = optparse.Option.ATTRS + ["hide", "level"]
+ TYPE_CHECKER = copy.copy(optparse.Option.TYPE_CHECKER)
+ TYPE_CHECKER["regexp"] = _regexp_validator
+ TYPE_CHECKER["regexp_csv"] = _regexp_csv_validator
+ TYPE_CHECKER["csv"] = _csv_validator
+ TYPE_CHECKER["yn"] = _yn_validator
+ TYPE_CHECKER["multiple_choice"] = _multiple_choices_validating_option
+ TYPE_CHECKER["non_empty_string"] = _non_empty_string_validator
+ TYPE_CHECKER["py_version"] = _py_version_validator
+
+ def __init__(self, *opts, **attrs):
+ optparse.Option.__init__(self, *opts, **attrs)
+ if hasattr(self, "hide") and self.hide:
+ self.help = optparse.SUPPRESS_HELP
+
+ def _check_choice(self):
+ if self.type in ("choice", "multiple_choice"):
+ if self.choices is None:
+ raise optparse.OptionError(
+ "must supply a list of choices for type 'choice'", self
+ )
+ if not isinstance(self.choices, (tuple, list)):
+ raise optparse.OptionError(
+ "choices must be a list of strings ('%s' supplied)"
+ % str(type(self.choices)).split("'")[1],
+ self,
+ )
+ elif self.choices is not None:
+ raise optparse.OptionError(
+ "must not supply choices for type %r" % self.type, self
+ )
+
+ # pylint: disable=unsupported-assignment-operation
+ optparse.Option.CHECK_METHODS[2] = _check_choice # type: ignore
+
+ def process(self, opt, value, values, parser):
+ # First, convert the value(s) to the right type. Howl if any
+ # value(s) are bogus.
+ value = self.convert_value(opt, value)
+ if self.type == "named":
+ existent = getattr(values, self.dest)
+ if existent:
+ existent.update(value)
+ value = existent
+ # And then take whatever action is expected of us.
+ # This is a separate method to make life easier for
+ # subclasses to add new actions.
+ return self.take_action(self.action, self.dest, opt, value, values, parser)
diff --git a/pylint/config/option_manager_mixin.py b/pylint/config/option_manager_mixin.py
new file mode 100644
index 0000000..70ec56e
--- /dev/null
+++ b/pylint/config/option_manager_mixin.py
@@ -0,0 +1,366 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+import collections
+import configparser
+import contextlib
+import copy
+import functools
+import optparse # pylint: disable=deprecated-module
+import os
+import sys
+
+import toml
+
+from pylint import utils
+from pylint.config.man_help_formatter import _ManHelpFormatter
+from pylint.config.option import Option
+from pylint.config.option_parser import OptionParser
+
+
+def _expand_default(self, option):
+ """Patch OptionParser.expand_default with custom behaviour
+
+ This will handle defaults to avoid overriding values in the
+ configuration file.
+ """
+ if self.parser is None or not self.default_tag:
+ return option.help
+ optname = option._long_opts[0][2:]
+ try:
+ provider = self.parser.options_manager._all_options[optname]
+ except KeyError:
+ value = None
+ else:
+ optdict = provider.get_option_def(optname)
+ optname = provider.option_attrname(optname, optdict)
+ value = getattr(provider.config, optname, optdict)
+ value = utils._format_option_value(optdict, value)
+ if value is optparse.NO_DEFAULT or not value:
+ value = self.NO_DEFAULT_VALUE
+ return option.help.replace(self.default_tag, str(value))
+
+
+@contextlib.contextmanager
+def _patch_optparse():
+ orig_default = optparse.HelpFormatter
+ try:
+ optparse.HelpFormatter.expand_default = _expand_default
+ yield
+ finally:
+ optparse.HelpFormatter.expand_default = orig_default
+
+
+class OptionsManagerMixIn:
+ """Handle configuration from both a configuration file and command line options"""
+
+ def __init__(self, usage, config_file=None):
+ self.config_file = config_file
+ self.reset_parsers(usage)
+ # list of registered options providers
+ self.options_providers = []
+ # dictionary associating option name to checker
+ self._all_options = collections.OrderedDict()
+ self._short_options = {}
+ self._nocallback_options = {}
+ self._mygroups = {}
+ # verbosity
+ self._maxlevel = 0
+
+ def reset_parsers(self, usage=""):
+ # configuration file parser
+ self.cfgfile_parser = configparser.ConfigParser(
+ inline_comment_prefixes=("#", ";")
+ )
+ # command line parser
+ self.cmdline_parser = OptionParser(Option, usage=usage)
+ self.cmdline_parser.options_manager = self
+ self._optik_option_attrs = set(self.cmdline_parser.option_class.ATTRS)
+
+ def register_options_provider(self, provider, own_group=True):
+ """register an options provider"""
+ assert provider.priority <= 0, "provider's priority can't be >= 0"
+ for i, options_provider in enumerate(self.options_providers):
+ if provider.priority > options_provider.priority:
+ self.options_providers.insert(i, provider)
+ break
+ else:
+ self.options_providers.append(provider)
+ non_group_spec_options = [
+ option for option in provider.options if "group" not in option[1]
+ ]
+ groups = getattr(provider, "option_groups", ())
+ if own_group and non_group_spec_options:
+ self.add_option_group(
+ provider.name.upper(),
+ provider.__doc__,
+ non_group_spec_options,
+ provider,
+ )
+ else:
+ for opt, optdict in non_group_spec_options:
+ self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
+ for gname, gdoc in groups:
+ gname = gname.upper()
+ goptions = [
+ option
+ for option in provider.options
+ if option[1].get("group", "").upper() == gname
+ ]
+ self.add_option_group(gname, gdoc, goptions, provider)
+
+ def add_option_group(self, group_name, _, options, provider):
+ # add option group to the command line parser
+ if group_name in self._mygroups:
+ group = self._mygroups[group_name]
+ else:
+ group = optparse.OptionGroup(
+ self.cmdline_parser, title=group_name.capitalize()
+ )
+ self.cmdline_parser.add_option_group(group)
+ group.level = provider.level
+ self._mygroups[group_name] = group
+ # add section to the config file
+ if (
+ group_name != "DEFAULT"
+ and group_name not in self.cfgfile_parser._sections
+ ):
+ self.cfgfile_parser.add_section(group_name)
+ # add provider's specific options
+ for opt, optdict in options:
+ self.add_optik_option(provider, group, opt, optdict)
+
+ def add_optik_option(self, provider, optikcontainer, opt, optdict):
+ args, optdict = self.optik_option(provider, opt, optdict)
+ option = optikcontainer.add_option(*args, **optdict)
+ self._all_options[opt] = provider
+ self._maxlevel = max(self._maxlevel, option.level or 0)
+
+ def optik_option(self, provider, opt, optdict):
+ """get our personal option definition and return a suitable form for
+ use with optik/optparse
+ """
+ optdict = copy.copy(optdict)
+ if "action" in optdict:
+ self._nocallback_options[provider] = opt
+ else:
+ optdict["action"] = "callback"
+ optdict["callback"] = self.cb_set_provider_option
+ # default is handled here and *must not* be given to optik if you
+ # want the whole machinery to work
+ if "default" in optdict:
+ if (
+ "help" in optdict
+ and optdict.get("default") is not None
+ and optdict["action"] not in ("store_true", "store_false")
+ ):
+ optdict["help"] += " [current: %default]"
+ del optdict["default"]
+ args = ["--" + str(opt)]
+ if "short" in optdict:
+ self._short_options[optdict["short"]] = opt
+ args.append("-" + optdict["short"])
+ del optdict["short"]
+ # cleanup option definition dict before giving it to optik
+ for key in list(optdict.keys()):
+ if key not in self._optik_option_attrs:
+ optdict.pop(key)
+ return args, optdict
+
+ def cb_set_provider_option(self, option, opt, value, parser):
+ """optik callback for option setting"""
+ if opt.startswith("--"):
+ # remove -- on long option
+ opt = opt[2:]
+ else:
+ # short option, get its long equivalent
+ opt = self._short_options[opt[1:]]
+ # trick since we can't set action='store_true' on options
+ if value is None:
+ value = 1
+ self.global_set_option(opt, value)
+
+ def global_set_option(self, opt, value):
+ """set option on the correct option provider"""
+ self._all_options[opt].set_option(opt, value)
+
+ def generate_config(self, stream=None, skipsections=()):
+ """write a configuration file according to the current configuration
+ into the given stream or stdout
+ """
+ options_by_section = {}
+ sections = []
+ for provider in self.options_providers:
+ for section, options in provider.options_by_section():
+ if section is None:
+ section = provider.name
+ if section in skipsections:
+ continue
+ options = [
+ (n, d, v)
+ for (n, d, v) in options
+ if d.get("type") is not None and not d.get("deprecated")
+ ]
+ if not options:
+ continue
+ if section not in sections:
+ sections.append(section)
+ alloptions = options_by_section.setdefault(section, [])
+ alloptions += options
+ stream = stream or sys.stdout
+ printed = False
+ for section in sections:
+ if printed:
+ print("\n", file=stream)
+ utils.format_section(
+ stream, section.upper(), sorted(options_by_section[section])
+ )
+ printed = True
+
+ def generate_manpage(self, pkginfo, section=1, stream=sys.stdout):
+ with _patch_optparse():
+ formatter = _ManHelpFormatter()
+ formatter.output_level = self._maxlevel
+ formatter.parser = self.cmdline_parser
+ print(
+ formatter.format_head(self.cmdline_parser, pkginfo, section),
+ file=stream,
+ )
+ print(self.cmdline_parser.format_option_help(formatter), file=stream)
+ print(formatter.format_tail(pkginfo), file=stream)
+
+ def load_provider_defaults(self):
+ """initialize configuration using default values"""
+ for provider in self.options_providers:
+ provider.load_defaults()
+
+ def read_config_file(self, config_file=None, verbose=None):
+ """Read the configuration file but do not load it (i.e. dispatching
+ values to each options provider)
+ """
+ help_level = 1
+ while help_level <= self._maxlevel:
+ opt = "-".join(["long"] * help_level) + "-help"
+ if opt in self._all_options:
+ break # already processed
+ help_function = functools.partial(self.helpfunc, level=help_level)
+ help_msg = "%s verbose help." % " ".join(["more"] * help_level)
+ optdict = {
+ "action": "callback",
+ "callback": help_function,
+ "help": help_msg,
+ }
+ provider = self.options_providers[0]
+ self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
+ provider.options += ((opt, optdict),)
+ help_level += 1
+ if config_file is None:
+ config_file = self.config_file
+ if config_file is not None:
+ config_file = os.path.expanduser(config_file)
+ if not os.path.exists(config_file):
+ raise OSError(f"The config file {config_file} doesn't exist!")
+
+ use_config_file = config_file and os.path.exists(config_file)
+ if use_config_file: # pylint: disable=too-many-nested-blocks
+ parser = self.cfgfile_parser
+
+ if config_file.endswith(".toml"):
+ with open(config_file) as fp:
+ content = toml.load(fp)
+
+ try:
+ sections_values = content["tool"]["pylint"]
+ except KeyError:
+ pass
+ else:
+ for section, values in sections_values.items():
+ # TOML has rich types, convert values to
+ # strings as ConfigParser expects.
+ for option, value in values.items():
+ if isinstance(value, bool):
+ values[option] = "yes" if value else "no"
+ elif isinstance(value, (int, float)):
+ values[option] = str(value)
+ elif isinstance(value, list):
+ values[option] = ",".join(value)
+ parser._sections[section.upper()] = values
+ else:
+ # Use this encoding in order to strip the BOM marker, if any.
+ with open(config_file, encoding="utf_8_sig") as fp:
+ parser.read_file(fp)
+
+ # normalize sections'title
+ for sect, values in list(parser._sections.items()):
+ if sect.startswith("pylint."):
+ sect = sect[len("pylint.") :]
+ if not sect.isupper() and values:
+ parser._sections[sect.upper()] = values
+ if not verbose:
+ return
+ if use_config_file:
+ msg = f"Using config file {os.path.abspath(config_file)}"
+ else:
+ msg = "No config file found, using default configuration"
+ print(msg, file=sys.stderr)
+
+ def load_config_file(self):
+ """Dispatch values previously read from a configuration file to each
+ options provider)"""
+ parser = self.cfgfile_parser
+ for section in parser.sections():
+ for option, value in parser.items(section):
+ try:
+ self.global_set_option(option, value)
+ except (KeyError, optparse.OptionError):
+ continue
+
+ def load_configuration(self, **kwargs):
+ """override configuration according to given parameters"""
+ return self.load_configuration_from_config(kwargs)
+
+ def load_configuration_from_config(self, config):
+ for opt, opt_value in config.items():
+ opt = opt.replace("_", "-")
+ provider = self._all_options[opt]
+ provider.set_option(opt, opt_value)
+
+ def load_command_line_configuration(self, args=None):
+ """Override configuration according to command line parameters
+
+ return additional arguments
+ """
+ with _patch_optparse():
+ if args is None:
+ args = sys.argv[1:]
+ else:
+ args = list(args)
+ (options, args) = self.cmdline_parser.parse_args(args=args)
+ for provider in self._nocallback_options:
+ config = provider.config
+ for attr in config.__dict__.keys():
+ value = getattr(options, attr, None)
+ if value is None:
+ continue
+ setattr(config, attr, value)
+ return args
+
+ def add_help_section(self, title, description, level=0):
+ """add a dummy option section for help purpose"""
+ group = optparse.OptionGroup(
+ self.cmdline_parser, title=title.capitalize(), description=description
+ )
+ group.level = level
+ self._maxlevel = max(self._maxlevel, level)
+ self.cmdline_parser.add_option_group(group)
+
+ def help(self, level=0):
+ """return the usage string for available options"""
+ self.cmdline_parser.formatter.output_level = level
+ with _patch_optparse():
+ return self.cmdline_parser.format_help()
+
+ def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
+ print(self.help(level))
+ sys.exit(0)
diff --git a/pylint/config/option_parser.py b/pylint/config/option_parser.py
new file mode 100644
index 0000000..e33175e
--- /dev/null
+++ b/pylint/config/option_parser.py
@@ -0,0 +1,47 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import optparse # pylint: disable=deprecated-module
+
+from pylint.config.option import Option
+
+
+def _level_options(group, outputlevel):
+ return [
+ option
+ for option in group.option_list
+ if (getattr(option, "level", 0) or 0) <= outputlevel
+ and option.help is not optparse.SUPPRESS_HELP
+ ]
+
+
+class OptionParser(optparse.OptionParser):
+ def __init__(self, option_class, *args, **kwargs):
+ optparse.OptionParser.__init__(self, option_class=Option, *args, **kwargs)
+
+ def format_option_help(self, formatter=None):
+ if formatter is None:
+ formatter = self.formatter
+ outputlevel = getattr(formatter, "output_level", 0)
+ formatter.store_option_strings(self)
+ result = []
+ result.append(formatter.format_heading("Options"))
+ formatter.indent()
+ if self.option_list:
+ result.append(optparse.OptionContainer.format_option_help(self, formatter))
+ result.append("\n")
+ for group in self.option_groups:
+ if group.level <= outputlevel and (
+ group.description or _level_options(group, outputlevel)
+ ):
+ result.append(group.format_help(formatter))
+ result.append("\n")
+ formatter.dedent()
+ # Drop the last "\n", or the header if no options or option groups:
+ return "".join(result[:-1])
+
+ def _match_long_opt(self, opt):
+ """Disable abbreviations."""
+ if opt not in self._long_opt:
+ raise optparse.BadOptionError(opt)
+ return opt
diff --git a/pylint/config/options_provider_mixin.py b/pylint/config/options_provider_mixin.py
new file mode 100644
index 0000000..fdce3a5
--- /dev/null
+++ b/pylint/config/options_provider_mixin.py
@@ -0,0 +1,111 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+import optparse # pylint: disable=deprecated-module
+from typing import Any, Dict, Tuple
+
+from pylint.config.option import _validate
+
+
+class UnsupportedAction(Exception):
+ """raised by set_option when it doesn't know what to do for an action"""
+
+
+class OptionsProviderMixIn:
+ """Mixin to provide options to an OptionsManager"""
+
+ # those attributes should be overridden
+ priority = -1
+ name = "default"
+ options: Tuple[Tuple[str, Dict[str, Any]], ...] = ()
+ level = 0
+
+ def __init__(self):
+ self.config = optparse.Values()
+ self.load_defaults()
+
+ def load_defaults(self):
+ """initialize the provider using default values"""
+ for opt, optdict in self.options:
+ action = optdict.get("action")
+ if action != "callback":
+ # callback action have no default
+ if optdict is None:
+ optdict = self.get_option_def(opt)
+ default = optdict.get("default")
+ self.set_option(opt, default, action, optdict)
+
+ def option_attrname(self, opt, optdict=None):
+ """get the config attribute corresponding to opt"""
+ if optdict is None:
+ optdict = self.get_option_def(opt)
+ return optdict.get("dest", opt.replace("-", "_"))
+
+ def option_value(self, opt):
+ """get the current value for the given option"""
+ return getattr(self.config, self.option_attrname(opt), None)
+
+ def set_option(self, optname, value, action=None, optdict=None):
+ """method called to set an option (registered in the options list)"""
+ if optdict is None:
+ optdict = self.get_option_def(optname)
+ if value is not None:
+ value = _validate(value, optdict, optname)
+ if action is None:
+ action = optdict.get("action", "store")
+ if action == "store":
+ setattr(self.config, self.option_attrname(optname, optdict), value)
+ elif action in ("store_true", "count"):
+ setattr(self.config, self.option_attrname(optname, optdict), 0)
+ elif action == "store_false":
+ setattr(self.config, self.option_attrname(optname, optdict), 1)
+ elif action == "append":
+ optname = self.option_attrname(optname, optdict)
+ _list = getattr(self.config, optname, None)
+ if _list is None:
+ if isinstance(value, (list, tuple)):
+ _list = value
+ elif value is not None:
+ _list = []
+ _list.append(value)
+ setattr(self.config, optname, _list)
+ elif isinstance(_list, tuple):
+ setattr(self.config, optname, _list + (value,))
+ else:
+ _list.append(value)
+ elif action == "callback":
+ optdict["callback"](None, optname, value, None)
+ else:
+ raise UnsupportedAction(action)
+
+ def get_option_def(self, opt):
+ """return the dictionary defining an option given its name"""
+ assert self.options
+ for option in self.options:
+ if option[0] == opt:
+ return option[1]
+ raise optparse.OptionError(
+ f"no such option {opt} in section {self.name!r}", opt
+ )
+
+ def options_by_section(self):
+ """return an iterator on options grouped by section
+
+ (section, [list of (optname, optdict, optvalue)])
+ """
+ sections = {}
+ for optname, optdict in self.options:
+ sections.setdefault(optdict.get("group"), []).append(
+ (optname, optdict, self.option_value(optname))
+ )
+ if None in sections:
+ yield None, sections.pop(None)
+ for section, options in sorted(sections.items()):
+ yield section.upper(), options
+
+ def options_and_values(self, options=None):
+ if options is None:
+ options = self.options
+ for optname, optdict in options:
+ yield (optname, optdict, self.option_value(optname))
diff --git a/pylint/constants.py b/pylint/constants.py
new file mode 100644
index 0000000..b95d701
--- /dev/null
+++ b/pylint/constants.py
@@ -0,0 +1,50 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import sys
+
+import astroid
+
+from pylint.__pkginfo__ import __version__
+
+PY38_PLUS = sys.version_info[:2] >= (3, 8)
+PY39_PLUS = sys.version_info[:2] >= (3, 9)
+PY310_PLUS = sys.version_info[:2] >= (3, 10)
+
+
+PY_EXTS = (".py", ".pyc", ".pyo", ".pyw", ".so", ".dll")
+
+MSG_STATE_CONFIDENCE = 2
+_MSG_ORDER = "EWRCIF"
+MSG_STATE_SCOPE_CONFIG = 0
+MSG_STATE_SCOPE_MODULE = 1
+
+# The line/node distinction does not apply to fatal errors and reports.
+_SCOPE_EXEMPT = "FR"
+
+MSG_TYPES = {
+ "I": "info",
+ "C": "convention",
+ "R": "refactor",
+ "W": "warning",
+ "E": "error",
+ "F": "fatal",
+}
+MSG_TYPES_LONG = {v: k for k, v in MSG_TYPES.items()}
+
+MSG_TYPES_STATUS = {"I": 0, "C": 16, "R": 8, "W": 4, "E": 2, "F": 1}
+
+# You probably don't want to change the MAIN_CHECKER_NAME
+# This would affect rcfile generation and retro-compatibility
+# on all project using [MASTER] in their rcfile.
+MAIN_CHECKER_NAME = "master"
+
+
+class WarningScope:
+ LINE = "line-based-msg"
+ NODE = "node-based-msg"
+
+
+full_version = f"""pylint {__version__}
+astroid {astroid.__version__}
+Python {sys.version}"""
diff --git a/pylint/epylint.py b/pylint/epylint.py
new file mode 100755
index 0000000..12f541c
--- /dev/null
+++ b/pylint/epylint.py
@@ -0,0 +1,203 @@
+# mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4
+# -*- vim:fenc=utf-8:ft=python:et:sw=4:ts=4:sts=4
+
+# Copyright (c) 2008-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Jakob Normark <jakobnormark@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Manuel Vázquez Acosta <mva.led@gmail.com>
+# Copyright (c) 2014 Derek Harland <derek.harland@finq.co.nz>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Mihai Balint <balint.mihai@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Daniela Plascencia <daplascen@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Ryan McGuire <ryan@enigmacurry.com>
+# Copyright (c) 2018 thernstig <30827238+thernstig@users.noreply.github.com>
+# Copyright (c) 2018 Radostin Stoyanov <rst0git@users.noreply.github.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Emacs and Flymake compatible Pylint.
+
+This script is for integration with emacs and is compatible with flymake mode.
+
+epylint walks out of python packages before invoking pylint. This avoids
+reporting import errors that occur when a module within a package uses the
+absolute import path to get another module within this package.
+
+For example:
+ - Suppose a package is structured as
+
+ a/__init__.py
+ a/b/x.py
+ a/c/y.py
+
+ - Then if y.py imports x as "from a.b import x" the following produces pylint
+ errors
+
+ cd a/c; pylint y.py
+
+ - The following obviously doesn't
+
+ pylint a/c/y.py
+
+ - As this script will be invoked by emacs within the directory of the file
+ we are checking we need to go out of it to avoid these false positives.
+
+
+You may also use py_run to run pylint with desired options and get back (or not)
+its output.
+"""
+import os
+import shlex
+import sys
+from io import StringIO
+from subprocess import PIPE, Popen
+
+
+def _get_env():
+ """Extracts the environment PYTHONPATH and appends the current sys.path to
+ those."""
+ env = dict(os.environ)
+ env["PYTHONPATH"] = os.pathsep.join(sys.path)
+ return env
+
+
+def lint(filename, options=()):
+ """Pylint the given file.
+
+ When run from emacs we will be in the directory of a file, and passed its
+ filename. If this file is part of a package and is trying to import other
+ modules from within its own package or another package rooted in a directory
+ below it, pylint will classify it as a failed import.
+
+ To get around this, we traverse down the directory tree to find the root of
+ the package this module is in. We then invoke pylint from this directory.
+
+ Finally, we must correct the filenames in the output generated by pylint so
+ Emacs doesn't become confused (it will expect just the original filename,
+ while pylint may extend it with extra directories if we've traversed down
+ the tree)
+ """
+ # traverse downwards until we are out of a python package
+ full_path = os.path.abspath(filename)
+ parent_path = os.path.dirname(full_path)
+ child_path = os.path.basename(full_path)
+
+ while parent_path != "/" and os.path.exists(
+ os.path.join(parent_path, "__init__.py")
+ ):
+ child_path = os.path.join(os.path.basename(parent_path), child_path)
+ parent_path = os.path.dirname(parent_path)
+
+ # Start pylint
+ # Ensure we use the python and pylint associated with the running epylint
+ run_cmd = "import sys; from pylint.lint import Run; Run(sys.argv[1:])"
+ cmd = (
+ [sys.executable, "-c", run_cmd]
+ + [
+ "--msg-template",
+ "{path}:{line}: {category} ({msg_id}, {symbol}, {obj}) {msg}",
+ "-r",
+ "n",
+ child_path,
+ ]
+ + list(options)
+ )
+
+ with Popen(
+ cmd, stdout=PIPE, cwd=parent_path, env=_get_env(), universal_newlines=True
+ ) as process:
+
+ for line in process.stdout:
+ # remove pylintrc warning
+ if line.startswith("No config file found"):
+ continue
+
+ # modify the file name thats output to reverse the path traversal we made
+ parts = line.split(":")
+ if parts and parts[0] == child_path:
+ line = ":".join([filename] + parts[1:])
+ print(line, end=" ")
+
+ process.wait()
+ return process.returncode
+
+
+def py_run(command_options="", return_std=False, stdout=None, stderr=None):
+ """Run pylint from python
+
+ ``command_options`` is a string containing ``pylint`` command line options;
+ ``return_std`` (boolean) indicates return of created standard output
+ and error (see below);
+ ``stdout`` and ``stderr`` are 'file-like' objects in which standard output
+ could be written.
+
+ Calling agent is responsible for stdout/err management (creation, close).
+ Default standard output and error are those from sys,
+ or standalone ones (``subprocess.PIPE``) are used
+ if they are not set and ``return_std``.
+
+ If ``return_std`` is set to ``True``, this function returns a 2-uple
+ containing standard output and error related to created process,
+ as follows: ``(stdout, stderr)``.
+
+ To silently run Pylint on a module, and get its standard output and error:
+ >>> (pylint_stdout, pylint_stderr) = py_run( 'module_name.py', True)
+ """
+ # Detect if we use Python as executable or not, else default to `python`
+ executable = sys.executable if "python" in sys.executable else "python"
+
+ # Create command line to call pylint
+ epylint_part = [executable, "-c", "from pylint import epylint;epylint.Run()"]
+ options = shlex.split(command_options, posix=not sys.platform.startswith("win"))
+ cli = epylint_part + options
+
+ # Providing standard output and/or error if not set
+ if stdout is None:
+ if return_std:
+ stdout = PIPE
+ else:
+ stdout = sys.stdout
+ if stderr is None:
+ if return_std:
+ stderr = PIPE
+ else:
+ stderr = sys.stderr
+ # Call pylint in a subprocess
+ with Popen(
+ cli,
+ shell=False,
+ stdout=stdout,
+ stderr=stderr,
+ env=_get_env(),
+ universal_newlines=True,
+ ) as process:
+ proc_stdout, proc_stderr = process.communicate()
+ # Return standard output and error
+ if return_std:
+ return StringIO(proc_stdout), StringIO(proc_stderr)
+ return None
+
+
+def Run():
+ if len(sys.argv) == 1:
+ print("Usage: %s <filename> [options]" % sys.argv[0])
+ sys.exit(1)
+ elif not os.path.exists(sys.argv[1]):
+ print("%s does not exist" % sys.argv[1])
+ sys.exit(1)
+ else:
+ sys.exit(lint(sys.argv[1], sys.argv[2:]))
+
+
+if __name__ == "__main__":
+ Run()
diff --git a/pylint/exceptions.py b/pylint/exceptions.py
new file mode 100644
index 0000000..f159f3e
--- /dev/null
+++ b/pylint/exceptions.py
@@ -0,0 +1,32 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019 Thomas Hisch <t.hisch@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Exception classes raised by various operations within pylint."""
+
+
+class InvalidMessageError(Exception):
+ """raised when a message creation, registration or addition is rejected"""
+
+
+class UnknownMessageError(Exception):
+ """raised when an unregistered message id is encountered"""
+
+
+class EmptyReportError(Exception):
+ """raised when a report is empty and so should not be displayed"""
+
+
+class InvalidReporterError(Exception):
+ """raised when selected reporter is invalid (e.g. not found)"""
+
+
+class InvalidArgsError(ValueError):
+ """raised when passed arguments are invalid, e.g., have the wrong length"""
diff --git a/pylint/extensions/__init__.py b/pylint/extensions/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pylint/extensions/__init__.py
diff --git a/pylint/extensions/_check_docs_utils.py b/pylint/extensions/_check_docs_utils.py
new file mode 100644
index 0000000..ca78459
--- /dev/null
+++ b/pylint/extensions/_check_docs_utils.py
@@ -0,0 +1,810 @@
+# Copyright (c) 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Yuri Bochkarev <baltazar.bz@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Mitar <mitar.github@tnode.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 Jim Robertson <jrobertson98atx@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Mitchell T.H. Young <mitchelly@gmail.com>
+# Copyright (c) 2018 Adrian Chirieac <chirieacam@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Danny Hermes <daniel.j.hermes@gmail.com>
+# Copyright (c) 2019 Zeb Nicholls <zebedee.nicholls@climate-energy-college.org>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Utility methods for docstring checking."""
+
+import re
+from typing import List
+
+import astroid
+
+from pylint.checkers import utils
+
+
+def space_indentation(s):
+ """The number of leading spaces in a string
+
+ :param str s: input string
+
+ :rtype: int
+ :return: number of leading spaces
+ """
+ return len(s) - len(s.lstrip(" "))
+
+
+def get_setters_property_name(node):
+ """Get the name of the property that the given node is a setter for.
+
+ :param node: The node to get the property name for.
+ :type node: str
+
+ :rtype: str or None
+ :returns: The name of the property that the node is a setter for,
+ or None if one could not be found.
+ """
+ decorators = node.decorators.nodes if node.decorators else []
+ for decorator in decorators:
+ if (
+ isinstance(decorator, astroid.Attribute)
+ and decorator.attrname == "setter"
+ and isinstance(decorator.expr, astroid.Name)
+ ):
+ return decorator.expr.name
+ return None
+
+
+def get_setters_property(node):
+ """Get the property node for the given setter node.
+
+ :param node: The node to get the property for.
+ :type node: astroid.FunctionDef
+
+ :rtype: astroid.FunctionDef or None
+ :returns: The node relating to the property of the given setter node,
+ or None if one could not be found.
+ """
+ property_ = None
+
+ property_name = get_setters_property_name(node)
+ class_node = utils.node_frame_class(node)
+ if property_name and class_node:
+ class_attrs = class_node.getattr(node.name)
+ for attr in class_attrs:
+ if utils.decorated_with_property(attr):
+ property_ = attr
+ break
+
+ return property_
+
+
+def returns_something(return_node):
+ """Check if a return node returns a value other than None.
+
+ :param return_node: The return node to check.
+ :type return_node: astroid.Return
+
+ :rtype: bool
+ :return: True if the return node returns a value other than None,
+ False otherwise.
+ """
+ returns = return_node.value
+
+ if returns is None:
+ return False
+
+ return not (isinstance(returns, astroid.Const) and returns.value is None)
+
+
+def _get_raise_target(node):
+ if isinstance(node.exc, astroid.Call):
+ func = node.exc.func
+ if isinstance(func, (astroid.Name, astroid.Attribute)):
+ return utils.safe_infer(func)
+ return None
+
+
+def _split_multiple_exc_types(target: str) -> List[str]:
+ delimiters = r"(\s*,(?:\s*or\s)?\s*|\s+or\s+)"
+ return re.split(delimiters, target)
+
+
+def possible_exc_types(node):
+ """
+ Gets all of the possible raised exception types for the given raise node.
+
+ .. note::
+
+ Caught exception types are ignored.
+
+
+ :param node: The raise node to find exception types for.
+ :type node: astroid.node_classes.NodeNG
+
+ :returns: A list of exception types possibly raised by :param:`node`.
+ :rtype: set(str)
+ """
+ excs = []
+ if isinstance(node.exc, astroid.Name):
+ inferred = utils.safe_infer(node.exc)
+ if inferred:
+ excs = [inferred.name]
+ elif node.exc is None:
+ handler = node.parent
+ while handler and not isinstance(handler, astroid.ExceptHandler):
+ handler = handler.parent
+
+ if handler and handler.type:
+ inferred_excs = astroid.unpack_infer(handler.type)
+ excs = (exc.name for exc in inferred_excs if exc is not astroid.Uninferable)
+ else:
+ target = _get_raise_target(node)
+ if isinstance(target, astroid.ClassDef):
+ excs = [target.name]
+ elif isinstance(target, astroid.FunctionDef):
+ for ret in target.nodes_of_class(astroid.Return):
+ if ret.frame() != target:
+ # return from inner function - ignore it
+ continue
+
+ val = utils.safe_infer(ret.value)
+ if (
+ val
+ and isinstance(val, (astroid.Instance, astroid.ClassDef))
+ and utils.inherit_from_std_ex(val)
+ ):
+ excs.append(val.name)
+
+ try:
+ return {exc for exc in excs if not utils.node_ignores_exception(node, exc)}
+ except astroid.InferenceError:
+ return set()
+
+
+def docstringify(docstring, default_type="default"):
+ for docstring_type in (
+ SphinxDocstring,
+ EpytextDocstring,
+ GoogleDocstring,
+ NumpyDocstring,
+ ):
+ instance = docstring_type(docstring)
+ if instance.is_valid():
+ return instance
+
+ docstring_type = DOCSTRING_TYPES.get(default_type, Docstring)
+ return docstring_type(docstring)
+
+
+class Docstring:
+ re_for_parameters_see = re.compile(
+ r"""
+ For\s+the\s+(other)?\s*parameters\s*,\s+see
+ """,
+ re.X | re.S,
+ )
+
+ supports_yields: bool = False
+ """True if the docstring supports a "yield" section.
+
+ False if the docstring uses the returns section to document generators.
+ """
+
+ # These methods are designed to be overridden
+ # pylint: disable=no-self-use
+ def __init__(self, doc):
+ doc = doc or ""
+ self.doc = doc.expandtabs()
+
+ def is_valid(self):
+ return False
+
+ def exceptions(self):
+ return set()
+
+ def has_params(self):
+ return False
+
+ def has_returns(self):
+ return False
+
+ def has_rtype(self):
+ return False
+
+ def has_property_returns(self):
+ return False
+
+ def has_property_type(self):
+ return False
+
+ def has_yields(self):
+ return False
+
+ def has_yields_type(self):
+ return False
+
+ def match_param_docs(self):
+ return set(), set()
+
+ def params_documented_elsewhere(self):
+ return self.re_for_parameters_see.search(self.doc) is not None
+
+
+class SphinxDocstring(Docstring):
+ re_type = r"""
+ [~!.]? # Optional link style prefix
+ \w(?:\w|\.[^\.])* # Valid python name
+ """
+
+ re_simple_container_type = r"""
+ {type} # a container type
+ [\(\[] [^\n\s]+ [\)\]] # with the contents of the container
+ """.format(
+ type=re_type
+ )
+
+ re_multiple_simple_type = r"""
+ (?:{container_type}|{type})
+ (?:(?:\s+(?:of|or)\s+|\s*,\s*)(?:{container_type}|{type}))*
+ """.format(
+ type=re_type, container_type=re_simple_container_type
+ )
+
+ re_xref = r"""
+ (?::\w+:)? # optional tag
+ `{}` # what to reference
+ """.format(
+ re_type
+ )
+
+ re_param_raw = r"""
+ : # initial colon
+ (?: # Sphinx keywords
+ param|parameter|
+ arg|argument|
+ key|keyword
+ )
+ \s+ # whitespace
+
+ (?: # optional type declaration
+ ({type}|{container_type})
+ \s+
+ )?
+
+ (\w+) # Parameter name
+ \s* # whitespace
+ : # final colon
+ """.format(
+ type=re_type, container_type=re_simple_container_type
+ )
+ re_param_in_docstring = re.compile(re_param_raw, re.X | re.S)
+
+ re_type_raw = r"""
+ :type # Sphinx keyword
+ \s+ # whitespace
+ ({type}) # Parameter name
+ \s* # whitespace
+ : # final colon
+ """.format(
+ type=re_multiple_simple_type
+ )
+ re_type_in_docstring = re.compile(re_type_raw, re.X | re.S)
+
+ re_property_type_raw = r"""
+ :type: # Sphinx keyword
+ \s+ # whitespace
+ {type} # type declaration
+ """.format(
+ type=re_multiple_simple_type
+ )
+ re_property_type_in_docstring = re.compile(re_property_type_raw, re.X | re.S)
+
+ re_raise_raw = r"""
+ : # initial colon
+ (?: # Sphinx keyword
+ raises?|
+ except|exception
+ )
+ \s+ # whitespace
+ ({type}) # exception type
+ \s* # whitespace
+ : # final colon
+ """.format(
+ type=re_multiple_simple_type
+ )
+ re_raise_in_docstring = re.compile(re_raise_raw, re.X | re.S)
+
+ re_rtype_in_docstring = re.compile(r":rtype:")
+
+ re_returns_in_docstring = re.compile(r":returns?:")
+
+ supports_yields = False
+
+ def is_valid(self):
+ return bool(
+ self.re_param_in_docstring.search(self.doc)
+ or self.re_raise_in_docstring.search(self.doc)
+ or self.re_rtype_in_docstring.search(self.doc)
+ or self.re_returns_in_docstring.search(self.doc)
+ or self.re_property_type_in_docstring.search(self.doc)
+ )
+
+ def exceptions(self):
+ types = set()
+
+ for match in re.finditer(self.re_raise_in_docstring, self.doc):
+ raise_type = match.group(1)
+ types.update(_split_multiple_exc_types(raise_type))
+
+ return types
+
+ def has_params(self):
+ if not self.doc:
+ return False
+
+ return self.re_param_in_docstring.search(self.doc) is not None
+
+ def has_returns(self):
+ if not self.doc:
+ return False
+
+ return bool(self.re_returns_in_docstring.search(self.doc))
+
+ def has_rtype(self):
+ if not self.doc:
+ return False
+
+ return bool(self.re_rtype_in_docstring.search(self.doc))
+
+ def has_property_returns(self):
+ if not self.doc:
+ return False
+
+ # The summary line is the return doc,
+ # so the first line must not be a known directive.
+ return not self.doc.lstrip().startswith(":")
+
+ def has_property_type(self):
+ if not self.doc:
+ return False
+
+ return bool(self.re_property_type_in_docstring.search(self.doc))
+
+ def match_param_docs(self):
+ params_with_doc = set()
+ params_with_type = set()
+
+ for match in re.finditer(self.re_param_in_docstring, self.doc):
+ name = match.group(2)
+ params_with_doc.add(name)
+ param_type = match.group(1)
+ if param_type is not None:
+ params_with_type.add(name)
+
+ params_with_type.update(re.findall(self.re_type_in_docstring, self.doc))
+ return params_with_doc, params_with_type
+
+
+class EpytextDocstring(SphinxDocstring):
+ """
+ Epytext is similar to Sphinx. See the docs:
+ http://epydoc.sourceforge.net/epytext.html
+ http://epydoc.sourceforge.net/fields.html#fields
+
+ It's used in PyCharm:
+ https://www.jetbrains.com/help/pycharm/2016.1/creating-documentation-comments.html#d848203e314
+ https://www.jetbrains.com/help/pycharm/2016.1/using-docstrings-to-specify-types.html
+ """
+
+ re_param_in_docstring = re.compile(
+ SphinxDocstring.re_param_raw.replace(":", "@", 1), re.X | re.S
+ )
+
+ re_type_in_docstring = re.compile(
+ SphinxDocstring.re_type_raw.replace(":", "@", 1), re.X | re.S
+ )
+
+ re_property_type_in_docstring = re.compile(
+ SphinxDocstring.re_property_type_raw.replace(":", "@", 1), re.X | re.S
+ )
+
+ re_raise_in_docstring = re.compile(
+ SphinxDocstring.re_raise_raw.replace(":", "@", 1), re.X | re.S
+ )
+
+ re_rtype_in_docstring = re.compile(
+ r"""
+ @ # initial "at" symbol
+ (?: # Epytext keyword
+ rtype|returntype
+ )
+ : # final colon
+ """,
+ re.X | re.S,
+ )
+
+ re_returns_in_docstring = re.compile(r"@returns?:")
+
+ def has_property_returns(self):
+ if not self.doc:
+ return False
+
+ # If this is a property docstring, the summary is the return doc.
+ if self.has_property_type():
+ # The summary line is the return doc,
+ # so the first line must not be a known directive.
+ return not self.doc.lstrip().startswith("@")
+
+ return False
+
+
+class GoogleDocstring(Docstring):
+ re_type = SphinxDocstring.re_type
+
+ re_xref = SphinxDocstring.re_xref
+
+ re_container_type = r"""
+ (?:{type}|{xref}) # a container type
+ [\(\[] [^\n]+ [\)\]] # with the contents of the container
+ """.format(
+ type=re_type, xref=re_xref
+ )
+
+ re_multiple_type = r"""
+ (?:{container_type}|{type}|{xref})
+ (?:(?:\s+(?:of|or)\s+|\s*,\s*)(?:{container_type}|{type}|{xref}))*
+ """.format(
+ type=re_type, xref=re_xref, container_type=re_container_type
+ )
+
+ _re_section_template = r"""
+ ^([ ]*) {0} \s*: \s*$ # Google parameter header
+ ( .* ) # section
+ """
+
+ re_param_section = re.compile(
+ _re_section_template.format(r"(?:Args|Arguments|Parameters)"),
+ re.X | re.S | re.M,
+ )
+
+ re_keyword_param_section = re.compile(
+ _re_section_template.format(r"Keyword\s(?:Args|Arguments|Parameters)"),
+ re.X | re.S | re.M,
+ )
+
+ re_param_line = re.compile(
+ r"""
+ \s* \*{{0,2}}(\w+) # identifier potentially with asterisks
+ \s* ( [(]
+ {type}
+ (?:,\s+optional)?
+ [)] )? \s* : # optional type declaration
+ \s* (.*) # beginning of optional description
+ """.format(
+ type=re_multiple_type
+ ),
+ re.X | re.S | re.M,
+ )
+
+ re_raise_section = re.compile(
+ _re_section_template.format(r"Raises"), re.X | re.S | re.M
+ )
+
+ re_raise_line = re.compile(
+ r"""
+ \s* ({type}) \s* : # identifier
+ \s* (.*) # beginning of optional description
+ """.format(
+ type=re_multiple_type
+ ),
+ re.X | re.S | re.M,
+ )
+
+ re_returns_section = re.compile(
+ _re_section_template.format(r"Returns?"), re.X | re.S | re.M
+ )
+
+ re_returns_line = re.compile(
+ r"""
+ \s* ({type}:)? # identifier
+ \s* (.*) # beginning of description
+ """.format(
+ type=re_multiple_type
+ ),
+ re.X | re.S | re.M,
+ )
+
+ re_property_returns_line = re.compile(
+ r"""
+ ^{type}: # indentifier
+ \s* (.*) # Summary line / description
+ """.format(
+ type=re_multiple_type
+ ),
+ re.X | re.S | re.M,
+ )
+
+ re_yields_section = re.compile(
+ _re_section_template.format(r"Yields?"), re.X | re.S | re.M
+ )
+
+ re_yields_line = re_returns_line
+
+ supports_yields = True
+
+ def is_valid(self):
+ return bool(
+ self.re_param_section.search(self.doc)
+ or self.re_raise_section.search(self.doc)
+ or self.re_returns_section.search(self.doc)
+ or self.re_yields_section.search(self.doc)
+ or self.re_property_returns_line.search(self._first_line())
+ )
+
+ def has_params(self):
+ if not self.doc:
+ return False
+
+ return self.re_param_section.search(self.doc) is not None
+
+ def has_returns(self):
+ if not self.doc:
+ return False
+
+ entries = self._parse_section(self.re_returns_section)
+ for entry in entries:
+ match = self.re_returns_line.match(entry)
+ if not match:
+ continue
+
+ return_desc = match.group(2)
+ if return_desc:
+ return True
+
+ return False
+
+ def has_rtype(self):
+ if not self.doc:
+ return False
+
+ entries = self._parse_section(self.re_returns_section)
+ for entry in entries:
+ match = self.re_returns_line.match(entry)
+ if not match:
+ continue
+
+ return_type = match.group(1)
+ if return_type:
+ return True
+
+ return False
+
+ def has_property_returns(self):
+ # The summary line is the return doc,
+ # so the first line must not be a known directive.
+ first_line = self._first_line()
+ return not bool(
+ self.re_param_section.search(first_line)
+ or self.re_raise_section.search(first_line)
+ or self.re_returns_section.search(first_line)
+ or self.re_yields_section.search(first_line)
+ )
+
+ def has_property_type(self):
+ if not self.doc:
+ return False
+
+ return bool(self.re_property_returns_line.match(self._first_line()))
+
+ def has_yields(self):
+ if not self.doc:
+ return False
+
+ entries = self._parse_section(self.re_yields_section)
+ for entry in entries:
+ match = self.re_yields_line.match(entry)
+ if not match:
+ continue
+
+ yield_desc = match.group(2)
+ if yield_desc:
+ return True
+
+ return False
+
+ def has_yields_type(self):
+ if not self.doc:
+ return False
+
+ entries = self._parse_section(self.re_yields_section)
+ for entry in entries:
+ match = self.re_yields_line.match(entry)
+ if not match:
+ continue
+
+ yield_type = match.group(1)
+ if yield_type:
+ return True
+
+ return False
+
+ def exceptions(self):
+ types = set()
+
+ entries = self._parse_section(self.re_raise_section)
+ for entry in entries:
+ match = self.re_raise_line.match(entry)
+ if not match:
+ continue
+
+ exc_type = match.group(1)
+ exc_desc = match.group(2)
+ if exc_desc:
+ types.update(_split_multiple_exc_types(exc_type))
+
+ return types
+
+ def match_param_docs(self):
+ params_with_doc = set()
+ params_with_type = set()
+
+ entries = self._parse_section(self.re_param_section)
+ entries.extend(self._parse_section(self.re_keyword_param_section))
+ for entry in entries:
+ match = self.re_param_line.match(entry)
+ if not match:
+ continue
+
+ param_name = match.group(1)
+ param_type = match.group(2)
+ param_desc = match.group(3)
+ if param_type:
+ params_with_type.add(param_name)
+
+ if param_desc:
+ params_with_doc.add(param_name)
+
+ return params_with_doc, params_with_type
+
+ def _first_line(self):
+ return self.doc.lstrip().split("\n", 1)[0]
+
+ @staticmethod
+ def min_section_indent(section_match):
+ return len(section_match.group(1)) + 1
+
+ @staticmethod
+ def _is_section_header(_):
+ # Google parsing does not need to detect section headers,
+ # because it works off of indentation level only
+ return False
+
+ def _parse_section(self, section_re):
+ section_match = section_re.search(self.doc)
+ if section_match is None:
+ return []
+
+ min_indentation = self.min_section_indent(section_match)
+
+ entries = []
+ entry = []
+ is_first = True
+ for line in section_match.group(2).splitlines():
+ if not line.strip():
+ continue
+ indentation = space_indentation(line)
+ if indentation < min_indentation:
+ break
+
+ # The first line after the header defines the minimum
+ # indentation.
+ if is_first:
+ min_indentation = indentation
+ is_first = False
+
+ if indentation == min_indentation:
+ if self._is_section_header(line):
+ break
+ # Lines with minimum indentation must contain the beginning
+ # of a new parameter documentation.
+ if entry:
+ entries.append("\n".join(entry))
+ entry = []
+
+ entry.append(line)
+
+ if entry:
+ entries.append("\n".join(entry))
+
+ return entries
+
+
+class NumpyDocstring(GoogleDocstring):
+ _re_section_template = r"""
+ ^([ ]*) {0} \s*?$ # Numpy parameters header
+ \s* [-=]+ \s*?$ # underline
+ ( .* ) # section
+ """
+
+ re_param_section = re.compile(
+ _re_section_template.format(r"(?:Args|Arguments|Parameters)"),
+ re.X | re.S | re.M,
+ )
+
+ re_param_line = re.compile(
+ r"""
+ \s* (\w+) # identifier
+ \s* :
+ \s* (?:({type})(?:,\s+optional)?)? # optional type declaration
+ \n # description starts on a new line
+ \s* (.*) # description
+ """.format(
+ type=GoogleDocstring.re_multiple_type
+ ),
+ re.X | re.S,
+ )
+
+ re_raise_section = re.compile(
+ _re_section_template.format(r"Raises"), re.X | re.S | re.M
+ )
+
+ re_raise_line = re.compile(
+ r"""
+ \s* ({type})$ # type declaration
+ \s* (.*) # optional description
+ """.format(
+ type=GoogleDocstring.re_type
+ ),
+ re.X | re.S | re.M,
+ )
+
+ re_returns_section = re.compile(
+ _re_section_template.format(r"Returns?"), re.X | re.S | re.M
+ )
+
+ re_returns_line = re.compile(
+ r"""
+ \s* (?:\w+\s+:\s+)? # optional name
+ ({type})$ # type declaration
+ \s* (.*) # optional description
+ """.format(
+ type=GoogleDocstring.re_multiple_type
+ ),
+ re.X | re.S | re.M,
+ )
+
+ re_yields_section = re.compile(
+ _re_section_template.format(r"Yields?"), re.X | re.S | re.M
+ )
+
+ re_yields_line = re_returns_line
+
+ supports_yields = True
+
+ @staticmethod
+ def min_section_indent(section_match):
+ return len(section_match.group(1))
+
+ @staticmethod
+ def _is_section_header(line):
+ return bool(re.match(r"\s*-+$", line))
+
+
+DOCSTRING_TYPES = {
+ "sphinx": SphinxDocstring,
+ "epytext": EpytextDocstring,
+ "google": GoogleDocstring,
+ "numpy": NumpyDocstring,
+ "default": Docstring,
+}
+"""A map of the name of the docstring type to its class.
+
+:type: dict(str, type)
+"""
diff --git a/pylint/extensions/bad_builtin.py b/pylint/extensions/bad_builtin.py
new file mode 100644
index 0000000..bb20901
--- /dev/null
+++ b/pylint/extensions/bad_builtin.py
@@ -0,0 +1,73 @@
+# Copyright (c) 2016, 2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Checker for deprecated builtins."""
+import astroid
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+BAD_FUNCTIONS = ["map", "filter"]
+# Some hints regarding the use of bad builtins.
+BUILTIN_HINTS = {"map": "Using a list comprehension can be clearer."}
+BUILTIN_HINTS["filter"] = BUILTIN_HINTS["map"]
+
+
+class BadBuiltinChecker(BaseChecker):
+
+ __implements__ = (IAstroidChecker,)
+ name = "deprecated_builtins"
+ msgs = {
+ "W0141": (
+ "Used builtin function %s",
+ "bad-builtin",
+ "Used when a disallowed builtin function is used (see the "
+ "bad-function option). Usual disallowed functions are the ones "
+ "like map, or filter , where Python offers now some cleaner "
+ "alternative like list comprehension.",
+ )
+ }
+
+ options = (
+ (
+ "bad-functions",
+ {
+ "default": BAD_FUNCTIONS,
+ "type": "csv",
+ "metavar": "<builtin function names>",
+ "help": "List of builtins function names that should not be "
+ "used, separated by a comma",
+ },
+ ),
+ )
+
+ @check_messages("bad-builtin")
+ def visit_call(self, node):
+ if isinstance(node.func, astroid.Name):
+ name = node.func.name
+ # ignore the name if it's not a builtin (i.e. not defined in the
+ # locals nor globals scope)
+ if not (name in node.frame() or name in node.root()):
+ if name in self.config.bad_functions:
+ hint = BUILTIN_HINTS.get(name)
+ if hint:
+ args = f"{name!r}. {hint}"
+ else:
+ args = repr(name)
+ self.add_message("bad-builtin", node=node, args=args)
+
+
+def register(linter):
+ """Required method to auto register this checker.
+
+ :param linter: Main interface object for Pylint plugins
+ :type linter: Pylint object
+ """
+ linter.register_checker(BadBuiltinChecker(linter))
diff --git a/pylint/extensions/bad_builtin.rst b/pylint/extensions/bad_builtin.rst
new file mode 100644
index 0000000..e87e684
--- /dev/null
+++ b/pylint/extensions/bad_builtin.rst
@@ -0,0 +1,9 @@
+This used to be the ``bad-builtin`` core checker, but it was moved to
+an extension instead. It can be used for finding prohibited used builtins,
+such as ``map`` or ``filter``, for which other alternatives exists.
+
+If you want to control for what builtins the checker should warn about,
+you can use the ``bad-functions`` option::
+
+ $ pylint a.py --load-plugins=pylint.extensions.bad_builtin --bad-functions=apply,reduce
+ ...
diff --git a/pylint/extensions/broad_try_clause.py b/pylint/extensions/broad_try_clause.py
new file mode 100644
index 0000000..5c14c99
--- /dev/null
+++ b/pylint/extensions/broad_try_clause.py
@@ -0,0 +1,76 @@
+# Copyright (c) 2019-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2019-2020 Tyler Thieding <tyler@thieding.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Looks for try/except statements with too much code in the try clause."""
+
+from astroid.node_classes import For, If, While, With
+
+from pylint import checkers, interfaces
+
+
+class BroadTryClauseChecker(checkers.BaseChecker):
+ """Checks for try clauses with too many lines.
+
+ According to PEP 8, ``try`` clauses shall contain the absolute minimum
+ amount of code. This checker enforces a maximum number of statements within
+ ``try`` clauses.
+
+ """
+
+ __implements__ = interfaces.IAstroidChecker
+
+ # configuration section name
+ name = "broad_try_clause"
+ msgs = {
+ "W0717": (
+ "%s",
+ "too-many-try-statements",
+ "Try clause contains too many statements.",
+ )
+ }
+
+ priority = -2
+ options = (
+ (
+ "max-try-statements",
+ {
+ "default": 1,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Maximum number of statements allowed in a try clause",
+ },
+ ),
+ )
+
+ def _count_statements(self, try_node):
+ statement_count = len(try_node.body)
+
+ for body_node in try_node.body:
+ if isinstance(body_node, (For, If, While, With)):
+ statement_count += self._count_statements(body_node)
+
+ return statement_count
+
+ def visit_tryexcept(self, node):
+ try_clause_statements = self._count_statements(node)
+ if try_clause_statements > self.config.max_try_statements:
+ msg = "try clause contains {} statements, expected at most {}".format(
+ try_clause_statements, self.config.max_try_statements
+ )
+ self.add_message(
+ "too-many-try-statements", node.lineno, node=node, args=msg
+ )
+
+ def visit_tryfinally(self, node):
+ self.visit_tryexcept(node)
+
+
+def register(linter):
+ """Required method to auto register this checker."""
+ linter.register_checker(BroadTryClauseChecker(linter))
diff --git a/pylint/extensions/check_docs.py b/pylint/extensions/check_docs.py
new file mode 100644
index 0000000..0a34b09
--- /dev/null
+++ b/pylint/extensions/check_docs.py
@@ -0,0 +1,25 @@
+# Copyright (c) 2014-2015 Bruno Daniel <bruno.daniel@blue-yonder.com>
+# Copyright (c) 2015-2016, 2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import warnings
+
+from pylint.extensions import docparams
+
+
+def register(linter):
+ """Required method to auto register this checker.
+
+ :param linter: Main interface object for Pylint plugins
+ :type linter: Pylint object
+ """
+ warnings.warn(
+ "This plugin is deprecated, use pylint.extensions.docparams instead.",
+ DeprecationWarning,
+ )
+ linter.register_checker(docparams.DocstringParameterChecker(linter))
diff --git a/pylint/extensions/check_elif.py b/pylint/extensions/check_elif.py
new file mode 100644
index 0000000..613f17f
--- /dev/null
+++ b/pylint/extensions/check_elif.py
@@ -0,0 +1,78 @@
+# Copyright (c) 2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import astroid
+
+from pylint.checkers import BaseTokenChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker, ITokenChecker
+
+
+class ElseifUsedChecker(BaseTokenChecker):
+ """Checks for use of "else if" when an "elif" could be used"""
+
+ __implements__ = (ITokenChecker, IAstroidChecker)
+ name = "else_if_used"
+ msgs = {
+ "R5501": (
+ 'Consider using "elif" instead of "else if"',
+ "else-if-used",
+ "Used when an else statement is immediately followed by "
+ "an if statement and does not contain statements that "
+ "would be unrelated to it.",
+ )
+ }
+
+ def __init__(self, linter=None):
+ BaseTokenChecker.__init__(self, linter)
+ self._init()
+
+ def _init(self):
+ self._elifs = []
+ self._if_counter = 0
+
+ def process_tokens(self, tokens):
+ # Process tokens and look for 'if' or 'elif'
+ for _, token, _, _, _ in tokens:
+ if token == "elif":
+ self._elifs.append(True)
+ elif token == "if":
+ self._elifs.append(False)
+
+ def leave_module(self, _):
+ self._init()
+
+ def visit_ifexp(self, node):
+ if isinstance(node.parent, astroid.FormattedValue):
+ return
+ self._if_counter += 1
+
+ def visit_comprehension(self, node):
+ self._if_counter += len(node.ifs)
+
+ @check_messages("else-if-used")
+ def visit_if(self, node):
+ if isinstance(node.parent, astroid.If):
+ orelse = node.parent.orelse
+ # current if node must directly follow an "else"
+ if orelse and orelse == [node]:
+ if not self._elifs[self._if_counter]:
+ self.add_message("else-if-used", node=node)
+ self._if_counter += 1
+
+
+def register(linter):
+ """Required method to auto register this checker.
+
+ :param linter: Main interface object for Pylint plugins
+ :type linter: Pylint object
+ """
+ linter.register_checker(ElseifUsedChecker(linter))
diff --git a/pylint/extensions/code_style.py b/pylint/extensions/code_style.py
new file mode 100644
index 0000000..1938f38
--- /dev/null
+++ b/pylint/extensions/code_style.py
@@ -0,0 +1,146 @@
+from typing import List, Set, Tuple, Type, Union
+
+import astroid
+from astroid.node_classes import NodeNG
+
+from pylint.checkers import BaseChecker, utils
+from pylint.checkers.utils import check_messages, safe_infer
+from pylint.interfaces import IAstroidChecker
+from pylint.lint import PyLinter
+
+
+class CodeStyleChecker(BaseChecker):
+ """Checkers that can improve code consistency.
+
+ As such they don't necessarily provide a performance benefit and
+ are often times opinionated.
+
+ Before adding another checker here, consider this:
+ 1. Does the checker provide a clear benefit,
+ i.e. detect a common issue or improve performance
+ => it should probably be part of the core checker classes
+ 2. Is it something that would improve code consistency,
+ maybe because it's slightly better with regards to performance
+ and therefore preferred => this is the right place
+ 3. Everything else should go into another extension
+ """
+
+ __implements__ = (IAstroidChecker,)
+
+ name = "code_style"
+ priority = -1
+ msgs = {
+ "R6101": (
+ "Consider using namedtuple or dataclass for dictionary values",
+ "consider-using-namedtuple-or-dataclass",
+ "Emitted when dictionary values can be replaced by namedtuples or dataclass instances.",
+ ),
+ "R6102": (
+ "Consider using an in-place tuple%s",
+ "consider-using-tuple",
+ "Emitted when an in-place defined list or set can be "
+ "replaced by a slightly faster tuple.",
+ ),
+ }
+
+ def __init__(self, linter: PyLinter) -> None:
+ """Initialize checker instance."""
+ super().__init__(linter=linter)
+
+ @check_messages("consider-using-namedtuple-or-dataclass")
+ def visit_dict(self, node: astroid.Dict) -> None:
+ self._check_dict_consider_namedtuple_dataclass(node)
+
+ @check_messages("consider-using-tuple")
+ def visit_for(self, node: astroid.For) -> None:
+ self._check_inplace_defined_list_set(node)
+
+ @check_messages("consider-using-tuple")
+ def visit_comprehension(self, node: astroid.Comprehension) -> None:
+ self._check_inplace_defined_list_set(node)
+
+ def _check_dict_consider_namedtuple_dataclass(self, node: astroid.Dict) -> None:
+ """Check if dictionary values can be replaced by Namedtuple or Dataclass."""
+ if not (
+ isinstance(node.parent, (astroid.Assign, astroid.AnnAssign))
+ and isinstance(node.parent.parent, astroid.Module)
+ or isinstance(node.parent, astroid.AnnAssign)
+ and utils.is_assign_name_annotated_with(node.parent.target, "Final")
+ ):
+ # If dict is not part of an 'Assign' or 'AnnAssign' node in
+ # a module context OR 'AnnAssign' with 'Final' annotation, skip check.
+ return
+
+ # All dict_values are itself dict nodes
+ if len(node.items) > 1 and all(
+ isinstance(dict_value, astroid.Dict) for _, dict_value in node.items
+ ):
+ KeyTupleT = Tuple[Type[NodeNG], str]
+
+ # Makes sure all keys are 'Const' string nodes
+ keys_checked: Set[KeyTupleT] = set()
+ for _, dict_value in node.items:
+ for key, _ in dict_value.items:
+ key_tuple = (type(key), key.as_string())
+ if key_tuple in keys_checked:
+ continue
+ inferred = safe_infer(key)
+ if not (
+ isinstance(inferred, astroid.Const)
+ and inferred.pytype() == "builtins.str"
+ ):
+ return
+ keys_checked.add(key_tuple)
+
+ # Makes sure all subdicts have at least 1 common key
+ key_tuples: List[Tuple[KeyTupleT, ...]] = []
+ for _, dict_value in node.items:
+ key_tuples.append(
+ tuple((type(key), key.as_string()) for key, _ in dict_value.items)
+ )
+ keys_intersection: Set[KeyTupleT] = set(key_tuples[0])
+ for sub_key_tuples in key_tuples[1:]:
+ keys_intersection.intersection_update(sub_key_tuples)
+ if not keys_intersection:
+ return
+
+ self.add_message("consider-using-namedtuple-or-dataclass", node=node)
+ return
+
+ # All dict_values are itself either list or tuple nodes
+ if len(node.items) > 1 and all(
+ isinstance(dict_value, (astroid.List, astroid.Tuple))
+ for _, dict_value in node.items
+ ):
+ # Make sure all sublists have the same length > 0
+ list_length = len(node.items[0][1].elts)
+ if list_length == 0:
+ return
+ for _, dict_value in node.items[1:]:
+ if len(dict_value.elts) != list_length:
+ return
+
+ # Make sure at least one list entry isn't a dict
+ for _, dict_value in node.items:
+ if all(isinstance(entry, astroid.Dict) for entry in dict_value.elts):
+ return
+
+ self.add_message("consider-using-namedtuple-or-dataclass", node=node)
+ return
+
+ def _check_inplace_defined_list_set(
+ self, node: Union[astroid.For, astroid.Comprehension]
+ ) -> None:
+ """Check if inplace defined list / set can be replaced by a tuple."""
+ if isinstance(node.iter, (astroid.List, astroid.Set)) and not any(
+ isinstance(item, astroid.Starred) for item in node.iter.elts
+ ):
+ self.add_message(
+ "consider-using-tuple",
+ node=node.iter,
+ args=(f" instead of {node.iter.__class__.__qualname__.lower()}"),
+ )
+
+
+def register(linter: PyLinter) -> None:
+ linter.register_checker(CodeStyleChecker(linter))
diff --git a/pylint/extensions/code_style.rst b/pylint/extensions/code_style.rst
new file mode 100644
index 0000000..a7ff659
--- /dev/null
+++ b/pylint/extensions/code_style.rst
@@ -0,0 +1,3 @@
+Checkers that can improve code consistency.
+As such they don't necessarily provide a performance benefit and
+are often times opinionated.
diff --git a/pylint/extensions/comparetozero.py b/pylint/extensions/comparetozero.py
new file mode 100644
index 0000000..9c6b73e
--- /dev/null
+++ b/pylint/extensions/comparetozero.py
@@ -0,0 +1,77 @@
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2017-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 bernie gray <bfgray3@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Looks for comparisons to zero."""
+
+import itertools
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+def _is_constant_zero(node):
+ return isinstance(node, astroid.Const) and node.value == 0
+
+
+class CompareToZeroChecker(checkers.BaseChecker):
+ """Checks for comparisons to zero.
+ Most of the times you should use the fact that integers with a value of 0 are false.
+ An exception to this rule is when 0 is allowed in the program and has a
+ different meaning than None!
+ """
+
+ __implements__ = (interfaces.IAstroidChecker,)
+
+ # configuration section name
+ name = "compare-to-zero"
+ msgs = {
+ "C2001": (
+ "Avoid comparisons to zero",
+ "compare-to-zero",
+ "Used when Pylint detects comparison to a 0 constant.",
+ )
+ }
+
+ priority = -2
+ options = ()
+
+ @utils.check_messages("compare-to-zero")
+ def visit_compare(self, node):
+ _operators = ["!=", "==", "is not", "is"]
+ # note: astroid.Compare has the left most operand in node.left
+ # while the rest are a list of tuples in node.ops
+ # the format of the tuple is ('compare operator sign', node)
+ # here we squash everything into `ops` to make it easier for processing later
+ ops = [("", node.left)]
+ ops.extend(node.ops)
+ ops = list(itertools.chain(*ops))
+
+ for ops_idx in range(len(ops) - 2):
+ op_1 = ops[ops_idx]
+ op_2 = ops[ops_idx + 1]
+ op_3 = ops[ops_idx + 2]
+ error_detected = False
+
+ # 0 ?? X
+ if _is_constant_zero(op_1) and op_2 in _operators:
+ error_detected = True
+ # X ?? 0
+ elif op_2 in _operators and _is_constant_zero(op_3):
+ error_detected = True
+
+ if error_detected:
+ self.add_message("compare-to-zero", node=node)
+
+
+def register(linter):
+ """Required method to auto register this checker."""
+ linter.register_checker(CompareToZeroChecker(linter))
diff --git a/pylint/extensions/confusing_elif.py b/pylint/extensions/confusing_elif.py
new file mode 100644
index 0000000..07b6c4a
--- /dev/null
+++ b/pylint/extensions/confusing_elif.py
@@ -0,0 +1,56 @@
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import astroid
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+from pylint.lint import PyLinter
+
+
+class ConfusingConsecutiveElifChecker(BaseChecker):
+ """Checks if "elif" is used right after an indented block that finishes with "if" or "elif" itself."""
+
+ __implements__ = IAstroidChecker
+
+ name = "confusing-elif-checker"
+ priority = -1
+ msgs = {
+ "R5601": (
+ "Consecutive elif with differing indentation level, consider creating a function to separate the inner elif",
+ "confusing-consecutive-elif",
+ "Used when an elif statement follows right after an indented block which itself ends with if or elif. "
+ "It may not be ovious if the elif statement was willingly or mistakenly unindented. "
+ "Extracting the indented if statement into a separate function might avoid confusion and prevent errors.",
+ )
+ }
+
+ @check_messages("confusing-consecutive-elif")
+ def visit_if(self, node: astroid.If):
+ body_ends_with_if = isinstance(
+ node.body[-1], astroid.If
+ ) and self._has_no_else_clause(node.body[-1])
+ if node.has_elif_block() and body_ends_with_if:
+ self.add_message("confusing-consecutive-elif", node=node.orelse[0])
+
+ @staticmethod
+ def _has_no_else_clause(node: astroid.If):
+ orelse = node.orelse
+ while orelse and isinstance(orelse[0], astroid.If):
+ orelse = orelse[0].orelse
+ if not orelse or isinstance(orelse[0], astroid.If):
+ return True
+ return False
+
+
+def register(linter: PyLinter):
+ """This required method auto registers the checker.
+
+ :param linter: The linter to register the checker to.
+ :type linter: pylint.lint.PyLinter
+ """
+ linter.register_checker(ConfusingConsecutiveElifChecker(linter))
diff --git a/pylint/extensions/docparams.py b/pylint/extensions/docparams.py
new file mode 100644
index 0000000..b53802b
--- /dev/null
+++ b/pylint/extensions/docparams.py
@@ -0,0 +1,628 @@
+# Copyright (c) 2014-2015 Bruno Daniel <bruno.daniel@blue-yonder.com>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2017 John Paraskevopoulos <io.paraskev@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 Jim Robertson <jrobertson98atx@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Adam Dangoor <adamdangoor@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Luigi <luigi.cristofolini@q-ctrl.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2021 Logan Miller <14319179+komodo472@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Pylint plugin for checking in Sphinx, Google, or Numpy style docstrings
+"""
+import re
+
+import astroid
+
+from pylint.checkers import BaseChecker
+from pylint.checkers import utils as checker_utils
+from pylint.extensions import _check_docs_utils as utils
+from pylint.interfaces import IAstroidChecker
+from pylint.utils import get_global_option
+
+
+class DocstringParameterChecker(BaseChecker):
+ """Checker for Sphinx, Google, or Numpy style docstrings
+
+ * Check that all function, method and constructor parameters are mentioned
+ in the params and types part of the docstring. Constructor parameters
+ can be documented in either the class docstring or ``__init__`` docstring,
+ but not both.
+ * Check that there are no naming inconsistencies between the signature and
+ the documentation, i.e. also report documented parameters that are missing
+ in the signature. This is important to find cases where parameters are
+ renamed only in the code, not in the documentation.
+ * Check that all explicitly raised exceptions in a function are documented
+ in the function docstring. Caught exceptions are ignored.
+
+ Activate this checker by adding the line::
+
+ load-plugins=pylint.extensions.docparams
+
+ to the ``MASTER`` section of your ``.pylintrc``.
+
+ :param linter: linter object
+ :type linter: :class:`pylint.lint.PyLinter`
+ """
+
+ __implements__ = IAstroidChecker
+
+ name = "parameter_documentation"
+ msgs = {
+ "W9005": (
+ '"%s" has constructor parameters documented in class and __init__',
+ "multiple-constructor-doc",
+ "Please remove parameter declarations in the class or constructor.",
+ ),
+ "W9006": (
+ '"%s" not documented as being raised',
+ "missing-raises-doc",
+ "Please document exceptions for all raised exception types.",
+ ),
+ "W9008": (
+ "Redundant returns documentation",
+ "redundant-returns-doc",
+ "Please remove the return/rtype documentation from this method.",
+ ),
+ "W9010": (
+ "Redundant yields documentation",
+ "redundant-yields-doc",
+ "Please remove the yields documentation from this method.",
+ ),
+ "W9011": (
+ "Missing return documentation",
+ "missing-return-doc",
+ "Please add documentation about what this method returns.",
+ {"old_names": [("W9007", "old-missing-returns-doc")]},
+ ),
+ "W9012": (
+ "Missing return type documentation",
+ "missing-return-type-doc",
+ "Please document the type returned by this method.",
+ # we can't use the same old_name for two different warnings
+ # {'old_names': [('W9007', 'missing-returns-doc')]},
+ ),
+ "W9013": (
+ "Missing yield documentation",
+ "missing-yield-doc",
+ "Please add documentation about what this generator yields.",
+ {"old_names": [("W9009", "old-missing-yields-doc")]},
+ ),
+ "W9014": (
+ "Missing yield type documentation",
+ "missing-yield-type-doc",
+ "Please document the type yielded by this method.",
+ # we can't use the same old_name for two different warnings
+ # {'old_names': [('W9009', 'missing-yields-doc')]},
+ ),
+ "W9015": (
+ '"%s" missing in parameter documentation',
+ "missing-param-doc",
+ "Please add parameter declarations for all parameters.",
+ {"old_names": [("W9003", "old-missing-param-doc")]},
+ ),
+ "W9016": (
+ '"%s" missing in parameter type documentation',
+ "missing-type-doc",
+ "Please add parameter type declarations for all parameters.",
+ {"old_names": [("W9004", "old-missing-type-doc")]},
+ ),
+ "W9017": (
+ '"%s" differing in parameter documentation',
+ "differing-param-doc",
+ "Please check parameter names in declarations.",
+ ),
+ "W9018": (
+ '"%s" differing in parameter type documentation',
+ "differing-type-doc",
+ "Please check parameter names in type declarations.",
+ ),
+ "W9019": (
+ '"%s" useless ignored parameter documentation',
+ "useless-param-doc",
+ "Please remove the ignored parameter documentation.",
+ ),
+ "W9020": (
+ '"%s" useless ignored parameter type documentation',
+ "useless-type-doc",
+ "Please remove the ignored parameter type documentation.",
+ ),
+ }
+
+ options = (
+ (
+ "accept-no-param-doc",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Whether to accept totally missing parameter "
+ "documentation in the docstring of a function that has "
+ "parameters.",
+ },
+ ),
+ (
+ "accept-no-raise-doc",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Whether to accept totally missing raises "
+ "documentation in the docstring of a function that "
+ "raises an exception.",
+ },
+ ),
+ (
+ "accept-no-return-doc",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Whether to accept totally missing return "
+ "documentation in the docstring of a function that "
+ "returns a statement.",
+ },
+ ),
+ (
+ "accept-no-yields-doc",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y or n>",
+ "help": "Whether to accept totally missing yields "
+ "documentation in the docstring of a generator.",
+ },
+ ),
+ (
+ "default-docstring-type",
+ {
+ "type": "choice",
+ "default": "default",
+ "choices": list(utils.DOCSTRING_TYPES),
+ "help": "If the docstring type cannot be guessed "
+ "the specified docstring type will be used.",
+ },
+ ),
+ )
+
+ priority = -2
+
+ constructor_names = {"__init__", "__new__"}
+ not_needed_param_in_docstring = {"self", "cls"}
+
+ def visit_functiondef(self, node):
+ """Called for function and method definitions (def).
+
+ :param node: Node for a function or method definition in the AST
+ :type node: :class:`astroid.scoped_nodes.Function`
+ """
+ node_doc = utils.docstringify(node.doc, self.config.default_docstring_type)
+
+ # skip functions that match the 'no-docstring-rgx' config option
+ no_docstring_rgx = get_global_option(self, "no-docstring-rgx")
+ if no_docstring_rgx and re.match(no_docstring_rgx, node.name):
+ return
+
+ # skip functions smaller than 'docstring-min-length'
+ lines = checker_utils.get_node_last_lineno(node) - node.lineno
+ max_lines = get_global_option(self, "docstring-min-length")
+ if max_lines > -1 and lines < max_lines:
+ return
+
+ self.check_functiondef_params(node, node_doc)
+ self.check_functiondef_returns(node, node_doc)
+ self.check_functiondef_yields(node, node_doc)
+
+ def check_functiondef_params(self, node, node_doc):
+ node_allow_no_param = None
+ if node.name in self.constructor_names:
+ class_node = checker_utils.node_frame_class(node)
+ if class_node is not None:
+ class_doc = utils.docstringify(
+ class_node.doc, self.config.default_docstring_type
+ )
+ self.check_single_constructor_params(class_doc, node_doc, class_node)
+
+ # __init__ or class docstrings can have no parameters documented
+ # as long as the other documents them.
+ node_allow_no_param = (
+ class_doc.has_params()
+ or class_doc.params_documented_elsewhere()
+ or None
+ )
+ class_allow_no_param = (
+ node_doc.has_params()
+ or node_doc.params_documented_elsewhere()
+ or None
+ )
+
+ self.check_arguments_in_docstring(
+ class_doc, node.args, class_node, class_allow_no_param
+ )
+
+ self.check_arguments_in_docstring(
+ node_doc, node.args, node, node_allow_no_param
+ )
+
+ def check_functiondef_returns(self, node, node_doc):
+ if (not node_doc.supports_yields and node.is_generator()) or node.is_abstract():
+ return
+
+ return_nodes = node.nodes_of_class(astroid.Return)
+ if (node_doc.has_returns() or node_doc.has_rtype()) and not any(
+ utils.returns_something(ret_node) for ret_node in return_nodes
+ ):
+ self.add_message("redundant-returns-doc", node=node)
+
+ def check_functiondef_yields(self, node, node_doc):
+ if not node_doc.supports_yields or node.is_abstract():
+ return
+
+ if (
+ node_doc.has_yields() or node_doc.has_yields_type()
+ ) and not node.is_generator():
+ self.add_message("redundant-yields-doc", node=node)
+
+ def visit_raise(self, node):
+ func_node = node.frame()
+ if not isinstance(func_node, astroid.FunctionDef):
+ return
+
+ expected_excs = utils.possible_exc_types(node)
+
+ if not expected_excs:
+ return
+
+ if not func_node.doc:
+ # If this is a property setter,
+ # the property should have the docstring instead.
+ property_ = utils.get_setters_property(func_node)
+ if property_:
+ func_node = property_
+
+ doc = utils.docstringify(func_node.doc, self.config.default_docstring_type)
+ if not doc.is_valid():
+ if doc.doc:
+ self._handle_no_raise_doc(expected_excs, func_node)
+ return
+
+ found_excs_full_names = doc.exceptions()
+
+ # Extract just the class name, e.g. "error" from "re.error"
+ found_excs_class_names = {exc.split(".")[-1] for exc in found_excs_full_names}
+ missing_excs = expected_excs - found_excs_class_names
+ self._add_raise_message(missing_excs, func_node)
+
+ def visit_return(self, node):
+ if not utils.returns_something(node):
+ return
+
+ func_node = node.frame()
+ if not isinstance(func_node, astroid.FunctionDef):
+ return
+
+ doc = utils.docstringify(func_node.doc, self.config.default_docstring_type)
+ if not doc.is_valid() and self.config.accept_no_return_doc:
+ return
+
+ is_property = checker_utils.decorated_with_property(func_node)
+
+ if not (doc.has_returns() or (doc.has_property_returns() and is_property)):
+ self.add_message("missing-return-doc", node=func_node)
+
+ if func_node.returns:
+ return
+
+ if not (doc.has_rtype() or (doc.has_property_type() and is_property)):
+ self.add_message("missing-return-type-doc", node=func_node)
+
+ def visit_yield(self, node):
+ func_node = node.frame()
+ if not isinstance(func_node, astroid.FunctionDef):
+ return
+
+ doc = utils.docstringify(func_node.doc, self.config.default_docstring_type)
+ if not doc.is_valid() and self.config.accept_no_yields_doc:
+ return
+
+ if doc.supports_yields:
+ doc_has_yields = doc.has_yields()
+ doc_has_yields_type = doc.has_yields_type()
+ else:
+ doc_has_yields = doc.has_returns()
+ doc_has_yields_type = doc.has_rtype()
+
+ if not doc_has_yields:
+ self.add_message("missing-yield-doc", node=func_node)
+
+ if not (doc_has_yields_type or func_node.returns):
+ self.add_message("missing-yield-type-doc", node=func_node)
+
+ def visit_yieldfrom(self, node):
+ self.visit_yield(node)
+
+ def _compare_missing_args(
+ self,
+ found_argument_names,
+ message_id,
+ not_needed_names,
+ expected_argument_names,
+ warning_node,
+ ):
+ """Compare the found argument names with the expected ones and
+ generate a message if there are arguments missing.
+
+ :param found_argument_names: argument names found in the docstring
+ :type found_argument_names: set
+
+ :param message_id: pylint message id
+ :type message_id: str
+
+ :param not_needed_names: names that may be omitted
+ :type not_needed_names: set
+
+ :param expected_argument_names: Expected argument names
+ :type expected_argument_names: set
+
+ :param warning_node: The node to be analyzed
+ :type warning_node: :class:`astroid.scoped_nodes.Node`
+ """
+ missing_argument_names = (
+ expected_argument_names - found_argument_names
+ ) - not_needed_names
+ if missing_argument_names:
+ self.add_message(
+ message_id,
+ args=(", ".join(sorted(missing_argument_names)),),
+ node=warning_node,
+ )
+
+ def _compare_different_args(
+ self,
+ found_argument_names,
+ message_id,
+ not_needed_names,
+ expected_argument_names,
+ warning_node,
+ ):
+ """Compare the found argument names with the expected ones and
+ generate a message if there are extra arguments found.
+
+ :param found_argument_names: argument names found in the docstring
+ :type found_argument_names: set
+
+ :param message_id: pylint message id
+ :type message_id: str
+
+ :param not_needed_names: names that may be omitted
+ :type not_needed_names: set
+
+ :param expected_argument_names: Expected argument names
+ :type expected_argument_names: set
+
+ :param warning_node: The node to be analyzed
+ :type warning_node: :class:`astroid.scoped_nodes.Node`
+ """
+ differing_argument_names = (
+ (expected_argument_names ^ found_argument_names)
+ - not_needed_names
+ - expected_argument_names
+ )
+
+ if differing_argument_names:
+ self.add_message(
+ message_id,
+ args=(", ".join(sorted(differing_argument_names)),),
+ node=warning_node,
+ )
+
+ def _compare_ignored_args(
+ self,
+ found_argument_names,
+ message_id,
+ ignored_argument_names,
+ warning_node,
+ ):
+ """Compare the found argument names with the ignored ones and
+ generate a message if there are ignored arguments found.
+
+ :param found_argument_names: argument names found in the docstring
+ :type found_argument_names: set
+
+ :param message_id: pylint message id
+ :type message_id: str
+
+ :param ignored_argument_names: Expected argument names
+ :type ignored_argument_names: set
+
+ :param warning_node: The node to be analyzed
+ :type warning_node: :class:`astroid.scoped_nodes.Node`
+ """
+ existing_ignored_argument_names = ignored_argument_names & found_argument_names
+
+ if existing_ignored_argument_names:
+ self.add_message(
+ message_id,
+ args=(", ".join(sorted(existing_ignored_argument_names)),),
+ node=warning_node,
+ )
+
+ def check_arguments_in_docstring(
+ self, doc, arguments_node, warning_node, accept_no_param_doc=None
+ ):
+ """Check that all parameters in a function, method or class constructor
+ on the one hand and the parameters mentioned in the parameter
+ documentation (e.g. the Sphinx tags 'param' and 'type') on the other
+ hand are consistent with each other.
+
+ * Undocumented parameters except 'self' are noticed.
+ * Undocumented parameter types except for 'self' and the ``*<args>``
+ and ``**<kwargs>`` parameters are noticed.
+ * Parameters mentioned in the parameter documentation that don't or no
+ longer exist in the function parameter list are noticed.
+ * If the text "For the parameters, see" or "For the other parameters,
+ see" (ignoring additional whitespace) is mentioned in the docstring,
+ missing parameter documentation is tolerated.
+ * If there's no Sphinx style, Google style or NumPy style parameter
+ documentation at all, i.e. ``:param`` is never mentioned etc., the
+ checker assumes that the parameters are documented in another format
+ and the absence is tolerated.
+
+ :param doc: Docstring for the function, method or class.
+ :type doc: :class:`Docstring`
+
+ :param arguments_node: Arguments node for the function, method or
+ class constructor.
+ :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
+
+ :param warning_node: The node to assign the warnings to
+ :type warning_node: :class:`astroid.scoped_nodes.Node`
+
+ :param accept_no_param_doc: Whether or not to allow no parameters
+ to be documented.
+ If None then this value is read from the configuration.
+ :type accept_no_param_doc: bool or None
+ """
+ # Tolerate missing param or type declarations if there is a link to
+ # another method carrying the same name.
+ if not doc.doc:
+ return
+
+ if accept_no_param_doc is None:
+ accept_no_param_doc = self.config.accept_no_param_doc
+ tolerate_missing_params = doc.params_documented_elsewhere()
+
+ # Collect the function arguments.
+ expected_argument_names = {arg.name for arg in arguments_node.args}
+ expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
+ not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
+
+ expected_but_ignored_argument_names = set()
+ ignored_argument_names = get_global_option(self, "ignored-argument-names")
+ if ignored_argument_names:
+ expected_but_ignored_argument_names = {
+ arg
+ for arg in expected_argument_names
+ if ignored_argument_names.match(arg)
+ }
+
+ if arguments_node.vararg is not None:
+ expected_argument_names.add(arguments_node.vararg)
+ not_needed_type_in_docstring.add(arguments_node.vararg)
+ if arguments_node.kwarg is not None:
+ expected_argument_names.add(arguments_node.kwarg)
+ not_needed_type_in_docstring.add(arguments_node.kwarg)
+ params_with_doc, params_with_type = doc.match_param_docs()
+
+ # Tolerate no parameter documentation at all.
+ if not params_with_doc and not params_with_type and accept_no_param_doc:
+ tolerate_missing_params = True
+
+ if not tolerate_missing_params:
+ self._compare_missing_args(
+ params_with_doc,
+ "missing-param-doc",
+ self.not_needed_param_in_docstring
+ | expected_but_ignored_argument_names,
+ expected_argument_names,
+ warning_node,
+ )
+
+ for index, arg_name in enumerate(arguments_node.args):
+ if arguments_node.annotations[index]:
+ params_with_type.add(arg_name.name)
+ for index, arg_name in enumerate(arguments_node.kwonlyargs):
+ if arguments_node.kwonlyargs_annotations[index]:
+ params_with_type.add(arg_name.name)
+
+ if not tolerate_missing_params:
+ self._compare_missing_args(
+ params_with_type,
+ "missing-type-doc",
+ not_needed_type_in_docstring | expected_but_ignored_argument_names,
+ expected_argument_names,
+ warning_node,
+ )
+
+ self._compare_different_args(
+ params_with_doc,
+ "differing-param-doc",
+ self.not_needed_param_in_docstring,
+ expected_argument_names,
+ warning_node,
+ )
+ self._compare_different_args(
+ params_with_type,
+ "differing-type-doc",
+ not_needed_type_in_docstring,
+ expected_argument_names,
+ warning_node,
+ )
+ self._compare_ignored_args(
+ params_with_doc,
+ "useless-param-doc",
+ expected_but_ignored_argument_names,
+ warning_node,
+ )
+ self._compare_ignored_args(
+ params_with_type,
+ "useless-type-doc",
+ expected_but_ignored_argument_names,
+ warning_node,
+ )
+
+ def check_single_constructor_params(self, class_doc, init_doc, class_node):
+ if class_doc.has_params() and init_doc.has_params():
+ self.add_message(
+ "multiple-constructor-doc", args=(class_node.name,), node=class_node
+ )
+
+ def _handle_no_raise_doc(self, excs, node):
+ if self.config.accept_no_raise_doc:
+ return
+
+ self._add_raise_message(excs, node)
+
+ def _add_raise_message(self, missing_excs, node):
+ """
+ Adds a message on :param:`node` for the missing exception type.
+
+ :param missing_excs: A list of missing exception types.
+ :type missing_excs: set(str)
+
+ :param node: The node show the message on.
+ :type node: astroid.node_classes.NodeNG
+ """
+ if node.is_abstract():
+ try:
+ missing_excs.remove("NotImplementedError")
+ except KeyError:
+ pass
+
+ if not missing_excs:
+ return
+
+ self.add_message(
+ "missing-raises-doc", args=(", ".join(sorted(missing_excs)),), node=node
+ )
+
+
+def register(linter):
+ """Required method to auto register this checker.
+
+ :param linter: Main interface object for Pylint plugins
+ :type linter: Pylint object
+ """
+ linter.register_checker(DocstringParameterChecker(linter))
diff --git a/pylint/extensions/docparams.rst b/pylint/extensions/docparams.rst
new file mode 100644
index 0000000..e46c4dc
--- /dev/null
+++ b/pylint/extensions/docparams.rst
@@ -0,0 +1,152 @@
+If you document the parameters of your functions, methods and constructors and
+their types systematically in your code this optional component might
+be useful for you. Sphinx style, Google style, and Numpy style are supported.
+(For some examples, see https://pypi.python.org/pypi/sphinxcontrib-napoleon .)
+
+You can activate this checker by adding the line::
+
+ load-plugins=pylint.extensions.docparams
+
+to the ``MASTER`` section of your ``.pylintrc``.
+
+This checker verifies that all function, method, and constructor docstrings
+include documentation of the
+
+* parameters and their types
+* return value and its type
+* exceptions raised
+
+and can handle docstrings in
+
+* Sphinx style (``param``, ``type``, ``return``, ``rtype``,
+ ``raise`` / ``except``)::
+
+ def function_foo(x, y, z):
+ '''function foo ...
+
+ :param x: bla x
+ :type x: int
+
+ :param y: bla y
+ :type y: float
+
+ :param int z: bla z
+
+ :return: sum
+ :rtype: float
+
+ :raises OSError: bla
+ '''
+ return x + y + z
+
+* or the Google style (``Args:``, ``Returns:``, ``Raises:``)::
+
+ def function_foo(x, y, z):
+ '''function foo ...
+
+ Args:
+ x (int): bla x
+ y (float): bla y
+
+ z (int): bla z
+
+ Returns:
+ float: sum
+
+ Raises:
+ OSError: bla
+ '''
+ return x + y + z
+
+* or the Numpy style (``Parameters``, ``Returns``, ``Raises``)::
+
+ def function_foo(x, y, z):
+ '''function foo ...
+
+ Parameters
+ ----------
+ x: int
+ bla x
+ y: float
+ bla y
+
+ z: int
+ bla z
+
+ Returns
+ -------
+ float
+ sum
+
+ Raises
+ ------
+ OSError
+ bla
+ '''
+ return x + y + z
+
+
+You'll be notified of **missing parameter documentation** but also of
+**naming inconsistencies** between the signature and the documentation which
+often arise when parameters are renamed automatically in the code, but not in
+the documentation.
+
+Constructor parameters can be documented in either the class docstring or
+the ``__init__`` docstring, but not both::
+
+ class ClassFoo(object):
+ '''Sphinx style docstring foo
+
+ :param float x: bla x
+
+ :param y: bla y
+ :type y: int
+ '''
+ def __init__(self, x, y):
+ pass
+
+ class ClassBar(object):
+ def __init__(self, x, y):
+ '''Google style docstring bar
+
+ Args:
+ x (float): bla x
+ y (int): bla y
+ '''
+ pass
+
+In some cases, having to document all parameters is a nuisance, for instance if
+many of your functions or methods just follow a **common interface**. To remove
+this burden, the checker accepts missing parameter documentation if one of the
+following phrases is found in the docstring:
+
+* For the other parameters, see
+* For the parameters, see
+
+(with arbitrary whitespace between the words). Please add a link to the
+docstring defining the interface, e.g. a superclass method, after "see"::
+
+ def callback(x, y, z):
+ '''Sphinx style docstring for callback ...
+
+ :param x: bla x
+ :type x: int
+
+ For the other parameters, see
+ :class:`MyFrameworkUsingAndDefiningCallback`
+ '''
+ return x + y + z
+
+ def callback(x, y, z):
+ '''Google style docstring for callback ...
+
+ Args:
+ x (int): bla x
+
+ For the other parameters, see
+ :class:`MyFrameworkUsingAndDefiningCallback`
+ '''
+ return x + y + z
+
+Naming inconsistencies in existing parameter and their type documentations are
+still detected.
diff --git a/pylint/extensions/docstyle.py b/pylint/extensions/docstyle.py
new file mode 100644
index 0000000..9f0e545
--- /dev/null
+++ b/pylint/extensions/docstyle.py
@@ -0,0 +1,91 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Luis Escobar <lescobar@vauxoo.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import linecache
+
+from pylint import checkers
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import HIGH, IAstroidChecker
+
+
+class DocStringStyleChecker(checkers.BaseChecker):
+ """Checks format of docstrings based on PEP 0257"""
+
+ __implements__ = IAstroidChecker
+ name = "docstyle"
+
+ msgs = {
+ "C0198": (
+ 'Bad docstring quotes in %s, expected """, given %s',
+ "bad-docstring-quotes",
+ "Used when a docstring does not have triple double quotes.",
+ ),
+ "C0199": (
+ "First line empty in %s docstring",
+ "docstring-first-line-empty",
+ "Used when a blank line is found at the beginning of a docstring.",
+ ),
+ }
+
+ @check_messages("docstring-first-line-empty", "bad-docstring-quotes")
+ def visit_module(self, node):
+ self._check_docstring("module", node)
+
+ def visit_classdef(self, node):
+ self._check_docstring("class", node)
+
+ def visit_functiondef(self, node):
+ ftype = "method" if node.is_method() else "function"
+ self._check_docstring(ftype, node)
+
+ visit_asyncfunctiondef = visit_functiondef
+
+ def _check_docstring(self, node_type, node):
+ docstring = node.doc
+ if docstring and docstring[0] == "\n":
+ self.add_message(
+ "docstring-first-line-empty",
+ node=node,
+ args=(node_type,),
+ confidence=HIGH,
+ )
+
+ # Use "linecache", instead of node.as_string(), because the latter
+ # looses the original form of the docstrings.
+
+ if docstring:
+ lineno = node.fromlineno + 1
+ line = linecache.getline(node.root().file, lineno).lstrip()
+ if line and line.find('"""') == 0:
+ return
+ if line and "'''" in line:
+ quotes = "'''"
+ elif line and line[0] == '"':
+ quotes = '"'
+ elif line and line[0] == "'":
+ quotes = "'"
+ else:
+ quotes = False
+ if quotes:
+ self.add_message(
+ "bad-docstring-quotes",
+ node=node,
+ args=(node_type, quotes),
+ confidence=HIGH,
+ )
+
+
+def register(linter):
+ """Required method to auto register this checker.
+
+ :param linter: Main interface object for Pylint plugins
+ :type linter: Pylint object
+ """
+ linter.register_checker(DocStringStyleChecker(linter))
diff --git a/pylint/extensions/empty_comment.py b/pylint/extensions/empty_comment.py
new file mode 100644
index 0000000..a6f2ede
--- /dev/null
+++ b/pylint/extensions/empty_comment.py
@@ -0,0 +1,56 @@
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IRawChecker
+
+
+def is_line_commented(line):
+ """Checks if a `# symbol that is not part of a string was found in line"""
+
+ comment_idx = line.find(b"#")
+ if comment_idx == -1:
+ return False
+ if comment_part_of_string(line, comment_idx):
+ return is_line_commented(line[:comment_idx] + line[comment_idx + 1 :])
+ return True
+
+
+def comment_part_of_string(line, comment_idx):
+ """checks if the symbol at comment_idx is part of a string"""
+
+ if (
+ line[:comment_idx].count(b"'") % 2 == 1
+ and line[comment_idx:].count(b"'") % 2 == 1
+ ) or (
+ line[:comment_idx].count(b'"') % 2 == 1
+ and line[comment_idx:].count(b'"') % 2 == 1
+ ):
+ return True
+ return False
+
+
+class CommentChecker(BaseChecker):
+ __implements__ = IRawChecker
+
+ name = "refactoring"
+ msgs = {
+ "R2044": (
+ "Line with empty comment",
+ "empty-comment",
+ (
+ "Used when a # symbol appears on a line not followed by an actual comment"
+ ),
+ )
+ }
+ options = ()
+ priority = -1 # low priority
+
+ def process_module(self, node):
+ with node.stream() as stream:
+ for (line_num, line) in enumerate(stream):
+ line = line.rstrip()
+ if line.endswith(b"#"):
+ if not is_line_commented(line[:-1]):
+ self.add_message("empty-comment", line=line_num + 1)
+
+
+def register(linter):
+ linter.register_checker(CommentChecker(linter))
diff --git a/pylint/extensions/emptystring.py b/pylint/extensions/emptystring.py
new file mode 100644
index 0000000..82a1a5f
--- /dev/null
+++ b/pylint/extensions/emptystring.py
@@ -0,0 +1,76 @@
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2017-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Looks for comparisons to empty string."""
+
+import itertools
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+def _is_constant_empty_str(node):
+ return isinstance(node, astroid.Const) and node.value == ""
+
+
+class CompareToEmptyStringChecker(checkers.BaseChecker):
+ """Checks for comparisons to empty string.
+ Most of the times you should use the fact that empty strings are false.
+ An exception to this rule is when an empty string value is allowed in the program
+ and has a different meaning than None!
+ """
+
+ __implements__ = (interfaces.IAstroidChecker,)
+
+ # configuration section name
+ name = "compare-to-empty-string"
+ msgs = {
+ "C1901": (
+ "Avoid comparisons to empty string",
+ "compare-to-empty-string",
+ "Used when Pylint detects comparison to an empty string constant.",
+ )
+ }
+
+ priority = -2
+ options = ()
+
+ @utils.check_messages("compare-to-empty-string")
+ def visit_compare(self, node):
+ _operators = ["!=", "==", "is not", "is"]
+ # note: astroid.Compare has the left most operand in node.left
+ # while the rest are a list of tuples in node.ops
+ # the format of the tuple is ('compare operator sign', node)
+ # here we squash everything into `ops` to make it easier for processing later
+ ops = [("", node.left)]
+ ops.extend(node.ops)
+ ops = list(itertools.chain(*ops))
+
+ for ops_idx in range(len(ops) - 2):
+ op_1 = ops[ops_idx]
+ op_2 = ops[ops_idx + 1]
+ op_3 = ops[ops_idx + 2]
+ error_detected = False
+
+ # x ?? ""
+ if _is_constant_empty_str(op_1) and op_2 in _operators:
+ error_detected = True
+ # '' ?? X
+ elif op_2 in _operators and _is_constant_empty_str(op_3):
+ error_detected = True
+
+ if error_detected:
+ self.add_message("compare-to-empty-string", node=node)
+
+
+def register(linter):
+ """Required method to auto register this checker."""
+ linter.register_checker(CompareToEmptyStringChecker(linter))
diff --git a/pylint/extensions/mccabe.py b/pylint/extensions/mccabe.py
new file mode 100644
index 0000000..a541d09
--- /dev/null
+++ b/pylint/extensions/mccabe.py
@@ -0,0 +1,199 @@
+# Copyright (c) 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Module to add McCabe checker class for pylint. """
+
+from mccabe import PathGraph as Mccabe_PathGraph
+from mccabe import PathGraphingAstVisitor as Mccabe_PathGraphingAstVisitor
+
+from pylint import checkers
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import HIGH, IAstroidChecker
+
+
+class PathGraph(Mccabe_PathGraph):
+ def __init__(self, node):
+ super().__init__(name="", entity="", lineno=1)
+ self.root = node
+
+
+class PathGraphingAstVisitor(Mccabe_PathGraphingAstVisitor):
+ def __init__(self):
+ super().__init__()
+ self._bottom_counter = 0
+
+ def default(self, node, *args):
+ for child in node.get_children():
+ self.dispatch(child, *args)
+
+ def dispatch(self, node, *args):
+ self.node = node
+ klass = node.__class__
+ meth = self._cache.get(klass)
+ if meth is None:
+ class_name = klass.__name__
+ meth = getattr(self.visitor, "visit" + class_name, self.default)
+ self._cache[klass] = meth
+ return meth(node, *args)
+
+ def visitFunctionDef(self, node):
+ if self.graph is not None:
+ # closure
+ pathnode = self._append_node(node)
+ self.tail = pathnode
+ self.dispatch_list(node.body)
+ bottom = "%s" % self._bottom_counter
+ self._bottom_counter += 1
+ self.graph.connect(self.tail, bottom)
+ self.graph.connect(node, bottom)
+ self.tail = bottom
+ else:
+ self.graph = PathGraph(node)
+ self.tail = node
+ self.dispatch_list(node.body)
+ self.graphs[f"{self.classname}{node.name}"] = self.graph
+ self.reset()
+
+ visitAsyncFunctionDef = visitFunctionDef
+
+ def visitSimpleStatement(self, node):
+ self._append_node(node)
+
+ visitAssert = (
+ visitAssign
+ ) = (
+ visitAugAssign
+ ) = (
+ visitDelete
+ ) = (
+ visitPrint
+ ) = (
+ visitRaise
+ ) = (
+ visitYield
+ ) = (
+ visitImport
+ ) = (
+ visitCall
+ ) = (
+ visitSubscript
+ ) = (
+ visitPass
+ ) = (
+ visitContinue
+ ) = (
+ visitBreak
+ ) = visitGlobal = visitReturn = visitExpr = visitAwait = visitSimpleStatement
+
+ def visitWith(self, node):
+ self._append_node(node)
+ self.dispatch_list(node.body)
+
+ visitAsyncWith = visitWith
+
+ def _append_node(self, node):
+ if not self.tail:
+ return None
+ self.graph.connect(self.tail, node)
+ self.tail = node
+ return node
+
+ def _subgraph(self, node, name, extra_blocks=()):
+ """create the subgraphs representing any `if` and `for` statements"""
+ if self.graph is None:
+ # global loop
+ self.graph = PathGraph(node)
+ self._subgraph_parse(node, node, extra_blocks)
+ self.graphs[f"{self.classname}{name}"] = self.graph
+ self.reset()
+ else:
+ self._append_node(node)
+ self._subgraph_parse(node, node, extra_blocks)
+
+ def _subgraph_parse(self, node, pathnode, extra_blocks):
+ """parse the body and any `else` block of `if` and `for` statements"""
+ loose_ends = []
+ self.tail = node
+ self.dispatch_list(node.body)
+ loose_ends.append(self.tail)
+ for extra in extra_blocks:
+ self.tail = node
+ self.dispatch_list(extra.body)
+ loose_ends.append(self.tail)
+ if node.orelse:
+ self.tail = node
+ self.dispatch_list(node.orelse)
+ loose_ends.append(self.tail)
+ else:
+ loose_ends.append(node)
+ if node:
+ bottom = "%s" % self._bottom_counter
+ self._bottom_counter += 1
+ for end in loose_ends:
+ self.graph.connect(end, bottom)
+ self.tail = bottom
+
+
+class McCabeMethodChecker(checkers.BaseChecker):
+ """Checks McCabe complexity cyclomatic threshold in methods and functions
+ to validate a too complex code.
+ """
+
+ __implements__ = IAstroidChecker
+ name = "design"
+
+ msgs = {
+ "R1260": (
+ "%s is too complex. The McCabe rating is %d",
+ "too-complex",
+ "Used when a method or function is too complex based on "
+ "McCabe Complexity Cyclomatic",
+ )
+ }
+ options = (
+ (
+ "max-complexity",
+ {
+ "default": 10,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "McCabe complexity cyclomatic threshold",
+ },
+ ),
+ )
+
+ @check_messages("too-complex")
+ def visit_module(self, node):
+ """visit an astroid.Module node to check too complex rating and
+ add message if is greather than max_complexity stored from options"""
+ visitor = PathGraphingAstVisitor()
+ for child in node.body:
+ visitor.preorder(child, visitor)
+ for graph in visitor.graphs.values():
+ complexity = graph.complexity()
+ node = graph.root
+ if hasattr(node, "name"):
+ node_name = "'%s'" % node.name
+ else:
+ node_name = "This '%s'" % node.__class__.__name__.lower()
+ if complexity <= self.config.max_complexity:
+ continue
+ self.add_message(
+ "too-complex", node=node, confidence=HIGH, args=(node_name, complexity)
+ )
+
+
+def register(linter):
+ """Required method to auto register this checker.
+
+ :param linter: Main interface object for Pylint plugins
+ :type linter: Pylint object
+ """
+ linter.register_checker(McCabeMethodChecker(linter))
diff --git a/pylint/extensions/mccabe.rst b/pylint/extensions/mccabe.rst
new file mode 100644
index 0000000..e63d5b2
--- /dev/null
+++ b/pylint/extensions/mccabe.rst
@@ -0,0 +1,37 @@
+You can now use this plugin for finding complexity issues in your code base.
+
+Activate it through ``pylint --load-plugins=pylint.extensions.mccabe``. It introduces
+a new warning, ``too-complex``, which is emitted when a code block has a complexity
+higher than a preestablished value, which can be controlled through the
+``max-complexity`` option, such as in this example::
+
+ $ cat a.py
+ def f10():
+ """McCabe rating: 11"""
+ myint = 2
+ if myint == 5:
+ return myint
+ elif myint == 6:
+ return myint
+ elif myint == 7:
+ return myint
+ elif myint == 8:
+ return myint
+ elif myint == 9:
+ return myint
+ elif myint == 10:
+ if myint == 8:
+ while True:
+ return True
+ elif myint == 8:
+ with myint:
+ return 8
+ else:
+ if myint == 2:
+ return myint
+ return myint
+ return myint
+ $ pylint a.py --load-plugins=pylint.extensions.mccabe
+ R:1: 'f10' is too complex. The McCabe rating is 11 (too-complex)
+ $ pylint a.py --load-plugins=pylint.extensions.mccabe --max-complexity=50
+ $
diff --git a/pylint/extensions/overlapping_exceptions.py b/pylint/extensions/overlapping_exceptions.py
new file mode 100644
index 0000000..4f9f41b
--- /dev/null
+++ b/pylint/extensions/overlapping_exceptions.py
@@ -0,0 +1,86 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Looks for overlapping exceptions."""
+
+import astroid
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.checkers.exceptions import _annotated_unpack_infer
+
+
+class OverlappingExceptionsChecker(checkers.BaseChecker):
+ """Checks for two or more exceptions in the same exception handler
+ clause that are identical or parts of the same inheritance hierarchy
+ (i.e. overlapping)."""
+
+ __implements__ = interfaces.IAstroidChecker
+
+ name = "overlap-except"
+ msgs = {
+ "W0714": (
+ "Overlapping exceptions (%s)",
+ "overlapping-except",
+ "Used when exceptions in handler overlap or are identical",
+ )
+ }
+ priority = -2
+ options = ()
+
+ @utils.check_messages("overlapping-except")
+ def visit_tryexcept(self, node):
+ """check for empty except"""
+ for handler in node.handlers:
+ if handler.type is None:
+ continue
+ if isinstance(handler.type, astroid.BoolOp):
+ continue
+ try:
+ excs = list(_annotated_unpack_infer(handler.type))
+ except astroid.InferenceError:
+ continue
+
+ handled_in_clause = []
+ for part, exc in excs:
+ if exc is astroid.Uninferable:
+ continue
+ if isinstance(exc, astroid.Instance) and utils.inherit_from_std_ex(exc):
+ # pylint: disable=protected-access
+ exc = exc._proxied
+
+ if not isinstance(exc, astroid.ClassDef):
+ continue
+
+ exc_ancestors = [
+ anc for anc in exc.ancestors() if isinstance(anc, astroid.ClassDef)
+ ]
+
+ for prev_part, prev_exc in handled_in_clause:
+ prev_exc_ancestors = [
+ anc
+ for anc in prev_exc.ancestors()
+ if isinstance(anc, astroid.ClassDef)
+ ]
+ if exc == prev_exc:
+ self.add_message(
+ "overlapping-except",
+ node=handler.type,
+ args="%s and %s are the same"
+ % (prev_part.as_string(), part.as_string()),
+ )
+ elif prev_exc in exc_ancestors or exc in prev_exc_ancestors:
+ ancestor = part if exc in prev_exc_ancestors else prev_part
+ descendant = part if prev_exc in exc_ancestors else prev_part
+ self.add_message(
+ "overlapping-except",
+ node=handler.type,
+ args="%s is an ancestor class of %s"
+ % (ancestor.as_string(), descendant.as_string()),
+ )
+ handled_in_clause += [(part, exc)]
+
+
+def register(linter):
+ """Required method to auto register this checker."""
+ linter.register_checker(OverlappingExceptionsChecker(linter))
diff --git a/pylint/extensions/redefined_variable_type.py b/pylint/extensions/redefined_variable_type.py
new file mode 100644
index 0000000..4bfa1ad
--- /dev/null
+++ b/pylint/extensions/redefined_variable_type.py
@@ -0,0 +1,118 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import astroid
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages, is_none, node_type
+from pylint.interfaces import IAstroidChecker
+
+BUILTINS = "builtins"
+
+
+class MultipleTypesChecker(BaseChecker):
+ """Checks for variable type redefinitions (NoneType excepted)
+
+ At a function, method, class or module scope
+
+ This rule could be improved:
+
+ - Currently, if an attribute is set to different types in 2 methods of a
+ same class, it won't be detected (see functional test)
+ - One could improve the support for inference on assignment with tuples,
+ ifexpr, etc. Also it would be great to have support for inference on
+ str.split()
+ """
+
+ __implements__ = IAstroidChecker
+
+ name = "multiple_types"
+ msgs = {
+ "R0204": (
+ "Redefinition of %s type from %s to %s",
+ "redefined-variable-type",
+ "Used when the type of a variable changes inside a "
+ "method or a function.",
+ )
+ }
+
+ def visit_classdef(self, _):
+ self._assigns.append({})
+
+ @check_messages("redefined-variable-type")
+ def leave_classdef(self, _):
+ self._check_and_add_messages()
+
+ visit_functiondef = visit_classdef
+ leave_functiondef = leave_module = leave_classdef
+
+ def visit_module(self, _):
+ self._assigns = [{}]
+
+ def _check_and_add_messages(self):
+ assigns = self._assigns.pop()
+ for name, args in assigns.items():
+ if len(args) <= 1:
+ continue
+ orig_node, orig_type = args[0]
+ # Check if there is a type in the following nodes that would be
+ # different from orig_type.
+ for redef_node, redef_type in args[1:]:
+ if redef_type == orig_type:
+ continue
+ # if a variable is defined to several types in an if node,
+ # this is not actually redefining.
+ orig_parent = orig_node.parent
+ redef_parent = redef_node.parent
+ if isinstance(orig_parent, astroid.If):
+ if orig_parent == redef_parent:
+ if (
+ redef_node in orig_parent.orelse
+ and orig_node not in orig_parent.orelse
+ ):
+ orig_node, orig_type = redef_node, redef_type
+ continue
+ elif isinstance(
+ redef_parent, astroid.If
+ ) and redef_parent in orig_parent.nodes_of_class(astroid.If):
+ orig_node, orig_type = redef_node, redef_type
+ continue
+ orig_type = orig_type.replace(BUILTINS + ".", "")
+ redef_type = redef_type.replace(BUILTINS + ".", "")
+ self.add_message(
+ "redefined-variable-type",
+ node=redef_node,
+ args=(name, orig_type, redef_type),
+ )
+ break
+
+ def visit_assign(self, node):
+ # we don't handle multiple assignment nor slice assignment
+ target = node.targets[0]
+ if isinstance(target, (astroid.Tuple, astroid.Subscript)):
+ return
+ # ignore NoneType
+ if is_none(node):
+ return
+ _type = node_type(node.value)
+ if _type:
+ self._assigns[-1].setdefault(target.as_string(), []).append(
+ (node, _type.pytype())
+ )
+
+
+def register(linter):
+ """Required method to auto register this checker.
+
+ :param linter: Main interface object for Pylint plugins
+ :type linter: Pylint object
+ """
+ linter.register_checker(MultipleTypesChecker(linter))
diff --git a/pylint/extensions/typing.py b/pylint/extensions/typing.py
new file mode 100644
index 0000000..c2ba28d
--- /dev/null
+++ b/pylint/extensions/typing.py
@@ -0,0 +1,318 @@
+from functools import lru_cache
+from typing import Dict, List, NamedTuple, Set, Union
+
+import astroid
+import astroid.bases
+import astroid.node_classes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import (
+ check_messages,
+ is_node_in_type_annotation_context,
+ safe_infer,
+)
+from pylint.interfaces import IAstroidChecker
+from pylint.lint import PyLinter
+
+
+class TypingAlias(NamedTuple):
+ name: str
+ name_collision: bool
+
+
+DEPRECATED_TYPING_ALIASES: Dict[str, TypingAlias] = {
+ "typing.Tuple": TypingAlias("tuple", False),
+ "typing.List": TypingAlias("list", False),
+ "typing.Dict": TypingAlias("dict", False),
+ "typing.Set": TypingAlias("set", False),
+ "typing.FrozenSet": TypingAlias("frozenset", False),
+ "typing.Type": TypingAlias("type", False),
+ "typing.Deque": TypingAlias("collections.deque", True),
+ "typing.DefaultDict": TypingAlias("collections.defaultdict", True),
+ "typing.OrderedDict": TypingAlias("collections.OrderedDict", True),
+ "typing.Counter": TypingAlias("collections.Counter", True),
+ "typing.ChainMap": TypingAlias("collections.ChainMap", True),
+ "typing.Awaitable": TypingAlias("collections.abc.Awaitable", True),
+ "typing.Coroutine": TypingAlias("collections.abc.Coroutine", True),
+ "typing.AsyncIterable": TypingAlias("collections.abc.AsyncIterable", True),
+ "typing.AsyncIterator": TypingAlias("collections.abc.AsyncIterator", True),
+ "typing.AsyncGenerator": TypingAlias("collections.abc.AsyncGenerator", True),
+ "typing.Iterable": TypingAlias("collections.abc.Iterable", True),
+ "typing.Iterator": TypingAlias("collections.abc.Iterator", True),
+ "typing.Generator": TypingAlias("collections.abc.Generator", True),
+ "typing.Reversible": TypingAlias("collections.abc.Reversible", True),
+ "typing.Container": TypingAlias("collections.abc.Container", True),
+ "typing.Collection": TypingAlias("collections.abc.Collection", True),
+ "typing.Callable": TypingAlias("collections.abc.Callable", True),
+ "typing.AbstractSet": TypingAlias("collections.abc.Set", False),
+ "typing.MutableSet": TypingAlias("collections.abc.MutableSet", True),
+ "typing.Mapping": TypingAlias("collections.abc.Mapping", True),
+ "typing.MutableMapping": TypingAlias("collections.abc.MutableMapping", True),
+ "typing.Sequence": TypingAlias("collections.abc.Sequence", True),
+ "typing.MutableSequence": TypingAlias("collections.abc.MutableSequence", True),
+ "typing.ByteString": TypingAlias("collections.abc.ByteString", True),
+ "typing.MappingView": TypingAlias("collections.abc.MappingView", True),
+ "typing.KeysView": TypingAlias("collections.abc.KeysView", True),
+ "typing.ItemsView": TypingAlias("collections.abc.ItemsView", True),
+ "typing.ValuesView": TypingAlias("collections.abc.ValuesView", True),
+ "typing.ContextManager": TypingAlias("contextlib.AbstractContextManager", False),
+ "typing.AsyncContextManager": TypingAlias(
+ "contextlib.AbstractAsyncContextManager", False
+ ),
+ "typing.Pattern": TypingAlias("re.Pattern", True),
+ "typing.Match": TypingAlias("re.Match", True),
+ "typing.Hashable": TypingAlias("collections.abc.Hashable", True),
+ "typing.Sized": TypingAlias("collections.abc.Sized", True),
+}
+
+ALIAS_NAMES = frozenset(key.split(".")[1] for key in DEPRECATED_TYPING_ALIASES)
+UNION_NAMES = ("Optional", "Union")
+
+
+class DeprecatedTypingAliasMsg(NamedTuple):
+ node: Union[astroid.Name, astroid.Attribute]
+ qname: str
+ alias: str
+ parent_subscript: bool
+
+
+class TypingChecker(BaseChecker):
+ """Find issue specifically related to type annotations."""
+
+ __implements__ = (IAstroidChecker,)
+
+ name = "typing"
+ priority = -1
+ msgs = {
+ "W6001": (
+ "'%s' is deprecated, use '%s' instead",
+ "deprecated-typing-alias",
+ "Emitted when a deprecated typing alias is used.",
+ ),
+ "R6002": (
+ "'%s' will be deprecated with PY39, consider using '%s' instead%s",
+ "consider-using-alias",
+ "Only emitted if 'runtime-typing=no' and a deprecated "
+ "typing alias is used in a type annotation context in "
+ "Python 3.7 or 3.8.",
+ ),
+ "R6003": (
+ "Consider using alternative Union syntax instead of '%s'%s",
+ "consider-alternative-union-syntax",
+ "Emitted when 'typing.Union' or 'typing.Optional' is used "
+ "instead of the alternative Union syntax 'int | None'.",
+ ),
+ }
+ options = (
+ (
+ "py-version",
+ {
+ "default": (3, 7),
+ "type": "py_version",
+ "metavar": "<py_version>",
+ "help": (
+ "Min Python version to use for typing related checks, "
+ "e.g. ``3.7``. This should be equal to the min supported Python "
+ "version of the project."
+ ),
+ },
+ ),
+ (
+ "runtime-typing",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "help": (
+ "Set to ``no`` if the app / library does **NOT** need to "
+ "support runtime introspection of type annotations. "
+ "If you use type annotations **exclusively** for type checking "
+ "of an application, you're probably fine. For libraries, "
+ "evaluate if some users what to access the type hints "
+ "at runtime first, e.g., through ``typing.get_type_hints``. "
+ "Applies to Python versions 3.7 - 3.9"
+ ),
+ },
+ ),
+ )
+
+ def __init__(self, linter: PyLinter) -> None:
+ """Initialize checker instance."""
+ super().__init__(linter=linter)
+ self._alias_name_collisions: Set[str] = set()
+ self._consider_using_alias_msgs: List[DeprecatedTypingAliasMsg] = []
+
+ @lru_cache()
+ def _py37_plus(self) -> bool:
+ return self.config.py_version >= (3, 7)
+
+ @lru_cache()
+ def _py39_plus(self) -> bool:
+ return self.config.py_version >= (3, 9)
+
+ @lru_cache()
+ def _py310_plus(self) -> bool:
+ return self.config.py_version >= (3, 10)
+
+ @lru_cache()
+ def _should_check_typing_alias(self) -> bool:
+ """The use of type aliases (PEP 585) requires Python 3.9
+ or Python 3.7+ with postponed evaluation.
+ """
+ return (
+ self._py39_plus()
+ or self._py37_plus()
+ and self.config.runtime_typing is False
+ )
+
+ @lru_cache()
+ def _should_check_alternative_union_syntax(self) -> bool:
+ """The use of alternative union syntax (PEP 604) requires Python 3.10
+ or Python 3.7+ with postponed evaluation.
+ """
+ return (
+ self._py310_plus()
+ or self._py37_plus()
+ and self.config.runtime_typing is False
+ )
+
+ def _msg_postponed_eval_hint(self, node) -> str:
+ """Message hint if postponed evaluation isn't enabled."""
+ if self._py310_plus() or "annotations" in node.root().future_imports:
+ return ""
+ return ". Add 'from __future__ import annotations' as well"
+
+ @check_messages(
+ "deprecated-typing-alias",
+ "consider-using-alias",
+ "consider-alternative-union-syntax",
+ )
+ def visit_name(self, node: astroid.Name) -> None:
+ if self._should_check_typing_alias() and node.name in ALIAS_NAMES:
+ self._check_for_typing_alias(node)
+ if self._should_check_alternative_union_syntax() and node.name in UNION_NAMES:
+ self._check_for_alternative_union_syntax(node, node.name)
+
+ @check_messages(
+ "deprecated-typing-alias",
+ "consider-using-alias",
+ "consider-alternative-union-syntax",
+ )
+ def visit_attribute(self, node: astroid.Attribute):
+ if self._should_check_typing_alias() and node.attrname in ALIAS_NAMES:
+ self._check_for_typing_alias(node)
+ if (
+ self._should_check_alternative_union_syntax()
+ and node.attrname in UNION_NAMES
+ ):
+ self._check_for_alternative_union_syntax(node, node.attrname)
+
+ def _check_for_alternative_union_syntax(
+ self,
+ node: Union[astroid.Name, astroid.Attribute],
+ name: str,
+ ) -> None:
+ """Check if alternative union syntax could be used.
+
+ Requires
+ - Python 3.10
+ - OR: Python 3.7+ with postponed evaluation in
+ a type annotation context
+ """
+ inferred = safe_infer(node)
+ if not (
+ isinstance(inferred, astroid.FunctionDef)
+ and inferred.qname()
+ in (
+ "typing.Optional",
+ "typing.Union",
+ )
+ or isinstance(inferred, astroid.bases.Instance)
+ and inferred.qname() == "typing._SpecialForm"
+ ):
+ return
+ if not (self._py310_plus() or is_node_in_type_annotation_context(node)):
+ return
+ self.add_message(
+ "consider-alternative-union-syntax",
+ node=node,
+ args=(name, self._msg_postponed_eval_hint(node)),
+ )
+
+ def _check_for_typing_alias(
+ self,
+ node: Union[astroid.Name, astroid.Attribute],
+ ) -> None:
+ """Check if typing alias is depecated or could be replaced.
+
+ Requires
+ - Python 3.9
+ - OR: Python 3.7+ with postponed evaluation in
+ a type annotation context
+
+ For Python 3.7+: Only emitt message if change doesn't create
+ any name collisions, only ever used in a type annotation
+ context, and can safely be replaced.
+ """
+ inferred = safe_infer(node)
+ if not isinstance(inferred, astroid.ClassDef):
+ return
+ alias = DEPRECATED_TYPING_ALIASES.get(inferred.qname(), None)
+ if alias is None:
+ return
+
+ if self._py39_plus():
+ self.add_message(
+ "deprecated-typing-alias",
+ node=node,
+ args=(inferred.qname(), alias.name),
+ )
+ return
+
+ # For PY37+, check for type annotation context first
+ if not is_node_in_type_annotation_context(node) and isinstance(
+ node.parent, astroid.Subscript
+ ):
+ if alias.name_collision is True:
+ self._alias_name_collisions.add(inferred.qname())
+ return
+ self._consider_using_alias_msgs.append(
+ DeprecatedTypingAliasMsg(
+ node,
+ inferred.qname(),
+ alias.name,
+ isinstance(node.parent, astroid.Subscript),
+ )
+ )
+
+ @check_messages("consider-using-alias")
+ def leave_module(self, node: astroid.Module) -> None:
+ """After parsing of module is complete, add messages for
+ 'consider-using-alias' check. Make sure results are safe
+ to recommend / collision free.
+ """
+ if self._py37_plus() and not self._py39_plus():
+ msg_future_import = self._msg_postponed_eval_hint(node)
+ while True:
+ try:
+ msg = self._consider_using_alias_msgs.pop(0)
+ except IndexError:
+ break
+ if msg.qname in self._alias_name_collisions:
+ continue
+ self.add_message(
+ "consider-using-alias",
+ node=msg.node,
+ args=(
+ msg.qname,
+ msg.alias,
+ msg_future_import if msg.parent_subscript else "",
+ ),
+ )
+ # Clear all module cache variables
+ self._alias_name_collisions.clear()
+ self._consider_using_alias_msgs.clear()
+
+
+def register(linter: PyLinter) -> None:
+ linter.register_checker(TypingChecker(linter))
diff --git a/pylint/extensions/typing.rst b/pylint/extensions/typing.rst
new file mode 100644
index 0000000..36be9c2
--- /dev/null
+++ b/pylint/extensions/typing.rst
@@ -0,0 +1 @@
+Find issue specifically related to type annotations.
diff --git a/pylint/graph.py b/pylint/graph.py
new file mode 100644
index 0000000..366206a
--- /dev/null
+++ b/pylint/graph.py
@@ -0,0 +1,207 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 谭九鼎 <109224573@qq.com>
+# Copyright (c) 2020 Benjamin Graham <benwilliamgraham@gmail.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 Andrew Howe <howeaj@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Graph manipulation utilities.
+
+(dot generation adapted from pypy/translator/tool/make_dot.py)
+"""
+import codecs
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+
+def target_info_from_filename(filename):
+ """Transforms /some/path/foo.png into ('/some/path', 'foo.png', 'png')."""
+ basename = os.path.basename(filename)
+ storedir = os.path.dirname(os.path.abspath(filename))
+ target = os.path.splitext(filename)[-1][1:]
+ return storedir, basename, target
+
+
+class DotBackend:
+ """Dot File backend."""
+
+ def __init__(
+ self,
+ graphname,
+ rankdir=None,
+ size=None,
+ ratio=None,
+ charset="utf-8",
+ renderer="dot",
+ additional_param=None,
+ ):
+ if additional_param is None:
+ additional_param = {}
+ self.graphname = graphname
+ self.renderer = renderer
+ self.lines = []
+ self._source = None
+ self.emit("digraph %s {" % normalize_node_id(graphname))
+ if rankdir:
+ self.emit("rankdir=%s" % rankdir)
+ if ratio:
+ self.emit("ratio=%s" % ratio)
+ if size:
+ self.emit('size="%s"' % size)
+ if charset:
+ assert charset.lower() in ("utf-8", "iso-8859-1", "latin1"), (
+ "unsupported charset %s" % charset
+ )
+ self.emit('charset="%s"' % charset)
+ for param in additional_param.items():
+ self.emit("=".join(param))
+
+ def get_source(self):
+ """returns self._source"""
+ if self._source is None:
+ self.emit("}\n")
+ self._source = "\n".join(self.lines)
+ del self.lines
+ return self._source
+
+ source = property(get_source)
+
+ def generate(self, outputfile: str = None, mapfile: str = None) -> str:
+ """Generates a graph file.
+
+ :param str outputfile: filename and path [defaults to graphname.png]
+ :param str mapfile: filename and path
+
+ :rtype: str
+ :return: a path to the generated file
+ :raises RuntimeError: if the executable for rendering was not found
+ """
+ graphviz_extensions = ("dot", "gv")
+ name = self.graphname
+ if outputfile is None:
+ target = "png"
+ pdot, dot_sourcepath = tempfile.mkstemp(".gv", name)
+ ppng, outputfile = tempfile.mkstemp(".png", name)
+ os.close(pdot)
+ os.close(ppng)
+ else:
+ _, _, target = target_info_from_filename(outputfile)
+ if not target:
+ target = "png"
+ outputfile = outputfile + "." + target
+ if target not in graphviz_extensions:
+ pdot, dot_sourcepath = tempfile.mkstemp(".gv", name)
+ os.close(pdot)
+ else:
+ dot_sourcepath = outputfile
+ with codecs.open(dot_sourcepath, "w", encoding="utf8") as pdot: # type: ignore
+ pdot.write(self.source) # type: ignore
+ if target not in graphviz_extensions:
+ if shutil.which(self.renderer) is None:
+ raise RuntimeError(
+ f"Cannot generate `{outputfile}` because '{self.renderer}' "
+ "executable not found. Install graphviz, or specify a `.gv` "
+ "outputfile to produce the DOT source code."
+ )
+ use_shell = sys.platform == "win32"
+ if mapfile:
+ subprocess.call(
+ [
+ self.renderer,
+ "-Tcmapx",
+ "-o",
+ mapfile,
+ "-T",
+ target,
+ dot_sourcepath,
+ "-o",
+ outputfile,
+ ],
+ shell=use_shell,
+ )
+ else:
+ subprocess.call(
+ [self.renderer, "-T", target, dot_sourcepath, "-o", outputfile],
+ shell=use_shell,
+ )
+ os.unlink(dot_sourcepath)
+ return outputfile
+
+ def emit(self, line):
+ """Adds <line> to final output."""
+ self.lines.append(line)
+
+ def emit_edge(self, name1, name2, **props):
+ """emit an edge from <name1> to <name2>.
+ edge properties: see https://www.graphviz.org/doc/info/attrs.html
+ """
+ attrs = [f'{prop}="{value}"' for prop, value in props.items()]
+ n_from, n_to = normalize_node_id(name1), normalize_node_id(name2)
+ self.emit("{} -> {} [{}];".format(n_from, n_to, ", ".join(sorted(attrs))))
+
+ def emit_node(self, name, **props):
+ """emit a node with given properties.
+ node properties: see https://www.graphviz.org/doc/info/attrs.html
+ """
+ attrs = [f'{prop}="{value}"' for prop, value in props.items()]
+ self.emit("{} [{}];".format(normalize_node_id(name), ", ".join(sorted(attrs))))
+
+
+def normalize_node_id(nid):
+ """Returns a suitable DOT node id for `nid`."""
+ return '"%s"' % nid
+
+
+def get_cycles(graph_dict, vertices=None):
+ """given a dictionary representing an ordered graph (i.e. key are vertices
+ and values is a list of destination vertices representing edges), return a
+ list of detected cycles
+ """
+ if not graph_dict:
+ return ()
+ result = []
+ if vertices is None:
+ vertices = graph_dict.keys()
+ for vertice in vertices:
+ _get_cycles(graph_dict, [], set(), result, vertice)
+ return result
+
+
+def _get_cycles(graph_dict, path, visited, result, vertice):
+ """recursive function doing the real work for get_cycles"""
+ if vertice in path:
+ cycle = [vertice]
+ for node in path[::-1]:
+ if node == vertice:
+ break
+ cycle.insert(0, node)
+ # make a canonical representation
+ start_from = min(cycle)
+ index = cycle.index(start_from)
+ cycle = cycle[index:] + cycle[0:index]
+ # append it to result if not already in
+ if cycle not in result:
+ result.append(cycle)
+ return
+ path.append(vertice)
+ try:
+ for node in graph_dict[vertice]:
+ # don't check already visited nodes again
+ if node not in visited:
+ _get_cycles(graph_dict, path, visited, result, node)
+ visited.add(node)
+ except KeyError:
+ pass
+ path.pop()
diff --git a/pylint/interfaces.py b/pylint/interfaces.py
new file mode 100644
index 0000000..1281843
--- /dev/null
+++ b/pylint/interfaces.py
@@ -0,0 +1,101 @@
+# Copyright (c) 2009-2010, 2012-2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Interfaces for Pylint objects"""
+from collections import namedtuple
+
+Confidence = namedtuple("Confidence", ["name", "description"])
+# Warning Certainties
+HIGH = Confidence("HIGH", "No false positive possible.")
+INFERENCE = Confidence("INFERENCE", "Warning based on inference result.")
+INFERENCE_FAILURE = Confidence(
+ "INFERENCE_FAILURE", "Warning based on inference with failures."
+)
+UNDEFINED = Confidence("UNDEFINED", "Warning without any associated confidence level.")
+
+CONFIDENCE_LEVELS = [HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED]
+
+
+class Interface:
+ """Base class for interfaces."""
+
+ @classmethod
+ def is_implemented_by(cls, instance):
+ return implements(instance, cls)
+
+
+def implements(obj, interface):
+ """Return true if the give object (maybe an instance or class) implements
+ the interface.
+ """
+ kimplements = getattr(obj, "__implements__", ())
+ if not isinstance(kimplements, (list, tuple)):
+ kimplements = (kimplements,)
+ for implementedinterface in kimplements:
+ if issubclass(implementedinterface, interface):
+ return True
+ return False
+
+
+class IChecker(Interface):
+ """This is a base interface, not designed to be used elsewhere than for
+ sub interfaces definition.
+ """
+
+ def open(self):
+ """called before visiting project (i.e set of modules)"""
+
+ def close(self):
+ """called after visiting project (i.e set of modules)"""
+
+
+class IRawChecker(IChecker):
+ """interface for checker which need to parse the raw file"""
+
+ def process_module(self, astroid):
+ """process a module
+
+ the module's content is accessible via astroid.stream
+ """
+
+
+class ITokenChecker(IChecker):
+ """Interface for checkers that need access to the token list."""
+
+ def process_tokens(self, tokens):
+ """Process a module.
+
+ tokens is a list of all source code tokens in the file.
+ """
+
+
+class IAstroidChecker(IChecker):
+ """interface for checker which prefers receive events according to
+ statement type
+ """
+
+
+class IReporter(Interface):
+ """reporter collect messages and display results encapsulated in a layout"""
+
+ def handle_message(self, msg) -> None:
+ """Handle the given message object."""
+
+ def display_reports(self, layout):
+ """display results encapsulated in the layout tree"""
+
+
+__all__ = ("IRawChecker", "IAstroidChecker", "ITokenChecker", "IReporter")
diff --git a/pylint/lint/__init__.py b/pylint/lint/__init__.py
new file mode 100644
index 0000000..a7c50f3
--- /dev/null
+++ b/pylint/lint/__init__.py
@@ -0,0 +1,104 @@
+# Copyright (c) 2006-2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2008 Fabrice Douchant <Fabrice.Douchant@logilab.fr>
+# Copyright (c) 2009 Vincent
+# Copyright (c) 2009 Mads Kiilerich <mads@kiilerich.com>
+# Copyright (c) 2011-2014 Google, Inc.
+# Copyright (c) 2012 David Pursehouse <david.pursehouse@sonymobile.com>
+# Copyright (c) 2012 Kevin Jing Qiu <kevin.jing.qiu@gmail.com>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2012 JT Olds <jtolds@xnet5.com>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014-2015 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Alexandru Coman <fcoman@bitdefender.com>
+# Copyright (c) 2014 Daniel Harding <dharding@living180.net>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2014 Dan Goldsmith <djgoldsmith@googlemail.com>
+# Copyright (c) 2015-2016 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2015 Steven Myint <hg@stevenmyint.com>
+# Copyright (c) 2015 Simu Toni <simutoni@gmail.com>
+# Copyright (c) 2015 Mihai Balint <balint.mihai@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Alan Evangelista <alanoe@linux.vnet.ibm.com>
+# Copyright (c) 2017-2019 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017-2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2017 Daniel Miller <millerdev@gmail.com>
+# Copyright (c) 2017 Roman Ivanov <me@roivanov.com>
+# Copyright (c) 2017 Ned Batchelder <ned@nedbatchelder.com>
+# Copyright (c) 2018-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018-2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2018 Matus Valo <matusvalo@users.noreply.github.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Randall Leeds <randall@bleeds.info>
+# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Jason Owen <jason.a.owen@gmail.com>
+# Copyright (c) 2018 Gary Tyler McLeod <mail@garytyler.com>
+# Copyright (c) 2018 Yuval Langer <yuvallanger@mail.tau.ac.il>
+# Copyright (c) 2018 kapsh <kapsh@kap.sh>
+# Copyright (c) 2019 syutbai <syutbai@gmail.com>
+# Copyright (c) 2019 Thomas Hisch <t.hisch@gmail.com>
+# Copyright (c) 2019 Hugues <hugues.bruant@affirm.com>
+# Copyright (c) 2019 Janne Rönkkö <jannero@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 Trevor Bekolay <tbekolay@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Robert Schweizer <robert_schweizer@gmx.de>
+# Copyright (c) 2019 Andres Perez Hortal <andresperezcba@gmail.com>
+# Copyright (c) 2019 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2019 Nicolas Dickreuter <dickreuter@gmail.com>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2020 anubh-v <anubhav@u.nus.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+""" pylint [options] modules_or_packages
+
+ Check that module(s) satisfy a coding standard (and more !).
+
+ pylint --help
+
+ Display this help message and exit.
+
+ pylint --help-msg <msg-id>[,<msg-id>]
+
+ Display help messages about given message identifiers and exit.
+"""
+import sys
+
+from pylint.lint.parallel import check_parallel
+from pylint.lint.pylinter import PyLinter
+from pylint.lint.report_functions import (
+ report_messages_by_module_stats,
+ report_messages_stats,
+ report_total_messages_stats,
+)
+from pylint.lint.run import Run
+from pylint.lint.utils import (
+ ArgumentPreprocessingError,
+ _patch_sys_path,
+ fix_import_path,
+ preprocess_options,
+)
+
+__all__ = [
+ "check_parallel",
+ "PyLinter",
+ "report_messages_by_module_stats",
+ "report_messages_stats",
+ "report_total_messages_stats",
+ "Run",
+ "ArgumentPreprocessingError",
+ "_patch_sys_path",
+ "fix_import_path",
+ "preprocess_options",
+]
+
+if __name__ == "__main__":
+ Run(sys.argv[1:])
diff --git a/pylint/lint/expand_modules.py b/pylint/lint/expand_modules.py
new file mode 100644
index 0000000..11927eb
--- /dev/null
+++ b/pylint/lint/expand_modules.py
@@ -0,0 +1,140 @@
+import os
+import sys
+from typing import List, Pattern, Tuple
+
+from astroid import modutils
+
+
+def _modpath_from_file(filename, is_namespace, path=None):
+ def _is_package_cb(path, parts):
+ return modutils.check_modpath_has_init(path, parts) or is_namespace
+
+ return modutils.modpath_from_file_with_callback(
+ filename, path=path, is_package_cb=_is_package_cb
+ )
+
+
+def get_python_path(filepath: str) -> str:
+ """TODO This get the python path with the (bad) assumption that there is always
+ an __init__.py. This is not true since python 3.3 and is causing problem."""
+ dirname = os.path.realpath(os.path.expanduser(filepath))
+ if not os.path.isdir(dirname):
+ dirname = os.path.dirname(dirname)
+ while True:
+ if not os.path.exists(os.path.join(dirname, "__init__.py")):
+ return dirname
+ old_dirname = dirname
+ dirname = os.path.dirname(dirname)
+ if old_dirname == dirname:
+ return os.getcwd()
+
+
+def _is_in_ignore_list_re(element: str, ignore_list_re: List[Pattern]) -> bool:
+ """determines if the element is matched in a regex ignore-list"""
+ for file_pattern in ignore_list_re:
+ if file_pattern.match(element):
+ return True
+ return False
+
+
+def expand_modules(
+ files_or_modules: List[str],
+ ignore_list: List[str],
+ ignore_list_re: List[Pattern],
+ ignore_list_paths_re: List[Pattern],
+) -> Tuple[List[dict], List[dict]]:
+ """take a list of files/modules/packages and return the list of tuple
+ (file, module name) which have to be actually checked
+ """
+ result = []
+ errors = []
+ path = sys.path.copy()
+
+ for something in files_or_modules:
+ basename = os.path.basename(something)
+ if (
+ basename in ignore_list
+ or _is_in_ignore_list_re(os.path.basename(something), ignore_list_re)
+ or _is_in_ignore_list_re(something, ignore_list_paths_re)
+ ):
+ continue
+ module_path = get_python_path(something)
+ additional_search_path = [".", module_path] + path
+ if os.path.exists(something):
+ # this is a file or a directory
+ try:
+ modname = ".".join(
+ modutils.modpath_from_file(something, path=additional_search_path)
+ )
+ except ImportError:
+ modname = os.path.splitext(basename)[0]
+ if os.path.isdir(something):
+ filepath = os.path.join(something, "__init__.py")
+ else:
+ filepath = something
+ else:
+ # suppose it's a module or package
+ modname = something
+ try:
+ filepath = modutils.file_from_modpath(
+ modname.split("."), path=additional_search_path
+ )
+ if filepath is None:
+ continue
+ except (ImportError, SyntaxError) as ex:
+ # The SyntaxError is a Python bug and should be
+ # removed once we move away from imp.find_module: https://bugs.python.org/issue10588
+ errors.append({"key": "fatal", "mod": modname, "ex": ex})
+ continue
+ filepath = os.path.normpath(filepath)
+ modparts = (modname or something).split(".")
+ try:
+ spec = modutils.file_info_from_modpath(
+ modparts, path=additional_search_path
+ )
+ except ImportError:
+ # Might not be acceptable, don't crash.
+ is_namespace = False
+ is_directory = os.path.isdir(something)
+ else:
+ is_namespace = modutils.is_namespace(spec)
+ is_directory = modutils.is_directory(spec)
+ if not is_namespace:
+ result.append(
+ {
+ "path": filepath,
+ "name": modname,
+ "isarg": True,
+ "basepath": filepath,
+ "basename": modname,
+ }
+ )
+ has_init = (
+ not (modname.endswith(".__init__") or modname == "__init__")
+ and os.path.basename(filepath) == "__init__.py"
+ )
+ if has_init or is_namespace or is_directory:
+ for subfilepath in modutils.get_module_files(
+ os.path.dirname(filepath), ignore_list, list_all=is_namespace
+ ):
+ if filepath == subfilepath:
+ continue
+ if _is_in_ignore_list_re(
+ os.path.basename(subfilepath), ignore_list_re
+ ) or _is_in_ignore_list_re(subfilepath, ignore_list_paths_re):
+ continue
+
+ modpath = _modpath_from_file(
+ subfilepath, is_namespace, path=additional_search_path
+ )
+ submodname = ".".join(modpath)
+ result.append(
+ {
+ "path": subfilepath,
+ "name": submodname,
+ "isarg": False,
+ "basepath": filepath,
+ "basename": modname,
+ }
+ )
+ return result, errors
diff --git a/pylint/lint/parallel.py b/pylint/lint/parallel.py
new file mode 100644
index 0000000..4433575
--- /dev/null
+++ b/pylint/lint/parallel.py
@@ -0,0 +1,168 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+import functools
+
+from pylint import reporters
+from pylint.lint.utils import _patch_sys_path
+from pylint.message import Message
+
+try:
+ import multiprocessing
+except ImportError:
+ multiprocessing = None # type: ignore
+
+# PyLinter object used by worker processes when checking files using multiprocessing
+# should only be used by the worker processes
+_worker_linter = None
+
+
+def _get_new_args(message):
+ location = (
+ message.abspath,
+ message.path,
+ message.module,
+ message.obj,
+ message.line,
+ message.column,
+ )
+ return (message.msg_id, message.symbol, location, message.msg, message.confidence)
+
+
+def _merge_stats(stats):
+ merged = {}
+ by_msg = collections.Counter()
+ for stat in stats:
+ message_stats = stat.pop("by_msg", {})
+ by_msg.update(message_stats)
+
+ for key, item in stat.items():
+ if key not in merged:
+ merged[key] = item
+ elif isinstance(item, dict):
+ merged[key].update(item)
+ else:
+ merged[key] = merged[key] + item
+
+ merged["by_msg"] = by_msg
+ return merged
+
+
+def _worker_initialize(linter, arguments=None):
+ global _worker_linter # pylint: disable=global-statement
+ _worker_linter = linter
+
+ # On the worker process side the messages are just collected and passed back to
+ # parent process as _worker_check_file function's return value
+ _worker_linter.set_reporter(reporters.CollectingReporter())
+ _worker_linter.open()
+
+ # Patch sys.path so that each argument is importable just like in single job mode
+ _patch_sys_path(arguments or ())
+
+
+def _worker_check_single_file(file_item):
+ name, filepath, modname = file_item
+
+ _worker_linter.open()
+ _worker_linter.check_single_file(name, filepath, modname)
+ mapreduce_data = collections.defaultdict(list)
+ for checker in _worker_linter.get_checkers():
+ try:
+ data = checker.get_map_data()
+ except AttributeError:
+ continue
+ mapreduce_data[checker.name].append(data)
+ msgs = [_get_new_args(m) for m in _worker_linter.reporter.messages]
+ _worker_linter.reporter.reset()
+ return (
+ id(multiprocessing.current_process()),
+ _worker_linter.current_name,
+ filepath,
+ _worker_linter.file_state.base_name,
+ msgs,
+ _worker_linter.stats,
+ _worker_linter.msg_status,
+ mapreduce_data,
+ )
+
+
+def _merge_mapreduce_data(linter, all_mapreduce_data):
+ """Merges map/reduce data across workers, invoking relevant APIs on checkers"""
+ # First collate the data, preparing it so we can send it to the checkers for
+ # validation. The intent here is to collect all the mapreduce data for all checker-
+ # runs across processes - that will then be passed to a static method on the
+ # checkers to be reduced and further processed.
+ collated_map_reduce_data = collections.defaultdict(list)
+ for linter_data in all_mapreduce_data.values():
+ for run_data in linter_data:
+ for checker_name, data in run_data.items():
+ collated_map_reduce_data[checker_name].extend(data)
+
+ # Send the data to checkers that support/require consolidated data
+ original_checkers = linter.get_checkers()
+ for checker in original_checkers:
+ if checker.name in collated_map_reduce_data:
+ # Assume that if the check has returned map/reduce data that it has the
+ # reducer function
+ checker.reduce_map_data(linter, collated_map_reduce_data[checker.name])
+
+
+def check_parallel(linter, jobs, files, arguments=None):
+ """Use the given linter to lint the files with given amount of workers (jobs)
+ This splits the work filestream-by-filestream. If you need to do work across
+ multiple files, as in the similarity-checker, then inherit from MapReduceMixin and
+ implement the map/reduce mixin functionality"""
+ # The reporter does not need to be passed to worker processes, i.e. the reporter does
+ original_reporter = linter.reporter
+ linter.reporter = None
+
+ # The linter is inherited by all the pool's workers, i.e. the linter
+ # is identical to the linter object here. This is required so that
+ # a custom PyLinter object can be used.
+ initializer = functools.partial(_worker_initialize, arguments=arguments)
+ pool = multiprocessing.Pool( # pylint: disable=consider-using-with
+ jobs, initializer=initializer, initargs=[linter]
+ )
+ # ..and now when the workers have inherited the linter, the actual reporter
+ # can be set back here on the parent process so that results get stored into
+ # correct reporter
+ linter.set_reporter(original_reporter)
+ linter.open()
+ try:
+ all_stats = []
+ all_mapreduce_data = collections.defaultdict(list)
+
+ # Maps each file to be worked on by a single _worker_check_single_file() call,
+ # collecting any map/reduce data by checker module so that we can 'reduce' it
+ # later.
+ for (
+ worker_idx, # used to merge map/reduce data across workers
+ module,
+ file_path,
+ base_name,
+ messages,
+ stats,
+ msg_status,
+ mapreduce_data,
+ ) in pool.imap_unordered(_worker_check_single_file, files):
+ linter.file_state.base_name = base_name
+ linter.set_current_module(module, file_path)
+ for msg in messages:
+ msg = Message(*msg)
+ linter.reporter.handle_message(msg)
+ all_stats.append(stats)
+ all_mapreduce_data[worker_idx].append(mapreduce_data)
+ linter.msg_status |= msg_status
+ finally:
+ pool.close()
+ pool.join()
+
+ _merge_mapreduce_data(linter, all_mapreduce_data)
+ linter.stats = _merge_stats(all_stats)
+
+ # Insert stats data to local checkers.
+ for checker in linter.get_checkers():
+ if checker is not linter:
+ checker.stats = linter.stats
diff --git a/pylint/lint/pylinter.py b/pylint/lint/pylinter.py
new file mode 100644
index 0000000..67cd9bf
--- /dev/null
+++ b/pylint/lint/pylinter.py
@@ -0,0 +1,1286 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+import contextlib
+import functools
+import operator
+import os
+import sys
+import tokenize
+import traceback
+import warnings
+from io import TextIOWrapper
+
+import astroid
+
+from pylint import checkers, config, exceptions, interfaces, reporters
+from pylint.constants import MAIN_CHECKER_NAME, MSG_TYPES
+from pylint.lint.expand_modules import expand_modules
+from pylint.lint.parallel import check_parallel
+from pylint.lint.report_functions import (
+ report_messages_by_module_stats,
+ report_messages_stats,
+ report_total_messages_stats,
+)
+from pylint.lint.utils import fix_import_path
+from pylint.message import MessageDefinitionStore, MessagesHandlerMixIn
+from pylint.reporters.ureports import nodes as report_nodes
+from pylint.utils import ASTWalker, FileState, utils
+from pylint.utils.pragma_parser import (
+ OPTION_PO,
+ InvalidPragmaError,
+ UnRecognizedOptionError,
+ parse_pragma,
+)
+
+MANAGER = astroid.MANAGER
+
+
+def _read_stdin():
+ # https://mail.python.org/pipermail/python-list/2012-November/634424.html
+ sys.stdin = TextIOWrapper(sys.stdin.detach(), encoding="utf-8")
+ return sys.stdin.read()
+
+
+def _load_reporter_by_class(reporter_class: str) -> type:
+ qname = reporter_class
+ module_part = astroid.modutils.get_module_part(qname)
+ module = astroid.modutils.load_module_from_name(module_part)
+ class_name = qname.split(".")[-1]
+ return getattr(module, class_name)
+
+
+# Python Linter class #########################################################
+
+MSGS = {
+ "F0001": (
+ "%s",
+ "fatal",
+ "Used when an error occurred preventing the analysis of a \
+ module (unable to find it for instance).",
+ ),
+ "F0002": (
+ "%s: %s",
+ "astroid-error",
+ "Used when an unexpected error occurred while building the "
+ "Astroid representation. This is usually accompanied by a "
+ "traceback. Please report such errors !",
+ ),
+ "F0010": (
+ "error while code parsing: %s",
+ "parse-error",
+ "Used when an exception occurred while building the Astroid "
+ "representation which could be handled by astroid.",
+ ),
+ "I0001": (
+ "Unable to run raw checkers on built-in module %s",
+ "raw-checker-failed",
+ "Used to inform that a built-in module has not been checked "
+ "using the raw checkers.",
+ ),
+ "I0010": (
+ "Unable to consider inline option %r",
+ "bad-inline-option",
+ "Used when an inline option is either badly formatted or can't "
+ "be used inside modules.",
+ ),
+ "I0011": (
+ "Locally disabling %s (%s)",
+ "locally-disabled",
+ "Used when an inline option disables a message or a messages category.",
+ ),
+ "I0013": (
+ "Ignoring entire file",
+ "file-ignored",
+ "Used to inform that the file will not be checked",
+ ),
+ "I0020": (
+ "Suppressed %s (from line %d)",
+ "suppressed-message",
+ "A message was triggered on a line, but suppressed explicitly "
+ "by a disable= comment in the file. This message is not "
+ "generated for messages that are ignored due to configuration "
+ "settings.",
+ ),
+ "I0021": (
+ "Useless suppression of %s",
+ "useless-suppression",
+ "Reported when a message is explicitly disabled for a line or "
+ "a block of code, but never triggered.",
+ ),
+ "I0022": (
+ 'Pragma "%s" is deprecated, use "%s" instead',
+ "deprecated-pragma",
+ "Some inline pylint options have been renamed or reworked, "
+ "only the most recent form should be used. "
+ "NOTE:skip-all is only available with pylint >= 0.26",
+ {"old_names": [("I0014", "deprecated-disable-all")]},
+ ),
+ "E0001": ("%s", "syntax-error", "Used when a syntax error is raised for a module."),
+ "E0011": (
+ "Unrecognized file option %r",
+ "unrecognized-inline-option",
+ "Used when an unknown inline option is encountered.",
+ ),
+ "E0012": (
+ "Bad option value %r",
+ "bad-option-value",
+ "Used when a bad value for an inline option is encountered.",
+ ),
+ "E0013": (
+ "Plugin '%s' is impossible to load, is it installed ? ('%s')",
+ "bad-plugin-value",
+ "Used when a bad value is used in 'load-plugins'.",
+ ),
+}
+
+
+# pylint: disable=too-many-instance-attributes,too-many-public-methods
+class PyLinter(
+ config.OptionsManagerMixIn,
+ MessagesHandlerMixIn,
+ reporters.ReportsHandlerMixIn,
+ checkers.BaseTokenChecker,
+):
+ """lint Python modules using external checkers.
+
+ This is the main checker controlling the other ones and the reports
+ generation. It is itself both a raw checker and an astroid checker in order
+ to:
+ * handle message activation / deactivation at the module level
+ * handle some basic but necessary stats'data (number of classes, methods...)
+
+ IDE plugin developers: you may have to call
+ `astroid.builder.MANAGER.astroid_cache.clear()` across runs if you want
+ to ensure the latest code version is actually checked.
+
+ This class needs to support pickling for parallel linting to work. The exception
+ is reporter member; see check_parallel function for more details.
+ """
+
+ __implements__ = (interfaces.ITokenChecker,)
+
+ name = MAIN_CHECKER_NAME
+ priority = 0
+ level = 0
+ msgs = MSGS
+
+ @staticmethod
+ def make_options():
+ return (
+ (
+ "ignore",
+ {
+ "type": "csv",
+ "metavar": "<file>[,<file>...]",
+ "dest": "black_list",
+ "default": ("CVS",),
+ "help": "Files or directories to be skipped. "
+ "They should be base names, not paths.",
+ },
+ ),
+ (
+ "ignore-patterns",
+ {
+ "type": "regexp_csv",
+ "metavar": "<pattern>[,<pattern>...]",
+ "dest": "black_list_re",
+ "default": (),
+ "help": "Files or directories matching the regex patterns are"
+ " skipped. The regex matches against base names, not paths.",
+ },
+ ),
+ (
+ "ignore-paths",
+ {
+ "type": "regexp_csv",
+ "metavar": "<pattern>[,<pattern>...]",
+ "dest": "ignore_list_paths_re",
+ "default": (),
+ "help": "Add files or directories matching the regex patterns to the"
+ " ignore-list. The regex matches against paths.",
+ },
+ ),
+ (
+ "persistent",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "level": 1,
+ "help": "Pickle collected data for later comparisons.",
+ },
+ ),
+ (
+ "load-plugins",
+ {
+ "type": "csv",
+ "metavar": "<modules>",
+ "default": (),
+ "level": 1,
+ "help": "List of plugins (as comma separated values of "
+ "python module names) to load, usually to register "
+ "additional checkers.",
+ },
+ ),
+ (
+ "output-format",
+ {
+ "default": "text",
+ "type": "string",
+ "metavar": "<format>",
+ "short": "f",
+ "group": "Reports",
+ "help": "Set the output format. Available formats are text,"
+ " parseable, colorized, json and msvs (visual studio)."
+ " You can also give a reporter class, e.g. mypackage.mymodule."
+ "MyReporterClass.",
+ },
+ ),
+ (
+ "reports",
+ {
+ "default": False,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "short": "r",
+ "group": "Reports",
+ "help": "Tells whether to display a full report or only the "
+ "messages.",
+ },
+ ),
+ (
+ "evaluation",
+ {
+ "type": "string",
+ "metavar": "<python_expression>",
+ "group": "Reports",
+ "level": 1,
+ "default": "10.0 - ((float(5 * error + warning + refactor + "
+ "convention) / statement) * 10)",
+ "help": "Python expression which should return a score less "
+ "than or equal to 10. You have access to the variables "
+ "'error', 'warning', 'refactor', and 'convention' which "
+ "contain the number of messages in each category, as well as "
+ "'statement' which is the total number of statements "
+ "analyzed. This score is used by the global "
+ "evaluation report (RP0004).",
+ },
+ ),
+ (
+ "score",
+ {
+ "default": True,
+ "type": "yn",
+ "metavar": "<y_or_n>",
+ "short": "s",
+ "group": "Reports",
+ "help": "Activate the evaluation score.",
+ },
+ ),
+ (
+ "fail-under",
+ {
+ "default": 10,
+ "type": "float",
+ "metavar": "<score>",
+ "help": "Specify a score threshold to be exceeded before program exits with error.",
+ },
+ ),
+ (
+ "fail-on",
+ {
+ "default": "",
+ "type": "csv",
+ "metavar": "<msg ids>",
+ "help": "Return non-zero exit code if any of these messages/categories are detected,"
+ " even if score is above --fail-under value. Syntax same as enable."
+ " Messages specified are enabled, while categories only check already-enabled messages.",
+ },
+ ),
+ (
+ "confidence",
+ {
+ "type": "multiple_choice",
+ "metavar": "<levels>",
+ "default": "",
+ "choices": [c.name for c in interfaces.CONFIDENCE_LEVELS],
+ "group": "Messages control",
+ "help": "Only show warnings with the listed confidence levels."
+ " Leave empty to show all. Valid levels: %s."
+ % (", ".join(c.name for c in interfaces.CONFIDENCE_LEVELS),),
+ },
+ ),
+ (
+ "enable",
+ {
+ "type": "csv",
+ "metavar": "<msg ids>",
+ "short": "e",
+ "group": "Messages control",
+ "help": "Enable the message, report, category or checker with the "
+ "given id(s). You can either give multiple identifier "
+ "separated by comma (,) or put this option multiple time "
+ "(only on the command line, not in the configuration file "
+ "where it should appear only once). "
+ 'See also the "--disable" option for examples.',
+ },
+ ),
+ (
+ "disable",
+ {
+ "type": "csv",
+ "metavar": "<msg ids>",
+ "short": "d",
+ "group": "Messages control",
+ "help": "Disable the message, report, category or checker "
+ "with the given id(s). You can either give multiple identifiers "
+ "separated by comma (,) or put this option multiple times "
+ "(only on the command line, not in the configuration file "
+ "where it should appear only once). "
+ 'You can also use "--disable=all" to disable everything first '
+ "and then reenable specific checks. For example, if you want "
+ "to run only the similarities checker, you can use "
+ '"--disable=all --enable=similarities". '
+ "If you want to run only the classes checker, but have no "
+ "Warning level messages displayed, use "
+ '"--disable=all --enable=classes --disable=W".',
+ },
+ ),
+ (
+ "msg-template",
+ {
+ "type": "string",
+ "metavar": "<template>",
+ "group": "Reports",
+ "help": (
+ "Template used to display messages. "
+ "This is a python new-style format string "
+ "used to format the message information. "
+ "See doc for all details."
+ ),
+ },
+ ),
+ (
+ "jobs",
+ {
+ "type": "int",
+ "metavar": "<n-processes>",
+ "short": "j",
+ "default": 1,
+ "help": "Use multiple processes to speed up Pylint. Specifying 0 will "
+ "auto-detect the number of processors available to use.",
+ },
+ ),
+ (
+ "unsafe-load-any-extension",
+ {
+ "type": "yn",
+ "metavar": "<yn>",
+ "default": False,
+ "hide": True,
+ "help": (
+ "Allow loading of arbitrary C extensions. Extensions"
+ " are imported into the active Python interpreter and"
+ " may run arbitrary code."
+ ),
+ },
+ ),
+ (
+ "limit-inference-results",
+ {
+ "type": "int",
+ "metavar": "<number-of-results>",
+ "default": 100,
+ "help": (
+ "Control the amount of potential inferred values when inferring "
+ "a single object. This can help the performance when dealing with "
+ "large functions or complex, nested conditions. "
+ ),
+ },
+ ),
+ (
+ "extension-pkg-allow-list",
+ {
+ "type": "csv",
+ "metavar": "<pkg[,pkg]>",
+ "default": [],
+ "help": (
+ "A comma-separated list of package or module names"
+ " from where C extensions may be loaded. Extensions are"
+ " loading into the active Python interpreter and may run"
+ " arbitrary code."
+ ),
+ },
+ ),
+ (
+ "extension-pkg-whitelist",
+ {
+ "type": "csv",
+ "metavar": "<pkg[,pkg]>",
+ "default": [],
+ "help": (
+ "A comma-separated list of package or module names"
+ " from where C extensions may be loaded. Extensions are"
+ " loading into the active Python interpreter and may run"
+ " arbitrary code. (This is an alternative name to"
+ " extension-pkg-allow-list for backward compatibility.)"
+ ),
+ },
+ ),
+ (
+ "suggestion-mode",
+ {
+ "type": "yn",
+ "metavar": "<yn>",
+ "default": True,
+ "help": (
+ "When enabled, pylint would attempt to guess common "
+ "misconfiguration and emit user-friendly hints instead "
+ "of false-positive error messages."
+ ),
+ },
+ ),
+ (
+ "exit-zero",
+ {
+ "action": "store_true",
+ "help": (
+ "Always return a 0 (non-error) status code, even if "
+ "lint errors are found. This is primarily useful in "
+ "continuous integration scripts."
+ ),
+ },
+ ),
+ (
+ "from-stdin",
+ {
+ "action": "store_true",
+ "help": (
+ "Interpret the stdin as a python script, whose filename "
+ "needs to be passed as the module_or_package argument."
+ ),
+ },
+ ),
+ )
+
+ option_groups = (
+ ("Messages control", "Options controlling analysis messages"),
+ ("Reports", "Options related to output formatting and reporting"),
+ )
+
+ def __init__(self, options=(), reporter=None, option_groups=(), pylintrc=None):
+ """Some stuff has to be done before ancestors initialization...
+ messages store / checkers / reporter / astroid manager"""
+ self.msgs_store = MessageDefinitionStore()
+ self.reporter = None
+ self._reporter_names = None
+ self._reporters = {}
+ self._checkers = collections.defaultdict(list)
+ self._pragma_lineno = {}
+ self._ignore_file = False
+ # visit variables
+ self.file_state = FileState()
+ self.current_name = None
+ self.current_file = None
+ self.stats = None
+ self.fail_on_symbols = []
+ # init options
+ self._external_opts = options
+ self.options = options + PyLinter.make_options()
+ self.option_groups = option_groups + PyLinter.option_groups
+ self._options_methods = {"enable": self.enable, "disable": self.disable}
+ self._bw_options_methods = {
+ "disable-msg": self._options_methods["disable"],
+ "enable-msg": self._options_methods["enable"],
+ }
+ MessagesHandlerMixIn.__init__(self)
+ reporters.ReportsHandlerMixIn.__init__(self)
+ super().__init__(
+ usage=__doc__,
+ config_file=pylintrc or next(config.find_default_config_files(), None),
+ )
+ checkers.BaseTokenChecker.__init__(self)
+ # provided reports
+ self.reports = (
+ ("RP0001", "Messages by category", report_total_messages_stats),
+ (
+ "RP0002",
+ "% errors / warnings by module",
+ report_messages_by_module_stats,
+ ),
+ ("RP0003", "Messages", report_messages_stats),
+ )
+ self.register_checker(self)
+ self._dynamic_plugins = set()
+ self._python3_porting_mode = False
+ self._error_mode = False
+ self.load_provider_defaults()
+ if reporter:
+ self.set_reporter(reporter)
+
+ def load_default_plugins(self):
+ checkers.initialize(self)
+ reporters.initialize(self)
+ # Make sure to load the default reporter, because
+ # the option has been set before the plugins had been loaded.
+ if not self.reporter:
+ self._load_reporters()
+
+ def load_plugin_modules(self, modnames):
+ """take a list of module names which are pylint plugins and load
+ and register them
+ """
+ for modname in modnames:
+ if modname in self._dynamic_plugins:
+ continue
+ self._dynamic_plugins.add(modname)
+ try:
+ module = astroid.modutils.load_module_from_name(modname)
+ module.register(self)
+ except ModuleNotFoundError:
+ pass
+
+ def load_plugin_configuration(self):
+ """Call the configuration hook for plugins
+
+ This walks through the list of plugins, grabs the "load_configuration"
+ hook, if exposed, and calls it to allow plugins to configure specific
+ settings.
+ """
+ for modname in self._dynamic_plugins:
+ try:
+ module = astroid.modutils.load_module_from_name(modname)
+ if hasattr(module, "load_configuration"):
+ module.load_configuration(self)
+ except ModuleNotFoundError as e:
+ self.add_message("bad-plugin-value", args=(modname, e), line=0)
+
+ def _load_reporters(self) -> None:
+ sub_reporters = []
+ output_files = []
+ with contextlib.ExitStack() as stack:
+ for reporter_name in self._reporter_names.split(","):
+ reporter_name, *reporter_output = reporter_name.split(":", 1)
+
+ reporter = self._load_reporter_by_name(reporter_name)
+ sub_reporters.append(reporter)
+
+ if reporter_output:
+ (reporter_output,) = reporter_output
+
+ # pylint: disable=consider-using-with
+ output_file = stack.enter_context(open(reporter_output, "w"))
+
+ reporter.set_output(output_file)
+ output_files.append(output_file)
+
+ # Extend the lifetime of all opened output files
+ close_output_files = stack.pop_all().close
+
+ if len(sub_reporters) > 1 or output_files:
+ self.set_reporter(
+ reporters.MultiReporter(
+ sub_reporters,
+ close_output_files,
+ )
+ )
+ else:
+ self.set_reporter(sub_reporters[0])
+
+ def _load_reporter_by_name(self, reporter_name: str) -> reporters.BaseReporter:
+ name = reporter_name.lower()
+ if name in self._reporters:
+ return self._reporters[name]()
+
+ try:
+ reporter_class = _load_reporter_by_class(reporter_name)
+ except (ImportError, AttributeError) as e:
+ raise exceptions.InvalidReporterError(name) from e
+ else:
+ return reporter_class()
+
+ def set_reporter(self, reporter):
+ """set the reporter used to display messages and reports"""
+ self.reporter = reporter
+ reporter.linter = self
+
+ def set_option(self, optname, value, action=None, optdict=None):
+ """overridden from config.OptionsProviderMixin to handle some
+ special options
+ """
+ if optname in self._options_methods or optname in self._bw_options_methods:
+ if value:
+ try:
+ meth = self._options_methods[optname]
+ except KeyError:
+ meth = self._bw_options_methods[optname]
+ warnings.warn(
+ "%s is deprecated, replace it by %s"
+ % (optname, optname.split("-")[0]),
+ DeprecationWarning,
+ )
+ value = utils._check_csv(value)
+ if isinstance(value, (list, tuple)):
+ for _id in value:
+ meth(_id, ignore_unknown=True)
+ else:
+ meth(value)
+ return # no need to call set_option, disable/enable methods do it
+ elif optname == "output-format":
+ self._reporter_names = value
+ # If the reporters are already available, load
+ # the reporter class.
+ if self._reporters:
+ self._load_reporters()
+
+ try:
+ checkers.BaseTokenChecker.set_option(self, optname, value, action, optdict)
+ except config.UnsupportedAction:
+ print("option %s can't be read from config file" % optname, file=sys.stderr)
+
+ def register_reporter(self, reporter_class):
+ self._reporters[reporter_class.name] = reporter_class
+
+ def report_order(self):
+ reports = sorted(self._reports, key=lambda x: getattr(x, "name", ""))
+ try:
+ # Remove the current reporter and add it
+ # at the end of the list.
+ reports.pop(reports.index(self))
+ except ValueError:
+ pass
+ else:
+ reports.append(self)
+ return reports
+
+ # checkers manipulation methods ############################################
+
+ def register_checker(self, checker):
+ """register a new checker
+
+ checker is an object implementing IRawChecker or / and IAstroidChecker
+ """
+ assert checker.priority <= 0, "checker priority can't be >= 0"
+ self._checkers[checker.name].append(checker)
+ for r_id, r_title, r_cb in checker.reports:
+ self.register_report(r_id, r_title, r_cb, checker)
+ self.register_options_provider(checker)
+ if hasattr(checker, "msgs"):
+ self.msgs_store.register_messages_from_checker(checker)
+ checker.load_defaults()
+
+ # Register the checker, but disable all of its messages.
+ if not getattr(checker, "enabled", True):
+ self.disable(checker.name)
+
+ def enable_fail_on_messages(self):
+ """enable 'fail on' msgs
+
+ Convert values in config.fail_on (which might be msg category, msg id,
+ or symbol) to specific msgs, then enable and flag them for later.
+ """
+ fail_on_vals = self.config.fail_on
+ if not fail_on_vals:
+ return
+
+ fail_on_cats = set()
+ fail_on_msgs = set()
+ for val in fail_on_vals:
+ # If value is a cateogry, add category, else add message
+ if val in MSG_TYPES:
+ fail_on_cats.add(val)
+ else:
+ fail_on_msgs.add(val)
+
+ # For every message in every checker, if cat or msg flagged, enable check
+ for all_checkers in self._checkers.values():
+ for checker in all_checkers:
+ for msg in checker.messages:
+ if msg.msgid in fail_on_msgs or msg.symbol in fail_on_msgs:
+ # message id/symbol matched, enable and flag it
+ self.enable(msg.msgid)
+ self.fail_on_symbols.append(msg.symbol)
+ elif msg.msgid[0] in fail_on_cats:
+ # message starts with a cateogry value, flag (but do not enable) it
+ self.fail_on_symbols.append(msg.symbol)
+
+ def any_fail_on_issues(self):
+ return any(x in self.fail_on_symbols for x in self.stats["by_msg"])
+
+ def disable_noerror_messages(self):
+ for msgcat, msgids in self.msgs_store._msgs_by_category.items():
+ # enable only messages with 'error' severity and above ('fatal')
+ if msgcat in ["E", "F"]:
+ for msgid in msgids:
+ self.enable(msgid)
+ else:
+ for msgid in msgids:
+ self.disable(msgid)
+
+ def disable_reporters(self):
+ """disable all reporters"""
+ for _reporters in self._reports.values():
+ for report_id, _, _ in _reporters:
+ self.disable_report(report_id)
+
+ def error_mode(self):
+ """error mode: enable only errors; no reports, no persistent"""
+ self._error_mode = True
+ self.disable_noerror_messages()
+ self.disable("miscellaneous")
+ if self._python3_porting_mode:
+ self.disable("all")
+ for msg_id in self._checker_messages("python3"):
+ if msg_id.startswith("E"):
+ self.enable(msg_id)
+ config_parser = self.cfgfile_parser
+ if config_parser.has_option("MESSAGES CONTROL", "disable"):
+ value = config_parser.get("MESSAGES CONTROL", "disable")
+ self.global_set_option("disable", value)
+ else:
+ self.disable("python3")
+ self.set_option("reports", False)
+ self.set_option("persistent", False)
+ self.set_option("score", False)
+
+ def python3_porting_mode(self):
+ """Disable all other checkers and enable Python 3 warnings."""
+ self.disable("all")
+ # re-enable some errors, or 'print', 'raise', 'async', 'await' will mistakenly lint fine
+ self.enable("fatal") # F0001
+ self.enable("astroid-error") # F0002
+ self.enable("parse-error") # F0010
+ self.enable("syntax-error") # E0001
+ self.enable("python3")
+ if self._error_mode:
+ # The error mode was activated, using the -E flag.
+ # So we'll need to enable only the errors from the
+ # Python 3 porting checker.
+ for msg_id in self._checker_messages("python3"):
+ if msg_id.startswith("E"):
+ self.enable(msg_id)
+ else:
+ self.disable(msg_id)
+ config_parser = self.cfgfile_parser
+ if config_parser.has_option("MESSAGES CONTROL", "disable"):
+ value = config_parser.get("MESSAGES CONTROL", "disable")
+ self.global_set_option("disable", value)
+ self._python3_porting_mode = True
+
+ def list_messages_enabled(self):
+ enabled = [
+ f" {message.symbol} ({message.msgid})"
+ for message in self.msgs_store.messages
+ if self.is_message_enabled(message.msgid)
+ ]
+ disabled = [
+ f" {message.symbol} ({message.msgid})"
+ for message in self.msgs_store.messages
+ if not self.is_message_enabled(message.msgid)
+ ]
+ print("Enabled messages:")
+ for msg in sorted(enabled):
+ print(msg)
+ print("\nDisabled messages:")
+ for msg in sorted(disabled):
+ print(msg)
+ print("")
+
+ # block level option handling #############################################
+ # see func_block_disable_msg.py test case for expected behaviour
+
+ def process_tokens(self, tokens):
+ """Process tokens from the current module to search for module/block level
+ options."""
+ control_pragmas = {"disable", "enable"}
+ prev_line = None
+ saw_newline = True
+ seen_newline = True
+ for (tok_type, content, start, _, _) in tokens:
+ if prev_line and prev_line != start[0]:
+ saw_newline = seen_newline
+ seen_newline = False
+
+ prev_line = start[0]
+ if tok_type in (tokenize.NL, tokenize.NEWLINE):
+ seen_newline = True
+
+ if tok_type != tokenize.COMMENT:
+ continue
+ match = OPTION_PO.search(content)
+ if match is None:
+ continue
+ try:
+ for pragma_repr in parse_pragma(match.group(2)):
+ if pragma_repr.action in ("disable-all", "skip-file"):
+ if pragma_repr.action == "disable-all":
+ self.add_message(
+ "deprecated-pragma",
+ line=start[0],
+ args=("disable-all", "skip-file"),
+ )
+ self.add_message("file-ignored", line=start[0])
+ self._ignore_file = True
+ return
+ try:
+ meth = self._options_methods[pragma_repr.action]
+ except KeyError:
+ meth = self._bw_options_methods[pragma_repr.action]
+ # found a "(dis|en)able-msg" pragma deprecated suppression
+ self.add_message(
+ "deprecated-pragma",
+ line=start[0],
+ args=(
+ pragma_repr.action,
+ pragma_repr.action.replace("-msg", ""),
+ ),
+ )
+ for msgid in pragma_repr.messages:
+ # Add the line where a control pragma was encountered.
+ if pragma_repr.action in control_pragmas:
+ self._pragma_lineno[msgid] = start[0]
+
+ if (pragma_repr.action, msgid) == ("disable", "all"):
+ self.add_message(
+ "deprecated-pragma",
+ line=start[0],
+ args=("disable=all", "skip-file"),
+ )
+ self.add_message("file-ignored", line=start[0])
+ self._ignore_file = True
+ return
+ # If we did not see a newline between the previous line and now,
+ # we saw a backslash so treat the two lines as one.
+ l_start = start[0]
+ if not saw_newline:
+ l_start -= 1
+ try:
+ meth(msgid, "module", l_start)
+ except exceptions.UnknownMessageError:
+ self.add_message(
+ "bad-option-value", args=msgid, line=start[0]
+ )
+ except UnRecognizedOptionError as err:
+ self.add_message(
+ "unrecognized-inline-option", args=err.token, line=start[0]
+ )
+ continue
+ except InvalidPragmaError as err:
+ self.add_message("bad-inline-option", args=err.token, line=start[0])
+ continue
+
+ # code checking methods ###################################################
+
+ def get_checkers(self):
+ """return all available checkers as a list"""
+ return [self] + [
+ c
+ for _checkers in self._checkers.values()
+ for c in _checkers
+ if c is not self
+ ]
+
+ def get_checker_names(self):
+ """Get all the checker names that this linter knows about."""
+ current_checkers = self.get_checkers()
+ return sorted(
+ {
+ checker.name
+ for checker in current_checkers
+ if checker.name != MAIN_CHECKER_NAME
+ }
+ )
+
+ def prepare_checkers(self):
+ """return checkers needed for activated messages and reports"""
+ if not self.config.reports:
+ self.disable_reporters()
+ # get needed checkers
+ needed_checkers = [self]
+ for checker in self.get_checkers()[1:]:
+ messages = {msg for msg in checker.msgs if self.is_message_enabled(msg)}
+ if messages or any(self.report_is_enabled(r[0]) for r in checker.reports):
+ needed_checkers.append(checker)
+ # Sort checkers by priority
+ needed_checkers = sorted(
+ needed_checkers, key=operator.attrgetter("priority"), reverse=True
+ )
+ return needed_checkers
+
+ # pylint: disable=unused-argument
+ @staticmethod
+ def should_analyze_file(modname, path, is_argument=False):
+ """Returns whether or not a module should be checked.
+
+ This implementation returns True for all python source file, indicating
+ that all files should be linted.
+
+ Subclasses may override this method to indicate that modules satisfying
+ certain conditions should not be linted.
+
+ :param str modname: The name of the module to be checked.
+ :param str path: The full path to the source code of the module.
+ :param bool is_argument: Whether the file is an argument to pylint or not.
+ Files which respect this property are always
+ checked, since the user requested it explicitly.
+ :returns: True if the module should be checked.
+ :rtype: bool
+ """
+ if is_argument:
+ return True
+ return path.endswith(".py")
+
+ # pylint: enable=unused-argument
+
+ def initialize(self):
+ """Initialize linter for linting
+
+ This method is called before any linting is done.
+ """
+ # initialize msgs_state now that all messages have been registered into
+ # the store
+ for msg in self.msgs_store.messages:
+ if not msg.may_be_emitted():
+ self._msgs_state[msg.msgid] = False
+
+ def check(self, files_or_modules):
+ """main checking entry: check a list of files or modules from their name.
+
+ files_or_modules is either a string or list of strings presenting modules to check.
+ """
+
+ self.initialize()
+
+ if not isinstance(files_or_modules, (list, tuple)):
+ files_or_modules = (files_or_modules,)
+
+ if self.config.from_stdin:
+ if len(files_or_modules) != 1:
+ raise exceptions.InvalidArgsError(
+ "Missing filename required for --from-stdin"
+ )
+
+ filepath = files_or_modules[0]
+ with fix_import_path(files_or_modules):
+ self._check_files(
+ functools.partial(self.get_ast, data=_read_stdin()),
+ [self._get_file_descr_from_stdin(filepath)],
+ )
+ elif self.config.jobs == 1:
+ with fix_import_path(files_or_modules):
+ self._check_files(
+ self.get_ast, self._iterate_file_descrs(files_or_modules)
+ )
+ else:
+ check_parallel(
+ self,
+ self.config.jobs,
+ self._iterate_file_descrs(files_or_modules),
+ files_or_modules,
+ )
+
+ def check_single_file(self, name, filepath, modname):
+ """Check single file
+
+ The arguments are the same that are documented in _check_files
+
+ The initialize() method should be called before calling this method
+ """
+ with self._astroid_module_checker() as check_astroid_module:
+ self._check_file(
+ self.get_ast, check_astroid_module, name, filepath, modname
+ )
+
+ def _check_files(self, get_ast, file_descrs):
+ """Check all files from file_descrs
+
+ The file_descrs should be iterable of tuple (name, filepath, modname)
+ where
+ - name: full name of the module
+ - filepath: path of the file
+ - modname: module name
+ """
+ with self._astroid_module_checker() as check_astroid_module:
+ for name, filepath, modname in file_descrs:
+ self._check_file(get_ast, check_astroid_module, name, filepath, modname)
+
+ def _check_file(self, get_ast, check_astroid_module, name, filepath, modname):
+ """Check a file using the passed utility functions (get_ast and check_astroid_module)
+
+ :param callable get_ast: callable returning AST from defined file taking the following arguments
+ - filepath: path to the file to check
+ - name: Python module name
+ :param callable check_astroid_module: callable checking an AST taking the following arguments
+ - ast: AST of the module
+ :param str name: full name of the module
+ :param str filepath: path to checked file
+ :param str modname: name of the checked Python module
+ """
+ self.set_current_module(name, filepath)
+ # get the module representation
+ ast_node = get_ast(filepath, name)
+ if ast_node is None:
+ return
+
+ self._ignore_file = False
+
+ self.file_state = FileState(modname)
+ # fix the current file (if the source file was not available or
+ # if it's actually a c extension)
+ self.current_file = ast_node.file # pylint: disable=maybe-no-member
+ check_astroid_module(ast_node)
+ # warn about spurious inline messages handling
+ spurious_messages = self.file_state.iter_spurious_suppression_messages(
+ self.msgs_store
+ )
+ for msgid, line, args in spurious_messages:
+ self.add_message(msgid, line, None, args)
+
+ @staticmethod
+ def _get_file_descr_from_stdin(filepath):
+ """Return file description (tuple of module name, file path, base name) from given file path
+
+ This method is used for creating suitable file description for _check_files when the
+ source is standard input.
+ """
+ try:
+ # Note that this function does not really perform an
+ # __import__ but may raise an ImportError exception, which
+ # we want to catch here.
+ modname = ".".join(astroid.modutils.modpath_from_file(filepath))
+ except ImportError:
+ modname = os.path.splitext(os.path.basename(filepath))[0]
+
+ return (modname, filepath, filepath)
+
+ def _iterate_file_descrs(self, files_or_modules):
+ """Return generator yielding file descriptions (tuples of module name, file path, base name)
+
+ The returned generator yield one item for each Python module that should be linted.
+ """
+ for descr in self._expand_files(files_or_modules):
+ name, filepath, is_arg = descr["name"], descr["path"], descr["isarg"]
+ if self.should_analyze_file(name, filepath, is_argument=is_arg):
+ yield (name, filepath, descr["basename"])
+
+ def _expand_files(self, modules):
+ """get modules and errors from a list of modules and handle errors"""
+ result, errors = expand_modules(
+ modules,
+ self.config.black_list,
+ self.config.black_list_re,
+ self.config.ignore_list_paths_re,
+ )
+ for error in errors:
+ message = modname = error["mod"]
+ key = error["key"]
+ self.set_current_module(modname)
+ if key == "fatal":
+ message = str(error["ex"]).replace(os.getcwd() + os.sep, "")
+ self.add_message(key, args=message)
+ return result
+
+ def set_current_module(self, modname, filepath=None):
+ """set the name of the currently analyzed module and
+ init statistics for it
+ """
+ if not modname and filepath is None:
+ return
+ self.reporter.on_set_current_module(modname, filepath)
+ self.current_name = modname
+ self.current_file = filepath or modname
+ self.stats["by_module"][modname] = {}
+ self.stats["by_module"][modname]["statement"] = 0
+ for msg_cat in MSG_TYPES.values():
+ self.stats["by_module"][modname][msg_cat] = 0
+
+ @contextlib.contextmanager
+ def _astroid_module_checker(self):
+ """Context manager for checking ASTs
+
+ The value in the context is callable accepting AST as its only argument.
+ """
+ walker = ASTWalker(self)
+ _checkers = self.prepare_checkers()
+ tokencheckers = [
+ c
+ for c in _checkers
+ if interfaces.implements(c, interfaces.ITokenChecker) and c is not self
+ ]
+ rawcheckers = [
+ c for c in _checkers if interfaces.implements(c, interfaces.IRawChecker)
+ ]
+ # notify global begin
+ for checker in _checkers:
+ checker.open()
+ if interfaces.implements(checker, interfaces.IAstroidChecker):
+ walker.add_checker(checker)
+
+ yield functools.partial(
+ self.check_astroid_module,
+ walker=walker,
+ tokencheckers=tokencheckers,
+ rawcheckers=rawcheckers,
+ )
+
+ # notify global end
+ self.stats["statement"] = walker.nbstatements
+ for checker in reversed(_checkers):
+ checker.close()
+
+ def get_ast(self, filepath, modname, data=None):
+ """Return an ast(roid) representation of a module or a string.
+
+ :param str filepath: path to checked file.
+ :param str modname: The name of the module to be checked.
+ :param str data: optional contents of the checked file.
+ :returns: the AST
+ :rtype: astroid.nodes.Module
+ """
+ try:
+ if data is None:
+ return MANAGER.ast_from_file(filepath, modname, source=True)
+ return astroid.builder.AstroidBuilder(MANAGER).string_build(
+ data, modname, filepath
+ )
+ except astroid.AstroidSyntaxError as ex:
+ # pylint: disable=no-member
+ self.add_message(
+ "syntax-error",
+ line=getattr(ex.error, "lineno", 0),
+ col_offset=getattr(ex.error, "offset", None),
+ args=str(ex.error),
+ )
+ except astroid.AstroidBuildingException as ex:
+ self.add_message("parse-error", args=ex)
+ except Exception as ex: # pylint: disable=broad-except
+ traceback.print_exc()
+ self.add_message("astroid-error", args=(ex.__class__, ex))
+ return None
+
+ def check_astroid_module(self, ast_node, walker, rawcheckers, tokencheckers):
+ """Check a module from its astroid representation.
+
+ For return value see _check_astroid_module
+ """
+ before_check_statements = walker.nbstatements
+
+ retval = self._check_astroid_module(
+ ast_node, walker, rawcheckers, tokencheckers
+ )
+
+ self.stats["by_module"][self.current_name]["statement"] = (
+ walker.nbstatements - before_check_statements
+ )
+
+ return retval
+
+ def _check_astroid_module(self, ast_node, walker, rawcheckers, tokencheckers):
+ """Check given AST node with given walker and checkers
+
+ :param astroid.nodes.Module ast_node: AST node of the module to check
+ :param pylint.utils.ast_walker.ASTWalker walker: AST walker
+ :param list rawcheckers: List of token checkers to use
+ :param list tokencheckers: List of raw checkers to use
+
+ :returns: True if the module was checked, False if ignored,
+ None if the module contents could not be parsed
+ :rtype: bool
+ """
+ try:
+ tokens = utils.tokenize_module(ast_node)
+ except tokenize.TokenError as ex:
+ self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
+ return None
+
+ if not ast_node.pure_python:
+ self.add_message("raw-checker-failed", args=ast_node.name)
+ else:
+ # assert astroid.file.endswith('.py')
+ # invoke ITokenChecker interface on self to fetch module/block
+ # level options
+ self.process_tokens(tokens)
+ if self._ignore_file:
+ return False
+ # walk ast to collect line numbers
+ self.file_state.collect_block_lines(self.msgs_store, ast_node)
+ # run raw and tokens checkers
+ for checker in rawcheckers:
+ checker.process_module(ast_node)
+ for checker in tokencheckers:
+ checker.process_tokens(tokens)
+ # generate events to astroid checkers
+ walker.walk(ast_node)
+ return True
+
+ # IAstroidChecker interface #################################################
+
+ def open(self):
+ """initialize counters"""
+ self.stats = {"by_module": {}, "by_msg": {}}
+ MANAGER.always_load_extensions = self.config.unsafe_load_any_extension
+ MANAGER.max_inferable_values = self.config.limit_inference_results
+ MANAGER.extension_package_whitelist.update(self.config.extension_pkg_allow_list)
+ if self.config.extension_pkg_whitelist:
+ MANAGER.extension_package_whitelist.update(
+ self.config.extension_pkg_whitelist
+ )
+ for msg_cat in MSG_TYPES.values():
+ self.stats[msg_cat] = 0
+
+ def generate_reports(self):
+ """close the whole package /module, it's time to make reports !
+
+ if persistent run, pickle results for later comparison
+ """
+ # Display whatever messages are left on the reporter.
+ self.reporter.display_messages(report_nodes.Section())
+
+ if self.file_state.base_name is not None:
+ # load previous results if any
+ previous_stats = config.load_results(self.file_state.base_name)
+ self.reporter.on_close(self.stats, previous_stats)
+ if self.config.reports:
+ sect = self.make_reports(self.stats, previous_stats)
+ else:
+ sect = report_nodes.Section()
+
+ if self.config.reports:
+ self.reporter.display_reports(sect)
+ score_value = self._report_evaluation()
+ # save results if persistent run
+ if self.config.persistent:
+ config.save_results(self.stats, self.file_state.base_name)
+ else:
+ self.reporter.on_close(self.stats, {})
+ score_value = None
+ return score_value
+
+ def _report_evaluation(self):
+ """make the global evaluation report"""
+ # check with at least check 1 statements (usually 0 when there is a
+ # syntax error preventing pylint from further processing)
+ note = None
+ previous_stats = config.load_results(self.file_state.base_name)
+ if self.stats["statement"] == 0:
+ return note
+
+ # get a global note for the code
+ evaluation = self.config.evaluation
+ try:
+ note = eval(evaluation, {}, self.stats) # pylint: disable=eval-used
+ except Exception as ex: # pylint: disable=broad-except
+ msg = "An exception occurred while rating: %s" % ex
+ else:
+ self.stats["global_note"] = note
+ msg = "Your code has been rated at %.2f/10" % note
+ pnote = previous_stats.get("global_note")
+ if pnote is not None:
+ msg += f" (previous run: {pnote:.2f}/10, {note - pnote:+.2f})"
+
+ if self.config.score:
+ sect = report_nodes.EvaluationSection(msg)
+ self.reporter.display_reports(sect)
+ return note
diff --git a/pylint/lint/report_functions.py b/pylint/lint/report_functions.py
new file mode 100644
index 0000000..d3a88a1
--- /dev/null
+++ b/pylint/lint/report_functions.py
@@ -0,0 +1,74 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+
+from pylint import checkers, exceptions
+from pylint.reporters.ureports import nodes as report_nodes
+
+
+def report_total_messages_stats(sect, stats, previous_stats):
+ """make total errors / warnings report"""
+ lines = ["type", "number", "previous", "difference"]
+ lines += checkers.table_lines_from_stats(
+ stats, previous_stats, ("convention", "refactor", "warning", "error")
+ )
+ sect.append(report_nodes.Table(children=lines, cols=4, rheaders=1))
+
+
+def report_messages_stats(sect, stats, _):
+ """make messages type report"""
+ if not stats["by_msg"]:
+ # don't print this report when we didn't detected any errors
+ raise exceptions.EmptyReportError()
+ in_order = sorted(
+ (value, msg_id)
+ for msg_id, value in stats["by_msg"].items()
+ if not msg_id.startswith("I")
+ )
+ in_order.reverse()
+ lines = ("message id", "occurrences")
+ for value, msg_id in in_order:
+ lines += (msg_id, str(value))
+ sect.append(report_nodes.Table(children=lines, cols=2, rheaders=1))
+
+
+def report_messages_by_module_stats(sect, stats, _):
+ """make errors / warnings by modules report"""
+ if len(stats["by_module"]) == 1:
+ # don't print this report when we are analysing a single module
+ raise exceptions.EmptyReportError()
+ by_mod = collections.defaultdict(dict)
+ for m_type in ("fatal", "error", "warning", "refactor", "convention"):
+ total = stats[m_type]
+ for module in stats["by_module"].keys():
+ mod_total = stats["by_module"][module][m_type]
+ if total == 0:
+ percent = 0
+ else:
+ percent = float((mod_total) * 100) / total
+ by_mod[module][m_type] = percent
+ sorted_result = []
+ for module, mod_info in by_mod.items():
+ sorted_result.append(
+ (
+ mod_info["error"],
+ mod_info["warning"],
+ mod_info["refactor"],
+ mod_info["convention"],
+ module,
+ )
+ )
+ sorted_result.sort()
+ sorted_result.reverse()
+ lines = ["module", "error", "warning", "refactor", "convention"]
+ for line in sorted_result:
+ # Don't report clean modules.
+ if all(entry == 0 for entry in line[:-1]):
+ continue
+ lines.append(line[-1])
+ for val in line[:-1]:
+ lines.append("%.2f" % val)
+ if len(lines) == 5:
+ raise exceptions.EmptyReportError()
+ sect.append(report_nodes.Table(children=lines, cols=5, rheaders=1))
diff --git a/pylint/lint/run.py b/pylint/lint/run.py
new file mode 100644
index 0000000..d17c40c
--- /dev/null
+++ b/pylint/lint/run.py
@@ -0,0 +1,478 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import os
+import sys
+import warnings
+
+from pylint import __pkginfo__, config, extensions, interfaces
+from pylint.constants import full_version
+from pylint.lint.pylinter import PyLinter
+from pylint.lint.utils import ArgumentPreprocessingError, preprocess_options
+from pylint.utils import utils
+
+try:
+ import multiprocessing
+except ImportError:
+ multiprocessing = None # type: ignore
+
+
+def _cpu_count() -> int:
+ """Use sched_affinity if available for virtualized or containerized environments."""
+ sched_getaffinity = getattr(os, "sched_getaffinity", None)
+ # pylint: disable=not-callable,using-constant-test
+ if sched_getaffinity:
+ return len(sched_getaffinity(0))
+ if multiprocessing:
+ return multiprocessing.cpu_count()
+ return 1
+
+
+def cb_list_extensions(option, optname, value, parser):
+ """List all the extensions under pylint.extensions"""
+
+ for filename in os.listdir(os.path.dirname(extensions.__file__)):
+ if filename.endswith(".py") and not filename.startswith("_"):
+ extension_name, _, _ = filename.partition(".")
+ print(f"pylint.extensions.{extension_name}")
+ sys.exit(0)
+
+
+def cb_list_confidence_levels(option, optname, value, parser):
+ for level in interfaces.CONFIDENCE_LEVELS:
+ print("%-18s: %s" % level)
+ sys.exit(0)
+
+
+def cb_init_hook(optname, value):
+ """exec arbitrary code to set sys.path for instance"""
+ exec(value) # pylint: disable=exec-used
+
+
+UNUSED_PARAM_SENTINEL = object()
+
+
+class Run:
+ """helper class to use as main for pylint :
+
+ run(*sys.argv[1:])
+ """
+
+ LinterClass = PyLinter
+ option_groups = (
+ (
+ "Commands",
+ "Options which are actually commands. Options in this \
+group are mutually exclusive.",
+ ),
+ )
+
+ @staticmethod
+ def _return_one(*args): # pylint: disable=unused-argument
+ return 1
+
+ def __init__(
+ self,
+ args,
+ reporter=None,
+ exit=True,
+ do_exit=UNUSED_PARAM_SENTINEL,
+ ): # pylint: disable=redefined-builtin
+ self._rcfile = None
+ self._output = None
+ self._version_asked = False
+ self._plugins = []
+ self.verbose = None
+ try:
+ preprocess_options(
+ args,
+ {
+ # option: (callback, takearg)
+ "version": (self.version_asked, False),
+ "init-hook": (cb_init_hook, True),
+ "rcfile": (self.cb_set_rcfile, True),
+ "load-plugins": (self.cb_add_plugins, True),
+ "verbose": (self.cb_verbose_mode, False),
+ "output": (self.cb_set_output, True),
+ },
+ )
+ except ArgumentPreprocessingError as ex:
+ print(ex, file=sys.stderr)
+ sys.exit(32)
+
+ self.linter = linter = self.LinterClass(
+ (
+ (
+ "rcfile",
+ {
+ "action": "callback",
+ "callback": Run._return_one,
+ "group": "Commands",
+ "type": "string",
+ "metavar": "<file>",
+ "help": "Specify a configuration file to load.",
+ },
+ ),
+ (
+ "output",
+ {
+ "action": "callback",
+ "callback": Run._return_one,
+ "group": "Commands",
+ "type": "string",
+ "metavar": "<file>",
+ "help": "Specify an output file.",
+ },
+ ),
+ (
+ "init-hook",
+ {
+ "action": "callback",
+ "callback": Run._return_one,
+ "type": "string",
+ "metavar": "<code>",
+ "level": 1,
+ "help": "Python code to execute, usually for sys.path "
+ "manipulation such as pygtk.require().",
+ },
+ ),
+ (
+ "help-msg",
+ {
+ "action": "callback",
+ "type": "string",
+ "metavar": "<msg-id>",
+ "callback": self.cb_help_message,
+ "group": "Commands",
+ "help": "Display a help message for the given message id and "
+ "exit. The value may be a comma separated list of message ids.",
+ },
+ ),
+ (
+ "list-msgs",
+ {
+ "action": "callback",
+ "metavar": "<msg-id>",
+ "callback": self.cb_list_messages,
+ "group": "Commands",
+ "level": 1,
+ "help": "Generate pylint's messages.",
+ },
+ ),
+ (
+ "list-msgs-enabled",
+ {
+ "action": "callback",
+ "metavar": "<msg-id>",
+ "callback": self.cb_list_messages_enabled,
+ "group": "Commands",
+ "level": 1,
+ "help": "Display a list of what messages are enabled "
+ "and disabled with the given configuration.",
+ },
+ ),
+ (
+ "list-groups",
+ {
+ "action": "callback",
+ "metavar": "<msg-id>",
+ "callback": self.cb_list_groups,
+ "group": "Commands",
+ "level": 1,
+ "help": "List pylint's message groups.",
+ },
+ ),
+ (
+ "list-conf-levels",
+ {
+ "action": "callback",
+ "callback": cb_list_confidence_levels,
+ "group": "Commands",
+ "level": 1,
+ "help": "Generate pylint's confidence levels.",
+ },
+ ),
+ (
+ "list-extensions",
+ {
+ "action": "callback",
+ "callback": cb_list_extensions,
+ "group": "Commands",
+ "level": 1,
+ "help": "List available extensions.",
+ },
+ ),
+ (
+ "full-documentation",
+ {
+ "action": "callback",
+ "metavar": "<msg-id>",
+ "callback": self.cb_full_documentation,
+ "group": "Commands",
+ "level": 1,
+ "help": "Generate pylint's full documentation.",
+ },
+ ),
+ (
+ "generate-rcfile",
+ {
+ "action": "callback",
+ "callback": self.cb_generate_config,
+ "group": "Commands",
+ "help": "Generate a sample configuration file according to "
+ "the current configuration. You can put other options "
+ "before this one to get them in the generated "
+ "configuration.",
+ },
+ ),
+ (
+ "generate-man",
+ {
+ "action": "callback",
+ "callback": self.cb_generate_manpage,
+ "group": "Commands",
+ "help": "Generate pylint's man page.",
+ "hide": True,
+ },
+ ),
+ (
+ "errors-only",
+ {
+ "action": "callback",
+ "callback": self.cb_error_mode,
+ "short": "E",
+ "help": "In error mode, checkers without error messages are "
+ "disabled and for others, only the ERROR messages are "
+ "displayed, and no reports are done by default.",
+ },
+ ),
+ (
+ "py3k",
+ {
+ "action": "callback",
+ "callback": self.cb_python3_porting_mode,
+ "help": "In Python 3 porting mode, all checkers will be "
+ "disabled and only messages emitted by the porting "
+ "checker will be displayed.",
+ },
+ ),
+ (
+ "verbose",
+ {
+ "action": "callback",
+ "callback": self.cb_verbose_mode,
+ "short": "v",
+ "help": "In verbose mode, extra non-checker-related info "
+ "will be displayed.",
+ },
+ ),
+ ),
+ option_groups=self.option_groups,
+ pylintrc=self._rcfile,
+ )
+ # register standard checkers
+ if self._version_asked:
+ print(full_version)
+ sys.exit(0)
+ linter.load_default_plugins()
+ # load command line plugins
+ linter.load_plugin_modules(self._plugins)
+ # add some help section
+ linter.add_help_section("Environment variables", config.ENV_HELP, level=1)
+ linter.add_help_section(
+ "Output",
+ "Using the default text output, the message format is : \n"
+ " \n"
+ " MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE \n"
+ " \n"
+ "There are 5 kind of message types : \n"
+ " * (C) convention, for programming standard violation \n"
+ " * (R) refactor, for bad code smell \n"
+ " * (W) warning, for python specific problems \n"
+ " * (E) error, for probable bugs in the code \n"
+ " * (F) fatal, if an error occurred which prevented pylint from doing further\n"
+ "processing.\n",
+ level=1,
+ )
+ linter.add_help_section(
+ "Output status code",
+ "Pylint should leave with following status code: \n"
+ " * 0 if everything went fine \n"
+ " * 1 if a fatal message was issued \n"
+ " * 2 if an error message was issued \n"
+ " * 4 if a warning message was issued \n"
+ " * 8 if a refactor message was issued \n"
+ " * 16 if a convention message was issued \n"
+ " * 32 on usage error \n"
+ " \n"
+ "status 1 to 16 will be bit-ORed so you can know which different categories has\n"
+ "been issued by analysing pylint output status code\n",
+ level=1,
+ )
+ # read configuration
+ linter.disable("I")
+ linter.enable("c-extension-no-member")
+ try:
+ linter.read_config_file(verbose=self.verbose)
+ except OSError as ex:
+ print(ex, file=sys.stderr)
+ sys.exit(32)
+
+ config_parser = linter.cfgfile_parser
+ # run init hook, if present, before loading plugins
+ if config_parser.has_option("MASTER", "init-hook"):
+ cb_init_hook(
+ "init-hook", utils._unquote(config_parser.get("MASTER", "init-hook"))
+ )
+ # is there some additional plugins in the file configuration, in
+ if config_parser.has_option("MASTER", "load-plugins"):
+ plugins = utils._splitstrip(config_parser.get("MASTER", "load-plugins"))
+ linter.load_plugin_modules(plugins)
+ # now we can load file config and command line, plugins (which can
+ # provide options) have been registered
+ linter.load_config_file()
+
+ if reporter:
+ # if a custom reporter is provided as argument, it may be overridden
+ # by file parameters, so re-set it here, but before command line
+ # parsing so it's still overrideable by command line option
+ linter.set_reporter(reporter)
+ try:
+ args = linter.load_command_line_configuration(args)
+ except SystemExit as exc:
+ if exc.code == 2: # bad options
+ exc.code = 32
+ raise
+ if not args:
+ print(linter.help())
+ sys.exit(32)
+
+ if linter.config.jobs < 0:
+ print(
+ "Jobs number (%d) should be greater than or equal to 0"
+ % linter.config.jobs,
+ file=sys.stderr,
+ )
+ sys.exit(32)
+ if linter.config.jobs > 1 or linter.config.jobs == 0:
+ if multiprocessing is None:
+ print(
+ "Multiprocessing library is missing, fallback to single process",
+ file=sys.stderr,
+ )
+ linter.set_option("jobs", 1)
+ elif linter.config.jobs == 0:
+ linter.config.jobs = _cpu_count()
+
+ # We have loaded configuration from config file and command line. Now, we can
+ # load plugin specific configuration.
+ linter.load_plugin_configuration()
+
+ # Now that plugins are loaded, get list of all fail_on messages, and enable them
+ linter.enable_fail_on_messages()
+
+ if self._output:
+ try:
+ with open(self._output, "w") as output:
+ linter.reporter.set_output(output)
+ linter.check(args)
+ score_value = linter.generate_reports()
+ except OSError as ex:
+ print(ex, file=sys.stderr)
+ sys.exit(32)
+ else:
+ linter.check(args)
+ score_value = linter.generate_reports()
+
+ if do_exit is not UNUSED_PARAM_SENTINEL:
+ warnings.warn(
+ "do_exit is deprecated and it is going to be removed in a future version.",
+ DeprecationWarning,
+ )
+ exit = do_exit
+
+ if exit:
+ if linter.config.exit_zero:
+ sys.exit(0)
+ else:
+ if (
+ score_value
+ and score_value >= linter.config.fail_under
+ # detected messages flagged by --fail-on prevent non-zero exit code
+ and not linter.any_fail_on_issues()
+ ):
+ sys.exit(0)
+ sys.exit(self.linter.msg_status)
+
+ def version_asked(self, _, __):
+ """callback for version (i.e. before option parsing)"""
+ self._version_asked = True
+
+ def cb_set_rcfile(self, name, value):
+ """callback for option preprocessing (i.e. before option parsing)"""
+ self._rcfile = value
+
+ def cb_set_output(self, name, value):
+ """callback for option preprocessing (i.e. before option parsing)"""
+ self._output = value
+
+ def cb_add_plugins(self, name, value):
+ """callback for option preprocessing (i.e. before option parsing)"""
+ self._plugins.extend(utils._splitstrip(value))
+
+ def cb_error_mode(self, *args, **kwargs):
+ """error mode:
+ * disable all but error messages
+ * disable the 'miscellaneous' checker which can be safely deactivated in
+ debug
+ * disable reports
+ * do not save execution information
+ """
+ self.linter.error_mode()
+
+ def cb_generate_config(self, *args, **kwargs):
+ """optik callback for sample config file generation"""
+ self.linter.generate_config(skipsections=("COMMANDS",))
+ sys.exit(0)
+
+ def cb_generate_manpage(self, *args, **kwargs):
+ """optik callback for sample config file generation"""
+ self.linter.generate_manpage(__pkginfo__)
+ sys.exit(0)
+
+ def cb_help_message(self, option, optname, value, parser):
+ """optik callback for printing some help about a particular message"""
+ self.linter.msgs_store.help_message(utils._splitstrip(value))
+ sys.exit(0)
+
+ def cb_full_documentation(self, option, optname, value, parser):
+ """optik callback for printing full documentation"""
+ self.linter.print_full_documentation()
+ sys.exit(0)
+
+ def cb_list_messages(self, option, optname, value, parser):
+ """optik callback for printing available messages"""
+ self.linter.msgs_store.list_messages()
+ sys.exit(0)
+
+ def cb_list_messages_enabled(self, option, optname, value, parser):
+ """optik callback for printing available messages"""
+ self.linter.list_messages_enabled()
+ sys.exit(0)
+
+ def cb_list_groups(self, *args, **kwargs):
+ """List all the check groups that pylint knows about
+
+ These should be useful to know what check groups someone can disable
+ or enable.
+ """
+ for check in self.linter.get_checker_names():
+ print(check)
+ sys.exit(0)
+
+ def cb_python3_porting_mode(self, *args, **kwargs):
+ """Activate only the python3 porting checker."""
+ self.linter.python3_porting_mode()
+
+ def cb_verbose_mode(self, *args, **kwargs):
+ self.verbose = True
diff --git a/pylint/lint/utils.py b/pylint/lint/utils.py
new file mode 100644
index 0000000..a90abfb
--- /dev/null
+++ b/pylint/lint/utils.py
@@ -0,0 +1,76 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import contextlib
+import sys
+
+from pylint.lint.expand_modules import get_python_path
+
+
+class ArgumentPreprocessingError(Exception):
+ """Raised if an error occurs during argument preprocessing."""
+
+
+def preprocess_options(args, search_for):
+ """look for some options (keys of <search_for>) which have to be processed
+ before others
+
+ values of <search_for> are callback functions to call when the option is
+ found
+ """
+ i = 0
+ while i < len(args):
+ arg = args[i]
+ if arg.startswith("--"):
+ try:
+ option, val = arg[2:].split("=", 1)
+ except ValueError:
+ option, val = arg[2:], None
+ try:
+ cb, takearg = search_for[option]
+ except KeyError:
+ i += 1
+ else:
+ del args[i]
+ if takearg and val is None:
+ if i >= len(args) or args[i].startswith("-"):
+ msg = "Option %s expects a value" % option
+ raise ArgumentPreprocessingError(msg)
+ val = args[i]
+ del args[i]
+ elif not takearg and val is not None:
+ msg = "Option %s doesn't expects a value" % option
+ raise ArgumentPreprocessingError(msg)
+ cb(option, val)
+ else:
+ i += 1
+
+
+def _patch_sys_path(args):
+ original = list(sys.path)
+ changes = []
+ seen = set()
+ for arg in args:
+ path = get_python_path(arg)
+ if path not in seen:
+ changes.append(path)
+ seen.add(path)
+
+ sys.path[:] = changes + sys.path
+ return original
+
+
+@contextlib.contextmanager
+def fix_import_path(args):
+ """Prepare sys.path for running the linter checks.
+
+ Within this context, each of the given arguments is importable.
+ Paths are added to sys.path in corresponding order to the arguments.
+ We avoid adding duplicate directories to sys.path.
+ `sys.path` is reset to its original value upon exiting this context.
+ """
+ original = _patch_sys_path(args)
+ try:
+ yield
+ finally:
+ sys.path[:] = original
diff --git a/pylint/message/__init__.py b/pylint/message/__init__.py
new file mode 100644
index 0000000..45403bc
--- /dev/null
+++ b/pylint/message/__init__.py
@@ -0,0 +1,53 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2009 Vincent
+# Copyright (c) 2009 Mads Kiilerich <mads@kiilerich.com>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014-2015 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 LCD 47 <lcd047@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2014 Damien Nozay <damien.nozay@gmail.com>
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Simu Toni <simutoni@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 xmo-odoo <xmo-odoo@users.noreply.github.com>
+# Copyright (c) 2017-2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2017-2018, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2017 Chris Lamb <chris@chris-lamb.co.uk>
+# Copyright (c) 2017 Thomas Hisch <t.hisch@gmail.com>
+# Copyright (c) 2017 Mikhail Fesenko <proggga@gmail.com>
+# Copyright (c) 2017 Craig Citro <craigcitro@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""All the classes related to Message handling."""
+
+from pylint.message.message import Message
+from pylint.message.message_definition import MessageDefinition
+from pylint.message.message_definition_store import MessageDefinitionStore
+from pylint.message.message_handler_mix_in import MessagesHandlerMixIn
+from pylint.message.message_id_store import MessageIdStore
+
+__all__ = [
+ "Message",
+ "MessageDefinition",
+ "MessageDefinitionStore",
+ "MessagesHandlerMixIn",
+ "MessageIdStore",
+]
diff --git a/pylint/message/message.py b/pylint/message/message.py
new file mode 100644
index 0000000..f7a67f5
--- /dev/null
+++ b/pylint/message/message.py
@@ -0,0 +1,49 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+import collections
+
+from pylint.constants import MSG_TYPES
+
+_MsgBase = collections.namedtuple(
+ "_MsgBase",
+ [
+ "msg_id",
+ "symbol",
+ "msg",
+ "C",
+ "category",
+ "confidence",
+ "abspath",
+ "path",
+ "module",
+ "obj",
+ "line",
+ "column",
+ ],
+)
+
+
+class Message(_MsgBase):
+ """This class represent a message to be issued by the reporters"""
+
+ def __new__(cls, msg_id, symbol, location, msg, confidence):
+ return _MsgBase.__new__(
+ cls,
+ msg_id,
+ symbol,
+ msg,
+ msg_id[0],
+ MSG_TYPES[msg_id[0]],
+ confidence,
+ *location
+ )
+
+ def format(self, template: str) -> str:
+ """Format the message according to the given template.
+
+ The template format is the one of the format method :
+ cf. https://docs.python.org/2/library/string.html#formatstrings
+ """
+ return template.format(**self._asdict())
diff --git a/pylint/message/message_definition.py b/pylint/message/message_definition.py
new file mode 100644
index 0000000..1e8c53e
--- /dev/null
+++ b/pylint/message/message_definition.py
@@ -0,0 +1,87 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import sys
+from typing import List, Optional, Tuple
+
+from pylint.constants import MSG_TYPES
+from pylint.exceptions import InvalidMessageError
+from pylint.utils import normalize_text
+
+
+class MessageDefinition:
+ def __init__(
+ self,
+ checker, # BaseChecker
+ msgid: str,
+ msg: str,
+ description: str,
+ symbol: str,
+ scope: str,
+ minversion: Optional[Tuple[int, int, int, str, int]] = None,
+ maxversion: Optional[Tuple[int, int, int, str, int]] = None,
+ old_names: List[Tuple[str, str]] = None,
+ ):
+ self.checker_name = checker.name
+ self.check_msgid(msgid)
+ self.msgid = msgid
+ self.symbol = symbol
+ self.msg = msg
+ self.description = description
+ self.scope = scope
+ self.minversion = minversion
+ self.maxversion = maxversion
+ self.old_names: List[Tuple[str, str]] = []
+ if old_names:
+ for old_msgid, old_symbol in old_names:
+ self.check_msgid(old_msgid)
+ self.old_names.append(
+ (old_msgid, old_symbol),
+ )
+
+ @staticmethod
+ def check_msgid(msgid: str) -> None:
+ if len(msgid) != 5:
+ raise InvalidMessageError(f"Invalid message id {msgid!r}")
+ if msgid[0] not in MSG_TYPES:
+ raise InvalidMessageError(f"Bad message type {msgid[0]} in {msgid!r}")
+
+ def __repr__(self):
+ return f"MessageDefinition:{self.symbol} ({self.msgid})"
+
+ def __str__(self):
+ return f"{repr(self)}:\n{self.msg} {self.description}"
+
+ def may_be_emitted(self) -> bool:
+ """return True if message may be emitted using the current interpreter"""
+ if self.minversion is not None and self.minversion > sys.version_info:
+ return False
+ if self.maxversion is not None and self.maxversion <= sys.version_info:
+ return False
+ return True
+
+ def format_help(self, checkerref: bool = False) -> str:
+ """return the help string for the given message id"""
+ desc = self.description
+ if checkerref:
+ desc += " This message belongs to the %s checker." % self.checker_name
+ title = self.msg
+ if self.minversion or self.maxversion:
+ restr = []
+ if self.minversion:
+ restr.append("< %s" % ".".join(str(n) for n in self.minversion))
+ if self.maxversion:
+ restr.append(">= %s" % ".".join(str(n) for n in self.maxversion))
+ restriction = " or ".join(restr)
+ if checkerref:
+ desc += " It can't be emitted when using Python %s." % restriction
+ else:
+ desc += (
+ " This message can't be emitted when using Python %s." % restriction
+ )
+ msg_help = normalize_text(" ".join(desc.split()), indent=" ")
+ message_id = f"{self.symbol} ({self.msgid})"
+ if title != "%s":
+ title = title.splitlines()[0]
+ return ":{}: *{}*\n{}".format(message_id, title.rstrip(" "), msg_help)
+ return f":{message_id}:\n{msg_help}"
diff --git a/pylint/message/message_definition_store.py b/pylint/message/message_definition_store.py
new file mode 100644
index 0000000..382b090
--- /dev/null
+++ b/pylint/message/message_definition_store.py
@@ -0,0 +1,81 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+from typing import Dict, List, ValuesView
+
+from pylint.exceptions import UnknownMessageError
+from pylint.message.message_definition import MessageDefinition
+from pylint.message.message_id_store import MessageIdStore
+
+
+class MessageDefinitionStore:
+
+ """The messages store knows information about every possible message definition but has
+ no particular state during analysis.
+ """
+
+ def __init__(self):
+ self.message_id_store: MessageIdStore = MessageIdStore()
+ # Primary registry for all active messages definitions.
+ # It contains the 1:1 mapping from msgid to MessageDefinition.
+ # Keys are msgid, values are MessageDefinition
+ self._messages_definitions: Dict[str, MessageDefinition] = {}
+ # MessageDefinition kept by category
+ self._msgs_by_category: Dict[str, List[str]] = collections.defaultdict(list)
+
+ @property
+ def messages(self) -> ValuesView[MessageDefinition]:
+ """The list of all active messages."""
+ return self._messages_definitions.values()
+
+ def register_messages_from_checker(self, checker) -> None:
+ """Register all messages definitions from a checker."""
+ checker.check_consistency()
+ for message in checker.messages:
+ self.register_message(message)
+
+ def register_message(self, message: MessageDefinition) -> None:
+ """Register a MessageDefinition with consistency in mind."""
+ self.message_id_store.register_message_definition(
+ message.msgid, message.symbol, message.old_names
+ )
+ self._messages_definitions[message.msgid] = message
+ self._msgs_by_category[message.msgid[0]].append(message.msgid)
+
+ def get_message_definitions(self, msgid_or_symbol: str) -> List[MessageDefinition]:
+ """Returns the Message definition for either a numeric or symbolic id."""
+ return [
+ self._messages_definitions[m]
+ for m in self.message_id_store.get_active_msgids(msgid_or_symbol)
+ ]
+
+ def get_msg_display_string(self, msgid_or_symbol: str) -> str:
+ """Generates a user-consumable representation of a message."""
+ message_definitions = self.get_message_definitions(msgid_or_symbol)
+ if len(message_definitions) == 1:
+ return repr(message_definitions[0].symbol)
+ return repr([md.symbol for md in message_definitions])
+
+ def help_message(self, msgids_or_symbols: List[str]) -> None:
+ """Display help messages for the given message identifiers"""
+ for msgids_or_symbol in msgids_or_symbols:
+ try:
+ for message_definition in self.get_message_definitions(
+ msgids_or_symbol
+ ):
+ print(message_definition.format_help(checkerref=True))
+ print("")
+ except UnknownMessageError as ex:
+ print(ex)
+ print("")
+ continue
+
+ def list_messages(self) -> None:
+ """Output full messages list documentation in ReST format."""
+ messages = sorted(self._messages_definitions.values(), key=lambda m: m.msgid)
+ for message in messages:
+ if not message.may_be_emitted():
+ continue
+ print(message.format_help(checkerref=False))
+ print("")
diff --git a/pylint/message/message_handler_mix_in.py b/pylint/message/message_handler_mix_in.py
new file mode 100644
index 0000000..1b468ee
--- /dev/null
+++ b/pylint/message/message_handler_mix_in.py
@@ -0,0 +1,392 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import sys
+from typing import List, Tuple
+
+from pylint.constants import (
+ _SCOPE_EXEMPT,
+ MAIN_CHECKER_NAME,
+ MSG_STATE_CONFIDENCE,
+ MSG_STATE_SCOPE_CONFIG,
+ MSG_STATE_SCOPE_MODULE,
+ MSG_TYPES,
+ MSG_TYPES_LONG,
+ MSG_TYPES_STATUS,
+ WarningScope,
+)
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+from pylint.interfaces import UNDEFINED
+from pylint.message.message import Message
+from pylint.utils import get_module_and_frameid, get_rst_section, get_rst_title
+
+
+class MessagesHandlerMixIn:
+ """A mix-in class containing all the messages related methods for the main lint class."""
+
+ __by_id_managed_msgs: List[Tuple[str, str, str, int, bool]] = []
+
+ def __init__(self):
+ self._msgs_state = {}
+ self.msg_status = 0
+
+ def _checker_messages(self, checker):
+ for known_checker in self._checkers[checker.lower()]:
+ yield from known_checker.msgs
+
+ @classmethod
+ def clear_by_id_managed_msgs(cls):
+ cls.__by_id_managed_msgs.clear()
+
+ @classmethod
+ def get_by_id_managed_msgs(cls):
+ return cls.__by_id_managed_msgs
+
+ def _register_by_id_managed_msg(self, msgid_or_symbol: str, line, is_disabled=True):
+ """If the msgid is a numeric one, then register it to inform the user
+ it could furnish instead a symbolic msgid."""
+ if msgid_or_symbol[1:].isdigit():
+ try:
+ symbol = self.msgs_store.message_id_store.get_symbol(msgid=msgid_or_symbol) # type: ignore
+ except UnknownMessageError:
+ return
+ managed = (self.current_name, msgid_or_symbol, symbol, line, is_disabled) # type: ignore
+ MessagesHandlerMixIn.__by_id_managed_msgs.append(managed)
+
+ def disable(self, msgid, scope="package", line=None, ignore_unknown=False):
+ self._set_msg_status(
+ msgid, enable=False, scope=scope, line=line, ignore_unknown=ignore_unknown
+ )
+ self._register_by_id_managed_msg(msgid, line)
+
+ def enable(self, msgid, scope="package", line=None, ignore_unknown=False):
+ self._set_msg_status(
+ msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown
+ )
+ self._register_by_id_managed_msg(msgid, line, is_disabled=False)
+
+ def _set_msg_status(
+ self, msgid, enable, scope="package", line=None, ignore_unknown=False
+ ):
+ assert scope in ("package", "module")
+ if msgid == "all":
+ for _msgid in MSG_TYPES:
+ self._set_msg_status(_msgid, enable, scope, line, ignore_unknown)
+ if enable and not self._python3_porting_mode:
+ # Don't activate the python 3 porting checker if it wasn't activated explicitly.
+ self.disable("python3")
+ return
+
+ # msgid is a category?
+ category_id = msgid.upper()
+ if category_id not in MSG_TYPES:
+ category_id = MSG_TYPES_LONG.get(category_id)
+ if category_id is not None:
+ for _msgid in self.msgs_store._msgs_by_category.get(category_id):
+ self._set_msg_status(_msgid, enable, scope, line)
+ return
+
+ # msgid is a checker name?
+ if msgid.lower() in self._checkers:
+ for checker in self._checkers[msgid.lower()]:
+ for _msgid in checker.msgs:
+ self._set_msg_status(_msgid, enable, scope, line)
+ return
+
+ # msgid is report id?
+ if msgid.lower().startswith("rp"):
+ if enable:
+ self.enable_report(msgid)
+ else:
+ self.disable_report(msgid)
+ return
+
+ try:
+ # msgid is a symbolic or numeric msgid.
+ message_definitions = self.msgs_store.get_message_definitions(msgid)
+ except UnknownMessageError:
+ if ignore_unknown:
+ return
+ raise
+ for message_definition in message_definitions:
+ self._set_one_msg_status(scope, message_definition, line, enable)
+
+ def _set_one_msg_status(self, scope, msg, line, enable):
+ if scope == "module":
+ self.file_state.set_msg_status(msg, line, enable)
+ if not enable and msg.symbol != "locally-disabled":
+ self.add_message(
+ "locally-disabled", line=line, args=(msg.symbol, msg.msgid)
+ )
+ else:
+ msgs = self._msgs_state
+ msgs[msg.msgid] = enable
+ # sync configuration object
+ self.config.enable = [
+ self._message_symbol(mid) for mid, val in sorted(msgs.items()) if val
+ ]
+ self.config.disable = [
+ self._message_symbol(mid)
+ for mid, val in sorted(msgs.items())
+ if not val
+ ]
+
+ def _message_symbol(self, msgid):
+ """Get the message symbol of the given message id
+
+ Return the original message id if the message does not
+ exist.
+ """
+ try:
+ return [md.symbol for md in self.msgs_store.get_message_definitions(msgid)]
+ except UnknownMessageError:
+ return msgid
+
+ def get_message_state_scope(self, msgid, line=None, confidence=UNDEFINED):
+ """Returns the scope at which a message was enabled/disabled."""
+ if self.config.confidence and confidence.name not in self.config.confidence:
+ return MSG_STATE_CONFIDENCE
+ try:
+ if line in self.file_state._module_msgs_state[msgid]:
+ return MSG_STATE_SCOPE_MODULE
+ except (KeyError, TypeError):
+ return MSG_STATE_SCOPE_CONFIG
+ return None
+
+ def is_message_enabled(self, msg_descr, line=None, confidence=None):
+ """return true if the message associated to the given message id is
+ enabled
+
+ msgid may be either a numeric or symbolic message id.
+ """
+ if self.config.confidence and confidence:
+ if confidence.name not in self.config.confidence:
+ return False
+ try:
+ message_definitions = self.msgs_store.get_message_definitions(msg_descr)
+ msgids = [md.msgid for md in message_definitions]
+ except UnknownMessageError:
+ # The linter checks for messages that are not registered
+ # due to version mismatch, just treat them as message IDs
+ # for now.
+ msgids = [msg_descr]
+ for msgid in msgids:
+ if self.is_one_message_enabled(msgid, line):
+ return True
+ return False
+
+ def is_one_message_enabled(self, msgid, line):
+ if line is None:
+ return self._msgs_state.get(msgid, True)
+ try:
+ return self.file_state._module_msgs_state[msgid][line]
+ except KeyError:
+ # Check if the message's line is after the maximum line existing in ast tree.
+ # This line won't appear in the ast tree and won't be referred in
+ # self.file_state._module_msgs_state
+ # This happens for example with a commented line at the end of a module.
+ max_line_number = self.file_state.get_effective_max_line_number()
+ if max_line_number and line > max_line_number:
+ fallback = True
+ lines = self.file_state._raw_module_msgs_state.get(msgid, {})
+
+ # Doesn't consider scopes, as a disable can be in a different scope
+ # than that of the current line.
+ closest_lines = reversed(
+ [
+ (message_line, enable)
+ for message_line, enable in lines.items()
+ if message_line <= line
+ ]
+ )
+ last_line, is_enabled = next(closest_lines, (None, None))
+ if last_line is not None:
+ fallback = is_enabled
+
+ return self._msgs_state.get(msgid, fallback)
+ return self._msgs_state.get(msgid, True)
+
+ def add_message(
+ self, msgid, line=None, node=None, args=None, confidence=None, col_offset=None
+ ):
+ """Adds a message given by ID or name.
+
+ If provided, the message string is expanded using args.
+
+ AST checkers must provide the node argument (but may optionally
+ provide line if the line number is different), raw and token checkers
+ must provide the line argument.
+ """
+ if confidence is None:
+ confidence = UNDEFINED
+ message_definitions = self.msgs_store.get_message_definitions(msgid)
+ for message_definition in message_definitions:
+ self.add_one_message(
+ message_definition, line, node, args, confidence, col_offset
+ )
+
+ @staticmethod
+ def check_message_definition(message_definition, line, node):
+ if message_definition.msgid[0] not in _SCOPE_EXEMPT:
+ # Fatal messages and reports are special, the node/scope distinction
+ # does not apply to them.
+ if message_definition.scope == WarningScope.LINE:
+ if line is None:
+ raise InvalidMessageError(
+ "Message %s must provide line, got None"
+ % message_definition.msgid
+ )
+ if node is not None:
+ raise InvalidMessageError(
+ "Message %s must only provide line, "
+ "got line=%s, node=%s" % (message_definition.msgid, line, node)
+ )
+ elif message_definition.scope == WarningScope.NODE:
+ # Node-based warnings may provide an override line.
+ if node is None:
+ raise InvalidMessageError(
+ "Message %s must provide Node, got None"
+ % message_definition.msgid
+ )
+
+ def add_one_message(
+ self, message_definition, line, node, args, confidence, col_offset
+ ):
+ self.check_message_definition(message_definition, line, node)
+ if line is None and node is not None:
+ line = node.fromlineno
+ if col_offset is None and hasattr(node, "col_offset"):
+ col_offset = node.col_offset
+
+ # should this message be displayed
+ if not self.is_message_enabled(message_definition.msgid, line, confidence):
+ self.file_state.handle_ignored_message(
+ self.get_message_state_scope(
+ message_definition.msgid, line, confidence
+ ),
+ message_definition.msgid,
+ line,
+ node,
+ args,
+ confidence,
+ )
+ return
+ # update stats
+ msg_cat = MSG_TYPES[message_definition.msgid[0]]
+ self.msg_status |= MSG_TYPES_STATUS[message_definition.msgid[0]]
+ if self.stats is None:
+ # pylint: disable=fixme
+ # TODO self.stats should make sense,
+ # class should make sense as soon as instantiated
+ # This is not true for Linter and Reporter at least
+ # pylint: enable=fixme
+ self.stats = {
+ msg_cat: 0,
+ "by_module": {self.current_name: {msg_cat: 0}},
+ "by_msg": {},
+ }
+ self.stats[msg_cat] += 1
+ self.stats["by_module"][self.current_name][msg_cat] += 1
+ try:
+ self.stats["by_msg"][message_definition.symbol] += 1
+ except KeyError:
+ self.stats["by_msg"][message_definition.symbol] = 1
+ # expand message ?
+ msg = message_definition.msg
+ if args:
+ msg %= args
+ # get module and object
+ if node is None:
+ module, obj = self.current_name, ""
+ abspath = self.current_file
+ else:
+ module, obj = get_module_and_frameid(node)
+ abspath = node.root().file
+ if abspath is not None:
+ path = abspath.replace(self.reporter.path_strip_prefix, "", 1)
+ else:
+ path = "configuration"
+ # add the message
+ self.reporter.handle_message(
+ Message(
+ message_definition.msgid,
+ message_definition.symbol,
+ (abspath, path, module, obj, line or 1, col_offset or 0),
+ msg,
+ confidence,
+ )
+ )
+
+ def _get_checkers_infos(self):
+ by_checker = {}
+ for checker in self.get_checkers():
+ name = checker.name
+ if name != "master":
+ try:
+ by_checker[name]["checker"] = checker
+ by_checker[name]["options"] += checker.options_and_values()
+ by_checker[name]["msgs"].update(checker.msgs)
+ by_checker[name]["reports"] += checker.reports
+ except KeyError:
+ by_checker[name] = {
+ "checker": checker,
+ "options": list(checker.options_and_values()),
+ "msgs": dict(checker.msgs),
+ "reports": list(checker.reports),
+ }
+ return by_checker
+
+ def get_checkers_documentation(self):
+ result = get_rst_title("Pylint global options and switches", "-")
+ result += """
+Pylint provides global options and switches.
+
+"""
+ for checker in self.get_checkers():
+ name = checker.name
+ if name == MAIN_CHECKER_NAME:
+ if checker.options:
+ for section, options in checker.options_by_section():
+ if section is None:
+ title = "General options"
+ else:
+ title = "%s options" % section.capitalize()
+ result += get_rst_title(title, "~")
+ result += "%s\n" % get_rst_section(None, options)
+ result += get_rst_title("Pylint checkers' options and switches", "-")
+ result += """\
+
+Pylint checkers can provide three set of features:
+
+* options that control their execution,
+* messages that they can raise,
+* reports that they can generate.
+
+Below is a list of all checkers and their features.
+
+"""
+ by_checker = self._get_checkers_infos()
+ for checker in sorted(by_checker):
+ information = by_checker[checker]
+ checker = information["checker"]
+ del information["checker"]
+ result += checker.get_full_documentation(**information)
+ return result
+
+ def print_full_documentation(self, stream=None):
+ """output a full documentation in ReST format"""
+ if not stream:
+ stream = sys.stdout
+ print(self.get_checkers_documentation()[:-1], file=stream)
+
+ @staticmethod
+ def _print_checker_doc(information, stream=None):
+ """Helper method for print_full_documentation.
+
+ Also used by doc/exts/pylint_extensions.py.
+ """
+ if not stream:
+ stream = sys.stdout
+ checker = information["checker"]
+ del information["checker"]
+ print(checker.get_full_documentation(**information)[:-1], file=stream)
diff --git a/pylint/message/message_id_store.py b/pylint/message/message_id_store.py
new file mode 100644
index 0000000..98dd0a5
--- /dev/null
+++ b/pylint/message/message_id_store.py
@@ -0,0 +1,117 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+from typing import Dict, List, Optional, Tuple
+
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+
+
+class MessageIdStore:
+
+ """The MessageIdStore store MessageId and make sure that there is a 1-1 relation between msgid and symbol."""
+
+ def __init__(self):
+ self.__msgid_to_symbol: Dict[str, str] = {}
+ self.__symbol_to_msgid: Dict[str, str] = {}
+ self.__old_names: Dict[str, List[str]] = {}
+
+ def __len__(self):
+ return len(self.__msgid_to_symbol)
+
+ def __repr__(self):
+ result = "MessageIdStore: [\n"
+ for msgid, symbol in self.__msgid_to_symbol.items():
+ result += f" - {msgid} ({symbol})\n"
+ result += "]"
+ return result
+
+ def get_symbol(self, msgid: str) -> str:
+ try:
+ return self.__msgid_to_symbol[msgid]
+ except KeyError as e:
+ msg = f"'{msgid}' is not stored in the message store."
+ raise UnknownMessageError(msg) from e
+
+ def get_msgid(self, symbol: str) -> str:
+ try:
+ return self.__symbol_to_msgid[symbol]
+ except KeyError as e:
+ msg = f"'{symbol}' is not stored in the message store."
+ raise UnknownMessageError(msg) from e
+
+ def register_message_definition(
+ self, msgid: str, symbol: str, old_names: List[Tuple[str, str]]
+ ):
+ self.check_msgid_and_symbol(msgid, symbol)
+ self.add_msgid_and_symbol(msgid, symbol)
+ for old_msgid, old_symbol in old_names:
+ self.check_msgid_and_symbol(old_msgid, old_symbol)
+ self.add_legacy_msgid_and_symbol(old_msgid, old_symbol, msgid)
+
+ def add_msgid_and_symbol(self, msgid: str, symbol: str) -> None:
+ """Add valid message id.
+
+ There is a little duplication with add_legacy_msgid_and_symbol to avoid a function call,
+ this is called a lot at initialization."""
+ self.__msgid_to_symbol[msgid] = symbol
+ self.__symbol_to_msgid[symbol] = msgid
+
+ def add_legacy_msgid_and_symbol(
+ self, msgid: str, symbol: str, new_msgid: str
+ ) -> None:
+ """Add valid legacy message id.
+
+ There is a little duplication with add_msgid_and_symbol to avoid a function call,
+ this is called a lot at initialization."""
+ self.__msgid_to_symbol[msgid] = symbol
+ self.__symbol_to_msgid[symbol] = msgid
+ existing_old_names = self.__old_names.get(msgid, [])
+ existing_old_names.append(new_msgid)
+ self.__old_names[msgid] = existing_old_names
+
+ def check_msgid_and_symbol(self, msgid: str, symbol: str) -> None:
+ existing_msgid: Optional[str] = self.__symbol_to_msgid.get(symbol)
+ existing_symbol: Optional[str] = self.__msgid_to_symbol.get(msgid)
+ if existing_symbol is None and existing_msgid is None:
+ return # both symbol and msgid are usable
+ if existing_msgid is not None:
+ if existing_msgid != msgid:
+ self._raise_duplicate_msgid(symbol, msgid, existing_msgid)
+ if existing_symbol != symbol:
+ # See https://github.com/python/mypy/issues/10559
+ self._raise_duplicate_symbol(msgid, symbol, existing_symbol) # type: ignore
+
+ @staticmethod
+ def _raise_duplicate_symbol(msgid: str, symbol: str, other_symbol: str):
+ """Raise an error when a symbol is duplicated."""
+ symbols = [symbol, other_symbol]
+ symbols.sort()
+ error_message = f"Message id '{msgid}' cannot have both "
+ error_message += f"'{symbols[0]}' and '{symbols[1]}' as symbolic name."
+ raise InvalidMessageError(error_message)
+
+ @staticmethod
+ def _raise_duplicate_msgid(symbol: str, msgid: str, other_msgid: str) -> None:
+ """Raise an error when a msgid is duplicated."""
+ msgids = [msgid, other_msgid]
+ msgids.sort()
+ error_message = (
+ f"Message symbol '{symbol}' cannot be used for "
+ f"'{msgids[0]}' and '{msgids[1]}' at the same time."
+ f" If you're creating an 'old_names' use 'old-{symbol}' as the old symbol."
+ )
+ raise InvalidMessageError(error_message)
+
+ def get_active_msgids(self, msgid_or_symbol: str) -> List[str]:
+ """Return msgids but the input can be a symbol."""
+ # Only msgid can have a digit as second letter
+ is_msgid: bool = msgid_or_symbol[1:].isdigit()
+ if is_msgid:
+ msgid = msgid_or_symbol.upper()
+ symbol = self.__msgid_to_symbol.get(msgid)
+ else:
+ msgid = self.__symbol_to_msgid.get(msgid_or_symbol) # type: ignore
+ symbol = msgid_or_symbol
+ if msgid is None or symbol is None or not msgid or not symbol:
+ error_msg = f"No such message id or symbol '{msgid_or_symbol}'."
+ raise UnknownMessageError(error_msg)
+ return self.__old_names.get(msgid, [msgid])
diff --git a/pylint/pyreverse/__init__.py b/pylint/pyreverse/__init__.py
new file mode 100644
index 0000000..95a760d
--- /dev/null
+++ b/pylint/pyreverse/__init__.py
@@ -0,0 +1,8 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""
+pyreverse.extensions
+"""
+
+__revision__ = "$Id $"
diff --git a/pylint/pyreverse/diadefslib.py b/pylint/pyreverse/diadefslib.py
new file mode 100644
index 0000000..5d803c9
--- /dev/null
+++ b/pylint/pyreverse/diadefslib.py
@@ -0,0 +1,239 @@
+# Copyright (c) 2006, 2008-2010, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""handle diagram generation options for class diagram or default diagrams
+"""
+
+import astroid
+
+from pylint.pyreverse.diagrams import ClassDiagram, PackageDiagram
+from pylint.pyreverse.utils import LocalsVisitor
+
+BUILTINS_NAME = "builtins"
+
+# diagram generators ##########################################################
+
+
+class DiaDefGenerator:
+ """handle diagram generation options"""
+
+ def __init__(self, linker, handler):
+ """common Diagram Handler initialization"""
+ self.config = handler.config
+ self._set_default_options()
+ self.linker = linker
+ self.classdiagram = None # defined by subclasses
+
+ def get_title(self, node):
+ """get title for objects"""
+ title = node.name
+ if self.module_names:
+ title = f"{node.root().name}.{title}"
+ return title
+
+ def _set_option(self, option):
+ """activate some options if not explicitly deactivated"""
+ # if we have a class diagram, we want more information by default;
+ # so if the option is None, we return True
+ if option is None:
+ return bool(self.config.classes)
+ return option
+
+ def _set_default_options(self):
+ """set different default options with _default dictionary"""
+ self.module_names = self._set_option(self.config.module_names)
+ all_ancestors = self._set_option(self.config.all_ancestors)
+ all_associated = self._set_option(self.config.all_associated)
+ anc_level, association_level = (0, 0)
+ if all_ancestors:
+ anc_level = -1
+ if all_associated:
+ association_level = -1
+ if self.config.show_ancestors is not None:
+ anc_level = self.config.show_ancestors
+ if self.config.show_associated is not None:
+ association_level = self.config.show_associated
+ self.anc_level, self.association_level = anc_level, association_level
+
+ def _get_levels(self):
+ """help function for search levels"""
+ return self.anc_level, self.association_level
+
+ def show_node(self, node):
+ """true if builtins and not show_builtins"""
+ if self.config.show_builtin:
+ return True
+ return node.root().name != BUILTINS_NAME
+
+ def add_class(self, node):
+ """visit one class and add it to diagram"""
+ self.linker.visit(node)
+ self.classdiagram.add_object(self.get_title(node), node)
+
+ def get_ancestors(self, node, level):
+ """return ancestor nodes of a class node"""
+ if level == 0:
+ return
+ for ancestor in node.ancestors(recurs=False):
+ if not self.show_node(ancestor):
+ continue
+ yield ancestor
+
+ def get_associated(self, klass_node, level):
+ """return associated nodes of a class node"""
+ if level == 0:
+ return
+ for association_nodes in list(klass_node.instance_attrs_type.values()) + list(
+ klass_node.locals_type.values()
+ ):
+ for node in association_nodes:
+ if isinstance(node, astroid.Instance):
+ node = node._proxied
+ if not (isinstance(node, astroid.ClassDef) and self.show_node(node)):
+ continue
+ yield node
+
+ def extract_classes(self, klass_node, anc_level, association_level):
+ """extract recursively classes related to klass_node"""
+ if self.classdiagram.has_node(klass_node) or not self.show_node(klass_node):
+ return
+ self.add_class(klass_node)
+
+ for ancestor in self.get_ancestors(klass_node, anc_level):
+ self.extract_classes(ancestor, anc_level - 1, association_level)
+
+ for node in self.get_associated(klass_node, association_level):
+ self.extract_classes(node, anc_level, association_level - 1)
+
+
+class DefaultDiadefGenerator(LocalsVisitor, DiaDefGenerator):
+ """generate minimum diagram definition for the project :
+
+ * a package diagram including project's modules
+ * a class diagram including project's classes
+ """
+
+ def __init__(self, linker, handler):
+ DiaDefGenerator.__init__(self, linker, handler)
+ LocalsVisitor.__init__(self)
+
+ def visit_project(self, node):
+ """visit a pyreverse.utils.Project node
+
+ create a diagram definition for packages
+ """
+ mode = self.config.mode
+ if len(node.modules) > 1:
+ self.pkgdiagram = PackageDiagram("packages %s" % node.name, mode)
+ else:
+ self.pkgdiagram = None
+ self.classdiagram = ClassDiagram("classes %s" % node.name, mode)
+
+ def leave_project(self, node): # pylint: disable=unused-argument
+ """leave the pyreverse.utils.Project node
+
+ return the generated diagram definition
+ """
+ if self.pkgdiagram:
+ return self.pkgdiagram, self.classdiagram
+ return (self.classdiagram,)
+
+ def visit_module(self, node):
+ """visit an astroid.Module node
+
+ add this class to the package diagram definition
+ """
+ if self.pkgdiagram:
+ self.linker.visit(node)
+ self.pkgdiagram.add_object(node.name, node)
+
+ def visit_classdef(self, node):
+ """visit an astroid.Class node
+
+ add this class to the class diagram definition
+ """
+ anc_level, association_level = self._get_levels()
+ self.extract_classes(node, anc_level, association_level)
+
+ def visit_importfrom(self, node):
+ """visit astroid.ImportFrom and catch modules for package diagram"""
+ if self.pkgdiagram:
+ self.pkgdiagram.add_from_depend(node, node.modname)
+
+
+class ClassDiadefGenerator(DiaDefGenerator):
+ """generate a class diagram definition including all classes related to a
+ given class
+ """
+
+ def __init__(self, linker, handler):
+ DiaDefGenerator.__init__(self, linker, handler)
+
+ def class_diagram(self, project, klass):
+ """return a class diagram definition for the given klass and its
+ related klasses
+ """
+
+ self.classdiagram = ClassDiagram(klass, self.config.mode)
+ if len(project.modules) > 1:
+ module, klass = klass.rsplit(".", 1)
+ module = project.get_module(module)
+ else:
+ module = project.modules[0]
+ klass = klass.split(".")[-1]
+ klass = next(module.ilookup(klass))
+
+ anc_level, association_level = self._get_levels()
+ self.extract_classes(klass, anc_level, association_level)
+ return self.classdiagram
+
+
+# diagram handler #############################################################
+
+
+class DiadefsHandler:
+ """handle diagram definitions :
+
+ get it from user (i.e. xml files) or generate them
+ """
+
+ def __init__(self, config):
+ self.config = config
+
+ def get_diadefs(self, project, linker):
+ """Get the diagrams configuration data
+
+ :param project:The pyreverse project
+ :type project: pyreverse.utils.Project
+ :param linker: The linker
+ :type linker: pyreverse.inspector.Linker(IdGeneratorMixIn, LocalsVisitor)
+
+ :returns: The list of diagram definitions
+ :rtype: list(:class:`pylint.pyreverse.diagrams.ClassDiagram`)
+ """
+
+ # read and interpret diagram definitions (Diadefs)
+ diagrams = []
+ generator = ClassDiadefGenerator(linker, self)
+ for klass in self.config.classes:
+ diagrams.append(generator.class_diagram(project, klass))
+ if not diagrams:
+ diagrams = DefaultDiadefGenerator(linker, self).visit(project)
+ for diagram in diagrams:
+ diagram.extract_relationships()
+ return diagrams
diff --git a/pylint/pyreverse/diagrams.py b/pylint/pyreverse/diagrams.py
new file mode 100644
index 0000000..bf9f67a
--- /dev/null
+++ b/pylint/pyreverse/diagrams.py
@@ -0,0 +1,255 @@
+# Copyright (c) 2006, 2008-2010, 2012-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""diagram objects
+"""
+
+import astroid
+
+from pylint.checkers.utils import decorated_with_property
+from pylint.pyreverse.utils import FilterMixIn, is_interface
+
+
+class Figure:
+ """base class for counter handling"""
+
+
+class Relationship(Figure):
+ """a relation ship from an object in the diagram to another"""
+
+ def __init__(self, from_object, to_object, relation_type, name=None):
+ Figure.__init__(self)
+ self.from_object = from_object
+ self.to_object = to_object
+ self.type = relation_type
+ self.name = name
+
+
+class DiagramEntity(Figure):
+ """a diagram object, i.e. a label associated to an astroid node"""
+
+ def __init__(self, title="No name", node=None):
+ Figure.__init__(self)
+ self.title = title
+ self.node = node
+
+
+class ClassDiagram(Figure, FilterMixIn):
+ """main class diagram handling"""
+
+ TYPE = "class"
+
+ def __init__(self, title, mode):
+ FilterMixIn.__init__(self, mode)
+ Figure.__init__(self)
+ self.title = title
+ self.objects = []
+ self.relationships = {}
+ self._nodes = {}
+ self.depends = []
+
+ def get_relationships(self, role):
+ # sorted to get predictable (hence testable) results
+ return sorted(
+ self.relationships.get(role, ()),
+ key=lambda x: (x.from_object.fig_id, x.to_object.fig_id),
+ )
+
+ def add_relationship(self, from_object, to_object, relation_type, name=None):
+ """create a relation ship"""
+ rel = Relationship(from_object, to_object, relation_type, name)
+ self.relationships.setdefault(relation_type, []).append(rel)
+
+ def get_relationship(self, from_object, relation_type):
+ """return a relation ship or None"""
+ for rel in self.relationships.get(relation_type, ()):
+ if rel.from_object is from_object:
+ return rel
+ raise KeyError(relation_type)
+
+ def get_attrs(self, node):
+ """return visible attributes, possibly with class name"""
+ attrs = []
+ properties = [
+ (n, m)
+ for n, m in node.items()
+ if isinstance(m, astroid.FunctionDef) and decorated_with_property(m)
+ ]
+ for node_name, associated_nodes in (
+ list(node.instance_attrs_type.items())
+ + list(node.locals_type.items())
+ + properties
+ ):
+ if not self.show_attr(node_name):
+ continue
+ names = self.class_names(associated_nodes)
+ if names:
+ node_name = "{} : {}".format(node_name, ", ".join(names))
+ attrs.append(node_name)
+ return sorted(attrs)
+
+ def get_methods(self, node):
+ """return visible methods"""
+ methods = [
+ m
+ for m in node.values()
+ if isinstance(m, astroid.FunctionDef)
+ and not decorated_with_property(m)
+ and self.show_attr(m.name)
+ ]
+ return sorted(methods, key=lambda n: n.name)
+
+ def add_object(self, title, node):
+ """create a diagram object"""
+ assert node not in self._nodes
+ ent = DiagramEntity(title, node)
+ self._nodes[node] = ent
+ self.objects.append(ent)
+
+ def class_names(self, nodes):
+ """return class names if needed in diagram"""
+ names = []
+ for node in nodes:
+ if isinstance(node, astroid.Instance):
+ node = node._proxied
+ if (
+ isinstance(node, astroid.ClassDef)
+ and hasattr(node, "name")
+ and not self.has_node(node)
+ ):
+ if node.name not in names:
+ node_name = node.name
+ names.append(node_name)
+ return names
+
+ def nodes(self):
+ """return the list of underlying nodes"""
+ return self._nodes.keys()
+
+ def has_node(self, node):
+ """return true if the given node is included in the diagram"""
+ return node in self._nodes
+
+ def object_from_node(self, node):
+ """return the diagram object mapped to node"""
+ return self._nodes[node]
+
+ def classes(self):
+ """return all class nodes in the diagram"""
+ return [o for o in self.objects if isinstance(o.node, astroid.ClassDef)]
+
+ def classe(self, name):
+ """return a class by its name, raise KeyError if not found"""
+ for klass in self.classes():
+ if klass.node.name == name:
+ return klass
+ raise KeyError(name)
+
+ def extract_relationships(self):
+ """extract relation ships between nodes in the diagram"""
+ for obj in self.classes():
+ node = obj.node
+ obj.attrs = self.get_attrs(node)
+ obj.methods = self.get_methods(node)
+ # shape
+ if is_interface(node):
+ obj.shape = "interface"
+ else:
+ obj.shape = "class"
+ # inheritance link
+ for par_node in node.ancestors(recurs=False):
+ try:
+ par_obj = self.object_from_node(par_node)
+ self.add_relationship(obj, par_obj, "specialization")
+ except KeyError:
+ continue
+ # implements link
+ for impl_node in node.implements:
+ try:
+ impl_obj = self.object_from_node(impl_node)
+ self.add_relationship(obj, impl_obj, "implements")
+ except KeyError:
+ continue
+ # associations link
+ for name, values in list(node.instance_attrs_type.items()) + list(
+ node.locals_type.items()
+ ):
+ for value in values:
+ if value is astroid.Uninferable:
+ continue
+ if isinstance(value, astroid.Instance):
+ value = value._proxied
+ try:
+ associated_obj = self.object_from_node(value)
+ self.add_relationship(associated_obj, obj, "association", name)
+ except KeyError:
+ continue
+
+
+class PackageDiagram(ClassDiagram):
+ """package diagram handling"""
+
+ TYPE = "package"
+
+ def modules(self):
+ """return all module nodes in the diagram"""
+ return [o for o in self.objects if isinstance(o.node, astroid.Module)]
+
+ def module(self, name):
+ """return a module by its name, raise KeyError if not found"""
+ for mod in self.modules():
+ if mod.node.name == name:
+ return mod
+ raise KeyError(name)
+
+ def get_module(self, name, node):
+ """return a module by its name, looking also for relative imports;
+ raise KeyError if not found
+ """
+ for mod in self.modules():
+ mod_name = mod.node.name
+ if mod_name == name:
+ return mod
+ # search for fullname of relative import modules
+ package = node.root().name
+ if mod_name == f"{package}.{name}":
+ return mod
+ if mod_name == "{}.{}".format(package.rsplit(".", 1)[0], name):
+ return mod
+ raise KeyError(name)
+
+ def add_from_depend(self, node, from_module):
+ """add dependencies created by from-imports"""
+ mod_name = node.root().name
+ obj = self.module(mod_name)
+ if from_module not in obj.node.depends:
+ obj.node.depends.append(from_module)
+
+ def extract_relationships(self):
+ """extract relation ships between nodes in the diagram"""
+ ClassDiagram.extract_relationships(self)
+ for obj in self.classes():
+ # ownership
+ try:
+ mod = self.object_from_node(obj.node.root())
+ self.add_relationship(obj, mod, "ownership")
+ except KeyError:
+ continue
+ for obj in self.modules():
+ obj.shape = "package"
+ # dependencies
+ for dep_name in obj.node.depends:
+ try:
+ dep = self.get_module(dep_name, obj.node)
+ except KeyError:
+ continue
+ self.add_relationship(obj, dep, "depends")
diff --git a/pylint/pyreverse/inspector.py b/pylint/pyreverse/inspector.py
new file mode 100644
index 0000000..8fa1220
--- /dev/null
+++ b/pylint/pyreverse/inspector.py
@@ -0,0 +1,355 @@
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""
+Visitor doing some postprocessing on the astroid tree.
+Try to resolve definitions (namespace) dictionary, relationship...
+"""
+import collections
+import os
+import traceback
+
+import astroid
+
+from pylint.pyreverse import utils
+
+
+def _iface_hdlr(_):
+ """Handler used by interfaces to handle suspicious interface nodes."""
+ return True
+
+
+def _astroid_wrapper(func, modname):
+ print("parsing %s..." % modname)
+ try:
+ return func(modname)
+ except astroid.exceptions.AstroidBuildingException as exc:
+ print(exc)
+ except Exception: # pylint: disable=broad-except
+ traceback.print_exc()
+ return None
+
+
+def interfaces(node, herited=True, handler_func=_iface_hdlr):
+ """Return an iterator on interfaces implemented by the given class node."""
+ try:
+ implements = astroid.bases.Instance(node).getattr("__implements__")[0]
+ except astroid.exceptions.NotFoundError:
+ return
+ if not herited and implements.frame() is not node:
+ return
+ found = set()
+ missing = False
+ for iface in astroid.node_classes.unpack_infer(implements):
+ if iface is astroid.Uninferable:
+ missing = True
+ continue
+ if iface not in found and handler_func(iface):
+ found.add(iface)
+ yield iface
+ if missing:
+ raise astroid.exceptions.InferenceError()
+
+
+class IdGeneratorMixIn:
+ """Mixin adding the ability to generate integer uid."""
+
+ def __init__(self, start_value=0):
+ self.id_count = start_value
+
+ def init_counter(self, start_value=0):
+ """init the id counter"""
+ self.id_count = start_value
+
+ def generate_id(self):
+ """generate a new identifier"""
+ self.id_count += 1
+ return self.id_count
+
+
+class Linker(IdGeneratorMixIn, utils.LocalsVisitor):
+ """Walk on the project tree and resolve relationships.
+
+ According to options the following attributes may be
+ added to visited nodes:
+
+ * uid,
+ a unique identifier for the node (on astroid.Project, astroid.Module,
+ astroid.Class and astroid.locals_type). Only if the linker
+ has been instantiated with tag=True parameter (False by default).
+
+ * Function
+ a mapping from locals names to their bounded value, which may be a
+ constant like a string or an integer, or an astroid node
+ (on astroid.Module, astroid.Class and astroid.Function).
+
+ * instance_attrs_type
+ as locals_type but for klass member attributes (only on astroid.Class)
+
+ * implements,
+ list of implemented interface _objects_ (only on astroid.Class nodes)
+ """
+
+ def __init__(self, project, inherited_interfaces=0, tag=False):
+ IdGeneratorMixIn.__init__(self)
+ utils.LocalsVisitor.__init__(self)
+ # take inherited interface in consideration or not
+ self.inherited_interfaces = inherited_interfaces
+ # tag nodes or not
+ self.tag = tag
+ # visited project
+ self.project = project
+
+ def visit_project(self, node):
+ """visit a pyreverse.utils.Project node
+
+ * optionally tag the node with a unique id
+ """
+ if self.tag:
+ node.uid = self.generate_id()
+ for module in node.modules:
+ self.visit(module)
+
+ def visit_package(self, node):
+ """visit an astroid.Package node
+
+ * optionally tag the node with a unique id
+ """
+ if self.tag:
+ node.uid = self.generate_id()
+ for subelmt in node.values():
+ self.visit(subelmt)
+
+ def visit_module(self, node):
+ """visit an astroid.Module node
+
+ * set the locals_type mapping
+ * set the depends mapping
+ * optionally tag the node with a unique id
+ """
+ if hasattr(node, "locals_type"):
+ return
+ node.locals_type = collections.defaultdict(list)
+ node.depends = []
+ if self.tag:
+ node.uid = self.generate_id()
+
+ def visit_classdef(self, node):
+ """visit an astroid.Class node
+
+ * set the locals_type and instance_attrs_type mappings
+ * set the implements list and build it
+ * optionally tag the node with a unique id
+ """
+ if hasattr(node, "locals_type"):
+ return
+ node.locals_type = collections.defaultdict(list)
+ if self.tag:
+ node.uid = self.generate_id()
+ # resolve ancestors
+ for baseobj in node.ancestors(recurs=False):
+ specializations = getattr(baseobj, "specializations", [])
+ specializations.append(node)
+ baseobj.specializations = specializations
+ # resolve instance attributes
+ node.instance_attrs_type = collections.defaultdict(list)
+ for assignattrs in node.instance_attrs.values():
+ for assignattr in assignattrs:
+ if not isinstance(assignattr, astroid.Unknown):
+ self.handle_assignattr_type(assignattr, node)
+ # resolve implemented interface
+ try:
+ node.implements = list(interfaces(node, self.inherited_interfaces))
+ except astroid.InferenceError:
+ node.implements = ()
+
+ def visit_functiondef(self, node):
+ """visit an astroid.Function node
+
+ * set the locals_type mapping
+ * optionally tag the node with a unique id
+ """
+ if hasattr(node, "locals_type"):
+ return
+ node.locals_type = collections.defaultdict(list)
+ if self.tag:
+ node.uid = self.generate_id()
+
+ link_project = visit_project
+ link_module = visit_module
+ link_class = visit_classdef
+ link_function = visit_functiondef
+
+ def visit_assignname(self, node):
+ """visit an astroid.AssignName node
+
+ handle locals_type
+ """
+ # avoid double parsing done by different Linkers.visit
+ # running over the same project:
+ if hasattr(node, "_handled"):
+ return
+ node._handled = True
+ if node.name in node.frame():
+ frame = node.frame()
+ else:
+ # the name has been defined as 'global' in the frame and belongs
+ # there.
+ frame = node.root()
+ try:
+ if not hasattr(frame, "locals_type"):
+ # If the frame doesn't have a locals_type yet,
+ # it means it wasn't yet visited. Visit it now
+ # to add what's missing from it.
+ if isinstance(frame, astroid.ClassDef):
+ self.visit_classdef(frame)
+ elif isinstance(frame, astroid.FunctionDef):
+ self.visit_functiondef(frame)
+ else:
+ self.visit_module(frame)
+
+ current = frame.locals_type[node.name]
+ values = set(node.infer())
+ frame.locals_type[node.name] = list(set(current) | values)
+ except astroid.InferenceError:
+ pass
+
+ @staticmethod
+ def handle_assignattr_type(node, parent):
+ """handle an astroid.assignattr node
+
+ handle instance_attrs_type
+ """
+ try:
+ values = set(node.infer())
+ current = set(parent.instance_attrs_type[node.attrname])
+ parent.instance_attrs_type[node.attrname] = list(current | values)
+ except astroid.InferenceError:
+ pass
+
+ def visit_import(self, node):
+ """visit an astroid.Import node
+
+ resolve module dependencies
+ """
+ context_file = node.root().file
+ for name in node.names:
+ relative = astroid.modutils.is_relative(name[0], context_file)
+ self._imported_module(node, name[0], relative)
+
+ def visit_importfrom(self, node):
+ """visit an astroid.ImportFrom node
+
+ resolve module dependencies
+ """
+ basename = node.modname
+ context_file = node.root().file
+ if context_file is not None:
+ relative = astroid.modutils.is_relative(basename, context_file)
+ else:
+ relative = False
+ for name in node.names:
+ if name[0] == "*":
+ continue
+ # analyze dependencies
+ fullname = f"{basename}.{name[0]}"
+ if fullname.find(".") > -1:
+ try:
+ fullname = astroid.modutils.get_module_part(fullname, context_file)
+ except ImportError:
+ continue
+ if fullname != basename:
+ self._imported_module(node, fullname, relative)
+
+ def compute_module(self, context_name, mod_path):
+ """return true if the module should be added to dependencies"""
+ package_dir = os.path.dirname(self.project.path)
+ if context_name == mod_path:
+ return 0
+ if astroid.modutils.is_standard_module(mod_path, (package_dir,)):
+ return 1
+ return 0
+
+ def _imported_module(self, node, mod_path, relative):
+ """Notify an imported module, used to analyze dependencies"""
+ module = node.root()
+ context_name = module.name
+ if relative:
+ mod_path = "{}.{}".format(".".join(context_name.split(".")[:-1]), mod_path)
+ if self.compute_module(context_name, mod_path):
+ # handle dependencies
+ if not hasattr(module, "depends"):
+ module.depends = []
+ mod_paths = module.depends
+ if mod_path not in mod_paths:
+ mod_paths.append(mod_path)
+
+
+class Project:
+ """a project handle a set of modules / packages"""
+
+ def __init__(self, name=""):
+ self.name = name
+ self.path = None
+ self.modules = []
+ self.locals = {}
+ self.__getitem__ = self.locals.__getitem__
+ self.__iter__ = self.locals.__iter__
+ self.values = self.locals.values
+ self.keys = self.locals.keys
+ self.items = self.locals.items
+
+ def add_module(self, node):
+ self.locals[node.name] = node
+ self.modules.append(node)
+
+ def get_module(self, name):
+ return self.locals[name]
+
+ def get_children(self):
+ return self.modules
+
+ def __repr__(self):
+ return f"<Project {self.name!r} at {id(self)} ({len(self.modules)} modules)>"
+
+
+def project_from_files(
+ files, func_wrapper=_astroid_wrapper, project_name="no name", black_list=("CVS",)
+):
+ """return a Project from a list of files or modules"""
+ # build the project representation
+ astroid_manager = astroid.manager.AstroidManager()
+ project = Project(project_name)
+ for something in files:
+ if not os.path.exists(something):
+ fpath = astroid.modutils.file_from_modpath(something.split("."))
+ elif os.path.isdir(something):
+ fpath = os.path.join(something, "__init__.py")
+ else:
+ fpath = something
+ ast = func_wrapper(astroid_manager.ast_from_file, fpath)
+ if ast is None:
+ continue
+ project.path = project.path or ast.file
+ project.add_module(ast)
+ base_name = ast.name
+ # recurse in package except if __init__ was explicitly given
+ if ast.package and something.find("__init__") == -1:
+ # recurse on others packages / modules if this is a package
+ for fpath in astroid.modutils.get_module_files(
+ os.path.dirname(ast.file), black_list
+ ):
+ ast = func_wrapper(astroid_manager.ast_from_file, fpath)
+ if ast is None or ast.name == base_name:
+ continue
+ project.add_module(ast)
+ return project
diff --git a/pylint/pyreverse/main.py b/pylint/pyreverse/main.py
new file mode 100644
index 0000000..a62a1c2
--- /dev/null
+++ b/pylint/pyreverse/main.py
@@ -0,0 +1,231 @@
+# Copyright (c) 2008-2010, 2012-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Alexander Pervakov <frost.nzcr4@jagmort.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Mark Byrne <mbyrnepr2@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""
+ %prog [options] <packages>
+
+ create UML diagrams for classes and modules in <packages>
+"""
+import os
+import subprocess
+import sys
+
+from pylint.config import ConfigurationMixIn
+from pylint.pyreverse import writer
+from pylint.pyreverse.diadefslib import DiadefsHandler
+from pylint.pyreverse.inspector import Linker, project_from_files
+from pylint.pyreverse.utils import insert_default_options
+
+OPTIONS = (
+ (
+ "filter-mode",
+ dict(
+ short="f",
+ default="PUB_ONLY",
+ dest="mode",
+ type="string",
+ action="store",
+ metavar="<mode>",
+ help="""filter attributes and functions according to
+ <mode>. Correct modes are :
+ 'PUB_ONLY' filter all non public attributes
+ [DEFAULT], equivalent to PRIVATE+SPECIAL_A
+ 'ALL' no filter
+ 'SPECIAL' filter Python special functions
+ except constructor
+ 'OTHER' filter protected and private
+ attributes""",
+ ),
+ ),
+ (
+ "class",
+ dict(
+ short="c",
+ action="append",
+ metavar="<class>",
+ dest="classes",
+ default=[],
+ help="create a class diagram with all classes related to <class>;\
+ this uses by default the options -ASmy",
+ ),
+ ),
+ (
+ "show-ancestors",
+ dict(
+ short="a",
+ action="store",
+ metavar="<ancestor>",
+ type="int",
+ help="show <ancestor> generations of ancestor classes not in <projects>",
+ ),
+ ),
+ (
+ "all-ancestors",
+ dict(
+ short="A",
+ default=None,
+ help="show all ancestors off all classes in <projects>",
+ ),
+ ),
+ (
+ "show-associated",
+ dict(
+ short="s",
+ action="store",
+ metavar="<association_level>",
+ type="int",
+ help="show <association_level> levels of associated classes not in <projects>",
+ ),
+ ),
+ (
+ "all-associated",
+ dict(
+ short="S",
+ default=None,
+ help="show recursively all associated off all associated classes",
+ ),
+ ),
+ (
+ "show-builtin",
+ dict(
+ short="b",
+ action="store_true",
+ default=False,
+ help="include builtin objects in representation of classes",
+ ),
+ ),
+ (
+ "module-names",
+ dict(
+ short="m",
+ default=None,
+ type="yn",
+ metavar="[yn]",
+ help="include module name in representation of classes",
+ ),
+ ),
+ (
+ "only-classnames",
+ dict(
+ short="k",
+ action="store_true",
+ default=False,
+ help="don't show attributes and methods in the class boxes; \
+this disables -f values",
+ ),
+ ),
+ (
+ "output",
+ dict(
+ short="o",
+ dest="output_format",
+ action="store",
+ default="dot",
+ metavar="<format>",
+ help="create a *.<format> output file if format available.",
+ ),
+ ),
+ (
+ "ignore",
+ {
+ "type": "csv",
+ "metavar": "<file[,file...]>",
+ "dest": "ignore_list",
+ "default": ("CVS",),
+ "help": "Files or directories to be skipped. They "
+ "should be base names, not paths.",
+ },
+ ),
+ (
+ "project",
+ {
+ "default": "",
+ "type": "string",
+ "short": "p",
+ "metavar": "<project name>",
+ "help": "set the project name.",
+ },
+ ),
+ (
+ "output-directory",
+ {
+ "default": "",
+ "type": "string",
+ "short": "d",
+ "action": "store",
+ "metavar": "<output_directory>",
+ "help": "set the output directory path.",
+ },
+ ),
+)
+
+
+def _check_graphviz_available(output_format):
+ """check if we need graphviz for different output format"""
+ try:
+ subprocess.call(["dot", "-V"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ except OSError:
+ print(
+ "The output format '%s' is currently not available.\n"
+ "Please install 'Graphviz' to have other output formats "
+ "than 'dot' or 'vcg'." % output_format
+ )
+ sys.exit(32)
+
+
+class Run(ConfigurationMixIn):
+ """base class providing common behaviour for pyreverse commands"""
+
+ options = OPTIONS # type: ignore
+
+ def __init__(self, args):
+ ConfigurationMixIn.__init__(self, usage=__doc__)
+ insert_default_options()
+ args = self.load_command_line_configuration()
+ if self.config.output_format not in ("dot", "vcg"):
+ _check_graphviz_available(self.config.output_format)
+
+ sys.exit(self.run(args))
+
+ def run(self, args):
+ """checking arguments and run project"""
+ if not args:
+ print(self.help())
+ return 1
+ # insert current working directory to the python path to recognize
+ # dependencies to local modules even if cwd is not in the PYTHONPATH
+ sys.path.insert(0, os.getcwd())
+ try:
+ project = project_from_files(
+ args,
+ project_name=self.config.project,
+ black_list=self.config.ignore_list,
+ )
+ linker = Linker(project, tag=True)
+ handler = DiadefsHandler(self.config)
+ diadefs = handler.get_diadefs(project, linker)
+ finally:
+ sys.path.pop(0)
+
+ if self.config.output_format == "vcg":
+ writer.VCGWriter(self.config).write(diadefs)
+ else:
+ writer.DotWriter(self.config).write(diadefs)
+ return 0
+
+
+if __name__ == "__main__":
+ Run(sys.argv[1:])
diff --git a/pylint/pyreverse/utils.py b/pylint/pyreverse/utils.py
new file mode 100644
index 0000000..a24d227
--- /dev/null
+++ b/pylint/pyreverse/utils.py
@@ -0,0 +1,215 @@
+# Copyright (c) 2006, 2008, 2010, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 yeting li <liyt@ios.ac.cn>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2020 bernie gray <bfgray3@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Generic classes/functions for pyreverse core/extensions. """
+import os
+import re
+import sys
+
+RCFILE = ".pyreverserc"
+
+
+def get_default_options():
+ """Read config file and return list of options."""
+ options = []
+ home = os.environ.get("HOME", "")
+ if home:
+ rcfile = os.path.join(home, RCFILE)
+ try:
+ with open(rcfile) as file_handle:
+ options = file_handle.read().split()
+ except OSError:
+ pass # ignore if no config file found
+ return options
+
+
+def insert_default_options():
+ """insert default options to sys.argv"""
+ options = get_default_options()
+ options.reverse()
+ for arg in options:
+ sys.argv.insert(1, arg)
+
+
+# astroid utilities ###########################################################
+SPECIAL = re.compile(r"^__([^\W_]_*)+__$")
+PRIVATE = re.compile(r"^__(_*[^\W_])+_?$")
+PROTECTED = re.compile(r"^_\w*$")
+
+
+def get_visibility(name):
+ """return the visibility from a name: public, protected, private or special"""
+ if SPECIAL.match(name):
+ visibility = "special"
+ elif PRIVATE.match(name):
+ visibility = "private"
+ elif PROTECTED.match(name):
+ visibility = "protected"
+
+ else:
+ visibility = "public"
+ return visibility
+
+
+ABSTRACT = re.compile(r"^.*Abstract.*")
+FINAL = re.compile(r"^[^\W\da-z]*$")
+
+
+def is_abstract(node):
+ """return true if the given class node correspond to an abstract class
+ definition
+ """
+ return ABSTRACT.match(node.name)
+
+
+def is_final(node):
+ """return true if the given class/function node correspond to final
+ definition
+ """
+ return FINAL.match(node.name)
+
+
+def is_interface(node):
+ # bw compat
+ return node.type == "interface"
+
+
+def is_exception(node):
+ # bw compat
+ return node.type == "exception"
+
+
+# Helpers #####################################################################
+
+_CONSTRUCTOR = 1
+_SPECIAL = 2
+_PROTECTED = 4
+_PRIVATE = 8
+MODES = {
+ "ALL": 0,
+ "PUB_ONLY": _SPECIAL + _PROTECTED + _PRIVATE,
+ "SPECIAL": _SPECIAL,
+ "OTHER": _PROTECTED + _PRIVATE,
+}
+VIS_MOD = {
+ "special": _SPECIAL,
+ "protected": _PROTECTED,
+ "private": _PRIVATE,
+ "public": 0,
+}
+
+
+class FilterMixIn:
+ """filter nodes according to a mode and nodes' visibility"""
+
+ def __init__(self, mode):
+ "init filter modes"
+ __mode = 0
+ for nummod in mode.split("+"):
+ try:
+ __mode += MODES[nummod]
+ except KeyError as ex:
+ print("Unknown filter mode %s" % ex, file=sys.stderr)
+ self.__mode = __mode
+
+ def show_attr(self, node):
+ """return true if the node should be treated"""
+ visibility = get_visibility(getattr(node, "name", node))
+ return not self.__mode & VIS_MOD[visibility]
+
+
+class ASTWalker:
+ """a walker visiting a tree in preorder, calling on the handler:
+
+ * visit_<class name> on entering a node, where class name is the class of
+ the node in lower case
+
+ * leave_<class name> on leaving a node, where class name is the class of
+ the node in lower case
+ """
+
+ def __init__(self, handler):
+ self.handler = handler
+ self._cache = {}
+
+ def walk(self, node, _done=None):
+ """walk on the tree from <node>, getting callbacks from handler"""
+ if _done is None:
+ _done = set()
+ if node in _done:
+ raise AssertionError((id(node), node, node.parent))
+ _done.add(node)
+ self.visit(node)
+ for child_node in node.get_children():
+ assert child_node is not node
+ self.walk(child_node, _done)
+ self.leave(node)
+ assert node.parent is not node
+
+ def get_callbacks(self, node):
+ """get callbacks from handler for the visited node"""
+ klass = node.__class__
+ methods = self._cache.get(klass)
+ if methods is None:
+ handler = self.handler
+ kid = klass.__name__.lower()
+ e_method = getattr(
+ handler, "visit_%s" % kid, getattr(handler, "visit_default", None)
+ )
+ l_method = getattr(
+ handler, "leave_%s" % kid, getattr(handler, "leave_default", None)
+ )
+ self._cache[klass] = (e_method, l_method)
+ else:
+ e_method, l_method = methods
+ return e_method, l_method
+
+ def visit(self, node):
+ """walk on the tree from <node>, getting callbacks from handler"""
+ method = self.get_callbacks(node)[0]
+ if method is not None:
+ method(node)
+
+ def leave(self, node):
+ """walk on the tree from <node>, getting callbacks from handler"""
+ method = self.get_callbacks(node)[1]
+ if method is not None:
+ method(node)
+
+
+class LocalsVisitor(ASTWalker):
+ """visit a project by traversing the locals dictionary"""
+
+ def __init__(self):
+ ASTWalker.__init__(self, self)
+ self._visited = set()
+
+ def visit(self, node):
+ """launch the visit starting from the given node"""
+ if node in self._visited:
+ return None
+
+ self._visited.add(node)
+ methods = self.get_callbacks(node)
+ if methods[0] is not None:
+ methods[0](node)
+ if hasattr(node, "locals"): # skip Instance and other proxy
+ for local_node in node.values():
+ self.visit(local_node)
+ if methods[1] is not None:
+ return methods[1](node)
+ return None
diff --git a/pylint/pyreverse/vcgutils.py b/pylint/pyreverse/vcgutils.py
new file mode 100644
index 0000000..38193b3
--- /dev/null
+++ b/pylint/pyreverse/vcgutils.py
@@ -0,0 +1,224 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Ram Rachum <ram@rachum.com>
+# Copyright (c) 2020 谭九鼎 <109224573@qq.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Functions to generate files readable with Georg Sander's vcg
+(Visualization of Compiler Graphs).
+
+You can download vcg at https://rw4.cs.uni-sb.de/~sander/html/gshome.html
+Note that vcg exists as a debian package.
+
+See vcg's documentation for explanation about the different values that
+maybe used for the functions parameters.
+"""
+
+ATTRS_VAL = {
+ "algos": (
+ "dfs",
+ "tree",
+ "minbackward",
+ "left_to_right",
+ "right_to_left",
+ "top_to_bottom",
+ "bottom_to_top",
+ "maxdepth",
+ "maxdepthslow",
+ "mindepth",
+ "mindepthslow",
+ "mindegree",
+ "minindegree",
+ "minoutdegree",
+ "maxdegree",
+ "maxindegree",
+ "maxoutdegree",
+ ),
+ "booleans": ("yes", "no"),
+ "colors": (
+ "black",
+ "white",
+ "blue",
+ "red",
+ "green",
+ "yellow",
+ "magenta",
+ "lightgrey",
+ "cyan",
+ "darkgrey",
+ "darkblue",
+ "darkred",
+ "darkgreen",
+ "darkyellow",
+ "darkmagenta",
+ "darkcyan",
+ "gold",
+ "lightblue",
+ "lightred",
+ "lightgreen",
+ "lightyellow",
+ "lightmagenta",
+ "lightcyan",
+ "lilac",
+ "turquoise",
+ "aquamarine",
+ "khaki",
+ "purple",
+ "yellowgreen",
+ "pink",
+ "orange",
+ "orchid",
+ ),
+ "shapes": ("box", "ellipse", "rhomb", "triangle"),
+ "textmodes": ("center", "left_justify", "right_justify"),
+ "arrowstyles": ("solid", "line", "none"),
+ "linestyles": ("continuous", "dashed", "dotted", "invisible"),
+}
+
+# meaning of possible values:
+# O -> string
+# 1 -> int
+# list -> value in list
+GRAPH_ATTRS = {
+ "title": 0,
+ "label": 0,
+ "color": ATTRS_VAL["colors"],
+ "textcolor": ATTRS_VAL["colors"],
+ "bordercolor": ATTRS_VAL["colors"],
+ "width": 1,
+ "height": 1,
+ "borderwidth": 1,
+ "textmode": ATTRS_VAL["textmodes"],
+ "shape": ATTRS_VAL["shapes"],
+ "shrink": 1,
+ "stretch": 1,
+ "orientation": ATTRS_VAL["algos"],
+ "vertical_order": 1,
+ "horizontal_order": 1,
+ "xspace": 1,
+ "yspace": 1,
+ "layoutalgorithm": ATTRS_VAL["algos"],
+ "late_edge_labels": ATTRS_VAL["booleans"],
+ "display_edge_labels": ATTRS_VAL["booleans"],
+ "dirty_edge_labels": ATTRS_VAL["booleans"],
+ "finetuning": ATTRS_VAL["booleans"],
+ "manhattan_edges": ATTRS_VAL["booleans"],
+ "smanhattan_edges": ATTRS_VAL["booleans"],
+ "port_sharing": ATTRS_VAL["booleans"],
+ "edges": ATTRS_VAL["booleans"],
+ "nodes": ATTRS_VAL["booleans"],
+ "splines": ATTRS_VAL["booleans"],
+}
+NODE_ATTRS = {
+ "title": 0,
+ "label": 0,
+ "color": ATTRS_VAL["colors"],
+ "textcolor": ATTRS_VAL["colors"],
+ "bordercolor": ATTRS_VAL["colors"],
+ "width": 1,
+ "height": 1,
+ "borderwidth": 1,
+ "textmode": ATTRS_VAL["textmodes"],
+ "shape": ATTRS_VAL["shapes"],
+ "shrink": 1,
+ "stretch": 1,
+ "vertical_order": 1,
+ "horizontal_order": 1,
+}
+EDGE_ATTRS = {
+ "sourcename": 0,
+ "targetname": 0,
+ "label": 0,
+ "linestyle": ATTRS_VAL["linestyles"],
+ "class": 1,
+ "thickness": 0,
+ "color": ATTRS_VAL["colors"],
+ "textcolor": ATTRS_VAL["colors"],
+ "arrowcolor": ATTRS_VAL["colors"],
+ "backarrowcolor": ATTRS_VAL["colors"],
+ "arrowsize": 1,
+ "backarrowsize": 1,
+ "arrowstyle": ATTRS_VAL["arrowstyles"],
+ "backarrowstyle": ATTRS_VAL["arrowstyles"],
+ "textmode": ATTRS_VAL["textmodes"],
+ "priority": 1,
+ "anchor": 1,
+ "horizontal_order": 1,
+}
+
+
+# Misc utilities ###############################################################
+
+
+class VCGPrinter:
+ """A vcg graph writer."""
+
+ def __init__(self, output_stream):
+ self._stream = output_stream
+ self._indent = ""
+
+ def open_graph(self, **args):
+ """open a vcg graph"""
+ self._stream.write("%sgraph:{\n" % self._indent)
+ self._inc_indent()
+ self._write_attributes(GRAPH_ATTRS, **args)
+
+ def close_graph(self):
+ """close a vcg graph"""
+ self._dec_indent()
+ self._stream.write("%s}\n" % self._indent)
+
+ def node(self, title, **args):
+ """draw a node"""
+ self._stream.write(f'{self._indent}node: {{title:"{title}"')
+ self._write_attributes(NODE_ATTRS, **args)
+ self._stream.write("}\n")
+
+ def edge(self, from_node, to_node, edge_type="", **args):
+ """draw an edge from a node to another."""
+ self._stream.write(
+ '%s%sedge: {sourcename:"%s" targetname:"%s"'
+ % (self._indent, edge_type, from_node, to_node)
+ )
+ self._write_attributes(EDGE_ATTRS, **args)
+ self._stream.write("}\n")
+
+ # private ##################################################################
+
+ def _write_attributes(self, attributes_dict, **args):
+ """write graph, node or edge attributes"""
+ for key, value in args.items():
+ try:
+ _type = attributes_dict[key]
+ except KeyError as e:
+ raise Exception(
+ """no such attribute %s
+possible attributes are %s"""
+ % (key, attributes_dict.keys())
+ ) from e
+
+ if not _type:
+ self._stream.write(f'{self._indent}{key}:"{value}"\n')
+ elif _type == 1:
+ self._stream.write(f"{self._indent}{key}:{int(value)}\n")
+ elif value in _type:
+ self._stream.write(f"{self._indent}{key}:{value}\n")
+ else:
+ raise Exception(
+ f"""value {value} isn't correct for attribute {key}
+correct values are {type}"""
+ )
+
+ def _inc_indent(self):
+ """increment indentation"""
+ self._indent = " %s" % self._indent
+
+ def _dec_indent(self):
+ """decrement indentation"""
+ self._indent = self._indent[:-2]
diff --git a/pylint/pyreverse/writer.py b/pylint/pyreverse/writer.py
new file mode 100644
index 0000000..0d80bb9
--- /dev/null
+++ b/pylint/pyreverse/writer.py
@@ -0,0 +1,218 @@
+# Copyright (c) 2008-2010, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Mike Frysinger <vapier@gentoo.org>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Kylian <development@goudcode.nl>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 Mark Byrne <mbyrnepr2@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Utilities for creating VCG and Dot diagrams"""
+
+import os
+
+from pylint.graph import DotBackend
+from pylint.pyreverse.utils import is_exception
+from pylint.pyreverse.vcgutils import VCGPrinter
+
+
+class DiagramWriter:
+ """base class for writing project diagrams"""
+
+ def __init__(self, config, styles):
+ self.config = config
+ self.pkg_edges, self.inh_edges, self.imp_edges, self.association_edges = styles
+ self.printer = None # defined in set_printer
+
+ def write(self, diadefs):
+ """write files for <project> according to <diadefs>"""
+ for diagram in diadefs:
+ basename = diagram.title.strip().replace(" ", "_")
+ file_name = f"{basename}.{self.config.output_format}"
+ if os.path.exists(self.config.output_directory):
+ file_name = os.path.join(self.config.output_directory, file_name)
+ self.set_printer(file_name, basename)
+ if diagram.TYPE == "class":
+ self.write_classes(diagram)
+ else:
+ self.write_packages(diagram)
+ self.close_graph()
+
+ def write_packages(self, diagram):
+ """write a package diagram"""
+ # sorted to get predictable (hence testable) results
+ for i, obj in enumerate(sorted(diagram.modules(), key=lambda x: x.title)):
+ self.printer.emit_node(i, label=self.get_title(obj), shape="box")
+ obj.fig_id = i
+ # package dependencies
+ for rel in diagram.get_relationships("depends"):
+ self.printer.emit_edge(
+ rel.from_object.fig_id, rel.to_object.fig_id, **self.pkg_edges
+ )
+
+ def write_classes(self, diagram):
+ """write a class diagram"""
+ # sorted to get predictable (hence testable) results
+ for i, obj in enumerate(sorted(diagram.objects, key=lambda x: x.title)):
+ self.printer.emit_node(i, **self.get_values(obj))
+ obj.fig_id = i
+ # inheritance links
+ for rel in diagram.get_relationships("specialization"):
+ self.printer.emit_edge(
+ rel.from_object.fig_id, rel.to_object.fig_id, **self.inh_edges
+ )
+ # implementation links
+ for rel in diagram.get_relationships("implements"):
+ self.printer.emit_edge(
+ rel.from_object.fig_id, rel.to_object.fig_id, **self.imp_edges
+ )
+ # generate associations
+ for rel in diagram.get_relationships("association"):
+ self.printer.emit_edge(
+ rel.from_object.fig_id,
+ rel.to_object.fig_id,
+ label=rel.name,
+ **self.association_edges,
+ )
+
+ def set_printer(self, file_name, basename):
+ """set printer"""
+ raise NotImplementedError
+
+ def get_title(self, obj):
+ """get project title"""
+ raise NotImplementedError
+
+ def get_values(self, obj):
+ """get label and shape for classes."""
+ raise NotImplementedError
+
+ def close_graph(self):
+ """finalize the graph"""
+ raise NotImplementedError
+
+
+class DotWriter(DiagramWriter):
+ """write dot graphs from a diagram definition and a project"""
+
+ def __init__(self, config):
+ styles = [
+ dict(arrowtail="none", arrowhead="open"),
+ dict(arrowtail="none", arrowhead="empty"),
+ dict(arrowtail="node", arrowhead="empty", style="dashed"),
+ dict(
+ fontcolor="green", arrowtail="none", arrowhead="diamond", style="solid"
+ ),
+ ]
+ DiagramWriter.__init__(self, config, styles)
+
+ def set_printer(self, file_name, basename):
+ """initialize DotWriter and add options for layout."""
+ layout = dict(rankdir="BT")
+ self.printer = DotBackend(basename, additional_param=layout)
+ self.file_name = file_name
+
+ def get_title(self, obj):
+ """get project title"""
+ return obj.title
+
+ def get_values(self, obj):
+ """get label and shape for classes.
+
+ The label contains all attributes and methods
+ """
+ label = obj.title
+ if obj.shape == "interface":
+ label = "«interface»\\n%s" % label
+ if not self.config.only_classnames:
+ label = r"{}|{}\l|".format(label, r"\l".join(obj.attrs))
+ for func in obj.methods:
+ if func.args.args:
+ args = [arg.name for arg in func.args.args if arg.name != "self"]
+ else:
+ args = []
+ label = r"{}{}({})\l".format(label, func.name, ", ".join(args))
+ label = "{%s}" % label
+ if is_exception(obj.node):
+ return dict(fontcolor="red", label=label, shape="record")
+ return dict(label=label, shape="record")
+
+ def close_graph(self):
+ """print the dot graph into <file_name>"""
+ self.printer.generate(self.file_name)
+
+
+class VCGWriter(DiagramWriter):
+ """write vcg graphs from a diagram definition and a project"""
+
+ def __init__(self, config):
+ styles = [
+ dict(arrowstyle="solid", backarrowstyle="none", backarrowsize=0),
+ dict(arrowstyle="solid", backarrowstyle="none", backarrowsize=10),
+ dict(
+ arrowstyle="solid",
+ backarrowstyle="none",
+ linestyle="dotted",
+ backarrowsize=10,
+ ),
+ dict(arrowstyle="solid", backarrowstyle="none", textcolor="green"),
+ ]
+ DiagramWriter.__init__(self, config, styles)
+
+ def set_printer(self, file_name, basename):
+ """initialize VCGWriter for a UML graph"""
+ self.graph_file = open(file_name, "w+") # pylint: disable=consider-using-with
+ self.printer = VCGPrinter(self.graph_file)
+ self.printer.open_graph(
+ title=basename,
+ layoutalgorithm="dfs",
+ late_edge_labels="yes",
+ port_sharing="no",
+ manhattan_edges="yes",
+ )
+ self.printer.emit_node = self.printer.node
+ self.printer.emit_edge = self.printer.edge
+
+ def get_title(self, obj):
+ """get project title in vcg format"""
+ return r"\fb%s\fn" % obj.title
+
+ def get_values(self, obj):
+ """get label and shape for classes.
+
+ The label contains all attributes and methods
+ """
+ if is_exception(obj.node):
+ label = r"\fb\f09%s\fn" % obj.title
+ else:
+ label = r"\fb%s\fn" % obj.title
+ if obj.shape == "interface":
+ shape = "ellipse"
+ else:
+ shape = "box"
+ if not self.config.only_classnames:
+ attrs = obj.attrs
+ methods = [func.name for func in obj.methods]
+ # box width for UML like diagram
+ maxlen = max(len(name) for name in [obj.title] + methods + attrs)
+ line = "_" * (maxlen + 2)
+ label = fr"{label}\n\f{line}"
+ for attr in attrs:
+ label = fr"{label}\n\f08{attr}"
+ if attrs:
+ label = fr"{label}\n\f{line}"
+ for func in methods:
+ label = fr"{label}\n\f10{func}()"
+ return dict(label=label, shape=shape)
+
+ def close_graph(self):
+ """close graph and file"""
+ self.printer.close_graph()
+ self.graph_file.close()
diff --git a/pylint/reporters/__init__.py b/pylint/reporters/__init__.py
new file mode 100644
index 0000000..3c60dfd
--- /dev/null
+++ b/pylint/reporters/__init__.py
@@ -0,0 +1,45 @@
+# Copyright (c) 2006, 2010, 2012-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Ricardo Gemignani <ricardo.gemignani@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Simu Toni <simutoni@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2017 Kári Tristan Helgason <kthelgason@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 ruro <ruro.ruro@ya.ru>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""utilities methods and classes for reporters"""
+
+
+from pylint import utils
+from pylint.reporters.base_reporter import BaseReporter
+from pylint.reporters.collecting_reporter import CollectingReporter
+from pylint.reporters.json_reporter import JSONReporter
+from pylint.reporters.multi_reporter import MultiReporter
+from pylint.reporters.reports_handler_mix_in import ReportsHandlerMixIn
+
+
+def initialize(linter):
+ """initialize linter with reporters in this package"""
+ utils.register_plugins(linter, __path__[0])
+
+
+__all__ = [
+ "BaseReporter",
+ "ReportsHandlerMixIn",
+ "JSONReporter",
+ "CollectingReporter",
+ "MultiReporter",
+]
diff --git a/pylint/reporters/base_reporter.py b/pylint/reporters/base_reporter.py
new file mode 100644
index 0000000..858073a
--- /dev/null
+++ b/pylint/reporters/base_reporter.py
@@ -0,0 +1,69 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import os
+import sys
+from typing import List
+
+from pylint.message import Message
+
+
+class BaseReporter:
+ """base class for reporters
+
+ symbols: show short symbolic names for messages.
+ """
+
+ extension = ""
+
+ def __init__(self, output=None):
+ self.linter = None
+ self.section = 0
+ self.out = None
+ self.out_encoding = None
+ self.set_output(output)
+ self.messages: List[Message] = []
+ # Build the path prefix to strip to get relative paths
+ self.path_strip_prefix = os.getcwd() + os.sep
+
+ def handle_message(self, msg: Message) -> None:
+ """Handle a new message triggered on the current file."""
+ self.messages.append(msg)
+
+ def set_output(self, output=None):
+ """set output stream"""
+ self.out = output or sys.stdout
+
+ def writeln(self, string=""):
+ """write a line in the output buffer"""
+ print(string, file=self.out)
+
+ def display_reports(self, layout):
+ """display results encapsulated in the layout tree"""
+ self.section = 0
+ if hasattr(layout, "report_id"):
+ layout.children[0].children[0].data += " (%s)" % layout.report_id
+ self._display(layout)
+
+ def _display(self, layout):
+ """display the layout"""
+ raise NotImplementedError()
+
+ def display_messages(self, layout):
+ """Hook for displaying the messages of the reporter
+
+ This will be called whenever the underlying messages
+ needs to be displayed. For some reporters, it probably
+ doesn't make sense to display messages as soon as they
+ are available, so some mechanism of storing them could be used.
+ This method can be implemented to display them after they've
+ been aggregated.
+ """
+
+ # Event callbacks
+
+ def on_set_current_module(self, module, filepath):
+ """Hook called when a module starts to be analysed."""
+
+ def on_close(self, stats, previous_stats):
+ """Hook called when a module finished analyzing."""
diff --git a/pylint/reporters/collecting_reporter.py b/pylint/reporters/collecting_reporter.py
new file mode 100644
index 0000000..814c4c7
--- /dev/null
+++ b/pylint/reporters/collecting_reporter.py
@@ -0,0 +1,18 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+from pylint.reporters.base_reporter import BaseReporter
+
+
+class CollectingReporter(BaseReporter):
+ """collects messages"""
+
+ name = "collector"
+
+ def __init__(self):
+ BaseReporter.__init__(self)
+ self.messages = []
+
+ def reset(self):
+ self.messages = []
+
+ _display = None
diff --git a/pylint/reporters/json_reporter.py b/pylint/reporters/json_reporter.py
new file mode 100644
index 0000000..7befaf2
--- /dev/null
+++ b/pylint/reporters/json_reporter.py
@@ -0,0 +1,54 @@
+# Copyright (c) 2014 Vlad Temian <vladtemian@gmail.com>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2017 guillaume2 <guillaume.peillex@gmail.col>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Clément Pit-Claudel <cpitclaudel@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""JSON reporter"""
+import json
+
+from pylint.interfaces import IReporter
+from pylint.reporters.base_reporter import BaseReporter
+
+
+class JSONReporter(BaseReporter):
+ """Report messages and layouts in JSON."""
+
+ __implements__ = IReporter
+ name = "json"
+ extension = "json"
+
+ def display_messages(self, layout):
+ """Launch layouts display"""
+ json_dumpable = [
+ {
+ "type": msg.category,
+ "module": msg.module,
+ "obj": msg.obj,
+ "line": msg.line,
+ "column": msg.column,
+ "path": msg.path,
+ "symbol": msg.symbol,
+ "message": msg.msg or "",
+ "message-id": msg.msg_id,
+ }
+ for msg in self.messages
+ ]
+ print(json.dumps(json_dumpable, indent=4), file=self.out)
+
+ def display_reports(self, layout):
+ """Don't do anything in this reporter."""
+
+ def _display(self, layout):
+ """Do nothing."""
+
+
+def register(linter):
+ """Register the reporter classes with the linter."""
+ linter.register_reporter(JSONReporter)
diff --git a/pylint/reporters/multi_reporter.py b/pylint/reporters/multi_reporter.py
new file mode 100644
index 0000000..506b9c3
--- /dev/null
+++ b/pylint/reporters/multi_reporter.py
@@ -0,0 +1,103 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+import os
+from typing import IO, Any, AnyStr, Callable, List, Mapping, Optional, Union
+
+from pylint.interfaces import IReporter
+from pylint.message import Message
+from pylint.reporters.base_reporter import BaseReporter
+from pylint.reporters.ureports.nodes import BaseLayout
+
+AnyFile = IO[AnyStr]
+AnyPath = Union[str, bytes, os.PathLike]
+PyLinter = Any
+
+
+class MultiReporter:
+ """Reports messages and layouts in plain text"""
+
+ __implements__ = IReporter
+ name = "_internal_multi_reporter"
+ # Note: do not register this reporter with linter.register_reporter as it is
+ # not intended to be used directly like a regular reporter, but is
+ # instead used to implement the
+ # `--output-format=json:somefile.json,colorized`
+ # multiple output formats feature
+
+ extension = ""
+
+ def __init__(
+ self,
+ sub_reporters: List[BaseReporter],
+ close_output_files: Callable[[], None],
+ output: Optional[AnyFile] = None,
+ ):
+ self._sub_reporters = sub_reporters
+ self.close_output_files = close_output_files
+
+ self._path_strip_prefix = os.getcwd() + os.sep
+ self._linter: Optional[PyLinter] = None
+
+ self.set_output(output)
+
+ def __del__(self):
+ self.close_output_files()
+
+ @property
+ def path_strip_prefix(self) -> str:
+ return self._path_strip_prefix
+
+ @property
+ def linter(self) -> Optional[PyLinter]:
+ return self._linter
+
+ @linter.setter
+ def linter(self, value: PyLinter) -> None:
+ self._linter = value
+ for rep in self._sub_reporters:
+ rep.linter = value
+
+ def handle_message(self, msg: Message) -> None:
+ """Handle a new message triggered on the current file."""
+ for rep in self._sub_reporters:
+ rep.handle_message(msg)
+
+ # pylint: disable=no-self-use
+ def set_output(self, output: Optional[AnyFile] = None) -> None:
+ """set output stream"""
+ # MultiReporter doesn't have it's own output. This method is only
+ # provided for API parity with BaseReporter and should not be called
+ # with non-None values for 'output'.
+ if output is not None:
+ raise NotImplementedError("MultiReporter does not support direct output.")
+
+ def writeln(self, string: str = "") -> None:
+ """write a line in the output buffer"""
+ for rep in self._sub_reporters:
+ rep.writeln(string)
+
+ def display_reports(self, layout: BaseLayout) -> None:
+ """display results encapsulated in the layout tree"""
+ for rep in self._sub_reporters:
+ rep.display_reports(layout)
+
+ def display_messages(self, layout: BaseLayout) -> None:
+ """hook for displaying the messages of the reporter"""
+ for rep in self._sub_reporters:
+ rep.display_messages(layout)
+
+ def on_set_current_module(self, module: str, filepath: Optional[AnyPath]) -> None:
+ """hook called when a module starts to be analysed"""
+ for rep in self._sub_reporters:
+ rep.on_set_current_module(module, filepath)
+
+ def on_close(
+ self,
+ stats: Mapping[Any, Any],
+ previous_stats: Mapping[Any, Any],
+ ) -> None:
+ """hook called when a module finished analyzing"""
+ for rep in self._sub_reporters:
+ rep.on_close(stats, previous_stats)
diff --git a/pylint/reporters/reports_handler_mix_in.py b/pylint/reporters/reports_handler_mix_in.py
new file mode 100644
index 0000000..2d7cc8b
--- /dev/null
+++ b/pylint/reporters/reports_handler_mix_in.py
@@ -0,0 +1,77 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+
+from pylint.exceptions import EmptyReportError
+from pylint.reporters.ureports.nodes import Section
+
+
+class ReportsHandlerMixIn:
+ """a mix-in class containing all the reports and stats manipulation
+ related methods for the main lint class
+ """
+
+ def __init__(self):
+ self._reports = collections.defaultdict(list)
+ self._reports_state = {}
+
+ def report_order(self):
+ """Return a list of reports, sorted in the order
+ in which they must be called.
+ """
+ return list(self._reports)
+
+ def register_report(self, reportid, r_title, r_cb, checker):
+ """register a report
+
+ reportid is the unique identifier for the report
+ r_title the report's title
+ r_cb the method to call to make the report
+ checker is the checker defining the report
+ """
+ reportid = reportid.upper()
+ self._reports[checker].append((reportid, r_title, r_cb))
+
+ def enable_report(self, reportid):
+ """disable the report of the given id"""
+ reportid = reportid.upper()
+ self._reports_state[reportid] = True
+
+ def disable_report(self, reportid):
+ """disable the report of the given id"""
+ reportid = reportid.upper()
+ self._reports_state[reportid] = False
+
+ def report_is_enabled(self, reportid):
+ """return true if the report associated to the given identifier is
+ enabled
+ """
+ return self._reports_state.get(reportid, True)
+
+ def make_reports(self, stats, old_stats):
+ """render registered reports"""
+ sect = Section("Report", "%s statements analysed." % (self.stats["statement"]))
+ for checker in self.report_order():
+ for reportid, r_title, r_cb in self._reports[checker]:
+ if not self.report_is_enabled(reportid):
+ continue
+ report_sect = Section(r_title)
+ try:
+ r_cb(report_sect, stats, old_stats)
+ except EmptyReportError:
+ continue
+ report_sect.report_id = reportid
+ sect.append(report_sect)
+ return sect
+
+ def add_stats(self, **kwargs):
+ """add some stats entries to the statistic dictionary
+ raise an AssertionError if there is a key conflict
+ """
+ for key, value in kwargs.items():
+ if key[-1] == "_":
+ key = key[:-1]
+ assert key not in self.stats
+ self.stats[key] = value
+ return self.stats
diff --git a/pylint/reporters/text.py b/pylint/reporters/text.py
new file mode 100644
index 0000000..66e8de9
--- /dev/null
+++ b/pylint/reporters/text.py
@@ -0,0 +1,251 @@
+# Copyright (c) 2006-2007, 2010-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 y2kbugger <y2kbugger@users.noreply.github.com>
+# Copyright (c) 2018-2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Jace Browning <jacebrowning@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Plain text reporters:
+
+:text: the default one grouping messages by module
+:colorized: an ANSI colorized text reporter
+"""
+import os
+import sys
+import warnings
+
+from pylint import utils
+from pylint.interfaces import IReporter
+from pylint.message import Message
+from pylint.reporters import BaseReporter
+from pylint.reporters.ureports.text_writer import TextWriter
+
+TITLE_UNDERLINES = ["", "=", "-", "."]
+
+ANSI_PREFIX = "\033["
+ANSI_END = "m"
+ANSI_RESET = "\033[0m"
+ANSI_STYLES = {
+ "reset": "0",
+ "bold": "1",
+ "italic": "3",
+ "underline": "4",
+ "blink": "5",
+ "inverse": "7",
+ "strike": "9",
+}
+ANSI_COLORS = {
+ "reset": "0",
+ "black": "30",
+ "red": "31",
+ "green": "32",
+ "yellow": "33",
+ "blue": "34",
+ "magenta": "35",
+ "cyan": "36",
+ "white": "37",
+}
+
+
+def _get_ansi_code(color=None, style=None):
+ """return ansi escape code corresponding to color and style
+
+ :type color: str or None
+ :param color:
+ the color name (see `ANSI_COLORS` for available values)
+ or the color number when 256 colors are available
+
+ :type style: str or None
+ :param style:
+ style string (see `ANSI_COLORS` for available values). To get
+ several style effects at the same time, use a coma as separator.
+
+ :raise KeyError: if an unexistent color or style identifier is given
+
+ :rtype: str
+ :return: the built escape code
+ """
+ ansi_code = []
+ if style:
+ style_attrs = utils._splitstrip(style)
+ for effect in style_attrs:
+ ansi_code.append(ANSI_STYLES[effect])
+ if color:
+ if color.isdigit():
+ ansi_code.extend(["38", "5"])
+ ansi_code.append(color)
+ else:
+ ansi_code.append(ANSI_COLORS[color])
+ if ansi_code:
+ return ANSI_PREFIX + ";".join(ansi_code) + ANSI_END
+ return ""
+
+
+def colorize_ansi(msg, color=None, style=None):
+ """colorize message by wrapping it with ansi escape codes
+
+ :type msg: str or unicode
+ :param msg: the message string to colorize
+
+ :type color: str or None
+ :param color:
+ the color identifier (see `ANSI_COLORS` for available values)
+
+ :type style: str or None
+ :param style:
+ style string (see `ANSI_COLORS` for available values). To get
+ several style effects at the same time, use a coma as separator.
+
+ :raise KeyError: if an unexistent color or style identifier is given
+
+ :rtype: str or unicode
+ :return: the ansi escaped string
+ """
+ # If both color and style are not defined, then leave the text as is
+ if color is None and style is None:
+ return msg
+ escape_code = _get_ansi_code(color, style)
+ # If invalid (or unknown) color, don't wrap msg with ansi codes
+ if escape_code:
+ return f"{escape_code}{msg}{ANSI_RESET}"
+ return msg
+
+
+class TextReporter(BaseReporter):
+ """Reports messages and layouts in plain text"""
+
+ __implements__ = IReporter
+ name = "text"
+ extension = "txt"
+ line_format = "{path}:{line}:{column}: {msg_id}: {msg} ({symbol})"
+
+ def __init__(self, output=None):
+ BaseReporter.__init__(self, output)
+ self._modules = set()
+ self._template = self.line_format
+
+ def on_set_current_module(self, module, filepath):
+ self._template = str(self.linter.config.msg_template or self._template)
+
+ def write_message(self, msg):
+ """Convenience method to write a formatted message with class default template"""
+ self.writeln(msg.format(self._template))
+
+ def handle_message(self, msg: Message) -> None:
+ """manage message of different type and in the context of path"""
+ if msg.module not in self._modules:
+ if msg.module:
+ self.writeln("************* Module %s" % msg.module)
+ self._modules.add(msg.module)
+ else:
+ self.writeln("************* ")
+ self.write_message(msg)
+
+ def _display(self, layout):
+ """launch layouts display"""
+ print(file=self.out)
+ TextWriter().format(layout, self.out)
+
+
+class ParseableTextReporter(TextReporter):
+ """a reporter very similar to TextReporter, but display messages in a form
+ recognized by most text editors :
+
+ <filename>:<linenum>:<msg>
+ """
+
+ name = "parseable"
+ line_format = "{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}"
+
+ def __init__(self, output=None):
+ warnings.warn(
+ "%s output format is deprecated. This is equivalent "
+ "to --msg-template=%s" % (self.name, self.line_format),
+ DeprecationWarning,
+ )
+ TextReporter.__init__(self, output)
+
+
+class VSTextReporter(ParseableTextReporter):
+ """Visual studio text reporter"""
+
+ name = "msvs"
+ line_format = "{path}({line}): [{msg_id}({symbol}){obj}] {msg}"
+
+
+class ColorizedTextReporter(TextReporter):
+ """Simple TextReporter that colorizes text output"""
+
+ name = "colorized"
+ COLOR_MAPPING = {
+ "I": ("green", None),
+ "C": (None, "bold"),
+ "R": ("magenta", "bold, italic"),
+ "W": ("magenta", None),
+ "E": ("red", "bold"),
+ "F": ("red", "bold, underline"),
+ "S": ("yellow", "inverse"), # S stands for module Separator
+ }
+
+ def __init__(self, output=None, color_mapping=None):
+ TextReporter.__init__(self, output)
+ self.color_mapping = color_mapping or dict(ColorizedTextReporter.COLOR_MAPPING)
+ ansi_terms = ["xterm-16color", "xterm-256color"]
+ if os.environ.get("TERM") not in ansi_terms:
+ if sys.platform == "win32":
+ # pylint: disable=import-error,import-outside-toplevel
+ import colorama
+
+ self.out = colorama.AnsiToWin32(self.out)
+
+ def _get_decoration(self, msg_id):
+ """Returns the tuple color, style associated with msg_id as defined
+ in self.color_mapping
+ """
+ try:
+ return self.color_mapping[msg_id[0]]
+ except KeyError:
+ return None, None
+
+ def handle_message(self, msg: Message) -> None:
+ """manage message of different types, and colorize output
+ using ansi escape codes
+ """
+ if msg.module not in self._modules:
+ color, style = self._get_decoration("S")
+ if msg.module:
+ modsep = colorize_ansi(
+ "************* Module %s" % msg.module, color, style
+ )
+ else:
+ modsep = colorize_ansi("************* %s" % msg.module, color, style)
+ self.writeln(modsep)
+ self._modules.add(msg.module)
+ color, style = self._get_decoration(msg.C)
+
+ msg = msg._replace(
+ **{
+ attr: colorize_ansi(getattr(msg, attr), color, style)
+ for attr in ("msg", "symbol", "category", "C")
+ }
+ )
+ self.write_message(msg)
+
+
+def register(linter):
+ """Register the reporter classes with the linter."""
+ linter.register_reporter(TextReporter)
+ linter.register_reporter(ParseableTextReporter)
+ linter.register_reporter(VSTextReporter)
+ linter.register_reporter(ColorizedTextReporter)
diff --git a/pylint/reporters/ureports/__init__.py b/pylint/reporters/ureports/__init__.py
new file mode 100644
index 0000000..53a3a37
--- /dev/null
+++ b/pylint/reporters/ureports/__init__.py
@@ -0,0 +1,98 @@
+# Copyright (c) 2015-2016, 2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Universal report objects and some formatting drivers.
+
+A way to create simple reports using python objects, primarily designed to be
+formatted as text and html.
+"""
+import os
+import sys
+from io import StringIO
+
+
+class BaseWriter:
+ """base class for ureport writers"""
+
+ def format(self, layout, stream=None, encoding=None):
+ """format and write the given layout into the stream object
+
+ unicode policy: unicode strings may be found in the layout;
+ try to call stream.write with it, but give it back encoded using
+ the given encoding if it fails
+ """
+ if stream is None:
+ stream = sys.stdout
+ if not encoding:
+ encoding = getattr(stream, "encoding", "UTF-8")
+ self.encoding = encoding or "UTF-8"
+ self.out = stream
+ self.begin_format()
+ layout.accept(self)
+ self.end_format()
+
+ def format_children(self, layout):
+ """recurse on the layout children and call their accept method
+ (see the Visitor pattern)
+ """
+ for child in getattr(layout, "children", ()):
+ child.accept(self)
+
+ def writeln(self, string=""):
+ """write a line in the output buffer"""
+ self.write(string + os.linesep)
+
+ def write(self, string):
+ """write a string in the output buffer"""
+ self.out.write(string)
+
+ def begin_format(self):
+ """begin to format a layout"""
+ self.section = 0
+
+ def end_format(self):
+ """finished to format a layout"""
+
+ def get_table_content(self, table):
+ """trick to get table content without actually writing it
+
+ return an aligned list of lists containing table cells values as string
+ """
+ result = [[]]
+ cols = table.cols
+ for cell in self.compute_content(table):
+ if cols == 0:
+ result.append([])
+ cols = table.cols
+ cols -= 1
+ result[-1].append(cell)
+ # fill missing cells
+ while len(result[-1]) < cols:
+ result[-1].append("")
+ return result
+
+ def compute_content(self, layout):
+ """trick to compute the formatting of children layout before actually
+ writing it
+
+ return an iterator on strings (one for each child element)
+ """
+ # Patch the underlying output stream with a fresh-generated stream,
+ # which is used to store a temporary representation of a child
+ # node.
+ out = self.out
+ try:
+ for child in layout.children:
+ stream = StringIO()
+ self.out = stream
+ child.accept(self)
+ yield stream.getvalue()
+ finally:
+ self.out = out
diff --git a/pylint/reporters/ureports/nodes.py b/pylint/reporters/ureports/nodes.py
new file mode 100644
index 0000000..dbc34d4
--- /dev/null
+++ b/pylint/reporters/ureports/nodes.py
@@ -0,0 +1,191 @@
+# Copyright (c) 2015-2016, 2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Micro reports objects.
+
+A micro report is a tree of layout and content objects.
+"""
+
+
+class VNode:
+ def __init__(self, nid=None):
+ self.id = nid
+ # navigation
+ self.parent = None
+ self.children = []
+
+ def __iter__(self):
+ return iter(self.children)
+
+ def append(self, child):
+ """add a node to children"""
+ self.children.append(child)
+ child.parent = self
+
+ def insert(self, index, child):
+ """insert a child node"""
+ self.children.insert(index, child)
+ child.parent = self
+
+ def _get_visit_name(self):
+ """
+ return the visit name for the mixed class. When calling 'accept', the
+ method <'visit_' + name returned by this method> will be called on the
+ visitor
+ """
+ try:
+ # pylint: disable=no-member
+ return self.TYPE.replace("-", "_")
+ # pylint: disable=broad-except
+ except Exception:
+ return self.__class__.__name__.lower()
+
+ def accept(self, visitor, *args, **kwargs):
+ func = getattr(visitor, "visit_%s" % self._get_visit_name())
+ return func(self, *args, **kwargs)
+
+ def leave(self, visitor, *args, **kwargs):
+ func = getattr(visitor, "leave_%s" % self._get_visit_name())
+ return func(self, *args, **kwargs)
+
+
+class BaseLayout(VNode):
+ """base container node
+
+ attributes
+ * children : components in this table (i.e. the table's cells)
+ """
+
+ def __init__(self, children=(), **kwargs):
+ super().__init__(**kwargs)
+ for child in children:
+ if isinstance(child, VNode):
+ self.append(child)
+ else:
+ self.add_text(child)
+
+ def append(self, child):
+ """overridden to detect problems easily"""
+ assert child not in self.parents()
+ VNode.append(self, child)
+
+ def parents(self):
+ """return the ancestor nodes"""
+ assert self.parent is not self
+ if self.parent is None:
+ return []
+ return [self.parent] + self.parent.parents()
+
+ def add_text(self, text):
+ """shortcut to add text data"""
+ self.children.append(Text(text))
+
+
+# non container nodes #########################################################
+
+
+class Text(VNode):
+ """a text portion
+
+ attributes :
+ * data : the text value as an encoded or unicode string
+ """
+
+ def __init__(self, data, escaped=True, **kwargs):
+ super().__init__(**kwargs)
+ # if isinstance(data, unicode):
+ # data = data.encode('ascii')
+ assert isinstance(data, str), data.__class__
+ self.escaped = escaped
+ self.data = data
+
+
+class VerbatimText(Text):
+ """a verbatim text, display the raw data
+
+ attributes :
+ * data : the text value as an encoded or unicode string
+ """
+
+
+# container nodes #############################################################
+
+
+class Section(BaseLayout):
+ """a section
+
+ attributes :
+ * BaseLayout attributes
+
+ a title may also be given to the constructor, it'll be added
+ as a first element
+ a description may also be given to the constructor, it'll be added
+ as a first paragraph
+ """
+
+ def __init__(self, title=None, description=None, **kwargs):
+ super().__init__(**kwargs)
+ if description:
+ self.insert(0, Paragraph([Text(description)]))
+ if title:
+ self.insert(0, Title(children=(title,)))
+
+
+class EvaluationSection(Section):
+ def __init__(self, message, **kwargs):
+ super().__init__(**kwargs)
+ title = Paragraph()
+ title.append(Text("-" * len(message)))
+ self.append(title)
+
+ message_body = Paragraph()
+ message_body.append(Text(message))
+ self.append(message_body)
+
+
+class Title(BaseLayout):
+ """a title
+
+ attributes :
+ * BaseLayout attributes
+
+ A title must not contains a section nor a paragraph!
+ """
+
+
+class Paragraph(BaseLayout):
+ """a simple text paragraph
+
+ attributes :
+ * BaseLayout attributes
+
+ A paragraph must not contains a section !
+ """
+
+
+class Table(BaseLayout):
+ """some tabular data
+
+ attributes :
+ * BaseLayout attributes
+ * cols : the number of columns of the table (REQUIRED)
+ * rheaders : the first row's elements are table's header
+ * cheaders : the first col's elements are table's header
+ * title : the table's optional title
+ """
+
+ def __init__(self, cols, title=None, rheaders=0, cheaders=0, **kwargs):
+ super().__init__(**kwargs)
+ assert isinstance(cols, int)
+ self.cols = cols
+ self.title = title
+ self.rheaders = rheaders
+ self.cheaders = cheaders
diff --git a/pylint/reporters/ureports/text_writer.py b/pylint/reporters/ureports/text_writer.py
new file mode 100644
index 0000000..e9ee80a
--- /dev/null
+++ b/pylint/reporters/ureports/text_writer.py
@@ -0,0 +1,96 @@
+# Copyright (c) 2015-2016, 2018-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 bot <bot@noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Text formatting drivers for ureports"""
+
+from pylint.reporters.ureports import BaseWriter
+
+TITLE_UNDERLINES = ["", "=", "-", "`", ".", "~", "^"]
+BULLETS = ["*", "-"]
+
+
+class TextWriter(BaseWriter):
+ """format layouts as text
+ (ReStructured inspiration but not totally handled yet)
+ """
+
+ def begin_format(self):
+ super().begin_format()
+ self.list_level = 0
+
+ def visit_section(self, layout):
+ """display a section as text"""
+ self.section += 1
+ self.writeln()
+ self.format_children(layout)
+ self.section -= 1
+ self.writeln()
+
+ def visit_evaluationsection(self, layout):
+ """Display an evaluation section as a text."""
+ self.section += 1
+ self.format_children(layout)
+ self.section -= 1
+ self.writeln()
+
+ def visit_title(self, layout):
+ title = "".join(list(self.compute_content(layout)))
+ self.writeln(title)
+ try:
+ self.writeln(TITLE_UNDERLINES[self.section] * len(title))
+ except IndexError:
+ print("FIXME TITLE TOO DEEP. TURNING TITLE INTO TEXT")
+
+ def visit_paragraph(self, layout):
+ """enter a paragraph"""
+ self.format_children(layout)
+ self.writeln()
+
+ def visit_table(self, layout):
+ """display a table as text"""
+ table_content = self.get_table_content(layout)
+ # get columns width
+ cols_width = [0] * len(table_content[0])
+ for row in table_content:
+ for index, col in enumerate(row):
+ cols_width[index] = max(cols_width[index], len(col))
+ self.default_table(layout, table_content, cols_width)
+ self.writeln()
+
+ def default_table(self, layout, table_content, cols_width):
+ """format a table"""
+ cols_width = [size + 1 for size in cols_width]
+ format_strings = " ".join(["%%-%ss"] * len(cols_width))
+ format_strings = format_strings % tuple(cols_width)
+ format_strings = format_strings.split(" ")
+ table_linesep = "\n+" + "+".join("-" * w for w in cols_width) + "+\n"
+ headsep = "\n+" + "+".join("=" * w for w in cols_width) + "+\n"
+
+ self.write(table_linesep)
+ for index, line in enumerate(table_content):
+ self.write("|")
+ for line_index, at_index in enumerate(line):
+ self.write(format_strings[line_index] % at_index)
+ self.write("|")
+ if index == 0 and layout.rheaders:
+ self.write(headsep)
+ else:
+ self.write(table_linesep)
+
+ def visit_verbatimtext(self, layout):
+ """display a verbatim layout as text (so difficult ;)"""
+ self.writeln("::\n")
+ for line in layout.data.splitlines():
+ self.writeln(" " + line)
+ self.writeln()
+
+ def visit_text(self, layout):
+ """add some text"""
+ self.write("%s" % layout.data)
diff --git a/pylint/testutils/__init__.py b/pylint/testutils/__init__.py
new file mode 100644
index 0000000..52bfcf2
--- /dev/null
+++ b/pylint/testutils/__init__.py
@@ -0,0 +1,57 @@
+# Copyright (c) 2012-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2013 buck@yelp.com <buck@yelp.com>
+# Copyright (c) 2014 LCD 47 <lcd047@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Ricardo Gemignani <ricardo.gemignani@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Roy Williams <roy.williams.iii@gmail.com>
+# Copyright (c) 2016 xmo-odoo <xmo-odoo@users.noreply.github.com>
+# Copyright (c) 2017 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Mr. Senko <atodorov@mrsenko.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 谭九鼎 <109224573@qq.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Lefteris Karapetsas <lefteris@refu.co>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Functional/non regression tests for pylint"""
+
+__all__ = [
+ "_get_tests_info",
+ "_tokenize_str",
+ "CheckerTestCase",
+ "FunctionalTestFile",
+ "linter",
+ "LintModuleTest",
+ "Message",
+ "MinimalTestReporter",
+ "set_config",
+ "GenericTestReporter",
+ "UPDATE_FILE",
+ "UPDATE_OPTION",
+ "UnittestLinter",
+]
+
+from pylint.testutils.checker_test_case import CheckerTestCase
+from pylint.testutils.constants import UPDATE_FILE, UPDATE_OPTION
+from pylint.testutils.decorator import set_config
+from pylint.testutils.functional_test_file import FunctionalTestFile
+from pylint.testutils.get_test_info import _get_tests_info
+from pylint.testutils.global_test_linter import linter
+from pylint.testutils.lint_module_test import LintModuleTest
+from pylint.testutils.output_line import Message
+from pylint.testutils.reporter_for_tests import GenericTestReporter, MinimalTestReporter
+from pylint.testutils.tokenize_str import _tokenize_str
+from pylint.testutils.unittest_linter import UnittestLinter
diff --git a/pylint/testutils/checker_test_case.py b/pylint/testutils/checker_test_case.py
new file mode 100644
index 0000000..77fe6f2
--- /dev/null
+++ b/pylint/testutils/checker_test_case.py
@@ -0,0 +1,54 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import contextlib
+from typing import Dict, Optional, Type
+
+from pylint.testutils.global_test_linter import linter
+from pylint.testutils.unittest_linter import UnittestLinter
+from pylint.utils import ASTWalker
+
+
+class CheckerTestCase:
+ """A base testcase class for unit testing individual checker classes."""
+
+ CHECKER_CLASS: Optional[Type] = None
+ CONFIG: Dict = {}
+
+ def setup_method(self):
+ self.linter = UnittestLinter()
+ self.checker = self.CHECKER_CLASS(self.linter) # pylint: disable=not-callable
+ for key, value in self.CONFIG.items():
+ setattr(self.checker.config, key, value)
+ self.checker.open()
+
+ @contextlib.contextmanager
+ def assertNoMessages(self):
+ """Assert that no messages are added by the given method."""
+ with self.assertAddsMessages():
+ yield
+
+ @contextlib.contextmanager
+ def assertAddsMessages(self, *messages):
+ """Assert that exactly the given method adds the given messages.
+
+ The list of messages must exactly match *all* the messages added by the
+ method. Additionally, we check to see whether the args in each message can
+ actually be substituted into the message string.
+ """
+ yield
+ got = self.linter.release_messages()
+ no_msg = "No message."
+ expected = "\n".join(repr(m) for m in messages) or no_msg
+ got_str = "\n".join(repr(m) for m in got) or no_msg
+ msg = (
+ "Expected messages did not match actual.\n"
+ f"\nExpected:\n{expected}\n\nGot:\n{got_str}\n"
+ )
+ assert got == list(messages), msg
+
+ def walk(self, node):
+ """recursive walk on the given node"""
+ walker = ASTWalker(linter)
+ walker.add_checker(self.checker)
+ walker.walk(node)
diff --git a/pylint/testutils/constants.py b/pylint/testutils/constants.py
new file mode 100644
index 0000000..e5a7c84
--- /dev/null
+++ b/pylint/testutils/constants.py
@@ -0,0 +1,28 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import operator
+import re
+import sys
+from os.path import abspath, dirname
+from pathlib import Path
+
+SYS_VERS_STR = "%d%d%d" % sys.version_info[:3]
+TITLE_UNDERLINES = ["", "=", "-", "."]
+PREFIX = abspath(dirname(__file__))
+UPDATE_OPTION = "--update-functional-output"
+UPDATE_FILE = Path("pylint-functional-test-update")
+# Common sub-expressions.
+_MESSAGE = {"msg": r"[a-z][a-z\-]+"}
+# Matches a #,
+# - followed by a comparison operator and a Python version (optional),
+# - followed by a line number with a +/- (optional),
+# - followed by a list of bracketed message symbols.
+# Used to extract expected messages from testdata files.
+_EXPECTED_RE = re.compile(
+ r"\s*#\s*(?:(?P<line>[+-]?[0-9]+):)?"
+ r"(?:(?P<op>[><=]+) *(?P<version>[0-9.]+):)?"
+ r"\s*\[(?P<msgs>%(msg)s(?:,\s*%(msg)s)*)]" % _MESSAGE
+)
+
+_OPERATORS = {">": operator.gt, "<": operator.lt, ">=": operator.ge, "<=": operator.le}
diff --git a/pylint/testutils/decorator.py b/pylint/testutils/decorator.py
new file mode 100644
index 0000000..52440ee
--- /dev/null
+++ b/pylint/testutils/decorator.py
@@ -0,0 +1,28 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import functools
+
+from pylint.testutils.checker_test_case import CheckerTestCase
+
+
+def set_config(**kwargs):
+ """Decorator for setting config values on a checker.
+
+ Passing the args and kwargs back to the test function itself
+ allows this decorator to be used on parametrized test cases.
+ """
+
+ def _wrapper(fun):
+ @functools.wraps(fun)
+ def _forward(self, *args, **test_function_kwargs):
+ for key, value in kwargs.items():
+ setattr(self.checker.config, key, value)
+ if isinstance(self, CheckerTestCase):
+ # reopen checker in case, it may be interested in configuration change
+ self.checker.open()
+ fun(self, *args, **test_function_kwargs)
+
+ return _forward
+
+ return _wrapper
diff --git a/pylint/testutils/functional_test_file.py b/pylint/testutils/functional_test_file.py
new file mode 100644
index 0000000..2923412
--- /dev/null
+++ b/pylint/testutils/functional_test_file.py
@@ -0,0 +1,73 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import configparser
+from os.path import basename, exists, join
+
+
+def parse_python_version(ver_str):
+ return tuple(int(digit) for digit in ver_str.split("."))
+
+
+class NoFileError(Exception):
+ pass
+
+
+class FunctionalTestFile:
+ """A single functional test case file with options."""
+
+ _CONVERTERS = {
+ "min_pyver": parse_python_version,
+ "max_pyver": parse_python_version,
+ "requires": lambda s: s.split(","),
+ }
+
+ def __init__(self, directory, filename):
+ self._directory = directory
+ self.base = filename.replace(".py", "")
+ self.options = {
+ "min_pyver": (2, 5),
+ "max_pyver": (4, 0),
+ "requires": [],
+ "except_implementations": [],
+ "exclude_platforms": [],
+ }
+ self._parse_options()
+
+ def __repr__(self):
+ return f"FunctionalTest:{self.base}"
+
+ def _parse_options(self):
+ cp = configparser.ConfigParser()
+ cp.add_section("testoptions")
+ try:
+ cp.read(self.option_file)
+ except NoFileError:
+ pass
+
+ for name, value in cp.items("testoptions"):
+ conv = self._CONVERTERS.get(name, lambda v: v)
+ self.options[name] = conv(value)
+
+ @property
+ def option_file(self):
+ return self._file_type(".rc")
+
+ @property
+ def module(self):
+ package = basename(self._directory)
+ return ".".join([package, self.base])
+
+ @property
+ def expected_output(self):
+ return self._file_type(".txt", check_exists=False)
+
+ @property
+ def source(self):
+ return self._file_type(".py")
+
+ def _file_type(self, ext, check_exists=True):
+ name = join(self._directory, self.base + ext)
+ if not check_exists or exists(name):
+ return name
+ raise NoFileError(f"Cannot find '{name}'.")
diff --git a/pylint/testutils/get_test_info.py b/pylint/testutils/get_test_info.py
new file mode 100644
index 0000000..73d7d3a
--- /dev/null
+++ b/pylint/testutils/get_test_info.py
@@ -0,0 +1,45 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+from glob import glob
+from os.path import basename, join, splitext
+
+from pylint.testutils.constants import SYS_VERS_STR
+
+
+def _get_tests_info(input_dir, msg_dir, prefix, suffix):
+ """get python input examples and output messages
+
+ We use following conventions for input files and messages:
+ for different inputs:
+ test for python >= x.y -> input = <name>_pyxy.py
+ test for python < x.y -> input = <name>_py_xy.py
+ for one input and different messages:
+ message for python >= x.y -> message = <name>_pyxy.txt
+ lower versions -> message with highest num
+ """
+ result = []
+ for fname in glob(join(input_dir, prefix + "*" + suffix)):
+ infile = basename(fname)
+ fbase = splitext(infile)[0]
+ # filter input files :
+ pyrestr = fbase.rsplit("_py", 1)[-1] # like _26 or 26
+ if pyrestr.isdigit(): # '24', '25'...
+ if pyrestr.isdigit() and int(SYS_VERS_STR) < int(pyrestr):
+ continue
+ if pyrestr.startswith("_") and pyrestr[1:].isdigit():
+ # skip test for higher python versions
+ if pyrestr[1:].isdigit() and int(SYS_VERS_STR) >= int(pyrestr[1:]):
+ continue
+ messages = glob(join(msg_dir, fbase + "*.txt"))
+ # the last one will be without ext, i.e. for all or upper versions:
+ if messages:
+ for outfile in sorted(messages, reverse=True):
+ py_rest = outfile.rsplit("_py", 1)[-1][:-4]
+ if py_rest.isdigit() and int(SYS_VERS_STR) >= int(py_rest):
+ break
+ else:
+ # This will provide an error message indicating the missing filename.
+ outfile = join(msg_dir, fbase + ".txt")
+ result.append((infile, outfile))
+ return result
diff --git a/pylint/testutils/global_test_linter.py b/pylint/testutils/global_test_linter.py
new file mode 100644
index 0000000..905210e
--- /dev/null
+++ b/pylint/testutils/global_test_linter.py
@@ -0,0 +1,20 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.testutils.reporter_for_tests import GenericTestReporter
+
+
+def create_test_linter():
+ test_reporter = GenericTestReporter()
+ linter_ = PyLinter()
+ linter_.set_reporter(test_reporter)
+ linter_.config.persistent = 0
+ checkers.initialize(linter_)
+ return linter_
+
+
+# Can't be renamed to a constant (easily), it breaks countless tests
+linter = create_test_linter()
diff --git a/pylint/testutils/lint_module_test.py b/pylint/testutils/lint_module_test.py
new file mode 100644
index 0000000..b04f2a0
--- /dev/null
+++ b/pylint/testutils/lint_module_test.py
@@ -0,0 +1,236 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import csv
+import operator
+import platform
+import sys
+from collections import Counter
+from io import StringIO
+from typing import Dict, List, Optional, Tuple
+
+import pytest
+from _pytest.config import Config
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.testutils.constants import _EXPECTED_RE, _OPERATORS, UPDATE_OPTION
+from pylint.testutils.functional_test_file import (
+ FunctionalTestFile,
+ NoFileError,
+ parse_python_version,
+)
+from pylint.testutils.output_line import OutputLine
+from pylint.testutils.reporter_for_tests import FunctionalTestReporter
+from pylint.utils import utils
+
+
+class LintModuleTest:
+ maxDiff = None
+
+ def __init__(self, test_file: FunctionalTestFile, config: Optional[Config] = None):
+ _test_reporter = FunctionalTestReporter()
+ self._linter = PyLinter()
+ self._linter.set_reporter(_test_reporter)
+ self._linter.config.persistent = 0
+ checkers.initialize(self._linter)
+ self._linter.disable("suppressed-message")
+ self._linter.disable("locally-disabled")
+ self._linter.disable("useless-suppression")
+ try:
+ self._linter.read_config_file(test_file.option_file)
+ if self._linter.cfgfile_parser.has_option("MASTER", "load-plugins"):
+ plugins = utils._splitstrip(
+ self._linter.cfgfile_parser.get("MASTER", "load-plugins")
+ )
+ self._linter.load_plugin_modules(plugins)
+ self._linter.load_config_file()
+ except NoFileError:
+ pass
+ self._test_file = test_file
+ self._config = config
+
+ def setUp(self):
+ if self._should_be_skipped_due_to_version():
+ pytest.skip(
+ "Test cannot run with Python %s."
+ % sys.version.split(" ", maxsplit=1)[0]
+ )
+ missing = []
+ for requirement in self._test_file.options["requires"]:
+ try:
+ __import__(requirement)
+ except ImportError:
+ missing.append(requirement)
+ if missing:
+ pytest.skip("Requires %s to be present." % ",".join(missing))
+ except_implementations = self._test_file.options["except_implementations"]
+ if except_implementations:
+ implementations = [i.strip() for i in except_implementations.split(",")]
+ if platform.python_implementation() in implementations:
+ msg = "Test cannot run with Python implementation %r"
+ pytest.skip(msg % platform.python_implementation())
+ excluded_platforms = self._test_file.options["exclude_platforms"]
+ if excluded_platforms:
+ platforms = [p.strip() for p in excluded_platforms.split(",")]
+ if sys.platform.lower() in platforms:
+ pytest.skip("Test cannot run on platform %r" % sys.platform)
+
+ def runTest(self):
+ self._runTest()
+
+ def _should_be_skipped_due_to_version(self):
+ return (
+ sys.version_info < self._test_file.options["min_pyver"]
+ or sys.version_info > self._test_file.options["max_pyver"]
+ )
+
+ def __str__(self):
+ return f"{self._test_file.base} ({self.__class__.__module__}.{self.__class__.__name__})"
+
+ @staticmethod
+ def get_expected_messages(stream):
+ """Parses a file and get expected messages.
+
+ :param stream: File-like input stream.
+ :type stream: enumerable
+ :returns: A dict mapping line,msg-symbol tuples to the count on this line.
+ :rtype: dict
+ """
+ messages = Counter()
+ for i, line in enumerate(stream):
+ match = _EXPECTED_RE.search(line)
+ if match is None:
+ continue
+ line = match.group("line")
+ if line is None:
+ line = i + 1
+ elif line.startswith("+") or line.startswith("-"):
+ line = i + 1 + int(line)
+ else:
+ line = int(line)
+
+ version = match.group("version")
+ op = match.group("op")
+ if version:
+ required = parse_python_version(version)
+ if not _OPERATORS[op](sys.version_info, required):
+ continue
+
+ for msg_id in match.group("msgs").split(","):
+ messages[line, msg_id.strip()] += 1
+ return messages
+
+ @staticmethod
+ def multiset_difference(
+ expected_entries: Counter, actual_entries: Counter
+ ) -> Tuple[Counter, Dict[str, int]]:
+ """Takes two multisets and compares them.
+
+ A multiset is a dict with the cardinality of the key as the value."""
+ missing = expected_entries.copy()
+ missing.subtract(actual_entries)
+ unexpected = {}
+ for key, value in list(missing.items()):
+ if value <= 0:
+ missing.pop(key)
+ if value < 0:
+ unexpected[key] = -value
+ return missing, unexpected
+
+ # pylint: disable=consider-using-with
+ def _open_expected_file(self):
+ try:
+ return open(self._test_file.expected_output)
+ except FileNotFoundError:
+ return StringIO("")
+
+ # pylint: disable=consider-using-with
+ def _open_source_file(self):
+ if self._test_file.base == "invalid_encoded_data":
+ return open(self._test_file.source)
+ if "latin1" in self._test_file.base:
+ return open(self._test_file.source, encoding="latin1")
+ return open(self._test_file.source, encoding="utf8")
+
+ def _get_expected(self):
+ with self._open_source_file() as f:
+ expected_msgs = self.get_expected_messages(f)
+ if not expected_msgs:
+ return Counter(), []
+ with self._open_expected_file() as f:
+ expected_output_lines = [
+ OutputLine.from_csv(row) for row in csv.reader(f, "test")
+ ]
+ return expected_msgs, expected_output_lines
+
+ def _get_actual(self):
+ messages = self._linter.reporter.messages
+ messages.sort(key=lambda m: (m.line, m.symbol, m.msg))
+ received_msgs = Counter()
+ received_output_lines = []
+ for msg in messages:
+ assert (
+ msg.symbol != "fatal"
+ ), f"Pylint analysis failed because of '{msg.msg}'"
+ received_msgs[msg.line, msg.symbol] += 1
+ received_output_lines.append(OutputLine.from_msg(msg))
+ return received_msgs, received_output_lines
+
+ def _runTest(self):
+ __tracebackhide__ = True # pylint: disable=unused-variable
+ modules_to_check = [self._test_file.source]
+ self._linter.check(modules_to_check)
+ expected_messages, expected_output = self._get_expected()
+ actual_messages, actual_output = self._get_actual()
+ assert (
+ expected_messages == actual_messages
+ ), self.error_msg_for_unequal_messages(
+ actual_messages, expected_messages, actual_output
+ )
+ self._check_output_text(expected_messages, expected_output, actual_output)
+
+ def error_msg_for_unequal_messages(
+ self, actual_messages, expected_messages, actual_output: List[OutputLine]
+ ):
+ msg = ['Wrong results for file "%s":' % (self._test_file.base)]
+ missing, unexpected = self.multiset_difference(
+ expected_messages, actual_messages
+ )
+ if missing:
+ msg.append("\nExpected in testdata:")
+ msg.extend(" %3d: %s" % msg for msg in sorted(missing))
+ if unexpected:
+ msg.append("\nUnexpected in testdata:")
+ msg.extend(" %3d: %s" % msg for msg in sorted(unexpected)) # type: ignore
+ error_msg = "\n".join(msg)
+ if self._config and self._config.getoption("verbose") > 0:
+ error_msg += "\n\nActual pylint output for this file:\n"
+ error_msg += "\n".join(str(o) for o in actual_output)
+ return error_msg
+
+ def error_msg_for_unequal_output(self, expected_lines, received_lines) -> str:
+ missing = set(expected_lines) - set(received_lines)
+ unexpected = set(received_lines) - set(expected_lines)
+ error_msg = (
+ f"Wrong output for '{self._test_file.base}.txt':\n"
+ "You can update the expected output automatically with: '"
+ f"python tests/test_functional.py {UPDATE_OPTION} -k "
+ f'"test_functional[{self._test_file.base}]"\'\n\n'
+ )
+ sort_by_line_number = operator.attrgetter("lineno")
+ if missing:
+ error_msg += "\n- Missing lines:\n"
+ for line in sorted(missing, key=sort_by_line_number):
+ error_msg += f"{line}\n"
+ if unexpected:
+ error_msg += "\n- Unexpected lines:\n"
+ for line in sorted(unexpected, key=sort_by_line_number):
+ error_msg += f"{line}\n"
+ return error_msg
+
+ def _check_output_text(self, _, expected_output, actual_output):
+ """This is a function because we want to be able to update the text in LintModuleOutputUpdate"""
+ assert expected_output == actual_output, self.error_msg_for_unequal_output(
+ expected_output, actual_output
+ )
diff --git a/pylint/testutils/output_line.py b/pylint/testutils/output_line.py
new file mode 100644
index 0000000..1150c6b
--- /dev/null
+++ b/pylint/testutils/output_line.py
@@ -0,0 +1,96 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+from typing import Any, NamedTuple
+
+from pylint import interfaces
+from pylint.constants import PY38_PLUS
+from pylint.testutils.constants import UPDATE_OPTION
+
+
+class Message(
+ collections.namedtuple("Message", ["msg_id", "line", "node", "args", "confidence"])
+):
+ def __new__(cls, msg_id, line=None, node=None, args=None, confidence=None):
+ return tuple.__new__(cls, (msg_id, line, node, args, confidence))
+
+ def __eq__(self, other):
+ if isinstance(other, Message):
+ if self.confidence and other.confidence:
+ return super().__eq__(other)
+ return self[:-1] == other[:-1]
+ return NotImplemented # pragma: no cover
+
+
+class MalformedOutputLineException(Exception):
+ def __init__(self, row, exception):
+ example = "msg-symbolic-name:42:27:MyClass.my_function:The message"
+ other_example = "msg-symbolic-name:7:42::The message"
+ expected = [
+ "symbol",
+ "line",
+ "column",
+ "MyClass.myFunction, (or '')",
+ "Message",
+ "confidence",
+ ]
+ reconstructed_row = ""
+ i = 0
+ try:
+ for i, column in enumerate(row):
+ reconstructed_row += f"\t{expected[i]}='{column}' ?\n"
+ for missing in expected[i + 1 :]:
+ reconstructed_row += f"\t{missing}= Nothing provided !\n"
+ except IndexError:
+ pass
+ raw = ":".join(row)
+ msg = f"""\
+{exception}
+
+Expected '{example}' or '{other_example}' but we got '{raw}':
+{reconstructed_row}
+
+Try updating it with: 'python tests/test_functional.py {UPDATE_OPTION}'"""
+ Exception.__init__(self, msg)
+
+
+class OutputLine(NamedTuple):
+ symbol: str
+ lineno: int
+ column: int
+ object: Any
+ msg: str
+ confidence: str
+
+ @classmethod
+ def from_msg(cls, msg):
+ column = cls.get_column(msg.column)
+ return cls(
+ msg.symbol,
+ msg.line,
+ column,
+ msg.obj or "",
+ msg.msg.replace("\r\n", "\n"),
+ msg.confidence.name
+ if msg.confidence != interfaces.UNDEFINED
+ else interfaces.HIGH.name,
+ )
+
+ @classmethod
+ def get_column(cls, column):
+ if not PY38_PLUS:
+ return "" # pragma: no cover
+ return str(column)
+
+ @classmethod
+ def from_csv(cls, row):
+ try:
+ confidence = row[5] if len(row) == 6 else interfaces.HIGH.name
+ column = cls.get_column(row[2])
+ return cls(row[0], int(row[1]), column, row[3], row[4], confidence)
+ except Exception as e:
+ raise MalformedOutputLineException(row, e) from e
+
+ def to_csv(self):
+ return tuple(self)
diff --git a/pylint/testutils/reporter_for_tests.py b/pylint/testutils/reporter_for_tests.py
new file mode 100644
index 0000000..e56a0e2
--- /dev/null
+++ b/pylint/testutils/reporter_for_tests.py
@@ -0,0 +1,75 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+from io import StringIO
+from os import getcwd, linesep, sep
+from typing import Dict, List
+
+from pylint import interfaces
+from pylint.message import Message
+from pylint.reporters import BaseReporter
+
+
+class GenericTestReporter(BaseReporter):
+ """reporter storing plain text messages"""
+
+ __implements__ = interfaces.IReporter
+
+ def __init__(self): # pylint: disable=super-init-not-called
+ self.reset()
+
+ def reset(self):
+ self.message_ids: Dict = {}
+ self.out = StringIO()
+ self.path_strip_prefix: str = getcwd() + sep
+ self.messages: List[str] = []
+
+ def handle_message(self, msg: Message) -> None:
+ """manage message of different type and in the context of path"""
+ obj = msg.obj
+ line = msg.line
+ msg_id = msg.msg_id
+ str_message: str = msg.msg
+ self.message_ids[msg_id] = 1
+ if obj:
+ obj = ":%s" % obj
+ sigle = msg_id[0]
+ if linesep != "\n":
+ # 2to3 writes os.linesep instead of using
+ # the previously used line separators
+ str_message = str_message.replace("\r\n", "\n")
+ self.messages.append(f"{sigle}:{line:>3}{obj}: {str_message}")
+
+ def finalize(self):
+ self.messages.sort()
+ for msg in self.messages:
+ print(msg, file=self.out)
+ result = self.out.getvalue()
+ self.reset()
+ return result
+
+ # pylint: disable=unused-argument
+ def on_set_current_module(self, module, filepath):
+ pass
+
+ # pylint: enable=unused-argument
+
+ def display_reports(self, layout):
+ """ignore layouts"""
+
+ _display = None
+
+
+class MinimalTestReporter(BaseReporter):
+ def on_set_current_module(self, module, filepath):
+ self.messages = []
+
+ _display = None
+
+
+class FunctionalTestReporter(BaseReporter): # pylint: disable=abstract-method
+ def on_set_current_module(self, module, filepath):
+ self.messages = []
+
+ def display_reports(self, layout):
+ """Ignore layouts and don't call self._display()."""
diff --git a/pylint/testutils/tokenize_str.py b/pylint/testutils/tokenize_str.py
new file mode 100644
index 0000000..96094fa
--- /dev/null
+++ b/pylint/testutils/tokenize_str.py
@@ -0,0 +1,9 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import tokenize
+from io import StringIO
+
+
+def _tokenize_str(code):
+ return list(tokenize.generate_tokens(StringIO(code).readline))
diff --git a/pylint/testutils/unittest_linter.py b/pylint/testutils/unittest_linter.py
new file mode 100644
index 0000000..ff902c2
--- /dev/null
+++ b/pylint/testutils/unittest_linter.py
@@ -0,0 +1,40 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+from pylint.testutils.global_test_linter import linter
+from pylint.testutils.output_line import Message
+
+
+class UnittestLinter:
+ """A fake linter class to capture checker messages."""
+
+ # pylint: disable=unused-argument, no-self-use
+
+ def __init__(self):
+ self._messages = []
+ self.stats = {}
+
+ def release_messages(self):
+ try:
+ return self._messages
+ finally:
+ self._messages = []
+
+ def add_message(
+ self, msg_id, line=None, node=None, args=None, confidence=None, col_offset=None
+ ):
+ # Do not test col_offset for now since changing Message breaks everything
+ self._messages.append(Message(msg_id, line, node, args, confidence))
+
+ @staticmethod
+ def is_message_enabled(*unused_args, **unused_kwargs):
+ return True
+
+ def add_stats(self, **kwargs):
+ for name, value in kwargs.items():
+ self.stats[name] = value
+ return self.stats
+
+ @property
+ def options_providers(self):
+ return linter.options_providers
diff --git a/pylint/utils/__init__.py b/pylint/utils/__init__.py
new file mode 100644
index 0000000..948e5d5
--- /dev/null
+++ b/pylint/utils/__init__.py
@@ -0,0 +1,89 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2009 Vincent
+# Copyright (c) 2009 Mads Kiilerich <mads@kiilerich.com>
+# Copyright (c) 2012-2014 Google, Inc.
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014-2015 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 LCD 47 <lcd047@gmail.com>
+# Copyright (c) 2014 Brett Cannon <brett@python.org>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2014 Damien Nozay <damien.nozay@gmail.com>
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Simu Toni <simutoni@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 xmo-odoo <xmo-odoo@users.noreply.github.com>
+# Copyright (c) 2017-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2017-2018, 2020-2021 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2017 Chris Lamb <chris@chris-lamb.co.uk>
+# Copyright (c) 2017 Thomas Hisch <t.hisch@gmail.com>
+# Copyright (c) 2017 Mikhail Fesenko <proggga@gmail.com>
+# Copyright (c) 2017 Craig Citro <craigcitro@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""some various utilities and helper classes, most of them used in the
+main pylint class
+"""
+
+from pylint.utils.ast_walker import ASTWalker
+from pylint.utils.file_state import FileState
+from pylint.utils.utils import (
+ HAS_ISORT_5,
+ IsortDriver,
+ _check_csv,
+ _format_option_value,
+ _splitstrip,
+ _unquote,
+ decoding_stream,
+ deprecated_option,
+ diff_string,
+ format_section,
+ get_global_option,
+ get_module_and_frameid,
+ get_rst_section,
+ get_rst_title,
+ normalize_text,
+ register_plugins,
+ safe_decode,
+ tokenize_module,
+)
+
+__all__ = [
+ "ASTWalker",
+ "HAS_ISORT_5",
+ "IsortDriver",
+ "_check_csv",
+ "_format_option_value",
+ "_splitstrip",
+ "_unquote",
+ "decoding_stream",
+ "deprecated_option",
+ "diff_string",
+ "FileState",
+ "format_section",
+ "get_global_option",
+ "get_module_and_frameid",
+ "get_rst_section",
+ "get_rst_title",
+ "normalize_text",
+ "register_plugins",
+ "safe_decode",
+ "tokenize_module",
+]
diff --git a/pylint/utils/ast_walker.py b/pylint/utils/ast_walker.py
new file mode 100644
index 0000000..6ad2f95
--- /dev/null
+++ b/pylint/utils/ast_walker.py
@@ -0,0 +1,85 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+
+from astroid import nodes
+
+
+class ASTWalker:
+ def __init__(self, linter):
+ # callbacks per node types
+ self.nbstatements = 0
+ self.visit_events = collections.defaultdict(list)
+ self.leave_events = collections.defaultdict(list)
+ self.linter = linter
+ self.exception_msg = False
+
+ def _is_method_enabled(self, method):
+ if not hasattr(method, "checks_msgs"):
+ return True
+ for msg_desc in method.checks_msgs:
+ if self.linter.is_message_enabled(msg_desc):
+ return True
+ return False
+
+ def add_checker(self, checker):
+ """walk to the checker's dir and collect visit and leave methods"""
+ vcids = set()
+ lcids = set()
+ visits = self.visit_events
+ leaves = self.leave_events
+ for member in dir(checker):
+ cid = member[6:]
+ if cid == "default":
+ continue
+ if member.startswith("visit_"):
+ v_meth = getattr(checker, member)
+ # don't use visit_methods with no activated message:
+ if self._is_method_enabled(v_meth):
+ visits[cid].append(v_meth)
+ vcids.add(cid)
+ elif member.startswith("leave_"):
+ l_meth = getattr(checker, member)
+ # don't use leave_methods with no activated message:
+ if self._is_method_enabled(l_meth):
+ leaves[cid].append(l_meth)
+ lcids.add(cid)
+ visit_default = getattr(checker, "visit_default", None)
+ if visit_default:
+ for cls in nodes.ALL_NODE_CLASSES:
+ cid = cls.__name__.lower()
+ if cid not in vcids:
+ visits[cid].append(visit_default)
+ # for now we have no "leave_default" method in Pylint
+
+ def walk(self, astroid):
+ """call visit events of astroid checkers for the given node, recurse on
+ its children, then leave events.
+ """
+ cid = astroid.__class__.__name__.lower()
+
+ # Detect if the node is a new name for a deprecated alias.
+ # In this case, favour the methods for the deprecated
+ # alias if any, in order to maintain backwards
+ # compatibility.
+ visit_events = self.visit_events.get(cid, ())
+ leave_events = self.leave_events.get(cid, ())
+
+ try:
+ if astroid.is_statement:
+ self.nbstatements += 1
+ # generate events for this node on each checker
+ for callback in visit_events or ():
+ callback(astroid)
+ # recurse on children
+ for child in astroid.get_children():
+ self.walk(child)
+ for callback in leave_events or ():
+ callback(astroid)
+ except Exception:
+ if self.exception_msg is False:
+ file = getattr(astroid.root(), "file", None)
+ print(f"Exception on node {repr(astroid)} in file '{file}'")
+ self.exception_msg = True
+ raise
diff --git a/pylint/utils/file_state.py b/pylint/utils/file_state.py
new file mode 100644
index 0000000..ba84369
--- /dev/null
+++ b/pylint/utils/file_state.py
@@ -0,0 +1,136 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import collections
+
+from astroid import nodes
+
+from pylint.constants import MSG_STATE_SCOPE_MODULE, WarningScope
+
+
+class FileState:
+ """Hold internal state specific to the currently analyzed file"""
+
+ def __init__(self, modname=None):
+ self.base_name = modname
+ self._module_msgs_state = {}
+ self._raw_module_msgs_state = {}
+ self._ignored_msgs = collections.defaultdict(set)
+ self._suppression_mapping = {}
+ self._effective_max_line_number = None
+
+ def collect_block_lines(self, msgs_store, module_node):
+ """Walk the AST to collect block level options line numbers."""
+ for msg, lines in self._module_msgs_state.items():
+ self._raw_module_msgs_state[msg] = lines.copy()
+ orig_state = self._module_msgs_state.copy()
+ self._module_msgs_state = {}
+ self._suppression_mapping = {}
+ self._effective_max_line_number = module_node.tolineno
+ self._collect_block_lines(msgs_store, module_node, orig_state)
+
+ def _collect_block_lines(self, msgs_store, node, msg_state):
+ """Recursively walk (depth first) AST to collect block level options
+ line numbers.
+ """
+ for child in node.get_children():
+ self._collect_block_lines(msgs_store, child, msg_state)
+ first = node.fromlineno
+ last = node.tolineno
+ # first child line number used to distinguish between disable
+ # which are the first child of scoped node with those defined later.
+ # For instance in the code below:
+ #
+ # 1. def meth8(self):
+ # 2. """test late disabling"""
+ # 3. pylint: disable=not-callable
+ # 4. print(self.blip)
+ # 5. pylint: disable=no-member
+ # 6. print(self.bla)
+ #
+ # E1102 should be disabled from line 1 to 6 while E1101 from line 5 to 6
+ #
+ # this is necessary to disable locally messages applying to class /
+ # function using their fromlineno
+ if (
+ isinstance(node, (nodes.Module, nodes.ClassDef, nodes.FunctionDef))
+ and node.body
+ ):
+ firstchildlineno = node.body[0].fromlineno
+ else:
+ firstchildlineno = last
+ for msgid, lines in msg_state.items():
+ for lineno, state in list(lines.items()):
+ original_lineno = lineno
+ if first > lineno or last < lineno:
+ continue
+ # Set state for all lines for this block, if the
+ # warning is applied to nodes.
+ message_definitions = msgs_store.get_message_definitions(msgid)
+ for message_definition in message_definitions:
+ if message_definition.scope == WarningScope.NODE:
+ if lineno > firstchildlineno:
+ state = True
+ first_, last_ = node.block_range(lineno)
+ else:
+ first_ = lineno
+ last_ = last
+ for line in range(first_, last_ + 1):
+ # do not override existing entries
+ if line in self._module_msgs_state.get(msgid, ()):
+ continue
+ if line in lines: # state change in the same block
+ state = lines[line]
+ original_lineno = line
+ if not state:
+ self._suppression_mapping[(msgid, line)] = original_lineno
+ try:
+ self._module_msgs_state[msgid][line] = state
+ except KeyError:
+ self._module_msgs_state[msgid] = {line: state}
+ del lines[lineno]
+
+ def set_msg_status(self, msg, line, status):
+ """Set status (enabled/disable) for a given message at a given line"""
+ assert line > 0
+ try:
+ self._module_msgs_state[msg.msgid][line] = status
+ except KeyError:
+ self._module_msgs_state[msg.msgid] = {line: status}
+
+ def handle_ignored_message(
+ self, state_scope, msgid, line, node, args, confidence
+ ): # pylint: disable=unused-argument
+ """Report an ignored message.
+
+ state_scope is either MSG_STATE_SCOPE_MODULE or MSG_STATE_SCOPE_CONFIG,
+ depending on whether the message was disabled locally in the module,
+ or globally. The other arguments are the same as for add_message.
+ """
+ if state_scope == MSG_STATE_SCOPE_MODULE:
+ try:
+ orig_line = self._suppression_mapping[(msgid, line)]
+ self._ignored_msgs[(msgid, orig_line)].add(line)
+ except KeyError:
+ pass
+
+ def iter_spurious_suppression_messages(self, msgs_store):
+ for warning, lines in self._raw_module_msgs_state.items():
+ for line, enable in lines.items():
+ if not enable and (warning, line) not in self._ignored_msgs:
+ # ignore cyclic-import check which can show false positives
+ # here due to incomplete context
+ if warning != "R0401":
+ yield "useless-suppression", line, (
+ msgs_store.get_msg_display_string(warning),
+ )
+ # don't use iteritems here, _ignored_msgs may be modified by add_message
+ for (warning, from_), lines in list(self._ignored_msgs.items()):
+ for line in lines:
+ yield "suppressed-message", line, (
+ msgs_store.get_msg_display_string(warning),
+ from_,
+ )
+
+ def get_effective_max_line_number(self):
+ return self._effective_max_line_number
diff --git a/pylint/utils/pragma_parser.py b/pylint/utils/pragma_parser.py
new file mode 100644
index 0000000..060c6da
--- /dev/null
+++ b/pylint/utils/pragma_parser.py
@@ -0,0 +1,132 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import re
+from collections import namedtuple
+from typing import Generator, List
+
+# Allow stopping after the first semicolon/hash encountered,
+# so that an option can be continued with the reasons
+# why it is active or disabled.
+OPTION_RGX = r"""
+ \s* # Any number of whithespace
+ \#? # One or zero hash
+ .* # Anything (as much as possible)
+ (\s* # Beginning of first matched group and any number of whitespaces
+ \# # Beginning of comment
+ .*? # Anything (as little as possible)
+ \bpylint: # pylint word and column
+ \s* # Any number of whitespaces
+ ([^;#\n]+)) # Anything except semicolon or hash or newline (it is the second matched group)
+ # and end of the first matched group
+ [;#]{0,1}""" # From 0 to 1 repetition of semicolon or hash
+OPTION_PO = re.compile(OPTION_RGX, re.VERBOSE)
+
+
+PragmaRepresenter = namedtuple("PragmaRepresenter", "action messages")
+
+
+ATOMIC_KEYWORDS = frozenset(("disable-all", "skip-file"))
+MESSAGE_KEYWORDS = frozenset(("disable-msg", "enable-msg", "disable", "enable"))
+# sorted is necessary because sets are unordered collections and ALL_KEYWORDS
+# string should not vary between executions
+# reverse is necessary in order to have the longest keywords first, so that, for example,
+# 'disable' string should not be matched instead of 'disable-all'
+ALL_KEYWORDS = "|".join(
+ sorted(ATOMIC_KEYWORDS | MESSAGE_KEYWORDS, key=len, reverse=True)
+)
+
+
+TOKEN_SPECIFICATION = [
+ ("KEYWORD", fr"\b({ALL_KEYWORDS:s})\b"),
+ ("MESSAGE_STRING", r"[0-9A-Za-z\-\_]{2,}"), # Identifiers
+ ("ASSIGN", r"="), # Assignment operator
+ ("MESSAGE_NUMBER", r"[CREIWF]{1}\d*"),
+]
+
+TOK_REGEX = "|".join(
+ f"(?P<{token_name:s}>{token_rgx:s})"
+ for token_name, token_rgx in TOKEN_SPECIFICATION
+)
+
+
+def emit_pragma_representer(action, messages):
+ if not messages and action in MESSAGE_KEYWORDS:
+ raise InvalidPragmaError(
+ "The keyword is not followed by message identifier", action
+ )
+ return PragmaRepresenter(action, messages)
+
+
+class PragmaParserError(Exception):
+ """
+ A class for exceptions thrown by pragma_parser module
+ """
+
+ def __init__(self, message, token):
+ """
+ :args message: explain the reason why the exception has been thrown
+ :args token: token concerned by the exception
+ """
+ self.message = message
+ self.token = token
+ super().__init__(self.message)
+
+
+class UnRecognizedOptionError(PragmaParserError):
+ """
+ Thrown in case the of a valid but unrecognized option
+ """
+
+
+class InvalidPragmaError(PragmaParserError):
+ """
+ Thrown in case the pragma is invalid
+ """
+
+
+def parse_pragma(pylint_pragma: str) -> Generator[PragmaRepresenter, None, None]:
+ action = None
+ messages: List[str] = []
+ assignment_required = False
+ previous_token = ""
+
+ for mo in re.finditer(TOK_REGEX, pylint_pragma):
+ kind = mo.lastgroup
+ value = mo.group()
+
+ if kind == "ASSIGN":
+ if not assignment_required:
+ if action:
+ # A keyword has been found previously but doesn't support assignement
+ raise UnRecognizedOptionError(
+ "The keyword doesn't support assignment", action
+ )
+ if previous_token:
+ # Something found previously but not a known keyword
+ raise UnRecognizedOptionError(
+ "The keyword is unknown", previous_token
+ )
+ # Nothing at all detected before this assignment
+ raise InvalidPragmaError("Missing keyword before assignment", "")
+ assignment_required = False
+ elif assignment_required:
+ raise InvalidPragmaError("The = sign is missing after the keyword", action)
+ elif kind == "KEYWORD":
+ if action:
+ yield emit_pragma_representer(action, messages)
+ action = value
+ messages = list()
+ assignment_required = action in MESSAGE_KEYWORDS
+ elif kind in ("MESSAGE_STRING", "MESSAGE_NUMBER"):
+ messages.append(value)
+ assignment_required = False
+ else:
+ raise RuntimeError("Token not recognized")
+
+ previous_token = value
+
+ if action:
+ yield emit_pragma_representer(action, messages)
+ else:
+ raise UnRecognizedOptionError("The keyword is unknown", previous_token)
diff --git a/pylint/utils/utils.py b/pylint/utils/utils.py
new file mode 100644
index 0000000..709ef4a
--- /dev/null
+++ b/pylint/utils/utils.py
@@ -0,0 +1,318 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+try:
+ import isort.api
+
+ HAS_ISORT_5 = True
+except ImportError: # isort < 5
+ import isort
+
+ HAS_ISORT_5 = False
+
+import codecs
+import os
+import re
+import sys
+import textwrap
+import tokenize
+
+from astroid import Module, modutils
+
+from pylint.constants import PY_EXTS
+
+DEFAULT_LINE_LENGTH = 79
+
+
+def normalize_text(text, line_len=DEFAULT_LINE_LENGTH, indent=""):
+ """Wrap the text on the given line length."""
+ return "\n".join(
+ textwrap.wrap(
+ text, width=line_len, initial_indent=indent, subsequent_indent=indent
+ )
+ )
+
+
+CMPS = ["=", "-", "+"]
+
+
+# py3k has no more cmp builtin
+def cmp(a, b): # pylint: disable=redefined-builtin
+ return (a > b) - (a < b)
+
+
+def diff_string(old, new):
+ """given an old and new int value, return a string representing the
+ difference
+ """
+ diff = abs(old - new)
+ diff_str = "{}{}".format(CMPS[cmp(old, new)], diff and ("%.2f" % diff) or "")
+ return diff_str
+
+
+def get_module_and_frameid(node):
+ """return the module name and the frame id in the module"""
+ frame = node.frame()
+ module, obj = "", []
+ while frame:
+ if isinstance(frame, Module):
+ module = frame.name
+ else:
+ obj.append(getattr(frame, "name", "<lambda>"))
+ try:
+ frame = frame.parent.frame()
+ except AttributeError:
+ frame = None
+ obj.reverse()
+ return module, ".".join(obj)
+
+
+def get_rst_title(title, character):
+ """Permit to get a title formatted as ReStructuredText test (underlined with a chosen character)."""
+ return f"{title}\n{character * len(title)}\n"
+
+
+def get_rst_section(section, options, doc=None):
+ """format an options section using as a ReStructuredText formatted output"""
+ result = ""
+ if section:
+ result += get_rst_title(section, "'")
+ if doc:
+ formatted_doc = normalize_text(doc)
+ result += "%s\n\n" % formatted_doc
+ for optname, optdict, value in options:
+ help_opt = optdict.get("help")
+ result += ":%s:\n" % optname
+ if help_opt:
+ formatted_help = normalize_text(help_opt, indent=" ")
+ result += "%s\n" % formatted_help
+ if value:
+ value = str(_format_option_value(optdict, value))
+ result += "\n Default: ``%s``\n" % value.replace("`` ", "```` ``")
+ return result
+
+
+def safe_decode(line, encoding, *args, **kwargs):
+ """return decoded line from encoding or decode with default encoding"""
+ try:
+ return line.decode(encoding or sys.getdefaultencoding(), *args, **kwargs)
+ except LookupError:
+ return line.decode(sys.getdefaultencoding(), *args, **kwargs)
+
+
+def decoding_stream(stream, encoding, errors="strict"):
+ try:
+ reader_cls = codecs.getreader(encoding or sys.getdefaultencoding())
+ except LookupError:
+ reader_cls = codecs.getreader(sys.getdefaultencoding())
+ return reader_cls(stream, errors)
+
+
+def tokenize_module(module):
+ with module.stream() as stream:
+ readline = stream.readline
+ return list(tokenize.tokenize(readline))
+
+
+def register_plugins(linter, directory):
+ """load all module and package in the given directory, looking for a
+ 'register' function in each one, used to register pylint checkers
+ """
+ imported = {}
+ for filename in os.listdir(directory):
+ base, extension = os.path.splitext(filename)
+ if base in imported or base == "__pycache__":
+ continue
+ if (
+ extension in PY_EXTS
+ and base != "__init__"
+ or (
+ not extension
+ and os.path.isdir(os.path.join(directory, base))
+ and not filename.startswith(".")
+ )
+ ):
+ try:
+ module = modutils.load_module_from_file(
+ os.path.join(directory, filename)
+ )
+ except ValueError:
+ # empty module name (usually emacs auto-save files)
+ continue
+ except ImportError as exc:
+ print(f"Problem importing module {filename}: {exc}", file=sys.stderr)
+ else:
+ if hasattr(module, "register"):
+ module.register(linter)
+ imported[base] = 1
+
+
+def get_global_option(checker, option, default=None):
+ """Retrieve an option defined by the given *checker* or
+ by all known option providers.
+
+ It will look in the list of all options providers
+ until the given *option* will be found.
+ If the option wasn't found, the *default* value will be returned.
+ """
+ # First, try in the given checker's config.
+ # After that, look in the options providers.
+
+ try:
+ return getattr(checker.config, option.replace("-", "_"))
+ except AttributeError:
+ pass
+ for provider in checker.linter.options_providers:
+ for options in provider.options:
+ if options[0] == option:
+ return getattr(provider.config, option.replace("-", "_"))
+ return default
+
+
+def deprecated_option(
+ shortname=None, opt_type=None, help_msg=None, deprecation_msg=None
+):
+ def _warn_deprecated(option, optname, *args): # pylint: disable=unused-argument
+ if deprecation_msg:
+ sys.stderr.write(deprecation_msg % (optname,))
+
+ option = {
+ "help": help_msg,
+ "hide": True,
+ "type": opt_type,
+ "action": "callback",
+ "callback": _warn_deprecated,
+ "deprecated": True,
+ }
+ if shortname:
+ option["shortname"] = shortname
+ return option
+
+
+def _splitstrip(string, sep=","):
+ """return a list of stripped string by splitting the string given as
+ argument on `sep` (',' by default). Empty string are discarded.
+
+ >>> _splitstrip('a, b, c , 4,,')
+ ['a', 'b', 'c', '4']
+ >>> _splitstrip('a')
+ ['a']
+ >>> _splitstrip('a,\nb,\nc,')
+ ['a', 'b', 'c']
+
+ :type string: str or unicode
+ :param string: a csv line
+
+ :type sep: str or unicode
+ :param sep: field separator, default to the comma (',')
+
+ :rtype: str or unicode
+ :return: the unquoted string (or the input string if it wasn't quoted)
+ """
+ return [word.strip() for word in string.split(sep) if word.strip()]
+
+
+def _unquote(string):
+ """remove optional quotes (simple or double) from the string
+
+ :type string: str or unicode
+ :param string: an optionally quoted string
+
+ :rtype: str or unicode
+ :return: the unquoted string (or the input string if it wasn't quoted)
+ """
+ if not string:
+ return string
+ if string[0] in "\"'":
+ string = string[1:]
+ if string[-1] in "\"'":
+ string = string[:-1]
+ return string
+
+
+def _check_csv(value):
+ if isinstance(value, (list, tuple)):
+ return value
+ return _splitstrip(value)
+
+
+def _comment(string):
+ """return string as a comment"""
+ lines = [line.strip() for line in string.splitlines()]
+ return "# " + ("%s# " % os.linesep).join(lines)
+
+
+def _format_option_value(optdict, value):
+ """return the user input's value from a 'compiled' value"""
+ if optdict.get("type", None) == "py_version":
+ value = ".".join(str(item) for item in value)
+ elif isinstance(value, (list, tuple)):
+ value = ",".join(_format_option_value(optdict, item) for item in value)
+ elif isinstance(value, dict):
+ value = ",".join(f"{k}:{v}" for k, v in value.items())
+ elif hasattr(value, "match"): # optdict.get('type') == 'regexp'
+ # compiled regexp
+ value = value.pattern
+ elif optdict.get("type") == "yn":
+ value = "yes" if value else "no"
+ elif isinstance(value, str) and value.isspace():
+ value = "'%s'" % value
+ return value
+
+
+def format_section(stream, section, options, doc=None):
+ """format an options section using the INI format"""
+ if doc:
+ print(_comment(doc), file=stream)
+ print("[%s]" % section, file=stream)
+ _ini_format(stream, options)
+
+
+def _ini_format(stream, options):
+ """format options using the INI format"""
+ for optname, optdict, value in options:
+ value = _format_option_value(optdict, value)
+ help_opt = optdict.get("help")
+ if help_opt:
+ help_opt = normalize_text(help_opt, indent="# ")
+ print(file=stream)
+ print(help_opt, file=stream)
+ else:
+ print(file=stream)
+ if value is None:
+ print("#%s=" % optname, file=stream)
+ else:
+ value = str(value).strip()
+ if re.match(r"^([\w-]+,)+[\w-]+$", str(value)):
+ separator = "\n " + " " * len(optname)
+ value = separator.join(x + "," for x in str(value).split(","))
+ # remove trailing ',' from last element of the list
+ value = value[:-1]
+ print(f"{optname}={value}", file=stream)
+
+
+class IsortDriver:
+ """A wrapper around isort API that changed between versions 4 and 5."""
+
+ def __init__(self, config):
+ if HAS_ISORT_5:
+ self.isort5_config = isort.api.Config(
+ # There is not typo here. EXTRA_standard_library is
+ # what most users want. The option has been named
+ # KNOWN_standard_library for ages in pylint and we
+ # don't want to break compatibility.
+ extra_standard_library=config.known_standard_library,
+ known_third_party=config.known_third_party,
+ )
+ else:
+ self.isort4_obj = isort.SortImports( # pylint: disable=no-member
+ file_contents="",
+ known_standard_library=config.known_standard_library,
+ known_third_party=config.known_third_party,
+ )
+
+ def place_module(self, package):
+ if HAS_ISORT_5:
+ return isort.api.place_module(package, self.isort5_config)
+ return self.isort4_obj.place_module(package)
diff --git a/pylintrc b/pylintrc
new file mode 100644
index 0000000..e488b13
--- /dev/null
+++ b/pylintrc
@@ -0,0 +1,381 @@
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Files or directories to be skipped. They should be base names, not
+# paths.
+ignore=CVS
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+ pylint.extensions.check_elif,
+ pylint.extensions.bad_builtin,
+ pylint.extensions.code_style,
+
+# Use multiple processes to speed up Pylint.
+jobs=1
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code
+extension-pkg-allow-list=
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time. See also the "--disable" option for examples.
+enable=
+ use-symbolic-message-instead,
+ useless-supression,
+ fixme
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+
+disable=
+ attribute-defined-outside-init,
+ duplicate-code,
+ invalid-name,
+ missing-docstring,
+ protected-access,
+ too-few-public-methods,
+ # handled by black
+ format
+
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]".
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=_$|dummy
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid defining new builtins when possible.
+additional-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,_cb
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=100
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+# List of optional constructs for which whitespace checking is disabled
+no-space-check=trailing-comma,dict-separator
+
+# Maximum number of lines in a module
+max-module-lines=2000
+
+# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
+# tab).
+indent-string=' '
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+
+[BASIC]
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=i,j,k,ex,Run,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# Regular expression matching correct function names
+function-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for function names
+function-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct variable names
+variable-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for variable names
+variable-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct constant names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Naming hint for constant names
+const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression matching correct attribute names
+attr-rgx=[a-z_][a-z0-9_]{2,}$
+
+# Naming hint for attribute names
+attr-name-hint=[a-z_][a-z0-9_]{2,}$
+
+# Regular expression matching correct argument names
+argument-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for argument names
+argument-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct class attribute names
+class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Naming hint for class attribute names
+class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Regular expression matching correct inline iteration names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Naming hint for inline iteration names
+inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
+
+# Regular expression matching correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Naming hint for class names
+class-name-hint=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression matching correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Naming hint for module names
+module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression matching correct method names
+method-rgx=[a-z_][a-z0-9_]{2,}$
+
+# Naming hint for method names
+method-name-hint=[a-z_][a-z0-9_]{2,}$
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=__.*__
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# List of decorators that define properties, such as abc.abstractproperty.
+property-classes=abc.abstractproperty
+
+
+[TYPECHECK]
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis
+ignored-modules=
+
+# List of classes names for which member attributes should not be checked
+# (useful for classes with attributes dynamically set).
+ignored-classes=SQLObject, optparse.Values, thread._local, _thread._local
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=REQUEST,acl_users,aq_parent
+
+# List of decorators that create context managers from functions, such as
+# contextlib.contextmanager.
+contextmanager-decorators=contextlib.contextmanager
+
+
+[SPELLING]
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=10
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*
+
+# Maximum number of locals for function / method body
+max-locals=25
+
+# Maximum number of return / yield for function / method body
+max-returns=11
+
+# Maximum number of branch for function / method body
+max-branches=26
+
+# Maximum number of statements in function / method body
+max-statements=100
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=11
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=25
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp,__post_init__
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,TERMIOS,Bastion,rexec
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=Exception
+
+
+[pylint.DEPRECATED_BUILTINS]
+
+# List of builtins function names that should not be used, separated by a comma
+bad-functions=map,input
diff --git a/requirements_test.txt b/requirements_test.txt
new file mode 100644
index 0000000..286aeed
--- /dev/null
+++ b/requirements_test.txt
@@ -0,0 +1,13 @@
+-r requirements_test_pre_commit.txt
+-r requirements_test_min.txt
+coveralls~=3.1
+coverage~=5.5
+pre-commit~=2.13;python_full_version>="3.6.2"
+tbump~=6.3.2
+pyenchant~=3.2
+pytest-cov~=2.12
+pytest-profiling~=1.7
+pytest-xdist~=2.3
+# Type packages for mypy
+types-pkg_resources==0.1.3
+types-toml==0.1.2
diff --git a/requirements_test_min.txt b/requirements_test_min.txt
new file mode 100644
index 0000000..b48e37d
--- /dev/null
+++ b/requirements_test_min.txt
@@ -0,0 +1,4 @@
+-e .
+astroid==2.6.0-dev0 # Pinned to a specific version for tests
+pytest~=6.2
+pytest-benchmark~=3.4
diff --git a/requirements_test_pre_commit.txt b/requirements_test_pre_commit.txt
new file mode 100644
index 0000000..174e83f
--- /dev/null
+++ b/requirements_test_pre_commit.txt
@@ -0,0 +1,6 @@
+# Everything in this file should reflect the pre-commit configuration
+# in .pre-commit-config.yaml
+black==21.6b0;python_full_version>="3.6.2"
+flake8==3.9.2
+isort==5.9.0
+mypy==0.902
diff --git a/script/__init__.py b/script/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/script/__init__.py
diff --git a/script/bump_changelog.py b/script/bump_changelog.py
new file mode 100644
index 0000000..e516530
--- /dev/null
+++ b/script/bump_changelog.py
@@ -0,0 +1,80 @@
+# ORIGINAL here:https://raw.githubusercontent.com/PyCQA/astroid/master/script/bump_changelog.py
+# DO NOT MODIFY DIRECTLY
+
+"""
+This script permits to upgrade the changelog in astroid or pylint when releasing a version.
+"""
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+DEFAULT_CHANGELOG_PATH = Path("ChangeLog")
+err = "in the changelog, fix that first!"
+TBA_ERROR_MSG = "More than one release date 'TBA' %s" % err
+NEW_VERSION_ERROR_MSG = "The text for this version '{version}' did not exists %s" % err
+NEXT_VERSION_ERROR_MSG = (
+ "The text for the next version '{version}' already exists %s" % err
+)
+
+TODAY = datetime.now()
+WHATS_NEW_TEXT = "What's New in astroid"
+FULL_WHATS_NEW_TEXT = WHATS_NEW_TEXT + " {version}?"
+RELEASE_DATE_TEXT = "Release Date: TBA"
+NEW_RELEASE_DATE_MESSAGE = "Release Date: {}".format(TODAY.strftime("%Y-%m-%d"))
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(__doc__)
+ parser.add_argument("version", help="The version we want to release")
+ args = parser.parse_args()
+ if "dev" not in args.version:
+ version = args.version
+ next_version = get_next_version(version)
+ run(version, next_version)
+
+
+def get_next_version(version: str) -> str:
+ new_version = version.split(".")
+ patch = new_version[2]
+ reminder = None
+ if "-" in patch:
+ patch, reminder = patch.split("-")
+ patch = str(int(patch) + 1)
+ new_version[2] = patch if reminder is None else f"{patch}-{reminder}"
+ return ".".join(new_version)
+
+
+def run(version: str, next_version: str) -> None:
+ with open(DEFAULT_CHANGELOG_PATH) as f:
+ content = f.read()
+ content = transform_content(content, version, next_version)
+ with open(DEFAULT_CHANGELOG_PATH, "w") as f:
+ f.write(content)
+
+
+def transform_content(content: str, version: str, next_version: str) -> str:
+ wn_new_version = FULL_WHATS_NEW_TEXT.format(version=version)
+ wn_next_version = FULL_WHATS_NEW_TEXT.format(version=next_version)
+ # There is only one field where the release date is TBA
+ assert content.count(RELEASE_DATE_TEXT) == 1, TBA_ERROR_MSG
+ # There is already a release note for the version we want to release
+ assert content.count(wn_new_version) == 1, NEW_VERSION_ERROR_MSG.format(
+ version=version
+ )
+ # There is no release notes for the next version
+ assert content.count(wn_next_version) == 0, NEXT_VERSION_ERROR_MSG.format(
+ version=next_version
+ )
+ index = content.find(WHATS_NEW_TEXT)
+ content = content.replace(RELEASE_DATE_TEXT, NEW_RELEASE_DATE_MESSAGE)
+ end_content = content[index:]
+ content = content[:index]
+ content += wn_next_version + "\n"
+ content += "=" * len(wn_next_version) + "\n"
+ content += RELEASE_DATE_TEXT + "\n" * 4
+ content += end_content
+ return content
+
+
+if __name__ == "__main__":
+ main()
diff --git a/script/fix_documentation.py b/script/fix_documentation.py
new file mode 100644
index 0000000..2422253
--- /dev/null
+++ b/script/fix_documentation.py
@@ -0,0 +1,101 @@
+"""Small script to fix various issues with the documentation. Used by pre-commit."""
+import argparse
+import re
+import sys
+from typing import List, Optional, Union
+
+INVALID_CODE_BLOCK_PATTERN = (
+ r"(?<=\s`)([\w\-\.\(\)\=]+\s{0,1}[\w\-\.\(\)\=]*)(?=`[,\.]{0,1}\s|$)"
+)
+
+DEFAULT_CHANGELOG = "ChangeLog"
+DEFAULT_SUBTITLE_PREFIX = "What's New in"
+
+
+def fix_inline_code_blocks(file_content: str) -> str:
+ """Use double quotes for code blocks. RST style.
+
+ Example:
+ `hello-world` -> ``hello-world``
+ """
+ pattern = re.compile(INVALID_CODE_BLOCK_PATTERN)
+ return pattern.sub(r"`\g<0>`", file_content)
+
+
+def changelog_insert_empty_lines(file_content: str, subtitle_text: str) -> str:
+ """Insert up to two empty lines before `What's New` entry in ChangeLog"""
+ lines = file_content.split("\n")
+ subtitle_count = 0
+ for i, line in enumerate(lines):
+ if line.startswith(subtitle_text):
+ subtitle_count += 1
+ if (
+ subtitle_count == 1
+ or i < 2
+ or lines[i - 1] == ""
+ and lines[i - 2] == ""
+ ):
+ continue
+ lines.insert(i, "")
+ return "\n".join(lines)
+
+
+class CustomHelpFormatter(argparse.HelpFormatter):
+ def __init__(
+ self,
+ prog: str,
+ indent_increment: int = 2,
+ max_help_position: int = 24,
+ width: Optional[int] = None,
+ ) -> None:
+ max_help_position = 40
+ super().__init__(
+ prog,
+ indent_increment=indent_increment,
+ max_help_position=max_help_position,
+ width=width,
+ )
+
+
+def main(argv: Union[List[str], None] = None) -> int:
+ argv = argv or sys.argv[1:]
+ parser = argparse.ArgumentParser(formatter_class=CustomHelpFormatter)
+ parser.add_argument(
+ "--changelog",
+ metavar="file",
+ default=DEFAULT_CHANGELOG,
+ help="Changelog filename (default: '%(default)s')",
+ )
+ parser.add_argument(
+ "--subtitle-prefix",
+ metavar="prefix",
+ default=DEFAULT_SUBTITLE_PREFIX,
+ help="Subtitle prefix (default: '%(default)s')",
+ )
+ parser.add_argument(
+ "filenames",
+ nargs="*",
+ metavar="FILES",
+ help="File names to modify",
+ )
+ args = parser.parse_args(argv)
+
+ return_value: int = 0
+ for file_name in args.filenames:
+ with open(file_name) as fp:
+ orignal_content = fp.read()
+ content = orignal_content
+ # Modify files
+ content = fix_inline_code_blocks(content)
+ if file_name == args.changelog:
+ content = changelog_insert_empty_lines(content, args.subtitle_prefix)
+ # If modified, write changes and eventually return 1
+ if orignal_content != content:
+ with open(file_name, "w") as fp:
+ fp.write(content)
+ return_value |= 1
+ return return_value
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..056e2a6
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,112 @@
+[metadata]
+name = pylint
+version = attr: pylint.__pkginfo__.__version__
+description = python code static checker
+long_description = file: README.rst
+long_description_content_type = text/x-rst
+url = https://github.com/PyCQA/pylint
+author = Python Code Quality Authority
+author_email = code-quality@python.org
+license = GPL-2.0-or-later
+license_files =
+ LICENSE
+ CONTRIBUTORS.txt
+classifiers =
+ Development Status :: 6 - Mature
+ Environment :: Console
+ Intended Audience :: Developers
+ License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+ Operating System :: OS Independent
+ Programming Language :: Python
+ Programming Language :: Python :: 3
+ Programming Language :: Python :: 3 :: Only
+ Programming Language :: Python :: 3.6
+ Programming Language :: Python :: 3.7
+ Programming Language :: Python :: 3.8
+ Programming Language :: Python :: 3.9
+ Programming Language :: Python :: Implementation :: CPython
+ Programming Language :: Python :: Implementation :: PyPy
+ Topic :: Software Development :: Debuggers
+ Topic :: Software Development :: Quality Assurance
+ Topic :: Software Development :: Testing
+keywords = static code analysis linter python lint
+project_urls =
+ What's New = https://pylint.pycqa.org/en/latest/whatsnew/
+ Bug tracker = https://github.com/PyCQA/pylint/issues
+ Discord server = https://discord.gg/Egy6P8AMB5
+ User manual = http://pylint.pycqa.org/en/latest/
+ Contributing = http://pylint.pycqa.org/en/latest/development_guide/contribute.html
+ Technical references = http://pylint.pycqa.org/en/latest/technical_reference/index.html
+
+[options]
+packages = find:
+install_requires =
+ astroid>=2.6.0-dev0,<2.7 # (You should also upgrade requirements_test_min.txt)
+ isort>=4.2.5,<6
+ mccabe>=0.6,<0.7
+ toml>=0.7.1
+ colorama;sys_platform=="win32"
+python_requires = ~=3.6
+
+[options.packages.find]
+include =
+ pylint*
+
+[options.entry_points]
+console_scripts =
+ pylint = pylint:run_pylint
+ epylint = pylint:run_epylint
+ pyreverse = pylint:run_pyreverse
+ symilar = pylint:run_symilar
+
+[aliases]
+test = pytest
+
+[tool:pytest]
+testpaths = tests
+python_files = *test_*.py
+addopts = -m "not acceptance"
+markers =
+ acceptance:
+ benchmark: Baseline of pylint performance, if this regress something serious happened
+
+[isort]
+multi_line_output = 3
+line_length = 88
+known_third_party = astroid, sphinx, isort, pytest, mccabe, six, toml
+include_trailing_comma = True
+skip_glob = tests/functional/**,tests/input/**,tests/extensions/data/**,tests/regrtest_data/**,tests/data/**,astroid/**,venv/**
+src_paths = pylint
+
+[mypy]
+scripts_are_modules = True
+
+[mypy-astroid.*]
+ignore_missing_imports = True
+
+[mypy-coverage]
+ignore_missing_imports = True
+
+[mypy-enchant.*]
+ignore_missing_imports = True
+
+[mypy-isort.*]
+ignore_missing_imports = True
+
+[mypy-mccabe]
+ignore_missing_imports = True
+
+[mypy-pytest]
+ignore_missing_imports = True
+
+[mypy-_pytest.*]
+ignore_missing_imports = True
+
+[mypy-setuptools]
+ignore_missing_imports = True
+
+[mypy-_string]
+ignore_missing_imports = True
+
+[mypy-toml.decoder]
+ignore_missing_imports = True
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..6068493
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()
diff --git a/tbump.toml b/tbump.toml
new file mode 100644
index 0000000..aa54f05
--- /dev/null
+++ b/tbump.toml
@@ -0,0 +1,47 @@
+github_url = "https://github.com/PyCQA/pylint"
+
+[version]
+current = "2.9.0-dev1"
+regex = '''
+^(?P<major>0|[1-9]\d*)
+\.
+(?P<minor>0|[1-9]\d*)
+\.
+(?P<patch>0|[1-9]\d*)
+(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
+'''
+
+[git]
+message_template = "Bump pylint to {new_version}, update changelog"
+tag_template = "v{new_version}"
+
+# For each file to patch, add a [[file]] config
+# section containing the path of the file, relative to the
+# tbump.toml location.
+[[file]]
+src = "pylint/__pkginfo__.py"
+
+# You can specify a list of commands to
+# run after the files have been patched
+# and before the git commit is made
+[[before_commit]]
+name = "Upgrade changelog"
+cmd = "python3 script/bump_changelog.py {new_version}"
+
+[[before_commit]]
+name = "Upgrade copyrights"
+cmd = "pip3 install copyrite;copyrite --contribution-threshold 1 --change-threshold 3 --backend-type git --aliases=.copyrite_aliases . --jobs=8"
+
+[[before_commit]]
+name = "Apply pre-commit"
+cmd = "pre-commit run --all-files||echo 'Hack so this command does not fail'"
+
+[[before_commit]]
+name = "Acceptance tests"
+cmd = "pytest -m acceptance"
+
+# Or run some commands after the git tag and the branch
+# have been pushed:
+# [[after_push]]
+# name = "publish"
+# cmd = "./publish.sh"
diff --git a/tests/acceptance/test_stdlib.py b/tests/acceptance/test_stdlib.py
new file mode 100644
index 0000000..1798117
--- /dev/null
+++ b/tests/acceptance/test_stdlib.py
@@ -0,0 +1,54 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import contextlib
+import io
+import os
+import sys
+
+import pytest
+
+import pylint.lint
+
+
+def is_module(filename):
+ return filename.endswith(".py")
+
+
+def is_package(filename, location):
+ return os.path.exists(os.path.join(location, filename, "__init__.py"))
+
+
+@contextlib.contextmanager
+def _patch_stdout(out):
+ sys.stdout = out
+ try:
+ yield
+ finally:
+ sys.stdout = sys.__stdout__
+
+
+LIB_DIRS = [os.path.dirname(os.__file__)]
+MODULES_TO_CHECK = [
+ (location, module)
+ for location in LIB_DIRS
+ for module in os.listdir(location)
+ if is_module(module) or is_package(module, location)
+]
+MODULES_NAMES = [m[1] for m in MODULES_TO_CHECK]
+
+
+@pytest.mark.acceptance
+@pytest.mark.parametrize(
+ ("test_module_location", "test_module_name"), MODULES_TO_CHECK, ids=MODULES_NAMES
+)
+def test_libmodule(test_module_location, test_module_name):
+ os.chdir(test_module_location)
+ with _patch_stdout(io.StringIO()):
+ try:
+ pylint.lint.Run([test_module_name, "--enable=all", "--ignore=test"])
+ except SystemExit as ex:
+ assert ex.code != 32
+ return
+
+ assert False, "shouldn't get there"
diff --git a/tests/benchmark/test_baseline_benchmarks.py b/tests/benchmark/test_baseline_benchmarks.py
new file mode 100644
index 0000000..6fc914d
--- /dev/null
+++ b/tests/benchmark/test_baseline_benchmarks.py
@@ -0,0 +1,359 @@
+""" Profiles basic -jX functionality """
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+# pylint: disable=protected-access,missing-function-docstring,no-self-use
+
+import os
+import pprint
+import time
+from unittest.mock import patch
+
+import pytest
+
+import pylint.interfaces
+from pylint.checkers.base_checker import BaseChecker
+from pylint.lint import PyLinter, Run, check_parallel
+from pylint.testutils import GenericTestReporter as Reporter
+from pylint.utils import register_plugins
+
+
+def _empty_filepath():
+ return os.path.abspath(
+ os.path.join(
+ os.path.dirname(__file__), "..", "input", "benchmark_minimal_file.py"
+ )
+ )
+
+
+class SleepingChecker(BaseChecker):
+ """A checker that sleeps, the wall-clock time should reduce as we add workers
+
+ As we apply a roughly constant amount of "work" in this checker any variance is
+ likely to be caused by the pylint system."""
+
+ __implements__ = (pylint.interfaces.IRawChecker,)
+
+ name = "sleeper"
+ msgs = {
+ "R9999": (
+ "Test",
+ "test-check",
+ "Some helpful text.",
+ )
+ }
+ sleep_duration = 0.5 # the time to pretend we're doing work for
+
+ def process_module(self, _astroid):
+ """Sleeps for `sleep_duration` on each call
+
+ This effectively means each file costs ~`sleep_duration`+framework overhead"""
+ time.sleep(self.sleep_duration)
+
+
+class SleepingCheckerLong(BaseChecker):
+ """A checker that sleeps, the wall-clock time should reduce as we add workers
+
+ As we apply a roughly constant amount of "work" in this checker any variance is
+ likely to be caused by the pylint system."""
+
+ __implements__ = (pylint.interfaces.IRawChecker,)
+
+ name = "long-sleeper"
+ msgs = {
+ "R9999": (
+ "Test",
+ "test-check",
+ "Some helpful text.",
+ )
+ }
+ sleep_duration = 0.5 # the time to pretend we're doing work for
+
+ def process_module(self, _astroid):
+ """Sleeps for `sleep_duration` on each call
+
+ This effectively means each file costs ~`sleep_duration`+framework overhead"""
+ time.sleep(self.sleep_duration)
+
+
+class NoWorkChecker(BaseChecker):
+ """A checker that sleeps, the wall-clock time should change as we add threads"""
+
+ __implements__ = (pylint.interfaces.IRawChecker,)
+
+ name = "sleeper"
+ msgs = {
+ "R9999": (
+ "Test",
+ "test-check",
+ "Some helpful text.",
+ )
+ }
+
+ def process_module(self, _astroid):
+ pass
+
+
+@pytest.mark.benchmark(
+ group="baseline",
+)
+class TestEstablishBaselineBenchmarks:
+ """Naive benchmarks for the high-level pylint framework
+
+ Because this benchmarks the fundemental and common parts and changes seen here will
+ impact everything else"""
+
+ empty_filepath = _empty_filepath()
+ empty_file_info = (
+ "name-emptyfile-file",
+ _empty_filepath(),
+ "modname-emptyfile-mod",
+ )
+ lot_of_files = 500
+
+ def test_baseline_benchmark_j1(self, benchmark):
+ """Establish a baseline of pylint performance with no work
+
+ We will add extra Checkers in other benchmarks.
+
+ Because this is so simple, if this regresses something very serious has happened
+ """
+ linter = PyLinter(reporter=Reporter())
+ fileinfos = [self.empty_filepath] # Single file to end-to-end the system
+ assert linter.config.jobs == 1
+ assert len(linter._checkers) == 1, "Should just have 'master'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_benchmark_j10(self, benchmark):
+ """Establish a baseline of pylint performance with no work across threads
+
+ Same as `test_baseline_benchmark_j1` but we use -j10 with 10 fake files to
+ ensure end-to-end-system invoked.
+
+ Because this is also so simple, if this regresses something very serious has
+ happened.
+ """
+ linter = PyLinter(reporter=Reporter())
+ linter.config.jobs = 10
+
+ # Create file per worker, using all workers
+ fileinfos = [self.empty_filepath for _ in range(linter.config.jobs)]
+
+ assert linter.config.jobs == 10
+ assert len(linter._checkers) == 1, "Should have 'master'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_benchmark_check_parallel_j10(self, benchmark):
+ """Should demonstrate times very close to `test_baseline_benchmark_j10`"""
+ linter = PyLinter(reporter=Reporter())
+
+ # Create file per worker, using all workers
+ fileinfos = [self.empty_file_info for _ in range(linter.config.jobs)]
+
+ assert len(linter._checkers) == 1, "Should have 'master'"
+ benchmark(check_parallel, linter, jobs=10, files=fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_lots_of_files_j1(self, benchmark):
+ """Establish a baseline with only 'master' checker being run in -j1
+
+ We do not register any checkers except the default 'master', so the cost is just
+ that of the system with a lot of files registerd"""
+ if benchmark.disabled:
+ benchmark(print, "skipping, only benchmark large file counts")
+ return # _only_ run this test is profiling
+ linter = PyLinter(reporter=Reporter())
+ linter.config.jobs = 1
+ fileinfos = [self.empty_filepath for _ in range(self.lot_of_files)]
+ assert linter.config.jobs == 1
+ assert len(linter._checkers) == 1, "Should have 'master'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_lots_of_files_j10(self, benchmark):
+ """Establish a baseline with only 'master' checker being run in -j10
+
+ As with the -j1 variant above `test_baseline_lots_of_files_j1`, we do not
+ register any checkers except the default 'master', so the cost is just that of
+ the check_parallel system across 10 workers, plus the overhead of PyLinter"""
+ if benchmark.disabled:
+ benchmark(print, "skipping, only benchmark large file counts")
+ return # _only_ run this test is profiling
+ linter = PyLinter(reporter=Reporter())
+ linter.config.jobs = 10
+ fileinfos = [self.empty_filepath for _ in range(self.lot_of_files)]
+ assert linter.config.jobs == 10
+ assert len(linter._checkers) == 1, "Should have 'master'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_lots_of_files_j1_empty_checker(self, benchmark):
+ """Baselines pylint for a single extra checker being run in -j1, for N-files
+
+ We use a checker that does no work, so the cost is just that of the system at
+ scale"""
+ if benchmark.disabled:
+ benchmark(print, "skipping, only benchmark large file counts")
+ return # _only_ run this test is profiling
+ linter = PyLinter(reporter=Reporter())
+ linter.config.jobs = 1
+ linter.register_checker(NoWorkChecker(linter))
+ fileinfos = [self.empty_filepath for _ in range(self.lot_of_files)]
+ assert linter.config.jobs == 1
+ assert len(linter._checkers) == 2, "Should have 'master' and 'sleeper'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_lots_of_files_j10_empty_checker(self, benchmark):
+ """Baselines pylint for a single extra checker being run in -j10, for N-files
+
+ We use a checker that does no work, so the cost is just that of the system at
+ scale, across workers"""
+ if benchmark.disabled:
+ benchmark(print, "skipping, only benchmark large file counts")
+ return # _only_ run this test is profiling
+ linter = PyLinter(reporter=Reporter())
+ linter.config.jobs = 10
+ linter.register_checker(NoWorkChecker(linter))
+ fileinfos = [self.empty_filepath for _ in range(self.lot_of_files)]
+ assert linter.config.jobs == 10
+ assert len(linter._checkers) == 2, "Should have 'master' and 'sleeper'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_benchmark_j1_single_working_checker(self, benchmark):
+ """Establish a baseline of single-worker performance for PyLinter
+
+ Here we mimick a single Checker that does some work so that we can see the
+ impact of running a simple system with -j1 against the same system with -j10.
+
+ We expect this benchmark to take very close to
+ `numfiles*SleepingChecker.sleep_duration`"""
+ if benchmark.disabled:
+ benchmark(print, "skipping, do not want to sleep in main tests")
+ return # _only_ run this test is profiling
+ linter = PyLinter(reporter=Reporter())
+ linter.register_checker(SleepingChecker(linter))
+
+ # Check the same number of files as
+ # `test_baseline_benchmark_j10_single_working_checker`
+ fileinfos = [self.empty_filepath for _ in range(10)]
+
+ assert linter.config.jobs == 1
+ assert len(linter._checkers) == 2, "Should have 'master' and 'sleeper'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_benchmark_j10_single_working_checker(self, benchmark):
+ """Establishes baseline of multi-worker performance for PyLinter/check_parallel
+
+ We expect this benchmark to take less time that test_baseline_benchmark_j1,
+ `error_margin*(1/J)*(numfiles*SleepingChecker.sleep_duration)`
+
+ Because of the cost of the framework and system the performance difference will
+ *not* be 1/10 of -j1 versions."""
+ if benchmark.disabled:
+ benchmark(print, "skipping, do not want to sleep in main tests")
+ return # _only_ run this test is profiling
+ linter = PyLinter(reporter=Reporter())
+ linter.config.jobs = 10
+ linter.register_checker(SleepingChecker(linter))
+
+ # Check the same number of files as
+ # `test_baseline_benchmark_j1_single_working_checker`
+ fileinfos = [self.empty_filepath for _ in range(10)]
+
+ assert linter.config.jobs == 10
+ assert len(linter._checkers) == 2, "Should have 'master' and 'sleeper'"
+ benchmark(linter.check, fileinfos)
+ assert (
+ linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ linter.reporter.messages
+ )
+
+ def test_baseline_benchmark_j1_all_checks_single_file(self, benchmark):
+ """Runs a single file, with -j1, against all plug-ins
+
+ ... that's the intent at least.
+ """
+ # Just 1 file, but all Checkers/Extensions
+ fileinfos = [self.empty_filepath]
+
+ runner = benchmark(Run, fileinfos, reporter=Reporter(), exit=False)
+ assert runner.linter.config.jobs == 1
+ print("len(runner.linter._checkers)", len(runner.linter._checkers))
+ assert len(runner.linter._checkers) > 1, "Should have more than 'master'"
+
+ assert (
+ runner.linter.msg_status == 0
+ ), "Expected no errors to be thrown: %s" % pprint.pformat(
+ runner.linter.reporter.messages
+ )
+
+ def test_baseline_benchmark_j1_all_checks_lots_of_files(self, benchmark):
+ """Runs lots of files, with -j1, against all plug-ins
+
+ ... that's the intent at least.
+ """
+ if benchmark.disabled:
+ benchmark(print, "skipping, only benchmark large file counts")
+ return # _only_ run this test is profiling
+ linter = PyLinter()
+
+ # Register all checkers/extensions and enable them
+ with patch("os.listdir", return_value=["pylint", "tests"]):
+ register_plugins(
+ linter,
+ os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")),
+ )
+ linter.load_default_plugins()
+ linter.enable("all")
+
+ # Just 1 file, but all Checkers/Extensions
+ fileinfos = [self.empty_filepath for _ in range(self.lot_of_files)]
+
+ assert linter.config.jobs == 1
+ print("len(linter._checkers)", len(linter._checkers))
+ assert len(linter._checkers) > 1, "Should have more than 'master'"
+ benchmark(linter.check, fileinfos)
diff --git a/tests/checkers/__init__.py b/tests/checkers/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/checkers/__init__.py
diff --git a/tests/checkers/conftest.py b/tests/checkers/conftest.py
new file mode 100644
index 0000000..e831015
--- /dev/null
+++ b/tests/checkers/conftest.py
@@ -0,0 +1,4 @@
+from pathlib import Path
+
+HERE = Path(__file__).parent
+REGR_DATA = HERE / ".." / "regrtest_data"
diff --git a/tests/checkers/unittest_base.py b/tests/checkers/unittest_base.py
new file mode 100644
index 0000000..a210d67
--- /dev/null
+++ b/tests/checkers/unittest_base.py
@@ -0,0 +1,679 @@
+# Copyright (c) 2013-2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Yannack <yannack@users.noreply.github.com>
+# Copyright (c) 2017, 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2017, 2019 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2017 ttenhoeve-aa <ttenhoeve@appannie.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Fureigh <fureigh@users.noreply.github.com>
+# Copyright (c) 2018 glmdgrielson <32415403+glmdgrielson@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020-2021 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 ethan-leba <ethanleba5@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2020 bernie gray <bfgray3@users.noreply.github.com>
+# Copyright (c) 2021 Or Bahari <orbahari@mail.tau.ac.il>
+# Copyright (c) 2021 David Gilman <davidgilman1@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unittest for the base checker."""
+
+import re
+import sys
+import unittest
+from typing import Dict, Type
+
+import astroid
+
+from pylint.checkers import BaseChecker, base
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstring(CheckerTestCase):
+ CHECKER_CLASS: Type = base.DocStringChecker
+
+ def test_missing_docstring_module(self):
+ module = astroid.parse("something")
+ message = Message("missing-module-docstring", node=module)
+ with self.assertAddsMessages(message):
+ self.checker.visit_module(module)
+
+ def test_missing_docstring_empty_module(self):
+ module = astroid.parse("")
+ with self.assertNoMessages():
+ self.checker.visit_module(module)
+
+ def test_empty_docstring_module(self):
+ module = astroid.parse("''''''")
+ message = Message("empty-docstring", node=module, args=("module",))
+ with self.assertAddsMessages(message):
+ self.checker.visit_module(module)
+
+ def test_empty_docstring_function(self):
+ func = astroid.extract_node(
+ """
+ def func(tion):
+ pass"""
+ )
+ message = Message("missing-function-docstring", node=func)
+ with self.assertAddsMessages(message):
+ self.checker.visit_functiondef(func)
+
+ @set_config(docstring_min_length=2)
+ def test_short_function_no_docstring(self):
+ func = astroid.extract_node(
+ """
+ def func(tion):
+ pass"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(func)
+
+ @set_config(docstring_min_length=2)
+ def test_long_function_no_docstring(self):
+ func = astroid.extract_node(
+ """
+ def func(tion):
+ pass
+ pass
+ """
+ )
+ message = Message("missing-function-docstring", node=func)
+ with self.assertAddsMessages(message):
+ self.checker.visit_functiondef(func)
+
+ @set_config(docstring_min_length=2)
+ def test_long_function_nested_statements_no_docstring(self):
+ func = astroid.extract_node(
+ """
+ def func(tion):
+ try:
+ pass
+ except:
+ pass
+ """
+ )
+ message = Message("missing-function-docstring", node=func)
+ with self.assertAddsMessages(message):
+ self.checker.visit_functiondef(func)
+
+ @set_config(docstring_min_length=2)
+ def test_function_no_docstring_by_name(self):
+ func = astroid.extract_node(
+ """
+ def __fun__(tion):
+ pass"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(func)
+
+ def test_class_no_docstring(self):
+ klass = astroid.extract_node(
+ """
+ class Klass(object):
+ pass"""
+ )
+ message = Message("missing-class-docstring", node=klass)
+ with self.assertAddsMessages(message):
+ self.checker.visit_classdef(klass)
+
+ def test_inner_function_no_docstring(self):
+ func = astroid.extract_node(
+ """
+ def func(tion):
+ \"""Documented\"""
+ def inner(fun):
+ # Not documented
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(func)
+
+
+class TestNameChecker(CheckerTestCase):
+ CHECKER_CLASS: Type = base.NameChecker
+ CONFIG: Dict = {"bad_names": set()}
+
+ @set_config(
+ attr_rgx=re.compile("[A-Z]+"),
+ property_classes=("abc.abstractproperty", ".custom_prop"),
+ )
+ def test_property_names(self):
+ # If a method is annotated with @property, its name should
+ # match the attr regex. Since by default the attribute regex is the same
+ # as the method regex, we override it here.
+ methods = astroid.extract_node(
+ """
+ import abc
+
+ def custom_prop(f):
+ return property(f)
+
+ class FooClass(object):
+ @property
+ def FOO(self): #@
+ pass
+
+ @property
+ def bar(self): #@
+ pass
+
+ @abc.abstractproperty
+ def BAZ(self): #@
+ pass
+
+ @custom_prop
+ def QUX(self): #@
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(methods[0])
+ self.checker.visit_functiondef(methods[2])
+ self.checker.visit_functiondef(methods[3])
+ with self.assertAddsMessages(
+ Message(
+ "invalid-name",
+ node=methods[1],
+ args=("Attribute", "bar", "'[A-Z]+' pattern"),
+ )
+ ):
+ self.checker.visit_functiondef(methods[1])
+
+ @set_config(attr_rgx=re.compile("[A-Z]+"))
+ def test_property_setters(self):
+ method = astroid.extract_node(
+ """
+ class FooClass(object):
+ @property
+ def foo(self): pass
+
+ @foo.setter
+ def FOOSETTER(self): #@
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(method)
+
+ def test_module_level_names(self):
+ assign = astroid.extract_node(
+ """
+ import collections
+ Class = collections.namedtuple("a", ("b", "c")) #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_assignname(assign.targets[0])
+
+ assign = astroid.extract_node(
+ """
+ class ClassA(object):
+ pass
+ ClassB = ClassA
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_assignname(assign.targets[0])
+
+ module = astroid.parse(
+ """
+ def A():
+ return 1, 2, 3
+ CONSTA, CONSTB, CONSTC = A()
+ CONSTD = A()"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_assignname(module.body[1].targets[0].elts[0])
+ self.checker.visit_assignname(module.body[2].targets[0])
+
+ assign = astroid.extract_node(
+ """
+ CONST = "12 34 ".rstrip().split()"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_assignname(assign.targets[0])
+
+ @unittest.skipIf(sys.version_info >= (3, 7), reason="Needs Python 3.6 or earlier")
+ @set_config(const_rgx=re.compile(".+"))
+ @set_config(function_rgx=re.compile(".+"))
+ @set_config(class_rgx=re.compile(".+"))
+ def test_assign_to_new_keyword_py3(self):
+ ast = astroid.extract_node(
+ """
+ async = "foo" #@
+ await = "bar" #@
+ def async(): #@
+ pass
+ class async: #@
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="assign-to-new-keyword",
+ node=ast[0].targets[0],
+ args=("async", "3.7"),
+ )
+ ):
+ self.checker.visit_assignname(ast[0].targets[0])
+ with self.assertAddsMessages(
+ Message(
+ msg_id="assign-to-new-keyword",
+ node=ast[1].targets[0],
+ args=("await", "3.7"),
+ )
+ ):
+ self.checker.visit_assignname(ast[1].targets[0])
+ with self.assertAddsMessages(
+ Message(msg_id="assign-to-new-keyword", node=ast[2], args=("async", "3.7"))
+ ):
+ self.checker.visit_functiondef(ast[2])
+ with self.assertAddsMessages(
+ Message(msg_id="assign-to-new-keyword", node=ast[3], args=("async", "3.7"))
+ ):
+ self.checker.visit_classdef(ast[3])
+
+
+class TestMultiNamingStyle(CheckerTestCase):
+ CHECKER_CLASS = base.NameChecker
+
+ MULTI_STYLE_RE = re.compile("(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$")
+
+ @set_config(class_rgx=MULTI_STYLE_RE)
+ def test_multi_name_detection_majority(self):
+ classes = astroid.extract_node(
+ """
+ class classb(object): #@
+ pass
+ class CLASSA(object): #@
+ pass
+ class CLASSC(object): #@
+ pass
+ """
+ )
+ message = Message(
+ "invalid-name",
+ node=classes[0],
+ args=("Class", "classb", "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern"),
+ )
+ with self.assertAddsMessages(message):
+ cls = None
+ for cls in classes:
+ self.checker.visit_classdef(cls)
+ if cls:
+ self.checker.leave_module(cls.root)
+
+ @set_config(class_rgx=MULTI_STYLE_RE)
+ def test_multi_name_detection_first_invalid(self):
+ classes = astroid.extract_node(
+ """
+ class class_a(object): #@
+ pass
+ class classb(object): #@
+ pass
+ class CLASSC(object): #@
+ pass
+ """
+ )
+ messages = [
+ Message(
+ "invalid-name",
+ node=classes[0],
+ args=(
+ "Class",
+ "class_a",
+ "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern",
+ ),
+ ),
+ Message(
+ "invalid-name",
+ node=classes[2],
+ args=(
+ "Class",
+ "CLASSC",
+ "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern",
+ ),
+ ),
+ ]
+ with self.assertAddsMessages(*messages):
+ cls = None
+ for cls in classes:
+ self.checker.visit_classdef(cls)
+ if cls:
+ self.checker.leave_module(cls.root)
+
+ @set_config(
+ method_rgx=MULTI_STYLE_RE,
+ function_rgx=MULTI_STYLE_RE,
+ name_group=("function:method",),
+ )
+ def test_multi_name_detection_group(self):
+ function_defs = astroid.extract_node(
+ """
+ class First(object):
+ def func(self): #@
+ pass
+
+ def FUNC(): #@
+ pass
+ """,
+ module_name="test",
+ )
+ message = Message(
+ "invalid-name",
+ node=function_defs[1],
+ args=("Function", "FUNC", "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern"),
+ )
+ with self.assertAddsMessages(message):
+ func = None
+ for func in function_defs:
+ self.checker.visit_functiondef(func)
+ if func:
+ self.checker.leave_module(func.root)
+
+ @set_config(
+ function_rgx=re.compile("(?:(?P<ignore>FOO)|(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$")
+ )
+ def test_multi_name_detection_exempt(self):
+ function_defs = astroid.extract_node(
+ """
+ def FOO(): #@
+ pass
+ def lower(): #@
+ pass
+ def FOO(): #@
+ pass
+ def UPPER(): #@
+ pass
+ """
+ )
+ message = Message(
+ "invalid-name",
+ node=function_defs[3],
+ args=(
+ "Function",
+ "UPPER",
+ "'(?:(?P<ignore>FOO)|(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern",
+ ),
+ )
+ with self.assertAddsMessages(message):
+ func = None
+ for func in function_defs:
+ self.checker.visit_functiondef(func)
+ if func:
+ self.checker.leave_module(func.root)
+
+
+class TestComparison(CheckerTestCase):
+ CHECKER_CLASS = base.ComparisonChecker
+
+ def test_comparison(self):
+ node = astroid.extract_node("foo == True")
+ message = Message(
+ "singleton-comparison",
+ node=node,
+ args=(
+ "'foo == True'",
+ "'foo is True' if checking for the singleton value True, or 'bool(foo)' if testing for truthiness",
+ ),
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node("foo == False")
+ message = Message(
+ "singleton-comparison",
+ node=node,
+ args=(
+ "'foo == False'",
+ "'foo is False' if checking for the singleton value False, or 'not foo' if testing for falsiness",
+ ),
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node("foo == None")
+ message = Message(
+ "singleton-comparison", node=node, args=("'foo == None'", "'foo is None'")
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node("foo is float('nan')")
+ message = Message(
+ "nan-comparison",
+ node=node,
+ args=("'foo is float('nan')'", "'math.isnan(foo)'"),
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node(
+ """
+ import numpy
+ foo != numpy.NaN
+ """
+ )
+ message = Message(
+ "nan-comparison",
+ node=node,
+ args=("'foo != numpy.NaN'", "'not math.isnan(foo)'"),
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node(
+ """
+ import numpy as nmp
+ foo is not nmp.NaN
+ """
+ )
+ message = Message(
+ "nan-comparison",
+ node=node,
+ args=("'foo is not nmp.NaN'", "'not math.isnan(foo)'"),
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node("True == foo")
+ messages = (
+ Message("misplaced-comparison-constant", node=node, args=("foo == True",)),
+ Message(
+ "singleton-comparison",
+ node=node,
+ args=(
+ "'True == foo'",
+ "'True is foo' if checking for the singleton value True, or 'bool(foo)' if testing for truthiness",
+ ),
+ ),
+ )
+ with self.assertAddsMessages(*messages):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node("False == foo")
+ messages = (
+ Message("misplaced-comparison-constant", node=node, args=("foo == False",)),
+ Message(
+ "singleton-comparison",
+ node=node,
+ args=(
+ "'False == foo'",
+ "'False is foo' if checking for the singleton value False, or 'not foo' if testing for falsiness",
+ ),
+ ),
+ )
+ with self.assertAddsMessages(*messages):
+ self.checker.visit_compare(node)
+
+ node = astroid.extract_node("None == foo")
+ messages = (
+ Message("misplaced-comparison-constant", node=node, args=("foo == None",)),
+ Message(
+ "singleton-comparison",
+ node=node,
+ args=("'None == foo'", "'None is foo'"),
+ ),
+ )
+ with self.assertAddsMessages(*messages):
+ self.checker.visit_compare(node)
+
+
+class TestNamePresets(unittest.TestCase):
+ SNAKE_CASE_NAMES = {"tést_snake_case", "test_snake_case11", "test_https_200"}
+ CAMEL_CASE_NAMES = {"téstCamelCase", "testCamelCase11", "testHTTP200"}
+ UPPER_CASE_NAMES = {"TÉST_UPPER_CASE", "TEST_UPPER_CASE11", "TEST_HTTP_200"}
+ PASCAL_CASE_NAMES = {"TéstPascalCase", "TestPascalCase11", "TestHTTP200"}
+ ALL_NAMES = (
+ SNAKE_CASE_NAMES | CAMEL_CASE_NAMES | UPPER_CASE_NAMES | PASCAL_CASE_NAMES
+ )
+
+ def _test_name_is_correct_for_all_name_types(self, naming_style, name):
+ for name_type in base.KNOWN_NAME_TYPES:
+ self._test_is_correct(naming_style, name, name_type)
+
+ def _test_name_is_incorrect_for_all_name_types(self, naming_style, name):
+ for name_type in base.KNOWN_NAME_TYPES:
+ self._test_is_incorrect(naming_style, name, name_type)
+
+ def _test_should_always_pass(self, naming_style):
+ always_pass_data = [
+ ("__add__", "method"),
+ ("__set_name__", "method"),
+ ("__version__", "const"),
+ ("__author__", "const"),
+ ]
+ for name, name_type in always_pass_data:
+ self._test_is_correct(naming_style, name, name_type)
+
+ @staticmethod
+ def _test_is_correct(naming_style, name, name_type):
+ rgx = naming_style.get_regex(name_type)
+ fail = f"{name!r} does not match pattern {rgx!r} (style: {naming_style}, type: {name_type})"
+ assert rgx.match(name), fail
+
+ @staticmethod
+ def _test_is_incorrect(naming_style, name, name_type):
+ rgx = naming_style.get_regex(name_type)
+ fail = f"{name!r} not match pattern {rgx!r} (style: {naming_style}, type: {name_type})"
+ assert not rgx.match(name), fail
+
+ def test_snake_case(self):
+ naming_style = base.SnakeCaseStyle
+
+ for name in self.SNAKE_CASE_NAMES:
+ self._test_name_is_correct_for_all_name_types(naming_style, name)
+ for name in self.ALL_NAMES - self.SNAKE_CASE_NAMES:
+ self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+
+ self._test_should_always_pass(naming_style)
+
+ def test_camel_case(self):
+ naming_style = base.CamelCaseStyle
+
+ for name in self.CAMEL_CASE_NAMES:
+ self._test_name_is_correct_for_all_name_types(naming_style, name)
+ for name in self.ALL_NAMES - self.CAMEL_CASE_NAMES:
+ self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+
+ self._test_should_always_pass(naming_style)
+
+ def test_upper_case(self):
+ naming_style = base.UpperCaseStyle
+
+ for name in self.UPPER_CASE_NAMES:
+ self._test_name_is_correct_for_all_name_types(naming_style, name)
+ for name in self.ALL_NAMES - self.UPPER_CASE_NAMES:
+ self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+ self._test_name_is_incorrect_for_all_name_types(naming_style, "UPPERcase")
+
+ self._test_should_always_pass(naming_style)
+
+ def test_pascal_case(self):
+ naming_style = base.PascalCaseStyle
+
+ for name in self.PASCAL_CASE_NAMES:
+ self._test_name_is_correct_for_all_name_types(naming_style, name)
+ for name in self.ALL_NAMES - self.PASCAL_CASE_NAMES:
+ self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+
+ self._test_should_always_pass(naming_style)
+
+
+class TestBaseChecker(unittest.TestCase):
+ def test_doc(self):
+ class OtherBasicChecker(BaseChecker):
+ name = "basic"
+ msgs = {
+ "W0001": (
+ "Basic checker has an example.",
+ "basic-checker-example",
+ "Used nowhere and serves no purpose.",
+ )
+ }
+
+ class LessBasicChecker(OtherBasicChecker):
+ options = (
+ (
+ "example-args",
+ {
+ "default": 42,
+ "type": "int",
+ "metavar": "<int>",
+ "help": "Example of integer argument for the checker.",
+ },
+ ),
+ )
+
+ basic = OtherBasicChecker()
+ expected_beginning = """\
+Basic checker
+~~~~~~~~~~~~~
+
+Verbatim name of the checker is ``basic``.
+
+"""
+ expected_middle = """\
+Basic checker Options
+^^^^^^^^^^^^^^^^^^^^^
+:example-args:
+ Example of integer argument for the checker.
+
+ Default: ``42``
+
+"""
+ expected_end = """\
+Basic checker Messages
+^^^^^^^^^^^^^^^^^^^^^^
+:basic-checker-example (W0001): *Basic checker has an example.*
+ Used nowhere and serves no purpose.
+
+
+"""
+ self.assertEqual(str(basic), expected_beginning + expected_end)
+ self.assertEqual(repr(basic), "Checker 'basic' (responsible for 'W0001')")
+ less_basic = LessBasicChecker()
+
+ self.assertEqual(
+ str(less_basic), expected_beginning + expected_middle + expected_end
+ )
+ self.assertEqual(repr(less_basic), repr(basic))
+
+
+class TestNoSix(unittest.TestCase):
+ @unittest.skip("too many dependencies need six :(")
+ def test_no_six(self):
+ try:
+ has_six = True
+ except ImportError:
+ has_six = False
+
+ self.assertFalse(has_six, "pylint must be able to run without six")
diff --git a/tests/checkers/unittest_classes.py b/tests/checkers/unittest_classes.py
new file mode 100644
index 0000000..47ac02d
--- /dev/null
+++ b/tests/checkers/unittest_classes.py
@@ -0,0 +1,245 @@
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019-2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@users.noreply.github.com>
+# Copyright (c) 2021 tiagohonorato <61059243+tiagohonorato@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the variables checker."""
+import astroid
+
+from pylint.checkers import classes
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestVariablesChecker(CheckerTestCase):
+
+ CHECKER_CLASS = classes.ClassChecker
+
+ def test_bitbucket_issue_164(self):
+ """Issue 164 report a false negative for access-member-before-definition"""
+ n1, n2 = astroid.extract_node(
+ """
+ class MyClass1:
+ def __init__(self):
+ self.first += 5 #@
+ self.first = 0 #@
+ """
+ )
+ message = Message(
+ "access-member-before-definition", node=n1.target, args=("first", n2.lineno)
+ )
+ with self.assertAddsMessages(message):
+ self.walk(n1.root())
+
+ @set_config(exclude_protected=("_meta", "_manager"))
+ def test_exclude_protected(self):
+ """Test that exclude-protected can be used to
+ exclude names from protected-access warning.
+ """
+
+ node = astroid.parse(
+ """
+ class Protected:
+ '''empty'''
+ def __init__(self):
+ self._meta = 42
+ self._manager = 24
+ self._teta = 29
+ OBJ = Protected()
+ OBJ._meta
+ OBJ._manager
+ OBJ._teta
+ """
+ )
+ with self.assertAddsMessages(
+ Message("protected-access", node=node.body[-1].value, args="_teta")
+ ):
+ self.walk(node.root())
+
+ def test_regression_non_parent_init_called_tracemalloc(self):
+ # This used to raise a non-parent-init-called on Pylint 1.3
+ # See issue https://bitbucket.org/logilab/pylint/issue/308/
+ # for reference.
+ node = astroid.extract_node(
+ """
+ from tracemalloc import Sequence
+ class _Traces(Sequence):
+ def __init__(self, traces): #@
+ Sequence.__init__(self)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_super_init_not_called_regression(self):
+ # This should not emit a super-init-not-called
+ # warning. It previously did this, because
+ # ``next(node.infer())`` was used in that checker's
+ # logic and the first inferred node was an Uninferable object,
+ # leading to this false positive.
+ node = astroid.extract_node(
+ """
+ import ctypes
+
+ class Foo(ctypes.BigEndianStructure):
+ def __init__(self): #@
+ ctypes.BigEndianStructure.__init__(self)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_uninferable_attribute(self):
+ """Make sure protect-access doesn't raise an exception Uninferable attributes"""
+
+ node = astroid.extract_node(
+ """
+ class MC():
+ @property
+ def nargs(self):
+ return 1 if self._nargs else 2
+
+ class Application(metaclass=MC):
+ def __no_special__(cls):
+ nargs = obj._nargs #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message("protected-access", node=node.value, args="_nargs")
+ ):
+ self.checker.visit_attribute(node.value)
+
+ @set_config(check_protected_access_in_special_methods=True)
+ def test_check_protected_access_in_special_methods(self):
+ """Test that check-protected-access-in-special-methods can be used to
+ trigger protected-access message emission for single underscore prefixed names
+ inside special methods
+ """
+
+ node = astroid.parse(
+ """
+ class Protected:
+ '''empty'''
+ def __init__(self):
+ self._protected = 42
+ self.public = "A"
+ self.__private = None
+ def __eq__(self, other):
+ self._protected = other._protected
+ def _fake_special_(self, other):
+ a = other.public
+ self.public = other._protected
+ self.__private = other.__private
+ """
+ )
+ classdef = node.body[-1]
+ assign_attribute_in_eq = classdef.instance_attr("_protected")[-1]
+ attribute_in_eq = list(assign_attribute_in_eq.assigned_stmts())[-1]
+ assign_attribute_in_fake_1 = classdef.instance_attr("public")[-1]
+ attribute_in_fake_1 = list(assign_attribute_in_fake_1.assigned_stmts())[-1]
+ assign_attribute_in_fake_2 = classdef.instance_attr("__private")[-1]
+ attribute_in_fake_2 = list(assign_attribute_in_fake_2.assigned_stmts())[-1]
+ unused_private_attr_1 = classdef.instance_attr("__private")[0]
+ unused_private_attr_2 = classdef.instance_attr("__private")[1]
+ with self.assertAddsMessages(
+ Message("protected-access", node=attribute_in_eq, args="_protected"),
+ Message("protected-access", node=attribute_in_fake_1, args="_protected"),
+ Message("protected-access", node=attribute_in_fake_2, args="__private"),
+ Message(
+ "unused-private-member",
+ node=unused_private_attr_1,
+ args=("Protected", "__private"),
+ ),
+ Message(
+ "unused-private-member",
+ node=unused_private_attr_2,
+ args=("Protected", "__private"),
+ ),
+ ):
+ self.walk(node.root())
+
+ @set_config(check_protected_access_in_special_methods=False)
+ def test_check_protected_access_in_special_methods_deact(self):
+ """Test that when check-protected-access-in-special-methods is False (default)
+ no protected-access message emission for single underscore prefixed names
+ inside special methods occur
+ """
+
+ node = astroid.parse(
+ """
+ class Protected:
+ '''empty'''
+ def __init__(self):
+ self._protected = 42
+ self.public = "A"
+ self.__private = None
+ def __eq__(self, other):
+ self._protected = other._protected
+ def _fake_special_(self, other):
+ a = other.public
+ self.public = other._protected
+ self.__private = other.__private
+ """
+ )
+ classdef = node.body[-1]
+ assign_attribute_in_fake_1 = classdef.instance_attr("public")[-1]
+ attribute_in_fake_1 = list(assign_attribute_in_fake_1.assigned_stmts())[-1]
+ assign_attribute_in_fake_2 = classdef.instance_attr("__private")[-1]
+ attribute_in_fake_2 = list(assign_attribute_in_fake_2.assigned_stmts())[-1]
+ unused_private_attr_1 = classdef.instance_attr("__private")[0]
+ unused_private_attr_2 = classdef.instance_attr("__private")[1]
+ with self.assertAddsMessages(
+ Message("protected-access", node=attribute_in_fake_1, args="_protected"),
+ Message("protected-access", node=attribute_in_fake_2, args="__private"),
+ Message(
+ "unused-private-member",
+ node=unused_private_attr_1,
+ args=("Protected", "__private"),
+ ),
+ Message(
+ "unused-private-member",
+ node=unused_private_attr_2,
+ args=("Protected", "__private"),
+ ),
+ ):
+ self.walk(node.root())
+
+ def test_private_attribute_hides_method(self):
+ node = astroid.extract_node(
+ """
+ class Parent:
+ def __init__(self):
+ self.__private = None
+
+ class Child(Parent):
+ def __private(self): #@
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_protected_attribute_hides_method(self):
+ node = astroid.extract_node(
+ """
+ class Parent:
+ def __init__(self):
+ self._protected = None
+
+ class Child(Parent):
+ def _protected(self): #@
+ pass
+ """
+ )
+ with self.assertAddsMessages(Message("method-hidden", node=node, args=("", 4))):
+ self.checker.visit_functiondef(node)
diff --git a/tests/checkers/unittest_deprecated.py b/tests/checkers/unittest_deprecated.py
new file mode 100644
index 0000000..2da2bce
--- /dev/null
+++ b/tests/checkers/unittest_deprecated.py
@@ -0,0 +1,526 @@
+import astroid
+
+from pylint.checkers import BaseChecker, DeprecatedMixin
+from pylint.interfaces import UNDEFINED, IAstroidChecker
+from pylint.testutils import CheckerTestCase, Message
+
+
+class _DeprecatedChecker(DeprecatedMixin, BaseChecker):
+ __implements__ = (IAstroidChecker,)
+ name = "deprecated"
+
+ def deprecated_methods(self):
+ return {"deprecated_func", ".Deprecated.deprecated_method"}
+
+ def deprecated_modules(self):
+ return {"deprecated_module"}
+
+ def deprecated_classes(self, module):
+ return ["DeprecatedClass"] if module == "deprecated" else []
+
+ def deprecated_arguments(self, method):
+ if method == "myfunction1":
+ # def myfunction1(arg1, deprecated_arg1='spam')
+ return ((1, "deprecated_arg1"),)
+ if method == "myfunction2":
+ # def myfunction2(arg1, deprecated_arg1, arg2='foo', deprecated_arg2='spam'))
+ return ((1, "deprecated_arg1"), (3, "deprecated_arg2"))
+ if method == "myfunction3":
+ # def myfunction1(arg1, *, deprecated_arg1='spam')
+ return ((None, "deprecated_arg1"),)
+ if method == ".MyClass.mymethod1":
+ # def mymethod1(self, arg1, deprecated_arg1=None)
+ return ((1, "deprecated_arg1"),)
+ if method == ".MyClass.mymethod2":
+ # def mymethod2(self, arg1, deprecated_arg1='bar', arg2='foo', deprecated_arg2='spam'))
+ return ((1, "deprecated_arg1"), (3, "deprecated_arg2"))
+ if method == ".MyClass.mymethod3":
+ # def mymethod1(self, arg1, *, deprecated_arg1=None)
+ return ((None, "deprecated_arg1"),)
+ if method == ".MyClass":
+ # def __init__(self, deprecated_arg=None)
+ return ((0, "deprecated_arg"),)
+ return ()
+
+ def deprecated_decorators(self):
+ return {".deprecated_decorator"}
+
+
+class TestDeprecatedChecker(CheckerTestCase):
+ CHECKER_CLASS = _DeprecatedChecker
+
+ def test_deprecated_function(self):
+ # Tests detecting deprecated function
+ node = astroid.extract_node(
+ """
+ def deprecated_func():
+ pass
+
+ deprecated_func()
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-method",
+ args=("deprecated_func",),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_deprecated_method(self):
+ # Tests detecting deprecated method
+ node = astroid.extract_node(
+ """
+ class Deprecated:
+ def deprecated_method():
+ pass
+
+ d = Deprecated()
+ d.deprecated_method()
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-method",
+ args=("deprecated_method",),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_no_message(self):
+ # Tests not raising error when no deprecated functions/methods are present.
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def mymethod():
+ pass
+
+ MyClass().mymethod()
+
+ def myfunc():
+ pass
+
+ myfunc()
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_function_deprecated_arg(self):
+ # Tests raising error when calling function with deprecated argument
+ node = astroid.extract_node(
+ """
+ def myfunction1(arg1, deprecated_arg1='spam'):
+ pass
+
+ myfunction1(None, 'deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "myfunction1"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_function_deprecated_kwarg(self):
+ # Tests raising error when calling function with deprecated keyword argument
+ node = astroid.extract_node(
+ """
+ def myfunction1(arg1, deprecated_arg1='spam'):
+ pass
+
+ myfunction1(None, deprecated_arg1='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "myfunction1"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_function_deprecated_not_used(self):
+ # Tests raising error when calling function without deprecated argument
+ node = astroid.extract_node(
+ """
+ def myfunction1(arg1, deprecated_arg1='spam'):
+ pass
+
+ myfunction1(None)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_function_deprecated_kwarg_only(self):
+ # Tests raising error when calling function with deprecated keyword only argument
+ node = astroid.extract_node(
+ """
+ def myfunction3(arg1, *, deprecated_arg1='spam'):
+ pass
+
+ myfunction3(None, deprecated_arg1='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "myfunction3"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_method_deprecated_arg(self):
+ # Tests raising error when calling method with deprecated argument
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def mymethod1(self, arg1, deprecated_arg1):
+ pass
+
+ MyClass().mymethod1(None, 'deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "mymethod1"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_method_deprecated_kwarg(self):
+ # Tests raising error when calling method with deprecated keyword argument
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def mymethod1(self, arg1, deprecated_arg1):
+ pass
+
+ MyClass().mymethod1(None, deprecated_arg1='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "mymethod1"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_method_deprecated_not_used(self):
+ # Tests raising error when calling method without deprecated argument
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def mymethod1(self, arg1, deprecated_arg1):
+ pass
+
+ MyClass().mymethod1(None)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_method_deprecated_kwarg_only(self):
+ # Tests raising error when calling method with deprecated keyword only argument
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def mymethod3(self, arg1, *, deprecated_arg1):
+ pass
+
+ MyClass().mymethod3(None, deprecated_arg1='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "mymethod3"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_function_deprecated_arg_kwargs(self):
+ # Tests raising error when calling function with deprecated argument
+ # and keyword argument
+ node = astroid.extract_node(
+ """
+ def myfunction2(arg1, deprecated_arg1, arg2='foo', deprecated_arg2='spam'):
+ pass
+
+ myfunction2(None, 'deprecated', deprecated_arg2='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "myfunction2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg2", "myfunction2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ ):
+ self.checker.visit_call(node)
+
+ def test_function_deprecated_kwarg_kwarg(self):
+ # Tests raising error when calling function with deprecated keyword arguments
+ node = astroid.extract_node(
+ """
+ def myfunction2(arg1, deprecated_arg1, arg2='foo', deprecated_arg2='spam'):
+ pass
+
+ myfunction2(None, deprecated_arg1='deprecated', deprecated_arg2='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "myfunction2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg2", "myfunction2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ ):
+ self.checker.visit_call(node)
+
+ def test_method_deprecated_arg_kwargs(self):
+ # Tests raising error when calling method with deprecated argument
+ # and keyword argument
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def mymethod2(self, arg1, deprecated_arg1, arg2='foo', deprecated_arg2='spam'):
+ pass
+
+ MyClass().mymethod2(None, 'deprecated', deprecated_arg2='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "mymethod2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg2", "mymethod2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ ):
+ self.checker.visit_call(node)
+
+ def test_method_deprecated_kwarg_kwarg(self):
+ # Tests raising error when calling method with deprecated keyword arguments
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def mymethod2(self, arg1, deprecated_arg1, arg2='foo', deprecated_arg2='spam'):
+ pass
+
+ MyClass().mymethod2(None, deprecated_arg1='deprecated', deprecated_arg2='deprecated')
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg1", "mymethod2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg2", "mymethod2"),
+ node=node,
+ confidence=UNDEFINED,
+ ),
+ ):
+ self.checker.visit_call(node)
+
+ def test_class_deprecated_arguments(self):
+
+ node = astroid.extract_node(
+ """
+ class MyClass:
+ def __init__(self, deprecated_arg=None):
+ pass
+
+ MyClass(5)
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-argument",
+ args=("deprecated_arg", "MyClass"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_deprecated_module(self):
+ # Tests detecting deprecated module
+ node = astroid.extract_node(
+ """
+ import deprecated_module
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-module",
+ args="deprecated_module",
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_import(node)
+
+ def test_deprecated_module_from(self):
+ # Tests detecting deprecated module
+ node = astroid.extract_node(
+ """
+ from deprecated_module import myfunction
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-module",
+ args="deprecated_module",
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_importfrom(node)
+
+ def test_deprecated_class_import_from(self):
+ # Tests detecting deprecated class via import from
+ node = astroid.extract_node(
+ """
+ from .deprecated import DeprecatedClass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-class",
+ args=("DeprecatedClass", "deprecated"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_importfrom(node)
+
+ def test_deprecated_class_import(self):
+ # Tests detecting deprecated class via import
+ node = astroid.extract_node(
+ """
+ import deprecated.DeprecatedClass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-class",
+ args=("DeprecatedClass", "deprecated"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_import(node)
+
+ def test_deprecated_class_call(self):
+ # Tests detecting deprecated class via call
+ node = astroid.extract_node(
+ """
+ import deprecated
+ deprecated.DeprecatedClass()
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-class",
+ args=("DeprecatedClass", "deprecated"),
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_call(node)
+
+ def test_deprecated_decorator(self):
+ # Tests detecting deprecated decorator
+ node = astroid.extract_node(
+ """
+ def deprecated_decorator(f):
+ def wrapper():
+ return f()
+ return wrapper
+
+ @deprecated_decorator #@
+ def function():
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-decorator",
+ args=".deprecated_decorator",
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_decorators(node)
+
+ def test_deprecated_decorator_with_arguments(self):
+ # Tests detecting deprecated decorator with arguments
+ node = astroid.extract_node(
+ """
+ def deprecated_decorator(arg1, arg2):
+ def wrapper(f):
+ def wrapped():
+ return f()
+ return wrapped
+ return wrapper
+
+ @deprecated_decorator(2, 3) #@
+ def function():
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="deprecated-decorator",
+ args=".deprecated_decorator",
+ node=node,
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_decorators(node)
diff --git a/tests/checkers/unittest_exceptions.py b/tests/checkers/unittest_exceptions.py
new file mode 100644
index 0000000..affd5cd
--- /dev/null
+++ b/tests/checkers/unittest_exceptions.py
@@ -0,0 +1,52 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Rene Zhang <rz99@cornell.edu>
+# Copyright (c) 2015 Steven Myint <hg@stevenmyint.com>
+# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Brian Shaginaw <brian.shaginaw@warbyparker.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for pylint.checkers.exceptions."""
+import astroid
+
+from pylint.checkers import exceptions
+from pylint.testutils import CheckerTestCase, Message
+
+
+class TestExceptionsChecker(CheckerTestCase):
+ """Tests for pylint.checkers.exceptions."""
+
+ CHECKER_CLASS = exceptions.ExceptionsChecker
+
+ # These tests aren't in the functional test suite,
+ # since they will be converted with 2to3 for Python 3
+ # and `raise (Error, ...)` will be converted to
+ # `raise Error(...)`, so it beats the purpose of the test.
+
+ def test_raising_bad_type_python3(self):
+ node = astroid.extract_node("raise (ZeroDivisionError, None) #@")
+ message = Message("raising-bad-type", node=node, args="tuple")
+ with self.assertAddsMessages(message):
+ self.checker.visit_raise(node)
+
+ def test_bad_exception_context_function(self):
+ node = astroid.extract_node(
+ """
+ def function():
+ pass
+
+ try:
+ pass
+ except function as exc:
+ raise Exception from exc #@
+ """
+ )
+ message = Message("bad-exception-context", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_raise(node)
diff --git a/tests/checkers/unittest_format.py b/tests/checkers/unittest_format.py
new file mode 100644
index 0000000..8d1c907
--- /dev/null
+++ b/tests/checkers/unittest_format.py
@@ -0,0 +1,279 @@
+# Copyright (c) 2009-2011, 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 buck <buck.2019@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Harut <yes@harutune.name>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Petr Pulc <petrpulc@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Krzysztof Czapla <k.czapla68@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 James M. Allen <james.m.allen@gmail.com>
+# Copyright (c) 2017 vinnyrose <vinnyrose@users.noreply.github.com>
+# Copyright (c) 2018, 2020 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Check format checker helper functions"""
+
+import os
+import tempfile
+import tokenize
+
+import astroid
+
+from pylint import lint, reporters
+from pylint.checkers.format import FormatChecker
+from pylint.testutils import CheckerTestCase, Message, _tokenize_str
+
+
+class TestMultiStatementLine(CheckerTestCase):
+ CHECKER_CLASS = FormatChecker
+
+ def testSingleLineIfStmts(self):
+ stmt = astroid.extract_node(
+ """
+ if True: pass #@
+ """
+ )
+ self.checker.config.single_line_if_stmt = False
+ with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+ self.visitFirst(stmt)
+ self.checker.config.single_line_if_stmt = True
+ with self.assertNoMessages():
+ self.visitFirst(stmt)
+ stmt = astroid.extract_node(
+ """
+ if True: pass #@
+ else:
+ pass
+ """
+ )
+ with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+ self.visitFirst(stmt)
+
+ def testSingleLineClassStmts(self):
+ stmt = astroid.extract_node(
+ """
+ class MyError(Exception): pass #@
+ """
+ )
+ self.checker.config.single_line_class_stmt = False
+ with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+ self.visitFirst(stmt)
+ self.checker.config.single_line_class_stmt = True
+ with self.assertNoMessages():
+ self.visitFirst(stmt)
+
+ stmt = astroid.extract_node(
+ """
+ class MyError(Exception): a='a' #@
+ """
+ )
+ self.checker.config.single_line_class_stmt = False
+ with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+ self.visitFirst(stmt)
+ self.checker.config.single_line_class_stmt = True
+ with self.assertNoMessages():
+ self.visitFirst(stmt)
+
+ stmt = astroid.extract_node(
+ """
+ class MyError(Exception): a='a'; b='b' #@
+ """
+ )
+ self.checker.config.single_line_class_stmt = False
+ with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+ self.visitFirst(stmt)
+ self.checker.config.single_line_class_stmt = True
+ with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+ self.visitFirst(stmt)
+
+ def testTryExceptFinallyNoMultipleStatement(self):
+ tree = astroid.extract_node(
+ """
+ try: #@
+ pass
+ except:
+ pass
+ finally:
+ pass"""
+ )
+ with self.assertNoMessages():
+ self.visitFirst(tree)
+
+ def visitFirst(self, tree):
+ self.checker.process_tokens([])
+ self.checker.visit_default(tree.body[0])
+
+ def test_ellipsis_is_ignored(self):
+ code = """
+ from typing import overload
+ @overload
+ def concat2(arg1: str) -> str: ...
+ """
+ tree = astroid.extract_node(code)
+ with self.assertNoMessages():
+ self.visitFirst(tree)
+
+ code = """
+ def concat2(arg1: str) -> str: ...
+ """
+ stmt = astroid.extract_node(code)
+ with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+ self.visitFirst(stmt)
+
+
+class TestSuperfluousParentheses(CheckerTestCase):
+ CHECKER_CLASS = FormatChecker
+
+ def testCheckKeywordParensHandlesValidCases(self):
+ cases = [
+ "if foo:",
+ "if foo():",
+ "if (x and y) or z:",
+ "assert foo()",
+ "assert ()",
+ "if (1, 2) in (3, 4):",
+ "if (a or b) in c:",
+ "return (x for x in x)",
+ "if (x for x in x):",
+ "for x in (x for x in x):",
+ "not (foo or bar)",
+ "not (foo or bar) and baz",
+ ]
+ with self.assertNoMessages():
+ for code in cases:
+ self.checker._check_keyword_parentheses(_tokenize_str(code), 0)
+
+ def testCheckKeywordParensHandlesUnnecessaryParens(self):
+ cases = [
+ (Message("superfluous-parens", line=1, args="if"), "if (foo):", 0),
+ (Message("superfluous-parens", line=1, args="if"), "if ((foo, bar)):", 0),
+ (Message("superfluous-parens", line=1, args="if"), "if (foo(bar)):", 0),
+ (
+ Message("superfluous-parens", line=1, args="return"),
+ "return ((x for x in x))",
+ 0,
+ ),
+ (Message("superfluous-parens", line=1, args="not"), "not (foo)", 0),
+ (Message("superfluous-parens", line=1, args="not"), "if not (foo):", 1),
+ (Message("superfluous-parens", line=1, args="if"), "if (not (foo)):", 0),
+ (Message("superfluous-parens", line=1, args="not"), "if (not (foo)):", 2),
+ (
+ Message("superfluous-parens", line=1, args="for"),
+ "for (x) in (1, 2, 3):",
+ 0,
+ ),
+ (
+ Message("superfluous-parens", line=1, args="if"),
+ "if (1) in (1, 2, 3):",
+ 0,
+ ),
+ ]
+ for msg, code, offset in cases:
+ with self.assertAddsMessages(msg):
+ self.checker._check_keyword_parentheses(_tokenize_str(code), offset)
+
+ def testNoSuperfluousParensWalrusOperatorIf(self):
+ """Parenthesis change the meaning of assignment in the walrus operator
+ and so are not superfluous:"""
+ code = "if (odd := is_odd(i))"
+ offset = 0
+ with self.assertNoMessages():
+ self.checker._check_keyword_parentheses(_tokenize_str(code), offset)
+
+ def testPositiveSuperfluousParensWalrusOperatorIf(self):
+ """Test positive superfluous parens with the walrus operator"""
+ code = "if ((odd := is_odd(i))):"
+ msg = Message("superfluous-parens", line=1, args="if")
+ with self.assertAddsMessages(msg):
+ self.checker._check_keyword_parentheses(_tokenize_str(code), 0)
+
+ def testNoSuperfluousParensWalrusOperatorNot(self):
+ """Test superfluous-parens with the not operator"""
+ code = "not (foo := 5)"
+ with self.assertNoMessages():
+ self.checker._check_keyword_parentheses(_tokenize_str(code), 0)
+
+ def testCheckIfArgsAreNotUnicode(self):
+ cases = [("if (foo):", 0), ("assert (1 == 1)", 0)]
+
+ for code, offset in cases:
+ self.checker._check_keyword_parentheses(_tokenize_str(code), offset)
+ got = self.linter.release_messages()
+ assert isinstance(got[-1].args, str)
+
+ def testFuturePrintStatementWithoutParensWarning(self):
+ code = """from __future__ import print_function
+print('Hello world!')
+"""
+ tree = astroid.parse(code)
+ with self.assertNoMessages():
+ self.checker.process_module(tree)
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def testKeywordParensFalsePositive(self):
+ code = "if 'bar' in (DICT or {}):"
+ with self.assertNoMessages():
+ self.checker._check_keyword_parentheses(_tokenize_str(code), start=2)
+
+
+class TestCheckSpace(CheckerTestCase):
+ CHECKER_CLASS = FormatChecker
+
+ def test_encoding_token(self):
+ """Make sure the encoding token doesn't change the checker's behavior
+
+ _tokenize_str doesn't produce an encoding token, but
+ reading a file does
+ """
+ with self.assertNoMessages():
+ encoding_token = tokenize.TokenInfo(
+ tokenize.ENCODING, "utf-8", (0, 0), (0, 0), ""
+ )
+ tokens = [encoding_token] + _tokenize_str(
+ "if (\n None):\n pass\n"
+ )
+ self.checker.process_tokens(tokens)
+
+
+def test_disable_global_option_end_of_line():
+ """
+ Test for issue with disabling tokenizer messages
+ that extend beyond the scope of the ast tokens
+ """
+ file_ = tempfile.NamedTemporaryFile( # pylint: disable=consider-using-with
+ "w", delete=False
+ )
+ with file_:
+ file_.write(
+ """
+mylist = [
+ None
+ ]
+ """
+ )
+ try:
+ linter = lint.PyLinter()
+ checker = FormatChecker(linter)
+ linter.register_checker(checker)
+ args = linter.load_command_line_configuration(
+ [file_.name, "-d", "bad-continuation"]
+ )
+ myreporter = reporters.CollectingReporter()
+ linter.set_reporter(myreporter)
+ linter.check(args)
+ assert not myreporter.messages
+ finally:
+ os.remove(file_.name)
diff --git a/tests/checkers/unittest_imports.py b/tests/checkers/unittest_imports.py
new file mode 100644
index 0000000..f10255e
--- /dev/null
+++ b/tests/checkers/unittest_imports.py
@@ -0,0 +1,163 @@
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Cezar <celnazli@bitdefender.com>
+# Copyright (c) 2015 James Morgensen <james.morgensen@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Hornwitser <github@hornwitser.no>
+# Copyright (c) 2018 Marianna Polatoglou <mpolatoglou@bloomberg.net>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the imports checker."""
+
+import os
+
+import astroid
+
+from pylint.checkers import imports
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+REGR_DATA = os.path.join(os.path.dirname(__file__), "..", "regrtest_data", "")
+
+
+class TestImportsChecker(CheckerTestCase):
+
+ CHECKER_CLASS = imports.ImportsChecker
+
+ @set_config(allow_any_import_level=("astroid",))
+ def test_import_outside_toplevel(self):
+ node = astroid.extract_node(
+ """
+ def f():
+ import astroid
+ """
+ ).body[0]
+
+ with self.assertNoMessages():
+ self.checker.visit_import(node)
+
+ node = astroid.extract_node(
+ """
+ def g():
+ import pylint
+ """
+ ).body[0]
+
+ with self.assertAddsMessages(
+ Message("import-outside-toplevel", node=node, args="pylint")
+ ):
+ self.checker.visit_import(node)
+
+ @set_config(
+ ignored_modules=("external_module", "fake_module.submodule", "foo", "bar")
+ )
+ def test_import_error_skipped(self):
+ """Make sure that imports do not emit an 'import-error' when the
+ module is configured to be ignored."""
+
+ node = astroid.extract_node(
+ """
+ from external_module import anything
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(node)
+
+ node = astroid.extract_node(
+ """
+ from external_module.another_module import anything
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(node)
+
+ node = astroid.extract_node(
+ """
+ import external_module
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_import(node)
+
+ node = astroid.extract_node(
+ """
+ from fake_module.submodule import anything
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(node)
+
+ node = astroid.extract_node(
+ """
+ from fake_module.submodule.deeper import anything
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(node)
+
+ node = astroid.extract_node(
+ """
+ import foo, bar
+ """
+ )
+ msg = Message("multiple-imports", node=node, args="foo, bar")
+ with self.assertAddsMessages(msg):
+ self.checker.visit_import(node)
+
+ node = astroid.extract_node(
+ """
+ import foo
+ import bar
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_import(node)
+
+ def test_reimported_same_line(self):
+ """
+ Test that duplicate imports on single line raise 'reimported'.
+ """
+ node = astroid.extract_node("from time import sleep, sleep, time")
+ msg = Message(msg_id="reimported", node=node, args=("sleep", 1))
+ with self.assertAddsMessages(msg):
+ self.checker.visit_importfrom(node)
+
+ def test_relative_beyond_top_level(self):
+ module = astroid.MANAGER.ast_from_module_name("beyond_top", REGR_DATA)
+ import_from = module.body[0]
+
+ msg = Message(msg_id="relative-beyond-top-level", node=import_from)
+ with self.assertAddsMessages(msg):
+ self.checker.visit_importfrom(import_from)
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(module.body[1])
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(module.body[2].body[0])
+
+ def test_wildcard_import_init(self):
+ module = astroid.MANAGER.ast_from_module_name("init_wildcard", REGR_DATA)
+ import_from = module.body[0]
+
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(import_from)
+
+ def test_wildcard_import_non_init(self):
+ module = astroid.MANAGER.ast_from_module_name("wildcard", REGR_DATA)
+ import_from = module.body[0]
+
+ msg = Message(
+ msg_id="wildcard-import",
+ node=import_from,
+ args="empty",
+ confidence=UNDEFINED,
+ )
+ with self.assertAddsMessages(msg):
+ self.checker.visit_importfrom(import_from)
diff --git a/tests/checkers/unittest_logging.py b/tests/checkers/unittest_logging.py
new file mode 100644
index 0000000..ee7824e
--- /dev/null
+++ b/tests/checkers/unittest_logging.py
@@ -0,0 +1,156 @@
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Alan Chan <achan961117@gmail.com>
+# Copyright (c) 2019-2020 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 Svet <svet@hyperscience.com>
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unittest for the logging checker."""
+import sys
+
+import astroid
+import pytest
+
+from pylint.checkers import logging
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestLoggingModuleDetection(CheckerTestCase):
+ CHECKER_CLASS = logging.LoggingChecker
+
+ def test_detects_standard_logging_module(self):
+ stmts = astroid.extract_node(
+ """
+ import logging #@
+ logging.warn('%s' % '%s') #@
+ """
+ )
+ self.checker.visit_module(None)
+ self.checker.visit_import(stmts[0])
+ with self.assertAddsMessages(
+ Message("logging-not-lazy", node=stmts[1], args=("lazy %",))
+ ):
+ self.checker.visit_call(stmts[1])
+
+ def test_dont_crash_on_invalid_format_string(self):
+ node = astroid.parse(
+ """
+ import logging
+ logging.error('0} - {1}'.format(1, 2))
+ """
+ )
+ self.walk(node)
+
+ def test_detects_renamed_standard_logging_module(self):
+ stmts = astroid.extract_node(
+ """
+ import logging as blogging #@
+ blogging.warn('%s' % '%s') #@
+ """
+ )
+ self.checker.visit_module(None)
+ self.checker.visit_import(stmts[0])
+ with self.assertAddsMessages(
+ Message("logging-not-lazy", node=stmts[1], args=("lazy %",))
+ ):
+ self.checker.visit_call(stmts[1])
+
+ @set_config(logging_modules=["logging", "my.logging"])
+ def test_nonstandard_logging_module(self):
+ stmts = astroid.extract_node(
+ """
+ from my import logging as blogging #@
+ blogging.warn('%s' % '%s') #@
+ """
+ )
+ self.checker.visit_module(None)
+ self.checker.visit_import(stmts[0])
+ with self.assertAddsMessages(
+ Message("logging-not-lazy", node=stmts[1], args=("lazy %",))
+ ):
+ self.checker.visit_call(stmts[1])
+
+ def _assert_logging_format_no_messages(self, stmt):
+ stmts = astroid.extract_node(
+ """
+ import logging #@
+ logging.error<placeholder> #@
+ """.replace(
+ "<placeholder>", stmt
+ )
+ )
+ self.checker.visit_module(None)
+ self.checker.visit_import(stmts[0])
+ with self.assertNoMessages():
+ self.checker.visit_call(stmts[1])
+
+ def _assert_logging_format_message(self, msg, stmt, args=None, with_too_many=False):
+ stmts = astroid.extract_node(
+ """
+ import logging #@
+ logging.error<placeholder> #@
+ """.replace(
+ "<placeholder>", stmt
+ )
+ )
+ self.checker.visit_module(None)
+ self.checker.visit_import(stmts[0])
+ messages = [Message(msg, node=stmts[1], args=args, confidence=UNDEFINED)]
+ if with_too_many:
+ messages.append(
+ Message("logging-too-many-args", node=stmts[1], confidence=UNDEFINED)
+ )
+ with self.assertAddsMessages(*messages):
+ self.checker.visit_call(stmts[1])
+
+ def _assert_logging_format_too_few_args(self, stmt):
+ self._assert_logging_format_message("logging-too-few-args", stmt)
+
+ def _assert_logging_format_too_many_args(self, stmt):
+ self._assert_logging_format_message("logging-too-many-args", stmt)
+
+ @set_config(logging_format_style="new")
+ def test_brace_format_style_matching_arguments(self):
+ self._assert_logging_format_no_messages("('constant string')")
+ self._assert_logging_format_no_messages("('{}')")
+ self._assert_logging_format_no_messages("('{}', 1)")
+ self._assert_logging_format_no_messages("('{0}', 1)")
+ self._assert_logging_format_no_messages("('{named}', {'named': 1})")
+ self._assert_logging_format_no_messages("('{} {named}', 1, {'named': 1})")
+ self._assert_logging_format_no_messages("('{0} {named}', 1, {'named': 1})")
+
+ @set_config(logging_format_style="new")
+ def test_brace_format_style_too_few_args(self):
+ self._assert_logging_format_too_few_args("('{}, {}', 1)")
+ self._assert_logging_format_too_few_args("('{0}, {1}', 1)")
+ self._assert_logging_format_too_few_args(
+ "('{named1}, {named2}', {'named1': 1})"
+ )
+ self._assert_logging_format_too_few_args("('{0}, {named}', 1)")
+ self._assert_logging_format_too_few_args("('{}, {named}', {'named': 1})")
+ self._assert_logging_format_too_few_args("('{0}, {named}', {'named': 1})")
+
+ @set_config(logging_format_style="new")
+ def test_brace_format_style_not_enough_arguments(self):
+ self._assert_logging_format_too_many_args("('constant string', 1, 2)")
+ self._assert_logging_format_too_many_args("('{}', 1, 2)")
+ self._assert_logging_format_too_many_args("('{0}', 1, 2)")
+ self._assert_logging_format_too_many_args("('{}, {named}', 1, 2, {'named': 1})")
+ self._assert_logging_format_too_many_args(
+ "('{0}, {named}', 1, 2, {'named': 1})"
+ )
+
+ @pytest.mark.skipif(sys.version_info < (3, 6), reason="F-string require >=3.6")
+ @set_config(logging_format_style="new")
+ def test_fstr_not_new_format_style_matching_arguments(self):
+ msg = "logging-fstring-interpolation"
+ args = ("lazy %",)
+ self._assert_logging_format_message(msg, "(f'{named}')", args)
diff --git a/tests/checkers/unittest_misc.py b/tests/checkers/unittest_misc.py
new file mode 100644
index 0000000..fc059ba
--- /dev/null
+++ b/tests/checkers/unittest_misc.py
@@ -0,0 +1,107 @@
+# Copyright (c) 2013-2014, 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 glegoux <gilles.legoux@gmail.com>
+# Copyright (c) 2018 Rogalski, Lukasz <lukasz.rogalski@intel.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the misc checker."""
+
+from pylint.checkers import misc
+from pylint.testutils import CheckerTestCase, Message, _tokenize_str, set_config
+
+
+class TestFixme(CheckerTestCase):
+ CHECKER_CLASS = misc.EncodingChecker
+
+ def test_fixme_with_message(self):
+ code = """a = 1
+ # FIXME message
+ """
+ with self.assertAddsMessages(
+ Message(msg_id="fixme", line=2, args="FIXME message")
+ ):
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def test_todo_without_message(self):
+ code = """a = 1
+ # TODO
+ """
+ with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="TODO")):
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def test_xxx_without_space(self):
+ code = """a = 1
+ #XXX
+ """
+ with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="XXX")):
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def test_xxx_middle(self):
+ code = """a = 1
+ # midle XXX
+ """
+ with self.assertNoMessages():
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def test_without_space_fixme(self):
+ code = """a = 1
+ #FIXME
+ """
+ with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="FIXME")):
+ self.checker.process_tokens(_tokenize_str(code))
+
+ @set_config(notes=[])
+ def test_absent_codetag(self):
+ code = """a = 1
+ # FIXME # FIXME
+ # TODO # TODO
+ # XXX # XXX
+ """
+ with self.assertNoMessages():
+ self.checker.process_tokens(_tokenize_str(code))
+
+ @set_config(notes=["CODETAG"])
+ def test_other_present_codetag(self):
+ code = """a = 1
+ # CODETAG
+ # FIXME
+ """
+ with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="CODETAG")):
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def test_issue_2321_should_not_trigger(self):
+ code = 'print("# TODO this should not trigger a fixme")'
+ with self.assertNoMessages():
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def test_issue_2321_should_trigger(self):
+ code = "# TODO this should not trigger a fixme"
+ with self.assertAddsMessages(
+ Message(msg_id="fixme", line=1, args="TODO this should not trigger a fixme")
+ ):
+ self.checker.process_tokens(_tokenize_str(code))
+
+ def test_dont_trigger_on_todoist(self):
+ code = """
+ # Todoist API: What is this task about?
+ # Todoist API: Look up a task's due date
+ # Todoist API: Look up a Project/Label/Task ID
+ # Todoist API: Fetch all labels
+ # Todoist API: "Name" value
+ # Todoist API: Get a task's priority
+ # Todoist API: Look up the Project ID a Task belongs to
+ # Todoist API: Fetch all Projects
+ # Todoist API: Fetch all Tasks
+ """
+ with self.assertNoMessages():
+ self.checker.process_tokens(_tokenize_str(code))
diff --git a/tests/checkers/unittest_python3.py b/tests/checkers/unittest_python3.py
new file mode 100644
index 0000000..c33d166
--- /dev/null
+++ b/tests/checkers/unittest_python3.py
@@ -0,0 +1,1177 @@
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014-2015 Brett Cannon <brett@python.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2015 Cosmin Poieana <cmin@ropython.org>
+# Copyright (c) 2015 Viorel Stirbu <viorels@gmail.com>
+# Copyright (c) 2016-2017 Roy Williams <roy.williams.iii@gmail.com>
+# Copyright (c) 2016 Roy Williams <rwilliams@lyft.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Daniel Miller <millerdev@gmail.com>
+# Copyright (c) 2018-2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 sbagan <pnlbagan@gmail.com>
+# Copyright (c) 2018 Aivar Annamaa <aivarannamaa@users.noreply.github.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Gabriel R Sezefredo <gabriel@sezefredo.com.br>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Federico Bond <federicobond@gmail.com>
+# Copyright (c) 2020 Athos Ribeiro <athoscr@fedoraproject.org>
+# Copyright (c) 2021 Tiago Honorato <tiagohonorato1@gmail.com>
+# Copyright (c) 2021 tiagohonorato <61059243+tiagohonorato@users.noreply.github.com>
+# Copyright (c) 2021 David Gilman <davidgilman1@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the python3 checkers."""
+
+# pylint: disable=too-many-public-methods,redefined-outer-name
+
+import astroid
+
+from pylint import testutils
+from pylint.checkers import python3 as checker
+from pylint.interfaces import INFERENCE, INFERENCE_FAILURE
+
+# TODO(cpopa): Port these to the functional test framework instead. pylint: disable=fixme
+
+
+class TestPython3Checker(testutils.CheckerTestCase):
+
+ CHECKER_CLASS = checker.Python3Checker
+
+ def check_bad_builtin(self, builtin_name):
+ node = astroid.extract_node(builtin_name + " #@")
+ message = builtin_name.lower() + "-builtin"
+ with self.assertAddsMessages(testutils.Message(message, node=node)):
+ self.checker.visit_name(node)
+
+ def test_bad_builtins(self):
+ builtins = [
+ "apply",
+ "buffer",
+ "cmp",
+ "coerce",
+ "execfile",
+ "file",
+ "input",
+ "intern",
+ "long",
+ "raw_input",
+ "round",
+ "reduce",
+ "StandardError",
+ "unichr",
+ "unicode",
+ "xrange",
+ "reload",
+ ]
+ for builtin in builtins:
+ self.check_bad_builtin(builtin)
+
+ def as_iterable_in_for_loop_test(self, fxn):
+ code = f"for x in {fxn}(): pass"
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_used_by_iterable_in_for_loop_test(self, fxn):
+ checker = f"{fxn}-builtin-not-iterating"
+ node = astroid.extract_node(
+ f"""
+ for x in (whatever(
+ {fxn}() #@
+ )):
+ pass
+ """
+ )
+ message = testutils.Message(checker, node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def as_iterable_in_genexp_test(self, fxn):
+ code = f"x = (x for x in {fxn}())"
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_iterable_in_starred_context(self, fxn):
+ code = f"x = test(*{fxn}())"
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_iterable_in_listcomp_test(self, fxn):
+ code = f"x = [x for x in {fxn}(None, [1])]"
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_iterable_in_yield_from(self, fxn):
+ code = f"yield from {fxn}()"
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_used_in_variant_in_genexp_test(self, fxn):
+ checker = f"{fxn}-builtin-not-iterating"
+ node = astroid.extract_node(
+ f"""
+ list(
+ __({fxn}(x))
+ for x in [1]
+ )
+ """
+ )
+ message = testutils.Message(checker, node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def as_used_in_variant_in_listcomp_test(self, fxn):
+ checker = f"{fxn}-builtin-not-iterating"
+ node = astroid.extract_node(
+ f"""
+ [
+ __({fxn}(None, x))
+ for x in [[1]]]
+ """
+ )
+ message = testutils.Message(checker, node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def as_argument_to_callable_constructor_test(self, fxn, callable_fn):
+ module = astroid.parse(f"x = {callable_fn}({fxn}())")
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_argument_to_materialized_filter(self, callable_fn):
+ module = astroid.parse(f"list(filter(None, {callable_fn}()))")
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_argument_to_random_fxn_test(self, fxn):
+ checker = f"{fxn}-builtin-not-iterating"
+ node = astroid.extract_node(
+ f"""
+ y(
+ {fxn}() #@
+ )
+ """
+ )
+ message = testutils.Message(checker, node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def as_argument_to_str_join_test(self, fxn):
+ code = f"x = ''.join({fxn}())"
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_argument_to_itertools_functions(self, fxn):
+ code = f"""
+ from __future__ import absolute_import
+ import itertools
+ from itertools import product
+ for i,j in product({fxn}(), repeat=2):
+ pass
+ for i,j in itertools.product({fxn}(), repeat=2):
+ pass
+ """
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_argument_to_zip_test(self, fxn):
+ module = astroid.parse(f"list(zip({fxn}))")
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_argument_to_map_test(self, fxn):
+ module = astroid.parse(f"list(map(__, {fxn}()))")
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def as_iterable_in_unpacking(self, fxn):
+ node = astroid.extract_node(
+ f"""
+ a, b = __({fxn}())
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def as_assignment(self, fxn):
+ checker = f"{fxn}-builtin-not-iterating"
+ node = astroid.extract_node(
+ f"""
+ a = __({fxn}())
+ """
+ )
+ message = testutils.Message(checker, node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def iterating_context_tests(self, fxn):
+ """Helper for verifying a function isn't used as an iterator."""
+ self.as_iterable_in_for_loop_test(fxn)
+ self.as_used_by_iterable_in_for_loop_test(fxn)
+ self.as_iterable_in_genexp_test(fxn)
+ self.as_iterable_in_listcomp_test(fxn)
+ self.as_used_in_variant_in_genexp_test(fxn)
+ self.as_used_in_variant_in_listcomp_test(fxn)
+ self.as_argument_to_random_fxn_test(fxn)
+ self.as_argument_to_str_join_test(fxn)
+ self.as_iterable_in_unpacking(fxn)
+ self.as_assignment(fxn)
+ self.as_argument_to_materialized_filter(fxn)
+ self.as_iterable_in_yield_from(fxn)
+ self.as_iterable_in_starred_context(fxn)
+ self.as_argument_to_itertools_functions(fxn)
+ self.as_argument_to_zip_test(fxn)
+ self.as_argument_to_map_test(fxn)
+ for func in (
+ "iter",
+ "list",
+ "tuple",
+ "sorted",
+ "set",
+ "sum",
+ "any",
+ "all",
+ "enumerate",
+ "dict",
+ "OrderedDict",
+ ):
+ self.as_argument_to_callable_constructor_test(fxn, func)
+
+ def test_dict_subclasses_methods_in_iterating_context(self):
+ iterating, not_iterating = astroid.extract_node(
+ """
+ from __future__ import absolute_import
+ from collections import defaultdict
+ d = defaultdict(list)
+ a, b = d.keys() #@
+ x = d.keys() #@
+ """
+ )
+
+ with self.assertNoMessages():
+ self.checker.visit_call(iterating.value)
+
+ message = testutils.Message("dict-keys-not-iterating", node=not_iterating.value)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(not_iterating.value)
+
+ def test_dict_methods_in_iterating_context(self):
+ iterating_code = [
+ "for x in {}(): pass",
+ "(x for x in {}())",
+ "[x for x in {}()]",
+ "iter({}())",
+ "a, b = {}()",
+ "max({}())",
+ "min({}())",
+ "3 in {}()",
+ "3 not in {}()",
+ "set().update({}())",
+ "[].extend({}())",
+ "{{}}.update({}())",
+ """
+ from __future__ import absolute_import
+ from itertools import chain
+ chain.from_iterable({}())
+ """,
+ ]
+ non_iterating_code = ["x = __({}())", "__({}())[0]"]
+
+ for method in ("keys", "items", "values"):
+ dict_method = f"{{}}.{method}"
+
+ for code in iterating_code:
+ with_value = code.format(dict_method)
+ module = astroid.parse(with_value)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ for code in non_iterating_code:
+ with_value = code.format(dict_method)
+ node = astroid.extract_node(with_value)
+
+ checker = f"dict-{method}-not-iterating"
+ message = testutils.Message(checker, node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_map_in_iterating_context(self):
+ self.iterating_context_tests("map")
+
+ def test_zip_in_iterating_context(self):
+ self.iterating_context_tests("zip")
+
+ def test_range_in_iterating_context(self):
+ self.iterating_context_tests("range")
+
+ def test_filter_in_iterating_context(self):
+ self.iterating_context_tests("filter")
+
+ def defined_method_test(self, method, warning):
+ """Helper for verifying that a certain method is not defined."""
+ node = astroid.extract_node(
+ f"""
+ class Foo(object):
+ def __{method}__(self, other): #@
+ pass"""
+ )
+ message = testutils.Message(warning, node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_functiondef(node)
+
+ def test_delslice_method(self):
+ self.defined_method_test("delslice", "delslice-method")
+
+ def test_getslice_method(self):
+ self.defined_method_test("getslice", "getslice-method")
+
+ def test_setslice_method(self):
+ self.defined_method_test("setslice", "setslice-method")
+
+ def test_coerce_method(self):
+ self.defined_method_test("coerce", "coerce-method")
+
+ def test_oct_method(self):
+ self.defined_method_test("oct", "oct-method")
+
+ def test_hex_method(self):
+ self.defined_method_test("hex", "hex-method")
+
+ def test_nonzero_method(self):
+ self.defined_method_test("nonzero", "nonzero-method")
+
+ def test_cmp_method(self):
+ self.defined_method_test("cmp", "cmp-method")
+
+ def test_div_method(self):
+ self.defined_method_test("div", "div-method")
+
+ def test_idiv_method(self):
+ self.defined_method_test("idiv", "idiv-method")
+
+ def test_rdiv_method(self):
+ self.defined_method_test("rdiv", "rdiv-method")
+
+ def test_eq_and_hash_method(self):
+ """Helper for verifying that a certain method is not defined."""
+ node = astroid.extract_node(
+ """
+ class Foo(object): #@
+ def __eq__(self, other):
+ pass
+ def __hash__(self):
+ pass"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_classdef(node)
+
+ def test_eq_and_hash_is_none(self):
+ """Helper for verifying that a certain method is not defined."""
+ node = astroid.extract_node(
+ """
+ class Foo(object): #@
+ def __eq__(self, other):
+ pass
+ __hash__ = None"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_classdef(node)
+
+ def test_eq_without_hash_method(self):
+ """Helper for verifying that a certain method is not defined."""
+ node = astroid.extract_node(
+ """
+ class Foo(object): #@
+ def __eq__(self, other):
+ pass"""
+ )
+ message = testutils.Message("eq-without-hash", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_classdef(node)
+
+ def test_relative_import(self):
+ node = astroid.extract_node("import string #@")
+ message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_import(node)
+ with self.assertNoMessages():
+ # message should only be added once
+ self.checker.visit_import(node)
+
+ def test_relative_from_import(self):
+ node = astroid.extract_node("from os import path #@")
+ message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_importfrom(node)
+ with self.assertNoMessages():
+ # message should only be added once
+ self.checker.visit_importfrom(node)
+
+ def test_absolute_import(self):
+ module_import = astroid.parse(
+ "from __future__ import absolute_import; import os"
+ )
+ module_from = astroid.parse(
+ "from __future__ import absolute_import; from os import path"
+ )
+ with self.assertNoMessages():
+ for module in (module_import, module_from):
+ self.walk(module)
+
+ def test_import_star_module_level(self):
+ node = astroid.extract_node(
+ """
+ def test():
+ from lala import * #@
+ """
+ )
+ absolute = testutils.Message("no-absolute-import", node=node)
+ star = testutils.Message("import-star-module-level", node=node)
+ with self.assertAddsMessages(absolute, star):
+ self.checker.visit_importfrom(node)
+
+ def test_division(self):
+ nodes = astroid.extract_node(
+ """\
+ from _unknown import a, b
+ 3 / 2 #@
+ 3 / int(a) #@
+ int(a) / 3 #@
+ a / b #@
+ """
+ )
+ for node in nodes:
+ message = testutils.Message("old-division", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_binop(node)
+
+ def test_division_with_future_statement(self):
+ module = astroid.parse("from __future__ import division; 3 / 2")
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_floor_division(self):
+ node = astroid.extract_node(" 3 // 2 #@")
+ with self.assertNoMessages():
+ self.checker.visit_binop(node)
+
+ def test_division_by_float(self):
+ nodes = astroid.extract_node(
+ """\
+ 3.0 / 2 #@
+ 3 / 2.0 #@
+ 3 / float(a) #@
+ float(a) / 3 #@
+ """
+ )
+ with self.assertNoMessages():
+ for node in nodes:
+ self.checker.visit_binop(node)
+
+ def test_division_different_types(self):
+ nodes = astroid.extract_node(
+ """
+ class A:
+ pass
+ A / 2 #@
+ A() / 2 #@
+ "a" / "a" #@
+ class Path:
+ def __div__(self, other):
+ return 42
+ Path() / 24 #@
+ """
+ )
+ for node in nodes:
+ with self.assertNoMessages():
+ self.checker.visit_binop(node)
+
+ def test_dict_iter_method(self):
+ for meth in ("keys", "values", "items"):
+ node = astroid.extract_node("x.iter%s() #@" % meth)
+ message = testutils.Message("dict-iter-method", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_dict_iter_method_on_dict(self):
+ nodes = astroid.extract_node(
+ """
+ from collections import defaultdict
+ {}.iterkeys() #@
+ defaultdict(list).iterkeys() #@
+ class Someclass(dict):
+ pass
+ Someclass().iterkeys() #@
+
+ # Emits even though we are not sure they are dicts
+ x.iterkeys() #@
+
+ def func(x):
+ x.iterkeys() #@
+ """
+ )
+ for node in nodes:
+ message = testutils.Message("dict-iter-method", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_dict_not_iter_method(self):
+ arg_node = astroid.extract_node("x.iterkeys(x) #@")
+ stararg_node = astroid.extract_node("x.iterkeys(*x) #@")
+ kwarg_node = astroid.extract_node("x.iterkeys(y=x) #@")
+ with self.assertNoMessages():
+ for node in (arg_node, stararg_node, kwarg_node):
+ self.checker.visit_call(node)
+
+ def test_dict_view_method(self):
+ for meth in ("keys", "values", "items"):
+ node = astroid.extract_node("x.view%s() #@" % meth)
+ message = testutils.Message("dict-view-method", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_dict_viewkeys(self):
+ nodes = astroid.extract_node(
+ """
+ from collections import defaultdict
+ {}.viewkeys() #@
+ defaultdict(list).viewkeys() #@
+ class Someclass(dict):
+ pass
+ Someclass().viewkeys() #@
+
+ # Emits even though they might not be dicts
+ x.viewkeys() #@
+
+ def func(x):
+ x.viewkeys() #@
+ """
+ )
+ for node in nodes:
+ message = testutils.Message("dict-view-method", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_next_method(self):
+ node = astroid.extract_node("x.next() #@")
+ message = testutils.Message("next-method-called", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_not_next_method(self):
+ arg_node = astroid.extract_node("x.next(x) #@")
+ stararg_node = astroid.extract_node("x.next(*x) #@")
+ kwarg_node = astroid.extract_node("x.next(y=x) #@")
+ with self.assertNoMessages():
+ for node in (arg_node, stararg_node, kwarg_node):
+ self.checker.visit_call(node)
+
+ def test_metaclass_assignment(self):
+ node = astroid.extract_node(
+ """
+ class Foo(object): #@
+ __metaclass__ = type"""
+ )
+ message = testutils.Message("metaclass-assignment", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_classdef(node)
+
+ def test_metaclass_global_assignment(self):
+ module = astroid.parse("__metaclass__ = type")
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_xreadlines_attribute(self):
+ node = astroid.extract_node(
+ """
+ f.xreadlines #@
+ """
+ )
+ message = testutils.Message("xreadlines-attribute", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ def test_exception_message_attribute(self):
+ node = astroid.extract_node(
+ """
+ try:
+ raise Exception("test")
+ except Exception as e:
+ e.message #@
+ """
+ )
+ message = testutils.Message("exception-message-attribute", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ def test_normal_message_attribute(self):
+ node = astroid.extract_node(
+ """
+ e.message #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ def test_invalid_codec(self):
+ node = astroid.extract_node('foobar.encode("hex") #@')
+ message = testutils.Message("invalid-str-codec", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_valid_codec(self):
+ node = astroid.extract_node('foobar.encode("ascii", "ignore") #@')
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_visit_call_with_kwarg(self):
+ node = astroid.extract_node('foobar.raz(encoding="hex") #@')
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_invalid_open_codec(self):
+ node = astroid.extract_node('open(foobar, encoding="hex") #@')
+ message = testutils.Message("invalid-str-codec", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_valid_open_codec(self):
+ node = astroid.extract_node('open(foobar, encoding="palmos") #@')
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_using_cmp_argument(self):
+ nodes = astroid.extract_node(
+ """
+ [].sort(cmp=lambda x: x) #@
+ a = list(range(x))
+ a.sort(cmp=lambda x: x) #@
+
+ sorted([], cmp=lambda x: x) #@
+ """
+ )
+ for node in nodes:
+ message = testutils.Message("using-cmp-argument", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_sys_maxint(self):
+ node = astroid.extract_node(
+ """
+ import sys
+ sys.maxint #@
+ """
+ )
+ message = testutils.Message("sys-max-int", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ def test_itertools_izip(self):
+ node = astroid.extract_node(
+ """
+ from itertools import izip #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ message = testutils.Message("deprecated-itertools-function", node=node)
+ with self.assertAddsMessages(absolute_import_message, message):
+ self.checker.visit_importfrom(node)
+
+ def test_deprecated_types_fields(self):
+ node = astroid.extract_node(
+ """
+ from types import StringType #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ message = testutils.Message("deprecated-types-field", node=node)
+ with self.assertAddsMessages(absolute_import_message, message):
+ self.checker.visit_importfrom(node)
+
+ def test_sys_maxint_imort_from(self):
+ node = astroid.extract_node(
+ """
+ from sys import maxint #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ message = testutils.Message("sys-max-int", node=node)
+ with self.assertAddsMessages(absolute_import_message, message):
+ self.checker.visit_importfrom(node)
+
+ def test_object_maxint(self):
+ node = astroid.extract_node(
+ """
+ sys = object()
+ sys.maxint #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ def test_bad_import(self):
+ node = astroid.extract_node(
+ """
+ import urllib2, sys #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ message = testutils.Message("bad-python3-import", node=node)
+ with self.assertAddsMessages(absolute_import_message, message):
+ self.checker.visit_import(node)
+
+ def test_bad_import_turtle(self):
+ node = astroid.extract_node(
+ """
+ import turtle #@
+ turtle.Turtle()
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(absolute_import_message):
+ self.checker.visit_import(node)
+
+ def test_bad_import_dbm(self):
+ node = astroid.extract_node(
+ """
+ from dbm import open as open_ #@
+ open_("dummy.db")
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(absolute_import_message):
+ self.checker.visit_importfrom(node)
+
+ def test_bad_import_conditional(self):
+ node = astroid.extract_node(
+ """
+ import six
+ if six.PY2:
+ import urllib2 #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(absolute_import_message):
+ self.checker.visit_import(node)
+
+ def test_bad_import_try_except_handler(self):
+ node = astroid.extract_node(
+ """
+ try:
+ from hashlib import sha
+ except:
+ import sha #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(absolute_import_message):
+ self.checker.visit_import(node)
+
+ def test_bad_import_try(self):
+ node = astroid.extract_node(
+ """
+ try:
+ import md5 #@
+ except:
+ from hashlib import md5
+ finally:
+ pass
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(absolute_import_message):
+ self.checker.visit_import(node)
+
+ def test_bad_import_try_finally(self):
+ node = astroid.extract_node(
+ """
+ try:
+ import Queue #@
+ finally:
+ import queue
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ message = testutils.Message("bad-python3-import", node=node)
+ with self.assertAddsMessages(absolute_import_message, message):
+ self.checker.visit_import(node)
+
+ def test_bad_import_from(self):
+ node = astroid.extract_node(
+ """
+ from cStringIO import StringIO #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ message = testutils.Message("bad-python3-import", node=node)
+ with self.assertAddsMessages(absolute_import_message, message):
+ self.checker.visit_importfrom(node)
+
+ def test_bad_string_attribute(self):
+ node = astroid.extract_node(
+ """
+ import string
+ string.maketrans #@
+ """
+ )
+ message = testutils.Message("deprecated-string-function", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ def test_bad_operator_attribute(self):
+ node = astroid.extract_node(
+ """
+ import operator
+ operator.div #@
+ """
+ )
+ message = testutils.Message("deprecated-operator-function", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ def test_comprehension_escape(self):
+ assign, escaped_node = astroid.extract_node(
+ """
+ a = [i for i in range(10)] #@
+ i #@
+ """
+ )
+ good_module = astroid.parse(
+ """
+ {c for c in range(10)} #@
+ {j:j for j in range(10)} #@
+ [image_child] = [x for x in range(10)]
+ thumbnail = func(__(image_child))
+ """
+ )
+ message = testutils.Message("comprehension-escape", node=escaped_node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_listcomp(assign.value)
+
+ with self.assertNoMessages():
+ self.walk(good_module)
+
+ def test_comprehension_escape_newly_introduced(self):
+ node = astroid.extract_node(
+ """
+ [i for i in range(3)]
+ for i in range(3):
+ i
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(node)
+
+ def test_exception_escape(self):
+ module = astroid.parse(
+ """
+ try: 1/0
+ except ValueError as exc:
+ pass
+ exc #@
+ try:
+ 2/0
+ except (ValueError, TypeError) as exc:
+ exc = 2
+ exc #@
+ try:
+ 2/0
+ except (ValueError, TypeError): #@
+ exc = 2
+ exc #@
+ try:
+ 1/0
+ except (ValueError, TypeError) as exc:
+ foo(bar for bar in exc.bar)
+ """
+ )
+ message = testutils.Message("exception-escape", node=module.body[1].value)
+ with self.assertAddsMessages(message):
+ self.checker.visit_excepthandler(module.body[0].handlers[0])
+ with self.assertNoMessages():
+ self.checker.visit_excepthandler(module.body[2].handlers[0])
+ self.checker.visit_excepthandler(module.body[4].handlers[0])
+ self.checker.visit_excepthandler(module.body[6].handlers[0])
+
+ def test_bad_sys_attribute(self):
+ node = astroid.extract_node(
+ """
+ import sys
+ sys.exc_clear #@
+ """
+ )
+ message = testutils.Message("deprecated-sys-function", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ def test_bad_urllib_attribute(self):
+ nodes = astroid.extract_node(
+ """
+ import urllib
+ urllib.addbase #@
+ urllib.splithost #@
+ urllib.urlretrieve #@
+ urllib.urlopen #@
+ urllib.urlencode #@
+ """
+ )
+ for node in nodes:
+ message = testutils.Message("deprecated-urllib-function", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ def test_ok_string_attribute(self):
+ node = astroid.extract_node(
+ """
+ import string
+ string.ascii_letters #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ def test_bad_string_call(self):
+ node = astroid.extract_node(
+ """
+ import string
+ string.upper("hello world") #@
+ """
+ )
+ message = testutils.Message("deprecated-string-function", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_ok_shadowed_call(self):
+ node = astroid.extract_node(
+ """
+ import six.moves.configparser
+ six.moves.configparser.ConfigParser() #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_ok_string_call(self):
+ node = astroid.extract_node(
+ """
+ import string
+ string.Foramtter() #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_bad_string_import_from(self):
+ node = astroid.extract_node(
+ """
+ from string import atoi #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ message = testutils.Message("deprecated-string-function", node=node)
+ with self.assertAddsMessages(absolute_import_message, message):
+ self.checker.visit_importfrom(node)
+
+ def test_ok_string_import_from(self):
+ node = astroid.extract_node(
+ """
+ from string import digits #@
+ """
+ )
+ absolute_import_message = testutils.Message("no-absolute-import", node=node)
+ with self.assertAddsMessages(absolute_import_message):
+ self.checker.visit_importfrom(node)
+
+ def test_bad_str_translate_call_string_literal(self):
+ node = astroid.extract_node(
+ """
+ foobar.translate(None, 'abc123') #@
+ """
+ )
+ message = testutils.Message(
+ "deprecated-str-translate-call", node=node, confidence=INFERENCE_FAILURE
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_bad_str_translate_call_variable(self):
+ node = astroid.extract_node(
+ """
+ def raz(foobar):
+ foobar.translate(None, 'hello') #@
+ """
+ )
+ message = testutils.Message(
+ "deprecated-str-translate-call", node=node, confidence=INFERENCE_FAILURE
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_bad_str_translate_call_infer_str(self):
+ node = astroid.extract_node(
+ """
+ foobar = "hello world"
+ foobar.translate(None, foobar) #@
+ """
+ )
+ message = testutils.Message(
+ "deprecated-str-translate-call", node=node, confidence=INFERENCE
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_call(node)
+
+ def test_ok_str_translate_call_integer(self):
+ node = astroid.extract_node(
+ """
+ foobar.translate(None, 33) #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_ok_str_translate_call_keyword(self):
+ node = astroid.extract_node(
+ """
+ foobar.translate(None, 'foobar', raz=33) #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_ok_str_translate_call_not_str(self):
+ node = astroid.extract_node(
+ """
+ foobar = {}
+ foobar.translate(None, 'foobar') #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_non_py2_conditional(self):
+ code = """
+ from __future__ import absolute_import
+ import sys
+ x = {}
+ if sys.maxsize:
+ x.iterkeys() #@
+ """
+ node = astroid.extract_node(code)
+ module = node.parent.parent
+ message = testutils.Message("dict-iter-method", node=node)
+ with self.assertAddsMessages(message):
+ self.walk(module)
+
+ def test_six_conditional(self):
+ code = """
+ from __future__ import absolute_import
+ import six
+ x = {}
+ if six.PY2:
+ x.iterkeys()
+ """
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_versioninfo_conditional(self):
+ code = """
+ from __future__ import absolute_import
+ import sys
+ x = {}
+ if sys.version_info[0] == 2:
+ x.iterkeys()
+ """
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_versioninfo_tuple_conditional(self):
+ code = """
+ from __future__ import absolute_import
+ import sys
+ x = {}
+ if sys.version_info == (2, 7):
+ x.iterkeys()
+ """
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_six_ifexp_conditional(self):
+ code = """
+ from __future__ import absolute_import
+ import six
+ import string
+ string.translate if six.PY2 else None
+ """
+ module = astroid.parse(code)
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_next_defined(self):
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def next(self): #@
+ pass"""
+ )
+ message = testutils.Message("next-method-defined", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_functiondef(node)
+
+ def test_next_defined_too_many_args(self):
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def next(self, foo=None): #@
+ pass"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_next_defined_static_method_too_many_args(self):
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ @staticmethod
+ def next(self): #@
+ pass"""
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_next_defined_static_method(self):
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ @staticmethod
+ def next(): #@
+ pass"""
+ )
+ message = testutils.Message("next-method-defined", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_functiondef(node)
+
+ def test_next_defined_class_method(self):
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ @classmethod
+ def next(cls): #@
+ pass"""
+ )
+ message = testutils.Message("next-method-defined", node=node)
+ with self.assertAddsMessages(message):
+ self.checker.visit_functiondef(node)
diff --git a/tests/checkers/unittest_refactoring.py b/tests/checkers/unittest_refactoring.py
new file mode 100644
index 0000000..15e18db
--- /dev/null
+++ b/tests/checkers/unittest_refactoring.py
@@ -0,0 +1,48 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import astroid
+
+from pylint.checkers.refactoring import LenChecker
+
+
+def test_class_tree_detection():
+ module = astroid.parse(
+ """
+class ClassWithBool(list):
+ def __bool__(self):
+ return True
+
+class ClassWithoutBool(dict):
+ pass
+
+class ChildClassWithBool(ClassWithBool):
+ pass
+
+class ChildClassWithoutBool(ClassWithoutBool):
+ pass
+"""
+ )
+ with_bool, without_bool, child_with_bool, child_without_bool = module.body
+ assert LenChecker().base_classes_of_node(with_bool) == [
+ "ClassWithBool",
+ "list",
+ "object",
+ ]
+ assert LenChecker().base_classes_of_node(without_bool) == [
+ "ClassWithoutBool",
+ "dict",
+ "object",
+ ]
+ assert LenChecker().base_classes_of_node(child_with_bool) == [
+ "ChildClassWithBool",
+ "ClassWithBool",
+ "list",
+ "object",
+ ]
+ assert LenChecker().base_classes_of_node(child_without_bool) == [
+ "ChildClassWithoutBool",
+ "ClassWithoutBool",
+ "dict",
+ "object",
+ ]
diff --git a/tests/checkers/unittest_similar.py b/tests/checkers/unittest_similar.py
new file mode 100644
index 0000000..12b54e5
--- /dev/null
+++ b/tests/checkers/unittest_similar.py
@@ -0,0 +1,419 @@
+# Copyright (c) 2010, 2012, 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 Ry4an Brase <ry4an-hg@ry4an.org>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Scott Worley <scottworley@scottworley.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 Taewon D. Kim <kimt33@mcmaster.ca>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2020 Eli Fine <ejfine@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Aditya Gupta <adityagupta1089@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+
+import pytest
+
+from pylint.checkers import similar
+from pylint.lint import PyLinter
+from pylint.testutils import GenericTestReporter as Reporter
+
+INPUT = Path(__file__).parent / ".." / "input"
+SIMILAR1 = str(INPUT / "similar1")
+SIMILAR2 = str(INPUT / "similar2")
+SIMILAR3 = str(INPUT / "similar3")
+SIMILAR4 = str(INPUT / "similar4")
+SIMILAR5 = str(INPUT / "similar5")
+SIMILAR6 = str(INPUT / "similar6")
+MULTILINE = str(INPUT / "multiline-import")
+HIDE_CODE_WITH_IMPORTS = str(INPUT / "hide_code_with_imports.py")
+
+
+def test_ignore_comments():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run(["--ignore-comments", SIMILAR1, SIMILAR2])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == (
+ """
+10 similar lines in 2 files
+==%s:0
+==%s:0
+ import one
+ from two import two
+ three
+ four
+ five
+ six
+ seven
+ eight
+ nine
+ ''' ten
+TOTAL lines=60 duplicates=10 percent=16.67
+"""
+ % (SIMILAR1, SIMILAR2)
+ ).strip()
+ )
+
+
+def test_ignore_docsrings():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run(["--ignore-docstrings", SIMILAR1, SIMILAR2])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == (
+ """
+8 similar lines in 2 files
+==%s:6
+==%s:6
+ seven
+ eight
+ nine
+ ''' ten
+ ELEVEN
+ twelve '''
+ thirteen
+ fourteen
+
+5 similar lines in 2 files
+==%s:0
+==%s:0
+ import one
+ from two import two
+ three
+ four
+ five
+TOTAL lines=60 duplicates=13 percent=21.67
+"""
+ % ((SIMILAR1, SIMILAR2) * 2)
+ ).strip()
+ )
+
+
+def test_ignore_imports():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run(["--ignore-imports", SIMILAR1, SIMILAR2])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == """
+TOTAL lines=60 duplicates=0 percent=0.00
+""".strip()
+ )
+
+
+def test_multiline_imports():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run([MULTILINE, MULTILINE])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == (
+ """
+8 similar lines in 2 files
+==%s:0
+==%s:0
+ from foo import (
+ bar,
+ baz,
+ quux,
+ quuux,
+ quuuux,
+ quuuuux,
+ )
+TOTAL lines=16 duplicates=8 percent=50.00
+"""
+ % (MULTILINE, MULTILINE)
+ ).strip()
+ )
+
+
+def test_ignore_multiline_imports():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run(["--ignore-imports", MULTILINE, MULTILINE])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == """
+TOTAL lines=16 duplicates=0 percent=0.00
+""".strip()
+ )
+
+
+def test_ignore_signatures_fail():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run([SIMILAR5, SIMILAR6])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == (
+ """
+7 similar lines in 2 files
+==%s:1
+==%s:8
+ arg1: int = 3,
+ arg2: Class1 = val1,
+ arg3: Class2 = func3(val2),
+ arg4: int = 4,
+ arg5: int = 5
+ ) -> Ret1:
+ pass
+TOTAL lines=23 duplicates=7 percent=30.43
+"""
+ % (SIMILAR5, SIMILAR6)
+ ).strip()
+ )
+
+
+def test_ignore_signatures_pass():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run(["--ignore-signatures", SIMILAR5, SIMILAR6])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == """
+TOTAL lines=23 duplicates=0 percent=0.00
+""".strip()
+ )
+
+
+def test_no_hide_code_with_imports():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run(["--ignore-imports"] + 2 * [HIDE_CODE_WITH_IMPORTS])
+ assert ex.value.code == 0
+ assert "TOTAL lines=32 duplicates=16 percent=50.00" in output.getvalue()
+
+
+def test_ignore_nothing():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run([SIMILAR1, SIMILAR2])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == (
+ """
+5 similar lines in 2 files
+==%s:0
+==%s:0
+ import one
+ from two import two
+ three
+ four
+ five
+TOTAL lines=60 duplicates=5 percent=8.33
+"""
+ % (SIMILAR1, SIMILAR2)
+ ).strip()
+ )
+
+
+def test_lines_without_meaningful_content_do_not_trigger_similarity():
+ output = StringIO()
+ with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+ similar.Run([SIMILAR3, SIMILAR4])
+ assert ex.value.code == 0
+ assert (
+ output.getvalue().strip()
+ == (
+ """
+14 similar lines in 2 files
+==%s:11
+==%s:11
+ b = (
+ (
+ [
+ "Lines 12-25 still trigger a similarity...",
+ "...warning, because..."
+ ],
+ [
+ "...even after ignoring lines with only symbols..."
+ ],
+ ),
+ (
+ "...there are still 5 similar lines in this code block.",
+ )
+ )
+TOTAL lines=50 duplicates=14 percent=28.00
+"""
+ % (SIMILAR3, SIMILAR4)
+ ).strip()
+ )
+
+
+def test_help():
+ output = StringIO()
+ with redirect_stdout(output):
+ try:
+ similar.Run(["--help"])
+ except SystemExit as ex:
+ assert ex.code == 0
+ else:
+ pytest.fail("not system exit")
+
+
+def test_no_args():
+ output = StringIO()
+ with redirect_stdout(output):
+ try:
+ similar.Run([])
+ except SystemExit as ex:
+ assert ex.code == 1
+ else:
+ pytest.fail("not system exit")
+
+
+def test_get_map_data():
+ """Tests that a SimilarChecker respects the MapReduceMixin interface"""
+ linter = PyLinter(reporter=Reporter())
+
+ # Add a parallel checker to ensure it can map and reduce
+ linter.register_checker(similar.SimilarChecker(linter))
+
+ source_streams = (
+ str(INPUT / "similar_lines_a.py"),
+ str(INPUT / "similar_lines_b.py"),
+ )
+ expected_linelists = (
+ (
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "def adipiscing(elit):",
+ 'etiam = "id"',
+ 'dictum = "purus,"',
+ 'vitae = "pretium"',
+ 'neque = "Vivamus"',
+ 'nec = "ornare"',
+ 'tortor = "sit"',
+ "return etiam, dictum, vitae, neque, nec, tortor",
+ "",
+ "",
+ "class Amet:",
+ "def similar_function_3_lines(self, tellus):",
+ "agittis = 10",
+ "tellus *= 300",
+ "return agittis, tellus",
+ "",
+ "def lorem(self, ipsum):",
+ 'dolor = "sit"',
+ 'amet = "consectetur"',
+ "return (lorem, dolor, amet)",
+ "",
+ "def similar_function_5_lines(self, similar):",
+ "some_var = 10",
+ "someother_var *= 300",
+ 'fusce = "sit"',
+ 'amet = "tortor"',
+ "return some_var, someother_var, fusce, amet",
+ "",
+ 'def __init__(self, moleskie, lectus="Mauris", ac="pellentesque"):',
+ 'metus = "ut"',
+ 'lobortis = "urna."',
+ 'Integer = "nisl"',
+ '(mauris,) = "interdum"',
+ 'non = "odio"',
+ 'semper = "aliquam"',
+ 'malesuada = "nunc."',
+ 'iaculis = "dolor"',
+ 'facilisis = "ultrices"',
+ 'vitae = "ut."',
+ "",
+ "return (",
+ "metus,",
+ "lobortis,",
+ "Integer,",
+ "mauris,",
+ "non,",
+ "semper,",
+ "malesuada,",
+ "iaculis,",
+ "facilisis,",
+ "vitae,",
+ ")",
+ "",
+ "def similar_function_3_lines(self, tellus):",
+ "agittis = 10",
+ "tellus *= 300",
+ "return agittis, tellus",
+ ),
+ (
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "class Nulla:",
+ 'tortor = "ultrices quis porta in"',
+ 'sagittis = "ut tellus"',
+ "",
+ "def pulvinar(self, blandit, metus):",
+ "egestas = [mauris for mauris in zip(blandit, metus)]",
+ "neque = (egestas, blandit)",
+ "",
+ "def similar_function_5_lines(self, similar):",
+ "some_var = 10",
+ "someother_var *= 300",
+ 'fusce = "sit"',
+ 'amet = "tortor"',
+ 'iaculis = "dolor"',
+ "return some_var, someother_var, fusce, amet, iaculis, iaculis",
+ "",
+ "",
+ "def tortor(self):",
+ "ultrices = 2",
+ 'quis = ultricies * "porta"',
+ "return ultricies, quis",
+ "",
+ "",
+ "class Commodo:",
+ "def similar_function_3_lines(self, tellus):",
+ "agittis = 10",
+ "tellus *= 300",
+ 'laoreet = "commodo "',
+ "return agittis, tellus, laoreet",
+ ),
+ )
+
+ data = []
+
+ # Manually perform a 'map' type function
+ for source_fname in source_streams:
+ sim = similar.SimilarChecker(linter)
+ with open(source_fname) as stream:
+ sim.append_stream(source_fname, stream)
+ # The map bit, can you tell? ;)
+ data.extend(sim.get_map_data())
+
+ assert len(expected_linelists) == len(data)
+ for source_fname, expected_lines, lineset_obj in zip(
+ source_streams, expected_linelists, data
+ ):
+ assert source_fname == lineset_obj.name
+ # There doesn't seem to be a faster way of doing this, yet.
+ lines = (line for idx, line in lineset_obj.enumerate_stripped())
+ assert tuple(expected_lines) == tuple(lines)
diff --git a/tests/checkers/unittest_spelling.py b/tests/checkers/unittest_spelling.py
new file mode 100644
index 0000000..009ec21
--- /dev/null
+++ b/tests/checkers/unittest_spelling.py
@@ -0,0 +1,614 @@
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017, 2020 Pedro Algarvio <pedro@algarvio.me>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 agutole <toldo_carp@hotmail.com>
+# Copyright (c) 2020 Ganden Schaffner <gschaffner@pm.me>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Eli Fine <ejfine@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unittest for the spelling checker."""
+
+import astroid
+import pytest
+
+from pylint.checkers import spelling
+from pylint.testutils import CheckerTestCase, Message, _tokenize_str, set_config
+
+# try to create enchant dictionary
+try:
+ import enchant
+except ImportError:
+ enchant = None
+
+spell_dict = None
+if enchant is not None:
+ try:
+ enchant.Dict("en_US")
+ spell_dict = "en_US"
+ except enchant.DictNotFoundError:
+ pass
+
+
+class TestSpellingChecker(CheckerTestCase): # pylint:disable=too-many-public-methods
+ # This is a test case class, not sure why it would be relevant to have
+ # this pylint rule enforced for test case classes.
+ CHECKER_CLASS = spelling.SpellingChecker
+
+ skip_on_missing_package_or_dict = pytest.mark.skipif(
+ spell_dict is None,
+ reason="missing python-enchant package or missing spelling dictionaries",
+ )
+
+ def _get_msg_suggestions(self, word, count=4):
+ suggestions = "' or '".join(self.checker.spelling_dict.suggest(word)[:count])
+ return f"'{suggestions}'"
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_check_bad_coment(self):
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ "coment",
+ "# bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.process_tokens(_tokenize_str("# bad coment"))
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ @set_config(max_spelling_suggestions=2)
+ def test_check_bad_coment_custom_suggestion_count(self):
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ "coment",
+ "# bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment", count=2),
+ ),
+ )
+ ):
+ self.checker.process_tokens(_tokenize_str("# bad coment"))
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_check_bad_docstring(self):
+ stmt = astroid.extract_node('def fff():\n """bad coment"""\n pass')
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "coment",
+ "bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.visit_functiondef(stmt)
+
+ stmt = astroid.extract_node('class Abc(object):\n """bad coment"""\n pass')
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "coment",
+ "bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.visit_classdef(stmt)
+
+ @pytest.mark.skipif(True, reason="pyenchant's tokenizer strips these")
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_invalid_docstring_characters(self):
+ stmt = astroid.extract_node('def fff():\n """test\\x00"""\n pass')
+ with self.assertAddsMessages(
+ Message("invalid-characters-in-docstring", line=2, args=("test\x00",))
+ ):
+ self.checker.visit_functiondef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_shebangs(self):
+ self.checker.process_tokens(_tokenize_str("#!/usr/bin/env python"))
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_python_coding_comments(self):
+ self.checker.process_tokens(_tokenize_str("# -*- coding: utf-8 -*-"))
+ assert self.linter.release_messages() == []
+ self.checker.process_tokens(_tokenize_str("# coding=utf-8"))
+ assert self.linter.release_messages() == []
+ self.checker.process_tokens(_tokenize_str("# vim: set fileencoding=utf-8 :"))
+ assert self.linter.release_messages() == []
+ # Now with a shebang first
+ self.checker.process_tokens(
+ _tokenize_str("#!/usr/bin/env python\n# -*- coding: utf-8 -*-")
+ )
+ assert self.linter.release_messages() == []
+ self.checker.process_tokens(
+ _tokenize_str("#!/usr/bin/env python\n# coding=utf-8")
+ )
+ assert self.linter.release_messages() == []
+ self.checker.process_tokens(
+ _tokenize_str("#!/usr/bin/env python\n# vim: set fileencoding=utf-8 :")
+ )
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_top_level_pylint_enable_disable_comments(self):
+ self.checker.process_tokens(
+ _tokenize_str("# Line 1\n Line 2\n# pylint: disable=ungrouped-imports")
+ )
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_words_with_numbers(self):
+ self.checker.process_tokens(_tokenize_str("\n# 0ne\n# Thr33\n# Sh3ll"))
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_wiki_words(self):
+ stmt = astroid.extract_node(
+ 'class ComentAbc(object):\n """ComentAbc with a bad coment"""\n pass'
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "coment",
+ "ComentAbc with a bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.visit_classdef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_camel_cased_words(self):
+ stmt = astroid.extract_node(
+ 'class ComentAbc(object):\n """comentAbc with a bad coment"""\n pass'
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "coment",
+ "comentAbc with a bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.visit_classdef(stmt)
+
+ # With just a single upper case letter in the end
+ stmt = astroid.extract_node(
+ 'class ComentAbc(object):\n """argumentN with a bad coment"""\n pass'
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "coment",
+ "argumentN with a bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.visit_classdef(stmt)
+
+ for ccn in (
+ "xmlHttpRequest",
+ "newCustomer",
+ "newCustomerId",
+ "innerStopwatch",
+ "supportsIpv6OnIos",
+ "affine3D",
+ ):
+ stmt = astroid.extract_node(
+ f'class TestClass(object):\n """{ccn} comment"""\n pass'
+ )
+ self.checker.visit_classdef(stmt)
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_words_with_underscores(self):
+ stmt = astroid.extract_node(
+ 'def fff(param_name):\n """test param_name"""\n pass'
+ )
+ self.checker.visit_functiondef(stmt)
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_email_address(self):
+ self.checker.process_tokens(_tokenize_str("# uname@domain.tld"))
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_urls(self):
+ self.checker.process_tokens(_tokenize_str("# https://github.com/rfk/pyenchant"))
+ assert self.linter.release_messages() == []
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_sphinx_directives(self):
+ stmt = astroid.extract_node(
+ 'class ComentAbc(object):\n """This is :class:`ComentAbc` with a bad coment"""\n pass'
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "coment",
+ "This is :class:`ComentAbc` with a bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.visit_classdef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_sphinx_directives_2(self):
+ stmt = astroid.extract_node(
+ 'class ComentAbc(object):\n """This is :py:attr:`ComentAbc` with a bad coment"""\n pass'
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "coment",
+ "This is :py:attr:`ComentAbc` with a bad coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ )
+ ):
+ self.checker.visit_classdef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ @pytest.mark.parametrize(
+ ",".join(
+ (
+ "misspelled_portion_of_directive",
+ "second_portion_of_directive",
+ "description",
+ )
+ ),
+ (
+ ("fmt", ": on", "black directive to turn on formatting"),
+ ("fmt", ": off", "black directive to turn off formatting"),
+ ("noqa", "", "pycharm directive"),
+ ("noqa", ":", "flake8 / zimports directive"),
+ ("nosec", "", "bandit directive"),
+ ("isort", ":skip", "isort directive"),
+ ("mypy", ":", "mypy directive"),
+ ),
+ )
+ def test_skip_tool_directives_at_beginning_of_comments_but_still_raise_error_if_directive_appears_later_in_comment( # pylint:disable=unused-argument
+ # Having the extra description parameter allows the description
+ # to show up in the pytest output as part of the test name
+ # when running parametrized tests.
+ self,
+ misspelled_portion_of_directive,
+ second_portion_of_directive,
+ description,
+ ):
+ full_comment = f"# {misspelled_portion_of_directive}{second_portion_of_directive} {misspelled_portion_of_directive}"
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ misspelled_portion_of_directive,
+ full_comment,
+ f" {'^'*len(misspelled_portion_of_directive)}",
+ self._get_msg_suggestions(misspelled_portion_of_directive),
+ ),
+ )
+ ):
+ self.checker.process_tokens(_tokenize_str(full_comment))
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_code_flanked_in_double_backticks(self):
+ full_comment = "# The function ``.qsize()`` .qsize()"
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ "qsize",
+ full_comment,
+ " ^^^^^",
+ self._get_msg_suggestions("qsize"),
+ ),
+ )
+ ):
+ self.checker.process_tokens(_tokenize_str(full_comment))
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_skip_code_flanked_in_single_backticks(self):
+ full_comment = "# The function `.qsize()` .qsize()"
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ "qsize",
+ full_comment,
+ " ^^^^^",
+ self._get_msg_suggestions("qsize"),
+ ),
+ )
+ ):
+ self.checker.process_tokens(_tokenize_str(full_comment))
+
+ @skip_on_missing_package_or_dict
+ @set_config(
+ spelling_dict=spell_dict,
+ spelling_ignore_comment_directives="newdirective:,noqa",
+ )
+ def test_skip_directives_specified_in_pylintrc(self):
+ full_comment = "# newdirective: do this newdirective"
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ "newdirective",
+ full_comment,
+ " ^^^^^^^^^^^^",
+ self._get_msg_suggestions("newdirective"),
+ ),
+ )
+ ):
+ self.checker.process_tokens(_tokenize_str(full_comment))
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_handle_words_joined_by_forward_slash(self):
+ stmt = astroid.extract_node(
+ '''
+ class ComentAbc(object):
+ """This is Comment/Abcz with a bad comment"""
+ pass
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=3,
+ args=(
+ "Abcz",
+ "This is Comment/Abcz with a bad comment",
+ " ^^^^",
+ self._get_msg_suggestions("Abcz"),
+ ),
+ )
+ ):
+ self.checker.visit_classdef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_more_than_one_error_in_same_line_for_same_word_on_docstring(self):
+ stmt = astroid.extract_node(
+ 'class ComentAbc(object):\n """Check teh dummy comment teh"""\n pass'
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "teh",
+ "Check teh dummy comment teh",
+ " ^^^",
+ self._get_msg_suggestions("teh"),
+ ),
+ ),
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "teh",
+ "Check teh dummy comment teh",
+ " ^^^",
+ self._get_msg_suggestions("teh"),
+ ),
+ ),
+ ):
+ self.checker.visit_classdef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_more_than_one_error_in_same_line_for_same_word_on_comment(self):
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ "coment",
+ "# bad coment coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ ),
+ Message(
+ "wrong-spelling-in-comment",
+ line=1,
+ args=(
+ "coment",
+ "# bad coment coment",
+ " ^^^^^^",
+ self._get_msg_suggestions("coment"),
+ ),
+ ),
+ ):
+ self.checker.process_tokens(_tokenize_str("# bad coment coment"))
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_docstring_lines_that_look_like_comments_1(self):
+ stmt = astroid.extract_node(
+ '''def f():
+ """
+ # msitake
+ """'''
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=3,
+ args=(
+ "msitake",
+ " # msitake",
+ " ^^^^^^^",
+ self._get_msg_suggestions("msitake"),
+ ),
+ )
+ ):
+ self.checker.visit_functiondef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_docstring_lines_that_look_like_comments_2(self):
+ stmt = astroid.extract_node(
+ '''def f():
+ """# msitake"""'''
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=2,
+ args=(
+ "msitake",
+ "# msitake",
+ " ^^^^^^^",
+ self._get_msg_suggestions("msitake"),
+ ),
+ )
+ ):
+ self.checker.visit_functiondef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_docstring_lines_that_look_like_comments_3(self):
+ stmt = astroid.extract_node(
+ '''def f():
+ """
+# msitake
+ """'''
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=3,
+ args=(
+ "msitake",
+ "# msitake",
+ " ^^^^^^^",
+ self._get_msg_suggestions("msitake"),
+ ),
+ )
+ ):
+ self.checker.visit_functiondef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_docstring_lines_that_look_like_comments_4(self):
+ stmt = astroid.extract_node(
+ '''def f():
+ """
+ # cat
+ """'''
+ )
+ with self.assertAddsMessages():
+ self.checker.visit_functiondef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_docstring_lines_that_look_like_comments_5(self):
+ stmt = astroid.extract_node(
+ '''def f():
+ """
+ msitake # cat
+ """'''
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=3,
+ args=(
+ "msitake",
+ " msitake # cat",
+ " ^^^^^^^",
+ self._get_msg_suggestions("msitake"),
+ ),
+ )
+ ):
+ self.checker.visit_functiondef(stmt)
+
+ @skip_on_missing_package_or_dict
+ @set_config(spelling_dict=spell_dict)
+ def test_docstring_lines_that_look_like_comments_6(self):
+ stmt = astroid.extract_node(
+ '''def f():
+ """
+ cat # msitake
+ """'''
+ )
+ with self.assertAddsMessages(
+ Message(
+ "wrong-spelling-in-docstring",
+ line=3,
+ args=(
+ "msitake",
+ " cat # msitake",
+ " ^^^^^^^",
+ self._get_msg_suggestions("msitake"),
+ ),
+ )
+ ):
+ self.checker.visit_functiondef(stmt)
diff --git a/tests/checkers/unittest_stdlib.py b/tests/checkers/unittest_stdlib.py
new file mode 100644
index 0000000..962b33f
--- /dev/null
+++ b/tests/checkers/unittest_stdlib.py
@@ -0,0 +1,120 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Cezar <celnazli@bitdefender.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Martin <MartinBasti@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import contextlib
+
+import astroid
+
+from pylint.checkers import stdlib
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message
+
+
+@contextlib.contextmanager
+def _add_transform(manager, node, transform, predicate=None):
+ manager.register_transform(node, transform, predicate)
+ try:
+ yield
+ finally:
+ manager.unregister_transform(node, transform, predicate)
+
+
+class TestStdlibChecker(CheckerTestCase):
+ CHECKER_CLASS = stdlib.StdlibChecker
+
+ def test_deprecated_no_qname_on_unexpected_nodes(self):
+ # Test that we don't crash on nodes which don't have
+ # a qname method. While this test might seem weird since
+ # it uses a transform, it's actually testing a crash that
+ # happened in production, but there was no way to retrieve
+ # the code for which this occurred (how an AssignAttr
+ # got to be the result of a function inference
+ # beats me..)
+
+ def infer_func(node, context=None): # pylint: disable=unused-argument
+ new_node = astroid.AssignAttr()
+ new_node.parent = node
+ yield new_node
+
+ manager = astroid.MANAGER
+ transform = astroid.inference_tip(infer_func)
+ with _add_transform(manager, astroid.Name, transform):
+ node = astroid.extract_node(
+ """
+ call_something()
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_copy_environ(self):
+ # shallow copy of os.environ should be reported
+ node = astroid.extract_node(
+ """
+ import copy, os
+ copy.copy(os.environ)
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="shallow-copy-environ", node=node, confidence=UNDEFINED)
+ ):
+ self.checker.visit_call(node)
+
+ def test_copy_environ_hidden(self):
+ # shallow copy of os.environ should be reported
+ # hide function names to be sure that checker is not just matching text
+ node = astroid.extract_node(
+ """
+ from copy import copy as test_cp
+ import os as o
+ test_cp(o.environ)
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="shallow-copy-environ", node=node, confidence=UNDEFINED)
+ ):
+ self.checker.visit_call(node)
+
+ def test_copy_dict(self):
+ # copy of dict is OK
+ node = astroid.extract_node(
+ """
+ import copy
+ test_dict = {}
+ copy.copy(test_dict)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_copy_uninferable(self):
+ # copy of uninferable object should not raise exception, nor make
+ # the checker crash
+ node = astroid.extract_node(
+ """
+ import copy
+ from missing_library import MissingObject
+ copy.copy(MissingObject)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_deepcopy_environ(self):
+ # deepcopy of os.environ is OK
+ node = astroid.extract_node(
+ """
+ import copy, os
+ copy.deepcopy(os.environ)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
diff --git a/tests/checkers/unittest_strings.py b/tests/checkers/unittest_strings.py
new file mode 100644
index 0000000..12b2b51
--- /dev/null
+++ b/tests/checkers/unittest_strings.py
@@ -0,0 +1,92 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Yury Gribov <tetra2005@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import astroid
+
+from pylint.checkers import strings
+from pylint.testutils import CheckerTestCase, Message
+
+TEST_TOKENS = (
+ '"X"',
+ "'X'",
+ "'''X'''",
+ '"""X"""',
+ 'r"X"',
+ "R'X'",
+ 'u"X"',
+ "F'X'",
+ 'f"X"',
+ "F'X'",
+ 'fr"X"',
+ 'Fr"X"',
+ 'fR"X"',
+ 'FR"X"',
+ 'rf"X"',
+ 'rF"X"',
+ 'Rf"X"',
+ 'RF"X"',
+)
+
+
+class TestStringChecker(CheckerTestCase):
+ CHECKER_CLASS = strings.StringFormatChecker
+
+ def test_format_bytes(self):
+ code = "b'test'.format(1, 2)"
+ node = astroid.extract_node(code)
+ with self.assertNoMessages():
+ self.checker.visit_call(node)
+
+ def test_format_types(self):
+ for code in ("'%s' % 1", "'%d' % 1", "'%f' % 1"):
+ with self.assertNoMessages():
+ node = astroid.extract_node(code)
+ self.checker.visit_binop(node)
+
+ for code in (
+ "'%s' % 1",
+ "'%(key)s' % {'key' : 1}",
+ "'%d' % 1",
+ "'%(key)d' % {'key' : 1}",
+ "'%f' % 1",
+ "'%(key)f' % {'key' : 1}",
+ "'%d' % 1.1",
+ "'%(key)d' % {'key' : 1.1}",
+ "'%s' % []",
+ "'%(key)s' % {'key' : []}",
+ "'%s' % None",
+ "'%(key)s' % {'key' : None}",
+ ):
+ with self.assertNoMessages():
+ node = astroid.extract_node(code)
+ self.checker.visit_binop(node)
+
+ for code, arg_type, format_type in (
+ ("'%d' % '1'", "builtins.str", "d"),
+ ("'%(key)d' % {'key' : '1'}", "builtins.str", "d"),
+ ("'%x' % 1.1", "builtins.float", "x"),
+ ("'%(key)x' % {'key' : 1.1}", "builtins.float", "x"),
+ ("'%d' % []", "builtins.list", "d"),
+ ("'%(key)d' % {'key' : []}", "builtins.list", "d"),
+ ):
+ node = astroid.extract_node(code)
+ with self.assertAddsMessages(
+ Message(
+ "bad-string-format-type", node=node, args=(arg_type, format_type)
+ )
+ ):
+ self.checker.visit_binop(node)
+
+
+def test_str_eval():
+ for token in TEST_TOKENS:
+ assert strings.str_eval(token) == "X"
diff --git a/tests/checkers/unittest_typecheck.py b/tests/checkers/unittest_typecheck.py
new file mode 100644
index 0000000..88d3dab
--- /dev/null
+++ b/tests/checkers/unittest_typecheck.py
@@ -0,0 +1,490 @@
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Holger Peters <email@holger-peters.de>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Filipe Brandenburger <filbranden@google.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 Martin Vielsmaier <martin.vielsmaier@gmail.com>
+# Copyright (c) 2019 Federico Bond <federicobond@gmail.com>
+# Copyright (c) 2020 Julien Palard <julien@palard.fr>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 David Gilman <davidgilman1@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import astroid
+import pytest
+
+from pylint.checkers import typecheck
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+try:
+ from coverage import tracer as _ # pylint: disable=unused-import
+
+ C_EXTENTIONS_AVAILABLE = True
+except ImportError:
+ _ = None
+ C_EXTENTIONS_AVAILABLE = False
+
+needs_c_extension = pytest.mark.skipif(
+ not C_EXTENTIONS_AVAILABLE, reason="Requires coverage (source of C-extension)"
+)
+
+
+class TestTypeChecker(CheckerTestCase):
+ "Tests for pylint.checkers.typecheck"
+ CHECKER_CLASS = typecheck.TypeChecker
+
+ def test_no_member_in_getattr(self):
+ """Make sure that a module attribute access is checked by pylint."""
+
+ node = astroid.extract_node(
+ """
+ import optparse
+ optparse.THIS_does_not_EXIST
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ "no-member",
+ node=node,
+ args=("Module", "optparse", "THIS_does_not_EXIST", ""),
+ )
+ ):
+ self.checker.visit_attribute(node)
+
+ @set_config(ignored_modules=("argparse",))
+ def test_no_member_in_getattr_ignored(self):
+ """Make sure that a module attribute access check is omitted with a
+ module that is configured to be ignored.
+ """
+
+ node = astroid.extract_node(
+ """
+ import argparse
+ argparse.THIS_does_not_EXIST
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ @set_config(ignored_modules=("xml.etree.",))
+ def test_ignored_modules_invalid_pattern(self):
+ node = astroid.extract_node(
+ """
+ import xml
+ xml.etree.Lala
+ """
+ )
+ message = Message(
+ "no-member", node=node, args=("Module", "xml.etree", "Lala", "")
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ @set_config(ignored_modules=("xml",))
+ def test_ignored_modules_root_one_applies_as_well(self):
+ # Check that when a root module is completely ignored, submodules are skipped.
+ node = astroid.extract_node(
+ """
+ import xml
+ xml.etree.Lala
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ @set_config(ignored_modules=("xml.etree*",))
+ def test_ignored_modules_patterns(self):
+ node = astroid.extract_node(
+ """
+ import xml
+ xml.etree.portocola #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ @set_config(ignored_classes=("xml.*",))
+ def test_ignored_classes_no_recursive_pattern(self):
+ node = astroid.extract_node(
+ """
+ import xml
+ xml.etree.ElementTree.Test
+ """
+ )
+ message = Message(
+ "no-member", node=node, args=("Module", "xml.etree.ElementTree", "Test", "")
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ @set_config(ignored_classes=("optparse.Values",))
+ def test_ignored_classes_qualified_name(self):
+ """Test that ignored-classes supports qualified name for ignoring."""
+ node = astroid.extract_node(
+ """
+ import optparse
+ optparse.Values.lala
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ @set_config(ignored_classes=("Values",))
+ def test_ignored_classes_only_name(self):
+ """Test that ignored_classes works with the name only."""
+ node = astroid.extract_node(
+ """
+ import optparse
+ optparse.Values.lala
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_attribute(node)
+
+ @set_config(suggestion_mode=False)
+ @needs_c_extension
+ def test_nomember_on_c_extension_error_msg(self):
+ node = astroid.extract_node(
+ """
+ from coverage import tracer
+ tracer.CTracer #@
+ """
+ )
+ message = Message(
+ "no-member", node=node, args=("Module", "coverage.tracer", "CTracer", "")
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ @set_config(suggestion_mode=True)
+ @needs_c_extension
+ def test_nomember_on_c_extension_info_msg(self):
+ node = astroid.extract_node(
+ """
+ from coverage import tracer
+ tracer.CTracer #@
+ """
+ )
+ message = Message(
+ "c-extension-no-member",
+ node=node,
+ args=("Module", "coverage.tracer", "CTracer", ""),
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_attribute(node)
+
+ @set_config(
+ contextmanager_decorators=(
+ "contextlib.contextmanager",
+ ".custom_contextmanager",
+ )
+ )
+ def test_custom_context_manager(self):
+ """Test that @custom_contextmanager is recognized as configured."""
+ node = astroid.extract_node(
+ """
+ from contextlib import contextmanager
+ def custom_contextmanager(f):
+ return contextmanager(f)
+ @custom_contextmanager
+ def dec():
+ yield
+ with dec():
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_with(node)
+
+ def test_invalid_metaclass(self):
+ module = astroid.parse(
+ """
+ class InvalidAsMetaclass(object):
+ pass
+
+ class FirstInvalid(object, metaclass=int):
+ pass
+
+ class SecondInvalid(object, metaclass=InvalidAsMetaclass):
+ pass
+
+ class ThirdInvalid(object, metaclass=2):
+ pass
+ """
+ )
+ for class_obj, metaclass_name in (
+ ("ThirdInvalid", "2"),
+ ("SecondInvalid", "InvalidAsMetaclass"),
+ ("FirstInvalid", "int"),
+ ):
+ classdef = module[class_obj]
+ message = Message(
+ "invalid-metaclass", node=classdef, args=(metaclass_name,)
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_classdef(classdef)
+
+ def test_invalid_metaclass_function_metaclasses(self):
+ module = astroid.parse(
+ """
+ def invalid_metaclass_1(name, bases, attrs):
+ return int
+ def invalid_metaclass_2(name, bases, attrs):
+ return 1
+ class Invalid(metaclass=invalid_metaclass_1):
+ pass
+ class InvalidSecond(metaclass=invalid_metaclass_2):
+ pass
+ """
+ )
+ for class_obj, metaclass_name in (("Invalid", "int"), ("InvalidSecond", "1")):
+ classdef = module[class_obj]
+ message = Message(
+ "invalid-metaclass", node=classdef, args=(metaclass_name,)
+ )
+ with self.assertAddsMessages(message):
+ self.checker.visit_classdef(classdef)
+
+ def test_typing_namedtuple_not_callable_issue1295(self):
+ module = astroid.parse(
+ """
+ import typing
+ Named = typing.NamedTuple('Named', [('foo', int), ('bar', int)])
+ named = Named(1, 2)
+ """
+ )
+ call = module.body[-1].value
+ callables = call.func.inferred()
+ assert len(callables) == 1
+ assert callables[0].callable()
+ with self.assertNoMessages():
+ self.checker.visit_call(call)
+
+ def test_typing_namedtuple_unsubscriptable_object_issue1295(self):
+ module = astroid.parse(
+ """
+ import typing
+ MyType = typing.Tuple[str, str]
+ """
+ )
+ subscript = module.body[-1].value
+ with self.assertNoMessages():
+ self.checker.visit_subscript(subscript)
+
+ def test_staticmethod_multiprocessing_call(self):
+ """Make sure not-callable isn't raised for descriptors
+
+ astroid can't process descriptors correctly so
+ pylint needs to ignore not-callable for them
+ right now
+
+ Test for https://github.com/PyCQA/pylint/issues/1699
+ """
+ call = astroid.extract_node(
+ """
+ import multiprocessing
+ multiprocessing.current_process() #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(call)
+
+ def test_not_callable_uninferable_property(self):
+ """Make sure not-callable isn't raised for uninferable
+ properties
+ """
+ call = astroid.extract_node(
+ """
+ class A:
+ @property
+ def call(self):
+ return undefined
+
+ a = A()
+ a.call() #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(call)
+
+ def test_descriptor_call(self):
+ call = astroid.extract_node(
+ """
+ def func():
+ pass
+
+ class ADescriptor:
+ def __get__(self, instance, owner):
+ return func
+
+ class AggregateCls:
+ a = ADescriptor()
+
+ AggregateCls().a() #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_call(call)
+
+ def test_unknown_parent(self):
+ """Make sure the callable check does not crash when a node's parent
+ cannot be determined.
+ """
+ call = astroid.extract_node(
+ """
+ def get_num(n):
+ return 2 * n
+ get_num(10)()
+ """
+ )
+ with self.assertAddsMessages(
+ Message("not-callable", node=call, args="get_num(10)")
+ ):
+ self.checker.visit_call(call)
+
+
+class TestTypeCheckerOnDecorators(CheckerTestCase):
+ "Tests for pylint.checkers.typecheck on decorated functions."
+ CHECKER_CLASS = typecheck.TypeChecker
+
+ def test_issue3882_class_decorators(self):
+ decorators = """
+ class Unsubscriptable:
+ def __init__(self, f):
+ self.f = f
+
+ class Subscriptable:
+ def __init__(self, f):
+ self.f = f
+
+ def __getitem__(self, item):
+ return item
+ """
+ for generic in "Optional", "List", "ClassVar", "Final", "Literal":
+ self.typing_objects_are_subscriptable(generic)
+
+ self.getitem_on_modules()
+ self.decorated_by_a_subscriptable_class(decorators)
+ self.decorated_by_an_unsubscriptable_class(decorators)
+
+ self.decorated_by_subscriptable_then_unsubscriptable_class(decorators)
+ self.decorated_by_unsubscriptable_then_subscriptable_class(decorators)
+
+ def getitem_on_modules(self):
+ """Mainly validate the code won't crash if we're not having a function."""
+ module = astroid.parse(
+ """
+ import collections
+ test = collections[int]
+ """
+ )
+ subscript = module.body[-1].value
+ with self.assertAddsMessages(
+ Message(
+ "unsubscriptable-object",
+ node=subscript.value,
+ args="collections",
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_subscript(subscript)
+
+ def typing_objects_are_subscriptable(self, generic):
+ module = astroid.parse(
+ f"""
+ import typing
+ test = typing.{generic}[int]
+ """
+ )
+ subscript = module.body[-1].value
+ with self.assertNoMessages():
+ self.checker.visit_subscript(subscript)
+
+ def decorated_by_a_subscriptable_class(self, decorators):
+ module = astroid.parse(
+ decorators
+ + """
+ @Subscriptable
+ def decorated():
+ ...
+
+ test = decorated[None]
+ """
+ )
+ subscript = module.body[-1].value
+ with self.assertNoMessages():
+ self.checker.visit_subscript(subscript)
+
+ def decorated_by_subscriptable_then_unsubscriptable_class(self, decorators):
+ module = astroid.parse(
+ decorators
+ + """
+ @Unsubscriptable
+ @Subscriptable
+ def decorated():
+ ...
+
+ test = decorated[None]
+ """
+ )
+ subscript = module.body[-1].value
+ with self.assertAddsMessages(
+ Message(
+ "unsubscriptable-object",
+ node=subscript.value,
+ args="decorated",
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_subscript(subscript)
+
+ def decorated_by_unsubscriptable_then_subscriptable_class(self, decorators):
+ module = astroid.parse(
+ decorators
+ + """
+ @Subscriptable
+ @Unsubscriptable
+ def decorated():
+ ...
+
+ test = decorated[None]
+ """
+ )
+ subscript = module.body[-1].value
+ with self.assertNoMessages():
+ self.checker.visit_subscript(subscript)
+
+ def decorated_by_an_unsubscriptable_class(self, decorators):
+ module = astroid.parse(
+ decorators
+ + """
+ @Unsubscriptable
+ def decorated():
+ ...
+
+ test = decorated[None]
+ """
+ )
+ subscript = module.body[-1].value
+ with self.assertAddsMessages(
+ Message(
+ "unsubscriptable-object",
+ node=subscript.value,
+ args="decorated",
+ confidence=UNDEFINED,
+ )
+ ):
+ self.checker.visit_subscript(subscript)
diff --git a/tests/checkers/unittest_utils.py b/tests/checkers/unittest_utils.py
new file mode 100644
index 0000000..18115bf
--- /dev/null
+++ b/tests/checkers/unittest_utils.py
@@ -0,0 +1,398 @@
+# Copyright (c) 2010 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Alan Chan <achan961117@gmail.com>
+# Copyright (c) 2018 Caio Carrara <ccarrara@redhat.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 Nathan Marrow <nmarrow@google.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint.checkers.utils module."""
+
+import astroid
+import pytest
+
+from pylint.checkers import utils
+
+
+@pytest.mark.parametrize(
+ "name,expected",
+ [
+ ("min", True),
+ ("__builtins__", True),
+ ("__path__", False),
+ ("__file__", False),
+ ("whatever", False),
+ ("mybuiltin", False),
+ ],
+)
+def testIsBuiltin(name, expected):
+ assert utils.is_builtin(name) == expected
+
+
+@pytest.mark.parametrize(
+ "fn,kw",
+ [("foo(3)", {"keyword": "bar"}), ("foo(one=a, two=b, three=c)", {"position": 1})],
+)
+def testGetArgumentFromCallError(fn, kw):
+ with pytest.raises(utils.NoSuchArgumentError):
+ node = astroid.extract_node(fn)
+ utils.get_argument_from_call(node, **kw)
+
+
+@pytest.mark.parametrize(
+ "fn,kw", [("foo(bar=3)", {"keyword": "bar"}), ("foo(a, b, c)", {"position": 1})]
+)
+def testGetArgumentFromCallExists(fn, kw):
+ node = astroid.extract_node(fn)
+ assert utils.get_argument_from_call(node, **kw) is not None
+
+
+def testGetArgumentFromCall():
+ node = astroid.extract_node("foo(a, not_this_one=1, this_one=2)")
+ arg = utils.get_argument_from_call(node, position=2, keyword="this_one")
+ assert arg.value == 2
+
+ node = astroid.extract_node("foo(a)")
+ with pytest.raises(utils.NoSuchArgumentError):
+ utils.get_argument_from_call(node, position=1)
+ with pytest.raises(ValueError):
+ utils.get_argument_from_call(node, None, None)
+ name = utils.get_argument_from_call(node, position=0)
+ assert name.name == "a"
+
+
+def test_error_of_type():
+ nodes = astroid.extract_node(
+ """
+ try: pass
+ except AttributeError: #@
+ pass
+ try: pass
+ except Exception: #@
+ pass
+ except: #@
+ pass
+ """
+ )
+ assert utils.error_of_type(nodes[0], AttributeError)
+ assert utils.error_of_type(nodes[0], (AttributeError,))
+ assert not utils.error_of_type(nodes[0], Exception)
+ assert utils.error_of_type(nodes[1], Exception)
+
+
+def test_node_ignores_exception():
+ nodes = astroid.extract_node(
+ """
+ try:
+ 1/0 #@
+ except ZeroDivisionError:
+ pass
+ try:
+ 1/0 #@
+ except Exception:
+ pass
+ try:
+ 2/0 #@
+ except:
+ pass
+ try:
+ 1/0 #@
+ except ValueError:
+ pass
+ """
+ )
+ assert utils.node_ignores_exception(nodes[0], ZeroDivisionError)
+ assert not utils.node_ignores_exception(nodes[1], ZeroDivisionError)
+ assert not utils.node_ignores_exception(nodes[2], ZeroDivisionError)
+ assert not utils.node_ignores_exception(nodes[3], ZeroDivisionError)
+
+
+def test_is_subclass_of_node_b_derived_from_node_a():
+ nodes = astroid.extract_node(
+ """
+ class Superclass: #@
+ pass
+
+ class Subclass(Superclass): #@
+ pass
+ """
+ )
+ assert utils.is_subclass_of(nodes[1], nodes[0])
+
+
+def test_is_subclass_of_node_b_not_derived_from_node_a():
+ nodes = astroid.extract_node(
+ """
+ class OneClass: #@
+ pass
+
+ class AnotherClass: #@
+ pass
+ """
+ )
+ assert not utils.is_subclass_of(nodes[1], nodes[0])
+
+
+def test_is_subclass_of_not_classdefs():
+ node = astroid.extract_node(
+ """
+ class OneClass: #@
+ pass
+ """
+ )
+ assert not utils.is_subclass_of(None, node)
+ assert not utils.is_subclass_of(node, None)
+ assert not utils.is_subclass_of(None, None)
+
+
+def test_parse_format_method_string():
+ samples = [
+ ("{}", 1),
+ ("{}:{}", 2),
+ ("{field}", 1),
+ ("{:5}", 1),
+ ("{:10}", 1),
+ ("{field:10}", 1),
+ ("{field:10}{{}}", 1),
+ ("{:5}{!r:10}", 2),
+ ("{:5}{}{{}}{}", 3),
+ ("{0}{1}{0}", 2),
+ ("Coordinates: {latitude}, {longitude}", 2),
+ ("X: {0[0]}; Y: {0[1]}", 1),
+ ("{:*^30}", 1),
+ ("{!r:}", 1),
+ ]
+ for fmt, count in samples:
+ keys, num_args, pos_args = utils.parse_format_method_string(fmt)
+ keyword_args = len({k for k, l in keys if not isinstance(k, int)})
+ assert keyword_args + num_args + pos_args == count
+
+
+def test_inherit_from_std_ex_recursive_definition():
+ node = astroid.extract_node(
+ """
+ import datetime
+ class First(datetime.datetime):
+ pass
+ class Second(datetime.datetime): #@
+ pass
+ datetime.datetime = First
+ datetime.datetime = Second
+ """
+ )
+ assert not utils.inherit_from_std_ex(node)
+
+
+def test_get_node_last_lineno_simple():
+ node = astroid.extract_node(
+ """
+ pass
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 2
+
+
+def test_get_node_last_lineno_if_simple():
+ node = astroid.extract_node(
+ """
+ if True:
+ print(1)
+ pass
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 4
+
+
+def test_get_node_last_lineno_if_elseif_else():
+ node = astroid.extract_node(
+ """
+ if True:
+ print(1)
+ elif False:
+ print(2)
+ else:
+ print(3)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 7
+
+
+def test_get_node_last_lineno_while():
+ node = astroid.extract_node(
+ """
+ while True:
+ print(1)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 3
+
+
+def test_get_node_last_lineno_while_else():
+ node = astroid.extract_node(
+ """
+ while True:
+ print(1)
+ else:
+ print(2)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 5
+
+
+def test_get_node_last_lineno_for():
+ node = astroid.extract_node(
+ """
+ for x in range(0, 5):
+ print(1)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 3
+
+
+def test_get_node_last_lineno_for_else():
+ node = astroid.extract_node(
+ """
+ for x in range(0, 5):
+ print(1)
+ else:
+ print(2)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 5
+
+
+def test_get_node_last_lineno_try():
+ node = astroid.extract_node(
+ """
+ try:
+ print(1)
+ except ValueError:
+ print(2)
+ except Exception:
+ print(3)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 7
+
+
+def test_get_node_last_lineno_try_except_else():
+ node = astroid.extract_node(
+ """
+ try:
+ print(1)
+ except Exception:
+ print(2)
+ print(3)
+ else:
+ print(4)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 8
+
+
+def test_get_node_last_lineno_try_except_finally():
+ node = astroid.extract_node(
+ """
+ try:
+ print(1)
+ except Exception:
+ print(2)
+ finally:
+ print(4)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 7
+
+
+def test_get_node_last_lineno_try_except_else_finally():
+ node = astroid.extract_node(
+ """
+ try:
+ print(1)
+ except Exception:
+ print(2)
+ else:
+ print(3)
+ finally:
+ print(4)
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 9
+
+
+def test_get_node_last_lineno_with():
+ node = astroid.extract_node(
+ """
+ with x as y:
+ print(1)
+ pass
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 4
+
+
+def test_get_node_last_lineno_method():
+ node = astroid.extract_node(
+ """
+ def x(a, b):
+ print(a, b)
+ pass
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 4
+
+
+def test_get_node_last_lineno_decorator():
+ node = astroid.extract_node(
+ """
+ @decor()
+ def x(a, b):
+ print(a, b)
+ pass
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 5
+
+
+def test_get_node_last_lineno_class():
+ node = astroid.extract_node(
+ """
+ class C(object):
+ CONST = True
+
+ def x(self, b):
+ print(b)
+
+ def y(self):
+ pass
+ pass
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 10
+
+
+def test_get_node_last_lineno_combined():
+ node = astroid.extract_node(
+ """
+ class C(object):
+ CONST = True
+
+ def y(self):
+ try:
+ pass
+ except:
+ pass
+ finally:
+ pass
+ """
+ )
+ assert utils.get_node_last_lineno(node) == 11
diff --git a/tests/checkers/unittest_variables.py b/tests/checkers/unittest_variables.py
new file mode 100644
index 0000000..90daa8d
--- /dev/null
+++ b/tests/checkers/unittest_variables.py
@@ -0,0 +1,354 @@
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 mar-chi-pan <mar.polatoglou@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Andrew Simmons <anjsimmo@gmail.com>
+# Copyright (c) 2020 Andrew Simmons <a.simmons@deakin.edu.au>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import os
+import re
+import sys
+from pathlib import Path
+
+import astroid
+
+from pylint.checkers import variables
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message, linter, set_config
+
+REGR_DATA_DIR = str(Path(__file__).parent / ".." / "regrtest_data")
+
+
+class TestVariablesChecker(CheckerTestCase):
+
+ CHECKER_CLASS = variables.VariablesChecker
+
+ def test_bitbucket_issue_78(self):
+ """Issue 78 report a false positive for unused-module"""
+ module = astroid.parse(
+ """
+ from sys import path
+ path += ['stuff']
+ def func():
+ other = 1
+ return len(other)
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(module)
+
+ @set_config(ignored_modules=("argparse",))
+ def test_no_name_in_module_skipped(self):
+ """Make sure that 'from ... import ...' does not emit a
+ 'no-name-in-module' with a module that is configured
+ to be ignored.
+ """
+
+ node = astroid.extract_node(
+ """
+ from argparse import THIS_does_not_EXIST
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_importfrom(node)
+
+ def test_all_elements_without_parent(self):
+ node = astroid.extract_node("__all__ = []")
+ node.value.elts.append(astroid.Const("test"))
+ root = node.root()
+ with self.assertNoMessages():
+ self.checker.visit_module(root)
+ self.checker.leave_module(root)
+
+ def test_redefined_builtin_ignored(self):
+ node = astroid.parse(
+ """
+ from future.builtins import open
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_module(node)
+
+ @set_config(redefining_builtins_modules=("os",))
+ def test_redefined_builtin_custom_modules(self):
+ node = astroid.parse(
+ """
+ from os import open
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_module(node)
+
+ @set_config(redefining_builtins_modules=("os",))
+ def test_redefined_builtin_modname_not_ignored(self):
+ node = astroid.parse(
+ """
+ from future.builtins import open
+ """
+ )
+ with self.assertAddsMessages(
+ Message("redefined-builtin", node=node.body[0], args="open")
+ ):
+ self.checker.visit_module(node)
+
+ @set_config(redefining_builtins_modules=("os",))
+ def test_redefined_builtin_in_function(self):
+ node = astroid.extract_node(
+ """
+ def test():
+ from os import open
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_module(node.root())
+ self.checker.visit_functiondef(node)
+
+ def test_unassigned_global(self):
+ node = astroid.extract_node(
+ """
+ def func():
+ global sys #@
+ import sys, lala
+ """
+ )
+ msg = Message("global-statement", node=node, confidence=UNDEFINED)
+ with self.assertAddsMessages(msg):
+ self.checker.visit_global(node)
+
+ def test_listcomp_in_decorator(self):
+ """Make sure class attributes in scope for listcomp in decorator.
+
+ https://github.com/PyCQA/pylint/issues/511
+ """
+ module = astroid.parse(
+ """
+ def dec(inp):
+ def inner(func):
+ print(inp)
+ return func
+ return inner
+
+
+ class Cls:
+
+ DATA = "foo"
+
+ @dec([x for x in DATA])
+ def fun(self):
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_listcomp_in_ancestors(self):
+ """Ensure list comprehensions in base classes are scoped correctly
+
+ https://github.com/PyCQA/pylint/issues/3434
+ """
+ module = astroid.parse(
+ """
+ import collections
+
+
+ l = ["a","b","c"]
+
+
+ class Foo(collections.namedtuple("Foo",[x+"_foo" for x in l])):
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(module)
+
+ def test_return_type_annotation(self):
+ """Make sure class attributes in scope for return type annotations.
+
+ https://github.com/PyCQA/pylint/issues/1976
+ """
+ module = astroid.parse(
+ """
+ class MyObject:
+ class MyType:
+ pass
+ def my_method(self) -> MyType:
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(module)
+
+
+class TestVariablesCheckerWithTearDown(CheckerTestCase):
+
+ CHECKER_CLASS = variables.VariablesChecker
+
+ def setup_method(self):
+ super().setup_method()
+ self._to_consume_backup = self.checker._to_consume
+ self.checker._to_consume = []
+
+ def teardown_method(self):
+ self.checker._to_consume = self._to_consume_backup
+
+ @set_config(callbacks=("callback_", "_callback"))
+ def test_custom_callback_string(self):
+ """Test the --calbacks option works."""
+ node = astroid.extract_node(
+ """
+ def callback_one(abc):
+ ''' should not emit unused-argument. '''
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+ self.checker.leave_functiondef(node)
+
+ node = astroid.extract_node(
+ """
+ def two_callback(abc, defg):
+ ''' should not emit unused-argument. '''
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+ self.checker.leave_functiondef(node)
+
+ node = astroid.extract_node(
+ """
+ def normal_func(abc):
+ ''' should emit unused-argument. '''
+ """
+ )
+ with self.assertAddsMessages(
+ Message("unused-argument", node=node["abc"], args="abc")
+ ):
+ self.checker.visit_functiondef(node)
+ self.checker.leave_functiondef(node)
+
+ node = astroid.extract_node(
+ """
+ def cb_func(abc):
+ ''' Previous callbacks are overridden. '''
+ """
+ )
+ with self.assertAddsMessages(
+ Message("unused-argument", node=node["abc"], args="abc")
+ ):
+ self.checker.visit_functiondef(node)
+ self.checker.leave_functiondef(node)
+
+ @set_config(redefining_builtins_modules=("os",))
+ def test_redefined_builtin_modname_not_ignored(self):
+ node = astroid.parse(
+ """
+ from future.builtins import open
+ """
+ )
+ with self.assertAddsMessages(
+ Message("redefined-builtin", node=node.body[0], args="open")
+ ):
+ self.checker.visit_module(node)
+
+ @set_config(redefining_builtins_modules=("os",))
+ def test_redefined_builtin_in_function(self):
+ node = astroid.extract_node(
+ """
+ def test():
+ from os import open
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_module(node.root())
+ self.checker.visit_functiondef(node)
+
+ def test_import_as_underscore(self):
+ node = astroid.parse(
+ """
+ import math as _
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(node)
+
+ def test_lambda_in_classdef(self):
+ # Make sure lambda doesn't raises
+ # Undefined-method in class def
+
+ # Issue 1824
+ # https://github.com/PyCQA/pylint/issues/1824
+ node = astroid.parse(
+ """
+ class MyObject(object):
+ method1 = lambda func: func()
+ method2 = lambda function: function()
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(node)
+
+ def test_nested_lambda(self):
+ """Make sure variables from parent lambdas
+ aren't noted as undefined
+
+ https://github.com/PyCQA/pylint/issues/760
+ """
+ node = astroid.parse(
+ """
+ lambda x: lambda: x + 1
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(node)
+
+ @set_config(ignored_argument_names=re.compile("arg"))
+ def test_ignored_argument_names_no_message(self):
+ """Make sure is_ignored_argument_names properly ignores
+ function arguments"""
+ node = astroid.parse(
+ """
+ def fooby(arg):
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(node)
+
+ @set_config(ignored_argument_names=re.compile("args|kwargs"))
+ def test_ignored_argument_names_starred_args(self):
+ node = astroid.parse(
+ """
+ def fooby(*args, **kwargs):
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.walk(node)
+
+
+class TestMissingSubmodule(CheckerTestCase):
+ CHECKER_CLASS = variables.VariablesChecker
+
+ @staticmethod
+ def test_package_all():
+
+ sys.path.insert(0, REGR_DATA_DIR)
+ try:
+ linter.check(os.path.join(REGR_DATA_DIR, "package_all"))
+ got = linter.reporter.finalize().strip()
+ assert got == "E: 3: Undefined variable name 'missing' in __all__"
+ finally:
+ sys.path.pop(0)
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..5c2567d
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,59 @@
+# pylint: disable=redefined-outer-name
+# pylint: disable=no-name-in-module
+import os
+from pathlib import Path
+
+import pytest
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.testutils import MinimalTestReporter
+
+
+@pytest.fixture()
+def tests_directory():
+ return Path(__file__).parent
+
+
+@pytest.fixture
+def linter(checker, register, enable, disable, reporter):
+ _linter = PyLinter()
+ _linter.set_reporter(reporter())
+ checkers.initialize(_linter)
+ if register:
+ register(_linter)
+ if checker:
+ _linter.register_checker(checker(_linter))
+ if disable:
+ for msg in disable:
+ _linter.disable(msg)
+ if enable:
+ for msg in enable:
+ _linter.enable(msg)
+ os.environ.pop("PYLINTRC", None)
+ return _linter
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return None
+
+
+@pytest.fixture(scope="module")
+def register():
+ return None
+
+
+@pytest.fixture(scope="module")
+def enable():
+ return None
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return None
+
+
+@pytest.fixture(scope="module")
+def reporter():
+ return MinimalTestReporter
diff --git a/tests/data/__init__.py b/tests/data/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/data/__init__.py
diff --git a/tests/data/ascript b/tests/data/ascript
new file mode 100755
index 0000000..f401ebc
--- /dev/null
+++ b/tests/data/ascript
@@ -0,0 +1,2 @@
+#!/usr/bin/python
+"""ttttttttttttttttttttoooooooooooooooooooooooooooooooooooooooooooooooooooooo lllllllllllooooooooooooooooooooooooooooonnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnngggggggggggggggggg"""
diff --git a/tests/data/classes_No_Name.dot b/tests/data/classes_No_Name.dot
new file mode 100644
index 0000000..8867b4e
--- /dev/null
+++ b/tests/data/classes_No_Name.dot
@@ -0,0 +1,12 @@
+digraph "classes_No_Name" {
+charset="utf-8"
+rankdir=BT
+"0" [label="{Ancestor|attr : str\lcls_member\l|get_value()\lset_value(value)\l}", shape="record"];
+"1" [label="{DoNothing|\l|}", shape="record"];
+"2" [label="{Interface|\l|get_value()\lset_value(value)\l}", shape="record"];
+"3" [label="{Specialization|TYPE : str\lrelation\ltop : str\l|}", shape="record"];
+"3" -> "0" [arrowhead="empty", arrowtail="none"];
+"0" -> "2" [arrowhead="empty", arrowtail="node", style="dashed"];
+"1" -> "0" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="cls_member", style="solid"];
+"1" -> "3" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="relation", style="solid"];
+}
diff --git a/tests/data/clientmodule_test.py b/tests/data/clientmodule_test.py
new file mode 100644
index 0000000..40db2e7
--- /dev/null
+++ b/tests/data/clientmodule_test.py
@@ -0,0 +1,29 @@
+""" docstring for file clientmodule.py """
+from data.suppliermodule_test import Interface, DoNothing
+
+class Ancestor:
+ """ Ancestor method """
+ __implements__ = (Interface,)
+ cls_member = DoNothing()
+
+ def __init__(self, value):
+ local_variable = 0
+ self.attr = 'this method shouldn\'t have a docstring'
+ self.__value = value
+
+ def get_value(self):
+ """ nice docstring ;-) """
+ return self.__value
+
+ def set_value(self, value):
+ self.__value = value
+ return 'this method shouldn\'t have a docstring'
+
+class Specialization(Ancestor):
+ TYPE = 'final class'
+ top = 'class'
+
+ def __init__(self, value, _id):
+ Ancestor.__init__(self, value)
+ self._id = _id
+ self.relation = DoNothing()
diff --git a/tests/data/packages_No_Name.dot b/tests/data/packages_No_Name.dot
new file mode 100644
index 0000000..1ceeb72
--- /dev/null
+++ b/tests/data/packages_No_Name.dot
@@ -0,0 +1,8 @@
+digraph "packages_No_Name" {
+charset="utf-8"
+rankdir=BT
+"0" [label="data", shape="box"];
+"1" [label="data.clientmodule_test", shape="box"];
+"2" [label="data.suppliermodule_test", shape="box"];
+"1" -> "2" [arrowhead="open", arrowtail="none"];
+}
diff --git a/tests/data/suppliermodule_test.py b/tests/data/suppliermodule_test.py
new file mode 100644
index 0000000..24dc9a0
--- /dev/null
+++ b/tests/data/suppliermodule_test.py
@@ -0,0 +1,10 @@
+""" file suppliermodule.py """
+
+class Interface:
+ def get_value(self):
+ raise NotImplementedError
+
+ def set_value(self, value):
+ raise NotImplementedError
+
+class DoNothing: pass
diff --git a/tests/extensions/__init__.py b/tests/extensions/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/extensions/__init__.py
diff --git a/tests/extensions/data/bad_builtin.py b/tests/extensions/data/bad_builtin.py
new file mode 100644
index 0000000..fd3e5c0
--- /dev/null
+++ b/tests/extensions/data/bad_builtin.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring
+
+TEST = map(str, (1, 2, 3)) # [bad-builtin]
+TEST1 = filter(str, (1, 2, 3)) # [bad-builtin]
diff --git a/tests/extensions/data/broad_try_clause.py b/tests/extensions/data/broad_try_clause.py
new file mode 100644
index 0000000..5649023
--- /dev/null
+++ b/tests/extensions/data/broad_try_clause.py
@@ -0,0 +1,49 @@
+# pylint: disable=missing-docstring, invalid-name
+
+MY_DICTIONARY = {"key_one": 1, "key_two": 2, "key_three": 3}
+
+try: # [max-try-statements]
+ value = MY_DICTIONARY["key_one"]
+ value += 1
+ print("This one has an except clause only.")
+except KeyError:
+ pass
+
+try: # [max-try-statements]
+ value = MY_DICTIONARY["key_one"]
+ value += 1
+ print("This one has an finally clause only.")
+finally:
+ pass
+
+try: # [max-try-statements]
+ value = MY_DICTIONARY["key_one"]
+ value += 1
+ print("This one has an except clause...")
+ print("and also a finally clause!")
+except KeyError:
+ pass
+finally:
+ pass
+
+try: # [max-try-statements]
+ if "key_one" in MY_DICTIONARY:
+ entered_if_body = True
+ print("This verifies that content inside of an if statement is counted too.")
+ else:
+ entered_if_body = False
+
+ while False:
+ print("This verifies that content inside of a while loop is counted too.")
+
+ for item in []:
+ print("This verifies that content inside of a for loop is counted too.")
+
+
+except KeyError:
+ pass
+
+try:
+ value = MY_DICTIONARY["key_one"]
+except KeyError:
+ value = 0
diff --git a/tests/extensions/data/compare_to_zero.py b/tests/extensions/data/compare_to_zero.py
new file mode 100644
index 0000000..dfe6bbc
--- /dev/null
+++ b/tests/extensions/data/compare_to_zero.py
@@ -0,0 +1,28 @@
+# pylint: disable=literal-comparison,missing-docstring,misplaced-comparison-constant
+
+X = 123
+Y = len('test')
+
+if X is 0: # [compare-to-zero]
+ pass
+
+if Y is not 0: # [compare-to-zero]
+ pass
+
+if X == 0: # [compare-to-zero]
+ pass
+
+if Y != 0: # [compare-to-zero]
+ pass
+
+if X > 0:
+ pass
+
+if X < 0:
+ pass
+
+if 0 < X:
+ pass
+
+if 0 > X:
+ pass
diff --git a/tests/extensions/data/docstring.py b/tests/extensions/data/docstring.py
new file mode 100644
index 0000000..8f34c65
--- /dev/null
+++ b/tests/extensions/data/docstring.py
@@ -0,0 +1,40 @@
+"""Checks of Dosctrings 'docstring-first-line-empty' 'bad-docstring-quotes'"""
+
+
+def check_messages(*messages):
+ """
+ docstring"""
+ return messages
+
+def function2():
+ """Test Ok"""
+
+class FFFF:
+ """
+ Test Docstring First Line Empty
+ """
+
+ def method1(self):
+ '''
+ Test Triple Single Quotes docstring
+ '''
+
+ def method2(self):
+ "bad docstring 1"
+
+ def method3(self):
+ 'bad docstring 2'
+
+ def method4(self):
+ ' """bad docstring 3 '
+
+ @check_messages('bad-open-mode', 'redundant-unittest-assert',
+ 'deprecated-module')
+ def method5(self):
+ """Test OK 1 with decorators"""
+
+ def method6(self):
+ r"""Test OK 2 with raw string"""
+
+ def method7(self):
+ u"""Test OK 3 with unicode string"""
diff --git a/tests/extensions/data/elif.py b/tests/extensions/data/elif.py
new file mode 100644
index 0000000..22e79c1
--- /dev/null
+++ b/tests/extensions/data/elif.py
@@ -0,0 +1,26 @@
+"""Checks use of "else if" triggers a refactor message"""
+
+def my_function():
+ """docstring"""
+ myint = 2
+ if myint > 5:
+ pass
+ else:
+ if myint <= 5:
+ pass
+ else:
+ myint = 3
+ if myint > 2:
+ if myint > 3:
+ pass
+ elif myint == 3:
+ pass
+ elif myint < 3:
+ pass
+ else:
+ if myint:
+ pass
+ else:
+ if myint:
+ pass
+ myint = 4
diff --git a/tests/extensions/data/empty_comment.py b/tests/extensions/data/empty_comment.py
new file mode 100644
index 0000000..8a18df2
--- /dev/null
+++ b/tests/extensions/data/empty_comment.py
@@ -0,0 +1,9 @@
+"""empty-comment test-case"""
+A = 5 #
+#
+A = '#' + '1'
+print(A) #
+print("A=", A) # should not be an error#
+A = "#pe\0ace#love#" #
+A = "peace#love" # \0 peace'#'''' love#peace'''-'#love'-"peace#love"#
+#######
diff --git a/tests/extensions/data/empty_string_comparison.py b/tests/extensions/data/empty_string_comparison.py
new file mode 100644
index 0000000..c6dcf8e
--- /dev/null
+++ b/tests/extensions/data/empty_string_comparison.py
@@ -0,0 +1,16 @@
+# pylint: disable=literal-comparison,missing-docstring
+
+X = ''
+Y = 'test'
+
+if X is '': # [compare-to-empty-string]
+ pass
+
+if Y is not "": # [compare-to-empty-string]
+ pass
+
+if X == "": # [compare-to-empty-string]
+ pass
+
+if Y != '': # [compare-to-empty-string]
+ pass
diff --git a/tests/extensions/data/mccabe.py b/tests/extensions/data/mccabe.py
new file mode 100644
index 0000000..fdbdb5f
--- /dev/null
+++ b/tests/extensions/data/mccabe.py
@@ -0,0 +1,205 @@
+"""Checks use of "too-complex" check"""
+
+
+def f1():
+ """McCabe rating: 1"""
+ pass
+
+
+def f2(n):
+ """McCabe rating: 1"""
+ k = n + 4
+ s = k + n
+ return s
+
+
+def f3(n):
+ """McCabe rating: 3"""
+ if n > 3:
+ return "bigger than three"
+ elif n > 4:
+ return "is never executed"
+ else:
+ return "smaller than or equal to three"
+
+
+def f4():
+ """McCabe rating: 2"""
+ for i in range(10):
+ print(i)
+
+
+def f5(mylist):
+ """McCabe rating: 2"""
+ for i in mylist:
+ print(i)
+ else:
+ print(None)
+
+
+def f6(n):
+ """McCabe rating: 2"""
+ if n > 4:
+ return f(n - 1)
+ else:
+ return n
+
+
+def f7():
+ """McCabe rating: 3"""
+ def b():
+ """McCabe rating: 2"""
+ def c():
+ """McCabe rating: 1"""
+ pass
+ c()
+ b()
+
+
+def f8():
+ """McCabe rating: 4"""
+ try:
+ print(1)
+ except TypeA:
+ print(2)
+ except TypeB:
+ print(3)
+ else:
+ print(4)
+
+
+def f9():
+ """McCabe rating: 9"""
+ myint = 2
+ if myint > 5:
+ pass
+ else:
+ if myint <= 5:
+ pass
+ else:
+ myint = 3
+ if myint > 2:
+ if myint > 3:
+ pass
+ elif myint == 3:
+ pass
+ elif myint < 3:
+ pass
+ else:
+ if myint:
+ pass
+ else:
+ if myint:
+ pass
+ myint = 4
+
+
+def f10():
+ """McCabe rating: 11"""
+ myint = 2
+ if myint == 5:
+ return myint
+ elif myint == 6:
+ return myint
+ elif myint == 7:
+ return myint
+ elif myint == 8:
+ return myint
+ elif myint == 9:
+ return myint
+ elif myint == 10:
+ if myint == 8:
+ while True:
+ return True
+ elif myint == 8:
+ with myint:
+ return 8
+ else:
+ if myint == 2:
+ return myint
+ return myint
+ return myint
+
+
+class MyClass1(object):
+ """Class of example to test mccabe"""
+ _name = 'MyClass' # To force a tail.node=None
+
+ def method1():
+ """McCabe rating: 1"""
+ pass
+
+ def method2(self, param1):
+ """McCabe rating: 18"""
+ if not param1:
+ pass
+ pass
+ if param1:
+ pass
+ else:
+ pass
+
+ pass
+
+ if param1:
+ pass
+ if param1:
+ pass
+ if param1:
+ pass
+ if param1:
+ pass
+ if param1:
+ pass
+ if param1:
+ pass
+ if param1:
+ for value in range(5):
+ pass
+
+ pass
+ for count in range(6):
+ with open('myfile') as fp:
+ count += 1
+ pass
+ pass
+ try:
+ pass
+ if not param1:
+ pass
+ else:
+ pass
+ if param1:
+ raise BaseException('Error')
+ with open('myfile2') as fp2:
+ pass
+ pass
+ finally:
+ if param1 is not None:
+ pass
+ for count2 in range(8):
+ try:
+ pass
+ except BaseException('Error2'):
+ pass
+ return param1
+
+
+for count in range(10):
+ if count == 1:
+ exit(0)
+ elif count == 2:
+ exit(1)
+ else:
+ exit(2)
+
+
+def method3(self):
+ try:
+ if True:
+ pass
+ else:
+ pass
+ finally:
+ pass
+ return True
diff --git a/tests/extensions/data/overlapping_exceptions.py b/tests/extensions/data/overlapping_exceptions.py
new file mode 100644
index 0000000..5ee50f3
--- /dev/null
+++ b/tests/extensions/data/overlapping_exceptions.py
@@ -0,0 +1,45 @@
+# pylint: disable=missing-docstring
+
+class SomeException(Exception):
+ pass
+
+class SubclassException(SomeException):
+ pass
+
+AliasException = SomeException
+
+try:
+ pass
+except (SomeException, SomeException): # [overlapping-except]
+ pass
+
+try:
+ pass
+except (SomeException, SubclassException): # [overlapping-except]
+ pass
+
+try:
+ pass
+except (SomeException, AliasException): # [overlapping-except]
+ pass
+
+try:
+ pass
+except (AliasException, SubclassException): # [overlapping-except]
+ pass
+
+try:
+ pass
+# +1:[overlapping-except, overlapping-except, overlapping-except]
+except (SomeException, AliasException, SubclassException):
+ pass
+
+try:
+ pass
+except (ArithmeticError, FloatingPointError): # [overlapping-except]
+ pass
+
+try:
+ pass
+except (ValueError, UnicodeDecodeError): # [overlapping-except]
+ pass
diff --git a/tests/extensions/data/overlapping_exceptions_py33.py b/tests/extensions/data/overlapping_exceptions_py33.py
new file mode 100644
index 0000000..16d5c30
--- /dev/null
+++ b/tests/extensions/data/overlapping_exceptions_py33.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring
+
+import socket
+
+try:
+ pass
+except (IOError, OSError): # [overlapping-except]
+ pass
+
+try:
+ pass
+except (socket.error, OSError): # [overlapping-except]
+ pass
+
+try:
+ pass
+except (ConnectionError, socket.error): # [overlapping-except]
+ pass
diff --git a/tests/extensions/data/redefined.py b/tests/extensions/data/redefined.py
new file mode 100644
index 0000000..8829c43
--- /dev/null
+++ b/tests/extensions/data/redefined.py
@@ -0,0 +1,85 @@
+"""Checks variable types aren't redefined within a method or a function"""
+
+# pylint: disable=too-few-public-methods,missing-docstring,unused-variable,invalid-name, useless-object-inheritance
+
+_OK = True
+
+class MyClass(object):
+
+ class Klass(object):
+ def __init__(self):
+ self.var2 = 'var'
+
+ def __init__(self):
+ self.var = True
+ self.var1 = 2
+ self.var2 = 1.
+ self.var1 = 2. # [redefined-variable-type]
+ self.a_str = "hello"
+ a_str = False
+ (a_str, b_str) = (1, 2) # no support for inference on tuple assignment
+ a_str = 2.0 if self.var else 1.0
+
+ def _getter(self):
+ return self.a_str
+ def _setter(self, val):
+ self.a_str = val
+ var2 = property(_getter, _setter)
+
+ def some_method(self):
+ def func():
+ var = 1
+ test = 'bar'
+ var = 'baz' # [redefined-variable-type]
+ self.var = 1 # the rule checks for redefinitions in the scope of a function or method
+ test = 'foo'
+ myint = 2
+ myint = False # [redefined-variable-type]
+
+_OK = "This is OK" # [redefined-variable-type]
+
+if _OK:
+ SOME_FLOAT = 1.
+
+def dummy_function():
+ return 2
+
+def other_function():
+ instance = MyClass()
+ instance = True # [redefined-variable-type]
+
+SOME_FLOAT = dummy_function() # [redefined-variable-type]
+
+A_GLOB = None
+A_GLOB = [1, 2, 3]
+
+def func2(x):
+ if x:
+ var = 'foo'
+ else:
+ var = True
+
+ if x:
+ var2 = 'foo'
+ elif not x:
+ var2 = 2
+ else:
+ pass
+
+ if x:
+ var3 = 'foo'
+ var3 = 2 # [redefined-variable-type]
+ else:
+ pass
+
+ var = 2 # [redefined-variable-type]
+
+ if x:
+ pass
+ elif not x:
+ var4 = True
+ elif _OK:
+ pass
+ else:
+ var4 = 2.
+ var4 = 'baz' # [redefined-variable-type]
diff --git a/tests/extensions/test_bad_builtin.py b/tests/extensions/test_bad_builtin.py
new file mode 100644
index 0000000..427dd20
--- /dev/null
+++ b/tests/extensions/test_bad_builtin.py
@@ -0,0 +1,44 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.bad_builtin
+"""
+from os import path as osp
+
+import pytest
+
+from pylint.extensions.bad_builtin import BadBuiltinChecker
+from pylint.lint import fix_import_path
+
+EXPECTED = [
+ "Used builtin function 'map'. Using a list comprehension can be clearer.",
+ "Used builtin function 'filter'. Using a list comprehension can be clearer.",
+]
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return BadBuiltinChecker
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["I"]
+
+
+def test_types_redefined(linter):
+ elif_test = osp.join(osp.dirname(osp.abspath(__file__)), "data", "bad_builtin.py")
+ with fix_import_path([elif_test]):
+ linter.check([elif_test])
+ msgs = sorted(linter.reporter.messages, key=lambda item: item.line)
+ assert len(msgs) == 2
+ for msg, expected in zip(msgs, EXPECTED):
+ assert msg.symbol == "bad-builtin"
+ assert msg.msg == expected
diff --git a/tests/extensions/test_broad_try_clause.py b/tests/extensions/test_broad_try_clause.py
new file mode 100644
index 0000000..fb9cffb
--- /dev/null
+++ b/tests/extensions/test_broad_try_clause.py
@@ -0,0 +1,69 @@
+# Copyright (c) 2019-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2019-2020 Tyler Thieding <tyler@thieding.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.broad_try_clause`"""
+import unittest
+from os import path as osp
+
+from pylint import checkers
+from pylint.extensions.broad_try_clause import BroadTryClauseChecker
+from pylint.lint import PyLinter
+from pylint.reporters import BaseReporter
+
+
+class BroadTryClauseTestReporter(BaseReporter):
+ def on_set_current_module(self, module, filepath):
+ self.messages = []
+
+ def _display(self, layout):
+ pass
+
+
+class BroadTryClauseTC(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls._linter = PyLinter()
+ cls._linter.set_reporter(BroadTryClauseTestReporter())
+ checkers.initialize(cls._linter)
+ cls._linter.register_checker(BroadTryClauseChecker(cls._linter))
+ cls._linter.disable("I")
+
+ def test_broad_try_clause_message(self):
+ broad_try_clause_test = osp.join(
+ osp.dirname(osp.abspath(__file__)), "data", "broad_try_clause.py"
+ )
+ self._linter.check([broad_try_clause_test])
+ msgs = self._linter.reporter.messages
+ self.assertEqual(len(msgs), 4)
+
+ self.assertEqual(msgs[0].symbol, "too-many-try-statements")
+ self.assertEqual(
+ msgs[0].msg, "try clause contains 3 statements, expected at most 1"
+ )
+ self.assertEqual(msgs[0].line, 5)
+
+ self.assertEqual(msgs[1].symbol, "too-many-try-statements")
+ self.assertEqual(
+ msgs[1].msg, "try clause contains 3 statements, expected at most 1"
+ )
+ self.assertEqual(msgs[1].line, 12)
+
+ self.assertEqual(msgs[2].symbol, "too-many-try-statements")
+ self.assertEqual(
+ msgs[2].msg, "try clause contains 4 statements, expected at most 1"
+ )
+ self.assertEqual(msgs[2].line, 19)
+
+ self.assertEqual(msgs[3].symbol, "too-many-try-statements")
+ self.assertEqual(
+ msgs[3].msg, "try clause contains 7 statements, expected at most 1"
+ )
+ self.assertEqual(msgs[3].line, 29)
diff --git a/tests/extensions/test_check_docs.py b/tests/extensions/test_check_docs.py
new file mode 100644
index 0000000..a65bf93
--- /dev/null
+++ b/tests/extensions/test_check_docs.py
@@ -0,0 +1,2330 @@
+# Copyright (c) 2014-2015 Bruno Daniel <bruno.daniel@blue-yonder.com>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Mitar <mitar.github@tnode.com>
+# Copyright (c) 2017 John Paraskevopoulos <io.paraskev@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Adrian Chirieac <chirieacam@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 Luigi <luigi.cristofolini@q-ctrl.com>
+# Copyright (c) 2021 Logan Miller <14319179+komodo472@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the pylint checkers in :mod:`pylint.extensions.check_docs`,
+in particular the parameter documentation checker `DocstringChecker`
+"""
+
+# pylint: disable=too-many-public-methods
+
+import astroid
+import pytest
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestParamDocChecker(CheckerTestCase):
+ """Tests for pylint_plugin.ParamDocChecker"""
+
+ CHECKER_CLASS = DocstringParameterChecker
+ CONFIG = {
+ "accept_no_param_doc": False,
+ "no_docstring_rgx": "",
+ "docstring_min_length": -1,
+ }
+
+ def test_missing_func_params_in_sphinx_docstring(self):
+ """Example of a function with missing Sphinx parameter documentation in
+ the docstring
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y, z):
+ '''docstring ...
+
+ :param x: bla
+
+ :param int z: bar
+ '''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("y",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_missing_func_params_in_google_docstring(self):
+ """Example of a function with missing Google style parameter
+ documentation in the docstring
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y, z):
+ '''docstring ...
+
+ Args:
+ x: bla
+ z (int): bar
+
+ some other stuff
+ '''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("y",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_missing_type_doc_google_docstring_exempt_kwonly_args(self):
+ node = astroid.extract_node(
+ """
+ def identifier_kwarg_method(arg1: int, arg2: int, *, value1: str, value2: str):
+ '''Code to show failure in missing-type-doc
+
+ Args:
+ arg1: First argument.
+ arg2: Second argument.
+ value1: First kwarg.
+ value2: Second kwarg.
+ '''
+ print("NOTE: It doesn't like anything after the '*'.")
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_missing_func_params_with_annotations_in_google_docstring(self):
+ """Example of a function with missing Google style parameter
+ documentation in the docstring.
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x: int, y: bool, z):
+ '''docstring ...
+
+ Args:
+ x: bla
+ y: blah blah
+ z (int): bar
+
+ some other stuff
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_default_arg_with_annotations_in_google_docstring(self):
+ """Example of a function with missing Google style parameter
+ documentation in the docstring.
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x: int, y: bool, z: int = 786):
+ '''docstring ...
+
+ Args:
+ x: bla
+ y: blah blah
+ z: bar
+
+ some other stuff
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_missing_func_params_with_partial_annotations_in_google_docstring(self):
+ """Example of a function with missing Google style parameter
+ documentation in the docstring.
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y: bool, z):
+ '''docstring ...
+
+ Args:
+ x: bla
+ y: blah blah
+ z (int): bar
+
+ some other stuff
+ '''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-type-doc", node=node, args=("x",))
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_non_builtin_annotations_in_google_docstring(self):
+ """Example of a function with missing Google style parameter
+ documentation in the docstring.
+ """
+ node = astroid.extract_node(
+ """
+ def area(bottomleft: Point, topright: Point) -> float:
+ '''Calculate area of fake rectangle.
+ Args:
+ bottomleft: bottom left point of rectangle
+ topright: top right point of rectangle
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_non_builtin_annotations_for_returntype_in_google_docstring(self):
+ """Example of a function with missing Google style parameter
+ documentation in the docstring.
+ """
+ node = astroid.extract_node(
+ """
+ def get_midpoint(bottomleft: Point, topright: Point) -> Point:
+ '''Calculate midpoint of fake rectangle.
+ Args:
+ bottomleft: bottom left point of rectangle
+ topright: top right point of rectangle
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_func_params_and_keyword_params_in_google_docstring(self):
+ """Example of a function with Google style parameter splitted
+ in Args and Keyword Args in the docstring
+ """
+ node = astroid.extract_node(
+ """
+ def my_func(this, other, that=True):
+ '''Prints this, other and that
+
+ Args:
+ this (str): Printed first
+ other (int): Other args
+
+ Keyword Args:
+ that (bool): Printed second
+ '''
+ print(this, that, other)
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_func_params_and_wrong_keyword_params_in_google_docstring(self):
+ """Example of a function with Google style parameter splitted
+ in Args and Keyword Args in the docstring but with wrong keyword args
+ """
+ node = astroid.extract_node(
+ """
+ def my_func(this, other, that=True):
+ '''Prints this, other and that
+
+ Args:
+ this (str): Printed first
+ other (int): Other args
+
+ Keyword Args:
+ these (bool): Printed second
+ '''
+ print(this, that, other)
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("that",)),
+ Message(msg_id="missing-type-doc", node=node, args=("that",)),
+ Message(msg_id="differing-param-doc", node=node, args=("these",)),
+ Message(msg_id="differing-type-doc", node=node, args=("these",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_missing_func_params_in_numpy_docstring(self):
+ """Example of a function with missing NumPy style parameter
+ documentation in the docstring
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y, z):
+ '''docstring ...
+
+ Parameters
+ ----------
+ x:
+ bla
+ z: int
+ bar
+
+ some other stuff
+ '''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("y",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ @set_config(accept_no_param_doc=True)
+ def test_tolerate_no_param_documentation_at_all(self):
+ """Example of a function with no parameter documentation at all
+
+ No error message is emitted.
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y):
+ '''docstring ...
+
+ missing parameter documentation'''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_don_t_tolerate_no_param_documentation_at_all(self):
+ """Example of a function with no parameter documentation at all
+
+ Missing documentation error message is emitted.
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y):
+ '''docstring ...
+
+ missing parameter documentation'''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("x, y",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_see_tolerate_no_param_documentation_at_all(self):
+ """Example for the usage of "For the parameters, see"
+ to suppress missing-param warnings.
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y):
+ '''docstring ...
+
+ For the parameters, see :func:`blah`
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def _visit_methods_of_class(self, node):
+ """Visit all methods of a class node
+
+ :param node: class node
+ :type node: :class:`astroid.scoped_nodes.Class`
+ """
+ for body_item in node.body:
+ if isinstance(body_item, astroid.FunctionDef) and hasattr(
+ body_item, "name"
+ ):
+ self.checker.visit_functiondef(body_item)
+
+ def test_missing_method_params_in_sphinx_docstring(self):
+ """Example of a class method with missing parameter documentation in
+ the Sphinx style docstring
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def method_foo(self, x, y):
+ '''docstring ...
+
+ missing parameter documentation
+
+ :param x: bla
+ '''
+ pass
+ """
+ )
+ method_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=method_node, args=("y",)),
+ Message(msg_id="missing-type-doc", node=method_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_missing_method_params_in_google_docstring(self):
+ """Example of a class method with missing parameter documentation in
+ the Google style docstring
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def method_foo(self, x, y):
+ '''docstring ...
+
+ missing parameter documentation
+
+ Args:
+ x: bla
+ '''
+ pass
+ """
+ )
+ method_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=method_node, args=("y",)),
+ Message(msg_id="missing-type-doc", node=method_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_missing_method_params_in_numpy_docstring(self):
+ """Example of a class method with missing parameter documentation in
+ the Numpy style docstring
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def method_foo(self, x, y):
+ '''docstring ...
+
+ missing parameter documentation
+
+ Parameters
+ ----------
+ x:
+ bla
+ '''
+ pass
+ """
+ )
+ method_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=method_node, args=("y",)),
+ Message(msg_id="missing-type-doc", node=method_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_existing_func_params_in_sphinx_docstring(self):
+ """Example of a function with correctly documented parameters and
+ return values (Sphinx style)
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg, zarg, warg):
+ '''function foo ...
+
+ :param xarg: bla xarg
+ :type xarg: int
+
+ :parameter yarg: bla yarg
+ :type yarg: my.qualified.type
+
+ :arg int zarg: bla zarg
+
+ :keyword my.qualified.type warg: bla warg
+
+ :return: sum
+ :rtype: float
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_existing_func_params_in_google_docstring(self):
+ """Example of a function with correctly documented parameters and
+ return values (Google style)
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg, zarg, warg):
+ '''function foo ...
+
+ Args:
+ xarg (int): bla xarg
+ yarg (my.qualified.type): bla
+ bla yarg
+
+ zarg (int): bla zarg
+ warg (my.qualified.type): bla warg
+
+ Returns:
+ float: sum
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_existing_func_params_in_numpy_docstring(self):
+ """Example of a function with correctly documented parameters and
+ return values (Numpy style)
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg, zarg, warg):
+ '''function foo ...
+
+ Parameters
+ ----------
+ xarg: int
+ bla xarg
+ yarg: my.qualified.type
+ bla yarg
+
+ zarg: int
+ bla zarg
+ warg: my.qualified.type
+ bla warg
+
+ Returns
+ -------
+ float
+ sum
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_wrong_name_of_func_params_in_sphinx_docstring(self):
+ """Example of functions with inconsistent parameter names in the
+ signature and in the Sphinx style documentation
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg, zarg):
+ '''function foo ...
+
+ :param xarg1: bla xarg
+ :type xarg: int
+
+ :param yarg: bla yarg
+ :type yarg1: float
+
+ :param str zarg1: bla zarg
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("xarg, zarg",)),
+ Message(msg_id="missing-type-doc", node=node, args=("yarg, zarg",)),
+ Message(msg_id="differing-param-doc", node=node, args=("xarg1, zarg1",)),
+ Message(msg_id="differing-type-doc", node=node, args=("yarg1, zarg1",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg):
+ '''function foo ...
+
+ :param yarg1: bla yarg
+ :type yarg1: float
+
+ For the other parameters, see bla.
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="differing-param-doc", node=node, args=("yarg1",)),
+ Message(msg_id="differing-type-doc", node=node, args=("yarg1",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_wrong_name_of_func_params_in_google_docstring(self):
+ """Example of functions with inconsistent parameter names in the
+ signature and in the Google style documentation
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg, zarg):
+ '''function foo ...
+
+ Args:
+ xarg1 (int): bla xarg
+ yarg (float): bla yarg
+
+ zarg1 (str): bla zarg
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("xarg, zarg",)),
+ Message(msg_id="missing-type-doc", node=node, args=("xarg, zarg",)),
+ Message(msg_id="differing-param-doc", node=node, args=("xarg1, zarg1",)),
+ Message(msg_id="differing-type-doc", node=node, args=("xarg1, zarg1",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg):
+ '''function foo ...
+
+ Args:
+ yarg1 (float): bla yarg
+
+ For the other parameters, see bla.
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="differing-param-doc", node=node, args=("yarg1",)),
+ Message(msg_id="differing-type-doc", node=node, args=("yarg1",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_wrong_name_of_func_params_in_numpy_docstring(self):
+ """Example of functions with inconsistent parameter names in the
+ signature and in the Numpy style documentation
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg, zarg):
+ '''function foo ...
+
+ Parameters
+ ----------
+ xarg1: int
+ bla xarg
+ yarg: float
+ bla yarg
+
+ zarg1: str
+ bla zarg
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("xarg, zarg",)),
+ Message(msg_id="missing-type-doc", node=node, args=("xarg, zarg",)),
+ Message(msg_id="differing-param-doc", node=node, args=("xarg1, zarg1",)),
+ Message(msg_id="differing-type-doc", node=node, args=("xarg1, zarg1",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg):
+ '''function foo ...
+
+ Parameters
+ ----------
+ yarg1: float
+ bla yarg
+
+ For the other parameters, see bla.
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="differing-param-doc", node=node, args=("yarg1",)),
+ Message(msg_id="differing-type-doc", node=node, args=("yarg1",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_see_sentence_for_func_params_in_sphinx_docstring(self):
+ """Example for the usage of "For the other parameters, see" to avoid
+ too many repetitions, e.g. in functions or methods adhering to a
+ given interface (Sphinx style)
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg):
+ '''function foo ...
+
+ :param yarg: bla yarg
+ :type yarg: float
+
+ For the other parameters, see :func:`bla`
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_see_sentence_for_func_params_in_google_docstring(self):
+ """Example for the usage of "For the other parameters, see" to avoid
+ too many repetitions, e.g. in functions or methods adhering to a
+ given interface (Google style)
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg):
+ '''function foo ...
+
+ Args:
+ yarg (float): bla yarg
+
+ For the other parameters, see :func:`bla`
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_see_sentence_for_func_params_in_numpy_docstring(self):
+ """Example for the usage of "For the other parameters, see" to avoid
+ too many repetitions, e.g. in functions or methods adhering to a
+ given interface (Numpy style)
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(xarg, yarg):
+ '''function foo ...
+
+ Parameters
+ ----------
+ yarg: float
+ bla yarg
+
+ For the other parameters, see :func:`bla`
+ '''
+ return xarg + yarg
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_constr_params_in_class_sphinx(self):
+ """Example of a class with missing constructor parameter documentation
+ (Sphinx style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''docstring foo
+
+ :param y: bla
+
+ missing constructor parameter documentation
+ '''
+
+ def __init__(self, x, y):
+ pass
+
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_class_google(self):
+ """Example of a class with missing constructor parameter documentation
+ (Google style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''docstring foo
+
+ Args:
+ y: bla
+
+ missing constructor parameter documentation
+ '''
+
+ def __init__(self, x, y):
+ pass
+
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_class_numpy(self):
+ """Example of a class with missing constructor parameter documentation
+ (Numpy style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''docstring foo
+
+ Parameters
+ ----------
+ y:
+ bla
+
+ missing constructor parameter documentation
+ '''
+
+ def __init__(self, x, y):
+ pass
+
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_and_attributes_in_class_numpy(self):
+ """Example of a class with correct constructor parameter documentation
+ and an attributes section (Numpy style)
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''
+ Parameters
+ ----------
+ foo : str
+ Something.
+
+ Attributes
+ ----------
+ bar : str
+ Something.
+ '''
+ def __init__(self, foo):
+ self.bar = None
+ """
+ )
+ with self.assertNoMessages():
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_init_sphinx(self):
+ """Example of a class with missing constructor parameter documentation
+ (Sphinx style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ def __init__(self, x, y):
+ '''docstring foo constructor
+
+ :param y: bla
+
+ missing constructor parameter documentation
+ '''
+
+ pass
+
+ """
+ )
+ constructor_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=constructor_node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=constructor_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_init_google(self):
+ """Example of a class with missing constructor parameter documentation
+ (Google style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ def __init__(self, x, y):
+ '''docstring foo constructor
+
+ Args:
+ y: bla
+
+ missing constructor parameter documentation
+ '''
+ pass
+
+ """
+ )
+ constructor_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=constructor_node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=constructor_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_init_numpy(self):
+ """Example of a class with missing constructor parameter documentation
+ (Numpy style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ def __init__(self, x, y):
+ '''docstring foo constructor
+
+ Parameters
+ ----------
+ y:
+ bla
+
+ missing constructor parameter documentation
+ '''
+ pass
+
+ """
+ )
+ constructor_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=constructor_node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=constructor_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_see_sentence_for_constr_params_in_class(self):
+ """Example usage of "For the parameters, see" in class docstring"""
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''docstring foo
+
+ For the parameters, see :func:`bla`
+ '''
+
+ def __init__(self, x, y):
+ '''init'''
+ pass
+
+ """
+ )
+ with self.assertNoMessages():
+ self._visit_methods_of_class(node)
+
+ def test_see_sentence_for_constr_params_in_init(self):
+ """Example usage of "For the parameters, see" in init docstring"""
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''foo'''
+
+ def __init__(self, x, y):
+ '''docstring foo constructor
+
+ For the parameters, see :func:`bla`
+ '''
+ pass
+
+ """
+ )
+ with self.assertNoMessages():
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_class_and_init_sphinx(self):
+ """Example of a class with missing constructor parameter documentation
+ in both the init docstring and the class docstring
+ (Sphinx style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''docstring foo
+
+ :param y: None
+
+ missing constructor parameter documentation
+ '''
+
+ def __init__(self, x, y):
+ '''docstring foo
+
+ :param y: bla
+
+ missing constructor parameter documentation
+ '''
+ pass
+
+ """
+ )
+ constructor_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="multiple-constructor-doc", node=node, args=(node.name,)),
+ Message(msg_id="missing-param-doc", node=node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ Message(msg_id="missing-param-doc", node=constructor_node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=constructor_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_class_and_init_google(self):
+ """Example of a class with missing constructor parameter documentation
+ in both the init docstring and the class docstring
+ (Google style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''docstring foo
+
+ Args:
+ y: bla
+
+ missing constructor parameter documentation
+ '''
+
+ def __init__(self, x, y):
+ '''docstring foo
+
+ Args:
+ y: bla
+
+ missing constructor parameter documentation
+ '''
+ pass
+
+ """
+ )
+ constructor_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="multiple-constructor-doc", node=node, args=(node.name,)),
+ Message(msg_id="missing-param-doc", node=node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ Message(msg_id="missing-param-doc", node=constructor_node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=constructor_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_constr_params_in_class_and_init_numpy(self):
+ """Example of a class with missing constructor parameter documentation
+ in both the init docstring and the class docstring
+ (Numpy style)
+
+ Everything is completely analogous to functions.
+ """
+ node = astroid.extract_node(
+ """
+ class ClassFoo(object):
+ '''docstring foo
+
+ Parameters
+ ----------
+ y:
+ bla
+
+ missing constructor parameter documentation
+ '''
+
+ def __init__(self, x, y):
+ '''docstring foo
+
+ Parameters
+ ----------
+ y:
+ bla
+
+ missing constructor parameter documentation
+ '''
+ pass
+
+ """
+ )
+ constructor_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="multiple-constructor-doc", node=node, args=(node.name,)),
+ Message(msg_id="missing-param-doc", node=node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=node, args=("x, y",)),
+ Message(msg_id="missing-param-doc", node=constructor_node, args=("x",)),
+ Message(msg_id="missing-type-doc", node=constructor_node, args=("x, y",)),
+ ):
+ self._visit_methods_of_class(node)
+
+ def test_kwonlyargs_are_taken_in_account(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(arg, *, kwonly, missing_kwonly):
+ """The docstring
+
+ :param int arg: The argument.
+ :param bool kwonly: A keyword-arg.
+ """
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("missing_kwonly",)),
+ Message(msg_id="missing-type-doc", node=node, args=("missing_kwonly",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_missing_args_sphinx(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, *args):
+ """The docstring
+
+ :param named_arg: Returned
+ :type named_arg: object
+ :returns: Maybe named_arg
+ :rtype: object or None
+ """
+ if args:
+ return named_arg
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("args",))
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_missing_kwargs_sphinx(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, **kwargs):
+ """The docstring
+
+ :param named_arg: Returned
+ :type named_arg: object
+ :returns: Maybe named_arg
+ :rtype: object or None
+ """
+ if kwargs:
+ return named_arg
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("kwargs",))
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_missing_args_google(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, *args):
+ """The docstring
+
+ Args:
+ named_arg (object): Returned
+
+ Returns:
+ object or None: Maybe named_arg
+ """
+ if args:
+ return named_arg
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("args",))
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_missing_kwargs_google(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, **kwargs):
+ """The docstring
+
+ Args:
+ named_arg (object): Returned
+
+ Returns:
+ object or None: Maybe named_arg
+ """
+ if kwargs:
+ return named_arg
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("kwargs",))
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_missing_args_numpy(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, *args):
+ """The docstring
+
+ Args
+ ----
+ named_arg : object
+ Returned
+
+ Returns
+ -------
+ object or None
+ Maybe named_arg
+ """
+ if args:
+ return named_arg
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("args",))
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_missing_kwargs_numpy(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, **kwargs):
+ """The docstring
+
+ Args
+ ----
+ named_arg : object
+ Returned
+
+ Returns
+ -------
+ object or None
+ Maybe named_arg
+ """
+ if kwargs:
+ return named_arg
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-param-doc", node=node, args=("kwargs",))
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_finds_args_without_type_sphinx(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, *args):
+ """The docstring
+
+ :param named_arg: Returned
+ :type named_arg: object
+ :param args: Optional arguments
+ :returns: Maybe named_arg
+ :rtype: object or None
+ """
+ if args:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_kwargs_without_type_sphinx(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, **kwargs):
+ """The docstring
+
+ :param named_arg: Returned
+ :type named_arg: object
+ :param kwargs: Keyword arguments
+ :returns: Maybe named_arg
+ :rtype: object or None
+ """
+ if kwargs:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_args_without_type_google(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, *args):
+ """The docstring
+
+ Args:
+ named_arg (object): Returned
+ *args: Optional arguments
+
+ Returns:
+ object or None: Maybe named_arg
+ """
+ if args:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_kwargs_without_type_google(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, **kwargs):
+ """The docstring
+
+ Args:
+ named_arg (object): Returned
+ **kwargs: Keyword arguments
+
+ Returns:
+ object or None: Maybe named_arg
+ """
+ if kwargs:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_args_without_type_numpy(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, *args):
+ """The docstring
+
+ Args
+ ----
+ named_arg : object
+ Returned
+ args :
+ Optional Arguments
+
+ Returns
+ -------
+ object or None
+ Maybe named_arg
+ """
+ if args:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_args_with_xref_type_google(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, **kwargs):
+ """The docstring
+
+ Args:
+ named_arg (`example.value`): Returned
+ **kwargs: Keyword arguments
+
+ Returns:
+ `example.value`: Maybe named_arg
+ """
+ if kwargs:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_args_with_xref_type_numpy(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, *args):
+ """The docstring
+
+ Args
+ ----
+ named_arg : `example.value`
+ Returned
+ args :
+ Optional Arguments
+
+ Returns
+ -------
+ `example.value`
+ Maybe named_arg
+ """
+ if args:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_kwargs_without_type_numpy(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(named_arg, **kwargs):
+ """The docstring
+
+ Args
+ ----
+ named_arg : object
+ Returned
+ kwargs :
+ Keyword arguments
+
+ Returns
+ -------
+ object or None
+ Maybe named_arg
+ """
+ if kwargs:
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ CONTAINER_TYPES = [
+ "dict(str,str)",
+ "dict[str,str]",
+ "tuple(int)",
+ "list[tokenize.TokenInfo]",
+ ]
+
+ COMPLEX_TYPES = CONTAINER_TYPES + [
+ "dict(str, str)",
+ "dict[str, str]",
+ "int or str",
+ "tuple(int or str)",
+ "tuple(int) or list(int)",
+ "tuple(int or str) or list(int or str)",
+ ]
+
+ @pytest.mark.parametrize("complex_type", COMPLEX_TYPES)
+ def test_finds_multiple_types_sphinx(self, complex_type):
+ node = astroid.extract_node(
+ f'''
+ def my_func(named_arg):
+ """The docstring
+
+ :param named_arg: Returned
+ :type named_arg: {complex_type}
+
+ :returns: named_arg
+ :rtype: {complex_type}
+ """
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ @pytest.mark.parametrize("complex_type", COMPLEX_TYPES)
+ def test_finds_multiple_types_google(self, complex_type):
+ node = astroid.extract_node(
+ f'''
+ def my_func(named_arg):
+ """The docstring
+
+ Args:
+ named_arg ({complex_type}): Returned
+
+ Returns:
+ {complex_type}: named_arg
+ """
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ @pytest.mark.parametrize("complex_type", COMPLEX_TYPES)
+ def test_finds_multiple_types_numpy(self, complex_type):
+ node = astroid.extract_node(
+ f'''
+ def my_func(named_arg):
+ """The docstring
+
+ Args
+ ----
+ named_arg : {complex_type}
+ Returned
+
+ Returns
+ -------
+ {complex_type}
+ named_arg
+ """
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ @pytest.mark.parametrize("container_type", CONTAINER_TYPES)
+ def test_finds_compact_container_types_sphinx(self, container_type):
+ node = astroid.extract_node(
+ f'''
+ def my_func(named_arg):
+ """The docstring
+
+ :param {container_type} named_arg: Returned
+
+ :returns: named_arg
+ :rtype: {container_type}
+ """
+ return named_arg
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_optional_specifier_google(self):
+ node = astroid.extract_node(
+ '''
+ def do_something(param1, param2, param3=(), param4=[], param5=[], param6=True):
+ """Do something.
+
+ Args:
+ param1 (str): Description.
+ param2 (dict(str, int)): Description.
+ param3 (tuple(str), optional): Defaults to empty. Description.
+ param4 (List[str], optional): Defaults to empty. Description.
+ param5 (list[tuple(str)], optional): Defaults to empty. Description.
+ param6 (bool, optional): Defaults to True. Description.
+
+ Returns:
+ int: Description.
+ """
+ return param1, param2, param3, param4, param5, param6
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_optional_specifier_numpy(self):
+ node = astroid.extract_node(
+ '''
+ def do_something(param, param2='all'):
+ """Do something.
+
+ Parameters
+ ----------
+ param : str
+ Description.
+ param2 : str, optional
+ Description (the default is 'all').
+
+ Returns
+ -------
+ int
+ Description.
+ """
+ return param, param2
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_short_name_exception(self):
+ node = astroid.extract_node(
+ '''
+ from fake_package import BadError
+
+ def do_something(): #@
+ """Do something.
+
+ Raises:
+ ~fake_package.exceptions.BadError: When something bad happened.
+ """
+ raise BadError("A bad thing happened.")
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_missing_raises_from_setter_sphinx(self):
+ """Example of a setter having missing raises documentation in
+ the Sphinx style docstring of the property
+ """
+ property_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''docstring ...
+
+ :type: int
+ '''
+ return 10
+
+ @foo.setter
+ def foo(self, value):
+ raise AttributeError() #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc",
+ node=property_node,
+ args=("AttributeError",),
+ )
+ ):
+ self.checker.visit_raise(node)
+
+ def test_finds_missing_raises_from_setter_google(self):
+ """Example of a setter having missing raises documentation in
+ the Google style docstring of the property
+ """
+ property_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''int: docstring
+
+ Include a "Raises" section so that this is identified
+ as a Google docstring and not a Numpy docstring.
+
+ Raises:
+ RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10
+
+ @foo.setter
+ def foo(self, value):
+ raise AttributeError() #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc",
+ node=property_node,
+ args=("AttributeError",),
+ )
+ ):
+ self.checker.visit_raise(node)
+
+ def test_finds_missing_raises_from_setter_numpy(self):
+ """Example of a setter having missing raises documentation in
+ the Numpy style docstring of the property
+ """
+ property_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''int: docstring
+
+ Include a "Raises" section so that this is identified
+ as a Numpy docstring and not a Google docstring.
+
+ Raises
+ ------
+ RuntimeError
+ Always
+ '''
+ raise RuntimeError()
+ return 10
+
+ @foo.setter
+ def foo(self, value):
+ raise AttributeError() #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc",
+ node=property_node,
+ args=("AttributeError",),
+ )
+ ):
+ self.checker.visit_raise(node)
+
+ def test_finds_missing_raises_in_setter_sphinx(self):
+ """Example of a setter having missing raises documentation in
+ its own Sphinx style docstring
+ """
+ setter_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self):
+ '''docstring ...
+
+ :type: int
+ :raises RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10
+
+ @foo.setter
+ def foo(self, value): #@
+ '''setter docstring ...
+
+ :type: None
+ '''
+ raise AttributeError() #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc", node=setter_node, args=("AttributeError",)
+ )
+ ):
+ self.checker.visit_raise(node)
+
+ def test_finds_missing_raises_from_setter_google_2(self):
+ """Example of a setter having missing raises documentation in
+ its own Google style docstring of the property
+ """
+ setter_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self):
+ '''int: docstring ...
+
+ Raises:
+ RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10
+
+ @foo.setter
+ def foo(self, value): #@
+ '''setter docstring ...
+
+ Raises:
+ RuntimeError: Never
+ '''
+ if True:
+ raise AttributeError() #@
+ raise RuntimeError()
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc", node=setter_node, args=("AttributeError",)
+ )
+ ):
+ self.checker.visit_raise(node)
+
+ def test_finds_missing_raises_from_setter_numpy_2(self):
+ """Example of a setter having missing raises documentation in
+ its own Numpy style docstring of the property
+ """
+ setter_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self):
+ '''int: docstring ...
+
+ Raises
+ ------
+ RuntimeError
+ Always
+ '''
+ raise RuntimeError()
+ return 10
+
+ @foo.setter
+ def foo(self, value): #@
+ '''setter docstring ...
+
+ Raises
+ ------
+ RuntimeError
+ Never
+ '''
+ if True:
+ raise AttributeError() #@
+ raise RuntimeError()
+ """
+ )
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc", node=setter_node, args=("AttributeError",)
+ )
+ ):
+ self.checker.visit_raise(node)
+
+ def test_finds_property_return_type_sphinx(self):
+ """Example of a property having return documentation in
+ a Sphinx style docstring
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''docstring ...
+
+ :type: int
+ '''
+ return 10
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_property_return_type_google(self):
+ """Example of a property having return documentation in
+ a Google style docstring
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''int: docstring ...
+
+ Raises:
+ RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_property_return_type_numpy(self):
+ """Example of a property having return documentation in
+ a numpy style docstring
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''int: docstring ...
+
+ Raises
+ ------
+ RuntimeError
+ Always
+ '''
+ raise RuntimeError()
+ return 10
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_finds_annotation_property_return_type_sphinx(self):
+ """Example of a property having missing return documentation in
+ a Sphinx style docstring
+ """
+ _, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self) -> int: #@
+ '''docstring ...
+
+ :raises RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(node)
+
+ def test_finds_missing_property_return_type_sphinx(self):
+ """Example of a property having missing return documentation in
+ a Sphinx style docstring
+ """
+ property_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''docstring ...
+
+ :raises RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-type-doc", node=property_node)
+ ):
+ self.checker.visit_return(node)
+
+ def test_finds_annotation_property_return_type_google(self):
+ """Example of a property having return documentation in
+ a Google style docstring
+ """
+ _, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self) -> int: #@
+ '''docstring ...
+
+ Raises:
+ RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(node)
+
+ def test_finds_missing_property_return_type_google(self):
+ """Example of a property having return documentation in
+ a Google style docstring
+ """
+ property_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''docstring ...
+
+ Raises:
+ RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-type-doc", node=property_node)
+ ):
+ self.checker.visit_return(node)
+
+ def test_finds_missing_property_return_type_numpy(self):
+ """Example of a property having return documentation in
+ a numpy style docstring
+ """
+ property_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ @property
+ def foo(self): #@
+ '''docstring ...
+
+ Raises
+ ------
+ RuntimeError
+ Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-type-doc", node=property_node)
+ ):
+ self.checker.visit_return(node)
+
+ def test_ignores_non_property_return_type_sphinx(self):
+ """Example of a class function trying to use `type` as return
+ documentation in a Sphinx style docstring
+ """
+ func_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self): #@
+ '''docstring ...
+
+ :type: int
+ '''
+ return 10 #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=func_node),
+ Message(msg_id="missing-return-type-doc", node=func_node),
+ ):
+ self.checker.visit_return(node)
+
+ def test_ignores_non_property_return_type_google(self):
+ """Example of a class function trying to use `type` as return
+ documentation in a Google style docstring
+ """
+ func_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self): #@
+ '''int: docstring ...
+
+ Raises:
+ RuntimeError: Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=func_node),
+ Message(msg_id="missing-return-type-doc", node=func_node),
+ ):
+ self.checker.visit_return(node)
+
+ def test_ignores_non_property_return_type_numpy(self):
+ """Example of a class function trying to use `type` as return
+ documentation in a numpy style docstring
+ """
+ func_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self): #@
+ '''int: docstring ...
+
+ Raises
+ ------
+ RuntimeError
+ Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=func_node),
+ Message(msg_id="missing-return-type-doc", node=func_node),
+ ):
+ self.checker.visit_return(node)
+
+ def test_non_property_annotation_return_type_numpy(self):
+ """Example of a class function trying to use `type` as return
+ documentation in a numpy style docstring
+ """
+ func_node, node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self) -> int: #@
+ '''int: docstring ...
+
+ Raises
+ ------
+ RuntimeError
+ Always
+ '''
+ raise RuntimeError()
+ return 10 #@
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=func_node)
+ ):
+ self.checker.visit_return(node)
+
+ def test_ignores_return_in_abstract_method_sphinx(self):
+ """Example of an abstract method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ import abc
+ class Foo(object):
+ @abc.abstractmethod
+ def foo(self): #@
+ '''docstring ...
+
+ :returns: Ten
+ :rtype: int
+ '''
+ return 10
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_return_in_abstract_method_google(self):
+ """Example of an abstract method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ import abc
+ class Foo(object):
+ @abc.abstractmethod
+ def foo(self): #@
+ '''docstring ...
+
+ Returns:
+ int: Ten
+ '''
+ return 10
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_return_in_abstract_method_numpy(self):
+ """Example of an abstract method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ import abc
+ class Foo(object):
+ @abc.abstractmethod
+ def foo(self): #@
+ '''docstring ...
+
+ Returns
+ -------
+ int
+ Ten
+ '''
+ return 10
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_raise_notimplementederror_sphinx(self):
+ """Example of an abstract"""
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg): #@
+ '''docstring ...
+
+ :param arg: An argument.
+ :type arg: int
+ '''
+ raise NotImplementedError()
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_return_in_abstract_method_google_2(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg): #@
+ '''docstring ...
+
+ Args:
+ arg (int): An argument.
+ '''
+ raise NotImplementedError()
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_return_in_abstract_method_numpy_2(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg): #@
+ '''docstring ...
+
+ Parameters
+ ----------
+ arg : int
+ An argument.
+ '''
+ raise NotImplementedError()
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_ignored_argument_names_sphinx(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg, _): #@
+ '''docstring ...
+
+ :param arg: An argument.
+ :type arg: int
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_ignored_argument_names_google(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg, _): #@
+ '''docstring ...
+
+ Args:
+ arg (int): An argument.
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_ignored_argument_names_numpy(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg, _): #@
+ '''docstring ...
+
+ Parameters
+ ----------
+ arg : int
+ An argument.
+ '''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_useless_docs_ignored_argument_names_sphinx(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg, _, _ignored): #@
+ '''docstring ...
+
+ :param arg: An argument.
+ :type arg: int
+
+ :param _: Another argument.
+ :type _: float
+
+ :param _ignored: Ignored argument.
+ '''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="useless-param-doc", node=node, args=("_, _ignored",)),
+ Message(msg_id="useless-type-doc", node=node, args=("_",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_useless_docs_ignored_argument_names_google(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg, _, _ignored): #@
+ '''docstring ...
+
+ Args:
+ arg (int): An argument.
+ _ (float): Another argument.
+ _ignored: Ignored argument.
+ '''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="useless-param-doc", node=node, args=("_, _ignored",)),
+ Message(msg_id="useless-type-doc", node=node, args=("_",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_useless_docs_ignored_argument_names_numpy(self):
+ """Example of a method documenting the return type that an
+ implementation should return.
+ """
+ node = astroid.extract_node(
+ """
+ class Foo(object):
+ def foo(self, arg, _, _ignored): #@
+ '''docstring ...
+
+ Parameters
+ ----------
+ arg : int
+ An argument.
+
+ _ : float
+ Another argument.
+
+ _ignored :
+ Ignored Argument
+ '''
+ pass
+ """
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="useless-param-doc", node=node, args=("_, _ignored",)),
+ Message(msg_id="useless-type-doc", node=node, args=("_",)),
+ ):
+ self.checker.visit_functiondef(node)
+
+ @set_config(no_docstring_rgx=r"^_(?!_).*$")
+ def test_skip_no_docstring_rgx(self):
+ """Example of a function that matches the default 'no-docstring-rgx' config option
+
+ No error message is emitted.
+ """
+ node = astroid.extract_node(
+ """
+ def _private_function_foo(x, y):
+ '''docstring ...
+
+ missing parameter documentation'''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ @set_config(docstring_min_length=3)
+ def test_skip_docstring_min_length(self):
+ """Example of a function that is less than 'docstring-min-length' config option
+
+ No error message is emitted.
+ """
+ node = astroid.extract_node(
+ """
+ def function_foo(x, y):
+ '''function is too short and is missing parameter documentation'''
+ pass
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
diff --git a/tests/extensions/test_check_docs_utils.py b/tests/extensions/test_check_docs_utils.py
new file mode 100644
index 0000000..49a2eac
--- /dev/null
+++ b/tests/extensions/test_check_docs_utils.py
@@ -0,0 +1,149 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016, 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the pylint checkers in :mod:`pylint.extensions.check_docs`,
+in particular the parameter documentation checker `DocstringChecker`
+"""
+import astroid
+import pytest
+
+from pylint.extensions import _check_docs_utils as utils
+
+
+@pytest.mark.parametrize(
+ "string,count",
+ [("abc", 0), ("", 0), (" abc", 2), ("\n abc", 0), (" \n abc", 3)],
+)
+def test_space_indentation(string, count):
+ """Test for pylint_plugin.ParamDocChecker"""
+ assert utils.space_indentation(string) == count
+
+
+@pytest.mark.parametrize(
+ "raise_node,expected",
+ [
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ raise NotImplementedError #@
+ """
+ ),
+ {"NotImplementedError"},
+ ),
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ raise NotImplementedError("Not implemented!") #@
+ """
+ ),
+ {"NotImplementedError"},
+ ),
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ try:
+ fake_func()
+ except RuntimeError:
+ raise #@
+ """
+ ),
+ {"RuntimeError"},
+ ),
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ try:
+ fake_func()
+ except RuntimeError:
+ if another_func():
+ raise #@
+ """
+ ),
+ {"RuntimeError"},
+ ),
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ try:
+ fake_func()
+ except RuntimeError:
+ try:
+ another_func()
+ raise #@
+ except NameError:
+ pass
+ """
+ ),
+ {"RuntimeError"},
+ ),
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ try:
+ fake_func()
+ except RuntimeError:
+ try:
+ another_func()
+ except NameError:
+ raise #@
+ """
+ ),
+ {"NameError"},
+ ),
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ try:
+ fake_func()
+ except:
+ raise #@
+ """
+ ),
+ set(),
+ ),
+ (
+ astroid.extract_node(
+ """
+ def my_func():
+ try:
+ fake_func()
+ except (RuntimeError, ValueError):
+ raise #@
+ """
+ ),
+ {"RuntimeError", "ValueError"},
+ ),
+ (
+ astroid.extract_node(
+ """
+ import not_a_module
+ def my_func():
+ try:
+ fake_func()
+ except not_a_module.Error:
+ raise #@
+ """
+ ),
+ set(),
+ ),
+ ],
+)
+def test_exception(raise_node, expected):
+ found = utils.possible_exc_types(raise_node)
+ assert found == expected
diff --git a/tests/extensions/test_check_mccabe.py b/tests/extensions/test_check_mccabe.py
new file mode 100644
index 0000000..0dcb347
--- /dev/null
+++ b/tests/extensions/test_check_mccabe.py
@@ -0,0 +1,66 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_mccabe"""
+# pylint: disable=redefined-outer-name
+
+from os import path as osp
+
+import pytest
+
+from pylint.extensions import mccabe
+
+EXPECTED_MSGS = [
+ "'f1' is too complex. The McCabe rating is 1",
+ "'f2' is too complex. The McCabe rating is 1",
+ "'f3' is too complex. The McCabe rating is 3",
+ "'f4' is too complex. The McCabe rating is 2",
+ "'f5' is too complex. The McCabe rating is 2",
+ "'f6' is too complex. The McCabe rating is 2",
+ "'f7' is too complex. The McCabe rating is 3",
+ "'f8' is too complex. The McCabe rating is 4",
+ "'f9' is too complex. The McCabe rating is 9",
+ "'method1' is too complex. The McCabe rating is 1",
+ "This 'for' is too complex. The McCabe rating is 4",
+ "'method3' is too complex. The McCabe rating is 2",
+ "'f10' is too complex. The McCabe rating is 11",
+ "'method2' is too complex. The McCabe rating is 18",
+]
+
+
+@pytest.fixture(scope="module")
+def enable():
+ return ["too-complex"]
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["all"]
+
+
+@pytest.fixture(scope="module")
+def register():
+ return mccabe.register
+
+
+@pytest.fixture
+def fname_mccabe_example():
+ return osp.join(osp.dirname(osp.abspath(__file__)), "data", "mccabe.py")
+
+
+@pytest.mark.parametrize(
+ "complexity, expected", [(0, EXPECTED_MSGS), (9, EXPECTED_MSGS[-2:])]
+)
+def test_max_mccabe_rate(linter, fname_mccabe_example, complexity, expected):
+ linter.global_set_option("max-complexity", complexity)
+ linter.check([fname_mccabe_example])
+ real_msgs = [message.msg for message in linter.reporter.messages]
+ assert sorted(expected) == sorted(real_msgs)
diff --git a/tests/extensions/test_check_raise_docs.py b/tests/extensions/test_check_raise_docs.py
new file mode 100644
index 0000000..3e3d471
--- /dev/null
+++ b/tests/extensions/test_check_raise_docs.py
@@ -0,0 +1,901 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016, 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2018 Jim Robertson <jrobertson98atx@gmail.com>
+# Copyright (c) 2018 Adam Dangoor <adamdangoor@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Danny Hermes <daniel.j.hermes@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the raised exception documentation checking in the
+`DocstringChecker` in :mod:`pylint.extensions.check_docs`
+"""
+
+# pylint: disable=too-many-public-methods
+
+import astroid
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstringCheckerRaise(CheckerTestCase):
+ """Tests for pylint_plugin.RaiseDocChecker"""
+
+ CHECKER_CLASS = DocstringParameterChecker
+
+ def test_ignores_no_docstring(self):
+ raise_node = astroid.extract_node(
+ """
+ def my_func(self):
+ raise RuntimeError('hi') #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_unknown_style(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring."""
+ raise RuntimeError('hi')
+ '''
+ )
+ raise_node = node.body[0]
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ @set_config(accept_no_raise_doc=False)
+ def test_warns_unknown_style(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring."""
+ raise RuntimeError('hi')
+ '''
+ )
+ raise_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_missing_sphinx_raises(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Never
+ """
+ raise RuntimeError('hi')
+ raise NameError('hi')
+ '''
+ )
+ raise_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_missing_google_raises(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises:
+ NameError: Never
+ """
+ raise RuntimeError('hi')
+ raise NameError('hi')
+ '''
+ )
+ raise_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_google_attr_raises_exact_exc(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a google docstring.
+
+ Raises:
+ re.error: Sometimes
+ """
+ import re
+ raise re.error('hi') #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_google_attr_raises_substr_exc(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a google docstring.
+
+ Raises:
+ re.error: Sometimes
+ """
+ from re import error
+ raise error('hi') #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_valid_missing_google_attr_raises(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a google docstring.
+
+ Raises:
+ re.anothererror: Sometimes
+ """
+ from re import error
+ raise error('hi')
+ '''
+ )
+ raise_node = node.body[1]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("error",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_invalid_missing_google_attr_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a google docstring.
+
+ Raises:
+ bogusmodule.error: Sometimes
+ """
+ from re import error
+ raise error('hi') #@
+ '''
+ )
+ # pylint allows this to pass since the comparison between Raises and
+ # raise are based on the class name, not the qualified name.
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_google_raises_local_reference(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a google docstring.
+
+ Raises:
+ .LocalException: Always
+ """
+ from neighbor_module import LocalException
+ raise LocalException('hi') #@
+ '''
+ )
+ # pylint allows this to pass since the comparison between Raises and
+ # raise are based on the class name, not the qualified name.
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ @set_config(accept_no_raise_doc=False)
+ def test_google_raises_with_prefix(self):
+ code_snippet = '''
+ def my_func(self):
+ """This is a google docstring.
+
+ Raises:
+ {prefix}re.error: Sometimes
+ """
+ import re
+ raise re.error('hi') #@
+ '''
+ for prefix in ("~", "!"):
+ raise_node = astroid.extract_node(code_snippet.format(prefix=prefix))
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_missing_numpy_raises(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises
+ ------
+ NameError
+ Never
+ """
+ raise RuntimeError('hi')
+ raise NameError('hi')
+ '''
+ )
+ raise_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_ignore_spurious_sphinx_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises RuntimeError: Always
+ :except NameError: Never
+ :raise OSError: Never
+ :exception ValueError: Never
+ """
+ raise RuntimeError('Blah') #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_all_sphinx_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises RuntimeError: Always
+ :except NameError: Never
+ :raise OSError: Never
+ :exception ValueError: Never
+ """
+ raise RuntimeError('hi') #@
+ raise NameError('hi')
+ raise OSError(2, 'abort!')
+ raise ValueError('foo')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_all_google_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises:
+ RuntimeError: Always
+ NameError: Never
+ """
+ raise RuntimeError('hi') #@
+ raise NameError('hi')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_all_numpy_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises
+ ------
+ RuntimeError
+ Always
+ NameError
+ Never
+ """
+ raise RuntimeError('hi') #@
+ raise NameError('hi')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_multiple_sphinx_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises RuntimeError: Always
+ :raises NameError, OSError, ValueError: Never
+ """
+ raise RuntimeError('hi')
+ raise NameError('hi') #@
+ raise OSError(2, 'abort!')
+ raise ValueError('foo')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_multiple_google_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises:
+ RuntimeError: Always
+ NameError, OSError, ValueError: Never
+ """
+ raise RuntimeError('hi')
+ raise NameError('hi') #@
+ raise OSError(2, 'abort!')
+ raise ValueError('foo')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_finds_rethrown_sphinx_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Sometimes
+ """
+ try:
+ fake_func()
+ except RuntimeError:
+ raise #@
+
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_rethrown_google_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises:
+ NameError: Sometimes
+ """
+ try:
+ fake_func()
+ except RuntimeError:
+ raise #@
+
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_rethrown_numpy_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises
+ ------
+ NameError
+ Sometimes
+ """
+ try:
+ fake_func()
+ except RuntimeError:
+ raise #@
+
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_finds_rethrown_sphinx_multiple_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Sometimes
+ """
+ try:
+ fake_func()
+ except (RuntimeError, ValueError):
+ raise #@
+
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc",
+ node=node,
+ args=("RuntimeError, ValueError",),
+ )
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_rethrown_google_multiple_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises:
+ NameError: Sometimes
+ """
+ try:
+ fake_func()
+ except (RuntimeError, ValueError):
+ raise #@
+
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc",
+ node=node,
+ args=("RuntimeError, ValueError",),
+ )
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_rethrown_numpy_multiple_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises
+ ------
+ NameError
+ Sometimes
+ """
+ try:
+ fake_func()
+ except (RuntimeError, ValueError):
+ raise #@
+
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(
+ msg_id="missing-raises-doc",
+ node=node,
+ args=("RuntimeError, ValueError",),
+ )
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_caught_sphinx_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Sometimes
+ """
+ try:
+ raise RuntimeError('hi') #@
+ except RuntimeError:
+ pass
+
+ raise NameError('hi')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_caught_google_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Raises:
+ NameError: Sometimes
+ """
+ try:
+ raise RuntimeError('hi') #@
+ except RuntimeError:
+ pass
+
+ raise NameError('hi')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_caught_numpy_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a numpy docstring.
+
+ Raises
+ ------
+ NameError
+ Sometimes
+ """
+ try:
+ raise RuntimeError('hi') #@
+ except RuntimeError:
+ pass
+
+ raise NameError('hi')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_numpy_attr_raises_exact_exc(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a numpy docstring.
+
+ Raises
+ ------
+ re.error
+ Sometimes
+ """
+ import re
+ raise re.error('hi') #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_numpy_attr_raises_substr_exc(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a numpy docstring.
+
+ Raises
+ ------
+ re.error
+ Sometimes
+ """
+ from re import error
+ raise error('hi') #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_valid_missing_numpy_attr_raises(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a numpy docstring.
+
+ Raises
+ ------
+ re.anothererror
+ Sometimes
+ """
+ from re import error
+ raise error('hi')
+ '''
+ )
+ raise_node = node.body[1]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("error",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_invalid_missing_numpy_attr_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a numpy docstring.
+
+ Raises
+ ------
+ bogusmodule.error
+ Sometimes
+ """
+ from re import error
+ raise error('hi') #@
+ '''
+ )
+ # pylint allows this to pass since the comparison between Raises and
+ # raise are based on the class name, not the qualified name.
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ @set_config(accept_no_raise_doc=False)
+ def test_numpy_raises_with_prefix(self):
+ code_snippet = '''
+ def my_func(self):
+ """This is a numpy docstring.
+
+ Raises
+ ------
+ {prefix}re.error
+ Sometimes
+ """
+ import re
+ raise re.error('hi') #@
+ '''
+ for prefix in ("~", "!"):
+ raise_node = astroid.extract_node(code_snippet.format(prefix=prefix))
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_missing_sphinx_raises_infer_from_instance(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Never
+ """
+ my_exception = RuntimeError('hi')
+ raise my_exception #@
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_missing_sphinx_raises_infer_from_function(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Never
+ """
+ def ex_func(val):
+ return RuntimeError(val)
+ raise ex_func('hi') #@
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_sphinx_attr_raises_exact_exc(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a sphinx docstring.
+
+ :raises re.error: Sometimes
+ """
+ import re
+ raise re.error('hi') #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_sphinx_attr_raises_substr_exc(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a sphinx docstring.
+
+ :raises re.error: Sometimes
+ """
+ from re import error
+ raise error('hi') #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_find_valid_missing_sphinx_attr_raises(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a sphinx docstring.
+
+ :raises re.anothererror: Sometimes
+ """
+ from re import error
+ raise error('hi')
+ '''
+ )
+ raise_node = node.body[1]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("error",))
+ ):
+ self.checker.visit_raise(raise_node)
+
+ def test_find_invalid_missing_sphinx_attr_raises(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a sphinx docstring.
+
+ :raises bogusmodule.error: Sometimes
+ """
+ from re import error
+ raise error('hi') #@
+ '''
+ )
+ # pylint allows this to pass since the comparison between Raises and
+ # raise are based on the class name, not the qualified name.
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ @set_config(accept_no_raise_doc=False)
+ def test_sphinx_raises_with_prefix(self):
+ code_snippet = '''
+ def my_func(self):
+ """This is a sphinx docstring.
+
+ :raises {prefix}re.error: Sometimes
+ """
+ import re
+ raise re.error('hi') #@
+ '''
+ for prefix in ("~", "!"):
+ raise_node = astroid.extract_node(code_snippet.format(prefix=prefix))
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_raise_uninferable(self):
+ raise_node = astroid.extract_node(
+ '''
+ from unknown import Unknown
+
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Never
+ """
+ raise Unknown('hi') #@
+ raise NameError('hi')
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_returns_from_inner_functions(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :raises NameError: Never
+ """
+ def ex_func(val):
+ def inner_func(value):
+ return OSError(value)
+ return RuntimeError(val)
+ raise ex_func('hi') #@
+ raise NameError('hi')
+ '''
+ )
+ node = raise_node.frame()
+ with self.assertAddsMessages(
+ Message(msg_id="missing-raises-doc", node=node, args=("RuntimeError",))
+ ):
+ # we do NOT expect a warning about the OSError in inner_func!
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_returns_use_only_names(self):
+ raise_node = astroid.extract_node(
+ '''
+ def myfunc():
+ """This is a docstring
+
+ :raises NameError: Never
+ """
+ def inner_func():
+ return 42
+
+ raise inner_func() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_ignores_returns_use_only_exception_instances(self):
+ raise_node = astroid.extract_node(
+ '''
+ def myfunc():
+ """This is a docstring
+
+ :raises MyException: Never
+ """
+ class MyException(Exception):
+ pass
+ def inner_func():
+ return MyException
+
+ raise inner_func() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_no_crash_when_inferring_handlers(self):
+ raise_node = astroid.extract_node(
+ '''
+ import collections
+
+ def test():
+ """raises
+
+ :raise U: pass
+ """
+ try:
+ pass
+ except collections.U as exc:
+ raise #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_no_crash_when_cant_find_exception(self):
+ raise_node = astroid.extract_node(
+ '''
+ import collections
+
+ def test():
+ """raises
+
+ :raise U: pass
+ """
+ try:
+ pass
+ except U as exc:
+ raise #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
+
+ def test_no_error_notimplemented_documented(self):
+ raise_node = astroid.extract_node(
+ '''
+ def my_func():
+ """
+ Raises:
+ NotImplementedError: When called.
+ """
+ raise NotImplementedError #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_raise(raise_node)
diff --git a/tests/extensions/test_check_return_docs.py b/tests/extensions/test_check_return_docs.py
new file mode 100644
index 0000000..20494c9
--- /dev/null
+++ b/tests/extensions/test_check_return_docs.py
@@ -0,0 +1,695 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016, 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Zeb Nicholls <zebedee.nicholls@climate-energy-college.org>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the return documentation checking in the
+`DocstringChecker` in :mod:`pylint.extensions.check_docs`
+"""
+
+# pylint: disable=too-many-public-methods
+
+import astroid
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstringCheckerReturn(CheckerTestCase):
+ """Tests for pylint_plugin.RaiseDocChecker"""
+
+ CHECKER_CLASS = DocstringParameterChecker
+
+ def test_ignores_no_docstring(self):
+ return_node = astroid.extract_node(
+ """
+ def my_func(self):
+ return False #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ @set_config(accept_no_return_doc=False)
+ def test_warns_no_docstring(self):
+ node = astroid.extract_node(
+ """
+ def my_func(self):
+ return False
+ """
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=node),
+ Message(msg_id="missing-return-type-doc", node=node),
+ ):
+ self.checker.visit_return(return_node)
+
+ def test_ignores_unknown_style(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring."""
+ return False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_warn_partial_sphinx_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: Always False
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-type-doc", node=node)
+ ):
+ self.checker.visit_return(return_node)
+
+ def test_sphinx_missing_return_type_with_annotations(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self) -> bool:
+ """This is a docstring.
+
+ :returns: Always False
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_warn_partial_sphinx_returns_type(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :rtype: bool
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-return-doc", node=node)):
+ self.checker.visit_return(return_node)
+
+ def test_warn_missing_sphinx_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ :param doc_type: Sphinx
+ :type doc_type: str
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=node),
+ Message(msg_id="missing-return-type-doc", node=node),
+ ):
+ self.checker.visit_return(return_node)
+
+ def test_warn_partial_google_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ Always False
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-type-doc", node=node)
+ ):
+ self.checker.visit_return(return_node)
+
+ def test_warn_partial_google_returns_type(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ bool:
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-return-doc", node=node)):
+ self.checker.visit_return(return_node)
+
+ def test_warn_missing_google_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ Parameters:
+ doc_type (str): Google
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=node),
+ Message(msg_id="missing-return-type-doc", node=node),
+ ):
+ self.checker.visit_return(return_node)
+
+ def test_warn_partial_numpy_returns_type(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ Arguments
+ ---------
+ doc_type : str
+ Numpy
+
+ Returns
+ -------
+ bool
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-return-doc", node=node)):
+ self.checker.visit_return(return_node)
+
+ def test_warn_missing_numpy_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ Arguments
+ ---------
+ doc_type : str
+ Numpy
+ """
+ return False
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-return-doc", node=node),
+ Message(msg_id="missing-return-type-doc", node=node),
+ ):
+ self.checker.visit_return(return_node)
+
+ def test_find_sphinx_returns(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :return: Always False
+ :rtype: bool
+ """
+ return False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_find_google_returns(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ bool: Always False
+ """
+ return False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_find_numpy_returns(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ bool
+ Always False
+ """
+ return False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_find_numpy_returns_with_of(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ :obj:`list` of :obj:`str`
+ List of strings
+ """
+ return ["hi", "bye"] #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_ignores_sphinx_return_none(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ :param doc_type: Sphinx
+ :type doc_type: str
+ """
+ return #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_ignores_google_return_none(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ Args:
+ doc_type (str): Google
+ """
+ return #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_ignores_numpy_return_none(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ Arguments
+ ---------
+ doc_type : str
+ Numpy
+ """
+ return #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_finds_sphinx_return_custom_class(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: An object
+ :rtype: :class:`mymodule.Class`
+ """
+ return mymodule.Class() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_finds_google_return_custom_class(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ mymodule.Class: An object
+ """
+ return mymodule.Class() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_finds_numpy_return_custom_class(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ mymodule.Class
+ An object
+ """
+ return mymodule.Class() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_finds_sphinx_return_list_of_custom_class(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: An object
+ :rtype: list(:class:`mymodule.Class`)
+ """
+ return [mymodule.Class()] #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_finds_google_return_list_of_custom_class(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ list(:class:`mymodule.Class`): An object
+ """
+ return [mymodule.Class()] #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_finds_numpy_return_list_of_custom_class(self):
+ return_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ list(:class:`mymodule.Class`)
+ An object
+ """
+ return [mymodule.Class()] #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_return(return_node)
+
+ def test_warns_sphinx_return_list_of_custom_class_without_description(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :rtype: list(:class:`mymodule.Class`)
+ """
+ return [mymodule.Class()]
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-return-doc", node=node)):
+ self.checker.visit_return(return_node)
+
+ def test_warns_google_return_list_of_custom_class_without_description(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ list(:class:`mymodule.Class`):
+ """
+ return [mymodule.Class()]
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-return-doc", node=node)):
+ self.checker.visit_return(return_node)
+
+ def test_warns_numpy_return_list_of_custom_class_without_description(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ list(:class:`mymodule.Class`)
+ """
+ return [mymodule.Class()]
+ '''
+ )
+ return_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-return-doc", node=node)):
+ self.checker.visit_return(return_node)
+
+ def test_warns_sphinx_redundant_return_doc(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: One
+ """
+ return None
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_sphinx_redundant_rtype_doc(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :rtype: int
+ """
+ return None
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_google_redundant_return_doc(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ One
+ """
+ return None
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_google_redundant_rtype_doc(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ int:
+ """
+ return None
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_numpy_redundant_return_doc(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ int
+ One
+ """
+ return None
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_numpy_redundant_rtype_doc(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ int
+ """
+ return None
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_sphinx_redundant_return_doc_multiple_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: One
+ :rtype: int
+
+ :returns: None sometimes
+ :rtype: None
+ """
+ if a_func():
+ return None
+ return 1
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_google_redundant_return_doc_multiple_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ int or None: One, or sometimes None.
+ """
+ if a_func():
+ return None
+ return 1
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_numpy_redundant_return_doc_multiple_returns(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ int
+ One
+ None
+ Sometimes
+ """
+ if a_func():
+ return None
+ return 1
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignore_sphinx_redundant_return_doc_yield(self):
+ node = astroid.extract_node(
+ '''
+ def my_func_with_yield(self):
+ """This is a docstring.
+
+ :returns: One
+ :rtype: generator
+ """
+ for value in range(3):
+ yield value
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_warns_google_redundant_return_doc_yield(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns:
+ int: One
+ """
+ yield 1
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_numpy_redundant_return_doc_yield(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Returns
+ -------
+ int
+ One
+ """
+ yield 1
+ '''
+ )
+ with self.assertAddsMessages(
+ Message(msg_id="redundant-returns-doc", node=node)
+ ):
+ self.checker.visit_functiondef(node)
diff --git a/tests/extensions/test_check_yields_docs.py b/tests/extensions/test_check_yields_docs.py
new file mode 100644
index 0000000..3dc3434
--- /dev/null
+++ b/tests/extensions/test_check_yields_docs.py
@@ -0,0 +1,488 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016, 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the yield documentation checking in the
+`DocstringChecker` in :mod:`pylint.extensions.check_docs`
+"""
+
+# pylint: disable=too-many-public-methods
+
+import astroid
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstringCheckerYield(CheckerTestCase):
+ """Tests for pylint_plugin.RaiseDocChecker"""
+
+ CHECKER_CLASS = DocstringParameterChecker
+
+ def test_ignores_no_docstring(self):
+ yield_node = astroid.extract_node(
+ """
+ def my_func(self):
+ yield False #@
+ """
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ @set_config(accept_no_yields_doc=False)
+ def test_warns_no_docstring(self):
+ node = astroid.extract_node(
+ """
+ def my_func(self):
+ yield False
+ """
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-yield-doc", node=node),
+ Message(msg_id="missing-yield-type-doc", node=node),
+ ):
+ self.checker.visit_yield(yield_node)
+
+ def test_ignores_unknown_style(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring."""
+ yield False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_warn_partial_sphinx_yields(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: Always False
+ """
+ yield False
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-yield-type-doc", node=node)
+ ):
+ self.checker.visit_yield(yield_node)
+
+ def test_warn_partial_sphinx_yields_type(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :rtype: bool
+ """
+ yield False
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-yield-doc", node=node)):
+ self.checker.visit_yield(yield_node)
+
+ def test_warn_missing_sphinx_yields(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ :param doc_type: Sphinx
+ :type doc_type: str
+ """
+ yield False
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-yield-doc", node=node),
+ Message(msg_id="missing-yield-type-doc", node=node),
+ ):
+ self.checker.visit_yield(yield_node)
+
+ def test_warn_partial_google_yields(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ Always False
+ """
+ yield False
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-yield-type-doc", node=node)
+ ):
+ self.checker.visit_yield(yield_node)
+
+ def test_warn_partial_google_yields_type(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ bool:
+ """
+ yield False
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-yield-doc", node=node)):
+ self.checker.visit_yield(yield_node)
+
+ def test_warn_missing_google_yields(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ Parameters:
+ doc_type (str): Google
+ """
+ yield False
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-yield-doc", node=node),
+ Message(msg_id="missing-yield-type-doc", node=node),
+ ):
+ self.checker.visit_yield(yield_node)
+
+ def test_warn_missing_numpy_yields(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self, doc_type):
+ """This is a docstring.
+
+ Arguments
+ ---------
+ doc_type : str
+ Numpy
+ """
+ yield False
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(
+ Message(msg_id="missing-yield-doc", node=node),
+ Message(msg_id="missing-yield-type-doc", node=node),
+ ):
+ self.checker.visit_yield(yield_node)
+
+ def test_find_sphinx_yields(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :return: Always False
+ :rtype: bool
+ """
+ yield False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_find_google_yields(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ bool: Always False
+ """
+ yield False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_find_numpy_yields(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields
+ -------
+ bool
+ Always False
+ """
+ yield False #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_finds_sphinx_yield_custom_class(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: An object
+ :rtype: :class:`mymodule.Class`
+ """
+ yield mymodule.Class() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_finds_google_yield_custom_class(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ mymodule.Class: An object
+ """
+ yield mymodule.Class() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_finds_numpy_yield_custom_class(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields
+ -------
+ mymodule.Class
+ An object
+ """
+ yield mymodule.Class() #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_finds_sphinx_yield_list_of_custom_class(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :returns: An object
+ :rtype: list(:class:`mymodule.Class`)
+ """
+ yield [mymodule.Class()] #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_finds_google_yield_list_of_custom_class(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ list(:class:`mymodule.Class`): An object
+ """
+ yield [mymodule.Class()] #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_finds_numpy_yield_list_of_custom_class(self):
+ yield_node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields
+ -------
+ list(:class:`mymodule.Class`)
+ An object
+ """
+ yield [mymodule.Class()] #@
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_warns_sphinx_yield_list_of_custom_class_without_description(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ :rtype: list(:class:`mymodule.Class`)
+ """
+ yield [mymodule.Class()]
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-yield-doc", node=node)):
+ self.checker.visit_yield(yield_node)
+
+ def test_warns_google_yield_list_of_custom_class_without_description(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ list(:class:`mymodule.Class`):
+ """
+ yield [mymodule.Class()]
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-yield-doc", node=node)):
+ self.checker.visit_yield(yield_node)
+
+ def test_warns_numpy_yield_list_of_custom_class_without_description(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields
+ -------
+ list(:class:`mymodule.Class`)
+ """
+ yield [mymodule.Class()]
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertAddsMessages(Message(msg_id="missing-yield-doc", node=node)):
+ self.checker.visit_yield(yield_node)
+
+ # No such thing as redundant yield documentation for sphinx because it
+ # doesn't support yield documentation
+
+ def test_ignores_google_redundant_yield_doc_multiple_yields(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ int or None: One, or sometimes None.
+ """
+ if a_func():
+ yield None
+ yield 1
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ def test_ignores_numpy_redundant_yield_doc_multiple_yields(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields
+ -------
+ int
+ One
+ None
+ Sometimes
+ """
+ if a_func():
+ yield None
+ yield 1
+ '''
+ )
+ with self.assertNoMessages():
+ self.checker.visit_functiondef(node)
+
+ # No such thing as redundant yield documentation for sphinx because it
+ # doesn't support yield documentation
+
+ def test_warns_google_redundant_yield_doc_return(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields:
+ int: One
+ """
+ return 1
+ '''
+ )
+ with self.assertAddsMessages(Message(msg_id="redundant-yields-doc", node=node)):
+ self.checker.visit_functiondef(node)
+
+ def test_warns_numpy_redundant_yield_doc_return(self):
+ node = astroid.extract_node(
+ '''
+ def my_func(self):
+ """This is a docstring.
+
+ Yields
+ -------
+ int
+ One
+ """
+ return 1
+ '''
+ )
+ with self.assertAddsMessages(Message(msg_id="redundant-yields-doc", node=node)):
+ self.checker.visit_functiondef(node)
+
+ def test_sphinx_missing_yield_type_with_annotations(self):
+ node = astroid.extract_node(
+ '''
+ import typing
+
+ def generator() -> typing.Iterator[int]:
+ """A simple function for checking type hints.
+
+ :returns: The number 0
+ """
+ yield 0
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
+
+ def test_google_missing_yield_type_with_annotations(self):
+ node = astroid.extract_node(
+ '''
+ import typing
+
+ def generator() -> typing.Iterator[int]:
+ """A simple function for checking type hints.
+
+ Yields:
+ The number 0
+ """
+ yield 0
+ '''
+ )
+ yield_node = node.body[0]
+ with self.assertNoMessages():
+ self.checker.visit_yield(yield_node)
diff --git a/tests/extensions/test_comparetozero.py b/tests/extensions/test_comparetozero.py
new file mode 100644
index 0000000..e9bea88
--- /dev/null
+++ b/tests/extensions/test_comparetozero.py
@@ -0,0 +1,53 @@
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.emptystring"""
+
+import os
+import unittest
+
+from pylint import checkers
+from pylint.extensions.comparetozero import CompareToZeroChecker
+from pylint.lint import PyLinter
+from pylint.reporters import BaseReporter
+
+
+class CompareToZeroTestReporter(BaseReporter):
+ def on_set_current_module(self, module, filepath):
+ self.messages = []
+
+ def _display(self, layout):
+ pass
+
+
+class CompareToZeroUsedTC(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls._linter = PyLinter()
+ cls._linter.set_reporter(CompareToZeroTestReporter())
+ checkers.initialize(cls._linter)
+ cls._linter.register_checker(CompareToZeroChecker(cls._linter))
+ cls._linter.disable("I")
+
+ def test_comparetozero_message(self):
+ elif_test = os.path.join(
+ os.path.dirname(os.path.abspath(__file__)), "data", "compare_to_zero.py"
+ )
+ self._linter.check([elif_test])
+ msgs = self._linter.reporter.messages
+ self.assertEqual(len(msgs), 4)
+ for msg in msgs:
+ self.assertEqual(msg.symbol, "compare-to-zero")
+ self.assertEqual(msg.msg, "Avoid comparisons to zero")
+ self.assertEqual(msgs[0].line, 6)
+ self.assertEqual(msgs[1].line, 9)
+ self.assertEqual(msgs[2].line, 12)
+ self.assertEqual(msgs[3].line, 15)
diff --git a/tests/extensions/test_confusing_elif.py b/tests/extensions/test_confusing_elif.py
new file mode 100644
index 0000000..131e908
--- /dev/null
+++ b/tests/extensions/test_confusing_elif.py
@@ -0,0 +1,196 @@
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.confusing_elif
+"""
+
+import astroid
+
+from pylint.extensions.confusing_elif import ConfusingConsecutiveElifChecker
+from pylint.testutils import CheckerTestCase, Message
+
+MSG_ID_CONFUSING_CONSECUTIVE_ELIF = "confusing-consecutive-elif"
+
+
+class TestConfusingConsecutiveElifChecker(CheckerTestCase):
+ """Tests for pylint.extensions.confusing_elif.ConfusingConsecutiveElifChecker"""
+
+ CHECKER_CLASS = ConfusingConsecutiveElifChecker
+
+ def test_triggered_if_if_block_ends_with_elif(self):
+ """
+ Given an if-elif construct
+ When the body of the if ends with an elif
+ Then the message confusing-consecutive-elif must be triggered.
+ """
+ example_code = """
+ def foo(a, b, c):
+ if a > b: #@
+ if a > 0:
+ return a
+ elif a < 0:
+ return 0
+ elif a > c: #@
+ return c
+ """
+ if_node_to_test, elif_node = astroid.extract_node(example_code)
+ with self.assertAddsMessages(
+ Message(msg_id=MSG_ID_CONFUSING_CONSECUTIVE_ELIF, node=elif_node)
+ ):
+ self.checker.visit_if(if_node_to_test)
+
+ def test_triggered_if_elif_block_ends_with_elif(self):
+ """
+ Given an if-elif-elif construct
+ When the body of the first elif ends with an elif
+ Then the message confusing-consecutive-elif must be triggered.
+ """
+ example_code = """
+ def foo(a, b, c):
+ if a < b:
+ return b
+ elif a > b: #@
+ if a > 0:
+ return a
+ elif a < 0:
+ return 0
+ elif a > c: #@
+ return c
+ """
+ if_node_to_test, elif_node = astroid.extract_node(example_code)
+ with self.assertAddsMessages(
+ Message(msg_id=MSG_ID_CONFUSING_CONSECUTIVE_ELIF, node=elif_node)
+ ):
+ self.checker.visit_if(if_node_to_test)
+
+ def test_triggered_if_block_ends_with_if(self):
+ """
+ Given an if-elif construct
+ When the body of the if ends with an if
+ Then the message confusing-consecutive-elif must be triggered.
+ """
+ example_code = """
+ def foo(a, b, c):
+ if a > b: #@
+ if a > 0:
+ return a
+ elif a > c: #@
+ return c
+ """
+ if_node_to_test, elif_node = astroid.extract_node(example_code)
+ with self.assertAddsMessages(
+ Message(msg_id=MSG_ID_CONFUSING_CONSECUTIVE_ELIF, node=elif_node)
+ ):
+ self.checker.visit_if(if_node_to_test)
+
+ def test_not_triggered_if_indented_block_ends_with_else(self):
+ """
+ Given an if-elif construct
+ When the body of the if ends with an else
+ Then no message shall be triggered.
+ """
+ example_code = """
+ def foo(a, b, c):
+ if a > b: #@
+ if a > 0:
+ return a
+ else:
+ return 0
+ elif a > c:
+ return c
+ """
+ if_node_to_test = astroid.extract_node(example_code)
+ with self.assertNoMessages():
+ self.checker.visit_if(if_node_to_test)
+
+ def test_not_triggered_if_indentend_block_ends_with_call(self):
+ """
+ Given an if-elif construct
+ When the body of the if ends with a function call
+ Then no message shall be triggered.
+
+ Note: There is nothing special about the body ending with a function call. This is just taken as a
+ representative value for the equivalence class of "every node class unrelated to if/elif/else".
+ """
+ example_code = """
+ def foo(a, b, c):
+ result = None
+ if a > b: #@
+ if a > 0:
+ result = a
+ print("result is", result)
+ elif a > c:
+ result = c
+ return result
+ """
+ if_node_to_test = astroid.extract_node(example_code)
+ with self.assertNoMessages():
+ self.checker.visit_if(if_node_to_test)
+
+ def test_not_triggered_if_indented_block_ends_with_ifexp(self):
+ """
+ Given an if-elif construct
+ When the body of the if ends with an if expression
+ Then no message shall be triggered.
+ """
+ example_code = """
+ def foo(a, b, c):
+ result = None
+ if a > b: #@
+ if a > 0:
+ result = a
+ result = b if b > c else c
+ elif a > c:
+ result = c
+ return result
+ """
+ if_node_to_test = astroid.extract_node(example_code)
+ with self.assertNoMessages():
+ self.checker.visit_if(if_node_to_test)
+
+ def test_not_triggered_if_outer_block_does_not_have_elif(self):
+ """
+ Given an if construct without an elif
+ When the body of the if ends with an if
+ Then no message shall be triggered.
+ """
+ example_code = """
+ def foo(a, b, c):
+ result = None
+ if a > b: #@
+ if a > 0:
+ result = a
+ elif a < 0:
+ result = 0
+ else:
+ result = c
+ return result
+ """
+ if_node_to_test = astroid.extract_node(example_code)
+ with self.assertNoMessages():
+ self.checker.visit_if(if_node_to_test)
+
+ def test_not_triggered_if_outer_block_continues_with_if(self):
+ """
+ Given an if construct which continues with a new if construct
+ When the body of the first if ends with an if expression
+ Then no message shall be triggered.
+ """
+ example_code = """
+ def foo(a, b, c):
+ result = None
+ if a > b: #@
+ if a > 0:
+ result = a
+ elif a < 0:
+ result = 0
+ if b > c:
+ result = c
+ return result
+ """
+ if_node_to_test = astroid.extract_node(example_code)
+ with self.assertNoMessages():
+ self.checker.visit_if(if_node_to_test)
diff --git a/tests/extensions/test_docstyle.py b/tests/extensions/test_docstyle.py
new file mode 100644
index 0000000..336cd31
--- /dev/null
+++ b/tests/extensions/test_docstyle.py
@@ -0,0 +1,55 @@
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Luis Escobar <lescobar@vauxoo.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_docstring
+"""
+
+from os.path import abspath, dirname, join
+
+import pytest
+
+from pylint.extensions.docstyle import DocStringStyleChecker
+
+EXPECTED_MSGS = [
+ "First line empty in function docstring",
+ "First line empty in class docstring",
+ "First line empty in method docstring",
+ "Bad docstring quotes in method, expected \"\"\", given '''",
+ 'Bad docstring quotes in method, expected """, given "',
+ 'Bad docstring quotes in method, expected """, given \'',
+ 'Bad docstring quotes in method, expected """, given \'',
+]
+
+EXPECTED_SYMBOLS = [
+ "docstring-first-line-empty",
+ "docstring-first-line-empty",
+ "docstring-first-line-empty",
+ "bad-docstring-quotes",
+ "bad-docstring-quotes",
+ "bad-docstring-quotes",
+ "bad-docstring-quotes",
+]
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return DocStringStyleChecker
+
+
+def test_docstring_message(linter):
+ docstring_test = join(dirname(abspath(__file__)), "data", "docstring.py")
+ linter.check([docstring_test])
+ msgs = linter.reporter.messages
+ assert len(msgs) == 7
+ for msg, expected_symbol, expected_msg in zip(
+ msgs, EXPECTED_SYMBOLS, EXPECTED_MSGS
+ ):
+ assert msg.symbol == expected_symbol
+ assert msg.msg == expected_msg
diff --git a/tests/extensions/test_elseif_used.py b/tests/extensions/test_elseif_used.py
new file mode 100644
index 0000000..8326458
--- /dev/null
+++ b/tests/extensions/test_elseif_used.py
@@ -0,0 +1,35 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_elif
+"""
+from os import path as osp
+
+import pytest
+
+from pylint.extensions.check_elif import ElseifUsedChecker
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return ElseifUsedChecker
+
+
+def test_elseif_message(linter):
+ elif_test = osp.join(osp.dirname(osp.abspath(__file__)), "data", "elif.py")
+ linter.check([elif_test])
+ msgs = linter.reporter.messages
+ assert len(msgs) == 2
+ for msg in msgs:
+ assert msg.symbol == "else-if-used"
+ assert msg.msg == 'Consider using "elif" instead of "else if"'
+ assert msgs[0].line == 9
+ assert msgs[1].line == 21
diff --git a/tests/extensions/test_empty_comment.py b/tests/extensions/test_empty_comment.py
new file mode 100644
index 0000000..b53f31d
--- /dev/null
+++ b/tests/extensions/test_empty_comment.py
@@ -0,0 +1,34 @@
+from pathlib import Path
+
+import pytest
+
+from pylint.extensions import empty_comment
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return empty_comment.CommentChecker
+
+
+@pytest.fixture(scope="module")
+def enable():
+ return ["empty-comment"]
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["all"]
+
+
+def test_comment_base_case(linter):
+ comment_test = str(Path(__file__).parent.joinpath("data", "empty_comment.py"))
+ linter.check([comment_test])
+ msgs = linter.reporter.messages
+ assert len(msgs) == 4
+ for msg in msgs:
+ assert msg.symbol == "empty-comment"
+ assert msg.msg == "Line with empty comment"
+ assert msgs[0].line == 2
+ assert msgs[1].line == 3
+ assert msgs[2].line == 5
+ assert msgs[3].line == 7
diff --git a/tests/extensions/test_emptystring.py b/tests/extensions/test_emptystring.py
new file mode 100644
index 0000000..5279189
--- /dev/null
+++ b/tests/extensions/test_emptystring.py
@@ -0,0 +1,44 @@
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2017-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.emptystring
+"""
+from os import path as osp
+
+import pytest
+
+from pylint.extensions.emptystring import CompareToEmptyStringChecker
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return CompareToEmptyStringChecker
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["I"]
+
+
+def test_emptystring_message(linter):
+ elif_test = osp.join(
+ osp.dirname(osp.abspath(__file__)), "data", "empty_string_comparison.py"
+ )
+ linter.check([elif_test])
+ msgs = linter.reporter.messages
+ expected_lineno = [6, 9, 12, 15]
+ assert len(msgs) == len(expected_lineno)
+ for msg, lineno in zip(msgs, expected_lineno):
+ assert msg.symbol == "compare-to-empty-string"
+ assert msg.msg == "Avoid comparisons to empty string"
+ assert msg.line == lineno
diff --git a/tests/extensions/test_overlapping_exceptions.py b/tests/extensions/test_overlapping_exceptions.py
new file mode 100644
index 0000000..e94a8f2
--- /dev/null
+++ b/tests/extensions/test_overlapping_exceptions.py
@@ -0,0 +1,87 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.overlapping_exceptions
+"""
+
+from os.path import dirname, join
+
+import pytest
+
+from pylint.extensions.overlapping_exceptions import OverlappingExceptionsChecker
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return OverlappingExceptionsChecker
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["I"]
+
+
+def test_overlapping_exceptions(linter):
+ test = join(dirname(__file__), "data", "overlapping_exceptions.py")
+ linter.check([test])
+ msgs = linter.reporter.messages
+
+ expected = [
+ (13, "Overlapping exceptions (SomeException and SomeException are the same)"),
+ (
+ 18,
+ "Overlapping exceptions (SomeException is an ancestor class of SubclassException)",
+ ),
+ (23, "Overlapping exceptions (SomeException and AliasException are the same)"),
+ (
+ 28,
+ "Overlapping exceptions (AliasException is an ancestor class of SubclassException)",
+ ),
+ (34, "Overlapping exceptions (SomeException and AliasException are the same)"),
+ (
+ 34,
+ "Overlapping exceptions (SomeException is an ancestor class of SubclassException)",
+ ),
+ (
+ 34,
+ "Overlapping exceptions (AliasException is an ancestor class of SubclassException)",
+ ),
+ (
+ 39,
+ "Overlapping exceptions (ArithmeticError is an ancestor class of FloatingPointError)",
+ ),
+ (
+ 44,
+ "Overlapping exceptions (ValueError is an ancestor class of UnicodeDecodeError)",
+ ),
+ ]
+
+ assert len(msgs) == len(expected)
+ for msg, exp in zip(msgs, expected):
+ assert msg.msg_id == "W0714"
+ assert msg.symbol == "overlapping-except"
+ assert msg.category == "warning"
+ assert (msg.line, msg.msg) == exp
+
+
+def test_overlapping_exceptions_py33(linter):
+ """From Python 3.3 both IOError and socket.error are aliases for OSError."""
+ test = join(dirname(__file__), "data", "overlapping_exceptions_py33.py")
+ linter.check([test])
+ msgs = linter.reporter.messages
+
+ expected = [
+ (7, "Overlapping exceptions (IOError and OSError are the same)"),
+ (12, "Overlapping exceptions (socket.error and OSError are the same)"),
+ (
+ 17,
+ "Overlapping exceptions (socket.error is an ancestor class of ConnectionError)",
+ ),
+ ]
+
+ assert len(msgs) == len(expected)
+ for msg, exp in zip(msgs, expected):
+ assert msg.msg_id == "W0714"
+ assert msg.symbol == "overlapping-except"
+ assert msg.category == "warning"
+ assert (msg.line, msg.msg) == exp
diff --git a/tests/extensions/test_redefined.py b/tests/extensions/test_redefined.py
new file mode 100644
index 0000000..eefe4b3
--- /dev/null
+++ b/tests/extensions/test_redefined.py
@@ -0,0 +1,51 @@
+# Copyright (c) 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_elif"""
+from os import path as osp
+
+import pytest
+
+from pylint.extensions.redefined_variable_type import MultipleTypesChecker
+from pylint.lint import fix_import_path
+
+EXPECTED = [
+ "Redefinition of self.var1 type from int to float",
+ "Redefinition of a_str type from bool to float",
+ "Redefinition of var type from int to str",
+ "Redefinition of myint type from int to bool",
+ "Redefinition of _OK type from bool to str",
+ "Redefinition of instance type from redefined.MyClass to bool",
+ "Redefinition of SOME_FLOAT type from float to int",
+ "Redefinition of var3 type from str to int",
+ "Redefinition of var type from bool to int",
+ "Redefinition of var4 type from float to str",
+]
+
+
+@pytest.fixture(scope="module")
+def checker():
+ return MultipleTypesChecker
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["I"]
+
+
+def test_types_redefined(linter):
+ elif_test = osp.join(osp.dirname(osp.abspath(__file__)), "data", "redefined.py")
+ with fix_import_path([elif_test]):
+ linter.check([elif_test])
+ msgs = sorted(linter.reporter.messages, key=lambda item: item.line)
+ assert len(msgs) == 10
+ for msg, expected in zip(msgs, EXPECTED):
+ assert msg.symbol == "redefined-variable-type"
+ assert msg.msg == expected
diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/__init__.py
diff --git a/tests/functional/a/__init__.py b/tests/functional/a/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/a/__init__.py
diff --git a/tests/functional/a/abstract/abstract_abc_methods.py b/tests/functional/a/abstract/abstract_abc_methods.py
new file mode 100644
index 0000000..d174669
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_abc_methods.py
@@ -0,0 +1,17 @@
+""" This should not warn about `prop` being abstract in Child """
+# pylint: disable=too-few-public-methods, no-absolute-import,metaclass-assignment, useless-object-inheritance
+
+import abc
+
+class Parent(object):
+ """Abstract Base Class """
+ __metaclass__ = abc.ABCMeta
+
+ @property
+ @abc.abstractmethod
+ def prop(self):
+ """ Abstract """
+
+class Child(Parent):
+ """ No warning for the following. """
+ prop = property(lambda self: 1)
diff --git a/tests/functional/a/abstract/abstract_class_instantiated_in_class.py b/tests/functional/a/abstract/abstract_class_instantiated_in_class.py
new file mode 100644
index 0000000..daaa3b6
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated_in_class.py
@@ -0,0 +1,17 @@
+"""Don't warn if the class is instantiated in its own body."""
+# pylint: disable=missing-docstring, useless-object-inheritance
+
+
+import abc
+
+
+class Ala(object, metaclass=abc.ABCMeta):
+
+ @abc.abstractmethod
+ def bala(self):
+ pass
+
+ @classmethod
+ def portocala(cls):
+ instance = cls()
+ return instance
diff --git a/tests/functional/a/abstract/abstract_class_instantiated_py3.py b/tests/functional/a/abstract/abstract_class_instantiated_py3.py
new file mode 100644
index 0000000..bf2ef2e
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated_py3.py
@@ -0,0 +1,128 @@
+"""Check that instantiating a class with
+`abc.ABCMeta` as metaclass fails if it defines
+abstract methods.
+"""
+
+# pylint: disable=too-few-public-methods, missing-docstring
+# pylint: disable=abstract-method, import-error, useless-object-inheritance
+
+import abc
+import weakref
+from lala import Bala
+
+
+class GoodClass(object, metaclass=abc.ABCMeta):
+ pass
+
+class SecondGoodClass(object, metaclass=abc.ABCMeta):
+ def test(self):
+ """ do nothing. """
+
+class ThirdGoodClass(object, metaclass=abc.ABCMeta):
+ """ This should not raise the warning. """
+ def test(self):
+ raise NotImplementedError()
+
+class BadClass(object, metaclass=abc.ABCMeta):
+ @abc.abstractmethod
+ def test(self):
+ """ do nothing. """
+
+class SecondBadClass(object, metaclass=abc.ABCMeta):
+ @property
+ @abc.abstractmethod
+ def test(self):
+ """ do nothing. """
+
+class ThirdBadClass(SecondBadClass):
+ pass
+
+
+class Structure(object, metaclass=abc.ABCMeta):
+ @abc.abstractmethod
+ def __iter__(self):
+ pass
+ @abc.abstractmethod
+ def __len__(self):
+ pass
+ @abc.abstractmethod
+ def __contains__(self, _):
+ pass
+ @abc.abstractmethod
+ def __hash__(self):
+ pass
+
+class Container(Structure):
+ def __contains__(self, _):
+ pass
+
+class Sizable(Structure):
+ def __len__(self):
+ return 42
+
+class Hashable(Structure):
+ __hash__ = 42
+
+
+class Iterator(Structure):
+ def keys(self): # pylint: disable=no-self-use
+ return iter([1, 2, 3])
+
+ __iter__ = keys
+
+class AbstractSizable(Structure):
+ @abc.abstractmethod
+ def length(self):
+ pass
+ __len__ = length
+
+class NoMroAbstractMethods(Container, Iterator, Sizable, Hashable):
+ pass
+
+class BadMroAbstractMethods(Container, Iterator, AbstractSizable):
+ pass
+
+class SomeMetaclass(metaclass=abc.ABCMeta):
+
+ @abc.abstractmethod
+ def prop(self):
+ pass
+
+class FourthGoodClass(SomeMetaclass):
+ """Don't consider this abstract if some attributes are
+ there, but can't be inferred.
+ """
+ prop = Bala # missing
+
+
+def main():
+ """ do nothing """
+ GoodClass()
+ SecondGoodClass()
+ ThirdGoodClass()
+ FourthGoodClass()
+ weakref.WeakKeyDictionary()
+ weakref.WeakValueDictionary()
+ NoMroAbstractMethods()
+
+ BadMroAbstractMethods() # [abstract-class-instantiated]
+ BadClass() # [abstract-class-instantiated]
+ SecondBadClass() # [abstract-class-instantiated]
+ ThirdBadClass() # [abstract-class-instantiated]
+
+
+if 1: # pylint: disable=using-constant-test
+ class FourthBadClass(object, metaclass=abc.ABCMeta):
+
+ def test(self):
+ pass
+else:
+ class FourthBadClass(object, metaclass=abc.ABCMeta):
+
+ @abc.abstractmethod
+ def test(self):
+ pass
+
+
+def main2():
+ FourthBadClass() # [abstract-class-instantiated]
diff --git a/tests/functional/a/abstract/abstract_class_instantiated_py3.rc b/tests/functional/a/abstract/abstract_class_instantiated_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/a/abstract/abstract_class_instantiated_py3.txt b/tests/functional/a/abstract/abstract_class_instantiated_py3.txt
new file mode 100644
index 0000000..f08baf8
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated_py3.txt
@@ -0,0 +1,5 @@
+abstract-class-instantiated:108:4:main:Abstract class 'BadMroAbstractMethods' with abstract methods instantiated
+abstract-class-instantiated:109:4:main:Abstract class 'BadClass' with abstract methods instantiated
+abstract-class-instantiated:110:4:main:Abstract class 'SecondBadClass' with abstract methods instantiated
+abstract-class-instantiated:111:4:main:Abstract class 'ThirdBadClass' with abstract methods instantiated
+abstract-class-instantiated:128:4:main2:Abstract class 'FourthBadClass' with abstract methods instantiated
diff --git a/tests/functional/a/abstract/abstract_class_instantiated_py34.py b/tests/functional/a/abstract/abstract_class_instantiated_py34.py
new file mode 100644
index 0000000..e24ad28
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated_py34.py
@@ -0,0 +1,19 @@
+"""
+Check that instantiating a class with `abc.ABCMeta` as ancestor fails if it
+defines abstract methods.
+"""
+
+# pylint: disable=too-few-public-methods, missing-docstring, no-init
+
+import abc
+
+
+
+class BadClass(abc.ABC):
+ @abc.abstractmethod
+ def test(self):
+ pass
+
+def main():
+ """ do nothing """
+ BadClass() # [abstract-class-instantiated]
diff --git a/tests/functional/a/abstract/abstract_class_instantiated_py34.rc b/tests/functional/a/abstract/abstract_class_instantiated_py34.rc
new file mode 100644
index 0000000..f400a86
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated_py34.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.4
diff --git a/tests/functional/a/abstract/abstract_class_instantiated_py34.txt b/tests/functional/a/abstract/abstract_class_instantiated_py34.txt
new file mode 100644
index 0000000..88d0ef3
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated_py34.txt
@@ -0,0 +1 @@
+abstract-class-instantiated:19:4:main:Abstract class 'BadClass' with abstract methods instantiated
diff --git a/tests/functional/a/abstract/abstract_method_py3.py b/tests/functional/a/abstract/abstract_method_py3.py
new file mode 100644
index 0000000..d58f680
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_method_py3.py
@@ -0,0 +1,107 @@
+"""Test abstract-method warning."""
+from __future__ import print_function
+
+# pylint: disable=missing-docstring, no-init, no-self-use
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+import abc
+
+
+class Abstract(object):
+ def aaaa(self):
+ """should be overridden in concrete class"""
+ raise NotImplementedError()
+
+ def bbbb(self):
+ """should be overridden in concrete class"""
+ raise NotImplementedError()
+
+
+class AbstractB(Abstract):
+ """Abstract class.
+
+ this class is checking that it does not output an error msg for
+ unimplemeted methods in abstract classes
+ """
+ def cccc(self):
+ """should be overridden in concrete class"""
+ raise NotImplementedError()
+
+class AbstractC(AbstractB, abc.ABC):
+ """
+ Abstract class.
+
+ Should not trigger a warning for unimplemented
+ abstract methods, because of explicit abc.ABC inheritance.
+ """
+
+
+class AbstractD(AbstractB, metaclass=abc.ABCMeta):
+ """
+ Abstract class.
+
+ Should not trigger a warning for unimplemented
+ abstract methods, because of explicit metaclass.
+ """
+
+
+class Concrete(Abstract): # [abstract-method]
+ """Concrete class"""
+
+ def aaaa(self):
+ """overidden form Abstract"""
+
+
+class Structure(object, metaclass=abc.ABCMeta):
+ @abc.abstractmethod
+ def __iter__(self):
+ pass
+ @abc.abstractmethod
+ def __len__(self):
+ pass
+ @abc.abstractmethod
+ def __contains__(self, _):
+ pass
+ @abc.abstractmethod
+ def __hash__(self):
+ pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Container(Structure):
+ def __contains__(self, _):
+ pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Sizable(Structure):
+ def __len__(self):
+ return 42
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Hashable(Structure):
+ __hash__ = 42
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Iterator(Structure):
+ def keys(self):
+ return iter([1, 2, 3])
+
+ __iter__ = keys
+
+
+class AbstractSizable(Structure):
+ @abc.abstractmethod
+ def length(self):
+ pass
+ __len__ = length
+
+
+class GoodComplexMRO(Container, Iterator, Sizable, Hashable):
+ pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class BadComplexMro(Container, Iterator, AbstractSizable):
+ pass
diff --git a/tests/functional/a/abstract/abstract_method_py3.rc b/tests/functional/a/abstract/abstract_method_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_method_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/a/abstract/abstract_method_py3.txt b/tests/functional/a/abstract/abstract_method_py3.txt
new file mode 100644
index 0000000..783242f
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_method_py3.txt
@@ -0,0 +1,16 @@
+abstract-method:47:0:Concrete:Method 'bbbb' is abstract in class 'Abstract' but is not overridden
+abstract-method:70:0:Container:Method '__hash__' is abstract in class 'Structure' but is not overridden
+abstract-method:70:0:Container:Method '__iter__' is abstract in class 'Structure' but is not overridden
+abstract-method:70:0:Container:Method '__len__' is abstract in class 'Structure' but is not overridden
+abstract-method:76:0:Sizable:Method '__contains__' is abstract in class 'Structure' but is not overridden
+abstract-method:76:0:Sizable:Method '__hash__' is abstract in class 'Structure' but is not overridden
+abstract-method:76:0:Sizable:Method '__iter__' is abstract in class 'Structure' but is not overridden
+abstract-method:82:0:Hashable:Method '__contains__' is abstract in class 'Structure' but is not overridden
+abstract-method:82:0:Hashable:Method '__iter__' is abstract in class 'Structure' but is not overridden
+abstract-method:82:0:Hashable:Method '__len__' is abstract in class 'Structure' but is not overridden
+abstract-method:87:0:Iterator:Method '__contains__' is abstract in class 'Structure' but is not overridden
+abstract-method:87:0:Iterator:Method '__hash__' is abstract in class 'Structure' but is not overridden
+abstract-method:87:0:Iterator:Method '__len__' is abstract in class 'Structure' but is not overridden
+abstract-method:106:0:BadComplexMro:Method '__hash__' is abstract in class 'Structure' but is not overridden
+abstract-method:106:0:BadComplexMro:Method '__len__' is abstract in class 'AbstractSizable' but is not overridden
+abstract-method:106:0:BadComplexMro:Method 'length' is abstract in class 'AbstractSizable' but is not overridden
diff --git a/tests/functional/a/access/access_attr_before_def_false_positive.py b/tests/functional/a/access/access_attr_before_def_false_positive.py
new file mode 100644
index 0000000..00b7e40
--- /dev/null
+++ b/tests/functional/a/access/access_attr_before_def_false_positive.py
@@ -0,0 +1,97 @@
+# pylint: disable=invalid-name,too-many-public-methods,attribute-defined-outside-init
+# pylint: disable=no-absolute-import, useless-object-inheritance,too-few-public-methods
+"""This module demonstrates a possible problem of pyLint with calling __init__ s
+from inherited classes.
+Initializations done there are not considered, which results in Error E0203 for
+self.cookedq."""
+
+from __future__ import print_function
+
+import telnetlib
+
+class SeeTelnet(telnetlib.Telnet):
+ """
+ Extension of telnetlib.
+ """
+
+ def __init__(self, host=None, port=0):
+ """
+ Constructor.
+ When called without arguments, create an unconnected instance.
+ With a hostname argument, it connects the instance; a port
+ number is optional.
+ Parameter:
+ - host: IP address of the host
+ - port: Port number
+ """
+ telnetlib.Telnet.__init__(self, host, port)
+
+ def readUntilArray(self, matches, _=None):
+ """
+ Read until a given string is encountered or until timeout.
+ ...
+ """
+ self.process_rawq()
+ maxLength = 0
+ for match in matches:
+ if len(match) > maxLength:
+ maxLength = len(match)
+
+class Base(object):
+ """bla bla"""
+ dougloup_papa = None
+
+ def __init__(self):
+ self._var = False
+
+class Derived(Base):
+ """derived blabla"""
+ dougloup_moi = None
+ def Work(self):
+ """do something"""
+ # E0203 - Access to member '_var' before its definition
+ if self._var:
+ print("True")
+ else:
+ print("False")
+ self._var = True
+
+ # E0203 - Access to member 'dougloup_papa' before its definition
+ if self.dougloup_papa:
+ print('dougloup !')
+ self.dougloup_papa = True
+ # E0203 - Access to member 'dougloup_moi' before its definition
+ if self.dougloup_moi:
+ print('dougloup !')
+ self.dougloup_moi = True
+
+
+class QoSALConnection(object):
+ """blabla"""
+
+ _the_instance = None
+
+ def __new__(cls):
+ if cls._the_instance is None:
+ cls._the_instance = object.__new__(cls)
+ return cls._the_instance
+
+ def __init__(self):
+ pass
+
+class DefinedOutsideInit(object):
+ """use_attr is seen as the method defining attr because its in
+ first position
+ """
+ def __init__(self):
+ self.reset()
+
+ def use_attr(self):
+ """use and set members"""
+ if self.attr:
+ print('hop')
+ self.attr = 10
+
+ def reset(self):
+ """reset members"""
+ self.attr = 4
diff --git a/tests/functional/a/access/access_member_before_definition.py b/tests/functional/a/access/access_member_before_definition.py
new file mode 100644
index 0000000..d8a97b4
--- /dev/null
+++ b/tests/functional/a/access/access_member_before_definition.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name
+# pylint: disable=attribute-defined-outside-init, useless-object-inheritance
+
+class Aaaa(object):
+ """class with attributes defined in wrong order"""
+
+ def __init__(self):
+ var1 = self._var2 # [access-member-before-definition]
+ self._var2 = 3
+ self._var3 = var1
+
+
+class Bbbb(object):
+ A = 23
+ B = A
+
+ def __getattr__(self, attr):
+ try:
+ return self.__repo
+ except AttributeError:
+ self.__repo = attr
+ return attr
+
+
+ def catchme(self, attr):
+ """no AttributeError catched"""
+ try:
+ return self._repo # [access-member-before-definition]
+ except ValueError:
+ self._repo = attr
+ return attr
+
+
+class Mixin(object):
+
+ def test_mixin(self):
+ """Don't emit access-member-before-definition for mixin classes."""
+ if self.already_defined:
+ # pylint: disable=attribute-defined-outside-init
+ self.already_defined = None
diff --git a/tests/functional/a/access/access_member_before_definition.txt b/tests/functional/a/access/access_member_before_definition.txt
new file mode 100644
index 0000000..76ba5de
--- /dev/null
+++ b/tests/functional/a/access/access_member_before_definition.txt
@@ -0,0 +1,2 @@
+access-member-before-definition:8:15:Aaaa.__init__:Access to member '_var2' before its definition line 9
+access-member-before-definition:28:19:Bbbb.catchme:Access to member '_repo' before its definition line 30
diff --git a/tests/functional/a/access/access_to__name__.py b/tests/functional/a/access/access_to__name__.py
new file mode 100644
index 0000000..82dcdbe
--- /dev/null
+++ b/tests/functional/a/access/access_to__name__.py
@@ -0,0 +1,21 @@
+# pylint: disable=too-few-public-methods, print-statement, useless-object-inheritance
+"""test access to __name__ gives undefined member on new/old class instances
+but not on new/old class object
+"""
+from __future__ import print_function
+
+class Aaaa:
+ """old class"""
+ def __init__(self):
+ print(self.__name__) # [no-member]
+ print(self.__class__.__name__)
+
+class NewClass(object):
+ """new class"""
+
+ def __new__(cls, *args, **kwargs):
+ print('new', cls.__name__)
+ return object.__new__(cls, *args, **kwargs)
+
+ def __init__(self):
+ print('init', self.__name__) # [no-member]
diff --git a/tests/functional/a/access/access_to__name__.txt b/tests/functional/a/access/access_to__name__.txt
new file mode 100644
index 0000000..5e1f80e
--- /dev/null
+++ b/tests/functional/a/access/access_to__name__.txt
@@ -0,0 +1,2 @@
+no-member:10:14:Aaaa.__init__:Instance of 'Aaaa' has no '__name__' member:INFERENCE
+no-member:21:22:NewClass.__init__:Instance of 'NewClass' has no '__name__' member:INFERENCE
diff --git a/tests/functional/a/access/access_to_protected_members.py b/tests/functional/a/access/access_to_protected_members.py
new file mode 100644
index 0000000..0643840
--- /dev/null
+++ b/tests/functional/a/access/access_to_protected_members.py
@@ -0,0 +1,213 @@
+# pylint: disable=too-few-public-methods, super-init-not-called, print-statement
+# pylint: disable=no-classmethod-decorator,useless-object-inheritance
+"""Test external access to protected class members."""
+from __future__ import print_function
+
+class MyClass(object):
+ """Class with protected members."""
+ _cls_protected = 5
+
+ def __init__(self, other):
+ MyClass._cls_protected = 6
+ self._protected = 1
+ self.public = other
+ self.attr = 0
+
+ def test(self):
+ """Docstring."""
+ self._protected += self._cls_protected
+ print(self.public._haha) # [protected-access]
+
+ def clsmeth(cls):
+ """Docstring."""
+ cls._cls_protected += 1
+ print(cls._cls_protected)
+ clsmeth = classmethod(clsmeth)
+
+ def _private_method(self):
+ """Doing nothing."""
+
+
+class Subclass(MyClass):
+ """Subclass with protected members."""
+
+ def __init__(self):
+ MyClass._protected = 5
+ super()._private_method()
+
+INST = Subclass()
+INST.attr = 1
+print(INST.attr)
+INST._protected = 2 # [protected-access]
+print(INST._protected) # [protected-access]
+INST._cls_protected = 3 # [protected-access]
+print(INST._cls_protected) # [protected-access]
+
+
+class Issue1031(object):
+ """Test for GitHub issue 1031"""
+ _attr = 1
+
+ def correct_access(self):
+ """Demonstrates correct access"""
+ return type(self)._attr
+
+ def incorrect_access(self):
+ """Demonstrates incorrect access"""
+ if self._attr == 1:
+ return type(INST)._protected # [protected-access]
+ return None
+
+
+class Issue1802(object):
+ """Test for GitHub issue 1802"""
+ def __init__(self, value):
+ self._foo = value
+ self.__private = 2 * value
+
+ def __eq__(self, other):
+ """Test a correct access as the access to protected member is in a special method"""
+ if isinstance(other, self.__class__):
+ answer = self._foo == other._foo
+ return answer and self.__private == other.__private # [protected-access]
+ return False
+
+ def not_in_special(self, other):
+ """
+ Test an incorrect access as the access to protected member is not inside a special method
+ """
+ if isinstance(other, self.__class__):
+ return self._foo == other._foo # [protected-access]
+ return False
+
+ def __le__(self, other):
+ """
+ Test a correct access as the access to protected member
+ is inside a special method even if it is deeply nested
+ """
+ if 2 > 1:
+ if isinstance(other, self.__class__):
+ if "answer" == "42":
+ return self._foo == other._foo
+ return False
+
+ def __fake_special__(self, other):
+ """
+ Test an incorrect access as the access
+ to protected member is not inside a licit special method
+ """
+ if isinstance(other, self.__class__):
+ return self._foo == other._foo # [protected-access]
+ return False
+
+
+class Issue1159OtherClass(object):
+ """Test for GitHub issue 1159"""
+
+ _foo = 0
+
+ def __init__(self):
+ self._bar = 0
+
+
+class Issue1159(object):
+ """Test for GitHub issue 1159"""
+
+ _foo = 0
+
+ def __init__(self):
+ self._bar = 0
+
+ @classmethod
+ def access_cls_attr(cls):
+ """
+ Access to protected class members inside class methods is OK.
+ """
+
+ _ = cls._foo
+
+ @classmethod
+ def assign_cls_attr(cls):
+ """
+ Assignment to protected class members inside class methods is OK.
+ """
+
+ cls._foo = 1
+
+ @classmethod
+ def access_inst_attr(cls):
+ """
+ Access to protected instance members inside class methods is OK.
+ """
+
+ instance = cls()
+ _ = instance._bar
+
+ @classmethod
+ def assign_inst_attr(cls):
+ """
+ Assignment to protected members inside class methods is OK.
+ """
+
+ instance = cls()
+ instance._bar = 1
+
+ @classmethod
+ def access_other_attr(cls):
+ """
+ Access to protected instance members of other classes is not OK.
+ """
+
+ instance = Issue1159OtherClass()
+ instance._bar = 3 # [protected-access]
+ _ = instance._foo # [protected-access]
+
+
+class Issue1159Subclass(Issue1159):
+ """Test for GitHub issue 1159"""
+
+ @classmethod
+ def access_inst_attr(cls):
+ """
+ Access to protected instance members inside class methods is OK.
+ """
+
+ instance = cls()
+ _ = instance._bar
+
+ @classmethod
+ def assign_inst_attr(cls):
+ """
+ Assignment to protected instance members inside class methods is OK.
+ """
+
+ instance = cls()
+ instance._bar = 1
+
+ @classmethod
+ def access_missing_member(cls):
+ """
+ Access to unassigned members inside class methods is not OK.
+ """
+
+ instance = cls()
+ _ = instance._baz # [no-member,protected-access]
+
+ @classmethod
+ def assign_missing_member(cls):
+ """
+ Defining attributes outside init is still not OK.
+ """
+
+ instance = cls()
+ instance._qux = 1 # [attribute-defined-outside-init]
+
+ @classmethod
+ def access_other_attr(cls):
+ """
+ Access to protected instance members of other classes is not OK.
+ """
+
+ instance = Issue1159OtherClass()
+ instance._bar = 3 # [protected-access]
+ _ = instance._foo # [protected-access]
diff --git a/tests/functional/a/access/access_to_protected_members.txt b/tests/functional/a/access/access_to_protected_members.txt
new file mode 100644
index 0000000..1b93683
--- /dev/null
+++ b/tests/functional/a/access/access_to_protected_members.txt
@@ -0,0 +1,16 @@
+protected-access:19:14:MyClass.test:Access to a protected member _haha of a client class
+protected-access:41:0::Access to a protected member _protected of a client class
+protected-access:42:6::Access to a protected member _protected of a client class
+protected-access:43:0::Access to a protected member _cls_protected of a client class
+protected-access:44:6::Access to a protected member _cls_protected of a client class
+protected-access:58:19:Issue1031.incorrect_access:Access to a protected member _protected of a client class
+protected-access:72:48:Issue1802.__eq__:Access to a protected member __private of a client class
+protected-access:80:32:Issue1802.not_in_special:Access to a protected member _foo of a client class
+protected-access:100:32:Issue1802.__fake_special__:Access to a protected member _foo of a client class
+protected-access:162:8:Issue1159.access_other_attr:Access to a protected member _bar of a client class
+protected-access:163:12:Issue1159.access_other_attr:Access to a protected member _foo of a client class
+no-member:194:12:Issue1159Subclass.access_missing_member:Instance of 'Issue1159Subclass' has no '_baz' member; maybe '_bar'?:INFERENCE
+protected-access:194:12:Issue1159Subclass.access_missing_member:Access to a protected member _baz of a client class
+attribute-defined-outside-init:203:8:Issue1159Subclass.assign_missing_member:Attribute '_qux' defined outside __init__
+protected-access:212:8:Issue1159Subclass.access_other_attr:Access to a protected member _bar of a client class
+protected-access:213:12:Issue1159Subclass.access_other_attr:Access to a protected member _foo of a client class
diff --git a/tests/functional/a/alternative/alternative_union_syntax.py b/tests/functional/a/alternative/alternative_union_syntax.py
new file mode 100644
index 0000000..9e258fa
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax.py
@@ -0,0 +1,84 @@
+"""Test PEP 604 - Alternative Union syntax"""
+# pylint: disable=missing-function-docstring,unused-argument,invalid-name,missing-class-docstring
+# pylint: disable=inherit-non-class,too-few-public-methods
+import dataclasses
+import typing
+from dataclasses import dataclass
+from typing import NamedTuple, TypedDict
+
+Alias = str | list[int]
+lst = [typing.Dict[str, int] | None,]
+
+var1: typing.Dict[str, int | None]
+var2: int | str | None
+var3: int | list[str | int]
+var4: typing.Dict[typing.Tuple[int, int] | int, None]
+
+cast_var = 1
+cast_var = typing.cast(str | int, cast_var)
+
+T = typing.TypeVar("T", int | str, bool)
+
+(lambda x: 2)(int | str)
+
+var: str | int
+
+def func(arg: int | str):
+ pass
+
+def func2() -> int | str:
+ pass
+
+class CustomCls(int):
+ pass
+
+Alias2 = CustomCls | str
+
+var2 = CustomCls(1) | int(2)
+
+
+# Check typing.NamedTuple
+CustomNamedTuple = typing.NamedTuple(
+ "CustomNamedTuple", [("my_var", int | str)])
+
+class CustomNamedTuple2(NamedTuple):
+ my_var: int | str
+
+class CustomNamedTuple3(typing.NamedTuple):
+ my_var: int | str
+
+
+# Check typing.TypedDict
+CustomTypedDict = TypedDict("CustomTypedDict", my_var=(int | str))
+
+CustomTypedDict2 = TypedDict("CustomTypedDict2", {"my_var": int | str})
+
+class CustomTypedDict3(TypedDict):
+ my_var: int | str
+
+class CustomTypedDict4(typing.TypedDict):
+ my_var: int | str
+
+
+# Check dataclasses
+def my_decorator(*args, **kwargs):
+ def wraps(*args, **kwargs):
+ pass
+ return wraps
+
+@dataclass
+class CustomDataClass:
+ my_var: int | str
+
+@dataclasses.dataclass
+class CustomDataClass2:
+ my_var: int | str
+
+@dataclass()
+class CustomDataClass3:
+ my_var: int | str
+
+@my_decorator
+@dataclasses.dataclass
+class CustomDataClass4:
+ my_var: int | str
diff --git a/tests/functional/a/alternative/alternative_union_syntax.rc b/tests/functional/a/alternative/alternative_union_syntax.rc
new file mode 100644
index 0000000..68a8c8e
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.10
diff --git a/tests/functional/a/alternative/alternative_union_syntax_error.py b/tests/functional/a/alternative/alternative_union_syntax_error.py
new file mode 100644
index 0000000..4dbeaca
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax_error.py
@@ -0,0 +1,89 @@
+"""Test PEP 604 - Alternative Union syntax
+without postponed evaluation of annotations.
+
+For Python 3.7 - 3.9: Everything should fail.
+Testing only 3.8/3.9 to support TypedDict.
+"""
+# pylint: disable=missing-function-docstring,unused-argument,invalid-name,missing-class-docstring,inherit-non-class,too-few-public-methods,line-too-long
+import dataclasses
+import typing
+from dataclasses import dataclass
+from typing import NamedTuple, TypedDict
+
+
+Alias = str | typing.List[int] # [unsupported-binary-operation]
+lst = [typing.Dict[str, int] | None,] # [unsupported-binary-operation]
+
+var1: typing.Dict[str, int | None] # [unsupported-binary-operation]
+var2: int | str | None # [unsupported-binary-operation]
+var3: int | typing.List[str | int] # [unsupported-binary-operation]
+var4: typing.Dict[typing.Tuple[int, int] | int, None] # [unsupported-binary-operation]
+
+cast_var = 1
+cast_var = typing.cast(str | int, cast_var) # [unsupported-binary-operation]
+
+T = typing.TypeVar("T", int | str, bool) # [unsupported-binary-operation]
+
+(lambda x: 2)(int | str) # [unsupported-binary-operation]
+
+var: str | int # [unsupported-binary-operation]
+
+def func(arg: int | str): # [unsupported-binary-operation]
+ pass
+
+def func2() -> int | str: # [unsupported-binary-operation]
+ pass
+
+class CustomCls(int):
+ pass
+
+Alias2 = CustomCls | str # [unsupported-binary-operation]
+
+var2 = CustomCls(1) | int(2)
+
+
+# Check typing.NamedTuple
+CustomNamedTuple = typing.NamedTuple(
+ "CustomNamedTuple", [("my_var", int | str)]) # [unsupported-binary-operation]
+
+class CustomNamedTuple2(NamedTuple):
+ my_var: int | str # [unsupported-binary-operation]
+
+class CustomNamedTuple3(typing.NamedTuple):
+ my_var: int | str # [unsupported-binary-operation]
+
+
+# Check typing.TypedDict
+CustomTypedDict = TypedDict("CustomTypedDict", my_var=int | str) # [unsupported-binary-operation]
+
+CustomTypedDict2 = TypedDict("CustomTypedDict2", {"my_var": int | str}) # [unsupported-binary-operation]
+
+class CustomTypedDict3(TypedDict):
+ my_var: int | str # [unsupported-binary-operation]
+
+class CustomTypedDict4(typing.TypedDict):
+ my_var: int | str # [unsupported-binary-operation]
+
+
+# Check dataclasses
+def my_decorator(*args, **kwargs):
+ def wraps(*args, **kwargs):
+ pass
+ return wraps
+
+@dataclass
+class CustomDataClass:
+ my_var: int | str # [unsupported-binary-operation]
+
+@dataclasses.dataclass
+class CustomDataClass2:
+ my_var: int | str # [unsupported-binary-operation]
+
+@dataclass()
+class CustomDataClass3:
+ my_var: int | str # [unsupported-binary-operation]
+
+@my_decorator
+@dataclasses.dataclass
+class CustomDataClass4:
+ my_var: int | str # [unsupported-binary-operation]
diff --git a/tests/functional/a/alternative/alternative_union_syntax_error.rc b/tests/functional/a/alternative/alternative_union_syntax_error.rc
new file mode 100644
index 0000000..776b99f
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax_error.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.8
+max_pyver=3.10
diff --git a/tests/functional/a/alternative/alternative_union_syntax_error.txt b/tests/functional/a/alternative/alternative_union_syntax_error.txt
new file mode 100644
index 0000000..d6c1bca
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax_error.txt
@@ -0,0 +1,24 @@
+unsupported-binary-operation:14:8::unsupported operand type(s) for |
+unsupported-binary-operation:15:7::unsupported operand type(s) for |
+unsupported-binary-operation:17:23::unsupported operand type(s) for |
+unsupported-binary-operation:18:6::unsupported operand type(s) for |
+unsupported-binary-operation:19:6::unsupported operand type(s) for |
+unsupported-binary-operation:20:18::unsupported operand type(s) for |
+unsupported-binary-operation:23:23::unsupported operand type(s) for |
+unsupported-binary-operation:25:24::unsupported operand type(s) for |
+unsupported-binary-operation:27:14::unsupported operand type(s) for |
+unsupported-binary-operation:29:5::unsupported operand type(s) for |
+unsupported-binary-operation:31:14:func:unsupported operand type(s) for |
+unsupported-binary-operation:34:15:func2:unsupported operand type(s) for |
+unsupported-binary-operation:40:9::unsupported operand type(s) for |
+unsupported-binary-operation:47:36::unsupported operand type(s) for |
+unsupported-binary-operation:50:12:CustomNamedTuple2:unsupported operand type(s) for |
+unsupported-binary-operation:53:12:CustomNamedTuple3:unsupported operand type(s) for |
+unsupported-binary-operation:57:54::unsupported operand type(s) for |
+unsupported-binary-operation:59:60::unsupported operand type(s) for |
+unsupported-binary-operation:62:12:CustomTypedDict3:unsupported operand type(s) for |
+unsupported-binary-operation:65:12:CustomTypedDict4:unsupported operand type(s) for |
+unsupported-binary-operation:76:12:CustomDataClass:unsupported operand type(s) for |
+unsupported-binary-operation:80:12:CustomDataClass2:unsupported operand type(s) for |
+unsupported-binary-operation:84:12:CustomDataClass3:unsupported operand type(s) for |
+unsupported-binary-operation:89:12:CustomDataClass4:unsupported operand type(s) for |
diff --git a/tests/functional/a/alternative/alternative_union_syntax_py37.py b/tests/functional/a/alternative/alternative_union_syntax_py37.py
new file mode 100644
index 0000000..95e463f
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax_py37.py
@@ -0,0 +1,90 @@
+"""Test PEP 604 - Alternative Union syntax
+with postponed evaluation of annotations enabled.
+
+For Python 3.7 - 3.9: Most things should work.
+Testing only 3.8/3.9 to support TypedDict.
+"""
+# pylint: disable=missing-function-docstring,unused-argument,invalid-name,missing-class-docstring,inherit-non-class,too-few-public-methods,line-too-long
+from __future__ import annotations
+import dataclasses
+import typing
+from dataclasses import dataclass
+from typing import NamedTuple, TypedDict
+
+
+Alias = str | typing.List[int] # [unsupported-binary-operation]
+lst = [typing.Dict[str, int] | None,] # [unsupported-binary-operation]
+
+var1: typing.Dict[str, int | None]
+var2: int | str | None
+var3: int | list[str | int]
+var4: typing.Dict[typing.Tuple[int, int] | int, None]
+
+cast_var = 1
+cast_var = typing.cast(str | int, cast_var) # [unsupported-binary-operation]
+
+T = typing.TypeVar("T", int | str, bool) # [unsupported-binary-operation]
+
+(lambda x: 2)(int | str) # [unsupported-binary-operation]
+
+var: str | int
+
+def func(arg: int | str):
+ pass
+
+def func2() -> int | str:
+ pass
+
+class CustomCls(int):
+ pass
+
+Alias2 = CustomCls | str # [unsupported-binary-operation]
+
+var2 = CustomCls(1) | int(2)
+
+
+# Check typing.NamedTuple
+CustomNamedTuple = typing.NamedTuple(
+ "CustomNamedTuple", [("my_var", int | str)]) # [unsupported-binary-operation]
+
+class CustomNamedTuple2(NamedTuple):
+ my_var: int | str
+
+class CustomNamedTuple3(typing.NamedTuple):
+ my_var: int | str
+
+
+# Check typing.TypedDict
+CustomTypedDict = TypedDict("CustomTypedDict", my_var=int | str) # [unsupported-binary-operation]
+
+CustomTypedDict2 = TypedDict("CustomTypedDict2", {"my_var": int | str}) # [unsupported-binary-operation]
+
+class CustomTypedDict3(TypedDict):
+ my_var: int | str
+
+class CustomTypedDict4(typing.TypedDict):
+ my_var: int | str
+
+
+# Check dataclasses
+def my_decorator(*args, **kwargs):
+ def wraps(*args, **kwargs):
+ pass
+ return wraps
+
+@dataclass
+class CustomDataClass:
+ my_var: int | str
+
+@dataclasses.dataclass
+class CustomDataClass2:
+ my_var: int | str
+
+@dataclass()
+class CustomDataClass3:
+ my_var: int | str
+
+@my_decorator
+@dataclasses.dataclass
+class CustomDataClass4:
+ my_var: int | str
diff --git a/tests/functional/a/alternative/alternative_union_syntax_py37.rc b/tests/functional/a/alternative/alternative_union_syntax_py37.rc
new file mode 100644
index 0000000..776b99f
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax_py37.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.8
+max_pyver=3.10
diff --git a/tests/functional/a/alternative/alternative_union_syntax_py37.txt b/tests/functional/a/alternative/alternative_union_syntax_py37.txt
new file mode 100644
index 0000000..e97793a
--- /dev/null
+++ b/tests/functional/a/alternative/alternative_union_syntax_py37.txt
@@ -0,0 +1,9 @@
+unsupported-binary-operation:15:8::unsupported operand type(s) for |
+unsupported-binary-operation:16:7::unsupported operand type(s) for |
+unsupported-binary-operation:24:23::unsupported operand type(s) for |
+unsupported-binary-operation:26:24::unsupported operand type(s) for |
+unsupported-binary-operation:28:14::unsupported operand type(s) for |
+unsupported-binary-operation:41:9::unsupported operand type(s) for |
+unsupported-binary-operation:48:36::unsupported operand type(s) for |
+unsupported-binary-operation:58:54::unsupported operand type(s) for |
+unsupported-binary-operation:60:60::unsupported operand type(s) for |
diff --git a/tests/functional/a/anomalous_backslash_escape.py b/tests/functional/a/anomalous_backslash_escape.py
new file mode 100644
index 0000000..f753dfd
--- /dev/null
+++ b/tests/functional/a/anomalous_backslash_escape.py
@@ -0,0 +1,21 @@
+"""Test for anomalous backslash escapes in strings"""
+
+
+BAD_ESCAPE = '\z' # [anomalous-backslash-in-string]
+BAD_ESCAPE_NOT_FIRST = 'abc\z' # [anomalous-backslash-in-string]
+BAD_ESCAPE_WITH_PREFIX = b'abc\z' # [anomalous-backslash-in-string]
+BAD_ESCAPE_WITH_BACKSLASH = b'a\
+ \z' # [anomalous-backslash-in-string]
+# +3:[anomalous-backslash-in-string]
+BAD_ESCAPE_BLOCK = b'''
+ abc
+ \z
+'''
+BAD_ESCAPE_PARENS = (b'abc'
+ b'\z') # [anomalous-backslash-in-string]
+GOOD_ESCAPE = '\b'
+
+# Valid raw strings
+BAD_ESCAPE_BUT_RAW = r'\z'
+
+# In a comment you can have whatever you want: \z
diff --git a/tests/functional/a/anomalous_backslash_escape.txt b/tests/functional/a/anomalous_backslash_escape.txt
new file mode 100644
index 0000000..68cb855
--- /dev/null
+++ b/tests/functional/a/anomalous_backslash_escape.txt
@@ -0,0 +1,6 @@
+anomalous-backslash-in-string:4:14::"Anomalous backslash in string: '\z'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:5:27::"Anomalous backslash in string: '\z'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:6:30::"Anomalous backslash in string: '\z'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:8:4::"Anomalous backslash in string: '\z'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:12:4::"Anomalous backslash in string: '\z'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:15:23::"Anomalous backslash in string: '\z'. String constant might be missing an r prefix."
diff --git a/tests/functional/a/anomalous_unicode_escape_py3.py b/tests/functional/a/anomalous_unicode_escape_py3.py
new file mode 100644
index 0000000..18ebdf5
--- /dev/null
+++ b/tests/functional/a/anomalous_unicode_escape_py3.py
@@ -0,0 +1,19 @@
+# pylint:disable=pointless-string-statement
+"""Test for backslash escapes in byte vs unicode strings"""
+
+# Would be valid in Unicode, but probably not what you want otherwise
+BAD_UNICODE = b'\u0042' # [anomalous-unicode-escape-in-string]
+BAD_LONG_UNICODE = b'\U00000042' # [anomalous-unicode-escape-in-string]
+# +1:[anomalous-unicode-escape-in-string]
+BAD_NAMED_UNICODE = b'\N{GREEK SMALL LETTER ALPHA}'
+
+GOOD_UNICODE = u'\u0042'
+GOOD_LONG_UNICODE = u'\U00000042'
+GOOD_NAMED_UNICODE = u'\N{GREEK SMALL LETTER ALPHA}'
+
+
+# Valid raw strings
+RAW_BACKSLASHES = r'raw'
+
+# In a comment you can have whatever you want: \ \\ \n \m
+# even things that look like bad strings: "C:\Program Files"
diff --git a/tests/functional/a/anomalous_unicode_escape_py3.rc b/tests/functional/a/anomalous_unicode_escape_py3.rc
new file mode 100644
index 0000000..c0490a6
--- /dev/null
+++ b/tests/functional/a/anomalous_unicode_escape_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/a/anomalous_unicode_escape_py3.txt b/tests/functional/a/anomalous_unicode_escape_py3.txt
new file mode 100644
index 0000000..3682db8
--- /dev/null
+++ b/tests/functional/a/anomalous_unicode_escape_py3.txt
@@ -0,0 +1,3 @@
+anomalous-unicode-escape-in-string:5:16::"Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix."
+anomalous-unicode-escape-in-string:6:21::"Anomalous Unicode escape in byte string: '\U'. String constant might be missing an r or u prefix."
+anomalous-unicode-escape-in-string:8:22::"Anomalous Unicode escape in byte string: '\N'. String constant might be missing an r or u prefix."
diff --git a/tests/functional/a/arguments.py b/tests/functional/a/arguments.py
new file mode 100644
index 0000000..7d0c74f
--- /dev/null
+++ b/tests/functional/a/arguments.py
@@ -0,0 +1,262 @@
+# pylint: disable=too-few-public-methods, no-absolute-import,missing-docstring,import-error,wrong-import-position
+# pylint: disable=wrong-import-order, useless-object-inheritance,unnecessary-lambda
+
+def decorator(fun):
+ """Decorator"""
+ return fun
+
+
+class DemoClass(object):
+ """Test class for method invocations."""
+
+ @staticmethod
+ def static_method(arg):
+ """static method."""
+ return arg + arg
+
+ @classmethod
+ def class_method(cls, arg):
+ """class method"""
+ return arg + arg
+
+ def method(self, arg):
+ """method."""
+ return (self, arg)
+
+ @decorator
+ def decorated_method(self, arg):
+ """decorated method."""
+ return (self, arg)
+
+
+def function_1_arg(first_argument):
+ """one argument function"""
+ return first_argument
+
+def function_3_args(first_argument, second_argument, third_argument):
+ """three arguments function"""
+ return first_argument, second_argument, third_argument
+
+def function_default_arg(one=1, two=2):
+ """fonction with default value"""
+ return two, one
+
+
+function_1_arg(420)
+function_1_arg() # [no-value-for-parameter]
+function_1_arg(1337, 347) # [too-many-function-args]
+
+function_3_args(420, 789) # [no-value-for-parameter]
+# +1:[no-value-for-parameter,no-value-for-parameter,no-value-for-parameter]
+function_3_args()
+function_3_args(1337, 347, 456)
+function_3_args('bab', 'bebe', None, 5.6) # [too-many-function-args]
+
+function_default_arg(1, two=5)
+function_default_arg(two=5)
+
+function_1_arg(bob=4) # [unexpected-keyword-arg,no-value-for-parameter]
+function_default_arg(1, 4, coin="hello") # [unexpected-keyword-arg]
+
+function_default_arg(1, one=5) # [redundant-keyword-arg]
+
+# Remaining tests are for coverage of correct names in messages.
+LAMBDA = lambda arg: 1
+
+LAMBDA() # [no-value-for-parameter]
+
+def method_tests():
+ """Method invocations."""
+ demo = DemoClass()
+ demo.static_method() # [no-value-for-parameter]
+ DemoClass.static_method() # [no-value-for-parameter]
+
+ demo.class_method() # [no-value-for-parameter]
+ DemoClass.class_method() # [no-value-for-parameter]
+
+ demo.method() # [no-value-for-parameter]
+ DemoClass.method(demo) # [no-value-for-parameter]
+
+ demo.decorated_method() # [no-value-for-parameter]
+ DemoClass.decorated_method(demo) # [no-value-for-parameter]
+
+# Test a regression (issue #234)
+import sys
+
+class Text(object):
+ """ Regression """
+
+ if sys.version_info > (3,):
+ def __new__(cls):
+ """ empty """
+ return object.__new__(cls)
+ else:
+ def __new__(cls):
+ """ empty """
+ return object.__new__(cls)
+
+Text()
+
+class TestStaticMethod(object):
+
+ @staticmethod
+ def test(first, second=None, **kwargs):
+ return first, second, kwargs
+
+ def func(self):
+ self.test(42)
+ self.test(42, second=34)
+ self.test(42, 42)
+ self.test() # [no-value-for-parameter]
+ self.test(42, 42, 42) # [too-many-function-args]
+
+
+class TypeCheckConstructor(object):
+ def __init__(self, first, second):
+ self.first = first
+ self.second = second
+ def test(self):
+ type(self)(1, 2, 3) # [too-many-function-args]
+ # +1: [no-value-for-parameter,no-value-for-parameter]
+ type(self)()
+ type(self)(1, lala=2) # [no-value-for-parameter,unexpected-keyword-arg]
+ type(self)(1, 2)
+ type(self)(first=1, second=2)
+
+
+class Test(object):
+ """ lambda needs Test instance as first argument """
+ lam = lambda self, icon: (self, icon)
+
+ def test(self):
+ self.lam(42)
+ self.lam() # [no-value-for-parameter]
+ self.lam(1, 2, 3) # [too-many-function-args]
+
+Test().lam() # [no-value-for-parameter]
+
+# Don't emit a redundant-keyword-arg for this example,
+# it's perfectly valid
+
+class Issue642(object):
+ attr = 0
+ def __str__(self):
+ return "{self.attr}".format(self=self)
+
+# These should not emit anything regarding the number of arguments,
+# since they have something invalid.
+from ala_bala_portocola import unknown
+
+# pylint: disable=not-a-mapping,not-an-iterable
+
+function_1_arg(*unknown)
+function_1_arg(1, *2)
+function_1_arg(1, 2, 3, **unknown)
+function_1_arg(4, 5, **1)
+function_1_arg(5, 6, **{unknown: 1})
+function_1_arg(**{object: 1})
+function_1_arg(**{1: 2})
+
+def no_context_but_redefined(*args):
+ args = [1]
+ #+1: [no-value-for-parameter, no-value-for-parameter]
+ expect_three(*list(args))
+
+def no_context_one_elem(*args):
+ expect_three(args) # [no-value-for-parameter, no-value-for-parameter]
+
+# Don't emit no-value-for-parameter for this, since we
+# don't have the context at our disposal.
+def expect_three(one, two, three):
+ return one + two + three
+
+
+def no_context(*args):
+ expect_three(*args)
+
+def no_context_two(*args):
+ expect_three(*list(args))
+
+def no_context_three(*args):
+ expect_three(*set(args))
+
+def compare_prices(arg):
+ return set((arg, ))
+
+def find_problems2(prob_dates):
+ for fff in range(10):
+ prob_dates |= compare_prices(fff)
+
+
+from collections import namedtuple
+
+
+def namedtuple_replace_issue_1036():
+ cls = namedtuple('cls', 'a b c')
+ new_instance = cls(1, 2, 3)._replace(
+ a=24,
+ b=24,
+ c=42
+ )
+ # +1:[unexpected-keyword-arg,unexpected-keyword-arg]
+ new_bad_instance = cls(1, 2, 3)._replace(d=24, e=32)
+ return new_instance, new_bad_instance
+
+
+from functools import partial
+
+def some_func(first, second, third):
+ return first + second + third
+
+
+partial(some_func, 1, 2)(3)
+partial(some_func, third=1, second=2)(3)
+partial(some_func, 1, third=2)(second=3)
+partial(some_func, 1)(1) # [no-value-for-parameter]
+partial(some_func, 1)(third=1) # [no-value-for-parameter]
+partial(some_func, 1, 2)(third=1, fourth=4) # [unexpected-keyword-arg]
+
+
+def mutation_decorator(fun):
+ """Decorator that changes a function's signature."""
+ def wrapper(*args, do_something=True, **kwargs):
+ if do_something:
+ return fun(*args, **kwargs)
+
+ return None
+
+ return wrapper
+
+
+def other_mutation_decorator(fun):
+ """Another decorator that changes a function's signature"""
+ def wrapper(*args, do_something=True, **kwargs):
+ if do_something:
+ return fun(*args, **kwargs)
+
+ return None
+
+ return wrapper
+
+
+@mutation_decorator
+def mutated_function(arg):
+ return arg
+
+
+@other_mutation_decorator
+def mutated(arg):
+ return arg
+
+
+mutated_function(do_something=False)
+mutated_function()
+
+mutated(do_something=True)
+
+
+def func(one, two, three):
+ return one + two + three
+
+
+CALL = lambda *args: func(*args)
diff --git a/tests/functional/a/arguments.rc b/tests/functional/a/arguments.rc
new file mode 100644
index 0000000..4764d05
--- /dev/null
+++ b/tests/functional/a/arguments.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+signature-mutators=functional.a.arguments.mutation_decorator,other_mutation_decorator
diff --git a/tests/functional/a/arguments.txt b/tests/functional/a/arguments.txt
new file mode 100644
index 0000000..d17bd4a
--- /dev/null
+++ b/tests/functional/a/arguments.txt
@@ -0,0 +1,39 @@
+no-value-for-parameter:46:0::No value for argument 'first_argument' in function call
+too-many-function-args:47:0::Too many positional arguments for function call
+no-value-for-parameter:49:0::No value for argument 'third_argument' in function call
+no-value-for-parameter:51:0::No value for argument 'first_argument' in function call
+no-value-for-parameter:51:0::No value for argument 'second_argument' in function call
+no-value-for-parameter:51:0::No value for argument 'third_argument' in function call
+too-many-function-args:53:0::Too many positional arguments for function call
+no-value-for-parameter:58:0::No value for argument 'first_argument' in function call
+unexpected-keyword-arg:58:0::Unexpected keyword argument 'bob' in function call
+unexpected-keyword-arg:59:0::Unexpected keyword argument 'coin' in function call
+redundant-keyword-arg:61:0::Argument 'one' passed by position and keyword in function call
+no-value-for-parameter:66:0::No value for argument 'arg' in lambda call
+no-value-for-parameter:71:4:method_tests:No value for argument 'arg' in staticmethod call
+no-value-for-parameter:72:4:method_tests:No value for argument 'arg' in staticmethod call
+no-value-for-parameter:74:4:method_tests:No value for argument 'arg' in classmethod call
+no-value-for-parameter:75:4:method_tests:No value for argument 'arg' in classmethod call
+no-value-for-parameter:77:4:method_tests:No value for argument 'arg' in method call
+no-value-for-parameter:78:4:method_tests:No value for argument 'arg' in unbound method call
+no-value-for-parameter:80:4:method_tests:No value for argument 'arg' in method call
+no-value-for-parameter:81:4:method_tests:No value for argument 'arg' in unbound method call
+no-value-for-parameter:110:8:TestStaticMethod.func:No value for argument 'first' in staticmethod call
+too-many-function-args:111:8:TestStaticMethod.func:Too many positional arguments for staticmethod call
+too-many-function-args:119:8:TypeCheckConstructor.test:Too many positional arguments for constructor call
+no-value-for-parameter:121:8:TypeCheckConstructor.test:No value for argument 'first' in constructor call
+no-value-for-parameter:121:8:TypeCheckConstructor.test:No value for argument 'second' in constructor call
+no-value-for-parameter:122:8:TypeCheckConstructor.test:No value for argument 'second' in constructor call
+unexpected-keyword-arg:122:8:TypeCheckConstructor.test:Unexpected keyword argument 'lala' in constructor call
+no-value-for-parameter:133:8:Test.test:No value for argument 'icon' in method call
+too-many-function-args:134:8:Test.test:Too many positional arguments for method call
+no-value-for-parameter:136:0::No value for argument 'icon' in method call
+no-value-for-parameter:163:4:no_context_but_redefined:No value for argument 'three' in function call
+no-value-for-parameter:163:4:no_context_but_redefined:No value for argument 'two' in function call
+no-value-for-parameter:166:4:no_context_one_elem:No value for argument 'three' in function call
+no-value-for-parameter:166:4:no_context_one_elem:No value for argument 'two' in function call
+unexpected-keyword-arg:202:23:namedtuple_replace_issue_1036:Unexpected keyword argument 'd' in method call
+unexpected-keyword-arg:202:23:namedtuple_replace_issue_1036:Unexpected keyword argument 'e' in method call
+no-value-for-parameter:215:0::No value for argument 'third' in function call
+no-value-for-parameter:216:0::No value for argument 'second' in function call
+unexpected-keyword-arg:217:0::Unexpected keyword argument 'fourth' in function call
diff --git a/tests/functional/a/arguments_differ.py b/tests/functional/a/arguments_differ.py
new file mode 100644
index 0000000..b5b4350
--- /dev/null
+++ b/tests/functional/a/arguments_differ.py
@@ -0,0 +1,320 @@
+"""Test that we are emitting arguments-differ when the arguments are different."""
+# pylint: disable=missing-docstring, too-few-public-methods, unused-argument,useless-super-delegation, useless-object-inheritance, unused-private-member
+
+class Parent(object):
+
+ def test(self):
+ pass
+
+
+class Child(Parent):
+
+ def test(self, arg): # [arguments-differ]
+ pass
+
+
+class ParentDefaults(object):
+
+ def test(self, arg=None, barg=None):
+ pass
+
+class ChildDefaults(ParentDefaults):
+
+ def test(self, arg=None): # [arguments-differ]
+ pass
+
+
+class Classmethod(object):
+
+ @classmethod
+ def func(cls, data):
+ return data
+
+ @classmethod
+ def func1(cls):
+ return cls
+
+
+class ClassmethodChild(Classmethod):
+
+ @staticmethod
+ def func(): # [arguments-differ]
+ pass
+
+ @classmethod
+ def func1(cls):
+ return cls()
+
+
+class Builtins(dict):
+ """Ignore for builtins, for which we don't know the number of required args."""
+
+ @classmethod
+ def fromkeys(cls, arg, arg1):
+ pass
+
+
+class Varargs(object):
+
+ def has_kwargs(self, arg, **kwargs):
+ pass
+
+ def no_kwargs(self, args):
+ pass
+
+
+class VarargsChild(Varargs):
+
+ def has_kwargs(self, arg): # [arguments-differ]
+ "Not okay to lose capabilities. Also, type has changed."
+
+ def no_kwargs(self, arg, **kwargs): # [arguments-renamed]
+ "Addition of kwargs does not violate LSP, but first argument's name has changed."
+
+
+class Super(object):
+ def __init__(self):
+ pass
+
+ def __private(self):
+ pass
+
+ def __private2_(self):
+ pass
+
+ def ___private3(self):
+ pass
+
+ def method(self, param):
+ raise NotImplementedError
+
+
+class Sub(Super):
+
+ # pylint: disable=unused-argument
+ def __init__(self, arg):
+ super().__init__()
+
+ def __private(self, arg):
+ pass
+
+ def __private2_(self, arg):
+ pass
+
+ def ___private3(self, arg):
+ pass
+
+ def method(self, param='abc'):
+ pass
+
+
+class Staticmethod(object):
+
+ @staticmethod
+ def func(data):
+ return data
+
+
+class StaticmethodChild(Staticmethod):
+
+ @classmethod
+ def func(cls, data):
+ return data
+
+
+class Property(object):
+
+ @property
+ def close(self):
+ pass
+
+class PropertySetter(Property):
+
+ @property
+ def close(self):
+ pass
+
+ @close.setter
+ def close(self, attr):
+ return attr
+
+
+class StaticmethodChild2(Staticmethod):
+
+ def func(self, data):
+ super().func(data)
+
+
+class SuperClass(object):
+
+ @staticmethod
+ def impl(arg1, arg2, **kwargs):
+ return arg1 + arg2
+
+
+class MyClass(SuperClass):
+
+ def impl(self, *args, **kwargs):
+ """
+ Acceptable use of vararg in subclass because it does not violate LSP.
+ """
+ super().impl(*args, **kwargs)
+
+
+class FirstHasArgs(object):
+
+ def test(self, *args):
+ pass
+
+
+class SecondChangesArgs(FirstHasArgs):
+
+ def test(self, first, second, *args): # [arguments-differ]
+ pass
+
+
+class Positional(object):
+
+ def test(self, first, second):
+ pass
+
+
+class PositionalChild(Positional):
+
+ def test(self, *args):
+ """
+ Acceptable use of vararg in subclass because it does not violate LSP.
+ """
+ super().test(args[0], args[1])
+
+class Mixed(object):
+
+ def mixed(self, first, second, *, third, fourth):
+ pass
+
+
+class MixedChild1(Mixed):
+
+ def mixed(self, first, *args, **kwargs):
+ """
+ Acceptable use of vararg in subclass because it does not violate LSP.
+ """
+ super().mixed(first, *args, **kwargs)
+
+
+class MixedChild2(Mixed):
+
+ def mixed(self, first, *args, third, **kwargs):
+ """
+ Acceptable use of vararg in subclass because it does not violate LSP.
+ """
+ super().mixed(first, *args, third, **kwargs)
+
+
+class HasSpecialMethod(object):
+
+ def __getitem__(self, key):
+ return key
+
+
+class OverridesSpecialMethod(HasSpecialMethod):
+
+ def __getitem__(self, cheie):
+ # no error here, method overrides special method
+ return cheie + 1
+
+
+class ParentClass(object):
+
+ def meth(self, arg, arg1):
+ raise NotImplementedError
+
+
+class ChildClass(ParentClass):
+
+ def meth(self, _arg, dummy):
+ # no error here, "dummy" and "_" are being ignored if
+ # spotted in a variable name (declared in dummy_parameter_regex)
+ pass
+
+
+# https://github.com/PyCQA/pylint/issues/4443
+# Some valid overwrites with type annotations
+
+import typing # pylint: disable=wrong-import-position
+from typing import Dict # pylint: disable=wrong-import-position
+
+class ParentT1:
+ def func(self, user_input: Dict[str, int]) -> None:
+ pass
+
+class ChildT1(ParentT1):
+ def func(self, user_input: Dict[str, int]) -> None:
+ pass
+
+class ParentT2:
+ async def func(self, user_input: typing.List) -> None:
+ pass
+
+class ChildT2(ParentT2):
+ async def func(self, user_input: typing.List) -> None:
+ pass
+
+class FooT1:
+ pass
+
+class ParentT3:
+ def func(self, user_input: FooT1) -> None:
+ pass
+
+class ChildT3(ParentT3):
+ def func(self, user_input: FooT1) -> None:
+ pass
+
+# Keyword and positional overriddes
+class AbstractFoo:
+
+ def kwonly_1(self, first, *, second, third):
+ "Normal positional with two positional only params."
+
+ def kwonly_2(self, *, first, second):
+ "Two positional only parameter."
+
+ def kwonly_3(self, *, first, second):
+ "Two positional only params."
+
+ def kwonly_4(self, *, first, second=None):
+ "One positional only and another with a default."
+
+ def kwonly_5(self, *, first, **kwargs):
+ "Keyword only and keyword variadics."
+
+ def kwonly_6(self, first, second, *, third):
+ "Two positional and one keyword"
+
+
+class Foo(AbstractFoo):
+
+ def kwonly_1(self, first, *, second): # [arguments-differ]
+ "One positional and only one positional only param."
+
+ def kwonly_2(self, *, first): # [arguments-differ]
+ "Only one positional parameter instead of two positional only parameters."
+
+ def kwonly_3(self, first, second): # [arguments-differ]
+ "Two positional params."
+
+ def kwonly_4(self, first, second): # [arguments-differ]
+ "Two positional params."
+
+ def kwonly_5(self, *, first): # [arguments-differ]
+ "Keyword only, but no variadics."
+
+ def kwonly_6(self, *args, **kwargs): # valid override
+ "Positional and keyword variadics to pass through parent params"
+
+
+class Foo2(AbstractFoo):
+
+ def kwonly_6(self, first, *args, **kwargs): # valid override
+ "One positional with the rest variadics to pass through parent params"
diff --git a/tests/functional/a/arguments_differ.txt b/tests/functional/a/arguments_differ.txt
new file mode 100644
index 0000000..12b7305
--- /dev/null
+++ b/tests/functional/a/arguments_differ.txt
@@ -0,0 +1,11 @@
+arguments-differ:12:4:Child.test:Number of parameters was 1 in 'Parent.test' and is now 2 in overridden 'Child.test' method
+arguments-differ:23:4:ChildDefaults.test:Number of parameters was 3 in 'ParentDefaults.test' and is now 2 in overridden 'ChildDefaults.test' method
+arguments-differ:41:4:ClassmethodChild.func:Number of parameters was 2 in 'Classmethod.func' and is now 0 in overridden 'ClassmethodChild.func' method
+arguments-differ:68:4:VarargsChild.has_kwargs:Variadics removed in overridden 'VarargsChild.has_kwargs' method
+arguments-renamed:71:4:VarargsChild.no_kwargs:Parameter 'args' has been renamed to 'arg' in overridden 'VarargsChild.no_kwargs' method
+arguments-differ:172:4:SecondChangesArgs.test:Number of parameters was 2 in 'FirstHasArgs.test' and is now 4 in overridden 'SecondChangesArgs.test' method
+arguments-differ:298:4:Foo.kwonly_1:Number of parameters was 4 in 'AbstractFoo.kwonly_1' and is now 3 in overridden 'Foo.kwonly_1' method
+arguments-differ:301:4:Foo.kwonly_2:Number of parameters was 3 in 'AbstractFoo.kwonly_2' and is now 2 in overridden 'Foo.kwonly_2' method
+arguments-differ:304:4:Foo.kwonly_3:Number of parameters was 3 in 'AbstractFoo.kwonly_3' and is now 3 in overridden 'Foo.kwonly_3' method
+arguments-differ:307:4:Foo.kwonly_4:Number of parameters was 3 in 'AbstractFoo.kwonly_4' and is now 3 in overridden 'Foo.kwonly_4' method
+arguments-differ:310:4:Foo.kwonly_5:Variadics removed in overridden 'Foo.kwonly_5' method
diff --git a/tests/functional/a/arguments_out_of_order.py b/tests/functional/a/arguments_out_of_order.py
new file mode 100644
index 0000000..600664c
--- /dev/null
+++ b/tests/functional/a/arguments_out_of_order.py
@@ -0,0 +1,53 @@
+ # pylint: disable=no-self-use, no-method-argument, missing-docstring,
+
+
+def function_3_args(first_argument, second_argument, third_argument):
+ """three arguments function"""
+ return first_argument, second_argument, third_argument
+
+
+def function_default_arg(one=1, two=2):
+ """fonction with default value"""
+ return two, one
+
+
+def args_out_of_order():
+ """Tests for arguments-out-of-order"""
+ first_argument = 1
+ second_argument = 2
+ third_argument = 3
+ one = 1
+ two = 2
+
+ function_3_args(first_argument, third_argument, second_argument) # [arguments-out-of-order]
+ function_3_args(second_argument, first_argument, # [arguments-out-of-order]
+ third_argument=third_argument)
+ function_default_arg(two, one) # [arguments-out-of-order]
+
+ # Checking exceptions:
+ # supplying the same attribute twice instead of two different ones
+ function_3_args(first_argument, first_argument, third_argument)
+
+ # keyword passing
+ function_default_arg(two=two, one=one)
+
+ # anything other than named attributes
+ function_3_args(1, list, 1 + 2)
+
+ # The check assumes you know better if at least 1 arg does not match the function signature
+ function_3_args(one, third_argument, second_argument)
+
+ # we currently don't warn for the case where keyword args have been swapped
+ function_default_arg(two=one, one=two)
+
+ # ensure object methods are checked correctly despite implicit self
+ class TestClass:
+ @staticmethod
+ def function_0_args():
+ return
+ def function_2_args(self, first_argument, second_argument=2):
+ return first_argument, second_argument
+
+ TestClass().function_2_args(second_argument, first_argument) # [arguments-out-of-order]
+ TestClass().function_2_args(first_argument, second_argument=second_argument)
+ TestClass.function_0_args()
diff --git a/tests/functional/a/arguments_out_of_order.txt b/tests/functional/a/arguments_out_of_order.txt
new file mode 100644
index 0000000..b912fc9
--- /dev/null
+++ b/tests/functional/a/arguments_out_of_order.txt
@@ -0,0 +1,4 @@
+arguments-out-of-order:22:4:args_out_of_order:Positional arguments appear to be out of order
+arguments-out-of-order:23:4:args_out_of_order:Positional arguments appear to be out of order
+arguments-out-of-order:25:4:args_out_of_order:Positional arguments appear to be out of order
+arguments-out-of-order:51:4:args_out_of_order:Positional arguments appear to be out of order
diff --git a/tests/functional/a/arguments_renamed.py b/tests/functional/a/arguments_renamed.py
new file mode 100644
index 0000000..65b5115
--- /dev/null
+++ b/tests/functional/a/arguments_renamed.py
@@ -0,0 +1,74 @@
+#pylint: disable = unused-argument, missing-docstring, no-self-use, line-too-long, useless-object-inheritance, too-few-public-methods
+import enum
+
+
+class Condiment(enum.Enum):
+ CINAMON = 1
+ SUGAR = 2
+
+class Fruit:
+ def brew(self, fruit_name: str):
+ print(f"Brewing a fruit named {fruit_name}")
+
+ def eat_with_condiment(self, fruit_name:str, condiment: Condiment):
+ print(f"Eating a fruit named {fruit_name} with {condiment}")
+
+class Orange(Fruit):
+ def brew(self, orange_name: str): # [arguments-renamed]
+ print(f"Brewing an orange named {orange_name}")
+
+ def eat_with_condiment(self, orange_name: str, condiment: Condiment()): #[arguments-renamed]
+ print(f"Eating a fruit named {orange_name} with {condiment}")
+
+class Banana(Fruit):
+ def brew(self, fruit_name: bool): # No warning here
+ print(f"Brewing a banana named {fruit_name}")
+
+ def eat_with_condiment(self, fruit_name: str, condiment: Condiment, error: str): # [arguments-differ]
+ print(f"Eating a fruit named {fruit_name} with {condiment}")
+
+class Parent(object):
+
+ def test(self, arg):
+ return arg + 1
+
+ def kwargs_test(self, arg, *, var1, var2):
+ print(f"keyword parameters are {var1} and {var2}.")
+
+class Child(Parent):
+
+ def test(self, arg1): # [arguments-renamed]
+ return arg1 + 1
+
+ def kwargs_test(self, arg, *, value1, var2): #[arguments-renamed]
+ print(f"keyword parameters are {value1} and {var2}.")
+
+class Child2(Parent):
+
+ def test(self, var): # [arguments-renamed]
+ return var + 1
+
+ def kwargs_test(self, *, var1, kw2): #[arguments-renamed, arguments-differ]
+ print(f"keyword parameters are {var1} and {kw2}.")
+
+class ParentDefaults(object):
+
+ def test1(self, arg, barg):
+ print(f"Argument values are {arg} and {barg}")
+
+ def test2(self, arg, barg):
+ print(f"Argument values are {arg} and {barg}!")
+
+ def test3(self, arg1, arg2):
+ print(f"arguments: {arg1} {arg2}")
+
+class ChildDefaults(ParentDefaults):
+
+ def test1(self, arg, param2): # [arguments-renamed]
+ print(f"Argument values are {arg} and {param2}")
+
+ def test2(self, _arg, ignored_barg): # no error here
+ print(f"Argument value is {_arg}")
+
+ def test3(self, dummy_param, arg2): # no error here
+ print(f"arguments: {arg2}")
diff --git a/tests/functional/a/arguments_renamed.txt b/tests/functional/a/arguments_renamed.txt
new file mode 100644
index 0000000..0f3b60c
--- /dev/null
+++ b/tests/functional/a/arguments_renamed.txt
@@ -0,0 +1,9 @@
+arguments-renamed:17:4:Orange.brew:Parameter 'fruit_name' has been renamed to 'orange_name' in overridden 'Orange.brew' method
+arguments-renamed:20:4:Orange.eat_with_condiment:Parameter 'fruit_name' has been renamed to 'orange_name' in overridden 'Orange.eat_with_condiment' method
+arguments-differ:27:4:Banana.eat_with_condiment:Number of parameters was 3 in 'Fruit.eat_with_condiment' and is now 4 in overridden 'Banana.eat_with_condiment' method
+arguments-renamed:40:4:Child.test:Parameter 'arg' has been renamed to 'arg1' in overridden 'Child.test' method
+arguments-renamed:43:4:Child.kwargs_test:Parameter 'var1' has been renamed to 'value1' in overridden 'Child.kwargs_test' method
+arguments-renamed:48:4:Child2.test:Parameter 'arg' has been renamed to 'var' in overridden 'Child2.test' method
+arguments-differ:51:4:Child2.kwargs_test:Number of parameters was 4 in 'Parent.kwargs_test' and is now 3 in overridden 'Child2.kwargs_test' method
+arguments-renamed:51:4:Child2.kwargs_test:Parameter 'var2' has been renamed to 'kw2' in overridden 'Child2.kwargs_test' method
+arguments-renamed:67:4:ChildDefaults.test1:Parameter 'barg' has been renamed to 'param2' in overridden 'ChildDefaults.test1' method
diff --git a/tests/functional/a/assert_on_string_literal.py b/tests/functional/a/assert_on_string_literal.py
new file mode 100644
index 0000000..14e7d4c
--- /dev/null
+++ b/tests/functional/a/assert_on_string_literal.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-module-docstring, undefined-variable
+assert [foo, bar], "No AssertionError"
+assert "There is an AssertionError" # [assert-on-string-literal]
+assert "" # [assert-on-string-literal]
diff --git a/tests/functional/a/assert_on_string_literal.txt b/tests/functional/a/assert_on_string_literal.txt
new file mode 100644
index 0000000..5f08165
--- /dev/null
+++ b/tests/functional/a/assert_on_string_literal.txt
@@ -0,0 +1,2 @@
+assert-on-string-literal:3:0::Assert statement has a string literal as its first argument. The assert will never fail.
+assert-on-string-literal:4:0::Assert statement has a string literal as its first argument. The assert will always fail.
diff --git a/tests/functional/a/assert_on_tuple.py b/tests/functional/a/assert_on_tuple.py
new file mode 100644
index 0000000..e360737
--- /dev/null
+++ b/tests/functional/a/assert_on_tuple.py
@@ -0,0 +1,11 @@
+'''Assert check example'''
+
+# pylint: disable=misplaced-comparison-constant, comparison-with-itself
+assert (1 == 1, 2 == 2), "no error"
+assert (1 == 1, 2 == 2) # [assert-on-tuple]
+assert 1 == 1, "no error"
+assert (1 == 1, ), "no error"
+assert (1 == 1, )
+assert (1 == 1, 2 == 2, 3 == 5), "no error"
+assert ()
+assert (True, 'error msg') # [assert-on-tuple]
diff --git a/tests/functional/a/assert_on_tuple.txt b/tests/functional/a/assert_on_tuple.txt
new file mode 100644
index 0000000..c53faf9
--- /dev/null
+++ b/tests/functional/a/assert_on_tuple.txt
@@ -0,0 +1,2 @@
+assert-on-tuple:5:0::Assert called on a 2-item-tuple. Did you mean 'assert x,y'?
+assert-on-tuple:11:0::Assert called on a 2-item-tuple. Did you mean 'assert x,y'?
diff --git a/tests/functional/a/assign/assigment_from_no_return.py b/tests/functional/a/assign/assigment_from_no_return.py
new file mode 100644
index 0000000..4cd5ef1
--- /dev/null
+++ b/tests/functional/a/assign/assigment_from_no_return.py
@@ -0,0 +1,61 @@
+# pylint: disable=useless-return, useless-object-inheritance, condition-evals-to-constant
+"""check assignment to function call where the function doesn't return
+
+ 'E1111': ('Assigning to function call which doesn\'t return',
+ 'Used when an assignment is done on a function call but the \
+ infered function doesn\'t return anything.'),
+ 'W1111': ('Assigning to function call which only returns None',
+ 'Used when an assignment is done on a function call but the \
+ infered function returns nothing but None.'),
+
+"""
+from __future__ import generators, print_function
+
+def func_no_return():
+ """function without return"""
+ print('dougloup')
+
+A = func_no_return() # [assignment-from-no-return]
+
+
+def func_return_none():
+ """function returning none"""
+ print('dougloup')
+ return None
+
+A = func_return_none() # [assignment-from-none]
+
+
+def func_implicit_return_none():
+ """Function returning None from bare return statement."""
+ return
+
+A = func_implicit_return_none() # [assignment-from-none]
+
+
+def func_return_none_and_smth():
+ """function returning none and something else"""
+ print('dougloup')
+ if 2 or 3:
+ return None
+ return 3
+
+A = func_return_none_and_smth()
+
+def generator():
+ """no problemo"""
+ yield 2
+
+A = generator()
+
+class Abstract(object):
+ """bla bla"""
+
+ def abstract_method(self):
+ """use to return something in concrete implementation"""
+ raise NotImplementedError
+
+ def use_abstract(self):
+ """should not issue E1111"""
+ var = self.abstract_method()
+ print(var)
diff --git a/tests/functional/a/assign/assigment_from_no_return.txt b/tests/functional/a/assign/assigment_from_no_return.txt
new file mode 100644
index 0000000..4518109
--- /dev/null
+++ b/tests/functional/a/assign/assigment_from_no_return.txt
@@ -0,0 +1,3 @@
+assignment-from-no-return:18:0::Assigning result of a function call, where the function has no return
+assignment-from-none:26:0::Assigning result of a function call, where the function returns None
+assignment-from-none:33:0::Assigning result of a function call, where the function returns None
diff --git a/tests/functional/a/assign/assigning_non_slot.py b/tests/functional/a/assign/assigning_non_slot.py
new file mode 100644
index 0000000..600a2d5
--- /dev/null
+++ b/tests/functional/a/assign/assigning_non_slot.py
@@ -0,0 +1,175 @@
+""" Checks assigning attributes not found in class slots
+will trigger assigning-non-slot warning.
+"""
+# pylint: disable=too-few-public-methods, no-init, missing-docstring, no-absolute-import, import-error, useless-object-inheritance
+from collections import deque
+
+from missing import Unknown
+
+class Empty(object):
+ """ empty """
+
+class Bad(object):
+ """ missing not in slots. """
+
+ __slots__ = ['member']
+
+ def __init__(self):
+ self.missing = 42 # [assigning-non-slot]
+
+class Bad2(object):
+ """ missing not in slots """
+ __slots__ = [deque.__name__, 'member']
+
+ def __init__(self):
+ self.deque = 42
+ self.missing = 42 # [assigning-non-slot]
+
+class Bad3(Bad):
+ """ missing not found in slots """
+
+ __slots__ = ['component']
+
+ def __init__(self):
+ self.component = 42
+ self.member = 24
+ self.missing = 42 # [assigning-non-slot]
+ super().__init__()
+
+class Good(Empty):
+ """ missing not in slots, but Empty doesn't
+ specify __slots__.
+ """
+ __slots__ = ['a']
+
+ def __init__(self):
+ self.missing = 42
+
+class Good2(object):
+ """ Using __dict__ in slots will be safe. """
+
+ __slots__ = ['__dict__', 'comp']
+
+ def __init__(self):
+ self.comp = 4
+ self.missing = 5
+
+class PropertyGood(object):
+ """ Using properties is safe. """
+
+ __slots__ = ['tmp', '_value']
+
+ @property
+ def test(self):
+ return self._value
+
+ @test.setter
+ def test(self, value):
+ # pylint: disable=attribute-defined-outside-init
+ self._value = value
+
+ def __init__(self):
+ self.test = 42
+
+class PropertyGood2(object):
+ """ Using properties in the body of the class is safe. """
+ __slots__ = ['_value']
+
+ def _getter(self):
+ return self._value
+
+ def _setter(self, value):
+ # pylint: disable=attribute-defined-outside-init
+ self._value = value
+
+ test = property(_getter, _setter)
+
+ def __init__(self):
+ self.test = 24
+
+class UnicodeSlots(object):
+ """Using unicode objects in __slots__ is okay.
+
+ On Python 3.3 onward, u'' is equivalent to '',
+ so this test should be safe for both versions.
+ """
+ __slots__ = (u'first', u'second')
+
+ def __init__(self):
+ self.first = 42
+ self.second = 24
+
+
+class DataDescriptor(object):
+ def __init__(self, name, default=''):
+ self.__name = name
+ self.__default = default
+
+ def __get__(self, inst, cls):
+ return getattr(inst, self.__name, self.__default)
+
+ def __set__(self, inst, value):
+ setattr(inst, self.__name, value)
+
+
+class NonDataDescriptor(object):
+ def __get__(self, inst, cls):
+ return 42
+
+
+class SlotsWithDescriptor(object):
+ __slots__ = ['_err']
+ data_descriptor = DataDescriptor('_err')
+ non_data_descriptor = NonDataDescriptor()
+ missing_descriptor = Unknown()
+
+
+def dont_emit_for_descriptors():
+ inst = SlotsWithDescriptor()
+ # This should not emit, because attr is
+ # a data descriptor
+ inst.data_descriptor = 'foo'
+ inst.non_data_descriptor = 'lala' # [assigning-non-slot]
+
+
+class ClassWithSlots(object):
+ __slots__ = ['foobar']
+
+
+class ClassReassigningDunderClass(object):
+ __slots__ = ['foobar']
+
+ def release(self):
+ self.__class__ = ClassWithSlots
+
+
+class ClassReassingingInvalidLayoutClass(object):
+ __slots__ = []
+
+ def release(self):
+ self.__class__ = ClassWithSlots # [assigning-non-slot]
+
+
+# pylint: disable=attribute-defined-outside-init
+class ClassHavingUnknownAncestors(Unknown):
+ __slots__ = ['yo']
+
+ def test(self):
+ self.not_yo = 42
+
+
+# pylint: disable=wrong-import-order, wrong-import-position
+from typing import (
+ Generic,
+ TypeVar,
+)
+
+TYPE = TypeVar('TYPE')
+
+
+class Cls(Generic[TYPE]):
+ """ Simple class with slots """
+ __slots__ = ['value']
+
+ def __init__(self, value):
+ self.value = value
diff --git a/tests/functional/a/assign/assigning_non_slot.txt b/tests/functional/a/assign/assigning_non_slot.txt
new file mode 100644
index 0000000..28bf5d4
--- /dev/null
+++ b/tests/functional/a/assign/assigning_non_slot.txt
@@ -0,0 +1,5 @@
+assigning-non-slot:18:8:Bad.__init__:Assigning to attribute 'missing' not defined in class slots
+assigning-non-slot:26:8:Bad2.__init__:Assigning to attribute 'missing' not defined in class slots
+assigning-non-slot:36:8:Bad3.__init__:Assigning to attribute 'missing' not defined in class slots
+assigning-non-slot:132:4:dont_emit_for_descriptors:Assigning to attribute 'non_data_descriptor' not defined in class slots
+assigning-non-slot:150:8:ClassReassingingInvalidLayoutClass.release:Assigning to attribute '__class__' not defined in class slots
diff --git a/tests/functional/a/assign/assigning_non_slot_4509.py b/tests/functional/a/assign/assigning_non_slot_4509.py
new file mode 100644
index 0000000..797c6b0
--- /dev/null
+++ b/tests/functional/a/assign/assigning_non_slot_4509.py
@@ -0,0 +1,18 @@
+# pylint: disable=invalid-name,missing-docstring,too-few-public-methods
+
+# Slots with base that inherits from 'Generic'
+# https://github.com/PyCQA/pylint/issues/4509
+# https://github.com/PyCQA/astroid/issues/999
+
+from typing import Generic, TypeVar
+T = TypeVar("T")
+
+class Base(Generic[T]):
+ __slots__ = ()
+
+class Foo(Base[T]):
+ __slots__ = ['_value']
+
+ def __init__(self, value: T):
+ self._value = value
+ self._bar = value # [assigning-non-slot]
diff --git a/tests/functional/a/assign/assigning_non_slot_4509.rc b/tests/functional/a/assign/assigning_non_slot_4509.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/a/assign/assigning_non_slot_4509.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/a/assign/assigning_non_slot_4509.txt b/tests/functional/a/assign/assigning_non_slot_4509.txt
new file mode 100644
index 0000000..a347f8c
--- /dev/null
+++ b/tests/functional/a/assign/assigning_non_slot_4509.txt
@@ -0,0 +1 @@
+assigning-non-slot:18:8:Foo.__init__:Assigning to attribute '_bar' not defined in class slots
diff --git a/tests/functional/a/assign/assignment_expression.py b/tests/functional/a/assign/assignment_expression.py
new file mode 100644
index 0000000..a2a586e
--- /dev/null
+++ b/tests/functional/a/assign/assignment_expression.py
@@ -0,0 +1,86 @@
+"""Test assignment expressions"""
+# pylint: disable=missing-docstring,unused-argument,unused-import,invalid-name
+# pylint: disable=blacklisted-name,unused-variable,pointless-statement
+import re
+
+if (a := True):
+ x = a
+else:
+ x = False
+
+x = b if (b := True) else False
+x2: bool = b2 if (b2 := True) else False
+x3 = 0
+x3 += b3 if (b3 := 4) else 6
+
+a = ["a ", "b ", "c "]
+c = [text for el in a if (text := el.strip()) == "b"]
+
+
+# check wrong usage
+assert err_a, (err_a := 2) # [used-before-assignment]
+print(err_b and (err_b := 2)) # [used-before-assignment]
+values = (
+ err_c := err_d, # [used-before-assignment]
+ err_d := 2,
+)
+
+
+# https://github.com/PyCQA/pylint/issues/3347
+s = 'foo' if (fval := lambda: 1) is None else fval
+
+
+# https://github.com/PyCQA/pylint/issues/3953
+assert (n := 2) == 1, f"Expected 1, but got {n}"
+dict({1: (o := 2)}, data=o)
+assert (p := 2) == 1, \
+ p
+
+FOO_PATT = re.compile("")
+foo = m.group("foo") if (m := FOO_PATT.match("")) else False
+
+
+# https://github.com/PyCQA/pylint/issues/3865
+if (c := lambda: 2) and c():
+ print("ok")
+
+def func():
+ print((d := lambda: 2) and d)
+
+
+# https://github.com/PyCQA/pylint/issues/3275
+values = (
+ e := 1,
+ f := e,
+)
+print(values)
+
+function = lambda: (
+ h := 1,
+ i := h,
+)
+print(function())
+
+
+# https://github.com/PyCQA/pylint/issues/3763
+foo if (foo := 3 - 2) > 0 else 0
+
+
+# https://github.com/PyCQA/pylint/issues/4238
+l1 = f'The number {(count1 := 4)} ' \
+ f'is equal to {count1}'
+l2: str = (
+ f'The number {(count2 := 4)} '
+ f'is equal to {count2}'
+)
+l3 = "Hello "
+l3 += (
+ f'The number {(count3 := 4)} '
+ f'is equal to {count3}'
+)
+
+
+# https://github.com/PyCQA/pylint/issues/4301
+def func2():
+ return f'The number {(count := 4)} ' \
+ f'is equal to {count}'
diff --git a/tests/functional/a/assign/assignment_expression.rc b/tests/functional/a/assign/assignment_expression.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/a/assign/assignment_expression.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/a/assign/assignment_expression.txt b/tests/functional/a/assign/assignment_expression.txt
new file mode 100644
index 0000000..c4b8da4
--- /dev/null
+++ b/tests/functional/a/assign/assignment_expression.txt
@@ -0,0 +1,3 @@
+used-before-assignment:21:7::Using variable 'err_a' before assignment
+used-before-assignment:22:6::Using variable 'err_b' before assignment
+used-before-assignment:24:13::Using variable 'err_d' before assignment
diff --git a/tests/functional/a/assign/assignment_from_no_return.py b/tests/functional/a/assign/assignment_from_no_return.py
new file mode 100644
index 0000000..887eb8d
--- /dev/null
+++ b/tests/functional/a/assign/assignment_from_no_return.py
@@ -0,0 +1,56 @@
+# pylint: disable=missing-docstring
+
+
+def some_func():
+ pass
+
+
+def decorate(func):
+ """Decorate *fn* to return ``self`` to enable chained method calls."""
+ def wrapper(self, *args, **kw):
+ func(self, *args, **kw)
+ return 42
+ return wrapper
+
+
+class Class:
+
+ def some_method(self):
+ pass
+
+ @decorate
+ def some_other_decorated_method(self):
+ pass
+
+ def some_other_method(self):
+ value = self.some_method() # [assignment-from-no-return]
+ other_value = self.some_other_decorated_method()
+ return value + other_value
+
+
+VALUE = some_func() # [assignment-from-no-return]
+
+
+class Parent:
+ """Parent class"""
+
+ def compute(self):
+ """This isn't supported by all child classes"""
+
+ # pylint: disable=no-self-use
+ raise ValueError('Not supported for this object')
+
+ def test(self):
+ """Test"""
+
+ result = self.compute()
+ return result
+
+
+class Child(Parent):
+ """Child class"""
+
+ def compute(self):
+ """This is supported for this child class"""
+
+ return 42
diff --git a/tests/functional/a/assign/assignment_from_no_return.txt b/tests/functional/a/assign/assignment_from_no_return.txt
new file mode 100644
index 0000000..88bcd9a
--- /dev/null
+++ b/tests/functional/a/assign/assignment_from_no_return.txt
@@ -0,0 +1,2 @@
+assignment-from-no-return:26:8:Class.some_other_method:Assigning result of a function call, where the function has no return
+assignment-from-no-return:31:0::Assigning result of a function call, where the function has no return
diff --git a/tests/functional/a/assign/assignment_from_no_return_py3.py b/tests/functional/a/assign/assignment_from_no_return_py3.py
new file mode 100644
index 0000000..7b1abd5
--- /dev/null
+++ b/tests/functional/a/assign/assignment_from_no_return_py3.py
@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+
+import asyncio
+
+
+async def bla1():
+ await asyncio.sleep(1)
+
+
+async def bla2():
+ await asyncio.sleep(2)
+
+
+async def combining_coroutine1():
+ await bla1()
+ await bla2()
+
+
+class Coro:
+ async def func(self):
+ future1 = bla1()
+ future2 = bla2()
+ await asyncio.gather(future1, future2)
+
+
+async def combining_coroutine2():
+ future1 = bla1()
+ future2 = bla2()
+ future3 = Coro().func()
+ await asyncio.gather(future1, future2, future3)
+
+
+def do_stuff():
+ loop = asyncio.get_event_loop()
+ loop.run_until_complete(combining_coroutine1())
+ loop.run_until_complete(combining_coroutine2())
diff --git a/tests/functional/a/assign/assignment_from_no_return_py3.rc b/tests/functional/a/assign/assignment_from_no_return_py3.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/a/assign/assignment_from_no_return_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/a/async_functions.py b/tests/functional/a/async_functions.py
new file mode 100644
index 0000000..3e63434
--- /dev/null
+++ b/tests/functional/a/async_functions.py
@@ -0,0 +1,63 @@
+"""Check that Python 3.5's async functions are properly analyzed by Pylint."""
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods
+# pylint: disable=using-constant-test, useless-object-inheritance
+
+async def next(): # [redefined-builtin]
+ pass
+
+async def some_function(arg1, arg2): # [unused-argument]
+ await arg1
+
+
+class OtherClass(object):
+
+ @staticmethod
+ def test():
+ return 42
+
+
+class Class(object):
+
+ async def some_method(self):
+ super(OtherClass, self).test() # [bad-super-call]
+
+
+# +1: [too-many-arguments,too-many-return-statements, too-many-branches]
+async def complex_function(this, function, has, more, arguments, than,
+ one, _, should, have):
+ if 1:
+ return this
+ if 1:
+ return function
+ if 1:
+ return has
+ if 1:
+ return more
+ if 1:
+ return arguments
+ if 1:
+ return than
+ try:
+ return one
+ finally:
+ pass
+ if 2:
+ return should
+ while True:
+ pass
+ if 1:
+ return have
+ if 2:
+ return function
+ if 3:
+ pass
+
+
+# +1: [duplicate-argument-name, duplicate-argument-name, dangerous-default-value]
+async def func(a, a, b=[]):
+ return a, b
+
+
+# +1: [empty-docstring, disallowed-name]
+async def foo():
+ ""
diff --git a/tests/functional/a/async_functions.rc b/tests/functional/a/async_functions.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/a/async_functions.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/a/async_functions.txt b/tests/functional/a/async_functions.txt
new file mode 100644
index 0000000..cb53248
--- /dev/null
+++ b/tests/functional/a/async_functions.txt
@@ -0,0 +1,11 @@
+redefined-builtin:5:0:next:Redefining built-in 'next'
+unused-argument:8:30:some_function:Unused argument 'arg2'
+bad-super-call:22:8:Class.some_method:Bad first argument 'OtherClass' given to super()
+too-many-arguments:26:0:complex_function:Too many arguments (10/5)
+too-many-branches:26:0:complex_function:Too many branches (13/12)
+too-many-return-statements:26:0:complex_function:Too many return statements (10/6)
+dangerous-default-value:57:0:func:Dangerous default value [] as argument
+duplicate-argument-name:57:15:func:Duplicate argument name a in function definition
+duplicate-argument-name:57:18:func:Duplicate argument name a in function definition
+disallowed-name:62:0:foo:Disallowed name "foo"
+empty-docstring:62:0:foo:Empty function docstring
diff --git a/tests/functional/a/attribute_defined_outside_init.py b/tests/functional/a/attribute_defined_outside_init.py
new file mode 100644
index 0000000..1cb319c
--- /dev/null
+++ b/tests/functional/a/attribute_defined_outside_init.py
@@ -0,0 +1,84 @@
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name, useless-object-inheritance
+
+class A(object):
+
+ def __init__(self):
+ self.x = 0
+ self.setUp()
+
+ def set_y(self, y):
+ self.y = y
+
+ def set_x(self, x):
+ self.x = x
+
+ def set_z(self, z):
+ self.z = z # [attribute-defined-outside-init]
+
+ def setUp(self):
+ self.x = 0
+ self.y = 0
+
+
+class B(A):
+
+ def test(self):
+ self.z = 44 # [attribute-defined-outside-init]
+
+
+class C(object):
+
+ def __init__(self):
+ self._init()
+
+ def _init(self):
+ self.z = 44
+
+
+class D(object):
+
+ def setUp(self):
+ self.set_z()
+
+ def set_z(self):
+ self.z = 42
+
+
+class E(object):
+
+ def __init__(self):
+ i = self._init
+ i()
+
+ def _init(self):
+ self.z = 44
+
+
+class Mixin(object):
+
+ def test_mixin(self):
+ """Don't emit attribute-defined-outside-init for mixin classes."""
+ if self.defined_already: # pylint: disable=access-member-before-definition
+ self.defined_already = None
+
+
+class F:
+ def func(self):
+ self.__dict__ = {'foo': 'bar'}
+
+
+class Mine:
+ def __init__(self, param):
+ self.prop = param
+
+ @property
+ def prop(self):
+ return self.__prop
+
+ @prop.setter
+ def prop(self, value):
+ self.__prop = value
+
+class DataClass:
+ def __post_init__(self):
+ self.a = 42
diff --git a/tests/functional/a/attribute_defined_outside_init.txt b/tests/functional/a/attribute_defined_outside_init.txt
new file mode 100644
index 0000000..cc7a9fd
--- /dev/null
+++ b/tests/functional/a/attribute_defined_outside_init.txt
@@ -0,0 +1,2 @@
+attribute-defined-outside-init:16:8:A.set_z:Attribute 'z' defined outside __init__
+attribute-defined-outside-init:26:8:B.test:Attribute 'z' defined outside __init__
diff --git a/tests/functional/a/await_outside_async.py b/tests/functional/a/await_outside_async.py
new file mode 100644
index 0000000..2bc1267
--- /dev/null
+++ b/tests/functional/a/await_outside_async.py
@@ -0,0 +1,30 @@
+# pylint: disable=missing-docstring,unused-variable
+import asyncio
+
+async def nested():
+ return 42
+
+async def main():
+ nested()
+ print(await nested()) # This is okay
+
+def not_async():
+ print(await nested()) # [await-outside-async]
+
+
+async def func(i):
+ return i**2
+
+async def okay_function():
+ var = [await func(i) for i in range(5)] # This should be okay
+
+
+# Test nested functions
+async def func2():
+ def inner_func():
+ await asyncio.sleep(1) # [await-outside-async]
+
+
+def outer_func():
+ async def inner_func():
+ await asyncio.sleep(1)
diff --git a/tests/functional/a/await_outside_async.rc b/tests/functional/a/await_outside_async.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/a/await_outside_async.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/a/await_outside_async.txt b/tests/functional/a/await_outside_async.txt
new file mode 100644
index 0000000..e38a51c
--- /dev/null
+++ b/tests/functional/a/await_outside_async.txt
@@ -0,0 +1,2 @@
+await-outside-async:12:10:not_async:'await' should be used within an async function
+await-outside-async:25:8:func2.inner_func:'await' should be used within an async function
diff --git a/tests/functional/b/__init__.py b/tests/functional/b/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/b/__init__.py
diff --git a/tests/functional/b/bad_except_order.py b/tests/functional/b/bad_except_order.py
new file mode 100644
index 0000000..4f2fa3e
--- /dev/null
+++ b/tests/functional/b/bad_except_order.py
@@ -0,0 +1,45 @@
+# pylint: disable=missing-docstring, bare-except, broad-except
+
+__revision__ = 1
+
+try:
+ __revision__ += 1
+except Exception:
+ __revision__ = 0
+except TypeError: # [bad-except-order]
+ __revision__ = 0
+
+try:
+ __revision__ += 1
+except LookupError:
+ __revision__ = 0
+except IndexError: # [bad-except-order]
+ __revision__ = 0
+
+try:
+ __revision__ += 1
+except (LookupError, NameError):
+ __revision__ = 0
+except (IndexError, UnboundLocalError): # [bad-except-order, bad-except-order]
+ __revision__ = 0
+
+try: # [bad-except-order]
+ __revision__ += 1
+except:
+ pass
+except Exception:
+ pass
+
+try:
+ __revision__ += 1
+except TypeError:
+ __revision__ = 0
+except:
+ __revision__ = 0
+
+try:
+ __revision__ += 1
+except Exception:
+ pass
+except:
+ pass
diff --git a/tests/functional/b/bad_except_order.txt b/tests/functional/b/bad_except_order.txt
new file mode 100644
index 0000000..1181676
--- /dev/null
+++ b/tests/functional/b/bad_except_order.txt
@@ -0,0 +1,5 @@
+bad-except-order:9:7::Bad except clauses order (Exception is an ancestor class of TypeError)
+bad-except-order:16:7::Bad except clauses order (LookupError is an ancestor class of IndexError)
+bad-except-order:23:7::Bad except clauses order (LookupError is an ancestor class of IndexError)
+bad-except-order:23:7::Bad except clauses order (NameError is an ancestor class of UnboundLocalError)
+bad-except-order:26:0::Bad except clauses order (empty except clause should always appear last)
diff --git a/tests/functional/b/bad_exception_context.py b/tests/functional/b/bad_exception_context.py
new file mode 100644
index 0000000..af3e4fb
--- /dev/null
+++ b/tests/functional/b/bad_exception_context.py
@@ -0,0 +1,24 @@
+"""Check that raise ... from .. uses a proper exception context """
+
+# pylint: disable=unreachable, import-error, multiple-imports
+
+import socket, unknown
+
+__revision__ = 0
+
+class ExceptionSubclass(Exception):
+ """ subclass """
+
+def test():
+ """ docstring """
+ raise IndexError from 1 # [bad-exception-context]
+ raise IndexError from None
+ raise IndexError from ZeroDivisionError
+ raise IndexError from object() # [bad-exception-context]
+ raise IndexError from ExceptionSubclass
+ raise IndexError from socket.error
+ raise IndexError() from None
+ raise IndexError() from ZeroDivisionError
+ raise IndexError() from ZeroDivisionError()
+ raise IndexError() from object() # [bad-exception-context]
+ raise IndexError() from unknown
diff --git a/tests/functional/b/bad_exception_context.rc b/tests/functional/b/bad_exception_context.rc
new file mode 100644
index 0000000..c0490a6
--- /dev/null
+++ b/tests/functional/b/bad_exception_context.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/b/bad_exception_context.txt b/tests/functional/b/bad_exception_context.txt
new file mode 100644
index 0000000..11f9e40
--- /dev/null
+++ b/tests/functional/b/bad_exception_context.txt
@@ -0,0 +1,3 @@
+bad-exception-context:14:4:test:Exception context set to something which is not an exception, nor None
+bad-exception-context:17:4:test:Exception context set to something which is not an exception, nor None
+bad-exception-context:23:4:test:Exception context set to something which is not an exception, nor None
diff --git a/tests/functional/b/bad_indentation.py b/tests/functional/b/bad_indentation.py
new file mode 100644
index 0000000..4c50eae
--- /dev/null
+++ b/tests/functional/b/bad_indentation.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring, pointless-statement
+from __future__ import print_function
+
+
+def totoo():
+ print('malindented') # [bad-indentation]
+
+def tutuu():
+ print('good indentation')
+
+def titii():
+ 1 # and this. # [bad-indentation]
+
+def tataa(kdict):
+ for key in ['1', '2', '3']:
+ key = key.lower()
+
+ if key in kdict:
+ del kdict[key]
diff --git a/tests/functional/b/bad_indentation.txt b/tests/functional/b/bad_indentation.txt
new file mode 100644
index 0000000..3963624
--- /dev/null
+++ b/tests/functional/b/bad_indentation.txt
@@ -0,0 +1,2 @@
+bad-indentation:6:0::Bad indentation. Found 1 spaces, expected 4
+bad-indentation:12:0::Bad indentation. Found 5 spaces, expected 4
diff --git a/tests/functional/b/bad_inline_option.py b/tests/functional/b/bad_inline_option.py
new file mode 100644
index 0000000..ac6fc66
--- /dev/null
+++ b/tests/functional/b/bad_inline_option.py
@@ -0,0 +1,5 @@
+"""errors-only is not usable as an inline option"""
+# +1: [bad-inline-option]
+# pylint: disable missing-docstring
+
+CONST = "The assignment operator is missing inside the pylint inline option."
diff --git a/tests/functional/b/bad_inline_option.rc b/tests/functional/b/bad_inline_option.rc
new file mode 100644
index 0000000..b211d72
--- /dev/null
+++ b/tests/functional/b/bad_inline_option.rc
@@ -0,0 +1,2 @@
+[Messages Control]
+enable=I
diff --git a/tests/functional/b/bad_inline_option.txt b/tests/functional/b/bad_inline_option.txt
new file mode 100644
index 0000000..6a97bff
--- /dev/null
+++ b/tests/functional/b/bad_inline_option.txt
@@ -0,0 +1 @@
+bad-inline-option:3:0::Unable to consider inline option 'disable'
diff --git a/tests/functional/b/bad_open_mode_py3.py b/tests/functional/b/bad_open_mode_py3.py
new file mode 100644
index 0000000..27aa2e6
--- /dev/null
+++ b/tests/functional/b/bad_open_mode_py3.py
@@ -0,0 +1,24 @@
+"""Warnings for using open() with an invalid mode string."""
+# pylint: disable=consider-using-with
+
+NAME = "foo.bar"
+open(NAME, "wb")
+open(NAME, "w")
+open(NAME, "rb")
+open(NAME, "x")
+open(NAME, "br")
+open(NAME, "+r")
+open(NAME, "xb")
+open(NAME, "rwx") # [bad-open-mode]
+open(NAME, "rr") # [bad-open-mode]
+open(NAME, "+") # [bad-open-mode]
+open(NAME, "xw") # [bad-open-mode]
+open(NAME, "ab+")
+open(NAME, "a+b")
+open(NAME, "+ab")
+open(NAME, "+rUb")
+open(NAME, "x+b")
+open(NAME, "Ua") # [bad-open-mode]
+open(NAME, "Ur++") # [bad-open-mode]
+open(NAME, "Ut")
+open(NAME, "Ubr")
diff --git a/tests/functional/b/bad_open_mode_py3.rc b/tests/functional/b/bad_open_mode_py3.rc
new file mode 100644
index 0000000..5bed69f
--- /dev/null
+++ b/tests/functional/b/bad_open_mode_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.0
+except_implementations=PyPy
diff --git a/tests/functional/b/bad_open_mode_py3.txt b/tests/functional/b/bad_open_mode_py3.txt
new file mode 100644
index 0000000..1ea2325
--- /dev/null
+++ b/tests/functional/b/bad_open_mode_py3.txt
@@ -0,0 +1,6 @@
+bad-open-mode:12:0::"""rwx"" is not a valid mode for open."
+bad-open-mode:13:0::"""rr"" is not a valid mode for open."
+bad-open-mode:14:0::"""+"" is not a valid mode for open."
+bad-open-mode:15:0::"""xw"" is not a valid mode for open."
+bad-open-mode:21:0::"""Ua"" is not a valid mode for open."
+bad-open-mode:22:0::"""Ur++"" is not a valid mode for open."
diff --git a/tests/functional/b/bad_option_value.py b/tests/functional/b/bad_option_value.py
new file mode 100644
index 0000000..073e828
--- /dev/null
+++ b/tests/functional/b/bad_option_value.py
@@ -0,0 +1,4 @@
+# pylint:enable=W04044 # [bad-option-value]
+"""check unknown option
+"""
+__revision__ = 1
diff --git a/tests/functional/b/bad_option_value.txt b/tests/functional/b/bad_option_value.txt
new file mode 100644
index 0000000..48eb852
--- /dev/null
+++ b/tests/functional/b/bad_option_value.txt
@@ -0,0 +1 @@
+bad-option-value:1:0::Bad option value 'W04044'
diff --git a/tests/functional/b/bad_reversed_sequence.py b/tests/functional/b/bad_reversed_sequence.py
new file mode 100644
index 0000000..0d7b84d
--- /dev/null
+++ b/tests/functional/b/bad_reversed_sequence.py
@@ -0,0 +1,79 @@
+""" Checks that reversed() receive proper argument """
+# pylint: disable=missing-docstring, useless-object-inheritance
+# pylint: disable=too-few-public-methods,no-self-use,no-absolute-import
+from collections import deque, OrderedDict
+from enum import IntEnum
+
+
+class GoodReversed(object):
+ """ Implements __reversed__ """
+ def __reversed__(self):
+ return [1, 2, 3]
+
+class SecondGoodReversed(object):
+ """ Implements __len__ and __getitem__ """
+ def __len__(self):
+ return 3
+
+ def __getitem__(self, index):
+ return index
+
+class BadReversed(object):
+ """ implements only len() """
+ def __len__(self):
+ return 3
+
+class SecondBadReversed(object):
+ """ implements only __getitem__ """
+ def __getitem__(self, index):
+ return index
+
+class ThirdBadReversed(dict):
+ """ dict subclass """
+
+def uninferable(seq):
+ """ This can't be infered at this moment,
+ make sure we don't have a false positive.
+ """
+ return reversed(seq)
+
+def test(path):
+ """ test function """
+ seq = reversed() # No argument given
+ seq = reversed(None) # [bad-reversed-sequence]
+ seq = reversed([1, 2, 3])
+ seq = reversed((1, 2, 3))
+ seq = reversed(set()) # [bad-reversed-sequence]
+ seq = reversed(iter([1, 2, 3])) # [bad-reversed-sequence]
+ seq = reversed(GoodReversed())
+ seq = reversed(SecondGoodReversed())
+ seq = reversed(BadReversed()) # [bad-reversed-sequence]
+ seq = reversed(SecondBadReversed()) # [bad-reversed-sequence]
+ seq = reversed(range(100))
+ seq = reversed(ThirdBadReversed()) # [bad-reversed-sequence]
+ seq = reversed(lambda: None) # [bad-reversed-sequence]
+ seq = reversed(deque([]))
+ seq = reversed("123")
+ seq = uninferable([1, 2, 3])
+ seq = reversed(path.split("/"))
+ return seq
+
+def test_dict_ancestor_and_reversed():
+ """Don't emit for subclasses of dict, with __reversed__ implemented."""
+ class Child(dict):
+ def __reversed__(self):
+ return reversed(range(10))
+
+ seq = reversed(OrderedDict())
+ return reversed(Child()), seq
+
+
+def test_dont_emit_for_reversing_enums():
+ """Don't emit when reversing enum classes"""
+ class Color(IntEnum):
+ RED = 1
+ GREEN = 2
+ BLUE = 3
+
+ for color in reversed(Color):
+ yield color
diff --git a/tests/functional/b/bad_reversed_sequence.txt b/tests/functional/b/bad_reversed_sequence.txt
new file mode 100644
index 0000000..051bd11
--- /dev/null
+++ b/tests/functional/b/bad_reversed_sequence.txt
@@ -0,0 +1,7 @@
+bad-reversed-sequence:43:10:test:The first reversed() argument is not a sequence
+bad-reversed-sequence:46:10:test:The first reversed() argument is not a sequence
+bad-reversed-sequence:47:10:test:The first reversed() argument is not a sequence
+bad-reversed-sequence:50:10:test:The first reversed() argument is not a sequence
+bad-reversed-sequence:51:10:test:The first reversed() argument is not a sequence
+bad-reversed-sequence:53:10:test:The first reversed() argument is not a sequence
+bad-reversed-sequence:54:10:test:The first reversed() argument is not a sequence
diff --git a/tests/functional/b/bad_reversed_sequence_py37.py b/tests/functional/b/bad_reversed_sequence_py37.py
new file mode 100644
index 0000000..a28c84c
--- /dev/null
+++ b/tests/functional/b/bad_reversed_sequence_py37.py
@@ -0,0 +1,2 @@
+""" Dictionaries are reversible starting on python 3.8"""
+reversed({'a': 1, 'b': 2}) # [bad-reversed-sequence]
diff --git a/tests/functional/b/bad_reversed_sequence_py37.rc b/tests/functional/b/bad_reversed_sequence_py37.rc
new file mode 100644
index 0000000..67a28a3
--- /dev/null
+++ b/tests/functional/b/bad_reversed_sequence_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.8
diff --git a/tests/functional/b/bad_reversed_sequence_py37.txt b/tests/functional/b/bad_reversed_sequence_py37.txt
new file mode 100644
index 0000000..1e1b939
--- /dev/null
+++ b/tests/functional/b/bad_reversed_sequence_py37.txt
@@ -0,0 +1 @@
+bad-reversed-sequence:2:::The first reversed() argument is not a sequence
diff --git a/tests/functional/b/bad_reversed_sequence_py38.py b/tests/functional/b/bad_reversed_sequence_py38.py
new file mode 100644
index 0000000..bbfdd97
--- /dev/null
+++ b/tests/functional/b/bad_reversed_sequence_py38.py
@@ -0,0 +1,2 @@
+""" Dictionaries are reversible starting on python 3.8"""
+reversed({'a': 1, 'b': 2})
diff --git a/tests/functional/b/bad_reversed_sequence_py38.rc b/tests/functional/b/bad_reversed_sequence_py38.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/b/bad_reversed_sequence_py38.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/b/bad_staticmethod_argument.py b/tests/functional/b/bad_staticmethod_argument.py
new file mode 100644
index 0000000..e73bf3d
--- /dev/null
+++ b/tests/functional/b/bad_staticmethod_argument.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring, no-staticmethod-decorator, useless-object-inheritance
+
+class Abcd(object):
+
+ def method1(self): # [bad-staticmethod-argument]
+ pass
+
+ method1 = staticmethod(method1)
+
+ def method2(cls): # [bad-staticmethod-argument]
+ pass
+
+ method2 = staticmethod(method2)
+
+ def __init__(self):
+ pass
diff --git a/tests/functional/b/bad_staticmethod_argument.txt b/tests/functional/b/bad_staticmethod_argument.txt
new file mode 100644
index 0000000..c2e0c5b
--- /dev/null
+++ b/tests/functional/b/bad_staticmethod_argument.txt
@@ -0,0 +1,2 @@
+bad-staticmethod-argument:5:4:Abcd.method1:Static method with 'self' as first argument
+bad-staticmethod-argument:10:4:Abcd.method2:Static method with 'cls' as first argument
diff --git a/tests/functional/b/bad_thread_instantiation.py b/tests/functional/b/bad_thread_instantiation.py
new file mode 100644
index 0000000..e7e02ea
--- /dev/null
+++ b/tests/functional/b/bad_thread_instantiation.py
@@ -0,0 +1,8 @@
+# pylint: disable=missing-docstring
+import threading
+
+
+threading.Thread(lambda: None).run() # [bad-thread-instantiation]
+threading.Thread(None, lambda: None)
+threading.Thread(group=None, target=lambda: None).run()
+threading.Thread() # [bad-thread-instantiation]
diff --git a/tests/functional/b/bad_thread_instantiation.txt b/tests/functional/b/bad_thread_instantiation.txt
new file mode 100644
index 0000000..59f606a
--- /dev/null
+++ b/tests/functional/b/bad_thread_instantiation.txt
@@ -0,0 +1,2 @@
+bad-thread-instantiation:5:0::threading.Thread needs the target function
+bad-thread-instantiation:8:0::threading.Thread needs the target function
diff --git a/tests/functional/b/bare_except.py b/tests/functional/b/bare_except.py
new file mode 100644
index 0000000..47a2079
--- /dev/null
+++ b/tests/functional/b/bare_except.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring, import-error
+
+try:
+ 1 + "2"
+except: # [bare-except]
+ pass
diff --git a/tests/functional/b/bare_except.txt b/tests/functional/b/bare_except.txt
new file mode 100644
index 0000000..514ffe1
--- /dev/null
+++ b/tests/functional/b/bare_except.txt
@@ -0,0 +1 @@
+bare-except:5:0::No exception type(s) specified
diff --git a/tests/functional/b/base_init_vars.py b/tests/functional/b/base_init_vars.py
new file mode 100644
index 0000000..08e2828
--- /dev/null
+++ b/tests/functional/b/base_init_vars.py
@@ -0,0 +1,35 @@
+# pylint:disable=no-self-use, print-statement
+# pylint:disable=too-few-public-methods, useless-object-inheritance
+"""Checks that class variables are seen as inherited !"""
+__revision__ = ''
+
+class BaseClass(object):
+ """A simple base class
+ """
+
+ def __init__(self):
+ self.base_var = {}
+
+ def met(self):
+ """yo"""
+ def meeting(self, with_):
+ """ye"""
+ return with_
+class MyClass(BaseClass):
+ """Inherits from BaseClass
+ """
+
+ def __init__(self):
+ BaseClass.__init__(self)
+ self.var = {}
+
+ def met(self):
+ """Checks that base_var is not seen as defined outsite '__init__'
+ """
+ self.var[1] = 'one'
+ self.base_var[1] = 'one'
+ return self.base_var, self.var
+
+if __name__ == '__main__':
+ OBJ = MyClass()
+ OBJ.met()
diff --git a/tests/functional/b/blacklisted_name.py b/tests/functional/b/blacklisted_name.py
new file mode 100644
index 0000000..84067e3
--- /dev/null
+++ b/tests/functional/b/blacklisted_name.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring
+
+def baz(): # [disallowed-name]
+ pass
diff --git a/tests/functional/b/blacklisted_name.txt b/tests/functional/b/blacklisted_name.txt
new file mode 100644
index 0000000..747d71a
--- /dev/null
+++ b/tests/functional/b/blacklisted_name.txt
@@ -0,0 +1 @@
+disallowed-name:3:0:baz:Disallowed name "baz"
diff --git a/tests/functional/b/broad_except.py b/tests/functional/b/broad_except.py
new file mode 100644
index 0000000..24c8399
--- /dev/null
+++ b/tests/functional/b/broad_except.py
@@ -0,0 +1,14 @@
+# pylint: disable=missing-docstring
+from __future__ import print_function
+__revision__ = 0
+
+try:
+ __revision__ += 1
+except Exception: # [broad-except]
+ print('error')
+
+
+try:
+ __revision__ += 1
+except BaseException: # [broad-except]
+ print('error')
diff --git a/tests/functional/b/broad_except.txt b/tests/functional/b/broad_except.txt
new file mode 100644
index 0000000..388457b
--- /dev/null
+++ b/tests/functional/b/broad_except.txt
@@ -0,0 +1,2 @@
+broad-except:7:7::Catching too general exception Exception
+broad-except:13:7::Catching too general exception BaseException
diff --git a/tests/functional/b/bugfix_local_scope_metaclass_1177.py b/tests/functional/b/bugfix_local_scope_metaclass_1177.py
new file mode 100644
index 0000000..22c07a3
--- /dev/null
+++ b/tests/functional/b/bugfix_local_scope_metaclass_1177.py
@@ -0,0 +1,54 @@
+# pylint: disable=missing-docstring,too-few-public-methods,import-error
+from UNINFERABLE import ImportedMetaclass, ImportedMetaclass2
+
+
+class Meta(type):
+ pass
+
+
+class Class(metaclass=Meta):
+ pass
+
+
+def func_scope():
+ class Meta2(type):
+ pass
+
+ class Class2(metaclass=Meta2):
+ pass
+
+ return Class2
+
+
+class ClassScope:
+ class Meta3(type):
+ pass
+
+ class Class3(metaclass=Meta3):
+ pass
+
+ instance = Class3()
+
+
+def mixed_scopes():
+ class ClassM(metaclass=Meta):
+ pass
+
+ return ClassM
+
+
+def imported_and_nested_scope1():
+ class ClassImp1(metaclass=ImportedMetaclass):
+ pass
+
+ class ClassImp2(metaclass=ImportedMetaclass):
+ pass
+
+ return ClassImp1, ClassImp2
+
+
+def imported_and_nested_scope2():
+ class ClassImp3(metaclass=ImportedMetaclass2):
+ pass
+
+ return ClassImp3
diff --git a/tests/functional/b/bugfix_local_scope_metaclass_1177.rc b/tests/functional/b/bugfix_local_scope_metaclass_1177.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/b/bugfix_local_scope_metaclass_1177.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/b/builtin_module_test.py b/tests/functional/b/builtin_module_test.py
new file mode 100644
index 0000000..9b1e7ce
--- /dev/null
+++ b/tests/functional/b/builtin_module_test.py
@@ -0,0 +1,11 @@
+"""test import from a builtin module"""
+
+from __future__ import absolute_import
+from math import log10
+
+__revision__ = None
+
+
+def log10_2():
+ """bla bla bla"""
+ return log10(2)
diff --git a/tests/functional/c/__init__.py b/tests/functional/c/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/c/__init__.py
diff --git a/tests/functional/c/cached_property.py b/tests/functional/c/cached_property.py
new file mode 100644
index 0000000..880015e
--- /dev/null
+++ b/tests/functional/c/cached_property.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,invalid-name,no-self-use
+from functools import cached_property
+
+
+# https://github.com/PyCQA/pylint/issues/4023
+# False-positive 'invalid-overridden-method' with 'cached_property'
+class Parent:
+ @property
+ def value(self):
+ return 42
+
+ def func(self):
+ return False
+
+
+class Child(Parent):
+ @cached_property
+ def value(self):
+ return 2**6
+
+ @cached_property
+ def func(self): # [invalid-overridden-method]
+ return 42
diff --git a/tests/functional/c/cached_property.rc b/tests/functional/c/cached_property.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/c/cached_property.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/c/cached_property.txt b/tests/functional/c/cached_property.txt
new file mode 100644
index 0000000..6c3a6d1
--- /dev/null
+++ b/tests/functional/c/cached_property.txt
@@ -0,0 +1 @@
+invalid-overridden-method:22:4:Child.func:Method 'func' was expected to be 'method', found it instead as 'property'
diff --git a/tests/functional/c/cellvar_escaping_loop.py b/tests/functional/c/cellvar_escaping_loop.py
new file mode 100644
index 0000000..48d2291
--- /dev/null
+++ b/tests/functional/c/cellvar_escaping_loop.py
@@ -0,0 +1,131 @@
+# pylint: disable=print-statement, unnecessary-comprehension,missing-docstring,too-few-public-methods
+"""Tests for loopvar-in-closure."""
+from __future__ import print_function
+
+from enum import Enum
+
+
+def good_case():
+ """No problems here."""
+ lst = []
+ for i in range(10):
+ lst.append(i)
+
+
+def good_case2():
+ """No problems here."""
+ return [i for i in range(10)]
+
+
+def good_case3():
+ """No problems here."""
+ lst = []
+ for i in range(10):
+ lst.append(lambda i=i: i)
+
+
+def good_case4():
+ """No problems here."""
+ lst = []
+ for i in range(10):
+ print(i)
+ lst.append(lambda i: i)
+
+
+def good_case5():
+ """No problems here."""
+ return (i for i in range(10))
+
+
+def good_case6():
+ """Accept use of the variable inside return."""
+ for i in range(10):
+ if i == 8:
+ return lambda: i
+ return lambda: -1
+
+
+def good_case7():
+ """Lambda defined and called in loop."""
+ for i in range(10):
+ print((lambda x: i + x)(1))
+
+
+def good_case8():
+ """Another eager binding of the cell variable."""
+ funs = []
+ for i in range(10):
+ def func(bound_i=i):
+ """Ignore."""
+ return bound_i
+ funs.append(func)
+ return funs
+
+
+def bad_case():
+ """Closing over a loop variable."""
+ lst = []
+ for i in range(10):
+ print(i)
+ lst.append(lambda: i) # [cell-var-from-loop]
+
+
+def bad_case2():
+ """Closing over a loop variable."""
+ return [lambda: i for i in range(10)] # [cell-var-from-loop]
+
+
+def bad_case3():
+ """Closing over variable defined in loop."""
+ lst = []
+ for i in range(10):
+ j = i * i
+ lst.append(lambda: j) # [cell-var-from-loop]
+ return lst
+
+
+def bad_case4():
+ """Closing over variable defined in loop."""
+ lst = []
+ for i in range(10):
+ def nested():
+ """Nested function."""
+ return i**2 # [cell-var-from-loop]
+ lst.append(nested)
+ return lst
+
+
+def bad_case5():
+ """Problematic case.
+
+ If this function is used as
+
+ >>> [x() for x in bad_case5()]
+
+ it behaves 'as expected', i.e. the result is range(10).
+
+ If it's used with
+
+ >>> lst = list(bad_case5())
+ >>> [x() for x in lst]
+
+ the result is [9] * 10 again.
+ """
+ return (lambda: i for i in range(10)) # [cell-var-from-loop]
+
+
+def bad_case6():
+ """Closing over variable defined in loop."""
+ lst = []
+ for i, j in zip(range(10), range(10, 20)):
+ print(j)
+ lst.append(lambda: i) # [cell-var-from-loop]
+ return lst
+
+
+class Test(Enum):
+ TEST = (40, 160)
+
+ @staticmethod
+ def new_test(minimum=TEST[0], maximum=TEST[1]):
+ return minimum, maximum
diff --git a/tests/functional/c/cellvar_escaping_loop.txt b/tests/functional/c/cellvar_escaping_loop.txt
new file mode 100644
index 0000000..49e8cb5
--- /dev/null
+++ b/tests/functional/c/cellvar_escaping_loop.txt
@@ -0,0 +1,6 @@
+cell-var-from-loop:70:27:bad_case.<lambda>:Cell variable i defined in loop
+cell-var-from-loop:75:20:bad_case2.<lambda>:Cell variable i defined in loop
+cell-var-from-loop:83:27:bad_case3.<lambda>:Cell variable j defined in loop
+cell-var-from-loop:93:19:bad_case4.nested:Cell variable i defined in loop
+cell-var-from-loop:114:20:bad_case5.<lambda>:Cell variable i defined in loop
+cell-var-from-loop:122:27:bad_case6.<lambda>:Cell variable i defined in loop
diff --git a/tests/functional/c/class_attributes.py b/tests/functional/c/class_attributes.py
new file mode 100644
index 0000000..b6fd460
--- /dev/null
+++ b/tests/functional/c/class_attributes.py
@@ -0,0 +1,18 @@
+"""Test that valid class attribute doesn't trigger errors"""
+__revision__ = 'sponge bob'
+# pylint: disable=useless-object-inheritance
+
+class Clazz(object):
+ "dummy class"
+
+ def __init__(self):
+ self.topic = 5
+ self._data = 45
+
+ def change_type(self, new_class):
+ """Change type"""
+ self.__class__ = new_class
+
+ def do_nothing(self):
+ "I do nothing useful"
+ return self.topic + 56
diff --git a/tests/functional/c/class_members_py30.py b/tests/functional/c/class_members_py30.py
new file mode 100644
index 0000000..cb7267c
--- /dev/null
+++ b/tests/functional/c/class_members_py30.py
@@ -0,0 +1,68 @@
+""" Various tests for class members access. """
+# pylint: disable=too-few-public-methods,import-error,no-init,missing-docstring, wrong-import-position,wrong-import-order, useless-object-inheritance
+from missing import Missing
+class MyClass(object):
+ """class docstring"""
+
+ def __init__(self):
+ """init"""
+ self.correct = 1
+
+ def test(self):
+ """test"""
+ self.correct += 2
+ self.incorrect += 2 # [no-member]
+ del self.havenot # [no-member]
+ self.nonexistent1.truc() # [no-member]
+ self.nonexistent2[1] = 'hehe' # [no-member]
+
+class XYZMixin(object):
+ """access to undefined members should be ignored in mixin classes by
+ default
+ """
+ def __init__(self):
+ print(self.nonexistent)
+
+
+class NewClass(object):
+ """use object.__setattr__"""
+ def __init__(self):
+ self.__setattr__('toto', 'tutu')
+
+from abc import ABCMeta
+
+class TestMetaclass(object, metaclass=ABCMeta):
+ """ Test attribute access for metaclasses. """
+
+class Metaclass(type):
+ """ metaclass """
+ @classmethod
+ def test(cls):
+ """ classmethod """
+
+class UsingMetaclass(object, metaclass=Metaclass):
+ """ empty """
+
+TestMetaclass.register(int)
+UsingMetaclass.test()
+TestMetaclass().register(int) # [no-member]
+UsingMetaclass().test() # [no-member]
+
+
+class NoKnownBases(Missing):
+ """Don't emit no-member if we don't know the bases of a class."""
+
+NoKnownBases().lalala()
+
+
+class MetaClass(object):
+ """Look some methods in the implicit metaclass."""
+
+ @classmethod
+ def whatever(cls):
+ return cls.mro() + cls.missing() # [no-member]
+
+from collections import namedtuple
+
+Tuple = namedtuple("Tuple", "field other")
+Tuple.field.__doc__ = "A doc for the field."
diff --git a/tests/functional/c/class_members_py30.rc b/tests/functional/c/class_members_py30.rc
new file mode 100644
index 0000000..c0490a6
--- /dev/null
+++ b/tests/functional/c/class_members_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/c/class_members_py30.txt b/tests/functional/c/class_members_py30.txt
new file mode 100644
index 0000000..c0fab25
--- /dev/null
+++ b/tests/functional/c/class_members_py30.txt
@@ -0,0 +1,7 @@
+no-member:14:8:MyClass.test:Instance of 'MyClass' has no 'incorrect' member:INFERENCE
+no-member:15:12:MyClass.test:Instance of 'MyClass' has no 'havenot' member:INFERENCE
+no-member:16:8:MyClass.test:Instance of 'MyClass' has no 'nonexistent1' member:INFERENCE
+no-member:17:8:MyClass.test:Instance of 'MyClass' has no 'nonexistent2' member:INFERENCE
+no-member:48:0::Instance of 'TestMetaclass' has no 'register' member:INFERENCE
+no-member:49:0::Instance of 'UsingMetaclass' has no 'test' member:INFERENCE
+no-member:63:27:MetaClass.whatever:Class 'MetaClass' has no 'missing' member:INFERENCE
diff --git a/tests/functional/c/class_members_py36.py b/tests/functional/c/class_members_py36.py
new file mode 100644
index 0000000..e43ab57
--- /dev/null
+++ b/tests/functional/c/class_members_py36.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+
+
+class Class:
+ attr: int
+ ...
+
+
+# `bar` definitely does not exist here, but in a complex scenario,
+# it might. We simply exclude PEP 526 class and instance variables
+# from `no-member`.
+print(Class().attr)
+print(Class.attr)
diff --git a/tests/functional/c/class_members_py36.rc b/tests/functional/c/class_members_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/c/class_members_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/c/class_scope.py b/tests/functional/c/class_scope.py
new file mode 100644
index 0000000..a22ba72
--- /dev/null
+++ b/tests/functional/c/class_scope.py
@@ -0,0 +1,43 @@
+# pylint: disable=too-few-public-methods,no-init, useless-object-inheritance
+"""check for scope problems"""
+
+__revision__ = None
+
+class Well(object):
+ """well"""
+ attr = 42
+ get_attr = lambda arg=attr: arg * 24
+ # +1: [undefined-variable, used-before-assignment]
+ get_attr_bad = lambda arg=revattr: revattr * 42
+ revattr = 24
+ bad_lambda = lambda: get_attr_bad # [undefined-variable]
+ bad_gen = list(attr + i for i in range(10)) # [undefined-variable]
+
+ class Data(object):
+ """base hidden class"""
+ class Sub(Data):
+ """whaou, is Data found???"""
+ attr = Data() # [undefined-variable]
+ def func(self):
+ """check Sub is not defined here"""
+ return Sub(), self # [undefined-variable]
+
+
+class Right:
+ """right"""
+ class Result1:
+ """result one"""
+ OK = 0
+ def work(self) -> Result1:
+ """good type hint"""
+ return self.Result1.OK
+
+
+class Wrong:
+ """wrong"""
+ class Result2:
+ """result two"""
+ OK = 0
+ def work(self) -> self.Result2: # [undefined-variable]
+ """bad type hint"""
+ return self.Result2.OK
diff --git a/tests/functional/c/class_scope.txt b/tests/functional/c/class_scope.txt
new file mode 100644
index 0000000..a45d232
--- /dev/null
+++ b/tests/functional/c/class_scope.txt
@@ -0,0 +1,7 @@
+undefined-variable:11:39:Well.<lambda>:Undefined variable 'revattr'
+used-before-assignment:11:30:Well.<lambda>:Using variable 'revattr' before assignment
+undefined-variable:13:25:Well.<lambda>:Undefined variable 'get_attr_bad'
+undefined-variable:14:19:Well:Undefined variable 'attr'
+undefined-variable:20:15:Well.Sub:Undefined variable 'Data'
+undefined-variable:23:15:Well.func:Undefined variable 'Sub'
+undefined-variable:41:22:Wrong.work:Undefined variable 'self'
diff --git a/tests/functional/c/class_variable_slots_conflict_exempted.py b/tests/functional/c/class_variable_slots_conflict_exempted.py
new file mode 100644
index 0000000..b6a0edf
--- /dev/null
+++ b/tests/functional/c/class_variable_slots_conflict_exempted.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+class Example:
+ __slots__ = ["field"]
+ field: int
diff --git a/tests/functional/c/class_variable_slots_conflict_exempted.rc b/tests/functional/c/class_variable_slots_conflict_exempted.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/c/class_variable_slots_conflict_exempted.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/c/classes_meth_could_be_a_function.py b/tests/functional/c/classes_meth_could_be_a_function.py
new file mode 100644
index 0000000..94103a3
--- /dev/null
+++ b/tests/functional/c/classes_meth_could_be_a_function.py
@@ -0,0 +1,33 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-init,useless-object-inheritance
+"""
+#2479
+
+R0201 (formely W0212), Method could be a function shouldn't be emitted in case
+like factory method pattern
+"""
+__revision__ = 1
+
+class XAsub(object):
+ pass
+class XBsub(XAsub):
+ pass
+class XCsub(XAsub):
+ pass
+
+class Aimpl(object):
+ # disable "method could be a function" on classes which are not overriding
+ # the factory method because in that case the usage of polymorphism is not
+ # detected
+ # pylint: disable=no-self-use
+ def makex(self):
+ return XAsub()
+
+class Bimpl(Aimpl):
+
+ def makex(self):
+ return XBsub()
+
+class Cimpl(Aimpl):
+
+ def makex(self):
+ return XCsub()
diff --git a/tests/functional/c/classes_protected_member_access.py b/tests/functional/c/classes_protected_member_access.py
new file mode 100644
index 0000000..516efd7
--- /dev/null
+++ b/tests/functional/c/classes_protected_member_access.py
@@ -0,0 +1,26 @@
+"""
+#3123: W0212 false positive on static method
+"""
+__revision__ = 1
+
+# pylint: disable=no-classmethod-decorator, no-staticmethod-decorator, useless-object-inheritance
+class A3123(object):
+ """oypuee"""
+ _protected = 1
+ def __init__(self):
+ pass
+
+
+ def cmeth(cls, val):
+ """set protected member"""
+ cls._protected = +val
+
+ cmeth = classmethod(cmeth)
+
+ def smeth(val):
+ """set protected member"""
+ A3123._protected += val
+
+ smeth = staticmethod(smeth)
+
+ prop = property(lambda self: self._protected)
diff --git a/tests/functional/c/comparison_with_callable.py b/tests/functional/c/comparison_with_callable.py
new file mode 100644
index 0000000..b676844
--- /dev/null
+++ b/tests/functional/c/comparison_with_callable.py
@@ -0,0 +1,60 @@
+# pylint: disable = disallowed-name, missing-docstring, useless-return, misplaced-comparison-constant, invalid-name, no-self-use, line-too-long, useless-object-inheritance
+def foo():
+ return None
+
+def goo():
+ return None
+
+if foo == 786: # [comparison-with-callable]
+ pass
+
+if 666 == goo: # [comparison-with-callable]
+ pass
+
+if foo == goo:
+ pass
+
+if foo() == goo():
+ pass
+
+
+class FakeClass(object):
+ def __init__(self):
+ self._fake_prop = 'fake it till you make it!!'
+
+ def fake_method(self):
+ return '666 - The Number of the Beast'
+
+ @property
+ def fake_property(self):
+ return self._fake_prop
+
+ @fake_property.setter
+ def fake_property(self, prop):
+ self._fake_prop = prop
+
+obj1 = FakeClass()
+obj2 = FakeClass()
+
+if obj1.fake_method == obj2.fake_method:
+ pass
+
+if obj1.fake_property != obj2.fake_property: # property although is function but is called without parenthesis
+ pass
+
+if obj1.fake_method != foo:
+ pass
+
+if obj1.fake_method != 786: # [comparison-with-callable]
+ pass
+
+if obj1.fake_method != obj2.fake_property: # [comparison-with-callable]
+ pass
+
+if 666 == 786:
+ pass
+
+a = 666
+b = 786
+if a == b:
+ pass
diff --git a/tests/functional/c/comparison_with_callable.txt b/tests/functional/c/comparison_with_callable.txt
new file mode 100644
index 0000000..a87f0b5
--- /dev/null
+++ b/tests/functional/c/comparison_with_callable.txt
@@ -0,0 +1,4 @@
+comparison-with-callable:8:3::Comparing against a callable, did you omit the parenthesis?
+comparison-with-callable:11:3::Comparing against a callable, did you omit the parenthesis?
+comparison-with-callable:48:3::Comparing against a callable, did you omit the parenthesis?
+comparison-with-callable:51:3::Comparing against a callable, did you omit the parenthesis?
diff --git a/tests/functional/c/condition_evals_to_constant.py b/tests/functional/c/condition_evals_to_constant.py
new file mode 100644
index 0000000..cfd0b00
--- /dev/null
+++ b/tests/functional/c/condition_evals_to_constant.py
@@ -0,0 +1,46 @@
+"""Test that boolean conditions simplify to a constant value"""
+# pylint: disable=pointless-statement
+from unknown import Unknown # pylint: disable=import-error
+
+
+def func(_):
+ """Pointless function"""
+
+
+CONSTANT = 100
+OTHER = 200
+
+# Simplifies any boolean expression that is coerced into a True/False value
+bool(CONSTANT or True) # [condition-evals-to-constant]
+assert CONSTANT or True # [condition-evals-to-constant]
+if CONSTANT and False: # [condition-evals-to-constant]
+ pass
+elif CONSTANT and False: # [condition-evals-to-constant]
+ pass
+while CONSTANT and False: # [condition-evals-to-constant]
+ break
+1 if CONSTANT or True else 2 # [condition-evals-to-constant]
+z = [x for x in range(10) if x or True] # [condition-evals-to-constant]
+
+# Simplifies recursively
+assert True or CONSTANT or OTHER # [condition-evals-to-constant]
+assert (CONSTANT or True) or (CONSTANT or True) # [condition-evals-to-constant]
+
+# Will try to infer the truthiness of an expression as long as it doesn't contain any variables
+assert 3 + 4 or CONSTANT # [condition-evals-to-constant]
+assert Unknown or True # [condition-evals-to-constant]
+
+assert True or True # [condition-evals-to-constant]
+assert False or False # [condition-evals-to-constant]
+assert True and True # [condition-evals-to-constant]
+assert False and False # [condition-evals-to-constant]
+
+
+# A bare constant that's not inside of a boolean operation will emit `using-constant-test` instead
+if True: # pylint: disable=using-constant-test
+ pass
+
+# Expressions not in one of the above situations will not emit a message
+CONSTANT or True
+bool(CONSTANT or OTHER)
+bool(func(CONSTANT or True))
diff --git a/tests/functional/c/condition_evals_to_constant.txt b/tests/functional/c/condition_evals_to_constant.txt
new file mode 100644
index 0000000..04d8deb
--- /dev/null
+++ b/tests/functional/c/condition_evals_to_constant.txt
@@ -0,0 +1,15 @@
+condition-evals-to-constant:14:5::Boolean condition 'CONSTANT or True' will always evaluate to 'True'
+condition-evals-to-constant:15:7::Boolean condition 'CONSTANT or True' will always evaluate to 'True'
+condition-evals-to-constant:16:3::Boolean condition 'CONSTANT and False' will always evaluate to 'False'
+condition-evals-to-constant:18:5::Boolean condition 'CONSTANT and False' will always evaluate to 'False'
+condition-evals-to-constant:20:6::Boolean condition 'CONSTANT and False' will always evaluate to 'False'
+condition-evals-to-constant:22:5::Boolean condition 'CONSTANT or True' will always evaluate to 'True'
+condition-evals-to-constant:23:29::Boolean condition 'x or True' will always evaluate to 'True'
+condition-evals-to-constant:26:7::Boolean condition 'True or CONSTANT or OTHER' will always evaluate to 'True'
+condition-evals-to-constant:27:7::Boolean condition 'CONSTANT or True or CONSTANT or True' will always evaluate to 'True'
+condition-evals-to-constant:30:7::Boolean condition '3 + 4 or CONSTANT' will always evaluate to '3 + 4'
+condition-evals-to-constant:31:7::Boolean condition 'Unknown or True' will always evaluate to 'True'
+condition-evals-to-constant:33:7::Boolean condition 'True or True' will always evaluate to 'True'
+condition-evals-to-constant:34:7::Boolean condition 'False or False' will always evaluate to 'False'
+condition-evals-to-constant:35:7::Boolean condition 'True and True' will always evaluate to 'True'
+condition-evals-to-constant:36:7::Boolean condition 'False and False' will always evaluate to 'False'
diff --git a/tests/functional/c/confidence_filter.py b/tests/functional/c/confidence_filter.py
new file mode 100644
index 0000000..4235199
--- /dev/null
+++ b/tests/functional/c/confidence_filter.py
@@ -0,0 +1,16 @@
+"""Test for the confidence filter."""
+from __future__ import print_function
+# pylint: disable=useless-object-inheritance
+
+class Client(object):
+ """use provider class"""
+
+ def __init__(self):
+ self.set_later = 0
+
+ def set_set_later(self, value):
+ """set set_later attribute (introduce an inference ambiguity)"""
+ self.set_later = value
+
+print(Client().set_later.lower())
+print(Client().foo) # [no-member]
diff --git a/tests/functional/c/confidence_filter.rc b/tests/functional/c/confidence_filter.rc
new file mode 100644
index 0000000..74953b6
--- /dev/null
+++ b/tests/functional/c/confidence_filter.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=no-init,too-few-public-methods,undefined-variable,print-statement
+confidence=INFERENCE,HIGH,UNDEFINED
diff --git a/tests/functional/c/confidence_filter.txt b/tests/functional/c/confidence_filter.txt
new file mode 100644
index 0000000..1c2cd83
--- /dev/null
+++ b/tests/functional/c/confidence_filter.txt
@@ -0,0 +1 @@
+no-member:16:6::Instance of 'Client' has no 'foo' member:INFERENCE
diff --git a/tests/functional/c/confusing_with_statement.py b/tests/functional/c/confusing_with_statement.py
new file mode 100644
index 0000000..7b8d494
--- /dev/null
+++ b/tests/functional/c/confusing_with_statement.py
@@ -0,0 +1,27 @@
+# pylint: disable=undefined-variable,not-context-manager,missing-docstring
+
+# both context managers are named
+with one as first, two as second:
+ pass
+
+# first matched as tuple; this is ok
+with one as (first, second), third:
+ pass
+
+# the first context manager doesn't have as name
+with one, two as second:
+ pass
+
+# the second is a function call; this is ok
+with one as first, two():
+ pass
+
+# nested with statements; make sure no message is emitted
+# this could be a false positive on Py2
+with one as first:
+ with two:
+ pass
+
+# ambiguous looking with statement
+with one as first, two: # [confusing-with-statement]
+ pass
diff --git a/tests/functional/c/confusing_with_statement.txt b/tests/functional/c/confusing_with_statement.txt
new file mode 100644
index 0000000..5ac2e7a
--- /dev/null
+++ b/tests/functional/c/confusing_with_statement.txt
@@ -0,0 +1 @@
+confusing-with-statement:26:0::"Following ""as"" with another context manager looks like a tuple."
diff --git a/tests/functional/c/consider/consider_iterating_dictionary.py b/tests/functional/c/consider/consider_iterating_dictionary.py
new file mode 100644
index 0000000..1198de1
--- /dev/null
+++ b/tests/functional/c/consider/consider_iterating_dictionary.py
@@ -0,0 +1,38 @@
+# pylint: disable=missing-docstring, expression-not-assigned, too-few-public-methods, no-member, import-error, no-self-use, line-too-long, useless-object-inheritance, unnecessary-comprehension
+
+from unknown import Unknown
+
+
+class CustomClass(object):
+ def keys(self):
+ return []
+
+for key in Unknown().keys():
+ pass
+for key in Unknown.keys():
+ pass
+for key in dict.keys():
+ pass
+for key in {}.values():
+ pass
+for key in {}.key():
+ pass
+for key in CustomClass().keys():
+ pass
+
+[key for key in {}.keys()] # [consider-iterating-dictionary]
+(key for key in {}.keys()) # [consider-iterating-dictionary]
+{key for key in {}.keys()} # [consider-iterating-dictionary]
+{key: key for key in {}.keys()} # [consider-iterating-dictionary]
+COMP1 = [key for key in {}.keys()] # [consider-iterating-dictionary]
+COMP2 = (key for key in {}.keys()) # [consider-iterating-dictionary]
+COMP3 = {key for key in {}.keys()} # [consider-iterating-dictionary]
+COMP4 = {key: key for key in {}.keys()} # [consider-iterating-dictionary]
+for key in {}.keys(): # [consider-iterating-dictionary]
+ pass
+
+# Issue #1247
+DICT = {'a': 1, 'b': 2}
+COMP1 = [k * 2 for k in DICT.keys()] + [k * 3 for k in DICT.keys()] # [consider-iterating-dictionary,consider-iterating-dictionary]
+COMP2, COMP3 = [k * 2 for k in DICT.keys()], [k * 3 for k in DICT.keys()] # [consider-iterating-dictionary,consider-iterating-dictionary]
+SOME_TUPLE = ([k * 2 for k in DICT.keys()], [k * 3 for k in DICT.keys()]) # [consider-iterating-dictionary,consider-iterating-dictionary]
diff --git a/tests/functional/c/consider/consider_iterating_dictionary.txt b/tests/functional/c/consider/consider_iterating_dictionary.txt
new file mode 100644
index 0000000..c1b12f9
--- /dev/null
+++ b/tests/functional/c/consider/consider_iterating_dictionary.txt
@@ -0,0 +1,15 @@
+consider-iterating-dictionary:23:16::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:24:16::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:25:16::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:26:21::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:27:24::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:28:24::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:29:24::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:30:29::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:31:11::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:36:24::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:36:55::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:37:31::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:37:61::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:38:30::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:38:60::Consider iterating the dictionary directly instead of calling .keys()
diff --git a/tests/functional/c/consider/consider_join.py b/tests/functional/c/consider/consider_join.py
new file mode 100644
index 0000000..24cd6dd
--- /dev/null
+++ b/tests/functional/c/consider/consider_join.py
@@ -0,0 +1,126 @@
+# pylint: disable=missing-docstring,invalid-name,undefined-variable,multiple-statements
+
+# Variations of 'result'
+result = ''
+for number in ['1', '2', '3']:
+ result += number # [consider-using-join]
+
+result = 'header'
+for number in ['1', '2', '3']:
+ result += number # [consider-using-join]
+
+result = another_result = ''
+for number in ['1', '2', '3']:
+ result += number # [consider-using-join]
+
+another_result = result = ''
+for number in ['1', '2', '3']:
+ result += number # [consider-using-join]
+
+result = 0 # result is not a string
+for number in ['1', '2', '3']:
+ result += number
+
+RESULT = '' # wrong name / initial variable missing
+for number in ['1', '2', '3']:
+ result += [number]
+
+string_variable = ''
+result = string_variable # type of 'result' not obviously a string
+for number in ['1', '2', '3']:
+ result += number
+
+result = ''
+another_result = '' # result defined too early
+for number in ['1', '2', '3']:
+ result += [number]
+
+for number in ['1', '2', '3']: # 'result'-definition missing
+ result += number
+
+
+# Variations of 'number'
+result = '' # no concatenation (iterator-name differs)
+for name in ['1', '2', '3']:
+ result += number
+
+result = '' # no concatenation (iterator-name differs)
+for _ in ['1', '2', '3']:
+ result += number
+# 'exprlist' is not a single name
+for index, number in ['1', '2', '3']:
+ result += number
+
+
+# Variations of 'iterable'
+result = ''
+for number in []:
+ result += number # [consider-using-join]
+
+result = ''
+for number in "a text":
+ result += number # [consider-using-join]
+
+result = ''
+for number in [1, 2, 3]:
+ result += number # [consider-using-join]
+
+a_list = [1, 2, 3]
+result = ''
+for number in a_list:
+ result += number # [consider-using-join]
+
+result = ''
+for number in ['1', '2', '3']:
+ result += number # [consider-using-join]
+
+result = ''
+for number in undefined_iterable:
+ result += number # [consider-using-join]
+
+
+# Variations of loop-body
+result = '' # addition is not the only part of the body
+for number in ['1', '2', '3']:
+ print(number)
+ result += number
+
+result = '' # addition is not the only part of the body
+for number in ['1', '2', '3']:
+ result += number
+ print(number)
+
+result = '' # augmented addition is not a simple one
+for number in ['1', '2', '3']:
+ result += '4' + number
+
+result = '' # assignment is not augmented
+for number in ['1', '2', '3']:
+ result = number
+
+result = '' # augmented assignment is not an addition
+for number in ['1', '2', '3']:
+ result -= number
+
+result = '' # addition is not the 'number'-iterable
+for number in ['1', '2', '3']:
+ result += another_number
+
+result = ''
+for number in ['1', '2', '3']: result += number # [consider-using-join]
+
+result = ''
+for number in ['1']:
+ result.result += number
+
+# Does not emit if the body is more complex
+result = {'context': 1}
+result['context'] = 0
+for number in ['1']:
+ result1 = 42 + int(number)
+ result['context'] += result1 * 24
+
+# Does not crash if the previous sibling does not have AssignNames
+result['context'] = 0
+for number in ['1']:
+ result['context'] += 24
diff --git a/tests/functional/c/consider/consider_join.txt b/tests/functional/c/consider/consider_join.txt
new file mode 100644
index 0000000..f544e55
--- /dev/null
+++ b/tests/functional/c/consider/consider_join.txt
@@ -0,0 +1,11 @@
+consider-using-join:6:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:10:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:14:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:18:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:58:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:62:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:66:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:71:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:75:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:79:4::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:110:31::Consider using str.join(sequence) for concatenating strings from an iterable
diff --git a/tests/functional/c/consider/consider_merging_isinstance.py b/tests/functional/c/consider/consider_merging_isinstance.py
new file mode 100644
index 0000000..d3387bd
--- /dev/null
+++ b/tests/functional/c/consider/consider_merging_isinstance.py
@@ -0,0 +1,37 @@
+"""Checks use of consider-merging-isinstance"""
+# pylint:disable=line-too-long, simplifiable-condition
+
+
+def isinstances():
+ "Examples of isinstances"
+ var = range(10)
+
+ # merged
+ if isinstance(var[1], (int, float)):
+ pass
+ result = isinstance(var[2], (int, float))
+
+ # not merged
+ if isinstance(var[3], int) or isinstance(var[3], float) or isinstance(var[3], list) and True: # [consider-merging-isinstance]
+ pass
+ result = isinstance(var[4], int) or isinstance(var[4], float) or isinstance(var[5], list) and False # [consider-merging-isinstance]
+
+ result = isinstance(var[5], int) or True or isinstance(var[5], float) # [consider-merging-isinstance]
+
+ infered_isinstance = isinstance
+ result = infered_isinstance(var[6], int) or infered_isinstance(var[6], float) or infered_isinstance(var[6], list) and False # [consider-merging-isinstance]
+ result = isinstance(var[10], str) or isinstance(var[10], int) and var[8] * 14 or isinstance(var[10], float) and var[5] * 14.4 or isinstance(var[10], list) # [consider-merging-isinstance]
+ result = isinstance(var[11], int) or isinstance(var[11], int) or isinstance(var[11], float) # [consider-merging-isinstance]
+
+ result = isinstance(var[20])
+ result = isinstance()
+
+ # Combination merged and not merged
+ result = isinstance(var[12], (int, float)) or isinstance(var[12], list) # [consider-merging-isinstance]
+
+ # not merged but valid
+ result = isinstance(var[5], int) and var[5] * 14 or isinstance(var[5], float) and var[5] * 14.4
+ result = isinstance(var[7], int) or not isinstance(var[7], float)
+ result = isinstance(var[6], int) or isinstance(var[7], float)
+ result = isinstance(var[6], int) or isinstance(var[7], int)
+ return result
diff --git a/tests/functional/c/consider/consider_merging_isinstance.txt b/tests/functional/c/consider/consider_merging_isinstance.txt
new file mode 100644
index 0000000..9728f1e
--- /dev/null
+++ b/tests/functional/c/consider/consider_merging_isinstance.txt
@@ -0,0 +1,7 @@
+consider-merging-isinstance:15:7:isinstances:Consider merging these isinstance calls to isinstance(var[3], (float, int))
+consider-merging-isinstance:17:13:isinstances:Consider merging these isinstance calls to isinstance(var[4], (float, int))
+consider-merging-isinstance:19:13:isinstances:Consider merging these isinstance calls to isinstance(var[5], (float, int))
+consider-merging-isinstance:22:13:isinstances:Consider merging these isinstance calls to isinstance(var[6], (float, int))
+consider-merging-isinstance:23:13:isinstances:Consider merging these isinstance calls to isinstance(var[10], (list, str))
+consider-merging-isinstance:24:13:isinstances:Consider merging these isinstance calls to isinstance(var[11], (float, int))
+consider-merging-isinstance:30:13:isinstances:Consider merging these isinstance calls to isinstance(var[12], (float, int, list))
diff --git a/tests/functional/c/consider/consider_swap_variables.py b/tests/functional/c/consider/consider_swap_variables.py
new file mode 100644
index 0000000..e332077
--- /dev/null
+++ b/tests/functional/c/consider/consider_swap_variables.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring,invalid-name,using-constant-test
+
+a, b, c, d = 'a b c d'.split()
+
+temp = a # [consider-swap-variables]
+a = b
+b = temp
+
+temp = a # only simple swaps are reported
+a = b
+if True:
+ b = a
+
+temp = a # this is no swap
+a = b
+b = a
+
+temp = a, b # complex swaps are ignored
+a, b = c, d
+c, d = temp
+
+temp = a # [consider-swap-variables]
+a = b # longer swap circles are only reported once
+b = temp
+temp = a
diff --git a/tests/functional/c/consider/consider_swap_variables.txt b/tests/functional/c/consider/consider_swap_variables.txt
new file mode 100644
index 0000000..3e099d6
--- /dev/null
+++ b/tests/functional/c/consider/consider_swap_variables.txt
@@ -0,0 +1,2 @@
+consider-swap-variables:5:0::Consider using tuple unpacking for swapping variables
+consider-swap-variables:22:0::Consider using tuple unpacking for swapping variables
diff --git a/tests/functional/c/consider/consider_using_dict_comprehension.py b/tests/functional/c/consider/consider_using_dict_comprehension.py
new file mode 100644
index 0000000..da0be6d
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_dict_comprehension.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring, invalid-name
+
+numbers = [1, 2, 3, 4, 5, 6]
+
+dict()
+
+dict([])
+
+dict([(number, number*2) for number in numbers]) # [consider-using-dict-comprehension]
+
+# Cannot emit as this cannot be written as a comprehension
+dict([value.split("=") for value in ["a=b", "c=d"]])
diff --git a/tests/functional/c/consider/consider_using_dict_comprehension.txt b/tests/functional/c/consider/consider_using_dict_comprehension.txt
new file mode 100644
index 0000000..ea2bb31
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_dict_comprehension.txt
@@ -0,0 +1 @@
+consider-using-dict-comprehension:9:0::Consider using a dictionary comprehension
diff --git a/tests/functional/c/consider/consider_using_dict_items.py b/tests/functional/c/consider/consider_using_dict_items.py
new file mode 100644
index 0000000..1d6c867
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_dict_items.py
@@ -0,0 +1,86 @@
+"""Emit a message for iteration through dict keys and subscripting dict with key."""
+# pylint: disable=line-too-long,missing-docstring,unsubscriptable-object,too-few-public-methods
+
+def bad():
+ a_dict = {1: 1, 2: 2, 3: 3}
+ for k in a_dict: # [consider-using-dict-items]
+ print(a_dict[k])
+ another_dict = dict()
+ for k in another_dict: # [consider-using-dict-items]
+ print(another_dict[k])
+
+
+def good():
+ a_dict = {1: 1, 2: 2, 3: 3}
+ for k in a_dict:
+ print(k)
+
+out_of_scope_dict = dict()
+
+def another_bad():
+ for k in out_of_scope_dict: # [consider-using-dict-items]
+ print(out_of_scope_dict[k])
+
+def another_good():
+ for k in out_of_scope_dict:
+ k = 1
+ k = 2
+ k = 3
+ print(out_of_scope_dict[k])
+
+
+b_dict = {}
+for k2 in b_dict: # Should not emit warning, key access necessary
+ b_dict[k2] = 2
+
+for k2 in b_dict: # Should not emit warning, key access necessary (AugAssign)
+ b_dict[k2] += 2
+
+# Warning should be emitted in this case
+for k6 in b_dict: # [consider-using-dict-items]
+ val = b_dict[k6]
+ b_dict[k6] = 2
+
+for k3 in b_dict: # [consider-using-dict-items]
+ val = b_dict[k3]
+
+for k4 in b_dict.keys(): # [consider-iterating-dictionary,consider-using-dict-items]
+ val = b_dict[k4]
+
+class Foo:
+ c_dict = {}
+
+# Should emit warning when iterating over a dict attribute of a class
+for k5 in Foo.c_dict: # [consider-using-dict-items]
+ val = Foo.c_dict[k5]
+
+c_dict = {}
+
+# Should NOT emit warning whey key used to access a different dict
+for k5 in Foo.c_dict: # This is fine
+ val = b_dict[k5]
+
+for k5 in Foo.c_dict: # This is fine
+ val = c_dict[k5]
+
+# Should emit warning within a list/dict comprehension
+val = {k9: b_dict[k9] for k9 in b_dict} # [consider-using-dict-items]
+val = [(k7, b_dict[k7]) for k7 in b_dict] # [consider-using-dict-items]
+
+# Should emit warning even when using dict attribute of a class within comprehension
+val = [(k7, Foo.c_dict[k7]) for k7 in Foo.c_dict] # [consider-using-dict-items]
+val = any(True for k8 in Foo.c_dict if Foo.c_dict[k8]) # [consider-using-dict-items]
+
+# Should emit warning when dict access done in ``if`` portion of comprehension
+val = any(True for k8 in b_dict if b_dict[k8]) # [consider-using-dict-items]
+
+# Should NOT emit warning whey key used to access a different dict
+val = [(k7, b_dict[k7]) for k7 in Foo.c_dict]
+val = any(True for k8 in Foo.c_dict if b_dict[k8])
+
+# Should NOT emit warning, essentially same check as above
+val = [(k7, c_dict[k7]) for k7 in Foo.c_dict]
+val = any(True for k8 in Foo.c_dict if c_dict[k8])
+
+# Should emit warning, using .keys() of Foo.c_dict
+val = any(True for k8 in Foo.c_dict.keys() if Foo.c_dict[k8]) # [consider-iterating-dictionary,consider-using-dict-items]
diff --git a/tests/functional/c/consider/consider_using_dict_items.txt b/tests/functional/c/consider/consider_using_dict_items.txt
new file mode 100644
index 0000000..8ead823
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_dict_items.txt
@@ -0,0 +1,15 @@
+consider-using-dict-items:6:4:bad:Consider iterating with .items()
+consider-using-dict-items:9:4:bad:Consider iterating with .items()
+consider-using-dict-items:21:4:another_bad:Consider iterating with .items()
+consider-using-dict-items:40:0::Consider iterating with .items()
+consider-using-dict-items:44:0::Consider iterating with .items()
+consider-iterating-dictionary:47:10::Consider iterating the dictionary directly instead of calling .keys()
+consider-using-dict-items:47:0::Consider iterating with .items()
+consider-using-dict-items:54:0::Consider iterating with .items()
+consider-using-dict-items:67:0::Consider iterating with .items()
+consider-using-dict-items:68:0::Consider iterating with .items()
+consider-using-dict-items:71:0::Consider iterating with .items()
+consider-using-dict-items:72:0::Consider iterating with .items()
+consider-using-dict-items:75:0::Consider iterating with .items()
+consider-iterating-dictionary:86:25::Consider iterating the dictionary directly instead of calling .keys()
+consider-using-dict-items:86:0::Consider iterating with .items()
diff --git a/tests/functional/c/consider/consider_using_enumerate.py b/tests/functional/c/consider/consider_using_enumerate.py
new file mode 100644
index 0000000..7db4968
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_enumerate.py
@@ -0,0 +1,85 @@
+"""Emit a message for iteration through range and len is encountered."""
+
+# pylint: disable=missing-docstring, import-error, useless-object-inheritance, unsubscriptable-object, too-few-public-methods
+
+def bad():
+ iterable = [1, 2, 3]
+ for obj in range(len(iterable)): # [consider-using-enumerate]
+ yield iterable[obj]
+ for obj in range(0, len(iterable)): # [consider-using-enumerate]
+ yield iterable[obj]
+
+
+class Bad(object):
+
+ def __iter__(self):
+ iterable = [1, 2, 3]
+ for i in range(len(iterable)): # [consider-using-enumerate]
+ yield iterable[i]
+
+ def test(self):
+ for i in range(len(self)): # [consider-using-enumerate]
+ yield self[i]
+
+
+def good():
+ iterable = other_obj = [1, 2, 3]
+ total = 0
+ for obj in range(len(iterable)):
+ total += obj
+ yield total
+ yield iterable[obj + 1: 2]
+ yield iterable[len(obj)]
+ for obj in iterable:
+ yield iterable[obj - 1]
+
+ for index, obj in enumerate(iterable):
+ yield iterable[index]
+ for index in range(0, 10):
+ yield iterable[index + 1]
+ for index in range(10):
+ yield iterable[index]
+ for index in range(len([1, 2, 3, 4])):
+ yield index
+ for index in range(1, len(iterable)):
+ yield index
+ for index in range(len(iterable)):
+ yield [1, 2, 3][index]
+ yield len([1, 2, 3])
+ for index in range(len(iterable)):
+ yield other_obj[index]
+
+ # pylint: disable=import-outside-toplevel
+ from unknown import unknown
+ for index in range(unknown(iterable)):
+ yield iterable[index]
+
+ for index in range(len(iterable)):
+ def test(iterable):
+ return iterable[index]
+ yield test([1, 2, 3])
+
+
+class Good(object):
+
+ def __iter__(self):
+ # Should not suggest enumerate on self
+ for i in range(len(self)):
+ yield self[i]
+
+
+def does_not_crash_on_range_without_args():
+ for elem in range():
+ print(elem)
+
+# False negative described in #3657
+# https://github.com/PyCQA/pylint/issues/3657
+class MyClass(object):
+ def __init__(self):
+ self.my_list = []
+
+my_obj = MyClass()
+def my_function(instance: MyClass):
+ for i in range(len(instance.my_list)): # [consider-using-enumerate]
+ var = instance.my_list[i]
+ print(var)
diff --git a/tests/functional/c/consider/consider_using_enumerate.txt b/tests/functional/c/consider/consider_using_enumerate.txt
new file mode 100644
index 0000000..4a47388
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_enumerate.txt
@@ -0,0 +1,5 @@
+consider-using-enumerate:7:4:bad:Consider using enumerate instead of iterating with range and len
+consider-using-enumerate:9:4:bad:Consider using enumerate instead of iterating with range and len
+consider-using-enumerate:17:8:Bad.__iter__:Consider using enumerate instead of iterating with range and len
+consider-using-enumerate:21:8:Bad.test:Consider using enumerate instead of iterating with range and len
+consider-using-enumerate:83:4:my_function:Consider using enumerate instead of iterating with range and len
diff --git a/tests/functional/c/consider/consider_using_generator.py b/tests/functional/c/consider/consider_using_generator.py
new file mode 100644
index 0000000..eadb34a
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_generator.py
@@ -0,0 +1,11 @@
+# pylint: disable=missing-docstring, invalid-name
+# https://github.com/PyCQA/pylint/issues/3165
+
+list([])
+tuple([])
+
+list([0 for y in list(range(10))]) # [consider-using-generator]
+tuple([0 for y in list(range(10))]) # [consider-using-generator]
+
+list(0 for y in list(range(10)))
+tuple(0 for y in list(range(10)))
diff --git a/tests/functional/c/consider/consider_using_generator.txt b/tests/functional/c/consider/consider_using_generator.txt
new file mode 100644
index 0000000..3d3c5a4
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_generator.txt
@@ -0,0 +1,2 @@
+consider-using-generator:7:0::Consider using a generator instead 'list(0 for y in list(range(10)))'
+consider-using-generator:8:0::Consider using a generator instead 'tuple(0 for y in list(range(10)))'
diff --git a/tests/functional/c/consider/consider_using_get.py b/tests/functional/c/consider/consider_using_get.py
new file mode 100644
index 0000000..8c5c689
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_get.py
@@ -0,0 +1,90 @@
+# pylint: disable=missing-docstring,invalid-name,using-constant-test,invalid-sequence-index,undefined-variable
+dictionary = dict()
+key = 'key'
+
+if 'key' in dictionary: # [consider-using-get]
+ variable = dictionary['key']
+
+if 'key' in dictionary: # [consider-using-get]
+ variable = dictionary['key']
+else:
+ variable = 'default'
+
+if key in dictionary: # [consider-using-get]
+ variable = dictionary[key]
+
+if 'key' in dictionary: # not accessing the dictionary in assignment
+ variable = "string"
+
+if 'key' in dictionary: # is a match, but not obvious and we ignore it for now
+ variable = dictionary[key]
+
+if 'key1' in dictionary: # dictionary querried for wrong key
+ variable = dictionary['key2']
+
+if 'key' in dictionary: # body is not pure
+ variable = dictionary['key']
+ print('found')
+
+if 'key' in dictionary: # body is not pure
+ variable = dictionary['key']
+ print('found')
+else:
+ variable = 'default'
+
+if 'key' in dictionary1: # different dictionaries
+ variable = dictionary2['key']
+else:
+ variable = 'default'
+
+if 'key' in dictionary: # body is not pure
+ variable = dictionary['key']
+else:
+ variable = 'default'
+ print('found')
+
+if 'key' in dictionary: # different variables
+ variable1 = dictionary['key']
+else:
+ variable2 = 'default'
+
+if 'key' in dictionary: # assignment is not simple
+ variable1 = variable2 = dictionary['key']
+
+if 'key' in dictionary: # assignment is not simple
+ variable1 = dictionary['key']
+else:
+ variable1 = variable2 = "default"
+
+if 'word' in 'text':
+ variable = 'text'['word'] # already bogus, but to assert that this only works with dictionaries
+
+if 'word' in dictionary:
+ variable = 'dictionary'['word']
+
+if 'key1' in dictionary: # not the simple case
+ variable = dictionary['key1']
+elif 'key2' in dictionary: # [consider-using-get]
+ variable = dictionary['key2']
+else:
+ variable = 'default'
+
+if 'key' in dictionary and bool(key): # not a simple compare
+ variable = dictionary['key1']
+else:
+ variable = 'default'
+
+if bool(key) and 'key' in dictionary: # not a simple compare
+ variable = dictionary['key1']
+else:
+ variable = 'default'
+
+
+d1 = {'foo': None}
+d2 = {}
+# Cannot be represented as using .get()
+if 'foo' in d1:
+ d2['bar'] = d1['foo']
+
+if 'key' in dictionary:
+ variable = dictionary[1:]
diff --git a/tests/functional/c/consider/consider_using_get.txt b/tests/functional/c/consider/consider_using_get.txt
new file mode 100644
index 0000000..d57b4a2
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_get.txt
@@ -0,0 +1,4 @@
+consider-using-get:5:0::Consider using dict.get for getting values from a dict if a key is present or a default if not
+consider-using-get:8:0::Consider using dict.get for getting values from a dict if a key is present or a default if not
+consider-using-get:13:0::Consider using dict.get for getting values from a dict if a key is present or a default if not
+consider-using-get:67:0::Consider using dict.get for getting values from a dict if a key is present or a default if not
diff --git a/tests/functional/c/consider/consider_using_in.py b/tests/functional/c/consider/consider_using_in.py
new file mode 100644
index 0000000..fb68ac5
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_in.py
@@ -0,0 +1,46 @@
+# pylint: disable=missing-docstring, invalid-name, pointless-statement, misplaced-comparison-constant, undefined-variable, literal-comparison, line-too-long, unneeded-not
+
+value = value1 = 1
+value2 = 2
+a_set = {1, 2, 3}
+a_list = [1, 2, 3]
+a_str = '1'
+
+# Positive
+value == 1 or value == 1 # [consider-using-in]
+value == 1 or value == 2 # [consider-using-in]
+'value' == value or 'value' == value # [consider-using-in]
+value == 1 or value == undef_value # [consider-using-in]
+value == 1 or value == 2 or value == 3 # [consider-using-in]
+value == '2' or value == 1 # [consider-using-in]
+1 == value or 2 == value # [consider-using-in]
+1 == value or value == 2 # [consider-using-in]
+value == 1 or value == a_list # [consider-using-in]
+value == a_set or value == a_list or value == a_str # [consider-using-in]
+value != 1 and value != 2 # [consider-using-in]
+value1 == value2 or value2 == value1 # [consider-using-in]
+a_list == [1, 2, 3] or a_list == [] # [consider-using-in]
+
+# Negative
+value != 1 or value != 2 # not a "not in"-case because of "or"
+value == 1 and value == 2 # not a "in"-case because of "and"
+value == 1 and value == 2 or value == 3 # not only 'or's
+value == 1 or value == 2 or 3 < value < 4 # not only '=='
+value == 1 # value not checked against multiple values
+value == 1 or value == 2 or value == 3 and value == 4 # not all checks are concatenated with 'or'
+value == 1 or 2 < value < 3 # length of 'ops' != 1 for second check
+value is 1 or value is 2 # 'in' compares using '==' not 'is' and therefore not considered
+not value == 1 and not value == 2
+value1 == 1 or value2 == 2 # different variables and only one comparison for each
+value1 == value2 == 1 or value1 == 2 # not checking multi-compares for '=='
+value1 != 1 == value2 and value2 != value1 != 2 # not checking multi-compares for '!='
+value1 == 1 or value1 == value2 or value2 == 3 # value1 or value2 do not occur in every check
+value1 == 1 or value1 == 2 or value2 == 1 or value2 == 2 # value1 or value2 do not occur in every check
+'value' == 1 or 'value' == 2 # only detect variables for now
+
+
+def oops():
+ return 5 / 0
+
+
+some_value = value == 4 or value == 5 or value == oops() # We only look for names and constants
diff --git a/tests/functional/c/consider/consider_using_in.txt b/tests/functional/c/consider/consider_using_in.txt
new file mode 100644
index 0000000..63e5fff
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_in.txt
@@ -0,0 +1,13 @@
+consider-using-in:10:0::"Consider merging these comparisons with ""in"" to 'value in (1,)'"
+consider-using-in:11:0::"Consider merging these comparisons with ""in"" to 'value in (1, 2)'"
+consider-using-in:12:0::"Consider merging these comparisons with ""in"" to ""value in ('value',)"""
+consider-using-in:13:0::"Consider merging these comparisons with ""in"" to 'value in (1, undef_value)'"
+consider-using-in:14:0::"Consider merging these comparisons with ""in"" to 'value in (1, 2, 3)'"
+consider-using-in:15:0::"Consider merging these comparisons with ""in"" to ""value in ('2', 1)"""
+consider-using-in:16:0::"Consider merging these comparisons with ""in"" to 'value in (1, 2)'"
+consider-using-in:17:0::"Consider merging these comparisons with ""in"" to 'value in (1, 2)'"
+consider-using-in:18:0::"Consider merging these comparisons with ""in"" to 'value in (1, a_list)'"
+consider-using-in:19:0::"Consider merging these comparisons with ""in"" to 'value in (a_set, a_list, a_str)'"
+consider-using-in:20:0::"Consider merging these comparisons with ""in"" to 'value not in (1, 2)'"
+consider-using-in:21:0::"Consider merging these comparisons with ""in"" to 'value1 in (value2,)'"
+consider-using-in:22:0::"Consider merging these comparisons with ""in"" to 'a_list in ([1, 2, 3], [])'"
diff --git a/tests/functional/c/consider/consider_using_min_max_builtin.py b/tests/functional/c/consider/consider_using_min_max_builtin.py
new file mode 100644
index 0000000..6e7c7b8
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_min_max_builtin.py
@@ -0,0 +1,107 @@
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods, redefined-outer-name
+
+value = 10
+value2 = 0
+value3 = 3
+
+# Positive
+if value < 10: # [consider-using-max-builtin]
+ value = 10
+
+if value >= 10: # [consider-using-min-builtin]
+ value = 10
+
+if value <= 10: # [consider-using-max-builtin]
+ value = 10
+
+if value > 10: # [consider-using-min-builtin]
+ value = 10
+
+if value < value2: # [consider-using-max-builtin]
+ value = value2
+
+if value > value2: # [consider-using-min-builtin]
+ value = value2
+
+
+class A:
+ def __init__(self):
+ self.value = 13
+
+
+A1 = A()
+if A1.value > 10: # [consider-using-min-builtin]
+ A1.value = 10
+
+
+class AA:
+ def __init__(self, value):
+ self.value = value
+
+ def __gt__(self, b):
+ return self.value > b
+
+ def __ge__(self, b):
+ return self.value >= b
+
+ def __lt__(self, b):
+ return self.value < b
+
+ def __le__(self, b):
+ return self.value <= b
+
+
+A1 = AA(0)
+A2 = AA(3)
+
+if A1 > A2: # [consider-using-min-builtin]
+ A1 = A2
+
+if A2 < A1: # [consider-using-max-builtin]
+ A2 = A1
+
+if A1 >= A2: # [consider-using-min-builtin]
+ A1 = A2
+
+if A2 <= A1: # [consider-using-max-builtin]
+ A2 = A1
+
+# Negative
+if value > 10:
+ value = 2
+
+if value > 10:
+ value = 2
+ value2 = 3
+
+if value > value2:
+ value = value3
+
+if value > 5:
+ value = value3
+
+if 2 < value <= 3:
+ value = 1
+
+if value <= 3:
+ value = 5
+
+if value <= 3:
+ value = 5
+elif value == 3:
+ value = 2
+
+if value > 10:
+ value = 10
+else:
+ value = 3
+
+
+# https://github.com/PyCQA/pylint/issues/4379
+var = 1
+if var == -1:
+ var = None
+
+var2 = 1
+if var2 in [1, 2]:
+ var2 = None
diff --git a/tests/functional/c/consider/consider_using_min_max_builtin.txt b/tests/functional/c/consider/consider_using_min_max_builtin.txt
new file mode 100644
index 0000000..9ed5e05
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_min_max_builtin.txt
@@ -0,0 +1,11 @@
+consider-using-max-builtin:8:0::"Consider using 'value = max(value, 10)' instead of unnecessary if block"
+consider-using-min-builtin:11:0::"Consider using 'value = min(value, 10)' instead of unnecessary if block"
+consider-using-max-builtin:14:0::"Consider using 'value = max(value, 10)' instead of unnecessary if block"
+consider-using-min-builtin:17:0::"Consider using 'value = min(value, 10)' instead of unnecessary if block"
+consider-using-max-builtin:20:0::"Consider using 'value = max(value, value2)' instead of unnecessary if block"
+consider-using-min-builtin:23:0::"Consider using 'value = min(value, value2)' instead of unnecessary if block"
+consider-using-min-builtin:33:0::"Consider using 'value = min(value, 10)' instead of unnecessary if block"
+consider-using-min-builtin:57:0::"Consider using 'A1 = min(A1, A2)' instead of unnecessary if block"
+consider-using-max-builtin:60:0::"Consider using 'A2 = max(A2, A1)' instead of unnecessary if block"
+consider-using-min-builtin:63:0::"Consider using 'A1 = min(A1, A2)' instead of unnecessary if block"
+consider-using-max-builtin:66:0::"Consider using 'A2 = max(A2, A1)' instead of unnecessary if block"
diff --git a/tests/functional/c/consider/consider_using_set_comprehension.py b/tests/functional/c/consider/consider_using_set_comprehension.py
new file mode 100644
index 0000000..345989c
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_set_comprehension.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring, invalid-name, unnecessary-comprehension
+
+numbers = [1, 2, 3, 4, 5, 6]
+
+set()
+
+set([])
+
+set([number for number in numbers]) # [consider-using-set-comprehension]
diff --git a/tests/functional/c/consider/consider_using_set_comprehension.txt b/tests/functional/c/consider/consider_using_set_comprehension.txt
new file mode 100644
index 0000000..4839a7a
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_set_comprehension.txt
@@ -0,0 +1 @@
+consider-using-set-comprehension:9:0::Consider using a set comprehension
diff --git a/tests/functional/c/consider/consider_using_sys_exit.py b/tests/functional/c/consider/consider_using_sys_exit.py
new file mode 100644
index 0000000..524cf00
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_sys_exit.py
@@ -0,0 +1,14 @@
+# pylint: disable=missing-docstring, invalid-name, disallowed-name, redefined-builtin, unused-variable
+import sys
+
+def foo():
+ exit() # [consider-using-sys-exit]
+
+def foo_1():
+ quit() # [consider-using-sys-exit]
+
+def foo_2():
+ quit = 'abc'
+ sys.exit()
+
+quit() # [consider-using-sys-exit]
diff --git a/tests/functional/c/consider/consider_using_sys_exit.txt b/tests/functional/c/consider/consider_using_sys_exit.txt
new file mode 100644
index 0000000..c429c65
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_sys_exit.txt
@@ -0,0 +1,3 @@
+consider-using-sys-exit:5:4:foo:Consider using sys.exit()
+consider-using-sys-exit:8:4:foo_1:Consider using sys.exit()
+consider-using-sys-exit:14:0::Consider using sys.exit()
diff --git a/tests/functional/c/consider/consider_using_sys_exit_exempted.py b/tests/functional/c/consider/consider_using_sys_exit_exempted.py
new file mode 100644
index 0000000..ba66989
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_sys_exit_exempted.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-docstring,redefined-builtin
+
+from sys import exit
+
+exit(0)
diff --git a/tests/functional/c/consider/consider_using_sys_exit_local_scope.py b/tests/functional/c/consider/consider_using_sys_exit_local_scope.py
new file mode 100644
index 0000000..05b57ae
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_sys_exit_local_scope.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-docstring,import-outside-toplevel,redefined-builtin
+
+def run():
+ from sys import exit
+ exit()
diff --git a/tests/functional/c/consider/consider_using_with.py b/tests/functional/c/consider/consider_using_with.py
new file mode 100644
index 0000000..84b394c
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with.py
@@ -0,0 +1,156 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, invalid-name, import-outside-toplevel
+import codecs
+import contextlib
+import multiprocessing
+import subprocess
+import tarfile
+import tempfile
+import threading
+import urllib
+import zipfile
+from concurrent import futures
+
+
+def test_codecs_open():
+ fh = codecs.open("test.txt", "utf8") # [consider-using-with]
+ fh.close()
+
+
+def test_urlopen():
+ _ = urllib.request.urlopen("http://www.python.org") # [consider-using-with]
+
+
+def test_temporary_file():
+ _ = tempfile.TemporaryFile("r") # [consider-using-with]
+
+
+def test_named_temporary_file():
+ _ = tempfile.NamedTemporaryFile("r") # [consider-using-with]
+
+
+def test_spooled_temporary_file():
+ _ = tempfile.SpooledTemporaryFile("r") # [consider-using-with]
+
+
+def test_temporary_directory():
+ _ = tempfile.TemporaryDirectory() # [consider-using-with]
+
+
+def test_zipfile():
+ myzip = zipfile.ZipFile("spam.zip", "w") # [consider-using-with]
+ _ = myzip.open("eggs.txt") # [consider-using-with]
+
+
+def test_pyzipfile():
+ myzip = zipfile.PyZipFile("spam.zip", "w") # [consider-using-with]
+
+ with zipfile.PyZipFile("spam.zip", "w"): # must not trigger
+ pass
+
+ _ = myzip.open("eggs.txt") # [consider-using-with]
+
+ with myzip.open("eggs.txt"): # must not trigger
+ pass
+
+
+def test_tarfile():
+ tf = tarfile.open("/tmp/test.tar", "w") # [consider-using-with]
+ tf.close()
+
+ with tarfile.open("/tmp/test.tar", "w"): # must not trigger
+ pass
+
+ tf = tarfile.TarFile("/tmp/test2.tar", "w") # [consider-using-with]
+ tf.close()
+
+ with tarfile.TarFile("/tmp/test2.tar", "w"): # must not trigger
+ pass
+
+
+def test_lock_acquisition():
+ lock = threading.Lock()
+ lock.acquire() # [consider-using-with]
+ lock.release()
+
+ with lock: # must not trigger
+ pass
+
+ rlock = threading.RLock()
+ rlock.acquire() # [consider-using-with]
+ rlock.release()
+
+ with rlock: # must not trigger
+ pass
+
+ sema = threading.Semaphore()
+ sema.acquire() # [consider-using-with]
+ sema.release()
+
+ with sema: # must not trigger
+ pass
+
+ bounded_sema = threading.BoundedSemaphore()
+ bounded_sema.acquire() # [consider-using-with]
+ bounded_sema.release()
+
+ with bounded_sema: # must not trigger
+ pass
+
+
+@contextlib.contextmanager
+def test_lock_acquisition_in_context_manager1():
+ """
+ The message must not be triggered if the resource allocation is done inside a context manager.
+ """
+ lock = threading.Lock()
+ lock.acquire() # must not trigger
+ yield
+ lock.release()
+
+
+class MyLockContext:
+ """
+ The message must not be triggered if the resource allocation is done inside a context manager.
+ """
+ def __init__(self):
+ self.lock = threading.Lock()
+
+ def __enter__(self):
+ self.lock.acquire() # must not trigger
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ self.lock.release()
+
+
+def test_multiprocessing():
+ # the different Locks provided by multiprocessing would be candidates
+ # for consider-using-with as well, but they lead to InferenceErrors.
+ _ = multiprocessing.Pool() # [consider-using-with]
+ with multiprocessing.Pool():
+ pass
+
+ manager = multiprocessing.managers.BaseManager()
+ manager.start() # [consider-using-with]
+ with multiprocessing.managers.BaseManager():
+ pass
+
+ manager = multiprocessing.managers.SyncManager()
+ manager.start() # [consider-using-with]
+ with multiprocessing.managers.SyncManager():
+ pass
+
+
+def test_futures():
+ _ = futures.ThreadPoolExecutor() # [consider-using-with]
+ with futures.ThreadPoolExecutor():
+ pass
+
+ _ = futures.ProcessPoolExecutor() # [consider-using-with]
+ with futures.ProcessPoolExecutor():
+ pass
+
+
+def test_popen():
+ _ = subprocess.Popen("sh") # [consider-using-with]
+ with subprocess.Popen("sh"):
+ pass
diff --git a/tests/functional/c/consider/consider_using_with.txt b/tests/functional/c/consider/consider_using_with.txt
new file mode 100644
index 0000000..66c1572
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with.txt
@@ -0,0 +1,22 @@
+consider-using-with:15:9:test_codecs_open:Consider using 'with' for resource-allocating operations
+consider-using-with:20:8:test_urlopen:Consider using 'with' for resource-allocating operations
+consider-using-with:24:8:test_temporary_file:Consider using 'with' for resource-allocating operations
+consider-using-with:28:8:test_named_temporary_file:Consider using 'with' for resource-allocating operations
+consider-using-with:32:8:test_spooled_temporary_file:Consider using 'with' for resource-allocating operations
+consider-using-with:36:8:test_temporary_directory:Consider using 'with' for resource-allocating operations
+consider-using-with:40:12:test_zipfile:Consider using 'with' for resource-allocating operations
+consider-using-with:41:8:test_zipfile:Consider using 'with' for resource-allocating operations
+consider-using-with:45:12:test_pyzipfile:Consider using 'with' for resource-allocating operations
+consider-using-with:50:8:test_pyzipfile:Consider using 'with' for resource-allocating operations
+consider-using-with:57:9:test_tarfile:Consider using 'with' for resource-allocating operations
+consider-using-with:63:9:test_tarfile:Consider using 'with' for resource-allocating operations
+consider-using-with:72:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations
+consider-using-with:79:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations
+consider-using-with:86:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations
+consider-using-with:93:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations
+consider-using-with:128:8:test_multiprocessing:Consider using 'with' for resource-allocating operations
+consider-using-with:133:4:test_multiprocessing:Consider using 'with' for resource-allocating operations
+consider-using-with:138:4:test_multiprocessing:Consider using 'with' for resource-allocating operations
+consider-using-with:144:8:test_futures:Consider using 'with' for resource-allocating operations
+consider-using-with:148:8:test_futures:Consider using 'with' for resource-allocating operations
+consider-using-with:154:8:test_popen:Consider using 'with' for resource-allocating operations
diff --git a/tests/functional/c/consider/consider_using_with_open.py b/tests/functional/c/consider/consider_using_with_open.py
new file mode 100644
index 0000000..9001a52
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with_open.py
@@ -0,0 +1,51 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, invalid-name, import-outside-toplevel
+# pylint: disable=missing-class-docstring, too-few-public-methods, unused-variable
+"""
+The functional test for the standard ``open()`` function has to be moved in a separate file,
+because PyPy has to be excluded for the tests as the ``open()`` function is uninferable in PyPy.
+However, all remaining checks for consider-using-with work in PyPy, so we do not want to exclude
+PyPy from ALL functional tests.
+"""
+from contextlib import contextmanager
+
+
+myfile = open("test.txt") # [consider-using-with]
+
+
+def test_open():
+ fh = open("test.txt") # [consider-using-with]
+ fh.close()
+
+ with open("test.txt") as fh: # must not trigger
+ fh.read()
+
+
+def test_open_in_enter():
+ """Message must not trigger if the resource is allocated in a context manager."""
+ class MyContextManager:
+ def __init__(self):
+ self.file_handle = None
+
+ def __enter__(self):
+ self.file_handle = open("foo.txt", "w") # must not trigger
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ self.file_handle.close()
+
+
+@contextmanager
+def test_open_in_with_contextlib():
+ """Message must not trigger if the resource is allocated in a context manager."""
+ file_handle = open("foo.txt", "w") # must not trigger
+ yield file_handle
+ file_handle.close()
+
+
+def test_open_outside_assignment():
+ open("foo").read() # [consider-using-with]
+ content = open("foo").read() # [consider-using-with]
+
+
+def test_open_inside_with_block():
+ with open("foo") as fh:
+ open("bar") # [consider-using-with]
diff --git a/tests/functional/c/consider/consider_using_with_open.rc b/tests/functional/c/consider/consider_using_with_open.rc
new file mode 100644
index 0000000..b47a745
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with_open.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=PyPy
diff --git a/tests/functional/c/consider/consider_using_with_open.txt b/tests/functional/c/consider/consider_using_with_open.txt
new file mode 100644
index 0000000..63cd08b
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with_open.txt
@@ -0,0 +1,5 @@
+consider-using-with:12:9::Consider using 'with' for resource-allocating operations
+consider-using-with:16:9:test_open:Consider using 'with' for resource-allocating operations
+consider-using-with:45:4:test_open_outside_assignment:Consider using 'with' for resource-allocating operations
+consider-using-with:46:14:test_open_outside_assignment:Consider using 'with' for resource-allocating operations
+consider-using-with:51:8:test_open_inside_with_block:Consider using 'with' for resource-allocating operations
diff --git a/tests/functional/c/continue_in_finally.py b/tests/functional/c/continue_in_finally.py
new file mode 100644
index 0000000..bb1fcba
--- /dev/null
+++ b/tests/functional/c/continue_in_finally.py
@@ -0,0 +1,23 @@
+"""Test that `continue` is catched when met inside a `finally` clause."""
+
+# pylint: disable=missing-docstring, lost-exception, broad-except
+
+while True:
+ try:
+ pass
+ finally:
+ continue # [continue-in-finally]
+
+while True:
+ try:
+ pass
+ finally:
+ break
+
+while True:
+ try:
+ pass
+ except Exception:
+ pass
+ else:
+ continue
diff --git a/tests/functional/c/continue_in_finally.rc b/tests/functional/c/continue_in_finally.rc
new file mode 100644
index 0000000..67a28a3
--- /dev/null
+++ b/tests/functional/c/continue_in_finally.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.8
diff --git a/tests/functional/c/continue_in_finally.txt b/tests/functional/c/continue_in_finally.txt
new file mode 100644
index 0000000..3a5e542
--- /dev/null
+++ b/tests/functional/c/continue_in_finally.txt
@@ -0,0 +1 @@
+continue-in-finally:9:::'continue' not supported inside 'finally' clause
diff --git a/tests/functional/c/control_pragmas.py b/tests/functional/c/control_pragmas.py
new file mode 100644
index 0000000..993f9a5
--- /dev/null
+++ b/tests/functional/c/control_pragmas.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring
+
+
+def test_pragma():
+ """Test that the control pragmas are not too eager to consume the entire line
+
+ We should stop either at:
+ - ; or #
+ - or at the end of line
+ """
+ # noqa: E501 # pylint: disable=unused-variable #nosec
+ variable = 1
+
+ # noqa # pylint: disable=undefined-variable,no-member; don't trigger
+ other_variable = some_variable + variable.member
+
+ # noqa # pylint: disable=unbalanced-tuple-unpacking,no-member # no trigger
+ first, second = some_other_variable
+ return first + other_variable.method()
diff --git a/tests/functional/c/crash_missing_module_type.py b/tests/functional/c/crash_missing_module_type.py
new file mode 100644
index 0000000..308606f
--- /dev/null
+++ b/tests/functional/c/crash_missing_module_type.py
@@ -0,0 +1,18 @@
+""" Test for a crash found in
+https://bitbucket.org/logilab/astroid/issue/45/attributeerror-module-object-has-no#comment-11944673
+"""
+# pylint: disable=no-init, invalid-name, too-few-public-methods, redefined-outer-name, useless-object-inheritance
+def decor(trop):
+ """ decorator """
+ return trop
+
+class Foo(object):
+ """ Class """
+ @decor
+ def prop(self):
+ """ method """
+ return self
+
+if __name__ == '__main__':
+ trop = Foo()
+ trop.prop = 42
diff --git a/tests/functional/c/ctor_arguments.py b/tests/functional/c/ctor_arguments.py
new file mode 100644
index 0000000..ee10413
--- /dev/null
+++ b/tests/functional/c/ctor_arguments.py
@@ -0,0 +1,104 @@
+"""Test function argument checker on __init__
+
+Based on tests/functional/a/arguments.py
+"""
+# pylint: disable=missing-docstring,too-few-public-methods,super-init-not-called,useless-object-inheritance
+
+
+class Class1Arg(object):
+ def __init__(self, first_argument):
+ """one argument function"""
+
+class Class3Arg(object):
+ def __init__(self, first_argument, second_argument, third_argument):
+ """three arguments function"""
+
+class ClassDefaultArg(object):
+ def __init__(self, one=1, two=2):
+ """function with default value"""
+
+class Subclass1Arg(Class1Arg):
+ pass
+
+class ClassAllArgs(Class1Arg):
+ def __init__(self, *args, **kwargs):
+ pass
+
+class ClassMultiInheritance(Class1Arg, Class3Arg):
+ pass
+
+class ClassNew(object):
+ def __new__(cls, first_argument, kwarg=None):
+ return first_argument, kwarg
+
+Class1Arg(420)
+Class1Arg() # [no-value-for-parameter]
+Class1Arg(1337, 347) # [too-many-function-args]
+
+Class3Arg(420, 789) # [no-value-for-parameter]
+# +1:[no-value-for-parameter,no-value-for-parameter,no-value-for-parameter]
+Class3Arg()
+Class3Arg(1337, 347, 456)
+Class3Arg('bab', 'bebe', None, 5.6) # [too-many-function-args]
+
+ClassDefaultArg(1, two=5)
+ClassDefaultArg(two=5)
+
+Class1Arg(bob=4) # [no-value-for-parameter,unexpected-keyword-arg]
+ClassDefaultArg(1, 4, coin="hello") # [unexpected-keyword-arg]
+
+ClassDefaultArg(1, one=5) # [redundant-keyword-arg]
+
+Subclass1Arg(420)
+Subclass1Arg() # [no-value-for-parameter]
+Subclass1Arg(1337, 347) # [too-many-function-args]
+
+ClassAllArgs()
+ClassAllArgs(1, 2, 3, even=4, more=5)
+
+ClassMultiInheritance(1)
+ClassMultiInheritance(1, 2, 3) # [too-many-function-args]
+
+ClassNew(1, kwarg=1)
+ClassNew(1, 2, 3) # [too-many-function-args]
+ClassNew(one=2) # [no-value-for-parameter,unexpected-keyword-arg]
+
+
+class Metaclass(type):
+ def __new__(cls, name, bases, namespace):
+ return type.__new__(cls, name, bases, namespace)
+
+def with_metaclass(meta, base=object):
+ """Create a new type that can be used as a metaclass."""
+ return meta("NewBase", (base, ), {})
+
+class ClassWithMeta(with_metaclass(Metaclass)):
+ pass
+
+ClassWithMeta()
+
+
+class BuiltinExc(Exception):
+ def __init__(self, val=True):
+ self.val = val
+
+BuiltinExc(42, 24, badarg=1) # [too-many-function-args,unexpected-keyword-arg]
+
+
+class Clsmethod(object):
+ def __init__(self, first, second):
+ self.first = first
+ self.second = second
+
+ @classmethod
+ def from_nothing(cls):
+ return cls(1, 2, 3, 4) # [too-many-function-args]
+
+ @classmethod
+ def from_nothing1(cls):
+ return cls() # [no-value-for-parameter,no-value-for-parameter]
+
+ @classmethod
+ def from_nothing2(cls):
+ # +1: [no-value-for-parameter,unexpected-keyword-arg]
+ return cls(1, not_argument=2)
diff --git a/tests/functional/c/ctor_arguments.txt b/tests/functional/c/ctor_arguments.txt
new file mode 100644
index 0000000..781715c
--- /dev/null
+++ b/tests/functional/c/ctor_arguments.txt
@@ -0,0 +1,24 @@
+no-value-for-parameter:35:0::No value for argument 'first_argument' in constructor call
+too-many-function-args:36:0::Too many positional arguments for constructor call
+no-value-for-parameter:38:0::No value for argument 'third_argument' in constructor call
+no-value-for-parameter:40:0::No value for argument 'first_argument' in constructor call
+no-value-for-parameter:40:0::No value for argument 'second_argument' in constructor call
+no-value-for-parameter:40:0::No value for argument 'third_argument' in constructor call
+too-many-function-args:42:0::Too many positional arguments for constructor call
+no-value-for-parameter:47:0::No value for argument 'first_argument' in constructor call
+unexpected-keyword-arg:47:0::Unexpected keyword argument 'bob' in constructor call
+unexpected-keyword-arg:48:0::Unexpected keyword argument 'coin' in constructor call
+redundant-keyword-arg:50:0::Argument 'one' passed by position and keyword in constructor call
+no-value-for-parameter:53:0::No value for argument 'first_argument' in constructor call
+too-many-function-args:54:0::Too many positional arguments for constructor call
+too-many-function-args:60:0::Too many positional arguments for constructor call
+too-many-function-args:63:0::Too many positional arguments for constructor call
+no-value-for-parameter:64:0::No value for argument 'first_argument' in constructor call
+unexpected-keyword-arg:64:0::Unexpected keyword argument 'one' in constructor call
+too-many-function-args:85:0::Too many positional arguments for constructor call
+unexpected-keyword-arg:85:0::Unexpected keyword argument 'badarg' in constructor call
+too-many-function-args:95:15:Clsmethod.from_nothing:Too many positional arguments for constructor call
+no-value-for-parameter:99:15:Clsmethod.from_nothing1:No value for argument 'first' in constructor call
+no-value-for-parameter:99:15:Clsmethod.from_nothing1:No value for argument 'second' in constructor call
+no-value-for-parameter:104:15:Clsmethod.from_nothing2:No value for argument 'second' in constructor call
+unexpected-keyword-arg:104:15:Clsmethod.from_nothing2:Unexpected keyword argument 'not_argument' in constructor call
diff --git a/tests/functional/d/__init__.py b/tests/functional/d/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/d/__init__.py
diff --git a/tests/functional/d/dangerous_default_value_py30.py b/tests/functional/d/dangerous_default_value_py30.py
new file mode 100644
index 0000000..4f74dbe
--- /dev/null
+++ b/tests/functional/d/dangerous_default_value_py30.py
@@ -0,0 +1,111 @@
+# pylint: disable=missing-docstring
+import collections
+
+HEHE = {}
+
+def function1(value=[]): # [dangerous-default-value]
+ """docstring"""
+ return value
+
+def function2(value=HEHE): # [dangerous-default-value]
+ """docstring"""
+ return value
+
+def function3(value):
+ """docstring"""
+ return value
+
+def function4(value=set()): # [dangerous-default-value]
+ """set is mutable and dangerous."""
+ return value
+
+def function5(value=frozenset()):
+ """frozenset is immutable and safe."""
+ return value
+
+GLOBAL_SET = set()
+
+def function6(value=GLOBAL_SET): # [dangerous-default-value]
+ """set is mutable and dangerous."""
+ return value
+
+def function7(value=dict()): # [dangerous-default-value]
+ """dict is mutable and dangerous."""
+ return value
+
+def function8(value=list()): # [dangerous-default-value]
+ """list is mutable and dangerous."""
+ return value
+
+def function9(value=[1, 2, 3, 4]): # [dangerous-default-value]
+ """list with items should not output item values in error message"""
+ return value
+
+def function10(value={'a': 1, 'b': 2}): # [dangerous-default-value]
+ """dictionaries with items should not output item values in error message"""
+ return value
+
+def function11(value=list([1, 2, 3])): # [dangerous-default-value]
+ """list with items should not output item values in error message"""
+ return value
+
+def function12(value=dict([('a', 1), ('b', 2)])): # [dangerous-default-value]
+ """dictionaries with items should not output item values in error message"""
+ return value
+
+OINK = {
+ 'a': 1,
+ 'b': 2
+}
+
+def function13(value=OINK): # [dangerous-default-value]
+ """dictionaries with items should not output item values in error message"""
+ return value
+
+def function14(value=dict([(1, 2), (1, 2, 3)])): # [dangerous-default-value]
+ """a dictionary which will not be inferred to a syntax AST, but to an
+ astroid.Instance.
+ """
+ return value
+
+INVALID_DICT = dict([(1, 2), (1, 2, 3)])
+
+def function15(value=INVALID_DICT): # [dangerous-default-value]
+ """The same situation as function14."""
+ return value
+
+def function16(value={1}): # [dangerous-default-value]
+ """set literal as default value"""
+ return value
+
+def function17(value=collections.deque()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function18(value=collections.ChainMap()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function19(value=collections.Counter()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function20(value=collections.OrderedDict()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function21(value=collections.defaultdict()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function22(value=collections.UserDict()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function23(value=collections.UserList()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function24(*, value=[]): # [dangerous-default-value]
+ """dangerous default value in kwarg."""
+ return value
diff --git a/tests/functional/d/dangerous_default_value_py30.rc b/tests/functional/d/dangerous_default_value_py30.rc
new file mode 100644
index 0000000..c0490a6
--- /dev/null
+++ b/tests/functional/d/dangerous_default_value_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/d/dangerous_default_value_py30.txt b/tests/functional/d/dangerous_default_value_py30.txt
new file mode 100644
index 0000000..8f4dd7e
--- /dev/null
+++ b/tests/functional/d/dangerous_default_value_py30.txt
@@ -0,0 +1,22 @@
+dangerous-default-value:6:0:function1:Dangerous default value [] as argument
+dangerous-default-value:10:0:function2:Dangerous default value HEHE (builtins.dict) as argument
+dangerous-default-value:18:0:function4:Dangerous default value set() (builtins.set) as argument
+dangerous-default-value:28:0:function6:Dangerous default value GLOBAL_SET (builtins.set) as argument
+dangerous-default-value:32:0:function7:Dangerous default value dict() (builtins.dict) as argument
+dangerous-default-value:36:0:function8:Dangerous default value list() (builtins.list) as argument
+dangerous-default-value:40:0:function9:Dangerous default value [] as argument
+dangerous-default-value:44:0:function10:Dangerous default value {} as argument
+dangerous-default-value:48:0:function11:Dangerous default value list() (builtins.list) as argument
+dangerous-default-value:52:0:function12:Dangerous default value dict() (builtins.dict) as argument
+dangerous-default-value:61:0:function13:Dangerous default value OINK (builtins.dict) as argument
+dangerous-default-value:65:0:function14:Dangerous default value dict() (builtins.dict) as argument
+dangerous-default-value:73:0:function15:Dangerous default value INVALID_DICT (builtins.dict) as argument
+dangerous-default-value:77:0:function16:Dangerous default value set() as argument
+dangerous-default-value:81:0:function17:Dangerous default value deque() (collections.deque) as argument
+dangerous-default-value:85:0:function18:Dangerous default value ChainMap() (collections.ChainMap) as argument
+dangerous-default-value:89:0:function19:Dangerous default value Counter() (collections.Counter) as argument
+dangerous-default-value:93:0:function20:Dangerous default value OrderedDict() (collections.OrderedDict) as argument
+dangerous-default-value:97:0:function21:Dangerous default value defaultdict() (collections.defaultdict) as argument
+dangerous-default-value:101:0:function22:Dangerous default value UserDict() (collections.UserDict) as argument
+dangerous-default-value:105:0:function23:Dangerous default value UserList() (collections.UserList) as argument
+dangerous-default-value:109:0:function24:Dangerous default value [] as argument
diff --git a/tests/functional/d/dataclass_with_default_factory.py b/tests/functional/d/dataclass_with_default_factory.py
new file mode 100644
index 0000000..b01f389
--- /dev/null
+++ b/tests/functional/d/dataclass_with_default_factory.py
@@ -0,0 +1,15 @@
+"""A test script the confuses pylint."""
+# https://github.com/PyCQA/pylint/issues/2605
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Test:
+ """A test dataclass with a field, that has a default_factory."""
+
+ test: list = field(default_factory=list)
+
+
+TEST = Test()
+TEST.test.append(1)
+print(TEST.test[0])
diff --git a/tests/functional/d/dataclass_with_default_factory.rc b/tests/functional/d/dataclass_with_default_factory.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/d/dataclass_with_default_factory.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/d/decorator_scope.py b/tests/functional/d/decorator_scope.py
new file mode 100644
index 0000000..141c26d
--- /dev/null
+++ b/tests/functional/d/decorator_scope.py
@@ -0,0 +1,19 @@
+# -*- pylint: disable=no-init,too-few-public-methods, useless-object-inheritance
+"""Test that decorators sees the class namespace - just like
+function default values does but function body doesn't.
+
+https://www.logilab.net/elo/ticket/3711 - bug finding decorator arguments
+https://www.logilab.net/elo/ticket/5626 - name resolution bug inside classes
+"""
+
+from __future__ import print_function
+
+class Test(object):
+ """test class"""
+ ident = lambda x: x
+
+ @ident(ident)
+ def method(self, val=ident(7), func=ident):
+ """hop"""
+ print(self)
+ return func(val)
diff --git a/tests/functional/d/decorator_unused.py b/tests/functional/d/decorator_unused.py
new file mode 100644
index 0000000..add5b3b
--- /dev/null
+++ b/tests/functional/d/decorator_unused.py
@@ -0,0 +1,13 @@
+# pylint: disable=C
+def foo():
+ _dispatch = {}
+
+ def save(fn):
+ _dispatch[fn.__name__] = fn
+ return fn
+
+ @save
+ def bar():
+ ...
+ # do whatever
+foo()
diff --git a/tests/functional/d/defined_and_used_on_same_line.py b/tests/functional/d/defined_and_used_on_same_line.py
new file mode 100644
index 0000000..a9b9eb7
--- /dev/null
+++ b/tests/functional/d/defined_and_used_on_same_line.py
@@ -0,0 +1,29 @@
+"""Check for definitions and usage happening on the same line."""
+#pylint: disable=missing-docstring,multiple-statements,no-absolute-import,parameter-unpacking,wrong-import-position,unnecessary-comprehension
+from __future__ import print_function
+print([index
+ for index in range(10)])
+
+print((index
+ for index in range(10)))
+
+FILTER_FUNC = lambda x: not x
+
+def func(xxx): return xxx
+
+def func2(xxx): return xxx + func2(1)
+
+import sys; print(sys.exc_info())
+
+for i in range(10): print(i)
+
+j = 4; LAMB = lambda x: x+j
+
+FUNC4 = lambda a, b: a != b
+
+# test https://www.logilab.org/ticket/6954:
+
+with open('f') as f: print(f.read())
+
+with open('f') as f, open(f.read()) as g:
+ print(g.read())
diff --git a/tests/functional/d/deprecated/deprecated_class_py33.py b/tests/functional/d/deprecated/deprecated_class_py33.py
new file mode 100644
index 0000000..470e467
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_class_py33.py
@@ -0,0 +1,11 @@
+"""Test deprecated classes from Python 3.3."""
+# pylint: disable=unused-import,import-error,no-name-in-module,abstract-class-instantiated
+
+from collections import Iterable # [deprecated-class]
+
+import collections.Set # [deprecated-class]
+
+import collections
+
+
+_ = collections.Awaitable() # [deprecated-class]
diff --git a/tests/functional/d/deprecated/deprecated_class_py33.rc b/tests/functional/d/deprecated/deprecated_class_py33.rc
new file mode 100644
index 0000000..692104e
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_class_py33.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.3
+max_pyver=3.10
diff --git a/tests/functional/d/deprecated/deprecated_class_py33.txt b/tests/functional/d/deprecated/deprecated_class_py33.txt
new file mode 100644
index 0000000..9a31c0e
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_class_py33.txt
@@ -0,0 +1,3 @@
+deprecated-class:4:0::Using deprecated class Iterable of module collections
+deprecated-class:6:0::Using deprecated class Set of module collections
+deprecated-class:11:4::Using deprecated class Awaitable of module collections
diff --git a/tests/functional/d/deprecated/deprecated_decorators.py b/tests/functional/d/deprecated/deprecated_decorators.py
new file mode 100644
index 0000000..800ba61
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_decorators.py
@@ -0,0 +1,20 @@
+"""Test deprecated abc decorators from Python 3.3."""
+# pylint: disable=missing-class-docstring,too-few-public-methods,missing-function-docstring,no-member
+
+import abc
+
+class MyClass:
+ @abc.abstractclassmethod # [deprecated-decorator]
+ def my_method(cls):
+ pass
+
+class Foo:
+ def __init__(self):
+ self._baz = 84
+
+ def method(self):
+ return self._baz
+
+ @method.setter # Invalid decorator
+ def method(self, value):
+ self._baz = value
diff --git a/tests/functional/d/deprecated/deprecated_decorators.rc b/tests/functional/d/deprecated/deprecated_decorators.rc
new file mode 100644
index 0000000..28c99bc
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_decorators.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.3
diff --git a/tests/functional/d/deprecated/deprecated_decorators.txt b/tests/functional/d/deprecated/deprecated_decorators.txt
new file mode 100644
index 0000000..a696c8b
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_decorators.txt
@@ -0,0 +1 @@
+deprecated-decorator:7:4:MyClass.my_method:Using deprecated decorator abc.abstractclassmethod()
diff --git a/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.py b/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.py
new file mode 100644
index 0000000..3338c24
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.py
@@ -0,0 +1,4 @@
+"""Test that getmoduleinfo is deprecated."""
+import inspect
+
+inspect.getmoduleinfo(inspect) # [deprecated-method]
diff --git a/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.rc b/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.rc
new file mode 100644
index 0000000..a444ca6
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.rc
@@ -0,0 +1,3 @@
+[testoptions]
+max_pyver=3.6
+min_pyver=3.3
diff --git a/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.txt b/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.txt
new file mode 100644
index 0000000..77632a1
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.txt
@@ -0,0 +1 @@
+deprecated-method:4:::Using deprecated method getmoduleinfo()
diff --git a/tests/functional/d/deprecated/deprecated_methods_py3.py b/tests/functional/d/deprecated/deprecated_methods_py3.py
new file mode 100644
index 0000000..80428c7
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py3.py
@@ -0,0 +1,50 @@
+""" Functional tests for method deprecation. """
+# pylint: disable=missing-docstring, super-init-not-called, not-callable
+import base64
+import cgi
+import inspect
+import logging
+import nntplib
+import platform
+import unittest
+import xml.etree.ElementTree
+
+
+class MyTest(unittest.TestCase):
+ def test(self):
+ self.assert_(True) # [deprecated-method]
+
+xml.etree.ElementTree.Element('tag').getchildren() # [deprecated-method]
+xml.etree.ElementTree.Element('tag').getiterator() # [deprecated-method]
+xml.etree.ElementTree.XMLParser('tag', None, None).doctype(None, None, None) # [deprecated-method]
+nntplib.NNTP(None).xpath(None) # [deprecated-method]
+
+
+inspect.getargspec(None) # [deprecated-method]
+logging.warn("a") # [deprecated-method]
+platform.popen([]) # [deprecated-method]
+base64.encodestring("42") # [deprecated-method]
+base64.decodestring("42") # [deprecated-method]
+cgi.escape("a") # [deprecated-method]
+
+
+class SuperCrash(unittest.TestCase):
+
+ def __init__(self):
+ # should not crash.
+ super()()
+
+xml.etree.ElementTree.iterparse(None)
+
+
+class Tests(unittest.TestCase):
+
+ def test_foo(self):
+ self.assertEquals(2 + 2, 4) # [deprecated-method]
+ self.assertNotEquals(2 + 2, 4) # [deprecated-method]
+ self.assertAlmostEquals(2 + 2, 4) # [deprecated-method]
+ self.assertNotAlmostEquals(2 + 2, 4) # [deprecated-method]
+ self.assert_("abc" == "2") # [deprecated-method]
+
+ self.assertRaisesRegex(ValueError, "exception")
+ self.assertRegex("something", r".+")
diff --git a/tests/functional/d/deprecated/deprecated_methods_py3.rc b/tests/functional/d/deprecated/deprecated_methods_py3.rc
new file mode 100644
index 0000000..6c3e727
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.3
+max_pyver=3.7
diff --git a/tests/functional/d/deprecated/deprecated_methods_py3.txt b/tests/functional/d/deprecated/deprecated_methods_py3.txt
new file mode 100644
index 0000000..9796114
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py3.txt
@@ -0,0 +1,16 @@
+deprecated-method:15::MyTest.test:Using deprecated method assert_()
+deprecated-method:17:::Using deprecated method getchildren()
+deprecated-method:18:::Using deprecated method getiterator()
+deprecated-method:19:::Using deprecated method doctype()
+deprecated-method:20:::Using deprecated method xpath()
+deprecated-method:23:::Using deprecated method getargspec()
+deprecated-method:24:::Using deprecated method warn()
+deprecated-method:25:::Using deprecated method popen()
+deprecated-method:26:::Using deprecated method encodestring()
+deprecated-method:27:::Using deprecated method decodestring()
+deprecated-method:28:::Using deprecated method escape()
+deprecated-method:43::Tests.test_foo:Using deprecated method assertEquals()
+deprecated-method:44::Tests.test_foo:Using deprecated method assertNotEquals()
+deprecated-method:45::Tests.test_foo:Using deprecated method assertAlmostEquals()
+deprecated-method:46::Tests.test_foo:Using deprecated method assertNotAlmostEquals()
+deprecated-method:47::Tests.test_foo:Using deprecated method assert_()
diff --git a/tests/functional/d/deprecated/deprecated_methods_py36.py b/tests/functional/d/deprecated/deprecated_methods_py36.py
new file mode 100644
index 0000000..f416a14
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py36.py
@@ -0,0 +1,7 @@
+""" Functional tests for method deprecation. """
+# pylint: disable=no-value-for-parameter
+import unittest
+from importlib.machinery import SourceFileLoader, SourcelessFileLoader
+
+SourceFileLoader('unittest', unittest.__file__).load_module() # [deprecated-method]
+SourcelessFileLoader('unittest', unittest.__file__).load_module() # [deprecated-method]
diff --git a/tests/functional/d/deprecated/deprecated_methods_py36.rc b/tests/functional/d/deprecated/deprecated_methods_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/d/deprecated/deprecated_methods_py36.txt b/tests/functional/d/deprecated/deprecated_methods_py36.txt
new file mode 100644
index 0000000..801d24b
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py36.txt
@@ -0,0 +1,2 @@
+deprecated-method:6:0::Using deprecated method load_module()
+deprecated-method:7:0::Using deprecated method load_module()
diff --git a/tests/functional/d/deprecated/deprecated_methods_py38.py b/tests/functional/d/deprecated/deprecated_methods_py38.py
new file mode 100644
index 0000000..57047f9
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py38.py
@@ -0,0 +1,45 @@
+""" Functional tests for method deprecation. """
+# pylint: disable=missing-docstring, super-init-not-called, not-callable
+import base64
+import inspect
+import logging
+import nntplib
+import unittest
+import xml.etree.ElementTree
+
+
+class MyTest(unittest.TestCase):
+ def test(self):
+ self.assert_(True) # [deprecated-method]
+
+xml.etree.ElementTree.Element('tag').getchildren() # [deprecated-method]
+xml.etree.ElementTree.Element('tag').getiterator() # [deprecated-method]
+nntplib.NNTP(None).xpath(None) # [deprecated-method]
+
+
+inspect.getargspec(None) # [deprecated-method]
+logging.warn("a") # [deprecated-method]
+base64.encodestring("42") # [deprecated-method]
+base64.decodestring("42") # [deprecated-method]
+
+
+class SuperCrash(unittest.TestCase):
+
+ def __init__(self):
+ # should not crash.
+ super()()
+
+xml.etree.ElementTree.iterparse(None)
+
+
+class Tests(unittest.TestCase):
+
+ def test_foo(self):
+ self.assertEquals(2 + 2, 4) # [deprecated-method]
+ self.assertNotEquals(2 + 2, 4) # [deprecated-method]
+ self.assertAlmostEquals(2 + 2, 4) # [deprecated-method]
+ self.assertNotAlmostEquals(2 + 2, 4) # [deprecated-method]
+ self.assert_("abc" == "2") # [deprecated-method]
+
+ self.assertRaisesRegex(ValueError, "exception")
+ self.assertRegex("something", r".+")
diff --git a/tests/functional/d/deprecated/deprecated_methods_py38.rc b/tests/functional/d/deprecated/deprecated_methods_py38.rc
new file mode 100644
index 0000000..35b185f
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py38.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.8
+max_pyver=3.9
diff --git a/tests/functional/d/deprecated/deprecated_methods_py38.txt b/tests/functional/d/deprecated/deprecated_methods_py38.txt
new file mode 100644
index 0000000..00d7f7d
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py38.txt
@@ -0,0 +1,13 @@
+deprecated-method:13:8:MyTest.test:Using deprecated method assert_()
+deprecated-method:15:0::Using deprecated method getchildren()
+deprecated-method:16:0::Using deprecated method getiterator()
+deprecated-method:17:0::Using deprecated method xpath()
+deprecated-method:20:0::Using deprecated method getargspec()
+deprecated-method:21:0::Using deprecated method warn()
+deprecated-method:22:0::Using deprecated method encodestring()
+deprecated-method:23:0::Using deprecated method decodestring()
+deprecated-method:38:8:Tests.test_foo:Using deprecated method assertEquals()
+deprecated-method:39:8:Tests.test_foo:Using deprecated method assertNotEquals()
+deprecated-method:40:8:Tests.test_foo:Using deprecated method assertAlmostEquals()
+deprecated-method:41:8:Tests.test_foo:Using deprecated method assertNotAlmostEquals()
+deprecated-method:42:8:Tests.test_foo:Using deprecated method assert_()
diff --git a/tests/functional/d/deprecated/deprecated_module_py3.py b/tests/functional/d/deprecated/deprecated_module_py3.py
new file mode 100644
index 0000000..308d400
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py3.py
@@ -0,0 +1,4 @@
+"""Test deprecated modules."""
+# pylint: disable=unused-import
+
+import optparse # [deprecated-module]
diff --git a/tests/functional/d/deprecated/deprecated_module_py3.rc b/tests/functional/d/deprecated/deprecated_module_py3.rc
new file mode 100644
index 0000000..46343d2
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.0
+max_pyver=3.6
diff --git a/tests/functional/d/deprecated/deprecated_module_py3.txt b/tests/functional/d/deprecated/deprecated_module_py3.txt
new file mode 100644
index 0000000..79c0a41
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py3.txt
@@ -0,0 +1 @@
+deprecated-module:4:::Uses of a deprecated module 'optparse'
diff --git a/tests/functional/d/deprecated/deprecated_module_py36.py b/tests/functional/d/deprecated/deprecated_module_py36.py
new file mode 100644
index 0000000..c49f9f0
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py36.py
@@ -0,0 +1,4 @@
+"""Test deprecated modules from Python 3.6."""
+# pylint: disable=unused-import,import-error
+
+import optparse # [deprecated-module]
diff --git a/tests/functional/d/deprecated/deprecated_module_py36.rc b/tests/functional/d/deprecated/deprecated_module_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/d/deprecated/deprecated_module_py36.txt b/tests/functional/d/deprecated/deprecated_module_py36.txt
new file mode 100644
index 0000000..ab5f489
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py36.txt
@@ -0,0 +1 @@
+deprecated-module:4:0::Uses of a deprecated module 'optparse'
diff --git a/tests/functional/d/deprecated/deprecated_module_py4.py b/tests/functional/d/deprecated/deprecated_module_py4.py
new file mode 100644
index 0000000..3cad959
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py4.py
@@ -0,0 +1,4 @@
+"""Test deprecated modules."""
+
+from deprecated import foo # [deprecated-module]
+import deprecated # [deprecated-module]
diff --git a/tests/functional/d/deprecated/deprecated_module_py4.rc b/tests/functional/d/deprecated/deprecated_module_py4.rc
new file mode 100644
index 0000000..6fbd340
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py4.rc
@@ -0,0 +1,4 @@
+[Messages Control]
+deprecated-modules=deprecated
+disable=all
+enable=deprecated-module
diff --git a/tests/functional/d/deprecated/deprecated_module_py4.txt b/tests/functional/d/deprecated/deprecated_module_py4.txt
new file mode 100644
index 0000000..f4800d0
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py4.txt
@@ -0,0 +1,2 @@
+deprecated-module:3:0::Uses of a deprecated module 'deprecated'
+deprecated-module:4:0::Uses of a deprecated module 'deprecated'
diff --git a/tests/functional/d/deprecated/deprecated_module_uninstalled.py b/tests/functional/d/deprecated/deprecated_module_uninstalled.py
new file mode 100644
index 0000000..52d55fa
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_uninstalled.py
@@ -0,0 +1,5 @@
+"""Test deprecated modules uninstalled."""
+# pylint: disable=unused-import,no-name-in-module,import-error
+
+from uninstalled import uninstalled_module # [deprecated-module]
+import uninstalled # [deprecated-module]
diff --git a/tests/functional/d/deprecated/deprecated_module_uninstalled.rc b/tests/functional/d/deprecated/deprecated_module_uninstalled.rc
new file mode 100644
index 0000000..d68fc0b
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_uninstalled.rc
@@ -0,0 +1,2 @@
+[Messages Control]
+deprecated-modules=uninstalled
diff --git a/tests/functional/d/deprecated/deprecated_module_uninstalled.txt b/tests/functional/d/deprecated/deprecated_module_uninstalled.txt
new file mode 100644
index 0000000..7d9f01a
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_uninstalled.txt
@@ -0,0 +1,2 @@
+deprecated-module:4:0::Uses of a deprecated module 'uninstalled'
+deprecated-module:5:0::Uses of a deprecated module 'uninstalled'
diff --git a/tests/functional/d/dict_iter_missing_items.py b/tests/functional/d/dict_iter_missing_items.py
new file mode 100644
index 0000000..333f589
--- /dev/null
+++ b/tests/functional/d/dict_iter_missing_items.py
@@ -0,0 +1,23 @@
+# pylint: disable=invalid-name, consider-iterating-dictionary, missing-docstring, import-error
+from unknown import Uninferable
+
+d = {1: 1, 2: 2}
+l = [1, 2]
+s1 = {1, 2}
+s2 = {1, 2, 3}
+
+# Positive
+for k, v in d: # [dict-iter-missing-items]
+ pass
+
+# Negative
+for k, v in d.items():
+ pass
+for k in d.keys():
+ pass
+for i, v in enumerate(l):
+ pass
+for i, v in s1.intersection(s2):
+ pass
+for k, v in Uninferable:
+ pass
diff --git a/tests/functional/d/dict_iter_missing_items.txt b/tests/functional/d/dict_iter_missing_items.txt
new file mode 100644
index 0000000..3e1ed80
--- /dev/null
+++ b/tests/functional/d/dict_iter_missing_items.txt
@@ -0,0 +1 @@
+dict-iter-missing-items:10:0::Unpacking a dictionary in iteration without calling .items()
diff --git a/tests/functional/d/disable_msg_github_issue_1389.py b/tests/functional/d/disable_msg_github_issue_1389.py
new file mode 100644
index 0000000..5c7ad1e
--- /dev/null
+++ b/tests/functional/d/disable_msg_github_issue_1389.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+
+from typing import Dict, NamedTuple, NewType, Set
+
+UserId = NewType('UserId', str) # pylint: disable=invalid-name
+PlaceId = NewType('PlaceId', str) # pylint: disable=invalid-name
+
+
+class Bar(NamedTuple):
+ place: PlaceId
+ name: str
+
+
+class Foo(NamedTuple):
+ user: Dict[UserId, Set[Bar]]
diff --git a/tests/functional/d/disable_msg_github_issue_1389.rc b/tests/functional/d/disable_msg_github_issue_1389.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/d/disable_msg_github_issue_1389.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/d/disable_ungrouped_imports.py b/tests/functional/d/disable_ungrouped_imports.py
new file mode 100644
index 0000000..48c06c0
--- /dev/null
+++ b/tests/functional/d/disable_ungrouped_imports.py
@@ -0,0 +1,10 @@
+"""Checks that disabling 'ungrouped-imports' on an import prevents subsequent
+imports from being considered ungrouped in respect to it."""
+# pylint: disable=unused-import,wrong-import-position,wrong-import-order,using-constant-test
+# pylint: disable=import-error
+from os.path import basename
+import logging.config # pylint: disable=ungrouped-imports
+import os.path
+import logging
+from os.path import join # [ungrouped-imports]
+import logging.handlers # [ungrouped-imports]
diff --git a/tests/functional/d/disable_ungrouped_imports.txt b/tests/functional/d/disable_ungrouped_imports.txt
new file mode 100644
index 0000000..a5a0e02
--- /dev/null
+++ b/tests/functional/d/disable_ungrouped_imports.txt
@@ -0,0 +1,2 @@
+ungrouped-imports:9:0::Imports from package os are not grouped
+ungrouped-imports:10:0::Imports from package logging are not grouped
diff --git a/tests/functional/d/disable_wrong_import_order.py b/tests/functional/d/disable_wrong_import_order.py
new file mode 100644
index 0000000..1fdf83f
--- /dev/null
+++ b/tests/functional/d/disable_wrong_import_order.py
@@ -0,0 +1,11 @@
+"""Checks that disabling 'wrong-import-order' on an import prevents subsequent
+imports from being considered out-of-order in respect to it but does not prevent
+it from being considered for 'ungrouped-imports'."""
+# pylint: disable=unused-import,import-error,no-name-in-module
+
+from first_party.foo import bar # pylint: disable=wrong-import-order
+import logging
+import os.path
+import sys
+from astroid import are_exclusive
+from first_party.bar import foo # [ungrouped-imports]
diff --git a/tests/functional/d/disable_wrong_import_order.txt b/tests/functional/d/disable_wrong_import_order.txt
new file mode 100644
index 0000000..d0fcafb
--- /dev/null
+++ b/tests/functional/d/disable_wrong_import_order.txt
@@ -0,0 +1 @@
+ungrouped-imports:11:0::Imports from package first_party are not grouped
diff --git a/tests/functional/d/disable_wrong_import_position.py b/tests/functional/d/disable_wrong_import_position.py
new file mode 100644
index 0000000..0703325
--- /dev/null
+++ b/tests/functional/d/disable_wrong_import_position.py
@@ -0,0 +1,7 @@
+"""Checks that disabling 'wrong-import-position' on a statement prevents it from
+invalidating subsequent imports."""
+# pylint: disable=unused-import
+
+CONSTANT = True # pylint: disable=wrong-import-position
+
+import sys
diff --git a/tests/functional/d/disabled_msgid_in_pylintrc.py b/tests/functional/d/disabled_msgid_in_pylintrc.py
new file mode 100644
index 0000000..09ddf11
--- /dev/null
+++ b/tests/functional/d/disabled_msgid_in_pylintrc.py
@@ -0,0 +1,6 @@
+"""https://github.com/PyCQA/pylint/issues/4265"""
+
+try:
+ f = open('test')
+except Exception:
+ pass
diff --git a/tests/functional/d/disabled_msgid_in_pylintrc.rc b/tests/functional/d/disabled_msgid_in_pylintrc.rc
new file mode 100644
index 0000000..6a584cb
--- /dev/null
+++ b/tests/functional/d/disabled_msgid_in_pylintrc.rc
@@ -0,0 +1,4 @@
+[MESSAGES CONTROL]
+
+disable=
+ C0111,C0326,W0703,R1732
diff --git a/tests/functional/d/docstrings.py b/tests/functional/d/docstrings.py
new file mode 100644
index 0000000..e466a00
--- /dev/null
+++ b/tests/functional/d/docstrings.py
@@ -0,0 +1,90 @@
+# pylint: disable=no-self-use, useless-object-inheritance, unnecessary-pass
+# -1: [missing-module-docstring]
+from __future__ import print_function
+
+# +1: [empty-docstring]
+def function0():
+ """"""
+
+# +1: [missing-function-docstring]
+def function1(value):
+ # missing docstring
+ print(value)
+
+def function2(value):
+ """docstring"""
+ print(value)
+
+def function3(value):
+ """docstring"""
+ print(value)
+
+# +1: [missing-class-docstring]
+class AAAA(object):
+ # missing docstring
+
+## class BBBB:
+## # missing docstring
+## pass
+
+## class CCCC:
+## """yeah !"""
+## def method1(self):
+## pass
+
+## def method2(self):
+## """ yeah !"""
+## pass
+
+ # +1: [missing-function-docstring]
+ def method1(self):
+ pass
+
+ def method2(self):
+ """ yeah !"""
+ pass
+
+ # +1: [empty-docstring]
+ def method3(self):
+ """"""
+ pass
+
+ def __init__(self):
+ pass
+
+class DDDD(AAAA):
+ """yeah !"""
+
+ def __init__(self):
+ AAAA.__init__(self)
+
+ # +1: [empty-docstring]
+ def method2(self):
+ """"""
+ pass
+
+ def method3(self):
+ pass
+
+ # +1: [missing-function-docstring]
+ def method4(self):
+ pass
+
+# pylint: disable=missing-docstring
+def function4():
+ pass
+
+# pylint: disable=empty-docstring
+def function5():
+ """"""
+ pass
+
+def function6():
+ """ I am a {} docstring.""".format("good")
+
+def function7():
+ """docstring"""
+ def inner():
+ # Not documented
+ return 42
+ return inner()
diff --git a/tests/functional/d/docstrings.txt b/tests/functional/d/docstrings.txt
new file mode 100644
index 0000000..e8bb2f3
--- /dev/null
+++ b/tests/functional/d/docstrings.txt
@@ -0,0 +1,8 @@
+missing-module-docstring:1:0::Missing module docstring
+empty-docstring:6:0:function0:Empty function docstring
+missing-function-docstring:10:0:function1:Missing function or method docstring
+missing-class-docstring:23:0:AAAA:Missing class docstring
+missing-function-docstring:40:4:AAAA.method1:Missing function or method docstring:INFERENCE
+empty-docstring:48:4:AAAA.method3:Empty method docstring:INFERENCE
+empty-docstring:62:4:DDDD.method2:Empty method docstring:INFERENCE
+missing-function-docstring:70:4:DDDD.method4:Missing function or method docstring:INFERENCE
diff --git a/tests/functional/d/dotted_ancestor.py b/tests/functional/d/dotted_ancestor.py
new file mode 100644
index 0000000..2c82d89
--- /dev/null
+++ b/tests/functional/d/dotted_ancestor.py
@@ -0,0 +1,11 @@
+"""bla"""
+# pylint: disable=no-absolute-import
+
+from ..n.non import non_init_parent_called
+
+__revision__ = 'yo'
+
+class Aaaa(non_init_parent_called.AAAA): # [too-few-public-methods]
+ """test dotted name in ancestors"""
+ def __init__(self):
+ non_init_parent_called.AAAA.__init__(self)
diff --git a/tests/functional/d/dotted_ancestor.txt b/tests/functional/d/dotted_ancestor.txt
new file mode 100644
index 0000000..4aa47e7
--- /dev/null
+++ b/tests/functional/d/dotted_ancestor.txt
@@ -0,0 +1 @@
+too-few-public-methods:8:0:Aaaa:Too few public methods (0/2)
diff --git a/tests/functional/d/duplicate_argument_name.py b/tests/functional/d/duplicate_argument_name.py
new file mode 100644
index 0000000..c60b117
--- /dev/null
+++ b/tests/functional/d/duplicate_argument_name.py
@@ -0,0 +1,14 @@
+"""Check for duplicate function arguments."""
+
+
+def foo1(_, _): # [duplicate-argument-name, duplicate-argument-name]
+ """Function with duplicate argument name."""
+
+def foo2(_abc, *, _abc): # [duplicate-argument-name, duplicate-argument-name]
+ """Function with duplicate argument name."""
+
+def foo3(_, _=3): # [duplicate-argument-name, duplicate-argument-name]
+ """Function with duplicate argument name."""
+
+def foo4(_, *, _): # [duplicate-argument-name, duplicate-argument-name]
+ """Function with duplicate argument name."""
diff --git a/tests/functional/d/duplicate_argument_name.txt b/tests/functional/d/duplicate_argument_name.txt
new file mode 100644
index 0000000..a8321d9
--- /dev/null
+++ b/tests/functional/d/duplicate_argument_name.txt
@@ -0,0 +1,8 @@
+duplicate-argument-name:4:9:foo1:Duplicate argument name _ in function definition
+duplicate-argument-name:4:12:foo1:Duplicate argument name _ in function definition
+duplicate-argument-name:7:9:foo2:Duplicate argument name _abc in function definition
+duplicate-argument-name:7:18:foo2:Duplicate argument name _abc in function definition
+duplicate-argument-name:10:9:foo3:Duplicate argument name _ in function definition
+duplicate-argument-name:10:12:foo3:Duplicate argument name _ in function definition
+duplicate-argument-name:13:9:foo4:Duplicate argument name _ in function definition
+duplicate-argument-name:13:15:foo4:Duplicate argument name _ in function definition
diff --git a/tests/functional/d/duplicate_argument_name_py3.py b/tests/functional/d/duplicate_argument_name_py3.py
new file mode 100644
index 0000000..c7fbe34
--- /dev/null
+++ b/tests/functional/d/duplicate_argument_name_py3.py
@@ -0,0 +1,5 @@
+"""Check for duplicate function keywordonly arguments."""
+
+
+def foo1(_, *_, _=3): # [duplicate-argument-name, duplicate-argument-name]
+ """Function with duplicate argument name."""
diff --git a/tests/functional/d/duplicate_argument_name_py3.rc b/tests/functional/d/duplicate_argument_name_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/d/duplicate_argument_name_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/d/duplicate_argument_name_py3.txt b/tests/functional/d/duplicate_argument_name_py3.txt
new file mode 100644
index 0000000..6942faa
--- /dev/null
+++ b/tests/functional/d/duplicate_argument_name_py3.txt
@@ -0,0 +1,2 @@
+duplicate-argument-name:4:9:foo1:Duplicate argument name _ in function definition
+duplicate-argument-name:4:16:foo1:Duplicate argument name _ in function definition
diff --git a/tests/functional/d/duplicate_bases.py b/tests/functional/d/duplicate_bases.py
new file mode 100644
index 0000000..51b329a
--- /dev/null
+++ b/tests/functional/d/duplicate_bases.py
@@ -0,0 +1,18 @@
+"""Test duplicate bases error."""
+# pylint: disable=missing-docstring,too-few-public-methods,no-init
+
+
+class Duplicates(str, str): # [duplicate-bases]
+ pass
+
+
+class Alpha(str):
+ pass
+
+
+class NotDuplicates(Alpha, str):
+ """The error should not be emitted for this case, since the
+ other same base comes from the ancestors."""
+
+
+print(Duplicates.__mro__)
diff --git a/tests/functional/d/duplicate_bases.txt b/tests/functional/d/duplicate_bases.txt
new file mode 100644
index 0000000..651086f
--- /dev/null
+++ b/tests/functional/d/duplicate_bases.txt
@@ -0,0 +1 @@
+duplicate-bases:5:0:Duplicates:Duplicate bases for class 'Duplicates'
diff --git a/tests/functional/d/duplicate_dict_literal_key.py b/tests/functional/d/duplicate_dict_literal_key.py
new file mode 100644
index 0000000..67eab28
--- /dev/null
+++ b/tests/functional/d/duplicate_dict_literal_key.py
@@ -0,0 +1,17 @@
+"""Check multiple key definition"""
+# pylint: disable=pointless-statement
+
+correct_dict = {
+ 'tea': 'for two',
+ 'two': 'for tea',
+}
+
+wrong_dict = { # [duplicate-key]
+ 'tea': 'for two',
+ 'two': 'for tea',
+ 'tea': 'time',
+
+}
+
+{1: b'a', 1: u'a'} # [duplicate-key]
+{1: 1, 1.0: 2} # [duplicate-key]
diff --git a/tests/functional/d/duplicate_dict_literal_key.txt b/tests/functional/d/duplicate_dict_literal_key.txt
new file mode 100644
index 0000000..756f158
--- /dev/null
+++ b/tests/functional/d/duplicate_dict_literal_key.txt
@@ -0,0 +1,3 @@
+duplicate-key:9:13::Duplicate key 'tea' in dictionary
+duplicate-key:16:0::Duplicate key 1 in dictionary
+duplicate-key:17:0::Duplicate key 1.0 in dictionary
diff --git a/tests/functional/d/duplicate_except.py b/tests/functional/d/duplicate_except.py
new file mode 100644
index 0000000..c68cf7a
--- /dev/null
+++ b/tests/functional/d/duplicate_except.py
@@ -0,0 +1,12 @@
+"""Test for duplicate-check."""
+
+def main():
+ """The second ValueError should be flagged."""
+ try:
+ raise ValueError('test')
+ except ValueError:
+ return 1
+ except ValueError: # [duplicate-except]
+ return 2
+ except (OSError, TypeError):
+ return 3
diff --git a/tests/functional/d/duplicate_except.txt b/tests/functional/d/duplicate_except.txt
new file mode 100644
index 0000000..cf8df9e
--- /dev/null
+++ b/tests/functional/d/duplicate_except.txt
@@ -0,0 +1 @@
+duplicate-except:9:11:main:Catching previously caught exception type ValueError
diff --git a/tests/functional/d/duplicate_string_formatting_argument.py b/tests/functional/d/duplicate_string_formatting_argument.py
new file mode 100644
index 0000000..b012f98
--- /dev/null
+++ b/tests/functional/d/duplicate_string_formatting_argument.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring
+
+NAME = 42
+OTHER_NAME = 24
+OTHER_OTHER_NAME = 2
+
+# +1: [duplicate-string-formatting-argument,duplicate-string-formatting-argument]
+CONST = "some value {} some other value {} {} {} {} {}".format(
+ NAME,
+ NAME,
+ OTHER_NAME,
+ OTHER_NAME,
+ OTHER_NAME,
+ OTHER_OTHER_NAME,
+)
diff --git a/tests/functional/d/duplicate_string_formatting_argument.txt b/tests/functional/d/duplicate_string_formatting_argument.txt
new file mode 100644
index 0000000..fdc4386
--- /dev/null
+++ b/tests/functional/d/duplicate_string_formatting_argument.txt
@@ -0,0 +1,2 @@
+duplicate-string-formatting-argument:8:8::Duplicate string formatting argument 'NAME', consider passing as named argument
+duplicate-string-formatting-argument:8:8::Duplicate string formatting argument 'OTHER_NAME', consider passing as named argument
diff --git a/tests/functional/e/__init__.py b/tests/functional/e/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/e/__init__.py
diff --git a/tests/functional/e/e1101_9588_base_attr_aug_assign.py b/tests/functional/e/e1101_9588_base_attr_aug_assign.py
new file mode 100644
index 0000000..7306840
--- /dev/null
+++ b/tests/functional/e/e1101_9588_base_attr_aug_assign.py
@@ -0,0 +1,38 @@
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+"""
+False positive case of E1101:
+
+The error is triggered when the attribute set in the base class is
+modified with augmented assignment in a derived class.
+
+https://www.logilab.org/ticket/9588
+"""
+__revision__ = 0
+
+class BaseClass(object):
+ "The base class"
+ def __init__(self):
+ "Set an attribute."
+ self.e1101 = 1
+
+class FalsePositiveClass(BaseClass):
+ "The first derived class which triggers the false positive"
+ def __init__(self):
+ "Augmented assignment triggers E1101."
+ BaseClass.__init__(self)
+ self.e1101 += 1
+
+ def countup(self):
+ "Consequently this also triggers E1101."
+ self.e1101 += 1
+
+class NegativeClass(BaseClass):
+ "The second derived class, which does not trigger the error E1101"
+ def __init__(self):
+ "Ordinary assignment is OK."
+ BaseClass.__init__(self)
+ self.e1101 = self.e1101 + 1
+
+ def countup(self):
+ "No problem."
+ self.e1101 += 1
diff --git a/tests/functional/e/enum_subclasses.py b/tests/functional/e/enum_subclasses.py
new file mode 100644
index 0000000..395cb24
--- /dev/null
+++ b/tests/functional/e/enum_subclasses.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring
+from enum import Enum, IntEnum
+
+
+class Issue1932(IntEnum):
+ """https://github.com/PyCQA/pylint/issues/1932"""
+ FOO = 1
+
+ def whats_my_name(self):
+ return self.name.lower()
+
+
+class Issue2062(Enum):
+ """https://github.com/PyCQA/pylint/issues/2062"""
+ FOO = 1
+ BAR = 2
+
+ def __str__(self):
+ return self.name.lower()
diff --git a/tests/functional/e/eval_used.py b/tests/functional/e/eval_used.py
new file mode 100644
index 0000000..d03dad7
--- /dev/null
+++ b/tests/functional/e/eval_used.py
@@ -0,0 +1,10 @@
+"""test for eval usage"""
+
+eval('os.listdir(".")') # [eval-used]
+eval('os.listdir(".")', globals={}) # [eval-used]
+
+eval('os.listdir(".")', globals=globals()) # [eval-used]
+
+def func():
+ """ eval in local scope"""
+ eval('b = 1') # [eval-used]
diff --git a/tests/functional/e/eval_used.txt b/tests/functional/e/eval_used.txt
new file mode 100644
index 0000000..f8cdc5f
--- /dev/null
+++ b/tests/functional/e/eval_used.txt
@@ -0,0 +1,4 @@
+eval-used:3:0::Use of eval
+eval-used:4:0::Use of eval
+eval-used:6:0::Use of eval
+eval-used:10:4:func:Use of eval
diff --git a/tests/functional/e/exception_is_binary_op.py b/tests/functional/e/exception_is_binary_op.py
new file mode 100644
index 0000000..f71163d
--- /dev/null
+++ b/tests/functional/e/exception_is_binary_op.py
@@ -0,0 +1,12 @@
+"""Warn about binary operations used as exceptions."""
+from __future__ import print_function
+try:
+ pass
+except Exception or BaseException: # [binary-op-exception]
+ print("caught1")
+except Exception and BaseException: # [binary-op-exception]
+ print("caught2")
+except Exception or BaseException: # [binary-op-exception]
+ print("caught3")
+except (Exception or BaseException) as exc: # [binary-op-exception]
+ print("caught4")
diff --git a/tests/functional/e/exception_is_binary_op.txt b/tests/functional/e/exception_is_binary_op.txt
new file mode 100644
index 0000000..1395c67
--- /dev/null
+++ b/tests/functional/e/exception_is_binary_op.txt
@@ -0,0 +1,4 @@
+binary-op-exception:5:0::"Exception to catch is the result of a binary ""or"" operation"
+binary-op-exception:7:0::"Exception to catch is the result of a binary ""and"" operation"
+binary-op-exception:9:0::"Exception to catch is the result of a binary ""or"" operation"
+binary-op-exception:11:0::"Exception to catch is the result of a binary ""or"" operation"
diff --git a/tests/functional/e/excess_escapes.py b/tests/functional/e/excess_escapes.py
new file mode 100644
index 0000000..04fa4db
--- /dev/null
+++ b/tests/functional/e/excess_escapes.py
@@ -0,0 +1,32 @@
+# pylint:disable=pointless-string-statement, fixme, misplaced-comparison-constant, comparison-with-itself
+"""Stray backslash escapes may be missing a raw-string prefix."""
+
+__revision__ = '$Id$'
+
+# Bad escape sequences, which probably don't do what you expect.
+A = "\[\]\\" # [anomalous-backslash-in-string,anomalous-backslash-in-string]
+assert '\/' == '\\/' # [anomalous-backslash-in-string]
+ESCAPE_BACKSLASH = '\`' # [anomalous-backslash-in-string]
+
+# Valid escape sequences.
+NEWLINE = "\n"
+OLD_ESCAPES = '\a\b\f\n\t\r\v'
+HEX = '\xad\x0a\x0d'
+# +1:[anomalous-backslash-in-string,anomalous-backslash-in-string]
+FALSE_OCTAL = '\o123\o000' # Not octal in Python
+OCTAL = '\123\000'
+NOT_OCTAL = '\888\999' # [anomalous-backslash-in-string,anomalous-backslash-in-string]
+NUL = '\0'
+UNICODE = u'\u1234'
+HIGH_UNICODE = u'\U0000abcd'
+QUOTES = '\'\"'
+LITERAL_NEWLINE = '\
+'
+ESCAPE_UNICODE = "\\\\n"
+
+# Bad docstring
+# +3:[anomalous-backslash-in-string]
+"""Even in a docstring
+
+You shouldn't have ambiguous text like: C:\Program Files\alpha
+"""
diff --git a/tests/functional/e/excess_escapes.txt b/tests/functional/e/excess_escapes.txt
new file mode 100644
index 0000000..20fa552
--- /dev/null
+++ b/tests/functional/e/excess_escapes.txt
@@ -0,0 +1,9 @@
+anomalous-backslash-in-string:7:5::"Anomalous backslash in string: '\['. String constant might be missing an r prefix."
+anomalous-backslash-in-string:7:7::"Anomalous backslash in string: '\]'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:8:8::"Anomalous backslash in string: '\/'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:9:20::"Anomalous backslash in string: '\`'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:16:15::"Anomalous backslash in string: '\o'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:16:20::"Anomalous backslash in string: '\o'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:18:13::"Anomalous backslash in string: '\8'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:18:17::"Anomalous backslash in string: '\9'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:31:42::"Anomalous backslash in string: '\P'. String constant might be missing an r prefix."
diff --git a/tests/functional/e/exec_used_py3.py b/tests/functional/e/exec_used_py3.py
new file mode 100644
index 0000000..5f84948
--- /dev/null
+++ b/tests/functional/e/exec_used_py3.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring
+
+exec('a = __revision__') # [exec-used]
+exec('a = 1', globals={}) # [exec-used]
+
+exec('a = 1', globals=globals()) # [exec-used]
+
+def func():
+ exec('b = 1') # [exec-used]
diff --git a/tests/functional/e/exec_used_py3.rc b/tests/functional/e/exec_used_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/e/exec_used_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/e/exec_used_py3.txt b/tests/functional/e/exec_used_py3.txt
new file mode 100644
index 0000000..ebfab1c
--- /dev/null
+++ b/tests/functional/e/exec_used_py3.txt
@@ -0,0 +1,4 @@
+exec-used:3:0::Use of exec
+exec-used:4:0::Use of exec
+exec-used:6:0::Use of exec
+exec-used:9:4:func:Use of exec
diff --git a/tests/functional/e/external_classmethod_crash.py b/tests/functional/e/external_classmethod_crash.py
new file mode 100644
index 0000000..7f6b927
--- /dev/null
+++ b/tests/functional/e/external_classmethod_crash.py
@@ -0,0 +1,21 @@
+# pylint: disable=no-init,too-few-public-methods,unused-argument,useless-object-inheritance
+"""tagging a function as a class method cause a crash when checking for
+signature overriding
+"""
+
+def fetch_config(mainattr=None):
+ """return a class method"""
+
+ def fetch_order(cls, attr, var):
+ """a class method"""
+ if attr == mainattr:
+ return var
+ return None
+ fetch_order = classmethod(fetch_order)
+ return fetch_order
+
+class Aaa(object):
+ """hop"""
+ fetch_order = fetch_config('A')
+
+__revision__ = None
diff --git a/tests/functional/ext/bad_builtins.py b/tests/functional/ext/bad_builtins.py
new file mode 100644
index 0000000..9737e0f
--- /dev/null
+++ b/tests/functional/ext/bad_builtins.py
@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+input("Yes or no ? (Y=1, n=0)") # [bad-builtin]
+print(map(str, filter(1, [1, 2, 3]))) # [bad-builtin, bad-builtin, bad-builtin]
diff --git a/tests/functional/ext/bad_builtins.rc b/tests/functional/ext/bad_builtins.rc
new file mode 100644
index 0000000..e32b9f3
--- /dev/null
+++ b/tests/functional/ext/bad_builtins.rc
@@ -0,0 +1,5 @@
+[MASTER]
+load-plugins = pylint.extensions.bad_builtin
+
+[pylint.DEPRECATED_BUILTINS]
+bad-functions=map,input,filter,print
diff --git a/tests/functional/ext/bad_builtins.txt b/tests/functional/ext/bad_builtins.txt
new file mode 100644
index 0000000..093b1d1
--- /dev/null
+++ b/tests/functional/ext/bad_builtins.txt
@@ -0,0 +1,4 @@
+bad-builtin:2:0::Used builtin function 'input'
+bad-builtin:3:15::Used builtin function 'filter'. Using a list comprehension can be clearer.
+bad-builtin:3:6::Used builtin function 'map'. Using a list comprehension can be clearer.
+bad-builtin:3:0::Used builtin function 'print'
diff --git a/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.py b/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.py
new file mode 100644
index 0000000..627de76
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.py
@@ -0,0 +1,74 @@
+# pylint: disable=missing-docstring,too-few-public-methods,unused-variable,no-name-in-module
+from typing import Final
+
+class Foo:
+ BAR = "bar"
+
+KEY_3 = "key_3"
+
+
+# Subdicts have at least 1 common key
+MAPPING_1 = { # [consider-using-namedtuple-or-dataclass]
+ "entry_1": {"key_1": 0, "key_2": 1, "key_diff_1": 2},
+ "entry_2": {"key_1": 0, "key_2": 1, "key_diff_2": 3},
+}
+MAPPING_2 = { # [consider-using-namedtuple-or-dataclass]
+ "entry_1": {KEY_3: None, Foo.BAR: None},
+ "entry_2": {KEY_3: None, Foo.BAR: None},
+}
+
+# ints are not valid fieldnames for namedtuples
+MAPPING_3 = {
+ "entry_1": {0: None, 1: None},
+ "entry_2": {0: None, 1: None},
+}
+
+
+def func():
+ # Not in module scope
+ mapping_4 = {
+ "entry_1": {"key_1": 0, "key_2": 1},
+ "entry_2": {"key_1": 0, "key_2": 1},
+ }
+
+ mapping_5: Final = { # [consider-using-namedtuple-or-dataclass]
+ "entry_1": {"key_1": 0, "key_2": 1},
+ "entry_2": {"key_1": 0, "key_2": 1},
+ }
+
+
+# lists must have the same length
+MAPPING_6 = { # [consider-using-namedtuple-or-dataclass]
+ "entry_1": [1, "a", set()],
+ "entry_2": [2, "b", set()],
+}
+MAPPING_7 = {
+ "entry_1": [],
+ "entry_2": [],
+}
+MAPPING_8 = {
+ "entry_1": [1],
+ "entry_2": [2, "b"],
+}
+MAPPING_9 = { # [consider-using-namedtuple-or-dataclass]
+ "entry_1": (1, "a"),
+ "entry_2": (2, "b"),
+}
+
+# No entry can't contain only dicts
+MAPPING_10 = {
+ "entry_1": [
+ {"key_1": None, "key_2": None},
+ ],
+ "entry_2": [None]
+}
+
+# No either dict, tuple, or list as dict values
+MAPPING_11 = {
+ "entry_1": 1,
+ "entry_2": 2,
+}
+MAPPING_12 = {
+ "entry_1": "",
+ "entry_2": "",
+}
diff --git a/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.rc b/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.rc
new file mode 100644
index 0000000..47767a2
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.rc
@@ -0,0 +1,2 @@
+[MASTER]
+load-plugins=pylint.extensions.code_style
diff --git a/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.txt b/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.txt
new file mode 100644
index 0000000..6c471db
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_namedtuple_or_dataclass.txt
@@ -0,0 +1,5 @@
+consider-using-namedtuple-or-dataclass:11:12::Consider using namedtuple or dataclass for dictionary values
+consider-using-namedtuple-or-dataclass:15:12::Consider using namedtuple or dataclass for dictionary values
+consider-using-namedtuple-or-dataclass:34:23:func:Consider using namedtuple or dataclass for dictionary values
+consider-using-namedtuple-or-dataclass:41:12::Consider using namedtuple or dataclass for dictionary values
+consider-using-namedtuple-or-dataclass:53:12::Consider using namedtuple or dataclass for dictionary values
diff --git a/tests/functional/ext/code_style/code_style_consider_using_tuple.py b/tests/functional/ext/code_style/code_style_consider_using_tuple.py
new file mode 100644
index 0000000..679ef77
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_tuple.py
@@ -0,0 +1,29 @@
+# pylint: disable=invalid-name,missing-docstring,pointless-statement,unnecessary-comprehension
+
+var = (1, 2, 3)
+
+for x in var:
+ pass
+for x in (1, 2, 3):
+ pass
+for x in [1, 2, 3]: # [consider-using-tuple]
+ pass
+
+(x for x in var)
+(x for x in (1, 2, 3))
+(x for x in [1, 2, 3]) # [consider-using-tuple]
+(x for x in {1, 2, 3}) # [consider-using-tuple]
+
+[x for x in var]
+[x for x in (1, 2, 3)]
+[x for x in [1, 2, 3]] # [consider-using-tuple]
+
+
+# list/set can't be replaced if tuple unpacking is used
+for x in [*var]:
+ pass
+for x in [2, *var]:
+ pass
+
+[x for x in [*var, 2]]
+[x for x in {*var, 2}]
diff --git a/tests/functional/ext/code_style/code_style_consider_using_tuple.rc b/tests/functional/ext/code_style/code_style_consider_using_tuple.rc
new file mode 100644
index 0000000..47767a2
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_tuple.rc
@@ -0,0 +1,2 @@
+[MASTER]
+load-plugins=pylint.extensions.code_style
diff --git a/tests/functional/ext/code_style/code_style_consider_using_tuple.txt b/tests/functional/ext/code_style/code_style_consider_using_tuple.txt
new file mode 100644
index 0000000..df796b6
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_tuple.txt
@@ -0,0 +1,4 @@
+consider-using-tuple:9:9::Consider using an in-place tuple instead of list
+consider-using-tuple:14:12::Consider using an in-place tuple instead of list
+consider-using-tuple:15:12::Consider using an in-place tuple instead of set
+consider-using-tuple:19:12::Consider using an in-place tuple instead of list
diff --git a/tests/functional/ext/confusing_elif.py b/tests/functional/ext/confusing_elif.py
new file mode 100644
index 0000000..9f1d1ff
--- /dev/null
+++ b/tests/functional/ext/confusing_elif.py
@@ -0,0 +1,41 @@
+# pylint: disable=missing-module-docstring, missing-function-docstring
+
+def check_config(machine, old_conf, new_conf):
+ """Example code that will trigger the message"""
+ if old_conf:
+ if not new_conf:
+ machine.disable()
+ elif old_conf.value != new_conf.value:
+ machine.disable()
+ machine.enable(new_conf.value)
+ elif new_conf: # [confusing-consecutive-elif]
+ machine.enable(new_conf.value)
+
+
+def check_config_2(machine, old_conf, new_conf):
+ """Example code must not trigger the message, because the inner block ends with else."""
+ if old_conf:
+ if not new_conf:
+ machine.disable()
+ elif old_conf.value != new_conf.value:
+ machine.disable()
+ machine.enable(new_conf.value)
+ else:
+ pass
+ elif new_conf:
+ machine.enable(new_conf.value)
+
+def check_config_3(machine, old_conf, new_conf):
+ """
+ Example code must not trigger the message,
+ because the inner if is not the final node of the body.
+ """
+ if old_conf:
+ if not new_conf:
+ machine.disable()
+ elif old_conf.value != new_conf.value:
+ machine.disable()
+ machine.enable(new_conf.value)
+ print("Processed old configuration...")
+ elif new_conf:
+ machine.enable(new_conf.value)
diff --git a/tests/functional/ext/confusing_elif.rc b/tests/functional/ext/confusing_elif.rc
new file mode 100644
index 0000000..6a11b2c
--- /dev/null
+++ b/tests/functional/ext/confusing_elif.rc
@@ -0,0 +1,2 @@
+[MASTER]
+load-plugins=pylint.extensions.confusing_elif
diff --git a/tests/functional/ext/confusing_elif.txt b/tests/functional/ext/confusing_elif.txt
new file mode 100644
index 0000000..55cc0d1
--- /dev/null
+++ b/tests/functional/ext/confusing_elif.txt
@@ -0,0 +1 @@
+confusing-consecutive-elif:11:4:check_config:Consecutive elif with differing indentation level, consider creating a function to separate the inner elif
diff --git a/tests/functional/ext/docparams.py b/tests/functional/ext/docparams.py
new file mode 100644
index 0000000..b879afc
--- /dev/null
+++ b/tests/functional/ext/docparams.py
@@ -0,0 +1,11 @@
+"""Fixture for testing missing documentation in docparams."""
+
+
+def _private_func(param1): # [missing-return-doc, missing-return-type-doc]
+ if param1:
+ raise Exception('Example')
+ return param1
+
+
+def _private_func2(param1): # [missing-yield-doc, missing-yield-type-doc]
+ yield param1
diff --git a/tests/functional/ext/docparams.rc b/tests/functional/ext/docparams.rc
new file mode 100644
index 0000000..eda78b6
--- /dev/null
+++ b/tests/functional/ext/docparams.rc
@@ -0,0 +1,8 @@
+[MASTER]
+load-plugins = pylint.extensions.docparams
+
+[BASIC]
+accept-no-param-doc = no
+accept-no-raise-doc = no
+accept-no-return-doc = no
+accept-no-yields-doc = no
diff --git a/tests/functional/ext/docparams.txt b/tests/functional/ext/docparams.txt
new file mode 100644
index 0000000..5eb3278
--- /dev/null
+++ b/tests/functional/ext/docparams.txt
@@ -0,0 +1,4 @@
+missing-return-doc:4:0:_private_func:Missing return documentation
+missing-return-type-doc:4:0:_private_func:Missing return type documentation
+missing-yield-doc:10:0:_private_func2:Missing yield documentation
+missing-yield-type-doc:10:0:_private_func2:Missing yield type documentation
diff --git a/tests/functional/ext/typing/typing_consider_using_alias.py b/tests/functional/ext/typing/typing_consider_using_alias.py
new file mode 100644
index 0000000..7549dd2
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_alias.py
@@ -0,0 +1,61 @@
+"""Test pylint.extension.typing - consider-using-alias
+
+'py-version' needs to be set to '3.7' or '3.8' and 'runtime-typing=no'.
+With 'from __future__ import annotations' present.
+"""
+# pylint: disable=missing-docstring,invalid-name,unused-argument,line-too-long
+from __future__ import annotations
+
+import collections
+import collections.abc
+import typing
+from collections.abc import Awaitable
+from dataclasses import dataclass
+from typing import Dict, List, Set, Union, TypedDict
+
+var1: typing.Dict[str, int] # [consider-using-alias]
+var2: List[int] # [consider-using-alias]
+var3: collections.abc.Iterable[int]
+var4: typing.OrderedDict[str, int] # [consider-using-alias]
+var5: typing.Awaitable[None] # [consider-using-alias]
+var6: typing.Iterable[int] # [consider-using-alias]
+var7: typing.Hashable # [consider-using-alias]
+var8: typing.ContextManager[str] # [consider-using-alias]
+var9: typing.Pattern[str] # [consider-using-alias]
+var10: typing.re.Match[str] # [consider-using-alias]
+var11: list[int]
+var12: collections.abc
+var13: Awaitable[None]
+var14: collections.defaultdict[str, str]
+
+Alias1 = Set[int]
+Alias2 = Dict[int, List[int]]
+Alias3 = Union[int, typing.List[str]]
+Alias4 = List # [consider-using-alias]
+
+def func1(arg1: List[int], /, *args: List[int], arg2: set[int], **kwargs: Dict[str, int]) -> typing.Tuple[int]:
+ # -1:[consider-using-alias,consider-using-alias,consider-using-alias,consider-using-alias]
+ pass
+
+def func2(arg1: list[int]) -> tuple[int, int]:
+ pass
+
+class CustomIntList(typing.List[int]):
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(List[int], cast_variable)
+
+(lambda x: 2)(List[int])
+
+class CustomNamedTuple(typing.NamedTuple):
+ my_var: List[int] # [consider-using-alias]
+
+CustomTypedDict1 = TypedDict("CustomTypedDict1", my_var=List[int])
+
+class CustomTypedDict2(TypedDict):
+ my_var: List[int] # [consider-using-alias]
+
+@dataclass
+class CustomDataClass:
+ my_var: List[int] # [consider-using-alias]
diff --git a/tests/functional/ext/typing/typing_consider_using_alias.rc b/tests/functional/ext/typing/typing_consider_using_alias.rc
new file mode 100644
index 0000000..e1f43ca
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_alias.rc
@@ -0,0 +1,9 @@
+[master]
+load-plugins=pylint.extensions.typing
+
+[testoptions]
+min_pyver=3.8
+
+[typing]
+py-version=3.7
+runtime-typing=no
diff --git a/tests/functional/ext/typing/typing_consider_using_alias.txt b/tests/functional/ext/typing/typing_consider_using_alias.txt
new file mode 100644
index 0000000..2ae1378
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_alias.txt
@@ -0,0 +1,17 @@
+consider-using-alias:16:6::'typing.Dict' will be deprecated with PY39, consider using 'dict' instead
+consider-using-alias:17:6::'typing.List' will be deprecated with PY39, consider using 'list' instead
+consider-using-alias:19:6::'typing.OrderedDict' will be deprecated with PY39, consider using 'collections.OrderedDict' instead
+consider-using-alias:20:6::'typing.Awaitable' will be deprecated with PY39, consider using 'collections.abc.Awaitable' instead
+consider-using-alias:21:6::'typing.Iterable' will be deprecated with PY39, consider using 'collections.abc.Iterable' instead
+consider-using-alias:22:6::'typing.Hashable' will be deprecated with PY39, consider using 'collections.abc.Hashable' instead
+consider-using-alias:23:6::'typing.ContextManager' will be deprecated with PY39, consider using 'contextlib.AbstractContextManager' instead
+consider-using-alias:24:6::'typing.Pattern' will be deprecated with PY39, consider using 're.Pattern' instead
+consider-using-alias:25:7::'typing.Match' will be deprecated with PY39, consider using 're.Match' instead
+consider-using-alias:34:9::'typing.List' will be deprecated with PY39, consider using 'list' instead
+consider-using-alias:36:74:func1:'typing.Dict' will be deprecated with PY39, consider using 'dict' instead
+consider-using-alias:36:16:func1:'typing.List' will be deprecated with PY39, consider using 'list' instead
+consider-using-alias:36:37:func1:'typing.List' will be deprecated with PY39, consider using 'list' instead
+consider-using-alias:36:93:func1:'typing.Tuple' will be deprecated with PY39, consider using 'tuple' instead
+consider-using-alias:52:12:CustomNamedTuple:'typing.List' will be deprecated with PY39, consider using 'list' instead
+consider-using-alias:57:12:CustomTypedDict2:'typing.List' will be deprecated with PY39, consider using 'list' instead
+consider-using-alias:61:12:CustomDataClass:'typing.List' will be deprecated with PY39, consider using 'list' instead
diff --git a/tests/functional/ext/typing/typing_consider_using_alias_without_future.py b/tests/functional/ext/typing/typing_consider_using_alias_without_future.py
new file mode 100644
index 0000000..44f55b8
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_alias_without_future.py
@@ -0,0 +1,58 @@
+"""Test pylint.extension.typing - consider-using-alias
+
+'py-version' needs to be set to '3.7' or '3.8' and 'runtime-typing=no'.
+"""
+# pylint: disable=missing-docstring,invalid-name,unused-argument,line-too-long,unsubscriptable-object
+import collections
+import collections.abc
+import typing
+from collections.abc import Awaitable
+from dataclasses import dataclass
+from typing import Dict, List, Set, Union, TypedDict
+
+var1: typing.Dict[str, int] # [consider-using-alias]
+var2: List[int] # [consider-using-alias]
+var3: collections.abc.Iterable[int]
+var4: typing.OrderedDict[str, int] # [consider-using-alias]
+var5: typing.Awaitable[None] # [consider-using-alias]
+var6: typing.Iterable[int] # [consider-using-alias]
+var7: typing.Hashable # [consider-using-alias]
+var8: typing.ContextManager[str] # [consider-using-alias]
+var9: typing.Pattern[str] # [consider-using-alias]
+var10: typing.re.Match[str] # [consider-using-alias]
+var11: list[int]
+var12: collections.abc
+var13: Awaitable[None]
+var14: collections.defaultdict[str, str]
+
+Alias1 = Set[int]
+Alias2 = Dict[int, List[int]]
+Alias3 = Union[int, typing.List[str]]
+Alias4 = List # [consider-using-alias]
+
+def func1(arg1: List[int], /, *args: List[int], arg2: set[int], **kwargs: Dict[str, int]) -> typing.Tuple[int]:
+ # -1:[consider-using-alias,consider-using-alias,consider-using-alias,consider-using-alias]
+ pass
+
+def func2(arg1: list[int]) -> tuple[int, int]:
+ pass
+
+class CustomIntList(typing.List[int]):
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(List[int], cast_variable)
+
+(lambda x: 2)(List[int])
+
+class CustomNamedTuple(typing.NamedTuple):
+ my_var: List[int] # [consider-using-alias]
+
+CustomTypedDict1 = TypedDict("CustomTypedDict1", my_var=List[int])
+
+class CustomTypedDict2(TypedDict):
+ my_var: List[int] # [consider-using-alias]
+
+@dataclass
+class CustomDataClass:
+ my_var: List[int] # [consider-using-alias]
diff --git a/tests/functional/ext/typing/typing_consider_using_alias_without_future.rc b/tests/functional/ext/typing/typing_consider_using_alias_without_future.rc
new file mode 100644
index 0000000..e1f43ca
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_alias_without_future.rc
@@ -0,0 +1,9 @@
+[master]
+load-plugins=pylint.extensions.typing
+
+[testoptions]
+min_pyver=3.8
+
+[typing]
+py-version=3.7
+runtime-typing=no
diff --git a/tests/functional/ext/typing/typing_consider_using_alias_without_future.txt b/tests/functional/ext/typing/typing_consider_using_alias_without_future.txt
new file mode 100644
index 0000000..c7105b9
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_alias_without_future.txt
@@ -0,0 +1,17 @@
+consider-using-alias:13:6::'typing.Dict' will be deprecated with PY39, consider using 'dict' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:14:6::'typing.List' will be deprecated with PY39, consider using 'list' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:16:6::'typing.OrderedDict' will be deprecated with PY39, consider using 'collections.OrderedDict' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:17:6::'typing.Awaitable' will be deprecated with PY39, consider using 'collections.abc.Awaitable' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:18:6::'typing.Iterable' will be deprecated with PY39, consider using 'collections.abc.Iterable' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:19:6::'typing.Hashable' will be deprecated with PY39, consider using 'collections.abc.Hashable' instead
+consider-using-alias:20:6::'typing.ContextManager' will be deprecated with PY39, consider using 'contextlib.AbstractContextManager' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:21:6::'typing.Pattern' will be deprecated with PY39, consider using 're.Pattern' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:22:7::'typing.Match' will be deprecated with PY39, consider using 're.Match' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:31:9::'typing.List' will be deprecated with PY39, consider using 'list' instead
+consider-using-alias:33:74:func1:'typing.Dict' will be deprecated with PY39, consider using 'dict' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:33:16:func1:'typing.List' will be deprecated with PY39, consider using 'list' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:33:37:func1:'typing.List' will be deprecated with PY39, consider using 'list' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:33:93:func1:'typing.Tuple' will be deprecated with PY39, consider using 'tuple' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:49:12:CustomNamedTuple:'typing.List' will be deprecated with PY39, consider using 'list' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:54:12:CustomTypedDict2:'typing.List' will be deprecated with PY39, consider using 'list' instead. Add 'from __future__ import annotations' as well
+consider-using-alias:58:12:CustomDataClass:'typing.List' will be deprecated with PY39, consider using 'list' instead. Add 'from __future__ import annotations' as well
diff --git a/tests/functional/ext/typing/typing_consider_using_union.py b/tests/functional/ext/typing/typing_consider_using_union.py
new file mode 100644
index 0000000..2f27b40
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union.py
@@ -0,0 +1,47 @@
+"""Test pylint.extension.typing - consider-alternative-union-syntax
+
+'py-version' needs to be set to >= '3.7' and 'runtime-typing=no'.
+With 'from __future__ import annotations' present.
+"""
+# pylint: disable=missing-docstring,invalid-name,unused-argument,line-too-long
+# pylint: disable=consider-using-alias
+from __future__ import annotations
+from dataclasses import dataclass
+import typing
+from typing import Dict, List, Optional, Union, TypedDict
+
+var1: Union[int, str] # [consider-alternative-union-syntax]
+var2: List[Union[int, None]] # [consider-alternative-union-syntax]
+var3: Dict[str, typing.Union[int, str]] # [consider-alternative-union-syntax]
+var4: Optional[int] # [consider-alternative-union-syntax]
+
+Alias1 = Union[int, str]
+Alias2 = List[Union[int, None]]
+Alias3 = Dict[str, typing.Union[int, str]]
+Alias4 = Optional[int]
+
+def func1(
+ arg1: Optional[int], # [consider-alternative-union-syntax]
+ **kwargs: Dict[str, Union[int, str]] # [consider-alternative-union-syntax]
+) -> Union[str, None]: # [consider-alternative-union-syntax]
+ pass
+
+class Custom1(List[Union[str, int]]):
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(Union[List[int], None], cast_variable)
+
+(lambda x: 2)(Optional[int])
+
+class CustomNamedTuple(typing.NamedTuple):
+ my_var: Union[int, str] # [consider-alternative-union-syntax]
+
+CustomTypedDict1 = TypedDict("CustomTypedDict1", my_var=Optional[int])
+
+class CustomTypedDict2(TypedDict):
+ my_var: Dict[str, List[Union[str, int]]] # [consider-alternative-union-syntax]
+
+@dataclass
+class CustomDataClass:
+ my_var: Optional[int] # [consider-alternative-union-syntax]
diff --git a/tests/functional/ext/typing/typing_consider_using_union.rc b/tests/functional/ext/typing/typing_consider_using_union.rc
new file mode 100644
index 0000000..e1f43ca
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union.rc
@@ -0,0 +1,9 @@
+[master]
+load-plugins=pylint.extensions.typing
+
+[testoptions]
+min_pyver=3.8
+
+[typing]
+py-version=3.7
+runtime-typing=no
diff --git a/tests/functional/ext/typing/typing_consider_using_union.txt b/tests/functional/ext/typing/typing_consider_using_union.txt
new file mode 100644
index 0000000..330a716
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union.txt
@@ -0,0 +1,10 @@
+consider-alternative-union-syntax:13:6::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:14:11::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:15:16::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:16:6::Consider using alternative Union syntax instead of 'Optional'
+consider-alternative-union-syntax:24:10:func1:Consider using alternative Union syntax instead of 'Optional'
+consider-alternative-union-syntax:25:24:func1:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:26:5:func1:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:38:12:CustomNamedTuple:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:43:27:CustomTypedDict2:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:47:12:CustomDataClass:Consider using alternative Union syntax instead of 'Optional'
diff --git a/tests/functional/ext/typing/typing_consider_using_union_py310.py b/tests/functional/ext/typing/typing_consider_using_union_py310.py
new file mode 100644
index 0000000..1018c36
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union_py310.py
@@ -0,0 +1,45 @@
+"""Test pylint.extension.typing - consider-alternative-union-syntax
+
+'py-version' needs to be set to >= '3.10'.
+"""
+# pylint: disable=missing-docstring,invalid-name,unused-argument,line-too-long
+# pylint: disable=deprecated-typing-alias
+from dataclasses import dataclass
+import typing
+from typing import Dict, List, Optional, Union, TypedDict
+
+var1: Union[int, str] # [consider-alternative-union-syntax]
+var2: List[Union[int, None]] # [consider-alternative-union-syntax]
+var3: Dict[str, typing.Union[int, str]] # [consider-alternative-union-syntax]
+var4: Optional[int] # [consider-alternative-union-syntax]
+
+Alias1 = Union[int, str] # [consider-alternative-union-syntax]
+Alias2 = List[Union[int, None]] # [consider-alternative-union-syntax]
+Alias3 = Dict[str, typing.Union[int, str]] # [consider-alternative-union-syntax]
+Alias4 = Optional[int] # [consider-alternative-union-syntax]
+
+def func1(
+ arg1: Optional[int], # [consider-alternative-union-syntax]
+ **kwargs: Dict[str, Union[int, str]] # [consider-alternative-union-syntax]
+) -> Union[str, None]: # [consider-alternative-union-syntax]
+ pass
+
+class Custom1(List[Union[str, int]]): # [consider-alternative-union-syntax]
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(Union[List[int], None], cast_variable) # [consider-alternative-union-syntax]
+
+(lambda x: 2)(Optional[int]) # [consider-alternative-union-syntax]
+
+class CustomNamedTuple(typing.NamedTuple):
+ my_var: Union[int, str] # [consider-alternative-union-syntax]
+
+CustomTypedDict1 = TypedDict("CustomTypedDict1", my_var=Optional[int]) # [consider-alternative-union-syntax]
+
+class CustomTypedDict2(TypedDict):
+ my_var: Dict[str, List[Union[str, int]]] # [consider-alternative-union-syntax]
+
+@dataclass
+class CustomDataClass:
+ my_var: Optional[int] # [consider-alternative-union-syntax]
diff --git a/tests/functional/ext/typing/typing_consider_using_union_py310.rc b/tests/functional/ext/typing/typing_consider_using_union_py310.rc
new file mode 100644
index 0000000..7400f16
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union_py310.rc
@@ -0,0 +1,8 @@
+[master]
+load-plugins=pylint.extensions.typing
+
+[testoptions]
+min_pyver=3.8
+
+[typing]
+py-version=3.10
diff --git a/tests/functional/ext/typing/typing_consider_using_union_py310.txt b/tests/functional/ext/typing/typing_consider_using_union_py310.txt
new file mode 100644
index 0000000..4402eb2
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union_py310.txt
@@ -0,0 +1,18 @@
+consider-alternative-union-syntax:11:6::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:12:11::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:13:16::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:14:6::Consider using alternative Union syntax instead of 'Optional'
+consider-alternative-union-syntax:16:9::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:17:14::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:18:19::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:19:9::Consider using alternative Union syntax instead of 'Optional'
+consider-alternative-union-syntax:22:10:func1:Consider using alternative Union syntax instead of 'Optional'
+consider-alternative-union-syntax:23:24:func1:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:24:5:func1:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:27:19:Custom1:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:31:28::Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:33:14::Consider using alternative Union syntax instead of 'Optional'
+consider-alternative-union-syntax:36:12:CustomNamedTuple:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:38:56::Consider using alternative Union syntax instead of 'Optional'
+consider-alternative-union-syntax:41:27:CustomTypedDict2:Consider using alternative Union syntax instead of 'Union'
+consider-alternative-union-syntax:45:12:CustomDataClass:Consider using alternative Union syntax instead of 'Optional'
diff --git a/tests/functional/ext/typing/typing_consider_using_union_without_future.py b/tests/functional/ext/typing/typing_consider_using_union_without_future.py
new file mode 100644
index 0000000..f459d04
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union_without_future.py
@@ -0,0 +1,45 @@
+"""Test pylint.extension.typing - consider-alternative-union-syntax
+
+'py-version' needs to be set to >= '3.7' and 'runtime-typing=no'.
+"""
+# pylint: disable=missing-docstring,invalid-name,unused-argument,line-too-long
+# pylint: disable=consider-using-alias
+from dataclasses import dataclass
+import typing
+from typing import Dict, List, Optional, Union, TypedDict
+
+var1: Union[int, str] # [consider-alternative-union-syntax]
+var2: List[Union[int, None]] # [consider-alternative-union-syntax]
+var3: Dict[str, typing.Union[int, str]] # [consider-alternative-union-syntax]
+var4: Optional[int] # [consider-alternative-union-syntax]
+
+Alias1 = Union[int, str]
+Alias2 = List[Union[int, None]]
+Alias3 = Dict[str, typing.Union[int, str]]
+Alias4 = Optional[int]
+
+def func1(
+ arg1: Optional[int], # [consider-alternative-union-syntax]
+ **kwargs: Dict[str, Union[int, str]] # [consider-alternative-union-syntax]
+) -> Union[str, None]: # [consider-alternative-union-syntax]
+ pass
+
+class Custom1(List[Union[str, int]]):
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(Union[List[int], None], cast_variable)
+
+(lambda x: 2)(Optional[int])
+
+class CustomNamedTuple(typing.NamedTuple):
+ my_var: Union[int, str] # [consider-alternative-union-syntax]
+
+CustomTypedDict1 = TypedDict("CustomTypedDict1", my_var=Optional[int])
+
+class CustomTypedDict2(TypedDict):
+ my_var: Dict[str, List[Union[str, int]]] # [consider-alternative-union-syntax]
+
+@dataclass
+class CustomDataClass:
+ my_var: Optional[int] # [consider-alternative-union-syntax]
diff --git a/tests/functional/ext/typing/typing_consider_using_union_without_future.rc b/tests/functional/ext/typing/typing_consider_using_union_without_future.rc
new file mode 100644
index 0000000..e1f43ca
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union_without_future.rc
@@ -0,0 +1,9 @@
+[master]
+load-plugins=pylint.extensions.typing
+
+[testoptions]
+min_pyver=3.8
+
+[typing]
+py-version=3.7
+runtime-typing=no
diff --git a/tests/functional/ext/typing/typing_consider_using_union_without_future.txt b/tests/functional/ext/typing/typing_consider_using_union_without_future.txt
new file mode 100644
index 0000000..c43cbc3
--- /dev/null
+++ b/tests/functional/ext/typing/typing_consider_using_union_without_future.txt
@@ -0,0 +1,10 @@
+consider-alternative-union-syntax:11:6::Consider using alternative Union syntax instead of 'Union'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:12:11::Consider using alternative Union syntax instead of 'Union'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:13:16::Consider using alternative Union syntax instead of 'Union'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:14:6::Consider using alternative Union syntax instead of 'Optional'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:22:10:func1:Consider using alternative Union syntax instead of 'Optional'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:23:24:func1:Consider using alternative Union syntax instead of 'Union'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:24:5:func1:Consider using alternative Union syntax instead of 'Union'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:36:12:CustomNamedTuple:Consider using alternative Union syntax instead of 'Union'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:41:27:CustomTypedDict2:Consider using alternative Union syntax instead of 'Union'. Add 'from __future__ import annotations' as well
+consider-alternative-union-syntax:45:12:CustomDataClass:Consider using alternative Union syntax instead of 'Optional'. Add 'from __future__ import annotations' as well
diff --git a/tests/functional/ext/typing/typing_deprecated_alias.py b/tests/functional/ext/typing/typing_deprecated_alias.py
new file mode 100644
index 0000000..3cd139c
--- /dev/null
+++ b/tests/functional/ext/typing/typing_deprecated_alias.py
@@ -0,0 +1,58 @@
+"""Test pylint.extension.typing - deprecated-typing-alias
+
+'py-version' needs to be set to >= '3.9'.
+"""
+# pylint: disable=missing-docstring,invalid-name,unused-argument,line-too-long,unsubscriptable-object
+import collections
+import collections.abc
+import typing
+from collections.abc import Awaitable
+from dataclasses import dataclass
+from typing import Dict, List, Set, Union, TypedDict
+
+var1: typing.Dict[str, int] # [deprecated-typing-alias]
+var2: List[int] # [deprecated-typing-alias]
+var3: collections.abc.Iterable[int]
+var4: typing.OrderedDict[str, int] # [deprecated-typing-alias]
+var5: typing.Awaitable[None] # [deprecated-typing-alias]
+var6: typing.Iterable[int] # [deprecated-typing-alias]
+var7: typing.Hashable # [deprecated-typing-alias]
+var8: typing.ContextManager[str] # [deprecated-typing-alias]
+var9: typing.Pattern[str] # [deprecated-typing-alias]
+var10: typing.re.Match[str] # [deprecated-typing-alias]
+var11: list[int]
+var12: collections.abc
+var13: Awaitable[None]
+var14: collections.defaultdict[str, str]
+
+Alias1 = Set[int] # [deprecated-typing-alias]
+Alias2 = Dict[int, List[int]] # [deprecated-typing-alias,deprecated-typing-alias]
+Alias3 = Union[int, typing.List[str]] # [deprecated-typing-alias]
+Alias4 = List # [deprecated-typing-alias]
+
+def func1(arg1: List[int], /, *args: List[int], arg2: set[int], **kwargs: Dict[str, int]) -> typing.Tuple[int]:
+ # -1:[deprecated-typing-alias,deprecated-typing-alias,deprecated-typing-alias,deprecated-typing-alias]
+ pass
+
+def func2(arg1: list[int]) -> tuple[int, int]:
+ pass
+
+class CustomIntList(typing.List[int]): # [deprecated-typing-alias]
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(List[int], cast_variable) # [deprecated-typing-alias]
+
+(lambda x: 2)(List[int]) # [deprecated-typing-alias]
+
+class CustomNamedTuple(typing.NamedTuple):
+ my_var: List[int] # [deprecated-typing-alias]
+
+CustomTypedDict1 = TypedDict("CustomTypedDict1", my_var=List[int]) # [deprecated-typing-alias]
+
+class CustomTypedDict2(TypedDict):
+ my_var: List[int] # [deprecated-typing-alias]
+
+@dataclass
+class CustomDataClass:
+ my_var: List[int] # [deprecated-typing-alias]
diff --git a/tests/functional/ext/typing/typing_deprecated_alias.rc b/tests/functional/ext/typing/typing_deprecated_alias.rc
new file mode 100644
index 0000000..2d21d50
--- /dev/null
+++ b/tests/functional/ext/typing/typing_deprecated_alias.rc
@@ -0,0 +1,8 @@
+[master]
+load-plugins=pylint.extensions.typing
+
+[testoptions]
+min_pyver=3.8
+
+[typing]
+py-version=3.9
diff --git a/tests/functional/ext/typing/typing_deprecated_alias.txt b/tests/functional/ext/typing/typing_deprecated_alias.txt
new file mode 100644
index 0000000..fa74fc1
--- /dev/null
+++ b/tests/functional/ext/typing/typing_deprecated_alias.txt
@@ -0,0 +1,25 @@
+deprecated-typing-alias:13:6::'typing.Dict' is deprecated, use 'dict' instead
+deprecated-typing-alias:14:6::'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:16:6::'typing.OrderedDict' is deprecated, use 'collections.OrderedDict' instead
+deprecated-typing-alias:17:6::'typing.Awaitable' is deprecated, use 'collections.abc.Awaitable' instead
+deprecated-typing-alias:18:6::'typing.Iterable' is deprecated, use 'collections.abc.Iterable' instead
+deprecated-typing-alias:19:6::'typing.Hashable' is deprecated, use 'collections.abc.Hashable' instead
+deprecated-typing-alias:20:6::'typing.ContextManager' is deprecated, use 'contextlib.AbstractContextManager' instead
+deprecated-typing-alias:21:6::'typing.Pattern' is deprecated, use 're.Pattern' instead
+deprecated-typing-alias:22:7::'typing.Match' is deprecated, use 're.Match' instead
+deprecated-typing-alias:28:9::'typing.Set' is deprecated, use 'set' instead
+deprecated-typing-alias:29:9::'typing.Dict' is deprecated, use 'dict' instead
+deprecated-typing-alias:29:19::'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:30:20::'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:31:9::'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:33:74:func1:'typing.Dict' is deprecated, use 'dict' instead
+deprecated-typing-alias:33:16:func1:'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:33:37:func1:'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:33:93:func1:'typing.Tuple' is deprecated, use 'tuple' instead
+deprecated-typing-alias:40:20:CustomIntList:'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:44:28::'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:46:14::'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:49:12:CustomNamedTuple:'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:51:56::'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:54:12:CustomTypedDict2:'typing.List' is deprecated, use 'list' instead
+deprecated-typing-alias:58:12:CustomDataClass:'typing.List' is deprecated, use 'list' instead
diff --git a/tests/functional/f/__init__.py b/tests/functional/f/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/f/__init__.py
diff --git a/tests/functional/f/f_string_without_interpolation.py b/tests/functional/f/f_string_without_interpolation.py
new file mode 100644
index 0000000..4d6e366
--- /dev/null
+++ b/tests/functional/f/f_string_without_interpolation.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-module-docstring
+import math
+
+VALUE = 1
+
+print(f"some value {VALUE}")
+print(f'pi: {math.pi:.3f}')
+
+print(f"ERROR") # [f-string-without-interpolation]
diff --git a/tests/functional/f/f_string_without_interpolation.rc b/tests/functional/f/f_string_without_interpolation.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/f/f_string_without_interpolation.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/f/f_string_without_interpolation.txt b/tests/functional/f/f_string_without_interpolation.txt
new file mode 100644
index 0000000..38df260
--- /dev/null
+++ b/tests/functional/f/f_string_without_interpolation.txt
@@ -0,0 +1 @@
+f-string-without-interpolation:9:6::Using an f-string that does not have any interpolated variables
diff --git a/tests/functional/f/fallback_import_disabled.py b/tests/functional/f/fallback_import_disabled.py
new file mode 100644
index 0000000..321eb11
--- /dev/null
+++ b/tests/functional/f/fallback_import_disabled.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-docstring,unused-import
+try:
+ import urllib2 as urllib_request #@
+ import urllib2 as urllib_error
+ from urlparse import urlparse
+except ImportError:
+ # python2
+ from urllib import request as urllib_request
+ from urllib import error as urllib_error
+ from urllib.parse import urlparseq
diff --git a/tests/functional/f/fallback_import_enabled.py b/tests/functional/f/fallback_import_enabled.py
new file mode 100644
index 0000000..9420830
--- /dev/null
+++ b/tests/functional/f/fallback_import_enabled.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-docstring,unused-import
+try:
+ import collections.missing # [no-name-in-module]
+except ImportError:
+ from collections import missing # [no-name-in-module]
diff --git a/tests/functional/f/fallback_import_enabled.rc b/tests/functional/f/fallback_import_enabled.rc
new file mode 100644
index 0000000..fb6f162
--- /dev/null
+++ b/tests/functional/f/fallback_import_enabled.rc
@@ -0,0 +1,2 @@
+[IMPORTS]
+analyse-fallback-blocks=yes
diff --git a/tests/functional/f/fallback_import_enabled.txt b/tests/functional/f/fallback_import_enabled.txt
new file mode 100644
index 0000000..b5ef596
--- /dev/null
+++ b/tests/functional/f/fallback_import_enabled.txt
@@ -0,0 +1,2 @@
+no-name-in-module:3:4::No name 'missing' in module 'collections'
+no-name-in-module:5:4::No name 'missing' in module 'collections'
diff --git a/tests/functional/f/first_arg.py b/tests/functional/f/first_arg.py
new file mode 100644
index 0000000..0b5c080
--- /dev/null
+++ b/tests/functional/f/first_arg.py
@@ -0,0 +1,42 @@
+# pylint: disable=missing-docstring, no-init, useless-object-inheritance
+"""check for methods first arguments
+"""
+
+__revision__ = 0
+
+
+class Obj(object):
+ # C0202, classmethod
+ def __new__(something): # [bad-classmethod-argument]
+ pass
+
+ # C0202, classmethod
+ def class1(cls):
+ pass
+ class1 = classmethod(class1) # [no-classmethod-decorator]
+
+ def class2(other): # [bad-classmethod-argument]
+ pass
+ class2 = classmethod(class2) # [no-classmethod-decorator]
+
+
+class Meta(type):
+ # C0204, metaclass __new__
+ def __new__(other, name, bases, dct): # [bad-mcs-classmethod-argument]
+ pass
+
+ # C0203, metaclass method
+ def method1(cls):
+ pass
+
+ def method2(other): # [bad-mcs-method-argument]
+ pass
+
+ # C0205, metaclass classmethod
+ def class1(cls):
+ pass
+ class1 = classmethod(class1) # [no-classmethod-decorator]
+
+ def class2(other): # [bad-mcs-classmethod-argument]
+ pass
+ class2 = classmethod(class2) # [no-classmethod-decorator]
diff --git a/tests/functional/f/first_arg.txt b/tests/functional/f/first_arg.txt
new file mode 100644
index 0000000..8344fa8
--- /dev/null
+++ b/tests/functional/f/first_arg.txt
@@ -0,0 +1,9 @@
+bad-classmethod-argument:10:4:Obj.__new__:Class method __new__ should have 'cls' as first argument
+no-classmethod-decorator:16:4:Obj:Consider using a decorator instead of calling classmethod
+bad-classmethod-argument:18:4:Obj.class2:Class method class2 should have 'cls' as first argument
+no-classmethod-decorator:20:4:Obj:Consider using a decorator instead of calling classmethod
+bad-mcs-classmethod-argument:25:4:Meta.__new__:Metaclass class method __new__ should have 'cls' as first argument
+bad-mcs-method-argument:32:4:Meta.method2:Metaclass method method2 should have 'cls' as first argument
+no-classmethod-decorator:38:4:Meta:Consider using a decorator instead of calling classmethod
+bad-mcs-classmethod-argument:40:4:Meta.class2:Metaclass class method class2 should have 'cls' as first argument
+no-classmethod-decorator:42:4:Meta:Consider using a decorator instead of calling classmethod
diff --git a/tests/functional/f/fixme.py b/tests/functional/f/fixme.py
new file mode 100644
index 0000000..081d508
--- /dev/null
+++ b/tests/functional/f/fixme.py
@@ -0,0 +1,33 @@
+# -*- encoding=utf-8 -*-
+# pylint: disable=missing-docstring, unused-variable
+
+# +1: [fixme]
+# FIXME: beep
+
+
+def function():
+ variable = "FIXME: Ignore me!"
+ # +1: [fixme]
+ test = "text" # FIXME: Valid test
+
+ # +1: [fixme]
+ # TODO: Do something with the variables
+ # +1: [fixme]
+ xxx = "n/a" # XXX: Fix this later
+ # +1: [fixme]
+ #FIXME: no space after hash
+ # +1: [fixme]
+ #todo: no space after hash
+
+ # +1: [fixme]
+ # FIXME: this is broken
+ # +1: [fixme]
+ # ./TODO: find with notes
+ # +1: [fixme]
+ # TO make something DO: find with regex
+ # FIXME: this is broken (ISSUE-1234)
+
+ #FIXME: in fact nothing to fix #pylint: disable=fixme
+ #TODO: in fact nothing to do #pylint: disable=fixme
+ #TODO: in fact nothing to do #pylint: disable=line-too-long, fixme
+ # Todoist API mentioned should not result in a message.
diff --git a/tests/functional/f/fixme.rc b/tests/functional/f/fixme.rc
new file mode 100644
index 0000000..6b903c1
--- /dev/null
+++ b/tests/functional/f/fixme.rc
@@ -0,0 +1,3 @@
+[testoptions]
+notes=XXX,TODO,./TODO
+notes-rgx=FIXME(?!.*ISSUE-\d+)|TO.*DO
diff --git a/tests/functional/f/fixme.txt b/tests/functional/f/fixme.txt
new file mode 100644
index 0000000..198e08a
--- /dev/null
+++ b/tests/functional/f/fixme.txt
@@ -0,0 +1,9 @@
+fixme:5:1::"FIXME: beep"
+fixme:11:20::"FIXME: Valid test"
+fixme:14:5::"TODO: Do something with the variables"
+fixme:16:18::"XXX: Fix this later"
+fixme:18:5::"FIXME: no space after hash"
+fixme:20:5::"todo: no space after hash"
+fixme:23:2::"FIXME: this is broken"
+fixme:25:5::"./TODO: find with notes"
+fixme:27:5::"TO make something DO: find with regex"
diff --git a/tests/functional/f/fixme_bad_formatting_1139.py b/tests/functional/f/fixme_bad_formatting_1139.py
new file mode 100644
index 0000000..33030ed
--- /dev/null
+++ b/tests/functional/f/fixme_bad_formatting_1139.py
@@ -0,0 +1,6 @@
+"""
+Test for issue ##1139 - when CRLF newline characters are used,
+\r is left in msg section. As a result, output line in cmdline
+is overwritten with text after msg"""
+
+# TODO Lorem ipsum dolor sit amet consectetur adipiscing elit # [fixme]
diff --git a/tests/functional/f/fixme_bad_formatting_1139.rc b/tests/functional/f/fixme_bad_formatting_1139.rc
new file mode 100644
index 0000000..554bb30
--- /dev/null
+++ b/tests/functional/f/fixme_bad_formatting_1139.rc
@@ -0,0 +1,2 @@
+[MESSAGES CONTROL]
+msg-template={C}:{line:3d},{column:2d}: {obj}: {msg} ({symbol}, {msg_id})
diff --git a/tests/functional/f/fixme_bad_formatting_1139.txt b/tests/functional/f/fixme_bad_formatting_1139.txt
new file mode 100644
index 0000000..4da0264
--- /dev/null
+++ b/tests/functional/f/fixme_bad_formatting_1139.txt
@@ -0,0 +1 @@
+fixme:6:1::TODO Lorem ipsum dolor sit amet consectetur adipiscing elit # [fixme]
diff --git a/tests/functional/f/formatted_string_literal_with_if_py36.py b/tests/functional/f/formatted_string_literal_with_if_py36.py
new file mode 100644
index 0000000..8feb4e2
--- /dev/null
+++ b/tests/functional/f/formatted_string_literal_with_if_py36.py
@@ -0,0 +1,8 @@
+"""Test that `if` in formatted string literal won't break Pylint."""
+# pylint: disable=missing-docstring, pointless-statement, using-constant-test
+
+f'{"+" if True else "-"}'
+if True:
+ pass
+elif True:
+ pass
diff --git a/tests/functional/f/formatted_string_literal_with_if_py36.rc b/tests/functional/f/formatted_string_literal_with_if_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/f/formatted_string_literal_with_if_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/f/func_disable_linebased.py b/tests/functional/f/func_disable_linebased.py
new file mode 100644
index 0000000..bb4ad23
--- /dev/null
+++ b/tests/functional/f/func_disable_linebased.py
@@ -0,0 +1,15 @@
+# This is a very very very very very very very very very very very very very very very very very very very very very long line. # [line-too-long]
+# pylint: disable=line-too-long
+# This is a very very very very very very very very very very very very very very very very very very very very very long line.
+"""Make sure enable/disable pragmas work for messages that are applied to lines and not syntax nodes.
+
+A disable pragma for a message that applies to nodes is applied to the whole
+block if it comes before the first statement (excluding the docstring). For
+line-based messages, this behavior needs to be altered to really only apply to
+the enclosed lines.
+"""
+# pylint: enable=line-too-long
+
+from __future__ import print_function
+
+print('This is a very long line which the linter will warn about, now that line-too-long has been enabled again.') # [line-too-long]
diff --git a/tests/functional/f/func_disable_linebased.txt b/tests/functional/f/func_disable_linebased.txt
new file mode 100644
index 0000000..6c64556
--- /dev/null
+++ b/tests/functional/f/func_disable_linebased.txt
@@ -0,0 +1,2 @@
+line-too-long:1:0::Line too long (146/100)
+line-too-long:15:0::Line too long (133/100)
diff --git a/tests/functional/f/function_redefined.py b/tests/functional/f/function_redefined.py
new file mode 100644
index 0000000..daac81d
--- /dev/null
+++ b/tests/functional/f/function_redefined.py
@@ -0,0 +1,120 @@
+# pylint: disable=no-self-use,missing-docstring,using-constant-test, useless-object-inheritance
+# pylint: disable=unused-import,wrong-import-position,reimported, unnecessary-pass
+from __future__ import division
+__revision__ = ''
+class AAAA(object):
+ """docstring"""
+ def __init__(self):
+ pass
+ def method1(self):
+ """docstring"""
+
+ def method2(self):
+ """docstring"""
+
+ def method2(self): # [function-redefined]
+ """docstring"""
+
+class AAAA(object): # [function-redefined]
+ """docstring"""
+ def __init__(self):
+ pass
+ def yeah(self):
+ """hehehe"""
+ def yoo(self):
+ """yoo"""
+def func1():
+ """docstring"""
+
+def func2():
+ """docstring"""
+
+def func2(): # [function-redefined]
+ """docstring"""
+ __revision__ = 1 # [redefined-outer-name]
+ return __revision__
+
+if __revision__:
+ def exclusive_func():
+ "docstring"
+else:
+ def exclusive_func():
+ "docstring"
+
+try:
+ def exclusive_func2():
+ "docstring"
+except TypeError:
+ def exclusive_func2():
+ "docstring"
+else:
+ def exclusive_func2(): # [function-redefined]
+ "this one redefine the one defined line 42"
+
+
+def with_inner_function_1():
+ """docstring"""
+ def callback():
+ """callback docstring"""
+ pass
+ return callback
+
+def with_inner_function_2():
+ """docstring"""
+ def callback():
+ """does not redefine callback returned by with_inner_function_1"""
+ pass
+ return callback
+
+def some_func():
+ """Don't emit if we defined a variable with the same name as a
+ __future__ directive.
+ """
+ division = 2
+ return division
+
+def dummy_func():
+ """First dummy function"""
+ pass
+
+def dummy_func():
+ """Second dummy function, don't emit function-redefined message
+ because of the dummy name"""
+ pass
+
+from math import ceil
+def ceil(): # [function-redefined]
+ pass
+
+import math
+def math(): # [function-redefined]
+ pass
+
+import math as _
+def _():
+ pass
+
+# pylint: disable=too-few-public-methods
+class ObjectProxy:
+ """ABC"""
+
+ # We actually *redefine* these attributes, but these shouldn't
+ # be considered actual redefinitions. Issue #2451
+ @property
+ def __module__(self):
+ return "actual.module"
+
+ @property
+ def __doc__(self):
+ return "Docstring"
+
+
+# Do not emit the error for conditional definitions
+def func(callback1=None, callback2=None):
+ if not callback1:
+ def callback1():
+ return 42
+ if callback2 is None:
+ def callback2():
+ return 24
+ return callback1(), callback2()
diff --git a/tests/functional/f/function_redefined.txt b/tests/functional/f/function_redefined.txt
new file mode 100644
index 0000000..26f1c28
--- /dev/null
+++ b/tests/functional/f/function_redefined.txt
@@ -0,0 +1,7 @@
+function-redefined:15:4:AAAA.method2:method already defined line 12
+function-redefined:18:0:AAAA:class already defined line 5
+function-redefined:32:0:func2:function already defined line 29
+redefined-outer-name:34:4:func2:Redefining name '__revision__' from outer scope (line 4)
+function-redefined:51:4:exclusive_func2:function already defined line 45
+function-redefined:86:0:ceil:function already defined line 85
+function-redefined:90:0:math:function already defined line 89
diff --git a/tests/functional/f/function_redefined_2540.py b/tests/functional/f/function_redefined_2540.py
new file mode 100644
index 0000000..2579229
--- /dev/null
+++ b/tests/functional/f/function_redefined_2540.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,too-few-public-methods,invalid-name
+
+from typing import ForwardRef
+
+Cls = ForwardRef("Cls")
+
+
+class Cls:
+ pass
diff --git a/tests/functional/f/function_redefined_2540.rc b/tests/functional/f/function_redefined_2540.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/f/function_redefined_2540.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/f/future_import.py b/tests/functional/f/future_import.py
new file mode 100644
index 0000000..e4d3785
--- /dev/null
+++ b/tests/functional/f/future_import.py
@@ -0,0 +1,3 @@
+"""a docstring"""
+
+from __future__ import generators
diff --git a/tests/functional/f/future_unicode_literals.py b/tests/functional/f/future_unicode_literals.py
new file mode 100644
index 0000000..30c2bd6
--- /dev/null
+++ b/tests/functional/f/future_unicode_literals.py
@@ -0,0 +1,6 @@
+"""Unicode literals in Python 2.*"""
+from __future__ import unicode_literals
+
+
+BAD_STRING = b'\u1234' # >= 2.7.4:[anomalous-unicode-escape-in-string]
+GOOD_STRING = '\u1234'
diff --git a/tests/functional/f/future_unicode_literals.rc b/tests/functional/f/future_unicode_literals.rc
new file mode 100644
index 0000000..58b5a94
--- /dev/null
+++ b/tests/functional/f/future_unicode_literals.rc
@@ -0,0 +1 @@
+[testoptions]
diff --git a/tests/functional/f/future_unicode_literals.txt b/tests/functional/f/future_unicode_literals.txt
new file mode 100644
index 0000000..3956b69
--- /dev/null
+++ b/tests/functional/f/future_unicode_literals.txt
@@ -0,0 +1 @@
+anomalous-unicode-escape-in-string:5:15::"Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix."
diff --git a/tests/functional/g/__init__.py b/tests/functional/g/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/g/__init__.py
diff --git a/tests/functional/g/generated_members.py b/tests/functional/g/generated_members.py
new file mode 100644
index 0000000..b79c008
--- /dev/null
+++ b/tests/functional/g/generated_members.py
@@ -0,0 +1,20 @@
+"""Test the generated-members config option."""
+# pylint: disable=pointless-statement, invalid-name, useless-object-inheritance
+from __future__ import print_function
+from astroid import node_classes
+from pylint import checkers
+
+class Klass(object):
+ """A class with a generated member."""
+
+print(Klass().DoesNotExist)
+print(Klass().aBC_set1)
+print(Klass().ham.does.not_.exist)
+print(Klass().spam.does.not_.exist) # [no-member]
+node_classes.Tuple.does.not_.exist
+checkers.base.doesnotexist()
+
+session = Klass()
+SESSION = Klass()
+session.rollback()
+SESSION.rollback()
diff --git a/tests/functional/g/generated_members.rc b/tests/functional/g/generated_members.rc
new file mode 100644
index 0000000..8b61b49
--- /dev/null
+++ b/tests/functional/g/generated_members.rc
@@ -0,0 +1,11 @@
+[Messages Control]
+disable=too-few-public-methods,print-statement
+
+[typecheck]
+generated-members=
+ \Afunctional\.g\.generated_members\.Klass\.ham\Z,
+ DoesNotExist,
+ "[a-zA-Z]+_set{1,2}",
+ node_classes.Tuple.*,
+ checkers.*?base,
+ (session|SESSION).rollback
diff --git a/tests/functional/g/generated_members.txt b/tests/functional/g/generated_members.txt
new file mode 100644
index 0000000..28e793c
--- /dev/null
+++ b/tests/functional/g/generated_members.txt
@@ -0,0 +1 @@
+no-member:13:6::Instance of 'Klass' has no 'spam' member:INFERENCE
diff --git a/tests/functional/g/generic_alias/__init__.py b/tests/functional/g/generic_alias/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/g/generic_alias/__init__.py
diff --git a/tests/functional/g/generic_alias/generic_alias_collections.py b/tests/functional/g/generic_alias/generic_alias_collections.py
new file mode 100644
index 0000000..33f6b6e
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections.py
@@ -0,0 +1,130 @@
+"""Test generic alias support for stdlib types (added in PY39)."""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+import abc
+import collections
+import collections.abc
+import contextlib
+import re
+
+# special
+tuple[int, int]
+type[int]
+collections.abc.Callable[[int], str]
+
+# builtins
+dict[int, str]
+list[int]
+set[int]
+frozenset[int]
+
+# collections
+collections.defaultdict[int, str]
+collections.OrderedDict[int, str]
+collections.ChainMap[int, str]
+collections.Counter[int]
+collections.deque[int]
+
+# collections.abc
+collections.abc.Set[int]
+collections.abc.Collection[int]
+collections.abc.Container[int]
+collections.abc.ItemsView[int, str]
+collections.abc.KeysView[int]
+collections.abc.Mapping[int, str]
+collections.abc.MappingView[int]
+collections.abc.MutableMapping[int, str]
+collections.abc.MutableSequence[int]
+collections.abc.MutableSet[int]
+collections.abc.Sequence[int]
+collections.abc.ValuesView[int]
+
+collections.abc.Iterable[int]
+collections.abc.Iterator[int]
+collections.abc.Generator[int, None, None]
+collections.abc.Reversible[int]
+
+collections.abc.Coroutine[list[str], str, int]
+collections.abc.AsyncGenerator[int, None]
+collections.abc.AsyncIterable[int]
+collections.abc.AsyncIterator[int]
+collections.abc.Awaitable[int]
+
+# contextlib
+contextlib.AbstractContextManager[int]
+contextlib.AbstractAsyncContextManager[int]
+
+# re
+re.Pattern[str]
+re.Match[str]
+
+
+# unsubscriptable types
+collections.abc.Hashable
+collections.abc.Sized
+collections.abc.Hashable[int] # [unsubscriptable-object]
+collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+collections.abc.ByteString[int]
+
+
+# Missing implementation for 'collections.abc' derived classes
+class DerivedHashable(collections.abc.Hashable): # [abstract-method] # __hash__
+ pass
+
+class DerivedIterable(collections.abc.Iterable[int]): # [abstract-method] # __iter__
+ pass
+
+class DerivedCollection(collections.abc.Collection[int]): # [abstract-method,abstract-method,abstract-method] # __contains__, __iter__, __len__
+ pass
+
+
+# No implementation required for 'builtins' and 'collections' types
+class DerivedList(list[int]):
+ pass
+
+class DerivedSet(set[int]):
+ pass
+
+class DerivedOrderedDict(collections.OrderedDict[int, str]):
+ pass
+
+class DerivedListIterable(list[collections.abc.Iterable[int]]):
+ pass
+
+
+# Multiple generic base classes
+class DerivedMultiple(collections.abc.Sized, collections.abc.Hashable): # [abstract-method,abstract-method]
+ pass
+
+class CustomAbstractCls1(abc.ABC):
+ pass
+class CustomAbstractCls2(collections.abc.Sized, collections.abc.Iterable[CustomAbstractCls1]): # [abstract-method,abstract-method] # __iter__, __len__
+ pass
+class CustomImplementation(CustomAbstractCls2): # [abstract-method,abstract-method] # __iter__, __len__
+ pass
+
+
+# Type annotations
+var_tuple: tuple[int, int]
+var_dict: dict[int, str]
+var_orderedDict: collections.OrderedDict[int, str]
+var_container: collections.abc.Container[int]
+var_sequence: collections.abc.Sequence[int]
+var_iterable: collections.abc.Iterable[int]
+var_awaitable: collections.abc.Awaitable[int]
+var_contextmanager: contextlib.AbstractContextManager[int]
+var_pattern: re.Pattern[int]
+var_bytestring: collections.abc.ByteString
+var_hashable: collections.abc.Hashable
+var_sized: collections.abc.Sized
+
+# Type annotation with unsubscriptable type
+var_int: int[int] # [unsubscriptable-object]
+var_hashable2: collections.abc.Hashable[int] # [unsubscriptable-object]
+var_sized2: collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+var_bytestring2: collections.abc.ByteString[int]
diff --git a/tests/functional/g/generic_alias/generic_alias_collections.rc b/tests/functional/g/generic_alias/generic_alias_collections.rc
new file mode 100644
index 0000000..16b75ee
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.9
diff --git a/tests/functional/g/generic_alias/generic_alias_collections.txt b/tests/functional/g/generic_alias/generic_alias_collections.txt
new file mode 100644
index 0000000..d9ce1f4
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections.txt
@@ -0,0 +1,16 @@
+unsubscriptable-object:66:0::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:67:0::Value 'collections.abc.Sized' is unsubscriptable
+abstract-method:74:0:DerivedHashable:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:77:0:DerivedIterable:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:80:0:DerivedCollection:Method '__contains__' is abstract in class 'Container' but is not overridden
+abstract-method:80:0:DerivedCollection:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:80:0:DerivedCollection:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:99:0:DerivedMultiple:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:99:0:DerivedMultiple:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:104:0:CustomAbstractCls2:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:104:0:CustomAbstractCls2:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:106:0:CustomImplementation:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:106:0:CustomImplementation:Method '__len__' is abstract in class 'Sized' but is not overridden
+unsubscriptable-object:125:9::Value 'int' is unsubscriptable
+unsubscriptable-object:126:15::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:127:12::Value 'collections.abc.Sized' is unsubscriptable
diff --git a/tests/functional/g/generic_alias/generic_alias_collections_py37.py b/tests/functional/g/generic_alias/generic_alias_collections_py37.py
new file mode 100644
index 0000000..eaa153c
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections_py37.py
@@ -0,0 +1,133 @@
+"""Test generic alias support for stdlib types (added in PY39).
+
+Raise [unsubscriptable-object] error for PY37 and PY38.
+"""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+import abc
+import collections
+import collections.abc
+import contextlib
+import re
+
+# special
+tuple[int, int] # [unsubscriptable-object]
+type[int] # [unsubscriptable-object]
+collections.abc.Callable[[int], str] # [unsubscriptable-object]
+
+# builtins
+dict[int, str] # [unsubscriptable-object]
+list[int] # [unsubscriptable-object]
+set[int] # [unsubscriptable-object]
+frozenset[int] # [unsubscriptable-object]
+
+# collections
+collections.defaultdict[int, str] # [unsubscriptable-object]
+collections.OrderedDict[int, str] # [unsubscriptable-object]
+collections.ChainMap[int, str] # [unsubscriptable-object]
+collections.Counter[int] # [unsubscriptable-object]
+collections.deque[int] # [unsubscriptable-object]
+
+# collections.abc
+collections.abc.Set[int] # [unsubscriptable-object]
+collections.abc.Collection[int] # [unsubscriptable-object]
+collections.abc.Container[int] # [unsubscriptable-object]
+collections.abc.ItemsView[int, str] # [unsubscriptable-object]
+collections.abc.KeysView[int] # [unsubscriptable-object]
+collections.abc.Mapping[int, str] # [unsubscriptable-object]
+collections.abc.MappingView[int] # [unsubscriptable-object]
+collections.abc.MutableMapping[int, str] # [unsubscriptable-object]
+collections.abc.MutableSequence[int] # [unsubscriptable-object]
+collections.abc.MutableSet[int] # [unsubscriptable-object]
+collections.abc.Sequence[int] # [unsubscriptable-object]
+collections.abc.ValuesView[int] # [unsubscriptable-object]
+
+collections.abc.Iterable[int] # [unsubscriptable-object]
+collections.abc.Iterator[int] # [unsubscriptable-object]
+collections.abc.Generator[int, None, None] # [unsubscriptable-object]
+collections.abc.Reversible[int] # [unsubscriptable-object]
+
+collections.abc.Coroutine[list[str], str, int] # [unsubscriptable-object,unsubscriptable-object]
+collections.abc.AsyncGenerator[int, None] # [unsubscriptable-object]
+collections.abc.AsyncIterable[int] # [unsubscriptable-object]
+collections.abc.AsyncIterator[int] # [unsubscriptable-object]
+collections.abc.Awaitable[int] # [unsubscriptable-object]
+
+# contextlib
+contextlib.AbstractContextManager[int] # [unsubscriptable-object]
+contextlib.AbstractAsyncContextManager[int] # [unsubscriptable-object]
+
+# re
+re.Pattern[str] # [unsubscriptable-object]
+re.Match[str] # [unsubscriptable-object]
+
+
+# unsubscriptable types
+collections.abc.Hashable
+collections.abc.Sized
+collections.abc.Hashable[int] # [unsubscriptable-object]
+collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+collections.abc.ByteString[int] # [unsubscriptable-object]
+
+
+# Missing implementation for 'collections.abc' derived classes
+class DerivedHashable(collections.abc.Hashable): # [abstract-method] # __hash__
+ pass
+
+class DerivedIterable(collections.abc.Iterable[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedCollection(collections.abc.Collection[int]): # [unsubscriptable-object]
+ pass
+
+
+# No implementation required for 'builtins' and 'collections' types
+class DerivedList(list[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedSet(set[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedOrderedDict(collections.OrderedDict[int, str]): # [unsubscriptable-object]
+ pass
+
+class DerivedListIterable(list[collections.abc.Iterable[int]]): # [unsubscriptable-object,unsubscriptable-object]
+ pass
+
+
+# Multiple generic base classes
+class DerivedMultiple(collections.abc.Sized, collections.abc.Hashable): # [abstract-method,abstract-method]
+ pass
+
+class CustomAbstractCls1(abc.ABC):
+ pass
+class CustomAbstractCls2(collections.abc.Sized, collections.abc.Iterable[CustomAbstractCls1]): # [abstract-method,unsubscriptable-object] # __len__
+ pass
+class CustomImplementation(CustomAbstractCls2): # [abstract-method] # __len__
+ pass
+
+
+# Type annotations
+var_tuple: tuple[int, int] # [unsubscriptable-object]
+var_dict: dict[int, str] # [unsubscriptable-object]
+var_orderedDict: collections.OrderedDict[int, str] # [unsubscriptable-object]
+var_container: collections.abc.Container[int] # [unsubscriptable-object]
+var_sequence: collections.abc.Sequence[int] # [unsubscriptable-object]
+var_iterable: collections.abc.Iterable[int] # [unsubscriptable-object]
+var_awaitable: collections.abc.Awaitable[int] # [unsubscriptable-object]
+var_contextmanager: contextlib.AbstractContextManager[int] # [unsubscriptable-object]
+var_pattern: re.Pattern[int] # [unsubscriptable-object]
+var_bytestring: collections.abc.ByteString
+var_hashable: collections.abc.Hashable
+var_sized: collections.abc.Sized
+
+# Type annotation with unsubscriptable type
+var_int: int[int] # [unsubscriptable-object]
+var_hashable2: collections.abc.Hashable[int] # [unsubscriptable-object]
+var_sized2: collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+var_bytestring2: collections.abc.ByteString[int] # [unsubscriptable-object]
diff --git a/tests/functional/g/generic_alias/generic_alias_collections_py37.rc b/tests/functional/g/generic_alias/generic_alias_collections_py37.rc
new file mode 100644
index 0000000..59df8e3
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections_py37.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.7
+max_pyver=3.9
diff --git a/tests/functional/g/generic_alias/generic_alias_collections_py37.txt b/tests/functional/g/generic_alias/generic_alias_collections_py37.txt
new file mode 100644
index 0000000..6108073
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections_py37.txt
@@ -0,0 +1,67 @@
+unsubscriptable-object:15:0::Value 'tuple' is unsubscriptable
+unsubscriptable-object:16:0::Value 'type' is unsubscriptable
+unsubscriptable-object:17:0::Value 'collections.abc.Callable' is unsubscriptable
+unsubscriptable-object:20:0::Value 'dict' is unsubscriptable
+unsubscriptable-object:21:0::Value 'list' is unsubscriptable
+unsubscriptable-object:22:0::Value 'set' is unsubscriptable
+unsubscriptable-object:23:0::Value 'frozenset' is unsubscriptable
+unsubscriptable-object:26:0::Value 'collections.defaultdict' is unsubscriptable
+unsubscriptable-object:27:0::Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:28:0::Value 'collections.ChainMap' is unsubscriptable
+unsubscriptable-object:29:0::Value 'collections.Counter' is unsubscriptable
+unsubscriptable-object:30:0::Value 'collections.deque' is unsubscriptable
+unsubscriptable-object:33:0::Value 'collections.abc.Set' is unsubscriptable
+unsubscriptable-object:34:0::Value 'collections.abc.Collection' is unsubscriptable
+unsubscriptable-object:35:0::Value 'collections.abc.Container' is unsubscriptable
+unsubscriptable-object:36:0::Value 'collections.abc.ItemsView' is unsubscriptable
+unsubscriptable-object:37:0::Value 'collections.abc.KeysView' is unsubscriptable
+unsubscriptable-object:38:0::Value 'collections.abc.Mapping' is unsubscriptable
+unsubscriptable-object:39:0::Value 'collections.abc.MappingView' is unsubscriptable
+unsubscriptable-object:40:0::Value 'collections.abc.MutableMapping' is unsubscriptable
+unsubscriptable-object:41:0::Value 'collections.abc.MutableSequence' is unsubscriptable
+unsubscriptable-object:42:0::Value 'collections.abc.MutableSet' is unsubscriptable
+unsubscriptable-object:43:0::Value 'collections.abc.Sequence' is unsubscriptable
+unsubscriptable-object:44:0::Value 'collections.abc.ValuesView' is unsubscriptable
+unsubscriptable-object:46:0::Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:47:0::Value 'collections.abc.Iterator' is unsubscriptable
+unsubscriptable-object:48:0::Value 'collections.abc.Generator' is unsubscriptable
+unsubscriptable-object:49:0::Value 'collections.abc.Reversible' is unsubscriptable
+unsubscriptable-object:51:0::Value 'collections.abc.Coroutine' is unsubscriptable
+unsubscriptable-object:51:26::Value 'list' is unsubscriptable
+unsubscriptable-object:52:0::Value 'collections.abc.AsyncGenerator' is unsubscriptable
+unsubscriptable-object:53:0::Value 'collections.abc.AsyncIterable' is unsubscriptable
+unsubscriptable-object:54:0::Value 'collections.abc.AsyncIterator' is unsubscriptable
+unsubscriptable-object:55:0::Value 'collections.abc.Awaitable' is unsubscriptable
+unsubscriptable-object:58:0::Value 'contextlib.AbstractContextManager' is unsubscriptable
+unsubscriptable-object:59:0::Value 'contextlib.AbstractAsyncContextManager' is unsubscriptable
+unsubscriptable-object:62:0::Value 're.Pattern' is unsubscriptable
+unsubscriptable-object:63:0::Value 're.Match' is unsubscriptable
+unsubscriptable-object:69:0::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:70:0::Value 'collections.abc.Sized' is unsubscriptable
+unsubscriptable-object:73:0::Value 'collections.abc.ByteString' is unsubscriptable
+abstract-method:77:0:DerivedHashable:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+unsubscriptable-object:80:22:DerivedIterable:Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:83:24:DerivedCollection:Value 'collections.abc.Collection' is unsubscriptable
+unsubscriptable-object:88:18:DerivedList:Value 'list' is unsubscriptable
+unsubscriptable-object:91:17:DerivedSet:Value 'set' is unsubscriptable
+unsubscriptable-object:94:25:DerivedOrderedDict:Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:97:31:DerivedListIterable:Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:97:26:DerivedListIterable:Value 'list' is unsubscriptable
+abstract-method:102:0:DerivedMultiple:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:102:0:DerivedMultiple:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:107:0:CustomAbstractCls2:Method '__len__' is abstract in class 'Sized' but is not overridden
+unsubscriptable-object:107:48:CustomAbstractCls2:Value 'collections.abc.Iterable' is unsubscriptable
+abstract-method:109:0:CustomImplementation:Method '__len__' is abstract in class 'Sized' but is not overridden
+unsubscriptable-object:114:11::Value 'tuple' is unsubscriptable
+unsubscriptable-object:115:10::Value 'dict' is unsubscriptable
+unsubscriptable-object:116:17::Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:117:15::Value 'collections.abc.Container' is unsubscriptable
+unsubscriptable-object:118:14::Value 'collections.abc.Sequence' is unsubscriptable
+unsubscriptable-object:119:14::Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:120:15::Value 'collections.abc.Awaitable' is unsubscriptable
+unsubscriptable-object:121:20::Value 'contextlib.AbstractContextManager' is unsubscriptable
+unsubscriptable-object:122:13::Value 're.Pattern' is unsubscriptable
+unsubscriptable-object:128:9::Value 'int' is unsubscriptable
+unsubscriptable-object:129:15::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:130:12::Value 'collections.abc.Sized' is unsubscriptable
+unsubscriptable-object:133:17::Value 'collections.abc.ByteString' is unsubscriptable
diff --git a/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.py b/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.py
new file mode 100644
index 0000000..5319f13
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.py
@@ -0,0 +1,135 @@
+"""Test generic alias support for stdlib types (added in PY39).
+
+Raise [unsubscriptable-object] error for PY37 and PY38.
+Make sure `import typing` doesn't change anything.
+"""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement,unused-import
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+import abc
+import collections
+import collections.abc
+import contextlib
+import re
+import typing
+
+# special
+tuple[int, int] # [unsubscriptable-object]
+type[int] # [unsubscriptable-object]
+collections.abc.Callable[[int], str] # [unsubscriptable-object]
+
+# builtins
+dict[int, str] # [unsubscriptable-object]
+list[int] # [unsubscriptable-object]
+set[int] # [unsubscriptable-object]
+frozenset[int] # [unsubscriptable-object]
+
+# collections
+collections.defaultdict[int, str] # [unsubscriptable-object]
+collections.OrderedDict[int, str] # [unsubscriptable-object]
+collections.ChainMap[int, str] # [unsubscriptable-object]
+collections.Counter[int] # [unsubscriptable-object]
+collections.deque[int] # [unsubscriptable-object]
+
+# collections.abc
+collections.abc.Set[int] # [unsubscriptable-object]
+collections.abc.Collection[int] # [unsubscriptable-object]
+collections.abc.Container[int] # [unsubscriptable-object]
+collections.abc.ItemsView[int, str] # [unsubscriptable-object]
+collections.abc.KeysView[int] # [unsubscriptable-object]
+collections.abc.Mapping[int, str] # [unsubscriptable-object]
+collections.abc.MappingView[int] # [unsubscriptable-object]
+collections.abc.MutableMapping[int, str] # [unsubscriptable-object]
+collections.abc.MutableSequence[int] # [unsubscriptable-object]
+collections.abc.MutableSet[int] # [unsubscriptable-object]
+collections.abc.Sequence[int] # [unsubscriptable-object]
+collections.abc.ValuesView[int] # [unsubscriptable-object]
+
+collections.abc.Iterable[int] # [unsubscriptable-object]
+collections.abc.Iterator[int] # [unsubscriptable-object]
+collections.abc.Generator[int, None, None] # [unsubscriptable-object]
+collections.abc.Reversible[int] # [unsubscriptable-object]
+
+collections.abc.Coroutine[list[str], str, int] # [unsubscriptable-object,unsubscriptable-object]
+collections.abc.AsyncGenerator[int, None] # [unsubscriptable-object]
+collections.abc.AsyncIterable[int] # [unsubscriptable-object]
+collections.abc.AsyncIterator[int] # [unsubscriptable-object]
+collections.abc.Awaitable[int] # [unsubscriptable-object]
+
+# contextlib
+contextlib.AbstractContextManager[int] # [unsubscriptable-object]
+contextlib.AbstractAsyncContextManager[int] # [unsubscriptable-object]
+
+# re
+re.Pattern[str] # [unsubscriptable-object]
+re.Match[str] # [unsubscriptable-object]
+
+
+# unsubscriptable types
+collections.abc.Hashable
+collections.abc.Sized
+collections.abc.Hashable[int] # [unsubscriptable-object]
+collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+collections.abc.ByteString[int] # [unsubscriptable-object]
+
+
+# Missing implementation for 'collections.abc' derived classes
+class DerivedHashable(collections.abc.Hashable): # [abstract-method] # __hash__
+ pass
+
+class DerivedIterable(collections.abc.Iterable[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedCollection(collections.abc.Collection[int]): # [unsubscriptable-object]
+ pass
+
+
+# No implementation required for 'builtins' and 'collections' types
+class DerivedList(list[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedSet(set[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedOrderedDict(collections.OrderedDict[int, str]): # [unsubscriptable-object]
+ pass
+
+class DerivedListIterable(list[collections.abc.Iterable[int]]): # [unsubscriptable-object,unsubscriptable-object]
+ pass
+
+
+# Multiple generic base classes
+class DerivedMultiple(collections.abc.Sized, collections.abc.Hashable): # [abstract-method,abstract-method]
+ pass
+
+class CustomAbstractCls1(abc.ABC):
+ pass
+class CustomAbstractCls2(collections.abc.Sized, collections.abc.Iterable[CustomAbstractCls1]): # [abstract-method,unsubscriptable-object] # __len__
+ pass
+class CustomImplementation(CustomAbstractCls2): # [abstract-method] # __len__
+ pass
+
+
+# Type annotations
+var_tuple: tuple[int, int] # [unsubscriptable-object]
+var_dict: dict[int, str] # [unsubscriptable-object]
+var_orderedDict: collections.OrderedDict[int, str] # [unsubscriptable-object]
+var_container: collections.abc.Container[int] # [unsubscriptable-object]
+var_sequence: collections.abc.Sequence[int] # [unsubscriptable-object]
+var_iterable: collections.abc.Iterable[int] # [unsubscriptable-object]
+var_awaitable: collections.abc.Awaitable[int] # [unsubscriptable-object]
+var_contextmanager: contextlib.AbstractContextManager[int] # [unsubscriptable-object]
+var_pattern: re.Pattern[int] # [unsubscriptable-object]
+var_bytestring: collections.abc.ByteString
+var_hashable: collections.abc.Hashable
+var_sized: collections.abc.Sized
+
+# Type annotation with unsubscriptable type
+var_int: int[int] # [unsubscriptable-object]
+var_hashable2: collections.abc.Hashable[int] # [unsubscriptable-object]
+var_sized2: collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+var_bytestring2: collections.abc.ByteString[int] # [unsubscriptable-object]
diff --git a/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.rc b/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.rc
new file mode 100644
index 0000000..59df8e3
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.7
+max_pyver=3.9
diff --git a/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.txt b/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.txt
new file mode 100644
index 0000000..ad7bc4a
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_collections_py37_with_typing.txt
@@ -0,0 +1,67 @@
+unsubscriptable-object:17:0::Value 'tuple' is unsubscriptable
+unsubscriptable-object:18:0::Value 'type' is unsubscriptable
+unsubscriptable-object:19:0::Value 'collections.abc.Callable' is unsubscriptable
+unsubscriptable-object:22:0::Value 'dict' is unsubscriptable
+unsubscriptable-object:23:0::Value 'list' is unsubscriptable
+unsubscriptable-object:24:0::Value 'set' is unsubscriptable
+unsubscriptable-object:25:0::Value 'frozenset' is unsubscriptable
+unsubscriptable-object:28:0::Value 'collections.defaultdict' is unsubscriptable
+unsubscriptable-object:29:0::Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:30:0::Value 'collections.ChainMap' is unsubscriptable
+unsubscriptable-object:31:0::Value 'collections.Counter' is unsubscriptable
+unsubscriptable-object:32:0::Value 'collections.deque' is unsubscriptable
+unsubscriptable-object:35:0::Value 'collections.abc.Set' is unsubscriptable
+unsubscriptable-object:36:0::Value 'collections.abc.Collection' is unsubscriptable
+unsubscriptable-object:37:0::Value 'collections.abc.Container' is unsubscriptable
+unsubscriptable-object:38:0::Value 'collections.abc.ItemsView' is unsubscriptable
+unsubscriptable-object:39:0::Value 'collections.abc.KeysView' is unsubscriptable
+unsubscriptable-object:40:0::Value 'collections.abc.Mapping' is unsubscriptable
+unsubscriptable-object:41:0::Value 'collections.abc.MappingView' is unsubscriptable
+unsubscriptable-object:42:0::Value 'collections.abc.MutableMapping' is unsubscriptable
+unsubscriptable-object:43:0::Value 'collections.abc.MutableSequence' is unsubscriptable
+unsubscriptable-object:44:0::Value 'collections.abc.MutableSet' is unsubscriptable
+unsubscriptable-object:45:0::Value 'collections.abc.Sequence' is unsubscriptable
+unsubscriptable-object:46:0::Value 'collections.abc.ValuesView' is unsubscriptable
+unsubscriptable-object:48:0::Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:49:0::Value 'collections.abc.Iterator' is unsubscriptable
+unsubscriptable-object:50:0::Value 'collections.abc.Generator' is unsubscriptable
+unsubscriptable-object:51:0::Value 'collections.abc.Reversible' is unsubscriptable
+unsubscriptable-object:53:0::Value 'collections.abc.Coroutine' is unsubscriptable
+unsubscriptable-object:53:26::Value 'list' is unsubscriptable
+unsubscriptable-object:54:0::Value 'collections.abc.AsyncGenerator' is unsubscriptable
+unsubscriptable-object:55:0::Value 'collections.abc.AsyncIterable' is unsubscriptable
+unsubscriptable-object:56:0::Value 'collections.abc.AsyncIterator' is unsubscriptable
+unsubscriptable-object:57:0::Value 'collections.abc.Awaitable' is unsubscriptable
+unsubscriptable-object:60:0::Value 'contextlib.AbstractContextManager' is unsubscriptable
+unsubscriptable-object:61:0::Value 'contextlib.AbstractAsyncContextManager' is unsubscriptable
+unsubscriptable-object:64:0::Value 're.Pattern' is unsubscriptable
+unsubscriptable-object:65:0::Value 're.Match' is unsubscriptable
+unsubscriptable-object:71:0::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:72:0::Value 'collections.abc.Sized' is unsubscriptable
+unsubscriptable-object:75:0::Value 'collections.abc.ByteString' is unsubscriptable
+abstract-method:79:0:DerivedHashable:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+unsubscriptable-object:82:22:DerivedIterable:Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:85:24:DerivedCollection:Value 'collections.abc.Collection' is unsubscriptable
+unsubscriptable-object:90:18:DerivedList:Value 'list' is unsubscriptable
+unsubscriptable-object:93:17:DerivedSet:Value 'set' is unsubscriptable
+unsubscriptable-object:96:25:DerivedOrderedDict:Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:99:31:DerivedListIterable:Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:99:26:DerivedListIterable:Value 'list' is unsubscriptable
+abstract-method:104:0:DerivedMultiple:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:104:0:DerivedMultiple:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:109:0:CustomAbstractCls2:Method '__len__' is abstract in class 'Sized' but is not overridden
+unsubscriptable-object:109:48:CustomAbstractCls2:Value 'collections.abc.Iterable' is unsubscriptable
+abstract-method:111:0:CustomImplementation:Method '__len__' is abstract in class 'Sized' but is not overridden
+unsubscriptable-object:116:11::Value 'tuple' is unsubscriptable
+unsubscriptable-object:117:10::Value 'dict' is unsubscriptable
+unsubscriptable-object:118:17::Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:119:15::Value 'collections.abc.Container' is unsubscriptable
+unsubscriptable-object:120:14::Value 'collections.abc.Sequence' is unsubscriptable
+unsubscriptable-object:121:14::Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:122:15::Value 'collections.abc.Awaitable' is unsubscriptable
+unsubscriptable-object:123:20::Value 'contextlib.AbstractContextManager' is unsubscriptable
+unsubscriptable-object:124:13::Value 're.Pattern' is unsubscriptable
+unsubscriptable-object:130:9::Value 'int' is unsubscriptable
+unsubscriptable-object:131:15::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:132:12::Value 'collections.abc.Sized' is unsubscriptable
+unsubscriptable-object:135:17::Value 'collections.abc.ByteString' is unsubscriptable
diff --git a/tests/functional/g/generic_alias/generic_alias_mixed_py37.py b/tests/functional/g/generic_alias/generic_alias_mixed_py37.py
new file mode 100644
index 0000000..cb7a4d0
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_mixed_py37.py
@@ -0,0 +1,41 @@
+"""Test generic alias support with mix of typing.py and stdlib types.
+
+Possible with postponed evaluation enabled, starting with PY37.
+"""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+from __future__ import annotations
+
+import collections
+import collections.abc
+import contextlib
+import re
+import typing
+
+# Type annotations
+var_orderedDict: collections.OrderedDict[int, str]
+var_container: collections.abc.Container[int]
+var_sequence: collections.abc.Sequence[int]
+var_iterable: collections.abc.Iterable[int]
+var_awaitable: collections.abc.Awaitable[int]
+var_pattern: re.Pattern[int]
+var_bytestring: collections.abc.ByteString
+var_hashable: collections.abc.Hashable
+var_ContextManager: contextlib.AbstractContextManager[int]
+
+
+# No implementation required for 'builtins'
+class DerivedListIterable(typing.List[typing.Iterable[int]]):
+ pass
+
+
+# Missing implementation for 'collections.abc' derived classes
+class DerivedHashable(typing.Hashable): # [abstract-method] # __hash__
+ pass
+
+class DerivedIterable(typing.Iterable[int]): # [abstract-method] # __iter__
+ pass
+
+class DerivedCollection(typing.Collection[int]): # [abstract-method,abstract-method,abstract-method] # __contains__, __iter__, __len__
+ pass
diff --git a/tests/functional/g/generic_alias/generic_alias_mixed_py37.rc b/tests/functional/g/generic_alias/generic_alias_mixed_py37.rc
new file mode 100644
index 0000000..59df8e3
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_mixed_py37.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.7
+max_pyver=3.9
diff --git a/tests/functional/g/generic_alias/generic_alias_mixed_py37.txt b/tests/functional/g/generic_alias/generic_alias_mixed_py37.txt
new file mode 100644
index 0000000..14d784e
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_mixed_py37.txt
@@ -0,0 +1,5 @@
+abstract-method:34:0:DerivedHashable:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:37:0:DerivedIterable:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:40:0:DerivedCollection:Method '__contains__' is abstract in class 'Container' but is not overridden
+abstract-method:40:0:DerivedCollection:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:40:0:DerivedCollection:Method '__len__' is abstract in class 'Sized' but is not overridden
diff --git a/tests/functional/g/generic_alias/generic_alias_mixed_py39.py b/tests/functional/g/generic_alias/generic_alias_mixed_py39.py
new file mode 100644
index 0000000..9c6e63e
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_mixed_py39.py
@@ -0,0 +1,36 @@
+"""Test generic alias support with mix of typing.py and stdlib types (PY39+)."""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+import collections
+import collections.abc
+import contextlib
+import re
+import typing
+
+# Type annotations
+var_orderedDict: collections.OrderedDict[int, str]
+var_container: collections.abc.Container[int]
+var_sequence: collections.abc.Sequence[int]
+var_iterable: collections.abc.Iterable[int]
+var_awaitable: collections.abc.Awaitable[int]
+var_pattern: re.Pattern[int]
+var_bytestring: collections.abc.ByteString
+var_hashable: collections.abc.Hashable
+var_ContextManager: contextlib.AbstractContextManager[int]
+
+
+# No implementation required for 'builtins'
+class DerivedListIterable(typing.List[typing.Iterable[int]]):
+ pass
+
+
+# Missing implementation for 'collections.abc' derived classes
+class DerivedHashable(typing.Hashable): # [abstract-method] # __hash__
+ pass
+
+class DerivedIterable(typing.Iterable[int]): # [abstract-method] # __iter__
+ pass
+
+class DerivedCollection(typing.Collection[int]): # [abstract-method,abstract-method,abstract-method] # __contains__, __iter__, __len__
+ pass
diff --git a/tests/functional/g/generic_alias/generic_alias_mixed_py39.rc b/tests/functional/g/generic_alias/generic_alias_mixed_py39.rc
new file mode 100644
index 0000000..16b75ee
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_mixed_py39.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.9
diff --git a/tests/functional/g/generic_alias/generic_alias_mixed_py39.txt b/tests/functional/g/generic_alias/generic_alias_mixed_py39.txt
new file mode 100644
index 0000000..2247c12
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_mixed_py39.txt
@@ -0,0 +1,5 @@
+abstract-method:29:0:DerivedHashable:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:32:0:DerivedIterable:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:35:0:DerivedCollection:Method '__contains__' is abstract in class 'Container' but is not overridden
+abstract-method:35:0:DerivedCollection:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:35:0:DerivedCollection:Method '__len__' is abstract in class 'Sized' but is not overridden
diff --git a/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.py b/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.py
new file mode 100644
index 0000000..5ded73b
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.py
@@ -0,0 +1,179 @@
+"""Test generic alias support for stdlib types (added in PY39).
+
+In type annotation context, they can be used with postponed evaluation enabled,
+starting with PY37.
+"""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+from __future__ import annotations
+
+import abc
+import collections
+import collections.abc
+import contextlib
+import re
+
+
+# ----- unsubscriptable (even with postponed evaluation) -----
+# special
+tuple[int, int] # [unsubscriptable-object]
+type[int] # [unsubscriptable-object]
+collections.abc.Callable[[int], str] # [unsubscriptable-object]
+
+# builtins
+dict[int, str] # [unsubscriptable-object]
+list[int] # [unsubscriptable-object]
+set[int] # [unsubscriptable-object]
+frozenset[int] # [unsubscriptable-object]
+
+# collections
+collections.defaultdict[int, str] # [unsubscriptable-object]
+collections.OrderedDict[int, str] # [unsubscriptable-object]
+collections.ChainMap[int, str] # [unsubscriptable-object]
+collections.Counter[int] # [unsubscriptable-object]
+collections.deque[int] # [unsubscriptable-object]
+
+# collections.abc
+collections.abc.Set[int] # [unsubscriptable-object]
+collections.abc.Collection[int] # [unsubscriptable-object]
+collections.abc.Container[int] # [unsubscriptable-object]
+collections.abc.ItemsView[int, str] # [unsubscriptable-object]
+collections.abc.KeysView[int] # [unsubscriptable-object]
+collections.abc.Mapping[int, str] # [unsubscriptable-object]
+collections.abc.MappingView[int] # [unsubscriptable-object]
+collections.abc.MutableMapping[int, str] # [unsubscriptable-object]
+collections.abc.MutableSequence[int] # [unsubscriptable-object]
+collections.abc.MutableSet[int] # [unsubscriptable-object]
+collections.abc.Sequence[int] # [unsubscriptable-object]
+collections.abc.ValuesView[int] # [unsubscriptable-object]
+
+collections.abc.Iterable[int] # [unsubscriptable-object]
+collections.abc.Iterator[int] # [unsubscriptable-object]
+collections.abc.Generator[int, None, None] # [unsubscriptable-object]
+collections.abc.Reversible[int] # [unsubscriptable-object]
+
+collections.abc.Coroutine[list[str], str, int] # [unsubscriptable-object,unsubscriptable-object]
+collections.abc.AsyncGenerator[int, None] # [unsubscriptable-object]
+collections.abc.AsyncIterable[int] # [unsubscriptable-object]
+collections.abc.AsyncIterator[int] # [unsubscriptable-object]
+collections.abc.Awaitable[int] # [unsubscriptable-object]
+
+# contextlib
+contextlib.AbstractContextManager[int] # [unsubscriptable-object]
+contextlib.AbstractAsyncContextManager[int] # [unsubscriptable-object]
+
+# re
+re.Pattern[str] # [unsubscriptable-object]
+re.Match[str] # [unsubscriptable-object]
+
+
+# unsubscriptable types
+collections.abc.Hashable
+collections.abc.Sized
+collections.abc.Hashable[int] # [unsubscriptable-object]
+collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+collections.abc.ByteString[int] # [unsubscriptable-object]
+
+
+# Missing implementation for 'collections.abc' derived classes
+class DerivedHashable(collections.abc.Hashable): # [abstract-method] # __hash__
+ pass
+
+class DerivedIterable(collections.abc.Iterable[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedCollection(collections.abc.Collection[int]): # [unsubscriptable-object]
+ pass
+
+
+# No implementation required for 'builtins' and 'collections' types
+class DerivedList(list[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedSet(set[int]): # [unsubscriptable-object]
+ pass
+
+class DerivedOrderedDict(collections.OrderedDict[int, str]): # [unsubscriptable-object]
+ pass
+
+class DerivedListIterable(list[collections.abc.Iterable[int]]): # [unsubscriptable-object,unsubscriptable-object]
+ pass
+
+
+# Multiple generic base classes
+class DerivedMultiple(collections.abc.Sized, collections.abc.Hashable): # [abstract-method,abstract-method]
+ pass
+
+class CustomAbstractCls1(abc.ABC):
+ pass
+class CustomAbstractCls2(collections.abc.Sized, collections.abc.Iterable[CustomAbstractCls1]): # [abstract-method,unsubscriptable-object] # __len__
+ pass
+class CustomImplementation(CustomAbstractCls2): # [abstract-method] # __len__
+ pass
+
+
+
+# ----- subscriptable (with postponed evaluation) -----
+# special
+var_tuple: tuple[int, int]
+var_type: type[int]
+var_callable: collections.abc.Callable[[int], str]
+
+# builtins
+var_dict: dict[int, str]
+var_list: list[int]
+var_set: set[int]
+var_frozenset: frozenset[int]
+
+# collections
+var_defaultdict: collections.defaultdict[int, str]
+var_OrderedDict: collections.OrderedDict[int, str]
+var_ChainMap: collections.ChainMap[int, str]
+var_Counter: collections.Counter[int]
+var_deque: collections.deque[int]
+
+# collections.abc
+var_abc_set: collections.abc.Set[int]
+var_abc_collection: collections.abc.Collection[int]
+var_abc_container: collections.abc.Container[int]
+var_abc_ItemsView: collections.abc.ItemsView[int, str]
+var_abc_KeysView: collections.abc.KeysView[int]
+var_abc_Mapping: collections.abc.Mapping[int, str]
+var_abc_MappingView: collections.abc.MappingView[int]
+var_abc_MutableMapping: collections.abc.MutableMapping[int, str]
+var_abc_MutableSequence: collections.abc.MutableSequence[int]
+var_abc_MutableSet: collections.abc.MutableSet[int]
+var_abc_Sequence: collections.abc.Sequence[int]
+var_abc_ValuesView: collections.abc.ValuesView[int]
+
+var_abc_Iterable: collections.abc.Iterable[int]
+var_abc_Iterator: collections.abc.Iterator[int]
+var_abc_Generator: collections.abc.Generator[int, None, None]
+var_abc_Reversible: collections.abc.Reversible[int]
+
+var_abc_Coroutine: collections.abc.Coroutine[list[str], str, int]
+var_abc_AsyncGenerator: collections.abc.AsyncGenerator[int, None]
+var_abc_AsyncIterable: collections.abc.AsyncIterable[int]
+var_abc_AsyncIterator: collections.abc.AsyncIterator[int]
+var_abc_Awaitable: collections.abc.Awaitable[int]
+
+# contextlib
+var_ContextManager: contextlib.AbstractContextManager[int]
+var_AsyncContextManager: contextlib.AbstractAsyncContextManager[int]
+
+# re
+var_re_Pattern: re.Pattern[str]
+var_re_Match: re.Match[str]
+
+
+# unsubscriptable types
+var_abc_Hashable: collections.abc.Hashable
+var_abc_Sized: collections.abc.Sized
+var_abc_Hashable2: collections.abc.Hashable[int] # [unsubscriptable-object]
+var_abc_Sized2: collections.abc.Sized[int] # [unsubscriptable-object]
+
+# subscriptable with Python 3.9
+var_abc_ByteString: collections.abc.ByteString[int]
diff --git a/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.rc b/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.rc
new file mode 100644
index 0000000..59df8e3
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.7
+max_pyver=3.9
diff --git a/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.txt b/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.txt
new file mode 100644
index 0000000..5bfcb48
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_postponed_evaluation_py37.txt
@@ -0,0 +1,56 @@
+unsubscriptable-object:20:0::Value 'tuple' is unsubscriptable
+unsubscriptable-object:21:0::Value 'type' is unsubscriptable
+unsubscriptable-object:22:0::Value 'collections.abc.Callable' is unsubscriptable
+unsubscriptable-object:25:0::Value 'dict' is unsubscriptable
+unsubscriptable-object:26:0::Value 'list' is unsubscriptable
+unsubscriptable-object:27:0::Value 'set' is unsubscriptable
+unsubscriptable-object:28:0::Value 'frozenset' is unsubscriptable
+unsubscriptable-object:31:0::Value 'collections.defaultdict' is unsubscriptable
+unsubscriptable-object:32:0::Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:33:0::Value 'collections.ChainMap' is unsubscriptable
+unsubscriptable-object:34:0::Value 'collections.Counter' is unsubscriptable
+unsubscriptable-object:35:0::Value 'collections.deque' is unsubscriptable
+unsubscriptable-object:38:0::Value 'collections.abc.Set' is unsubscriptable
+unsubscriptable-object:39:0::Value 'collections.abc.Collection' is unsubscriptable
+unsubscriptable-object:40:0::Value 'collections.abc.Container' is unsubscriptable
+unsubscriptable-object:41:0::Value 'collections.abc.ItemsView' is unsubscriptable
+unsubscriptable-object:42:0::Value 'collections.abc.KeysView' is unsubscriptable
+unsubscriptable-object:43:0::Value 'collections.abc.Mapping' is unsubscriptable
+unsubscriptable-object:44:0::Value 'collections.abc.MappingView' is unsubscriptable
+unsubscriptable-object:45:0::Value 'collections.abc.MutableMapping' is unsubscriptable
+unsubscriptable-object:46:0::Value 'collections.abc.MutableSequence' is unsubscriptable
+unsubscriptable-object:47:0::Value 'collections.abc.MutableSet' is unsubscriptable
+unsubscriptable-object:48:0::Value 'collections.abc.Sequence' is unsubscriptable
+unsubscriptable-object:49:0::Value 'collections.abc.ValuesView' is unsubscriptable
+unsubscriptable-object:51:0::Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:52:0::Value 'collections.abc.Iterator' is unsubscriptable
+unsubscriptable-object:53:0::Value 'collections.abc.Generator' is unsubscriptable
+unsubscriptable-object:54:0::Value 'collections.abc.Reversible' is unsubscriptable
+unsubscriptable-object:56:0::Value 'collections.abc.Coroutine' is unsubscriptable
+unsubscriptable-object:56:26::Value 'list' is unsubscriptable
+unsubscriptable-object:57:0::Value 'collections.abc.AsyncGenerator' is unsubscriptable
+unsubscriptable-object:58:0::Value 'collections.abc.AsyncIterable' is unsubscriptable
+unsubscriptable-object:59:0::Value 'collections.abc.AsyncIterator' is unsubscriptable
+unsubscriptable-object:60:0::Value 'collections.abc.Awaitable' is unsubscriptable
+unsubscriptable-object:63:0::Value 'contextlib.AbstractContextManager' is unsubscriptable
+unsubscriptable-object:64:0::Value 'contextlib.AbstractAsyncContextManager' is unsubscriptable
+unsubscriptable-object:67:0::Value 're.Pattern' is unsubscriptable
+unsubscriptable-object:68:0::Value 're.Match' is unsubscriptable
+unsubscriptable-object:74:0::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:75:0::Value 'collections.abc.Sized' is unsubscriptable
+unsubscriptable-object:78:0::Value 'collections.abc.ByteString' is unsubscriptable
+abstract-method:82:0:DerivedHashable:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+unsubscriptable-object:85:22:DerivedIterable:Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:88:24:DerivedCollection:Value 'collections.abc.Collection' is unsubscriptable
+unsubscriptable-object:93:18:DerivedList:Value 'list' is unsubscriptable
+unsubscriptable-object:96:17:DerivedSet:Value 'set' is unsubscriptable
+unsubscriptable-object:99:25:DerivedOrderedDict:Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:102:31:DerivedListIterable:Value 'collections.abc.Iterable' is unsubscriptable
+unsubscriptable-object:102:26:DerivedListIterable:Value 'list' is unsubscriptable
+abstract-method:107:0:DerivedMultiple:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:107:0:DerivedMultiple:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:112:0:CustomAbstractCls2:Method '__len__' is abstract in class 'Sized' but is not overridden
+unsubscriptable-object:112:48:CustomAbstractCls2:Value 'collections.abc.Iterable' is unsubscriptable
+abstract-method:114:0:CustomImplementation:Method '__len__' is abstract in class 'Sized' but is not overridden
+unsubscriptable-object:175:19::Value 'collections.abc.Hashable' is unsubscriptable
+unsubscriptable-object:176:16::Value 'collections.abc.Sized' is unsubscriptable
diff --git a/tests/functional/g/generic_alias/generic_alias_related.py b/tests/functional/g/generic_alias/generic_alias_related.py
new file mode 100644
index 0000000..20b074b
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_related.py
@@ -0,0 +1,54 @@
+"""Test related function for generic alias.
+
+Any solution should not change the behavior of
+- `__getitem__`
+- `__class_getitem__`
+- `metaclass=ABCMeta`
+"""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+from abc import ABCMeta, abstractmethod
+import typing
+
+
+class ClsUnsubscriptable:
+ def __init__(self):
+ pass
+
+class ClsGetItem:
+ def __init__(self):
+ self.var = [1, 2, 3, 4]
+ def __getitem__(self, item):
+ return self.var[item]
+
+class ClsClassGetItem:
+ def __init__(self):
+ pass
+ __class_getitem__ = lambda cls, x: None
+
+class ClsList(typing.List):
+ pass
+
+
+ClsUnsubscriptable()[1] # [unsubscriptable-object]
+ClsUnsubscriptable[int] # [unsubscriptable-object]
+
+ClsGetItem()[1]
+ClsGetItem[int] # [unsubscriptable-object]
+
+ClsClassGetItem()[1] # [unsubscriptable-object]
+ClsClassGetItem[int]
+
+# subscriptable because of inheritance
+ClsList([0, 1, 2])[1]
+ClsList[int]
+
+
+class ClsAbstract(metaclass=ABCMeta):
+ @abstractmethod
+ def abstract_method(self):
+ pass
+
+class Derived(ClsAbstract): # [abstract-method]
+ pass
diff --git a/tests/functional/g/generic_alias/generic_alias_related.rc b/tests/functional/g/generic_alias/generic_alias_related.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_related.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/g/generic_alias/generic_alias_related.txt b/tests/functional/g/generic_alias/generic_alias_related.txt
new file mode 100644
index 0000000..b10f66f
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_related.txt
@@ -0,0 +1,5 @@
+unsubscriptable-object:34:0::Value 'ClsUnsubscriptable()' is unsubscriptable
+unsubscriptable-object:35:0::Value 'ClsUnsubscriptable' is unsubscriptable
+unsubscriptable-object:38:0::Value 'ClsGetItem' is unsubscriptable
+unsubscriptable-object:40:0::Value 'ClsClassGetItem()' is unsubscriptable
+abstract-method:53:0:Derived:Method 'abstract_method' is abstract in class 'ClsAbstract' but is not overridden
diff --git a/tests/functional/g/generic_alias/generic_alias_related_py39.py b/tests/functional/g/generic_alias/generic_alias_related_py39.py
new file mode 100644
index 0000000..14445a0
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_related_py39.py
@@ -0,0 +1,56 @@
+"""Test related function for generic alias.
+
+Any solution should not change the behavior of
+- `__getitem__`
+- `__class_getitem__`
+- `metaclass=ABCMeta`
+"""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+from abc import ABCMeta, abstractmethod
+import typing
+
+GenericAlias = type(list[int])
+
+
+class ClsUnsubscriptable:
+ def __init__(self):
+ pass
+
+class ClsGetItem:
+ def __init__(self):
+ self.var = [1, 2, 3, 4]
+ def __getitem__(self, item):
+ return self.var[item]
+
+class ClsClassGetItem:
+ def __init__(self):
+ pass
+ __class_getitem__ = classmethod(GenericAlias)
+
+class ClsList(typing.List):
+ pass
+
+
+ClsUnsubscriptable()[1] # [unsubscriptable-object]
+ClsUnsubscriptable[int] # [unsubscriptable-object]
+
+ClsGetItem()[1]
+ClsGetItem[int] # [unsubscriptable-object]
+
+ClsClassGetItem()[1] # [unsubscriptable-object]
+ClsClassGetItem[int]
+
+# subscriptable because of inheritance
+ClsList([0, 1, 2])[1]
+ClsList[int]
+
+
+class ClsAbstract(metaclass=ABCMeta):
+ @abstractmethod
+ def abstract_method(self):
+ pass
+
+class Derived(ClsAbstract): # [abstract-method]
+ pass
diff --git a/tests/functional/g/generic_alias/generic_alias_related_py39.rc b/tests/functional/g/generic_alias/generic_alias_related_py39.rc
new file mode 100644
index 0000000..16b75ee
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_related_py39.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.9
diff --git a/tests/functional/g/generic_alias/generic_alias_related_py39.txt b/tests/functional/g/generic_alias/generic_alias_related_py39.txt
new file mode 100644
index 0000000..be51879
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_related_py39.txt
@@ -0,0 +1,5 @@
+unsubscriptable-object:36:0::Value 'ClsUnsubscriptable()' is unsubscriptable
+unsubscriptable-object:37:0::Value 'ClsUnsubscriptable' is unsubscriptable
+unsubscriptable-object:40:0::Value 'ClsGetItem' is unsubscriptable
+unsubscriptable-object:42:0::Value 'ClsClassGetItem()' is unsubscriptable
+abstract-method:55:0:Derived:Method 'abstract_method' is abstract in class 'ClsAbstract' but is not overridden
diff --git a/tests/functional/g/generic_alias/generic_alias_side_effects.py b/tests/functional/g/generic_alias/generic_alias_side_effects.py
new file mode 100644
index 0000000..64b3d98
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_side_effects.py
@@ -0,0 +1,78 @@
+# pylint: disable=missing-docstring,invalid-name,line-too-long,too-few-public-methods
+import typing
+import collections
+from typing import Generic, TypeVar
+
+
+# tests/functional/a/assigning_non_slot.py
+TYPE = TypeVar('TYPE')
+
+class Cls(Generic[TYPE]):
+ """ Simple class with slots """
+ __slots__ = ['value']
+
+ def __init__(self, value):
+ self.value = value
+
+
+# tests/functional/d/dangerous_default_value_py30.py
+def function4(value=set()): # [dangerous-default-value]
+ """set is mutable and dangerous."""
+ return value
+
+def function5(value=frozenset()):
+ """frozenset is immutable and safe."""
+ return value
+
+def function7(value=dict()): # [dangerous-default-value]
+ """dict is mutable and dangerous."""
+ return value
+
+def function8(value=list()): # [dangerous-default-value]
+ """list is mutable and dangerous."""
+ return value
+
+def function17(value=collections.deque()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function18(value=collections.ChainMap()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function19(value=collections.Counter()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function20(value=collections.OrderedDict()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+def function21(value=collections.defaultdict()): # [dangerous-default-value]
+ """mutable, dangerous"""
+ return value
+
+
+# tests/functional/p/protocol_classes.py (min py38)
+T2 = typing.TypeVar("T2")
+
+class HasherGeneric(typing.Protocol[T2]):
+ """A hashing algorithm, e.g. :func:`hashlib.sha256`."""
+ def update(self, blob: bytes):
+ ...
+ def digest(self) -> bytes:
+ ...
+
+
+# tests/functional/r/regression/regression_2443_duplicate_bases.py
+IN = TypeVar('IN', contravariant=True)
+OUT = TypeVar('OUT', covariant=True)
+
+class ConsumingMixin(Generic[IN]):
+ pass
+
+class ProducingMixin(Generic[OUT]):
+ pass
+
+class StreamingMixin(Generic[IN, OUT], ConsumingMixin[IN], ProducingMixin[OUT]):
+ pass
diff --git a/tests/functional/g/generic_alias/generic_alias_side_effects.rc b/tests/functional/g/generic_alias/generic_alias_side_effects.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_side_effects.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/g/generic_alias/generic_alias_side_effects.txt b/tests/functional/g/generic_alias/generic_alias_side_effects.txt
new file mode 100644
index 0000000..bbd64c1
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_side_effects.txt
@@ -0,0 +1,8 @@
+dangerous-default-value:19:0:function4:Dangerous default value set() (builtins.set) as argument
+dangerous-default-value:27:0:function7:Dangerous default value dict() (builtins.dict) as argument
+dangerous-default-value:31:0:function8:Dangerous default value list() (builtins.list) as argument
+dangerous-default-value:35:0:function17:Dangerous default value deque() (collections.deque) as argument
+dangerous-default-value:39:0:function18:Dangerous default value ChainMap() (collections.ChainMap) as argument
+dangerous-default-value:43:0:function19:Dangerous default value Counter() (collections.Counter) as argument
+dangerous-default-value:47:0:function20:Dangerous default value OrderedDict() (collections.OrderedDict) as argument
+dangerous-default-value:51:0:function21:Dangerous default value defaultdict() (collections.defaultdict) as argument
diff --git a/tests/functional/g/generic_alias/generic_alias_typing.py b/tests/functional/g/generic_alias/generic_alias_typing.py
new file mode 100644
index 0000000..2ce05de
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_typing.py
@@ -0,0 +1,141 @@
+"""Test generic alias support for typing.py types."""
+# flake8: noqa
+# pylint: disable=missing-docstring,pointless-statement
+# pylint: disable=too-few-public-methods,multiple-statements,line-too-long
+import abc
+import typing
+
+# special
+typing.Tuple[int, int]
+typing.Type[int]
+typing.Callable[[int], str]
+
+# builtins
+typing.Dict[int, str]
+typing.List[int]
+typing.Set[int]
+typing.FrozenSet[int]
+
+# collections
+typing.DefaultDict[int, str]
+typing.OrderedDict[int, str]
+typing.ChainMap[int, str]
+typing.Counter[int]
+typing.Deque[int]
+
+# collections.abc
+typing.AbstractSet[int]
+typing.Collection[int]
+typing.Container[int]
+typing.ItemsView[int, str]
+typing.KeysView[int]
+typing.Mapping[int, str]
+typing.MappingView[int]
+typing.MutableMapping[int, str]
+typing.MutableSequence[int]
+typing.MutableSet[int]
+typing.Sequence[int]
+typing.ValuesView[int]
+
+typing.Iterable[int]
+typing.Iterator[int]
+typing.Generator[int, None, None]
+typing.Reversible[int]
+
+typing.Coroutine[typing.List[str], str, int]
+typing.AsyncGenerator[int, None]
+typing.AsyncIterable[int]
+typing.AsyncIterator[int]
+typing.Awaitable[int]
+
+# contextlib
+typing.ContextManager[int]
+typing.AsyncContextManager[int]
+
+# re
+typing.Pattern[str]
+typing.Match[str]
+typing.re.Pattern[str]
+typing.re.Match[str]
+
+
+# unsubscriptable types
+typing.ByteString
+typing.Hashable
+typing.Sized
+typing.ByteString[int] # [unsubscriptable-object]
+typing.Hashable[int] # [unsubscriptable-object]
+typing.Sized[int] # [unsubscriptable-object]
+
+
+# Missing implementation for 'collections.abc' derived classes
+class DerivedHashable(typing.Hashable): # [abstract-method] # __hash__
+ pass
+
+class DerivedIterable(typing.Iterable[int]): # [abstract-method] # __iter__
+ pass
+
+class DerivedCollection(typing.Collection[int]): # [abstract-method,abstract-method,abstract-method] # __contains__, __iter__, __len__
+ pass
+
+
+# No implementation required for 'builtins' and 'collections' types
+class DerivedList(typing.List[int]):
+ def func(self):
+ return self.__iter__()
+
+class DerivedSet(typing.Set[int]):
+ def func(self):
+ return self.add(2)
+
+class DerivedOrderedDict(typing.OrderedDict[int, str]):
+ def func(self):
+ return self.items()
+
+class DerivedListIterable(typing.List[typing.Iterable[int]]):
+ pass
+
+
+# Multiple generic base classes
+class DerivedMultiple(typing.Sized, typing.Hashable): # [abstract-method,abstract-method]
+ pass
+
+class CustomAbstractCls1(abc.ABC):
+ pass
+class CustomAbstractCls2(typing.Sized, typing.Iterable[CustomAbstractCls1]): # [abstract-method,abstract-method] # __iter__, __len__
+ pass
+class CustomImplementation(CustomAbstractCls2): # [abstract-method,abstract-method] # __iter__, __len__
+ pass
+
+
+# Inheritance without generic
+class DerivedList2(typing.List):
+ pass
+
+class DerivedOrderedDict2(typing.OrderedDict):
+ pass
+
+class DerivedIterable2(typing.Iterable): # [abstract-method] # __iter__
+ pass
+
+
+# Type annotations
+var_tuple: typing.Tuple[int, int]
+var_dict: typing.Dict[int, str]
+var_orderedDict: typing.OrderedDict[int, str]
+var_container: typing.Container[int]
+var_sequence: typing.Sequence[int]
+var_iterable: typing.Iterable[int]
+var_awaitable: typing.Awaitable[int]
+var_contextmanager: typing.ContextManager[int]
+var_pattern: typing.Pattern[int]
+var_pattern2: typing.re.Pattern[int]
+var_bytestring: typing.ByteString
+var_hashable: typing.Hashable
+var_sized: typing.Sized
+
+# Type annotation with unsubscriptable type
+var_int: int[int] # [unsubscriptable-object]
+var_bytestring2: typing.ByteString[int] # [unsubscriptable-object]
+var_hashable2: typing.Hashable[int] # [unsubscriptable-object]
+var_sized2: typing.Sized[int] # [unsubscriptable-object]
diff --git a/tests/functional/g/generic_alias/generic_alias_typing.rc b/tests/functional/g/generic_alias/generic_alias_typing.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_typing.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/g/generic_alias/generic_alias_typing.txt b/tests/functional/g/generic_alias/generic_alias_typing.txt
new file mode 100644
index 0000000..8942ca7
--- /dev/null
+++ b/tests/functional/g/generic_alias/generic_alias_typing.txt
@@ -0,0 +1,19 @@
+unsubscriptable-object:66:0::Value 'typing.ByteString' is unsubscriptable
+unsubscriptable-object:67:0::Value 'typing.Hashable' is unsubscriptable
+unsubscriptable-object:68:0::Value 'typing.Sized' is unsubscriptable
+abstract-method:72:0:DerivedHashable:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:75:0:DerivedIterable:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:78:0:DerivedCollection:Method '__contains__' is abstract in class 'Container' but is not overridden
+abstract-method:78:0:DerivedCollection:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:78:0:DerivedCollection:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:100:0:DerivedMultiple:Method '__hash__' is abstract in class 'Hashable' but is not overridden
+abstract-method:100:0:DerivedMultiple:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:105:0:CustomAbstractCls2:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:105:0:CustomAbstractCls2:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:107:0:CustomImplementation:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+abstract-method:107:0:CustomImplementation:Method '__len__' is abstract in class 'Sized' but is not overridden
+abstract-method:118:0:DerivedIterable2:Method '__iter__' is abstract in class 'Iterable' but is not overridden
+unsubscriptable-object:138:9::Value 'int' is unsubscriptable
+unsubscriptable-object:139:17::Value 'typing.ByteString' is unsubscriptable
+unsubscriptable-object:140:15::Value 'typing.Hashable' is unsubscriptable
+unsubscriptable-object:141:12::Value 'typing.Sized' is unsubscriptable
diff --git a/tests/functional/g/genexp_in_class_scope.py b/tests/functional/g/genexp_in_class_scope.py
new file mode 100644
index 0000000..0569638
--- /dev/null
+++ b/tests/functional/g/genexp_in_class_scope.py
@@ -0,0 +1,6 @@
+# pylint: disable=no-init,too-few-public-methods, missing-docstring
+# pylint: disable=useless-object-inheritance
+"""Class scope must be handled correctly in genexps"""
+class MyClass(object):
+ var1 = []
+ var2 = list(value*2 for value in var1)
diff --git a/tests/functional/g/genexpr_variable_scope.py b/tests/functional/g/genexpr_variable_scope.py
new file mode 100644
index 0000000..a00d72d
--- /dev/null
+++ b/tests/functional/g/genexpr_variable_scope.py
@@ -0,0 +1,5 @@
+"""test name defined in generator expression are not available
+outside the genexpr scope
+"""
+from __future__ import print_function
+print(n) # [undefined-variable]
diff --git a/tests/functional/g/genexpr_variable_scope.txt b/tests/functional/g/genexpr_variable_scope.txt
new file mode 100644
index 0000000..4567d7f
--- /dev/null
+++ b/tests/functional/g/genexpr_variable_scope.txt
@@ -0,0 +1 @@
+undefined-variable:5:6::Undefined variable 'n'
diff --git a/tests/functional/g/globals.py b/tests/functional/g/globals.py
new file mode 100644
index 0000000..e7f3cc8
--- /dev/null
+++ b/tests/functional/g/globals.py
@@ -0,0 +1,32 @@
+"""Warnings about global statements and usage of global variables."""
+from __future__ import print_function
+
+global CSTE # [global-at-module-level]
+print(CSTE) # [undefined-variable]
+
+CONSTANT = 1
+
+def fix_contant(value):
+ """all this is ok, but try not using global ;)"""
+ global CONSTANT # [global-statement]
+ print(CONSTANT)
+ CONSTANT = value
+
+
+def other():
+ """global behaviour test"""
+ global HOP # [global-variable-not-assigned]
+ print(HOP) # [undefined-variable]
+
+
+def define_constant():
+ """ok but somevar is not defined at the module scope"""
+ global SOMEVAR # [global-variable-undefined]
+ SOMEVAR = 2
+
+
+# pylint: disable=invalid-name
+def global_with_import():
+ """should only warn for global-statement"""
+ global sys # [global-statement]
+ import sys # pylint: disable=import-outside-toplevel
diff --git a/tests/functional/g/globals.txt b/tests/functional/g/globals.txt
new file mode 100644
index 0000000..399fea0
--- /dev/null
+++ b/tests/functional/g/globals.txt
@@ -0,0 +1,7 @@
+global-at-module-level:4:0::Using the global statement at the module level
+undefined-variable:5:6::Undefined variable 'CSTE'
+global-statement:11:4:fix_contant:Using the global statement
+global-variable-not-assigned:18:4:other:Using global for 'HOP' but no assignment is done
+undefined-variable:19:10:other:Undefined variable 'HOP'
+global-variable-undefined:24:4:define_constant:Global variable 'SOMEVAR' undefined at the module level
+global-statement:31:4:global_with_import:Using the global statement
diff --git a/tests/functional/i/__init__.py b/tests/functional/i/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/i/__init__.py
diff --git a/tests/functional/i/implicit/implicit_str_concat.py b/tests/functional/i/implicit/implicit_str_concat.py
new file mode 100644
index 0000000..707fa75
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat.py
@@ -0,0 +1,31 @@
+#pylint: disable=invalid-name,missing-docstring
+
+# Basic test with a list
+TEST_LIST1 = ['a' 'b'] # [implicit-str-concat]
+# Testing with unicode strings in a tuple, with a comma AFTER concatenation
+TEST_LIST2 = (u"a" u"b", u"c") # [implicit-str-concat]
+# Testing with raw strings in a set, with a comma BEFORE concatenation
+TEST_LIST3 = {r'''a''', r'''b''' r'''c'''} # [implicit-str-concat]
+# Testing that only ONE warning is generated when string concatenation happens
+# in the middle of a list
+TEST_LIST4 = ["""a""", """b""" """c""", """d"""] # [implicit-str-concat]
+
+# The following shouldn't raise a warning because it is a function call
+print('a', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'ccc')
+
+# The following shouldn't raise a warning because string literals are
+# on different lines
+TEST_LIST5 = ('a', 'b'
+ 'c')
+
+# The following shouldn't raise a warning because of the escaped newline
+TEST_LIST6 = ('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb \
+ ccc')
+
+# But we should emit when there is an actual juxtaposition
+# +1: [implicit-str-concat]
+TEST_LIST7 = ('a' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb \
+ ccc')
+
+# No warning for bytes
+TEST_LIST8 = [b'A' b'B']
diff --git a/tests/functional/i/implicit/implicit_str_concat.txt b/tests/functional/i/implicit/implicit_str_concat.txt
new file mode 100644
index 0000000..11cecd7
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat.txt
@@ -0,0 +1,5 @@
+implicit-str-concat:4:0::Implicit string concatenation found in list
+implicit-str-concat:6:0::Implicit string concatenation found in tuple
+implicit-str-concat:8:0::Implicit string concatenation found in set
+implicit-str-concat:11:0::Implicit string concatenation found in list
+implicit-str-concat:27:0::Implicit string concatenation found in assignment
diff --git a/tests/functional/i/implicit/implicit_str_concat_latin1.py b/tests/functional/i/implicit/implicit_str_concat_latin1.py
new file mode 100644
index 0000000..cf8c3e6
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat_latin1.py
@@ -0,0 +1,4 @@
+# coding: latin_1
+#pylint: disable=invalid-name,missing-docstring
+
+TOTO = ('Café', 'Café', 'Café')
diff --git a/tests/functional/i/implicit/implicit_str_concat_multiline.py b/tests/functional/i/implicit/implicit_str_concat_multiline.py
new file mode 100755
index 0000000..337ac80
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat_multiline.py
@@ -0,0 +1,4 @@
+#pylint: disable=missing-docstring
+
+TEST_TUPLE = ('a', 'b' # [implicit-str-concat]
+ 'c')
diff --git a/tests/functional/i/implicit/implicit_str_concat_multiline.rc b/tests/functional/i/implicit/implicit_str_concat_multiline.rc
new file mode 100755
index 0000000..e5b3447
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat_multiline.rc
@@ -0,0 +1,2 @@
+[STRING_CONSTANT]
+check-str-concat-over-line-jumps=yes
diff --git a/tests/functional/i/implicit/implicit_str_concat_multiline.txt b/tests/functional/i/implicit/implicit_str_concat_multiline.txt
new file mode 100644
index 0000000..c796269
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat_multiline.txt
@@ -0,0 +1 @@
+implicit-str-concat:3:0::Implicit string concatenation found in tuple
diff --git a/tests/functional/i/implicit/implicit_str_concat_utf8.py b/tests/functional/i/implicit/implicit_str_concat_utf8.py
new file mode 100644
index 0000000..7cd6618
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat_utf8.py
@@ -0,0 +1,3 @@
+#pylint: disable=invalid-name,missing-docstring
+
+TOTO = ('Café', 'Café', 'Café')
diff --git a/tests/functional/i/import_aliasing.py b/tests/functional/i/import_aliasing.py
new file mode 100644
index 0000000..abe5087
--- /dev/null
+++ b/tests/functional/i/import_aliasing.py
@@ -0,0 +1,25 @@
+# pylint: disable=unused-import, missing-docstring, invalid-name, reimported, import-error, wrong-import-order, no-name-in-module, relative-beyond-top-level
+# Functional tests for import aliasing
+# 1. useless-import-alias
+# 2. consider-using-from-import
+
+from collections import OrderedDict as OrderedDict # [useless-import-alias]
+from collections import OrderedDict as o_dict
+import os.path as path # [consider-using-from-import]
+import os.path as p
+import foo.bar.foobar as foobar # [consider-using-from-import]
+import os
+import os as OS
+from sys import version
+from . import bar as bar # [useless-import-alias]
+from . import bar as Bar
+from . import bar
+from ..foo import bar as bar # [useless-import-alias]
+from ..foo.bar import foobar as foobar # [useless-import-alias]
+from ..foo.bar import foobar as anotherfoobar
+from . import foo as foo, foo2 as bar2 # [useless-import-alias]
+from . import foo as bar, foo2 as foo2 # [useless-import-alias]
+from . import foo as bar, foo2 as bar2
+from foo.bar import foobar as foobar # [useless-import-alias]
+from foo.bar import foobar as foo
+from .foo.bar import f as foobar
diff --git a/tests/functional/i/import_aliasing.txt b/tests/functional/i/import_aliasing.txt
new file mode 100644
index 0000000..e95cb33
--- /dev/null
+++ b/tests/functional/i/import_aliasing.txt
@@ -0,0 +1,9 @@
+useless-import-alias:6:0::Import alias does not rename original package
+consider-using-from-import:8:0::Use 'from os import path' instead
+consider-using-from-import:10:0::Use 'from foo.bar import foobar' instead
+useless-import-alias:14:0::Import alias does not rename original package
+useless-import-alias:17:0::Import alias does not rename original package
+useless-import-alias:18:0::Import alias does not rename original package
+useless-import-alias:20:0::Import alias does not rename original package
+useless-import-alias:21:0::Import alias does not rename original package
+useless-import-alias:23:0::Import alias does not rename original package
diff --git a/tests/functional/i/import_error.py b/tests/functional/i/import_error.py
new file mode 100644
index 0000000..7eb4d78
--- /dev/null
+++ b/tests/functional/i/import_error.py
@@ -0,0 +1,37 @@
+""" Test that import errors are detected. """
+# pylint: disable=invalid-name, unused-import, no-absolute-import, bare-except, broad-except, wrong-import-order, wrong-import-position
+import totally_missing # [import-error]
+
+try:
+ import maybe_missing
+except ImportError:
+ maybe_missing = None
+
+try:
+ import maybe_missing_1
+except (ImportError, SyntaxError):
+ maybe_missing_1 = None
+
+try:
+ import maybe_missing_2 # [import-error]
+except ValueError:
+ maybe_missing_2 = None
+
+
+try:
+ if maybe_missing:
+ import really_missing
+except ImportError:
+ pass
+
+# pylint: disable=no-name-in-module
+from functional.s.syntax_error import toto # [syntax-error]
+
+# Don't emit import-error if guarded behind `sys.version_info`
+import sys
+
+if sys.version_info >= (3, 9):
+ import zoneinfo
+
+if sys.version_info[:2] >= (3, 9):
+ import zoneinfo
diff --git a/tests/functional/i/import_error.rc b/tests/functional/i/import_error.rc
new file mode 100644
index 0000000..2901db3
--- /dev/null
+++ b/tests/functional/i/import_error.rc
@@ -0,0 +1,5 @@
+[Messages Control]
+disable=C,R,W
+
+[testoptions]
+except_implementations=PyPy
diff --git a/tests/functional/i/import_error.txt b/tests/functional/i/import_error.txt
new file mode 100644
index 0000000..7e7319d
--- /dev/null
+++ b/tests/functional/i/import_error.txt
@@ -0,0 +1,3 @@
+import-error:3:0::Unable to import 'totally_missing'
+import-error:16:4::Unable to import 'maybe_missing_2'
+syntax-error:28:0::Cannot import 'functional.s.syntax_error' due to syntax error 'invalid syntax (<unknown>, line 1)'
diff --git a/tests/functional/i/import_itself.py b/tests/functional/i/import_itself.py
new file mode 100644
index 0000000..becd529
--- /dev/null
+++ b/tests/functional/i/import_itself.py
@@ -0,0 +1,10 @@
+"""test module importing itself"""
+# pylint: disable=no-absolute-import,using-constant-test
+from __future__ import print_function
+from . import import_itself # [import-self]
+
+__revision__ = 0
+
+
+if __revision__:
+ print(import_itself)
diff --git a/tests/functional/i/import_itself.txt b/tests/functional/i/import_itself.txt
new file mode 100644
index 0000000..4dd3610
--- /dev/null
+++ b/tests/functional/i/import_itself.txt
@@ -0,0 +1 @@
+import-self:4:0::Module import itself
diff --git a/tests/functional/i/inconsistent/inconsistent_mro.py b/tests/functional/i/inconsistent/inconsistent_mro.py
new file mode 100644
index 0000000..0b65068
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_mro.py
@@ -0,0 +1,9 @@
+"""Tests for inconsistent-mro."""
+# pylint: disable=missing-docstring,too-few-public-methods,no-init
+
+class Str(str):
+ pass
+
+
+class Inconsistent(str, Str): # [inconsistent-mro]
+ pass
diff --git a/tests/functional/i/inconsistent/inconsistent_mro.txt b/tests/functional/i/inconsistent/inconsistent_mro.txt
new file mode 100644
index 0000000..a0708be
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_mro.txt
@@ -0,0 +1 @@
+inconsistent-mro:8:0:Inconsistent:Inconsistent method resolution order for class 'Inconsistent'
diff --git a/tests/functional/i/inconsistent/inconsistent_quotes.py b/tests/functional/i/inconsistent/inconsistent_quotes.py
new file mode 100644
index 0000000..76553f9
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_quotes.py
@@ -0,0 +1,16 @@
+"""Tests for inconsistent quoting strategy.
+
+In this file, double quotes are the majority quote delimiter.
+"""
+
+FIRST_STRING = "double-quoted string"
+SECOND_STRING = 'single-quoted string' # [inconsistent-quotes]
+THIRD_STRING = "another double-quoted string"
+FOURTH_STRING = "yet another double-quoted string"
+FIFTH_STRING = 'single-quoted string with an unescaped "double quote"'
+
+def function_with_docstring():
+ '''This is a multi-line docstring that should not raise a warning even though the
+ delimiter it uses for quotes is not the delimiter used in the majority of the
+ module.
+ '''
diff --git a/tests/functional/i/inconsistent/inconsistent_quotes.rc b/tests/functional/i/inconsistent/inconsistent_quotes.rc
new file mode 100644
index 0000000..9935ff9
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_quotes.rc
@@ -0,0 +1,2 @@
+[STRING]
+check-quote-consistency=yes
diff --git a/tests/functional/i/inconsistent/inconsistent_quotes.txt b/tests/functional/i/inconsistent/inconsistent_quotes.txt
new file mode 100644
index 0000000..042fe85
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_quotes.txt
@@ -0,0 +1 @@
+inconsistent-quotes:7:0::Quote delimiter ' is inconsistent with the rest of the file
diff --git a/tests/functional/i/inconsistent/inconsistent_quotes2.py b/tests/functional/i/inconsistent/inconsistent_quotes2.py
new file mode 100644
index 0000000..d9b157e
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_quotes2.py
@@ -0,0 +1,10 @@
+"""Tests for inconsistent quoting strategy.
+
+In this file, single quotes are the majority quote delimiter.
+"""
+
+FIRST_STRING = "double-quoted string" # [inconsistent-quotes]
+SECOND_STRING = 'single-quoted string'
+THIRD_STRING = 'another single-quoted string'
+FOURTH_STRING = 'yet another single-quoted string'
+FIFTH_STRING = "double-quoted string with an unescaped 'single quote'"
diff --git a/tests/functional/i/inconsistent/inconsistent_quotes2.rc b/tests/functional/i/inconsistent/inconsistent_quotes2.rc
new file mode 100644
index 0000000..9935ff9
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_quotes2.rc
@@ -0,0 +1,2 @@
+[STRING]
+check-quote-consistency=yes
diff --git a/tests/functional/i/inconsistent/inconsistent_quotes2.txt b/tests/functional/i/inconsistent/inconsistent_quotes2.txt
new file mode 100644
index 0000000..0f2f77b
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_quotes2.txt
@@ -0,0 +1 @@
+inconsistent-quotes:6:0::"Quote delimiter "" is inconsistent with the rest of the file"
diff --git a/tests/functional/i/inconsistent/inconsistent_returns.py b/tests/functional/i/inconsistent/inconsistent_returns.py
new file mode 100644
index 0000000..08dde25
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_returns.py
@@ -0,0 +1,355 @@
+#pylint: disable=missing-docstring, no-else-return, no-else-break, invalid-name, unused-variable, superfluous-parens, try-except-raise
+#pylint: disable=disallowed-name
+"""Testing inconsistent returns"""
+import math
+import sys
+
+# These ones are consistent
+def explicit_returns(var):
+ if var >= 0:
+ return math.sqrt(var)
+ else:
+ return None
+
+def explicit_returns2(var):
+ if var < 0:
+ return None
+ return math.sqrt(var)
+
+def empty_implicit_returns(var):
+ if var < 0:
+ return
+
+def returns_in_exceptions():
+ try:
+ raise ValueError('test')
+ except ValueError:
+ return 1
+ except (OSError, TypeError):
+ return 2
+
+def returns_and_exceptions(var):
+ if var < 10:
+ return var**2
+ else:
+ raise ValueError("Incorrect value")
+
+def returns_and_exceptions_issue1770(var):
+ try:
+ if var == 1:
+ return 'a'
+ elif var == 2:
+ return 'b'
+ else:
+ raise ValueError
+ except AssertionError:
+ return None
+
+def explicit_returns3(arg):
+ if arg:
+ return False
+ else:
+ if arg < 3:
+ print('arg < 3')
+ return True
+
+def explicit_returns4(arg):
+ if arg:
+ if arg > 2:
+ print('arg > 2')
+ return False
+ else:
+ if arg < 3:
+ print('arg < 3')
+ return True
+
+def explicit_returns5(arg):
+ if arg:
+ if arg > 2:
+ print('arg > 2')
+ return False
+ else:
+ return True
+
+def nested_function():
+ def dummy_return():
+ return True
+ return dummy_return
+
+def explicit_returns6(x, y, z):
+ if x: # pylint: disable=no-else-return
+ a = 1
+ if y: # pylint: disable=no-else-return
+ b = 2
+ return y
+ else:
+ c = 3
+ return x
+ else:
+ d = 4
+ return z
+
+def explicit_returns7(arg):
+ if arg < 0:
+ arg = 2 * arg
+ return 'below 0'
+ elif arg == 0:
+ print("Null arg")
+ return '0'
+ else:
+ arg = 3 * arg
+ return 'above 0'
+
+def bug_1772():
+ """Don't check inconsistent return statements inside while loop"""
+ counter = 1
+ while True:
+ counter += 1
+ if counter == 100:
+ return 7
+
+def bug_1771(var):
+ if var == 1:
+ sys.exit(1)
+ else:
+ return var * 2
+
+def bug_1771_with_user_config(var):
+ # sys.getdefaultencoding is considered as a never
+ # returning function in the inconsistent_returns.rc file.
+ if var == 1:
+ sys.getdefaultencoding()
+ else:
+ return var * 2
+
+def bug_1794_inner_func_in_if(var):
+ # pylint: disable = no-else-return,useless-return
+ if var:
+ def _inner():
+ return None
+ return None
+ else:
+ return None
+
+try:
+ import ConfigParser as configparser
+except ImportError:
+ import configparser
+
+# Due to the try/except import above, astroid cannot safely
+# infer the exception type. It doesn't matter here, because
+# as the raise statement is not inside a try/except one, there
+# is no need to infer the exception type. It is just an exception
+# that is raised.
+def bug_1794(a):
+ for x in range(a):
+ if x == 100:
+ return a
+ raise configparser.NoSectionError('toto')
+
+#pylint: disable = no-else-return
+def bug_1782_bis(val=3):
+ if val == 3:
+ while True:
+ break
+ return True
+ else:
+ raise RuntimeError()
+
+# Next ones are not consistent
+def explicit_implicit_returns(var): # [inconsistent-return-statements]
+ if var >= 0:
+ return math.sqrt(var)
+
+def empty_explicit_returns(var): # [inconsistent-return-statements]
+ if var < 0:
+ return
+ return math.sqrt(var)
+
+def explicit_implicit_returns2(arg): # [inconsistent-return-statements]
+ if arg:
+ if arg > 2:
+ print('arg > 2')
+ return False
+ else:
+ return True
+
+def explicit_implicit_returns3(arg): # [inconsistent-return-statements]
+ if arg:
+ if arg > 2:
+ print('arg > 2')
+ return False
+ else:
+ return True
+
+def returns_missing_in_catched_exceptions(arg): # [inconsistent-return-statements]
+ try:
+ arg = arg**2
+ raise ValueError('test')
+ except ValueError:
+ print('ValueError')
+ arg = 0
+ except (OSError, TypeError):
+ return 2
+
+def complex_func(arg): # [inconsistent-return-statements]
+ for i in range(arg):
+ if i > arg / 2:
+ break
+ else:
+ return arg
+
+def inconsistent_returns_in_nested_function():
+ def not_consistent_returns_inner(arg): # [inconsistent-return-statements]
+ for i in range(arg):
+ if i > arg / 2:
+ break
+ else:
+ return arg
+ return not_consistent_returns_inner
+
+def bug_1771_counter_example(var): # [inconsistent-return-statements]
+ if var == 1:
+ inconsistent_returns_in_nested_function()
+ else:
+ return var * 2
+
+class BlargException(Exception):
+ pass
+
+
+def blarg(someval):
+ try:
+ if someval:
+ raise BlargException()
+ return 5
+ except BlargException:
+ raise
+
+def bug_1772_counter_example(): # [inconsistent-return-statements]
+ counter = 1
+ if counter == 1:
+ while True:
+ counter += 1
+ if counter == 100:
+ return 7
+
+def bug_1794_inner_func_in_if_counter_example_1(var): # [inconsistent-return-statements]
+ # pylint: disable = no-else-return,useless-return
+ if var:
+ def _inner():
+ return None
+ return None
+ else:
+ return
+
+def bug_1794_inner_func_in_if_counter_example_2(var): # [inconsistent-return-statements]
+ # pylint: disable = no-else-return,useless-return
+ if var:
+ def _inner():
+ return
+ return None
+ else:
+ return
+
+def bug_1794_inner_func_in_if_counter_example_3(var): # [inconsistent-return-statements]
+ # pylint: disable = no-else-return,useless-return
+ if var:
+ def _inner():
+ return None
+ return None
+ else:
+ def _inner2(var_bis): # [inconsistent-return-statements]
+ if var_bis:
+ return True
+ return
+
+def bug_3468(bar): # [inconsistent-return-statements]
+ """
+ In case of AttributeError the function returns implicitly None.
+ There are one explicit return and one implicit.
+ """
+ try:
+ return bar.baz
+ except AttributeError:
+ pass
+
+def bug_3468_variant(bar): # [inconsistent-return-statements]
+ """
+ In case of AttributeError the function returns implicitly None
+ There are one explicit return and one implicit.
+ """
+ try:
+ return bar.baz
+ except AttributeError:
+ pass
+ except KeyError:
+ return True
+ except ValueError:
+ raise
+
+def bug_3468_counter_example(bar):
+ """
+ In case of AttributeError the function returns explicitly None.
+ Thus all returns are explicit.
+ """
+ try:
+ return bar.baz
+ except AttributeError:
+ pass
+ return None
+
+def bug_3468_counter_example_2(bar):
+ """
+ In case of AttributeError the function returns explicitly None.
+ Thus all returns are explicit.
+ """
+ try:
+ return bar.baz
+ except AttributeError:
+ return None
+
+def nothing_to_do():
+ pass
+
+def bug_pylint_3873():
+ try:
+ nothing_to_do()
+ return True
+ except IndexError:
+ return False
+
+def bug_pylint_3873_1(): # [inconsistent-return-statements]
+ try:
+ nothing_to_do()
+ return True
+ except IndexError:
+ pass
+ except ValueError:
+ return False
+
+def bug_pylint_3873_2():
+ try:
+ nothing_to_do()
+ return True
+ except IndexError:
+ nothing_to_do()
+ return False
+
+# https://github.com/PyCQA/pylint/issues/4019
+def bug_pylint_4019(x):
+ """
+ assert False is equivalent to a return
+ """
+ if x == 1:
+ return 42
+ assert False
+
+
+def bug_pylint_4019_wrong(x): # [inconsistent-return-statements]
+ """
+ assert True is not equivalent to a return
+ """
+ if x == 1:
+ return 42
+ assert True
diff --git a/tests/functional/i/inconsistent/inconsistent_returns.rc b/tests/functional/i/inconsistent/inconsistent_returns.rc
new file mode 100644
index 0000000..dd6cbb5
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_returns.rc
@@ -0,0 +1,2 @@
+[REFACTORING]
+never-returning-functions=sys.exit,sys.getdefaultencoding
diff --git a/tests/functional/i/inconsistent/inconsistent_returns.txt b/tests/functional/i/inconsistent/inconsistent_returns.txt
new file mode 100644
index 0000000..d0a6dd1
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_returns.txt
@@ -0,0 +1,17 @@
+inconsistent-return-statements:160:0:explicit_implicit_returns:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:164:0:empty_explicit_returns:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:169:0:explicit_implicit_returns2:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:177:0:explicit_implicit_returns3:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:185:0:returns_missing_in_catched_exceptions:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:195:0:complex_func:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:203:4:inconsistent_returns_in_nested_function.not_consistent_returns_inner:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:211:0:bug_1771_counter_example:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:229:0:bug_1772_counter_example:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:237:0:bug_1794_inner_func_in_if_counter_example_1:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:246:0:bug_1794_inner_func_in_if_counter_example_2:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:255:0:bug_1794_inner_func_in_if_counter_example_3:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:262:8:bug_1794_inner_func_in_if_counter_example_3._inner2:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:267:0:bug_3468:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:277:0:bug_3468_variant:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:322:0:bug_pylint_3873_1:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:349:0:bug_pylint_4019_wrong:Either all return statements in a function should return an expression, or none of them should.
diff --git a/tests/functional/i/inconsistent/inconsistent_returns_noreturn.py b/tests/functional/i/inconsistent/inconsistent_returns_noreturn.py
new file mode 100644
index 0000000..768d6e6
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_returns_noreturn.py
@@ -0,0 +1,55 @@
+"""Testing inconsistent returns involving typing.NoReturn annotations."""
+# pylint: disable=missing-docstring, invalid-name
+
+import sys
+import typing
+
+def parser_error(msg) -> typing.NoReturn: # pylint: disable=unused-argument
+ sys.exit(1)
+
+def parser_error_nortype(msg): # pylint: disable=unused-argument
+ sys.exit(2)
+
+
+from typing import NoReturn # pylint: disable=wrong-import-position
+
+def parser_error_name(msg) -> NoReturn: # pylint: disable=unused-argument
+ sys.exit(3)
+
+def bug_pylint_4122(s):
+ """
+ Every returns is consistent because parser_error has type hints
+ indicating it never returns
+ """
+ try:
+ n = int(s)
+ if n < 1:
+ raise ValueError()
+ return n
+ except ValueError:
+ parser_error('parser error')
+
+def bug_pylint_4122_wrong(s): # [inconsistent-return-statements]
+ """
+ Every returns is not consistent because parser_error_nortype has no type hints
+ """
+ try:
+ n = int(s)
+ if n < 1:
+ raise ValueError()
+ return n
+ except ValueError:
+ parser_error_nortype('parser error')
+
+def bug_pylint_4122_bis(s):
+ """
+ Every returns is consistent because parser_error has type hints
+ indicating it never returns
+ """
+ try:
+ n = int(s)
+ if n < 1:
+ raise ValueError()
+ return n
+ except ValueError:
+ parser_error_name('parser error')
diff --git a/tests/functional/i/inconsistent/inconsistent_returns_noreturn.rc b/tests/functional/i/inconsistent/inconsistent_returns_noreturn.rc
new file mode 100644
index 0000000..bf9569b
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_returns_noreturn.rc
@@ -0,0 +1,5 @@
+[testoptions]
+min_pyver=3.6.2
+
+[REFACTORING]
+never-returning-functions=sys.exit,sys.getdefaultencoding
diff --git a/tests/functional/i/inconsistent/inconsistent_returns_noreturn.txt b/tests/functional/i/inconsistent/inconsistent_returns_noreturn.txt
new file mode 100644
index 0000000..9b23552
--- /dev/null
+++ b/tests/functional/i/inconsistent/inconsistent_returns_noreturn.txt
@@ -0,0 +1 @@
+inconsistent-return-statements:32:0:bug_pylint_4122_wrong:Either all return statements in a function should return an expression, or none of them should.
diff --git a/tests/functional/i/inherit_non_class.py b/tests/functional/i/inherit_non_class.py
new file mode 100644
index 0000000..ee9ef50
--- /dev/null
+++ b/tests/functional/i/inherit_non_class.py
@@ -0,0 +1,81 @@
+"""Test that inheriting from something which is not
+a class emits a warning. """
+
+# pylint: disable=no-init, import-error, invalid-name, using-constant-test, useless-object-inheritance
+# pylint: disable=missing-docstring, too-few-public-methods, no-absolute-import
+
+from missing import Missing
+
+if 1:
+ Ambiguous = None
+else:
+ Ambiguous = int
+
+class Empty(object):
+ """ Empty class. """
+
+def return_class():
+ """ Return a class. """
+ return Good3
+
+class Bad(1): # [inherit-non-class]
+ """ Can't inherit from instance. """
+
+class Bad1(lambda abc: 42): # [inherit-non-class]
+ """ Can't inherit from lambda. """
+
+class Bad2(object()): # [inherit-non-class]
+ """ Can't inherit from an instance of object. """
+
+class Bad3(return_class): # [inherit-non-class]
+ """ Can't inherit from function. """
+
+class Bad4(Empty()): # [inherit-non-class]
+ """ Can't inherit from instance. """
+
+class Good(object):
+ pass
+
+class Good1(int):
+ pass
+
+class Good2(type):
+ pass
+
+class Good3(type(int)):
+ pass
+
+class Good4(return_class()):
+ pass
+
+class Good5(Good4, int, object):
+ pass
+
+class Good6(Ambiguous):
+ """ Inherits from something ambiguous.
+
+ This could emit a warning when we will have
+ flow detection.
+ """
+
+class Unknown(Missing):
+ pass
+
+class Unknown1(Good5 if True else Bad1):
+ pass
+
+
+class NotInheritableBool(bool): # [inherit-non-class]
+ pass
+
+
+class NotInheritableRange(range): # [inherit-non-class]
+ pass
+
+
+class NotInheritableSlice(slice): # [inherit-non-class]
+ pass
+
+
+class NotInheritableMemoryView(memoryview): # [inherit-non-class]
+ pass
diff --git a/tests/functional/i/inherit_non_class.txt b/tests/functional/i/inherit_non_class.txt
new file mode 100644
index 0000000..9252c2f
--- /dev/null
+++ b/tests/functional/i/inherit_non_class.txt
@@ -0,0 +1,9 @@
+inherit-non-class:21:0:Bad:Inheriting '1', which is not a class.
+inherit-non-class:24:0:Bad1:"Inheriting 'lambda abc: 42', which is not a class."
+inherit-non-class:27:0:Bad2:Inheriting 'object()', which is not a class.
+inherit-non-class:30:0:Bad3:Inheriting 'return_class', which is not a class.
+inherit-non-class:33:0:Bad4:Inheriting 'Empty()', which is not a class.
+inherit-non-class:68:0:NotInheritableBool:Inheriting 'bool', which is not a class.
+inherit-non-class:72:0:NotInheritableRange:Inheriting 'range', which is not a class.
+inherit-non-class:76:0:NotInheritableSlice:Inheriting 'slice', which is not a class.
+inherit-non-class:80:0:NotInheritableMemoryView:Inheriting 'memoryview', which is not a class.
diff --git a/tests/functional/i/init_is_generator.py b/tests/functional/i/init_is_generator.py
new file mode 100644
index 0000000..17f96db
--- /dev/null
+++ b/tests/functional/i/init_is_generator.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-docstring,too-few-public-methods, useless-object-inheritance
+
+class SomeClass(object):
+ def __init__(self): # [init-is-generator]
+ yield None
diff --git a/tests/functional/i/init_is_generator.txt b/tests/functional/i/init_is_generator.txt
new file mode 100644
index 0000000..b341a07
--- /dev/null
+++ b/tests/functional/i/init_is_generator.txt
@@ -0,0 +1 @@
+init-is-generator:4:4:SomeClass.__init__:__init__ method is a generator
diff --git a/tests/functional/i/init_not_called.py b/tests/functional/i/init_not_called.py
new file mode 100644
index 0000000..8f646eb
--- /dev/null
+++ b/tests/functional/i/init_not_called.py
@@ -0,0 +1,86 @@
+# pylint: disable=too-few-public-methods,import-error,missing-docstring,wrong-import-position,useless-super-delegation, useless-object-inheritance, unnecessary-pass
+"""test for __init__ not called
+"""
+from __future__ import print_function
+
+class AAAA:
+ """ancestor 1"""
+
+ def __init__(self):
+ print('init', self)
+
+class BBBB:
+ """ancestor 2"""
+
+ def __init__(self):
+ print('init', self)
+
+class CCCC:
+ """ancestor 3"""
+
+
+class ZZZZ(AAAA, BBBB, CCCC):
+ """derived class"""
+
+ def __init__(self): # [super-init-not-called]
+ AAAA.__init__(self)
+
+class NewStyleA(object):
+ """new style class"""
+ def __init__(self):
+ super().__init__()
+ print('init', self)
+
+class NewStyleB(NewStyleA):
+ """derived new style class"""
+ def __init__(self):
+ super().__init__()
+
+class NoInit(object):
+ """No __init__ defined"""
+
+class Init(NoInit):
+ """Don't complain for not calling the super __init__"""
+
+ def __init__(self, arg):
+ self.arg = arg
+
+class NewStyleC(object):
+ """__init__ defined by assignment."""
+ def xx_init(self):
+ """Initializer."""
+ pass
+
+ __init__ = xx_init
+
+class AssignedInit(NewStyleC):
+ """No init called."""
+ def __init__(self): # [super-init-not-called]
+ self.arg = 0
+
+from missing import Missing
+
+class UnknownBases(Missing):
+ """Don't emit no-init if the bases aren't known."""
+
+
+from typing import overload # pylint: disable=wrong-import-order
+
+class Parent:
+
+ def __init__(self, num: int):
+ self.number = num
+
+
+class Child(Parent):
+
+ @overload
+ def __init__(self, num: int):
+ ...
+
+ @overload
+ def __init__(self, num: float):
+ ...
+
+ def __init__(self, num):
+ super().__init__(round(num))
diff --git a/tests/functional/i/init_not_called.txt b/tests/functional/i/init_not_called.txt
new file mode 100644
index 0000000..332f1db
--- /dev/null
+++ b/tests/functional/i/init_not_called.txt
@@ -0,0 +1,2 @@
+super-init-not-called:25:4:ZZZZ.__init__:__init__ method from base class 'BBBB' is not called
+super-init-not-called:58:4:AssignedInit.__init__:__init__ method from base class 'NewStyleC' is not called
diff --git a/tests/functional/i/init_return_from_inner_function.py b/tests/functional/i/init_return_from_inner_function.py
new file mode 100644
index 0000000..065a1ad
--- /dev/null
+++ b/tests/functional/i/init_return_from_inner_function.py
@@ -0,0 +1,12 @@
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+"""#10075"""
+
+__revision__ = 1
+
+class Aaa(object):
+ """docstring"""
+ def __init__(self):
+ def inner_function(arg):
+ """inner docstring"""
+ return arg + 4
+ self.func = inner_function
diff --git a/tests/functional/i/init_subclass_classmethod_py36.py b/tests/functional/i/init_subclass_classmethod_py36.py
new file mode 100644
index 0000000..ad37970
--- /dev/null
+++ b/tests/functional/i/init_subclass_classmethod_py36.py
@@ -0,0 +1,16 @@
+# pylint: disable=too-few-public-methods, missing-docstring,no-init, useless-object-inheritance
+
+class PluginBase(object):
+ subclasses = []
+
+ def __init_subclass__(cls, **kwargs):
+ super().__init_subclass__(**kwargs)
+ cls.subclasses.append(cls)
+
+
+class Plugin1(PluginBase):
+ pass
+
+
+class Plugin2(PluginBase):
+ pass
diff --git a/tests/functional/i/init_subclass_classmethod_py36.rc b/tests/functional/i/init_subclass_classmethod_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/i/init_subclass_classmethod_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/i/inner_classes.py b/tests/functional/i/inner_classes.py
new file mode 100644
index 0000000..7ce8101
--- /dev/null
+++ b/tests/functional/i/inner_classes.py
@@ -0,0 +1,33 @@
+# pylint: disable=too-few-public-methods, useless-object-inheritance, unnecessary-pass
+"""Backend Base Classes for the schwelm user DB"""
+
+__revision__ = "alpha"
+
+class Aaa(object):
+ """docstring"""
+ def __init__(self):
+ self.__setattr__('a', 'b')
+
+
+ def one_public(self):
+ """docstring"""
+ pass
+
+ def another_public(self):
+ """docstring"""
+ pass
+
+class Bbb(Aaa):
+ """docstring"""
+ pass
+
+class Ccc(Aaa):
+ """docstring"""
+
+ class Ddd(Aaa):
+ """docstring"""
+ pass
+
+ class Eee(Ddd):
+ """docstring"""
+ pass
diff --git a/tests/functional/i/invalid/b/invalid_bool_returned.py b/tests/functional/i/invalid/b/invalid_bool_returned.py
new file mode 100644
index 0000000..0e68ed2
--- /dev/null
+++ b/tests/functional/i/invalid/b/invalid_bool_returned.py
@@ -0,0 +1,62 @@
+"""Check invalid value returned by __bool__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodBool(object):
+ """__bool__ returns <type 'bool'>"""
+
+ def __bool__(self):
+ return True
+
+
+class SecondGoodBool(object):
+ """__bool__ returns <type 'bool'>"""
+
+ def __bool__(self):
+ return bool(0)
+
+
+class BoolMetaclass(type):
+ def __bool__(cls):
+ return True
+
+
+@six.add_metaclass(BoolMetaclass)
+class ThirdGoodBool(object):
+ """Bool through the metaclass."""
+
+
+class FirstBadBool(object):
+ """ __bool__ returns an integer """
+
+ def __bool__(self): # [invalid-bool-returned]
+ return 1
+
+
+class SecondBadBool(object):
+ """ __bool__ returns str """
+
+ def __bool__(self): # [invalid-bool-returned]
+ return "True"
+
+
+class ThirdBadBool(object):
+ """ __bool__ returns node which does not have 'value' in AST """
+
+ def __bool__(self): # [invalid-bool-returned]
+ return lambda: 3
+
+
+class AmbigousBool(object):
+ """ Uninferable return value """
+ __bool__ = lambda self: Missing
+
+
+class AnotherAmbiguousBool(object):
+ """Potential uninferable return value"""
+ def __bool__(self):
+ return bool(Missing)
diff --git a/tests/functional/i/invalid/b/invalid_bool_returned.txt b/tests/functional/i/invalid/b/invalid_bool_returned.txt
new file mode 100644
index 0000000..9af5b18
--- /dev/null
+++ b/tests/functional/i/invalid/b/invalid_bool_returned.txt
@@ -0,0 +1,3 @@
+invalid-bool-returned:36:4:FirstBadBool.__bool__:__bool__ does not return bool
+invalid-bool-returned:43:4:SecondBadBool.__bool__:__bool__ does not return bool
+invalid-bool-returned:50:4:ThirdBadBool.__bool__:__bool__ does not return bool
diff --git a/tests/functional/i/invalid/b/invalid_bytes_returned.py b/tests/functional/i/invalid/b/invalid_bytes_returned.py
new file mode 100644
index 0000000..703fea2
--- /dev/null
+++ b/tests/functional/i/invalid/b/invalid_bytes_returned.py
@@ -0,0 +1,64 @@
+"""Check invalid value returned by __bytes__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodBytes(object):
+ """__bytes__ returns <type 'bytes'>"""
+
+ def __bytes__(self):
+ return b"some bytes"
+
+
+class SecondGoodBytes(object):
+ """__bytes__ returns <type 'bytes'>"""
+
+ def __bytes__(self):
+ return bytes("123", "ascii")
+
+
+class BytesMetaclass(type):
+ def __bytes__(cls):
+ return b"some bytes"
+
+
+@six.add_metaclass(BytesMetaclass)
+class ThirdGoodBytes(object):
+ """Bytes through the metaclass."""
+
+
+class FirstBadBytes(object):
+ """ __bytes__ returns bytes """
+
+ def __bytes__(self): # [invalid-bytes-returned]
+ return "123"
+
+
+class SecondBadBytes(object):
+ """ __bytes__ returns int """
+
+ def __bytes__(self): # [invalid-bytes-returned]
+ return 1
+
+
+class ThirdBadBytes(object):
+ """ __bytes__ returns node which does not have 'value' in AST """
+
+ def __bytes__(self): # [invalid-bytes-returned]
+ return lambda: b"some bytes"
+
+
+class AmbiguousBytes(object):
+ """ Uninferable return value """
+
+ __bytes__ = lambda self: Missing
+
+
+class AnotherAmbiguousBytes(object):
+ """Potential uninferable return value"""
+
+ def __bytes__(self):
+ return bytes(Missing)
diff --git a/tests/functional/i/invalid/b/invalid_bytes_returned.txt b/tests/functional/i/invalid/b/invalid_bytes_returned.txt
new file mode 100644
index 0000000..63440cb
--- /dev/null
+++ b/tests/functional/i/invalid/b/invalid_bytes_returned.txt
@@ -0,0 +1,3 @@
+invalid-bytes-returned:36:4:FirstBadBytes.__bytes__:__bytes__ does not return bytes
+invalid-bytes-returned:43:4:SecondBadBytes.__bytes__:__bytes__ does not return bytes
+invalid-bytes-returned:50:4:ThirdBadBytes.__bytes__:__bytes__ does not return bytes
diff --git a/tests/functional/i/invalid/e/invalid_envvar_value.py b/tests/functional/i/invalid/e/invalid_envvar_value.py
new file mode 100644
index 0000000..3c1a888
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_envvar_value.py
@@ -0,0 +1,84 @@
+# pylint: disable=useless-return,missing-docstring
+from os import getenv
+
+
+def function_returning_list():
+ return []
+
+def function_returning_none():
+ return None
+
+def function_returning_string():
+ return "Result"
+
+def function_returning_bytes():
+ return b"Result"
+
+def deep_function_returning_string():
+ return function_returning_string()
+
+def deep_function_returning_bytes():
+ return function_returning_bytes()
+
+
+# --------------------------------------------------------------------------- #
+# Testing getenv #
+# --------------------------------------------------------------------------- #
+
+getenv() # pylint: disable=no-value-for-parameter
+
+getenv(b"TEST") # [invalid-envvar-value]
+getenv("TEST")
+getenv(None) # [invalid-envvar-value]
+getenv(["Crap"]) # [invalid-envvar-value]
+getenv(function_returning_bytes()) # [invalid-envvar-value]
+getenv(deep_function_returning_bytes()) # [invalid-envvar-value]
+getenv(function_returning_list()) # [invalid-envvar-value]
+getenv(function_returning_none()) # [invalid-envvar-value]
+getenv(function_returning_string())
+getenv(deep_function_returning_string())
+
+getenv(b"TEST", "default") # [invalid-envvar-value]
+getenv("TEST", "default")
+getenv(None, "default") # [invalid-envvar-value]
+getenv(["Crap"], "default") # [invalid-envvar-value]
+getenv(function_returning_bytes(), "default") # [invalid-envvar-value]
+getenv(function_returning_list(), "default") # [invalid-envvar-value]
+getenv(function_returning_none(), "default") # [invalid-envvar-value]
+getenv(function_returning_string(), "default")
+
+getenv(key=b"TEST") # [invalid-envvar-value]
+getenv(key="TEST")
+getenv(key=None) # [invalid-envvar-value]
+getenv(key=["Crap"]) # [invalid-envvar-value]
+getenv(key=function_returning_bytes()) # [invalid-envvar-value]
+getenv(key=function_returning_list()) # [invalid-envvar-value]
+getenv(key=function_returning_none()) # [invalid-envvar-value]
+getenv(key=function_returning_string())
+
+getenv('TEST', "value")
+getenv('TEST', []) # [invalid-envvar-default]
+getenv('TEST', None)
+getenv('TEST', b"123") # [invalid-envvar-default]
+getenv('TEST', function_returning_list()) # [invalid-envvar-default]
+getenv('TEST', function_returning_none())
+getenv('TEST', function_returning_string())
+getenv('TEST', function_returning_bytes()) # [invalid-envvar-default]
+
+getenv('TEST', default="value")
+getenv('TEST', default=[]) # [invalid-envvar-default]
+getenv('TEST', default=None)
+getenv('TEST', default=b"123") # [invalid-envvar-default]
+getenv('TEST', default=function_returning_list()) # [invalid-envvar-default]
+getenv('TEST', default=function_returning_none())
+getenv('TEST', default=function_returning_string())
+getenv('TEST', default=function_returning_bytes()) # [invalid-envvar-default]
+
+getenv(key='TEST')
+getenv(key='TEST', default="value")
+getenv(key='TEST', default=b"value") # [invalid-envvar-default]
+getenv(key='TEST', default=["Crap"]) # [invalid-envvar-default]
+getenv(key='TEST', default=function_returning_list()) # [invalid-envvar-default]
+getenv(key='TEST', default=function_returning_none())
+getenv(key='TEST', default=function_returning_string())
+getenv(key='TEST', default=function_returning_bytes()) # [invalid-envvar-default]
diff --git a/tests/functional/i/invalid/e/invalid_envvar_value.txt b/tests/functional/i/invalid/e/invalid_envvar_value.txt
new file mode 100644
index 0000000..cec352b
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_envvar_value.txt
@@ -0,0 +1,31 @@
+invalid-envvar-value:30:0::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:32:0::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:33:0::os.getenv does not support builtins.list type argument
+invalid-envvar-value:34:0::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:35:0::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:36:0::os.getenv does not support builtins.list type argument
+invalid-envvar-value:37:0::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:41:0::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:43:0::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:44:0::os.getenv does not support builtins.list type argument
+invalid-envvar-value:45:0::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:46:0::os.getenv does not support builtins.list type argument
+invalid-envvar-value:47:0::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:50:0::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:52:0::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:53:0::os.getenv does not support builtins.list type argument
+invalid-envvar-value:54:0::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:55:0::os.getenv does not support builtins.list type argument
+invalid-envvar-value:56:0::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-default:60:0::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:62:0::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:63:0::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:66:0::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:69:0::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:71:0::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:72:0::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:75:0::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:79:0::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:80:0::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:81:0::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:84:0::os.getenv default type is builtins.bytes. Expected str or None.
diff --git a/tests/functional/i/invalid/e/invalid_exceptions_caught.py b/tests/functional/i/invalid/e/invalid_exceptions_caught.py
new file mode 100644
index 0000000..2526434
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_exceptions_caught.py
@@ -0,0 +1,135 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+# pylint: disable=too-many-ancestors, no-absolute-import, import-error, multiple-imports,wrong-import-position
+from __future__ import print_function
+
+import socket, binascii, abc, six
+
+class MyException(object):
+ """Custom 'exception'."""
+
+class MySecondException(object):
+ """Custom 'exception'."""
+
+class MyGoodException(Exception):
+ """Custom exception."""
+
+class MySecondGoodException(MyGoodException):
+ """Custom exception."""
+
+class SkipException(socket.error):
+ """Not an exception for Python 2, but one in 3."""
+
+class SecondSkipException(SkipException):
+ """Also a good exception."""
+
+try:
+ 1 + 1
+except MyException: # [catching-non-exception]
+ print("caught")
+
+try:
+ 1 + 2
+# +1:[catching-non-exception,catching-non-exception]
+except (MyException, MySecondException):
+ print("caught")
+
+try:
+ 1 + 3
+except MyGoodException:
+ print("caught")
+
+try:
+ 1 + 3
+except (MyGoodException, MySecondGoodException):
+ print("caught")
+
+try:
+ 1 + 3
+except (SkipException, SecondSkipException):
+ print("caught")
+
+try:
+ 1 + 42
+# +1:[catching-non-exception,catching-non-exception]
+except (None, list()):
+ print("caught")
+
+try:
+ 1 + 24
+except None: # [catching-non-exception]
+ print("caught")
+
+EXCEPTION = None
+EXCEPTION = ZeroDivisionError
+try:
+ 1 + 46
+except EXCEPTION:
+ print("caught")
+
+try:
+ 1 + 42
+# +1:[catching-non-exception,catching-non-exception,catching-non-exception]
+except (list([4, 5, 6]), None, ZeroDivisionError, 4):
+ print("caught")
+
+EXCEPTION_TUPLE = (ZeroDivisionError, OSError)
+NON_EXCEPTION_TUPLE = (ZeroDivisionError, OSError, 4)
+
+try:
+ 1 + 42
+except EXCEPTION_TUPLE:
+ print("caught")
+
+try:
+ 1 + 42
+except NON_EXCEPTION_TUPLE: # [catching-non-exception]
+ print("caught")
+
+from missing_import import UnknownError
+UNKNOWN_COMPONENTS = (ZeroDivisionError, UnknownError)
+
+try:
+ 1 + 42
+except UNKNOWN_COMPONENTS:
+ print("caught")
+
+try:
+ 1 + 42
+except binascii.Error:
+ print('builtin and detected')
+
+try:
+ 1 + 45
+except object: # [catching-non-exception]
+ print('caught')
+
+try:
+ 1 + 42
+except range: # [catching-non-exception]
+ print('caught')
+
+
+class HasErrorInMRO(six.with_metaclass(abc.ABCMeta, Exception)):
+ pass
+
+
+class Second(HasErrorInMRO):
+ pass
+
+
+try:
+ raise Second
+except Second:
+ pass
+
+
+class SomeBase(UnknownError):
+ pass
+
+
+EXCEPTIONS = (SomeBase, ValueError)
+
+try:
+ raise ValueError
+except EXCEPTIONS:
+ pass
diff --git a/tests/functional/i/invalid/e/invalid_exceptions_caught.rc b/tests/functional/i/invalid/e/invalid_exceptions_caught.rc
new file mode 100644
index 0000000..6a8ee96
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_exceptions_caught.rc
@@ -0,0 +1,2 @@
+[testoptions]
+requires = six
diff --git a/tests/functional/i/invalid/e/invalid_exceptions_caught.txt b/tests/functional/i/invalid/e/invalid_exceptions_caught.txt
new file mode 100644
index 0000000..4beed61
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_exceptions_caught.txt
@@ -0,0 +1,12 @@
+catching-non-exception:27:7::"Catching an exception which doesn't inherit from Exception: MyException"
+catching-non-exception:33:7::"Catching an exception which doesn't inherit from Exception: MyException"
+catching-non-exception:33:7::"Catching an exception which doesn't inherit from Exception: MySecondException"
+catching-non-exception:54:7::"Catching an exception which doesn't inherit from Exception: None"
+catching-non-exception:54:7::"Catching an exception which doesn't inherit from Exception: list()"
+catching-non-exception:59:7::"Catching an exception which doesn't inherit from Exception: None"
+catching-non-exception:72:7::"Catching an exception which doesn't inherit from Exception: 4"
+catching-non-exception:72:7::"Catching an exception which doesn't inherit from Exception: None"
+catching-non-exception:72:7::"Catching an exception which doesn't inherit from Exception: list([4, 5, 6])"
+catching-non-exception:85:7::"Catching an exception which doesn't inherit from Exception: NON_EXCEPTION_TUPLE"
+catching-non-exception:103:7::"Catching an exception which doesn't inherit from Exception: object"
+catching-non-exception:108:7::"Catching an exception which doesn't inherit from Exception: range"
diff --git a/tests/functional/i/invalid/e/invalid_exceptions_raised.py b/tests/functional/i/invalid/e/invalid_exceptions_raised.py
new file mode 100644
index 0000000..34f740d
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_exceptions_raised.py
@@ -0,0 +1,105 @@
+# pylint:disable=too-few-public-methods,no-init,import-error,missing-docstring, not-callable, useless-object-inheritance,import-outside-toplevel
+"""test pb with exceptions and old/new style classes"""
+
+
+class ValidException(Exception):
+ """Valid Exception."""
+
+class OldStyleClass:
+ """Not an exception."""
+
+class NewStyleClass(object):
+ """Not an exception."""
+
+
+def good_case():
+ """raise"""
+ raise ValidException('hop')
+
+def good_case1():
+ """zlib.error is defined in C module."""
+ import zlib
+ raise zlib.error(4)
+
+def good_case2():
+ """decimal.DivisionByZero is defined in C on Python 3."""
+ import decimal
+ raise decimal.DivisionByZero(4)
+
+def good_case3():
+ """io.BlockingIOError is defined in C."""
+ import io
+ raise io.BlockingIOError
+
+def bad_case0():
+ """raise"""
+ # +2:<3.0:[nonstandard-exception]
+ # +1:>=3.0:[raising-non-exception]
+ raise OldStyleClass('hop')
+
+def bad_case1():
+ """raise"""
+ raise NewStyleClass() # [raising-non-exception]
+
+def bad_case2():
+ """raise"""
+ # +2:<3.0:[nonstandard-exception]
+ # +1:>=3.0:[raising-non-exception]
+ raise OldStyleClass('hop')
+
+def bad_case3():
+ """raise"""
+ raise NewStyleClass # [raising-non-exception]
+
+def bad_case4():
+ """raise"""
+ raise NotImplemented('hop') # [notimplemented-raised]
+
+def bad_case5():
+ """raise"""
+ raise 1 # [raising-bad-type]
+
+def bad_case6():
+ """raise"""
+ raise None # [raising-bad-type]
+
+def bad_case7():
+ """raise list"""
+ raise list # [raising-non-exception]
+
+def bad_case8():
+ """raise tuple"""
+ raise tuple # [raising-non-exception]
+
+def bad_case9():
+ """raise dict"""
+ raise dict # [raising-non-exception]
+
+def unknown_bases():
+ """Don't emit when we don't know the bases."""
+ from lala import bala # pylint: disable=import-outside-toplevel
+ class MyException(bala):
+ pass
+ raise MyException
+
+
+def exception_instance_regression():
+ """Exceptions have a particular class type"""
+ try:
+ int("9a")
+ except ValueError as exc:
+ raise exc
+
+
+def reusing_same_name_picks_the_latest_raised_value():
+ class Error(Exception):
+ """some error"""
+
+ exceptions = tuple([ValueError, TypeError])
+ try:
+ raise ValueError
+ except exceptions as exc: # pylint: disable=catching-non-exception
+ # https://github.com/PyCQA/pylint/issues/1756
+ exc = Error(exc)
+ if exc:
+ raise exc
diff --git a/tests/functional/i/invalid/e/invalid_exceptions_raised.txt b/tests/functional/i/invalid/e/invalid_exceptions_raised.txt
new file mode 100644
index 0000000..7985a71
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_exceptions_raised.txt
@@ -0,0 +1,10 @@
+raising-non-exception:38:4:bad_case0:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:42:4:bad_case1:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:48:4:bad_case2:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:52:4:bad_case3:Raising a new style class which doesn't inherit from BaseException
+notimplemented-raised:56:4:bad_case4:NotImplemented raised - should raise NotImplementedError
+raising-bad-type:60:4:bad_case5:Raising int while only classes or instances are allowed
+raising-bad-type:64:4:bad_case6:Raising NoneType while only classes or instances are allowed
+raising-non-exception:68:4:bad_case7:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:72:4:bad_case8:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:76:4:bad_case9:Raising a new style class which doesn't inherit from BaseException
diff --git a/tests/functional/i/invalid/g/invalid_getnewargs_ex_returned.py b/tests/functional/i/invalid/g/invalid_getnewargs_ex_returned.py
new file mode 100644
index 0000000..e378950
--- /dev/null
+++ b/tests/functional/i/invalid/g/invalid_getnewargs_ex_returned.py
@@ -0,0 +1,85 @@
+"""Check invalid value returned by __getnewargs_ex__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodGetNewArgsEx(object):
+ """__getnewargs_ex__ returns <type 'tuple'>"""
+
+ def __getnewargs_ex__(self):
+ return ((1,), {"2": "2"})
+
+
+class SecondGoodGetNewArgsEx(object):
+ """__getnewargs_ex__ returns <type 'tuple'>"""
+
+ def __getnewargs_ex__(self):
+ return (tuple(), dict())
+
+
+class GetNewArgsExMetaclass(type):
+ def __getnewargs_ex__(cls):
+ return ((1,), {"2": "2"})
+
+
+@six.add_metaclass(GetNewArgsExMetaclass)
+class ThirdGoodGetNewArgsEx(object):
+ """GetNewArgsEx through the metaclass."""
+
+
+class FirstBadGetNewArgsEx(object):
+ """ __getnewargs_ex__ returns an integer """
+
+ def __getnewargs_ex__(self): # [invalid-getnewargs-ex-returned]
+ return 1
+
+
+class SecondBadGetNewArgsEx(object):
+ """ __getnewargs_ex__ returns tuple with incorrect arg length"""
+
+ def __getnewargs_ex__(self): # [invalid-getnewargs-ex-returned]
+ return (tuple(1), dict(x="y"), 1)
+
+
+class ThirdBadGetNewArgsEx(object):
+ """ __getnewargs_ex__ returns tuple with wrong type for first arg """
+
+ def __getnewargs_ex__(self): # [invalid-getnewargs-ex-returned]
+ return (dict(x="y"), dict(x="y"))
+
+
+class FourthBadGetNewArgsEx(object):
+ """ __getnewargs_ex__ returns tuple with wrong type for second arg """
+
+ def __getnewargs_ex__(self): # [invalid-getnewargs-ex-returned]
+ return ((1, ), (1, ))
+
+
+class FifthBadGetNewArgsEx(object):
+ """ __getnewargs_ex__ returns tuple with wrong type for both args """
+
+ def __getnewargs_ex__(self): # [invalid-getnewargs-ex-returned]
+ return ({'x': 'y'}, (2,))
+
+
+class SixthBadGetNewArgsEx(object):
+ """ __getnewargs_ex__ returns node which does not have 'value' in AST """
+
+ def __getnewargs_ex__(self): # [invalid-getnewargs-ex-returned]
+ return lambda: (1, 2)
+
+
+class AmbigousGetNewArgsEx(object):
+ """ Uninferable return value """
+
+ __getnewargs_ex__ = lambda self: Missing
+
+
+class AnotherAmbiguousGetNewArgsEx(object):
+ """Potential uninferable return value"""
+
+ def __getnewargs_ex__(self):
+ return tuple(Missing)
diff --git a/tests/functional/i/invalid/g/invalid_getnewargs_ex_returned.txt b/tests/functional/i/invalid/g/invalid_getnewargs_ex_returned.txt
new file mode 100644
index 0000000..ea8c170
--- /dev/null
+++ b/tests/functional/i/invalid/g/invalid_getnewargs_ex_returned.txt
@@ -0,0 +1,6 @@
+invalid-getnewargs-ex-returned:36:4:FirstBadGetNewArgsEx.__getnewargs_ex__:__getnewargs_ex__ does not return a tuple containing (tuple, dict)
+invalid-getnewargs-ex-returned:43:4:SecondBadGetNewArgsEx.__getnewargs_ex__:__getnewargs_ex__ does not return a tuple containing (tuple, dict)
+invalid-getnewargs-ex-returned:50:4:ThirdBadGetNewArgsEx.__getnewargs_ex__:__getnewargs_ex__ does not return a tuple containing (tuple, dict)
+invalid-getnewargs-ex-returned:57:4:FourthBadGetNewArgsEx.__getnewargs_ex__:__getnewargs_ex__ does not return a tuple containing (tuple, dict)
+invalid-getnewargs-ex-returned:64:4:FifthBadGetNewArgsEx.__getnewargs_ex__:__getnewargs_ex__ does not return a tuple containing (tuple, dict)
+invalid-getnewargs-ex-returned:71:4:SixthBadGetNewArgsEx.__getnewargs_ex__:__getnewargs_ex__ does not return a tuple containing (tuple, dict)
diff --git a/tests/functional/i/invalid/g/invalid_getnewargs_returned.py b/tests/functional/i/invalid/g/invalid_getnewargs_returned.py
new file mode 100644
index 0000000..ee5305f
--- /dev/null
+++ b/tests/functional/i/invalid/g/invalid_getnewargs_returned.py
@@ -0,0 +1,62 @@
+"""Check invalid value returned by __getnewargs__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodGetNewArgs(object):
+ """__getnewargs__ returns <type 'tuple'>"""
+
+ def __getnewargs__(self):
+ return (1, "2", 3)
+
+
+class SecondGoodGetNewArgs(object):
+ """__getnewargs__ returns <type 'tuple'>"""
+
+ def __getnewargs__(self):
+ return tuple()
+
+
+class GetNewArgsMetaclass(type):
+ def __getnewargs__(cls):
+ return (1, 2, 3)
+
+
+@six.add_metaclass(GetNewArgsMetaclass)
+class ThirdGoodGetNewArgs(object):
+ """GetNewArgs through the metaclass."""
+
+
+class FirstBadGetNewArgs(object):
+ """ __getnewargs__ returns an integer """
+
+ def __getnewargs__(self): # [invalid-getnewargs-returned]
+ return 1
+
+
+class SecondBadGetNewArgs(object):
+ """ __getnewargs__ returns str """
+
+ def __getnewargs__(self): # [invalid-getnewargs-returned]
+ return "(1, 2, 3)"
+
+
+class ThirdBadGetNewArgs(object):
+ """ __getnewargs__ returns node which does not have 'value' in AST """
+
+ def __getnewargs__(self): # [invalid-getnewargs-returned]
+ return lambda: tuple(1, 2)
+
+
+class AmbigousGetNewArgs(object):
+ """ Uninferable return value """
+ __getnewargs__ = lambda self: Missing
+
+
+class AnotherAmbiguousGetNewArgs(object):
+ """Potential uninferable return value"""
+ def __getnewargs__(self):
+ return tuple(Missing)
diff --git a/tests/functional/i/invalid/g/invalid_getnewargs_returned.txt b/tests/functional/i/invalid/g/invalid_getnewargs_returned.txt
new file mode 100644
index 0000000..3560a80
--- /dev/null
+++ b/tests/functional/i/invalid/g/invalid_getnewargs_returned.txt
@@ -0,0 +1,3 @@
+invalid-getnewargs-returned:36:4:FirstBadGetNewArgs.__getnewargs__:__getnewargs__ does not return a tuple
+invalid-getnewargs-returned:43:4:SecondBadGetNewArgs.__getnewargs__:__getnewargs__ does not return a tuple
+invalid-getnewargs-returned:50:4:ThirdBadGetNewArgs.__getnewargs__:__getnewargs__ does not return a tuple
diff --git a/tests/functional/i/invalid/invalid_all_format.py b/tests/functional/i/invalid/invalid_all_format.py
new file mode 100644
index 0000000..1d1c0b1
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format.py
@@ -0,0 +1,7 @@
+"""Test invalid __all__ format.
+
+Tuples with one element MUST contain a comma! Otherwise it's a string.
+"""
+__all__ = ("CONST") # [invalid-all-format]
+
+CONST = 42
diff --git a/tests/functional/i/invalid/invalid_all_format.txt b/tests/functional/i/invalid/invalid_all_format.txt
new file mode 100644
index 0000000..75c6fe0
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format.txt
@@ -0,0 +1 @@
+invalid-all-format:5:11::Invalid format for __all__, must be tuple or list
diff --git a/tests/functional/i/invalid/invalid_all_format_valid_1.py b/tests/functional/i/invalid/invalid_all_format_valid_1.py
new file mode 100644
index 0000000..f3d8b43
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format_valid_1.py
@@ -0,0 +1,4 @@
+"""Test valid __all__ format."""
+__all__ = ("CONST", )
+
+CONST = 42
diff --git a/tests/functional/i/invalid/invalid_all_format_valid_2.py b/tests/functional/i/invalid/invalid_all_format_valid_2.py
new file mode 100644
index 0000000..aa243c6
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format_valid_2.py
@@ -0,0 +1,4 @@
+"""Test valid __all__ format."""
+__all__ = ["CONST"]
+
+CONST = 42
diff --git a/tests/functional/i/invalid/invalid_all_object.py b/tests/functional/i/invalid/invalid_all_object.py
new file mode 100644
index 0000000..4468c98
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_object.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring
+__all__ = (
+ 1, # [invalid-all-object]
+ lambda: None, # [invalid-all-object]
+ None, # [invalid-all-object]
+)
diff --git a/tests/functional/i/invalid/invalid_all_object.txt b/tests/functional/i/invalid/invalid_all_object.txt
new file mode 100644
index 0000000..ebcdb8d
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_object.txt
@@ -0,0 +1,3 @@
+invalid-all-object:3:4::Invalid object '1' in __all__, must contain only strings
+invalid-all-object:4:4:<lambda>:"Invalid object 'lambda: None' in __all__, must contain only strings"
+invalid-all-object:5:4::Invalid object 'None' in __all__, must contain only strings
diff --git a/tests/functional/i/invalid/invalid_class_object.py b/tests/functional/i/invalid/invalid_class_object.py
new file mode 100644
index 0000000..367756e
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_class_object.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name
+from collections import defaultdict
+
+class A:
+ pass
+
+class B:
+ pass
+
+A.__class__ = B
+A.__class__ = str
+A.__class__ = float
+A.__class__ = dict
+A.__class__ = set
+
+A.__class__ = defaultdict
+A.__class__ = defaultdict(str) # [invalid-class-object]
+A.__class__ = 1 # [invalid-class-object]
diff --git a/tests/functional/i/invalid/invalid_class_object.txt b/tests/functional/i/invalid/invalid_class_object.txt
new file mode 100644
index 0000000..0c09dd3
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_class_object.txt
@@ -0,0 +1,2 @@
+invalid-class-object:17:0::Invalid __class__ object
+invalid-class-object:18:0::Invalid __class__ object
diff --git a/tests/functional/i/invalid/invalid_format_returned.py b/tests/functional/i/invalid/invalid_format_returned.py
new file mode 100644
index 0000000..ec428b4
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_format_returned.py
@@ -0,0 +1,64 @@
+"""Check invalid value returned by __format__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodFormat(object):
+ """__format__ returns <type 'str'>"""
+
+ def __format__(self, format_spec):
+ return "some format"
+
+
+class SecondGoodFormat(object):
+ """__format__ returns <type 'str'>"""
+
+ def __format__(self, format_spec):
+ return str(123)
+
+
+class FormatMetaclass(type):
+ def __format__(cls, format_spec):
+ return "some format"
+
+
+@six.add_metaclass(FormatMetaclass)
+class ThirdGoodFormat(object):
+ """Format through the metaclass."""
+
+
+class FirstBadFormat(object):
+ """ __format__ returns bytes """
+
+ def __format__(self, format_spec): # [invalid-format-returned]
+ return b"123"
+
+
+class SecondBadFormat(object):
+ """ __format__ returns int """
+
+ def __format__(self, format_spec): # [invalid-format-returned]
+ return 1
+
+
+class ThirdBadFormat(object):
+ """ __format__ returns node which does not have 'value' in AST """
+
+ def __format__(self, format_spec): # [invalid-format-returned]
+ return lambda: "some format"
+
+
+class AmbiguousFormat(object):
+ """ Uninferable return value """
+
+ __format__ = lambda self, format_spec: Missing
+
+
+class AnotherAmbiguousFormat(object):
+ """Potential uninferable return value"""
+
+ def __format__(self, format_spec):
+ return str(Missing)
diff --git a/tests/functional/i/invalid/invalid_format_returned.txt b/tests/functional/i/invalid/invalid_format_returned.txt
new file mode 100644
index 0000000..3a3e1ae
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_format_returned.txt
@@ -0,0 +1,3 @@
+invalid-format-returned:36:4:FirstBadFormat.__format__:__format__ does not return str
+invalid-format-returned:43:4:SecondBadFormat.__format__:__format__ does not return str
+invalid-format-returned:50:4:ThirdBadFormat.__format__:__format__ does not return str
diff --git a/tests/functional/i/invalid/invalid_hash_returned.py b/tests/functional/i/invalid/invalid_hash_returned.py
new file mode 100644
index 0000000..47f63e9
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_hash_returned.py
@@ -0,0 +1,71 @@
+"""Check invalid value returned by __hash__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodHash(object):
+ """__hash__ returns <type 'int'>"""
+
+ def __hash__(self):
+ return 1
+
+
+class SecondGoodHash(object):
+ """__hash__ returns <type 'int'>"""
+
+ def __hash__(self):
+ return 0
+
+
+class HashMetaclass(type):
+ def __hash__(cls):
+ return 1
+
+
+@six.add_metaclass(HashMetaclass)
+class ThirdGoodHash(object):
+ """Hash through the metaclass."""
+
+
+class FirstBadHash(object):
+ """ __hash__ returns a dict """
+
+ def __hash__(self): # [invalid-hash-returned]
+ return {}
+
+
+class SecondBadHash(object):
+ """ __hash__ returns str """
+
+ def __hash__(self): # [invalid-hash-returned]
+ return "True"
+
+
+class ThirdBadHash(object):
+ """ __hash__ returns a float"""
+
+ def __hash__(self): # [invalid-hash-returned]
+ return 1.11
+
+
+class FourthBadHash(object):
+ """ __hash__ returns node which does not have 'value' in AST """
+
+ def __hash__(self): # [invalid-hash-returned]
+ return lambda: 3
+
+
+class AmbigousHash(object):
+ """ Uninferable return value """
+
+ __hash__ = lambda self: Missing
+
+
+class AnotherAmbiguousHash(object):
+ """Potential uninferable return value"""
+
+ def __hash__(self):
+ return hash(Missing)
diff --git a/tests/functional/i/invalid/invalid_hash_returned.txt b/tests/functional/i/invalid/invalid_hash_returned.txt
new file mode 100644
index 0000000..f30e514
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_hash_returned.txt
@@ -0,0 +1,4 @@
+invalid-hash-returned:36:4:FirstBadHash.__hash__:__hash__ does not return int
+invalid-hash-returned:43:4:SecondBadHash.__hash__:__hash__ does not return int
+invalid-hash-returned:50:4:ThirdBadHash.__hash__:__hash__ does not return int
+invalid-hash-returned:57:4:FourthBadHash.__hash__:__hash__ does not return int
diff --git a/tests/functional/i/invalid/invalid_index_returned.py b/tests/functional/i/invalid/invalid_index_returned.py
new file mode 100644
index 0000000..c48d9a8
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_index_returned.py
@@ -0,0 +1,71 @@
+"""Check invalid value returned by __index__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodIndex(object):
+ """__index__ returns <type 'int'>"""
+
+ def __index__(self):
+ return 1
+
+
+class SecondGoodIndex(object):
+ """__index__ returns <type 'int'>"""
+
+ def __index__(self):
+ return 0
+
+
+class IndexMetaclass(type):
+ def __index__(cls):
+ return 1
+
+
+@six.add_metaclass(IndexMetaclass)
+class ThirdGoodIndex(object):
+ """Index through the metaclass."""
+
+
+class FirstBadIndex(object):
+ """ __index__ returns a dict """
+
+ def __index__(self): # [invalid-index-returned]
+ return {'1': '1'}
+
+
+class SecondBadIndex(object):
+ """ __index__ returns str """
+
+ def __index__(self): # [invalid-index-returned]
+ return "42"
+
+
+class ThirdBadIndex(object):
+ """ __index__ returns a float"""
+
+ def __index__(self): # [invalid-index-returned]
+ return 1.11
+
+
+class FourthBadIndex(object):
+ """ __index__ returns node which does not have 'value' in AST """
+
+ def __index__(self): # [invalid-index-returned]
+ return lambda: 3
+
+
+class AmbigousIndex(object):
+ """ Uninferable return value """
+
+ __index__ = lambda self: Missing
+
+
+class AnotherAmbiguousIndex(object):
+ """Potential uninferable return value"""
+
+ def __index__(self):
+ return int(Missing)
diff --git a/tests/functional/i/invalid/invalid_index_returned.txt b/tests/functional/i/invalid/invalid_index_returned.txt
new file mode 100644
index 0000000..840d74a
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_index_returned.txt
@@ -0,0 +1,4 @@
+invalid-index-returned:36:4:FirstBadIndex.__index__:__index__ does not return int
+invalid-index-returned:43:4:SecondBadIndex.__index__:__index__ does not return int
+invalid-index-returned:50:4:ThirdBadIndex.__index__:__index__ does not return int
+invalid-index-returned:57:4:FourthBadIndex.__index__:__index__ does not return int
diff --git a/tests/functional/i/invalid/invalid_name.py b/tests/functional/i/invalid/invalid_name.py
new file mode 100644
index 0000000..07ad99b
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name.py
@@ -0,0 +1,69 @@
+""" Tests for invalid-name checker. """
+# pylint: disable=unused-import, no-absolute-import, wrong-import-position,import-outside-toplevel
+
+AAA = 24
+try:
+ import collections
+except ImportError:
+ collections = None
+
+aaa = 42 # [invalid-name]
+try:
+ import time
+except ValueError:
+ time = None # [invalid-name]
+
+try:
+ from sys import argv, executable as python
+except ImportError:
+ argv = 42
+ python = 24
+
+def test():
+ """ Shouldn't emit an invalid-name here. """
+ try:
+ import re
+ except ImportError:
+ re = None
+ return re
+
+def a(): # [invalid-name]
+ """yo"""
+
+
+def _generate_cmdline_tests():
+ TestCase = collections.namedtuple('TestCase', 'cmd, valid')
+ valid = ['leave-mode', 'hint all']
+ # Valid command only -> valid
+ for item in valid:
+ yield TestCase(''.join(item), True)
+
+
+# We should emit for the loop variable.
+for i in range(10):
+ Foocapfor = 2 # [invalid-name]
+
+
+def dummy_decorator(aaabc, bbbcd):
+ """Some"""
+ def real_decorator(fff):
+ """pieces of"""
+ def wrapper(*args, **kwargs):
+ """docstring"""
+ print(aaabc, bbbcd)
+ fff(*args, **kwargs)
+ return wrapper
+ return real_decorator
+
+
+@dummy_decorator(1, [
+ 0 # Fixing #119 should make this go away
+# C0103 always points here - line 61 # [invalid-name]
+
+
+])
+def a_very_very_very_long_function_name_WithCamelCase_to_make_it_sad(): # Should be line 65
+ """Docstring"""
+ print('LOL')
+
+a_very_very_very_long_function_name_WithCamelCase_to_make_it_sad()
diff --git a/tests/functional/i/invalid/invalid_name.txt b/tests/functional/i/invalid/invalid_name.txt
new file mode 100644
index 0000000..c4ecbfa
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name.txt
@@ -0,0 +1,5 @@
+invalid-name:10:0::"Constant name ""aaa"" doesn't conform to UPPER_CASE naming style"
+invalid-name:14:4::"Constant name ""time"" doesn't conform to UPPER_CASE naming style"
+invalid-name:30:0:a:"Function name ""a"" doesn't conform to snake_case naming style"
+invalid-name:44:4::"Constant name ""Foocapfor"" doesn't conform to UPPER_CASE naming style"
+invalid-name:61:0:a_very_very_very_long_function_name_WithCamelCase_to_make_it_sad:"Function name ""a_very_very_very_long_function_name_WithCamelCase_to_make_it_sad"" doesn't conform to snake_case naming style"
diff --git a/tests/functional/i/invalid/invalid_overridden_method.py b/tests/functional/i/invalid/invalid_overridden_method.py
new file mode 100644
index 0000000..33f2167
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_overridden_method.py
@@ -0,0 +1,78 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+import abc
+
+
+class SuperClass(metaclass=abc.ABCMeta):
+ @property
+ @abc.abstractmethod
+ def prop(self):
+ pass
+
+ @abc.abstractmethod
+ async def async_method(self):
+ pass
+
+ @abc.abstractmethod
+ def method_a(self):
+ pass
+
+ @abc.abstractmethod
+ def method_b(self):
+ pass
+
+class ValidDerived(SuperClass):
+ @property
+ def prop(self):
+ return None
+
+ async def async_method(self):
+ return None
+
+ def method_a(self):
+ pass
+
+ def method_b(self):
+ pass
+
+class InvalidDerived(SuperClass):
+ def prop(self): # [invalid-overridden-method]
+ return None
+
+ def async_method(self): # [invalid-overridden-method]
+ return None
+
+ @property
+ def method_a(self): # [invalid-overridden-method]
+ return None
+
+ async def method_b(self): # [invalid-overridden-method]
+ return None
+
+class Property:
+
+ @property
+ def close(self):
+ pass
+
+
+class PropertySetter(Property):
+
+ @property
+ def close(self):
+ pass
+
+ @close.setter
+ def close(self, attr):
+ return attr
+
+ @close.deleter
+ def close(self):
+ return None
+
+
+class AbstractProperty:
+
+ @property
+ @abc.abstractmethod
+ def prop(self):
+ return
diff --git a/tests/functional/i/invalid/invalid_overridden_method.txt b/tests/functional/i/invalid/invalid_overridden_method.txt
new file mode 100644
index 0000000..a44daa7
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_overridden_method.txt
@@ -0,0 +1,4 @@
+invalid-overridden-method:38:4:InvalidDerived.prop:Method 'prop' was expected to be 'property', found it instead as 'method'
+invalid-overridden-method:41:4:InvalidDerived.async_method:Method 'async_method' was expected to be 'async', found it instead as 'non-async'
+invalid-overridden-method:45:4:InvalidDerived.method_a:Method 'method_a' was expected to be 'method', found it instead as 'property'
+invalid-overridden-method:48:4:InvalidDerived.method_b:Method 'method_b' was expected to be 'non-async', found it instead as 'async'
diff --git a/tests/functional/i/invalid/invalid_repr_returned.py b/tests/functional/i/invalid/invalid_repr_returned.py
new file mode 100644
index 0000000..3bbd782
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_repr_returned.py
@@ -0,0 +1,64 @@
+"""Check invalid value returned by __repr__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodRepr(object):
+ """__repr__ returns <type 'str'>"""
+
+ def __repr__(self):
+ return "some repr"
+
+
+class SecondGoodRepr(object):
+ """__repr__ returns <type 'str'>"""
+
+ def __repr__(self):
+ return str(123)
+
+
+class ReprMetaclass(type):
+ def __repr__(cls):
+ return "some repr"
+
+
+@six.add_metaclass(ReprMetaclass)
+class ThirdGoodRepr(object):
+ """Repr through the metaclass."""
+
+
+class FirstBadRepr(object):
+ """ __repr__ returns bytes """
+
+ def __repr__(self): # [invalid-repr-returned]
+ return b"123"
+
+
+class SecondBadRepr(object):
+ """ __repr__ returns int """
+
+ def __repr__(self): # [invalid-repr-returned]
+ return 1
+
+
+class ThirdBadRepr(object):
+ """ __repr__ returns node which does not have 'value' in AST """
+
+ def __repr__(self): # [invalid-repr-returned]
+ return lambda: "some repr"
+
+
+class AmbiguousRepr(object):
+ """ Uninferable return value """
+
+ __repr__ = lambda self: Missing
+
+
+class AnotherAmbiguousRepr(object):
+ """Potential uninferable return value"""
+
+ def __repr__(self):
+ return str(Missing)
diff --git a/tests/functional/i/invalid/invalid_repr_returned.txt b/tests/functional/i/invalid/invalid_repr_returned.txt
new file mode 100644
index 0000000..4be375f
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_repr_returned.txt
@@ -0,0 +1,3 @@
+invalid-repr-returned:36:4:FirstBadRepr.__repr__:__repr__ does not return str
+invalid-repr-returned:43:4:SecondBadRepr.__repr__:__repr__ does not return str
+invalid-repr-returned:50:4:ThirdBadRepr.__repr__:__repr__ does not return str
diff --git a/tests/functional/i/invalid/invalid_unary_operand_type.py b/tests/functional/i/invalid/invalid_unary_operand_type.py
new file mode 100644
index 0000000..f2a0124
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_unary_operand_type.py
@@ -0,0 +1,51 @@
+"""Detect problems with invalid operands used on invalid objects."""
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name
+# pylint: disable=unused-variable, useless-object-inheritance
+
+import collections
+
+
+class Implemented(object):
+ def __invert__(self):
+ return 42
+ def __pos__(self):
+ return 42
+ def __neg__(self):
+ return 42
+
+
+def these_are_good():
+ negative = -1
+ negative1 = -1.0
+ positive = +1
+ positive2 = +1.0
+ inverted = ~1
+ not_int = not 1
+ not_float = not 2.0
+ not_string = not ""
+ not_list = not []
+ not_dict = not {}
+ not_tuple = not (1, 2)
+ inverted_instance = ~Implemented()
+ positive_instance = +Implemented()
+ negative_instance = -Implemented()
+ not_instance = not Implemented()
+
+
+def these_are_bad():
+ invert_list = ~[] # [invalid-unary-operand-type]
+ invert_tuple = ~() # [invalid-unary-operand-type]
+ invert_dict = ~dict() # [invalid-unary-operand-type]
+ invert_dict_1 = ~{} # [invalid-unary-operand-type]
+ invert_set = ~set() # [invalid-unary-operand-type]
+ neg_set = -set() # [invalid-unary-operand-type]
+ neg_str = -"" # [invalid-unary-operand-type]
+ invert_str = ~"" # [invalid-unary-operand-type]
+ pos_str = +"" # [invalid-unary-operand-type]
+ class A(object):
+ pass
+ invert_func = ~(lambda: None) # [invalid-unary-operand-type]
+ invert_class = ~A # [invalid-unary-operand-type]
+ invert_instance = ~A() # [invalid-unary-operand-type]
+ invert_module = ~collections # [invalid-unary-operand-type]
+ invert_float = ~2.0 # [invalid-unary-operand-type]
diff --git a/tests/functional/i/invalid/invalid_unary_operand_type.txt b/tests/functional/i/invalid/invalid_unary_operand_type.txt
new file mode 100644
index 0000000..6a3dd59
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_unary_operand_type.txt
@@ -0,0 +1,14 @@
+invalid-unary-operand-type:36:18:these_are_bad:"bad operand type for unary ~: list"
+invalid-unary-operand-type:37:19:these_are_bad:"bad operand type for unary ~: tuple"
+invalid-unary-operand-type:38:18:these_are_bad:"bad operand type for unary ~: dict"
+invalid-unary-operand-type:39:20:these_are_bad:"bad operand type for unary ~: dict"
+invalid-unary-operand-type:40:17:these_are_bad:"bad operand type for unary ~: set"
+invalid-unary-operand-type:41:14:these_are_bad:"bad operand type for unary -: set"
+invalid-unary-operand-type:42:14:these_are_bad:"bad operand type for unary -: str"
+invalid-unary-operand-type:43:17:these_are_bad:"bad operand type for unary ~: str"
+invalid-unary-operand-type:44:14:these_are_bad:"bad operand type for unary +: str"
+invalid-unary-operand-type:47:18:these_are_bad:"bad operand type for unary ~: <lambda>"
+invalid-unary-operand-type:48:19:these_are_bad:"bad operand type for unary ~: A"
+invalid-unary-operand-type:49:22:these_are_bad:"bad operand type for unary ~: A"
+invalid-unary-operand-type:50:20:these_are_bad:"bad operand type for unary ~: collections"
+invalid-unary-operand-type:51:19:these_are_bad:"bad operand type for unary ~: float"
diff --git a/tests/functional/i/invalid/l/invalid_length_hint_returned.py b/tests/functional/i/invalid/l/invalid_length_hint_returned.py
new file mode 100644
index 0000000..7696bc9
--- /dev/null
+++ b/tests/functional/i/invalid/l/invalid_length_hint_returned.py
@@ -0,0 +1,64 @@
+"""Check invalid value returned by __length_hint__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import sys
+
+import six
+
+from missing import Missing
+
+
+class FirstGoodLengthHint(object):
+ """__length_hint__ returns <type 'int'>"""
+
+ def __length_hint__(self):
+ return 0
+
+
+class SecondGoodLengthHint(object):
+ """__length_hint__ returns <type 'long'>"""
+
+ def __length_hint__(self):
+ return sys.maxsize + 1
+
+
+class LengthHintMetaclass(type):
+ def __length_hint__(cls):
+ return 1
+
+
+@six.add_metaclass(LengthHintMetaclass)
+class ThirdGoodLengthHint(object):
+ """LengthHintgth through the metaclass."""
+
+
+class FirstBadLengthHint(object):
+ """ __length_hint__ returns a negative integer """
+
+ def __length_hint__(self): # [invalid-length-hint-returned]
+ return -1
+
+
+class SecondBadLengthHint(object):
+ """ __length_hint__ returns non-int """
+
+ def __length_hint__(self): # [invalid-length-hint-returned]
+ return 3.0
+
+
+class ThirdBadLengthHint(object):
+ """ __length_hint__ returns node which does not have 'value' in AST """
+
+ def __length_hint__(self): # [invalid-length-hint-returned]
+ return lambda: 3
+
+
+class AmbigousLengthHint(object):
+ """ Uninferable return value """
+ __length_hint__ = lambda self: Missing
+
+
+class AnotherAmbiguousLengthHint(object):
+ """Potential uninferable return value"""
+ def __length_hint__(self):
+ return int(Missing)
diff --git a/tests/functional/i/invalid/l/invalid_length_hint_returned.txt b/tests/functional/i/invalid/l/invalid_length_hint_returned.txt
new file mode 100644
index 0000000..dd31af7
--- /dev/null
+++ b/tests/functional/i/invalid/l/invalid_length_hint_returned.txt
@@ -0,0 +1,3 @@
+invalid-length-hint-returned:38:4:FirstBadLengthHint.__length_hint__:__length_hint__ does not return non-negative integer
+invalid-length-hint-returned:45:4:SecondBadLengthHint.__length_hint__:__length_hint__ does not return non-negative integer
+invalid-length-hint-returned:52:4:ThirdBadLengthHint.__length_hint__:__length_hint__ does not return non-negative integer
diff --git a/tests/functional/i/invalid/l/invalid_length_returned.py b/tests/functional/i/invalid/l/invalid_length_returned.py
new file mode 100644
index 0000000..99af28d
--- /dev/null
+++ b/tests/functional/i/invalid/l/invalid_length_returned.py
@@ -0,0 +1,71 @@
+"""Check invalid value returned by __len__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import sys
+
+import six
+
+from missing import Missing
+
+
+class FirstGoodLen(object):
+ """__len__ returns <type 'int'>"""
+
+ def __len__(self):
+ return 0
+
+
+class SecondGoodLen(object):
+ """__len__ returns <type 'long'>"""
+
+ def __len__(self):
+ return sys.maxsize + 1
+
+
+class LenMetaclass(type):
+ def __len__(cls):
+ return 1
+
+
+@six.add_metaclass(LenMetaclass)
+class ThirdGoodLen(object):
+ """Length through the metaclass."""
+
+
+class FirstBadLen(object):
+ """ __len__ returns a negative integer """
+
+ def __len__(self): # [invalid-length-returned]
+ return -1
+
+
+class SecondBadLen(object):
+ """ __len__ returns non-int """
+
+ def __len__(self): # [invalid-length-returned]
+ return 3.0
+
+
+class ThirdBadLen(object):
+ """ __len__ returns node which does not have 'value' in AST """
+
+ def __len__(self): # [invalid-length-returned]
+ return lambda: 3
+
+
+class NonRegression(object):
+ """ __len__ returns nothing """
+
+ def __len__(self): # [invalid-length-returned]
+ print(3.0)
+
+
+class AmbigousLen(object):
+ """ Uninferable return value """
+ __len__ = lambda self: Missing
+
+
+class AnotherAmbiguousLen(object):
+ """Potential uninferable return value"""
+ def __len__(self):
+ return int(Missing)
diff --git a/tests/functional/i/invalid/l/invalid_length_returned.txt b/tests/functional/i/invalid/l/invalid_length_returned.txt
new file mode 100644
index 0000000..27b86cd
--- /dev/null
+++ b/tests/functional/i/invalid/l/invalid_length_returned.txt
@@ -0,0 +1,4 @@
+invalid-length-returned:38:4:FirstBadLen.__len__:__len__ does not return non-negative integer
+invalid-length-returned:45:4:SecondBadLen.__len__:__len__ does not return non-negative integer
+invalid-length-returned:52:4:ThirdBadLen.__len__:__len__ does not return non-negative integer
+invalid-length-returned:59:4:NonRegression.__len__:__len__ does not return non-negative integer
diff --git a/tests/functional/i/invalid/m/invalid_metaclass.py b/tests/functional/i/invalid/m/invalid_metaclass.py
new file mode 100644
index 0000000..c0e9d74
--- /dev/null
+++ b/tests/functional/i/invalid/m/invalid_metaclass.py
@@ -0,0 +1,34 @@
+# pylint: disable=missing-docstring, too-few-public-methods, import-error,unused-argument, useless-object-inheritance
+
+import abc
+
+import six
+from unknown import Unknown
+
+
+class InvalidAsMetaclass(object):
+ pass
+
+
+class ValidAsMetaclass(type):
+ pass
+
+
+@six.add_metaclass(type)
+class FirstGood(object):
+ pass
+
+
+@six.add_metaclass(abc.ABCMeta)
+class SecondGood(object):
+ pass
+
+
+@six.add_metaclass(Unknown)
+class ThirdGood(object):
+ pass
+
+
+@six.add_metaclass(ValidAsMetaclass)
+class FourthGood(object):
+ pass
diff --git a/tests/functional/i/invalid/m/invalid_metaclass_py3.py b/tests/functional/i/invalid/m/invalid_metaclass_py3.py
new file mode 100644
index 0000000..2fc458f
--- /dev/null
+++ b/tests/functional/i/invalid/m/invalid_metaclass_py3.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring, too-few-public-methods, import-error,unused-argument
+
+from unknown import Unknown
+
+
+def valid_metaclass_1(name, _, attrs):
+ return type
+
+
+def valid_metaclass_2(_name, _bases, _attrs):
+ return Unknown
+
+
+class GoodMetaclass(metaclass=valid_metaclass_1):
+ pass
+
+
+class SecondGoodMetaclass(metaclass=valid_metaclass_2):
+ pass
diff --git a/tests/functional/i/invalid/m/invalid_metaclass_py3.rc b/tests/functional/i/invalid/m/invalid_metaclass_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/i/invalid/m/invalid_metaclass_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/i/invalid/s/invalid_sequence_index.py b/tests/functional/i/invalid/s/invalid_sequence_index.py
new file mode 100644
index 0000000..d11155c
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_sequence_index.py
@@ -0,0 +1,242 @@
+"""Errors for invalid sequence indices"""
+# pylint: disable=too-few-public-methods, no-self-use, import-error, missing-docstring, useless-object-inheritance, unnecessary-pass
+import six
+from unknown import Unknown
+
+TESTLIST = [1, 2, 3]
+TESTTUPLE = (1, 2, 3)
+TESTSTR = '123'
+
+# getitem tests with bad indices
+def function1():
+ """list index is a function"""
+ return TESTLIST[id] # [invalid-sequence-index]
+
+def function2():
+ """list index is None"""
+ return TESTLIST[None] # [invalid-sequence-index]
+
+def function3():
+ """list index is a float expression"""
+ return TESTLIST[float(0)] # [invalid-sequence-index]
+
+def function4():
+ """list index is a str constant"""
+ return TESTLIST['0'] # [invalid-sequence-index]
+
+def function5():
+ """list index does not implement __index__"""
+ class NonIndexType(object):
+ """Class without __index__ method"""
+ pass
+
+ return TESTLIST[NonIndexType()] # [invalid-sequence-index]
+
+def function6():
+ """Tuple index is None"""
+ return TESTTUPLE[None] # [invalid-sequence-index]
+
+def function7():
+ """String index is None"""
+ return TESTSTR[None] # [invalid-sequence-index]
+
+def function8():
+ """Index of subclass of tuple is None"""
+ class TupleTest(tuple):
+ """Subclass of tuple"""
+ pass
+ return TupleTest()[None] # [invalid-sequence-index]
+
+# getitem tests with good indices
+def function9():
+ """list index is an int constant"""
+ return TESTLIST[0] # no error
+
+def function10():
+ """list index is an integer expression"""
+ return TESTLIST[int(0.0)] # no error
+
+def function11():
+ """list index is a slice"""
+ return TESTLIST[slice(1, 2, 3)] # no error
+
+def function12():
+ """list index implements __index__"""
+ class IndexType(object):
+ """Class with __index__ method"""
+ def __index__(self):
+ """Allow objects of this class to be used as slice indices"""
+ return 0
+
+ return TESTLIST[IndexType()] # no error
+
+def function13():
+ """list index implements __index__ in a superclass"""
+ class IndexType(object):
+ """Class with __index__ method"""
+ def __index__(self):
+ """Allow objects of this class to be used as slice indices"""
+ return 0
+
+ class IndexSubType(IndexType):
+ """Class with __index__ in parent"""
+ pass
+
+ return TESTLIST[IndexSubType()] # no error
+
+def function14():
+ """Tuple index is an int constant"""
+ return TESTTUPLE[0]
+
+def function15():
+ """String index is an int constant"""
+ return TESTSTR[0]
+
+def function16():
+ """Index of subclass of tuple is an int constant"""
+ class TupleTest(tuple):
+ """Subclass of tuple"""
+ pass
+ return TupleTest()[0] # no error
+
+def function17():
+ """Index of subclass of tuple with custom __getitem__ is None"""
+ class TupleTest(tuple):
+ """Subclass of tuple with custom __getitem__"""
+ def __getitem__(self, index):
+ """Allow non-integer indices"""
+ return 0
+ return TupleTest()[None] # no error
+
+def function18():
+ """Index of subclass of tuple with __getitem__ in superclass is None"""
+ class TupleTest(tuple):
+ """Subclass of tuple with custom __getitem__"""
+ def __getitem__(self, index):
+ """Allow non-integer indices"""
+ return 0
+
+ class SubTupleTest(TupleTest):
+ """Subclass of a subclass of tuple"""
+ pass
+
+ return SubTupleTest()[None] # no error
+
+# Test with set and delete statements
+def function19():
+ """Set with None and integer indices"""
+ TESTLIST[None] = 0 # [invalid-sequence-index]
+ TESTLIST[0] = 0 # no error
+
+def function20():
+ """Delete with None and integer indicies"""
+ del TESTLIST[None] # [invalid-sequence-index]
+ del TESTLIST[0] # no error
+
+def function21():
+ """Set and delete on a subclass of list"""
+ class ListTest(list):
+ """Inherit all list get/set/del handlers"""
+ pass
+ test = ListTest()
+
+ # Set and delete with invalid indices
+ test[None] = 0 # [invalid-sequence-index]
+ del test[None] # [invalid-sequence-index]
+
+ # Set and delete with valid indices
+ test[0] = 0 # no error
+ del test[0] # no error
+
+def function22():
+ """Get, set, and delete on a subclass of list that overrides __setitem__"""
+ class ListTest(list):
+ """Override setitem but not get or del"""
+ def __setitem__(self, key, value):
+ pass
+ test = ListTest()
+
+ # failure on the getitem with None
+ test[None][0] = 0 # [invalid-sequence-index]
+ # failure on the getitem with None
+ del test[None] # [invalid-sequence-index]
+
+ test[0][0] = 0 # getitem with int and setitem with int, no error
+ test[None] = 0 # setitem overridden, no error
+ test[0] = 0 # setitem with int, no error
+ del test[0] # delitem with int, no error
+
+def function23():
+ """Get, set, and delete on a subclass of list that overrides __delitem__"""
+ class ListTest(list):
+ """Override delitem but not get or set"""
+ def __delitem__(self, key):
+ pass
+ test = ListTest()
+
+ # failure on the getitem with None
+ test[None][0] = 0 # [invalid-sequence-index]
+ # setitem with invalid index
+ test[None] = 0 # [invalid-sequence-index]
+
+ test[0][0] = 0 # getitem with int and setitem with int, no error
+ test[0] = 0 # setitem with int, no error
+ del test[None] # delitem overridden, no error
+ del test[0] # delitem with int, no error
+
+def function24():
+ """Get, set, and delete on a subclass of list that overrides __getitem__"""
+ class ListTest(list):
+ """Override gelitem but not del or set"""
+ def __getitem__(self, key):
+ pass
+ test = ListTest()
+
+ # setitem with invalid index
+ test[None] = 0 # [invalid-sequence-index]
+ # delitem with invalid index
+ del test[None] # [invalid-sequence-index]
+
+ test[None][0] = 0 # getitem overridden, no error
+ test[0][0] = 0 # getitem with int and setitem with int, no error
+ test[0] = 0 # setitem with int, no error
+ del test[0] # delitem with int, no error
+
+# Teest ExtSlice usage
+def function25():
+ """Extended slice used with a list"""
+ return TESTLIST[..., 0] # [invalid-sequence-index]
+
+def function26():
+ """Extended slice used with an object that implements __getitem__"""
+ class ExtSliceTest(object):
+ """Permit extslice syntax by implementing __getitem__"""
+ def __getitem__(self, index):
+ return 0
+ return ExtSliceTest()[..., 0] # no error
+
+def function27():
+ """Don't warn in the case where the indexed object has unknown base classes."""
+ class UnknownBase(Unknown):
+ pass
+ slices = UnknownBase["aaaa"] + UnknownBase()[object]
+ ext_slices = UnknownBase[..., 0] + UnknownBase()[..., 0]
+ return slices, ext_slices
+
+
+def function28():
+ """Don't emit for classes with the right implementation."""
+
+ class Meta(type):
+ def __getitem__(cls, arg):
+ return 24
+
+ @six.add_metaclass(Meta)
+ class Works(object):
+ pass
+
+ @six.add_metaclass(Meta)
+ class Error(list):
+ pass
+
+ return Works['hello'] + Error['hello']
diff --git a/tests/functional/i/invalid/s/invalid_sequence_index.txt b/tests/functional/i/invalid/s/invalid_sequence_index.txt
new file mode 100644
index 0000000..baf1b21
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_sequence_index.txt
@@ -0,0 +1,19 @@
+invalid-sequence-index:13:11:function1:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:17:11:function2:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:21:11:function3:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:25:11:function4:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:33:11:function5:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:37:11:function6:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:41:11:function7:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:48:11:function8:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:128:4:function19:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:133:8:function20:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:144:4:function21:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:145:8:function21:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:160:4:function22:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:162:8:function22:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:178:4:function23:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:180:4:function23:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:196:4:function24:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:198:8:function24:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:208:11:function25:Sequence index is not an int, slice, or instance with __index__
diff --git a/tests/functional/i/invalid/s/invalid_slice_index.py b/tests/functional/i/invalid/s/invalid_slice_index.py
new file mode 100644
index 0000000..1eb2fda
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_slice_index.py
@@ -0,0 +1,71 @@
+"""Errors for invalid slice indices"""
+# pylint: disable=too-few-public-methods, no-self-use,missing-docstring,expression-not-assigned, useless-object-inheritance, unnecessary-pass
+
+
+TESTLIST = [1, 2, 3]
+
+# Invalid indices
+def function1():
+ """functions used as indices"""
+ return TESTLIST[id:id:] # [invalid-slice-index,invalid-slice-index]
+
+def function2():
+ """strings used as indices"""
+ return TESTLIST['0':'1':] # [invalid-slice-index,invalid-slice-index]
+
+def function3():
+ """class without __index__ used as index"""
+
+ class NoIndexTest(object):
+ """Class with no __index__ method"""
+ pass
+
+ return TESTLIST[NoIndexTest()::] # [invalid-slice-index]
+
+# Valid indices
+def function4():
+ """integers used as indices"""
+ return TESTLIST[0:0:0] # no error
+
+def function5():
+ """None used as indices"""
+ return TESTLIST[None:None:None] # no error
+
+def function6():
+ """class with __index__ used as index"""
+ class IndexTest(object):
+ """Class with __index__ method"""
+ def __index__(self):
+ """Allow objects of this class to be used as slice indices"""
+ return 0
+
+ return TESTLIST[IndexTest():None:None] # no error
+
+def function7():
+ """class with __index__ in superclass used as index"""
+ class IndexType(object):
+ """Class with __index__ method"""
+ def __index__(self):
+ """Allow objects of this class to be used as slice indices"""
+ return 0
+
+ class IndexSubType(IndexType):
+ """Class with __index__ in parent"""
+ pass
+
+ return TESTLIST[IndexSubType():None:None] # no error
+
+def function8():
+ """slice object used as index"""
+ return TESTLIST[slice(1, 2, 3)] # no error
+
+
+def function9():
+ """Use a custom class that knows how to handle string slices"""
+ class StringSlice:
+ def __getitem__(self, item):
+ return item
+
+ StringSlice()["a":"b":"c"]
+ StringSlice()["a":"b":"c", "a":"b"]
+ StringSlice()[slice("a", "b", "c")]
diff --git a/tests/functional/i/invalid/s/invalid_slice_index.txt b/tests/functional/i/invalid/s/invalid_slice_index.txt
new file mode 100644
index 0000000..e715138
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_slice_index.txt
@@ -0,0 +1,5 @@
+invalid-slice-index:10:0:function1:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:10:0:function1:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:14:0:function2:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:14:0:function2:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:23:0:function3:Slice index is not an int, None, or instance with __index__
diff --git a/tests/functional/i/invalid/s/invalid_star_assignment_target.py b/tests/functional/i/invalid/s/invalid_star_assignment_target.py
new file mode 100644
index 0000000..452f9a7
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_star_assignment_target.py
@@ -0,0 +1,4 @@
+"""Test for *a = b """
+
+*FIRST = [1, 2, 3] # [invalid-star-assignment-target]
+(*FIRST, ) = [1, 2, 3]
diff --git a/tests/functional/i/invalid/s/invalid_star_assignment_target.rc b/tests/functional/i/invalid/s/invalid_star_assignment_target.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_star_assignment_target.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/i/invalid/s/invalid_star_assignment_target.txt b/tests/functional/i/invalid/s/invalid_star_assignment_target.txt
new file mode 100644
index 0000000..eb9f27c
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_star_assignment_target.txt
@@ -0,0 +1 @@
+invalid-star-assignment-target:3:0::Starred assignment target must be in a list or tuple
diff --git a/tests/functional/i/invalid/s/invalid_str_returned.py b/tests/functional/i/invalid/s/invalid_str_returned.py
new file mode 100644
index 0000000..00ef220
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_str_returned.py
@@ -0,0 +1,64 @@
+"""Check invalid value returned by __str__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import six
+
+from missing import Missing
+
+
+class FirstGoodStr(object):
+ """__str__ returns <type 'str'>"""
+
+ def __str__(self):
+ return "some str"
+
+
+class SecondGoodStr(object):
+ """__str__ returns <type 'str'>"""
+
+ def __str__(self):
+ return str(123)
+
+
+class StrMetaclass(type):
+ def __str__(cls):
+ return "some str"
+
+
+@six.add_metaclass(StrMetaclass)
+class ThirdGoodStr(object):
+ """Str through the metaclass."""
+
+
+class FirstBadStr(object):
+ """ __str__ returns bytes """
+
+ def __str__(self): # [invalid-str-returned]
+ return b"123"
+
+
+class SecondBadStr(object):
+ """ __str__ returns int """
+
+ def __str__(self): # [invalid-str-returned]
+ return 1
+
+
+class ThirdBadStr(object):
+ """ __str__ returns node which does not have 'value' in AST """
+
+ def __str__(self): # [invalid-str-returned]
+ return lambda: "some str"
+
+
+class AmbiguousStr(object):
+ """ Uninferable return value """
+
+ __str__ = lambda self: Missing
+
+
+class AnotherAmbiguousStr(object):
+ """Potential uninferable return value"""
+
+ def __str__(self):
+ return str(Missing)
diff --git a/tests/functional/i/invalid/s/invalid_str_returned.txt b/tests/functional/i/invalid/s/invalid_str_returned.txt
new file mode 100644
index 0000000..36b7ec5
--- /dev/null
+++ b/tests/functional/i/invalid/s/invalid_str_returned.txt
@@ -0,0 +1,3 @@
+invalid-str-returned:36:4:FirstBadStr.__str__:__str__ does not return str
+invalid-str-returned:43:4:SecondBadStr.__str__:__str__ does not return str
+invalid-str-returned:50:4:ThirdBadStr.__str__:__str__ does not return str
diff --git a/tests/functional/i/isinstance_second_argument.py b/tests/functional/i/isinstance_second_argument.py
new file mode 100644
index 0000000..cf32cbf
--- /dev/null
+++ b/tests/functional/i/isinstance_second_argument.py
@@ -0,0 +1,31 @@
+#pylint: disable=missing-docstring, undefined-variable, invalid-name, too-few-public-methods, wrong-import-position,import-error
+
+import collections
+from unknown import Unknown
+
+# Positive test cases
+class A:
+ pass
+
+class B(A):
+ pass
+
+isinstance(A(), A)
+isinstance(A(), B)
+
+isinstance(-9999, int)
+isinstance(True and False, bool)
+isinstance("a 'string'", type("test"))
+
+isinstance(3.123213, collections.OrderedDict)
+isinstance(foo, (int, collections.Counter))
+isinstance("a string", ((int, type(False)), (float, set), str))
+isinstance(10, (int,) + (str, bool) + (dict, list, tuple))
+isinstance(10, tuple(Unknown))
+
+# Negative test cases
+isinstance({a:1}, hash) # [isinstance-second-argument-not-valid-type]
+isinstance(64, hex) # [isinstance-second-argument-not-valid-type]
+isinstance({b: 100}, (hash, dict)) # [isinstance-second-argument-not-valid-type]
+isinstance("string", ((dict, iter), str, (int, bool))) # [isinstance-second-argument-not-valid-type]
+isinstance(int, 1) # [isinstance-second-argument-not-valid-type]
diff --git a/tests/functional/i/isinstance_second_argument.txt b/tests/functional/i/isinstance_second_argument.txt
new file mode 100644
index 0000000..aef0dcc
--- /dev/null
+++ b/tests/functional/i/isinstance_second_argument.txt
@@ -0,0 +1,5 @@
+isinstance-second-argument-not-valid-type:27:0::Second argument of isinstance is not a type
+isinstance-second-argument-not-valid-type:28:0::Second argument of isinstance is not a type
+isinstance-second-argument-not-valid-type:29:0::Second argument of isinstance is not a type
+isinstance-second-argument-not-valid-type:30:0::Second argument of isinstance is not a type
+isinstance-second-argument-not-valid-type:31:0::Second argument of isinstance is not a type
diff --git a/tests/functional/i/iterable_context.py b/tests/functional/i/iterable_context.py
new file mode 100644
index 0000000..6efefd5
--- /dev/null
+++ b/tests/functional/i/iterable_context.py
@@ -0,0 +1,192 @@
+"""
+Checks that primitive values are not used in an
+iterating/mapping context.
+"""
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods,no-init,no-self-use,import-error,unused-argument,bad-mcs-method-argument,wrong-import-position,no-else-return, useless-object-inheritance, unnecessary-comprehension
+from __future__ import print_function
+
+# primitives
+numbers = [1, 2, 3]
+
+for i in numbers:
+ pass
+
+for i in iter(numbers):
+ pass
+
+for i in "123":
+ pass
+
+for i in u"123":
+ pass
+
+for i in b"123":
+ pass
+
+for i in bytearray(b"123"):
+ pass
+
+for i in set(numbers):
+ pass
+
+for i in frozenset(numbers):
+ pass
+
+for i in dict(a=1, b=2):
+ pass
+
+# comprehensions
+for i in [x for x in range(10)]:
+ pass
+
+for i in {x for x in range(1, 100, 2)}:
+ pass
+
+for i in {x: 10 - x for x in range(10)}:
+ pass
+
+# generators
+def powers_of_two():
+ k = 0
+ while k < 10:
+ yield 2 ** k
+ k += 1
+
+for i in powers_of_two():
+ pass
+
+for i in powers_of_two: # [not-an-iterable]
+ pass
+
+# check for custom iterators
+class A(object):
+ pass
+
+class B(object):
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ return 1
+
+ def next(self):
+ return 1
+
+class C(object):
+ "old-style iterator"
+ def __getitem__(self, k):
+ if k > 10:
+ raise IndexError
+ return k + 1
+
+ def __len__(self):
+ return 10
+
+for i in C():
+ print(i)
+
+
+def test(*args):
+ print(args)
+
+
+test(*A()) # [not-an-iterable]
+test(*B())
+test(*B) # [not-an-iterable]
+for i in A(): # [not-an-iterable]
+ pass
+for i in B():
+ pass
+for i in B: # [not-an-iterable]
+ pass
+
+for i in range: # [not-an-iterable]
+ pass
+
+# check that primitive non-iterable types are caught
+for i in True: # [not-an-iterable]
+ pass
+
+for i in None: # [not-an-iterable]
+ pass
+
+for i in 8.5: # [not-an-iterable]
+ pass
+
+for i in 10: # [not-an-iterable]
+ pass
+
+
+# skip uninferable instances
+from some_missing_module import Iterable
+
+class MyClass(Iterable):
+ pass
+
+m = MyClass()
+for i in m:
+ print(i)
+
+# skip checks if statement is inside mixin/base/abstract class
+class ManagedAccessViewMixin(object):
+ access_requirements = None
+
+ def get_access_requirements(self):
+ return self.access_requirements
+
+ def dispatch(self, *_args, **_kwargs):
+ klasses = self.get_access_requirements()
+
+ # no error should be emitted here
+ for requirement in klasses:
+ print(requirement)
+
+class BaseType(object):
+ valid_values = None
+
+ def validate(self, value):
+ if self.valid_values is None:
+ return True
+ else:
+ # error should not be emitted here
+ for v in self.valid_values:
+ if value == v:
+ return True
+ return False
+
+class AbstractUrlMarkManager(object):
+ def __init__(self):
+ self._lineparser = None
+ self._init_lineparser()
+ # error should not be emitted here
+ for line in self._lineparser:
+ print(line)
+
+ def _init_lineparser(self):
+ raise NotImplementedError
+
+# class is not named as abstract
+# but still is deduceably abstract
+class UrlMarkManager(object):
+ def __init__(self):
+ self._lineparser = None
+ self._init_lineparser()
+ # error should not be emitted here
+ for line in self._lineparser:
+ print(line)
+
+ def _init_lineparser(self):
+ raise NotImplementedError
+
+
+class HasDynamicGetattr(object):
+
+ def __init__(self):
+ self._obj = []
+
+ def __getattr__(self, attr):
+ return getattr(self._obj, attr)
+
+
+for elem in HasDynamicGetattr():
+ pass
diff --git a/tests/functional/i/iterable_context.txt b/tests/functional/i/iterable_context.txt
new file mode 100644
index 0000000..2ec91a4
--- /dev/null
+++ b/tests/functional/i/iterable_context.txt
@@ -0,0 +1,10 @@
+not-an-iterable:58:9::Non-iterable value powers_of_two is used in an iterating context
+not-an-iterable:93:6::Non-iterable value A() is used in an iterating context
+not-an-iterable:95:6::Non-iterable value B is used in an iterating context
+not-an-iterable:96:9::Non-iterable value A() is used in an iterating context
+not-an-iterable:100:9::Non-iterable value B is used in an iterating context
+not-an-iterable:103:9::Non-iterable value range is used in an iterating context
+not-an-iterable:107:9::Non-iterable value True is used in an iterating context
+not-an-iterable:110:9::Non-iterable value None is used in an iterating context
+not-an-iterable:113:9::Non-iterable value 8.5 is used in an iterating context
+not-an-iterable:116:9::Non-iterable value 10 is used in an iterating context
diff --git a/tests/functional/i/iterable_context_py3.py b/tests/functional/i/iterable_context_py3.py
new file mode 100644
index 0000000..34047ed
--- /dev/null
+++ b/tests/functional/i/iterable_context_py3.py
@@ -0,0 +1,55 @@
+"""
+Checks that iterable metaclasses are recognized by pylint.
+"""
+# pylint: disable=missing-docstring,too-few-public-methods,no-init,no-self-use,unused-argument,bad-mcs-method-argument
+# pylint: disable=wrong-import-position
+# metaclasses as iterables
+class Meta(type):
+ def __iter__(self):
+ return iter((1, 2, 3))
+
+class SomeClass(metaclass=Meta):
+ pass
+
+
+for i in SomeClass:
+ print(i)
+for i in SomeClass(): # [not-an-iterable]
+ print(i)
+
+
+import asyncio
+
+
+@asyncio.coroutine
+def coroutine_function_return_none():
+ return
+
+
+@asyncio.coroutine
+def coroutine_function_return_object():
+ return 12
+
+
+@asyncio.coroutine
+def coroutine_function_return_future():
+ return asyncio.Future()
+
+
+@asyncio.coroutine
+def coroutine_function_pass():
+ pass
+
+
+@asyncio.coroutine
+def coroutine_generator():
+ yield
+
+
+@asyncio.coroutine
+def main():
+ yield from coroutine_function_return_none()
+ yield from coroutine_function_return_object()
+ yield from coroutine_function_return_future()
+ yield from coroutine_function_pass()
+ yield from coroutine_generator()
diff --git a/tests/functional/i/iterable_context_py3.rc b/tests/functional/i/iterable_context_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/i/iterable_context_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/i/iterable_context_py3.txt b/tests/functional/i/iterable_context_py3.txt
new file mode 100644
index 0000000..b3849d4
--- /dev/null
+++ b/tests/functional/i/iterable_context_py3.txt
@@ -0,0 +1 @@
+not-an-iterable:17:9::Non-iterable value SomeClass() is used in an iterating context
diff --git a/tests/functional/i/iterable_context_py36.py b/tests/functional/i/iterable_context_py36.py
new file mode 100644
index 0000000..d50d3da
--- /dev/null
+++ b/tests/functional/i/iterable_context_py36.py
@@ -0,0 +1,41 @@
+# pylint: disable=missing-docstring,too-few-public-methods,unused-variable,unnecessary-comprehension
+import asyncio
+
+class AIter:
+ async def __aiter__(self):
+ for value in range(20):
+ yield value
+
+ async def to_list(self):
+ values = [m async for m in self]
+ other_values = [m for m in self] # [not-an-iterable]
+ for value in self: # [not-an-iterable]
+ yield value
+ async for value in self:
+ yield value
+
+
+async def some_iter_func(number):
+ """ emits 1 number per second """
+ for i in range(1, number):
+ yield i
+ await asyncio.sleep(1)
+
+
+async def count_to(number):
+ """ counts to n in async manner"""
+ async for i in some_iter_func(number):
+ print(i)
+
+
+async def gen_values(num_values):
+ for value in range(num_values):
+ yield value
+
+
+async def do_some_comprehensions():
+ sets = {elem async for elem in gen_values(10)}
+ lists = [elem async for elem in gen_values(10)]
+ dicts = {elem: elem async for elem in gen_values(10)}
+ gen = (elem async for elem in gen_values(10))
+ return sets, lists, dicts, gen
diff --git a/tests/functional/i/iterable_context_py36.rc b/tests/functional/i/iterable_context_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/i/iterable_context_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/i/iterable_context_py36.txt b/tests/functional/i/iterable_context_py36.txt
new file mode 100644
index 0000000..b4a7c1f
--- /dev/null
+++ b/tests/functional/i/iterable_context_py36.txt
@@ -0,0 +1,2 @@
+not-an-iterable:11:35:AIter.to_list:Non-iterable value self is used in an iterating context
+not-an-iterable:12:21:AIter.to_list:Non-iterable value self is used in an iterating context
diff --git a/tests/functional/import_outside_toplevel.py b/tests/functional/import_outside_toplevel.py
new file mode 100644
index 0000000..3721db6
--- /dev/null
+++ b/tests/functional/import_outside_toplevel.py
@@ -0,0 +1,42 @@
+# pylint: disable=unused-import,multiple-imports,no-self-use,missing-docstring,invalid-name,too-few-public-methods
+
+import abc
+
+if 4 == 5:
+ import ast
+
+
+def f():
+ import symtable # [import-outside-toplevel]
+
+
+def g():
+ import os, sys # [import-outside-toplevel]
+
+
+def h():
+ import time as thyme # [import-outside-toplevel]
+
+
+def i():
+ import random as rand, socket as sock # [import-outside-toplevel]
+
+
+class C:
+ import tokenize # [import-outside-toplevel]
+
+ def j(self):
+ import turtle # [import-outside-toplevel]
+
+
+def k(flag):
+ if flag:
+ import tabnanny # [import-outside-toplevel]
+
+
+def j():
+ from collections import defaultdict # [import-outside-toplevel]
+
+
+def m():
+ from math import sin as sign, cos as cosplay # [import-outside-toplevel]
diff --git a/tests/functional/import_outside_toplevel.txt b/tests/functional/import_outside_toplevel.txt
new file mode 100644
index 0000000..d4b1786
--- /dev/null
+++ b/tests/functional/import_outside_toplevel.txt
@@ -0,0 +1,9 @@
+import-outside-toplevel:10:4:f:Import outside toplevel (symtable)
+import-outside-toplevel:14:4:g:Import outside toplevel (os, sys)
+import-outside-toplevel:18:4:h:Import outside toplevel (time)
+import-outside-toplevel:22:4:i:Import outside toplevel (random, socket)
+import-outside-toplevel:26:4:C:Import outside toplevel (tokenize)
+import-outside-toplevel:29:8:C.j:Import outside toplevel (turtle)
+import-outside-toplevel:34:8:k:Import outside toplevel (tabnanny)
+import-outside-toplevel:38:4:j:Import outside toplevel (collections.defaultdict)
+import-outside-toplevel:42:4:m:Import outside toplevel (math.sin, math.cos)
diff --git a/tests/functional/k/__init__.py b/tests/functional/k/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/k/__init__.py
diff --git a/tests/functional/k/keyword_arg_before_vararg.py b/tests/functional/k/keyword_arg_before_vararg.py
new file mode 100644
index 0000000..1192874
--- /dev/null
+++ b/tests/functional/k/keyword_arg_before_vararg.py
@@ -0,0 +1,35 @@
+"""Unittests for W1125 (kw args before *args)"""
+from __future__ import absolute_import, print_function
+
+# pylint: disable=unused-argument, useless-object-inheritance, unnecessary-pass
+def check_kwargs_before_args(param1, param2=2, *args): # [keyword-arg-before-vararg]
+ """docstring"""
+ pass
+
+check_kwargs_before_args(5)
+
+# pylint: disable=too-few-public-methods, invalid-name
+class AAAA(object):
+ """class AAAA"""
+ def func_in_class(self, param1, param2=2, *args): # [keyword-arg-before-vararg]
+ "method in class AAAA"
+ pass
+
+ @staticmethod
+ def static_method_in_class(param1, param2=3, *args): # [keyword-arg-before-vararg]
+ "static method in class AAAA"
+ pass
+
+ @classmethod
+ def class_method_in_class(cls, param1, param2=4, *args): # [keyword-arg-before-vararg]
+ "class method in class AAAA"
+ pass
+
+some_var = AAAA()
+some_var.func_in_class(3)
+
+some_var.static_method_in_class(4)
+AAAA.static_method_in_class(4)
+
+some_var.class_method_in_class(5)
+AAAA.class_method_in_class(5)
diff --git a/tests/functional/k/keyword_arg_before_vararg.txt b/tests/functional/k/keyword_arg_before_vararg.txt
new file mode 100644
index 0000000..874c094
--- /dev/null
+++ b/tests/functional/k/keyword_arg_before_vararg.txt
@@ -0,0 +1,4 @@
+keyword-arg-before-vararg:5:0:check_kwargs_before_args:Keyword argument before variable positional arguments list in the definition of check_kwargs_before_args function
+keyword-arg-before-vararg:14:4:AAAA.func_in_class:Keyword argument before variable positional arguments list in the definition of func_in_class function
+keyword-arg-before-vararg:19:4:AAAA.static_method_in_class:Keyword argument before variable positional arguments list in the definition of static_method_in_class function
+keyword-arg-before-vararg:24:4:AAAA.class_method_in_class:Keyword argument before variable positional arguments list in the definition of class_method_in_class function
diff --git a/tests/functional/l/__init__.py b/tests/functional/l/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/l/__init__.py
diff --git a/tests/functional/l/lambda_use_before_assign.py b/tests/functional/l/lambda_use_before_assign.py
new file mode 100644
index 0000000..af2775c
--- /dev/null
+++ b/tests/functional/l/lambda_use_before_assign.py
@@ -0,0 +1,8 @@
+"""https://www.logilab.net/elo/ticket/18862"""
+from __future__ import print_function
+__revision__ = 1
+def function():
+ """hop"""
+ ggg = lambda: xxx
+ xxx = 1
+ print(ggg())
diff --git a/tests/functional/l/len_checks.py b/tests/functional/l/len_checks.py
new file mode 100644
index 0000000..2cbefcb
--- /dev/null
+++ b/tests/functional/l/len_checks.py
@@ -0,0 +1,186 @@
+# pylint: disable=too-few-public-methods,import-error, no-absolute-import,missing-docstring, misplaced-comparison-constant
+# pylint: disable=useless-super-delegation,wrong-import-position,invalid-name, wrong-import-order, condition-evals-to-constant
+
+if len('TEST'): # [len-as-condition]
+ pass
+
+if not len('TEST'): # [len-as-condition]
+ pass
+
+z = []
+if z and len(['T', 'E', 'S', 'T']): # [len-as-condition]
+ pass
+
+if True or len('TEST'): # [len-as-condition]
+ pass
+
+if len('TEST') == 0: # Should be fine
+ pass
+
+if len('TEST') < 1: # Should be fine
+ pass
+
+if len('TEST') <= 0: # Should be fine
+ pass
+
+if 1 > len('TEST'): # Should be fine
+ pass
+
+if 0 >= len('TEST'): # Should be fine
+ pass
+
+if z and len('TEST') == 0: # Should be fine
+ pass
+
+if 0 == len('TEST') < 10: # Should be fine
+ pass
+
+if 0 < 1 <= len('TEST') < 10: # Should be fine
+ pass
+
+if 10 > len('TEST') != 0: # Should be fine
+ pass
+
+if 10 > len('TEST') > 1 > 0: # Should be fine
+ pass
+
+if 0 <= len('TEST') < 100: # Should be fine
+ pass
+
+if z or 10 > len('TEST') != 0: # Should be fine
+ pass
+
+if z:
+ pass
+elif len('TEST'): # [len-as-condition]
+ pass
+
+if z:
+ pass
+elif not len('TEST'): # [len-as-condition]
+ pass
+
+while len('TEST'): # [len-as-condition]
+ pass
+
+while not len('TEST'): # [len-as-condition]
+ pass
+
+while z and len('TEST'): # [len-as-condition]
+ pass
+
+while not len('TEST') and z: # [len-as-condition]
+ pass
+
+assert len('TEST') > 0 # Should be fine
+
+x = 1 if len('TEST') != 0 else 2 # Should be fine
+
+f_o_o = len('TEST') or 42 # Should be fine
+
+a = x and len(x) # Should be fine
+
+def some_func():
+ return len('TEST') > 0 # Should be fine
+
+def github_issue_1325():
+ l = [1, 2, 3]
+ length = len(l) if l else 0 # Should be fine
+ return length
+
+def github_issue_1331(*args):
+ assert False, len(args) # Should be fine
+
+def github_issue_1331_v2(*args):
+ assert len(args), args # [len-as-condition]
+
+def github_issue_1331_v3(*args):
+ assert len(args) or z, args # [len-as-condition]
+
+def github_issue_1331_v4(*args):
+ assert z and len(args), args # [len-as-condition]
+
+b = bool(len(z)) # [len-as-condition]
+c = bool(len('TEST') or 42) # [len-as-condition]
+
+
+def github_issue_1879():
+
+ class ClassWithBool(list):
+ def __bool__(self):
+ return True
+
+ class ClassWithoutBool(list):
+ pass
+
+ class ChildClassWithBool(ClassWithBool):
+ pass
+
+ class ChildClassWithoutBool(ClassWithoutBool):
+ pass
+
+ assert len(ClassWithBool())
+ assert len(ChildClassWithBool())
+ assert len(ClassWithoutBool()) # [len-as-condition]
+ assert len(ChildClassWithoutBool()) # [len-as-condition]
+ assert len(range(0)) # [len-as-condition]
+ assert len([t + 1 for t in []]) # [len-as-condition]
+ assert len(u + 1 for u in []) # [len-as-condition]
+ assert len({"1":(v + 1) for v in {}}) # [len-as-condition]
+ assert len(set((w + 1) for w in set())) # [len-as-condition]
+
+ # pylint: disable=import-outside-toplevel
+ import numpy
+ numpy_array = numpy.array([0])
+ if len(numpy_array) > 0:
+ print('numpy_array')
+ if len(numpy_array):
+ print('numpy_array')
+ if numpy_array:
+ print('b')
+
+ import pandas as pd
+ pandas_df = pd.DataFrame()
+ if len(pandas_df):
+ print("this works, but pylint tells me not to use len() without comparison")
+ if len(pandas_df) > 0:
+ print("this works and pylint likes it, but it's not the solution intended by PEP-8")
+ if pandas_df:
+ print("this does not work (truth value of dataframe is ambiguous)")
+
+ def function_returning_list(r):
+ if r==1:
+ return [1]
+ return [2]
+
+ def function_returning_int(r):
+ if r==1:
+ return 1
+ return 2
+
+ # def function_returning_generator(r):
+ # for i in [r, 1, 2, 3]:
+ # yield i
+
+ # def function_returning_comprehension(r):
+ # return [x+1 for x in [r, 1, 2, 3]]
+
+ # def function_returning_function(r):
+ # return function_returning_generator(r)
+
+ assert len(function_returning_list(z)) # [len-as-condition]
+ assert len(function_returning_int(z))
+ # This should raise a len-as-conditions once astroid can infer it
+ # See https://github.com/PyCQA/pylint/pull/3821#issuecomment-743771514
+ # assert len(function_returning_generator(z))
+ # assert len(function_returning_comprehension(z))
+ # assert len(function_returning_function(z))
+
+
+def github_issue_4215():
+ # Test undefined variables
+ # https://github.com/PyCQA/pylint/issues/4215
+ if len(undefined_var): # [undefined-variable]
+ pass
+ if len(undefined_var2[0]): # [undefined-variable]
+ pass
diff --git a/tests/functional/l/len_checks.txt b/tests/functional/l/len_checks.txt
new file mode 100644
index 0000000..f1b96e4
--- /dev/null
+++ b/tests/functional/l/len_checks.txt
@@ -0,0 +1,25 @@
+len-as-condition:4:3::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:7:3::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:11:9::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:14:11::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:55:5::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:60:5::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:63:6::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:66:6::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:69:12::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:72:6::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:95:11:github_issue_1331_v2:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:98:11:github_issue_1331_v3:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:101:17:github_issue_1331_v4:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:103:9::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:104:9::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:124:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:125:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:126:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:127:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:128:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:129:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:130:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:171:11:github_issue_1879:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+undefined-variable:183:11:github_issue_4215:Undefined variable 'undefined_var'
+undefined-variable:185:11:github_issue_4215:Undefined variable 'undefined_var2'
diff --git a/tests/functional/l/line_endings.py b/tests/functional/l/line_endings.py
new file mode 100644
index 0000000..0b6e795
--- /dev/null
+++ b/tests/functional/l/line_endings.py
@@ -0,0 +1,3 @@
+"mixing line endings are not welcome"
+# +1: [unexpected-line-ending-format, mixed-line-endings]
+CONST = 1
diff --git a/tests/functional/l/line_endings.rc b/tests/functional/l/line_endings.rc
new file mode 100644
index 0000000..95532ea
--- /dev/null
+++ b/tests/functional/l/line_endings.rc
@@ -0,0 +1,2 @@
+[Format]
+expected-line-ending-format=LF
diff --git a/tests/functional/l/line_endings.txt b/tests/functional/l/line_endings.txt
new file mode 100644
index 0000000..9d45f4a
--- /dev/null
+++ b/tests/functional/l/line_endings.txt
@@ -0,0 +1,2 @@
+mixed-line-endings:3:0::Mixed line endings LF and CRLF
+unexpected-line-ending-format:3:0::Unexpected line ending format. There is 'CRLF' while it should be 'LF'.
diff --git a/tests/functional/l/line_too_long.py b/tests/functional/l/line_too_long.py
new file mode 100644
index 0000000..1be4603
--- /dev/null
+++ b/tests/functional/l/line_too_long.py
@@ -0,0 +1,77 @@
+# pylint: disable=fixme, unnecessary-pass
+# +1: [line-too-long]
+#####################################################################################################
+# +1: [line-too-long]
+""" that one is too long tooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo loooooong"""
+
+# The next line is exactly 80 characters long.
+A = "--------------------------------------------------------------------------"
+
+# Do not trigger the line-too-long warning if the only token that makes the
+# line longer than 80 characters is a trailing pylint disable.
+# pylint:disable=invalid-name
+var = (
+ "This line has a disable pragma and whitespace trailing beyond 80 chars. "
+)
+
+# +1: [line-too-long]
+badname = "This line is already longer than 100 characters even without the pragma. Trust me. Please." # pylint:disable=invalid-name
+
+# http://example.com/this/is/a/very/long/url?but=splitting&urls=is&a=pain&so=they&can=be&long
+
+
+# +1: [line-too-long]
+# This line is toooooooooooooooooooooooooooooooooooooooooooooooo looooooooooooooooooooooooooooooooooooooooong #pylint: disable=fixme
+
+# +1: [line-too-long]
+# TODO: This line is toooooooooooooooooooooooooooooooooooooooooooooooo looooooooooooooooooooooooooooooooooooooooong #pylint: disable=fixme
+
+
+def function():
+ # +3: [line-too-long]
+ """This is a docstring.
+
+ That contains a very, very long line that exceeds the 100 characters limit by a good margin. So good?
+ """
+ pass
+
+
+# Don't crash when the line is in a docstring
+def func_with_long(parameter):
+ """
+ # pylint: disable=line-too-long
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccc
+ """
+ return parameter
+
+
+# No line-too-long message should be emitted as the disable comment stands for all the multiline
+def issue_2957():
+ """
+ This is a very very very long line within a docstring that should trigger a pylint C0301 error line-too-long
+
+ Even spread on multiple lines, the disable command is still effective on very very very, maybe too much long docstring
+ """#pylint: disable=line-too-long
+ return True
+
+
+def issue_2957_bis():
+ # +3: [line-too-long]
+ # +4: [line-too-long]
+ """
+ This is a very very very long line within a docstring that should trigger a pylint C0301 error line-too-long
+
+ Even spread on multiple lines, the disable command is still effective on very very very, maybe too much long docstring
+ """
+ return True
+
+
+# +2: [line-too-long]
+# +2: [line-too-long]
+VAR = """A very very long, maybe too much, constant. Just here to trigger message emission and check everything is fine and nice"""
+"""But it is however too long, isn't it? I don't know what to say more here. I got a lack of imagination, just listening to music..."""
+
+
+# +1: [line-too-long]
+VAR_BIS = """A very very long, maybe too much, constant. Just here to trigger message emission and check everything is fine and nice"""
+"""But it is however too long, isn't it? I don't know what to say more here. I got a lack of imagination, just listening to music..."""#pylint: disable=line-too-long
diff --git a/tests/functional/l/line_too_long.txt b/tests/functional/l/line_too_long.txt
new file mode 100644
index 0000000..57719ce
--- /dev/null
+++ b/tests/functional/l/line_too_long.txt
@@ -0,0 +1,11 @@
+line-too-long:3:0::Line too long (101/100)
+line-too-long:5:0::Line too long (104/100)
+line-too-long:18:0::Line too long (102/100)
+line-too-long:24:0::Line too long (109/100)
+line-too-long:27:0::Line too long (115/100)
+line-too-long:34:0::Line too long (105/100)
+line-too-long:62:0::Line too long (112/100)
+line-too-long:64:0::Line too long (122/100)
+line-too-long:71:0::Line too long (131/100)
+line-too-long:72:0::Line too long (135/100)
+line-too-long:76:0::Line too long (135/100)
diff --git a/tests/functional/l/line_too_long_end_of_module.py b/tests/functional/l/line_too_long_end_of_module.py
new file mode 100644
index 0000000..21cb756
--- /dev/null
+++ b/tests/functional/l/line_too_long_end_of_module.py
@@ -0,0 +1,7 @@
+#pylint: disable=missing-docstring, line-too-long
+
+# Hey this is a very long commented line just to trigger pylint's line-too-long message. It is just above a dummy function with a very long code line.
+def dummy_function():
+ print("What a beautiful dummy function with such a very long line inside that it should trigger pylint's line-too-long message ")
+
+# Hey this is a very long commented line at the end of the module. It is just here to trigger pylint's line-too-long message.
diff --git a/tests/functional/l/literal_comparison.py b/tests/functional/l/literal_comparison.py
new file mode 100644
index 0000000..646e57e
--- /dev/null
+++ b/tests/functional/l/literal_comparison.py
@@ -0,0 +1,50 @@
+# pylint: disable=missing-docstring, comparison-with-itself
+
+
+if 2 is 2: # [literal-comparison]
+ pass
+
+if "a" is b"a": # [literal-comparison]
+ pass
+
+if 2.0 is 3.0: # [literal-comparison]
+ pass
+
+if () is (1, 2, 3): # [literal-comparison]
+ pass
+
+if () is {1:2, 2:3}: # [literal-comparison]
+ pass
+
+if [] is [4, 5, 6]: # [literal-comparison]
+ pass
+
+if () is {1, 2, 3}: # [literal-comparison]
+ pass
+
+if () is not {1:2, 2:3}: # [literal-comparison]
+ pass
+
+if [] is not [4, 5, 6]: # [literal-comparison]
+ pass
+
+if () is not {1, 2, 3}: # [literal-comparison]
+ pass
+
+
+CONST = 24
+
+
+if CONST is 0: # [literal-comparison]
+ pass
+
+if CONST is 1: # [literal-comparison]
+ pass
+
+if CONST is 42: # [literal-comparison]
+ pass
+
+# We do not do inference for this check, since the comparing
+# object might be used as a sentinel.
+if () is CONST:
+ pass
diff --git a/tests/functional/l/literal_comparison.txt b/tests/functional/l/literal_comparison.txt
new file mode 100644
index 0000000..541bfe5
--- /dev/null
+++ b/tests/functional/l/literal_comparison.txt
@@ -0,0 +1,13 @@
+literal-comparison:4:3::Comparison to literal
+literal-comparison:7:3::Comparison to literal
+literal-comparison:10:3::Comparison to literal
+literal-comparison:13:3::Comparison to literal
+literal-comparison:16:3::Comparison to literal
+literal-comparison:19:3::Comparison to literal
+literal-comparison:22:3::Comparison to literal
+literal-comparison:25:3::Comparison to literal
+literal-comparison:28:3::Comparison to literal
+literal-comparison:31:3::Comparison to literal
+literal-comparison:38:3::Comparison to literal
+literal-comparison:41:3::Comparison to literal
+literal-comparison:44:3::Comparison to literal
diff --git a/tests/functional/l/logging_format_interpolation.py b/tests/functional/l/logging_format_interpolation.py
new file mode 100644
index 0000000..8defa94
--- /dev/null
+++ b/tests/functional/l/logging_format_interpolation.py
@@ -0,0 +1,37 @@
+# pylint: disable=no-member, no-absolute-import, import-error,line-too-long
+# pylint: disable=invalid-name,missing-docstring,wrong-import-order,wrong-import-position
+try:
+ import __builtin__ as builtins
+except ImportError:
+ import builtins
+
+# Muck up the names in an effort to confuse...
+import logging as renamed_logging
+import os as logging
+from uninferable import UNINFERABLE
+
+FORMAT_STR = '{0}, {1}'
+
+# Statements that should be flagged:
+renamed_logging.debug('{0}, {1}'.format(4, 5)) # [logging-format-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, 'msg: {}'.format('Run!')) # [logging-format-interpolation]
+renamed_logging.debug(FORMAT_STR.format(4, 5)) # [logging-format-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, FORMAT_STR.format(4, 5)) # [logging-format-interpolation]
+renamed_logging.info("Read {l} rows".format(l=123456789)) # [logging-format-interpolation]
+
+# Statements that should not be flagged:
+renamed_logging.debug(format(66, 'x'))
+renamed_logging.debug(builtins.format(66, 'x'))
+renamed_logging.log(renamed_logging.DEBUG, 'msg: Run!'.upper())
+logging.debug('{0}, {1}'.format(4, 5))
+logging.log(logging.DEBUG, 'msg: {}'.format('Run!'))
+renamed_logging.info("Read {l:,d} rows".format(l=123456789))
+renamed_logging.info(UNINFERABLE.format(l=123456789))
+
+
+class Logger(renamed_logging.Logger):
+ pass
+
+custom_logger = Logger('three')
+custom_logger.info('testing {0}'.format('info')) # [logging-format-interpolation]
+custom_logger.info('testing %s' % 'info') # [logging-not-lazy]
diff --git a/tests/functional/l/logging_format_interpolation.txt b/tests/functional/l/logging_format_interpolation.txt
new file mode 100644
index 0000000..6437b71
--- /dev/null
+++ b/tests/functional/l/logging_format_interpolation.txt
@@ -0,0 +1,7 @@
+logging-format-interpolation:16:22::Use lazy % formatting in logging functions
+logging-format-interpolation:17:43::Use lazy % formatting in logging functions
+logging-format-interpolation:18:22::Use lazy % formatting in logging functions
+logging-format-interpolation:19:43::Use lazy % formatting in logging functions
+logging-format-interpolation:20:21::Use lazy % formatting in logging functions
+logging-format-interpolation:36:19::Use lazy % formatting in logging functions
+logging-not-lazy:37:0::Use lazy % formatting in logging functions
diff --git a/tests/functional/l/logging_format_interpolation_py36.py b/tests/functional/l/logging_format_interpolation_py36.py
new file mode 100644
index 0000000..2601c5b
--- /dev/null
+++ b/tests/functional/l/logging_format_interpolation_py36.py
@@ -0,0 +1,5 @@
+"""Test logging-fstring-interpolation for Python 3.6"""
+import logging as renamed_logging
+
+
+renamed_logging.info(f'Read {renamed_logging} from globals') # [logging-fstring-interpolation]
diff --git a/tests/functional/l/logging_format_interpolation_py36.rc b/tests/functional/l/logging_format_interpolation_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/l/logging_format_interpolation_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/l/logging_format_interpolation_py36.txt b/tests/functional/l/logging_format_interpolation_py36.txt
new file mode 100644
index 0000000..a0de664
--- /dev/null
+++ b/tests/functional/l/logging_format_interpolation_py36.txt
@@ -0,0 +1 @@
+logging-fstring-interpolation:5:0::Use lazy % formatting in logging functions
diff --git a/tests/functional/l/logging_fstring_interpolation_py36.py b/tests/functional/l/logging_fstring_interpolation_py36.py
new file mode 100644
index 0000000..5aebb7d
--- /dev/null
+++ b/tests/functional/l/logging_fstring_interpolation_py36.py
@@ -0,0 +1,21 @@
+"""Test logging-fstring-interpolation for Python 3.6"""
+# pylint: disable=invalid-name
+
+from datetime import datetime
+
+import logging as renamed_logging
+
+
+local_var_1 = 4
+local_var_2 = "run!"
+
+pi = 3.14159265
+
+may_14 = datetime(year=2018, month=5, day=14)
+
+# Statements that should be flagged:
+renamed_logging.debug(f'{local_var_1} {local_var_2}') # [logging-fstring-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, f'msg: {local_var_2}') # [logging-fstring-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, f'pi: {pi:.3f}') # [logging-fstring-interpolation]
+renamed_logging.info(f"{local_var_2.upper()}") # [logging-fstring-interpolation]
+renamed_logging.info(f"{may_14:'%b %d: %Y'}") # [logging-fstring-interpolation]
diff --git a/tests/functional/l/logging_fstring_interpolation_py36.rc b/tests/functional/l/logging_fstring_interpolation_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/l/logging_fstring_interpolation_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/l/logging_fstring_interpolation_py36.txt b/tests/functional/l/logging_fstring_interpolation_py36.txt
new file mode 100644
index 0000000..5529b33
--- /dev/null
+++ b/tests/functional/l/logging_fstring_interpolation_py36.txt
@@ -0,0 +1,5 @@
+logging-fstring-interpolation:17:0::Use lazy % formatting in logging functions
+logging-fstring-interpolation:18:0::Use lazy % formatting in logging functions
+logging-fstring-interpolation:19:0::Use lazy % formatting in logging functions
+logging-fstring-interpolation:20:0::Use lazy % formatting in logging functions
+logging-fstring-interpolation:21:0::Use lazy % formatting in logging functions
diff --git a/tests/functional/l/logging_not_lazy.py b/tests/functional/l/logging_not_lazy.py
new file mode 100644
index 0000000..c063432
--- /dev/null
+++ b/tests/functional/l/logging_not_lazy.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,no-member,deprecated-method,invalid-name
+
+# Muck up the names in an effort to confuse...
+import logging as renamed_logging
+import os as logging
+
+var = "123"
+var_name = 'Var:'
+# Statements that should be flagged:
+renamed_logging.warn('%s, %s' % (4, 5)) # [logging-not-lazy]
+renamed_logging.exception('%s' % 'Exceptional!') # [logging-not-lazy]
+renamed_logging.log(renamed_logging.INFO, 'msg: %s' % 'Run!') # [logging-not-lazy]
+renamed_logging.log(renamed_logging.INFO, "Var: " + var) # [logging-not-lazy]
+renamed_logging.warn('%s' + ' the rest of a single string') # [logging-not-lazy]
+renamed_logging.log(renamed_logging.INFO, var_name + var) # [logging-not-lazy]
+
+var_name = 'Var:'
+# Statements that should not be flagged:
+renamed_logging.warn('%s, %s', 4, 5)
+renamed_logging.log(renamed_logging.INFO, 'msg: %s', 'Run!')
+logging.warn('%s, %s' % (4, 5))
+logging.log(logging.INFO, 'msg: %s' % 'Run!')
+logging.log("Var: " + var)
diff --git a/tests/functional/l/logging_not_lazy.txt b/tests/functional/l/logging_not_lazy.txt
new file mode 100644
index 0000000..88a1c1e
--- /dev/null
+++ b/tests/functional/l/logging_not_lazy.txt
@@ -0,0 +1,6 @@
+logging-not-lazy:10:0::Use lazy % formatting in logging functions
+logging-not-lazy:11:0::Use lazy % formatting in logging functions
+logging-not-lazy:12:0::Use lazy % formatting in logging functions
+logging-not-lazy:13:0::Use lazy % formatting in logging functions
+logging-not-lazy:14:0::Use lazy % formatting in logging functions
+logging-not-lazy:15:0::Use lazy % formatting in logging functions
diff --git a/tests/functional/l/logging_not_lazy_with_logger.py b/tests/functional/l/logging_not_lazy_with_logger.py
new file mode 100644
index 0000000..ef2221f
--- /dev/null
+++ b/tests/functional/l/logging_not_lazy_with_logger.py
@@ -0,0 +1,13 @@
+"""Logging warnings using a logger class."""
+from __future__ import absolute_import
+import logging
+
+__revision__ = ''
+
+LOG = logging.getLogger("domain")
+LOG.debug("%s" % "junk") # [logging-not-lazy]
+LOG.log(logging.DEBUG, "%s" % "junk") # [logging-not-lazy]
+LOG2 = LOG.debug
+LOG2("%s" % "junk") # [logging-not-lazy]
+
+logging.getLogger("domain").debug("%s" % "junk") # [logging-not-lazy]
diff --git a/tests/functional/l/logging_not_lazy_with_logger.txt b/tests/functional/l/logging_not_lazy_with_logger.txt
new file mode 100644
index 0000000..31fe45c
--- /dev/null
+++ b/tests/functional/l/logging_not_lazy_with_logger.txt
@@ -0,0 +1,4 @@
+logging-not-lazy:8:0::Use lazy % formatting in logging functions
+logging-not-lazy:9:0::Use lazy % formatting in logging functions
+logging-not-lazy:11:0::Use lazy % formatting in logging functions
+logging-not-lazy:13:0::Use lazy % formatting in logging functions
diff --git a/tests/functional/l/logical_tautology.py b/tests/functional/l/logical_tautology.py
new file mode 100644
index 0000000..be133ba
--- /dev/null
+++ b/tests/functional/l/logical_tautology.py
@@ -0,0 +1,40 @@
+"""Check for logical tautology, when a value is compared against itself."""
+# pylint: disable=missing-docstring, disallowed-name, singleton-comparison, too-many-return-statements, inconsistent-return-statements, no-else-return, too-many-branches, literal-comparison
+
+def foo():
+ arg = 786
+ if arg == arg: # [comparison-with-itself]
+ return True
+ elif arg != arg: # [comparison-with-itself]
+ return True
+ elif arg > arg: # [comparison-with-itself]
+ return True
+ elif arg <= arg: # [comparison-with-itself]
+ return True
+ elif None == None: # [comparison-with-itself]
+ return None
+ elif 786 == 786: # [comparison-with-itself]
+ return True
+ elif 786 is 786: # [comparison-with-itself]
+ return True
+ elif 786 is not 786: # [comparison-with-itself]
+ return True
+ elif arg is arg: # [comparison-with-itself]
+ return True
+ elif arg is not arg: # [comparison-with-itself]
+ return True
+ elif True is True: # [comparison-with-itself]
+ return True
+ elif 666 == 786:
+ return False
+ else:
+ return None
+
+
+def bar():
+ arg = 666
+ return 666 if arg != arg else 786 # [comparison-with-itself]
+
+def foobar():
+ arg = 786
+ return arg > 786
diff --git a/tests/functional/l/logical_tautology.txt b/tests/functional/l/logical_tautology.txt
new file mode 100644
index 0000000..dba64ce
--- /dev/null
+++ b/tests/functional/l/logical_tautology.txt
@@ -0,0 +1,12 @@
+comparison-with-itself:6:7:foo:Redundant comparison - arg == arg
+comparison-with-itself:8:9:foo:Redundant comparison - arg != arg
+comparison-with-itself:10:9:foo:Redundant comparison - arg > arg
+comparison-with-itself:12:9:foo:Redundant comparison - arg <= arg
+comparison-with-itself:14:9:foo:Redundant comparison - None == None
+comparison-with-itself:16:9:foo:Redundant comparison - 786 == 786
+comparison-with-itself:18:9:foo:Redundant comparison - 786 is 786
+comparison-with-itself:20:9:foo:Redundant comparison - 786 is not 786
+comparison-with-itself:22:9:foo:Redundant comparison - arg is arg
+comparison-with-itself:24:9:foo:Redundant comparison - arg is not arg
+comparison-with-itself:26:9:foo:Redundant comparison - True is True
+comparison-with-itself:36:18:bar:Redundant comparison - arg != arg
diff --git a/tests/functional/l/long_lines_with_utf8.py b/tests/functional/l/long_lines_with_utf8.py
new file mode 100644
index 0000000..a1d90ed
--- /dev/null
+++ b/tests/functional/l/long_lines_with_utf8.py
@@ -0,0 +1,7 @@
+# coding: utf-8
+"""Test data file files with non-ASCII content."""
+
+
+THIS_IS_A_LONG_VARIABLE_NAME = 'Существительное Частица' # but the line is okay
+
+THIS_IS_A_VERY_LONG_VARIABLE_NAME = 'Существительное Частица' # and the line is not okay # [line-too-long]
diff --git a/tests/functional/l/long_lines_with_utf8.txt b/tests/functional/l/long_lines_with_utf8.txt
new file mode 100644
index 0000000..22440fa
--- /dev/null
+++ b/tests/functional/l/long_lines_with_utf8.txt
@@ -0,0 +1 @@
+line-too-long:7:0::Line too long (108/100)
diff --git a/tests/functional/l/long_utf8_lines.py b/tests/functional/l/long_utf8_lines.py
new file mode 100644
index 0000000..815759f
--- /dev/null
+++ b/tests/functional/l/long_utf8_lines.py
@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""this utf-8 doc string have some non ASCII caracters like 'é', or '¢»ß'"""
+### check also comments with some more non ASCII caracters like 'é' or '¢»ß'
+
+__revision__ = 1100
+
+ASCII = "----------------------------------------------------------------------"
+UTF_8 = "--------------------------------------------------------------------éé"
diff --git a/tests/functional/l/loopvar_in_dict_comp_py27.py b/tests/functional/l/loopvar_in_dict_comp_py27.py
new file mode 100644
index 0000000..072ea1b
--- /dev/null
+++ b/tests/functional/l/loopvar_in_dict_comp_py27.py
@@ -0,0 +1,8 @@
+"""Tests for loopvar-in-closure."""
+
+__revision__ = 0
+
+
+def bad_case():
+ """Loop variable from dict comprehension."""
+ return {x: lambda: x for x in range(10)} # [cell-var-from-loop]
diff --git a/tests/functional/l/loopvar_in_dict_comp_py27.txt b/tests/functional/l/loopvar_in_dict_comp_py27.txt
new file mode 100644
index 0000000..2d98fcf
--- /dev/null
+++ b/tests/functional/l/loopvar_in_dict_comp_py27.txt
@@ -0,0 +1 @@
+cell-var-from-loop:8:23:bad_case.<lambda>:Cell variable x defined in loop
diff --git a/tests/functional/l/lost_exception.py b/tests/functional/l/lost_exception.py
new file mode 100644
index 0000000..c8fd3fe
--- /dev/null
+++ b/tests/functional/l/lost_exception.py
@@ -0,0 +1,38 @@
+# pylint: disable=missing-docstring, using-constant-test,cell-var-from-loop
+
+def insidious_break_and_return():
+ for i in range(0, -5, -1):
+ my_var = 0
+
+ try:
+ my_var += 1.0/i
+ if i < -3:
+ break
+ return my_var
+ finally:
+ if i > -2:
+ break # [lost-exception]
+ return my_var # [lost-exception]
+ return None
+
+
+def break_and_return():
+ for i in range(0, -5, -1):
+ my_var = 0
+ if i:
+ break
+ try:
+ my_var += 1.0/i
+ finally:
+ for _ in range(2):
+ if True:
+ break
+ else:
+ def strange():
+ if True:
+ return my_var
+ return None
+ strange()
+ if i:
+ break
+ return
diff --git a/tests/functional/l/lost_exception.txt b/tests/functional/l/lost_exception.txt
new file mode 100644
index 0000000..f2791dc
--- /dev/null
+++ b/tests/functional/l/lost_exception.txt
@@ -0,0 +1,2 @@
+lost-exception:14:16:insidious_break_and_return:break statement in finally block may swallow exception
+lost-exception:15:12:insidious_break_and_return:return statement in finally block may swallow exception
diff --git a/tests/functional/m/__init__.py b/tests/functional/m/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/m/__init__.py
diff --git a/tests/functional/m/mapping_context.py b/tests/functional/m/mapping_context.py
new file mode 100644
index 0000000..6b3a135
--- /dev/null
+++ b/tests/functional/m/mapping_context.py
@@ -0,0 +1,109 @@
+"""
+Checks that only valid values are used in a mapping context.
+"""
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods,no-self-use,import-error,wrong-import-position, useless-object-inheritance
+from __future__ import print_function
+
+
+def test(**kwargs):
+ print(kwargs)
+
+
+# dictionary value/comprehension
+dict_value = dict(a=1, b=2, c=3)
+dict_comp = {chr(x): x for x in range(256)}
+test(**dict_value)
+test(**dict_comp)
+
+
+# in order to be used in kwargs custom mapping class should define
+# __iter__(), __getitem__(key) and keys().
+class CustomMapping(object):
+ def __init__(self):
+ self.data = dict(a=1, b=2, c=3, d=4, e=5)
+
+ def __getitem__(self, key):
+ return self.data[key]
+
+ def keys(self):
+ return self.data.keys()
+
+test(**CustomMapping())
+test(**CustomMapping) # [not-a-mapping]
+
+class NotMapping(object):
+ pass
+
+test(**NotMapping()) # [not-a-mapping]
+
+# skip checks if statement is inside mixin/base/abstract class
+class SomeMixin(object):
+ kwargs = None
+
+ def get_kwargs(self):
+ return self.kwargs
+
+ def run(self, **kwargs):
+ print(kwargs)
+
+ def dispatch(self):
+ kws = self.get_kwargs()
+ self.run(**kws)
+
+class AbstractThing(object):
+ kwargs = None
+
+ def get_kwargs(self):
+ return self.kwargs
+
+ def run(self, **kwargs):
+ print(kwargs)
+
+ def dispatch(self):
+ kws = self.get_kwargs()
+ self.run(**kws)
+
+class BaseThing(object):
+ kwargs = None
+
+ def get_kwargs(self):
+ return self.kwargs
+
+ def run(self, **kwargs):
+ print(kwargs)
+
+ def dispatch(self):
+ kws = self.get_kwargs()
+ self.run(**kws)
+
+# abstract class
+class Thing(object):
+ def get_kwargs(self):
+ raise NotImplementedError
+
+ def run(self, **kwargs):
+ print(kwargs)
+
+ def dispatch(self):
+ kwargs = self.get_kwargs()
+ self.run(**kwargs)
+
+# skip uninferable instances
+from some_missing_module import Mapping
+
+class MyClass(Mapping):
+ pass
+
+test(**MyClass())
+
+
+class HasDynamicGetattr(object):
+
+ def __init__(self):
+ self._obj = {}
+
+ def __getattr__(self, attr):
+ return getattr(self._obj, attr)
+
+
+test(**HasDynamicGetattr())
diff --git a/tests/functional/m/mapping_context.txt b/tests/functional/m/mapping_context.txt
new file mode 100644
index 0000000..2326356
--- /dev/null
+++ b/tests/functional/m/mapping_context.txt
@@ -0,0 +1,2 @@
+not-a-mapping:32:7::Non-mapping value CustomMapping is used in a mapping context
+not-a-mapping:37:7::Non-mapping value NotMapping() is used in a mapping context
diff --git a/tests/functional/m/mapping_context_py3.py b/tests/functional/m/mapping_context_py3.py
new file mode 100644
index 0000000..042d4d0
--- /dev/null
+++ b/tests/functional/m/mapping_context_py3.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods,no-self-use
+from __future__ import print_function
+
+def test(**kwargs):
+ print(kwargs)
+
+# metaclasses as mappings
+class Meta(type):
+ def __getitem__(cls, key):
+ return ord(key)
+
+ def keys(cls):
+ return ['a', 'b', 'c']
+
+class SomeClass(metaclass=Meta):
+ pass
+
+test(**SomeClass)
+test(**SomeClass()) # [not-a-mapping]
diff --git a/tests/functional/m/mapping_context_py3.rc b/tests/functional/m/mapping_context_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/m/mapping_context_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/m/mapping_context_py3.txt b/tests/functional/m/mapping_context_py3.txt
new file mode 100644
index 0000000..f774914
--- /dev/null
+++ b/tests/functional/m/mapping_context_py3.txt
@@ -0,0 +1 @@
+not-a-mapping:19:7::Non-mapping value SomeClass() is used in a mapping context
diff --git a/tests/functional/m/member/member_checks.py b/tests/functional/m/member/member_checks.py
new file mode 100644
index 0000000..ee79d10
--- /dev/null
+++ b/tests/functional/m/member/member_checks.py
@@ -0,0 +1,233 @@
+# pylint: disable=print-statement,missing-docstring,no-self-use,too-few-public-methods,bare-except,broad-except, useless-object-inheritance, unused-private-member
+# pylint: disable=using-constant-test,expression-not-assigned, assigning-non-slot, unused-variable,pointless-statement, wrong-import-order, wrong-import-position,import-outside-toplevel
+from __future__ import print_function
+class Provider(object):
+ """provide some attributes and method"""
+ cattr = 4
+ def __init__(self):
+ self.attr = 4
+ def method(self, val):
+ """impressive method"""
+ return self.attr * val
+ def hophop(self):
+ """hop method"""
+ print('hop hop hop', self)
+
+
+class Client(object):
+ """use provider class"""
+
+ def __init__(self):
+ self._prov = Provider()
+ self._prov_attr = Provider.cattr
+ self._prov_attr2 = Provider.cattribute # [no-member]
+ self.set_later = 0
+
+ def set_set_later(self, value):
+ """set set_later attribute (introduce an inference ambiguity)"""
+ self.set_later = value
+
+ def use_method(self):
+ """use provider's method"""
+ self._prov.hophop()
+ self._prov.hophophop() # [no-member]
+
+ def use_attr(self):
+ """use provider's attr"""
+ print(self._prov.attr)
+ print(self._prov.attribute) # [no-member]
+
+ def debug(self):
+ """print debug information"""
+ print(self.__class__.__name__)
+ print(self.__doc__)
+ print(self.__dict__)
+ print(self.__module__)
+
+ def test_bt_types(self):
+ """test access to unexistant member of builtin types"""
+ lis = []
+ lis.apppend(self) # [no-member]
+ dic = {}
+ dic.set(self) # [no-member]
+ tup = ()
+ tup.append(self) # [no-member]
+ string = 'toto'
+ print(string.loower()) # [no-member]
+ integer = 1
+ print(integer.whatever) # [no-member]
+
+ def test_no_false_positives(self):
+ none = None
+ print(none.whatever)
+ # No misssing in the parents.
+ super().misssing() # [no-member]
+
+
+class Mixin(object):
+ """No no-member should be emitted for mixins."""
+
+class Getattr(object):
+ """no-member shouldn't be emitted for classes with dunder getattr."""
+
+ def __getattr__(self, attr):
+ return self.__dict__[attr]
+
+
+class Getattribute(object):
+ """no-member shouldn't be emitted for classes with dunder getattribute."""
+
+ def __getattribute__(self, attr):
+ return 42
+
+print(object.__init__)
+print(property.__init__)
+print(Client().set_later.lower())
+print(Mixin().nanana())
+print(Getattr().nananan())
+print(Getattribute().batman())
+
+try:
+ Client().missing_method()
+except AttributeError:
+ pass
+
+try:
+ Client().indeed() # [no-member]
+except ImportError:
+ pass
+
+try:
+ Client.missing()
+except AttributeError:
+ Client.missing() # [no-member]
+
+try:
+ Client.missing()
+except AttributeError:
+ try:
+ Client.missing() # [no-member]
+ except ValueError:
+ pass
+
+try:
+ if Client:
+ Client().missing()
+except AttributeError:
+ pass
+
+try:
+ Client().indeed()
+except AttributeError:
+ try:
+ Client.missing() # [no-member]
+ except Exception:
+ pass
+
+
+class SuperChecks(str, str): # pylint: disable=duplicate-bases
+ """Don't fail when the MRO is invalid."""
+ def test(self):
+ super().lalala()
+
+type(Client()).ala # [no-member]
+type({}).bala # [no-member]
+type('').portocala # [no-member]
+
+
+def socket_false_positive():
+ """Test a regression
+ Version used:
+
+ - Pylint 0.10.0
+ - Logilab common 0.15.0
+ - Logilab astroid 0.15.1
+
+ False E1101 positive, line 23:
+ Instance of '_socketobject' has no 'connect' member
+ """
+
+ import socket
+ sckt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sckt.connect(('127.0.0.1', 80))
+ sckt.close()
+
+
+def no_conjugate_member(magic_flag):
+ """should not raise E1101 on something.conjugate"""
+ if magic_flag:
+ something = 1.0
+ else:
+ something = 1.0j
+ if isinstance(something, float):
+ return something
+ return something.conjugate()
+
+
+class NoDunderNameInInstance(object):
+ """Emit a warning when accessing __name__ from an instance."""
+ def __init__(self):
+ self.var = self.__name__ # [no-member]
+
+
+class InvalidAccessBySlots(object):
+ __slots__ = ('a', )
+ def __init__(self):
+ var = self.teta # [no-member]
+ self.teta = 24
+
+
+class MetaWithDynamicGetattr(type):
+
+ def __getattr__(cls, attr):
+ return attr
+
+
+class SomeClass(object, metaclass=MetaWithDynamicGetattr):
+ pass
+
+
+SomeClass.does_not_exist
+
+class ClassWithMangledAttribute(object):
+ def __init__(self):
+ self.name = 'Bug1643'
+ def __bar(self):
+ print(self.name + "xD")
+
+ClassWithMangledAttribute()._ClassWithMangledAttribute__bar() # pylint: disable=protected-access
+
+
+import enum
+
+
+class Cls(enum.IntEnum):
+ BAR = 0
+
+
+SOME_VALUE = Cls.BAZ # [no-member]
+
+
+
+# Does not crash when inferring the `append` attribute on the slice object
+class SomeClassUsingSlice:
+ def __init__(self, flag):
+ if flag:
+ self.attribute = slice(None)
+ else:
+ self.attribute = []
+ self.attribute.append(1)
+
+from enum import Enum
+class Animal(Enum):
+ ANT = 1
+ BEE = 2
+ CAT = 3
+ DOG = 4
+# To test false positive no-member on Enum.__members__.items()
+for itm in Animal.__members__.items():
+ print(itm)
+for keyy in Animal.__members__.keys(): # pylint: disable=consider-iterating-dictionary
+ print(keyy)
+for vall in Animal.__members__.values():
+ print(vall)
diff --git a/tests/functional/m/member/member_checks.txt b/tests/functional/m/member/member_checks.txt
new file mode 100644
index 0000000..0b7ee94
--- /dev/null
+++ b/tests/functional/m/member/member_checks.txt
@@ -0,0 +1,19 @@
+no-member:23:27:Client.__init__:Class 'Provider' has no 'cattribute' member:INFERENCE
+no-member:33:8:Client.use_method:Instance of 'Provider' has no 'hophophop' member:INFERENCE
+no-member:38:14:Client.use_attr:Instance of 'Provider' has no 'attribute' member:INFERENCE
+no-member:50:8:Client.test_bt_types:Instance of 'list' has no 'apppend' member; maybe 'append'?:INFERENCE
+no-member:52:8:Client.test_bt_types:Instance of 'dict' has no 'set' member; maybe 'get'?:INFERENCE
+no-member:54:8:Client.test_bt_types:Instance of 'tuple' has no 'append' member:INFERENCE
+no-member:56:14:Client.test_bt_types:Instance of 'str' has no 'loower' member; maybe 'lower'?:INFERENCE
+no-member:58:14:Client.test_bt_types:Instance of 'int' has no 'whatever' member:INFERENCE
+no-member:64:8:Client.test_no_false_positives:Super of 'Client' has no 'misssing' member:INFERENCE
+no-member:96:4::Instance of 'Client' has no 'indeed' member:INFERENCE
+no-member:103:4::Class 'Client' has no 'missing' member:INFERENCE
+no-member:109:8::Class 'Client' has no 'missing' member:INFERENCE
+no-member:123:8::Class 'Client' has no 'missing' member:INFERENCE
+no-member:133:0::Class 'Client' has no 'ala' member:INFERENCE
+no-member:134:0::Class 'dict' has no 'bala' member:INFERENCE
+no-member:135:0::Class 'str' has no 'portocala' member:INFERENCE
+no-member:170:19:NoDunderNameInInstance.__init__:Instance of 'NoDunderNameInInstance' has no '__name__' member:INFERENCE
+no-member:176:14:InvalidAccessBySlots.__init__:Instance of 'InvalidAccessBySlots' has no 'teta' member:INFERENCE
+no-member:208:13::Class 'Cls' has no 'BAZ' member; maybe 'BAR'?:INFERENCE
diff --git a/tests/functional/m/member/member_checks_hints.py b/tests/functional/m/member/member_checks_hints.py
new file mode 100644
index 0000000..3925f47
--- /dev/null
+++ b/tests/functional/m/member/member_checks_hints.py
@@ -0,0 +1,27 @@
+# pylint: disable=missing-docstring, too-few-public-methods, pointless-statement, useless-object-inheritance
+
+
+class Parent(object):
+
+ def __init__(self):
+ self._parent = 42
+ self._registry = {}
+ self._similar1 = 24
+ self._similar2 = 23
+ self._similar3 = 24
+ self._really_similar1 = 23
+ self._really_similar2 = 42
+
+
+class Child(Parent):
+
+ def __init__(self):
+ super().__init__()
+
+ self._similar # [no-member]
+ self._really_similar # [no-member]
+ self._paren # [no-member]
+ # Distance is too big
+ self._registryyyy # [no-member]
+ # Nothing close.
+ self._pretty_sure_this_wont_match # [no-member]
diff --git a/tests/functional/m/member/member_checks_hints.rc b/tests/functional/m/member/member_checks_hints.rc
new file mode 100644
index 0000000..8d4b587
--- /dev/null
+++ b/tests/functional/m/member/member_checks_hints.rc
@@ -0,0 +1,3 @@
+[TYPECHECK]
+missing-member-max-choices = 3
+missing-member-hint-distance = 1
diff --git a/tests/functional/m/member/member_checks_hints.txt b/tests/functional/m/member/member_checks_hints.txt
new file mode 100644
index 0000000..9dd977b
--- /dev/null
+++ b/tests/functional/m/member/member_checks_hints.txt
@@ -0,0 +1,5 @@
+no-member:21:8:Child.__init__:Instance of 'Child' has no '_similar' member; maybe one of '_similar1', '_similar2' or '_similar3'?:INFERENCE
+no-member:22:8:Child.__init__:Instance of 'Child' has no '_really_similar' member; maybe one of '_really_similar1' or '_really_similar2'?:INFERENCE
+no-member:23:8:Child.__init__:Instance of 'Child' has no '_paren' member; maybe '_parent'?:INFERENCE
+no-member:25:8:Child.__init__:Instance of 'Child' has no '_registryyyy' member:INFERENCE
+no-member:27:8:Child.__init__:Instance of 'Child' has no '_pretty_sure_this_wont_match' member:INFERENCE
diff --git a/tests/functional/m/member/member_checks_ignore_none.py b/tests/functional/m/member/member_checks_ignore_none.py
new file mode 100644
index 0000000..06f01cb
--- /dev/null
+++ b/tests/functional/m/member/member_checks_ignore_none.py
@@ -0,0 +1,7 @@
+# pylint: disable=missing-docstring, useless-return
+
+def func():
+ return None
+
+
+SOME_VAR = func().DOES_NOT_EXIST # [no-member]
diff --git a/tests/functional/m/member/member_checks_ignore_none.rc b/tests/functional/m/member/member_checks_ignore_none.rc
new file mode 100644
index 0000000..9ec706e
--- /dev/null
+++ b/tests/functional/m/member/member_checks_ignore_none.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+ignore-none=no
diff --git a/tests/functional/m/member/member_checks_ignore_none.txt b/tests/functional/m/member/member_checks_ignore_none.txt
new file mode 100644
index 0000000..ead0e7e
--- /dev/null
+++ b/tests/functional/m/member/member_checks_ignore_none.txt
@@ -0,0 +1 @@
+no-member:7:11::Instance of 'NoneType' has no 'DOES_NOT_EXIST' member:INFERENCE
diff --git a/tests/functional/m/member/member_checks_inference_improvements.py b/tests/functional/m/member/member_checks_inference_improvements.py
new file mode 100644
index 0000000..6eefa79
--- /dev/null
+++ b/tests/functional/m/member/member_checks_inference_improvements.py
@@ -0,0 +1,11 @@
+# pylint: disable=missing-docstring
+
+
+def test_oserror_has_strerror():
+ # https://github.com/PyCQA/pylint/issues/2553
+ try:
+ raise OSError()
+ except OSError as exc:
+ if exc.strerror is not None:
+ return exc.strerror.lower()
+ return None
diff --git a/tests/functional/m/member/member_checks_no_hints.py b/tests/functional/m/member/member_checks_no_hints.py
new file mode 100644
index 0000000..3925f47
--- /dev/null
+++ b/tests/functional/m/member/member_checks_no_hints.py
@@ -0,0 +1,27 @@
+# pylint: disable=missing-docstring, too-few-public-methods, pointless-statement, useless-object-inheritance
+
+
+class Parent(object):
+
+ def __init__(self):
+ self._parent = 42
+ self._registry = {}
+ self._similar1 = 24
+ self._similar2 = 23
+ self._similar3 = 24
+ self._really_similar1 = 23
+ self._really_similar2 = 42
+
+
+class Child(Parent):
+
+ def __init__(self):
+ super().__init__()
+
+ self._similar # [no-member]
+ self._really_similar # [no-member]
+ self._paren # [no-member]
+ # Distance is too big
+ self._registryyyy # [no-member]
+ # Nothing close.
+ self._pretty_sure_this_wont_match # [no-member]
diff --git a/tests/functional/m/member/member_checks_no_hints.rc b/tests/functional/m/member/member_checks_no_hints.rc
new file mode 100644
index 0000000..0f9c9ca
--- /dev/null
+++ b/tests/functional/m/member/member_checks_no_hints.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+missing-member-hint=no
diff --git a/tests/functional/m/member/member_checks_no_hints.txt b/tests/functional/m/member/member_checks_no_hints.txt
new file mode 100644
index 0000000..6d81864
--- /dev/null
+++ b/tests/functional/m/member/member_checks_no_hints.txt
@@ -0,0 +1,5 @@
+no-member:21:8:Child.__init__:Instance of 'Child' has no '_similar' member:INFERENCE
+no-member:22:8:Child.__init__:Instance of 'Child' has no '_really_similar' member:INFERENCE
+no-member:23:8:Child.__init__:Instance of 'Child' has no '_paren' member:INFERENCE
+no-member:25:8:Child.__init__:Instance of 'Child' has no '_registryyyy' member:INFERENCE
+no-member:27:8:Child.__init__:Instance of 'Child' has no '_pretty_sure_this_wont_match' member:INFERENCE
diff --git a/tests/functional/m/member/member_checks_opaque.py b/tests/functional/m/member/member_checks_opaque.py
new file mode 100644
index 0000000..9b592af
--- /dev/null
+++ b/tests/functional/m/member/member_checks_opaque.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,import-error
+
+from unknown import Unknown, some_value
+
+
+def test(argument):
+ if argument:
+ return 42
+ return Unknown
+
+
+test(some_value).test() # [no-member]
diff --git a/tests/functional/m/member/member_checks_opaque.rc b/tests/functional/m/member/member_checks_opaque.rc
new file mode 100644
index 0000000..025cd2a
--- /dev/null
+++ b/tests/functional/m/member/member_checks_opaque.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+ignore-on-opaque-inference=n
diff --git a/tests/functional/m/member/member_checks_opaque.txt b/tests/functional/m/member/member_checks_opaque.txt
new file mode 100644
index 0000000..2fabce4
--- /dev/null
+++ b/tests/functional/m/member/member_checks_opaque.txt
@@ -0,0 +1 @@
+no-member:12:0::Instance of 'int' has no 'test' member:INFERENCE
diff --git a/tests/functional/m/member/member_checks_py37.py b/tests/functional/m/member/member_checks_py37.py
new file mode 100644
index 0000000..ebbedbd
--- /dev/null
+++ b/tests/functional/m/member/member_checks_py37.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring
+import collections.abc
+import asyncio
+
+isinstance([], collections.abc.Iterable)
+
+
+async def gen():
+ await asyncio.sleep(0.1)
+ value = yield 42
+ print(value)
+ await asyncio.sleep(0.2)
+
+
+async def test():
+ generator = gen()
+
+ await generator.asend(None)
+ await generator.send(None) # [no-member]
diff --git a/tests/functional/m/member/member_checks_py37.rc b/tests/functional/m/member/member_checks_py37.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/m/member/member_checks_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/m/member/member_checks_py37.txt b/tests/functional/m/member/member_checks_py37.txt
new file mode 100644
index 0000000..c52eab1
--- /dev/null
+++ b/tests/functional/m/member/member_checks_py37.txt
@@ -0,0 +1 @@
+no-member:19:10:test:AsyncGenerator 'async_generator' has no 'send' member; maybe 'asend'?:INFERENCE
diff --git a/tests/functional/m/member/member_checks_typed_annotations.py b/tests/functional/m/member/member_checks_typed_annotations.py
new file mode 100644
index 0000000..90f775a
--- /dev/null
+++ b/tests/functional/m/member/member_checks_typed_annotations.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods
+class A:
+ myfield: int
+
+class B(A):
+ pass
+
+class C:
+ pass
+
+class D(C, B):
+ pass
+
+
+a = A()
+print(a.myfield)
+
+b = B()
+print(b.myfield)
+
+d = D()
+print(d.myfield)
+
+c = C()
+print(c.myfield) # [no-member]
diff --git a/tests/functional/m/member/member_checks_typed_annotations.txt b/tests/functional/m/member/member_checks_typed_annotations.txt
new file mode 100644
index 0000000..6261a31
--- /dev/null
+++ b/tests/functional/m/member/member_checks_typed_annotations.txt
@@ -0,0 +1 @@
+no-member:25:6::Instance of 'C' has no 'myfield' member:INFERENCE
diff --git a/tests/functional/m/member/membership_protocol.py b/tests/functional/m/member/membership_protocol.py
new file mode 100644
index 0000000..3401f4b
--- /dev/null
+++ b/tests/functional/m/member/membership_protocol.py
@@ -0,0 +1,123 @@
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,too-few-public-methods,import-error,no-init,wrong-import-position,no-else-return, comparison-with-itself, useless-object-inheritance
+
+# standard types
+1 in [1, 2, 3]
+1 in {'a': 1, 'b': 2}
+1 in {1, 2, 3}
+1 in (1, 2, 3)
+'1' in "123"
+'1' in u"123"
+'1' in bytearray(b"123")
+1 in frozenset([1, 2, 3])
+
+# comprehensions
+1 in [x ** 2 % 10 for x in range(10)]
+1 in {x ** 2 % 10 for x in range(10)}
+1 in {x: x ** 2 % 10 for x in range(10)}
+
+# iterators
+1 in iter([1, 2, 3])
+
+# generator
+def count(upto=float("inf")):
+ i = 0
+ while True:
+ if i > upto:
+ break
+ yield i
+ i += 1
+
+10 in count(upto=10)
+
+# custom instance
+class UniversalContainer(object):
+ def __contains__(self, key):
+ return True
+
+42 in UniversalContainer()
+
+# custom iterable
+class CustomIterable(object):
+ def __iter__(self):
+ return iter((1, 2, 3))
+3 in CustomIterable()
+
+# old-style iterable
+class OldStyleIterable(object):
+ def __getitem__(self, key):
+ if key < 10:
+ return 2 ** key
+ else:
+ raise IndexError("bad index")
+64 in OldStyleIterable()
+
+# do not emit warning if class has unknown bases
+from some_missing_module import ImportedClass
+
+class MaybeIterable(ImportedClass):
+ pass
+
+10 in MaybeIterable()
+
+# do not emit warning inside mixins/abstract/base classes
+class UsefulMixin(object):
+ stuff = None
+
+ def get_stuff(self):
+ return self.stuff
+
+ def act(self, thing):
+ stuff = self.get_stuff()
+ if thing in stuff:
+ pass
+
+class BaseThing(object):
+ valid_values = None
+
+ def validate(self, value):
+ if self.valid_values is None:
+ return True
+ else:
+ # error should not be emitted here
+ return value in self.valid_values
+
+class AbstractThing(object):
+ valid_values = None
+
+ def validate(self, value):
+ if self.valid_values is None:
+ return True
+ else:
+ # error should not be emitted here
+ return value in self.valid_values
+
+# class is not named as abstract
+# but still is deduceably abstract
+class Thing(object):
+ valid_values = None
+
+ def __init__(self):
+ self._init_values()
+
+ def validate(self, value):
+ if self.valid_values is None:
+ return True
+ else:
+ # error should not be emitted here
+ return value in self.valid_values
+
+ def _init_values(self):
+ raise NotImplementedError
+
+# error cases
+42 in 42 # [unsupported-membership-test]
+42 not in None # [unsupported-membership-test]
+42 in 8.5 # [unsupported-membership-test]
+
+class EmptyClass(object):
+ pass
+
+42 not in EmptyClass() # [unsupported-membership-test]
+42 in EmptyClass # [unsupported-membership-test]
+42 not in count # [unsupported-membership-test]
+42 in range # [unsupported-membership-test]
diff --git a/tests/functional/m/member/membership_protocol.txt b/tests/functional/m/member/membership_protocol.txt
new file mode 100644
index 0000000..e021062
--- /dev/null
+++ b/tests/functional/m/member/membership_protocol.txt
@@ -0,0 +1,7 @@
+unsupported-membership-test:113:6::Value '42' doesn't support membership test
+unsupported-membership-test:114:10::Value 'None' doesn't support membership test
+unsupported-membership-test:115:6::Value '8.5' doesn't support membership test
+unsupported-membership-test:120:10::Value 'EmptyClass()' doesn't support membership test
+unsupported-membership-test:121:6::Value 'EmptyClass' doesn't support membership test
+unsupported-membership-test:122:10::Value 'count' doesn't support membership test
+unsupported-membership-test:123:6::Value 'range' doesn't support membership test
diff --git a/tests/functional/m/member/membership_protocol_py3.py b/tests/functional/m/member/membership_protocol_py3.py
new file mode 100644
index 0000000..6780723
--- /dev/null
+++ b/tests/functional/m/member/membership_protocol_py3.py
@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-init,no-self-use,unused-argument,pointless-statement,expression-not-assigned
+
+# metaclasses that support membership test protocol
+class MetaIterable(type):
+ def __iter__(cls):
+ return iter((1, 2, 3))
+
+class MetaOldIterable(type):
+ def __getitem__(cls, key):
+ if key < 10:
+ return key ** 2
+
+ raise IndexError("bad index")
+
+class MetaContainer(type):
+ def __contains__(cls, key):
+ return False
+
+
+class IterableClass(metaclass=MetaOldIterable):
+ pass
+
+class OldIterableClass(metaclass=MetaOldIterable):
+ pass
+
+class ContainerClass(metaclass=MetaContainer):
+ pass
+
+
+def test():
+ 1 in IterableClass
+ 1 in OldIterableClass
+ 1 in ContainerClass
+ 1 in IterableClass() # [unsupported-membership-test]
+ 1 in OldIterableClass() # [unsupported-membership-test]
+ 1 in ContainerClass() # [unsupported-membership-test]
diff --git a/tests/functional/m/member/membership_protocol_py3.rc b/tests/functional/m/member/membership_protocol_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/m/member/membership_protocol_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/m/member/membership_protocol_py3.txt b/tests/functional/m/member/membership_protocol_py3.txt
new file mode 100644
index 0000000..495cf94
--- /dev/null
+++ b/tests/functional/m/member/membership_protocol_py3.txt
@@ -0,0 +1,3 @@
+unsupported-membership-test:34:9:test:Value 'IterableClass()' doesn't support membership test
+unsupported-membership-test:35:9:test:Value 'OldIterableClass()' doesn't support membership test
+unsupported-membership-test:36:9:test:Value 'ContainerClass()' doesn't support membership test
diff --git a/tests/functional/m/metaclass_attr_access.py b/tests/functional/m/metaclass_attr_access.py
new file mode 100644
index 0000000..e6bf1cc
--- /dev/null
+++ b/tests/functional/m/metaclass_attr_access.py
@@ -0,0 +1,20 @@
+# pylint: disable=too-few-public-methods, metaclass-assignment, useless-object-inheritance
+"""test attribute access on metaclass"""
+
+
+from __future__ import print_function
+
+class Meta(type):
+ """the meta class"""
+ def __init__(cls, name, bases, dictionary):
+ super(Meta, cls).__init__(name, bases, dictionary)
+ print(cls, cls._meta_args)
+ delattr(cls, '_meta_args')
+
+class Test(object):
+ """metaclassed class"""
+ __metaclass__ = Meta
+ _meta_args = ('foo', 'bar')
+
+ def __init__(self):
+ print('__init__', self)
diff --git a/tests/functional/m/method_hidden.py b/tests/functional/m/method_hidden.py
new file mode 100644
index 0000000..47031d8
--- /dev/null
+++ b/tests/functional/m/method_hidden.py
@@ -0,0 +1,92 @@
+# pylint: disable=too-few-public-methods,print-statement, useless-object-inheritance,missing-docstring
+"""check method hidding ancestor attribute
+"""
+from __future__ import print_function
+
+class Abcd(object):
+ """dummy"""
+ def __init__(self):
+ self.abcd = 1
+
+class Cdef(Abcd):
+ """dummy"""
+ def abcd(self): # [method-hidden]
+ """test
+ """
+ print(self)
+
+class AbcdMixin:
+ def abcd(self):
+ pass
+
+class Dabc(AbcdMixin, Abcd):
+ def abcd(self):
+ pass
+
+class CustomProperty:
+ """dummy"""
+ def __init__(self, _):
+ pass
+
+ def __get__(self, obj, __):
+ if not obj:
+ return self
+ return 5
+
+ def __set__(self, _, __):
+ pass
+
+class Ddef:
+ """dummy"""
+ def __init__(self):
+ self.five = "five"
+
+ @CustomProperty
+ def five(self):
+ """Always 5."""
+ return self
+
+
+def my_decorator(*args, **kwargs):
+ return CustomProperty(*args, **kwargs)
+
+
+class Foo:
+ def __init__(self):
+ self._bar = 42
+ self._baz = 84
+
+ @my_decorator
+ def method(self): # E0202
+ return self._baz
+
+ @method.setter
+ def method(self, value):
+ self._baz = value
+
+ def do_something_with_baz(self, value):
+ self.method = value
+
+
+class One:
+ def __init__(self, one=None):
+ if one is not None:
+ self.one = one
+
+ def one(self): # [method-hidden]
+ pass
+
+class Two(One):
+ def one(self):
+ pass
+
+try:
+ import unknown as js
+except ImportError:
+ import json as js
+
+
+class JsonEncoder(js.JSONEncoder):
+ # pylint: disable=useless-super-delegation,super-with-arguments
+ def default(self, o):
+ return super(JsonEncoder, self).default(o)
diff --git a/tests/functional/m/method_hidden.txt b/tests/functional/m/method_hidden.txt
new file mode 100644
index 0000000..a15bf30
--- /dev/null
+++ b/tests/functional/m/method_hidden.txt
@@ -0,0 +1,2 @@
+method-hidden:13:4:Cdef.abcd:An attribute defined in functional.m.method_hidden line 9 hides this method
+method-hidden:76:4:One.one:An attribute defined in functional.m.method_hidden line 74 hides this method
diff --git a/tests/functional/m/misplaced_bare_raise.py b/tests/functional/m/misplaced_bare_raise.py
new file mode 100644
index 0000000..6148733
--- /dev/null
+++ b/tests/functional/m/misplaced_bare_raise.py
@@ -0,0 +1,85 @@
+# pylint: disable=missing-docstring, broad-except, unreachable, try-except-raise, raise-missing-from
+# pylint: disable=unused-variable, too-few-public-methods, invalid-name, useless-object-inheritance
+
+try:
+ raise # [misplaced-bare-raise]
+except Exception:
+ pass
+
+try:
+ pass
+except Exception:
+ raise
+
+# pylint: disable=misplaced-comparison-constant
+try:
+ pass
+except Exception:
+ if 1 == 2:
+ raise
+
+def test():
+ try:
+ pass
+ except Exception:
+ def chest():
+ try:
+ pass
+ except Exception:
+ raise
+ raise
+
+def test1():
+ try:
+ if 1 > 2:
+ def best():
+ raise # [misplaced-bare-raise]
+ except Exception:
+ pass
+ raise # [misplaced-bare-raise]
+raise # [misplaced-bare-raise]
+
+try:
+ pass
+finally:
+ # This might work or might not to, depending if there's
+ # an error raised inside the try block. But relying on this
+ # behaviour can be error prone, so we decided to warn
+ # against it.
+ raise # [misplaced-bare-raise]
+
+
+class A(object):
+ try:
+ pass
+ except Exception:
+ raise
+ raise # [misplaced-bare-raise]
+
+# This works in Python 2, but the intent is nevertheless
+# unclear. It will also not work on Python 3, so it's best
+# not to rely on it.
+exc = None
+try:
+ 1/0
+except ZeroDivisionError as exc:
+ pass
+if exc:
+ raise # [misplaced-bare-raise]
+
+# Don't emit if we're in ``__exit__``.
+class ContextManager(object):
+ def __enter__(self):
+ return self
+ def __exit__(self, *args):
+ raise
+
+
+def test_dont_trigger_in_finally_clause_found_in_exception_handler():
+ try:
+ raise ValueError('bad value')
+ except ValueError:
+ try:
+ raise IOError('failed')
+ finally:
+ raise
diff --git a/tests/functional/m/misplaced_bare_raise.txt b/tests/functional/m/misplaced_bare_raise.txt
new file mode 100644
index 0000000..38e04f9
--- /dev/null
+++ b/tests/functional/m/misplaced_bare_raise.txt
@@ -0,0 +1,7 @@
+misplaced-bare-raise:5:4::The raise statement is not inside an except clause
+misplaced-bare-raise:36:16:test1.best:The raise statement is not inside an except clause
+misplaced-bare-raise:39:4:test1:The raise statement is not inside an except clause
+misplaced-bare-raise:40:0::The raise statement is not inside an except clause
+misplaced-bare-raise:49:4::The raise statement is not inside an except clause
+misplaced-bare-raise:57:4:A:The raise statement is not inside an except clause
+misplaced-bare-raise:68:4::The raise statement is not inside an except clause
diff --git a/tests/functional/m/misplaced_comparison_constant.py b/tests/functional/m/misplaced_comparison_constant.py
new file mode 100644
index 0000000..29f2b1e
--- /dev/null
+++ b/tests/functional/m/misplaced_comparison_constant.py
@@ -0,0 +1,36 @@
+"""Check that the constants are on the right side of the comparisons"""
+
+# pylint: disable=singleton-comparison, missing-docstring, too-few-public-methods, useless-object-inheritance
+
+class MyClass(object):
+ def __init__(self):
+ self.attr = 1
+
+ def dummy_return(self):
+ return self.attr
+
+def dummy_return():
+ return 2
+
+def bad_comparisons():
+ """this is not ok"""
+ instance = MyClass()
+ for i in range(10):
+ if 5 <= i: # [misplaced-comparison-constant]
+ pass
+ if 1 == i: # [misplaced-comparison-constant]
+ pass
+ if 3 < dummy_return(): # [misplaced-comparison-constant]
+ pass
+ if 4 != instance.dummy_return(): # [misplaced-comparison-constant]
+ pass
+ if 1 == instance.attr: # [misplaced-comparison-constant]
+ pass
+ if "aaa" == instance.attr: # [misplaced-comparison-constant]
+ pass
+
+def good_comparison():
+ """this is ok"""
+ for i in range(10):
+ if i == 5:
+ pass
diff --git a/tests/functional/m/misplaced_comparison_constant.txt b/tests/functional/m/misplaced_comparison_constant.txt
new file mode 100644
index 0000000..b517b49
--- /dev/null
+++ b/tests/functional/m/misplaced_comparison_constant.txt
@@ -0,0 +1,6 @@
+misplaced-comparison-constant:19:11:bad_comparisons:Comparison should be i >= 5
+misplaced-comparison-constant:21:11:bad_comparisons:Comparison should be i == 1
+misplaced-comparison-constant:23:11:bad_comparisons:Comparison should be dummy_return() > 3
+misplaced-comparison-constant:25:11:bad_comparisons:Comparison should be instance.dummy_return() != 4
+misplaced-comparison-constant:27:11:bad_comparisons:Comparison should be instance.attr == 1
+misplaced-comparison-constant:29:11:bad_comparisons:Comparison should be instance.attr == 'aaa'
diff --git a/tests/functional/m/misplaced_format_function.py b/tests/functional/m/misplaced_format_function.py
new file mode 100644
index 0000000..7bcabfc
--- /dev/null
+++ b/tests/functional/m/misplaced_format_function.py
@@ -0,0 +1,58 @@
+"""Test that format function is used only with string."""
+
+# pylint: disable=invalid-name, pointless-string-statement, line-too-long, no-member, disallowed-name, undefined-variable, missing-docstring, too-few-public-methods
+
+print('value: {}').format(123) # [misplaced-format-function]
+print("value: {}").format(123) # [misplaced-format-function]
+print('value: {}'.format(123))
+print('{} Come Forth!'.format('Lazarus'))
+print('Der Hem ist mein Licht und mein Heil, vor wem sollte ich mich furchten? => {}'.format('Psalm 27, 1'))
+print('123')
+print()
+s = 'value: {}'.format(123)
+a = 'value: {}'
+a.format(123)
+
+def foo(arg):
+ """The World is Yours"""
+ return arg.format(123) # we don't know if arg is str or not, don't raise error.
+
+def goo(arg):
+ """The World is Yours"""
+ TextWriter.format(arg)
+
+def bar(arg, TextWriter):
+ """The World is Yours"""
+ TextWriter().format(arg)
+
+def foobar(arg, TextWriter):
+ """The World is Yours"""
+ TextWriter.format(arg)
+
+def barfoo(arg):
+ """The World is Yours"""
+ TextWriter().format(arg)
+
+def _display(self, layout):
+ """launch layouts display"""
+ print(file=self.out)
+ TextWriter().format(layout, self.out)
+
+
+class FakeClass:
+ def __init__(self, string):
+ self.string = string
+
+ def get_string(self):
+ return self.string
+
+ def format_string(self):
+ self.string.format()
+ self.get_string().format()
+ print(self.get_string()).format() # [misplaced-format-function]
+ print(self.get_string().format())
+
+obj = FakeClass('Voila!!!')
+obj.get_string().format()
+print(obj.get_string().format())
+print(obj.get_string()).format() # [misplaced-format-function]
diff --git a/tests/functional/m/misplaced_format_function.txt b/tests/functional/m/misplaced_format_function.txt
new file mode 100644
index 0000000..2a77a27
--- /dev/null
+++ b/tests/functional/m/misplaced_format_function.txt
@@ -0,0 +1,4 @@
+misplaced-format-function:5:0::format function is not called on str
+misplaced-format-function:6:0::format function is not called on str
+misplaced-format-function:52:8:FakeClass.format_string:format function is not called on str
+misplaced-format-function:58:0::format function is not called on str
diff --git a/tests/functional/m/misplaced_future.py b/tests/functional/m/misplaced_future.py
new file mode 100644
index 0000000..b4317d9
--- /dev/null
+++ b/tests/functional/m/misplaced_future.py
@@ -0,0 +1,6 @@
+"""Test that __future__ is not the first statement after the docstring."""
+import collections
+from __future__ import print_function # [misplaced-future]
+from __future__ import with_statement
+
+DATA = collections
diff --git a/tests/functional/m/misplaced_future.txt b/tests/functional/m/misplaced_future.txt
new file mode 100644
index 0000000..645618b
--- /dev/null
+++ b/tests/functional/m/misplaced_future.txt
@@ -0,0 +1 @@
+misplaced-future:3:0::__future__ import is not the first non docstring statement
diff --git a/tests/functional/m/missing/missing_docstring.py b/tests/functional/m/missing/missing_docstring.py
new file mode 100644
index 0000000..72d6762
--- /dev/null
+++ b/tests/functional/m/missing/missing_docstring.py
@@ -0,0 +1,58 @@
+# [missing-module-docstring]
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+
+def public_documented():
+ """It has a docstring."""
+
+
+def _private_undocumented():
+ # Doesn't need a docstring
+ pass
+
+
+def _private_documented():
+ """It has a docstring."""
+
+
+class ClassDocumented(object):
+ """It has a docstring."""
+
+
+class ClassUndocumented(object): # [missing-class-docstring]
+ pass
+
+
+def public_undocumented(): # [missing-function-docstring]
+ pass
+
+
+def __sizeof__():
+ # Special
+ pass
+
+
+def __mangled():
+ pass
+
+
+class Property(object):
+ """Don't warn about setters and deleters."""
+
+ def __init__(self):
+ self._value = None
+
+ @property
+ def test(self):
+ """Default docstring for setters and deleters."""
+
+ @test.setter
+ def test(self, value):
+ self._value = value
+
+ @test.deleter
+ def test(self):
+ pass
+
+
+class DocumentedViaDunderDoc(object):
+ __doc__ = "This one"
diff --git a/tests/functional/m/missing/missing_docstring.txt b/tests/functional/m/missing/missing_docstring.txt
new file mode 100644
index 0000000..c9ec521
--- /dev/null
+++ b/tests/functional/m/missing/missing_docstring.txt
@@ -0,0 +1,3 @@
+missing-module-docstring:1:0::Missing module docstring
+missing-class-docstring:21:0:ClassUndocumented:Missing class docstring
+missing-function-docstring:25:0:public_undocumented:Missing function or method docstring
diff --git a/tests/functional/m/missing/missing_docstring_new_style.py b/tests/functional/m/missing/missing_docstring_new_style.py
new file mode 100644
index 0000000..58c7c1e
--- /dev/null
+++ b/tests/functional/m/missing/missing_docstring_new_style.py
@@ -0,0 +1,47 @@
+# [missing-module-docstring]
+# pylint: disable=too-few-public-methods
+
+
+class ClassDocumented:
+ """It has a docstring."""
+
+
+class UndocumentedClass: # [missing-class-docstring]
+ pass
+
+
+# pylint: disable=missing-class-docstring
+class ClassUndocumented:
+ pass
+
+
+# pylint: enable=missing-class-docstring
+class OtherClassUndocumented: # [missing-class-docstring]
+ pass
+
+
+def public_documented():
+ """It has a docstring."""
+
+
+def _private_undocumented():
+ # Doesn't need a docstring
+ pass
+
+
+def _private_documented():
+ """It has a docstring."""
+
+
+def public_undocumented(): # [missing-function-docstring]
+ pass
+
+
+# pylint: disable=missing-function-docstring
+def undocumented_function():
+ pass
+
+
+# pylint: enable=missing-function-docstring
+def undocumented_other_function(): # [missing-function-docstring]
+ pass
diff --git a/tests/functional/m/missing/missing_docstring_new_style.txt b/tests/functional/m/missing/missing_docstring_new_style.txt
new file mode 100644
index 0000000..f194673
--- /dev/null
+++ b/tests/functional/m/missing/missing_docstring_new_style.txt
@@ -0,0 +1,5 @@
+missing-module-docstring:1:0::Missing module docstring
+missing-class-docstring:9:0:UndocumentedClass:Missing class docstring
+missing-class-docstring:19:0:OtherClassUndocumented:Missing class docstring
+missing-function-docstring:36:0:public_undocumented:Missing function or method docstring
+missing-function-docstring:46:0:undocumented_other_function:Missing function or method docstring
diff --git a/tests/functional/m/missing/missing_final_newline.py b/tests/functional/m/missing/missing_final_newline.py
new file mode 100644
index 0000000..370f902
--- /dev/null
+++ b/tests/functional/m/missing/missing_final_newline.py
@@ -0,0 +1,4 @@
+"""This file does not have a final newline."""
+from __future__ import print_function
+# +1:[missing-final-newline]
+print(1)
\ No newline at end of file
diff --git a/tests/functional/m/missing/missing_final_newline.txt b/tests/functional/m/missing/missing_final_newline.txt
new file mode 100644
index 0000000..d7c329b
--- /dev/null
+++ b/tests/functional/m/missing/missing_final_newline.txt
@@ -0,0 +1 @@
+missing-final-newline:4:0::Final newline missing
diff --git a/tests/functional/m/missing/missing_kwoa_py3.py b/tests/functional/m/missing/missing_kwoa_py3.py
new file mode 100644
index 0000000..b4dc604
--- /dev/null
+++ b/tests/functional/m/missing/missing_kwoa_py3.py
@@ -0,0 +1,73 @@
+# pylint: disable=missing-docstring,unused-argument,too-few-public-methods
+import typing
+
+
+def target(pos, *, keyword):
+ return pos + keyword
+
+
+def forwarding_kwds(pos, **kwds):
+ target(pos, **kwds)
+
+
+def forwarding_args(*args, keyword):
+ target(*args, keyword=keyword)
+
+def forwarding_conversion(*args, **kwargs):
+ target(*args, **dict(kwargs))
+
+
+def not_forwarding_kwargs(*args, **kwargs):
+ target(*args) # [missing-kwoa]
+
+
+target(1, keyword=2)
+
+PARAM = 1
+target(2, PARAM) # [too-many-function-args, missing-kwoa]
+
+
+def some_function(*, param):
+ return param + 2
+
+
+def other_function(**kwargs):
+ return some_function(**kwargs) # Does not trigger missing-kwoa
+
+
+other_function(param=2)
+
+
+class Parent:
+
+ @typing.overload
+ def __init__( self, *, first, second, third):
+ pass
+
+ @typing.overload
+ def __init__(self, *, first, second):
+ pass
+
+ @typing.overload
+ def __init__(self, *, first):
+ pass
+
+ def __init__(
+ self,
+ *,
+ first,
+ second: typing.Optional[str] = None,
+ third: typing.Optional[str] = None):
+ self._first = first
+ self._second = second
+ self._third = third
+
+
+class Child(Parent):
+ def __init__(
+ self,
+ *,
+ first,
+ second):
+ super().__init__(first=first, second=second)
+ self._first = first + second
diff --git a/tests/functional/m/missing/missing_kwoa_py3.rc b/tests/functional/m/missing/missing_kwoa_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/m/missing/missing_kwoa_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/m/missing/missing_kwoa_py3.txt b/tests/functional/m/missing/missing_kwoa_py3.txt
new file mode 100644
index 0000000..7106355
--- /dev/null
+++ b/tests/functional/m/missing/missing_kwoa_py3.txt
@@ -0,0 +1,3 @@
+missing-kwoa:21:4:not_forwarding_kwargs:Missing mandatory keyword argument 'keyword' in function call
+missing-kwoa:27:0::Missing mandatory keyword argument 'keyword' in function call
+too-many-function-args:27:0::Too many positional arguments for function call
diff --git a/tests/functional/m/missing/missing_module_docstring_disabled.py b/tests/functional/m/missing/missing_module_docstring_disabled.py
new file mode 100644
index 0000000..d4d9edf
--- /dev/null
+++ b/tests/functional/m/missing/missing_module_docstring_disabled.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-module-docstring, too-few-public-methods
+
+
+class Documented:
+ "Something."
diff --git a/tests/functional/m/missing/missing_parentheses_for_call_in_test.py b/tests/functional/m/missing/missing_parentheses_for_call_in_test.py
new file mode 100644
index 0000000..cd1d76a
--- /dev/null
+++ b/tests/functional/m/missing/missing_parentheses_for_call_in_test.py
@@ -0,0 +1,95 @@
+"""Verify if call to function or method inside tests are missing parentheses."""
+# pylint: disable=using-constant-test, missing-docstring, useless-object-inheritance
+# pylint: disable=invalid-name, expression-not-assigned
+
+import collections
+
+
+def bool_function():
+ return True
+
+def nonbool_function():
+ return 42
+
+
+class Class(object):
+
+ @staticmethod
+ def bool_method():
+ return False
+
+ @staticmethod
+ def nonbool_method():
+ return 42
+
+
+if collections:
+ pass
+
+if bool_function: # [missing-parentheses-for-call-in-test]
+ pass
+
+if not bool_function():
+ pass
+
+if nonbool_function: # [missing-parentheses-for-call-in-test]
+ pass
+
+if nonbool_function() != 42:
+ pass
+
+instance = Class()
+
+if instance.bool_method: # [missing-parentheses-for-call-in-test]
+ pass
+
+if not instance.bool_method():
+ pass
+
+if not instance.nonbool_method:
+ pass
+elif instance.bool_method: # [missing-parentheses-for-call-in-test]
+ pass
+
+bool_lambda = lambda: True
+
+if bool_lambda: # [missing-parentheses-for-call-in-test]
+ pass
+
+if not bool_lambda():
+ pass
+
+nonbool_lambda = lambda: 42
+
+if nonbool_lambda: # [missing-parentheses-for-call-in-test]
+ pass
+
+if not nonbool_lambda():
+ pass
+
+MY_VALUE = 42 if bool_function else -1 # [missing-parentheses-for-call-in-test]
+MY_2ND_VALUE = 42 if not bool_function() else -1
+MY_THIRD_VALUE = 42 if bool_lambda else -1 # [missing-parentheses-for-call-in-test]
+MY_FOURTH_VALUE = 42 if nonbool_lambda else -1 # [missing-parentheses-for-call-in-test]
+
+[x for x in range(100) if bool_function] # [missing-parentheses-for-call-in-test]
+[x for x in range(100) if bool_lambda] # [missing-parentheses-for-call-in-test]
+[x for x in range(100) if not bool_function()]
+[x for x in range(100) if not bool_lambda()]
+[x for x in range(100) if nonbool_lambda] # [missing-parentheses-for-call-in-test]
+[x for x in range(100) if nonbool_function] # [missing-parentheses-for-call-in-test]
+
+def non_const_node_function():
+ return (1, 2, 42)
+
+if non_const_node_function: # [missing-parentheses-for-call-in-test]
+ pass
+
+def yielding_function():
+ yield 42
+
+if yielding_function: # [missing-parentheses-for-call-in-test]
+ pass
+
+if not yielding_function():
+ pass
diff --git a/tests/functional/m/missing/missing_parentheses_for_call_in_test.txt b/tests/functional/m/missing/missing_parentheses_for_call_in_test.txt
new file mode 100644
index 0000000..0547c6e
--- /dev/null
+++ b/tests/functional/m/missing/missing_parentheses_for_call_in_test.txt
@@ -0,0 +1,15 @@
+missing-parentheses-for-call-in-test:29:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:35:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:43:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:51:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:56:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:64:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:70:11::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:72:17::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:73:18::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:75:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:76:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:79:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:80:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:85:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:91:0::Using a conditional statement with potentially wrong function or method call due to missing parentheses
diff --git a/tests/functional/m/missing/missing_self_argument.py b/tests/functional/m/missing/missing_self_argument.py
new file mode 100644
index 0000000..79ae348
--- /dev/null
+++ b/tests/functional/m/missing/missing_self_argument.py
@@ -0,0 +1,21 @@
+"""Checks that missing self in method defs don't crash Pylint."""
+# pylint: disable=useless-object-inheritance
+
+
+
+class MyClass(object):
+ """A class with some methods missing self args."""
+
+ def __init__(self):
+ self.var = "var"
+
+ def method(): # [no-method-argument]
+ """A method without a self argument."""
+
+ def setup(): # [no-method-argument]
+ """A method without a self argument, but usage."""
+ self.var = 1 # [undefined-variable]
+
+ def correct(self):
+ """Correct."""
+ self.var = "correct"
diff --git a/tests/functional/m/missing/missing_self_argument.txt b/tests/functional/m/missing/missing_self_argument.txt
new file mode 100644
index 0000000..1b76262
--- /dev/null
+++ b/tests/functional/m/missing/missing_self_argument.txt
@@ -0,0 +1,3 @@
+no-method-argument:12:4:MyClass.method:Method has no argument
+no-method-argument:15:4:MyClass.setup:Method has no argument
+undefined-variable:17:8:MyClass.setup:Undefined variable 'self'
diff --git a/tests/functional/m/module___dict__.py b/tests/functional/m/module___dict__.py
new file mode 100644
index 0000000..8b2154c
--- /dev/null
+++ b/tests/functional/m/module___dict__.py
@@ -0,0 +1,9 @@
+"""https://www.logilab.org/ticket/6949."""
+from __future__ import print_function
+__revision__ = None
+
+print(__dict__ is not None) # [used-before-assignment]
+
+__dict__ = {}
+
+print(__dict__ is not None)
diff --git a/tests/functional/m/module___dict__.txt b/tests/functional/m/module___dict__.txt
new file mode 100644
index 0000000..c5b65ad
--- /dev/null
+++ b/tests/functional/m/module___dict__.txt
@@ -0,0 +1 @@
+used-before-assignment:5:6::Using variable '__dict__' before assignment
diff --git a/tests/functional/m/monkeypatch_method.py b/tests/functional/m/monkeypatch_method.py
new file mode 100644
index 0000000..e8bd03a
--- /dev/null
+++ b/tests/functional/m/monkeypatch_method.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring,too-few-public-methods, useless-object-inheritance
+'''Test that a function is considered a method when looked up through a class.'''
+
+class Clazz(object):
+ 'test class'
+
+ def __init__(self, value):
+ self.value = value
+
+def func(arg1, arg2):
+ 'function that will be used as a method'
+ return arg1.value + arg2
+
+Clazz.method = func
+
+VAR = Clazz(1).method(2)
diff --git a/tests/functional/m/multiple_imports.py b/tests/functional/m/multiple_imports.py
new file mode 100644
index 0000000..9008dcc
--- /dev/null
+++ b/tests/functional/m/multiple_imports.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring, unused-import
+import os, socket # [multiple-imports]
diff --git a/tests/functional/m/multiple_imports.txt b/tests/functional/m/multiple_imports.txt
new file mode 100644
index 0000000..45380c3
--- /dev/null
+++ b/tests/functional/m/multiple_imports.txt
@@ -0,0 +1 @@
+multiple-imports:2:0::Multiple imports on one line (os, socket)
diff --git a/tests/functional/n/__init__.py b/tests/functional/n/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/n/__init__.py
diff --git a/tests/functional/n/name/namePresetCamelCase.py b/tests/functional/n/name/namePresetCamelCase.py
new file mode 100644
index 0000000..e048ec4
--- /dev/null
+++ b/tests/functional/n/name/namePresetCamelCase.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+__version__ = "1.0"
+SOME_CONSTANT = 42 # [invalid-name]
+
+
+def sayHello(someArgument):
+ return [someArgument * someValue for someValue in range(10)]
+
+
+class MyClass: # [invalid-name]
+ def __init__(self, argX):
+ self._mySecretX = argX
+
+ @property
+ def myPublicX(self):
+ return self._mySecretX * 2
+
+ def __eq__(self, other):
+ return isinstance(other, MyClass) and self.myPublicX == other.myPublicX
+
+
+def say_hello(): # [invalid-name]
+ pass
diff --git a/tests/functional/n/name/namePresetCamelCase.rc b/tests/functional/n/name/namePresetCamelCase.rc
new file mode 100644
index 0000000..29f4450
--- /dev/null
+++ b/tests/functional/n/name/namePresetCamelCase.rc
@@ -0,0 +1,13 @@
+[BASIC]
+function-naming-style=camelCase
+const-naming-style=camelCase
+attr-naming-style=camelCase
+argument-naming-style=camelCase
+module-naming-style=camelCase
+method-naming-style=camelCase
+variable-naming-style=camelCase
+class-attribute-naming-style=camelCase
+inlinevar-naming-style=camelCase
+class-naming-style=camelCase
+
+include-naming-hint=yes
diff --git a/tests/functional/n/name/namePresetCamelCase.txt b/tests/functional/n/name/namePresetCamelCase.txt
new file mode 100644
index 0000000..b24b0a8
--- /dev/null
+++ b/tests/functional/n/name/namePresetCamelCase.txt
@@ -0,0 +1,3 @@
+invalid-name:3:0::"Constant name ""SOME_CONSTANT"" doesn't conform to camelCase naming style ('([^\\W\\dA-Z][^\\W_]*|__.*__)$' pattern)"
+invalid-name:10:0:MyClass:"Class name ""MyClass"" doesn't conform to camelCase naming style ('[^\\W\\dA-Z][^\\W_]+$' pattern)"
+invalid-name:22:0:say_hello:"Function name ""say_hello"" doesn't conform to camelCase naming style ('([^\\W\\dA-Z][^\\W_]{2,}|__[^\\W\\dA-Z_]\\w+__)$' pattern)"
diff --git a/tests/functional/n/name/name_final.py b/tests/functional/n/name/name_final.py
new file mode 100644
index 0000000..60b92ce
--- /dev/null
+++ b/tests/functional/n/name/name_final.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+"""Test typing.Final"""
+import typing
+from typing import Final
+
+class Foo:
+ """Class with class constants annotated with Final."""
+ CLASS_CONST: Final[int] = 42
+ CLASS_CONST2: Final = "const"
+ variable: Final[str] = "invalid name" # [invalid-name]
+ CLASS_CONST3: typing.Final
+ variable2: typing.Final[int] # [invalid-name]
+ CLASS_CONST4: Final[typing.ClassVar[str]] = "valid"
+
+MODULE_CONST: Final = 1
+module_var: typing.Final[str] = "const" # [invalid-name]
diff --git a/tests/functional/n/name/name_final.rc b/tests/functional/n/name/name_final.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/n/name/name_final.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/n/name/name_final.txt b/tests/functional/n/name/name_final.txt
new file mode 100644
index 0000000..b9fdd20
--- /dev/null
+++ b/tests/functional/n/name/name_final.txt
@@ -0,0 +1,3 @@
+invalid-name:10:4:Foo:"Class constant name ""variable"" doesn't conform to UPPER_CASE naming style"
+invalid-name:12:4:Foo:"Class constant name ""variable2"" doesn't conform to UPPER_CASE naming style"
+invalid-name:16:0::"Constant name ""module_var"" doesn't conform to UPPER_CASE naming style"
diff --git a/tests/functional/n/name/name_final_snake_case.py b/tests/functional/n/name/name_final_snake_case.py
new file mode 100644
index 0000000..ddfc353
--- /dev/null
+++ b/tests/functional/n/name/name_final_snake_case.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+"""Test typing.Final with name style snake_case."""
+import typing
+from typing import Final
+
+class Foo:
+ """Class with class constants annotated with Final."""
+ CLASS_CONST: Final[int] = 42 # [invalid-name]
+ CLASS_CONST2: Final = "const" # [invalid-name]
+ variable: Final[str] = "invalid name"
+ CLASS_CONST3: typing.Final # [invalid-name]
+ variable2: typing.Final[int]
+ CLASS_CONST4: Final[typing.ClassVar[str]] = "invalid name" # [invalid-name]
+
+MODULE_CONST: Final = 1 # [invalid-name]
+module_var: typing.Final[str] = "const"
diff --git a/tests/functional/n/name/name_final_snake_case.rc b/tests/functional/n/name/name_final_snake_case.rc
new file mode 100644
index 0000000..43700a6
--- /dev/null
+++ b/tests/functional/n/name/name_final_snake_case.rc
@@ -0,0 +1,6 @@
+[testoptions]
+min_pyver=3.8
+
+[BASIC]
+class-const-naming-style=snake_case
+const-naming-style=snake_case
diff --git a/tests/functional/n/name/name_final_snake_case.txt b/tests/functional/n/name/name_final_snake_case.txt
new file mode 100644
index 0000000..48f03d1
--- /dev/null
+++ b/tests/functional/n/name/name_final_snake_case.txt
@@ -0,0 +1,5 @@
+invalid-name:8:4:Foo:"Class constant name ""CLASS_CONST"" doesn't conform to snake_case naming style"
+invalid-name:9:4:Foo:"Class constant name ""CLASS_CONST2"" doesn't conform to snake_case naming style"
+invalid-name:11:4:Foo:"Class constant name ""CLASS_CONST3"" doesn't conform to snake_case naming style"
+invalid-name:13:4:Foo:"Class constant name ""CLASS_CONST4"" doesn't conform to snake_case naming style"
+invalid-name:15:0::"Constant name ""MODULE_CONST"" doesn't conform to snake_case naming style"
diff --git a/tests/functional/n/name/name_good_bad_names_regex.py b/tests/functional/n/name/name_good_bad_names_regex.py
new file mode 100644
index 0000000..75208c1
--- /dev/null
+++ b/tests/functional/n/name/name_good_bad_names_regex.py
@@ -0,0 +1,20 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+__version__ = "1.0"
+ignored_SOME_CONSTANT = 42
+
+explicit_bad_some_constant = 42 # [disallowed-name]
+
+snake_case_bad_SOME_CONSTANT = 42 # [invalid-name]
+
+
+class my_class:
+ def __init__(self, arg_x):
+ self._my_secret_x = arg_x
+
+ @property
+ def my_public_x(self):
+ return self._my_secret_x * 2
+
+
+def disallowed_2_snake_case(): # [disallowed-name]
+ pass
diff --git a/tests/functional/n/name/name_good_bad_names_regex.rc b/tests/functional/n/name/name_good_bad_names_regex.rc
new file mode 100644
index 0000000..abb08ce
--- /dev/null
+++ b/tests/functional/n/name/name_good_bad_names_regex.rc
@@ -0,0 +1,15 @@
+[BASIC]
+function-naming-style=snake_case
+const-naming-style=snake_case
+attr-naming-style=snake_case
+argument-naming-style=snake_case
+module-naming-style=snake_case
+method-naming-style=snake_case
+variable-naming-style=snake_case
+class-attribute-naming-style=snake_case
+inlinevar-naming-style=snake_case
+class-naming-style=snake_case
+
+good-names-rgxs=ignored.*
+bad-names-rgxs=explicit.*,disallowed.*
+include-naming-hint=yes
diff --git a/tests/functional/n/name/name_good_bad_names_regex.txt b/tests/functional/n/name/name_good_bad_names_regex.txt
new file mode 100644
index 0000000..537c429
--- /dev/null
+++ b/tests/functional/n/name/name_good_bad_names_regex.txt
@@ -0,0 +1,3 @@
+disallowed-name:5:0::Disallowed name "explicit_bad_some_constant"
+invalid-name:7:0::"Constant name ""snake_case_bad_SOME_CONSTANT"" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]*|__.*__)$' pattern)"
+disallowed-name:19:0:disallowed_2_snake_case:Disallowed name "disallowed_2_snake_case"
diff --git a/tests/functional/n/name/name_preset_snake_case.py b/tests/functional/n/name/name_preset_snake_case.py
new file mode 100644
index 0000000..7535049
--- /dev/null
+++ b/tests/functional/n/name/name_preset_snake_case.py
@@ -0,0 +1,35 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+from enum import Enum
+from typing import ClassVar
+
+__version__ = "1.0"
+SOME_CONSTANT = 42 # [invalid-name]
+
+
+def say_hello(some_argument):
+ return [some_argument * some_value for some_value in range(10)]
+
+
+class MyClass: # [invalid-name]
+ def __init__(self, arg_x):
+ self._my_secret_x = arg_x
+
+ @property
+ def my_public_x(self):
+ return self._my_secret_x * 2
+
+ def __eq__(self, other):
+ return isinstance(other, MyClass) and self.my_public_x == other.my_public_x
+
+
+def sayHello(): # [invalid-name]
+ pass
+
+
+class FooEnum(Enum): # [invalid-name]
+ const_with_snake_case = 42
+ another_const = 43
+
+
+class Bar: # [invalid-name]
+ const_with_snake_case: ClassVar[int] = 42
diff --git a/tests/functional/n/name/name_preset_snake_case.rc b/tests/functional/n/name/name_preset_snake_case.rc
new file mode 100644
index 0000000..2b04af5
--- /dev/null
+++ b/tests/functional/n/name/name_preset_snake_case.rc
@@ -0,0 +1,14 @@
+[BASIC]
+function-naming-style=snake_case
+const-naming-style=snake_case
+attr-naming-style=snake_case
+argument-naming-style=snake_case
+module-naming-style=snake_case
+method-naming-style=snake_case
+variable-naming-style=snake_case
+class-attribute-naming-style=snake_case
+class-const-naming-style=snake_case
+inlinevar-naming-style=snake_case
+class-naming-style=snake_case
+
+include-naming-hint=yes
diff --git a/tests/functional/n/name/name_preset_snake_case.txt b/tests/functional/n/name/name_preset_snake_case.txt
new file mode 100644
index 0000000..c189797
--- /dev/null
+++ b/tests/functional/n/name/name_preset_snake_case.txt
@@ -0,0 +1,5 @@
+invalid-name:6:0::"Constant name ""SOME_CONSTANT"" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]*|__.*__)$' pattern)"
+invalid-name:13:0:MyClass:"Class name ""MyClass"" doesn't conform to snake_case naming style ('[^\\W\\dA-Z][^\\WA-Z]+$' pattern)"
+invalid-name:25:0:sayHello:"Function name ""sayHello"" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]{2,}|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)"
+invalid-name:29:0:FooEnum:"Class name ""FooEnum"" doesn't conform to snake_case naming style ('[^\\W\\dA-Z][^\\WA-Z]+$' pattern)"
+invalid-name:34:0:Bar:"Class name ""Bar"" doesn't conform to snake_case naming style ('[^\\W\\dA-Z][^\\WA-Z]+$' pattern)"
diff --git a/tests/functional/n/name/name_styles.py b/tests/functional/n/name/name_styles.py
new file mode 100644
index 0000000..a9d7435
--- /dev/null
+++ b/tests/functional/n/name/name_styles.py
@@ -0,0 +1,160 @@
+"""Test for the invalid-name warning."""
+# pylint: disable=no-absolute-import, useless-object-inheritance, unnecessary-pass, unnecessary-comprehension, unused-private-member
+from __future__ import print_function
+import abc
+import collections
+import typing
+from enum import Enum
+from typing import ClassVar
+
+GOOD_CONST_NAME = ''
+bad_const_name = 0 # [invalid-name]
+
+
+def BADFUNCTION_name(): # [invalid-name]
+ """Bad function name."""
+ BAD_LOCAL_VAR = 1 # [invalid-name]
+ print(BAD_LOCAL_VAR)
+
+
+def func_bad_argname(NOT_GOOD): # [invalid-name]
+ """Function with a badly named argument."""
+ return NOT_GOOD
+
+
+def no_nested_args(arg1, arg21, arg22):
+ """Well-formed function."""
+ print(arg1, arg21, arg22)
+
+
+class bad_class_name(object): # [invalid-name]
+ """Class with a bad name."""
+
+
+class CorrectClassName(object):
+ """Class with a good name."""
+
+ def __init__(self):
+ self._good_private_name = 10
+ self.__good_real_private_name = 11
+ self.good_attribute_name = 12
+ self._Bad_AtTR_name = None # [invalid-name]
+ self.Bad_PUBLIC_name = None # [invalid-name]
+
+ zz = 'Why Was It Bad Class Attribute?'
+ GOOD_CLASS_ATTR = 'Good Class Attribute'
+
+ def BadMethodName(self): # [invalid-name]
+ """A Method with a bad name."""
+
+ def good_method_name(self):
+ """A method with a good name."""
+
+ def __DunDER_IS_not_free_for_all__(self): # [invalid-name]
+ """Another badly named method."""
+
+
+class DerivedFromCorrect(CorrectClassName):
+ """A derived class with an invalid inherited members.
+
+ Derived attributes and methods with invalid names do not trigger warnings.
+ """
+ zz = 'Now a good class attribute'
+
+ def __init__(self):
+ super().__init__()
+ self._Bad_AtTR_name = None # Ignored
+
+ def BadMethodName(self):
+ """Ignored since the method is in the interface."""
+
+
+V = [WHAT_Ever_inListComp for WHAT_Ever_inListComp in GOOD_CONST_NAME]
+
+def class_builder():
+ """Function returning a class object."""
+
+ class EmbeddedClass(object):
+ """Useless class."""
+
+ return EmbeddedClass
+
+# +1:[invalid-name]
+BAD_NAME_FOR_CLASS = collections.namedtuple('Named', ['tuple'])
+NEXT_BAD_NAME_FOR_CLASS = class_builder() # [invalid-name]
+
+GoodName = collections.namedtuple('Named', ['tuple'])
+ToplevelClass = class_builder()
+
+# Aliases for classes have the same name constraints.
+AlsoCorrect = CorrectClassName
+NOT_CORRECT = CorrectClassName # [invalid-name]
+
+
+def test_globals():
+ """Names in global statements are also checked."""
+ global NOT_CORRECT
+ global AlsoCorrect # [invalid-name]
+ NOT_CORRECT = 1
+ AlsoCorrect = 2
+
+
+class FooClass(object):
+ """A test case for property names.
+
+ Since by default, the regex for attributes is the same as the one
+ for method names, we check the warning messages to contain the
+ string 'attribute'.
+ """
+ @property
+ def PROPERTY_NAME(self): # [invalid-name]
+ """Ignored."""
+ pass
+
+ @property
+ @abc.abstractmethod
+ def ABSTRACT_PROPERTY_NAME(self): # [invalid-name]
+ """Ignored."""
+ pass
+
+ @PROPERTY_NAME.setter
+ def PROPERTY_NAME_SETTER(self): # [invalid-name]
+ """Ignored."""
+ pass
+
+ def _nice_and_long_descriptive_private_method_name(self):
+ """private method with long name"""
+ pass
+
+
+def good_public_function_name(good_arg_name):
+ """This is a perfect public function"""
+ good_variable_name = 1
+ return good_variable_name + good_arg_name
+
+
+def _private_scope_function_with_long_descriptive_name():
+ """Private scope function are cool with long descriptive names"""
+ return 12
+
+LONG_CONSTANT_NAME_IN_PUBLIC_SCOPE_ARE_OKAY = True
+# We don't emit for non-const nodes
+good_name_for_funcs = lambda: None
+good_name_for_lists = [1, 2, 3]
+
+class _AnExceptionalExceptionThatOccursVeryVeryRarely(Exception):
+ """A very exceptional exception with a nice descriptive name"""
+ pass
+
+class FooEnum(Enum):
+ """A test case for enum names."""
+ GOOD_ENUM_NAME = 1
+ bad_enum_name = 2 # [invalid-name]
+
+class Bar:
+ """Class with class variables annotated with ClassVar."""
+ CLASS_CONST: ClassVar[int] = 42
+ CLASS_CONST2: ClassVar = "const"
+ variable: ClassVar[str] = "invalid name"
+ CLASS_CONST3: typing.ClassVar
+ variable2: typing.ClassVar[int]
diff --git a/tests/functional/n/name/name_styles.rc b/tests/functional/n/name/name_styles.rc
new file mode 100644
index 0000000..1a63e67
--- /dev/null
+++ b/tests/functional/n/name/name_styles.rc
@@ -0,0 +1,5 @@
+[testoptions]
+min_pyver=2.6
+
+[Messages Control]
+disable=too-few-public-methods,abstract-class-not-used,global-statement
diff --git a/tests/functional/n/name/name_styles.txt b/tests/functional/n/name/name_styles.txt
new file mode 100644
index 0000000..0a82e60
--- /dev/null
+++ b/tests/functional/n/name/name_styles.txt
@@ -0,0 +1,17 @@
+invalid-name:11:0::"Constant name ""bad_const_name"" doesn't conform to UPPER_CASE naming style"
+invalid-name:14:0:BADFUNCTION_name:"Function name ""BADFUNCTION_name"" doesn't conform to snake_case naming style"
+invalid-name:16:4:BADFUNCTION_name:"Variable name ""BAD_LOCAL_VAR"" doesn't conform to snake_case naming style"
+invalid-name:20:0:func_bad_argname:"Argument name ""NOT_GOOD"" doesn't conform to snake_case naming style"
+invalid-name:30:0:bad_class_name:"Class name ""bad_class_name"" doesn't conform to PascalCase naming style"
+invalid-name:41:8:CorrectClassName.__init__:"Attribute name ""_Bad_AtTR_name"" doesn't conform to snake_case naming style"
+invalid-name:42:8:CorrectClassName.__init__:"Attribute name ""Bad_PUBLIC_name"" doesn't conform to snake_case naming style"
+invalid-name:47:4:CorrectClassName.BadMethodName:"Method name ""BadMethodName"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:53:4:CorrectClassName.__DunDER_IS_not_free_for_all__:"Method name ""__DunDER_IS_not_free_for_all__"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:83:0::"Class name ""BAD_NAME_FOR_CLASS"" doesn't conform to PascalCase naming style"
+invalid-name:84:0::"Class name ""NEXT_BAD_NAME_FOR_CLASS"" doesn't conform to PascalCase naming style"
+invalid-name:91:0::"Class name ""NOT_CORRECT"" doesn't conform to PascalCase naming style"
+invalid-name:97:4:test_globals:"Constant name ""AlsoCorrect"" doesn't conform to UPPER_CASE naming style"
+invalid-name:110:4:FooClass.PROPERTY_NAME:"Attribute name ""PROPERTY_NAME"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:116:4:FooClass.ABSTRACT_PROPERTY_NAME:"Attribute name ""ABSTRACT_PROPERTY_NAME"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:121:4:FooClass.PROPERTY_NAME_SETTER:"Attribute name ""PROPERTY_NAME_SETTER"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:152:4:FooEnum:"Class constant name ""bad_enum_name"" doesn't conform to UPPER_CASE naming style"
diff --git a/tests/functional/n/name/namedtuple_member_inference.py b/tests/functional/n/name/namedtuple_member_inference.py
new file mode 100644
index 0000000..4488ceb
--- /dev/null
+++ b/tests/functional/n/name/namedtuple_member_inference.py
@@ -0,0 +1,22 @@
+"""Test namedtuple attributes.
+
+Regression test for:
+https://bitbucket.org/logilab/pylint/issue/93/pylint-crashes-on-namedtuple-attribute
+"""
+from __future__ import absolute_import, print_function
+from collections import namedtuple
+
+__revision__ = None
+
+Thing = namedtuple('Thing', ())
+
+Fantastic = namedtuple('Fantastic', ['foo'])
+
+def test():
+ """Test member access in named tuples."""
+ print(Thing.x) # [no-member]
+ fan = Fantastic(1)
+ print(fan.foo)
+ # Should not raise protected-access.
+ fan2 = fan._replace(foo=2)
+ print(fan2.foo)
diff --git a/tests/functional/n/name/namedtuple_member_inference.txt b/tests/functional/n/name/namedtuple_member_inference.txt
new file mode 100644
index 0000000..b754e9b
--- /dev/null
+++ b/tests/functional/n/name/namedtuple_member_inference.txt
@@ -0,0 +1 @@
+no-member:17:10:test:Class 'Thing' has no 'x' member:INFERENCE
diff --git a/tests/functional/n/name/names_in__all__.py b/tests/functional/n/name/names_in__all__.py
new file mode 100644
index 0000000..9b2840a
--- /dev/null
+++ b/tests/functional/n/name/names_in__all__.py
@@ -0,0 +1,49 @@
+# pylint: disable=too-few-public-methods,no-self-use, no-absolute-import,import-error, useless-object-inheritance, unnecessary-pass
+"""Test Pylint's use of __all__.
+
+* NonExistant is not defined in this module, and it is listed in
+ __all__. An error is expected.
+
+* This module imports path and republished it in __all__. No errors
+ are expected.
+"""
+from __future__ import print_function
+from os import path
+from collections import deque
+from missing import Missing
+
+__all__ = [
+ 'Dummy',
+ '', # [undefined-all-variable]
+ Missing,
+ SomeUndefined, # [undefined-variable]
+ 'NonExistant', # [undefined-all-variable]
+ 'path',
+ 'func', # [undefined-all-variable]
+ 'inner', # [undefined-all-variable]
+ 'InnerKlass', deque.__name__] # [undefined-all-variable]
+
+
+class Dummy(object):
+ """A class defined in this module."""
+ pass
+
+DUMMY = Dummy()
+
+def function():
+ """Function docstring
+ """
+ pass
+
+function()
+
+class Klass(object):
+ """A klass which contains a function"""
+ def func(self):
+ """A klass method"""
+ inner = None
+ print(inner)
+
+ class InnerKlass(object):
+ """An inner klass"""
+ pass
diff --git a/tests/functional/n/name/names_in__all__.txt b/tests/functional/n/name/names_in__all__.txt
new file mode 100644
index 0000000..aa90151
--- /dev/null
+++ b/tests/functional/n/name/names_in__all__.txt
@@ -0,0 +1,6 @@
+undefined-all-variable:17:4::Undefined variable name '' in __all__
+undefined-variable:19:4::Undefined variable 'SomeUndefined'
+undefined-all-variable:20:4::Undefined variable name 'NonExistant' in __all__
+undefined-all-variable:22:4::Undefined variable name 'func' in __all__
+undefined-all-variable:23:4::Undefined variable name 'inner' in __all__
+undefined-all-variable:24:4::Undefined variable name 'InnerKlass' in __all__
diff --git a/tests/functional/n/nan_comparison_check.py b/tests/functional/n/nan_comparison_check.py
new file mode 100644
index 0000000..b01cf26
--- /dev/null
+++ b/tests/functional/n/nan_comparison_check.py
@@ -0,0 +1,21 @@
+# pylint: disable=missing-docstring, invalid-name, misplaced-comparison-constant
+# pylint: disable=literal-comparison,comparison-with-itself, import-error
+"""Test detection of NaN value comparison."""
+import numpy
+x = 42
+a = x is numpy.NaN # [nan-comparison]
+b = x == numpy.NaN # [nan-comparison]
+c = x == float('nan') # [nan-comparison]
+e = numpy.NaN == numpy.NaN # [nan-comparison]
+f = x is 1
+g = 123 is "123"
+h = numpy.NaN is not x # [nan-comparison]
+i = numpy.NaN != x # [nan-comparison]
+
+j = x != numpy.NaN # [nan-comparison]
+j1 = x != float('nan') # [nan-comparison]
+assert x == numpy.NaN # [nan-comparison]
+assert x is not float('nan') # [nan-comparison]
+if x == numpy.NaN: # [nan-comparison]
+ pass
+z = bool(x is numpy.NaN) # [nan-comparison]
diff --git a/tests/functional/n/nan_comparison_check.txt b/tests/functional/n/nan_comparison_check.txt
new file mode 100644
index 0000000..2351ea4
--- /dev/null
+++ b/tests/functional/n/nan_comparison_check.txt
@@ -0,0 +1,12 @@
+nan-comparison:6:4::Comparison 'x is numpy.NaN' should be 'math.isnan(x)'
+nan-comparison:7:4::Comparison 'x == numpy.NaN' should be 'math.isnan(x)'
+nan-comparison:8:4::Comparison 'x == float('nan')' should be 'math.isnan(x)'
+nan-comparison:9:4::Comparison 'numpy.NaN == numpy.NaN' should be 'math.isnan(numpy.NaN)'
+nan-comparison:12:4::Comparison 'numpy.NaN is not x' should be 'not math.isnan(x)'
+nan-comparison:13:4::Comparison 'numpy.NaN != x' should be 'not math.isnan(x)'
+nan-comparison:15:4::Comparison 'x != numpy.NaN' should be 'not math.isnan(x)'
+nan-comparison:16:5::Comparison 'x != float('nan')' should be 'not math.isnan(x)'
+nan-comparison:17:7::Comparison 'x == numpy.NaN' should be 'math.isnan(x)'
+nan-comparison:18:7::Comparison 'x is not float('nan')' should be 'not math.isnan(x)'
+nan-comparison:19:3::Comparison 'x == numpy.NaN' should be 'math.isnan(x)'
+nan-comparison:21:9::Comparison 'x is numpy.NaN' should be 'math.isnan(x)'
diff --git a/tests/functional/n/nested_blocks_issue1088.py b/tests/functional/n/nested_blocks_issue1088.py
new file mode 100644
index 0000000..d44a9f7
--- /dev/null
+++ b/tests/functional/n/nested_blocks_issue1088.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+def had_bug(num):
+ if num > 1: # [too-many-nested-blocks]
+ if num > 2:
+ if num > 3:
+ if num > 4:
+ if num > 5:
+ if num > 6:
+ return True
+ return None
+
+
+def was_correct(num):
+ if num > 1: # [too-many-nested-blocks]
+ if num > 2:
+ if num > 3:
+ if num > 4:
+ if num > 5:
+ if num > 6:
+ return True
+ if num == 0:
+ return False
+ return None
diff --git a/tests/functional/n/nested_blocks_issue1088.txt b/tests/functional/n/nested_blocks_issue1088.txt
new file mode 100644
index 0000000..66dac6e
--- /dev/null
+++ b/tests/functional/n/nested_blocks_issue1088.txt
@@ -0,0 +1,2 @@
+too-many-nested-blocks:3:4:had_bug:Too many nested blocks (6/5)
+too-many-nested-blocks:14:4:was_correct:Too many nested blocks (6/5)
diff --git a/tests/functional/n/nested_func_defined_in_loop.py b/tests/functional/n/nested_func_defined_in_loop.py
new file mode 100644
index 0000000..39d2889
--- /dev/null
+++ b/tests/functional/n/nested_func_defined_in_loop.py
@@ -0,0 +1,10 @@
+"""Check a nested function defined in a loop."""
+
+def example(args):
+ """The check"""
+ for i in args:
+ def nested():
+ print(i) # [cell-var-from-loop]
+ nested()
+ for i in args:
+ print(i)
diff --git a/tests/functional/n/nested_func_defined_in_loop.txt b/tests/functional/n/nested_func_defined_in_loop.txt
new file mode 100644
index 0000000..9f70ebc
--- /dev/null
+++ b/tests/functional/n/nested_func_defined_in_loop.txt
@@ -0,0 +1 @@
+cell-var-from-loop:7:18:example.nested:Cell variable i defined in loop
diff --git a/tests/functional/n/new_style_class_py_30.py b/tests/functional/n/new_style_class_py_30.py
new file mode 100644
index 0000000..fd78c55
--- /dev/null
+++ b/tests/functional/n/new_style_class_py_30.py
@@ -0,0 +1,35 @@
+"""check builtin data descriptors such as mode and name attributes on a file are correctly handled
+
+bug notified by Pierre Rouleau on 2005-04-24
+"""
+from __future__ import print_function
+__revision__ = None
+
+
+class File(file): # pylint: disable=file-builtin,undefined-variable
+ """ Testing new-style class inheritance from file"""
+ def __init__(self, name, mode="r", buffering=-1, verbose=False):
+ """Constructor"""
+ self.was_modified = False
+ self.verbose = verbose
+ super(File, self).__init__(name, mode, buffering) # [super-with-arguments]
+ if self.verbose:
+ print("File %s is opened. The mode is: %s" % (self.name,
+ self.mode))
+
+ def write(self, a_string):
+ """ Write a string to the file."""
+ super(File, self).write(a_string) # [super-with-arguments]
+ self.was_modified = True
+
+ def writelines(self, sequence):
+ """ Write a sequence of strings to the file. """
+ super(File, self).writelines(sequence) # [super-with-arguments]
+ self.was_modified = True
+
+ def close(self):
+ """Close the file."""
+ if self.verbose:
+ print("Closing file %s" % self.name)
+ super(File, self).close() # [super-with-arguments]
+ self.was_modified = False
diff --git a/tests/functional/n/new_style_class_py_30.txt b/tests/functional/n/new_style_class_py_30.txt
new file mode 100644
index 0000000..1f34343
--- /dev/null
+++ b/tests/functional/n/new_style_class_py_30.txt
@@ -0,0 +1,4 @@
+super-with-arguments:15:8:File.__init__:Consider using Python 3 style super() without arguments
+super-with-arguments:22:8:File.write:Consider using Python 3 style super() without arguments
+super-with-arguments:27:8:File.writelines:Consider using Python 3 style super() without arguments
+super-with-arguments:34:8:File.close:Consider using Python 3 style super() without arguments
diff --git a/tests/functional/n/no/__init__.py b/tests/functional/n/no/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/n/no/__init__.py
diff --git a/tests/functional/n/no/no_classmethod_decorator.py b/tests/functional/n/no/no_classmethod_decorator.py
new file mode 100644
index 0000000..66cc0b3
--- /dev/null
+++ b/tests/functional/n/no/no_classmethod_decorator.py
@@ -0,0 +1,35 @@
+"""Checks class methods are declared with a decorator if within the class
+scope and if classmethod's argument is a member of the class
+"""
+
+# pylint: disable=too-few-public-methods, using-constant-test, no-self-argument, useless-object-inheritance
+
+class MyClass(object):
+ """Some class"""
+ def __init__(self):
+ pass
+
+ def cmethod(cls):
+ """class method-to-be"""
+ cmethod = classmethod(cmethod) # [no-classmethod-decorator]
+
+ if True:
+ cmethod = classmethod(cmethod) # [no-classmethod-decorator]
+
+ @classmethod
+ def my_second_method(cls):
+ """correct class method definition"""
+
+ def other_method(cls):
+ """some method"""
+ cmethod2 = classmethod(other_method) # [no-classmethod-decorator]
+
+def helloworld():
+ """says hello"""
+
+
+MyClass.new_class_method = classmethod(helloworld)
+
+class MyOtherClass(object):
+ """Some other class"""
+ _make = classmethod(tuple.__new__)
diff --git a/tests/functional/n/no/no_classmethod_decorator.txt b/tests/functional/n/no/no_classmethod_decorator.txt
new file mode 100644
index 0000000..90b10f2
--- /dev/null
+++ b/tests/functional/n/no/no_classmethod_decorator.txt
@@ -0,0 +1,3 @@
+no-classmethod-decorator:14:4:MyClass:Consider using a decorator instead of calling classmethod
+no-classmethod-decorator:17:8:MyClass:Consider using a decorator instead of calling classmethod
+no-classmethod-decorator:25:4:MyClass:Consider using a decorator instead of calling classmethod
diff --git a/tests/functional/n/no/no_dummy_redefined.py b/tests/functional/n/no/no_dummy_redefined.py
new file mode 100644
index 0000000..c6b093d
--- /dev/null
+++ b/tests/functional/n/no/no_dummy_redefined.py
@@ -0,0 +1,14 @@
+"""Make sure warnings about redefinitions do not trigger for dummy variables."""
+from __future__ import print_function
+
+
+_, INTERESTING = 'a=b'.split('=')
+
+value = 10 # [invalid-name]
+
+
+def clobbering():
+ """Clobbers a dummy name from the outer scope."""
+ value = 9 # [redefined-outer-name]
+ for _ in range(7):
+ print(value)
diff --git a/tests/functional/n/no/no_dummy_redefined.txt b/tests/functional/n/no/no_dummy_redefined.txt
new file mode 100644
index 0000000..3e6854b
--- /dev/null
+++ b/tests/functional/n/no/no_dummy_redefined.txt
@@ -0,0 +1,2 @@
+invalid-name:7:0::"Constant name ""value"" doesn't conform to UPPER_CASE naming style"
+redefined-outer-name:12:4:clobbering:Redefining name 'value' from outer scope (line 7)
diff --git a/tests/functional/n/no/no_else_break.py b/tests/functional/n/no/no_else_break.py
new file mode 100644
index 0000000..cf23f31
--- /dev/null
+++ b/tests/functional/n/no/no_else_break.py
@@ -0,0 +1,137 @@
+""" Test that superfluous else return are detected. """
+
+# pylint:disable=invalid-name,missing-docstring,unused-variable
+
+
+def foo1(x, y, z):
+ for i in x:
+ if i > y: # [no-else-break]
+ break
+ else:
+ a = z
+
+
+def foo2(x, y, w, z):
+ for i in x:
+ if i > y: # [no-else-break]
+ break
+ elif i > w:
+ break
+ else:
+ a = z
+
+
+def foo3(x, y, z):
+ for i in x:
+ if i > y:
+ a = 1
+ if z: # [no-else-break]
+ b = 2
+ break
+ else:
+ c = 3
+ break
+ else:
+ d = 4
+ break
+
+
+def foo4(x, y):
+ for i in x:
+ if i > x: # [no-else-break]
+ if y:
+ a = 4
+ else:
+ b = 2
+ break
+ else:
+ c = 3
+ break
+
+
+def foo5(x, y, z):
+ for i in x:
+ if i > y: # [no-else-break]
+ if y:
+ a = 4
+ else:
+ b = 2
+ break
+ elif z:
+ c = 2
+ else:
+ c = 3
+ break
+
+
+def foo6(x, y):
+ for i in x:
+ if i > x:
+ if y: # [no-else-break]
+ a = 4
+ break
+ else:
+ b = 2
+ else:
+ c = 3
+ break
+
+
+def bar1(x, y, z):
+ for i in x:
+ if i > y:
+ break
+ return z
+
+
+def bar2(w, x, y, z):
+ for i in w:
+ if i > x:
+ break
+ if z < i:
+ a = y
+ else:
+ break
+ return
+
+
+def bar3(x, y, z):
+ for i in x:
+ if i > y:
+ if z:
+ break
+ else:
+ return z
+ return None
+
+
+def bar4(x):
+ for i in range(10):
+ if x: # [no-else-break]
+ break
+ else:
+ try:
+ return
+ except ValueError:
+ break
+
+
+def nested1(x, y, z):
+ for i in x:
+ if i > x:
+ for j in y:
+ if j < z:
+ break
+ else:
+ a = z
+
+
+def nested2(x, y, z):
+ for i in x:
+ if i > x:
+ for j in y:
+ if j > z:
+ break
+ break
+ else:
+ a = z
diff --git a/tests/functional/n/no/no_else_break.txt b/tests/functional/n/no/no_else_break.txt
new file mode 100644
index 0000000..d1a27f7
--- /dev/null
+++ b/tests/functional/n/no/no_else_break.txt
@@ -0,0 +1,7 @@
+no-else-break:8:8:foo1:"Unnecessary ""else"" after ""break"""
+no-else-break:16:8:foo2:"Unnecessary ""elif"" after ""break"""
+no-else-break:28:12:foo3:"Unnecessary ""else"" after ""break"""
+no-else-break:41:8:foo4:"Unnecessary ""else"" after ""break"""
+no-else-break:54:8:foo5:"Unnecessary ""elif"" after ""break"""
+no-else-break:70:12:foo6:"Unnecessary ""else"" after ""break"""
+no-else-break:110:8:bar4:"Unnecessary ""else"" after ""break"""
diff --git a/tests/functional/n/no/no_else_continue.py b/tests/functional/n/no/no_else_continue.py
new file mode 100644
index 0000000..37f70f1
--- /dev/null
+++ b/tests/functional/n/no/no_else_continue.py
@@ -0,0 +1,137 @@
+""" Test that superfluous else return are detected. """
+
+# pylint:disable=invalid-name,missing-docstring,unused-variable
+
+
+def foo1(x, y, z):
+ for i in x:
+ if i < y: # [no-else-continue]
+ continue
+ else:
+ a = z
+
+
+def foo2(x, y, w, z):
+ for i in x:
+ if i < y: # [no-else-continue]
+ continue
+ elif i < w:
+ continue
+ else:
+ a = z
+
+
+def foo3(x, y, z):
+ for i in x:
+ if i < y:
+ a = 1
+ if z: # [no-else-continue]
+ b = 2
+ continue
+ else:
+ c = 3
+ continue
+ else:
+ d = 4
+ continue
+
+
+def foo4(x, y):
+ for i in x:
+ if i < x: # [no-else-continue]
+ if y:
+ a = 4
+ else:
+ b = 2
+ continue
+ else:
+ c = 3
+ continue
+
+
+def foo5(x, y, z):
+ for i in x:
+ if i < y: # [no-else-continue]
+ if y:
+ a = 4
+ else:
+ b = 2
+ continue
+ elif z:
+ c = 2
+ else:
+ c = 3
+ continue
+
+
+def foo6(x, y):
+ for i in x:
+ if i < x:
+ if y: # [no-else-continue]
+ a = 4
+ continue
+ else:
+ b = 2
+ else:
+ c = 3
+ continue
+
+
+def bar1(x, y, z):
+ for i in x:
+ if i < y:
+ continue
+ return z
+
+
+def bar2(w, x, y, z):
+ for i in w:
+ if i < x:
+ continue
+ if z < i:
+ a = y
+ else:
+ continue
+ return
+
+
+def bar3(x, y, z):
+ for i in x:
+ if i < y:
+ if z:
+ continue
+ else:
+ return z
+ return None
+
+
+def bar4(x):
+ for i in range(10):
+ if x: # [no-else-continue]
+ continue
+ else:
+ try:
+ return
+ except ValueError:
+ continue
+
+
+def nested1(x, y, z):
+ for i in x:
+ if i < x:
+ for j in y:
+ if j < z:
+ continue
+ else:
+ a = z
+
+
+def nested2(x, y, z):
+ for i in x:
+ if i < x:
+ for j in y:
+ if j < z:
+ continue
+ continue
+ else:
+ a = z
diff --git a/tests/functional/n/no/no_else_continue.txt b/tests/functional/n/no/no_else_continue.txt
new file mode 100644
index 0000000..6d659ea
--- /dev/null
+++ b/tests/functional/n/no/no_else_continue.txt
@@ -0,0 +1,7 @@
+no-else-continue:8:8:foo1:"Unnecessary ""else"" after ""continue"""
+no-else-continue:16:8:foo2:"Unnecessary ""elif"" after ""continue"""
+no-else-continue:28:12:foo3:"Unnecessary ""else"" after ""continue"""
+no-else-continue:41:8:foo4:"Unnecessary ""else"" after ""continue"""
+no-else-continue:54:8:foo5:"Unnecessary ""elif"" after ""continue"""
+no-else-continue:70:12:foo6:"Unnecessary ""else"" after ""continue"""
+no-else-continue:110:8:bar4:"Unnecessary ""else"" after ""continue"""
diff --git a/tests/functional/n/no/no_else_raise.py b/tests/functional/n/no/no_else_raise.py
new file mode 100644
index 0000000..ae807fa
--- /dev/null
+++ b/tests/functional/n/no/no_else_raise.py
@@ -0,0 +1,110 @@
+""" Test that superfluous else return are detected. """
+
+# pylint:disable=invalid-name,missing-docstring,unused-variable,raise-missing-from
+
+def foo1(x, y, z):
+ if x: # [no-else-raise]
+ a = 1
+ raise Exception(y)
+ else:
+ b = 2
+ raise Exception(z)
+
+
+def foo2(x, y, w, z):
+ if x: # [no-else-raise]
+ a = 1
+ raise Exception(y)
+ elif z:
+ b = 2
+ raise Exception(w)
+ else:
+ c = 3
+ raise Exception(z)
+
+
+def foo3(x, y, z):
+ if x:
+ a = 1
+ if y: # [no-else-raise]
+ b = 2
+ raise Exception(y)
+ else:
+ c = 3
+ raise Exception(x)
+ else:
+ d = 4
+ raise Exception(z)
+
+
+def foo4(x, y):
+ if x: # [no-else-raise]
+ if y:
+ a = 4
+ else:
+ b = 2
+ raise Exception(x)
+ else:
+ c = 3
+ raise Exception(y)
+
+
+def foo5(x, y, z):
+ if x: # [no-else-raise]
+ if y:
+ a = 4
+ else:
+ b = 2
+ raise Exception(x)
+ elif z:
+ raise Exception(y)
+ else:
+ c = 3
+ raise Exception(z)
+
+
+def foo6(x, y):
+ if x:
+ if y: # [no-else-raise]
+ a = 4
+ raise Exception(x)
+ else:
+ b = 2
+ else:
+ c = 3
+ raise Exception(y)
+
+
+def bar1(x, y, z):
+ if x:
+ raise Exception(y)
+ raise Exception(z)
+
+
+def bar2(w, x, y, z):
+ if x:
+ raise Exception(y)
+ if z:
+ a = 1
+ else:
+ raise Exception(w)
+ raise Exception(None)
+
+
+def bar3(x, y, z):
+ if x:
+ if z:
+ raise Exception(y)
+ else:
+ raise Exception(z)
+ raise Exception(None)
+
+
+def bar4(x):
+ if x: # [no-else-raise]
+ raise Exception(True)
+ else:
+ try:
+ raise Exception(False)
+ except ValueError:
+ raise Exception(None)
diff --git a/tests/functional/n/no/no_else_raise.txt b/tests/functional/n/no/no_else_raise.txt
new file mode 100644
index 0000000..b41f713
--- /dev/null
+++ b/tests/functional/n/no/no_else_raise.txt
@@ -0,0 +1,7 @@
+no-else-raise:6:4:foo1:"Unnecessary ""else"" after ""raise"""
+no-else-raise:15:4:foo2:"Unnecessary ""elif"" after ""raise"""
+no-else-raise:29:8:foo3:"Unnecessary ""else"" after ""raise"""
+no-else-raise:41:4:foo4:"Unnecessary ""else"" after ""raise"""
+no-else-raise:53:4:foo5:"Unnecessary ""elif"" after ""raise"""
+no-else-raise:68:8:foo6:"Unnecessary ""else"" after ""raise"""
+no-else-raise:104:4:bar4:"Unnecessary ""else"" after ""raise"""
diff --git a/tests/functional/n/no/no_else_return.py b/tests/functional/n/no/no_else_return.py
new file mode 100644
index 0000000..0a87551
--- /dev/null
+++ b/tests/functional/n/no/no_else_return.py
@@ -0,0 +1,110 @@
+""" Test that superfluous else return are detected. """
+
+
+# pylint:disable=invalid-name,missing-docstring,unused-variable
+def foo1(x, y, z):
+ if x: # [no-else-return]
+ a = 1
+ return y
+ else:
+ b = 2
+ return z
+
+
+def foo2(x, y, w, z):
+ if x: # [no-else-return]
+ a = 1
+ return y
+ elif z:
+ b = 2
+ return w
+ else:
+ c = 3
+ return z
+
+
+def foo3(x, y, z):
+ if x:
+ a = 1
+ if y: # [no-else-return]
+ b = 2
+ return y
+ else:
+ c = 3
+ return x
+ else:
+ d = 4
+ return z
+
+
+def foo4(x, y):
+ if x: # [no-else-return]
+ if y:
+ a = 4
+ else:
+ b = 2
+ return
+ else:
+ c = 3
+ return
+
+
+def foo5(x, y, z):
+ if x: # [no-else-return]
+ if y:
+ a = 4
+ else:
+ b = 2
+ return
+ elif z:
+ c = 2
+ else:
+ c = 3
+ return
+
+
+def foo6(x, y):
+ if x:
+ if y: # [no-else-return]
+ a = 4
+ return
+ else:
+ b = 2
+ else:
+ c = 3
+ return
+
+
+def bar1(x, y, z):
+ if x:
+ return y
+ return z
+
+
+def bar2(w, x, y, z):
+ if x:
+ return y
+ if z:
+ a = 1
+ else:
+ return w
+ return None
+
+
+def bar3(x, y, z):
+ if x:
+ if z:
+ return y
+ else:
+ return z
+ return None
+
+
+def bar4(x):
+ if x: # [no-else-return]
+ return True
+ else:
+ try:
+ return False
+ except ValueError:
+ return None
diff --git a/tests/functional/n/no/no_else_return.txt b/tests/functional/n/no/no_else_return.txt
new file mode 100644
index 0000000..4560f74
--- /dev/null
+++ b/tests/functional/n/no/no_else_return.txt
@@ -0,0 +1,7 @@
+no-else-return:6:4:foo1:"Unnecessary ""else"" after ""return"""
+no-else-return:15:4:foo2:"Unnecessary ""elif"" after ""return"""
+no-else-return:29:8:foo3:"Unnecessary ""else"" after ""return"""
+no-else-return:41:4:foo4:"Unnecessary ""else"" after ""return"""
+no-else-return:53:4:foo5:"Unnecessary ""elif"" after ""return"""
+no-else-return:68:8:foo6:"Unnecessary ""else"" after ""return"""
+no-else-return:104:4:bar4:"Unnecessary ""else"" after ""return"""
diff --git a/tests/functional/n/no/no_method_argument_py38.py b/tests/functional/n/no/no_method_argument_py38.py
new file mode 100644
index 0000000..c674532
--- /dev/null
+++ b/tests/functional/n/no/no_method_argument_py38.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+
+
+class Cls:
+ def __init__(self, obj, /):
+ self.obj = obj
diff --git a/tests/functional/n/no/no_method_argument_py38.rc b/tests/functional/n/no/no_method_argument_py38.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/n/no/no_method_argument_py38.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/n/no/no_name_in_module.py b/tests/functional/n/no/no_name_in_module.py
new file mode 100644
index 0000000..e3ea946
--- /dev/null
+++ b/tests/functional/n/no/no_name_in_module.py
@@ -0,0 +1,66 @@
+# pylint: disable=wildcard-import,unused-import,no-absolute-import,invalid-name,import-error,
+# pylint: disable=bare-except,broad-except,wrong-import-order,ungrouped-imports,wrong-import-position
+"""check nonexistent names imported are reported"""
+from __future__ import print_function
+import collections.tutu # [no-name-in-module]
+from collections import toto # [no-name-in-module]
+toto.yo()
+
+from xml.etree import ElementTree
+ElementTree.nonexistant_function() # [no-member]
+ElementTree.another.nonexistant.function() # [no-member]
+
+
+import sys
+print(sys.stdout, 'hello world')
+print(sys.stdoout, 'bye bye world') # [no-member]
+
+
+import re
+re.finditer('*', 'yo')
+
+from rie import *
+from re import findiiter, compiile # [no-name-in-module,no-name-in-module]
+
+import os
+'SOMEVAR' in os.environ # [pointless-statement]
+
+try:
+ from collections import something
+except ImportError:
+ something = None
+
+try:
+ from collections import anything # [no-name-in-module]
+except ValueError:
+ anything = None
+
+try:
+ import collections.missing
+except ImportError:
+ pass
+
+try:
+ import collections.indeed_missing # [no-name-in-module]
+except ValueError:
+ pass
+
+try:
+ import collections.emit # [no-name-in-module]
+except Exception:
+ pass
+
+try:
+ import collections.emit1
+except ImportError:
+ pass
+
+try:
+ if something:
+ import collections.emit2 # [no-name-in-module]
+except Exception:
+ pass
+
+from .no_self_use import Super
+from .no_self_use import lala # [no-name-in-module]
+from .no_self_use.bla import lala1 # [no-name-in-module]
diff --git a/tests/functional/n/no/no_name_in_module.txt b/tests/functional/n/no/no_name_in_module.txt
new file mode 100644
index 0000000..883e6b5
--- /dev/null
+++ b/tests/functional/n/no/no_name_in_module.txt
@@ -0,0 +1,14 @@
+no-name-in-module:5:0::No name 'tutu' in module 'collections'
+no-name-in-module:6:0::No name 'toto' in module 'collections'
+no-member:10:0::Module 'xml.etree.ElementTree' has no 'nonexistant_function' member:INFERENCE
+no-member:11:0::Module 'xml.etree.ElementTree' has no 'another' member:INFERENCE
+no-member:16:6::Module 'sys' has no 'stdoout' member; maybe 'stdout'?:INFERENCE
+no-name-in-module:23:0::No name 'compiile' in module 're'
+no-name-in-module:23:0::No name 'findiiter' in module 're'
+pointless-statement:26:0::Statement seems to have no effect
+no-name-in-module:34:4::No name 'anything' in module 'collections'
+no-name-in-module:44:4::No name 'indeed_missing' in module 'collections'
+no-name-in-module:49:4::No name 'emit' in module 'collections'
+no-name-in-module:60:8::No name 'emit2' in module 'collections'
+no-name-in-module:65:0::No name 'lala' in module 'functional.n.no.no_self_use'
+no-name-in-module:66:0::No name 'bla' in module 'functional.n.no.no_self_use'
diff --git a/tests/functional/n/no/no_self_argument.py b/tests/functional/n/no/no_self_argument.py
new file mode 100644
index 0000000..38f6040
--- /dev/null
+++ b/tests/functional/n/no/no_self_argument.py
@@ -0,0 +1,18 @@
+"""Check for method without self as first argument"""
+# pylint: disable=useless-object-inheritance
+from __future__ import print_function
+
+class NoSelfArgument(object):
+ """dummy class"""
+
+ def __init__(truc): # [no-self-argument]
+ """method without self"""
+ print(1)
+
+ def abdc(yoo): # [no-self-argument]
+ """another test"""
+ print(yoo)
+
+ def edf(self):
+ """just another method"""
+ print('yapudju in', self)
diff --git a/tests/functional/n/no/no_self_argument.txt b/tests/functional/n/no/no_self_argument.txt
new file mode 100644
index 0000000..7e11c5c
--- /dev/null
+++ b/tests/functional/n/no/no_self_argument.txt
@@ -0,0 +1,2 @@
+no-self-argument:8:4:NoSelfArgument.__init__:"Method should have ""self"" as first argument"
+no-self-argument:12:4:NoSelfArgument.abdc:"Method should have ""self"" as first argument"
diff --git a/tests/functional/n/no/no_self_argument_py37.py b/tests/functional/n/no/no_self_argument_py37.py
new file mode 100644
index 0000000..8e6d6fc
--- /dev/null
+++ b/tests/functional/n/no/no_self_argument_py37.py
@@ -0,0 +1,15 @@
+"""Test detection of self as argument of first method in Python 3.7 and above."""
+
+# pylint: disable=missing-docstring,too-few-public-methods,useless-object-inheritance
+
+
+class Toto(object):
+
+ def __class_getitem__(cls, params):
+ # This is actually a special method which is always a class method.
+ # See https://www.python.org/dev/peps/pep-0560/#class-getitem
+ pass
+
+ def __class_other__(cls, params): # [no-self-argument]
+ # This is not a special case and as such is an instance method.
+ pass
diff --git a/tests/functional/n/no/no_self_argument_py37.rc b/tests/functional/n/no/no_self_argument_py37.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/n/no/no_self_argument_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/n/no/no_self_argument_py37.txt b/tests/functional/n/no/no_self_argument_py37.txt
new file mode 100644
index 0000000..d0aba84
--- /dev/null
+++ b/tests/functional/n/no/no_self_argument_py37.txt
@@ -0,0 +1 @@
+no-self-argument:13:4:Toto.__class_other__:"Method should have ""self"" as first argument"
diff --git a/tests/functional/n/no/no_self_use.py b/tests/functional/n/no/no_self_use.py
new file mode 100644
index 0000000..f84ab15
--- /dev/null
+++ b/tests/functional/n/no/no_self_use.py
@@ -0,0 +1,78 @@
+# pylint: disable=too-few-public-methods,missing-docstring, useless-object-inheritance
+"""test detection of method which could be a function"""
+
+from __future__ import print_function
+
+class Toto(object):
+ """bla bal abl"""
+
+ def __init__(self):
+ self.aaa = 2
+
+ def regular_method(self):
+ """this method is a real method since it access to self"""
+ self.function_method()
+
+ def function_method(self): # [no-self-use]
+ """this method isn' a real method since it doesn't need self"""
+ print('hello')
+
+
+class Base(object):
+ """an abstract class"""
+
+ def __init__(self):
+ self.aaa = 2
+
+ def check(self, arg):
+ """an abstract method, could not be a function"""
+ raise NotImplementedError
+
+
+class Sub(Base):
+ """a concrete class"""
+
+ def check(self, arg):
+ """a concrete method, could not be a function since it need
+ polymorphism benefits
+ """
+ return arg == 0
+
+class Super(object):
+ """same as before without abstract"""
+ attr = 1
+ def method(self):
+ """regular"""
+ print(self.attr)
+
+class Sub1(Super):
+ """override method with need for self"""
+ def method(self):
+ """no i can not be a function"""
+ print(42)
+
+ def __len__(self):
+ """no i can not be a function"""
+ return 42
+
+ def __cmp__(self, other):
+ """no i can not be a function"""
+ print(42)
+
+ def __copy__(self):
+ return 24
+
+ def __getstate__(self):
+ return 42
+
+
+class Prop(object):
+
+ @property
+ def count(self):
+ """Don't emit no-self-use for properties.
+
+ They can't be functions and they can be part of an
+ API specification.
+ """
+ return 42
diff --git a/tests/functional/n/no/no_self_use.txt b/tests/functional/n/no/no_self_use.txt
new file mode 100644
index 0000000..b14ee9e
--- /dev/null
+++ b/tests/functional/n/no/no_self_use.txt
@@ -0,0 +1 @@
+no-self-use:16:4:Toto.function_method:Method could be a function
diff --git a/tests/functional/n/no/no_self_use_py3.py b/tests/functional/n/no/no_self_use_py3.py
new file mode 100644
index 0000000..f401508
--- /dev/null
+++ b/tests/functional/n/no/no_self_use_py3.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,no-init,unused-argument,invalid-name,too-few-public-methods
+
+class A:
+ def __init__(self):
+ self.store = {}
+
+ def get(self, key, default=None):
+ return self.store.get(key, default)
+
+class B(A):
+ def get_memo(self, obj):
+ return super().get(obj)
diff --git a/tests/functional/n/no/no_self_use_py3.rc b/tests/functional/n/no/no_self_use_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/n/no/no_self_use_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/n/no/no_staticmethod_decorator.py b/tests/functional/n/no/no_staticmethod_decorator.py
new file mode 100644
index 0000000..d0e0eff
--- /dev/null
+++ b/tests/functional/n/no/no_staticmethod_decorator.py
@@ -0,0 +1,35 @@
+"""Checks static methods are declared with a decorator if within the class
+scope and if static method's argument is a member of the class
+"""
+
+# pylint: disable=too-few-public-methods, using-constant-test, no-method-argument, useless-object-inheritance
+
+class MyClass(object):
+ """Some class"""
+ def __init__(self):
+ pass
+
+ def smethod():
+ """static method-to-be"""
+ smethod = staticmethod(smethod) # [no-staticmethod-decorator]
+
+ if True:
+ smethod = staticmethod(smethod) # [no-staticmethod-decorator]
+
+ @staticmethod
+ def my_second_method():
+ """correct static method definition"""
+
+ def other_method():
+ """some method"""
+ smethod2 = staticmethod(other_method) # [no-staticmethod-decorator]
+
+def helloworld():
+ """says hello"""
+
+
+MyClass.new_static_method = staticmethod(helloworld)
+
+class MyOtherClass(object):
+ """Some other class"""
+ _make = staticmethod(tuple.__new__)
diff --git a/tests/functional/n/no/no_staticmethod_decorator.txt b/tests/functional/n/no/no_staticmethod_decorator.txt
new file mode 100644
index 0000000..df89766
--- /dev/null
+++ b/tests/functional/n/no/no_staticmethod_decorator.txt
@@ -0,0 +1,3 @@
+no-staticmethod-decorator:14:4:MyClass:Consider using a decorator instead of calling staticmethod
+no-staticmethod-decorator:17:8:MyClass:Consider using a decorator instead of calling staticmethod
+no-staticmethod-decorator:25:4:MyClass:Consider using a decorator instead of calling staticmethod
diff --git a/tests/functional/n/no/no_warning_docstring.py b/tests/functional/n/no/no_warning_docstring.py
new file mode 100644
index 0000000..315eeea
--- /dev/null
+++ b/tests/functional/n/no/no_warning_docstring.py
@@ -0,0 +1,42 @@
+''' Test for inheritance '''
+from __future__ import print_function
+__revision__ = 1
+# pylint: disable=too-few-public-methods, using-constant-test, useless-object-inheritance
+class AAAA(object):
+ ''' class AAAA '''
+
+ def __init__(self):
+ pass
+
+ def method1(self):
+ ''' method 1 '''
+ print(self)
+
+ def method2(self):
+ ''' method 2 '''
+ print(self)
+
+class BBBB(AAAA):
+ ''' class BBBB '''
+
+ def __init__(self):
+ AAAA.__init__(self)
+
+ # should ignore docstring calling from class AAAA
+ def method1(self):
+ AAAA.method1(self)
+
+class CCCC(BBBB):
+ ''' class CCCC '''
+
+ def __init__(self):
+ BBBB.__init__(self)
+
+ # should ignore docstring since CCCC is inherited from BBBB which is
+ # inherited from AAAA containing method2
+ if __revision__:
+ def method2(self):
+ AAAA.method2(self)
+ else:
+ def method2(self):
+ AAAA.method1(self)
diff --git a/tests/functional/n/non/__init__.py b/tests/functional/n/non/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/n/non/__init__.py
diff --git a/tests/functional/n/non/non_ascii_name.py b/tests/functional/n/non/non_ascii_name.py
new file mode 100644
index 0000000..276a23f
--- /dev/null
+++ b/tests/functional/n/non/non_ascii_name.py
@@ -0,0 +1,6 @@
+""" Tests for non-ascii-name checker. """
+
+áéíóú = 4444 # [non-ascii-name]
+
+def úóíéá(): # [non-ascii-name]
+ """yo"""
diff --git a/tests/functional/n/non/non_ascii_name.rc b/tests/functional/n/non/non_ascii_name.rc
new file mode 100644
index 0000000..ff09ea1
--- /dev/null
+++ b/tests/functional/n/non/non_ascii_name.rc
@@ -0,0 +1,3 @@
+[testoptions]
+# This test cannot run on Windows due to Unicode error formatting.
+exclude_platforms=win32
diff --git a/tests/functional/n/non/non_ascii_name.txt b/tests/functional/n/non/non_ascii_name.txt
new file mode 100644
index 0000000..076d726
--- /dev/null
+++ b/tests/functional/n/non/non_ascii_name.txt
@@ -0,0 +1,2 @@
+non-ascii-name:3:0::"Constant name ""áéíóú"" contains a non-ASCII unicode character"
+non-ascii-name:5:0:úóíéá:"Function name ""úóíéá"" contains a non-ASCII unicode character"
diff --git a/tests/functional/n/non/non_init_parent_called.py b/tests/functional/n/non/non_init_parent_called.py
new file mode 100644
index 0000000..1ecc8f1
--- /dev/null
+++ b/tests/functional/n/non/non_init_parent_called.py
@@ -0,0 +1,51 @@
+# pylint: disable=protected-access,import-self,too-few-public-methods,line-too-long
+# pylint: disable=no-absolute-import,wrong-import-order, useless-object-inheritance,
+"""test for call to __init__ from a non ancestor class
+"""
+from __future__ import print_function
+from . import non_init_parent_called
+import nonexistant # [import-error]
+__revision__ = '$Id: non_init_parent_called.py,v 1.2 2004-09-29 08:35:13 syt Exp $'
+
+class AAAA(object):
+ """ancestor 1"""
+
+ def __init__(self):
+ print('init', self)
+ BBBBMixin.__init__(self) # [non-parent-init-called]
+
+class BBBBMixin(object):
+ """ancestor 2"""
+
+ def __init__(self):
+ print('init', self)
+
+class CCC(BBBBMixin, non_init_parent_called.AAAA, non_init_parent_called.BBBB, nonexistant.AClass): # [no-member]
+ """mix different things, some inferable some not"""
+ def __init__(self):
+ BBBBMixin.__init__(self)
+ non_init_parent_called.AAAA.__init__(self)
+ non_init_parent_called.BBBB.__init__(self) # [no-member]
+ nonexistant.AClass.__init__(self)
+
+class DDDD(AAAA):
+ """call superclass constructor in disjunct branches"""
+ def __init__(self, value):
+ if value:
+ AAAA.__init__(self)
+ else:
+ AAAA.__init__(self)
+
+class Super(dict):
+ """ test late binding super() call """
+ def __init__(self):
+ base = super()
+ base.__init__()
+
+class Super2(dict):
+ """ Using the same idiom as Super, but without calling
+ the __init__ method.
+ """
+ def __init__(self): # [super-init-not-called]
+ base = super()
+ base.__woohoo__() # [no-member]
diff --git a/tests/functional/n/non/non_init_parent_called.txt b/tests/functional/n/non/non_init_parent_called.txt
new file mode 100644
index 0000000..22073d6
--- /dev/null
+++ b/tests/functional/n/non/non_init_parent_called.txt
@@ -0,0 +1,6 @@
+import-error:7:0::Unable to import 'nonexistant'
+non-parent-init-called:15:8:AAAA.__init__:__init__ method from a non direct base class 'BBBBMixin' is called
+no-member:23:50:CCC:Module 'functional.n.non.non_init_parent_called' has no 'BBBB' member:INFERENCE
+no-member:28:8:CCC.__init__:Module 'functional.n.non.non_init_parent_called' has no 'BBBB' member:INFERENCE
+super-init-not-called:49:4:Super2.__init__:__init__ method from base class 'dict' is not called
+no-member:51:8:Super2.__init__:Super of 'Super2' has no '__woohoo__' member:INFERENCE
diff --git a/tests/functional/n/non/non_iterator_returned.py b/tests/functional/n/non/non_iterator_returned.py
new file mode 100644
index 0000000..94c3601
--- /dev/null
+++ b/tests/functional/n/non/non_iterator_returned.py
@@ -0,0 +1,101 @@
+"""Check non-iterators returned by __iter__ """
+
+# pylint: disable=too-few-public-methods, missing-docstring, no-self-use, useless-object-inheritance, consider-using-with
+
+
+class FirstGoodIterator(object):
+ """ yields in iterator. """
+
+ def __iter__(self):
+ for index in range(10):
+ yield index
+
+
+class SecondGoodIterator(object):
+ """ __iter__ and next """
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ """ Infinite iterator, but still an iterator """
+ return 1
+
+ def next(self):
+ """Same as __next__, but for Python 2."""
+ return 1
+
+
+class ThirdGoodIterator(object):
+ """ Returns other iterator, not the current instance """
+
+ def __iter__(self):
+ return SecondGoodIterator()
+
+
+class FourthGoodIterator(object):
+ """ __iter__ returns iter(...) """
+
+ def __iter__(self):
+ return iter(range(10))
+
+
+class IteratorMetaclass(type):
+ def __next__(cls):
+ return 1
+
+ def next(cls):
+ return 2
+
+
+class IteratorClass(object, metaclass=IteratorMetaclass):
+ """Iterable through the metaclass."""
+
+
+class FifthGoodIterator(object):
+ """__iter__ returns a class which uses an iterator-metaclass."""
+
+ def __iter__(self):
+ return IteratorClass
+
+
+class FileBasedIterator(object):
+ def __init__(self, path):
+ self.path = path
+ self.file = None
+
+ def __iter__(self):
+ if self.file is not None:
+ self.file.close()
+ self.file = open(self.path)
+ # self file has two infered values: None and <instance of 'file'>
+ # we don't want to emit error in this case
+ return self.file
+
+
+class FirstBadIterator(object):
+ """ __iter__ returns a list """
+
+ def __iter__(self): # [non-iterator-returned]
+ return []
+
+
+class SecondBadIterator(object):
+ """ __iter__ without next """
+
+ def __iter__(self): # [non-iterator-returned]
+ return self
+
+
+class ThirdBadIterator(object):
+ """ __iter__ returns an instance of another non-iterator """
+
+ def __iter__(self): # [non-iterator-returned]
+ return SecondBadIterator()
+
+
+class FourthBadIterator(object):
+ """__iter__ returns a class."""
+
+ def __iter__(self): # [non-iterator-returned]
+ return ThirdBadIterator
diff --git a/tests/functional/n/non/non_iterator_returned.txt b/tests/functional/n/non/non_iterator_returned.txt
new file mode 100644
index 0000000..a789482
--- /dev/null
+++ b/tests/functional/n/non/non_iterator_returned.txt
@@ -0,0 +1,4 @@
+non-iterator-returned:79:4:FirstBadIterator.__iter__:__iter__ returns non-iterator
+non-iterator-returned:86:4:SecondBadIterator.__iter__:__iter__ returns non-iterator
+non-iterator-returned:93:4:ThirdBadIterator.__iter__:__iter__ returns non-iterator
+non-iterator-returned:100:4:FourthBadIterator.__iter__:__iter__ returns non-iterator
diff --git a/tests/functional/n/non/non_str_assignment_to_dunder_name.py b/tests/functional/n/non/non_str_assignment_to_dunder_name.py
new file mode 100644
index 0000000..a910cbd
--- /dev/null
+++ b/tests/functional/n/non/non_str_assignment_to_dunder_name.py
@@ -0,0 +1,53 @@
+# pylint: disable=missing-module-docstring, missing-class-docstring
+# pylint: disable=too-few-public-methods, missing-function-docstring
+# pylint: disable=import-error
+
+import random
+
+from unknown import Unknown
+
+
+class ExampleClass():
+ pass
+
+
+def example_function():
+ pass
+
+
+def returns_str():
+ return "abcd"
+
+
+def returns_int():
+ return 0
+
+
+def returns_tuple():
+ return 0, "abc"
+
+
+# Might not be thorough if same hash seed is used in testing...
+def returns_random_type():
+ if random.randint(0, 1) > 0:
+ return 0
+
+ return "abc"
+
+ExampleClass.__name__ = 1 # [non-str-assignment-to-dunder-name]
+ExampleClass.__name__ = True # [non-str-assignment-to-dunder-name]
+ExampleClass.__name__ = returns_tuple() # [non-str-assignment-to-dunder-name]
+ExampleClass.__name__ = returns_int() # [non-str-assignment-to-dunder-name]
+ExampleClass.__name__ = "foo"
+ExampleClass.__name__ = returns_str()
+ExampleClass.__name__ = returns_random_type()
+ExampleClass.__name__ = Unknown
+
+example_function.__name__ = 1 # [non-str-assignment-to-dunder-name]
+example_function.__name__ = True # [non-str-assignment-to-dunder-name]
+example_function.__name__ = returns_tuple() # [non-str-assignment-to-dunder-name]
+example_function.__name__ = returns_int() # [non-str-assignment-to-dunder-name]
+example_function.__name__ = "foo"
+example_function.__name__ = returns_str()
+example_function.__name__ = returns_random_type()
+example_function.__name__ = Unknown
diff --git a/tests/functional/n/non/non_str_assignment_to_dunder_name.txt b/tests/functional/n/non/non_str_assignment_to_dunder_name.txt
new file mode 100644
index 0000000..b6cc0ce
--- /dev/null
+++ b/tests/functional/n/non/non_str_assignment_to_dunder_name.txt
@@ -0,0 +1,8 @@
+non-str-assignment-to-dunder-name:37:0::Non-string value assigned to __name__
+non-str-assignment-to-dunder-name:38:0::Non-string value assigned to __name__
+non-str-assignment-to-dunder-name:39:0::Non-string value assigned to __name__
+non-str-assignment-to-dunder-name:40:0::Non-string value assigned to __name__
+non-str-assignment-to-dunder-name:46:0::Non-string value assigned to __name__
+non-str-assignment-to-dunder-name:47:0::Non-string value assigned to __name__
+non-str-assignment-to-dunder-name:48:0::Non-string value assigned to __name__
+non-str-assignment-to-dunder-name:49:0::Non-string value assigned to __name__
diff --git a/tests/functional/n/none_dunder_protocols_py36.py b/tests/functional/n/none_dunder_protocols_py36.py
new file mode 100644
index 0000000..5573cee
--- /dev/null
+++ b/tests/functional/n/none_dunder_protocols_py36.py
@@ -0,0 +1,34 @@
+# pylint: disable=missing-docstring, too-few-public-methods,pointless-statement
+# pylint: disable=expression-not-assigned
+
+class MetaIterable(type):
+ __iter__ = None
+
+
+class MetaOldIterable(type):
+ __getitem__ = None
+
+
+class MetaContainer(type):
+ __contains__ = None
+
+
+class NonIterableClass(metaclass=MetaOldIterable):
+ __contains__ = None
+
+
+class OldNonIterableClass(metaclass=MetaOldIterable):
+ __contains__ = None
+
+
+class NonContainerClass(metaclass=MetaContainer):
+ __iter__ = None
+
+
+def test():
+ 1 in NonIterableClass # [unsupported-membership-test]
+ 1 in OldNonIterableClass # [unsupported-membership-test]
+ 1 in NonContainerClass # [unsupported-membership-test]
+ 1 in NonIterableClass() # [unsupported-membership-test]
+ 1 in OldNonIterableClass() # [unsupported-membership-test]
+ 1 in NonContainerClass() # [unsupported-membership-test]
diff --git a/tests/functional/n/none_dunder_protocols_py36.rc b/tests/functional/n/none_dunder_protocols_py36.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/n/none_dunder_protocols_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/n/none_dunder_protocols_py36.txt b/tests/functional/n/none_dunder_protocols_py36.txt
new file mode 100644
index 0000000..d550006
--- /dev/null
+++ b/tests/functional/n/none_dunder_protocols_py36.txt
@@ -0,0 +1,6 @@
+unsupported-membership-test:29:9:test:Value 'NonIterableClass' doesn't support membership test
+unsupported-membership-test:30:9:test:Value 'OldNonIterableClass' doesn't support membership test
+unsupported-membership-test:31:9:test:Value 'NonContainerClass' doesn't support membership test
+unsupported-membership-test:32:9:test:Value 'NonIterableClass()' doesn't support membership test
+unsupported-membership-test:33:9:test:Value 'OldNonIterableClass()' doesn't support membership test
+unsupported-membership-test:34:9:test:Value 'NonContainerClass()' doesn't support membership test
diff --git a/tests/functional/n/nonexistent_operator.py b/tests/functional/n/nonexistent_operator.py
new file mode 100644
index 0000000..f05a649
--- /dev/null
+++ b/tests/functional/n/nonexistent_operator.py
@@ -0,0 +1,15 @@
+"""check operator use"""
+# pylint: disable=invalid-name, pointless-statement
+a = 1
+a += 5
+a = +a
+b = ++a # [nonexistent-operator]
+++a # [nonexistent-operator]
+c = (++a) * b # [nonexistent-operator]
+
+a = 1
+a -= 5
+b = --a # [nonexistent-operator]
+b = a
+--a # [nonexistent-operator]
+c = (--a) * b # [nonexistent-operator]
diff --git a/tests/functional/n/nonexistent_operator.txt b/tests/functional/n/nonexistent_operator.txt
new file mode 100644
index 0000000..67d0646
--- /dev/null
+++ b/tests/functional/n/nonexistent_operator.txt
@@ -0,0 +1,6 @@
+nonexistent-operator:6:4::Use of the non-existent ++ operator
+nonexistent-operator:7:0::Use of the non-existent ++ operator
+nonexistent-operator:8:5::Use of the non-existent ++ operator
+nonexistent-operator:12:4::Use of the non-existent -- operator
+nonexistent-operator:14:0::Use of the non-existent -- operator
+nonexistent-operator:15:5::Use of the non-existent -- operator
diff --git a/tests/functional/n/nonlocal_and_global.py b/tests/functional/n/nonlocal_and_global.py
new file mode 100644
index 0000000..9400524
--- /dev/null
+++ b/tests/functional/n/nonlocal_and_global.py
@@ -0,0 +1,12 @@
+"""Test that a name is both nonlocal and global in the same scope."""
+# pylint: disable=missing-docstring,global-variable-not-assigned,invalid-name,nonlocal-without-binding
+
+def bad(): # [nonlocal-and-global]
+ nonlocal missing
+ global missing
+
+def good():
+ nonlocal missing
+ def test():
+ global missing
+ return test
diff --git a/tests/functional/n/nonlocal_and_global.rc b/tests/functional/n/nonlocal_and_global.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/n/nonlocal_and_global.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/n/nonlocal_and_global.txt b/tests/functional/n/nonlocal_and_global.txt
new file mode 100644
index 0000000..3b5668a
--- /dev/null
+++ b/tests/functional/n/nonlocal_and_global.txt
@@ -0,0 +1 @@
+nonlocal-and-global:4:0:bad:Name 'missing' is nonlocal and global
diff --git a/tests/functional/n/nonlocal_without_binding.py b/tests/functional/n/nonlocal_without_binding.py
new file mode 100644
index 0000000..be3c003
--- /dev/null
+++ b/tests/functional/n/nonlocal_without_binding.py
@@ -0,0 +1,42 @@
+""" Checks that reversed() receive proper argument """
+# pylint: disable=missing-docstring,invalid-name,unused-variable, useless-object-inheritance
+# pylint: disable=too-few-public-methods,no-self-use,no-absolute-import
+
+def test():
+ def parent():
+ a = 42
+ def stuff():
+ nonlocal a
+
+ c = 24
+ def parent2():
+ a = 42
+ def stuff():
+ def other_stuff():
+ nonlocal a
+ nonlocal c
+
+b = 42
+def func():
+ def other_func():
+ nonlocal b # [nonlocal-without-binding]
+
+class SomeClass(object):
+ nonlocal x # [nonlocal-without-binding]
+
+ def func(self):
+ nonlocal some_attr # [nonlocal-without-binding]
+
+
+def func2():
+ nonlocal_ = None
+ local = None
+
+ class Class:
+
+ nonlocal nonlocal_
+
+ nonlocal_ = 1
+ local = 1
+
+ return local + nonlocal_
diff --git a/tests/functional/n/nonlocal_without_binding.rc b/tests/functional/n/nonlocal_without_binding.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/n/nonlocal_without_binding.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/n/nonlocal_without_binding.txt b/tests/functional/n/nonlocal_without_binding.txt
new file mode 100644
index 0000000..df5595a
--- /dev/null
+++ b/tests/functional/n/nonlocal_without_binding.txt
@@ -0,0 +1,3 @@
+nonlocal-without-binding:22:8:func.other_func:nonlocal name b found without binding
+nonlocal-without-binding:25:4:SomeClass:nonlocal name x found without binding
+nonlocal-without-binding:28:8:SomeClass.func:nonlocal name some_attr found without binding
diff --git a/tests/functional/n/not_async_context_manager.py b/tests/functional/n/not_async_context_manager.py
new file mode 100644
index 0000000..138d76d
--- /dev/null
+++ b/tests/functional/n/not_async_context_manager.py
@@ -0,0 +1,71 @@
+"""Test that an async context manager receives a proper object."""
+# pylint: disable=missing-docstring, import-error, too-few-public-methods, useless-object-inheritance
+import contextlib
+
+from ala import Portocala
+
+
+@contextlib.contextmanager
+def ctx_manager():
+ yield
+
+
+class ContextManager(object):
+ def __enter__(self):
+ pass
+ def __exit__(self, *args):
+ pass
+
+class PartialAsyncContextManager(object):
+ def __aenter__(self):
+ pass
+
+class SecondPartialAsyncContextManager(object):
+ def __aexit__(self, *args):
+ pass
+
+class UnknownBases(Portocala):
+ def __aenter__(self):
+ pass
+
+
+class AsyncManagerMixin(object):
+ pass
+
+class GoodAsyncManager(object):
+ def __aenter__(self):
+ pass
+ def __aexit__(self, *args):
+ pass
+
+class InheritExit(object):
+ def __aexit__(self, *args):
+ pass
+
+class SecondGoodAsyncManager(InheritExit):
+ def __aenter__(self):
+ pass
+
+
+async def bad_coro():
+ async with 42: # [not-async-context-manager]
+ pass
+ async with ctx_manager(): # [not-async-context-manager]
+ pass
+ async with ContextManager(): # [not-async-context-manager]
+ pass
+ async with PartialAsyncContextManager(): # [not-async-context-manager]
+ pass
+ async with SecondPartialAsyncContextManager(): # [not-async-context-manager]
+ pass
+
+
+async def good_coro():
+ async with UnknownBases():
+ pass
+ async with AsyncManagerMixin():
+ pass
+ async with GoodAsyncManager():
+ pass
+ async with SecondGoodAsyncManager():
+ pass
diff --git a/tests/functional/n/not_async_context_manager.rc b/tests/functional/n/not_async_context_manager.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/n/not_async_context_manager.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/n/not_async_context_manager.txt b/tests/functional/n/not_async_context_manager.txt
new file mode 100644
index 0000000..01b4113
--- /dev/null
+++ b/tests/functional/n/not_async_context_manager.txt
@@ -0,0 +1,5 @@
+not-async-context-manager:51:4:bad_coro:Async context manager 'int' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:53:4:bad_coro:Async context manager 'generator' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:55:4:bad_coro:Async context manager 'ContextManager' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:57:4:bad_coro:Async context manager 'PartialAsyncContextManager' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:59:4:bad_coro:Async context manager 'SecondPartialAsyncContextManager' doesn't implement __aenter__ and __aexit__.
diff --git a/tests/functional/n/not_async_context_manager_py37.py b/tests/functional/n/not_async_context_manager_py37.py
new file mode 100644
index 0000000..c1ca269
--- /dev/null
+++ b/tests/functional/n/not_async_context_manager_py37.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring
+
+from contextlib import asynccontextmanager
+
+
+@asynccontextmanager
+async def context_manager(value):
+ yield value
+
+
+async with context_manager(42) as ans:
+ assert ans == 42
+
+
+def async_context_manager():
+ @asynccontextmanager
+ async def wrapper():
+ pass
+ return wrapper
+
+async def func():
+ async with async_context_manager():
+ pass
diff --git a/tests/functional/n/not_async_context_manager_py37.rc b/tests/functional/n/not_async_context_manager_py37.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/n/not_async_context_manager_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/n/not_callable.py b/tests/functional/n/not_callable.py
new file mode 100644
index 0000000..8d5b000
--- /dev/null
+++ b/tests/functional/n/not_callable.py
@@ -0,0 +1,125 @@
+# pylint: disable=missing-docstring,no-self-use,too-few-public-methods,wrong-import-position, useless-object-inheritance
+
+REVISION = None
+
+REVISION() # [not-callable]
+
+def correct():
+ return 1
+
+REVISION = correct()
+
+class Correct(object):
+ """callable object"""
+
+class MetaCorrect(object):
+ """callable object"""
+ def __call__(self):
+ return self
+
+INSTANCE = Correct()
+CALLABLE_INSTANCE = MetaCorrect()
+CORRECT = CALLABLE_INSTANCE()
+INCORRECT = INSTANCE() # [not-callable]
+LIST = []
+INCORRECT = LIST() # [not-callable]
+DICT = {}
+INCORRECT = DICT() # [not-callable]
+TUPLE = ()
+INCORRECT = TUPLE() # [not-callable]
+INT = 1
+INCORRECT = INT() # [not-callable]
+
+# Test calling properties. Pylint can detect when using only the
+# getter, but it doesn't infer properly when having a getter
+# and a setter.
+class MyProperty(property):
+ """ test subclasses """
+
+class PropertyTest(object):
+ """ class """
+
+ def __init__(self):
+ self.attr = 4
+
+ @property
+ def test(self):
+ """ Get the attribute """
+ return self.attr
+
+ @test.setter
+ def test(self, value):
+ """ Set the attribute """
+ self.attr = value
+
+ @MyProperty
+ def custom(self):
+ """ Get the attribute """
+ return self.attr
+
+ @custom.setter
+ def custom(self, value):
+ """ Set the attribute """
+ self.attr = value
+
+PROP = PropertyTest()
+PROP.test(40) # [not-callable]
+PROP.custom() # [not-callable]
+
+# Safe from not-callable when using properties.
+
+class SafeProperty(object):
+ @property
+ def static(self):
+ return staticmethod
+
+ @property
+ def klass(self):
+ return classmethod
+
+ @property
+ def get_lambda(self):
+ return lambda: None
+
+ @property
+ def other_function(self):
+ def function(arg):
+ return arg
+ return function
+
+ @property
+ def dict_builtin(self):
+ return dict
+
+ @property
+ def range_builtin(self):
+ return range
+
+ @property
+ def instance(self):
+ class Empty(object):
+ def __call__(self):
+ return 42
+ return Empty()
+
+ @property
+ def does_not_make_sense(self):
+ raise NotImplementedError
+
+PROP1 = SafeProperty()
+PROP1.static(2)
+PROP1.klass(2)
+PROP1.get_lambda()
+PROP1.other_function(4)
+PROP1.dict_builtin()
+PROP1.range_builtin(4)
+PROP1.instance()
+PROP1.does_not_make_sense()
+
+
+import missing # pylint: disable=import-error
+
+class UnknownBaseCallable(missing.Blah):
+ pass
+
+UnknownBaseCallable()()
diff --git a/tests/functional/n/not_callable.txt b/tests/functional/n/not_callable.txt
new file mode 100644
index 0000000..397e617
--- /dev/null
+++ b/tests/functional/n/not_callable.txt
@@ -0,0 +1,8 @@
+not-callable:5:0::REVISION is not callable
+not-callable:23:12::INSTANCE is not callable
+not-callable:25:12::LIST is not callable
+not-callable:27:12::DICT is not callable
+not-callable:29:12::TUPLE is not callable
+not-callable:31:12::INT is not callable
+not-callable:66:0::PROP.test is not callable
+not-callable:67:0::PROP.custom is not callable
diff --git a/tests/functional/n/not_context_manager.py b/tests/functional/n/not_context_manager.py
new file mode 100644
index 0000000..a59f5a2
--- /dev/null
+++ b/tests/functional/n/not_context_manager.py
@@ -0,0 +1,135 @@
+"""Tests that onjects used in a with statement implement context manager protocol"""
+
+# pylint: disable=too-few-public-methods, invalid-name, import-error, missing-docstring
+# pylint: disable=no-init,wrong-import-position, useless-object-inheritance
+# Tests no messages for objects that implement the protocol
+class Manager(object):
+ def __enter__(self):
+ pass
+ def __exit__(self, type_, value, traceback):
+ pass
+with Manager():
+ pass
+
+class AnotherManager(Manager):
+ pass
+with AnotherManager():
+ pass
+
+
+# Tests message for class that doesn't implement the protocol
+class NotAManager(object):
+ pass
+with NotAManager(): #[not-context-manager]
+ pass
+
+# Tests contextlib.contextmanager usage is recognized as correct.
+from contextlib import contextmanager
+@contextmanager
+def dec():
+ yield
+with dec(): # valid use
+ pass
+
+
+# Tests a message is produced when a contextlib.contextmanager
+# decorated function is used without being called.
+with dec: # [not-context-manager]
+ pass
+
+
+# Tests no messages about context manager protocol
+# if the type can't be inferred.
+from missing import Missing
+with Missing():
+ pass
+
+# Tests context managers as names.
+
+def penelopa():
+ return 42
+
+hopa = dec()
+tropa = penelopa()
+
+with tropa: # [not-context-manager]
+ pass
+
+with hopa:
+ pass
+
+
+# Tests that no messages are emitted for function calls
+# which return managers
+
+def wrapper():
+ return dec()
+
+with wrapper():
+ pass
+
+# Tests for properties returning managers.
+
+class Property(object):
+
+ @property
+ def ctx(self):
+ return dec()
+
+ @property
+ def not_ctx(self):
+ return 42
+
+
+lala = Property()
+with lala.ctx:
+ # Don't emit when the context manager is the
+ # result of accessing a property.
+ pass
+
+with lala.not_ctx: # [not-context-manager]
+ pass
+
+
+class TestKnownBases(Missing):
+ pass
+
+with TestKnownBases():
+ pass
+
+# Ignore mixins.
+class ManagerMixin(object):
+ def test(self):
+ with self:
+ pass
+
+class FullContextManager(ManagerMixin):
+ def __enter__(self):
+ return self
+ def __exit__(self, *args):
+ pass
+
+# Test a false positive with returning a generator
+# from a context manager.
+def generator():
+ yield 42
+
+@contextmanager
+def context_manager_returning_generator():
+ return generator()
+
+with context_manager_returning_generator():
+ pass
+
+FIRST = [context_manager_returning_generator()]
+with FIRST[0]:
+ pass
+
+def other_indirect_func():
+ return generator()
+
+def not_context_manager():
+ return other_indirect_func()
+
+with not_context_manager(): # [not-context-manager]
+ pass
diff --git a/tests/functional/n/not_context_manager.txt b/tests/functional/n/not_context_manager.txt
new file mode 100644
index 0000000..71b3af3
--- /dev/null
+++ b/tests/functional/n/not_context_manager.txt
@@ -0,0 +1,5 @@
+not-context-manager:23:0::Context manager 'NotAManager' doesn't implement __enter__ and __exit__.
+not-context-manager:37:0::Context manager 'dec' doesn't implement __enter__ and __exit__.
+not-context-manager:55:0::Context manager 'int' doesn't implement __enter__ and __exit__.
+not-context-manager:90:0::Context manager 'int' doesn't implement __enter__ and __exit__.
+not-context-manager:134:0::Context manager 'generator' doesn't implement __enter__ and __exit__.
diff --git a/tests/functional/n/not_in_loop.py b/tests/functional/n/not_in_loop.py
new file mode 100644
index 0000000..f7319ee
--- /dev/null
+++ b/tests/functional/n/not_in_loop.py
@@ -0,0 +1,55 @@
+"""Test that not-in-loop is detected properly."""
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods
+# pylint: disable=useless-else-on-loop, using-constant-test, useless-object-inheritance
+# pylint: disable=no-else-continue
+
+while True:
+ def ala():
+ continue # [not-in-loop]
+
+while True:
+ pass
+else:
+ continue # [not-in-loop]
+
+def lala():
+ continue # [not-in-loop]
+
+while True:
+ class A(object):
+ continue # [not-in-loop]
+
+for _ in range(10):
+ pass
+else:
+ continue # [not-in-loop]
+
+for _ in range(42):
+ pass
+else:
+ break # [not-in-loop]
+
+if True:
+ continue # [not-in-loop]
+else:
+ break # [not-in-loop]
+
+for _ in range(10):
+ for _ in range(20):
+ pass
+ else:
+ continue
+
+while True:
+ while True:
+ break
+ else:
+ break
+ break
+else:
+ pass
+
+for _ in range(1):
+ continue
+for _ in range(42):
+ break
diff --git a/tests/functional/n/not_in_loop.txt b/tests/functional/n/not_in_loop.txt
new file mode 100644
index 0000000..d4f82e5
--- /dev/null
+++ b/tests/functional/n/not_in_loop.txt
@@ -0,0 +1,8 @@
+not-in-loop:8:8:ala:'continue' not properly in loop
+not-in-loop:13:4::'continue' not properly in loop
+not-in-loop:16:4:lala:'continue' not properly in loop
+not-in-loop:20:8:A:'continue' not properly in loop
+not-in-loop:25:4::'continue' not properly in loop
+not-in-loop:30:4::'break' not properly in loop
+not-in-loop:33:4::'continue' not properly in loop
+not-in-loop:35:4::'break' not properly in loop
diff --git a/tests/functional/o/__init__.py b/tests/functional/o/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/o/__init__.py
diff --git a/tests/functional/o/object_as_class_attribute.py b/tests/functional/o/object_as_class_attribute.py
new file mode 100644
index 0000000..2ac729b
--- /dev/null
+++ b/tests/functional/o/object_as_class_attribute.py
@@ -0,0 +1,18 @@
+# pylint: disable=too-few-public-methods,useless-object-inheritance
+"""Test case for the problem described below :
+ - A class extends 'object'
+ - This class defines its own __init__()
+ * pylint will therefore check that baseclasses' init()
+ are called
+ - If this class defines an 'object' attribute, then pylint
+ will use this new definition when trying to retrieve
+ object.__init__()
+"""
+
+__revision__ = None
+
+class Statement(object):
+ """ ... """
+ def __init__(self):
+ pass
+ object = None
diff --git a/tests/functional/o/old_division_floats.py b/tests/functional/o/old_division_floats.py
new file mode 100644
index 0000000..8b39cde
--- /dev/null
+++ b/tests/functional/o/old_division_floats.py
@@ -0,0 +1,3 @@
+from __future__ import print_function
+
+print(float(1) / 2)
diff --git a/tests/functional/o/old_division_floats.rc b/tests/functional/o/old_division_floats.rc
new file mode 100644
index 0000000..fe413f4
--- /dev/null
+++ b/tests/functional/o/old_division_floats.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=all
+enable=old-division
diff --git a/tests/functional/o/old_division_manually.py b/tests/functional/o/old_division_manually.py
new file mode 100644
index 0000000..4eb48e9
--- /dev/null
+++ b/tests/functional/o/old_division_manually.py
@@ -0,0 +1,3 @@
+from __future__ import division, print_function
+
+print(1 / 3)
diff --git a/tests/functional/o/old_division_manually.rc b/tests/functional/o/old_division_manually.rc
new file mode 100644
index 0000000..fe413f4
--- /dev/null
+++ b/tests/functional/o/old_division_manually.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=all
+enable=old-division
diff --git a/tests/functional/o/overloaded_operator.py b/tests/functional/o/overloaded_operator.py
new file mode 100644
index 0000000..c305af6
--- /dev/null
+++ b/tests/functional/o/overloaded_operator.py
@@ -0,0 +1,21 @@
+# pylint: disable=missing-docstring,too-few-public-methods,useless-object-inheritance
+"""#3291"""
+from __future__ import print_function
+
+class Myarray(object):
+ def __init__(self, array):
+ self.array = array
+
+ def __mul__(self, val):
+ return Myarray(val)
+
+ def astype(self):
+ return "ASTYPE", self
+
+def randint(maximum):
+ if maximum is not None:
+ return Myarray([1, 2, 3]) * 2
+
+ return int(5)
+
+print(randint(1).astype()) # we don't wan't an error for astype access
diff --git a/tests/functional/p/__init__.py b/tests/functional/p/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/p/__init__.py
diff --git a/tests/functional/p/pattern_matching.py b/tests/functional/p/pattern_matching.py
new file mode 100644
index 0000000..50f190f
--- /dev/null
+++ b/tests/functional/p/pattern_matching.py
@@ -0,0 +1,24 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods
+
+class Point2D:
+ __match_args__ = ("x", "y")
+
+ def __init__(self, x, y):
+ self.x = x
+ self.y = y
+
+
+# Don't emit false-positive 'unused-variable' and 'undefined-varibable'
+var = 42
+match var:
+ case [*rest1]:
+ print(rest1)
+ case {**rest2}:
+ print(rest2)
+ case Point2D(0, a):
+ print(a)
+ case Point2D(x=0, y=b) as new_point:
+ print(b)
+ print(new_point)
+ case new_var:
+ print(new_var)
diff --git a/tests/functional/p/pattern_matching.rc b/tests/functional/p/pattern_matching.rc
new file mode 100644
index 0000000..68a8c8e
--- /dev/null
+++ b/tests/functional/p/pattern_matching.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.10
diff --git a/tests/functional/p/plugin_does_not_exists.py b/tests/functional/p/plugin_does_not_exists.py
new file mode 100644
index 0000000..8b31d23
--- /dev/null
+++ b/tests/functional/p/plugin_does_not_exists.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-docstring
+
+from shadok import ShadokInteger # [import-error]
+
+ShadokInteger("Buga ZoMeu")
diff --git a/tests/functional/p/plugin_does_not_exists.rc b/tests/functional/p/plugin_does_not_exists.rc
new file mode 100644
index 0000000..72e7c1a
--- /dev/null
+++ b/tests/functional/p/plugin_does_not_exists.rc
@@ -0,0 +1,3 @@
+[master]
+load-plugins=
+ pylint.extensions.check_does_not_exists_in_venv,
diff --git a/tests/functional/p/plugin_does_not_exists.txt b/tests/functional/p/plugin_does_not_exists.txt
new file mode 100644
index 0000000..8d5a79f
--- /dev/null
+++ b/tests/functional/p/plugin_does_not_exists.txt
@@ -0,0 +1 @@
+import-error:3:0::Unable to import 'shadok':HIGH
diff --git a/tests/functional/p/postponed_evaluation_activated.py b/tests/functional/p/postponed_evaluation_activated.py
new file mode 100644
index 0000000..3cc694d
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_activated.py
@@ -0,0 +1,28 @@
+# pylint: disable=missing-docstring,no-self-use,unused-argument,pointless-statement
+# pylint: disable=too-few-public-methods,no-name-in-module
+from __future__ import annotations
+
+
+class Class:
+ @classmethod
+ def from_string(cls, source) -> Class:
+ ...
+
+ def validate_b(self, obj: OtherClass) -> bool:
+ ...
+
+
+class OtherClass:
+ ...
+
+
+class Example:
+ obj: Other
+
+
+class Other:
+ ...
+
+
+class ExampleSelf:
+ next: ExampleSelf
diff --git a/tests/functional/p/postponed_evaluation_activated.rc b/tests/functional/p/postponed_evaluation_activated.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_activated.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/p/postponed_evaluation_activated_with_alias.py b/tests/functional/p/postponed_evaluation_activated_with_alias.py
new file mode 100644
index 0000000..4f47247
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_activated_with_alias.py
@@ -0,0 +1,28 @@
+# pylint: disable=missing-docstring,no-self-use,unused-argument,pointless-statement
+# pylint: disable=too-few-public-methods,no-name-in-module
+from __future__ import annotations as __annotations__
+
+
+class MyClass:
+ @classmethod
+ def from_string(cls, source) -> MyClass:
+ ...
+
+ def validate_b(self, obj: OtherClass) -> bool:
+ ...
+
+
+class OtherClass:
+ ...
+
+
+class Example:
+ obj: Other
+
+
+class Other:
+ ...
+
+
+class ExampleSelf:
+ next: ExampleSelf
diff --git a/tests/functional/p/postponed_evaluation_activated_with_alias.rc b/tests/functional/p/postponed_evaluation_activated_with_alias.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_activated_with_alias.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/p/postponed_evaluation_not_activated.py b/tests/functional/p/postponed_evaluation_not_activated.py
new file mode 100644
index 0000000..f892414
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_not_activated.py
@@ -0,0 +1,14 @@
+# pylint: disable=missing-docstring,no-self-use,unused-argument,pointless-statement
+# pylint: disable=too-few-public-methods
+
+class Class:
+ @classmethod
+ def from_string(cls, source) -> Class: # [undefined-variable]
+ ...
+
+ def validate_b(self, obj: OtherClass) -> bool: # [used-before-assignment]
+ ...
+
+
+class OtherClass:
+ ...
diff --git a/tests/functional/p/postponed_evaluation_not_activated.rc b/tests/functional/p/postponed_evaluation_not_activated.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_not_activated.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/p/postponed_evaluation_not_activated.txt b/tests/functional/p/postponed_evaluation_not_activated.txt
new file mode 100644
index 0000000..ece8a13
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_not_activated.txt
@@ -0,0 +1,2 @@
+undefined-variable:6:36:Class.from_string:Undefined variable 'Class'
+used-before-assignment:9:30:Class.validate_b:Using variable 'OtherClass' before assignment
diff --git a/tests/functional/p/postponed_evaluation_pep585.py b/tests/functional/p/postponed_evaluation_pep585.py
new file mode 100644
index 0000000..889155a
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585.py
@@ -0,0 +1,133 @@
+"""Test PEP 585 in combination with postponed evaluation PEP 563.
+
+This check requires Python 3.7 or 3.8!
+Testing with 3.8 only, to support TypedDict.
+"""
+# pylint: disable=missing-docstring,unused-argument,unused-import,too-few-public-methods,invalid-name,inherit-non-class,unsupported-binary-operation,wrong-import-position,ungrouped-imports,unused-variable
+from __future__ import annotations
+import collections
+import dataclasses
+import typing
+from dataclasses import dataclass
+from typing import Any, Dict, NamedTuple, TypedDict, Union, Tuple
+
+
+AliasInvalid = list[int] # [unsubscriptable-object]
+
+class CustomIntList(typing.List[int]):
+ pass
+
+class CustomIntListError(list[int]): # [unsubscriptable-object]
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(list[int], cast_variable) # [unsubscriptable-object]
+
+T = typing.TypeVar("T", list[int], str) # [unsubscriptable-object]
+
+(lambda x: 2)(list[int]) # [unsubscriptable-object]
+
+
+# Check typing.NamedTuple
+CustomNamedTuple = typing.NamedTuple(
+ "CustomNamedTuple", [("my_var", list[int])]) # [unsubscriptable-object]
+
+class CustomNamedTuple2(NamedTuple):
+ my_var: list[int]
+
+class CustomNamedTuple3(typing.NamedTuple):
+ my_var: list[int]
+
+
+# Check typing.TypedDict
+CustomTypedDict = TypedDict("CustomTypedDict", my_var=list[int]) # [unsubscriptable-object]
+
+CustomTypedDict2 = TypedDict("CustomTypedDict2", {"my_var": list[int]}) # [unsubscriptable-object]
+
+class CustomTypedDict3(TypedDict):
+ my_var: list[int]
+
+class CustomTypedDict4(typing.TypedDict):
+ my_var: list[int]
+
+
+# Check dataclasses
+def my_decorator(*args, **kwargs):
+ def wraps(*args, **kwargs):
+ pass
+ return wraps
+
+@dataclass
+class CustomDataClass:
+ my_var: list[int]
+
+@dataclasses.dataclass
+class CustomDataClass2:
+ my_var: list[int]
+
+@dataclass()
+class CustomDataClass3:
+ my_var: list[int]
+
+@my_decorator
+@dataclasses.dataclass
+class CustomDataClass4:
+ my_var: list[int]
+
+
+var1: set[int]
+var2: collections.OrderedDict[str, int]
+var3: dict[str, list[int]]
+var4: Dict[str, list[int]]
+var5: dict[tuple[int, int], str]
+var6: Dict[tuple[int, int], str]
+var7: list[list[int]]
+var8: tuple[list[int]]
+var9: int | list[str | int]
+var10: Union[list[str], None]
+var11: Union[Union[list[int], int]]
+
+def func(arg: list[int]):
+ pass
+
+def func2() -> list[int]:
+ pass
+
+Alias2 = Union[list[str], None] # [unsubscriptable-object]
+Alias3 = Union[Union[list[int], int]] # [unsubscriptable-object]
+Alias4 = Tuple[list[int]] # [unsubscriptable-object]
+Alias5 = Dict[str, list[int]] # [unsubscriptable-object]
+Alias6 = int | list[int] # [unsubscriptable-object]
+Alias7 = list[list[int]] # [unsubscriptable-object,unsubscriptable-object]
+
+
+import collections.abc
+import contextlib
+import re
+
+class OrderedDict:
+ pass
+
+var12: OrderedDict[str, int] # [unsubscriptable-object]
+var13: list[int]
+var14: collections.OrderedDict[str, int]
+var15: collections.Counter[int]
+var16: collections.abc.Iterable[int]
+var17: contextlib.AbstractContextManager[int]
+var18: re.Pattern[str]
+
+
+def func3():
+ AliasInvalid2 = list[int] # [unsubscriptable-object]
+ cast_variable2 = [1, 2, 3]
+ cast_variable2 = typing.cast(list[int], cast_variable2) # [unsubscriptable-object]
+ var19: list[int]
+
+def func4(arg=list[int]): # [unsubscriptable-object]
+ pass
+
+def func5(arg1: list[int], arg2=set[int]): # [unsubscriptable-object]
+ pass
+
+def func6(arg1: list[int], /, *args: tuple[str], arg2: set[int], **kwargs: dict[str, Any]):
+ pass
diff --git a/tests/functional/p/postponed_evaluation_pep585.rc b/tests/functional/p/postponed_evaluation_pep585.rc
new file mode 100644
index 0000000..35b185f
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.8
+max_pyver=3.9
diff --git a/tests/functional/p/postponed_evaluation_pep585.txt b/tests/functional/p/postponed_evaluation_pep585.txt
new file mode 100644
index 0000000..2d59589
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585.txt
@@ -0,0 +1,20 @@
+unsubscriptable-object:15:15::Value 'list' is unsubscriptable
+unsubscriptable-object:20:25:CustomIntListError:Value 'list' is unsubscriptable
+unsubscriptable-object:24:28::Value 'list' is unsubscriptable
+unsubscriptable-object:26:24::Value 'list' is unsubscriptable
+unsubscriptable-object:28:14::Value 'list' is unsubscriptable
+unsubscriptable-object:33:36::Value 'list' is unsubscriptable
+unsubscriptable-object:43:54::Value 'list' is unsubscriptable
+unsubscriptable-object:45:60::Value 'list' is unsubscriptable
+unsubscriptable-object:96:15::Value 'list' is unsubscriptable
+unsubscriptable-object:97:21::Value 'list' is unsubscriptable
+unsubscriptable-object:98:15::Value 'list' is unsubscriptable
+unsubscriptable-object:99:19::Value 'list' is unsubscriptable
+unsubscriptable-object:100:15::Value 'list' is unsubscriptable
+unsubscriptable-object:101:9::Value 'list' is unsubscriptable
+unsubscriptable-object:101:14::Value 'list' is unsubscriptable
+unsubscriptable-object:111:7::Value 'OrderedDict' is unsubscriptable
+unsubscriptable-object:121:20:func3:Value 'list' is unsubscriptable
+unsubscriptable-object:123:33:func3:Value 'list' is unsubscriptable
+unsubscriptable-object:126:14:func4:Value 'list' is unsubscriptable
+unsubscriptable-object:129:32:func5:Value 'set' is unsubscriptable
diff --git a/tests/functional/p/postponed_evaluation_pep585_error.py b/tests/functional/p/postponed_evaluation_pep585_error.py
new file mode 100644
index 0000000..71f09dc
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585_error.py
@@ -0,0 +1,116 @@
+"""Test PEP 585 without postponed evaluation. Everything should fail.
+
+This check requires Python 3.7 or Python 3.8!
+Testing with 3.8 only, to support TypedDict.
+"""
+# pylint: disable=missing-docstring,unused-argument,unused-import,too-few-public-methods,invalid-name,inherit-non-class,unsupported-binary-operation,unused-variable,line-too-long
+import collections
+import dataclasses
+import typing
+from dataclasses import dataclass
+from typing import Any, Dict, NamedTuple, TypedDict, Union
+
+
+AliasInvalid = list[int] # [unsubscriptable-object]
+
+class CustomIntList(typing.List[int]):
+ pass
+
+class CustomIntListError(list[int]): # [unsubscriptable-object]
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(list[int], cast_variable) # [unsubscriptable-object]
+
+T = typing.TypeVar("T", list[int], str) # [unsubscriptable-object]
+
+(lambda x: 2)(list[int]) # [unsubscriptable-object]
+
+
+# Check typing.NamedTuple
+CustomNamedTuple = typing.NamedTuple(
+ "CustomNamedTuple", [("my_var", list[int])]) # [unsubscriptable-object]
+
+class CustomNamedTuple2(NamedTuple):
+ my_var: list[int] # [unsubscriptable-object]
+
+class CustomNamedTuple3(typing.NamedTuple):
+ my_var: list[int] # [unsubscriptable-object]
+
+
+# Check typing.TypedDict
+CustomTypedDict = TypedDict("CustomTypedDict", my_var=list[int]) # [unsubscriptable-object]
+
+CustomTypedDict2 = TypedDict("CustomTypedDict2", {"my_var": list[int]}) # [unsubscriptable-object]
+
+class CustomTypedDict3(TypedDict):
+ my_var: list[int] # [unsubscriptable-object]
+
+class CustomTypedDict4(typing.TypedDict):
+ my_var: list[int] # [unsubscriptable-object]
+
+
+# Check dataclasses
+def my_decorator(*args, **kwargs):
+ def wraps(*args, **kwargs):
+ pass
+ return wraps
+
+@dataclass
+class CustomDataClass:
+ my_var: list[int] # [unsubscriptable-object]
+
+@dataclasses.dataclass
+class CustomDataClass2:
+ my_var: list[int] # [unsubscriptable-object]
+
+@dataclass()
+class CustomDataClass3:
+ my_var: list[int] # [unsubscriptable-object]
+
+@my_decorator
+@dataclasses.dataclass
+class CustomDataClass4:
+ my_var: list[int] # [unsubscriptable-object]
+
+
+var1: set[int] # [unsubscriptable-object]
+var2: collections.OrderedDict[str, int] # [unsubscriptable-object]
+var3: dict[str, list[int]] # [unsubscriptable-object,unsubscriptable-object]
+var4: Dict[str, list[int]] # [unsubscriptable-object]
+var5: dict[tuple[int, int], str] # [unsubscriptable-object,unsubscriptable-object]
+var6: Dict[tuple[int, int], str] # [unsubscriptable-object]
+var7: list[list[int]] # [unsubscriptable-object,unsubscriptable-object]
+var8: tuple[list[int]] # [unsubscriptable-object,unsubscriptable-object]
+var9: int | list[str | int] # [unsubscriptable-object]
+var10: Union[list[str], None] # [unsubscriptable-object]
+var11: Union[Union[list[int], int]] # [unsubscriptable-object]
+
+def func(arg: list[int]): # [unsubscriptable-object]
+ pass
+
+def func2() -> list[int]: # [unsubscriptable-object]
+ pass
+
+Alias2 = Union[list[str], None] # [unsubscriptable-object]
+Alias3 = Union[Union[list[int], int]] # [unsubscriptable-object]
+Alias5 = Dict[str, list[int]] # [unsubscriptable-object]
+Alias6 = int | list[int] # [unsubscriptable-object]
+Alias7 = list[list[int]] # [unsubscriptable-object,unsubscriptable-object]
+
+
+def func3():
+ AliasInvalid2 = list[int] # [unsubscriptable-object]
+ cast_variable2 = [1, 2, 3]
+ cast_variable2 = typing.cast(list[int], cast_variable2) # [unsubscriptable-object]
+ var12: list[int] # [unsubscriptable-object]
+
+def func4(var=list[int]): # [unsubscriptable-object]
+ pass
+
+def func5(arg1: list[int], arg2=set[int]): # [unsubscriptable-object,unsubscriptable-object]
+ pass
+
+def func6(arg1: list[int], /, *args: tuple[str], arg2: set[int], **kwargs: dict[str, Any]):
+ # -1:[unsubscriptable-object,unsubscriptable-object,unsubscriptable-object,unsubscriptable-object]
+ pass
diff --git a/tests/functional/p/postponed_evaluation_pep585_error.rc b/tests/functional/p/postponed_evaluation_pep585_error.rc
new file mode 100644
index 0000000..35b185f
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585_error.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.8
+max_pyver=3.9
diff --git a/tests/functional/p/postponed_evaluation_pep585_error.txt b/tests/functional/p/postponed_evaluation_pep585_error.txt
new file mode 100644
index 0000000..3949a62
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585_error.txt
@@ -0,0 +1,49 @@
+unsubscriptable-object:14:15::Value 'list' is unsubscriptable
+unsubscriptable-object:19:25:CustomIntListError:Value 'list' is unsubscriptable
+unsubscriptable-object:23:28::Value 'list' is unsubscriptable
+unsubscriptable-object:25:24::Value 'list' is unsubscriptable
+unsubscriptable-object:27:14::Value 'list' is unsubscriptable
+unsubscriptable-object:32:36::Value 'list' is unsubscriptable
+unsubscriptable-object:35:12:CustomNamedTuple2:Value 'list' is unsubscriptable
+unsubscriptable-object:38:12:CustomNamedTuple3:Value 'list' is unsubscriptable
+unsubscriptable-object:42:54::Value 'list' is unsubscriptable
+unsubscriptable-object:44:60::Value 'list' is unsubscriptable
+unsubscriptable-object:47:12:CustomTypedDict3:Value 'list' is unsubscriptable
+unsubscriptable-object:50:12:CustomTypedDict4:Value 'list' is unsubscriptable
+unsubscriptable-object:61:12:CustomDataClass:Value 'list' is unsubscriptable
+unsubscriptable-object:65:12:CustomDataClass2:Value 'list' is unsubscriptable
+unsubscriptable-object:69:12:CustomDataClass3:Value 'list' is unsubscriptable
+unsubscriptable-object:74:12:CustomDataClass4:Value 'list' is unsubscriptable
+unsubscriptable-object:77:6::Value 'set' is unsubscriptable
+unsubscriptable-object:78:6::Value 'collections.OrderedDict' is unsubscriptable
+unsubscriptable-object:79:6::Value 'dict' is unsubscriptable
+unsubscriptable-object:79:16::Value 'list' is unsubscriptable
+unsubscriptable-object:80:16::Value 'list' is unsubscriptable
+unsubscriptable-object:81:6::Value 'dict' is unsubscriptable
+unsubscriptable-object:81:11::Value 'tuple' is unsubscriptable
+unsubscriptable-object:82:11::Value 'tuple' is unsubscriptable
+unsubscriptable-object:83:6::Value 'list' is unsubscriptable
+unsubscriptable-object:83:11::Value 'list' is unsubscriptable
+unsubscriptable-object:84:12::Value 'list' is unsubscriptable
+unsubscriptable-object:84:6::Value 'tuple' is unsubscriptable
+unsubscriptable-object:85:12::Value 'list' is unsubscriptable
+unsubscriptable-object:86:13::Value 'list' is unsubscriptable
+unsubscriptable-object:87:19::Value 'list' is unsubscriptable
+unsubscriptable-object:89:14:func:Value 'list' is unsubscriptable
+unsubscriptable-object:92:15:func2:Value 'list' is unsubscriptable
+unsubscriptable-object:95:15::Value 'list' is unsubscriptable
+unsubscriptable-object:96:21::Value 'list' is unsubscriptable
+unsubscriptable-object:97:19::Value 'list' is unsubscriptable
+unsubscriptable-object:98:15::Value 'list' is unsubscriptable
+unsubscriptable-object:99:9::Value 'list' is unsubscriptable
+unsubscriptable-object:99:14::Value 'list' is unsubscriptable
+unsubscriptable-object:103:20:func3:Value 'list' is unsubscriptable
+unsubscriptable-object:105:33:func3:Value 'list' is unsubscriptable
+unsubscriptable-object:106:11:func3:Value 'list' is unsubscriptable
+unsubscriptable-object:108:14:func4:Value 'list' is unsubscriptable
+unsubscriptable-object:111:16:func5:Value 'list' is unsubscriptable
+unsubscriptable-object:111:32:func5:Value 'set' is unsubscriptable
+unsubscriptable-object:114:75:func6:Value 'dict' is unsubscriptable
+unsubscriptable-object:114:16:func6:Value 'list' is unsubscriptable
+unsubscriptable-object:114:55:func6:Value 'set' is unsubscriptable
+unsubscriptable-object:114:37:func6:Value 'tuple' is unsubscriptable
diff --git a/tests/functional/p/postponed_evaluation_pep585_py39.py b/tests/functional/p/postponed_evaluation_pep585_py39.py
new file mode 100644
index 0000000..98201a6
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585_py39.py
@@ -0,0 +1,128 @@
+"""Test PEP 585 works as expected, starting with Python 3.9"""
+# pylint: disable=missing-docstring,unused-argument,unused-import,too-few-public-methods,invalid-name,inherit-non-class,unsupported-binary-operation,wrong-import-position,ungrouped-imports,unused-variable
+import collections
+import dataclasses
+import typing
+from dataclasses import dataclass
+from typing import Any, Dict, NamedTuple, TypedDict, Union, Tuple
+
+
+AliasValid = list[int]
+
+class CustomIntList(typing.List[int]):
+ pass
+
+class CustomIntListError(list[int]):
+ pass
+
+cast_variable = [1, 2, 3]
+cast_variable = typing.cast(list[int], cast_variable)
+
+T = typing.TypeVar("T", list[int], str)
+
+(lambda x: 2)(list[int])
+
+
+# Check typing.NamedTuple
+CustomNamedTuple = typing.NamedTuple(
+ "CustomNamedTuple", [("my_var", list[int])])
+
+class CustomNamedTuple2(NamedTuple):
+ my_var: list[int]
+
+class CustomNamedTuple3(typing.NamedTuple):
+ my_var: list[int]
+
+
+# Check typing.TypedDict
+CustomTypedDict = TypedDict("CustomTypedDict", my_var=list[int])
+
+CustomTypedDict2 = TypedDict("CustomTypedDict2", {"my_var": list[int]})
+
+class CustomTypedDict3(TypedDict):
+ my_var: list[int]
+
+class CustomTypedDict4(typing.TypedDict):
+ my_var: list[int]
+
+
+# Check dataclasses
+def my_decorator(*args, **kwargs):
+ def wraps(*args, **kwargs):
+ pass
+ return wraps
+
+@dataclass
+class CustomDataClass:
+ my_var: list[int]
+
+@dataclasses.dataclass
+class CustomDataClass2:
+ my_var: list[int]
+
+@dataclass()
+class CustomDataClass3:
+ my_var: list[int]
+
+@my_decorator
+@dataclasses.dataclass
+class CustomDataClass4:
+ my_var: list[int]
+
+
+var1: set[int]
+var2: collections.OrderedDict[str, int]
+var3: dict[str, list[int]]
+var4: Dict[str, list[int]]
+var5: dict[tuple[int, int], str]
+var6: Dict[tuple[int, int], str]
+var7: list[list[int]]
+var8: tuple[list[int]]
+var9: int | list[str | int]
+var10: Union[list[str], None]
+var11: Union[Union[list[int], int]]
+
+def func(arg: list[int]):
+ pass
+
+def func2() -> list[int]:
+ pass
+
+Alias2 = Union[list[str], None]
+Alias3 = Union[Union[list[int], int]]
+Alias4 = Tuple[list[int]]
+Alias5 = Dict[str, list[int]]
+Alias6 = int | list[int]
+Alias7 = list[list[int]]
+
+
+import collections.abc
+import contextlib
+import re
+
+class OrderedDict:
+ pass
+
+var12: OrderedDict[str, int] # [unsubscriptable-object]
+var13: list[int]
+var14: collections.OrderedDict[str, int]
+var15: collections.Counter[int]
+var16: collections.abc.Iterable[int]
+var17: contextlib.AbstractContextManager[int]
+var18: re.Pattern[str]
+
+
+def func3():
+ AliasInvalid2 = list[int]
+ cast_variable2 = [1, 2, 3]
+ cast_variable2 = typing.cast(list[int], cast_variable2)
+ var19: list[int]
+
+def func4(var=list[int]):
+ pass
+
+def func5(arg1: list[int], arg2=set[int]):
+ pass
+
+def func6(arg1: list[int], /, *args: tuple[str], arg2: set[int], **kwargs: dict[str, Any]):
+ pass
diff --git a/tests/functional/p/postponed_evaluation_pep585_py39.rc b/tests/functional/p/postponed_evaluation_pep585_py39.rc
new file mode 100644
index 0000000..16b75ee
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585_py39.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.9
diff --git a/tests/functional/p/postponed_evaluation_pep585_py39.txt b/tests/functional/p/postponed_evaluation_pep585_py39.txt
new file mode 100644
index 0000000..e0d0010
--- /dev/null
+++ b/tests/functional/p/postponed_evaluation_pep585_py39.txt
@@ -0,0 +1 @@
+unsubscriptable-object:106:7::Value 'OrderedDict' is unsubscriptable
diff --git a/tests/functional/p/pragma_after_backslash.py b/tests/functional/p/pragma_after_backslash.py
new file mode 100644
index 0000000..4de44bd
--- /dev/null
+++ b/tests/functional/p/pragma_after_backslash.py
@@ -0,0 +1,10 @@
+"""Test that a pragma has an effect when separated by a backslash."""
+# pylint: disable=too-few-public-methods
+
+class Foo:
+ """block-disable test"""
+
+ def meth3(self):
+ """test one line disabling"""
+ print(self.bla) \
+ # pylint: disable=no-member
diff --git a/tests/functional/p/preferred_module.py b/tests/functional/p/preferred_module.py
new file mode 100644
index 0000000..ce1f1c2
--- /dev/null
+++ b/tests/functional/p/preferred_module.py
@@ -0,0 +1,5 @@
+"""Test preferred modules."""
+# pylint: disable=unused-import
+
+import json # [preferred-module]
+from re import search # [preferred-module]
diff --git a/tests/functional/p/preferred_module.rc b/tests/functional/p/preferred_module.rc
new file mode 100644
index 0000000..e0982e0
--- /dev/null
+++ b/tests/functional/p/preferred_module.rc
@@ -0,0 +1,2 @@
+[IMPORTS]
+preferred-modules=json:ujson,re:regex
diff --git a/tests/functional/p/preferred_module.txt b/tests/functional/p/preferred_module.txt
new file mode 100644
index 0000000..8ac3be3
--- /dev/null
+++ b/tests/functional/p/preferred_module.txt
@@ -0,0 +1,2 @@
+preferred-module:4:0::Prefer importing 'ujson' instead of 'json'
+preferred-module:5:0::Prefer importing 'regex' instead of 're'
diff --git a/tests/functional/p/property_affectation_py26.py b/tests/functional/p/property_affectation_py26.py
new file mode 100644
index 0000000..323cf2d
--- /dev/null
+++ b/tests/functional/p/property_affectation_py26.py
@@ -0,0 +1,24 @@
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+"""
+Simple test case for an annoying behavior in pylint.
+"""
+
+__revision__ = 'pouet'
+
+class Test(object):
+ """Smallest test case for reported issue."""
+
+ def __init__(self):
+ self._thing = None
+
+ @property
+ def myattr(self):
+ """Getter for myattr"""
+ return self._thing
+
+ @myattr.setter
+ def myattr(self, value):
+ """Setter for myattr."""
+ self._thing = value
+
+Test().myattr = 'grou'
diff --git a/tests/functional/p/property_with_parameters.py b/tests/functional/p/property_with_parameters.py
new file mode 100644
index 0000000..b210bb5
--- /dev/null
+++ b/tests/functional/p/property_with_parameters.py
@@ -0,0 +1,22 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+from abc import ABCMeta, abstractmethod
+
+
+class Cls:
+ @property
+ def attribute(self, param, param1): # [property-with-parameters]
+ return param + param1
+
+
+class MyClassBase(metaclass=ABCMeta):
+ """MyClassBase."""
+
+ @property
+ @abstractmethod
+ def example(self):
+ """Getter."""
+
+ @example.setter
+ @abstractmethod
+ def example(self, value):
+ """Setter."""
diff --git a/tests/functional/p/property_with_parameters.txt b/tests/functional/p/property_with_parameters.txt
new file mode 100644
index 0000000..732640c
--- /dev/null
+++ b/tests/functional/p/property_with_parameters.txt
@@ -0,0 +1 @@
+property-with-parameters:7:4:Cls.attribute:Cannot have defined parameters for properties
diff --git a/tests/functional/p/protected_access_access_different_scopes.py b/tests/functional/p/protected_access_access_different_scopes.py
new file mode 100644
index 0000000..dc09aa5
--- /dev/null
+++ b/tests/functional/p/protected_access_access_different_scopes.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+class MyClass:
+
+ async def method(self):
+ pass
+
+
+def function():
+ assert self.attr # [undefined-variable]
+
+
+def func():
+ self.attr += 2 # [undefined-variable]
diff --git a/tests/functional/p/protected_access_access_different_scopes.rc b/tests/functional/p/protected_access_access_different_scopes.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/p/protected_access_access_different_scopes.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/p/protected_access_access_different_scopes.txt b/tests/functional/p/protected_access_access_different_scopes.txt
new file mode 100644
index 0000000..17736cc
--- /dev/null
+++ b/tests/functional/p/protected_access_access_different_scopes.txt
@@ -0,0 +1,2 @@
+undefined-variable:9:11:function:Undefined variable 'self'
+undefined-variable:13:4:func:Undefined variable 'self'
diff --git a/tests/functional/p/protocol_classes.py b/tests/functional/p/protocol_classes.py
new file mode 100644
index 0000000..784da60
--- /dev/null
+++ b/tests/functional/p/protocol_classes.py
@@ -0,0 +1,34 @@
+# pylint: disable=missing-docstring
+import typing
+
+
+class Hasher(typing.Protocol):
+ """A hashing algorithm, e.g. :func:`hashlib.sha256`."""
+
+ def update(self, blob: bytes):
+ ...
+
+ def digest(self) -> bytes:
+ ...
+
+
+Generic = typing.TypeVar("Generic")
+
+
+class HasherGeneric(typing.Protocol[Generic]):
+ """A hashing algorithm, e.g. :func:`hashlib.sha256`."""
+ def update(self, blob: bytes):
+ ...
+ def digest(self) -> bytes:
+ ...
+
+
+class Protocol: #pylint:disable=too-few-public-methods
+ pass
+
+class HasherFake(Protocol):
+ """A hashing algorithm, e.g. :func:`hashlib.sha256`."""
+ def update(self, blob: bytes): # [no-self-use, unused-argument]
+ ...
+ def digest(self) -> bytes: # [no-self-use]
+ ...
diff --git a/tests/functional/p/protocol_classes.rc b/tests/functional/p/protocol_classes.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/p/protocol_classes.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/p/protocol_classes.txt b/tests/functional/p/protocol_classes.txt
new file mode 100644
index 0000000..f85953f
--- /dev/null
+++ b/tests/functional/p/protocol_classes.txt
@@ -0,0 +1,3 @@
+no-self-use:31:4:HasherFake.update:Method could be a function
+unused-argument:31:21:HasherFake.update:Unused argument 'blob':INFERENCE
+no-self-use:33:4:HasherFake.digest:Method could be a function
diff --git a/tests/functional/r/__init__.py b/tests/functional/r/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/r/__init__.py
diff --git a/tests/functional/r/raise/raise_missing_from.py b/tests/functional/r/raise/raise_missing_from.py
new file mode 100644
index 0000000..d23cefb
--- /dev/null
+++ b/tests/functional/r/raise/raise_missing_from.py
@@ -0,0 +1,157 @@
+# pylint:disable=missing-docstring, unreachable, using-constant-test, invalid-name, bare-except
+# pylint:disable=try-except-raise, undefined-variable, too-few-public-methods, superfluous-parens
+
+################################################################################
+# Positives:
+
+try:
+ 1 / 0
+except ZeroDivisionError:
+ # +1: [raise-missing-from]
+ raise KeyError
+
+try:
+ 1 / 0
+except ZeroDivisionError:
+ # Our algorithm doesn't have to be careful about the complicated expression below, because
+ # the exception above wasn't bound to a name.
+ # +1: [raise-missing-from]
+ raise (foo + bar).baz
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ # +1: [raise-missing-from]
+ raise KeyError
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ # +1: [raise-missing-from]
+ raise KeyError
+else:
+ pass
+finally:
+ pass
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ if 1:
+ if 1:
+ with whatever:
+ try:
+ # +1: [raise-missing-from]
+ raise KeyError
+ except:
+ pass
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ # +1: [raise-missing-from]
+ raise KeyError()
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ # +1: [raise-missing-from]
+ raise KeyError(whatever, whatever=whatever)
+
+
+################################################################################
+# Negatives (Same cases as above, except with `from`):
+
+try:
+ 1 / 0
+except ZeroDivisionError:
+ raise KeyError from foo
+
+try:
+ 1 / 0
+except ZeroDivisionError:
+ raise (foo + bar).baz from foo
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise KeyError from foo
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise KeyError from foo
+else:
+ pass
+finally:
+ pass
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ if 1:
+ if 1:
+ with whatever:
+ try:
+ raise KeyError from foo
+ except:
+ pass
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise KeyError() from foo
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise KeyError(whatever, whatever=whatever) from foo
+
+
+################################################################################
+# Other negatives:
+
+try:
+ 1 / 0
+except ZeroDivisionError:
+ raise
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise e
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ if 1:
+ if 1:
+ if 1:
+ raise e
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise e.with_traceback(e.__traceback__)
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ raise (e + 7)
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ def f():
+ raise KeyError
+
+try:
+ 1 / 0
+except ZeroDivisionError as e:
+ class Foo:
+ raise KeyError
diff --git a/tests/functional/r/raise/raise_missing_from.txt b/tests/functional/r/raise/raise_missing_from.txt
new file mode 100644
index 0000000..1513870
--- /dev/null
+++ b/tests/functional/r/raise/raise_missing_from.txt
@@ -0,0 +1,7 @@
+raise-missing-from:11:4::Consider explicitly re-raising using the 'from' keyword
+raise-missing-from:19:4::Consider explicitly re-raising using the 'from' keyword
+raise-missing-from:25:4::Consider explicitly re-raising using the 'from' keyword
+raise-missing-from:31:4::Consider explicitly re-raising using the 'from' keyword
+raise-missing-from:45:20::Consider explicitly re-raising using the 'from' keyword
+raise-missing-from:53:4::Consider explicitly re-raising using the 'from' keyword
+raise-missing-from:59:4::Consider explicitly re-raising using the 'from' keyword
diff --git a/tests/functional/r/raise/raising_format_tuple.py b/tests/functional/r/raise/raising_format_tuple.py
new file mode 100644
index 0000000..0f3a334
--- /dev/null
+++ b/tests/functional/r/raise/raising_format_tuple.py
@@ -0,0 +1,51 @@
+'''
+Complain about multi-argument exception constructors where the first argument
+contains a percent sign, thus suggesting a % string formatting was intended
+instead. The same holds for a string containing {...} suggesting str.format()
+was intended.
+'''
+
+def bad_percent(arg):
+ '''Raising a percent-formatted string and an argument'''
+ raise KeyError('Bad key: %r', arg) # [raising-format-tuple]
+
+def good_percent(arg):
+ '''Instead of passing multiple arguments, format the message'''
+ raise KeyError('Bad key: %r' % arg)
+
+def bad_multiarg(name, value):
+ '''Raising a formatted string and multiple additional arguments'''
+ raise ValueError('%s measures %.2f', name, value) # [raising-format-tuple]
+
+def good_multiarg(name, value):
+ '''The arguments have to be written as a tuple for formatting'''
+ raise ValueError('%s measures %.2f' % (name, value))
+
+def bad_braces(arg):
+ '''Curly braces as placeholders'''
+ raise KeyError('Bad key: {:r}', arg) # [raising-format-tuple]
+
+def good_braces(arg):
+ '''Call str.format() instead'''
+ raise KeyError('Bad key: {:r}'.format(arg))
+
+def bad_multistring(arg):
+ '''Multiple adjacent string literals'''
+ raise AssertionError( # [raising-format-tuple]
+ 'Long message about %s '
+ "split over several adjacent literals", arg)
+
+def bad_triplequote(arg):
+ '''String literals with triple quotes'''
+ raise AssertionError( # [raising-format-tuple]
+ '''Long message about %s
+ split over several adjacent literals''', arg)
+
+def bad_unicode(arg):
+ '''Unicode string literal'''
+ raise ValueError(u'Bad %s', arg) # [raising-format-tuple]
+
+def raise_something_without_name(arg):
+ '''Regression test for nodes without .node attribute'''
+ import standard_exceptions # pylint: disable=import-error,import-outside-toplevel
+ raise standard_exceptions.MyException(u'An %s', arg) # [raising-format-tuple]
diff --git a/tests/functional/r/raise/raising_format_tuple.txt b/tests/functional/r/raise/raising_format_tuple.txt
new file mode 100644
index 0000000..756fd10
--- /dev/null
+++ b/tests/functional/r/raise/raising_format_tuple.txt
@@ -0,0 +1,7 @@
+raising-format-tuple:10:4:bad_percent:Exception arguments suggest string formatting might be intended
+raising-format-tuple:18:4:bad_multiarg:Exception arguments suggest string formatting might be intended
+raising-format-tuple:26:4:bad_braces:Exception arguments suggest string formatting might be intended
+raising-format-tuple:34:4:bad_multistring:Exception arguments suggest string formatting might be intended
+raising-format-tuple:40:4:bad_triplequote:Exception arguments suggest string formatting might be intended
+raising-format-tuple:46:4:bad_unicode:Exception arguments suggest string formatting might be intended
+raising-format-tuple:51:4:raise_something_without_name:Exception arguments suggest string formatting might be intended
diff --git a/tests/functional/r/raise/raising_non_exception_py3.py b/tests/functional/r/raise/raising_non_exception_py3.py
new file mode 100644
index 0000000..7961c52
--- /dev/null
+++ b/tests/functional/r/raise/raising_non_exception_py3.py
@@ -0,0 +1,13 @@
+"""The following code should emit a raising-non-exception.
+
+Previously, it didn't, due to a bug in the check for bad-exception-context,
+which prevented further checking on the Raise node.
+"""
+# pylint: disable=import-error, too-few-public-methods, useless-object-inheritance
+
+from missing_module import missing
+
+class Exc(object):
+ """Not an actual exception."""
+
+raise Exc from missing # [raising-non-exception]
diff --git a/tests/functional/r/raise/raising_non_exception_py3.rc b/tests/functional/r/raise/raising_non_exception_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/r/raise/raising_non_exception_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/r/raise/raising_non_exception_py3.txt b/tests/functional/r/raise/raising_non_exception_py3.txt
new file mode 100644
index 0000000..9a2e494
--- /dev/null
+++ b/tests/functional/r/raise/raising_non_exception_py3.txt
@@ -0,0 +1 @@
+raising-non-exception:13:0::Raising a new style class which doesn't inherit from BaseException
diff --git a/tests/functional/r/raise/raising_self.py b/tests/functional/r/raise/raising_self.py
new file mode 100644
index 0000000..16f244b
--- /dev/null
+++ b/tests/functional/r/raise/raising_self.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-docstring
+
+class MultiException(Exception):
+ def __init__(self):
+ Exception.__init__(self)
+ def return_self(self):
+ return self
+
+
+raise MultiException().return_self()
diff --git a/tests/functional/r/recursion/recursion_error_2667.py b/tests/functional/r/recursion/recursion_error_2667.py
new file mode 100644
index 0000000..585cf7f
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_2667.py
@@ -0,0 +1,9 @@
+"""Add regression test for https://github.com/PyCQA/pylint/issues/2667"""
+# pylint: disable=missing-docstring, too-few-public-methods
+
+class MyClass:
+ def __init__(self):
+ self._slice = slice(0, 10)
+
+ def incr(self):
+ self._slice = slice(0, self._slice.stop + 1)
diff --git a/tests/functional/r/recursion/recursion_error_2836.py b/tests/functional/r/recursion/recursion_error_2836.py
new file mode 100644
index 0000000..9be68b2
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_2836.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring
+class Data:
+ def __init__(self):
+ self.shape = [None, 17]
+
+ @property
+ def ndim(self):
+ return len(self.shape)
+
+ def copy_move_axis(self, old_axis):
+ if old_axis < 0:
+ old_axis += self.ndim
+ assert old_axis >= 0
+ assert 0 <= old_axis < self.ndim
+
+ new_shape = [None] * self.ndim
+ self.shape = new_shape
+ return self
diff --git a/tests/functional/r/recursion/recursion_error_2861.py b/tests/functional/r/recursion/recursion_error_2861.py
new file mode 100644
index 0000000..03e0a54
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_2861.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring,redefined-builtin,unsubscriptable-object
+# pylint: disable=invalid-name,too-few-public-methods,attribute-defined-outside-init
+class Repository:
+ def _transfer(self, bytes=-1):
+ self._bytesTransfered = 0
+ bufff = True
+ while bufff and (bytes < 0 or self._bytesTransfered < bytes):
+ bufff = bufff[: bytes - self._bytesTransfered]
+ self._bytesTransfered += len(bufff)
diff --git a/tests/functional/r/recursion/recursion_error_2899.py b/tests/functional/r/recursion/recursion_error_2899.py
new file mode 100644
index 0000000..27ee287
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_2899.py
@@ -0,0 +1,9 @@
+# pylint: disable=global-statement,missing-docstring,disallowed-name
+foo = "test"
+
+
+def broken():
+ global foo
+
+ bar = len(foo)
+ foo = foo[bar]
diff --git a/tests/functional/r/recursion/recursion_error_2906.py b/tests/functional/r/recursion/recursion_error_2906.py
new file mode 100644
index 0000000..6b4b08d
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_2906.py
@@ -0,0 +1,14 @@
+"""Recursion error for https://github.com/PyCQA/pylint/issues/2906"""
+# pylint: disable=disallowed-name,global-statement,invalid-name,missing-docstring
+lst = []
+
+
+def foo():
+ lst.append(0)
+
+
+def bar():
+ global lst
+
+ length = len(lst)
+ lst += [length]
diff --git a/tests/functional/r/recursion/recursion_error_3152.py b/tests/functional/r/recursion/recursion_error_3152.py
new file mode 100644
index 0000000..97ec190
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_3152.py
@@ -0,0 +1,7 @@
+"""Check that we do not crash with a recursion error"""
+import setuptools
+
+
+# pylint: disable=missing-docstring,too-few-public-methods
+class Custom(setuptools.Command):
+ pass
diff --git a/tests/functional/r/recursion/recursion_error_3159.py b/tests/functional/r/recursion/recursion_error_3159.py
new file mode 100644
index 0000000..086cce7
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_3159.py
@@ -0,0 +1,26 @@
+"""Check that we do not crash with a recursion error
+
+https://github.com/PyCQA/pylint/issues/3159
+"""
+# pylint: disable=missing-docstring
+from setuptools import Command, find_packages, setup
+
+
+class AnyCommand(Command):
+ def initialize_options(self):
+ pass
+
+ def finalize_options(self):
+ pass
+
+ @staticmethod
+ def run():
+ print("Do anything")
+
+
+setup(
+ name="Thing",
+ version="1.0",
+ packages=find_packages(),
+ cmdclass={"anycommand": AnyCommand},
+)
diff --git a/tests/functional/r/recursion/recursion_error_940.py b/tests/functional/r/recursion/recursion_error_940.py
new file mode 100644
index 0000000..4a9f346
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_940.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+import datetime
+
+
+class NewDate(datetime.date):
+ @classmethod
+ def today(cls):
+ return cls(2010, 1, 1)
+
+
+class Next(object):
+ def __init__(self):
+ datetime.date = NewDate
diff --git a/tests/functional/r/recursion/recursion_error_crash.py b/tests/functional/r/recursion/recursion_error_crash.py
new file mode 100644
index 0000000..208bc2e
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_crash.py
@@ -0,0 +1,9 @@
+"""Test that a recursion error does not happen
+
+https://github.com/PyCQA/pylint/issues/2463
+"""
+import os
+
+ABC = os.path.realpath('abc')
+DEF = os.path.realpath(ABC + 'def')
+GHI = os.path.join(DEF, 'ghi')
diff --git a/tests/functional/r/recursion/recursion_error_crash_2683.py b/tests/functional/r/recursion/recursion_error_crash_2683.py
new file mode 100644
index 0000000..05978a3
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_crash_2683.py
@@ -0,0 +1,13 @@
+"""Test for https://github.com/PyCQA/pylint/issues/2683"""
+# pylint: disable=missing-docstring,too-few-public-methods
+
+class Cls:
+ def __init__(self):
+ self.count = 5
+
+ def method(self):
+ records = []
+ for _ in []:
+ records += []
+ records = records[:self.count]
+ records.sort()
diff --git a/tests/functional/r/recursion/recursion_error_crash_astroid_623.py b/tests/functional/r/recursion/recursion_error_crash_astroid_623.py
new file mode 100644
index 0000000..662da61
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_error_crash_astroid_623.py
@@ -0,0 +1,10 @@
+"""Test that a recursion error does not happen
+
+https://github.com/PyCQA/astroid/issues/623
+"""
+from os import path
+
+FIRST = path.normpath(path.dirname(path.realpath(__file__)))
+SECOND = path.normpath(path.abspath(path.join(FIRST, "..")))
+THIRD = path.normpath(path.abspath(path.join(SECOND, "..")))
+FOURTH = path.join(THIRD)
diff --git a/tests/functional/r/recursion/recursion_regression_2960.py b/tests/functional/r/recursion/recursion_regression_2960.py
new file mode 100644
index 0000000..96e0fbf
--- /dev/null
+++ b/tests/functional/r/recursion/recursion_regression_2960.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring
+from runpy import run_path
+
+_STH = run_path('hello.py')
diff --git a/tests/functional/r/redeclared_assigned_name.py b/tests/functional/r/redeclared_assigned_name.py
new file mode 100644
index 0000000..a2ff124
--- /dev/null
+++ b/tests/functional/r/redeclared_assigned_name.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring
+
+FIRST, FIRST = (1, 2) # [redeclared-assigned-name]
+
+for SECOND, SECOND in enumerate(range(5, 10)): # [redeclared-assigned-name]
+ print(SECOND)
+
+for FIRST, (SECOND, FIRST, SECOND) in enumerate(range(5, 10)): # [redeclared-assigned-name]
+ print(SECOND)
+
+for DUMM, DUMM in enumerate(range(5, 10)): # [redeclared-assigned-name]
+ print(DUMM)
+
+for DUMMY, DUMMY in enumerate(range(5, 10)):
+ print(DUMMY)
+
+for _, _ in enumerate(range(5, 10)):
+ print(_)
diff --git a/tests/functional/r/redeclared_assigned_name.rc b/tests/functional/r/redeclared_assigned_name.rc
new file mode 100644
index 0000000..3043c52
--- /dev/null
+++ b/tests/functional/r/redeclared_assigned_name.rc
@@ -0,0 +1,2 @@
+[BASIC]
+dummy-variables-rgx=DUMMY
diff --git a/tests/functional/r/redeclared_assigned_name.txt b/tests/functional/r/redeclared_assigned_name.txt
new file mode 100644
index 0000000..931c8a2
--- /dev/null
+++ b/tests/functional/r/redeclared_assigned_name.txt
@@ -0,0 +1,4 @@
+redeclared-assigned-name:3:0::Redeclared variable 'FIRST' in assignment
+redeclared-assigned-name:5:4::Redeclared variable 'SECOND' in assignment
+redeclared-assigned-name:8:11::Redeclared variable 'SECOND' in assignment
+redeclared-assigned-name:11:4::Redeclared variable 'DUMM' in assignment
diff --git a/tests/functional/r/redefine_loop.py b/tests/functional/r/redefine_loop.py
new file mode 100644
index 0000000..012ba13
--- /dev/null
+++ b/tests/functional/r/redefine_loop.py
@@ -0,0 +1,8 @@
+"""Test case for variable redefined in inner loop."""
+for item in range(0, 5):
+ print("hello")
+ for item in range(5, 10): #[redefined-outer-name]
+ print(item)
+ print("yay")
+ print(item)
+ print("done")
diff --git a/tests/functional/r/redefine_loop.txt b/tests/functional/r/redefine_loop.txt
new file mode 100644
index 0000000..dec738e
--- /dev/null
+++ b/tests/functional/r/redefine_loop.txt
@@ -0,0 +1 @@
+redefined-outer-name:4:4::Redefining name 'item' from outer scope (line 2)
diff --git a/tests/functional/r/redefined_argument_from_local.py b/tests/functional/r/redefined_argument_from_local.py
new file mode 100644
index 0000000..8202527
--- /dev/null
+++ b/tests/functional/r/redefined_argument_from_local.py
@@ -0,0 +1,67 @@
+# pylint: disable=missing-docstring, unused-variable, unused-argument
+# pylint: disable=redefined-outer-name, invalid-name
+
+def test_redefined_in_with(name):
+ with open('something') as name: # [redefined-argument-from-local]
+ pass
+ with open('something') as (second, name): # [redefined-argument-from-local]
+ pass
+ with open('something') as (second, (name, third)): # [redefined-argument-from-local]
+ pass
+ other = None
+ with open('something') as other:
+ pass
+
+
+
+def test_not_redefined_in_with(name):
+ with open('something') as test_redefined_in_with:
+ pass
+
+
+
+def test_redefined_in_for(name):
+ for name in []: # [redefined-argument-from-local]
+ pass
+ for (name, is_) in []: # [redefined-argument-from-local]
+ pass
+ for (is_, (name, _)) in []: # [redefined-argument-from-local]
+ pass
+ for _ in []:
+ pass
+
+
+def test_not_redefined_in_for(name):
+ for name_1 in []:
+ pass
+
+ # This one can be okay if you are interested in the last value
+ # of the iteration
+ other = None
+ for other in []:
+ pass
+
+
+def test_redefined_in_except_handler(name):
+ try:
+ 1 / 0
+ except ZeroDivisionError as name: # [redefined-argument-from-local]
+ pass
+
+
+def test_not_redefined_in_except_handler(name):
+ try:
+ 1 / 0
+ except ZeroDivisionError as test_redefined_in_except_handler:
+ pass
+
+
+def test_not_redefined(name):
+ if not name:
+ name = ''
+
+
+def apply_filter(objects, filt=lambda obj: True):
+ for obj in objects:
+ if filt(obj):
+ yield obj
diff --git a/tests/functional/r/redefined_argument_from_local.txt b/tests/functional/r/redefined_argument_from_local.txt
new file mode 100644
index 0000000..28ec50d
--- /dev/null
+++ b/tests/functional/r/redefined_argument_from_local.txt
@@ -0,0 +1,7 @@
+redefined-argument-from-local:5:30:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:7:39:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:9:40:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:24:8:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:26:9:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:28:15:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:48:4:test_redefined_in_except_handler:Redefining argument with the local name 'name'
diff --git a/tests/functional/r/redefined_builtin.py b/tests/functional/r/redefined_builtin.py
new file mode 100644
index 0000000..c840f8d
--- /dev/null
+++ b/tests/functional/r/redefined_builtin.py
@@ -0,0 +1,11 @@
+"""Tests for redefining builtins."""
+from __future__ import print_function
+
+def function():
+ """Redefined local."""
+ type = 1 # [redefined-builtin]
+ print(type)
+
+# pylint:disable=invalid-name
+map = {} # [redefined-builtin]
+__doc__ = 'reset the doc'
diff --git a/tests/functional/r/redefined_builtin.txt b/tests/functional/r/redefined_builtin.txt
new file mode 100644
index 0000000..8d65251
--- /dev/null
+++ b/tests/functional/r/redefined_builtin.txt
@@ -0,0 +1,2 @@
+redefined-builtin:6:4:function:Redefining built-in 'type'
+redefined-builtin:10:0::Redefining built-in 'map'
diff --git a/tests/functional/r/redefined_builtin_allowed.py b/tests/functional/r/redefined_builtin_allowed.py
new file mode 100644
index 0000000..ec7697d
--- /dev/null
+++ b/tests/functional/r/redefined_builtin_allowed.py
@@ -0,0 +1,9 @@
+"""Tests for redefining builtins."""
+
+def function():
+ """Allow some redefines."""
+ dir = "path" # allowed in config
+ dict = "wrong" # [redefined-builtin]
+ print(dir, dict)
+
+list = "not in globals" # [redefined-builtin]
diff --git a/tests/functional/r/redefined_builtin_allowed.rc b/tests/functional/r/redefined_builtin_allowed.rc
new file mode 100644
index 0000000..845729d
--- /dev/null
+++ b/tests/functional/r/redefined_builtin_allowed.rc
@@ -0,0 +1,4 @@
+[messages control]
+disable = invalid-name
+[variables]
+allowed-redefined-builtins = dir, list
diff --git a/tests/functional/r/redefined_builtin_allowed.txt b/tests/functional/r/redefined_builtin_allowed.txt
new file mode 100644
index 0000000..cd97f32
--- /dev/null
+++ b/tests/functional/r/redefined_builtin_allowed.txt
@@ -0,0 +1,2 @@
+redefined-builtin:6:4:function:Redefining built-in 'dict'
+redefined-builtin:9:0::Redefining built-in 'list'
diff --git a/tests/functional/r/redefined_outer_name_type_checking.py b/tests/functional/r/redefined_outer_name_type_checking.py
new file mode 100644
index 0000000..399fc8c
--- /dev/null
+++ b/tests/functional/r/redefined_outer_name_type_checking.py
@@ -0,0 +1,21 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,too-few-public-methods
+# pylint: disable=no-self-use,missing-function-docstring
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+
+class Cls:
+ def func(self, stuff: defaultdict):
+ # This import makes the definition work.
+ # pylint: disable=import-outside-toplevel
+ from collections import defaultdict
+
+ obj = defaultdict()
+ obj.update(stuff)
+ return obj
+
+
+if TYPE_CHECKING:
+ # This import makes the annotations work.
+ from collections import defaultdict
diff --git a/tests/functional/r/redefined_outer_name_type_checking.rc b/tests/functional/r/redefined_outer_name_type_checking.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/r/redefined_outer_name_type_checking.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/r/redundant_unittest_assert.py b/tests/functional/r/redundant_unittest_assert.py
new file mode 100644
index 0000000..b7efffc
--- /dev/null
+++ b/tests/functional/r/redundant_unittest_assert.py
@@ -0,0 +1,38 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+"""
+https://www.logilab.org/ticket/355
+If you are using assertTrue or assertFalse and the first argument is a
+constant(like a string), then the assert will always be true. Therefore,
+it should emit a warning message.
+"""
+
+import unittest
+
+@unittest.skip("don't run this")
+class Tests(unittest.TestCase):
+ def test_something(self):
+ ''' Simple test '''
+ some_var = 'It should be assertEqual'
+ # +1:[redundant-unittest-assert]
+ self.assertTrue('I meant assertEqual not assertTrue', some_var)
+ # +1:[redundant-unittest-assert]
+ self.assertFalse('I meant assertEqual not assertFalse', some_var)
+ # +1:[redundant-unittest-assert]
+ self.assertTrue(True, some_var)
+ # +1:[redundant-unittest-assert]
+ self.assertFalse(False, some_var)
+ # +1:[redundant-unittest-assert]
+ self.assertFalse(None, some_var)
+ # +1:[redundant-unittest-assert]
+ self.assertTrue(0, some_var)
+
+ self.assertTrue('should be' in some_var, some_var)
+ self.assertTrue(some_var, some_var)
+
+
+@unittest.skip("don't run this")
+class RegressionWithArgs(unittest.TestCase):
+ '''Don't fail if the bound method doesn't have arguments.'''
+
+ def test(self):
+ self.run()
diff --git a/tests/functional/r/redundant_unittest_assert.txt b/tests/functional/r/redundant_unittest_assert.txt
new file mode 100644
index 0000000..ad9d22a
--- /dev/null
+++ b/tests/functional/r/redundant_unittest_assert.txt
@@ -0,0 +1,6 @@
+redundant-unittest-assert:17:8:Tests.test_something:Redundant use of assertTrue with constant value 'I meant assertEqual not assertTrue'
+redundant-unittest-assert:19:8:Tests.test_something:Redundant use of assertFalse with constant value 'I meant assertEqual not assertFalse'
+redundant-unittest-assert:21:8:Tests.test_something:Redundant use of assertTrue with constant value True
+redundant-unittest-assert:23:8:Tests.test_something:Redundant use of assertFalse with constant value False
+redundant-unittest-assert:25:8:Tests.test_something:Redundant use of assertFalse with constant value None
+redundant-unittest-assert:27:8:Tests.test_something:Redundant use of assertTrue with constant value 0
diff --git a/tests/functional/r/regression/regression_1326_crash_uninferable.py b/tests/functional/r/regression/regression_1326_crash_uninferable.py
new file mode 100644
index 0000000..a42d44a
--- /dev/null
+++ b/tests/functional/r/regression/regression_1326_crash_uninferable.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring
+
+import socket
+
+RETRYABLE_EXCEPTIONS = (socket.error,)
+
+# pylint: disable=wrong-exception-operation
+def exception_handler():
+ try:
+ yield 1
+ except RETRYABLE_EXCEPTIONS + tuple():
+ yield 2
diff --git a/tests/functional/r/regression/regression_2306_enum_value.py b/tests/functional/r/regression/regression_2306_enum_value.py
new file mode 100644
index 0000000..0cc23c2
--- /dev/null
+++ b/tests/functional/r/regression/regression_2306_enum_value.py
@@ -0,0 +1,11 @@
+# pylint: disable=missing-docstring,invalid-name
+
+from enum import Enum
+
+class Color(Enum):
+ red = 1
+ green = 2
+ blue = 3
+
+ def __lt__(self, other):
+ return self.value < other.value
diff --git a/tests/functional/r/regression/regression_2443_duplicate_bases.py b/tests/functional/r/regression/regression_2443_duplicate_bases.py
new file mode 100644
index 0000000..f32490c
--- /dev/null
+++ b/tests/functional/r/regression/regression_2443_duplicate_bases.py
@@ -0,0 +1,28 @@
+# pylint: disable=missing-docstring, too-many-ancestors,too-few-public-methods
+from typing import Generic, TypeVar
+
+IN = TypeVar('IN', contravariant=True)
+OUT = TypeVar('OUT', covariant=True)
+
+
+class Service:
+ pass
+
+
+class ConsumingMixin(Generic[IN]):
+ pass
+
+
+class ProducingMixin(Generic[OUT]):
+ pass
+
+
+class StreamingMixin(Generic[IN, OUT], ConsumingMixin[IN], ProducingMixin[OUT]):
+ pass
+
+
+class Example(StreamingMixin[str, int], Service):
+ pass
+
+
+print(Example.__mro__)
diff --git a/tests/functional/r/regression/regression_2443_duplicate_bases.rc b/tests/functional/r/regression/regression_2443_duplicate_bases.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/r/regression/regression_2443_duplicate_bases.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/r/regression/regression_2937_ifexp.py b/tests/functional/r/regression/regression_2937_ifexp.py
new file mode 100644
index 0000000..55b2404
--- /dev/null
+++ b/tests/functional/r/regression/regression_2937_ifexp.py
@@ -0,0 +1,20 @@
+# pylint: disable=missing-docstring,no-else-return,using-constant-test
+def get_list():
+ return [1] if True else [2]
+
+
+def find_int():
+ return int(get_list()[0])
+
+
+def func():
+ if True:
+ return find_int()
+ else:
+ return find_int()
+
+
+def test():
+ resp = func()
+ assert resp / resp > 0
+ return resp
diff --git a/tests/functional/r/regression/regression_3091.py b/tests/functional/r/regression/regression_3091.py
new file mode 100644
index 0000000..8196db1
--- /dev/null
+++ b/tests/functional/r/regression/regression_3091.py
@@ -0,0 +1,6 @@
+# pylint: disable=too-few-public-methods,invalid-name,missing-docstring
+class MyClass():
+ fun = lambda self, x: x * 2
+ def __init__(self):
+ x = self.fun(1) # Crashes pylint 2.3.1
+ print(x)
diff --git a/tests/functional/r/regression/regression_3231_no_member_property.py b/tests/functional/r/regression/regression_3231_no_member_property.py
new file mode 100644
index 0000000..6cc9cd7
--- /dev/null
+++ b/tests/functional/r/regression/regression_3231_no_member_property.py
@@ -0,0 +1,20 @@
+# pylint: disable=missing-docstring
+from abc import ABCMeta, abstractmethod
+
+
+class Cls(metaclass=ABCMeta):
+ def __init__(self):
+ pass
+
+ @property
+ @abstractmethod
+ def values(self):
+ pass
+
+ @classmethod
+ def some_method(cls):
+ return cls.values.issubset({2, 3})
+
+
+class Subcls(Cls):
+ values = {1, 2, 3}
diff --git a/tests/functional/r/regression/regression_3416_unused_argument_raise.py b/tests/functional/r/regression/regression_3416_unused_argument_raise.py
new file mode 100644
index 0000000..9bc7617
--- /dev/null
+++ b/tests/functional/r/regression/regression_3416_unused_argument_raise.py
@@ -0,0 +1,14 @@
+"""Test that we emit unused-argument when a function uses `raise
+
+https://github.com/PyCQA/pylint/issues/3416
+"""
+
+# pylint:disable=raise-missing-from
+
+# +1: [unused-argument, unused-argument, unused-argument]
+def fun(arg_a, arg_b, arg_c) -> None:
+ """Routine docstring"""
+ try:
+ pass
+ except Exception:
+ raise RuntimeError("")
diff --git a/tests/functional/r/regression/regression_3416_unused_argument_raise.txt b/tests/functional/r/regression/regression_3416_unused_argument_raise.txt
new file mode 100644
index 0000000..44d7a62
--- /dev/null
+++ b/tests/functional/r/regression/regression_3416_unused_argument_raise.txt
@@ -0,0 +1,3 @@
+unused-argument:9:8:fun:Unused argument 'arg_a'
+unused-argument:9:15:fun:Unused argument 'arg_b'
+unused-argument:9:22:fun:Unused argument 'arg_c'
diff --git a/tests/functional/r/regression/regression_3535_double_enum_inherit.py b/tests/functional/r/regression/regression_3535_double_enum_inherit.py
new file mode 100644
index 0000000..374b5f8
--- /dev/null
+++ b/tests/functional/r/regression/regression_3535_double_enum_inherit.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,invalid-name
+# https://github.com/PyCQA/pylint/issues/3535
+
+import enum
+
+class A(enum.Enum):
+ pass
+
+class B(A):
+ x = enum.auto()
+
+print(B.__members__['x'])
diff --git a/tests/functional/r/regression/regression_3595_notcallable_collections.py b/tests/functional/r/regression/regression_3595_notcallable_collections.py
new file mode 100644
index 0000000..120b26a
--- /dev/null
+++ b/tests/functional/r/regression/regression_3595_notcallable_collections.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring,unused-import
+# https://github.com/PyCQA/pylint/issues/3595
+
+import collections
+
+class Example:
+ def __init__(self):
+ self.prev()
+ self.next()
+ def prev(self):
+ pass
+ def next(self):
+ pass
diff --git a/tests/functional/r/regression/regression_4221_object_instanceattr.py b/tests/functional/r/regression/regression_4221_object_instanceattr.py
new file mode 100644
index 0000000..4c346b1
--- /dev/null
+++ b/tests/functional/r/regression/regression_4221_object_instanceattr.py
@@ -0,0 +1,8 @@
+# pylint: disable=missing-docstring
+# https://github.com/PyCQA/pylint/issues/4221
+
+import random
+o = object()
+if random.choice([True, False]):
+ o.count = None
+"abc".count("a")
diff --git a/tests/functional/r/regression/regression_4358_unsubscriptable_enum.py b/tests/functional/r/regression/regression_4358_unsubscriptable_enum.py
new file mode 100644
index 0000000..63a9d77
--- /dev/null
+++ b/tests/functional/r/regression/regression_4358_unsubscriptable_enum.py
@@ -0,0 +1,9 @@
+# pylint: disable=pointless-statement,missing-docstring
+# https://github.com/PyCQA/pylint/issues/4358
+
+from enum import Enum
+
+class Foo(Enum):
+ BAR = 1
+
+Foo.__members__['BAR'] # <-- error: Value 'Foo.__members__' is unsubscriptable
diff --git a/tests/functional/r/regression/regression___file___global.py b/tests/functional/r/regression/regression___file___global.py
new file mode 100644
index 0000000..9ad2eed
--- /dev/null
+++ b/tests/functional/r/regression/regression___file___global.py
@@ -0,0 +1,8 @@
+"""test no crash on __file__ global"""
+
+def func():
+ """override __file__"""
+ global __file__ # [global-statement, redefined-builtin]
+ __file__ = 'hop'
+
+__revision__ = 'pouet'
diff --git a/tests/functional/r/regression/regression___file___global.txt b/tests/functional/r/regression/regression___file___global.txt
new file mode 100644
index 0000000..502b452
--- /dev/null
+++ b/tests/functional/r/regression/regression___file___global.txt
@@ -0,0 +1,2 @@
+global-statement:5:4:func:Using the global statement
+redefined-builtin:5:4:func:Redefining built-in '__file__'
diff --git a/tests/functional/r/regression/regression_implicit_none_with_no_return.py b/tests/functional/r/regression/regression_implicit_none_with_no_return.py
new file mode 100644
index 0000000..4e6fc4d
--- /dev/null
+++ b/tests/functional/r/regression/regression_implicit_none_with_no_return.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring,pointless-statement,invalid-name,no-self-use
+
+class A:
+ def func(self):
+ print('hello')
+
+ @property
+ def index(self):
+ print('world')
+
+
+# Since these are not assigned anywhere, assignment-from-none etc.
+# in typecheck does not warn
+
+a = A()
+# double call is workaround for #4426
+a.func()() # [not-callable]
+[1, 2, 3][a.index] # [invalid-sequence-index]
diff --git a/tests/functional/r/regression/regression_implicit_none_with_no_return.txt b/tests/functional/r/regression/regression_implicit_none_with_no_return.txt
new file mode 100644
index 0000000..5163b7b
--- /dev/null
+++ b/tests/functional/r/regression/regression_implicit_none_with_no_return.txt
@@ -0,0 +1,2 @@
+not-callable:17:0::a.func() is not callable
+invalid-sequence-index:18:0::Sequence index is not an int, slice, or instance with __index__
diff --git a/tests/functional/r/regression/regression_infer_call_result_3690.py b/tests/functional/r/regression/regression_infer_call_result_3690.py
new file mode 100644
index 0000000..0a4b40d
--- /dev/null
+++ b/tests/functional/r/regression/regression_infer_call_result_3690.py
@@ -0,0 +1,11 @@
+# pylint: disable-msg=missing-docstring,too-few-public-methods,using-constant-test # [deprecated-pragma]
+
+class Class:
+ @property
+ @classmethod
+ def func(cls):
+ pass
+
+
+if Class.func:
+ pass
diff --git a/tests/functional/r/regression/regression_infer_call_result_3690.txt b/tests/functional/r/regression/regression_infer_call_result_3690.txt
new file mode 100644
index 0000000..bd69d7f
--- /dev/null
+++ b/tests/functional/r/regression/regression_infer_call_result_3690.txt
@@ -0,0 +1 @@
+deprecated-pragma:1:0::"Pragma ""disable-msg"" is deprecated, use ""disable"" instead"
diff --git a/tests/functional/r/regression/regression_no_member_1078.py b/tests/functional/r/regression/regression_no_member_1078.py
new file mode 100644
index 0000000..b7be27d
--- /dev/null
+++ b/tests/functional/r/regression/regression_no_member_1078.py
@@ -0,0 +1,14 @@
+"""Make sure no-member is not emitted when modifying __doc__ via augmented assignment
+
+https://github.com/PyCQA/pylint/issues/1078
+"""
+# pylint: disable=too-few-public-methods,missing-class-docstring
+class Cls:
+ def test(self):
+ "a"
+
+ test.__doc__ += "b"
+
+
+print(Cls().test.__doc__)
+print(Cls.test.__doc__)
diff --git a/tests/functional/r/regression/regression_no_value_for_parameter.py b/tests/functional/r/regression/regression_no_value_for_parameter.py
new file mode 100644
index 0000000..6dd2ea4
--- /dev/null
+++ b/tests/functional/r/regression/regression_no_value_for_parameter.py
@@ -0,0 +1,42 @@
+# pylint: disable=missing-docstring,import-error
+import os
+
+from Unknown import Unknown
+
+
+class ConfigManager(Unknown):
+
+
+ RENAMED_SECTIONS = {
+ 'permissions': 'content'
+ }
+
+ def test(self):
+ self.RENAMED_SECTIONS.items() #@
+
+ def items(self, sectname, raw=True):
+ pass
+
+
+def func(*, key=None):
+ return key
+
+
+def varargs_good(*parts):
+ """All good"""
+ return os.path.join(*parts)
+
+
+def varargs_no_expr(*parts):
+ """False positive below this line"""
+ ret = os.path.join(*parts)
+ return ret
+
+
+def kwargs_good(**kwargs):
+ return func(**kwargs)
+
+
+def kwargs_no_expr(**kwargs):
+ ret = func(**kwargs)
+ return ret
diff --git a/tests/functional/r/regression/regression_posonly_args.py b/tests/functional/r/regression/regression_posonly_args.py
new file mode 100644
index 0000000..750b1f9
--- /dev/null
+++ b/tests/functional/r/regression/regression_posonly_args.py
@@ -0,0 +1,21 @@
+"""Test linting.
+
+This is only intended to test pylint support for python 3.8's
+positional-only arguments (PEP 570).
+"""
+
+
+class Foobar:
+ """Class for frobulating the Foobar."""
+
+ @classmethod
+ def buildme(cls, /, value):
+ """Construct object using alternate method."""
+ return cls(value).abc
+
+ def runme(self, qrs, /, xyz=None):
+ """Do something funcy."""
+ if self.abc and qrs and xyz:
+ print("found something else")
+
+ abc = 42
diff --git a/tests/functional/r/regression/regression_posonly_args.rc b/tests/functional/r/regression/regression_posonly_args.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/r/regression/regression_posonly_args.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/r/regression/regression_properties_in_class_context.py b/tests/functional/r/regression/regression_properties_in_class_context.py
new file mode 100644
index 0000000..6a06a70
--- /dev/null
+++ b/tests/functional/r/regression/regression_properties_in_class_context.py
@@ -0,0 +1,44 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+
+class Meta(type):
+ @property
+ def values(cls):
+ return ['foo', 'bar']
+
+
+class Parent(metaclass=Meta):
+ pass
+
+
+assert 'foo' in Parent.values # no warning
+for value in Parent.values: # no warning
+ print(value)
+
+
+class Child(Parent):
+ pass
+
+
+assert 'foo' in Child.values # false-positive: unsupported-membership-test
+for value in Child.values: # false-positive: not-an-iterable
+ print(value)
+
+
+class Meta2(type):
+ def a_method(cls): # pylint: disable=no-self-use
+ return [123]
+
+
+class Parent2(metaclass=Meta2):
+ @property
+ def a_method(self):
+ return "actually a property"
+
+
+class Child2(Parent2):
+ pass
+
+
+assert 123 in Child2.a_method # [unsupported-membership-test]
+for value in Child2.a_method: # [not-an-iterable]
+ print(value)
diff --git a/tests/functional/r/regression/regression_properties_in_class_context.txt b/tests/functional/r/regression/regression_properties_in_class_context.txt
new file mode 100644
index 0000000..9b754bd
--- /dev/null
+++ b/tests/functional/r/regression/regression_properties_in_class_context.txt
@@ -0,0 +1,2 @@
+unsupported-membership-test:42:14::Value 'Child2.a_method' doesn't support membership test
+not-an-iterable:43:13::Non-iterable value Child2.a_method is used in an iterating context
diff --git a/tests/functional/r/regression/regression_property_no_member_2641.py b/tests/functional/r/regression/regression_property_no_member_2641.py
new file mode 100644
index 0000000..083f78b
--- /dev/null
+++ b/tests/functional/r/regression/regression_property_no_member_2641.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring,unused-argument,too-few-public-methods
+# https://github.com/PyCQA/pylint/issues/2641
+from abc import ABCMeta, abstractmethod
+
+
+class Person(metaclass=ABCMeta):
+ @abstractmethod
+ def __init__(self, name, age):
+ self.name = name
+ self.age = age
+
+ @property
+ def name(self):
+ return self.__name
+
+ @name.setter
+ def name(self, value):
+ self.__name = value
+
+
+class Myself(Person):
+ def __init__(self, name, age, tel):
+ super().__init__(name, age)
+ self.tel = tel
+
+ @Person.name.setter
+ def name(self, value):
+ super(self.__class__, self.__class__).name.fset(self, "override")
+
+
+class Wife(Person):
+ def __init__(self, name, age, tel):
+ super().__init__(name, age)
+ self.tel = tel
+
+
+ms = Myself("Matheus Saraiva", 36, "988070350")
+wi = Wife("Joice Saraiva", 34, "999923554")
+
+print(wi.name)
diff --git a/tests/functional/r/regression/regression_property_no_member_3269.py b/tests/functional/r/regression/regression_property_no_member_3269.py
new file mode 100644
index 0000000..784dd90
--- /dev/null
+++ b/tests/functional/r/regression/regression_property_no_member_3269.py
@@ -0,0 +1,23 @@
+"""Calling a super property"""
+# pylint: disable=too-few-public-methods,invalid-name
+
+class A:
+ """A parent class"""
+
+ @property
+ def test(self):
+ """A property"""
+ return "test"
+
+
+class B:
+ """A child class"""
+
+ @property
+ def test(self):
+ """Overriding implementation of prop which calls the parent"""
+ return A.test.fget(self) + " overriden"
+
+
+if __name__ == "__main__":
+ print(B().test)
diff --git a/tests/functional/r/regression/regression_property_no_member_844.py b/tests/functional/r/regression/regression_property_no_member_844.py
new file mode 100644
index 0000000..759b7bf
--- /dev/null
+++ b/tests/functional/r/regression/regression_property_no_member_844.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-overridden-method
+# https://github.com/PyCQA/pylint/issues/844
+class Parent:
+ def __init__(self):
+ self.__thing = 'foo'
+
+ @property
+ def thing(self):
+ return self.__thing
+
+
+class Child(Parent):
+ @Parent.thing.getter
+ def thing(self):
+ return super().thing + '!'
+
+
+print(Child().thing)
diff --git a/tests/functional/r/regression/regression_property_no_member_870.py b/tests/functional/r/regression/regression_property_no_member_870.py
new file mode 100644
index 0000000..e89ae16
--- /dev/null
+++ b/tests/functional/r/regression/regression_property_no_member_870.py
@@ -0,0 +1,15 @@
+# pylint: disable=too-few-public-methods,invalid-name,missing-docstring
+# https://github.com/PyCQA/pylint/issues/870
+
+class X:
+ def __init__(self, val=None):
+ self._val = val
+ @property
+ def val(self):
+ return self._val
+ @val.setter
+ def val(self, value):
+ self._val = value
+
+if __name__ == '__main__':
+ print(X([]).val.append)
diff --git a/tests/functional/r/regression/regression_property_slots_2439.py b/tests/functional/r/regression/regression_property_slots_2439.py
new file mode 100644
index 0000000..91cf86c
--- /dev/null
+++ b/tests/functional/r/regression/regression_property_slots_2439.py
@@ -0,0 +1,22 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods
+# https://github.com/PyCQA/pylint/issues/2439
+class TestClass:
+ __slots__ = ["_i"]
+
+ def __init__(self):
+ self._i = 0
+
+ @property
+ def i(self):
+ return self._i
+
+ @i.setter
+ def i(self, v):
+ self._i = v
+
+ other = i
+
+
+instance = TestClass()
+instance.other = 42
+print(instance.i)
diff --git a/tests/functional/r/regression/regression_too_many_arguments_2335.py b/tests/functional/r/regression/regression_too_many_arguments_2335.py
new file mode 100644
index 0000000..d2759ad
--- /dev/null
+++ b/tests/functional/r/regression/regression_too_many_arguments_2335.py
@@ -0,0 +1,11 @@
+"""Test that `abc.ABCMeta.__new__` does not trigger too-many-function-arguments when referred
+
+https://github.com/PyCQA/pylint/issues/2335
+"""
+# pylint: disable=missing-class-docstring,unused-argument,arguments-differ
+from abc import ABCMeta
+
+
+class NodeCheckMetaClass(ABCMeta):
+ def __new__(cls, name, bases, namespace, **kwargs):
+ return ABCMeta.__new__(cls, name, bases, namespace)
diff --git a/tests/functional/r/reimport.py b/tests/functional/r/reimport.py
new file mode 100644
index 0000000..defe519
--- /dev/null
+++ b/tests/functional/r/reimport.py
@@ -0,0 +1,31 @@
+"""check reimport
+"""
+from __future__ import absolute_import, print_function
+
+# pylint: disable=using-constant-test,ungrouped-imports,wrong-import-position,import-outside-toplevel
+import os
+from os.path import join, exists
+import os # [reimported]
+import re as _re
+
+__revision__ = 0
+_re.match('yo', '.*')
+
+if __revision__:
+ print(os)
+ from os.path import exists # [reimported]
+ print(join, exists)
+
+def func(yooo):
+ """reimport in different scope"""
+ import os as ass # [reimported]
+ ass.remove(yooo)
+ import re # [reimported]
+ re.compile('.*')
+
+if 1: # pylint: disable=using-constant-test
+ import sys
+ print(sys.modules)
+else:
+ print('bla')
+ import sys
diff --git a/tests/functional/r/reimport.txt b/tests/functional/r/reimport.txt
new file mode 100644
index 0000000..c57d148
--- /dev/null
+++ b/tests/functional/r/reimport.txt
@@ -0,0 +1,4 @@
+reimported:8:0::Reimport 'os' (imported line 6)
+reimported:16:4::Reimport 'exists' (imported line 7)
+reimported:21:4:func:Reimport 'os' (imported line 6)
+reimported:23:4:func:Reimport 're' (imported line 9)
diff --git a/tests/functional/r/reimported.py b/tests/functional/r/reimported.py
new file mode 100644
index 0000000..03b07c4
--- /dev/null
+++ b/tests/functional/r/reimported.py
@@ -0,0 +1,44 @@
+# pylint: disable=missing-docstring,unused-import,import-error, wildcard-import,unused-wildcard-import,redefined-builtin,no-name-in-module,ungrouped-imports,wrong-import-order
+
+from time import sleep, sleep # [reimported]
+from lala import missing, missing # [reimported]
+
+import missing1
+import missing1 # [reimported]
+
+from collections import deque
+from itertools import deque # [reimported]
+
+from collections import OrderedDict
+from itertools import OrderedDict as NotOrderedDict
+
+from itertools import *
+from os import *
+
+# pylint: disable=misplaced-future
+from __future__ import absolute_import, print_function
+
+import sys
+
+import xml.etree.ElementTree
+from xml.etree import ElementTree # [reimported]
+
+from email import encoders
+import email.encoders # [reimported]
+
+import sys # [reimported] #pylint: disable=ungrouped-imports,wrong-import-order
+__revision__ = 0
+
+def no_reimport():
+ """docstring"""
+ import os #pylint: disable=import-outside-toplevel
+ print(os)
+
+
+def reimport():
+ """This function contains a reimport."""
+ import sys # [reimported,redefined-outer-name] #pylint: disable=import-outside-toplevel
+ del sys
+
+
+del sys, ElementTree, xml.etree.ElementTree, encoders, email.encoders
diff --git a/tests/functional/r/reimported.txt b/tests/functional/r/reimported.txt
new file mode 100644
index 0000000..f947012
--- /dev/null
+++ b/tests/functional/r/reimported.txt
@@ -0,0 +1,9 @@
+reimported:3:0::Reimport 'sleep' (imported line 3)
+reimported:4:0::Reimport 'missing' (imported line 4)
+reimported:7:0::Reimport 'missing1' (imported line 6)
+reimported:10:0::Reimport 'deque' (imported line 9)
+reimported:24:0::Reimport 'ElementTree' (imported line 23)
+reimported:27:0::Reimport 'email.encoders' (imported line 26)
+reimported:29:0::Reimport 'sys' (imported line 21)
+redefined-outer-name:40:4:reimport:Redefining name 'sys' from outer scope (line 16)
+reimported:40:4:reimport:Reimport 'sys' (imported line 21)
diff --git a/tests/functional/r/renamed_import_logging_not_lazy.py b/tests/functional/r/renamed_import_logging_not_lazy.py
new file mode 100644
index 0000000..e4ca1c3
--- /dev/null
+++ b/tests/functional/r/renamed_import_logging_not_lazy.py
@@ -0,0 +1,20 @@
+# pylint: disable=missing-docstring, too-few-public-methods, no-member
+
+from __future__ import absolute_import
+# Muck up the names in an effort to confuse...
+import logging as renamed_logging
+
+
+class Logger:
+ """Fake logger"""
+
+
+logger = renamed_logging.getLogger(__name__)
+fake_logger = Logger()
+
+# Statements that should be flagged
+renamed_logging.warning('%s, %s' % (4, 5)) # [logging-not-lazy]
+logger.warning('%s' % 5) # [logging-not-lazy]
+
+# Statements that should not be flagged:
+fake_logger.warn('%s' % 5)
diff --git a/tests/functional/r/renamed_import_logging_not_lazy.txt b/tests/functional/r/renamed_import_logging_not_lazy.txt
new file mode 100644
index 0000000..f60571e
--- /dev/null
+++ b/tests/functional/r/renamed_import_logging_not_lazy.txt
@@ -0,0 +1,2 @@
+logging-not-lazy:16:0::Use lazy % formatting in logging functions
+logging-not-lazy:17:0::Use lazy % formatting in logging functions
diff --git a/tests/functional/r/repeated_keyword.py b/tests/functional/r/repeated_keyword.py
new file mode 100644
index 0000000..786c53b
--- /dev/null
+++ b/tests/functional/r/repeated_keyword.py
@@ -0,0 +1,13 @@
+"""Check that a keyword is not repeated in a function call
+
+This is somehow related to redundant-keyword, but it's not the same.
+"""
+
+# pylint: disable=missing-docstring, invalid-name
+
+def test(a, b):
+ return a, b
+
+test(1, 24)
+test(1, b=24, **{})
+test(1, b=24, **{'b': 24}) # [repeated-keyword]
diff --git a/tests/functional/r/repeated_keyword.txt b/tests/functional/r/repeated_keyword.txt
new file mode 100644
index 0000000..29b23ef
--- /dev/null
+++ b/tests/functional/r/repeated_keyword.txt
@@ -0,0 +1 @@
+repeated-keyword:13:0::Got multiple values for keyword argument 'b' in function call
diff --git a/tests/functional/r/return_in_init.py b/tests/functional/r/return_in_init.py
new file mode 100644
index 0000000..bf0aa06
--- /dev/null
+++ b/tests/functional/r/return_in_init.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring,too-few-public-methods,useless-return, useless-object-inheritance
+
+class MyClass(object):
+
+ def __init__(self): # [return-in-init]
+ return 1
+
+class MyClass2(object):
+ """dummy class"""
+
+ def __init__(self):
+ return
+
+
+class MyClass3(object):
+ """dummy class"""
+
+ def __init__(self):
+ return None
+
+class MyClass5(object):
+ """dummy class"""
+
+ def __init__(self):
+ self.callable = lambda: (yield None)
diff --git a/tests/functional/r/return_in_init.txt b/tests/functional/r/return_in_init.txt
new file mode 100644
index 0000000..f7ecc37
--- /dev/null
+++ b/tests/functional/r/return_in_init.txt
@@ -0,0 +1 @@
+return-in-init:5:4:MyClass.__init__:Explicit return in __init__
diff --git a/tests/functional/r/return_outside_function.py b/tests/functional/r/return_outside_function.py
new file mode 100644
index 0000000..449dafd
--- /dev/null
+++ b/tests/functional/r/return_outside_function.py
@@ -0,0 +1,2 @@
+"""This is gramatically correct, but it's still a SyntaxError"""
+return # [return-outside-function]
diff --git a/tests/functional/r/return_outside_function.txt b/tests/functional/r/return_outside_function.txt
new file mode 100644
index 0000000..b4ae4f3
--- /dev/null
+++ b/tests/functional/r/return_outside_function.txt
@@ -0,0 +1 @@
+return-outside-function:2:0::Return outside function
diff --git a/tests/functional/r/reused_outer_loop_variable.py b/tests/functional/r/reused_outer_loop_variable.py
new file mode 100644
index 0000000..b244e99
--- /dev/null
+++ b/tests/functional/r/reused_outer_loop_variable.py
@@ -0,0 +1,37 @@
+"""Tests for redefining an outer loop variable."""
+from __future__ import print_function
+__revision__ = 0
+
+# Simple nested loop
+for i in range(10):
+ for i in range(10): #[redefined-outer-name]
+ print(i)
+
+# When outer loop unpacks a tuple
+for i, i_again in enumerate(range(10)):
+ for i in range(10): #[redefined-outer-name]
+ print(i, i_again)
+
+# When inner loop unpacks a tuple
+for i in range(10):
+ for i, i_again in range(10): #[redefined-outer-name]
+ print(i, i_again)
+
+# With nested tuple unpacks
+for (a, (b, c)) in [(1, (2, 3))]:
+ for i, a in range(10): #[redefined-outer-name]
+ print(i, a, b, c)
+
+# Ignores when in else
+for i in range(10):
+ print(i)
+ if i > 5:
+ break
+else:
+ for i in range(2):
+ print(i)
+
+# Ignores dummy variables
+for _ in range(10):
+ for _ in range(10):
+ print("Hello")
diff --git a/tests/functional/r/reused_outer_loop_variable.txt b/tests/functional/r/reused_outer_loop_variable.txt
new file mode 100644
index 0000000..8edec28
--- /dev/null
+++ b/tests/functional/r/reused_outer_loop_variable.txt
@@ -0,0 +1,4 @@
+redefined-outer-name:7:4::Redefining name 'i' from outer scope (line 6)
+redefined-outer-name:12:4::Redefining name 'i' from outer scope (line 11)
+redefined-outer-name:17:4::Redefining name 'i' from outer scope (line 16)
+redefined-outer-name:22:4::Redefining name 'a' from outer scope (line 21)
diff --git a/tests/functional/r/reused_outer_loop_variable_py3.py b/tests/functional/r/reused_outer_loop_variable_py3.py
new file mode 100644
index 0000000..6eaa1f5
--- /dev/null
+++ b/tests/functional/r/reused_outer_loop_variable_py3.py
@@ -0,0 +1,5 @@
+"""Python >= 3 tests for redefining an outer loop's variable."""
+
+for i, *j in [(1, 2, 3, 4)]:
+ for j in range(i): #[redefined-outer-name]
+ print(j)
diff --git a/tests/functional/r/reused_outer_loop_variable_py3.rc b/tests/functional/r/reused_outer_loop_variable_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/r/reused_outer_loop_variable_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/r/reused_outer_loop_variable_py3.txt b/tests/functional/r/reused_outer_loop_variable_py3.txt
new file mode 100644
index 0000000..dcc32e8
--- /dev/null
+++ b/tests/functional/r/reused_outer_loop_variable_py3.txt
@@ -0,0 +1 @@
+redefined-outer-name:4:4::Redefining name 'j' from outer scope (line 3)
diff --git a/tests/functional/s/__init__.py b/tests/functional/s/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/s/__init__.py
diff --git a/tests/functional/s/self/self_assigning_variable.py b/tests/functional/s/self/self_assigning_variable.py
new file mode 100644
index 0000000..c9f2781
--- /dev/null
+++ b/tests/functional/s/self/self_assigning_variable.py
@@ -0,0 +1,28 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+# pylint: disable=unpacking-non-sequence,attribute-defined-outside-init,invalid-name
+
+class Class:
+ pass
+
+CLS = Class()
+FIRST = 1
+# Not enough values on the right hand side
+FIRST, SECOND = FIRST
+# Not enough values on the left hand side
+FIRST = FIRST, SECOND
+# Not equivalent to a self assignment
+FIRST = (FIRST, )
+# Not assigning to an attribute
+CLS.FIRST = FIRST
+# Not a name on the right hand side
+FIRST = Class()
+FIRST = FIRST # [self-assigning-variable]
+FIRST, SECOND = FIRST, CLS.FIRST # [self-assigning-variable]
+
+
+FOO = 1
+FOO, = [FOO]
+
+
+class RedefinedModuleLevel:
+ FOO = FOO
diff --git a/tests/functional/s/self/self_assigning_variable.txt b/tests/functional/s/self/self_assigning_variable.txt
new file mode 100644
index 0000000..a1262de
--- /dev/null
+++ b/tests/functional/s/self/self_assigning_variable.txt
@@ -0,0 +1,2 @@
+self-assigning-variable:19:0::Assigning the same variable 'FIRST' to itself
+self-assigning-variable:20:0::Assigning the same variable 'FIRST' to itself
diff --git a/tests/functional/s/self/self_cls_assignment.py b/tests/functional/s/self/self_cls_assignment.py
new file mode 100644
index 0000000..4e63bb4
--- /dev/null
+++ b/tests/functional/s/self/self_cls_assignment.py
@@ -0,0 +1,47 @@
+"""Warning about assigning self/cls variable."""
+from __future__ import print_function
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+
+class Foo(object):
+ """Class with methods that check for self/cls assignment"""
+
+ # pylint: disable=no-self-argument,no-self-use
+ def self_foo(bar_):
+ """Instance method, should warn for bar"""
+ bar_ = 10 # [self-cls-assignment]
+
+ # pylint: disable=no-self-use
+ def self_foofoo(self, lala):
+ """Instance method, should warn for self"""
+ self = lala # [self-cls-assignment]
+
+ @classmethod
+ def cls_foo(cls):
+ """Class method, should warn for cls"""
+ cls = 'tada' # [self-cls-assignment]
+
+ # pylint: disable=unused-argument
+ @staticmethod
+ def static_foo(lala):
+ """Static method, no warnings"""
+ lala = 10
+
+
+# pylint: disable=unused-argument
+def free_foo(bar_, lala):
+ """Free function, no warnings"""
+ bar_ = lala
+
+
+class TestNonLocal:
+ """Test class for nonlocal assignment of self"""
+
+ def function(self, param):
+ """This function uses nonlocal to reassign self"""
+
+ def _set_param(param):
+ nonlocal self
+ self = param # [self-cls-assignment]
+
+ _set_param(param)
+ return self
diff --git a/tests/functional/s/self/self_cls_assignment.txt b/tests/functional/s/self/self_cls_assignment.txt
new file mode 100644
index 0000000..eeb2ca2
--- /dev/null
+++ b/tests/functional/s/self/self_cls_assignment.txt
@@ -0,0 +1,4 @@
+self-cls-assignment:11:8:Foo.self_foo:Invalid assignment to bar_ in method
+self-cls-assignment:16:8:Foo.self_foofoo:Invalid assignment to self in method
+self-cls-assignment:21:8:Foo.cls_foo:Invalid assignment to cls in method
+self-cls-assignment:44:12:TestNonLocal.function._set_param:Invalid assignment to self in method
diff --git a/tests/functional/s/signature_differs.py b/tests/functional/s/signature_differs.py
new file mode 100644
index 0000000..f4f80ca
--- /dev/null
+++ b/tests/functional/s/signature_differs.py
@@ -0,0 +1,32 @@
+# pylint: disable=too-few-public-methods, missing-docstring, no-self-use, useless-object-inheritance
+
+class Abcd(object):
+
+ def __init__(self):
+ self.aarg = False
+
+ def abcd(self, aaa=1, bbbb=None):
+ return aaa, bbbb
+
+ def args(self):
+ self.aarg = True
+
+
+class Cdef(Abcd):
+
+ def __init__(self, aaa):
+ Abcd.__init__(self)
+ self.aaa = aaa
+
+ def abcd(self, aaa, bbbb=None): # [signature-differs]
+ return aaa, bbbb
+
+
+class Ghij(Abcd):
+ def __init__(self, aaa):
+ Abcd.__init__(self)
+ self.aaa = aaa
+
+ def abcd(self, *args, **kwargs):
+ """Test that a method with variadics does not trigger the warning"""
+ return super().abcd(*args, **kwargs)
diff --git a/tests/functional/s/signature_differs.txt b/tests/functional/s/signature_differs.txt
new file mode 100644
index 0000000..5281903
--- /dev/null
+++ b/tests/functional/s/signature_differs.txt
@@ -0,0 +1 @@
+signature-differs:21:4:Cdef.abcd:Signature differs from overridden 'abcd' method
diff --git a/tests/functional/s/simplifiable/simplifiable_condition.py b/tests/functional/s/simplifiable/simplifiable_condition.py
new file mode 100644
index 0000000..32bf36a
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplifiable_condition.py
@@ -0,0 +1,36 @@
+"""Test that boolean conditions can be simplified"""
+# pylint: disable=pointless-statement
+
+
+def func(_):
+ """Pointless function"""
+
+
+CONSTANT = 100
+OTHER = 200
+
+# Simplifies any boolean expression that is coerced into a True/False value
+bool(CONSTANT or False) # [simplifiable-condition]
+assert CONSTANT or False # [simplifiable-condition]
+if CONSTANT and True: # [simplifiable-condition]
+ pass
+elif CONSTANT and True: # [simplifiable-condition]
+ pass
+while CONSTANT and True: # [simplifiable-condition]
+ break
+1 if CONSTANT or False else 2 # [simplifiable-condition]
+z = [x for x in range(10) if x or False] # [simplifiable-condition]
+
+# Simplifies recursively
+assert CONSTANT or (True and False) # [simplifiable-condition]
+assert True and CONSTANT and OTHER # [simplifiable-condition]
+assert (CONSTANT or False) and (OTHER or True) # [simplifiable-condition]
+
+# Will try to infer the truthiness of an expression as long as it doesn't contain any variables
+assert [] or CONSTANT # [simplifiable-condition]
+assert {} or CONSTANT # [simplifiable-condition]
+
+# Expressions not in one of the above situations will not emit a message
+CONSTANT or True
+bool(CONSTANT or OTHER)
+bool(func(CONSTANT or True))
diff --git a/tests/functional/s/simplifiable/simplifiable_condition.txt b/tests/functional/s/simplifiable/simplifiable_condition.txt
new file mode 100644
index 0000000..b3552b5
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplifiable_condition.txt
@@ -0,0 +1,12 @@
+simplifiable-condition:13:5::Boolean condition 'CONSTANT or False' may be simplified to 'CONSTANT'
+simplifiable-condition:14:7::Boolean condition 'CONSTANT or False' may be simplified to 'CONSTANT'
+simplifiable-condition:15:3::Boolean condition 'CONSTANT and True' may be simplified to 'CONSTANT'
+simplifiable-condition:17:5::Boolean condition 'CONSTANT and True' may be simplified to 'CONSTANT'
+simplifiable-condition:19:6::Boolean condition 'CONSTANT and True' may be simplified to 'CONSTANT'
+simplifiable-condition:21:5::Boolean condition 'CONSTANT or False' may be simplified to 'CONSTANT'
+simplifiable-condition:22:29::Boolean condition 'x or False' may be simplified to 'x'
+simplifiable-condition:25:7::Boolean condition 'CONSTANT or True and False' may be simplified to 'CONSTANT'
+simplifiable-condition:26:7::Boolean condition 'True and CONSTANT and OTHER' may be simplified to 'CONSTANT and OTHER'
+simplifiable-condition:27:7::Boolean condition '(CONSTANT or False) and (OTHER or True)' may be simplified to 'CONSTANT'
+simplifiable-condition:30:7::Boolean condition '[] or CONSTANT' may be simplified to 'CONSTANT'
+simplifiable-condition:31:7::Boolean condition '{} or CONSTANT' may be simplified to 'CONSTANT'
diff --git a/tests/functional/s/simplifiable/simplifiable_if_expression.py b/tests/functional/s/simplifiable/simplifiable_if_expression.py
new file mode 100644
index 0000000..bcfdf89
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplifiable_if_expression.py
@@ -0,0 +1,27 @@
+"""Test that some if expressions can be simplified."""
+
+# pylint: disable=missing-docstring, invalid-name
+
+
+def test_simplifiable_1(arg):
+ # Simple test that can be replaced by bool(arg)
+ return True if arg else False # [simplifiable-if-expression]
+
+def test_simplifiable_2(arg):
+ # Simple test that can be replaced by not arg
+ return False if arg else True # [simplifiable-if-expression]
+
+def test_simplifiable_3(arg):
+ # Simple test that can be replaced by arg == 1
+ return True if arg == 1 else False # [simplifiable-if-expression]
+
+def test_simplifiable_4(arg):
+ # Simple test that can be replaced by not (arg == 1)
+ return False if arg == 1 else True # [simplifiable-if-expression]
+
+def test_not_simplifiable(arg):
+ x = True if arg else True
+ y = 0 if arg else 1
+ t = False if arg != 1 else False
+ t2 = None if arg > 3 else False
+ return x, y, t, t2
diff --git a/tests/functional/s/simplifiable/simplifiable_if_expression.txt b/tests/functional/s/simplifiable/simplifiable_if_expression.txt
new file mode 100644
index 0000000..872df8c
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplifiable_if_expression.txt
@@ -0,0 +1,4 @@
+simplifiable-if-expression:8:11:test_simplifiable_1:The if expression can be replaced with 'bool(test)'
+simplifiable-if-expression:12:11:test_simplifiable_2:The if expression can be replaced with 'not test'
+simplifiable-if-expression:16:11:test_simplifiable_3:The if expression can be replaced with 'test'
+simplifiable-if-expression:20:11:test_simplifiable_4:The if expression can be replaced with 'not test'
diff --git a/tests/functional/s/simplifiable/simplifiable_if_statement.py b/tests/functional/s/simplifiable/simplifiable_if_statement.py
new file mode 100644
index 0000000..4d4c8b5
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplifiable_if_statement.py
@@ -0,0 +1,146 @@
+"""Test that some if statement tests can be simplified."""
+
+# pylint: disable=missing-docstring, invalid-name, no-else-return, arguments-out-of-order
+
+
+def test_simplifiable_1(arg):
+ # Simple test that can be replaced by bool(arg)
+ if arg: # [simplifiable-if-statement]
+ return True
+ else:
+ return False
+
+
+def test_simplifiable_2(arg, arg2):
+ # Can be reduced to bool(arg and not arg2)
+ if arg and not arg2: # [simplifiable-if-statement]
+ return True
+ else:
+ return False
+
+
+def test_simplifiable_3(arg, arg2):
+ # Can be reduced to bool(arg and not arg2)
+ if arg and not arg2: # [simplifiable-if-statement]
+ var = True
+ else:
+ var = False
+ return var
+
+
+def test_simplifiable_4(arg):
+ if arg:
+ var = True
+ else:
+ if arg == "arg1": # [simplifiable-if-statement]
+ return True
+ else:
+ return False
+ return var
+
+
+def test_not_necessarily_simplifiable_1(arg, arg2):
+ # Can be reduced to bool(not arg and not arg2) or to
+ # `not all(N)`, which is a bit harder to understand
+ # than `any(N)` when var should be False.
+ if arg or arg2:
+ var = False
+ else:
+ var = True
+ return var
+
+
+def test_not_necessarily_simplifiabile_2(arg):
+ # This could theoretically be reduced to `not arg or arg > 3`
+ # but the net result is that now the condition is harder to understand,
+ # because it requires understanding of an extra clause:
+ # * first, there is the negation of truthness with `not arg`
+ # * the second clause is `arg > 3`, which occurs when arg has a
+ # a truth value, but it implies that `arg > 3` is equivalent
+ # with `arg and arg > 3`, which means that the user must
+ # think about this assumption when evaluating `arg > 3`.
+ # The original form is easier to grasp.
+ if arg and arg <= 3:
+ return False
+ else:
+ return True
+
+
+def test_not_simplifiable_3(arg):
+ if arg:
+ test_not_necessarily_simplifiabile_2(arg)
+ test_not_necessarily_simplifiable_1(arg, arg)
+ return False
+ else:
+ if arg < 3:
+ test_simplifiable_3(arg, 42)
+ return True
+
+
+def test_not_simplifiable_4(arg):
+ # Not interested in multiple elifs
+ if arg == "any":
+ return True
+ elif test_not_simplifiable_3(arg) == arg:
+ return True
+ else:
+ return False
+
+
+def test_not_simplifiable_5(arg):
+ # Different actions in each branch
+ if arg == "any":
+ return True
+ else:
+ var = 42
+ return var
+
+
+def test_not_simplifiable_6(arg):
+ # Different actions in each branch
+ if arg == "any":
+ var = 42
+ else:
+ return True
+ return var
+
+def test_not_simplifiable_7(arg):
+ # Returning something different
+ if arg == "any":
+ return 4
+ else:
+ return 5
+
+
+def test_not_simplifiable_8(arg):
+ # Only one of the branch returns something boolean
+ if arg == "any":
+ return True
+ else:
+ return 0
+
+
+def test_not_simplifiable_9():
+ # Not the same targets
+ first = True
+ second = 1
+ third = [1]
+ fourth = False
+ fifth = False
+
+ if first and second in third:
+ fourth = True
+ else:
+ fifth = True
+ return fourth + fifth
+
+
+def test_not_simplifiable_10():
+ # Subscripts are not considered
+ object_type = 'read'
+ filter_kwargs = {}
+ if object_type == 'read':
+ filter_kwargs['a'] = True
+ else:
+ filter_kwargs['b'] = True
+ return filter_kwargs
diff --git a/tests/functional/s/simplifiable/simplifiable_if_statement.txt b/tests/functional/s/simplifiable/simplifiable_if_statement.txt
new file mode 100644
index 0000000..aa61f49
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplifiable_if_statement.txt
@@ -0,0 +1,4 @@
+simplifiable-if-statement:8:4:test_simplifiable_1:The if statement can be replaced with 'return bool(test)'
+simplifiable-if-statement:16:4:test_simplifiable_2:The if statement can be replaced with 'return bool(test)'
+simplifiable-if-statement:24:4:test_simplifiable_3:The if statement can be replaced with 'var = bool(test)'
+simplifiable-if-statement:35:8:test_simplifiable_4:The if statement can be replaced with 'return bool(test)'
diff --git a/tests/functional/s/simplifiable/simplify_chained_comparison.py b/tests/functional/s/simplifiable/simplify_chained_comparison.py
new file mode 100644
index 0000000..4be9fbe
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplify_chained_comparison.py
@@ -0,0 +1,89 @@
+"""Test that some boolean expression statement tests can be simplified."""
+
+# pylint: disable=missing-docstring, invalid-name, no-else-return, too-many-branches
+
+
+def test_simplify_chained_comparison_1():
+ a = 1
+ b = 2
+ c = 3
+ return a < b and b < c # [chained-comparison]
+
+
+def test_simplify_chained_comparison_2():
+ a = 1
+ return a < 10 and a > 1 # [chained-comparison]
+
+
+def test_simplify_chained_comparison_3():
+ a = 1
+ b = 2
+ c = 3
+ d = 4
+ if a < 10 and a > 1: # [chained-comparison]
+ pass
+ elif a > 1 and a < 10: # [chained-comparison]
+ pass
+ elif a > 1 and a <= 10: # [chained-comparison]
+ pass
+ elif a > 1 and a < 10 and b == 2: # [chained-comparison]
+ pass
+ elif a > 1 and c == b and a < 10: # [chained-comparison]
+ pass
+ elif a > 100 and c == b and a < 10: # [chained-comparison]
+ # In this comparison we are not checking whether left bound is actually
+ # lower than right bound or not.
+ pass
+ elif a < b and b < c: # [chained-comparison]
+ pass
+ elif a > b and b > c: # [chained-comparison]
+ pass
+ elif a < b and a == 1 and b < c: # [chained-comparison]
+ pass
+ elif a < b and b < c and c == 786: # [chained-comparison]
+ pass
+ elif a < b and b < 0 and c == 786: # [chained-comparison]
+ pass
+ elif a < b and c == 786 and b < 0: # [chained-comparison]
+ pass
+ elif c == 786 and b < 0 and a < b: # [chained-comparison]
+ pass
+ elif a < b < c and c < d: # [chained-comparison]
+ pass
+ elif b < c < d and a < b: # [chained-comparison]
+ pass
+ elif a < b < c and a < b and b < c: # [chained-comparison]
+ pass
+
+
+def test_not_simplify_chained_comparison_1():
+ a = 1
+ b = 2
+ c = 3
+ d = 4
+ if a < 10 and b > 1:
+ pass
+ elif a > 1 and b < 10:
+ pass
+ elif a > 1 and a == 10:
+ pass
+ elif a == 1 and b == 2:
+ pass
+ elif a > 1 and a > 10:
+ pass
+ elif a < 100 and a < 10:
+ pass
+ elif a < b and a < c:
+ pass
+ elif a < b and a == 1 and a < c:
+ pass
+ elif a < b and a < c and c == 786:
+ pass
+ elif a < b < c and b < d:
+ pass
+ elif a < b < c and a < d:
+ pass
+ elif b < c < d and a < c:
+ pass
+ elif b < c < d and a < d:
+ pass
diff --git a/tests/functional/s/simplifiable/simplify_chained_comparison.txt b/tests/functional/s/simplifiable/simplify_chained_comparison.txt
new file mode 100644
index 0000000..fe8d3c3
--- /dev/null
+++ b/tests/functional/s/simplifiable/simplify_chained_comparison.txt
@@ -0,0 +1,18 @@
+chained-comparison:10:11:test_simplify_chained_comparison_1:Simplify chained comparison between the operands
+chained-comparison:15:11:test_simplify_chained_comparison_2:Simplify chained comparison between the operands
+chained-comparison:23:7:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:25:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:27:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:29:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:31:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:33:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:37:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:39:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:41:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:43:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:45:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:47:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:49:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:51:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:53:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:55:9:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
diff --git a/tests/functional/s/singledispatch_functions_py3.py b/tests/functional/s/singledispatch_functions_py3.py
new file mode 100644
index 0000000..cfd4d87
--- /dev/null
+++ b/tests/functional/s/singledispatch_functions_py3.py
@@ -0,0 +1,76 @@
+# pylint: disable=missing-docstring,import-error,unused-import,assignment-from-no-return
+# pylint: disable=invalid-name, too-few-public-methods, useless-object-inheritance
+from __future__ import print_function
+from UNINFERABLE import uninferable_func
+
+try:
+ from functools import singledispatch
+except ImportError:
+ from singledispatch import singledispatch
+
+my_single_dispatch = singledispatch
+
+
+class FakeSingleDispatch(object):
+
+ @staticmethod
+ def register(function):
+ return function
+
+ def __call__(self, function):
+ return function
+
+fake_singledispatch_decorator = FakeSingleDispatch()
+
+@singledispatch
+def func(arg):
+ return arg
+
+
+@func.register(str)
+def _(arg):
+ return 42
+
+
+@func.register(float)
+@func.register(int)
+def _(arg):
+ return 42
+
+
+@my_single_dispatch
+def func2(arg):
+ return arg
+
+
+@func2.register(int)
+def _(arg):
+ return 42
+
+
+@singledispatch
+def with_extra_arg(arg, verbose=False):
+ if verbose:
+ print(arg)
+ return arg
+
+
+@with_extra_arg.register(str)
+def _(arg, verbose=False):
+ unused = 42 # [unused-variable]
+ return arg[::-1]
+
+
+@fake_singledispatch_decorator
+def not_single_dispatch(arg): # [unused-argument]
+ return 'not yet implemented'
+
+
+@fake_singledispatch_decorator.register(str)
+def bad_single_dispatch(arg): # [unused-argument]
+ return 42
+
+
+@fake_singledispatch_decorator.register(str)
+def bad_single_dispatch(arg): # [unused-argument, function-redefined]
+ return 24
diff --git a/tests/functional/s/singledispatch_functions_py3.rc b/tests/functional/s/singledispatch_functions_py3.rc
new file mode 100644
index 0000000..e481c3b
--- /dev/null
+++ b/tests/functional/s/singledispatch_functions_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+;https://bugs.python.org/issue10445
+min_pyver=3.4
diff --git a/tests/functional/s/singledispatch_functions_py3.txt b/tests/functional/s/singledispatch_functions_py3.txt
new file mode 100644
index 0000000..6b26e77
--- /dev/null
+++ b/tests/functional/s/singledispatch_functions_py3.txt
@@ -0,0 +1,5 @@
+unused-variable:60:4:_:Unused variable 'unused'
+unused-argument:65:24:not_single_dispatch:Unused argument 'arg'
+unused-argument:70:24:bad_single_dispatch:Unused argument 'arg'
+function-redefined:75:0:bad_single_dispatch:function already defined line 70
+unused-argument:75:24:bad_single_dispatch:Unused argument 'arg'
diff --git a/tests/functional/s/singleton_comparison.py b/tests/functional/s/singleton_comparison.py
new file mode 100644
index 0000000..d7ebdaf
--- /dev/null
+++ b/tests/functional/s/singleton_comparison.py
@@ -0,0 +1,20 @@
+# pylint: disable=missing-docstring, invalid-name, misplaced-comparison-constant,literal-comparison, comparison-with-itself
+x = 42
+a = x is None
+b = x == None # [singleton-comparison]
+c = x == True # [singleton-comparison]
+d = x == False # [singleton-comparison]
+e = True == True # [singleton-comparison]
+f = x is 1
+g = 123 is "123"
+h = None is x
+i = None == x # [singleton-comparison]
+
+j = x != True # [singleton-comparison]
+j1 = x != False # [singleton-comparison]
+j2 = x != None # [singleton-comparison]
+assert x == True # [singleton-comparison]
+assert x != False # [singleton-comparison]
+if x == True: # [singleton-comparison]
+ pass
+z = bool(x == True) # [singleton-comparison]
diff --git a/tests/functional/s/singleton_comparison.txt b/tests/functional/s/singleton_comparison.txt
new file mode 100644
index 0000000..0907dcb
--- /dev/null
+++ b/tests/functional/s/singleton_comparison.txt
@@ -0,0 +1,12 @@
+singleton-comparison:4:4::Comparison 'x == None' should be 'x is None'
+singleton-comparison:5:4::Comparison 'x == True' should be 'x is True' if checking for the singleton value True, or 'bool(x)' if testing for truthiness
+singleton-comparison:6:4::Comparison 'x == False' should be 'x is False' if checking for the singleton value False, or 'not x' if testing for falsiness
+singleton-comparison:7:4::Comparison 'True == True' should be 'True is True' if checking for the singleton value True, or 'bool(True)' if testing for truthiness
+singleton-comparison:11:4::Comparison 'None == x' should be 'None is x'
+singleton-comparison:13:4::Comparison 'x != True' should be 'x is not True' if checking for the singleton value True, or 'not x' if testing for falsiness
+singleton-comparison:14:5::Comparison 'x != False' should be 'x is not False' if checking for the singleton value False, or 'bool(x)' if testing for truthiness
+singleton-comparison:15:5::Comparison 'x != None' should be 'x is not None'
+singleton-comparison:16:7::Comparison 'x == True' should be 'x is True' if checking for the singleton value True, or 'x' if testing for truthiness
+singleton-comparison:17:7::Comparison 'x != False' should be 'x is not False' if checking for the singleton value False, or 'x' if testing for truthiness
+singleton-comparison:18:3::Comparison 'x == True' should be 'x is True' if checking for the singleton value True, or 'x' if testing for truthiness
+singleton-comparison:20:9::Comparison 'x == True' should be 'x is True' if checking for the singleton value True, or 'x' if testing for truthiness
diff --git a/tests/functional/s/slots_checks.py b/tests/functional/s/slots_checks.py
new file mode 100644
index 0000000..9cdcf97
--- /dev/null
+++ b/tests/functional/s/slots_checks.py
@@ -0,0 +1,101 @@
+""" Checks that classes uses valid __slots__ """
+
+# pylint: disable=too-few-public-methods, missing-docstring, no-absolute-import, useless-object-inheritance
+# pylint: disable=using-constant-test, wrong-import-position, no-else-return, line-too-long, unused-private-member
+from collections import deque
+
+def func():
+ if True:
+ return ("a", "b", "c")
+ else:
+ return [str(var) for var in range(3)]
+
+
+class NotIterable(object):
+ def __iter_(self):
+ """ do nothing """
+
+class Good(object):
+ __slots__ = ()
+
+class SecondGood(object):
+ __slots__ = []
+
+class ThirdGood(object):
+ __slots__ = ['a']
+
+class FourthGood(object):
+ __slots__ = ('a%s' % i for i in range(10))
+
+class FifthGood(object):
+ __slots__ = deque(["a", "b", "c"])
+
+class SixthGood(object):
+ __slots__ = {"a": "b", "c": "d"}
+
+class Bad(object): # [invalid-slots]
+ __slots__ = list
+
+class SecondBad(object): # [invalid-slots]
+ __slots__ = 1
+
+class ThirdBad(object):
+ __slots__ = ('a', 2) # [invalid-slots-object]
+
+class FourthBad(object): # [invalid-slots]
+ __slots__ = NotIterable()
+
+class FifthBad(object):
+ __slots__ = ("a", "b", "") # [invalid-slots-object]
+
+class SixthBad(object): # [single-string-used-for-slots]
+ __slots__ = "a"
+
+class SeventhBad(object): # [single-string-used-for-slots]
+ __slots__ = ('foo')
+
+class EighthBad(object): # [single-string-used-for-slots]
+ __slots__ = deque.__name__
+
+class PotentiallyGood(object):
+ __slots__ = func()
+
+class PotentiallySecondGood(object):
+ __slots__ = ('a', deque.__name__)
+
+
+class Metaclass(type):
+
+ def __iter__(cls):
+ for value in range(10):
+ yield str(value)
+
+
+class IterableClass(object, metaclass=Metaclass):
+ pass
+
+class PotentiallyThirdGood(object):
+ __slots__ = IterableClass
+
+class PotentiallyFourthGood(object):
+ __slots__ = Good.__slots__
+
+
+class ValueInSlotConflict(object):
+ __slots__ = ('first', 'second', 'third', 'fourth') # [class-variable-slots-conflict, class-variable-slots-conflict, class-variable-slots-conflict]
+ first = None
+
+ @property
+ def third(self):
+ return 42
+
+ def fourth(self):
+ return self.third
+
+
+class Parent(object):
+ first = 42
+
+
+class ChildNotAffectedByValueInSlot(Parent):
+ __slots__ = ('first', )
diff --git a/tests/functional/s/slots_checks.txt b/tests/functional/s/slots_checks.txt
new file mode 100644
index 0000000..ffe82f8
--- /dev/null
+++ b/tests/functional/s/slots_checks.txt
@@ -0,0 +1,11 @@
+invalid-slots:36:0:Bad:Invalid __slots__ object
+invalid-slots:39:0:SecondBad:Invalid __slots__ object
+invalid-slots-object:43:22:ThirdBad:Invalid object '2' in __slots__, must contain only non empty strings
+invalid-slots:45:0:FourthBad:Invalid __slots__ object
+invalid-slots-object:49:27:FifthBad:"Invalid object ""''"" in __slots__, must contain only non empty strings"
+single-string-used-for-slots:51:0:SixthBad:Class __slots__ should be a non-string iterable
+single-string-used-for-slots:54:0:SeventhBad:Class __slots__ should be a non-string iterable
+single-string-used-for-slots:57:0:EighthBad:Class __slots__ should be a non-string iterable
+class-variable-slots-conflict:85:17:ValueInSlotConflict:Value 'first' in slots conflicts with class variable
+class-variable-slots-conflict:85:45:ValueInSlotConflict:Value 'fourth' in slots conflicts with class variable
+class-variable-slots-conflict:85:36:ValueInSlotConflict:Value 'third' in slots conflicts with class variable
diff --git a/tests/functional/s/socketerror_import.py b/tests/functional/s/socketerror_import.py
new file mode 100644
index 0000000..df5de29
--- /dev/null
+++ b/tests/functional/s/socketerror_import.py
@@ -0,0 +1,6 @@
+"""ds"""
+from __future__ import absolute_import, print_function
+from socket import error
+__revision__ = '$Id: socketerror_import.py,v 1.2 2005-12-28 14:58:22 syt Exp $'
+
+print(error)
diff --git a/tests/functional/s/star/star_needs_assignment_target.py b/tests/functional/s/star/star_needs_assignment_target.py
new file mode 100644
index 0000000..5421c22
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target.py
@@ -0,0 +1,4 @@
+"""Test for a = *b"""
+
+FIRST = *[1, 2] # [star-needs-assignment-target]
+*THIRD, FOURTH = [1, 2, 3,]
diff --git a/tests/functional/s/star/star_needs_assignment_target.rc b/tests/functional/s/star/star_needs_assignment_target.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/s/star/star_needs_assignment_target.txt b/tests/functional/s/star/star_needs_assignment_target.txt
new file mode 100644
index 0000000..57f6693
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target.txt
@@ -0,0 +1 @@
+star-needs-assignment-target:3:8::Can use starred expression only in assignment target
diff --git a/tests/functional/s/star/star_needs_assignment_target_py35.py b/tests/functional/s/star/star_needs_assignment_target_py35.py
new file mode 100644
index 0000000..fb5eea8
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target_py35.py
@@ -0,0 +1,15 @@
+"""
+Test PEP 0448 -- Additional Unpacking Generalizations
+https://www.python.org/dev/peps/pep-0448/
+"""
+
+# pylint: disable=superfluous-parens, unnecessary-comprehension
+
+UNPACK_TUPLE = (*range(4), 4)
+UNPACK_LIST = [*range(4), 4]
+UNPACK_SET = {*range(4), 4}
+UNPACK_DICT = {'a': 1, **{'b': '2'}}
+UNPACK_DICT2 = {**UNPACK_DICT, "x": 1, "y": 2}
+UNPACK_DICT3 = {**{'a': 1}, 'a': 2, **{'a': 3}}
+
+UNPACK_IN_COMP = {elem for elem in (*range(10))} # [star-needs-assignment-target]
diff --git a/tests/functional/s/star/star_needs_assignment_target_py35.rc b/tests/functional/s/star/star_needs_assignment_target_py35.rc
new file mode 100644
index 0000000..b743e8f
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target_py35.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.5
+max_pyver=3.8
diff --git a/tests/functional/s/star/star_needs_assignment_target_py35.txt b/tests/functional/s/star/star_needs_assignment_target_py35.txt
new file mode 100644
index 0000000..a4fa2ca
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target_py35.txt
@@ -0,0 +1 @@
+star-needs-assignment-target:15:37::Can use starred expression only in assignment target
diff --git a/tests/functional/s/statement_without_effect.py b/tests/functional/s/statement_without_effect.py
new file mode 100644
index 0000000..bac4f67
--- /dev/null
+++ b/tests/functional/s/statement_without_effect.py
@@ -0,0 +1,75 @@
+"""Test for statements without effects."""
+# pylint: disable=too-few-public-methods, useless-object-inheritance, unnecessary-comprehension
+
+# +1:[pointless-string-statement]
+"""inline doc string should use a separated message"""
+
+__revision__ = ''
+
+__revision__ # [pointless-statement]
+
+__revision__ <= 1 # [pointless-statement]
+
+__revision__.lower()
+
+[i for i in __revision__] # [pointless-statement]
+
+# +1:[pointless-string-statement]
+"""inline doc string should use a separated message"""
+
+
+__revision__.lower(); # [unnecessary-semicolon]
+
+list() and tuple() # [expression-not-assigned]
+
+def to_be():
+ """return 42"""
+ return "42"
+
+ANSWER = to_be() # ok
+ANSWER == to_be() # [expression-not-assigned]
+
+to_be() or not to_be() # [expression-not-assigned]
+to_be().title # [expression-not-assigned]
+
+GOOD_ATTRIBUTE_DOCSTRING = 42
+"""Module level attribute docstring is fine. """
+
+class ClassLevelAttributeTest(object):
+ """ test attribute docstrings. """
+
+ good_attribute_docstring = 24
+ """ class level attribute docstring is fine either. """
+ second_good_attribute_docstring = 42
+ # Comments are good.
+
+ # empty lines are good, too.
+ """ Still a valid class level attribute docstring. """
+
+ def __init__(self):
+ self.attr = 42
+ """ Good attribute docstring """
+ attr = 24
+ """ Still a good __init__ level attribute docstring. """
+ val = 0
+ for val in range(42):
+ val += attr
+ # +1:[pointless-string-statement]
+ """ Invalid attribute docstring """
+ self.val = val
+
+ def test(self):
+ """ invalid attribute docstrings here. """
+ self.val = 42
+ # +1:[pointless-string-statement]
+ """ this is an invalid attribute docstring. """
+
+
+def ellipsis():
+ """Test that an Ellipsis as a body does not trigger the error"""
+ ...
+
+
+class EllipsisBody:
+ """Test that an Ellipsis as a body does not trigger the error"""
+ ...
diff --git a/tests/functional/s/statement_without_effect.txt b/tests/functional/s/statement_without_effect.txt
new file mode 100644
index 0000000..23ccf95
--- /dev/null
+++ b/tests/functional/s/statement_without_effect.txt
@@ -0,0 +1,12 @@
+pointless-string-statement:5:0::String statement has no effect
+pointless-statement:9:0::Statement seems to have no effect
+pointless-statement:11:0::Statement seems to have no effect
+pointless-statement:15:0::Statement seems to have no effect
+pointless-string-statement:18:0::String statement has no effect
+unnecessary-semicolon:21:0::Unnecessary semicolon
+expression-not-assigned:23:0::"Expression ""list() and tuple()"" is assigned to nothing"
+expression-not-assigned:30:0::"Expression ""ANSWER == to_be()"" is assigned to nothing"
+expression-not-assigned:32:0::"Expression ""to_be() or not to_be()"" is assigned to nothing"
+expression-not-assigned:33:0::"Expression ""to_be().title"" is assigned to nothing"
+pointless-string-statement:58:8:ClassLevelAttributeTest.__init__:String statement has no effect
+pointless-string-statement:65:8:ClassLevelAttributeTest.test:String statement has no effect
diff --git a/tests/functional/s/statement_without_effect_py36.py b/tests/functional/s/statement_without_effect_py36.py
new file mode 100644
index 0000000..59745ce
--- /dev/null
+++ b/tests/functional/s/statement_without_effect_py36.py
@@ -0,0 +1,18 @@
+"""Test for statements without effects."""
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+
+
+class ClassLevelAttributeTest(object):
+ """ test attribute docstrings. """
+
+ some_variable: int = 42
+ """Data docstring"""
+
+ some_other_variable: int = 42
+ """Data docstring"""
+
+ def func(self):
+ """Some Empty Docstring"""
+
+ # +1: [pointless-string-statement]
+ """useless"""
diff --git a/tests/functional/s/statement_without_effect_py36.rc b/tests/functional/s/statement_without_effect_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/s/statement_without_effect_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/s/statement_without_effect_py36.txt b/tests/functional/s/statement_without_effect_py36.txt
new file mode 100644
index 0000000..70fc36c
--- /dev/null
+++ b/tests/functional/s/statement_without_effect_py36.txt
@@ -0,0 +1 @@
+pointless-string-statement:18:4:ClassLevelAttributeTest:String statement has no effect
diff --git a/tests/functional/s/stop_iteration_inside_generator.py b/tests/functional/s/stop_iteration_inside_generator.py
new file mode 100644
index 0000000..822f633
--- /dev/null
+++ b/tests/functional/s/stop_iteration_inside_generator.py
@@ -0,0 +1,129 @@
+"""
+Test that no StopIteration is raised inside a generator
+"""
+# pylint: disable=missing-docstring,invalid-name,import-error, try-except-raise, wrong-import-position,not-callable,raise-missing-from
+import asyncio
+
+class RebornStopIteration(StopIteration):
+ """
+ A class inheriting from StopIteration exception
+ """
+
+# This one is ok
+def gen_ok():
+ yield 1
+ yield 2
+ yield 3
+
+# pylint should warn about this one
+# because of a direct raising of StopIteration inside generator
+def gen_stopiter():
+ yield 1
+ yield 2
+ yield 3
+ raise StopIteration # [stop-iteration-return]
+
+# pylint should warn about this one
+# because of a direct raising of an exception inheriting from StopIteration inside generator
+def gen_stopiterchild():
+ yield 1
+ yield 2
+ yield 3
+ raise RebornStopIteration # [stop-iteration-return]
+
+# pylint should warn here
+# because of the possibility that next raises a StopIteration exception
+def gen_next_raises_stopiter():
+ g = gen_ok()
+ while True:
+ yield next(g) # [stop-iteration-return]
+
+# This one is the same as gen_next_raises_stopiter
+# but is ok because the next function is inside
+# a try/except block handling StopIteration
+def gen_next_inside_try_except():
+ g = gen_ok()
+ while True:
+ try:
+ yield next(g)
+ except StopIteration:
+ return
+
+# This one is the same as gen_next_inside_try_except
+# but is not ok because the next function is inside
+# a try/except block that don't handle StopIteration
+def gen_next_inside_wrong_try_except():
+ g = gen_ok()
+ while True:
+ try:
+ yield next(g) # [stop-iteration-return]
+ except ValueError:
+ return
+
+# This one is the same as gen_next_inside_try_except
+# but is not ok because the next function is inside
+# a try/except block that handle StopIteration but reraise it
+def gen_next_inside_wrong_try_except2():
+ g = gen_ok()
+ while True:
+ try:
+ yield next(g)
+ except StopIteration:
+ raise StopIteration # [stop-iteration-return]
+
+# Those two last are ok
+def gen_in_for():
+ for el in gen_ok():
+ yield el
+
+def gen_yield_from():
+ yield from gen_ok()
+
+
+def gen_dont_crash_on_no_exception():
+ g = gen_ok()
+ while True:
+ try:
+ yield next(g) # [stop-iteration-return]
+ except ValueError:
+ raise
+
+
+def gen_dont_crash_on_uninferable():
+ # https://github.com/PyCQA/pylint/issues/1779
+ yield from iter()
+ raise asyncio.TimeoutError()
+
+
+# https://github.com/PyCQA/pylint/issues/1830
+def gen_next_with_sentinel():
+ yield next([], 42) # No bad return
+
+
+from itertools import count
+
+# https://github.com/PyCQA/pylint/issues/2158
+def generator_using_next():
+ counter = count()
+ number = next(counter)
+ yield number * 2
+
+
+# pylint: disable=no-self-use,too-few-public-methods
+class SomeClassWithNext:
+ def next(self):
+ return iter([1, 2, 3])
+ def some_gen(self):
+ for value in self.next():
+ yield value
+
+
+SomeClassWithNext().some_gen()
+
+
+def something_invalid():
+ raise Exception('cannot iterate this')
+
+
+def invalid_object_passed_to_next():
+ yield next(something_invalid()) # [stop-iteration-return]
diff --git a/tests/functional/s/stop_iteration_inside_generator.rc b/tests/functional/s/stop_iteration_inside_generator.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/s/stop_iteration_inside_generator.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/s/stop_iteration_inside_generator.txt b/tests/functional/s/stop_iteration_inside_generator.txt
new file mode 100644
index 0000000..6b1828e
--- /dev/null
+++ b/tests/functional/s/stop_iteration_inside_generator.txt
@@ -0,0 +1,7 @@
+stop-iteration-return:24:4:gen_stopiter:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:32:4:gen_stopiterchild:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:39:14:gen_next_raises_stopiter:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:59:18:gen_next_inside_wrong_try_except:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:72:12:gen_next_inside_wrong_try_except2:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:87:18:gen_dont_crash_on_no_exception:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:129:10:invalid_object_passed_to_next:Do not raise StopIteration in generator, use return statement instead
diff --git a/tests/functional/s/string/string_formatting.py b/tests/functional/s/string/string_formatting.py
new file mode 100644
index 0000000..21332f0
--- /dev/null
+++ b/tests/functional/s/string/string_formatting.py
@@ -0,0 +1,218 @@
+"""Test for Python 3 string formatting error"""
+
+# pylint: disable=too-few-public-methods, import-error, unused-argument, line-too-long, no-absolute-import,
+# pylint: disable=useless-object-inheritance
+import os
+import sys
+import logging
+from missing import Missing
+
+
+class Custom(object):
+ """ Has a __getattr__ """
+ def __getattr__(self, _):
+ return self
+
+
+class Test(object):
+ """ test format attribute access """
+ custom = Custom()
+ ids = [1, 2, 3, [4, 5, 6]]
+
+
+class Getitem(object):
+ """ test custom getitem for lookup access """
+ def __getitem__(self, index):
+ return 42
+
+
+class ReturnYes(object):
+ """ can't be properly infered """
+ missing = Missing()
+
+
+def log(message, message_type="error"):
+ """ Test """
+ return message
+
+
+def print_good():
+ """ Good format strings """
+ "{0} {1}".format(1, 2)
+ "{0!r:20}".format("Hello")
+ "{!r:20}".format("Hello")
+ "{a!r:20}".format(a="Hello")
+ "{pid}".format(pid=os.getpid())
+ str("{}").format(2)
+ "{0.missing.length}".format(ReturnYes())
+ "{1.missing.length}".format(ReturnYes())
+ "{a.ids[3][1]}".format(a=Test())
+ "{a[0][0]}".format(a=[[1]])
+ "{[0][0]}".format({0: {0: 1}})
+ "{a.test}".format(a=Custom())
+ "{a.__len__}".format(a=[])
+ "{a.ids.__len__}".format(a=Test())
+ "{a[0]}".format(a=Getitem())
+ "{a[0][0]}".format(a=[Getitem()])
+ "{[0][0]}".format(["test"])
+ # these are skipped
+ "{0} {1}".format(*[1, 2])
+ "{a} {b}".format(**{'a': 1, 'b': 2})
+ "{a}".format(a=Missing())
+ logging.debug("%s", 42)
+ logging.debug("%s %s", 42, 43)
+
+
+def pprint_bad():
+ """Test string format """
+ "{{}}".format(1) # [too-many-format-args]
+ "{} {".format() # [bad-format-string]
+ "{} }".format() # [bad-format-string]
+ "{0} {}".format(1, 2) # [format-combined-specification]
+ # +1: [missing-format-argument-key, unused-format-string-argument]
+ "{a} {b}".format(a=1, c=2)
+ "{} {a}".format(1, 2) # [missing-format-argument-key]
+ "{} {}".format(1) # [too-few-format-args]
+ "{} {}".format(1, 2, 3) # [too-many-format-args]
+ # +1: [missing-format-argument-key,missing-format-argument-key,missing-format-argument-key]
+ "{a} {b} {c}".format()
+ "{} {}".format(a=1, b=2) # [too-few-format-args]
+ # +1: [missing-format-argument-key, missing-format-argument-key]
+ "{a} {b}".format(1, 2)
+ "{0} {1} {a}".format(1, 2, 3) # [missing-format-argument-key]
+ # +1: [missing-format-attribute]
+ "{a.ids.__len__.length}".format(a=Test())
+ "{a.ids[3][400]}".format(a=Test()) # [invalid-format-index]
+ "{a.ids[3]['string']}".format(a=Test()) # [invalid-format-index]
+ "{[0][1]}".format(["a"]) # [invalid-format-index]
+ "{[0][0]}".format(((1, ))) # [invalid-format-index]
+ # +1: [missing-format-argument-key, unused-format-string-argument]
+ "{b[0]}".format(a=23)
+ "{a[0]}".format(a=object) # [invalid-format-index]
+ log("{}".format(2, "info")) # [too-many-format-args]
+ "{0.missing}".format(2) # [missing-format-attribute]
+ "{0} {1} {2}".format(1, 2) # [too-few-format-args]
+ "{0} {1}".format(1, 2, 3) # [too-many-format-args]
+ "{0} {a}".format(a=4) # [too-few-format-args]
+ "{[0]} {}".format([4]) # [too-few-format-args]
+ "{[0]} {}".format([4], 5, 6) # [too-many-format-args]
+ logging.debug("%s %s", 42) # [logging-too-few-args]
+ logging.debug("%s", 42, 43) # [logging-too-many-args]
+
+
+def good_issue288(*args, **kwargs):
+ """ Test that using kwargs does not emit a false
+ positive.
+ """
+ 'Hello John Doe {0[0]}'.format(args)
+ 'Hello {0[name]}'.format(kwargs)
+
+
+def good_issue287():
+ """ Test that the string format checker skips
+ format nodes which don't have a string as a parent
+ (but a subscript, name etc).
+ """
+ name = 'qwerty'
+ ret = {'comment': ''}
+ ret['comment'] = 'MySQL grant {0} is set to be revoked'
+ ret['comment'] = ret['comment'].format(name)
+ return ret, name
+
+
+def nested_issue294():
+ """ Test nested format fields. """
+ '{0:>{1}}'.format(42, 24)
+ '{0:{a[1]}} {a}'.format(1, a=[1, 2])
+ '{:>{}}'.format(42, 24)
+ '{0:>{1}}'.format(42) # [too-few-format-args]
+ '{0:>{1}}'.format(42, 24, 54) # [too-many-format-args]
+ '{0:{a[1]}}'.format(1) # [missing-format-argument-key]
+ '{0:{a.x}}'.format(1, a=2) # [missing-format-attribute]
+
+
+def issue310():
+ """ Test a regression using duplicate manual position arguments. """
+ '{0} {1} {0}'.format(1, 2)
+ '{0} {1} {0}'.format(1) # [too-few-format-args]
+
+
+def issue322():
+ """ Test a regression using mixed manual position arguments
+ and attribute access arguments.
+ """
+ '{0}{1[FOO]}'.format(123, {'FOO': 456})
+ '{0}{1[FOO]}'.format(123, {'FOO': 456}, 321) # [too-many-format-args]
+ '{0}{1[FOO]}'.format(123) # [too-few-format-args]
+
+
+def issue338():
+ """
+ Check that using a namedtuple subclass doesn't crash when
+ trying to infer EmptyNodes (resulted after mocking the
+ members of namedtuples).
+ """
+ from collections import namedtuple # pylint: disable=import-outside-toplevel
+
+ class Crash(namedtuple("C", "foo bar")):
+ """ Looking for attributes in __str__ will crash,
+ because EmptyNodes can't be infered.
+ """
+ def __str__(self):
+ return "{0.foo}: {0.bar}".format(self)
+ return Crash
+
+
+def issue351():
+ """
+ Check that the format method can be assigned to a variable, ie:
+ """
+ fmt = 'test {} {}'.format
+ fmt('arg1') # [too-few-format-args]
+ fmt('arg1', 'arg2')
+ fmt('arg1', 'arg2', 'arg3') # [too-many-format-args]
+
+
+def issue373():
+ """
+ Ignore any object coming from an argument.
+ """
+ class SomeClass(object):
+ """ empty docstring. """
+ def __init__(self, opts=None):
+ self.opts = opts
+
+ def dunc(self, arg):
+ """Don't try to analyze this."""
+ return "A{0}{1}".format(arg, self.opts)
+
+ def func(self):
+ """Don't try to analyze the following string."""
+ return 'AAA{0[iface]}BBB{0[port]}'.format(self.opts)
+
+ return SomeClass
+
+
+def issue_463():
+ """
+ Mix positional arguments, `{0}`, with positional
+ arguments with attribute access, `{0.__x__}`.
+ """
+ data = "{0.__class__.__name__}: {0}".format(42)
+ data2 = "{0[0]}: {0}".format([1])
+ return (data, data2)
+
+
+def avoid_empty_attribute():
+ """The following string is invalid, avoid crashing."""
+
+ return "There are {.:2f} undiscovered errors.".format(1) # [bad-format-string]
+
+
+def invalid_format_index_on_inference_ambiguity():
+ """Test inference bug for invalid-format-index"""
+ if len(sys.argv) > 1:
+ options = [["Woof!"]]
+ else:
+ options = [["Barf!"]]
+ return 'Why is this bad? {options[0][0]}'.format(options=options)
diff --git a/tests/functional/s/string/string_formatting.txt b/tests/functional/s/string/string_formatting.txt
new file mode 100644
index 0000000..f522dd1
--- /dev/null
+++ b/tests/functional/s/string/string_formatting.txt
@@ -0,0 +1,43 @@
+too-many-format-args:68:4:pprint_bad:Too many arguments for format string
+bad-format-string:69:4:pprint_bad:Invalid format string
+bad-format-string:70:4:pprint_bad:Invalid format string
+format-combined-specification:71:4:pprint_bad:Format string contains both automatic field numbering and manual field specification
+missing-format-argument-key:73:4:pprint_bad:Missing keyword argument 'b' for format string
+unused-format-string-argument:73:4:pprint_bad:Unused format argument 'c'
+missing-format-argument-key:74:4:pprint_bad:Missing keyword argument 'a' for format string
+too-few-format-args:75:4:pprint_bad:Not enough arguments for format string
+too-many-format-args:76:4:pprint_bad:Too many arguments for format string
+missing-format-argument-key:78:4:pprint_bad:Missing keyword argument 'a' for format string
+missing-format-argument-key:78:4:pprint_bad:Missing keyword argument 'b' for format string
+missing-format-argument-key:78:4:pprint_bad:Missing keyword argument 'c' for format string
+too-few-format-args:79:4:pprint_bad:Not enough arguments for format string
+missing-format-argument-key:81:4:pprint_bad:Missing keyword argument 'a' for format string
+missing-format-argument-key:81:4:pprint_bad:Missing keyword argument 'b' for format string
+missing-format-argument-key:82:4:pprint_bad:Missing keyword argument 'a' for format string
+missing-format-attribute:84:4:pprint_bad:Missing format attribute 'length' in format specifier 'a.ids.__len__.length'
+invalid-format-index:85:4:pprint_bad:Using invalid lookup key 400 in format specifier 'a.ids[3][400]'
+invalid-format-index:86:4:pprint_bad:"Using invalid lookup key ""'string'"" in format specifier 'a.ids[3][""\'string\'""]'"
+invalid-format-index:87:4:pprint_bad:Using invalid lookup key 1 in format specifier '0[0][1]'
+invalid-format-index:88:4:pprint_bad:Using invalid lookup key 0 in format specifier '0[0][0]'
+missing-format-argument-key:90:4:pprint_bad:Missing keyword argument 'b' for format string
+unused-format-string-argument:90:4:pprint_bad:Unused format argument 'a'
+invalid-format-index:91:4:pprint_bad:Using invalid lookup key 0 in format specifier 'a[0]'
+too-many-format-args:92:8:pprint_bad:Too many arguments for format string
+missing-format-attribute:93:4:pprint_bad:Missing format attribute 'missing' in format specifier '0.missing'
+too-few-format-args:94:4:pprint_bad:Not enough arguments for format string
+too-many-format-args:95:4:pprint_bad:Too many arguments for format string
+too-few-format-args:96:4:pprint_bad:Not enough arguments for format string
+too-few-format-args:97:4:pprint_bad:Not enough arguments for format string
+too-many-format-args:98:4:pprint_bad:Too many arguments for format string
+logging-too-few-args:99:4:pprint_bad:Not enough arguments for logging format string
+logging-too-many-args:100:4:pprint_bad:Too many arguments for logging format string
+too-few-format-args:128:4:nested_issue294:Not enough arguments for format string
+too-many-format-args:129:4:nested_issue294:Too many arguments for format string
+missing-format-argument-key:130:4:nested_issue294:Missing keyword argument 'a' for format string
+missing-format-attribute:131:4:nested_issue294:Missing format attribute 'x' in format specifier 'a.x'
+too-few-format-args:137:4:issue310:Not enough arguments for format string
+too-many-format-args:145:4:issue322:Too many arguments for format string
+too-few-format-args:146:4:issue322:Not enough arguments for format string
+too-few-format-args:171:4:issue351:Not enough arguments for format string
+too-many-format-args:173:4:issue351:Too many arguments for format string
+bad-format-string:209:11:avoid_empty_attribute:Invalid format string
diff --git a/tests/functional/s/string/string_formatting_disable.py b/tests/functional/s/string/string_formatting_disable.py
new file mode 100644
index 0000000..88f3dcf
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_disable.py
@@ -0,0 +1 @@
+"a {} {".format(1) # [bad-format-string]
diff --git a/tests/functional/s/string/string_formatting_disable.rc b/tests/functional/s/string/string_formatting_disable.rc
new file mode 100644
index 0000000..0193339
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_disable.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=all
+enable=bad-format-string
diff --git a/tests/functional/s/string/string_formatting_disable.txt b/tests/functional/s/string/string_formatting_disable.txt
new file mode 100644
index 0000000..f6e390f
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_disable.txt
@@ -0,0 +1 @@
+bad-format-string:1:0::Invalid format string
diff --git a/tests/functional/s/string/string_formatting_error.py b/tests/functional/s/string/string_formatting_error.py
new file mode 100644
index 0000000..97dfedc
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_error.py
@@ -0,0 +1,20 @@
+"""test string format error"""
+# pylint: disable=print-statement,unsupported-binary-operation,line-too-long
+from __future__ import print_function
+
+PARG_1 = PARG_2 = PARG_3 = 1
+
+
+def pprint():
+ """Test string format"""
+ print("%s %s" % {'PARG_1': 1, 'PARG_2': 2}) # [too-few-format-args]
+ print("%s" % (PARG_1, PARG_2)) # [too-many-format-args]
+ print("%(PARG_1)d %d" % {'PARG_1': 1, 'PARG_2': 2}) # [mixed-format-string]
+ print("%(PARG_1)d %(PARG_2)d" % {'PARG_1': 1}) # [missing-format-string-key]
+ print("%(PARG_1)d %(PARG_2)d" % {'PARG_1': 1, 'PARG_2':2, 'PARG_3':3}) # [unused-format-string-key]
+ print("%(PARG_1)d %(PARG_2)d" % {'PARG_1': 1, 2:3}) # [missing-format-string-key,bad-format-string-key]
+ print("%(PARG_1)d %(PARG_2)d" % (2, 3)) # [format-needs-mapping]
+ print("%(PARG_1)d %(PARG_2)d" % [2, 3]) # [format-needs-mapping]
+ print("%2z" % PARG_1) # [bad-format-character]
+ print("strange format %2" % PARG_2) # [truncated-format-string]
+ print("works in 3 %a" % 1)
diff --git a/tests/functional/s/string/string_formatting_error.txt b/tests/functional/s/string/string_formatting_error.txt
new file mode 100644
index 0000000..52b67f8
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_error.txt
@@ -0,0 +1,11 @@
+too-few-format-args:10:10:pprint:Not enough arguments for format string
+too-many-format-args:11:10:pprint:Too many arguments for format string
+mixed-format-string:12:10:pprint:Mixing named and unnamed conversion specifiers in format string
+missing-format-string-key:13:10:pprint:Missing key 'PARG_2' in format string dictionary
+unused-format-string-key:14:10:pprint:Unused key 'PARG_3' in format string dictionary
+bad-format-string-key:15:10:pprint:Format string dictionary key should be a string, not 2
+missing-format-string-key:15:10:pprint:Missing key 'PARG_2' in format string dictionary
+format-needs-mapping:16:10:pprint:Expected mapping for format string, not Tuple
+format-needs-mapping:17:10:pprint:Expected mapping for format string, not List
+bad-format-character:18:10:pprint:Unsupported format character 'z' (0x7a) at index 2
+truncated-format-string:19:10:pprint:Format string ends in middle of conversion specifier
diff --git a/tests/functional/s/string/string_formatting_failed_inference.py b/tests/functional/s/string/string_formatting_failed_inference.py
new file mode 100644
index 0000000..c5add58
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_failed_inference.py
@@ -0,0 +1,4 @@
+""" Testing string format with a failed inference. This should not crash. """
+# pylint: disable=using-constant-test
+import collections
+"{dict[0]}".format(dict=collections.defaultdict(int))
diff --git a/tests/functional/s/string/string_formatting_failed_inference_py35.py b/tests/functional/s/string/string_formatting_failed_inference_py35.py
new file mode 100644
index 0000000..a511ff8
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_failed_inference_py35.py
@@ -0,0 +1,6 @@
+""" Testing string format with a failed inference. This should not crash. """
+# pylint: disable=using-constant-test
+import collections
+"{dict[0]}".format(dict=collections.defaultdict(int))
+
+COMMENT = "message %s %s %s" % (0, *(1 if "cond" else 2,) * 2)
diff --git a/tests/functional/s/string/string_formatting_failed_inference_py35.rc b/tests/functional/s/string/string_formatting_failed_inference_py35.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_failed_inference_py35.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/s/string/string_formatting_py3.py b/tests/functional/s/string/string_formatting_py3.py
new file mode 100644
index 0000000..3cdd60e
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_py3.py
@@ -0,0 +1,21 @@
+# pylint: disable=missing-docstring,import-error
+
+
+def issue_957_good():
+ meat = ['spam', 'ham']
+ print('%s%s%s' % ('eggs', *meat))
+
+
+def issue_957_bad1():
+ meat = ['spam', 'ham', 'monty python']
+ print('%s%s%s' % ('eggs', *meat)) # [too-many-format-args]
+
+
+def issue_957_bad2():
+ meat = ['spam']
+ print('%s%s%s' % ('eggs', *meat)) # [too-few-format-args]
+
+
+def issue_957_uninferable():
+ from butchery import meat # pylint: disable=import-outside-toplevel
+ print('%s%s%s' % ('eggs', *meat))
diff --git a/tests/functional/s/string/string_formatting_py3.rc b/tests/functional/s/string/string_formatting_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/s/string/string_formatting_py3.txt b/tests/functional/s/string/string_formatting_py3.txt
new file mode 100644
index 0000000..bf90e01
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_py3.txt
@@ -0,0 +1,2 @@
+too-many-format-args:11:10:issue_957_bad1:Too many arguments for format string
+too-few-format-args:16:10:issue_957_bad2:Not enough arguments for format string
diff --git a/tests/functional/s/string/string_log_formatting.py b/tests/functional/s/string/string_log_formatting.py
new file mode 100644
index 0000000..e03d47f
--- /dev/null
+++ b/tests/functional/s/string/string_log_formatting.py
@@ -0,0 +1,28 @@
+# pylint: disable=no-absolute-import
+"""Test checking of log format strings
+"""
+
+import logging
+
+__revision__ = ''
+
+
+def pprint():
+ """Test string format in logging statements.
+ """
+ # These should all emit lint errors:
+ logging.info(0, '') # [logging-too-many-args]
+ logging.info('', '') # [logging-too-many-args]
+ logging.info('%s%', '') # [logging-format-truncated]
+ logging.info('%s%s', '') # [logging-too-few-args]
+ logging.info('%s%y', '', '') # [logging-unsupported-format]
+ logging.info('%s%s', '', '', '') # [logging-too-many-args]
+
+ # These should be okay:
+ logging.info(1)
+ logging.info(True)
+ logging.info('')
+ logging.info('%s%')
+ logging.info('%s', '')
+ logging.info('%s%%', '')
+ logging.info('%s%s', '', '')
diff --git a/tests/functional/s/string/string_log_formatting.txt b/tests/functional/s/string/string_log_formatting.txt
new file mode 100644
index 0000000..aec9c26
--- /dev/null
+++ b/tests/functional/s/string/string_log_formatting.txt
@@ -0,0 +1,6 @@
+logging-too-many-args:14:4:pprint:Too many arguments for logging format string
+logging-too-many-args:15:4:pprint:Too many arguments for logging format string
+logging-format-truncated:16:4:pprint:Logging format string ends in middle of conversion specifier
+logging-too-few-args:17:4:pprint:Not enough arguments for logging format string
+logging-unsupported-format:18:4:pprint:Unsupported logging format character 'y' (0x79) at index 3
+logging-too-many-args:19:4:pprint:Too many arguments for logging format string
diff --git a/tests/functional/s/subprocess_popen_preexec_fn.py b/tests/functional/s/subprocess_popen_preexec_fn.py
new file mode 100644
index 0000000..7226124
--- /dev/null
+++ b/tests/functional/s/subprocess_popen_preexec_fn.py
@@ -0,0 +1,11 @@
+# pylint: disable=disallowed-name,no-value-for-parameter,missing-docstring,consider-using-with
+
+import subprocess
+
+def foo():
+ pass
+
+
+subprocess.Popen(preexec_fn=foo) # [subprocess-popen-preexec-fn]
+
+subprocess.Popen()
diff --git a/tests/functional/s/subprocess_popen_preexec_fn.txt b/tests/functional/s/subprocess_popen_preexec_fn.txt
new file mode 100644
index 0000000..55b886d
--- /dev/null
+++ b/tests/functional/s/subprocess_popen_preexec_fn.txt
@@ -0,0 +1 @@
+subprocess-popen-preexec-fn:9:0::Using preexec_fn keyword which may be unsafe in the presence of threads
diff --git a/tests/functional/s/subprocess_run_check35.py b/tests/functional/s/subprocess_run_check35.py
new file mode 100644
index 0000000..fc4d99d
--- /dev/null
+++ b/tests/functional/s/subprocess_run_check35.py
@@ -0,0 +1,6 @@
+# pylint: disable=disallowed-name,no-value-for-parameter,missing-docstring
+
+import subprocess
+
+
+subprocess.run() # [subprocess-run-check]
diff --git a/tests/functional/s/subprocess_run_check35.rc b/tests/functional/s/subprocess_run_check35.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/s/subprocess_run_check35.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/s/subprocess_run_check35.txt b/tests/functional/s/subprocess_run_check35.txt
new file mode 100644
index 0000000..3f854ad
--- /dev/null
+++ b/tests/functional/s/subprocess_run_check35.txt
@@ -0,0 +1 @@
+subprocess-run-check:6:0::Using subprocess.run without explicitly set `check` is not recommended.
diff --git a/tests/functional/s/super/super_checks.py b/tests/functional/s/super/super_checks.py
new file mode 100644
index 0000000..3f132df
--- /dev/null
+++ b/tests/functional/s/super/super_checks.py
@@ -0,0 +1,125 @@
+# pylint: disable=too-few-public-methods,import-error, no-absolute-import,missing-docstring, useless-object-inheritance
+# pylint: disable=useless-super-delegation,wrong-import-position,invalid-name, wrong-import-order
+# pylint: disable=super-with-arguments
+from unknown import Missing
+
+class Aaaa:
+ """old style"""
+ def hop(self):
+ """hop"""
+ super(Aaaa, self).hop() # >=3.0:[no-member]
+
+ def __init__(self):
+ super(Aaaa, self).__init__()
+
+class NewAaaa(object):
+ """old style"""
+ def hop(self):
+ """hop"""
+ super(NewAaaa, self).hop() # [no-member]
+
+ def __init__(self):
+ super(Aaaa, self).__init__() # [bad-super-call]
+
+class Py3kAaaa(NewAaaa):
+ """new style"""
+ def __init__(self):
+ super().__init__() # <3.0:[missing-super-argument]
+
+class Py3kWrongSuper(Py3kAaaa):
+ """new style"""
+ def __init__(self):
+ super(NewAaaa, self).__init__() # [bad-super-call]
+
+class WrongNameRegression(Py3kAaaa):
+ """ test a regression with the message """
+ def __init__(self):
+ super(Missing, self).__init__() # [bad-super-call]
+
+class Getattr(object):
+ """ crash """
+ name = NewAaaa
+
+class CrashSuper(object):
+ """ test a crash with this checker """
+ def __init__(self):
+ super(Getattr.name, self).__init__() # [bad-super-call]
+
+class Empty(object):
+ """Just an empty class."""
+
+class SuperDifferentScope(object):
+ """Don'emit bad-super-call when the super call is in another scope.
+ For reference, see https://bitbucket.org/logilab/pylint/issue/403.
+ """
+ @staticmethod
+ def test():
+ """Test that a bad-super-call is not emitted for this case."""
+ class FalsePositive(Empty):
+ """The following super is in another scope than `test`."""
+ def __init__(self, arg):
+ super(FalsePositive, self).__init__(arg)
+ super(object, 1).__init__() # [bad-super-call]
+
+
+class UnknownBases(Missing):
+ """Don't emit if we don't know all the bases."""
+ def __init__(self):
+ super(UnknownBases, self).__init__()
+ super(UnknownBases, self).test()
+ super(Missing, self).test() # [bad-super-call]
+
+
+# Test that we are detecting proper super errors.
+
+class BaseClass(object):
+
+ not_a_method = 42
+
+ def function(self, param):
+ return param + self.not_a_method
+
+ def __getattr__(self, attr):
+ return attr
+
+
+class InvalidSuperChecks(BaseClass):
+
+ def __init__(self):
+ super(InvalidSuperChecks, self).not_a_method() # [not-callable]
+ super(InvalidSuperChecks, self).attribute_error() # [no-member]
+ super(InvalidSuperChecks, self).function(42)
+ super(InvalidSuperChecks, self).function() # [no-value-for-parameter]
+ super(InvalidSuperChecks, self).function(42, 24, 24) # [too-many-function-args]
+ # +1: [unexpected-keyword-arg,no-value-for-parameter]
+ super(InvalidSuperChecks, self).function(lala=42)
+ # Even though BaseClass has a __getattr__, that won't
+ # be called.
+ super(InvalidSuperChecks, self).attribute_error() # [no-member]
+
+
+
+# Regression for PyCQA/pylint/issues/773
+import subprocess
+
+# The problem was related to astroid not filtering statements
+# at scope level properly, basically not doing strong updates.
+try:
+ TimeoutExpired = subprocess.TimeoutExpired
+except AttributeError:
+ class TimeoutExpired(subprocess.CalledProcessError):
+ def __init__(self):
+ returncode = -1
+ self.timeout = -1
+ super(TimeoutExpired, self).__init__("", returncode)
+
+
+class SuperWithType(object):
+ """type(self) may lead to recursion loop in derived classes"""
+ def __init__(self):
+ super(type(self), self).__init__() # [bad-super-call]
+
+class SuperWithSelfClass(object):
+ """self.__class__ may lead to recursion loop in derived classes"""
+ def __init__(self):
+ super(self.__class__, self).__init__() # [bad-super-call]
diff --git a/tests/functional/s/super/super_checks.txt b/tests/functional/s/super/super_checks.txt
new file mode 100644
index 0000000..bd360c8
--- /dev/null
+++ b/tests/functional/s/super/super_checks.txt
@@ -0,0 +1,17 @@
+no-member:10:8:Aaaa.hop:Super of 'Aaaa' has no 'hop' member:INFERENCE
+no-member:19:8:NewAaaa.hop:Super of 'NewAaaa' has no 'hop' member:INFERENCE
+bad-super-call:22:8:NewAaaa.__init__:Bad first argument 'Aaaa' given to super()
+bad-super-call:32:8:Py3kWrongSuper.__init__:Bad first argument 'NewAaaa' given to super()
+bad-super-call:37:8:WrongNameRegression.__init__:Bad first argument 'Missing' given to super()
+bad-super-call:46:8:CrashSuper.__init__:Bad first argument 'NewAaaa' given to super()
+bad-super-call:62:8:SuperDifferentScope.test:Bad first argument 'object' given to super()
+bad-super-call:70:8:UnknownBases.__init__:Bad first argument 'Missing' given to super()
+not-callable:89:8:InvalidSuperChecks.__init__:super(InvalidSuperChecks, self).not_a_method is not callable
+no-member:90:8:InvalidSuperChecks.__init__:Super of 'InvalidSuperChecks' has no 'attribute_error' member:INFERENCE
+no-value-for-parameter:92:8:InvalidSuperChecks.__init__:No value for argument 'param' in method call
+too-many-function-args:93:8:InvalidSuperChecks.__init__:Too many positional arguments for method call
+no-value-for-parameter:95:8:InvalidSuperChecks.__init__:No value for argument 'param' in method call
+unexpected-keyword-arg:95:8:InvalidSuperChecks.__init__:Unexpected keyword argument 'lala' in method call
+no-member:98:8:InvalidSuperChecks.__init__:Super of 'InvalidSuperChecks' has no 'attribute_error' member:INFERENCE
+bad-super-call:120:8:SuperWithType.__init__:Bad first argument 'type' given to super()
+bad-super-call:125:8:SuperWithSelfClass.__init__:Bad first argument 'self.__class__' given to super()
diff --git a/tests/functional/s/super/super_with_arguments.py b/tests/functional/s/super/super_with_arguments.py
new file mode 100644
index 0000000..8ab7c4d
--- /dev/null
+++ b/tests/functional/s/super/super_with_arguments.py
@@ -0,0 +1,35 @@
+class Foo:
+ pass
+
+
+class Bar(Foo):
+ def __init__(self):
+ super(Bar, self).__init__() # [super-with-arguments]
+
+
+class Baz(Foo):
+ def __init__(self):
+ super().__init__()
+
+
+class Qux(Foo):
+ def __init__(self):
+ super(Bar, self).__init__()
+
+
+class NotSuperCall(Foo):
+ def __init__(self):
+ super.test(Bar, self).__init__()
+
+
+class InvalidSuperCall(Foo):
+ def __init__(self):
+ super(InvalidSuperCall.__class__, self).__init__()
+
+
+def method_accepting_cls(cls, self):
+ # Using plain `super()` is not valid here, since there's no `__class__` cell found
+ # (Exact exception would be 'RuntimeError: super(): __class__ cell not found')
+ # Instead, we expect to *not* see a warning about `super-with-arguments`.
+ # Explicitly passing `cls`, and `self` to `super()` is what's required.
+ super(cls, self).__init__()
diff --git a/tests/functional/s/super/super_with_arguments.rc b/tests/functional/s/super/super_with_arguments.rc
new file mode 100644
index 0000000..0e70163
--- /dev/null
+++ b/tests/functional/s/super/super_with_arguments.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=all
+enable=super-with-arguments
diff --git a/tests/functional/s/super/super_with_arguments.txt b/tests/functional/s/super/super_with_arguments.txt
new file mode 100644
index 0000000..f882848
--- /dev/null
+++ b/tests/functional/s/super/super_with_arguments.txt
@@ -0,0 +1 @@
+super-with-arguments:7:8:Bar.__init__:Consider using Python 3 style super() without arguments
diff --git a/tests/functional/s/superfluous_parens.py b/tests/functional/s/superfluous_parens.py
new file mode 100644
index 0000000..13418cd
--- /dev/null
+++ b/tests/functional/s/superfluous_parens.py
@@ -0,0 +1,19 @@
+"""Test the superfluous-parens warning."""
+from __future__ import print_function
+# pylint: disable=unneeded-not
+i = 3
+if (i == 5): # [superfluous-parens]
+ pass
+if not (i == 5): # [superfluous-parens]
+ pass
+if not (3 or 5):
+ pass
+for (x) in (1, 2, 3): # [superfluous-parens]
+ print(x)
+if (1) in (1, 2, 3): # [superfluous-parens]
+ pass
+if (1, 2) in (1, 2, 3):
+ pass
+DICT = {'a': 1, 'b': 2}
+del(DICT['b']) # [superfluous-parens]
+del DICT['a']
diff --git a/tests/functional/s/superfluous_parens.txt b/tests/functional/s/superfluous_parens.txt
new file mode 100644
index 0000000..73c1d10
--- /dev/null
+++ b/tests/functional/s/superfluous_parens.txt
@@ -0,0 +1,5 @@
+superfluous-parens:5:0::Unnecessary parens after 'if' keyword
+superfluous-parens:7:0::Unnecessary parens after 'not' keyword
+superfluous-parens:11:0::Unnecessary parens after 'for' keyword
+superfluous-parens:13:0::Unnecessary parens after 'if' keyword
+superfluous-parens:18:0::Unnecessary parens after 'del' keyword
diff --git a/tests/functional/s/suspicious_str_strip_call_py3.py b/tests/functional/s/suspicious_str_strip_call_py3.py
new file mode 100644
index 0000000..e859f25
--- /dev/null
+++ b/tests/functional/s/suspicious_str_strip_call_py3.py
@@ -0,0 +1,9 @@
+"""Suspicious str.strip calls."""
+__revision__ = 1
+
+''.strip('yo')
+''.strip()
+
+u''.strip('http://') # [bad-str-strip-call]
+u''.lstrip('http://') # [bad-str-strip-call]
+b''.rstrip('http://') # [bad-str-strip-call]
diff --git a/tests/functional/s/suspicious_str_strip_call_py3.rc b/tests/functional/s/suspicious_str_strip_call_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/s/suspicious_str_strip_call_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/s/suspicious_str_strip_call_py3.txt b/tests/functional/s/suspicious_str_strip_call_py3.txt
new file mode 100644
index 0000000..dc50d46
--- /dev/null
+++ b/tests/functional/s/suspicious_str_strip_call_py3.txt
@@ -0,0 +1,3 @@
+bad-str-strip-call:7:0::Suspicious argument in str.strip call
+bad-str-strip-call:8:0::Suspicious argument in str.lstrip call
+bad-str-strip-call:9:0::Suspicious argument in bytes.rstrip call
diff --git a/tests/functional/s/syntax_error.py b/tests/functional/s/syntax_error.py
new file mode 100644
index 0000000..c93df6b
--- /dev/null
+++ b/tests/functional/s/syntax_error.py
@@ -0,0 +1 @@
+def toto # [syntax-error]
diff --git a/tests/functional/s/syntax_error.rc b/tests/functional/s/syntax_error.rc
new file mode 100644
index 0000000..b47a745
--- /dev/null
+++ b/tests/functional/s/syntax_error.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=PyPy
diff --git a/tests/functional/s/syntax_error.txt b/tests/functional/s/syntax_error.txt
new file mode 100644
index 0000000..b56259d
--- /dev/null
+++ b/tests/functional/s/syntax_error.txt
@@ -0,0 +1 @@
+syntax-error:1:10::invalid syntax (<unknown>, line 1)
diff --git a/tests/functional/s/syntax_error_jython.py b/tests/functional/s/syntax_error_jython.py
new file mode 100644
index 0000000..c93df6b
--- /dev/null
+++ b/tests/functional/s/syntax_error_jython.py
@@ -0,0 +1 @@
+def toto # [syntax-error]
diff --git a/tests/functional/s/syntax_error_jython.rc b/tests/functional/s/syntax_error_jython.rc
new file mode 100644
index 0000000..29bd3fa
--- /dev/null
+++ b/tests/functional/s/syntax_error_jython.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=CPython, PyPy
diff --git a/tests/functional/s/syntax_error_jython.txt b/tests/functional/s/syntax_error_jython.txt
new file mode 100644
index 0000000..56c75f6
--- /dev/null
+++ b/tests/functional/s/syntax_error_jython.txt
@@ -0,0 +1 @@
+syntax-error:1::"mismatched input '\n\n\n\n' expecting LPAREN"
diff --git a/tests/functional/s/sys_stream_regression_1004.py b/tests/functional/s/sys_stream_regression_1004.py
new file mode 100644
index 0000000..c039185
--- /dev/null
+++ b/tests/functional/s/sys_stream_regression_1004.py
@@ -0,0 +1,7 @@
+'''Regression for issue https://github.com/PyCQA/pylint/issues/1004'''
+# pylint: disable=missing-docstring, pointless-statement
+
+import sys
+sys.__stdout__.buffer.write('test')
+sys.__stdout__.buff # [no-member]
+sys.__stdout__.buffer.write1 # [no-member]
diff --git a/tests/functional/s/sys_stream_regression_1004.rc b/tests/functional/s/sys_stream_regression_1004.rc
new file mode 100644
index 0000000..15704f5
--- /dev/null
+++ b/tests/functional/s/sys_stream_regression_1004.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.5
+except_implementations=PyPy
diff --git a/tests/functional/s/sys_stream_regression_1004.txt b/tests/functional/s/sys_stream_regression_1004.txt
new file mode 100644
index 0000000..f92121a
--- /dev/null
+++ b/tests/functional/s/sys_stream_regression_1004.txt
@@ -0,0 +1,2 @@
+no-member:6:0::Instance of 'TextIOWrapper' has no 'buff' member:INFERENCE
+no-member:7:0::Instance of 'BufferedWriter' has no 'write1' member; maybe 'write'?:INFERENCE
diff --git a/tests/functional/t/__init__.py b/tests/functional/t/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/t/__init__.py
diff --git a/tests/functional/t/ternary.py b/tests/functional/t/ternary.py
new file mode 100644
index 0000000..deac01e
--- /dev/null
+++ b/tests/functional/t/ternary.py
@@ -0,0 +1,33 @@
+"""Test for old ternary constructs"""
+from UNINFERABLE import condition, true_value, false_value, some_callable # pylint: disable=import-error
+
+SOME_VALUE1 = true_value if condition else false_value
+SOME_VALUE2 = condition and true_value or false_value # [consider-using-ternary]
+SOME_VALUE3 = condition
+
+def func1():
+ """Ternary return value correct"""
+ return true_value if condition else false_value
+
+
+def func2():
+ """Ternary return value incorrect"""
+ return condition and true_value or false_value # [consider-using-ternary]
+
+
+SOME_VALUE4 = some_callable(condition) and 'ERROR' or 'SUCCESS' # [consider-using-ternary]
+SOME_VALUE5 = SOME_VALUE1 > 3 and 'greater' or 'not greater' # [consider-using-ternary]
+SOME_VALUE6 = (SOME_VALUE2 > 4 and SOME_VALUE3) and 'both' or 'not' # [consider-using-ternary]
+SOME_VALUE7 = 'both' if (SOME_VALUE2 > 4) and (SOME_VALUE3) else 'not'
+SOME_VALUE8 = SOME_VALUE1 and SOME_VALUE2 and SOME_VALUE3 or SOME_VALUE4
+SOME_VALUE9 = SOME_VALUE1 and False or SOME_VALUE2 # [simplify-boolean-expression]
+
+YEAR = 1992
+# Cannot be simplified with a ternary.
+IS_LEAP_YEAR = YEAR % 4 == 0 and YEAR % 100 != 0 or YEAR % 400 == 0
+
+
+def func4():
+ """"Using a Name as a condition but still emits"""
+ truth_value = 42
+ return condition and truth_value or false_value # [consider-using-ternary]
diff --git a/tests/functional/t/ternary.txt b/tests/functional/t/ternary.txt
new file mode 100644
index 0000000..d78aa45
--- /dev/null
+++ b/tests/functional/t/ternary.txt
@@ -0,0 +1,7 @@
+consider-using-ternary:5:0::Consider using ternary (true_value if condition else false_value)
+consider-using-ternary:15:4:func2:Consider using ternary (true_value if condition else false_value)
+consider-using-ternary:18:0::Consider using ternary ('ERROR' if some_callable(condition) else 'SUCCESS')
+consider-using-ternary:19:0::Consider using ternary ('greater' if SOME_VALUE1 > 3 else 'not greater')
+consider-using-ternary:20:0::Consider using ternary ('both' if SOME_VALUE2 > 4 and SOME_VALUE3 else 'not')
+simplify-boolean-expression:23:0::Boolean expression may be simplified to SOME_VALUE2
+consider-using-ternary:33:4:func4:Consider using ternary (truth_value if condition else false_value)
diff --git a/tests/functional/t/test_compile.py b/tests/functional/t/test_compile.py
new file mode 100644
index 0000000..d4a4ac2
--- /dev/null
+++ b/tests/functional/t/test_compile.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring, unused-variable, pointless-statement, too-few-public-methods, useless-object-inheritance
+
+class WrapperClass(object):
+ def method(self):
+ var = +4294967296
+ self.method.__code__.co_consts
diff --git a/tests/functional/t/tokenize_error.py b/tests/functional/t/tokenize_error.py
new file mode 100644
index 0000000..323950d
--- /dev/null
+++ b/tests/functional/t/tokenize_error.py
@@ -0,0 +1,6 @@
+"""A module that is accepted by Python but rejected by tokenize.
+
+The problem is the trailing line continuation at the end of the line,
+which produces a TokenError."""
+# +2: [syntax-error]
+""\
diff --git a/tests/functional/t/tokenize_error.rc b/tests/functional/t/tokenize_error.rc
new file mode 100644
index 0000000..58b5a94
--- /dev/null
+++ b/tests/functional/t/tokenize_error.rc
@@ -0,0 +1 @@
+[testoptions]
diff --git a/tests/functional/t/tokenize_error.txt b/tests/functional/t/tokenize_error.txt
new file mode 100644
index 0000000..bf780eb
--- /dev/null
+++ b/tests/functional/t/tokenize_error.txt
@@ -0,0 +1 @@
+syntax-error:7:0::EOF in multi-line statement
diff --git a/tests/functional/t/tokenize_error_jython.py b/tests/functional/t/tokenize_error_jython.py
new file mode 100644
index 0000000..205f5fc
--- /dev/null
+++ b/tests/functional/t/tokenize_error_jython.py
@@ -0,0 +1,7 @@
+# [syntax-error]
+"""A module that is accepted by Python but rejected by tokenize.
+
+The problem is the trailing line continuation at the end of the line,
+which produces a TokenError."""
+
+""\
diff --git a/tests/functional/t/tokenize_error_jython.rc b/tests/functional/t/tokenize_error_jython.rc
new file mode 100644
index 0000000..0dd0789
--- /dev/null
+++ b/tests/functional/t/tokenize_error_jython.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=CPython,PyPy,IronPython
diff --git a/tests/functional/t/tokenize_error_jython.txt b/tests/functional/t/tokenize_error_jython.txt
new file mode 100644
index 0000000..6c1abf4
--- /dev/null
+++ b/tests/functional/t/tokenize_error_jython.txt
@@ -0,0 +1 @@
+syntax-error:1::unexpected character after line continuation character
diff --git a/tests/functional/t/too/__init__.py b/tests/functional/t/too/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/t/too/__init__.py
diff --git a/tests/functional/t/too/too_few_public_methods.py b/tests/functional/t/too/too_few_public_methods.py
new file mode 100644
index 0000000..5ba528f
--- /dev/null
+++ b/tests/functional/t/too/too_few_public_methods.py
@@ -0,0 +1,50 @@
+# pylint: disable=missing-docstring, useless-object-inheritance
+from __future__ import print_function
+
+
+from enum import Enum
+
+
+class Aaaa(object): # [too-few-public-methods]
+
+ def __init__(self):
+ pass
+
+ def meth1(self):
+ print(self)
+
+ def _dontcount(self):
+ print(self)
+
+
+# Don't emit for these cases.
+class Klass(object):
+ """docstring"""
+
+ def meth1(self):
+ """first"""
+
+ def meth2(self):
+ """second"""
+
+
+class EnoughPublicMethods(Klass):
+ """We shouldn't emit too-few-public-methods for this."""
+
+
+class BossMonster(Enum):
+ """An enum does not need methods to be useful."""
+ MEGASHARK = 1
+ OCTOPUS = 2
+
+
+class DumbList:
+ """A class can define only special methods."""
+ def __init__(self, iterable):
+ self._list = list(iterable)
+
+ def __len__(self):
+ return len(self._list)
+
+ def __getitem__(self, index):
+ return self._list[index]
diff --git a/tests/functional/t/too/too_few_public_methods.txt b/tests/functional/t/too/too_few_public_methods.txt
new file mode 100644
index 0000000..a86ba6d
--- /dev/null
+++ b/tests/functional/t/too/too_few_public_methods.txt
@@ -0,0 +1 @@
+too-few-public-methods:8:0:Aaaa:Too few public methods (1/2)
diff --git a/tests/functional/t/too/too_few_public_methods_37.py b/tests/functional/t/too/too_few_public_methods_37.py
new file mode 100644
index 0000000..55fc544
--- /dev/null
+++ b/tests/functional/t/too/too_few_public_methods_37.py
@@ -0,0 +1,37 @@
+# pylint: disable=missing-docstring
+import dataclasses
+import typing
+from dataclasses import dataclass
+
+
+@dataclasses.dataclass
+class ScheduledTxSearchModel:
+ date_from = None
+ date_to = None
+
+
+@dataclass
+class ScheduledTxSearchModelOne:
+ date = None
+
+
+@dataclass(frozen=True)
+class Test:
+ some_integer: int
+
+
+class Example(typing.NamedTuple):
+ some_int: int
+
+
+@dataclasses.dataclass(frozen=True)
+class Point:
+ """A three dimensional point with x, y and z components."""
+
+ attr1: float
+ attr2: float
+ attr3: float
+
+ def to_array(self):
+ """Convert to a NumPy array `np.array((x, y, z))`."""
+ return self.attr1
diff --git a/tests/functional/t/too/too_few_public_methods_37.rc b/tests/functional/t/too/too_few_public_methods_37.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/t/too/too_few_public_methods_37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/t/too/too_many_ancestors.py b/tests/functional/t/too/too_many_ancestors.py
new file mode 100644
index 0000000..2c105ba
--- /dev/null
+++ b/tests/functional/t/too/too_many_ancestors.py
@@ -0,0 +1,45 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance, arguments-differ
+from collections.abc import MutableSequence
+
+class Aaaa(object):
+ pass
+class Bbbb(object):
+ pass
+class Cccc(object):
+ pass
+class Dddd(object):
+ pass
+class Eeee(object):
+ pass
+class Ffff(object):
+ pass
+class Gggg(object):
+ pass
+class Hhhh(object):
+ pass
+
+class Iiii(Aaaa, Bbbb, Cccc, Dddd, Eeee, Ffff, Gggg, Hhhh): # [too-many-ancestors]
+ pass
+
+class Jjjj(Iiii): # [too-many-ancestors]
+ pass
+
+
+# https://github.com/PyCQA/pylint/issues/4166
+# https://github.com/PyCQA/pylint/issues/4415
+class ItemSequence(MutableSequence):
+ """Minimal MutableSequence."""
+ def __getitem__(self, key):
+ return key
+
+ def __setitem__(self, key, value):
+ _ = key, value
+
+ def __delitem__(self, key):
+ _ = key
+
+ def insert(self, index, value):
+ _ = index, value
+
+ def __len__(self):
+ return 1
diff --git a/tests/functional/t/too/too_many_ancestors.txt b/tests/functional/t/too/too_many_ancestors.txt
new file mode 100644
index 0000000..d913ce4
--- /dev/null
+++ b/tests/functional/t/too/too_many_ancestors.txt
@@ -0,0 +1,2 @@
+too-many-ancestors:21:0:Iiii:Too many ancestors (8/7)
+too-many-ancestors:24:0:Jjjj:Too many ancestors (9/7)
diff --git a/tests/functional/t/too/too_many_arguments.py b/tests/functional/t/too/too_many_arguments.py
new file mode 100644
index 0000000..689745e
--- /dev/null
+++ b/tests/functional/t/too/too_many_arguments.py
@@ -0,0 +1,32 @@
+# pylint: disable=missing-docstring,wrong-import-position
+
+def stupid_function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9): # [too-many-arguments]
+ return arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
+
+
+class MyClass:
+ text = "MyText"
+
+ def mymethod1(self):
+ return self.text
+
+ def mymethod2(self):
+ return self.mymethod1.__get__(self, MyClass)
+
+
+MyClass().mymethod2()()
+
+
+# Check a false positive does not occur
+from functools import partial
+
+
+def root_function(first, second, third):
+ return first + second + third
+
+
+def func_call():
+ """Test we don't emit a FP for https://github.com/PyCQA/pylint/issues/2588"""
+ partial_func = partial(root_function, 1, 2, 3)
+ partial_func()
+ return root_function(1, 2, 3)
diff --git a/tests/functional/t/too/too_many_arguments.txt b/tests/functional/t/too/too_many_arguments.txt
new file mode 100644
index 0000000..d4f5516
--- /dev/null
+++ b/tests/functional/t/too/too_many_arguments.txt
@@ -0,0 +1 @@
+too-many-arguments:3:0:stupid_function:Too many arguments (9/5)
diff --git a/tests/functional/t/too/too_many_arguments_issue_1045.py b/tests/functional/t/too/too_many_arguments_issue_1045.py
new file mode 100644
index 0000000..e5aa76d
--- /dev/null
+++ b/tests/functional/t/too/too_many_arguments_issue_1045.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring
+
+# pylint: disable=unused-import, undefined-variable; false positives :-(
+
+import functools
+
+
+@functools.lru_cache()
+def func():
+ pass
+
+
+func.cache_clear()
diff --git a/tests/functional/t/too/too_many_arguments_issue_1045.rc b/tests/functional/t/too/too_many_arguments_issue_1045.rc
new file mode 100644
index 0000000..d425e7c
--- /dev/null
+++ b/tests/functional/t/too/too_many_arguments_issue_1045.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.2
diff --git a/tests/functional/t/too/too_many_arguments_overload.py b/tests/functional/t/too/too_many_arguments_overload.py
new file mode 100644
index 0000000..1155deb
--- /dev/null
+++ b/tests/functional/t/too/too_many_arguments_overload.py
@@ -0,0 +1,38 @@
+# pylint: disable=missing-function-docstring,missing-module-docstring,missing-class-docstring
+# pylint: disable=too-few-public-methods
+from typing import overload
+
+
+class ClassA:
+ @classmethod
+ @overload
+ def method(cls, arg1):
+ pass
+
+ @classmethod
+ @overload
+ def method(cls, arg1, arg2):
+ pass
+
+ @classmethod
+ def method(cls, arg1, arg2=None):
+ pass
+
+
+ClassA.method(1, 2)
+
+
+class ClassB:
+ @overload
+ def method(self, arg1):
+ pass
+
+ @overload
+ def method(self, arg1, arg2):
+ pass
+
+ def method(self, arg1, arg2=None):
+ pass
+
+
+ClassB().method(1, arg2=2)
diff --git a/tests/functional/t/too/too_many_boolean_expressions.py b/tests/functional/t/too/too_many_boolean_expressions.py
new file mode 100644
index 0000000..e875385
--- /dev/null
+++ b/tests/functional/t/too/too_many_boolean_expressions.py
@@ -0,0 +1,20 @@
+"""Checks for if statements containing too many boolean expressions"""
+
+# pylint: disable=invalid-name, comparison-with-itself, chained-comparison, condition-evals-to-constant
+
+x = y = z = 5
+if x > -5 and x < 5 and y > -5 and y < 5 and z > -5 and z < 5: # [too-many-boolean-expressions]
+ pass
+elif True and False and 1 and 2 and 3:
+ pass
+elif True and False and 1 and 2 and 3 and 4 and 5: # [too-many-boolean-expressions]
+ pass
+elif True and (True and True) and (x == 5 or True or True): # [too-many-boolean-expressions]
+ pass
+elif True and (True or (x > -5 and x < 5 and (z > -5 or z < 5))): # [too-many-boolean-expressions]
+ pass
+elif True == True == True == True == True == True:
+ pass
+
+if True and False and 1 and 2 and 3:
+ pass
diff --git a/tests/functional/t/too/too_many_boolean_expressions.txt b/tests/functional/t/too/too_many_boolean_expressions.txt
new file mode 100644
index 0000000..6055e74
--- /dev/null
+++ b/tests/functional/t/too/too_many_boolean_expressions.txt
@@ -0,0 +1,4 @@
+too-many-boolean-expressions:6:3::Too many boolean expressions in if statement (6/5)
+too-many-boolean-expressions:10:5::Too many boolean expressions in if statement (7/5)
+too-many-boolean-expressions:12:5::Too many boolean expressions in if statement (6/5)
+too-many-boolean-expressions:14:5::Too many boolean expressions in if statement (6/5)
diff --git a/tests/functional/t/too/too_many_branches.py b/tests/functional/t/too/too_many_branches.py
new file mode 100644
index 0000000..7b0b068
--- /dev/null
+++ b/tests/functional/t/too/too_many_branches.py
@@ -0,0 +1,69 @@
+""" Test for too many branches. """
+# pylint: disable=using-constant-test
+def wrong(): # [too-many-branches]
+ """ Has too many branches. """
+ if 1:
+ pass
+ elif 1:
+ pass
+ elif 1:
+ pass
+ elif 1:
+ pass
+ elif 1:
+ pass
+ elif 1:
+ pass
+ try:
+ pass
+ finally:
+ pass
+ if 2:
+ pass
+ while True:
+ pass
+ if 1:
+ pass
+ elif 2:
+ pass
+ elif 3:
+ pass
+
+def good():
+ """ Too many branches only if we take
+ into consideration the nested functions.
+ """
+ def nested_1():
+ """ empty """
+ if 1:
+ pass
+ elif 2:
+ pass
+ elif 3:
+ pass
+ elif 4:
+ pass
+
+ nested_1()
+ try:
+ pass
+ finally:
+ pass
+ try:
+ pass
+ finally:
+ pass
+ if 1:
+ pass
+ elif 2:
+ pass
+ elif 3:
+ pass
+ elif 4:
+ pass
+ elif 5:
+ pass
+ elif 6:
+ pass
+ elif 7:
+ pass
diff --git a/tests/functional/t/too/too_many_branches.txt b/tests/functional/t/too/too_many_branches.txt
new file mode 100644
index 0000000..e5bfd4d
--- /dev/null
+++ b/tests/functional/t/too/too_many_branches.txt
@@ -0,0 +1 @@
+too-many-branches:3:0:wrong:Too many branches (13/12)
diff --git a/tests/functional/t/too/too_many_instance_attributes.py b/tests/functional/t/too/too_many_instance_attributes.py
new file mode 100644
index 0000000..f6703e0
--- /dev/null
+++ b/tests/functional/t/too/too_many_instance_attributes.py
@@ -0,0 +1,26 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+
+class Aaaa(object): # [too-many-instance-attributes]
+
+ def __init__(self):
+ self.aaaa = 1
+ self.bbbb = 2
+ self.cccc = 3
+ self.dddd = 4
+ self.eeee = 5
+ self.ffff = 6
+ self.gggg = 7
+ self.hhhh = 8
+ self.iiii = 9
+ self.jjjj = 10
+ self._aaaa = 1
+ self._bbbb = 2
+ self._cccc = 3
+ self._dddd = 4
+ self._eeee = 5
+ self._ffff = 6
+ self._gggg = 7
+ self._hhhh = 8
+ self._iiii = 9
+ self._jjjj = 10
+ self.tomuch = None
diff --git a/tests/functional/t/too/too_many_instance_attributes.txt b/tests/functional/t/too/too_many_instance_attributes.txt
new file mode 100644
index 0000000..42c8549
--- /dev/null
+++ b/tests/functional/t/too/too_many_instance_attributes.txt
@@ -0,0 +1 @@
+too-many-instance-attributes:3:0:Aaaa:Too many instance attributes (21/7)
diff --git a/tests/functional/t/too/too_many_lines.py b/tests/functional/t/too/too_many_lines.py
new file mode 100644
index 0000000..78e568c
--- /dev/null
+++ b/tests/functional/t/too/too_many_lines.py
@@ -0,0 +1,1015 @@
+# pylint: disable=missing-docstring
+# -1: [too-many-lines]
+__revision__ = 0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ZERFZAER = 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HEHEHE = 2
diff --git a/tests/functional/t/too/too_many_lines.txt b/tests/functional/t/too/too_many_lines.txt
new file mode 100644
index 0000000..5c228ac
--- /dev/null
+++ b/tests/functional/t/too/too_many_lines.txt
@@ -0,0 +1 @@
+too-many-lines:1:0::Too many lines in module (1015/1000)
diff --git a/tests/functional/t/too/too_many_lines_disabled.py b/tests/functional/t/too/too_many_lines_disabled.py
new file mode 100644
index 0000000..1b0866d
--- /dev/null
+++ b/tests/functional/t/too/too_many_lines_disabled.py
@@ -0,0 +1,1018 @@
+"""Test that disabling too-many-lines on any line works."""
+
+
+
+# pylint: disable=too-many-lines
+__revision__ = 0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ZERFZAER = 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HEHEHE = 2
diff --git a/tests/functional/t/too/too_many_locals.py b/tests/functional/t/too/too_many_locals.py
new file mode 100644
index 0000000..ac38a9e
--- /dev/null
+++ b/tests/functional/t/too/too_many_locals.py
@@ -0,0 +1,60 @@
+# pylint: disable=missing-docstring
+from __future__ import print_function
+
+def function(arg1, arg2, arg3, arg4, arg5): # [too-many-locals]
+ arg6, arg7, arg8, arg9 = arg1, arg2, arg3, arg4
+ print(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+ loc1, loc2, loc3, loc4, loc5, loc6, loc7 = arg1, arg2, arg3, arg4, arg5, \
+ arg6, arg7
+ print(loc1, loc2, loc3, loc4, loc5, loc6, loc7)
+
+
+def too_many_locals_function(): # [too-many-locals]
+ """pylint will complains about too many local variables"""
+ args0 = 0
+ args1 = args0 * 1
+ args2 = args1 * 2
+ args3 = args2 * 3
+ args4 = args3 * 4
+ args5 = args4 * 5
+ args6 = args5 * 6
+ args7 = args6 * 7
+ args8 = args7 * 8
+ args9 = args8 * 9
+ args10 = args9 * 10
+ args11 = args10 * 11
+ args12 = args11 * 12
+ args13 = args12 * 13
+ args14 = args13 * 14
+ args15 = args14 * 15
+ return args15
+
+def too_many_arguments_function(arga, argu, argi, arge, argt, args): # [too-many-arguments]
+ """pylint will complains about too many arguments."""
+ arga = argu
+ arga += argi
+ arga += arge
+ arga += argt
+ arga += args
+ return arga
+
+def ignored_arguments_function(arga, argu, argi,
+ _arge=0, _argt=1, _args=None):
+ """pylint will ignore _arge, _argt, _args.
+
+ Consequently pylint will only coun 13 arguments.
+ """
+ arg0 = 0
+ arg1 = arg0 * 1 + arga
+ arg2 = arg1 * 2 + argu
+ arg3 = arg2 * 3 + argi
+ arg4 = arg3 * 4 + _arge
+ arg5 = arg4 * 5 + _argt
+ arg6 = arg5 * 6
+ arg7 = arg6 * 7
+ arg8 = arg7 * 8
+ arg9 = arg8 * 9
+ arg9 += arg0
+ if _args:
+ arg9 += sum(_args)
+ return arg9
diff --git a/tests/functional/t/too/too_many_locals.txt b/tests/functional/t/too/too_many_locals.txt
new file mode 100644
index 0000000..4af7f03
--- /dev/null
+++ b/tests/functional/t/too/too_many_locals.txt
@@ -0,0 +1,3 @@
+too-many-locals:4:0:function:Too many local variables (16/15)
+too-many-locals:12:0:too_many_locals_function:Too many local variables (16/15)
+too-many-arguments:32:0:too_many_arguments_function:Too many arguments (6/5)
diff --git a/tests/functional/t/too/too_many_nested_blocks.py b/tests/functional/t/too/too_many_nested_blocks.py
new file mode 100644
index 0000000..e7c0079
--- /dev/null
+++ b/tests/functional/t/too/too_many_nested_blocks.py
@@ -0,0 +1,97 @@
+"""Checks the maximum block level is smaller than 6 in function definitions"""
+
+#pylint: disable=using-constant-test, missing-docstring, too-many-return-statements,no-else-return
+
+def my_function():
+ if 1: # [too-many-nested-blocks]
+ for i in range(10):
+ if i == 2:
+ while True:
+ try:
+ if True:
+ i += 1
+ except IOError:
+ pass
+
+ if 1:
+ for i in range(10):
+ if i == 2:
+ while True:
+ try:
+ i += 1
+ except IOError:
+ pass
+
+ def nested_func():
+ if True:
+ for i in range(10):
+ while True:
+ if True:
+ if True:
+ yield i
+
+ nested_func()
+
+def more_complex_function():
+ attr1 = attr2 = attr3 = [1, 2, 3]
+ if attr1:
+ for i in attr1:
+ if attr2:
+ return i
+ else:
+ return 'duh'
+ elif attr2:
+ for i in attr2:
+ if attr2:
+ return i
+ else:
+ return 'duh'
+ else:
+ for i in range(15):
+ if attr3:
+ return i
+ else:
+ return 'doh'
+ return None
+
+def elif_function():
+ arg = None
+ if arg == 1:
+ return 1
+ elif arg == 2:
+ return 2
+ elif arg == 3:
+ return 3
+ elif arg == 4:
+ return 4
+ elif arg == 5:
+ return 5
+ elif arg == 6:
+ return 6
+ elif arg == 7:
+ return 7
+ return None
+
+def else_if_function():
+ arg = None
+ if arg == 1: # [too-many-nested-blocks]
+ return 1
+ else:
+ if arg == 2:
+ return 2
+ else:
+ if arg == 3:
+ return 3
+ else:
+ if arg == 4:
+ return 4
+ else:
+ if arg == 5:
+ return 5
+ else:
+ if arg == 6:
+ return 6
+ else:
+ if arg == 7:
+ return 7
+ return None
diff --git a/tests/functional/t/too/too_many_nested_blocks.txt b/tests/functional/t/too/too_many_nested_blocks.txt
new file mode 100644
index 0000000..6232b9f
--- /dev/null
+++ b/tests/functional/t/too/too_many_nested_blocks.txt
@@ -0,0 +1,2 @@
+too-many-nested-blocks:6:4:my_function:Too many nested blocks (6/5)
+too-many-nested-blocks:77:4:else_if_function:Too many nested blocks (7/5)
diff --git a/tests/functional/t/too/too_many_public_methods.py b/tests/functional/t/too/too_many_public_methods.py
new file mode 100644
index 0000000..11b4b36
--- /dev/null
+++ b/tests/functional/t/too/too_many_public_methods.py
@@ -0,0 +1,79 @@
+# pylint: disable=missing-docstring, useless-object-inheritance
+
+class Aaaa(object): # [too-many-public-methods]
+
+ def __init__(self):
+ pass
+
+ def meth1(self):
+ """hehehe"""
+
+ def meth2(self):
+ """hehehe"""
+
+ def meth3(self):
+ """hehehe"""
+
+ def meth4(self):
+ """hehehe"""
+
+ def meth5(self):
+ """hehehe"""
+
+ def meth6(self):
+ """hehehe"""
+
+ def meth7(self):
+ """hehehe"""
+
+ def meth8(self):
+ """hehehe"""
+
+ def meth9(self):
+ """hehehe"""
+
+ def meth10(self):
+ """hehehe"""
+
+ def meth11(self):
+ """hehehe"""
+
+ def meth12(self):
+ """hehehe"""
+
+ def meth13(self):
+ """hehehe"""
+
+ def meth14(self):
+ """hehehe"""
+
+ def meth15(self):
+ """hehehe"""
+
+ def meth16(self):
+ """hehehe"""
+
+ def meth17(self):
+ """hehehe"""
+
+ def meth18(self):
+ """hehehe"""
+
+ def meth19(self):
+ """hehehe"""
+
+ def meth20(self):
+ """hehehe"""
+
+ def meth21(self):
+ """hehehe"""
+
+ def _dontcount(self):
+ """not public"""
+
+class BBB(Aaaa):
+ """Don't emit for methods defined in the parent."""
+ def meth1(self):
+ """trop"""
+ def meth2(self):
+ """tzop"""
diff --git a/tests/functional/t/too/too_many_public_methods.txt b/tests/functional/t/too/too_many_public_methods.txt
new file mode 100644
index 0000000..61e47e8
--- /dev/null
+++ b/tests/functional/t/too/too_many_public_methods.txt
@@ -0,0 +1 @@
+too-many-public-methods:3:0:Aaaa:Too many public methods (21/20)
diff --git a/tests/functional/t/too/too_many_return_statements.py b/tests/functional/t/too/too_many_return_statements.py
new file mode 100644
index 0000000..66a85da
--- /dev/null
+++ b/tests/functional/t/too/too_many_return_statements.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring
+
+def stupid_function(arg): # [too-many-return-statements]
+ if arg == 1:
+ return 1
+ if arg == 2:
+ return 2
+ if arg == 3:
+ return 3
+ if arg == 4:
+ return 4
+ if arg == 5:
+ return 5
+ if arg == 6:
+ return 6
+ if arg == 7:
+ return 7
+ if arg == 8:
+ return 8
+ if arg == 9:
+ return 9
+ if arg == 10:
+ return 10
+ return None
+
+
+def many_yield(text):
+ """Not a problem"""
+ if text:
+ yield " line 1: %s\n" % text
+ yield " line 2\n"
+ yield " line 3\n"
+ yield " line 4\n"
+ yield " line 5\n"
+ else:
+ yield " line 6\n"
+ yield " line 7\n"
+ yield " line 8\n"
+ yield " line 9\n"
+ yield " line 10\n"
diff --git a/tests/functional/t/too/too_many_return_statements.txt b/tests/functional/t/too/too_many_return_statements.txt
new file mode 100644
index 0000000..5abbb71
--- /dev/null
+++ b/tests/functional/t/too/too_many_return_statements.txt
@@ -0,0 +1 @@
+too-many-return-statements:3:0:stupid_function:Too many return statements (11/6)
diff --git a/tests/functional/t/too/too_many_star_expressions.py b/tests/functional/t/too/too_many_star_expressions.py
new file mode 100644
index 0000000..c1bbfb9
--- /dev/null
+++ b/tests/functional/t/too/too_many_star_expressions.py
@@ -0,0 +1,7 @@
+"""Test for too-many-star-expressions."""
+# pylint: disable=unbalanced-tuple-unpacking
+*FIRST, *SECOND = [1, 2, 3] # [too-many-star-expressions]
+(FIRST, *SECOND), *THIRD = ((1, 2, 3), 4, 5)
+*FIRST_1, SECOND = (1, 2, 3)
+(*FIRST, *SECOND), THIRD = [...] # [too-many-star-expressions]
+((*FIRST, SECOND), *THIRD), *FOURTH = [...]
diff --git a/tests/functional/t/too/too_many_star_expressions.rc b/tests/functional/t/too/too_many_star_expressions.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/t/too/too_many_star_expressions.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/t/too/too_many_star_expressions.txt b/tests/functional/t/too/too_many_star_expressions.txt
new file mode 100644
index 0000000..d1e74b6
--- /dev/null
+++ b/tests/functional/t/too/too_many_star_expressions.txt
@@ -0,0 +1,2 @@
+too-many-star-expressions:3:0::More than one starred expression in assignment
+too-many-star-expressions:6:0::More than one starred expression in assignment
diff --git a/tests/functional/t/too/too_many_statements.py b/tests/functional/t/too/too_many_statements.py
new file mode 100644
index 0000000..7de72bc
--- /dev/null
+++ b/tests/functional/t/too/too_many_statements.py
@@ -0,0 +1,133 @@
+# pylint: disable=missing-docstring, invalid-name
+
+from __future__ import print_function
+
+def stupid_function(arg): # [too-many-statements]
+ if arg == 1:
+ print(1)
+ elif arg == 2:
+ print(1)
+ elif arg == 3:
+ print(1)
+ elif arg == 4:
+ print(1)
+ elif arg == 5:
+ print(1)
+ elif arg == 6:
+ print(1)
+ elif arg == 7:
+ print(1)
+ elif arg == 8:
+ print(1)
+ elif arg == 9:
+ print(1)
+ elif arg == 10:
+ print(1)
+ elif arg < 1:
+ print(1)
+ print(1)
+ arg = 0
+ for _ in range(arg):
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+ print(1)
+
+def long_function_with_inline_def(fake): # [too-many-statements]
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ def an_inline_function(var):
+ return var + var
+ fake = an_inline_function(fake)
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+ fake += 1
+
+
+def exmaple_function(): # [too-many-statements]
+ a = 1
+ b = 2
+ c = 3
+ d = a * b + c
+ print(d)
diff --git a/tests/functional/t/too/too_many_statements.rc b/tests/functional/t/too/too_many_statements.rc
new file mode 100644
index 0000000..d6d22f2
--- /dev/null
+++ b/tests/functional/t/too/too_many_statements.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max-statements=5
diff --git a/tests/functional/t/too/too_many_statements.txt b/tests/functional/t/too/too_many_statements.txt
new file mode 100644
index 0000000..c723dba
--- /dev/null
+++ b/tests/functional/t/too/too_many_statements.txt
@@ -0,0 +1,3 @@
+too-many-statements:5:0:stupid_function:Too many statements (55/5):HIGH
+too-many-statements:62:0:long_function_with_inline_def:Too many statements (62/5):HIGH
+too-many-statements:128:0:exmaple_function:Too many statements (6/5):HIGH
diff --git a/tests/functional/t/trailing_comma_tuple.py b/tests/functional/t/trailing_comma_tuple.py
new file mode 100644
index 0000000..de60184
--- /dev/null
+++ b/tests/functional/t/trailing_comma_tuple.py
@@ -0,0 +1,50 @@
+"""Check trailing comma one element tuples."""
+# pylint: disable=missing-docstring
+AAA = 1, # [trailing-comma-tuple]
+BBB = "aaaa", # [trailing-comma-tuple]
+CCC="aaa", # [trailing-comma-tuple]
+FFF=['f'], # [trailing-comma-tuple]
+
+BBB = 1, 2
+CCC = (1, 2, 3)
+DDD = (
+ 1, 2, 3,
+)
+EEE = (
+ "aaa",
+)
+
+
+def test(*args, **kwargs):
+ return args, kwargs
+
+
+test(widget=1, label='test')
+test(widget=1,
+ label='test')
+test(widget=1, \
+ label='test')
+
+
+def some_func(first, second):
+ if first:
+ return first, # [trailing-comma-tuple]
+ if second:
+ return (first, second,)
+ return first, second, # [trailing-comma-tuple]
+
+
+def some_other_func():
+ yield 'hello', # [trailing-comma-tuple]
+
+GGG = ["aaa"
+], # [trailing-comma-tuple]
+
+HHH = ["aaa"
+]
+
+III = some_func(0,
+ 0), # [trailing-comma-tuple]
+
+JJJ = some_func(0,
+ 0)
diff --git a/tests/functional/t/trailing_comma_tuple.rc b/tests/functional/t/trailing_comma_tuple.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/t/trailing_comma_tuple.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/t/trailing_comma_tuple.txt b/tests/functional/t/trailing_comma_tuple.txt
new file mode 100644
index 0000000..0f98b22
--- /dev/null
+++ b/tests/functional/t/trailing_comma_tuple.txt
@@ -0,0 +1,9 @@
+trailing-comma-tuple:3:0::Disallow trailing comma tuple
+trailing-comma-tuple:4:0::Disallow trailing comma tuple
+trailing-comma-tuple:5:0::Disallow trailing comma tuple
+trailing-comma-tuple:6:0::Disallow trailing comma tuple
+trailing-comma-tuple:31:0::Disallow trailing comma tuple
+trailing-comma-tuple:34:0::Disallow trailing comma tuple
+trailing-comma-tuple:38:0::Disallow trailing comma tuple
+trailing-comma-tuple:41:0::Disallow trailing comma tuple
+trailing-comma-tuple:47:0::Disallow trailing comma tuple
diff --git a/tests/functional/t/trailing_newlines.py b/tests/functional/t/trailing_newlines.py
new file mode 100644
index 0000000..8fbadbb
--- /dev/null
+++ b/tests/functional/t/trailing_newlines.py
@@ -0,0 +1,3 @@
+"""Regression test for trailing-newlines (C0304)."""
+# +1: [trailing-newlines]
+
diff --git a/tests/functional/t/trailing_newlines.txt b/tests/functional/t/trailing_newlines.txt
new file mode 100644
index 0000000..2558a71
--- /dev/null
+++ b/tests/functional/t/trailing_newlines.txt
@@ -0,0 +1 @@
+trailing-newlines:3:0::Trailing newlines
diff --git a/tests/functional/t/trailing_whitespaces.py b/tests/functional/t/trailing_whitespaces.py
new file mode 100644
index 0000000..48de809
--- /dev/null
+++ b/tests/functional/t/trailing_whitespaces.py
@@ -0,0 +1,11 @@
+"""Regression test for trailing-whitespace (C0303)."""
+# pylint: disable=mixed-line-endings
+from __future__ import print_function
+
+# +1: [trailing-whitespace]
+print('some trailing whitespace')
+# +1: [trailing-whitespace]
+print('trailing whitespace does not count towards the line length limit')
+print('windows line ends are ok')
+# +1: [trailing-whitespace]
+print('but trailing whitespace on win is not')
diff --git a/tests/functional/t/trailing_whitespaces.txt b/tests/functional/t/trailing_whitespaces.txt
new file mode 100644
index 0000000..1faabc8
--- /dev/null
+++ b/tests/functional/t/trailing_whitespaces.txt
@@ -0,0 +1,3 @@
+trailing-whitespace:6:33::Trailing whitespace
+trailing-whitespace:8:73::Trailing whitespace
+trailing-whitespace:11:46::Trailing whitespace
diff --git a/tests/functional/t/try_except_raise.py b/tests/functional/t/try_except_raise.py
new file mode 100644
index 0000000..006a29b
--- /dev/null
+++ b/tests/functional/t/try_except_raise.py
@@ -0,0 +1,111 @@
+# pylint:disable=missing-docstring, unreachable, bad-except-order, bare-except, unnecessary-pass
+# pylint: disable=undefined-variable, broad-except, raise-missing-from
+try:
+ int("9a")
+except: # [try-except-raise]
+ raise
+
+try:
+ int("9a")
+except:
+ raise ValueError('Invalid integer')
+
+
+try:
+ int("9a")
+except: # [try-except-raise]
+ raise
+ print('caught exception')
+
+try:
+ int("9a")
+except:
+ print('caught exception')
+ raise
+
+
+class AAAException(Exception):
+ """AAAException"""
+ pass
+
+class BBBException(AAAException):
+ """BBBException"""
+ pass
+
+def ccc():
+ """try-except-raise test function"""
+
+ try:
+ raise BBBException("asdf")
+ except BBBException:
+ raise
+ except AAAException:
+ raise BBBException("raised from AAAException")
+
+
+def ddd():
+ """try-except-raise test function"""
+
+ try:
+ raise BBBException("asdf")
+ except AAAException:
+ raise BBBException("raised from AAAException")
+ except: # [try-except-raise]
+ raise
+
+try:
+ pass
+except RuntimeError:
+ raise
+except:
+ print("a failure")
+
+try:
+ pass
+except:
+ print("a failure")
+except RuntimeError: # [try-except-raise]
+ raise
+
+try:
+ pass
+except: # [try-except-raise]
+ raise
+except RuntimeError:
+ print("a failure")
+
+try:
+ pass
+except (FileNotFoundError, PermissionError):
+ raise
+except OSError:
+ print("a failure")
+
+# also consider tuples for subsequent exception handler instead of just bare except handler
+try:
+ pass
+except (FileNotFoundError, PermissionError):
+ raise
+except (OverflowError, OSError):
+ print("a failure")
+
+try:
+ pass
+except (FileNotFoundError, PermissionError): # [try-except-raise]
+ raise
+except (OverflowError, ZeroDivisionError):
+ print("a failure")
+
+try:
+ pass
+except (FileNotFoundError, PermissionError):
+ raise
+except Exception:
+ print("a failure")
+
+try:
+ pass
+except (FileNotFoundError, PermissionError):
+ raise
+except (Exception,):
+ print("a failure")
diff --git a/tests/functional/t/try_except_raise.txt b/tests/functional/t/try_except_raise.txt
new file mode 100644
index 0000000..81e1fd4
--- /dev/null
+++ b/tests/functional/t/try_except_raise.txt
@@ -0,0 +1,6 @@
+try-except-raise:5:0::The except handler raises immediately
+try-except-raise:16:0::The except handler raises immediately
+try-except-raise:53:4:ddd:The except handler raises immediately
+try-except-raise:67:0::The except handler raises immediately
+try-except-raise:72:0::The except handler raises immediately
+try-except-raise:94:0::The except handler raises immediately
diff --git a/tests/functional/t/try_except_raise_crash.py b/tests/functional/t/try_except_raise_crash.py
new file mode 100644
index 0000000..48a0434
--- /dev/null
+++ b/tests/functional/t/try_except_raise_crash.py
@@ -0,0 +1,26 @@
+# pylint: disable=missing-docstring,too-many-ancestors, broad-except
+import collections.abc
+from typing import TYPE_CHECKING, Sized
+
+if TYPE_CHECKING:
+ BaseClass = Sized
+else:
+ BaseClass = collections.abc.Sized
+
+
+class TestBaseException(BaseClass):
+ def __len__(self):
+ return 0
+
+
+class TestException(TestBaseException):
+ pass
+
+
+def test():
+ try:
+ 1 / 0
+ except TestException: # [catching-non-exception,try-except-raise]
+ raise
+ except Exception:
+ pass
diff --git a/tests/functional/t/try_except_raise_crash.rc b/tests/functional/t/try_except_raise_crash.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/t/try_except_raise_crash.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/t/try_except_raise_crash.txt b/tests/functional/t/try_except_raise_crash.txt
new file mode 100644
index 0000000..0fab918
--- /dev/null
+++ b/tests/functional/t/try_except_raise_crash.txt
@@ -0,0 +1,2 @@
+catching-non-exception:23:11:test:"Catching an exception which doesn't inherit from Exception: TestException"
+try-except-raise:23:4:test:The except handler raises immediately
diff --git a/tests/functional/t/typedDict.py b/tests/functional/t/typedDict.py
new file mode 100644
index 0000000..912a4ea
--- /dev/null
+++ b/tests/functional/t/typedDict.py
@@ -0,0 +1,18 @@
+"""Test typing.TypedDict"""
+# pylint: disable=invalid-name,missing-class-docstring
+import typing
+from typing import TypedDict
+
+
+class CustomTD(TypedDict):
+ var: int
+
+class CustomTD2(typing.TypedDict, total=False):
+ var2: str
+
+class CustomTD3(CustomTD2):
+ var3: int
+
+CustomTD4 = TypedDict("CustomTD4", var4=bool)
+
+CustomTD5 = TypedDict("CustomTD5", {"var5": bool})
diff --git a/tests/functional/t/typedDict.rc b/tests/functional/t/typedDict.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/t/typedDict.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/t/typing_generic.py b/tests/functional/t/typing_generic.py
new file mode 100644
index 0000000..191d998
--- /dev/null
+++ b/tests/functional/t/typing_generic.py
@@ -0,0 +1,32 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods
+
+# https://github.com/PyCQA/pylint/issues/2822
+# Base should be subscriptable, even with ABCMeta as metaclass
+from abc import ABC, ABCMeta
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+class Base(Generic[T], metaclass=ABCMeta):
+ """Base"""
+
+class Impl(Base[str]):
+ """Impl"""
+
+
+# https://github.com/PyCQA/astroid/issues/942
+Anything = TypeVar("Anything")
+MoreSpecific = TypeVar("MoreSpecific", str, int)
+
+class A(ABC, Generic[Anything]):
+ def a_method(self) -> None: # pylint: disable=no-self-use
+ print("hello")
+
+class B(A[MoreSpecific]):
+ pass
+
+class C(B[str]):
+ pass
+
+c = C()
+c.a_method() # should NOT emit `no-member` error
diff --git a/tests/functional/t/typing_generic.rc b/tests/functional/t/typing_generic.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/t/typing_generic.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/t/typing_use.py b/tests/functional/t/typing_use.py
new file mode 100644
index 0000000..b92a087
--- /dev/null
+++ b/tests/functional/t/typing_use.py
@@ -0,0 +1,65 @@
+# pylint: disable=missing-docstring
+
+import typing
+from typing import overload
+
+@typing.overload
+def double_with_docstring(arg: str) -> str:
+ """Return arg, concatenated with itself."""
+
+
+@typing.overload
+def double_with_docstring(arg: int) -> int:
+ """Return twice arg."""
+
+
+def double_with_docstring(arg):
+ """Return 2 * arg."""
+ return 2 * arg
+
+
+def double_with_docstring(arg): # [function-redefined]
+ """Redefined function implementation"""
+ return 2 * arg
+
+
+@typing.overload
+def double_with_ellipsis(arg: str) -> str:
+ ...
+
+
+@typing.overload
+def double_with_ellipsis(arg: int) -> int:
+ ...
+
+
+def double_with_ellipsis(arg):
+ return 2 * arg
+
+
+@typing.overload
+def double_with_pass(arg: str) -> str:
+ pass
+
+
+@typing.overload
+def double_with_pass(arg: int) -> int:
+ pass
+
+
+def double_with_pass(arg):
+ return 2 * arg
+
+# pylint: disable=too-few-public-methods
+class Cls:
+ @typing.overload
+ def method(self, param: int) -> None:
+ ...
+
+ @overload
+ def method(self, param: str) -> None:
+ ...
+
+ def method(self, param):
+ return (self, param)
+# pylint: enable=too-few-public-methods
diff --git a/tests/functional/t/typing_use.rc b/tests/functional/t/typing_use.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/t/typing_use.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/t/typing_use.txt b/tests/functional/t/typing_use.txt
new file mode 100644
index 0000000..1ff53a1
--- /dev/null
+++ b/tests/functional/t/typing_use.txt
@@ -0,0 +1 @@
+function-redefined:21:0:double_with_docstring:function already defined line 16
diff --git a/tests/functional/u/__init__.py b/tests/functional/u/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/u/__init__.py
diff --git a/tests/functional/u/unbalanced_tuple_unpacking.py b/tests/functional/u/unbalanced_tuple_unpacking.py
new file mode 100644
index 0000000..ed807c0
--- /dev/null
+++ b/tests/functional/u/unbalanced_tuple_unpacking.py
@@ -0,0 +1,108 @@
+"""Check possible unbalanced tuple unpacking """
+from __future__ import absolute_import
+from functional.u.unpacking import unpack
+
+# pylint: disable=using-constant-test, useless-object-inheritance,import-outside-toplevel
+
+def do_stuff():
+ """This is not right."""
+ first, second = 1, 2, 3 # [unbalanced-tuple-unpacking]
+ return first + second
+
+def do_stuff1():
+ """This is not right."""
+ first, second = [1, 2, 3] # [unbalanced-tuple-unpacking]
+ return first + second
+
+def do_stuff2():
+ """This is not right."""
+ (first, second) = 1, 2, 3 # [unbalanced-tuple-unpacking]
+ return first + second
+
+def do_stuff3():
+ """This is not right."""
+ first, second = range(100)
+ return first + second
+
+def do_stuff4():
+ """ This is right """
+ first, second = 1, 2
+ return first + second
+
+def do_stuff5():
+ """ This is also right """
+ first, second = (1, 2)
+ return first + second
+
+def do_stuff6():
+ """ This is right """
+ (first, second) = (1, 2)
+ return first + second
+
+def temp():
+ """ This is not weird """
+ if True:
+ return [1, 2]
+ return [2, 3, 4]
+
+def do_stuff7():
+ """ This is not right, but we're not sure """
+ first, second = temp()
+ return first + second
+
+def temp2():
+ """ This is weird, but correct """
+ if True:
+ return (1, 2)
+
+ if True:
+ return (2, 3)
+ return (4, 5)
+
+def do_stuff8():
+ """ This is correct """
+ first, second = temp2()
+ return first + second
+
+def do_stuff9():
+ """ This is not correct """
+ first, second = unpack() # [unbalanced-tuple-unpacking]
+ return first + second
+
+class UnbalancedUnpacking(object):
+ """ Test unbalanced tuple unpacking in instance attributes. """
+ # pylint: disable=attribute-defined-outside-init, invalid-name, too-few-public-methods
+ def test(self):
+ """ unpacking in instance attributes """
+ # we're not sure if temp() returns two or three values
+ # so we shouldn't emit an error
+ self.a, self.b = temp()
+ self.a, self.b = temp2()
+ self.a, self.b = unpack() # [unbalanced-tuple-unpacking]
+
+
+def issue329(*args):
+ """ Don't emit unbalanced tuple unpacking if the
+ rhs of the assignment is a variable-length argument,
+ because we don't know the actual length of the tuple.
+ """
+ first, second, third = args
+ return first, second, third
+
+
+def test_decimal():
+ """Test a false positive with decimal.Decimal.as_tuple
+
+ See astroid https://bitbucket.org/logilab/astroid/issues/92/
+ """
+ from decimal import Decimal
+ dec = Decimal(2)
+ first, second, third = dec.as_tuple()
+ return first, second, third
+
+
+def test_issue_559():
+ """Test that we don't have a false positive wrt to issue #559."""
+ from ctypes import c_int
+ root_x, root_y, win_x, win_y = [c_int()] * 4
+ return root_x, root_y, win_x, win_y
diff --git a/tests/functional/u/unbalanced_tuple_unpacking.txt b/tests/functional/u/unbalanced_tuple_unpacking.txt
new file mode 100644
index 0000000..e13d96a
--- /dev/null
+++ b/tests/functional/u/unbalanced_tuple_unpacking.txt
@@ -0,0 +1,5 @@
+unbalanced-tuple-unpacking:9:4:do_stuff:"Possible unbalanced tuple unpacking with sequence (1, 2, 3): left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:14:4:do_stuff1:"Possible unbalanced tuple unpacking with sequence [1, 2, 3]: left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:19:4:do_stuff2:"Possible unbalanced tuple unpacking with sequence (1, 2, 3): left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:69:4:do_stuff9:"Possible unbalanced tuple unpacking with sequence defined at line 7 of functional.u.unpacking: left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:81:8:UnbalancedUnpacking.test:"Possible unbalanced tuple unpacking with sequence defined at line 7 of functional.u.unpacking: left side has 2 label(s), right side has 3 value(s)"
diff --git a/tests/functional/u/unbalanced_tuple_unpacking_py30.py b/tests/functional/u/unbalanced_tuple_unpacking_py30.py
new file mode 100644
index 0000000..68f5fb7
--- /dev/null
+++ b/tests/functional/u/unbalanced_tuple_unpacking_py30.py
@@ -0,0 +1,11 @@
+""" Test that using starred nodes in unpacking
+does not trigger a false positive on Python 3.
+"""
+
+__revision__ = 1
+
+def test():
+ """ Test that starred expressions don't give false positives. """
+ first, second, *last = (1, 2, 3, 4)
+ *last, = (1, 2)
+ return (first, second, last)
diff --git a/tests/functional/u/unbalanced_tuple_unpacking_py30.rc b/tests/functional/u/unbalanced_tuple_unpacking_py30.rc
new file mode 100644
index 0000000..c0490a6
--- /dev/null
+++ b/tests/functional/u/unbalanced_tuple_unpacking_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/u/undefined/undefined_loop_variable.py b/tests/functional/u/undefined/undefined_loop_variable.py
new file mode 100644
index 0000000..a984898
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_loop_variable.py
@@ -0,0 +1,75 @@
+# pylint: disable=missing-docstring,redefined-builtin
+
+def do_stuff(some_random_list):
+ for var in some_random_list:
+ pass
+ return var # [undefined-loop-variable]
+
+
+def do_else(some_random_list):
+ for var in some_random_list:
+ if var == 42:
+ break
+ else:
+ var = 84
+ return var
+
+__revision__ = 'yo'
+
+TEST_LC = [C for C in __revision__ if C.isalpha()]
+B = [B for B in __revision__ if B.isalpha()]
+VAR2 = B # nor this one
+
+for var1, var2 in TEST_LC:
+ var1 = var2 + 4
+VAR3 = var1 # [undefined-loop-variable]
+
+for note in __revision__:
+ note.something()
+for line in __revision__:
+ for note in line:
+ A = note.anotherthing()
+
+
+for x in []:
+ pass
+for x in range(3):
+ VAR5 = (lambda: x)()
+
+
+def do_stuff_with_a_list():
+ for var in [1, 2, 3]:
+ pass
+ return var
+
+
+def do_stuff_with_a_set():
+ for var in {1, 2, 3}:
+ pass
+ return var
+
+
+def do_stuff_with_a_dict():
+ for var in {1: 2, 3: 4}:
+ pass
+ return var
+
+
+def do_stuff_with_a_tuple():
+ for var in (1, 2, 3):
+ pass
+ return var
+
+
+def do_stuff_with_a_range():
+ for var in range(1, 2):
+ pass
+ return var
+
+
+def do_stuff_with_redefined_range():
+ def range(key):
+ yield from [1, key]
+ for var in range(3):
+ pass
+ return var # [undefined-loop-variable]
diff --git a/tests/functional/u/undefined/undefined_loop_variable.txt b/tests/functional/u/undefined/undefined_loop_variable.txt
new file mode 100644
index 0000000..ea194e7
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_loop_variable.txt
@@ -0,0 +1,3 @@
+undefined-loop-variable:6:11:do_stuff:Using possibly undefined loop variable 'var'
+undefined-loop-variable:25:7::Using possibly undefined loop variable 'var1'
+undefined-loop-variable:75:11:do_stuff_with_redefined_range:Using possibly undefined loop variable 'var'
diff --git a/tests/functional/u/undefined/undefined_variable.py b/tests/functional/u/undefined/undefined_variable.py
new file mode 100644
index 0000000..7fe205c
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable.py
@@ -0,0 +1,296 @@
+# pylint: disable=missing-docstring, multiple-statements, useless-object-inheritance,import-outside-toplevel
+# pylint: disable=too-few-public-methods, no-init, no-self-use,bare-except,broad-except, import-error
+from __future__ import print_function
+
+# pylint: disable=wrong-import-position
+from typing import TYPE_CHECKING
+
+DEFINED = 1
+
+if DEFINED != 1:
+ if DEFINED in (unknown, DEFINED): # [undefined-variable]
+ DEFINED += 1
+
+
+def in_method(var):
+ """method doc"""
+ var = nomoreknown # [undefined-variable]
+ assert var
+
+DEFINED = {DEFINED:__revision__} # [undefined-variable]
+# +1:[undefined-variable]
+DEFINED[__revision__] = OTHER = 'move this is astroid test'
+
+OTHER += '$'
+
+def bad_default(var, default=unknown2): # [undefined-variable]
+ """function with defaut arg's value set to an unexistant name"""
+ print(var, default)
+ print(xxxx) # [undefined-variable]
+ augvar += 1 # [undefined-variable]
+ del vardel # [undefined-variable]
+
+LMBD = lambda x, y=doesnotexist: x+y # [undefined-variable]
+LMBD2 = lambda x, y: x+z # [undefined-variable]
+
+try:
+ POUET # don't catch me
+except NameError:
+ POUET = 'something'
+
+try:
+ POUETT # [used-before-assignment]
+except Exception: # pylint:disable = broad-except
+ POUETT = 'something'
+
+try:
+ POUETTT # don't catch me
+except: # pylint:disable = bare-except
+ POUETTT = 'something'
+
+print(POUET, POUETT, POUETTT)
+
+
+try:
+ PLOUF # [used-before-assignment]
+except ValueError:
+ PLOUF = 'something'
+
+print(PLOUF)
+
+def if_branch_test(something):
+ """hop"""
+ if something == 0:
+ if xxx == 1: # [used-before-assignment]
+ pass
+ else:
+ print(xxx)
+ xxx = 3
+
+
+def decorator(arg):
+ """Decorator with one argument."""
+ return lambda: list(arg)
+
+
+@decorator(arg=[i * 2 for i in range(15)])
+def func1():
+ """A function with a decorator that contains a listcomp."""
+
+@decorator(arg=(i * 2 for i in range(15)))
+def func2():
+ """A function with a decorator that contains a genexpr."""
+
+@decorator(lambda x: x > 0)
+def main():
+ """A function with a decorator that contains a lambda."""
+
+# Test shared scope.
+
+def test_arguments(arg=TestClass): # [used-before-assignment]
+ """ TestClass isn't defined yet. """
+ return arg
+
+class TestClass(Ancestor): # [used-before-assignment]
+ """ contains another class, which uses an undefined ancestor. """
+
+ class MissingAncestor(Ancestor1): # [used-before-assignment]
+ """ no op """
+
+ def test1(self):
+ """ It should trigger here, because the two classes
+ have the same scope.
+ """
+ class UsingBeforeDefinition(Empty): # [used-before-assignment]
+ """ uses Empty before definition """
+ class Empty(object):
+ """ no op """
+ return UsingBeforeDefinition
+
+ def test(self):
+ """ Ancestor isn't defined yet, but we don't care. """
+ class MissingAncestor1(Ancestor):
+ """ no op """
+ return MissingAncestor1
+
+class Self(object):
+ """ Detect when using the same name inside the class scope. """
+ obj = Self # [undefined-variable]
+
+class Self1(object):
+ """ No error should be raised here. """
+
+ def test(self):
+ """ empty """
+ return Self1
+
+
+class Ancestor(object):
+ """ No op """
+
+class Ancestor1(object):
+ """ No op """
+
+NANA = BAT # [undefined-variable]
+del BAT
+
+
+class KeywordArgument(object):
+ """Test keyword arguments."""
+
+ enable = True
+ def test(self, is_enabled=enable):
+ """do nothing."""
+
+ def test1(self, is_enabled=enabled): # [used-before-assignment]
+ """enabled is undefined at this point, but it is used before assignment."""
+
+ def test2(self, is_disabled=disabled): # [undefined-variable]
+ """disabled is undefined"""
+
+ enabled = True
+
+ func = lambda arg=arg: arg * arg # [undefined-variable]
+
+ arg2 = 0
+ func2 = lambda arg2=arg2: arg2 * arg2
+
+# Don't emit if the code is protected by NameError
+try:
+ unicode_1
+except NameError:
+ pass
+
+try:
+ unicode_2 # [undefined-variable]
+except Exception:
+ pass
+
+try:
+ unicode_3 # [undefined-variable]
+except ValueError:
+ pass
+
+# See https://bitbucket.org/logilab/pylint/issue/111/
+try: raise IOError(1, "a")
+except IOError as err: print(err)
+
+
+def test_conditional_comprehension():
+ methods = ['a', 'b', '_c', '_d']
+ my_methods = sum(1 for method in methods
+ if not method.startswith('_'))
+ return my_methods
+
+
+class MyError(object):
+ pass
+
+
+class MyClass(object):
+ class MyError(MyError):
+ pass
+
+
+def dec(inp):
+ def inner(func):
+ print(inp)
+ return func
+ return inner
+
+# Make sure lambdas with expressions
+# referencing parent class do not raise undefined variable
+# because at the time of their calling, the class name will
+# be populated
+# See https://github.com/PyCQA/pylint/issues/704
+class LambdaClass:
+ myattr = 1
+ mylambda = lambda: LambdaClass.myattr
+
+# Need different classes to make sure
+# consumed variables don't get in the way
+class LambdaClass2:
+ myattr = 1
+ # Different base_scope scope but still applies
+ mylambda2 = lambda: [LambdaClass2.myattr for _ in [1, 2]]
+
+class LambdaClass3:
+ myattr = 1
+ # Nested default argument in lambda
+ # Should not raise error
+ mylambda3 = lambda: lambda a=LambdaClass3: a
+
+class LambdaClass4:
+ myattr = 1
+ mylambda4 = lambda a=LambdaClass4: lambda: a # [undefined-variable]
+
+# Make sure the first lambda does not consume the LambdaClass5 class
+# name although the expression is is valid
+# Consuming the class would cause the subsequent undefined-variable to be masked
+class LambdaClass5:
+ myattr = 1
+ mylambda = lambda: LambdaClass5.myattr
+ mylambda4 = lambda a=LambdaClass5: lambda: a # [undefined-variable]
+
+
+def nonlocal_in_ifexp():
+ import matplotlib.pyplot as plt
+ def onclick(event):
+ if event:
+ nonlocal i
+ i += 1
+ print(i)
+ i = 0
+ fig = plt.figure()
+ fig.canvas.mpl_connect('button_press_event', onclick)
+ plt.show(block=True)
+
+
+
+if TYPE_CHECKING:
+ from datetime import datetime
+
+
+def func_should_fail(_dt: datetime): # [used-before-assignment]
+ pass
+
+
+# The following should not emit an error.
+# pylint: disable=invalid-name
+if TYPE_CHECKING:
+ from typing_extensions import Literal
+
+ AllowedValues = Literal['hello', 'world']
+
+
+if TYPE_CHECKING:
+ from collections import Counter
+ from collections import OrderedDict
+else:
+ Counter = object
+ OrderedDict = object
+
+
+def tick(counter: Counter, name: str, dictionary: OrderedDict) -> OrderedDict:
+ counter[name] += 1
+ return dictionary
+
+
+# pylint: disable=unused-argument
+def not_using_loop_variable_accordingly(iterator):
+ for iteree in iteree: # [undefined-variable]
+ yield iteree
+# pylint: enable=unused-argument
+
+
+class DunderClass:
+ def method(self):
+ # This name is not defined in the AST but it's present at runtime
+ return __class__
+
+
+def undefined_annotation(a:x): # [undefined-variable]
+ if x == 2: # [used-before-assignment]
+ for x in [1, 2]:
+ pass
+ return a
diff --git a/tests/functional/u/undefined/undefined_variable.txt b/tests/functional/u/undefined/undefined_variable.txt
new file mode 100644
index 0000000..384a3a3
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable.txt
@@ -0,0 +1,30 @@
+undefined-variable:11:19::Undefined variable 'unknown'
+undefined-variable:17:10:in_method:Undefined variable 'nomoreknown'
+undefined-variable:20:19::Undefined variable '__revision__'
+undefined-variable:22:8::Undefined variable '__revision__'
+undefined-variable:26:29:bad_default:Undefined variable 'unknown2'
+undefined-variable:29:10:bad_default:Undefined variable 'xxxx'
+undefined-variable:30:4:bad_default:Undefined variable 'augvar'
+undefined-variable:31:8:bad_default:Undefined variable 'vardel'
+undefined-variable:33:19:<lambda>:Undefined variable 'doesnotexist'
+undefined-variable:34:23:<lambda>:Undefined variable 'z'
+used-before-assignment:42:4::Using variable 'POUETT' before assignment
+used-before-assignment:55:4::Using variable 'PLOUF' before assignment
+used-before-assignment:64:11:if_branch_test:Using variable 'xxx' before assignment
+used-before-assignment:90:23:test_arguments:Using variable 'TestClass' before assignment
+used-before-assignment:94:16:TestClass:Using variable 'Ancestor' before assignment
+used-before-assignment:97:26:TestClass.MissingAncestor:Using variable 'Ancestor1' before assignment
+used-before-assignment:104:36:TestClass.test1.UsingBeforeDefinition:Using variable 'Empty' before assignment
+undefined-variable:118:10:Self:Undefined variable 'Self'
+undefined-variable:134:7::Undefined variable 'BAT'
+used-before-assignment:145:31:KeywordArgument.test1:Using variable 'enabled' before assignment
+undefined-variable:148:32:KeywordArgument.test2:Undefined variable 'disabled'
+undefined-variable:153:22:KeywordArgument.<lambda>:Undefined variable 'arg'
+undefined-variable:165:4::Undefined variable 'unicode_2'
+undefined-variable:170:4::Undefined variable 'unicode_3'
+undefined-variable:225:25:LambdaClass4.<lambda>:Undefined variable 'LambdaClass4'
+undefined-variable:233:25:LambdaClass5.<lambda>:Undefined variable 'LambdaClass5'
+used-before-assignment:254:26:func_should_fail:Using variable 'datetime' before assignment
+undefined-variable:281:18:not_using_loop_variable_accordingly:Undefined variable 'iteree'
+undefined-variable:292:27:undefined_annotation:Undefined variable 'x'
+used-before-assignment:293:7:undefined_annotation:Using variable 'x' before assignment
diff --git a/tests/functional/u/undefined/undefined_variable_crash_on_attribute.py b/tests/functional/u/undefined/undefined_variable_crash_on_attribute.py
new file mode 100644
index 0000000..571efab
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable_crash_on_attribute.py
@@ -0,0 +1,6 @@
+# pylint: disable=import-error,missing-module-docstring,missing-class-docstring,too-few-public-methods
+import unknown
+
+
+class Cls(metaclass=unknown.path.MetaFoo):
+ pass
diff --git a/tests/functional/u/undefined/undefined_variable_py30.py b/tests/functional/u/undefined/undefined_variable_py30.py
new file mode 100644
index 0000000..78d6dd3
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable_py30.py
@@ -0,0 +1,86 @@
+"""Test warnings about access to undefined variables
+for various Python 3 constructs. """
+# pylint: disable=too-few-public-methods, no-init, no-self-use, import-error
+# pylint: disable=wrong-import-position, invalid-metaclass, useless-object-inheritance
+class Undefined:
+ """ test various annotation problems. """
+
+ def test(self)->Undefined: # [undefined-variable]
+ """ used Undefined, which is Undefined in this scope. """
+
+ Undefined = True
+
+ def test1(self)->Undefined:
+ """ This Undefined exists at local scope. """
+
+ def test2(self):
+ """ This should not emit. """
+ def func()->Undefined:
+ """ empty """
+ return 2
+ return func
+
+
+class Undefined1:
+ """ Other annotation problems. """
+
+ Undef = 42
+ ABC = 42
+
+ class InnerScope:
+ """ Test inner scope definition. """
+
+ def test_undefined(self)->Undef: # [undefined-variable]
+ """ Looking at a higher scope is impossible. """
+
+ def test1(self)->ABC: # [undefined-variable]
+ """ Triggers undefined-variable. """
+
+
+class FalsePositive342(object):
+ # pylint: disable=line-too-long
+ """ Fix some false positives found in
+ https://bitbucket.org/logilab/pylint/issue/342/spurious-undefined-variable-for-class
+ """
+
+ top = 42
+
+ def test_good(self, bac: top):
+ """ top is defined at this moment. """
+
+ def test_bad(self, bac: trop): # [undefined-variable]
+ """ trop is undefined at this moment. """
+
+ def test_bad1(self, *args: trop1): # [undefined-variable]
+ """ trop1 is undefined at this moment. """
+
+ def test_bad2(self, **bac: trop2): # [undefined-variable]
+ """ trop2 is undefined at this moment. """
+
+import abc
+from abc import ABCMeta
+
+class Bad(metaclass=ABCMet): # [undefined-variable]
+ """ Notice the typo """
+
+class SecondBad(metaclass=ab.ABCMeta): # [undefined-variable]
+ """ Notice the `ab` module. """
+
+class Good(metaclass=int):
+ """ int is not a proper metaclass, but it is defined. """
+
+class SecondGood(metaclass=Good):
+ """ empty """
+
+class ThirdGood(metaclass=ABCMeta):
+ """ empty """
+
+class FourthGood(ThirdGood):
+ """ This should not trigger anything. """
+
+class FifthGood(metaclass=abc.Metaclass):
+ """Metaclasses can come from imported modules."""
+
+# The following used to raise used-before-assignment
+# pylint: disable=missing-docstring, multiple-statements
+def used_before_assignment(*, arg): return arg + 1
diff --git a/tests/functional/u/undefined/undefined_variable_py30.rc b/tests/functional/u/undefined/undefined_variable_py30.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/u/undefined/undefined_variable_py30.txt b/tests/functional/u/undefined/undefined_variable_py30.txt
new file mode 100644
index 0000000..e40ecd1
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable_py30.txt
@@ -0,0 +1,8 @@
+undefined-variable:8:20:Undefined.test:Undefined variable 'Undefined'
+undefined-variable:33:34:Undefined1.InnerScope.test_undefined:Undefined variable 'Undef'
+undefined-variable:36:25:Undefined1.InnerScope.test1:Undefined variable 'ABC'
+undefined-variable:51:28:FalsePositive342.test_bad:Undefined variable 'trop'
+undefined-variable:54:31:FalsePositive342.test_bad1:Undefined variable 'trop1'
+undefined-variable:57:31:FalsePositive342.test_bad2:Undefined variable 'trop2'
+undefined-variable:63:0:Bad:Undefined variable 'ABCMet'
+undefined-variable:66:0:SecondBad:Undefined variable 'ab'
diff --git a/tests/functional/u/unexpected_special_method_signature.py b/tests/functional/u/unexpected_special_method_signature.py
new file mode 100644
index 0000000..aba6811
--- /dev/null
+++ b/tests/functional/u/unexpected_special_method_signature.py
@@ -0,0 +1,120 @@
+"""Test for special methods implemented incorrectly."""
+
+# pylint: disable=missing-docstring, unused-argument, too-few-public-methods
+# pylint: disable=invalid-name,too-many-arguments,bad-staticmethod-argument, useless-object-inheritance
+
+class Invalid(object):
+
+ def __enter__(self, other): # [unexpected-special-method-signature]
+ pass
+
+ def __del__(self, other): # [unexpected-special-method-signature]
+ pass
+
+ def __format__(self, other, other2): # [unexpected-special-method-signature]
+ pass
+
+ def __setattr__(self): # [unexpected-special-method-signature]
+ pass
+
+ def __round__(self, invalid, args): # [unexpected-special-method-signature]
+ pass
+
+ def __deepcopy__(self, memo, other): # [unexpected-special-method-signature]
+ pass
+
+ def __iter__(): # [no-method-argument]
+ pass
+
+ @staticmethod
+ def __getattr__(self, nanana): # [unexpected-special-method-signature]
+ pass
+
+
+class FirstBadContextManager(object):
+ def __enter__(self):
+ return self
+ def __exit__(self, exc_type): # [unexpected-special-method-signature]
+ pass
+
+class SecondBadContextManager(object):
+ def __enter__(self):
+ return self
+ def __exit__(self, exc_type, value, tb, stack): # [unexpected-special-method-signature]
+ pass
+
+class ThirdBadContextManager(object):
+ def __enter__(self):
+ return self
+
+ # +1: [unexpected-special-method-signature]
+ def __exit__(self, exc_type, value, tb, stack, *args):
+ pass
+
+
+class Async(object):
+
+ def __aiter__(self, extra): # [unexpected-special-method-signature]
+ pass
+ def __anext__(self, extra, argument): # [unexpected-special-method-signature]
+ pass
+ def __await__(self, param): # [unexpected-special-method-signature]
+ pass
+ def __aenter__(self, first): # [unexpected-special-method-signature]
+ pass
+ def __aexit__(self): # [unexpected-special-method-signature]
+ pass
+
+
+class Valid(object):
+
+ def __new__(cls, test, multiple, args):
+ pass
+
+ def __init__(self, this, can, have, multiple, args, as_well):
+ pass
+
+ def __call__(self, also, trv, for_this):
+ pass
+
+ def __round__(self, n):
+ pass
+
+ def __index__(self, n=42):
+ """Expects 0 args, but we are taking in account arguments with defaults."""
+
+ def __deepcopy__(self, memo):
+ pass
+
+ def __format__(self, format_specification=''):
+ pass
+
+ def __copy__(self, this=None, is_not=None, necessary=None):
+ pass
+
+ @staticmethod
+ def __enter__():
+ pass
+
+ @staticmethod
+ def __getitem__(index):
+ pass
+
+
+class FirstGoodContextManager(object):
+ def __enter__(self):
+ return self
+ def __exit__(self, exc_type, value, tb):
+ pass
+
+class SecondGoodContextManager(object):
+ def __enter__(self):
+ return self
+ def __exit__(self, exc_type=None, value=None, tb=None):
+ pass
+
+class ThirdGoodContextManager(object):
+ def __enter__(self):
+ return self
+ def __exit__(self, exc_type, *args):
+ pass
diff --git a/tests/functional/u/unexpected_special_method_signature.txt b/tests/functional/u/unexpected_special_method_signature.txt
new file mode 100644
index 0000000..607f7d1
--- /dev/null
+++ b/tests/functional/u/unexpected_special_method_signature.txt
@@ -0,0 +1,16 @@
+unexpected-special-method-signature:8:4:Invalid.__enter__:The special method '__enter__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:11:4:Invalid.__del__:The special method '__del__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:14:4:Invalid.__format__:The special method '__format__' expects 1 param(s), 2 were given
+unexpected-special-method-signature:17:4:Invalid.__setattr__:The special method '__setattr__' expects 2 param(s), 0 was given
+unexpected-special-method-signature:20:4:Invalid.__round__:The special method '__round__' expects between 0 or 1 param(s), 2 were given
+unexpected-special-method-signature:23:4:Invalid.__deepcopy__:The special method '__deepcopy__' expects 1 param(s), 2 were given
+no-method-argument:26:4:Invalid.__iter__:Method has no argument
+unexpected-special-method-signature:30:4:Invalid.__getattr__:The special method '__getattr__' expects 1 param(s), 2 were given
+unexpected-special-method-signature:37:4:FirstBadContextManager.__exit__:The special method '__exit__' expects 3 param(s), 1 was given
+unexpected-special-method-signature:43:4:SecondBadContextManager.__exit__:The special method '__exit__' expects 3 param(s), 4 were given
+unexpected-special-method-signature:51:4:ThirdBadContextManager.__exit__:The special method '__exit__' expects 3 param(s), 4 were given
+unexpected-special-method-signature:57:4:Async.__aiter__:The special method '__aiter__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:59:4:Async.__anext__:The special method '__anext__' expects 0 param(s), 2 were given
+unexpected-special-method-signature:61:4:Async.__await__:The special method '__await__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:63:4:Async.__aenter__:The special method '__aenter__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:65:4:Async.__aexit__:The special method '__aexit__' expects 3 param(s), 0 was given
diff --git a/tests/functional/u/ungrouped_imports.py b/tests/functional/u/ungrouped_imports.py
new file mode 100644
index 0000000..9c0862b
--- /dev/null
+++ b/tests/functional/u/ungrouped_imports.py
@@ -0,0 +1,26 @@
+"""Checks import order rule"""
+# pylint: disable=unused-import,wrong-import-position,wrong-import-order,using-constant-test
+# pylint: disable=import-error
+import six
+import logging.config
+import os.path
+from astroid import are_exclusive
+import logging # [ungrouped-imports]
+import unused_import
+try:
+ import os # [ungrouped-imports]
+except ImportError:
+ pass
+from os import pardir
+import scipy
+from os import sep
+from astroid import exceptions # [ungrouped-imports]
+if True:
+ import logging.handlers # [ungrouped-imports]
+from os.path import join # [ungrouped-imports]
+# Test related to compatibility with isort:
+# We check that we do not create error with the old way pylint was handling it
+import subprocess
+import unittest
+from unittest import TestCase
+from unittest.mock import MagicMock
diff --git a/tests/functional/u/ungrouped_imports.txt b/tests/functional/u/ungrouped_imports.txt
new file mode 100644
index 0000000..a23d999
--- /dev/null
+++ b/tests/functional/u/ungrouped_imports.txt
@@ -0,0 +1,5 @@
+ungrouped-imports:8:0::Imports from package logging are not grouped
+ungrouped-imports:11:4::Imports from package os are not grouped
+ungrouped-imports:17:0::Imports from package astroid are not grouped
+ungrouped-imports:19:4::Imports from package logging are not grouped
+ungrouped-imports:20:0::Imports from package os are not grouped
diff --git a/tests/functional/u/ungrouped_imports_isort_compatible.py b/tests/functional/u/ungrouped_imports_isort_compatible.py
new file mode 100644
index 0000000..2e64ed4
--- /dev/null
+++ b/tests/functional/u/ungrouped_imports_isort_compatible.py
@@ -0,0 +1,6 @@
+"""Checks import order rule with imports that isort could generate"""
+# pylint: disable=unused-import
+import astroid
+import isort
+from astroid import are_exclusive, decorators
+from astroid.modutils import get_module_part, is_standard_module
diff --git a/tests/functional/u/unhashable_dict_key.py b/tests/functional/u/unhashable_dict_key.py
new file mode 100644
index 0000000..fe6142f
--- /dev/null
+++ b/tests/functional/u/unhashable_dict_key.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,expression-not-assigned,too-few-public-methods,pointless-statement, useless-object-inheritance
+
+
+class Unhashable(object):
+ __hash__ = list.__hash__
+
+{}[[1, 2, 3]] # [unhashable-dict-key]
+{}[{}] # [unhashable-dict-key]
+{}[Unhashable()] # [unhashable-dict-key]
+{}[1:2] # [unhashable-dict-key]
+{'foo': 'bar'}['foo']
+{'foo': 'bar'}[42]
diff --git a/tests/functional/u/unhashable_dict_key.txt b/tests/functional/u/unhashable_dict_key.txt
new file mode 100644
index 0000000..d108769
--- /dev/null
+++ b/tests/functional/u/unhashable_dict_key.txt
@@ -0,0 +1,4 @@
+unhashable-dict-key:7:0::Dict key is unhashable
+unhashable-dict-key:8:0::Dict key is unhashable
+unhashable-dict-key:9:0::Dict key is unhashable
+unhashable-dict-key:10:0::Dict key is unhashable
diff --git a/tests/functional/u/unidiomatic_typecheck.py b/tests/functional/u/unidiomatic_typecheck.py
new file mode 100644
index 0000000..302bcc2
--- /dev/null
+++ b/tests/functional/u/unidiomatic_typecheck.py
@@ -0,0 +1,70 @@
+"""Warnings for using type(x) == Y or type(x) is Y instead of isinstance(x, Y)."""
+# pylint: disable=missing-docstring,expression-not-assigned,redefined-builtin,invalid-name
+
+def simple_positives():
+ type(42) is int # [unidiomatic-typecheck]
+ type(42) is not int # [unidiomatic-typecheck]
+ type(42) == int # [unidiomatic-typecheck]
+ type(42) != int # [unidiomatic-typecheck]
+
+def simple_inference_positives():
+ alias = type
+ alias(42) is int # [unidiomatic-typecheck]
+ alias(42) is not int # [unidiomatic-typecheck]
+ alias(42) == int # [unidiomatic-typecheck]
+ alias(42) != int # [unidiomatic-typecheck]
+
+def type_creation_negatives():
+ type('Q', (object,), dict(a=1)) is int
+ type('Q', (object,), dict(a=1)) is not int
+ type('Q', (object,), dict(a=1)) == int
+ type('Q', (object,), dict(a=1)) != int
+
+def invalid_type_call_negatives(**kwargs):
+ type(bad=7) is int
+ type(bad=7) is not int
+ type(bad=7) == int
+ type(bad=7) != int
+ type(bad=7) in [int]
+ type(bad=7) not in [int]
+ type('bad', 7) is int
+ type('bad', 7) is not int
+ type('bad', 7) == int
+ type('bad', 7) != int
+ type('bad', 7) in [int]
+ type('bad', 7) not in [int]
+ type(**kwargs) is int
+ type(**kwargs) is not int
+ type(**kwargs) == int
+ type(**kwargs) != int
+ type(**kwargs) in [int]
+ type(**kwargs) not in [int]
+
+def local_var_shadowing_inference_negatives():
+ type = lambda dummy: 7
+ type(42) is int
+ type(42) is not int
+ type(42) == int
+ type(42) != int
+ type(42) in [int]
+ type(42) not in [int]
+
+def parameter_shadowing_inference_negatives(type):
+ type(42) is int
+ type(42) is not int
+ type(42) == int
+ type(42) != int
+ type(42) in [int]
+ type(42) not in [int]
+
+def deliberate_subclass_check_negatives(b):
+ type(42) is type(b)
+ type(42) is not type(b)
+
+def type_of_literals_positives(a):
+ type(a) is type([]) # [unidiomatic-typecheck]
+ type(a) is not type([]) # [unidiomatic-typecheck]
+ type(a) is type({}) # [unidiomatic-typecheck]
+ type(a) is not type({}) # [unidiomatic-typecheck]
+ type(a) is type("") # [unidiomatic-typecheck]
+ type(a) is not type("") # [unidiomatic-typecheck]
diff --git a/tests/functional/u/unidiomatic_typecheck.txt b/tests/functional/u/unidiomatic_typecheck.txt
new file mode 100644
index 0000000..7302b5a
--- /dev/null
+++ b/tests/functional/u/unidiomatic_typecheck.txt
@@ -0,0 +1,14 @@
+unidiomatic-typecheck:5:4:simple_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:6:4:simple_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:7:4:simple_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:8:4:simple_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:12:4:simple_inference_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:13:4:simple_inference_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:14:4:simple_inference_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:15:4:simple_inference_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:65:4:type_of_literals_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:66:4:type_of_literals_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:67:4:type_of_literals_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:68:4:type_of_literals_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:69:4:type_of_literals_positives:Use isinstance() rather than type() for a typecheck.
+unidiomatic-typecheck:70:4:type_of_literals_positives:Use isinstance() rather than type() for a typecheck.
diff --git a/tests/functional/u/uninferable_all_object.py b/tests/functional/u/uninferable_all_object.py
new file mode 100644
index 0000000..3e565f9
--- /dev/null
+++ b/tests/functional/u/uninferable_all_object.py
@@ -0,0 +1,9 @@
+"""Test that non-inferable __all__ variables do not make Pylint crash."""
+
+__all__ = sorted([
+ 'Dummy',
+ 'NonExistant',
+ 'path',
+ 'func',
+ 'inner',
+ 'InnerKlass'])
diff --git a/tests/functional/u/unknown_encoding_jython.py b/tests/functional/u/unknown_encoding_jython.py
new file mode 100644
index 0000000..9863285
--- /dev/null
+++ b/tests/functional/u/unknown_encoding_jython.py
@@ -0,0 +1,6 @@
+# [syntax-error]
+# -*- coding: IBO-8859-1 -*-
+""" check correct unknown encoding declaration
+"""
+
+__revision__ = 'יייי'
diff --git a/tests/functional/u/unknown_encoding_jython.rc b/tests/functional/u/unknown_encoding_jython.rc
new file mode 100644
index 0000000..ed0c011
--- /dev/null
+++ b/tests/functional/u/unknown_encoding_jython.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=PyPy,CPython,IronPython
diff --git a/tests/functional/u/unknown_encoding_jython.txt b/tests/functional/u/unknown_encoding_jython.txt
new file mode 100644
index 0000000..b7ff720
--- /dev/null
+++ b/tests/functional/u/unknown_encoding_jython.txt
@@ -0,0 +1 @@
+syntax-error:1::"Unknown encoding: IBO-8859-1"
diff --git a/tests/functional/u/unnecessary/unnecessary_comprehension.py b/tests/functional/u/unnecessary/unnecessary_comprehension.py
new file mode 100644
index 0000000..d6a3d1e
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_comprehension.py
@@ -0,0 +1,49 @@
+# pylint: disable=undefined-variable, pointless-statement, missing-docstring, line-too-long, expression-not-assigned
+# For name-reference see https://docs.python.org/3/reference/expressions.html#displays-for-lists-sets-and-dictionaries
+
+# List comprehensions
+[x for x in iterable] # [unnecessary-comprehension]
+[y for x in iterable] # expression != target_list
+[x for x,y,z in iterable] # expression != target_list
+[(x,y,z) for x,y,z in iterable] # [unnecessary-comprehension]
+[(x,y,z) for (x,y,z) in iterable] # [unnecessary-comprehension]
+[x for x, *y in iterable] # expression != target_list
+[x for x in iterable if condition] # exclude comp_if
+[y for x in iterable for y in x] # exclude nested comprehensions
+[2 * x for x in iterable] # exclude useful comprehensions
+[(x, y, 1) for x, y in iterable] # exclude useful comprehensions
+# Test case for issue #4499
+a_dict = dict()
+[(k, v) for k, v in a_dict.items()] # [unnecessary-comprehension]
+
+# Set comprehensions
+{x for x in iterable} # [unnecessary-comprehension]
+{y for x in iterable} # expression != target_list
+{x for x,y,z in iterable} # expression != target_list
+{(x,y,z) for x,y,z in iterable} # [unnecessary-comprehension]
+{(x,y,z) for (x, y, z) in iterable} # [unnecessary-comprehension]
+{(x,y,z) for x in iterable} # expression != target_list
+{(x,y,(a,b,c)) for x in iterable} # expression != target_list
+{x for x, *y in iterable} # expression != target_list
+{x for x in iterable if condition} # exclude comp_if
+{y for x in iterable for y in x} # exclude nested comprehensions
+
+# Dictionary comprehensions
+{x: y for x, y in iterable} # [unnecessary-comprehension]
+{y: x for x, y in iterable} # key value wrong order
+{x: y for (x, y) in iterable} # [unnecessary-comprehension]
+{x: y for x,y,z in iterable} # expression != target_list
+{x: y for x, y in iterable if condition} # exclude comp_if
+{y: z for x in iterable for y, z in x} # exclude nested comprehensions
+{x: 1 for x in iterable} # expression != target_list
+{2 * x: 3 + x for x in iterable} # exclude useful comprehensions
+
+# Some additional tests on helptext -- when object is already a list/set/dict
+my_list = list()
+my_dict = dict()
+my_set = set()
+
+[elem for elem in my_list] # [unnecessary-comprehension]
+{k: v for k, v in my_dict.items()} # [unnecessary-comprehension]
+{k: my_dict[k] for k in my_dict} # [consider-using-dict-items]
+{elem for elem in my_set} # [unnecessary-comprehension]
diff --git a/tests/functional/u/unnecessary/unnecessary_comprehension.txt b/tests/functional/u/unnecessary/unnecessary_comprehension.txt
new file mode 100644
index 0000000..189bcc6
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_comprehension.txt
@@ -0,0 +1,13 @@
+unnecessary-comprehension:5:0::Unnecessary use of a comprehension, use list(iterable) instead.
+unnecessary-comprehension:8:0::Unnecessary use of a comprehension, use list(iterable) instead.
+unnecessary-comprehension:9:0::Unnecessary use of a comprehension, use list(iterable) instead.
+unnecessary-comprehension:17:0::Unnecessary use of a comprehension, use list(a_dict.items()) instead.
+unnecessary-comprehension:20:0::Unnecessary use of a comprehension, use set(iterable) instead.
+unnecessary-comprehension:23:0::Unnecessary use of a comprehension, use set(iterable) instead.
+unnecessary-comprehension:24:0::Unnecessary use of a comprehension, use set(iterable) instead.
+unnecessary-comprehension:32:0::Unnecessary use of a comprehension, use dict(iterable) instead.
+unnecessary-comprehension:34:0::Unnecessary use of a comprehension, use dict(iterable) instead.
+unnecessary-comprehension:46:0::Unnecessary use of a comprehension, use my_list instead.
+unnecessary-comprehension:47:0::Unnecessary use of a comprehension, use my_dict instead.
+consider-using-dict-items:48:0::Consider iterating with .items()
+unnecessary-comprehension:49:0::Unnecessary use of a comprehension, use my_set instead.
diff --git a/tests/functional/u/unnecessary/unnecessary_dict_index_lookup.py b/tests/functional/u/unnecessary/unnecessary_dict_index_lookup.py
new file mode 100644
index 0000000..901e176
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_dict_index_lookup.py
@@ -0,0 +1,63 @@
+# pylint: disable=missing-docstring, too-few-public-methods, expression-not-assigned, line-too-long
+
+a_dict = dict()
+b_dict = dict()
+
+for k, v in a_dict.items():
+ print(a_dict[k]) # [unnecessary-dict-index-lookup]
+ print(b_dict[k]) # Should not emit warning, accessing other dictionary
+ a_dict[k] = 123 # Should not emit warning, key access necessary
+ a_dict[k] += 123 # Should not emit warning, key access necessary
+ print(a_dict[k]) # [unnecessary-dict-index-lookup]
+ k = "another key"
+ print(a_dict[k]) # This is fine, key reassigned
+
+
+# Tests on comprehensions
+{v: 1 for k, v in a_dict.items() if a_dict[k]} # [unnecessary-dict-index-lookup]
+{v: 1 for k, v in a_dict.items() if k} # This is fine, no indexing
+{a_dict[k]: 1 for k, v in a_dict.items() if k} # [unnecessary-dict-index-lookup]
+{a_dict[k]: 1 for k, v in a_dict.items() if a_dict[k]} # [unnecessary-dict-index-lookup, unnecessary-dict-index-lookup]
+
+[v for k, v in a_dict.items() if a_dict[k]] # [unnecessary-dict-index-lookup]
+[v for k, v in a_dict.items() if k] # This is fine, no indexing
+[a_dict[k] for k, v in a_dict.items() if k] # [unnecessary-dict-index-lookup]
+[a_dict[k] for k, v in a_dict.items() if a_dict[k]] # [unnecessary-dict-index-lookup, unnecessary-dict-index-lookup]
+
+
+# Tests on dict attribute of a class
+class Foo:
+ c_dict = {}
+
+for k, v in Foo.c_dict.items():
+ print(b_dict[k]) # Should not emit warning, accessing other dictionary
+ print(Foo.c_dict[k]) # [unnecessary-dict-index-lookup]
+ Foo.c_dict[k] += Foo.c_dict[k] # [unnecessary-dict-index-lookup]
+ Foo.c_dict[k] += v # key access necessary
+
+# Tests on comprehensions
+{v: 1 for k, v in Foo.c_dict.items() if Foo.c_dict[k]} # [unnecessary-dict-index-lookup]
+{v: 1 for k, v in Foo.c_dict.items() if k} # This is fine, no indexing
+{Foo.c_dict[k]: 1 for k, v in Foo.c_dict.items() if k} # [unnecessary-dict-index-lookup]
+{Foo.c_dict[k]: 1 for k, v in Foo.c_dict.items() if Foo.c_dict[k]} # [unnecessary-dict-index-lookup, unnecessary-dict-index-lookup]
+
+[v for k, v in Foo.c_dict.items() if Foo.c_dict[k]] # [unnecessary-dict-index-lookup]
+[v for k, v in Foo.c_dict.items() if k] # This is fine, no indexing
+[Foo.c_dict[k] for k, v in Foo.c_dict.items() if k] # [unnecessary-dict-index-lookup]
+[Foo.c_dict[k] for k, v in Foo.c_dict.items() if Foo.c_dict[k]] # [unnecessary-dict-index-lookup, unnecessary-dict-index-lookup]
+
+# Test assigning d.items() to a single variable
+d = {1: "a", 2: "b"}
+for item in d.items():
+ print(item[0])
+ print(d[item[0]]) # [unnecessary-dict-index-lookup]
+
+[item[0] for item in d.items()]
+[d[item[0]] for item in d.items()] # [unnecessary-dict-index-lookup]
+
+# Reassigning single var
+for item in d.items():
+ print(item[0])
+ print(d[item[0]]) # [unnecessary-dict-index-lookup]
+ item = (2, "b")
+ print(d[item[0]]) # This is fine, no warning thrown as key has been reassigned
diff --git a/tests/functional/u/unnecessary/unnecessary_dict_index_lookup.txt b/tests/functional/u/unnecessary/unnecessary_dict_index_lookup.txt
new file mode 100644
index 0000000..dedf9e7
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_dict_index_lookup.txt
@@ -0,0 +1,23 @@
+unnecessary-dict-index-lookup:7:10::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:11:10::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:17:36::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:19:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:20:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:20:44::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:22:33::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:24:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:25:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:25:41::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:34:10::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:35:21::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:39:40::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:41:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:42:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:42:52::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:44:37::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:46:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:47:1::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:47:49::Unnecessary dictionary index lookup, use 'v' instead
+unnecessary-dict-index-lookup:53:10::Unnecessary dictionary index lookup, use 'item[1]' instead
+unnecessary-dict-index-lookup:56:1::Unnecessary dictionary index lookup, use 'item[1]' instead
+unnecessary-dict-index-lookup:61:10::Unnecessary dictionary index lookup, use 'item[1]' instead
diff --git a/tests/functional/u/unnecessary/unnecessary_lambda.py b/tests/functional/u/unnecessary/unnecessary_lambda.py
new file mode 100644
index 0000000..f0bd775
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_lambda.py
@@ -0,0 +1,53 @@
+# pylint: disable=undefined-variable
+"""test suspicious lambda expressions
+"""
+
+__revision__ = ''
+
+# Some simple examples of the most commonly encountered forms.
+# +1: [unnecessary-lambda]
+_ = lambda: list() # replaceable with "list"
+# +1: [unnecessary-lambda]
+_ = lambda x: hash(x) # replaceable with "hash"
+# +1: [unnecessary-lambda]
+_ = lambda x, y: min(x, y) # replaceable with "min"
+
+# A function that can take any arguments given to it.
+_ANYARGS = lambda *args, **kwargs: 'completely arbitrary return value'
+
+# Some more complex forms of unnecessary lambda expressions.
+# +1: [unnecessary-lambda]
+_ = lambda *args: _ANYARGS(*args)
+# +1: [unnecessary-lambda]
+_ = lambda **kwargs: _ANYARGS(**kwargs)
+# +1: [unnecessary-lambda]
+_ = lambda *args, **kwargs: _ANYARGS(*args, **kwargs)
+# +1: [unnecessary-lambda]
+_ = lambda x, y, z, *args, **kwargs: _ANYARGS(x, y, z, *args, **kwargs)
+
+# Lambdas that are *not* unnecessary and should *not* trigger warnings.
+_ = lambda x: x
+_ = lambda x: x()
+_ = lambda x=4: hash(x)
+_ = lambda x, y: list(range(y, x))
+_ = lambda x: list(range(5, x))
+_ = lambda x, y: list(range(x, 5))
+_ = lambda x, y, z: x.y(z)
+_ = lambda: 5
+_ = lambda **kwargs: _ANYARGS()
+_ = lambda **kwargs: _ANYARGS(**dict([('three', 3)]))
+_ = lambda **kwargs: _ANYARGS(**{'three': 3})
+_ = lambda dict_arg, **kwargs: _ANYARGS(kwargs, **dict_arg)
+_ = lambda *args: _ANYARGS()
+_ = lambda *args: _ANYARGS(*list([3, 4]))
+_ = lambda *args: _ANYARGS(*[3, 4])
+_ = lambda list_arg, *args: _ANYARGS(args, *list_arg)
+_ = lambda: _ANYARGS(*[3])
+_ = lambda: _ANYARGS(**{'three': 3})
+_ = lambda: _ANYARGS(*[3], **{'three': 3})
+_ = lambda: _ANYARGS(func=42)
+
+# Don't warn about this.
+_ = lambda: code().analysis()
+
+_ = lambda **kwargs: dict(bar=42, **kwargs)
diff --git a/tests/functional/u/unnecessary/unnecessary_lambda.txt b/tests/functional/u/unnecessary/unnecessary_lambda.txt
new file mode 100644
index 0000000..c3983b1
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_lambda.txt
@@ -0,0 +1,7 @@
+unnecessary-lambda:9:4:<lambda>:Lambda may not be necessary
+unnecessary-lambda:11:4:<lambda>:Lambda may not be necessary
+unnecessary-lambda:13:4:<lambda>:Lambda may not be necessary
+unnecessary-lambda:20:4:<lambda>:Lambda may not be necessary
+unnecessary-lambda:22:4:<lambda>:Lambda may not be necessary
+unnecessary-lambda:24:4:<lambda>:Lambda may not be necessary
+unnecessary-lambda:26:4:<lambda>:Lambda may not be necessary
diff --git a/tests/functional/u/unnecessary/unnecessary_not.py b/tests/functional/u/unnecessary/unnecessary_not.py
new file mode 100644
index 0000000..97acecd
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_not.py
@@ -0,0 +1,63 @@
+"""Check exceeding negations in boolean expressions trigger warnings"""
+
+# pylint: disable=singleton-comparison,too-many-branches,too-few-public-methods,undefined-variable
+# pylint: disable=literal-comparison, comparison-with-itself, useless-object-inheritance
+def unneeded_not():
+ """This is not ok
+ """
+ bool_var = True
+ someint = 2
+ if not not bool_var: # [unneeded-not]
+ pass
+ if not someint == 1: # [unneeded-not]
+ pass
+ if not someint != 1: # [unneeded-not]
+ pass
+ if not someint < 1: # [unneeded-not]
+ pass
+ if not someint > 1: # [unneeded-not]
+ pass
+ if not someint <= 1: # [unneeded-not]
+ pass
+ if not someint >= 1: # [unneeded-not]
+ pass
+ if not not someint: # [unneeded-not]
+ pass
+ if not bool_var == True: # [unneeded-not]
+ pass
+ if not bool_var == False: # [unneeded-not]
+ pass
+ if not bool_var != True: # [unneeded-not]
+ pass
+ if not True == True: # [unneeded-not]
+ pass
+ if not 2 in [3, 4]: # [unneeded-not]
+ pass
+ if not someint is 'test': # [unneeded-not]
+ pass
+
+
+def tolerated_statements():
+ """This is ok"""
+ bool_var = True
+ someint = 2
+ if not(bool_var == False and someint == 1):
+ pass
+ if 2 not in [3, 4]:
+ pass
+ if not someint == bool_var == 2:
+ pass
+ if not 2 <= someint < 3 < 4:
+ pass
+ if not set('bar') <= set('foobaz'):
+ pass
+ if not set(something) <= 3:
+ pass
+ if not frozenset(something) <= 3:
+ pass
+
+
+class Klass(object):
+ """This is also ok"""
+ def __ne__(self, other):
+ return not self == other
diff --git a/tests/functional/u/unnecessary/unnecessary_not.txt b/tests/functional/u/unnecessary/unnecessary_not.txt
new file mode 100644
index 0000000..722f26d
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_not.txt
@@ -0,0 +1,14 @@
+unneeded-not:10:7:unneeded_not:"Consider changing ""not not bool_var"" to ""bool_var"""
+unneeded-not:12:7:unneeded_not:"Consider changing ""not someint == 1"" to ""someint != 1"""
+unneeded-not:14:7:unneeded_not:"Consider changing ""not someint != 1"" to ""someint == 1"""
+unneeded-not:16:7:unneeded_not:"Consider changing ""not someint < 1"" to ""someint >= 1"""
+unneeded-not:18:7:unneeded_not:"Consider changing ""not someint > 1"" to ""someint <= 1"""
+unneeded-not:20:7:unneeded_not:"Consider changing ""not someint <= 1"" to ""someint > 1"""
+unneeded-not:22:7:unneeded_not:"Consider changing ""not someint >= 1"" to ""someint < 1"""
+unneeded-not:24:7:unneeded_not:"Consider changing ""not not someint"" to ""someint"""
+unneeded-not:26:7:unneeded_not:"Consider changing ""not bool_var == True"" to ""bool_var != True"""
+unneeded-not:28:7:unneeded_not:"Consider changing ""not bool_var == False"" to ""bool_var != False"""
+unneeded-not:30:7:unneeded_not:"Consider changing ""not bool_var != True"" to ""bool_var == True"""
+unneeded-not:32:7:unneeded_not:"Consider changing ""not True == True"" to ""True != True"""
+unneeded-not:34:7:unneeded_not:"Consider changing ""not 2 in [3, 4]"" to ""2 not in [3, 4]"""
+unneeded-not:36:7:unneeded_not:"Consider changing ""not someint is 'test'"" to ""someint is not 'test'"""
diff --git a/tests/functional/u/unnecessary/unnecessary_pass.py b/tests/functional/u/unnecessary/unnecessary_pass.py
new file mode 100644
index 0000000..c273309
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_pass.py
@@ -0,0 +1,49 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+
+try:
+ A = 2
+except ValueError:
+ A = 24
+ pass # [unnecessary-pass]
+
+def docstring_only():
+ '''In Python, stubbed functions often have a body that contains just a
+ single `pass` statement, indicating that the function doesn't do
+ anything. However, a stubbed function can also have just a
+ docstring, and function with a docstring and no body also does
+ nothing.
+ '''
+
+
+# This function has no docstring, so it needs a `pass` statement.
+def pass_only():
+ pass
+
+
+def docstring_and_pass():
+ '''This function doesn't do anything, but it has a docstring, so its
+ `pass` statement is useless clutter.
+
+ NEW CHECK: useless-pass
+
+ This would check for stubs with both docstrings and `pass`
+ statements, suggesting the removal of the useless `pass`
+ statements
+ '''
+ pass # [unnecessary-pass]
+
+
+class DocstringOnly:
+ '''The same goes for class stubs: docstring, or `pass`, but not both.
+ '''
+
+
+# No problem
+class PassOnly:
+ pass
+
+
+class DocstringAndPass:
+ '''Whoops! Mark this one as bad too.
+ '''
+ pass # [unnecessary-pass]
diff --git a/tests/functional/u/unnecessary/unnecessary_pass.txt b/tests/functional/u/unnecessary/unnecessary_pass.txt
new file mode 100644
index 0000000..6eabcf5
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_pass.txt
@@ -0,0 +1,3 @@
+unnecessary-pass:7:4::Unnecessary pass statement
+unnecessary-pass:33:4:docstring_and_pass:Unnecessary pass statement
+unnecessary-pass:49:4:DocstringAndPass:Unnecessary pass statement
diff --git a/tests/functional/u/unpacking.py b/tests/functional/u/unpacking.py
new file mode 100644
index 0000000..59d9abb
--- /dev/null
+++ b/tests/functional/u/unpacking.py
@@ -0,0 +1,11 @@
+""" Code for checking the display of the module
+for unbalanced-tuple-unpacking and unpacking-non-sequence
+"""
+
+def unpack():
+ """ Return something"""
+ return (1, 2, 3)
+
+def nonseq():
+ """ Return non sequence """
+ return 1
diff --git a/tests/functional/u/unpacking_generalizations.py b/tests/functional/u/unpacking_generalizations.py
new file mode 100644
index 0000000..1c5fb16
--- /dev/null
+++ b/tests/functional/u/unpacking_generalizations.py
@@ -0,0 +1,29 @@
+"""Various tests for unpacking generalizations added in Python 3.5"""
+
+# pylint: disable=missing-docstring, invalid-name
+
+def func_variadic_args(*args):
+ return args
+
+
+def func_variadic_positional_args(a, b, *args):
+ return a, b, args
+
+def func_positional_args(a, b, c, d):
+ return a, b, c, d
+
+
+func_variadic_args(*(2, 3), *(3, 4), *(4, 5))
+func_variadic_args(1, 2, *(2, 3), 2, 3, *(4, 5))
+func_variadic_positional_args(1, 2, *(4, 5), *(5, 6))
+func_variadic_positional_args(*(2, 3), *(4, 5), *(5, 6))
+func_variadic_positional_args(*(2, 3))
+func_variadic_positional_args(*(2, 3, 4))
+func_variadic_positional_args(1, 2, 3, *(3, 4))
+
+func_positional_args(*(2, 3, 4), *(2, 3)) # [too-many-function-args]
+func_positional_args(*(1, 2), 3) # [no-value-for-parameter]
+func_positional_args(1, *(2, ), 3, *(4, 5)) # [too-many-function-args]
+func_positional_args(1, 2, c=24, d=32, **{'d': 32}) # [repeated-keyword]
+# +1: [repeated-keyword,repeated-keyword]
+func_positional_args(1, 2, c=24, **{'c': 34, 'd': 33}, **{'d': 24})
diff --git a/tests/functional/u/unpacking_generalizations.rc b/tests/functional/u/unpacking_generalizations.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/u/unpacking_generalizations.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/u/unpacking_generalizations.txt b/tests/functional/u/unpacking_generalizations.txt
new file mode 100644
index 0000000..96c476c
--- /dev/null
+++ b/tests/functional/u/unpacking_generalizations.txt
@@ -0,0 +1,6 @@
+too-many-function-args:24:0::Too many positional arguments for function call
+no-value-for-parameter:25:0::No value for argument 'd' in function call
+too-many-function-args:26:0::Too many positional arguments for function call
+repeated-keyword:27:0::Got multiple values for keyword argument 'd' in function call
+repeated-keyword:29:0::Got multiple values for keyword argument 'c' in function call
+repeated-keyword:29:0::Got multiple values for keyword argument 'd' in function call
diff --git a/tests/functional/u/unpacking_non_sequence.py b/tests/functional/u/unpacking_non_sequence.py
new file mode 100644
index 0000000..c681641
--- /dev/null
+++ b/tests/functional/u/unpacking_non_sequence.py
@@ -0,0 +1,139 @@
+"""Check unpacking non-sequences in assignments. """
+
+# pylint: disable=too-few-public-methods, invalid-name, attribute-defined-outside-init, unused-variable, no-absolute-import
+# pylint: disable=using-constant-test, no-init, missing-docstring, wrong-import-order,wrong-import-position,no-else-return, useless-object-inheritance
+from os import rename as nonseq_func
+from functional.u.unpacking import nonseq
+
+__revision__ = 0
+
+# Working
+
+class Seq(object):
+ """ sequence """
+ def __init__(self):
+ self.items = range(2)
+
+ def __getitem__(self, item):
+ return self.items[item]
+
+ def __len__(self):
+ return len(self.items)
+
+class Iter(object):
+ """ Iterator """
+ def __iter__(self):
+ for number in range(2):
+ yield number
+
+def good_unpacking():
+ """ returns should be unpackable """
+ if True:
+ return [1, 2]
+ else:
+ return (3, 4)
+
+def good_unpacking2():
+ """ returns should be unpackable """
+ return good_unpacking()
+
+class MetaIter(type):
+ "metaclass that makes classes that use it iterables"
+ def __iter__(cls):
+ return iter((1, 2))
+
+class IterClass(metaclass=MetaIter):
+ "class that is iterable (and unpackable)"
+
+class AbstrClass(object):
+ "abstract class"
+ pair = None
+
+ def setup_pair(self):
+ "abstract method"
+ raise NotImplementedError
+
+ def __init__(self):
+ "error should not be emitted because setup_pair is abstract"
+ self.setup_pair()
+ x, y = self.pair
+
+a, b = [1, 2]
+a, b = (1, 2)
+a, b = set([1, 2])
+a, b = {1: 2, 2: 3}
+a, b = "xy"
+a, b = Seq()
+a, b = Iter()
+a, b = (number for number in range(2))
+a, b = good_unpacking()
+a, b = good_unpacking2()
+a, b = IterClass
+
+# Not working
+class NonSeq(object):
+ """ does nothing """
+
+a, b = NonSeq() # [unpacking-non-sequence]
+a, b = ValueError # [unpacking-non-sequence]
+a, b = None # [unpacking-non-sequence]
+a, b = 1 # [unpacking-non-sequence]
+a, b = nonseq # [unpacking-non-sequence]
+a, b = nonseq() # [unpacking-non-sequence]
+a, b = nonseq_func # [unpacking-non-sequence]
+
+class ClassUnpacking(object):
+ """ Check unpacking as instance attributes. """
+
+ def test(self):
+ """ test unpacking in instance attributes. """
+
+ self.a, self.b = 1, 2
+ self.a, self.b = {1: 2, 2: 3}
+ self.a, self.b = "xy"
+ self.a, c = "xy"
+ c, self.a = good_unpacking()
+ self.a, self.b = Iter()
+
+ self.a, self.b = NonSeq() # [unpacking-non-sequence]
+ self.a, self.b = ValueError # [unpacking-non-sequence]
+ self.a, c = nonseq_func # [unpacking-non-sequence]
+
+class TestBase(object):
+ 'base class with `test` method implementation'
+ @staticmethod
+ def test(data):
+ 'default implementation'
+ return data
+
+class Test(TestBase):
+ 'child class that overrides `test` method'
+ def __init__(self):
+ # no error should be emitted here as `test` is overridden in this class
+ (self.aaa, self.bbb, self.ccc) = self.test(None)
+
+ @staticmethod
+ def test(data):
+ 'overridden implementation'
+ return (1, 2, 3)
+
+
+import platform
+
+
+def flow_control_false_positive():
+ # This used to trigger an unpacking-non-sequence error. The problem was
+ # partially related to the fact that pylint does not understand flow control,
+ # but now it does not emit anymore, for this example, due to skipping it when
+ # determining an inference of multiple potential values.
+ # In any case, it is good having this repro as a test.
+ system, node, release, version, machine, processor = platform.uname()
+ # The previous line raises W0633
+ return system, node, release, version, machine, processor
+
+
+def flow_control_unpacking(var=None):
+ if var is not None:
+ var0, var1 = var
+ return var0, var1
+ return None
diff --git a/tests/functional/u/unpacking_non_sequence.txt b/tests/functional/u/unpacking_non_sequence.txt
new file mode 100644
index 0000000..0ac2bc2
--- /dev/null
+++ b/tests/functional/u/unpacking_non_sequence.txt
@@ -0,0 +1,10 @@
+unpacking-non-sequence:77:0::Attempting to unpack a non-sequence defined at line 74
+unpacking-non-sequence:78:0::Attempting to unpack a non-sequence
+unpacking-non-sequence:79:0::Attempting to unpack a non-sequence None
+unpacking-non-sequence:80:0::Attempting to unpack a non-sequence 1
+unpacking-non-sequence:81:0::Attempting to unpack a non-sequence defined at line 9 of functional.u.unpacking
+unpacking-non-sequence:82:0::Attempting to unpack a non-sequence defined at line 11 of functional.u.unpacking
+unpacking-non-sequence:83:0::Attempting to unpack a non-sequence
+unpacking-non-sequence:98:8:ClassUnpacking.test:Attempting to unpack a non-sequence defined at line 74
+unpacking-non-sequence:99:8:ClassUnpacking.test:Attempting to unpack a non-sequence
+unpacking-non-sequence:100:8:ClassUnpacking.test:Attempting to unpack a non-sequence
diff --git a/tests/functional/u/unreachable.py b/tests/functional/u/unreachable.py
new file mode 100644
index 0000000..b03dec8
--- /dev/null
+++ b/tests/functional/u/unreachable.py
@@ -0,0 +1,22 @@
+# pylint: disable=missing-docstring
+
+from __future__ import print_function
+
+def func1():
+ return 1
+ print('unreachable') # [unreachable]
+
+def func2():
+ while 1:
+ break
+ print('unreachable') # [unreachable]
+
+def func3():
+ for i in (1, 2, 3):
+ print(i)
+ continue
+ print('unreachable') # [unreachable]
+
+def func4():
+ raise Exception
+ return 1 / 0 # [unreachable]
diff --git a/tests/functional/u/unreachable.txt b/tests/functional/u/unreachable.txt
new file mode 100644
index 0000000..5dd33e2
--- /dev/null
+++ b/tests/functional/u/unreachable.txt
@@ -0,0 +1,4 @@
+unreachable:7:4:func1:Unreachable code
+unreachable:12:8:func2:Unreachable code
+unreachable:18:8:func3:Unreachable code
+unreachable:22:4:func4:Unreachable code
diff --git a/tests/functional/u/unrecognized_inline_option.py b/tests/functional/u/unrecognized_inline_option.py
new file mode 100644
index 0000000..3163b1e
--- /dev/null
+++ b/tests/functional/u/unrecognized_inline_option.py
@@ -0,0 +1,3 @@
+# +1: [unrecognized-inline-option]
+# pylint:bouboule=1
+"""Check unknown option"""
diff --git a/tests/functional/u/unrecognized_inline_option.txt b/tests/functional/u/unrecognized_inline_option.txt
new file mode 100644
index 0000000..a893733
--- /dev/null
+++ b/tests/functional/u/unrecognized_inline_option.txt
@@ -0,0 +1 @@
+unrecognized-inline-option:2:0::Unrecognized file option 'bouboule'
diff --git a/tests/functional/u/unsubscriptable_value.py b/tests/functional/u/unsubscriptable_value.py
new file mode 100644
index 0000000..73c3ac4
--- /dev/null
+++ b/tests/functional/u/unsubscriptable_value.py
@@ -0,0 +1,127 @@
+"""
+Checks that value used in a subscript supports subscription
+(i.e. defines __getitem__ method).
+"""
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,wrong-import-position, unnecessary-comprehension
+# pylint: disable=too-few-public-methods,import-error,invalid-name,wrong-import-order, useless-object-inheritance
+import six
+
+# primitives
+numbers = [1, 2, 3]
+numbers[0]
+"123"[0]
+u"123"[0]
+b"123"[0]
+bytearray(b"123")[0]
+dict(a=1, b=2)['a']
+(1, 2, 3)[0]
+
+# list/dict comprehensions are fine
+[x for x in range(10)][0]
+{x: 10 - x for x in range(10)}[0]
+
+
+# instances
+class NonSubscriptable(object):
+ pass
+
+class Subscriptable(object):
+ def __getitem__(self, key):
+ return key + key
+
+NonSubscriptable()[0] # [unsubscriptable-object]
+NonSubscriptable[0] # [unsubscriptable-object]
+Subscriptable()[0]
+Subscriptable[0] # [unsubscriptable-object]
+
+# generators are not subscriptable
+def powers_of_two():
+ k = 0
+ while k < 10:
+ yield 2 ** k
+ k += 1
+
+powers_of_two()[0] # [unsubscriptable-object]
+powers_of_two[0] # [unsubscriptable-object]
+
+
+# check that primitive non subscriptable types are caught
+True[0] # [unsubscriptable-object]
+None[0] # [unsubscriptable-object]
+8.5[0] # [unsubscriptable-object]
+10[0] # [unsubscriptable-object]
+
+# sets are not subscriptable
+{x ** 2 for x in range(10)}[0] # [unsubscriptable-object]
+set(numbers)[0] # [unsubscriptable-object]
+frozenset(numbers)[0] # [unsubscriptable-object]
+
+# skip instances with unknown base classes
+from some_missing_module import LibSubscriptable
+
+class MaybeSubscriptable(LibSubscriptable):
+ pass
+
+MaybeSubscriptable()[0]
+
+# subscriptable classes (through metaclasses)
+
+class MetaSubscriptable(type):
+ def __getitem__(cls, key):
+ return key + key
+
+class SubscriptableClass(six.with_metaclass(MetaSubscriptable, object)):
+ pass
+
+SubscriptableClass[0]
+SubscriptableClass()[0] # [unsubscriptable-object]
+
+# functions are not subscriptable
+def test(*args, **kwargs):
+ return args, kwargs
+
+test()[0]
+test[0] # [unsubscriptable-object]
+
+# deque
+from collections import deque
+deq = deque(maxlen=10)
+deq.append(42)
+deq[0]
+
+
+class AbstractClass(object):
+
+ def __init__(self):
+ self.ala = {i for i in range(10)}
+ self.bala = [i for i in range(10)]
+ self.portocala = None
+
+ def test_unsubscriptable(self):
+ self.bala[0]
+ self.portocala[0]
+
+
+class ClassMixin(object):
+
+ def __init__(self):
+ self.ala = {i for i in range(10)}
+ self.bala = [i for i in range(10)]
+ self.portocala = None
+
+ def test_unsubscriptable(self):
+ self.bala[0]
+ self.portocala[0]
+
+
+def return_an_int(param):
+ """Returns an int"""
+ if param == 0:
+ return 1
+ return 0
+
+
+def test_one(param):
+ """Should complain about var_one[0], but doesn't"""
+ var_one = return_an_int(param)
+ return var_one[0] # [unsubscriptable-object]
diff --git a/tests/functional/u/unsubscriptable_value.rc b/tests/functional/u/unsubscriptable_value.rc
new file mode 100644
index 0000000..6a8ee96
--- /dev/null
+++ b/tests/functional/u/unsubscriptable_value.rc
@@ -0,0 +1,2 @@
+[testoptions]
+requires = six
diff --git a/tests/functional/u/unsubscriptable_value.txt b/tests/functional/u/unsubscriptable_value.txt
new file mode 100644
index 0000000..c95e05c
--- /dev/null
+++ b/tests/functional/u/unsubscriptable_value.txt
@@ -0,0 +1,15 @@
+unsubscriptable-object:32:0::Value 'NonSubscriptable()' is unsubscriptable
+unsubscriptable-object:33:0::Value 'NonSubscriptable' is unsubscriptable
+unsubscriptable-object:35:0::Value 'Subscriptable' is unsubscriptable
+unsubscriptable-object:44:0::Value 'powers_of_two()' is unsubscriptable
+unsubscriptable-object:45:0::Value 'powers_of_two' is unsubscriptable
+unsubscriptable-object:49:0::Value 'True' is unsubscriptable
+unsubscriptable-object:50:0::Value 'None' is unsubscriptable
+unsubscriptable-object:51:0::Value '8.5' is unsubscriptable
+unsubscriptable-object:52:0::Value '10' is unsubscriptable
+unsubscriptable-object:55:0::Value '{x**2 for x in range(10)}' is unsubscriptable
+unsubscriptable-object:56:0::Value 'set(numbers)' is unsubscriptable
+unsubscriptable-object:57:0::Value 'frozenset(numbers)' is unsubscriptable
+unsubscriptable-object:77:0::Value 'SubscriptableClass()' is unsubscriptable
+unsubscriptable-object:84:0::Value 'test' is unsubscriptable
+unsubscriptable-object:127:11:test_one:Value 'var_one' is unsubscriptable
diff --git a/tests/functional/u/unsubscriptable_value_py37.py b/tests/functional/u/unsubscriptable_value_py37.py
new file mode 100644
index 0000000..acbbe6b
--- /dev/null
+++ b/tests/functional/u/unsubscriptable_value_py37.py
@@ -0,0 +1,17 @@
+# pylint: disable=missing-class-docstring,too-few-public-methods,pointless-statement,expression-not-assigned
+"""
+Checks that class used in a subscript supports subscription
+(i.e. defines __class_getitem__ method).
+"""
+import typing
+
+
+class Subscriptable:
+
+ def __class_getitem__(cls, params):
+ pass
+
+Subscriptable[0]
+Subscriptable()[0] # [unsubscriptable-object]
+
+a: typing.List[int]
diff --git a/tests/functional/u/unsubscriptable_value_py37.rc b/tests/functional/u/unsubscriptable_value_py37.rc
new file mode 100644
index 0000000..a17bb22
--- /dev/null
+++ b/tests/functional/u/unsubscriptable_value_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/u/unsubscriptable_value_py37.txt b/tests/functional/u/unsubscriptable_value_py37.txt
new file mode 100644
index 0000000..b595997
--- /dev/null
+++ b/tests/functional/u/unsubscriptable_value_py37.txt
@@ -0,0 +1 @@
+unsubscriptable-object:15:0::Value 'Subscriptable()' is unsubscriptable
diff --git a/tests/functional/u/unsupported/unsupported_assignment_operation.py b/tests/functional/u/unsupported/unsupported_assignment_operation.py
new file mode 100644
index 0000000..c0b5866
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_assignment_operation.py
@@ -0,0 +1,94 @@
+"""
+Checks that value used in a subscript support assignments
+(i.e. defines __setitem__ method).
+"""
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,wrong-import-position,unnecessary-comprehension
+# pylint: disable=too-few-public-methods,import-error,invalid-name,wrong-import-order, useless-object-inheritance
+import six
+
+# primitives
+numbers = [1, 2, 3]
+numbers[0] = 42
+
+
+bytearray(b"123")[0] = 42
+dict(a=1, b=2)['a'] = 42
+(1, 2, 3)[0] = 42 # [unsupported-assignment-operation]
+
+# list/dict comprehensions are fine
+[x for x in range(10)][0] = 42
+{x: 10 - x for x in range(10)}[0] = 42
+
+
+# instances
+class NonSubscriptable(object):
+ pass
+
+class Subscriptable(object):
+ def __setitem__(self, key, value):
+ return key + value
+
+NonSubscriptable()[0] = 24 # [unsupported-assignment-operation]
+NonSubscriptable[0] = 24 # [unsupported-assignment-operation]
+Subscriptable()[0] = 24
+Subscriptable[0] = 24 # [unsupported-assignment-operation]
+
+# generators are not subscriptable
+def powers_of_two():
+ k = 0
+ while k < 10:
+ yield 2 ** k
+ k += 1
+
+powers_of_two()[0] = 42 # [unsupported-assignment-operation]
+powers_of_two[0] = 42 # [unsupported-assignment-operation]
+
+
+# check that primitive non subscriptable types are caught
+True[0] = 24 # [unsupported-assignment-operation]
+None[0] = 42 # [unsupported-assignment-operation]
+8.5[0] = 24 # [unsupported-assignment-operation]
+10[0] = 24 # [unsupported-assignment-operation]
+
+# sets are not subscriptable
+{x ** 2 for x in range(10)}[0] = 24 # [unsupported-assignment-operation]
+set(numbers)[0] = 24 # [unsupported-assignment-operation]
+frozenset(numbers)[0] = 42 # [unsupported-assignment-operation]
+
+# skip instances with unknown base classes
+from some_missing_module import LibSubscriptable
+
+class MaybeSubscriptable(LibSubscriptable):
+ pass
+
+MaybeSubscriptable()[0] = 42
+
+# subscriptable classes (through metaclasses)
+
+class MetaSubscriptable(type):
+ def __setitem__(cls, key, value):
+ return key + value
+
+class SubscriptableClass(six.with_metaclass(MetaSubscriptable, object)):
+ pass
+
+SubscriptableClass[0] = 24
+SubscriptableClass()[0] = 24 # [unsupported-assignment-operation]
+
+# functions are not subscriptable
+def test(*args, **kwargs):
+ return args, kwargs
+
+test()[0] = 24 # [unsupported-assignment-operation]
+test[0] = 24 # [unsupported-assignment-operation]
+
+# deque
+from collections import deque
+deq = deque(maxlen=10)
+deq.append(42)
+deq[0] = 42
+
+# tuples assignment
+values = [1, 2, 3, 4]
+(values[0], values[1]) = 3, 4
+(values[0], SubscriptableClass()[0]) = 42, 42 # [unsupported-assignment-operation]
diff --git a/tests/functional/u/unsupported/unsupported_assignment_operation.rc b/tests/functional/u/unsupported/unsupported_assignment_operation.rc
new file mode 100644
index 0000000..6a8ee96
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_assignment_operation.rc
@@ -0,0 +1,2 @@
+[testoptions]
+requires = six
diff --git a/tests/functional/u/unsupported/unsupported_assignment_operation.txt b/tests/functional/u/unsupported/unsupported_assignment_operation.txt
new file mode 100644
index 0000000..854e8bf
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_assignment_operation.txt
@@ -0,0 +1,17 @@
+unsupported-assignment-operation:16:0::'(1, 2, 3)' does not support item assignment
+unsupported-assignment-operation:31:0::'NonSubscriptable()' does not support item assignment
+unsupported-assignment-operation:32:0::'NonSubscriptable' does not support item assignment
+unsupported-assignment-operation:34:0::'Subscriptable' does not support item assignment
+unsupported-assignment-operation:43:0::'powers_of_two()' does not support item assignment
+unsupported-assignment-operation:44:0::'powers_of_two' does not support item assignment
+unsupported-assignment-operation:48:0::'True' does not support item assignment
+unsupported-assignment-operation:49:0::'None' does not support item assignment
+unsupported-assignment-operation:50:0::'8.5' does not support item assignment
+unsupported-assignment-operation:51:0::'10' does not support item assignment
+unsupported-assignment-operation:54:0::'{x**2 for x in range(10)}' does not support item assignment
+unsupported-assignment-operation:55:0::'set(numbers)' does not support item assignment
+unsupported-assignment-operation:56:0::'frozenset(numbers)' does not support item assignment
+unsupported-assignment-operation:76:0::'SubscriptableClass()' does not support item assignment
+unsupported-assignment-operation:82:0::'test()' does not support item assignment
+unsupported-assignment-operation:83:0::'test' does not support item assignment
+unsupported-assignment-operation:94:12::'SubscriptableClass()' does not support item assignment
diff --git a/tests/functional/u/unsupported/unsupported_binary_operation.py b/tests/functional/u/unsupported/unsupported_binary_operation.py
new file mode 100644
index 0000000..0bfe1d1
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_binary_operation.py
@@ -0,0 +1,66 @@
+"""Test for unsupported-binary-operation."""
+# pylint: disable=missing-docstring,too-few-public-methods,pointless-statement
+# pylint: disable=expression-not-assigned, invalid-name, useless-object-inheritance
+
+
+import collections
+
+
+1 + "a" # [unsupported-binary-operation]
+1 - [] # [unsupported-binary-operation]
+1 * {} # [unsupported-binary-operation]
+1 / collections # [unsupported-binary-operation]
+1 ** (lambda x: x) # [unsupported-binary-operation]
+{} * {} # [unsupported-binary-operation]
+{} - {} # [unsupported-binary-operation]
+{} | {} # [unsupported-binary-operation]
+{} >> {} # [unsupported-binary-operation]
+[] + () # [unsupported-binary-operation]
+() + [] # [unsupported-binary-operation]
+[] * 2.0 # [unsupported-binary-operation]
+() * 2.0 # [unsupported-binary-operation]
+2.0 >> 2.0 # [unsupported-binary-operation]
+class A(object):
+ pass
+class B(object):
+ pass
+A() + B() # [unsupported-binary-operation]
+class A1(object):
+ def __add__(self, other):
+ return NotImplemented
+
+A1() + A1() # [unsupported-binary-operation]
+
+class A2(object):
+ def __add__(self, other):
+ return NotImplemented
+class B2(object):
+ def __radd__(self, other):
+ return NotImplemented
+A2() + B2() # [unsupported-binary-operation]
+
+class Parent(object):
+ pass
+class Child(Parent):
+ def __add__(self, other):
+ return NotImplemented
+Child() + Parent() # [unsupported-binary-operation]
+class A3(object):
+ def __add__(self, other):
+ return NotImplemented
+class B3(A3):
+ def __radd__(self, other):
+ return NotImplemented
+A3() + B3() # [unsupported-binary-operation]
+# Augmented
+FFF = 1
+FFF += A() # [unsupported-binary-operation]
+TTT = 1
+TTT += [] # [unsupported-binary-operation]
+
+
+# Don't emit for this case since we don't know what unknown is.
+from unknown import Unknown
+class Base(Unknown):
+ pass
+Base() * 23
diff --git a/tests/functional/u/unsupported/unsupported_binary_operation.rc b/tests/functional/u/unsupported/unsupported_binary_operation.rc
new file mode 100644
index 0000000..401ccfe
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_binary_operation.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=4.0
diff --git a/tests/functional/u/unsupported/unsupported_binary_operation.txt b/tests/functional/u/unsupported/unsupported_binary_operation.txt
new file mode 100644
index 0000000..00e43cb
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_binary_operation.txt
@@ -0,0 +1,21 @@
+unsupported-binary-operation:9::"unsupported operand type(s) for +: 'int' and 'str'"
+unsupported-binary-operation:10::"unsupported operand type(s) for -: 'int' and 'list'"
+unsupported-binary-operation:11::"unsupported operand type(s) for *: 'int' and 'dict'"
+unsupported-binary-operation:12::"unsupported operand type(s) for /: 'int' and 'module'"
+unsupported-binary-operation:13::"unsupported operand type(s) for **: 'int' and 'function'"
+unsupported-binary-operation:14::"unsupported operand type(s) for *: 'dict' and 'dict'"
+unsupported-binary-operation:15::"unsupported operand type(s) for -: 'dict' and 'dict'"
+unsupported-binary-operation:16::"unsupported operand type(s) for |: 'dict' and 'dict'"
+unsupported-binary-operation:17::"unsupported operand type(s) for >>: 'dict' and 'dict'"
+unsupported-binary-operation:18::"unsupported operand type(s) for +: 'list' and 'tuple'"
+unsupported-binary-operation:19::"unsupported operand type(s) for +: 'tuple' and 'list'"
+unsupported-binary-operation:20::"unsupported operand type(s) for *: 'list' and 'float'"
+unsupported-binary-operation:21::"unsupported operand type(s) for *: 'tuple' and 'float'"
+unsupported-binary-operation:22::"unsupported operand type(s) for >>: 'float' and 'float'"
+unsupported-binary-operation:27::"unsupported operand type(s) for +: 'A' and 'B'"
+unsupported-binary-operation:32::"unsupported operand type(s) for +: 'A1' and 'A1'"
+unsupported-binary-operation:40::"unsupported operand type(s) for +: 'A2' and 'B2'"
+unsupported-binary-operation:47::"unsupported operand type(s) for +: 'Child' and 'Parent'"
+unsupported-binary-operation:54::"unsupported operand type(s) for +: 'A3' and 'B3'"
+unsupported-binary-operation:57::"unsupported operand type(s) for +=: 'int' and 'A'"
+unsupported-binary-operation:59::"unsupported operand type(s) for +=: 'int' and 'list'"
diff --git a/tests/functional/u/unsupported/unsupported_delete_operation.py b/tests/functional/u/unsupported/unsupported_delete_operation.py
new file mode 100644
index 0000000..3c2882a
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_delete_operation.py
@@ -0,0 +1,94 @@
+"""
+Checks that value used in a subscript support deletion
+(i.e. defines __delitem__ method).
+"""
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,wrong-import-position,unnecessary-comprehension
+# pylint: disable=too-few-public-methods,import-error,invalid-name,wrong-import-order, useless-object-inheritance
+import six
+
+# primitives
+numbers = [1, 2, 3]
+del numbers[0]
+
+
+del bytearray(b"123")[0]
+del dict(a=1, b=2)['a']
+del (1, 2, 3)[0] # [unsupported-delete-operation]
+
+# list/dict comprehensions are fine
+del [x for x in range(10)][0]
+del {x: 10 - x for x in range(10)}[0]
+
+
+# instances
+class NonSubscriptable(object):
+ pass
+
+class Subscriptable(object):
+ def __delitem__(self, key):
+ pass
+
+del NonSubscriptable()[0] # [unsupported-delete-operation]
+del NonSubscriptable[0] # [unsupported-delete-operation]
+del Subscriptable()[0]
+del Subscriptable[0] # [unsupported-delete-operation]
+
+# generators are not subscriptable
+def powers_of_two():
+ k = 0
+ while k < 10:
+ yield 2 ** k
+ k += 1
+
+del powers_of_two()[0] # [unsupported-delete-operation]
+del powers_of_two[0] # [unsupported-delete-operation]
+
+
+# check that primitive non subscriptable types are caught
+del True[0] # [unsupported-delete-operation]
+del None[0] # [unsupported-delete-operation]
+del 8.5[0] # [unsupported-delete-operation]
+del 10[0] # [unsupported-delete-operation]
+
+# sets are not subscriptable
+del {x ** 2 for x in range(10)}[0] # [unsupported-delete-operation]
+del set(numbers)[0] # [unsupported-delete-operation]
+del frozenset(numbers)[0] # [unsupported-delete-operation]
+
+# skip instances with unknown base classes
+from some_missing_module import LibSubscriptable
+
+class MaybeSubscriptable(LibSubscriptable):
+ pass
+
+del MaybeSubscriptable()[0]
+
+# subscriptable classes (through metaclasses)
+
+class MetaSubscriptable(type):
+ def __delitem__(cls, key):
+ pass
+
+class SubscriptableClass(six.with_metaclass(MetaSubscriptable, object)):
+ pass
+
+del SubscriptableClass[0]
+del SubscriptableClass()[0] # [unsupported-delete-operation]
+
+# functions are not subscriptable
+def test(*args, **kwargs):
+ return args, kwargs
+
+del test()[0] # [unsupported-delete-operation]
+del test[0] # [unsupported-delete-operation]
+
+# deque
+from collections import deque
+deq = deque(maxlen=10)
+deq.append(42)
+del deq[0]
+
+# tuples assignment
+values = [1, 2, 3, 4]
+del (values[0], values[1])
+del (values[0], SubscriptableClass()[0]) # [unsupported-delete-operation]
diff --git a/tests/functional/u/unsupported/unsupported_delete_operation.rc b/tests/functional/u/unsupported/unsupported_delete_operation.rc
new file mode 100644
index 0000000..6a8ee96
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_delete_operation.rc
@@ -0,0 +1,2 @@
+[testoptions]
+requires = six
diff --git a/tests/functional/u/unsupported/unsupported_delete_operation.txt b/tests/functional/u/unsupported/unsupported_delete_operation.txt
new file mode 100644
index 0000000..6ad92eb
--- /dev/null
+++ b/tests/functional/u/unsupported/unsupported_delete_operation.txt
@@ -0,0 +1,17 @@
+unsupported-delete-operation:16:4::'(1, 2, 3)' does not support item deletion
+unsupported-delete-operation:31:4::'NonSubscriptable()' does not support item deletion
+unsupported-delete-operation:32:4::'NonSubscriptable' does not support item deletion
+unsupported-delete-operation:34:4::'Subscriptable' does not support item deletion
+unsupported-delete-operation:43:4::'powers_of_two()' does not support item deletion
+unsupported-delete-operation:44:4::'powers_of_two' does not support item deletion
+unsupported-delete-operation:48:4::'True' does not support item deletion
+unsupported-delete-operation:49:4::'None' does not support item deletion
+unsupported-delete-operation:50:4::'8.5' does not support item deletion
+unsupported-delete-operation:51:4::'10' does not support item deletion
+unsupported-delete-operation:54:4::'{x**2 for x in range(10)}' does not support item deletion
+unsupported-delete-operation:55:4::'set(numbers)' does not support item deletion
+unsupported-delete-operation:56:4::'frozenset(numbers)' does not support item deletion
+unsupported-delete-operation:76:4::'SubscriptableClass()' does not support item deletion
+unsupported-delete-operation:82:4::'test()' does not support item deletion
+unsupported-delete-operation:83:4::'test' does not support item deletion
+unsupported-delete-operation:94:16::'SubscriptableClass()' does not support item deletion
diff --git a/tests/functional/u/unused/__init__.py b/tests/functional/u/unused/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/u/unused/__init__.py
diff --git a/tests/functional/u/unused/unused_argument.py b/tests/functional/u/unused/unused_argument.py
new file mode 100644
index 0000000..707eb25
--- /dev/null
+++ b/tests/functional/u/unused/unused_argument.py
@@ -0,0 +1,89 @@
+# pylint: disable=missing-docstring,too-few-public-methods, useless-object-inheritance
+
+def test_unused(first, second, _not_used): # [unused-argument, unused-argument]
+ pass
+
+
+def test_prefixed_with_ignored(first, ignored_second):
+ first()
+
+
+def test_prefixed_with_unused(first, unused_second):
+ first()
+
+# for Sub.inherited, only the warning for "aay" is desired.
+# The warnings for "aab" and "aac" are most likely false positives though,
+# because there could be another subclass that overrides the same method and does
+# use the arguments (eg Sub2)
+
+
+class Base(object):
+ "parent"
+ def inherited(self, aaa, aab, aac):
+ "abstract method"
+ raise NotImplementedError
+
+class Sub(Base):
+ "child 1"
+ def inherited(self, aaa, aab, aac):
+ "overridden method, though don't use every argument"
+ return aaa
+
+ def newmethod(self, aax, aay): # [unused-argument]
+ "another method, warning for aay desired"
+ return self, aax
+
+class Sub2(Base):
+ "child 1"
+
+ def inherited(self, aaa, aab, aac):
+ "overridden method, use every argument"
+ return aaa + aab + aac
+
+def metadata_from_dict(key):
+ """
+ Should not raise unused-argument message because key is
+ used inside comprehension dict
+ """
+ return {key: str(value) for key, value in key.items()}
+
+# pylint: disable=too-few-public-methods, print-statement, misplaced-future,wrong-import-position
+from __future__ import print_function
+
+
+def function(arg=1): # [unused-argument]
+ """ignore arg"""
+
+
+class AAAA(object):
+ """dummy class"""
+
+ def method(self, arg): # [unused-argument]
+ """dummy method"""
+ print(self)
+ def __init__(self, *unused_args, **unused_kwargs):
+ pass
+
+ @classmethod
+ def selected(cls, *args, **kwargs): # [unused-argument, unused-argument]
+ """called by the registry when the vobject has been selected.
+ """
+ return cls
+
+ def using_inner_function(self, etype, size=1):
+ """return a fake result set for a particular entity type"""
+ rset = AAAA([('A',)]*size, '%s X' % etype,
+ description=[(etype,)]*size)
+ def inner(row, col=0, etype=etype, req=self, rset=rset):
+ """inner using all its argument"""
+ # pylint: disable=maybe-no-member
+ return req.vreg.etype_class(etype)(req, rset, row, col)
+ # pylint: disable = attribute-defined-outside-init
+ rset.get_entity = inner
+
+class BBBB(object):
+ """dummy class"""
+
+ def __init__(self, arg): # [unused-argument]
+ """Constructor with an extra parameter. Should raise a warning"""
+ self.spam = 1
diff --git a/tests/functional/u/unused/unused_argument.txt b/tests/functional/u/unused/unused_argument.txt
new file mode 100644
index 0000000..b1ad4ad
--- /dev/null
+++ b/tests/functional/u/unused/unused_argument.txt
@@ -0,0 +1,8 @@
+unused-argument:3:16:test_unused:Unused argument 'first'
+unused-argument:3:23:test_unused:Unused argument 'second'
+unused-argument:32:29:Sub.newmethod:Unused argument 'aay':INFERENCE
+unused-argument:54:13:function:Unused argument 'arg'
+unused-argument:61:21:AAAA.method:Unused argument 'arg':INFERENCE
+unused-argument:68:0:AAAA.selected:Unused argument 'args':INFERENCE
+unused-argument:68:0:AAAA.selected:Unused argument 'kwargs':INFERENCE
+unused-argument:87:23:BBBB.__init__:Unused argument 'arg':INFERENCE
diff --git a/tests/functional/u/unused/unused_argument_py3.py b/tests/functional/u/unused/unused_argument_py3.py
new file mode 100644
index 0000000..4d0fd9a
--- /dev/null
+++ b/tests/functional/u/unused/unused_argument_py3.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring
+
+def func(first, *, second): # [unused-argument, unused-argument]
+ pass
+
+
+def only_raises(first, second=42): # [unused-argument]
+ if first == 24:
+ raise ValueError
diff --git a/tests/functional/u/unused/unused_argument_py3.rc b/tests/functional/u/unused/unused_argument_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/u/unused/unused_argument_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/u/unused/unused_argument_py3.txt b/tests/functional/u/unused/unused_argument_py3.txt
new file mode 100644
index 0000000..2bddb51
--- /dev/null
+++ b/tests/functional/u/unused/unused_argument_py3.txt
@@ -0,0 +1,3 @@
+unused-argument:3:9:func:Unused argument 'first'
+unused-argument:3:19:func:Unused argument 'second'
+unused-argument:7:23:only_raises:Unused argument 'second'
diff --git a/tests/functional/u/unused/unused_global_variable1.py b/tests/functional/u/unused/unused_global_variable1.py
new file mode 100644
index 0000000..e630c33
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable1.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint'
diff --git a/tests/functional/u/unused/unused_global_variable2.py b/tests/functional/u/unused/unused_global_variable2.py
new file mode 100644
index 0000000..6222409
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable2.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint' # [unused-variable]
diff --git a/tests/functional/u/unused/unused_global_variable2.rc b/tests/functional/u/unused/unused_global_variable2.rc
new file mode 100644
index 0000000..5dcd4a8
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable2.rc
@@ -0,0 +1,2 @@
+[variables]
+allow-global-unused-variables=no
diff --git a/tests/functional/u/unused/unused_global_variable2.txt b/tests/functional/u/unused/unused_global_variable2.txt
new file mode 100644
index 0000000..a670aa0
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable2.txt
@@ -0,0 +1 @@
+unused-variable:2:0::Unused variable 'VAR'
diff --git a/tests/functional/u/unused/unused_global_variable3.py b/tests/functional/u/unused/unused_global_variable3.py
new file mode 100644
index 0000000..896789e
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable3.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint'
+
+
+def func(argument):
+ return VAR + argument
diff --git a/tests/functional/u/unused/unused_global_variable4.py b/tests/functional/u/unused/unused_global_variable4.py
new file mode 100644
index 0000000..aef49d6
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable4.py
@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint' # [unused-variable]
+VAR = 'pylint2' # [unused-variable]
diff --git a/tests/functional/u/unused/unused_global_variable4.rc b/tests/functional/u/unused/unused_global_variable4.rc
new file mode 100644
index 0000000..5dcd4a8
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable4.rc
@@ -0,0 +1,2 @@
+[variables]
+allow-global-unused-variables=no
diff --git a/tests/functional/u/unused/unused_global_variable4.txt b/tests/functional/u/unused/unused_global_variable4.txt
new file mode 100644
index 0000000..67e6da9
--- /dev/null
+++ b/tests/functional/u/unused/unused_global_variable4.txt
@@ -0,0 +1,2 @@
+unused-variable:2:0::Unused variable 'VAR'
+unused-variable:3:0::Unused variable 'VAR'
diff --git a/tests/functional/u/unused/unused_import.py b/tests/functional/u/unused/unused_import.py
new file mode 100644
index 0000000..c6c2f20
--- /dev/null
+++ b/tests/functional/u/unused/unused_import.py
@@ -0,0 +1,63 @@
+"""unused import"""
+# pylint: disable=undefined-all-variable, import-error, no-absolute-import, too-few-public-methods, missing-docstring,wrong-import-position, useless-object-inheritance, multiple-imports
+import xml.etree # [unused-import]
+import xml.sax # [unused-import]
+import os.path as test # [unused-import]
+from sys import argv as test2 # [unused-import]
+from sys import flags # [unused-import]
+# +1:[unused-import,unused-import]
+from collections import deque, OrderedDict, Counter
+import re, html.parser # [unused-import]
+DATA = Counter()
+# pylint: disable=self-assigning-variable
+from fake import SomeName, SomeOtherName # [unused-import]
+class SomeClass(object):
+ SomeName = SomeName # https://bitbucket.org/logilab/pylint/issue/475
+ SomeOtherName = 1
+ SomeOtherName = SomeOtherName
+
+from never import __all__
+# pylint: disable=wrong-import-order,ungrouped-imports
+import typing
+from typing import TYPE_CHECKING
+
+
+if typing.TYPE_CHECKING:
+ import collections
+if TYPE_CHECKING:
+ import itertools
+
+
+def get_ordered_dict() -> 'collections.OrderedDict':
+ return []
+
+
+def get_itertools_obj() -> 'itertools.count':
+ return []
+
+def use_html_parser() -> 'html.parser.HTMLParser':
+ return html.parser.HTMLParser
+
+# pylint: disable=misplaced-future
+
+from __future__ import print_function
+
+import os # [unused-import]
+import sys
+
+class NonRegr(object):
+ """???"""
+ def __init__(self):
+ print('initialized')
+
+ def sys(self):
+ """should not get sys from there..."""
+ print(self, sys)
+
+ def dummy(self, truc):
+ """yo"""
+ return self, truc
+
+ def blop(self):
+ """yo"""
+ print(self, 'blip')
diff --git a/tests/functional/u/unused/unused_import.txt b/tests/functional/u/unused/unused_import.txt
new file mode 100644
index 0000000..79ac42d
--- /dev/null
+++ b/tests/functional/u/unused/unused_import.txt
@@ -0,0 +1,10 @@
+unused-import:3:0::Unused import xml.etree
+unused-import:4:0::Unused import xml.sax
+unused-import:5:0::Unused os.path imported as test
+unused-import:6:0::Unused argv imported from sys as test2
+unused-import:7:0::Unused flags imported from sys
+unused-import:9:0::Unused OrderedDict imported from collections
+unused-import:9:0::Unused deque imported from collections
+unused-import:10:0::Unused import re
+unused-import:13:0::Unused SomeOtherName imported from fake
+unused-import:45:0::Unused import os
diff --git a/tests/functional/u/unused/unused_import_assigned_to.py b/tests/functional/u/unused/unused_import_assigned_to.py
new file mode 100644
index 0000000..fb339bc
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_assigned_to.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring, import-error, invalid-name
+# pylint: disable=too-few-public-methods, disallowed-name, no-member, useless-object-inheritance
+
+import uuid
+
+# Note this import doesn't actually exist
+import foo
+
+from .a import x
+
+
+class Y(object):
+ x = x[0]
+
+
+def test(default=None):
+ return default
+
+
+class BaseModel(object):
+ uuid = test(default=uuid.uuid4)
+
+
+class bar(object):
+ foo = foo.baz
diff --git a/tests/functional/u/unused/unused_import_class_def_keyword.py b/tests/functional/u/unused/unused_import_class_def_keyword.py
new file mode 100644
index 0000000..0d6b599
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_class_def_keyword.py
@@ -0,0 +1,38 @@
+"""
+Test false-positive for unused-import on class keyword arguments
+
+ https://github.com/PyCQA/pylint/issues/3202
+"""
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name,import-error
+
+# Imports don't exist! Only check `unused-import`
+from const import DOMAIN
+from const import DOMAIN_2
+from const import DOMAIN_3
+
+
+class Child:
+ def __init_subclass__(cls, **kwargs):
+ pass
+
+class Parent(Child, domain=DOMAIN):
+ pass
+
+
+# Alternative 1
+class Parent_2(Child, domain=DOMAIN_2):
+ DOMAIN_2 = DOMAIN_2
+
+
+# Alternative 2
+class A:
+ def __init__(self, arg):
+ pass
+
+class B:
+ CONF = "Hello World"
+ SCHEMA = A(arg=CONF)
+
+
+# Test normal instantiation
+A(arg=DOMAIN_3)
diff --git a/tests/functional/u/unused/unused_import_everything_disabled.py b/tests/functional/u/unused/unused_import_everything_disabled.py
new file mode 100644
index 0000000..7d6cce7
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_everything_disabled.py
@@ -0,0 +1,8 @@
+"""Test that unused-import is not emitted here when everything else is disabled
+
+https://github.com/PyCQA/pylint/issues/3445
+"""
+from os import environ
+
+for k, v in environ.items():
+ print(k, v)
diff --git a/tests/functional/u/unused/unused_import_everything_disabled.rc b/tests/functional/u/unused/unused_import_everything_disabled.rc
new file mode 100644
index 0000000..a9f89cf
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_everything_disabled.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=all
+enable=unused-import
diff --git a/tests/functional/u/unused/unused_import_positional_only_py38.py b/tests/functional/u/unused/unused_import_positional_only_py38.py
new file mode 100644
index 0000000..693a377
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_positional_only_py38.py
@@ -0,0 +1,10 @@
+"""Test that positional only argument annotations are properly marked as consumed
+
+https://github.com/PyCQA/pylint/issues/3462
+"""
+from typing import AnyStr, Set
+
+
+def func(arg: AnyStr, /, arg2: Set[str]):
+ """Uses positional only arguments"""
+ return arg, arg2
diff --git a/tests/functional/u/unused/unused_import_positional_only_py38.rc b/tests/functional/u/unused/unused_import_positional_only_py38.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_positional_only_py38.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/u/unused/unused_import_py30.py b/tests/functional/u/unused/unused_import_py30.py
new file mode 100644
index 0000000..95fed20
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_py30.py
@@ -0,0 +1,19 @@
+"""check unused import for metaclasses"""
+# pylint: disable=too-few-public-methods,wrong-import-position,ungrouped-imports
+__revision__ = 1
+import abc
+import sys
+from abc import ABCMeta
+from abc import ABCMeta as SomethingElse # [reimported]
+
+class Meta(metaclass=abc.ABCMeta):
+ """ Test """
+ def __init__(self):
+ self.data = sys.executable
+ self.test = abc
+
+class Meta2(metaclass=ABCMeta):
+ """ Test """
+
+class Meta3(metaclass=SomethingElse):
+ """ test """
diff --git a/tests/functional/u/unused/unused_import_py30.txt b/tests/functional/u/unused/unused_import_py30.txt
new file mode 100644
index 0000000..1a2ff4f
--- /dev/null
+++ b/tests/functional/u/unused/unused_import_py30.txt
@@ -0,0 +1 @@
+reimported:7:0::Reimport 'ABCMeta' (imported line 6)
diff --git a/tests/functional/u/unused/unused_name_from_wilcard_import.py b/tests/functional/u/unused/unused_name_from_wilcard_import.py
new file mode 100644
index 0000000..56f5b60
--- /dev/null
+++ b/tests/functional/u/unused/unused_name_from_wilcard_import.py
@@ -0,0 +1,3 @@
+"""check unused import from a wildcard import"""
+# pylint: disable=no-absolute-import,line-too-long
+from .unused_argument_py3 import * # [unused-wildcard-import, unused-wildcard-import, wildcard-import]
diff --git a/tests/functional/u/unused/unused_name_from_wilcard_import.txt b/tests/functional/u/unused/unused_name_from_wilcard_import.txt
new file mode 100644
index 0000000..ba7628b
--- /dev/null
+++ b/tests/functional/u/unused/unused_name_from_wilcard_import.txt
@@ -0,0 +1,3 @@
+unused-wildcard-import:3:0::Unused import func from wildcard import
+unused-wildcard-import:3:0::Unused import only_raises from wildcard import
+wildcard-import:3:0::Wildcard import unused_argument_py3
diff --git a/tests/functional/u/unused/unused_private_member.py b/tests/functional/u/unused/unused_private_member.py
new file mode 100644
index 0000000..d654785
--- /dev/null
+++ b/tests/functional/u/unused/unused_private_member.py
@@ -0,0 +1,68 @@
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods, no-self-use, line-too-long, unused-argument, protected-access
+
+class AnotherClass():
+ def __test(self): # [unused-private-member]
+ pass
+
+class HasUnusedInClass():
+ __my_secret = "I have no secrets" # [unused-private-member]
+ __my_used_secret = "I have no secrets unused"
+
+ @classmethod
+ def __private_class_method_unused(cls): # [unused-private-member]
+ print(cls.__my_used_secret)
+
+ @classmethod
+ def __private_class_method_used(cls):
+ pass
+
+ @staticmethod
+ def __private_static_method_unused(): # [unused-private-member]
+ pass
+
+ @staticmethod
+ def __private_static_method_used():
+ pass
+
+ def __init__(self): # Will not trigger as it begins with __ and ends with __
+ self.__instance_secret = "I will never be initialized" # [unused-private-member]
+ self.__another_secret = "hello world"
+
+ def __str__(self): # Will not trigger as it begins with __ and ends with __
+ return "hello"
+
+ def __test(self, x, y, z): # [unused-private-member]
+ fn = HasUnusedInClass.__private_class_method_used
+ fn()
+ fn2 = HasUnusedInClass.__private_static_method_used
+ fn2()
+
+ def __my_print(self, string):
+ print(self.__another_secret + string)
+ another_obj = AnotherClass()
+ another_obj.__test() # this class's test should still be unused
+
+ def hey(self): # Will not trigger as it does not begin with __
+ self.__my_print("!")
+
+ def __test_fn_as_var(self):
+ pass
+
+ def assign_fn_to_var(self):
+ fn = self.__test_fn_as_var
+ fn()
+
+ def __test_recursive(self): # [unused-private-member]
+ self.__test_recursive()
+
+# False positive: Singleton Pattern
+class MyCls:
+ __class_var = None
+
+ @classmethod
+ def set_class_var(cls, var):
+ cls.__class_var = var # should not emit a message, used in get_class_var()
+
+ @classmethod
+ def get_class_var(cls):
+ return cls.__class_var
diff --git a/tests/functional/u/unused/unused_private_member.txt b/tests/functional/u/unused/unused_private_member.txt
new file mode 100644
index 0000000..feaa45e
--- /dev/null
+++ b/tests/functional/u/unused/unused_private_member.txt
@@ -0,0 +1,7 @@
+unused-private-member:4:4:AnotherClass.__test:Unused private member `AnotherClass.__test(self)`
+unused-private-member:8:4:HasUnusedInClass:Unused private member `HasUnusedInClass.__my_secret`
+unused-private-member:12:4:HasUnusedInClass.__private_class_method_unused:Unused private member `HasUnusedInClass.__private_class_method_unused(cls)`
+unused-private-member:20:4:HasUnusedInClass.__private_static_method_unused:Unused private member `HasUnusedInClass.__private_static_method_unused()`
+unused-private-member:28:8:HasUnusedInClass.__init__:Unused private member `HasUnusedInClass.__instance_secret`
+unused-private-member:34:4:HasUnusedInClass.__test:Unused private member `HasUnusedInClass.__test(self, x, y, z)`
+unused-private-member:55:4:HasUnusedInClass.__test_recursive:Unused private member `HasUnusedInClass.__test_recursive(self)`
diff --git a/tests/functional/u/unused/unused_typing_imports.py b/tests/functional/u/unused/unused_typing_imports.py
new file mode 100644
index 0000000..7de4e41
--- /dev/null
+++ b/tests/functional/u/unused/unused_typing_imports.py
@@ -0,0 +1,85 @@
+# pylint: disable=missing-docstring
+"""Regression test for https://github.com/PyCQA/pylint/issues/1168
+
+The problem was that we weren't handling keyword-only arguments annotations,
+which means we were never processing them.
+"""
+
+import re
+import typing
+from collections import Counter as CollectionCounter
+from collections import defaultdict
+from datetime import datetime
+from typing import (
+ Any,
+ Callable,
+ Iterable,
+ List,
+ NamedTuple,
+ Optional,
+ Pattern,
+ Sequence,
+ Set,
+ Tuple,
+)
+
+
+def func1(arg: Optional[Callable]=None):
+ return arg
+
+
+def func2(*, arg: Optional[Iterable]=None):
+ return arg
+
+
+SOME_VALUE = [1] # type: List[Any]
+for VALUE in [[1], [2], [3]]: # type: Tuple[Any]
+ print(VALUE)
+
+
+class ContextManager:
+ def __enter__(self):
+ return {1}
+
+ def __exit__(self, *_args):
+ pass
+
+
+with ContextManager() as SOME_DICT: # type: Set[int]
+ print(SOME_DICT)
+
+
+def func_test_type_comment(param):
+ # type: (NamedTuple) -> Tuple[NamedTuple, Pattern]
+ return param, re.compile('good')
+
+
+def typing_fully_qualified():
+ variable = None # type: typing.Optional[str]
+ other_variable: 'typing.Optional[str]' = None
+ return variable, other_variable
+
+
+def function(arg1, # type: Iterable
+ arg2 # type: List
+ ):
+ # type: (...) -> Sequence
+ """docstring"""
+ print(arg1, arg2)
+
+
+def magic(alpha, beta, gamma):
+ # type: (str, Optional[str], Optional[datetime]) -> Any
+ """going strong"""
+ return alpha, beta, gamma
+
+
+def unused_assignment_import():
+ foo_or_bar = 42 # type: defaultdict
+ return foo_or_bar
+
+
+def unused_reassigned_import(counter):
+ # type: (CollectionCounter) -> int
+ print(counter)
+ return 42
diff --git a/tests/functional/u/unused/unused_typing_imports.rc b/tests/functional/u/unused/unused_typing_imports.rc
new file mode 100644
index 0000000..b239d6e
--- /dev/null
+++ b/tests/functional/u/unused/unused_typing_imports.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.6
+except_implementations=PyPy
diff --git a/tests/functional/u/unused/unused_variable.py b/tests/functional/u/unused/unused_variable.py
new file mode 100644
index 0000000..11c4081
--- /dev/null
+++ b/tests/functional/u/unused/unused_variable.py
@@ -0,0 +1,159 @@
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods, no-self-use, useless-object-inheritance,import-outside-toplevel, fixme
+
+def test_regression_737():
+ import xml # [unused-import]
+
+def test_regression_923():
+ import unittest.case # [unused-import]
+ import xml as sql # [unused-import]
+
+def test_unused_with_prepended_underscore():
+ _foo = 42
+ _ = 24
+ __a = 24
+ dummy = 24
+ _a_ = 42 # [unused-variable]
+ __a__ = 24 # [unused-variable]
+ __never_used = 42
+
+def test_local_field_prefixed_with_unused_or_ignored():
+ flagged_local_field = 42 # [unused-variable]
+ unused_local_field = 42
+ ignored_local_field = 42
+
+
+class HasUnusedDunderClass(object):
+
+ def test(self):
+ __class__ = 42 # [unused-variable]
+
+ def best(self):
+ self.test()
+
+
+def locals_example_defined_before():
+ value = 42 # [possibly-unused-variable]
+ return locals()
+
+
+def locals_example_defined_after():
+ local_variables = locals()
+ value = 42 # [unused-variable]
+ return local_variables
+
+
+def locals_does_not_account_for_subscopes():
+ value = 42 # [unused-variable]
+
+ def some_other_scope():
+ return locals()
+ return some_other_scope
+
+
+def unused_import_from():
+ from functools import wraps as abc # [unused-import]
+ from collections import namedtuple # [unused-import]
+
+
+def unused_import_in_function(value):
+ from string import digits, hexdigits # [unused-import]
+ return value if value in digits else "Nope"
+
+
+def hello(arg):
+ my_var = 'something' # [unused-variable]
+ if arg:
+ return True
+ raise Exception
+
+# pylint: disable=redefined-outer-name, wrong-import-position,misplaced-future
+from __future__ import print_function
+PATH = OS = collections = deque = None
+
+
+def function(matches):
+ """"yo"""
+ aaaa = 1 # [unused-variable]
+ index = -1
+ for match in matches:
+ index += 1
+ print(match)
+
+
+def visit_if(self, node):
+ """increments the branches counter"""
+ branches = 1
+ # don't double count If nodes coming from some 'elif'
+ if node.orelse and len(node.orelse) > 1:
+ branches += 1
+ self.inc_branch(branches)
+ self.stmts += branches
+
+
+def test_global():
+ """ Test various assignments of global
+ variables through imports.
+ """
+ global PATH, OS, collections, deque # [global-statement]
+ from os import path as PATH
+ import os as OS
+ import collections
+ from collections import deque
+ # make sure that these triggers unused-variable
+ from sys import platform # [unused-import]
+ from sys import version as VERSION # [unused-import]
+ import this # [unused-import]
+ import re as RE # [unused-import]
+
+# test cases that include exceptions
+def function2():
+ unused = 1 # [unused-variable]
+ try:
+ 1 / 0
+ except ZeroDivisionError as error:
+ # TODO fix bug for not identifying unused variables in nested exceptions see issue #4391
+ try:
+ 1 / 0
+ except ZeroDivisionError as error:
+ raise Exception("") from error
+
+def func():
+ try:
+ 1 / 0
+ except ZeroDivisionError as error:
+ # TODO fix bug for not identifying unused variables in nested exceptions see issue #4391
+ try:
+ 1 / 0
+ except error:
+ print("error")
+
+def func2():
+ try:
+ 1 / 0
+ except ZeroDivisionError as error:
+ # TODO fix bug for not identifying unused variables in nested exceptions see issue #4391
+ try:
+ 1 / 0
+ except:
+ raise Exception("") from error
+
+def func3():
+ try:
+ 1 / 0
+ except ZeroDivisionError as error:
+ print(f"{error}")
+ try:
+ 1 / 2
+ except TypeError as error:
+ # TODO fix bug for not identifying unused variables in nested exceptions see issue #4391
+ print("warning")
+
+def func4():
+ try:
+ 1 / 0
+ except ZeroDivisionError as error: # [unused-variable]
+ try:
+ 1 / 0
+ except ZeroDivisionError as error:
+ # TODO fix bug for not identifying unused variables in nested exceptions see issue #4391
+ print("error")
diff --git a/tests/functional/u/unused/unused_variable.txt b/tests/functional/u/unused/unused_variable.txt
new file mode 100644
index 0000000..760d8b8
--- /dev/null
+++ b/tests/functional/u/unused/unused_variable.txt
@@ -0,0 +1,22 @@
+unused-import:4:4:test_regression_737:Unused import xml
+unused-import:7:4:test_regression_923:Unused import unittest.case
+unused-import:8:4:test_regression_923:Unused xml imported as sql
+unused-variable:15:4:test_unused_with_prepended_underscore:Unused variable '_a_'
+unused-variable:16:4:test_unused_with_prepended_underscore:Unused variable '__a__'
+unused-variable:20:4:test_local_field_prefixed_with_unused_or_ignored:Unused variable 'flagged_local_field'
+unused-variable:28:8:HasUnusedDunderClass.test:Unused variable '__class__'
+possibly-unused-variable:35:4:locals_example_defined_before:Possibly unused variable 'value'
+unused-variable:41:4:locals_example_defined_after:Unused variable 'value'
+unused-variable:46:4:locals_does_not_account_for_subscopes:Unused variable 'value'
+unused-import:54:4:unused_import_from:Unused wraps imported from functools as abc
+unused-import:55:4:unused_import_from:Unused namedtuple imported from collections
+unused-import:59:4:unused_import_in_function:Unused hexdigits imported from string
+unused-variable:64:4:hello:Unused variable 'my_var'
+unused-variable:76:4:function:Unused variable 'aaaa'
+global-statement:97:4:test_global:Using the global statement
+unused-import:103:4:test_global:Unused platform imported from sys
+unused-import:104:4:test_global:Unused version imported from sys as VERSION
+unused-import:105:4:test_global:Unused import this
+unused-import:106:4:test_global:Unused re imported as RE
+unused-variable:110:4:function2:Unused variable 'unused'
+unused-variable:154:4:func4:Unused variable 'error'
diff --git a/tests/functional/u/unused/unused_variable_py36.py b/tests/functional/u/unused/unused_variable_py36.py
new file mode 100644
index 0000000..396d028
--- /dev/null
+++ b/tests/functional/u/unused/unused_variable_py36.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring
+
+def function():
+ ann: int = 0
+ assign = 0
+
+ def inner():
+ nonlocal ann, assign
+ ann += 1
+ assign += 1
+ return ann + assign
+
+ return inner()
diff --git a/tests/functional/u/unused/unused_variable_py36.rc b/tests/functional/u/unused/unused_variable_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/u/unused/unused_variable_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/u/use/use_a_generator.py b/tests/functional/u/use/use_a_generator.py
new file mode 100644
index 0000000..279deb4
--- /dev/null
+++ b/tests/functional/u/use/use_a_generator.py
@@ -0,0 +1,11 @@
+# pylint: disable=missing-docstring, invalid-name
+# https://github.com/PyCQA/pylint/issues/3165
+
+any([])
+all([])
+
+any([0 for x in list(range(10))]) # [use-a-generator]
+all([0 for y in list(range(10))]) # [use-a-generator]
+
+any(0 for x in list(range(10)))
+all(0 for y in list(range(10)))
diff --git a/tests/functional/u/use/use_a_generator.txt b/tests/functional/u/use/use_a_generator.txt
new file mode 100644
index 0000000..e7be228
--- /dev/null
+++ b/tests/functional/u/use/use_a_generator.txt
@@ -0,0 +1,2 @@
+use-a-generator:7:0::Use a generator instead 'any(0 for x in list(range(10)))'
+use-a-generator:8:0::Use a generator instead 'all(0 for y in list(range(10)))'
diff --git a/tests/functional/u/use/use_maxsplit_arg.py b/tests/functional/u/use/use_maxsplit_arg.py
new file mode 100644
index 0000000..1b998e5
--- /dev/null
+++ b/tests/functional/u/use/use_maxsplit_arg.py
@@ -0,0 +1,84 @@
+"""Emit a message for accessing first/last element of string.split"""
+# pylint: disable=line-too-long,missing-docstring,unsubscriptable-object,too-few-public-methods,invalid-name,redefined-builtin
+
+# Test subscripting .split()
+get_first = '1,2,3'.split(',')[0] # [use-maxsplit-arg]
+get_last = '1,2,3'[::-1].split(',')[0] # [use-maxsplit-arg]
+
+SEQ = '1,2,3'
+get_first = SEQ.split(',')[0] # [use-maxsplit-arg]
+get_last = SEQ.split(',')[-1] # [use-maxsplit-arg]
+get_first = SEQ.rsplit(',')[0] # [use-maxsplit-arg]
+get_last = SEQ.rsplit(',')[-1] # [use-maxsplit-arg]
+
+# Don't suggest maxsplit=1 if not accessing the first or last element
+get_mid = SEQ.split(',')[1]
+get_mid = SEQ.split(',')[-2]
+
+
+# Test varying maxsplit argument -- all these will be okay
+# ## str.split() tests
+good_split = '1,2,3'.split(sep=',', maxsplit=1)[-1]
+good_split = '1,2,3'.split(sep=',', maxsplit=1)[0]
+good_split = '1,2,3'.split(sep=',', maxsplit=2)[-1]
+good_split = '1,2,3'.split(sep=',', maxsplit=2)[0]
+good_split = '1,2,3'.split(sep=',', maxsplit=2)[1]
+
+# ## str.rsplit() tests
+good_split = '1,2,3'.rsplit(sep=',', maxsplit=1)[-1]
+good_split = '1,2,3'.rsplit(sep=',', maxsplit=1)[0]
+good_split = '1,2,3'.rsplit(sep=',', maxsplit=2)[-1]
+good_split = '1,2,3'.rsplit(sep=',', maxsplit=2)[0]
+good_split = '1,2,3'.rsplit(sep=',', maxsplit=2)[1]
+
+
+# Tests on class attributes
+class Foo():
+ class_str = '1,2,3'
+ def __init__(self):
+ self.my_str = '1,2,3'
+
+ def get_string(self) -> str:
+ return self.my_str
+
+# Class attributes
+get_first = Foo.class_str.split(',')[0] # [use-maxsplit-arg]
+get_last = Foo.class_str.split(',')[-1] # [use-maxsplit-arg]
+get_first = Foo.class_str.rsplit(',')[0] # [use-maxsplit-arg]
+get_last = Foo.class_str.rsplit(',')[-1] # [use-maxsplit-arg]
+
+get_mid = Foo.class_str.split(',')[1]
+get_mid = Foo.class_str.split(',')[-2]
+
+
+# Test with accessors
+bar = Foo()
+get_first = bar.get_string().split(',')[0] # [use-maxsplit-arg]
+get_last = bar.get_string().split(',')[-1] # [use-maxsplit-arg]
+
+get_mid = bar.get_string().split(',')[1]
+get_mid = bar.get_string().split(',')[-2]
+
+
+# Test with iterating over strings
+list_of_strs = ["a", "b", "c", "d", "e", "f"]
+for s in list_of_strs:
+ print(s.split(" ")[0]) # [use-maxsplit-arg]
+ print(s.split(" ")[-1]) # [use-maxsplit-arg]
+ print(s.split(" ")[-2])
+
+
+# Test warning messages (matching and replacing .split / .rsplit)
+class Bar():
+ split = '1,2,3'
+
+# Error message should show Bar.split.split(',', maxsplit=1) or Bar.split.rsplit(',', maxsplit=1)
+print(Bar.split.split(",")[0]) # [use-maxsplit-arg]
+print(Bar.split.split(",")[-1]) # [use-maxsplit-arg]
+print(Bar.split.rsplit(",")[0]) # [use-maxsplit-arg]
+print(Bar.split.rsplit(",")[-1]) # [use-maxsplit-arg]
+
+# Special cases
+a = "1,2,3".split('\n')[0] # [use-maxsplit-arg]
+a = "1,2,3".split('split')[-1] # [use-maxsplit-arg]
+a = "1,2,3".rsplit('rsplit')[0] # [use-maxsplit-arg]
diff --git a/tests/functional/u/use/use_maxsplit_arg.txt b/tests/functional/u/use/use_maxsplit_arg.txt
new file mode 100644
index 0000000..8137374
--- /dev/null
+++ b/tests/functional/u/use/use_maxsplit_arg.txt
@@ -0,0 +1,21 @@
+use-maxsplit-arg:5:12::Use '1,2,3'.split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:6:11::"Use '1,2,3'[::-1].split(',', maxsplit=1)[0] instead"
+use-maxsplit-arg:9:12::Use SEQ.split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:10:11::Use SEQ.rsplit(',', maxsplit=1)[-1] instead
+use-maxsplit-arg:11:12::Use SEQ.split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:12:11::Use SEQ.rsplit(',', maxsplit=1)[-1] instead
+use-maxsplit-arg:45:12::Use Foo.class_str.split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:46:11::Use Foo.class_str.rsplit(',', maxsplit=1)[-1] instead
+use-maxsplit-arg:47:12::Use Foo.class_str.split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:48:11::Use Foo.class_str.rsplit(',', maxsplit=1)[-1] instead
+use-maxsplit-arg:56:12::Use bar.get_string().split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:57:11::Use bar.get_string().rsplit(',', maxsplit=1)[-1] instead
+use-maxsplit-arg:66:10::Use s.split(' ', maxsplit=1)[0] instead
+use-maxsplit-arg:67:10::Use s.rsplit(' ', maxsplit=1)[-1] instead
+use-maxsplit-arg:76:6::Use Bar.split.split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:77:6::Use Bar.split.rsplit(',', maxsplit=1)[-1] instead
+use-maxsplit-arg:78:6::Use Bar.split.split(',', maxsplit=1)[0] instead
+use-maxsplit-arg:79:6::Use Bar.split.rsplit(',', maxsplit=1)[-1] instead
+use-maxsplit-arg:82:4::Use '1,2,3'.split('\n', maxsplit=1)[0] instead
+use-maxsplit-arg:83:4::Use '1,2,3'.rsplit('split', maxsplit=1)[-1] instead
+use-maxsplit-arg:84:4::Use '1,2,3'.split('rsplit', maxsplit=1)[0] instead
diff --git a/tests/functional/u/use/use_symbolic_message_instead.py b/tests/functional/u/use/use_symbolic_message_instead.py
new file mode 100644
index 0000000..afdd93c
--- /dev/null
+++ b/tests/functional/u/use/use_symbolic_message_instead.py
@@ -0,0 +1,25 @@
+# pylint: disable=C0111,R0903,T1234 # [bad-option-value,use-symbolic-message-instead,use-symbolic-message-instead]
+# pylint: enable=C0111 # [use-symbolic-message-instead]
+
+def my_function(arg): # [missing-function-docstring]
+ return arg or True
+
+# pylint: disable=C0111 # [use-symbolic-message-instead]
+# pylint: enable=R0903 # [use-symbolic-message-instead]
+# pylint: disable=R0903 # [use-symbolic-message-instead]
+
+
+def foo(): # pylint: disable=C0102 # [use-symbolic-message-instead]
+ return 1
+
+
+def toto(): # pylint: disable=C0102,R1711 # [use-symbolic-message-instead,use-symbolic-message-instead]
+ return
+
+
+def test_enabled_by_id_msg(): # pylint: enable=C0111 # [use-symbolic-message-instead,missing-function-docstring]
+ pass
+
+
+def baz(): # pylint: disable=blacklisted-name
+ return 1
diff --git a/tests/functional/u/use/use_symbolic_message_instead.txt b/tests/functional/u/use/use_symbolic_message_instead.txt
new file mode 100644
index 0000000..09861bf
--- /dev/null
+++ b/tests/functional/u/use/use_symbolic_message_instead.txt
@@ -0,0 +1,13 @@
+bad-option-value:1:0::Bad option value 'T1234'
+use-symbolic-message-instead:1:0::"'C0111' is cryptic: use '# pylint: disable=missing-docstring' instead"
+use-symbolic-message-instead:1:0::"'R0903' is cryptic: use '# pylint: disable=too-few-public-methods' instead"
+use-symbolic-message-instead:2:0::"'C0111' is cryptic: use '# pylint: enable=missing-docstring' instead"
+missing-function-docstring:4:0:my_function:Missing function or method docstring
+use-symbolic-message-instead:7:0::"'C0111' is cryptic: use '# pylint: disable=missing-docstring' instead"
+use-symbolic-message-instead:8:0::"'R0903' is cryptic: use '# pylint: enable=too-few-public-methods' instead"
+use-symbolic-message-instead:9:0::"'R0903' is cryptic: use '# pylint: disable=too-few-public-methods' instead"
+use-symbolic-message-instead:12:0::"'C0102' is cryptic: use '# pylint: disable=blacklisted-name' instead"
+use-symbolic-message-instead:16:0::"'C0102' is cryptic: use '# pylint: disable=blacklisted-name' instead"
+use-symbolic-message-instead:16:0::"'R1711' is cryptic: use '# pylint: disable=useless-return' instead"
+missing-function-docstring:20:0:test_enabled_by_id_msg:Missing function or method docstring
+use-symbolic-message-instead:20:0::"'C0111' is cryptic: use '# pylint: enable=missing-docstring' instead"
diff --git a/tests/functional/u/use/used_before_assignement.py b/tests/functional/u/use/used_before_assignement.py
new file mode 100644
index 0000000..c975b1d
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignement.py
@@ -0,0 +1,8 @@
+"""pylint doesn't see the NameError in this module"""
+
+__revision__ = None
+
+MSG = "hello %s" % MSG # [used-before-assignment]
+
+MSG2 = ("hello %s" %
+ MSG2) # [used-before-assignment]
diff --git a/tests/functional/u/use/used_before_assignement.txt b/tests/functional/u/use/used_before_assignement.txt
new file mode 100644
index 0000000..d19fe32
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignement.txt
@@ -0,0 +1,2 @@
+used-before-assignment:5:19::Using variable 'MSG' before assignment
+used-before-assignment:8:8::Using variable 'MSG2' before assignment
diff --git a/tests/functional/u/use/used_before_assignment_488.py b/tests/functional/u/use/used_before_assignment_488.py
new file mode 100644
index 0000000..efc133c
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_488.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring
+def func():
+ """Test that a variable defined in a finally clause does not trigger a false positive"""
+ try:
+ variable = 1
+ yield variable
+ finally:
+ variable = 2
+ yield variable
diff --git a/tests/functional/u/use/used_before_assignment_issue1081.py b/tests/functional/u/use/used_before_assignment_issue1081.py
new file mode 100644
index 0000000..0c59cce
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_issue1081.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods, useless-object-inheritance
+
+x = 24
+
+
+def used_before_assignment_1(a):
+ if x == a: # [used-before-assignment]
+ for x in [1, 2]: # [redefined-outer-name]
+ pass
+
+
+def used_before_assignment_2(a):
+ if x == a: # [used-before-assignment]
+ pass
+ x = 2 # [redefined-outer-name]
+
+
+def used_before_assignment_3(a):
+ if x == a: # [used-before-assignment]
+ if x > 3:
+ x = 2 # [redefined-outer-name]
+
+
+def not_used_before_assignment(a):
+ if x == a:
+ pass
+
+
+def not_used_before_assignment_2(a):
+ x = 3 # [redefined-outer-name]
+ if x == a:
+ pass
+
+
+def func(something):
+ return something ** 3
+
+
+class FalsePositive(object):
+ x = func(x)
diff --git a/tests/functional/u/use/used_before_assignment_issue1081.txt b/tests/functional/u/use/used_before_assignment_issue1081.txt
new file mode 100644
index 0000000..4d43c4a
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_issue1081.txt
@@ -0,0 +1,7 @@
+used-before-assignment:7:7:used_before_assignment_1:Using variable 'x' before assignment
+redefined-outer-name:8:12:used_before_assignment_1:Redefining name 'x' from outer scope (line 3)
+used-before-assignment:13:7:used_before_assignment_2:Using variable 'x' before assignment
+redefined-outer-name:15:4:used_before_assignment_2:Redefining name 'x' from outer scope (line 3)
+used-before-assignment:19:7:used_before_assignment_3:Using variable 'x' before assignment
+redefined-outer-name:21:12:used_before_assignment_3:Redefining name 'x' from outer scope (line 3)
+redefined-outer-name:30:4:not_used_before_assignment_2:Redefining name 'x' from outer scope (line 3)
diff --git a/tests/functional/u/use/used_before_assignment_issue853.py b/tests/functional/u/use/used_before_assignment_issue853.py
new file mode 100644
index 0000000..f8b4122
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_issue853.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,bare-except,pointless-statement,superfluous-parens
+def strangeproblem():
+ try:
+ for _ in range(0, 4):
+ message = object()
+ print(type(message))
+ finally:
+ message = object()
+
+
+try:
+ MY_INT = 1
+ print("MY_INT = %d" % MY_INT)
+finally:
+ MY_INT = 2
+
+try:
+ pass
+except:
+ FALSE_POSITIVE = 1
+ FALSE_POSITIVE # here pylint claims used-before-assignment
+finally:
+ FALSE_POSITIVE = 2 # this line is needed to reproduce the issue
diff --git a/tests/functional/u/use/used_before_assignment_nonlocal.py b/tests/functional/u/use/used_before_assignment_nonlocal.py
new file mode 100644
index 0000000..5cbdd51
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_nonlocal.py
@@ -0,0 +1,60 @@
+"""Check for nonlocal and used-before-assignment"""
+# pylint: disable=missing-docstring, unused-variable, no-init, too-few-public-methods
+
+__revision__ = 0
+
+def test_ok():
+ """ uses nonlocal """
+ cnt = 1
+ def wrap():
+ nonlocal cnt
+ cnt = cnt + 1
+ wrap()
+
+def test_fail():
+ """ doesn't use nonlocal """
+ cnt = 1
+ def wrap():
+ cnt = cnt + 1 # [used-before-assignment]
+ wrap()
+
+def test_fail2():
+ """ use nonlocal, but for other variable """
+ cnt = 1
+ count = 1
+ def wrap():
+ nonlocal count
+ cnt = cnt + 1 # [used-before-assignment]
+ wrap()
+
+def test_fail3(arg: test_fail4): # [used-before-assignment]
+ """ Depends on `test_fail4`, in argument annotation. """
+ return arg
+# +1: [used-before-assignment, used-before-assignment]
+def test_fail4(*args: test_fail5, **kwargs: undefined):
+ """ Depends on `test_fail5` and `undefined` in
+ variable and named arguments annotations.
+ """
+ return args, kwargs
+
+def test_fail5()->undefined1: # [used-before-assignment]
+ """ Depends on `undefined1` in function return annotation. """
+
+def undefined():
+ """ no op """
+
+def undefined1():
+ """ no op """
+
+
+def nonlocal_in_ifexp():
+ """bar"""
+ bug2 = True
+ def on_click(event):
+ """on_click"""
+ if event:
+ nonlocal bug2
+ bug2 = not bug2
+ on_click(True)
+
+nonlocal_in_ifexp()
diff --git a/tests/functional/u/use/used_before_assignment_nonlocal.rc b/tests/functional/u/use/used_before_assignment_nonlocal.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_nonlocal.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/u/use/used_before_assignment_nonlocal.txt b/tests/functional/u/use/used_before_assignment_nonlocal.txt
new file mode 100644
index 0000000..59aa075
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_nonlocal.txt
@@ -0,0 +1,6 @@
+used-before-assignment:18:14:test_fail.wrap:Using variable 'cnt' before assignment
+used-before-assignment:27:14:test_fail2.wrap:Using variable 'cnt' before assignment
+used-before-assignment:30:20:test_fail3:Using variable 'test_fail4' before assignment
+used-before-assignment:34:22:test_fail4:Using variable 'test_fail5' before assignment
+used-before-assignment:34:44:test_fail4:Using variable 'undefined' before assignment
+used-before-assignment:40:18:test_fail5:Using variable 'undefined1' before assignment
diff --git a/tests/functional/u/use/used_prior_global_declaration.py b/tests/functional/u/use/used_prior_global_declaration.py
new file mode 100644
index 0000000..0795010
--- /dev/null
+++ b/tests/functional/u/use/used_prior_global_declaration.py
@@ -0,0 +1,39 @@
+# pylint: disable=missing-docstring, pointless-statement, global-variable-not-assigned, global-statement
+
+
+CONST = 1
+
+
+def test():
+ CONST # [used-prior-global-declaration]
+
+ global CONST
+
+
+def other_test():
+ CONST
+
+ global SOMETHING
+
+
+def other_test_1():
+ global SOMETHING
+
+ CONST
+
+
+def other_test_2():
+ CONST
+
+ def inner():
+ global CONST
+
+ return inner
+
+
+def other_test_3():
+ def inner():
+ return CONST
+
+ global CONST
+ return inner
diff --git a/tests/functional/u/use/used_prior_global_declaration.rc b/tests/functional/u/use/used_prior_global_declaration.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/u/use/used_prior_global_declaration.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/u/use/used_prior_global_declaration.txt b/tests/functional/u/use/used_prior_global_declaration.txt
new file mode 100644
index 0000000..2354e0e
--- /dev/null
+++ b/tests/functional/u/use/used_prior_global_declaration.txt
@@ -0,0 +1 @@
+used-prior-global-declaration:8:4:test:Name 'CONST' is used prior to global declaration
diff --git a/tests/functional/u/use/using_constant_test.py b/tests/functional/u/use/using_constant_test.py
new file mode 100644
index 0000000..b3d0623
--- /dev/null
+++ b/tests/functional/u/use/using_constant_test.py
@@ -0,0 +1,150 @@
+"""Verify if constant tests are used inside if statements."""
+# pylint: disable=invalid-name, missing-docstring,too-few-public-methods
+# pylint: disable=no-init,expression-not-assigned, useless-object-inheritance
+# pylint: disable=missing-parentheses-for-call-in-test, unnecessary-comprehension, condition-evals-to-constant
+
+
+import collections
+
+
+def function():
+ yield
+
+
+class Class(object):
+
+ def method(self):
+ pass
+
+
+instance = Class()
+
+if collections: # [using-constant-test]
+ pass
+
+# GenExpr
+if (node for node in range(10)): # [using-constant-test]
+ pass
+
+if lambda: None: # [using-constant-test]
+ pass
+
+if function: # [using-constant-test]
+ pass
+
+if Class: # [using-constant-test]
+ pass
+
+if 2: # [using-constant-test]
+ pass
+
+if True: # [using-constant-test]
+ pass
+
+if '': # [using-constant-test]
+ pass
+
+if b'': # [using-constant-test]
+ pass
+
+if 2.0: # [using-constant-test]
+ pass
+
+if {}: # [using-constant-test]
+ pass
+
+if {1, 2, 3}: # [using-constant-test]
+ pass
+
+if (1, 2, 3): # [using-constant-test]
+ pass
+
+if (): # [using-constant-test]
+ pass
+
+if [1, 2, 3]: # [using-constant-test]
+ pass
+
+if []: # [using-constant-test]
+ pass
+
+# Generator
+generator = function()
+if generator: # [using-constant-test]
+ pass
+
+if 1 if 2 else 3: # [using-constant-test]
+ pass
+
+def test_comprehensions():
+ [data for data in range(100) if abs] # [using-constant-test]
+ [data for data in range(100) if 1] # [using-constant-test]
+ (data for data in range(100) if abs) # [using-constant-test]
+ (data for data in range(100) if 1) # [using-constant-test]
+ {data for data in range(100) if abs} # [using-constant-test]
+ {data: 1 for data in range(100) if abs} # [using-constant-test]
+
+
+# UnboundMethod / Function
+if Class.method: # [using-constant-test]
+ pass
+
+# BoundMethod
+if instance.method: # [using-constant-test]
+ pass
+
+# For these, we require to do inference, even though the result can be a
+# constant value. For some of them, we could determine that the test
+# is constant, such as 2 + 3, but the components of the BinOp
+# can be anything else (2 + somefunccall).
+
+name = 42
+if name:
+ pass
+
+if 3 + 4:
+ pass
+
+if 3 and 4:
+ pass
+
+if not 3:
+ pass
+
+if instance.method():
+ pass
+
+# pylint: disable=misplaced-comparison-constant
+if 2 < 3:
+ pass
+
+if tuple((1, 2, 3)):
+ pass
+
+if dict():
+ pass
+
+if tuple():
+ pass
+
+if list():
+ pass
+
+if [1, 2, 3][:1]:
+ pass
+
+def test(*args):
+ if args:
+ return 42
+ return None
+
+def test_good_comprehension_checks():
+ [data for data in range(100)]
+ [data for data in range(100) if data]
+ [data for data in range(100) if abs(data)]
+ (data for data in range(100) if data)
+ (data for data in range(100) if abs(data))
+ {data for data in range(100) if data}
+ {data for data in range(100) if abs(data)}
+ {data: 1 for data in range(100) if data}
+ {data: 1 for data in range(100)}
diff --git a/tests/functional/u/use/using_constant_test.txt b/tests/functional/u/use/using_constant_test.txt
new file mode 100644
index 0000000..9d11227
--- /dev/null
+++ b/tests/functional/u/use/using_constant_test.txt
@@ -0,0 +1,26 @@
+using-constant-test:22:0::Using a conditional statement with a constant value
+using-constant-test:26:0::Using a conditional statement with a constant value
+using-constant-test:29:0::Using a conditional statement with a constant value
+using-constant-test:32:0::Using a conditional statement with a constant value
+using-constant-test:35:0::Using a conditional statement with a constant value
+using-constant-test:38:0::Using a conditional statement with a constant value
+using-constant-test:41:0::Using a conditional statement with a constant value
+using-constant-test:44:0::Using a conditional statement with a constant value
+using-constant-test:47:0::Using a conditional statement with a constant value
+using-constant-test:50:0::Using a conditional statement with a constant value
+using-constant-test:53:0::Using a conditional statement with a constant value
+using-constant-test:56:0::Using a conditional statement with a constant value
+using-constant-test:59:0::Using a conditional statement with a constant value
+using-constant-test:62:0::Using a conditional statement with a constant value
+using-constant-test:65:0::Using a conditional statement with a constant value
+using-constant-test:68:0::Using a conditional statement with a constant value
+using-constant-test:73:0::Using a conditional statement with a constant value
+using-constant-test:76:3::Using a conditional statement with a constant value
+using-constant-test:80:0:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:81:0:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:82:0:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:83:0:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:84:0:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:85:0:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:89:0::Using a conditional statement with a constant value
+using-constant-test:93:0::Using a conditional statement with a constant value
diff --git a/tests/functional/u/useless/useless_else_on_loop.py b/tests/functional/u/useless/useless_else_on_loop.py
new file mode 100644
index 0000000..d686f46
--- /dev/null
+++ b/tests/functional/u/useless/useless_else_on_loop.py
@@ -0,0 +1,103 @@
+"""Check for else branches on loops with break and return only."""
+from __future__ import print_function
+__revision__ = 0
+
+def test_return_for():
+ """else + return is not accetable."""
+ for i in range(10):
+ if i % 2:
+ return i
+ else: # [useless-else-on-loop]
+ print('math is broken')
+ return None
+
+def test_return_while():
+ """else + return is not accetable."""
+ while True:
+ return 1
+ else: # [useless-else-on-loop]
+ print('math is broken')
+ return None
+
+
+while True:
+ def short_fun():
+ """A function with a loop."""
+ for _ in range(10):
+ break
+else: # [useless-else-on-loop]
+ print('or else!')
+
+
+while True:
+ while False:
+ break
+else: # [useless-else-on-loop]
+ print('or else!')
+
+for j in range(10):
+ pass
+else: # [useless-else-on-loop]
+ print('fat chance')
+ for j in range(10):
+ break
+
+
+def test_return_for2():
+ """no false positive for break in else
+
+ https://bitbucket.org/logilab/pylint/issue/117/useless-else-on-loop-false-positives
+ """
+ for i in range(10):
+ for _ in range(i):
+ if i % 2:
+ break
+ else:
+ break
+ else:
+ print('great math')
+
+
+def test_break_in_orelse_deep():
+ """no false positive for break in else deeply nested
+ """
+ for _ in range(10):
+ if 1 < 2:
+ for _ in range(3):
+ if 3 < 2:
+ break
+ else:
+ break
+ else:
+ return True
+ return False
+
+
+def test_break_in_orelse_deep2():
+ """should rise a useless-else-on-loop message, as the break statement is only
+ for the inner for loop
+ """
+ for _ in range(10):
+ if 1 < 2:
+ for _ in range(3):
+ if 3 < 2:
+ break
+ else:
+ print("all right")
+ else: # [useless-else-on-loop]
+ return True
+ return False
+
+
+def test_break_in_orelse_deep3():
+ """no false positive for break deeply nested in else
+ """
+ for _ in range(10):
+ for _ in range(3):
+ pass
+ else:
+ if 1 < 2:
+ break
+ else:
+ return True
+ return False
diff --git a/tests/functional/u/useless/useless_else_on_loop.txt b/tests/functional/u/useless/useless_else_on_loop.txt
new file mode 100644
index 0000000..dff8e31
--- /dev/null
+++ b/tests/functional/u/useless/useless_else_on_loop.txt
@@ -0,0 +1,6 @@
+useless-else-on-loop:10:4:test_return_for:Else clause on loop without a break statement
+useless-else-on-loop:18:4:test_return_while:Else clause on loop without a break statement
+useless-else-on-loop:28:0::Else clause on loop without a break statement
+useless-else-on-loop:35:0::Else clause on loop without a break statement
+useless-else-on-loop:40:0::Else clause on loop without a break statement
+useless-else-on-loop:87:4:test_break_in_orelse_deep2:Else clause on loop without a break statement
diff --git a/tests/functional/u/useless/useless_object_inheritance.py b/tests/functional/u/useless/useless_object_inheritance.py
new file mode 100644
index 0000000..562c81f
--- /dev/null
+++ b/tests/functional/u/useless/useless_object_inheritance.py
@@ -0,0 +1,27 @@
+"""Check if a class inherits from object.
+In python3 every class implicitly inherits from object, therefore give refactoring message to
+ remove object from bases"""
+# pylint: disable=no-init, invalid-name, missing-docstring, too-few-public-methods
+# pylint: disable=inconsistent-mro
+import abc
+
+class A(object): # [useless-object-inheritance]
+ pass
+
+class B:
+ pass
+
+class C(B, object): # [useless-object-inheritance]
+ pass
+
+class D(object, C, metaclass=abc.ABCMeta): # [useless-object-inheritance]
+ pass
+
+class E(D, C, object, metaclass=abc.ABCMeta): # [useless-object-inheritance]
+ pass
+
+class F(A): # positive test case
+ pass
+
+class G(B): # positive test case
+ pass
diff --git a/tests/functional/u/useless/useless_object_inheritance.txt b/tests/functional/u/useless/useless_object_inheritance.txt
new file mode 100644
index 0000000..1b18607
--- /dev/null
+++ b/tests/functional/u/useless/useless_object_inheritance.txt
@@ -0,0 +1,4 @@
+useless-object-inheritance:8:0:A:Class 'A' inherits from object, can be safely removed from bases in python3
+useless-object-inheritance:14:0:C:Class 'C' inherits from object, can be safely removed from bases in python3
+useless-object-inheritance:17:0:D:Class 'D' inherits from object, can be safely removed from bases in python3
+useless-object-inheritance:20:0:E:Class 'E' inherits from object, can be safely removed from bases in python3
diff --git a/tests/functional/u/useless/useless_return.py b/tests/functional/u/useless/useless_return.py
new file mode 100644
index 0000000..61aaebe
--- /dev/null
+++ b/tests/functional/u/useless/useless_return.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-self-use,bad-option-value, useless-object-inheritance
+from __future__ import print_function
+
+def myfunc(): # [useless-return]
+ print('---- testing ---')
+ return
+
+class SomeClass(object):
+ def mymethod(self): # [useless-return]
+ print('---- testing ---')
+ return None
+
+ # These are not emitted
+ def item_at(self):
+ return None
diff --git a/tests/functional/u/useless/useless_return.txt b/tests/functional/u/useless/useless_return.txt
new file mode 100644
index 0000000..9299b45
--- /dev/null
+++ b/tests/functional/u/useless/useless_return.txt
@@ -0,0 +1,2 @@
+useless-return:4:0:myfunc:Useless return at end of function or method
+useless-return:9:4:SomeClass.mymethod:Useless return at end of function or method
diff --git a/tests/functional/u/useless/useless_super_delegation.py b/tests/functional/u/useless/useless_super_delegation.py
new file mode 100644
index 0000000..002c7eb
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation.py
@@ -0,0 +1,262 @@
+# pylint: disable=missing-docstring, no-member, no-self-use, bad-super-call
+# pylint: disable=too-few-public-methods, unused-argument, invalid-name, too-many-public-methods
+# pylint: disable=line-too-long, useless-object-inheritance, arguments-out-of-order
+# pylint: disable=super-with-arguments, dangerous-default-value
+
+def not_a_method(param, param2):
+ return super(None, None).not_a_method(param, param2)
+
+
+class SuperBase(object):
+ def with_default_arg(self, first, default_arg="only_in_super_base"):
+ pass
+
+ def with_default_arg_bis(self, first, default_arg="only_in_super_base"):
+ pass
+
+ def with_default_arg_ter(self, first, default_arg="will_be_changed"):
+ pass
+
+ def with_default_arg_quad(self, first, default_arg="will_be_changed"):
+ pass
+
+
+class Base(SuperBase):
+
+ fake_method = not_a_method
+
+ def something(self):
+ pass
+
+ def with_default_argument(self, first, default_arg="default"):
+ pass
+
+ def with_default_argument_bis(self, first, default_arg="default"):
+ pass
+
+ def without_default_argument(self, first, second):
+ pass
+
+ def with_default_argument_none(self, first, default_arg=None):
+ pass
+
+ def without_default_argument2(self, first, second):
+ pass
+
+ def with_default_argument_int(self, first, default_arg=42):
+ pass
+
+ def with_default_argument_tuple(self, first, default_arg=()):
+ pass
+
+ def with_default_argument_dict(self, first, default_arg={}):
+ pass
+
+ def with_default_arg_ter(self, first, default_arg="has_been_changed"):
+ super().with_default_arg_ter(first, default_arg)
+
+ def with_default_arg_quad(self, first, default_arg="has_been_changed"):
+ super().with_default_arg_quad(first, default_arg)
+
+class NotUselessSuper(Base):
+
+ def multiple_statements(self):
+ first = 42 * 24
+ return super().multiple_statements() + first
+
+ def not_a_call(self):
+ return 1 + 2
+
+ def not_super_call(self):
+ return type(self).__class__
+
+ def not_super_attribute_access(self):
+ return super()
+
+ def invalid_super_call(self):
+ return super(NotUselessSuper, 1).invalid_super_call()
+
+ def other_invalid_super_call(self):
+ return super(2, 3, 4, 5).other_invalid_super_call()
+
+ def different_name(self):
+ return super().something()
+
+ def different_super_mro_pointer(self):
+ return super(Base, self).different_super_mro_pointer()
+
+ def different_super_type(self):
+ return super(NotUselessSuper, NotUselessSuper).different_super_type()
+
+ def other_different_super_type(self):
+ return super(NotUselessSuper, 1).other_different_super_type()
+
+ def not_passing_param(self, first):
+ return super(NotUselessSuper, self).not_passing_param()
+
+ def modifying_param(self, first):
+ return super(NotUselessSuper, self).modifying_param(first + 1)
+
+ def transforming_param(self, first):
+ return super(NotUselessSuper, self).transforming_param(type(first))
+
+ def modifying_variadic(self, *args):
+ return super(NotUselessSuper, self).modifying_variadic(tuple(args))
+
+ def not_passing_keyword_variadics(self, *args, **kwargs):
+ return super(NotUselessSuper, self).not_passing_keyword_variadics(*args)
+
+ def not_passing_default(self, first, second=None):
+ return super(NotUselessSuper, self).not_passing_default(first)
+
+ def passing_only_a_handful(self, first, second, third, fourth):
+ return super(NotUselessSuper, self).passing_only_a_handful(
+ first, second)
+
+ def not_the_same_order(self, first, second, third):
+ return super(NotUselessSuper, self).not_the_same_order(third, first, second)
+
+ def no_kwargs_in_signature(self, key=None):
+ values = {'key': 'something'}
+ return super(NotUselessSuper, self).no_kwargs_in_signature(**values)
+
+ def no_args_in_signature(self, first, second):
+ values = (first + 1, second + 2)
+ return super(NotUselessSuper, self).no_args_in_signature(*values)
+
+ def variadics_with_multiple_keyword_arguments(self, **kwargs):
+ return super(NotUselessSuper, self).variadics_with_multiple_keyword_arguments(
+ first=None,
+ second=None,
+ **kwargs)
+
+ def extraneous_keyword_params(self, none_ok=False):
+ super(NotUselessSuper, self).extraneous_keyword_params(
+ none_ok,
+ valid_values=[23, 42])
+
+ def extraneous_positional_args(self, **args):
+ super(NotUselessSuper, self).extraneous_positional_args(
+ 1, 2, **args)
+
+ def with_default_argument(self, first, default_arg="other"):
+ # Not useless because the default_arg is different from the one in the base class
+ super(NotUselessSuper, self).with_default_argument(first, default_arg)
+
+ def without_default_argument(self, first, second=True):
+ # Not useless because in the base class there is not default value for second argument
+ super(NotUselessSuper, self).without_default_argument(first, second)
+
+ def with_default_argument_none(self, first, default_arg='NotNone'):
+ # Not useless because the default_arg is different from the one in the base class
+ super(NotUselessSuper, self).with_default_argument_none(first, default_arg)
+
+ def without_default_argument2(self, first, second=None):
+ # Not useless because in the base class there is not default value for second argument
+ super(NotUselessSuper, self).without_default_argument2(first, second)
+
+ def with_default_argument_int(self, first, default_arg="42"):
+ # Not useless because the default_arg is a string whereas in the base class it's an int
+ super(NotUselessSuper, self).with_default_argument_int(first, default_arg)
+
+ def with_default_argument_tuple(self, first, default_arg=("42", "a")):
+ # Not useless because the default_arg is different from the one in the base class
+ super(NotUselessSuper, self).with_default_argument_tuple(first, default_arg)
+
+ def with_default_argument_dict(self, first, default_arg={'foo': 'bar'}):
+ # Not useless because the default_arg is different from the one in the base class
+ super(NotUselessSuper, self).with_default_argument_dict(first, default_arg)
+
+ def with_default_argument_bis(self, first, default_arg="default"):
+ # Although the default_arg is the same as in the base class, the call signature
+ # differs. Thus it is not useless.
+ super(NotUselessSuper, self).with_default_argument_bis(default_arg + "_argument")
+
+ def fake_method(self, param2="other"):
+ super(NotUselessSuper, self).fake_method(param2)
+
+ def with_default_arg(self, first, default_arg="only_in_super_base"):
+ # Not useless because the call of this method is different from the function signature
+ super(NotUselessSuper, self).with_default_arg(first, default_arg + "_and_here")
+
+ def with_default_arg_bis(self, first, default_arg="default_changed"):
+ # Not useless because the default value is different from the SuperBase one
+ super(NotUselessSuper, self).with_default_arg_bis(first, default_arg)
+
+ def with_default_arg_ter(self, first, default_arg="has_been_changed_again"):
+ # Not useless because the default value is different from the Base one
+ super(NotUselessSuper, self).with_default_arg_ter(first, default_arg)
+
+ def with_default_arg_quad(self, first, default_arg="has_been_changed"):
+ # Not useless because the default value is the same as in the base but the
+ # call is different from the signature
+ super(NotUselessSuper, self).with_default_arg_quad(first, default_arg + "_and_modified")
+
+
+class UselessSuper(Base):
+
+ def equivalent_params(self): # [useless-super-delegation]
+ return super(UselessSuper, self).equivalent_params()
+
+ def equivalent_params_1(self, first): # [useless-super-delegation]
+ return super(UselessSuper, self).equivalent_params_1(first)
+
+ def equivalent_params_2(self, *args): # [useless-super-delegation]
+ return super(UselessSuper, self).equivalent_params_2(*args)
+
+ def equivalent_params_3(self, *args, **kwargs): # [useless-super-delegation]
+ return super(UselessSuper, self).equivalent_params_3(*args, **kwargs)
+
+ def equivalent_params_4(self, first): # [useless-super-delegation]
+ super(UselessSuper, self).equivalent_params_4(first)
+
+ def equivalent_params_5(self, first, *args): # [useless-super-delegation]
+ super(UselessSuper, self).equivalent_params_5(first, *args)
+
+ def equivalent_params_6(self, first, *args, **kwargs): # [useless-super-delegation]
+ return super(UselessSuper, self).equivalent_params_6(first, *args, **kwargs)
+
+ def with_default_argument(self, first, default_arg="default"): # [useless-super-delegation]
+ # useless because the default value here is the same as in the base class
+ return super(UselessSuper, self).with_default_argument(first, default_arg)
+
+ def without_default_argument(self, first, second): # [useless-super-delegation]
+ return super(UselessSuper, self).without_default_argument(first, second)
+
+ def with_default_argument_none(self, first, default_arg=None): # [useless-super-delegation]
+ # useless because the default value here is the same as in the base class
+ super(UselessSuper, self).with_default_argument_none(first, default_arg)
+
+ def with_default_argument_int(self, first, default_arg=42): # [useless-super-delegation]
+ super(UselessSuper, self).with_default_argument_int(first, default_arg)
+
+ def with_default_argument_tuple(self, first, default_arg=()): # [useless-super-delegation]
+ super(UselessSuper, self).with_default_argument_tuple(first, default_arg)
+
+ def with_default_argument_dict(self, first, default_arg={}): # [useless-super-delegation]
+ super(UselessSuper, self).with_default_argument_dict(first, default_arg)
+
+ def __init__(self): # [useless-super-delegation]
+ super(UselessSuper, self).__init__()
+
+ def with_default_arg(self, first, default_arg="only_in_super_base"): # [useless-super-delegation]
+ super(UselessSuper, self).with_default_arg(first, default_arg)
+
+ def with_default_arg_bis(self, first, default_arg="only_in_super_base"): # [useless-super-delegation]
+ super(UselessSuper, self).with_default_arg_bis(first, default_arg)
+
+ def with_default_arg_ter(self, first, default_arg="has_been_changed"): # [useless-super-delegation]
+ super(UselessSuper, self).with_default_arg_ter(first, default_arg)
+
+ def with_default_arg_quad(self, first, default_arg="has_been_changed"): # [useless-super-delegation]
+ super(UselessSuper, self).with_default_arg_quad(first, default_arg)
+
+
+def trigger_something(value_to_trigger):
+ pass
+
+
+class NotUselessSuperDecorators(Base):
+ @trigger_something('value1')
+ def method_decorated(self):
+ super(NotUselessSuperDecorators, self).method_decorated()
diff --git a/tests/functional/u/useless/useless_super_delegation.txt b/tests/functional/u/useless/useless_super_delegation.txt
new file mode 100644
index 0000000..d2dae56
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation.txt
@@ -0,0 +1,18 @@
+useless-super-delegation:198:4:UselessSuper.equivalent_params:Useless super delegation in method 'equivalent_params'
+useless-super-delegation:201:4:UselessSuper.equivalent_params_1:Useless super delegation in method 'equivalent_params_1'
+useless-super-delegation:204:4:UselessSuper.equivalent_params_2:Useless super delegation in method 'equivalent_params_2'
+useless-super-delegation:207:4:UselessSuper.equivalent_params_3:Useless super delegation in method 'equivalent_params_3'
+useless-super-delegation:210:4:UselessSuper.equivalent_params_4:Useless super delegation in method 'equivalent_params_4'
+useless-super-delegation:213:4:UselessSuper.equivalent_params_5:Useless super delegation in method 'equivalent_params_5'
+useless-super-delegation:216:4:UselessSuper.equivalent_params_6:Useless super delegation in method 'equivalent_params_6'
+useless-super-delegation:219:4:UselessSuper.with_default_argument:Useless super delegation in method 'with_default_argument'
+useless-super-delegation:223:4:UselessSuper.without_default_argument:Useless super delegation in method 'without_default_argument'
+useless-super-delegation:226:4:UselessSuper.with_default_argument_none:Useless super delegation in method 'with_default_argument_none'
+useless-super-delegation:230:4:UselessSuper.with_default_argument_int:Useless super delegation in method 'with_default_argument_int'
+useless-super-delegation:233:4:UselessSuper.with_default_argument_tuple:Useless super delegation in method 'with_default_argument_tuple'
+useless-super-delegation:236:4:UselessSuper.with_default_argument_dict:Useless super delegation in method 'with_default_argument_dict'
+useless-super-delegation:239:4:UselessSuper.__init__:Useless super delegation in method '__init__'
+useless-super-delegation:242:4:UselessSuper.with_default_arg:Useless super delegation in method 'with_default_arg'
+useless-super-delegation:245:4:UselessSuper.with_default_arg_bis:Useless super delegation in method 'with_default_arg_bis'
+useless-super-delegation:248:4:UselessSuper.with_default_arg_ter:Useless super delegation in method 'with_default_arg_ter'
+useless-super-delegation:251:4:UselessSuper.with_default_arg_quad:Useless super delegation in method 'with_default_arg_quad'
diff --git a/tests/functional/u/useless/useless_super_delegation_py3.py b/tests/functional/u/useless/useless_super_delegation_py3.py
new file mode 100644
index 0000000..b32ced8
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py3.py
@@ -0,0 +1,43 @@
+# pylint: disable=missing-docstring, no-member, unused-argument, invalid-name,unused-variable
+# pylint: disable=too-few-public-methods,wrong-import-position, useless-object-inheritance
+
+class NotUselessSuper(object):
+
+ def not_passing_keyword_only(self, first, *, second):
+ return super().not_passing_keyword_only(first)
+
+ def passing_keyword_only_with_modifications(self, first, *, second):
+ return super().passing_keyword_only_with_modifications(
+ first, second + 1)
+
+
+class AlsoNotUselessSuper(NotUselessSuper):
+ def not_passing_keyword_only(self, first, *, second="second"):
+ return super().not_passing_keyword_only(first, second=second)
+
+
+class UselessSuper(object):
+
+ def useless(self, *, first): # [useless-super-delegation]
+ super().useless(first=first)
+
+
+class Egg():
+ def __init__(self, thing: object) -> None:
+ pass
+
+class Spam(Egg):
+ def __init__(self, thing: int) -> None:
+ super().__init__(thing)
+
+class Ham(Egg):
+ def __init__(self, thing: object) -> None: # [useless-super-delegation]
+ super().__init__(thing)
+
+
+from typing import List
+
+
+class Test:
+ def __init__(self, _arg: List[int]) -> None:
+ super().__init__()
diff --git a/tests/functional/u/useless/useless_super_delegation_py3.rc b/tests/functional/u/useless/useless_super_delegation_py3.rc
new file mode 100644
index 0000000..c093be2
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/u/useless/useless_super_delegation_py3.txt b/tests/functional/u/useless/useless_super_delegation_py3.txt
new file mode 100644
index 0000000..3a1fdaa
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py3.txt
@@ -0,0 +1,2 @@
+useless-super-delegation:21:4:UselessSuper.useless:Useless super delegation in method 'useless'
+useless-super-delegation:34:4:Ham.__init__:Useless super delegation in method '__init__'
diff --git a/tests/functional/u/useless/useless_super_delegation_py35.py b/tests/functional/u/useless/useless_super_delegation_py35.py
new file mode 100644
index 0000000..16030f8
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py35.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-member,unused-argument, useless-object-inheritance
+
+class NotUselessSuper(object):
+
+ def not_passing_all_params(self, first, *args, second=None, **kwargs):
+ return super().not_passing_all_params(*args, second, **kwargs)
+
+
+class UselessSuper(object):
+
+ def useless(self, first, *, second=None, **kwargs): # [useless-super-delegation]
+ return super().useless(first, second=second, **kwargs)
diff --git a/tests/functional/u/useless/useless_super_delegation_py35.rc b/tests/functional/u/useless/useless_super_delegation_py35.rc
new file mode 100644
index 0000000..71de8b6
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py35.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/u/useless/useless_super_delegation_py35.txt b/tests/functional/u/useless/useless_super_delegation_py35.txt
new file mode 100644
index 0000000..672ce19
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py35.txt
@@ -0,0 +1 @@
+useless-super-delegation:11:4:UselessSuper.useless:Useless super delegation in method 'useless'
diff --git a/tests/functional/u/useless/useless_super_delegation_py38.py b/tests/functional/u/useless/useless_super_delegation_py38.py
new file mode 100644
index 0000000..ec40229
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py38.py
@@ -0,0 +1,17 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+from typing import Any
+
+
+class Egg:
+ def __init__(self, first: Any, /, second: Any) -> None:
+ pass
+
+
+class Spam(Egg):
+ def __init__(self, first: float, /, second: float) -> None:
+ super().__init__(first, second)
+
+
+class Ham(Egg):
+ def __init__(self, first: Any, /, second: Any) -> None: # [useless-super-delegation]
+ super().__init__(first, second)
diff --git a/tests/functional/u/useless/useless_super_delegation_py38.rc b/tests/functional/u/useless/useless_super_delegation_py38.rc
new file mode 100644
index 0000000..85fc502
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py38.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/u/useless/useless_super_delegation_py38.txt b/tests/functional/u/useless/useless_super_delegation_py38.txt
new file mode 100644
index 0000000..3334445
--- /dev/null
+++ b/tests/functional/u/useless/useless_super_delegation_py38.txt
@@ -0,0 +1 @@
+useless-super-delegation:16:4:Ham.__init__:Useless super delegation in method '__init__'
diff --git a/tests/functional/w/__init__.py b/tests/functional/w/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/w/__init__.py
diff --git a/tests/functional/w/wildcard_import.py b/tests/functional/w/wildcard_import.py
new file mode 100644
index 0000000..66ae63d
--- /dev/null
+++ b/tests/functional/w/wildcard_import.py
@@ -0,0 +1,5 @@
+# pylint: disable=no-absolute-import,missing-docstring,import-error,unused-wildcard-import
+from indirect1 import * # [wildcard-import]
+# This is an unresolved import which still generates the wildcard-import
+# warning.
+from unknown.package import * # [wildcard-import]
diff --git a/tests/functional/w/wildcard_import.txt b/tests/functional/w/wildcard_import.txt
new file mode 100644
index 0000000..67721a6
--- /dev/null
+++ b/tests/functional/w/wildcard_import.txt
@@ -0,0 +1,2 @@
+wildcard-import:2:0::Wildcard import indirect1
+wildcard-import:5:0::Wildcard import unknown.package
diff --git a/tests/functional/w/wildcard_import_allowed.py b/tests/functional/w/wildcard_import_allowed.py
new file mode 100644
index 0000000..21fea47
--- /dev/null
+++ b/tests/functional/w/wildcard_import_allowed.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring,unused-wildcard-import,redefined-builtin,import-error
+from csv import *
+from abc import * # [wildcard-import]
+from UNINFERABLE import * # [wildcard-import]
diff --git a/tests/functional/w/wildcard_import_allowed.rc b/tests/functional/w/wildcard_import_allowed.rc
new file mode 100644
index 0000000..c46d828
--- /dev/null
+++ b/tests/functional/w/wildcard_import_allowed.rc
@@ -0,0 +1,2 @@
+[IMPORTS]
+allow-wildcard-with-all=yes
diff --git a/tests/functional/w/wildcard_import_allowed.txt b/tests/functional/w/wildcard_import_allowed.txt
new file mode 100644
index 0000000..6413af2
--- /dev/null
+++ b/tests/functional/w/wildcard_import_allowed.txt
@@ -0,0 +1,2 @@
+wildcard-import:3:0::Wildcard import abc
+wildcard-import:4:0::Wildcard import UNINFERABLE
diff --git a/tests/functional/w/with_used_before_assign.py b/tests/functional/w/with_used_before_assign.py
new file mode 100644
index 0000000..64a475a
--- /dev/null
+++ b/tests/functional/w/with_used_before_assign.py
@@ -0,0 +1,11 @@
+'''
+Regression test for
+https://bitbucket.org/logilab/pylint/issue/128/attributeerror-when-parsing
+'''
+from __future__ import with_statement
+
+def do_nothing():
+ """ empty """
+ with open("") as ctx.obj: # [undefined-variable]
+ context.do() # [used-before-assignment]
+ context = None
diff --git a/tests/functional/w/with_used_before_assign.txt b/tests/functional/w/with_used_before_assign.txt
new file mode 100644
index 0000000..4a98cec
--- /dev/null
+++ b/tests/functional/w/with_used_before_assign.txt
@@ -0,0 +1,2 @@
+undefined-variable:9:21:do_nothing:Undefined variable 'ctx'
+used-before-assignment:10:8:do_nothing:Using variable 'context' before assignment
diff --git a/tests/functional/w/with_using_generator.py b/tests/functional/w/with_using_generator.py
new file mode 100644
index 0000000..187bdcf
--- /dev/null
+++ b/tests/functional/w/with_using_generator.py
@@ -0,0 +1,15 @@
+""" Testing with statements that use generators. This should not crash. """
+# pylint: disable=useless-object-inheritance
+
+class Base(object):
+ """ Base class. """
+ val = 0
+
+ def gen(self):
+ """ A generator. """
+ yield self.val
+
+ def fun(self):
+ """ With statement using a generator. """
+ with self.gen(): # [not-context-manager]
+ pass
diff --git a/tests/functional/w/with_using_generator.txt b/tests/functional/w/with_using_generator.txt
new file mode 100644
index 0000000..6bd65fb
--- /dev/null
+++ b/tests/functional/w/with_using_generator.txt
@@ -0,0 +1 @@
+not-context-manager:14:8:Base.fun:Context manager 'generator' doesn't implement __enter__ and __exit__.
diff --git a/tests/functional/w/wrong_exception_operation.py b/tests/functional/w/wrong_exception_operation.py
new file mode 100644
index 0000000..1c3c4e3
--- /dev/null
+++ b/tests/functional/w/wrong_exception_operation.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring, superfluous-parens
+
+
+try:
+ 1/0
+except (ValueError | TypeError): # [wrong-exception-operation]
+ pass
+
+try:
+ 1/0
+except (ValueError + TypeError): # [wrong-exception-operation]
+ pass
+
+
+try:
+ 1/0
+except (ValueError < TypeError): # [wrong-exception-operation]
+ pass
diff --git a/tests/functional/w/wrong_exception_operation.txt b/tests/functional/w/wrong_exception_operation.txt
new file mode 100644
index 0000000..05624a3
--- /dev/null
+++ b/tests/functional/w/wrong_exception_operation.txt
@@ -0,0 +1,3 @@
+wrong-exception-operation:6:8::Invalid exception operation. Did you mean '(ValueError, TypeError)' instead?
+wrong-exception-operation:11:8::Invalid exception operation. Did you mean '(ValueError, TypeError)' instead?
+wrong-exception-operation:17:8::Invalid exception operation. Did you mean '(ValueError, TypeError)' instead?
diff --git a/tests/functional/w/wrong_import_order.py b/tests/functional/w/wrong_import_order.py
new file mode 100644
index 0000000..ed0615b
--- /dev/null
+++ b/tests/functional/w/wrong_import_order.py
@@ -0,0 +1,43 @@
+"""Checks import order rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+from __future__ import absolute_import
+try:
+ from six.moves import configparser
+except ImportError:
+ import configparser
+
+import logging
+
+import six
+import os.path # [wrong-import-order]
+from astroid import are_exclusive
+import sys # [wrong-import-order]
+import datetime # [wrong-import-order]
+import unused_import
+from .package import Class
+import totally_missing # [wrong-import-order]
+from . import package
+import astroid # [wrong-import-order]
+from . import package2
+from .package2 import Class2
+from ..package3 import Class3
+from six.moves.urllib.parse import quote # [wrong-import-order]
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+if LOGGER:
+ # imports nested skipped
+ from . import package4
+ import pprint
+ from pprint import PrettyPrinter
+
+
+try:
+ # imports nested skipped
+ from . import package4
+ import random
+ from random import division
+except ImportError:
+ LOGGER.info('A useful message here')
diff --git a/tests/functional/w/wrong_import_order.txt b/tests/functional/w/wrong_import_order.txt
new file mode 100644
index 0000000..e520ef2
--- /dev/null
+++ b/tests/functional/w/wrong_import_order.txt
@@ -0,0 +1,6 @@
+wrong-import-order:12:0::"standard import ""import os.path"" should be placed before ""import six"""
+wrong-import-order:14:0::"standard import ""import sys"" should be placed before ""import six"""
+wrong-import-order:15:0::"standard import ""import datetime"" should be placed before ""import six"""
+wrong-import-order:18:0::"third party import ""import totally_missing"" should be placed before ""from .package import Class"""
+wrong-import-order:20:0::"third party import ""import astroid"" should be placed before ""from .package import Class"""
+wrong-import-order:24:0::"third party import ""from six.moves.urllib.parse import quote"" should be placed before ""from .package import Class"""
diff --git a/tests/functional/w/wrong_import_order2.py b/tests/functional/w/wrong_import_order2.py
new file mode 100644
index 0000000..7157512
--- /dev/null
+++ b/tests/functional/w/wrong_import_order2.py
@@ -0,0 +1,16 @@
+"""Checks import order rule in a right case"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module
+
+
+# Standard imports
+import os
+from sys import argv
+
+# external imports
+import isort
+
+from six import moves
+
+# local_imports
+from . import my_package
+from .my_package import myClass
diff --git a/tests/functional/w/wrong_import_position.py b/tests/functional/w/wrong_import_position.py
new file mode 100644
index 0000000..c06f9da
--- /dev/null
+++ b/tests/functional/w/wrong_import_position.py
@@ -0,0 +1,33 @@
+"""Checks import order rule"""
+# pylint: disable=unused-import,ungrouped-imports,wrong-import-order
+# pylint: disable=import-error, too-few-public-methods, missing-docstring,using-constant-test, useless-object-inheritance
+import os.path
+
+if True:
+ from astroid import are_exclusive
+try:
+ import sys
+except ImportError:
+ class Myclass(object):
+ """docstring"""
+
+if sys.version_info[0] >= 3:
+ from collections import OrderedDict
+else:
+ class OrderedDict(object):
+ """Nothing to see here."""
+ def some_func(self):
+ pass
+
+import six # [wrong-import-position]
+
+CONSTANT = True
+
+import datetime # [wrong-import-position]
+
+VAR = 0
+for i in range(10):
+ VAR += i
+
+import scipy # [wrong-import-position]
+import astroid # [wrong-import-position]
diff --git a/tests/functional/w/wrong_import_position.txt b/tests/functional/w/wrong_import_position.txt
new file mode 100644
index 0000000..22c4267
--- /dev/null
+++ b/tests/functional/w/wrong_import_position.txt
@@ -0,0 +1,4 @@
+wrong-import-position:22:0::"Import ""import six"" should be placed at the top of the module"
+wrong-import-position:26:0::"Import ""import datetime"" should be placed at the top of the module"
+wrong-import-position:32:0::"Import ""import scipy"" should be placed at the top of the module"
+wrong-import-position:33:0::"Import ""import astroid"" should be placed at the top of the module"
diff --git a/tests/functional/w/wrong_import_position10.py b/tests/functional/w/wrong_import_position10.py
new file mode 100644
index 0000000..f4a8680
--- /dev/null
+++ b/tests/functional/w/wrong_import_position10.py
@@ -0,0 +1,15 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import
+import os
+
+try:
+ import ast
+except ImportError:
+ def method(items):
+ """docstring"""
+ value = 0
+ for item in items:
+ value += item
+ return value
+
+import sys
diff --git a/tests/functional/w/wrong_import_position11.py b/tests/functional/w/wrong_import_position11.py
new file mode 100644
index 0000000..9af72c0
--- /dev/null
+++ b/tests/functional/w/wrong_import_position11.py
@@ -0,0 +1,4 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,pointless-string-statement
+A = 1
+import os # [wrong-import-position]
diff --git a/tests/functional/w/wrong_import_position11.txt b/tests/functional/w/wrong_import_position11.txt
new file mode 100644
index 0000000..a08aaa9
--- /dev/null
+++ b/tests/functional/w/wrong_import_position11.txt
@@ -0,0 +1 @@
+wrong-import-position:4:0::"Import ""import os"" should be placed at the top of the module"
diff --git a/tests/functional/w/wrong_import_position12.py b/tests/functional/w/wrong_import_position12.py
new file mode 100644
index 0000000..300968c
--- /dev/null
+++ b/tests/functional/w/wrong_import_position12.py
@@ -0,0 +1,5 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,pointless-string-statement
+"Two string"
+
+import os # [wrong-import-position]
diff --git a/tests/functional/w/wrong_import_position12.txt b/tests/functional/w/wrong_import_position12.txt
new file mode 100644
index 0000000..ca655ff
--- /dev/null
+++ b/tests/functional/w/wrong_import_position12.txt
@@ -0,0 +1 @@
+wrong-import-position:5:0::"Import ""import os"" should be placed at the top of the module"
diff --git a/tests/functional/w/wrong_import_position13.py b/tests/functional/w/wrong_import_position13.py
new file mode 100644
index 0000000..6b3d034
--- /dev/null
+++ b/tests/functional/w/wrong_import_position13.py
@@ -0,0 +1,4 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,no-name-in-module
+A = 1
+from sys import x # [wrong-import-position]
diff --git a/tests/functional/w/wrong_import_position13.txt b/tests/functional/w/wrong_import_position13.txt
new file mode 100644
index 0000000..5010d9d
--- /dev/null
+++ b/tests/functional/w/wrong_import_position13.txt
@@ -0,0 +1 @@
+wrong-import-position:4:0::"Import ""from sys import x"" should be placed at the top of the module"
diff --git a/tests/functional/w/wrong_import_position14.py b/tests/functional/w/wrong_import_position14.py
new file mode 100644
index 0000000..f5c9a03
--- /dev/null
+++ b/tests/functional/w/wrong_import_position14.py
@@ -0,0 +1,5 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,undefined-variable,import-error
+if x:
+ import os
+import y # [wrong-import-position]
diff --git a/tests/functional/w/wrong_import_position14.txt b/tests/functional/w/wrong_import_position14.txt
new file mode 100644
index 0000000..22e09e2
--- /dev/null
+++ b/tests/functional/w/wrong_import_position14.txt
@@ -0,0 +1 @@
+wrong-import-position:5:0::"Import ""import y"" should be placed at the top of the module"
diff --git a/tests/functional/w/wrong_import_position15.py b/tests/functional/w/wrong_import_position15.py
new file mode 100644
index 0000000..58a19b6
--- /dev/null
+++ b/tests/functional/w/wrong_import_position15.py
@@ -0,0 +1,9 @@
+"""Checks import position rule with pep-0008"""
+# pylint: disable=unused-import
+
+__author__ = 'some author'
+__email__ = 'some.author@some_email'
+__copyright__ = 'Some copyright'
+
+
+import sys
diff --git a/tests/functional/w/wrong_import_position2.py b/tests/functional/w/wrong_import_position2.py
new file mode 100644
index 0000000..d7441b4
--- /dev/null
+++ b/tests/functional/w/wrong_import_position2.py
@@ -0,0 +1,10 @@
+"""Checks import order rule with nested non_import sentence"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+try:
+ from sys import argv
+except ImportError:
+ pass
+else:
+ pass
+
+import os
diff --git a/tests/functional/w/wrong_import_position3.py b/tests/functional/w/wrong_import_position3.py
new file mode 100644
index 0000000..a1808a8
--- /dev/null
+++ b/tests/functional/w/wrong_import_position3.py
@@ -0,0 +1,3 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+import os
diff --git a/tests/functional/w/wrong_import_position4.py b/tests/functional/w/wrong_import_position4.py
new file mode 100644
index 0000000..96f39ce
--- /dev/null
+++ b/tests/functional/w/wrong_import_position4.py
@@ -0,0 +1,5 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level,unused-variable,import-outside-toplevel
+def method1():
+ """Method 1"""
+ import x
diff --git a/tests/functional/w/wrong_import_position5.py b/tests/functional/w/wrong_import_position5.py
new file mode 100644
index 0000000..ff9c28c
--- /dev/null
+++ b/tests/functional/w/wrong_import_position5.py
@@ -0,0 +1,4 @@
+r"""Checks import position rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+
+import os
diff --git a/tests/functional/w/wrong_import_position6.py b/tests/functional/w/wrong_import_position6.py
new file mode 100644
index 0000000..e719d2c
--- /dev/null
+++ b/tests/functional/w/wrong_import_position6.py
@@ -0,0 +1,7 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level,undefined-variable
+
+import y
+
+if x:
+ import os
diff --git a/tests/functional/w/wrong_import_position7.py b/tests/functional/w/wrong_import_position7.py
new file mode 100644
index 0000000..58a79b8
--- /dev/null
+++ b/tests/functional/w/wrong_import_position7.py
@@ -0,0 +1,9 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+try:
+ import x
+except ImportError:
+ pass
+finally:
+ pass
+import y
diff --git a/tests/functional/w/wrong_import_position8.py b/tests/functional/w/wrong_import_position8.py
new file mode 100644
index 0000000..531d9ca
--- /dev/null
+++ b/tests/functional/w/wrong_import_position8.py
@@ -0,0 +1,4 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level,undefined-variable
+if x:
+ import os
diff --git a/tests/functional/w/wrong_import_position9.py b/tests/functional/w/wrong_import_position9.py
new file mode 100644
index 0000000..232c453
--- /dev/null
+++ b/tests/functional/w/wrong_import_position9.py
@@ -0,0 +1,9 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+import y
+try:
+ import x
+except ImportError:
+ pass
+else:
+ pass
diff --git a/tests/functional/w/wrong_import_position_exclude_dunder_main.py b/tests/functional/w/wrong_import_position_exclude_dunder_main.py
new file mode 100644
index 0000000..05f6803
--- /dev/null
+++ b/tests/functional/w/wrong_import_position_exclude_dunder_main.py
@@ -0,0 +1,12 @@
+# pylint: disable=import-error, unused-import, missing-docstring
+CONS = 42
+
+if __name__ == '__main__':
+ CONSTANT = True
+ VAR = 0
+ for i in range(10):
+ VAR += i
+
+ import six
+ import datetime
+ import astroid
diff --git a/tests/functional/y/__init__.py b/tests/functional/y/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/functional/y/__init__.py
diff --git a/tests/functional/y/yield_assign_py25.py b/tests/functional/y/yield_assign_py25.py
new file mode 100644
index 0000000..6a5ae00
--- /dev/null
+++ b/tests/functional/y/yield_assign_py25.py
@@ -0,0 +1,21 @@
+"""https://www.logilab.org/ticket/8771"""
+
+from __future__ import print_function
+
+def generator():
+ """yield as assignment"""
+ yield 45
+ xxxx = yield 123
+ print(xxxx)
+
+def generator_fp1(seq):
+ """W0631 false positive"""
+ for val in seq:
+ pass
+ for val in seq:
+ yield val
+
+def generator_fp2():
+ """E0601 false positive"""
+ xxxx = 12
+ yield xxxx
diff --git a/tests/functional/y/yield_from_iterable_py33.py b/tests/functional/y/yield_from_iterable_py33.py
new file mode 100644
index 0000000..7803936
--- /dev/null
+++ b/tests/functional/y/yield_from_iterable_py33.py
@@ -0,0 +1,7 @@
+"""
+Check that `yield from`-statement takes an iterable.
+"""
+# pylint: disable=missing-docstring
+
+def to_ten():
+ yield from 10 # [not-an-iterable]
diff --git a/tests/functional/y/yield_from_iterable_py33.rc b/tests/functional/y/yield_from_iterable_py33.rc
new file mode 100644
index 0000000..28c99bc
--- /dev/null
+++ b/tests/functional/y/yield_from_iterable_py33.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.3
diff --git a/tests/functional/y/yield_from_iterable_py33.txt b/tests/functional/y/yield_from_iterable_py33.txt
new file mode 100644
index 0000000..871b11c
--- /dev/null
+++ b/tests/functional/y/yield_from_iterable_py33.txt
@@ -0,0 +1 @@
+not-an-iterable:7:15:to_ten:Non-iterable value 10 is used in an iterating context
diff --git a/tests/functional/y/yield_from_outside_func.py b/tests/functional/y/yield_from_outside_func.py
new file mode 100644
index 0000000..e2db90c
--- /dev/null
+++ b/tests/functional/y/yield_from_outside_func.py
@@ -0,0 +1,4 @@
+"""This is gramatically correct, but it's still a SyntaxError"""
+yield from [1, 2] # [yield-outside-function]
+
+LAMBDA_WITH_YIELD = lambda: (yield from [1, 2])
diff --git a/tests/functional/y/yield_from_outside_func.rc b/tests/functional/y/yield_from_outside_func.rc
new file mode 100644
index 0000000..28c99bc
--- /dev/null
+++ b/tests/functional/y/yield_from_outside_func.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.3
diff --git a/tests/functional/y/yield_from_outside_func.txt b/tests/functional/y/yield_from_outside_func.txt
new file mode 100644
index 0000000..415637c
--- /dev/null
+++ b/tests/functional/y/yield_from_outside_func.txt
@@ -0,0 +1 @@
+yield-outside-function:2:0::Yield outside function
diff --git a/tests/functional/y/yield_inside_async_function.py b/tests/functional/y/yield_inside_async_function.py
new file mode 100644
index 0000000..33585bf
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function.py
@@ -0,0 +1,12 @@
+"""Test that `yield` or `yield from` can't be used inside an async function."""
+# pylint: disable=missing-docstring, unused-variable
+
+async def good_coro():
+ def _inner():
+ yield 42
+ yield from [1, 2, 3]
+
+
+async def bad_coro():
+ yield 42 # [yield-inside-async-function]
+ yield from [1, 2, 3] # [yield-inside-async-function]
diff --git a/tests/functional/y/yield_inside_async_function.rc b/tests/functional/y/yield_inside_async_function.rc
new file mode 100644
index 0000000..0a040cb
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.5
+max_pyver=3.6
diff --git a/tests/functional/y/yield_inside_async_function.txt b/tests/functional/y/yield_inside_async_function.txt
new file mode 100644
index 0000000..5b48798
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function.txt
@@ -0,0 +1,2 @@
+yield-inside-async-function:11::bad_coro:Yield inside async function
+yield-inside-async-function:12::bad_coro:Yield inside async function
diff --git a/tests/functional/y/yield_inside_async_function_py36.py b/tests/functional/y/yield_inside_async_function_py36.py
new file mode 100644
index 0000000..a0f52e6
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function_py36.py
@@ -0,0 +1,12 @@
+"""Test that `yield` or `yield from` can't be used inside an async function."""
+# pylint: disable=missing-docstring, unused-variable
+
+async def good_coro():
+ def _inner():
+ yield 42
+ yield from [1, 2, 3]
+
+
+async def bad_coro():
+ yield 42
+ yield from [1, 2, 3] # [yield-inside-async-function]
diff --git a/tests/functional/y/yield_inside_async_function_py36.rc b/tests/functional/y/yield_inside_async_function_py36.rc
new file mode 100644
index 0000000..0ba2b63
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/y/yield_inside_async_function_py36.txt b/tests/functional/y/yield_inside_async_function_py36.txt
new file mode 100644
index 0000000..1a8492f
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function_py36.txt
@@ -0,0 +1 @@
+yield-inside-async-function:12:4:bad_coro:Yield inside async function
diff --git a/tests/functional/y/yield_outside_func.py b/tests/functional/y/yield_outside_func.py
new file mode 100644
index 0000000..5824bc0
--- /dev/null
+++ b/tests/functional/y/yield_outside_func.py
@@ -0,0 +1,4 @@
+"""This is gramatically correct, but it's still a SyntaxError"""
+yield 1 # [yield-outside-function]
+
+LAMBDA_WITH_YIELD = lambda: (yield)
diff --git a/tests/functional/y/yield_outside_func.txt b/tests/functional/y/yield_outside_func.txt
new file mode 100644
index 0000000..415637c
--- /dev/null
+++ b/tests/functional/y/yield_outside_func.txt
@@ -0,0 +1 @@
+yield-outside-function:2:0::Yield outside function
diff --git a/tests/functional/y/yield_return_mix.py b/tests/functional/y/yield_return_mix.py
new file mode 100644
index 0000000..8e050f0
--- /dev/null
+++ b/tests/functional/y/yield_return_mix.py
@@ -0,0 +1,8 @@
+""" module doc """
+# pylint: disable=useless-return
+__revision__ = None
+
+def somegen():
+ """this kind of mix is OK"""
+ yield 1
+ return
diff --git a/tests/input/__init__.py b/tests/input/__init__.py
new file mode 100644
index 0000000..60e92b7
--- /dev/null
+++ b/tests/input/__init__.py
@@ -0,0 +1 @@
+"""test"""
diff --git a/tests/input/benchmark_minimal_file.py b/tests/input/benchmark_minimal_file.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/input/benchmark_minimal_file.py
diff --git a/tests/input/func_3k_removed_stuff_py_30.py b/tests/input/func_3k_removed_stuff_py_30.py
new file mode 100644
index 0000000..54ad935
--- /dev/null
+++ b/tests/input/func_3k_removed_stuff_py_30.py
@@ -0,0 +1,13 @@
+"""test relative import"""
+# pylint: disable=no-absolute-import
+from __future__ import print_function
+import func_w0401
+__revision__ = filter(None, map(str, (1, 2, 3)))
+
+
+def function():
+ """something"""
+ print(func_w0401)
+ unic = u"unicode"
+ low = unic.looower
+ return low
diff --git a/tests/input/func_i0011.py b/tests/input/func_i0011.py
new file mode 100644
index 0000000..a4ef215
--- /dev/null
+++ b/tests/input/func_i0011.py
@@ -0,0 +1,4 @@
+# pylint:disable=W0404
+"""check warning on local disabling
+"""
+__revision__ = 1
diff --git a/tests/input/func_i0012.py b/tests/input/func_i0012.py
new file mode 100644
index 0000000..9b6fbe7
--- /dev/null
+++ b/tests/input/func_i0012.py
@@ -0,0 +1,4 @@
+# pylint:enable=W0404
+"""check warning on local enabling
+"""
+__revision__ = 1
diff --git a/tests/input/func_i0013.py b/tests/input/func_i0013.py
new file mode 100644
index 0000000..0a3f833
--- /dev/null
+++ b/tests/input/func_i0013.py
@@ -0,0 +1,8 @@
+# pylint: skip-file
+"""disable-all is usable as an inline option"""
+
+# no warning should be issued
+try:
+ import this
+except:
+ pass
diff --git a/tests/input/func_i0014.py b/tests/input/func_i0014.py
new file mode 100644
index 0000000..63ff37c
--- /dev/null
+++ b/tests/input/func_i0014.py
@@ -0,0 +1,8 @@
+# pylint: disable-all
+"""disable-all is usable as an inline option"""
+
+# no warning should be issued
+try:
+ import this
+except:
+ pass
diff --git a/tests/input/func_i0020.py b/tests/input/func_i0020.py
new file mode 100644
index 0000000..8c0fe9f
--- /dev/null
+++ b/tests/input/func_i0020.py
@@ -0,0 +1,8 @@
+"""Test for reporting of suppressed messages."""
+
+__revision__ = 0
+
+def suppressed():
+ """A function with an unused variable."""
+ # pylint: disable=W0612
+ var = 0
diff --git a/tests/input/func_i0022.py b/tests/input/func_i0022.py
new file mode 100644
index 0000000..f5b308f
--- /dev/null
+++ b/tests/input/func_i0022.py
@@ -0,0 +1,22 @@
+"""Deprecated suppression style."""
+
+__revision__ = None
+
+a = 1 # pylint: disable=invalid-name
+b = 1 # pylint: disable-msg=invalid-name
+
+# pylint: disable=invalid-name
+c = 1
+# pylint: enable=invalid-name
+
+# pylint: disable-msg=invalid-name
+d = 1
+# pylint: enable-msg=invalid-name
+
+# pylint: disable-msg=C0103
+e = 1
+# pylint: enable-msg=C0103
+
+# pylint: disable=C0103
+f = 1
+# pylint: enable=C0103
diff --git a/tests/input/func_return_yield_mix_py_33.py b/tests/input/func_return_yield_mix_py_33.py
new file mode 100644
index 0000000..b120b80
--- /dev/null
+++ b/tests/input/func_return_yield_mix_py_33.py
@@ -0,0 +1,15 @@
+"""pylint should detect yield and return mix inside generators"""
+# pylint: disable=using-constant-test, inconsistent-return-statements
+def somegen():
+ """this is a bad generator"""
+ if True:
+ return 1
+ else:
+ yield 2
+
+def moregen():
+ """this is another bad generator"""
+ if True:
+ yield 1
+ else:
+ return 2
diff --git a/tests/input/func_w0122_py_30.py b/tests/input/func_w0122_py_30.py
new file mode 100644
index 0000000..6b86691
--- /dev/null
+++ b/tests/input/func_w0122_py_30.py
@@ -0,0 +1,12 @@
+"""test global statement"""
+
+__revision__ = 0
+
+exec 'a = __revision__'
+exec 'a = 1' in {}
+
+exec 'a = 1' in globals()
+
+def func():
+ """exec in local scope"""
+ exec 'b = 1'
diff --git a/tests/input/func_w0332_py_30.py b/tests/input/func_w0332_py_30.py
new file mode 100644
index 0000000..6a38e8c
--- /dev/null
+++ b/tests/input/func_w0332_py_30.py
@@ -0,0 +1,4 @@
+"""check use of l as long int marker
+"""
+# pylint: disable=long-suffix
+__revision__ = 1l
diff --git a/tests/input/func_w0401.py b/tests/input/func_w0401.py
new file mode 100644
index 0000000..12227bc
--- /dev/null
+++ b/tests/input/func_w0401.py
@@ -0,0 +1,9 @@
+"""test cyclic import
+"""
+# pylint: disable=no-absolute-import
+from __future__ import print_function
+
+from . import w0401_cycle
+
+if w0401_cycle:
+ print(w0401_cycle)
diff --git a/tests/input/func_w0401_disabled.py b/tests/input/func_w0401_disabled.py
new file mode 100644
index 0000000..966706c
--- /dev/null
+++ b/tests/input/func_w0401_disabled.py
@@ -0,0 +1,9 @@
+"""test cyclic import
+"""
+# pylint: disable=no-absolute-import
+from __future__ import print_function
+
+from . import w0401_cycle # pylint: disable=cyclic-import
+
+if w0401_cycle:
+ print(w0401_cycle)
diff --git a/tests/input/func_w0401_disabled_in_func.py b/tests/input/func_w0401_disabled_in_func.py
new file mode 100644
index 0000000..69f2668
--- /dev/null
+++ b/tests/input/func_w0401_disabled_in_func.py
@@ -0,0 +1,11 @@
+"""Test disabling of cyclic import check inside a function
+"""
+# pylint: disable=no-absolute-import,import-outside-toplevel
+from __future__ import print_function
+
+
+def func():
+ """Test disabling of cyclic import check inside a function"""
+ from . import w0401_cycle # pylint: disable=cyclic-import
+ if w0401_cycle:
+ print(w0401_cycle)
diff --git a/tests/input/func_w0401_package/__init__.py b/tests/input/func_w0401_package/__init__.py
new file mode 100644
index 0000000..dedef66
--- /dev/null
+++ b/tests/input/func_w0401_package/__init__.py
@@ -0,0 +1,2 @@
+"""Our big package."""
+__revision__ = None
diff --git a/tests/input/func_w0401_package/all_the_things.py b/tests/input/func_w0401_package/all_the_things.py
new file mode 100644
index 0000000..b8bd47b
--- /dev/null
+++ b/tests/input/func_w0401_package/all_the_things.py
@@ -0,0 +1,9 @@
+"""All the things!"""
+# pylint: disable=no-absolute-import
+from .thing1 import THING1
+from .thing2 import THING2
+from .thing2 import THING1_PLUS_THING2
+__revision__ = None
+
+_ = (THING1, THING2, THING1_PLUS_THING2)
+del _
diff --git a/tests/input/func_w0401_package/thing1.py b/tests/input/func_w0401_package/thing1.py
new file mode 100644
index 0000000..34972a7
--- /dev/null
+++ b/tests/input/func_w0401_package/thing1.py
@@ -0,0 +1,3 @@
+"""The first thing."""
+__revision__ = None
+THING1 = "I am thing1"
diff --git a/tests/input/func_w0401_package/thing2.py b/tests/input/func_w0401_package/thing2.py
new file mode 100644
index 0000000..66d3316
--- /dev/null
+++ b/tests/input/func_w0401_package/thing2.py
@@ -0,0 +1,7 @@
+"""The second thing."""
+# pylint: disable=no-absolute-import
+from .all_the_things import THING1
+__revision__ = None
+
+THING2 = "I am thing2"
+THING1_PLUS_THING2 = "%s, plus %s" % (THING1, THING2)
diff --git a/tests/input/func_w0801.py b/tests/input/func_w0801.py
new file mode 100644
index 0000000..cd386ff
--- /dev/null
+++ b/tests/input/func_w0801.py
@@ -0,0 +1,11 @@
+"""test code similarities
+by defaut docstring are not considered
+"""
+__revision__ = 'id'
+A = 2
+B = 3
+C = A + B
+# need more than X lines to trigger the message
+C *= 2
+A -= B
+# all this should be detected
diff --git a/tests/input/hide_code_with_imports.py b/tests/input/hide_code_with_imports.py
new file mode 100644
index 0000000..a8449c9
--- /dev/null
+++ b/tests/input/hide_code_with_imports.py
@@ -0,0 +1,16 @@
+quicksort = lambda a: qs1(a,0,len(a)-1) ; import a
+qs1 = lambda a,lo,hi: qs2(a,lo,hi) if lo<hi else a ; import b
+qs2 = lambda a,lo,hi: qs3(lo,hi,*qsp(a,lo,hi)) ; import c
+qs3 = lambda lo,hi,a,p: qs1(qs1(a,p+1,hi),lo,p-1) ; import d
+qsp = lambda a,lo,hi: qsp1(a,lo,hi,a[hi],lo,lo) ; import e
+qsp1 = lambda a,lo,hi,p,i,j: qsp2(a,lo,hi,p,i,j,j<hi) ; import f
+qsp2 = lambda a,lo,hi,p,i,j,c: qspt(a,lo,hi,p,i,j,qsp3 if c else qsp7); import g
+qspt = lambda a,lo,hi,p,i,j,n: n(a,lo,hi,p,i,j) ; import h
+qsp3 = lambda a,lo,hi,p,i,j: qsp4(a,lo,hi,p,i,j,a[j]<p) ; import i
+qsp4 = lambda a,lo,hi,p,i,j,c: qspt(a,lo,hi,p,i,j,qsp5 if c else qsp6); import j
+qsp5 = lambda a,lo,hi,p,i,j: qsp1(sw(a,i,j),lo,hi,p,i+1,j+1) ; import k
+qsp6 = lambda a,lo,hi,p,i,j: qsp1(a,lo,hi,p,i,j+1) ; import l
+qsp7 = lambda a,lo,hi,p,i,j: (sw(a,i,hi), i) ; import m
+sw = lambda a,i,j: sw1(enumerate(a),i,j,a[i],(-1,a[j])) ; import n
+sw1 = lambda a,i,j,ai,aj: sw2([aj if x[0]==i else x for x in a],j,ai) ; import o
+sw2 = lambda a,j,ai: [ai if x[0]==j else x[1] for x in a] ; import p
diff --git a/tests/input/ignore_except_pass_by_default.py b/tests/input/ignore_except_pass_by_default.py
new file mode 100644
index 0000000..444e540
--- /dev/null
+++ b/tests/input/ignore_except_pass_by_default.py
@@ -0,0 +1,6 @@
+"""#5575: by default no W0704 warning on bare pass in except"""
+
+try:
+ __exception__ = 0
+except ValueError:
+ pass
diff --git a/tests/input/multiline-import b/tests/input/multiline-import
new file mode 100644
index 0000000..b9507ef
--- /dev/null
+++ b/tests/input/multiline-import
@@ -0,0 +1,8 @@
+from foo import (
+ bar,
+ baz,
+ quux,
+ quuux,
+ quuuux,
+ quuuuux,
+)
diff --git a/tests/input/no_absolute_import.py b/tests/input/no_absolute_import.py
new file mode 100644
index 0000000..6905941
--- /dev/null
+++ b/tests/input/no_absolute_import.py
@@ -0,0 +1,5 @@
+""" Puts issue #2672 under test (-j 1 vs -j N)
+
+Here we use a simple file to ensure configs are treated exactly the same way in -j 1 and
+-j N """
+import os # pylint: disable=unused-import
diff --git a/tests/input/noext b/tests/input/noext
new file mode 100644
index 0000000..8aeda06
--- /dev/null
+++ b/tests/input/noext
@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+"""a python file without .py extension"""
+
+__revision__ = None
diff --git a/tests/input/not__init__.py b/tests/input/not__init__.py
new file mode 100644
index 0000000..60e92b7
--- /dev/null
+++ b/tests/input/not__init__.py
@@ -0,0 +1 @@
+"""test"""
diff --git a/tests/input/similar1 b/tests/input/similar1
new file mode 100644
index 0000000..a533e2f
--- /dev/null
+++ b/tests/input/similar1
@@ -0,0 +1,30 @@
+import one
+from two import two
+three
+four
+five
+six # comments optionally ignored
+seven
+eight
+nine
+''' ten
+eleven
+twelve '''
+thirteen
+fourteen
+fifteen
+
+
+
+
+sixteen
+seventeen
+eighteen
+
+
+
+
+nineteen
+r"""
+twenty
+"""
diff --git a/tests/input/similar2 b/tests/input/similar2
new file mode 100644
index 0000000..79bcab2
--- /dev/null
+++ b/tests/input/similar2
@@ -0,0 +1,30 @@
+import one
+from two import two
+three
+four
+five
+six
+seven
+eight
+nine
+''' ten
+ELEVEN
+twelve '''
+thirteen
+fourteen
+FIFTEEN
+
+
+
+
+sixteen
+seventeen
+eighteen
+
+
+
+
+NINETEEN
+r"""
+twenty
+"""
diff --git a/tests/input/similar3 b/tests/input/similar3
new file mode 100644
index 0000000..337431f
--- /dev/null
+++ b/tests/input/similar3
@@ -0,0 +1,25 @@
+a = (
+ (
+ [
+ "Lines 1-8 used to trigger a similarity warning, but now they don't because...",
+ "...lines with only symbols are ignored and don't count in the line count limit."
+ ]
+ ),
+)
+
+"This line in similar3 breaks up the sections of code by being different than similar4"
+
+b = (
+ (
+ [
+ "Lines 12-25 still trigger a similarity...",
+ "...warning, because..."
+ ],
+ [
+ "...even after ignoring lines with only symbols..."
+ ],
+ ),
+ (
+ "...there are still 5 similar lines in this code block.",
+ )
+)
diff --git a/tests/input/similar4 b/tests/input/similar4
new file mode 100644
index 0000000..abdad26
--- /dev/null
+++ b/tests/input/similar4
@@ -0,0 +1,25 @@
+a = (
+ (
+ [
+ "Lines 1-8 used to trigger a similarity warning, but now they don't because...",
+ "...lines with only symbols are ignored and don't count in the line count limit."
+ ]
+ ),
+)
+
+"This line in similar4 breaks up the sections of code by being different than similar3"
+
+b = (
+ (
+ [
+ "Lines 12-25 still trigger a similarity...",
+ "...warning, because..."
+ ],
+ [
+ "...even after ignoring lines with only symbols..."
+ ],
+ ),
+ (
+ "...there are still 5 similar lines in this code block.",
+ )
+)
diff --git a/tests/input/similar5 b/tests/input/similar5
new file mode 100644
index 0000000..d87610b
--- /dev/null
+++ b/tests/input/similar5
@@ -0,0 +1,8 @@
+def func1(
+ arg1: int = 3,
+ arg2: Class1 = val1,
+ arg3: Class2 = func3(val2),
+ arg4: int = 4,
+ arg5: int = 5
+) -> Ret1:
+ pass
diff --git a/tests/input/similar6 b/tests/input/similar6
new file mode 100644
index 0000000..0377e92
--- /dev/null
+++ b/tests/input/similar6
@@ -0,0 +1,15 @@
+
+@deco1(dval1)
+@deco2(dval2)
+@deco3(
+ dval3,
+ dval4
+)
+async def func2(
+ arg1: int = 3,
+ arg2: Class1 = val1,
+ arg3: Class2 = func3(val2),
+ arg4: int = 4,
+ arg5: int = 5
+) -> Ret1:
+ pass
diff --git a/tests/input/similar_lines_a.py b/tests/input/similar_lines_a.py
new file mode 100644
index 0000000..65a72a7
--- /dev/null
+++ b/tests/input/similar_lines_a.py
@@ -0,0 +1,63 @@
+""" A file designed to have lines of similarity when compared to similar_lines_b
+
+We use lorm-ipsum to generate 'random' code. """
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+
+
+def adipiscing(elit):
+ etiam = "id"
+ dictum = "purus,"
+ vitae = "pretium"
+ neque = "Vivamus"
+ nec = "ornare"
+ tortor = "sit"
+ return etiam, dictum, vitae, neque, nec, tortor
+
+
+class Amet:
+ def similar_function_3_lines(self, tellus): # line same #1
+ agittis = 10 # line same #2
+ tellus *= 300 # line same #3
+ return agittis, tellus # line diff
+
+ def lorem(self, ipsum):
+ dolor = "sit"
+ amet = "consectetur"
+ return (lorem, dolor, amet)
+
+ def similar_function_5_lines(self, similar): # line same #1
+ some_var = 10 # line same #2
+ someother_var *= 300 # line same #3
+ fusce = "sit" # line same #4
+ amet = "tortor" # line same #5
+ return some_var, someother_var, fusce, amet # line diff
+
+ def __init__(self, moleskie, lectus="Mauris", ac="pellentesque"):
+ metus = "ut"
+ lobortis = "urna."
+ Integer = "nisl"
+ (mauris,) = "interdum"
+ non = "odio"
+ semper = "aliquam"
+ malesuada = "nunc."
+ iaculis = "dolor"
+ facilisis = "ultrices"
+ vitae = "ut."
+
+ return (
+ metus,
+ lobortis,
+ Integer,
+ mauris,
+ non,
+ semper,
+ malesuada,
+ iaculis,
+ facilisis,
+ vitae,
+ )
+
+ def similar_function_3_lines(self, tellus): # line same #1
+ agittis = 10 # line same #2
+ tellus *= 300 # line same #3
+ return agittis, tellus # line diff
diff --git a/tests/input/similar_lines_b.py b/tests/input/similar_lines_b.py
new file mode 100644
index 0000000..2163488
--- /dev/null
+++ b/tests/input/similar_lines_b.py
@@ -0,0 +1,36 @@
+""" The sister file of similar_lines_a, another file designed to have lines of
+similarity when compared to its sister file
+
+As with the sister file, we use lorm-ipsum to generate 'random' code. """
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+
+
+class Nulla:
+ tortor = "ultrices quis porta in"
+ sagittis = "ut tellus"
+
+ def pulvinar(self, blandit, metus):
+ egestas = [mauris for mauris in zip(blandit, metus)]
+ neque = (egestas, blandit)
+
+ def similar_function_5_lines(self, similar): # line same #1
+ some_var = 10 # line same #2
+ someother_var *= 300 # line same #3
+ fusce = "sit" # line same #4
+ amet = "tortor" # line same #5
+ iaculis = "dolor" # line diff
+ return some_var, someother_var, fusce, amet, iaculis, iaculis # line diff
+
+
+def tortor(self):
+ ultrices = 2
+ quis = ultricies * "porta"
+ return ultricies, quis
+
+
+class Commodo:
+ def similar_function_3_lines(self, tellus): # line same #1
+ agittis = 10 # line same #2
+ tellus *= 300 # line same #3
+ laoreet = "commodo " # line diff
+ return agittis, tellus, laoreet # line diff
diff --git a/tests/input/w0401_cycle.py b/tests/input/w0401_cycle.py
new file mode 100644
index 0000000..ddb4255
--- /dev/null
+++ b/tests/input/w0401_cycle.py
@@ -0,0 +1,9 @@
+"""w0401 dependency
+"""
+# pylint: disable=print-statement, no-absolute-import
+from __future__ import print_function
+
+from . import func_w0401
+
+if func_w0401:
+ print(input)
diff --git a/tests/input/w0801_same.py b/tests/input/w0801_same.py
new file mode 100644
index 0000000..cd386ff
--- /dev/null
+++ b/tests/input/w0801_same.py
@@ -0,0 +1,11 @@
+"""test code similarities
+by defaut docstring are not considered
+"""
+__revision__ = 'id'
+A = 2
+B = 3
+C = A + B
+# need more than X lines to trigger the message
+C *= 2
+A -= B
+# all this should be detected
diff --git a/tests/lint/__init__.py b/tests/lint/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/lint/__init__.py
diff --git a/tests/lint/unittest_expand_modules.py b/tests/lint/unittest_expand_modules.py
new file mode 100644
index 0000000..a6618ce
--- /dev/null
+++ b/tests/lint/unittest_expand_modules.py
@@ -0,0 +1,89 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+
+import re
+from pathlib import Path
+
+import pytest
+
+from pylint.lint.expand_modules import _is_in_ignore_list_re, expand_modules
+
+
+def test__is_in_ignore_list_re_match():
+ patterns = [
+ re.compile(".*enchilada.*"),
+ re.compile("unittest_.*"),
+ re.compile(".*tests/.*"),
+ ]
+ assert _is_in_ignore_list_re("unittest_utils.py", patterns)
+ assert _is_in_ignore_list_re("cheese_enchiladas.xml", patterns)
+ assert _is_in_ignore_list_re("src/tests/whatever.xml", patterns)
+
+
+def test__is_in_ignore_list_re_nomatch():
+ patterns = [
+ re.compile(".*enchilada.*"),
+ re.compile("unittest_.*"),
+ re.compile(".*tests/.*"),
+ ]
+ assert not _is_in_ignore_list_re("test_utils.py", patterns)
+ assert not _is_in_ignore_list_re("enchilad.py", patterns)
+ assert not _is_in_ignore_list_re("src/tests.py", patterns)
+
+
+TEST_DIRECTORY = Path(__file__).parent.parent
+INIT_PATH = str(TEST_DIRECTORY / "lint/__init__.py")
+EXPAND_MODULES = str(TEST_DIRECTORY / "lint/unittest_expand_modules.py")
+this_file = {
+ "basename": "lint.unittest_expand_modules",
+ "basepath": EXPAND_MODULES,
+ "isarg": True,
+ "name": "lint.unittest_expand_modules",
+ "path": EXPAND_MODULES,
+}
+
+this_file_from_init = {
+ "basename": "lint",
+ "basepath": INIT_PATH,
+ "isarg": False,
+ "name": "lint.unittest_expand_modules",
+ "path": EXPAND_MODULES,
+}
+
+unittest_lint = {
+ "basename": "lint",
+ "basepath": INIT_PATH,
+ "isarg": False,
+ "name": "lint.unittest_lint",
+ "path": str(TEST_DIRECTORY / "lint/unittest_lint.py"),
+}
+
+
+init_of_package = {
+ "basename": "lint",
+ "basepath": INIT_PATH,
+ "isarg": True,
+ "name": "lint",
+ "path": INIT_PATH,
+}
+
+
+@pytest.mark.parametrize(
+ "files_or_modules,expected",
+ [
+ ([__file__], [this_file]),
+ (
+ [Path(__file__).parent],
+ [init_of_package, this_file_from_init, unittest_lint],
+ ),
+ ],
+)
+def test_expand_modules(files_or_modules, expected):
+ ignore_list, ignore_list_re, ignore_list_paths_re = [], [], []
+ modules, errors = expand_modules(
+ files_or_modules, ignore_list, ignore_list_re, ignore_list_paths_re
+ )
+ modules.sort(key=lambda d: d["name"])
+ assert modules == expected
+ assert not errors
diff --git a/tests/lint/unittest_lint.py b/tests/lint/unittest_lint.py
new file mode 100644
index 0000000..3485b16
--- /dev/null
+++ b/tests/lint/unittest_lint.py
@@ -0,0 +1,841 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2011-2014 Google, Inc.
+# Copyright (c) 2012 Kevin Jing Qiu <kevin.jing.qiu@gmail.com>
+# Copyright (c) 2012 Anthony VEREZ <anthony.verez.external@cassidian.com>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Noam Yorav-Raphael <noamraph@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2017-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2017 Craig Citro <craigcitro@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 Matus Valo <matusvalo@users.noreply.github.com>
+# Copyright (c) 2018 Scott Worley <scottworley@scottworley.com>
+# Copyright (c) 2018 Randall Leeds <randall@bleeds.info>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+# Copyright (c) 2019 Janne Rönkkö <jannero@users.noreply.github.com>
+# Copyright (c) 2019 Trevor Bekolay <tbekolay@gmail.com>
+# Copyright (c) 2019 Andres Perez Hortal <andresperezcba@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 Martin Vielsmaier <martin@vielsmaier.net>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+# pylint: disable=redefined-outer-name
+
+import os
+import re
+import sys
+import tempfile
+from contextlib import contextmanager
+from importlib import reload
+from io import StringIO
+from os import chdir, getcwd
+from os.path import abspath, basename, dirname, isdir, join, sep
+from shutil import rmtree
+
+import pytest
+
+from pylint import checkers, config, exceptions, interfaces, lint, testutils
+from pylint.checkers.utils import check_messages
+from pylint.constants import (
+ MSG_STATE_CONFIDENCE,
+ MSG_STATE_SCOPE_CONFIG,
+ MSG_STATE_SCOPE_MODULE,
+)
+from pylint.exceptions import InvalidMessageError
+from pylint.lint import ArgumentPreprocessingError, PyLinter, Run, preprocess_options
+from pylint.reporters import text
+from pylint.utils import FileState, tokenize_module
+
+if os.name == "java":
+ # pylint: disable=no-member
+ # os._name is valid see https://www.programcreek.com/python/example/3842/os._name
+ if os.name == "nt":
+ HOME = "USERPROFILE"
+ else:
+ HOME = "HOME"
+elif sys.platform == "win32":
+ HOME = "USERPROFILE"
+else:
+ HOME = "HOME"
+
+
+@contextmanager
+def fake_home():
+ folder = tempfile.mkdtemp("fake-home")
+ old_home = os.environ.get(HOME)
+ try:
+ os.environ[HOME] = folder
+ yield
+ finally:
+ os.environ.pop("PYLINTRC", "")
+ if old_home is None:
+ del os.environ[HOME]
+ else:
+ os.environ[HOME] = old_home
+ rmtree(folder, ignore_errors=True)
+
+
+def remove(file):
+ try:
+ os.remove(file)
+ except OSError:
+ pass
+
+
+HERE = abspath(dirname(__file__))
+INPUT_DIR = join(HERE, "..", "input")
+REGRTEST_DATA_DIR = join(HERE, "..", "regrtest_data")
+DATA_DIR = join(HERE, "..", "data")
+
+
+@contextmanager
+def tempdir():
+ """Create a temp directory and change the current location to it.
+
+ This is supposed to be used with a *with* statement.
+ """
+ tmp = tempfile.mkdtemp()
+
+ # Get real path of tempfile, otherwise test fail on mac os x
+ current_dir = getcwd()
+ chdir(tmp)
+ abs_tmp = abspath(".")
+
+ try:
+ yield abs_tmp
+ finally:
+ chdir(current_dir)
+ rmtree(abs_tmp)
+
+
+def create_files(paths, chroot="."):
+ """Creates directories and files found in <path>.
+
+ :param list paths: list of relative paths to files or directories
+ :param str chroot: the root directory in which paths will be created
+
+ >>> from os.path import isdir, isfile
+ >>> isdir('/tmp/a')
+ False
+ >>> create_files(['a/b/foo.py', 'a/b/c/', 'a/b/c/d/e.py'], '/tmp')
+ >>> isdir('/tmp/a')
+ True
+ >>> isdir('/tmp/a/b/c')
+ True
+ >>> isfile('/tmp/a/b/c/d/e.py')
+ True
+ >>> isfile('/tmp/a/b/foo.py')
+ True
+ """
+ dirs, files = set(), set()
+ for path in paths:
+ path = join(chroot, path)
+ filename = basename(path)
+ # path is a directory path
+ if filename == "":
+ dirs.add(path)
+ # path is a filename path
+ else:
+ dirs.add(dirname(path))
+ files.add(path)
+ for dirpath in dirs:
+ if not isdir(dirpath):
+ os.makedirs(dirpath)
+ for filepath in files:
+ with open(filepath, "w"):
+ pass
+
+
+@pytest.fixture
+def fake_path():
+ orig = list(sys.path)
+ fake = [1, 2, 3]
+ sys.path[:] = fake
+ yield fake
+ sys.path[:] = orig
+
+
+def test_no_args(fake_path):
+ with lint.fix_import_path([]):
+ assert sys.path == fake_path
+ assert sys.path == fake_path
+
+
+@pytest.mark.parametrize(
+ "case", [["a/b/"], ["a/b"], ["a/b/__init__.py"], ["a/"], ["a"]]
+)
+def test_one_arg(fake_path, case):
+ with tempdir() as chroot:
+ create_files(["a/b/__init__.py"])
+ expected = [join(chroot, "a")] + fake_path
+
+ assert sys.path == fake_path
+ with lint.fix_import_path(case):
+ assert sys.path == expected
+ assert sys.path == fake_path
+
+
+@pytest.mark.parametrize(
+ "case",
+ [
+ ["a/b", "a/c"],
+ ["a/c/", "a/b/"],
+ ["a/b/__init__.py", "a/c/__init__.py"],
+ ["a", "a/c/__init__.py"],
+ ],
+)
+def test_two_similar_args(fake_path, case):
+ with tempdir() as chroot:
+ create_files(["a/b/__init__.py", "a/c/__init__.py"])
+ expected = [join(chroot, "a")] + fake_path
+
+ assert sys.path == fake_path
+ with lint.fix_import_path(case):
+ assert sys.path == expected
+ assert sys.path == fake_path
+
+
+@pytest.mark.parametrize(
+ "case",
+ [
+ ["a/b/c/__init__.py", "a/d/__init__.py", "a/e/f.py"],
+ ["a/b/c", "a", "a/e"],
+ ["a/b/c", "a", "a/b/c", "a/e", "a"],
+ ],
+)
+def test_more_args(fake_path, case):
+ with tempdir() as chroot:
+ create_files(["a/b/c/__init__.py", "a/d/__init__.py", "a/e/f.py"])
+ expected = [
+ join(chroot, suffix)
+ for suffix in (sep.join(("a", "b")), "a", sep.join(("a", "e")))
+ ] + fake_path
+
+ assert sys.path == fake_path
+ with lint.fix_import_path(case):
+ assert sys.path == expected
+ assert sys.path == fake_path
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["I"]
+
+
+@pytest.fixture(scope="module")
+def reporter():
+ return testutils.GenericTestReporter
+
+
+@pytest.fixture
+def init_linter(linter):
+ linter.open()
+ linter.set_current_module("toto")
+ linter.file_state = FileState("toto")
+ return linter
+
+
+def test_pylint_visit_method_taken_in_account(linter):
+ class CustomChecker(checkers.BaseChecker):
+ __implements__ = interfaces.IAstroidChecker
+ name = "custom"
+ msgs = {"W9999": ("", "custom", "")}
+
+ @check_messages("custom")
+ def visit_class(self, _):
+ pass
+
+ linter.register_checker(CustomChecker(linter))
+ linter.open()
+ out = StringIO()
+ linter.set_reporter(text.TextReporter(out))
+ linter.check("abc")
+
+
+def test_enable_message(init_linter):
+ linter = init_linter
+ assert linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("W0102")
+ linter.disable("W0101", scope="package")
+ linter.disable("W0102", scope="module", line=1)
+ assert not linter.is_message_enabled("W0101")
+ assert not linter.is_message_enabled("W0102", 1)
+ linter.set_current_module("tutu")
+ assert not linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("W0102")
+ linter.enable("W0101", scope="package")
+ linter.enable("W0102", scope="module", line=1)
+ assert linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("W0102", 1)
+
+
+def test_enable_message_category(init_linter):
+ linter = init_linter
+ assert linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("C0202")
+ linter.disable("W", scope="package")
+ linter.disable("C", scope="module", line=1)
+ assert not linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("C0202")
+ assert not linter.is_message_enabled("C0202", line=1)
+ linter.set_current_module("tutu")
+ assert not linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("C0202")
+ linter.enable("W", scope="package")
+ linter.enable("C", scope="module", line=1)
+ assert linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("C0202")
+ assert linter.is_message_enabled("C0202", line=1)
+
+
+def test_message_state_scope(init_linter):
+ class FakeConfig:
+ confidence = ["HIGH"]
+
+ linter = init_linter
+ linter.disable("C0202")
+ assert MSG_STATE_SCOPE_CONFIG == linter.get_message_state_scope("C0202")
+ linter.disable("W0101", scope="module", line=3)
+ assert MSG_STATE_SCOPE_CONFIG == linter.get_message_state_scope("C0202")
+ assert MSG_STATE_SCOPE_MODULE == linter.get_message_state_scope("W0101", 3)
+ linter.enable("W0102", scope="module", line=3)
+ assert MSG_STATE_SCOPE_MODULE == linter.get_message_state_scope("W0102", 3)
+ linter.config = FakeConfig()
+ assert MSG_STATE_CONFIDENCE == linter.get_message_state_scope(
+ "this-is-bad", confidence=interfaces.INFERENCE
+ )
+
+
+def test_enable_message_block(init_linter):
+ linter = init_linter
+ linter.open()
+ filepath = join(REGRTEST_DATA_DIR, "func_block_disable_msg.py")
+ linter.set_current_module("func_block_disable_msg")
+ astroid = linter.get_ast(filepath, "func_block_disable_msg")
+ linter.process_tokens(tokenize_module(astroid))
+ fs = linter.file_state
+ fs.collect_block_lines(linter.msgs_store, astroid)
+ # global (module level)
+ assert linter.is_message_enabled("W0613")
+ assert linter.is_message_enabled("E1101")
+ # meth1
+ assert linter.is_message_enabled("W0613", 13)
+ # meth2
+ assert not linter.is_message_enabled("W0613", 18)
+ # meth3
+ assert not linter.is_message_enabled("E1101", 24)
+ assert linter.is_message_enabled("E1101", 26)
+ # meth4
+ assert not linter.is_message_enabled("E1101", 32)
+ assert linter.is_message_enabled("E1101", 36)
+ # meth5
+ assert not linter.is_message_enabled("E1101", 42)
+ assert not linter.is_message_enabled("E1101", 43)
+ assert linter.is_message_enabled("E1101", 46)
+ assert not linter.is_message_enabled("E1101", 49)
+ assert not linter.is_message_enabled("E1101", 51)
+ # meth6
+ assert not linter.is_message_enabled("E1101", 57)
+ assert linter.is_message_enabled("E1101", 61)
+ assert not linter.is_message_enabled("E1101", 64)
+ assert not linter.is_message_enabled("E1101", 66)
+
+ assert linter.is_message_enabled("E0602", 57)
+ assert linter.is_message_enabled("E0602", 61)
+ assert not linter.is_message_enabled("E0602", 62)
+ assert linter.is_message_enabled("E0602", 64)
+ assert linter.is_message_enabled("E0602", 66)
+ # meth7
+ assert not linter.is_message_enabled("E1101", 70)
+ assert linter.is_message_enabled("E1101", 72)
+ assert linter.is_message_enabled("E1101", 75)
+ assert linter.is_message_enabled("E1101", 77)
+
+ fs = linter.file_state
+ assert fs._suppression_mapping["W0613", 18] == 17
+ assert fs._suppression_mapping["E1101", 33] == 30
+ assert ("E1101", 46) not in fs._suppression_mapping
+ assert fs._suppression_mapping["C0302", 18] == 1
+ assert fs._suppression_mapping["C0302", 50] == 1
+ # This is tricky. While the disable in line 106 is disabling
+ # both 108 and 110, this is usually not what the user wanted.
+ # Therefore, we report the closest previous disable comment.
+ assert fs._suppression_mapping["E1101", 108] == 106
+ assert fs._suppression_mapping["E1101", 110] == 109
+
+
+def test_enable_by_symbol(init_linter):
+ """messages can be controlled by symbolic names.
+
+ The state is consistent across symbols and numbers.
+ """
+ linter = init_linter
+ assert linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("unreachable")
+ assert linter.is_message_enabled("W0102")
+ assert linter.is_message_enabled("dangerous-default-value")
+ linter.disable("unreachable", scope="package")
+ linter.disable("dangerous-default-value", scope="module", line=1)
+ assert not linter.is_message_enabled("W0101")
+ assert not linter.is_message_enabled("unreachable")
+ assert not linter.is_message_enabled("W0102", 1)
+ assert not linter.is_message_enabled("dangerous-default-value", 1)
+ linter.set_current_module("tutu")
+ assert not linter.is_message_enabled("W0101")
+ assert not linter.is_message_enabled("unreachable")
+ assert linter.is_message_enabled("W0102")
+ assert linter.is_message_enabled("dangerous-default-value")
+ linter.enable("unreachable", scope="package")
+ linter.enable("dangerous-default-value", scope="module", line=1)
+ assert linter.is_message_enabled("W0101")
+ assert linter.is_message_enabled("unreachable")
+ assert linter.is_message_enabled("W0102", 1)
+ assert linter.is_message_enabled("dangerous-default-value", 1)
+
+
+def test_enable_report(linter):
+ assert linter.report_is_enabled("RP0001")
+ linter.disable("RP0001")
+ assert not linter.report_is_enabled("RP0001")
+ linter.enable("RP0001")
+ assert linter.report_is_enabled("RP0001")
+
+
+def test_report_output_format_aliased(linter):
+ text.register(linter)
+ linter.set_option("output-format", "text")
+ assert linter.reporter.__class__.__name__ == "TextReporter"
+
+
+def test_set_unsupported_reporter(linter):
+ text.register(linter)
+ with pytest.raises(exceptions.InvalidReporterError):
+ linter.set_option("output-format", "missing.module.Class")
+
+
+def test_set_option_1(linter):
+ linter.set_option("disable", "C0111,W0234")
+ assert not linter.is_message_enabled("C0111")
+ assert not linter.is_message_enabled("W0234")
+ assert linter.is_message_enabled("W0113")
+ assert not linter.is_message_enabled("missing-docstring")
+ assert not linter.is_message_enabled("non-iterator-returned")
+
+
+def test_set_option_2(linter):
+ linter.set_option("disable", ("C0111", "W0234"))
+ assert not linter.is_message_enabled("C0111")
+ assert not linter.is_message_enabled("W0234")
+ assert linter.is_message_enabled("W0113")
+ assert not linter.is_message_enabled("missing-docstring")
+ assert not linter.is_message_enabled("non-iterator-returned")
+
+
+def test_enable_checkers(linter):
+ linter.disable("design")
+ assert not ("design" in [c.name for c in linter.prepare_checkers()])
+ linter.enable("design")
+ assert "design" in [c.name for c in linter.prepare_checkers()]
+
+
+def test_errors_only(linter):
+ linter.error_mode()
+ checkers = linter.prepare_checkers()
+ checker_names = {c.name for c in checkers}
+ should_not = {"design", "format", "metrics", "miscellaneous", "similarities"}
+ assert set() == should_not & checker_names
+
+
+def test_disable_similar(linter):
+ linter.set_option("disable", "RP0801")
+ linter.set_option("disable", "R0801")
+ assert not ("similarities" in [c.name for c in linter.prepare_checkers()])
+
+
+def test_disable_alot(linter):
+ """check that we disabled a lot of checkers"""
+ linter.set_option("reports", False)
+ linter.set_option("disable", "R,C,W")
+ checker_names = [c.name for c in linter.prepare_checkers()]
+ for cname in ("design", "metrics", "similarities"):
+ assert not (cname in checker_names), cname
+
+
+def test_addmessage(linter):
+ linter.set_reporter(testutils.GenericTestReporter())
+ linter.open()
+ linter.set_current_module("0123")
+ linter.add_message("C0301", line=1, args=(1, 2))
+ linter.add_message("line-too-long", line=2, args=(3, 4))
+ assert [
+ "C: 1: Line too long (1/2)",
+ "C: 2: Line too long (3/4)",
+ ] == linter.reporter.messages
+
+
+def test_addmessage_invalid(linter):
+ linter.set_reporter(testutils.GenericTestReporter())
+ linter.open()
+ linter.set_current_module("0123")
+
+ with pytest.raises(InvalidMessageError) as cm:
+ linter.add_message("line-too-long", args=(1, 2))
+ assert str(cm.value) == "Message C0301 must provide line, got None"
+
+ with pytest.raises(InvalidMessageError) as cm:
+ linter.add_message("line-too-long", line=2, node="fake_node", args=(1, 2))
+ assert (
+ str(cm.value)
+ == "Message C0301 must only provide line, got line=2, node=fake_node"
+ )
+
+ with pytest.raises(InvalidMessageError) as cm:
+ linter.add_message("C0321")
+ assert str(cm.value) == "Message C0321 must provide Node, got None"
+
+
+def test_load_plugin_command_line():
+ dummy_plugin_path = join(REGRTEST_DATA_DIR, "dummy_plugin")
+ sys.path.append(dummy_plugin_path)
+
+ run = Run(
+ ["--load-plugins", "dummy_plugin", join(REGRTEST_DATA_DIR, "empty.py")],
+ exit=False,
+ )
+ assert (
+ len([ch.name for ch in run.linter.get_checkers() if ch.name == "dummy_plugin"])
+ == 2
+ )
+
+ sys.path.remove(dummy_plugin_path)
+
+
+def test_load_plugin_config_file():
+ dummy_plugin_path = join(REGRTEST_DATA_DIR, "dummy_plugin")
+ sys.path.append(dummy_plugin_path)
+ config_path = join(REGRTEST_DATA_DIR, "dummy_plugin.rc")
+
+ run = Run(
+ ["--rcfile", config_path, join(REGRTEST_DATA_DIR, "empty.py")],
+ exit=False,
+ )
+ assert (
+ len([ch.name for ch in run.linter.get_checkers() if ch.name == "dummy_plugin"])
+ == 2
+ )
+
+ sys.path.remove(dummy_plugin_path)
+
+
+def test_load_plugin_configuration():
+ dummy_plugin_path = join(REGRTEST_DATA_DIR, "dummy_plugin")
+ sys.path.append(dummy_plugin_path)
+
+ run = Run(
+ [
+ "--load-plugins",
+ "dummy_conf_plugin",
+ "--ignore",
+ "foo,bar",
+ join(REGRTEST_DATA_DIR, "empty.py"),
+ ],
+ exit=False,
+ )
+ assert run.linter.config.black_list == ["foo", "bar", "bin"]
+
+
+def test_init_hooks_called_before_load_plugins():
+ with pytest.raises(RuntimeError):
+ Run(["--load-plugins", "unexistant", "--init-hook", "raise RuntimeError"])
+ with pytest.raises(RuntimeError):
+ Run(["--init-hook", "raise RuntimeError", "--load-plugins", "unexistant"])
+
+
+def test_analyze_explicit_script(linter):
+ linter.set_reporter(testutils.GenericTestReporter())
+ linter.check(os.path.join(DATA_DIR, "ascript"))
+ assert ["C: 2: Line too long (175/100)"] == linter.reporter.messages
+
+
+def test_python3_checker_disabled(linter):
+ checker_names = [c.name for c in linter.prepare_checkers()]
+ assert "python3" not in checker_names
+
+ linter.set_option("enable", "python3")
+ checker_names = [c.name for c in linter.prepare_checkers()]
+ assert "python3" in checker_names
+
+
+def test_full_documentation(linter):
+ out = StringIO()
+ linter.print_full_documentation(out)
+ output = out.getvalue()
+ # A few spot checks only
+ for re_str in (
+ # autogenerated text
+ "^Pylint global options and switches$",
+ "Verbatim name of the checker is ``python3``",
+ # messages
+ "^:old-octal-literal \\(E1608\\):",
+ # options
+ "^:dummy-variables-rgx:",
+ ):
+ regexp = re.compile(re_str, re.MULTILINE)
+ assert re.search(regexp, output)
+
+
+def test_list_msgs_enabled(init_linter, capsys):
+ linter = init_linter
+ linter.enable("W0101", scope="package")
+ linter.disable("W0102", scope="package")
+ linter.list_messages_enabled()
+
+ lines = capsys.readouterr().out.splitlines()
+
+ assert "Enabled messages:" in lines
+ assert " unreachable (W0101)" in lines
+
+ assert "Disabled messages:" in lines
+ disabled_ix = lines.index("Disabled messages:")
+
+ # W0101 should be in the enabled section
+ assert lines.index(" unreachable (W0101)") < disabled_ix
+
+ assert " dangerous-default-value (W0102)" in lines
+ # W0102 should be in the disabled section
+ assert lines.index(" dangerous-default-value (W0102)") > disabled_ix
+
+
+@pytest.fixture
+def pop_pylintrc():
+ os.environ.pop("PYLINTRC", None)
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylint_home():
+ uhome = os.path.expanduser("~")
+ if uhome == "~":
+ expected = ".pylint.d"
+ else:
+ expected = os.path.join(uhome, ".pylint.d")
+ assert config.PYLINT_HOME == expected
+
+ try:
+ pylintd = join(tempfile.gettempdir(), ".pylint.d")
+ os.environ["PYLINTHOME"] = pylintd
+ try:
+ reload(config)
+ assert config.PYLINT_HOME == pylintd
+ finally:
+ try:
+ os.remove(pylintd)
+ except FileNotFoundError:
+ pass
+ finally:
+ del os.environ["PYLINTHOME"]
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylintrc():
+ with fake_home():
+ current_dir = getcwd()
+ chdir(os.path.dirname(os.path.abspath(sys.executable)))
+ try:
+ assert config.find_pylintrc() is None
+ os.environ["PYLINTRC"] = join(tempfile.gettempdir(), ".pylintrc")
+ assert config.find_pylintrc() is None
+ os.environ["PYLINTRC"] = "."
+ assert config.find_pylintrc() is None
+ finally:
+ chdir(current_dir)
+ reload(config)
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylintrc_parentdir():
+ with tempdir() as chroot:
+
+ create_files(
+ [
+ "a/pylintrc",
+ "a/b/__init__.py",
+ "a/b/pylintrc",
+ "a/b/c/__init__.py",
+ "a/b/c/d/__init__.py",
+ "a/b/c/d/e/.pylintrc",
+ ]
+ )
+ with fake_home():
+ assert config.find_pylintrc() is None
+ results = {
+ "a": join(chroot, "a", "pylintrc"),
+ "a/b": join(chroot, "a", "b", "pylintrc"),
+ "a/b/c": join(chroot, "a", "b", "pylintrc"),
+ "a/b/c/d": join(chroot, "a", "b", "pylintrc"),
+ "a/b/c/d/e": join(chroot, "a", "b", "c", "d", "e", ".pylintrc"),
+ }
+ for basedir, expected in results.items():
+ os.chdir(join(chroot, basedir))
+ assert config.find_pylintrc() == expected
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylintrc_parentdir_no_package():
+ with tempdir() as chroot:
+ with fake_home():
+ create_files(["a/pylintrc", "a/b/pylintrc", "a/b/c/d/__init__.py"])
+ assert config.find_pylintrc() is None
+ results = {
+ "a": join(chroot, "a", "pylintrc"),
+ "a/b": join(chroot, "a", "b", "pylintrc"),
+ "a/b/c": None,
+ "a/b/c/d": None,
+ }
+ for basedir, expected in results.items():
+ os.chdir(join(chroot, basedir))
+ assert config.find_pylintrc() == expected
+
+
+class TestPreprocessOptions:
+ def _callback(self, name, value):
+ self.args.append((name, value))
+
+ def test_value_equal(self):
+ self.args = []
+ preprocess_options(
+ ["--foo", "--bar=baz", "--qu=ux"],
+ {"foo": (self._callback, False), "qu": (self._callback, True)},
+ )
+ assert [("foo", None), ("qu", "ux")] == self.args
+
+ def test_value_space(self):
+ self.args = []
+ preprocess_options(["--qu", "ux"], {"qu": (self._callback, True)})
+ assert [("qu", "ux")] == self.args
+
+ @staticmethod
+ def test_error_missing_expected_value():
+ with pytest.raises(ArgumentPreprocessingError):
+ preprocess_options(["--foo", "--bar", "--qu=ux"], {"bar": (None, True)})
+ with pytest.raises(ArgumentPreprocessingError):
+ preprocess_options(["--foo", "--bar"], {"bar": (None, True)})
+
+ @staticmethod
+ def test_error_unexpected_value():
+ with pytest.raises(ArgumentPreprocessingError):
+ preprocess_options(
+ ["--foo", "--bar=spam", "--qu=ux"], {"bar": (None, False)}
+ )
+
+
+class _CustomPyLinter(PyLinter):
+ # pylint: disable=too-many-ancestors
+ def should_analyze_file(self, modname, path, is_argument=False):
+ if os.path.basename(path) == "wrong.py":
+ return False
+
+ return super().should_analyze_file(modname, path, is_argument=is_argument)
+
+
+def test_custom_should_analyze_file():
+ """Check that we can write custom should_analyze_file that work
+ even for arguments.
+ """
+ package_dir = os.path.join(REGRTEST_DATA_DIR, "bad_package")
+ wrong_file = os.path.join(package_dir, "wrong.py")
+
+ for jobs in (1, 2):
+ reporter = testutils.GenericTestReporter()
+ linter = _CustomPyLinter()
+ linter.config.jobs = jobs
+ linter.config.persistent = 0
+ linter.open()
+ linter.set_reporter(reporter)
+
+ try:
+ sys.path.append(os.path.dirname(package_dir))
+ linter.check([package_dir, wrong_file])
+ finally:
+ sys.path.pop()
+
+ messages = reporter.messages
+ assert len(messages) == 1
+ assert "invalid syntax" in messages[0]
+
+
+# we do the check with jobs=1 as well, so that we are sure that the duplicates
+# are created by the multiprocessing problem.
+@pytest.mark.parametrize("jobs", [1, 2])
+def test_multiprocessing(jobs):
+ """Check that multiprocessing does not create duplicates."""
+ # For the bug (#3584) to show up we need more than one file with issues
+ # per process
+ filenames = [
+ "special_attr_scope_lookup_crash.py",
+ "syntax_error.py",
+ "unused_variable.py",
+ "wildcard.py",
+ "wrong_import_position.py",
+ ]
+
+ reporter = testutils.GenericTestReporter()
+ linter = PyLinter()
+ linter.config.jobs = jobs
+ linter.config.persistent = 0
+ linter.open()
+ linter.set_reporter(reporter)
+
+ try:
+ sys.path.append(os.path.dirname(REGRTEST_DATA_DIR))
+ linter.check([os.path.join(REGRTEST_DATA_DIR, fname) for fname in filenames])
+ finally:
+ sys.path.pop()
+
+ messages = reporter.messages
+ assert len(messages) == len(set(messages))
+
+
+def test_filename_with__init__(init_linter):
+ # This tracks a regression where a file whose name ends in __init__.py,
+ # such as flycheck__init__.py, would accidentally lead to linting the
+ # entire containing directory.
+ reporter = testutils.GenericTestReporter()
+ linter = init_linter
+ linter.open()
+ linter.set_reporter(reporter)
+ filepath = join(INPUT_DIR, "not__init__.py")
+ linter.check([filepath])
+ messages = reporter.messages
+ assert len(messages) == 0
+
+
+def test_by_module_statement_value(init_linter):
+ """Test "statement" for each module analized of computed correctly."""
+ linter = init_linter
+ linter.check(os.path.join(os.path.dirname(__file__), "data"))
+
+ for module, module_stats in linter.stats["by_module"].items():
+
+ linter2 = init_linter
+ if module == "data":
+ linter2.check(os.path.join(os.path.dirname(__file__), "data/__init__.py"))
+ else:
+ linter2.check(os.path.join(os.path.dirname(__file__), module))
+
+ # Check that the by_module "statement" is equal to the global "statement"
+ # computed for that module
+ assert module_stats["statement"] == linter2.stats["statement"]
diff --git a/tests/message/__init__.py b/tests/message/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/message/__init__.py
diff --git a/tests/message/conftest.py b/tests/message/conftest.py
new file mode 100644
index 0000000..1f5036d
--- /dev/null
+++ b/tests/message/conftest.py
@@ -0,0 +1,77 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+# pylint: disable=redefined-outer-name
+
+
+import pytest
+
+from pylint.checkers import BaseChecker
+from pylint.message import MessageDefinitionStore, MessageIdStore
+
+
+@pytest.fixture
+def msgid():
+ return "W1234"
+
+
+@pytest.fixture
+def symbol():
+ return "msg-symbol"
+
+
+@pytest.fixture
+def empty_store():
+ return MessageDefinitionStore()
+
+
+@pytest.fixture
+def store():
+ store_ = MessageDefinitionStore()
+
+ class Checker(BaseChecker):
+ name = "achecker"
+ msgs = {
+ "W1234": (
+ "message",
+ "msg-symbol",
+ "msg description.",
+ {"old_names": [("W0001", "old-symbol")]},
+ ),
+ "E1234": (
+ "Duplicate keyword argument %r in %s call",
+ "duplicate-keyword-arg",
+ "Used when a function call passes the same keyword argument multiple times.",
+ {"maxversion": (2, 6)},
+ ),
+ }
+
+ store_.register_messages_from_checker(Checker())
+ return store_
+
+
+@pytest.fixture
+def message_definitions(store):
+ return store.messages
+
+
+@pytest.fixture
+def msgids():
+ return {
+ "W1234": "warning-symbol",
+ "W1235": "warning-symbol-two",
+ "C1234": "convention-symbol",
+ "E1234": "error-symbol",
+ }
+
+
+@pytest.fixture
+def empty_msgid_store():
+ return MessageIdStore()
+
+
+@pytest.fixture
+def msgid_store(msgids):
+ msgid_store = MessageIdStore()
+ for msgid, symbol in msgids.items():
+ msgid_store.add_msgid_and_symbol(msgid, symbol)
+ return msgid_store
diff --git a/tests/message/unittest_message.py b/tests/message/unittest_message.py
new file mode 100644
index 0000000..583eb14
--- /dev/null
+++ b/tests/message/unittest_message.py
@@ -0,0 +1,52 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+from pylint.message import Message
+
+
+def test_new_message(message_definitions):
+ def build_message(message_definition, location_value):
+ return Message(
+ symbol=message_definition.symbol,
+ msg_id=message_definition.msgid,
+ location=[
+ location_value["abspath"],
+ location_value["path"],
+ location_value["module"],
+ location_value["obj"],
+ location_value["line"],
+ location_value["column"],
+ ],
+ msg=message_definition.msg,
+ confidence="high",
+ )
+
+ template = "{path}:{line}:{column}: {msg_id}: {msg} ({symbol})"
+ for message_definition in message_definitions:
+ if message_definition.msgid == "E1234":
+ e1234_message_definition = message_definition
+ if message_definition.msgid == "W1234":
+ w1234_message_definition = message_definition
+ e1234_location_values = {
+ "abspath": "1",
+ "path": "2",
+ "module": "3",
+ "obj": "4",
+ "line": "5",
+ "column": "6",
+ }
+ w1234_location_values = {
+ "abspath": "7",
+ "path": "8",
+ "module": "9",
+ "obj": "10",
+ "line": "11",
+ "column": "12",
+ }
+ expected = (
+ "2:5:6: E1234: Duplicate keyword argument %r in %s call (duplicate-keyword-arg)"
+ )
+ e1234 = build_message(e1234_message_definition, e1234_location_values)
+ w1234 = build_message(w1234_message_definition, w1234_location_values)
+ assert e1234.format(template) == expected
+ assert w1234.format(template) == "8:11:12: W1234: message (msg-symbol)"
diff --git a/tests/message/unittest_message_definition.py b/tests/message/unittest_message_definition.py
new file mode 100644
index 0000000..1935d84
--- /dev/null
+++ b/tests/message/unittest_message_definition.py
@@ -0,0 +1,117 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import sys
+from unittest import mock
+
+import pytest
+
+from pylint.checkers import BaseChecker
+from pylint.constants import WarningScope
+from pylint.exceptions import InvalidMessageError
+from pylint.message import MessageDefinition
+
+
+@pytest.mark.parametrize(
+ "msgid,expected",
+ [
+ ("Q1234", "Bad message type Q in 'Q1234'"),
+ ("W12345", "Invalid message id 'W12345'"),
+ ],
+)
+def test_create_invalid_message_type(msgid, expected):
+ checker_mock = mock.Mock(name="Checker")
+ checker_mock.name = "checker"
+
+ with pytest.raises(InvalidMessageError) as invalid_message_error:
+ MessageDefinition.check_msgid(msgid)
+ with pytest.raises(InvalidMessageError) as other_invalid_message_error:
+ MessageDefinition(checker_mock, msgid, "msg", "descr", "symbol", "scope")
+ assert str(invalid_message_error.value) == expected
+ assert str(other_invalid_message_error.value) == expected
+
+
+class FalseChecker(BaseChecker):
+ name = "FalseChecker"
+ msgs = {
+ "W1234": ("message one", "msg-symbol-one", "msg description"),
+ "W1235": (
+ "message two",
+ "msg-symbol-two",
+ "msg description",
+ {"old_names": [("W1230", "msg-symbol-one")]},
+ ),
+ }
+
+
+class TestMessagesDefinition:
+ @staticmethod
+ def assert_with_fail_msg(msg, expected=True):
+ fail_msg = (
+ f"With minversion='{msg.minversion}' and maxversion='{msg.maxversion}',"
+ f" and the python interpreter being {sys.version_info} "
+ "the message should{}be emitable"
+ )
+ if expected:
+ assert msg.may_be_emitted(), fail_msg.format(" ")
+ else:
+ assert not msg.may_be_emitted(), fail_msg.format(" not ")
+
+ @staticmethod
+ def get_message_definition():
+ args = [
+ FalseChecker(),
+ "W1234",
+ "message",
+ "description",
+ "msg-symbol",
+ WarningScope.NODE,
+ ]
+ kwargs = {"minversion": None, "maxversion": None}
+ return MessageDefinition(*args, **kwargs)
+
+ def test_may_be_emitted(self):
+ major = sys.version_info.major
+ minor = sys.version_info.minor
+ msg = self.get_message_definition()
+ self.assert_with_fail_msg(msg, expected=True)
+ msg.minversion = (major, minor - 1)
+ msg.maxversion = (major, minor + 1)
+ self.assert_with_fail_msg(msg, expected=True)
+ msg.minversion = (major, minor + 1)
+ self.assert_with_fail_msg(msg, expected=False)
+ msg.minversion = (major, minor - 1)
+ self.assert_with_fail_msg(msg, expected=True)
+ msg.maxversion = (major, minor - 1)
+ self.assert_with_fail_msg(msg, expected=False)
+
+ def test_repr(self):
+ msg = self.get_message_definition()
+ repr_str = str([msg, msg])
+ assert "W1234" in repr_str
+ assert "msg-symbol" in repr_str
+ expected = "[MessageDefinition:msg-symbol-one (W1234), MessageDefinition:msg-symbol-two (W1235)]"
+ assert str(FalseChecker().messages) == expected
+
+ def test_str(self):
+ msg = self.get_message_definition()
+ str_msg = str(msg)
+ assert "W1234" in str_msg
+ assert "msg-symbol" in str_msg
+ expected = """MessageDefinition:msg-symbol-one (W1234):
+message one msg description"""
+ assert str(FalseChecker().messages[0]) == expected
+
+ def test_format_help(self):
+ msg = self.get_message_definition()
+ major = sys.version_info.major
+ minor = sys.version_info.minor
+ msg.minversion = (major, minor - 1)
+ msg.maxversion = (major, minor + 1)
+ format_str_checker_ref = msg.format_help(checkerref=False)
+ format_str = msg.format_help(checkerref=True)
+ assert str(minor - 1) in format_str
+ assert str(major + 1) in format_str_checker_ref
+ expected_format_help = """:msg-symbol-one (W1234): *message one*
+ msg description"""
+ assert FalseChecker().messages[0].format_help() == expected_format_help
diff --git a/tests/message/unittest_message_definition_store.py b/tests/message/unittest_message_definition_store.py
new file mode 100644
index 0000000..b240af9
--- /dev/null
+++ b/tests/message/unittest_message_definition_store.py
@@ -0,0 +1,269 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+from contextlib import redirect_stdout
+from io import StringIO
+
+import pytest
+
+from pylint.checkers import BaseChecker
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+from pylint.message import MessageDefinition
+
+
+@pytest.mark.parametrize(
+ "messages,expected",
+ [
+ (
+ {
+ "W1234": ("message one", "msg-symbol-one", "msg description"),
+ "W4321": ("message two", "msg-symbol-two", "msg description"),
+ },
+ r"Inconsistent checker part in message id 'W4321' (expected 'x12xx' because we already had ['W1234']).",
+ ),
+ (
+ {
+ "W1233": (
+ "message two",
+ "msg-symbol-two",
+ "msg description",
+ {"old_names": [("W1234", "old-symbol")]},
+ ),
+ "W1234": ("message one", "msg-symbol-one", "msg description"),
+ },
+ "Message id 'W1234' cannot have both 'msg-symbol-one' and 'old-symbol' as symbolic name.",
+ ),
+ (
+ {
+ "W1234": ("message one", "msg-symbol-one", "msg description"),
+ "W1235": (
+ "message two",
+ "msg-symbol-two",
+ "msg description",
+ {"old_names": [("W1234", "old-symbol")]},
+ ),
+ },
+ "Message id 'W1234' cannot have both 'msg-symbol-one' and 'old-symbol' as symbolic name.",
+ ),
+ (
+ {
+ "W1234": (
+ "message one",
+ "msg-symbol-one",
+ "msg description",
+ {"old_names": [("W1201", "old-symbol-one")]},
+ ),
+ "W1235": (
+ "message two",
+ "msg-symbol-two",
+ "msg description",
+ {"old_names": [("W1201", "old-symbol-two")]},
+ ),
+ },
+ "Message id 'W1201' cannot have both 'old-symbol-one' and 'old-symbol-two' as symbolic name.",
+ ),
+ (
+ {
+ "W1234": ("message one", "msg-symbol", "msg description"),
+ "W1235": ("message two", "msg-symbol", "msg description"),
+ },
+ "Message symbol 'msg-symbol' cannot be used for 'W1234' and 'W1235' at the same time. "
+ "If you're creating an 'old_names' use 'old-msg-symbol' as the old symbol.",
+ ),
+ (
+ {
+ "W1233": (
+ "message two",
+ "msg-symbol-two",
+ "msg description",
+ {"old_names": [("W1230", "msg-symbol-one")]},
+ ),
+ "W1234": ("message one", "msg-symbol-one", "msg description"),
+ },
+ "Message symbol 'msg-symbol-one' cannot be used for 'W1230' and 'W1234' at the same time."
+ " If you're creating an 'old_names' use 'old-msg-symbol-one' as the old symbol.",
+ ),
+ (
+ {
+ "W1234": ("message one", "msg-symbol-one", "msg description"),
+ "W1235": (
+ "message two",
+ "msg-symbol-two",
+ "msg description",
+ {"old_names": [("W1230", "msg-symbol-one")]},
+ ),
+ },
+ "Message symbol 'msg-symbol-one' cannot be used for 'W1230' and 'W1234' at the same time. "
+ "If you're creating an 'old_names' use 'old-msg-symbol-one' as the old symbol.",
+ ),
+ (
+ {
+ "W1234": (
+ "message one",
+ "msg-symbol-one",
+ "msg description",
+ {"old_names": [("W1230", "old-symbol-one")]},
+ ),
+ "W1235": (
+ "message two",
+ "msg-symbol-two",
+ "msg description",
+ {"old_names": [("W1231", "old-symbol-one")]},
+ ),
+ },
+ "Message symbol 'old-symbol-one' cannot be used for 'W1230' and 'W1231' at the same time. "
+ "If you're creating an 'old_names' use 'old-old-symbol-one' as the old symbol.",
+ ),
+ ],
+)
+def test_register_error(empty_store, messages, expected):
+ class Checker(BaseChecker):
+ name = "checker"
+ msgs = messages
+
+ with pytest.raises(InvalidMessageError) as cm:
+ empty_store.register_messages_from_checker(Checker())
+ assert str(cm.value) == expected
+
+
+def test_register_error_new_id_duplicate_of_new(empty_store):
+ class CheckerOne(BaseChecker):
+ name = "checker_one"
+ msgs = {"W1234": ("message one", "msg-symbol-one", "msg description.")}
+
+ class CheckerTwo(BaseChecker):
+ name = "checker_two"
+ msgs = {"W1234": ("message two", "msg-symbol-two", "another msg description.")}
+
+ empty_store.register_messages_from_checker(CheckerOne())
+ test_register_error(
+ empty_store,
+ CheckerTwo.msgs,
+ "Message id 'W1234' cannot have both 'msg-symbol-one' and 'msg-symbol-two' as symbolic name.",
+ )
+
+
+def test_format_help(capsys, store):
+ store.help_message([])
+ captured = capsys.readouterr()
+ assert captured.out == ""
+ store.help_message(["W1234", "E1234", "C1234"])
+ captured = capsys.readouterr()
+ assert (
+ captured.out
+ == """:msg-symbol (W1234): *message*
+ msg description. This message belongs to the achecker checker.
+
+:duplicate-keyword-arg (E1234): *Duplicate keyword argument %r in %s call*
+ Used when a function call passes the same keyword argument multiple times.
+ This message belongs to the achecker checker. It can't be emitted when using
+ Python >= 2.6.
+
+No such message id or symbol 'C1234'.
+
+"""
+ )
+
+
+def test_get_msg_display_string(store):
+ assert store.get_msg_display_string("W1234") == "'msg-symbol'"
+ assert store.get_msg_display_string("E1234") == "'duplicate-keyword-arg'"
+
+
+def test_check_message_id(store):
+ w1234 = store.get_message_definitions("W1234")[0]
+ w0001 = store.get_message_definitions("W0001")[0]
+ e1234 = store.get_message_definitions("E1234")[0]
+ old_symbol = store.get_message_definitions("old-symbol")[0]
+ assert isinstance(w1234, MessageDefinition)
+ assert isinstance(e1234, MessageDefinition)
+ assert w1234 == w0001
+ assert w1234 == old_symbol
+ with pytest.raises(UnknownMessageError):
+ store.get_message_definitions("YB12")
+
+
+class TestMessageDefinitionStore:
+ @staticmethod
+ def _compare_messages(desc, msg, checkerref=False):
+ assert desc == msg.format_help(checkerref=checkerref)
+
+ def test_message_help(self, store):
+ message_definition = store.get_message_definitions("W1234")[0]
+ self._compare_messages(
+ """:msg-symbol (W1234): *message*
+ msg description. This message belongs to the achecker checker.""",
+ message_definition,
+ checkerref=True,
+ )
+ self._compare_messages(
+ """:msg-symbol (W1234): *message*
+ msg description.""",
+ message_definition,
+ checkerref=False,
+ )
+
+ def test_message_help_minmax(self, store):
+ # build the message manually to be python version independent
+ message_definition = store.get_message_definitions("E1234")[0]
+ self._compare_messages(
+ """:duplicate-keyword-arg (E1234): *Duplicate keyword argument %r in %s call*
+ Used when a function call passes the same keyword argument multiple times.
+ This message belongs to the achecker checker. It can't be emitted when using
+ Python >= 2.6.""",
+ message_definition,
+ checkerref=True,
+ )
+ self._compare_messages(
+ """:duplicate-keyword-arg (E1234): *Duplicate keyword argument %r in %s call*
+ Used when a function call passes the same keyword argument multiple times.
+ This message can't be emitted when using Python >= 2.6.""",
+ message_definition,
+ checkerref=False,
+ )
+
+
+def test_list_messages(store):
+ output = StringIO()
+ with redirect_stdout(output):
+ store.list_messages()
+ # cursory examination of the output: we're mostly testing it completes
+ assert ":msg-symbol (W1234): *message*" in output.getvalue()
+
+
+def test_renamed_message_register(store):
+ assert store.get_message_definitions("W0001")[0].symbol == "msg-symbol"
+ assert store.get_message_definitions("old-symbol")[0].symbol == "msg-symbol"
+
+
+def test_multiple_child_of_old_name(store):
+ """We can define multiple name with the same old name."""
+
+ class FamillyChecker(BaseChecker):
+ name = "famillychecker"
+ msgs = {
+ "W1235": (
+ "Child 1",
+ "child-one",
+ "Child one description.",
+ {"old_names": [("C1234", "mother")]},
+ ),
+ "W1236": (
+ "Child 2",
+ "child-two",
+ "Child two description",
+ {"old_names": [("C1234", "mother")]},
+ ),
+ }
+
+ store.register_messages_from_checker(FamillyChecker())
+ mother = store.get_message_definitions("C1234")
+ child = store.get_message_definitions("W1235")
+ other_child = store.get_message_definitions("W1236")
+ assert len(mother) == 2
+ assert len(child) == 1
+ assert len(other_child) == 1
+ child = child[0]
+ other_child = other_child[0]
+ assert child in mother
+ assert other_child in mother
diff --git a/tests/message/unittest_message_id_store.py b/tests/message/unittest_message_id_store.py
new file mode 100644
index 0000000..a411fd7
--- /dev/null
+++ b/tests/message/unittest_message_id_store.py
@@ -0,0 +1,85 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import pytest
+
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+
+
+def test_len_str(msgid_store, msgids):
+ assert len(msgid_store) == len(msgids)
+ str_result = str(msgid_store)
+ assert "MessageIdStore: [" in str_result
+ assert " - W1234 (warning-symbol)" in str_result
+ assert " - W1235 (warning-symbol-two)" in str_result
+ assert " - C1234 (convention-symbol)" in str_result
+ assert " - E1234 (error-symbol)" in str_result
+ assert "]" in str_result
+
+
+def test_get_message_ids(msgid_store, msgids):
+ """We can get message id even with capitalization problem."""
+ msgid = list(msgids.keys())[0]
+ msgids_result = msgid_store.get_active_msgids(msgid.lower())
+ assert len(msgids_result) == 1
+ assert msgid == msgids_result[0]
+
+
+def test_get_message_ids_not_existing(empty_msgid_store):
+ with pytest.raises(UnknownMessageError) as error:
+ w9876 = "W9876"
+ empty_msgid_store.get_active_msgids(w9876)
+ assert w9876 in str(error.value)
+
+
+def test_register_message_definitions(empty_msgid_store, message_definitions):
+ number_of_msgid = len(message_definitions)
+ for message_definition in message_definitions:
+ empty_msgid_store.register_message_definition(
+ message_definition.msgid,
+ message_definition.symbol,
+ message_definition.old_names,
+ )
+ if message_definition.old_names:
+ number_of_msgid += len(message_definition.old_names)
+ assert len(empty_msgid_store) == number_of_msgid
+
+
+def test_add_msgid_and_symbol(empty_msgid_store):
+ empty_msgid_store.add_msgid_and_symbol("E1235", "new-sckiil")
+ empty_msgid_store.add_legacy_msgid_and_symbol("C1235", "old-sckiil", "E1235")
+ assert len(empty_msgid_store) == 2
+ message_ids = empty_msgid_store.get_active_msgids("E1235")
+ assert len(message_ids) == 1
+ assert message_ids[0] == "E1235"
+ message_ids = empty_msgid_store.get_active_msgids("old-sckiil")
+ assert len(message_ids) == 1
+ assert message_ids[0] == "E1235"
+ assert empty_msgid_store.get_symbol("C1235") == "old-sckiil"
+ assert empty_msgid_store.get_symbol("E1235") == "new-sckiil"
+ assert empty_msgid_store.get_msgid("old-sckiil") == "C1235"
+ assert empty_msgid_store.get_msgid("new-sckiil") == "E1235"
+ with pytest.raises(UnknownMessageError):
+ empty_msgid_store.get_symbol("C1234")
+ with pytest.raises(UnknownMessageError):
+ empty_msgid_store.get_msgid("not-exist")
+
+
+def test_duplicate_symbol(empty_msgid_store):
+ empty_msgid_store.add_msgid_and_symbol("W1234", "warning-symbol")
+ with pytest.raises(InvalidMessageError) as error:
+ empty_msgid_store.check_msgid_and_symbol("W1234", "other-symbol")
+ assert (
+ "Message id 'W1234' cannot have both 'other-symbol' and 'warning-symbol' as symbolic name."
+ in str(error.value)
+ )
+
+
+def test_duplicate_msgid(msgid_store):
+ msgid_store.add_msgid_and_symbol("W1234", "warning-symbol")
+ with pytest.raises(InvalidMessageError) as error:
+ msgid_store.check_msgid_and_symbol("W1235", "warning-symbol")
+ assert (
+ "Message symbol 'warning-symbol' cannot be used for 'W1234' and 'W1235'"
+ in str(error.value)
+ )
diff --git a/tests/messages/builtin_module.txt b/tests/messages/builtin_module.txt
new file mode 100644
index 0000000..2616c0e
--- /dev/null
+++ b/tests/messages/builtin_module.txt
@@ -0,0 +1 @@
+F: 1: ignored builtin module sys
diff --git a/tests/messages/func_3k_removed_stuff_py_30.txt b/tests/messages/func_3k_removed_stuff_py_30.txt
new file mode 100644
index 0000000..9920f1b
--- /dev/null
+++ b/tests/messages/func_3k_removed_stuff_py_30.txt
@@ -0,0 +1,2 @@
+E: 12:function: Instance of 'unicode' has no 'looower' member
+W: 4: Relative import 'func_w0401', should be 'input.func_w0401'
diff --git a/tests/messages/func_bad_cont_dictcomp_py27.txt b/tests/messages/func_bad_cont_dictcomp_py27.txt
new file mode 100644
index 0000000..51bde77
--- /dev/null
+++ b/tests/messages/func_bad_cont_dictcomp_py27.txt
@@ -0,0 +1,6 @@
+C: 35: Wrong continued indentation (add 2 spaces).
+ for x in range(3)} # [bad-continuation]
+ ^ |
+C: 38: Wrong continued indentation (remove 4 spaces).
+ for x in range(3)} # [bad-continuation]
+ | ^
diff --git a/tests/messages/func_bug113231.txt b/tests/messages/func_bug113231.txt
new file mode 100644
index 0000000..f05f160
--- /dev/null
+++ b/tests/messages/func_bug113231.txt
@@ -0,0 +1,2 @@
+W: 20: Use lazy % formatting in logging functions
+W: 21: Use lazy % formatting in logging functions
diff --git a/tests/messages/func_disable_linebased.txt b/tests/messages/func_disable_linebased.txt
new file mode 100644
index 0000000..06e391d
--- /dev/null
+++ b/tests/messages/func_disable_linebased.txt
@@ -0,0 +1,2 @@
+C: 1: Line too long (127/100)
+C: 14: Line too long (114/100)
diff --git a/tests/messages/func_disable_linebased_py30.txt b/tests/messages/func_disable_linebased_py30.txt
new file mode 100644
index 0000000..06e391d
--- /dev/null
+++ b/tests/messages/func_disable_linebased_py30.txt
@@ -0,0 +1,2 @@
+C: 1: Line too long (127/100)
+C: 14: Line too long (114/100)
diff --git a/tests/messages/func_i0011.txt b/tests/messages/func_i0011.txt
new file mode 100644
index 0000000..609f208
--- /dev/null
+++ b/tests/messages/func_i0011.txt
@@ -0,0 +1,3 @@
+I: 1: 'W0404' is cryptic: use '# pylint: disable=reimported' instead
+I: 1: Locally disabling reimported (W0404)
+I: 1: Useless suppression of 'reimported'
diff --git a/tests/messages/func_i0012.txt b/tests/messages/func_i0012.txt
new file mode 100644
index 0000000..2054758
--- /dev/null
+++ b/tests/messages/func_i0012.txt
@@ -0,0 +1 @@
+I: 1: 'W0404' is cryptic: use '# pylint: enable=reimported' instead
diff --git a/tests/messages/func_i0013.txt b/tests/messages/func_i0013.txt
new file mode 100644
index 0000000..75d7afd
--- /dev/null
+++ b/tests/messages/func_i0013.txt
@@ -0,0 +1 @@
+I: 1: Ignoring entire file
diff --git a/tests/messages/func_i0014.txt b/tests/messages/func_i0014.txt
new file mode 100644
index 0000000..c3b521d
--- /dev/null
+++ b/tests/messages/func_i0014.txt
@@ -0,0 +1,2 @@
+I: 1: Ignoring entire file
+I: 1: Pragma "disable-all" is deprecated, use "skip-file" instead
diff --git a/tests/messages/func_i0020.txt b/tests/messages/func_i0020.txt
new file mode 100644
index 0000000..5ae78a4
--- /dev/null
+++ b/tests/messages/func_i0020.txt
@@ -0,0 +1,3 @@
+I: 7: 'W0612' is cryptic: use '# pylint: disable=unused-variable' instead
+I: 7: Locally disabling unused-variable (W0612)
+I: 8: Suppressed 'unused-variable' (from line 7)
diff --git a/tests/messages/func_i0022.txt b/tests/messages/func_i0022.txt
new file mode 100644
index 0000000..0108fb1
--- /dev/null
+++ b/tests/messages/func_i0022.txt
@@ -0,0 +1,21 @@
+I: 5: Locally disabling invalid-name (C0103)
+I: 5: Suppressed 'invalid-name' (from line 5)
+I: 6: Locally disabling invalid-name (C0103)
+I: 6: Pragma "disable-msg" is deprecated, use "disable" instead
+I: 6: Suppressed 'invalid-name' (from line 6)
+I: 8: Locally disabling invalid-name (C0103)
+I: 9: Suppressed 'invalid-name' (from line 8)
+I: 12: Locally disabling invalid-name (C0103)
+I: 12: Pragma "disable-msg" is deprecated, use "disable" instead
+I: 13: Suppressed 'invalid-name' (from line 12)
+I: 14: Pragma "enable-msg" is deprecated, use "enable" instead
+I: 16: 'C0103' is cryptic: use '# pylint: disable=invalid-name' instead
+I: 16: Locally disabling invalid-name (C0103)
+I: 16: Pragma "disable-msg" is deprecated, use "disable" instead
+I: 17: Suppressed 'invalid-name' (from line 16)
+I: 18: 'C0103' is cryptic: use '# pylint: enable=invalid-name' instead
+I: 18: Pragma "enable-msg" is deprecated, use "enable" instead
+I: 20: 'C0103' is cryptic: use '# pylint: disable=invalid-name' instead
+I: 20: Locally disabling invalid-name (C0103)
+I: 21: Suppressed 'invalid-name' (from line 20)
+I: 22: 'C0103' is cryptic: use '# pylint: enable=invalid-name' instead
diff --git a/tests/messages/func_raw_escapes.txt b/tests/messages/func_raw_escapes.txt
new file mode 100644
index 0000000..991fba7
--- /dev/null
+++ b/tests/messages/func_raw_escapes.txt
@@ -0,0 +1,3 @@
+W: 5: Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix.
+W: 6: Anomalous Unicode escape in byte string: '\U'. String constant might be missing an r or u prefix.
+W: 7: Anomalous Unicode escape in byte string: '\N'. String constant might be missing an r or u prefix.
diff --git a/tests/messages/func_return_yield_mix_py_33.txt b/tests/messages/func_return_yield_mix_py_33.txt
new file mode 100644
index 0000000..d81ce5c
--- /dev/null
+++ b/tests/messages/func_return_yield_mix_py_33.txt
@@ -0,0 +1,2 @@
+E: 6:somegen: Return with argument inside generator
+E: 15:moregen: Return with argument inside generator
diff --git a/tests/messages/func_toolonglines_py30.txt b/tests/messages/func_toolonglines_py30.txt
new file mode 100644
index 0000000..cd594f5
--- /dev/null
+++ b/tests/messages/func_toolonglines_py30.txt
@@ -0,0 +1,4 @@
+C: 1: Line too long (101/100)
+C: 2: Line too long (104/100)
+C: 17: Line too long (102/100)
+C: 25: Line too long (105/100)
diff --git a/tests/messages/func_typecheck_callfunc_assigment.txt b/tests/messages/func_typecheck_callfunc_assigment.txt
new file mode 100644
index 0000000..d1257ca
--- /dev/null
+++ b/tests/messages/func_typecheck_callfunc_assigment.txt
@@ -0,0 +1,3 @@
+E: 18: Assigning result of a function call, where the function has no return
+E: 26: Assigning result of a function call, where the function returns None
+E: 33: Assigning result of a function call, where the function returns None
diff --git a/tests/messages/func_typecheck_getattr_py30.txt b/tests/messages/func_typecheck_getattr_py30.txt
new file mode 100644
index 0000000..b6bf150
--- /dev/null
+++ b/tests/messages/func_typecheck_getattr_py30.txt
@@ -0,0 +1,9 @@
+E: 25:Client.__init__: Class 'Provider' has no 'cattribute' member
+E: 35:Client.use_method: Instance of 'Provider' has no 'hophophop' member
+E: 40:Client.use_attr: Instance of 'Provider' has no 'attribute' member
+E: 52:Client.test_bt_types: Instance of 'list' has no 'apppend' member
+E: 54:Client.test_bt_types: Instance of 'dict' has no 'set' member
+E: 56:Client.test_bt_types: Instance of 'tuple' has no 'append' member
+E: 58:Client.test_bt_types: Instance of 'str' has no 'loower' member
+E: 62:Client.test_bt_types: Instance of 'int' has no 'whatever' member
+E: 66: Instance of 'int' has no 'lower' member (but some types could not be inferred)
diff --git a/tests/messages/func_typecheck_non_callable_call.txt b/tests/messages/func_typecheck_non_callable_call.txt
new file mode 100644
index 0000000..80e89d6
--- /dev/null
+++ b/tests/messages/func_typecheck_non_callable_call.txt
@@ -0,0 +1,8 @@
+E: 10: __revision__ is not callable
+E: 29: INSTANCE is not callable
+E: 31: LIST is not callable
+E: 33: DICT is not callable
+E: 35: TUPLE is not callable
+E: 37: INT is not callable
+E: 72: PROP.test is not callable
+E: 73: PROP.custom is not callable
diff --git a/tests/messages/func_unicode_literal_py26.txt b/tests/messages/func_unicode_literal_py26.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/messages/func_unicode_literal_py26.txt
diff --git a/tests/messages/func_unicode_literal_py274.txt b/tests/messages/func_unicode_literal_py274.txt
new file mode 100644
index 0000000..25efa99
--- /dev/null
+++ b/tests/messages/func_unicode_literal_py274.txt
@@ -0,0 +1 @@
+W: 6: Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix.
diff --git a/tests/messages/func_use_for_or_listcomp_var_py29.txt b/tests/messages/func_use_for_or_listcomp_var_py29.txt
new file mode 100644
index 0000000..2d27b51
--- /dev/null
+++ b/tests/messages/func_use_for_or_listcomp_var_py29.txt
@@ -0,0 +1,2 @@
+W: 6: Using possibly undefined loop variable 'C'
+W: 15: Using possibly undefined loop variable 'var1'
diff --git a/tests/messages/func_use_for_or_listcomp_var_py30.txt b/tests/messages/func_use_for_or_listcomp_var_py30.txt
new file mode 100644
index 0000000..35a85d5
--- /dev/null
+++ b/tests/messages/func_use_for_or_listcomp_var_py30.txt
@@ -0,0 +1,2 @@
+E: 6: Using variable 'C' before assignment
+W: 15: Using possibly undefined loop variable 'var1'
diff --git a/tests/messages/func_variables_unused_name_from_wilcard_import.txt b/tests/messages/func_variables_unused_name_from_wilcard_import.txt
new file mode 100644
index 0000000..01c57af
--- /dev/null
+++ b/tests/messages/func_variables_unused_name_from_wilcard_import.txt
@@ -0,0 +1,4 @@
+W: 3: Unused import NonRegr from wildcard import
+W: 3: Unused import os from wildcard import
+W: 3: Unused import sys from wildcard import
+W: 3: Wildcard import input.func_w0611
diff --git a/tests/messages/func_w0122_py_30.txt b/tests/messages/func_w0122_py_30.txt
new file mode 100644
index 0000000..e016366
--- /dev/null
+++ b/tests/messages/func_w0122_py_30.txt
@@ -0,0 +1,4 @@
+W: 5: Use of exec
+W: 6: Use of exec
+W: 8: Use of exec
+W: 12:func: Use of exec
diff --git a/tests/messages/func_w0312.txt b/tests/messages/func_w0312.txt
new file mode 100644
index 0000000..917e8d0
--- /dev/null
+++ b/tests/messages/func_w0312.txt
@@ -0,0 +1,2 @@
+W: 10: Found indentation with tabs instead of spaces
+W: 11: Found indentation with tabs instead of spaces
diff --git a/tests/messages/func_w0332_py_30.txt b/tests/messages/func_w0332_py_30.txt
new file mode 100644
index 0000000..16f1d80
--- /dev/null
+++ b/tests/messages/func_w0332_py_30.txt
@@ -0,0 +1 @@
+W: 4: Use of "l" as long integer identifier
diff --git a/tests/messages/func_w0401.txt b/tests/messages/func_w0401.txt
new file mode 100644
index 0000000..f6648f4
--- /dev/null
+++ b/tests/messages/func_w0401.txt
@@ -0,0 +1,3 @@
+R: 1: Cyclic import (input.func_w0401 -> input.w0401_cycle)
+W: 8: Using a conditional statement with a constant value
+W: 8: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0401_disabled.txt b/tests/messages/func_w0401_disabled.txt
new file mode 100644
index 0000000..b5a8db3
--- /dev/null
+++ b/tests/messages/func_w0401_disabled.txt
@@ -0,0 +1,2 @@
+W: 8: Using a conditional statement with a constant value
+W: 8: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0401_disabled_in_func.txt b/tests/messages/func_w0401_disabled_in_func.txt
new file mode 100644
index 0000000..b5ce452
--- /dev/null
+++ b/tests/messages/func_w0401_disabled_in_func.txt
@@ -0,0 +1,2 @@
+W: 8: Using a conditional statement with a constant value
+W: 10:func: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0401_package.txt b/tests/messages/func_w0401_package.txt
new file mode 100644
index 0000000..ca05124
--- /dev/null
+++ b/tests/messages/func_w0401_package.txt
@@ -0,0 +1,2 @@
+R: 1: Cyclic import (input.func_w0401_package.all_the_things -> input.func_w0401_package.thing2)
+W: 8: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0622.txt b/tests/messages/func_w0622.txt
new file mode 100644
index 0000000..7191347
--- /dev/null
+++ b/tests/messages/func_w0622.txt
@@ -0,0 +1,2 @@
+W: 8:function: Redefining built-in 'type'
+W: 11: Redefining built-in 'map'
diff --git a/tests/messages/func_w0623.txt b/tests/messages/func_w0623.txt
new file mode 100644
index 0000000..08fe8b5
--- /dev/null
+++ b/tests/messages/func_w0623.txt
@@ -0,0 +1,11 @@
+C: 28:some_function: Variable name "FOO" doesn't conform to 'variable-name-hint' template
+C: 41: Constant name "exc3" doesn't conform to 'constant-name-hint' template
+C: 55: Variable name "OOPS" doesn't conform to 'variable-name-hint' template
+W: 18:some_function: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 20:some_function: Redefining name 'OSError' from builtins in exception handler
+W: 20:some_function: Unused variable 'OSError'
+W: 22:some_function: Redefining name 'MyError' from outer scope (line 7) in exception handler
+W: 22:some_function: Unused variable 'MyError'
+W: 45: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 47: Redefining name 'OSError' from builtins in exception handler
+W: 49: Redefining name 'MyOtherError' from outer scope (line 36) in exception handler
diff --git a/tests/messages/func_w0623_py_30.txt b/tests/messages/func_w0623_py_30.txt
new file mode 100644
index 0000000..77329bb
--- /dev/null
+++ b/tests/messages/func_w0623_py_30.txt
@@ -0,0 +1,12 @@
+C: 28:some_function: Variable name "FOO" doesn't conform to 'variable-name-hint' template
+C: 41: Constant name "exc3" doesn't conform to 'constant-name-hint' template
+C: 57: Variable name "OOPS" doesn't conform to 'variable-name-hint' template
+W: 18:some_function: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 20:some_function: Redefining name 'OSError' from builtins in exception handler
+W: 20:some_function: Unused variable 'OSError'
+W: 22:some_function: Redefining name 'MyError' from outer scope (line 7) in exception handler
+W: 22:some_function: Unused variable 'MyError'
+W: 45: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 47: Redefining name 'args' from object 'exceptions.RuntimeError' in exception handler
+W: 49: Redefining name 'OSError' from builtins in exception handler
+W: 51: Redefining name 'MyOtherError' from outer scope (line 36) in exception handler
diff --git a/tests/messages/func_w0801.txt b/tests/messages/func_w0801.txt
new file mode 100644
index 0000000..203ce92
--- /dev/null
+++ b/tests/messages/func_w0801.txt
@@ -0,0 +1,11 @@
+R: 1: Similar lines in 2 files
+==input.func_w0801:3
+==input.w0801_same:3
+__revision__ = 'id'
+A = 2
+B = 3
+C = A + B
+# need more than X lines to trigger the message
+C *= 2
+A -= B
+# all this should be detected
diff --git a/tests/messages/func_with_without_as_py25.txt b/tests/messages/func_with_without_as_py25.txt
new file mode 100644
index 0000000..e62b69b
--- /dev/null
+++ b/tests/messages/func_with_without_as_py25.txt
@@ -0,0 +1,2 @@
+E: 11:do_nothing: Using variable 'base' before assignment
+W: 11:do_nothing: Statement seems to have no effect
diff --git a/tests/profile/test_profile_against_externals.py b/tests/profile/test_profile_against_externals.py
new file mode 100644
index 0000000..2860411
--- /dev/null
+++ b/tests/profile/test_profile_against_externals.py
@@ -0,0 +1,57 @@
+""" Profiles basic -jX functionality """
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+# pylint: disable=protected-access,missing-function-docstring,no-self-use
+
+import os
+import pprint
+
+import pytest
+
+from pylint.lint import Run
+from pylint.testutils import GenericTestReporter as Reporter
+
+
+def _get_py_files(scanpath):
+ assert os.path.exists(scanpath), "Dir not found %s" % scanpath
+
+ filepaths = []
+ for dirpath, dirnames, filenames in os.walk(scanpath):
+ dirnames[:] = [dirname for dirname in dirnames if dirname != "__pycache__"]
+ filepaths.extend(
+ [
+ os.path.join(dirpath, filename)
+ for filename in filenames
+ if filename.endswith(".py")
+ ]
+ )
+ return filepaths
+
+
+@pytest.mark.skipif(
+ not os.environ.get("PYTEST_PROFILE_EXTERNAL", False),
+ reason="PYTEST_PROFILE_EXTERNAL, not set, assuming not a profile run",
+)
+@pytest.mark.parametrize(
+ "name,git_repo", [("numpy", "https://github.com/numpy/numpy.git")]
+)
+def test_run(tmp_path, name, git_repo):
+ """Runs pylint against external sources"""
+ checkoutdir = tmp_path / name
+ checkoutdir.mkdir()
+ os.system(f"git clone --depth=1 {git_repo} {checkoutdir}")
+ filepaths = _get_py_files(scanpath=str(checkoutdir))
+ print("Have %d files" % len(filepaths))
+
+ runner = Run(filepaths, reporter=Reporter(), do_exit=False)
+
+ print(
+ "Had %d files with %d messages"
+ % (len(filepaths), len(runner.linter.reporter.messages))
+ )
+ pprint.pprint(runner.linter.reporter.messages)
diff --git a/tests/regrtest_data/.pylintrc b/tests/regrtest_data/.pylintrc
new file mode 100644
index 0000000..f513037
--- /dev/null
+++ b/tests/regrtest_data/.pylintrc
@@ -0,0 +1,3 @@
+[MASTER]
+
+optimize-ast=no
diff --git a/tests/regrtest_data/absimp/__init__.py b/tests/regrtest_data/absimp/__init__.py
new file mode 100644
index 0000000..fdabe9f
--- /dev/null
+++ b/tests/regrtest_data/absimp/__init__.py
@@ -0,0 +1,4 @@
+"""a package with absolute import activated
+"""
+
+from __future__ import absolute_import
diff --git a/tests/regrtest_data/absimp/string.py b/tests/regrtest_data/absimp/string.py
new file mode 100644
index 0000000..9a60e26
--- /dev/null
+++ b/tests/regrtest_data/absimp/string.py
@@ -0,0 +1,7 @@
+"""
+https://www.logilab.org/ticket/70495
+https://www.logilab.org/ticket/70565
+"""
+from __future__ import absolute_import, print_function
+import string
+print(string)
diff --git a/tests/regrtest_data/application_crash.py b/tests/regrtest_data/application_crash.py
new file mode 100644
index 0000000..8d3eb17
--- /dev/null
+++ b/tests/regrtest_data/application_crash.py
@@ -0,0 +1 @@
+ABC = something_undefined
diff --git a/tests/regrtest_data/bad_package/__init__.py b/tests/regrtest_data/bad_package/__init__.py
new file mode 100644
index 0000000..16c3a15
--- /dev/null
+++ b/tests/regrtest_data/bad_package/__init__.py
@@ -0,0 +1,2 @@
+import missing
+raise missing.Missing..
diff --git a/tests/regrtest_data/bad_package/wrong.py b/tests/regrtest_data/bad_package/wrong.py
new file mode 100644
index 0000000..2d2d78f
--- /dev/null
+++ b/tests/regrtest_data/bad_package/wrong.py
@@ -0,0 +1,5 @@
+"""
+Test that pylint doesn't crash when a relative import
+depends on the local __init__, which contains an expected syntax error.
+"""
+from . import missing
diff --git a/tests/regrtest_data/beyond_top/__init__.py b/tests/regrtest_data/beyond_top/__init__.py
new file mode 100644
index 0000000..788cf45
--- /dev/null
+++ b/tests/regrtest_data/beyond_top/__init__.py
@@ -0,0 +1,6 @@
+from ... import Something
+from . import data
+try:
+ from ... import Lala
+except ImportError:
+ pass
diff --git a/tests/regrtest_data/beyond_top/data.py b/tests/regrtest_data/beyond_top/data.py
new file mode 100644
index 0000000..3b735ff
--- /dev/null
+++ b/tests/regrtest_data/beyond_top/data.py
@@ -0,0 +1 @@
+Anything = 42
diff --git a/tests/regrtest_data/classdoc_usage.py b/tests/regrtest_data/classdoc_usage.py
new file mode 100644
index 0000000..2d9df51
--- /dev/null
+++ b/tests/regrtest_data/classdoc_usage.py
@@ -0,0 +1,17 @@
+"""ds"""
+
+__revision__ = None
+# pylint: disable=useless-object-inheritance
+
+class SomeClass(object):
+ """cds"""
+ doc = __doc__
+
+ def __init__(self):
+ """only to make pylint happier"""
+
+ def please(self):
+ """public method 1/2"""
+
+ def besilent(self):
+ """public method 2/2"""
diff --git a/tests/regrtest_data/comments_pylintrc b/tests/regrtest_data/comments_pylintrc
new file mode 100644
index 0000000..6d1cd39
--- /dev/null
+++ b/tests/regrtest_data/comments_pylintrc
@@ -0,0 +1,7 @@
+[MESSAGES CONTROL]
+disable=all
+enable=
+ trailing-whitespace, # Caring about it
+ bad-indentation, # And about this
+ # And about this
+ missing-docstring
diff --git a/tests/regrtest_data/dataclasses_pyreverse/__init__.py b/tests/regrtest_data/dataclasses_pyreverse/__init__.py
new file mode 100644
index 0000000..e4c9233
--- /dev/null
+++ b/tests/regrtest_data/dataclasses_pyreverse/__init__.py
@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class InventoryItem:
+ """Class for keeping track of an item in inventory."""
+
+ name: str
+ unit_price: float
+ quantity_on_hand: int = 0
+
+ def total_cost(self) -> float:
+ return self.unit_price * self.quantity_on_hand
diff --git a/tests/regrtest_data/decimal_inference.py b/tests/regrtest_data/decimal_inference.py
new file mode 100644
index 0000000..00c9130
--- /dev/null
+++ b/tests/regrtest_data/decimal_inference.py
@@ -0,0 +1,10 @@
+"""hum E1011 on .prec member is justifiable since Context instance are built
+using setattr/locals :(
+
+2007/02/17 update: .prec attribute is now detected by astroid :o)
+"""
+from __future__ import print_function
+import decimal
+
+decimal.getcontext().prec = 200
+print(decimal.getcontext().prec)
diff --git a/tests/regrtest_data/descriptor_crash.py b/tests/regrtest_data/descriptor_crash.py
new file mode 100644
index 0000000..4b3adcc
--- /dev/null
+++ b/tests/regrtest_data/descriptor_crash.py
@@ -0,0 +1,20 @@
+# -*- coding: iso-8859-1 -*-
+
+import urllib
+
+class Page(object):
+ _urlOpen = staticmethod(urllib.urlopen)
+
+ def getPage(self, url):
+ handle = self._urlOpen(url)
+ data = handle.read()
+ handle.close()
+ return data
+ #_getPage
+
+#Page
+
+if __name__ == "__main__":
+ import sys
+ p = Page()
+ print p.getPage(sys.argv[1])
diff --git a/tests/regrtest_data/dummy/__init__.py b/tests/regrtest_data/dummy/__init__.py
new file mode 100644
index 0000000..0b43a70
--- /dev/null
+++ b/tests/regrtest_data/dummy/__init__.py
@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+from .dummy import DUMMY
+from .another import ANOTHER
diff --git a/tests/regrtest_data/dummy/another.py b/tests/regrtest_data/dummy/another.py
new file mode 100644
index 0000000..56a8712
--- /dev/null
+++ b/tests/regrtest_data/dummy/another.py
@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+
+ANOTHER = 42
diff --git a/tests/regrtest_data/dummy/dummy.py b/tests/regrtest_data/dummy/dummy.py
new file mode 100644
index 0000000..60345dc
--- /dev/null
+++ b/tests/regrtest_data/dummy/dummy.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring
+DUMMY = 42
diff --git a/tests/regrtest_data/dummy_plugin.rc b/tests/regrtest_data/dummy_plugin.rc
new file mode 100644
index 0000000..162dedc
--- /dev/null
+++ b/tests/regrtest_data/dummy_plugin.rc
@@ -0,0 +1,6 @@
+[MASTER]
+load-plugins=dummy_plugin
+
+[DUMMY_PLUGIN]
+dummy_option_1="dummy value 1"
+dummy_option_2="dummy value 2"
diff --git a/tests/regrtest_data/dummy_plugin/dummy_conf_plugin.py b/tests/regrtest_data/dummy_plugin/dummy_conf_plugin.py
new file mode 100644
index 0000000..f58387f
--- /dev/null
+++ b/tests/regrtest_data/dummy_plugin/dummy_conf_plugin.py
@@ -0,0 +1,6 @@
+def register(linter):
+ pass
+
+
+def load_configuration(linter):
+ linter.config.black_list += ('bin',)
diff --git a/tests/regrtest_data/dummy_plugin/dummy_plugin.py b/tests/regrtest_data/dummy_plugin/dummy_plugin.py
new file mode 100644
index 0000000..95b0b93
--- /dev/null
+++ b/tests/regrtest_data/dummy_plugin/dummy_plugin.py
@@ -0,0 +1,30 @@
+from pylint.checkers import BaseChecker
+
+
+class DummyPlugin1(BaseChecker):
+ name = 'dummy_plugin'
+ msgs = {'I9061': ('Dummy short desc 01', 'dummy-message-01', 'Dummy long desc')}
+ options = (
+ ('dummy_option_1', {
+ 'type': 'string',
+ 'metavar': '<string>',
+ 'help': 'Dummy option 1',
+ }),
+ )
+
+
+class DummyPlugin2(BaseChecker):
+ name = 'dummy_plugin'
+ msgs = {'I9060': ('Dummy short desc 02', 'dummy-message-02', 'Dummy long desc')}
+ options = (
+ ('dummy_option_2', {
+ 'type': 'string',
+ 'metavar': '<string>',
+ 'help': 'Dummy option 2',
+ }),
+ )
+
+
+def register(linter):
+ linter.register_checker(DummyPlugin1(linter))
+ linter.register_checker(DummyPlugin2(linter))
diff --git a/tests/regrtest_data/duplicate_data_raw_strings/__init__.py b/tests/regrtest_data/duplicate_data_raw_strings/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/regrtest_data/duplicate_data_raw_strings/__init__.py
diff --git a/tests/regrtest_data/duplicate_data_raw_strings/first.py b/tests/regrtest_data/duplicate_data_raw_strings/first.py
new file mode 100644
index 0000000..687c592
--- /dev/null
+++ b/tests/regrtest_data/duplicate_data_raw_strings/first.py
@@ -0,0 +1,11 @@
+r"""A raw docstring.
+"""
+
+
+def look_busy():
+ xxxx = 1
+ yyyy = 2
+ zzzz = 3
+ wwww = 4
+ vvvv = xxxx + yyyy + zzzz + wwww
+ return vvvv
diff --git a/tests/regrtest_data/duplicate_data_raw_strings/second.py b/tests/regrtest_data/duplicate_data_raw_strings/second.py
new file mode 100644
index 0000000..687c592
--- /dev/null
+++ b/tests/regrtest_data/duplicate_data_raw_strings/second.py
@@ -0,0 +1,11 @@
+r"""A raw docstring.
+"""
+
+
+def look_busy():
+ xxxx = 1
+ yyyy = 2
+ zzzz = 3
+ wwww = 4
+ vvvv = xxxx + yyyy + zzzz + wwww
+ return vvvv
diff --git a/tests/regrtest_data/empty.py b/tests/regrtest_data/empty.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/regrtest_data/empty.py
diff --git a/tests/regrtest_data/fail_under_minus10.py b/tests/regrtest_data/fail_under_minus10.py
new file mode 100644
index 0000000..5ce3785
--- /dev/null
+++ b/tests/regrtest_data/fail_under_minus10.py
@@ -0,0 +1,11 @@
+"""
+ Pylint score: -10
+"""
+import nonexistent
+
+
+def loop():
+ count = 0
+ for i in range(5):
+ count += 1
+ print(count)
diff --git a/tests/regrtest_data/fail_under_plus7_5.py b/tests/regrtest_data/fail_under_plus7_5.py
new file mode 100644
index 0000000..fea27f4
--- /dev/null
+++ b/tests/regrtest_data/fail_under_plus7_5.py
@@ -0,0 +1,9 @@
+""""
+ pylint score: +7.50
+"""
+
+import os
+
+def func():
+ path = '/tmp'
+ os.path.exists(path)
diff --git a/tests/regrtest_data/func_block_disable_msg.py b/tests/regrtest_data/func_block_disable_msg.py
new file mode 100644
index 0000000..36198db
--- /dev/null
+++ b/tests/regrtest_data/func_block_disable_msg.py
@@ -0,0 +1,1026 @@
+# pylint: disable=C0302,bare-except,print-statement, useless-object-inheritance
+"""pylint option block-disable"""
+from __future__ import print_function
+
+class Foo(object):
+ """block-disable test"""
+
+ def __init__(self):
+ self._test = "42"
+
+ def meth1(self, arg):
+ """this issues a message"""
+ print(self)
+
+ def meth2(self, arg):
+ """and this one not"""
+ # pylint: disable=W0613
+ print(self._test\
+ + "foo")
+
+ def meth3(self):
+ """test one line disabling"""
+ # no error
+ print(self.bla) # pylint: disable=E1101
+ # error
+ print(self.blop)
+
+ def meth4(self):
+ """test re-enabling"""
+ # pylint: disable=E1101
+ # no error
+ print(self.bla)
+ print(self.blop)
+ # pylint: enable=E1101
+ # error
+ print(self.blip)
+
+ def meth5(self):
+ """test IF sub-block re-enabling"""
+ # pylint: disable=E1101
+ # no error
+ print(self.bla)
+ if self.blop:
+ # pylint: enable=E1101
+ # error
+ print(self.blip)
+ else:
+ # no error
+ print(self.blip)
+ # no error
+ print(self.blip)
+
+ def meth6(self):
+ """test TRY/EXCEPT sub-block re-enabling"""
+ # pylint: disable=E1101
+ # no error
+ print(self.bla)
+ try:
+ # pylint: enable=E1101
+ # error
+ print(self.blip)
+ except UndefinedName: # pylint: disable=E0602
+ # no error
+ print(self.blip)
+ # no error
+ print(self.blip)
+
+ def meth7(self):
+ """test one line block opening disabling"""
+ if self.blop: # pylint: disable=E1101
+ # error
+ print(self.blip)
+ else:
+ # error
+ print(self.blip)
+ # error
+ print(self.blip)
+
+
+ def meth8(self):
+ """test late disabling"""
+ # error
+ print(self.blip)
+ # pylint: disable=E1101
+ # no error
+ print(self.bla)
+ print(self.blop)
+
+ def meth9(self):
+ """test re-enabling right after a block with whitespace"""
+ eris = 5
+
+ if eris: # pylint: disable=using-constant-test
+ print("In block")
+
+ # pylint: disable=E1101
+ # no error
+ print(self.bla)
+ print(self.blu)
+ # pylint: enable=E1101
+ # error
+ print(self.blip)
+
+ def meth10(self):
+ """Test double disable"""
+ # pylint: disable=E1101
+ # no error
+ print(self.bla)
+ # pylint: disable=E1101
+ print(self.blu)
+
+
+class ClassLevelMessage(object):
+ """shouldn't display to much attributes/not enough methods messages
+ """
+ # pylint: disable=R0902,R0903
+
+ def __init__(self):
+ self.attr1 = 1
+ self.attr2 = 1
+ self.attr3 = 1
+ self.attr4 = 1
+ self.attr5 = 1
+ self.attr6 = 1
+ self.attr7 = 1
+ self.attr8 = 1
+ self.attr9 = 1
+ self.attr0 = 1
+
+ def too_complex_but_thats_ok(self, attr1, attr2):
+ """THIS Method has too much branches and returns but i don't care
+ """
+ # pylint: disable=R0912,R0911
+ try:
+ attr3 = attr1+attr2
+ except ValueError:
+ attr3 = None
+ except:
+ return 'duh', self
+ if attr1:
+ for i in attr1:
+ if attr2:
+ return i
+ else:
+ return 'duh'
+ elif attr2:
+ for i in attr2:
+ if attr2:
+ return i
+ else:
+ return 'duh'
+ else:
+ for i in range(15):
+ if attr3:
+ return i
+ else:
+ return 'doh'
+ return None
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+print('hop, too many lines but i don\'t care')
diff --git a/tests/regrtest_data/import_assign.py b/tests/regrtest_data/import_assign.py
new file mode 100644
index 0000000..c01cd52
--- /dev/null
+++ b/tests/regrtest_data/import_assign.py
@@ -0,0 +1,5 @@
+import shmixml.dom.minidom
+import xml.dom.minidom
+
+if 'dom' not in xml.__dict__:
+ xml.dom = shmixml.dom
diff --git a/tests/regrtest_data/import_package_subpackage_module.py b/tests/regrtest_data/import_package_subpackage_module.py
new file mode 100644
index 0000000..2864e3c
--- /dev/null
+++ b/tests/regrtest_data/import_package_subpackage_module.py
@@ -0,0 +1,49 @@
+# pylint: disable=I0011,C0301,W0611
+"""I found some of my scripts trigger off an AttributeError in pylint
+0.8.1 (with common 0.12.0 and astroid 0.13.1).
+
+Traceback (most recent call last):
+ File "/usr/bin/pylint", line 4, in ?
+ lint.Run(sys.argv[1:])
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 729, in __init__
+ linter.check(args)
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 412, in check
+ self.check_file(filepath, modname, checkers)
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 426, in check_file
+ astroid = self._check_file(filepath, modname, checkers)
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 450, in _check_file
+ self.check_astroid_module(astroid, checkers)
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 494, in check_astroid_module
+ self.astroid_events(astroid, [checker for checker in checkers
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 511, in astroid_events
+ self.astroid_events(child, checkers, _reversed_checkers)
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 511, in astroid_events
+ self.astroid_events(child, checkers, _reversed_checkers)
+ File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 508, in astroid_events
+ checker.visit(astroid)
+ File "/usr/lib/python2.4/site-packages/logilab/astroid/utils.py", line 84, in visit
+ method(node)
+ File "/usr/lib/python2.4/site-packages/pylint/checkers/variables.py", line 295, in visit_import
+ self._check_module_attrs(node, module, name_parts[1:])
+ File "/usr/lib/python2.4/site-packages/pylint/checkers/variables.py", line 357, in _check_module_attrs
+ self.add_message('E0611', args=(name, module.name),
+AttributeError: Import instance has no attribute 'name'
+
+
+You can reproduce it by:
+(1) create package structure like the following:
+
+package/
+ __init__.py
+ subpackage/
+ __init__.py
+ module.py
+
+(2) in package/__init__.py write:
+
+import subpackage
+
+(3) run pylint with a script importing package.subpackage.module.
+"""
+import package.subpackage.module
+__revision__ = '$Id: import_package_subpackage_module.py,v 1.1 2005-11-10 16:08:54 syt Exp $'
diff --git a/tests/regrtest_data/import_something.py b/tests/regrtest_data/import_something.py
new file mode 100644
index 0000000..3a74a71
--- /dev/null
+++ b/tests/regrtest_data/import_something.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring,unused-import
+
+import os
+import sys
diff --git a/tests/regrtest_data/init_wildcard/__init__.py b/tests/regrtest_data/init_wildcard/__init__.py
new file mode 100644
index 0000000..8a4b31c
--- /dev/null
+++ b/tests/regrtest_data/init_wildcard/__init__.py
@@ -0,0 +1 @@
+from empty import *
diff --git a/tests/regrtest_data/meta.py b/tests/regrtest_data/meta.py
new file mode 100644
index 0000000..7001207
--- /dev/null
+++ b/tests/regrtest_data/meta.py
@@ -0,0 +1,3 @@
+# pylint: disable=invalid-name, missing-docstring
+# pylint: disable=unbalanced-tuple-unpacking
+n = 42
diff --git a/tests/regrtest_data/module_global.py b/tests/regrtest_data/module_global.py
new file mode 100644
index 0000000..107d652
--- /dev/null
+++ b/tests/regrtest_data/module_global.py
@@ -0,0 +1,7 @@
+# pylint: disable=W0603,W0601,W0604,E0602,W0104
+"""was causing infinite recursion
+"""
+__revision__ = 1
+
+global GLOBAL_VAR
+GLOBAL_VAR.foo
diff --git a/tests/regrtest_data/no_stdout_encoding.py b/tests/regrtest_data/no_stdout_encoding.py
new file mode 100644
index 0000000..d72aa65
--- /dev/null
+++ b/tests/regrtest_data/no_stdout_encoding.py
@@ -0,0 +1,4 @@
+#-*- coding:iso-8859-1 -*-
+class test:
+ def __init__(self, dir):
+ testString = u"répertoire :\n%s !"%dir
diff --git a/tests/regrtest_data/numarray_import.py b/tests/regrtest_data/numarray_import.py
new file mode 100644
index 0000000..e89757f
--- /dev/null
+++ b/tests/regrtest_data/numarray_import.py
@@ -0,0 +1,7 @@
+"""#10077"""
+
+__revision__ = 1
+
+from numarray import zeros
+
+zeros(shape=(4, 5))
diff --git a/tests/regrtest_data/numarray_inf.py b/tests/regrtest_data/numarray_inf.py
new file mode 100644
index 0000000..4ea22a9
--- /dev/null
+++ b/tests/regrtest_data/numarray_inf.py
@@ -0,0 +1,5 @@
+"""#3216"""
+
+import numarray as na
+import numarray.random_array as nar
+IM16 = nar.randint(0, 256, 300).astype(na.UInt8)
diff --git a/tests/regrtest_data/package/AudioTime.py b/tests/regrtest_data/package/AudioTime.py
new file mode 100644
index 0000000..ef65143
--- /dev/null
+++ b/tests/regrtest_data/package/AudioTime.py
@@ -0,0 +1,3 @@
+"""test preceded by the AudioTime class in __init__.py"""
+
+__revision__ = 0
diff --git a/tests/regrtest_data/package/__init__.py b/tests/regrtest_data/package/__init__.py
new file mode 100644
index 0000000..10cc40f
--- /dev/null
+++ b/tests/regrtest_data/package/__init__.py
@@ -0,0 +1,15 @@
+# pylint: disable=R0903
+
+"""package's __init__ file"""
+
+from . import subpackage
+
+__revision__ = 0
+
+# E0602 - Undefined variable '__path__'
+__path__ += "folder"
+
+class AudioTime:
+ """test precedence over the AudioTime submodule"""
+
+ DECIMAL = 3
diff --git a/tests/regrtest_data/package/subpackage/__init__.py b/tests/regrtest_data/package/subpackage/__init__.py
new file mode 100644
index 0000000..dc4782e
--- /dev/null
+++ b/tests/regrtest_data/package/subpackage/__init__.py
@@ -0,0 +1 @@
+"""package.subpackage"""
diff --git a/tests/regrtest_data/package/subpackage/module.py b/tests/regrtest_data/package/subpackage/module.py
new file mode 100644
index 0000000..4b7244b
--- /dev/null
+++ b/tests/regrtest_data/package/subpackage/module.py
@@ -0,0 +1 @@
+"""package.subpackage.module"""
diff --git a/tests/regrtest_data/package_all/__init__.py b/tests/regrtest_data/package_all/__init__.py
new file mode 100644
index 0000000..4e3696b
--- /dev/null
+++ b/tests/regrtest_data/package_all/__init__.py
@@ -0,0 +1,3 @@
+""" Check for E0603 for missing submodule found in __all__ """
+__revision__ = 1
+__all__ = ['notmissing', 'missing']
diff --git a/tests/regrtest_data/package_all/notmissing.py b/tests/regrtest_data/package_all/notmissing.py
new file mode 100644
index 0000000..7cf8543
--- /dev/null
+++ b/tests/regrtest_data/package_all/notmissing.py
@@ -0,0 +1,2 @@
+""" empty """
+__revision__ = 1
diff --git a/tests/regrtest_data/precedence_test.py b/tests/regrtest_data/precedence_test.py
new file mode 100644
index 0000000..ff5871d
--- /dev/null
+++ b/tests/regrtest_data/precedence_test.py
@@ -0,0 +1,21 @@
+"""
+ # package/__init__.py
+ class AudioTime(object):
+ DECIMAL = 3
+
+ # package/AudioTime.py
+ class AudioTime(object):
+ pass
+
+ # test.py
+ from package import AudioTime
+ # E0611 - No name 'DECIMAL' in module 'AudioTime.AudioTime'
+ print AudioTime.DECIMAL
+
+"""
+from __future__ import print_function
+from package import AudioTime
+__revision__ = 0
+
+
+print(AudioTime.DECIMAL)
diff --git a/tests/regrtest_data/py3k-disabled.rc b/tests/regrtest_data/py3k-disabled.rc
new file mode 100644
index 0000000..41d7757
--- /dev/null
+++ b/tests/regrtest_data/py3k-disabled.rc
@@ -0,0 +1,2 @@
+[MESSAGES CONTROL]
+disable=no-absolute-import
diff --git a/tests/regrtest_data/py3k_error_flag.py b/tests/regrtest_data/py3k_error_flag.py
new file mode 100644
index 0000000..6bead41
--- /dev/null
+++ b/tests/regrtest_data/py3k_error_flag.py
@@ -0,0 +1,11 @@
+"""Contains both normal error messages and Python3 porting error messages."""
+# pylint: disable=too-few-public-methods
+
+raise Exception, 1 # Error emitted here with the Python 3 checker.
+
+
+class Test(object):
+ """dummy"""
+
+ def __init__(self):
+ return 42
diff --git a/tests/regrtest_data/py3k_errors_and_warnings.py b/tests/regrtest_data/py3k_errors_and_warnings.py
new file mode 100644
index 0000000..3d033e8
--- /dev/null
+++ b/tests/regrtest_data/py3k_errors_and_warnings.py
@@ -0,0 +1,19 @@
+"""Contains both normal error messages and Python3 porting error messages."""
+# pylint: disable=too-few-public-methods
+
+# error: import missing `from __future__ import absolute_import`
+import sys
+
+# error: Use raise ErrorClass(args) instead of raise ErrorClass, args.
+raise Exception, 1
+
+class Test(object):
+ """dummy"""
+
+ def __init__(self):
+ # warning: Calling a dict.iter*() method
+ {1: 2}.iteritems()
+ return 42
+
+# error: print statement used
+print 'not in python3'
diff --git a/tests/regrtest_data/regression_missing_init_3564/subdirectory/file.py b/tests/regrtest_data/regression_missing_init_3564/subdirectory/file.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/regrtest_data/regression_missing_init_3564/subdirectory/file.py
diff --git a/tests/regrtest_data/special_attr_scope_lookup_crash.py b/tests/regrtest_data/special_attr_scope_lookup_crash.py
new file mode 100644
index 0000000..b693a9f
--- /dev/null
+++ b/tests/regrtest_data/special_attr_scope_lookup_crash.py
@@ -0,0 +1,3 @@
+class Klass(object):
+ """A"""
+ __doc__ += "B"
diff --git a/tests/regrtest_data/syntax_error.py b/tests/regrtest_data/syntax_error.py
new file mode 100644
index 0000000..cdc7c14
--- /dev/null
+++ b/tests/regrtest_data/syntax_error.py
@@ -0,0 +1 @@
+class A extends B {}
diff --git a/tests/regrtest_data/test_pylintrc_comments.py b/tests/regrtest_data/test_pylintrc_comments.py
new file mode 100644
index 0000000..ef8c403
--- /dev/null
+++ b/tests/regrtest_data/test_pylintrc_comments.py
@@ -0,0 +1,2 @@
+def f(x):
+ return x # 1 space
diff --git a/tests/regrtest_data/try_finally_disable_msg_crash.py b/tests/regrtest_data/try_finally_disable_msg_crash.py
new file mode 100644
index 0000000..1719308
--- /dev/null
+++ b/tests/regrtest_data/try_finally_disable_msg_crash.py
@@ -0,0 +1,5 @@
+try:
+ pass
+finally:
+ # pylint: disable=W0201
+ pass
diff --git a/tests/regrtest_data/unused_variable.py b/tests/regrtest_data/unused_variable.py
new file mode 100644
index 0000000..eee909d
--- /dev/null
+++ b/tests/regrtest_data/unused_variable.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring
+
+def test():
+ variable = ''
+ variable2 = None
+ return variable2
diff --git a/tests/regrtest_data/wildcard.py b/tests/regrtest_data/wildcard.py
new file mode 100644
index 0000000..8a4b31c
--- /dev/null
+++ b/tests/regrtest_data/wildcard.py
@@ -0,0 +1 @@
+from empty import *
diff --git a/tests/regrtest_data/wrong_import_position.py b/tests/regrtest_data/wrong_import_position.py
new file mode 100644
index 0000000..9e2d099
--- /dev/null
+++ b/tests/regrtest_data/wrong_import_position.py
@@ -0,0 +1,11 @@
+"""Test that wrong-import-position is properly reset when
+other errors are disabled.
+"""
+# pylint: disable=unused-import, too-few-public-methods
+
+
+class Something(object):
+ """A class before an import."""
+
+
+import os
diff --git a/tests/test_check_parallel.py b/tests/test_check_parallel.py
new file mode 100644
index 0000000..fc437be
--- /dev/null
+++ b/tests/test_check_parallel.py
@@ -0,0 +1,403 @@
+"""Puts the check_parallel system under test"""
+# Copyright (c) 2020-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+# pylint: disable=protected-access,missing-function-docstring,no-self-use
+
+import collections
+import os
+
+import pytest
+
+import pylint.interfaces
+import pylint.lint.parallel
+from pylint.checkers.base_checker import BaseChecker
+from pylint.lint import PyLinter
+from pylint.lint.parallel import _worker_check_single_file as worker_check_single_file
+from pylint.lint.parallel import _worker_initialize as worker_initialize
+from pylint.lint.parallel import check_parallel
+from pylint.testutils import GenericTestReporter as Reporter
+
+
+def _gen_file_data(idx=0):
+ """Generates a file to use as a stream"""
+ filepath = os.path.abspath(
+ os.path.join(os.path.dirname(__file__), "input", "similar1")
+ )
+ file_data = (
+ "--test-file_data-name-%d--" % idx,
+ filepath,
+ "--test-file_data-modname-%d--" % idx,
+ )
+ return file_data
+
+
+def _gen_file_datas(count=1):
+ return [_gen_file_data(idx) for idx in range(count)]
+
+
+class SequentialTestChecker(BaseChecker):
+ """A checker that does not need to consolidate data across run invocations"""
+
+ __implements__ = (pylint.interfaces.IRawChecker,)
+
+ name = "sequential-checker"
+ test_data = "sequential"
+ msgs = {
+ "R9999": (
+ "Test",
+ "sequential-test-check",
+ "Some helpful text.",
+ )
+ }
+
+ def __init__(self, linter, *args, **kwargs):
+ super().__init__(linter, *args, **kwargs)
+ self.data = []
+ self.linter = linter
+
+ def process_module(self, _astroid):
+ """Called once per stream/file/astroid object"""
+ # record the number of invocations with the data object
+ record = self.test_data + str(len(self.data))
+ self.data.append(record)
+
+
+class ExtraSequentialTestChecker(SequentialTestChecker):
+ """A checker that does not need to consolidate data across run invocations"""
+
+ name = "extra-sequential-checker"
+ test_data = "extra-sequential"
+
+
+class ThirdSequentialTestChecker(SequentialTestChecker):
+ """A checker that does not need to consolidate data across run invocations"""
+
+ name = "third-sequential-checker"
+ test_data = "third-sequential"
+
+
+class TestCheckParallelFramework:
+ """Tests the check_parallel() function's framework"""
+
+ def setup_class(self):
+ self._prev_global_linter = pylint.lint.parallel._worker_linter
+
+ def teardown_class(self):
+ pylint.lint.parallel._worker_linter = self._prev_global_linter
+
+ def test_worker_initialize(self):
+ linter = PyLinter(reporter=Reporter())
+ worker_initialize(linter=linter)
+ assert pylint.lint.parallel._worker_linter == linter
+
+ def test_worker_check_single_file_uninitialised(self):
+ pylint.lint.parallel._worker_linter = None
+ with pytest.raises( # Objects that do not match the linter interface will fail
+ AttributeError, match="'NoneType' object has no attribute 'open'"
+ ):
+ worker_check_single_file(_gen_file_data())
+
+ def test_worker_check_single_file_no_checkers(self):
+ linter = PyLinter(reporter=Reporter())
+ worker_initialize(linter=linter)
+
+ (
+ _, # proc-id
+ name,
+ _, # file_path
+ _, # base_name
+ msgs,
+ stats,
+ msg_status,
+ _, # mapreduce_data
+ ) = worker_check_single_file(_gen_file_data())
+ assert name == "--test-file_data-name-0--"
+ assert [] == msgs
+ no_errors_status = 0
+ assert no_errors_status == msg_status
+ assert {
+ "by_module": {
+ "--test-file_data-name-0--": {
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ }
+ },
+ "by_msg": {},
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ } == stats
+
+ def test_worker_check_sequential_checker(self):
+ """Same as test_worker_check_single_file_no_checkers with SequentialTestChecker"""
+ linter = PyLinter(reporter=Reporter())
+ worker_initialize(linter=linter)
+
+ # Add the only checker we care about in this test
+ linter.register_checker(SequentialTestChecker(linter))
+
+ (
+ _, # proc-id
+ name,
+ _, # file_path
+ _, # base_name
+ msgs,
+ stats,
+ msg_status,
+ _, # mapreduce_data
+ ) = worker_check_single_file(_gen_file_data())
+
+ # Ensure we return the same data as the single_file_no_checkers test
+ assert name == "--test-file_data-name-0--"
+ assert [] == msgs
+ no_errors_status = 0
+ assert no_errors_status == msg_status
+ assert {
+ "by_module": {
+ "--test-file_data-name-0--": {
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ }
+ },
+ "by_msg": {},
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ } == stats
+
+
+class TestCheckParallel:
+ """Tests the check_parallel() function"""
+
+ def test_sequential_checkers_work(self):
+ """Tests original basic types of checker works as expected in -jN
+
+ This means that a sequential checker should return the same data for a given
+ file-stream irrespective of whether its run in -j1 or -jN
+ """
+ linter = PyLinter(reporter=Reporter())
+
+ # Add a sequential checker to ensure it records data against some streams
+ linter.register_checker(SequentialTestChecker(linter))
+ linter.enable("R9999")
+
+ # Create a dummy file, the actual contents of which will be ignored by the
+ # register test checkers, but it will trigger at least a single-job to be run.
+ single_file_container = _gen_file_datas(count=1)
+
+ # Invoke the lint process in a multiprocess way, although we only specify one
+ # job.
+ check_parallel(linter, jobs=1, files=single_file_container, arguments=None)
+ assert len(linter.get_checkers()) == 2, (
+ "We should only have the 'master' and 'sequential-checker' "
+ "checkers registered"
+ )
+ assert {
+ "by_module": {
+ "--test-file_data-name-0--": {
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ }
+ },
+ "by_msg": {},
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ } == linter.stats
+
+ # now run the regular mode of checking files and check that, in this proc, we
+ # collect the right data
+ filepath = single_file_container[0][1] # get the filepath element
+ linter.check(filepath)
+ assert {
+ "by_module": {
+ "input.similar1": { # module is the only change from previous
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ }
+ },
+ "by_msg": {},
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ } == linter.stats
+
+ def test_invoke_single_job(self):
+ """Tests basic checkers functionality using just a single workderdo
+
+ This is *not* the same -j1 and does not happen under normal operation"""
+ linter = PyLinter(reporter=Reporter())
+
+ linter.register_checker(SequentialTestChecker(linter))
+
+ # Create a dummy file, the actual contents of which will be ignored by the
+ # register test checkers, but it will trigger at least a single-job to be run.
+ single_file_container = _gen_file_datas(count=1)
+
+ # Invoke the lint process in a multiprocess way, although we only specify one
+ # job.
+ check_parallel(linter, jobs=1, files=single_file_container, arguments=None)
+
+ assert {
+ "by_module": {
+ "--test-file_data-name-0--": {
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ }
+ },
+ "by_msg": collections.Counter(),
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ } == linter.stats
+ assert linter.msg_status == 0, "We expect a single-file check to exit cleanly"
+
+ @pytest.mark.parametrize(
+ "num_files,num_jobs,num_checkers",
+ [
+ (1, 2, 1),
+ (1, 2, 2),
+ (1, 2, 3),
+ (2, 2, 1),
+ (2, 2, 2),
+ (2, 2, 3),
+ (3, 2, 1),
+ (3, 2, 2),
+ (3, 2, 3),
+ (3, 1, 1),
+ (3, 1, 2),
+ (3, 1, 3),
+ (3, 5, 1),
+ (3, 5, 2),
+ (3, 5, 3),
+ (10, 2, 1),
+ (10, 2, 2),
+ (10, 2, 3),
+ (2, 10, 1),
+ (2, 10, 2),
+ (2, 10, 3),
+ ],
+ )
+ def test_compare_workers_to_single_proc(self, num_files, num_jobs, num_checkers):
+ """Compares the 3 key parameters for check_parallel() produces the same results
+
+ The intent here is to ensure that the check_parallel() operates on each file,
+ without ordering issues, irrespective of the number of workers used and the
+ number of checkers applied.
+
+ This test becomes more important if we want to change how we parametrise the
+ checkers, for example if we aim to batch the files across jobs."""
+
+ # define the stats we expect to get back from the runs, these should only vary
+ # with the number of files.
+ expected_stats = {
+ "by_module": {
+ "--test-file_data-name-%d--"
+ % idx: {
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18,
+ "warning": 0,
+ }
+ for idx in range(num_files)
+ },
+ "by_msg": {},
+ "convention": 0,
+ "error": 0,
+ "fatal": 0,
+ "info": 0,
+ "refactor": 0,
+ "statement": 18 * num_files,
+ "warning": 0,
+ }
+
+ file_infos = _gen_file_datas(num_files)
+
+ # Loop for single-proc and mult-proc so we can ensure the same linter-config
+ for do_single_proc in range(2):
+ linter = PyLinter(reporter=Reporter())
+
+ # Assign between 1 and 3 checkers to the linter, they should not change the
+ # results of the lint
+ linter.register_checker(SequentialTestChecker(linter))
+ if num_checkers > 1:
+ linter.register_checker(ExtraSequentialTestChecker(linter))
+ if num_checkers > 2:
+ linter.register_checker(ThirdSequentialTestChecker(linter))
+
+ if do_single_proc:
+ # establish the baseline
+ assert (
+ linter.config.jobs == 1
+ ), "jobs>1 are ignored when calling _check_files"
+ linter._check_files(linter.get_ast, file_infos)
+ assert linter.msg_status == 0, "We should not fail the lint"
+ stats_single_proc = linter.stats
+ else:
+ check_parallel(
+ linter,
+ jobs=num_jobs,
+ files=file_infos,
+ arguments=None,
+ )
+ stats_check_parallel = linter.stats
+ assert linter.msg_status == 0, "We should not fail the lint"
+
+ assert (
+ stats_single_proc == stats_check_parallel
+ ), "Single-proc and check_parallel() should return the same thing"
+ assert (
+ stats_check_parallel == expected_stats
+ ), "The lint is returning unexpected results, has something changed?"
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 0000000..ecfac33
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,93 @@
+# pylint: disable=missing-module-docstring, missing-function-docstring, protected-access
+import unittest.mock
+
+import pylint.lint
+
+
+def check_configuration_file_reader(config_file):
+ """Initialize pylint with the given configuration file and check that
+ what we initialized the linter with what was expected.
+ """
+ args = ["--rcfile", str(config_file), __file__]
+ # If we used `pytest.raises(SystemExit)`, the `runner` variable
+ # would not be accessible outside the `with` block.
+ with unittest.mock.patch("sys.exit") as mocked_exit:
+ # Do not actually run checks, that could be slow. Do not mock
+ # `Pylinter.check`: it calls `Pylinter.initialize` which is
+ # needed to properly set up messages inclusion/exclusion
+ # in `_msg_states`, used by `is_message_enabled`.
+ with unittest.mock.patch("pylint.lint.pylinter.check_parallel"):
+ runner = pylint.lint.Run(args)
+
+ # "logging-not-lazy" and "logging-format-interpolation"
+ expected_disabled = {"W1201", "W1202"}
+ for msgid in expected_disabled:
+ assert not runner.linter.is_message_enabled(msgid)
+ assert runner.linter.config.jobs == 10
+ assert runner.linter.config.reports
+
+ mocked_exit.assert_called_once_with(0)
+ return runner
+
+
+def test_can_read_ini(tmp_path):
+ # Check that we can read the "regular" INI .pylintrc file
+ config_file = tmp_path / ".pylintrc"
+ config_file.write_text(
+ """
+[messages control]
+disable = logging-not-lazy,logging-format-interpolation
+jobs = 10
+reports = yes
+"""
+ )
+ check_configuration_file_reader(config_file)
+
+
+def test_can_read_setup_cfg(tmp_path):
+ # Check that we can read a setup.cfg (which is an INI file where
+ # section names are prefixed with "pylint."
+ config_file = tmp_path / "setup.cfg"
+ config_file.write_text(
+ """
+[pylint.messages control]
+disable = logging-not-lazy,logging-format-interpolation
+jobs = 10
+reports = yes
+"""
+ )
+ check_configuration_file_reader(config_file)
+
+
+def test_can_read_toml(tmp_path):
+ # Check that we can read a TOML file where lists and integers are
+ # expressed as strings.
+ config_file = tmp_path / "pyproject.toml"
+ config_file.write_text(
+ """
+[tool.pylint."messages control"]
+disable = "logging-not-lazy,logging-format-interpolation"
+jobs = "10"
+reports = "yes"
+"""
+ )
+ check_configuration_file_reader(config_file)
+
+
+def test_can_read_toml_rich_types(tmp_path):
+ # Check that we can read a TOML file where lists, integers and
+ # booleans are expressed as such (and not as strings), using TOML
+ # type system.
+ config_file = tmp_path / "pyproject.toml"
+ config_file.write_text(
+ """
+[tool.pylint."messages control"]
+disable = [
+ "logging-not-lazy",
+ "logging-format-interpolation",
+]
+jobs = 10
+reports = true
+"""
+ )
+ check_configuration_file_reader(config_file)
diff --git a/tests/test_epylint.py b/tests/test_epylint.py
new file mode 100644
index 0000000..a53c2b0
--- /dev/null
+++ b/tests/test_epylint.py
@@ -0,0 +1,61 @@
+"""Test for issue https://github.com/PyCQA/pylint/issues/4286"""
+# pylint: disable=redefined-outer-name
+import pytest
+
+from pylint import epylint as lint
+
+
+@pytest.fixture()
+def example_path(tmp_path):
+ content = """class IvrAudioApp:
+
+ def run(self):
+ self.hassan()
+ """
+ path = tmp_path / "my_app.py"
+ with open(path, "w") as f:
+ f.write(content)
+ return path
+
+
+def test_epylint_good_command(example_path):
+ out, err = lint.py_run(
+ "%s -E --disable=E1111 --msg-template '{category} {module} {obj} {line} {column} {msg}'"
+ % example_path,
+ return_std=True,
+ )
+ msg = out.read()
+ assert (
+ msg
+ == """\
+************* Module my_app
+ error my_app IvrAudioApp.run 4 8 Instance of 'IvrAudioApp' has no 'hassan' member
+ """
+ )
+ assert err.read() == ""
+
+
+def test_epylint_strange_command(example_path):
+ out, err = lint.py_run(
+ "%s -E --disable=E1111 --msg-template={category} {module} {obj} {line} {column} {msg}"
+ % example_path,
+ return_std=True,
+ )
+ assert (
+ out.read()
+ == """\
+************* Module {module}
+ fatal
+ ************* Module {obj}
+ fatal
+ ************* Module {line}
+ fatal
+ ************* Module {column}
+ fatal
+ ************* Module {msg}
+ fatal
+ ************* Module my_app
+ error
+ """
+ )
+ assert err.read() == ""
diff --git a/tests/test_func.py b/tests/test_func.py
new file mode 100644
index 0000000..15edf59
--- /dev/null
+++ b/tests/test_func.py
@@ -0,0 +1,173 @@
+# Copyright (c) 2006-2010, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Michka Popoff <michkapopoff@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""functional/non regression tests for pylint"""
+
+import re
+import sys
+from os.path import abspath, dirname, join
+
+import pytest
+
+from pylint.testutils import UPDATE_FILE, UPDATE_OPTION, _get_tests_info, linter
+
+INPUT_DIR = join(dirname(abspath(__file__)), "input")
+MSG_DIR = join(dirname(abspath(__file__)), "messages")
+
+
+FILTER_RGX = None
+INFO_TEST_RGX = re.compile(r"^func_i\d\d\d\d$")
+
+
+def exception_str(self, ex): # pylint: disable=unused-argument
+ """function used to replace default __str__ method of exception instances"""
+ return "in {}\n:: {}".format(ex.file, ", ".join(ex.args))
+
+
+class LintTestUsingModule:
+ INPUT_DIR = None
+ DEFAULT_PACKAGE = "input"
+ package = DEFAULT_PACKAGE
+ linter = linter
+ module = None
+ depends = None
+ output = None
+
+ def _test_functionality(self):
+ tocheck = [self.package + "." + self.module]
+ # pylint: disable=not-an-iterable; can't handle boolean checks for now
+ if self.depends:
+ tocheck += [
+ self.package + ".%s" % name.replace(".py", "")
+ for name, _ in self.depends
+ ]
+ self._test(tocheck)
+
+ def _check_result(self, got):
+ error_msg = (
+ f"Wrong output for '{self.output}':\n"
+ "You can update the expected output automatically with: '"
+ f"python tests/test_func.py {UPDATE_OPTION}'\n\n"
+ )
+ assert self._get_expected() == got, error_msg
+
+ def _test(self, tocheck):
+ if INFO_TEST_RGX.match(self.module):
+ self.linter.enable("I")
+ else:
+ self.linter.disable("I")
+ try:
+ self.linter.check(tocheck)
+ except Exception as ex:
+ # need finalization to restore a correct state
+ self.linter.reporter.finalize()
+ ex.file = tocheck
+ print(ex)
+ ex.__str__ = exception_str
+ raise
+ self._check_result(self.linter.reporter.finalize())
+
+ def _has_output(self):
+ return not self.module.startswith("func_noerror_")
+
+ def _get_expected(self):
+ if self._has_output() and self.output:
+ with open(self.output) as fobj:
+ return fobj.read().strip() + "\n"
+ else:
+ return ""
+
+
+class LintTestUpdate(LintTestUsingModule):
+ def _check_result(self, got):
+ if not self._has_output():
+ return
+ try:
+ expected = self._get_expected()
+ except OSError:
+ expected = ""
+ if got != expected:
+ with open(self.output, "w") as f:
+ f.write(got)
+
+
+def gen_tests(filter_rgx):
+ if filter_rgx:
+ is_to_run = re.compile(filter_rgx).search
+ else:
+ is_to_run = lambda x: 1 # noqa: E731 We're going to throw all this anyway
+ tests = []
+ for module_file, messages_file in _get_tests_info(INPUT_DIR, MSG_DIR, "func_", ""):
+ if not is_to_run(module_file) or module_file.endswith((".pyc", "$py.class")):
+ continue
+ base = module_file.replace(".py", "").split("_")[1]
+ dependencies = _get_tests_info(INPUT_DIR, MSG_DIR, base, ".py")
+ tests.append((module_file, messages_file, dependencies))
+ if UPDATE_FILE.exists():
+ return tests
+ assert len(tests) < 12, "Please do not add new test cases here." + "\n".join(
+ str(k) for k in tests if not k[2]
+ )
+ return tests
+
+
+TEST_WITH_EXPECTED_DEPRECATION = ["func_excess_escapes.py"]
+
+
+@pytest.mark.parametrize(
+ "module_file,messages_file,dependencies",
+ gen_tests(FILTER_RGX),
+ ids=[o[0] for o in gen_tests(FILTER_RGX)],
+)
+def test_functionality(module_file, messages_file, dependencies, recwarn):
+ __test_functionality(module_file, messages_file, dependencies)
+ warning = None
+ try:
+ # Catch <unknown>:x: DeprecationWarning: invalid escape sequence
+ # so it's not shown during tests
+ warning = recwarn.pop()
+ except AssertionError:
+ pass
+ if warning is not None:
+ if module_file in TEST_WITH_EXPECTED_DEPRECATION and sys.version_info.minor > 5:
+ assert issubclass(warning.category, DeprecationWarning)
+ assert "invalid escape sequence" in str(warning.message)
+
+
+def __test_functionality(module_file, messages_file, dependencies):
+ lint_test = LintTestUpdate() if UPDATE_FILE.exists() else LintTestUsingModule()
+ lint_test.module = module_file.replace(".py", "")
+ lint_test.output = messages_file
+ lint_test.depends = dependencies or None
+ lint_test.INPUT_DIR = INPUT_DIR
+ lint_test._test_functionality()
+
+
+if __name__ == "__main__":
+ if UPDATE_OPTION in sys.argv:
+ UPDATE_FILE.touch()
+ sys.argv.remove(UPDATE_OPTION)
+ if len(sys.argv) > 1:
+ FILTER_RGX = sys.argv[1]
+ del sys.argv[1]
+ try:
+ pytest.main(sys.argv)
+ finally:
+ if UPDATE_FILE.exists():
+ UPDATE_FILE.unlink()
diff --git a/tests/test_functional.py b/tests/test_functional.py
new file mode 100644
index 0000000..c42cb0c
--- /dev/null
+++ b/tests/test_functional.py
@@ -0,0 +1,130 @@
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Lucas Cimon <lucas.cimon@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Mr. Senko <atodorov@mrsenko.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2020 bernie gray <bfgray3@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Functional full-module tests for PyLint."""
+import csv
+import os
+import sys
+
+import pytest
+
+from pylint import testutils
+from pylint.testutils import UPDATE_FILE, UPDATE_OPTION
+from pylint.utils import HAS_ISORT_5
+
+# Notes:
+# - for the purpose of this test, the confidence levels HIGH and UNDEFINED
+# are treated as the same.
+
+# TODOs
+# - implement exhaustivity tests
+
+# 'Wet finger' number of files that are reasonable to display by an IDE
+# 'Wet finger' as in 'in my settings there are precisely this many'.
+REASONABLY_DISPLAYABLE_VERTICALLY = 48
+
+
+class LintModuleOutputUpdate(testutils.LintModuleTest):
+ """If message files should be updated instead of checked."""
+
+ class TestDialect(csv.excel):
+ delimiter = ":"
+ lineterminator = "\n"
+
+ csv.register_dialect("test", TestDialect)
+
+ def _check_output_text(self, _, expected_output, actual_output):
+ if expected_output and expected_output == actual_output:
+ return
+ if not expected_output and not actual_output:
+ if os.path.exists(self._test_file.expected_output):
+ os.remove(self._test_file.expected_output)
+ return
+ with open(self._test_file.expected_output, "w") as f:
+ writer = csv.writer(f, dialect="test")
+ for line in actual_output:
+ writer.writerow(line.to_csv())
+
+
+def get_tests():
+ input_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "functional")
+ suite = []
+ for dirpath, _, filenames in os.walk(input_dir):
+ if dirpath.endswith("__pycache__"):
+ continue
+
+ assert (
+ len(filenames) <= REASONABLY_DISPLAYABLE_VERTICALLY
+ ), f"{dirpath} contain too much functional tests files."
+
+ for filename in filenames:
+ if filename != "__init__.py" and filename.endswith(".py"):
+ # isort 5 has slightly different rules as isort 4. Testing
+ # both would be hard: test with isort 5 only.
+ if filename == "wrong_import_order.py" and not HAS_ISORT_5:
+ continue
+ suite.append(testutils.FunctionalTestFile(dirpath, filename))
+ return suite
+
+
+TESTS = get_tests()
+TESTS_NAMES = [t.base for t in TESTS]
+TEST_WITH_EXPECTED_DEPRECATION = [
+ "future_unicode_literals",
+ "anomalous_unicode_escape_py3",
+]
+
+
+@pytest.mark.parametrize("test_file", TESTS, ids=TESTS_NAMES)
+def test_functional(test_file, recwarn, pytestconfig):
+ __tracebackhide__ = True # pylint: disable=unused-variable
+ if UPDATE_FILE.exists():
+ lint_test = LintModuleOutputUpdate(test_file, pytestconfig)
+ else:
+ lint_test = testutils.LintModuleTest(test_file, pytestconfig)
+ lint_test.setUp()
+ lint_test.runTest()
+ warning = None
+ try:
+ # Catch <unknown>:x: DeprecationWarning: invalid escape sequence
+ # so it's not shown during tests
+ warning = recwarn.pop()
+ except AssertionError:
+ pass
+ if warning is not None:
+ if (
+ test_file.base in TEST_WITH_EXPECTED_DEPRECATION
+ and sys.version_info.minor > 5
+ ):
+ assert issubclass(warning.category, DeprecationWarning)
+ assert "invalid escape sequence" in str(warning.message)
+
+
+if __name__ == "__main__":
+ if UPDATE_OPTION in sys.argv:
+ UPDATE_FILE.touch()
+ sys.argv.remove(UPDATE_OPTION)
+ try:
+ pytest.main(sys.argv)
+ finally:
+ if UPDATE_FILE.exists():
+ UPDATE_FILE.unlink()
diff --git a/tests/test_import_graph.py b/tests/test_import_graph.py
new file mode 100644
index 0000000..7cbaea2
--- /dev/null
+++ b/tests/test_import_graph.py
@@ -0,0 +1,110 @@
+# Copyright (c) 2006-2008, 2010, 2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Andrew Howe <howeaj@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+# pylint: disable=redefined-outer-name
+
+import os
+import shutil
+from os.path import exists
+
+import pytest
+
+from pylint import testutils
+from pylint.checkers import imports, initialize
+from pylint.lint import PyLinter
+
+
+@pytest.fixture
+def dest(request):
+ dest = request.param
+ yield dest
+ try:
+ os.remove(dest)
+ except FileNotFoundError:
+ # file may not have been created if tests inside fixture skipped
+ pass
+
+
+POSSIBLE_DOT_FILENAMES = ["foo.dot", "foo.gv", "tests/regrtest_data/foo.dot"]
+
+
+@pytest.mark.parametrize("dest", POSSIBLE_DOT_FILENAMES, indirect=True)
+def test_dependencies_graph(dest):
+ """DOC files are correctly generated, and the graphname is the basename"""
+ imports._dependencies_graph(dest, {"labas": ["hoho", "yep"], "hoho": ["yep"]})
+ with open(dest) as stream:
+ assert (
+ stream.read().strip()
+ == """
+digraph "foo" {
+rankdir=LR
+charset="utf-8"
+URL="." node[shape="box"]
+"hoho" [];
+"yep" [];
+"labas" [];
+"yep" -> "hoho" [];
+"hoho" -> "labas" [];
+"yep" -> "labas" [];
+}
+""".strip()
+ )
+
+
+@pytest.mark.parametrize("filename", ["graph.png", "graph"])
+@pytest.mark.skipif(
+ any(shutil.which(x) for x in ("dot", "gv")), reason="dot or gv is installed"
+)
+def test_missing_graphviz(filename):
+ """Raises if graphviz is not installed, and defaults to png if no extension given"""
+ with pytest.raises(RuntimeError, match=r"Cannot generate `graph\.png`.*"):
+ imports._dependencies_graph(filename, {"a": ["b", "c"], "b": ["c"]})
+
+
+@pytest.fixture
+def linter():
+ pylinter = PyLinter(reporter=testutils.GenericTestReporter())
+ initialize(pylinter)
+ return pylinter
+
+
+@pytest.fixture
+def remove_files():
+ yield
+ for fname in ("import.dot", "ext_import.dot", "int_import.dot"):
+ try:
+ os.remove(fname)
+ except FileNotFoundError:
+ pass
+
+
+@pytest.mark.usefixtures("remove_files")
+def test_checker_dep_graphs(linter):
+ linter.global_set_option("persistent", False)
+ linter.global_set_option("reports", True)
+ linter.global_set_option("enable", "imports")
+ linter.global_set_option("import-graph", "import.dot")
+ linter.global_set_option("ext-import-graph", "ext_import.dot")
+ linter.global_set_option("int-import-graph", "int_import.dot")
+ linter.global_set_option("int-import-graph", "int_import.dot")
+ # ignore this file causing spurious MemoryError w/ some python version (>=2.3?)
+ linter.global_set_option("ignore", ("func_unknown_encoding.py",))
+ linter.check("input")
+ linter.generate_reports()
+ assert exists("import.dot")
+ assert exists("ext_import.dot")
+ assert exists("int_import.dot")
diff --git a/tests/test_numversion.py b/tests/test_numversion.py
new file mode 100644
index 0000000..d1f459a
--- /dev/null
+++ b/tests/test_numversion.py
@@ -0,0 +1,26 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import pytest
+
+from pylint.__pkginfo__ import get_numversion_from_version
+
+
+@pytest.mark.parametrize(
+ "version,expected_numversion",
+ [
+ ["2.8.1", (2, 8, 1)],
+ ["2.8.2+", (2, 8, 2)],
+ ["3.0.0a0", (3, 0, 0)],
+ ["3..0", (3, 0, 0)],
+ ["1.a", (1, 0, 0)],
+ ["", (0, 0, 0)],
+ ["3.0.0b1", (3, 0, 0)],
+ ["3.0.0rc1", (3, 0, 0)],
+ ["3.0.0dev-234324234234f23abc4", (3, 0, 0)],
+ ["pylint-2.4.7", (2, 4, 7)],
+ ["2.8.3.dev3+g28c093c2.d20210428", (2, 8, 3)],
+ ],
+)
+def test_numversion(version, expected_numversion):
+ assert get_numversion_from_version(version) == expected_numversion
diff --git a/tests/test_pragma_parser.py b/tests/test_pragma_parser.py
new file mode 100644
index 0000000..0dec8ac
--- /dev/null
+++ b/tests/test_pragma_parser.py
@@ -0,0 +1,100 @@
+import pytest
+
+from pylint.utils.pragma_parser import (
+ OPTION_PO,
+ InvalidPragmaError,
+ UnRecognizedOptionError,
+ parse_pragma,
+)
+
+
+def test_simple_pragma():
+ comment = "#pylint: disable = missing-docstring"
+ match = OPTION_PO.search(comment)
+ for pragma_repr in parse_pragma(match.group(2)):
+ assert pragma_repr.action == "disable"
+ assert pragma_repr.messages == ["missing-docstring"]
+
+
+def test_disable_checker_with_number_in_name():
+ comment = "#pylint: disable = j3-custom-checker"
+ match = OPTION_PO.search(comment)
+ for pragma_repr in parse_pragma(match.group(2)):
+ assert pragma_repr.action == "disable"
+ assert pragma_repr.messages == ["j3-custom-checker"]
+
+
+def test_simple_pragma_no_messages():
+ comment = "#pylint: skip-file"
+ match = OPTION_PO.search(comment)
+ for pragma_repr in parse_pragma(match.group(2)):
+ assert pragma_repr.action == "skip-file"
+ assert pragma_repr.messages == []
+
+
+def test_simple_pragma_multiple_messages():
+ comment = "#pylint: disable = missing-docstring, invalid-name"
+ match = OPTION_PO.search(comment)
+ for pragma_repr in parse_pragma(match.group(2)):
+ assert pragma_repr.action == "disable"
+ assert pragma_repr.messages == ["missing-docstring", "invalid-name"]
+
+
+def test_multiple_pragma_multiple_messages():
+ comment = "#pylint: disable = missing-docstring, invalid-name, enable = R0202, no-self-use"
+ match = OPTION_PO.search(comment)
+ res = list(parse_pragma(match.group(2)))
+ assert res[0].action == "disable"
+ assert res[0].messages == ["missing-docstring", "invalid-name"]
+ assert res[1].action == "enable"
+ assert res[1].messages == ["R0202", "no-self-use"]
+
+
+def test_missing_assignment():
+ comment = "#pylint: disable missing-docstring"
+ match = OPTION_PO.search(comment)
+ with pytest.raises(InvalidPragmaError):
+ list(parse_pragma(match.group(2)))
+
+
+def test_missing_keyword():
+ comment = "#pylint: = missing-docstring"
+ match = OPTION_PO.search(comment)
+ with pytest.raises(InvalidPragmaError):
+ list(parse_pragma(match.group(2)))
+
+
+def test_unsupported_assignment():
+ comment = "#pylint: disable-all = missing-docstring"
+ match = OPTION_PO.search(comment)
+ with pytest.raises(UnRecognizedOptionError):
+ list(parse_pragma(match.group(2)))
+
+
+def test_unknown_keyword_with_messages():
+ comment = "#pylint: unknown-keyword = missing-docstring"
+ match = OPTION_PO.search(comment)
+ with pytest.raises(UnRecognizedOptionError):
+ list(parse_pragma(match.group(2)))
+
+
+def test_unknown_keyword_without_messages():
+ comment = "#pylint: unknown-keyword"
+ match = OPTION_PO.search(comment)
+ with pytest.raises(UnRecognizedOptionError):
+ list(parse_pragma(match.group(2)))
+
+
+def test_missing_message():
+ comment = "#pylint: disable = "
+ match = OPTION_PO.search(comment)
+ with pytest.raises(InvalidPragmaError):
+ list(parse_pragma(match.group(2)))
+
+
+def test_parse_message_with_dash():
+ comment = "#pylint: disable = raw_input-builtin"
+ match = OPTION_PO.search(comment)
+ res = list(parse_pragma(match.group(2)))
+ assert res[0].action == "disable"
+ assert res[0].messages == ["raw_input-builtin"]
diff --git a/tests/test_pylint_runners.py b/tests/test_pylint_runners.py
new file mode 100644
index 0000000..1f3739e
--- /dev/null
+++ b/tests/test_pylint_runners.py
@@ -0,0 +1,20 @@
+# pylint: disable=missing-module-docstring, missing-function-docstring
+import os
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from pylint import run_epylint, run_pylint, run_pyreverse, run_symilar
+
+
+@pytest.mark.parametrize(
+ "runner", [run_pylint, run_epylint, run_pyreverse, run_symilar]
+)
+def test_runner(runner):
+ filepath = os.path.abspath(__file__)
+ testargs = ["", filepath]
+ with patch.object(sys, "argv", testargs):
+ with pytest.raises(SystemExit) as err:
+ runner()
+ assert err.value.code == 0
diff --git a/tests/test_regr.py b/tests/test_regr.py
new file mode 100644
index 0000000..995bab8
--- /dev/null
+++ b/tests/test_regr.py
@@ -0,0 +1,137 @@
+# Copyright (c) 2006-2011, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""non regression tests for pylint, which requires a too specific configuration
+to be incorporated in the automatic functional test framework
+"""
+# pylint: disable=redefined-outer-name
+
+import os
+import sys
+from os.path import abspath, dirname, join
+
+import astroid
+import pytest
+
+from pylint import testutils
+
+REGR_DATA = join(dirname(abspath(__file__)), "regrtest_data")
+sys.path.insert(1, REGR_DATA)
+
+
+@pytest.fixture(scope="module")
+def reporter():
+ return testutils.GenericTestReporter
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["I"]
+
+
+@pytest.fixture
+def finalize_linter(linter):
+ """call reporter.finalize() to cleanup
+ pending messages if a test finished badly
+ """
+ yield linter
+ linter.reporter.finalize()
+
+
+def Equals(expected):
+ return lambda got: got == expected
+
+
+@pytest.mark.parametrize(
+ "file_name, check",
+ [
+ ("package.__init__", Equals("")),
+ ("precedence_test", Equals("")),
+ ("import_package_subpackage_module", Equals("")),
+ ("pylint.checkers.__init__", lambda x: "__path__" not in x),
+ (join(REGR_DATA, "classdoc_usage.py"), Equals("")),
+ (join(REGR_DATA, "module_global.py"), Equals("")),
+ (join(REGR_DATA, "decimal_inference.py"), Equals("")),
+ (join(REGR_DATA, "absimp", "string.py"), Equals("")),
+ (join(REGR_DATA, "bad_package"), lambda x: "Unused import missing" in x),
+ ],
+)
+def test_package(finalize_linter, file_name, check):
+ finalize_linter.check(file_name)
+ got = finalize_linter.reporter.finalize().strip()
+ assert check(got)
+
+
+@pytest.mark.parametrize(
+ "file_name",
+ [
+ join(REGR_DATA, "import_assign.py"),
+ join(REGR_DATA, "special_attr_scope_lookup_crash.py"),
+ join(REGR_DATA, "try_finally_disable_msg_crash"),
+ ],
+)
+def test_crash(finalize_linter, file_name):
+ finalize_linter.check(file_name)
+
+
+@pytest.mark.parametrize(
+ "fname", [x for x in os.listdir(REGR_DATA) if x.endswith("_crash.py")]
+)
+def test_descriptor_crash(fname, finalize_linter):
+ finalize_linter.check(join(REGR_DATA, fname))
+ finalize_linter.reporter.finalize().strip()
+
+
+@pytest.fixture
+def modify_path():
+ cwd = os.getcwd()
+ sys.path.insert(0, "")
+ yield
+ sys.path.pop(0)
+ os.chdir(cwd)
+
+
+@pytest.mark.usefixtures("modify_path")
+def test_check_package___init__(finalize_linter):
+ filename = "package.__init__"
+ finalize_linter.check(filename)
+ checked = list(finalize_linter.stats["by_module"].keys())
+ assert checked == [filename]
+
+ os.chdir(join(REGR_DATA, "package"))
+ finalize_linter.check("__init__")
+ checked = list(finalize_linter.stats["by_module"].keys())
+ assert checked == ["__init__"]
+
+
+def test_pylint_config_attr():
+ mod = astroid.MANAGER.ast_from_module_name("pylint.lint.pylinter")
+ pylinter = mod["PyLinter"]
+ expect = [
+ "OptionsManagerMixIn",
+ "object",
+ "MessagesHandlerMixIn",
+ "ReportsHandlerMixIn",
+ "BaseTokenChecker",
+ "BaseChecker",
+ "OptionsProviderMixIn",
+ ]
+ assert [c.name for c in pylinter.ancestors()] == expect
+ assert list(astroid.Instance(pylinter).getattr("config"))
+ inferred = list(astroid.Instance(pylinter).igetattr("config"))
+ assert len(inferred) == 1
+ assert inferred[0].root().name == "optparse"
+ assert inferred[0].name == "Values"
diff --git a/tests/test_self.py b/tests/test_self.py
new file mode 100644
index 0000000..b47e174
--- /dev/null
+++ b/tests/test_self.py
@@ -0,0 +1,1201 @@
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Vlad Temian <vladtemian@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017, 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017, 2019 Thomas Hisch <t.hisch@gmail.com>
+# Copyright (c) 2017 Daniel Miller <millerdev@gmail.com>
+# Copyright (c) 2017 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Jason Owen <jason.a.owen@gmail.com>
+# Copyright (c) 2018 Jace Browning <jacebrowning@gmail.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+# Copyright (c) 2019 Hugues <hugues.bruant@affirm.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2020 Matěj Grabovský <mgrabovs@redhat.com>
+# Copyright (c) 2020 Pieter Engelbrecht <pengelbrecht@rems2.com>
+# Copyright (c) 2020 Clément Pit-Claudel <cpitclaudel@users.noreply.github.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Dr. Nick <das-intensity@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 chohner <mail@chohner.com>
+# Copyright (c) 2021 Louis Sautier <sautier.louis@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+# pylint: disable=too-many-public-methods
+
+import configparser
+import contextlib
+import json
+import os
+import platform
+import re
+import subprocess
+import sys
+import textwrap
+import warnings
+from copy import copy
+from io import StringIO
+from os.path import abspath, dirname, join
+from pathlib import Path
+from typing import Generator, Optional
+from unittest import mock
+from unittest.mock import patch
+
+import pytest
+
+from pylint import modify_sys_path
+from pylint.constants import MAIN_CHECKER_NAME, MSG_TYPES_STATUS
+from pylint.lint import Run
+from pylint.message import Message
+from pylint.reporters import JSONReporter
+from pylint.reporters.text import BaseReporter, ColorizedTextReporter, TextReporter
+from pylint.utils import utils
+
+HERE = abspath(dirname(__file__))
+CLEAN_PATH = re.escape(dirname(dirname(__file__)) + os.path.sep)
+UNNECESSARY_LAMBDA = join(
+ HERE, "functional", "u", "unnecessary", "unnecessary_lambda.py"
+)
+
+
+@contextlib.contextmanager
+def _patch_streams(out):
+ sys.stderr = sys.stdout = out
+ try:
+ yield
+ finally:
+ sys.stderr = sys.__stderr__
+ sys.stdout = sys.__stdout__
+
+
+@contextlib.contextmanager
+def _configure_lc_ctype(lc_ctype):
+ lc_ctype_env = "LC_CTYPE"
+ original_lctype = os.environ.get(lc_ctype_env)
+ os.environ[lc_ctype_env] = lc_ctype
+ try:
+ yield
+ finally:
+ os.environ.pop(lc_ctype_env)
+ if original_lctype:
+ os.environ[lc_ctype_env] = original_lctype
+
+
+class MultiReporter(BaseReporter):
+ def __init__(self, reporters):
+ # pylint: disable=super-init-not-called
+ # We don't call it because there is an attribute "linter" that is set inside the base class
+ # and we have another setter here using yet undefined attribute.
+ # I don't think fixing the init order in a test class used once is worth it.
+ self._reporters = reporters
+ self.path_strip_prefix = os.getcwd() + os.sep
+
+ def on_set_current_module(self, *args, **kwargs):
+ for rep in self._reporters:
+ rep.on_set_current_module(*args, **kwargs)
+
+ def handle_message(self, msg: Message) -> None:
+ for rep in self._reporters:
+ rep.handle_message(msg)
+
+ def _display(self, layout):
+ pass
+
+ @property
+ def out(self):
+ return self._reporters[0].out
+
+ @property
+ def linter(self):
+ return self._linter
+
+ @linter.setter
+ def linter(self, value):
+ self._linter = value
+ for rep in self._reporters:
+ rep.linter = value
+
+
+class TestRunTC:
+ def _runtest(self, args, reporter=None, out=None, code=None):
+ if out is None:
+ out = StringIO()
+ pylint_code = self._run_pylint(args, reporter=reporter, out=out)
+ if reporter:
+ output = reporter.out.getvalue()
+ elif hasattr(out, "getvalue"):
+ output = out.getvalue()
+ else:
+ output = None
+ msg = f"expected output status {code}, got {pylint_code}"
+ if output is not None:
+ msg = f"{msg}. Below pylint output: \n{output}"
+ assert pylint_code == code, msg
+
+ @staticmethod
+ def _run_pylint(args, out, reporter=None):
+ args = args + ["--persistent=no"]
+ with _patch_streams(out):
+ with pytest.raises(SystemExit) as cm:
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore")
+ Run(args, reporter=reporter)
+ return cm.value.code
+
+ @staticmethod
+ def _clean_paths(output):
+ """Normalize path to the tests directory."""
+ output = re.sub(CLEAN_PATH, "", output, flags=re.MULTILINE)
+ return output.replace("\\", "/")
+
+ def _test_output(self, args, expected_output):
+ out = StringIO()
+ self._run_pylint(args, out=out)
+ actual_output = self._clean_paths(out.getvalue())
+ expected_output = self._clean_paths(expected_output)
+ assert expected_output.strip() in actual_output.strip()
+
+ def _test_output_file(self, args, filename, expected_output):
+ """
+ Run Pylint with the ``output`` option set (must be included in
+ the ``args`` passed to this method!) and check the file content afterwards.
+ """
+ out = StringIO()
+ self._run_pylint(args, out=out)
+ cmdline_output = out.getvalue()
+ file_output = self._clean_paths(Path(filename).read_text(encoding="utf-8"))
+ expected_output = self._clean_paths(expected_output)
+ assert (
+ cmdline_output == ""
+ ), "Unexpected output to stdout/stderr while output option was set"
+ assert expected_output.strip() in file_output.strip()
+
+ def test_pkginfo(self):
+ """Make pylint check itself."""
+ self._runtest(["pylint.__pkginfo__"], reporter=TextReporter(StringIO()), code=0)
+
+ def test_all(self):
+ """Make pylint check itself."""
+ reporters = [
+ TextReporter(StringIO()),
+ ColorizedTextReporter(StringIO()),
+ JSONReporter(StringIO()),
+ ]
+ self._runtest(
+ [join(HERE, "functional", "a", "arguments.py")],
+ reporter=MultiReporter(reporters),
+ code=2,
+ )
+
+ def test_no_ext_file(self):
+ self._runtest([join(HERE, "input", "noext")], code=0)
+
+ def test_w0704_ignored(self):
+ self._runtest([join(HERE, "input", "ignore_except_pass_by_default.py")], code=0)
+
+ def test_exit_zero(self):
+ self._runtest(
+ ["--exit-zero", join(HERE, "regrtest_data", "syntax_error.py")], code=0
+ )
+
+ def test_generate_config_option(self):
+ self._runtest(["--generate-rcfile"], code=0)
+
+ def test_generate_config_option_order(self):
+ out1 = StringIO()
+ out2 = StringIO()
+ self._runtest(["--generate-rcfile"], code=0, out=out1)
+ self._runtest(["--generate-rcfile"], code=0, out=out2)
+ output1 = out1.getvalue()
+ output2 = out2.getvalue()
+ assert output1 == output2
+
+ def test_generate_config_disable_symbolic_names(self):
+ # Test that --generate-rcfile puts symbolic names in the --disable
+ # option.
+
+ out = StringIO()
+ self._run_pylint(["--generate-rcfile", "--rcfile="], out=out)
+
+ output = out.getvalue()
+ # Get rid of the pesky messages that pylint emits if the
+ # configuration file is not found.
+ pattern = rf"\[{MAIN_CHECKER_NAME.upper()}"
+ master = re.search(pattern, output)
+ assert master is not None, f"{pattern} not found in {output}"
+ out = StringIO(output[master.start() :])
+ parser = configparser.RawConfigParser()
+ parser.read_file(out)
+ messages = utils._splitstrip(parser.get("MESSAGES CONTROL", "disable"))
+ assert "suppressed-message" in messages
+
+ def test_generate_rcfile_no_obsolete_methods(self):
+ out = StringIO()
+ self._run_pylint(["--generate-rcfile"], out=out)
+ output = out.getvalue()
+ assert "profile" not in output
+
+ def test_nonexistent_config_file(self):
+ self._runtest(["--rcfile=/tmp/this_file_does_not_exist"], code=32)
+
+ def test_help_message_option(self):
+ self._runtest(["--help-msg", "W0101"], code=0)
+
+ def test_error_help_message_option(self):
+ self._runtest(["--help-msg", "WX101"], code=0)
+
+ def test_error_missing_arguments(self):
+ self._runtest([], code=32)
+
+ def test_no_out_encoding(self):
+ """test redirection of stdout with non ascii caracters"""
+ # This test reproduces bug #48066 ; it happens when stdout is redirected
+ # through '>' : the sys.stdout.encoding becomes then None, and if the
+ # output contains non ascii, pylint will crash
+ strio = StringIO()
+ assert strio.encoding is None
+ self._runtest(
+ [join(HERE, "regrtest_data", "no_stdout_encoding.py"), "--enable=all"],
+ out=strio,
+ code=28,
+ )
+
+ def test_parallel_execution(self):
+ out = StringIO()
+ self._runtest(
+ [
+ "-j 2",
+ join(HERE, "functional", "a", "arguments.py"),
+ ],
+ out=out,
+ # We expect similarities to fail and an error
+ code=MSG_TYPES_STATUS["E"],
+ )
+ assert (
+ "Unexpected keyword argument 'fourth' in function call"
+ in out.getvalue().strip()
+ )
+
+ def test_parallel_execution_bug_2674(self):
+ """Tests that disabling absolute imports works the same in -j1/j2"""
+ expected_ret_code = 0 # we are disabling the check, should pass
+ for jobs in (1, 2):
+ self._runtest(
+ [
+ "--py3k",
+ "--disable=no-absolute-import",
+ "-j %d" % jobs,
+ join(HERE, "input", "no_absolute_import.py"),
+ ],
+ code=expected_ret_code,
+ )
+
+ def test_parallel_execution_missing_arguments(self):
+ self._runtest(["-j 2", "not_here", "not_here_too"], code=1)
+
+ def test_py3k_option(self):
+ # Test that --py3k flag works.
+ rc_code = 0
+ self._runtest([UNNECESSARY_LAMBDA, "--py3k"], code=rc_code)
+
+ def test_py3k_jobs_option(self):
+ rc_code = 0
+ self._runtest([UNNECESSARY_LAMBDA, "--py3k", "-j 2"], code=rc_code)
+
+ def test_abbreviations_are_not_supported(self):
+ expected = "no such option: --load-plugin"
+ self._test_output([".", "--load-plugin"], expected_output=expected)
+
+ def test_enable_all_works(self):
+ module = join(HERE, "data", "clientmodule_test.py")
+ expected = textwrap.dedent(
+ f"""
+ ************* Module data.clientmodule_test
+ {module}:10:8: W0612: Unused variable 'local_variable' (unused-variable)
+ {module}:18:4: C0116: Missing function or method docstring (missing-function-docstring)
+ {module}:22:0: C0115: Missing class docstring (missing-class-docstring)
+ """
+ )
+ self._test_output(
+ [module, "--disable=all", "--enable=all", "-rn"], expected_output=expected
+ )
+
+ def test_wrong_import_position_when_others_disabled(self):
+ module1 = join(HERE, "regrtest_data", "import_something.py")
+ module2 = join(HERE, "regrtest_data", "wrong_import_position.py")
+ expected_output = textwrap.dedent(
+ f"""
+ ************* Module wrong_import_position
+ {module2}:11:0: C0413: Import "import os" should be placed at the top of the module (wrong-import-position)
+ """
+ )
+ args = [
+ module2,
+ module1,
+ "--disable=all",
+ "--enable=wrong-import-position",
+ "-rn",
+ "-sn",
+ ]
+ out = StringIO()
+ self._run_pylint(args, out=out)
+ actual_output = self._clean_paths(out.getvalue().strip())
+
+ to_remove = "No config file found, using default configuration"
+ if to_remove in actual_output:
+ actual_output = actual_output[len(to_remove) :]
+ if actual_output.startswith("Using config file "):
+ # If ~/.pylintrc is present remove the
+ # Using config file... line
+ actual_output = actual_output[actual_output.find("\n") :]
+ assert self._clean_paths(expected_output.strip()) == actual_output.strip()
+
+ def test_import_itself_not_accounted_for_relative_imports(self):
+ expected = "Your code has been rated at 10.00/10"
+ package = join(HERE, "regrtest_data", "dummy")
+ self._test_output(
+ [package, "--disable=locally-disabled", "-rn"], expected_output=expected
+ )
+
+ def test_reject_empty_indent_strings(self):
+ expected = "indent string can't be empty"
+ module = join(HERE, "data", "clientmodule_test.py")
+ self._test_output([module, "--indent-string="], expected_output=expected)
+
+ def test_json_report_when_file_has_syntax_error(self):
+ out = StringIO()
+ module = join(HERE, "regrtest_data", "syntax_error.py")
+ self._runtest([module], code=2, reporter=JSONReporter(out))
+ output = json.loads(out.getvalue())
+ assert isinstance(output, list)
+ assert len(output) == 1
+ assert isinstance(output[0], dict)
+ # So each version wants a different column number...
+ if platform.python_implementation() == "PyPy":
+ column = 9
+ elif sys.version_info >= (3, 8):
+ column = 9
+ else:
+ column = 15
+ expected = {
+ "obj": "",
+ "column": column,
+ "line": 1,
+ "type": "error",
+ "symbol": "syntax-error",
+ "module": "syntax_error",
+ }
+ message = output[0]
+ for key, value in expected.items():
+ assert key in message
+ assert message[key] == value
+ msg = message["message"].lower()
+ assert any(x in msg for x in ("expected ':'", "invalid syntax"))
+ assert "<unknown>" in msg
+ assert "line 1" in msg
+
+ def test_json_report_when_file_is_missing(self):
+ out = StringIO()
+ module = join(HERE, "regrtest_data", "totally_missing.py")
+ self._runtest([module], code=1, reporter=JSONReporter(out))
+ output = json.loads(out.getvalue())
+ assert isinstance(output, list)
+ assert len(output) == 1
+ assert isinstance(output[0], dict)
+ expected = {
+ "obj": "",
+ "column": 0,
+ "line": 1,
+ "type": "fatal",
+ "symbol": "fatal",
+ "module": module,
+ }
+ message = output[0]
+ for key, value in expected.items():
+ assert key in message
+ assert message[key] == value
+ assert message["message"].startswith("No module named")
+
+ def test_json_report_does_not_escape_quotes(self):
+ out = StringIO()
+ module = join(HERE, "regrtest_data", "unused_variable.py")
+ self._runtest([module], code=4, reporter=JSONReporter(out))
+ output = json.loads(out.getvalue())
+ assert isinstance(output, list)
+ assert len(output) == 1
+ assert isinstance(output[0], dict)
+ expected = {
+ "symbol": "unused-variable",
+ "module": "unused_variable",
+ "column": 4,
+ "message": "Unused variable 'variable'",
+ "message-id": "W0612",
+ "line": 4,
+ "type": "warning",
+ }
+ message = output[0]
+ for key, value in expected.items():
+ assert key in message
+ assert message[key] == value
+
+ def test_information_category_disabled_by_default(self):
+ expected = "Your code has been rated at 10.00/10"
+ path = join(HERE, "regrtest_data", "meta.py")
+ self._test_output([path], expected_output=expected)
+
+ def test_error_mode_shows_no_score(self):
+ module = join(HERE, "regrtest_data", "application_crash.py")
+ expected_output = textwrap.dedent(
+ f"""
+ ************* Module application_crash
+ {module}:1:6: E0602: Undefined variable 'something_undefined' (undefined-variable)
+ """
+ )
+ self._test_output([module, "-E"], expected_output=expected_output)
+
+ def test_evaluation_score_shown_by_default(self):
+ expected_output = "Your code has been rated at "
+ module = join(HERE, "regrtest_data", "application_crash.py")
+ self._test_output([module], expected_output=expected_output)
+
+ def test_confidence_levels(self):
+ expected = "Your code has been rated at"
+ path = join(HERE, "regrtest_data", "meta.py")
+ self._test_output(
+ [path, "--confidence=HIGH,INFERENCE"], expected_output=expected
+ )
+
+ def test_bom_marker(self):
+ path = join(HERE, "regrtest_data", "meta.py")
+ config_path = join(HERE, "regrtest_data", ".pylintrc")
+ expected = "Your code has been rated at 10.00/10"
+ self._test_output(
+ [path, "--rcfile=%s" % config_path, "-rn"], expected_output=expected
+ )
+
+ def test_pylintrc_plugin_duplicate_options(self):
+ dummy_plugin_path = join(HERE, "regrtest_data", "dummy_plugin")
+ # Enable --load-plugins=dummy_plugin
+ sys.path.append(dummy_plugin_path)
+ config_path = join(HERE, "regrtest_data", "dummy_plugin.rc")
+ expected = (
+ ":dummy-message-01 (I9061): *Dummy short desc 01*\n"
+ " Dummy long desc This message belongs to the dummy_plugin checker.\n\n"
+ ":dummy-message-02 (I9060): *Dummy short desc 02*\n"
+ " Dummy long desc This message belongs to the dummy_plugin checker."
+ )
+ self._test_output(
+ [
+ "--rcfile=%s" % config_path,
+ "--help-msg=dummy-message-01,dummy-message-02",
+ ],
+ expected_output=expected,
+ )
+ expected = (
+ "[DUMMY_PLUGIN]\n\n# Dummy option 1\ndummy_option_1=dummy value 1\n\n"
+ "# Dummy option 2\ndummy_option_2=dummy value 2"
+ )
+ self._test_output(
+ ["--rcfile=%s" % config_path, "--generate-rcfile"], expected_output=expected
+ )
+ sys.path.remove(dummy_plugin_path)
+
+ def test_pylintrc_comments_in_values(self):
+ path = join(HERE, "regrtest_data", "test_pylintrc_comments.py")
+ config_path = join(HERE, "regrtest_data", "comments_pylintrc")
+ expected = textwrap.dedent(
+ f"""
+ ************* Module test_pylintrc_comments
+ {path}:2:0: W0311: Bad indentation. Found 1 spaces, expected 4 (bad-indentation)
+ {path}:1:0: C0114: Missing module docstring (missing-module-docstring)
+ {path}:1:0: C0116: Missing function or method docstring (missing-function-docstring)
+ """
+ )
+ self._test_output(
+ [path, "--rcfile=%s" % config_path, "-rn"], expected_output=expected
+ )
+
+ def test_no_crash_with_formatting_regex_defaults(self):
+ self._runtest(
+ ["--ignore-patterns=a"], reporter=TextReporter(StringIO()), code=32
+ )
+
+ def test_getdefaultencoding_crashes_with_lc_ctype_utf8(self):
+ module = join(HERE, "regrtest_data", "application_crash.py")
+ expected_output = textwrap.dedent(
+ f"""
+ {module}:1:6: E0602: Undefined variable 'something_undefined' (undefined-variable)
+ """
+ )
+ with _configure_lc_ctype("UTF-8"):
+ self._test_output([module, "-E"], expected_output=expected_output)
+
+ @pytest.mark.skipif(sys.platform == "win32", reason="only occurs on *nix")
+ def test_parseable_file_path(self):
+ file_name = "test_target.py"
+ fake_path = HERE + os.getcwd()
+ module = join(fake_path, file_name)
+
+ try:
+ # create module under directories which have the same name as reporter.path_strip_prefix
+ # e.g. /src/some/path/src/test_target.py when reporter.path_strip_prefix = /src/
+ os.makedirs(fake_path)
+ with open(module, "w") as test_target:
+ test_target.write("a,b = object()")
+
+ self._test_output(
+ [module, "--output-format=parseable"], expected_output=file_name
+ )
+ finally:
+ os.remove(module)
+ os.removedirs(fake_path)
+
+ @pytest.mark.parametrize(
+ "input_path,module,expected_path",
+ [
+ (join(HERE, "mymodule.py"), "mymodule", join(HERE, "mymodule.py")),
+ ("mymodule.py", "mymodule", "mymodule.py"),
+ ],
+ )
+ def test_stdin(self, input_path, module, expected_path):
+ expected_output = f"""************* Module {module}
+{expected_path}:1:0: W0611: Unused import os (unused-import)
+
+"""
+
+ with mock.patch(
+ "pylint.lint.pylinter._read_stdin", return_value="import os\n"
+ ) as mock_stdin:
+ self._test_output(
+ ["--from-stdin", input_path, "--disable=all", "--enable=unused-import"],
+ expected_output=expected_output,
+ )
+ assert mock_stdin.call_count == 1
+
+ def test_stdin_missing_modulename(self):
+ self._runtest(["--from-stdin"], code=32)
+
+ @pytest.mark.parametrize("write_bpy_to_disk", [False, True])
+ def test_relative_imports(self, write_bpy_to_disk, tmpdir):
+ a = tmpdir.join("a")
+
+ b_code = textwrap.dedent(
+ """
+ from .c import foobar
+ from .d import bla # module does not exist
+
+ foobar('hello')
+ bla()
+ """
+ )
+
+ c_code = textwrap.dedent(
+ """
+ def foobar(arg):
+ pass
+ """
+ )
+
+ a.mkdir()
+ a.join("__init__.py").write("")
+ if write_bpy_to_disk:
+ a.join("b.py").write(b_code)
+ a.join("c.py").write(c_code)
+
+ with tmpdir.as_cwd():
+ # why don't we start pylint in a subprocess?
+ expected = (
+ "************* Module a.b\n"
+ "a/b.py:3:0: E0401: Unable to import 'a.d' (import-error)\n\n"
+ )
+
+ if write_bpy_to_disk:
+ # --from-stdin is not used here
+ self._test_output(
+ ["a/b.py", "--disable=all", "--enable=import-error"],
+ expected_output=expected,
+ )
+
+ # this code needs to work w/ and w/o a file named a/b.py on the
+ # harddisk.
+ with mock.patch("pylint.lint.pylinter._read_stdin", return_value=b_code):
+ self._test_output(
+ [
+ "--from-stdin",
+ join("a", "b.py"),
+ "--disable=all",
+ "--enable=import-error",
+ ],
+ expected_output=expected,
+ )
+
+ def test_stdin_syntaxerror(self):
+ expected_output = (
+ "************* Module a\n"
+ "a.py:1:4: E0001: invalid syntax (<unknown>, line 1) (syntax-error)"
+ )
+
+ with mock.patch(
+ "pylint.lint.pylinter._read_stdin", return_value="for\n"
+ ) as mock_stdin:
+ self._test_output(
+ ["--from-stdin", "a.py", "--disable=all", "--enable=syntax-error"],
+ expected_output=expected_output,
+ )
+ assert mock_stdin.call_count == 1
+
+ def test_version(self):
+ def check(lines):
+ assert lines[0].startswith("pylint ")
+ assert lines[1].startswith("astroid ")
+ assert lines[2].startswith("Python ")
+
+ out = StringIO()
+ self._run_pylint(["--version"], out=out)
+ check(out.getvalue().splitlines())
+
+ result = subprocess.check_output([sys.executable, "-m", "pylint", "--version"])
+ result = result.decode("utf-8")
+ check(result.splitlines())
+
+ def test_fail_under(self):
+ self._runtest(
+ [
+ "--fail-under",
+ "-10",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_plus7_5.py"),
+ ],
+ code=0,
+ )
+ self._runtest(
+ [
+ "--fail-under",
+ "6",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_plus7_5.py"),
+ ],
+ code=0,
+ )
+ self._runtest(
+ [
+ "--fail-under",
+ "7.5",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_plus7_5.py"),
+ ],
+ code=0,
+ )
+ self._runtest(
+ [
+ "--fail-under",
+ "7.6",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_plus7_5.py"),
+ ],
+ code=16,
+ )
+
+ self._runtest(
+ [
+ "--fail-under",
+ "-11",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_minus10.py"),
+ ],
+ code=0,
+ )
+ self._runtest(
+ [
+ "--fail-under",
+ "-10",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_minus10.py"),
+ ],
+ code=0,
+ )
+ self._runtest(
+ [
+ "--fail-under",
+ "-9",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_minus10.py"),
+ ],
+ code=22,
+ )
+ self._runtest(
+ [
+ "--fail-under",
+ "-5",
+ "--enable=all",
+ join(HERE, "regrtest_data", "fail_under_minus10.py"),
+ ],
+ code=22,
+ )
+
+ @pytest.mark.parametrize(
+ "fu_score,fo_msgs,fname,out",
+ [
+ # Essentially same test cases as --fail-under, but run with/without a detected issue code
+ # missing-function-docstring (C0116) is issue in both files
+ # --fail-under should be irrelevant as missing-function-docstring is hit
+ (-10, "missing-function-docstring", "fail_under_plus7_5.py", 16),
+ (6, "missing-function-docstring", "fail_under_plus7_5.py", 16),
+ (7.5, "missing-function-docstring", "fail_under_plus7_5.py", 16),
+ (7.6, "missing-function-docstring", "fail_under_plus7_5.py", 16),
+ (-11, "missing-function-docstring", "fail_under_minus10.py", 22),
+ (-10, "missing-function-docstring", "fail_under_minus10.py", 22),
+ (-9, "missing-function-docstring", "fail_under_minus10.py", 22),
+ (-5, "missing-function-docstring", "fail_under_minus10.py", 22),
+ # --fail-under should guide whether error code as missing-function-docstring is not hit
+ (-10, "broad-except", "fail_under_plus7_5.py", 0),
+ (6, "broad-except", "fail_under_plus7_5.py", 0),
+ (7.5, "broad-except", "fail_under_plus7_5.py", 0),
+ (7.6, "broad-except", "fail_under_plus7_5.py", 16),
+ (-11, "broad-except", "fail_under_minus10.py", 0),
+ (-10, "broad-except", "fail_under_minus10.py", 0),
+ (-9, "broad-except", "fail_under_minus10.py", 22),
+ (-5, "broad-except", "fail_under_minus10.py", 22),
+ # Enable by message id
+ (-10, "C0116", "fail_under_plus7_5.py", 16),
+ # Enable by category
+ (-10, "C", "fail_under_plus7_5.py", 16),
+ (-10, "fake1,C,fake2", "fail_under_plus7_5.py", 16),
+ # Ensure entire category not enabled by any msg id
+ (-10, "C0115", "fail_under_plus7_5.py", 0),
+ ],
+ )
+ def test_fail_on(self, fu_score, fo_msgs, fname, out):
+ self._runtest(
+ [
+ "--fail-under",
+ f"{fu_score:f}",
+ f"--fail-on={fo_msgs}",
+ "--enable=all",
+ join(HERE, "regrtest_data", fname),
+ ],
+ code=out,
+ )
+
+ @pytest.mark.parametrize(
+ "opts,out",
+ [
+ # Special case to ensure that disabled items from category aren't enabled
+ (["--disable=C0116", "--fail-on=C"], 0),
+ # Ensure order does not matter
+ (["--fail-on=C", "--disable=C0116"], 0),
+ # Ensure --fail-on takes precedence over --disable
+ (["--disable=C0116", "--fail-on=C0116"], 16),
+ # Ensure order does not matter
+ (["--fail-on=C0116", "--disable=C0116"], 16),
+ ],
+ )
+ def test_fail_on_edge_case(self, opts, out):
+ self._runtest(
+ opts + [join(HERE, "regrtest_data", "fail_under_plus7_5.py")],
+ code=out,
+ )
+
+ @staticmethod
+ def test_modify_sys_path() -> None:
+ @contextlib.contextmanager
+ def test_sys_path() -> Generator[None, None, None]:
+ original_path = sys.path
+ try:
+ yield
+ finally:
+ sys.path = original_path
+
+ @contextlib.contextmanager
+ def test_environ_pythonpath(
+ new_pythonpath: Optional[str],
+ ) -> Generator[None, None, None]:
+ original_pythonpath = os.environ.get("PYTHONPATH")
+ if new_pythonpath:
+ os.environ["PYTHONPATH"] = new_pythonpath
+ elif new_pythonpath is None and original_pythonpath is not None:
+ # If new_pythonpath is None, make sure to delete PYTHONPATH if present
+ del os.environ["PYTHONPATH"]
+ try:
+ yield
+ finally:
+ if original_pythonpath:
+ os.environ["PYTHONPATH"] = original_pythonpath
+ elif new_pythonpath is not None:
+ # Only delete PYTHONPATH if new_pythonpath wasn't None
+ del os.environ["PYTHONPATH"]
+
+ with test_sys_path(), patch("os.getcwd") as mock_getcwd:
+ cwd = "/tmp/pytest-of-root/pytest-0/test_do_not_import_files_from_0"
+ mock_getcwd.return_value = cwd
+ default_paths = [
+ "/usr/local/lib/python39.zip",
+ "/usr/local/lib/python3.9",
+ "/usr/local/lib/python3.9/lib-dynload",
+ "/usr/local/lib/python3.9/site-packages",
+ ]
+
+ paths = [
+ cwd,
+ *default_paths,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath(None):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+
+ paths = [
+ cwd,
+ cwd,
+ *default_paths,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath("."):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+
+ paths = [
+ cwd,
+ "/custom_pythonpath",
+ *default_paths,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath("/custom_pythonpath"):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+
+ paths = [
+ cwd,
+ "/custom_pythonpath",
+ cwd,
+ *default_paths,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath("/custom_pythonpath:"):
+ modify_sys_path()
+ assert sys.path == [paths[1]] + paths[3:]
+
+ paths = [
+ "",
+ cwd,
+ "/custom_pythonpath",
+ *default_paths,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath(":/custom_pythonpath"):
+ modify_sys_path()
+ assert sys.path == paths[2:]
+
+ paths = [
+ cwd,
+ cwd,
+ "/custom_pythonpath",
+ *default_paths,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath(":/custom_pythonpath:"):
+ modify_sys_path()
+ assert sys.path == paths[2:]
+
+ paths = [
+ cwd,
+ cwd,
+ *default_paths,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath(":."):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+ sys.path = copy(paths)
+ with test_environ_pythonpath(f":{cwd}"):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+
+ sys.path = copy(paths)
+ with test_environ_pythonpath(".:"):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+ sys.path = copy(paths)
+ with test_environ_pythonpath(f"{cwd}:"):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+
+ paths = [
+ "",
+ cwd,
+ *default_paths,
+ cwd,
+ ]
+ sys.path = copy(paths)
+ with test_environ_pythonpath(cwd):
+ modify_sys_path()
+ assert sys.path == paths[1:]
+
+ @staticmethod
+ def test_do_not_import_files_from_local_directory(tmpdir):
+ p_astroid = tmpdir / "astroid.py"
+ p_astroid.write("'Docstring'\nimport completely_unknown\n")
+ p_hmac = tmpdir / "hmac.py"
+ p_hmac.write("'Docstring'\nimport completely_unknown\n")
+
+ with tmpdir.as_cwd():
+ subprocess.check_output(
+ [
+ sys.executable,
+ "-m",
+ "pylint",
+ "astroid.py",
+ "--disable=import-error,unused-import",
+ ],
+ cwd=str(tmpdir),
+ )
+
+ # Linting this astroid file does not import it
+ with tmpdir.as_cwd():
+ subprocess.check_output(
+ [
+ sys.executable,
+ "-m",
+ "pylint",
+ "-j2",
+ "astroid.py",
+ "--disable=import-error,unused-import",
+ ],
+ cwd=str(tmpdir),
+ )
+
+ # Test with multiple jobs for hmac.py for which we have a
+ # CVE against: https://github.com/PyCQA/pylint/issues/959
+ with tmpdir.as_cwd():
+ subprocess.call(
+ [
+ sys.executable,
+ "-m",
+ "pylint",
+ "-j2",
+ "hmac.py",
+ "--disable=import-error,unused-import",
+ ],
+ cwd=str(tmpdir),
+ )
+
+ @staticmethod
+ def test_do_not_import_files_from_local_directory_with_pythonpath(tmpdir):
+ p_astroid = tmpdir / "astroid.py"
+ p_astroid.write("'Docstring'\nimport completely_unknown\n")
+ p_hmac = tmpdir / "hmac.py"
+ p_hmac.write("'Docstring'\nimport completely_unknown\n")
+
+ # Appending a colon to PYTHONPATH should not break path stripping
+ # https://github.com/PyCQA/pylint/issues/3636
+ with tmpdir.as_cwd():
+ orig_pythonpath = os.environ.get("PYTHONPATH")
+ os.environ["PYTHONPATH"] = f"{(orig_pythonpath or '').strip(':')}:"
+ subprocess.check_output(
+ [
+ sys.executable,
+ "-m",
+ "pylint",
+ "astroid.py",
+ "--disable=import-error,unused-import",
+ ],
+ cwd=str(tmpdir),
+ )
+ if orig_pythonpath:
+ os.environ["PYTHONPATH"] = orig_pythonpath
+ else:
+ del os.environ["PYTHONPATH"]
+
+ @staticmethod
+ def test_import_plugin_from_local_directory_if_pythonpath_cwd(tmpdir):
+ p_plugin = tmpdir / "plugin.py"
+ p_plugin.write("# Some plugin content")
+
+ with tmpdir.as_cwd():
+ orig_pythonpath = os.environ.get("PYTHONPATH")
+ if sys.platform == "win32":
+ os.environ["PYTHONPATH"] = "."
+ else:
+ os.environ["PYTHONPATH"] = f"{(orig_pythonpath or '').strip(':')}:."
+ process = subprocess.run(
+ [
+ sys.executable,
+ "-m",
+ "pylint",
+ "--load-plugins",
+ "plugin",
+ ],
+ cwd=str(tmpdir),
+ stderr=subprocess.PIPE,
+ check=False,
+ )
+ assert (
+ "AttributeError: module 'plugin' has no attribute 'register'"
+ in process.stderr.decode()
+ )
+ if orig_pythonpath:
+ os.environ["PYTHONPATH"] = orig_pythonpath
+ else:
+ del os.environ["PYTHONPATH"]
+
+ def test_allow_import_of_files_found_in_modules_during_parallel_check(self, tmpdir):
+ test_directory = tmpdir / "test_directory"
+ test_directory.mkdir()
+ spam_module = test_directory / "spam.py"
+ spam_module.write("'Empty'")
+
+ init_module = test_directory / "__init__.py"
+ init_module.write("'Empty'")
+
+ # For multiple jobs we could not find the `spam.py` file.
+ with tmpdir.as_cwd():
+ self._runtest(
+ [
+ "-j2",
+ "--disable=missing-docstring, missing-final-newline",
+ "test_directory",
+ ],
+ code=0,
+ )
+
+ # A single job should be fine as well
+ with tmpdir.as_cwd():
+ self._runtest(
+ [
+ "-j1",
+ "--disable=missing-docstring, missing-final-newline",
+ "test_directory",
+ ],
+ code=0,
+ )
+
+ @staticmethod
+ def test_can_list_directories_without_dunder_init(tmpdir):
+ test_directory = tmpdir / "test_directory"
+ test_directory.mkdir()
+ spam_module = test_directory / "spam.py"
+ spam_module.write("'Empty'")
+
+ subprocess.check_output(
+ [
+ sys.executable,
+ "-m",
+ "pylint",
+ "--disable=missing-docstring, missing-final-newline",
+ "test_directory",
+ ],
+ cwd=str(tmpdir),
+ stderr=subprocess.PIPE,
+ )
+
+ def test_jobs_score(self):
+ path = join(HERE, "regrtest_data", "unused_variable.py")
+ expected = "Your code has been rated at 7.50/10"
+ self._test_output([path, "--jobs=2", "-ry"], expected_output=expected)
+
+ def test_duplicate_code_raw_strings(self):
+ path = join(HERE, "regrtest_data", "duplicate_data_raw_strings")
+ expected_output = "Similar lines in 2 files"
+ self._test_output(
+ [path, "--disable=all", "--enable=duplicate-code"],
+ expected_output=expected_output,
+ )
+
+ def test_regression_parallel_mode_without_filepath(self):
+ # Test that parallel mode properly passes filepath
+ # https://github.com/PyCQA/pylint/issues/3564
+ path = join(
+ HERE, "regrtest_data", "regression_missing_init_3564", "subdirectory/"
+ )
+ self._test_output([path, "-j2"], expected_output="No such file or directory")
+
+ def test_output_file_valid_path(self, tmpdir):
+ path = join(HERE, "regrtest_data", "unused_variable.py")
+ output_file = tmpdir / "output.txt"
+ expected = "Your code has been rated at 7.50/10"
+ self._test_output_file(
+ [path, f"--output={output_file}"],
+ output_file,
+ expected_output=expected,
+ )
+
+ def test_output_file_invalid_path_exits_with_code_32(self):
+ path = join(HERE, "regrtest_data", "unused_variable.py")
+ output_file = "thisdirectorydoesnotexit/output.txt"
+ self._runtest([path, f"--output={output_file}"], code=32)
+
+ @pytest.mark.parametrize(
+ "output_format, expected_output",
+ [
+ (
+ "text",
+ "tests/regrtest_data/unused_variable.py:4:4: W0612: Unused variable 'variable' (unused-variable)",
+ ),
+ (
+ "parseable",
+ "tests/regrtest_data/unused_variable.py:4: [W0612(unused-variable), test] Unused variable 'variable'",
+ ),
+ (
+ "msvs",
+ "tests/regrtest_data/unused_variable.py(4): [W0612(unused-variable)test] Unused variable 'variable'",
+ ),
+ (
+ "colorized",
+ "tests/regrtest_data/unused_variable.py:4:4: W0612: [35mUnused variable 'variable'[0m ([35munused-variable[0m)",
+ ),
+ ("json", '"message": "Unused variable \'variable\'",'),
+ ],
+ )
+ def test_output_file_can_be_combined_with_output_format_option(
+ self, tmpdir, output_format, expected_output
+ ):
+ path = join(HERE, "regrtest_data", "unused_variable.py")
+ output_file = tmpdir / "output.txt"
+ self._test_output_file(
+ [path, f"--output={output_file}", f"--output-format={output_format}"],
+ output_file,
+ expected_output,
+ )
+
+ def test_output_file_can_be_combined_with_custom_reporter(self, tmpdir):
+ path = join(HERE, "regrtest_data", "unused_variable.py")
+ output_file = tmpdir / "output.txt"
+ # It does not really have to be a truly custom reporter.
+ # It is only important that it is being passed explicitly to ``Run``.
+ myreporter = TextReporter()
+ self._run_pylint(
+ [path, f"--output={output_file}"],
+ out=sys.stdout,
+ reporter=myreporter,
+ )
+ assert output_file.exists()
+
+ def test_output_file_specified_in_rcfile(self, tmpdir):
+ output_file = tmpdir / "output.txt"
+ rcfile = tmpdir / "pylintrc"
+ rcfile_contents = textwrap.dedent(
+ f"""
+ [MASTER]
+ output={output_file}
+ """
+ )
+ rcfile.write_text(rcfile_contents, encoding="utf-8")
+ path = join(HERE, "regrtest_data", "unused_variable.py")
+ expected = "Your code has been rated at 7.50/10"
+ self._test_output_file(
+ [path, f"--output={output_file}", f"--rcfile={rcfile}"],
+ output_file,
+ expected_output=expected,
+ )
diff --git a/tests/testutils/test_output_line.py b/tests/testutils/test_output_line.py
new file mode 100644
index 0000000..2fb342f
--- /dev/null
+++ b/tests/testutils/test_output_line.py
@@ -0,0 +1,103 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+# pylint: disable=redefined-outer-name
+
+import pytest
+
+from pylint.constants import PY38_PLUS
+from pylint.interfaces import HIGH, INFERENCE
+from pylint.message import Message
+from pylint.testutils.output_line import MalformedOutputLineException, OutputLine
+
+
+@pytest.fixture()
+def message():
+ def inner(confidence=HIGH):
+ return Message(
+ symbol="missing-docstring",
+ msg_id="C0123",
+ location=[
+ "abspath",
+ "path",
+ "module",
+ "obj",
+ "line",
+ "column",
+ ],
+ msg="msg",
+ confidence=confidence,
+ )
+
+ return inner
+
+
+def test_output_line():
+ output_line = OutputLine(
+ symbol="missing-docstring",
+ lineno=0,
+ column=0,
+ object="",
+ msg="Missing docstring's bad.",
+ confidence=HIGH,
+ )
+ assert output_line.symbol == "missing-docstring"
+
+
+def test_output_line_from_message(message):
+ output_line = OutputLine.from_msg(message())
+ assert output_line.symbol == "missing-docstring"
+ assert output_line.msg == "msg"
+
+
+@pytest.mark.parametrize("confidence", [HIGH, INFERENCE])
+def test_output_line_to_csv(confidence, message):
+ output_line = OutputLine.from_msg(message(confidence))
+ csv = output_line.to_csv()
+ expected_column = "column" if PY38_PLUS else ""
+ assert csv == (
+ "missing-docstring",
+ "line",
+ expected_column,
+ "obj",
+ "msg",
+ confidence.name,
+ )
+
+
+def test_output_line_from_csv_error():
+ with pytest.raises(
+ MalformedOutputLineException,
+ match="msg-symbolic-name:42:27:MyClass.my_function:The message",
+ ):
+ OutputLine.from_csv("'missing-docstring', 'line', 'column', 'obj', 'msg'")
+ with pytest.raises(
+ MalformedOutputLineException, match="symbol='missing-docstring' ?"
+ ):
+ csv = ("missing-docstring", "line", "column", "obj", "msg")
+ OutputLine.from_csv(csv)
+
+
+@pytest.mark.parametrize(
+ "confidence,expected_confidence", [[None, "HIGH"], ["INFERENCE", "INFERENCE"]]
+)
+def test_output_line_from_csv(confidence, expected_confidence):
+ proper_csv = (
+ "missing-docstring",
+ "1",
+ "2",
+ "obj",
+ "msg",
+ )
+ if confidence is not None:
+ proper_csv += (confidence,)
+ output_line = OutputLine.from_csv(proper_csv)
+ expected_column = "2" if PY38_PLUS else ""
+ assert output_line == OutputLine(
+ symbol="missing-docstring",
+ lineno=1,
+ column=expected_column,
+ object="obj",
+ msg="msg",
+ confidence=expected_confidence,
+ )
diff --git a/tests/unittest_config.py b/tests/unittest_config.py
new file mode 100644
index 0000000..e43d81f
--- /dev/null
+++ b/tests/unittest_config.py
@@ -0,0 +1,65 @@
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2016-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit tests for the config module."""
+
+import re
+import sre_constants
+
+import pytest
+
+from pylint import config
+
+RE_PATTERN_TYPE = getattr(re, "Pattern", getattr(re, "_pattern_type", None))
+
+
+def test__regexp_validator_valid():
+ result = config.option._regexp_validator(None, None, "test_.*")
+ assert isinstance(result, RE_PATTERN_TYPE)
+ assert result.pattern == "test_.*"
+
+
+def test__regexp_validator_invalid():
+ with pytest.raises(sre_constants.error):
+ config.option._regexp_validator(None, None, "test_)")
+
+
+def test__csv_validator_no_spaces():
+ values = ["One", "Two", "Three"]
+ result = config.option._csv_validator(None, None, ",".join(values))
+ assert isinstance(result, list)
+ assert len(result) == 3
+ for i, value in enumerate(values):
+ assert result[i] == value
+
+
+def test__csv_validator_spaces():
+ values = ["One", "Two", "Three"]
+ result = config.option._csv_validator(None, None, ", ".join(values))
+ assert isinstance(result, list)
+ assert len(result) == 3
+ for i, value in enumerate(values):
+ assert result[i] == value
+
+
+def test__regexp_csv_validator_valid():
+ pattern_strings = ["test_.*", "foo\\.bar", "^baz$"]
+ result = config.option._regexp_csv_validator(None, None, ",".join(pattern_strings))
+ for i, regex in enumerate(result):
+ assert isinstance(regex, RE_PATTERN_TYPE)
+ assert regex.pattern == pattern_strings[i]
+
+
+def test__regexp_csv_validator_invalid():
+ pattern_strings = ["test_.*", "foo\\.bar", "^baz)$"]
+ with pytest.raises(sre_constants.error):
+ config.option._regexp_csv_validator(None, None, ",".join(pattern_strings))
diff --git a/tests/unittest_pyreverse_diadefs.py b/tests/unittest_pyreverse_diadefs.py
new file mode 100644
index 0000000..beb1f75
--- /dev/null
+++ b/tests/unittest_pyreverse_diadefs.py
@@ -0,0 +1,199 @@
+# Copyright (c) 2008-2010, 2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 bot <bot@noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Unit test for the extensions.diadefslib modules"""
+# pylint: disable=redefined-outer-name
+import sys
+from pathlib import Path
+
+import astroid
+import pytest
+from unittest_pyreverse_writer import Config, get_project
+
+from pylint.pyreverse.diadefslib import (
+ ClassDiadefGenerator,
+ DefaultDiadefGenerator,
+ DiaDefGenerator,
+ DiadefsHandler,
+)
+from pylint.pyreverse.inspector import Linker
+
+
+def _process_classes(classes):
+ """extract class names of a list"""
+ return sorted((isinstance(c.node, astroid.ClassDef), c.title) for c in classes)
+
+
+def _process_relations(relations):
+ """extract relation indices from a relation list"""
+ result = []
+ for rel_type, rels in relations.items():
+ for rel in rels:
+ result.append((rel_type, rel.from_object.title, rel.to_object.title))
+ result.sort()
+ return result
+
+
+@pytest.fixture
+def HANDLER():
+ return DiadefsHandler(Config())
+
+
+@pytest.fixture(scope="module")
+def PROJECT():
+ return get_project("data")
+
+
+def test_option_values(HANDLER, PROJECT):
+ """test for ancestor, associated and module options"""
+ df_h = DiaDefGenerator(Linker(PROJECT), HANDLER)
+ cl_config = Config()
+ cl_config.classes = ["Specialization"]
+ cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
+ assert df_h._get_levels() == (0, 0)
+ assert not df_h.module_names
+ assert cl_h._get_levels() == (-1, -1)
+ assert cl_h.module_names
+ for hndl in (df_h, cl_h):
+ hndl.config.all_ancestors = True
+ hndl.config.all_associated = True
+ hndl.config.module_names = True
+ hndl._set_default_options()
+ assert hndl._get_levels() == (-1, -1)
+ assert hndl.module_names
+ handler = DiadefsHandler(Config())
+ df_h = DiaDefGenerator(Linker(PROJECT), handler)
+ cl_config = Config()
+ cl_config.classes = ["Specialization"]
+ cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
+ for hndl in (df_h, cl_h):
+ hndl.config.show_ancestors = 2
+ hndl.config.show_associated = 1
+ hndl.config.module_names = False
+ hndl._set_default_options()
+ assert hndl._get_levels() == (2, 1)
+ assert not hndl.module_names
+
+
+def test_default_values():
+ """test default values for package or class diagrams"""
+ # TODO : should test difference between default values for package or class diagrams pylint: disable=fixme
+
+
+class TestDefaultDiadefGenerator:
+ _should_rels = [
+ ("association", "DoNothing", "Ancestor"),
+ ("association", "DoNothing", "Specialization"),
+ ("implements", "Ancestor", "Interface"),
+ ("specialization", "Specialization", "Ancestor"),
+ ]
+
+ def test_exctract_relations(self, HANDLER, PROJECT):
+ """test extract_relations between classes"""
+ cd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)[1]
+ cd.extract_relationships()
+ relations = _process_relations(cd.relationships)
+ assert relations == self._should_rels
+
+ def test_functional_relation_extraction(self):
+ """functional test of relations extraction;
+ different classes possibly in different modules"""
+ # XXX should be catching pyreverse environnement problem but doesn't
+ # pyreverse doesn't extracts the relations but this test ok
+ project = get_project("data")
+ handler = DiadefsHandler(Config())
+ diadefs = handler.get_diadefs(project, Linker(project, tag=True))
+ cd = diadefs[1]
+ relations = _process_relations(cd.relationships)
+ assert relations == self._should_rels
+
+
+def test_known_values1(HANDLER, PROJECT):
+ dd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)
+ assert len(dd) == 2
+ keys = [d.TYPE for d in dd]
+ assert keys == ["package", "class"]
+ pd = dd[0]
+ assert pd.title == "packages No Name"
+ modules = sorted((isinstance(m.node, astroid.Module), m.title) for m in pd.objects)
+ assert modules == [
+ (True, "data"),
+ (True, "data.clientmodule_test"),
+ (True, "data.suppliermodule_test"),
+ ]
+ cd = dd[1]
+ assert cd.title == "classes No Name"
+ classes = _process_classes(cd.objects)
+ assert classes == [
+ (True, "Ancestor"),
+ (True, "DoNothing"),
+ (True, "Interface"),
+ (True, "Specialization"),
+ ]
+
+
+def test_known_values2(HANDLER):
+ project = get_project("data.clientmodule_test")
+ dd = DefaultDiadefGenerator(Linker(project), HANDLER).visit(project)
+ assert len(dd) == 1
+ keys = [d.TYPE for d in dd]
+ assert keys == ["class"]
+ cd = dd[0]
+ assert cd.title == "classes No Name"
+ classes = _process_classes(cd.objects)
+ assert classes == [(True, "Ancestor"), (True, "Specialization")]
+
+
+def test_known_values3(HANDLER, PROJECT):
+ HANDLER.config.classes = ["Specialization"]
+ cdg = ClassDiadefGenerator(Linker(PROJECT), HANDLER)
+ special = "data.clientmodule_test.Specialization"
+ cd = cdg.class_diagram(PROJECT, special)
+ assert cd.title == special
+ classes = _process_classes(cd.objects)
+ assert classes == [
+ (True, "data.clientmodule_test.Ancestor"),
+ (True, special),
+ (True, "data.suppliermodule_test.DoNothing"),
+ ]
+
+
+def test_known_values4(HANDLER, PROJECT):
+ HANDLER.config.classes = ["Specialization"]
+ HANDLER.config.module_names = False
+ cd = ClassDiadefGenerator(Linker(PROJECT), HANDLER).class_diagram(
+ PROJECT, "data.clientmodule_test.Specialization"
+ )
+ assert cd.title == "data.clientmodule_test.Specialization"
+ classes = _process_classes(cd.objects)
+ assert classes == [
+ (True, "Ancestor"),
+ (True, "DoNothing"),
+ (True, "Specialization"),
+ ]
+
+
+@pytest.mark.skipif(sys.version_info < (3, 8), reason="Requires dataclasses")
+def test_regression_dataclasses_inference(HANDLER):
+ project_path = Path("regrtest_data") / "dataclasses_pyreverse"
+ path = get_project(str(project_path))
+
+ cdg = ClassDiadefGenerator(Linker(path), HANDLER)
+ special = "regrtest_data.dataclasses_pyreverse.InventoryItem"
+ cd = cdg.class_diagram(path, special)
+ assert cd.title == special
diff --git a/tests/unittest_pyreverse_inspector.py b/tests/unittest_pyreverse_inspector.py
new file mode 100644
index 0000000..e1ff637
--- /dev/null
+++ b/tests/unittest_pyreverse_inspector.py
@@ -0,0 +1,130 @@
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""
+ for the visitors.diadefs module
+"""
+# pylint: disable=redefined-outer-name
+
+import os
+
+import astroid
+import pytest
+from unittest_pyreverse_writer import get_project
+
+from pylint.pyreverse import inspector
+
+
+@pytest.fixture
+def project():
+ project = get_project("data", "data")
+ linker = inspector.Linker(project)
+ linker.visit(project)
+ return project
+
+
+def test_class_implements(project):
+ klass = project.get_module("data.clientmodule_test")["Ancestor"]
+ assert hasattr(klass, "implements")
+ assert len(klass.implements) == 1
+ assert isinstance(klass.implements[0], astroid.nodes.ClassDef)
+ assert klass.implements[0].name == "Interface"
+
+
+def test_class_implements_specialization(project):
+ klass = project.get_module("data.clientmodule_test")["Specialization"]
+ assert hasattr(klass, "implements")
+ assert len(klass.implements) == 0
+
+
+def test_locals_assignment_resolution(project):
+ klass = project.get_module("data.clientmodule_test")["Specialization"]
+ assert hasattr(klass, "locals_type")
+ type_dict = klass.locals_type
+ assert len(type_dict) == 2
+ keys = sorted(type_dict.keys())
+ assert keys == ["TYPE", "top"]
+ assert len(type_dict["TYPE"]) == 1
+ assert type_dict["TYPE"][0].value == "final class"
+ assert len(type_dict["top"]) == 1
+ assert type_dict["top"][0].value == "class"
+
+
+def test_instance_attrs_resolution(project):
+ klass = project.get_module("data.clientmodule_test")["Specialization"]
+ assert hasattr(klass, "instance_attrs_type")
+ type_dict = klass.instance_attrs_type
+ assert len(type_dict) == 2
+ keys = sorted(type_dict.keys())
+ assert keys == ["_id", "relation"]
+ assert isinstance(type_dict["relation"][0], astroid.bases.Instance), type_dict[
+ "relation"
+ ]
+ assert type_dict["relation"][0].name == "DoNothing"
+ assert type_dict["_id"][0] is astroid.Uninferable
+
+
+def test_concat_interfaces():
+ cls = astroid.extract_node(
+ '''
+ class IMachin: pass
+
+ class Correct2:
+ """docstring"""
+ __implements__ = (IMachin,)
+
+ class BadArgument:
+ """docstring"""
+ __implements__ = (IMachin,)
+
+ class InterfaceCanNowBeFound: #@
+ """docstring"""
+ __implements__ = BadArgument.__implements__ + Correct2.__implements__
+ '''
+ )
+ interfaces = inspector.interfaces(cls)
+ assert [i.name for i in interfaces] == ["IMachin"]
+
+
+def test_interfaces():
+ module = astroid.parse(
+ """
+ class Interface(object): pass
+ class MyIFace(Interface): pass
+ class AnotherIFace(Interface): pass
+ class Concrete0(object):
+ __implements__ = MyIFace
+ class Concrete1:
+ __implements__ = (MyIFace, AnotherIFace)
+ class Concrete2:
+ __implements__ = (MyIFace, AnotherIFace)
+ class Concrete23(Concrete1): pass
+ """
+ )
+
+ for klass, interfaces in (
+ ("Concrete0", ["MyIFace"]),
+ ("Concrete1", ["MyIFace", "AnotherIFace"]),
+ ("Concrete2", ["MyIFace", "AnotherIFace"]),
+ ("Concrete23", ["MyIFace", "AnotherIFace"]),
+ ):
+ klass = module[klass]
+ assert [i.name for i in inspector.interfaces(klass)] == interfaces
+
+
+def test_from_directory(project):
+ expected = os.path.join("tests", "data", "__init__.py")
+ assert project.name == "data"
+ assert project.path.endswith(expected)
+
+
+def test_project_node(project):
+ expected = ["data", "data.clientmodule_test", "data.suppliermodule_test"]
+ assert sorted(project.keys()) == expected
diff --git a/tests/unittest_pyreverse_writer.py b/tests/unittest_pyreverse_writer.py
new file mode 100644
index 0000000..98bb014
--- /dev/null
+++ b/tests/unittest_pyreverse_writer.py
@@ -0,0 +1,134 @@
+# Copyright (c) 2008, 2010, 2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2021 Mark Byrne <mbyrnepr2@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""
+unit test for visitors.diadefs and extensions.diadefslib modules
+"""
+
+
+import codecs
+import os
+from difflib import unified_diff
+
+import pytest
+
+from pylint.pyreverse.diadefslib import DefaultDiadefGenerator, DiadefsHandler
+from pylint.pyreverse.inspector import Linker, project_from_files
+from pylint.pyreverse.utils import get_visibility
+from pylint.pyreverse.writer import DotWriter
+
+_DEFAULTS = {
+ "all_ancestors": None,
+ "show_associated": None,
+ "module_names": None,
+ "output_format": "dot",
+ "diadefs_file": None,
+ "quiet": 0,
+ "show_ancestors": None,
+ "classes": (),
+ "all_associated": None,
+ "mode": "PUB_ONLY",
+ "show_builtin": False,
+ "only_classnames": False,
+ "output_directory": "",
+}
+
+
+class Config:
+ """config object for tests"""
+
+ def __init__(self):
+ for attr, value in _DEFAULTS.items():
+ setattr(self, attr, value)
+
+
+def _file_lines(path):
+ # we don't care about the actual encoding, but python3 forces us to pick one
+ with codecs.open(path, encoding="latin1") as stream:
+ lines = [
+ line.strip()
+ for line in stream.readlines()
+ if (
+ line.find("squeleton generated by ") == -1
+ and not line.startswith('__revision__ = "$Id:')
+ )
+ ]
+ return [line for line in lines if line]
+
+
+def get_project(module, name="No Name"):
+ """return an astroid project representation"""
+
+ def _astroid_wrapper(func, modname):
+ return func(modname)
+
+ return project_from_files([module], _astroid_wrapper, project_name=name)
+
+
+DOT_FILES = ["packages_No_Name.dot", "classes_No_Name.dot"]
+
+
+@pytest.fixture(scope="module")
+def setup():
+ project = get_project(os.path.join(os.path.dirname(__file__), "data"))
+ linker = Linker(project)
+ CONFIG = Config()
+ handler = DiadefsHandler(CONFIG)
+ dd = DefaultDiadefGenerator(linker, handler).visit(project)
+ for diagram in dd:
+ diagram.extract_relationships()
+ writer = DotWriter(CONFIG)
+ writer.write(dd)
+ yield
+ for fname in DOT_FILES:
+ try:
+ os.remove(fname)
+ except FileNotFoundError:
+ continue
+
+
+@pytest.mark.usefixtures("setup")
+@pytest.mark.parametrize("generated_file", DOT_FILES)
+def test_dot_files(generated_file):
+ expected_file = os.path.join(os.path.dirname(__file__), "data", generated_file)
+ generated = _file_lines(generated_file)
+ expected = _file_lines(expected_file)
+ generated = "\n".join(generated)
+ expected = "\n".join(expected)
+ files = f"\n *** expected : {expected_file}, generated : {generated_file} \n"
+ diff = "\n".join(
+ line for line in unified_diff(expected.splitlines(), generated.splitlines())
+ )
+ assert expected == generated, f"{files}{diff}"
+ os.remove(generated_file)
+
+
+@pytest.mark.parametrize(
+ "names, expected",
+ [
+ (["__reduce_ex__", "__setattr__"], "special"),
+ (["__g_", "____dsf", "__23_9"], "private"),
+ (["simple"], "public"),
+ (
+ ["_", "__", "___", "____", "_____", "___e__", "_nextsimple", "_filter_it_"],
+ "protected",
+ ),
+ ],
+)
+def test_get_visibility(names, expected):
+ for name in names:
+ got = get_visibility(name)
+ assert got == expected, f"got {got} instead of {expected} for value {name}"
diff --git a/tests/unittest_reporters_json.py b/tests/unittest_reporters_json.py
new file mode 100644
index 0000000..11d3776
--- /dev/null
+++ b/tests/unittest_reporters_json.py
@@ -0,0 +1,62 @@
+# Copyright (c) 2014 Vlad Temian <vladtemian@gmail.com>
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 guillaume2 <guillaume.peillex@gmail.col>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+"""Test for the JSON reporter."""
+
+import json
+from io import StringIO
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.reporters import JSONReporter
+from pylint.reporters.ureports.nodes import EvaluationSection
+
+expected_score_message = "Expected score message"
+expected_result = [
+ [
+ ("column", 0),
+ ("line", 1),
+ ("message", "Line too long (1/2)"),
+ ("message-id", "C0301"),
+ ("module", "0123"),
+ ("obj", ""),
+ ("path", "0123"),
+ ("symbol", "line-too-long"),
+ ("type", "convention"),
+ ]
+]
+
+
+def test_simple_json_output_no_score():
+ report = get_linter_result(score=False)
+ assert len(report) == 1
+ report_result = [sorted(report[0].items(), key=lambda item: item[0])]
+ assert report_result == expected_result
+
+
+def get_linter_result(score):
+ output = StringIO()
+ reporter = JSONReporter(output)
+ linter = PyLinter(reporter=reporter)
+ checkers.initialize(linter)
+ linter.config.persistent = 0
+ linter.config.score = score
+ linter.open()
+ linter.set_current_module("0123")
+ linter.add_message("line-too-long", line=1, args=(1, 2))
+ # we call those methods because we didn't actually run the checkers
+ if score:
+ reporter.display_reports(EvaluationSection(expected_score_message))
+ reporter.display_messages(None)
+ report_result = json.loads(output.getvalue())
+ return report_result
diff --git a/tests/unittest_reporting.py b/tests/unittest_reporting.py
new file mode 100644
index 0000000..1c4bda9
--- /dev/null
+++ b/tests/unittest_reporting.py
@@ -0,0 +1,264 @@
+# Copyright (c) 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Calin Don <calin.don@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2019-2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2021 ruro <ruro.ruro@ya.ru>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+# pylint: disable=redefined-outer-name
+
+import warnings
+from contextlib import redirect_stdout
+from io import StringIO
+from json import dumps
+
+import pytest
+
+from pylint import checkers
+from pylint.interfaces import IReporter
+from pylint.lint import PyLinter
+from pylint.reporters import BaseReporter
+from pylint.reporters.text import ParseableTextReporter, TextReporter
+
+
+@pytest.fixture(scope="module")
+def reporter():
+ return TextReporter
+
+
+@pytest.fixture(scope="module")
+def disable():
+ return ["I"]
+
+
+def test_template_option(linter):
+ output = StringIO()
+ linter.reporter.set_output(output)
+ linter.set_option("msg-template", "{msg_id}:{line:03d}")
+ linter.open()
+ linter.set_current_module("0123")
+ linter.add_message("C0301", line=1, args=(1, 2))
+ linter.add_message("line-too-long", line=2, args=(3, 4))
+ assert output.getvalue() == "************* Module 0123\nC0301:001\nC0301:002\n"
+
+
+def test_parseable_output_deprecated():
+ with warnings.catch_warnings(record=True) as cm:
+ warnings.simplefilter("always")
+ ParseableTextReporter()
+
+ assert len(cm) == 1
+ assert isinstance(cm[0].message, DeprecationWarning)
+
+
+def test_parseable_output_regression():
+ output = StringIO()
+ with warnings.catch_warnings(record=True):
+ linter = PyLinter(reporter=ParseableTextReporter())
+
+ checkers.initialize(linter)
+ linter.config.persistent = 0
+ linter.reporter.set_output(output)
+ linter.set_option("output-format", "parseable")
+ linter.open()
+ linter.set_current_module("0123")
+ linter.add_message("line-too-long", line=1, args=(1, 2))
+ assert (
+ output.getvalue() == "************* Module 0123\n"
+ "0123:1: [C0301(line-too-long), ] "
+ "Line too long (1/2)\n"
+ )
+
+
+class NopReporter(BaseReporter):
+ __implements__ = IReporter
+ name = "nop-reporter"
+ extension = ""
+
+ def __init__(self, output=None):
+ super().__init__(output)
+ print("A NopReporter was initialized.", file=self.out)
+
+ def writeln(self, string=""):
+ pass
+
+ def _display(self, layout):
+ pass
+
+
+def test_multi_format_output(tmp_path):
+ text = StringIO(newline=None)
+ json = tmp_path / "somefile.json"
+
+ source_file = tmp_path / "somemodule.py"
+ source_file.write_text('NOT_EMPTY = "This module is not empty"\n')
+ escaped_source_file = dumps(str(source_file))
+
+ nop_format = NopReporter.__module__ + "." + NopReporter.__name__
+ formats = ",".join(["json:" + str(json), "text", nop_format])
+
+ with redirect_stdout(text):
+ linter = PyLinter()
+ linter.set_option("persistent", False)
+ linter.set_option("output-format", formats)
+ linter.set_option("reports", True)
+ linter.set_option("score", True)
+ linter.load_default_plugins()
+
+ assert linter.reporter.linter is linter
+ with pytest.raises(NotImplementedError):
+ linter.reporter.set_output(text)
+
+ linter.open()
+ linter.check_single_file("somemodule", source_file, "somemodule")
+ linter.add_message("line-too-long", line=1, args=(1, 2))
+ linter.generate_reports()
+ linter.reporter.writeln("direct output")
+
+ # Ensure the output files are flushed and closed
+ linter.reporter.close_output_files()
+ del linter.reporter
+
+ with open(json) as f:
+ assert (
+ f.read() == "[\n"
+ " {\n"
+ ' "type": "convention",\n'
+ ' "module": "somemodule",\n'
+ ' "obj": "",\n'
+ ' "line": 1,\n'
+ ' "column": 0,\n'
+ f' "path": {escaped_source_file},\n'
+ ' "symbol": "missing-module-docstring",\n'
+ ' "message": "Missing module docstring",\n'
+ ' "message-id": "C0114"\n'
+ " },\n"
+ " {\n"
+ ' "type": "convention",\n'
+ ' "module": "somemodule",\n'
+ ' "obj": "",\n'
+ ' "line": 1,\n'
+ ' "column": 0,\n'
+ f' "path": {escaped_source_file},\n'
+ ' "symbol": "line-too-long",\n'
+ ' "message": "Line too long (1/2)",\n'
+ ' "message-id": "C0301"\n'
+ " }\n"
+ "]\n"
+ "direct output\n"
+ )
+
+ assert (
+ text.getvalue() == "A NopReporter was initialized.\n"
+ "************* Module somemodule\n"
+ f"{source_file}:1:0: C0114: Missing module docstring (missing-module-docstring)\n"
+ f"{source_file}:1:0: C0301: Line too long (1/2) (line-too-long)\n"
+ "\n"
+ "\n"
+ "Report\n"
+ "======\n"
+ "1 statements analysed.\n"
+ "\n"
+ "Statistics by type\n"
+ "------------------\n"
+ "\n"
+ "+---------+-------+-----------+-----------+------------+---------+\n"
+ "|type |number |old number |difference |%documented |%badname |\n"
+ "+=========+=======+===========+===========+============+=========+\n"
+ "|module |1 |NC |NC |0.00 |0.00 |\n"
+ "+---------+-------+-----------+-----------+------------+---------+\n"
+ "|class |0 |NC |NC |0 |0 |\n"
+ "+---------+-------+-----------+-----------+------------+---------+\n"
+ "|method |0 |NC |NC |0 |0 |\n"
+ "+---------+-------+-----------+-----------+------------+---------+\n"
+ "|function |0 |NC |NC |0 |0 |\n"
+ "+---------+-------+-----------+-----------+------------+---------+\n"
+ "\n"
+ "\n"
+ "\n"
+ "Raw metrics\n"
+ "-----------\n"
+ "\n"
+ "+----------+-------+------+---------+-----------+\n"
+ "|type |number |% |previous |difference |\n"
+ "+==========+=======+======+=========+===========+\n"
+ "|code |2 |66.67 |NC |NC |\n"
+ "+----------+-------+------+---------+-----------+\n"
+ "|docstring |0 |0.00 |NC |NC |\n"
+ "+----------+-------+------+---------+-----------+\n"
+ "|comment |0 |0.00 |NC |NC |\n"
+ "+----------+-------+------+---------+-----------+\n"
+ "|empty |1 |33.33 |NC |NC |\n"
+ "+----------+-------+------+---------+-----------+\n"
+ "\n"
+ "\n"
+ "\n"
+ "Duplication\n"
+ "-----------\n"
+ "\n"
+ "+-------------------------+------+---------+-----------+\n"
+ "| |now |previous |difference |\n"
+ "+=========================+======+=========+===========+\n"
+ "|nb duplicated lines |0 |NC |NC |\n"
+ "+-------------------------+------+---------+-----------+\n"
+ "|percent duplicated lines |0.000 |NC |NC |\n"
+ "+-------------------------+------+---------+-----------+\n"
+ "\n"
+ "\n"
+ "\n"
+ "Messages by category\n"
+ "--------------------\n"
+ "\n"
+ "+-----------+-------+---------+-----------+\n"
+ "|type |number |previous |difference |\n"
+ "+===========+=======+=========+===========+\n"
+ "|convention |2 |NC |NC |\n"
+ "+-----------+-------+---------+-----------+\n"
+ "|refactor |0 |NC |NC |\n"
+ "+-----------+-------+---------+-----------+\n"
+ "|warning |0 |NC |NC |\n"
+ "+-----------+-------+---------+-----------+\n"
+ "|error |0 |NC |NC |\n"
+ "+-----------+-------+---------+-----------+\n"
+ "\n"
+ "\n"
+ "\n"
+ "Messages\n"
+ "--------\n"
+ "\n"
+ "+-------------------------+------------+\n"
+ "|message id |occurrences |\n"
+ "+=========================+============+\n"
+ "|missing-module-docstring |1 |\n"
+ "+-------------------------+------------+\n"
+ "|line-too-long |1 |\n"
+ "+-------------------------+------------+\n"
+ "\n"
+ "\n"
+ "\n"
+ "\n"
+ "-------------------------------------\n"
+ "Your code has been rated at -10.00/10\n"
+ "\n"
+ "direct output\n"
+ )
+
+
+def test_display_results_is_renamed():
+ class CustomReporter(TextReporter):
+ def _display(self, layout):
+ return None
+
+ reporter = CustomReporter()
+ with pytest.raises(AttributeError) as exc:
+ # pylint: disable=no-member
+ reporter.display_results()
+ assert "no attribute 'display_results'" in str(exc)
diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/utils/__init__.py
diff --git a/tests/utils/unittest_ast_walker.py b/tests/utils/unittest_ast_walker.py
new file mode 100644
index 0000000..5bf5b5b
--- /dev/null
+++ b/tests/utils/unittest_ast_walker.py
@@ -0,0 +1,67 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import warnings
+
+import astroid
+
+from pylint.checkers.utils import check_messages
+from pylint.utils import ASTWalker
+
+
+class TestASTWalker:
+ class MockLinter:
+ def __init__(self, msgs):
+ self._msgs = msgs
+
+ def is_message_enabled(self, msgid):
+ return self._msgs.get(msgid, True)
+
+ class Checker:
+ def __init__(self):
+ self.called = set()
+
+ @check_messages("first-message")
+ def visit_module(self, module): # pylint: disable=unused-argument
+ self.called.add("module")
+
+ @check_messages("second-message")
+ def visit_call(self, module):
+ raise NotImplementedError
+
+ @check_messages("second-message", "third-message")
+ def visit_assignname(self, module): # pylint: disable=unused-argument
+ self.called.add("assignname")
+
+ @check_messages("second-message")
+ def leave_assignname(self, module):
+ raise NotImplementedError
+
+ def test_check_messages(self):
+ linter = self.MockLinter(
+ {"first-message": True, "second-message": False, "third-message": True}
+ )
+ walker = ASTWalker(linter)
+ checker = self.Checker()
+ walker.add_checker(checker)
+ walker.walk(astroid.parse("x = func()"))
+ assert {"module", "assignname"} == checker.called
+
+ def test_deprecated_methods(self):
+ class Checker:
+ def __init__(self):
+ self.called = False
+
+ @check_messages("first-message")
+ def visit_assname(self, node): # pylint: disable=unused-argument
+ self.called = True
+
+ linter = self.MockLinter({"first-message": True})
+ walker = ASTWalker(linter)
+ checker = Checker()
+ walker.add_checker(checker)
+ with warnings.catch_warnings(record=True):
+ warnings.simplefilter("always")
+ walker.walk(astroid.parse("x = 1"))
+
+ assert not checker.called
diff --git a/tests/utils/unittest_utils.py b/tests/utils/unittest_utils.py
new file mode 100644
index 0000000..9985b63
--- /dev/null
+++ b/tests/utils/unittest_utils.py
@@ -0,0 +1,39 @@
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2017-2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2017-2018, 2020 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2017 ttenhoeve-aa <ttenhoeve@appannie.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2020 Peter Kolbus <peter.kolbus@gmail.com>
+# Copyright (c) 2020 hippo91 <guillaume.peillex@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/LICENSE
+
+import io
+
+from pylint.utils import utils
+
+
+def test_decoding_stream_unknown_encoding():
+ """decoding_stream should fall back to *some* decoding when given an
+ unknown encoding.
+ """
+ binary_io = io.BytesIO(b"foo\nbar")
+ stream = utils.decoding_stream(binary_io, "garbage-encoding")
+ # should still act like a StreamReader
+ ret = stream.readlines()
+ assert ret == ["foo\n", "bar"]
+
+
+def test_decoding_stream_known_encoding():
+ binary_io = io.BytesIO("€".encode("cp1252"))
+ stream = utils.decoding_stream(binary_io, "cp1252")
+ assert stream.read() == "€"
diff --git a/tox.ini b/tox.ini
new file mode 100644
index 0000000..0d13fa8
--- /dev/null
+++ b/tox.ini
@@ -0,0 +1,85 @@
+[tox]
+minversion = 2.4
+envlist = formatting, py36, py37, py38, py39, py310, pypy, benchmark
+skip_missing_interpreters = true
+
+[testenv:pylint]
+deps =
+ -r {toxinidir}/requirements_test_min.txt
+ pre-commit~=2.13
+commands =
+ pre-commit run pylint --all-files
+
+[testenv:formatting]
+basepython = python3
+deps =
+ -r {toxinidir}/requirements_test_min.txt
+ pre-commit~=2.13
+commands =
+ pre-commit run --all-files
+
+[testenv:mypy]
+basepython = python3
+deps =
+ pre-commit~=2.13
+commands =
+ pre-commit run mypy --all-files
+
+[testenv]
+setenv =
+ COVERAGE_FILE = {toxinidir}/.coverage.{envname}
+deps =
+ -r {toxinidir}/requirements_test.txt
+commands =
+ ; Run tests, ensuring all benchmark tests do not run
+ pytest --benchmark-disable {toxinidir}/tests/ {posargs:}
+
+[testenv:spelling]
+deps =
+ -r {toxinidir}/requirements_test.txt
+commands =
+ pytest {toxinidir}/tests/ {posargs:} -k unittest_spelling
+
+[testenv:coverage-html]
+setenv =
+ COVERAGE_FILE = {toxinidir}/.coverage
+deps =
+ -r {toxinidir}/requirements_test.txt
+skip_install = true
+commands =
+ coverage combine
+ coverage html --ignore-errors --rcfile={toxinidir}/.coveragerc
+
+[testenv:docs]
+changedir = doc/
+deps =
+ -r {toxinidir}/doc/requirements.txt
+commands =
+ sphinx-build -W -b html -d _build/doctrees . _build/html
+
+[testenv:benchmark]
+deps =
+ -r {toxinidir}/requirements_test.txt
+ pygal
+commands =
+ ; Run the only the benchmark tests, grouping output and forcing .json output so we
+ ; can compare benchmark runs
+ pytest --exitfirst \
+ --failed-first \
+ --benchmark-only \
+ --benchmark-save=batch_files \
+ --benchmark-save-data \
+ --benchmark-autosave {toxinidir}/tests \
+ --benchmark-group-by="group" \
+ {posargs:}
+
+[testenv:profile_against_external]
+setenv =
+ PYTEST_PROFILE_EXTERNAL = 1
+deps =
+ -r {toxinidir}/requirements_test.txt
+ gprof2dot
+commands =
+ pytest --exitfirst \
+ --profile-svg \
+ {toxinidir}/tests/profile/test_profile_against_externals.py
