Merge upstream tag v2.11.1.

Test: None
Bug: http://b/206656351
Change-Id: I7831112fa3014bf7998432f9e1ac96be18fca60c

1585 files changed, 99715 insertions, 0 deletions

diff --git a/.copyrite_aliases b/.copyrite_aliases
new file mode 100644
index 000000000..170ba35fa
--- /dev/null
+++ b/.copyrite_aliases
@@ -0,0 +1,102 @@
+[
+  {
+    "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": ["31762852+mbyrnepr2@users.noreply.github.com", "mbyrnepr2@gmail.com"],
+    "authoritative_mail": "31762852+mbyrnepr2@users.noreply.github.com",
+    "name": "Mark Byrne"
+  },
+  {
+    "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 000000000..3e7af77c8
--- /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 000000000..9a701d7f0
--- /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 000000000..0fe17f860
--- /dev/null
+++ b/.github/CONTRIBUTING.md
@@ -0,0 +1,2 @@
+Please read the
+[contribute doc](https://github.com/PyCQA/pylint/blob/main/doc/development_guide/contribute.rst).
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 000000000..29063e2e0
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+tidelift: "pypi/pylint"
+github: [Pierre-Sassoulas, cdce8p, hippo91]
diff --git a/.github/ISSUE_TEMPLATE/BUG-REPORT.yml b/.github/ISSUE_TEMPLATE/BUG-REPORT.yml
new file mode 100644
index 000000000..93386964b
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/BUG-REPORT.yml
@@ -0,0 +1,106 @@
+name: 🐛 Bug report
+description: Report a bug in pylint
+labels: [bug, needs triage]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Thank you for wanting to report a bug in pylint!**
+
+        ⚠ Please make sure that this [issue wasn't already requested][issue search], or already implemented in the main branch.
+
+
+        [issue search]: https://github.com/PyCQA/pylint/issues?q=is%3Aissue+is%3Aopen+
+
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: Bug description
+      description:
+        What is the bug about? Please provide the code that is causing the issue, and
+        configurations used if required
+      placeholder: |
+        # Please disable message unrelated to the bug
+        # pylint: disable=missing-docstring,
+        <a> = b + 1
+      render: python
+    validations:
+      required: true
+  - type: textarea
+    id: configuration
+    attributes:
+      label: Configuration
+      description:
+        Please provide the part of the configuration that is causing the bug if required
+        (Leave this part blank if the configuration is not relevant)
+      placeholder: |
+        # Leave this blank if the configuration is not relevant!
+
+        [MASTER]
+        load-plugins=
+            pylint.extensions.code_style
+
+        [MESSAGE CONTROL]
+        enable=
+            useless-supression
+
+        # ...
+      render: ini
+  - type: textarea
+    id: cmd-used
+    attributes:
+      label: Command used
+      description: What was the command used to invoke pylint?
+      placeholder: |
+        pylint a.py
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: current-behavior
+    attributes:
+      label: Pylint output
+      description: What is the current pylint output?
+      placeholder: |
+        ************* Module a
+        a.py:3:1: E0001: invalid syntax (<unknown>, line 1) (syntax-error)
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: future-behavior
+    attributes:
+      label: Expected behavior
+      description:
+        What would you expect instead? For example expected output or behavior
+    validations:
+      required: true
+  - type: textarea
+    id: python-interpreter
+    attributes:
+      label: Pylint version
+      description: >-
+        Please copy and paste the result of `pylint --version` or specify the range of
+        version affected.
+      placeholder: |
+        pylint 2.9.6
+        astroid 2.6.5
+        Python 3.8.10 (default, Jun  2 2021, 10:49:15) [GCC 9.4.0]
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: OS / Environment
+      description: >-
+        Provide all relevant information below, e.g. OS version, terminal etc.
+      placeholder: Fedora 33, Cygwin, etc.
+  - type: textarea
+    id: additional-deps
+    attributes:
+      label: Additional dependencies
+      description: If applicable ie, if we can't reproduce without it
+      placeholder: |
+        Please copy and paste the result of `pip freeze`. For example:
+        pandas==0.23.2
+        marshmallow==3.10.0
diff --git a/.github/ISSUE_TEMPLATE/FEATURE-REQUEST.yml b/.github/ISSUE_TEMPLATE/FEATURE-REQUEST.yml
new file mode 100644
index 000000000..ea04db095
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/FEATURE-REQUEST.yml
@@ -0,0 +1,45 @@
+name: ✨ Feature request
+description: Suggest an idea for pylint
+labels: [enhancement, needs triage]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Thank you for wanting to make a suggestion for pylint!**
+
+        ⚠ Please make sure that [this feature wasn't already requested][issue search] or already implemented in the main branch.
+
+
+        [issue search]: https://github.com/PyCQA/pylint/issues?q=is%3Aissue+is%3Aopen+
+
+  - type: textarea
+    id: current-problem
+    attributes:
+      label: Current problem
+      description:
+        What are you trying to do, that you are unable to achieve with pylint as it
+        currently stands?
+      placeholder: >-
+        I'm trying to do X and I'm missing feature Y for this to be easily achievable.
+    validations:
+      required: true
+  - type: textarea
+    id: proposed-solution
+    attributes:
+      label: Desired solution
+      description: A clear and concise description of what you want to happen.
+      placeholder: >-
+        When I do X, I want to achieve Y in a situation when Z.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: >
+        Add any other context, links, etc. about the feature here. Describe how the
+        feature would be used, why it is needed and what it would solve.
+
+        **HINT:** You can paste https://gist.github.com links for larger files.
+      placeholder: >-
+        I asked on https://stackoverflow.com/... and the community advised me to do X, Y
+        and Z.
diff --git a/.github/ISSUE_TEMPLATE/QUESTION.yml b/.github/ISSUE_TEMPLATE/QUESTION.yml
new file mode 100644
index 000000000..adce7e227
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/QUESTION.yml
@@ -0,0 +1,48 @@
+name: 🤔 Support question
+description: Questions about pylint that are not covered in the documentation
+labels: [question, needs triage, documentation]
+body:
+  - type: markdown
+    attributes:
+      value: >
+        **Thank you for wanting to report a problem with pylint documentation!**
+
+
+        Please fill out your suggestions below. If the problem seems straightforward,
+        feel free to go ahead and submit a pull request instead!
+
+
+        ⚠ Verify first that your issue is not [already reported on GitHub][issue
+        search].
+
+        💬 If you are seeking community support, please consider [starting a discussion
+        on Discord][Discussions].
+
+
+        [issue search]: https://github.com/PyCQA/pylint/issues?q=is%3Aissue+is%3Aopen+
+
+        [Discussions]: https://discord.gg/Egy6P8AMB5
+
+  - type: textarea
+    id: question
+    attributes:
+      label: Question
+    validations:
+      required: true
+  - type: textarea
+    id: documentation
+    attributes:
+      label: Documentation for future user
+      description:
+        Where did you expect this information to be? What do we need to add or what do
+        we need to reorganize?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: >
+        Add any other context, links, etc. about the question here.
+      placeholder: >-
+        I asked on https://stackoverflow.com/... and the community advised me to do X, Y
+        and Z.
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 000000000..4e8b5ce05
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: 💬 Discord
+    url: https://discord.gg/Egy6P8AMB5
+    about: Astroid and pylint informal dev discussion
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 000000000..5cb6329f6
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,31 @@
+<!--
+Thank you for submitting a PR to pylint!
+
+To ease the process of reviewing your PR, do make sure to complete the following boxes.
+
+- [ ] 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.
+-->
+
+## Type of Changes
+
+<!-- Leave the corresponding lines for the applicable type of change: -->
+
+|     | Type                   |
+| --- | ---------------------- |
+| ✓   | :bug: Bug fix          |
+| ✓   | :sparkles: New feature |
+| ✓   | :hammer: Refactoring   |
+| ✓   | :scroll: Docs          |
+
+## Description
+
+<!--
+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 000000000..bbe6fc2fd
--- /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 000000000..877047a07
--- /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 000000000..2eec5b96c
--- /dev/null
+++ b/.github/workflows/ci.yaml
@@ -0,0 +1,477 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - 2.*
+  pull_request: ~
+
+env:
+  CACHE_VERSION: 3
+  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/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
new file mode 100644
index 000000000..c00e72869
--- /dev/null
+++ b/.github/workflows/codeql-analysis.yml
@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [main]
+  schedule:
+    - cron: "44 16 * * 4"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ["python"]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
+        with:
+          languages: ${{ matrix.language }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+          # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+      # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+      # If this step fails, then you should remove it and run the build manually (see below)
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v1
+
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 https://git.io/JvXDl
+
+      # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+      #    and modify them (or add more) to build your code if your project
+      #    uses a compiled language
+
+      #- run: |
+      #   make bootstrap
+      #   make release
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v1
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 000000000..046af6f7f
--- /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 000000000..3d96061c6
--- /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 000000000..ebaa68b90
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,94 @@
+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.26.0
+    hooks:
+      - id: pyupgrade
+        args: [--py36-plus]
+        exclude: *fixtures
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.9.3
+    hooks:
+      - id: isort
+  - repo: https://github.com/psf/black
+    rev: 21.8b0
+    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/myint/rstcheck
+    rev: "3f92957478422df87bd730abde66f089cc1ee19b"
+    hooks:
+      - id: rstcheck
+        args: ["--ignore-roles=func,class,mod", "--report=warning"]
+        types: [text] # necessary to include ChangeLog file
+        files: ^(ChangeLog|doc/(.*/)*.*\.rst)
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.910
+    hooks:
+      - id: mypy
+        name: mypy
+        entry: mypy
+        language: python
+        types: [python]
+        args: []
+        require_serial: true
+        additional_dependencies:
+          ["platformdirs==2.2.0", "types-pkg_resources==0.1.3", "types-toml==0.1.3"]
+        exclude: tests/functional/|tests/input|tests(/.*)*/data|tests/regrtest_data/|tests/data/|tests(/.*)+/conftest.py|doc/|bin/
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v2.4.0
+    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 000000000..1bec0790e
--- /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 000000000..c0fb27844
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,12 @@
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+sphinx:
+  fail_on_warning: true
+  configuration: doc/conf.py
+
+python:
+  version: 3.8
+  install:
+    - requirements: doc/requirements.txt
diff --git a/CONTRIBUTORS.txt b/CONTRIBUTORS.txt
new file mode 100644
index 000000000..1efde3cb7
--- /dev/null
+++ b/CONTRIBUTORS.txt
@@ -0,0 +1,545 @@
+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.
+
+* Dmitri Prybysh: 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
+
+* Sergei Lebedev (superbobry): contributor
+
+* Maksym Humetskyi (mhumetskyi): contributor
+  - Fixed ignored empty functions by similarities checker with "ignore-signatures" option enabled
+  - Ignore function decorators signatures as well by similarities checker with "ignore-signatures" option enabled
+  - Ignore class methods and nested functions signatures as well by similarities checker with "ignore-signatures" option enabled
+
+* Daniel Dorani (doranid): contributor
+
+* Will Shanks: contributor
+
+* Mark Bell: contributor
+
+* Marco Gorelli: contributor
+  - Documented Jupyter integration
+
+* Rebecca Turner (9999years): contributor
+
+* Yilei Yang: contributor
+
+* Marcin Kurczewski (rr-): contributor
+
+* Eisuke Kawashima (e-kwsm): contributor
+
+* Daniel van Noord (DanielNoord): contributor
+
+* Michal Vasilek: contributor
+
+* Kai Mueller (kasium): contributor
+
+* Sam Vermeiren (PaaEl): contributor
+
+* Phil A. (flying-sheep): contributor
+
+* Melvin Hazeleger (melvio): contributor
+
+* Hayden Richards (SupImDos): contributor
+  - Fixed "no-self-use" for async methods
+  - Fixed "docparams" extension for async functions and methods
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 000000000..c730dc5b0
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,5943 @@
+------------------
+Pylint's ChangeLog
+------------------
+
+
+
+What's New in Pylint 2.12.0?
+============================
+Release date: TBA
+
+..
+  Put new features here and also in 'doc/whatsnew/2.12.rst'
+
+
+
+What's New in Pylint 2.11.2?
+============================
+Release date: TBA
+
+
+
+What's New in Pylint 2.11.1?
+============================
+Release date: 2021-09-16
+
+..
+  Put bug fixes that should not wait for a new minor version here
+
+* ``unspecified-encoding`` now checks the encoding of ``pathlib.Path()`` correctly
+
+  Closes #5017
+
+
+What's New in Pylint 2.11.0?
+============================
+Release date: 2021-09-16
+
+* The python3 porting mode checker and it's ``py3k`` option were removed. You can still find it in older pylint
+  versions.
+
+* ``raising-bad-type`` is now properly emitted when  raising a string
+
+* Added new extension ``SetMembershipChecker`` with ``use-set-for-membership`` check:
+  Emitted when using an in-place defined ``list`` or ``tuple`` to do a membership test. ``sets`` are better optimized for that.
+
+  Closes #4776
+
+
+* Added ``py-version`` config key (if ``[MASTER]`` section). Used for version dependant checks.
+  Will default to whatever Python version pylint is executed with.
+
+* ``CodeStyleChecker``
+
+  * Added ``consider-using-assignment-expr``: Emitted when an assignment is directly followed by an if statement
+    and both can be combined by using an assignment expression ``:=``. Requires Python 3.8
+
+    Closes #4862
+
+* Added ``consider-using-f-string``: Emitted when .format() or '%' is being used to format a string.
+
+  Closes #3592
+
+* Fix false positive for ``consider-using-with`` if a context manager is assigned to a
+  variable in different paths of control flow (e. g. if-else clause).
+
+  Closes #4751
+
+* https is now prefered in the documentation and http://pylint.pycqa.org correctly redirect to https://pylint.pycqa.org
+
+  Closes #3802
+
+* Fix false positive for ``function-redefined`` for simple type annotations
+
+  Closes #4936
+
+* Fix false positive for ``protected-access`` if a protected member is used in type hints of function definitions
+
+* Fix false positive ``dict-iter-missing-items`` for dictionaries only using tuples as keys
+
+  Closes #3282
+
+* The ``unspecified-encoding`` checker now also checks calls to ``pathlib.Path().read_text()``
+  and ``pathlib.Path().write_text()``
+
+  Closes #4945
+
+* Fix false positive ``superfluous-parens`` for tuples created with inner tuples
+
+  Closes #4907
+
+* Fix false positive ``unused-private-member`` for accessing attributes in a class using ``cls``
+
+  Closes #4849
+
+* Fix false positive ``unused-private-member`` for private staticmethods accessed in classmethods.
+
+  Closes #4849
+
+* Extended ``consider-using-in`` check to work for attribute access.
+
+* Setting ``min-similarity-lines`` to 0 now makes the similarty checker stop checking for duplicate code
+
+  Closes #4901
+
+* Fix a bug where pylint complained if the cache's parent directory does not exist
+
+  Closes #4900
+
+* The ``global-variable-not-assigned`` checker now catches global variables that are never reassigned in a
+  local scope and catches (reassigned) functions
+
+  Closes #1375
+  Closes #330
+
+* Fix false positives for invalid-all-format that are lists or tuples at runtime
+
+  Closes #4711
+
+* Fix ``no-self-use`` and ``docparams extension`` for async functions and methods.
+
+* Add documentation for ``pyreverse`` and ``symilar``
+
+  Closes #4616
+
+* Non symbolic messages with the wrong capitalisation now correctly trigger ``use-symbolic-message-instead``
+
+  Closes #5000
+
+* The ``consider-iterating-dictionary`` checker now also considers membership checks
+
+  Closes #4069
+
+* The ``invalid-name`` message is now more detailed when using multiple naming style regexes.
+
+
+What's New in Pylint 2.10.2?
+============================
+Release date: 2021-08-21
+
+* We now use platformdirs instead of appdirs since the latter is not maintained.
+
+  Closes #4886
+
+* Fix a crash in the checker raising ``shallow-copy-environ`` when failing to infer
+  on ``copy.copy``
+
+  Closes #4891
+
+
+
+What's New in Pylint 2.10.1?
+============================
+Release date: 2021-08-20
+
+* pylint does not crash when PYLINT_HOME does not exist.
+
+  Closes #4883
+
+
+What's New in Pylint 2.10.0?
+============================
+Release date: 2021-08-20
+
+* pyreverse: add option to produce colored output.
+
+  Closes #4488
+
+* pyreverse: add output in PlantUML format.
+
+  Closes #4498
+
+* ``consider-using-with`` is no longer triggered if a context manager is returned from a function.
+
+  Closes #4748
+
+* pylint does not crash with a traceback anymore when a file is problematic. It
+  creates a template text file for opening an issue on the bug tracker instead.
+  The linting can go on for other non problematic files instead of being impossible.
+
+* pyreverse: Show class has-a relationships inferred from the type-hint
+
+  Closes #4744
+
+* Fixed a crash when importing beyond the top level package during ``import-error``
+  message creation
+
+  Closes #4775
+
+* Added ``ignored-parents`` option to the design checker to ignore specific
+  classes from the ``too-many-ancestors`` check (R0901).
+
+  Partially closes #3057
+
+* Added ``unspecified-encoding``: Emitted when open() is called without specifying an encoding
+
+  Closes #3826
+
+* Improved the Similarity checker performance. Fix issue with ``--min-similarity-lines`` used with ``--jobs``.
+
+  Close #4120
+  Close #4118
+
+* Don't emit ``no-member`` error if guarded behind if statement.
+
+  Ref #1162
+  Closes #1990
+  Closes #4168
+
+* The default for ``PYLINTHOME`` is now the standard ``XDG_CACHE_HOME``, and pylint now uses ``appdirs``.
+
+  Closes #3878
+
+* Added ``use-list-literal``: Emitted when ``list()`` is called with no arguments instead of using ``[]``
+
+  Closes #4365
+
+* Added ``use-dict-literal``: Emitted when ``dict()`` is called with no arguments instead of using ``{}``
+
+  Closes #4365
+
+* Added optional extension ``consider-ternary-expression``: Emitted whenever a variable is assigned in both branches of an if/else block.
+
+  Closes # 4366
+
+* Added optional extension ``while-used``: Emitted whenever a ``while`` loop is used.
+
+  Closes # 4367
+
+* Added ``forgotten-debug-statement``: Emitted when ``breakpoint``, ``pdb.set_trace`` or ``sys.breakpointhook`` calls are found
+
+  Closes #3692
+
+* Fix false-positive of ``unused-private-member`` when using nested functions in a class
+
+  Closes #4673
+
+* Fix crash for ``unused-private-member`` that occurred with nested attributes.
+
+  Closes #4755
+
+* Fix a false positive for ``unused-private-member`` with class names
+
+  Closes #4681
+
+* Fix false positives for ``superfluous-parens`` with walrus operator, ternary operator and inside list comprehension.
+
+  Closes #2818
+  Closes #3249
+  Closes #3608
+  Closes #4346
+
+* Added ``format-string-without-interpolation`` checker: Emitted when formatting is applied to a string without any variables to be replaced
+
+  Closes #4042
+
+* Refactor of ``--list-msgs`` & ``--list-msgs-enabled``: both options now show whether messages are emittable with the current interpreter.
+
+  Closes #4778
+
+* Fix false negative for ``used-before-assignment`` when the variable is assigned
+  in an exception handler, but used outside of the handler.
+
+  Closes #626
+
+* Added ``disable-next`` option: allows using `# pylint: disable-next=msgid` to disable a message for the following line
+
+  Closes #1682
+
+* Added ``redundant-u-string-prefix`` checker: Emitted when the u prefix is added to a string
+
+  Closes #4102
+
+* Fixed ``cell-var-from-loop`` checker: handle cell variables in comprehensions within functions,
+  and function default argument expressions. Also handle basic variable shadowing.
+
+  Closes #2846
+  Closes #3107
+
+* Fixed bug with ``cell-var-from-loop`` checker: it no longer has false negatives when
+  both ``unused-variable`` and ``used-before-assignment`` are disabled.
+
+* Fix false postive for ``invalid-all-format`` if the list or tuple builtin functions are used
+
+  Closes #4711
+
+* Config files can now contain environment variables
+
+  Closes #3839
+
+* Fix false-positive ``used-before-assignment`` with an assignment expression in a ``Return`` node
+
+  Closes #4828
+
+* Added ``use-sequence-for-iteration``: Emitted when iterating over an in-place defined ``set``.
+
+* ``CodeStyleChecker``
+
+  * Limit ``consider-using-tuple`` to be emitted only for in-place defined ``lists``.
+
+  * Emit ``consider-using-tuple`` even if list contains a ``starred`` expression.
+
+* Ignore decorators lines by similarities checker when ignore signatures flag enabled
+
+  Closes #4839
+
+* Allow ``true`` and ``false`` values in ``pylintrc`` for better compatibility with ``toml`` config.
+
+* Class methods' signatures are ignored the same way as functions' with similarities "ignore-signatures" option enabled
+
+  Closes #4653
+
+* Improve performance when inferring ``Call`` nodes, by utilizing caching.
+
+* Improve error message for invalid-metaclass when the node is an Instance.
+
+
+What's New in Pylint 2.9.6?
+===========================
+Release date: 2021-07-28
+
+* Fix a false positive ``undefined-variable`` when variable name in decoration
+  matches function argument
+
+  Closes #3791
+
+
+What's New in Pylint 2.9.5?
+===========================
+Release date: 2021-07-21
+
+* Fix a crash when there would be a 'TypeError object does not support
+  item assignment' in the code we parse.
+
+  Closes #4439
+
+* Fix crash if a callable returning a context manager was assigned to a list or dict item
+
+  Closes #4732
+
+* Fix a crash when a AttributeInferenceError was not handled properly when
+  failing to infer the real name of an import in astroid.
+
+  Closes #4692
+
+
+What's New in Pylint 2.9.4?
+===========================
+Release date: 2021-07-20
+
+* Added ``time.clock`` to deprecated functions/methods for python 3.3
+
+* Fix bug in which --fail-on can return a zero exit code even when the specified issue is present
+
+  Closes #4296
+  Closes #3363
+
+* Fix hard failure when handling missing attribute in a class with duplicated bases
+
+  Closes #4687
+
+* Fix false-positive ``consider-using-with`` (R1732) if a ternary conditional is used together with ``with``
+
+  Closes #4676
+
+* Fix false-positive ``deprecated-module`` when relative import uses deprecated module name.
+
+  Closes #4629
+
+* Fix false-positive ``consider-using-with`` (R1732) if ``contextlib.ExitStack`` takes care of calling the ``__exit__`` method
+
+  Closes #4654
+
+* Fix a false positive for ``unused-private-member`` when mutating a private attribute
+  with ``cls``
+
+  Closes #4657
+
+* Fix ignored empty functions by similarities checker with "ignore-signatures" option enabled
+
+  Closes #4652
+
+* Fix false-positive of ``use-maxsplit-arg`` when index is incremented in
+  a loop
+
+  Closes #4664
+
+* Don't emit ``cyclic-import`` message if import is guarded by ``typing.TYPE_CHECKING``.
+
+  Closes #3525
+
+* Fix false-positive ``not-callable`` with alternative ``TypedDict`` syntax
+
+  Closes #4715
+
+* Clarify documentation for consider-using-from-import
+
+* Don't emit ``unreachable`` warning for empty generator functions
+
+  Closes #4698
+
+* Don't emit ``import-error``, ``no-name-in-module``, and ``ungrouped-imports``
+  for imports guarded by ``sys.version_info`` or ``typing.TYPE_CHECKING``.
+
+  Closes #3285
+  Closes #3382
+
+* Fix ``invalid-overridden-method`` with nested property
+
+  Closes #4368
+
+* Fix false-positive of ``unused-private-member`` when using ``__new__`` in a class
+
+  Closes #4668
+
+* No longer emit ``consider-using-with`` for ``ThreadPoolExecutor`` and ``ProcessPoolExecutor``
+  as they have legitimate use cases without a ``with`` block.
+
+  Closes #4689
+
+* Fix crash when inferring variables assigned in match patterns
+
+  Closes #4685
+
+* Fix a crash when a StopIteration was raised when inferring
+  a faulty function in a context manager.
+
+  Closes #4723
+
+
+What's New in Pylint 2.9.3?
+===========================
+Release date: 2021-07-01
+
+
+* Fix a crash that happened when analysing empty function with docstring
+  in the ``similarity`` checker.
+
+  Closes #4648
+
+* The ``similarity`` checker no longer add three trailing whitespaces for
+  empty lines in its report.
+
+
+What's New in Pylint 2.9.2?
+===========================
+Release date: 2021-07-01
+
+* Fix a crash that happened when analysing code using ``type(self)`` to access
+  a class attribute in the ``unused-private-member`` checker.
+
+  Closes #4638
+
+* Fix a false positive for ``unused-private-member`` when accessing a private variable
+  with ``self``
+
+  Closes #4644
+
+* Fix false-positive of ``unnecessary-dict-index-lookup`` and ``consider-using-dict-items``
+  for reassigned dict index lookups
+
+  Closes #4630
+
+
+What's New in Pylint 2.9.1?
+===========================
+Release date: 2021-06-30
+
+* Upgrade astroid to 2.6.2
+
+  Closes #4631
+  Closes #4633
+
+
+What's New in Pylint 2.9.0?
+===========================
+Release date: 2021-06-29
+
+* Python 3.10 is now supported.
+
+* Add type annotations to pyreverse dot files
+
+  Closes #1548
+
+* Fix missing support for detecting deprecated aliases to existing
+  functions/methods.
+
+  Closes #4618
+
+* astroid has been upgraded to 2.6.1
+
+* Added various deprecated functions/methods for python 3.10, 3.7, 3.6 and 3.3
+
+* Fix false positive ``useless-type-doc`` on ignored argument using ``pylint.extensions.docparams``
+  when a function was typed using pep484 but not inside the docstring.
+
+  Closes #4117
+  Closes #4593
+
+* ``setuptools_scm`` has been removed and replaced by ``tbump`` in order to not
+  have hidden runtime dependencies to setuptools
+
+* Fix a crash when a test function is decorated with ``@pytest.fixture`` and astroid can't
+  infer the name of the decorator when using ``open`` without ``with``.
+
+  Closes #4612
+
+* 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
+
+* Fix ``unused-import`` false positive for imported modules referenced in
+  attribute lookups in type comments.
+
+  Closes #4603
+
+
+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?
+===========================
+Release date: 2021-02-16
+
+* 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
+
+* 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: 2016-07-15
+
+    * 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 000000000..aafe62a6a
--- /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 000000000..8c4c849e2
--- /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 000000000..0ea68b181
--- /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 000000000..388a974cc
--- /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=main
+    :target: https://github.com/PyCQA/pylint/actions
+
+.. image:: https://coveralls.io/repos/github/PyCQA/pylint/badge.svg?branch=main
+    :target: https://coveralls.io/github/PyCQA/pylint?branch=main
+
+
+.. 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/main.svg
+   :target: https://results.pre-commit.ci/latest/github/PyCQA/pylint/main
+   :alt: pre-commit.ci status
+
+.. |tideliftlogo| image:: https://raw.githubusercontent.com/PyCQA/pylint/main/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/main/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/main/doc/logo.png>`_
+- `doc/logo.svg <https://raw.githubusercontent.com/PyCQA/pylint/main/doc/logo.svg>`_
diff --git a/doc/Makefile b/doc/Makefile
new file mode 100644
index 000000000..9d8ba8335
--- /dev/null
+++ b/doc/Makefile
@@ -0,0 +1,161 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PIP           = pip
+PAPER         =
+BUILDDIR      = _build
+PYTHON        = /usr/bin/env python
+PYTHONPATH    =
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest all
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+	-rm -f reference_guide/features.rst
+	-rm -f extensions.rst
+
+html: features.rst extensions.rst
+	@echo
+	@echo "Install dependencies"
+	$(PIP) install python-docs-theme
+	@echo "Finished installing dependencies"
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Pylint.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Pylint.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/Pylint"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Pylint"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+
+extensions.rst: exts/pylint_extensions.py
+extensions.rst: $(shell find ../pylint/extensions -type f -regex '.*\.py')
+extensions.rst: $(shell find ../pylint/extensions -type f -regex '.*\.rst')
+	rm -f extensions.rst
+	PYTHONPATH=$(PYTHONPATH) $(PYTHON) ./exts/pylint_extensions.py
+
+features.rst: exts/pylint_features.py
+features.rst: $(shell find ../pylint/checkers -type f -regex '.*\.py')
+	rm -f features.rst
+	PYTHONPATH=$(PYTHONPATH) $(PYTHON) ./exts/pylint_features.py
+
+gen-examples:
+	chmod u+w ../examples/pylintrc
+	pylint --rcfile=/dev/null --generate-rcfile > ../examples/pylintrc
+
+gen-man:
+	chmod u+w ../man/pylint.1
+	pylint --rcfile=/dev/null --generate-man > ../man/pylint.1
+
+all: html gen-man gen-examples
diff --git a/doc/additional_commands/index.rst b/doc/additional_commands/index.rst
new file mode 100644
index 000000000..e4c92cab3
--- /dev/null
+++ b/doc/additional_commands/index.rst
@@ -0,0 +1,109 @@
+
+Additional Commands
+===================
+
+Pylint ships with some additional tools that can be executed from the command line once Pylint itself is installed.
+
+
+Pyreverse
+---------
+
+``pyreverse`` analyzes your source code and generates package and class diagrams.
+It supports output to ``.dot``/``.gv``, ``.vcg`` and ``.puml``/``.plantuml`` (PlantUML) file formats.
+If Graphviz (or the ``dot`` command) is installed, all `output formats supported by Graphviz <https://graphviz.org/docs/outputs/>`_
+can be used as well. In this case, ``pyreverse`` first generates a temporary ``.gv`` file, which is then
+fed to Graphviz to generate the final image.
+
+Running Pyreverse
+'''''''''''''''''
+
+To run ``pyreverse``, use::
+
+  pyreverse [options] <packages>
+
+<packages> can also be a single Python module.
+To see a full list of the available options, run::
+
+   pyreverse -h
+
+
+Example Output
+''''''''''''''
+
+Example diagrams generated with the ``.puml`` output format are shown below.
+
+Class Diagram
+.............
+
+.. image:: ../media/pyreverse_example_classes.png
+   :width: 625
+   :height: 589
+   :alt: Class diagram generated by pyreverse
+   :align: center
+
+
+Package Diagram
+...............
+
+.. image:: ../media/pyreverse_example_packages.png
+   :width: 344
+   :height: 177
+   :alt: Package diagram generated by pyreverse
+   :align: center
+
+
+Creating Class Diagrams for Specific Classes
+''''''''''''''''''''''''''''''''''''''''''''
+
+In many cases creating a single diagram depicting all classes in the project yields a rather unwieldy, giant diagram.
+While limiting the input path to a single package or module can already help greatly to narrow down the scope, the ``-c`` option
+provides another way to create a class diagram focusing on a single class and its collaborators.
+For example, running::
+
+  pyreverse -ASmy -c pylint.checkers.classes.ClassChecker pylint
+
+will generate the full class and package diagrams for ``pylint``, but will additionally generate a file ``pylint.checkers.classes.ClassChecker.dot``:
+
+.. image:: ../media/ClassChecker_diagram.png
+   :width: 757
+   :height: 1452
+   :alt: Package diagram generated by pyreverse
+   :align: center
+
+
+Symilar
+-------
+
+The console script ``symilar`` finds copy pasted blocks in a set of files. It provides a command line interface to the ``Similar`` class, which includes the logic for
+Pylint's ``duplicate-code`` message.
+It can be invoked with::
+
+  symilar [-d|--duplicates min_duplicated_lines] [-i|--ignore-comments] [--ignore-docstrings] [--ignore-imports] [--ignore-signatures] file1...
+
+All files that shall be checked have to be passed in explicitly, e.g.::
+
+  symilar foo.py, bar.py, subpackage/spam.py, subpackage/eggs.py
+
+``symilar`` produces output like the following::
+
+  17 similar lines in 2 files
+  ==tests/data/clientmodule_test.py:3
+  ==tests/data/suppliermodule_test.py:12
+    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'
+  TOTAL lines=58 duplicates=17 percent=29.31
diff --git a/doc/backlinks.rst b/doc/backlinks.rst
new file mode 100644
index 000000000..375386cd6
--- /dev/null
+++ b/doc/backlinks.rst
@@ -0,0 +1,14 @@
+
+Some projects using Pylint
+--------------------------
+The following projects are known to use Pylint to help develop better
+Python code:
+
+* edX (https://github.com/edx)
+* qutebrowser (https://github.com/The-Compiler/qutebrowser)
+* Odoo (https://github.com/OCA)
+* Landscape.io (https://github.com/landscapeio/)
+* Codacy (https://github.com/Codacy/)
+* SaltStack (https://github.com/saltstack)
+* CodeFactor (https://github.com/codefactor-io)
+* many more...
diff --git a/doc/conf.py b/doc/conf.py
new file mode 100644
index 000000000..d76cc67e3
--- /dev/null
+++ b/doc/conf.py
@@ -0,0 +1,242 @@
+#
+# Pylint documentation build configuration file, created by
+# sphinx-quickstart on Thu Apr  4 20:31:25 2013.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import os
+import sys
+from datetime import datetime
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+from pylint import __version__
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.append(os.path.abspath("exts"))
+
+# -- General configuration -----------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = [
+    "pylint_features",
+    "pylint_extensions",
+    "sphinx.ext.autosectionlabel",
+    "sphinx.ext.intersphinx",
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix of source filenames.
+source_suffix = ".rst"
+
+# The encoding of source files.
+# source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = "index"
+
+# General information about the project.
+project = "Pylint"
+current_year = datetime.utcnow().year
+copyright = f"2003-{current_year}, Logilab, PyCQA and contributors"
+
+# The full version, including alpha/beta/rc tags.
+release = __version__
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+# language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+# today = ''
+# Else, today_fmt is used as the format for a strftime call.
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ["_build"]
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = "python_docs_theme"
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+html_theme_options = {
+    "collapsiblesidebar": True,
+    "issues_url": "https://github.com/pycqa/pylint/issues/new",
+    "root_name": "PyCQA",
+    "root_url": "https://meta.pycqa.org/en/latest/",
+}
+
+# Add any paths that contain custom themes here, relative to this directory.
+# html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+# html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+# html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+# html_static_path = ['_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+html_last_updated_fmt = "%b %d, %Y"
+
+smartquotes = False
+
+# Custom sidebar templates, maps document names to template names.
+html_sidebars = {
+    "**": ["localtoc.html", "globaltoc.html", "relations.html", "sourcelink.html"]
+}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+# html_domain_indices = True
+
+# If false, no index is generated.
+# html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+# html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+# html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+# html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+# html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "Pylintdoc"
+
+
+# -- Options for LaTeX output --------------------------------------------------
+
+# The paper size ('letter' or 'a4').
+# latex_paper_size = 'letter'
+
+# The font size ('10pt', '11pt' or '12pt').
+# latex_font_size = '10pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass [howto/manual]).
+latex_documents = [
+    (
+        "index",
+        "Pylint.tex",
+        "Pylint Documentation",
+        "Logilab, PyCQA and contributors",
+        "manual",
+    )
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+# latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+# latex_use_parts = False
+
+# If true, show page references after internal links.
+# latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+# latex_show_urls = False
+
+# Additional stuff for the LaTeX preamble.
+# latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+# latex_appendices = []
+
+# If false, no module index is generated.
+# latex_domain_indices = True
+
+
+# -- Options for manual page output --------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    ("index", "pylint", "Pylint Documentation", ["Logilab, PyCQA and contributors"], 1)
+]
+
+intersphinx_mapping = {
+    "astroid": ("https://astroid.readthedocs.io/en/latest/", None),
+    "python": ("https://docs.python.org/3", None),
+}
+
+# Prevent label issues due to colliding section names
+# through including multiple documents
+autosectionlabel_prefix_document = True
diff --git a/doc/development_guide/contribute.rst b/doc/development_guide/contribute.rst
new file mode 100644
index 000000000..d846805ac
--- /dev/null
+++ b/doc/development_guide/contribute.rst
@@ -0,0 +1,203 @@
+.. -*- coding: utf-8 -*-
+
+==============
+ Contributing
+==============
+
+.. _bug reports, feedback:
+
+Bug reports, feedback
+---------------------
+
+You think you have found a bug in Pylint? Well, this may be the case
+since Pylint is under heavy development!
+
+Please take the time to check if it is already in the issue tracker at
+https://github.com/PyCQA/pylint
+
+If you cannot find it in the tracker, create a new issue there or discuss your
+problem on the code-quality@python.org mailing list or using the discord
+server https://discord.gg/Egy6P8AMB5.
+
+The code-quality mailing list is also a nice place to provide feedback about
+Pylint, since it is shared with other tools that aim at improving the quality of
+python code.
+
+Note that if you don't find something you have expected in Pylint's issue
+tracker, it may be because it is an issue with one of its dependencies, namely
+astroid:
+
+* https://github.com/PyCQA/astroid
+
+.. _Mailing lists:
+
+Discord server
+--------------
+
+https://discord.gg/Egy6P8AMB5
+
+Mailing lists
+-------------
+
+You can subscribe to this mailing list at
+https://mail.python.org/mailman/listinfo/code-quality
+
+Archives are available at
+https://mail.python.org/pipermail/code-quality/
+
+Archives before April 2013 are available at
+https://lists.logilab.org/pipermail/python-projects/
+
+
+.. _repository:
+
+Repository
+----------
+
+Pylint is developed using the git_ distributed version control system.
+
+You can clone Pylint and its dependencies from ::
+
+  git clone https://github.com/PyCQA/pylint
+  git clone https://github.com/PyCQA/astroid
+
+.. _git: https://git-scm.com/
+
+Got a change for Pylint?  Below are a few steps you should take to make sure
+your patch gets accepted.
+
+- Test your code
+
+  * Pylint is very well tested, with a high code coverage.
+    It has two types of tests, usual unittests and functional tests.
+
+    The usual unittests can be found under `/pylint/test` directory and they can
+    be used for testing almost anything Pylint related. But for the ease
+    of testing Pylint's messages, we also have the concept of functional tests.
+
+  * You should also run all the tests to ensure that your change isn't a
+    breaking one. You can run the tests using the tox_ package, as in::
+
+      python -m tox
+      python -m tox -epy36 # for Python 3.6 suite only
+      python -m tox -epylint # for running Pylint over Pylint's codebase
+      python -m tox -eformatting # for running formatting checks over Pylint's codebase
+
+  * It's usually a good idea to run tox_ with ``--recreate``. This is needed because
+    the tox environment might use an older version of astroid_, which can cause various failures
+    when you are running against the latest pylint::
+
+     python -m tox --recreate # The entire tox environment is going to be recreated
+
+
+  * To run only a specific test suite, use a pattern for the test filename
+    (**without** the ``.py`` extension), as in::
+
+      python -m tox -e py36 -- -k test_functional
+      python -m tox -e py36 -- -k  \*func\*
+
+  * Since we just use pytest_ to run the tests, you can also use it as well,
+    although we highly recommend using tox_ instead::
+
+      pytest pylint -k test_functional
+
+  * ``pylint`` uses black_ and isort_ among other Python autoformatters.
+    We have a pre-commit hook which should take care of the autoformatting for
+    you. To enable it, do the following:
+
+     * install ``pre-commit`` using ``pip install pre-commit``
+
+     * then run ``pre-commit install`` in the ``pylint`` root directory to enable the git hooks.
+
+- Add a short entry to the ChangeLog describing the change, except for internal
+  implementation only changes. Not usually required, but for changes other than small
+  bugs we also add a couple of sentences in the release document for that release,
+  (`What's New` section). For the release document we usually write some more details,
+  and it is also a good place to offer examples on how the new change is supposed to work.
+
+- Add a short entry in :file:`doc/whatsnew/VERSION.rst`.
+
+- Add yourself to the `CONTRIBUTORS` file, flag yourself appropriately
+  (if in doubt, you're a ``contributor``).
+
+- Write a comprehensive commit message
+
+- Relate your change to an issue in the tracker if such an issue exists (see
+  `Closing issues via commit messages`_ of the GitHub documentation for more
+  information on this)
+
+- Document your change, if it is a non-trivial one.
+
+- Send a pull request from GitHub (see `About pull requests`_ for more insight
+  about this topic)
+
+
+.. _functional_tests:
+
+Functional Tests
+----------------
+
+These are residing under '/pylint/test/functional' and they are formed of multiple
+components. First, each Python file is considered to be a test case and it
+should be accompanied by a .txt file, having the same name, with the messages
+that are supposed to be emitted by the given test file.
+
+In the Python file, each line for which Pylint is supposed to emit a message
+has to be annotated with a comment in the form ``# [message_symbol]``, as in::
+
+    a, b, c = 1 # [unbalanced-tuple-unpacking]
+
+If multiple messages are expected on the same line, then this syntax can be used::
+
+    a, b, c = 1.test # [unbalanced-tuple-unpacking, no-member]
+
+You can also use ``# +n: [`` with n an integer if the above syntax would make the line too long or other reasons::
+
+    # +1: [empty-comment]
+    #
+
+If you need special control over Pylint's flag, you can also create a .rc file, which
+can have sections of Pylint's configuration.
+
+During development, it's sometimes helpful to run all functional tests in your
+current environment in order to have faster feedback. Run from Pylint root directory with::
+
+    python tests/test_functional.py
+
+You can use all the options you would use for pytest, for example `-k "test_functional[len_checks]"`.
+If required the .txt file can be re-generated from the current output by appending
+`--update-functional-output` to the command line::
+
+    python tests/test_functional.py --update-functional-output -k "test_functional[len_checks]"
+
+.. _`Closing issues via commit messages`: https://help.github.com/articles/closing-issues-via-commit-messages/
+.. _`About pull requests`: https://help.github.com/articles/using-pull-requests/
+.. _tox: https://tox.readthedocs.io/en/latest/
+.. _pytest: https://pytest.readthedocs.io/en/latest/
+.. _black: https://github.com/ambv/black
+.. _isort: https://github.com/timothycrosley/isort
+.. _astroid: https://github.com/pycqa/astroid
+
+
+Tips for Getting Started with Pylint Development
+------------------------------------------------
+* Read the :ref:`technical-reference`. It gives a short walk through of the pylint
+  codebase and will help you identify where you will need to make changes
+  for what you are trying to implement.
+
+* :func:`astroid.extract_node` is your friend. Most checkers are AST based,
+  so you will likely need to interact with :mod:`astroid`.
+  A short example of how to use :func:`astroid.extract_node` is given
+  :ref:`here <astroid_extract_node>`.
+
+* When fixing a bug for a specific check, search the code for the warning
+  message to find where the warning is raised,
+  and therefore where the logic for that code exists.
+
+
+Building the documentation
+----------------------------
+
+We use **tox** for building the documentation::
+
+  $ tox -e docs
diff --git a/doc/development_guide/index.rst b/doc/development_guide/index.rst
new file mode 100644
index 000000000..d4804a435
--- /dev/null
+++ b/doc/development_guide/index.rst
@@ -0,0 +1,9 @@
+
+Development
+===========
+
+.. toctree::
+   :maxdepth: 2
+   :titlesonly:
+
+   contribute
diff --git a/doc/exts/pylint_extensions.py b/doc/exts/pylint_extensions.py
new file mode 100755
index 000000000..4dc6f184f
--- /dev/null
+++ b/doc/exts/pylint_extensions.py
@@ -0,0 +1,115 @@
+#!/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/main/LICENSE
+
+"""Script used to generate the extensions file before building the actual documentation."""
+
+import os
+import re
+import sys
+
+import sphinx
+
+from pylint.constants import MAIN_CHECKER_NAME
+from pylint.lint import PyLinter
+from pylint.utils import get_rst_title
+
+# Some modules have been renamed and deprecated under their old names.
+# Skip documenting these modules since:
+# 1) They are deprecated, why document them moving forward?
+# 2) We can't load the deprecated module and the newly renamed module at the
+# same time without getting naming conflicts
+DEPRECATED_MODULES = ["check_docs"]  # ==> docparams
+
+
+def builder_inited(app):
+    """Output full documentation in ReST format for all extension modules"""
+    # PACKAGE/docs/exts/pylint_extensions.py --> PACKAGE/
+    base_path = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    )
+    # PACKAGE/ --> PACKAGE/pylint/extensions
+    ext_path = os.path.join(base_path, "pylint", "extensions")
+    modules = []
+    doc_files = {}
+    for filename in os.listdir(ext_path):
+        name, ext = os.path.splitext(filename)
+        if name[0] == "_" or name in DEPRECATED_MODULES:
+            continue
+        if ext == ".py":
+            modules.append(f"pylint.extensions.{name}")
+        elif ext == ".rst":
+            doc_files["pylint.extensions." + name] = os.path.join(ext_path, filename)
+    modules.sort()
+    if not modules:
+        sys.exit("No Pylint extensions found?")
+
+    linter = PyLinter()
+    linter.load_plugin_modules(modules)
+
+    extensions_doc = os.path.join(
+        base_path, "doc", "technical_reference", "extensions.rst"
+    )
+    with open(extensions_doc, "w") as stream:
+        stream.write(
+            get_rst_title("Optional Pylint checkers in the extensions module", "=")
+        )
+        stream.write("Pylint provides the following optional plugins:\n\n")
+        for module in modules:
+            stream.write(f"- :ref:`{module}`\n")
+        stream.write("\n")
+        stream.write(
+            "You can activate any or all of these extensions "
+            "by adding a ``load-plugins`` line to the ``MASTER`` "
+            "section of your ``.pylintrc``, for example::\n"
+        )
+        stream.write(
+            "\n    load-plugins=pylint.extensions.docparams,"
+            "pylint.extensions.docstyle\n\n"
+        )
+        by_checker = get_plugins_info(linter, doc_files)
+        for checker, information in sorted(by_checker.items()):
+            linter._print_checker_doc(information, stream=stream)
+
+
+def get_plugins_info(linter, doc_files):
+    by_checker = {}
+    for checker in linter.get_checkers():
+        if checker.name == MAIN_CHECKER_NAME:
+            continue
+        module = checker.__module__
+        # Plugins only - skip over core checkers
+        if re.match("pylint.checkers", module):
+            continue
+        # Find any .rst documentation associated with this plugin
+        doc = ""
+        doc_file = doc_files.get(module)
+        if doc_file:
+            with open(doc_file) as f:
+                doc = f.read()
+        try:
+            by_checker[checker]["checker"] = checker
+            by_checker[checker]["options"] += checker.options_and_values()
+            by_checker[checker]["msgs"].update(checker.msgs)
+            by_checker[checker]["reports"] += checker.reports
+            by_checker[checker]["doc"] += doc
+            by_checker[checker]["module"] += module
+        except KeyError:
+            by_checker[checker] = {
+                "checker": checker,
+                "options": list(checker.options_and_values()),
+                "msgs": dict(checker.msgs),
+                "reports": list(checker.reports),
+                "doc": doc,
+                "module": module,
+            }
+    return by_checker
+
+
+def setup(app):
+    app.connect("builder-inited", builder_inited)
+    return {"version": sphinx.__display_version__}
+
+
+if __name__ == "__main__":
+    builder_inited(None)
diff --git a/doc/exts/pylint_features.py b/doc/exts/pylint_features.py
new file mode 100755
index 000000000..7a296986c
--- /dev/null
+++ b/doc/exts/pylint_features.py
@@ -0,0 +1,35 @@
+#!/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/main/LICENSE
+
+"""Script used to generate the features file before building the actual documentation."""
+
+import os
+
+import sphinx
+
+from pylint.lint import PyLinter
+
+
+def builder_inited(app):
+    # PACKAGE/docs/exts/pylint_extensions.py --> PACKAGE/
+    base_path = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    )
+    linter = PyLinter()
+    linter.load_default_plugins()
+    features = os.path.join(base_path, "doc", "technical_reference", "features.rst")
+    with open(features, "w") as stream:
+        stream.write("Pylint features\n")
+        stream.write("===============\n\n")
+        stream.write(".. generated by pylint --full-documentation\n\n")
+        linter.print_full_documentation(stream)
+
+
+def setup(app):
+    app.connect("builder-inited", builder_inited)
+    return {"version": sphinx.__display_version__}
+
+
+if __name__ == "__main__":
+    builder_inited(None)
diff --git a/doc/faq.rst b/doc/faq.rst
new file mode 100644
index 000000000..479d3c052
--- /dev/null
+++ b/doc/faq.rst
@@ -0,0 +1,269 @@
+.. -*- coding: utf-8 -*-
+
+.. _faq:
+
+==========================
+Frequently Asked Questions
+==========================
+
+1. About Pylint
+===============
+
+1.1 What is Pylint?
+--------------------
+
+Pylint is a `static code checker`_, meaning it can analyse your code without
+actually running it. Pylint checks for errors, tries to enforce a coding
+standard, and tries to enforce a coding style.
+
+.. _`static code checker`: https://en.wikipedia.org/wiki/Static_code_analysis
+
+
+2. Installation
+===============
+
+2.1 How do I install Pylint?
+----------------------------
+
+Everything should be explained on :ref:`installation`.
+
+2.2 What kind of versioning system does Pylint use?
+---------------------------------------------------
+
+Pylint uses git. To get the latest version of Pylint from the repository, simply invoke ::
+
+    git clone https://github.com/PyCQA/pylint
+
+.. _git: https://git-scm.com/
+
+2.3 What are Pylint's dependencies?
+-----------------------------------
+
+Pylint depends on astroid_ and a couple of other packages.
+See the following section for details on what versions of Python are
+supported.
+
+.. _`astroid`: https://github.com/PyCQA/astroid
+
+2.4 What versions of Python is Pylint supporting?
+--------------------------------------------------
+
+The supported running environment since Pylint 2.7.X is Python 3.6+.
+
+
+3. Running Pylint
+=================
+
+3.1 Can I give pylint a file as an argument instead of a module?
+-----------------------------------------------------------------
+
+Pylint expects the name of a package or module as its argument. As a
+convenience, you can give it a file name if it's possible to guess a module name from
+the file's path using the python path. Some examples :
+
+"pylint mymodule.py" should always work since the current working
+directory is automatically added on top of the python path
+
+"pylint directory/mymodule.py" will work if "directory" is a python
+package (i.e. has an __init__.py file), an implicit namespace package
+or if "directory" is in the python path.
+
+"pylint /whatever/directory/mymodule.py" will work if either:
+
+    - "/whatever/directory" is in the python path
+
+    - your cwd is "/whatever/directory"
+
+    - "directory" is a python package and "/whatever" is in the python
+          path
+
+        - "directory" is an implicit namespace package and is in the python path.
+
+    - "directory" is a python package and your cwd is "/whatever" and so
+          on...
+
+3.2 Where is the persistent data stored to compare between successive runs?
+----------------------------------------------------------------------------
+
+Analysis data are stored as a pickle file in a directory which is
+localized using the following rules:
+
+* value of the PYLINTHOME environment variable if set
+
+* "pylint" subdirectory of the user's XDG_CACHE_HOME if the environment variable is set, otherwise
+
+        - Linux: "~/.cache/pylint"
+
+        - Mac OS X: "~/Library/Caches/pylint"
+
+        - Windows: "C:\Users\<username>\AppData\Local\pylint"
+
+* ".pylint.d" directory in the current directory
+
+3.3 How do I find the option name (for pylintrc) corresponding to a specific command line option?
+--------------------------------------------------------------------------------------------------------
+
+You can generate a sample pylintrc file with --generate-rcfile
+Every option present on the command line before this will be included in
+the rc file
+
+For example::
+
+    pylint --disable=bare-except,invalid-name --class-rgx='[A-Z][a-z]+' --generate-rcfile
+
+3.4 I'd rather not run Pylint from the command line. Can I integrate it with my editor?
+---------------------------------------------------------------------------------------
+
+Much probably. Read :ref:`ide-integration`
+
+
+4. Message Control
+==================
+
+4.1 How to disable a particular message?
+-----------------------------------------------------------
+
+For a single line : Add ``#pylint: disable=some-message,another-one`` at the
+end of the desired line of code. Since Pylint 2.10 you can also use
+``#pylint: disable-next=...`` on the line just above the problem.
+``...`` in the following example is a short hand for the list of
+messages you want to disable.
+
+For larger disable : You can add ``#pylint: disable=...`` at the block level to
+disable for the block. It's possible to enable for the reminder of the block
+with ``#pylint: enable=...`` A block is either a scope (say a function, a module),
+or a multiline statement (try, finally, if statements, for loops).
+`It's currently impossible to disable inside an else block`_
+
+Read :ref:`message-control` for details and examples.
+
+.. _`It's currently impossible to disable inside an else block`: https://github.com/PyCQA/pylint/issues/872
+
+4.2 Is there a way to disable a message for a particular module only?
+---------------------------------------------------------------------
+
+Yes, you can disable or enable (globally disabled) messages at the
+module level by adding the corresponding option in a comment at the
+top of the file: ::
+
+    # pylint: disable=wildcard-import, method-hidden
+    # pylint: enable=too-many-lines
+
+4.3 How can I tell Pylint to never check a given module?
+--------------------------------------------------------
+
+Add ``#pylint: skip-file`` at the beginning of the module.
+
+In order to ease finding which modules are ignored an Information-level message
+`file-ignored` is emitted.
+
+4.4 Do I have to remember all these numbers?
+--------------------------------------------
+
+No, you can use symbolic names for messages::
+
+    # pylint: disable=fixme, line-too-long
+
+
+4.5 I have a callback function where I have no control over received arguments. How do I avoid getting unused argument warnings?
+----------------------------------------------------------------------------------------------------------------------------------
+
+Prefix (ui) the callback's name by `cb_`, as in cb_onclick(...). By
+doing so arguments usage won't be checked. Another solution is to
+use one of the names defined in the "dummy-variables" configuration
+variable for unused argument ("_" and "dummy" by default).
+
+4.6 What is the format of the configuration file?
+---------------------------------------------------
+
+Pylint uses ConfigParser from the standard library to parse the configuration
+file.  It means that if you need to disable a lot of messages, you can use
+tricks like: ::
+
+    # disable wildcard-import, method-hidden and too-many-lines because I do
+    # not want it
+    disable= wildcard-import,
+     method-hidden,
+     too-many-lines
+
+
+4.7 Why are there a bunch of messages disabled by default?
+----------------------------------------------------------
+
+pylint does have some messages disabled by default, either because
+they are prone to false positives or that they are opinionated enough
+for not being included as default messages.
+
+You can see the plugin you need to explicitly `load in the technical reference`_
+
+.. _`load in the technical reference`: http://pylint.pycqa.org/en/latest/technical_reference/extensions.html?highlight=load%20plugin
+
+4.8 I am using another popular linter alongside pylint. Which messages should I disable to avoid duplicates?
+------------------------------------------------------------------------------------------------------------
+
+pycodestyle_: unneeded-not, line-too-long, unnecessary-semicolon, trailing-whitespace, missing-final-newline, bad-indentation, multiple-statements, bare-except
+
+pyflakes_: undefined-variable, unused-import, unused-variable
+
+mccabe_: too-many-branches
+
+pydocstyle_: missing-module-docstring, missing-class-docstring, missing-function-docstring
+
+pep8-naming_: invalid-name, bad-classmethod-argument, bad-mcs-classmethod-argument, no-self-argument
+
+isort_: wrong-import-order
+
+flake8-import-order_: wrong-import-order
+
+.. _`pycodestyle`: https://github.com/PyCQA/pycodestyle
+.. _`pyflakes`: https://github.com/PyCQA/pyflakes
+.. _`mccabe`: https://github.com/PyCQA/mccabe
+.. _`pydocstyle`: https://github.com/PyCQA/pydocstyle
+.. _`pep8-naming`: https://github.com/PyCQA/pep8-naming
+.. _`isort`: https://github.com/pycqa/isort
+.. _`flake8-import-order`: https://github.com/PyCQA/flake8-import-order
+
+
+5. Classes and Inheritance
+==========================
+
+
+5.1 When is Pylint considering a class as an abstract class?
+-------------------------------------------------------------
+
+A class is considered as an abstract class if at least one of its
+methods is doing nothing but raising NotImplementedError.
+
+5.2 How do I avoid "access to undefined member" messages in my mixin classes?
+-------------------------------------------------------------------------------
+
+To do so you have to set the ignore-mixin-members option to
+"yes" (this is the default value) and to name your mixin class with
+a name which ends with "mixin" (whatever case).
+
+
+6. Troubleshooting
+==================
+
+6.1 Pylint gave my code a negative rating out of ten. That can't be right!
+--------------------------------------------------------------------------
+
+Even though the final rating Pylint renders is nominally out of ten, there's no
+lower bound on it. By default, the formula to calculate score is ::
+
+    10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+However, this option can be changed in the Pylint rc file. If having negative
+values really bugs you, you can set the formula to be the maximum of 0 and the
+above expression.
+
+
+6.2 I think I found a bug in Pylint. What should I do?
+-------------------------------------------------------
+
+Read :ref:`Bug reports, feedback`
+
+6.3 I have a question about Pylint that isn't answered here.
+------------------------------------------------------------
+
+Read :ref:`Mailing lists`
diff --git a/doc/how_tos/custom_checkers.rst b/doc/how_tos/custom_checkers.rst
new file mode 100644
index 000000000..c5deddd94
--- /dev/null
+++ b/doc/how_tos/custom_checkers.rst
@@ -0,0 +1,299 @@
+.. _write_a_checker:
+
+How to Write a Checker
+======================
+You can find some simple examples in the distribution
+(`custom.py <https://github.com/PyCQA/pylint/blob/main/examples/custom.py>`_
+,
+`custom_raw.py <https://github.com/PyCQA/pylint/blob/main/examples/custom_raw.py>`_
+and
+`deprecation_checker.py <https://github.com/PyCQA/pylint/blob/main/examples/deprecation_checker.py>`_).
+
+.. TODO Create custom_token.py
+
+There are three kinds of checkers:
+
+* Raw checkers, which analyse each module as a raw file stream.
+* Token checkers, which analyse a file using the list of tokens that
+  represent the source code in the file.
+* AST checkers, which work on an AST representation of the module.
+
+The AST representation is provided by the :mod:`astroid` library.
+:mod:`astroid` adds additional information and methods
+over :mod:`ast` in the standard library,
+to make tree navigation and code introspection easier.
+
+.. TODO Writing a Raw Checker
+
+.. TODO Writing a Token Checker
+
+Writing an AST Checker
+----------------------
+Let's implement a checker to make sure that all ``return`` nodes in a function
+return a unique constant.
+Firstly we will need to fill in some required boilerplate:
+
+.. code-block:: python
+
+  import astroid
+  from astroid import nodes
+
+  from pylint.checkers import BaseChecker
+  from pylint.interfaces import IAstroidChecker
+  from pylint.lint import PyLinter
+
+  class UniqueReturnChecker(BaseChecker):
+      __implements__ = IAstroidChecker
+
+      name = 'unique-returns'
+      priority = -1
+      msgs = {
+          'W0001': (
+              'Returns a non-unique constant.',
+              'non-unique-returns',
+              'All constants returned in a function should be unique.'
+          ),
+      }
+      options = (
+          (
+              'ignore-ints',
+              {
+                  'default': False, 'type': 'yn', 'metavar' : '<y_or_n>',
+                  'help': 'Allow returning non-unique integers',
+              }
+          ),
+      )
+
+
+So far we have defined the following required components of our checker:
+
+* A name. The name is used to generate a special configuration
+   section for the checker, when options have been provided.
+
+* A priority. This must be to be lower than 0. The checkers are ordered by
+   the priority when run, from the most negative to the most positive.
+
+* A message dictionary. Each checker is being used for finding problems
+   in your code, the problems being displayed to the user through **messages**.
+   The message dictionary should specify what messages the checker is
+   going to emit. It has the following format::
+
+       msgs = {
+           'message-id': (
+               'displayed-message', 'message-symbol', 'message-help'
+           )
+       }
+
+   * The ``message-id`` should be a 4-digit number,
+     prefixed with a **message category**.
+     There are multiple message categories,
+     these being ``C``, ``W``, ``E``, ``F``, ``R``,
+     standing for ``Convention``, ``Warning``, ``Error``, ``Fatal`` and ``Refactoring``.
+     The rest of the 5 digits should not conflict with existing checkers
+     and they should be consistent across the checker.
+     For instance,
+     the first two digits should not be different across the checker.
+
+   * The ``displayed-message`` is used for displaying the message to the user,
+     once it is emitted.
+
+   * The ``message-symbol`` is an alias of the message id
+     and it can be used wherever the message id can be used.
+
+   * The ``message-help`` is used when calling ``pylint --help-msg``.
+
+We have also defined an optional component of the checker.
+The options list defines any user configurable options.
+It has the following format::
+
+    options = (
+        'option-symbol': {'argparse-like-kwarg': 'value'},
+    )
+
+* The ``option-symbol`` is a unique name for the option.
+  This is used on the command line and in config files.
+  The hyphen is replaced by an underscore when used in the checker,
+  similarly to how you would use  :class:`argparse.Namespace`.
+
+Next we'll track when we enter and leave a function.
+
+.. code-block:: python
+
+  def __init__(self, linter: PyLinter =None) -> None:
+      super(UniqueReturnChecker, self).__init__(linter)
+      self._function_stack = []
+
+  def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+      self._function_stack.append([])
+
+  def leave_functiondef(self, node: nodes.FunctionDef) -> None:
+      self._function_stack.pop()
+
+In the constructor we initialise a stack to keep a list of return nodes
+for each function.
+An AST checker is a visitor, and should implement
+``visit_<lowered class name>`` or ``leave_<lowered class name>``
+methods for the nodes it's interested in.
+In this case we have implemented ``visit_functiondef`` and ``leave_functiondef``
+to add a new list of return nodes for this function,
+and to remove the list of return nodes when we leave the function.
+
+Finally we'll implement the check.
+We will define a ``visit_return`` function,
+which is called with a :class:`.astroid.nodes.Return` node.
+
+.. _astroid_extract_node:
+.. TODO We can shorten/remove this bit once astroid has API docs.
+
+We'll need to be able to figure out what attributes a
+:class:`.astroid.nodes.Return` node has available.
+We can use :func:`astroid.extract_node` for this::
+
+  >>> node = astroid.extract_node("return 5")
+  >>> node
+  <Return l.1 at 0x7efe62196390>
+  >>> help(node)
+  >>> node.value
+  <Const.int l.1 at 0x7efe62196ef0>
+
+We could also construct a more complete example::
+
+  >>> node_a, node_b = astroid.extract_node("""
+  ... def test():
+  ...     if True:
+  ...         return 5 #@
+  ...     return 5 #@
+  """)
+  >>> node_a.value
+  <Const.int l.4 at 0x7efe621a74e0>
+  >>> node_a.value.value
+  5
+  >>> node_a.value.value == node_b.value.value
+  True
+
+For :func:`astroid.extract_node`, you can use ``#@`` at the end of a line to choose which statements will be extracted into nodes.
+
+For more information on :func:`astroid.extract_node`,
+see the `astroid documentation <https://astroid.readthedocs.io/en/latest/>`_.
+
+Now we know how to use the astroid node, we can implement our check.
+
+.. code-block:: python
+
+  def visit_return(self, node: nodes.Return) -> None:
+      if not isinstance(node.value, nodes.Const):
+          return
+
+      for other_return in self._function_stack[-1]:
+         if (node.value.value == other_return.value.value and
+             not (self.config.ignore_ints and node.value.pytype() == int)):
+             self.add_message(
+                 'non-unique-returns', node=node,
+             )
+
+      self._function_stack[-1].append(node)
+
+Once we have established that the source code has failed our check,
+we use :func:`~.BaseChecker.add_message` to emit our failure message.
+
+Finally, we need to register the checker with pylint.
+Add the ``register`` function to the top level of the file.
+
+.. code-block:: python
+
+  def register(linter):
+      linter.register_checker(UniqueReturnChecker(linter))
+
+We are now ready to debug and test our checker!
+
+Debugging a Checker
+-------------------
+It is very simple to get to a point where we can use :mod:`pdb`.
+We'll need a small test case.
+Put the following into a Python file:
+
+.. code-block:: python
+
+  def test():
+      if True:
+          return 5
+      return 5
+
+  def test2():
+      if True:
+          return 1
+      return 5
+
+After inserting pdb into our checker and installing it,
+we can run pylint with only our checker::
+
+  $ pylint --load-plugins=my_plugin --disable=all --enable=non-unique-returns test.py
+  (Pdb)
+
+Now we can debug our checker!
+
+.. Note::
+
+    ``my_plugin`` refers to a module called ``my_plugin.py``.
+    This module can be made available to pylint by putting this
+    module's parent directory in your ``PYTHONPATH``
+    environment variable or by adding the ``my_plugin.py``
+    file to the ``pylint/checkers`` directory if running from source.
+
+Testing a Checker
+-----------------
+Pylint is very well suited to test driven development.
+You can implement the template of the checker,
+produce all of your test cases and check that they fail,
+implement the checker,
+then check that all of your test cases work.
+
+Pylint provides a :class:`pylint.testutils.CheckerTestCase`
+to make test cases very simple.
+We can use the example code that we used for debugging as our test cases.
+
+.. code-block:: python
+
+  import my_plugin
+  import pylint.testutils
+
+  class TestUniqueReturnChecker(pylint.testutils.CheckerTestCase):
+      CHECKER_CLASS = my_plugin.UniqueReturnChecker
+
+      def test_finds_non_unique_ints(self):
+          func_node, return_node_a, return_node_b = astroid.extract_node("""
+          def test(): #@
+              if True:
+                  return 5 #@
+              return 5 #@
+          """)
+
+          self.checker.visit_functiondef(func_node)
+          self.checker.visit_return(return_node_a)
+          with self.assertAddsMessages(
+              pylint.testutils.Message(
+                  msg_id='non-unique-returns',
+                  node=return_node_b,
+              ),
+          ):
+              self.checker.visit_return(return_node_b)
+
+      def test_ignores_unique_ints(self):
+          func_node, return_node_a, return_node_b = astroid.extract_node("""
+          def test(): #@
+              if True:
+                  return 1 #@
+              return 5 #@
+          """)
+
+          with self.assertNoMessages():
+              self.checker.visit_functiondef(func_node)
+              self.checker.visit_return(return_node_a)
+              self.checker.visit_return(return_node_b)
+
+
+Once again we are using :func:`astroid.extract_node` to
+construct our test cases.
+:class:`pylint.testutils.CheckerTestCase` has created the linter and checker for us,
+we simply simulate a traversal of the AST tree
+using the nodes that we are interested in.
diff --git a/doc/how_tos/index.rst b/doc/how_tos/index.rst
new file mode 100644
index 000000000..7ec3a2f36
--- /dev/null
+++ b/doc/how_tos/index.rst
@@ -0,0 +1,10 @@
+How To Guides
+=============
+
+.. toctree::
+   :maxdepth: 2
+   :titlesonly:
+
+   custom_checkers
+   plugins
+   transform_plugins
diff --git a/doc/how_tos/plugins.rst b/doc/how_tos/plugins.rst
new file mode 100644
index 000000000..a68bd22f8
--- /dev/null
+++ b/doc/how_tos/plugins.rst
@@ -0,0 +1,65 @@
+.. -*- coding: utf-8 -*-
+
+How To Write a Pylint Plugin
+============================
+
+Pylint provides support for writing two types of extensions.
+First, there is the concept of **checkers**,
+which can be used for finding problems in your code.
+Secondly, there is also the concept of **transform plugin**,
+which represents a way through which the inference and
+the capabilities of Pylint can be enhanced
+and tailored to a particular module, library of framework.
+
+In general, a plugin is a module which should have a function ``register``,
+which takes an instance of ``pylint.lint.PyLinter`` as input.
+
+A plugin can optionally define a function, ``load_configuration``,
+which takes an instance of ``pylint.lint.PyLinter`` as input. This
+function is called after Pylint loads configuration from configuration
+file and command line interface. This function should load additional
+plugin specific configuration to Pylint.
+
+So a basic hello-world plugin can be implemented as:
+
+.. sourcecode:: python
+
+  # Inside hello_plugin.py
+  def register(linter):
+    print('Hello world')
+
+
+We can run this plugin by placing this module in the PYTHONPATH and invoking
+**pylint** as:
+
+.. sourcecode:: bash
+
+  $ pylint -E --load-plugins hello_plugin foo.py
+  Hello world
+
+We can extend hello-world plugin to ignore some specific names using
+``load_configuration`` function:
+
+.. sourcecode:: python
+
+  # Inside hello_plugin.py
+  def register(linter):
+    print('Hello world')
+
+  def load_configuration(linter):
+
+    name_checker = get_checker(linter, NameChecker)
+    # We consider as good names of variables Hello and World
+    name_checker.config.good_names += ('Hello', 'World')
+
+    # We ignore bin directory
+    linter.config.black_list += ('bin',)
+
+Depending if we need a **transform plugin** or a **checker**, this might not
+be enough. For the former, this is enough to declare the module as a plugin,
+but in the case of the latter, we need to register our checker with the linter
+object, by calling the following inside the ``register`` function::
+
+    linter.register_checker(OurChecker(linter))
+
+For more information on writing a checker see :ref:`write_a_checker`.
diff --git a/doc/how_tos/transform_plugins.rst b/doc/how_tos/transform_plugins.rst
new file mode 100644
index 000000000..30e057820
--- /dev/null
+++ b/doc/how_tos/transform_plugins.rst
@@ -0,0 +1,108 @@
+
+Transform plugins
+^^^^^^^^^^^^^^^^^
+
+Why write a plugin?
+-------------------
+
+Pylint is a static analysis tool and Python is a dynamically typed language.
+So there will be cases where Pylint cannot analyze files properly (this problem
+can happen in statically typed languages also if reflection or dynamic
+evaluation is used).
+
+The plugins are a way to tell Pylint how to handle such cases,
+since only the user would know what needs to be done. They are usually operating
+on the AST level, by modifying or changing it in a way which can ease its
+understanding by Pylint.
+
+Example
+-------
+
+Let us run Pylint on a module from the Python source: `warnings.py`_ and see what happens:
+
+.. sourcecode:: shell
+
+  amitdev$ pylint -E Lib/warnings.py
+  E:297,36: Instance of 'WarningMessage' has no 'message' member (no-member)
+  E:298,36: Instance of 'WarningMessage' has no 'filename' member (no-member)
+  E:298,51: Instance of 'WarningMessage' has no 'lineno' member (no-member)
+  E:298,64: Instance of 'WarningMessage' has no 'line' member (no-member)
+
+
+Did we catch a genuine error? Let's open the code and look at ``WarningMessage`` class:
+
+.. sourcecode:: python
+
+  class WarningMessage(object):
+
+    """Holds the result of a single showwarning() call."""
+
+    _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file",
+                        "line")
+
+    def __init__(self, message, category, filename, lineno, file=None,
+                    line=None):
+      local_values = locals()
+      for attr in self._WARNING_DETAILS:
+        setattr(self, attr, local_values[attr])
+      self._category_name = category.__name__ if category else None
+
+    def __str__(self):
+      ...
+
+Ah, the fields (``message``, ``category`` etc) are not defined statically on the class.
+Instead they are added using ``setattr``. Pylint would have a tough time figuring
+this out.
+
+Enter Plugin
+------------
+
+We can write a transform plugin to tell Pylint how to analyze this properly.
+
+One way to fix our example with a plugin would be to transform the ``WarningMessage`` class,
+by setting the attributes so that Pylint can see them. This can be done by
+registering a transform function. We can transform any node in the parsed AST like
+Module, Class, Function etc. In our case we need to transform a class. It can be done so:
+
+.. sourcecode:: python
+
+  import astroid
+
+  def register(linter):
+    # Needed for registering the plugin.
+    pass
+
+  def transform(cls):
+    if cls.name == 'WarningMessage':
+      import warnings
+      for f in warnings.WarningMessage._WARNING_DETAILS:
+        cls.locals[f] = [astroid.ClassDef(f, None)]
+
+  astroid.MANAGER.register_transform(astroid.ClassDef, transform)
+
+Let's go through the plugin. First, we need to register a class transform, which
+is done via the ``register_transform`` function in ``MANAGER``. It takes the node
+type and function as parameters. We need to change a class, so we use ``astroid.ClassDef``.
+We also pass a ``transform`` function which does the actual transformation.
+
+``transform`` function is simple as well. If the class is ``WarningMessage`` then we
+add the attributes to its locals (we are not bothered about type of attributes, so setting
+them as class will do. But we could set them to any type we want). That's it.
+
+Note: We don't need to do anything in the ``register`` function of the plugin since we
+are not modifying anything in the linter itself.
+
+Lets run Pylint with this plugin and see:
+
+.. sourcecode:: bash
+
+  amitdev$ pylint -E --load-plugins warning_plugin Lib/warnings.py
+  amitdev$
+
+All the false positives associated with ``WarningMessage`` are now gone. This is just
+an example, any code transformation can be done by plugins.
+
+See `astroid/brain`_ for real life examples of transform plugins.
+
+.. _`warnings.py`: https://hg.python.org/cpython/file/2.7/Lib/warnings.py
+.. _`astroid/brain`: https://github.com/PyCQA/astroid/tree/main/astroid/brain
diff --git a/doc/index.rst b/doc/index.rst
new file mode 100644
index 000000000..1508ff679
--- /dev/null
+++ b/doc/index.rst
@@ -0,0 +1,27 @@
+
+Pylint User Manual
+==================
+
+Pylint is a tool that checks for errors in Python code, tries to enforce a
+coding standard and looks for code smells. It can also look for certain type
+errors, it can recommend suggestions about how particular blocks can be
+refactored and can offer you details about the code's complexity.
+
+
+.. toctree::
+   :maxdepth: 2
+   :titlesonly:
+
+   intro
+   tutorial
+
+   user_guide/index.rst
+   how_tos/index.rst
+   technical_reference/index.rst
+   development_guide/index.rst
+   additional_commands/index.rst
+
+   faq
+   backlinks
+   support
+   whatsnew/index.rst
diff --git a/doc/intro.rst b/doc/intro.rst
new file mode 100644
index 000000000..8fcaf5d12
--- /dev/null
+++ b/doc/intro.rst
@@ -0,0 +1,57 @@
+.. -*- coding: utf-8 -*-
+
+==============
+ Introduction
+==============
+
+What is Pylint?
+---------------
+
+Pylint is a tool that checks for errors in Python code, tries to enforce a
+coding standard and looks for `code smells`_. It can also look for certain type
+errors, it can recommend suggestions about how particular blocks
+can be refactored and can offer you details about the code's complexity.
+
+Other similar projects would include pychecker_ (now defunct), pyflakes_,
+flake8_, and mypy_. The default coding style used by Pylint is close to `PEP 8`_.
+
+Pylint will display a number of messages as it analyzes the code and it can
+also be used for displaying some statistics about the number of warnings and
+errors found in different files. The messages are classified under various
+categories such as errors and warnings.
+
+Last but not least, the code is given an overall mark, based on the number and
+severity of the warnings and errors.
+
+.. _pychecker: http://pychecker.sf.net
+.. _pyflakes: https://github.com/pyflakes/pyflakes
+.. _flake8: https://gitlab.com/pycqa/flake8/
+.. _mypy: https://github.com/python/mypy
+.. _`PEP 8`: https://www.python.org/dev/peps/pep-0008/
+.. _`Guido's style guide`: https://www.python.org/doc/essays/styleguide/
+.. _`refactoring book`: https://www.refactoring.com/
+.. _`code smells`: https://martinfowler.com/bliki/CodeSmell.html
+
+What Pylint is not?
+-------------------
+
+What Pylint says is not to be taken as gospel and Pylint isn't smarter than you
+are: it may warn you about things that you have conscientiously done.
+
+Pylint tries hard to report as few false positives as possible for errors, but
+it may be too verbose with warnings. That's for example because it tries to
+detect things that may be dangerous in a context, but are not in others, or
+because it checks for some things that you don't care about. Generally, you
+shouldn't expect Pylint to be totally quiet about your code, so don't
+necessarily be alarmed if it gives you a hell lot of messages for your project!
+
+The best way to tackle pylint's verboseness is to:
+
+* enable or disable the messages or message categories that you want to be
+  activated or not for when pylint is analyzing your code.
+  This can be done easily through a command line flag. For instance, disabling
+  all convention messages is simple as a ``--disable=C`` option added to pylint
+  command.
+
+* create a custom configuration file, tailored to your needs. You can generate
+  one using pylint's command ``--generate-rcfile``.
diff --git a/doc/logo.png b/doc/logo.png
new file mode 100644
index 000000000..15c1c6c68
--- /dev/null
+++ b/doc/logo.png
diff --git a/doc/logo.svg b/doc/logo.svg
new file mode 100644
index 000000000..e96e44396
--- /dev/null
+++ b/doc/logo.svg
@@ -0,0 +1,267 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- This file was generated by dvisvgm 1.0.11 (x86_64-pc-linux-gnu) -->
+
+<!-- Mon Jun 17 16:01:58 2013 -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   height="172.28319"
+   version="1.1"
+   viewBox="56.6209 54.0603 104.60054 129.21239"
+   width="139.46739"
+   id="svg2"
+   inkscape:version="0.92.1 r15371"
+   sodipodi:docname="pylint.svg">
+  <metadata
+     id="metadata13">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs11">
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient2795"
+       id="radialGradient1480"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(2.382716e-8,-0.296405,1.43676,4.683673e-7,-128.544,150.5202)"
+       cx="61.518883"
+       cy="132.28575"
+       fx="61.518883"
+       fy="132.28575"
+       r="29.036913" />
+    <linearGradient
+       id="linearGradient2795">
+      <stop
+         style="stop-color:#b8b8b8;stop-opacity:0.49803922;"
+         offset="0"
+         id="stop2797" />
+      <stop
+         style="stop-color:#7f7f7f;stop-opacity:0;"
+         offset="1"
+         id="stop2799" />
+    </linearGradient>
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4671"
+       id="linearGradient1475"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.79323321,0,0,0.80089141,57.605396,58.202768)"
+       x1="150.96111"
+       y1="192.35176"
+       x2="112.03144"
+       y2="137.27299" />
+    <linearGradient
+       id="linearGradient4671">
+      <stop
+         style="stop-color:#ffd43b;stop-opacity:1;"
+         offset="0"
+         id="stop4673" />
+      <stop
+         style="stop-color:#ffe873;stop-opacity:1"
+         offset="1"
+         id="stop4675" />
+    </linearGradient>
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4689"
+       id="linearGradient1478"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,-9.399749,-5.305317)"
+       x1="26.648937"
+       y1="20.603781"
+       x2="135.66525"
+       y2="114.39767" />
+    <linearGradient
+       id="linearGradient4689">
+      <stop
+         style="stop-color:#5a9fd4;stop-opacity:1;"
+         offset="0"
+         id="stop4691" />
+      <stop
+         style="stop-color:#306998;stop-opacity:1;"
+         offset="1"
+         id="stop4693" />
+    </linearGradient>
+    <linearGradient
+       y2="114.39767"
+       x2="135.66525"
+       y1="20.603781"
+       x1="26.648937"
+       gradientTransform="matrix(0.79323321,0,0,0.80089141,57.605396,58.202768)"
+       gradientUnits="userSpaceOnUse"
+       id="linearGradient4040"
+       xlink:href="#linearGradient4689"
+       inkscape:collect="always" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4689"
+       id="linearGradient4227"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.79323321,0,0,0.80089141,57.605396,58.202768)"
+       x1="26.648937"
+       y1="20.603781"
+       x2="135.66525"
+       y2="114.39767" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4671"
+       id="linearGradient4229"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.79323321,0,0,0.80089141,57.605396,58.202768)"
+       x1="150.96111"
+       y1="192.35176"
+       x2="112.03144"
+       y2="137.27299" />
+  </defs>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1286"
+     inkscape:window-height="1161"
+     id="namedview9"
+     showgrid="false"
+     inkscape:zoom="1.4142136"
+     inkscape:cx="346.34884"
+     inkscape:cy="68.737588"
+     inkscape:window-x="630"
+     inkscape:window-y="18"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg2"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     showguides="true"
+     inkscape:guide-bbox="true">
+    <sodipodi:guide
+       orientation="1,0"
+       position="364.70553,303.68897"
+       id="guide4239"
+       inkscape:locked="false" />
+  </sodipodi:namedview>
+  <g
+     id="g4209"
+     transform="matrix(1.0176699,0,0,1.0176699,-1.0084453,-0.95524014)">
+    <g
+       transform="matrix(0.65164348,0,0,0.65164348,5.8404193,5.3798232)"
+       id="g4079">
+      <path
+         inkscape:connector-curvature="0"
+         style="opacity:0.57347669;fill:url(#linearGradient4227);fill-opacity:1"
+         d="m 156.18462,74.705452 c -6.46336,0.02997 -12.63573,0.581274 -18.06677,1.542286 -15.99918,2.826542 -18.90402,8.742714 -18.90402,19.653124 v 14.409348 h 37.80803 v 4.80312 h -37.80803 -14.18902 c -10.988075,0 -20.60954,6.60447 -23.619006,19.16841 -3.471376,14.40121 -3.625358,23.38778 0,38.42495 2.687525,11.19308 9.105724,19.16839 20.093776,19.16841 h 12.99926 v -17.2736 c 0,-12.47917 10.79727,-23.4868 23.61901,-23.48682 h 37.76396 c 10.51214,0 18.90401,-8.65536 18.90401,-19.21247 V 95.900862 c 0,-10.246187 -8.64383,-17.943073 -18.90401,-19.653124 -6.49486,-1.081151 -13.23384,-1.572303 -19.69719,-1.542286 z m -20.4463,11.589192 c 3.90531,0 7.09451,3.241285 7.09451,7.226691 0,3.971289 -3.1892,7.182645 -7.09451,7.182645 -3.91931,0 -7.09451,-3.211356 -7.09451,-7.182645 0,-3.985406 3.1752,-7.226691 7.09451,-7.226691 z"
+         id="path1948" />
+      <path
+         inkscape:connector-curvature="0"
+         style="opacity:0.57347669;fill:url(#linearGradient4229);fill-opacity:1"
+         d="m 199.50081,115.11333 v 16.78888 c 0,13.0162 -11.03522,23.97152 -23.619,23.97154 h -37.76396 c -10.34418,0 -18.90402,8.85321 -18.90402,19.21247 v 36.00133 c 0,10.24621 8.90978,16.27289 18.90402,19.21249 11.9679,3.51902 23.44448,4.15501 37.76396,0 9.51831,-2.75588 18.90401,-8.30206 18.90401,-19.21249 v -14.40933 h -37.76396 v -4.80312 h 37.76396 18.90401 c 10.98807,0 15.08267,-7.66442 18.904,-19.16841 3.94732,-11.84318 3.77936,-23.23233 0,-38.42495 -2.71552,-10.93868 -7.90195,-19.16841 -18.904,-19.16841 z m -21.23948,91.17112 c 3.91931,0 7.09451,3.21136 7.09451,7.18263 0,3.98542 -3.1752,7.22672 -7.09451,7.22672 -3.90531,0 -7.09451,-3.2413 -7.09451,-7.22672 0,-3.97127 3.1892,-7.18263 7.09451,-7.18263 z"
+         id="path1950" />
+    </g>
+    <g
+       transform="matrix(0.66750079,0,0,0.66750079,2.8842973,20.787868)"
+       id="g4149">
+      <g
+         style="opacity:0.74193552;fill:none"
+         inkscape:tile-y0="198.86828"
+         inkscape:tile-x0="9.3899528"
+         transform="matrix(0.15261804,0,0,0.15261804,72.423903,200.62356)"
+         id="use3154"
+         inkscape:tile-cx="28.491054"
+         inkscape:tile-cy="217.96938"
+         inkscape:tile-w="38.202203"
+         inkscape:tile-h="38.202211">
+        <path
+           id="path3940"
+           style="fill:#d48c00;fill-opacity:1;stroke:#000000;stroke-width:0.77165896;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:10.03750038;stroke-dasharray:none"
+           d="m 57.4709,154.4603 1.75,0.175 2.875,0.45 3.925,0.9 4.85,1.4 5.65,2.05 6.3,2.725 6.8,3.475 7.1,4.2 7.25,4.925 7.225,5.6 7.025,6.2 6.65,6.65 6.2,7.025 5.6,7.225 4.925,7.25 4.2,7.1 3.475,6.8 2.725,6.3 2.05,5.65 1.4,4.85 0.9,3.925 0.45,2.875 0.175,1.75 0.025,0.59998 0.025,-0.60002 0.175,-1.75 0.45,-2.875 0.9,-3.925 1.4,-4.85 2.05,-5.65 2.725,-6.3 3.475,-6.8 4.2,-7.1 4.925,-7.25 5.6,-7.225 6.2,-7.025 6.65,-6.65 7.025,-6.2 7.225,-5.6 7.25,-4.925 7.1,-4.2 6.8,-3.475 6.3,-2.725 5.65,-2.05 4.85,-1.4 3.925,-0.9 2.875,-0.45 1.75,-0.175 0.59998,-0.025 -0.60002,-0.025 -1.75,-0.175 -2.875,-0.45 -3.925,-0.9 -4.85,-1.4 -5.65,-2.05 -6.3,-2.725 -6.8,-3.475 -7.1,-4.2 -7.25,-4.925 -7.225,-5.6 -7.025,-6.2 -6.64992,-6.65004 -6.2,-7.025 -5.6,-7.225 -4.925,-7.25 -4.2,-7.1 -3.475,-6.8 -2.725,-6.3 -2.05,-5.65 -1.4,-4.85 -0.9,-3.925 -0.45,-2.875 -0.175,-1.75 -0.025,-0.59998 -0.025,0.60002 -0.175,1.75 -0.45,2.875 -0.9,3.925 -1.4,4.85 -2.05,5.65 -2.725,6.3 -3.475,6.8 -4.2,7.1 -4.925,7.25 -5.6,7.225 -6.20008,7.025 -6.65,6.65 -7.025,6.2 -7.225,5.6 -7.25,4.925 -7.1,4.2 -6.8,3.475 -6.3,2.725 -5.65,2.05 -4.85,1.4 -3.925,0.9 -2.875,0.45 -1.75,0.175 -0.59998,0.025 z"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" />
+      </g>
+      <g
+         id="use4119"
+         transform="matrix(0.15261804,0,0,0.15261804,72.423903,200.62356)"
+         inkscape:tile-x0="9.3899528"
+         inkscape:tile-y0="198.86828"
+         style="opacity:0.74193552;fill:none;stroke-width:5.24184418;stroke-miterlimit:10.03750038;stroke-dasharray:none">
+        <path
+           sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+           inkscape:connector-curvature="0"
+           d="m 57.4709,154.4603 1.75,0.175 2.875,0.45 3.925,0.9 4.85,1.4 5.65,2.05 6.3,2.725 6.8,3.475 7.1,4.2 7.25,4.925 7.225,5.6 7.025,6.2 6.65,6.65 6.2,7.025 5.6,7.225 4.925,7.25 4.2,7.1 3.475,6.8 2.725,6.3 2.05,5.65 1.4,4.85 0.9,3.925 0.45,2.875 0.175,1.75 0.025,0.59998 0.025,-0.60002 0.175,-1.75 0.45,-2.875 0.9,-3.925 1.4,-4.85 2.05,-5.65 2.725,-6.3 3.475,-6.8 4.2,-7.1 4.925,-7.25 5.6,-7.225 6.2,-7.025 6.65,-6.65 7.025,-6.2 7.225,-5.6 7.25,-4.925 7.1,-4.2 6.8,-3.475 6.3,-2.725 5.65,-2.05 4.85,-1.4 3.925,-0.9 2.875,-0.45 1.75,-0.175 0.59998,-0.025 -0.60002,-0.025 -1.75,-0.175 -2.875,-0.45 -3.925,-0.9 -4.85,-1.4 -5.65,-2.05 -6.3,-2.725 -6.8,-3.475 -7.1,-4.2 -7.25,-4.925 -7.225,-5.6 -7.025,-6.2 -6.64992,-6.65004 -6.2,-7.025 -5.6,-7.225 -4.925,-7.25 -4.2,-7.1 -3.475,-6.8 -2.725,-6.3 -2.05,-5.65 -1.4,-4.85 -0.9,-3.925 -0.45,-2.875 -0.175,-1.75 -0.025,-0.59998 -0.025,0.60002 -0.175,1.75 -0.45,2.875 -0.9,3.925 -1.4,4.85 -2.05,5.65 -2.725,6.3 -3.475,6.8 -4.2,7.1 -4.925,7.25 -5.6,7.225 -6.20008,7.025 -6.65,6.65 -7.025,6.2 -7.225,5.6 -7.25,4.925 -7.1,4.2 -6.8,3.475 -6.3,2.725 -5.65,2.05 -4.85,1.4 -3.925,0.9 -2.875,0.45 -1.75,0.175 -0.59998,0.025 z"
+           style="fill:#d48c00;fill-opacity:1;stroke:#000000;stroke-width:7.71658897;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:10.03750038;stroke-dasharray:none"
+           id="path4147" />
+      </g>
+      <g
+         id="use4121"
+         transform="matrix(0.15261804,0,0,0.15261804,102.98566,200.62356)"
+         inkscape:tile-x0="9.3899528"
+         inkscape:tile-y0="198.86828"
+         style="opacity:0.74193552;fill:none;stroke-width:5.24184418;stroke-miterlimit:10.03750038;stroke-dasharray:none">
+        <path
+           sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+           inkscape:connector-curvature="0"
+           d="m 57.4709,154.4603 1.75,0.175 2.875,0.45 3.925,0.9 4.85,1.4 5.65,2.05 6.3,2.725 6.8,3.475 7.1,4.2 7.25,4.925 7.225,5.6 7.025,6.2 6.65,6.65 6.2,7.025 5.6,7.225 4.925,7.25 4.2,7.1 3.475,6.8 2.725,6.3 2.05,5.65 1.4,4.85 0.9,3.925 0.45,2.875 0.175,1.75 0.025,0.59998 0.025,-0.60002 0.175,-1.75 0.45,-2.875 0.9,-3.925 1.4,-4.85 2.05,-5.65 2.725,-6.3 3.475,-6.8 4.2,-7.1 4.925,-7.25 5.6,-7.225 6.2,-7.025 6.65,-6.65 7.025,-6.2 7.225,-5.6 7.25,-4.925 7.1,-4.2 6.8,-3.475 6.3,-2.725 5.65,-2.05 4.85,-1.4 3.925,-0.9 2.875,-0.45 1.75,-0.175 0.59998,-0.025 -0.60002,-0.025 -1.75,-0.175 -2.875,-0.45 -3.925,-0.9 -4.85,-1.4 -5.65,-2.05 -6.3,-2.725 -6.8,-3.475 -7.1,-4.2 -7.25,-4.925 -7.225,-5.6 -7.025,-6.2 -6.64992,-6.65004 -6.2,-7.025 -5.6,-7.225 -4.925,-7.25 -4.2,-7.1 -3.475,-6.8 -2.725,-6.3 -2.05,-5.65 -1.4,-4.85 -0.9,-3.925 -0.45,-2.875 -0.175,-1.75 -0.025,-0.59998 -0.025,0.60002 -0.175,1.75 -0.45,2.875 -0.9,3.925 -1.4,4.85 -2.05,5.65 -2.725,6.3 -3.475,6.8 -4.2,7.1 -4.925,7.25 -5.6,7.225 -6.20008,7.025 -6.65,6.65 -7.025,6.2 -7.225,5.6 -7.25,4.925 -7.1,4.2 -6.8,3.475 -6.3,2.725 -5.65,2.05 -4.85,1.4 -3.925,0.9 -2.875,0.45 -1.75,0.175 -0.59998,0.025 z"
+           style="fill:#d48c00;fill-opacity:1;stroke:#000000;stroke-width:7.71658897;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:10.03750038;stroke-dasharray:none"
+           id="path4143" />
+      </g>
+      <g
+         id="use4123"
+         transform="matrix(0.15261804,0,0,0.15261804,133.54743,200.62356)"
+         inkscape:tile-x0="9.3899528"
+         inkscape:tile-y0="198.86828"
+         style="opacity:0.74193552;fill:none;stroke-width:5.24184418;stroke-miterlimit:10.03750038;stroke-dasharray:none">
+        <path
+           sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+           inkscape:connector-curvature="0"
+           d="m 57.4709,154.4603 1.75,0.175 2.875,0.45 3.925,0.9 4.85,1.4 5.65,2.05 6.3,2.725 6.8,3.475 7.1,4.2 7.25,4.925 7.225,5.6 7.025,6.2 6.65,6.65 6.2,7.025 5.6,7.225 4.925,7.25 4.2,7.1 3.475,6.8 2.725,6.3 2.05,5.65 1.4,4.85 0.9,3.925 0.45,2.875 0.175,1.75 0.025,0.59998 0.025,-0.60002 0.175,-1.75 0.45,-2.875 0.9,-3.925 1.4,-4.85 2.05,-5.65 2.725,-6.3 3.475,-6.8 4.2,-7.1 4.925,-7.25 5.6,-7.225 6.2,-7.025 6.65,-6.65 7.025,-6.2 7.225,-5.6 7.25,-4.925 7.1,-4.2 6.8,-3.475 6.3,-2.725 5.65,-2.05 4.85,-1.4 3.925,-0.9 2.875,-0.45 1.75,-0.175 0.59998,-0.025 -0.60002,-0.025 -1.75,-0.175 -2.875,-0.45 -3.925,-0.9 -4.85,-1.4 -5.65,-2.05 -6.3,-2.725 -6.8,-3.475 -7.1,-4.2 -7.25,-4.925 -7.225,-5.6 -7.025,-6.2 -6.64992,-6.65004 -6.2,-7.025 -5.6,-7.225 -4.925,-7.25 -4.2,-7.1 -3.475,-6.8 -2.725,-6.3 -2.05,-5.65 -1.4,-4.85 -0.9,-3.925 -0.45,-2.875 -0.175,-1.75 -0.025,-0.59998 -0.025,0.60002 -0.175,1.75 -0.45,2.875 -0.9,3.925 -1.4,4.85 -2.05,5.65 -2.725,6.3 -3.475,6.8 -4.2,7.1 -4.925,7.25 -5.6,7.225 -6.20008,7.025 -6.65,6.65 -7.025,6.2 -7.225,5.6 -7.25,4.925 -7.1,4.2 -6.8,3.475 -6.3,2.725 -5.65,2.05 -4.85,1.4 -3.925,0.9 -2.875,0.45 -1.75,0.175 -0.59998,0.025 z"
+           style="fill:#d48c00;fill-opacity:1;stroke:#000000;stroke-width:7.71658897;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:10.03750038;stroke-dasharray:none"
+           id="path4139" />
+      </g>
+      <g
+         id="use4125"
+         transform="matrix(0.15261804,0,0,0.15261804,164.10919,200.62356)"
+         inkscape:tile-x0="9.3899528"
+         inkscape:tile-y0="198.86828"
+         style="opacity:0.74193552;fill:none;stroke-width:5.24184418;stroke-miterlimit:10.03750038;stroke-dasharray:none">
+        <path
+           sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+           inkscape:connector-curvature="0"
+           d="m 57.4709,154.4603 1.75,0.175 2.875,0.45 3.925,0.9 4.85,1.4 5.65,2.05 6.3,2.725 6.8,3.475 7.1,4.2 7.25,4.925 7.225,5.6 7.025,6.2 6.65,6.65 6.2,7.025 5.6,7.225 4.925,7.25 4.2,7.1 3.475,6.8 2.725,6.3 2.05,5.65 1.4,4.85 0.9,3.925 0.45,2.875 0.175,1.75 0.025,0.59998 0.025,-0.60002 0.175,-1.75 0.45,-2.875 0.9,-3.925 1.4,-4.85 2.05,-5.65 2.725,-6.3 3.475,-6.8 4.2,-7.1 4.925,-7.25 5.6,-7.225 6.2,-7.025 6.65,-6.65 7.025,-6.2 7.225,-5.6 7.25,-4.925 7.1,-4.2 6.8,-3.475 6.3,-2.725 5.65,-2.05 4.85,-1.4 3.925,-0.9 2.875,-0.45 1.75,-0.175 0.59998,-0.025 -0.60002,-0.025 -1.75,-0.175 -2.875,-0.45 -3.925,-0.9 -4.85,-1.4 -5.65,-2.05 -6.3,-2.725 -6.8,-3.475 -7.1,-4.2 -7.25,-4.925 -7.225,-5.6 -7.025,-6.2 -6.64992,-6.65004 -6.2,-7.025 -5.6,-7.225 -4.925,-7.25 -4.2,-7.1 -3.475,-6.8 -2.725,-6.3 -2.05,-5.65 -1.4,-4.85 -0.9,-3.925 -0.45,-2.875 -0.175,-1.75 -0.025,-0.59998 -0.025,0.60002 -0.175,1.75 -0.45,2.875 -0.9,3.925 -1.4,4.85 -2.05,5.65 -2.725,6.3 -3.475,6.8 -4.2,7.1 -4.925,7.25 -5.6,7.225 -6.20008,7.025 -6.65,6.65 -7.025,6.2 -7.225,5.6 -7.25,4.925 -7.1,4.2 -6.8,3.475 -6.3,2.725 -5.65,2.05 -4.85,1.4 -3.925,0.9 -2.875,0.45 -1.75,0.175 -0.59998,0.025 z"
+           style="fill:#d48c00;fill-opacity:1;stroke:#000000;stroke-width:7.71658897;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:10.03750038;stroke-dasharray:none"
+           id="path4135" />
+      </g>
+      <g
+         id="use4127"
+         transform="matrix(0.15261804,0,0,0.15261804,194.67095,200.62356)"
+         inkscape:tile-x0="9.3899528"
+         inkscape:tile-y0="198.86828"
+         style="opacity:0.74193552;fill:none;stroke-width:5.24184418;stroke-miterlimit:10.03750038;stroke-dasharray:none">
+        <path
+           sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+           inkscape:connector-curvature="0"
+           d="m 57.4709,154.4603 1.75,0.175 2.875,0.45 3.925,0.9 4.85,1.4 5.65,2.05 6.3,2.725 6.8,3.475 7.1,4.2 7.25,4.925 7.225,5.6 7.025,6.2 6.65,6.65 6.2,7.025 5.6,7.225 4.925,7.25 4.2,7.1 3.475,6.8 2.725,6.3 2.05,5.65 1.4,4.85 0.9,3.925 0.45,2.875 0.175,1.75 0.025,0.59998 0.025,-0.60002 0.175,-1.75 0.45,-2.875 0.9,-3.925 1.4,-4.85 2.05,-5.65 2.725,-6.3 3.475,-6.8 4.2,-7.1 4.925,-7.25 5.6,-7.225 6.2,-7.025 6.65,-6.65 7.025,-6.2 7.225,-5.6 7.25,-4.925 7.1,-4.2 6.8,-3.475 6.3,-2.725 5.65,-2.05 4.85,-1.4 3.925,-0.9 2.875,-0.45 1.75,-0.175 0.59998,-0.025 -0.60002,-0.025 -1.75,-0.175 -2.875,-0.45 -3.925,-0.9 -4.85,-1.4 -5.65,-2.05 -6.3,-2.725 -6.8,-3.475 -7.1,-4.2 -7.25,-4.925 -7.225,-5.6 -7.025,-6.2 -6.64992,-6.65004 -6.2,-7.025 -5.6,-7.225 -4.925,-7.25 -4.2,-7.1 -3.475,-6.8 -2.725,-6.3 -2.05,-5.65 -1.4,-4.85 -0.9,-3.925 -0.45,-2.875 -0.175,-1.75 -0.025,-0.59998 -0.025,0.60002 -0.175,1.75 -0.45,2.875 -0.9,3.925 -1.4,4.85 -2.05,5.65 -2.725,6.3 -3.475,6.8 -4.2,7.1 -4.925,7.25 -5.6,7.225 -6.20008,7.025 -6.65,6.65 -7.025,6.2 -7.225,5.6 -7.25,4.925 -7.1,4.2 -6.8,3.475 -6.3,2.725 -5.65,2.05 -4.85,1.4 -3.925,0.9 -2.875,0.45 -1.75,0.175 -0.59998,0.025 z"
+           style="fill:none;stroke:#000000;stroke-width:7.71658897;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:10.03750038;stroke-dasharray:none"
+           id="path4131" />
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/doc/make.bat b/doc/make.bat
new file mode 100644
index 000000000..7c754602b
--- /dev/null
+++ b/doc/make.bat
@@ -0,0 +1,198 @@
+@ECHO OFF
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set BUILDDIR=_build
+set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
+set I18NSPHINXOPTS=%SPHINXOPTS% .
+if NOT "%PAPER%" == "" (
+	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
+	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
+)
+
+if "%1" == "" goto help
+
+if "%1" == "help" (
+	:help
+	echo.Please use `make ^<target^>` where ^<target^> is one of
+	echo.  html       to make standalone HTML files
+	echo.  dirhtml    to make HTML files named index.html in directories
+	echo.  singlehtml to make a single large HTML file
+	echo.  pickle     to make pickle files
+	echo.  json       to make JSON files
+	echo.  htmlhelp   to make HTML files and a HTML help project
+	echo.  qthelp     to make HTML files and a qthelp project
+	echo.  devhelp    to make HTML files and a Devhelp project
+	echo.  epub       to make an epub
+	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+	echo.  text       to make text files
+	echo.  man        to make manual pages
+	echo.  texinfo    to make Texinfo files
+	echo.  gettext    to make PO message catalogs
+	echo.  changes    to make an overview over all changed/added/deprecated items
+	echo.  linkcheck  to check all external links for integrity
+	echo.  doctest    to run all doctests embedded in the documentation if enabled
+	goto end
+)
+
+if "%1" == "clean" (
+	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
+	del /q /s %BUILDDIR%\*
+	goto end
+)
+
+
+if "%1" == "html" (
+	rm -f features.rst
+	echo Pylint features > reference_guide/features.rst
+	echo =============== >> reference_guide/features.rst
+	echo  >> reference_guide/features.rst
+	echo .. generated by pylint --full-documentation >> reference_guide/features.rst
+	echo  >> reference_guide/features.rst
+	python -m pylint --full-documentation >> reference_guide/features.rst
+	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
+	goto end
+)
+
+if "%1" == "dirhtml" (
+	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
+	goto end
+)
+
+if "%1" == "singlehtml" (
+	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
+	goto end
+)
+
+if "%1" == "pickle" (
+	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the pickle files.
+	goto end
+)
+
+if "%1" == "json" (
+	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the JSON files.
+	goto end
+)
+
+if "%1" == "htmlhelp" (
+	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run HTML Help Workshop with the ^
+.hhp project file in %BUILDDIR%/htmlhelp.
+	goto end
+)
+
+if "%1" == "qthelp" (
+	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run "qcollectiongenerator" with the ^
+.qhcp project file in %BUILDDIR%/qthelp, like this:
+	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\a.qhcp
+	echo.To view the help file:
+	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\a.ghc
+	goto end
+)
+
+if "%1" == "devhelp" (
+	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished.
+	goto end
+)
+
+if "%1" == "epub" (
+	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The epub file is in %BUILDDIR%/epub.
+	goto end
+)
+
+if "%1" == "latex" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "text" (
+	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The text files are in %BUILDDIR%/text.
+	goto end
+)
+
+if "%1" == "man" (
+	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The manual pages are in %BUILDDIR%/man.
+	goto end
+)
+
+if "%1" == "texinfo" (
+	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
+	goto end
+)
+
+if "%1" == "gettext" (
+	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
+	goto end
+)
+
+if "%1" == "changes" (
+	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.The overview file is in %BUILDDIR%/changes.
+	goto end
+)
+
+if "%1" == "linkcheck" (
+	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Link check complete; look for any errors in the above output ^
+or in %BUILDDIR%/linkcheck/output.txt.
+	goto end
+)
+
+if "%1" == "doctest" (
+	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Testing of doctests in the sources finished, look at the ^
+results in %BUILDDIR%/doctest/output.txt.
+	goto end
+)
+
+:end
diff --git a/doc/media/ClassChecker_diagram.png b/doc/media/ClassChecker_diagram.png
new file mode 100644
index 000000000..a6a685ce2
--- /dev/null
+++ b/doc/media/ClassChecker_diagram.png
diff --git a/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png b/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png
new file mode 100644
index 000000000..317dc4d98
--- /dev/null
+++ b/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png
diff --git a/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White_small.png b/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White_small.png
new file mode 100644
index 000000000..53b9c0fc3
--- /dev/null
+++ b/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White_small.png
diff --git a/doc/media/pyreverse_example_classes.png b/doc/media/pyreverse_example_classes.png
new file mode 100644
index 000000000..1903aef52
--- /dev/null
+++ b/doc/media/pyreverse_example_classes.png
diff --git a/doc/media/pyreverse_example_packages.png b/doc/media/pyreverse_example_packages.png
new file mode 100644
index 000000000..200b307be
--- /dev/null
+++ b/doc/media/pyreverse_example_packages.png
diff --git a/doc/release.md b/doc/release.md
new file mode 100644
index 000000000..0854464af
--- /dev/null
+++ b/doc/release.md
@@ -0,0 +1,52 @@
+# Releasing a pylint version
+
+So, you want to release the `X.Y.Z` version of pylint ?
+
+## Process
+
+1. Check if the dependencies of the package are correct, make sure that astroid is
+   pinned to the latest version.
+2. Install the release dependencies `pip3 install pre-commit tbump`
+3. Bump the version by using `tbump X.Y.Z --no-tag --no-push`
+4. Check the result (Do `git diff vX.Y.Z-1 ChangeLog doc/whatsnew/` in particular).
+5. Move back to a dev version for pylint with `tbump`:
+
+```bash
+tbump X.Y.Z+1-dev0 --no-tag --no-push # You can interrupt during copyrite
+git commit -am "Move back to a dev version following X.Y.Z release"
+```
+
+4. Check the result
+5. Open a merge request with the two commits (no one can push directly on `main`)
+6. After the merge recover the merged commits and tag the first one (the version should
+   be `X.Y.Z`) as `vX.Y.Z`
+7. Push the tag
+8. Go to GitHub, click on "Releases" then on the `vX.Y.Z` tag, choose edit tag, and copy
+   past the changelog in the description. This will trigger the release to pypi.
+
+## Post release
+
+### Merge tags in main for pre-commit
+
+If the tag you just made is not part of the main branch, merge the tag `vX.Y.Z` in the
+main branch by doing a history only merge. It's done in order to signal that this is an
+official release tag, and for `pre-commit autoupdate` to works.
+
+```bash
+git checkout main
+git merge --no-edit --strategy=ours vX.Y.Z
+git push
+```
+
+### Milestone handling
+
+We move issue that were not done in the next milestone and block release only if it's an
+issue labelled as blocker.
+
+- Close milestone `X.Y.Z`
+- Create the milestones for `X.Y.Z+1`, (or `X.Y+1.0`, and `X+1.0.0` if applicable)
+
+#### What's new
+
+If it's a minor release, create a new `What's new in Pylint X.Y+1` document. Add it to
+`doc/index.rst`. Take a look at the examples from `doc/whatsnew`.
diff --git a/doc/requirements.txt b/doc/requirements.txt
new file mode 100644
index 000000000..0c356b873
--- /dev/null
+++ b/doc/requirements.txt
@@ -0,0 +1,3 @@
+Sphinx==4.2.0
+python-docs-theme==2021.8
+-e .
diff --git a/doc/support.rst b/doc/support.rst
new file mode 100644
index 000000000..33f740379
--- /dev/null
+++ b/doc/support.rst
@@ -0,0 +1,17 @@
+Support
+-------
+
+.. image:: media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png
+   :width: 100
+   :height: 150
+   :alt: Tidelift
+   :align: left
+   :class: 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
diff --git a/doc/technical_reference/c_extensions.rst b/doc/technical_reference/c_extensions.rst
new file mode 100644
index 000000000..1bc7475c2
--- /dev/null
+++ b/doc/technical_reference/c_extensions.rst
@@ -0,0 +1,29 @@
+Pylint and C extensions
+=======================
+
+If you are getting the dreaded **no-member** error, there is a possibility that
+either **pylint** found a bug in your code or that it actually tries to lint
+a C extension module.
+
+Linting C extension modules is not supported out of the box, especially since
+pylint has no way to get an AST object out of the extension module.
+
+But **pylint** actually has a mechanism which you might use in case you
+want to analyze C extensions. **pylint** has a flag, called **extension-pkg-allow-list**
+(formerly **extension-pkg-whitelist**), through which you can tell it to
+import that module and to build an AST from that imported module::
+
+   $ pylint --extension-pkg-allow-list=your_c_extension
+
+Be aware though that using this flag means that extensions are loaded into the
+active Python interpreter and may run arbitrary code, which you may not want. This
+is the reason why we disable by default loading C extensions. In case you do not want
+the hassle of passing C extensions module with this flag all the time, you
+can enable **unsafe-load-any-extension** in your configuration file, which will
+build AST objects from all the C extensions that **pylint** encounters::
+
+   $ pylint --unsafe-load-any-extension=y
+
+Alternatively, since **pylint** emits a separate error for attributes that cannot be
+found in C extensions, **c-extension-no-member**, you can disable this error for
+your project.
diff --git a/doc/technical_reference/checkers.rst b/doc/technical_reference/checkers.rst
new file mode 100644
index 000000000..d59e316c6
--- /dev/null
+++ b/doc/technical_reference/checkers.rst
@@ -0,0 +1,7 @@
+Checkers
+--------
+All of the default pylint checkers exist in ``pylint.checkers``.
+This is where most of pylint's brains exist.
+Most checkers are AST based and so use :mod:`astroid`.
+``pylint.checkers.utils`` provides a large number of utility methods for
+dealing with :mod:`astroid`.
diff --git a/doc/technical_reference/index.rst b/doc/technical_reference/index.rst
new file mode 100644
index 000000000..cf3a3a65f
--- /dev/null
+++ b/doc/technical_reference/index.rst
@@ -0,0 +1,20 @@
+.. _technical-reference:
+
+Technical Reference
+===================
+
+.. TODO Configuration
+
+.. TODO Messages
+
+.. TODO Reports
+
+.. toctree::
+  :maxdepth: 2
+  :titlesonly:
+
+  startup
+  checkers
+  extensions
+  features
+  c_extensions
diff --git a/doc/technical_reference/startup.rst b/doc/technical_reference/startup.rst
new file mode 100644
index 000000000..5a2063d4a
--- /dev/null
+++ b/doc/technical_reference/startup.rst
@@ -0,0 +1,22 @@
+Startup and the Linter Class
+----------------------------
+The two main classes in :mod:`pylint.lint` are
+:class:`.pylint.lint.Run` and :class:`.pylint.lint.PyLinter`.
+
+The :class:`.pylint.lint.Run` object is responsible for starting up pylint.
+It does some basic checking of the given command line options to
+find the initial hook to run,
+find the config file to use,
+and find which plugins have been specified.
+It can then create the master :class:`.pylint.lint.PyLinter` instance
+and initialise it with the config file and plugins that were discovered
+when preprocessing the command line options.
+Finally the :class:`.pylint.lint.Run` object launches any child linters
+for parallel jobs, and starts the linting process.
+
+The :class:`.pylint.lint.PyLinter` is responsible for coordinating the
+linting process.
+It parses the configuration and provides it for the checkers and other plugins,
+it handles the messages emitted by the checkers,
+it handles the output reporting,
+and it launches the checkers.
diff --git a/doc/tutorial.rst b/doc/tutorial.rst
new file mode 100644
index 000000000..6eb46bfc9
--- /dev/null
+++ b/doc/tutorial.rst
@@ -0,0 +1,279 @@
+
+========
+Tutorial
+========
+
+:Author: Robert Kirkpatrick
+
+
+Intro
+-----
+
+Beginner to coding standards?  Pylint can be your guide to reveal what's really
+going on behind the scenes and help you to become a more aware programmer.
+
+Sharing code is a rewarding endeavor.  Putting your code ``out there`` can be
+either an act of philanthropy, ``coming of age``, or a basic extension of belief
+in open source.  Whatever the motivation, your good intentions may not have the
+desired outcome if people find your code hard to use or understand.  The Python
+community has formalized some recommended programming styles to help everyone
+write code in a common, agreed-upon style that makes the most sense for shared
+code.  This style is captured in `PEP 8`_, the "Style Guide for Python Code".
+Pylint can be a quick and easy way of
+seeing if your code has captured the essence of `PEP 8`_ and is therefore
+``friendly`` to other potential users.
+
+Perhaps you're not ready to share your code but you'd like to learn a bit more
+about writing better code and don't know where to start.  Pylint can tell you
+where you may have run astray and point you in the direction to figure out what
+you have done and how to do better.
+
+This tutorial is all about approaching coding standards with little or no
+knowledge of in-depth programming or the code standards themselves.  It's the
+equivalent of skipping the manual and jumping right in.
+
+My command line prompt for these examples is:
+
+.. sourcecode:: console
+
+  robertk01 Desktop$
+
+.. _PEP 8: https://www.python.org/dev/peps/pep-0008/
+
+Getting Started
+---------------
+
+Running Pylint with no arguments will invoke the help dialogue and give you an
+idea of the arguments available to you.  Do that now, i.e.:
+
+.. sourcecode:: console
+
+  robertk01 Desktop$ pylint
+  ...
+  a bunch of stuff
+  ...
+
+
+A couple of the options that we'll focus on here are: ::
+
+  Commands:
+    --help-msg=<msg-id>
+    --generate-rcfile
+  Messages control:
+    --disable=<msg-ids>
+  Reports:
+    --reports=<y_or_n>
+    --output-format=<format>
+
+If you need more detail, you can also ask for an even longer help message,
+like so: ::
+
+  robertk01 Desktop$ pylint --long-help
+  ...
+  Even more stuff
+  ...
+
+Pay attention to the last bit of this longer help output.  This gives you a
+hint of what
+Pylint is going to ``pick on``: ::
+
+  Output:
+     Using the default text output, the message format is :
+    MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE
+    There are 5 kind of message types :
+    * (C) convention, for programming standard violation
+    * (R) refactor, for bad code smell
+    * (W) warning, for python specific problems
+    * (E) error, for probable bugs in the code
+    * (F) fatal, if an error occurred which prevented pylint from doing
+    further processing.
+
+When Pylint is first run on a fresh piece of code, a common complaint is that it
+is too ``noisy``.  The current default configuration is set to enforce all possible
+warnings.  We'll use some of the options I noted above to make it suit your
+preferences a bit better (and thus make it emit messages only when needed).
+
+
+Your First Pylint'ing
+---------------------
+
+We'll use a basic Python script as fodder for our tutorial.
+The starting code we will use is called simplecaesar.py and is here in its
+entirety:
+
+.. sourcecode:: python
+
+   #!/usr/bin/env python3
+
+   import string;
+
+   shift = 3
+   choice = input("would you like to encode or decode?")
+   word = input("Please enter text")
+   letters = string.ascii_letters + string.punctuation + string.digits
+   encoded = ''
+   if choice == "encode":
+       for letter in word:
+           if letter == ' ':
+               encoded = encoded + ' '
+           else:
+               x = letters.index(letter) + shift
+               encoded = encoded + letters[x]
+   if choice == "decode":
+       for letter in word:
+           if letter == ' ':
+               encoded = encoded + ' '
+           else:
+               x = letters.index(letter) - shift
+               encoded = encoded + letters[x]
+
+   print(encoded)
+
+
+Let's get started.
+
+If we run this:
+
+.. sourcecode:: console
+
+  robertk01 Desktop$ pylint simplecaesar.py
+  ************* Module simplecaesar
+  simplecaesar.py:3:0: W0301: Unnecessary semicolon (unnecessary-semicolon)
+  simplecaesar.py:1:0: C0114: Missing module docstring (missing-module-docstring)
+  simplecaesar.py:5:0: C0103: Constant name "shift" doesn't conform to UPPER_CASE naming style (invalid-name)
+  simplecaesar.py:9:0: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
+  simplecaesar.py:13:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
+
+  -----------------------------------
+  Your code has been rated at 7.37/10
+
+
+Previous experience taught me that the default output for the messages
+needed a bit more info.  We can see the second line is: ::
+
+  "simplecaesar.py:1:0: C0114: Missing module docstring (missing-module-docstring)"
+
+This basically means that line 1 violates a convention ``C0114``.  It's telling me I really should have a docstring.
+I agree, but what if I didn't fully understand what rule I violated.  Knowing only that I violated a convention
+isn't much help if I'm a newbie. Another piece of information there is the
+message symbol between parens, ``missing-module-docstring`` here.
+
+If I want to read up a bit more about that, I can go back to the
+command line and try this:
+
+.. sourcecode:: console
+
+  robertk01 Desktop$ pylint --help-msg=missing-module-docstring
+  :missing-module-docstring (C0114): *Missing module docstring*
+    Used when a module has no docstring.Empty modules do not require a docstring.
+    This message belongs to the basic checker.
+
+
+Yeah, ok. That one was a bit of a no-brainer, but I have run into error messages
+that left me with no clue about what went wrong, simply because I was unfamiliar
+with the underlying mechanism of code theory.  One error that puzzled my newbie
+mind was: ::
+
+  :too-many-instance-attributes (R0902): *Too many instance attributes (%s/%s)*
+
+I get it now thanks to Pylint pointing it out to me.  If you don't get that one,
+pour a fresh cup of coffee and look into it - let your programmer mind grow!
+
+
+The Next Step
+-------------
+
+Now that we got some configuration stuff out of the way, let's see what we can
+do with the remaining warnings.
+
+If we add a docstring to describe what the code is meant to do that will help.
+There are 5 ``invalid-name`` messages that we will get to later.  Lastly, I
+put an unnecessary semicolon at the end of the import line so I'll
+fix that too. To sum up, I'll add a docstring to line 2, and remove the ``;``
+from line 3.
+
+Here is the updated code:
+
+.. sourcecode:: python
+
+   #!/usr/bin/env python3
+   """This script prompts a user to enter a message to encode or decode
+   using a classic Caesar shift substitution (3 letter shift)"""
+
+   import string
+
+   shift = 3
+   choice = input("would you like to encode or decode?")
+   word = input("Please enter text")
+   letters = string.ascii_letters + string.punctuation + string.digits
+   encoded = ''
+   if choice == "encode":
+       for letter in word:
+           if letter == ' ':
+               encoded = encoded + ' '
+           else:
+               x = letters.index(letter) + shift
+               encoded = encoded + letters[x]
+   if choice == "decode":
+       for letter in word:
+           if letter == ' ':
+               encoded = encoded + ' '
+           else:
+               x = letters.index(letter) - shift
+               encoded = encoded + letters[x]
+
+   print(encoded)
+
+Here is what happens when we run it:
+
+.. sourcecode:: console
+
+  robertk01 Desktop$ pylint simplecaesar.py
+  ************* Module simplecaesar
+  simplecaesar.py:7:0: C0103: Constant name "shift" doesn't conform to UPPER_CASE naming style (invalid-name)
+  simplecaesar.py:11:0: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
+  simplecaesar.py:15:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
+
+  ------------------------------------------------------------------
+  Your code has been rated at 8.42/10 (previous run: 7.37/10, +1.05)
+
+Nice! Pylint told us how much our code rating has improved since our last run, and we're down to just the ``invalid-name`` messages.
+
+There are fairly well defined conventions around naming things like instance
+variables, functions, classes, etc.  The conventions focus on the use of
+UPPERCASE and lowercase as well as the characters that separate multiple words
+in the name.  This lends itself well to checking via a regular expression, thus
+the **should match (([A-Z\_][A-Z1-9\_]*)|(__.*__))$**.
+
+In this case Pylint is telling me that those variables appear to be constants
+and should be all UPPERCASE. This is an in-house convention that has lived with Pylint
+since its inception. You too can create your own in-house naming
+conventions but for the purpose of this tutorial, we want to stick to the `PEP 8`_
+standard. In this case, the variables I declared should follow the convention
+of all lowercase.  The appropriate rule would be something like:
+"should match [a-z\_][a-z0-9\_]{2,30}$".  Notice the lowercase letters in the
+regular expression (a-z versus A-Z).
+
+If we run that rule using a ``--const-rgx='[a-z\_][a-z0-9\_]{2,30}$'`` option, it
+will now be quite quiet:
+
+.. sourcecode:: console
+
+  robertk01 Desktop$ pylint --const-rgx='[a-z_][a-z0-9_]{2,30}$' simplecaesar.py
+
+  -------------------------------------------------------------------
+  Your code has been rated at 10.00/10 (previous run: 8.42/10, +1.58)
+
+
+Regular expressions can be quite a beast so take my word on this particular
+example but go ahead and `read up`_ on them if you want.
+
+.. tip::
+ It would really be a pain to specify that regex on the command line all the time, particularly if we're using many other options.
+ That's what a configuration file is for. We can configure our Pylint to
+ store our options for us so we don't have to declare them on the command line.  Using a configuration file is a nice way of formalizing your rules and
+ quickly sharing them with others. Invoking ``pylint --generate-rcfile`` will create a sample rcfile with all the options set and explained in comments.
+
+That's it for the basic intro. More tutorials will follow.
+
+.. _`read up`: https://docs.python.org/library/re.html
diff --git a/doc/user_guide/ide-integration.rst b/doc/user_guide/ide-integration.rst
new file mode 100644
index 000000000..a4af1e0c1
--- /dev/null
+++ b/doc/user_guide/ide-integration.rst
@@ -0,0 +1,277 @@
+.. _ide-integration:
+
+###########################
+ Editor and IDE integration
+###########################
+
+To use Pylint with:
+
+ - Emacs_, see https://www.emacswiki.org/emacs/PythonProgrammingInEmacs#toc8,
+ - Vim_, see https://www.vim.org/scripts/script.php?script_id=891,
+ - `Visual Studio`_, see https://docs.microsoft.com/visualstudio/python/code-pylint,
+ - Eclipse_ and PyDev_, see https://pydev.org/manual_adv_pylint.html,
+ - Komodo_, see http://mateusz.loskot.net/posts/2006/01/15/running-pylint-from-komodo/,
+ - gedit_, see https://launchpad.net/gedit-pylint-2 or https://wiki.gnome.org/Apps/Gedit/PylintPlugin,
+ - WingIDE_, see https://www.wingware.com/doc/edit/pylint,
+ - PyCharm_, see :ref:`the section below <pylint_in_pycharm>`,
+ - TextMate_, see :ref:`the section below <pylint_in_textmate>`
+ - `Visual Studio Code`_, see https://code.visualstudio.com/docs/python/linting#_pylint,
+ - `Jupyter Notebook`_, see https://github.com/nbQA-dev/nbQA,
+
+Pylint is integrated in:
+
+ - `Visual Studio`_, see the `Python > Run PyLint` command on a project's context menu.
+ - Eric_ IDE, see the `Project > Check` menu,
+ - Spyder_, see the `View -> Panes -> Static code analysis` pane and
+   its `corresponding documentation <https://docs.spyder-ide.org/pylint.html>`_.
+ - pyscripter_, see the `Tool -> Tools` menu.
+ - `Visual Studio Code`_, see the `Preferences -> Settings` menu.
+
+.. _Emacs: https://www.gnu.org/software/emacs/
+.. _Vim: https://www.vim.org/
+.. _Visual Studio: https://www.visualstudio.com/
+.. _Eclipse: https://www.eclipse.org/
+.. _Eric: https://eric-ide.python-projects.org/
+.. _pyscripter: https://github.com/pyscripter/pyscripter
+.. _pydev: https://pydev.org
+.. _Komodo: http://www.activestate.com/Products/Komodo/
+.. _gedit: https://wiki.gnome.org/Apps/Gedit
+.. _WingIDE: https://www.wingware.com/
+.. _spyder: https://www.spyder-ide.org/
+.. _PyCharm: https://www.jetbrains.com/pycharm/
+.. _TextMate: https://macromates.com
+.. _Visual Studio Code: https://code.visualstudio.com/
+.. _Jupyter Notebook: https://jupyter.org/
+
+Using Pylint thru flymake in Emacs
+==================================
+
+To enable flymake for Python, insert the following into your .emacs:
+
+.. sourcecode:: common-lisp
+
+    ;; Configure flymake for Python
+    (when (load "flymake" t)
+      (defun flymake-pylint-init ()
+        (let* ((temp-file (flymake-init-create-temp-buffer-copy
+                           'flymake-create-temp-inplace))
+               (local-file (file-relative-name
+                            temp-file
+                            (file-name-directory buffer-file-name))))
+          (list "epylint" (list local-file))))
+      (add-to-list 'flymake-allowed-file-name-masks
+                   '("\\.py\\'" flymake-pylint-init)))
+
+    ;; Set as a minor mode for Python
+    (add-hook 'python-mode-hook '(lambda () (flymake-mode)))
+
+Above stuff is in ``pylint/elisp/pylint-flymake.el``, which should be automatically
+installed on Debian systems, in which cases you don't have to put it in your ``.emacs`` file.
+
+Other things you may find useful to set:
+
+.. sourcecode:: common-lisp
+
+    ;; Configure to wait a bit longer after edits before starting
+    (setq-default flymake-no-changes-timeout '3)
+
+    ;; Keymaps to navigate to the errors
+    (add-hook 'python-mode-hook '(lambda () (define-key python-mode-map "\C-cn" 'flymake-goto-next-error)))
+    (add-hook 'python-mode-hook '(lambda () (define-key python-mode-map "\C-cp" 'flymake-goto-prev-error)))
+
+
+Finally, by default flymake only displays the extra information about the error when you
+hover the mouse over the highlighted line. The following will use the minibuffer to display
+messages when you the cursor is on the line.
+
+.. sourcecode:: common-lisp
+
+    ;; To avoid having to mouse hover for the error message, these functions make flymake error messages
+    ;; appear in the minibuffer
+    (defun show-fly-err-at-point ()
+      "If the cursor is sitting on a flymake error, display the message in the minibuffer"
+      (require 'cl)
+      (interactive)
+      (let ((line-no (line-number-at-pos)))
+        (dolist (elem flymake-err-info)
+          (if (eq (car elem) line-no)
+    	  (let ((err (car (second elem))))
+    	    (message "%s" (flymake-ler-text err)))))))
+
+    (add-hook 'post-command-hook 'show-fly-err-at-point)
+
+
+Alternative, if you only wish to pollute the minibuffer after an explicit flymake-goto-* then use
+the following instead of a post-command-hook
+
+.. sourcecode:: common-lisp
+
+    (defadvice flymake-goto-next-error (after display-message activate compile)
+      "Display the error in the mini-buffer rather than having to mouse over it"
+      (show-fly-err-at-point))
+
+    (defadvice flymake-goto-prev-error (after display-message activate compile)
+      "Display the error in the mini-buffer rather than having to mouse over it"
+      (show-fly-err-at-point))
+
+.. _pylint_in_pycharm:
+
+Integrate Pylint with PyCharm
+=============================
+
+Install Pylint the usual way::
+
+    pip install pylint
+
+Remember the path at which it's installed::
+
+    which pylint
+
+Using pylint-pycharm plugin
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#.  In PyCharm go to *Preferences* > *Plugins* > *Browse repositories...*
+#.  Right-click on the plugin named **Pylint**, select **Download and Install** and restart PyCharm when prompted
+
+If the plugin is not finding the Pylint executable (e.g. is not inside the PATH environmental variable), you can
+specify it manually using the plugin settings:
+
+#.  *Preferences* > *Other Settings* > *Pylint* or simply click the gear icon from the side bar of the Pylint tool window
+#.  Type the path directly or use the Browse button to open a file selection dialog
+#.  Press the Test button to check if the plugin is able to run the executable
+
+For more info on how to use the plugin please check the `official plugin documentation <https://github.com/leinardi/pylint-pycharm/blob/master/README.md>`_.
+
+Using External Tools
+~~~~~~~~~~~~~~~~~~~~
+
+Within PyCharm:
+
+#.  Navigate to the preferences window
+#.  Select "External Tools"
+#.  Click the plus sign at the bottom of the dialog to add a new external task
+#.  In the dialog, populate the following fields:
+
+    :Name:                              Pylint
+    :Description:                       A Python source code analyzer which looks for programming errors, helps enforcing a coding standard and sniffs for some code smells.
+    :Synchronize files after execution: unchecked
+    :Program:                           ``/path/to/pylint``
+    :Parameters:                        ``$FilePath$``
+
+#.  Click OK
+
+The option to check the current file with Pylint should now be available in *Tools* > *External Tools* > *Pylint*.
+
+
+.. _pylint_in_textmate:
+
+Integrate Pylint with TextMate
+==============================
+
+Install Pylint in the usual way::
+
+    pip install pylint
+
+Install the `Python bundle for TextMate <https://github.com/textmate/python.tmbundle>`_:
+
+#.  select *TextMate* > *Preferences*
+#.  select the *Bundles* tab
+#.  find and tick the *Python* bundle in the list
+
+You should now see it in *Bundles* > *Python*.
+
+In *Preferences*, select the *Variables* tab. If a ``TM_PYCHECKER`` variable is not already listed, add
+it, with the value ``pylint``.
+
+The default keyboard shortcut to run the syntax checker is *Control-Shift-V* - open a ``.py`` file
+in Textmate, and try it.
+
+You should see the output in a new window:
+
+    PyCheckMate 1.2 – Pylint 1.4.4
+
+    No config file found, using default configuration
+
+Then all is well, and most likely Pylint will have expressed some opinions about your Python code
+(or will exit with ``0`` if your code already conforms to its expectations).
+
+If you receive a message:
+
+    Please install PyChecker, PyFlakes, Pylint, PEP 8 or flake8 for more extensive code checking.
+
+That means that Pylint wasn't found, which is likely an issue with command paths - TextMate needs
+be looking for Pylint on the right paths.
+
+Check where Pylint has been installed, using ``which``::
+
+    $ which pylint
+    /usr/local/bin/pylint
+
+The output will tell you where Pylint can be found; in this case, in ``/usr/local/bin``.
+
+#. select *TextMate* > *Preferences*
+#. select the *Variables* tab
+#. find and check that a ``PATH`` variable exists, and that it contains the appropriate path (if
+   the path to Pylint were ``/usr/local/bin/pylint`` as above, then the variable would need to
+   contain ``/usr/local/bin``). An actual example in this case might be
+   ``$PATH:/opt/local/bin:/usr/local/bin:/usr/texbin``, which includes other paths.
+
+... and try running Pylint again.
+
+Integrate Pylint with Visual Studio Code
+========================================
+
+Command-line arguments and configuration files
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+See `Pylint command line arguments`_ for general switches. Command line
+arguments can be used to load Pylint plugins, such as that for Django:
+
+::
+
+    "python.linting.pylintArgs": ["--load-plugins", "pylint_django"]
+
+Options can also be specified in a ``pylintrc`` or ``.pylintrc`` file in
+the workspace folder, as described on `Pylint command line arguments`_.
+
+To control which Pylint messages are shown, add the following contents
+to an options file:
+
+.. code:: ini
+
+    [MESSAGES CONTROL]
+
+    # 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.
+    #enable=
+
+    # Disable 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).
+    #disable=
+
+Message category mapping
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+The Python extension maps Pylint message categories to VS Code
+categories through the following settings. If desired, change the
+setting to change the mapping.
+
++----------------------+-----------------------------------+------------------+
+| Pylint category      | Applicable setting                | VS Code category |
+|                      | (python.linting.)                 | mapping          |
++======================+===================================+==================+
+| convention           | pylintCategorySeverity.convention | Information      |
++----------------------+-----------------------------------+------------------+
+| refactor             | pylintCategorySeverity.refactor   | Hint             |
++----------------------+-----------------------------------+------------------+
+| warning              | pylintCategorySeverity.warning    | Warning          |
++----------------------+-----------------------------------+------------------+
+| error                | pylintCategorySeverity.error      | Error            |
++----------------------+-----------------------------------+------------------+
+| fatal                | pylintCategorySeverity.fatal      | Error            |
++----------------------+-----------------------------------+------------------+
+
+.. _Pylint command line arguments: https://pylint.readthedocs.io/en/latest/user_guide/run.html#command-line-options
diff --git a/doc/user_guide/index.rst b/doc/user_guide/index.rst
new file mode 100644
index 000000000..e25db0f99
--- /dev/null
+++ b/doc/user_guide/index.rst
@@ -0,0 +1,14 @@
+
+User Guide
+==========
+
+.. toctree::
+   :maxdepth: 2
+   :titlesonly:
+
+   installation
+   run
+   output
+   message-control
+   options
+   ide-integration
diff --git a/doc/user_guide/installation.rst b/doc/user_guide/installation.rst
new file mode 100644
index 000000000..0b72b3bf6
--- /dev/null
+++ b/doc/user_guide/installation.rst
@@ -0,0 +1,27 @@
+.. _installation:
+
+Installation
+------------
+
+
+Python packages
+'''''''''''''''
+
+Pylint should be easily installable using pip.
+
+.. code-block:: sh
+
+   pip install pylint
+
+
+Source distribution installation
+''''''''''''''''''''''''''''''''
+
+From the source distribution, extract the tarball, go to the extracted
+directory and simply run ::
+
+    python setup.py install
+
+Or you can install it in editable mode, using ::
+
+    python setup.py develop
diff --git a/doc/user_guide/message-control.rst b/doc/user_guide/message-control.rst
new file mode 100644
index 000000000..0f735e533
--- /dev/null
+++ b/doc/user_guide/message-control.rst
@@ -0,0 +1,205 @@
+.. _message-control:
+
+Messages control
+================
+
+``pylint`` has an advanced message control for its checks, offering the ability
+to enable / disable a message either from the command line or from the configuration
+file, as well as from the code itself.
+
+For all of these controls, ``pylint`` accepts the following values:
+
+* a symbolic message: ``no-member``, ``undefined-variable`` etc.
+
+* a numerical ID: ``E1101``, ``E1102`` etc.
+
+* The name of the group of checks. You can grab those with ``pylint --list-groups``.
+  For example, you can disable / enable all the checks related to type checking, with
+  ``typecheck`` or all the checks related to variables with ``variables``
+
+* Corresponding category of the checks
+
+  * ``C`` convention related checks
+  * ``R`` refactoring related checks
+  * ``W`` various warnings
+  * ``E`` errors, for probable bugs in the code
+  * ``F`` fatal, if an error occurred which prevented ``pylint`` from doing further processing.
+
+* All the checks with ``all``
+
+
+Block disables
+--------------
+
+This describes how the pragma controls operate at a code level.
+
+The pragma controls can disable / enable:
+
+* All the violations on a single line
+
+    .. sourcecode:: python
+
+        a, b = ... # pylint: disable=unbalanced-tuple-unpacking
+
+* All the violations on the following line
+
+    .. sourcecode:: python
+
+        # pylint: disable-next=unbalanced-tuple-unpacking
+        a, b = ...
+
+* All the violations in a single scope
+
+    .. sourcecode:: python
+
+        def test():
+            # Disable all the no-member violations in this function
+            # pylint: disable=no-member
+            ...
+
+* All the violations in a `block`. For instance, each separate branch of an
+  ``if`` statement is considered a separate block, as in the following example:
+
+    .. sourcecode:: python
+
+        def meth5(self):
+            # pylint: disable=no-member
+            # no error
+            print(self.bla)
+            if self.blop:
+                # pylint: enable=no-member
+                # enable all no-members for this block
+                print(self.blip)
+            else:
+                # This is affected by the scope disable
+                print(self.blip)
+            # pylint: enable=no-member
+            print(self.blip)
+            if self.blop:
+                # pylint: disable=no-member
+                # disable all no-members for this block
+                print(self.blip)
+            else:
+                # This emits a violation
+                print(self.blip)
+
+
+* If the violation occurs on a block starting line, then it applies only to that line
+
+    .. sourcecode:: python
+
+        if self.blop: # pylint: disable=no-member; applies only to this line
+            # Here we get an error
+            print(self.blip)
+        else:
+            # error
+            print(self.blip)
+
+
+
+Here's an example with all these rules in a single place:
+
+.. sourcecode:: python
+
+    """pylint option block-disable"""
+
+    __revision__ = None
+
+    class Foo(object):
+        """block-disable test"""
+
+        def __init__(self):
+            pass
+
+        def meth1(self, arg):
+            """this issues a message"""
+            print(self)
+
+        def meth2(self, arg):
+            """and this one not"""
+            # pylint: disable=unused-argument
+            print(self\
+                  + "foo")
+
+        def meth3(self):
+            """test one line disabling"""
+            # no error
+            print(self.bla) # pylint: disable=no-member
+            # error
+            print(self.blop)
+
+        def meth4(self):
+            """test re-enabling"""
+            # pylint: disable=no-member
+            # no error
+            print(self.bla)
+            print(self.blop)
+            # pylint: enable=no-member
+            # error
+            print(self.blip)
+
+        def meth5(self):
+            """test IF sub-block re-enabling"""
+            # pylint: disable=no-member
+            # no error
+            print(self.bla)
+            if self.blop:
+                # pylint: enable=no-member
+                # 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=no-member
+            # no error
+            print(self.bla)
+            try:
+                # pylint: enable=no-member
+                # error
+                print(self.blip)
+            except UndefinedName: # pylint: disable=undefined-variable
+                # no error
+                print(self.blip)
+            # no error
+            print(self.blip)
+
+        def meth7(self):
+            """test one line block opening disabling"""
+            if self.blop: # pylint: disable=no-member
+                # 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=no-member
+            # no error
+            print(self.bla)
+            print(self.blop)
+
+        def meth9(self):
+            """test next line disabling"""
+            # no error
+            # pylint: disable-next=no-member
+            print(self.bla)
+            # error
+            print(self.blop)
+
+
+Detecting useless disables
+--------------------------
+
+As pylint gets better and false positives are removed,
+disables that became useless can accumulate and clutter the code.
+In order to clean them you can enable the ``useless-suppression`` warning.
diff --git a/doc/user_guide/options.rst b/doc/user_guide/options.rst
new file mode 100644
index 000000000..898c7a60a
--- /dev/null
+++ b/doc/user_guide/options.rst
@@ -0,0 +1,177 @@
+.. -*- coding: utf-8 -*-
+
+===============
+ Configuration
+===============
+
+Naming Styles
+-------------
+
+Introduction
+~~~~~~~~~~~~
+
+Pylint recognizes a number of different name types internally. With a few
+exceptions, the type of the name is governed by the location the assignment to a
+name is found in, and not the type of object assigned.
+
++--------------------+---------------------------------------------------------------------------------------------------+
+| Name Type          | Description                                                                                       |
++====================+===================================================================================================+
+| ``module``         | Module and package names, same as the file names.                                                 |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``const``          | Module-level constants, any variable defined at module level that is not bound to a class object. |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``class``          | Names in ``class`` statements, as well as names bound to class objects at module level.           |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``function``       | Functions, toplevel or nested in functions or methods.                                            |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``method``         | Methods, functions defined in class bodies. Includes static and class methods.                    |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``attr``           | Attributes created on class instances inside methods.                                             |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``argument``       | Arguments to any function type, including lambdas.                                                |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``variable``       | Local variables in function scopes.                                                               |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``class-attribute``| Attributes defined in class bodies.                                                               |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``class-const``    | Enum constants and class variables annotated with ``ClassVar``                                    |
++--------------------+---------------------------------------------------------------------------------------------------+
+| ``inlinevar``      | Loop variables in list comprehensions and generator expressions.                                  |
++--------------------+---------------------------------------------------------------------------------------------------+
+
+Default behavior
+~~~~~~~~~~~~~~~~
+By default, Pylint will enforce PEP8_-suggested names.
+
+Predefined Naming Styles
+~~~~~~~~~~~~~~~~~~~~~~~~
+Pylint provides set of predefined naming styles. Those predefined
+naming styles may be used to adjust Pylint configuration to coding
+style used in linted project.
+
+Following predefined naming styles are available:
+
+* ``snake_case``
+* ``camelCase``
+* ``PascalCase``
+* ``UPPER_CASE``
+* ``any`` - fake style which does not enforce any limitations
+
+Following options are exposed:
+
+.. option:: --module-naming-style=<style>
+
+.. option:: --const-naming-style=<style>
+
+.. option:: --class-naming-style=<style>
+
+.. option:: --function-naming-style=<style>
+
+.. option:: --method-naming-style=<style>
+
+.. option:: --attr-naming-style=<style>
+
+.. option:: --argument-naming-style=<style>
+
+.. option:: --variable-naming-style=<style>
+
+.. option:: --class-attribute-naming-style=<style>
+
+.. option:: --class-const-naming-style=<style>
+
+.. option:: --inlinevar-naming-style=<style>
+
+
+Custom regular expressions
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If predefined naming styles are too limited, checker behavior may be further
+customized. For each name type, a separate regular expression matching valid
+names of this type can be defined. If any of custom regular expressions are
+defined, it overrides ``*-naming-style`` option value.
+
+Regular expressions for the names are anchored at the beginning, any anchor for
+the end must be supplied explicitly. Any name not matching the regular
+expression will lead to an instance of ``invalid-name``.
+
+
+.. option:: --module-rgx=<regex>
+
+.. option:: --const-rgx=<regex>
+
+.. option:: --class-rgx=<regex>
+
+.. option:: --function-rgx=<regex>
+
+.. option:: --method-rgx=<regex>
+
+.. option:: --attr-rgx=<regex>
+
+.. option:: --argument-rgx=<regex>
+
+.. option:: --variable-rgx=<regex>
+
+.. option:: --class-attribute-rgx=<regex>
+
+.. option:: --class-const-rgx=<regex>
+
+.. option:: --inlinevar-rgx=<regex>
+
+Multiple naming styles for custom regular expressions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Large code bases that have been worked on for multiple years often exhibit an
+evolution in style as well. In some cases, modules can be in the same package,
+but still have different naming style based on the stratum they belong to.
+However, intra-module consistency should still be required, to make changes
+inside a single file easier. For this case, Pylint supports regular expression
+with several named capturing group.
+
+Rather than emitting name warnings immediately, Pylint will determine the
+prevalent naming style inside each module and enforce it on all names.
+
+Consider the following (simplified) example::
+
+   pylint --function-rgx='(?:(?P<snake>[a-z_]+)|(?P<camel>[a-z]+([A-Z][a-z]*)*))$' sample.py
+
+The regular expression defines two naming styles, ``snake`` for snake-case
+names, and ``camel`` for camel-case names.
+
+In ``sample.py``, the function name on line 1 and 7 will mark the module
+and enforce the match of named group ``snake`` for the remaining names in
+the module::
+
+   def valid_snake_case(arg):
+      ...
+
+   def InvalidCamelCase(arg):
+      ...
+
+   def more_valid_snake_case(arg):
+    ...
+
+Because of this, the name on line 4 will trigger an ``invalid-name`` warning,
+even though the name matches the given regex.
+
+Matches named ``exempt`` or ``ignore`` can be used for non-tainting names, to
+prevent built-in or interface-dictated names to trigger certain naming styles.
+
+.. option:: --name-group=<name1:name2:...,...>
+
+   Default value: empty
+
+   Format: comma-separated groups of colon-separated names.
+
+   This option can be used to combine name styles. For example, ``function:method`` enforces that functions and methods use the same style, and a style triggered by either name type carries over to the other. This requires that the regular expression for the combined name types use the same group names.
+
+Name Hints
+~~~~~~~~~~
+
+.. option:: --include-naming-hint=y|n
+
+   Default: off
+
+   Include a hint (regular expression used) for the correct name format with every ``invalid-name`` warning.
+
+.. _PEP8: https://www.python.org/dev/peps/pep-0008
diff --git a/doc/user_guide/output.rst b/doc/user_guide/output.rst
new file mode 100644
index 000000000..4d375fdc7
--- /dev/null
+++ b/doc/user_guide/output.rst
@@ -0,0 +1,140 @@
+
+Pylint output
+-------------
+
+The default format for the output is raw text. You can change this by passing
+pylint the ``--output-format=<value>`` option. Possible values are: json,
+parseable, colorized and msvs (visual studio).
+
+Multiple output formats can be used at the same time by passing
+``--output-format`` a comma-separated list of formats. To change the output file
+for an individual format, specify it after a semicolon. For example, you can
+save a json report to ``somefile`` and print a colorized report to stdout at the
+same time with :
+::
+
+  --output-format=json:somefile,colorized
+
+Moreover you can customize the exact way information are displayed using the
+`--msg-template=<format string>` option. The `format string` uses the
+`Python new format syntax`_ and the following fields are available :
+
+path
+    relative path to the file
+abspath
+    absolute path to the file
+line
+    line number
+column
+    column number
+module
+    module name
+obj
+    object within the module (if any)
+msg
+    text of the message
+msg_id
+    the message code (eg. I0011)
+symbol
+    symbolic name of the message (eg. locally-disabled)
+C
+    one letter indication of the message category
+category
+    fullname of the message category
+
+For example, the former (pre 1.0) default format can be obtained with::
+
+  pylint --msg-template='{msg_id}:{line:3d},{column}: {obj}: {msg}'
+
+A few other examples:
+
+* the default format::
+
+    {path}:{line}:{column}: {msg_id}: {msg} ({symbol})
+
+* Visual Studio compatible format (former 'msvs' output format)::
+
+    {path}({line}): [{msg_id}{obj}] {msg}
+
+* Parseable (Emacs and all, former 'parseable' output format) format::
+
+    {path}:{line}: [{msg_id}({symbol}), {obj}] {msg}
+
+The ``--msg-template`` option can only be combined with text-based reporters (``--output-format`` either unspecified or one of: parseable, colorized or msvs).
+If both ``--output-format`` and ``--msg-template`` are specified, the ``--msg-template`` option will take precedence over the default line format defined by the reporter class.
+
+.. _Python new format syntax: https://docs.python.org/2/library/string.html#formatstrings
+
+Source code analysis section
+''''''''''''''''''''''''''''
+
+For each python module, Pylint will first display a few '*' characters followed
+by the name of the module. Then, a number of messages with the following format:
+::
+
+  MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE
+
+You can get another output format, useful since it's recognized by
+most editors or other development tools using the ``--output-format=parseable``
+option.
+
+The message type can be:
+
+  * [I]nformational messages that Pylint emits (do not contribute to your analysis score)
+  * [R]efactor for a "good practice" metric violation
+  * [C]onvention for coding standard violation
+  * [W]arning for stylistic problems, or minor programming issues
+  * [E]rror for important programming issues (i.e. most probably bug)
+  * [F]atal for errors which prevented further processing
+
+Sometimes the line of code which caused the error is displayed with
+a caret pointing to the error. This may be generalized in future
+versions of Pylint.
+
+Example (extracted from a run of Pylint on itself...):
+
+::
+
+  ************* Module pylint.checkers.format
+  W: 50: Too long line (86/80)
+  W:108: Operator not followed by a space
+       print >>sys.stderr, 'Unable to match %r', line
+              ^
+  W:141: Too long line (81/80)
+  W: 74:searchall: Unreachable code
+  W:171:FormatChecker.process_tokens: Redefining built-in (type)
+  W:150:FormatChecker.process_tokens: Too many local variables (20/15)
+  W:150:FormatChecker.process_tokens: Too many branches (13/12)
+
+
+Reports section
+'''''''''''''''
+
+Following the analysis message, Pylint can display a set of reports,
+each one focusing on a particular aspect of the project, such as number
+of messages by categories, modules dependencies. These features can
+be enabled through the ``--reports=y`` option, or its shorthand
+version ``-rn``.
+
+For instance, the metrics report displays summaries gathered from the
+current run.
+
+  * the number of processed modules
+  * for each module, the percentage of errors and warnings
+  * the total number of errors and warnings
+  * percentage of classes, functions and modules with docstrings, and
+    a comparison from the previous run
+  * percentage of classes, functions and modules with correct name
+    (according to the coding standard), and a comparison from the
+    previous run
+  * a list of external dependencies found in the code, and where they appear
+
+Score section
+'''''''''''''
+
+Finally, Pylint displays a global evaluation score for the code, rated out of a
+maximum score of 10.0. This output can be suppressed through the ``--score=n``
+option, or its shorthand version ``-sn``.
+
+The evaluation formula can be overridden with the
+``--evaluation=<python_expression>`` option.
diff --git a/doc/user_guide/run.rst b/doc/user_guide/run.rst
new file mode 100644
index 000000000..0e5cce4be
--- /dev/null
+++ b/doc/user_guide/run.rst
@@ -0,0 +1,185 @@
+================
+ Running Pylint
+================
+
+Invoking Pylint
+---------------
+
+Pylint is meant to be called from the command line. The usage is ::
+
+   pylint [options] modules_or_packages
+
+You should give Pylint the name of a python package or module, or some number
+of packages or modules. Pylint
+``will not import`` this package or module, though uses Python internals
+to locate them and as such is subject to the same rules and configuration.
+You should pay attention to your ``PYTHONPATH``, since it is a common error
+to analyze an installed version of a module instead of the
+development version.
+
+It is also possible to analyze Python files, with a few
+restrictions. The thing to keep in mind is that Pylint will try to
+convert the file name to a module name, and only be able to process
+the file if it succeeds.  ::
+
+  pylint mymodule.py
+
+should always work since the current working
+directory is automatically added on top of the python path ::
+
+  pylint directory/mymodule.py
+
+will work if ``directory`` is a python package (i.e. has an __init__.py
+file or it is an implicit namespace package) or if "directory" is in the
+python path.
+
+For more details on this see the :ref:`faq`.
+
+It is also possible to call Pylint from another Python program,
+thanks to the ``Run()`` function in the ``pylint.lint`` module
+(assuming Pylint options are stored in a list of strings ``pylint_options``) as:
+
+.. sourcecode:: python
+
+  import pylint.lint
+  pylint_opts = ['--version']
+  pylint.lint.Run(pylint_opts)
+
+To silently run Pylint on a ``module_name.py`` module,
+and get its standard output and error:
+
+.. sourcecode:: python
+
+  from pylint import epylint as lint
+  (pylint_stdout, pylint_stderr) = lint.py_run('module_name.py', return_std=True)
+
+It is also possible to include additional Pylint options in the first argument to ``py_run``:
+
+.. sourcecode:: python
+
+  from pylint import epylint as lint
+  (pylint_stdout, pylint_stderr) = lint.py_run('module_name.py --disable C0114', return_std=True)
+
+The options ``--msg-template="{path}:{line}: {category} ({msg_id}, {symbol}, {obj}) {msg}"`` and
+``--reports=n`` are set implicitly inside the ``epylint`` module.
+
+Command line options
+--------------------
+
+First of all, we have two basic (but useful) options.
+
+--version             show program's version number and exit
+-h, --help            show help about the command line options
+
+Pylint is architected around several checkers. You can disable a specific
+checker or some of its messages or message categories by specifying
+``--disable=<symbol>``. If you want to enable only some checkers or some
+message symbols, first use ``--disable=all`` then
+``--enable=<symbol>`` with ``<symbol>`` being a comma-separated list of checker
+names and message symbols. See the list of available features for a
+description of provided checkers with their functionalities.
+The ``--disable`` and ``--enable`` options can be used with comma-separated lists
+mixing checkers, message ids and categories like ``-d C,W,no-error,design``
+
+It is possible to disable all messages with ``--disable=all``. This is
+useful to enable only a few checkers or a few messages by first
+disabling everything, and then re-enabling only what you need.
+
+Each checker has some specific options, which can take either a yes/no
+value, an integer, a python regular expression, or a comma-separated
+list of values (which are generally used to override a regular
+expression in special cases). For a full list of options, use ``--help``
+
+Specifying all the options suitable for your setup and coding
+standards can be tedious, so it is possible to use a configuration file to
+specify the default values.  You can specify a configuration file on the
+command line using the ``--rcfile`` option.  Otherwise, Pylint searches for a
+configuration file in the following order and uses the first one it finds:
+
+#. ``pylintrc`` in the current working directory
+#. ``.pylintrc`` in the current working directory
+#. ``pyproject.toml`` in the current working directory,
+   providing it has at least one ``tool.pylint.`` section.
+#. ``setup.cfg`` in the current working directory,
+   providing it has at least one ``pylint.`` section
+#. If the current working directory is in a Python package, Pylint searches \
+   up the hierarchy of Python packages until it finds a ``pylintrc`` file. \
+   This allows you to specify coding standards on a module-by-module \
+   basis.  Of course, a directory is judged to be a Python package if it \
+   contains an ``__init__.py`` file.
+#. The file named by environment variable ``PYLINTRC``
+#. if you have a home directory which isn't ``/root``:
+
+   #. ``.pylintrc`` in your home directory
+   #. ``.config/pylintrc`` in your home directory
+
+#. ``/etc/pylintrc``
+
+The ``--generate-rcfile`` option will generate a commented configuration file
+on standard output according to the current configuration and exit. This
+includes:
+
+* Any configuration file found as explained above
+* Options appearing before ``--generate-rcfile`` on the Pylint command line
+
+Of course you can also start with the default values and hand-tune the
+configuration.
+
+Other useful global options include:
+
+--ignore=<file[,file...]>  Files or directories to be skipped. They should be
+                           base names, not paths.
+--output-format=<format>   Select output format (text, json, custom).
+--msg-template=<template>  Modify text output message template.
+--list-msgs                Generate pylint's messages.
+--list-msgs-enabled        Display a list of what messages are enabled and
+                           disabled with the given configuration.
+--full-documentation       Generate pylint's full documentation, in reST
+                             format.
+
+Parallel execution
+------------------
+
+It is possible to speed up the execution of Pylint. If the running computer
+has more CPUs than one, then the work for checking all files could be spread across all
+cores via Pylints's sub-processes.
+This functionality is exposed via the ``-j`` command-line parameter.
+If the provided number is 0, then the total number of CPUs will be autodetected and used.
+
+Example::
+
+  pylint -j 4 mymodule1.py mymodule2.py mymodule3.py mymodule4.py
+
+This will spawn 4 parallel Pylint sub-process, where each provided module will
+be checked in parallel. Discovered problems by checkers are not displayed
+immediately. They are shown just after checking a module is complete.
+
+There are some limitations in running checks in parallel in the current
+implementation. It is not possible to use custom plugins
+(i.e. ``--load-plugins`` option), nor it is not possible to use
+initialization hooks (i.e. the ``--init-hook`` option).
+
+Exit codes
+----------
+
+Pylint returns bit-encoded exit codes. If applicable, the table below lists the related
+stderr stream message output.
+
+=========  =========================  ==========================================
+exit code  meaning                    stderr stream message
+=========  =========================  ==========================================
+0          no error
+1          fatal message issued
+2          error message issued
+4          warning message issued
+8          refactor message issued
+16         convention message issued
+32         usage error                - "internal error while receiving results\
+                                        from child linter" "Error occurred,
+                                        stopping the linter."
+                                      - "<return of linter.help()>"
+                                      - "Jobs number <#> should be greater \
+                                        than 0"
+                                      - "<IOError message when trying to open \
+                                        output file>"
+=========  =========================  ==========================================
diff --git a/doc/whatsnew/1.6.rst b/doc/whatsnew/1.6.rst
new file mode 100644
index 000000000..f58a24d80
--- /dev/null
+++ b/doc/whatsnew/1.6.rst
@@ -0,0 +1,200 @@
+**************************
+  What's New In Pylint 1.6
+**************************
+
+:Release: 1.6.0
+:Date: 2016-07-07
+
+
+Summary -- Release highlights
+=============================
+
+Nothing major.
+
+
+New checkers
+============
+
+* We added a new recommendation check, ``consider-iterating-dictionary``,
+  which is emitted when a dictionary is iterated by using ``.keys()``.
+
+  For instance, the following code would trigger this warning, since
+  the dictionary's keys can be iterated without calling the method explicitly.
+
+  .. code-block:: python
+
+      for key in dictionary.keys():
+          ...
+
+      # Can be refactored to:
+      for key in dictionary:
+          ...
+
+* ``trailing-newlines`` check was added, which is emitted when a file has trailing newlines.
+
+
+* ``invalid-length-returned`` check was added, which is emitted when the ``__len__``
+  special method returns something else than a non-negative number. For instance, this
+  example is triggering it::
+
+      class Container(object):
+          def __len__(self):
+              return self._items # Oups, forgot to call len() over it.
+
+
+
+* Add a new check to the *check_docs* extension for looking for duplicate
+  constructor parameters in a class constructor docstring or in a class docstring.
+
+  The check ``multiple-constructor-doc`` is emitted when the parameter is documented
+  in both places.
+
+
+* We added a new extension plugin, ``pylint.extensions.mccabe``, which can be used
+  for warning about the complexity in the code.
+
+  You can enable it as in::
+
+      $ pylint module_or_project --load-plugins=pylint.extensions.mccabe
+
+  See more at :ref:`pylint.extensions.mccabe`
+
+
+New features
+============
+
+* ``generated-members`` now supports qualified names through regular expressions.
+
+  For instance, for ignoring all the errors generated by ``numpy.core``'s attributes, we can
+  now use::
+
+      $ pylint a.py --generated-members=numpy.*
+
+
+* Add the ability to ignore files based on regex matching, with the new ``--ignore-patterns`` option.
+
+  Rather than clobber the existing ``ignore`` option, we decided to have a separate
+  option for it. For instance, for ignoring all the test files, we can now use::
+
+      $ pylint myproject --ignore-patterns=test.*?py
+
+
+* We added a new option, ``redefining-builtins-modules``, which is used for
+  defining the modules which can redefine builtins.
+  *pylint* will emit an error when a builtin is redefined, such as defining
+  a variable called ``next``. But in some cases, the builtins can be
+  redefined in the case they are imported from other places, different
+  than the ``builtins`` module, such is the case for ``six.moves``, which
+  contains more forward-looking functions::
+
+      $ cat a.py
+      # Oups, now pylint emits a redefined-builtin message.
+      from six.moves import open
+      $ pylint a.py --redefining-builtins-modules=six.moves
+
+  Default values: ``six.moves,future.builtins``
+
+
+
+Bug fixes
+=========
+
+* Fixed a bug where the top name of a qualified import was detected as an unused variable.
+
+* We don't warn about ``invalid-sequence-index`` if the indexed object has unknown
+  base classes, that Pylint cannot deduce.
+
+
+
+Other Changes
+=============
+
+
+* The ``bad-builtin`` check was moved into an extension.
+
+  The check was complaining about used builtin functions which
+  were supposed to not be used. For instance, ``map`` and ``filter``
+  were falling into this category, since better alternatives can
+  be used, such as list comprehensions. But the check was annoying,
+  since using ``map`` or ``filter`` can have its use cases and as
+  such, we decided to move it to an extension check instead.
+  It can now be enabled through ``--load-plugins=pylint.extensions.bad_builtin``.
+
+* We use the ``configparser`` backport internally, for Python 2.
+
+  This allows having comments inside list values, in the configuration,
+  such as::
+
+      disable=no-member,
+              # Don't like this check
+              bad-indentation
+
+* We now use the isort_ package internally.
+
+  This improves the ```wrong-import-order`` check, so now
+  we should have less false positives regarding the import order.
+
+
+* We do not emit ``import-error`` or ``no-name-in-module`` for fallback import blocks by default.
+
+  A fallback import block can be considered a TryExcept block, which contains imports in both
+  branches, such as::
+
+      try:
+          import urllib.request as request
+      except ImportError:
+          import urllib2 as request
+
+  In the case where **pylint** can not find one import from the ``except`` branch, then
+  it will emit an ``import-error``, but this gets cumbersome when trying to write
+  compatible code for both Python versions. As such, we don't check these blocks by default,
+  but the analysis can be enforced by using the new ``--analyse-fallback-block`` flag.
+
+* ``reimported`` is emitted when the same name is imported from different module, as in::
+
+      from collections import deque, OrderedDict, deque
+
+
+Deprecated features
+===================
+
+* The HTML support was deprecated and will be eventually removed
+  in Pylint 1.7.0.
+
+  This feature was lately a second class citizen in Pylint, being
+  often neglected and having a couple of bugs. Since we now have
+  the JSON reporter, this can be used as a basis for more prettier
+  HTML outputs than what Pylint can currently offer.
+
+* The ``--files-output`` option was deprecated and will be eventually
+  removed in Pylint 1.7.0.
+
+* The ``--optimize-ast`` option was deprecated and will be eventually
+  removed in Pylint 1.7.0.
+
+  The option was initially added for handling pathological cases,
+  such as joining too many strings using the addition operator, which
+  was leading pylint to have a recursion error when trying to figure
+  out what the string was. Unfortunately, we decided to ignore the
+  issue, since the pathological case would have happen when the
+  code was parsed by Python as well, without actually reaching the
+  runtime step and as such, we will remove the option in the future.
+
+* The ``check_docs`` extension is now deprecated. The extension is still available
+  under the ``docparams`` name, so this should work::
+
+      $ pylint module_or_package --load-extensions=pylint.extensions.docparams
+
+  The old name is still kept for backward compatibility, but it will be
+  eventually removed.
+
+
+Removed features
+================
+
+* None yet
+
+
+
+
+.. _isort: https://pypi.python.org/pypi/isort
diff --git a/doc/whatsnew/1.7.rst b/doc/whatsnew/1.7.rst
new file mode 100644
index 000000000..0690ab9e5
--- /dev/null
+++ b/doc/whatsnew/1.7.rst
@@ -0,0 +1,959 @@
+**************************
+  What's New In Pylint 1.7
+**************************
+
+:Release: 1.7
+:Date: 2017-04-13
+
+
+Summary -- Release highlights
+=============================
+
+* None yet.
+
+
+New checkers
+============
+
+* ``single-string-used-for-slots`` check was added, which is used
+  whenever a class is using a single string as a slot value. While this
+  is technically not a problem per se, it might trip users when manipulating
+  the slots value as an iterable, which would in turn iterate over characters
+  of the slot value. In order to be more straight-forward, always try to use
+  a container such as a list or a tuple for defining slot values.
+
+* We added a new check, ``literal-comparison``, which is used
+  whenever **pylint** can detect a comparison to a literal. This is usually
+  not what we want and, potentially, error prone. For instance, in the given example,
+  the first string comparison returns true, since smaller strings are interned
+  by the interpreter, while for larger ones, it will return False:
+
+  .. code-block:: python
+
+       mystring = "ok"
+       if mystring is "ok": # Returns true
+           # do stuff
+
+       mystring = "a" * 1000
+       if mystring is ("a" * 1000): # This will return False
+           # do stuff
+
+  Instead of using the ``is`` operator, you should use the ``==`` operator for
+  this use case.
+
+
+* We added a new refactoring message, ``consider-merging-isinstance``, which is
+  emitted whenever we can detect that consecutive *isinstance* calls can be merged
+  together.
+  For instance, in this example, we can merge the first two *isinstance* calls:
+
+  .. code-block:: python
+
+      # $ cat a.py
+      if isinstance(x, int) or isinstance(x, float):
+          pass
+      if isinstance(x, (int, float)) or isinstance(x, str):
+          pass
+      # $ pylint a.py
+      # R:  1, 0: Consider merging these isinstance calls to isinstance(x, (float, int)) (consider-merging-isinstance)
+      # R:  3, 0: Consider merging these isinstance calls to isinstance(x, (int, float, str)) (consider-merging-isinstance)
+
+* A new error check was added, ``invalid-metaclass``, which is used whenever *pylint*
+  can detect that a given class is using a metaclass which is invalid for the purpose
+  of the class. This usually might indicate a problem in the code, rather than
+  something done on purpose.
+
+  .. code-block:: python
+
+       # Needs to inherit from *type* in order to be valid
+       class SomeClass(object):
+           ...
+
+       class MyClass(metaclass=SomeClass):
+           pass
+
+* A new warning was added, ``useless-super-delegation``, which is 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.
+
+  For instance, in this example, the first two methods are useless, since they
+  do the exact same thing as the methods from the base classes, while the next
+  two methods are not, since they do some extra operations with the passed
+  arguments.
+
+  .. code-block:: python
+
+      class Impl(Base):
+
+          def __init__(self, param1, param2):
+              super(Impl, self).__init__(param1, param2)
+
+          def useless(self, first, second):
+              return super(Impl, self).useless(first, second)
+
+          def not_useless(self, first, **kwargs):
+              debug = kwargs.pop('debug', False)
+              if debug:
+                  ...
+              return super(Impl, self).not_useless(first, **kwargs)
+
+          def not_useless_1(self, first, *args):
+              return super(Impl, self).not_useless_1(first + some_value, *args)
+
+* A new warning was added, ``len-as-condition``, which is used whenever
+  we detect that a condition uses ``len(SEQUENCE)`` incorrectly. Instead
+  one could use ``if SEQUENCE`` or ``if not SEQUENCE``.
+
+  For instance, all of the examples below:
+
+  .. code-block:: python
+
+      if len(S):
+        pass
+
+      if not len(S):
+        pass
+
+      if len(S) > 0:
+        pass
+
+      if len(S) != 0:
+        pass
+
+      if len(S) == 0:
+        pass
+
+  can be written in a more natural way:
+
+  .. code-block:: python
+
+      if S:
+        pass
+
+      if not S:
+        pass
+
+  See https://www.python.org/dev/peps/pep-0008/#programming-recommendations
+  for more information.
+
+* A new extension was added, ``emptystring.py`` which detects whenever
+  we detect comparisons to empty string constants. This extension is disabled
+  by default. For instance, the examples below:
+
+  .. code-block:: python
+
+      if S != "":
+        pass
+
+      if S == '':
+        pass
+
+  can be written in a more natural way:
+
+  .. code-block:: python
+
+      if S:
+        pass
+
+      if not S:
+        pass
+
+  An exception to this is when empty string is an allowed value whose meaning
+  is treated differently than ``None``. For example the meaning could be
+  user selected no additional options vs. user has not made their selection yet!
+
+  You can activate this checker by adding the line::
+
+      load-plugins=pylint.extensions.emptystring
+
+  to the ``MASTER`` section of your ``.pylintrc`` or using the command::
+
+      $ pylint a.py --load-plugins=pylint.extensions.emptystring
+
+* A new extension was added, ``comparetozero.py`` which detects whenever
+  we compare integers to zero. This extension is disabled by default.
+  For instance, the examples below:
+
+  .. code-block:: python
+
+      if X != 0:
+        pass
+
+      if X == 0:
+        pass
+
+  can be written in a more natural way:
+
+  .. code-block:: python
+
+      if X:
+        pass
+
+      if not X:
+        pass
+
+  An exception to this is when zero is an allowed value whose meaning
+  is treated differently than ``None``. For example the meaning could be
+  ``None`` means no limit, while ``0`` means the limit it zero!
+
+  You can activate this checker by adding the line::
+
+      load-plugins=pylint.extensions.comparetozero
+
+  to the ``MASTER`` section of your ``.pylintrc`` or using the command::
+
+      $ pylint a.py --load-plugins=pylint.extensions.comparetozero
+
+* We've added new error conditions for ``bad-super-call`` which now detect
+  the usage of ``super(type(self), self)`` and ``super(self.__class__, self)``
+  patterns. These can lead to recursion loop in derived classes. The problem
+  is visible only if you override a class that uses these incorrect invocations
+  of ``super()``.
+
+  For instance, ``Derived.__init__()`` will correctly call ``Base.__init__``.
+  At this point ``type(self)`` will be equal to ``Derived`` and the call again
+  goes to ``Base.__init__`` and we enter a recursion loop.
+
+  .. code-block:: python
+
+      class Base(object):
+          def __init__(self, param1, param2):
+              super(type(self), self).__init__(param1, param2)
+
+      class Derived(Base):
+          def __init__(self, param1, param2):
+              super(Derived, self).__init__(param1, param2)
+
+* The warnings ``missing-returns-doc`` and ``missing-yields-doc`` have each
+  been replaced with two new warnings - ``missing-[return|yield]-doc`` and
+  ``missing-[return|yield]-type-doc``. Having these as separate warnings
+  allows the user to choose whether their documentation style requires
+  text descriptions of function return/yield, specification of return/yield
+  types, or both.
+
+  .. code-block:: python
+
+      # This will raise missing-return-type-doc but not missing-return-doc
+      def my_sphinx_style_func(self):
+          """This is a Sphinx-style docstring.
+
+          :returns: Always False
+          """
+          return False
+
+      # This will raise missing-return-doc but not missing-return-type-doc
+      def my_google_style_func(self):
+          """This is a Google-style docstring.
+
+          Returns:
+              bool:
+          """
+          return False
+
+* A new refactoring check was added, ``redefined-argument-from-local``, which is
+  emitted when **pylint** can detect than a function argument is redefined locally
+  in some potential error prone cases. For instance, in the following piece of code,
+  we have a bug, since the check will never return ``True``, given the fact that we
+  are comparing the same object to its attributes.
+
+  .. code-block:: python
+
+      def test(resource):
+          for resource in resources:
+              # The ``for`` is reusing ``resource``, which means that the following
+              # ``resource`` is not what we wanted to check against.
+              if resource.resource_type == resource:
+                 call_resource(resource)
+
+  Other places where this check looks are *with* statement name bindings and
+  except handler's name binding.
+
+* A new refactoring check was added, ``no-else-return``, which is
+  emitted when pylint encounters an else following a chain of ifs,
+  all of them containing a return statement.
+
+  .. code-block:: python
+
+    def foo1(x, y, z):
+        if x:
+            return y
+        else:  # This is unnecessary here.
+            return z
+
+
+  We could fix it deleting the ``else`` statement.
+
+  .. code-block:: python
+
+    def foo1(x, y, z):
+        if x:
+            return y
+        return z
+
+* A new Python 3 check was added, ``eq-without-hash``, which enforces classes that implement
+  ``__eq__`` *also* implement ``__hash__``.  The behavior around classes which implement ``__eq__``
+  but not ``__hash__`` changed in Python 3; in Python 2 such classes would get ``object.__hash__``
+  as their default implementation.  In Python 3, aforementioned classes get ``None`` as their
+  implementation thus making them unhashable.
+
+  .. code-block:: python
+
+      class JustEq(object):
+         def __init__(self, x):
+           self.x = x
+
+         def __eq__(self, other):
+           return self.x == other.x
+
+      class Neither(object):
+        def __init__(self, x):
+          self.x = x
+
+      class HashAndEq(object):
+         def __init__(self, x):
+           self.x = x
+
+         def __eq__(self, other):
+           return self.x == other.x
+
+         def __hash__(self):
+           return hash(self.x)
+
+      {Neither(1), Neither(2)}  # OK in Python 2 and Python 3
+      {HashAndEq(1), HashAndEq(2)}  # OK in Python 2 and Python 3
+      {JustEq(1), JustEq(2)}  # Works in Python 2, throws in Python 3
+
+
+  In general, this is a poor practice which motivated the behavior change.
+
+  .. code-block:: python
+
+      as_set = {JustEq(1), JustEq(2)}
+      print(JustEq(1) in as_set)  # prints False
+      print(JustEq(1) in list(as_set))  # prints True
+
+
+  In order to fix this error and avoid behavior differences between Python 2 and Python 3, classes
+  should either explicitly set ``__hash__`` to ``None`` or implement a hashing function.
+
+  .. code-block:: python
+
+      class JustEq(object):
+         def __init__(self, x):
+           self.x = x
+
+         def __eq__(self, other):
+           return self.x == other.x
+
+         __hash__ = None
+
+      {JustEq(1), JustEq(2)}  # Now throws an exception in both Python 2 and Python 3.
+
+* 3 new Python 3 checkers were added, ``div-method``, ``idiv-method`` and ``rdiv-method``.
+  The magic methods ``__div__`` and ``__idiv__`` have been phased out in Python 3 in favor
+  of ``__truediv__``.  Classes implementing ``__div__`` that still need to be used from Python
+  2 code not using ``from __future__ import division`` should implement ``__truediv__`` and
+  alias ``__div__`` to that implementation.
+
+  .. code-block:: python
+
+      from __future__ import division
+
+      class DivisibleThing(object):
+         def __init__(self, x):
+           self.x = x
+
+         def __truediv__(self, other):
+           return DivisibleThing(self.x / other.x)
+
+         __div__ = __truediv__
+
+* A new Python 3 checker was added to warn about accessing the ``message`` attribute on
+  Exceptions.  The message attribute was deprecated in Python 2.7 and was removed in Python 3.
+  See https://www.python.org/dev/peps/pep-0352/#retracted-ideas for more information.
+
+  .. code-block:: python
+
+      try:
+        raise Exception("Oh No!!")
+      except Exception as e:
+        print(e.message)
+
+  Instead of relying on the ``message`` attribute, you should explicitly cast the exception to a
+  string:
+
+  .. code-block:: python
+
+      try:
+        raise Exception("Oh No!!")
+      except Exception as e:
+        print(str(e))
+
+
+* A new Python 3 checker was added to warn about using ``encode`` or ``decode`` on strings
+  with non-text codecs.  This check also checks calls to ``open`` with the keyword argument
+  ``encoding``.  See https://docs.python.org/3/whatsnew/3.4.html#improvements-to-codec-handling
+  for more information.
+
+  .. code-block:: python
+
+      'hello world'.encode('hex')
+
+  Instead of using the ``encode`` method for non-text codecs use the ``codecs`` module.
+
+  .. code-block:: python
+
+      import codecs
+      codecs.encode('hello world', 'hex')
+
+
+* A new warning was added, ``overlapping-except``, which is emitted
+  when an except handler treats two exceptions which are *overlapping*.
+  This means that one exception is an ancestor of the other one or it is
+  just an alias.
+
+  For example, in Python 3.3+, IOError is an alias for OSError. In addition, socket.error is
+  an alias for OSError. The intention is to find cases like the following:
+
+  .. code-block:: python
+
+      import socket
+      try:
+          pass
+      except (ConnectionError, IOError, OSError, socket.error):
+          pass
+
+* A new Python 3 checker was added to warn about accessing ``sys.maxint``.  This attribute was
+  removed in Python 3 in favor of ``sys.maxsize``.
+
+  .. code-block:: python
+
+      import sys
+      print(sys.maxint)
+
+  Instead of using ``sys.maxint``, use ``sys.maxsize``
+
+  .. code-block:: python
+
+      import sys
+      print(sys.maxsize)
+
+* A new Python 3 checker was added to warn about importing modules that have either moved or been
+  removed from the standard library.
+
+  One of the major undertakings with Python 3 was a reorganization of the standard library to
+  remove old or supplanted modules and reorganize some of the existing modules.  As a result,
+  roughly 100 modules that exist in Python 2 no longer exist in Python 3.  See
+  https://www.python.org/dev/peps/pep-3108/ and https://www.python.org/dev/peps/pep-0004/ for more
+  information.  For suggestions on how to handle this, see
+  https://pythonhosted.org/six/#module-six.moves or http://python3porting.com/stdlib.html.
+
+  .. code-block:: python
+
+      from cStringIO import StringIO
+
+  Instead of directly importing the deprecated module, either use ``six.moves`` or a conditional
+  import.
+
+  .. code-block:: python
+
+      from six.moves import cStringIO as StringIO
+
+      if sys.version_info[0] >= 3:
+          from io import StringIO
+      else:
+          from cStringIO import StringIO
+
+  This checker will assume any imports that happen within a conditional or a ``try/except`` block
+  are valid.
+
+* A new Python 3 checker was added to warn about accessing deprecated functions on the string
+  module.  Python 3 removed functions that were duplicated from the builtin ``str`` class.  See
+  https://docs.python.org/2/library/string.html#deprecated-string-functions for more information.
+
+  .. code-block:: python
+
+      import string
+      print(string.upper('hello world!'))
+
+  Instead of using ``string.upper``, call the ``upper`` method directly on the string object.
+
+  .. code-block:: python
+
+      "hello world!".upper()
+
+
+* A new Python 3 checker was added to warn about calling ``str.translate`` with the removed
+  ``deletechars`` parameter.  ``str.translate`` is frequently used as a way to remove characters
+  from a string.
+
+  .. code-block:: python
+
+      'hello world'.translate(None, 'low')
+
+  Unfortunately, there is not an idiomatic way of writing this call in a 2and3 compatible way.  If
+  this code is not in the critical path for your application and the use of ``translate`` was a
+  premature optimization, consider using ``re.sub`` instead:
+
+  .. code-block:: python
+
+      import re
+      chars_to_remove = re.compile('[low]')
+      chars_to_remove.sub('', 'hello world')
+
+  If this code is in your critical path and must be as fast as possible, consider declaring a
+  helper method that varies based upon Python version.
+
+  .. code-block:: python
+
+      if six.PY3:
+          def _remove_characters(text, deletechars):
+              return text.translate({ord(x): None for x in deletechars})
+      else:
+          def _remove_characters(text, deletechars):
+              return text.translate(None, deletechars)
+
+* A new refactoring check was added, ``consider-using-ternary``, which is
+  emitted when pylint encounters constructs which were used to emulate
+  ternary statement before it was introduced in Python 2.5.
+
+  .. code-block:: python
+
+    value = condition and truth_value or false_value
+
+
+  Warning can be fixed by using standard ternary construct:
+
+  .. code-block:: python
+
+    value = truth_value if condition else false_value
+
+
+* A new refactoring check was added, ``trailing-comma-tuple``, which 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.
+
+  The warning is emitted for such a construct:
+
+  .. code-block:: python
+
+     a = 1,
+
+  The warning can be fixed by adding parantheses:
+
+  .. code-block:: python
+
+     a = (1, )
+
+
+* Two new check were added for detecting an unsupported operation
+  over an instance, ``unsupported-assignment-operation`` and ``unsupported-delete-operation``.
+  The first one is emitted whenever an object does not support item assignment, while
+  the second is emitted when an object does not support item deletion:
+
+  .. code-block:: python
+
+      class A:
+          pass
+      instance = A()
+      instance[4] = 4 # unsupported-assignment-operation
+      del instance[4] # unsupported-delete-operation
+
+* A new check was added, ``relative-beyond-top-level``, which is emitted
+  when a relative import tries to access too many levels in the current package.
+
+* A new check was added, ``trailing-newlines``, which is emitted when a file
+  has trailing new lines.
+
+* ``invalid-length-returned`` check was added, which is emitted when a ``__len__``
+  implementation does not return a non-negative integer.
+
+* There is a new extension, ``pylint.extensions.mccabe``, which can be used for
+  computing the McCabe complexity of classes and functions.
+
+  You can enable this extension through ``--load-plugins=pylint.extensions.mccabe``
+
+* A new check was added, ``used-prior-global-declaration``. This is emitted when
+  a name is used prior a global declaration, resulting in a SyntaxError in Python 3.6.
+
+* A new message was added, ``assign-to-new-keyword``. This is emitted when used name
+  is known to become a keyword in future Python release. Assignments to keywords
+  would result in ``SyntaxError`` after switching to newer interpreter version.
+
+  .. code-block:: python
+
+      # While it's correct in Python 2.x, it raises a SyntaxError in Python 3.x
+      True = 1
+      False = 0
+
+      # Same as above, but it'll be a SyntaxError starting from Python 3.7
+      async = "async"
+      await = "await
+
+
+Other Changes
+=============
+
+* We 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.
+
+* Namespace packages are now supported by pylint. This includes both explicit namespace
+  packages and implicit namespace packages, supported in Python 3 through PEP 420.
+
+* A new option was added, ``--analyse-fallback-block``.
+
+  This can be used to support both Python 2 and 3 compatible import block code,
+  which means that the import block might have code that exists only in one or another
+  interpreter, leading to false positives when analysed. By default, this is false, you
+  can enable the analysis for both branches using this flag.
+
+* ``ignored-argument-names`` option 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.
+
+* A new option was added, ``redefining-builtins-modules``, for controlling the modules
+  which can redefine builtins, such as six.moves and future.builtins.
+
+* A new option was added, ``ignore-patterns``, which is used for building a
+  ignore list of directories and files matching the regex patterns, similar to the
+  ``ignore`` option.
+
+
+* The reports are now disabled by default, as well as the information category
+  warnings.
+
+* ``arguments-differ`` check was rewritten to take in consideration
+  keyword only parameters and variadics.
+
+  Now it also complains about losing or adding capabilities to a method,
+  by introducing positional or keyword variadics. For instance, *pylint*
+  now complains about these cases:
+
+  .. code-block:: python
+
+       class Parent(object):
+
+           def foo(self, first, second):
+               ...
+
+           def bar(self, **kwargs):
+               ...
+
+           def baz(self, *, first):
+               ...
+
+       class Child(Parent):
+
+           # Why subclassing in the first place?
+           def foo(self, *args, **kwargs):
+               # mutate args or kwargs.
+               super(Child, self).foo(*args, **kwargs)
+
+           def bar(self, first=None, second=None, **kwargs):
+               # The overridden method adds two new parameters,
+               # which can also be passed as positional arguments,
+               # breaking the contract of the parent's method.
+
+           def baz(self, first):
+               # Not keyword-only
+
+* ``redefined-outer-name`` is now also emitted when a
+  nested loop's target variable is the same as an outer loop.
+
+  .. code-block:: python
+
+      for i, j in [(1, 2), (3, 4)]:
+          for j in range(i):
+              print(j)
+
+* relax character limit for method and function names that starts with ``_``.
+  This will let people to use longer descriptive names for methods and
+  functions with a shorter scope (considered as private). The same idea
+  applies to variable names, only with an inverse rule: you want long
+  descriptive names for variables with bigger scope, like globals.
+
+* Add ``InvalidMessageError`` exception class and replace ``assert`` in
+  pylint.utils with ``raise InvalidMessageError``.
+
+* ``UnknownMessageError`` (formerly ``UnknownMessage``) and
+  ``EmptyReportError`` (formerly ``EmptyReport``) are now provided by the new
+  ``pylint.exceptions`` submodule instead of ``pylint.utils`` as before.
+
+* We now support inline comments for comma separated values in the configurations
+
+  For instance, you can now use the **#** sign for having comments inside
+  comma separated values, as seen below::
+
+      disable=no-member, # Don't care about it for now
+              bad-indentation, # No need for this
+              import-error
+
+  Of course, interweaving comments with values is also working::
+
+      disable=no-member,
+              # Don't care about it for now
+              bad-indentation # No need for this
+
+
+  This works by setting the `inline comment prefixes`_ accordingly.
+
+* Added epytext docstring support to the docparams extension.
+
+* We added support for providing hints when not finding a missing member.
+
+  For example, given the following code, it should be obvious that
+  the programmer intended to use the ``mail`` attribute, rather than
+  ``email``.
+
+  .. code-block:: python
+
+    class Contribution:
+        def __init__(self, name, email, date):
+            self.name = name
+            self.mail = mail
+            self.date = date
+
+    for c in contributions:
+        print(c.email) # Oups
+
+  **pylint** will now warn that there is a chance of having a typo,
+  suggesting new names that could be used instead.
+
+  .. code-block:: sh
+
+    $ pylint a.py
+    E: 8,10: Instance of 'Contribution' has no 'email' member; maybe 'mail'?
+
+  The behaviour is controlled through the ``--missing-member-hint`` option.
+  Other options that come with this change are ``--missing-member-max-choices``
+  for choosing the total number of choices that should be picked in this
+  situation and ``--missing-member-hint-distance``, which specifies a metric
+  for computing the distance between the names (this is based on Levenshtein
+  distance, which means the lower the number, the more pickier the algorithm
+  will be).
+
+* ``PyLinter.should_analyze_file`` has a new parameter, ``is_argument``,
+  which specifies if the given path is a **pylint** argument or not.
+
+  ``should_analyze_file`` is called whenever **pylint** tries to determine
+  if a file should be analyzed, defaulting to files with the ``.py``
+  extension, but this function gets called only in the case where the said
+  file is not passed as a command line argument to **pylint**. This usually
+  means that pylint will analyze a file, even if that file has a different
+  extension, as long as the file was explicitly passed at command line.
+  Since ``should_analyze_file`` cannot be overridden to handle all the cases,
+  the check for the provenience of files was moved into ``should_analyze_file``.
+  This means we now can write something similar with this example, for ignoring
+  every file respecting the desired property, disregarding the provenience of the
+  file, being it a file passed as CLI argument or part of a package.
+
+  .. code-block:: python
+
+     from pylint.lint import Run, PyLinter
+
+     class CustomPyLinter(PyLinter):
+
+          def should_analyze_file(self, modname, path, is_argument=False):
+              if respect_condition(path):
+                  return False
+              return super().should_analyze_file(modname, path, is_argument=is_argument)
+
+
+     class CustomRun(Run):
+          LinterClass = CustomPyLinter
+
+     CustomRun(sys.argv[1:])
+
+* Imports aliased with underscore are skipped when checking for unused imports.
+
+* ``bad-builtin`` and ``redefined-variable-type`` are now extensions,
+  being disabled by default. They can be enabled through:
+  ``--load-plugins=pylint.extensions.redefined_variable_type,pylint.extensions.bad_builtin``
+
+  * Imports checker supports new switch ``allow-wildcard-with-all`` which disables
+    warning on wildcard import when imported module defines ``__all__`` variable.
+
+* ``differing-param-doc`` is now used for the differing part of the old ``missing-param-doc``,
+  and ``differing-type-doc`` for the differing part of the old ``missing-type-doc``.
+
+
+Bug fixes
+=========
+
+* Fix a false positive of ``redundant-returns-doc``, occurred when the documented
+  function was using *yield* instead of *return*.
+
+* 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.
+
+* Added proper exception type inference for ``missing-raises-doc``. Now:
+
+  .. code-block:: python
+
+      def my_func():
+          """"My function."""
+          ex = ValueError('foo')
+          raise ex
+
+  will properly be flagged for missing documentation of
+  ``:raises ValueError:`` instead of ``:raises ex:``, among other scenarios.
+
+* Fix false positives of ``missing-[raises|params|type]-doc`` due to not
+  recognizing valid keyword synonyms supported by Sphinx.
+
+* More thorough validation in ``MessagesStore.register_messages()`` to detect
+  conflicts between a new message and any existing message id, symbol,
+  or ``old_names``.
+
+* We now support having plugins that shares the same name and with each one
+  providing options.
+
+  A plugin can be logically split into multiple classes, each class providing
+  certain capabilities, all of them being tied under the same name. But when
+  two or more such classes are also adding options, then **pylint** crashed,
+  since it already added the first encountered section. Now, these should
+  work as expected.
+
+  .. code-block:: python
+
+     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))
+
+* We do not yield ``unused-argument`` for singledispatch implementations and
+  do not warn about ``function-redefined`` for multiple implementations with same name.
+
+  .. code-block:: python
+
+     from functools import singledispatch
+
+     @singledispatch
+     def f(x):
+         return 2*x
+
+     @f.register(str)
+     def _(x):
+         return -1
+
+     @f.register(int)
+     @f.register(float)
+     def _(x):
+         return -x
+
+* ``unused-variable`` checker has new functionality of warning about unused
+  variables in global module namespace. Since globals in module namespace
+  may be a part of exposed API, this check is disabled by default. For
+  enabling it, set ``allow-global-unused-variables`` option to false.
+
+* Fix a false-positive ``logging-format-interpolation`` message, when format
+  specifications are used in formatted string. In general, these operations
+  are not always convertible to old-style formatting used by logging module.
+
+* Added a new switch ``single-line-class-stmt`` to allow single-line declaration
+  of empty class bodies (as seen in the example below). Pylint won't emit a
+  ``multiple-statements`` message when this option is enabled.
+
+  .. code-block:: python
+
+     class MyError(Exception): pass
+
+  * ``too-many-format-args`` and ``too-few-format-args`` are emitted correctly
+    (or not emitted at all, when exact count of elements in RHS cannot be
+    inferred) when starred expressions are used in RHS tuple. For example,
+    code block as shown below detects correctly that the used tuple has in
+    fact three elements, not two.
+
+  .. code-block:: python
+
+    meat = ['spam', 'ham']
+    print('%s%s%s' % ('eggs', *meat))
+
+* ``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.
+
+Removed Changes
+===============
+
+* ``pylint-gui`` was removed, because it was deemed unfit for being included
+  in *pylint*. It had a couple of bugs and misfeatures, its usability was subpar
+  and since its development was neglected, we decided it is best to move on without it.
+
+
+* The HTML reporter was removed, including the ``--output-format=html`` option.
+  It was lately a second class citizen in Pylint, being mostly neglected.
+  Since we now have the JSON reporter, it can be used as a basis for building
+  more prettier HTML reports than what Pylint can currently generate. This is
+  part of the effort of removing cruft from Pylint, by removing less used
+  features.
+
+* The ``--files-output`` option was removed. While the same functionality cannot
+  be easily replicated, the JSON reporter, for instance, can be used as a basis
+  for generating the messages per each file.
+
+* ``--required-attributes`` option was removed.
+
+* ``--ignore-iface-methods`` option was removed.
+
+* The ``--optimize-ast`` flag was removed.
+
+  The option was initially added for handling pathological cases,
+  such as joining too many strings using the addition operator, which
+  was leading pylint to have a recursion error when trying to figure
+  out what the string was. Unfortunately, we decided to ignore the
+  issue, since the pathological case would have happen when the
+  code was parsed by Python as well, without actually reaching the
+  runtime step and as such, we decided to remove the error altogether.
+
+* ``epylint.py_run``'s *script* parameter was removed.
+
+  Now ``epylint.py_run`` is always using the underlying ``epylint.lint``
+  method from the current interpreter. This avoids some issues when multiple
+  instances of **pylint** are installed, which means that ``epylint.py_run``
+  might have ran a different ``epylint`` script than what was intended.
+
+.. _`inline comment prefixes`: https://docs.python.org/3/library/configparser.html#customizing-parser-behaviour
diff --git a/doc/whatsnew/1.8.rst b/doc/whatsnew/1.8.rst
new file mode 100644
index 000000000..6121b81a8
--- /dev/null
+++ b/doc/whatsnew/1.8.rst
@@ -0,0 +1,374 @@
+**************************
+  What's New In Pylint 1.8
+**************************
+
+:Release: 1.8
+:Date: 2017-12-15
+
+
+Summary -- Release highlights
+=============================
+
+* None so far
+
+New checkers
+============
+
+* A new check was added, ``shallow-copy-environ``.
+
+  This warning message is emitted when shallow copy of os.environ is created.
+  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.
+
+  .. code-block:: python
+
+     import copy
+     import os
+     wrong_env_copy = copy.copy(os.environ)  # will emit pylint warning
+     wrong_env_copy['ENV_VAR'] = 'new_value'  # changes os.environ
+     assert os.environ['ENV_VAR'] == 'new_value'
+
+     good_env_copy = dict(os.environ)  # the right way
+     good_env_copy['ENV_VAR'] = 'different_value'  # doesn't change os.environ
+     assert os.environ['ENV_VAR'] == 'new_value'
+
+* A new check was added, ``keyword-arg-before-vararg``.
+
+  This warning message is emitted when a function is defined with a keyword
+  argument appearing before variable-length 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.
+
+  .. code-block:: python
+
+     def foo(a, b=3, *args):
+         print(a, b, args)
+
+     # Case1: a=0, b=2, args=(4,5)
+     foo(0,2,4,5) # 0 2 (4,5) ==> Observed values are same as expected values
+
+     # Case2: a=0, b=<default_value>, args=(4,5)
+     foo(0,4,5) # 0 4 (5,) ==> args list got modified as well as the observed value of b
+
+     # Case3: Syntax Error if tried as follows
+     foo(0,b=2,4,5) # syntax error
+
+* A new check was added, ``simplify-boolean-expression``.
+
+  This message is emitted when ``consider-using-ternary`` check would emit
+  not equivalent code, due to truthy element being falsy in boolean context.
+
+  .. code-block:: python
+
+     value = condition and False or other_value
+
+  This flawed construct may be simplified to:
+
+  .. code-block:: python
+
+     value = other_value
+
+* A new check was added, ``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.
+
+  In the following example, the instantiation will fail, which is definitely
+  not desired:
+
+  .. code-block:: python
+
+     import threading
+     threading.Thread(lambda: print(1)) # Oups, this is the group parameter
+
+* A new Python 3 checker was added to warn about accessing functions that have been
+  removed from the itertools module ``izip``, ``imap``, ``iflter``, ``izip_longest``, and ``ifilterfalse``.
+
+  .. code-block:: python
+
+      from itertools import izip
+      print(list(izip([1, 2], [3])))
+
+  Instead use ``six.moves`` to import a Python 2 and Python 3 compatible function:
+
+  .. code-block:: python
+
+      from six.moves import zip
+      print(list(zip([1, 2], [3])))
+
+* A new Python 3 checker was added to warn about accessing deprecated fields from
+  the types module like ``ListType`` or ``IntType``
+
+  .. code-block:: python
+
+      from types import ListType
+      print(isinstance([], ListType))
+
+  Instead use the declarations in the builtin namespace:
+
+  .. code-block:: python
+
+      print(isinstance([], list))
+
+* A new Python 3 checker was added to warn about declaring a ``next`` method that
+  would have implemented the ``Iterator`` protocol in Python 2 but is now a normal
+  method in Python 3.
+
+  .. code-block:: python
+
+      class Foo(object):
+          def next(self):
+              return 42
+
+  Instead implement a ``__next__`` method and use ``six.Iterator`` as a base class
+  or alias ``next`` to ``__next__``:
+
+  .. code-block:: python
+
+      class Foo(object):
+          def __next__(self):
+              return 42
+          next = __next__
+
+* Three new Python 3 checkers were added to warn about using dictionary methods
+  in non-iterating contexts.
+
+  For example, the following are returning iterators in Python 3::
+
+  .. code-block:: python
+
+     d = {}
+     d.keys()[0]
+     d.items()[0]
+     d.values() + d.keys()
+
+* A new Python 3 porting check was added, ``non-ascii-bytes-literals``
+
+  This message is emitted whenever we detect that a bytes string contain
+  non-ASCII characters, which results in a SyntaxError on Python 3.
+
+* A new warning, ``raising-format-tuple``, will catch situations where the
+  intent was likely raising an exception with a formatted message string,
+  but the actual code did omit the formatting and instead passes template
+  string and value parameters as separate arguments to the exception
+  constructor.  So it detects things like
+
+  .. code-block:: python
+
+      raise SomeError('message about %s', foo)
+      raise SomeError('message about {}', foo)
+
+  which likely were meant instead as
+
+  .. code-block:: python
+
+      raise SomeError('message about %s' % foo)
+      raise SomeError('message about {}'.format(foo))
+
+  This warning can be ignored on projects which deliberately use lazy
+  formatting of messages in all user-facing exception handlers.
+
+* Following the recommendations of PEP479_ ,a new Python 3.0 checker was added to warn about raising a ``StopIteration`` inside
+  a generator. Raising a ``StopIteration`` inside a generator may be due a direct call
+  to ``raise StopIteration``:
+
+  .. code-block:: python
+
+      def gen_stopiter():
+          yield 1
+          yield 2
+          yield 3
+          raise StopIteration
+
+  Instead use a simple ``return`` statement
+
+  .. code-block:: python
+
+      def gen_stopiter():
+          yield 1
+          yield 2
+          yield 3
+          return
+
+  Raising a ``StopIteration`` may also be due to the call to ``next`` function with a generator
+  as argument:
+
+  .. code-block:: python
+
+      def gen_next_raises_stopiter():
+          g = gen_ok()
+          while True:
+              yield next(g)
+
+  In this case, surround the call to ``next`` with a try/except block:
+
+  .. code-block:: python
+
+      def gen_next_raises_stopiter():
+          g = gen_ok()
+          while True:
+              try:
+                  yield next(g)
+              except StopIteration:
+                  return
+
+  The check about raising a StopIteration inside a generator is also valid if the exception
+  raised inherit from StopIteration.
+  Close #1385
+
+ .. _PEP479: https://www.python.org/dev/peps/pep-0479
+
+* A new Python checker was added to warn about using a ``+`` operator inside call of logging methods
+  when one of the operands is a literal string:
+
+  .. code-block:: python
+
+     import logging
+     var = "123"
+     logging.log(logging.INFO, "Var: " + var)
+
+  Instead use formatted string and positional arguments :
+
+  .. code-block:: python
+
+     import logging
+     var = "123"
+     logging.log(logging.INFO, "Var: %s", var)
+
+* A new Python checker was added to warn about ``inconsistent-return-statements``. A function or a method
+  has inconsistent return statements if it returns both explicit and implicit values :
+
+  .. code-block:: python
+
+    def mix_implicit_explicit_returns(arg):
+        if arg < 10:
+            return True
+        elif arg < 20:
+            return
+
+  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).
+  Thus, the previous function should be written:
+
+  .. code-block:: python
+
+    def mix_implicit_explicit_returns(arg):
+        if arg < 10:
+            return True
+        elif arg < 20:
+            return None
+
+  Close #1267
+
+ .. _PEP8: https://www.python.org/dev/peps/pep-0008
+
+Other Changes
+=============
+
+* Fixing u'' string in superfluous-parens message.
+
+* Configuration options of invalid name checker are significantly redesigned.
+  Predefined rules for common naming styles were introduced. For typical
+  setups, user friendly options like ``--function-naming-style=camelCase`` may
+  be used in place of hand-written regular expressions. Default linter config
+  enforce PEP8-compatible naming style. See documentation for details.
+
+* Raise meaningful exception in case of invalid reporter class (output format)
+  being selected.
+
+* The docparams extension now allows a property docstring to document both
+  the property and the setter. Therefore setters can also have no docstring.
+
+* The docparams extension now understands property type syntax.
+
+  .. code-block:: python
+
+      class Foo(object):
+          @property
+          def foo(self):
+              """My Sphinx style docstring description.
+
+              :type: int
+              """
+              return 10
+
+  .. code-block:: python
+
+    class Foo(object):
+        @property
+        def foo(self):
+            """int: My Numpy and Google docstring style description."""
+            return 10
+
+* In case of ``--output-format=json``, the dictionary returned holds a new key-value pair.
+  The key is ``message-id`` and the value the message id.
+
+* Spelling checker has a new configuration parameter ``max-spelling-suggestions``, which
+  affects maximum count of suggestions included in emitted message.
+
+* The **invalid-name** check contains the name of the template that caused the failure.
+
+  For the given code, **pylint** used to emit ``invalid-name`` in the form ``Invalid constant name var``,
+  without offering any context why ``var`` is not such a good name.
+
+  With this change, it is now more clear what should be improved for a name to be accepted according to
+  its corresponding template.
+
+* New configuration flag, ``suggestion-mode`` was introduced. When enabled, pylint would
+  attempt to emit user-friendly suggestions instead of spurious errors for some known
+  false-positive scenarios. Flag is enabled by default.
+
+* ``superfluous-parens`` is no longer wrongly emitted for logical statements involving ``in`` operator
+  (see example below for what used to be false-positive).
+
+  .. code-block:: python
+
+    foo = None
+    if 'bar' in (foo or {}):
+      pass
+
+* Redefinition of dummy function is now possible. ``function-redefined`` message won't be emitted anymore when
+  dummy functions are redefined.
+
+* ``missing-param-doc`` and ``missing-type-doc`` are no longer emitted when
+  ``Args`` and ``Keyword Args`` are mixed in Google docstring.
+
+* Fix of false positive ``useless-super-delegation`` message when
+  parameters default values are different from those used in the base class.
+
+* Fix of false positive ``useless-else-on-loop`` message when break statements
+  are deeply nested inside loop.
+
+* The Python 3 porting checker no longer emits multiple ``no-absolute-import`` per file.
+
+* The Python 3 porting checker respects disabled checkers found in the config file.
+
+* Modules, classes, or methods consist of compound statements that exceed the ``docstring-min-length``
+  are now correctly emitting ``missing-docstring``
+
+* Fix no ``wrong-import-order`` message emitted on ordering of first and third party libraries.
+  With this fix, pylint distinguishes first and third party modules when checking
+  import order.
+
+* Fix the ignored ``pylint disable=fixme`` directives for comments following
+  the last statement in a file.
+
+* 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.
+
+* If the rcfile specified on the command line doesn't exist, then an
+  IOError exception is raised.
+
+* Fix the wrong scope of ``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.
diff --git a/doc/whatsnew/1.9.rst b/doc/whatsnew/1.9.rst
new file mode 100644
index 000000000..f70b41dc7
--- /dev/null
+++ b/doc/whatsnew/1.9.rst
@@ -0,0 +1,92 @@
+**************************
+  What's New In Pylint 1.9
+**************************
+
+:Release: 1.9
+:Date: 2018-05-15
+
+
+Summary -- Release highlights
+=============================
+
+* None so far
+
+New checkers
+============
+
+* A new Python 3 checker was added to warn about the removed ``operator.div`` function.
+
+* A new Python 3 checker was added to warn about accessing functions that have been
+  moved from the urllib module in corresponding subpackages, such as ``urllib.request``.
+
+  .. code-block:: python
+
+      from urllib import urlencode
+
+  Instead the previous code should use ``urllib.parse`` or ``six.moves`` to import a
+  module in a Python 2 and 3 compatible fashion:
+
+  .. code-block:: python
+
+      from six.moves.urllib.parse import urlencode
+
+
+  To have this working on Python 3 as well, please use the ``six`` library:
+
+  .. code-block:: python
+
+      six.reraise(Exception, "value", tb)
+
+
+* A new check was added to warn about using unicode raw string literals. This is
+  a syntax error in Python 3:
+
+  .. code-block:: python
+
+      a = ur'...'
+
+* Added a new ``deprecated-sys-function`` check, emitted when accessing removed ``sys`` members.
+
+* Added ``xreadlines-attribute`` check, emitted when the ``xreadlines()`` attribute is accessed
+  on a file object.
+
+* 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.
+
+  .. code-block:: python
+
+      try:
+        1/0
+      except ZeroDivisionError as exc:
+         ...
+      print(exc) # This will raise a NameError on Python 3
+
+      [i for i in some_iterator if some_condition(i)]
+      print(i) # This will raise a NameError on Python 3
+
+
+Other Changes
+=============
+
+* ``defaultdict`` and subclasses of ``dict`` are now handled for `dict-iter-*` checks. That
+  means that the following code will now emit warnings for when ``iteritems`` and friends
+  are accessed:
+
+  .. code-block:: python
+
+      some_dict = defaultdict(list)
+      ...
+      some_dict.iterkeys()
+
+* Enum classes no longer trigger ``too-few-methods``
+
+* Special methods now count towards ``too-few-methods``,
+  and are considered part of the public API.
+  They are still not counted towards the number of methods for
+  ``too-many-methods``.
+
+* docparams allows abstract methods to document returns documentation even
+  if the default implementation does not return something.
+  They also no longer need to document raising a NotImplementedError.
diff --git a/doc/whatsnew/2.0.rst b/doc/whatsnew/2.0.rst
new file mode 100644
index 000000000..b94bdf5f3
--- /dev/null
+++ b/doc/whatsnew/2.0.rst
@@ -0,0 +1,359 @@
+**************************
+ What's New in Pylint 2.0
+**************************
+
+:Release: 2.0
+:Date: 2018-07-15
+
+Summary -- Release highlights
+=============================
+
+* Dropped support for Python 2. This release will work only on Python 3.4+.
+
+  If you need to use ``pylint`` with Python 2, you can use Pylint 1.9+. We'll continue
+  to do bug releases until 2020, when Python 2 goes officially EOL.
+  ``pylint`` will gain the ability to analyze Python 2 files, but some checks might not work
+  as they will assume that their running environment is Python 2.
+
+* Given the dropping of Python 2, the Python 3 porting mode (enabled via ``--py3k``) can now
+  also run with Python 3.
+
+  The porting mode used to be a no-op on Python 3, but most of the messages can now be emitted
+  when the running interpreter is Python 3. The only messages that won't be emitted are those that
+  rely on a particular syntax specific to Python 2, for instance ``print`` as a statement.
+
+
+New checkers
+============
+* A new check was added, ``useless-object-inheritance``.
+
+  This refactoring message is emitted when pylint detects that a class inherits from object,
+  which is redundant as in Python 3, every class implicitly inherits from object.
+
+  .. code-block:: python
+
+    class A(object):
+        pass
+
+    class A:    # better
+        pass
+
+* A new check was added, ``comparison-with-callable``.
+
+  This refactoring 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.
+
+  .. code-block:: python
+
+    def foo():
+        return None
+
+    def goo():
+        return None
+
+    if foo == 786:  # bad
+        pass
+
+    if foo() == 786:    # good
+        pass
+
+* A new check was added, ``chained-comparison``.
+
+  This refactoring message is emitted if a boolean operation can be simplified by chaining some
+  of its operations. check below example:
+
+  .. code-block:: python
+
+    if a < b and b < c:
+        pass
+
+    if a < b < c:   # better
+        pass
+
+* A new check was added, ``useless-import-alias``.
+
+  This refactoring message is emitted when an import alias does not rename the original package.
+
+  .. code-block:: python
+
+    import numpy as numpy # bad
+    import numpy as np # good
+    from collection import OrderedDict as OrderedDict # bad
+    from collection import OrderedDict as ordered_dict # good
+
+* A new check was added, ``comparison-with-itself``.
+
+  This refactoring message is emitted when a variable is compared against itself.
+
+  .. code-block:: python
+
+    if variable == variable:  # bad
+        pass
+
+* A new check was added, ``consider-using-in``.
+
+  This refactoring message is emitted when a variable is compared against multiple
+  values concatenated by ors instead of using the faster, more idiomatic "in" check.
+
+  .. code-block:: python
+
+    if variable == 1 or variable == 2 or variable == 3:  # bad
+        pass
+
+    if variable in (1, 2, 3):  # good
+        pass
+
+* A new check was added, ``consider-using-get``.
+
+  This refactoring message is emitted when manually checking if a key is in a dictionary
+  and getting its value if it is (and optionally a default if not)
+  instead of the more idiomatic dict.get.
+
+  .. code-block:: python
+
+    if 'key' in dictionary:  # bad
+        variable = dictionary['key']
+    else:
+        variable = 'default'
+
+    variable = dictionary.get('key', 'default')  # good
+
+* A new check was added, ``consider-using-join``.
+
+  This refactoring message is emitted when using a for loop over an iterable to join strings
+  instead of the faster, less memory consuming and more idiomatic str.join(sequence).
+
+  .. code-block:: python
+
+    result = ''  # bad
+    for number in ['1', '2', '3']:
+        result += number
+
+    result = ''.join(['1', '2', '3'])  # good
+
+* 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.
+
+* New ``use-symbolic-message-instead`` message when a message is activated or
+  deactivated by id instead of symbol.
+  The use of symbol is more explicit and easier to remind.
+
+* A new check was added, ``consider-swap-variables``.
+
+  This refactoring message is emitted when using a temporary variable in order
+  to swap the values of two variables instead of the shorter, more idiomatic
+  approach with tuple-unpacking.
+
+  Instead of a temporary variable, the one-line syntax with commas should be used.
+
+  See this `style guide`_ document or this `swap values presentation`_ for details.
+
+  .. code-block:: python
+
+     temp = a  # the wrong way
+     a = b
+     b = temp
+
+     a, b = b, a  # the right way
+
+* Two new checks, ``invalid-envvar-value`` and ``invalid-envvar-default``, were added.
+
+  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.
+
+* A new check was added, ``subprocess-popen-preexec-fn``,
+
+  This refactoring message is emitted when using the keyword argument preexec_fn
+  when creating subprocess.Popen instances which may be unsafe when used in
+  the presence of threads.
+
+  See `subprocess.Popen <https://docs.python.org/3/library/subprocess.html#popen-constructor>`_
+  for full warning details.
+
+* New ``try-except-raise`` message when an except handler block has a bare
+  ``raise`` statement as its first operator or the exception type being raised
+  is the same as the one being handled.
+
+*  New ``possibly-unused-variable`` check added.
+
+  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.
+
+  For instance, the following code will now trigger this new error:
+
+  .. code-block:: python
+
+     def func():
+         some_value = some_call()
+         return locals()
+
+* New ``unhashable-dict-key`` check added to detect dict lookups using
+  unhashable keys such as lists or dicts.
+
+* New ``self-cls-assignment`` warning check added.
+
+  This is warning if the first argument of an instance/ class method gets
+  assigned
+
+  .. code-block:: python
+
+     class Foo(object):
+         def foo(self, bar):
+             self = bar
+
+* New verbose mode option ``--verbose`` to display of extra non-checker-related output. Disabled by default.
+
+* Two new checks were added for recommending dict and set comprehensions where possible.
+
+  These two checks are going to flag the following examples:
+
+  .. code-block:: python
+
+     dict([(k, v) for (k, v) in ...]) # better as {k: v for k, v in ...}
+     set([k for k in ...]) # better as {k for k in ...}
+
+Other Changes
+=============
+
+* A couple of performance improvements brought to ``astroid`` should make
+  ``pylint`` should be a bit faster as well.
+
+  We added a new flag, ``max_inferable_values`` on :class:`astroid.MANAGER` for
+  limitting the maximum amount of values that ``astroid`` can infer when inferring
+  values. This change should improve the performance when dealing with large frameworks
+  such as ``django``.
+  You can also control this behaviour with ``pylint --limit-inference-results``
+
+  We also rewrote how ``nodes_of_class`` and ``get_children`` methods operate which
+  should result in a performance boost for a couple of checks.
+
+* Fix a false positive ``inconsistent-return-statements`` message when exception is raised inside
+  an else statement.
+
+* 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.
+
+* Fix a false positive ``inconsistent-return-statements`` message when if
+  statement is inside try/except.
+
+* Fix a false positive ``inconsistent-return-statements`` message when
+  ``while`` loop are used.
+
+* Fix emission of false positive ``no-member`` message for class with
+  "private" attributes whose name is mangled.
+
+* Fix ``unused-argument`` false positives with overshadowed variable in dictionary comprehension.
+
+* Fixing false positive ``inconsistent-return-statements`` when
+  never returning functions are used (i.e such as sys.exit).
+
+* Fix false positive ``inconsistent-return-statements`` message when a
+  function is defined under an if statement.
+
+* Fix false positive ``inconsistent-return-statements`` message by
+  avoiding useless exception inference if the exception is not handled.
+
+* Fix false positive ``undefined-variable`` for lambda argument in class definitions
+
+* Suppress false-positive ``not-callable`` messages from certain staticmethod descriptors
+
+* Expand ``ignored-argument-names`` include starred arguments and keyword arguments
+
+* ``singleton-comparison`` will suggest better boolean conditions for negative conditions.
+
+* ``undefined-loop-variable`` takes in consideration non-empty iterred objects before emitting.
+
+  For instance, if the loop iterable is not empty, this check will no longer be emitted.
+
+* Enum classes no longer trigger ``too-few-methods``
+
+* Special methods now count towards ``too-few-methods``,
+  and are considered part of the public API.
+  They are still not counted towards the number of methods for
+  ``too-many-methods``.
+
+* ``docparams`` extension allows abstract methods to document returns
+  documentation even if the default implementation does not return something.
+  They also no longer need to document raising a ``NotImplementedError.``
+
+* Skip wildcard import check for ``__init__.py``.
+
+* Don't warn 'useless-super-delegation' if the subclass method has different type annotations.
+
+* Don't warn that a global variable is unused if it is defined by an import
+
+  .. code-block:: python
+
+    def func():
+        global sys
+        import sys
+
+* Added basic support for postponed evaluation of function annotations.
+
+  If ``pylint`` detects the corresponding ``from __future__ import annotations`` import,
+  it will not emit ``used-before-assignment`` and ``undefined-variable`` in the cases
+  triggered by the annotations.
+
+  More details on the postponed evaluation of annotations can be read in
+  `PEP 563`_.
+
+* A new command line option was added, ``--exit-zero``, for the use of continuous integration
+  scripts which abort if a command returns a non-zero status code.  If the
+  option is specified, and Pylint runs successfully, it will exit with 0
+  regardless of the number of lint issues detected.
+
+  Configuration errors, parse errors, and calling Pylint with invalid
+  command-line options all still return a non-zero error code, even if
+  ``--exit-zero`` is specified.
+
+* Don't emit ``unused-import`` anymore for typing imports used in type comments. For instance,
+  in the following example pylint used to complain that ``Any`` and ``List`` are not used,
+  while they should be considered used by a type checker.
+
+  .. code-block:: python
+
+      from typing import Any, List
+      a = 1 # type: List[Any]
+
+* Fix false positive ``line-too-long`` for commented lines at the end of module
+
+* Fix emitting ``useless-super-delegation`` when changing the default value of keyword arguments.
+
+* Support ``typing.TYPE_CHECKING`` for *unused-import* errors
+
+  When modules are imported under ``typing.TYPE_CHECKING`` guard, ``pylint``
+  will no longer emit *unused-import*.
+
+* Fix false positive ``unused-variable`` in lambda default arguments
+
+* ``assignment-from-no-return`` considers methods as well as functions.
+
+  If you have a method that doesn't return a value, but later on you assign
+  a value to a function call to that method (so basically it will be ``None``),
+  then ``pylint`` is going to emit an ``assignment-from-no-return`` error.
+
+* A new flag was added, ``--ignore-none`` which controls the ``no-member``
+  behaviour with respect to ``None`` values.
+
+  Previously ``pylint`` was not emitting ``no-member`` if it inferred that
+  the owner of an attribute access is a ``None`` value. In some cases,
+  this might actually cause bugs, so if you want to check for ``None`` values
+  as well, pass ``--ignore-none=n`` to pylint.
+
+* Fix false-positive ``bad-continuation`` for with statements
+
+* Fix false-positive ``bad-whitespace`` message for typing annoatations
+  with ellipses in them
+
+* Fix false-positive ``undefined-variable`` for nested lambdas
+
+
+.. _PEP 563: https://www.python.org/dev/peps/pep-0563/
+.. _style guide: https://docs.python-guide.org/en/latest/writing/style/
+.. _swap values presentation: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html#swap-values
diff --git a/doc/whatsnew/2.1.rst b/doc/whatsnew/2.1.rst
new file mode 100644
index 000000000..3b49ae8f4
--- /dev/null
+++ b/doc/whatsnew/2.1.rst
@@ -0,0 +1,73 @@
+**************************
+ What's New in Pylint 2.1
+**************************
+
+:Release: 2.1
+:Date: 2018-08-01
+
+Summary -- Release highlights
+=============================
+
+* This release mostly includes fixes for bugs found after the launch of 2.0.
+
+New checkers
+============
+
+* A new check was added, ``misplaced-format-function``.
+
+  This message is emitted when pylint detects that a format function is called on non str object.
+  This can occur due to wrong placement of closing bracket, e.g
+
+  .. code-block:: python
+
+    print('value: {}').format(123) # bad
+
+    print('value: {}'.format(123)) # good
+
+
+Other Changes
+=============
+
+* ``try-except-raise`` check was demoted from an error to a warning, as part of issue #2323.
+
+* Correctly handle the new name of the Python implementation of the ``abc`` module.
+
+  In Python 3.7, the ``abc`` module has both a C implementation as well as a Python one,
+  but the Python implementation has a different file name that what ``pylint`` was expecting,
+  resulting in some checks getting confused.
+
+* 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.
+
+
+* ``invalid name`` is no longer triggered for function and attribute names longer
+  than 30 characters. The upper limit was removed completely.
+
+
+* Fix false-positive ``undefined-variable`` for self referential class name in lamdbas
+
+* ``no-else-return`` also specifies the type of the branch that is causing the error.
+
+* Fixed inconsistent behaviour for bad-continuation on first line of file.
+
+* Fixed a bug where ``pylint`` was not able to disable certain messages on the last line through
+  the global disable option.
+
+* ``pylint`` no longer emits ``useless-return`` when it finds 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.
+
+* Fixed a bug where ``pylint`` was crashing when being unable to infer the value of an argument to ``next()``
+
+
+* ``pylint`` no longer emit ``not-an-iterable`` when dealing with async iterators.
+
+* ``pylint`` gained the ability to specify a default docstring type for when the check cannot guess the type
+
+  For this we added a ``--default-docstring-type`` command line option.
diff --git a/doc/whatsnew/2.10.rst b/doc/whatsnew/2.10.rst
new file mode 100644
index 000000000..82f7950d1
--- /dev/null
+++ b/doc/whatsnew/2.10.rst
@@ -0,0 +1,136 @@
+***************************
+ What's New in Pylint 2.10
+***************************
+
+:Release: 2.10
+:Date: 2021-08-20
+
+Summary -- Release highlights
+=============================
+
+In 2.10, we added several new default check, like ``unspecified-encoding``, ``forgotten-debug-statement`` or
+``use-dict-literal``. There's also a few opinionated optional one. You can now forbid while loop or
+profess your exclusive love of ternary expressions publicly. We promise you hours of arguing fun with
+your whole team if you add those to your configuration.
+
+We've also fixed some long standing bugs, false positives, or missing options like ``ignore-signature`` that
+will now work on inner function's signatures.
+
+A new option to disable the next line, ``disable-next``, has been added. It's also possible to export
+colored diagrams, and plantuml diagram using pyreverse. ``PYLINT_HOME`` is now ``XDG_CACHE_HOME`` if not set.
+
+The performance of the similarity checker has been improved, as well as several small performance fixes.
+
+We're going to continue working on improving performance during 2.11. We're also going to finalize
+a new ``possible-forgotten-f-prefix`` check that had too much false positives at release time.
+Check the `possible-forgotten-f-prefix`_ issue if you want to provide knowledge or use case :)
+
+.. _possible-forgotten-f-prefix: https://github.com/PyCQA/pylint/pull/4787
+
+New checkers
+============
+
+* Added ``unspecified-encoding``: Emitted when open() is called without specifying an encoding
+
+  Closes #3826
+
+* Added ``use-list-literal``: Emitted when ``list()`` is called with no arguments instead of using ``[]``
+
+  Closes #4365
+
+* Added ``use-dict-literal``: Emitted when ``dict()`` is called with no arguments instead of using ``{}``
+
+  Closes #4365
+
+* Added ``forgotten-debug-statement``: Emitted when ``breakpoint``, ``pdb.set_trace`` or ``sys.breakpointhook`` calls are found
+
+  Closes #3692
+
+* Added ``use-sequence-for-iteration``: Emitted when iterating over an in-place defined ``set``.
+
+
+* Added ``format-string-without-interpolation`` checker: Emitted when formatting is applied to a string without any variables to be replaced
+
+  Closes #4042
+
+* Added ``redundant-u-string-prefix`` checker: Emitted when the u prefix is added to a string
+
+  Closes #4102
+
+Extensions
+==========
+
+* ``CodeStyleChecker``
+
+  * Limit ``consider-using-tuple`` to be emitted only for in-place defined ``lists``.
+
+  * Emit ``consider-using-tuple`` even if list contains a ``starred`` expression.
+
+* Added optional extension ``consider-ternary-expression``: Emitted whenever a variable is assigned in both branches of an if/else block.
+
+  Closes # 4366
+
+* Added optional extension ``while-used``: Emitted whenever a ``while`` loop is used.
+
+  Closes # 4367
+
+Other Changes
+=============
+
+* pyreverse now permit to produce colored generated diagram by using the ``colorized`` option.
+
+* Pyreverse - add output in PlantUML format
+
+* ``consider-using-with`` is no longer triggered if a context manager is returned from a function.
+
+* pylint does not crash with a traceback anymore when a file is problematic. It
+  creates a template text file for opening an issue on the bug tracker instead.
+  The linting can go on for other non problematic files instead of being impossible.
+
+* Pyreverse - Show class has-a relationships inferred from type-hints
+
+* Performance of the Similarity checker has been improved.
+
+* Added ``time.clock`` to deprecated functions/methods for python 3.3
+
+* Added ``ignored-parents`` option to the design checker to ignore specific
+  classes from the ``too-many-ancestors`` check (R0901).
+
+* Don't emit ``no-member`` error if guarded behind if statement.
+
+  Ref #1162
+  Closes #1990
+  Closes #4168
+
+* Fix false positives for ``superfluous-parens`` with walrus operator, ternary operator and inside list comprehension.
+
+  Closes #2818
+  Closes #3249
+  Closes #3608
+  Closes #4346
+
+* Refactor of ``--list-msgs`` & ``--list-msgs-enabled``: both options now show whether messages are emittable with the current interpreter.
+
+  Closes #4778
+
+* Fix false negative for ``used-before-assignment`` when the variable is assigned
+  in an exception handler, but used outside of the handler.
+
+  Closes #626
+
+* Added ``disable-next`` option: allows using `# pylint: disable-next=msgid` to disable a message for the following line
+
+  Closes #1682
+
+* Fixed ``cell-var-from-loop`` checker: handle cell variables in comprehensions within functions,
+  and function default argument expressions. Also handle basic variable shadowing.
+
+  Closes #2846
+  Closes #3107
+
+* Fixed bug with ``cell-var-from-loop`` checker: it no longer has false negatives when
+  both ``unused-variable`` and ``used-before-assignment`` are disabled.
+
+* Class methods' signatures are now ignored the same way as functions' with similarities "ignore-signatures" option enabled
+
+  Closes #4653
diff --git a/doc/whatsnew/2.11.rst b/doc/whatsnew/2.11.rst
new file mode 100644
index 000000000..312ec5de3
--- /dev/null
+++ b/doc/whatsnew/2.11.rst
@@ -0,0 +1,120 @@
+***************************
+ What's New in Pylint 2.11
+***************************
+
+:Release: 2.11
+:Date: 2021-09-16
+
+Summary -- Release highlights
+=============================
+
+In 2.11, we added a new default checker to advise using f-string as it's
+the most efficient way of formatting strings right now. You can use
+`pyupgrade`_ to migrate your old ``%`` and ``format()`` automatically.
+
+We added a new extension ``SetMembershipChecker`` that will advise the
+use of set for membership test, as it's more performant than lists or tuples.
+The ``CodeStyleChecker`` also got some love, check it out if you're not already
+using it.
+
+We fixed some long standing bugs, false positives, or false negatives and
+we added small quality of life options like ``min-similarity-lines`` that
+disable the duplication check when set to 0.
+
+Under the hood the code for both pylint and astroid is progressively more typed,
+which could be helpful to you if you're using them as libraries. In order for
+this new typing to make more sense and stay simple, we deprecated some functions
+or type that will be removed in the next major version. This is an ongoing effort.
+
+The future ``possible-forgotten-f-prefix`` check still had too much false positives,
+and is delayed again. Check the `possible-forgotten-f-prefix`_ issue if you want
+to provide knowledge or use case :)
+
+.. _possible-forgotten-f-prefix: https://github.com/PyCQA/pylint/pull/4787
+.. _pyupgrade: https://github.com/asottile/pyupgrade
+
+
+New checkers
+============
+
+* Added ``consider-using-f-string``: Emitted when .format() or '%' is being used to format a string.
+
+  Closes #3592
+
+Removed checkers
+================
+
+* The python3 porting mode checker and it's ``py3k`` option were removed. You can still find it in older pylint
+  versions.
+
+Extensions
+==========
+
+* Added new extension ``SetMembershipChecker`` with ``use-set-for-membership`` check:
+  Emitted when using an in-place defined ``list`` or ``tuple`` to do a membership test. ``sets`` are better optimized for that.
+
+  Closes #4776
+
+* ``CodeStyleChecker``
+
+  * Added ``consider-using-assignment-expr``: Emitted when an assignment is directly followed by an if statement
+    and both can be combined by using an assignment expression ``:=``. Requires Python 3.8
+
+    Closes #4862
+
+
+Other Changes
+=============
+
+* Added ``py-version`` config key (if ``[MASTER]`` section). Used for version dependant checks.
+  Will default to whatever Python version pylint is executed with.
+
+* The ``invalid-name`` message is now more detailed when using multiple naming style regexes.
+
+* Fix false positive for ``consider-using-with`` if a context manager is assigned to a
+  variable in different paths of control flow (e. g. if-else clause).
+
+  Closes #4751
+
+* Fix false positive for ``function-redefined`` for simple type annotations
+
+  Closes #4936
+
+* Fix false positive for ``protected-access`` if a protected member is used in type hints of function definitions
+
+* Fix false positive ``dict-iter-missing-items`` for dictionaries only using tuples as keys
+
+  Closes #3282
+
+* The ``unspecified-encoding`` checker now also checks calls to ``pathlib.Path().read_text()``
+  and ``pathlib.Path().write_text()``
+
+  Closes #4945
+
+* Fix false positive ``superfluous-parens`` for tuples created with inner tuples
+
+  Closes #4907
+
+* Fix false positive ``unused-private-member`` for accessing attributes in a class using ``cls``
+
+  Closes #4849
+
+* Extended ``consider-using-in`` check to work for attribute access.
+
+* Setting ``min-similarity-lines`` to 0 now makes the similarty checker stop checking for duplicate code
+
+  Closes #4901
+
+* Fix a bug where pylint complained if the cache's parent directory does not exist
+
+  Closes #4900
+
+* The ``global-variable-not-assigned`` checker now catches global variables that are never reassigned in a
+  local scope and catches (reassigned) functions
+
+  Closes #1375
+  Closes #330
+
+* The ``consider-iterating-dictionary`` checker now also considers membership checks
+
+  Closes #4069
diff --git a/doc/whatsnew/2.12.rst b/doc/whatsnew/2.12.rst
new file mode 100644
index 000000000..6a611eeb3
--- /dev/null
+++ b/doc/whatsnew/2.12.rst
@@ -0,0 +1,25 @@
+***************************
+ What's New in Pylint 2.12
+***************************
+
+:Release: 2.12
+:Date: TBA
+
+Summary -- Release highlights
+=============================
+
+
+New checkers
+============
+
+
+Removed checkers
+================
+
+
+Extensions
+==========
+
+
+Other Changes
+=============
diff --git a/doc/whatsnew/2.2.rst b/doc/whatsnew/2.2.rst
new file mode 100644
index 000000000..4a7478ffb
--- /dev/null
+++ b/doc/whatsnew/2.2.rst
@@ -0,0 +1,66 @@
+**************************
+ What's New in Pylint 2.2
+**************************
+
+:Release: 2.2
+:Date: 2018-11-25
+
+Summary -- Release highlights
+=============================
+
+
+New checkers
+============
+
+* String checker now reports format string type mismatches.
+
+* ``duplicate-string-formatting-argument`` was added for detecting duplicate string
+  formatting arguments that should be passed instead as named arguments.
+
+* ``logging-format-style`` is a new option for the logging checker for usage of
+  str.format() style format strings in calls to loggers.
+
+  It accepts two options: ``--logging-format-style=old`` for using `%` style formatting,
+  which is the assumed default, and ``--logging-format-style=new`` for using `{}` style formatting.
+
+* ``implicit-str-concat-in-sequence`` detects string concatenation inside lists, sets & tuples.
+
+  Example of code that would generate such warning:
+
+  .. code-block:: python
+
+    woops = ('a', 'b' 'c')
+
+
+Other Changes
+=============
+
+* ``try-except-raise`` checker now handles multilevel inheritance hirerachy for exceptions correctly.
+
+  Close #2484
+
+* Ignore import x.y.z as z cases for checker ``useless-import-alias``.
+
+* ``unnecessary-pass`` is now also emitted when a function or class contains only docstring and pass statement,
+  in which case, docstring is enough for empty definition.
+
+* Fix false positive ``undefined-variable`` and ``used-before-assignment`` with nonlocal keyword usage.
+
+* Fix exceptions being raised when one of the params is not a ClassDef for :func:`checkers.utils.is_subclass_of`.
+
+* ``pylint`` now picks the latest value from the inferred values of the exception that gets
+  raised, when looking for ``raising-non-exception``. This helps when reusing a variable name
+  for multiple types, since ``pylint`` was picking just the first inferred value, leading
+  to spurious false positives.
+
+  Close #2431
+
+* ``pylint`` used to emit a ``not-an-iterable`` error when looking at coroutines built
+  with ``asyncio.coroutine``. This is no longer the case as we handle coroutines explicitly.
+
+  Close #996
+
+* ``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
diff --git a/doc/whatsnew/2.3.rst b/doc/whatsnew/2.3.rst
new file mode 100644
index 000000000..94921887d
--- /dev/null
+++ b/doc/whatsnew/2.3.rst
@@ -0,0 +1,66 @@
+**************************
+ What's New in Pylint 2.3
+**************************
+
+:Release: 2.3
+:Date: 2019-02-27
+
+
+Summary -- Release highlights
+=============================
+
+* This release improves the performance of the 2.X series after it was affected by a performance regression a couple of releases ago.
+
+New checkers
+============
+
+* We added a new check message ``wrong-exception-operation``.
+  This is emitted 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.
+
+  Closes #2494
+
+* We added a new ``no-else-raise`` warning similar to ``no-else-return``
+
+  Closes #2558
+
+* We added a new option ``check-str-concat-over-line-jumps`` to check
+  ``implicit-str-concat-in-sequence`` over multiple lines.
+
+
+Other Changes
+=============
+
+Quite a lot of bug fixes and improvements went into this release, here's a handful of them.
+For the full changes, check the Changelog.
+
+* We no longer emit ``*-not-iterating`` checks for builtins consumed by ``itertools``
+
+* We fixed some false positives for ``no-self-argument`` and ``unsubscriptable-object``
+  when using ``__class_getitem__`` (new in Python 3.7)
+
+* ``pylint`` now supports ``Ellipsis`` as a synonym for ``pass`` statements.
+
+* ``fixme`` gets triggered only on comments.
+
+* ``pylint`` exempts starred unpacking from ``*-not-iterating`` Python 3 checks.
+
+* ``compare-to-zero`` is now less zealous by checking against equality and identity.
+
+*``yield from`` is exempted from ``*-not-iterating`` Python 3 checks.
+
+* A false positive with ``not-async-context-manager`` caused by not understanding
+  ``contextlib.asynccontextmanager`` was fixed.
+
+* We refactored ``bad-reversed-sequence`` to account for more objects that can define ``__reversed__``.
+
+* ``no-member`` is now emitted for enums when they lack a member.
+
+* Plugins can now use the ``load_configuration()`` hook.
+  This hook is executed after configuration is loaded to prevent overwriting plugin
+  specific configuration via user-based configuration.
+
+* There's a new command line option ``list-groups`` for listing all the check groups
+  ``pylint`` knows about. This is useful to know what groups you can disable or enable
+  individually.
diff --git a/doc/whatsnew/2.4.rst b/doc/whatsnew/2.4.rst
new file mode 100644
index 000000000..d88dd5552
--- /dev/null
+++ b/doc/whatsnew/2.4.rst
@@ -0,0 +1,222 @@
+**************************
+ What's New in Pylint 2.4
+**************************
+
+:Release: 2.4
+:Date: 2019-09-24
+
+
+Summary -- Release highlights
+=============================
+
+
+New checkers
+============
+
+* ``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.
+
+* 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
+
+* 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 new checks, ``no-else-break`` and ``no-else-continue``
+
+  These checks highlight unnecessary ``else`` and ``elif`` blocks after
+  ``break`` and ``continue`` statements.
+
+  Close #2327
+
+* Added ``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
+
+* 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, ``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
+
+* 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.
+
+  For example, the following would raise this warning::
+
+    def new_a(attr, attr2):
+      a_inst = Aclass()
+      a_inst.attr2 = attr2
+      # should be: a_inst.attr = attr, but have a typo
+      attr = attr
+      return a_inst
+
+  Close #2930
+
+* Added a new check ``property-with-parameters`` which detects when a property
+  has more than a single argument.
+
+  Close #3006
+
+* Added ``subprocess-run-check`` to handle subprocess.run without explicitly set ``check`` keyword.
+
+  Close #2848
+
+* We added a new check message ``dict-iter-missing-items``.
+  This is emitted when trying to iterate through a dict in a for loop without calling its .items() method.
+
+  Closes #2761
+
+* We added a new check message ``missing-parentheses-for-call-in-test``.
+  This is emitted in case a call to a function is made inside a test but
+  it misses parentheses.
+
+* A new check ``class-variable-slots-conflict`` was added.
+
+  This check is emitted when ``pylint`` finds a class variable that conflicts with a slot
+  name, which would raise a ``ValueError`` at runtime.
+
+  For example, the following would raise an error::
+
+    class A:
+        __slots__ = ('first', 'second')
+        first = 1
+
+* A new check ``preferred-module`` was added.
+
+  This check is emitted when ``pylint`` finds an imported module that has a
+  preferred replacement listed in ``preferred-modules``.
+
+  For example, you can set the preferred modules as ``xml:defusedxml,json:ujson``
+  to make ``pylint`` suggest using ``defusedxml`` instead of ``xml``
+  and ``ujson`` rather than ``json``.
+
+* A new extension ``broad_try_clause`` was added.
+
+  This extension enforces a configurable maximum number of statements inside
+  of a try clause. This facilitates enforcing PEP 8's guidelines about try / except
+  statements and the amount of code in the try clause.
+
+  You can enable this extension using ``--load-plugins=pylint.extensions.broad_try_clause``
+  and you can configure the amount of statements in a try statement using
+  ``--max-try-statements``.
+
+
+Other Changes
+=============
+
+* Don't emit ``protected-access`` when a single underscore prefixed attribute is used
+  inside a special method
+
+  Close #1802
+
+* ``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.
+
+  OK::
+
+    if len(x) == 0:
+      pass
+
+    while not len(x) == 0:
+      pass
+
+    assert len(x) > 5, message
+
+  KO::
+
+    if not len(x):
+      pass
+
+    while len(x) and other_cond:
+      pass
+
+    assert len(x), message
+
+* A file is now read from stdin if the ``--from-stdin`` flag is used on the
+  command line. In addition to the ``--from-stdin`` flag a (single) file
+  name needs to be specified on the command line, which is needed for the
+  report.
+
+* The checker for ungrouped imports is now more permissive.
+
+The import can now be sorted alphabetically by import style.
+This makes pylint compatible with isort.
+
+The following imports do not trigger an ``ungrouped-imports`` anymore ::
+
+    import unittest
+    import zipfile
+    from unittest import TestCase
+    from unittest.mock import MagicMock
+
+* The checker for missing return documentation is now more flexible.
+
+The following does not trigger a ``missing-return-doc`` anymore ::
+
+    def my_func(self):
+        """This is a docstring.
+
+        Returns
+        -------
+        :obj:`list` of :obj:`str`
+            List of strings
+        """
+        return ["hi", "bye"] #@
+
+* ``signature-mutators`` CLI and config 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.
+
+For example a test may want to make use of hypothesis.
+Adding ``hypothesis.extra.numpy.arrays`` to ``signature_mutators``
+would mean that ``no-value-for-parameter`` would not be raised for::
+
+    @given(img=arrays(dtype=np.float32, shape=(3, 3, 3, 3)))
+    def test_image(img):
+        ...
+
+* Allow the option of f-strings as a valid logging string formatting method.
+
+``logging-fstring--interpolation`` has been merged into
+``logging-format-interpolation`` to allow the ``logging-format-style`` option
+to control which logging string format style is valid.
+To allow this, a new ``fstr`` value is valid for the ``logging-format-style``
+option.
+
+* ``--list-msgs-enabled`` command was added.
+
+When enabling/disabling several messages and groups in a config file,
+it can be unclear which messages are actually enabled and which are disabled.
+This new command produces the final resolved lists of enabled/disabled messages,
+sorted by symbol but with the ID provided for use with ``--help-msg``.
diff --git a/doc/whatsnew/2.5.rst b/doc/whatsnew/2.5.rst
new file mode 100644
index 000000000..f926f5940
--- /dev/null
+++ b/doc/whatsnew/2.5.rst
@@ -0,0 +1,102 @@
+**************************
+ What's New in Pylint 2.5
+**************************
+
+:Release: 2.5
+:Date: 2020-04-27
+
+
+Summary -- Release highlights
+=============================
+
+
+New checkers
+============
+
+* A new check ``isinstance-second-argument-not-valid-type`` was added.
+
+   This check is emitted whenever **pylint** finds a call to the ``isinstance``
+   function with a second argument that is not a type. Such code is likely
+   unintended as it will cause a TypeError to be thrown at runtime error.
+
+* A new check ``assert-on-string-literal`` was added.
+
+   This check is emitted whenever **pylint** finds an assert statement
+   with a string literal as its first argument. Such assert statements
+   are probably unintended as they will always pass.
+
+* A new check ``f-string-without-interpolation`` was added.
+
+   This check is emitted whenever **pylint** detects the use of an
+   f-string without having any interpolated values in it, which means
+   that the f-string can be a normal string.
+
+* Multiple checks for invalid return types of protocol functions were added:
+
+   * ``invalid-bool-returned``: ``__bool__`` did not return a bool
+   * ``invalid-index-returned``: ``__index__`` did not return an integer
+   * ``invalid-repr-returned)``: ``__repr__`` did not return a string
+   * ``invalid-str-returned)``: ``__str__`` did not return a string
+   * ``invalid-bytes-returned)``: ``__bytes__`` did not return a string
+   * ``invalid-hash-returned)``: ``__hash__`` did not return an integer
+   * ``invalid-length-hint-returned)``: ``__length_hint__`` did not return a non-negative integer
+   * ``invalid-format-returned)``: ``__format__`` did not return a string
+   * ``invalid-getnewargs-returned)``: ``__getnewargs__`` did not return a tuple
+   * ``invalid-getnewargs-ex-returned)``: ``__getnewargs_ex__`` did not return a tuple of the form (tuple, dict)
+
+* A new check ``inconsistent-quotes`` was added.
+
+   This check is emitted when quotes delimiters (``"`` and ``'``) are not used
+   consistently throughout a module.  It allows avoiding unnecessary escaping,
+   allowing, for example, ``"Don't error"`` in a module in which single-quotes
+   otherwise delimit strings so that the single quote in ``Don't`` doesn't need to be escaped.
+
+* A new check ``non-str-assignment-to-dunder-name`` was added to ensure that only strings are assigned to ``__name__`` attributes.
+
+
+Other Changes
+=============
+
+* Configuration can be read from a setup.cfg or pyproject.toml file in the current directory.
+  A setup.cfg must prepend pylintrc section names with ``pylint.``, for example ``[pylint.MESSAGES CONTROL]``.
+  A pyproject.toml file must prepend section names with ``tool.pylint.``, for example ``[tool.pylint.'MESSAGES CONTROL']``.
+  These files can also be passed in on the command line.
+
+* Add new ``good-names-rgx`` and ``bad-names-rgx`` to enable permitting or disallowing of names via regular expressions
+
+  To enable better handling of permitted/disallowed names, we added two new config options: good-names-rgxs: a comma-
+  separated list of regexes, that if a name matches will be exempt of naming-checking. bad-names-rgxs: a comma-
+  separated list of regexes, that if a name matches will be always marked as a disallowed name.
+
+* Mutable ``collections.*`` are now flagged as dangerous defaults.
+
+* Add new ``--fail-under`` flag for setting the threshold for the score to fail overall tests. If the score is over the fail-under threshold, pylint will complete SystemExit with value 0 to indicate no errors.
+
+* Added a new option ``notes-rgx`` to make fixme warnings more flexible. Now either ``notes`` or ``notes-rgx`` option can be used to detect fixme warnings.
+
+* Non-ASCII characters are now allowed by ``invalid-name``.
+
+* ``pylint`` no longer emits ``invalid-name`` for non-constants found at module level.
+
+  Pylint was considering all module level variables as constants, which is not what PEP 8 is actually mandating.
+
+* A new check ``non-ascii-name`` was added to detect identifiers with non-ASCII characters.
+
+* Overloaded typing functions no longer trigger ``no-self-use``, ``unused-argument``, ``missing-docstring`` and similar checks
+  that assumed that overloaded functions are normal functions.
+
+* ``python -m pylint`` can no longer be made to import files from the local directory.
+
+* A new command ``--list-extensions`` was added.
+
+  This command lists all extensions present in ``pylint.extensions``.
+
+* Various false positives have been fixed which you can read more about in the Changelog files.
+
+* 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.
+The type of formatting to use is chosen through enabling and disabling messages
+rather than through the logging-format-style option.
+The fstr value of the logging-format-style option is not valid.
diff --git a/doc/whatsnew/2.6.rst b/doc/whatsnew/2.6.rst
new file mode 100644
index 000000000..34c4124aa
--- /dev/null
+++ b/doc/whatsnew/2.6.rst
@@ -0,0 +1,34 @@
+**************************
+ What's New in Pylint 2.6
+**************************
+
+:Release: 2.6
+:Date: 2020-08-20
+
+Summary -- Release highlights
+=============================
+
+* ``bad-continuation`` and ``bad-whitespace`` have been removed. ``black`` or another formatter can help you with this better than Pylint
+* Added support for isort 5
+
+New checkers
+============
+
+* Add ``super-with-arguments`` check for flagging instances of Python 2 style super calls.
+
+* Add ``raise-missing-from`` check for exceptions that should have a cause.
+
+Other Changes
+=============
+
+* ``bad-continuation`` and ``bad-whitespace`` have been removed. ``black`` or another formatter can help you with this better than Pylint
+
+* 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.
+
+* ``mixed-indentation`` has been removed, it is no longer useful since TabError is included directly in python3
+
+* Fix superfluous-parens false-positive for the walrus operator
+
+* Add support for 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.
+
+.. _the migration guide in isort documentation: https://timothycrosley.github.io/isort/docs/upgrade_guides/5.0.0/#known_standard_library
diff --git a/doc/whatsnew/2.7.rst b/doc/whatsnew/2.7.rst
new file mode 100644
index 000000000..35bdb9348
--- /dev/null
+++ b/doc/whatsnew/2.7.rst
@@ -0,0 +1,60 @@
+**************************
+ What's New in Pylint 2.7
+**************************
+
+:Release: 2.7
+:Date: 2021-02-21
+
+Summary -- Release highlights
+=============================
+
+* Python 3.6+ is now required.
+* No more duplicate messages when using multiple jobs.
+* Handling of the new typing provided by mypy 0.8
+* Reduced the number of false positives in general
+* Reduced the occurrence of genuinely large recursion that went above system limit (See #3836, for a fix for pandas)
+
+New checkers
+============
+
+* Add ``nan-comparison`` check for comparison of NaN values
+
+* Add support to ``ignored-argument-names`` in DocstringParameterChecker and
+  adds ``useless-param-doc`` and ``useless-type-doc`` messages.
+
+* Add ``empty-comment`` check for empty comments.
+
+* 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.
+
+* Add ``consider-using-generator`` check for the use of list comprehension inside ``any`` or ``all`` function.
+
+Other Changes
+=============
+
+* Fix false positive for ``builtin-not-iterating`` when ``zip`` or ``map`` receives iterable
+
+* Fix linter multiprocessing pool shutdown which triggered warnings when runned in parallels with other pytest plugins.
+
+* Enums are now required to be named in UPPER_CASE by ``invalid-name``.
+
+* Fix bug that lead to duplicate messages when using ``--jobs 2`` or more.
+
+* 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.
+
+* ``inconsistent-return-statements`` message is now emitted if one of ``try/except`` statement
+  is not returning explicitly while the other do.
+
+* Fix false positive message ``useless-super-delegation`` when default keyword argument is a dictionary.
+
+* Fix vulnerable regular expressions in ``pyreverse``. The ambiguities of vulnerable regular expressions are removed, making the repaired regular expressions safer and faster matching.
+
+* ``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 positive for other classes, like pandas's DataFrame or numpy's Array.
+
+* Fixes duplicate code detection for --jobs=2+
+
+* New option ``allowed-redefined-builtins`` defines variable names allowed to shadow builtins.
+
+* Improved protected access checks to allow access inside class methods
diff --git a/doc/whatsnew/2.8.rst b/doc/whatsnew/2.8.rst
new file mode 100644
index 000000000..0344e981c
--- /dev/null
+++ b/doc/whatsnew/2.8.rst
@@ -0,0 +1,60 @@
+**************************
+ What's New in Pylint 2.8
+**************************
+
+:Release: 2.8
+:Date: 2021-04-24
+
+Summary -- Release highlights
+=============================
+
+Breaking changes
+================
+
+* The 'doc' extra-require has been removed. `__pkginfo__`` does not contain the package metadata anymore
+  (except ``numversion``, until 3.0). Meta-information are accessible with
+
+```python
+from importlib import metadata
+metadata.metadata('pylint')
+```
+Prefer that to an import from ``__pkginfo__``.
+
+New checkers
+============
+
+* 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.
+
+* Add ``deprecated-argument`` check for deprecated arguments.
+
+* 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.
+
+* Add ``consider-using-min-max-builtin`` check for if statement which could be replaced by Python builtin min or max.
+
+* 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!
+
+* Add ``deprecated-class`` check for deprecated classes.
+
+Other Changes
+=============
+
+* New option ``--output=<file>`` to output result to a file rather than printing to stdout.
+
+  Closes #1070
+
+* 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.
+
+* 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%.
+
+* Updated ``astroid`` to 2.5.4
+
+* COPYING has been renamed to LICENSE for standardization.
diff --git a/doc/whatsnew/2.9.rst b/doc/whatsnew/2.9.rst
new file mode 100644
index 000000000..0c3b41577
--- /dev/null
+++ b/doc/whatsnew/2.9.rst
@@ -0,0 +1,106 @@
+**************************
+ What's New in Pylint 2.9
+**************************
+
+:Release: 2.9
+:Date: 2021-06-29
+
+Summary -- Release highlights
+=============================
+
+Pylint is now compatible with python 3.10.
+
+A lot of new checks have been added, some non-opinionated performance warnings
+like ``use-maxsplit-arg``, some consensual style warnings like
+``unnecessary-dict-index-lookup`` or new deprecation checks.
+
+We're aiming to reduce pylint noise for first time users and making some
+new checks optional is a step in that direction. In order to do that we
+created an optional code style checker that can be loaded using
+``pylint.extensions.code_style`` with the ``load-plugins`` options.
+More than ever, if as a veteran you want the most checks you can possibly get,
+`you should check the list of pylint extensions. <http://pylint.pycqa.org/en/latest/technical_reference/extensions.html#optional-pylint-checkers-in-the-extensions-module>`_.
+
+
+New checkers
+============
+
+* ``deprecated-decorator``: Emitted when deprecated decorator is used.
+
+* ``consider-using-dict-items``: Emitted when iterating over dictionary keys and then
+  indexing the same dictionary with the key within loop body.
+
+* ``use-maxsplit-arg``: Emitted either when accessing only the first or last
+  element of ``str.split()``.
+
+* An ``ignore_signatures`` option has been added to the similarity checker. It will permits  to reduce false positives when multiple functions have the same parameters.
+
+* ``unnecessary-dict-index-lookup``: Emitted when iterating over dictionary items
+  (key-value pairs) and accessing the value by index lookup.
+
+* ``consider-using-from-import``: Emitted when a submodule/member of a package is imported and aliased with the same name.
+
+* New checker ``unused-private-member``: Emitted when a private member (i.e., starts with ``__``) of a class is defined but not used.
+
+* New checker ``invalid-class-object``: Emitted when a non-class is assigned to a ``__class__`` attribute.
+
+* ``invalid-all-format``: Emitted when ``__all__`` has an invalid format,
+  i.e. isn't a ``tuple`` or ``list``.
+
+* New checker ``await-outside-async``: Emitted when await is used outside an async function.
+
+* 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.
+
+  * ``consider-using-tuple``: Emitted when an in-place defined list or set can be replaced by a tuple.
+
+  * ``consider-using-namedtuple-or-dataclass``: Emitted when dictionary values
+    can be replaced by namedtuples or dataclass instances.
+
+
+Other Changes
+=============
+
+* Fix false-positive ``consider-using-with`` (R1732) if a ternary conditional is used together with ``with``
+
+* Fix false-positive ``consider-using-with`` (R1732) if ``contextlib.ExitStack`` takes care of calling the ``__exit__`` method
+
+* Add type annotations to pyreverse dot files
+
+* Pylint's tags are now the standard form ``vX.Y.Z`` and not ``pylint-X.Y.Z`` anymore.
+
+* Fix false-positive ``too-many-ancestors`` when inheriting from builtin classes,
+  especially from the ``collections.abc`` module
+
+* The output messages for ``arguments-differ`` error message have been customized based on the different error cases.
+
+* New option ``--fail-on=<msg ids>`` to return non-zero exit codes regardless of ``fail-under`` value.
+
+* A new error called ``arguments-renamed`` has been created, which identifies any changes at the parameter names
+  of overridden functions. It aims to separate the functionality of ``arguments-differ``.
+
+* Fix incompatibility with Python 3.6.0 caused by ``typing.Counter`` and ``typing.NoReturn`` usage
+
+* Allow comma-separated list in ``output-format`` and separate output files for
+  each specified format.  Each output file can be defined after a semicolon for example : ``--output-format=json:myfile.json,colorized``
+
+* The ``using-constant-test`` checker now detects constant tests consisting of list literals
+  like ``[]`` and ``[1, 2, 3]``.
+
+* ``ignore-paths`` configuration directive has been added. Defined regex patterns are matched against file path.
+
+* Added handling of floating point values when parsing configuration from pyproject.toml
+
+* Fix false positive ``useless-type-doc`` on ignored argument using ``pylint.extensions.docparams`` when a function
+  was typed using pep484 but not inside the docstring.
+
+* Fix missing support for detecting deprecated aliases to existing functions/methods.
+  functions/methods.
+
+* Added various deprecated functions/methods for python 3.10, 3.7, 3.6 and 3.3
+
+* No longer emit ``consider-using-with`` for ``ThreadPoolExecutor`` and ``ProcessPoolExecutor``
+  as they have legitimate use cases without a ``with`` block.
+
+* Fix crash if a callable returning a context manager was assigned to a list or dict item
diff --git a/doc/whatsnew/changelog.rst b/doc/whatsnew/changelog.rst
new file mode 100644
index 000000000..69ed4fe6c
--- /dev/null
+++ b/doc/whatsnew/changelog.rst
@@ -0,0 +1 @@
+.. include:: ../../ChangeLog
diff --git a/doc/whatsnew/index.rst b/doc/whatsnew/index.rst
new file mode 100644
index 000000000..68d9226b8
--- /dev/null
+++ b/doc/whatsnew/index.rst
@@ -0,0 +1,35 @@
+.. _whatsnew-index:
+
+######################
+ What's New in Pylint
+######################
+
+High level descriptions of the most important changes between major Pylint versions.
+
+.. toctree::
+   :maxdepth: 1
+
+   2.12.rst
+   2.11.rst
+   2.10.rst
+   2.9.rst
+   2.8.rst
+   2.7.rst
+   2.6.rst
+   2.5.rst
+   2.4.rst
+   2.3.rst
+   2.2.rst
+   2.1.rst
+   2.0.rst
+   1.9.rst
+   1.8.rst
+   1.7.rst
+   1.6.rst
+
+The "Changelog" contains *all* nontrivial changes to Pylint for the current version.
+
+.. toctree::
+   :maxdepth: 2
+
+   changelog.rst
diff --git a/elisp/pylint-flymake.el b/elisp/pylint-flymake.el
new file mode 100644
index 000000000..6313ba545
--- /dev/null
+++ b/elisp/pylint-flymake.el
@@ -0,0 +1,15 @@
+;; Configure flymake for python
+(when (load "flymake" t)
+  (defun flymake-pylint-init ()
+    (let* ((temp-file (flymake-init-create-temp-buffer-copy
+                       'flymake-create-temp-inplace))
+           (local-file (file-relative-name
+                        temp-file
+                        (file-name-directory buffer-file-name))))
+      (list "epylint" (list local-file))))
+
+  (add-to-list 'flymake-allowed-file-name-masks
+               '("\\.py\\'" flymake-pylint-init)))
+
+;; Set as a minor mode for python
+(add-hook 'python-mode-hook '(lambda () (flymake-mode)))
diff --git a/elisp/pylint.el b/elisp/pylint.el
new file mode 100644
index 000000000..327da0fcb
--- /dev/null
+++ b/elisp/pylint.el
@@ -0,0 +1,255 @@
+;;; pylint.el --- minor mode for running `pylint'
+
+;; Copyright (c) 2009, 2010 Ian Eure <ian.eure@gmail.com>
+;; Author: Ian Eure <ian.eure@gmail.com>
+;; Maintainer: Jonathan Kotta <jpkotta@gmail.com>
+
+;; Keywords: languages python
+;; Version: 1.02
+
+;; pylint.el 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, or (at your option) any later
+;; version.
+;;
+;; It 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 your copy of Emacs; see the file COPYING.  If not, write to the Free
+;; Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+;; MA 02110-1301, USA
+
+;;; Commentary:
+;;
+;; Specialized compile mode for pylint.  You may want to add the
+;; following to your init.el:
+;;
+;;   (autoload 'pylint "pylint")
+;;   (add-hook 'python-mode-hook 'pylint-add-menu-items)
+;;   (add-hook 'python-mode-hook 'pylint-add-key-bindings)
+;;
+;; There is also a handy command `pylint-insert-ignore-comment' that
+;; makes it easy to insert comments of the form `# pylint:
+;; ignore=msg1,msg2,...'.
+
+;;; Code:
+
+(require 'compile)
+(require 'tramp)
+
+(defgroup pylint nil
+  "Minor mode for running the Pylint Python checker"
+  :prefix "pylint-"
+  :group 'tools
+  :group 'languages)
+
+(defvar pylint-last-buffer nil
+  "The most recent PYLINT buffer.
+A PYLINT buffer becomes most recent when you select PYLINT mode in it.
+Notice that using \\[next-error] or \\[compile-goto-error] modifies
+`completion-last-buffer' rather than `pylint-last-buffer'.")
+
+(defconst pylint-regexp-alist
+  (let ((base "^\\(.*\\):\\([0-9]+\\):\s+\\(\\[%s.*\\)$"))
+    (list
+     (list (format base "[FE]") 1 2)
+     (list (format base "[RWC]") 1 2 nil 1)))
+  "Regexp used to match PYLINT hits.  See `compilation-error-regexp-alist'.")
+
+(defcustom pylint-options '("--reports=n" "--output-format=parseable")
+  "Options to pass to pylint.py"
+  :type '(repeat string)
+  :group 'pylint)
+
+(defcustom pylint-use-python-indent-offset nil
+  "If non-nil, use `python-indent-offset' to set indent-string."
+  :type 'boolean
+  :group 'pylint)
+
+(defcustom pylint-command "pylint"
+  "PYLINT command."
+  :type '(file)
+  :group 'pylint)
+
+(defcustom pylint-alternate-pylint-command "pylint2"
+  "Command for pylint when invoked with C-u."
+  :type '(file)
+  :group 'pylint)
+
+(defcustom pylint-ask-about-save nil
+  "Non-nil means \\[pylint] asks which buffers to save before compiling.
+Otherwise, it saves all modified buffers without asking."
+  :type 'boolean
+  :group 'pylint)
+
+(defvar pylint--messages-list ()
+  "A list of strings of all pylint messages.")
+
+(defvar pylint--messages-list-hist ()
+  "Completion history for `pylint--messages-list'.")
+
+(defun pylint--sort-messages (a b)
+  "Compare function for sorting `pylint--messages-list'.
+
+Sorts most recently used elements first using `pylint--messages-list-hist'."
+  (let ((idx 0)
+        (a-idx most-positive-fixnum)
+        (b-idx most-positive-fixnum))
+    (dolist (e pylint--messages-list-hist)
+      (when (string= e a)
+        (setq a-idx idx))
+      (when (string= e b)
+        (setq b-idx idx))
+      (setq idx (1+ idx)))
+    (< a-idx b-idx)))
+
+(defun pylint--create-messages-list ()
+  "Use `pylint-command' to populate `pylint--messages-list'."
+  ;; example output:
+  ;;  |--we want this--|
+  ;;  v                v
+  ;; :using-cmp-argument (W1640): *Using the cmp argument for list.sort / sorted*
+  ;;   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. This message can't be emitted when using Python >= 3.0.
+  (setq pylint--messages-list
+        (split-string
+         (with-temp-buffer
+           (shell-command (concat pylint-command " --list-msgs") (current-buffer))
+           (flush-lines "^[^:]")
+           (goto-char (point-min))
+           (while (not (eobp))
+             (delete-char 1) ;; delete ";"
+             (re-search-forward " ")
+             (delete-region (point) (line-end-position))
+             (forward-line 1))
+           (buffer-substring-no-properties (point-min) (point-max))))))
+
+;;;###autoload
+(defun pylint-insert-ignore-comment (&optional arg)
+  "Insert a comment like \"# pylint: disable=msg1,msg2,...\".
+
+This command repeatedly uses `completing-read' to match known
+messages, and ultimately inserts a comma-separated list of all
+the selected messages.
+
+With prefix argument, only insert a comma-separated list (for
+appending to an existing list)."
+  (interactive "*P")
+  (unless pylint--messages-list
+    (pylint--create-messages-list))
+  (setq pylint--messages-list
+        (sort pylint--messages-list #'pylint--sort-messages))
+  (let ((msgs ())
+        (msg "")
+        (prefix (if arg
+                    ","
+                  "# pylint: disable="))
+        (sentinel "[DONE]"))
+    (while (progn
+             (setq msg (completing-read
+                        "Message: "
+                        pylint--messages-list
+                        nil t nil 'pylint--messages-list-hist sentinel))
+             (unless (string= sentinel msg)
+               (add-to-list 'msgs msg 'append))))
+    (setq pylint--messages-list-hist
+          (delete sentinel pylint--messages-list-hist))
+    (insert prefix (mapconcat 'identity msgs ","))))
+
+(define-compilation-mode pylint-mode "PYLINT"
+  (setq pylint-last-buffer (current-buffer))
+  (set (make-local-variable 'compilation-error-regexp-alist)
+       pylint-regexp-alist)
+  (set (make-local-variable 'compilation-disable-input) t))
+
+(defvar pylint-mode-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map compilation-minor-mode-map)
+    (define-key map " " 'scroll-up)
+    (define-key map "\^?" 'scroll-down)
+    (define-key map "\C-c\C-f" 'next-error-follow-minor-mode)
+
+    (define-key map "\r" 'compile-goto-error)  ;; ?
+    (define-key map "n" 'next-error-no-select)
+    (define-key map "p" 'previous-error-no-select)
+    (define-key map "{" 'compilation-previous-file)
+    (define-key map "}" 'compilation-next-file)
+    (define-key map "\t" 'compilation-next-error)
+    (define-key map [backtab] 'compilation-previous-error)
+    map)
+  "Keymap for PYLINT buffers.
+`compilation-minor-mode-map' is a cdr of this.")
+
+(defun pylint--make-indent-string ()
+  "Make a string for the `--indent-string' option."
+  (format "--indent-string='%s'"
+          (make-string python-indent-offset ?\ )))
+
+;;;###autoload
+(defun pylint (&optional arg)
+  "Run PYLINT, and collect output in a buffer, much like `compile'.
+
+While pylint runs asynchronously, you can use \\[next-error] (M-x next-error),
+or \\<pylint-mode-map>\\[compile-goto-error] in the grep \
+output buffer, to go to the lines where pylint found matches.
+
+\\{pylint-mode-map}"
+  (interactive "P")
+
+  (save-some-buffers (not pylint-ask-about-save) nil)
+  (let* ((filename (buffer-file-name))
+         (localname-offset (cl-struct-slot-offset 'tramp-file-name 'localname))
+         (filename (or (and (tramp-tramp-file-p filename)
+                         (elt (tramp-dissect-file-name filename) localname-offset))
+                      filename))
+         (filename (shell-quote-argument filename))
+         (pylint-command (if arg
+                             pylint-alternate-pylint-command
+                           pylint-command))
+         (pylint-options (if (not pylint-use-python-indent-offset)
+                             pylint-options
+                           (append pylint-options
+                                   (list (pylint--make-indent-string)))))
+         (command (mapconcat
+                   'identity
+                   (append `(,pylint-command) pylint-options `(,filename))
+                   " ")))
+
+    (compilation-start command 'pylint-mode)))
+
+;;;###autoload
+(defun pylint-add-key-bindings ()
+  (let ((map (cond
+              ((boundp 'py-mode-map) py-mode-map)
+              ((boundp 'python-mode-map) python-mode-map))))
+
+    ;; shortcuts in the tradition of python-mode and ropemacs
+    (define-key map (kbd "C-c m l") 'pylint)
+    (define-key map (kbd "C-c m p") 'previous-error)
+    (define-key map (kbd "C-c m n") 'next-error)
+    (define-key map (kbd "C-c m i") 'pylint-insert-ignore-comment)
+    nil))
+
+;;;###autoload
+(defun pylint-add-menu-items ()
+  (let ((map (cond
+              ((boundp 'py-mode-map) py-mode-map)
+              ((boundp 'python-mode-map) python-mode-map))))
+
+    (define-key map [menu-bar Python pylint-separator]
+      '("--" . pylint-separator))
+    (define-key map [menu-bar Python next-error]
+      '("Next error" . next-error))
+    (define-key map [menu-bar Python prev-error]
+      '("Previous error" . previous-error))
+    (define-key map [menu-bar Python lint]
+      '("Pylint" . pylint))
+    nil))
+
+(provide 'pylint)
+
+;;; pylint.el ends here
diff --git a/elisp/startup b/elisp/startup
new file mode 100644
index 000000000..fd40b427e
--- /dev/null
+++ b/elisp/startup
@@ -0,0 +1,17 @@
+;; -*-emacs-lisp-*-
+;;
+;; Emacs startup file for the Debian GNU/Linux %PACKAGE% package
+;;
+;; Originally contributed by Nils Naumann <naumann@unileoben.ac.at>
+;; Modified by Dirk Eddelbuettel <edd@debian.org>
+;; Adapted for dh-make by Jim Van Zandt <jrv@vanzandt.mv.com>
+
+;; The %PACKAGE% package follows the Debian/GNU Linux 'emacsen' policy and
+;; byte-compiles its elisp files for each 'emacs flavor' (emacs19,
+;; xemacs19, emacs20, xemacs20...).  The compiled code is then
+;; installed in a subdirectory of the respective site-lisp directory.
+;; We have to add this to the load-path:
+(setq load-path (cons (concat "/usr/share/"
+                              (symbol-name debian-emacs-flavor)
+                              "/site-lisp/%PACKAGE%") load-path))
+(load-library "pylint")
diff --git a/examples/custom.py b/examples/custom.py
new file mode 100644
index 000000000..bd9797e2a
--- /dev/null
+++ b/examples/custom.py
@@ -0,0 +1,73 @@
+from astroid import nodes
+
+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: nodes.Call) -> None:
+        """Called when a :class:`.nodes.Call` node is visited.
+
+        See :mod:`astroid` for the description of available nodes.
+
+        :param node: The node to check.
+        """
+        if not (
+            isinstance(node.func, nodes.Attribute)
+            and isinstance(node.func.expr, nodes.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 000000000..5f747869f
--- /dev/null
+++ b/examples/custom_raw.py
@@ -0,0 +1,40 @@
+from astroid import nodes
+
+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: nodes.Module) -> None:
+        """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 000000000..93910b724
--- /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 000000000..0bfe95939
--- /dev/null
+++ b/examples/pylintrc
@@ -0,0 +1,533 @@
+[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=
+
+# Add files or directories matching the regex patterns to the ignore-list.
+# The regex matches against paths.
+ignore-paths=
+
+# 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=raw-checker-failed,
+        bad-inline-option,
+        locally-disabled,
+        file-ignored,
+        suppressed-message,
+        useless-suppression,
+        deprecated-pragma,
+        use-symbolic-message-instead,
+
+# 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 000000000..d5cdaa967
--- /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 000000000..ddf794f86
--- /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/main/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", "modify_sys_path"]
diff --git a/pylint/__main__.py b/pylint/__main__.py
new file mode 100644
index 000000000..278570f61
--- /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/main/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 000000000..2e9d7b7c5
--- /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/main/LICENSE
+from typing import Tuple
+
+__version__ = "2.11.1"
+
+
+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 000000000..9e7ff6eed
--- /dev/null
+++ b/pylint/checkers/__init__.py
@@ -0,0 +1,94 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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 typing import Iterable, List, Union
+
+from pylint.checkers.base_checker import BaseChecker, BaseTokenChecker
+from pylint.checkers.deprecated import DeprecatedMixin
+from pylint.checkers.mapreduce_checker import MapReduceMixin
+from pylint.typing import CheckerStats
+from pylint.utils import diff_string, register_plugins
+
+
+def table_lines_from_stats(
+    stats: CheckerStats,
+    old_stats: CheckerStats,
+    columns: Iterable[str],
+) -> List[str]:
+    """get values listed in <columns> from <stats> and <old_stats>,
+    and return a formatted list of values, designed to be given to a
+    ureport.Table object
+    """
+    lines: List[str] = []
+    for m_type in columns:
+        new: Union[int, str] = stats[m_type]  # type: ignore
+        old: Union[int, str, None] = old_stats.get(m_type)  # type: ignore
+        if old is not None:
+            diff_str = diff_string(old, new)
+        else:
+            old, diff_str = "NC", "NC"
+        new = f"{new:.3f}" if isinstance(new, float) else str(new)
+        old = f"{old:.3f}" if isinstance(old, float) else str(old)
+        lines.extend((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 000000000..f9d1e15dd
--- /dev/null
+++ b/pylint/checkers/async.py
@@ -0,0 +1,97 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Checker for anything related to the async protocol (PEP 492)."""
+
+import sys
+
+import astroid
+from astroid import nodes
+
+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: nodes.AsyncFunctionDef) -> None:
+        for child in node.nodes_of_class(nodes.Yield):
+            if child.scope() is node and (
+                sys.version_info[:2] == (3, 5) or isinstance(child, nodes.YieldFrom)
+            ):
+                self.add_message("yield-inside-async-function", node=child)
+
+    @checker_utils.check_messages("not-async-context-manager")
+    def visit_asyncwith(self, node: nodes.AsyncWith) -> None:
+        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, nodes.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 000000000..776d5e520
--- /dev/null
+++ b/pylint/checkers/base.py
@@ -0,0 +1,2613 @@
+# 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, 2021 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Yilei "Dolee" Yang <yileiyang@google.com>
+# Copyright (c) 2021 Lorena B <46202743+lorena-b@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/main/LICENSE
+
+"""basic checker for Python code"""
+import collections
+import itertools
+import re
+import sys
+from typing import Any, Dict, Iterator, Optional, Pattern, Union
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, exceptions, interfaces
+from pylint import utils as lint_utils
+from pylint.checkers import utils
+from pylint.checkers.utils import (
+    infer_all,
+    is_overload_stub,
+    is_property_deleter,
+    is_property_setter,
+)
+from pylint.reporters.ureports import nodes as reporter_nodes
+from pylint.typing import CheckerStats
+
+
+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 = (nodes.Const, nodes.Dict, nodes.List, nodes.Set)
+UNITTEST_CASE = "unittest.case"
+TYPE_QNAME = "builtins.type"
+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: f"{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, nodes.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((nodes.ImportFrom, nodes.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,
+            (
+                nodes.For,
+                nodes.ListComp,
+                nodes.SetComp,
+                nodes.DictComp,
+                nodes.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 = (nodes.For, nodes.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 = (nodes.For, nodes.While)
+    definition_nodes = (nodes.FunctionDef, nodes.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(nodes.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: nodes.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"
+
+    decorators = node.decorators.nodes if node.decorators else []
+    for decorator in decorators:
+        # If the function is a property (decorated with @property
+        # or @abc.abstractproperty), the name type is 'attr'.
+        if isinstance(decorator, nodes.Name) or (
+            isinstance(decorator, nodes.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: CheckerStats,
+    old_stats: CheckerStats,
+):
+    """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: Dict[str, Dict[str, str]] = {}
+    for node_type in ("module", "class", "method", "function"):
+        try:
+            total: int = stats[node_type]  # type: ignore
+        except KeyError as e:
+            raise exceptions.EmptyReportError() from e
+        nice_stats[node_type] = {}
+        if total != 0:
+            try:
+                undocumented_node: int = stats["undocumented_" + node_type]  # type: ignore
+                documented = total - undocumented_node
+                percent = (documented * 100.0) / total
+                nice_stats[node_type]["percent_documented"] = f"{percent:.2f}"
+            except KeyError:
+                nice_stats[node_type]["percent_documented"] = "NC"
+            try:
+                badname_node: int = stats["badname_" + node_type]  # type: ignore
+                percent = (badname_node * 100.0) / total
+                nice_stats[node_type]["percent_badname"] = f"{percent:.2f}"
+            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: Optional[Union[str, int]] = old_stats.get(node_type, None)  # type: ignore
+        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, nodes.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: nodes.ClassDef) -> None:
+        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, nodes.Tuple):
+                return self._too_many_starred_for_tuple(elem)
+            if isinstance(elem, nodes.Starred):
+                starred_count += 1
+        return starred_count > 1
+
+    @utils.check_messages("too-many-star-expressions", "invalid-star-assignment-target")
+    def visit_assign(self, node: nodes.Assign) -> None:
+        # Check *a, *b = ...
+        assign_target = node.targets[0]
+        # Check *a = b
+        if isinstance(node.targets[0], nodes.Starred):
+            self.add_message("invalid-star-assignment-target", node=node)
+
+        if not isinstance(assign_target, nodes.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: nodes.Starred) -> None:
+        """Check that a Starred expression is used in an assignment target."""
+        if isinstance(node.parent, nodes.Call):
+            # f(*args) is converted to Call(args=[Starred]), so ignore
+            # them for this check.
+            return
+        if isinstance(node.parent, (nodes.List, nodes.Tuple, nodes.Set, nodes.Dict)):
+            # PEP 448 unpacking.
+            return
+
+        stmt = node.statement()
+        if not isinstance(stmt, nodes.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: nodes.FunctionDef) -> None:
+        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(
+            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.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: Iterator[Any] = 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(nodes.Global)
+            for name in child.names
+            if child.scope() is node
+        }
+
+        if not scope_globals:
+            return
+
+        for node_name in node.nodes_of_class(nodes.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(nodes.Nonlocal)
+                if same_scope(child)
+            )
+        )
+
+        if not nonlocals:
+            return
+
+        global_vars = set(
+            from_iter(
+                child.names
+                for child in node.nodes_of_class(nodes.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: nodes.Return) -> None:
+        if not isinstance(node.frame(), nodes.FunctionDef):
+            self.add_message("return-outside-function", node=node)
+
+    @utils.check_messages("yield-outside-function")
+    def visit_yield(self, node: nodes.Yield) -> None:
+        self._check_yield_outside_func(node)
+
+    @utils.check_messages("yield-outside-function")
+    def visit_yieldfrom(self, node: nodes.YieldFrom) -> None:
+        self._check_yield_outside_func(node)
+
+    @utils.check_messages("not-in-loop", "continue-in-finally")
+    def visit_continue(self, node: nodes.Continue) -> None:
+        self._check_in_loop(node, "continue")
+
+    @utils.check_messages("not-in-loop")
+    def visit_break(self, node: nodes.Break) -> None:
+        self._check_in_loop(node, "break")
+
+    @utils.check_messages("useless-else-on-loop")
+    def visit_for(self, node: nodes.For) -> None:
+        self._check_else_on_loop(node)
+
+    @utils.check_messages("useless-else-on-loop")
+    def visit_while(self, node: nodes.While) -> None:
+        self._check_else_on_loop(node)
+
+    @utils.check_messages("nonexistent-operator")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        """check use of the non-existent ++ and -- operator operator"""
+        if (
+            (node.op in "+-")
+            and isinstance(node.operand, nodes.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, (nodes.ClassDef, nodes.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, nodes.FunctionDef):
+            self.add_message("nonlocal-without-binding", args=(name,), node=node)
+
+    @utils.check_messages("nonlocal-without-binding")
+    def visit_nonlocal(self, node: nodes.Nonlocal) -> None:
+        for name in node.names:
+            self._check_nonlocal_without_binding(node, name)
+
+    @utils.check_messages("abstract-class-instantiated")
+    def visit_call(self, node: nodes.Call) -> None:
+        """Check instantiating abstract class with
+        abc.ABCMeta as metaclass.
+        """
+        for inferred in infer_all(node.func):
+            self._check_inferred_class_is_abstract(inferred, node)
+
+    def _check_inferred_class_is_abstract(self, inferred, node):
+        if not isinstance(inferred, nodes.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(), (nodes.FunctionDef, nodes.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, (nodes.For, nodes.While)):
+                if node not in _node.orelse:
+                    return
+
+            if isinstance(_node, (nodes.ClassDef, nodes.FunctionDef)):
+                break
+            if (
+                isinstance(_node, nodes.TryFinally)
+                and node in _node.finalbody
+                and isinstance(node, nodes.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 = [
+            i
+            for i in parent_frame.locals[node.name]
+            if not (isinstance(i.parent, nodes.AnnAssign) and i.parent.simple)
+        ]
+        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, nodes.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, nodes.If):
+                # Exempt "if not <func>" cases
+                if (
+                    isinstance(node.parent.test, nodes.UnaryOp)
+                    and node.parent.test.op == "not"
+                    and isinstance(node.parent.test.operand, nodes.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, nodes.Compare)
+                    and isinstance(node.parent.test.left, nodes.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], nodes.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: CheckerStats = {}
+        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: nodes.If) -> None:
+        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: nodes.IfExp) -> None:
+        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: nodes.Comprehension) -> None:
+        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 = (
+            nodes.Module,
+            nodes.GeneratorExp,
+            nodes.Lambda,
+            nodes.FunctionDef,
+            nodes.ClassDef,
+            astroid.bases.Generator,
+            astroid.UnboundMethod,
+            astroid.BoundMethod,
+            nodes.Module,
+        )
+        structs = (nodes.Dict, nodes.Tuple, nodes.Set, nodes.List)
+
+        # These nodes are excepted, since they are not constant
+        # values, requiring a computation to happen.
+        except_nodes = (
+            nodes.Call,
+            nodes.BinOp,
+            nodes.BoolOp,
+            nodes.UnaryOp,
+            nodes.Subscript,
+        )
+        inferred = None
+        emit = isinstance(test, (nodes.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, nodes.FunctionDef):
+                    call_inferred = inferred.infer_call_result()
+                elif isinstance(inferred, nodes.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, _: nodes.Module) -> None:
+        """check module name, docstring and required arguments"""
+        self.stats["module"] += 1  # type: ignore
+
+    def visit_classdef(self, _: nodes.ClassDef) -> None:
+        """check module name, docstring and redefinition
+        increment branch counter
+        """
+        self.stats["class"] += 1  # type: ignore
+
+    @utils.check_messages(
+        "pointless-statement", "pointless-string-statement", "expression-not-assigned"
+    )
+    def visit_expr(self, node: nodes.Expr) -> None:
+        """Check for various kind of statements without effect"""
+        expr = node.value
+        if isinstance(expr, nodes.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, (nodes.ClassDef, nodes.Module, nodes.FunctionDef)):
+                if isinstance(scope, nodes.FunctionDef) and scope.name != "__init__":
+                    pass
+                else:
+                    sibling = expr.previous_sibling()
+                    if (
+                        sibling is not None
+                        and sibling.scope() is scope
+                        and isinstance(sibling, (nodes.Assign, nodes.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, (nodes.Yield, nodes.Await, nodes.Call))
+            or (isinstance(node.parent, nodes.TryExcept) and node.parent.body == [node])
+            or (isinstance(expr, nodes.Const) and expr.value is Ellipsis)
+        ):
+            return
+        if any(expr.nodes_of_class(nodes.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, nodes.Starred):
+                if (
+                    isinstance(arg.value, nodes.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, nodes.Name):
+                if arg.value.name != variadic_name:
+                    return True
+            else:
+                return True
+        return False
+
+    @utils.check_messages("unnecessary-lambda")
+    def visit_lambda(self, node: nodes.Lambda) -> None:
+        """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, nodes.Call):
+            # The body of the lambda must be a function call expression
+            # for the lambda to be unnecessary.
+            return
+        if isinstance(node.body.func, nodes.Attribute) and isinstance(
+            node.body.func.expr, nodes.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, nodes.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: nodes.FunctionDef) -> None:
+        """check function name, docstring, arguments, redefinition,
+        variable names, max locals
+        """
+        self.stats["method" if node.is_method() else "function"] += 1  # type: ignore
+        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, (nodes.List, nodes.Set, nodes.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, nodes.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: nodes.Return) -> None:
+        """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 block ?
+        self._check_not_in_finally(node, "return", (nodes.FunctionDef,))
+
+    @utils.check_messages("unreachable")
+    def visit_continue(self, node: nodes.Continue) -> None:
+        """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: nodes.Break) -> None:
+        """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 block ?
+        self._check_not_in_finally(node, "break", (nodes.For, nodes.While))
+
+    @utils.check_messages("unreachable")
+    def visit_raise(self, node: nodes.Raise) -> None:
+        """check if the node has a right sibling (if so, that's some unreachable
+        code)
+        """
+        self._check_unreachable(node)
+
+    def _check_misplaced_format_function(self, call_node):
+        if not isinstance(call_node.func, nodes.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, nodes.Call):
+                return
+            if (
+                isinstance(call_expr.func, nodes.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: nodes.Call) -> None:
+        """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, nodes.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: nodes.Assert) -> None:
+        """check whether assert is used on a tuple or string literal."""
+        if (
+            node.fail is None
+            and isinstance(node.test, nodes.Tuple)
+            and len(node.test.elts) == 2
+        ):
+            self.add_message("assert-on-tuple", node=node)
+
+        if isinstance(node.test, nodes.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: nodes.Dict) -> None:
+        """check duplicate key in dictionary"""
+        keys = set()
+        for k, _ in node.items:
+            if isinstance(k, nodes.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: nodes.TryFinally) -> None:
+        """update try...finally flag"""
+        self._tryfinallys.append(node)
+
+    def leave_tryfinally(self, _: nodes.TryFinally) -> None:
+        """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:
+            if (
+                isinstance(node, nodes.Return)
+                and isinstance(unreach_stmt, nodes.Expr)
+                and isinstance(unreach_stmt.value, nodes.Yield)
+            ):
+                # Don't add 'unreachable' for empty generators.
+                # Only add warning if 'yield' is followed by another node.
+                unreach_stmt = unreach_stmt.next_sibling()
+                if unreach_stmt is None:
+                    return
+            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 block 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], nodes.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, (nodes.List, nodes.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: nodes.With) -> None:
+        # 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], nodes.AssignName) and (
+                    pair[1] is None and not isinstance(pair[0], nodes.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], nodes.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, nodes.Name):
+            if len(targets) != 1:
+                return
+            rhs_names = [node.value]
+        elif isinstance(node.value, nodes.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, nodes.Name):
+                continue
+            if not isinstance(target, nodes.AssignName):
+                continue
+            if isinstance(scope, nodes.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, nodes.Tuple):
+                continue
+
+            found_names = []
+            for element in target.elts:
+                if isinstance(element, nodes.Tuple):
+                    self._check_redeclared_assign_name([element])
+                elif isinstance(element, nodes.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: nodes.Assign) -> None:
+        self._check_self_assigning_variable(node)
+        self._check_redeclared_assign_name(node.targets)
+
+    @utils.check_messages("redeclared-assigned-name")
+    def visit_for(self, node: nodes.For) -> None:
+        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": f"Naming style matching correct {human_readable_name} names.",
+                },
+            )
+        )
+        name_options.append(
+            (
+                f"{name_type}-rgx",
+                {
+                    "default": None,
+                    "type": "regexp",
+                    "metavar": "<regexp>",
+                    "help": f"Regular expression matching correct {human_readable_name} names. Overrides {name_type}-naming-style.",
+                },
+            )
+        )
+    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] = f"{custom_regex.pattern!r} pattern"
+            else:
+                hints[name_type] = f"{naming_style_name} naming style"
+
+        return regexps, hints
+
+    @utils.check_messages("disallowed-name", "invalid-name", "non-ascii-name")
+    def visit_module(self, node: nodes.Module) -> None:
+        self._check_name("module", node.name.split(".")[-1], node)
+        self._bad_names = {}
+
+    def leave_module(self, _: nodes.Module) -> None:
+        for all_groups in self._bad_names.values():
+            if len(all_groups) < 2:
+                continue
+            groups = collections.defaultdict(list)
+            min_warnings = sys.maxsize
+            prevalent_group, _ = max(all_groups.items(), key=lambda item: len(item[1]))
+            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(prevalent_group, *args)
+
+    @utils.check_messages(
+        "disallowed-name", "invalid-name", "assign-to-new-keyword", "non-ascii-name"
+    )
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        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: nodes.FunctionDef) -> None:
+        # 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: nodes.Global) -> None:
+        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: nodes.AssignName) -> None:
+        """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, nodes.Comprehension):
+            self._check_name("inlinevar", node.name, node)
+        elif isinstance(frame, nodes.Module):
+            if isinstance(assign_type, nodes.Assign):
+                if isinstance(utils.safe_infer(assign_type.value), nodes.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), nodes.Const
+                ):
+                    self._check_name("const", node.name, node)
+            elif isinstance(
+                assign_type, nodes.AnnAssign
+            ) and utils.is_assign_name_annotated_with(node, "Final"):
+                self._check_name("const", node.name, node)
+        elif isinstance(frame, nodes.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, nodes.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, nodes.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,
+        prevalent_group: Optional[str],
+        node: nodes.NodeNG,
+        node_type: str,
+        name: str,
+        confidence,
+        warning: str = "invalid-name",
+    ) -> None:
+        type_label = HUMAN_READABLE_TYPES[node_type]
+        hint = self._name_hints[node_type]
+        if prevalent_group:
+            # This happens in the multi naming match case. The expected
+            # prevalent group needs to be spelled out to make the message
+            # correct.
+            hint = f"the `{prevalent_group}` group in the {hint}"
+        if self.config.include_naming_hint:
+            hint += f" ({self._name_regexps[node_type].pattern!r} 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  # type: ignore
+
+    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(
+                None, 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, nodes.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(None, 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: nodes.Module) -> None:
+        self._check_docstring("module", node)
+
+    @utils.check_messages("missing-docstring", "empty-docstring")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        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: nodes.FunctionDef) -> None:
+        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(), nodes.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], nodes.FunctionDef
+                    ):
+                        overridden = True
+                        break
+                self._check_docstring(
+                    ftype, node, report_missing=not overridden, confidence=confidence
+                )
+            elif isinstance(node.parent.frame(), nodes.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], nodes.Expr)
+                and isinstance(node.body[0].value, nodes.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: nodes.Pass) -> None:
+        if len(node.parent.child_sequence(node)) > 1 or (
+            isinstance(node.parent, (nodes.ClassDef, nodes.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, nodes.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, nodes.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, nodes.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, nodes.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, nodes.Attribute) and node.attrname == "NaN":
+                if isinstance(node.expr, nodes.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."""
+        is_other_literal = isinstance(
+            literal, (nodes.List, nodes.Tuple, nodes.Dict, nodes.Set)
+        )
+        is_const = False
+        if isinstance(literal, nodes.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, nodes.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: nodes.Compare):
+        """Check if identifier is compared against itself.
+        :param node: Compare node
+        :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, nodes.Const) and isinstance(
+            right_operand, nodes.Const
+        ):
+            left_operand = left_operand.value
+            right_operand = right_operand.value
+        elif isinstance(left_operand, nodes.Name) and isinstance(
+            right_operand, nodes.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 = (nodes.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: nodes.Compare) -> None:
+        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, nodes.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, nodes.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, nodes.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 000000000..e690e71d7
--- /dev/null
+++ b/pylint/checkers/base_checker.py
@@ -0,0 +1,191 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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.typing import CheckerStats
+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
+        self.stats: CheckerStats = {}
+
+    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 = f"{self.name.replace('_', ' ').title()} checker"
+        if module:
+            # Provide anchor to link against
+            result += f".. _{module}:\n\n"
+        result += f"{get_rst_title(checker_title, '~')}\n"
+        if module:
+            result += f"This checker is provided by ``{module}``.\n"
+        result += f"Verbatim name of the checker is ``{self.name}``.\n\n"
+        if doc:
+            # Provide anchor to link against
+            result += get_rst_title(f"{checker_title} Documentation", "^")
+            result += f"{cleandoc(doc)}\n\n"
+        # 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 += f"{get_rst_section(None, options)}\n"
+        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 += f"{msg.format_help(checkerref=False)}\n"
+            result += "\n"
+        if reports:
+            result += get_rst_title(f"{checker_title} Reports", "^")
+            for report in reports:
+                result += (
+                    ":%s: %s\n" % report[:2]  # pylint: disable=consider-using-f-string
+                )
+            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 000000000..d3faabc00
--- /dev/null
+++ b/pylint/checkers/classes.py
@@ -0,0 +1,2397 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@users.noreply.github.com>
+# Copyright (c) 2021 SupImDos <62866982+SupImDos@users.noreply.github.com>
+# Copyright (c) 2021 Kayran Schmidt <59456929+yumasheta@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Yu Shao, Pang <p.yushao2@gmail.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/main/LICENSE
+
+"""classes checker for Python code
+"""
+import collections
+from itertools import chain, zip_longest
+from typing import List, Pattern
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, utils
+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, nodes.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, nodes.Name):
+            kws[arg] = value.name
+        else:
+            kws[arg] = None
+
+    for arg in call.args:
+        if isinstance(arg, nodes.Starred) and isinstance(arg.value, nodes.Name):
+            # Positional variadic and a name, otherwise some transformation
+            # might have occurred.
+            starred_args.append(arg.value.name)
+        elif isinstance(arg, nodes.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 = {
+            nodes.Const: "value",
+            nodes.ClassDef: "name",
+            nodes.Tuple: "elts",
+            nodes.List: "elts",
+            nodes.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[nodes.AssignName],
+    overridden: List[nodes.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: nodes.FunctionDef,
+    overridden: nodes.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, nodes.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(nodes.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 = "builtins.property"
+    for attr in attributes:
+        if attr is astroid.Uninferable:
+            continue
+        try:
+            inferred = next(attr.infer())
+        except astroid.InferenceError:
+            continue
+        if isinstance(inferred, nodes.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(nodes.Call):
+        func = call.func
+        if isinstance(func, nodes.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, nodes.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: nodes.ClassDef) -> None:
+        """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(
+                "builtins.type"
+            ):
+                continue
+
+            if not isinstance(ancestor, nodes.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: nodes.ClassDef) -> None:
+        """close a class node:
+        check that instance attributes are defined in __init__ and check
+        access to existent members
+        """
+        self._check_unused_private_functions(node)
+        self._check_unused_private_variables(node)
+        self._check_unused_private_attributes(node)
+        self._check_attribute_defined_outside_init(node)
+
+    def _check_unused_private_functions(self, node: nodes.ClassDef) -> None:
+        for function_def in node.nodes_of_class(nodes.FunctionDef):
+            if not is_attr_private(function_def.name):
+                continue
+            parent_scope = function_def.parent.scope()
+            if isinstance(parent_scope, nodes.FunctionDef):
+                # Handle nested functions
+                if function_def.name in (
+                    n.name for n in parent_scope.nodes_of_class(nodes.Name)
+                ):
+                    continue
+            for attribute in node.nodes_of_class(nodes.Attribute):
+                if (
+                    attribute.attrname != function_def.name
+                    or attribute.scope() == function_def  # We ignore recursive calls
+                ):
+                    continue
+                if isinstance(attribute.expr, nodes.Name) and attribute.expr.name in (
+                    "self",
+                    "cls",
+                    node.name,
+                ):
+                    # self.__attrname
+                    # cls.__attrname
+                    # node_name.__attrname
+                    break
+                if isinstance(attribute.expr, nodes.Call):
+                    # type(self).__attrname
+                    inferred = safe_infer(attribute.expr)
+                    if (
+                        isinstance(inferred, nodes.ClassDef)
+                        and inferred.name == node.name
+                    ):
+                        break
+            else:
+                name_stack = []
+                curr = parent_scope
+                # Generate proper names for nested functions
+                while curr != node:
+                    name_stack.append(curr.name)
+                    curr = curr.parent.scope()
+
+                outer_level_names = f"{'.'.join(reversed(name_stack))}"
+                function_repr = f"{outer_level_names}.{function_def.name}({function_def.args.as_string()})"
+                self.add_message(
+                    "unused-private-member",
+                    node=function_def,
+                    args=(node.name, function_repr.lstrip(".")),
+                )
+
+    def _check_unused_private_variables(self, node: nodes.ClassDef) -> None:
+        for assign_name in node.nodes_of_class(nodes.AssignName):
+            if isinstance(assign_name.parent, nodes.Arguments):
+                continue  # Ignore function arguments
+            if not is_attr_private(assign_name.name):
+                continue
+            for child in node.nodes_of_class((nodes.Name, nodes.Attribute)):
+                if isinstance(child, nodes.Name) and child.name == assign_name.name:
+                    break
+                if (
+                    isinstance(child, nodes.Attribute)
+                    and child.attrname == assign_name.name
+                    and child.expr.name in ("self", "cls", node.name)
+                ):
+                    break
+            else:
+                args = (node.name, assign_name.name)
+                self.add_message("unused-private-member", node=assign_name, args=args)
+
+    def _check_unused_private_attributes(self, node: nodes.ClassDef) -> None:
+        for assign_attr in node.nodes_of_class(nodes.AssignAttr):
+            if not is_attr_private(assign_attr.attrname) or not isinstance(
+                assign_attr.expr, nodes.Name
+            ):
+                continue
+
+            # Logic for checking false positive when using __new__,
+            # Get the returned object names of the __new__ magic function
+            # Then check if the attribute was consumed in other instance methods
+            acceptable_obj_names: List[str] = ["self"]
+            scope = assign_attr.scope()
+            if isinstance(scope, nodes.FunctionDef) and scope.name == "__new__":
+                acceptable_obj_names.extend(
+                    [
+                        return_node.value.name
+                        for return_node in scope.nodes_of_class(nodes.Return)
+                        if isinstance(return_node.value, nodes.Name)
+                    ]
+                )
+
+            for attribute in node.nodes_of_class(nodes.Attribute):
+                if attribute.attrname != assign_attr.attrname:
+                    continue
+
+                if (
+                    assign_attr.expr.name
+                    in [
+                        "cls",
+                        node.name,
+                    ]
+                    and attribute.expr.name in ["cls", "self", node.name]
+                ):
+                    # If assigned to cls or class name, can be accessed by cls/self/class name
+                    break
+
+                if (
+                    assign_attr.expr.name in acceptable_obj_names
+                    and attribute.expr.name == "self"
+                ):
+                    # If assigned to self.attrib, can only be accessed by self
+                    # Or if __new__ was used, the returned object names are acceptable
+                    break
+
+                if assign_attr.expr.name == attribute.expr.name == node.name:
+                    # Recognise attributes which are accessed via the class name
+                    break
+
+            else:
+                args = (node.name, assign_attr.attrname)
+                self.add_message("unused-private-member", node=assign_attr, args=args)
+
+    def _check_attribute_defined_outside_init(self, cnode: nodes.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_lst 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_lst = [
+                n
+                for n in nodes_lst
+                if not isinstance(n.statement(), (nodes.Delete, nodes.AugAssign))
+                and n.root() is current_module
+            ]
+            if not nodes_lst:
+                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_lst)
+            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_lst:
+                        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: nodes.FunctionDef) -> None:
+        """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, nodes.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, nodes.Attribute) and decorator.attrname in (
+                    "getter",
+                    "setter",
+                    "deleter",
+                ):
+                    # attribute affectation will call this method, not hiding it
+                    return
+                if isinstance(decorator, nodes.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, nodes.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, nodes.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, nodes.FunctionDef)
+                and overridden_frame.type == "method"
+            ):
+                overridden_frame = overridden_frame.parent.frame()
+            if not (
+                isinstance(overridden_frame, nodes.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, nodes.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, (nodes.Expr, nodes.Return)):
+            # Doing something else than what we are interested into.
+            return
+
+        call = statement.value
+        if (
+            not isinstance(call, nodes.Call)
+            # Not a super() attribute access.
+            or not isinstance(call.func, nodes.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, nodes.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, nodes.AsyncFunctionDef)
+        current_is_async = isinstance(function_node, nodes.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, nodes.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, nodes.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, nodes.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, nodes.AnnAssign) and parent.value is None:
+                        return
+                self.add_message(
+                    "class-variable-slots-conflict", args=(inferred.value,), node=elt
+                )
+
+    def leave_functiondef(self, node: nodes.FunctionDef) -> None:
+        """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)
+
+    leave_asyncfunctiondef = leave_functiondef
+
+    def visit_attribute(self, node: nodes.Attribute) -> None:
+        """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: nodes.AssignAttr) -> None:
+        if isinstance(
+            node.assign_type(), nodes.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: nodes.AssignAttr) -> None:
+        if not node.attrname == "__class__":
+            return
+        inferred = safe_infer(node.parent.value)
+        if isinstance(inferred, nodes.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: nodes.Assign) -> None:
+        self._check_classmethod_declaration(assign_node)
+        node = assign_node.targets[0]
+        if not isinstance(node, nodes.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, nodes.Call):
+            return
+
+        # check the function called is "classmethod" or "staticmethod"
+        func = node.value.func
+        if not isinstance(func, nodes.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, nodes.ClassDef):
+            return
+
+        # Check if the arg passed to classmethod is a class member
+        classmeth_arg = node.value.args[0]
+        if not isinstance(classmeth_arg, nodes.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: nodes.Attribute):
+        """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()
+
+            # Typing annotations in funciton definitions can include protected members
+            if utils.is_node_in_type_annotation_context(node):
+                return
+
+            # 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, nodes.Call)
+                and isinstance(node.expr.func, nodes.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, nodes.Assign)
+                    and len(stmt.targets) == 1
+                    and isinstance(stmt.targets[0], nodes.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: nodes.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, nodes.Call)
+            and isinstance(expr.func, nodes.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, nodes.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: nodes.Name) -> None:
+        """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_lst 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_lst]
+                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_lst:
+                        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(nodes.Call):
+            expr = stmt.func
+            if not isinstance(expr, nodes.Attribute) or expr.attrname != "__init__":
+                continue
+            # skip the test if using super
+            if (
+                isinstance(expr.expr, nodes.Call)
+                and isinstance(expr.expr.func, nodes.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, nodes.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, nodes.FunctionDef)
+            and isinstance(refmethod, nodes.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 nodes.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, nodes.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 "
+            f"iterable (i.e. has no `{NEXT_METHOD}` 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: nodes.FunctionDef) -> None:
+        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, ["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
+            # pylint: disable-next=consider-using-f-string
+            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, nodes.Const)
+        )
+
+    @staticmethod
+    def _is_int(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "int"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, int)
+
+    @staticmethod
+    def _is_str(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "str"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, str)
+
+    @staticmethod
+    def _is_bool(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, bool)
+
+    @staticmethod
+    def _is_bytes(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
+
+    @staticmethod
+    def _is_tuple(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
+
+    @staticmethod
+    def _is_dict(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
+            return True
+
+        return isinstance(node, nodes.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, nodes.ClassDef):
+            metaclass = node.metaclass()
+            if metaclass and isinstance(metaclass, nodes.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, nodes.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, nodes.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, nodes.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, nodes.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 000000000..ac1cd6425
--- /dev/null
+++ b/pylint/checkers/deprecated.py
@@ -0,0 +1,244 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+"""Checker mixin for deprecated functionality."""
+from itertools import chain
+from typing import Any, Container, Iterable, Tuple, Union
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import utils
+from pylint.checkers.base_checker import BaseChecker
+from pylint.checkers.utils import get_import_name, infer_all, safe_infer
+
+ACCEPTABLE_NODES = (
+    astroid.BoundMethod,
+    astroid.UnboundMethod,
+    nodes.FunctionDef,
+    nodes.ClassDef,
+)
+
+
+class DeprecatedMixin(BaseChecker):
+    """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: nodes.Call) -> None:
+        """Called when a :class:`nodes.Call` node is visited."""
+        self.check_deprecated_class_in_call(node)
+        for inferred in infer_all(node.func):
+            # Calling entry point for deprecation check logic.
+            self.check_deprecated_method(node, inferred)
+
+    @utils.check_messages(
+        "deprecated-module",
+        "deprecated-class",
+    )
+    def visit_import(self, node: nodes.Import) -> None:
+        """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: nodes.Decorators) -> None:
+        """Triggered when a decorator statement is seen"""
+        children = list(node.get_children())
+        if not children:
+            return
+        if isinstance(children[0], nodes.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: nodes.ImportFrom) -> None:
+        """triggered when a from statement is seen"""
+        basename = node.modname
+        basename = get_import_name(node, basename)
+        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, nodes.Attribute):
+            func_name = node.func.attrname
+        elif isinstance(node.func, nodes.Name):
+            func_name = node.func.name
+        else:
+            # Not interested in other nodes.
+            return
+
+        if hasattr(inferred.parent, "qname") and inferred.parent.qname():
+            # Handling the situation when deprecated function is
+            # alias to existing function.
+            qnames = {
+                inferred.qname(),
+                f"{inferred.parent.qname()}.{func_name}",
+                func_name,
+            }
+        else:
+            qnames = {inferred.qname(), func_name}
+        if any(name in self.deprecated_methods() for name in qnames):
+            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 {}
+        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
+        for position, arg_name in chain(*deprecated_arguments):
+            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, nodes.Attribute) and isinstance(
+            node.func.expr, nodes.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 000000000..809a49f43
--- /dev/null
+++ b/pylint/checkers/design_analysis.py
@@ -0,0 +1,631 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Melvin <31448155+melvio@users.noreply.github.com>
+# Copyright (c) 2021 Rebecca Turner <rbt@sent.as>
+# 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/main/LICENSE
+
+"""check for signs of poor design"""
+
+import re
+from collections import defaultdict
+from typing import FrozenSet, List, Set, cast
+
+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
+from pylint.typing import CheckerStats
+
+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
+
+
+def _get_parents(
+    node: nodes.ClassDef, ignored_parents: FrozenSet[str]
+) -> Set[nodes.ClassDef]:
+    r"""Get parents of ``node``, excluding ancestors of ``ignored_parents``.
+
+    If we have the following inheritance diagram:
+
+             F
+            /
+        D  E
+         \/
+          B  C
+           \/
+            A      # class A(B, C): ...
+
+    And ``ignored_parents`` is ``{"E"}``, then this function will return
+    ``{A, B, C, D}`` -- both ``E`` and its ancestors are excluded.
+    """
+    parents: Set[nodes.ClassDef] = set()
+    to_explore = cast(List[nodes.ClassDef], list(node.ancestors(recurs=False)))
+    while to_explore:
+        parent = to_explore.pop()
+        if parent.qname() in ignored_parents:
+            continue
+        parents.add(parent)
+        to_explore.extend(parent.ancestors(recurs=False))
+    return parents
+
+
+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).",
+            },
+        ),
+        (
+            "ignored-parents",
+            {
+                "default": (),
+                "type": "csv",
+                "metavar": "<comma separated list of class names>",
+                "help": "List of qualified class names to ignore when counting class parents (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: CheckerStats = {}
+        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) -> None:
+        """check size of inheritance hierarchy and number of instance attributes"""
+        parents = _get_parents(
+            node, STDLIB_CLASSES_IGNORE_ANCESTOR.union(self.config.ignored_parents)
+        )
+        nb_parents = len(parents)
+        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: nodes.ClassDef) -> None:
+        """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: nodes.FunctionDef) -> None:
+        """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: nodes.FunctionDef) -> None:
+        """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, _: nodes.Return) -> None:
+        """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: nodes.NodeNG) -> None:
+        """default visit method -> increments the statements counter if
+        necessary
+        """
+        if node.is_statement:
+            self._inc_all_stmts(1)
+
+    def visit_tryexcept(self, node: nodes.TryExcept) -> None:
+        """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: nodes.TryFinally) -> None:
+        """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: nodes.If) -> None:
+        """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: nodes.While) -> None:
+        """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 000000000..2e26c31a0
--- /dev/null
+++ b/pylint/checkers/exceptions.py
@@ -0,0 +1,580 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Checks for various exception related errors."""
+import builtins
+import inspect
+from typing import Any, List, Optional
+
+import astroid
+from astroid import nodes, objects
+
+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, (nodes.List, nodes.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: List) -> bool:
+    """Return true if the given statement node raise an exception"""
+    for node in body:
+        if isinstance(node, nodes.Raise):
+            return True
+    return False
+
+
+OVERGENERAL_EXCEPTIONS = ("BaseException", "Exception")
+
+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, _: nodes.NodeNG) -> None:
+        """Default implementation for all the nodes."""
+
+
+class ExceptionRaiseRefVisitor(BaseVisitor):
+    """Visit references (anything that is not an AST leaf)."""
+
+    def visit_name(self, node: nodes.Name) -> None:
+        if node.name == "NotImplemented":
+            self._checker.add_message("notimplemented-raised", node=self._node)
+
+    def visit_call(self, node: nodes.Call) -> None:
+        if isinstance(node.func, nodes.Name):
+            self.visit_name(node.func)
+        if (
+            len(node.args) > 1
+            and isinstance(node.args[0], nodes.Const)
+            and isinstance(node.args[0].value, str)
+        ):
+            msg = node.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, node: nodes.Const) -> None:
+        self._checker.add_message(
+            "raising-bad-type", node=self._node, args=node.value.__class__.__name__
+        )
+
+    def visit_instance(self, instance: objects.ExceptionInstance) -> None:
+        # 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, node: nodes.ClassDef) -> None:
+        if not utils.inherit_from_std_ex(node) and utils.has_known_bases(node):
+            if node.newstyle:
+                self._checker.add_message("raising-non-exception", node=self._node)
+
+    def visit_tuple(self, _: nodes.Tuple) -> None:
+        self._checker.add_message("raising-bad-type", node=self._node, args="tuple")
+
+    def visit_default(self, node: nodes.NodeNG) -> None:
+        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 "  # pylint: disable=consider-using-f-string
+                '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: nodes.Raise) -> None:
+        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, nodes.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 = (nodes.ExceptHandler, nodes.FunctionDef)
+        while current and not isinstance(current.parent, ignores):
+            current = current.parent
+
+        expected = (nodes.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: nodes.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, nodes.Const):
+            if cause.value is not None:
+                self.add_message("bad-exception-context", node=node)
+        elif not isinstance(cause, nodes.ClassDef) and not utils.inherit_from_std_ex(
+            cause
+        ):
+            self.add_message("bad-exception-context", node=node)
+
+    def _check_raise_missing_from(self, node: nodes.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, nodes.Call) and isinstance(node.exc.func, nodes.Name):
+            # We have a `raise SomeException(whatever)`.
+            self.add_message("raise-missing-from", node=node)
+        elif (
+            isinstance(node.exc, nodes.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, nodes.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, nodes.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, nodes.Const) and exc.value is None:
+                if (
+                    isinstance(handler.type, nodes.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,
+        ) -> Optional[List[nodes.NodeNG]]:
+            exceptions: List[nodes.NodeNG] = []
+            if handler.type:
+                exceptions_in_handler = utils.safe_infer(handler.type)
+                if isinstance(exceptions_in_handler, nodes.Tuple):
+                    exceptions = list(
+                        {
+                            exception
+                            for exception in exceptions_in_handler.elts
+                            if isinstance(exception, nodes.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: nodes.BinOp) -> None:
+        if isinstance(node.parent, nodes.ExceptHandler):
+            # except (V | A)
+            suggestion = f"Did you mean '({node.left.as_string()}, {node.right.as_string()})' instead?"
+            self.add_message("wrong-exception-operation", node=node, args=(suggestion,))
+
+    @utils.check_messages("wrong-exception-operation")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        if isinstance(node.parent, nodes.ExceptHandler):
+            # except (V < A)
+            suggestion = f"Did you mean '({node.left.as_string()}, {', '.join(operand.as_string() for _, operand in node.ops)})' instead?"
+            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: nodes.TryExcept) -> None:
+        """check for empty except"""
+        self._check_try_except_raise(node)
+        exceptions_classes: List[Any] = []
+        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, nodes.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, nodes.ClassDef):
+                        continue
+
+                    exc_ancestors = [
+                        anc
+                        for anc in exc.ancestors()
+                        if isinstance(anc, nodes.ClassDef)
+                    ]
+
+                    for previous_exc in exceptions_classes:
+                        if previous_exc in exc_ancestors:
+                            msg = f"{previous_exc.name} is an ancestor class of {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 000000000..62064b88b
--- /dev/null
+++ b/pylint/checkers/format.py
@@ -0,0 +1,816 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/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, _node: nodes.Module) -> None:
+        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
+        contains_double_parens = 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
+                if tokens[i + 1].string == "(":
+                    contains_double_parens = 1
+            elif token.string == ")":
+                depth -= 1
+                if depth:
+                    if contains_double_parens and tokens[i + 1].string == ")":
+                        # For walrus operators in `if (not)` conditions and comprehensions
+                        if keyword_token in {"in", "if", "not"}:
+                            continue
+                        return
+                    contains_double_parens -= 1
+                    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):
+                    if contains_walrus_operator and walrus_operator_depth - 1 == depth:
+                        return
+                    # The empty tuple () is always accepted.
+                    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 and keyword_token != "in":
+                        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
+                # A generator expression can have a 'else' token in it.
+                # We check the rest of the tokens to see if any problems incure after
+                # the 'else'.
+                elif token[1] == "else":
+                    if "(" in (i.string for i in tokens[i:]):
+                        self._check_keyword_parentheses(tokens[i:], 0)
+                    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: nodes.NodeNG) -> None:
+        """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 000000000..68559520e
--- /dev/null
+++ b/pylint/checkers/imports.py
@@ -0,0 +1,1008 @@
+# 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, 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# 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) 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, 2021 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Will Shanks <wsha@posteo.net>
+# Copyright (c) 2021 Matus Valo <matusvalo@users.noreply.github.com>
+# Copyright (c) 2021 yushao2 <36848472+yushao2@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/main/LICENSE
+
+"""imports checkers for Python code"""
+
+import collections
+import copy
+import os
+import sys
+from distutils import sysconfig
+from typing import Any, Dict, List, Set, Tuple, Union
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, DeprecatedMixin
+from pylint.checkers.utils import (
+    check_messages,
+    get_import_name,
+    is_from_fallback_block,
+    is_node_in_guarded_import_block,
+    node_ignores_exception,
+)
+from pylint.exceptions import EmptyReportError
+from pylint.graph import DotBackend, get_cycles
+from pylint.interfaces import IAstroidChecker
+from pylint.lint import PyLinter
+from pylint.reporters.ureports.nodes import Paragraph, Section, VerbatimText
+from pylint.typing import CheckerStats
+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_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, nodes.Import):
+            if any(fullname == iname[0] for iname in first.names):
+                found = True
+                break
+        elif isinstance(first, nodes.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
+
+    if is_node_in_guarded_import_block(node):
+        # Ignore import failure if part of guarded import block
+        # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+        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_items = data.items()
+    for i, (mod, (sub, files)) in enumerate(sorted(nodes_items, key=lambda x: x[0])):
+        files = "" if not files else f"({','.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_items) - 1:
+                sub_indent_str = f"{indent_str}  "
+            else:
+                sub_indent_str = f"{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: Section, 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 of a package is imported and "
+        "aliased with the same name. "
+        "E.g., instead of ``import concurrent.futures as futures`` use "
+        "``from concurrent import futures``",
+    ),
+    "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: PyLinter = None
+    ):  # pylint: disable=super-init-not-called # See https://github.com/PyCQA/pylint/issues/4941
+        BaseChecker.__init__(self, linter)
+        self.stats: CheckerStats = {}
+        self.import_graph: collections.defaultdict = collections.defaultdict(set)
+        self._imports_stack: List[Tuple[Any, Any]] = []
+        self._first_non_import_node = None
+        self._module_pkg: Dict[
+            Any, Any
+        ] = {}  # mapping of modules to the pkg they belong in
+        self._allow_any_import_level: Set[Any] = 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: nodes.Import) -> None:
+        """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, nodes.Module):
+                # Allow imports nested
+                self._check_position(node)
+            if isinstance(node.scope(), nodes.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: nodes.ImportFrom) -> None:
+        """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, nodes.Module):
+            # Allow imports nested
+            self._check_position(node)
+        if isinstance(node.scope(), nodes.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: nodes.Module) -> None:
+        # 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[str] = set()  # set for 'import x' style
+        met_from: Set[str] = 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
+            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
+            package, _, _ = import_name.partition(".")
+            if (
+                current_package
+                and current_package != package
+                and package in met
+                and is_node_in_guarded_import_block(import_node) is False
+            ):
+                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, nodes.Module):
+            return
+        nested_allowed = [nodes.TryExcept, nodes.TryFinally]
+        is_nested_allowed = [
+            allowed for allowed in nested_allowed if isinstance(node, allowed)
+        ]
+        if is_nested_allowed and any(
+            node.nodes_of_class((nodes.Import, nodes.ImportFrom))
+        ):
+            return
+        if isinstance(node, nodes.Assign):
+            # Add compatibility for module level dunder names
+            # https://www.python.org/dev/peps/pep-0008/#module-level-dunder-names
+            valid_targets = [
+                isinstance(target, nodes.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: nodes.FunctionDef) -> None:
+        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(), nodes.Module):
+            return
+
+        root = node
+        while not isinstance(root.parent, nodes.Module):
+            root = root.parent
+
+        if isinstance(root, (nodes.If, nodes.TryFinally, nodes.TryExcept)):
+            if any(root.nodes_of_class((nodes.Import, nodes.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, nodes.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, nodes.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, nodes.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, nodes.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=(
+                            f'standard import "{node.as_string()}"',
+                            f'"{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=(
+                            f'third party import "{node.as_string()}"',
+                            f'"{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=(
+                            f'first party import "{node.as_string()}"',
+                            f'"{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 = f"Cannot import {modname!r} due to syntax error {str(exc.error)!r}"  # 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: Union[nodes.Import, nodes.ImportFrom], importedmodname: str
+    ) -> None:
+        """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
+
+        in_type_checking_block = (
+            isinstance(node.parent, nodes.If) and node.parent.is_typing_guard()
+        )
+
+        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
+            dependencies_stat: Dict[str, Union[Set]] = self.stats["dependencies"]  # type: ignore
+            importedmodnames = dependencies_stat.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)
+                or in_type_checking_block
+            ):
+                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[nodes.Import, nodes.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(), nodes.Module):
+            return
+
+        module_names = [
+            f"{node.modname}.{name[0]}"
+            if isinstance(node, nodes.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 000000000..e04b0ec8f
--- /dev/null
+++ b/pylint/checkers/logging.py
@@ -0,0 +1,414 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""checker for use of Python logging
+"""
+import string
+from typing import Set
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.checkers.utils import check_messages, infer_all
+
+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, _: nodes.Module) -> None:
+        """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[str] = 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: nodes.ImportFrom) -> None:
+        """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: nodes.Import) -> None:
+        """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: nodes.Call) -> None:
+        """Checks calls to logging methods."""
+
+        def is_logging_name():
+            return (
+                isinstance(node.func, nodes.Attribute)
+                and isinstance(node.func.expr, nodes.Name)
+                and node.func.expr.name in self._logging_names
+            )
+
+        def is_logger_class():
+            for inferred in infer_all(node.func):
+                if isinstance(inferred, astroid.BoundMethod):
+                    parent = inferred._proxied.parent
+                    if isinstance(parent, nodes.ClassDef) and (
+                        parent.qname() == "logging.Logger"
+                        or any(
+                            ancestor.qname() == "logging.Logger"
+                            for ancestor in parent.ancestors()
+                        )
+                    ):
+                        return True, inferred._proxied.name
+            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], nodes.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], nodes.Call):
+            self._check_call_func(node.args[format_pos])
+        elif isinstance(node.args[format_pos], nodes.Const):
+            self._check_format_string(node, format_pos)
+        elif isinstance(node.args[format_pos], nodes.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, nodes.Const) and operand.name == "str"
+
+    def _check_call_func(self, node: nodes.Call):
+        """Checks that function call is not format_string.format()."""
+        func = utils.safe_infer(node.func)
+        types = ("str", "unicode")
+        methods = ("format",)
+        if (
+            isinstance(func, astroid.BoundMethod)
+            and 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 (nodes.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 (nodes.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, nodes.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, nodes.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 000000000..cb76decf9
--- /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/main/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 000000000..9a29cb1fb
--- /dev/null
+++ b/pylint/checkers/misc.py
@@ -0,0 +1,195 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Nick Drozd <nicholasdrozd@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/main/LICENSE
+
+
+"""Check source code is ascii only or has an encoding declaration (PEP 263)"""
+
+import re
+import tokenize
+from typing import Optional
+
+from astroid import nodes
+
+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, node: nodes.Module) -> None:
+        """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 == node.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 = fr"#\s*({notes})\b"
+
+        self._fixme_pattern = re.compile(regex_string, re.I)
+
+    def _check_encoding(
+        self, lineno: int, line: bytes, file_encoding: str
+    ) -> Optional[str]:
+        try:
+            return line.decode(file_encoding)
+        except UnicodeDecodeError:
+            pass
+        except LookupError:
+            if (
+                line.startswith(b"#")
+                and "coding" in str(line)
+                and file_encoding in str(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, node: nodes.Module) -> None:
+        """inspect the source file to find encoding problem"""
+        encoding = node.file_encoding if node.file_encoding else "ascii"
+
+        with node.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 000000000..624f60bdd
--- /dev/null
+++ b/pylint/checkers/newstyle.py
@@ -0,0 +1,137 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""check for new / old style related problems
+"""
+import astroid
+from astroid import nodes
+
+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: nodes.FunctionDef) -> None:
+        """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(nodes.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, nodes.Attribute):
+                continue
+
+            call = expr.expr
+            # skip the test if using super
+            if not (
+                isinstance(call, nodes.Call)
+                and isinstance(call.func, nodes.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, nodes.Call)
+                    and isinstance(arg0.func, nodes.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], nodes.Name)
+                    and call.args[1].name == "self"
+                    and isinstance(arg0, nodes.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/raw_metrics.py b/pylint/checkers/raw_metrics.py
new file mode 100644
index 000000000..0cb707427
--- /dev/null
+++ b/pylint/checkers/raw_metrics.py
@@ -0,0 +1,128 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+import tokenize
+from typing import Any, Optional, Union
+
+from pylint.checkers import BaseTokenChecker
+from pylint.exceptions import EmptyReportError
+from pylint.interfaces import ITokenChecker
+from pylint.reporters.ureports.nodes import Table
+from pylint.typing import CheckerStats
+from pylint.utils import diff_string
+
+
+def report_raw_stats(
+    sect,
+    stats: CheckerStats,
+    old_stats: CheckerStats,
+):
+    """calculate percentage of code / doc / comment / empty"""
+    total_lines: int = stats["total_lines"]  # type: ignore
+    if not total_lines:
+        raise EmptyReportError()
+    sect.description = f"{total_lines} lines have been analyzed"
+    lines = ["type", "number", "%", "previous", "difference"]
+    for node_type in ("code", "docstring", "comment", "empty"):
+        key = node_type + "_lines"
+        total: int = stats[key]  # type: ignore
+        percent = float(total * 100) / total_lines
+        old: Optional[Union[int, str]] = old_stats.get(key, None)  # type: ignore
+        if old is not None:
+            diff_str = diff_string(old, total)
+        else:
+            old, diff_str = "NC", "NC"
+        lines += [node_type, str(total), f"{percent:.2f}", 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: CheckerStats = {}
+
+    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 000000000..9208634ff
--- /dev/null
+++ b/pylint/checkers/refactoring/__init__.py
@@ -0,0 +1,53 @@
+# 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>
+# 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/main/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 000000000..4e4eb2b46
--- /dev/null
+++ b/pylint/checkers/refactoring/len_checker.py
@@ -0,0 +1,122 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+from typing import List
+
+import astroid
+from astroid import nodes
+
+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: nodes.Call) -> None:
+        # 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, nodes.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 = (
+            nodes.ListComp,
+            nodes.SetComp,
+            nodes.DictComp,
+            nodes.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-variable, 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: nodes.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: nodes.UnaryOp) -> None:
+        """`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, nodes.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: nodes.ClassDef) -> List[nodes.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 000000000..f8c670e96
--- /dev/null
+++ b/pylint/checkers/refactoring/not_checker.py
@@ -0,0 +1,83 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+
+import astroid
+from astroid import nodes
+
+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 = (nodes.Set,)
+    # 'builtins' py3, '__builtin__' py2
+    skipped_classnames = [f"builtins.{qname}" for qname in ("set", "frozenset")]
+
+    @utils.check_messages("unneeded-not")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        if node.op != "not":
+            return
+        operand = node.operand
+
+        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
+            self.add_message(
+                "unneeded-not",
+                node=node,
+                args=(node.as_string(), operand.operand.as_string()),
+            )
+        elif isinstance(operand, nodes.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 = (
+                f"{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 000000000..84c399988
--- /dev/null
+++ b/pylint/checkers/refactoring/recommendation_checker.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/main/LICENSE
+from typing import Union
+
+import astroid
+from astroid import nodes
+
+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 or when ``.keys()`` is used for a membership check. "
+            "It is enough to iterate through the dictionary itself, "
+            "``for key in dictionary``. For membership checks, "
+            "``if key in dictionary`` is faster.",
+        ),
+        "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.",
+        ),
+        "C0208": (
+            "Use a sequence type when iterating over values",
+            "use-sequence-for-iteration",
+            "When iterating over values, sequence types (e.g., ``lists``, ``tuples``, ``ranges``) "
+            "are more efficient than ``sets``.",
+        ),
+        "C0209": (
+            "Formatting a regular string which could be a f-string",
+            "consider-using-f-string",
+            "Used when we detect a string that is being formatted with format() or % "
+            "which could potentially be a f-string. The use of f-strings is preferred.",
+        ),
+    }
+
+    @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: nodes.Call) -> None:
+        self._check_consider_iterating_dictionary(node)
+        self._check_use_maxsplit_arg(node)
+
+    def _check_consider_iterating_dictionary(self, node: nodes.Call) -> None:
+        if not isinstance(node.func, nodes.Attribute):
+            return
+        if node.func.attrname != "keys":
+            return
+        if (
+            isinstance(node.parent, (nodes.For, nodes.Comprehension))
+            or isinstance(node.parent, nodes.Compare)
+            and any(
+                op
+                for op, comparator in node.parent.ops
+                if op == "in" and comparator is node
+            )
+        ):
+            inferred = utils.safe_infer(node.func)
+            if not isinstance(inferred, astroid.BoundMethod) or not isinstance(
+                inferred.bound, nodes.Dict
+            ):
+                return
+
+            self.add_message("consider-iterating-dictionary", node=node)
+
+    def _check_use_maxsplit_arg(self, node: nodes.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 not (
+            isinstance(node.func, nodes.Attribute)
+            and node.func.attrname in ("split", "rsplit")
+            and isinstance(utils.safe_infer(node.func), astroid.BoundMethod)
+        ):
+            return
+
+        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, nodes.Subscript):
+            try:
+                subscript_value = utils.get_subscript_const_value(node.parent).value
+            except utils.InferredTypeError:
+                return
+
+            # Check for cases where variable (Name) subscripts may be mutated within a loop
+            if isinstance(node.parent.slice, nodes.Name):
+                # Check if loop present within the scope of the node
+                scope = node.scope()
+                for loop_node in scope.nodes_of_class((nodes.For, nodes.While)):
+                    if not loop_node.parent_of(node):
+                        continue
+
+                    # Check if var is mutated within loop (Assign/AugAssign)
+                    for assignment_node in loop_node.nodes_of_class(nodes.AugAssign):
+                        if node.parent.slice.name == assignment_node.target.name:
+                            return
+                    for assignment_node in loop_node.nodes_of_class(nodes.Assign):
+                        if node.parent.slice.name in [
+                            n.name for n in assignment_node.targets
+                        ]:
+                            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",
+        "use-sequence-for-iteration",
+    )
+    def visit_for(self, node: nodes.For) -> None:
+        self._check_consider_using_enumerate(node)
+        self._check_consider_using_dict_items(node)
+        self._check_use_sequence_for_iteration(node)
+
+    def _check_consider_using_enumerate(self, node: nodes.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, nodes.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], nodes.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], nodes.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, nodes.Name):
+            expected_subscript_val_type = nodes.Name
+        elif isinstance(iterating_object, nodes.Attribute):
+            expected_subscript_val_type = nodes.Attribute
+        else:
+            return
+        # If we're defining __iter__ on self, enumerate won't work
+        scope = node.scope()
+        if (
+            isinstance(iterating_object, nodes.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(nodes.Subscript):
+                if not isinstance(subscript.value, expected_subscript_val_type):
+                    continue
+
+                value = subscript.slice
+                if not isinstance(value, nodes.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, nodes.Name)
+                    and iterating_object.name == subscript.value.name
+                    or isinstance(subscript.value, nodes.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: nodes.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(nodes.Subscript):
+                if not isinstance(subscript.value, (nodes.Name, nodes.Attribute)):
+                    continue
+
+                value = subscript.slice
+                if (
+                    not isinstance(value, nodes.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, nodes.Assign)
+                    and subscript in subscript.parent.targets
+                    or isinstance(subscript.parent, nodes.AugAssign)
+                    and subscript == subscript.parent.target
+                ):
+                    # Ignore this subscript if it is the target of an assignment
+                    # Early termination as dict index lookup is necessary
+                    return
+
+                self.add_message("consider-using-dict-items", node=node)
+                return
+
+    @utils.check_messages(
+        "consider-using-dict-items",
+        "use-sequence-for-iteration",
+    )
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        self._check_consider_using_dict_items_comprehension(node)
+        self._check_use_sequence_for_iteration(node)
+
+    def _check_consider_using_dict_items_comprehension(
+        self, node: nodes.Comprehension
+    ) -> None:
+        """Add message when accessing dict values by index lookup."""
+        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(nodes.Subscript):
+                if not isinstance(subscript.value, (nodes.Name, nodes.Attribute)):
+                    continue
+
+                value = subscript.slice
+                if (
+                    not isinstance(value, nodes.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
+
+    def _check_use_sequence_for_iteration(
+        self, node: Union[nodes.For, nodes.Comprehension]
+    ) -> None:
+        """Check if code iterates over an in-place defined set."""
+        if isinstance(node.iter, nodes.Set):
+            self.add_message("use-sequence-for-iteration", node=node.iter)
+
+    @utils.check_messages("consider-using-f-string")
+    def visit_const(self, node: nodes.Const) -> None:
+        if node.pytype() == "builtins.str" and not isinstance(
+            node.parent, nodes.JoinedStr
+        ):
+            self._detect_replacable_format_call(node)
+
+    def _detect_replacable_format_call(self, node: nodes.Const) -> None:
+        """Check whether a string is used in a call to format() or '%' and whether it
+        can be replaced by a f-string"""
+        if (
+            isinstance(node.parent, nodes.Attribute)
+            and node.parent.attrname == "format"
+        ):
+            # Allow assigning .format to a variable
+            if isinstance(node.parent.parent, nodes.Assign):
+                return
+
+            if node.parent.parent.args:
+                for arg in node.parent.parent.args:
+                    # If star expressions with more than 1 element are being used
+                    if isinstance(arg, nodes.Starred):
+                        inferred = utils.safe_infer(arg.value)
+                        if (
+                            isinstance(inferred, astroid.List)
+                            and len(inferred.elts) > 1
+                        ):
+                            return
+
+            elif node.parent.parent.keywords:
+                keyword_args = [
+                    i[0] for i in utils.parse_format_method_string(node.value)[0]
+                ]
+                for keyword in node.parent.parent.keywords:
+                    # If keyword is used multiple times
+                    if keyword_args.count(keyword.arg) > 1:
+                        return
+
+                    keyword = utils.safe_infer(keyword.value)
+
+                    # If lists of more than one element are being unpacked
+                    if isinstance(keyword, nodes.Dict):
+                        if len(keyword.items) > 1 and len(keyword_args) > 1:
+                            return
+
+            # If all tests pass, then raise message
+            self.add_message(
+                "consider-using-f-string",
+                node=node,
+                line=node.lineno,
+                col_offset=node.col_offset,
+            )
+
+        elif isinstance(node.parent, nodes.BinOp) and node.parent.op == "%":
+            inferred_right = utils.safe_infer(node.parent.right)
+
+            # If dicts or lists of length > 1 are used
+            if isinstance(inferred_right, nodes.Dict):
+                if len(inferred_right.items) > 1:
+                    return
+            elif isinstance(inferred_right, nodes.List):
+                if len(inferred_right.elts) > 1:
+                    return
+
+            # If all tests pass, then raise message
+            self.add_message(
+                "consider-using-f-string",
+                node=node,
+                line=node.lineno,
+                col_offset=node.col_offset,
+            )
diff --git a/pylint/checkers/refactoring/refactoring_checker.py b/pylint/checkers/refactoring/refactoring_checker.py
new file mode 100644
index 000000000..763c65d46
--- /dev/null
+++ b/pylint/checkers/refactoring/refactoring_checker.py
@@ -0,0 +1,1933 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import collections
+import copy
+import itertools
+import tokenize
+from functools import reduce
+from typing import Dict, Iterator, List, NamedTuple, Optional, Tuple, Union
+
+import astroid
+from astroid import nodes
+from astroid.util import Uninferable
+
+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",
+        "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: nodes.Call) -> bool:
+    frame = node.frame()
+    if not isinstance(
+        frame, (nodes.FunctionDef, astroid.BoundMethod, astroid.UnboundMethod)
+    ):
+        return False
+    return frame.name == "__enter__" or utils.decorated_with(
+        frame, "contextlib.contextmanager"
+    )
+
+
+def _is_a_return_statement(node: nodes.Call) -> bool:
+    frame = node.frame()
+    parent = node.parent
+    while parent is not frame:
+        if isinstance(parent, nodes.Return):
+            return True
+        parent = parent.parent
+    return False
+
+
+def _is_part_of_with_items(node: nodes.Call) -> bool:
+    """
+    Checks if one of the node's parents is a ``nodes.With`` node and that the node itself is located
+    somewhere under its ``items``.
+    """
+    frame = node.frame()
+    current = node
+    while current != frame:
+        if isinstance(current, nodes.With):
+            items_start = current.items[0][0].lineno
+            items_end = current.items[-1][0].tolineno
+            return items_start <= node.lineno <= items_end
+        current = current.parent
+    return False
+
+
+def _will_be_released_automatically(node: nodes.Call) -> bool:
+    """Checks if a call that could be used in a ``with`` statement is used in an alternative
+    construct which would ensure that its __exit__ method is called."""
+    callables_taking_care_of_exit = frozenset(
+        (
+            "contextlib._BaseExitStack.enter_context",
+            "contextlib.ExitStack.enter_context",  # necessary for Python 3.6 compatibility
+        )
+    )
+    if not isinstance(node.parent, nodes.Call):
+        return False
+    func = utils.safe_infer(node.parent.func)
+    if not func:
+        return False
+    return func.qname() in callables_taking_care_of_exit
+
+
+class ConsiderUsingWithStack(NamedTuple):
+    """Stack for objects that may potentially trigger a R1732 message
+    if they are not used in a ``with`` block later on."""
+
+    module_scope: Dict[str, nodes.NodeNG] = {}
+    class_scope: Dict[str, nodes.NodeNG] = {}
+    function_scope: Dict[str, nodes.NodeNG] = {}
+
+    def __iter__(self) -> Iterator[Dict[str, nodes.NodeNG]]:
+        yield from (self.function_scope, self.class_scope, self.module_scope)
+
+    def get_stack_for_frame(
+        self, frame: Union[nodes.FunctionDef, nodes.ClassDef, nodes.Module]
+    ):
+        """Get the stack corresponding to the scope of the given frame."""
+        if isinstance(frame, nodes.FunctionDef):
+            return self.function_scope
+        if isinstance(frame, nodes.ClassDef):
+            return self.class_scope
+        return self.module_scope
+
+    def clear_all(self) -> None:
+        """Convenience method to clear all stacks"""
+        for stack in self:
+            stack.clear()
+
+
+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.",
+        ),
+        "R1734": (
+            "Consider using [] instead of list()",
+            "use-list-literal",
+            "Emitted when using list() to create an empty list instead of the literal []. "
+            "The literal is faster as it avoids an additional function call.",
+        ),
+        "R1735": (
+            "Consider using {} instead of dict()",
+            "use-dict-literal",
+            "Emitted when using dict() to create an empty dictionary instead of the literal {}. "
+            "The literal is faster as it avoids an additional function call.",
+        ),
+    }
+    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._consider_using_with_stack = ConsiderUsingWithStack()
+        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
+        self._consider_using_with_stack.clear_all()
+
+    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, nodes.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, nodes.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, nodes.Return):
+            if not isinstance(else_branch, nodes.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, nodes.Assign):
+            if not isinstance(else_branch, nodes.Assign):
+                return
+
+            # Check if we assign to the same value
+            first_branch_targets = [
+                target.name
+                for target in first_branch.targets
+                if isinstance(target, nodes.AssignName)
+            ]
+            else_branch_targets = [
+                target.name
+                for target in else_branch.targets
+                if isinstance(target, nodes.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])
+
+    @utils.check_messages("consider-using-with")
+    def leave_module(self, _: nodes.Module) -> None:
+        # check for context managers that have been created but not used
+        self._emit_consider_using_with_if_needed(
+            self._consider_using_with_stack.module_scope
+        )
+        self._init()
+
+    @utils.check_messages("too-many-nested-blocks")
+    def visit_tryexcept(self, node: nodes.TryExcept) -> None:
+        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, nodes.FunctionDef):
+            return
+
+        for defined_argument in scope.args.nodes_of_class(
+            nodes.AssignName, skip_klass=(nodes.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: nodes.For) -> None:
+        self._check_nested_blocks(node)
+        self._check_unnecessary_dict_index_lookup(node)
+
+        for name in node.target.nodes_of_class(nodes.AssignName):
+            self._check_redefined_argument_from_local(name)
+
+    @utils.check_messages("redefined-argument-from-local")
+    def visit_excepthandler(self, node: nodes.ExceptHandler) -> None:
+        if node.name and isinstance(node.name, nodes.AssignName):
+            self._check_redefined_argument_from_local(node.name)
+
+    @utils.check_messages("redefined-argument-from-local")
+    def visit_with(self, node: nodes.With) -> None:
+        for var, names in node.items:
+            if isinstance(var, nodes.Name):
+                for stack in self._consider_using_with_stack:
+                    # We don't need to restrict the stacks we search to the current scope and outer scopes,
+                    # as e.g. the function_scope stack will be empty when we check a ``with`` on the class level.
+                    if var.name in stack:
+                        del stack[var.name]
+                        break
+            if not names:
+                continue
+            for name in names.nodes_of_class(nodes.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=nodes.Return
+        )
+
+    def _check_superfluous_else_raise(self, node):
+        return self._check_superfluous_else(
+            node, msg_id="no-else-raise", returning_node_class=nodes.Raise
+        )
+
+    def _check_superfluous_else_break(self, node):
+        return self._check_superfluous_else(
+            node, msg_id="no-else-break", returning_node_class=nodes.Break
+        )
+
+    def _check_superfluous_else_continue(self, node):
+        return self._check_superfluous_else(
+            node, msg_id="no-else-continue", returning_node_class=nodes.Continue
+        )
+
+    @staticmethod
+    def _type_and_name_are_equal(node_a, node_b):
+        for _type in (nodes.Name, nodes.AssignName):
+            if all(isinstance(_node, _type) for _node in (node_a, node_b)):
+                return node_a.name == node_b.name
+        if all(isinstance(_node, nodes.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, nodes.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, nodes.Assign)
+            and len(node.body[0].targets) == 1
+            and isinstance(node.body[0].targets[0], nodes.AssignName)
+            and isinstance(stmt.value, nodes.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]), nodes.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], nodes.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: nodes.If) -> None:
+        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: nodes.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, nodes.Compare)
+            and not isinstance(target, nodes.Subscript)
+            and not isinstance(node.test.left, nodes.Subscript)
+            and isinstance(body, nodes.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, (nodes.Name, nodes.Const)):
+            return
+
+        operator, right_statement = node.test.ops[0]
+        if isinstance(body.value, nodes.Name):
+            body_value = body.value.name
+        else:
+            body_value = body.value.value
+
+        if isinstance(right_statement, nodes.Name):
+            right_statement_value = right_statement.name
+        elif isinstance(right_statement, nodes.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: nodes.IfExp) -> None:
+        self._check_simplifiable_ifexp(node)
+
+    def _check_simplifiable_ifexp(self, node):
+        if not isinstance(node.body, nodes.Const) or not isinstance(
+            node.orelse, nodes.Const
+        ):
+            return
+
+        if not isinstance(node.body.value, bool) or not isinstance(
+            node.orelse.value, bool
+        ):
+            return
+
+        if isinstance(node.test, nodes.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",
+        "consider-using-with",
+    )
+    def leave_functiondef(self, node: nodes.FunctionDef) -> None:
+        # 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] = []
+        # check for context managers that have been created but not used
+        self._emit_consider_using_with_if_needed(
+            self._consider_using_with_stack.function_scope
+        )
+        self._consider_using_with_stack.function_scope.clear()
+
+    @utils.check_messages("consider-using-with")
+    def leave_classdef(self, _: nodes.ClassDef) -> None:
+        # check for context managers that have been created but not used
+        self._emit_consider_using_with_if_needed(
+            self._consider_using_with_stack.class_scope
+        )
+        self._consider_using_with_stack.class_scope.clear()
+
+    @utils.check_messages("stop-iteration-return")
+    def visit_raise(self, node: nodes.Raise) -> None:
+        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, nodes.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, nodes.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, nodes.Name)
+            and node.args
+            and isinstance(node.args[0], nodes.ListComp)
+        ):
+            if node.func.name == "dict" and not isinstance(
+                node.args[0].elt, nodes.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, nodes.Call)
+            and node.func
+            and isinstance(node.func, nodes.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], nodes.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",
+        "use-list-literal",
+        "use-dict-literal",
+    )
+    def visit_call(self, node: nodes.Call) -> None:
+        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)
+        self._check_use_list_or_dict_literal(node)
+
+    @staticmethod
+    def _has_exit_in_scope(scope):
+        exit_func = scope.locals.get("exit")
+        return bool(
+            exit_func and isinstance(exit_func[0], (nodes.ImportFrom, nodes.Import))
+        )
+
+    def _check_quit_exit_call(self, node):
+
+        if isinstance(node.func, nodes.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, nodes.Name) or node.func.name != "super":
+            return
+
+        # pylint: disable=too-many-boolean-expressions
+        if (
+            len(node.args) != 2
+            or not isinstance(node.args[1], nodes.Name)
+            or node.args[1].name != "self"
+            or not isinstance(node.args[0], nodes.Name)
+            or not isinstance(node.args[1], nodes.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:`nodes.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, nodes.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, nodes.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(), nodes.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, nodes.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),
+            )
+
+    def _emit_consider_using_with_if_needed(self, stack: Dict[str, nodes.NodeNG]):
+        for node in stack.values():
+            self.add_message("consider-using-with", node=node)
+
+    @staticmethod
+    def _duplicated_isinstance_types(node):
+        """Get the duplicated types from the underlying isinstance calls.
+
+        :param nodes.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, nodes.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, nodes.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, nodes.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, nodes.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, (nodes.Name, nodes.Attribute)):
+                    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, nodes.Name):
+                        value = operand.name
+                    elif isinstance(operand, nodes.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, nodes.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(nodes.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 [nodes.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, nodes.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(nodes.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: nodes.BoolOp) -> None:
+        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, nodes.Assign)
+            and len(node.targets) == 1
+            and isinstance(node.targets[0], nodes.AssignName)
+            and isinstance(node.value, nodes.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",
+        "consider-using-with",
+    )
+    def visit_assign(self, node: nodes.Assign) -> None:
+        self._append_context_managers_to_stack(node)
+        self.visit_return(node)  # remaining checks are identical as for return nodes
+
+    @utils.check_messages(
+        "simplify-boolean-expression",
+        "consider-using-ternary",
+        "consider-swap-variables",
+    )
+    def visit_return(self, node: nodes.Return) -> None:
+        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, nodes.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 = f"{truth_value.as_string()} if {cond.as_string()} else {false_value.as_string()}"
+        self.add_message(message, node=node, args=(suggestion,))
+
+    def _append_context_managers_to_stack(self, node: nodes.Assign) -> None:
+        if _is_inside_context_manager(node):
+            # if we are inside a context manager itself, we assume that it will handle the resource management itself.
+            return
+        if isinstance(node.targets[0], (nodes.Tuple, nodes.List, nodes.Set)):
+            assignees = node.targets[0].elts
+            value = utils.safe_infer(node.value)
+            if value is None or not hasattr(value, "elts"):
+                # We cannot deduce what values are assigned, so we have to skip this
+                return
+            values = value.elts
+        else:
+            assignees = [node.targets[0]]
+            values = [node.value]
+        if Uninferable in (assignees, values):
+            return
+        for assignee, value in zip(assignees, values):
+            if not isinstance(value, nodes.Call):
+                continue
+            inferred = utils.safe_infer(value.func)
+            if (
+                not inferred
+                or inferred.qname() not in CALLS_RETURNING_CONTEXT_MANAGERS
+                or not isinstance(assignee, (nodes.AssignName, nodes.AssignAttr))
+            ):
+                continue
+            stack = self._consider_using_with_stack.get_stack_for_frame(node.frame())
+            varname = (
+                assignee.name
+                if isinstance(assignee, nodes.AssignName)
+                else assignee.attrname
+            )
+            if varname in stack:
+                existing_node = stack[varname]
+                if astroid.are_exclusive(node, existing_node):
+                    # only one of the two assignments can be executed at runtime, thus it is fine
+                    stack[varname] = value
+                    continue
+                # variable was redefined before it was used in a ``with`` block
+                self.add_message(
+                    "consider-using-with",
+                    node=existing_node,
+                )
+            stack[varname] = value
+
+    def _check_consider_using_with(self, node: nodes.Call):
+        if _is_inside_context_manager(node) or _is_a_return_statement(node):
+            # If we are inside a context manager itself, we assume that it will handle the resource management itself.
+            # If the node is a child of a return, we assume that the caller knows he is getting a context manager
+            # he should use properly (i.e. in a ``with``).
+            return
+        if (
+            node
+            in self._consider_using_with_stack.get_stack_for_frame(
+                node.frame()
+            ).values()
+        ):
+            # the result of this call was already assigned to a variable and will be checked when leaving the scope.
+            return
+        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 _is_part_of_with_items(node)
+            )
+        )
+        if could_be_used_in_with and not _will_be_released_automatically(node):
+            self.add_message("consider-using-with", node=node)
+
+    def _check_use_list_or_dict_literal(self, node: nodes.Call) -> None:
+        """Check if empty list or dict is created by using the literal [] or {}"""
+        if node.as_string() in ("list()", "dict()"):
+            inferred = utils.safe_infer(node.func)
+            if isinstance(inferred, nodes.ClassDef) and not node.args:
+                if inferred.qname() == "builtins.list":
+                    self.add_message("use-list-literal", node=node)
+                elif inferred.qname() == "builtins.dict" and not node.keywords:
+                    self.add_message("use-dict-literal", 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, nodes.For) or len(for_loop.body) > 1:
+            return
+        assign = for_loop.previous_sibling()
+        if not isinstance(assign, nodes.Assign):
+            return
+        result_assign_names = {
+            target.name
+            for target in assign.targets
+            if isinstance(target, nodes.AssignName)
+        }
+
+        is_concat_loop = (
+            aug_assign.op == "+="
+            and isinstance(aug_assign.target, nodes.AssignName)
+            and len(for_loop.body) == 1
+            and aug_assign.target.name in result_assign_names
+            and isinstance(assign.value, nodes.Const)
+            and isinstance(assign.value.value, str)
+            and isinstance(aug_assign.value, nodes.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: nodes.AugAssign) -> None:
+        self._check_consider_using_join(node)
+
+    @utils.check_messages("unnecessary-comprehension", "unnecessary-dict-index-lookup")
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        self._check_unnecessary_comprehension(node)
+        self._check_unnecessary_dict_index_lookup(node)
+
+    def _check_unnecessary_comprehension(self, node: nodes.Comprehension) -> None:
+        if (
+            isinstance(node.parent, nodes.GeneratorExp)
+            or len(node.ifs) != 0
+            or len(node.parent.generators) != 1
+            or node.is_async
+        ):
+            return
+
+        if (
+            isinstance(node.parent, nodes.DictComp)
+            and isinstance(node.parent.key, nodes.Name)
+            and isinstance(node.parent.value, nodes.Name)
+            and isinstance(node.target, nodes.Tuple)
+            and all(isinstance(elt, nodes.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, (nodes.ListComp, nodes.SetComp)):
+            expr = node.parent.elt
+            if isinstance(expr, nodes.Name):
+                expr_list = expr.name
+            elif isinstance(expr, nodes.Tuple):
+                if any(not isinstance(elt, nodes.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, nodes.AssignName)
+                else (
+                    [
+                        elt.name
+                        for elt in target.elts
+                        if isinstance(elt, nodes.AssignName)
+                    ]
+                    if isinstance(target, nodes.Tuple)
+                    else []
+                )
+            )
+        else:
+            return
+        if expr_list == target_list != []:
+            args: Optional[Tuple[str]] = None
+            inferred = utils.safe_infer(node.iter)
+            if isinstance(node.parent, nodes.DictComp) and isinstance(
+                inferred, astroid.objects.DictItems
+            ):
+                args = (f"{node.iter.func.expr.as_string()}",)
+            elif (
+                isinstance(node.parent, nodes.ListComp)
+                and isinstance(inferred, nodes.List)
+            ) or (
+                isinstance(node.parent, nodes.SetComp)
+                and isinstance(inferred, nodes.Set)
+            ):
+                args = (f"{node.iter.as_string()}",)
+            if args:
+                self.add_message("unnecessary-comprehension", node=node, args=args)
+                return
+
+            if isinstance(node.parent, nodes.DictComp):
+                func = "dict"
+            elif isinstance(node.parent, nodes.ListComp):
+                func = "list"
+            elif isinstance(node.parent, nodes.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, nodes.BoolOp)
+            and node.op == "or"
+            and len(node.values) == 2
+            and isinstance(node.values[0], nodes.BoolOp)
+            and not isinstance(node.values[1], nodes.BoolOp)
+            and node.values[0].op == "and"
+            and not isinstance(node.values[0].values[1], nodes.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: nodes.FunctionDef) -> None:
+        self._return_nodes[node.name] = list(
+            node.nodes_of_class(nodes.Return, skip_klass=nodes.FunctionDef)
+        )
+
+    def _check_consistent_returns(self, node: nodes.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 (nodes.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: nodes.If) -> bool:
+        """Check if the If node ends with an explicit return statement.
+
+        Args:
+            node (nodes.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, nodes.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, nodes.FunctionDef)
+        )
+        return is_if_returning and is_orelse_returning
+
+    def _is_raise_node_return_ended(self, node: nodes.Raise) -> bool:
+        """Check if the Raise node ends with an explicit return statement.
+
+        Args:
+            node (nodes.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: nodes.NodeNG) -> bool:
+        """Check if the node ends with an explicit return statement.
+
+        Args:
+            node (nodes.NodeNG): node to be checked.
+
+        Returns:
+            bool: True if the node ends with an explicit statement, False otherwise.
+
+        """
+        # Recursion base case
+        if isinstance(node, nodes.Return):
+            return True
+        if isinstance(node, nodes.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, nodes.While):
+            return True
+        if isinstance(node, nodes.Raise):
+            return self._is_raise_node_return_ended(node)
+        if isinstance(node, nodes.If):
+            return self._is_if_node_return_ended(node)
+        if isinstance(node, nodes.TryExcept):
+            handlers = {
+                _child
+                for _child in node.get_children()
+                if isinstance(_child, nodes.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, nodes.Assert)
+            and isinstance(node.test, nodes.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: nodes.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, nodes.Return):
+                return True
+            next_sibling = next_sibling.next_sibling()
+        return False
+
+    def _is_function_def_never_returning(self, node: nodes.FunctionDef) -> bool:
+        """Return True if the function never returns. False otherwise.
+
+        Args:
+            node (nodes.FunctionDef): function definition node to be analyzed.
+
+        Returns:
+            bool: True if the function never returns, False otherwise.
+        """
+        if isinstance(node, nodes.FunctionDef) and node.returns:
+            return (
+                isinstance(node.returns, nodes.Attribute)
+                and node.returns.attrname == "NoReturn"
+                or isinstance(node.returns, nodes.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, nodes.Return):
+            # e.g. "return"
+            if last.value is None:
+                self.add_message("useless-return", node=node)
+            # return None"
+            elif isinstance(last.value, nodes.Const) and (last.value.value is None):
+                self.add_message("useless-return", node=node)
+
+    def _check_unnecessary_dict_index_lookup(
+        self, node: Union[nodes.For, nodes.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, nodes.Call)
+            and isinstance(node.iter.func, nodes.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, nodes.For) else node.parent.get_children()
+            )
+            for child in children:
+                for subscript in child.nodes_of_class(nodes.Subscript):
+                    if not isinstance(subscript.value, (nodes.Name, nodes.Attribute)):
+                        continue
+
+                    value = subscript.slice
+
+                    if isinstance(node, nodes.For) and (
+                        isinstance(subscript.parent, nodes.Assign)
+                        and subscript in subscript.parent.targets
+                        or isinstance(subscript.parent, nodes.AugAssign)
+                        and subscript == subscript.parent.target
+                    ):
+                        # Ignore this subscript if it is the target of an assignment
+                        # Early termination; after reassignment dict index lookup will be necessary
+                        return
+
+                    # Case where .items is assigned to k,v (i.e., for k, v in d.items())
+                    if isinstance(value, nodes.Name):
+                        if (
+                            not isinstance(node.target, nodes.Tuple)
+                            or value.name != node.target.elts[0].name
+                            or iterating_object_name != subscript.value.as_string()
+                        ):
+                            continue
+
+                        if (
+                            isinstance(node, nodes.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, nodes.Subscript):
+                        if (
+                            not isinstance(node.target, nodes.AssignName)
+                            or node.target.name != value.value.name
+                            or iterating_object_name != subscript.value.as_string()
+                        ):
+                            continue
+
+                        if (
+                            isinstance(node, nodes.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, nodes.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 000000000..42d407171
--- /dev/null
+++ b/pylint/checkers/similar.py
@@ -0,0 +1,950 @@
+# 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-2021 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2020 Eli Fine <ejfine@gmail.com>
+# Copyright (c) 2020 Shiv Venkatasubrahmanyam <shvenkat@users.noreply.github.com>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Maksym Humetskyi <Humetsky@gmail.com>
+# Copyright (c) 2021 bot <bot@noreply.github.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/main/LICENSE
+
+# pylint: disable=redefined-builtin
+"""a similarities / code duplication command line tool and pylint checker
+
+The algorithm is based on comparing the hash value of n successive lines of a file.
+First the files are read and any line that doesn't fullfill requirement are removed (comments, docstrings...)
+Those stripped lines are stored in the LineSet class which gives access to them.
+Then each index of the stripped lines collection is associated with the hash of n successive entries of the stripped lines starting at the current index
+(n is the minimum common lines option).
+The common hashes between both linesets are then looked for. If there are matches, then the match indices in both linesets are stored and associated
+with the corresponding couples (start line number/end line number) in both files.
+This association is then postprocessed to handle the case of successive matches. For example if the minimum common lines setting is set to four, then
+the hashes are computed with four lines. If one of match indices couple (12, 34) is the successor of another one (11, 33) then it means that there are
+in fact five lines wich are common.
+Once postprocessed the values of association table are the result looked for, i.e start and end lines numbers of common lines in both files.
+"""
+import copy
+import functools
+import itertools
+import operator
+import re
+import sys
+from collections import defaultdict
+from getopt import getopt
+from io import BufferedIOBase, BufferedReader, BytesIO
+from itertools import chain, groupby
+from typing import (
+    Any,
+    Dict,
+    FrozenSet,
+    Generator,
+    Iterable,
+    List,
+    NamedTuple,
+    NewType,
+    Optional,
+    Set,
+    TextIO,
+    Tuple,
+    Union,
+)
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, MapReduceMixin, table_lines_from_stats
+from pylint.interfaces import IRawChecker
+from pylint.reporters.ureports.nodes import Table
+from pylint.typing import CheckerStats
+from pylint.utils import decoding_stream
+
+DEFAULT_MIN_SIMILARITY_LINE = 4
+
+REGEX_FOR_LINES_WITH_CONTENT = re.compile(r".*\w+")
+
+# Index defines a location in a LineSet stripped lines collection
+Index = NewType("Index", int)
+
+# LineNumber defines a location in a LinesSet real lines collection (the whole file lines)
+LineNumber = NewType("LineNumber", int)
+
+
+# LineSpecifs holds characteristics of a line in a file
+class LineSpecifs(NamedTuple):
+    line_number: LineNumber
+    text: str
+
+
+# Links LinesChunk object to the starting indices (in lineset's stripped lines)
+# of the different chunk of lines that are used to compute the hash
+HashToIndex_T = Dict["LinesChunk", List[Index]]
+
+# Links index in the lineset's stripped lines to the real lines in the file
+IndexToLines_T = Dict[Index, "SuccessiveLinesLimits"]
+
+# The types the streams read by pylint can take. Originating from astroid.nodes.Module.stream() and open()
+STREAM_TYPES = Union[TextIO, BufferedReader, BytesIO]
+
+
+class CplSuccessiveLinesLimits:
+    """
+    This class holds a couple of SuccessiveLinesLimits objects, one for each file compared,
+    and a counter on the number of common lines between both stripped lines collections extracted
+    from both files
+    """
+
+    __slots__ = ("first_file", "second_file", "effective_cmn_lines_nb")
+
+    def __init__(
+        self,
+        first_file: "SuccessiveLinesLimits",
+        second_file: "SuccessiveLinesLimits",
+        effective_cmn_lines_nb: int,
+    ) -> None:
+        self.first_file = first_file
+        self.second_file = second_file
+        self.effective_cmn_lines_nb = effective_cmn_lines_nb
+
+
+# Links the indices ot the starting line in both lineset's stripped lines to
+# the start and end lines in both files
+CplIndexToCplLines_T = Dict["LineSetStartCouple", CplSuccessiveLinesLimits]
+
+
+class LinesChunk:
+    """
+    The LinesChunk object computes and stores the hash of some consecutive stripped lines of a lineset.
+    """
+
+    __slots__ = ("_fileid", "_index", "_hash")
+
+    def __init__(self, fileid: str, num_line: int, *lines: Iterable[str]) -> None:
+        self._fileid: str = fileid
+        """The name of the file from which the LinesChunk object is generated """
+
+        self._index: Index = Index(num_line)
+        """The index in the stripped lines that is the starting of consecutive lines"""
+
+        self._hash: int = sum(hash(lin) for lin in lines)
+        """The hash of some consecutive lines"""
+
+    def __eq__(self, o: Any) -> bool:
+        if not isinstance(o, LinesChunk):
+            return NotImplemented
+        return self._hash == o._hash
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def __repr__(self) -> str:
+        return (
+            f"<LinesChunk object for file {self._fileid} ({self._index}, {self._hash})>"
+        )
+
+    def __str__(self) -> str:
+        return (
+            f"LinesChunk object for file {self._fileid}, starting at line {self._index} \n"
+            f"Hash is {self._hash}"
+        )
+
+
+class SuccessiveLinesLimits:
+    """
+    A class to handle the numbering of begin and end of successive lines.
+
+    :note: Only the end line number can be updated.
+    """
+
+    __slots__ = ("_start", "_end")
+
+    def __init__(self, start: LineNumber, end: LineNumber) -> None:
+        self._start: LineNumber = start
+        self._end: LineNumber = end
+
+    @property
+    def start(self) -> LineNumber:
+        return self._start
+
+    @property
+    def end(self) -> LineNumber:
+        return self._end
+
+    @end.setter
+    def end(self, value: LineNumber) -> None:
+        self._end = value
+
+    def __repr__(self) -> str:
+        return f"<SuccessiveLinesLimits <{self._start};{self._end}>>"
+
+
+class LineSetStartCouple(NamedTuple):
+    """
+    Indices in both linesets that mark the beginning of successive lines
+    """
+
+    fst_lineset_index: Index
+    snd_lineset_index: Index
+
+    def __repr__(self) -> str:
+        return (
+            f"<LineSetStartCouple <{self.fst_lineset_index};{self.snd_lineset_index}>>"
+        )
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, LineSetStartCouple):
+            return NotImplemented
+        return (
+            self.fst_lineset_index == other.fst_lineset_index
+            and self.snd_lineset_index == other.snd_lineset_index
+        )
+
+    def __hash__(self) -> int:
+        return hash(self.fst_lineset_index) + hash(self.snd_lineset_index)
+
+    def increment(self, value: Index) -> "LineSetStartCouple":
+        return LineSetStartCouple(
+            Index(self.fst_lineset_index + value),
+            Index(self.snd_lineset_index + value),
+        )
+
+
+LinesChunkLimits_T = Tuple["LineSet", LineNumber, LineNumber]
+
+
+def hash_lineset(
+    lineset: "LineSet", min_common_lines: int = DEFAULT_MIN_SIMILARITY_LINE
+) -> Tuple[HashToIndex_T, IndexToLines_T]:
+    """
+    Return two dicts. The first associates the hash of successive stripped lines of a lineset
+    to the indices of the starting lines.
+    The second dict, associates the index of the starting line in the lineset's stripped lines to the
+    couple [start, end] lines number in the corresponding file.
+
+    :param lineset: lineset object (i.e the lines in a file)
+    :param min_common_lines: number of successive lines that are used to compute the hash
+    :return: a dict linking hashes to corresponding start index and a dict that links this
+             index to the start and end lines in the file
+    """
+    hash2index = defaultdict(list)
+    index2lines = {}
+    # Comments, docstring and other specific patterns maybe excluded -> call to stripped_lines
+    # to get only what is desired
+    lines = tuple(x.text for x in lineset.stripped_lines)
+    # Need different iterators on same lines but each one is shifted 1 from the precedent
+    shifted_lines = [iter(lines[i:]) for i in range(min_common_lines)]
+
+    for index_i, *succ_lines in enumerate(zip(*shifted_lines)):
+        start_linenumber = lineset.stripped_lines[index_i].line_number
+        try:
+            end_linenumber = lineset.stripped_lines[
+                index_i + min_common_lines
+            ].line_number
+        except IndexError:
+            end_linenumber = lineset.stripped_lines[-1].line_number + 1
+
+        index = Index(index_i)
+        index2lines[index] = SuccessiveLinesLimits(
+            start=LineNumber(start_linenumber), end=LineNumber(end_linenumber)
+        )
+
+        l_c = LinesChunk(lineset.name, index, *succ_lines)
+        hash2index[l_c].append(index)
+
+    return hash2index, index2lines
+
+
+def remove_successives(all_couples: CplIndexToCplLines_T) -> None:
+    """
+    Removes all successive entries in the dictionary in argument
+
+    :param all_couples: collection that has to be cleaned up from successives entries.
+                        The keys are couples of indices that mark the beginning of common entries
+                        in both linesets. The values have two parts. The first one is the couple
+                        of starting and ending line numbers of common successives lines in the first file.
+                        The second part is the same for the second file.
+
+    For example consider the following dict:
+
+    >>> all_couples
+    {(11, 34): ([5, 9], [27, 31]),
+     (23, 79): ([15, 19], [45, 49]),
+     (12, 35): ([6, 10], [28, 32])}
+
+    There are two successives keys (11, 34) and (12, 35).
+    It means there are two consecutive similar chunks of lines in both files.
+    Thus remove last entry and update the last line numbers in the first entry
+
+    >>> remove_successives(all_couples)
+    >>> all_couples
+    {(11, 34): ([5, 10], [27, 32]),
+     (23, 79): ([15, 19], [45, 49])}
+    """
+    couple: LineSetStartCouple
+    for couple in tuple(all_couples.keys()):
+        to_remove = []
+        test = couple.increment(Index(1))
+        while test in all_couples:
+            all_couples[couple].first_file.end = all_couples[test].first_file.end
+            all_couples[couple].second_file.end = all_couples[test].second_file.end
+            all_couples[couple].effective_cmn_lines_nb += 1
+            to_remove.append(test)
+            test = test.increment(Index(1))
+
+        for target in to_remove:
+            try:
+                all_couples.pop(target)
+            except KeyError:
+                pass
+
+
+def filter_noncode_lines(
+    ls_1: "LineSet",
+    stindex_1: Index,
+    ls_2: "LineSet",
+    stindex_2: Index,
+    common_lines_nb: int,
+) -> int:
+    """
+    Return the effective number of common lines between lineset1 and lineset2 filtered from non code lines, that is to say the number of
+    common successive stripped lines except those that do not contain code (for example a ligne with only an
+    ending parathensis)
+
+    :param ls_1: first lineset
+    :param stindex_1: first lineset starting index
+    :param ls_2: second lineset
+    :param stindex_2: second lineset starting index
+    :param common_lines_nb: number of common successive stripped lines before being filtered from non code lines
+    :return: the number of common successives stripped lines that contain code
+    """
+    stripped_l1 = [
+        lspecif.text
+        for lspecif in ls_1.stripped_lines[stindex_1 : stindex_1 + common_lines_nb]
+        if REGEX_FOR_LINES_WITH_CONTENT.match(lspecif.text)
+    ]
+    stripped_l2 = [
+        lspecif.text
+        for lspecif in ls_2.stripped_lines[stindex_2 : stindex_2 + common_lines_nb]
+        if REGEX_FOR_LINES_WITH_CONTENT.match(lspecif.text)
+    ]
+    return sum(sline_1 == sline_2 for sline_1, sline_2 in zip(stripped_l1, stripped_l2))
+
+
+class Commonality(NamedTuple):
+    cmn_lines_nb: int
+    fst_lset: "LineSet"
+    fst_file_start: LineNumber
+    fst_file_end: LineNumber
+    snd_lset: "LineSet"
+    snd_file_start: LineNumber
+    snd_file_end: LineNumber
+
+
+class Similar:
+    """finds copy-pasted lines of code in a project"""
+
+    def __init__(
+        self,
+        min_lines: int = DEFAULT_MIN_SIMILARITY_LINE,
+        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: STREAM_TYPES, encoding: Optional[str] = None
+    ) -> None:
+        """append a file to search for similarities"""
+        if isinstance(stream, BufferedIOBase):
+            if encoding is None:
+                raise ValueError
+            readlines = decoding_stream(stream, encoding).readlines
+        else:
+            readlines = stream.readlines  # type: ignore # hint parameter is incorrectly typed as non-optional
+        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) -> None:
+        """start looking for similarities and display results on stdout"""
+        if self.min_lines == 0:
+            return
+        self._display_sims(self._compute_sims())
+
+    def _compute_sims(self) -> List[Tuple[int, Set[LinesChunkLimits_T]]]:
+        """compute similarities in appended files"""
+        no_duplicates: Dict[int, List[Set[LinesChunkLimits_T]]] = defaultdict(list)
+
+        for commonality in self._iter_sims():
+            num = commonality.cmn_lines_nb
+            lineset1 = commonality.fst_lset
+            start_line_1 = commonality.fst_file_start
+            end_line_1 = commonality.fst_file_end
+            lineset2 = commonality.snd_lset
+            start_line_2 = commonality.snd_file_start
+            end_line_2 = commonality.snd_file_end
+
+            duplicate = no_duplicates[num]
+            couples: Set[LinesChunkLimits_T]
+            for couples in duplicate:
+                if (lineset1, start_line_1, end_line_1) in couples or (
+                    lineset2,
+                    start_line_2,
+                    end_line_2,
+                ) in couples:
+                    break
+            else:
+                duplicate.append(
+                    {
+                        (lineset1, start_line_1, end_line_1),
+                        (lineset2, start_line_2, end_line_2),
+                    }
+                )
+        sims: List[Tuple[int, Set[LinesChunkLimits_T]]] = []
+        ensembles: List[Set[LinesChunkLimits_T]]
+        for num, ensembles in no_duplicates.items():
+            cpls: Set[LinesChunkLimits_T]
+            for cpls in ensembles:
+                sims.append((num, cpls))
+        sims.sort()
+        sims.reverse()
+        return sims
+
+    def _display_sims(
+        self, similarities: List[Tuple[int, Set[LinesChunkLimits_T]]]
+    ) -> None:
+        """Display computed similarities on stdout"""
+        report = self._get_similarity_report(similarities)
+        print(report)
+
+    def _get_similarity_report(
+        self, similarities: List[Tuple[int, Set[LinesChunkLimits_T]]]
+    ) -> str:
+        """Create a report from similarities"""
+        report: str = ""
+        duplicated_line_number: int = 0
+        for number, couples in similarities:
+            report += f"\n{number} similar lines in {len(couples)} files\n"
+            couples_l = sorted(couples)
+            line_set = start_line = end_line = None
+            for line_set, start_line, end_line in couples_l:
+                report += f"=={line_set.name}:[{start_line}:{end_line}]\n"
+            if line_set:
+                for line in line_set._real_lines[start_line:end_line]:
+                    report += f"   {line.rstrip()}\n" if line.rstrip() else "\n"
+            duplicated_line_number += number * (len(couples_l) - 1)
+        total_line_number: int = sum(len(lineset) for lineset in self.linesets)
+        report += f"TOTAL lines={total_line_number} duplicates={duplicated_line_number} percent={duplicated_line_number * 100.0 / total_line_number:.2f}\n"
+        return report
+
+    def _find_common(
+        self, lineset1: "LineSet", lineset2: "LineSet"
+    ) -> Generator[Commonality, None, None]:
+        """
+        Find similarities in the two given linesets.
+
+        This the core of the algorithm.
+        The idea is to compute the hashes of a minimal number of successive lines of each lineset and then compare the hashes.
+        Every match of such comparison is stored in a dict that links the couple of starting indices in both linesets to
+        the couple of corresponding starting and ending lines in both files.
+        Last regroups all successive couples in a bigger one. It allows to take into account common chunk of lines that have more
+        than the minimal number of successive lines required.
+        """
+        hash_to_index_1: HashToIndex_T
+        hash_to_index_2: HashToIndex_T
+        index_to_lines_1: IndexToLines_T
+        index_to_lines_2: IndexToLines_T
+        hash_to_index_1, index_to_lines_1 = hash_lineset(lineset1, self.min_lines)
+        hash_to_index_2, index_to_lines_2 = hash_lineset(lineset2, self.min_lines)
+
+        hash_1: FrozenSet[LinesChunk] = frozenset(hash_to_index_1.keys())
+        hash_2: FrozenSet[LinesChunk] = frozenset(hash_to_index_2.keys())
+
+        common_hashes: Iterable[LinesChunk] = sorted(
+            hash_1 & hash_2, key=lambda m: hash_to_index_1[m][0]
+        )
+
+        # all_couples is a dict that links the couple of indices in both linesets that mark the beginning of
+        # successive common lines, to the corresponding starting and ending number lines in both files
+        all_couples: CplIndexToCplLines_T = {}
+
+        for c_hash in sorted(common_hashes, key=operator.attrgetter("_index")):
+            for indices_in_linesets in itertools.product(
+                hash_to_index_1[c_hash], hash_to_index_2[c_hash]
+            ):
+                index_1 = indices_in_linesets[0]
+                index_2 = indices_in_linesets[1]
+                all_couples[
+                    LineSetStartCouple(index_1, index_2)
+                ] = CplSuccessiveLinesLimits(
+                    copy.copy(index_to_lines_1[index_1]),
+                    copy.copy(index_to_lines_2[index_2]),
+                    effective_cmn_lines_nb=self.min_lines,
+                )
+
+        remove_successives(all_couples)
+
+        for cml_stripped_l, cmn_l in all_couples.items():
+            start_index_1 = cml_stripped_l.fst_lineset_index
+            start_index_2 = cml_stripped_l.snd_lineset_index
+            nb_common_lines = cmn_l.effective_cmn_lines_nb
+
+            com = Commonality(
+                cmn_lines_nb=nb_common_lines,
+                fst_lset=lineset1,
+                fst_file_start=cmn_l.first_file.start,
+                fst_file_end=cmn_l.first_file.end,
+                snd_lset=lineset2,
+                snd_file_start=cmn_l.second_file.start,
+                snd_file_end=cmn_l.second_file.end,
+            )
+
+            eff_cmn_nb = filter_noncode_lines(
+                lineset1, start_index_1, lineset2, start_index_2, nb_common_lines
+            )
+
+            if eff_cmn_nb > self.min_lines:
+                yield com
+
+    def _iter_sims(self) -> Generator[Commonality, None, None]:
+        """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: Iterable[str],
+    ignore_comments: bool,
+    ignore_docstrings: bool,
+    ignore_imports: bool,
+    ignore_signatures: bool,
+) -> List[LineSpecifs]:
+    """
+    Return tuples of line/line number/line type with leading/trailing whitespace and any ignored code features removed
+
+    :param lines: a collection of lines
+    :param ignore_comments: if true, any comment in the lines collection is removed from the result
+    :param ignore_docstrings: if true, any line that is a docstring is removed from the result
+    :param ignore_imports: if true, any line that is an import is removed from the result
+    :param ignore_signatures: if true, any line that is part of a function signature is removed from the result
+    :return: the collection of line/line number/line type tuples
+    """
+    if ignore_imports or ignore_signatures:
+        tree = astroid.parse("".join(lines))
+    if ignore_imports:
+        node_is_import_by_lineno = (
+            (node.lineno, isinstance(node, (nodes.Import, nodes.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:
+
+        def _get_functions(
+            functions: List[nodes.NodeNG], tree: nodes.NodeNG
+        ) -> List[nodes.NodeNG]:
+            """Recursively get all functions including nested in the classes from the tree."""
+
+            for node in tree.body:
+                if isinstance(node, (nodes.FunctionDef, nodes.AsyncFunctionDef)):
+                    functions.append(node)
+
+                if isinstance(
+                    node,
+                    (nodes.ClassDef, nodes.FunctionDef, nodes.AsyncFunctionDef),
+                ):
+                    _get_functions(functions, node)
+
+            return functions
+
+        functions = _get_functions([], tree)
+        signature_lines = set(
+            chain(
+                *(
+                    range(
+                        func.lineno,
+                        func.body[0].lineno if func.body else func.tolineno + 1,
+                    )
+                    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 = ""
+        if line:
+            strippedlines.append(
+                LineSpecifs(text=line, line_number=LineNumber(lineno - 1))
+            )
+    return strippedlines
+
+
+@functools.total_ordering
+class LineSet:
+    """
+    Holds and indexes all the lines of a single source file.
+    Allows for correspondance between real lines of the source file and stripped ones, which
+    are the real ones from which undesired patterns have been removed.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        lines: List[str],
+        ignore_comments: bool = False,
+        ignore_docstrings: bool = False,
+        ignore_imports: bool = False,
+        ignore_signatures: bool = False,
+    ) -> None:
+        self.name = name
+        self._real_lines = lines
+        self._stripped_lines = stripped_lines(
+            lines, ignore_comments, ignore_docstrings, ignore_imports, ignore_signatures
+        )
+
+    def __str__(self):
+        return f"<Lineset for {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__
+
+    @property
+    def stripped_lines(self):
+        return self._stripped_lines
+
+    @property
+    def real_lines(self):
+        return self._real_lines
+
+
+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: CheckerStats,
+    old_stats: CheckerStats,
+):
+    """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",
+            {
+                "default": DEFAULT_MIN_SIMILARITY_LINE,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Minimum lines number of a similarity.",
+            },
+        ),
+        (
+            "ignore-comments",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Comments are removed from the similarity computation",
+            },
+        ),
+        (
+            "ignore-docstrings",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Docstrings are removed from the similarity computation",
+            },
+        ),
+        (
+            "ignore-imports",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Imports are removed from the similarity computation",
+            },
+        ),
+        (
+            "ignore-signatures",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Signatures are removed from the similarity computation",
+            },
+        ),
+    )
+    # reports
+    reports = (("RP0801", "Duplication", report_similarities),)
+
+    def __init__(self, linter=None) -> None:
+        BaseChecker.__init__(self, linter)
+        Similar.__init__(
+            self,
+            min_lines=self.config.min_similarity_lines,
+            ignore_comments=self.config.ignore_comments,
+            ignore_docstrings=self.config.ignore_docstrings,
+            ignore_imports=self.config.ignore_imports,
+            ignore_signatures=self.config.ignore_signatures,
+        )
+        self.stats: CheckerStats = {}
+
+    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: nodes.Module) -> None:
+        """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 = start_line = end_line = None
+            for lineset, start_line, end_line in couples:
+                msg.append(f"=={lineset.name}:[{start_line}:{end_line}]")
+            msg.sort()
+
+            if lineset:
+                for line in lineset.real_lines[start_line:end_line]:
+                    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)
+
+    def reduce_map_data(self, 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.min_lines = self.min_lines
+        recombined.ignore_comments = self.ignore_comments
+        recombined.ignore_docstrings = self.ignore_docstrings
+        recombined.ignore_imports = self.ignore_imports
+        recombined.ignore_signatures = self.ignore_signatures
+        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 = DEFAULT_MIN_SIMILARITY_LINE
+    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, encoding="utf-8") 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 000000000..3b2973ffa
--- /dev/null
+++ b/pylint/checkers/spelling.py
@@ -0,0 +1,476 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 bot <bot@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/main/LICENSE
+
+"""Checker for spelling errors in comments and docstrings.
+"""
+import os
+import re
+import tokenize
+from typing import Pattern
+
+from astroid import nodes
+
+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. "
+                f"Available dictionaries: {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", encoding="utf-8"
+            )
+        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(f"{lower_cased_word}\n")
+                    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(fr"(\W|^)({word})(\W|$)", 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: nodes.Module) -> None:
+        if not self.initialized:
+            return
+        self._check_docstring(node)
+
+    @check_messages("wrong-spelling-in-docstring")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        if not self.initialized:
+            return
+        self._check_docstring(node)
+
+    @check_messages("wrong-spelling-in-docstring")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        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 000000000..a4cd88a4d
--- /dev/null
+++ b/pylint/checkers/stdlib.py
@@ -0,0 +1,718 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Yilei "Dolee" Yang <yileiyang@google.com>
+# Copyright (c) 2021 Matus Valo <matusvalo@users.noreply.github.com>
+# Copyright (c) 2021 victor <16359131+jiajunsu@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/main/LICENSE
+
+"""Checkers for various standard library functions."""
+
+import sys
+from collections.abc import Iterable
+from typing import Any, Dict, Set
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, DeprecatedMixin, utils
+from pylint.interfaces import IAstroidChecker
+from pylint.lint import PyLinter
+
+OPEN_FILES_MODE = ("open", "file")
+OPEN_FILES_ENCODING = ("open", "read_text", "write_text")
+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", "pathlib"}
+DEBUG_BREAKPOINTS = ("builtins.breakpoint", "sys.breakpointhook", "pdb.set_trace")
+
+
+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: Dict = {
+    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",
+            "sqlite3.OptimizedUnicode",
+            "time.clock",
+        },
+        (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",
+            "_ssl.RAND_pseudo_bytes",
+        },
+        (3, 7, 0): {
+            "sys.set_coroutine_wrapper",
+            "sys.get_coroutine_wrapper",
+            "aifc.openfp",
+            "threading.Thread.isAlive",
+            "asyncio.Task.current_task",
+            "asyncio.Task.all_task",
+            "locale.format",
+            "ssl.wrap_socket",
+            "ssl.match_hostname",
+            "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",
+            "zipimport.zipimporter.load_module",
+            "zipimport.zipimporter.find_module",
+            "zipimport.zipimporter.find_loader",
+            "threading.currentThread",
+            "threading.activeCount",
+            "threading.Condition.notifyAll",
+            "threading.Event.isSet",
+            "threading.Thread.setName",
+            "threading.Thread.getName",
+            "threading.Thread.isDaemon",
+            "threading.Thread.setDaemon",
+            "cgi.log",
+        },
+    },
+}
+
+
+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.",
+        ),
+        "W1514": (
+            "Using open without explicitly specifying an encoding",
+            "unspecified-encoding",
+            "It is better to specify an encoding when opening documents. "
+            "Using the system default implicitly can create problems on other operating systems. "
+            "See https://www.python.org/dev/peps/pep-0597/",
+        ),
+        "W1515": (
+            "Leaving functions creating breakpoints in production code is not recommended",
+            "forgotten-debug-statement",
+            "Calls to breakpoint(), sys.breakpointhook() and pdb.set_trace() should be removed "
+            "from code that is not actively being debugged.",
+        ),
+    }
+
+    def __init__(
+        self, linter: PyLinter = None
+    ):  # pylint: disable=super-init-not-called # See https://github.com/PyCQA/pylint/issues/4941
+        BaseChecker.__init__(self, linter)
+        self._deprecated_methods: Set[Any] = 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 = {}
+        for since_vers, func_list in DEPRECATED_ARGUMENTS.items():
+            if since_vers <= sys.version_info:
+                self._deprecated_attributes.update(func_list)
+        self._deprecated_classes = {}
+        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: nodes.Call) -> None:
+        arg = utils.get_argument_from_call(node, position=0)
+        try:
+            inferred_args = arg.inferred()
+        except astroid.InferenceError:
+            return
+        for inferred in inferred_args:
+            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",
+        "unspecified-encoding",
+        "forgotten-debug-statement",
+    )
+    def visit_call(self, node: nodes.Call) -> None:
+        """Visit a Call node."""
+        self.check_deprecated_class_in_call(node)
+        for inferred in utils.infer_all(node.func):
+            if inferred is astroid.Uninferable:
+                continue
+            if inferred.root().name in OPEN_MODULE:
+                if (
+                    isinstance(node.func, nodes.Name)
+                    and node.func.name in OPEN_FILES_MODE
+                ):
+                    self._check_open_mode(node)
+                if (
+                    isinstance(node.func, nodes.Name)
+                    and node.func.name in OPEN_FILES_ENCODING
+                    or isinstance(node.func, nodes.Attribute)
+                    and node.func.attrname in OPEN_FILES_ENCODING
+                ):
+                    self._check_open_encoded(node, inferred.root().name)
+            elif inferred.root().name == UNITTEST_CASE:
+                self._check_redundant_assert(node, inferred)
+            elif isinstance(inferred, nodes.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, nodes.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)
+                elif name in DEBUG_BREAKPOINTS:
+                    self.add_message("forgotten-debug-statement", node=node)
+            self.check_deprecated_method(node, inferred)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        if node.op == "not":
+            self._check_datetime(node.operand)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_if(self, node: nodes.If) -> None:
+        self._check_datetime(node.test)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_ifexp(self, node: nodes.IfExp) -> None:
+        self._check_datetime(node.test)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_boolop(self, node: nodes.BoolOp) -> None:
+        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], nodes.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, nodes.Const) and not _check_mode_str(
+                mode_arg.value
+            ):
+                self.add_message("bad-open-mode", node=node, args=mode_arg.value)
+
+    def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
+        """Check that the encoded argument of an open call is valid."""
+        mode_arg = None
+        try:
+            if open_module == "_io":
+                mode_arg = utils.get_argument_from_call(
+                    node, position=1, keyword="mode"
+                )
+            elif open_module == "pathlib":
+                mode_arg = utils.get_argument_from_call(
+                    node, position=0, keyword="mode"
+                )
+        except utils.NoSuchArgumentError:
+            pass
+
+        if mode_arg:
+            mode_arg = utils.safe_infer(mode_arg)
+        if not mode_arg or "b" not in mode_arg.value:
+            encoding_arg = None
+            try:
+                encoding_arg = utils.get_argument_from_call(
+                    node, position=None, keyword="encoding"
+                )
+            except utils.NoSuchArgumentError:
+                self.add_message("unspecified-encoding", node=node)
+
+            if encoding_arg:
+                encoding_arg = utils.safe_infer(encoding_arg)
+
+                if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
+                    self.add_message("unspecified-encoding", node=node)
+
+    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, nodes.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 000000000..f983e8afe
--- /dev/null
+++ b/pylint/checkers/strings.py
@@ -0,0 +1,1012 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Checker for string formatting operations.
+"""
+
+import collections
+import numbers
+import re
+import tokenize
+from typing import TYPE_CHECKING, Iterable
+
+import astroid
+from astroid import nodes
+
+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(f"({'|'.join(_PREFIXES)})?'''")
+DOUBLE_QUOTED_REGEX = re.compile(f"({'|'.join(_PREFIXES)})?\"\"\"")
+QUOTE_DELIMITER_REGEX = re.compile(f"({'|'.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.",
+    ),
+    "W1310": (
+        "Using formatting for a string that does not have any interpolated variables",
+        "format-string-without-interpolation",
+        "Used when we detect a string that does not have any interpolation variables, "
+        "in which case it can be either a normal string without formatting or a bug in the code.",
+    ),
+}
+
+OTHER_NODES = (
+    nodes.Const,
+    nodes.List,
+    nodes.Lambda,
+    nodes.FunctionDef,
+    nodes.ListComp,
+    nodes.SetComp,
+    nodes.GeneratorExp,
+)
+
+
+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",
+        "format-string-without-interpolation",
+    )
+    def visit_binop(self, node: nodes.BinOp) -> None:
+        if node.op != "%":
+            return
+        left = node.left
+        args = node.right
+
+        if not (isinstance(left, nodes.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 not required_keys and not required_num_args:
+            self.add_message("format-string-without-interpolation", 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, nodes.Dict):
+                keys = set()
+                unknown_keys = False
+                for k, _ in args.items:
+                    if isinstance(k, nodes.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, nodes.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
+                        and arg_type != 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, nodes.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, nodes.Tuple):
+                rhs_tuple = utils.safe_infer(args)
+                num_args = None
+                if isinstance(rhs_tuple, nodes.BaseContainer):
+                    args_elts = rhs_tuple.elts
+                    num_args = len(args_elts)
+            elif isinstance(args, (OTHER_NODES, (nodes.Dict, nodes.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
+                        and arg_type != 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: nodes.JoinedStr) -> None:
+        if isinstance(node.parent, nodes.FormattedValue):
+            return
+        for value in node.values:
+            if isinstance(value, nodes.FormattedValue):
+                return
+        self.add_message("f-string-without-interpolation", node=node)
+
+    @check_messages(*MSGS)
+    def visit_call(self, node: nodes.Call) -> None:
+        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, nodes.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, nodes.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, nodes.Attribute) and not isinstance(
+            node.func.expr, nodes.Const
+        ):
+            return
+        if node.starargs or node.kwargs:
+            return
+        try:
+            strnode = next(func.bound.infer())
+        except astroid.InferenceError:
+            return
+        if not (isinstance(strnode, nodes.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 not num_args:
+                self.add_message("format-string-without-interpolation", node=node)
+                return
+            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, nodes.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(nodes.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).",
+        ),
+        "W1406": (
+            "The u prefix for strings is no longer necessary in Python >=3.0",
+            "redundant-u-string-prefix",
+            "Used when we detect a string with a u prefix. These prefixes were necessary "
+            "in Python 2 to indicate a string was Unicode, but since Python 3.0 strings "
+            "are Unicode by default.",
+        ),
+    }
+    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, node: nodes.Module) -> None:
+        self._unicode_literals = "unicode_literals" in node.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: nodes.List) -> None:
+        self.check_for_concatenated_strings(node.elts, "list")
+
+    @check_messages("implicit-str-concat")
+    def visit_set(self, node: nodes.Set) -> None:
+        self.check_for_concatenated_strings(node.elts, "set")
+
+    @check_messages("implicit-str-concat")
+    def visit_tuple(self, node: nodes.Tuple) -> None:
+        self.check_for_concatenated_strings(node.elts, "tuple")
+
+    def visit_assign(self, node: nodes.Assign) -> None:
+        if isinstance(node.value, nodes.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, nodes.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
+
+    @check_messages("redundant-u-string-prefix")
+    def visit_const(self, node: nodes.Const) -> None:
+        if node.pytype() == "builtins.str" and not isinstance(
+            node.parent, nodes.JoinedStr
+        ):
+            self._detect_u_string_prefix(node)
+
+    def _detect_u_string_prefix(self, node: nodes.Const):
+        """Check whether strings include a 'u' prefix like u'String'"""
+        if node.kind == "u":
+            self.add_message(
+                "redundant-u-string-prefix",
+                line=node.lineno,
+                col_offset=node.col_offset,
+            )
+
+
+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(f"string token {string_token} is not a well-formed string")
+    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 000000000..1245652b1
--- /dev/null
+++ b/pylint/checkers/typecheck.py
@@ -0,0 +1,2003 @@
+# 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, 2021 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 David Liu <david@cs.toronto.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 doranid <ddandd@gmail.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/main/LICENSE
+
+"""try to find more bugs in the code using astroid inference capabilities
+"""
+
+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 Any, Callable, Iterator, List, Optional, Pattern, Tuple
+
+import astroid
+from astroid import bases, nodes
+
+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
+
+STR_FORMAT = {"builtins.str.format"}
+ASYNCIO_COROUTINE = "asyncio.coroutines.coroutine"
+BUILTIN_TUPLE = "builtins.tuple"
+TYPE_ANNOTATION_NODES_TYPES = (
+    nodes.AnnAssign,
+    nodes.Arguments,
+    nodes.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)
+    qname = owner.qname() if hasattr(owner, "qname") else ""
+    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(nodes.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, astroid.MroError):
+        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 = f"one of {', '.join(names[:-1])} or {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.
+        * The node is guarded behind and `IF` or `IFExp` node
+    """
+    # pylint: disable=too-many-return-statements
+    if node_ignores_exception(node, AttributeError):
+        return False
+    if ignored_none and isinstance(owner, nodes.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, nodes.FunctionDef) and (
+        owner.decorators or owner.is_abstract()
+    ):
+        return False
+    if isinstance(owner, (astroid.Instance, nodes.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, nodes.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, nodes.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
+    # Don't emit no-member if guarded behind `IF` or `IFExp`
+    #   * Walk up recursively until if statement is found.
+    #   * Check if condition can be inferred as `Const`,
+    #       would evaluate as `False`,
+    #       and wheater the node is part of the `body`.
+    #   * Continue checking until scope of node is reached.
+    scope: nodes.NodeNG = node.scope()
+    node_origin: nodes.NodeNG = node
+    parent: nodes.NodeNG = node.parent
+    while parent != scope:
+        if isinstance(parent, (nodes.If, nodes.IfExp)):
+            inferred = safe_infer(parent.test)
+            if (  # pylint: disable=too-many-boolean-expressions
+                isinstance(inferred, nodes.Const)
+                and inferred.bool_value() is False
+                and (
+                    isinstance(parent, nodes.If)
+                    and node_origin in parent.body
+                    or isinstance(parent, nodes.IfExp)
+                    and node_origin == parent.body
+                )
+            ):
+                return False
+        node_origin, parent = parent, parent.parent
+
+    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, nodes.FunctionDef):
+        return callable_obj, parameters, callable_obj.type
+    if isinstance(callable_obj, nodes.Lambda):
+        return callable_obj, parameters, "lambda"
+    if isinstance(callable_obj, nodes.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, nodes.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, nodes.Lambda) and not isinstance(scope, nodes.FunctionDef):
+        variadics = list(node.keywords or []) + node.kwargs
+    elif isinstance(statement, (nodes.Return, nodes.Expr, nodes.Assign)) and isinstance(
+        statement.value, nodes.Call
+    ):
+        call = statement.value
+        variadics = list(call.keywords or []) + call.kwargs
+
+    return _no_context_variadic(node, scope.args.kwarg, nodes.Keyword, variadics)
+
+
+def _no_context_variadic_positional(node, scope):
+    variadics = ()
+    if isinstance(scope, nodes.Lambda) and not isinstance(scope, nodes.FunctionDef):
+        variadics = node.starargs + node.kwargs
+    else:
+        statement = node.statement()
+        if isinstance(
+            statement, (nodes.Expr, nodes.Return, nodes.Assign)
+        ) and isinstance(statement.value, nodes.Call):
+            call = statement.value
+            variadics = call.starargs + call.kwargs
+
+    return _no_context_variadic(node, scope.args.vararg, nodes.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, nodes.FunctionDef) and isinstance(
+        scope, nodes.Lambda
+    )
+    statement = node.statement()
+    for name in statement.nodes_of_class(nodes.Name):
+        if name.name != variadic_name:
+            continue
+
+        inferred = safe_infer(name)
+        if isinstance(inferred, (nodes.List, nodes.Tuple)):
+            length = len(inferred.elts)
+        elif isinstance(inferred, nodes.Dict):
+            length = len(inferred.items)
+        else:
+            continue
+
+        if is_in_lambda_scope and isinstance(inferred.parent, nodes.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, nodes.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: nodes.FunctionDef):
+    """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 = nodes.List()
+    class_bases.postinit(elts=cls.bases)
+
+    attrs = nodes.Dict()
+    local_names = [(name, values[-1]) for name, values in cls.locals.items()]
+    attrs.postinit(local_names)
+
+    builder_args = nodes.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, nodes.Tuple):
+        return any(_is_invalid_isinstance_type(elt) for elt in inferred.elts)
+    if isinstance(inferred, nodes.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: nodes.FunctionDef) -> None:
+        # 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: nodes.ClassDef) -> None:
+        def _metaclass_name(metaclass):
+            # pylint: disable=unidiomatic-typecheck
+            if isinstance(metaclass, (nodes.ClassDef, nodes.FunctionDef)):
+                return metaclass.name
+            if type(metaclass) is bases.Instance:
+                # Really do mean type, not isinstance, since subclasses of bases.Instance
+                # like Const or Dict should use metaclass.as_string below.
+                return str(metaclass)
+            return metaclass.as_string()
+
+        metaclass = node.declared_metaclass()
+        if not metaclass:
+            return
+
+        if isinstance(metaclass, nodes.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, nodes.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: nodes.AssignAttr) -> None:
+        if isinstance(node.assign_type(), nodes.AugAssign):
+            self.visit_attribute(node)
+
+    def visit_delattr(self, node: nodes.DelAttr) -> None:
+        self.visit_attribute(node)
+
+    @check_messages("no-member", "c-extension-no-member")
+    def visit_attribute(self, node: nodes.Attribute) -> None:
+        """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, 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(), nodes.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, nodes.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: nodes.Assign) -> None:
+        """
+        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, nodes.Call):
+            return
+
+        function_node = safe_infer(node.value.func)
+        funcs = (nodes.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, nodes.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(nodes.Return, skip_klass=nodes.FunctionDef)
+        )
+        if not returns:
+            self.add_message("assignment-from-no-return", node=node)
+        else:
+            for rnode in returns:
+                if not (
+                    isinstance(rnode.value, nodes.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, nodes.AssignAttr):
+            return
+        if not lhs.attrname == "__name__":
+            return
+
+        # If the right hand side is not a string
+        rhs = node.value
+        if isinstance(rhs, nodes.Const) and isinstance(rhs.value, str):
+            return
+        inferred = utils.safe_infer(rhs)
+        if not inferred:
+            return
+        if not (isinstance(inferred, nodes.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, nodes.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, nodes.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, 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: nodes.Call) -> None:
+        """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(), nodes.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, (nodes.Lambda, nodes.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: List[List[Any]] = []
+        parameter_name_to_index = {}
+        for i, arg in enumerate(args):
+            if isinstance(arg, nodes.Tuple):
+                name = None
+                # Don't store any parameter names within the tuple, since those
+                # are not assignable from keyword arguments.
+            else:
+                assert isinstance(arg, nodes.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, nodes.Keyword):
+                name = arg.arg
+            else:
+                assert isinstance(arg, nodes.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:
+                display_name = "<tuple>" if name is None else 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: nodes.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, (nodes.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.AttributeInferenceError,
+            IndexError,
+        ):
+            return None
+        if (
+            not isinstance(itemmethod, nodes.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, nodes.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, nodes.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, nodes.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: nodes.ExtSlice) -> None:
+        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, nodes.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, nodes.ExtSlice):
+            parent = parent.parent
+        if isinstance(parent, nodes.Subscript):
+            inferred = safe_infer(parent.value)
+            if inferred is None or inferred is astroid.Uninferable:
+                # Don't know what this is
+                return
+            known_objects = (
+                nodes.List,
+                nodes.Dict,
+                nodes.Tuple,
+                astroid.objects.FrozenSet,
+                nodes.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: nodes.With) -> None:
+        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: Iterator[Any] = 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, nodes.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: nodes.UnaryOp) -> None:
+        """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: nodes.BinOp) -> None:
+        if node.op == "|":
+            self._detect_unsupported_alternative_union_syntax(node)
+
+    def _detect_unsupported_alternative_union_syntax(self, node: nodes.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,
+            (
+                nodes.Assign,
+                nodes.Call,
+                nodes.Keyword,
+                nodes.Dict,
+                nodes.Tuple,
+                nodes.Set,
+                nodes.List,
+                nodes.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, nodes.Module):
+                        break
+            if not allowed_nested_syntax:
+                self._check_unsupported_alternative_union_syntax(node)
+
+    def _check_unsupported_alternative_union_syntax(self, node: nodes.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, nodes.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: nodes.BinOp) -> None:
+        """Detect TypeErrors for binary arithmetic operands."""
+        self._check_binop_errors(node)
+
+    @check_messages("unsupported-binary-operation")
+    def _visit_augassign(self, node: nodes.AugAssign) -> None:
+        """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, nodes.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: nodes.Compare) -> None:
+        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: nodes.Subscript) -> None:
+        self._check_invalid_sequence_index(node)
+
+        supported_protocol: Optional[Callable[[Any, Any], bool]] = None
+        if isinstance(node.value, (nodes.ListComp, nodes.DictComp)):
+            return
+
+        if isinstance(node.value, nodes.Dict):
+            # Assert dict key is hashable
+            inferred = safe_infer(node.slice)
+            if inferred and inferred != 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, nodes.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, nodes.ClassDef):
+                inferred = first_decorator.instantiate_class()
+            else:
+                return  # It would be better to handle function
+                # decorators, but let's start slow.
+
+        if supported_protocol and 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: nodes.For) -> None:
+        if not isinstance(node.target, nodes.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, nodes.Name):
+            # it's not a bare variable
+            return
+
+        inferred = safe_infer(iterable)
+        if not inferred:
+            return
+        if not isinstance(inferred, nodes.Dict):
+            # the iterable is not a dict
+            return
+
+        if all(isinstance(i[0], nodes.Tuple) for i in inferred.items):
+            # if all keys are tuples
+            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, nodes.Call):
+            return False
+
+        inferred_func = safe_infer(node.func)
+        if not isinstance(inferred_func, nodes.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, nodes.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, nodes.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: nodes.For) -> None:
+        self._check_iterable(node.iter)
+
+    @check_messages("not-an-iterable")
+    def visit_asyncfor(self, node: nodes.AsyncFor) -> None:
+        self._check_iterable(node.iter, check_async=True)
+
+    @check_messages("not-an-iterable")
+    def visit_yieldfrom(self, node: nodes.YieldFrom) -> None:
+        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: nodes.Call) -> None:
+        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: nodes.ListComp) -> None:
+        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: nodes.DictComp) -> None:
+        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: nodes.SetComp) -> None:
+        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: nodes.GeneratorExp) -> None:
+        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: nodes.Await) -> None:
+        self._check_await_outside_coroutine(node)
+
+    def _check_await_outside_coroutine(self, node: nodes.Await) -> None:
+        node_scope = node.scope()
+        while not isinstance(node_scope, nodes.Module):
+            if isinstance(node_scope, nodes.AsyncFunctionDef):
+                return
+            if isinstance(node_scope, nodes.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 000000000..e6e91c2c1
--- /dev/null
+++ b/pylint/checkers/utils.py
@@ -0,0 +1,1568 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2021 David Liu <david@cs.toronto.edu>
+# Copyright (c) 2021 Matus Valo <matusvalo@users.noreply.github.com>
+# Copyright (c) 2021 Lorena B <46202743+lorena-b@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/main/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 Callable, Dict, Iterable, List, Match, Optional, Set, Tuple, Union
+
+import _string
+import astroid
+import astroid.objects
+from astroid import TooManyLevelsError, nodes
+from astroid.context import InferenceContext
+
+COMP_NODE_TYPES = (
+    nodes.ListComp,
+    nodes.SetComp,
+    nodes.DictComp,
+    nodes.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
+}
+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: nodes.NodeNG) -> bool:
+    """Return true if given node is inside lambda"""
+    parent = node.parent
+    while parent is not None:
+        if isinstance(parent, nodes.Lambda):
+            return True
+        parent = parent.parent
+    return False
+
+
+def get_all_elements(
+    node: nodes.NodeNG,
+) -> Iterable[nodes.NodeNG]:
+    """Recursively returns all atoms in nested lists and tuples."""
+    if isinstance(node, (nodes.Tuple, nodes.List)):
+        for child in node.elts:
+            yield from get_all_elements(child)
+    else:
+        yield node
+
+
+def is_super(node: nodes.NodeNG) -> bool:
+    """return True if the node is referencing the "super" builtin function"""
+    if getattr(node, "name", None) == "super" and node.root().name == "builtins":
+        return True
+    return False
+
+
+def is_error(node: nodes.FunctionDef) -> bool:
+    """Return true if the given function node only raises an exception"""
+    return len(node.body) == 1 and isinstance(node.body[0], nodes.Raise)
+
+
+builtins = builtins.__dict__.copy()  # type: ignore
+SPECIAL_BUILTINS = ("__builtins__",)  # '__path__', '__file__')
+
+
+def is_builtin_object(node: nodes.NodeNG) -> bool:
+    """Returns True if the given node is an object from the __builtin__ module."""
+    return node and node.root().name == "builtins"
+
+
+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: nodes.NodeNG,
+    varname: str,
+    scope: nodes.NodeNG,
+) -> bool:
+    if isinstance(scope, nodes.If):
+        for node in scope.body:
+            if (
+                isinstance(node, nodes.Assign)
+                and any(
+                    isinstance(target, nodes.AssignName) and target.name == varname
+                    for target in node.targets
+                )
+            ) or (isinstance(node, nodes.Nonlocal) and varname in node.names):
+                return True
+    elif isinstance(scope, (COMP_NODE_TYPES, nodes.For)):
+        for ass_node in scope.nodes_of_class(nodes.AssignName):
+            if ass_node.name == varname:
+                return True
+    elif isinstance(scope, nodes.With):
+        for expr, ids in scope.items:
+            if expr.parent_of(var_node):
+                break
+            if ids and isinstance(ids, nodes.AssignName) and ids.name == varname:
+                return True
+    elif isinstance(scope, (nodes.Lambda, nodes.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, nodes.ExceptHandler):
+        if isinstance(scope.name, nodes.AssignName):
+            ass_node = scope.name
+            if ass_node.name == varname:
+                return True
+    return False
+
+
+def is_defined_before(var_node: nodes.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(nodes.AssignName):
+            if assign_node.name == varname:
+                return True
+        for imp_node in _node.nodes_of_class((nodes.ImportFrom, nodes.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: nodes.NodeNG, scope: Optional[nodes.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, (nodes.FunctionDef, nodes.Lambda)):
+        for default_node in scope.args.defaults:
+            for default_name_node in default_node.nodes_of_class(nodes.Name):
+                if default_name_node is node:
+                    return True
+    return False
+
+
+def is_func_decorator(node: nodes.NodeNG) -> bool:
+    """return true if the name is used in function decorator"""
+    parent = node.parent
+    while parent is not None:
+        if isinstance(parent, nodes.Decorators):
+            return True
+        if parent.is_statement or isinstance(
+            parent,
+            (
+                nodes.Lambda,
+                nodes.ComprehensionScope,
+                nodes.ListComp,
+            ),
+        ):
+            break
+        parent = parent.parent
+    return False
+
+
+def is_ancestor_name(frame: nodes.ClassDef, node: nodes.NodeNG) -> bool:
+    """return True if `frame` is an astroid.Class node with `node` in the
+    subtree of its bases attribute
+    """
+    if not isinstance(frame, nodes.ClassDef):
+        return False
+    for base in frame.bases:
+        if node in base.nodes_of_class(nodes.Name):
+            return True
+    return False
+
+
+def is_being_called(node: nodes.NodeNG) -> bool:
+    """return True if node is the function being called in a Call node"""
+    return isinstance(node.parent, nodes.Call) and node.parent.func is node
+
+
+def assign_parent(node: nodes.NodeNG) -> nodes.NodeNG:
+    """return the higher parent which is not an AssignName, Tuple or List node"""
+    while node and isinstance(node, (nodes.AssignName, nodes.Tuple, nodes.List)):
+        node = node.parent
+    return node
+
+
+def overrides_a_method(class_node: nodes.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], nodes.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 = {}
+    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: nodes.NodeNG) -> Optional[nodes.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 = (
+        nodes.NodeNG,
+        astroid.UnboundMethod,
+        astroid.BaseInstance,
+    )
+    while (
+        klass
+        and isinstance(klass, nodes_to_check)
+        and not isinstance(klass, nodes.ClassDef)
+    ):
+        if klass.parent is None:
+            return None
+
+        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: nodes.Call, position: int = None, keyword: str = None
+) -> nodes.Name:
+    """Returns the specified argument from a function call.
+
+    :param nodes.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: nodes.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: nodes.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: nodes.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,)
+    expected_errors = {stringify_error(error) for error in error_type}
+    if not handler.type:
+        return False
+    return handler.catch(expected_errors)
+
+
+def decorated_with_property(node: nodes.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, nodes.FunctionDef)):
+        return False
+    if node.decorators:
+        for decorator in node.decorators.nodes:
+            if isinstance(decorator, nodes.Attribute) and decorator.attrname in kinds:
+                return True
+    return False
+
+
+def is_property_setter(node: nodes.FunctionDef) -> bool:
+    """Check if the given node is a property setter"""
+    return _is_property_kind(node, "setter")
+
+
+def is_property_deleter(node: nodes.FunctionDef) -> bool:
+    """Check if the given node is a property deleter"""
+    return _is_property_kind(node, "deleter")
+
+
+def is_property_setter_or_deleter(node: nodes.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: nodes.Name) -> bool:
+    for inferred in decorator.infer():
+        if isinstance(inferred, nodes.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":
+                    return True
+        elif isinstance(inferred, nodes.FunctionDef):
+            # If decorator is function, check if it has exactly one return
+            # and the return is itself a function decorated with property
+            returns: List[nodes.Return] = list(
+                inferred._get_return_nodes_skip_functions()
+            )
+            if len(returns) == 1 and isinstance(
+                returns[0].value, (nodes.Name, nodes.Attribute)
+            ):
+                inferred = safe_infer(returns[0].value)
+                if (
+                    inferred
+                    and isinstance(inferred, astroid.objects.Property)
+                    and isinstance(inferred.function, nodes.FunctionDef)
+                ):
+                    return decorated_with_property(inferred.function)
+    return False
+
+
+def decorated_with(
+    func: Union[nodes.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, nodes.Call):
+            # We only want to infer the function name
+            decorator_node = decorator_node.func
+        try:
+            if any(
+                i.name in qnames or i.qname() in qnames
+                for i in decorator_node.infer()
+                if i is not None and i != astroid.Uninferable
+            ):
+                return True
+        except astroid.InferenceError:
+            continue
+    return False
+
+
+@lru_cache(maxsize=1024)
+def unimplemented_abstract_methods(
+    node: nodes.ClassDef, is_abstract_cb: nodes.FunctionDef = None
+) -> Dict[str, nodes.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, nodes.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, nodes.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, nodes.FunctionDef):
+                    if obj.name in visited:
+                        del visited[obj.name]
+            if isinstance(inferred, nodes.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: nodes.NodeNG,
+) -> Optional[Union[nodes.ExceptHandler, nodes.TryExcept]]:
+    """Return the ExceptHandler or the TryExcept node in which the node is."""
+    current = node
+    ignores = (nodes.ExceptHandler, nodes.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: nodes.NodeNG,
+) -> Optional[Union[nodes.ExceptHandler, nodes.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, nodes.ExceptHandler):
+            return current
+    return None
+
+
+def is_from_fallback_block(node: nodes.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, nodes.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, (nodes.ImportFrom, nodes.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: nodes.ExceptHandler, exception
+) -> bool:
+    func = partial(error_of_type, error_type=(exception,))
+    return any(func(handler) for handler in handlers)
+
+
+def get_exception_handlers(
+    node: nodes.NodeNG, exception=Exception
+) -> Optional[List[nodes.ExceptHandler]]:
+    """Return the collections of handlers handling the exception in arguments.
+
+    Args:
+        node (nodes.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, nodes.TryExcept):
+        return [
+            handler for handler in context.handlers if error_of_type(handler, exception)
+        ]
+    return []
+
+
+def is_node_inside_try_except(node: nodes.Raise) -> bool:
+    """Check if the node is directly under a Try/Except statement.
+    (but not under an ExceptHandler!)
+
+    Args:
+        node (nodes.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, nodes.TryExcept)
+
+
+def node_ignores_exception(node: nodes.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: nodes.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: nodes.NodeNG, attr: str) -> bool:
+    try:
+        attributes = value.getattr(attr)
+    except astroid.NotFoundError:
+        return False
+
+    first = attributes[0]
+    if isinstance(first, nodes.AssignName):
+        if isinstance(first.parent.value, nodes.Const):
+            return False
+    return True
+
+
+def is_comprehension(node: nodes.NodeNG) -> bool:
+    comprehensions = (
+        nodes.ListComp,
+        nodes.SetComp,
+        nodes.DictComp,
+        nodes.GeneratorExp,
+    )
+    return isinstance(node, comprehensions)
+
+
+def _supports_mapping_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(
+        value, GETITEM_METHOD
+    ) and _supports_protocol_method(value, KEYS_METHOD)
+
+
+def _supports_membership_test_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, CONTAINS_METHOD)
+
+
+def _supports_iteration_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, ITER_METHOD) or _supports_protocol_method(
+        value, GETITEM_METHOD
+    )
+
+
+def _supports_async_iteration_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, AITER_METHOD)
+
+
+def _supports_getitem_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, GETITEM_METHOD)
+
+
+def _supports_setitem_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, SETITEM_METHOD)
+
+
+def _supports_delitem_protocol(value: nodes.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: nodes.NodeNG) -> bool:
+    while node is not None:
+        if isinstance(node, nodes.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: nodes.NodeNG, protocol_callback: nodes.FunctionDef
+) -> bool:
+    if isinstance(value, nodes.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: nodes.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: nodes.NodeNG) -> bool:
+    return _supports_protocol(value, _supports_mapping_protocol)
+
+
+def supports_membership_test(value: nodes.NodeNG) -> bool:
+    supported = _supports_protocol(value, _supports_membership_test_protocol)
+    return supported or is_iterable(value)
+
+
+def supports_getitem(value: nodes.NodeNG, node: nodes.NodeNG) -> bool:
+    if isinstance(value, nodes.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: nodes.NodeNG, _: nodes.NodeNG) -> bool:
+    return _supports_protocol(value, _supports_setitem_protocol)
+
+
+def supports_delitem(value: nodes.NodeNG, _: nodes.NodeNG) -> 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: nodes.NodeNG, context=None) -> Optional[nodes.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
+
+
+@lru_cache(maxsize=512)
+def infer_all(
+    node: nodes.NodeNG, context: InferenceContext = None
+) -> List[nodes.NodeNG]:
+    try:
+        return list(node.infer(context=context))
+    except astroid.InferenceError:
+        return []
+
+
+def has_known_bases(klass: nodes.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, nodes.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: nodes.NodeNG) -> bool:
+    return (
+        node is None
+        or (isinstance(node, nodes.Const) and node.value is None)
+        or (isinstance(node, nodes.Name) and node.name == "None")
+    )
+
+
+def node_type(node: nodes.NodeNG) -> Optional[nodes.NodeNG]:
+    """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[nodes.NodeNG] = 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: nodes.FunctionDef) -> bool:
+    """Check if the given function node is a singledispatch function."""
+
+    singledispatch_qnames = (
+        "functools.singledispatch",
+        "singledispatch.singledispatch",
+    )
+
+    if not isinstance(node, nodes.FunctionDef):
+        return False
+
+    decorators = node.decorators.nodes if node.decorators else []
+    for decorator in decorators:
+        # func.register are function calls
+        if not isinstance(decorator, nodes.Call):
+            continue
+
+        func = decorator.func
+        if not isinstance(func, nodes.Attribute) or func.attrname != "register":
+            continue
+
+        try:
+            func_def = next(func.expr.infer())
+        except astroid.InferenceError:
+            continue
+
+        if isinstance(func_def, nodes.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: nodes.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: nodes.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: nodes.ClassDef, node: nodes.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: nodes.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, nodes.AnnAssign)
+            and parent_node.annotation == current_node
+            or isinstance(parent_node, nodes.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, nodes.FunctionDef)
+            and parent_node.returns == current_node
+        ):
+            return True
+        current_node, parent_node = parent_node, parent_node.parent
+        if isinstance(parent_node, nodes.Module):
+            return False
+
+
+def is_subclass_of(child: nodes.ClassDef, parent: nodes.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, nodes.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: nodes.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: nodes.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, nodes.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: nodes.NodeNG, name: str) -> bool:
+    """Checks if node is a function call with the given name"""
+    return (
+        isinstance(node, nodes.Call)
+        and isinstance(node.func, nodes.Name)
+        and node.func.name == name
+    )
+
+
+def is_test_condition(
+    node: nodes.NodeNG,
+    parent: Optional[nodes.NodeNG] = None,
+) -> bool:
+    """Returns true if the given node is being tested for truthiness"""
+    parent = parent or node.parent
+    if isinstance(parent, (nodes.While, nodes.If, nodes.IfExp, nodes.Assert)):
+        return node is parent.test or parent.test.parent_of(node)
+    if isinstance(parent, nodes.Comprehension):
+        return node in parent.ifs
+    return is_call_of_name(parent, "bool") and parent.parent_of(node)
+
+
+def is_classdef_type(node: nodes.ClassDef) -> bool:
+    """Test if ClassDef node is Type."""
+    if node.name == "type":
+        return True
+    for base in node.bases:
+        if isinstance(base, nodes.Name) and base.name == "type":
+            return True
+    return False
+
+
+def is_attribute_typed_annotation(
+    node: Union[nodes.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, nodes.AssignName)
+        and isinstance(attribute.parent, nodes.AnnAssign)
+    ):
+        return True
+    for base in node.bases:
+        inferred = safe_infer(base)
+        if (
+            inferred
+            and isinstance(inferred, nodes.ClassDef)
+            and is_attribute_typed_annotation(inferred, attr_name)
+        ):
+            return True
+    return False
+
+
+def is_assign_name_annotated_with(node: nodes.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, nodes.AnnAssign):
+        return False
+    annotation = node.parent.annotation
+    if isinstance(annotation, nodes.Subscript):
+        annotation = annotation.value
+    if (
+        isinstance(annotation, nodes.Name)
+        and annotation.name == typing_name
+        or isinstance(annotation, nodes.Attribute)
+        and annotation.attrname == typing_name
+    ):
+        return True
+    return False
+
+
+def get_iterating_dictionary_name(
+    node: Union[nodes.For, nodes.Comprehension]
+) -> Optional[str]:
+    """Get the name of the dictionary which keys are being iterated over on
+    a ``nodes.For`` or ``nodes.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, nodes.Call)
+        and isinstance(node.iter.func, nodes.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, (nodes.Name, nodes.Attribute)):
+        inferred = safe_infer(node.iter)
+        if not isinstance(inferred, nodes.Dict):
+            return None
+        return node.iter.as_string()
+
+    return None
+
+
+def get_subscript_const_value(node: nodes.Subscript) -> nodes.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, nodes.Const):
+        raise InferredTypeError("Subscript.slice cannot be inferred as a nodes.Const")
+
+    return inferred
+
+
+def get_import_name(
+    importnode: Union[nodes.Import, nodes.ImportFrom], modname: str
+) -> str:
+    """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.
+
+    :param importnode: node representing import statement.
+    :param modname: module name from import statement.
+    :returns: absolute qualified module name of the module
+        used in import.
+    """
+    if isinstance(importnode, nodes.ImportFrom) and importnode.level:
+        root = importnode.root()
+        if isinstance(root, nodes.Module):
+            try:
+                return root.relative_to_absolute_name(modname, level=importnode.level)
+            except TooManyLevelsError:
+                return modname
+    return modname
+
+
+def is_node_in_guarded_import_block(node: nodes.NodeNG) -> bool:
+    """Return True if node is part for guarded if block.
+    I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+    """
+    return isinstance(node.parent, nodes.If) and (
+        node.parent.is_sys_guard() or node.parent.is_typing_guard()
+    )
+
+
+def is_reassigned_after_current(node: nodes.NodeNG, varname: str) -> bool:
+    """Check if the given variable name is reassigned in the same scope after the current node"""
+    return any(
+        a.name == varname and a.lineno > node.lineno
+        for a in node.scope().nodes_of_class((nodes.AssignName, nodes.FunctionDef))
+    )
diff --git a/pylint/checkers/variables.py b/pylint/checkers/variables.py
new file mode 100644
index 000000000..cfaf3b731
--- /dev/null
+++ b/pylint/checkers/variables.py
@@ -0,0 +1,2199 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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 kasium <15907922+kasium@users.noreply.github.com>
+# Copyright (c) 2021 Marcin Kurczewski <rr-@sakuya.pl>
+# Copyright (c) 2021 Sergei Lebedev <185856+superbobry@users.noreply.github.com>
+# Copyright (c) 2021 Lorena B <46202743+lorena-b@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/main/LICENSE
+
+"""variables checkers for Python code
+"""
+import collections
+import copy
+import itertools
+import os
+import re
+from functools import lru_cache
+
+import astroid
+from astroid import nodes
+
+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, nodes.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, nodes.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, nodes.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 = f" {inferred.as_string()}"
+        elif inferred.lineno:
+            more = f" defined at line {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, nodes.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, (nodes.FunctionDef, nodes.Arguments)):
+            return False
+    elif any(
+        not isinstance(f, (nodes.ClassDef, nodes.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, (nodes.ClassDef, nodes.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, nodes.AssignName)
+            and isinstance(stmt.assign_type(), nodes.AugAssign)
+            for stmt in stmts
+        ):
+            continue
+        for stmt in stmts:
+            if not isinstance(stmt, (nodes.ImportFrom, nodes.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((nodes.Import, nodes.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(nodes.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, nodes.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 = (
+        nodes.FunctionDef,
+        nodes.ClassDef,
+        nodes.Import,
+        nodes.ImportFrom,
+    )
+    for call in scope.nodes_of_class(nodes.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, consumed_nodes):
+        """
+        Mark the given nodes as consumed for the name.
+        If all of the nodes for the name were consumed, delete the name from
+        the to_consume dictionary
+        """
+        unconsumed = [n for n in self.to_consume[name] if n not in set(consumed_nodes)]
+        self.consumed[name] = consumed_nodes
+
+        if unconsumed:
+            self.to_consume[name] = unconsumed
+        else:
+            del self.to_consume[name]
+
+    def get_next_to_consume(self, node):
+        """
+        Return a list of the nodes that define `node` from this scope.
+        Return None to indicate a special case that needs to be handled by the caller.
+        """
+        name = node.name
+        parent_node = node.parent
+        found_nodes = self.to_consume.get(name)
+        if (
+            found_nodes
+            and isinstance(parent_node, nodes.Assign)
+            and parent_node == found_nodes[0].parent
+        ):
+            lhs = found_nodes[0].parent.targets[0]
+            if lhs.name == name:  # this name is defined in this very statement
+                found_nodes = None
+
+        if (
+            found_nodes
+            and isinstance(parent_node, nodes.For)
+            and parent_node.iter == node
+            and parent_node.target in found_nodes
+        ):
+            found_nodes = None
+
+        # Filter out assignments in ExceptHandlers that node is not contained in
+        if found_nodes:
+            found_nodes = [
+                n
+                for n in found_nodes
+                if not isinstance(n.statement(), nodes.ExceptHandler)
+                or n.statement().parent_of(node)
+            ]
+
+        return found_nodes
+
+
+# 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: nodes.For) -> None:
+        assigned_to = [a.name for a in node.target.nodes_of_class(nodes.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: nodes.For) -> None:
+        self._loop_variables.pop()
+        self._store_type_annotation_names(node)
+
+    def visit_module(self, node: nodes.Module) -> None:
+        """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: nodes.Module) -> None:
+        """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: nodes.ClassDef) -> None:
+        """visit class: update consumption analysis variable"""
+        self._to_consume.append(NamesConsumer(node, "class"))
+
+    def leave_classdef(self, _: nodes.ClassDef) -> None:
+        """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: nodes.Lambda) -> None:
+        """visit lambda: update consumption analysis variable"""
+        self._to_consume.append(NamesConsumer(node, "lambda"))
+
+    def leave_lambda(self, _: nodes.Lambda) -> None:
+        """leave lambda: update consumption analysis variable"""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_generatorexp(self, node: nodes.GeneratorExp) -> None:
+        """visit genexpr: update consumption analysis variable"""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_generatorexp(self, _: nodes.GeneratorExp) -> None:
+        """leave genexpr: update consumption analysis variable"""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_dictcomp(self, node: nodes.DictComp) -> None:
+        """visit dictcomp: update consumption analysis variable"""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_dictcomp(self, _: nodes.DictComp) -> None:
+        """leave dictcomp: update consumption analysis variable"""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_setcomp(self, node: nodes.SetComp) -> None:
+        """visit setcomp: update consumption analysis variable"""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_setcomp(self, _: nodes.SetComp) -> None:
+        """leave setcomp: update consumption analysis variable"""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """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, nodes.Global):
+                definition = globs[name][0]
+                if (
+                    isinstance(definition, nodes.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, nodes.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: nodes.FunctionDef) -> None:
+        """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(nodes.Global))
+        nonlocal_names = _flattened_scope_names(node.nodes_of_class(nodes.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: nodes.Global) -> None:
+        """check names imported exists in the global scope"""
+        frame = node.frame()
+        if isinstance(frame, nodes.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, nodes.Import) for local in locals_.get(name, ())
+            )
+            if (
+                not utils.is_reassigned_after_current(node, name)
+                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, nodes.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
+                if isinstance(anode, nodes.FunctionDef) and anode.parent is module:
+                    # module level function 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: nodes.AssignName) -> None:
+        if isinstance(node.assign_type(), nodes.AugAssign):
+            self.visit_name(node)
+
+    def visit_delname(self, node: nodes.DelName) -> None:
+        self.visit_name(node)
+
+    # pylint: disable=too-many-branches
+    def visit_name(self, node: nodes.Name) -> None:
+        """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, nodes.Keyword)
+                and isinstance(node.parent.parent, nodes.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 (
+                utils.is_func_decorator(current_consumer.node)
+                or not (
+                    current_consumer.scope_type == "comprehension"
+                    and self._has_homonym_in_upper_function_scope(node, i)
+                )
+            ):
+                self._check_late_binding_closure(node)
+                self._loopvar_name(node, name)
+                break
+
+            found_nodes = current_consumer.get_next_to_consume(node)
+            if found_nodes is None:
+                continue
+
+            # checks for use before assignment
+            if found_nodes:
+                defnode = utils.assign_parent(found_nodes[0])
+            else:
+                defnode = None
+                if used_before_assignment_is_enabled:
+                    self.add_message("used-before-assignment", args=name, node=node)
+
+            self._check_late_binding_closure(node)
+
+            if (
+                undefined_variable_is_enabled or used_before_assignment_is_enabled
+            ) and defnode is not None:
+                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, nodes.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, (nodes.DelName, nodes.AssignName)
+                    )
+                    if (
+                        recursive_klass
+                        or defined_by_stmt
+                        or annotation_return
+                        or isinstance(defstmt, nodes.Delete)
+                    ):
+                        if not utils.node_ignores_exception(node, NameError):
+
+                            # Handle postponed evaluation of annotations
+                            if not (
+                                self._postponed_evaluation_enabled
+                                and isinstance(
+                                    stmt,
+                                    (
+                                        nodes.AnnAssign,
+                                        nodes.FunctionDef,
+                                        nodes.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, (nodes.AnnAssign, nodes.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, nodes.ClassDef) and name in frame.locals:
+                            if isinstance(node.parent, nodes.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_nodes)
+            # 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 nodes.Module.scope_attrs
+                or utils.is_builtin(name)
+                or name in self.config.additional_builtins
+                or (
+                    name == "__class__"
+                    and isinstance(frame, nodes.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: nodes.Import) -> None:
+        """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
+        if utils.is_node_in_guarded_import_block(node) is True:
+            # Don't verify import if part of guarded import block
+            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+            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, nodes.Module):
+                continue
+            self._check_module_attrs(node, module, parts[1:])
+
+    @utils.check_messages("no-name-in-module")
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        """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
+        if utils.is_node_in_guarded_import_block(node) is True:
+            # Don't verify import if part of guarded import block
+            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+            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: nodes.Assign) -> None:
+        """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], (nodes.Tuple, nodes.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: nodes.ListComp) -> None:
+        """visit dictcomp: update consumption analysis variable"""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_listcomp(self, _: nodes.ListComp) -> None:
+        """leave dictcomp: update consumption analysis variable"""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def leave_assign(self, node: nodes.Assign) -> None:
+        self._store_type_annotation_names(node)
+
+    def leave_with(self, node: nodes.With) -> None:
+        self._store_type_annotation_names(node)
+
+    def visit_arguments(self, node: nodes.Arguments) -> None:
+        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, nodes.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: nodes.NodeNG, frame: nodes.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, nodes.Lambda) and child is not parent.args:
+                # Body of lambda should not have access to class attributes.
+                return True
+            if isinstance(parent, nodes.Comprehension) and child is not parent.iter:
+                # Only iter of list/set/dict/generator comprehension should have access.
+                return True
+            if isinstance(parent, 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, nodes.FunctionDef)
+                or isinstance(node.frame(), nodes.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, nodes.Comprehension
+                )
+            # check if we have a nonlocal
+            elif name in defframe.locals:
+                maybee0601 = not any(
+                    isinstance(child, nodes.Nonlocal) and name in child.names
+                    for child in defframe.get_children()
+                )
+
+        if (
+            base_scope_type == "lambda"
+            and isinstance(frame, nodes.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, nodes.Arguments)
+                and node in defnode.defaults
+                and frame.locals[name][0].fromlineno < defstmt.fromlineno
+            )
+        elif isinstance(defframe, nodes.ClassDef) and isinstance(
+            frame, nodes.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, nodes.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, nodes.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,
+                        (
+                            nodes.Assign,
+                            nodes.AnnAssign,
+                            nodes.AugAssign,
+                            nodes.Expr,
+                            nodes.Return,
+                        ),
+                    )
+                    and isinstance(defstmt.value, nodes.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, nodes.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,
+                                (
+                                    nodes.Assign,
+                                    nodes.AnnAssign,
+                                    nodes.AugAssign,
+                                    nodes.Return,
+                                ),
+                            )
+                            and isinstance(defstmt.value, nodes.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, (nodes.Import, nodes.ImportFrom)):
+                defstmt_parent = defstmt.parent
+
+                if (
+                    isinstance(defstmt_parent, nodes.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, nodes.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, nodes.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, nodes.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, (nodes.For, nodes.Comprehension, nodes.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, nodes.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 = (
+                nodes.List,
+                nodes.Tuple,
+                nodes.Dict,
+                nodes.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, nodes.FunctionDef)
+            and name == "__class__"
+            and len(node.locals["__class__"]) == 1
+            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
+        ):
+            return
+
+        # Ignore names imported by the global statement.
+        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.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, (nodes.Assign, nodes.AnnAssign)):
+                if name in nonlocal_names:
+                    return
+
+            qname = asname = None
+            if isinstance(stmt, (nodes.Import, nodes.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, nodes.Import):
+                    if asname is not None:
+                        msg = f"{qname} imported as {asname}"
+                    else:
+                        msg = f"import {name}"
+                    self.add_message("unused-import", args=msg, node=stmt)
+                    return
+                if isinstance(stmt, nodes.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, nodes.FunctionDef) and stmt.decorators:
+                return
+
+            # Don't check function stubs created only for type information
+            if utils.is_overload_stub(node):
+                return
+
+            # Special case for exception variable
+            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
+                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
+            ):
+                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, nodes.AssignName)
+            and isinstance(stmt.parent, nodes.Arguments)
+            or isinstance(stmt, nodes.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, nodes.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: nodes.Name) -> None:
+        """Check whether node is a cell var that is assigned within a containing loop.
+
+        Special cases where we don't care about the error:
+        1. When the node's function is immediately called, e.g. (lambda: i)()
+        2. When the node's function is returned from within the loop, e.g. return lambda: i
+        """
+        if not self.linter.is_message_enabled("cell-var-from-loop"):
+            return
+
+        node_scope = node.frame()
+
+        # If node appears in a default argument expression,
+        # look at the next enclosing frame instead
+        if utils.is_default_argument(node, node_scope):
+            node_scope = node_scope.parent.frame()
+
+        # Check if node is a cell var
+        if (
+            not isinstance(node_scope, (nodes.Lambda, nodes.FunctionDef))
+            or node.name in node_scope.locals
+        ):
+            return
+
+        assign_scope, stmts = node.lookup(node.name)
+        if not stmts or not assign_scope.parent_of(node_scope):
+            return
+
+        if utils.is_comprehension(assign_scope):
+            self.add_message("cell-var-from-loop", node=node, args=node.name)
+        else:
+            # Look for an enclosing For loop.
+            # Currently, we only consider the first assignment
+            assignment_node = stmts[0]
+
+            maybe_for = assignment_node
+            while maybe_for and not isinstance(maybe_for, nodes.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 utils.is_being_called(node_scope)
+                    and not isinstance(node_scope.statement(), nodes.Return)
+                ):
+                    self.add_message("cell-var-from-loop", node=node, args=node.name)
+
+    def _should_ignore_redefined_builtin(self, stmt):
+        if not isinstance(stmt, nodes.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, nodes.Name):
+            self._type_annotation_names.append(type_annotation.name)
+            return
+
+        if isinstance(type_annotation, nodes.Attribute):
+            self._store_type_annotation_node(type_annotation.expr)
+            return
+
+        if not isinstance(type_annotation, nodes.Subscript):
+            return
+
+        if (
+            isinstance(type_annotation.value, nodes.Attribute)
+            and isinstance(type_annotation.value.expr, nodes.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(nodes.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, nodes.AssignName)
+        }
+        scope = node.scope()
+        nonlocals_with_same_name = any(
+            child
+            for child in scope.body
+            if isinstance(child, nodes.Nonlocal) and assign_names & set(child.names)
+        )
+        if nonlocals_with_same_name:
+            scope = node.scope().parent.scope()
+
+        if not (
+            isinstance(scope, 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, nodes.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, nodes.Arguments)
+            and isinstance(node.value, nodes.Name)
+            and node.value.name == inferred.parent.vararg
+        ):
+            # Variable-length argument, we can't determine the length.
+            return
+        if isinstance(inferred, (nodes.Tuple, nodes.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, nodes.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, nodes.Module):
+            return module
+        return None
+
+    def _check_all(self, node: nodes.Module, not_consumed):
+        assigned = next(node.igetattr("__all__"))
+        if assigned is astroid.Uninferable:
+            return
+        if not assigned.pytype() in ["builtins.list", "builtins.tuple"]:
+            line, col = assigned.tolineno, assigned.col_offset
+            self.add_message("invalid-all-format", line=line, col_offset=col, node=node)
+            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, nodes.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, node_lst in not_consumed.items():
+            for node in node_lst:
+                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, nodes.Import) or (
+                    isinstance(stmt, nodes.ImportFrom) and not stmt.modname
+                ):
+                    if isinstance(stmt, nodes.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 = f"import {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, nodes.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:
+                            msg = f"{imported_name} imported from {stmt.modname} as {as_name}"
+                        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, nodes.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, nodes.Name):
+            name = klass._metaclass.name
+        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
+            attr = klass._metaclass.expr
+            while not isinstance(attr, nodes.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
+            and not (
+                name in nodes.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 000000000..d6e2c1f25
--- /dev/null
+++ b/pylint/config/__init__.py
@@ -0,0 +1,159 @@
+# 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, 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2019 Janne Rönkkö <jannero@users.noreply.github.com>
+# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Eisuke Kawashima <e-kwsm@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/main/LICENSE
+
+import os
+import pathlib
+import pickle
+import sys
+from datetime import datetime
+
+import platformdirs
+
+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 = platformdirs.user_cache_dir("pylint")
+    # The spam prevention is due to pylint being used in parallel by
+    # pre-commit, and the message being spammy in this context
+    # Also if you work with old version of pylint that recreate the
+    # old pylint home, you can get the old message for a long time.
+    prefix_spam_prevention = "pylint_warned_about_old_cache_already"
+    spam_prevention_file = os.path.join(
+        PYLINT_HOME,
+        datetime.now().strftime(prefix_spam_prevention + "_%Y-%m-%d.temp"),
+    )
+    old_home = os.path.join(USER_HOME, ".pylint.d")
+    if os.path.exists(old_home) and not os.path.exists(spam_prevention_file):
+        print(
+            f"PYLINTHOME is now '{PYLINT_HOME}' but obsolescent '{old_home}' is found; "
+            "you can safely remove the latter",
+            file=sys.stderr,
+        )
+        # Remove old spam prevention file
+        if os.path.exists(PYLINT_HOME):
+            for filename in os.listdir(PYLINT_HOME):
+                if prefix_spam_prevention in filename:
+                    try:
+                        os.remove(os.path.join(PYLINT_HOME, filename))
+                    except OSError:
+                        pass
+
+        # Create spam prevention file for today
+        try:
+            pathlib.Path(PYLINT_HOME).mkdir(parents=True, exist_ok=True)
+            with open(spam_prevention_file, "w", encoding="utf8") as f:
+                f.write("")
+        except Exception:  # pylint: disable=broad-except
+            # Can't write in PYLINT_HOME ?
+            print(
+                "Can't write the file that was supposed to "
+                f"prevent pylint.d deprecation spam in {PYLINT_HOME}."
+            )
+
+
+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.makedirs(PYLINT_HOME)
+        except OSError:
+            print(f"Unable to create directory {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.
+"""
diff --git a/pylint/config/configuration_mixin.py b/pylint/config/configuration_mixin.py
new file mode 100644
index 000000000..deca7f4bc
--- /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/main/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 000000000..2a8937e52
--- /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/main/LICENSE
+
+import configparser
+import os
+
+import toml
+from toml.decoder import TomlDecodeError
+
+
+def _toml_has_config(path):
+    with open(path, encoding="utf-8") 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 000000000..4b078146d
--- /dev/null
+++ b/pylint/config/man_help_formatter.py
@@ -0,0 +1,119 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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
+        )
+        self.output_level: int
+
+    def format_heading(self, heading):
+        return f".SH {heading.upper()}\n"
+
+    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"  # pylint: disable=consider-using-f-string
+            % 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 000000000..eb5890896
--- /dev/null
+++ b/pylint/config/option.py
@@ -0,0 +1,177 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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", "true"):
+        return True
+    if value in ("n", "no", "false"):
+        return False
+    msg = "option %s: invalid yn value %r, should be in (y, yes, true, n, no, false)"
+    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(f'Unsupported type "{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(
+                    # pylint: disable-next=consider-using-f-string
+                    "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(
+                f"must not supply choices for type {self.type!r}", 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 000000000..f18fcfeca
--- /dev/null
+++ b/pylint/config/option_manager_mixin.py
@@ -0,0 +1,369 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+
+import collections
+import configparser
+import contextlib
+import copy
+import functools
+import optparse  # pylint: disable=deprecated-module
+import os
+import sys
+from types import ModuleType
+from typing import Dict, List, Optional, TextIO, Tuple
+
+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():
+    # pylint: disable = redefined-variable-type
+    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: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
+    ) -> None:
+        """write a configuration file according to the current configuration
+        into the given stream or stdout
+        """
+        options_by_section: Dict[str, List[Tuple]] = {}
+        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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
+    ) -> None:
+        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)
+        """
+        for help_level in range(1, self._maxlevel + 1):
+            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 = f"{' '.join(['more'] * help_level)} verbose help."
+            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),)
+
+        if config_file is None:
+            config_file = self.config_file
+        if config_file is not None:
+            config_file = os.path.expandvars(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, encoding="utf-8") 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) -> List[str]:
+        """Override configuration according to command line parameters
+
+        return additional arguments
+        """
+        with _patch_optparse():
+            args = sys.argv[1:] if args is None else 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 000000000..ceae3c719
--- /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/main/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 000000000..a8526095c
--- /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/main/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 000000000..56ce9eaac
--- /dev/null
+++ b/pylint/constants.py
@@ -0,0 +1,51 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+import platform
+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)
+
+IS_PYPY = platform.python_implementation() == "PyPy"
+
+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 000000000..13842b440
--- /dev/null
+++ b/pylint/epylint.py
@@ -0,0 +1,200 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Nick Drozd <nicholasdrozd@gmail.com>
+# 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/main/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:
+        stdout = PIPE if return_std else sys.stdout
+    if stderr is None:
+        stderr = PIPE if return_std else 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(f"Usage: {sys.argv[0]} <filename> [options]")
+        sys.exit(1)
+    elif not os.path.exists(sys.argv[1]):
+        print(f"{sys.argv[1]} does not exist")
+        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 000000000..ec1e513f7
--- /dev/null
+++ b/pylint/exceptions.py
@@ -0,0 +1,39 @@
+# 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 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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"""
+
+
+class NoLineSuppliedError(Exception):
+    """raised when trying to disable a message on a next line without supplying a line number"""
diff --git a/pylint/extensions/__init__.py b/pylint/extensions/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..66b4be24c
--- /dev/null
+++ b/pylint/extensions/_check_docs_utils.py
@@ -0,0 +1,787 @@
+# Copyright (c) 2016-2019, 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016-2020 Claudiu Popa <pcmanticore@gmail.com>
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.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/main/LICENSE
+
+"""Utility methods for docstring checking."""
+
+import re
+from typing import List
+
+import astroid
+from astroid import nodes
+
+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, nodes.Attribute)
+            and decorator.attrname == "setter"
+            and isinstance(decorator.expr, nodes.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: nodes.FunctionDef
+
+    :rtype: nodes.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, nodes.Const) and returns.value is None)
+
+
+def _get_raise_target(node):
+    if isinstance(node.exc, nodes.Call):
+        func = node.exc.func
+        if isinstance(func, (nodes.Name, nodes.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: nodes.NodeNG
+
+    :returns: A list of exception types possibly raised by :param:`node`.
+    :rtype: set(str)
+    """
+    excs = []
+    if isinstance(node.exc, nodes.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, nodes.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, nodes.ClassDef):
+            excs = [target.name]
+        elif isinstance(target, nodes.FunctionDef):
+            for ret in target.nodes_of_class(nodes.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, nodes.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 __repr__(self) -> str:
+        return f"<{self.__class__.__name__}:'''{self.doc}'''>"
+
+    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 = fr"""
+        {re_type}                     # a container type
+        [\(\[] [^\n\s]+ [\)\]]        # with the contents of the container
+    """
+
+    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 = fr"""
+        (?::\w+:)?                    # optional tag
+        `{re_type}`                   # what to reference
+        """
+
+    re_param_raw = fr"""
+        :                       # initial colon
+        (?:                     # Sphinx keywords
+        param|parameter|
+        arg|argument|
+        key|keyword
+        )
+        \s+                     # whitespace
+
+        (?:                     # optional type declaration
+        ({re_type}|{re_simple_container_type})
+        \s+
+        )?
+
+        (\w+)                   # Parameter name
+        \s*                     # whitespace
+        :                       # final colon
+        """
+    re_param_in_docstring = re.compile(re_param_raw, re.X | re.S)
+
+    re_type_raw = fr"""
+        :type                           # Sphinx keyword
+        \s+                             # whitespace
+        ({re_multiple_simple_type})     # Parameter name
+        \s*                             # whitespace
+        :                               # final colon
+        """
+    re_type_in_docstring = re.compile(re_type_raw, re.X | re.S)
+
+    re_property_type_raw = fr"""
+        :type:                      # Sphinx keyword
+        \s+                         # whitespace
+        {re_multiple_simple_type}   # type declaration
+        """
+    re_property_type_in_docstring = re.compile(re_property_type_raw, re.X | re.S)
+
+    re_raise_raw = fr"""
+        :                               # initial colon
+        (?:                             # Sphinx keyword
+        raises?|
+        except|exception
+        )
+        \s+                             # whitespace
+        ({re_multiple_simple_type})     # exception type
+        \s*                             # whitespace
+        :                               # final colon
+        """
+    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 = fr"""
+        (?:{re_type}|{re_xref})       # a container type
+        [\(\[] [^\n]+ [\)\]]          # with the contents of the container
+    """
+
+    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(
+        fr"""
+        \s*  \*{{0,2}}(\w+)             # identifier potentially with asterisks
+        \s*  ( [(]
+            {re_multiple_type}
+            (?:,\s+optional)?
+            [)] )? \s* :                # optional type declaration
+        \s*  (.*)                       # beginning of optional description
+    """,
+        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(
+        fr"""
+        \s*  ({re_multiple_type}) \s* :  # identifier
+        \s*  (.*)                        # beginning of optional description
+    """,
+        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(
+        fr"""
+        \s* ({re_multiple_type}:)?        # identifier
+        \s* (.*)                          # beginning of description
+    """,
+        re.X | re.S | re.M,
+    )
+
+    re_property_returns_line = re.compile(
+        fr"""
+        ^{re_multiple_type}:           # indentifier
+        \s* (.*)                       # Summary line / description
+    """,
+        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(
+        fr"""
+        \s*  (\w+)                                                          # identifier
+        \s*  :
+        \s*  (?:({GoogleDocstring.re_multiple_type})(?:,\s+optional)?)?     # optional type declaration
+        \n                                                                  # description starts on a new line
+        \s* (.*)                                                            # description
+    """,
+        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(
+        fr"""
+        \s* ({GoogleDocstring.re_type})$   # type declaration
+        \s* (.*)                           # optional description
+    """,
+        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(
+        fr"""
+        \s* (?:\w+\s+:\s+)? # optional name
+        ({GoogleDocstring.re_multiple_type})$   # type declaration
+        \s* (.*)                                # optional description
+    """,
+        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 000000000..b90ede111
--- /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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Nick Drozd <nicholasdrozd@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/main/LICENSE
+
+"""Checker for deprecated builtins."""
+from astroid import nodes
+
+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: nodes.Call) -> None:
+        if isinstance(node.func, nodes.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)
+                    args = f"{name!r}. {hint}" if hint else 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 000000000..e87e6843c
--- /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 000000000..abc99251a
--- /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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.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/main/LICENSE
+
+"""Looks for try/except statements with too much code in the try clause."""
+
+from astroid import nodes
+
+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, (nodes.For, nodes.If, nodes.While, nodes.With)):
+                statement_count += self._count_statements(body_node)
+
+        return statement_count
+
+    def visit_tryexcept(self, node: nodes.TryExcept) -> None:
+        try_clause_statements = self._count_statements(node)
+        if try_clause_statements > self.config.max_try_statements:
+            msg = f"try clause contains {try_clause_statements} statements, expected at most {self.config.max_try_statements}"
+            self.add_message(
+                "too-many-try-statements", node.lineno, node=node, args=msg
+            )
+
+    def visit_tryfinally(self, node: nodes.TryFinally) -> None:
+        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 000000000..96ea4311f
--- /dev/null
+++ b/pylint/extensions/check_docs.py
@@ -0,0 +1,26 @@
+# 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>
+# 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/main/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 000000000..67dbd0d9c
--- /dev/null
+++ b/pylint/extensions/check_elif.py
@@ -0,0 +1,80 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+from astroid import nodes
+
+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, _: nodes.Module) -> None:
+        self._init()
+
+    def visit_ifexp(self, node: nodes.IfExp) -> None:
+        if isinstance(node.parent, nodes.FormattedValue):
+            return
+        self._if_counter += 1
+
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        self._if_counter += len(node.ifs)
+
+    @check_messages("else-if-used")
+    def visit_if(self, node: nodes.If) -> None:
+        if isinstance(node.parent, nodes.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 000000000..42681d379
--- /dev/null
+++ b/pylint/extensions/code_style.py
@@ -0,0 +1,307 @@
+import sys
+from typing import List, Optional, Set, Tuple, Type, Union, cast
+
+from astroid import nodes
+
+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
+from pylint.utils.utils import get_global_option
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
+
+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 instead of list",
+            "consider-using-tuple",
+            "Only for style consistency! "
+            "Emitted where an in-place defined ``list`` can be replaced by a ``tuple``. "
+            "Due to optimizations by CPython, there is no performance benefit from it.",
+        ),
+        "R6103": (
+            "Use '%s' instead",
+            "consider-using-assignment-expr",
+            "Emitted when an if assignment is directly followed by an if statement and "
+            "both can be combined by using an assignment expression ``:=``. "
+            "Requires Python 3.8",
+        ),
+    }
+    options = (
+        (
+            "max-line-length-suggestions",
+            {
+                "type": "int",
+                "metavar": "<int>",
+                "help": (
+                    "Max line length for which to sill emit suggestions. "
+                    "Used to prevent optional suggestions which would get split "
+                    "by a code formatter (e.g., black). "
+                    "Will default to the setting for ``max-line-length``."
+                ),
+            },
+        ),
+    )
+
+    def __init__(self, linter: PyLinter) -> None:
+        """Initialize checker instance."""
+        super().__init__(linter=linter)
+
+    def open(self) -> None:
+        py_version = get_global_option(self, "py-version")
+        self._py38_plus = py_version >= (3, 8)
+        self._max_length: int = (
+            self.config.max_line_length_suggestions
+            or get_global_option(self, "max-line-length")
+        )
+
+    @check_messages("consider-using-namedtuple-or-dataclass")
+    def visit_dict(self, node: nodes.Dict) -> None:
+        self._check_dict_consider_namedtuple_dataclass(node)
+
+    @check_messages("consider-using-tuple")
+    def visit_for(self, node: nodes.For) -> None:
+        if isinstance(node.iter, nodes.List):
+            self.add_message("consider-using-tuple", node=node.iter)
+
+    @check_messages("consider-using-tuple")
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        if isinstance(node.iter, nodes.List):
+            self.add_message("consider-using-tuple", node=node.iter)
+
+    @check_messages("consider-using-assignment-expr")
+    def visit_if(self, node: nodes.If) -> None:
+        if self._py38_plus:
+            self._check_consider_using_assignment_expr(node)
+
+    def _check_dict_consider_namedtuple_dataclass(self, node: nodes.Dict) -> None:
+        """Check if dictionary values can be replaced by Namedtuple or Dataclass."""
+        if not (
+            isinstance(node.parent, (nodes.Assign, nodes.AnnAssign))
+            and isinstance(node.parent.parent, nodes.Module)
+            or isinstance(node.parent, nodes.AnnAssign)
+            and isinstance(node.parent.target, nodes.AssignName)
+            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, nodes.Dict) for _, dict_value in node.items
+        ):
+            KeyTupleT = Tuple[Type[nodes.NodeNG], str]
+
+            # Makes sure all keys are 'Const' string nodes
+            keys_checked: Set[KeyTupleT] = set()
+            for _, dict_value in node.items:
+                dict_value = cast(nodes.Dict, dict_value)
+                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, nodes.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:
+                dict_value = cast(nodes.Dict, dict_value)
+                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, (nodes.List, nodes.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:]:
+                dict_value = cast(Union[nodes.List, nodes.Tuple], dict_value)
+                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:
+                dict_value = cast(Union[nodes.List, nodes.Tuple], dict_value)
+                if all(isinstance(entry, nodes.Dict) for entry in dict_value.elts):
+                    return
+
+            self.add_message("consider-using-namedtuple-or-dataclass", node=node)
+            return
+
+    def _check_consider_using_assignment_expr(self, node: nodes.If) -> None:
+        """Check if an assignment expression (walrus operator) can be used.
+
+        For example if an assignment is directly followed by an if statment:
+        >>> x = 2
+        >>> if x:
+        >>>     ...
+
+        Can be replaced by:
+        >>> if (x := 2):
+        >>>     ...
+
+        Note: Assignment expressions were added in Python 3.8
+        """
+        # Check if `node.test` contains a `Name` node
+        node_name: Optional[nodes.Name] = None
+        if isinstance(node.test, nodes.Name):
+            node_name = node.test
+        elif (
+            isinstance(node.test, nodes.UnaryOp)
+            and node.test.op == "not"
+            and isinstance(node.test.operand, nodes.Name)
+        ):
+            node_name = node.test.operand
+        elif (
+            isinstance(node.test, nodes.Compare)
+            and isinstance(node.test.left, nodes.Name)
+            and len(node.test.ops) == 1
+        ):
+            node_name = node.test.left
+        else:
+            return
+
+        # Make sure the previous node is an assignment to the same name
+        # used in `node.test`. Furthermore, ignore if assignment spans multiple lines.
+        prev_sibling = node.previous_sibling()
+        if CodeStyleChecker._check_prev_sibling_to_if_stmt(
+            prev_sibling, node_name.name
+        ):
+
+            # Check if match statement would be a better fit.
+            # I.e. multiple ifs that test the same name.
+            if CodeStyleChecker._check_ignore_assignment_expr_suggestion(
+                node, node_name.name
+            ):
+                return
+
+            # Build suggestion string. Check length of suggestion
+            # does not exceed max-line-length-suggestions
+            test_str = node.test.as_string().replace(
+                node_name.name,
+                f"({node_name.name} := {prev_sibling.value.as_string()})",
+                1,
+            )
+            suggestion = f"if {test_str}:"
+            if (
+                node.col_offset is not None
+                and len(suggestion) + node.col_offset > self._max_length
+                or len(suggestion) > self._max_length
+            ):
+                return
+
+            self.add_message(
+                "consider-using-assignment-expr",
+                node=node_name,
+                args=(suggestion,),
+            )
+
+    @staticmethod
+    def _check_prev_sibling_to_if_stmt(
+        prev_sibling: Optional[nodes.NodeNG], name: Optional[str]
+    ) -> TypeGuard[Union[nodes.Assign, nodes.AnnAssign]]:
+        """Check if previous sibling is an assignment with the same name.
+        Ignore statements which span multiple lines.
+        """
+        if prev_sibling is None or prev_sibling.tolineno - prev_sibling.fromlineno != 0:
+            return False
+
+        if (
+            isinstance(prev_sibling, nodes.Assign)
+            and len(prev_sibling.targets) == 1
+            and isinstance(prev_sibling.targets[0], nodes.AssignName)
+            and prev_sibling.targets[0].name == name
+        ):
+            return True
+        if (
+            isinstance(prev_sibling, nodes.AnnAssign)
+            and isinstance(prev_sibling.target, nodes.AssignName)
+            and prev_sibling.target.name == name
+        ):
+            return True
+        return False
+
+    @staticmethod
+    def _check_ignore_assignment_expr_suggestion(
+        node: nodes.If, name: Optional[str]
+    ) -> bool:
+        """Return True if suggestion for assignment expr should be ignore.
+
+        E.g., in cases where a match statement would be a better fit
+        (multiple conditions).
+        """
+        if isinstance(node.test, nodes.Compare):
+            next_if_node: Optional[nodes.If] = None
+            next_sibling = node.next_sibling()
+            if len(node.orelse) == 1 and isinstance(node.orelse[0], nodes.If):
+                # elif block
+                next_if_node = node.orelse[0]
+            elif isinstance(next_sibling, nodes.If):
+                # separate if block
+                next_if_node = next_sibling
+
+            if (  # pylint: disable=too-many-boolean-expressions
+                next_if_node is not None
+                and (
+                    isinstance(next_if_node.test, nodes.Compare)
+                    and isinstance(next_if_node.test.left, nodes.Name)
+                    and next_if_node.test.left.name == name
+                    or isinstance(next_if_node.test, nodes.Name)
+                    and next_if_node.test.name == name
+                )
+            ):
+                return True
+        return False
+
+
+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 000000000..a7ff659e8
--- /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 000000000..ced62f0a6
--- /dev/null
+++ b/pylint/extensions/comparetozero.py
@@ -0,0 +1,82 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# 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/main/LICENSE
+
+"""Looks for comparisons to zero."""
+
+import itertools
+from typing import Any, Iterable
+
+import astroid
+from astroid import nodes
+
+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: nodes.Compare) -> None:
+        _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)
+        iter_ops: Iterable[Any] = iter(ops)
+        ops = list(itertools.chain(*iter_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 000000000..2741ece44
--- /dev/null
+++ b/pylint/extensions/confusing_elif.py
@@ -0,0 +1,59 @@
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# 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/main/LICENSE
+
+from astroid import nodes
+
+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"
+    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: nodes.If) -> None:
+        body_ends_with_if = isinstance(
+            node.body[-1], nodes.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: nodes.If):
+        orelse = node.orelse
+        while orelse and isinstance(orelse[0], nodes.If):
+            orelse = orelse[0].orelse
+        if not orelse or isinstance(orelse[0], nodes.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/consider_ternary_expression.py b/pylint/extensions/consider_ternary_expression.py
new file mode 100644
index 000000000..976cd20b9
--- /dev/null
+++ b/pylint/extensions/consider_ternary_expression.py
@@ -0,0 +1,53 @@
+"""Check for if / assign blocks that can be rewritten with if-expressions."""
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IAstroidChecker
+
+
+class ConsiderTernaryExpressionChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+    name = "consider_ternary_expression"
+    msgs = {
+        "W0160": (
+            "Consider rewriting as a ternary expression",
+            "consider-ternary-expression",
+            "Multiple assign statements spread across if/else blocks can be "
+            "rewritten with a single assingment and ternary expression",
+        )
+    }
+
+    def visit_if(self, node: nodes.If) -> None:
+        if isinstance(node.parent, nodes.If):
+            return
+
+        if len(node.body) != 1 or len(node.orelse) != 1:
+            return
+
+        bst = node.body[0]
+        ost = node.orelse[0]
+
+        if not isinstance(bst, nodes.Assign) or not isinstance(ost, nodes.Assign):
+            return
+
+        for (bname, oname) in zip(bst.targets, ost.targets):
+            if not isinstance(bname, nodes.AssignName) or not isinstance(
+                oname, nodes.AssignName
+            ):
+                return
+
+            if bname.name != oname.name:
+                return
+
+        self.add_message("consider-ternary-expression", 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(ConsiderTernaryExpressionChecker(linter))
diff --git a/pylint/extensions/docparams.py b/pylint/extensions/docparams.py
new file mode 100644
index 000000000..32abedfb8
--- /dev/null
+++ b/pylint/extensions/docparams.py
@@ -0,0 +1,642 @@
+# 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 SupImDos <62866982+SupImDos@users.noreply.github.com>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.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/main/LICENSE
+
+"""Pylint plugin for checking in Sphinx, Google, or Numpy style docstrings
+"""
+import re
+from typing import Optional
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers import utils as checker_utils
+from pylint.extensions import _check_docs_utils as utils
+from pylint.extensions._check_docs_utils import Docstring
+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: nodes.FunctionDef) -> None:
+        """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)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    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: nodes.Raise) -> None:
+        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: nodes.Return) -> None:
+        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: nodes.Yield) -> None:
+        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: nodes.YieldFrom) -> None:
+        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: Docstring,
+        arguments_node: astroid.Arguments,
+        warning_node: astroid.NodeNG,
+        accept_no_param_doc: Optional[bool] = 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,
+            )
+
+        # This is before the update of param_with_type because this must check only
+        # the type documented in a docstring, not the one using pep484
+        # See #4117 and #4593
+        self._compare_ignored_args(
+            params_with_type,
+            "useless-type-doc",
+            expected_but_ignored_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,
+        )
+
+    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: nodes.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 000000000..e46c4dcd7
--- /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 000000000..7866312b2
--- /dev/null
+++ b/pylint/extensions/docstyle.py
@@ -0,0 +1,95 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+import linecache
+
+from astroid import nodes
+
+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: nodes.Module) -> None:
+        self._check_docstring("module", node)
+
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        self._check_docstring("class", node)
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        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 000000000..7b9841678
--- /dev/null
+++ b/pylint/extensions/empty_comment.py
@@ -0,0 +1,58 @@
+from astroid import nodes
+
+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: nodes.Module) -> None:
+        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 000000000..b54bffdfe
--- /dev/null
+++ b/pylint/extensions/emptystring.py
@@ -0,0 +1,80 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Looks for  comparisons to empty string."""
+
+import itertools
+from typing import Any, Iterable
+
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+def _is_constant_empty_str(node):
+    return isinstance(node, nodes.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: nodes.Compare) -> None:
+        _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)
+        iter_ops: Iterable[Any] = iter(ops)
+        ops = list(itertools.chain(*iter_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 000000000..70ad5a553
--- /dev/null
+++ b/pylint/extensions/mccabe.py
@@ -0,0 +1,202 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Module to add McCabe checker class for pylint. """
+
+from astroid import nodes
+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 = f"{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 = f"{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: nodes.Module) -> None:
+        """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 = f"'{node.name}'"
+            else:
+                node_name = f"This '{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 000000000..e63d5b20f
--- /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 000000000..2ed9038e3
--- /dev/null
+++ b/pylint/extensions/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/main/LICENSE
+
+"""Looks for overlapping exceptions."""
+
+from typing import Any, List, Tuple
+
+import astroid
+from astroid import nodes
+
+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: nodes.TryExcept) -> None:
+        """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: List[Tuple[Any, Any]] = []
+            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=f"{prev_part.as_string()} and {part.as_string()} are the same",
+                        )
+                    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=f"{ancestor.as_string()} is an ancestor class of {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 000000000..864c50ddf
--- /dev/null
+++ b/pylint/extensions/redefined_variable_type.py
@@ -0,0 +1,120 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+from typing import List
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages, is_none, node_type
+from pylint.interfaces import IAstroidChecker
+
+
+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, _: nodes.ClassDef) -> None:
+        self._assigns.append({})
+
+    @check_messages("redefined-variable-type")
+    def leave_classdef(self, _: nodes.ClassDef) -> None:
+        self._check_and_add_messages()
+
+    visit_functiondef = visit_classdef
+    leave_functiondef = leave_module = leave_classdef
+
+    def visit_module(self, _: nodes.Module) -> None:
+        self._assigns: List[dict] = [{}]
+
+    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, nodes.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, nodes.If
+                    ) and redef_parent in orig_parent.nodes_of_class(nodes.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: nodes.Assign) -> None:
+        # we don't handle multiple assignment nor slice assignment
+        target = node.targets[0]
+        if isinstance(target, (nodes.Tuple, nodes.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/set_membership.py b/pylint/extensions/set_membership.py
new file mode 100644
index 000000000..c63e268b3
--- /dev/null
+++ b/pylint/extensions/set_membership.py
@@ -0,0 +1,47 @@
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+from pylint.lint import PyLinter
+
+
+class SetMembershipChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+
+    name = "set_membership"
+    priority = -1
+    msgs = {
+        "R6201": (
+            "Consider using set for membership test",
+            "use-set-for-membership",
+            "Membership tests are more efficient when performed on "
+            "a lookup optimized datatype like ``sets``.",
+        ),
+    }
+
+    def __init__(self, linter: PyLinter) -> None:
+        """Initialize checker instance."""
+        super().__init__(linter=linter)
+
+    @check_messages("use-set-for-membership")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        for op, comparator in node.ops:
+            if op == "in":
+                self._check_in_comparison(comparator)
+
+    def _check_in_comparison(self, comparator: nodes.NodeNG) -> None:
+        """Checks for membership comparisons with in-place container objects."""
+        if not isinstance(comparator, nodes.BaseContainer) or isinstance(
+            comparator, nodes.Set
+        ):
+            return
+
+        # Heuristic - We need to be sure all items in set are hashable
+        if all(isinstance(item, nodes.Const) for item in comparator.elts):
+            self.add_message("use-set-for-membership", node=comparator)
+
+
+def register(linter: PyLinter) -> None:
+    linter.register_checker(SetMembershipChecker(linter))
diff --git a/pylint/extensions/typing.py b/pylint/extensions/typing.py
new file mode 100644
index 000000000..90386a8d4
--- /dev/null
+++ b/pylint/extensions/typing.py
@@ -0,0 +1,286 @@
+from typing import Dict, List, NamedTuple, Set, Union
+
+import astroid.bases
+from astroid import nodes
+
+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
+from pylint.utils.utils import get_global_option
+
+
+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[nodes.Name, nodes.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 = (
+        (
+            "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"
+                ),
+            },
+        ),
+    )
+
+    _should_check_typing_alias: bool
+    """The use of type aliases (PEP 585) requires Python 3.9
+    or Python 3.7+ with postponed evaluation.
+    """
+
+    _should_check_alternative_union_syntax: bool
+    """The use of alternative union syntax (PEP 604) requires Python 3.10
+    or Python 3.7+ with postponed evaluation.
+    """
+
+    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] = []
+
+    def open(self) -> None:
+        py_version = get_global_option(self, "py-version")
+        self._py37_plus = py_version >= (3, 7)
+        self._py39_plus = py_version >= (3, 9)
+        self._py310_plus = py_version >= (3, 10)
+
+        self._should_check_typing_alias = self._py39_plus or (
+            self._py37_plus and self.config.runtime_typing is False
+        )
+        self._should_check_alternative_union_syntax = 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: nodes.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: nodes.Attribute) -> None:
+        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[nodes.Name, nodes.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, nodes.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[nodes.Name, nodes.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, nodes.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, nodes.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, nodes.Subscript),
+            )
+        )
+
+    @check_messages("consider-using-alias")
+    def leave_module(self, node: nodes.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)
+            for msg in self._consider_using_alias_msgs:
+                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 000000000..36be9c2c3
--- /dev/null
+++ b/pylint/extensions/typing.rst
@@ -0,0 +1 @@
+Find issue specifically related to type annotations.
diff --git a/pylint/extensions/while_used.py b/pylint/extensions/while_used.py
new file mode 100644
index 000000000..8d05ace90
--- /dev/null
+++ b/pylint/extensions/while_used.py
@@ -0,0 +1,32 @@
+"""Check for use of while loops."""
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+
+class WhileChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+    name = "while_used"
+    msgs = {
+        "W0149": (
+            "Used `while` loop",
+            "while-used",
+            "Unbounded `while` loops can often be rewritten as bounded `for` loops.",
+        )
+    }
+
+    @check_messages("while-used")
+    def visit_while(self, node: nodes.While) -> None:
+        self.add_message("while-used", 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(WhileChecker(linter))
diff --git a/pylint/graph.py b/pylint/graph.py
new file mode 100644
index 000000000..2dc3bae99
--- /dev/null
+++ b/pylint/graph.py
@@ -0,0 +1,211 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.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 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/main/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(f"digraph {normalize_node_id(graphname)} {{")
+        if rankdir:
+            self.emit(f"rankdir={rankdir}")
+        if ratio:
+            self.emit(f"ratio={ratio}")
+        if size:
+            self.emit(f'size="{size}"')
+        if charset:
+            assert charset.lower() in (
+                "utf-8",
+                "iso-8859-1",
+                "latin1",
+            ), f"unsupported charset {charset}"
+            self.emit(f'charset="{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 file:
+            file.write(self.source)
+        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(f"{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(f"{normalize_node_id(name)} [{', '.join(sorted(attrs))}];")
+
+
+def normalize_node_id(nid):
+    """Returns a suitable DOT node id for `nid`."""
+    return f'"{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 000000000..e657e7115
--- /dev/null
+++ b/pylint/interfaces.py
@@ -0,0 +1,109 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Interfaces for Pylint objects"""
+from collections import namedtuple
+from typing import TYPE_CHECKING, Tuple
+
+from astroid import nodes
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+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", interface: Tuple[type, type]) -> bool:
+    """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, node: nodes.Module) -> None:
+        """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: "Section") -> None:
+        """display results encapsulated in the layout tree"""
+
+
+__all__ = ("IRawChecker", "IAstroidChecker", "ITokenChecker", "IReporter", "IChecker")
diff --git a/pylint/lint/__init__.py b/pylint/lint/__init__.py
new file mode 100644
index 000000000..69d0f95d1
--- /dev/null
+++ b/pylint/lint/__init__.py
@@ -0,0 +1,105 @@
+# 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>
+# 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/main/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 000000000..1d4432322
--- /dev/null
+++ b/pylint/lint/expand_modules.py
@@ -0,0 +1,142 @@
+import os
+import sys
+from typing import List, Pattern, Tuple
+
+from astroid import modutils
+
+from pylint.typing import ErrorDescriptionDict, ModuleDescriptionDict
+
+
+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[ModuleDescriptionDict], List[ErrorDescriptionDict]]:
+    """take a list of files/modules/packages and return the list of tuple
+    (file, module name) which have to be actually checked
+    """
+    result: List[ModuleDescriptionDict] = []
+    errors: List[ErrorDescriptionDict] = []
+    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 000000000..1896fc95f
--- /dev/null
+++ b/pylint/lint/parallel.py
@@ -0,0 +1,175 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import collections
+import functools
+from typing import TYPE_CHECKING, Any, DefaultDict, Dict, Iterable, List, Tuple, Union
+
+from pylint import reporters
+from pylint.lint.utils import _patch_sys_path
+from pylint.message import Message
+from pylint.typing import CheckerStats, FileItem
+
+if TYPE_CHECKING:
+    from typing import Counter  # typing.Counter added in Python 3.6.1
+
+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: List[CheckerStats]):
+    merged: CheckerStats = {}
+    by_msg: "Counter[str]" = collections.Counter()
+    for stat in stats:
+        message_stats: Union["Counter[str]", Dict] = stat.pop("by_msg", {})  # type: ignore
+        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)  # type: ignore
+            else:
+                merged[key] = merged[key] + item  # type: ignore
+
+    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: FileItem,
+) -> Tuple[int, Any, str, Any, List[Tuple[Any, ...]], Any, Any, DefaultDict[Any, List]]:
+    if not _worker_linter:
+        raise Exception("Worker linter not yet initialised")
+    _worker_linter.open()
+    _worker_linter.check_single_file_item(file_item)
+    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,
+        file_item.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: Iterable[FileItem], 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)  # type: ignore  # linter.set_reporter() call above makes linter have a reporter attr
+            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([linter.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 000000000..e8efc2fcd
--- /dev/null
+++ b/pylint/lint/pylinter.py
@@ -0,0 +1,1298 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import collections
+import contextlib
+import functools
+import operator
+import os
+import sys
+import tokenize
+import traceback
+import warnings
+from io import TextIOWrapper
+from typing import Iterable, Iterator, List, Optional, Sequence, Union
+
+import astroid
+from astroid import AstroidError, nodes
+
+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,
+    get_fatal_error_message,
+    prepare_crash_report,
+)
+from pylint.message import MessageDefinitionStore, MessagesHandlerMixIn
+from pylint.reporters.ureports import nodes as report_nodes
+from pylint.typing import CheckerStats, FileItem, ModuleDescriptionDict
+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
+    # Will be used like this : datetime.now().strftime(crash_file_path)
+    crash_file_path: str = "pylint-crash-%Y-%m-%d-%H.txt"
+
+    @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."
+                    f" Leave empty to show all. Valid levels: {', '.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."
+                    ),
+                },
+            ),
+            (
+                "py-version",
+                {
+                    "default": sys.version_info[:2],
+                    "type": "py_version",
+                    "metavar": "<py_version>",
+                    "help": (
+                        "Min Python version to use for version dependend checks. "
+                        "Will default to the version used to run pylint."
+                    ),
+                },
+            ),
+        )
+
+    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: CheckerStats = {}
+        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,
+            "disable-next": self.disable_next,
+        }
+        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._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", encoding="utf-8")
+                    )
+
+                    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(
+                        f"{optname} is deprecated, replace it by {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(f"option {optname} can't be read from config file", 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 (
+            self.stats
+            and self.stats.get("by_msg") is not None
+            and 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")
+        self.set_option("reports", False)
+        self.set_option("persistent", False)
+        self.set_option("score", False)
+
+    def list_messages_enabled(self):
+        emittable, non_emittable = self.msgs_store.find_emittable_messages()
+        enabled = []
+        disabled = []
+        for message in emittable:
+            if self.is_message_enabled(message.msgid):
+                enabled.append(f"  {message.symbol} ({message.msgid})")
+            else:
+                disabled.append(f"  {message.symbol} ({message.msgid})")
+        print("Enabled messages:")
+        for msg in enabled:
+            print(msg)
+        print("\nDisabled messages:")
+        for msg in disabled:
+            print(msg)
+        print("\nNon-emittable messages with current interpreter:")
+        for msg in non_emittable:
+            print(f"  {msg.symbol} ({msg.msgid})")
+        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", "disable-next", "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: Union[Sequence[str], str]) -> None:
+        """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)):
+            # pylint: disable-next=fixme
+            # TODO: Update typing and docstring for 'files_or_modules' when removing the deprecation
+            warnings.warn(
+                "In pylint 3.0, the checkers check function will only accept sequence of string",
+                DeprecationWarning,
+            )
+            files_or_modules = (files_or_modules,)  # type: ignore
+        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: str, filepath: str, modname: str) -> None:
+        warnings.warn(
+            "In pylint 3.0, the checkers check_single_file function will be removed. "
+            "Use check_single_file_item instead.",
+            DeprecationWarning,
+        )
+        self.check_single_file_item(FileItem(name, filepath, modname))
+
+    def check_single_file_item(self, file: FileItem) -> None:
+        """Check single file item
+
+        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, file)
+
+    def _check_files(
+        self,
+        get_ast,
+        file_descrs: Iterable[FileItem],
+    ) -> None:
+        """Check all files from file_descrs"""
+        with self._astroid_module_checker() as check_astroid_module:
+            for file in file_descrs:
+                try:
+                    self._check_file(get_ast, check_astroid_module, file)
+                except Exception as ex:  # pylint: disable=broad-except
+                    template_path = prepare_crash_report(
+                        ex, file.filepath, self.crash_file_path
+                    )
+                    msg = get_fatal_error_message(file.filepath, template_path)
+                    if isinstance(ex, AstroidError):
+                        symbol = "astroid-error"
+                        self.add_message(symbol, args=(file.filepath, msg))
+                    else:
+                        symbol = "fatal"
+                        self.add_message(symbol, args=msg)
+
+    def _check_file(self, get_ast, check_astroid_module, file: FileItem):
+        """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 FileItem file: data about the file
+        """
+        self.set_current_module(file.name, file.filepath)
+        # get the module representation
+        ast_node = get_ast(file.filepath, file.name)
+        if ast_node is None:
+            return
+
+        self._ignore_file = False
+
+        self.file_state = FileState(file.modpath)
+        # 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: str) -> FileItem:
+        """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 FileItem(modname, filepath, filepath)
+
+    def _iterate_file_descrs(self, files_or_modules) -> Iterator[FileItem]:
+        """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 FileItem(name, filepath, descr["basename"])
+
+    def _expand_files(self, modules) -> List[ModuleDescriptionDict]:
+        """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: Optional[str] = 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] = {}  # type: ignore # Refactor of PyLinter.stats necessary
+        self.stats["by_module"][modname]["statement"] = 0  # type: ignore
+        for msg_cat in MSG_TYPES.values():
+            self.stats["by_module"][modname][msg_cat] = 0  # type: ignore
+
+    @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, node: nodes.Module, walker, rawcheckers, tokencheckers
+    ):
+        """Check given AST node with given walker and checkers
+
+        :param astroid.nodes.Module 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(node)
+        except tokenize.TokenError as ex:
+            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
+            return None
+
+        if not node.pure_python:
+            self.add_message("raw-checker-failed", args=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, node)
+            # run raw and tokens checkers
+            for checker in rawcheckers:
+                checker.process_module(node)
+            for checker in tokencheckers:
+                checker.process_tokens(tokens)
+        # generate events to astroid checkers
+        walker.walk(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 = f"An exception occurred while rating: {ex}"
+        else:
+            self.stats["global_note"] = note
+            msg = f"Your code has been rated at {note:.2f}/10"
+            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 000000000..201b28b7b
--- /dev/null
+++ b/pylint/lint/report_functions.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/main/LICENSE
+
+import collections
+from typing import DefaultDict, Dict, List, Tuple, Union
+
+from pylint import checkers, exceptions
+from pylint.reporters.ureports.nodes import Table
+from pylint.typing import CheckerStats
+
+
+def report_total_messages_stats(
+    sect,
+    stats: CheckerStats,
+    previous_stats: CheckerStats,
+):
+    """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(Table(children=lines, cols=4, rheaders=1))
+
+
+def report_messages_stats(
+    sect,
+    stats: CheckerStats,
+    _: CheckerStats,
+):
+    """make messages type report"""
+    if not stats["by_msg"]:
+        # don't print this report when we didn't detected any errors
+        raise exceptions.EmptyReportError()
+    by_msg_stats: Dict[str, int] = stats["by_msg"]  # type: ignore
+    in_order: List[Tuple[int, str]] = sorted(
+        (value, msg_id)
+        for msg_id, value in by_msg_stats.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(Table(children=lines, cols=2, rheaders=1))
+
+
+def report_messages_by_module_stats(
+    sect,
+    stats: CheckerStats,
+    _: CheckerStats,
+):
+    """make errors / warnings by modules report"""
+    module_stats: Dict[str, Dict[str, int]] = stats["by_module"]  # type: ignore
+    if len(module_stats) == 1:
+        # don't print this report when we are analysing a single module
+        raise exceptions.EmptyReportError()
+    by_mod: DefaultDict[str, Dict[str, Union[int, float]]] = collections.defaultdict(
+        dict
+    )
+    for m_type in ("fatal", "error", "warning", "refactor", "convention"):
+        total: int = stats[m_type]  # type: ignore
+        for module in module_stats.keys():
+            mod_total = module_stats[module][m_type]
+            percent = 0 if total == 0 else 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(f"{val:.2f}")
+    if len(lines) == 5:
+        raise exceptions.EmptyReportError()
+    sect.append(Table(children=lines, cols=5, rheaders=1))
diff --git a/pylint/lint/run.py b/pylint/lint/run.py
new file mode 100644
index 000000000..d84ed2703
--- /dev/null
+++ b/pylint/lint/run.py
@@ -0,0 +1,463 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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(f"%-18s: {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": "Display a list of all pylint's messages divided by whether "
+                        "they are emittable with the given interpreter.",
+                    },
+                ),
+                (
+                    "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, "
+                        "disabled and non-emittable 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.",
+                    },
+                ),
+                (
+                    "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(
+                f"Jobs number ({linter.config.jobs}) should be greater than or equal to 0",
+                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", encoding="utf-8") 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)
+            elif linter.any_fail_on_issues():
+                # We need to make sure we return a failing exit code in this case.
+                # So we use self.linter.msg_status if that is non-zero, otherwise we just return 1.
+                sys.exit(self.linter.msg_status or 1)
+            elif score_value is not None and score_value >= linter.config.fail_under:
+                sys.exit(0)
+            else:
+                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_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 000000000..ed0cefb77
--- /dev/null
+++ b/pylint/lint/utils.py
@@ -0,0 +1,133 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import contextlib
+import sys
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+from pylint.config import PYLINT_HOME
+from pylint.lint.expand_modules import get_python_path
+
+
+class ArgumentPreprocessingError(Exception):
+    """Raised if an error occurs during argument preprocessing."""
+
+
+def prepare_crash_report(ex: Exception, filepath: str, crash_file_path: str) -> Path:
+    issue_template_path = (
+        Path(PYLINT_HOME) / datetime.now().strftime(str(crash_file_path))
+    ).resolve()
+    with open(filepath, encoding="utf8") as f:
+        file_content = f.read()
+    template = ""
+    if not issue_template_path.exists():
+        template = """\
+First, please verify that the bug is not already filled:
+https://github.com/PyCQA/pylint/issues/
+
+Then create a new crash issue:
+https://github.com/PyCQA/pylint/issues/new?assignees=&labels=crash%2Cneeds+triage&template=BUG-REPORT.yml
+
+"""
+    template += f"""\
+
+Issue title:
+Crash ``{ex}`` (if possible, be more specific about what made pylint crash)
+Content:
+When parsing the following file:
+
+<!--
+ If sharing the code is not an option, please state so,
+ but providing only the stacktrace would still be helpful.
+ -->
+
+```python
+{file_content}
+```
+
+pylint crashed with a ``{ex.__class__.__name__}`` and with the following stacktrace:
+```
+"""
+    try:
+        with open(issue_template_path, "a", encoding="utf8") as f:
+            f.write(template)
+            traceback.print_exc(file=f)
+            f.write("```\n")
+    except FileNotFoundError:
+        print(f"Can't write the issue template for the crash in {issue_template_path}.")
+    return issue_template_path
+
+
+def get_fatal_error_message(filepath: str, issue_template_path: Path) -> str:
+    return (
+        f"Fatal error while checking '{filepath}'. "
+        f"Please open an issue in our bug tracker so we address this. "
+        f"There is a pre-filled template that you can use in '{issue_template_path}'."
+    )
+
+
+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 not arg.startswith("--"):
+            i += 1
+        else:
+            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 = f"Option {option} expects a value"
+                        raise ArgumentPreprocessingError(msg)
+                    val = args[i]
+                    del args[i]
+                elif not takearg and val is not None:
+                    msg = f"Option {option} doesn't expects a value"
+                    raise ArgumentPreprocessingError(msg)
+                cb(option, val)
+
+
+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 000000000..346e964f1
--- /dev/null
+++ b/pylint/message/__init__.py
@@ -0,0 +1,54 @@
+# 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>
+# 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/main/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 000000000..df0e7079e
--- /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/main/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 000000000..30dacb32f
--- /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/main/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]] = None,
+        maxversion: Optional[Tuple[int, 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 += f" This message belongs to the {self.checker_name} checker."
+        title = self.msg
+        if self.minversion or self.maxversion:
+            restr = []
+            if self.minversion:
+                restr.append(f"< {'.'.join(str(n) for n in self.minversion)}")
+            if self.maxversion:
+                restr.append(f">= {'.'.join(str(n) for n in self.maxversion)}")
+            restriction = " or ".join(restr)
+            if checkerref:
+                desc += f" It can't be emitted when using Python {restriction}."
+            else:
+                desc += (
+                    f" This message can't be emitted when using Python {restriction}."
+                )
+        msg_help = normalize_text(" ".join(desc.split()), indent="  ")
+        message_id = f"{self.symbol} ({self.msgid})"
+        if title != "%s":
+            title = title.splitlines()[0]
+            return f":{message_id}: *{title.rstrip(' ')}*\n{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 000000000..c715d8561
--- /dev/null
+++ b/pylint/message/message_definition_store.py
@@ -0,0 +1,97 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import collections
+from typing import Dict, List, Tuple, 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."""
+        emittable, non_emittable = self.find_emittable_messages()
+        print("Emittable messages with current interpreter:")
+        for msg in emittable:
+            print(msg.format_help(checkerref=False))
+        print("\nNon-emittable messages with current interpreter:")
+        for msg in non_emittable:
+            print(msg.format_help(checkerref=False))
+        print("")
+
+    def find_emittable_messages(
+        self,
+    ) -> Tuple[List[MessageDefinition], List[MessageDefinition]]:
+        """Finds all emittable and non-emittable messages"""
+        messages = sorted(self._messages_definitions.values(), key=lambda m: m.msgid)
+        emittable = []
+        non_emittable = []
+        for message in messages:
+            if message.may_be_emitted():
+                emittable.append(message)
+            else:
+                non_emittable.append(message)
+        return emittable, non_emittable
diff --git a/pylint/message/message_handler_mix_in.py b/pylint/message/message_handler_mix_in.py
new file mode 100644
index 000000000..6d24131a7
--- /dev/null
+++ b/pylint/message/message_handler_mix_in.py
@@ -0,0 +1,403 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import sys
+from io import TextIOWrapper
+from typing import List, TextIO, Tuple, Union
+
+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,
+    NoLineSuppliedError,
+    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 disable_next(
+        self,
+        msgid: str,
+        scope: str = "package",
+        line: Union[bool, int] = None,
+        ignore_unknown: bool = False,
+    ):
+        if not line:
+            raise NoLineSuppliedError
+        self._set_msg_status(
+            msgid,
+            enable=False,
+            scope=scope,
+            line=line + 1,
+            ignore_unknown=ignore_unknown,
+        )
+        self._register_by_id_managed_msg(msgid, line + 1)
+
+    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)
+            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(
+                        f"Message {message_definition.msgid} must provide line, got None"
+                    )
+                if node is not None:
+                    raise InvalidMessageError(
+                        f"Message {message_definition.msgid} must only provide line, "
+                        f"got line={line}, node={node}"
+                    )
+            elif message_definition.scope == WarningScope.NODE:
+                # Node-based warnings may provide an override line.
+                if node is None:
+                    raise InvalidMessageError(
+                        f"Message {message_definition.msgid} must provide Node, got None"
+                    )
+
+    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 = f"{section.capitalize()} options"
+                        result += get_rst_title(title, "~")
+                        result += f"{get_rst_section(None, options)}\n"
+        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: TextIO = sys.stdout) -> None:
+        """output a full documentation in ReST format"""
+        print(self.get_checkers_documentation()[:-1], file=stream)
+
+    @staticmethod
+    def _print_checker_doc(information, stream: TextIOWrapper) -> None:
+        """Helper method used by doc/exts/pylint_extensions.py."""
+        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 000000000..f0ba0c2de
--- /dev/null
+++ b/pylint/message/message_id_store.py
@@ -0,0 +1,118 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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.upper()]
+        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 and existing_symbol != symbol:
+            # See https://github.com/python/mypy/issues/10559
+            self._raise_duplicate_symbol(msgid, symbol, existing_symbol)
+
+    @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()
+        msgid = None
+        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)
+            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 000000000..fdbbe1e83
--- /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/main/LICENSE
+
+"""
+pyreverse.extensions
+"""
+
+__revision__ = "$Id $"
diff --git a/pylint/pyreverse/diadefslib.py b/pylint/pyreverse/diadefslib.py
new file mode 100644
index 000000000..508bbfa82
--- /dev/null
+++ b/pylint/pyreverse/diadefslib.py
@@ -0,0 +1,245 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""handle diagram generation options for class diagram or default diagrams
+"""
+
+from typing import Any, Optional
+
+import astroid
+from astroid import nodes
+
+from pylint.pyreverse.diagrams import ClassDiagram, PackageDiagram
+from pylint.pyreverse.inspector import Project
+from pylint.pyreverse.utils import LocalsVisitor
+
+# 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"
+
+    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, nodes.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: Project) -> None:
+        """visit a pyreverse.utils.Project node
+
+        create a diagram definition for packages
+        """
+        mode = self.config.mode
+        if len(node.modules) > 1:
+            self.pkgdiagram: Optional[PackageDiagram] = PackageDiagram(
+                f"packages {node.name}", mode
+            )
+        else:
+            self.pkgdiagram = None
+        self.classdiagram = ClassDiagram(f"classes {node.name}", mode)
+
+    def leave_project(self, _: Project) -> Any:
+        """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: nodes.Module) -> None:
+        """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: nodes.ClassDef) -> None:
+        """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: nodes.ImportFrom) -> None:
+        """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 000000000..27aec8159
--- /dev/null
+++ b/pylint/pyreverse/diagrams.py
@@ -0,0 +1,273 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.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 Mark Byrne <31762852+mbyrnepr2@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/main/LICENSE
+
+"""diagram objects
+"""
+
+import astroid
+from astroid import nodes
+
+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 PackageEntity(DiagramEntity):
+    """A diagram object representing a package"""
+
+
+class ClassEntity(DiagramEntity):
+    """A diagram object representing a class"""
+
+    def __init__(self, title, node):
+        super().__init__(title=title, node=node)
+        self.attrs = None
+        self.methods = None
+
+
+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, nodes.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 = f"{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, nodes.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_lst):
+        """return class names if needed in diagram"""
+        names = []
+        for node in nodes_lst:
+            if isinstance(node, astroid.Instance):
+                node = node._proxied
+            if (
+                isinstance(node, (nodes.ClassDef, nodes.Name, nodes.Subscript))
+                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, nodes.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, nodes.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 == f"{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/dot_printer.py b/pylint/pyreverse/dot_printer.py
new file mode 100644
index 000000000..fea9046f4
--- /dev/null
+++ b/pylint/pyreverse/dot_printer.py
@@ -0,0 +1,163 @@
+# Copyright (c) 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Nick Drozd <nicholasdrozd@gmail.com>
+# 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/main/LICENSE
+
+"""
+Class to generate files in dot format and image formats supported by Graphviz.
+"""
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, FrozenSet, List, Optional
+
+from astroid import nodes
+
+from pylint.pyreverse.printer import EdgeType, Layout, NodeProperties, NodeType, Printer
+from pylint.pyreverse.utils import check_graphviz_availability, get_annotation_label
+
+ALLOWED_CHARSETS: FrozenSet[str] = frozenset(("utf-8", "iso-8859-1", "latin1"))
+SHAPES: Dict[NodeType, str] = {
+    NodeType.PACKAGE: "box",
+    NodeType.INTERFACE: "record",
+    NodeType.CLASS: "record",
+}
+ARROWS: Dict[EdgeType, Dict] = {
+    EdgeType.INHERITS: dict(arrowtail="none", arrowhead="empty"),
+    EdgeType.IMPLEMENTS: dict(arrowtail="node", arrowhead="empty", style="dashed"),
+    EdgeType.ASSOCIATION: dict(
+        fontcolor="green", arrowtail="none", arrowhead="diamond", style="solid"
+    ),
+    EdgeType.USES: dict(arrowtail="none", arrowhead="open"),
+}
+
+
+class DotPrinter(Printer):
+    DEFAULT_COLOR = "black"
+
+    def __init__(
+        self,
+        title: str,
+        layout: Optional[Layout] = None,
+        use_automatic_namespace: Optional[bool] = None,
+    ):
+        layout = layout or Layout.BOTTOM_TO_TOP
+        self.charset = "utf-8"
+        super().__init__(title, layout, use_automatic_namespace)
+
+    def _open_graph(self) -> None:
+        """Emit the header lines"""
+        self.emit(f'digraph "{self.title}" {{')
+        if self.layout:
+            self.emit(f"rankdir={self.layout.value}")
+        if self.charset:
+            assert (
+                self.charset.lower() in ALLOWED_CHARSETS
+            ), f"unsupported charset {self.charset}"
+            self.emit(f'charset="{self.charset}"')
+
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node. Nodes can be classes, packages, participants etc."""
+        if properties is None:
+            properties = NodeProperties(label=name)
+        shape = SHAPES[type_]
+        color = properties.color if properties.color is not None else self.DEFAULT_COLOR
+        style = "filled" if color != self.DEFAULT_COLOR else "solid"
+        label = self._build_label_for_node(properties)
+        label_part = f', label="{label}"' if label else ""
+        fontcolor_part = (
+            f', fontcolor="{properties.fontcolor}"' if properties.fontcolor else ""
+        )
+        self.emit(
+            f'"{name}" [color="{color}"{fontcolor_part}{label_part}, shape="{shape}", style="{style}"];'
+        )
+
+    def _build_label_for_node(
+        self, properties: NodeProperties, is_interface: Optional[bool] = False
+    ) -> str:
+        if not properties.label:
+            return ""
+
+        label: str = properties.label
+        if is_interface:
+            # add a stereotype
+            label = "<<interface>>\\n" + label
+
+        if properties.attrs is None and properties.methods is None:
+            # return a "compact" form which only displays the class name in a box
+            return label
+
+        # Add class attributes
+        attrs: List[str] = properties.attrs or []
+        label = "{" + label + "|" + r"\l".join(attrs) + r"\l|"
+
+        # Add class methods
+        methods: List[nodes.FunctionDef] = properties.methods or []
+        for func in methods:
+            args = self._get_method_arguments(func)
+            label += fr"{func.name}({', '.join(args)})"
+            if func.returns:
+                label += ": " + get_annotation_label(func.returns)
+            label += r"\l"
+        label += "}"
+        return label
+
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+        arrowstyle = ARROWS[type_]
+        attrs = [f'{prop}="{value}"' for prop, value in arrowstyle.items()]
+        if label:
+            attrs.append(f'label="{label}"')
+        self.emit(f'"{from_node}" -> "{to_node}" [{", ".join(sorted(attrs))}];')
+
+    def generate(self, outputfile: str) -> None:
+        self._close_graph()
+        graphviz_extensions = ("dot", "gv")
+        name = self.title
+        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 = Path(outputfile).suffix.lstrip(".")
+            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 open(dot_sourcepath, "w", encoding="utf8") as outfile:
+            outfile.writelines(self.lines)
+        if target not in graphviz_extensions:
+            check_graphviz_availability()
+            use_shell = sys.platform == "win32"
+            subprocess.call(
+                ["dot", "-T", target, dot_sourcepath, "-o", outputfile],
+                shell=use_shell,
+            )
+            os.unlink(dot_sourcepath)
+
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
+        self.emit("}\n")
diff --git a/pylint/pyreverse/inspector.py b/pylint/pyreverse/inspector.py
new file mode 100644
index 000000000..25819f5aa
--- /dev/null
+++ b/pylint/pyreverse/inspector.py
@@ -0,0 +1,345 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Nick Drozd <nicholasdrozd@gmail.com>
+# Copyright (c) 2021 Mark Byrne <31762852+mbyrnepr2@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/main/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 astroid import nodes
+
+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(f"parsing {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 nodes.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 Project:
+    """a project handle a set of modules / packages"""
+
+    def __init__(self, name=""):
+        self.name = name
+        self.uid = None
+        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)>"
+
+
+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: Project) -> None:
+        """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_module(self, node: nodes.Module) -> None:
+        """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: nodes.ClassDef) -> None:
+        """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, nodes.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: nodes.FunctionDef) -> None:
+        """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: nodes.AssignName) -> None:
+        """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()
+        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, nodes.ClassDef):
+                self.visit_classdef(frame)
+            elif isinstance(frame, nodes.FunctionDef):
+                self.visit_functiondef(frame)
+            else:
+                self.visit_module(frame)
+
+        current = frame.locals_type[node.name]
+        frame.locals_type[node.name] = list(set(current) | utils.infer_node(node))
+
+    @staticmethod
+    def handle_assignattr_type(node, parent):
+        """handle an astroid.assignattr node
+
+        handle instance_attrs_type
+        """
+        current = set(parent.instance_attrs_type[node.attrname])
+        parent.instance_attrs_type[node.attrname] = list(
+            current | utils.infer_node(node)
+        )
+
+    def visit_import(self, node: nodes.Import) -> None:
+        """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: nodes.ImportFrom) -> None:
+        """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 = f"{'.'.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)
+
+
+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 000000000..7e4aff102
--- /dev/null
+++ b/pylint/pyreverse/main.py
@@ -0,0 +1,235 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Mark Byrne <31762852+mbyrnepr2@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/main/LICENSE
+
+"""
+  %prog [options] <packages>
+
+  create UML diagrams for classes and modules in <packages>
+"""
+import os
+import sys
+from typing import Iterable
+
+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 check_graphviz_availability, 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.",
+        ),
+    ),
+    (
+        "colorized",
+        dict(
+            dest="colorized",
+            action="store_true",
+            default=False,
+            help="Use colored output. Classes/modules of the same package get the same color.",
+        ),
+    ),
+    (
+        "max-color-depth",
+        dict(
+            dest="max_color_depth",
+            action="store",
+            default=2,
+            metavar="<depth>",
+            type="int",
+            help="Use separate colors up to package depth of <depth>",
+        ),
+    ),
+    (
+        "ignore",
+        dict(
+            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",
+        dict(
+            default="",
+            type="string",
+            short="p",
+            metavar="<project name>",
+            help="set the project name.",
+        ),
+    ),
+    (
+        "output-directory",
+        dict(
+            default="",
+            type="string",
+            short="d",
+            action="store",
+            metavar="<output_directory>",
+            help="set the output directory path.",
+        ),
+    ),
+)
+
+
+class Run(ConfigurationMixIn):
+    """base class providing common behaviour for pyreverse commands"""
+
+    options = OPTIONS
+
+    def __init__(self, args: Iterable[str]):
+        ConfigurationMixIn.__init__(self, usage=__doc__)
+        insert_default_options()
+        args = self.load_command_line_configuration(args)
+        if self.config.output_format not in ("dot", "vcg"):
+            check_graphviz_availability()
+
+        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)
+        writer.DiagramWriter(self.config).write(diadefs)
+        return 0
+
+
+if __name__ == "__main__":
+    Run(sys.argv[1:])
diff --git a/pylint/pyreverse/plantuml_printer.py b/pylint/pyreverse/plantuml_printer.py
new file mode 100644
index 000000000..c73cddd5e
--- /dev/null
+++ b/pylint/pyreverse/plantuml_printer.py
@@ -0,0 +1,97 @@
+# 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/main/LICENSE
+
+"""
+Class to generate files in dot format and image formats supported by Graphviz.
+"""
+from typing import Dict, Optional
+
+from pylint.pyreverse.printer import EdgeType, Layout, NodeProperties, NodeType, Printer
+from pylint.pyreverse.utils import get_annotation_label
+
+
+class PlantUmlPrinter(Printer):
+    """Printer for PlantUML diagrams"""
+
+    DEFAULT_COLOR = "black"
+
+    NODES: Dict[NodeType, str] = {
+        NodeType.CLASS: "class",
+        NodeType.INTERFACE: "class",
+        NodeType.PACKAGE: "package",
+    }
+    ARROWS: Dict[EdgeType, str] = {
+        EdgeType.INHERITS: "--|>",
+        EdgeType.IMPLEMENTS: "..|>",
+        EdgeType.ASSOCIATION: "--*",
+        EdgeType.USES: "-->",
+    }
+
+    def _open_graph(self) -> None:
+        """Emit the header lines"""
+        self.emit("@startuml " + self.title)
+        if not self.use_automatic_namespace:
+            self.emit("set namespaceSeparator none")
+        if self.layout:
+            if self.layout is Layout.LEFT_TO_RIGHT:
+                self.emit("left to right direction")
+            elif self.layout is Layout.TOP_TO_BOTTOM:
+                self.emit("top to bottom direction")
+            else:
+                raise ValueError(
+                    f"Unsupported layout {self.layout}. PlantUmlPrinter only supports left to right and top to bottom layout."
+                )
+
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node. Nodes can be classes, packages, participants etc."""
+        if properties is None:
+            properties = NodeProperties(label=name)
+        stereotype = " << interface >>" if type_ is NodeType.INTERFACE else ""
+        nodetype = self.NODES[type_]
+        if properties.color and properties.color != self.DEFAULT_COLOR:
+            color = f" #{properties.color}"
+        else:
+            color = ""
+        body = []
+        if properties.attrs:
+            body.extend(properties.attrs)
+        if properties.methods:
+            for func in properties.methods:
+                args = self._get_method_arguments(func)
+                line = f"{func.name}({', '.join(args)})"
+                if func.returns:
+                    line += " -> " + get_annotation_label(func.returns)
+                body.append(line)
+        label = properties.label if properties.label is not None else name
+        if properties.fontcolor and properties.fontcolor != self.DEFAULT_COLOR:
+            label = f"<color:{properties.fontcolor}>{label}</color>"
+        self.emit(f'{nodetype} "{label}" as {name}{stereotype}{color} {{')
+        self._inc_indent()
+        for line in body:
+            self.emit(line)
+        self._dec_indent()
+        self.emit("}")
+
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+        edge = f"{from_node} {self.ARROWS[type_]} {to_node}"
+        if label:
+            edge += f" : {label}"
+        self.emit(edge)
+
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
+        self.emit("@enduml")
diff --git a/pylint/pyreverse/printer.py b/pylint/pyreverse/printer.py
new file mode 100644
index 000000000..bdd561898
--- /dev/null
+++ b/pylint/pyreverse/printer.py
@@ -0,0 +1,131 @@
+# Copyright (c) 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# 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/main/LICENSE
+
+"""
+Base class defining the interface for a printer.
+"""
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import List, NamedTuple, Optional
+
+from astroid import nodes
+
+from pylint.pyreverse.utils import get_annotation_label
+
+
+class NodeType(Enum):
+    CLASS = "class"
+    INTERFACE = "interface"
+    PACKAGE = "package"
+
+
+class EdgeType(Enum):
+    INHERITS = "inherits"
+    IMPLEMENTS = "implements"
+    ASSOCIATION = "association"
+    USES = "uses"
+
+
+class Layout(Enum):
+    LEFT_TO_RIGHT = "LR"
+    RIGHT_TO_LEFT = "RL"
+    TOP_TO_BOTTOM = "TB"
+    BOTTOM_TO_TOP = "BT"
+
+
+class NodeProperties(NamedTuple):
+    label: str
+    attrs: Optional[List[str]] = None
+    methods: Optional[List[nodes.FunctionDef]] = None
+    color: Optional[str] = None
+    fontcolor: Optional[str] = None
+
+
+class Printer(ABC):
+    """Base class defining the interface for a printer"""
+
+    def __init__(
+        self,
+        title: str,
+        layout: Optional[Layout] = None,
+        use_automatic_namespace: Optional[bool] = None,
+    ):
+        self.title: str = title
+        self.layout = layout
+        self.use_automatic_namespace = use_automatic_namespace
+        self.lines: List[str] = []
+        self._indent = ""
+        self._open_graph()
+
+    def _inc_indent(self):
+        """increment indentation"""
+        self._indent += "  "
+
+    def _dec_indent(self):
+        """decrement indentation"""
+        self._indent = self._indent[:-2]
+
+    @abstractmethod
+    def _open_graph(self) -> None:
+        """Emit the header lines, i.e. all boilerplate code that defines things like layout etc."""
+
+    def emit(self, line: str, force_newline: Optional[bool] = True) -> None:
+        if force_newline and not line.endswith("\n"):
+            line += "\n"
+        self.lines.append(self._indent + line)
+
+    @abstractmethod
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node. Nodes can be classes, packages, participants etc."""
+
+    @abstractmethod
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+
+    @staticmethod
+    def _get_method_arguments(method: nodes.FunctionDef) -> List[str]:
+        if method.args.args:
+            arguments: List[nodes.AssignName] = [
+                arg for arg in method.args.args if arg.name != "self"
+            ]
+        else:
+            arguments = []
+
+        annotations = dict(zip(arguments, method.args.annotations[1:]))
+        for arg in arguments:
+            annotation_label = ""
+            ann = annotations.get(arg)
+            if ann:
+                annotation_label = get_annotation_label(ann)
+            annotations[arg] = annotation_label
+
+        return [
+            f"{arg.name}: {ann}" if ann else f"{arg.name}"
+            for arg, ann in annotations.items()
+        ]
+
+    def generate(self, outputfile: str) -> None:
+        """Generate and save the final outputfile."""
+        self._close_graph()
+        with open(outputfile, "w", encoding="utf-8") as outfile:
+            outfile.writelines(self.lines)
+
+    @abstractmethod
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
diff --git a/pylint/pyreverse/printer_factory.py b/pylint/pyreverse/printer_factory.py
new file mode 100644
index 000000000..c52f24a4d
--- /dev/null
+++ b/pylint/pyreverse/printer_factory.py
@@ -0,0 +1,22 @@
+# 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/main/LICENSE
+
+from typing import Type
+
+from pylint.pyreverse.dot_printer import DotPrinter
+from pylint.pyreverse.plantuml_printer import PlantUmlPrinter
+from pylint.pyreverse.printer import Printer
+from pylint.pyreverse.vcg_printer import VCGPrinter
+
+filetype_to_printer = {
+    "vcg": VCGPrinter,
+    "plantuml": PlantUmlPrinter,
+    "puml": PlantUmlPrinter,
+    "dot": DotPrinter,
+}
+
+
+def get_printer_for_filetype(filetype: str) -> Type[Printer]:
+    return filetype_to_printer.get(filetype, DotPrinter)
diff --git a/pylint/pyreverse/utils.py b/pylint/pyreverse/utils.py
new file mode 100644
index 000000000..904f6eacb
--- /dev/null
+++ b/pylint/pyreverse/utils.py
@@ -0,0 +1,295 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Mark Byrne <31762852+mbyrnepr2@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/main/LICENSE
+
+"""Generic classes/functions for pyreverse core/extensions. """
+import os
+import re
+import shutil
+import sys
+from typing import Optional, Union
+
+import astroid
+from astroid import nodes
+
+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, encoding="utf-8") 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(f"Unknown filter mode {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, f"visit_{kid}", getattr(handler, "visit_default", None)
+            )
+            l_method = getattr(
+                handler, f"leave_{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
+
+
+def get_annotation_label(ann: Union[nodes.Name, nodes.Subscript]) -> str:
+    label = ""
+    if isinstance(ann, nodes.Subscript):
+        label = ann.as_string()
+    elif isinstance(ann, nodes.Name):
+        label = ann.name
+    return label
+
+
+def get_annotation(
+    node: Union[nodes.AssignAttr, nodes.AssignName]
+) -> Optional[Union[nodes.Name, nodes.Subscript]]:
+    """return the annotation for `node`"""
+    ann = None
+    if isinstance(node.parent, nodes.AnnAssign):
+        ann = node.parent.annotation
+    elif isinstance(node, nodes.AssignAttr):
+        init_method = node.parent.parent
+        try:
+            annotations = dict(zip(init_method.locals, init_method.args.annotations))
+            ann = annotations.get(node.parent.value.name)
+        except AttributeError:
+            pass
+    else:
+        return ann
+
+    try:
+        default, *_ = node.infer()
+    except astroid.InferenceError:
+        default = ""
+
+    label = get_annotation_label(ann)
+    if ann:
+        label = (
+            fr"Optional[{label}]"
+            if getattr(default, "value", "value") is None
+            and not label.startswith("Optional")
+            else label
+        )
+    if label:
+        ann.name = label
+    return ann
+
+
+def infer_node(node: Union[nodes.AssignAttr, nodes.AssignName]) -> set:
+    """Return a set containing the node annotation if it exists
+    otherwise return a set of the inferred types using the NodeNG.infer method"""
+
+    ann = get_annotation(node)
+    try:
+        if ann:
+            if isinstance(ann, nodes.Subscript):
+                return {ann}
+            return set(ann.infer())
+        return set(node.infer())
+    except astroid.InferenceError:
+        return {ann} if ann else set()
+
+
+def check_graphviz_availability():
+    """Check if the ``dot`` command is available on the machine.
+    This is needed if image output is desired and ``dot`` is used to convert
+    from *.dot or *.gv into the final output format."""
+    if shutil.which("dot") is None:
+        print(
+            "The requested output format is currently not available.\n"
+            "Please install 'Graphviz' to have other output formats "
+            "than 'dot' or 'vcg'."
+        )
+        sys.exit(32)
diff --git a/pylint/pyreverse/vcg_printer.py b/pylint/pyreverse/vcg_printer.py
new file mode 100644
index 000000000..bbc131760
--- /dev/null
+++ b/pylint/pyreverse/vcg_printer.py
@@ -0,0 +1,290 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@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/main/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.
+"""
+from typing import Any, Dict, Mapping, Optional
+
+from pylint.pyreverse.printer import EdgeType, Layout, NodeProperties, NodeType, Printer
+
+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,
+}
+SHAPES: Dict[NodeType, str] = {
+    NodeType.PACKAGE: "box",
+    NodeType.CLASS: "box",
+    NodeType.INTERFACE: "ellipse",
+}
+ARROWS: Dict[EdgeType, Dict] = {
+    EdgeType.USES: dict(arrowstyle="solid", backarrowstyle="none", backarrowsize=0),
+    EdgeType.INHERITS: dict(
+        arrowstyle="solid", backarrowstyle="none", backarrowsize=10
+    ),
+    EdgeType.IMPLEMENTS: dict(
+        arrowstyle="solid",
+        backarrowstyle="none",
+        linestyle="dotted",
+        backarrowsize=10,
+    ),
+    EdgeType.ASSOCIATION: dict(
+        arrowstyle="solid", backarrowstyle="none", textcolor="green"
+    ),
+}
+ORIENTATION: Dict[Layout, str] = {
+    Layout.LEFT_TO_RIGHT: "left_to_right",
+    Layout.RIGHT_TO_LEFT: "right_to_left",
+    Layout.TOP_TO_BOTTOM: "top_to_bottom",
+    Layout.BOTTOM_TO_TOP: "bottom_to_top",
+}
+
+# Misc utilities ###############################################################
+
+
+class VCGPrinter(Printer):
+    def _open_graph(self) -> None:
+        """Emit the header lines"""
+        self.emit("graph:{\n")
+        self._inc_indent()
+        self._write_attributes(
+            GRAPH_ATTRS,
+            title=self.title,
+            layoutalgorithm="dfs",
+            late_edge_labels="yes",
+            port_sharing="no",
+            manhattan_edges="yes",
+        )
+        if self.layout:
+            self._write_attributes(GRAPH_ATTRS, orientation=ORIENTATION[self.layout])
+
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
+        self._dec_indent()
+        self.emit("}")
+
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node. Nodes can be classes, packages, participants etc."""
+        if properties is None:
+            properties = NodeProperties(label=name)
+        elif properties.label is None:
+            properties.label = name
+        self.emit(f'node: {{title:"{name}"', force_newline=False)
+        self._write_attributes(
+            NODE_ATTRS,
+            label=self._build_label_for_node(properties),
+            shape=SHAPES[type_],
+        )
+        self.emit("}")
+
+    @staticmethod
+    def _build_label_for_node(properties: NodeProperties) -> str:
+        fontcolor = "\f09" if properties.fontcolor == "red" else ""
+        label = fr"\fb{fontcolor}{properties.label}\fn"
+        if properties.attrs is None and properties.methods is None:
+            # return a compact form which only displays the classname in a box
+            return label
+        attrs = properties.attrs or []
+        methods = properties.methods or []
+        method_names = [func.name for func in methods]
+        # box width for UML like diagram
+        maxlen = max(len(name) for name in [properties.label] + method_names + 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 method_names:
+            label = fr"{label}\n\f10{func}()"
+        return label
+
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+        self.emit(
+            f'edge: {{sourcename:"{from_node}" targetname:"{to_node}"',
+            force_newline=False,
+        )
+        attributes = ARROWS[type_]
+        if label:
+            attributes["label"] = label
+        self._write_attributes(
+            EDGE_ATTRS,
+            **attributes,
+        )
+        self.emit("}")
+
+    def _write_attributes(self, attributes_dict: Mapping[str, Any], **args) -> None:
+        """write graph, node or edge attributes"""
+        for key, value in args.items():
+            try:
+                _type = attributes_dict[key]
+            except KeyError as e:
+                raise Exception(
+                    f"no such attribute {key}\npossible attributes are {attributes_dict.keys()}"
+                ) from e
+
+            if not _type:
+                self.emit(f'{key}:"{value}"\n')
+            elif _type == 1:
+                self.emit(f"{key}:{int(value)}\n")
+            elif value in _type:
+                self.emit(f"{key}:{value}\n")
+            else:
+                raise Exception(
+                    f"value {value} isn't correct for attribute {key} correct values are {type}"
+                )
diff --git a/pylint/pyreverse/writer.py b/pylint/pyreverse/writer.py
new file mode 100644
index 000000000..fa2ce1836
--- /dev/null
+++ b/pylint/pyreverse/writer.py
@@ -0,0 +1,175 @@
+# 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 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Mark Byrne <31762852+mbyrnepr2@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/main/LICENSE
+
+"""Utilities for creating VCG and Dot diagrams"""
+
+import itertools
+import os
+
+from astroid import modutils, nodes
+
+from pylint.pyreverse.diagrams import (
+    ClassDiagram,
+    ClassEntity,
+    DiagramEntity,
+    PackageDiagram,
+    PackageEntity,
+)
+from pylint.pyreverse.printer import EdgeType, NodeProperties, NodeType
+from pylint.pyreverse.printer_factory import get_printer_for_filetype
+from pylint.pyreverse.utils import is_exception
+
+
+class DiagramWriter:
+    """base class for writing project diagrams"""
+
+    def __init__(self, config):
+        self.config = config
+        self.printer_class = get_printer_for_filetype(self.config.output_format)
+        self.printer = None  # defined in set_printer
+        self.file_name = ""  # defined in set_printer
+        self.depth = self.config.max_color_depth
+        self.available_colors = itertools.cycle(
+            [
+                "aliceblue",
+                "antiquewhite",
+                "aquamarine",
+                "burlywood",
+                "cadetblue",
+                "chartreuse",
+                "chocolate",
+                "coral",
+                "cornflowerblue",
+                "cyan",
+                "darkgoldenrod",
+                "darkseagreen",
+                "dodgerblue",
+                "forestgreen",
+                "gold",
+                "hotpink",
+                "mediumspringgreen",
+            ]
+        )
+        self.used_colors = {}
+
+    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.save()
+
+    def write_packages(self, diagram: PackageDiagram) -> None:
+        """write a package diagram"""
+        # sorted to get predictable (hence testable) results
+        for module in sorted(diagram.modules(), key=lambda x: x.title):
+            module.fig_id = module.node.qname()
+            self.printer.emit_node(
+                module.fig_id,
+                type_=NodeType.PACKAGE,
+                properties=self.get_package_properties(module),
+            )
+        # package dependencies
+        for rel in diagram.get_relationships("depends"):
+            self.printer.emit_edge(
+                rel.from_object.fig_id,
+                rel.to_object.fig_id,
+                type_=EdgeType.USES,
+            )
+
+    def write_classes(self, diagram: ClassDiagram) -> None:
+        """write a class diagram"""
+        # sorted to get predictable (hence testable) results
+        for obj in sorted(diagram.objects, key=lambda x: x.title):
+            obj.fig_id = obj.node.qname()
+            type_ = NodeType.INTERFACE if obj.shape == "interface" else NodeType.CLASS
+            self.printer.emit_node(
+                obj.fig_id, type_=type_, properties=self.get_class_properties(obj)
+            )
+        # inheritance links
+        for rel in diagram.get_relationships("specialization"):
+            self.printer.emit_edge(
+                rel.from_object.fig_id,
+                rel.to_object.fig_id,
+                type_=EdgeType.INHERITS,
+            )
+        # implementation links
+        for rel in diagram.get_relationships("implements"):
+            self.printer.emit_edge(
+                rel.from_object.fig_id,
+                rel.to_object.fig_id,
+                type_=EdgeType.IMPLEMENTS,
+            )
+        # 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,
+                type_=EdgeType.ASSOCIATION,
+            )
+
+    def set_printer(self, file_name: str, basename: str) -> None:
+        """set printer"""
+        self.printer = self.printer_class(basename)
+        self.file_name = file_name
+
+    def get_package_properties(self, obj: PackageEntity) -> NodeProperties:
+        """get label and shape for packages."""
+        return NodeProperties(
+            label=obj.title,
+            color=self.get_shape_color(obj) if self.config.colorized else "black",
+        )
+
+    def get_class_properties(self, obj: ClassEntity) -> NodeProperties:
+        """get label and shape for classes."""
+        properties = NodeProperties(
+            label=obj.title,
+            attrs=obj.attrs if not self.config.only_classnames else None,
+            methods=obj.methods if not self.config.only_classnames else None,
+            fontcolor="red" if is_exception(obj.node) else "black",
+            color=self.get_shape_color(obj) if self.config.colorized else "black",
+        )
+        return properties
+
+    def get_shape_color(self, obj: DiagramEntity) -> str:
+        """get shape color"""
+        qualified_name = obj.node.qname()
+        if modutils.is_standard_module(qualified_name.split(".", maxsplit=1)[0]):
+            return "grey"
+        if isinstance(obj.node, nodes.ClassDef):
+            package = qualified_name.rsplit(".", maxsplit=2)[0]
+        elif obj.node.package:
+            package = qualified_name
+        else:
+            package = qualified_name.rsplit(".", maxsplit=1)[0]
+        base_name = ".".join(package.split(".", self.depth)[: self.depth])
+        if base_name not in self.used_colors:
+            self.used_colors[base_name] = next(self.available_colors)
+        return self.used_colors[base_name]
+
+    def save(self) -> None:
+        """write to disk"""
+        self.printer.generate(self.file_name)
diff --git a/pylint/reporters/__init__.py b/pylint/reporters/__init__.py
new file mode 100644
index 000000000..39cf5fb0a
--- /dev/null
+++ b/pylint/reporters/__init__.py
@@ -0,0 +1,48 @@
+# 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 Marc Mueller <30130371+cdce8p@users.noreply.github.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/main/LICENSE
+
+"""utilities methods and classes for reporters"""
+from typing import TYPE_CHECKING
+
+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
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+
+
+def initialize(linter: "PyLinter") -> None:
+    """initialize linter with reporters in this package"""
+    utils.register_plugins(linter, __path__[0])  # type: ignore # Fixed in https://github.com/python/mypy/pull/9454
+
+
+__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 000000000..9bd9e80e6
--- /dev/null
+++ b/pylint/reporters/base_reporter.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/main/LICENSE
+
+import os
+import sys
+from typing import TYPE_CHECKING, List, Optional
+
+from pylint.message import Message
+from pylint.reporters.ureports.nodes import Text
+from pylint.typing import CheckerStats
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+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: "Section") -> None:
+        """display results encapsulated in the layout tree"""
+        self.section = 0
+        if layout.report_id:
+            if isinstance(layout.children[0].children[0], Text):
+                layout.children[0].children[0].data += f" ({layout.report_id})"
+            else:
+                raise ValueError(f"Incorrect child for {layout.children[0].children}")
+        self._display(layout)
+
+    def _display(self, layout: "Section") -> None:
+        """display the layout"""
+        raise NotImplementedError()
+
+    def display_messages(self, layout: Optional["Section"]) -> None:
+        """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: str, filepath: Optional[str]) -> None:
+        """Hook called when a module starts to be analysed."""
+
+    def on_close(
+        self,
+        stats: CheckerStats,
+        previous_stats: CheckerStats,
+    ) -> None:
+        """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 000000000..fbd9eb46b
--- /dev/null
+++ b/pylint/reporters/collecting_reporter.py
@@ -0,0 +1,24 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+from typing import TYPE_CHECKING
+
+from pylint.reporters.base_reporter import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+class CollectingReporter(BaseReporter):
+    """collects messages"""
+
+    name = "collector"
+
+    def __init__(self) -> None:
+        BaseReporter.__init__(self)
+        self.messages = []
+
+    def reset(self) -> None:
+        self.messages = []
+
+    def _display(self, layout: "Section") -> None:
+        pass
diff --git a/pylint/reporters/json_reporter.py b/pylint/reporters/json_reporter.py
new file mode 100644
index 000000000..87949c1c4
--- /dev/null
+++ b/pylint/reporters/json_reporter.py
@@ -0,0 +1,60 @@
+# 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>
+# 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/main/LICENSE
+
+"""JSON reporter"""
+import json
+from typing import TYPE_CHECKING, Optional
+
+from pylint.interfaces import IReporter
+from pylint.reporters.base_reporter import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+    from pylint.reporters.ureports.nodes import Section
+
+
+class JSONReporter(BaseReporter):
+    """Report messages and layouts in JSON."""
+
+    __implements__ = IReporter
+    name = "json"
+    extension = "json"
+
+    def display_messages(self, layout: Optional["Section"]) -> None:
+        """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: "Section") -> None:
+        """Don't do anything in this reporter."""
+
+    def _display(self, layout: "Section") -> None:
+        """Do nothing."""
+
+
+def register(linter: "PyLinter") -> None:
+    """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 000000000..b3b67d87a
--- /dev/null
+++ b/pylint/reporters/multi_reporter.py
@@ -0,0 +1,105 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+
+import os
+from typing import IO, TYPE_CHECKING, Any, AnyStr, Callable, List, Optional
+
+from pylint.interfaces import IReporter
+from pylint.message import Message
+from pylint.reporters.base_reporter import BaseReporter
+from pylint.typing import CheckerStats
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+AnyFile = IO[AnyStr]
+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) -> None:
+        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: "Section") -> None:
+        """display results encapsulated in the layout tree"""
+        for rep in self._sub_reporters:
+            rep.display_reports(layout)
+
+    def display_messages(self, layout: Optional["Section"]) -> 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[str]) -> 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: CheckerStats,
+        previous_stats: CheckerStats,
+    ) -> 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 000000000..de3bbe225
--- /dev/null
+++ b/pylint/reporters/reports_handler_mix_in.py
@@ -0,0 +1,93 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import collections
+from typing import TYPE_CHECKING, Any, Callable, DefaultDict, Dict, List, Tuple
+
+from pylint.exceptions import EmptyReportError
+from pylint.interfaces import IChecker
+from pylint.reporters.ureports.nodes import Section
+from pylint.typing import CheckerStats
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+
+
+class ReportsHandlerMixIn:
+    """a mix-in class containing all the reports and stats manipulation
+    related methods for the main lint class
+    """
+
+    def __init__(self) -> None:
+        self._reports: DefaultDict[
+            IChecker, List[Tuple[str, str, Callable]]
+        ] = collections.defaultdict(list)
+        self._reports_state: Dict[str, bool] = {}
+
+    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: str, r_title: str, r_cb: Callable, checker: IChecker
+    ) -> None:
+        """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: str) -> None:
+        """disable the report of the given id"""
+        reportid = reportid.upper()
+        self._reports_state[reportid] = True
+
+    def disable_report(self, reportid: str) -> None:
+        """disable the report of the given id"""
+        reportid = reportid.upper()
+        self._reports_state[reportid] = False
+
+    def report_is_enabled(self, reportid: str) -> bool:
+        """return true if the report associated to the given identifier is
+        enabled
+        """
+        return self._reports_state.get(reportid, True)
+
+    def make_reports(  # type: ignore # ReportsHandlerMixIn is always mixed with PyLinter
+        self: "PyLinter",
+        stats: CheckerStats,
+        old_stats: CheckerStats,
+    ) -> Section:
+        """render registered reports"""
+        sect = Section("Report", f"{self.stats['statement']} statements analysed.")
+        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(  # type: ignore # ReportsHandlerMixIn is always mixed with PyLinter
+        self: "PyLinter", **kwargs: Any
+    ) -> CheckerStats:
+        """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 000000000..e941ba60d
--- /dev/null
+++ b/pylint/reporters/text.py
@@ -0,0 +1,256 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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 typing import TYPE_CHECKING, Optional
+
+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
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+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: str, filepath: Optional[str]) -> None:
+        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(f"************* Module {msg.module}")
+                self._modules.add(msg.module)
+            else:
+                self.writeln("************* ")
+        self.write_message(msg)
+
+    def _display(self, layout: "Section") -> None:
+        """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(
+            f"{self.name} output format is deprecated. This is equivalent to --msg-template={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(
+                    f"************* Module {msg.module}", color, style
+                )
+            else:
+                modsep = colorize_ansi(f"************* {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 000000000..29bc85d89
--- /dev/null
+++ b/pylint/reporters/ureports/__init__.py
@@ -0,0 +1,6 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+__all__ = ("BaseWriter",)
+
+from pylint.reporters.ureports.base_writer import BaseWriter
diff --git a/pylint/reporters/ureports/base_writer.py b/pylint/reporters/ureports/base_writer.py
new file mode 100644
index 000000000..418079ae0
--- /dev/null
+++ b/pylint/reporters/ureports/base_writer.py
@@ -0,0 +1,109 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Nick Drozd <nicholasdrozd@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/main/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
+from typing import TYPE_CHECKING, Iterator, List, TextIO, Union
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import (
+        EvaluationSection,
+        Paragraph,
+        Section,
+        Table,
+    )
+
+
+class BaseWriter:
+    """base class for ureport writers"""
+
+    def format(self, layout, stream: TextIO = sys.stdout, encoding=None) -> 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 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: Union["EvaluationSection", "Paragraph", "Section"]
+    ) -> None:
+        """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: str = "") -> None:
+        """write a line in the output buffer"""
+        self.write(string + os.linesep)
+
+    def write(self, string: str) -> None:
+        """write a string in the output buffer"""
+        self.out.write(string)
+
+    def begin_format(self) -> None:
+        """begin to format a layout"""
+        self.section = 0
+
+    def end_format(self) -> None:
+        """finished to format a layout"""
+
+    def get_table_content(self, table: "Table") -> List[List[str]]:
+        """trick to get table content without actually writing it
+
+        return an aligned list of lists containing table cells values as string
+        """
+        result: List[List[str]] = [[]]
+        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
+        result[-1] += [""] * (cols - len(result[-1]))
+        return result
+
+    def compute_content(self, layout) -> Iterator[str]:
+        """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 000000000..4f7cde24d
--- /dev/null
+++ b/pylint/reporters/ureports/nodes.py
@@ -0,0 +1,189 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Micro reports objects.
+
+A micro report is a tree of layout and content objects.
+"""
+from typing import Any, Iterable, Iterator, List, Optional, Union
+
+from pylint.reporters.ureports.text_writer import TextWriter
+
+
+class VNode:
+    def __init__(self) -> None:
+        self.parent: Optional["BaseLayout"] = None
+        self.children: List["VNode"] = []
+        self.visitor_name: str = self.__class__.__name__.lower()
+
+    def __iter__(self) -> Iterator["VNode"]:
+        return iter(self.children)
+
+    def accept(self, visitor: TextWriter, *args: Any, **kwargs: Any) -> None:
+        func = getattr(visitor, f"visit_{self.visitor_name}")
+        return func(self, *args, **kwargs)
+
+    def leave(self, visitor, *args, **kwargs):
+        func = getattr(visitor, f"leave_{self.visitor_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: Iterable[Union["Text", str]] = ()) -> None:
+        super().__init__()
+        for child in children:
+            if isinstance(child, VNode):
+                self.append(child)
+            else:
+                self.add_text(child)
+
+    def append(self, child: VNode) -> None:
+        """add a node to children"""
+        assert child not in self.parents()
+        self.children.append(child)
+        child.parent = self
+
+    def insert(self, index: int, child: VNode) -> None:
+        """insert a child node"""
+        self.children.insert(index, child)
+        child.parent = self
+
+    def parents(self) -> List["BaseLayout"]:
+        """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: str) -> None:
+        """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: str, escaped: bool = True) -> None:
+        super().__init__()
+        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: Optional[str] = None,
+        description: Optional[str] = None,
+        children: Iterable[Union["Text", str]] = (),
+    ) -> None:
+        super().__init__(children=children)
+        if description:
+            self.insert(0, Paragraph([Text(description)]))
+        if title:
+            self.insert(0, Title(children=(title,)))
+        self.report_id: str = ""  # Used in ReportHandlerMixin.make_reports
+
+
+class EvaluationSection(Section):
+    def __init__(
+        self, message: str, children: Iterable[Union["Text", str]] = ()
+    ) -> None:
+        super().__init__(children=children)
+        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: int,
+        title: Optional[str] = None,
+        rheaders: int = 0,
+        cheaders: int = 0,
+        children: Iterable[Union["Text", str]] = (),
+    ) -> None:
+        super().__init__(children=children)
+        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 000000000..392c86cc8
--- /dev/null
+++ b/pylint/reporters/ureports/text_writer.py
@@ -0,0 +1,114 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# 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/main/LICENSE
+
+"""Text formatting drivers for ureports"""
+
+from typing import TYPE_CHECKING, List
+
+from pylint.reporters.ureports.base_writer import BaseWriter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import (
+        EvaluationSection,
+        Paragraph,
+        Section,
+        Table,
+        Text,
+        Title,
+        VerbatimText,
+    )
+
+TITLE_UNDERLINES = ["", "=", "-", "`", ".", "~", "^"]
+BULLETS = ["*", "-"]
+
+
+class TextWriter(BaseWriter):
+    """format layouts as text
+    (ReStructured inspiration but not totally handled yet)
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.list_level = 0
+
+    def visit_section(self, layout: "Section") -> None:
+        """display a section as text"""
+        self.section += 1
+        self.writeln()
+        self.format_children(layout)
+        self.section -= 1
+        self.writeln()
+
+    def visit_evaluationsection(self, layout: "EvaluationSection") -> None:
+        """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") -> None:
+        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: "Paragraph") -> None:
+        """enter a paragraph"""
+        self.format_children(layout)
+        self.writeln()
+
+    def visit_table(self, layout: "Table") -> None:
+        """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", table_content: List[List[str]], cols_width: List[int]
+    ) -> None:
+        """format a table"""
+        cols_width = [size + 1 for size in cols_width]
+        format_strings = " ".join(["%%-%ss"] * len(cols_width))
+        format_strings %= tuple(cols_width)
+
+        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)
+        split_strings = format_strings.split(" ")
+        for index, line in enumerate(table_content):
+            self.write("|")
+            for line_index, at_index in enumerate(line):
+                self.write(split_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: "VerbatimText") -> None:
+        """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: "Text") -> None:
+        """add some text"""
+        self.write(f"{layout.data}")
diff --git a/pylint/testutils/__init__.py b/pylint/testutils/__init__.py
new file mode 100644
index 000000000..66458954a
--- /dev/null
+++ b/pylint/testutils/__init__.py
@@ -0,0 +1,58 @@
+# 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 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# 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/main/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 000000000..5c8815dab
--- /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/main/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 000000000..fc04d927d
--- /dev/null
+++ b/pylint/testutils/constants.py
@@ -0,0 +1,30 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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]  # pylint: disable=consider-using-f-string
+)
+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]+):)?"  # pylint: disable=consider-using-f-string
+    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 000000000..44d186d1e
--- /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/main/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 000000000..bea65394b
--- /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/main/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 000000000..3b63a8e55
--- /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/main/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 000000000..2e6028e30
--- /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/main/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 000000000..c15d01271
--- /dev/null
+++ b/pylint/testutils/lint_module_test.py
@@ -0,0 +1,241 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import csv
+import operator
+import platform
+import sys
+from collections import Counter
+from io import StringIO, TextIOWrapper
+from typing import TYPE_CHECKING, 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
+
+if TYPE_CHECKING:
+    from typing import Counter as CounterType  # typing.Counter added in Python 3.6.1
+
+
+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(
+                f"Test cannot run with Python {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(f"Requires {','.join(missing)} to be present.")
+        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(f"Test cannot run on platform {sys.platform!r}")
+
+    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: TextIOWrapper) -> "CounterType[Tuple[int, str]]":
+        """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: "CounterType[Tuple[int, str]]" = 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:
+                lineno = i + 1
+            elif line.startswith("+") or line.startswith("-"):
+                lineno = i + 1 + int(line)
+            else:
+                lineno = 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[lineno, msg_id.strip()] += 1
+        return messages
+
+    @staticmethod
+    def multiset_difference(
+        expected_entries: "CounterType", actual_entries: "CounterType"
+    ) -> Tuple["CounterType", 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, encoding="utf-8")
+        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, encoding="utf-8")
+        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:
+            expected_msgs = 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 = [f'Wrong results for file "{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  # pylint: disable=consider-using-f-string
+                for msg in sorted(missing)
+            )
+        if unexpected:
+            msg.append("\nUnexpected in testdata:")
+            msg.extend(" %3d: %s" % msg for msg in sorted(unexpected))  # type: ignore #pylint: disable=consider-using-f-string
+        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 000000000..4fb71b456
--- /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/main/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: str
+    object: Any
+    msg: str
+    confidence: interfaces.Confidence
+
+    @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/pyreverse.py b/pylint/testutils/pyreverse.py
new file mode 100644
index 000000000..edaef621d
--- /dev/null
+++ b/pylint/testutils/pyreverse.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/main/LICENSE
+
+from typing import List, Optional, Tuple
+
+
+# This class could and should be replaced with a simple dataclass when support for Python < 3.7 is dropped.
+# A NamedTuple is not possible as some tests need to modify attributes during the test.
+class PyreverseConfig:  # pylint: disable=too-many-instance-attributes, too-many-arguments
+    """Holds the configuration options for Pyreverse.
+    The default values correspond to the defaults of the options parser."""
+
+    def __init__(
+        self,
+        mode: str = "PUB_ONLY",
+        classes: Optional[List[str]] = None,
+        show_ancestors: Optional[int] = None,
+        all_ancestors: Optional[bool] = None,
+        show_associated: Optional[int] = None,
+        all_associated: Optional[bool] = None,
+        show_builtin: bool = False,
+        module_names: Optional[bool] = None,
+        only_classnames: bool = False,
+        output_format: str = "dot",
+        colorized: bool = False,
+        max_color_depth: int = 2,
+        ignore_list: Tuple = tuple(),
+        project: str = "",
+        output_directory: str = "",
+    ):
+        self.mode = mode
+        if classes:
+            self.classes = classes
+        else:
+            self.classes = []
+        self.show_ancestors = show_ancestors
+        self.all_ancestors = all_ancestors
+        self.show_associated = show_associated
+        self.all_associated = all_associated
+        self.show_builtin = show_builtin
+        self.module_names = module_names
+        self.only_classnames = only_classnames
+        self.output_format = output_format
+        self.colorized = colorized
+        self.max_color_depth = max_color_depth
+        self.ignore_list = ignore_list
+        self.project = project
+        self.output_directory = output_directory
diff --git a/pylint/testutils/reporter_for_tests.py b/pylint/testutils/reporter_for_tests.py
new file mode 100644
index 000000000..480f1ed2d
--- /dev/null
+++ b/pylint/testutils/reporter_for_tests.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/main/LICENSE
+
+from io import StringIO
+from os import getcwd, linesep, sep
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from pylint import interfaces
+from pylint.message import Message
+from pylint.reporters import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+class GenericTestReporter(BaseReporter):
+    """reporter storing plain text messages"""
+
+    __implements__ = interfaces.IReporter
+
+    def __init__(
+        self,
+    ):  # pylint: disable=super-init-not-called # See https://github.com/PyCQA/pylint/issues/4941
+        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 = f":{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: str, filepath: Optional[str]) -> None:
+        pass
+
+    # pylint: enable=unused-argument
+
+    def display_reports(self, layout: "Section") -> None:
+        """ignore layouts"""
+
+    def _display(self, layout: "Section") -> None:
+        pass
+
+
+class MinimalTestReporter(BaseReporter):
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        self.messages = []
+
+    def _display(self, layout: "Section") -> None:
+        pass
+
+
+class FunctionalTestReporter(BaseReporter):
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        self.messages = []
+
+    def display_reports(self, layout: "Section") -> None:
+        """Ignore layouts and don't call self._display()."""
+
+    def _display(self, layout: "Section") -> None:
+        pass
diff --git a/pylint/testutils/tokenize_str.py b/pylint/testutils/tokenize_str.py
new file mode 100644
index 000000000..16bfea8ab
--- /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/main/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 000000000..b75592ce6
--- /dev/null
+++ b/pylint/testutils/unittest_linter.py
@@ -0,0 +1,41 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+from pylint.testutils.global_test_linter import linter
+from pylint.testutils.output_line import Message
+from pylint.typing import CheckerStats
+
+
+class UnittestLinter:
+    """A fake linter class to capture checker messages."""
+
+    # pylint: disable=unused-argument, no-self-use
+
+    def __init__(self):
+        self._messages = []
+        self.stats: CheckerStats = {}
+
+    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/typing.py b/pylint/typing.py
new file mode 100644
index 000000000..4c12710de
--- /dev/null
+++ b/pylint/typing.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/main/LICENSE
+
+"""A collection of typing utilities."""
+import sys
+from typing import TYPE_CHECKING, Dict, List, NamedTuple, Union
+
+if TYPE_CHECKING:
+    from typing import Counter  # typing.Counter added in Python 3.6.1
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, TypedDict
+else:
+    from typing_extensions import Literal, TypedDict
+
+
+class FileItem(NamedTuple):
+    """Represents data about a file handled by pylint
+
+    Each file item has:
+    - name: full name of the module
+    - filepath: path of the file
+    - modname: module name
+    """
+
+    name: str
+    filepath: str
+    modpath: str
+
+
+class ModuleDescriptionDict(TypedDict):
+    """Represents data about a checked module"""
+
+    path: str
+    name: str
+    isarg: bool
+    basepath: str
+    basename: str
+
+
+class ErrorDescriptionDict(TypedDict):
+    """Represents data about errors collected during checking of a module"""
+
+    key: Literal["fatal"]
+    mod: str
+    ex: Union[ImportError, SyntaxError]
+
+
+# The base type of the "stats" attribute of a checker
+CheckerStats = Dict[
+    str, Union[int, "Counter[str]", List, Dict[str, Union[int, str, Dict[str, int]]]]
+]
diff --git a/pylint/utils/__init__.py b/pylint/utils/__init__.py
new file mode 100644
index 000000000..8bdd70259
--- /dev/null
+++ b/pylint/utils/__init__.py
@@ -0,0 +1,90 @@
+# 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>
+# 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/main/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 000000000..756889251
--- /dev/null
+++ b/pylint/utils/ast_walker.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/main/LICENSE
+
+import collections
+import traceback
+
+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}'")
+                traceback.print_exc()
+                self.exception_msg = True
+            raise
diff --git a/pylint/utils/file_state.py b/pylint/utils/file_state.py
new file mode 100644
index 000000000..7209fe061
--- /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/main/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 000000000..d57d6a1de
--- /dev/null
+++ b/pylint/utils/pragma_parser.py
@@ -0,0 +1,134 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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-next", "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 = []
+            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 000000000..231983aa6
--- /dev/null
+++ b/pylint/utils/utils.py
@@ -0,0 +1,413 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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 io import BufferedReader, BytesIO
+from typing import (
+    TYPE_CHECKING,
+    List,
+    Optional,
+    Pattern,
+    TextIO,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from astroid import Module, modutils, nodes
+
+from pylint.constants import PY_EXTS
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if TYPE_CHECKING:
+    from pylint.checkers.base_checker import BaseChecker
+
+DEFAULT_LINE_LENGTH = 79
+
+# These are types used to overload get_global_option() and refer to the options type
+GLOBAL_OPTION_BOOL = Literal[
+    "ignore-mixin-members",
+    "suggestion-mode",
+    "analyse-fallback-blocks",
+    "allow-global-unused-variables",
+]
+GLOBAL_OPTION_INT = Literal["max-line-length", "docstring-min-length"]
+GLOBAL_OPTION_LIST = Literal["ignored-modules"]
+GLOBAL_OPTION_PATTERN = Literal[
+    "no-docstring-rgx", "dummy-variables-rgx", "ignored-argument-names"
+]
+GLOBAL_OPTION_TUPLE_INT = Literal["py-version"]
+GLOBAL_OPTION_NAMES = Union[
+    GLOBAL_OPTION_BOOL,
+    GLOBAL_OPTION_INT,
+    GLOBAL_OPTION_LIST,
+    GLOBAL_OPTION_PATTERN,
+    GLOBAL_OPTION_TUPLE_INT,
+]
+T_GlobalOptionReturnTypes = TypeVar(
+    "T_GlobalOptionReturnTypes", bool, int, List[str], Pattern, Tuple[int, ...]
+)
+
+
+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 = f"{CMPS[cmp(old, new)]}{diff and f'{diff:.2f}' 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:
+            break
+    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 += f"{formatted_doc}\n\n"
+    for optname, optdict, value in options:
+        help_opt = optdict.get("help")
+        result += f":{optname}:\n"
+        if help_opt:
+            formatted_help = normalize_text(help_opt, indent="  ")
+            result += f"{formatted_help}\n"
+        if value:
+            value = str(_format_option_value(optdict, value))
+            result += f"\n  Default: ``{value.replace('`` ', '```` ``')}``\n"
+    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: Union[BufferedReader, BytesIO],
+    encoding: str,
+    errors: Literal["strict"] = "strict",
+) -> codecs.StreamReader:
+    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(node: nodes.Module) -> List[tokenize.TokenInfo]:
+    with node.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
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker", option: GLOBAL_OPTION_BOOL, default: Optional[bool] = None
+) -> bool:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker", option: GLOBAL_OPTION_INT, default: Optional[int] = None
+) -> int:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_LIST,
+    default: Optional[List[str]] = None,
+) -> List[str]:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_PATTERN,
+    default: Optional[Pattern] = None,
+) -> Pattern:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_TUPLE_INT,
+    default: Optional[Tuple[int, ...]] = None,
+) -> Tuple[int, ...]:
+    ...
+
+
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_NAMES,
+    default: Optional[T_GlobalOptionReturnTypes] = None,
+) -> Optional[T_GlobalOptionReturnTypes]:
+    """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 "# " + f"{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 = f"'{value}'"
+    return value
+
+
+def format_section(
+    stream: TextIO, section: str, options: List[Tuple], doc: Optional[str] = None
+) -> None:
+    """format an options section using the INI format"""
+    if doc:
+        print(_comment(doc), file=stream)
+    print(f"[{section}]", file=stream)
+    _ini_format(stream, options)
+
+
+def _ini_format(stream: TextIO, options: List[Tuple]) -> None:
+    """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(f"#{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 000000000..6acebfbfb
--- /dev/null
+++ b/pylintrc
@@ -0,0 +1,396 @@
+[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,
+    pylint.extensions.overlapping_exceptions,
+    pylint.extensions.typing,
+    pylint.extensions.redefined_variable_type,
+
+# 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=
+
+# Minimum supported python version
+py-version = 3.6
+
+
+[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
+
+# List of qualified class names to ignore when counting class parents (see R0901).
+ignored-parents=
+
+# 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
+
+
+[TYPING]
+
+# Annotations are used exclusively for type checking
+runtime-typing = no
+
+
+[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 000000000..e912ca13b
--- /dev/null
+++ b/requirements_test.txt
@@ -0,0 +1,13 @@
+-r requirements_test_pre_commit.txt
+-r requirements_test_min.txt
+coveralls~=3.2
+coverage~=5.5
+pre-commit~=2.15;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.5
diff --git a/requirements_test_min.txt b/requirements_test_min.txt
new file mode 100644
index 000000000..4eb27002c
--- /dev/null
+++ b/requirements_test_min.txt
@@ -0,0 +1,5 @@
+-e .
+# astroid dependency is also defined in setup.cfg
+astroid==2.8.0  # 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 000000000..dc2031fb8
--- /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.8b0;python_full_version>="3.6.2"
+flake8==3.9.2
+isort==5.9.3
+mypy==0.910
diff --git a/script/__init__.py b/script/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/script/__init__.py
diff --git a/script/bump_changelog.py b/script/bump_changelog.py
new file mode 100644
index 000000000..6b8e4abbf
--- /dev/null
+++ b/script/bump_changelog.py
@@ -0,0 +1,163 @@
+# ORIGINAL here: https://github.com/PyCQA/astroid/blob/main/script/bump_changelog.py
+# DO NOT MODIFY DIRECTLY
+
+"""
+This script permits to upgrade the changelog in astroid or pylint when releasing a version.
+"""
+# pylint: disable=logging-fstring-interpolation
+import argparse
+import enum
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import List
+
+DEFAULT_CHANGELOG_PATH = Path("ChangeLog")
+
+RELEASE_DATE_TEXT = "Release date: TBA"
+WHATS_NEW_TEXT = "What's New in Pylint"
+TODAY = datetime.now()
+FULL_WHATS_NEW_TEXT = WHATS_NEW_TEXT + " {version}?"
+NEW_RELEASE_DATE_MESSAGE = f"Release date: {TODAY.strftime('%Y-%m-%d')}"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(__doc__)
+    parser.add_argument("version", help="The version we want to release")
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", default=False, help="Logging or not"
+    )
+    args = parser.parse_args()
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    logging.debug(f"Launching bump_changelog with args: {args}")
+    if "dev" in args.version:
+        return
+    with open(DEFAULT_CHANGELOG_PATH, encoding="utf-8") as f:
+        content = f.read()
+    content = transform_content(content, args.version)
+    with open(DEFAULT_CHANGELOG_PATH, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+class VersionType(enum.Enum):
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 2
+
+
+def get_next_version(version: str, version_type: VersionType) -> str:
+    new_version = version.split(".")
+    part_to_increase = new_version[version_type.value]
+    if "-" in part_to_increase:
+        part_to_increase = part_to_increase.split("-")[0]
+    for i in range(version_type.value, 3):
+        new_version[i] = "0"
+    new_version[version_type.value] = str(int(part_to_increase) + 1)
+    return ".".join(new_version)
+
+
+def get_next_versions(version: str, version_type: VersionType) -> List[str]:
+
+    if version_type == VersionType.PATCH:
+        # "2.6.1" => ["2.6.2"]
+        return [get_next_version(version, VersionType.PATCH)]
+    if version_type == VersionType.MINOR:
+        # "2.6.0" => ["2.7.0", "2.6.1"]
+        assert version.endswith(".0"), f"{version} does not look like a minor version"
+    else:
+        # "3.0.0" => ["3.1.0", "3.0.1"]
+        assert version.endswith(".0.0"), f"{version} does not look like a major version"
+    next_minor_version = get_next_version(version, VersionType.MINOR)
+    next_patch_version = get_next_version(version, VersionType.PATCH)
+    logging.debug(f"Getting the new version for {version} - {version_type.name}")
+    return [next_minor_version, next_patch_version]
+
+
+def get_version_type(version: str) -> VersionType:
+    if version.endswith(".0.0"):
+        version_type = VersionType.MAJOR
+    elif version.endswith(".0"):
+        version_type = VersionType.MINOR
+    else:
+        version_type = VersionType.PATCH
+    return version_type
+
+
+def get_whats_new(
+    version: str, add_date: bool = False, change_date: bool = False
+) -> str:
+    whats_new_text = FULL_WHATS_NEW_TEXT.format(version=version)
+    result = [whats_new_text, "=" * len(whats_new_text)]
+    if add_date and change_date:
+        result += [NEW_RELEASE_DATE_MESSAGE]
+    elif add_date:
+        result += [RELEASE_DATE_TEXT]
+    elif change_date:
+        raise ValueError("Can't use change_date=True with add_date=False")
+    logging.debug(
+        f"version='{version}', add_date='{add_date}', change_date='{change_date}': {result}"
+    )
+    return "\n".join(result)
+
+
+def get_all_whats_new(version: str, version_type: VersionType) -> str:
+    result = ""
+    for version_ in get_next_versions(version, version_type=version_type):
+        result += get_whats_new(version_, add_date=True) + "\n" * 4
+    return result
+
+
+def transform_content(content: str, version: str) -> str:
+    version_type = get_version_type(version)
+    next_version = get_next_version(version, version_type)
+    old_date = get_whats_new(version, add_date=True)
+    new_date = get_whats_new(version, add_date=True, change_date=True)
+    next_version_with_date = get_all_whats_new(version, version_type)
+    do_checks(content, next_version, version, version_type)
+    index = content.find(old_date)
+    logging.debug(f"Replacing\n'{old_date}'\nby\n'{new_date}'\n")
+    content = content.replace(old_date, new_date)
+    end_content = content[index:]
+    content = content[:index]
+    logging.debug(f"Adding:\n'{next_version_with_date}'\n")
+    content += next_version_with_date + end_content
+    return content
+
+
+def do_checks(content, next_version, version, version_type):
+    err = "in the changelog, fix that first!"
+    NEW_VERSION_ERROR_MSG = (
+        # pylint: disable-next=consider-using-f-string
+        "The text for this version '{version}' did not exists %s"
+        % err
+    )
+    NEXT_VERSION_ERROR_MSG = (
+        # pylint: disable-next=consider-using-f-string
+        "The text for the next version '{version}' already exists %s"
+        % err
+    )
+    wn_next_version = get_whats_new(next_version)
+    wn_this_version = get_whats_new(version)
+    # There is only one field where the release date is TBA
+    if version_type in [VersionType.MAJOR, VersionType.MINOR]:
+        assert (
+            content.count(RELEASE_DATE_TEXT) <= 1
+        ), f"There should be only one release date 'TBA' ({version}) {err}"
+    else:
+        next_minor_version = get_next_version(version, VersionType.MINOR)
+        assert (
+            content.count(RELEASE_DATE_TEXT) <= 2
+        ), f"There should be only two release dates 'TBA' ({version} and {next_minor_version}) {err}"
+    # There is already a release note for the version we want to release
+    assert content.count(wn_this_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
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/script/fix_documentation.py b/script/fix_documentation.py
new file mode 100644
index 000000000..b03f70ead
--- /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, encoding="utf-8") 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", encoding="utf-8") 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 000000000..f415db45d
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,120 @@
+[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
+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 :: 3.10
+    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 =
+    Homepage = https://www.pylint.org/
+    Source Code = https://github.com/PyCQA/pylint
+    What's New = https://pylint.pycqa.org/en/latest/whatsnew/
+    Bug Tracker = https://github.com/PyCQA/pylint/issues
+    Discord Server = https://discord.gg/Egy6P8AMB5
+    Docs: User Guide = https://pylint.pycqa.org/en/latest/
+    Docs: Contributing = https://pylint.pycqa.org/en/latest/development_guide/contribute.html
+    Docs: Technical Reference = https://pylint.pycqa.org/en/latest/technical_reference/index.html
+
+[options]
+packages = find:
+install_requires =
+    platformdirs>=2.2.0
+    astroid>=2.8.0,<2.9 # (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"
+    typing-extensions>=3.10.0;python_version<"3.10"
+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 = platformdirs, 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
+warn_unused_ignores = True
+
+[mypy-astroid.*]
+ignore_missing_imports = True
+
+[mypy-tests.*]
+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 000000000..606849326
--- /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 000000000..60e394896
--- /dev/null
+++ b/tbump.toml
@@ -0,0 +1,47 @@
+github_url = "https://github.com/PyCQA/pylint"
+
+[version]
+current = "2.11.1"
+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 000000000..c5af893b4
--- /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/main/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 000000000..f1b9f775d
--- /dev/null
+++ b/tests/benchmark/test_baseline_benchmarks.py
@@ -0,0 +1,342 @@
+""" 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+# pylint: disable=protected-access,missing-function-docstring,no-self-use
+
+import os
+import pprint
+import time
+from unittest.mock import patch
+
+import pytest
+from astroid import nodes
+
+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.typing import FileItem
+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, _node: nodes.Module) -> None:
+        """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, _node: nodes.Module) -> None:
+        """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, _node: nodes.Module) -> None:
+        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 = FileItem(
+        "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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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
+        ), f"Expected no errors to be thrown: {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 000000000..e69de29bb
--- /dev/null
+++ b/tests/checkers/__init__.py
diff --git a/tests/checkers/conftest.py b/tests/checkers/conftest.py
new file mode 100644
index 000000000..e83101542
--- /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 000000000..c980c349f
--- /dev/null
+++ b/tests/checkers/unittest_base.py
@@ -0,0 +1,698 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Yilei "Dolee" Yang <yileiyang@google.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@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/main/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) -> None:
+        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) -> None:
+        module = astroid.parse("")
+        with self.assertNoMessages():
+            self.checker.visit_module(module)
+
+    def test_empty_docstring_module(self) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        func = astroid.extract_node(
+            """
+        def __fun__(tion):
+           pass"""
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(func)
+
+    def test_class_no_docstring(self) -> None:
+        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) -> None:
+        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) -> None:
+        # 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) -> None:
+        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) -> None:
+        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) -> None:
+        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",
+                "the `UP` group in the '(?:(?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) -> None:
+        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",
+                    "the `down` group in the '(?:(?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",
+                "the `down` group in the '(?:(?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) -> None:
+        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",
+                "the `down` group in the '(?:(?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) -> None:
+        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: Type[base.NamingStyle], name: str
+    ) -> None:
+        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: Type[base.NamingStyle], name: str
+    ) -> None:
+        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: Type[base.NamingStyle]) -> None:
+        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: Type[base.NamingStyle], name: str, name_type: str
+    ) -> None:
+        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: Type[base.NamingStyle], name: str, name_type: str
+    ) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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 000000000..e11ec28f1
--- /dev/null
+++ b/tests/checkers/unittest_classes.py
@@ -0,0 +1,247 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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 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/main/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) -> None:
+        """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) -> None:
+        """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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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) -> None:
+        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 000000000..686fb0cc3
--- /dev/null
+++ b/tests/checkers/unittest_deprecated.py
@@ -0,0 +1,557 @@
+from typing import List, Optional, Set, Tuple, Union
+
+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) -> Set[str]:
+        return {"deprecated_func", ".Deprecated.deprecated_method"}
+
+    def deprecated_modules(self) -> Set[str]:
+        return {"deprecated_module"}
+
+    def deprecated_classes(self, module: str) -> List[str]:
+        return ["DeprecatedClass"] if module == "deprecated" else []
+
+    def deprecated_arguments(
+        self, method: str
+    ) -> Union[
+        Tuple[Tuple[Optional[int], str], ...], Tuple[Tuple[int, str], Tuple[int, str]]
+    ]:
+        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) -> Set[str]:
+        return {".deprecated_decorator"}
+
+
+class TestDeprecatedChecker(CheckerTestCase):
+    CHECKER_CLASS = _DeprecatedChecker
+
+    def test_deprecated_function(self) -> None:
+        # 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) -> None:
+        # 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_deprecated_method_alias(self) -> None:
+        # Tests detecting deprecated method defined as alias
+        # to existing method
+        node = astroid.extract_node(
+            """
+        class Deprecated:
+            def _deprecated_method(self):
+                pass
+
+            deprecated_method = _deprecated_method
+
+        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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+
+        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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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_design.py b/tests/checkers/unittest_design.py
new file mode 100644
index 000000000..5c6f38816
--- /dev/null
+++ b/tests/checkers/unittest_design.py
@@ -0,0 +1,44 @@
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Rebecca Turner <rbt@sent.as>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+
+import astroid
+
+from pylint.checkers import design_analysis
+from pylint.testutils import CheckerTestCase, set_config
+
+
+class TestDesignChecker(CheckerTestCase):
+
+    CHECKER_CLASS = design_analysis.MisdesignChecker
+
+    @set_config(
+        ignored_parents=(".Dddd",),
+        max_parents=1,
+    )
+    def test_too_many_ancestors_ignored_parents_are_skipped(self) -> None:
+        """Make sure that classes listed in ``ignored-parents`` aren't counted
+        by the too-many-ancestors message.
+        """
+
+        node = astroid.extract_node(
+            """
+        class Aaaa(object):
+            pass
+        class Bbbb(Aaaa):
+            pass
+        class Cccc(Bbbb):
+            pass
+        class Dddd(Cccc):
+            pass
+        class Eeee(Dddd):
+            pass
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_classdef(node)
diff --git a/tests/checkers/unittest_exceptions.py b/tests/checkers/unittest_exceptions.py
new file mode 100644
index 000000000..8764c7467
--- /dev/null
+++ b/tests/checkers/unittest_exceptions.py
@@ -0,0 +1,54 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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) -> None:
+        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) -> None:
+        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 000000000..4023207bb
--- /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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# 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/main/LICENSE
+
+"""Check format checker helper functions"""
+
+import os
+import tempfile
+import tokenize
+from typing import Any
+
+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) -> None:
+        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) -> None:
+        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) -> None:
+        tree = astroid.extract_node(
+            """
+        try:  #@
+            pass
+        except:
+            pass
+        finally:
+            pass"""
+        )
+        with self.assertNoMessages():
+            self.visitFirst(tree)
+
+    def visitFirst(self, tree: Any) -> None:
+        self.checker.process_tokens([])
+        self.checker.visit_default(tree.body[0])
+
+    def test_ellipsis_is_ignored(self) -> None:
+        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) -> None:
+        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",
+            "return [x for x in (3 if 1 else [4])]",
+            "return (x for x in ((3, 4) if 2 > 1 else (5, 6)))",
+        ]
+        with self.assertNoMessages():
+            for code in cases:
+                self.checker._check_keyword_parentheses(_tokenize_str(code), 0)
+
+    def testCheckKeywordParensHandlesUnnecessaryParens(self) -> None:
+        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="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) -> None:
+        """Parenthesis change the meaning of assignment in the walrus operator
+        and so are not always superfluous:"""
+        cases = [
+            ("if (odd := is_odd(i))\n"),
+            ("not (foo := 5)\n"),
+        ]
+        for code in cases:
+            with self.assertNoMessages():
+                self.checker.process_tokens(_tokenize_str(code))
+
+    def testPositiveSuperfluousParensWalrusOperatorIf(self) -> None:
+        """Test positive superfluous parens cases with the walrus operator"""
+        cases = [
+            (Message("superfluous-parens", line=1, args="if"), "if ((x := y)):\n"),
+            (Message("superfluous-parens", line=1, args="not"), "if not ((x := y)):\n"),
+        ]
+        for msg, code in cases:
+            with self.assertAddsMessages(msg):
+                self.checker.process_tokens(_tokenize_str(code))
+
+    def testCheckIfArgsAreNotUnicode(self) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        """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() -> None:
+    """
+    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 000000000..6bc3ae2c1
--- /dev/null
+++ b/tests/checkers/unittest_imports.py
@@ -0,0 +1,165 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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) -> None:
+        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) -> None:
+        """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) -> None:
+        """
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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 000000000..f0868b512
--- /dev/null
+++ b/tests/checkers/unittest_logging.py
@@ -0,0 +1,165 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Unittest for the logging checker."""
+import sys
+from typing import Optional, Tuple
+
+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) -> None:
+        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) -> None:
+        node = astroid.parse(
+            """
+        import logging
+        logging.error('0} - {1}'.format(1, 2))
+        """
+        )
+        self.walk(node)
+
+    def test_detects_renamed_standard_logging_module(self) -> None:
+        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) -> None:
+        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: str) -> None:
+        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: str,
+        stmt: str,
+        args: Optional[Tuple[str]] = None,
+        with_too_many: bool = False,
+    ) -> None:
+        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: str) -> None:
+        self._assert_logging_format_message("logging-too-few-args", stmt)
+
+    def _assert_logging_format_too_many_args(self, stmt: str) -> None:
+        self._assert_logging_format_message("logging-too-many-args", stmt)
+
+    @set_config(logging_format_style="new")
+    def test_brace_format_style_matching_arguments(self) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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 000000000..eb35c69f3
--- /dev/null
+++ b/tests/checkers/unittest_misc.py
@@ -0,0 +1,109 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        code = """a = 1
+                # midle XXX
+                """
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_without_space_fixme(self) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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_refactoring.py b/tests/checkers/unittest_refactoring.py
new file mode 100644
index 000000000..4b132e218
--- /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/main/LICENSE
+
+import astroid
+
+from pylint.checkers.refactoring import LenChecker
+
+
+def test_class_tree_detection() -> None:
+    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 000000000..a9a13b72a
--- /dev/null
+++ b/tests/checkers/unittest_similar.py
@@ -0,0 +1,512 @@
+# 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-2021 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2020 Frank Harrison <frank@doublethefish.com>
+# Copyright (c) 2020 Eli Fine <ejfine@gmail.com>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Maksym Humetskyi <Humetsky@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.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/main/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")
+SIMILAR_CLS_A = str(INPUT / "similar_cls_a.py")
+SIMILAR_CLS_B = str(INPUT / "similar_cls_b.py")
+EMPTY_FUNCTION_1 = str(INPUT / "similar_empty_func_1.py")
+EMPTY_FUNCTION_2 = str(INPUT / "similar_empty_func_2.py")
+MULTILINE = str(INPUT / "multiline-import")
+HIDE_CODE_WITH_IMPORTS = str(INPUT / "hide_code_with_imports.py")
+
+
+def test_ignore_comments() -> None:
+    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()
+        == (
+            f"""
+10 similar lines in 2 files
+=={SIMILAR1}:[0:11]
+=={SIMILAR2}:[0:11]
+   import one
+   from two import two
+   three
+   four
+   five
+   six
+   # A full line comment
+   seven
+   eight
+   nine
+   ''' ten
+TOTAL lines=62 duplicates=10 percent=16.13
+"""
+        ).strip()
+    )
+
+
+def test_ignore_docstrings() -> None:
+    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()
+        == (
+            f"""
+5 similar lines in 2 files
+=={SIMILAR1}:[7:15]
+=={SIMILAR2}:[7:15]
+   seven
+   eight
+   nine
+   ''' ten
+   ELEVEN
+   twelve '''
+   thirteen
+   fourteen
+
+5 similar lines in 2 files
+=={SIMILAR1}:[0:5]
+=={SIMILAR2}:[0:5]
+   import one
+   from two import two
+   three
+   four
+   five
+TOTAL lines=62 duplicates=10 percent=16.13
+"""
+        ).strip()
+    )
+
+
+def test_ignore_imports() -> None:
+    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=62 duplicates=0 percent=0.00
+""".strip()
+    )
+
+
+def test_multiline_imports() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([MULTILINE, MULTILINE])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            f"""
+8 similar lines in 2 files
+=={MULTILINE}:[0:8]
+=={MULTILINE}:[0:8]
+   from foo import (
+     bar,
+     baz,
+     quux,
+     quuux,
+     quuuux,
+     quuuuux,
+   )
+TOTAL lines=16 duplicates=8 percent=50.00
+"""
+        ).strip()
+    )
+
+
+def test_ignore_multiline_imports() -> None:
+    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() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([SIMILAR5, SIMILAR6])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            f'''
+9 similar lines in 2 files
+=={SIMILAR5}:[7:17]
+=={SIMILAR6}:[8:18]
+       arg1: int = 3,
+       arg2: Class1 = val1,
+       arg3: Class2 = func3(val2),
+       arg4: int = 4,
+       arg5: int = 5
+   ) -> Ret1:
+       pass
+
+   def example():
+       """Valid function definition with docstring only."""
+
+6 similar lines in 2 files
+=={SIMILAR5}:[0:6]
+=={SIMILAR6}:[1:7]
+   @deco1(dval1)
+   @deco2(dval2)
+   @deco3(
+       dval3,
+       dval4
+   )
+TOTAL lines=35 duplicates=15 percent=42.86
+'''
+        ).strip()
+    )
+
+
+def test_ignore_signatures_pass() -> None:
+    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=35 duplicates=0 percent=0.00
+""".strip()
+    )
+
+
+def test_ignore_signatures_class_methods_fail() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([SIMILAR_CLS_B, SIMILAR_CLS_A])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            f'''
+15 similar lines in 2 files
+=={SIMILAR_CLS_A}:[1:18]
+=={SIMILAR_CLS_B}:[1:18]
+       def parent_method(
+           self,
+           *,
+           a="",
+           b=None,
+           c=True,
+       ):
+           """Overridden method example."""
+
+           def _internal_func(
+               arg1: int = 1,
+               arg2: str = "2",
+               arg3: int = 3,
+               arg4: bool = True,
+           ):
+               pass
+
+
+7 similar lines in 2 files
+=={SIMILAR_CLS_A}:[20:27]
+=={SIMILAR_CLS_B}:[20:27]
+               self,
+               *,
+               a=None,
+               b=False,
+               c="",
+           ):
+               pass
+TOTAL lines=54 duplicates=22 percent=40.74
+'''
+        ).strip()
+    )
+
+
+def test_ignore_signatures_class_methods_pass() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--ignore-signatures", SIMILAR_CLS_B, SIMILAR_CLS_A])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == """
+TOTAL lines=54 duplicates=0 percent=0.00
+""".strip()
+    )
+
+
+def test_ignore_signatures_empty_functions_fail() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([EMPTY_FUNCTION_1, EMPTY_FUNCTION_2])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            f'''
+6 similar lines in 2 files
+=={EMPTY_FUNCTION_1}:[1:7]
+=={EMPTY_FUNCTION_2}:[1:7]
+       arg1: int = 1,
+       arg2: str = "2",
+       arg3: int = 3,
+       arg4: bool = True,
+   ) -> None:
+       """Valid function definition with docstring only."""
+TOTAL lines=14 duplicates=6 percent=42.86
+'''
+        ).strip()
+    )
+
+
+def test_ignore_signatures_empty_functions_pass() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--ignore-signatures", EMPTY_FUNCTION_1, EMPTY_FUNCTION_2])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == """
+TOTAL lines=14 duplicates=0 percent=0.00
+""".strip()
+    )
+
+
+def test_no_hide_code_with_imports() -> None:
+    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() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([SIMILAR1, SIMILAR2])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            f"""
+5 similar lines in 2 files
+=={SIMILAR1}:[0:5]
+=={SIMILAR2}:[0:5]
+   import one
+   from two import two
+   three
+   four
+   five
+TOTAL lines=62 duplicates=5 percent=8.06
+"""
+        ).strip()
+    )
+
+
+def test_lines_without_meaningful_content_do_not_trigger_similarity() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([SIMILAR3, SIMILAR4])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            f"""
+14 similar lines in 2 files
+=={SIMILAR3}:[11:25]
+=={SIMILAR4}:[11:25]
+   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
+"""
+        ).strip()
+    )
+
+
+def test_help() -> None:
+    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() -> None:
+    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() -> None:
+    """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, encoding="utf-8") 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 = (linespec.text for linespec in lineset_obj.stripped_lines)
+        assert tuple(expected_lines) == tuple(lines)
+
+
+def test_set_duplicate_lines_to_zero() -> None:
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--duplicates=0", SIMILAR1, SIMILAR2])
+    assert ex.value.code == 0
+    assert output.getvalue() == ""
diff --git a/tests/checkers/unittest_spelling.py b/tests/checkers/unittest_spelling.py
new file mode 100644
index 000000000..a1ed80337
--- /dev/null
+++ b/tests/checkers/unittest_spelling.py
@@ -0,0 +1,615 @@
+# 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 Marc Mueller <30130371+cdce8p@users.noreply.github.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/main/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 000000000..a2de9bf04
--- /dev/null
+++ b/tests/checkers/unittest_stdlib.py
@@ -0,0 +1,132 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+import contextlib
+from typing import Any, Callable, Iterator, Optional, Union
+
+import astroid
+from astroid import nodes
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import AssignAttr, Name
+
+from pylint.checkers import stdlib
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message
+
+
+@contextlib.contextmanager
+def _add_transform(
+    manager: AstroidManager,
+    node: type,
+    transform: Callable,
+    predicate: Optional[Any] = None,
+) -> Iterator:
+    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) -> None:
+        """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: Name, context: Optional[Any] = None
+        ) -> Iterator[
+            Union[Iterator, Iterator[AssignAttr]]
+        ]:  # pylint: disable=unused-argument
+            new_node = nodes.AssignAttr(attrname="alpha", parent=node)
+            yield new_node
+
+        manager = astroid.MANAGER
+        transform = astroid.inference_tip(infer_func)
+        with _add_transform(manager, nodes.Name, transform):
+            node = astroid.extract_node(
+                """
+            call_something()
+            """
+            )
+            with self.assertNoMessages():
+                self.checker.visit_call(node)
+
+    def test_copy_environ(self) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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) -> None:
+        # 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 000000000..9a7ca0b27
--- /dev/null
+++ b/tests/checkers/unittest_strings.py
@@ -0,0 +1,93 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/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) -> None:
+        code = "b'test'.format(1, 2)"
+        node = astroid.extract_node(code)
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_format_types(self) -> None:
+        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() -> None:
+    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 000000000..90714ece9
--- /dev/null
+++ b/tests/checkers/unittest_typecheck.py
@@ -0,0 +1,501 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 David Liu <david@cs.toronto.edu>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@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/main/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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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) -> None:
+        # 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) -> None:
+        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) -> None:
+        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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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) -> None:
+        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) -> None:
+        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
+
+        class FourthInvalid(object, metaclass=InvalidAsMetaclass()):
+            pass
+        """
+        )
+        for class_obj, metaclass_name in (
+            ("FourthInvalid", "Instance of .InvalidAsMetaclass"),
+            ("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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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) -> None:
+        """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) -> None:
+        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) -> None:
+        """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: str) -> None:
+        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: str) -> None:
+        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: str
+    ) -> None:
+        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: str
+    ) -> None:
+        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: str) -> None:
+        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 000000000..9774b2d58
--- /dev/null
+++ b/tests/checkers/unittest_utils.py
@@ -0,0 +1,406 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Tests for the pylint.checkers.utils module."""
+
+from typing import Dict, Union
+
+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: str, kw: Union[Dict[str, int], Dict[str, str]]
+) -> None:
+    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: str, kw: Union[Dict[str, int], Dict[str, str]]
+) -> None:
+    node = astroid.extract_node(fn)
+    assert utils.get_argument_from_call(node, **kw) is not None
+
+
+def testGetArgumentFromCall() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    node = astroid.extract_node(
+        """
+        pass
+    """
+    )
+    assert utils.get_node_last_lineno(node) == 2
+
+
+def test_get_node_last_lineno_if_simple() -> None:
+    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() -> None:
+    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() -> None:
+    node = astroid.extract_node(
+        """
+        while True:
+            print(1)
+        """
+    )
+    assert utils.get_node_last_lineno(node) == 3
+
+
+def test_get_node_last_lineno_while_else() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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 000000000..315ad8ab8
--- /dev/null
+++ b/tests/checkers/unittest_variables.py
@@ -0,0 +1,376 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Sergei Lebedev <185856+superbobry@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/main/LICENSE
+
+import os
+import re
+import sys
+import unittest
+from pathlib import Path
+
+import astroid
+
+from pylint.checkers import variables
+from pylint.constants import IS_PYPY
+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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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)
+
+    @unittest.skipIf(IS_PYPY, "PyPy does not parse type comments")
+    def test_attribute_in_type_comment(self):
+        """Ensure attribute lookups in type comments are accounted for.
+
+        https://github.com/PyCQA/pylint/issues/4603
+        """
+        module = astroid.parse(
+            """
+        import foo
+        from foo import Bar, Boo
+        a = ... # type: foo.Bar
+        b = ... # type: foo.Bar[Boo]
+        c = ... # type: Bar.Boo
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(module)
+
+
+class TestVariablesCheckerWithTearDown(CheckerTestCase):
+
+    CHECKER_CLASS = variables.VariablesChecker
+
+    def setup_method(self) -> None:
+        super().setup_method()
+        self._to_consume_backup = self.checker._to_consume
+        self.checker._to_consume = []
+
+    def teardown_method(self) -> None:
+        self.checker._to_consume = self._to_consume_backup
+
+    @set_config(callbacks=("callback_", "_callback"))
+    def test_custom_callback_string(self) -> None:
+        """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) -> None:
+        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) -> None:
+        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) -> None:
+        node = astroid.parse(
+            """
+        import math as _
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+    def test_lambda_in_classdef(self) -> None:
+        # 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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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() -> None:
+
+        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 000000000..5c2567d11
--- /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 000000000..e69de29bb
--- /dev/null
+++ b/tests/data/__init__.py
diff --git a/tests/data/ascript b/tests/data/ascript
new file mode 100755
index 000000000..f401ebc4b
--- /dev/null
+++ b/tests/data/ascript
@@ -0,0 +1,2 @@
+#!/usr/bin/python
+"""ttttttttttttttttttttoooooooooooooooooooooooooooooooooooooooooooooooooooooo lllllllllllooooooooooooooooooooooooooooonnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnngggggggggggggggggg"""
diff --git a/tests/data/clientmodule_test.py b/tests/data/clientmodule_test.py
new file mode 100644
index 000000000..82deaaf6f
--- /dev/null
+++ b/tests/data/clientmodule_test.py
@@ -0,0 +1,30 @@
+""" docstring for file clientmodule.py """
+from data.suppliermodule_test import Interface, DoNothing, DoNothing2
+
+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, relation2: DoNothing2):
+        Ancestor.__init__(self, value)
+        self._id = _id
+        self.relation = DoNothing()
+        self.relation2 = relation2
diff --git a/tests/data/suppliermodule_test.py b/tests/data/suppliermodule_test.py
new file mode 100644
index 000000000..9c8b05d52
--- /dev/null
+++ b/tests/data/suppliermodule_test.py
@@ -0,0 +1,28 @@
+""" file suppliermodule.py """
+from typing import Optional
+
+class Interface:
+    def get_value(self):
+        raise NotImplementedError
+
+    def set_value(self, value):
+        raise NotImplementedError
+
+class CustomException(Exception): pass
+
+class DoNothing: pass
+
+class DoNothing2: pass
+
+class DoSomething:
+    def __init__(
+            self,
+            a_string: str,
+            optional_int: int = None,
+            optional_int_2: Optional[int] = None):
+        self.my_string = a_string
+        self.my_int = optional_int
+        self.my_int_2 = optional_int_2
+
+    def do_it(self, new_int: int) -> int:
+        return self.my_int + new_int
diff --git a/tests/extensions/__init__.py b/tests/extensions/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..fd3e5c054
--- /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 000000000..5649023c6
--- /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 000000000..dfe6bbcb5
--- /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 000000000..8f34c657f
--- /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 000000000..22e79c1db
--- /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 000000000..8a18df2eb
--- /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 000000000..c6dcf8ea8
--- /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 000000000..fdbdb5f0c
--- /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 000000000..5ee50f314
--- /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 000000000..16d5c30d1
--- /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 000000000..8829c4383
--- /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 000000000..4512873f0
--- /dev/null
+++ b/tests/extensions/test_bad_builtin.py
@@ -0,0 +1,47 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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
+from pylint.lint.pylinter import PyLinter
+
+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: PyLinter) -> None:
+    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 000000000..4e38adb23
--- /dev/null
+++ b/tests/extensions/test_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) 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.broad_try_clause`"""
+import unittest
+from os import path as osp
+from typing import TYPE_CHECKING, Optional
+
+from pylint import checkers
+from pylint.extensions.broad_try_clause import BroadTryClauseChecker
+from pylint.lint import PyLinter
+from pylint.reporters import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+class BroadTryClauseTestReporter(BaseReporter):
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        self.messages = []
+
+    def _display(self, layout: "Section") -> None:
+        pass
+
+
+class BroadTryClauseTC(unittest.TestCase):
+    _linter = PyLinter()
+
+    @classmethod
+    def setUpClass(cls):
+        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) -> None:
+        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 000000000..28f8d935c
--- /dev/null
+++ b/tests/extensions/test_check_docs.py
@@ -0,0 +1,2333 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.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/main/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 astroid import nodes
+
+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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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) -> None:
+        """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) -> None:
+        """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,
+    ) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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: nodes.ClassDef) -> None:
+        """Visit all methods of a class node
+
+        :param node: class node
+        :type node: :class:`nodes.Class`
+        """
+        for body_item in node.body:
+            if isinstance(body_item, nodes.FunctionDef) and hasattr(body_item, "name"):
+                self.checker.visit_functiondef(body_item)
+
+    def test_missing_method_params_in_sphinx_docstring(self) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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) -> None:
+        """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-type-doc", node=node, args=("_",)),
+            Message(msg_id="useless-param-doc", node=node, args=("_, _ignored",)),
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_useless_docs_ignored_argument_names_google(self) -> None:
+        """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-type-doc", node=node, args=("_",)),
+            Message(msg_id="useless-param-doc", node=node, args=("_, _ignored",)),
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_useless_docs_ignored_argument_names_numpy(self) -> None:
+        """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-type-doc", node=node, args=("_",)),
+            Message(msg_id="useless-param-doc", node=node, args=("_, _ignored",)),
+        ):
+            self.checker.visit_functiondef(node)
+
+    @set_config(no_docstring_rgx=r"^_(?!_).*$")
+    def test_skip_no_docstring_rgx(self) -> None:
+        """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) -> None:
+        """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 000000000..c1552a0c3
--- /dev/null
+++ b/tests/extensions/test_check_docs_utils.py
@@ -0,0 +1,151 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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: str, count: int) -> None:
+    """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 000000000..14d2d37ad
--- /dev/null
+++ b/tests/extensions/test_check_mccabe.py
@@ -0,0 +1,72 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_mccabe"""
+# pylint: disable=redefined-outer-name
+
+from os import path as osp
+from typing import List
+
+import pytest
+
+from pylint.extensions import mccabe
+from pylint.lint.pylinter import PyLinter
+
+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() -> str:
+    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: PyLinter, fname_mccabe_example: str, complexity: int, expected: List[str]
+) -> None:
+    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 000000000..2930c56b2
--- /dev/null
+++ b/tests/extensions/test_check_raise_docs.py
@@ -0,0 +1,902 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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 000000000..cb55b0c93
--- /dev/null
+++ b/tests/extensions/test_check_return_docs.py
@@ -0,0 +1,697 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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 000000000..1048130d3
--- /dev/null
+++ b/tests/extensions/test_check_yields_docs.py
@@ -0,0 +1,490 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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 000000000..7b5bb1624
--- /dev/null
+++ b/tests/extensions/test_comparetozero.py
@@ -0,0 +1,60 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.emptystring"""
+
+import os
+import unittest
+from typing import TYPE_CHECKING, Optional
+
+from pylint import checkers
+from pylint.extensions.comparetozero import CompareToZeroChecker
+from pylint.lint import PyLinter
+from pylint.reporters import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+class CompareToZeroTestReporter(BaseReporter):
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        self.messages = []
+
+    def _display(self, layout: "Section") -> None:
+        pass
+
+
+class CompareToZeroUsedTC(unittest.TestCase):
+    _linter = PyLinter()
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        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) -> None:
+        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 000000000..65adfbb7f
--- /dev/null
+++ b/tests/extensions/test_confusing_elif.py
@@ -0,0 +1,198 @@
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# 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/main/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) -> None:
+        """
+        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) -> None:
+        """
+        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) -> None:
+        """
+        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) -> None:
+        """
+        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) -> None:
+        """
+        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) -> None:
+        """
+        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) -> None:
+        """
+        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) -> None:
+        """
+        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 000000000..7c1d019e7
--- /dev/null
+++ b/tests/extensions/test_docstyle.py
@@ -0,0 +1,58 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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
+from pylint.lint.pylinter import PyLinter
+
+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: PyLinter) -> None:
+    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 000000000..994a5efcf
--- /dev/null
+++ b/tests/extensions/test_elseif_used.py
@@ -0,0 +1,38 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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
+from pylint.lint.pylinter import PyLinter
+
+
+@pytest.fixture(scope="module")
+def checker():
+    return ElseifUsedChecker
+
+
+def test_elseif_message(linter: PyLinter) -> None:
+    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 000000000..42d1b51f2
--- /dev/null
+++ b/tests/extensions/test_empty_comment.py
@@ -0,0 +1,35 @@
+from pathlib import Path
+
+import pytest
+
+from pylint.extensions import empty_comment
+from pylint.lint.pylinter import PyLinter
+
+
+@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: PyLinter) -> None:
+    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 000000000..f89f9202f
--- /dev/null
+++ b/tests/extensions/test_emptystring.py
@@ -0,0 +1,47 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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
+from pylint.lint.pylinter import PyLinter
+
+
+@pytest.fixture(scope="module")
+def checker():
+    return CompareToEmptyStringChecker
+
+
+@pytest.fixture(scope="module")
+def disable():
+    return ["I"]
+
+
+def test_emptystring_message(linter: PyLinter) -> None:
+    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 000000000..005e0bcf9
--- /dev/null
+++ b/tests/extensions/test_overlapping_exceptions.py
@@ -0,0 +1,88 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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
+from pylint.lint.pylinter import PyLinter
+
+
+@pytest.fixture(scope="module")
+def checker():
+    return OverlappingExceptionsChecker
+
+
+@pytest.fixture(scope="module")
+def disable():
+    return ["I"]
+
+
+def test_overlapping_exceptions(linter: PyLinter) -> None:
+    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: PyLinter) -> None:
+    """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 000000000..1f945bf79
--- /dev/null
+++ b/tests/extensions/test_redefined.py
@@ -0,0 +1,54 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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
+from pylint.lint.pylinter import PyLinter
+
+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: PyLinter) -> None:
+    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/extensions/test_while_used.py b/tests/extensions/test_while_used.py
new file mode 100644
index 000000000..3bf081a29
--- /dev/null
+++ b/tests/extensions/test_while_used.py
@@ -0,0 +1,25 @@
+"""Tests for the pylint checker in :mod:`pylint.extensions.while
+"""
+
+import astroid
+
+from pylint.extensions.while_used import WhileChecker
+from pylint.testutils import CheckerTestCase, Message
+
+
+class TestWhileUsed(CheckerTestCase):
+
+    CHECKER_CLASS = WhileChecker
+
+    def test_while_used(self) -> None:
+        node = astroid.extract_node(
+            """
+        def f():
+            i = 0
+            while i < 10:
+                i += 1
+        """
+        ).body[1]
+
+        with self.assertAddsMessages(Message("while-used", node=node)):
+            self.checker.visit_while(node)
diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..e69de29bb
--- /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 000000000..d63389c50
--- /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, 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.py b/tests/functional/a/abstract/abstract_class_instantiated.py
new file mode 100644
index 000000000..85facb540
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated.py
@@ -0,0 +1,143 @@
+"""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]
+
+
+class BadClassTwo(abc.ABC):
+    """
+    Check that instantiating a class with `abc.ABCMeta` as ancestor fails if it
+    defines abstract methods.
+    """
+    @abc.abstractmethod
+    def test(self):
+        pass
+
+
+def main_two():
+    """ do nothing """
+    BadClassTwo() # [abstract-class-instantiated]
diff --git a/tests/functional/a/abstract/abstract_class_instantiated.txt b/tests/functional/a/abstract/abstract_class_instantiated.txt
new file mode 100644
index 000000000..757528d01
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_class_instantiated.txt
@@ -0,0 +1,6 @@
+abstract-class-instantiated:108:4:main:Abstract class 'BadMroAbstractMethods' with abstract methods instantiated:HIGH
+abstract-class-instantiated:109:4:main:Abstract class 'BadClass' with abstract methods instantiated:HIGH
+abstract-class-instantiated:110:4:main:Abstract class 'SecondBadClass' with abstract methods instantiated:HIGH
+abstract-class-instantiated:111:4:main:Abstract class 'ThirdBadClass' with abstract methods instantiated:HIGH
+abstract-class-instantiated:128:4:main2:Abstract class 'FourthBadClass' with abstract methods instantiated:HIGH
+abstract-class-instantiated:143:4:main_two:Abstract class 'BadClassTwo' with abstract methods instantiated:HIGH
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 000000000..daaa3b689
--- /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_method.py b/tests/functional/a/abstract/abstract_method.py
new file mode 100644
index 000000000..d58f68036
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_method.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.txt b/tests/functional/a/abstract/abstract_method.txt
new file mode 100644
index 000000000..783242fd5
--- /dev/null
+++ b/tests/functional/a/abstract/abstract_method.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 000000000..fbad8c377
--- /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= 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 000000000..d8a97b4c7
--- /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 000000000..76ba5de50
--- /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 000000000..1a622824b
--- /dev/null
+++ b/tests/functional/a/access/access_to__name__.py
@@ -0,0 +1,21 @@
+# pylint: disable=too-few-public-methods,  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 000000000..5e1f80e2a
--- /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 000000000..ffbfabf15
--- /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
+# 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 000000000..1b93683db
--- /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/access/access_to_protected_members_typing.py b/tests/functional/a/access/access_to_protected_members_typing.py
new file mode 100644
index 000000000..4e5eee4c6
--- /dev/null
+++ b/tests/functional/a/access/access_to_protected_members_typing.py
@@ -0,0 +1,32 @@
+# pylint: disable=too-few-public-methods, invalid-name
+"""Test typing with a protected member"""
+from __future__ import annotations
+
+
+class MyClass:
+    """Class with protected members."""
+
+    class _Inner_Class:
+        """Inner class with protected members."""
+
+        def __init__(self) -> None:
+            self.data = 1
+
+        def return_data(self) -> int:
+            """Return data"""
+            return self.data
+
+    def return_private_class(self) -> MyClass._Inner_Class:
+        """Doing nothing."""
+        return self._Inner_Class()
+
+
+def access_protected_class(data: MyClass._Inner_Class) -> int:
+    """Function that always receives a protected class."""
+    return data.return_data() + 1
+
+
+def pass_protected_class() -> None:
+    """Function that passes a protected class to another function."""
+    data_value = access_protected_class(MyClass().return_private_class())
+    print(data_value)
diff --git a/tests/functional/a/access/access_to_protected_members_typing.rc b/tests/functional/a/access/access_to_protected_members_typing.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/a/access/access_to_protected_members_typing.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/a/access/access_to_protected_members_typing.txt b/tests/functional/a/access/access_to_protected_members_typing.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/a/access/access_to_protected_members_typing.txt
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 000000000..9e258faa5
--- /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 000000000..68a8c8ef1
--- /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 000000000..4dbeacafc
--- /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 000000000..776b99f68
--- /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 000000000..d6c1bca78
--- /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 000000000..95e463fc1
--- /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 000000000..776b99f68
--- /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 000000000..e97793af6
--- /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 000000000..f753dfd92
--- /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 000000000..68cb8556c
--- /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.py b/tests/functional/a/anomalous_unicode_escape.py
new file mode 100644
index 000000000..7c863097b
--- /dev/null
+++ b/tests/functional/a/anomalous_unicode_escape.py
@@ -0,0 +1,19 @@
+# pylint:disable=pointless-string-statement, redundant-u-string-prefix
+"""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.txt b/tests/functional/a/anomalous_unicode_escape.txt
new file mode 100644
index 000000000..3682db856
--- /dev/null
+++ b/tests/functional/a/anomalous_unicode_escape.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 000000000..9e66ff18d
--- /dev/null
+++ b/tests/functional/a/arguments.py
@@ -0,0 +1,262 @@
+# pylint: disable=too-few-public-methods, missing-docstring,import-error,wrong-import-position
+# pylint: disable=wrong-import-order, useless-object-inheritance,unnecessary-lambda, consider-using-f-string
+
+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 000000000..4764d05da
--- /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 000000000..d17bd4a50
--- /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 000000000..b5b43505a
--- /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 000000000..12b730503
--- /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 000000000..600664c94
--- /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 000000000..b912fc999
--- /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 000000000..22e7519ac
--- /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 000000000..0f3b60c1f
--- /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 000000000..14e7d4c55
--- /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 000000000..5f08165d3
--- /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 000000000..e360737e6
--- /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 000000000..c53faf935
--- /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/assigning_non_slot.py b/tests/functional/a/assign/assigning_non_slot.py
new file mode 100644
index 000000000..cf673692f
--- /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,  import-error, useless-object-inheritance, redundant-u-string-prefix
+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 000000000..28bf5d4cf
--- /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 000000000..797c6b083
--- /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 000000000..a17bb22da
--- /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 000000000..a347f8c95
--- /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 000000000..4bb41f1a6
--- /dev/null
+++ b/tests/functional/a/assign/assignment_expression.py
@@ -0,0 +1,91 @@
+"""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}'
+
+
+# https://github.com/PyCQA/pylint/issues/4828
+def func3():
+    return bar if (bar := "") else ""
diff --git a/tests/functional/a/assign/assignment_expression.rc b/tests/functional/a/assign/assignment_expression.rc
new file mode 100644
index 000000000..85fc502b3
--- /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 000000000..c4b8da483
--- /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 000000000..5415f6097
--- /dev/null
+++ b/tests/functional/a/assign/assignment_from_no_return.py
@@ -0,0 +1,78 @@
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods, no-self-use
+
+
+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
+
+
+# Regression test for https://github.com/PyCQA/pylint/issues/4220
+class A:
+    """Parent class"""
+    def f(self):
+        """This returns something"""
+        return 42
+
+
+class B(A):
+    """Child class"""
+    def __init__(self):
+        self.a = A()
+        result = self.a.f()  # no error here
+        print(result)
+
+    def f(self):
+        """This doesn't return anything"""
+
+
+res = B().a.f()  # no error here
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 000000000..88bcd9a20
--- /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_2.py b/tests/functional/a/assign/assignment_from_no_return_2.py
new file mode 100644
index 000000000..4cd5ef106
--- /dev/null
+++ b/tests/functional/a/assign/assignment_from_no_return_2.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/assignment_from_no_return_2.txt b/tests/functional/a/assign/assignment_from_no_return_2.txt
new file mode 100644
index 000000000..4518109ac
--- /dev/null
+++ b/tests/functional/a/assign/assignment_from_no_return_2.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/assignment_from_no_return_py3.py b/tests/functional/a/assign/assignment_from_no_return_py3.py
new file mode 100644
index 000000000..cb6dcd962
--- /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,no-self-use
+
+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/async_functions.py b/tests/functional/a/async_functions.py
new file mode 100644
index 000000000..3e634341c
--- /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.txt b/tests/functional/a/async_functions.txt
new file mode 100644
index 000000000..cb5324868
--- /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 000000000..1cb319c61
--- /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 000000000..cc7a9fd35
--- /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 000000000..2bc126761
--- /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 000000000..a17bb22da
--- /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 000000000..e38a51cd3
--- /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 000000000..e69de29bb
--- /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 000000000..4f2fa3ea8
--- /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 000000000..1181676a2
--- /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 000000000..af3e4fb9f
--- /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.txt b/tests/functional/b/bad_exception_context.txt
new file mode 100644
index 000000000..11f9e404e
--- /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 000000000..4c50eae0b
--- /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 000000000..3963624fd
--- /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 000000000..ac6fc6642
--- /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 000000000..b211d7254
--- /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 000000000..6a97bff61
--- /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.py b/tests/functional/b/bad_open_mode.py
new file mode 100644
index 000000000..b68238013
--- /dev/null
+++ b/tests/functional/b/bad_open_mode.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", encoding="utf-8")

+open(NAME, "rb")

+open(NAME, "x", encoding="utf-8")

+open(NAME, "br")

+open(NAME, "+r", encoding="utf-8")

+open(NAME, "xb")

+open(NAME, "rwx", encoding="utf-8")  # [bad-open-mode]

+open(NAME, "rr", encoding="utf-8")  # [bad-open-mode]

+open(NAME, "+", encoding="utf-8")  # [bad-open-mode]

+open(NAME, "xw", encoding="utf-8")  # [bad-open-mode]

+open(NAME, "ab+")

+open(NAME, "a+b")

+open(NAME, "+ab")

+open(NAME, "+rUb")

+open(NAME, "x+b")

+open(NAME, "Ua", encoding="utf-8")  # [bad-open-mode]

+open(NAME, "Ur++", encoding="utf-8")  # [bad-open-mode]

+open(NAME, "Ut", encoding="utf-8")

+open(NAME, "Ubr")

diff --git a/tests/functional/b/bad_open_mode.rc b/tests/functional/b/bad_open_mode.rc
new file mode 100644
index 000000000..b47a74525
--- /dev/null
+++ b/tests/functional/b/bad_open_mode.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=PyPy
diff --git a/tests/functional/b/bad_open_mode.txt b/tests/functional/b/bad_open_mode.txt
new file mode 100644
index 000000000..1ea232598
--- /dev/null
+++ b/tests/functional/b/bad_open_mode.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 000000000..073e828da
--- /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 000000000..48eb85264
--- /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 000000000..101123330
--- /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
+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 000000000..051bd11ba
--- /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 000000000..a28c84cc0
--- /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 000000000..67a28a36a
--- /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 000000000..1e1b939ab
--- /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 000000000..bbfdd97c3
--- /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 000000000..85fc502b3
--- /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 000000000..e73bf3dcd
--- /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 000000000..c2e0c5b0e
--- /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 000000000..e7e02eaed
--- /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 000000000..59f606aee
--- /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 000000000..47a207920
--- /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 000000000..514ffe1d6
--- /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 000000000..b77ec2b8d
--- /dev/null
+++ b/tests/functional/b/base_init_vars.py
@@ -0,0 +1,35 @@
+# pylint:disable=no-self-use
+# pylint:disable=too-few-public-methods, useless-object-inheritance
+"""Checks that class variables are seen as inherited !"""
+
+
+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 000000000..84067e3ff
--- /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 000000000..747d71a95
--- /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 000000000..24c839951
--- /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 000000000..388457b40
--- /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 000000000..22c07a330
--- /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/builtin_module_test.py b/tests/functional/b/builtin_module_test.py
new file mode 100644
index 000000000..9b1e7ce8e
--- /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 000000000..e69de29bb
--- /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 000000000..880015eb1
--- /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 000000000..85fc502b3
--- /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 000000000..6c3a6d107
--- /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 000000000..5520fe949
--- /dev/null
+++ b/tests/functional/c/cellvar_escaping_loop.py
@@ -0,0 +1,219 @@
+# pylint: disable= 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 good_case9():
+    """Ignore when the cell var is not defined in a loop"""
+    i = 10
+    lst = []
+    for _ in range(10):
+        lst.append(lambda: i)
+    return lst
+
+
+def good_case10():
+    """Ignore when a loop variable is showdowed by an inner function"""
+    lst = []
+    for i in range(10):  # pylint: disable=unused-variable
+        def func():
+            i = 100
+            def func2(arg=i):
+                return arg
+
+            return func2
+
+        lst.append(func)
+    return lst
+
+
+def good_case_issue3107():
+    """Eager binding of cell variable when used in a non-trivial default argument expression.
+    """
+    for i in [[2], [3]]:
+        next(filter(lambda j, ix=i[0]: j == ix, [1, 3]))
+
+
+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
+
+
+def bad_case7():
+    """Multiple variables unpacked in comprehension."""
+    return [
+        lambda: (
+            x  # [cell-var-from-loop]
+            + y)  # [cell-var-from-loop]
+        for x, y in ((1, 2), (3, 4), (5, 6))
+    ]
+
+
+def bad_case8():
+    """Closing over variable defined in loop below the function."""
+    lst = []
+    for i in range(10):
+        lst.append(lambda: j)  # [cell-var-from-loop]
+        j = i * i
+    return lst
+
+
+def bad_case9():
+    """Detect when loop variable shadows an outer assignment."""
+    lst = []
+    i = 100
+    for i in range(10):
+        lst.append(lambda: i)  # [cell-var-from-loop]
+    return lst
+
+
+def bad_case10():
+    """Detect when a loop variable is the default argument for a nested function"""
+    lst = []
+    for i in range(10):
+        def func():
+            def func2(arg=i):  # [cell-var-from-loop]
+                return arg
+
+            return func2
+
+        lst.append(func)
+    return lst
+
+
+def bad_case_issue2846():
+    """Closing over variable that is used within a comprehension in the function body."""
+    lst_a = [
+        (lambda: n)  # [cell-var-from-loop]
+        for n in range(3)
+    ]
+
+    lst_b = [
+        (lambda: [n for _ in range(3)])  # [cell-var-from-loop]
+        for n in range(3)
+    ]
+
+    return lst_a, lst_b
+
+
+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 000000000..4513d833f
--- /dev/null
+++ b/tests/functional/c/cellvar_escaping_loop.txt
@@ -0,0 +1,13 @@
+cell-var-from-loop:101:27:bad_case.<lambda>:Cell variable i defined in loop:HIGH
+cell-var-from-loop:106:20:bad_case2.<lambda>:Cell variable i defined in loop:HIGH
+cell-var-from-loop:114:27:bad_case3.<lambda>:Cell variable j defined in loop:HIGH
+cell-var-from-loop:124:19:bad_case4.nested:Cell variable i defined in loop:HIGH
+cell-var-from-loop:145:20:bad_case5.<lambda>:Cell variable i defined in loop:HIGH
+cell-var-from-loop:153:27:bad_case6.<lambda>:Cell variable i defined in loop:HIGH
+cell-var-from-loop:161:12:bad_case7.<lambda>:Cell variable x defined in loop:HIGH
+cell-var-from-loop:162:14:bad_case7.<lambda>:Cell variable y defined in loop:HIGH
+cell-var-from-loop:171:27:bad_case8.<lambda>:Cell variable j defined in loop:HIGH
+cell-var-from-loop:181:27:bad_case9.<lambda>:Cell variable i defined in loop:HIGH
+cell-var-from-loop:190:26:bad_case10.func.func2:Cell variable i defined in loop:HIGH
+cell-var-from-loop:202:17:bad_case_issue2846.<lambda>:Cell variable n defined in loop:HIGH
+cell-var-from-loop:207:18:bad_case_issue2846.<lambda>:Cell variable n defined in loop:HIGH
diff --git a/tests/functional/c/class_attributes.py b/tests/functional/c/class_attributes.py
new file mode 100644
index 000000000..1d41f9d7a
--- /dev/null
+++ b/tests/functional/c/class_attributes.py
@@ -0,0 +1,32 @@
+"""Test that valid class attribute doesn't trigger errors"""
+__revision__ = 'sponge bob'
+# pylint: disable=useless-object-inheritance,missing-docstring,too-few-public-methods
+
+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
+
+
+class Base:
+    _class_prop: int
+
+
+class Child(Base):
+    _class_prop = 42
+
+    def method(self):
+        print(self._class_prop)
+
+
+Child().method()
diff --git a/tests/functional/c/class_members.py b/tests/functional/c/class_members.py
new file mode 100644
index 000000000..e43ab57ba
--- /dev/null
+++ b/tests/functional/c/class_members.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_py30.py b/tests/functional/c/class_members_py30.py
new file mode 100644
index 000000000..cb7267ce5
--- /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.txt b/tests/functional/c/class_members_py30.txt
new file mode 100644
index 000000000..c0fab25a7
--- /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_scope.py b/tests/functional/c/class_scope.py
new file mode 100644
index 000000000..a22ba721b
--- /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 000000000..a45d23263
--- /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 000000000..b6a0edf44
--- /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/classes_meth_could_be_a_function.py b/tests/functional/c/classes_meth_could_be_a_function.py
new file mode 100644
index 000000000..94103a324
--- /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 000000000..516efd7d4
--- /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 000000000..b676844ae
--- /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 000000000..a87f0b57e
--- /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 000000000..cfd0b00f4
--- /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 000000000..04d8deb8c
--- /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 000000000..42351998d
--- /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 000000000..5d21cb56e
--- /dev/null
+++ b/tests/functional/c/confidence_filter.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=no-init,too-few-public-methods,undefined-variable
+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 000000000..1c2cd8380
--- /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 000000000..7b8d494e4
--- /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 000000000..5ac2e7a50
--- /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 000000000..996fa5429
--- /dev/null
+++ b/tests/functional/c/consider/consider_iterating_dictionary.py
@@ -0,0 +1,68 @@
+# pylint: disable=missing-docstring, expression-not-assigned, too-few-public-methods
+# pylint: disable=no-member, import-error, no-self-use, line-too-long, useless-object-inheritance
+# pylint: disable=unnecessary-comprehension, use-dict-literal
+
+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]
+
+# Checks for membership checks
+if 1 in dict().keys(): # [consider-iterating-dictionary]
+    pass
+if 1 in {}.keys(): # [consider-iterating-dictionary]
+    pass
+if 1 in Unknown().keys():
+    pass
+if 1 in Unknown.keys():
+    pass
+if 1 in CustomClass().keys():
+    pass
+if 1 in dict():
+    pass
+if 1 in dict().values():
+    pass
+if (1, 1) in dict().items():
+    pass
+if [1] == {}.keys():
+    pass
+if [1] == {}:
+    pass
+if [1] == dict():
+    pass
+VAR = 1 in {}.keys() # [consider-iterating-dictionary]
+VAR = 1 in {}
+VAR = 1 in dict()
+VAR = [1, 2] == {}.keys() in {False}
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 000000000..a3ebbac2a
--- /dev/null
+++ b/tests/functional/c/consider/consider_iterating_dictionary.txt
@@ -0,0 +1,18 @@
+consider-iterating-dictionary:25:16::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:26:16::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:27:16::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:28:21::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:29:24::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:30:24::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:31:24::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:32:29::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:33:11::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:38:24::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:38:55::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:39:31::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:39:61::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:40:30::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:40:60::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:43:8::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:45:8::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-iterating-dictionary:65:11::Consider iterating the dictionary directly instead of calling .keys():HIGH
diff --git a/tests/functional/c/consider/consider_join.py b/tests/functional/c/consider/consider_join.py
new file mode 100644
index 000000000..24cd6dd49
--- /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 000000000..f544e55b8
--- /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 000000000..d3387bd5c
--- /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 000000000..9728f1e15
--- /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 000000000..e3320773f
--- /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 000000000..3e099d671
--- /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 000000000..c9d740e18
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_dict_comprehension.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring, invalid-name, use-dict-literal

+

+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 000000000..ea2bb31ae
--- /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 000000000..32e92e803
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_dict_items.py
@@ -0,0 +1,105 @@
+"""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,redefined-outer-name,use-dict-literal

+

+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]

+

+# Test false positive described in #4630

+# (https://github.com/PyCQA/pylint/issues/4630)

+

+d = {'key': 'value'}

+

+for k in d:  # this is fine, with the reassignment of d[k], d[k] is necessary

+    d[k] += '123'

+    if '1' in d[k]:  # index lookup necessary here, do not emit error

+        print('found 1')

+

+for k in d:  # if this gets rewritten to d.items(), we are back to the above problem

+    d[k] = d[k] + 1

+    if '1' in d[k]:  # index lookup necessary here, do not emit error

+        print('found 1')

+

+for k in d:  # [consider-using-dict-items]

+    if '1' in d[k]:  # index lookup necessary here, do not emit error

+        print('found 1')

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 000000000..9951d6848
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_dict_items.txt
@@ -0,0 +1,16 @@
+consider-using-dict-items:6:4:bad:Consider iterating with .items():HIGH
+consider-using-dict-items:9:4:bad:Consider iterating with .items():HIGH
+consider-using-dict-items:21:4:another_bad:Consider iterating with .items():HIGH
+consider-using-dict-items:40:0::Consider iterating with .items():HIGH
+consider-using-dict-items:44:0::Consider iterating with .items():HIGH
+consider-iterating-dictionary:47:10::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-using-dict-items:47:0::Consider iterating with .items():HIGH
+consider-using-dict-items:54:0::Consider iterating with .items():HIGH
+consider-using-dict-items:67:0::Consider iterating with .items():HIGH
+consider-using-dict-items:68:0::Consider iterating with .items():HIGH
+consider-using-dict-items:71:0::Consider iterating with .items():HIGH
+consider-using-dict-items:72:0::Consider iterating with .items():HIGH
+consider-using-dict-items:75:0::Consider iterating with .items():HIGH
+consider-iterating-dictionary:86:25::Consider iterating the dictionary directly instead of calling .keys():HIGH
+consider-using-dict-items:86:0::Consider iterating with .items():HIGH
+consider-using-dict-items:103:0::Consider iterating with .items():HIGH
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 000000000..bf29d6885
--- /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]  # pylint: disable=cell-var-from-loop

+        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 000000000..4a4738838
--- /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_f_string.py b/tests/functional/c/consider/consider_using_f_string.py
new file mode 100644
index 000000000..825f3517c
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_f_string.py
@@ -0,0 +1,107 @@
+"""Test to see if a f-string would be possible and consider-using-f-string should be raised"""
+# pylint: disable=unused-variable, invalid-name, missing-function-docstring, pointless-statement
+# pylint: disable=expression-not-assigned, repeated-keyword
+
+PARAM_1 = PARAM_2 = PARAM_3 = 1
+PARAM_LIST = [PARAM_1, PARAM_2, PARAM_3]
+PARAM_LIST_SINGLE = [PARAM_1]
+PARAM_DICT = {"Param_1": PARAM_1, "Param_2": PARAM_2, "Param_3": PARAM_3}
+PARAM_DICT_SINGLE = {"Param_1": PARAM_1}
+
+
+def return_parameter():
+    return PARAM_1
+
+
+def return_list():
+    return PARAM_LIST
+
+
+def return_dict():
+    return PARAM_DICT
+
+
+def print_good():
+    print("String {}, {} or {}".format(*PARAM_LIST))
+    print("String {}, {}, {} or {}".format(*PARAM_LIST_SINGLE, *PARAM_LIST))
+    print("String {Param}, {}, {} or {}".format(Param=PARAM_1, *PARAM_LIST))
+    print("String {Param} {Param}".format(Param=PARAM_1))
+    print("{Param_1} {Param_2}".format(**PARAM_DICT))
+    print("{Param_1} {Param_2} {Param_3}".format(**PARAM_DICT_SINGLE, **PARAM_DICT))
+    print("{Param_1} {Param_2} {Param_3}".format(Param_1=PARAM_1, **PARAM_DICT))
+    print("{Param_1} {Param_2}".format(**PARAM_DICT))
+    print("{Param_1} {Param_2}".format(**return_dict()))
+    print("%(Param_1)s %(Param_2)s" % PARAM_LIST)
+    print("%(Param_1)s %(Param_2)s" % PARAM_DICT)
+    print("%(Param_1)s %(Param_2)s" % return_dict())
+    print("{a[Param_1]}{a[Param_2]}".format(a=PARAM_DICT))
+
+def print_bad():
+    print("String %f" % PARAM_1)  # [consider-using-f-string]
+    print("String {}".format(PARAM_1))  # [consider-using-f-string]
+    print("String {Param_1}".format(Param_1=PARAM_1))  # [consider-using-f-string]
+    print("{} {}".format(PARAM_1, PARAM_2))  # [consider-using-f-string]
+    print("{Par_1}{Par_2}".format(Par_1=PARAM_1, Par_2=PARAM_2))  # [consider-using-f-string]
+    print("{Param_1}".format(*PARAM_LIST_SINGLE))  # [consider-using-f-string]
+    print("{Param_1}".format(**PARAM_DICT_SINGLE))  # [consider-using-f-string]
+    print("String %s" % (PARAM_1))  # [consider-using-f-string]
+    print("String %s %s" % (PARAM_1, PARAM_2))  # [consider-using-f-string]
+    print("String %s" % (PARAM_LIST_SINGLE))  # [consider-using-f-string]
+
+
+def statement_good():
+    "String {}, {} or {}".format(*PARAM_LIST)
+    "String {}, {}, {} or {}".format(*PARAM_LIST_SINGLE, *PARAM_LIST)
+    "String {Param}, {}, {} or {}".format(Param=PARAM_1, *PARAM_LIST)
+    "String {Param} {Param}".format(Param=PARAM_1)
+    "{Param_1} {Param_2}".format(**PARAM_DICT)
+    "{Param_1} {Param_2} {Param_3}".format(**PARAM_DICT_SINGLE, **PARAM_DICT)
+    "{Param_1} {Param_2} {Param_3}".format(Param_1=PARAM_1, **PARAM_DICT)
+    "{Param_1} {Param_2}".format(**PARAM_DICT)
+    "{Param_1} {Param_2}".format(**return_dict())
+    "%(Param_1)s %(Param_2)s" % PARAM_LIST
+    "%(Param_1)s %(Param_2)s" % PARAM_DICT
+    "%(Param_1)s %(Param_2)s" % return_dict()
+    "{a[Param_1]}{a[Param_2]}".format(a=PARAM_DICT)
+
+def statement_bad():
+    "String %f" % PARAM_1  # [consider-using-f-string]
+    "String {}".format(PARAM_1)  # [consider-using-f-string]
+    "String {Param_1}".format(Param_1=PARAM_1)  # [consider-using-f-string]
+    "{} {}".format(PARAM_1, PARAM_2)  # [consider-using-f-string]
+    "{Par_1}{Par_2}".format(Par_1=PARAM_1, Par_2=PARAM_2)  # [consider-using-f-string]
+    "{Param_1}".format(*PARAM_LIST_SINGLE)  # [consider-using-f-string]
+    "{Param_1}".format(**PARAM_DICT_SINGLE)  # [consider-using-f-string]
+    "String %s" % (PARAM_1)  # [consider-using-f-string]
+    "String %s %s" % (PARAM_1, PARAM_2)  # [consider-using-f-string]
+    "String %s" % (PARAM_LIST_SINGLE)  # [consider-using-f-string]
+
+
+def assignment_good():
+    A = "String {}, {} or {}".format(*PARAM_LIST)
+    B = "String {}, {}, {} or {}".format(*PARAM_LIST_SINGLE, *PARAM_LIST)
+    C = "String {Param}, {}, {} or {}".format(Param=PARAM_1, *PARAM_LIST)
+    D = "String {Param} {Param}".format(Param=PARAM_1)
+    E = "{Param_1} {Param_2}".format(**PARAM_DICT)
+    F = "{Param_1} {Param_2} {Param_3}".format(**PARAM_DICT_SINGLE, **PARAM_DICT)
+    G = "{Param_1} {Param_2} {Param_3}".format(Param_1=PARAM_1, **PARAM_DICT)
+    H = "{Param_1} {Param_2}".format(**PARAM_DICT)
+    I = "{Param_1} {Param_2}".format(**return_dict())
+    J = "%(Param_1)s %(Param_2)s" % PARAM_LIST
+    K = "%(Param_1)s %(Param_2)s" % PARAM_DICT
+    L = "%(Param_1)s %(Param_2)s" % return_dict()
+    M = "{a[Param_1]}{a[Param_2]}".format(a=PARAM_DICT)
+    N = "{Param}".format
+
+
+def assignment_bad():
+    a = "String %f" % PARAM_1  # [consider-using-f-string]
+    b = "String {}".format(PARAM_1)  # [consider-using-f-string]
+    c = "String {Param_1}".format(Param_1=PARAM_1)  # [consider-using-f-string]
+    d = "{} {}".format(PARAM_1, PARAM_2)  # [consider-using-f-string]
+    e = "{Par_1}{Par_2}".format(Par_1=PARAM_1, Par_2=PARAM_2)  # [consider-using-f-string]
+    f = "{Param_1}".format(*PARAM_LIST_SINGLE)  # [consider-using-f-string]
+    g = "{Param_1}".format(**PARAM_DICT_SINGLE)  # [consider-using-f-string]
+    h = "String %s" % (PARAM_1)  # [consider-using-f-string]
+    i = "String %s %s" % (PARAM_1, PARAM_2)  # [consider-using-f-string]
+    j = "String %s" % (PARAM_LIST_SINGLE)  # [consider-using-f-string]
diff --git a/tests/functional/c/consider/consider_using_f_string.txt b/tests/functional/c/consider/consider_using_f_string.txt
new file mode 100644
index 000000000..db8f98112
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_f_string.txt
@@ -0,0 +1,30 @@
+consider-using-f-string:40:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:41:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:42:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:43:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:44:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:45:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:46:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:47:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:48:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:49:10:print_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:68:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:69:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:70:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:71:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:72:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:73:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:74:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:75:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:76:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:77:4:statement_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:98:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:99:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:100:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:101:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:102:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:103:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:104:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:105:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:106:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
+consider-using-f-string:107:8:assignment_bad:Formatting a regular string which could be a f-string:HIGH
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 000000000..eadb34a56
--- /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 000000000..3d3c5a494
--- /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 000000000..0b71431d0
--- /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 = {}
+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 000000000..d57b4a269
--- /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 000000000..8d23bb093
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_in.py
@@ -0,0 +1,53 @@
+# pylint: disable=missing-docstring, invalid-name, pointless-statement, misplaced-comparison-constant, undefined-variable, literal-comparison, line-too-long, unneeded-not, too-few-public-methods
+
+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
+
+
+# With attribute nodes
+class A:
+    value = 2
+
+A.value == 1 or A.value == 2  # [consider-using-in]
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 000000000..72c8e389d
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_in.txt
@@ -0,0 +1,14 @@
+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], [])'"
+consider-using-in:53:0::"Consider merging these comparisons with ""in"" to 'A.value in (1, 2)'"
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 000000000..6e7c7b886
--- /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 000000000..9ed5e0559
--- /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 000000000..345989c69
--- /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 000000000..4839a7a62
--- /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 000000000..524cf004d
--- /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 000000000..c429c652e
--- /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 000000000..ba66989cb
--- /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 000000000..05b57ae41
--- /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 000000000..d05866aaa
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with.py
@@ -0,0 +1,231 @@
+# 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.futures import ThreadPoolExecutor, ProcessPoolExecutor
+
+
+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_popen():
+    _ = subprocess.Popen("sh")  # [consider-using-with]
+    with subprocess.Popen("sh"):
+        pass
+
+
+def test_suppress_in_exit_stack():
+    """Regression test for issue #4654 (false positive)"""
+    with contextlib.ExitStack() as stack:
+        _ = stack.enter_context(
+            open("/sys/firmware/devicetree/base/hwid,location", "r", encoding="utf-8")
+        )  # must not trigger
+
+
+def test_futures():
+    """
+    Regression test for issue #4689.
+    ThreadPoolExecutor and ProcessPoolExecutor were formerly part of the callables that raised
+    the R1732 message if used outside a with block, but there are legitimate use cases where
+    Executor instances are used e.g. as a persistent background worker pool throughout the program.
+    """
+    thread_executor = ThreadPoolExecutor()
+    thread_executor.submit(print, 1)
+    process_executor = ProcessPoolExecutor()
+    process_executor.submit(print, 2)
+    thread_executor.shutdown()
+    process_executor.shutdown()
+
+
+pool = multiprocessing.Pool()  # must not trigger, as it is used later on
+with pool:
+    pass
+
+
+global_pool = (
+    multiprocessing.Pool()
+)  # must not trigger, will be used in nested scope
+
+
+def my_nested_function():
+    with global_pool:
+        pass
+
+
+# this must also work for tuple unpacking
+pool1, pool2 = (
+    multiprocessing.Pool(),  # must not trigger
+    multiprocessing.Pool(),  # must not trigger
+)
+
+with pool1:
+    pass
+
+with pool2:
+    pass
+
+unused_pool1, unused_pool2 = (
+    multiprocessing.Pool(),  # [consider-using-with]
+    multiprocessing.Pool(),  # [consider-using-with]
+)
+
+used_pool, unused_pool = (
+    multiprocessing.Pool(),  # must not trigger
+    multiprocessing.Pool(),  # [consider-using-with]
+)
+with used_pool:
+    pass
+
+unused_pool, used_pool = (
+    multiprocessing.Pool(),  # [consider-using-with]
+    multiprocessing.Pool(),  # must not trigger
+)
+with used_pool:
+    pass
+
+
+def test_subscript_assignment():
+    """
+    Regression test for issue https://github.com/PyCQA/pylint/issues/4732.
+    If a context manager is assigned to a list or dict, we are not able to
+    tell if / how the context manager is used later on, as it is not assigned
+    to a variable or attribute directly.
+    In this case we can only emit the message directly.
+    """
+    job_list = [None, None]
+    job_list[0] = subprocess.Popen("ls")  # [consider-using-with]
+    job_dict = {}
+    job_dict["myjob"] = subprocess.Popen("ls")  # [consider-using-with]
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 000000000..45311b15b
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with.txt
@@ -0,0 +1,26 @@
+consider-using-with:15:9:test_codecs_open:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:20:8:test_urlopen:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:24:8:test_temporary_file:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:28:8:test_named_temporary_file:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:32:8:test_spooled_temporary_file:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:36:8:test_temporary_directory:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:40:12:test_zipfile:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:41:8:test_zipfile:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:45:12:test_pyzipfile:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:50:8:test_pyzipfile:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:57:9:test_tarfile:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:63:9:test_tarfile:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:72:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:79:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:86:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:93:4:test_lock_acquisition:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:129:8:test_multiprocessing:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:134:4:test_multiprocessing:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:139:4:test_multiprocessing:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:145:8:test_popen:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:201:4::Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:202:4::Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:207:4::Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:213:4::Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:229:18:test_subscript_assignment:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:231:24:test_subscript_assignment:Consider using 'with' for resource-allocating operations:HIGH
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 000000000..7c584d8f5
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with_open.py
@@ -0,0 +1,161 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, invalid-name, import-outside-toplevel, no-self-use
+# pylint: disable=missing-class-docstring, too-few-public-methods, unused-variable, multiple-statements, line-too-long
+"""
+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
+from pathlib import Path
+
+myfile = open("test.txt", encoding="utf-8")  # [consider-using-with]
+
+
+def test_open():
+    fh = open("test.txt", encoding="utf-8")  # [consider-using-with]
+    fh.close()
+
+    with open("test.txt", encoding="utf-8") 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", encoding="utf-8")  # 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", encoding="utf-8")  # must not trigger
+    yield file_handle
+    file_handle.close()
+
+
+def test_open_outside_assignment():
+    open("foo", encoding="utf-8").read()  # [consider-using-with]
+    content = open("foo", encoding="utf-8").read()  # [consider-using-with]
+
+
+def test_open_inside_with_block():
+    with open("foo", encoding="utf-8") as fh:
+        open("bar", encoding="utf-8")  # [consider-using-with]
+
+
+def test_ternary_if_in_with_block(file1, file2, which):
+    """Regression test for issue #4676 (false positive)"""
+    with (open(file1, encoding="utf-8") if which else open(file2, encoding="utf-8")) as input_file:  # must not trigger
+        return input_file.read()
+
+
+def test_single_line_with(file1):
+    with open(file1, encoding="utf-8"): return file1.read()  # must not trigger
+
+
+def test_multiline_with_items(file1, file2, which):
+    with (open(file1, encoding="utf-8") if which
+        else open(file2, encoding="utf-8")) as input_file: return input_file.read()
+
+
+def test_suppress_on_return():
+    return open("foo", encoding="utf8")  # must not trigger
+
+
+class TestControlFlow:
+    """
+    The message is triggered if a context manager is assigned to a variable, which name is later
+    reassigned without the variable being used inside a ``with`` first.
+    E.g. the following would trigger the message:
+
+        a = open("foo")  # <-- would trigger here
+        a = "something new"
+
+    But it must not happen that the logic which checks if the same variable is assigned multiple
+    times in different code branches where only one of those assign statements is hit at runtime.
+    For example, the variable could be assigned in an if-else construct.
+
+    These tests check that the message is not triggered in those circumstances.
+    """
+
+    def test_defined_in_if_and_else(self, predicate):
+        if predicate:
+            file_handle = open("foo", encoding="utf8")  # must not trigger
+        else:
+            file_handle = open("bar", encoding="utf8")  # must not trigger
+        with file_handle:
+            return file_handle.read()
+
+    def test_defined_in_else_only(self, predicate):
+        if predicate:
+            result = "shiny watermelon"
+        else:
+            file_handle = open("foo", encoding="utf8")  # must not trigger
+            with file_handle:
+                result = file_handle.read()
+        return result
+
+    def test_defined_in_if_only(self, predicate):
+        if predicate:
+            file_handle = open("foo", encoding="utf8")  # must not trigger
+            with file_handle:
+                result = file_handle.read()
+        else:
+            result = "shiny watermelon"
+        return result
+
+    def test_triggers_if_reassigned_after_if_else(self, predicate):
+        if predicate:
+            file_handle = open("foo", encoding="utf8")
+        else:
+            file_handle = open(  # [consider-using-with]
+                "bar", encoding="utf8"
+            )
+        file_handle = None
+        return file_handle
+
+    def test_defined_in_try_and_except(self):
+        try:
+            file_handle = open("foo", encoding="utf8")  # must not trigger
+        except FileNotFoundError:
+            file_handle = open("bar", encoding="utf8")  # must not trigger
+        with file_handle:
+            return file_handle.read()
+
+    def test_defined_in_try_and_finally(self):
+        try:
+            file_handle = open("foo", encoding="utf8")  # must not trigger
+        except FileNotFoundError:
+            Path("foo").touch()
+        finally:
+            file_handle.open("foo", encoding="utf")  # must not trigger
+        with file_handle:
+            return file_handle.read()
+
+    def test_defined_in_different_except_handlers(self, a, b):
+        try:
+            result = a/b
+        except ZeroDivisionError:
+            logfile = open("math_errors.txt", encoding="utf8")  # must not trigger
+            result = "Can't divide by zero"
+        except TypeError:
+            logfile = open("type_errors.txt", encoding="utf8")  # must not trigger
+            result = "Wrong types"
+        else:
+            logfile = open("results.txt", encoding="utf8")  # must not trigger
+        with logfile:
+            logfile.write(result)
+
+    def test_multiple_return_statements(self, predicate):
+        if predicate:
+            return open("foo", encoding="utf8")  # must not trigger
+        return open("bar", encoding="utf8")  # must not trigger
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 000000000..b47a74525
--- /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 000000000..cf3fdc1c8
--- /dev/null
+++ b/tests/functional/c/consider/consider_using_with_open.txt
@@ -0,0 +1,6 @@
+consider-using-with:12:9::Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:16:9:test_open:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:46:4:test_open_outside_assignment:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:47:14:test_open_outside_assignment:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:52:8:test_open_inside_with_block:Consider using 'with' for resource-allocating operations:HIGH
+consider-using-with:120:26:TestControlFlow.test_triggers_if_reassigned_after_if_else:Consider using 'with' for resource-allocating operations:HIGH
diff --git a/tests/functional/c/continue_in_finally.py b/tests/functional/c/continue_in_finally.py
new file mode 100644
index 000000000..bb1fcbab1
--- /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 000000000..67a28a36a
--- /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 000000000..3a5e542e1
--- /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 000000000..993f9a5dd
--- /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 000000000..308606ff4
--- /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 000000000..ee10413e3
--- /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 000000000..781715c0a
--- /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 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/d/__init__.py
diff --git a/tests/functional/d/dangerous_default_value.py b/tests/functional/d/dangerous_default_value.py
new file mode 100644
index 000000000..161eaceed
--- /dev/null
+++ b/tests/functional/d/dangerous_default_value.py
@@ -0,0 +1,111 @@
+# pylint: disable=missing-docstring, use-list-literal, use-dict-literal
+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.txt b/tests/functional/d/dangerous_default_value.txt
new file mode 100644
index 000000000..8f4dd7e47
--- /dev/null
+++ b/tests/functional/d/dangerous_default_value.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 000000000..db392d8b7
--- /dev/null
+++ b/tests/functional/d/dataclass_with_default_factory.py
@@ -0,0 +1,50 @@
+"""Various regression tests for dataclasses."""
+# See issues:
+# - https://github.com/PyCQA/pylint/issues/2605
+# - https://github.com/PyCQA/pylint/issues/2698
+from dataclasses import dataclass, field
+import dataclasses as dc
+from typing import cast
+
+
+@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])
+
+
+@dc.dataclass  # Note the use of dc instead of dataclasses
+class Test2:
+    """Test dataclass that uses a renamed import of dataclasses"""
+    int_prop: int = dc.field(default=10)
+    list_prop: list = dc.field(default_factory=list)
+    dict_prop: dict = dc.field(default_factory=dict)
+
+
+TEST2 = Test2()
+for _ in TEST2.list_prop:  # This is okay
+    pass
+
+
+TEST2.dict_prop["key"] = "value"  # This is okay
+
+
+# Test2.int_prop is inferred as 10, not a Field
+print(Test2.int_prop + 1)
+for _ in Test2.int_prop:  # [not-an-iterable]
+    pass
+
+
+Test2.int_prop["key"] = "value"  # [unsupported-assignment-operation]
+
+
+@dc.dataclass
+class TEST3:
+    """Test dataclass that puts call to field() in another function call"""
+    attribute: int = cast(int, field(default_factory=dict))
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 000000000..a17bb22da
--- /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/dataclass_with_default_factory.txt b/tests/functional/d/dataclass_with_default_factory.txt
new file mode 100644
index 000000000..af789b14a
--- /dev/null
+++ b/tests/functional/d/dataclass_with_default_factory.txt
@@ -0,0 +1,2 @@
+not-an-iterable:40:9::Non-iterable value Test2.int_prop is used in an iterating context:HIGH
+unsupported-assignment-operation:44:0::'Test2.int_prop' does not support item assignment:HIGH
diff --git a/tests/functional/d/dataclass_with_field.py b/tests/functional/d/dataclass_with_field.py
new file mode 100644
index 000000000..9a807becb
--- /dev/null
+++ b/tests/functional/d/dataclass_with_field.py
@@ -0,0 +1,32 @@
+"""Regression test for https://github.com/PyCQA/pylint/issues/4899"""
+
+# pylint: disable=missing-docstring,too-few-public-methods
+
+from dataclasses import field
+from typing import List
+from pydantic.dataclasses import dataclass # [import-error]
+
+
+class Item:
+    pass
+
+
+@dataclass
+class Case:
+    """Case class (group Item)"""
+
+    name: str
+    irr: float = 0
+    items: List[Item] = field(default_factory=lambda: [])
+
+    def add_item(self, item: Item) -> None:
+        """Add an item to the item list."""
+
+        self.items.append(item)
+
+    def find_item(self, description: str) -> Item:
+        """Find an item by description"""
+
+        return next(
+            (item for item in self.items if item.description == description), None
+        )
diff --git a/tests/functional/d/dataclass_with_field.rc b/tests/functional/d/dataclass_with_field.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/d/dataclass_with_field.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/d/dataclass_with_field.txt b/tests/functional/d/dataclass_with_field.txt
new file mode 100644
index 000000000..1caf8470a
--- /dev/null
+++ b/tests/functional/d/dataclass_with_field.txt
@@ -0,0 +1 @@
+import-error:7:0::Unable to import 'pydantic.dataclasses':HIGH
diff --git a/tests/functional/d/decorator_scope.py b/tests/functional/d/decorator_scope.py
new file mode 100644
index 000000000..141c26d06
--- /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 000000000..add5b3b40
--- /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 000000000..98e5077a6
--- /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,wrong-import-position,unnecessary-comprehension,unspecified-encoding
+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/dataclass_typecheck.py b/tests/functional/d/deprecated/dataclass_typecheck.py
new file mode 100644
index 000000000..9a2be2fb8
--- /dev/null
+++ b/tests/functional/d/deprecated/dataclass_typecheck.py
@@ -0,0 +1,115 @@
+"""Tests for dataclass attributes with basic type annotations.
+
+Tests for regressions from https://github.com/PyCQA/astroid/pull/1126
+"""
+# pylint: disable=missing-docstring,too-few-public-methods,pointless-statement,redefined-builtin, fixme
+from dataclasses import dataclass
+from typing import Callable, Dict, List, Optional
+
+
+class Dummy:
+    pass
+
+
+@dataclass
+class MyClass:
+    # Attribute inference does not support Optional, so Uninferable is yielded
+    # This should not trigger any type errors from pylint
+    attr0: Optional[Dummy]
+
+    attr1: int
+    attr2: str
+    attr3: Callable[[int], int]
+    attr4: List[int]
+    attr5: Dict[str, str]
+
+
+obj = MyClass(None, 1, 'hi', lambda x: x, [], {})
+
+lst = [0, 1, 2]
+print(lst[obj.attr0])
+print(lst[obj.attr1])
+print(lst[obj.attr2])  # [invalid-sequence-index]
+
+print(lst[obj.attr0::])
+print(lst[obj.attr1::])
+print(lst[obj.attr2::])  # [invalid-slice-index]
+
+obj.attr0(100)
+obj.attr1(100)  # [not-callable]
+obj.attr3(100)
+
+print(-obj.attr0)
+print(-obj.attr1)
+print(-obj.attr2)  # [invalid-unary-operand-type]
+
+print(1 + obj.attr0)
+print(1 + obj.attr1)
+print(1 + obj.attr2)  # Should be an error here once unsupported-binary-operation is enabled
+
+print(1 in obj.attr0)
+print(1 in obj.attr1)  # [unsupported-membership-test]
+print(1 in obj.attr4)
+print('hi' in obj.attr5)
+
+print(obj.attr0[1])
+print(obj.attr1[1])  # [unsubscriptable-object]
+print(obj.attr4[1])
+print(obj.attr5['hi'])
+
+obj.attr0[1] = 1
+obj.attr1[1] = 1  # [unsupported-assignment-operation]
+obj.attr4[1] = 1
+obj.attr5['hi'] = 'bye'
+
+del obj.attr0[1]
+del obj.attr1[1]  # [unsupported-delete-operation]
+del obj.attr4[1]
+del obj.attr5['hi']
+
+
+class Manager:
+    def __enter__(self):
+        pass
+
+    def __exit__(self, type_, value, traceback):
+        pass
+
+
+@dataclass
+class MyClass2:
+    attr0: Optional[Dummy]
+    attr1: Manager
+    attr2: str
+
+
+obj2 = MyClass2(None, Manager(), 'hi')
+with obj2.attr0:
+    pass
+with obj2.attr1:
+    pass
+with obj2.attr2:  # [not-context-manager]
+    pass
+
+
+class Test1(metaclass=obj.attr0):
+    pass
+
+
+class Test2(metaclass=obj.attr1):  # [invalid-metaclass]
+    pass
+
+
+{}[obj.attr0] = 1
+{}[obj.attr1] = 1
+{}[obj.attr5] = 1  # [unhashable-dict-key]
+
+for k, v in obj.attr5:  # TODO: Should be an dict-iter-missing-items error
+    print(k, v)
+
+__name__ = obj.attr0
+__name__ = obj.attr1  # TODO: Should be a non-str-assignment-to-dunder-name error
+__name__ = obj.attr2
+
+print(isinstance(1, obj.attr0))
+print(isinstance(1, obj.attr1))  # [isinstance-second-argument-not-valid-type]
diff --git a/tests/functional/d/deprecated/dataclass_typecheck.rc b/tests/functional/d/deprecated/dataclass_typecheck.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/d/deprecated/dataclass_typecheck.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/d/deprecated/dataclass_typecheck.txt b/tests/functional/d/deprecated/dataclass_typecheck.txt
new file mode 100644
index 000000000..529f4aab9
--- /dev/null
+++ b/tests/functional/d/deprecated/dataclass_typecheck.txt
@@ -0,0 +1,12 @@
+invalid-sequence-index:32:6::Sequence index is not an int, slice, or instance with __index__:HIGH
+invalid-slice-index:36:0::Slice index is not an int, None, or instance with __index__:HIGH
+not-callable:39:0::obj.attr1 is not callable:HIGH
+invalid-unary-operand-type:44:6::"bad operand type for unary -: str":HIGH
+unsupported-membership-test:51:11::Value 'obj.attr1' doesn't support membership test:HIGH
+unsubscriptable-object:56:6::Value 'obj.attr1' is unsubscriptable:HIGH
+unsupported-assignment-operation:61:0::'obj.attr1' does not support item assignment:HIGH
+unsupported-delete-operation:66:4::'obj.attr1' does not support item deletion:HIGH
+not-context-manager:91:0::Context manager 'str' doesn't implement __enter__ and __exit__.:HIGH
+invalid-metaclass:99:0:Test2:Invalid metaclass 'Instance of builtins.int' used:HIGH
+unhashable-dict-key:105:0::Dict key is unhashable:HIGH
+isinstance-second-argument-not-valid-type:115:6::Second argument of isinstance is not a type:HIGH
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 000000000..470e467ba
--- /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 000000000..4e2b74831
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_class_py33.rc
@@ -0,0 +1,2 @@
+[testoptions]
+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 000000000..9a31c0efb
--- /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 000000000..800ba6171
--- /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.txt b/tests/functional/d/deprecated/deprecated_decorators.txt
new file mode 100644
index 000000000..a696c8bfe
--- /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 000000000..3338c2456
--- /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 000000000..83cd04143
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_method_getmoduleinfo.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.6
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 000000000..77632a157
--- /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 000000000..80428c79f
--- /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 000000000..b56440977
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+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 000000000..9796114f6
--- /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 000000000..f416a144c
--- /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.txt b/tests/functional/d/deprecated/deprecated_methods_py36.txt
new file mode 100644
index 000000000..801d24b6e
--- /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 000000000..35ec88f5a
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py38.py
@@ -0,0 +1,53 @@
+""" 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".+")
+
+
+class Deprecated:  # pylint: disable=too-few-public-methods
+    deprecated_method = logging.warn
+
+
+d = Deprecated()
+d.deprecated_method()  # [deprecated-method]
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 000000000..35b185fdb
--- /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 000000000..788cdd2b6
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_methods_py38.txt
@@ -0,0 +1,14 @@
+deprecated-method:13:8:MyTest.test:Using deprecated method assert_():HIGH
+deprecated-method:15:0::Using deprecated method getchildren():HIGH
+deprecated-method:16:0::Using deprecated method getiterator():HIGH
+deprecated-method:17:0::Using deprecated method xpath():HIGH
+deprecated-method:20:0::Using deprecated method getargspec():HIGH
+deprecated-method:21:0::Using deprecated method warn():HIGH
+deprecated-method:22:0::Using deprecated method encodestring():HIGH
+deprecated-method:23:0::Using deprecated method decodestring():HIGH
+deprecated-method:38:8:Tests.test_foo:Using deprecated method assertEquals():HIGH
+deprecated-method:39:8:Tests.test_foo:Using deprecated method assertNotEquals():HIGH
+deprecated-method:40:8:Tests.test_foo:Using deprecated method assertAlmostEquals():HIGH
+deprecated-method:41:8:Tests.test_foo:Using deprecated method assertNotAlmostEquals():HIGH
+deprecated-method:42:8:Tests.test_foo:Using deprecated method assert_():HIGH
+deprecated-method:53:0::Using deprecated method deprecated_method():HIGH
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 000000000..308d400e7
--- /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 000000000..83cd04143
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_module_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+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 000000000..79c0a418c
--- /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 000000000..c49f9f0bc
--- /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.txt b/tests/functional/d/deprecated/deprecated_module_py36.txt
new file mode 100644
index 000000000..ab5f48996
--- /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 000000000..3cad959e7
--- /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 000000000..6fbd3407e
--- /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 000000000..f4800d0b9
--- /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 000000000..52d55fa84
--- /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 000000000..d68fc0bc9
--- /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 000000000..7d9f01afa
--- /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/deprecated/deprecated_relative_import/__init__.py b/tests/functional/d/deprecated/deprecated_relative_import/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_relative_import/__init__.py
diff --git a/tests/functional/d/deprecated/deprecated_relative_import/dot_relative_import.py b/tests/functional/d/deprecated/deprecated_relative_import/dot_relative_import.py
new file mode 100644
index 000000000..db07f976b
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_relative_import/dot_relative_import.py
@@ -0,0 +1,7 @@
+# pylint: disable=import-error, missing-module-docstring, unused-import
+
+# from import of stdlib optparse which should yield deprecated-module error
+from optparse import OptionParser # [deprecated-module]
+# from import of module internal optparse module inside this package.
+# This should not yield deprecated-module error
+from .optparse import Bar
diff --git a/tests/functional/d/deprecated/deprecated_relative_import/dot_relative_import.txt b/tests/functional/d/deprecated/deprecated_relative_import/dot_relative_import.txt
new file mode 100644
index 000000000..8f1b95f94
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_relative_import/dot_relative_import.txt
@@ -0,0 +1 @@
+deprecated-module:4:0::Uses of a deprecated module 'optparse':HIGH
diff --git a/tests/functional/d/deprecated/deprecated_relative_import/subpackage/__init__.py b/tests/functional/d/deprecated/deprecated_relative_import/subpackage/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_relative_import/subpackage/__init__.py
diff --git a/tests/functional/d/deprecated/deprecated_relative_import/subpackage/dot_dot_relative_import.py b/tests/functional/d/deprecated/deprecated_relative_import/subpackage/dot_dot_relative_import.py
new file mode 100644
index 000000000..359a4c46d
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_relative_import/subpackage/dot_dot_relative_import.py
@@ -0,0 +1,7 @@
+# pylint: disable=import-error, unused-import, missing-module-docstring
+
+# from import of stdlib optparse which should yield deprecated-module error
+from optparse import OptionParser # [deprecated-module]
+# from import of module internal optparse module inside this package.
+# This should not yield deprecated-module error
+from ..optparse import Bar
diff --git a/tests/functional/d/deprecated/deprecated_relative_import/subpackage/dot_dot_relative_import.txt b/tests/functional/d/deprecated/deprecated_relative_import/subpackage/dot_dot_relative_import.txt
new file mode 100644
index 000000000..8f1b95f94
--- /dev/null
+++ b/tests/functional/d/deprecated/deprecated_relative_import/subpackage/dot_dot_relative_import.txt
@@ -0,0 +1 @@
+deprecated-module:4:0::Uses of a deprecated module 'optparse':HIGH
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 000000000..81977b026
--- /dev/null
+++ b/tests/functional/d/dict_iter_missing_items.py
@@ -0,0 +1,26 @@
+# pylint: disable=invalid-name, consider-iterating-dictionary, missing-docstring, import-error
+from unknown import Uninferable
+
+d = {1: 1, 2: 2}
+d_tuple = {(1, 2): 3, (4, 5): 6}
+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
+for a, b in d_tuple:
+    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 000000000..c3eb12f2c
--- /dev/null
+++ b/tests/functional/d/dict_iter_missing_items.txt
@@ -0,0 +1 @@
+dict-iter-missing-items:11: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 000000000..5c7ad1e5d
--- /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_next_line.py b/tests/functional/d/disable_msg_next_line.py
new file mode 100644
index 000000000..f500feb1e
--- /dev/null
+++ b/tests/functional/d/disable_msg_next_line.py
@@ -0,0 +1,20 @@
+"""Test if disable-next only disables messages for the next line"""
+# pylint: disable=missing-function-docstring
+# pylint: disable-next=unused-argument, invalid-name
+def function_A(arg1, arg2):
+    return arg1
+
+
+# pylint: disable-next=unused-argument,invalid-name
+def function_B(arg1, arg2):
+    return arg1
+
+
+# pylint: disable-next=invalid-name, f-string-without-interpolation
+def function_C():
+    x = "string"  # [unused-variable, invalid-name]
+    return f"This should be a normal string"  # [f-string-without-interpolation]
+
+
+def function_D(arg1, arg2):  # [unused-argument, invalid-name]
+    return arg1
diff --git a/tests/functional/d/disable_msg_next_line.txt b/tests/functional/d/disable_msg_next_line.txt
new file mode 100644
index 000000000..bfd0adeae
--- /dev/null
+++ b/tests/functional/d/disable_msg_next_line.txt
@@ -0,0 +1,5 @@
+invalid-name:15:4:function_C:"Variable name ""x"" doesn't conform to snake_case naming style":HIGH
+unused-variable:15:4:function_C:"Unused variable 'x'":HIGH
+f-string-without-interpolation:16:11:function_C:"Using an f-string that does not have any interpolated variables":HIGH
+invalid-name:19:0:function_D:"Function name ""function_D"" doesn't conform to snake_case naming style":HIGH
+unused-argument:19:21:function_D:"Unused argument 'arg2'":HIGH
diff --git a/tests/functional/d/disable_ungrouped_imports.py b/tests/functional/d/disable_ungrouped_imports.py
new file mode 100644
index 000000000..48c06c01c
--- /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 000000000..a5a0e02a2
--- /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 000000000..1fdf83fb1
--- /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 000000000..d0fcafbc4
--- /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 000000000..0703325a9
--- /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 000000000..91cb155e1
--- /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', encoding="utf-8")
+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 000000000..6a584cb99
--- /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 000000000..e9d137a7f
--- /dev/null
+++ b/tests/functional/d/docstrings.py
@@ -0,0 +1,90 @@
+# pylint: disable=no-self-use, useless-object-inheritance, unnecessary-pass, consider-using-f-string

+# -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 000000000..e8bb2f3de
--- /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 000000000..89826179a
--- /dev/null
+++ b/tests/functional/d/dotted_ancestor.py
@@ -0,0 +1,10 @@
+"""bla"""
+
+
+from ..n.non import non_init_parent_called
+
+
+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 000000000..20f9dbee8
--- /dev/null
+++ b/tests/functional/d/dotted_ancestor.txt
@@ -0,0 +1 @@
+too-few-public-methods:7:0:Aaaa:Too few public methods (0/2):HIGH
diff --git a/tests/functional/d/duplicate_argument_name.py b/tests/functional/d/duplicate_argument_name.py
new file mode 100644
index 000000000..c60b11784
--- /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 000000000..a8321d9ce
--- /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 000000000..c7fbe3478
--- /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.txt b/tests/functional/d/duplicate_argument_name_py3.txt
new file mode 100644
index 000000000..6942faaae
--- /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 000000000..51b329a4f
--- /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 000000000..651086fd9
--- /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 000000000..6d359ff0a
--- /dev/null
+++ b/tests/functional/d/duplicate_dict_literal_key.py
@@ -0,0 +1,17 @@
+"""Check multiple key definition"""
+# pylint: disable=pointless-statement, redundant-u-string-prefix
+
+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 000000000..756f15818
--- /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 000000000..c68cf7a24
--- /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 000000000..cf8df9e3f
--- /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 000000000..572f20eca
--- /dev/null
+++ b/tests/functional/d/duplicate_string_formatting_argument.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring, consider-using-f-string
+
+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 000000000..fdc438624
--- /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 000000000..e69de29bb
--- /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 000000000..7306840cb
--- /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 000000000..c8493da78
--- /dev/null
+++ b/tests/functional/e/enum_subclasses.py
@@ -0,0 +1,79 @@
+# pylint: disable=missing-docstring, invalid-name
+from enum import Enum, IntEnum, auto
+
+
+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()
+
+
+class OrderedEnum(Enum):
+    def __ge__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value >= other.value  # line 11
+        return NotImplemented
+
+    def __gt__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value > other.value  # line 16
+        return NotImplemented
+
+
+class Color(OrderedEnum):
+    red = 0
+    green = 1
+
+
+class People(Enum):
+    jack = 0
+    john = 1
+
+
+print(Color.red.value)  # line 29
+print(People.jack.name)
+
+
+class BaseEnum(Enum):
+    def some_behavior(self):
+        pass
+
+
+class MyEnum(BaseEnum):
+
+    FOO = 1
+    BAR = 2
+
+
+print(MyEnum.FOO.value)
+
+class TestBase(Enum):
+    """Adds a special method to enums."""
+
+    def hello_pylint(self) -> str:
+        """False positive."""
+        return self.name
+
+
+class TestEnum(TestBase):
+    """Tests the false positive for enums."""
+
+    a = auto()
+    b = auto()
+
+
+test_enum = TestEnum.a
+assert test_enum.hello_pylint() == test_enum.name
diff --git a/tests/functional/e/eval_used.py b/tests/functional/e/eval_used.py
new file mode 100644
index 000000000..d03dad7ca
--- /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 000000000..f8cdc5f53
--- /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 000000000..f71163d1f
--- /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 000000000..1395c67a1
--- /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 000000000..19fd5cb4d
--- /dev/null
+++ b/tests/functional/e/excess_escapes.py
@@ -0,0 +1,33 @@
+# pylint:disable=pointless-string-statement, fixme, misplaced-comparison-constant, comparison-with-itself
+"""Stray backslash escapes may be missing a raw-string prefix."""
+# pylint: disable=redundant-u-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 000000000..4082e4709
--- /dev/null
+++ b/tests/functional/e/excess_escapes.txt
@@ -0,0 +1,9 @@
+anomalous-backslash-in-string:8:5::"Anomalous backslash in string: '\['. String constant might be missing an r prefix."
+anomalous-backslash-in-string:8:7::"Anomalous backslash in string: '\]'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:9:8::"Anomalous backslash in string: '\/'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:10:20::"Anomalous backslash in string: '\`'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:17:15::"Anomalous backslash in string: '\o'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:17:20::"Anomalous backslash in string: '\o'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:19:13::"Anomalous backslash in string: '\8'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:19:17::"Anomalous backslash in string: '\9'. String constant might be missing an r prefix."
+anomalous-backslash-in-string:32:42::"Anomalous backslash in string: '\P'. String constant might be missing an r prefix."
diff --git a/tests/functional/e/exec_used.py b/tests/functional/e/exec_used.py
new file mode 100644
index 000000000..5f849480e
--- /dev/null
+++ b/tests/functional/e/exec_used.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.txt b/tests/functional/e/exec_used.txt
new file mode 100644
index 000000000..ebfab1c09
--- /dev/null
+++ b/tests/functional/e/exec_used.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 000000000..7f6b927af
--- /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 000000000..9737e0ffc
--- /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 000000000..e32b9f32c
--- /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 000000000..093b1d1e5
--- /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_assignment_expr.py b/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.py
new file mode 100644
index 000000000..60d3f4d1b
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.py
@@ -0,0 +1,159 @@
+# pylint: disable=missing-docstring,invalid-name,undefined-variable,too-few-public-methods
+
+a1 = 2
+if a1:  # [consider-using-assignment-expr]
+    ...
+
+# Do not suggest assignement expressions if assignment spans multiple lines
+a2 = (
+    1,
+)
+if a2:
+    ...
+
+# Only first name should be replaced
+a3 = 2
+if a3 == a3_a:  # [consider-using-assignment-expr]
+    ...
+
+# Above black line length
+a4 = some_loooooooonnnnnngggg_object_name.with_some_really_long_function_name(arg)
+if a4:
+    ...
+
+def func_a():
+    a5 = some___object.function_name_is_just_long_enough_to_fit_in_line()  # some comment
+    if a5 is None:  # [consider-using-assignment-expr]
+        ...
+
+    # Using assignment expression would result in line being 89 chars long
+    a6 = some_long_object.function_name_is_too_long_enough_to_fit___line()
+    if a6 is None:
+        ...
+
+# Previous unrelate note should not match
+print("")
+if a7:
+    ...
+
+
+b1: int = 2
+if b1:  # [consider-using-assignment-expr]
+    ...
+
+b2 = some_function(2, 3)
+if b2:  # [consider-using-assignment-expr]
+    ...
+
+b3 = some_object.variable
+if b3:  # [consider-using-assignment-expr]
+    ...
+
+
+# UnaryOp
+c1 = 2
+if not c1:  # [consider-using-assignment-expr]
+    ...
+
+
+# Compare
+d1 = 2
+if d1 is True:  # [consider-using-assignment-expr]
+    ...
+
+d2 = 2
+if d2 is not None:  # [consider-using-assignment-expr]
+    ...
+
+d3 = 2
+if d3 == 2:  # [consider-using-assignment-expr]
+    ...
+
+
+# -----
+# Don't emit warning if match statement would be a better fit
+o1 = 2
+if o1 == 1:
+    ...
+elif o1 == 2:
+    ...
+elif o1 == 3:
+    ...
+
+o2 = 2
+if o2 == 1:
+    ...
+elif o2:
+    ...
+
+o3 = 2
+if o3 == 1:  # [consider-using-assignment-expr]
+    ...
+else:
+    ...
+
+o4 = 2
+if o4 == 1:  # [consider-using-assignment-expr]
+    ...
+elif o4 and o4_other:
+    ...
+
+o5 = 2
+if o5 == 1:  # [consider-using-assignment-expr]
+    ...
+elif o5_other == 1:
+    ...
+
+o6 = 2
+if o6 == 1:  # [consider-using-assignment-expr]
+    ...
+elif o6_other:
+    ...
+
+def func_p():
+    p1 = 2
+    if p1 == 1:
+        return
+    if p1 == 2:
+        return
+
+    p2 = 2
+    if p2 == 1:
+        return
+    if p2:
+        return
+
+    p3 = 2
+    if p3 == 1:  # [consider-using-assignment-expr]
+        ...
+    else:
+        ...
+
+    p4 = 2
+    if p4 == 1:  # [consider-using-assignment-expr]
+        ...
+    elif p4 and p4_other:
+        ...
+
+    p5 = 2
+    if p5 == 1:  # [consider-using-assignment-expr]
+        ...
+    elif p5_other == 1:
+        ...
+
+    p6 = 2
+    if p6 == 1:  # [consider-using-assignment-expr]
+        ...
+    elif p6_other:
+        ...
+
+
+# -----
+# Assignment expression does NOT work for attribute access
+# Make sure not to emit message!
+class A:
+    var = 1
+
+A.var = 2
+if A.var:
+    ...
diff --git a/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.rc b/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.rc
new file mode 100644
index 000000000..2a659c07d
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.rc
@@ -0,0 +1,6 @@
+[MASTER]
+load-plugins=pylint.extensions.code_style
+py-version=3.8
+
+[CODE_STYLE]
+max-line-length-suggestions=88
diff --git a/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.txt b/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.txt
new file mode 100644
index 000000000..64179ba72
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_assignment_expr.txt
@@ -0,0 +1,18 @@
+consider-using-assignment-expr:4:3::"Use 'if (a1 := 2):' instead":HIGH
+consider-using-assignment-expr:16:3::"Use 'if (a3 := 2) == a3_a:' instead":HIGH
+consider-using-assignment-expr:26:7:func_a:"Use 'if (a5 := some___object.function_name_is_just_long_enough_to_fit_in_line()) is None:' instead":HIGH
+consider-using-assignment-expr:41:3::"Use 'if (b1 := 2):' instead":HIGH
+consider-using-assignment-expr:45:3::"Use 'if (b2 := some_function(2, 3)):' instead":HIGH
+consider-using-assignment-expr:49:3::"Use 'if (b3 := some_object.variable):' instead":HIGH
+consider-using-assignment-expr:55:7::"Use 'if not (c1 := 2):' instead":HIGH
+consider-using-assignment-expr:61:3::"Use 'if (d1 := 2) is True:' instead":HIGH
+consider-using-assignment-expr:65:3::"Use 'if (d2 := 2) is not None:' instead":HIGH
+consider-using-assignment-expr:69:3::"Use 'if (d3 := 2) == 2:' instead":HIGH
+consider-using-assignment-expr:90:3::"Use 'if (o3 := 2) == 1:' instead":HIGH
+consider-using-assignment-expr:96:3::"Use 'if (o4 := 2) == 1:' instead":HIGH
+consider-using-assignment-expr:102:3::"Use 'if (o5 := 2) == 1:' instead":HIGH
+consider-using-assignment-expr:108:3::"Use 'if (o6 := 2) == 1:' instead":HIGH
+consider-using-assignment-expr:127:7:func_p:"Use 'if (p3 := 2) == 1:' instead":HIGH
+consider-using-assignment-expr:133:7:func_p:"Use 'if (p4 := 2) == 1:' instead":HIGH
+consider-using-assignment-expr:139:7:func_p:"Use 'if (p5 := 2) == 1:' instead":HIGH
+consider-using-assignment-expr:145:7:func_p:"Use 'if (p6 := 2) == 1:' instead":HIGH
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 000000000..627de7684
--- /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 000000000..47767a206
--- /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 000000000..6c471db96
--- /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 000000000..d24396079
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_tuple.py
@@ -0,0 +1,31 @@
+# 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 var]
+[x for x in (1, 2, 3)]
+[x for x in [1, 2, 3]]  # [consider-using-tuple]
+
+
+for x in [*var]:  # [consider-using-tuple]
+    pass
+for x in [2, *var]:  # [consider-using-tuple]
+    pass
+
+[x for x in [*var, 2]]  # [consider-using-tuple]
+
+
+# Don't emit warning for sets as this is handled by builtin checker
+(x for x in {1, 2, 3})  # [use-sequence-for-iteration]
+[x for x in {*var, 2}]  # [use-sequence-for-iteration]
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 000000000..47767a206
--- /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 000000000..167c8c037
--- /dev/null
+++ b/tests/functional/ext/code_style/code_style_consider_using_tuple.txt
@@ -0,0 +1,8 @@
+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:18:12::Consider using an in-place tuple instead of list
+consider-using-tuple:21:9::Consider using an in-place tuple instead of list
+consider-using-tuple:23:9::Consider using an in-place tuple instead of list
+consider-using-tuple:26:12::Consider using an in-place tuple instead of list
+use-sequence-for-iteration:30:12::Use a sequence type when iterating over values
+use-sequence-for-iteration:31:12::Use a sequence type when iterating over values
diff --git a/tests/functional/ext/confusing_elif.py b/tests/functional/ext/confusing_elif.py
new file mode 100644
index 000000000..9f1d1ffe9
--- /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 000000000..6a11b2c09
--- /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 000000000..55cc0d13f
--- /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/consider_ternary_expression.py b/tests/functional/ext/consider_ternary_expression.py
new file mode 100644
index 000000000..5ed5eaac4
--- /dev/null
+++ b/tests/functional/ext/consider_ternary_expression.py
@@ -0,0 +1,17 @@
+if f():  # [consider-ternary-expression]
+    x = 4
+else:
+    x = 5
+
+if g():
+    y = 3
+elif h():
+    y = 4
+else:
+    y = 5
+
+def a():
+    if i():  # [consider-ternary-expression]
+        z = 4
+    else:
+        z = 5
diff --git a/tests/functional/ext/consider_ternary_expression.rc b/tests/functional/ext/consider_ternary_expression.rc
new file mode 100644
index 000000000..39b1d7975
--- /dev/null
+++ b/tests/functional/ext/consider_ternary_expression.rc
@@ -0,0 +1,10 @@
+[MASTER]
+load-plugins=pylint.extensions.consider_ternary_expression,
+
+[MESSAGES CONTROL]
+disable=
+  invalid-name,
+  undefined-variable,
+  unused-variable,
+  missing-function-docstring,
+  missing-module-docstring,
diff --git a/tests/functional/ext/consider_ternary_expression.txt b/tests/functional/ext/consider_ternary_expression.txt
new file mode 100644
index 000000000..08e51e61d
--- /dev/null
+++ b/tests/functional/ext/consider_ternary_expression.txt
@@ -0,0 +1,2 @@
+consider-ternary-expression:1:0::Consider rewriting as a ternary expression
+consider-ternary-expression:14:4:a:Consider rewriting as a ternary expression
diff --git a/tests/functional/ext/docparams.py b/tests/functional/ext/docparams.py
new file mode 100644
index 000000000..269686a01
--- /dev/null
+++ b/tests/functional/ext/docparams.py
@@ -0,0 +1,41 @@
+"""Fixture for testing missing documentation in docparams."""
+
+
+def _private_func1(param1):  # [missing-return-doc, missing-return-type-doc]
+    """This is a test docstring without returns"""
+    return param1
+
+
+def _private_func2(param1):  # [missing-yield-doc, missing-yield-type-doc]
+    """This is a test docstring without yields"""
+    yield param1
+
+
+def _private_func3(param1):  # [missing-raises-doc]
+    """This is a test docstring without raises"""
+    raise Exception('Example')
+
+
+def public_func1(param1):  # [missing-param-doc, missing-type-doc]
+    """This is a test docstring without params"""
+    print(param1)
+
+
+async def _async_private_func1(param1):  # [missing-return-doc, missing-return-type-doc]
+    """This is a test docstring without returns"""
+    return param1
+
+
+async def _async_private_func2(param1):  # [missing-yield-doc, missing-yield-type-doc]
+    """This is a test docstring without yields"""
+    yield param1
+
+
+async def _async_private_func3(param1):  # [missing-raises-doc]
+    """This is a test docstring without raises"""
+    raise Exception('Example')
+
+
+async def async_public_func1(param1):  # [missing-param-doc, missing-type-doc]
+    """This is a test docstring without params"""
+    print(param1)
diff --git a/tests/functional/ext/docparams.rc b/tests/functional/ext/docparams.rc
new file mode 100644
index 000000000..eda78b640
--- /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 000000000..cccc78126
--- /dev/null
+++ b/tests/functional/ext/docparams.txt
@@ -0,0 +1,14 @@
+missing-return-doc:4:0:_private_func1:Missing return documentation
+missing-return-type-doc:4:0:_private_func1:Missing return type documentation
+missing-yield-doc:9:0:_private_func2:Missing yield documentation
+missing-yield-type-doc:9:0:_private_func2:Missing yield type documentation
+missing-raises-doc:14:0:_private_func3:"""Exception""" not documented as being raised
+missing-param-doc:19:0:public_func1:"""param1""" missing in parameter documentation
+missing-type-doc:19:0:public_func1:"""param1""" missing in parameter type documentation
+missing-return-doc:24:0:_async_private_func1:Missing return documentation
+missing-return-type-doc:24:0:_async_private_func1:Missing return type documentation
+missing-yield-doc:29:0:_async_private_func2:Missing yield documentation
+missing-yield-type-doc:29:0:_async_private_func2:Missing yield type documentation
+missing-raises-doc:34:0:_async_private_func3:"""Exception""" not documented as being raised
+missing-param-doc:39:0:async_public_func1:"""param1""" missing in parameter documentation
+missing-type-doc:39:0:async_public_func1:"""param1""" missing in parameter type documentation
diff --git a/tests/functional/ext/set_membership/set_membership_use_set_membership.py b/tests/functional/ext/set_membership/set_membership_use_set_membership.py
new file mode 100644
index 000000000..50e07f4dd
--- /dev/null
+++ b/tests/functional/ext/set_membership/set_membership_use_set_membership.py
@@ -0,0 +1,40 @@
+# pylint: disable=invalid-name,missing-docstring,pointless-statement,unnecessary-comprehension,undefined-variable
+
+x = 1
+var = frozenset({1, 2, 3})
+
+x in var
+x in {1, 2, 3}
+x in (1, 2, 3)  # [use-set-for-membership]
+x in [1, 2, 3]  # [use-set-for-membership]
+
+if x in var:
+    pass
+if x in {1, 2, 3}:
+    pass
+if x in (1, 2, 3):  # [use-set-for-membership]
+    pass
+if x in [1, 2, 3]:  # [use-set-for-membership]
+    pass
+
+42 if x in [1, 2, 3] else None  # [use-set-for-membership]
+assert x in [1, 2, 3]  # [use-set-for-membership]
+(x for x in var if x in [1, 2, 3])  # [use-set-for-membership]
+while x in [1, 2, 3]:  # [use-set-for-membership]
+    break
+
+# Stacked operators, rightmost pair is evaluated first
+# Doesn't make much sense in practice since `in` will only return `bool`
+True == x in [1, 2, 3]  # [use-set-for-membership]  # noqa: E712
+1 >= x in [1, 2, 3]  # [use-set-for-membership]  # noqa: E712
+
+
+# Test hashable heuristic
+x in (1, "Hello World", False, None)  # [use-set-for-membership]
+x in (1, [])  # List is not hashable
+
+if some_var:
+    var2 = 2
+else:
+    var2 = []
+x in (1, var2)  # var2 can be a list
diff --git a/tests/functional/ext/set_membership/set_membership_use_set_membership.rc b/tests/functional/ext/set_membership/set_membership_use_set_membership.rc
new file mode 100644
index 000000000..688dcbc31
--- /dev/null
+++ b/tests/functional/ext/set_membership/set_membership_use_set_membership.rc
@@ -0,0 +1,2 @@
+[MASTER]
+load-plugins=pylint.extensions.set_membership
diff --git a/tests/functional/ext/set_membership/set_membership_use_set_membership.txt b/tests/functional/ext/set_membership/set_membership_use_set_membership.txt
new file mode 100644
index 000000000..b2adb9ecd
--- /dev/null
+++ b/tests/functional/ext/set_membership/set_membership_use_set_membership.txt
@@ -0,0 +1,11 @@
+use-set-for-membership:8:5::Consider using set for membership test:HIGH
+use-set-for-membership:9:5::Consider using set for membership test:HIGH
+use-set-for-membership:15:8::Consider using set for membership test:HIGH
+use-set-for-membership:17:8::Consider using set for membership test:HIGH
+use-set-for-membership:20:11::Consider using set for membership test:HIGH
+use-set-for-membership:21:12::Consider using set for membership test:HIGH
+use-set-for-membership:22:24::Consider using set for membership test:HIGH
+use-set-for-membership:23:11::Consider using set for membership test:HIGH
+use-set-for-membership:28:13::Consider using set for membership test:HIGH
+use-set-for-membership:29:10::Consider using set for membership test:HIGH
+use-set-for-membership:33:5::Consider using set for membership test:HIGH
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 000000000..7549dd2e4
--- /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 000000000..e1f43ca61
--- /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 000000000..2ae1378f7
--- /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 000000000..44f55b8b4
--- /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 000000000..e1f43ca61
--- /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 000000000..c7105b965
--- /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 000000000..2f27b40da
--- /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 000000000..e1f43ca61
--- /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 000000000..330a7165f
--- /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 000000000..1018c3670
--- /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 000000000..7400f16d6
--- /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 000000000..4402eb218
--- /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 000000000..f459d047b
--- /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 000000000..e1f43ca61
--- /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 000000000..c43cbc3ce
--- /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 000000000..3cd139cdb
--- /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 000000000..2d21d503c
--- /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 000000000..fa74fc161
--- /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/ext/while_used.py b/tests/functional/ext/while_used.py
new file mode 100644
index 000000000..848da0d51
--- /dev/null
+++ b/tests/functional/ext/while_used.py
@@ -0,0 +1,10 @@
+"""Functional test"""
+
+while True:  # [while-used]
+    print("asdf")
+
+def fff():
+    "zxcv"
+    i = 0
+    while i < 10:  # [while-used]
+        i += 1
diff --git a/tests/functional/ext/while_used.rc b/tests/functional/ext/while_used.rc
new file mode 100644
index 000000000..28e1b1faf
--- /dev/null
+++ b/tests/functional/ext/while_used.rc
@@ -0,0 +1,2 @@
+[MASTER]
+load-plugins=pylint.extensions.while_used,
diff --git a/tests/functional/ext/while_used.txt b/tests/functional/ext/while_used.txt
new file mode 100644
index 000000000..80ca84d56
--- /dev/null
+++ b/tests/functional/ext/while_used.txt
@@ -0,0 +1,2 @@
+while-used:3:0::Used `while` loop
+while-used:9:4:fff:Used `while` loop
diff --git a/tests/functional/f/__init__.py b/tests/functional/f/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..4d6e36634
--- /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.txt b/tests/functional/f/f_string_without_interpolation.txt
new file mode 100644
index 000000000..38df260d1
--- /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 000000000..321eb1158
--- /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 000000000..9420830ff
--- /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 000000000..fb6f1629a
--- /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 000000000..b5ef59695
--- /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 000000000..0b5c0804b
--- /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 000000000..8344fa8dd
--- /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 000000000..081d508f4
--- /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 000000000..6b903c1bd
--- /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 000000000..198e08a4b
--- /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 000000000..33030ed4c
--- /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 000000000..554bb3013
--- /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 000000000..4da0264f2
--- /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/forgotten_debug_statement_py37.py b/tests/functional/f/forgotten_debug_statement_py37.py
new file mode 100644
index 000000000..ebe0a7a44
--- /dev/null
+++ b/tests/functional/f/forgotten_debug_statement_py37.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-docstring
+
+import pdb
+import sys
+
+breakpoint()  # [forgotten-debug-statement]
+sys.breakpointhook()  # [forgotten-debug-statement]
+pdb.set_trace()  # [forgotten-debug-statement]
+b = breakpoint
+b()  # [forgotten-debug-statement]
diff --git a/tests/functional/f/forgotten_debug_statement_py37.rc b/tests/functional/f/forgotten_debug_statement_py37.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/f/forgotten_debug_statement_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/f/forgotten_debug_statement_py37.txt b/tests/functional/f/forgotten_debug_statement_py37.txt
new file mode 100644
index 000000000..40e8914a6
--- /dev/null
+++ b/tests/functional/f/forgotten_debug_statement_py37.txt
@@ -0,0 +1,4 @@
+forgotten-debug-statement:6:0::"Leaving functions creating breakpoints in production code is not recommended"
+forgotten-debug-statement:7:0::"Leaving functions creating breakpoints in production code is not recommended"
+forgotten-debug-statement:8:0::"Leaving functions creating breakpoints in production code is not recommended"
+forgotten-debug-statement:10:0::"Leaving functions creating breakpoints in production code is not recommended"
diff --git a/tests/functional/f/formatted_string_literal_with_if.py b/tests/functional/f/formatted_string_literal_with_if.py
new file mode 100644
index 000000000..8feb4e293
--- /dev/null
+++ b/tests/functional/f/formatted_string_literal_with_if.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/func_disable_linebased.py b/tests/functional/f/func_disable_linebased.py
new file mode 100644
index 000000000..bb4ad232c
--- /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 000000000..6c6455695
--- /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 000000000..a70ccf9c4
--- /dev/null
+++ b/tests/functional/f/function_redefined.py
@@ -0,0 +1,128 @@
+# 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
+
+from typing import Callable
+
+__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()
+
+do_something: Callable[[], int]
+
+def do_something() -> int:
+    return 1
diff --git a/tests/functional/f/function_redefined.txt b/tests/functional/f/function_redefined.txt
new file mode 100644
index 000000000..dcf04c3b9
--- /dev/null
+++ b/tests/functional/f/function_redefined.txt
@@ -0,0 +1,7 @@
+function-redefined:18:4:AAAA.method2:method already defined line 15:HIGH
+function-redefined:21:0:AAAA:class already defined line 8:HIGH
+function-redefined:35:0:func2:function already defined line 32:HIGH
+redefined-outer-name:37:4:func2:Redefining name '__revision__' from outer scope (line 7):HIGH
+function-redefined:54:4:exclusive_func2:function already defined line 48:HIGH
+function-redefined:89:0:ceil:function already defined line 88:HIGH
+function-redefined:93:0:math:function already defined line 92:HIGH
diff --git a/tests/functional/f/function_redefined_2540.py b/tests/functional/f/function_redefined_2540.py
new file mode 100644
index 000000000..25792295e
--- /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 000000000..a17bb22da
--- /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 000000000..e4d3785a1
--- /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 000000000..30c2bd6b3
--- /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 000000000..58b5a9413
--- /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 000000000..3956b69f9
--- /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 000000000..e69de29bb
--- /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 000000000..2b3a2b07d
--- /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 nodes
+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]
+nodes.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 000000000..5f8f9cd0f
--- /dev/null
+++ b/tests/functional/g/generated_members.rc
@@ -0,0 +1,11 @@
+[Messages Control]
+disable=too-few-public-methods
+
+[typecheck]
+generated-members=
+    \Afunctional\.g\.generated_members\.Klass\.ham\Z,
+    DoesNotExist,
+    "[a-zA-Z]+_set{1,2}",
+    nodes.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 000000000..28e793c32
--- /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 000000000..e69de29bb
--- /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 000000000..33f6b6e2c
--- /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 000000000..16b75eea7
--- /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 000000000..d9ce1f443
--- /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 000000000..eaa153ced
--- /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 000000000..59df8e3c3
--- /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 000000000..6108073e6
--- /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 000000000..5319f13b6
--- /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 000000000..59df8e3c3
--- /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 000000000..ad7bc4a1b
--- /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 000000000..cb7a4d0f4
--- /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 000000000..59df8e3c3
--- /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 000000000..14d784ea0
--- /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 000000000..9c6e63e66
--- /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 000000000..16b75eea7
--- /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 000000000..2247c127f
--- /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 000000000..5ded73b3d
--- /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 000000000..59df8e3c3
--- /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 000000000..5bfcb4845
--- /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 000000000..20b074bae
--- /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 000000000..a17bb22da
--- /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 000000000..b10f66f30
--- /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 000000000..14445a043
--- /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 000000000..16b75eea7
--- /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 000000000..be51879d6
--- /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 000000000..ea7d7a9ce
--- /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,use-list-literal,use-dict-literal
+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 000000000..85fc502b3
--- /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 000000000..bbd64c12a
--- /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 000000000..2ce05deaf
--- /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 000000000..a17bb22da
--- /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 000000000..8942ca71a
--- /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 000000000..056963813
--- /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 000000000..a00d72d32
--- /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 000000000..4567d7fc9
--- /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 000000000..6440e62fc
--- /dev/null
+++ b/tests/functional/g/globals.py
@@ -0,0 +1,67 @@
+"""Warnings about global statements and usage of global variables."""
+# pylint: disable=invalid-name, redefined-outer-name, missing-function-docstring
+from __future__ import print_function
+
+global CSTE  # [global-at-module-level]
+print(CSTE)  # [undefined-variable]
+
+CONSTANT = 1
+def FUNC():
+    pass
+
+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
+
+
+def global_with_import():
+    """should only warn for global-statement"""
+    global sys  # [global-statement]
+    import sys  # pylint: disable=import-outside-toplevel
+
+
+def global_no_assign():
+    """Not assigning anything to the global makes 'global' superfluous"""
+    global CONSTANT  # [global-variable-not-assigned]
+    print(CONSTANT)
+
+
+def global_operator_assign():
+    """Operator assigns should only throw a global statement error"""
+    global CONSTANT  # [global-statement]
+    print(CONSTANT)
+    CONSTANT += 1
+
+
+def global_function_assign():
+    """Function assigns should only throw a global statement error"""
+    global CONSTANT  # [global-statement]
+
+    def CONSTANT():
+        pass
+
+    CONSTANT()
+
+
+def override_func():
+    """Overriding a function should only throw a global statement error"""
+    global FUNC # [global-statement]
+
+    def FUNC():
+        pass
+
+    FUNC()
diff --git a/tests/functional/g/globals.txt b/tests/functional/g/globals.txt
new file mode 100644
index 000000000..1f07e0e75
--- /dev/null
+++ b/tests/functional/g/globals.txt
@@ -0,0 +1,11 @@
+global-at-module-level:5:0::Using the global statement at the module level:HIGH
+undefined-variable:6:6::Undefined variable 'CSTE':HIGH
+global-statement:14:4:fix_contant:Using the global statement:HIGH
+global-variable-not-assigned:21:4:other:Using global for 'HOP' but no assignment is done:HIGH
+undefined-variable:22:10:other:Undefined variable 'HOP':HIGH
+global-variable-undefined:27:4:define_constant:Global variable 'SOMEVAR' undefined at the module level:HIGH
+global-statement:33:4:global_with_import:Using the global statement:HIGH
+global-variable-not-assigned:39:4:global_no_assign:Using global for 'CONSTANT' but no assignment is done:HIGH
+global-statement:45:4:global_operator_assign:Using the global statement:HIGH
+global-statement:52:4:global_function_assign:Using the global statement:HIGH
+global-statement:62:4:override_func:Using the global statement:HIGH
diff --git a/tests/functional/i/__init__.py b/tests/functional/i/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..1ad9aed8c
--- /dev/null
+++ b/tests/functional/i/implicit/implicit_str_concat.py
@@ -0,0 +1,31 @@
+#pylint: disable=invalid-name,missing-docstring,redundant-u-string-prefix
+
+# 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 000000000..11cecd777
--- /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 000000000..cf8c3e6ab
--- /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 000000000..337ac8035
--- /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 000000000..e5b344774
--- /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 000000000..c796269e4
--- /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 000000000..7cd661860
--- /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 000000000..3926534f1
--- /dev/null
+++ b/tests/functional/i/import_aliasing.py
@@ -0,0 +1,26 @@
+# pylint: disable=unused-import, missing-docstring, invalid-name, reimported, import-error, wrong-import-order, no-name-in-module
+# 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
+from ............a import b  # [relative-beyond-top-level]
diff --git a/tests/functional/i/import_aliasing.txt b/tests/functional/i/import_aliasing.txt
new file mode 100644
index 000000000..6b5e7d360
--- /dev/null
+++ b/tests/functional/i/import_aliasing.txt
@@ -0,0 +1,10 @@
+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
+relative-beyond-top-level:26:0::Attempted relative import beyond top-level package
diff --git a/tests/functional/i/import_error.py b/tests/functional/i/import_error.py
new file mode 100644
index 000000000..21c06d1e3
--- /dev/null
+++ b/tests/functional/i/import_error.py
@@ -0,0 +1,59 @@
+""" Test that import errors are detected. """
+# pylint: disable=invalid-name, unused-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
+
+
+from functional.s.syntax_error import toto  # [no-name-in-module,syntax-error]
+
+
+# Don't emit `import-error` or `no-name-in-module`
+# if guarded behind `sys.version_info` or `typing.TYPE_CHECKING`
+import sys
+import typing
+import typing as tp  # pylint: disable=reimported
+from typing import TYPE_CHECKING
+
+
+if sys.version_info >= (3, 9):
+    import some_module
+    from some_module import some_class
+else:
+    import some_module_alt
+
+if sys.version_info[:2] >= (3, 9):
+    import some_module
+else:
+    import some_module_alt
+
+
+if typing.TYPE_CHECKING:
+    import stub_import
+
+if tp.TYPE_CHECKING:
+    import stub_import
+
+if TYPE_CHECKING:
+    import stub_import
+    from stub_import import stub_class
diff --git a/tests/functional/i/import_error.rc b/tests/functional/i/import_error.rc
new file mode 100644
index 000000000..2901db32d
--- /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 000000000..4cc479698
--- /dev/null
+++ b/tests/functional/i/import_error.txt
@@ -0,0 +1,4 @@
+import-error:3:0::Unable to import 'totally_missing'
+import-error:16:4::Unable to import 'maybe_missing_2'
+no-name-in-module:28:0::No name 'syntax_error' in module 'functional.s'
+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 000000000..1f4928f3e
--- /dev/null
+++ b/tests/functional/i/import_itself.py
@@ -0,0 +1,10 @@
+"""test module importing itself"""
+# pylint: disable=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 000000000..4dd361096
--- /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/import_outside_toplevel.py b/tests/functional/i/import_outside_toplevel.py
new file mode 100644
index 000000000..3721db613
--- /dev/null
+++ b/tests/functional/i/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/i/import_outside_toplevel.txt b/tests/functional/i/import_outside_toplevel.txt
new file mode 100644
index 000000000..d4b1786ea
--- /dev/null
+++ b/tests/functional/i/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/i/inconsistent/inconsistent_mro.py b/tests/functional/i/inconsistent/inconsistent_mro.py
new file mode 100644
index 000000000..0b65068d7
--- /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 000000000..a0708be85
--- /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 000000000..76553f98b
--- /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 000000000..9935ff9b7
--- /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 000000000..042fe85c2
--- /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 000000000..d9b157e34
--- /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 000000000..9935ff9b7
--- /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 000000000..0f2f77bf8
--- /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 000000000..08dde253e
--- /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 000000000..dd6cbb598
--- /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 000000000..d0a6dd133
--- /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 000000000..768d6e658
--- /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 000000000..bf9569ba2
--- /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 000000000..9b23552d1
--- /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/inference_crash_4692.py b/tests/functional/i/inference_crash_4692.py
new file mode 100644
index 000000000..5e990aaa7
--- /dev/null
+++ b/tests/functional/i/inference_crash_4692.py
@@ -0,0 +1,9 @@
+"""Regression test for https://github.com/PyCQA/pylint/issues/4692."""
+
+# We can't use click like in the issue because the crash
+# does not appear if click is installed (astroid can analyse it)
+import notclick  # [import-error]
+
+
+for name, item in notclick.__dict__.items():
+    _ = isinstance(item, notclick.Command) and item != 'foo'
diff --git a/tests/functional/i/inference_crash_4692.txt b/tests/functional/i/inference_crash_4692.txt
new file mode 100644
index 000000000..31a55d55f
--- /dev/null
+++ b/tests/functional/i/inference_crash_4692.txt
@@ -0,0 +1 @@
+import-error:5:0::Unable to import 'notclick':HIGH
diff --git a/tests/functional/i/inherit_non_class.py b/tests/functional/i/inherit_non_class.py
new file mode 100644
index 000000000..bbee6bd9a
--- /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

+

+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 000000000..9252c2fbf
--- /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 000000000..17f96db30
--- /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 000000000..b341a07a8
--- /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 000000000..8f646eb26
--- /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 000000000..332f1db67
--- /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 000000000..065a1ad70
--- /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.py b/tests/functional/i/init_subclass_classmethod.py
new file mode 100644
index 000000000..ad379705d
--- /dev/null
+++ b/tests/functional/i/init_subclass_classmethod.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/inner_classes.py b/tests/functional/i/inner_classes.py
new file mode 100644
index 000000000..7ce8101f0
--- /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 000000000..0e68ed263
--- /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 000000000..9af5b182c
--- /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 000000000..703fea278
--- /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 000000000..63440cbbc
--- /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 000000000..3c1a8882b
--- /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 000000000..cec352b61
--- /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 000000000..c0298a06e
--- /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, use-list-literal
+# pylint: disable=too-many-ancestors,  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 000000000..6a8ee96ca
--- /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 000000000..4beed611c
--- /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 000000000..475326545
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_exceptions_raised.py
@@ -0,0 +1,110 @@
+# 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
+
+
+def bad_case10():
+    """raise string"""
+    raise "string"  # [raising-bad-type]
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 000000000..c857eab77
--- /dev/null
+++ b/tests/functional/i/invalid/e/invalid_exceptions_raised.txt
@@ -0,0 +1,11 @@
+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
+raising-bad-type:110:4:bad_case10:Raising str while only classes or instances are allowed
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 000000000..ad94b8805
--- /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, use-dict-literal
+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 000000000..ea8c1703f
--- /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 000000000..ee5305fe8
--- /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 000000000..3560a80f9
--- /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 000000000..1d1c0b18f
--- /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 000000000..f10297d4e
--- /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:HIGH
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 000000000..f3d8b4361
--- /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 000000000..aa243c65b
--- /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_format_valid_3.py b/tests/functional/i/invalid/invalid_all_format_valid_3.py
new file mode 100644
index 000000000..3725d055e
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format_valid_3.py
@@ -0,0 +1,4 @@
+"""Test valid __all__ format."""
+__all__ = list("CONST")
+
+CONST = 42
diff --git a/tests/functional/i/invalid/invalid_all_format_valid_4.py b/tests/functional/i/invalid/invalid_all_format_valid_4.py
new file mode 100644
index 000000000..65a8c384b
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format_valid_4.py
@@ -0,0 +1,4 @@
+"""Test valid __all__ format."""
+__all__ = tuple("CONST")
+
+CONST = 42
diff --git a/tests/functional/i/invalid/invalid_all_format_valid_5.py b/tests/functional/i/invalid/invalid_all_format_valid_5.py
new file mode 100644
index 000000000..aa0e4dbf3
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format_valid_5.py
@@ -0,0 +1,7 @@
+"""Test valid __all__ format."""
+
+# pylint: disable=import-error, unused-import
+
+from foo import bar
+
+__all__ = list(globals().keys())
diff --git a/tests/functional/i/invalid/invalid_all_format_valid_6.py b/tests/functional/i/invalid/invalid_all_format_valid_6.py
new file mode 100644
index 000000000..64ac46bb7
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_all_format_valid_6.py
@@ -0,0 +1,7 @@
+"""Test valid __all__ format."""
+
+# pylint: disable=import-error, unused-import
+
+from foo import bar
+
+__all__ = tuple(globals().keys())
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 000000000..4468c987b
--- /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 000000000..ebcdb8d35
--- /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 000000000..367756eaa
--- /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 000000000..0c09dd334
--- /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 000000000..ec428b4b3
--- /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 000000000..3a3e1ae67
--- /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 000000000..47f63e99b
--- /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 000000000..f30e51417
--- /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 000000000..c48d9a837
--- /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 000000000..840d74a91
--- /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 000000000..9ec81bfbf
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name.py
@@ -0,0 +1,69 @@
+""" Tests for invalid-name checker. """

+# pylint: disable=unused-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 000000000..c4ecbfafd
--- /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_name_issue_3405.py b/tests/functional/i/invalid/invalid_name_issue_3405.py
new file mode 100644
index 000000000..9b0dd37cd
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name_issue_3405.py
@@ -0,0 +1,11 @@
+""" Regression test for https://github.com/PyCQA/pylint/issues/3405. """
+
+import dataclasses
+from typing import ClassVar
+
+
+@dataclasses.dataclass
+class Foo:
+    """ClassVar attribute should be matched against class-attribute-rgx, not attr-rgx"""
+    # class-attribute-rgx='^y$'
+    x: ClassVar[int] = 0  # [invalid-name]
diff --git a/tests/functional/i/invalid/invalid_name_issue_3405.rc b/tests/functional/i/invalid/invalid_name_issue_3405.rc
new file mode 100644
index 000000000..c8bdd0efd
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name_issue_3405.rc
@@ -0,0 +1,9 @@
+[MESSAGES CONTROL]
+enable=invalid-name
+
+[BASIC]
+attr-rgx=^x$
+class-attribute-rgx=^y$
+
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/i/invalid/invalid_name_issue_3405.txt b/tests/functional/i/invalid/invalid_name_issue_3405.txt
new file mode 100644
index 000000000..999137e42
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name_issue_3405.txt
@@ -0,0 +1 @@
+invalid-name:11:4:Foo:"Class attribute name ""x"" doesn't conform to '^y$' pattern":HIGH
diff --git a/tests/functional/i/invalid/invalid_name_multinaming_style.py b/tests/functional/i/invalid/invalid_name_multinaming_style.py
new file mode 100644
index 000000000..561a15472
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name_multinaming_style.py
@@ -0,0 +1,13 @@
+"""Test for multi naming style."""
+
+
+def UPPER():  # [invalid-name]
+    """UPPER func that will generate invalid-name error."""
+
+
+def lower():
+    """lower func that satisfies the prevalent group `lower`."""
+
+
+def anotherlower():
+    """Another lower func that satisfies the prevalent group `lower`."""
diff --git a/tests/functional/i/invalid/invalid_name_multinaming_style.rc b/tests/functional/i/invalid/invalid_name_multinaming_style.rc
new file mode 100644
index 000000000..d513cfbff
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name_multinaming_style.rc
@@ -0,0 +1,2 @@
+[BASIC]
+function-rgx=^(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$
diff --git a/tests/functional/i/invalid/invalid_name_multinaming_style.txt b/tests/functional/i/invalid/invalid_name_multinaming_style.txt
new file mode 100644
index 000000000..abcde057e
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_name_multinaming_style.txt
@@ -0,0 +1 @@
+invalid-name:4:0:UPPER:"Function name ""UPPER"" doesn't conform to the `down` group in the '^(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern":HIGH
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 000000000..69af42a0a
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_overridden_method.py
@@ -0,0 +1,127 @@
+# pylint: disable=missing-docstring,too-few-public-methods,disallowed-name,invalid-name,unused-argument
+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
+
+
+# https://github.com/PyCQA/pylint/issues/4368
+# Decrator functions with a nested property decorator should still be
+# inferred as property.
+
+def my_property(func):
+    @property
+    def _wrapper(self):
+        pass
+    return _wrapper
+
+def not_a_property(func):
+    def _wrapper(self):
+        pass
+    return _wrapper
+
+def multiple_returns(func):
+    def _wrapper(self):
+        pass
+    if foobar:  # pylint: disable=undefined-variable
+        return False
+    return _wrapper
+
+class A:
+    @property
+    def foo(self):
+        return True
+
+    @property
+    def bar(self):
+        return True
+
+    @property
+    def bar2(self):
+        return True
+
+class B(A):
+    @my_property
+    def foo(self):
+        return False
+
+    @not_a_property
+    def bar(self):  # [invalid-overridden-method]
+        return False
+
+    @multiple_returns
+    def bar2(self):  # [invalid-overridden-method]
+        return False
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 000000000..8e09d9883
--- /dev/null
+++ b/tests/functional/i/invalid/invalid_overridden_method.txt
@@ -0,0 +1,6 @@
+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'
+invalid-overridden-method:122:4:B.bar:Method 'bar' was expected to be 'property', found it instead as 'method'
+invalid-overridden-method:126:4:B.bar2:Method 'bar2' was expected to be 'property', found it instead as 'method'
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 000000000..3bbd7828d
--- /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 000000000..4be375f1f
--- /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 000000000..e7231c34d
--- /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, use-dict-literal

+

+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 000000000..6a3dd591d
--- /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 000000000..7696bc9fd
--- /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 000000000..dd31af76e
--- /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 000000000..99af28d1c
--- /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 000000000..27b86cd13
--- /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 000000000..c0e9d74be
--- /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 000000000..2fc458f5c
--- /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/s/invalid_sequence_index.py b/tests/functional/i/invalid/s/invalid_sequence_index.py
new file mode 100644
index 000000000..d11155c02
--- /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 000000000..baf1b2167
--- /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 000000000..1eb2fda9c
--- /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 000000000..e715138b4
--- /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 000000000..452f9a728
--- /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.txt b/tests/functional/i/invalid/s/invalid_star_assignment_target.txt
new file mode 100644
index 000000000..eb9f27c90
--- /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 000000000..00ef22046
--- /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 000000000..36b7ec57c
--- /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 000000000..cf32cbfbb
--- /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 000000000..aef0dcc07
--- /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 000000000..2754d179f
--- /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,redundant-u-string-prefix
+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 000000000..2ec91a4b9
--- /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 000000000..34047eda0
--- /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.txt b/tests/functional/i/iterable_context_py3.txt
new file mode 100644
index 000000000..b3849d467
--- /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 000000000..d50d3da98
--- /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.txt b/tests/functional/i/iterable_context_py36.txt
new file mode 100644
index 000000000..b4a7c1fe1
--- /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/k/__init__.py b/tests/functional/k/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..119287410
--- /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 000000000..874c09497
--- /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 000000000..e69de29bb
--- /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 000000000..af2775cae
--- /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 000000000..ceeedb549
--- /dev/null
+++ b/tests/functional/l/len_checks.py
@@ -0,0 +1,186 @@
+# pylint: disable=too-few-public-methods,import-error, 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 000000000..f1b96e477
--- /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 000000000..0b6e795e3
--- /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 000000000..95532ea80
--- /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 000000000..9d45f4ad6
--- /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 000000000..1be460375
--- /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 000000000..57719ce6d
--- /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 000000000..21cb75655
--- /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 000000000..646e57eec
--- /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 000000000..541bfe515
--- /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 000000000..5670ad57c
--- /dev/null
+++ b/tests/functional/l/logging_format_interpolation.py
@@ -0,0 +1,37 @@
+# pylint: disable=no-member,  import-error,line-too-long
+# pylint: disable=invalid-name,missing-docstring,wrong-import-order,wrong-import-position, consider-using-f-string
+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 000000000..6437b7176
--- /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 000000000..2601c5bfc
--- /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.txt b/tests/functional/l/logging_format_interpolation_py36.txt
new file mode 100644
index 000000000..a0de664a6
--- /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 000000000..5aebb7dd2
--- /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.txt b/tests/functional/l/logging_fstring_interpolation_py36.txt
new file mode 100644
index 000000000..5529b338e
--- /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 000000000..28aa3b783
--- /dev/null
+++ b/tests/functional/l/logging_not_lazy.py
@@ -0,0 +1,22 @@
+# pylint: disable=missing-docstring,no-member,deprecated-method,invalid-name, consider-using-f-string
+
+# 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]
+
+# 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 000000000..88a1c1e81
--- /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 000000000..69d0e9bd4
--- /dev/null
+++ b/tests/functional/l/logging_not_lazy_with_logger.py
@@ -0,0 +1,14 @@
+"""Logging warnings using a logger class."""
+# pylint: disable=consider-using-f-string
+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 000000000..43d9c1620
--- /dev/null
+++ b/tests/functional/l/logging_not_lazy_with_logger.txt
@@ -0,0 +1,4 @@
+logging-not-lazy:9:0::Use lazy % formatting in logging functions
+logging-not-lazy:10:0::Use lazy % formatting in logging functions
+logging-not-lazy:12:0::Use lazy % formatting in logging functions
+logging-not-lazy:14: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 000000000..be133ba87
--- /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 000000000..dba64ce48
--- /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 000000000..a1d90edcc
--- /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 000000000..22440fa17
--- /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 000000000..815759fe5
--- /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.py b/tests/functional/l/loopvar_in_dict_comp.py
new file mode 100644
index 000000000..072ea1bf5
--- /dev/null
+++ b/tests/functional/l/loopvar_in_dict_comp.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.txt b/tests/functional/l/loopvar_in_dict_comp.txt
new file mode 100644
index 000000000..2d98fcfff
--- /dev/null
+++ b/tests/functional/l/loopvar_in_dict_comp.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 000000000..c8fd3fe1f
--- /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 000000000..f2791dc7d
--- /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 000000000..e69de29bb
--- /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 000000000..6b3a13573
--- /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 000000000..232635628
--- /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 000000000..042d4d02d
--- /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.txt b/tests/functional/m/mapping_context_py3.txt
new file mode 100644
index 000000000..f77491458
--- /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 000000000..c1b6a22fb
--- /dev/null
+++ b/tests/functional/m/member/member_checks.py
@@ -0,0 +1,233 @@
+# pylint: disable=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 000000000..0b7ee9478
--- /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 000000000..3925f4741
--- /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 000000000..8d4b587f4
--- /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 000000000..9dd977b13
--- /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 000000000..06f01cb6a
--- /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 000000000..9ec706ec6
--- /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 000000000..ead0e7efe
--- /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 000000000..6eefa7958
--- /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 000000000..3925f4741
--- /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 000000000..0f9c9ca3b
--- /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 000000000..6d818641e
--- /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 000000000..9b592af64
--- /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 000000000..025cd2a0f
--- /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 000000000..2fabce4e2
--- /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 000000000..ebbedbde3
--- /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 000000000..a17bb22da
--- /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 000000000..c52eab13c
--- /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 000000000..90f775a43
--- /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 000000000..6261a31aa
--- /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 000000000..e5efc8916
--- /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, redundant-u-string-prefix
+
+# 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 000000000..e021062da
--- /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 000000000..678072354
--- /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.txt b/tests/functional/m/member/membership_protocol_py3.txt
new file mode 100644
index 000000000..495cf94db
--- /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 000000000..50f9712fa
--- /dev/null
+++ b/tests/functional/m/metaclass_attr_access.py
@@ -0,0 +1,21 @@
+# pylint: disable=too-few-public-methods, 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 000000000..cdbe323e2
--- /dev/null
+++ b/tests/functional/m/method_hidden.py
@@ -0,0 +1,92 @@
+# pylint: disable=too-few-public-methods, 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 000000000..a15bf30c2
--- /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 000000000..6148733e2
--- /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 000000000..38e04f988
--- /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 000000000..29f2b1ed8
--- /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 000000000..b517b499e
--- /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 000000000..679f59858
--- /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
+# pylint: disable=consider-using-f-string
+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 000000000..2a77a2720
--- /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 000000000..b4317d96f
--- /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 000000000..645618b8a
--- /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 000000000..72d6762aa
--- /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 000000000..c9ec52161
--- /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 000000000..58c7c1ec8
--- /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 000000000..f194673fe
--- /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 000000000..370f902b7
--- /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 000000000..d7c329b70
--- /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.py b/tests/functional/m/missing/missing_kwoa.py
new file mode 100644
index 000000000..b4dc604cd
--- /dev/null
+++ b/tests/functional/m/missing/missing_kwoa.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.txt b/tests/functional/m/missing/missing_kwoa.txt
new file mode 100644
index 000000000..710635504
--- /dev/null
+++ b/tests/functional/m/missing/missing_kwoa.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 000000000..d4d9edf3f
--- /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 000000000..cd1d76a8d
--- /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 000000000..0547c6e30
--- /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 000000000..79ae34879
--- /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 000000000..1b7626244
--- /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 000000000..8b2154c95
--- /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 000000000..c5b65ada1
--- /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 000000000..e8bd03aa7
--- /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 000000000..9008dcc52
--- /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 000000000..45380c350
--- /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 000000000..e69de29bb
--- /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 000000000..e048ec4d8
--- /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 000000000..29f44504a
--- /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 000000000..b24b0a881
--- /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 000000000..60b92ce18
--- /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 000000000..85fc502b3
--- /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 000000000..b9fdd20e5
--- /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 000000000..ddfc3537a
--- /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 000000000..43700a640
--- /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 000000000..48f03d13b
--- /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 000000000..75208c1eb
--- /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 000000000..abb08ce3b
--- /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 000000000..537c42983
--- /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 000000000..75350497e
--- /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 000000000..2b04af5d4
--- /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 000000000..c189797e9
--- /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 000000000..27e6e1044
--- /dev/null
+++ b/tests/functional/n/name/name_styles.py
@@ -0,0 +1,160 @@
+"""Test for the invalid-name warning."""
+# pylint: disable= 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 000000000..e6e01b246
--- /dev/null
+++ b/tests/functional/n/name/name_styles.rc
@@ -0,0 +1,2 @@
+[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 000000000..0a82e6084
--- /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 000000000..4488ceb0a
--- /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 000000000..b754e9be7
--- /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 000000000..c5d17cd80
--- /dev/null
+++ b/tests/functional/n/name/names_in__all__.py
@@ -0,0 +1,49 @@
+# pylint: disable=too-few-public-methods,no-self-use, 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 000000000..aa9015143
--- /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 000000000..b01cf2636
--- /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 000000000..2351ea403
--- /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 000000000..d44a9f71f
--- /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 000000000..66dac6efd
--- /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 000000000..39d2889a4
--- /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 000000000..9f70ebc4c
--- /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 000000000..b70c6e097
--- /dev/null
+++ b/tests/functional/n/new_style_class_py_30.py
@@ -0,0 +1,34 @@
+"""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=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(f"File {self.name} is opened.  The mode is: {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(f"Closing file {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 000000000..b86cc2b54
--- /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:21:8:File.write:Consider using Python 3 style super() without arguments
+super-with-arguments:26:8:File.writelines:Consider using Python 3 style super() without arguments
+super-with-arguments:33: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 000000000..e69de29bb
--- /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 000000000..66cc0b3c0
--- /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 000000000..90b10f2b1
--- /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 000000000..c6b093dad
--- /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 000000000..3e6854be5
--- /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 000000000..cf23f313a
--- /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 000000000..d1a27f73c
--- /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 000000000..37f70f121
--- /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 000000000..6d659ea28
--- /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 000000000..ae807fae3
--- /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 000000000..b41f7132f
--- /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 000000000..0a87551fa
--- /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 000000000..4560f7490
--- /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_member.py b/tests/functional/n/no/no_member.py
new file mode 100644
index 000000000..73b2227a6
--- /dev/null
+++ b/tests/functional/n/no/no_member.py
@@ -0,0 +1,31 @@
+# pylint: disable=missing-docstring, unused-argument, wrong-import-position, invalid-name
+
+
+# Regression test for https://github.com/PyCQA/pylint/issues/400
+class TestListener:
+    def __init__(self):
+        self._latest = None
+
+    def wait(self, timeout):
+        result = self._latest
+        self._latest = None
+        return result
+
+    def peer_joined(self, peer):
+        self._latest = peer
+
+
+listener = TestListener()
+broker = listener.wait(3).get_domain()  # No error here
+
+
+# Regression test for https://github.com/PyCQA/pylint/issues/4377
+from urllib import parse
+
+url = 'http://www.google.com'
+
+parsed_url = parse.urlparse(url)
+sorted_query = parse.urlencode(
+    sorted(parse.parse_qsl(parsed_url.query), key=lambda param: param[0]))
+new_parsed_url = parse.ParseResult._replace(parsed_url, query=sorted_query)
+new_url = new_parsed_url.geturl()  # No error here
diff --git a/tests/functional/n/no/no_member_dataclasses.py b/tests/functional/n/no/no_member_dataclasses.py
new file mode 100644
index 000000000..972da9ad9
--- /dev/null
+++ b/tests/functional/n/no/no_member_dataclasses.py
@@ -0,0 +1,83 @@
+"""Test various regressions for dataclasses and no-member.
+"""
+# pylint: disable=missing-docstring, too-few-public-methods
+from abc import ABCMeta, abstractmethod
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict
+
+
+# https://github.com/PyCQA/pylint/issues/3754
+@dataclass(frozen=True)
+class DeploymentState(metaclass=ABCMeta):
+    type: str
+
+    @abstractmethod
+    def to_dict(self) -> Dict:
+        """
+        Serializes given DeploymentState instance to Dict.
+        :return:
+        """
+
+
+@dataclass(frozen=True)
+class DeploymentStateEcs(DeploymentState):
+    blue: Any
+    green: Any
+    candidate: Any
+
+    def to_dict(self) -> Dict:
+        return {
+            'type': self.type,  # No error here
+            'blue': asdict(self.blue),
+            'green': asdict(self.green),
+            'candidate': self.candidate.value,
+        }
+
+
+@dataclass(frozen=True)
+class DeploymentStateLambda(DeploymentState):
+    current: Any
+    candidate: Any
+
+    def to_dict(self) -> Dict:
+        return {
+            'type': self.type,  # No error here
+            'current': asdict(self.current),
+            'candidate': asdict(self.candidate) if self.candidate else None,
+        }
+
+
+# https://github.com/PyCQA/pylint/issues/2600
+@dataclass
+class TestClass:
+    attr1: str
+    attr2: str
+    dict_prop: Dict[str, str] = field(default_factory=dict)
+
+    def some_func(self) -> None:
+        for key, value in self.dict_prop.items():  # No error here
+            print(key)
+            print(value)
+
+
+class TestClass2:  # not a dataclass, field inferred to a Field
+    attr1: str
+    attr2: str
+    dict_prop: Dict[str, str] = field(default_factory=dict)
+
+    def some_func(self) -> None:
+        for key, value in self.dict_prop.items():  # [no-member]
+            print(key)
+            print(value)
+
+
+@dataclass
+class TestClass3:
+    attr1: str
+    attr2: str
+    dict_prop = field(default_factory=dict)  # No type annotation, not treated as field
+
+    def some_func(self) -> None:
+        for key, value in self.dict_prop.items():  # [no-member]
+            print(key)
+            print(value)
diff --git a/tests/functional/n/no/no_member_dataclasses.rc b/tests/functional/n/no/no_member_dataclasses.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/n/no/no_member_dataclasses.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/n/no/no_member_dataclasses.txt b/tests/functional/n/no/no_member_dataclasses.txt
new file mode 100644
index 000000000..ffa499e71
--- /dev/null
+++ b/tests/functional/n/no/no_member_dataclasses.txt
@@ -0,0 +1,2 @@
+no-member:69:26:TestClass2.some_func:Instance of 'Field' has no 'items' member:INFERENCE
+no-member:81:26:TestClass3.some_func:Instance of 'Field' has no 'items' member:INFERENCE
diff --git a/tests/functional/n/no/no_member_if_statements.py b/tests/functional/n/no/no_member_if_statements.py
new file mode 100644
index 000000000..ad87e9950
--- /dev/null
+++ b/tests/functional/n/no/no_member_if_statements.py
@@ -0,0 +1,79 @@
+# pylint: disable=invalid-name,missing-docstring,pointless-statement
+from datetime import datetime
+from typing import Union
+
+value = "Hello World"
+value.isoformat()  # [no-member]
+
+
+if isinstance(value, datetime):
+    value.isoformat()
+else:
+    value.isoformat()  # [no-member]
+
+
+def func():
+    if hasattr(value, "load"):
+        value.load()
+
+    if getattr(value, "load", None):
+        value.load
+
+
+if value.none_existent():  # [no-member]
+    pass
+
+res = value.isoformat() if isinstance(value, datetime) else value
+
+
+class Base:
+    _attr_state: Union[str, datetime] = "Unknown"
+
+    @property
+    def state(self) -> Union[str, datetime]:
+        return self._attr_state
+
+    def some_function(self) -> str:
+        state = self.state
+        if isinstance(state, datetime):
+            return state.isoformat()
+        return str(state)
+
+
+# https://github.com/PyCQA/pylint/issues/1990
+# Attribute access after 'isinstance' should not cause 'no-member' error
+import subprocess  # pylint: disable=wrong-import-position  # noqa: E402
+
+try:
+    subprocess.check_call(['ls', '-'])  # Deliberately made error in this line
+except Exception as err:
+    if isinstance(err, subprocess.CalledProcessError):
+        print(f'Subprocess error occured. Return code: {err.returncode}')
+    else:
+        print(f'An error occured: {str(err)}')
+    raise
+
+
+# https://github.com/PyCQA/pylint/issues/4168
+# 'encode' for 'arg' should not cause 'no-member' error
+mixed_tuple = (b"a", b"b", b"c", b"d")
+byte_tuple = [arg.encode('utf8') if isinstance(arg, str) else arg for arg in mixed_tuple]
+
+for arg in mixed_tuple:
+    if isinstance(arg, str):
+        print(arg.encode('utf8'))
+    else:
+        print(arg)
+
+
+# https://github.com/PyCQA/pylint/issues/1162
+# Attribute access after 'isinstance' should not cause 'no-member' error
+class FoobarException(Exception):
+    foobar = None
+
+try:  # noqa: E305
+    pass
+except Exception as ex:
+    if isinstance(ex, FoobarException):
+        ex.foobar
+    raise
diff --git a/tests/functional/n/no/no_member_if_statements.txt b/tests/functional/n/no/no_member_if_statements.txt
new file mode 100644
index 000000000..2bc673b49
--- /dev/null
+++ b/tests/functional/n/no/no_member_if_statements.txt
@@ -0,0 +1,3 @@
+no-member:6:0::Instance of 'str' has no 'isoformat' member:INFERENCE
+no-member:12:4::Instance of 'str' has no 'isoformat' member:INFERENCE
+no-member:23:3::Instance of 'str' has no 'none_existent' member:INFERENCE
diff --git a/tests/functional/n/no/no_member_nested_namedtuple.py b/tests/functional/n/no/no_member_nested_namedtuple.py
new file mode 100644
index 000000000..6a87ff63d
--- /dev/null
+++ b/tests/functional/n/no/no_member_nested_namedtuple.py
@@ -0,0 +1,8 @@
+from typing import NamedTuple
+
+class Ax(NamedTuple):
+    class Bx:
+        b = 0
+
+
+print(Ax.Bx.b)
diff --git a/tests/functional/n/no/no_member_nested_namedtuple.rc b/tests/functional/n/no/no_member_nested_namedtuple.rc
new file mode 100644
index 000000000..d115e3986
--- /dev/null
+++ b/tests/functional/n/no/no_member_nested_namedtuple.rc
@@ -0,0 +1,10 @@
+[testoptions]
+min_pyver=3.7
+
+[MESSAGES CONTROL]
+disable=fixme,
+    logging-too-many-args,
+    logging-fstring-interpolation,
+    missing-docstring,
+    no-else-return,
+    too-few-public-methods,
diff --git a/tests/functional/n/no/no_member_subclassed_dataclasses.py b/tests/functional/n/no/no_member_subclassed_dataclasses.py
new file mode 100644
index 000000000..918abc5db
--- /dev/null
+++ b/tests/functional/n/no/no_member_subclassed_dataclasses.py
@@ -0,0 +1,40 @@
+from abc import ABCMeta, abstractmethod
+import dataclasses as dc
+from typing import Any, Dict
+
+@dc.dataclass(frozen=True)
+class DeploymentState(metaclass=ABCMeta):
+    type: str
+
+    @abstractmethod
+    def to_dict(self) -> Dict:
+        """
+        Serializes given DeploymentState instance to Dict.
+        :return:
+        """
+
+@dc.dataclass(frozen=True)
+class DeploymentStateEcs(DeploymentState):
+    blue: Any
+    green: Any
+    candidate: Any
+
+    def to_dict(self) -> Dict:
+        return {
+            'type': self.type,
+            'blue': dc.asdict(self.blue),
+            'green': dc.asdict(self.green),
+            'candidate': self.candidate.value,
+        }
+
+@dc.dataclass(frozen=True)
+class DeploymentStateLambda(DeploymentState):
+    current: Any
+    candidate: Any
+
+    def to_dict(self) -> Dict:
+        return {
+            'type': self.type,
+            'current': dc.asdict(self.current),
+            'candidate': dc.asdict(self.candidate) if self.candidate else None,
+        }
diff --git a/tests/functional/n/no/no_member_subclassed_dataclasses.rc b/tests/functional/n/no/no_member_subclassed_dataclasses.rc
new file mode 100644
index 000000000..d115e3986
--- /dev/null
+++ b/tests/functional/n/no/no_member_subclassed_dataclasses.rc
@@ -0,0 +1,10 @@
+[testoptions]
+min_pyver=3.7
+
+[MESSAGES CONTROL]
+disable=fixme,
+    logging-too-many-args,
+    logging-fstring-interpolation,
+    missing-docstring,
+    no-else-return,
+    too-few-public-methods,
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 000000000..c67453288
--- /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 000000000..85fc502b3
--- /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 000000000..ba67fbdb7
--- /dev/null
+++ b/tests/functional/n/no/no_name_in_module.py
@@ -0,0 +1,66 @@
+# pylint: disable=wildcard-import,unused-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 000000000..883e6b5d7
--- /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 000000000..38f6040b5
--- /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 000000000..7e11c5ced
--- /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 000000000..8e6d6fc34
--- /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 000000000..a17bb22da
--- /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 000000000..d0aba8476
--- /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 000000000..8311da0f0
--- /dev/null
+++ b/tests/functional/n/no/no_self_use.py
@@ -0,0 +1,85 @@
+# 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')
+
+    async def async_regular_method(self):
+        """this async method is a real method since it accesses self"""
+        await self.async_function_method()
+
+    async def async_function_method(self): # [no-self-use]
+        """this async method isn't 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 000000000..c91eff9a8
--- /dev/null
+++ b/tests/functional/n/no/no_self_use.txt
@@ -0,0 +1,2 @@
+no-self-use:16:4:Toto.function_method:Method could be a function
+no-self-use:24:4:Toto.async_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 000000000..f40150835
--- /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_staticmethod_decorator.py b/tests/functional/n/no/no_staticmethod_decorator.py
new file mode 100644
index 000000000..d0e0effa4
--- /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 000000000..df897666a
--- /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 000000000..315eeeaab
--- /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 000000000..e69de29bb
--- /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 000000000..276a23f75
--- /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 000000000..ff09ea1f6
--- /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 000000000..076d7267d
--- /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 000000000..97489accf
--- /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=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 000000000..22073d63d
--- /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 000000000..4d0dd2a39
--- /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, encoding="utf-8")
+        # 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 000000000..a78948236
--- /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 000000000..a910cbd6f
--- /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 000000000..b6cc0ce5d
--- /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.py b/tests/functional/n/none_dunder_protocols.py
new file mode 100644
index 000000000..5573ceeb4
--- /dev/null
+++ b/tests/functional/n/none_dunder_protocols.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.txt b/tests/functional/n/none_dunder_protocols.txt
new file mode 100644
index 000000000..d55000645
--- /dev/null
+++ b/tests/functional/n/none_dunder_protocols.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 000000000..f05a64947
--- /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 000000000..67d064606
--- /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 000000000..940052436
--- /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.txt b/tests/functional/n/nonlocal_and_global.txt
new file mode 100644
index 000000000..3b5668aac
--- /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 000000000..22887bcee
--- /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
+
+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.txt b/tests/functional/n/nonlocal_without_binding.txt
new file mode 100644
index 000000000..df5595aae
--- /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 000000000..138d76dfa
--- /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.txt b/tests/functional/n/not_async_context_manager.txt
new file mode 100644
index 000000000..01b411303
--- /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 000000000..c1ca26976
--- /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 000000000..a17bb22da
--- /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 000000000..01a9009bf
--- /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,use-dict-literal
+
+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 000000000..397e617b6
--- /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 000000000..a59f5a200
--- /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 000000000..71b3af399
--- /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 000000000..f7319eef7
--- /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 000000000..d4f82e5c7
--- /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 000000000..e69de29bb
--- /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 000000000..2ac729b36
--- /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 000000000..8b39cde7f
--- /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 000000000..fe413f4d4
--- /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 000000000..4eb48e93c
--- /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 000000000..fe413f4d4
--- /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 000000000..c305af689
--- /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 000000000..e69de29bb
--- /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 000000000..4b3a71643
--- /dev/null
+++ b/tests/functional/p/pattern_matching.py
@@ -0,0 +1,38 @@
+# 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)
+
+
+# Test inference of variables assigned in patterns doesn't crash pylint
+var = 42
+match var:
+    case (1, *rest3):
+        if rest3 != 2:
+            pass
+    case {1: _, **rest4}:
+        if rest4 != 2:
+            pass
+    case c:
+        if c != 2:
+            pass
diff --git a/tests/functional/p/pattern_matching.rc b/tests/functional/p/pattern_matching.rc
new file mode 100644
index 000000000..68a8c8ef1
--- /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 000000000..8b31d2348
--- /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 000000000..72e7c1af7
--- /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 000000000..8d5a79f24
--- /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 000000000..3cc694d47
--- /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 000000000..a17bb22da
--- /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 000000000..4f4724771
--- /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 000000000..a17bb22da
--- /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 000000000..f892414f0
--- /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 000000000..a17bb22da
--- /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 000000000..ece8a13e4
--- /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 000000000..889155a0f
--- /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 000000000..35b185fdb
--- /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 000000000..2d595896c
--- /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 000000000..71f09dc4c
--- /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 000000000..35b185fdb
--- /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 000000000..3949a6253
--- /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 000000000..98201a6d8
--- /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 000000000..16b75eea7
--- /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 000000000..e0d0010a2
--- /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 000000000..4de44bd7d
--- /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 000000000..ce1f1c2c8
--- /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 000000000..e0982e030
--- /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 000000000..8ac3be36b
--- /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 000000000..323cf2d05
--- /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 000000000..b210bb501
--- /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 000000000..732640cc4
--- /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 000000000..dc09aa52b
--- /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.txt b/tests/functional/p/protected_access_access_different_scopes.txt
new file mode 100644
index 000000000..17736cc83
--- /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 000000000..784da6098
--- /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 000000000..85fc502b3
--- /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 000000000..f85953fc8
--- /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 000000000..e69de29bb
--- /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 000000000..d23cefb5e
--- /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 000000000..15138705a
--- /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 000000000..268d834f4
--- /dev/null
+++ b/tests/functional/r/raise/raising_format_tuple.py
@@ -0,0 +1,52 @@
+'''
+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.
+'''
+# pylint: disable=redundant-u-string-prefix, consider-using-f-string
+
+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 000000000..d663ca454
--- /dev/null
+++ b/tests/functional/r/raise/raising_format_tuple.txt
@@ -0,0 +1,7 @@
+raising-format-tuple:11:4:bad_percent:Exception arguments suggest string formatting might be intended
+raising-format-tuple:19:4:bad_multiarg:Exception arguments suggest string formatting might be intended
+raising-format-tuple:27:4:bad_braces:Exception arguments suggest string formatting might be intended
+raising-format-tuple:35:4:bad_multistring:Exception arguments suggest string formatting might be intended
+raising-format-tuple:41:4:bad_triplequote:Exception arguments suggest string formatting might be intended
+raising-format-tuple:47:4:bad_unicode:Exception arguments suggest string formatting might be intended
+raising-format-tuple:52:4:raise_something_without_name:Exception arguments suggest string formatting might be intended
diff --git a/tests/functional/r/raise/raising_non_exception.py b/tests/functional/r/raise/raising_non_exception.py
new file mode 100644
index 000000000..7961c5220
--- /dev/null
+++ b/tests/functional/r/raise/raising_non_exception.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.txt b/tests/functional/r/raise/raising_non_exception.txt
new file mode 100644
index 000000000..9a2e494f1
--- /dev/null
+++ b/tests/functional/r/raise/raising_non_exception.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 000000000..16f244ba5
--- /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 000000000..585cf7f2f
--- /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 000000000..9be68b265
--- /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 000000000..03e0a5444
--- /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 000000000..27ee2875c
--- /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 000000000..6b4b08d5f
--- /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 000000000..97ec190e8
--- /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 000000000..086cce769
--- /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 000000000..4a9f346cb
--- /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 000000000..208bc2e7a
--- /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 000000000..05978a355
--- /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 000000000..662da6145
--- /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 000000000..96e0fbf74
--- /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 000000000..a2ff124a1
--- /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 000000000..3043c52fb
--- /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 000000000..931c8a2b6
--- /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 000000000..012ba136b
--- /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 000000000..dec738ee8
--- /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 000000000..7ccff1d18
--- /dev/null
+++ b/tests/functional/r/redefined_argument_from_local.py
@@ -0,0 +1,69 @@
+# pylint: disable=missing-docstring, unused-variable, unused-argument
+# pylint: disable=redefined-outer-name, invalid-name
+
+
+def test_redefined_in_with(name):
+    with open("something", encoding="utf-8") as name:  # [redefined-argument-from-local]
+        pass
+    with open("something", encoding="utf-8") as (second, name):  # [redefined-argument-from-local]
+        pass
+    with open("something", encoding="utf-8") as (
+        second,
+        (name, third),  # [redefined-argument-from-local]
+    ):
+        pass
+    other = None
+    with open("something", encoding="utf-8") as other:
+        pass
+
+
+def test_not_redefined_in_with(name):
+    with open("something", encoding="utf-8") 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 000000000..b811971c6
--- /dev/null
+++ b/tests/functional/r/redefined_argument_from_local.txt
@@ -0,0 +1,7 @@
+redefined-argument-from-local:6:48:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:8:57:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:12:9:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:26:8:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:28:9:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:30:15:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:50: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 000000000..c840f8dd5
--- /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 000000000..8d652510c
--- /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 000000000..ec7697dfc
--- /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 000000000..845729dce
--- /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 000000000..cd97f3249
--- /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 000000000..399fc8cea
--- /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 000000000..a17bb22da
--- /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_u_string_prefix.py b/tests/functional/r/redundant_u_string_prefix.py
new file mode 100644
index 000000000..7ffbabd09
--- /dev/null
+++ b/tests/functional/r/redundant_u_string_prefix.py
@@ -0,0 +1,14 @@
+""""Checks for redundant u-prefixes for strings"""
+# pylint: disable=missing-function-docstring
+
+def print_good():
+    print("String")
+    print(f"String{1 + 1}")
+
+
+def print_bad():
+    print(u"String")  # [redundant-u-string-prefix]
+    print(u'String')  # [redundant-u-string-prefix]
+    print([u"String", u"String2"])  # [redundant-u-string-prefix, redundant-u-string-prefix]
+    print((u"String", u"String2"))  # [redundant-u-string-prefix, redundant-u-string-prefix]
+    print({1: u"String"})  # [redundant-u-string-prefix]
diff --git a/tests/functional/r/redundant_u_string_prefix.rc b/tests/functional/r/redundant_u_string_prefix.rc
new file mode 100644
index 000000000..85fc502b3
--- /dev/null
+++ b/tests/functional/r/redundant_u_string_prefix.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/r/redundant_u_string_prefix.txt b/tests/functional/r/redundant_u_string_prefix.txt
new file mode 100644
index 000000000..f970ef8e8
--- /dev/null
+++ b/tests/functional/r/redundant_u_string_prefix.txt
@@ -0,0 +1,7 @@
+redundant-u-string-prefix:10:10::The u prefix for strings is no longer necessary in Python >=3.0:HIGH
+redundant-u-string-prefix:11:10::The u prefix for strings is no longer necessary in Python >=3.0:HIGH
+redundant-u-string-prefix:12:11::The u prefix for strings is no longer necessary in Python >=3.0:HIGH
+redundant-u-string-prefix:12:22::The u prefix for strings is no longer necessary in Python >=3.0:HIGH
+redundant-u-string-prefix:13:11::The u prefix for strings is no longer necessary in Python >=3.0:HIGH
+redundant-u-string-prefix:13:22::The u prefix for strings is no longer necessary in Python >=3.0:HIGH
+redundant-u-string-prefix:14:14::The u prefix for strings is no longer necessary in Python >=3.0:HIGH
diff --git a/tests/functional/r/redundant_unittest_assert.py b/tests/functional/r/redundant_unittest_assert.py
new file mode 100644
index 000000000..b7efffc4e
--- /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 000000000..ad9d22a97
--- /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 000000000..a42d44ac3
--- /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 000000000..0cc23c2db
--- /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 000000000..f32490c44
--- /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_2913.py b/tests/functional/r/regression/regression_2913.py
new file mode 100644
index 000000000..f36adb459
--- /dev/null
+++ b/tests/functional/r/regression/regression_2913.py
@@ -0,0 +1,19 @@
+"""Module doc string."""
+# pylint: disable=locally-disabled
+
+
+# pylint: disable=too-few-public-methods
+class Base:
+    """My base class."""
+
+
+# pylint: enable=too-few-public-methods
+
+
+class BaseCorrect:  # pylint: disable=too-few-public-methods
+    """My base class."""
+
+
+class BaseInner:  # [too-few-public-methods]
+    # pylint: disable=too-few-public-methods
+    """My base class."""
diff --git a/tests/functional/r/regression/regression_2913.txt b/tests/functional/r/regression/regression_2913.txt
new file mode 100644
index 000000000..97bc38ce7
--- /dev/null
+++ b/tests/functional/r/regression/regression_2913.txt
@@ -0,0 +1 @@
+too-few-public-methods:17:0:BaseInner:Too few public methods (0/2):HIGH
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 000000000..55b240440
--- /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 000000000..8196db12d
--- /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 000000000..6cc9cd71c
--- /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 000000000..9bc761701
--- /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 000000000..44d7a6230
--- /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 000000000..374b5f860
--- /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 000000000..120b26a04
--- /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 000000000..4c346b145
--- /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 000000000..63a9d7749
--- /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_4439.py b/tests/functional/r/regression/regression_4439.py
new file mode 100644
index 000000000..966cc8006
--- /dev/null
+++ b/tests/functional/r/regression/regression_4439.py
@@ -0,0 +1,13 @@
+"""AttributeError: 'Subscript' object has no attribute 'name' """
+# pylint: disable=missing-docstring
+
+from typing import Optional
+
+from attr import attrib, attrs
+
+
+@attrs()
+class User:
+    name: str = attrib()
+    age: int = attrib()
+    occupation = Optional[str] = attrib(default=None) # [unsupported-assignment-operation]
diff --git a/tests/functional/r/regression/regression_4439.rc b/tests/functional/r/regression/regression_4439.rc
new file mode 100644
index 000000000..4e2b74831
--- /dev/null
+++ b/tests/functional/r/regression/regression_4439.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.10
diff --git a/tests/functional/r/regression/regression_4439.txt b/tests/functional/r/regression/regression_4439.txt
new file mode 100644
index 000000000..1fe96738d
--- /dev/null
+++ b/tests/functional/r/regression/regression_4439.txt
@@ -0,0 +1 @@
+unsupported-assignment-operation:13:17:User:'Optional' does not support item assignment:HIGH
diff --git a/tests/functional/r/regression/regression_4612_crash_pytest_fixture.py b/tests/functional/r/regression/regression_4612_crash_pytest_fixture.py
new file mode 100644
index 000000000..f7680f1fb
--- /dev/null
+++ b/tests/functional/r/regression/regression_4612_crash_pytest_fixture.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring,consider-using-with,redefined-outer-name
+
+import pytest
+
+
+@pytest.fixture
+def qm_file():
+    qm_file = open("src/test/resources/example_qm_file.csv", encoding="utf-8").read()
+    return qm_file
diff --git a/tests/functional/r/regression/regression_4680.py b/tests/functional/r/regression/regression_4680.py
new file mode 100644
index 000000000..d43472607
--- /dev/null
+++ b/tests/functional/r/regression/regression_4680.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+
+import pkg.sub  # [import-error]
+
+
+class Failed(metaclass=pkg.sub.Metaclass):
+    pass
+
+
+class FailedTwo(metaclass=ab.ABCMeta):  # [undefined-variable]
+    pass
+
+
+class FailedThree(metaclass=pkg.sob.Metaclass):
+    pass
+
+
+assert pkg.sub.value is None
diff --git a/tests/functional/r/regression/regression_4680.txt b/tests/functional/r/regression/regression_4680.txt
new file mode 100644
index 000000000..22c689eb5
--- /dev/null
+++ b/tests/functional/r/regression/regression_4680.txt
@@ -0,0 +1,2 @@
+import-error:3:0::Unable to import 'pkg.sub':HIGH
+undefined-variable:10:0:FailedTwo:Undefined variable 'ab':HIGH
diff --git a/tests/functional/r/regression/regression_4688_duplicated_bases_member_hints.py b/tests/functional/r/regression/regression_4688_duplicated_bases_member_hints.py
new file mode 100644
index 000000000..88699e78e
--- /dev/null
+++ b/tests/functional/r/regression/regression_4688_duplicated_bases_member_hints.py
@@ -0,0 +1,7 @@
+# pylint: disable=missing-docstring, pointless-statement, useless-object-inheritance
+# pylint: disable=duplicate-bases, too-few-public-methods
+
+
+class Klass(object, object):
+    def get(self):
+        self._non_existent_attribute # [no-member]
diff --git a/tests/functional/r/regression/regression_4688_duplicated_bases_member_hints.txt b/tests/functional/r/regression/regression_4688_duplicated_bases_member_hints.txt
new file mode 100644
index 000000000..ac58fcf32
--- /dev/null
+++ b/tests/functional/r/regression/regression_4688_duplicated_bases_member_hints.txt
@@ -0,0 +1 @@
+no-member:7:8:Klass.get:Instance of 'Klass' has no '_non_existent_attribute' member:INFERENCE
diff --git a/tests/functional/r/regression/regression_4723.py b/tests/functional/r/regression/regression_4723.py
new file mode 100644
index 000000000..012825db0
--- /dev/null
+++ b/tests/functional/r/regression/regression_4723.py
@@ -0,0 +1,21 @@
+"""Latest version of astroid (2.6.3) causes RuntimeError:
+generator raised StopIteration #4723"""
+# pylint: disable=invalid-name,missing-docstring,too-few-public-methods
+
+import contextlib
+
+
+class A:
+    @contextlib.contextmanager
+    def get(self):
+        yield self
+
+
+class B(A):
+    def play():  # [no-method-argument]
+        pass
+
+
+def func():
+    with B().get() as b:
+        b.play()
diff --git a/tests/functional/r/regression/regression_4723.txt b/tests/functional/r/regression/regression_4723.txt
new file mode 100644
index 000000000..abd1fc25b
--- /dev/null
+++ b/tests/functional/r/regression/regression_4723.txt
@@ -0,0 +1 @@
+no-method-argument:15:4:B.play:Method has no argument:HIGH
diff --git a/tests/functional/r/regression/regression_4891.py b/tests/functional/r/regression/regression_4891.py
new file mode 100644
index 000000000..34945e812
--- /dev/null
+++ b/tests/functional/r/regression/regression_4891.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-module-docstring
+# pylint: disable=too-few-public-methods
+import copy
+
+class MyData:
+    '''
+    class docstring
+    '''
+    def __init__(self):
+        self.data = {}
+
+    def process(self):
+        '''
+        another method is responsible for putting "static_key"
+        '''
+        copy.copy(self.data['static_key'])
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 000000000..9ad2eed02
--- /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 000000000..502b452ec
--- /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 000000000..4e6fc4d28
--- /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 000000000..5163b7b7c
--- /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 000000000..0a4b40d7e
--- /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 000000000..bd69d7f7e
--- /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_issue_4631.py b/tests/functional/r/regression/regression_issue_4631.py
new file mode 100644
index 000000000..195c38611
--- /dev/null
+++ b/tests/functional/r/regression/regression_issue_4631.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-function-docstring
+
+"""
+Regression tests for StopIteration raised when using limit-inference-results=0
+"""
+
+
+def get_youtube_link(song_name: str, song_artists):
+    with open("possible errors.txt", "ab") as file:
+        file.write(f"{', '.join(song_artists)} - {song_name}".encode())
diff --git a/tests/functional/r/regression/regression_issue_4631.rc b/tests/functional/r/regression/regression_issue_4631.rc
new file mode 100644
index 000000000..44c9b77ee
--- /dev/null
+++ b/tests/functional/r/regression/regression_issue_4631.rc
@@ -0,0 +1,2 @@
+[testoptions]
+limit-inference-results=0
diff --git a/tests/functional/r/regression/regression_issue_4633.py b/tests/functional/r/regression/regression_issue_4633.py
new file mode 100644
index 000000000..bd9502acd
--- /dev/null
+++ b/tests/functional/r/regression/regression_issue_4633.py
@@ -0,0 +1,22 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-self-use
+
+"""
+Regression tests for https://github.com/PyCQA/pylint/issues/4633
+"""
+
+from queue import Queue
+from unittest.mock import MagicMock
+
+mock = MagicMock(name="mock")
+
+
+class Ham(mock.spam):
+    def __init__(self):
+        self.queue = Queue()
+
+
+class SecondHam:
+    def whatever(self):
+        test_var = Ham()
+        while not test_var.queue.empty():
+            pass
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 000000000..b7be27d3c
--- /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 000000000..6dd2ea491
--- /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 000000000..750b1f951
--- /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 000000000..85fc502b3
--- /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 000000000..6a06a7065
--- /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 000000000..9b754bde3
--- /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 000000000..083f78bdc
--- /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 000000000..784dd90d4
--- /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 000000000..759b7bfe3
--- /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 000000000..e89ae169e
--- /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 000000000..91cf86cfd
--- /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 000000000..d2759adfe
--- /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 000000000..defe51959
--- /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 000000000..c57d14817
--- /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 000000000..03b07c4d6
--- /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 000000000..f947012af
--- /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 000000000..5eb23bf95
--- /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, consider-using-f-string
+
+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 000000000..f60571e7f
--- /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 000000000..786c53bab
--- /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 000000000..29b23efe4
--- /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 000000000..bf0aa064f
--- /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 000000000..f7ecc37f0
--- /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 000000000..449dafd68
--- /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 000000000..b4ae4f359
--- /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 000000000..b244e99f5
--- /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 000000000..8edec28fb
--- /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 000000000..6eaa1f51c
--- /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.txt b/tests/functional/r/reused_outer_loop_variable_py3.txt
new file mode 100644
index 000000000..dcc32e8dc
--- /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 000000000..e69de29bb
--- /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 000000000..c9f2781db
--- /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 000000000..a1262decc
--- /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 000000000..4e63bb422
--- /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 000000000..eeb2ca230
--- /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 000000000..f4f80caf2
--- /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 000000000..5281903bc
--- /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 000000000..32bf36aca
--- /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 000000000..b3552b50f
--- /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 000000000..bcfdf890b
--- /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 000000000..872df8c25
--- /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 000000000..4d4c8b5d4
--- /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 000000000..aa61f4993
--- /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 000000000..4be9fbe3d
--- /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 000000000..fe8d3c384
--- /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.py b/tests/functional/s/singledispatch_functions.py
new file mode 100644
index 000000000..cfd4d873c
--- /dev/null
+++ b/tests/functional/s/singledispatch_functions.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.txt b/tests/functional/s/singledispatch_functions.txt
new file mode 100644
index 000000000..6b26e7794
--- /dev/null
+++ b/tests/functional/s/singledispatch_functions.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 000000000..d7ebdaf24
--- /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 000000000..0907dcb8b
--- /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 000000000..79912b65c
--- /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,  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__ = (f'a{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 000000000..ffe82f8a1
--- /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 000000000..df5de2957
--- /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 000000000..5421c226b
--- /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.txt b/tests/functional/s/star/star_needs_assignment_target.txt
new file mode 100644
index 000000000..57f66931d
--- /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_py37.py b/tests/functional/s/star/star_needs_assignment_target_py37.py
new file mode 100644
index 000000000..fb5eea86a
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target_py37.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_py37.rc b/tests/functional/s/star/star_needs_assignment_target_py37.rc
new file mode 100644
index 000000000..67a28a36a
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.8
diff --git a/tests/functional/s/star/star_needs_assignment_target_py37.txt b/tests/functional/s/star/star_needs_assignment_target_py37.txt
new file mode 100644
index 000000000..a4fa2caea
--- /dev/null
+++ b/tests/functional/s/star/star_needs_assignment_target_py37.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 000000000..53da873d8
--- /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, use-list-literal
+
+# +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 000000000..23ccf9547
--- /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 000000000..59745ce2b
--- /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.txt b/tests/functional/s/statement_without_effect_py36.txt
new file mode 100644
index 000000000..70fc36c6d
--- /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 000000000..822f63369
--- /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.txt b/tests/functional/s/stop_iteration_inside_generator.txt
new file mode 100644
index 000000000..6b1828e87
--- /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 000000000..8372a4373
--- /dev/null
+++ b/tests/functional/s/string/string_formatting.py
@@ -0,0 +1,222 @@
+"""Test for Python 3 string formatting error"""

+

+# pylint: disable=too-few-public-methods, import-error, unused-argument, line-too-long,

+# pylint: disable=useless-object-inheritance, consider-using-f-string

+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) # [format-string-without-interpolation]

+    "{} {".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]

+    "String".format(1)  # [format-string-without-interpolation]

+    "String".format(())  # [format-string-without-interpolation]

+    "String".format([])  # [format-string-without-interpolation]

+    "String".format(None)  # [format-string-without-interpolation]

+

+

+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 000000000..112e4ba6d
--- /dev/null
+++ b/tests/functional/s/string/string_formatting.txt
@@ -0,0 +1,47 @@
+format-string-without-interpolation:68:4:pprint_bad:Using formatting for a string that does not have any interpolated variables
+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
+format-string-without-interpolation:101:4:pprint_bad:Using formatting for a string that does not have any interpolated variables
+format-string-without-interpolation:102:4:pprint_bad:Using formatting for a string that does not have any interpolated variables
+format-string-without-interpolation:103:4:pprint_bad:Using formatting for a string that does not have any interpolated variables
+format-string-without-interpolation:104:4:pprint_bad:Using formatting for a string that does not have any interpolated variables
+too-few-format-args:132:4:nested_issue294:Not enough arguments for format string
+too-many-format-args:133:4:nested_issue294:Too many arguments for format string
+missing-format-argument-key:134:4:nested_issue294:Missing keyword argument 'a' for format string
+missing-format-attribute:135:4:nested_issue294:Missing format attribute 'x' in format specifier 'a.x'
+too-few-format-args:141:4:issue310:Not enough arguments for format string
+too-many-format-args:149:4:issue322:Too many arguments for format string
+too-few-format-args:150:4:issue322:Not enough arguments for format string
+too-few-format-args:175:4:issue351:Not enough arguments for format string
+too-many-format-args:177:4:issue351:Too many arguments for format string
+bad-format-string:213: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 000000000..88f3dcf03
--- /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 000000000..0193339de
--- /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 000000000..f6e390f00
--- /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 000000000..681fedd56
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_error.py
@@ -0,0 +1,24 @@
+"""test string format error"""
+# pylint: disable=unsupported-binary-operation,line-too-long, consider-using-f-string
+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)
+    print("String" % PARG_1) # [format-string-without-interpolation]
+    print("String" % ())  # [format-string-without-interpolation]
+    print("String" % [])  # [format-string-without-interpolation]
+    print("String" % None)  # [format-string-without-interpolation]
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 000000000..9fd27478d
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_error.txt
@@ -0,0 +1,15 @@
+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
+format-string-without-interpolation:21:10:pprint:Using formatting for a string that does not have any interpolated variables
+format-string-without-interpolation:22:10:pprint:Using formatting for a string that does not have any interpolated variables
+format-string-without-interpolation:23:10:pprint:Using formatting for a string that does not have any interpolated variables
+format-string-without-interpolation:24:10:pprint:Using formatting for a string that does not have any interpolated variables
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 000000000..e47ca5baa
--- /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, consider-using-f-string
+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 000000000..f4d3ef34e
--- /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, consider-using-f-string
+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_py3.py b/tests/functional/s/string/string_formatting_py3.py
new file mode 100644
index 000000000..6ab4d8c91
--- /dev/null
+++ b/tests/functional/s/string/string_formatting_py3.py
@@ -0,0 +1,21 @@
+# pylint: disable=missing-docstring,import-error, consider-using-f-string
+
+
+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.txt b/tests/functional/s/string/string_formatting_py3.txt
new file mode 100644
index 000000000..bf90e016b
--- /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 000000000..3bed980f7
--- /dev/null
+++ b/tests/functional/s/string/string_log_formatting.py
@@ -0,0 +1,28 @@
+"""
+Test checking of log format strings
+"""
+
+import logging
+
+
+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 000000000..aec9c26d5
--- /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 000000000..722612442
--- /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 000000000..55b886d0e
--- /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_check.py b/tests/functional/s/subprocess_run_check.py
new file mode 100644
index 000000000..fc4d99d9b
--- /dev/null
+++ b/tests/functional/s/subprocess_run_check.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_check.txt b/tests/functional/s/subprocess_run_check.txt
new file mode 100644
index 000000000..3f854ad08
--- /dev/null
+++ b/tests/functional/s/subprocess_run_check.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 000000000..277feae7e
--- /dev/null
+++ b/tests/functional/s/super/super_checks.py
@@ -0,0 +1,125 @@
+# pylint: disable=too-few-public-methods,import-error, 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 000000000..bd360c831
--- /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 000000000..8ab7c4d71
--- /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 000000000..0e70163ee
--- /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 000000000..f882848f8
--- /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/super/superfluous_parens.py b/tests/functional/s/super/superfluous_parens.py
new file mode 100644
index 000000000..22c4c3ab4
--- /dev/null
+++ b/tests/functional/s/super/superfluous_parens.py
@@ -0,0 +1,67 @@
+"""Test the superfluous-parens warning."""
+# pylint: disable=unneeded-not, unnecessary-comprehension, missing-function-docstring, invalid-name, fixme
+# pylint: disable=import-error, missing-class-docstring, too-few-public-methods
+import numpy as np
+A = 3
+if (A == 5):  # [superfluous-parens]
+    pass
+if not (A == 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']
+
+B = [x for x in ((3, 4))]
+C = [x for x in ((3, 4) if 1 > 0 else (5, 6))]
+D = [x for x in ((3, 4) if 1 > 0 else ((5, 6)))]
+E = [x for x in ((3, 4) if 1 > 0 else ((((5, 6)))))]
+
+# Test assertions
+F = "Version 1.0"
+G = "1.0"
+assert "Version " + G in F
+assert ("Version " + G) in F # [superfluous-parens]
+
+# Test assignment
+H = 2 + (5 * 3)
+NUMS_LIST = ['1', '2', '3']
+NUMS_SET = {'1', '2', '3'}
+NUMS_DICT = {'1': 1, '2': 2, '3': 3}
+I = tuple(x for x in ((a, str(a)) for a in ()))
+
+# Test functions
+def function_A():
+    return (x for x in ((3, 4)))
+
+def function_B(var):
+    return (var.startswith(('A', 'B', 'C')) or var == 'D')
+
+# TODO: Test string combinations, see https://github.com/PyCQA/pylint/issues/4792
+# Lines 45, 46 & 47 should raise the superfluous-parens message
+J = "TestString"
+K = ("Test " + "String")
+L = ("Test " + "String") in I
+assert "" + ("Version " + "String") in I
+
+# Test numpy
+def function_numpy_A(var_1: int, var_2: int) -> np.ndarray:
+    result = (((var_1 & var_2)) > 0)
+    return result.astype(np.float32)
+
+def function_numpy_B(var_1: int, var_2: int) -> np.ndarray:
+    return (((var_1 & var_2)) > 0).astype(np.float32)
+
+# Test Class
+class ClassA:
+    keys = []
+
+    def __iter__(self):
+        return ((k, getattr(self, k)) for k in self.keys)
diff --git a/tests/functional/s/super/superfluous_parens.txt b/tests/functional/s/super/superfluous_parens.txt
new file mode 100644
index 000000000..d07817e3d
--- /dev/null
+++ b/tests/functional/s/super/superfluous_parens.txt
@@ -0,0 +1,6 @@
+superfluous-parens:6:0::Unnecessary parens after 'if' keyword:HIGH
+superfluous-parens:8:0::Unnecessary parens after 'not' keyword:HIGH
+superfluous-parens:12:0::Unnecessary parens after 'for' keyword:HIGH
+superfluous-parens:14:0::Unnecessary parens after 'if' keyword:HIGH
+superfluous-parens:19:0::Unnecessary parens after 'del' keyword:HIGH
+superfluous-parens:31:0::Unnecessary parens after 'assert' keyword:HIGH
diff --git a/tests/functional/s/super/superfluous_parens_walrus_py38.py b/tests/functional/s/super/superfluous_parens_walrus_py38.py
new file mode 100644
index 000000000..cf155954e
--- /dev/null
+++ b/tests/functional/s/super/superfluous_parens_walrus_py38.py
@@ -0,0 +1,51 @@
+"""Test the superfluous-parens warning with python 3.8 functionality (walrus operator)"""
+# pylint: disable=missing-function-docstring, invalid-name, missing-class-docstring, import-error
+import numpy
+
+# Test parens in if statements
+if not (x := False):
+    print(x)
+
+if not (foo := 5):
+    pass
+
+A = 1
+if odd := isinstance(A, int):
+    pass
+
+if not ((x := 1)):  # [superfluous-parens]
+    pass
+
+if ((x := A)):   # [superfluous-parens]
+    pass
+
+if not ((x := A)):  # [superfluous-parens]
+    pass
+
+if not ((((x := 1)))):  # [superfluous-parens]
+    pass
+
+# Test assertions
+assert (ret := str(42))
+
+# Teast 2D arrays with numpy (since they allow commas within indexing)
+ARRAY_2D = numpy.zeros((3, 3), dtype=bool)
+E = not (vals := ARRAY_2D[:, :].all())
+F = not (vals := ARRAY_2D[2, 2].all())
+G = not (vals := ARRAY_2D[::].all())
+H = not (vals := ARRAY_2D[2:2].all())
+
+# Test yield
+class TestYieldClass:
+    @classmethod
+    def function_A(cls):
+        yield (var := 1 + 1)
+        print(var)
+
+    @classmethod
+    def function_B(cls):
+        yield str(1 + 1)
+
+    @classmethod
+    def function_C(cls):
+        yield (1 + 1) # [superfluous-parens]
diff --git a/tests/functional/s/super/superfluous_parens_walrus_py38.rc b/tests/functional/s/super/superfluous_parens_walrus_py38.rc
new file mode 100644
index 000000000..85fc502b3
--- /dev/null
+++ b/tests/functional/s/super/superfluous_parens_walrus_py38.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/s/super/superfluous_parens_walrus_py38.txt b/tests/functional/s/super/superfluous_parens_walrus_py38.txt
new file mode 100644
index 000000000..06ddf23b3
--- /dev/null
+++ b/tests/functional/s/super/superfluous_parens_walrus_py38.txt
@@ -0,0 +1,5 @@
+superfluous-parens:16:0::Unnecessary parens after 'not' keyword:HIGH
+superfluous-parens:19:0::Unnecessary parens after 'if' keyword:HIGH
+superfluous-parens:22:0::Unnecessary parens after 'not' keyword:HIGH
+superfluous-parens:25:0::Unnecessary parens after 'not' keyword:HIGH
+superfluous-parens:51:0::Unnecessary parens after 'yield' keyword:HIGH
diff --git a/tests/functional/s/suspicious_str_strip_call.py b/tests/functional/s/suspicious_str_strip_call.py
new file mode 100644
index 000000000..40684cc1d
--- /dev/null
+++ b/tests/functional/s/suspicious_str_strip_call.py
@@ -0,0 +1,10 @@
+"""Suspicious str.strip calls."""
+# pylint: disable=redundant-u-string-prefix
+__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.txt b/tests/functional/s/suspicious_str_strip_call.txt
new file mode 100644
index 000000000..7e338386c
--- /dev/null
+++ b/tests/functional/s/suspicious_str_strip_call.txt
@@ -0,0 +1,3 @@
+bad-str-strip-call:8:0::Suspicious argument in str.strip call
+bad-str-strip-call:9:0::Suspicious argument in str.lstrip call
+bad-str-strip-call:10: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 000000000..c93df6b05
--- /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 000000000..b47a74525
--- /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 000000000..b56259d02
--- /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 000000000..c93df6b05
--- /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 000000000..29bd3facf
--- /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 000000000..56c75f6f6
--- /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 000000000..c0391859d
--- /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 000000000..b47a74525
--- /dev/null
+++ b/tests/functional/s/sys_stream_regression_1004.rc
@@ -0,0 +1,2 @@
+[testoptions]
+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 000000000..f92121a2c
--- /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 000000000..e69de29bb
--- /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 000000000..deac01e3c
--- /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 000000000..d78aa45a6
--- /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 000000000..d4a4ac2aa
--- /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 000000000..323950d91
--- /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 000000000..58b5a9413
--- /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 000000000..bf780eb96
--- /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 000000000..205f5fc6b
--- /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 000000000..0dd078923
--- /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 000000000..6c1abf4a3
--- /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 000000000..e69de29bb
--- /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 000000000..5ba528f79
--- /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 000000000..a86ba6d81
--- /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 000000000..55fc54484
--- /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 000000000..a17bb22da
--- /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 000000000..2c105ba28
--- /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 000000000..d913ce4ef
--- /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_ancestors_ignored_parents.py b/tests/functional/t/too/too_many_ancestors_ignored_parents.py
new file mode 100644
index 000000000..93598d941
--- /dev/null
+++ b/tests/functional/t/too/too_many_ancestors_ignored_parents.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring, too-few-public-methods, invalid-name
+
+# Inheritance diagram:
+#       F
+#      /
+#  D  E
+#   \/
+#    B  C
+#     \/
+#      A
+#
+# Once `E` is pruned from the tree, we have:
+#  D
+#   \
+#    B  C
+#     \/
+#      A
+#
+# By setting `max-parents=2`, we're able to check that tree-pruning works
+# correctly; in the new diagram, `B` has only 1 parent, so it doesn't raise a
+# message, and `A` has 3, so it does raise a message with the specific number
+# of parents.
+
+class F:
+    """0 parents"""
+
+class E(F):
+    """1 parent"""
+
+class D:
+    """0 parents"""
+
+class B(D, E):
+    """3 parents"""
+
+class C:
+    """0 parents"""
+
+class A(B, C): # [too-many-ancestors]
+    """5 parents"""
diff --git a/tests/functional/t/too/too_many_ancestors_ignored_parents.rc b/tests/functional/t/too/too_many_ancestors_ignored_parents.rc
new file mode 100644
index 000000000..1d06dad25
--- /dev/null
+++ b/tests/functional/t/too/too_many_ancestors_ignored_parents.rc
@@ -0,0 +1,3 @@
+[testoptions]
+max-parents=2
+ignored-parents=functional.t.too.too_many_ancestors_ignored_parents.E
diff --git a/tests/functional/t/too/too_many_ancestors_ignored_parents.txt b/tests/functional/t/too/too_many_ancestors_ignored_parents.txt
new file mode 100644
index 000000000..e1eea426a
--- /dev/null
+++ b/tests/functional/t/too/too_many_ancestors_ignored_parents.txt
@@ -0,0 +1 @@
+too-many-ancestors:39:0:A:Too many ancestors (3/2)
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 000000000..689745e27
--- /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 000000000..d4f551634
--- /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 000000000..e5aa76d75
--- /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_overload.py b/tests/functional/t/too/too_many_arguments_overload.py
new file mode 100644
index 000000000..1155deb0c
--- /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 000000000..e8753859c
--- /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 000000000..6055e7437
--- /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 000000000..7b0b068ad
--- /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 000000000..e5bfd4d49
--- /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 000000000..565b8ec10
--- /dev/null
+++ b/tests/functional/t/too/too_many_instance_attributes.py
@@ -0,0 +1,27 @@
+# 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 000000000..b749ae9a9
--- /dev/null
+++ b/tests/functional/t/too/too_many_instance_attributes.txt
@@ -0,0 +1 @@
+too-many-instance-attributes:4:0:Aaaa:Too many instance attributes (21/7):HIGH
diff --git a/tests/functional/t/too/too_many_instance_attributes_py37.py b/tests/functional/t/too/too_many_instance_attributes_py37.py
new file mode 100644
index 000000000..904475783
--- /dev/null
+++ b/tests/functional/t/too/too_many_instance_attributes_py37.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+from dataclasses import dataclass, InitVar
+
+# InitVars should not count as instance attributes (see issue #3754)
+# Default max_instance_attributes is 7
+@dataclass
+class Hello:
+    a_1: int
+    a_2: int
+    a_3: int
+    a_4: int
+    a_5: int
+    a_6: int
+    a_7: int
+    a_8: InitVar[int]
+
+    def __post_init__(self, a_8):
+        self.a_1 += a_8
diff --git a/tests/functional/t/too/too_many_instance_attributes_py37.rc b/tests/functional/t/too/too_many_instance_attributes_py37.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/t/too/too_many_instance_attributes_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.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 000000000..78e568c23
--- /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 000000000..5c228ac49
--- /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 000000000..1b0866db2
--- /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 000000000..ac38a9e01
--- /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 000000000..4af7f0307
--- /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 000000000..e7c007957
--- /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 000000000..6232b9ff0
--- /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 000000000..11b4b367d
--- /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 000000000..61e47e8eb
--- /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 000000000..b9f35a2ad
--- /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 f"    line 1: {text}\n"
+        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 000000000..5abbb71b3
--- /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 000000000..c1bbfb9d3
--- /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.txt b/tests/functional/t/too/too_many_star_expressions.txt
new file mode 100644
index 000000000..d1e74b624
--- /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 000000000..7de72bc2c
--- /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 000000000..d6d22f237
--- /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 000000000..c723dba13
--- /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 000000000..de60184ca
--- /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.txt b/tests/functional/t/trailing_comma_tuple.txt
new file mode 100644
index 000000000..0f98b2283
--- /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 000000000..8fbadbb3e
--- /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 000000000..2558a71f8
--- /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 000000000..48de809c6
--- /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 000000000..1faabc84a
--- /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 000000000..006a29bf9
--- /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 000000000..81e1fd417
--- /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 000000000..48a043493
--- /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 000000000..a17bb22da
--- /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 000000000..0fab918b9
--- /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 000000000..3ce96b256
--- /dev/null
+++ b/tests/functional/t/typedDict.py
@@ -0,0 +1,31 @@
+"""Test typing.TypedDict"""
+# pylint: disable=invalid-name,missing-class-docstring,pointless-statement
+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})
+
+my_dict = CustomTD(var=1)
+my_dict["var"]
+my_dict["var"] = 2
+
+
+# https://github.com/PyCQA/pylint/issues/4715
+# Instance of TypedDict should be callable
+Link = TypedDict("Link", {"href": str})
+Link(href="foo")
diff --git a/tests/functional/t/typedDict.rc b/tests/functional/t/typedDict.rc
new file mode 100644
index 000000000..85fc502b3
--- /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 000000000..191d9982d
--- /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 000000000..a17bb22da
--- /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 000000000..b92a08722
--- /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.txt b/tests/functional/t/typing_use.txt
new file mode 100644
index 000000000..1ff53a13e
--- /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 000000000..e69de29bb
--- /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 000000000..ed807c0d7
--- /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 000000000..e13d96ab9
--- /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 000000000..68f5fb79a
--- /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/undefined/undefined_loop_variable.py b/tests/functional/u/undefined/undefined_loop_variable.py
new file mode 100644
index 000000000..956773e31
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_loop_variable.py
@@ -0,0 +1,105 @@
+# pylint: disable=missing-docstring,redefined-builtin, consider-using-f-string
+
+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}:  # pylint: disable=use-sequence-for-iteration
+        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]
+
+
+def test(content):
+    # https://github.com/PyCQA/pylint/issues/3711
+    def handle_line(layne):
+        if "X" in layne:
+            layne = layne.replace("X", "Y")
+        elif "Y" in layne:  # line 5
+            layne = '{}'.format(layne)
+        elif "Z" in layne:  # line 7
+            layne = f'{layne}'
+        else:
+            layne = '%s' % layne  # line 10
+
+    for layne in content.split('\n'):
+        handle_line(layne)
+
+
+lst = []
+lst2 = [1, 2, 3]
+
+for item in lst:
+    pass
+
+bigger = [
+    [
+        x for x in lst2 if x > item
+    ]
+    for item in lst
+]
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 000000000..ea194e769
--- /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 000000000..0b92a495d
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable.py
@@ -0,0 +1,330 @@
+# 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
+
+
+# #3711's comment regression test
+lst = []
+lst2 = [1, 2, 3]
+
+for item in lst:
+    pass
+
+bigger = [
+    [
+        x for x in lst2 if x > item
+    ]
+    for item in lst
+]
+
+
+# 3791
+@decorator(x for x in range(3))
+def decorated1(x):
+    print(x)
+
+@decorator(x * x for x in range(3))
+def decorated2(x):
+    print(x)
+
+@decorator(x)  # [undefined-variable]
+@decorator(x * x for x in range(3))
+def decorated3(x):
+    print(x)
+
+@decorator(x * x * y for x in range(3))  # [undefined-variable]
+def decorated4(x):
+    print(x)
diff --git a/tests/functional/u/undefined/undefined_variable.txt b/tests/functional/u/undefined/undefined_variable.txt
new file mode 100644
index 000000000..a6db029bb
--- /dev/null
+++ b/tests/functional/u/undefined/undefined_variable.txt
@@ -0,0 +1,32 @@
+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
+undefined-variable:323:11:decorated3:Undefined variable 'x'
+undefined-variable:328:19:decorated4:Undefined variable 'y'
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 000000000..571efab1c
--- /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 000000000..78d6dd3ea
--- /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.txt b/tests/functional/u/undefined/undefined_variable_py30.txt
new file mode 100644
index 000000000..e40ecd1bc
--- /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 000000000..aba6811b9
--- /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 000000000..607f7d1a5
--- /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 000000000..ace3a8e3f
--- /dev/null
+++ b/tests/functional/u/ungrouped_imports.py
@@ -0,0 +1,34 @@
+"""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
+
+
+# https://github.com/PyCQA/pylint/issues/3382
+# Imports in a `if TYPE_CHECKING` block should not trigger `ungrouped-imports`
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    import re
+    from typing import List
diff --git a/tests/functional/u/ungrouped_imports.txt b/tests/functional/u/ungrouped_imports.txt
new file mode 100644
index 000000000..a23d9997a
--- /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 000000000..2e64ed402
--- /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 000000000..fe6142ff4
--- /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 000000000..d10876929
--- /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 000000000..302bcc2b7
--- /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 000000000..7302b5a42
--- /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 000000000..3e565f9eb
--- /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 000000000..986328512
--- /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 000000000..ed0c011c8
--- /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 000000000..b7ff720d3
--- /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 000000000..3d76f6e66
--- /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 = {}
+[(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 = []
+my_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 000000000..189bcc60e
--- /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 000000000..55dd5688c
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_dict_index_lookup.py
@@ -0,0 +1,84 @@
+# pylint: disable=missing-docstring, too-few-public-methods, expression-not-assigned, line-too-long
+
+a_dict = {}
+b_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])  # Should not emit warning, v != a_dict[k]
+
+for k, v in b_dict.items():
+    k = "another key"
+    print(b_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]
+    unnecessary = 0 # pylint: disable=invalid-name
+    unnecessary += 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
+
+
+# Test false positive described in #4630
+# (https://github.com/PyCQA/pylint/issues/4630)
+
+d = {'key': 'value'}
+
+for k, _ in d.items():
+    d[k] += 'VALUE'
+    if 'V' in d[k]:  # This is fine, if d[k] is replaced with _, the semantics change
+        print('found V')
+
+
+for k, _ in d.items():
+    if 'V' in d[k]:  # [unnecessary-dict-index-lookup]
+        d[k] = "value"
+        print(d[k])  # This is fine
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 000000000..37956ab3f
--- /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:HIGH
+unnecessary-dict-index-lookup:19:36::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:21:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:22:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:22:44::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:24:33::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:26:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:27:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:27:41::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:37:10::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:39:19::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:43:40::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:45:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:46:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:46:52::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:48:37::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:50:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:51:1::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:51:49::Unnecessary dictionary index lookup, use 'v' instead:HIGH
+unnecessary-dict-index-lookup:57:10::Unnecessary dictionary index lookup, use 'item[1]' instead:HIGH
+unnecessary-dict-index-lookup:60:1::Unnecessary dictionary index lookup, use 'item[1]' instead:HIGH
+unnecessary-dict-index-lookup:65:10::Unnecessary dictionary index lookup, use 'item[1]' instead:HIGH
+unnecessary-dict-index-lookup:82:14::Unnecessary dictionary index lookup, use '_' instead:HIGH
diff --git a/tests/functional/u/unnecessary/unnecessary_lambda.py b/tests/functional/u/unnecessary/unnecessary_lambda.py
new file mode 100644
index 000000000..91f6bf86d
--- /dev/null
+++ b/tests/functional/u/unnecessary/unnecessary_lambda.py
@@ -0,0 +1,53 @@
+# pylint: disable=undefined-variable, use-list-literal

+"""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 000000000..c3983b195
--- /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 000000000..97acecd73
--- /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 000000000..722f26d40
--- /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 000000000..c2733096a
--- /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 000000000..6eabcf5bd
--- /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 000000000..59d9abbe4
--- /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 000000000..1c5fb16b8
--- /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.txt b/tests/functional/u/unpacking_generalizations.txt
new file mode 100644
index 000000000..96c476cc2
--- /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 000000000..b7ea2189c
--- /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
+# 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 000000000..0ac2bc29a
--- /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/unpacking_non_sequence_py37.py b/tests/functional/u/unpacking_non_sequence_py37.py
new file mode 100644
index 000000000..dd8af1136
--- /dev/null
+++ b/tests/functional/u/unpacking_non_sequence_py37.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring
+
+# https://github.com/PyCQA/pylint/issues/4895
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+
+@dataclass
+class Metric:
+    function: Callable[..., tuple[int, int]]
+
+    def update(self):
+        _, _ = self.function()
diff --git a/tests/functional/u/unpacking_non_sequence_py37.rc b/tests/functional/u/unpacking_non_sequence_py37.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/u/unpacking_non_sequence_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/u/unreachable.py b/tests/functional/u/unreachable.py
new file mode 100644
index 000000000..2c71f6cf4
--- /dev/null
+++ b/tests/functional/u/unreachable.py
@@ -0,0 +1,35 @@
+# 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]
+
+
+# https://github.com/PyCQA/pylint/issues/4698
+def func5():
+    """Empty generator functions should be allowed."""
+    return
+    yield
+
+def func6():
+    """Add 'unreachable' if yield is followed by another node."""
+    return
+    yield
+    print("unreachable")  # [unreachable]
diff --git a/tests/functional/u/unreachable.txt b/tests/functional/u/unreachable.txt
new file mode 100644
index 000000000..19108724c
--- /dev/null
+++ b/tests/functional/u/unreachable.txt
@@ -0,0 +1,5 @@
+unreachable:7:4:func1:Unreachable code
+unreachable:12:8:func2:Unreachable code
+unreachable:18:8:func3:Unreachable code
+unreachable:22:4:func4:Unreachable code
+unreachable:35:4:func6: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 000000000..3163b1ea6
--- /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 000000000..a89373326
--- /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/unspecified_encoding_py38.py b/tests/functional/u/unspecified_encoding_py38.py
new file mode 100644
index 000000000..8f143474b
--- /dev/null
+++ b/tests/functional/u/unspecified_encoding_py38.py
@@ -0,0 +1,82 @@
+"""Warnings for using open() without specifying an encoding"""
+# pylint: disable=consider-using-with
+import io
+import locale
+from pathlib import Path
+
+FILENAME = "foo.bar"
+open(FILENAME, "w", encoding="utf-8")
+open(FILENAME, "wb")
+open(FILENAME, "w+b")
+open(FILENAME)  # [unspecified-encoding]
+open(FILENAME, "wt")  # [unspecified-encoding]
+open(FILENAME, "w+")  # [unspecified-encoding]
+open(FILENAME, "w", encoding=None)  # [unspecified-encoding]
+open(FILENAME, "r")  # [unspecified-encoding]
+
+with open(FILENAME, encoding="utf8", errors="surrogateescape") as f:
+    pass
+
+LOCALE_ENCODING = locale.getlocale()[1]
+with open(FILENAME, encoding=LOCALE_ENCODING) as f:
+    pass
+
+with open(FILENAME) as f:  # [unspecified-encoding]
+    pass
+
+with open(FILENAME, encoding=None) as f:  # [unspecified-encoding]
+    pass
+
+LOCALE_ENCODING = None
+with open(FILENAME, encoding=LOCALE_ENCODING) as f:  # [unspecified-encoding]
+    pass
+
+io.open(FILENAME, "w+b")
+io.open_code(FILENAME)
+io.open(FILENAME)  # [unspecified-encoding]
+io.open(FILENAME, "wt")  # [unspecified-encoding]
+io.open(FILENAME, "w+")  # [unspecified-encoding]
+io.open(FILENAME, "w", encoding=None)  # [unspecified-encoding]
+
+with io.open(FILENAME, encoding="utf8", errors="surrogateescape") as f:
+    pass
+
+LOCALE_ENCODING = locale.getlocale()[1]
+with io.open(FILENAME, encoding=LOCALE_ENCODING) as f:
+    pass
+
+with io.open(FILENAME) as f:  # [unspecified-encoding]
+    pass
+
+with io.open(FILENAME, encoding=None) as f:  # [unspecified-encoding]
+    pass
+
+LOCALE_ENCODING = None
+with io.open(FILENAME, encoding=LOCALE_ENCODING) as f:  # [unspecified-encoding]
+    pass
+
+LOCALE_ENCODING = locale.getlocale()[1]
+Path(FILENAME).read_text(encoding=LOCALE_ENCODING)
+Path(FILENAME).read_text(encoding="utf8")
+
+LOCALE_ENCODING = None
+Path(FILENAME).read_text()  # [unspecified-encoding]
+Path(FILENAME).read_text(encoding=None)  # [unspecified-encoding]
+Path(FILENAME).read_text(encoding=LOCALE_ENCODING)  # [unspecified-encoding]
+
+LOCALE_ENCODING = locale.getlocale()[1]
+Path(FILENAME).write_text("string", encoding=LOCALE_ENCODING)
+Path(FILENAME).write_text("string", encoding="utf8")
+
+LOCALE_ENCODING = None
+Path(FILENAME).write_text("string")  # [unspecified-encoding]
+Path(FILENAME).write_text("string", encoding=None)  # [unspecified-encoding]
+Path(FILENAME).write_text("string", encoding=LOCALE_ENCODING)  # [unspecified-encoding]
+
+LOCALE_ENCODING = locale.getlocale()[1]
+Path(FILENAME).open("w+b")
+Path(FILENAME).open()  # [unspecified-encoding]
+Path(FILENAME).open("wt")  # [unspecified-encoding]
+Path(FILENAME).open("w+")  # [unspecified-encoding]
+Path(FILENAME).open("w", encoding=None)  # [unspecified-encoding]
+Path(FILENAME).open("w", encoding=LOCALE_ENCODING)
diff --git a/tests/functional/u/unspecified_encoding_py38.rc b/tests/functional/u/unspecified_encoding_py38.rc
new file mode 100644
index 000000000..85fc502b3
--- /dev/null
+++ b/tests/functional/u/unspecified_encoding_py38.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/u/unspecified_encoding_py38.txt b/tests/functional/u/unspecified_encoding_py38.txt
new file mode 100644
index 000000000..832b3c750
--- /dev/null
+++ b/tests/functional/u/unspecified_encoding_py38.txt
@@ -0,0 +1,25 @@
+unspecified-encoding:11:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:12:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:13:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:14:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:15:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:24:5::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:27:5::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:31:5::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:36:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:37:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:38:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:39:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:48:5::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:51:5::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:55:5::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:63:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:64:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:65:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:72:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:73:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:74:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:78:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:79:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:80:0::Using open without explicitly specifying an encoding:HIGH
+unspecified-encoding:81:0::Using open without explicitly specifying an encoding:HIGH
diff --git a/tests/functional/u/unsubscriptable_value.py b/tests/functional/u/unsubscriptable_value.py
new file mode 100644
index 000000000..6a97cc4c8
--- /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, redundant-u-string-prefix
+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 000000000..6a8ee96ca
--- /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 000000000..c95e05cdc
--- /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 000000000..acbbe6bdd
--- /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 000000000..a17bb22da
--- /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 000000000..b5959971a
--- /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 000000000..c0b58668a
--- /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 000000000..6a8ee96ca
--- /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 000000000..854e8bfec
--- /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 000000000..0bfe1d16a
--- /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 000000000..401ccfe27
--- /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 000000000..00e43cbdc
--- /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 000000000..3c2882a64
--- /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 000000000..6a8ee96ca
--- /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 000000000..6ad92eb33
--- /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 000000000..e69de29bb
--- /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 000000000..a3fd4e6ab
--- /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,  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, f'{etype} X',
+                    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 000000000..b1ad4ad5a
--- /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 000000000..4d0fd9adc
--- /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.txt b/tests/functional/u/unused/unused_argument_py3.txt
new file mode 100644
index 000000000..2bddb5184
--- /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 000000000..e630c3337
--- /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 000000000..62224096e
--- /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 000000000..5dcd4a84c
--- /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 000000000..a670aa0e0
--- /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 000000000..896789eda
--- /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 000000000..aef49d68c
--- /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 000000000..5dcd4a84c
--- /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 000000000..67e6da979
--- /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 000000000..3bf17c6c9
--- /dev/null
+++ b/tests/functional/u/unused/unused_import.py
@@ -0,0 +1,63 @@
+"""unused import"""
+# pylint: disable=undefined-all-variable, import-error,  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 000000000..79ac42d10
--- /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 000000000..fb339bce7
--- /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 000000000..0d6b59987
--- /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 000000000..7d6cce74c
--- /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 000000000..a9f89cf84
--- /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 000000000..693a377d9
--- /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 000000000..85fc502b3
--- /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 000000000..95fed2055
--- /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 000000000..1a2ff4fb9
--- /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 000000000..292d40f95
--- /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=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 000000000..ba7628ba8
--- /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 000000000..319a06d88
--- /dev/null
+++ b/tests/functional/u/unused/unused_private_member.py
@@ -0,0 +1,302 @@
+# 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
+
+
+class Bla:
+    """Regression test for issue 4638"""
+
+    def __init__(self):
+        type(self).__a()
+        self.__b()
+        Bla.__c()
+
+    @classmethod
+    def __a(cls):
+        pass
+
+    @classmethod
+    def __b(cls):
+        pass
+
+    @classmethod
+    def __c(cls):
+        pass
+
+
+class Klass:
+    """Regression test for 4644"""
+
+    __seventyseven = 77
+    __ninetyone = 91
+
+    def __init__(self):
+        self.twentyone = 21 * (1 / (self.__seventyseven + 33)) % 100
+        self.ninetyfive = Klass.__ninetyone + 4
+
+
+k = Klass()
+print(k.twentyone)
+print(k.ninetyfive)
+
+# https://github.com/PyCQA/pylint/issues/4657
+# Mutation of class member with cls should not fire a false-positive
+class FalsePositive4657:
+    """False positivie tests for 4657"""
+    __attr_a = None
+    __attr_b = 'b'
+
+    @classmethod
+    def load_attrs(cls):
+        """Load attributes."""
+        cls.__attr_a = 'a'
+
+    @property
+    def attr_a(self):
+        """Get a."""
+        return self.__attr_a
+
+    @property
+    def attr_b(self):
+        """Get b."""
+        return self.__attr_b
+
+    # Test cases where we assign self.attr, but try to
+    # access cls.attr
+
+    def __init__(self):
+        self.__attr_c = "this is an unused private instance attribute"  # [unused-private-member]
+
+    @property
+    def attr_c(self):
+        """Get c."""
+        return cls.__attr_c  # [undefined-variable]
+
+
+# https://github.com/PyCQA/pylint/issues/4668
+# Attributes assigned within __new__() has to be processed as part of the class
+class FalsePositive4668:
+    # pylint: disable=protected-access, no-member, unreachable
+
+    def __new__(cls, func, *args):
+        if args:
+            true_obj = super(FalsePositive4668, cls).__new__(cls)
+            true_obj.func = func
+            true_obj.__args = args  # Do not emit message here
+            return true_obj
+
+        false_obj = super(FalsePositive4668, cls).__new__(cls)
+        false_obj.func = func
+        false_obj.__args = args  # Do not emit message here
+        false_obj.__secret_bool = False
+        false_obj.__unused = None  # [unused-private-member]
+        return false_obj
+        # unreachable but non-Name return value
+        return 3+4
+
+    def exec(self):
+        print(self.__secret_bool)
+        return self.func(*self.__args)
+
+
+# https://github.com/PyCQA/pylint/issues/4673
+# Nested functions shouldn't cause a false positive if they are properly used
+class FalsePositive4673:
+    """ The testing class """
+
+    def __init__(self, in_thing):
+        self.thing = False
+        self.do_thing(in_thing)
+
+    def do_thing(self, in_thing):
+        """ Checks the false-positive condition, sets a property. """
+        def __false_positive(in_thing):
+            print(in_thing)
+
+        def __true_positive(in_thing):  # [unused-private-member]
+            print(in_thing)
+
+        __false_positive(in_thing)
+        self.thing = True
+
+    def undo_thing(self):
+        """ Unsets a property. """
+        self.thing = False
+
+    def complicated_example(self, flag):
+        def __inner_1():
+            pass
+
+        def __inner_2():
+            pass
+
+        def __inner_3(fn):
+            return fn
+
+        def __inner_4():  # [unused-private-member]
+            pass
+
+        fn_to_return = __inner_1 if flag else __inner_3(__inner_2)
+        return fn_to_return
+
+
+# https://github.com/PyCQA/pylint/issues/4755
+# Nested attributes shouldn't cause crash
+class Crash4755Context:
+    def __init__(self):
+        self.__messages = None  # [unused-private-member]
+
+class Crash4755Command:
+    def __init__(self):
+        self.context = Crash4755Context()
+
+    def method(self):
+        self.context.__messages = []
+        for message in self.context.__messages:
+            print(message)
+
+
+# https://github.com/PyCQA/pylint/issues/4681
+# Accessing attributes of the class using the class name should not result in a false positive
+# as long as it is used within the class
+class FalsePositive4681:
+    __instance = None
+    __should_cause_error = None  # [unused-private-member]
+    @staticmethod
+    def instance():
+        if FalsePositive4681.__instance is None:
+            FalsePositive4681()
+        return FalsePositive4681.__instance
+
+    def __init__(self):
+        try:
+            FalsePositive4681.__instance = 42  # This should be fine
+            FalsePositive4681.__should_cause_error = True  # [unused-private-member]
+        except Exception:  # pylint: disable=broad-except
+            print("Error")
+            FalsePositive4681.__instance = False  # This should be fine
+            FalsePositive4681.__should_cause_error = False  # [unused-private-member]
+
+# Accessing attributes of the class using `cls` should not result in a false positive
+# as long as it is used within the class
+class FalsePositive4681b:
+    __instance = None
+
+    @classmethod  # Use class method here
+    def instance(cls):
+        if cls.__instance is None:
+            cls()
+        return cls.__instance
+
+    def __init__(self):
+        try:
+            FalsePositive4681b.__instance = 42  # This should be fine
+        except Exception:  # pylint: disable=broad-except
+            print("Error")
+            FalsePositive4681b.__instance = False  # This should be fine
+
+
+# https://github.com/PyCQA/pylint/issues/4849
+# Accessing private static methods from classmethods via `cls` should not result in a
+# false positive
+class FalsePositive4849:
+    @staticmethod
+    def __private_method():
+        """Is private and does nothing."""
+
+    # This should already be covered by `HasUnusedInClass`
+    @staticmethod
+    def __unused_private_method():  # [unused-private-member]
+        """Is not used."""
+
+    @classmethod
+    def use_private_method(cls):
+        """Calls private method."""
+        cls.__private_method()  # This should pass
+
+
+class Pony:
+    """https://github.com/PyCQA/pylint/issues/4837"""
+    __defaults = {}
+    __defaults_set = False
+
+    def __init__(self, value):
+        self.value = value
+
+    def __init_defaults(self):  # [unused-private-member]
+        if not self.__defaults_set:
+            type(self).__defaults = { "fur": "pink" }
+            type(self).__defaults_set = True
+
+    def __get_fur_color(self):  # [unused-private-member]
+        color = lookup_attribute(self.__defaults, "fur")
+        return color
+
+
+def lookup_attribute(mapping, key):
+    return mapping[key]
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 000000000..08adc8c15
--- /dev/null
+++ b/tests/functional/u/unused/unused_private_member.txt
@@ -0,0 +1,19 @@
+unused-private-member:4:4:AnotherClass.__test:Unused private member `AnotherClass.__test(self)`:HIGH
+unused-private-member:8:4:HasUnusedInClass:Unused private member `HasUnusedInClass.__my_secret`:HIGH
+unused-private-member:12:4:HasUnusedInClass.__private_class_method_unused:Unused private member `HasUnusedInClass.__private_class_method_unused(cls)`:HIGH
+unused-private-member:20:4:HasUnusedInClass.__private_static_method_unused:Unused private member `HasUnusedInClass.__private_static_method_unused()`:HIGH
+unused-private-member:28:8:HasUnusedInClass.__init__:Unused private member `HasUnusedInClass.__instance_secret`:HIGH
+unused-private-member:34:4:HasUnusedInClass.__test:Unused private member `HasUnusedInClass.__test(self, x, y, z)`:HIGH
+unused-private-member:55:4:HasUnusedInClass.__test_recursive:Unused private member `HasUnusedInClass.__test_recursive(self)`:HIGH
+unused-private-member:133:8:FalsePositive4657.__init__:Unused private member `FalsePositive4657.__attr_c`:HIGH
+undefined-variable:138:15:FalsePositive4657.attr_c:Undefined variable 'cls':HIGH
+unused-private-member:157:8:FalsePositive4668.__new__:Unused private member `FalsePositive4668.__unused`:HIGH
+unused-private-member:181:8:FalsePositive4673.do_thing.__true_positive:Unused private member `FalsePositive4673.do_thing.__true_positive(in_thing)`:HIGH
+unused-private-member:201:8:FalsePositive4673.complicated_example.__inner_4:Unused private member `FalsePositive4673.complicated_example.__inner_4()`:HIGH
+unused-private-member:212:8:Crash4755Context.__init__:Unused private member `Crash4755Context.__messages`:HIGH
+unused-private-member:229:4:FalsePositive4681:Unused private member `FalsePositive4681.__should_cause_error`:HIGH
+unused-private-member:239:12:FalsePositive4681.__init__:Unused private member `FalsePositive4681.__should_cause_error`:HIGH
+unused-private-member:243:12:FalsePositive4681.__init__:Unused private member `FalsePositive4681.__should_cause_error`:HIGH
+unused-private-member:274:4:FalsePositive4849.__unused_private_method:Unused private member `FalsePositive4849.__unused_private_method()`:HIGH
+unused-private-member:291:4:Pony.__init_defaults:Unused private member `Pony.__init_defaults(self)`:HIGH
+unused-private-member:296:4:Pony.__get_fur_color:Unused private member `Pony.__get_fur_color(self)`:HIGH
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 000000000..7de4e411b
--- /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 000000000..b47a74525
--- /dev/null
+++ b/tests/functional/u/unused/unused_typing_imports.rc
@@ -0,0 +1,2 @@
+[testoptions]
+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 000000000..d5afd8f2b
--- /dev/null
+++ b/tests/functional/u/unused/unused_variable.py
@@ -0,0 +1,174 @@
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods, no-self-use, useless-object-inheritance,import-outside-toplevel, fixme, line-too-long
+
+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)
+
+from astroid import nodes
+def visit_if(self, node: nodes.If) -> None:
+    """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-variable-not-assigned, global-variable-not-assigned]
+    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:  # [unused-variable]
+            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")
+
+
+def main(lst):
+    """https://github.com/PyCQA/astroid/pull/1111#issuecomment-890367609"""
+    try:
+        raise ValueError
+    except ValueError as e:  # [unused-variable]
+        pass
+
+    for e in lst:
+        pass
+
+    # e will be undefined if lst is empty
+    print(e)  # [undefined-loop-variable]
+
+main([])
diff --git a/tests/functional/u/unused/unused_variable.txt b/tests/functional/u/unused/unused_variable.txt
new file mode 100644
index 000000000..bfe5dc91b
--- /dev/null
+++ b/tests/functional/u/unused/unused_variable.txt
@@ -0,0 +1,26 @@
+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-variable-not-assigned:97:4:test_global:Using global for 'PATH' but no assignment is done:HIGH
+global-variable-not-assigned:97:4:test_global:Using global for 'deque' but no assignment is done:HIGH
+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:147:8:func3:Unused variable 'error'
+unused-variable:153:4:func4:Unused variable 'error'
+unused-variable:165:4:main:Unused variable 'e'
+undefined-loop-variable:172:10:main:Using possibly undefined loop variable 'e'
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 000000000..396d02805
--- /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/use/use_a_generator.py b/tests/functional/u/use/use_a_generator.py
new file mode 100644
index 000000000..279deb46f
--- /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 000000000..e7be228f0
--- /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_literal_dict.py b/tests/functional/u/use/use_literal_dict.py
new file mode 100644
index 000000000..3377b4e63
--- /dev/null
+++ b/tests/functional/u/use/use_literal_dict.py
@@ -0,0 +1,7 @@
+# pylint: disable=missing-docstring, invalid-name
+
+x = dict()  # [use-dict-literal]
+x = dict(a="1", b=None, c=3)
+x = dict(zip(["a", "b", "c"], [1, 2, 3]))
+x = {}
+x = {"a": 1, "b": 2, "c": 3}
diff --git a/tests/functional/u/use/use_literal_dict.txt b/tests/functional/u/use/use_literal_dict.txt
new file mode 100644
index 000000000..eede5530d
--- /dev/null
+++ b/tests/functional/u/use/use_literal_dict.txt
@@ -0,0 +1 @@
+use-dict-literal:3:4::"Consider using {} instead of dict()"
diff --git a/tests/functional/u/use/use_literal_list.py b/tests/functional/u/use/use_literal_list.py
new file mode 100644
index 000000000..78614a49d
--- /dev/null
+++ b/tests/functional/u/use/use_literal_list.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring, invalid-name
+
+x = list()  # [use-list-literal]
+x = list("string")
+x = list(range(3))
+x = []
+x = ["string"]
+x = [1, 2, 3]
+x = [range(3)]
diff --git a/tests/functional/u/use/use_literal_list.txt b/tests/functional/u/use/use_literal_list.txt
new file mode 100644
index 000000000..07987027d
--- /dev/null
+++ b/tests/functional/u/use/use_literal_list.txt
@@ -0,0 +1 @@
+use-list-literal:3:4::"Consider using [] instead of list()"
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 000000000..396da3adc
--- /dev/null
+++ b/tests/functional/u/use/use_maxsplit_arg.py
@@ -0,0 +1,92 @@
+"""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]

+

+# Test cases for false-positive reported in #4664

+# https://github.com/PyCQA/pylint/issues/4664

+source = 'A.B.C.D.E.F.G'

+i = 0

+for j in range(5):

+    print(source.split('.')[i])

+    i = i + 1

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 000000000..8137374aa
--- /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_sequence_for_iteration.py b/tests/functional/u/use/use_sequence_for_iteration.py
new file mode 100644
index 000000000..2dd1feb18
--- /dev/null
+++ b/tests/functional/u/use/use_sequence_for_iteration.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring,pointless-statement,unnecessary-comprehension
+
+var = {1, 2, 3}
+
+for x in var:
+    pass
+for x in {1, 2, 3}:  # [use-sequence-for-iteration]
+    pass
+
+(x for x in var)
+(x for x in {1, 2, 3})  # [use-sequence-for-iteration]
+
+[x for x in var]
+[x for x in {1, 2, 3}]  # [use-sequence-for-iteration]
+
+[x for x in {*var, 4}]  # [use-sequence-for-iteration]
diff --git a/tests/functional/u/use/use_sequence_for_iteration.txt b/tests/functional/u/use/use_sequence_for_iteration.txt
new file mode 100644
index 000000000..615df8a30
--- /dev/null
+++ b/tests/functional/u/use/use_sequence_for_iteration.txt
@@ -0,0 +1,4 @@
+use-sequence-for-iteration:7:9::Use a sequence type when iterating over values:HIGH
+use-sequence-for-iteration:11:12::Use a sequence type when iterating over values:HIGH
+use-sequence-for-iteration:14:12::Use a sequence type when iterating over values:HIGH
+use-sequence-for-iteration:16:12::Use a sequence type when iterating over values:HIGH
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 000000000..4b826d7ca
--- /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,w0223   # [use-symbolic-message-instead,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 000000000..ba4b729f6
--- /dev/null
+++ b/tests/functional/u/use/use_symbolic_message_instead.txt
@@ -0,0 +1,14 @@
+bad-option-value:1:0::Bad option value 'T1234':HIGH
+use-symbolic-message-instead:1:0::"'C0111' is cryptic: use '# pylint: disable=missing-docstring' instead":HIGH
+use-symbolic-message-instead:1:0::"'R0903' is cryptic: use '# pylint: disable=too-few-public-methods' instead":HIGH
+use-symbolic-message-instead:2:0::"'c0111' is cryptic: use '# pylint: enable=missing-docstring' instead":HIGH
+use-symbolic-message-instead:2:0::"'w0223' is cryptic: use '# pylint: enable=abstract-method' instead":HIGH
+missing-function-docstring:4:0:my_function:Missing function or method docstring:HIGH
+use-symbolic-message-instead:7:0::"'C0111' is cryptic: use '# pylint: disable=missing-docstring' instead":HIGH
+use-symbolic-message-instead:8:0::"'R0903' is cryptic: use '# pylint: enable=too-few-public-methods' instead":HIGH
+use-symbolic-message-instead:9:0::"'R0903' is cryptic: use '# pylint: disable=too-few-public-methods' instead":HIGH
+use-symbolic-message-instead:12:0::"'C0102' is cryptic: use '# pylint: disable=blacklisted-name' instead":HIGH
+use-symbolic-message-instead:16:0::"'C0102' is cryptic: use '# pylint: disable=blacklisted-name' instead":HIGH
+use-symbolic-message-instead:16:0::"'R1711' is cryptic: use '# pylint: disable=useless-return' instead":HIGH
+missing-function-docstring:20:0:test_enabled_by_id_msg:Missing function or method docstring:HIGH
+use-symbolic-message-instead:20:0::"'C0111' is cryptic: use '# pylint: enable=missing-docstring' instead":HIGH
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 000000000..285f3d180
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignement.py
@@ -0,0 +1,8 @@
+"""pylint doesn't see the NameError in this module"""
+#pylint: disable=consider-using-f-string
+__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 000000000..d19fe322a
--- /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 000000000..efc133c2b
--- /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 000000000..0c59ccebe
--- /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 000000000..4d43c4ad2
--- /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_issue626.py b/tests/functional/u/use/used_before_assignment_issue626.py
new file mode 100644
index 000000000..c98632b7f
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_issue626.py
@@ -0,0 +1,44 @@
+# pylint: disable=missing-docstring,invalid-name
+def main1():
+    try:
+        raise ValueError
+    except ValueError as e:  # [unused-variable]
+        pass
+
+    print(e)  # [used-before-assignment]
+
+
+def main2():
+    try:
+        raise ValueError
+    except ValueError as e:
+        print(e)
+
+
+def main3():
+    try:
+        raise ValueError
+    except ValueError as e:  # [unused-variable]
+        pass
+
+    e = 10
+    print(e)
+
+
+def main4():
+    try:
+        raise ValueError
+    except ValueError as e:  # [unused-variable]
+        pass
+
+    try:
+        raise ValueError
+    except ValueError as e:
+        pass
+
+    try:
+        raise ValueError
+    except ValueError as e:
+        pass
+
+    print(e)  # [used-before-assignment]
diff --git a/tests/functional/u/use/used_before_assignment_issue626.txt b/tests/functional/u/use/used_before_assignment_issue626.txt
new file mode 100644
index 000000000..e7e56c195
--- /dev/null
+++ b/tests/functional/u/use/used_before_assignment_issue626.txt
@@ -0,0 +1,5 @@
+unused-variable:5:4:main1:Unused variable 'e'
+used-before-assignment:8:10:main1:Using variable 'e' before assignment
+unused-variable:21:4:main3:Unused variable 'e'
+unused-variable:31:4:main4:Unused variable 'e'
+used-before-assignment:44:10:main4:Using variable 'e' before assignment
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 000000000..7da9fdd50
--- /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, consider-using-f-string
+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 000000000..5cbdd510c
--- /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.txt b/tests/functional/u/use/used_before_assignment_nonlocal.txt
new file mode 100644
index 000000000..59aa0756d
--- /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 000000000..079501022
--- /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.txt b/tests/functional/u/use/used_prior_global_declaration.txt
new file mode 100644
index 000000000..2354e0ef8
--- /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 000000000..74b8a9c1a
--- /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
+# pylint: disable=use-list-literal, use-dict-literal
+
+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 000000000..9d112272f
--- /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 000000000..d686f4658
--- /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 000000000..dff8e318a
--- /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 000000000..562c81f6a
--- /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 000000000..1b18607fa
--- /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 000000000..61aaebe7a
--- /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 000000000..9299b458a
--- /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 000000000..002c7eb03
--- /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 000000000..d2dae5603
--- /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 000000000..b32ced873
--- /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.txt b/tests/functional/u/useless/useless_super_delegation_py3.txt
new file mode 100644
index 000000000..3a1fdaa1a
--- /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 000000000..16030f8a4
--- /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.txt b/tests/functional/u/useless/useless_super_delegation_py35.txt
new file mode 100644
index 000000000..672ce197e
--- /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 000000000..ec402299f
--- /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 000000000..85fc502b3
--- /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 000000000..333444554
--- /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/u/useless/useless_type_doc.py b/tests/functional/u/useless/useless_type_doc.py
new file mode 100644
index 000000000..6714755fd
--- /dev/null
+++ b/tests/functional/u/useless/useless_type_doc.py
@@ -0,0 +1,72 @@
+"""demonstrate FP with useless-type-doc"""
+
+
+def function(public_param: int, _some_private_param: bool = False) -> None:
+    """does things
+
+    Args:
+        public_param: an ordinary parameter
+    """
+    for _ in range(public_param):
+        ...
+    if _some_private_param:
+        ...
+    else:
+        ...
+
+
+def smart_function(public_param: int, _some_private_param: bool = False) -> None:
+    """We're speaking about _some_private_param without really documenting it.
+
+    Args:
+        public_param: an ordinary parameter
+    """
+    for _ in range(public_param):
+        ...
+    if _some_private_param:
+        ...
+    else:
+        ...
+
+
+# +1: [useless-type-doc,useless-param-doc]
+def function_useless_doc(public_param: int, _some_private_param: bool = False) -> None:
+    """does things
+
+    Args:
+        public_param: an ordinary parameter
+        _some_private_param (bool): private param
+
+    """
+    for _ in range(public_param):
+        ...
+    if _some_private_param:
+        ...
+    else:
+        ...
+
+
+def test(_new: str) -> str:
+    """foobar
+
+    :return: comment
+    """
+    return ""
+
+
+def smarter_test(_new: str) -> str:
+    """We're speaking about _new without really documenting it.
+
+    :return: comment
+    """
+    return ""
+
+
+# +1: [useless-type-doc,useless-param-doc]
+def test_two(_new: str) -> str:
+    """foobar
+
+    :param str _new:
+    :return: comment
+    """
+    return ""
diff --git a/tests/functional/u/useless/useless_type_doc.rc b/tests/functional/u/useless/useless_type_doc.rc
new file mode 100644
index 000000000..d4a6dc172
--- /dev/null
+++ b/tests/functional/u/useless/useless_type_doc.rc
@@ -0,0 +1,8 @@
+[MASTER]
+load-plugins=pylint.extensions.docparams,
+
+[PARAMETER_DOCUMENTATION]
+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/u/useless/useless_type_doc.txt b/tests/functional/u/useless/useless_type_doc.txt
new file mode 100644
index 000000000..20083ed79
--- /dev/null
+++ b/tests/functional/u/useless/useless_type_doc.txt
@@ -0,0 +1,4 @@
+useless-param-doc:33:0:function_useless_doc:"""_some_private_param"" useless ignored parameter documentation":HIGH
+useless-type-doc:33:0:function_useless_doc:"""_some_private_param"" useless ignored parameter type documentation":HIGH
+useless-param-doc:66:0:test_two:"""_new"" useless ignored parameter documentation":HIGH
+useless-type-doc:66:0:test_two:"""_new"" useless ignored parameter type documentation":HIGH
diff --git a/tests/functional/w/__init__.py b/tests/functional/w/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..4034162e0
--- /dev/null
+++ b/tests/functional/w/wildcard_import.py
@@ -0,0 +1,5 @@
+# pylint: disable=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 000000000..67721a6e5
--- /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 000000000..21fea4738
--- /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 000000000..c46d828f6
--- /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 000000000..6413af27a
--- /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 000000000..ebe7d3093
--- /dev/null
+++ b/tests/functional/w/with_used_before_assign.py
@@ -0,0 +1,12 @@
+"""
+Regression test for
+https://bitbucket.org/logilab/pylint/issue/128/attributeerror-when-parsing
+"""
+from __future__ import with_statement
+
+
+def do_nothing():
+    """ empty """
+    with open("", encoding="utf-8") 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 000000000..8e1fe1be8
--- /dev/null
+++ b/tests/functional/w/with_used_before_assign.txt
@@ -0,0 +1,2 @@
+undefined-variable:10:39:do_nothing:Undefined variable 'ctx'
+used-before-assignment:11: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 000000000..187bdcfea
--- /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 000000000..6bd65fbe7
--- /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 000000000..1c3c4e380
--- /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 000000000..05624a3a0
--- /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 000000000..ed0615b0c
--- /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 000000000..e520ef219
--- /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 000000000..7157512dd
--- /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 000000000..c06f9da1f
--- /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 000000000..22c426726
--- /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 000000000..f4a868039
--- /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 000000000..9af72c0e5
--- /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 000000000..a08aaa95c
--- /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 000000000..300968c40
--- /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 000000000..ca655ff5b
--- /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 000000000..6b3d03463
--- /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 000000000..5010d9db4
--- /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 000000000..f5c9a03e5
--- /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 000000000..22e09e25a
--- /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 000000000..58a19b66c
--- /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 000000000..d7441b465
--- /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 000000000..a1808a8fd
--- /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 000000000..96f39ce8d
--- /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 000000000..ff9c28cd7
--- /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 000000000..e719d2cb9
--- /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 000000000..58a79b84b
--- /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 000000000..531d9ca5f
--- /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 000000000..232c453cc
--- /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 000000000..05f680377
--- /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 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/y/__init__.py
diff --git a/tests/functional/y/yield_assign.py b/tests/functional/y/yield_assign.py
new file mode 100644
index 000000000..6a5ae00b2
--- /dev/null
+++ b/tests/functional/y/yield_assign.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.py b/tests/functional/y/yield_from_iterable.py
new file mode 100644
index 000000000..7803936d5
--- /dev/null
+++ b/tests/functional/y/yield_from_iterable.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.txt b/tests/functional/y/yield_from_iterable.txt
new file mode 100644
index 000000000..871b11c4a
--- /dev/null
+++ b/tests/functional/y/yield_from_iterable.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 000000000..e2db90c94
--- /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.txt b/tests/functional/y/yield_from_outside_func.txt
new file mode 100644
index 000000000..415637c31
--- /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 000000000..9f293b47d
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function.py
@@ -0,0 +1,16 @@
+"""Test that `yield` or `yield from` can't be used inside an async function."""

+# pylint: disable=missing-docstring, unused-variable

+

+async def good():

+    def _inner():

+        yield 42

+        yield from [1, 2, 3]

+

+async def good_two():

+    # Starting from python 3.6 it's possible to yield inside async

+    # https://www.python.org/dev/peps/pep-0525/

+    yield 42

+

+

+async def bad():

+    yield from [1, 2, 3] # [yield-inside-async-function]

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 000000000..0355800b6
--- /dev/null
+++ b/tests/functional/y/yield_inside_async_function.txt
@@ -0,0 +1 @@
+yield-inside-async-function:16:4:bad:Yield inside async function:HIGH
diff --git a/tests/functional/y/yield_outside_func.py b/tests/functional/y/yield_outside_func.py
new file mode 100644
index 000000000..5824bc0c7
--- /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 000000000..415637c31
--- /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 000000000..8e050f0f0
--- /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 000000000..60e92b76c
--- /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 000000000..e69de29bb
--- /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 000000000..d844c5603
--- /dev/null
+++ b/tests/input/func_3k_removed_stuff_py_30.py
@@ -0,0 +1,13 @@
+"""test relative 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 000000000..a4ef215bc
--- /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 000000000..9b6fbe79f
--- /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 000000000..0a3f83367
--- /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 000000000..63ff37c9f
--- /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 000000000..8c0fe9f5c
--- /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 000000000..f5b308f70
--- /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_noerror_cycle/__init__.py b/tests/input/func_noerror_cycle/__init__.py
new file mode 100644
index 000000000..fd8d14ec2
--- /dev/null
+++ b/tests/input/func_noerror_cycle/__init__.py
@@ -0,0 +1,3 @@
+# https://github.com/PyCQA/pylint/issues/3525
+# `cyclic-import` should not be emitted if one import
+# is guarded by `typing.TYPE_CHECKING`
diff --git a/tests/input/func_noerror_cycle/a.py b/tests/input/func_noerror_cycle/a.py
new file mode 100644
index 000000000..85bd49e0c
--- /dev/null
+++ b/tests/input/func_noerror_cycle/a.py
@@ -0,0 +1,8 @@
+# pylint: disable=missing-docstring
+from typing import List
+
+from .b import var
+
+LstT = List[int]
+
+print(var)
diff --git a/tests/input/func_noerror_cycle/b.py b/tests/input/func_noerror_cycle/b.py
new file mode 100644
index 000000000..df17057fa
--- /dev/null
+++ b/tests/input/func_noerror_cycle/b.py
@@ -0,0 +1,7 @@
+# pylint: disable=missing-docstring
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .a import LstT
+
+var: "LstT" = [1, 2]
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 000000000..b120b80ac
--- /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 000000000..6b8669130
--- /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_w0401.py b/tests/input/func_w0401.py
new file mode 100644
index 000000000..f8fae2447
--- /dev/null
+++ b/tests/input/func_w0401.py
@@ -0,0 +1,9 @@
+"""test cyclic 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 000000000..955188f08
--- /dev/null
+++ b/tests/input/func_w0401_disabled.py
@@ -0,0 +1,9 @@
+"""test cyclic 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 000000000..c0013d831
--- /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=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 000000000..dedef6608
--- /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 000000000..64556e1be
--- /dev/null
+++ b/tests/input/func_w0401_package/all_the_things.py
@@ -0,0 +1,9 @@
+"""All the things!"""
+
+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 000000000..34972a7d2
--- /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 000000000..d7a0f2239
--- /dev/null
+++ b/tests/input/func_w0401_package/thing2.py
@@ -0,0 +1,7 @@
+"""The second thing."""
+
+from .all_the_things import THING1
+__revision__ = None
+
+THING2 = "I am thing2"
+THING1_PLUS_THING2 = f"{THING1}, plus {THING2}"
diff --git a/tests/input/func_w0801.py b/tests/input/func_w0801.py
new file mode 100644
index 000000000..cd386ff55
--- /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 000000000..a8449c9b9
--- /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 000000000..444e540d2
--- /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 000000000..b9507ef8a
--- /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/noext b/tests/input/noext
new file mode 100644
index 000000000..8aeda06d3
--- /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 000000000..60e92b76c
--- /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 000000000..eb7f389c9
--- /dev/null
+++ b/tests/input/similar1
@@ -0,0 +1,31 @@
+import one
+from two import two
+three
+four
+five
+six # comments optionally ignored
+# even full line comment!
+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 000000000..687479a1a
--- /dev/null
+++ b/tests/input/similar2
@@ -0,0 +1,31 @@
+import one
+from two import two
+three
+four
+five
+six
+# A full line comment
+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 000000000..337431fe5
--- /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 000000000..abdad26db
--- /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 000000000..0c8bbc2b1
--- /dev/null
+++ b/tests/input/similar5
@@ -0,0 +1,17 @@
+@deco1(dval1)
+@deco2(dval2)
+@deco3(
+    dval3,
+    dval4
+)
+def func1(
+    arg1: int = 3,
+    arg2: Class1 = val1,
+    arg3: Class2 = func3(val2),
+    arg4: int = 4,
+    arg5: int = 5
+) -> Ret1:
+    pass
+
+def example():
+    """Valid function definition with docstring only."""
diff --git a/tests/input/similar6 b/tests/input/similar6
new file mode 100644
index 000000000..d12c8841b
--- /dev/null
+++ b/tests/input/similar6
@@ -0,0 +1,18 @@
+
+@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
+
+def example():
+    """Valid function definition with docstring only."""
diff --git a/tests/input/similar_cls_a.py b/tests/input/similar_cls_a.py
new file mode 100644
index 000000000..9f4e149e2
--- /dev/null
+++ b/tests/input/similar_cls_a.py
@@ -0,0 +1,27 @@
+class A:
+    def parent_method(
+        self,
+        *,
+        a="",
+        b=None,
+        c=True,
+    ):
+        """Overridden method example."""
+
+        def _internal_func(
+            arg1: int = 1,
+            arg2: str = "2",
+            arg3: int = 3,
+            arg4: bool = True,
+        ):
+            pass
+
+    class InternalA:
+        def some_method_a(
+            self,
+            *,
+            a=None,
+            b=False,
+            c="",
+        ):
+            pass
diff --git a/tests/input/similar_cls_b.py b/tests/input/similar_cls_b.py
new file mode 100644
index 000000000..91df34a38
--- /dev/null
+++ b/tests/input/similar_cls_b.py
@@ -0,0 +1,27 @@
+class B:
+    def parent_method(
+        self,
+        *,
+        a="",
+        b=None,
+        c=True,
+    ):
+        """Overridden method example."""
+
+        def _internal_func(
+            arg1: int = 1,
+            arg2: str = "2",
+            arg3: int = 3,
+            arg4: bool = True,
+        ):
+            pass
+
+    class InternalB:
+        def some_method_b(
+            self,
+            *,
+            a=None,
+            b=False,
+            c="",
+        ):
+            pass
diff --git a/tests/input/similar_empty_func_1.py b/tests/input/similar_empty_func_1.py
new file mode 100644
index 000000000..0abf6998e
--- /dev/null
+++ b/tests/input/similar_empty_func_1.py
@@ -0,0 +1,7 @@
+def func1(
+    arg1: int = 1,
+    arg2: str = "2",
+    arg3: int = 3,
+    arg4: bool = True,
+) -> None:
+    """Valid function definition with docstring only."""
diff --git a/tests/input/similar_empty_func_2.py b/tests/input/similar_empty_func_2.py
new file mode 100644
index 000000000..40c6479fa
--- /dev/null
+++ b/tests/input/similar_empty_func_2.py
@@ -0,0 +1,7 @@
+def func2(
+    arg1: int = 1,
+    arg2: str = "2",
+    arg3: int = 3,
+    arg4: bool = True,
+) -> None:
+    """Valid function definition with docstring only."""
diff --git a/tests/input/similar_lines_a.py b/tests/input/similar_lines_a.py
new file mode 100644
index 000000000..65a72a79d
--- /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 000000000..21634883d
--- /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 000000000..37be7c562
--- /dev/null
+++ b/tests/input/w0401_cycle.py
@@ -0,0 +1,9 @@
+"""w0401 dependency
+"""
+
+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 000000000..cd386ff55
--- /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 000000000..e69de29bb
--- /dev/null
+++ b/tests/lint/__init__.py
diff --git a/tests/lint/test_pylinter.py b/tests/lint/test_pylinter.py
new file mode 100644
index 000000000..27fc10ebf
--- /dev/null
+++ b/tests/lint/test_pylinter.py
@@ -0,0 +1,37 @@
+import sys
+from typing import Any
+from unittest.mock import patch
+
+from _pytest.capture import CaptureFixture
+from astroid import AstroidBuildingError
+from py._path.local import LocalPath  # type: ignore
+
+from pylint.lint.pylinter import PyLinter
+from pylint.utils import FileState
+
+if sys.version_info >= (3, 6, 2):
+    from typing import NoReturn
+else:
+    from typing_extensions import NoReturn
+
+
+def raise_exception(*args: Any, **kwargs: Any) -> NoReturn:
+    raise AstroidBuildingError(modname="spam")
+
+
+@patch.object(FileState, "iter_spurious_suppression_messages", raise_exception)
+def test_crash_in_file(
+    linter: PyLinter, capsys: CaptureFixture, tmpdir: LocalPath
+) -> None:
+    args = linter.load_command_line_configuration([__file__])
+    linter.crash_file_path = str(tmpdir / "pylint-crash-%Y")
+    linter.check(args)
+    out, err = capsys.readouterr()
+    assert not out
+    assert not err
+    files = tmpdir.listdir()
+    assert len(files) == 1
+    assert "pylint-crash-20" in str(files[0])
+    with open(files[0], encoding="utf8") as f:
+        content = f.read()
+    assert "Failed to import module spam." in content
diff --git a/tests/lint/test_utils.py b/tests/lint/test_utils.py
new file mode 100644
index 000000000..f7294f353
--- /dev/null
+++ b/tests/lint/test_utils.py
@@ -0,0 +1,33 @@
+from pathlib import Path, PosixPath
+
+from pylint.lint.utils import get_fatal_error_message, prepare_crash_report
+
+
+def test_prepare_crash_report(tmp_path: PosixPath) -> None:
+    exception_content = "Exmessage"
+    python_file = tmp_path / "myfile.py"
+    python_content = "from shadok import MagicFaucet"
+    with open(python_file, "w", encoding="utf8") as f:
+        f.write(python_content)
+    try:
+        raise Exception(exception_content)
+    except Exception as ex:  # pylint: disable=broad-except
+        template_path = prepare_crash_report(
+            ex, str(python_file), str(tmp_path / "pylint-crash-%Y.txt")
+        )
+    assert str(tmp_path) in str(template_path)
+    with open(template_path, encoding="utf8") as f:
+        template_content = f.read()
+    assert python_content in template_content
+    assert exception_content in template_content
+    assert "in test_prepare_crash_report" in template_content
+    assert "raise Exception(exception_content)" in template_content
+
+
+def test_get_fatal_error_message() -> None:
+    python_path = "mypath.py"
+    crash_path = "crash.txt"
+    msg = get_fatal_error_message(python_path, Path(crash_path))
+    assert python_path in msg
+    assert crash_path in msg
+    assert "open an issue" in msg
diff --git a/tests/lint/unittest_expand_modules.py b/tests/lint/unittest_expand_modules.py
new file mode 100644
index 000000000..ef98cf575
--- /dev/null
+++ b/tests/lint/unittest_expand_modules.py
@@ -0,0 +1,110 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/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() -> None:
+    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() -> None:
+    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"),
+}
+
+test_utils = {
+    "basename": "lint",
+    "basepath": INIT_PATH,
+    "isarg": False,
+    "name": "lint.test_utils",
+    "path": str(TEST_DIRECTORY / "lint/test_utils.py"),
+}
+
+test_pylinter = {
+    "basename": "lint",
+    "basepath": INIT_PATH,
+    "isarg": False,
+    "name": "lint.test_pylinter",
+    "path": str(TEST_DIRECTORY / "lint/test_pylinter.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,
+                test_pylinter,
+                test_utils,
+                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 000000000..53d2cd739
--- /dev/null
+++ b/tests/lint/unittest_lint.py
@@ -0,0 +1,842 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Michal Vasilek <michal@vasilek.cz>
+# Copyright (c) 2021 Eisuke Kawashima <e-kwsm@users.noreply.github.com>
+# 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/main/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
+from typing import Dict, Iterable, Iterator, List, Optional, Tuple
+
+import platformdirs
+import pytest
+from _pytest.capture import CaptureFixture
+
+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() -> Iterator:
+    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() -> Iterator[str]:
+    """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: List[str], chroot: str = ".") -> None:
+    """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", encoding="utf-8"):
+            pass
+
+
+@pytest.fixture
+def fake_path() -> Iterator[Iterable[str]]:
+    orig = list(sys.path)
+    fake: Iterable[str] = ["1", "2", "3"]
+    sys.path[:] = fake
+    yield fake
+    sys.path[:] = orig
+
+
+def test_no_args(fake_path: List[int]) -> None:
+    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: List[str], case: List[str]) -> None:
+    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: PyLinter) -> PyLinter:
+    linter.open()
+    linter.set_current_module("toto")
+    linter.file_state = FileState("toto")
+    return linter
+
+
+def test_pylint_visit_method_taken_in_account(linter: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    """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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    text.register(linter)
+    linter.set_option("output-format", "text")
+    assert linter.reporter.__class__.__name__ == "TextReporter"
+
+
+def test_set_unsupported_reporter(linter: PyLinter) -> None:
+    text.register(linter)
+    with pytest.raises(exceptions.InvalidReporterError):
+        linter.set_option("output-format", "missing.module.Class")
+
+
+def test_set_option_1(linter: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    """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: PyLinter) -> None:
+    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: PyLinter) -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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: PyLinter) -> None:
+    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_full_documentation(linter: PyLinter) -> None:
+    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 ``variables``",
+        # messages
+        "^:undefined-loop-variable \\(W0631\\): *",
+        # options
+        "^:dummy-variables-rgx:",
+    ):
+        regexp = re.compile(re_str, re.MULTILINE)
+        assert re.search(regexp, output)
+
+
+def test_list_msgs_enabled(init_linter: PyLinter, capsys: CaptureFixture) -> None:
+    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() -> None:
+    os.environ.pop("PYLINTRC", None)
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylint_home() -> None:
+    uhome = os.path.expanduser("~")
+    if uhome == "~":
+        expected = ".pylint.d"
+    else:
+        expected = platformdirs.user_cache_dir("pylint")
+    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:
+                rmtree(pylintd)
+            except FileNotFoundError:
+                pass
+    finally:
+        del os.environ["PYLINTHOME"]
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylintrc() -> None:
+    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() -> None:
+    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() -> None:
+    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: str, value: Optional[str]) -> None:
+        self.args.append((name, value))
+
+    def test_value_equal(self) -> None:
+        self.args: List[Tuple[str, Optional[str]]] = []
+        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) -> None:
+        self.args = []
+        preprocess_options(["--qu", "ux"], {"qu": (self._callback, True)})
+        assert [("qu", "ux")] == self.args
+
+    @staticmethod
+    def test_error_missing_expected_value() -> None:
+        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() -> None:
+        with pytest.raises(ArgumentPreprocessingError):
+            preprocess_options(
+                ["--foo", "--bar=spam", "--qu=ux"], {"bar": (None, False)}
+            )
+
+
+class _CustomPyLinter(PyLinter):
+    # pylint: disable=too-many-ancestors
+    @staticmethod
+    def should_analyze_file(modname: str, path: str, is_argument: bool = False) -> bool:
+        if os.path.basename(path) == "wrong.py":
+            return False
+
+        return super(_CustomPyLinter, _CustomPyLinter).should_analyze_file(
+            modname, path, is_argument=is_argument
+        )
+
+
+def test_custom_should_analyze_file() -> None:
+    """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: int) -> None:
+    """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: PyLinter) -> None:
+    # 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: PyLinter) -> None:
+    """Test "statement" for each module analized of computed correctly."""
+    linter = init_linter
+    linter.check([os.path.join(os.path.dirname(__file__), "data")])
+
+    by_module_stats: Dict[str, Dict[str, int]] = linter.stats["by_module"]  # type: ignore
+    for module, module_stats in by_module_stats.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 000000000..e69de29bb
--- /dev/null
+++ b/tests/message/__init__.py
diff --git a/tests/message/conftest.py b/tests/message/conftest.py
new file mode 100644
index 000000000..e30dbb535
--- /dev/null
+++ b/tests/message/conftest.py
@@ -0,0 +1,79 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# pylint: disable=redefined-outer-name
+
+
+from typing import Dict, ValuesView
+
+import pytest
+
+from pylint.checkers import BaseChecker
+from pylint.message import MessageDefinition, MessageDefinitionStore, MessageIdStore
+
+
+@pytest.fixture
+def msgid():
+    return "W1234"
+
+
+@pytest.fixture
+def symbol():
+    return "msg-symbol"
+
+
+@pytest.fixture
+def empty_store() -> MessageDefinitionStore:
+    return MessageDefinitionStore()
+
+
+@pytest.fixture
+def store() -> MessageDefinitionStore:
+    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: MessageDefinitionStore) -> ValuesView[MessageDefinition]:
+    return store.messages
+
+
+@pytest.fixture
+def msgids() -> Dict[str, str]:
+    return {
+        "W1234": "warning-symbol",
+        "W1235": "warning-symbol-two",
+        "C1234": "convention-symbol",
+        "E1234": "error-symbol",
+    }
+
+
+@pytest.fixture
+def empty_msgid_store() -> MessageIdStore:
+    return MessageIdStore()
+
+
+@pytest.fixture
+def msgid_store(msgids: Dict[str, str]) -> MessageIdStore:
+    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 000000000..6f8b4aa01
--- /dev/null
+++ b/tests/message/unittest_message.py
@@ -0,0 +1,57 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+from typing import Dict, ValuesView
+
+from pylint.message import Message
+from pylint.message.message_definition import MessageDefinition
+
+
+def test_new_message(message_definitions: ValuesView[MessageDefinition]) -> None:
+    def build_message(
+        message_definition: MessageDefinition, location_value: Dict[str, str]
+    ) -> Message:
+        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 000000000..2015c2154
--- /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/main/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: MessageDefinition, expected: bool = True) -> None:
+        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() -> MessageDefinition:
+        kwargs = {"minversion": None, "maxversion": None}
+        return MessageDefinition(
+            FalseChecker(),
+            "W1234",
+            "message",
+            "description",
+            "msg-symbol",
+            WarningScope.NODE,
+            **kwargs,
+        )
+
+    def test_may_be_emitted(self) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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 000000000..4d108489e
--- /dev/null
+++ b/tests/message/unittest_message_definition_store.py
@@ -0,0 +1,273 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+from contextlib import redirect_stdout
+from io import StringIO
+
+import pytest
+from _pytest.capture import CaptureFixture
+
+from pylint.checkers import BaseChecker
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+from pylint.message import MessageDefinition
+from pylint.message.message_definition_store import MessageDefinitionStore
+
+
+@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: MessageDefinitionStore,
+) -> None:
+    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: CaptureFixture, store: MessageDefinitionStore) -> None:
+    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: MessageDefinitionStore) -> None:
+    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: MessageDefinitionStore) -> None:
+    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: str, msg: MessageDefinition, checkerref: bool = False
+    ) -> None:
+        assert desc == msg.format_help(checkerref=checkerref)
+
+    def test_message_help(self, store: MessageDefinitionStore) -> None:
+        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: MessageDefinitionStore) -> None:
+        # 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: MessageDefinitionStore) -> None:
+    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: MessageDefinitionStore) -> None:
+    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: MessageDefinitionStore) -> None:
+    """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
+    assert child[0] in mother
+    assert other_child[0] 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 000000000..340b23d32
--- /dev/null
+++ b/tests/message/unittest_message_id_store.py
@@ -0,0 +1,92 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+from typing import Dict, ValuesView
+
+import pytest
+
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+from pylint.message.message_definition import MessageDefinition
+from pylint.message.message_id_store import MessageIdStore
+
+
+def test_len_str(msgid_store: MessageIdStore, msgids: Dict[str, str]) -> None:
+    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: MessageIdStore, msgids: Dict[str, str]) -> None:
+    """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: MessageIdStore) -> None:
+    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: MessageIdStore,
+    message_definitions: ValuesView[MessageDefinition],
+) -> None:
+    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: MessageIdStore) -> None:
+    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: MessageIdStore) -> None:
+    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: MessageIdStore) -> None:
+    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 000000000..2616c0e20
--- /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 000000000..9920f1b64
--- /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 000000000..51bde771e
--- /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 000000000..f05f16020
--- /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 000000000..06e391d4f
--- /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 000000000..06e391d4f
--- /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 000000000..609f20861
--- /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 000000000..205475890
--- /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 000000000..75d7afd60
--- /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 000000000..c3b521d5a
--- /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 000000000..5ae78a4a9
--- /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 000000000..0108fb107
--- /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_noerror_cycle.txt b/tests/messages/func_noerror_cycle.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/messages/func_noerror_cycle.txt
diff --git a/tests/messages/func_raw_escapes.txt b/tests/messages/func_raw_escapes.txt
new file mode 100644
index 000000000..991fba7dd
--- /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 000000000..d81ce5cf4
--- /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 000000000..cd594f5fa
--- /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 000000000..d1257ca17
--- /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 000000000..b6bf150f6
--- /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 000000000..80e89d6f9
--- /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 000000000..e69de29bb
--- /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 000000000..25efa9998
--- /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 000000000..2d27b5165
--- /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 000000000..35a85d511
--- /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 000000000..01c57af07
--- /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 000000000..e0163662c
--- /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 000000000..917e8d0e2
--- /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 000000000..16f1d8024
--- /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 000000000..f6648f477
--- /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 000000000..b5a8db3d2
--- /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 000000000..b5ce4524d
--- /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 000000000..ca0512448
--- /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 000000000..719134726
--- /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 000000000..08fe8b571
--- /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 000000000..77329bb0f
--- /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 000000000..54355ab8a
--- /dev/null
+++ b/tests/messages/func_w0801.txt
@@ -0,0 +1,10 @@
+R:  1: Similar lines in 2 files
+==input.func_w0801:[3:10]
+==input.w0801_same:[3:10]
+__revision__ = 'id'
+A = 2
+B = 3
+C = A + B
+# need more than X lines to trigger the message
+C *= 2
+A -= B
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 000000000..e62b69bba
--- /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 000000000..14b6dae71
--- /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 Daniël van Noord <13665637+DanielNoord@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/main/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), f"Dir not found {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(f"Have {len(filepaths)} files")
+
+    runner = Run(filepaths, reporter=Reporter(), do_exit=False)
+
+    print(
+        f"Had {len(filepaths)} files with {len(runner.linter.reporter.messages)} messages"
+    )
+    pprint.pprint(runner.linter.reporter.messages)
diff --git a/tests/pyreverse/conftest.py b/tests/pyreverse/conftest.py
new file mode 100644
index 000000000..cb9e0780a
--- /dev/null
+++ b/tests/pyreverse/conftest.py
@@ -0,0 +1,55 @@
+from typing import Callable, Optional
+
+import pytest
+from astroid.nodes.scoped_nodes import Module
+
+from pylint.pyreverse.inspector import Project, project_from_files
+from pylint.testutils.pyreverse import PyreverseConfig
+
+
+@pytest.fixture()
+def default_config() -> PyreverseConfig:
+    return PyreverseConfig()
+
+
+@pytest.fixture()
+def colorized_dot_config() -> PyreverseConfig:
+    return PyreverseConfig(
+        output_format="dot",
+        colorized=True,
+    )
+
+
+@pytest.fixture()
+def vcg_config() -> PyreverseConfig:
+    return PyreverseConfig(
+        output_format="vcg",
+    )
+
+
+@pytest.fixture()
+def puml_config() -> PyreverseConfig:
+    return PyreverseConfig(
+        output_format="puml",
+    )
+
+
+@pytest.fixture()
+def colorized_puml_config() -> PyreverseConfig:
+    return PyreverseConfig(
+        output_format="puml",
+        colorized=True,
+    )
+
+
+@pytest.fixture(scope="session")
+def get_project() -> Callable:
+    def _get_project(module: str, name: Optional[str] = "No Name") -> Project:
+        """return an astroid project representation"""
+
+        def _astroid_wrapper(func: Callable, modname: str) -> Module:
+            return func(modname)
+
+        return project_from_files([module], _astroid_wrapper, project_name=name)
+
+    return _get_project
diff --git a/tests/pyreverse/data/classes_No_Name.dot b/tests/pyreverse/data/classes_No_Name.dot
new file mode 100644
index 000000000..cbe3d155d
--- /dev/null
+++ b/tests/pyreverse/data/classes_No_Name.dot
@@ -0,0 +1,16 @@
+digraph "classes_No_Name" {
+rankdir=BT
+charset="utf-8"
+"data.clientmodule_test.Ancestor" [color="black", fontcolor="black", label="{Ancestor|attr : str\lcls_member\l|get_value()\lset_value(value)\l}", shape="record", style="solid"];
+"data.suppliermodule_test.CustomException" [color="black", fontcolor="red", label="{CustomException|\l|}", shape="record", style="solid"];
+"data.suppliermodule_test.DoNothing" [color="black", fontcolor="black", label="{DoNothing|\l|}", shape="record", style="solid"];
+"data.suppliermodule_test.DoNothing2" [color="black", fontcolor="black", label="{DoNothing2|\l|}", shape="record", style="solid"];
+"data.suppliermodule_test.DoSomething" [color="black", fontcolor="black", label="{DoSomething|my_int : Optional[int]\lmy_int_2 : Optional[int]\lmy_string : str\l|do_it(new_int: int): int\l}", shape="record", style="solid"];
+"data.suppliermodule_test.Interface" [color="black", fontcolor="black", label="{Interface|\l|get_value()\lset_value(value)\l}", shape="record", style="solid"];
+"data.clientmodule_test.Specialization" [color="black", fontcolor="black", label="{Specialization|TYPE : str\lrelation\lrelation2\ltop : str\l|}", shape="record", style="solid"];
+"data.clientmodule_test.Specialization" -> "data.clientmodule_test.Ancestor" [arrowhead="empty", arrowtail="none"];
+"data.clientmodule_test.Ancestor" -> "data.suppliermodule_test.Interface" [arrowhead="empty", arrowtail="node", style="dashed"];
+"data.suppliermodule_test.DoNothing" -> "data.clientmodule_test.Ancestor" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="cls_member", style="solid"];
+"data.suppliermodule_test.DoNothing" -> "data.clientmodule_test.Specialization" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="relation", style="solid"];
+"data.suppliermodule_test.DoNothing2" -> "data.clientmodule_test.Specialization" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="relation2", style="solid"];
+}
diff --git a/tests/pyreverse/data/classes_No_Name.puml b/tests/pyreverse/data/classes_No_Name.puml
new file mode 100644
index 000000000..35bda65c1
--- /dev/null
+++ b/tests/pyreverse/data/classes_No_Name.puml
@@ -0,0 +1,36 @@
+@startuml classes_No_Name
+set namespaceSeparator none
+class "Ancestor" as data.clientmodule_test.Ancestor {
+  attr : str
+  cls_member
+  get_value()
+  set_value(value)
+}
+class "<color:red>CustomException</color>" as data.suppliermodule_test.CustomException {
+}
+class "DoNothing" as data.suppliermodule_test.DoNothing {
+}
+class "DoNothing2" as data.suppliermodule_test.DoNothing2 {
+}
+class "DoSomething" as data.suppliermodule_test.DoSomething {
+  my_int : Optional[int]
+  my_int_2 : Optional[int]
+  my_string : str
+  do_it(new_int: int) -> int
+}
+class "Interface" as data.suppliermodule_test.Interface {
+  get_value()
+  set_value(value)
+}
+class "Specialization" as data.clientmodule_test.Specialization {
+  TYPE : str
+  relation
+  relation2
+  top : str
+}
+data.clientmodule_test.Specialization --|> data.clientmodule_test.Ancestor
+data.clientmodule_test.Ancestor ..|> data.suppliermodule_test.Interface
+data.suppliermodule_test.DoNothing --* data.clientmodule_test.Ancestor : cls_member
+data.suppliermodule_test.DoNothing --* data.clientmodule_test.Specialization : relation
+data.suppliermodule_test.DoNothing2 --* data.clientmodule_test.Specialization : relation2
+@enduml
diff --git a/tests/pyreverse/data/classes_No_Name.vcg b/tests/pyreverse/data/classes_No_Name.vcg
new file mode 100644
index 000000000..748c432f2
--- /dev/null
+++ b/tests/pyreverse/data/classes_No_Name.vcg
@@ -0,0 +1,52 @@
+graph:{
+  title:"classes_No_Name"
+  layoutalgorithm:dfs
+  late_edge_labels:yes
+  port_sharing:no
+  manhattan_edges:yes
+  node: {title:"data.clientmodule_test.Ancestor"  label:"\fbAncestor\fn\n\f____________\n\f08attr : str\n\f08cls_member\n\f____________\n\f10get_value()\n\f10set_value()"
+  shape:box
+}
+  node: {title:"data.suppliermodule_test.CustomException"  label:"\fb09CustomException\fn\n\f_________________"
+  shape:box
+}
+  node: {title:"data.suppliermodule_test.DoNothing"  label:"\fbDoNothing\fn\n\f___________"
+  shape:box
+}
+  node: {title:"data.suppliermodule_test.DoNothing2"  label:"\fbDoNothing2\fn\n\f____________"
+  shape:box
+}
+  node: {title:"data.suppliermodule_test.DoSomething"  label:"\fbDoSomething\fn\n\f__________________________\n\f08my_int : Optional[int]\n\f08my_int_2 : Optional[int]\n\f08my_string : str\n\f__________________________\n\f10do_it()"
+  shape:box
+}
+  node: {title:"data.suppliermodule_test.Interface"  label:"\fbInterface\fn\n\f___________\n\f10get_value()\n\f10set_value()"
+  shape:box
+}
+  node: {title:"data.clientmodule_test.Specialization"  label:"\fbSpecialization\fn\n\f________________\n\f08TYPE : str\n\f08relation\n\f08relation2\n\f08top : str\n\f________________"
+  shape:box
+}
+  edge: {sourcename:"data.clientmodule_test.Specialization" targetname:"data.clientmodule_test.Ancestor"  arrowstyle:solid
+  backarrowstyle:none
+  backarrowsize:10
+}
+  edge: {sourcename:"data.clientmodule_test.Ancestor" targetname:"data.suppliermodule_test.Interface"  arrowstyle:solid
+  backarrowstyle:none
+  linestyle:dotted
+  backarrowsize:10
+}
+  edge: {sourcename:"data.suppliermodule_test.DoNothing" targetname:"data.clientmodule_test.Ancestor"  arrowstyle:solid
+  backarrowstyle:none
+  textcolor:green
+  label:"cls_member"
+}
+  edge: {sourcename:"data.suppliermodule_test.DoNothing" targetname:"data.clientmodule_test.Specialization"  arrowstyle:solid
+  backarrowstyle:none
+  textcolor:green
+  label:"relation"
+}
+  edge: {sourcename:"data.suppliermodule_test.DoNothing2" targetname:"data.clientmodule_test.Specialization"  arrowstyle:solid
+  backarrowstyle:none
+  textcolor:green
+  label:"relation2"
+}
+}
diff --git a/tests/pyreverse/data/classes_colorized.dot b/tests/pyreverse/data/classes_colorized.dot
new file mode 100644
index 000000000..ff96df77c
--- /dev/null
+++ b/tests/pyreverse/data/classes_colorized.dot
@@ -0,0 +1,16 @@
+digraph "classes_colorized" {
+rankdir=BT
+charset="utf-8"
+"data.clientmodule_test.Ancestor" [color="aliceblue", fontcolor="black", label="{Ancestor|attr : str\lcls_member\l|get_value()\lset_value(value)\l}", shape="record", style="filled"];
+"data.suppliermodule_test.CustomException" [color="aliceblue", fontcolor="red", label="{CustomException|\l|}", shape="record", style="filled"];
+"data.suppliermodule_test.DoNothing" [color="aliceblue", fontcolor="black", label="{DoNothing|\l|}", shape="record", style="filled"];
+"data.suppliermodule_test.DoNothing2" [color="aliceblue", fontcolor="black", label="{DoNothing2|\l|}", shape="record", style="filled"];
+"data.suppliermodule_test.DoSomething" [color="aliceblue", fontcolor="black", label="{DoSomething|my_int : Optional[int]\lmy_int_2 : Optional[int]\lmy_string : str\l|do_it(new_int: int): int\l}", shape="record", style="filled"];
+"data.suppliermodule_test.Interface" [color="aliceblue", fontcolor="black", label="{Interface|\l|get_value()\lset_value(value)\l}", shape="record", style="filled"];
+"data.clientmodule_test.Specialization" [color="aliceblue", fontcolor="black", label="{Specialization|TYPE : str\lrelation\lrelation2\ltop : str\l|}", shape="record", style="filled"];
+"data.clientmodule_test.Specialization" -> "data.clientmodule_test.Ancestor" [arrowhead="empty", arrowtail="none"];
+"data.clientmodule_test.Ancestor" -> "data.suppliermodule_test.Interface" [arrowhead="empty", arrowtail="node", style="dashed"];
+"data.suppliermodule_test.DoNothing" -> "data.clientmodule_test.Ancestor" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="cls_member", style="solid"];
+"data.suppliermodule_test.DoNothing" -> "data.clientmodule_test.Specialization" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="relation", style="solid"];
+"data.suppliermodule_test.DoNothing2" -> "data.clientmodule_test.Specialization" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="relation2", style="solid"];
+}
diff --git a/tests/pyreverse/data/classes_colorized.puml b/tests/pyreverse/data/classes_colorized.puml
new file mode 100644
index 000000000..25c0f34e9
--- /dev/null
+++ b/tests/pyreverse/data/classes_colorized.puml
@@ -0,0 +1,36 @@
+@startuml classes_colorized
+set namespaceSeparator none
+class "Ancestor" as data.clientmodule_test.Ancestor #aliceblue {
+  attr : str
+  cls_member
+  get_value()
+  set_value(value)
+}
+class "<color:red>CustomException</color>" as data.suppliermodule_test.CustomException #aliceblue {
+}
+class "DoNothing" as data.suppliermodule_test.DoNothing #aliceblue {
+}
+class "DoNothing2" as data.suppliermodule_test.DoNothing2 #aliceblue {
+}
+class "DoSomething" as data.suppliermodule_test.DoSomething #aliceblue {
+  my_int : Optional[int]
+  my_int_2 : Optional[int]
+  my_string : str
+  do_it(new_int: int) -> int
+}
+class "Interface" as data.suppliermodule_test.Interface #aliceblue {
+  get_value()
+  set_value(value)
+}
+class "Specialization" as data.clientmodule_test.Specialization #aliceblue {
+  TYPE : str
+  relation
+  relation2
+  top : str
+}
+data.clientmodule_test.Specialization --|> data.clientmodule_test.Ancestor
+data.clientmodule_test.Ancestor ..|> data.suppliermodule_test.Interface
+data.suppliermodule_test.DoNothing --* data.clientmodule_test.Ancestor : cls_member
+data.suppliermodule_test.DoNothing --* data.clientmodule_test.Specialization : relation
+data.suppliermodule_test.DoNothing2 --* data.clientmodule_test.Specialization : relation2
+@enduml
diff --git a/tests/pyreverse/data/packages_No_Name.dot b/tests/pyreverse/data/packages_No_Name.dot
new file mode 100644
index 000000000..7b145dc91
--- /dev/null
+++ b/tests/pyreverse/data/packages_No_Name.dot
@@ -0,0 +1,8 @@
+digraph "packages_No_Name" {
+rankdir=BT
+charset="utf-8"
+"data" [color="black", label="data", shape="box", style="solid"];
+"data.clientmodule_test" [color="black", label="data.clientmodule_test", shape="box", style="solid"];
+"data.suppliermodule_test" [color="black", label="data.suppliermodule_test", shape="box", style="solid"];
+"data.clientmodule_test" -> "data.suppliermodule_test" [arrowhead="open", arrowtail="none"];
+}
diff --git a/tests/pyreverse/data/packages_No_Name.puml b/tests/pyreverse/data/packages_No_Name.puml
new file mode 100644
index 000000000..7089df0ea
--- /dev/null
+++ b/tests/pyreverse/data/packages_No_Name.puml
@@ -0,0 +1,13 @@
+@startuml packages_No_Name
+set namespaceSeparator none
+package "data" as data {
+
+}
+package "data.clientmodule_test" as data.clientmodule_test {
+
+}
+package "data.suppliermodule_test" as data.suppliermodule_test {
+
+}
+data.clientmodule_test --> data.suppliermodule_test
+@enduml
diff --git a/tests/pyreverse/data/packages_No_Name.vcg b/tests/pyreverse/data/packages_No_Name.vcg
new file mode 100644
index 000000000..03f4e2481
--- /dev/null
+++ b/tests/pyreverse/data/packages_No_Name.vcg
@@ -0,0 +1,20 @@
+graph:{
+  title:"packages_No_Name"
+  layoutalgorithm:dfs
+  late_edge_labels:yes
+  port_sharing:no
+  manhattan_edges:yes
+  node: {title:"data"  label:"\fbdata\fn"
+  shape:box
+}
+  node: {title:"data.clientmodule_test"  label:"\fbdata.clientmodule_test\fn"
+  shape:box
+}
+  node: {title:"data.suppliermodule_test"  label:"\fbdata.suppliermodule_test\fn"
+  shape:box
+}
+  edge: {sourcename:"data.clientmodule_test" targetname:"data.suppliermodule_test"  arrowstyle:solid
+  backarrowstyle:none
+  backarrowsize:0
+}
+}
diff --git a/tests/pyreverse/data/packages_colorized.dot b/tests/pyreverse/data/packages_colorized.dot
new file mode 100644
index 000000000..917fa86f5
--- /dev/null
+++ b/tests/pyreverse/data/packages_colorized.dot
@@ -0,0 +1,8 @@
+digraph "packages_colorized" {
+rankdir=BT
+charset="utf-8"
+"data" [color="aliceblue", label="data", shape="box", style="filled"];
+"data.clientmodule_test" [color="aliceblue", label="data.clientmodule_test", shape="box", style="filled"];
+"data.suppliermodule_test" [color="aliceblue", label="data.suppliermodule_test", shape="box", style="filled"];
+"data.clientmodule_test" -> "data.suppliermodule_test" [arrowhead="open", arrowtail="none"];
+}
diff --git a/tests/pyreverse/data/packages_colorized.puml b/tests/pyreverse/data/packages_colorized.puml
new file mode 100644
index 000000000..8d489e7aa
--- /dev/null
+++ b/tests/pyreverse/data/packages_colorized.puml
@@ -0,0 +1,13 @@
+@startuml packages_colorized
+set namespaceSeparator none
+package "data" as data #aliceblue {
+
+}
+package "data.clientmodule_test" as data.clientmodule_test #aliceblue {
+
+}
+package "data.suppliermodule_test" as data.suppliermodule_test #aliceblue {
+
+}
+data.clientmodule_test --> data.suppliermodule_test
+@enduml
diff --git a/tests/pyreverse/test_diadefs.py b/tests/pyreverse/test_diadefs.py
new file mode 100644
index 000000000..0b31a28fe
--- /dev/null
+++ b/tests/pyreverse/test_diadefs.py
@@ -0,0 +1,220 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.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 Mark Byrne <31762852+mbyrnepr2@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/main/LICENSE
+
+"""Unit test for the extensions.diadefslib modules"""
+# pylint: disable=redefined-outer-name
+import sys
+from pathlib import Path
+from typing import Callable, Dict, List, Tuple
+
+import pytest
+from astroid import nodes
+
+from pylint.pyreverse.diadefslib import (
+    ClassDiadefGenerator,
+    DefaultDiadefGenerator,
+    DiaDefGenerator,
+    DiadefsHandler,
+)
+from pylint.pyreverse.diagrams import DiagramEntity, Relationship
+from pylint.pyreverse.inspector import Linker, Project
+from pylint.testutils.pyreverse import PyreverseConfig
+
+
+def _process_classes(classes: List[DiagramEntity]) -> List[Tuple[bool, str]]:
+    """extract class names of a list"""
+    return sorted((isinstance(c.node, nodes.ClassDef), c.title) for c in classes)
+
+
+def _process_relations(
+    relations: Dict[str, List[Relationship]]
+) -> List[Tuple[str, str, str]]:
+    """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(default_config: PyreverseConfig) -> DiadefsHandler:
+    return DiadefsHandler(default_config)
+
+
+@pytest.fixture(scope="module")
+def PROJECT(get_project):
+    return get_project("data")
+
+
+def test_option_values(
+    default_config: PyreverseConfig, HANDLER: DiadefsHandler, PROJECT: Project
+) -> None:
+    """test for ancestor, associated and module options"""
+    df_h = DiaDefGenerator(Linker(PROJECT), HANDLER)
+    cl_config = default_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(default_config)
+    df_h = DiaDefGenerator(Linker(PROJECT), handler)
+    cl_config = default_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() -> None:
+    """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"),
+        ("association", "DoNothing2", "Specialization"),
+        ("implements", "Ancestor", "Interface"),
+        ("specialization", "Specialization", "Ancestor"),
+    ]
+
+    def test_exctract_relations(
+        self, HANDLER: DiadefsHandler, PROJECT: Project
+    ) -> None:
+        """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, default_config: PyreverseConfig, get_project: Callable
+    ) -> None:
+        """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(default_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: DiadefsHandler, PROJECT: Project) -> None:
+    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, nodes.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, "CustomException"),
+        (True, "DoNothing"),
+        (True, "DoNothing2"),
+        (True, "DoSomething"),
+        (True, "Interface"),
+        (True, "Specialization"),
+    ]
+
+
+def test_known_values2(HANDLER: DiadefsHandler, get_project: Callable) -> None:
+    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: DiadefsHandler, PROJECT: Project) -> None:
+    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"),
+        (True, "data.suppliermodule_test.DoNothing2"),
+    ]
+
+
+def test_known_values4(HANDLER: DiadefsHandler, PROJECT: Project) -> None:
+    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, "DoNothing2"),
+        (True, "Specialization"),
+    ]
+
+
+@pytest.mark.skipif(sys.version_info < (3, 8), reason="Requires dataclasses")
+def test_regression_dataclasses_inference(
+    HANDLER: DiadefsHandler, get_project: Callable
+) -> None:
+    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/pyreverse/test_inspector.py b/tests/pyreverse/test_inspector.py
new file mode 100644
index 000000000..8be038396
--- /dev/null
+++ b/tests/pyreverse/test_inspector.py
@@ -0,0 +1,136 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.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 Mark Byrne <31762852+mbyrnepr2@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/main/LICENSE
+
+"""
+ for the visitors.diadefs module
+"""
+# pylint: disable=redefined-outer-name
+
+import os
+from typing import Callable
+
+import astroid
+import pytest
+from astroid import nodes
+
+from pylint.pyreverse import inspector
+from pylint.pyreverse.inspector import Project
+
+
+@pytest.fixture
+def project(get_project: Callable) -> Project:
+    project = get_project("data", "data")
+    linker = inspector.Linker(project)
+    linker.visit(project)
+    return project
+
+
+def test_class_implements(project: Project) -> None:
+    klass = project.get_module("data.clientmodule_test")["Ancestor"]
+    assert hasattr(klass, "implements")
+    assert len(klass.implements) == 1
+    assert isinstance(klass.implements[0], nodes.ClassDef)
+    assert klass.implements[0].name == "Interface"
+
+
+def test_class_implements_specialization(project: Project) -> None:
+    klass = project.get_module("data.clientmodule_test")["Specialization"]
+    assert hasattr(klass, "implements")
+    assert len(klass.implements) == 0
+
+
+def test_locals_assignment_resolution(project: Project) -> None:
+    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: Project) -> None:
+    klass = project.get_module("data.clientmodule_test")["Specialization"]
+    assert hasattr(klass, "instance_attrs_type")
+    type_dict = klass.instance_attrs_type
+    assert len(type_dict) == 3
+    keys = sorted(type_dict.keys())
+    assert keys == ["_id", "relation", "relation2"]
+    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() -> None:
+    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() -> None:
+    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: Project) -> None:
+    expected = os.path.join("tests", "data", "__init__.py")
+    assert project.name == "data"
+    assert project.path.endswith(expected)
+
+
+def test_project_node(project: Project) -> None:
+    expected = ["data", "data.clientmodule_test", "data.suppliermodule_test"]
+    assert sorted(project.keys()) == expected
diff --git a/tests/pyreverse/test_printer.py b/tests/pyreverse/test_printer.py
new file mode 100644
index 000000000..e2b72b22c
--- /dev/null
+++ b/tests/pyreverse/test_printer.py
@@ -0,0 +1,53 @@
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+from typing import Type
+
+import pytest
+
+from pylint.pyreverse.dot_printer import DotPrinter
+from pylint.pyreverse.plantuml_printer import PlantUmlPrinter
+from pylint.pyreverse.printer import Layout, NodeType, Printer
+from pylint.pyreverse.vcg_printer import VCGPrinter
+
+
+@pytest.mark.parametrize(
+    "layout, printer_class, expected_content, line_index",
+    [
+        (Layout.TOP_TO_BOTTOM, DotPrinter, "rankdir=TB", -2),
+        (Layout.BOTTOM_TO_TOP, DotPrinter, "rankdir=BT", -2),
+        (Layout.LEFT_TO_RIGHT, DotPrinter, "rankdir=LR", -2),
+        (Layout.RIGHT_TO_LEFT, DotPrinter, "rankdir=RL", -2),
+        (Layout.TOP_TO_BOTTOM, VCGPrinter, "orientation:top_to_bottom", -1),
+        (Layout.BOTTOM_TO_TOP, VCGPrinter, "orientation:bottom_to_top", -1),
+        (Layout.LEFT_TO_RIGHT, VCGPrinter, "orientation:left_to_right", -1),
+        (Layout.RIGHT_TO_LEFT, VCGPrinter, "orientation:right_to_left", -1),
+        (Layout.TOP_TO_BOTTOM, PlantUmlPrinter, "top to bottom direction", -1),
+        (Layout.LEFT_TO_RIGHT, PlantUmlPrinter, "left to right direction", -1),
+    ],
+)
+def test_explicit_layout(
+    layout: Layout, printer_class: Type[Printer], expected_content: str, line_index: int
+) -> None:
+    printer = printer_class(title="unittest", layout=layout)
+    assert printer.lines[line_index].strip() == expected_content
+
+
+@pytest.mark.parametrize(
+    "layout, printer_class",
+    [(Layout.BOTTOM_TO_TOP, PlantUmlPrinter), (Layout.RIGHT_TO_LEFT, PlantUmlPrinter)],
+)
+def test_unsupported_layout(layout: Layout, printer_class: Type[Printer]):
+    with pytest.raises(ValueError):
+        printer_class(title="unittest", layout=layout)
+
+
+class TestPlantUmlPrinter:
+    printer = PlantUmlPrinter(title="unittest", layout=Layout.TOP_TO_BOTTOM)
+
+    def test_node_without_properties(self) -> None:
+        self.printer.emit_node(name="test", type_=NodeType.CLASS)
+        assert self.printer.lines[-2:] == ['class "test" as test {\n', "}\n"]
diff --git a/tests/pyreverse/test_printer_factory.py b/tests/pyreverse/test_printer_factory.py
new file mode 100644
index 000000000..f2ad7106a
--- /dev/null
+++ b/tests/pyreverse/test_printer_factory.py
@@ -0,0 +1,29 @@
+# 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/main/LICENSE
+
+"""
+Unit tests for pylint.pyreverse.printer_factory
+"""
+
+import pytest
+
+from pylint.pyreverse import printer_factory
+from pylint.pyreverse.dot_printer import DotPrinter
+from pylint.pyreverse.plantuml_printer import PlantUmlPrinter
+from pylint.pyreverse.vcg_printer import VCGPrinter
+
+
+@pytest.mark.parametrize(
+    "filetype, expected_printer_class",
+    [
+        ("vcg", VCGPrinter),
+        ("dot", DotPrinter),
+        ("puml", PlantUmlPrinter),
+        ("plantuml", PlantUmlPrinter),
+        ("png", DotPrinter),
+    ],
+)
+def test_get_printer_for_filetype(filetype, expected_printer_class):
+    assert printer_factory.get_printer_for_filetype(filetype) == expected_printer_class
diff --git a/tests/pyreverse/test_utils.py b/tests/pyreverse/test_utils.py
new file mode 100644
index 000000000..b140bb369
--- /dev/null
+++ b/tests/pyreverse/test_utils.py
@@ -0,0 +1,145 @@
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+# Copyright (c) 2021 Mark Byrne <31762852+mbyrnepr2@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
+
+"""Tests for pylint.pyreverse.utils"""
+
+from typing import Any
+from unittest.mock import patch
+
+import astroid
+import pytest
+from astroid import nodes
+
+from pylint.pyreverse.utils import get_annotation, get_visibility, infer_node
+
+
+@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}"
+
+
+@pytest.mark.parametrize(
+    "assign, label",
+    [
+        ("a: str = None", "Optional[str]"),
+        ("a: str = 'mystr'", "str"),
+        ("a: Optional[str] = 'str'", "Optional[str]"),
+        ("a: Optional[str] = None", "Optional[str]"),
+    ],
+)
+def test_get_annotation_annassign(assign, label):
+    """AnnAssign"""
+    node = astroid.extract_node(assign)
+    got = get_annotation(node.value).name
+    assert isinstance(node, nodes.AnnAssign)
+    assert got == label, f"got {got} instead of {label} for value {node}"
+
+
+@pytest.mark.parametrize(
+    "init_method, label",
+    [
+        ("def __init__(self, x: str):                   self.x = x", "str"),
+        ("def __init__(self, x: str = 'str'):           self.x = x", "str"),
+        ("def __init__(self, x: str = None):            self.x = x", "Optional[str]"),
+        ("def __init__(self, x: Optional[str]):         self.x = x", "Optional[str]"),
+        ("def __init__(self, x: Optional[str] = None):  self.x = x", "Optional[str]"),
+        ("def __init__(self, x: Optional[str] = 'str'): self.x = x", "Optional[str]"),
+    ],
+)
+def test_get_annotation_assignattr(init_method, label):
+    """AssignAttr"""
+    assign = fr"""
+        class A:
+            {init_method}
+    """
+    node = astroid.extract_node(assign)
+    instance_attrs = node.instance_attrs
+    for _, assign_attrs in instance_attrs.items():
+        for assign_attr in assign_attrs:
+            got = get_annotation(assign_attr).name
+            assert isinstance(assign_attr, nodes.AssignAttr)
+            assert got == label, f"got {got} instead of {label} for value {node}"
+
+
+@patch("pylint.pyreverse.utils.get_annotation")
+@patch("astroid.node_classes.NodeNG.infer", side_effect=astroid.InferenceError)
+def test_infer_node_1(mock_infer: Any, mock_get_annotation: Any) -> None:
+    """Return set() when astroid.InferenceError is raised and an annotation has
+    not been returned
+    """
+    mock_get_annotation.return_value = None
+    node = astroid.extract_node("a: str = 'mystr'")
+    mock_infer.return_value = "x"
+    assert infer_node(node) == set()
+    assert mock_infer.called
+
+
+@patch("pylint.pyreverse.utils.get_annotation")
+@patch("astroid.node_classes.NodeNG.infer")
+def test_infer_node_2(mock_infer: Any, mock_get_annotation: Any) -> None:
+    """Return set(node.infer()) when InferenceError is not raised and an
+    annotation has not been returned
+    """
+    mock_get_annotation.return_value = None
+    node = astroid.extract_node("a: str = 'mystr'")
+    mock_infer.return_value = "x"
+    assert infer_node(node) == set("x")
+    assert mock_infer.called
+
+
+def test_infer_node_3() -> None:
+    """Return a set containing a nodes.ClassDef object when the attribute
+    has a type annotation"""
+    node = astroid.extract_node(
+        """
+        class Component:
+            pass
+
+        class Composite:
+            def __init__(self, component: Component):
+                self.component = component
+    """
+    )
+    instance_attr = node.instance_attrs.get("component")[0]
+    assert isinstance(infer_node(instance_attr), set)
+    assert isinstance(infer_node(instance_attr).pop(), nodes.ClassDef)
+
+
+def test_infer_node_4() -> None:
+    """Verify the label for an argument with a typehint of the type
+    nodes.Subscript
+    """
+    node = astroid.extract_node(
+        """
+        class MyClass:
+            def __init__(self, my_int: Optional[int] = None):
+                self.my_test_int = my_int
+    """
+    )
+
+    instance_attr = node.instance_attrs.get("my_test_int")[0]
+    assert isinstance(instance_attr, nodes.AssignAttr)
+
+    inferred = infer_node(instance_attr).pop()
+    assert isinstance(inferred, nodes.Subscript)
+    assert inferred.name == "Optional[int]"
diff --git a/tests/pyreverse/test_writer.py b/tests/pyreverse/test_writer.py
new file mode 100644
index 000000000..9826dfa39
--- /dev/null
+++ b/tests/pyreverse/test_writer.py
@@ -0,0 +1,197 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com>
+# Copyright (c) 2021 Mark Byrne <31762852+mbyrnepr2@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/main/LICENSE
+
+"""
+Unit test for ``DiagramWriter``
+"""
+
+
+import codecs
+import os
+from difflib import unified_diff
+from typing import Callable, Iterator, List
+from unittest.mock import Mock
+
+import pytest
+
+from pylint.pyreverse.diadefslib import DefaultDiadefGenerator, DiadefsHandler
+from pylint.pyreverse.inspector import Linker, Project
+from pylint.pyreverse.writer import DiagramWriter
+from pylint.testutils.pyreverse import PyreverseConfig
+
+_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: str) -> List[str]:
+    # 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]
+
+
+DOT_FILES = ["packages_No_Name.dot", "classes_No_Name.dot"]
+COLORIZED_DOT_FILES = ["packages_colorized.dot", "classes_colorized.dot"]
+VCG_FILES = ["packages_No_Name.vcg", "classes_No_Name.vcg"]
+PUML_FILES = ["packages_No_Name.puml", "classes_No_Name.puml"]
+COLORIZED_PUML_FILES = ["packages_colorized.puml", "classes_colorized.puml"]
+
+
+@pytest.fixture()
+def setup_dot(default_config: PyreverseConfig, get_project: Callable) -> Iterator:
+    writer = DiagramWriter(default_config)
+    project = get_project(os.path.join(os.path.dirname(__file__), "..", "data"))
+    yield from _setup(project, default_config, writer)
+
+
+@pytest.fixture()
+def setup_colorized_dot(
+    colorized_dot_config: PyreverseConfig, get_project: Callable
+) -> Iterator:
+    writer = DiagramWriter(colorized_dot_config)
+    project = get_project(
+        os.path.join(os.path.dirname(__file__), "..", "data"), name="colorized"
+    )
+    yield from _setup(project, colorized_dot_config, writer)
+
+
+@pytest.fixture()
+def setup_vcg(vcg_config: PyreverseConfig, get_project: Callable) -> Iterator:
+    writer = DiagramWriter(vcg_config)
+    project = get_project(os.path.join(os.path.dirname(__file__), "..", "data"))
+    yield from _setup(project, vcg_config, writer)
+
+
+@pytest.fixture()
+def setup_puml(puml_config: PyreverseConfig, get_project: Callable) -> Iterator:
+    writer = DiagramWriter(puml_config)
+    project = get_project(os.path.join(os.path.dirname(__file__), "..", "data"))
+    yield from _setup(project, puml_config, writer)
+
+
+@pytest.fixture()
+def setup_colorized_puml(
+    colorized_puml_config: PyreverseConfig, get_project: Callable
+) -> Iterator:
+    writer = DiagramWriter(colorized_puml_config)
+    project = get_project(
+        os.path.join(os.path.dirname(__file__), "..", "data"), name="colorized"
+    )
+    yield from _setup(project, colorized_puml_config, writer)
+
+
+def _setup(
+    project: Project, config: PyreverseConfig, writer: DiagramWriter
+) -> Iterator:
+    linker = Linker(project)
+    handler = DiadefsHandler(config)
+    dd = DefaultDiadefGenerator(linker, handler).visit(project)
+    for diagram in dd:
+        diagram.extract_relationships()
+    writer.write(dd)
+    yield
+    for fname in (
+        DOT_FILES + COLORIZED_DOT_FILES + VCG_FILES + PUML_FILES + COLORIZED_PUML_FILES
+    ):
+        try:
+            os.remove(fname)
+        except FileNotFoundError:
+            continue
+
+
+@pytest.mark.usefixtures("setup_dot")
+@pytest.mark.parametrize("generated_file", DOT_FILES)
+def test_dot_files(generated_file: str) -> None:
+    _assert_files_are_equal(generated_file)
+
+
+@pytest.mark.usefixtures("setup_colorized_dot")
+@pytest.mark.parametrize("generated_file", COLORIZED_DOT_FILES)
+def test_colorized_dot_files(generated_file: str) -> None:
+    _assert_files_are_equal(generated_file)
+
+
+@pytest.mark.usefixtures("setup_vcg")
+@pytest.mark.parametrize("generated_file", VCG_FILES)
+def test_vcg_files(generated_file: str) -> None:
+    _assert_files_are_equal(generated_file)
+
+
+@pytest.mark.usefixtures("setup_puml")
+@pytest.mark.parametrize("generated_file", PUML_FILES)
+def test_puml_files(generated_file: str) -> None:
+    _assert_files_are_equal(generated_file)
+
+
+@pytest.mark.usefixtures("setup_colorized_puml")
+@pytest.mark.parametrize("generated_file", COLORIZED_PUML_FILES)
+def test_colorized_puml_files(generated_file: str) -> None:
+    _assert_files_are_equal(generated_file)
+
+
+def _assert_files_are_equal(generated_file: str) -> None:
+    expected_file = os.path.join(os.path.dirname(__file__), "data", generated_file)
+    generated = _file_lines(generated_file)
+    expected = _file_lines(expected_file)
+    joined_generated = "\n".join(generated)
+    joined_expected = "\n".join(expected)
+    files = f"\n *** expected : {expected_file}, generated : {generated_file} \n"
+    diff = "\n".join(
+        line
+        for line in unified_diff(
+            joined_expected.splitlines(), joined_generated.splitlines()
+        )
+    )
+    assert joined_expected == joined_generated, f"{files}{diff}"
+
+
+def test_color_for_stdlib_module(default_config: PyreverseConfig) -> None:
+    writer = DiagramWriter(default_config)
+    obj = Mock()
+    obj.node = Mock()
+    obj.node.qname.return_value = "collections"
+    assert writer.get_shape_color(obj) == "grey"
diff --git a/tests/regrtest_data/.pylintrc b/tests/regrtest_data/.pylintrc
new file mode 100644
index 000000000..f5130379c
--- /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 000000000..fdabe9f78
--- /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 000000000..9a60e26ab
--- /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 000000000..8d3eb170b
--- /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 000000000..16c3a1562
--- /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 000000000..2d2d78f98
--- /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 000000000..788cf4510
--- /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 000000000..3b735ff50
--- /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 000000000..2d9df51cd
--- /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 000000000..6d1cd3991
--- /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 000000000..e4c923343
--- /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 000000000..00c913040
--- /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 000000000..4b3adccde
--- /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 000000000..0b43a7096
--- /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 000000000..56a871238
--- /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 000000000..60345dc13
--- /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 000000000..162dedc89
--- /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 000000000..f58387f83
--- /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 000000000..dd0554f7e
--- /dev/null
+++ b/tests/regrtest_data/dummy_plugin/dummy_plugin.py
@@ -0,0 +1,31 @@
+from pylint.checkers import BaseChecker
+from pylint.lint.pylinter import PyLinter
+
+
+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: PyLinter) -> None:
+    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 000000000..e69de29bb
--- /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 000000000..687c5922e
--- /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 000000000..687c5922e
--- /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 000000000..e69de29bb
--- /dev/null
+++ b/tests/regrtest_data/empty.py
diff --git a/tests/regrtest_data/fail_on.py b/tests/regrtest_data/fail_on.py
new file mode 100644
index 000000000..6f22e5013
--- /dev/null
+++ b/tests/regrtest_data/fail_on.py
@@ -0,0 +1,12 @@
+"""
+    Pylint score:  -1.67
+"""
+import nonexistent
+# pylint: disable=broad-except
+
+
+def loop():
+    count = 0
+    for _ in range(5):
+        count += 1
+    print(count)
diff --git a/tests/regrtest_data/fail_on_info_only.py b/tests/regrtest_data/fail_on_info_only.py
new file mode 100644
index 000000000..c6baffed0
--- /dev/null
+++ b/tests/regrtest_data/fail_on_info_only.py
@@ -0,0 +1,11 @@
+"""
+    Pylint score:  -1.67
+"""
+# pylint: disable=broad-except
+
+def loop():
+    """Run a loop."""
+    count = 0
+    for _ in range(5):
+        count += 1
+    print(count)
diff --git a/tests/regrtest_data/fail_under_minus10.py b/tests/regrtest_data/fail_under_minus10.py
new file mode 100644
index 000000000..5ce3785ba
--- /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 000000000..fea27f4ec
--- /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 000000000..8a94ab4f3
--- /dev/null
+++ b/tests/regrtest_data/func_block_disable_msg.py
@@ -0,0 +1,1026 @@
+# pylint: disable=C0302,bare-except, 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 000000000..c01cd52f7
--- /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 000000000..2864e3c9e
--- /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 000000000..3a74a717f
--- /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 000000000..8a4b31cea
--- /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 000000000..700120727
--- /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 000000000..107d65289
--- /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 000000000..d72aa65bb
--- /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 000000000..e89757f19
--- /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 000000000..4ea22a9c6
--- /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 000000000..ef65143c1
--- /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 000000000..10cc40f6c
--- /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 000000000..dc4782e6c
--- /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 000000000..4b7244ba0
--- /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 000000000..4e3696bec
--- /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 000000000..7cf85430a
--- /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 000000000..ff5871d46
--- /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/regression_missing_init_3564/subdirectory/file.py b/tests/regrtest_data/regression_missing_init_3564/subdirectory/file.py
new file mode 100644
index 000000000..e69de29bb
--- /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 000000000..b693a9fcc
--- /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 000000000..cdc7c147d
--- /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 000000000..ef8c40395
--- /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 000000000..1719308fd
--- /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 000000000..eee909d53
--- /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 000000000..8a4b31cea
--- /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 000000000..9e2d099e0
--- /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 000000000..c0fbe00fd
--- /dev/null
+++ b/tests/test_check_parallel.py
@@ -0,0 +1,556 @@
+"""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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Julien Palard <julien@palard.fr>
+# 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/main/LICENSE
+
+# pylint: disable=protected-access,missing-function-docstring,no-self-use
+
+import collections
+import os
+from typing import List
+
+import pytest
+from astroid import nodes
+
+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
+from pylint.typing import CheckerStats, FileItem
+
+
+def _gen_file_data(idx: int = 0) -> FileItem:
+    """Generates a file to use as a stream"""
+    filepath = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "input", "similar1")
+    )
+    file_data = FileItem(
+        f"--test-file_data-name-{idx}--",
+        filepath,
+        f"--test-file_data-modname-{idx}--",
+    )
+    return file_data
+
+
+def _gen_file_datas(count: int = 1) -> List[FileItem]:
+    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: PyLinter) -> None:
+        super().__init__(linter)
+        self.data: List[str] = []
+        self.linter = linter
+
+    def process_module(self, _node: nodes.Module) -> None:
+        """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 ParallelTestChecker(BaseChecker):
+    """A checker that does need to consolidate data.
+
+    To simulate the need to consolidate data, this checker only
+    reports a message for pairs of files.
+
+    On non-parallel builds: it works on all the files in a single run.
+
+    On parallel builds: lint.parallel calls ``open`` once per file.
+
+    So if files are treated by separate processes, no messages will be
+    raised from the individual process, all messages will be raised
+    from reduce_map_data.
+    """
+
+    __implements__ = (pylint.interfaces.IRawChecker,)
+
+    name = "parallel-checker"
+    test_data = "parallel"
+    msgs = {
+        "R9999": (
+            "Test %s",
+            "parallel-test-check",
+            "Some helpful text.",
+        )
+    }
+
+    def __init__(self, linter: PyLinter) -> None:
+        super().__init__(linter)
+        self.data: List[str] = []
+        self.linter = linter
+        self.stats: CheckerStats = {}
+
+    def open(self) -> None:
+        """init the checkers: reset statistics information"""
+        self.stats = self.linter.add_stats()
+        self.data = []
+
+    def close(self) -> None:
+        for _ in self.data[1::2]:  # Work on pairs of files, see class docstring.
+            self.add_message("R9999", args=("From process_module, two files seen.",))
+
+    def get_map_data(self):
+        return self.data
+
+    def reduce_map_data(self, linter: PyLinter, data: List[List[str]]) -> None:
+        recombined = type(self)(linter)
+        recombined.open()
+        aggregated = []
+        for d in data:
+            aggregated.extend(d)
+        for _ in aggregated[1::2]:  # Work on pairs of files, see class docstring.
+            self.add_message("R9999", args=("From reduce_map_data",))
+        recombined.close()
+
+    def process_module(self, _node: nodes.Module) -> None:
+        """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 ExtraParallelTestChecker(ParallelTestChecker):
+    """A checker that does need to consolidate data across run invocations"""
+
+    name = "extra-parallel-checker"
+    test_data = "extra-parallel"
+
+
+class ThirdSequentialTestChecker(SequentialTestChecker):
+    """A checker that does not need to consolidate data across run invocations"""
+
+    name = "third-sequential-checker"
+    test_data = "third-sequential"
+
+
+class ThirdParallelTestChecker(ParallelTestChecker):
+    """A checker that does need to consolidate data across run invocations"""
+
+    name = "third-parallel-checker"
+    test_data = "third-parallel"
+
+
+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) -> None:
+        linter = PyLinter(reporter=Reporter())
+        worker_initialize(linter=linter)
+        assert pylint.lint.parallel._worker_linter == linter
+
+    def test_worker_check_single_file_uninitialised(self) -> None:
+        pylint.lint.parallel._worker_linter = None
+        with pytest.raises(  # Objects that do not match the linter interface will fail
+            Exception, match="Worker linter not yet initialised"
+        ):
+            worker_check_single_file(_gen_file_data())
+
+    def test_worker_check_single_file_no_checkers(self) -> None:
+        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) -> None:
+        """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) -> None:
+        """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=iter(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) -> None:
+        """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=iter(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": {
+                # pylint: disable-next=consider-using-f-string
+                "--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?"
+
+    @pytest.mark.parametrize(
+        "num_files,num_jobs,num_checkers",
+        [
+            (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_map_reduce(self, num_files, num_jobs, num_checkers):
+        """Compares the 3 key parameters for check_parallel() produces the same results
+
+        The intent here is to validate the reduce step: no stats should be lost.
+
+        Checks regression of https://github.com/PyCQA/pylint/issues/4118
+        """
+
+        # define the stats we expect to get back from the runs, these should only vary
+        # with the number of files.
+        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(ParallelTestChecker(linter))
+            if num_checkers > 1:
+                linter.register_checker(ExtraParallelTestChecker(linter))
+            if num_checkers > 2:
+                linter.register_checker(ThirdParallelTestChecker(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)
+                stats_single_proc = linter.stats
+            else:
+                check_parallel(
+                    linter,
+                    jobs=num_jobs,
+                    files=file_infos,
+                    arguments=None,
+                )
+                stats_check_parallel = linter.stats
+        assert (
+            stats_single_proc["by_msg"] == stats_check_parallel["by_msg"]
+        ), "Single-proc and check_parallel() should return the same thing"
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 000000000..7a4b09639
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,127 @@
+# pylint: disable=missing-module-docstring, missing-function-docstring, protected-access
+import os
+import unittest.mock
+from pathlib import PosixPath
+
+import pytest
+
+import pylint.lint
+from pylint.config import OptionsManagerMixIn
+from pylint.lint.run import Run
+
+
+def check_configuration_file_reader(config_file: PosixPath) -> Run:
+    """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: PosixPath) -> None:
+    # 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: PosixPath) -> None:
+    # 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: PosixPath) -> None:
+    # 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: PosixPath) -> None:
+    # 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)
+
+
+def test_can_read_env_variable(tmp_path: PosixPath) -> None:
+    # Check that we can read the "regular" INI .pylintrc file
+    # if it has an environment variable.
+    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"
+"""
+    )
+    os.environ["tmp_path_env"] = str(tmp_path / "pyproject.toml")
+    options_manager_mix_in = OptionsManagerMixIn("", "${tmp_path_env}")
+    options_manager_mix_in.read_config_file("${tmp_path_env}")
+
+    def test_read_config_file() -> None:
+        with pytest.raises(OSError):
+            options_manager_mix_in.read_config_file("${tmp_path_en}")
+
+    test_read_config_file()
+    options_manager_mix_in.load_config_file()
+    section = options_manager_mix_in.cfgfile_parser.sections()[0]
+    jobs, jobs_nr = options_manager_mix_in.cfgfile_parser.items(section)[1]
+    assert jobs == "jobs"
+    assert jobs_nr == "10"
diff --git a/tests/test_epylint.py b/tests/test_epylint.py
new file mode 100644
index 000000000..4f2d2aad0
--- /dev/null
+++ b/tests/test_epylint.py
@@ -0,0 +1,65 @@
+"""Test for issue https://github.com/PyCQA/pylint/issues/4286"""
+# pylint: disable=redefined-outer-name
+from pathlib import PosixPath
+
+import pytest
+
+from pylint import epylint as lint
+
+
+@pytest.fixture()
+def example_path(tmp_path: PosixPath) -> PosixPath:
+    content = """class IvrAudioApp:
+
+    def run(self):
+        self.hassan()
+    """
+    path = tmp_path / "my_app.py"
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(content)
+    return path
+
+
+def test_epylint_good_command(example_path: PosixPath) -> None:
+    out, err = lint.py_run(
+        # pylint: disable-next=consider-using-f-string
+        "%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: PosixPath) -> None:
+    out, err = lint.py_run(
+        # pylint: disable-next=consider-using-f-string
+        "%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 000000000..98bdf184a
--- /dev/null
+++ b/tests/test_func.py
@@ -0,0 +1,179 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""functional/non regression tests for pylint"""
+
+import re
+import sys
+from os.path import abspath, dirname, join
+from typing import List, Optional, Tuple
+
+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) -> str:  # pylint: disable=unused-argument
+    """function used to replace default __str__ method of exception instances
+    This function is not typed because it is legacy code"""
+    return f"in {ex.file}\n:: {', '.join(ex.args)}"
+
+
+class LintTestUsingModule:
+    INPUT_DIR: Optional[str] = None
+    DEFAULT_PACKAGE = "input"
+    package = DEFAULT_PACKAGE
+    linter = linter
+    module: Optional[str] = None
+    depends: Optional[List[Tuple[str, str]]] = None
+    output: Optional[str] = None
+
+    def _test_functionality(self) -> None:
+        if self.module:
+            tocheck = [self.package + "." + self.module]
+        # pylint: disable=not-an-iterable; can't handle boolean checks for now
+        if self.depends:
+            tocheck += [
+                self.package + f".{name.replace('.py', '')}" for name, _ in self.depends
+            ]
+        self._test(tocheck)
+
+    def _check_result(self, got: str) -> None:
+        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: List[str]) -> None:
+        if self.module and INFO_TEST_RGX.match(self.module):
+            self.linter.enable("I")
+        else:
+            self.linter.disable("I")
+        try:
+            self.linter.check(tocheck)
+        except Exception as ex:
+            print(f"Exception: {ex} in {tocheck}:: {'‚ '.join(ex.args)}")
+            ex.file = tocheck  # type: ignore # This is legacy code we're trying to remove, not worth it to type correctly
+            print(ex)
+            ex.__str__ = exception_str  # type: ignore # This is legacy code we're trying to remove, impossible to type correctly
+            raise
+        self._check_result(self.linter.reporter.finalize())
+
+    def _has_output(self) -> bool:
+        return isinstance(self.module, str) and not self.module.startswith(
+            "func_noerror_"
+        )
+
+    def _get_expected(self) -> str:
+        if self._has_output() and self.output:
+            with open(self.output, encoding="utf-8") 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", encoding="utf-8") 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) < 13, "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: str, messages_file: str, dependencies: List[Tuple[str, str]]
+) -> None:
+    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 000000000..513823a05
--- /dev/null
+++ b/tests/test_functional.py
@@ -0,0 +1,139 @@
+# 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 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Functional full-module tests for PyLint."""
+import csv
+import os
+import sys
+from typing import Union
+
+import pytest
+from _pytest.config import Config
+from _pytest.recwarn import WarningsRecorder
+
+from pylint import testutils
+from pylint.testutils import UPDATE_FILE, UPDATE_OPTION
+from pylint.testutils.functional_test_file import FunctionalTestFile
+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", encoding="utf-8") 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: FunctionalTestFile, recwarn: WarningsRecorder, pytestconfig: Config
+) -> None:
+    __tracebackhide__ = True  # pylint: disable=unused-variable
+    if UPDATE_FILE.exists():
+        lint_test: Union[
+            LintModuleOutputUpdate, testutils.LintModuleTest
+        ] = 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 000000000..42e3baf56
--- /dev/null
+++ b/tests/test_import_graph.py
@@ -0,0 +1,113 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.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/main/LICENSE
+# pylint: disable=redefined-outer-name
+
+import os
+import shutil
+from os.path import exists
+from typing import Iterator, Union
+
+import pytest
+from _pytest.fixtures import SubRequest
+
+from pylint import testutils
+from pylint.checkers import imports, initialize
+from pylint.lint import PyLinter
+
+
+@pytest.fixture
+def dest(request: SubRequest) -> Iterator[Union[Iterator, Iterator[str]]]:
+    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: str) -> None:
+    """DOC files are correctly generated, and the graphname is the basename"""
+    imports._dependencies_graph(dest, {"labas": ["hoho", "yep"], "hoho": ["yep"]})
+    with open(dest, encoding="utf-8") 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: str) -> None:
+    """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 = PyLinter(reporter=testutils.GenericTestReporter())
+    initialize(pylinter)
+    return pylinter
+
+
+@pytest.fixture
+def remove_files() -> Iterator:
+    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: PyLinter) -> None:
+    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 000000000..46f154da7
--- /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/main/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 000000000..473f2048b
--- /dev/null
+++ b/tests/test_pragma_parser.py
@@ -0,0 +1,112 @@
+import pytest
+
+from pylint.utils.pragma_parser import (
+    OPTION_PO,
+    InvalidPragmaError,
+    UnRecognizedOptionError,
+    parse_pragma,
+)
+
+
+def test_simple_pragma() -> None:
+    comment = "#pylint: disable = missing-docstring"
+    match = OPTION_PO.search(comment)
+    assert match
+    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() -> None:
+    comment = "#pylint: disable = j3-custom-checker"
+    match = OPTION_PO.search(comment)
+    assert match
+    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() -> None:
+    comment = "#pylint: skip-file"
+    match = OPTION_PO.search(comment)
+    assert match
+    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() -> None:
+    comment = "#pylint: disable = missing-docstring, invalid-name"
+    match = OPTION_PO.search(comment)
+    assert match
+    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() -> None:
+    comment = "#pylint: disable = missing-docstring, invalid-name, enable = R0202, no-self-use"
+    match = OPTION_PO.search(comment)
+    assert match
+    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() -> None:
+    comment = "#pylint: disable missing-docstring"
+    match = OPTION_PO.search(comment)
+    assert match
+    with pytest.raises(InvalidPragmaError):
+        list(parse_pragma(match.group(2)))
+
+
+def test_missing_keyword() -> None:
+    comment = "#pylint: = missing-docstring"
+    match = OPTION_PO.search(comment)
+    assert match
+    with pytest.raises(InvalidPragmaError):
+        list(parse_pragma(match.group(2)))
+
+
+def test_unsupported_assignment() -> None:
+    comment = "#pylint: disable-all = missing-docstring"
+    match = OPTION_PO.search(comment)
+    assert match
+    with pytest.raises(UnRecognizedOptionError):
+        list(parse_pragma(match.group(2)))
+
+
+def test_unknown_keyword_with_messages() -> None:
+    comment = "#pylint: unknown-keyword = missing-docstring"
+    match = OPTION_PO.search(comment)
+    assert match
+    with pytest.raises(UnRecognizedOptionError):
+        list(parse_pragma(match.group(2)))
+
+
+def test_unknown_keyword_without_messages() -> None:
+    comment = "#pylint: unknown-keyword"
+    match = OPTION_PO.search(comment)
+    assert match
+    with pytest.raises(UnRecognizedOptionError):
+        list(parse_pragma(match.group(2)))
+
+
+def test_missing_message() -> None:
+    comment = "#pylint: disable = "
+    match = OPTION_PO.search(comment)
+    assert match
+    with pytest.raises(InvalidPragmaError):
+        list(parse_pragma(match.group(2)))
+
+
+def test_parse_message_with_dash() -> None:
+    comment = "#pylint: disable = raw_input-builtin"
+    match = OPTION_PO.search(comment)
+    assert match
+    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 000000000..84ac05c31
--- /dev/null
+++ b/tests/test_pylint_runners.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-module-docstring, missing-function-docstring
+import os
+import sys
+from typing import Callable
+from unittest.mock import patch
+
+import pytest
+from py._path.local import LocalPath  # type: ignore
+
+from pylint import run_epylint, run_pylint, run_pyreverse, run_symilar
+
+
+@pytest.mark.parametrize(
+    "runner", [run_epylint, run_pylint, run_pyreverse, run_symilar]
+)
+def test_runner(runner: Callable, tmpdir: LocalPath) -> None:
+    filepath = os.path.abspath(__file__)
+    testargs = ["", filepath]
+    with tmpdir.as_cwd():
+        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 000000000..393481a00
--- /dev/null
+++ b/tests/test_regr.py
@@ -0,0 +1,141 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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
+from typing import Iterator
+
+import astroid
+import pytest
+
+from pylint import testutils
+from pylint.lint.pylinter import PyLinter
+
+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: PyLinter) -> Iterator[PyLinter]:
+    """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: str, finalize_linter: PyLinter) -> None:
+    finalize_linter.check([join(REGR_DATA, fname)])
+    finalize_linter.reporter.finalize().strip()
+
+
+@pytest.fixture
+def modify_path() -> Iterator:
+    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: PyLinter) -> None:
+    filename = ["package.__init__"]
+    finalize_linter.check(filename)
+    checked = list(finalize_linter.stats["by_module"].keys())  # type: ignore # Refactor of PyLinter.stats necessary
+    assert checked == filename
+
+    os.chdir(join(REGR_DATA, "package"))
+    finalize_linter.check(["__init__"])
+    checked = list(finalize_linter.stats["by_module"].keys())  # type: ignore
+    assert checked == ["__init__"]
+
+
+def test_pylint_config_attr() -> None:
+    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 000000000..41e7898e8
--- /dev/null
+++ b/tests/test_self.py
@@ -0,0 +1,1242 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Mark Bell <mark00bell@googlemail.com>
+# 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/main/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 TYPE_CHECKING, Any, Generator, Iterator, List, Optional, Union
+from unittest import mock
+from unittest.mock import patch
+
+import pytest
+from _pytest.capture import EncodedFile
+from py._path.local import LocalPath  # type: ignore
+
+from pylint import modify_sys_path
+from pylint.constants import MAIN_CHECKER_NAME, MSG_TYPES_STATUS
+from pylint.lint import Run
+from pylint.lint.pylinter import PyLinter
+from pylint.message import Message
+from pylint.reporters import JSONReporter
+from pylint.reporters.text import BaseReporter, ColorizedTextReporter, TextReporter
+from pylint.utils import utils
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+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: Union[StringIO, EncodedFile]) -> Iterator:
+    sys.stderr = sys.stdout = out
+    try:
+        yield
+    finally:
+        sys.stderr = sys.__stderr__
+        sys.stdout = sys.__stdout__
+
+
+@contextlib.contextmanager
+def _configure_lc_ctype(lc_ctype: str) -> Iterator:
+    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: List[BaseReporter]) -> None:
+        # 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: str, **kwargs: Any) -> None:
+        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: "Section") -> None:
+        pass
+
+    @property
+    def out(self) -> StringIO:
+        return self._reporters[0].out
+
+    @property
+    def linter(self) -> Optional[Any]:
+        return self._linter
+
+    @linter.setter
+    def linter(self, value: PyLinter) -> None:
+        self._linter = value
+        for rep in self._reporters:
+            rep.linter = value
+
+
+class TestRunTC:
+    def _runtest(
+        self,
+        args: List[str],
+        reporter: Any = None,
+        out: Optional[StringIO] = None,
+        code: int = None,
+    ) -> 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: List[str], out: Union[StringIO, EncodedFile], reporter: Any = None
+    ) -> int:
+        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: str) -> str:
+        """Normalize path to the tests directory."""
+        output = re.sub(CLEAN_PATH, "", output, flags=re.MULTILINE)
+        return output.replace("\\", "/")
+
+    def _test_output(self, args: List[str], expected_output: str) -> None:
+        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: List[str], filename: LocalPath, expected_output: str
+    ) -> None:
+        """
+        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) -> None:
+        """Make pylint check itself."""
+        self._runtest(["pylint.__pkginfo__"], reporter=TextReporter(StringIO()), code=0)
+
+    def test_all(self) -> None:
+        """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) -> None:
+        self._runtest([join(HERE, "input", "noext")], code=0)
+
+    def test_w0704_ignored(self) -> None:
+        self._runtest([join(HERE, "input", "ignore_except_pass_by_default.py")], code=0)
+
+    def test_exit_zero(self) -> None:
+        self._runtest(
+            ["--exit-zero", join(HERE, "regrtest_data", "syntax_error.py")], code=0
+        )
+
+    def test_generate_config_option(self) -> None:
+        self._runtest(["--generate-rcfile"], code=0)
+
+    def test_generate_config_option_order(self) -> None:
+        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) -> None:
+        # 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 = fr"\[{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) -> None:
+        out = StringIO()
+        self._run_pylint(["--generate-rcfile"], out=out)
+        output = out.getvalue()
+        assert "profile" not in output
+
+    def test_nonexistent_config_file(self) -> None:
+        self._runtest(["--rcfile=/tmp/this_file_does_not_exist"], code=32)
+
+    def test_help_message_option(self) -> None:
+        self._runtest(["--help-msg", "W0101"], code=0)
+
+    def test_error_help_message_option(self) -> None:
+        self._runtest(["--help-msg", "WX101"], code=0)
+
+    def test_error_missing_arguments(self) -> None:
+        self._runtest([], code=32)
+
+    def test_no_out_encoding(self) -> None:
+        """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) -> None:
+        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_missing_arguments(self) -> None:
+        self._runtest(["-j 2", "not_here", "not_here_too"], code=1)
+
+    def test_abbreviations_are_not_supported(self) -> None:
+        expected = "no such option: --load-plugin"
+        self._test_output([".", "--load-plugin"], expected_output=expected)
+
+    def test_enable_all_works(self) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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, f"--rcfile={config_path}", "-rn"], expected_output=expected
+        )
+
+    def test_pylintrc_plugin_duplicate_options(self) -> None:
+        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(
+            [
+                f"--rcfile={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(
+            [f"--rcfile={config_path}", "--generate-rcfile"], expected_output=expected
+        )
+        sys.path.remove(dummy_plugin_path)
+
+    def test_pylintrc_comments_in_values(self) -> None:
+        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, f"--rcfile={config_path}", "-rn"], expected_output=expected
+        )
+
+    def test_no_crash_with_formatting_regex_defaults(self) -> None:
+        self._runtest(
+            ["--ignore-patterns=a"], reporter=TextReporter(StringIO()), code=32
+        )
+
+    def test_getdefaultencoding_crashes_with_lc_ctype_utf8(self) -> None:
+        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", encoding="utf-8") 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) -> None:
+        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) -> None:
+        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) -> None:
+        def check(lines: List[str]) -> None:
+            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_str = result.decode("utf-8")
+        check(result_str.splitlines())
+
+    def test_fail_under(self) -> None:
+        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: LocalPath) -> None:
+        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: LocalPath,
+    ) -> None:
+        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: LocalPath,
+    ) -> None:
+        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: LocalPath
+    ) -> None:
+        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: LocalPath) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        # 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: LocalPath) -> None:
+        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) -> None:
+        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(
+        "args, expected",
+        [
+            ([], 0),
+            (["--enable=C"], 0),
+            (["--fail-on=superfluous-parens"], 0),
+            (["--fail-on=import-error"], 6),
+            (["--fail-on=unused-import"], 6),
+            (["--fail-on=unused-import", "--enable=C"], 22),
+            (["--fail-on=missing-function-docstring"], 22),
+            (["--fail-on=useless-suppression"], 6),
+            (["--fail-on=useless-suppression", "--enable=C"], 22),
+        ],
+    )
+    def test_fail_on_exit_code(self, args, expected):
+        path = join(HERE, "regrtest_data", "fail_on.py")
+        # We set fail-under to be something very low so that even with the warnings
+        # and errors that are generated they don't affect the exit code.
+        self._runtest([path, "--fail-under=-10"] + args, code=expected)
+
+    @pytest.mark.parametrize(
+        "args, expected",
+        [
+            ([], 0),
+            (["--enable=C"], 0),
+            (["--fail-on=superfluous-parens"], 0),
+            (["--fail-on=import-error"], 0),
+            (["--fail-on=unused-import"], 0),
+            (["--fail-on=unused-import", "--enable=C"], 0),
+            (["--fail-on=missing-function-docstring"], 0),
+            (["--fail-on=useless-suppression"], 1),
+            (["--fail-on=useless-suppression", "--enable=C"], 1),
+        ],
+    )
+    def test_fail_on_info_only_exit_code(self, args, expected):
+        path = join(HERE, "regrtest_data", "fail_on_info_only.py")
+        self._runtest([path] + args, code=expected)
+
+    @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: Unused variable 'variable' (unused-variable)",
+            ),
+            ("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: LocalPath
+    ) -> None:
+        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: LocalPath) -> None:
+        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 000000000..cd8bc7e9b
--- /dev/null
+++ b/tests/testutils/test_output_line.py
@@ -0,0 +1,109 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+# pylint: disable=redefined-outer-name
+
+from typing import Callable, List, Optional
+
+import pytest
+
+from pylint.constants import PY38_PLUS
+from pylint.interfaces import HIGH, INFERENCE, Confidence
+from pylint.message import Message
+from pylint.testutils.output_line import MalformedOutputLineException, OutputLine
+
+
+@pytest.fixture()
+def message() -> Callable:
+    def inner(confidence: Confidence = HIGH) -> Message:
+        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() -> None:
+    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: Callable) -> None:
+    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: Confidence, message: Callable) -> None:
+    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() -> None:
+    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: Optional[str], expected_confidence: Confidence
+) -> None:
+    if confidence:
+        proper_csv: List[str] = [
+            "missing-docstring",
+            "1",
+            "2",
+            "obj",
+            "msg",
+            confidence,
+        ]
+    else:
+        proper_csv = ["missing-docstring", "1", "2", "obj", "msg"]
+    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 000000000..9be02fc4c
--- /dev/null
+++ b/tests/unittest_config.py
@@ -0,0 +1,67 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/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() -> None:
+    result = config.option._regexp_validator(None, None, "test_.*")
+    assert isinstance(result, RE_PATTERN_TYPE)
+    assert result.pattern == "test_.*"
+
+
+def test__regexp_validator_invalid() -> None:
+    with pytest.raises(sre_constants.error):
+        config.option._regexp_validator(None, None, "test_)")
+
+
+def test__csv_validator_no_spaces() -> None:
+    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() -> None:
+    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() -> None:
+    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() -> None:
+    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_reporters_json.py b/tests/unittest_reporters_json.py
new file mode 100644
index 000000000..ed6ed74a4
--- /dev/null
+++ b/tests/unittest_reporters_json.py
@@ -0,0 +1,65 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+"""Test for the JSON reporter."""
+
+import json
+from io import StringIO
+from typing import Any, Dict, List
+
+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() -> None:
+    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: bool) -> List[Dict[str, Any]]:
+    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 000000000..c0fdb61d4
--- /dev/null
+++ b/tests/unittest_reporting.py
@@ -0,0 +1,271 @@
+# 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 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.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/main/LICENSE
+# pylint: disable=redefined-outer-name
+
+import warnings
+from contextlib import redirect_stdout
+from io import StringIO
+from json import dumps
+from typing import TYPE_CHECKING
+
+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
+from pylint.typing import FileItem
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+@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: "Section") -> None:
+        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_item(FileItem("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, encoding="utf-8") 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: "Section") -> None:
+            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 000000000..e69de29bb
--- /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 000000000..9d350830a
--- /dev/null
+++ b/tests/utils/unittest_ast_walker.py
@@ -0,0 +1,68 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+
+import warnings
+from typing import Dict, Set
+
+import astroid
+
+from pylint.checkers.utils import check_messages
+from pylint.utils import ASTWalker
+
+
+class TestASTWalker:
+    class MockLinter:
+        def __init__(self, msgs: Dict[str, bool]) -> None:
+            self._msgs = msgs
+
+        def is_message_enabled(self, msgid: str) -> bool:
+            return self._msgs.get(msgid, True)
+
+    class Checker:
+        def __init__(self) -> None:
+            self.called: Set[str] = 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) -> None:
+        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) -> None:
+        class Checker:
+            def __init__(self) -> None:
+                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 000000000..6514de872
--- /dev/null
+++ b/tests/utils/unittest_utils.py
@@ -0,0 +1,41 @@
+# 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>
+# Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@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/main/LICENSE
+
+import io
+
+from pylint.utils import utils
+
+
+def test_decoding_stream_unknown_encoding() -> None:
+    """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() -> None:
+    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 000000000..0d13fa8ad
--- /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